Merge tag 'v3.1-rc6' into staging/for_v3.2

* tag 'v3.1-rc6': (1902 commits)
  Linux 3.1-rc6
  ioctl: register LTTng ioctl
  fuse: fix memory leak
  fuse: fix flock breakage
  Btrfs: add dummy extent if dst offset excceeds file end in
  Btrfs: calc file extent num_bytes correctly in file clone
  btrfs: xattr: fix attribute removal
  Btrfs: fix wrong nbytes information of the inode
  Btrfs: fix the file extent gap when doing direct IO
  Btrfs: fix unclosed transaction handle in btrfs_cont_expand
  Btrfs: fix misuse of trans block rsv
  Btrfs: reset to appropriate block rsv after orphan operations
  Btrfs: skip locking if searching the commit root in csum lookup
  btrfs: fix warning in iput for bad-inode
  Btrfs: fix an oops when deleting snapshots
  [media] vp7045: fix buffer setup
  [media] nuvoton-cir: simplify raw IR sample handling
  [media] [Resend] viacam: Don't explode if pci_find_bus() returns NULL
  [media] v4l2: Fix documentation of the codec device controls
  [media] gspca - sonixj: Fix the darkness of sensor om6802 in 320x240
  ...

719 files changed, 32221 insertions, 11565 deletions

diff --git a/drivers/acpi/acpica/acglobal.h b/drivers/acpi/acpica/acglobal.h
index 73863d86f022..76dc02f15574 100644
--- a/drivers/acpi/acpica/acglobal.h
+++ b/drivers/acpi/acpica/acglobal.h
@@ -126,6 +126,12 @@ u8 ACPI_INIT_GLOBAL(acpi_gbl_copy_dsdt_locally, FALSE);
  */
 u8 ACPI_INIT_GLOBAL(acpi_gbl_truncate_io_addresses, FALSE);
 
+/*
+ * Disable runtime checking and repair of values returned by control methods.
+ * Use only if the repair is causing a problem on a particular machine.
+ */
+u8 ACPI_INIT_GLOBAL(acpi_gbl_disable_auto_repair, FALSE);
+
 /* acpi_gbl_FADT is a local copy of the FADT, converted to a common format. */
 
 struct acpi_table_fadt acpi_gbl_FADT;
diff --git a/drivers/acpi/acpica/aclocal.h b/drivers/acpi/acpica/aclocal.h
index c7f743ca395b..5552125d8340 100644
--- a/drivers/acpi/acpica/aclocal.h
+++ b/drivers/acpi/acpica/aclocal.h
@@ -357,6 +357,7 @@ struct acpi_predefined_data {
         char *pathname;
         const union acpi_predefined_info *predefined;
         union acpi_operand_object *parent_package;
+        struct acpi_namespace_node *node;
         u32 flags;
         u8 node_flags;
 };
diff --git a/drivers/acpi/acpica/acpredef.h b/drivers/acpi/acpica/acpredef.h
index 94e73c97cf85..c445cca490ea 100644
--- a/drivers/acpi/acpica/acpredef.h
+++ b/drivers/acpi/acpica/acpredef.h
@@ -468,6 +468,7 @@ static const union acpi_predefined_info predefined_names[] =
         {{"_SWS", 0, ACPI_RTYPE_INTEGER}},
         {{"_TC1", 0, ACPI_RTYPE_INTEGER}},
         {{"_TC2", 0, ACPI_RTYPE_INTEGER}},
+        {{"_TDL", 0, ACPI_RTYPE_INTEGER}},
         {{"_TIP", 1, ACPI_RTYPE_INTEGER}},
         {{"_TIV", 1, ACPI_RTYPE_INTEGER}},
         {{"_TMP", 0, ACPI_RTYPE_INTEGER}},
diff --git a/drivers/acpi/acpica/nspredef.c b/drivers/acpi/acpica/nspredef.c
index 9fb03fa8ffde..c845c8089f39 100644
--- a/drivers/acpi/acpica/nspredef.c
+++ b/drivers/acpi/acpica/nspredef.c
@@ -193,14 +193,20 @@ acpi_ns_check_predefined_names(struct acpi_namespace_node *node,
         }
 
         /*
-         * 1) We have a return value, but if one wasn't expected, just exit, this is
-         * not a problem. For example, if the "Implicit Return" feature is
-         * enabled, methods will always return a value.
+         * Return value validation and possible repair.
          *
-         * 2) If the return value can be of any type, then we cannot perform any
-         * validation, exit.
+         * 1) Don't perform return value validation/repair if this feature
+         * has been disabled via a global option.
+         *
+         * 2) We have a return value, but if one wasn't expected, just exit,
+         * this is not a problem. For example, if the "Implicit Return"
+         * feature is enabled, methods will always return a value.
+         *
+         * 3) If the return value can be of any type, then we cannot perform
+         * any validation, just exit.
          */
-        if ((!predefined->info.expected_btypes) ||
+        if (acpi_gbl_disable_auto_repair ||
+            (!predefined->info.expected_btypes) ||
             (predefined->info.expected_btypes == ACPI_RTYPE_ALL)) {
                 goto cleanup;
         }
@@ -212,6 +218,7 @@ acpi_ns_check_predefined_names(struct acpi_namespace_node *node,
                 goto cleanup;
         }
         data->predefined = predefined;
+        data->node = node;
         data->node_flags = node->flags;
         data->pathname = pathname;
 
diff --git a/drivers/acpi/acpica/nsrepair2.c b/drivers/acpi/acpica/nsrepair2.c
index 973883babee1..024c4f263f87 100644
--- a/drivers/acpi/acpica/nsrepair2.c
+++ b/drivers/acpi/acpica/nsrepair2.c
@@ -503,6 +503,21 @@ acpi_ns_repair_TSS(struct acpi_predefined_data *data,
 {
         union acpi_operand_object *return_object = *return_object_ptr;
         acpi_status status;
+        struct acpi_namespace_node *node;
+
+        /*
+         * We can only sort the _TSS return package if there is no _PSS in the
+         * same scope. This is because if _PSS is present, the ACPI specification
+         * dictates that the _TSS Power Dissipation field is to be ignored, and
+         * therefore some BIOSs leave garbage values in the _TSS Power field(s).
+         * In this case, it is best to just return the _TSS package as-is.
+         * (May, 2011)
+         */
+        status =
+            acpi_ns_get_node(data->node, "^_PSS", ACPI_NS_NO_UPSEARCH, &node);
+        if (ACPI_SUCCESS(status)) {
+                return (AE_OK);
+        }
 
         status = acpi_ns_check_sorted_list(data, return_object, 5, 1,
                                            ACPI_SORT_DESCENDING,
diff --git a/drivers/acpi/acpica/tbinstal.c b/drivers/acpi/acpica/tbinstal.c
index 48db0944ce4a..62365f6075dd 100644
--- a/drivers/acpi/acpica/tbinstal.c
+++ b/drivers/acpi/acpica/tbinstal.c
@@ -126,12 +126,29 @@ acpi_tb_add_table(struct acpi_table_desc *table_desc, u32 *table_index)
         }
 
         /*
-         * Originally, we checked the table signature for "SSDT" or "PSDT" here.
-         * Next, we added support for OEMx tables, signature "OEM".
-         * Valid tables were encountered with a null signature, so we've just
-         * given up on validating the signature, since it seems to be a waste
-         * of code. The original code was removed (05/2008).
+         * Validate the incoming table signature.
+         *
+         * 1) Originally, we checked the table signature for "SSDT" or "PSDT".
+         * 2) We added support for OEMx tables, signature "OEM".
+         * 3) Valid tables were encountered with a null signature, so we just
+         *    gave up on validating the signature, (05/2008).
+         * 4) We encountered non-AML tables such as the MADT, which caused
+         *    interpreter errors and kernel faults. So now, we once again allow
+         *    only "SSDT", "OEMx", and now, also a null signature. (05/2011).
          */
+        if ((table_desc->pointer->signature[0] != 0x00) &&
+            (!ACPI_COMPARE_NAME(table_desc->pointer->signature, ACPI_SIG_SSDT))
+            && (ACPI_STRNCMP(table_desc->pointer->signature, "OEM", 3))) {
+                ACPI_ERROR((AE_INFO,
+                            "Table has invalid signature [%4.4s] (0x%8.8X), must be SSDT or OEMx",
+                            acpi_ut_valid_acpi_name(*(u32 *)table_desc->
+                                                    pointer->
+                                                    signature) ? table_desc->
+                            pointer->signature : "????",
+                            *(u32 *)table_desc->pointer->signature));
+
+                return_ACPI_STATUS(AE_BAD_SIGNATURE);
+        }
 
         (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
 
diff --git a/drivers/acpi/apei/Kconfig b/drivers/acpi/apei/Kconfig
index f739a70b1c70..c34aa51af4ee 100644
--- a/drivers/acpi/apei/Kconfig
+++ b/drivers/acpi/apei/Kconfig
@@ -10,9 +10,11 @@ config ACPI_APEI
           error injection.
 
 config ACPI_APEI_GHES
-        tristate "APEI Generic Hardware Error Source"
+        bool "APEI Generic Hardware Error Source"
         depends on ACPI_APEI && X86
         select ACPI_HED
+        select LLIST
+        select GENERIC_ALLOCATOR
         help
           Generic Hardware Error Source provides a way to report
           platform hardware errors (such as that from chipset). It
@@ -30,6 +32,13 @@ config ACPI_APEI_PCIEAER
           PCIe AER errors may be reported via APEI firmware first mode.
           Turn on this option to enable the corresponding support.
 
+config ACPI_APEI_MEMORY_FAILURE
+        bool "APEI memory error recovering support"
+        depends on ACPI_APEI && MEMORY_FAILURE
+        help
+          Memory errors may be reported via APEI firmware first mode.
+          Turn on this option to enable the memory recovering support.
+
 config ACPI_APEI_EINJ
         tristate "APEI Error INJection (EINJ)"
         depends on ACPI_APEI && DEBUG_FS
diff --git a/drivers/acpi/apei/apei-base.c b/drivers/acpi/apei/apei-base.c
index 4a904a4bf05f..8041248fce9b 100644
--- a/drivers/acpi/apei/apei-base.c
+++ b/drivers/acpi/apei/apei-base.c
@@ -157,9 +157,10 @@ EXPORT_SYMBOL_GPL(apei_exec_noop);
  * Interpret the specified action. Go through whole action table,
  * execute all instructions belong to the action.
  */
-int apei_exec_run(struct apei_exec_context *ctx, u8 action)
+int __apei_exec_run(struct apei_exec_context *ctx, u8 action,
+                    bool optional)
 {
-        int rc;
+        int rc = -ENOENT;
         u32 i, ip;
         struct acpi_whea_header *entry;
         apei_exec_ins_func_t run;
@@ -198,9 +199,9 @@ rewind:
                         goto rewind;
         }
 
-        return 0;
+        return !optional && rc < 0 ? rc : 0;
 }
-EXPORT_SYMBOL_GPL(apei_exec_run);
+EXPORT_SYMBOL_GPL(__apei_exec_run);
 
 typedef int (*apei_exec_entry_func_t)(struct apei_exec_context *ctx,
                                       struct acpi_whea_header *entry,
@@ -603,3 +604,29 @@ struct dentry *apei_get_debugfs_dir(void)
         return dapei;
 }
 EXPORT_SYMBOL_GPL(apei_get_debugfs_dir);
+
+int apei_osc_setup(void)
+{
+        static u8 whea_uuid_str[] = "ed855e0c-6c90-47bf-a62a-26de0fc5ad5c";
+        acpi_handle handle;
+        u32 capbuf[3];
+        struct acpi_osc_context context = {
+                .uuid_str       = whea_uuid_str,
+                .rev            = 1,
+                .cap.length     = sizeof(capbuf),
+                .cap.pointer    = capbuf,
+        };
+
+        capbuf[OSC_QUERY_TYPE] = OSC_QUERY_ENABLE;
+        capbuf[OSC_SUPPORT_TYPE] = 0;
+        capbuf[OSC_CONTROL_TYPE] = 0;
+
+        if (ACPI_FAILURE(acpi_get_handle(NULL, "\\_SB", &handle))
+            || ACPI_FAILURE(acpi_run_osc(handle, &context)))
+                return -EIO;
+        else {
+                kfree(context.ret.pointer);
+                return 0;
+        }
+}
+EXPORT_SYMBOL_GPL(apei_osc_setup);
diff --git a/drivers/acpi/apei/apei-internal.h b/drivers/acpi/apei/apei-internal.h
index ef0581f2094d..f57050e7a5e7 100644
--- a/drivers/acpi/apei/apei-internal.h
+++ b/drivers/acpi/apei/apei-internal.h
@@ -50,7 +50,18 @@ static inline u64 apei_exec_ctx_get_output(struct apei_exec_context *ctx)
         return ctx->value;
 }
 
-int apei_exec_run(struct apei_exec_context *ctx, u8 action);
+int __apei_exec_run(struct apei_exec_context *ctx, u8 action, bool optional);
+
+static inline int apei_exec_run(struct apei_exec_context *ctx, u8 action)
+{
+        return __apei_exec_run(ctx, action, 0);
+}
+
+/* It is optional whether the firmware provides the action */
+static inline int apei_exec_run_optional(struct apei_exec_context *ctx, u8 action)
+{
+        return __apei_exec_run(ctx, action, 1);
+}
 
 /* Common instruction implementation */
 
@@ -113,4 +124,6 @@ void apei_estatus_print(const char *pfx,
                         const struct acpi_hest_generic_status *estatus);
 int apei_estatus_check_header(const struct acpi_hest_generic_status *estatus);
 int apei_estatus_check(const struct acpi_hest_generic_status *estatus);
+
+int apei_osc_setup(void);
 #endif
diff --git a/drivers/acpi/apei/einj.c b/drivers/acpi/apei/einj.c
index f74b2ea11f21..589b96c38704 100644
--- a/drivers/acpi/apei/einj.c
+++ b/drivers/acpi/apei/einj.c
@@ -46,7 +46,8 @@
  * Some BIOSes allow parameters to the SET_ERROR_TYPE entries in the
  * EINJ table through an unpublished extension. Use with caution as
  * most will ignore the parameter and make their own choice of address
- * for error injection.
+ * for error injection.  This extension is used only if
+ * param_extension module parameter is specified.
  */
 struct einj_parameter {
         u64 type;
@@ -65,6 +66,9 @@ struct einj_parameter {
         ((struct acpi_whea_header *)((char *)(tab) +                    \
                                     sizeof(struct acpi_table_einj)))
 
+static bool param_extension;
+module_param(param_extension, bool, 0);
+
 static struct acpi_table_einj *einj_tab;
 
 static struct apei_resources einj_resources;
@@ -285,7 +289,7 @@ static int __einj_error_inject(u32 type, u64 param1, u64 param2)
 
         einj_exec_ctx_init(&ctx);
 
-        rc = apei_exec_run(&ctx, ACPI_EINJ_BEGIN_OPERATION);
+        rc = apei_exec_run_optional(&ctx, ACPI_EINJ_BEGIN_OPERATION);
         if (rc)
                 return rc;
         apei_exec_ctx_set_input(&ctx, type);
@@ -323,7 +327,7 @@ static int __einj_error_inject(u32 type, u64 param1, u64 param2)
         rc = __einj_error_trigger(trigger_paddr);
         if (rc)
                 return rc;
-        rc = apei_exec_run(&ctx, ACPI_EINJ_END_OPERATION);
+        rc = apei_exec_run_optional(&ctx, ACPI_EINJ_END_OPERATION);
 
         return rc;
 }
@@ -489,14 +493,6 @@ static int __init einj_init(void)
                                      einj_debug_dir, NULL, &error_type_fops);
         if (!fentry)
                 goto err_cleanup;
-        fentry = debugfs_create_x64("param1", S_IRUSR | S_IWUSR,
-                                    einj_debug_dir, &error_param1);
-        if (!fentry)
-                goto err_cleanup;
-        fentry = debugfs_create_x64("param2", S_IRUSR | S_IWUSR,
-                                    einj_debug_dir, &error_param2);
-        if (!fentry)
-                goto err_cleanup;
         fentry = debugfs_create_file("error_inject", S_IWUSR,
                                      einj_debug_dir, NULL, &error_inject_fops);
         if (!fentry)
@@ -513,12 +509,23 @@ static int __init einj_init(void)
         rc = apei_exec_pre_map_gars(&ctx);
         if (rc)
                 goto err_release;
-        param_paddr = einj_get_parameter_address();
-        if (param_paddr) {
-                einj_param = ioremap(param_paddr, sizeof(*einj_param));
-                rc = -ENOMEM;
-                if (!einj_param)
-                        goto err_unmap;
+        if (param_extension) {
+                param_paddr = einj_get_parameter_address();
+                if (param_paddr) {
+                        einj_param = ioremap(param_paddr, sizeof(*einj_param));
+                        rc = -ENOMEM;
+                        if (!einj_param)
+                                goto err_unmap;
+                        fentry = debugfs_create_x64("param1", S_IRUSR | S_IWUSR,
+                                                    einj_debug_dir, &error_param1);
+                        if (!fentry)
+                                goto err_unmap;
+                        fentry = debugfs_create_x64("param2", S_IRUSR | S_IWUSR,
+                                                    einj_debug_dir, &error_param2);
+                        if (!fentry)
+                                goto err_unmap;
+                } else
+                        pr_warn(EINJ_PFX "Parameter extension is not supported.\n");
         }
 
         pr_info(EINJ_PFX "Error INJection is initialized.\n");
@@ -526,6 +533,8 @@ static int __init einj_init(void)
         return 0;
 
 err_unmap:
+        if (einj_param)
+                iounmap(einj_param);
         apei_exec_post_unmap_gars(&ctx);
 err_release:
         apei_resources_release(&einj_resources);
diff --git a/drivers/acpi/apei/erst-dbg.c b/drivers/acpi/apei/erst-dbg.c
index a4cfb64c86a1..903549df809b 100644
--- a/drivers/acpi/apei/erst-dbg.c
+++ b/drivers/acpi/apei/erst-dbg.c
@@ -33,7 +33,7 @@
 
 #define ERST_DBG_PFX                    "ERST DBG: "
 
-#define ERST_DBG_RECORD_LEN_MAX         4096
+#define ERST_DBG_RECORD_LEN_MAX         0x4000
 
 static void *erst_dbg_buf;
 static unsigned int erst_dbg_buf_len;
@@ -213,6 +213,10 @@ static struct miscdevice erst_dbg_dev = {
 
 static __init int erst_dbg_init(void)
 {
+        if (erst_disable) {
+                pr_info(ERST_DBG_PFX "ERST support is disabled.\n");
+                return -ENODEV;
+        }
         return misc_register(&erst_dbg_dev);
 }
 
diff --git a/drivers/acpi/apei/erst.c b/drivers/acpi/apei/erst.c
index e6cef8e1b534..2ca59dc69f7f 100644
--- a/drivers/acpi/apei/erst.c
+++ b/drivers/acpi/apei/erst.c
@@ -642,7 +642,7 @@ static int __erst_write_to_storage(u64 offset)
         int rc;
 
         erst_exec_ctx_init(&ctx);
-        rc = apei_exec_run(&ctx, ACPI_ERST_BEGIN_WRITE);
+        rc = apei_exec_run_optional(&ctx, ACPI_ERST_BEGIN_WRITE);
         if (rc)
                 return rc;
         apei_exec_ctx_set_input(&ctx, offset);
@@ -666,7 +666,7 @@ static int __erst_write_to_storage(u64 offset)
         if (rc)
                 return rc;
         val = apei_exec_ctx_get_output(&ctx);
-        rc = apei_exec_run(&ctx, ACPI_ERST_END);
+        rc = apei_exec_run_optional(&ctx, ACPI_ERST_END);
         if (rc)
                 return rc;
 
@@ -681,7 +681,7 @@ static int __erst_read_from_storage(u64 record_id, u64 offset)
         int rc;
 
         erst_exec_ctx_init(&ctx);
-        rc = apei_exec_run(&ctx, ACPI_ERST_BEGIN_READ);
+        rc = apei_exec_run_optional(&ctx, ACPI_ERST_BEGIN_READ);
         if (rc)
                 return rc;
         apei_exec_ctx_set_input(&ctx, offset);
@@ -709,7 +709,7 @@ static int __erst_read_from_storage(u64 record_id, u64 offset)
         if (rc)
                 return rc;
         val = apei_exec_ctx_get_output(&ctx);
-        rc = apei_exec_run(&ctx, ACPI_ERST_END);
+        rc = apei_exec_run_optional(&ctx, ACPI_ERST_END);
         if (rc)
                 return rc;
 
@@ -724,7 +724,7 @@ static int __erst_clear_from_storage(u64 record_id)
         int rc;
 
         erst_exec_ctx_init(&ctx);
-        rc = apei_exec_run(&ctx, ACPI_ERST_BEGIN_CLEAR);
+        rc = apei_exec_run_optional(&ctx, ACPI_ERST_BEGIN_CLEAR);
         if (rc)
                 return rc;
         apei_exec_ctx_set_input(&ctx, record_id);
@@ -748,7 +748,7 @@ static int __erst_clear_from_storage(u64 record_id)
         if (rc)
                 return rc;
         val = apei_exec_ctx_get_output(&ctx);
-        rc = apei_exec_run(&ctx, ACPI_ERST_END);
+        rc = apei_exec_run_optional(&ctx, ACPI_ERST_END);
         if (rc)
                 return rc;
 
@@ -932,8 +932,11 @@ static int erst_check_table(struct acpi_table_erst *erst_tab)
 static int erst_open_pstore(struct pstore_info *psi);
 static int erst_close_pstore(struct pstore_info *psi);
 static ssize_t erst_reader(u64 *id, enum pstore_type_id *type,
-                       struct timespec *time);
-static u64 erst_writer(enum pstore_type_id type, size_t size);
+                           struct timespec *time, struct pstore_info *psi);
+static u64 erst_writer(enum pstore_type_id type, unsigned int part,
+                       size_t size, struct pstore_info *psi);
+static int erst_clearer(enum pstore_type_id type, u64 id,
+                        struct pstore_info *psi);
 
 static struct pstore_info erst_info = {
         .owner          = THIS_MODULE,
@@ -942,7 +945,7 @@ static struct pstore_info erst_info = {
         .close          = erst_close_pstore,
         .read           = erst_reader,
         .write          = erst_writer,
-        .erase          = erst_clear
+        .erase          = erst_clearer
 };
 
 #define CPER_CREATOR_PSTORE                                             \
@@ -983,7 +986,7 @@ static int erst_close_pstore(struct pstore_info *psi)
 }
 
 static ssize_t erst_reader(u64 *id, enum pstore_type_id *type,
-                       struct timespec *time)
+                           struct timespec *time, struct pstore_info *psi)
 {
         int rc;
         ssize_t len = 0;
@@ -1037,7 +1040,8 @@ out:
         return (rc < 0) ? rc : (len - sizeof(*rcd));
 }
 
-static u64 erst_writer(enum pstore_type_id type, size_t size)
+static u64 erst_writer(enum pstore_type_id type, unsigned int part,
+                       size_t size, struct pstore_info *psi)
 {
         struct cper_pstore_record *rcd = (struct cper_pstore_record *)
                                         (erst_info.buf - sizeof(*rcd));
@@ -1080,6 +1084,12 @@ static u64 erst_writer(enum pstore_type_id type, size_t size)
         return rcd->hdr.record_id;
 }
 
+static int erst_clearer(enum pstore_type_id type, u64 id,
+                        struct pstore_info *psi)
+{
+        return erst_clear(id);
+}
+
 static int __init erst_init(void)
 {
         int rc = 0;
diff --git a/drivers/acpi/apei/ghes.c b/drivers/acpi/apei/ghes.c
index f703b2881153..0784f99a4665 100644
--- a/drivers/acpi/apei/ghes.c
+++ b/drivers/acpi/apei/ghes.c
@@ -12,7 +12,7 @@
  * For more information about Generic Hardware Error Source, please
  * refer to ACPI Specification version 4.0, section 17.3.2.6
  *
- * Copyright 2010 Intel Corp.
+ * Copyright 2010,2011 Intel Corp.
  *   Author: Huang Ying <ying.huang@intel.com>
  *
  * This program is free software; you can redistribute it and/or
@@ -42,6 +42,9 @@
 #include <linux/mutex.h>
 #include <linux/ratelimit.h>
 #include <linux/vmalloc.h>
+#include <linux/irq_work.h>
+#include <linux/llist.h>
+#include <linux/genalloc.h>
 #include <acpi/apei.h>
 #include <acpi/atomicio.h>
 #include <acpi/hed.h>
@@ -53,6 +56,30 @@
 #define GHES_PFX        "GHES: "
 
 #define GHES_ESTATUS_MAX_SIZE           65536
+#define GHES_ESOURCE_PREALLOC_MAX_SIZE  65536
+
+#define GHES_ESTATUS_POOL_MIN_ALLOC_ORDER 3
+
+/* This is just an estimation for memory pool allocation */
+#define GHES_ESTATUS_CACHE_AVG_SIZE     512
+
+#define GHES_ESTATUS_CACHES_SIZE        4
+
+#define GHES_ESTATUS_IN_CACHE_MAX_NSEC  10000000000ULL
+/* Prevent too many caches are allocated because of RCU */
+#define GHES_ESTATUS_CACHE_ALLOCED_MAX  (GHES_ESTATUS_CACHES_SIZE * 3 / 2)
+
+#define GHES_ESTATUS_CACHE_LEN(estatus_len)                     \
+        (sizeof(struct ghes_estatus_cache) + (estatus_len))
+#define GHES_ESTATUS_FROM_CACHE(estatus_cache)                  \
+        ((struct acpi_hest_generic_status *)                    \
+         ((struct ghes_estatus_cache *)(estatus_cache) + 1))
+
+#define GHES_ESTATUS_NODE_LEN(estatus_len)                      \
+        (sizeof(struct ghes_estatus_node) + (estatus_len))
+#define GHES_ESTATUS_FROM_NODE(estatus_node)                            \
+        ((struct acpi_hest_generic_status *)                            \
+         ((struct ghes_estatus_node *)(estatus_node) + 1))
 
 /*
  * One struct ghes is created for each generic hardware error source.
@@ -77,6 +104,22 @@ struct ghes {
         };
 };
 
+struct ghes_estatus_node {
+        struct llist_node llnode;
+        struct acpi_hest_generic *generic;
+};
+
+struct ghes_estatus_cache {
+        u32 estatus_len;
+        atomic_t count;
+        struct acpi_hest_generic *generic;
+        unsigned long long time_in;
+        struct rcu_head rcu;
+};
+
+int ghes_disable;
+module_param_named(disable, ghes_disable, bool, 0);
+
 static int ghes_panic_timeout   __read_mostly = 30;
 
 /*
@@ -121,6 +164,22 @@ static struct vm_struct *ghes_ioremap_area;
 static DEFINE_RAW_SPINLOCK(ghes_ioremap_lock_nmi);
 static DEFINE_SPINLOCK(ghes_ioremap_lock_irq);
 
+/*
+ * printk is not safe in NMI context.  So in NMI handler, we allocate
+ * required memory from lock-less memory allocator
+ * (ghes_estatus_pool), save estatus into it, put them into lock-less
+ * list (ghes_estatus_llist), then delay printk into IRQ context via
+ * irq_work (ghes_proc_irq_work).  ghes_estatus_size_request record
+ * required pool size by all NMI error source.
+ */
+static struct gen_pool *ghes_estatus_pool;
+static unsigned long ghes_estatus_pool_size_request;
+static struct llist_head ghes_estatus_llist;
+static struct irq_work ghes_proc_irq_work;
+
+struct ghes_estatus_cache *ghes_estatus_caches[GHES_ESTATUS_CACHES_SIZE];
+static atomic_t ghes_estatus_cache_alloced;
+
 static int ghes_ioremap_init(void)
 {
         ghes_ioremap_area = __get_vm_area(PAGE_SIZE * GHES_IOREMAP_PAGES,
@@ -180,6 +239,55 @@ static void ghes_iounmap_irq(void __iomem *vaddr_ptr)
         __flush_tlb_one(vaddr);
 }
 
+static int ghes_estatus_pool_init(void)
+{
+        ghes_estatus_pool = gen_pool_create(GHES_ESTATUS_POOL_MIN_ALLOC_ORDER, -1);
+        if (!ghes_estatus_pool)
+                return -ENOMEM;
+        return 0;
+}
+
+static void ghes_estatus_pool_free_chunk_page(struct gen_pool *pool,
+                                              struct gen_pool_chunk *chunk,
+                                              void *data)
+{
+        free_page(chunk->start_addr);
+}
+
+static void ghes_estatus_pool_exit(void)
+{
+        gen_pool_for_each_chunk(ghes_estatus_pool,
+                                ghes_estatus_pool_free_chunk_page, NULL);
+        gen_pool_destroy(ghes_estatus_pool);
+}
+
+static int ghes_estatus_pool_expand(unsigned long len)
+{
+        unsigned long i, pages, size, addr;
+        int ret;
+
+        ghes_estatus_pool_size_request += PAGE_ALIGN(len);
+        size = gen_pool_size(ghes_estatus_pool);
+        if (size >= ghes_estatus_pool_size_request)
+                return 0;
+        pages = (ghes_estatus_pool_size_request - size) / PAGE_SIZE;
+        for (i = 0; i < pages; i++) {
+                addr = __get_free_page(GFP_KERNEL);
+                if (!addr)
+                        return -ENOMEM;
+                ret = gen_pool_add(ghes_estatus_pool, addr, PAGE_SIZE, -1);
+                if (ret)
+                        return ret;
+        }
+
+        return 0;
+}
+
+static void ghes_estatus_pool_shrink(unsigned long len)
+{
+        ghes_estatus_pool_size_request -= PAGE_ALIGN(len);
+}
+
 static struct ghes *ghes_new(struct acpi_hest_generic *generic)
 {
         struct ghes *ghes;
@@ -341,43 +449,196 @@ static void ghes_clear_estatus(struct ghes *ghes)
         ghes->flags &= ~GHES_TO_CLEAR;
 }
 
-static void ghes_do_proc(struct ghes *ghes)
+static void ghes_do_proc(const struct acpi_hest_generic_status *estatus)
 {
-        int sev, processed = 0;
+        int sev, sec_sev;
         struct acpi_hest_generic_data *gdata;
 
-        sev = ghes_severity(ghes->estatus->error_severity);
-        apei_estatus_for_each_section(ghes->estatus, gdata) {
-#ifdef CONFIG_X86_MCE
+        sev = ghes_severity(estatus->error_severity);
+        apei_estatus_for_each_section(estatus, gdata) {
+                sec_sev = ghes_severity(gdata->error_severity);
                 if (!uuid_le_cmp(*(uuid_le *)gdata->section_type,
                                  CPER_SEC_PLATFORM_MEM)) {
-                        apei_mce_report_mem_error(
-                                sev == GHES_SEV_CORRECTED,
-                                (struct cper_sec_mem_err *)(gdata+1));
-                        processed = 1;
-                }
+                        struct cper_sec_mem_err *mem_err;
+                        mem_err = (struct cper_sec_mem_err *)(gdata+1);
+#ifdef CONFIG_X86_MCE
+                        apei_mce_report_mem_error(sev == GHES_SEV_CORRECTED,
+                                                  mem_err);
 #endif
+#ifdef CONFIG_ACPI_APEI_MEMORY_FAILURE
+                        if (sev == GHES_SEV_RECOVERABLE &&
+                            sec_sev == GHES_SEV_RECOVERABLE &&
+                            mem_err->validation_bits & CPER_MEM_VALID_PHYSICAL_ADDRESS) {
+                                unsigned long pfn;
+                                pfn = mem_err->physical_addr >> PAGE_SHIFT;
+                                memory_failure_queue(pfn, 0, 0);
+                        }
+#endif
+                }
         }
 }
 
-static void ghes_print_estatus(const char *pfx, struct ghes *ghes)
+static void __ghes_print_estatus(const char *pfx,
+                                 const struct acpi_hest_generic *generic,
+                                 const struct acpi_hest_generic_status *estatus)
 {
-        /* Not more than 2 messages every 5 seconds */
-        static DEFINE_RATELIMIT_STATE(ratelimit, 5*HZ, 2);
-
         if (pfx == NULL) {
-                if (ghes_severity(ghes->estatus->error_severity) <=
+                if (ghes_severity(estatus->error_severity) <=
                     GHES_SEV_CORRECTED)
                         pfx = KERN_WARNING HW_ERR;
                 else
                         pfx = KERN_ERR HW_ERR;
         }
-        if (__ratelimit(&ratelimit)) {
-                printk(
-        "%s""Hardware error from APEI Generic Hardware Error Source: %d\n",
-        pfx, ghes->generic->header.source_id);
-                apei_estatus_print(pfx, ghes->estatus);
+        printk("%s""Hardware error from APEI Generic Hardware Error Source: %d\n",
+               pfx, generic->header.source_id);
+        apei_estatus_print(pfx, estatus);
+}
+
+static int ghes_print_estatus(const char *pfx,
+                              const struct acpi_hest_generic *generic,
+                              const struct acpi_hest_generic_status *estatus)
+{
+        /* Not more than 2 messages every 5 seconds */
+        static DEFINE_RATELIMIT_STATE(ratelimit_corrected, 5*HZ, 2);
+        static DEFINE_RATELIMIT_STATE(ratelimit_uncorrected, 5*HZ, 2);
+        struct ratelimit_state *ratelimit;
+
+        if (ghes_severity(estatus->error_severity) <= GHES_SEV_CORRECTED)
+                ratelimit = &ratelimit_corrected;
+        else
+                ratelimit = &ratelimit_uncorrected;
+        if (__ratelimit(ratelimit)) {
+                __ghes_print_estatus(pfx, generic, estatus);
+                return 1;
         }
+        return 0;
+}
+
+/*
+ * GHES error status reporting throttle, to report more kinds of
+ * errors, instead of just most frequently occurred errors.
+ */
+static int ghes_estatus_cached(struct acpi_hest_generic_status *estatus)
+{
+        u32 len;
+        int i, cached = 0;
+        unsigned long long now;
+        struct ghes_estatus_cache *cache;
+        struct acpi_hest_generic_status *cache_estatus;
+
+        len = apei_estatus_len(estatus);
+        rcu_read_lock();
+        for (i = 0; i < GHES_ESTATUS_CACHES_SIZE; i++) {
+                cache = rcu_dereference(ghes_estatus_caches[i]);
+                if (cache == NULL)
+                        continue;
+                if (len != cache->estatus_len)
+                        continue;
+                cache_estatus = GHES_ESTATUS_FROM_CACHE(cache);
+                if (memcmp(estatus, cache_estatus, len))
+                        continue;
+                atomic_inc(&cache->count);
+                now = sched_clock();
+                if (now - cache->time_in < GHES_ESTATUS_IN_CACHE_MAX_NSEC)
+                        cached = 1;
+                break;
+        }
+        rcu_read_unlock();
+        return cached;
+}
+
+static struct ghes_estatus_cache *ghes_estatus_cache_alloc(
+        struct acpi_hest_generic *generic,
+        struct acpi_hest_generic_status *estatus)
+{
+        int alloced;
+        u32 len, cache_len;
+        struct ghes_estatus_cache *cache;
+        struct acpi_hest_generic_status *cache_estatus;
+
+        alloced = atomic_add_return(1, &ghes_estatus_cache_alloced);
+        if (alloced > GHES_ESTATUS_CACHE_ALLOCED_MAX) {
+                atomic_dec(&ghes_estatus_cache_alloced);
+                return NULL;
+        }
+        len = apei_estatus_len(estatus);
+        cache_len = GHES_ESTATUS_CACHE_LEN(len);
+        cache = (void *)gen_pool_alloc(ghes_estatus_pool, cache_len);
+        if (!cache) {
+                atomic_dec(&ghes_estatus_cache_alloced);
+                return NULL;
+        }
+        cache_estatus = GHES_ESTATUS_FROM_CACHE(cache);
+        memcpy(cache_estatus, estatus, len);
+        cache->estatus_len = len;
+        atomic_set(&cache->count, 0);
+        cache->generic = generic;
+        cache->time_in = sched_clock();
+        return cache;
+}
+
+static void ghes_estatus_cache_free(struct ghes_estatus_cache *cache)
+{
+        u32 len;
+
+        len = apei_estatus_len(GHES_ESTATUS_FROM_CACHE(cache));
+        len = GHES_ESTATUS_CACHE_LEN(len);
+        gen_pool_free(ghes_estatus_pool, (unsigned long)cache, len);
+        atomic_dec(&ghes_estatus_cache_alloced);
+}
+
+static void ghes_estatus_cache_rcu_free(struct rcu_head *head)
+{
+        struct ghes_estatus_cache *cache;
+
+        cache = container_of(head, struct ghes_estatus_cache, rcu);
+        ghes_estatus_cache_free(cache);
+}
+
+static void ghes_estatus_cache_add(
+        struct acpi_hest_generic *generic,
+        struct acpi_hest_generic_status *estatus)
+{
+        int i, slot = -1, count;
+        unsigned long long now, duration, period, max_period = 0;
+        struct ghes_estatus_cache *cache, *slot_cache = NULL, *new_cache;
+
+        new_cache = ghes_estatus_cache_alloc(generic, estatus);
+        if (new_cache == NULL)
+                return;
+        rcu_read_lock();
+        now = sched_clock();
+        for (i = 0; i < GHES_ESTATUS_CACHES_SIZE; i++) {
+                cache = rcu_dereference(ghes_estatus_caches[i]);
+                if (cache == NULL) {
+                        slot = i;
+                        slot_cache = NULL;
+                        break;
+                }
+                duration = now - cache->time_in;
+                if (duration >= GHES_ESTATUS_IN_CACHE_MAX_NSEC) {
+                        slot = i;
+                        slot_cache = cache;
+                        break;
+                }
+                count = atomic_read(&cache->count);
+                period = duration;
+                do_div(period, (count + 1));
+                if (period > max_period) {
+                        max_period = period;
+                        slot = i;
+                        slot_cache = cache;
+                }
+        }
+        /* new_cache must be put into array after its contents are written */
+        smp_wmb();
+        if (slot != -1 && cmpxchg(ghes_estatus_caches + slot,
+                                  slot_cache, new_cache) == slot_cache) {
+                if (slot_cache)
+                        call_rcu(&slot_cache->rcu, ghes_estatus_cache_rcu_free);
+        } else
+                ghes_estatus_cache_free(new_cache);
+        rcu_read_unlock();
 }
 
 static int ghes_proc(struct ghes *ghes)
@@ -387,9 +648,11 @@ static int ghes_proc(struct ghes *ghes)
         rc = ghes_read_estatus(ghes, 0);
         if (rc)
                 goto out;
-        ghes_print_estatus(NULL, ghes);
-        ghes_do_proc(ghes);
-
+        if (!ghes_estatus_cached(ghes->estatus)) {
+                if (ghes_print_estatus(NULL, ghes->generic, ghes->estatus))
+                        ghes_estatus_cache_add(ghes->generic, ghes->estatus);
+        }
+        ghes_do_proc(ghes->estatus);
 out:
         ghes_clear_estatus(ghes);
         return 0;
@@ -447,6 +710,45 @@ static int ghes_notify_sci(struct notifier_block *this,
         return ret;
 }
 
+static void ghes_proc_in_irq(struct irq_work *irq_work)
+{
+        struct llist_node *llnode, *next, *tail = NULL;
+        struct ghes_estatus_node *estatus_node;
+        struct acpi_hest_generic *generic;
+        struct acpi_hest_generic_status *estatus;
+        u32 len, node_len;
+
+        /*
+         * Because the time order of estatus in list is reversed,
+         * revert it back to proper order.
+         */
+        llnode = llist_del_all(&ghes_estatus_llist);
+        while (llnode) {
+                next = llnode->next;
+                llnode->next = tail;
+                tail = llnode;
+                llnode = next;
+        }
+        llnode = tail;
+        while (llnode) {
+                next = llnode->next;
+                estatus_node = llist_entry(llnode, struct ghes_estatus_node,
+                                           llnode);
+                estatus = GHES_ESTATUS_FROM_NODE(estatus_node);
+                len = apei_estatus_len(estatus);
+                node_len = GHES_ESTATUS_NODE_LEN(len);
+                ghes_do_proc(estatus);
+                if (!ghes_estatus_cached(estatus)) {
+                        generic = estatus_node->generic;
+                        if (ghes_print_estatus(NULL, generic, estatus))
+                                ghes_estatus_cache_add(generic, estatus);
+                }
+                gen_pool_free(ghes_estatus_pool, (unsigned long)estatus_node,
+                              node_len);
+                llnode = next;
+        }
+}
+
 static int ghes_notify_nmi(struct notifier_block *this,
                                   unsigned long cmd, void *data)
 {
@@ -476,7 +778,8 @@ static int ghes_notify_nmi(struct notifier_block *this,
 
         if (sev_global >= GHES_SEV_PANIC) {
                 oops_begin();
-                ghes_print_estatus(KERN_EMERG HW_ERR, ghes_global);
+                __ghes_print_estatus(KERN_EMERG HW_ERR, ghes_global->generic,
+                                     ghes_global->estatus);
                 /* reboot to log the error! */
                 if (panic_timeout == 0)
                         panic_timeout = ghes_panic_timeout;
@@ -484,12 +787,34 @@ static int ghes_notify_nmi(struct notifier_block *this,
         }
 
         list_for_each_entry_rcu(ghes, &ghes_nmi, list) {
+#ifdef CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG
+                u32 len, node_len;
+                struct ghes_estatus_node *estatus_node;
+                struct acpi_hest_generic_status *estatus;
+#endif
                 if (!(ghes->flags & GHES_TO_CLEAR))
                         continue;
-                /* Do not print estatus because printk is not NMI safe */
-                ghes_do_proc(ghes);
+#ifdef CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG
+                if (ghes_estatus_cached(ghes->estatus))
+                        goto next;
+                /* Save estatus for further processing in IRQ context */
+                len = apei_estatus_len(ghes->estatus);
+                node_len = GHES_ESTATUS_NODE_LEN(len);
+                estatus_node = (void *)gen_pool_alloc(ghes_estatus_pool,
+                                                      node_len);
+                if (estatus_node) {
+                        estatus_node->generic = ghes->generic;
+                        estatus = GHES_ESTATUS_FROM_NODE(estatus_node);
+                        memcpy(estatus, ghes->estatus, len);
+                        llist_add(&estatus_node->llnode, &ghes_estatus_llist);
+                }
+next:
+#endif
                 ghes_clear_estatus(ghes);
         }
+#ifdef CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG
+        irq_work_queue(&ghes_proc_irq_work);
+#endif
 
 out:
         raw_spin_unlock(&ghes_nmi_lock);
@@ -504,10 +829,26 @@ static struct notifier_block ghes_notifier_nmi = {
         .notifier_call = ghes_notify_nmi,
 };
 
+static unsigned long ghes_esource_prealloc_size(
+        const struct acpi_hest_generic *generic)
+{
+        unsigned long block_length, prealloc_records, prealloc_size;
+
+        block_length = min_t(unsigned long, generic->error_block_length,
+                             GHES_ESTATUS_MAX_SIZE);
+        prealloc_records = max_t(unsigned long,
+                                 generic->records_to_preallocate, 1);
+        prealloc_size = min_t(unsigned long, block_length * prealloc_records,
+                              GHES_ESOURCE_PREALLOC_MAX_SIZE);
+
+        return prealloc_size;
+}
+
 static int __devinit ghes_probe(struct platform_device *ghes_dev)
 {
         struct acpi_hest_generic *generic;
         struct ghes *ghes = NULL;
+        unsigned long len;
         int rc = -EINVAL;
 
         generic = *(struct acpi_hest_generic **)ghes_dev->dev.platform_data;
@@ -573,6 +914,8 @@ static int __devinit ghes_probe(struct platform_device *ghes_dev)
                 mutex_unlock(&ghes_list_mutex);
                 break;
         case ACPI_HEST_NOTIFY_NMI:
+                len = ghes_esource_prealloc_size(generic);
+                ghes_estatus_pool_expand(len);
                 mutex_lock(&ghes_list_mutex);
                 if (list_empty(&ghes_nmi))
                         register_die_notifier(&ghes_notifier_nmi);
@@ -597,6 +940,7 @@ static int __devexit ghes_remove(struct platform_device *ghes_dev)
 {
         struct ghes *ghes;
         struct acpi_hest_generic *generic;
+        unsigned long len;
 
         ghes = platform_get_drvdata(ghes_dev);
         generic = ghes->generic;
@@ -627,6 +971,8 @@ static int __devexit ghes_remove(struct platform_device *ghes_dev)
                  * freed after NMI handler finishes.
                  */
                 synchronize_rcu();
+                len = ghes_esource_prealloc_size(generic);
+                ghes_estatus_pool_shrink(len);
                 break;
         default:
                 BUG();
@@ -662,15 +1008,43 @@ static int __init ghes_init(void)
                 return -EINVAL;
         }
 
+        if (ghes_disable) {
+                pr_info(GHES_PFX "GHES is not enabled!\n");
+                return -EINVAL;
+        }
+
+        init_irq_work(&ghes_proc_irq_work, ghes_proc_in_irq);
+
         rc = ghes_ioremap_init();
         if (rc)
                 goto err;
 
-        rc = platform_driver_register(&ghes_platform_driver);
+        rc = ghes_estatus_pool_init();
         if (rc)
                 goto err_ioremap_exit;
 
+        rc = ghes_estatus_pool_expand(GHES_ESTATUS_CACHE_AVG_SIZE *
+                                      GHES_ESTATUS_CACHE_ALLOCED_MAX);
+        if (rc)
+                goto err_pool_exit;
+
+        rc = platform_driver_register(&ghes_platform_driver);
+        if (rc)
+                goto err_pool_exit;
+
+        rc = apei_osc_setup();
+        if (rc == 0 && osc_sb_apei_support_acked)
+                pr_info(GHES_PFX "APEI firmware first mode is enabled by APEI bit and WHEA _OSC.\n");
+        else if (rc == 0 && !osc_sb_apei_support_acked)
+                pr_info(GHES_PFX "APEI firmware first mode is enabled by WHEA _OSC.\n");
+        else if (rc && osc_sb_apei_support_acked)
+                pr_info(GHES_PFX "APEI firmware first mode is enabled by APEI bit.\n");
+        else
+                pr_info(GHES_PFX "Failed to enable APEI firmware first mode.\n");
+
         return 0;
+err_pool_exit:
+        ghes_estatus_pool_exit();
 err_ioremap_exit:
         ghes_ioremap_exit();
 err:
@@ -680,6 +1054,7 @@ err:
 static void __exit ghes_exit(void)
 {
         platform_driver_unregister(&ghes_platform_driver);
+        ghes_estatus_pool_exit();
         ghes_ioremap_exit();
 }
 
diff --git a/drivers/acpi/apei/hest.c b/drivers/acpi/apei/hest.c
index 181bc2f7bb74..05fee06f4d6e 100644
--- a/drivers/acpi/apei/hest.c
+++ b/drivers/acpi/apei/hest.c
@@ -231,16 +231,17 @@ void __init acpi_hest_init(void)
                 goto err;
         }
 
-        rc = apei_hest_parse(hest_parse_ghes_count, &ghes_count);
-        if (rc)
-                goto err;
-
-        rc = hest_ghes_dev_register(ghes_count);
-        if (!rc) {
-                pr_info(HEST_PFX "Table parsing has been initialized.\n");
-                return;
+        if (!ghes_disable) {
+                rc = apei_hest_parse(hest_parse_ghes_count, &ghes_count);
+                if (rc)
+                        goto err;
+                rc = hest_ghes_dev_register(ghes_count);
+                if (rc)
+                        goto err;
         }
 
+        pr_info(HEST_PFX "Table parsing has been initialized.\n");
+        return;
 err:
         hest_disable = 1;
 }
diff --git a/drivers/acpi/battery.c b/drivers/acpi/battery.c
index 2c661353e8f2..7711d94a0409 100644
--- a/drivers/acpi/battery.c
+++ b/drivers/acpi/battery.c
@@ -55,6 +55,9 @@
 #define ACPI_BATTERY_NOTIFY_INFO        0x81
 #define ACPI_BATTERY_NOTIFY_THRESHOLD   0x82
 
+/* Battery power unit: 0 means mW, 1 means mA */
+#define ACPI_BATTERY_POWER_UNIT_MA      1
+
 #define _COMPONENT              ACPI_BATTERY_COMPONENT
 
 ACPI_MODULE_NAME("battery");
@@ -91,16 +94,12 @@ MODULE_DEVICE_TABLE(acpi, battery_device_ids);
 enum {
         ACPI_BATTERY_ALARM_PRESENT,
         ACPI_BATTERY_XINFO_PRESENT,
-        /* For buggy DSDTs that report negative 16-bit values for either
-         * charging or discharging current and/or report 0 as 65536
-         * due to bad math.
-         */
-        ACPI_BATTERY_QUIRK_SIGNED16_CURRENT,
         ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY,
 };
 
 struct acpi_battery {
         struct mutex lock;
+        struct mutex sysfs_lock;
         struct power_supply bat;
         struct acpi_device *device;
         struct notifier_block pm_nb;
@@ -301,7 +300,8 @@ static enum power_supply_property energy_battery_props[] = {
 #ifdef CONFIG_ACPI_PROCFS_POWER
 inline char *acpi_battery_units(struct acpi_battery *battery)
 {
-        return (battery->power_unit)?"mA":"mW";
+        return (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) ?
+                "mA" : "mW";
 }
 #endif
 
@@ -461,9 +461,17 @@ static int acpi_battery_get_state(struct acpi_battery *battery)
         battery->update_time = jiffies;
         kfree(buffer.pointer);
 
-        if (test_bit(ACPI_BATTERY_QUIRK_SIGNED16_CURRENT, &battery->flags) &&
-            battery->rate_now != -1)
+        /* For buggy DSDTs that report negative 16-bit values for either
+         * charging or discharging current and/or report 0 as 65536
+         * due to bad math.
+         */
+        if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA &&
+                battery->rate_now != ACPI_BATTERY_VALUE_UNKNOWN &&
+                (s16)(battery->rate_now) < 0) {
                 battery->rate_now = abs((s16)battery->rate_now);
+                printk_once(KERN_WARNING FW_BUG "battery: (dis)charge rate"
+                        " invalid.\n");
+        }
 
         if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags)
             && battery->capacity_now >= 0 && battery->capacity_now <= 100)
@@ -544,7 +552,7 @@ static int sysfs_add_battery(struct acpi_battery *battery)
 {
         int result;
 
-        if (battery->power_unit) {
+        if (battery->power_unit == ACPI_BATTERY_POWER_UNIT_MA) {
                 battery->bat.properties = charge_battery_props;
                 battery->bat.num_properties =
                         ARRAY_SIZE(charge_battery_props);
@@ -566,18 +574,16 @@ static int sysfs_add_battery(struct acpi_battery *battery)
 
 static void sysfs_remove_battery(struct acpi_battery *battery)
 {
-        if (!battery->bat.dev)
+        mutex_lock(&battery->sysfs_lock);
+        if (!battery->bat.dev) {
+                mutex_unlock(&battery->sysfs_lock);
                 return;
+        }
+
         device_remove_file(battery->bat.dev, &alarm_attr);
         power_supply_unregister(&battery->bat);
         battery->bat.dev = NULL;
-}
-
-static void acpi_battery_quirks(struct acpi_battery *battery)
-{
-        if (dmi_name_in_vendors("Acer") && battery->power_unit) {
-                set_bit(ACPI_BATTERY_QUIRK_SIGNED16_CURRENT, &battery->flags);
-        }
+        mutex_unlock(&battery->sysfs_lock);
 }
 
 /*
@@ -592,7 +598,7 @@ static void acpi_battery_quirks(struct acpi_battery *battery)
  *
  * Handle this correctly so that they won't break userspace.
  */
-static void acpi_battery_quirks2(struct acpi_battery *battery)
+static void acpi_battery_quirks(struct acpi_battery *battery)
 {
         if (test_bit(ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY, &battery->flags))
                 return ;
@@ -623,13 +629,15 @@ static int acpi_battery_update(struct acpi_battery *battery)
                 result = acpi_battery_get_info(battery);
                 if (result)
                         return result;
-                acpi_battery_quirks(battery);
                 acpi_battery_init_alarm(battery);
         }
-        if (!battery->bat.dev)
-                sysfs_add_battery(battery);
+        if (!battery->bat.dev) {
+                result = sysfs_add_battery(battery);
+                if (result)
+                        return result;
+        }
         result = acpi_battery_get_state(battery);
-        acpi_battery_quirks2(battery);
+        acpi_battery_quirks(battery);
         return result;
 }
 
@@ -863,7 +871,7 @@ DECLARE_FILE_FUNCTIONS(alarm);
                 }, \
         }
 
-static struct battery_file {
+static const struct battery_file {
         struct file_operations ops;
         mode_t mode;
         const char *name;
@@ -948,9 +956,12 @@ static int battery_notify(struct notifier_block *nb,
         struct acpi_battery *battery = container_of(nb, struct acpi_battery,
                                                     pm_nb);
         switch (mode) {
+        case PM_POST_HIBERNATION:
         case PM_POST_SUSPEND:
-                sysfs_remove_battery(battery);
-                sysfs_add_battery(battery);
+                if (battery->bat.dev) {
+                        sysfs_remove_battery(battery);
+                        sysfs_add_battery(battery);
+                }
                 break;
         }
 
@@ -972,28 +983,38 @@ static int acpi_battery_add(struct acpi_device *device)
         strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
         device->driver_data = battery;
         mutex_init(&battery->lock);
+        mutex_init(&battery->sysfs_lock);
         if (ACPI_SUCCESS(acpi_get_handle(battery->device->handle,
                         "_BIX", &handle)))
                 set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
-        acpi_battery_update(battery);
+        result = acpi_battery_update(battery);
+        if (result)
+                goto fail;
 #ifdef CONFIG_ACPI_PROCFS_POWER
         result = acpi_battery_add_fs(device);
 #endif
-        if (!result) {
-                printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n",
-                        ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
-                        device->status.battery_present ? "present" : "absent");
-        } else {
+        if (result) {
 #ifdef CONFIG_ACPI_PROCFS_POWER
                 acpi_battery_remove_fs(device);
 #endif
-                kfree(battery);
+                goto fail;
         }
 
+        printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n",
+                ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
+                device->status.battery_present ? "present" : "absent");
+
         battery->pm_nb.notifier_call = battery_notify;
         register_pm_notifier(&battery->pm_nb);
 
         return result;
+
+fail:
+        sysfs_remove_battery(battery);
+        mutex_destroy(&battery->lock);
+        mutex_destroy(&battery->sysfs_lock);
+        kfree(battery);
+        return result;
 }
 
 static int acpi_battery_remove(struct acpi_device *device, int type)
@@ -1009,6 +1030,7 @@ static int acpi_battery_remove(struct acpi_device *device, int type)
 #endif
         sysfs_remove_battery(battery);
         mutex_destroy(&battery->lock);
+        mutex_destroy(&battery->sysfs_lock);
         kfree(battery);
         return 0;
 }
diff --git a/drivers/acpi/bus.c b/drivers/acpi/bus.c
index d1e06c182cdb..437ddbf0c49a 100644
--- a/drivers/acpi/bus.c
+++ b/drivers/acpi/bus.c
@@ -39,6 +39,7 @@
 #include <linux/pci.h>
 #include <acpi/acpi_bus.h>
 #include <acpi/acpi_drivers.h>
+#include <acpi/apei.h>
 #include <linux/dmi.h>
 #include <linux/suspend.h>
 
@@ -519,6 +520,7 @@ out_kfree:
 }
 EXPORT_SYMBOL(acpi_run_osc);
 
+bool osc_sb_apei_support_acked;
 static u8 sb_uuid_str[] = "0811B06E-4A27-44F9-8D60-3CBBC22E7B48";
 static void acpi_bus_osc_support(void)
 {
@@ -541,11 +543,19 @@ static void acpi_bus_osc_support(void)
 #if defined(CONFIG_ACPI_PROCESSOR) || defined(CONFIG_ACPI_PROCESSOR_MODULE)
         capbuf[OSC_SUPPORT_TYPE] |= OSC_SB_PPC_OST_SUPPORT;
 #endif
+
+        if (!ghes_disable)
+                capbuf[OSC_SUPPORT_TYPE] |= OSC_SB_APEI_SUPPORT;
         if (ACPI_FAILURE(acpi_get_handle(NULL, "\\_SB", &handle)))
                 return;
-        if (ACPI_SUCCESS(acpi_run_osc(handle, &context)))
+        if (ACPI_SUCCESS(acpi_run_osc(handle, &context))) {
+                u32 *capbuf_ret = context.ret.pointer;
+                if (context.ret.length > OSC_SUPPORT_TYPE)
+                        osc_sb_apei_support_acked =
+                                capbuf_ret[OSC_SUPPORT_TYPE] & OSC_SB_APEI_SUPPORT;
                 kfree(context.ret.pointer);
-        /* do we need to check the returned cap? Sounds no */
+        }
+        /* do we need to check other returned cap? Sounds no */
 }
 
 /* --------------------------------------------------------------------------
diff --git a/drivers/acpi/dock.c b/drivers/acpi/dock.c
index 1864ad3cf895..19a61136d848 100644
--- a/drivers/acpi/dock.c
+++ b/drivers/acpi/dock.c
@@ -77,7 +77,7 @@ struct dock_dependent_device {
         struct list_head list;
         struct list_head hotplug_list;
         acpi_handle handle;
-        struct acpi_dock_ops *ops;
+        const struct acpi_dock_ops *ops;
         void *context;
 };
 
@@ -589,7 +589,7 @@ EXPORT_SYMBOL_GPL(unregister_dock_notifier);
  * the dock driver after _DCK is executed.
  */
 int
-register_hotplug_dock_device(acpi_handle handle, struct acpi_dock_ops *ops,
+register_hotplug_dock_device(acpi_handle handle, const struct acpi_dock_ops *ops,
                              void *context)
 {
         struct dock_dependent_device *dd;
diff --git a/drivers/acpi/ec_sys.c b/drivers/acpi/ec_sys.c
index 05b44201a614..22f918bacd35 100644
--- a/drivers/acpi/ec_sys.c
+++ b/drivers/acpi/ec_sys.c
@@ -92,7 +92,7 @@ static ssize_t acpi_ec_write_io(struct file *f, const char __user *buf,
         return count;
 }
 
-static struct file_operations acpi_ec_io_ops = {
+static const struct file_operations acpi_ec_io_ops = {
         .owner = THIS_MODULE,
         .open  = acpi_ec_open_io,
         .read  = acpi_ec_read_io,
diff --git a/drivers/acpi/fan.c b/drivers/acpi/fan.c
index 467479f07c1f..0f0356ca1a9e 100644
--- a/drivers/acpi/fan.c
+++ b/drivers/acpi/fan.c
@@ -110,7 +110,7 @@ fan_set_cur_state(struct thermal_cooling_device *cdev, unsigned long state)
         return result;
 }
 
-static struct thermal_cooling_device_ops fan_cooling_ops = {
+static const struct thermal_cooling_device_ops fan_cooling_ops = {
         .get_max_state = fan_get_max_state,
         .get_cur_state = fan_get_cur_state,
         .set_cur_state = fan_set_cur_state,
diff --git a/drivers/acpi/osl.c b/drivers/acpi/osl.c
index 372f9b70f7f4..fa32f584229f 100644
--- a/drivers/acpi/osl.c
+++ b/drivers/acpi/osl.c
@@ -155,7 +155,7 @@ static u32 acpi_osi_handler(acpi_string interface, u32 supported)
 {
         if (!strcmp("Linux", interface)) {
 
-                printk(KERN_NOTICE FW_BUG PREFIX
+                printk_once(KERN_NOTICE FW_BUG PREFIX
                         "BIOS _OSI(Linux) query %s%s\n",
                         osi_linux.enable ? "honored" : "ignored",
                         osi_linux.cmdline ? " via cmdline" :
@@ -237,8 +237,23 @@ void acpi_os_vprintf(const char *fmt, va_list args)
 #endif
 }
 
+#ifdef CONFIG_KEXEC
+static unsigned long acpi_rsdp;
+static int __init setup_acpi_rsdp(char *arg)
+{
+        acpi_rsdp = simple_strtoul(arg, NULL, 16);
+        return 0;
+}
+early_param("acpi_rsdp", setup_acpi_rsdp);
+#endif
+
 acpi_physical_address __init acpi_os_get_root_pointer(void)
 {
+#ifdef CONFIG_KEXEC
+        if (acpi_rsdp)
+                return acpi_rsdp;
+#endif
+
         if (efi_enabled) {
                 if (efi.acpi20 != EFI_INVALID_TABLE_ADDR)
                         return efi.acpi20;
@@ -1083,7 +1098,13 @@ struct osi_setup_entry {
         bool enable;
 };
 
-static struct osi_setup_entry __initdata osi_setup_entries[OSI_STRING_ENTRIES_MAX];
+static struct osi_setup_entry __initdata
+                osi_setup_entries[OSI_STRING_ENTRIES_MAX] = {
+        {"Module Device", true},
+        {"Processor Device", true},
+        {"3.0 _SCP Extensions", true},
+        {"Processor Aggregator Device", true},
+};
 
 void __init acpi_osi_setup(char *str)
 {
diff --git a/drivers/acpi/pci_irq.c b/drivers/acpi/pci_irq.c
index f907cfbfa13c..7f9eba9a0b02 100644
--- a/drivers/acpi/pci_irq.c
+++ b/drivers/acpi/pci_irq.c
@@ -303,6 +303,61 @@ void acpi_pci_irq_del_prt(struct pci_bus *bus)
 /* --------------------------------------------------------------------------
                           PCI Interrupt Routing Support
    -------------------------------------------------------------------------- */
+#ifdef CONFIG_X86_IO_APIC
+extern int noioapicquirk;
+extern int noioapicreroute;
+
+static int bridge_has_boot_interrupt_variant(struct pci_bus *bus)
+{
+        struct pci_bus *bus_it;
+
+        for (bus_it = bus ; bus_it ; bus_it = bus_it->parent) {
+                if (!bus_it->self)
+                        return 0;
+                if (bus_it->self->irq_reroute_variant)
+                        return bus_it->self->irq_reroute_variant;
+        }
+        return 0;
+}
+
+/*
+ * Some chipsets (e.g. Intel 6700PXH) generate a legacy INTx when the IRQ
+ * entry in the chipset's IO-APIC is masked (as, e.g. the RT kernel does
+ * during interrupt handling). When this INTx generation cannot be disabled,
+ * we reroute these interrupts to their legacy equivalent to get rid of
+ * spurious interrupts.
+ */
+static int acpi_reroute_boot_interrupt(struct pci_dev *dev,
+                                       struct acpi_prt_entry *entry)
+{
+        if (noioapicquirk || noioapicreroute) {
+                return 0;
+        } else {
+                switch (bridge_has_boot_interrupt_variant(dev->bus)) {
+                case 0:
+                        /* no rerouting necessary */
+                        return 0;
+                case INTEL_IRQ_REROUTE_VARIANT:
+                        /*
+                         * Remap according to INTx routing table in 6700PXH
+                         * specs, intel order number 302628-002, section
+                         * 2.15.2. Other chipsets (80332, ...) have the same
+                         * mapping and are handled here as well.
+                         */
+                        dev_info(&dev->dev, "PCI IRQ %d -> rerouted to legacy "
+                                 "IRQ %d\n", entry->index,
+                                 (entry->index % 4) + 16);
+                        entry->index = (entry->index % 4) + 16;
+                        return 1;
+                default:
+                        dev_warn(&dev->dev, "Cannot reroute IRQ %d to legacy "
+                                 "IRQ: unknown mapping\n", entry->index);
+                        return -1;
+                }
+        }
+}
+#endif /* CONFIG_X86_IO_APIC */
+
 static struct acpi_prt_entry *acpi_pci_irq_lookup(struct pci_dev *dev, int pin)
 {
         struct acpi_prt_entry *entry;
@@ -311,6 +366,9 @@ static struct acpi_prt_entry *acpi_pci_irq_lookup(struct pci_dev *dev, int pin)
 
         entry = acpi_pci_irq_find_prt_entry(dev, pin);
         if (entry) {
+#ifdef CONFIG_X86_IO_APIC
+                acpi_reroute_boot_interrupt(dev, entry);
+#endif /* CONFIG_X86_IO_APIC */
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %s[%c] _PRT entry\n",
                                   pci_name(dev), pin_name(pin)));
                 return entry;
diff --git a/drivers/acpi/pci_root.c b/drivers/acpi/pci_root.c
index d06078d660ad..2672c798272f 100644
--- a/drivers/acpi/pci_root.c
+++ b/drivers/acpi/pci_root.c
@@ -485,7 +485,8 @@ static int __devinit acpi_pci_root_add(struct acpi_device *device)
                 root->secondary.end = 0xFF;
                 printk(KERN_WARNING FW_BUG PREFIX
                        "no secondary bus range in _CRS\n");
-                status = acpi_evaluate_integer(device->handle, METHOD_NAME__BBN,                                               NULL, &bus);
+                status = acpi_evaluate_integer(device->handle, METHOD_NAME__BBN,
+                                               NULL, &bus);
                 if (ACPI_SUCCESS(status))
                         root->secondary.start = bus;
                 else if (status == AE_NOT_FOUND)
diff --git a/drivers/acpi/processor_thermal.c b/drivers/acpi/processor_thermal.c
index 79cb65332894..870550d6a4bf 100644
--- a/drivers/acpi/processor_thermal.c
+++ b/drivers/acpi/processor_thermal.c
@@ -244,7 +244,7 @@ processor_set_cur_state(struct thermal_cooling_device *cdev,
         return result;
 }
 
-struct thermal_cooling_device_ops processor_cooling_ops = {
+const struct thermal_cooling_device_ops processor_cooling_ops = {
         .get_max_state = processor_get_max_state,
         .get_cur_state = processor_get_cur_state,
         .set_cur_state = processor_set_cur_state,
diff --git a/drivers/acpi/sbs.c b/drivers/acpi/sbs.c
index 50658ff887d9..6e36d0c0057c 100644
--- a/drivers/acpi/sbs.c
+++ b/drivers/acpi/sbs.c
@@ -130,6 +130,9 @@ struct acpi_sbs {
 
 #define to_acpi_sbs(x) container_of(x, struct acpi_sbs, charger)
 
+static int acpi_sbs_remove(struct acpi_device *device, int type);
+static int acpi_battery_get_state(struct acpi_battery *battery);
+
 static inline int battery_scale(int log)
 {
         int scale = 1;
@@ -195,6 +198,8 @@ static int acpi_sbs_battery_get_property(struct power_supply *psy,
 
         if ((!battery->present) && psp != POWER_SUPPLY_PROP_PRESENT)
                 return -ENODEV;
+
+        acpi_battery_get_state(battery);
         switch (psp) {
         case POWER_SUPPLY_PROP_STATUS:
                 if (battery->rate_now < 0)
@@ -225,11 +230,17 @@ static int acpi_sbs_battery_get_property(struct power_supply *psy,
         case POWER_SUPPLY_PROP_POWER_NOW:
                 val->intval = abs(battery->rate_now) *
                                 acpi_battery_ipscale(battery) * 1000;
+                val->intval *= (acpi_battery_mode(battery)) ?
+                                (battery->voltage_now *
+                                acpi_battery_vscale(battery) / 1000) : 1;
                 break;
         case POWER_SUPPLY_PROP_CURRENT_AVG:
         case POWER_SUPPLY_PROP_POWER_AVG:
                 val->intval = abs(battery->rate_avg) *
                                 acpi_battery_ipscale(battery) * 1000;
+                val->intval *= (acpi_battery_mode(battery)) ?
+                                (battery->voltage_now *
+                                acpi_battery_vscale(battery) / 1000) : 1;
                 break;
         case POWER_SUPPLY_PROP_CAPACITY:
                 val->intval = battery->state_of_charge;
@@ -903,8 +914,6 @@ static void acpi_sbs_callback(void *context)
         }
 }
 
-static int acpi_sbs_remove(struct acpi_device *device, int type);
-
 static int acpi_sbs_add(struct acpi_device *device)
 {
         struct acpi_sbs *sbs;
diff --git a/drivers/acpi/sleep.c b/drivers/acpi/sleep.c
index 6c949602cbd1..3ed80b2ca907 100644
--- a/drivers/acpi/sleep.c
+++ b/drivers/acpi/sleep.c
@@ -428,6 +428,22 @@ static struct dmi_system_id __initdata acpisleep_dmi_table[] = {
                 DMI_MATCH(DMI_PRODUCT_NAME, "1000 Series"),
                 },
         },
+        {
+        .callback = init_old_suspend_ordering,
+        .ident = "Asus A8N-SLI DELUXE",
+        .matches = {
+                DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
+                DMI_MATCH(DMI_BOARD_NAME, "A8N-SLI DELUXE"),
+                },
+        },
+        {
+        .callback = init_old_suspend_ordering,
+        .ident = "Asus A8N-SLI Premium",
+        .matches = {
+                DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
+                DMI_MATCH(DMI_BOARD_NAME, "A8N-SLI Premium"),
+                },
+        },
         {},
 };
 #endif /* CONFIG_SUSPEND */
diff --git a/drivers/acpi/sysfs.c b/drivers/acpi/sysfs.c
index 77255f250dbb..c538d0ef10ff 100644
--- a/drivers/acpi/sysfs.c
+++ b/drivers/acpi/sysfs.c
@@ -149,12 +149,12 @@ static int param_get_debug_level(char *buffer, const struct kernel_param *kp)
         return result;
 }
 
-static struct kernel_param_ops param_ops_debug_layer = {
+static const struct kernel_param_ops param_ops_debug_layer = {
         .set = param_set_uint,
         .get = param_get_debug_layer,
 };
 
-static struct kernel_param_ops param_ops_debug_level = {
+static const struct kernel_param_ops param_ops_debug_level = {
         .set = param_set_uint,
         .get = param_get_debug_level,
 };
diff --git a/drivers/acpi/thermal.c b/drivers/acpi/thermal.c
index 2607e17b520f..48fbc647b178 100644
--- a/drivers/acpi/thermal.c
+++ b/drivers/acpi/thermal.c
@@ -812,7 +812,7 @@ acpi_thermal_unbind_cooling_device(struct thermal_zone_device *thermal,
                                 thermal_zone_unbind_cooling_device);
 }
 
-static struct thermal_zone_device_ops acpi_thermal_zone_ops = {
+static const struct thermal_zone_device_ops acpi_thermal_zone_ops = {
         .bind = acpi_thermal_bind_cooling_device,
         .unbind = acpi_thermal_unbind_cooling_device,
         .get_temp = thermal_get_temp,
diff --git a/drivers/acpi/video.c b/drivers/acpi/video.c
index ada4b4d9bdc8..08a44b532f7c 100644
--- a/drivers/acpi/video.c
+++ b/drivers/acpi/video.c
@@ -307,7 +307,7 @@ video_set_cur_state(struct thermal_cooling_device *cooling_dev, unsigned long st
         return acpi_video_device_lcd_set_level(video, level);
 }
 
-static struct thermal_cooling_device_ops video_cooling_ops = {
+static const struct thermal_cooling_device_ops video_cooling_ops = {
         .get_max_state = video_get_max_state,
         .get_cur_state = video_get_cur_state,
         .set_cur_state = video_set_cur_state,
diff --git a/drivers/ata/Kconfig b/drivers/ata/Kconfig
index ca3e6be44a04..5987e0ba8c2d 100644
--- a/drivers/ata/Kconfig
+++ b/drivers/ata/Kconfig
@@ -468,6 +468,15 @@ config PATA_ICSIDE
           interface card.  This is not required for ICS partition support.
           If you are unsure, say N to this.
 
+config PATA_IMX
+        tristate "PATA support for Freescale iMX"
+        depends on ARCH_MXC
+        help
+          This option enables support for the PATA host available on Freescale
+          iMX SoCs.
+
+          If unsure, say N.
+
 config PATA_IT8213
         tristate "IT8213 PATA support (Experimental)"
         depends on PCI && EXPERIMENTAL
diff --git a/drivers/ata/Makefile b/drivers/ata/Makefile
index 8ac64e1aa051..9550d691fd19 100644
--- a/drivers/ata/Makefile
+++ b/drivers/ata/Makefile
@@ -48,6 +48,7 @@ obj-$(CONFIG_PATA_HPT37X)	+= pata_hpt37x.o
 obj-$(CONFIG_PATA_HPT3X2N)      += pata_hpt3x2n.o
 obj-$(CONFIG_PATA_HPT3X3)       += pata_hpt3x3.o
 obj-$(CONFIG_PATA_ICSIDE)       += pata_icside.o
+obj-$(CONFIG_PATA_IMX)          += pata_imx.o
 obj-$(CONFIG_PATA_IT8213)       += pata_it8213.o
 obj-$(CONFIG_PATA_IT821X)       += pata_it821x.o
 obj-$(CONFIG_PATA_JMICRON)      += pata_jmicron.o
diff --git a/drivers/ata/libata-acpi.c b/drivers/ata/libata-acpi.c
index e0a5b555cee1..bb7c5f1085cc 100644
--- a/drivers/ata/libata-acpi.c
+++ b/drivers/ata/libata-acpi.c
@@ -218,12 +218,12 @@ static void ata_acpi_dev_uevent(acpi_handle handle, u32 event, void *data)
         ata_acpi_uevent(dev->link->ap, dev, event);
 }
 
-static struct acpi_dock_ops ata_acpi_dev_dock_ops = {
+static const struct acpi_dock_ops ata_acpi_dev_dock_ops = {
         .handler = ata_acpi_dev_notify_dock,
         .uevent = ata_acpi_dev_uevent,
 };
 
-static struct acpi_dock_ops ata_acpi_ap_dock_ops = {
+static const struct acpi_dock_ops ata_acpi_ap_dock_ops = {
         .handler = ata_acpi_ap_notify_dock,
         .uevent = ata_acpi_ap_uevent,
 };
diff --git a/drivers/ata/pata_imx.c b/drivers/ata/pata_imx.c
new file mode 100644
index 000000000000..ca9d9caedfa3
--- /dev/null
+++ b/drivers/ata/pata_imx.c
@@ -0,0 +1,253 @@
+/*
+ * Freescale iMX PATA driver
+ *
+ * Copyright (C) 2011 Arnaud Patard <arnaud.patard@rtp-net.org>
+ *
+ * Based on pata_platform - Copyright (C) 2006 - 2007  Paul Mundt
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * TODO:
+ * - dmaengine support
+ * - check if timing stuff needed
+ */
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/blkdev.h>
+#include <scsi/scsi_host.h>
+#include <linux/ata.h>
+#include <linux/libata.h>
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+
+#define DRV_NAME "pata_imx"
+
+#define PATA_IMX_ATA_CONTROL            0x24
+#define PATA_IMX_ATA_CTRL_FIFO_RST_B    (1<<7)
+#define PATA_IMX_ATA_CTRL_ATA_RST_B     (1<<6)
+#define PATA_IMX_ATA_CTRL_IORDY_EN      (1<<0)
+#define PATA_IMX_ATA_INT_EN             0x2C
+#define PATA_IMX_ATA_INTR_ATA_INTRQ2    (1<<3)
+#define PATA_IMX_DRIVE_DATA             0xA0
+#define PATA_IMX_DRIVE_CONTROL          0xD8
+
+struct pata_imx_priv {
+        struct clk *clk;
+        /* timings/interrupt/control regs */
+        u8 *host_regs;
+        u32 ata_ctl;
+};
+
+static int pata_imx_set_mode(struct ata_link *link, struct ata_device **unused)
+{
+        struct ata_device *dev;
+        struct ata_port *ap = link->ap;
+        struct pata_imx_priv *priv = ap->host->private_data;
+        u32 val;
+
+        ata_for_each_dev(dev, link, ENABLED) {
+                dev->pio_mode = dev->xfer_mode = XFER_PIO_0;
+                dev->xfer_shift = ATA_SHIFT_PIO;
+                dev->flags |= ATA_DFLAG_PIO;
+
+                val = __raw_readl(priv->host_regs + PATA_IMX_ATA_CONTROL);
+                if (ata_pio_need_iordy(dev))
+                        val |= PATA_IMX_ATA_CTRL_IORDY_EN;
+                else
+                        val &= ~PATA_IMX_ATA_CTRL_IORDY_EN;
+                __raw_writel(val, priv->host_regs + PATA_IMX_ATA_CONTROL);
+
+                ata_dev_printk(dev, KERN_INFO, "configured for PIO\n");
+        }
+        return 0;
+}
+
+static struct scsi_host_template pata_imx_sht = {
+        ATA_PIO_SHT(DRV_NAME),
+};
+
+static struct ata_port_operations pata_imx_port_ops = {
+        .inherits               = &ata_sff_port_ops,
+        .sff_data_xfer          = ata_sff_data_xfer_noirq,
+        .cable_detect           = ata_cable_unknown,
+        .set_mode               = pata_imx_set_mode,
+};
+
+static void pata_imx_setup_port(struct ata_ioports *ioaddr)
+{
+        /* Fixup the port shift for platforms that need it */
+        ioaddr->data_addr       = ioaddr->cmd_addr + (ATA_REG_DATA    << 2);
+        ioaddr->error_addr      = ioaddr->cmd_addr + (ATA_REG_ERR     << 2);
+        ioaddr->feature_addr    = ioaddr->cmd_addr + (ATA_REG_FEATURE << 2);
+        ioaddr->nsect_addr      = ioaddr->cmd_addr + (ATA_REG_NSECT   << 2);
+        ioaddr->lbal_addr       = ioaddr->cmd_addr + (ATA_REG_LBAL    << 2);
+        ioaddr->lbam_addr       = ioaddr->cmd_addr + (ATA_REG_LBAM    << 2);
+        ioaddr->lbah_addr       = ioaddr->cmd_addr + (ATA_REG_LBAH    << 2);
+        ioaddr->device_addr     = ioaddr->cmd_addr + (ATA_REG_DEVICE  << 2);
+        ioaddr->status_addr     = ioaddr->cmd_addr + (ATA_REG_STATUS  << 2);
+        ioaddr->command_addr    = ioaddr->cmd_addr + (ATA_REG_CMD     << 2);
+}
+
+static int __devinit pata_imx_probe(struct platform_device *pdev)
+{
+        struct ata_host *host;
+        struct ata_port *ap;
+        struct pata_imx_priv *priv;
+        int irq = 0;
+        struct resource *io_res;
+
+        io_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (io_res == NULL)
+                return -EINVAL;
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq <= 0)
+                return -EINVAL;
+
+        priv = devm_kzalloc(&pdev->dev,
+                                sizeof(struct pata_imx_priv), GFP_KERNEL);
+        if (!priv)
+                return -ENOMEM;
+
+        priv->clk = clk_get(&pdev->dev, NULL);
+        if (IS_ERR(priv->clk)) {
+                dev_err(&pdev->dev, "Failed to get clock\n");
+                return PTR_ERR(priv->clk);
+        }
+
+        clk_enable(priv->clk);
+
+        host = ata_host_alloc(&pdev->dev, 1);
+        if (!host)
+                goto free_priv;
+
+        host->private_data = priv;
+        ap = host->ports[0];
+
+        ap->ops = &pata_imx_port_ops;
+        ap->pio_mask = ATA_PIO0;
+        ap->flags |= ATA_FLAG_SLAVE_POSS;
+
+        priv->host_regs = devm_ioremap(&pdev->dev, io_res->start,
+                resource_size(io_res));
+        if (!priv->host_regs) {
+                dev_err(&pdev->dev, "failed to map IO/CTL base\n");
+                goto free_priv;
+        }
+
+        ap->ioaddr.cmd_addr = priv->host_regs + PATA_IMX_DRIVE_DATA;
+        ap->ioaddr.ctl_addr = priv->host_regs + PATA_IMX_DRIVE_CONTROL;
+
+        ap->ioaddr.altstatus_addr = ap->ioaddr.ctl_addr;
+
+        pata_imx_setup_port(&ap->ioaddr);
+
+        ata_port_desc(ap, "cmd 0x%llx ctl 0x%llx",
+                (unsigned long long)io_res->start + PATA_IMX_DRIVE_DATA,
+                (unsigned long long)io_res->start + PATA_IMX_DRIVE_CONTROL);
+
+        /* deassert resets */
+        __raw_writel(PATA_IMX_ATA_CTRL_FIFO_RST_B |
+                        PATA_IMX_ATA_CTRL_ATA_RST_B,
+                        priv->host_regs + PATA_IMX_ATA_CONTROL);
+        /* enable interrupts */
+        __raw_writel(PATA_IMX_ATA_INTR_ATA_INTRQ2,
+                        priv->host_regs + PATA_IMX_ATA_INT_EN);
+
+        /* activate */
+        return ata_host_activate(host, irq, ata_sff_interrupt, 0,
+                                &pata_imx_sht);
+
+free_priv:
+        clk_disable(priv->clk);
+        clk_put(priv->clk);
+        return -ENOMEM;
+}
+
+static int __devexit pata_imx_remove(struct platform_device *pdev)
+{
+        struct ata_host *host = dev_get_drvdata(&pdev->dev);
+        struct pata_imx_priv *priv = host->private_data;
+
+        ata_host_detach(host);
+
+        __raw_writel(0, priv->host_regs + PATA_IMX_ATA_INT_EN);
+
+        clk_disable(priv->clk);
+        clk_put(priv->clk);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int pata_imx_suspend(struct device *dev)
+{
+        struct ata_host *host = dev_get_drvdata(dev);
+        struct pata_imx_priv *priv = host->private_data;
+        int ret;
+
+        ret = ata_host_suspend(host, PMSG_SUSPEND);
+        if (!ret) {
+                __raw_writel(0, priv->host_regs + PATA_IMX_ATA_INT_EN);
+                priv->ata_ctl =
+                        __raw_readl(priv->host_regs + PATA_IMX_ATA_CONTROL);
+                clk_disable(priv->clk);
+        }
+
+        return ret;
+}
+
+static int pata_imx_resume(struct device *dev)
+{
+        struct ata_host *host = dev_get_drvdata(dev);
+        struct pata_imx_priv *priv = host->private_data;
+
+        clk_enable(priv->clk);
+
+        __raw_writel(priv->ata_ctl, priv->host_regs + PATA_IMX_ATA_CONTROL);
+
+        __raw_writel(PATA_IMX_ATA_INTR_ATA_INTRQ2,
+                        priv->host_regs + PATA_IMX_ATA_INT_EN);
+
+        ata_host_resume(host);
+
+        return 0;
+}
+
+static const struct dev_pm_ops pata_imx_pm_ops = {
+        .suspend        = pata_imx_suspend,
+        .resume         = pata_imx_resume,
+};
+#endif
+
+static struct platform_driver pata_imx_driver = {
+        .probe          = pata_imx_probe,
+        .remove         = __devexit_p(pata_imx_remove),
+        .driver = {
+                .name           = DRV_NAME,
+                .owner          = THIS_MODULE,
+#ifdef CONFIG_PM
+                .pm             = &pata_imx_pm_ops,
+#endif
+        },
+};
+
+static int __init pata_imx_init(void)
+{
+        return platform_driver_register(&pata_imx_driver);
+}
+
+static void __exit pata_imx_exit(void)
+{
+        platform_driver_unregister(&pata_imx_driver);
+}
+module_init(pata_imx_init);
+module_exit(pata_imx_exit);
+
+MODULE_AUTHOR("Arnaud Patard <arnaud.patard@rtp-net.org>");
+MODULE_DESCRIPTION("low-level driver for iMX PATA");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:" DRV_NAME);
diff --git a/drivers/ata/pata_via.c b/drivers/ata/pata_via.c
index 65e4be6be220..8e9f5048a10a 100644
--- a/drivers/ata/pata_via.c
+++ b/drivers/ata/pata_via.c
@@ -124,6 +124,17 @@ static const struct via_isa_bridge {
         { NULL }
 };
 
+static const struct dmi_system_id no_atapi_dma_dmi_table[] = {
+        {
+                .ident = "AVERATEC 3200",
+                .matches = {
+                        DMI_MATCH(DMI_BOARD_VENDOR, "AVERATEC"),
+                        DMI_MATCH(DMI_BOARD_NAME, "3200"),
+                },
+        },
+        { }
+};
+
 struct via_port {
         u8 cached_device;
 };
@@ -355,6 +366,13 @@ static unsigned long via_mode_filter(struct ata_device *dev, unsigned long mask)
                         mask &= ~ ATA_MASK_UDMA;
                 }
         }
+
+        if (dev->class == ATA_DEV_ATAPI &&
+            dmi_check_system(no_atapi_dma_dmi_table)) {
+                ata_dev_warn(dev, "controller locks up on ATAPI DMA, forcing PIO\n");
+                mask &= ATA_MASK_PIO;
+        }
+
         return mask;
 }
 
diff --git a/drivers/ata/sata_dwc_460ex.c b/drivers/ata/sata_dwc_460ex.c
index 0a9a774a7e1e..5c4237452f50 100644
--- a/drivers/ata/sata_dwc_460ex.c
+++ b/drivers/ata/sata_dwc_460ex.c
@@ -1329,7 +1329,7 @@ static int sata_dwc_port_start(struct ata_port *ap)
                         dev_err(ap->dev, "%s: dma_alloc_coherent failed\n",
                                  __func__);
                         err = -ENOMEM;
-                        goto CLEANUP;
+                        goto CLEANUP_ALLOC;
                 }
         }
 
@@ -1349,15 +1349,13 @@ static int sata_dwc_port_start(struct ata_port *ap)
         /* Clear any error bits before libata starts issuing commands */
         clear_serror();
         ap->private_data = hsdevp;
+        dev_dbg(ap->dev, "%s: done\n", __func__);
+        return 0;
 
+CLEANUP_ALLOC:
+        kfree(hsdevp);
 CLEANUP:
-        if (err) {
-                sata_dwc_port_stop(ap);
-                dev_dbg(ap->dev, "%s: fail\n", __func__);
-        } else {
-                dev_dbg(ap->dev, "%s: done\n", __func__);
-        }
-
+        dev_dbg(ap->dev, "%s: fail. ap->id = %d\n", __func__, ap->print_id);
         return err;
 }
 
diff --git a/drivers/ata/sata_sil.c b/drivers/ata/sata_sil.c
index 98c1d780f552..9dfb40b8c2c9 100644
--- a/drivers/ata/sata_sil.c
+++ b/drivers/ata/sata_sil.c
@@ -438,7 +438,7 @@ static void sil_host_intr(struct ata_port *ap, u32 bmdma2)
         u8 status;
 
         if (unlikely(bmdma2 & SIL_DMA_SATA_IRQ)) {
-                u32 serror;
+                u32 serror = 0xffffffff;
 
                 /* SIEN doesn't mask SATA IRQs on some 3112s.  Those
                  * controllers continue to assert IRQ as long as
diff --git a/drivers/base/devres.c b/drivers/base/devres.c
index cf7a0c788052..65cd74832450 100644
--- a/drivers/base/devres.c
+++ b/drivers/base/devres.c
@@ -397,6 +397,7 @@ static int remove_nodes(struct device *dev,
 
 static int release_nodes(struct device *dev, struct list_head *first,
                          struct list_head *end, unsigned long flags)
+        __releases(&dev->devres_lock)
 {
         LIST_HEAD(todo);
         int cnt;
diff --git a/drivers/base/devtmpfs.c b/drivers/base/devtmpfs.c
index b89fffc1d777..a4760e095ff5 100644
--- a/drivers/base/devtmpfs.c
+++ b/drivers/base/devtmpfs.c
@@ -166,7 +166,7 @@ static int create_path(const char *nodepath)
 {
         char *path;
         char *s;
-        int err;
+        int err = 0;
 
         /* parent directories do not exist, create them */
         path = kstrdup(nodepath, GFP_KERNEL);
@@ -376,7 +376,7 @@ int devtmpfs_mount(const char *mntdir)
         return err;
 }
 
-static __initdata DECLARE_COMPLETION(setup_done);
+static DECLARE_COMPLETION(setup_done);
 
 static int handle(const char *name, mode_t mode, struct device *dev)
 {
diff --git a/drivers/base/firmware_class.c b/drivers/base/firmware_class.c
index bbb03e6f7255..06ed6b4e7df5 100644
--- a/drivers/base/firmware_class.c
+++ b/drivers/base/firmware_class.c
@@ -521,11 +521,6 @@ static int _request_firmware(const struct firmware **firmware_p,
         if (!firmware_p)
                 return -EINVAL;
 
-        if (WARN_ON(usermodehelper_is_disabled())) {
-                dev_err(device, "firmware: %s will not be loaded\n", name);
-                return -EBUSY;
-        }
-
         *firmware_p = firmware = kzalloc(sizeof(*firmware), GFP_KERNEL);
         if (!firmware) {
                 dev_err(device, "%s: kmalloc(struct firmware) failed\n",
@@ -539,6 +534,12 @@ static int _request_firmware(const struct firmware **firmware_p,
                 return 0;
         }
 
+        if (WARN_ON(usermodehelper_is_disabled())) {
+                dev_err(device, "firmware: %s will not be loaded\n", name);
+                retval = -EBUSY;
+                goto out;
+        }
+
         if (uevent)
                 dev_dbg(device, "firmware: requesting %s\n", name);
 
diff --git a/drivers/base/platform.c b/drivers/base/platform.c
index 0cad9c7f6bb5..99a5272d7c2f 100644
--- a/drivers/base/platform.c
+++ b/drivers/base/platform.c
@@ -33,7 +33,7 @@ EXPORT_SYMBOL_GPL(platform_bus);
 
 /**
  * arch_setup_pdev_archdata - Allow manipulation of archdata before its used
- * @dev: platform device
+ * @pdev: platform device
  *
  * This is called before platform_device_add() such that any pdev_archdata may
  * be setup before the platform_notifier is called.  So if a user needs to
diff --git a/drivers/base/power/clock_ops.c b/drivers/base/power/clock_ops.c
index a846b2f95cfb..2c18d584066d 100644
--- a/drivers/base/power/clock_ops.c
+++ b/drivers/base/power/clock_ops.c
@@ -19,7 +19,7 @@
 
 struct pm_clk_data {
         struct list_head clock_list;
-        struct mutex lock;
+        spinlock_t lock;
 };
 
 enum pce_status {
@@ -73,9 +73,9 @@ int pm_clk_add(struct device *dev, const char *con_id)
                 }
         }
 
-        mutex_lock(&pcd->lock);
+        spin_lock_irq(&pcd->lock);
         list_add_tail(&ce->node, &pcd->clock_list);
-        mutex_unlock(&pcd->lock);
+        spin_unlock_irq(&pcd->lock);
         return 0;
 }
 
@@ -83,8 +83,8 @@ int pm_clk_add(struct device *dev, const char *con_id)
  * __pm_clk_remove - Destroy PM clock entry.
  * @ce: PM clock entry to destroy.
  *
- * This routine must be called under the mutex protecting the PM list of clocks
- * corresponding the the @ce's device.
+ * This routine must be called under the spinlock protecting the PM list of
+ * clocks corresponding the the @ce's device.
  */
 static void __pm_clk_remove(struct pm_clock_entry *ce)
 {
@@ -123,7 +123,7 @@ void pm_clk_remove(struct device *dev, const char *con_id)
         if (!pcd)
                 return;
 
-        mutex_lock(&pcd->lock);
+        spin_lock_irq(&pcd->lock);
 
         list_for_each_entry(ce, &pcd->clock_list, node) {
                 if (!con_id && !ce->con_id) {
@@ -137,7 +137,7 @@ void pm_clk_remove(struct device *dev, const char *con_id)
                 }
         }
 
-        mutex_unlock(&pcd->lock);
+        spin_unlock_irq(&pcd->lock);
 }
 
 /**
@@ -158,7 +158,7 @@ int pm_clk_init(struct device *dev)
         }
 
         INIT_LIST_HEAD(&pcd->clock_list);
-        mutex_init(&pcd->lock);
+        spin_lock_init(&pcd->lock);
         dev->power.subsys_data = pcd;
         return 0;
 }
@@ -181,12 +181,12 @@ void pm_clk_destroy(struct device *dev)
 
         dev->power.subsys_data = NULL;
 
-        mutex_lock(&pcd->lock);
+        spin_lock_irq(&pcd->lock);
 
         list_for_each_entry_safe_reverse(ce, c, &pcd->clock_list, node)
                 __pm_clk_remove(ce);
 
-        mutex_unlock(&pcd->lock);
+        spin_unlock_irq(&pcd->lock);
 
         kfree(pcd);
 }
@@ -220,13 +220,14 @@ int pm_clk_suspend(struct device *dev)
 {
         struct pm_clk_data *pcd = __to_pcd(dev);
         struct pm_clock_entry *ce;
+        unsigned long flags;
 
         dev_dbg(dev, "%s()\n", __func__);
 
         if (!pcd)
                 return 0;
 
-        mutex_lock(&pcd->lock);
+        spin_lock_irqsave(&pcd->lock, flags);
 
         list_for_each_entry_reverse(ce, &pcd->clock_list, node) {
                 if (ce->status == PCE_STATUS_NONE)
@@ -238,7 +239,7 @@ int pm_clk_suspend(struct device *dev)
                 }
         }
 
-        mutex_unlock(&pcd->lock);
+        spin_unlock_irqrestore(&pcd->lock, flags);
 
         return 0;
 }
@@ -251,13 +252,14 @@ int pm_clk_resume(struct device *dev)
 {
         struct pm_clk_data *pcd = __to_pcd(dev);
         struct pm_clock_entry *ce;
+        unsigned long flags;
 
         dev_dbg(dev, "%s()\n", __func__);
 
         if (!pcd)
                 return 0;
 
-        mutex_lock(&pcd->lock);
+        spin_lock_irqsave(&pcd->lock, flags);
 
         list_for_each_entry(ce, &pcd->clock_list, node) {
                 if (ce->status == PCE_STATUS_NONE)
@@ -269,7 +271,7 @@ int pm_clk_resume(struct device *dev)
                 }
         }
 
-        mutex_unlock(&pcd->lock);
+        spin_unlock_irqrestore(&pcd->lock, flags);
 
         return 0;
 }
@@ -344,6 +346,7 @@ int pm_clk_suspend(struct device *dev)
 {
         struct pm_clk_data *pcd = __to_pcd(dev);
         struct pm_clock_entry *ce;
+        unsigned long flags;
 
         dev_dbg(dev, "%s()\n", __func__);
 
@@ -351,12 +354,12 @@ int pm_clk_suspend(struct device *dev)
         if (!pcd || !dev->driver)
                 return 0;
 
-        mutex_lock(&pcd->lock);
+        spin_lock_irqsave(&pcd->lock, flags);
 
         list_for_each_entry_reverse(ce, &pcd->clock_list, node)
                 clk_disable(ce->clk);
 
-        mutex_unlock(&pcd->lock);
+        spin_unlock_irqrestore(&pcd->lock, flags);
 
         return 0;
 }
@@ -369,6 +372,7 @@ int pm_clk_resume(struct device *dev)
 {
         struct pm_clk_data *pcd = __to_pcd(dev);
         struct pm_clock_entry *ce;
+        unsigned long flags;
 
         dev_dbg(dev, "%s()\n", __func__);
 
@@ -376,12 +380,12 @@ int pm_clk_resume(struct device *dev)
         if (!pcd || !dev->driver)
                 return 0;
 
-        mutex_lock(&pcd->lock);
+        spin_lock_irqsave(&pcd->lock, flags);
 
         list_for_each_entry(ce, &pcd->clock_list, node)
                 clk_enable(ce->clk);
 
-        mutex_unlock(&pcd->lock);
+        spin_unlock_irqrestore(&pcd->lock, flags);
 
         return 0;
 }
diff --git a/drivers/base/power/domain.c b/drivers/base/power/domain.c
index be8714aa9dd6..1c374579407c 100644
--- a/drivers/base/power/domain.c
+++ b/drivers/base/power/domain.c
@@ -80,7 +80,6 @@ static void genpd_set_active(struct generic_pm_domain *genpd)
 int pm_genpd_poweron(struct generic_pm_domain *genpd)
 {
         struct generic_pm_domain *parent = genpd->parent;
-        DEFINE_WAIT(wait);
         int ret = 0;
 
  start:
@@ -112,7 +111,7 @@ int pm_genpd_poweron(struct generic_pm_domain *genpd)
         }
 
         if (genpd->power_on) {
-                int ret = genpd->power_on(genpd);
+                ret = genpd->power_on(genpd);
                 if (ret)
                         goto out;
         }
@@ -461,6 +460,21 @@ static int pm_genpd_runtime_resume(struct device *dev)
         return 0;
 }
 
+/**
+ * pm_genpd_poweroff_unused - Power off all PM domains with no devices in use.
+ */
+void pm_genpd_poweroff_unused(void)
+{
+        struct generic_pm_domain *genpd;
+
+        mutex_lock(&gpd_list_lock);
+
+        list_for_each_entry(genpd, &gpd_list, gpd_list_node)
+                genpd_queue_power_off_work(genpd);
+
+        mutex_unlock(&gpd_list_lock);
+}
+
 #else
 
 static inline void genpd_power_off_work_fn(struct work_struct *work) {}
@@ -1256,18 +1270,3 @@ void pm_genpd_init(struct generic_pm_domain *genpd,
         list_add(&genpd->gpd_list_node, &gpd_list);
         mutex_unlock(&gpd_list_lock);
 }
-
-/**
- * pm_genpd_poweroff_unused - Power off all PM domains with no devices in use.
- */
-void pm_genpd_poweroff_unused(void)
-{
-        struct generic_pm_domain *genpd;
-
-        mutex_lock(&gpd_list_lock);
-
-        list_for_each_entry(genpd, &gpd_list, gpd_list_node)
-                genpd_queue_power_off_work(genpd);
-
-        mutex_unlock(&gpd_list_lock);
-}
diff --git a/drivers/base/power/runtime.c b/drivers/base/power/runtime.c
index 8dc247c974af..acb3f83b8079 100644
--- a/drivers/base/power/runtime.c
+++ b/drivers/base/power/runtime.c
@@ -226,11 +226,17 @@ static int rpm_idle(struct device *dev, int rpmflags)
                 callback = NULL;
 
         if (callback) {
-                spin_unlock_irq(&dev->power.lock);
+                if (dev->power.irq_safe)
+                        spin_unlock(&dev->power.lock);
+                else
+                        spin_unlock_irq(&dev->power.lock);
 
                 callback(dev);
 
-                spin_lock_irq(&dev->power.lock);
+                if (dev->power.irq_safe)
+                        spin_lock(&dev->power.lock);
+                else
+                        spin_lock_irq(&dev->power.lock);
         }
 
         dev->power.idle_notification = false;
diff --git a/drivers/base/regmap/regmap-i2c.c b/drivers/base/regmap/regmap-i2c.c
index c2231ff06cbc..c4f7a45cd2c3 100644
--- a/drivers/base/regmap/regmap-i2c.c
+++ b/drivers/base/regmap/regmap-i2c.c
@@ -113,3 +113,4 @@ struct regmap *regmap_init_i2c(struct i2c_client *i2c,
 }
 EXPORT_SYMBOL_GPL(regmap_init_i2c);
 
+MODULE_LICENSE("GPL");
diff --git a/drivers/base/regmap/regmap-spi.c b/drivers/base/regmap/regmap-spi.c
index 4deba0621bc7..f8396945d6ed 100644
--- a/drivers/base/regmap/regmap-spi.c
+++ b/drivers/base/regmap/regmap-spi.c
@@ -13,6 +13,7 @@
 #include <linux/regmap.h>
 #include <linux/spi/spi.h>
 #include <linux/init.h>
+#include <linux/module.h>
 
 static int regmap_spi_write(struct device *dev, const void *data, size_t count)
 {
@@ -70,3 +71,5 @@ struct regmap *regmap_init_spi(struct spi_device *spi,
         return regmap_init(&spi->dev, &regmap_spi, config);
 }
 EXPORT_SYMBOL_GPL(regmap_init_spi);
+
+MODULE_LICENSE("GPL");
diff --git a/drivers/base/regmap/regmap.c b/drivers/base/regmap/regmap.c
index cf3565cae93d..20663f8dae45 100644
--- a/drivers/base/regmap/regmap.c
+++ b/drivers/base/regmap/regmap.c
@@ -168,13 +168,11 @@ struct regmap *regmap_init(struct device *dev,
         map->work_buf = kmalloc(map->format.buf_size, GFP_KERNEL);
         if (map->work_buf == NULL) {
                 ret = -ENOMEM;
-                goto err_bus;
+                goto err_map;
         }
 
         return map;
 
-err_bus:
-        module_put(map->bus->owner);
 err_map:
         kfree(map);
 err:
@@ -188,7 +186,6 @@ EXPORT_SYMBOL_GPL(regmap_init);
 void regmap_exit(struct regmap *map)
 {
         kfree(map->work_buf);
-        module_put(map->bus->owner);
         kfree(map);
 }
 EXPORT_SYMBOL_GPL(regmap_exit);
@@ -317,7 +314,7 @@ static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
                 u8[0] |= map->bus->read_flag_mask;
 
         ret = map->bus->read(map->dev, map->work_buf, map->format.reg_bytes,
-                             val, map->format.val_bytes);
+                             val, val_len);
         if (ret != 0)
                 return ret;
 
diff --git a/drivers/bcma/main.c b/drivers/bcma/main.c
index 873e2e4ac55f..73b7b1a18fab 100644
--- a/drivers/bcma/main.c
+++ b/drivers/bcma/main.c
@@ -15,6 +15,7 @@ MODULE_LICENSE("GPL");
 static int bcma_bus_match(struct device *dev, struct device_driver *drv);
 static int bcma_device_probe(struct device *dev);
 static int bcma_device_remove(struct device *dev);
+static int bcma_device_uevent(struct device *dev, struct kobj_uevent_env *env);
 
 static ssize_t manuf_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
@@ -49,6 +50,7 @@ static struct bus_type bcma_bus_type = {
         .match          = bcma_bus_match,
         .probe          = bcma_device_probe,
         .remove         = bcma_device_remove,
+        .uevent         = bcma_device_uevent,
         .dev_attrs      = bcma_device_attrs,
 };
 
@@ -227,6 +229,16 @@ static int bcma_device_remove(struct device *dev)
         return 0;
 }
 
+static int bcma_device_uevent(struct device *dev, struct kobj_uevent_env *env)
+{
+        struct bcma_device *core = container_of(dev, struct bcma_device, dev);
+
+        return add_uevent_var(env,
+                              "MODALIAS=bcma:m%04Xid%04Xrev%02Xcl%02X",
+                              core->id.manuf, core->id.id,
+                              core->id.rev, core->id.class);
+}
+
 static int __init bcma_modinit(void)
 {
         int err;
diff --git a/drivers/block/Kconfig b/drivers/block/Kconfig
index 717d6e4e18d3..6f07ec1c2f58 100644
--- a/drivers/block/Kconfig
+++ b/drivers/block/Kconfig
@@ -256,6 +256,21 @@ config BLK_DEV_LOOP
 
           Most users will answer N here.
 
+config BLK_DEV_LOOP_MIN_COUNT
+        int "Number of loop devices to pre-create at init time"
+        depends on BLK_DEV_LOOP
+        default 8
+        help
+          Static number of loop devices to be unconditionally pre-created
+          at init time.
+
+          This default value can be overwritten on the kernel command
+          line or with module-parameter loop.max_loop.
+
+          The historic default is 8. If a late 2011 version of losetup(8)
+          is used, it can be set to 0, since needed loop devices can be
+          dynamically allocated with the /dev/loop-control interface.
+
 config BLK_DEV_CRYPTOLOOP
         tristate "Cryptoloop Support"
         select CRYPTO
@@ -471,7 +486,7 @@ config XEN_BLKDEV_FRONTEND
           in another domain which drives the actual block device.
 
 config XEN_BLKDEV_BACKEND
-        tristate "Block-device backend driver"
+        tristate "Xen block-device backend driver"
         depends on XEN_BACKEND
         help
           The block-device backend driver allows the kernel to export its
diff --git a/drivers/block/drbd/drbd_nl.c b/drivers/block/drbd/drbd_nl.c
index 515bcd948a43..0feab261e295 100644
--- a/drivers/block/drbd/drbd_nl.c
+++ b/drivers/block/drbd/drbd_nl.c
@@ -1829,10 +1829,10 @@ static int drbd_nl_syncer_conf(struct drbd_conf *mdev, struct drbd_nl_cfg_req *n
 
         /* silently ignore cpu mask on UP kernel */
         if (nr_cpu_ids > 1 && sc.cpu_mask[0] != 0) {
-                err = __bitmap_parse(sc.cpu_mask, 32, 0,
+                err = bitmap_parse(sc.cpu_mask, 32,
                                 cpumask_bits(new_cpu_mask), nr_cpu_ids);
                 if (err) {
-                        dev_warn(DEV, "__bitmap_parse() failed with %d\n", err);
+                        dev_warn(DEV, "bitmap_parse() failed with %d\n", err);
                         retcode = ERR_CPU_MASK_PARSE;
                         goto fail;
                 }
diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index 76c8da78212b..4720c7ade0ae 100644
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -75,11 +75,11 @@
 #include <linux/kthread.h>
 #include <linux/splice.h>
 #include <linux/sysfs.h>
-
+#include <linux/miscdevice.h>
 #include <asm/uaccess.h>
 
-static LIST_HEAD(loop_devices);
-static DEFINE_MUTEX(loop_devices_mutex);
+static DEFINE_IDR(loop_index_idr);
+static DEFINE_MUTEX(loop_index_mutex);
 
 static int max_part;
 static int part_shift;
@@ -722,17 +722,10 @@ static inline int is_loop_device(struct file *file)
 static ssize_t loop_attr_show(struct device *dev, char *page,
                               ssize_t (*callback)(struct loop_device *, char *))
 {
-        struct loop_device *l, *lo = NULL;
-
-        mutex_lock(&loop_devices_mutex);
-        list_for_each_entry(l, &loop_devices, lo_list)
-                if (disk_to_dev(l->lo_disk) == dev) {
-                        lo = l;
-                        break;
-                }
-        mutex_unlock(&loop_devices_mutex);
+        struct gendisk *disk = dev_to_disk(dev);
+        struct loop_device *lo = disk->private_data;
 
-        return lo ? callback(lo, page) : -EIO;
+        return callback(lo, page);
 }
 
 #define LOOP_ATTR_RO(_name)                                             \
@@ -750,10 +743,10 @@ static ssize_t loop_attr_backing_file_show(struct loop_device *lo, char *buf)
         ssize_t ret;
         char *p = NULL;
 
-        mutex_lock(&lo->lo_ctl_mutex);
+        spin_lock_irq(&lo->lo_lock);
         if (lo->lo_backing_file)
                 p = d_path(&lo->lo_backing_file->f_path, buf, PAGE_SIZE - 1);
-        mutex_unlock(&lo->lo_ctl_mutex);
+        spin_unlock_irq(&lo->lo_lock);
 
         if (IS_ERR_OR_NULL(p))
                 ret = PTR_ERR(p);
@@ -1007,7 +1000,9 @@ static int loop_clr_fd(struct loop_device *lo, struct block_device *bdev)
 
         kthread_stop(lo->lo_thread);
 
+        spin_lock_irq(&lo->lo_lock);
         lo->lo_backing_file = NULL;
+        spin_unlock_irq(&lo->lo_lock);
 
         loop_release_xfer(lo);
         lo->transfer = NULL;
@@ -1485,13 +1480,22 @@ static int lo_compat_ioctl(struct block_device *bdev, fmode_t mode,
 
 static int lo_open(struct block_device *bdev, fmode_t mode)
 {
-        struct loop_device *lo = bdev->bd_disk->private_data;
+        struct loop_device *lo;
+        int err = 0;
+
+        mutex_lock(&loop_index_mutex);
+        lo = bdev->bd_disk->private_data;
+        if (!lo) {
+                err = -ENXIO;
+                goto out;
+        }
 
         mutex_lock(&lo->lo_ctl_mutex);
         lo->lo_refcnt++;
         mutex_unlock(&lo->lo_ctl_mutex);
-
-        return 0;
+out:
+        mutex_unlock(&loop_index_mutex);
+        return err;
 }
 
 static int lo_release(struct gendisk *disk, fmode_t mode)
@@ -1557,40 +1561,71 @@ int loop_register_transfer(struct loop_func_table *funcs)
         return 0;
 }
 
+static int unregister_transfer_cb(int id, void *ptr, void *data)
+{
+        struct loop_device *lo = ptr;
+        struct loop_func_table *xfer = data;
+
+        mutex_lock(&lo->lo_ctl_mutex);
+        if (lo->lo_encryption == xfer)
+                loop_release_xfer(lo);
+        mutex_unlock(&lo->lo_ctl_mutex);
+        return 0;
+}
+
 int loop_unregister_transfer(int number)
 {
         unsigned int n = number;
-        struct loop_device *lo;
         struct loop_func_table *xfer;
 
         if (n == 0 || n >= MAX_LO_CRYPT || (xfer = xfer_funcs[n]) == NULL)
                 return -EINVAL;
 
         xfer_funcs[n] = NULL;
-
-        list_for_each_entry(lo, &loop_devices, lo_list) {
-                mutex_lock(&lo->lo_ctl_mutex);
-
-                if (lo->lo_encryption == xfer)
-                        loop_release_xfer(lo);
-
-                mutex_unlock(&lo->lo_ctl_mutex);
-        }
-
+        idr_for_each(&loop_index_idr, &unregister_transfer_cb, xfer);
         return 0;
 }
 
 EXPORT_SYMBOL(loop_register_transfer);
 EXPORT_SYMBOL(loop_unregister_transfer);
 
-static struct loop_device *loop_alloc(int i)
+static int loop_add(struct loop_device **l, int i)
 {
         struct loop_device *lo;
         struct gendisk *disk;
+        int err;
 
         lo = kzalloc(sizeof(*lo), GFP_KERNEL);
-        if (!lo)
+        if (!lo) {
+                err = -ENOMEM;
                 goto out;
+        }
+
+        err = idr_pre_get(&loop_index_idr, GFP_KERNEL);
+        if (err < 0)
+                goto out_free_dev;
+
+        if (i >= 0) {
+                int m;
+
+                /* create specific i in the index */
+                err = idr_get_new_above(&loop_index_idr, lo, i, &m);
+                if (err >= 0 && i != m) {
+                        idr_remove(&loop_index_idr, m);
+                        err = -EEXIST;
+                }
+        } else if (i == -1) {
+                int m;
+
+                /* get next free nr */
+                err = idr_get_new(&loop_index_idr, lo, &m);
+                if (err >= 0)
+                        i = m;
+        } else {
+                err = -EINVAL;
+        }
+        if (err < 0)
+                goto out_free_dev;
 
         lo->lo_queue = blk_alloc_queue(GFP_KERNEL);
         if (!lo->lo_queue)
@@ -1611,81 +1646,158 @@ static struct loop_device *loop_alloc(int i)
         disk->private_data      = lo;
         disk->queue             = lo->lo_queue;
         sprintf(disk->disk_name, "loop%d", i);
-        return lo;
+        add_disk(disk);
+        *l = lo;
+        return lo->lo_number;
 
 out_free_queue:
         blk_cleanup_queue(lo->lo_queue);
 out_free_dev:
         kfree(lo);
 out:
-        return NULL;
+        return err;
 }
 
-static void loop_free(struct loop_device *lo)
+static void loop_remove(struct loop_device *lo)
 {
+        del_gendisk(lo->lo_disk);
         blk_cleanup_queue(lo->lo_queue);
         put_disk(lo->lo_disk);
-        list_del(&lo->lo_list);
         kfree(lo);
 }
 
-static struct loop_device *loop_init_one(int i)
+static int find_free_cb(int id, void *ptr, void *data)
+{
+        struct loop_device *lo = ptr;
+        struct loop_device **l = data;
+
+        if (lo->lo_state == Lo_unbound) {
+                *l = lo;
+                return 1;
+        }
+        return 0;
+}
+
+static int loop_lookup(struct loop_device **l, int i)
 {
         struct loop_device *lo;
+        int ret = -ENODEV;
 
-        list_for_each_entry(lo, &loop_devices, lo_list) {
-                if (lo->lo_number == i)
-                        return lo;
+        if (i < 0) {
+                int err;
+
+                err = idr_for_each(&loop_index_idr, &find_free_cb, &lo);
+                if (err == 1) {
+                        *l = lo;
+                        ret = lo->lo_number;
+                }
+                goto out;
         }
 
-        lo = loop_alloc(i);
+        /* lookup and return a specific i */
+        lo = idr_find(&loop_index_idr, i);
         if (lo) {
-                add_disk(lo->lo_disk);
-                list_add_tail(&lo->lo_list, &loop_devices);
+                *l = lo;
+                ret = lo->lo_number;
         }
-        return lo;
-}
-
-static void loop_del_one(struct loop_device *lo)
-{
-        del_gendisk(lo->lo_disk);
-        loop_free(lo);
+out:
+        return ret;
 }
 
 static struct kobject *loop_probe(dev_t dev, int *part, void *data)
 {
         struct loop_device *lo;
         struct kobject *kobj;
+        int err;
 
-        mutex_lock(&loop_devices_mutex);
-        lo = loop_init_one(MINOR(dev) >> part_shift);
-        kobj = lo ? get_disk(lo->lo_disk) : ERR_PTR(-ENOMEM);
-        mutex_unlock(&loop_devices_mutex);
+        mutex_lock(&loop_index_mutex);
+        err = loop_lookup(&lo, MINOR(dev) >> part_shift);
+        if (err < 0)
+                err = loop_add(&lo, MINOR(dev) >> part_shift);
+        if (err < 0)
+                kobj = ERR_PTR(err);
+        else
+                kobj = get_disk(lo->lo_disk);
+        mutex_unlock(&loop_index_mutex);
 
         *part = 0;
         return kobj;
 }
 
+static long loop_control_ioctl(struct file *file, unsigned int cmd,
+                               unsigned long parm)
+{
+        struct loop_device *lo;
+        int ret = -ENOSYS;
+
+        mutex_lock(&loop_index_mutex);
+        switch (cmd) {
+        case LOOP_CTL_ADD:
+                ret = loop_lookup(&lo, parm);
+                if (ret >= 0) {
+                        ret = -EEXIST;
+                        break;
+                }
+                ret = loop_add(&lo, parm);
+                break;
+        case LOOP_CTL_REMOVE:
+                ret = loop_lookup(&lo, parm);
+                if (ret < 0)
+                        break;
+                mutex_lock(&lo->lo_ctl_mutex);
+                if (lo->lo_state != Lo_unbound) {
+                        ret = -EBUSY;
+                        mutex_unlock(&lo->lo_ctl_mutex);
+                        break;
+                }
+                if (lo->lo_refcnt > 0) {
+                        ret = -EBUSY;
+                        mutex_unlock(&lo->lo_ctl_mutex);
+                        break;
+                }
+                lo->lo_disk->private_data = NULL;
+                mutex_unlock(&lo->lo_ctl_mutex);
+                idr_remove(&loop_index_idr, lo->lo_number);
+                loop_remove(lo);
+                break;
+        case LOOP_CTL_GET_FREE:
+                ret = loop_lookup(&lo, -1);
+                if (ret >= 0)
+                        break;
+                ret = loop_add(&lo, -1);
+        }
+        mutex_unlock(&loop_index_mutex);
+
+        return ret;
+}
+
+static const struct file_operations loop_ctl_fops = {
+        .open           = nonseekable_open,
+        .unlocked_ioctl = loop_control_ioctl,
+        .compat_ioctl   = loop_control_ioctl,
+        .owner          = THIS_MODULE,
+        .llseek         = noop_llseek,
+};
+
+static struct miscdevice loop_misc = {
+        .minor          = LOOP_CTRL_MINOR,
+        .name           = "loop-control",
+        .fops           = &loop_ctl_fops,
+};
+
+MODULE_ALIAS_MISCDEV(LOOP_CTRL_MINOR);
+MODULE_ALIAS("devname:loop-control");
+
 static int __init loop_init(void)
 {
         int i, nr;
         unsigned long range;
-        struct loop_device *lo, *next;
+        struct loop_device *lo;
+        int err;
 
-        /*
-         * loop module now has a feature to instantiate underlying device
-         * structure on-demand, provided that there is an access dev node.
-         * However, this will not work well with user space tool that doesn't
-         * know about such "feature".  In order to not break any existing
-         * tool, we do the following:
-         *
-         * (1) if max_loop is specified, create that many upfront, and this
-         *     also becomes a hard limit.
-         * (2) if max_loop is not specified, create 8 loop device on module
-         *     load, user can further extend loop device by create dev node
-         *     themselves and have kernel automatically instantiate actual
-         *     device on-demand.
-         */
+        err = misc_register(&loop_misc);
+        if (err < 0)
+                return err;
 
         part_shift = 0;
         if (max_part > 0) {
@@ -1708,57 +1820,60 @@ static int __init loop_init(void)
         if (max_loop > 1UL << (MINORBITS - part_shift))
                 return -EINVAL;
 
+        /*
+         * If max_loop is specified, create that many devices upfront.
+         * This also becomes a hard limit. If max_loop is not specified,
+         * create CONFIG_BLK_DEV_LOOP_MIN_COUNT loop devices at module
+         * init time. Loop devices can be requested on-demand with the
+         * /dev/loop-control interface, or be instantiated by accessing
+         * a 'dead' device node.
+         */
         if (max_loop) {
                 nr = max_loop;
                 range = max_loop << part_shift;
         } else {
-                nr = 8;
+                nr = CONFIG_BLK_DEV_LOOP_MIN_COUNT;
                 range = 1UL << MINORBITS;
         }
 
         if (register_blkdev(LOOP_MAJOR, "loop"))
                 return -EIO;
 
-        for (i = 0; i < nr; i++) {
-                lo = loop_alloc(i);
-                if (!lo)
-                        goto Enomem;
-                list_add_tail(&lo->lo_list, &loop_devices);
-        }
-
-        /* point of no return */
-
-        list_for_each_entry(lo, &loop_devices, lo_list)
-                add_disk(lo->lo_disk);
-
         blk_register_region(MKDEV(LOOP_MAJOR, 0), range,
                                   THIS_MODULE, loop_probe, NULL, NULL);
 
+        /* pre-create number of devices given by config or max_loop */
+        mutex_lock(&loop_index_mutex);
+        for (i = 0; i < nr; i++)
+                loop_add(&lo, i);
+        mutex_unlock(&loop_index_mutex);
+
         printk(KERN_INFO "loop: module loaded\n");
         return 0;
+}
 
-Enomem:
-        printk(KERN_INFO "loop: out of memory\n");
-
-        list_for_each_entry_safe(lo, next, &loop_devices, lo_list)
-                loop_free(lo);
+static int loop_exit_cb(int id, void *ptr, void *data)
+{
+        struct loop_device *lo = ptr;
 
-        unregister_blkdev(LOOP_MAJOR, "loop");
-        return -ENOMEM;
+        loop_remove(lo);
+        return 0;
 }
 
 static void __exit loop_exit(void)
 {
         unsigned long range;
-        struct loop_device *lo, *next;
 
         range = max_loop ? max_loop << part_shift : 1UL << MINORBITS;
 
-        list_for_each_entry_safe(lo, next, &loop_devices, lo_list)
-                loop_del_one(lo);
+        idr_for_each(&loop_index_idr, &loop_exit_cb, NULL);
+        idr_remove_all(&loop_index_idr);
+        idr_destroy(&loop_index_idr);
 
         blk_unregister_region(MKDEV(LOOP_MAJOR, 0), range);
         unregister_blkdev(LOOP_MAJOR, "loop");
+
+        misc_deregister(&loop_misc);
 }
 
 module_init(loop_init);
diff --git a/drivers/block/swim3.c b/drivers/block/swim3.c
index 773bfa792777..ae3e167e17ad 100644
--- a/drivers/block/swim3.c
+++ b/drivers/block/swim3.c
@@ -1184,6 +1184,7 @@ static struct of_device_id swim3_match[] =
         {
         .compatible     = "swim3"
         },
+        { /* end of list */ }
 };
 
 static struct macio_driver swim3_driver =
diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c
index b536a9cef917..9ea8c2576c70 100644
--- a/drivers/block/xen-blkfront.c
+++ b/drivers/block/xen-blkfront.c
@@ -123,8 +123,8 @@ static DEFINE_SPINLOCK(minor_lock);
 #define BLKIF_MINOR_EXT(dev) ((dev)&(~EXTENDED))
 #define EMULATED_HD_DISK_MINOR_OFFSET (0)
 #define EMULATED_HD_DISK_NAME_OFFSET (EMULATED_HD_DISK_MINOR_OFFSET / 256)
-#define EMULATED_SD_DISK_MINOR_OFFSET (EMULATED_HD_DISK_MINOR_OFFSET + (4 * 16))
-#define EMULATED_SD_DISK_NAME_OFFSET (EMULATED_HD_DISK_NAME_OFFSET + 4)
+#define EMULATED_SD_DISK_MINOR_OFFSET (0)
+#define EMULATED_SD_DISK_NAME_OFFSET (EMULATED_SD_DISK_MINOR_OFFSET / 256)
 
 #define DEV_NAME        "xvd"   /* name in /dev */
 
@@ -529,7 +529,7 @@ static int xlvbd_alloc_gendisk(blkif_sector_t capacity,
                 minor = BLKIF_MINOR_EXT(info->vdevice);
                 nr_parts = PARTS_PER_EXT_DISK;
                 offset = minor / nr_parts;
-                if (xen_hvm_domain() && offset <= EMULATED_HD_DISK_NAME_OFFSET + 4)
+                if (xen_hvm_domain() && offset < EMULATED_HD_DISK_NAME_OFFSET + 4)
                         printk(KERN_WARNING "blkfront: vdevice 0x%x might conflict with "
                                         "emulated IDE disks,\n\t choose an xvd device name"
                                         "from xvde on\n", info->vdevice);
diff --git a/drivers/bluetooth/ath3k.c b/drivers/bluetooth/ath3k.c
index a5854735bb2e..db7cb8111fbe 100644
--- a/drivers/bluetooth/ath3k.c
+++ b/drivers/bluetooth/ath3k.c
@@ -63,6 +63,7 @@ static struct usb_device_id ath3k_table[] = {
         /* Atheros AR3011 with sflash firmware*/
         { USB_DEVICE(0x0CF3, 0x3002) },
         { USB_DEVICE(0x13d3, 0x3304) },
+        { USB_DEVICE(0x0930, 0x0215) },
 
         /* Atheros AR9285 Malbec with sflash firmware */
         { USB_DEVICE(0x03F0, 0x311D) },
diff --git a/drivers/bluetooth/btusb.c b/drivers/bluetooth/btusb.c
index 91d13a9e8c65..3ef476070baf 100644
--- a/drivers/bluetooth/btusb.c
+++ b/drivers/bluetooth/btusb.c
@@ -106,6 +106,7 @@ static struct usb_device_id blacklist_table[] = {
         /* Atheros 3011 with sflash firmware */
         { USB_DEVICE(0x0cf3, 0x3002), .driver_info = BTUSB_IGNORE },
         { USB_DEVICE(0x13d3, 0x3304), .driver_info = BTUSB_IGNORE },
+        { USB_DEVICE(0x0930, 0x0215), .driver_info = BTUSB_IGNORE },
 
         /* Atheros AR9285 Malbec with sflash firmware */
         { USB_DEVICE(0x03f0, 0x311d), .driver_info = BTUSB_IGNORE },
@@ -256,7 +257,9 @@ static void btusb_intr_complete(struct urb *urb)
 
         err = usb_submit_urb(urb, GFP_ATOMIC);
         if (err < 0) {
-                if (err != -EPERM)
+                /* -EPERM: urb is being killed;
+                 * -ENODEV: device got disconnected */
+                if (err != -EPERM && err != -ENODEV)
                         BT_ERR("%s urb %p failed to resubmit (%d)",
                                                 hdev->name, urb, -err);
                 usb_unanchor_urb(urb);
@@ -341,7 +344,9 @@ static void btusb_bulk_complete(struct urb *urb)
 
         err = usb_submit_urb(urb, GFP_ATOMIC);
         if (err < 0) {
-                if (err != -EPERM)
+                /* -EPERM: urb is being killed;
+                 * -ENODEV: device got disconnected */
+                if (err != -EPERM && err != -ENODEV)
                         BT_ERR("%s urb %p failed to resubmit (%d)",
                                                 hdev->name, urb, -err);
                 usb_unanchor_urb(urb);
@@ -431,7 +436,9 @@ static void btusb_isoc_complete(struct urb *urb)
 
         err = usb_submit_urb(urb, GFP_ATOMIC);
         if (err < 0) {
-                if (err != -EPERM)
+                /* -EPERM: urb is being killed;
+                 * -ENODEV: device got disconnected */
+                if (err != -EPERM && err != -ENODEV)
                         BT_ERR("%s urb %p failed to resubmit (%d)",
                                                 hdev->name, urb, -err);
                 usb_unanchor_urb(urb);
diff --git a/drivers/cdrom/cdrom.c b/drivers/cdrom/cdrom.c
index 75fb965b8f72..f997c27d79e2 100644
--- a/drivers/cdrom/cdrom.c
+++ b/drivers/cdrom/cdrom.c
@@ -1929,11 +1929,17 @@ static int dvd_read_manufact(struct cdrom_device_info *cdi, dvd_struct *s,
                 goto out;
 
         s->manufact.len = buf[0] << 8 | buf[1];
-        if (s->manufact.len < 0 || s->manufact.len > 2048) {
+        if (s->manufact.len < 0) {
                 cdinfo(CD_WARNING, "Received invalid manufacture info length"
                                    " (%d)\n", s->manufact.len);
                 ret = -EIO;
         } else {
+                if (s->manufact.len > 2048) {
+                        cdinfo(CD_WARNING, "Received invalid manufacture info "
+                                        "length (%d): truncating to 2048\n",
+                                        s->manufact.len);
+                        s->manufact.len = 2048;
+                }
                 memcpy(s->manufact.value, &buf[4], s->manufact.len);
         }
 
diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index 49502bc5360a..423fd56bf612 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -616,5 +616,16 @@ config MSM_SMD_PKT
           Enables userspace clients to read and write to some packet SMD
           ports via device interface for MSM chipset.
 
+config TILE_SROM
+        bool "Character-device access via hypervisor to the Tilera SPI ROM"
+        depends on TILE
+        default y
+        ---help---
+          This device provides character-level read-write access
+          to the SROM, typically via the "0", "1", and "2" devices
+          in /dev/srom/.  The Tilera hypervisor makes the flash
+          device appear much like a simple EEPROM, and knows
+          how to partition a single ROM for multiple purposes.
+
 endmenu
 
diff --git a/drivers/char/Makefile b/drivers/char/Makefile
index 7a00672bd85d..32762ba769c2 100644
--- a/drivers/char/Makefile
+++ b/drivers/char/Makefile
@@ -63,3 +63,5 @@ obj-$(CONFIG_RAMOOPS)		+= ramoops.o
 
 obj-$(CONFIG_JS_RTC)            += js-rtc.o
 js-rtc-y = rtc.o
+
+obj-$(CONFIG_TILE_SROM)         += tile-srom.o
diff --git a/drivers/char/msm_smd_pkt.c b/drivers/char/msm_smd_pkt.c
index b6f8a65c9960..8eca55deb3a3 100644
--- a/drivers/char/msm_smd_pkt.c
+++ b/drivers/char/msm_smd_pkt.c
@@ -379,9 +379,8 @@ static int __init smd_pkt_init(void)
         for (i = 0; i < NUM_SMD_PKT_PORTS; ++i) {
                 smd_pkt_devp[i] = kzalloc(sizeof(struct smd_pkt_dev),
                                           GFP_KERNEL);
-                if (IS_ERR(smd_pkt_devp[i])) {
-                        r = PTR_ERR(smd_pkt_devp[i]);
-                        pr_err("kmalloc() failed %d\n", r);
+                if (!smd_pkt_devp[i]) {
+                        pr_err("kmalloc() failed\n");
                         goto clean_cdevs;
                 }
 
diff --git a/drivers/char/ramoops.c b/drivers/char/ramoops.c
index fca0c51bbc90..810aff9e750f 100644
--- a/drivers/char/ramoops.c
+++ b/drivers/char/ramoops.c
@@ -147,6 +147,14 @@ static int __init ramoops_probe(struct platform_device *pdev)
         cxt->phys_addr = pdata->mem_address;
         cxt->record_size = pdata->record_size;
         cxt->dump_oops = pdata->dump_oops;
+        /*
+         * Update the module parameter variables as well so they are visible
+         * through /sys/module/ramoops/parameters/
+         */
+        mem_size = pdata->mem_size;
+        mem_address = pdata->mem_address;
+        record_size = pdata->record_size;
+        dump_oops = pdata->dump_oops;
 
         if (!request_mem_region(cxt->phys_addr, cxt->size, "ramoops")) {
                 pr_err("request mem region failed\n");
diff --git a/drivers/char/random.c b/drivers/char/random.c
index 729281961f22..c35a785005b0 100644
--- a/drivers/char/random.c
+++ b/drivers/char/random.c
@@ -1300,345 +1300,14 @@ ctl_table random_table[] = {
 };
 #endif  /* CONFIG_SYSCTL */
 
-/********************************************************************
- *
- * Random functions for networking
- *
- ********************************************************************/
-
-/*
- * TCP initial sequence number picking.  This uses the random number
- * generator to pick an initial secret value.  This value is hashed
- * along with the TCP endpoint information to provide a unique
- * starting point for each pair of TCP endpoints.  This defeats
- * attacks which rely on guessing the initial TCP sequence number.
- * This algorithm was suggested by Steve Bellovin.
- *
- * Using a very strong hash was taking an appreciable amount of the total
- * TCP connection establishment time, so this is a weaker hash,
- * compensated for by changing the secret periodically.
- */
-
-/* F, G and H are basic MD4 functions: selection, majority, parity */
-#define F(x, y, z) ((z) ^ ((x) & ((y) ^ (z))))
-#define G(x, y, z) (((x) & (y)) + (((x) ^ (y)) & (z)))
-#define H(x, y, z) ((x) ^ (y) ^ (z))
-
-/*
- * The generic round function.  The application is so specific that
- * we don't bother protecting all the arguments with parens, as is generally
- * good macro practice, in favor of extra legibility.
- * Rotation is separate from addition to prevent recomputation
- */
-#define ROUND(f, a, b, c, d, x, s)      \
-        (a += f(b, c, d) + x, a = (a << s) | (a >> (32 - s)))
-#define K1 0
-#define K2 013240474631UL
-#define K3 015666365641UL
-
-#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
-
-static __u32 twothirdsMD4Transform(__u32 const buf[4], __u32 const in[12])
-{
-        __u32 a = buf[0], b = buf[1], c = buf[2], d = buf[3];
-
-        /* Round 1 */
-        ROUND(F, a, b, c, d, in[ 0] + K1,  3);
-        ROUND(F, d, a, b, c, in[ 1] + K1,  7);
-        ROUND(F, c, d, a, b, in[ 2] + K1, 11);
-        ROUND(F, b, c, d, a, in[ 3] + K1, 19);
-        ROUND(F, a, b, c, d, in[ 4] + K1,  3);
-        ROUND(F, d, a, b, c, in[ 5] + K1,  7);
-        ROUND(F, c, d, a, b, in[ 6] + K1, 11);
-        ROUND(F, b, c, d, a, in[ 7] + K1, 19);
-        ROUND(F, a, b, c, d, in[ 8] + K1,  3);
-        ROUND(F, d, a, b, c, in[ 9] + K1,  7);
-        ROUND(F, c, d, a, b, in[10] + K1, 11);
-        ROUND(F, b, c, d, a, in[11] + K1, 19);
-
-        /* Round 2 */
-        ROUND(G, a, b, c, d, in[ 1] + K2,  3);
-        ROUND(G, d, a, b, c, in[ 3] + K2,  5);
-        ROUND(G, c, d, a, b, in[ 5] + K2,  9);
-        ROUND(G, b, c, d, a, in[ 7] + K2, 13);
-        ROUND(G, a, b, c, d, in[ 9] + K2,  3);
-        ROUND(G, d, a, b, c, in[11] + K2,  5);
-        ROUND(G, c, d, a, b, in[ 0] + K2,  9);
-        ROUND(G, b, c, d, a, in[ 2] + K2, 13);
-        ROUND(G, a, b, c, d, in[ 4] + K2,  3);
-        ROUND(G, d, a, b, c, in[ 6] + K2,  5);
-        ROUND(G, c, d, a, b, in[ 8] + K2,  9);
-        ROUND(G, b, c, d, a, in[10] + K2, 13);
-
-        /* Round 3 */
-        ROUND(H, a, b, c, d, in[ 3] + K3,  3);
-        ROUND(H, d, a, b, c, in[ 7] + K3,  9);
-        ROUND(H, c, d, a, b, in[11] + K3, 11);
-        ROUND(H, b, c, d, a, in[ 2] + K3, 15);
-        ROUND(H, a, b, c, d, in[ 6] + K3,  3);
-        ROUND(H, d, a, b, c, in[10] + K3,  9);
-        ROUND(H, c, d, a, b, in[ 1] + K3, 11);
-        ROUND(H, b, c, d, a, in[ 5] + K3, 15);
-        ROUND(H, a, b, c, d, in[ 9] + K3,  3);
-        ROUND(H, d, a, b, c, in[ 0] + K3,  9);
-        ROUND(H, c, d, a, b, in[ 4] + K3, 11);
-        ROUND(H, b, c, d, a, in[ 8] + K3, 15);
-
-        return buf[1] + b; /* "most hashed" word */
-        /* Alternative: return sum of all words? */
-}
-#endif
-
-#undef ROUND
-#undef F
-#undef G
-#undef H
-#undef K1
-#undef K2
-#undef K3
-
-/* This should not be decreased so low that ISNs wrap too fast. */
-#define REKEY_INTERVAL (300 * HZ)
-/*
- * Bit layout of the tcp sequence numbers (before adding current time):
- * bit 24-31: increased after every key exchange
- * bit 0-23: hash(source,dest)
- *
- * The implementation is similar to the algorithm described
- * in the Appendix of RFC 1185, except that
- * - it uses a 1 MHz clock instead of a 250 kHz clock
- * - it performs a rekey every 5 minutes, which is equivalent
- *      to a (source,dest) tulple dependent forward jump of the
- *      clock by 0..2^(HASH_BITS+1)
- *
- * Thus the average ISN wraparound time is 68 minutes instead of
- * 4.55 hours.
- *
- * SMP cleanup and lock avoidance with poor man's RCU.
- *                      Manfred Spraul <manfred@colorfullife.com>
- *
- */
-#define COUNT_BITS 8
-#define COUNT_MASK ((1 << COUNT_BITS) - 1)
-#define HASH_BITS 24
-#define HASH_MASK ((1 << HASH_BITS) - 1)
+static u32 random_int_secret[MD5_MESSAGE_BYTES / 4] ____cacheline_aligned;
 
-static struct keydata {
-        __u32 count; /* already shifted to the final position */
-        __u32 secret[12];
-} ____cacheline_aligned ip_keydata[2];
-
-static unsigned int ip_cnt;
-
-static void rekey_seq_generator(struct work_struct *work);
-
-static DECLARE_DELAYED_WORK(rekey_work, rekey_seq_generator);
-
-/*
- * Lock avoidance:
- * The ISN generation runs lockless - it's just a hash over random data.
- * State changes happen every 5 minutes when the random key is replaced.
- * Synchronization is performed by having two copies of the hash function
- * state and rekey_seq_generator always updates the inactive copy.
- * The copy is then activated by updating ip_cnt.
- * The implementation breaks down if someone blocks the thread
- * that processes SYN requests for more than 5 minutes. Should never
- * happen, and even if that happens only a not perfectly compliant
- * ISN is generated, nothing fatal.
- */
-static void rekey_seq_generator(struct work_struct *work)
+static int __init random_int_secret_init(void)
 {
-        struct keydata *keyptr = &ip_keydata[1 ^ (ip_cnt & 1)];
-
-        get_random_bytes(keyptr->secret, sizeof(keyptr->secret));
-        keyptr->count = (ip_cnt & COUNT_MASK) << HASH_BITS;
-        smp_wmb();
-        ip_cnt++;
-        schedule_delayed_work(&rekey_work,
-                              round_jiffies_relative(REKEY_INTERVAL));
-}
-
-static inline struct keydata *get_keyptr(void)
-{
-        struct keydata *keyptr = &ip_keydata[ip_cnt & 1];
-
-        smp_rmb();
-
-        return keyptr;
-}
-
-static __init int seqgen_init(void)
-{
-        rekey_seq_generator(NULL);
+        get_random_bytes(random_int_secret, sizeof(random_int_secret));
         return 0;
 }
-late_initcall(seqgen_init);
-
-#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
-__u32 secure_tcpv6_sequence_number(__be32 *saddr, __be32 *daddr,
-                                   __be16 sport, __be16 dport)
-{
-        __u32 seq;
-        __u32 hash[12];
-        struct keydata *keyptr = get_keyptr();
-
-        /* The procedure is the same as for IPv4, but addresses are longer.
-         * Thus we must use twothirdsMD4Transform.
-         */
-
-        memcpy(hash, saddr, 16);
-        hash[4] = ((__force u16)sport << 16) + (__force u16)dport;
-        memcpy(&hash[5], keyptr->secret, sizeof(__u32) * 7);
-
-        seq = twothirdsMD4Transform((const __u32 *)daddr, hash) & HASH_MASK;
-        seq += keyptr->count;
-
-        seq += ktime_to_ns(ktime_get_real());
-
-        return seq;
-}
-EXPORT_SYMBOL(secure_tcpv6_sequence_number);
-#endif
-
-/*  The code below is shamelessly stolen from secure_tcp_sequence_number().
- *  All blames to Andrey V. Savochkin <saw@msu.ru>.
- */
-__u32 secure_ip_id(__be32 daddr)
-{
-        struct keydata *keyptr;
-        __u32 hash[4];
-
-        keyptr = get_keyptr();
-
-        /*
-         *  Pick a unique starting offset for each IP destination.
-         *  The dest ip address is placed in the starting vector,
-         *  which is then hashed with random data.
-         */
-        hash[0] = (__force __u32)daddr;
-        hash[1] = keyptr->secret[9];
-        hash[2] = keyptr->secret[10];
-        hash[3] = keyptr->secret[11];
-
-        return half_md4_transform(hash, keyptr->secret);
-}
-
-__u32 secure_ipv6_id(const __be32 daddr[4])
-{
-        const struct keydata *keyptr;
-        __u32 hash[4];
-
-        keyptr = get_keyptr();
-
-        hash[0] = (__force __u32)daddr[0];
-        hash[1] = (__force __u32)daddr[1];
-        hash[2] = (__force __u32)daddr[2];
-        hash[3] = (__force __u32)daddr[3];
-
-        return half_md4_transform(hash, keyptr->secret);
-}
-
-#ifdef CONFIG_INET
-
-__u32 secure_tcp_sequence_number(__be32 saddr, __be32 daddr,
-                                 __be16 sport, __be16 dport)
-{
-        __u32 seq;
-        __u32 hash[4];
-        struct keydata *keyptr = get_keyptr();
-
-        /*
-         *  Pick a unique starting offset for each TCP connection endpoints
-         *  (saddr, daddr, sport, dport).
-         *  Note that the words are placed into the starting vector, which is
-         *  then mixed with a partial MD4 over random data.
-         */
-        hash[0] = (__force u32)saddr;
-        hash[1] = (__force u32)daddr;
-        hash[2] = ((__force u16)sport << 16) + (__force u16)dport;
-        hash[3] = keyptr->secret[11];
-
-        seq = half_md4_transform(hash, keyptr->secret) & HASH_MASK;
-        seq += keyptr->count;
-        /*
-         *      As close as possible to RFC 793, which
-         *      suggests using a 250 kHz clock.
-         *      Further reading shows this assumes 2 Mb/s networks.
-         *      For 10 Mb/s Ethernet, a 1 MHz clock is appropriate.
-         *      For 10 Gb/s Ethernet, a 1 GHz clock should be ok, but
-         *      we also need to limit the resolution so that the u32 seq
-         *      overlaps less than one time per MSL (2 minutes).
-         *      Choosing a clock of 64 ns period is OK. (period of 274 s)
-         */
-        seq += ktime_to_ns(ktime_get_real()) >> 6;
-
-        return seq;
-}
-
-/* Generate secure starting point for ephemeral IPV4 transport port search */
-u32 secure_ipv4_port_ephemeral(__be32 saddr, __be32 daddr, __be16 dport)
-{
-        struct keydata *keyptr = get_keyptr();
-        u32 hash[4];
-
-        /*
-         *  Pick a unique starting offset for each ephemeral port search
-         *  (saddr, daddr, dport) and 48bits of random data.
-         */
-        hash[0] = (__force u32)saddr;
-        hash[1] = (__force u32)daddr;
-        hash[2] = (__force u32)dport ^ keyptr->secret[10];
-        hash[3] = keyptr->secret[11];
-
-        return half_md4_transform(hash, keyptr->secret);
-}
-EXPORT_SYMBOL_GPL(secure_ipv4_port_ephemeral);
-
-#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
-u32 secure_ipv6_port_ephemeral(const __be32 *saddr, const __be32 *daddr,
-                               __be16 dport)
-{
-        struct keydata *keyptr = get_keyptr();
-        u32 hash[12];
-
-        memcpy(hash, saddr, 16);
-        hash[4] = (__force u32)dport;
-        memcpy(&hash[5], keyptr->secret, sizeof(__u32) * 7);
-
-        return twothirdsMD4Transform((const __u32 *)daddr, hash);
-}
-#endif
-
-#if defined(CONFIG_IP_DCCP) || defined(CONFIG_IP_DCCP_MODULE)
-/* Similar to secure_tcp_sequence_number but generate a 48 bit value
- * bit's 32-47 increase every key exchange
- *       0-31  hash(source, dest)
- */
-u64 secure_dccp_sequence_number(__be32 saddr, __be32 daddr,
-                                __be16 sport, __be16 dport)
-{
-        u64 seq;
-        __u32 hash[4];
-        struct keydata *keyptr = get_keyptr();
-
-        hash[0] = (__force u32)saddr;
-        hash[1] = (__force u32)daddr;
-        hash[2] = ((__force u16)sport << 16) + (__force u16)dport;
-        hash[3] = keyptr->secret[11];
-
-        seq = half_md4_transform(hash, keyptr->secret);
-        seq |= ((u64)keyptr->count) << (32 - HASH_BITS);
-
-        seq += ktime_to_ns(ktime_get_real());
-        seq &= (1ull << 48) - 1;
-
-        return seq;
-}
-EXPORT_SYMBOL(secure_dccp_sequence_number);
-#endif
-
-#endif /* CONFIG_INET */
-
+late_initcall(random_int_secret_init);
 
 /*
  * Get a random word for internal kernel use only. Similar to urandom but
@@ -1646,17 +1315,15 @@ EXPORT_SYMBOL(secure_dccp_sequence_number);
  * value is not cryptographically secure but for several uses the cost of
  * depleting entropy is too high
  */
-DEFINE_PER_CPU(__u32 [4], get_random_int_hash);
+DEFINE_PER_CPU(__u32 [MD5_DIGEST_WORDS], get_random_int_hash);
 unsigned int get_random_int(void)
 {
-        struct keydata *keyptr;
         __u32 *hash = get_cpu_var(get_random_int_hash);
-        int ret;
+        unsigned int ret;
 
-        keyptr = get_keyptr();
         hash[0] += current->pid + jiffies + get_cycles();
-
-        ret = half_md4_transform(hash, keyptr->secret);
+        md5_transform(hash, random_int_secret);
+        ret = hash[0];
         put_cpu_var(get_random_int_hash);
 
         return ret;
diff --git a/drivers/char/tile-srom.c b/drivers/char/tile-srom.c
new file mode 100644
index 000000000000..cf3ee008dca2
--- /dev/null
+++ b/drivers/char/tile-srom.c
@@ -0,0 +1,481 @@
+/*
+ * Copyright 2011 Tilera Corporation. All Rights Reserved.
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation, version 2.
+ *
+ *   This program is distributed in the hope that it will be useful, but
+ *   WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
+ *   NON INFRINGEMENT.  See the GNU General Public License for
+ *   more details.
+ *
+ * SPI Flash ROM driver
+ *
+ * This source code is derived from code provided in "Linux Device
+ * Drivers, Third Edition", by Jonathan Corbet, Alessandro Rubini, and
+ * Greg Kroah-Hartman, published by O'Reilly Media, Inc.
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/init.h>
+#include <linux/kernel.h>       /* printk() */
+#include <linux/slab.h>         /* kmalloc() */
+#include <linux/fs.h>           /* everything... */
+#include <linux/errno.h>        /* error codes */
+#include <linux/types.h>        /* size_t */
+#include <linux/proc_fs.h>
+#include <linux/fcntl.h>        /* O_ACCMODE */
+#include <linux/aio.h>
+#include <linux/pagemap.h>
+#include <linux/hugetlb.h>
+#include <linux/uaccess.h>
+#include <linux/platform_device.h>
+#include <hv/hypervisor.h>
+#include <linux/ioctl.h>
+#include <linux/cdev.h>
+#include <linux/delay.h>
+#include <hv/drv_srom_intf.h>
+
+/*
+ * Size of our hypervisor I/O requests.  We break up large transfers
+ * so that we don't spend large uninterrupted spans of time in the
+ * hypervisor.  Erasing an SROM sector takes a significant fraction of
+ * a second, so if we allowed the user to, say, do one I/O to write the
+ * entire ROM, we'd get soft lockup timeouts, or worse.
+ */
+#define SROM_CHUNK_SIZE ((size_t)4096)
+
+/*
+ * When hypervisor is busy (e.g. erasing), poll the status periodically.
+ */
+
+/*
+ * Interval to poll the state in msec
+ */
+#define SROM_WAIT_TRY_INTERVAL 20
+
+/*
+ * Maximum times to poll the state
+ */
+#define SROM_MAX_WAIT_TRY_TIMES 1000
+
+struct srom_dev {
+        int hv_devhdl;                  /* Handle for hypervisor device */
+        u32 total_size;                 /* Size of this device */
+        u32 sector_size;                /* Size of a sector */
+        u32 page_size;                  /* Size of a page */
+        struct mutex lock;              /* Allow only one accessor at a time */
+};
+
+static int srom_major;                  /* Dynamic major by default */
+module_param(srom_major, int, 0);
+MODULE_AUTHOR("Tilera Corporation");
+MODULE_LICENSE("GPL");
+
+static int srom_devs;                   /* Number of SROM partitions */
+static struct cdev srom_cdev;
+static struct class *srom_class;
+static struct srom_dev *srom_devices;
+
+/*
+ * Handle calling the hypervisor and managing EAGAIN/EBUSY.
+ */
+
+static ssize_t _srom_read(int hv_devhdl, void *buf,
+                          loff_t off, size_t count)
+{
+        int retval, retries = SROM_MAX_WAIT_TRY_TIMES;
+        for (;;) {
+                retval = hv_dev_pread(hv_devhdl, 0, (HV_VirtAddr)buf,
+                                      count, off);
+                if (retval >= 0)
+                        return retval;
+                if (retval == HV_EAGAIN)
+                        continue;
+                if (retval == HV_EBUSY && --retries > 0) {
+                        msleep(SROM_WAIT_TRY_INTERVAL);
+                        continue;
+                }
+                pr_err("_srom_read: error %d\n", retval);
+                return -EIO;
+        }
+}
+
+static ssize_t _srom_write(int hv_devhdl, const void *buf,
+                           loff_t off, size_t count)
+{
+        int retval, retries = SROM_MAX_WAIT_TRY_TIMES;
+        for (;;) {
+                retval = hv_dev_pwrite(hv_devhdl, 0, (HV_VirtAddr)buf,
+                                       count, off);
+                if (retval >= 0)
+                        return retval;
+                if (retval == HV_EAGAIN)
+                        continue;
+                if (retval == HV_EBUSY && --retries > 0) {
+                        msleep(SROM_WAIT_TRY_INTERVAL);
+                        continue;
+                }
+                pr_err("_srom_write: error %d\n", retval);
+                return -EIO;
+        }
+}
+
+/**
+ * srom_open() - Device open routine.
+ * @inode: Inode for this device.
+ * @filp: File for this specific open of the device.
+ *
+ * Returns zero, or an error code.
+ */
+static int srom_open(struct inode *inode, struct file *filp)
+{
+        filp->private_data = &srom_devices[iminor(inode)];
+        return 0;
+}
+
+
+/**
+ * srom_release() - Device release routine.
+ * @inode: Inode for this device.
+ * @filp: File for this specific open of the device.
+ *
+ * Returns zero, or an error code.
+ */
+static int srom_release(struct inode *inode, struct file *filp)
+{
+        struct srom_dev *srom = filp->private_data;
+        char dummy;
+
+        /* Make sure we've flushed anything written to the ROM. */
+        mutex_lock(&srom->lock);
+        if (srom->hv_devhdl >= 0)
+                _srom_write(srom->hv_devhdl, &dummy, SROM_FLUSH_OFF, 1);
+        mutex_unlock(&srom->lock);
+
+        filp->private_data = NULL;
+
+        return 0;
+}
+
+
+/**
+ * srom_read() - Read data from the device.
+ * @filp: File for this specific open of the device.
+ * @buf: User's data buffer.
+ * @count: Number of bytes requested.
+ * @f_pos: File position.
+ *
+ * Returns number of bytes read, or an error code.
+ */
+static ssize_t srom_read(struct file *filp, char __user *buf,
+                         size_t count, loff_t *f_pos)
+{
+        int retval = 0;
+        void *kernbuf;
+        struct srom_dev *srom = filp->private_data;
+
+        kernbuf = kmalloc(SROM_CHUNK_SIZE, GFP_KERNEL);
+        if (!kernbuf)
+                return -ENOMEM;
+
+        if (mutex_lock_interruptible(&srom->lock)) {
+                retval = -ERESTARTSYS;
+                kfree(kernbuf);
+                return retval;
+        }
+
+        while (count) {
+                int hv_retval;
+                int bytes_this_pass = min(count, SROM_CHUNK_SIZE);
+
+                hv_retval = _srom_read(srom->hv_devhdl, kernbuf,
+                                       *f_pos, bytes_this_pass);
+                if (hv_retval > 0) {
+                        if (copy_to_user(buf, kernbuf, hv_retval) != 0) {
+                                retval = -EFAULT;
+                                break;
+                        }
+                } else if (hv_retval <= 0) {
+                        if (retval == 0)
+                                retval = hv_retval;
+                        break;
+                }
+
+                retval += hv_retval;
+                *f_pos += hv_retval;
+                buf += hv_retval;
+                count -= hv_retval;
+        }
+
+        mutex_unlock(&srom->lock);
+        kfree(kernbuf);
+
+        return retval;
+}
+
+/**
+ * srom_write() - Write data to the device.
+ * @filp: File for this specific open of the device.
+ * @buf: User's data buffer.
+ * @count: Number of bytes requested.
+ * @f_pos: File position.
+ *
+ * Returns number of bytes written, or an error code.
+ */
+static ssize_t srom_write(struct file *filp, const char __user *buf,
+                          size_t count, loff_t *f_pos)
+{
+        int retval = 0;
+        void *kernbuf;
+        struct srom_dev *srom = filp->private_data;
+
+        kernbuf = kmalloc(SROM_CHUNK_SIZE, GFP_KERNEL);
+        if (!kernbuf)
+                return -ENOMEM;
+
+        if (mutex_lock_interruptible(&srom->lock)) {
+                retval = -ERESTARTSYS;
+                kfree(kernbuf);
+                return retval;
+        }
+
+        while (count) {
+                int hv_retval;
+                int bytes_this_pass = min(count, SROM_CHUNK_SIZE);
+
+                if (copy_from_user(kernbuf, buf, bytes_this_pass) != 0) {
+                        retval = -EFAULT;
+                        break;
+                }
+
+                hv_retval = _srom_write(srom->hv_devhdl, kernbuf,
+                                        *f_pos, bytes_this_pass);
+                if (hv_retval <= 0) {
+                        if (retval == 0)
+                                retval = hv_retval;
+                        break;
+                }
+
+                retval += hv_retval;
+                *f_pos += hv_retval;
+                buf += hv_retval;
+                count -= hv_retval;
+        }
+
+        mutex_unlock(&srom->lock);
+        kfree(kernbuf);
+
+        return retval;
+}
+
+/* Provide our own implementation so we can use srom->total_size. */
+loff_t srom_llseek(struct file *filp, loff_t offset, int origin)
+{
+        struct srom_dev *srom = filp->private_data;
+
+        if (mutex_lock_interruptible(&srom->lock))
+                return -ERESTARTSYS;
+
+        switch (origin) {
+        case SEEK_END:
+                offset += srom->total_size;
+                break;
+        case SEEK_CUR:
+                offset += filp->f_pos;
+                break;
+        }
+
+        if (offset < 0 || offset > srom->total_size) {
+                offset = -EINVAL;
+        } else {
+                filp->f_pos = offset;
+                filp->f_version = 0;
+        }
+
+        mutex_unlock(&srom->lock);
+
+        return offset;
+}
+
+static ssize_t total_show(struct device *dev,
+                          struct device_attribute *attr, char *buf)
+{
+        struct srom_dev *srom = dev_get_drvdata(dev);
+        return sprintf(buf, "%u\n", srom->total_size);
+}
+
+static ssize_t sector_show(struct device *dev,
+                           struct device_attribute *attr, char *buf)
+{
+        struct srom_dev *srom = dev_get_drvdata(dev);
+        return sprintf(buf, "%u\n", srom->sector_size);
+}
+
+static ssize_t page_show(struct device *dev,
+                         struct device_attribute *attr, char *buf)
+{
+        struct srom_dev *srom = dev_get_drvdata(dev);
+        return sprintf(buf, "%u\n", srom->page_size);
+}
+
+static struct device_attribute srom_dev_attrs[] = {
+        __ATTR(total_size, S_IRUGO, total_show, NULL),
+        __ATTR(sector_size, S_IRUGO, sector_show, NULL),
+        __ATTR(page_size, S_IRUGO, page_show, NULL),
+        __ATTR_NULL
+};
+
+static char *srom_devnode(struct device *dev, mode_t *mode)
+{
+        *mode = S_IRUGO | S_IWUSR;
+        return kasprintf(GFP_KERNEL, "srom/%s", dev_name(dev));
+}
+
+/*
+ * The fops
+ */
+static const struct file_operations srom_fops = {
+        .owner =     THIS_MODULE,
+        .llseek =    srom_llseek,
+        .read =      srom_read,
+        .write =     srom_write,
+        .open =      srom_open,
+        .release =   srom_release,
+};
+
+/**
+ * srom_setup_minor() - Initialize per-minor information.
+ * @srom: Per-device SROM state.
+ * @index: Device to set up.
+ */
+static int srom_setup_minor(struct srom_dev *srom, int index)
+{
+        struct device *dev;
+        int devhdl = srom->hv_devhdl;
+
+        mutex_init(&srom->lock);
+
+        if (_srom_read(devhdl, &srom->total_size,
+                       SROM_TOTAL_SIZE_OFF, sizeof(srom->total_size)) < 0)
+                return -EIO;
+        if (_srom_read(devhdl, &srom->sector_size,
+                       SROM_SECTOR_SIZE_OFF, sizeof(srom->sector_size)) < 0)
+                return -EIO;
+        if (_srom_read(devhdl, &srom->page_size,
+                       SROM_PAGE_SIZE_OFF, sizeof(srom->page_size)) < 0)
+                return -EIO;
+
+        dev = device_create(srom_class, &platform_bus,
+                            MKDEV(srom_major, index), srom, "%d", index);
+        return IS_ERR(dev) ? PTR_ERR(dev) : 0;
+}
+
+/** srom_init() - Initialize the driver's module. */
+static int srom_init(void)
+{
+        int result, i;
+        dev_t dev = MKDEV(srom_major, 0);
+
+        /*
+         * Start with a plausible number of partitions; the krealloc() call
+         * below will yield about log(srom_devs) additional allocations.
+         */
+        srom_devices = kzalloc(4 * sizeof(struct srom_dev), GFP_KERNEL);
+
+        /* Discover the number of srom partitions. */
+        for (i = 0; ; i++) {
+                int devhdl;
+                char buf[20];
+                struct srom_dev *new_srom_devices =
+                        krealloc(srom_devices, (i+1) * sizeof(struct srom_dev),
+                                 GFP_KERNEL | __GFP_ZERO);
+                if (!new_srom_devices) {
+                        result = -ENOMEM;
+                        goto fail_mem;
+                }
+                srom_devices = new_srom_devices;
+                sprintf(buf, "srom/0/%d", i);
+                devhdl = hv_dev_open((HV_VirtAddr)buf, 0);
+                if (devhdl < 0) {
+                        if (devhdl != HV_ENODEV)
+                                pr_notice("srom/%d: hv_dev_open failed: %d.\n",
+                                          i, devhdl);
+                        break;
+                }
+                srom_devices[i].hv_devhdl = devhdl;
+        }
+        srom_devs = i;
+
+        /* Bail out early if we have no partitions at all. */
+        if (srom_devs == 0) {
+                result = -ENODEV;
+                goto fail_mem;
+        }
+
+        /* Register our major, and accept a dynamic number. */
+        if (srom_major)
+                result = register_chrdev_region(dev, srom_devs, "srom");
+        else {
+                result = alloc_chrdev_region(&dev, 0, srom_devs, "srom");
+                srom_major = MAJOR(dev);
+        }
+        if (result < 0)
+                goto fail_mem;
+
+        /* Register a character device. */
+        cdev_init(&srom_cdev, &srom_fops);
+        srom_cdev.owner = THIS_MODULE;
+        srom_cdev.ops = &srom_fops;
+        result = cdev_add(&srom_cdev, dev, srom_devs);
+        if (result < 0)
+                goto fail_chrdev;
+
+        /* Create a sysfs class. */
+        srom_class = class_create(THIS_MODULE, "srom");
+        if (IS_ERR(srom_class)) {
+                result = PTR_ERR(srom_class);
+                goto fail_cdev;
+        }
+        srom_class->dev_attrs = srom_dev_attrs;
+        srom_class->devnode = srom_devnode;
+
+        /* Do per-partition initialization */
+        for (i = 0; i < srom_devs; i++) {
+                result = srom_setup_minor(srom_devices + i, i);
+                if (result < 0)
+                        goto fail_class;
+        }
+
+        return 0;
+
+fail_class:
+        for (i = 0; i < srom_devs; i++)
+                device_destroy(srom_class, MKDEV(srom_major, i));
+        class_destroy(srom_class);
+fail_cdev:
+        cdev_del(&srom_cdev);
+fail_chrdev:
+        unregister_chrdev_region(dev, srom_devs);
+fail_mem:
+        kfree(srom_devices);
+        return result;
+}
+
+/** srom_cleanup() - Clean up the driver's module. */
+static void srom_cleanup(void)
+{
+        int i;
+        for (i = 0; i < srom_devs; i++)
+                device_destroy(srom_class, MKDEV(srom_major, i));
+        class_destroy(srom_class);
+        cdev_del(&srom_cdev);
+        unregister_chrdev_region(MKDEV(srom_major, 0), srom_devs);
+        kfree(srom_devices);
+}
+
+module_init(srom_init);
+module_exit(srom_cleanup);
diff --git a/drivers/char/tpm/tpm_tis.c b/drivers/char/tpm/tpm_tis.c
index 7fc2f108f490..3f4051a7c5a7 100644
--- a/drivers/char/tpm/tpm_tis.c
+++ b/drivers/char/tpm/tpm_tis.c
@@ -80,7 +80,7 @@ enum tis_defaults {
 static LIST_HEAD(tis_chips);
 static DEFINE_SPINLOCK(tis_lock);
 
-#ifdef CONFIG_PNP
+#if defined(CONFIG_PNP) && defined(CONFIG_ACPI)
 static int is_itpm(struct pnp_dev *dev)
 {
         struct acpi_device *acpi = pnp_acpi_device(dev);
@@ -93,6 +93,11 @@ static int is_itpm(struct pnp_dev *dev)
 
         return 0;
 }
+#else
+static inline int is_itpm(struct pnp_dev *dev)
+{
+        return 0;
+}
 #endif
 
 static int check_locality(struct tpm_chip *chip, int l)
diff --git a/drivers/clocksource/sh_cmt.c b/drivers/clocksource/sh_cmt.c
index dc7c033ef587..32a77becc098 100644
--- a/drivers/clocksource/sh_cmt.c
+++ b/drivers/clocksource/sh_cmt.c
@@ -26,6 +26,7 @@
 #include <linux/clk.h>
 #include <linux/irq.h>
 #include <linux/err.h>
+#include <linux/delay.h>
 #include <linux/clocksource.h>
 #include <linux/clockchips.h>
 #include <linux/sh_timer.h>
@@ -150,13 +151,13 @@ static void sh_cmt_start_stop_ch(struct sh_cmt_priv *p, int start)
 
 static int sh_cmt_enable(struct sh_cmt_priv *p, unsigned long *rate)
 {
-        int ret;
+        int k, ret;
 
         /* enable clock */
         ret = clk_enable(p->clk);
         if (ret) {
                 dev_err(&p->pdev->dev, "cannot enable clock\n");
-                return ret;
+                goto err0;
         }
 
         /* make sure channel is disabled */
@@ -174,9 +175,38 @@ static int sh_cmt_enable(struct sh_cmt_priv *p, unsigned long *rate)
         sh_cmt_write(p, CMCOR, 0xffffffff);
         sh_cmt_write(p, CMCNT, 0);
 
+        /*
+         * According to the sh73a0 user's manual, as CMCNT can be operated
+         * only by the RCLK (Pseudo 32 KHz), there's one restriction on
+         * modifying CMCNT register; two RCLK cycles are necessary before
+         * this register is either read or any modification of the value
+         * it holds is reflected in the LSI's actual operation.
+         *
+         * While at it, we're supposed to clear out the CMCNT as of this
+         * moment, so make sure it's processed properly here.  This will
+         * take RCLKx2 at maximum.
+         */
+        for (k = 0; k < 100; k++) {
+                if (!sh_cmt_read(p, CMCNT))
+                        break;
+                udelay(1);
+        }
+
+        if (sh_cmt_read(p, CMCNT)) {
+                dev_err(&p->pdev->dev, "cannot clear CMCNT\n");
+                ret = -ETIMEDOUT;
+                goto err1;
+        }
+
         /* enable channel */
         sh_cmt_start_stop_ch(p, 1);
         return 0;
+ err1:
+        /* stop clock */
+        clk_disable(p->clk);
+
+ err0:
+        return ret;
 }
 
 static void sh_cmt_disable(struct sh_cmt_priv *p)
diff --git a/drivers/connector/cn_proc.c b/drivers/connector/cn_proc.c
index 3ee1fdb31ea7..e55814bc0d06 100644
--- a/drivers/connector/cn_proc.c
+++ b/drivers/connector/cn_proc.c
@@ -57,6 +57,7 @@ void proc_fork_connector(struct task_struct *task)
         struct proc_event *ev;
         __u8 buffer[CN_PROC_MSG_SIZE];
         struct timespec ts;
+        struct task_struct *parent;
 
         if (atomic_read(&proc_event_num_listeners) < 1)
                 return;
@@ -67,8 +68,11 @@ void proc_fork_connector(struct task_struct *task)
         ktime_get_ts(&ts); /* get high res monotonic timestamp */
         put_unaligned(timespec_to_ns(&ts), (__u64 *)&ev->timestamp_ns);
         ev->what = PROC_EVENT_FORK;
-        ev->event_data.fork.parent_pid = task->real_parent->pid;
-        ev->event_data.fork.parent_tgid = task->real_parent->tgid;
+        rcu_read_lock();
+        parent = rcu_dereference(task->real_parent);
+        ev->event_data.fork.parent_pid = parent->pid;
+        ev->event_data.fork.parent_tgid = parent->tgid;
+        rcu_read_unlock();
         ev->event_data.fork.child_pid = task->pid;
         ev->event_data.fork.child_tgid = task->tgid;
 
diff --git a/drivers/cpuidle/cpuidle.c b/drivers/cpuidle/cpuidle.c
index bf5092455a8f..d4c542372886 100644
--- a/drivers/cpuidle/cpuidle.c
+++ b/drivers/cpuidle/cpuidle.c
@@ -25,9 +25,19 @@ DEFINE_PER_CPU(struct cpuidle_device *, cpuidle_devices);
 
 DEFINE_MUTEX(cpuidle_lock);
 LIST_HEAD(cpuidle_detected_devices);
-static void (*pm_idle_old)(void);
 
 static int enabled_devices;
+static int off __read_mostly;
+static int initialized __read_mostly;
+
+int cpuidle_disabled(void)
+{
+        return off;
+}
+void disable_cpuidle(void)
+{
+        off = 1;
+}
 
 #if defined(CONFIG_ARCH_HAS_CPU_IDLE_WAIT)
 static void cpuidle_kick_cpus(void)
@@ -46,25 +56,23 @@ static int __cpuidle_register_device(struct cpuidle_device *dev);
  * cpuidle_idle_call - the main idle loop
  *
  * NOTE: no locks or semaphores should be used here
+ * return non-zero on failure
  */
-static void cpuidle_idle_call(void)
+int cpuidle_idle_call(void)
 {
         struct cpuidle_device *dev = __this_cpu_read(cpuidle_devices);
         struct cpuidle_state *target_state;
         int next_state;
 
+        if (off)
+                return -ENODEV;
+
+        if (!initialized)
+                return -ENODEV;
+
         /* check if the device is ready */
-        if (!dev || !dev->enabled) {
-                if (pm_idle_old)
-                        pm_idle_old();
-                else
-#if defined(CONFIG_ARCH_HAS_DEFAULT_IDLE)
-                        default_idle();
-#else
-                        local_irq_enable();
-#endif
-                return;
-        }
+        if (!dev || !dev->enabled)
+                return -EBUSY;
 
 #if 0
         /* shows regressions, re-enable for 2.6.29 */
@@ -89,7 +97,7 @@ static void cpuidle_idle_call(void)
         next_state = cpuidle_curr_governor->select(dev);
         if (need_resched()) {
                 local_irq_enable();
-                return;
+                return 0;
         }
 
         target_state = &dev->states[next_state];
@@ -114,6 +122,8 @@ static void cpuidle_idle_call(void)
         /* give the governor an opportunity to reflect on the outcome */
         if (cpuidle_curr_governor->reflect)
                 cpuidle_curr_governor->reflect(dev);
+
+        return 0;
 }
 
 /**
@@ -121,10 +131,10 @@ static void cpuidle_idle_call(void)
  */
 void cpuidle_install_idle_handler(void)
 {
-        if (enabled_devices && (pm_idle != cpuidle_idle_call)) {
+        if (enabled_devices) {
                 /* Make sure all changes finished before we switch to new idle */
                 smp_wmb();
-                pm_idle = cpuidle_idle_call;
+                initialized = 1;
         }
 }
 
@@ -133,8 +143,8 @@ void cpuidle_install_idle_handler(void)
  */
 void cpuidle_uninstall_idle_handler(void)
 {
-        if (enabled_devices && pm_idle_old && (pm_idle != pm_idle_old)) {
-                pm_idle = pm_idle_old;
+        if (enabled_devices) {
+                initialized = 0;
                 cpuidle_kick_cpus();
         }
 }
@@ -427,7 +437,8 @@ static int __init cpuidle_init(void)
 {
         int ret;
 
-        pm_idle_old = pm_idle;
+        if (cpuidle_disabled())
+                return -ENODEV;
 
         ret = cpuidle_add_class_sysfs(&cpu_sysdev_class);
         if (ret)
@@ -438,4 +449,5 @@ static int __init cpuidle_init(void)
         return 0;
 }
 
+module_param(off, int, 0444);
 core_initcall(cpuidle_init);
diff --git a/drivers/cpuidle/cpuidle.h b/drivers/cpuidle/cpuidle.h
index 33e50d556f17..38c3fd8b9d76 100644
--- a/drivers/cpuidle/cpuidle.h
+++ b/drivers/cpuidle/cpuidle.h
@@ -13,6 +13,7 @@ extern struct list_head cpuidle_governors;
 extern struct list_head cpuidle_detected_devices;
 extern struct mutex cpuidle_lock;
 extern spinlock_t cpuidle_driver_lock;
+extern int cpuidle_disabled(void);
 
 /* idle loop */
 extern void cpuidle_install_idle_handler(void);
diff --git a/drivers/cpuidle/driver.c b/drivers/cpuidle/driver.c
index fd1601e3d125..3f7e3cedd133 100644
--- a/drivers/cpuidle/driver.c
+++ b/drivers/cpuidle/driver.c
@@ -26,6 +26,9 @@ int cpuidle_register_driver(struct cpuidle_driver *drv)
         if (!drv)
                 return -EINVAL;
 
+        if (cpuidle_disabled())
+                return -ENODEV;
+
         spin_lock(&cpuidle_driver_lock);
         if (cpuidle_curr_driver) {
                 spin_unlock(&cpuidle_driver_lock);
diff --git a/drivers/cpuidle/governor.c b/drivers/cpuidle/governor.c
index 724c164d31c9..ea2f8e7aa24a 100644
--- a/drivers/cpuidle/governor.c
+++ b/drivers/cpuidle/governor.c
@@ -81,6 +81,9 @@ int cpuidle_register_governor(struct cpuidle_governor *gov)
         if (!gov || !gov->select)
                 return -EINVAL;
 
+        if (cpuidle_disabled())
+                return -ENODEV;
+
         mutex_lock(&cpuidle_lock);
         if (__cpuidle_find_governor(gov->name) == NULL) {
                 ret = 0;
diff --git a/drivers/dma/TODO b/drivers/dma/TODO
index a4af8589330c..734ed0206cd5 100644
--- a/drivers/dma/TODO
+++ b/drivers/dma/TODO
@@ -9,6 +9,5 @@ TODO for slave dma
         - mxs-dma.c
         - dw_dmac
         - intel_mid_dma
-        - ste_dma40
 4. Check other subsystems for dma drivers and merge/move to dmaengine
 5. Remove dma_slave_config's dma direction.
diff --git a/drivers/dma/amba-pl08x.c b/drivers/dma/amba-pl08x.c
index e6d7228b1479..be21e3f138a8 100644
--- a/drivers/dma/amba-pl08x.c
+++ b/drivers/dma/amba-pl08x.c
@@ -80,6 +80,7 @@
 #include <linux/interrupt.h>
 #include <linux/slab.h>
 #include <linux/delay.h>
+#include <linux/dma-mapping.h>
 #include <linux/dmapool.h>
 #include <linux/dmaengine.h>
 #include <linux/amba/bus.h>
@@ -156,14 +157,10 @@ struct pl08x_driver_data {
 #define PL08X_BOUNDARY_SHIFT            (10)    /* 1KB 0x400 */
 #define PL08X_BOUNDARY_SIZE             (1 << PL08X_BOUNDARY_SHIFT)
 
-/* Minimum period between work queue runs */
-#define PL08X_WQ_PERIODMIN      20
-
 /* Size (bytes) of each LLI buffer allocated for one transfer */
 # define PL08X_LLI_TSFR_SIZE    0x2000
 
 /* Maximum times we call dma_pool_alloc on this pool without freeing */
-#define PL08X_MAX_ALLOCS        0x40
 #define MAX_NUM_TSFR_LLIS       (PL08X_LLI_TSFR_SIZE/sizeof(struct pl08x_lli))
 #define PL08X_ALIGN             8
 
@@ -495,10 +492,10 @@ static inline u32 pl08x_cctl_bits(u32 cctl, u8 srcwidth, u8 dstwidth,
 
 struct pl08x_lli_build_data {
         struct pl08x_txd *txd;
-        struct pl08x_driver_data *pl08x;
         struct pl08x_bus_data srcbus;
         struct pl08x_bus_data dstbus;
         size_t remainder;
+        u32 lli_bus;
 };
 
 /*
@@ -551,8 +548,7 @@ static void pl08x_fill_lli_for_desc(struct pl08x_lli_build_data *bd,
         llis_va[num_llis].src = bd->srcbus.addr;
         llis_va[num_llis].dst = bd->dstbus.addr;
         llis_va[num_llis].lli = llis_bus + (num_llis + 1) * sizeof(struct pl08x_lli);
-        if (bd->pl08x->lli_buses & PL08X_AHB2)
-                llis_va[num_llis].lli |= PL080_LLI_LM_AHB2;
+        llis_va[num_llis].lli |= bd->lli_bus;
 
         if (cctl & PL080_CONTROL_SRC_INCR)
                 bd->srcbus.addr += len;
@@ -605,9 +601,9 @@ static int pl08x_fill_llis_for_desc(struct pl08x_driver_data *pl08x,
         cctl = txd->cctl;
 
         bd.txd = txd;
-        bd.pl08x = pl08x;
         bd.srcbus.addr = txd->src_addr;
         bd.dstbus.addr = txd->dst_addr;
+        bd.lli_bus = (pl08x->lli_buses & PL08X_AHB2) ? PL080_LLI_LM_AHB2 : 0;
 
         /* Find maximum width of the source bus */
         bd.srcbus.maxwidth =
@@ -622,25 +618,15 @@ static int pl08x_fill_llis_for_desc(struct pl08x_driver_data *pl08x,
         /* Set up the bus widths to the maximum */
         bd.srcbus.buswidth = bd.srcbus.maxwidth;
         bd.dstbus.buswidth = bd.dstbus.maxwidth;
-        dev_vdbg(&pl08x->adev->dev,
-                 "%s source bus is %d bytes wide, dest bus is %d bytes wide\n",
-                 __func__, bd.srcbus.buswidth, bd.dstbus.buswidth);
-
 
         /*
          * Bytes transferred == tsize * MIN(buswidths), not max(buswidths)
          */
         max_bytes_per_lli = min(bd.srcbus.buswidth, bd.dstbus.buswidth) *
                 PL080_CONTROL_TRANSFER_SIZE_MASK;
-        dev_vdbg(&pl08x->adev->dev,
-                 "%s max bytes per lli = %zu\n",
-                 __func__, max_bytes_per_lli);
 
         /* We need to count this down to zero */
         bd.remainder = txd->len;
-        dev_vdbg(&pl08x->adev->dev,
-                 "%s remainder = %zu\n",
-                 __func__, bd.remainder);
 
         /*
          * Choose bus to align to
@@ -649,6 +635,16 @@ static int pl08x_fill_llis_for_desc(struct pl08x_driver_data *pl08x,
          */
         pl08x_choose_master_bus(&bd, &mbus, &sbus, cctl);
 
+        dev_vdbg(&pl08x->adev->dev, "src=0x%08x%s/%u dst=0x%08x%s/%u len=%zu llimax=%zu\n",
+                 bd.srcbus.addr, cctl & PL080_CONTROL_SRC_INCR ? "+" : "",
+                 bd.srcbus.buswidth,
+                 bd.dstbus.addr, cctl & PL080_CONTROL_DST_INCR ? "+" : "",
+                 bd.dstbus.buswidth,
+                 bd.remainder, max_bytes_per_lli);
+        dev_vdbg(&pl08x->adev->dev, "mbus=%s sbus=%s\n",
+                 mbus == &bd.srcbus ? "src" : "dst",
+                 sbus == &bd.srcbus ? "src" : "dst");
+
         if (txd->len < mbus->buswidth) {
                 /* Less than a bus width available - send as single bytes */
                 while (bd.remainder) {
@@ -840,15 +836,14 @@ static int pl08x_fill_llis_for_desc(struct pl08x_driver_data *pl08x,
         {
                 int i;
 
+                dev_vdbg(&pl08x->adev->dev,
+                         "%-3s %-9s  %-10s %-10s %-10s %s\n",
+                         "lli", "", "csrc", "cdst", "clli", "cctl");
                 for (i = 0; i < num_llis; i++) {
                         dev_vdbg(&pl08x->adev->dev,
-                                 "lli %d @%p: csrc=0x%08x, cdst=0x%08x, cctl=0x%08x, clli=0x%08x\n",
-                                 i,
-                                 &llis_va[i],
-                                 llis_va[i].src,
-                                 llis_va[i].dst,
-                                 llis_va[i].cctl,
-                                 llis_va[i].lli
+                                 "%3d @%p: 0x%08x 0x%08x 0x%08x 0x%08x\n",
+                                 i, &llis_va[i], llis_va[i].src,
+                                 llis_va[i].dst, llis_va[i].lli, llis_va[i].cctl
                                 );
                 }
         }
@@ -1054,64 +1049,105 @@ pl08x_dma_tx_status(struct dma_chan *chan,
 
 /* PrimeCell DMA extension */
 struct burst_table {
-        int burstwords;
+        u32 burstwords;
         u32 reg;
 };
 
 static const struct burst_table burst_sizes[] = {
         {
                 .burstwords = 256,
-                .reg = (PL080_BSIZE_256 << PL080_CONTROL_SB_SIZE_SHIFT) |
-                        (PL080_BSIZE_256 << PL080_CONTROL_DB_SIZE_SHIFT),
+                .reg = PL080_BSIZE_256,
         },
         {
                 .burstwords = 128,
-                .reg = (PL080_BSIZE_128 << PL080_CONTROL_SB_SIZE_SHIFT) |
-                        (PL080_BSIZE_128 << PL080_CONTROL_DB_SIZE_SHIFT),
+                .reg = PL080_BSIZE_128,
         },
         {
                 .burstwords = 64,
-                .reg = (PL080_BSIZE_64 << PL080_CONTROL_SB_SIZE_SHIFT) |
-                        (PL080_BSIZE_64 << PL080_CONTROL_DB_SIZE_SHIFT),
+                .reg = PL080_BSIZE_64,
         },
         {
                 .burstwords = 32,
-                .reg = (PL080_BSIZE_32 << PL080_CONTROL_SB_SIZE_SHIFT) |
-                        (PL080_BSIZE_32 << PL080_CONTROL_DB_SIZE_SHIFT),
+                .reg = PL080_BSIZE_32,
         },
         {
                 .burstwords = 16,
-                .reg = (PL080_BSIZE_16 << PL080_CONTROL_SB_SIZE_SHIFT) |
-                        (PL080_BSIZE_16 << PL080_CONTROL_DB_SIZE_SHIFT),
+                .reg = PL080_BSIZE_16,
         },
         {
                 .burstwords = 8,
-                .reg = (PL080_BSIZE_8 << PL080_CONTROL_SB_SIZE_SHIFT) |
-                        (PL080_BSIZE_8 << PL080_CONTROL_DB_SIZE_SHIFT),
+                .reg = PL080_BSIZE_8,
         },
         {
                 .burstwords = 4,
-                .reg = (PL080_BSIZE_4 << PL080_CONTROL_SB_SIZE_SHIFT) |
-                        (PL080_BSIZE_4 << PL080_CONTROL_DB_SIZE_SHIFT),
+                .reg = PL080_BSIZE_4,
         },
         {
-                .burstwords = 1,
-                .reg = (PL080_BSIZE_1 << PL080_CONTROL_SB_SIZE_SHIFT) |
-                        (PL080_BSIZE_1 << PL080_CONTROL_DB_SIZE_SHIFT),
+                .burstwords = 0,
+                .reg = PL080_BSIZE_1,
         },
 };
 
+/*
+ * Given the source and destination available bus masks, select which
+ * will be routed to each port.  We try to have source and destination
+ * on separate ports, but always respect the allowable settings.
+ */
+static u32 pl08x_select_bus(u8 src, u8 dst)
+{
+        u32 cctl = 0;
+
+        if (!(dst & PL08X_AHB1) || ((dst & PL08X_AHB2) && (src & PL08X_AHB1)))
+                cctl |= PL080_CONTROL_DST_AHB2;
+        if (!(src & PL08X_AHB1) || ((src & PL08X_AHB2) && !(dst & PL08X_AHB2)))
+                cctl |= PL080_CONTROL_SRC_AHB2;
+
+        return cctl;
+}
+
+static u32 pl08x_cctl(u32 cctl)
+{
+        cctl &= ~(PL080_CONTROL_SRC_AHB2 | PL080_CONTROL_DST_AHB2 |
+                  PL080_CONTROL_SRC_INCR | PL080_CONTROL_DST_INCR |
+                  PL080_CONTROL_PROT_MASK);
+
+        /* Access the cell in privileged mode, non-bufferable, non-cacheable */
+        return cctl | PL080_CONTROL_PROT_SYS;
+}
+
+static u32 pl08x_width(enum dma_slave_buswidth width)
+{
+        switch (width) {
+        case DMA_SLAVE_BUSWIDTH_1_BYTE:
+                return PL080_WIDTH_8BIT;
+        case DMA_SLAVE_BUSWIDTH_2_BYTES:
+                return PL080_WIDTH_16BIT;
+        case DMA_SLAVE_BUSWIDTH_4_BYTES:
+                return PL080_WIDTH_32BIT;
+        default:
+                return ~0;
+        }
+}
+
+static u32 pl08x_burst(u32 maxburst)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(burst_sizes); i++)
+                if (burst_sizes[i].burstwords <= maxburst)
+                        break;
+
+        return burst_sizes[i].reg;
+}
+
 static int dma_set_runtime_config(struct dma_chan *chan,
                                   struct dma_slave_config *config)
 {
         struct pl08x_dma_chan *plchan = to_pl08x_chan(chan);
         struct pl08x_driver_data *pl08x = plchan->host;
-        struct pl08x_channel_data *cd = plchan->cd;
         enum dma_slave_buswidth addr_width;
-        dma_addr_t addr;
-        u32 maxburst;
+        u32 width, burst, maxburst;
         u32 cctl = 0;
-        int i;
 
         if (!plchan->slave)
                 return -EINVAL;
@@ -1119,11 +1155,9 @@ static int dma_set_runtime_config(struct dma_chan *chan,
         /* Transfer direction */
         plchan->runtime_direction = config->direction;
         if (config->direction == DMA_TO_DEVICE) {
-                addr = config->dst_addr;
                 addr_width = config->dst_addr_width;
                 maxburst = config->dst_maxburst;
         } else if (config->direction == DMA_FROM_DEVICE) {
-                addr = config->src_addr;
                 addr_width = config->src_addr_width;
                 maxburst = config->src_maxburst;
         } else {
@@ -1132,46 +1166,40 @@ static int dma_set_runtime_config(struct dma_chan *chan,
                 return -EINVAL;
         }
 
-        switch (addr_width) {
-        case DMA_SLAVE_BUSWIDTH_1_BYTE:
-                cctl |= (PL080_WIDTH_8BIT << PL080_CONTROL_SWIDTH_SHIFT) |
-                        (PL080_WIDTH_8BIT << PL080_CONTROL_DWIDTH_SHIFT);
-                break;
-        case DMA_SLAVE_BUSWIDTH_2_BYTES:
-                cctl |= (PL080_WIDTH_16BIT << PL080_CONTROL_SWIDTH_SHIFT) |
-                        (PL080_WIDTH_16BIT << PL080_CONTROL_DWIDTH_SHIFT);
-                break;
-        case DMA_SLAVE_BUSWIDTH_4_BYTES:
-                cctl |= (PL080_WIDTH_32BIT << PL080_CONTROL_SWIDTH_SHIFT) |
-                        (PL080_WIDTH_32BIT << PL080_CONTROL_DWIDTH_SHIFT);
-                break;
-        default:
+        width = pl08x_width(addr_width);
+        if (width == ~0) {
                 dev_err(&pl08x->adev->dev,
                         "bad runtime_config: alien address width\n");
                 return -EINVAL;
         }
 
+        cctl |= width << PL080_CONTROL_SWIDTH_SHIFT;
+        cctl |= width << PL080_CONTROL_DWIDTH_SHIFT;
+
         /*
-         * Now decide on a maxburst:
          * If this channel will only request single transfers, set this
          * down to ONE element.  Also select one element if no maxburst
          * is specified.
          */
-        if (plchan->cd->single || maxburst == 0) {
-                cctl |= (PL080_BSIZE_1 << PL080_CONTROL_SB_SIZE_SHIFT) |
-                        (PL080_BSIZE_1 << PL080_CONTROL_DB_SIZE_SHIFT);
+        if (plchan->cd->single)
+                maxburst = 1;
+
+        burst = pl08x_burst(maxburst);
+        cctl |= burst << PL080_CONTROL_SB_SIZE_SHIFT;
+        cctl |= burst << PL080_CONTROL_DB_SIZE_SHIFT;
+
+        if (plchan->runtime_direction == DMA_FROM_DEVICE) {
+                plchan->src_addr = config->src_addr;
+                plchan->src_cctl = pl08x_cctl(cctl) | PL080_CONTROL_DST_INCR |
+                        pl08x_select_bus(plchan->cd->periph_buses,
+                                         pl08x->mem_buses);
         } else {
-                for (i = 0; i < ARRAY_SIZE(burst_sizes); i++)
-                        if (burst_sizes[i].burstwords <= maxburst)
-                                break;
-                cctl |= burst_sizes[i].reg;
+                plchan->dst_addr = config->dst_addr;
+                plchan->dst_cctl = pl08x_cctl(cctl) | PL080_CONTROL_SRC_INCR |
+                        pl08x_select_bus(pl08x->mem_buses,
+                                         plchan->cd->periph_buses);
         }
 
-        plchan->runtime_addr = addr;
-
-        /* Modify the default channel data to fit PrimeCell request */
-        cd->cctl = cctl;
-
         dev_dbg(&pl08x->adev->dev,
                 "configured channel %s (%s) for %s, data width %d, "
                 "maxburst %d words, LE, CCTL=0x%08x\n",
@@ -1270,23 +1298,6 @@ static int pl08x_prep_channel_resources(struct pl08x_dma_chan *plchan,
         return 0;
 }
 
-/*
- * Given the source and destination available bus masks, select which
- * will be routed to each port.  We try to have source and destination
- * on separate ports, but always respect the allowable settings.
- */
-static u32 pl08x_select_bus(struct pl08x_driver_data *pl08x, u8 src, u8 dst)
-{
-        u32 cctl = 0;
-
-        if (!(dst & PL08X_AHB1) || ((dst & PL08X_AHB2) && (src & PL08X_AHB1)))
-                cctl |= PL080_CONTROL_DST_AHB2;
-        if (!(src & PL08X_AHB1) || ((src & PL08X_AHB2) && !(dst & PL08X_AHB2)))
-                cctl |= PL080_CONTROL_SRC_AHB2;
-
-        return cctl;
-}
-
 static struct pl08x_txd *pl08x_get_txd(struct pl08x_dma_chan *plchan,
         unsigned long flags)
 {
@@ -1338,8 +1349,8 @@ static struct dma_async_tx_descriptor *pl08x_prep_dma_memcpy(
         txd->cctl |= PL080_CONTROL_SRC_INCR | PL080_CONTROL_DST_INCR;
 
         if (pl08x->vd->dualmaster)
-                txd->cctl |= pl08x_select_bus(pl08x,
-                                        pl08x->mem_buses, pl08x->mem_buses);
+                txd->cctl |= pl08x_select_bus(pl08x->mem_buses,
+                                              pl08x->mem_buses);
 
         ret = pl08x_prep_channel_resources(plchan, txd);
         if (ret)
@@ -1356,7 +1367,6 @@ static struct dma_async_tx_descriptor *pl08x_prep_slave_sg(
         struct pl08x_dma_chan *plchan = to_pl08x_chan(chan);
         struct pl08x_driver_data *pl08x = plchan->host;
         struct pl08x_txd *txd;
-        u8 src_buses, dst_buses;
         int ret;
 
         /*
@@ -1390,42 +1400,22 @@ static struct dma_async_tx_descriptor *pl08x_prep_slave_sg(
         txd->direction = direction;
         txd->len = sgl->length;
 
-        txd->cctl = plchan->cd->cctl &
-                        ~(PL080_CONTROL_SRC_AHB2 | PL080_CONTROL_DST_AHB2 |
-                          PL080_CONTROL_SRC_INCR | PL080_CONTROL_DST_INCR |
-                          PL080_CONTROL_PROT_MASK);
-
-        /* Access the cell in privileged mode, non-bufferable, non-cacheable */
-        txd->cctl |= PL080_CONTROL_PROT_SYS;
-
         if (direction == DMA_TO_DEVICE) {
                 txd->ccfg |= PL080_FLOW_MEM2PER << PL080_CONFIG_FLOW_CONTROL_SHIFT;
-                txd->cctl |= PL080_CONTROL_SRC_INCR;
+                txd->cctl = plchan->dst_cctl;
                 txd->src_addr = sgl->dma_address;
-                if (plchan->runtime_addr)
-                        txd->dst_addr = plchan->runtime_addr;
-                else
-                        txd->dst_addr = plchan->cd->addr;
-                src_buses = pl08x->mem_buses;
-                dst_buses = plchan->cd->periph_buses;
+                txd->dst_addr = plchan->dst_addr;
         } else if (direction == DMA_FROM_DEVICE) {
                 txd->ccfg |= PL080_FLOW_PER2MEM << PL080_CONFIG_FLOW_CONTROL_SHIFT;
-                txd->cctl |= PL080_CONTROL_DST_INCR;
-                if (plchan->runtime_addr)
-                        txd->src_addr = plchan->runtime_addr;
-                else
-                        txd->src_addr = plchan->cd->addr;
+                txd->cctl = plchan->src_cctl;
+                txd->src_addr = plchan->src_addr;
                 txd->dst_addr = sgl->dma_address;
-                src_buses = plchan->cd->periph_buses;
-                dst_buses = pl08x->mem_buses;
         } else {
                 dev_err(&pl08x->adev->dev,
                         "%s direction unsupported\n", __func__);
                 return NULL;
         }
 
-        txd->cctl |= pl08x_select_bus(pl08x, src_buses, dst_buses);
-
         ret = pl08x_prep_channel_resources(plchan, txd);
         if (ret)
                 return NULL;
@@ -1676,6 +1666,20 @@ static irqreturn_t pl08x_irq(int irq, void *dev)
         return mask ? IRQ_HANDLED : IRQ_NONE;
 }
 
+static void pl08x_dma_slave_init(struct pl08x_dma_chan *chan)
+{
+        u32 cctl = pl08x_cctl(chan->cd->cctl);
+
+        chan->slave = true;
+        chan->name = chan->cd->bus_id;
+        chan->src_addr = chan->cd->addr;
+        chan->dst_addr = chan->cd->addr;
+        chan->src_cctl = cctl | PL080_CONTROL_DST_INCR |
+                pl08x_select_bus(chan->cd->periph_buses, chan->host->mem_buses);
+        chan->dst_cctl = cctl | PL080_CONTROL_SRC_INCR |
+                pl08x_select_bus(chan->host->mem_buses, chan->cd->periph_buses);
+}
+
 /*
  * Initialise the DMAC memcpy/slave channels.
  * Make a local wrapper to hold required data
@@ -1707,9 +1711,8 @@ static int pl08x_dma_init_virtual_channels(struct pl08x_driver_data *pl08x,
                 chan->state = PL08X_CHAN_IDLE;
 
                 if (slave) {
-                        chan->slave = true;
-                        chan->name = pl08x->pd->slave_channels[i].bus_id;
                         chan->cd = &pl08x->pd->slave_channels[i];
+                        pl08x_dma_slave_init(chan);
                 } else {
                         chan->cd = &pl08x->pd->memcpy_channel;
                         chan->name = kasprintf(GFP_KERNEL, "memcpy%d", i);
diff --git a/drivers/dma/at_hdmac.c b/drivers/dma/at_hdmac.c
index 36144f88d718..6a483eac7b3f 100644
--- a/drivers/dma/at_hdmac.c
+++ b/drivers/dma/at_hdmac.c
@@ -1216,7 +1216,7 @@ static int __init at_dma_probe(struct platform_device *pdev)
         atdma->dma_common.cap_mask = pdata->cap_mask;
         atdma->all_chan_mask = (1 << pdata->nr_channels) - 1;
 
-        size = io->end - io->start + 1;
+        size = resource_size(io);
         if (!request_mem_region(io->start, size, pdev->dev.driver->name)) {
                 err = -EBUSY;
                 goto err_kfree;
@@ -1362,7 +1362,7 @@ static int __exit at_dma_remove(struct platform_device *pdev)
         atdma->regs = NULL;
 
         io = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        release_mem_region(io->start, io->end - io->start + 1);
+        release_mem_region(io->start, resource_size(io));
 
         kfree(atdma);
 
diff --git a/drivers/dma/coh901318.c b/drivers/dma/coh901318.c
index a92d95eac86b..4234f416ef11 100644
--- a/drivers/dma/coh901318.c
+++ b/drivers/dma/coh901318.c
@@ -41,6 +41,8 @@ struct coh901318_desc {
         struct coh901318_lli *lli;
         enum dma_data_direction dir;
         unsigned long flags;
+        u32 head_config;
+        u32 head_ctrl;
 };
 
 struct coh901318_base {
@@ -661,6 +663,9 @@ static struct coh901318_desc *coh901318_queue_start(struct coh901318_chan *cohc)
 
                 coh901318_desc_submit(cohc, cohd);
 
+                /* Program the transaction head */
+                coh901318_set_conf(cohc, cohd->head_config);
+                coh901318_set_ctrl(cohc, cohd->head_ctrl);
                 coh901318_prep_linked_list(cohc, cohd->lli);
 
                 /* start dma job on this channel */
@@ -1091,8 +1096,6 @@ coh901318_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
         } else
                 goto err_direction;
 
-        coh901318_set_conf(cohc, config);
-
         /* The dma only supports transmitting packages up to
          * MAX_DMA_PACKET_SIZE. Calculate to total number of
          * dma elemts required to send the entire sg list
@@ -1129,16 +1132,18 @@ coh901318_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
         if (ret)
                 goto err_lli_fill;
 
-        /*
-         * Set the default ctrl for the channel to the one from the lli,
-         * things may have changed due to odd buffer alignment etc.
-         */
-        coh901318_set_ctrl(cohc, lli->control);
 
         COH_DBG(coh901318_list_print(cohc, lli));
 
         /* Pick a descriptor to handle this transfer */
         cohd = coh901318_desc_get(cohc);
+        cohd->head_config = config;
+        /*
+         * Set the default head ctrl for the channel to the one from the
+         * lli, things may have changed due to odd buffer alignment
+         * etc.
+         */
+        cohd->head_ctrl = lli->control;
         cohd->dir = direction;
         cohd->flags = flags;
         cohd->desc.tx_submit = coh901318_tx_submit;
diff --git a/drivers/dma/dmaengine.c b/drivers/dma/dmaengine.c
index 48694c34d96b..b48967b499da 100644
--- a/drivers/dma/dmaengine.c
+++ b/drivers/dma/dmaengine.c
@@ -62,9 +62,9 @@
 #include <linux/slab.h>
 
 static DEFINE_MUTEX(dma_list_mutex);
+static DEFINE_IDR(dma_idr);
 static LIST_HEAD(dma_device_list);
 static long dmaengine_ref_count;
-static struct idr dma_idr;
 
 /* --- sysfs implementation --- */
 
@@ -510,8 +510,8 @@ struct dma_chan *__dma_request_channel(dma_cap_mask_t *mask, dma_filter_fn fn, v
                                          dma_chan_name(chan));
                                 list_del_rcu(&device->global_node);
                         } else if (err)
-                                pr_err("dmaengine: failed to get %s: (%d)\n",
-                                       dma_chan_name(chan), err);
+                                pr_debug("dmaengine: failed to get %s: (%d)\n",
+                                         dma_chan_name(chan), err);
                         else
                                 break;
                         if (--device->privatecnt == 0)
@@ -1050,8 +1050,6 @@ EXPORT_SYMBOL_GPL(dma_run_dependencies);
 
 static int __init dma_bus_init(void)
 {
-        idr_init(&dma_idr);
-        mutex_init(&dma_list_mutex);
         return class_register(&dma_devclass);
 }
 arch_initcall(dma_bus_init);
diff --git a/drivers/dma/ep93xx_dma.c b/drivers/dma/ep93xx_dma.c
index 0766c1e53b1d..5d7a49bd7c26 100644
--- a/drivers/dma/ep93xx_dma.c
+++ b/drivers/dma/ep93xx_dma.c
@@ -902,7 +902,7 @@ static void ep93xx_dma_free_chan_resources(struct dma_chan *chan)
  *
  * Returns a valid DMA descriptor or %NULL in case of failure.
  */
-struct dma_async_tx_descriptor *
+static struct dma_async_tx_descriptor *
 ep93xx_dma_prep_dma_memcpy(struct dma_chan *chan, dma_addr_t dest,
                            dma_addr_t src, size_t len, unsigned long flags)
 {
diff --git a/drivers/dma/imx-sdma.c b/drivers/dma/imx-sdma.c
index 1eb60ded2f0d..7bd7e98548cd 100644
--- a/drivers/dma/imx-sdma.c
+++ b/drivers/dma/imx-sdma.c
@@ -1305,8 +1305,10 @@ static int __init sdma_probe(struct platform_device *pdev)
                 goto err_request_irq;
 
         sdma->script_addrs = kzalloc(sizeof(*sdma->script_addrs), GFP_KERNEL);
-        if (!sdma->script_addrs)
+        if (!sdma->script_addrs) {
+                ret = -ENOMEM;
                 goto err_alloc;
+        }
 
         if (of_id)
                 pdev->id_entry = of_id->data;
diff --git a/drivers/dma/intel_mid_dma.c b/drivers/dma/intel_mid_dma.c
index f653517ef744..8a3fdd87db97 100644
--- a/drivers/dma/intel_mid_dma.c
+++ b/drivers/dma/intel_mid_dma.c
@@ -1351,7 +1351,6 @@ int dma_suspend(struct pci_dev *pci, pm_message_t state)
                         return -EAGAIN;
         }
         device->state = SUSPENDED;
-        pci_set_drvdata(pci, device);
         pci_save_state(pci);
         pci_disable_device(pci);
         pci_set_power_state(pci, PCI_D3hot);
@@ -1380,7 +1379,6 @@ int dma_resume(struct pci_dev *pci)
         }
         device->state = RUNNING;
         iowrite32(REG_BIT0, device->dma_base + DMA_CFG);
-        pci_set_drvdata(pci, device);
         return 0;
 }
 
diff --git a/drivers/dma/ioat/dma_v3.c b/drivers/dma/ioat/dma_v3.c
index d845dc4b7103..f519c93a61e7 100644
--- a/drivers/dma/ioat/dma_v3.c
+++ b/drivers/dma/ioat/dma_v3.c
@@ -73,10 +73,10 @@
 /* provide a lookup table for setting the source address in the base or
  * extended descriptor of an xor or pq descriptor
  */
-static const u8 xor_idx_to_desc __read_mostly = 0xd0;
-static const u8 xor_idx_to_field[] __read_mostly = { 1, 4, 5, 6, 7, 0, 1, 2 };
-static const u8 pq_idx_to_desc __read_mostly = 0xf8;
-static const u8 pq_idx_to_field[] __read_mostly = { 1, 4, 5, 0, 1, 2, 4, 5 };
+static const u8 xor_idx_to_desc = 0xe0;
+static const u8 xor_idx_to_field[] = { 1, 4, 5, 6, 7, 0, 1, 2 };
+static const u8 pq_idx_to_desc = 0xf8;
+static const u8 pq_idx_to_field[] = { 1, 4, 5, 0, 1, 2, 4, 5 };
 
 static dma_addr_t xor_get_src(struct ioat_raw_descriptor *descs[2], int idx)
 {
diff --git a/drivers/dma/ioat/pci.c b/drivers/dma/ioat/pci.c
index fab37d1cf48d..5e3a40f79945 100644
--- a/drivers/dma/ioat/pci.c
+++ b/drivers/dma/ioat/pci.c
@@ -72,6 +72,17 @@ static struct pci_device_id ioat_pci_tbl[] = {
         { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_JSF8) },
         { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_JSF9) },
 
+        { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB0) },
+        { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB1) },
+        { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB2) },
+        { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB3) },
+        { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB4) },
+        { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB5) },
+        { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB6) },
+        { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB7) },
+        { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB8) },
+        { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB9) },
+
         { 0, }
 };
 MODULE_DEVICE_TABLE(pci, ioat_pci_tbl);
diff --git a/drivers/dma/ipu/ipu_idmac.c b/drivers/dma/ipu/ipu_idmac.c
index fd7d2b308cf2..6815905a772f 100644
--- a/drivers/dma/ipu/ipu_idmac.c
+++ b/drivers/dma/ipu/ipu_idmac.c
@@ -1706,16 +1706,14 @@ static int __init ipu_probe(struct platform_device *pdev)
                 ipu_data.irq_fn, ipu_data.irq_err, ipu_data.irq_base);
 
         /* Remap IPU common registers */
-        ipu_data.reg_ipu = ioremap(mem_ipu->start,
-                                   mem_ipu->end - mem_ipu->start + 1);
+        ipu_data.reg_ipu = ioremap(mem_ipu->start, resource_size(mem_ipu));
         if (!ipu_data.reg_ipu) {
                 ret = -ENOMEM;
                 goto err_ioremap_ipu;
         }
 
         /* Remap Image Converter and Image DMA Controller registers */
-        ipu_data.reg_ic = ioremap(mem_ic->start,
-                                  mem_ic->end - mem_ic->start + 1);
+        ipu_data.reg_ic = ioremap(mem_ic->start, resource_size(mem_ic));
         if (!ipu_data.reg_ic) {
                 ret = -ENOMEM;
                 goto err_ioremap_ic;
diff --git a/drivers/dma/mv_xor.c b/drivers/dma/mv_xor.c
index 06f9f27dbe7c..9a353c2216d0 100644
--- a/drivers/dma/mv_xor.c
+++ b/drivers/dma/mv_xor.c
@@ -1304,7 +1304,8 @@ static int mv_xor_shared_probe(struct platform_device *pdev)
         if (!res)
                 return -ENODEV;
 
-        msp->xor_base = devm_ioremap(&pdev->dev, res->start, resource_size(res));
+        msp->xor_base = devm_ioremap(&pdev->dev, res->start,
+                                     resource_size(res));
         if (!msp->xor_base)
                 return -EBUSY;
 
diff --git a/drivers/dma/mxs-dma.c b/drivers/dma/mxs-dma.c
index 88aad4f54002..be641cbd36fc 100644
--- a/drivers/dma/mxs-dma.c
+++ b/drivers/dma/mxs-dma.c
@@ -327,10 +327,12 @@ static int mxs_dma_alloc_chan_resources(struct dma_chan *chan)
 
         memset(mxs_chan->ccw, 0, PAGE_SIZE);
 
-        ret = request_irq(mxs_chan->chan_irq, mxs_dma_int_handler,
-                                0, "mxs-dma", mxs_dma);
-        if (ret)
-                goto err_irq;
+        if (mxs_chan->chan_irq != NO_IRQ) {
+                ret = request_irq(mxs_chan->chan_irq, mxs_dma_int_handler,
+                                        0, "mxs-dma", mxs_dma);
+                if (ret)
+                        goto err_irq;
+        }
 
         ret = clk_enable(mxs_dma->clk);
         if (ret)
@@ -535,6 +537,7 @@ static int mxs_dma_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
         switch (cmd) {
         case DMA_TERMINATE_ALL:
                 mxs_dma_disable_chan(mxs_chan);
+                mxs_dma_reset_chan(mxs_chan);
                 break;
         case DMA_PAUSE:
                 mxs_dma_pause_chan(mxs_chan);
@@ -707,6 +710,8 @@ static struct platform_device_id mxs_dma_type[] = {
         }, {
                 .name = "mxs-dma-apbx",
                 .driver_data = MXS_DMA_APBX,
+        }, {
+                /* end of list */
         }
 };
 
diff --git a/drivers/dma/pch_dma.c b/drivers/dma/pch_dma.c
index ff5b38f9d45b..1ac8d4b580b7 100644
--- a/drivers/dma/pch_dma.c
+++ b/drivers/dma/pch_dma.c
@@ -45,7 +45,8 @@
 #define DMA_STATUS_MASK_BITS            0x3
 #define DMA_STATUS_SHIFT_BITS           16
 #define DMA_STATUS_IRQ(x)               (0x1 << (x))
-#define DMA_STATUS_ERR(x)               (0x1 << ((x) + 8))
+#define DMA_STATUS0_ERR(x)              (0x1 << ((x) + 8))
+#define DMA_STATUS2_ERR(x)              (0x1 << (x))
 
 #define DMA_DESC_WIDTH_SHIFT_BITS       12
 #define DMA_DESC_WIDTH_1_BYTE           (0x3 << DMA_DESC_WIDTH_SHIFT_BITS)
@@ -61,6 +62,9 @@
 
 #define MAX_CHAN_NR                     8
 
+#define DMA_MASK_CTL0_MODE      0x33333333
+#define DMA_MASK_CTL2_MODE      0x00003333
+
 static unsigned int init_nr_desc_per_channel = 64;
 module_param(init_nr_desc_per_channel, uint, 0644);
 MODULE_PARM_DESC(init_nr_desc_per_channel,
@@ -133,6 +137,7 @@ struct pch_dma {
 #define PCH_DMA_CTL3    0x0C
 #define PCH_DMA_STS0    0x10
 #define PCH_DMA_STS1    0x14
+#define PCH_DMA_STS2    0x18
 
 #define dma_readl(pd, name) \
         readl((pd)->membase + PCH_DMA_##name)
@@ -183,13 +188,19 @@ static void pdc_enable_irq(struct dma_chan *chan, int enable)
 {
         struct pch_dma *pd = to_pd(chan->device);
         u32 val;
+        int pos;
+
+        if (chan->chan_id < 8)
+                pos = chan->chan_id;
+        else
+                pos = chan->chan_id + 8;
 
         val = dma_readl(pd, CTL2);
 
         if (enable)
-                val |= 0x1 << chan->chan_id;
+                val |= 0x1 << pos;
         else
-                val &= ~(0x1 << chan->chan_id);
+                val &= ~(0x1 << pos);
 
         dma_writel(pd, CTL2, val);
 
@@ -202,10 +213,17 @@ static void pdc_set_dir(struct dma_chan *chan)
         struct pch_dma_chan *pd_chan = to_pd_chan(chan);
         struct pch_dma *pd = to_pd(chan->device);
         u32 val;
+        u32 mask_mode;
+        u32 mask_ctl;
 
         if (chan->chan_id < 8) {
                 val = dma_readl(pd, CTL0);
 
+                mask_mode = DMA_CTL0_MODE_MASK_BITS <<
+                                        (DMA_CTL0_BITS_PER_CH * chan->chan_id);
+                mask_ctl = DMA_MASK_CTL0_MODE & ~(DMA_CTL0_MODE_MASK_BITS <<
+                                       (DMA_CTL0_BITS_PER_CH * chan->chan_id));
+                val &= mask_mode;
                 if (pd_chan->dir == DMA_TO_DEVICE)
                         val |= 0x1 << (DMA_CTL0_BITS_PER_CH * chan->chan_id +
                                        DMA_CTL0_DIR_SHIFT_BITS);
@@ -213,18 +231,24 @@ static void pdc_set_dir(struct dma_chan *chan)
                         val &= ~(0x1 << (DMA_CTL0_BITS_PER_CH * chan->chan_id +
                                          DMA_CTL0_DIR_SHIFT_BITS));
 
+                val |= mask_ctl;
                 dma_writel(pd, CTL0, val);
         } else {
                 int ch = chan->chan_id - 8; /* ch8-->0 ch9-->1 ... ch11->3 */
                 val = dma_readl(pd, CTL3);
 
+                mask_mode = DMA_CTL0_MODE_MASK_BITS <<
+                                                (DMA_CTL0_BITS_PER_CH * ch);
+                mask_ctl = DMA_MASK_CTL2_MODE & ~(DMA_CTL0_MODE_MASK_BITS <<
+                                                 (DMA_CTL0_BITS_PER_CH * ch));
+                val &= mask_mode;
                 if (pd_chan->dir == DMA_TO_DEVICE)
                         val |= 0x1 << (DMA_CTL0_BITS_PER_CH * ch +
                                        DMA_CTL0_DIR_SHIFT_BITS);
                 else
                         val &= ~(0x1 << (DMA_CTL0_BITS_PER_CH * ch +
                                          DMA_CTL0_DIR_SHIFT_BITS));
-
+                val |= mask_ctl;
                 dma_writel(pd, CTL3, val);
         }
 
@@ -236,33 +260,37 @@ static void pdc_set_mode(struct dma_chan *chan, u32 mode)
 {
         struct pch_dma *pd = to_pd(chan->device);
         u32 val;
+        u32 mask_ctl;
+        u32 mask_dir;
 
         if (chan->chan_id < 8) {
+                mask_ctl = DMA_MASK_CTL0_MODE & ~(DMA_CTL0_MODE_MASK_BITS <<
+                           (DMA_CTL0_BITS_PER_CH * chan->chan_id));
+                mask_dir = 1 << (DMA_CTL0_BITS_PER_CH * chan->chan_id +\
+                                 DMA_CTL0_DIR_SHIFT_BITS);
                 val = dma_readl(pd, CTL0);
-
-                val &= ~(DMA_CTL0_MODE_MASK_BITS <<
-                        (DMA_CTL0_BITS_PER_CH * chan->chan_id));
+                val &= mask_dir;
                 val |= mode << (DMA_CTL0_BITS_PER_CH * chan->chan_id);
-
+                val |= mask_ctl;
                 dma_writel(pd, CTL0, val);
         } else {
                 int ch = chan->chan_id - 8; /* ch8-->0 ch9-->1 ... ch11->3 */
-
+                mask_ctl = DMA_MASK_CTL2_MODE & ~(DMA_CTL0_MODE_MASK_BITS <<
+                                                 (DMA_CTL0_BITS_PER_CH * ch));
+                mask_dir = 1 << (DMA_CTL0_BITS_PER_CH * ch +\
+                                 DMA_CTL0_DIR_SHIFT_BITS);
                 val = dma_readl(pd, CTL3);
-
-                val &= ~(DMA_CTL0_MODE_MASK_BITS <<
-                        (DMA_CTL0_BITS_PER_CH * ch));
+                val &= mask_dir;
                 val |= mode << (DMA_CTL0_BITS_PER_CH * ch);
-
+                val |= mask_ctl;
                 dma_writel(pd, CTL3, val);
-
         }
 
         dev_dbg(chan2dev(chan), "pdc_set_mode: chan %d -> %x\n",
                 chan->chan_id, val);
 }
 
-static u32 pdc_get_status(struct pch_dma_chan *pd_chan)
+static u32 pdc_get_status0(struct pch_dma_chan *pd_chan)
 {
         struct pch_dma *pd = to_pd(pd_chan->chan.device);
         u32 val;
@@ -272,9 +300,27 @@ static u32 pdc_get_status(struct pch_dma_chan *pd_chan)
                         DMA_STATUS_BITS_PER_CH * pd_chan->chan.chan_id));
 }
 
+static u32 pdc_get_status2(struct pch_dma_chan *pd_chan)
+{
+        struct pch_dma *pd = to_pd(pd_chan->chan.device);
+        u32 val;
+
+        val = dma_readl(pd, STS2);
+        return DMA_STATUS_MASK_BITS & (val >> (DMA_STATUS_SHIFT_BITS +
+                        DMA_STATUS_BITS_PER_CH * (pd_chan->chan.chan_id - 8)));
+}
+
 static bool pdc_is_idle(struct pch_dma_chan *pd_chan)
 {
-        if (pdc_get_status(pd_chan) == DMA_STATUS_IDLE)
+        u32 sts;
+
+        if (pd_chan->chan.chan_id < 8)
+                sts = pdc_get_status0(pd_chan);
+        else
+                sts = pdc_get_status2(pd_chan);
+
+
+        if (sts == DMA_STATUS_IDLE)
                 return true;
         else
                 return false;
@@ -495,11 +541,11 @@ static int pd_alloc_chan_resources(struct dma_chan *chan)
                 list_add_tail(&desc->desc_node, &tmp_list);
         }
 
-        spin_lock_bh(&pd_chan->lock);
+        spin_lock_irq(&pd_chan->lock);
         list_splice(&tmp_list, &pd_chan->free_list);
         pd_chan->descs_allocated = i;
         pd_chan->completed_cookie = chan->cookie = 1;
-        spin_unlock_bh(&pd_chan->lock);
+        spin_unlock_irq(&pd_chan->lock);
 
         pdc_enable_irq(chan, 1);
 
@@ -517,10 +563,10 @@ static void pd_free_chan_resources(struct dma_chan *chan)
         BUG_ON(!list_empty(&pd_chan->active_list));
         BUG_ON(!list_empty(&pd_chan->queue));
 
-        spin_lock_bh(&pd_chan->lock);
+        spin_lock_irq(&pd_chan->lock);
         list_splice_init(&pd_chan->free_list, &tmp_list);
         pd_chan->descs_allocated = 0;
-        spin_unlock_bh(&pd_chan->lock);
+        spin_unlock_irq(&pd_chan->lock);
 
         list_for_each_entry_safe(desc, _d, &tmp_list, desc_node)
                 pci_pool_free(pd->pool, desc, desc->txd.phys);
@@ -536,10 +582,10 @@ static enum dma_status pd_tx_status(struct dma_chan *chan, dma_cookie_t cookie,
         dma_cookie_t last_completed;
         int ret;
 
-        spin_lock_bh(&pd_chan->lock);
+        spin_lock_irq(&pd_chan->lock);
         last_completed = pd_chan->completed_cookie;
         last_used = chan->cookie;
-        spin_unlock_bh(&pd_chan->lock);
+        spin_unlock_irq(&pd_chan->lock);
 
         ret = dma_async_is_complete(cookie, last_completed, last_used);
 
@@ -654,7 +700,7 @@ static int pd_device_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
         if (cmd != DMA_TERMINATE_ALL)
                 return -ENXIO;
 
-        spin_lock_bh(&pd_chan->lock);
+        spin_lock_irq(&pd_chan->lock);
 
         pdc_set_mode(&pd_chan->chan, DMA_CTL0_DISABLE);
 
@@ -664,7 +710,7 @@ static int pd_device_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
         list_for_each_entry_safe(desc, _d, &list, desc_node)
                 pdc_chain_complete(pd_chan, desc);
 
-        spin_unlock_bh(&pd_chan->lock);
+        spin_unlock_irq(&pd_chan->lock);
 
         return 0;
 }
@@ -693,30 +739,45 @@ static irqreturn_t pd_irq(int irq, void *devid)
         struct pch_dma *pd = (struct pch_dma *)devid;
         struct pch_dma_chan *pd_chan;
         u32 sts0;
+        u32 sts2;
         int i;
-        int ret = IRQ_NONE;
+        int ret0 = IRQ_NONE;
+        int ret2 = IRQ_NONE;
 
         sts0 = dma_readl(pd, STS0);
+        sts2 = dma_readl(pd, STS2);
 
         dev_dbg(pd->dma.dev, "pd_irq sts0: %x\n", sts0);
 
         for (i = 0; i < pd->dma.chancnt; i++) {
                 pd_chan = &pd->channels[i];
 
-                if (sts0 & DMA_STATUS_IRQ(i)) {
-                        if (sts0 & DMA_STATUS_ERR(i))
-                                set_bit(0, &pd_chan->err_status);
+                if (i < 8) {
+                        if (sts0 & DMA_STATUS_IRQ(i)) {
+                                if (sts0 & DMA_STATUS0_ERR(i))
+                                        set_bit(0, &pd_chan->err_status);
 
-                        tasklet_schedule(&pd_chan->tasklet);
-                        ret = IRQ_HANDLED;
-                }
+                                tasklet_schedule(&pd_chan->tasklet);
+                                ret0 = IRQ_HANDLED;
+                        }
+                } else {
+                        if (sts2 & DMA_STATUS_IRQ(i - 8)) {
+                                if (sts2 & DMA_STATUS2_ERR(i))
+                                        set_bit(0, &pd_chan->err_status);
 
+                                tasklet_schedule(&pd_chan->tasklet);
+                                ret2 = IRQ_HANDLED;
+                        }
+                }
         }
 
         /* clear interrupt bits in status register */
-        dma_writel(pd, STS0, sts0);
+        if (ret0)
+                dma_writel(pd, STS0, sts0);
+        if (ret2)
+                dma_writel(pd, STS2, sts2);
 
-        return ret;
+        return ret0 | ret2;
 }
 
 #ifdef  CONFIG_PM
diff --git a/drivers/dma/pl330.c b/drivers/dma/pl330.c
index 6abe1ec1f2ce..00eee59e8b33 100644
--- a/drivers/dma/pl330.c
+++ b/drivers/dma/pl330.c
@@ -82,7 +82,7 @@ struct dma_pl330_dmac {
         spinlock_t pool_lock;
 
         /* Peripheral channels connected to this DMAC */
-        struct dma_pl330_chan peripherals[0]; /* keep at end */
+        struct dma_pl330_chan *peripherals; /* keep at end */
 };
 
 struct dma_pl330_desc {
@@ -451,8 +451,13 @@ static struct dma_pl330_desc *pl330_get_desc(struct dma_pl330_chan *pch)
         desc->txd.cookie = 0;
         async_tx_ack(&desc->txd);
 
-        desc->req.rqtype = peri->rqtype;
-        desc->req.peri = peri->peri_id;
+        if (peri) {
+                desc->req.rqtype = peri->rqtype;
+                desc->req.peri = peri->peri_id;
+        } else {
+                desc->req.rqtype = MEMTOMEM;
+                desc->req.peri = 0;
+        }
 
         dma_async_tx_descriptor_init(&desc->txd, &pch->chan);
 
@@ -529,10 +534,10 @@ pl330_prep_dma_memcpy(struct dma_chan *chan, dma_addr_t dst,
         struct pl330_info *pi;
         int burst;
 
-        if (unlikely(!pch || !len || !peri))
+        if (unlikely(!pch || !len))
                 return NULL;
 
-        if (peri->rqtype != MEMTOMEM)
+        if (peri && peri->rqtype != MEMTOMEM)
                 return NULL;
 
         pi = &pch->dmac->pif;
@@ -577,7 +582,7 @@ pl330_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
         int i, burst_size;
         dma_addr_t addr;
 
-        if (unlikely(!pch || !sgl || !sg_len))
+        if (unlikely(!pch || !sgl || !sg_len || !peri))
                 return NULL;
 
         /* Make sure the direction is consistent */
@@ -666,17 +671,12 @@ pl330_probe(struct amba_device *adev, const struct amba_id *id)
         struct dma_device *pd;
         struct resource *res;
         int i, ret, irq;
+        int num_chan;
 
         pdat = adev->dev.platform_data;
 
-        if (!pdat || !pdat->nr_valid_peri) {
-                dev_err(&adev->dev, "platform data missing\n");
-                return -ENODEV;
-        }
-
         /* Allocate a new DMAC and its Channels */
-        pdmac = kzalloc(pdat->nr_valid_peri * sizeof(*pch)
-                                + sizeof(*pdmac), GFP_KERNEL);
+        pdmac = kzalloc(sizeof(*pdmac), GFP_KERNEL);
         if (!pdmac) {
                 dev_err(&adev->dev, "unable to allocate mem\n");
                 return -ENOMEM;
@@ -685,7 +685,7 @@ pl330_probe(struct amba_device *adev, const struct amba_id *id)
         pi = &pdmac->pif;
         pi->dev = &adev->dev;
         pi->pl330_data = NULL;
-        pi->mcbufsz = pdat->mcbuf_sz;
+        pi->mcbufsz = pdat ? pdat->mcbuf_sz : 0;
 
         res = &adev->res;
         request_mem_region(res->start, resource_size(res), "dma-pl330");
@@ -717,27 +717,35 @@ pl330_probe(struct amba_device *adev, const struct amba_id *id)
         INIT_LIST_HEAD(&pd->channels);
 
         /* Initialize channel parameters */
-        for (i = 0; i < pdat->nr_valid_peri; i++) {
-                struct dma_pl330_peri *peri = &pdat->peri[i];
-                pch = &pdmac->peripherals[i];
+        num_chan = max(pdat ? pdat->nr_valid_peri : 0, (u8)pi->pcfg.num_chan);
+        pdmac->peripherals = kzalloc(num_chan * sizeof(*pch), GFP_KERNEL);
 
-                switch (peri->rqtype) {
-                case MEMTOMEM:
+        for (i = 0; i < num_chan; i++) {
+                pch = &pdmac->peripherals[i];
+                if (pdat) {
+                        struct dma_pl330_peri *peri = &pdat->peri[i];
+
+                        switch (peri->rqtype) {
+                        case MEMTOMEM:
+                                dma_cap_set(DMA_MEMCPY, pd->cap_mask);
+                                break;
+                        case MEMTODEV:
+                        case DEVTOMEM:
+                                dma_cap_set(DMA_SLAVE, pd->cap_mask);
+                                break;
+                        default:
+                                dev_err(&adev->dev, "DEVTODEV Not Supported\n");
+                                continue;
+                        }
+                        pch->chan.private = peri;
+                } else {
                         dma_cap_set(DMA_MEMCPY, pd->cap_mask);
-                        break;
-                case MEMTODEV:
-                case DEVTOMEM:
-                        dma_cap_set(DMA_SLAVE, pd->cap_mask);
-                        break;
-                default:
-                        dev_err(&adev->dev, "DEVTODEV Not Supported\n");
-                        continue;
+                        pch->chan.private = NULL;
                 }
 
                 INIT_LIST_HEAD(&pch->work_list);
                 spin_lock_init(&pch->lock);
                 pch->pl330_chid = NULL;
-                pch->chan.private = peri;
                 pch->chan.device = pd;
                 pch->chan.chan_id = i;
                 pch->dmac = pdmac;
diff --git a/drivers/dma/shdma.c b/drivers/dma/shdma.c
index 028330044201..7f49235d14b9 100644
--- a/drivers/dma/shdma.c
+++ b/drivers/dma/shdma.c
@@ -70,12 +70,36 @@ static u32 sh_dmae_readl(struct sh_dmae_chan *sh_dc, u32 reg)
 
 static u16 dmaor_read(struct sh_dmae_device *shdev)
 {
-        return __raw_readw(shdev->chan_reg + DMAOR / sizeof(u32));
+        u32 __iomem *addr = shdev->chan_reg + DMAOR / sizeof(u32);
+
+        if (shdev->pdata->dmaor_is_32bit)
+                return __raw_readl(addr);
+        else
+                return __raw_readw(addr);
 }
 
 static void dmaor_write(struct sh_dmae_device *shdev, u16 data)
 {
-        __raw_writew(data, shdev->chan_reg + DMAOR / sizeof(u32));
+        u32 __iomem *addr = shdev->chan_reg + DMAOR / sizeof(u32);
+
+        if (shdev->pdata->dmaor_is_32bit)
+                __raw_writel(data, addr);
+        else
+                __raw_writew(data, addr);
+}
+
+static void chcr_write(struct sh_dmae_chan *sh_dc, u32 data)
+{
+        struct sh_dmae_device *shdev = to_sh_dev(sh_dc);
+
+        __raw_writel(data, sh_dc->base + shdev->chcr_offset / sizeof(u32));
+}
+
+static u32 chcr_read(struct sh_dmae_chan *sh_dc)
+{
+        struct sh_dmae_device *shdev = to_sh_dev(sh_dc);
+
+        return __raw_readl(sh_dc->base + shdev->chcr_offset / sizeof(u32));
 }
 
 /*
@@ -120,7 +144,7 @@ static int sh_dmae_rst(struct sh_dmae_device *shdev)
 
 static bool dmae_is_busy(struct sh_dmae_chan *sh_chan)
 {
-        u32 chcr = sh_dmae_readl(sh_chan, CHCR);
+        u32 chcr = chcr_read(sh_chan);
 
         if ((chcr & (CHCR_DE | CHCR_TE)) == CHCR_DE)
                 return true; /* working */
@@ -130,8 +154,7 @@ static bool dmae_is_busy(struct sh_dmae_chan *sh_chan)
 
 static unsigned int calc_xmit_shift(struct sh_dmae_chan *sh_chan, u32 chcr)
 {
-        struct sh_dmae_device *shdev = container_of(sh_chan->common.device,
-                                                struct sh_dmae_device, common);
+        struct sh_dmae_device *shdev = to_sh_dev(sh_chan);
         struct sh_dmae_pdata *pdata = shdev->pdata;
         int cnt = ((chcr & pdata->ts_low_mask) >> pdata->ts_low_shift) |
                 ((chcr & pdata->ts_high_mask) >> pdata->ts_high_shift);
@@ -144,8 +167,7 @@ static unsigned int calc_xmit_shift(struct sh_dmae_chan *sh_chan, u32 chcr)
 
 static u32 log2size_to_chcr(struct sh_dmae_chan *sh_chan, int l2size)
 {
-        struct sh_dmae_device *shdev = container_of(sh_chan->common.device,
-                                                struct sh_dmae_device, common);
+        struct sh_dmae_device *shdev = to_sh_dev(sh_chan);
         struct sh_dmae_pdata *pdata = shdev->pdata;
         int i;
 
@@ -169,18 +191,23 @@ static void dmae_set_reg(struct sh_dmae_chan *sh_chan, struct sh_dmae_regs *hw)
 
 static void dmae_start(struct sh_dmae_chan *sh_chan)
 {
-        u32 chcr = sh_dmae_readl(sh_chan, CHCR);
+        struct sh_dmae_device *shdev = to_sh_dev(sh_chan);
+        u32 chcr = chcr_read(sh_chan);
+
+        if (shdev->pdata->needs_tend_set)
+                sh_dmae_writel(sh_chan, 0xFFFFFFFF, TEND);
 
-        chcr |= CHCR_DE | CHCR_IE;
-        sh_dmae_writel(sh_chan, chcr & ~CHCR_TE, CHCR);
+        chcr |= CHCR_DE | shdev->chcr_ie_bit;
+        chcr_write(sh_chan, chcr & ~CHCR_TE);
 }
 
 static void dmae_halt(struct sh_dmae_chan *sh_chan)
 {
-        u32 chcr = sh_dmae_readl(sh_chan, CHCR);
+        struct sh_dmae_device *shdev = to_sh_dev(sh_chan);
+        u32 chcr = chcr_read(sh_chan);
 
-        chcr &= ~(CHCR_DE | CHCR_TE | CHCR_IE);
-        sh_dmae_writel(sh_chan, chcr, CHCR);
+        chcr &= ~(CHCR_DE | CHCR_TE | shdev->chcr_ie_bit);
+        chcr_write(sh_chan, chcr);
 }
 
 static void dmae_init(struct sh_dmae_chan *sh_chan)
@@ -192,7 +219,7 @@ static void dmae_init(struct sh_dmae_chan *sh_chan)
         u32 chcr = DM_INC | SM_INC | 0x400 | log2size_to_chcr(sh_chan,
                                                    LOG2_DEFAULT_XFER_SIZE);
         sh_chan->xmit_shift = calc_xmit_shift(sh_chan, chcr);
-        sh_dmae_writel(sh_chan, chcr, CHCR);
+        chcr_write(sh_chan, chcr);
 }
 
 static int dmae_set_chcr(struct sh_dmae_chan *sh_chan, u32 val)
@@ -202,23 +229,25 @@ static int dmae_set_chcr(struct sh_dmae_chan *sh_chan, u32 val)
                 return -EBUSY;
 
         sh_chan->xmit_shift = calc_xmit_shift(sh_chan, val);
-        sh_dmae_writel(sh_chan, val, CHCR);
+        chcr_write(sh_chan, val);
 
         return 0;
 }
 
 static int dmae_set_dmars(struct sh_dmae_chan *sh_chan, u16 val)
 {
-        struct sh_dmae_device *shdev = container_of(sh_chan->common.device,
-                                                struct sh_dmae_device, common);
+        struct sh_dmae_device *shdev = to_sh_dev(sh_chan);
         struct sh_dmae_pdata *pdata = shdev->pdata;
         const struct sh_dmae_channel *chan_pdata = &pdata->channel[sh_chan->id];
         u16 __iomem *addr = shdev->dmars;
-        int shift = chan_pdata->dmars_bit;
+        unsigned int shift = chan_pdata->dmars_bit;
 
         if (dmae_is_busy(sh_chan))
                 return -EBUSY;
 
+        if (pdata->no_dmars)
+                return 0;
+
         /* in the case of a missing DMARS resource use first memory window */
         if (!addr)
                 addr = (u16 __iomem *)shdev->chan_reg;
@@ -296,9 +325,7 @@ static struct sh_desc *sh_dmae_get_desc(struct sh_dmae_chan *sh_chan)
 static const struct sh_dmae_slave_config *sh_dmae_find_slave(
         struct sh_dmae_chan *sh_chan, struct sh_dmae_slave *param)
 {
-        struct dma_device *dma_dev = sh_chan->common.device;
-        struct sh_dmae_device *shdev = container_of(dma_dev,
-                                        struct sh_dmae_device, common);
+        struct sh_dmae_device *shdev = to_sh_dev(sh_chan);
         struct sh_dmae_pdata *pdata = shdev->pdata;
         int i;
 
@@ -771,10 +798,8 @@ static void sh_chan_xfer_ld_queue(struct sh_dmae_chan *sh_chan)
 
         spin_lock_bh(&sh_chan->desc_lock);
         /* DMA work check */
-        if (dmae_is_busy(sh_chan)) {
-                spin_unlock_bh(&sh_chan->desc_lock);
-                return;
-        }
+        if (dmae_is_busy(sh_chan))
+                goto sh_chan_xfer_ld_queue_end;
 
         /* Find the first not transferred descriptor */
         list_for_each_entry(desc, &sh_chan->ld_queue, node)
@@ -788,6 +813,7 @@ static void sh_chan_xfer_ld_queue(struct sh_dmae_chan *sh_chan)
                         break;
                 }
 
+sh_chan_xfer_ld_queue_end:
         spin_unlock_bh(&sh_chan->desc_lock);
 }
 
@@ -846,7 +872,7 @@ static irqreturn_t sh_dmae_interrupt(int irq, void *data)
 
         spin_lock(&sh_chan->desc_lock);
 
-        chcr = sh_dmae_readl(sh_chan, CHCR);
+        chcr = chcr_read(sh_chan);
 
         if (chcr & CHCR_TE) {
                 /* DMA stop */
@@ -1144,6 +1170,16 @@ static int __init sh_dmae_probe(struct platform_device *pdev)
         /* platform data */
         shdev->pdata = pdata;
 
+        if (pdata->chcr_offset)
+                shdev->chcr_offset = pdata->chcr_offset;
+        else
+                shdev->chcr_offset = CHCR;
+
+        if (pdata->chcr_ie_bit)
+                shdev->chcr_ie_bit = pdata->chcr_ie_bit;
+        else
+                shdev->chcr_ie_bit = CHCR_IE;
+
         platform_set_drvdata(pdev, shdev);
 
         pm_runtime_enable(&pdev->dev);
diff --git a/drivers/dma/shdma.h b/drivers/dma/shdma.h
index 5ae9fc512180..dc56576f9fdb 100644
--- a/drivers/dma/shdma.h
+++ b/drivers/dma/shdma.h
@@ -47,10 +47,14 @@ struct sh_dmae_device {
         struct list_head node;
         u32 __iomem *chan_reg;
         u16 __iomem *dmars;
+        unsigned int chcr_offset;
+        u32 chcr_ie_bit;
 };
 
 #define to_sh_chan(chan) container_of(chan, struct sh_dmae_chan, common)
 #define to_sh_desc(lh) container_of(lh, struct sh_desc, node)
 #define tx_to_sh_desc(tx) container_of(tx, struct sh_desc, async_tx)
+#define to_sh_dev(chan) container_of(chan->common.device,\
+                                     struct sh_dmae_device, common)
 
 #endif  /* __DMA_SHDMA_H */
diff --git a/drivers/dma/ste_dma40.c b/drivers/dma/ste_dma40.c
index 29d1addbe0cf..467e4dcb20a0 100644
--- a/drivers/dma/ste_dma40.c
+++ b/drivers/dma/ste_dma40.c
@@ -14,6 +14,7 @@
 #include <linux/clk.h>
 #include <linux/delay.h>
 #include <linux/err.h>
+#include <linux/amba/bus.h>
 
 #include <plat/ste_dma40.h>
 
@@ -45,9 +46,6 @@
 #define D40_ALLOC_PHY           (1 << 30)
 #define D40_ALLOC_LOG_FREE      0
 
-/* Hardware designer of the block */
-#define D40_HW_DESIGNER 0x8
-
 /**
  * enum 40_command - The different commands and/or statuses.
  *
@@ -176,8 +174,10 @@ struct d40_base;
  * @tasklet: Tasklet that gets scheduled from interrupt context to complete a
  * transfer and call client callback.
  * @client: Cliented owned descriptor list.
+ * @pending_queue: Submitted jobs, to be issued by issue_pending()
  * @active: Active descriptor.
  * @queue: Queued jobs.
+ * @prepare_queue: Prepared jobs.
  * @dma_cfg: The client configuration of this dma channel.
  * @configured: whether the dma_cfg configuration is valid
  * @base: Pointer to the device instance struct.
@@ -186,6 +186,8 @@ struct d40_base;
  * @log_def: Default logical channel settings.
  * @lcla: Space for one dst src pair for logical channel transfers.
  * @lcpa: Pointer to dst and src lcpa settings.
+ * @runtime_addr: runtime configured address.
+ * @runtime_direction: runtime configured direction.
  *
  * This struct can either "be" a logical or a physical channel.
  */
@@ -200,8 +202,10 @@ struct d40_chan {
         struct dma_chan                  chan;
         struct tasklet_struct            tasklet;
         struct list_head                 client;
+        struct list_head                 pending_queue;
         struct list_head                 active;
         struct list_head                 queue;
+        struct list_head                 prepare_queue;
         struct stedma40_chan_cfg         dma_cfg;
         bool                             configured;
         struct d40_base                 *base;
@@ -476,7 +480,6 @@ static struct d40_desc *d40_desc_get(struct d40_chan *d40c)
 
                 list_for_each_entry_safe(d, _d, &d40c->client, node)
                         if (async_tx_test_ack(&d->txd)) {
-                                d40_pool_lli_free(d40c, d);
                                 d40_desc_remove(d);
                                 desc = d;
                                 memset(desc, 0, sizeof(*desc));
@@ -643,9 +646,25 @@ static struct d40_desc *d40_first_active_get(struct d40_chan *d40c)
         return d;
 }
 
+/* remove desc from current queue and add it to the pending_queue */
 static void d40_desc_queue(struct d40_chan *d40c, struct d40_desc *desc)
 {
-        list_add_tail(&desc->node, &d40c->queue);
+        d40_desc_remove(desc);
+        desc->is_in_client_list = false;
+        list_add_tail(&desc->node, &d40c->pending_queue);
+}
+
+static struct d40_desc *d40_first_pending(struct d40_chan *d40c)
+{
+        struct d40_desc *d;
+
+        if (list_empty(&d40c->pending_queue))
+                return NULL;
+
+        d = list_first_entry(&d40c->pending_queue,
+                             struct d40_desc,
+                             node);
+        return d;
 }
 
 static struct d40_desc *d40_first_queued(struct d40_chan *d40c)
@@ -789,6 +808,7 @@ done:
 static void d40_term_all(struct d40_chan *d40c)
 {
         struct d40_desc *d40d;
+        struct d40_desc *_d;
 
         /* Release active descriptors */
         while ((d40d = d40_first_active_get(d40c))) {
@@ -802,6 +822,26 @@ static void d40_term_all(struct d40_chan *d40c)
                 d40_desc_free(d40c, d40d);
         }
 
+        /* Release pending descriptors */
+        while ((d40d = d40_first_pending(d40c))) {
+                d40_desc_remove(d40d);
+                d40_desc_free(d40c, d40d);
+        }
+
+        /* Release client owned descriptors */
+        if (!list_empty(&d40c->client))
+                list_for_each_entry_safe(d40d, _d, &d40c->client, node) {
+                        d40_desc_remove(d40d);
+                        d40_desc_free(d40c, d40d);
+                }
+
+        /* Release descriptors in prepare queue */
+        if (!list_empty(&d40c->prepare_queue))
+                list_for_each_entry_safe(d40d, _d,
+                                         &d40c->prepare_queue, node) {
+                        d40_desc_remove(d40d);
+                        d40_desc_free(d40c, d40d);
+                }
 
         d40c->pending_tx = 0;
         d40c->busy = false;
@@ -1189,7 +1229,6 @@ static void dma_tasklet(unsigned long data)
 
         if (!d40d->cyclic) {
                 if (async_tx_test_ack(&d40d->txd)) {
-                        d40_pool_lli_free(d40c, d40d);
                         d40_desc_remove(d40d);
                         d40_desc_free(d40c, d40d);
                 } else {
@@ -1576,21 +1615,10 @@ static int d40_free_dma(struct d40_chan *d40c)
         u32 event;
         struct d40_phy_res *phy = d40c->phy_chan;
         bool is_src;
-        struct d40_desc *d;
-        struct d40_desc *_d;
-
 
         /* Terminate all queued and active transfers */
         d40_term_all(d40c);
 
-        /* Release client owned descriptors */
-        if (!list_empty(&d40c->client))
-                list_for_each_entry_safe(d, _d, &d40c->client, node) {
-                        d40_pool_lli_free(d40c, d);
-                        d40_desc_remove(d);
-                        d40_desc_free(d40c, d);
-                }
-
         if (phy == NULL) {
                 chan_err(d40c, "phy == null\n");
                 return -EINVAL;
@@ -1892,6 +1920,12 @@ d40_prep_sg(struct dma_chan *dchan, struct scatterlist *sg_src,
                 goto err;
         }
 
+        /*
+         * add descriptor to the prepare queue in order to be able
+         * to free them later in terminate_all
+         */
+        list_add_tail(&desc->node, &chan->prepare_queue);
+
         spin_unlock_irqrestore(&chan->lock, flags);
 
         return &desc->txd;
@@ -2092,7 +2126,7 @@ dma40_prep_dma_cyclic(struct dma_chan *chan, dma_addr_t dma_addr,
         struct scatterlist *sg;
         int i;
 
-        sg = kcalloc(periods + 1, sizeof(struct scatterlist), GFP_KERNEL);
+        sg = kcalloc(periods + 1, sizeof(struct scatterlist), GFP_NOWAIT);
         for (i = 0; i < periods; i++) {
                 sg_dma_address(&sg[i]) = dma_addr;
                 sg_dma_len(&sg[i]) = period_len;
@@ -2152,24 +2186,87 @@ static void d40_issue_pending(struct dma_chan *chan)
 
         spin_lock_irqsave(&d40c->lock, flags);
 
-        /* Busy means that pending jobs are already being processed */
+        list_splice_tail_init(&d40c->pending_queue, &d40c->queue);
+
+        /* Busy means that queued jobs are already being processed */
         if (!d40c->busy)
                 (void) d40_queue_start(d40c);
 
         spin_unlock_irqrestore(&d40c->lock, flags);
 }
 
+static int
+dma40_config_to_halfchannel(struct d40_chan *d40c,
+                            struct stedma40_half_channel_info *info,
+                            enum dma_slave_buswidth width,
+                            u32 maxburst)
+{
+        enum stedma40_periph_data_width addr_width;
+        int psize;
+
+        switch (width) {
+        case DMA_SLAVE_BUSWIDTH_1_BYTE:
+                addr_width = STEDMA40_BYTE_WIDTH;
+                break;
+        case DMA_SLAVE_BUSWIDTH_2_BYTES:
+                addr_width = STEDMA40_HALFWORD_WIDTH;
+                break;
+        case DMA_SLAVE_BUSWIDTH_4_BYTES:
+                addr_width = STEDMA40_WORD_WIDTH;
+                break;
+        case DMA_SLAVE_BUSWIDTH_8_BYTES:
+                addr_width = STEDMA40_DOUBLEWORD_WIDTH;
+                break;
+        default:
+                dev_err(d40c->base->dev,
+                        "illegal peripheral address width "
+                        "requested (%d)\n",
+                        width);
+                return -EINVAL;
+        }
+
+        if (chan_is_logical(d40c)) {
+                if (maxburst >= 16)
+                        psize = STEDMA40_PSIZE_LOG_16;
+                else if (maxburst >= 8)
+                        psize = STEDMA40_PSIZE_LOG_8;
+                else if (maxburst >= 4)
+                        psize = STEDMA40_PSIZE_LOG_4;
+                else
+                        psize = STEDMA40_PSIZE_LOG_1;
+        } else {
+                if (maxburst >= 16)
+                        psize = STEDMA40_PSIZE_PHY_16;
+                else if (maxburst >= 8)
+                        psize = STEDMA40_PSIZE_PHY_8;
+                else if (maxburst >= 4)
+                        psize = STEDMA40_PSIZE_PHY_4;
+                else
+                        psize = STEDMA40_PSIZE_PHY_1;
+        }
+
+        info->data_width = addr_width;
+        info->psize = psize;
+        info->flow_ctrl = STEDMA40_NO_FLOW_CTRL;
+
+        return 0;
+}
+
 /* Runtime reconfiguration extension */
-static void d40_set_runtime_config(struct dma_chan *chan,
-                               struct dma_slave_config *config)
+static int d40_set_runtime_config(struct dma_chan *chan,
+                                  struct dma_slave_config *config)
 {
         struct d40_chan *d40c = container_of(chan, struct d40_chan, chan);
         struct stedma40_chan_cfg *cfg = &d40c->dma_cfg;
-        enum dma_slave_buswidth config_addr_width;
+        enum dma_slave_buswidth src_addr_width, dst_addr_width;
         dma_addr_t config_addr;
-        u32 config_maxburst;
-        enum stedma40_periph_data_width addr_width;
-        int psize;
+        u32 src_maxburst, dst_maxburst;
+        int ret;
+
+        src_addr_width = config->src_addr_width;
+        src_maxburst = config->src_maxburst;
+        dst_addr_width = config->dst_addr_width;
+        dst_maxburst = config->dst_maxburst;
 
         if (config->direction == DMA_FROM_DEVICE) {
                 dma_addr_t dev_addr_rx =
@@ -2188,8 +2285,11 @@ static void d40_set_runtime_config(struct dma_chan *chan,
                                 cfg->dir);
                 cfg->dir = STEDMA40_PERIPH_TO_MEM;
 
-                config_addr_width = config->src_addr_width;
-                config_maxburst = config->src_maxburst;
+                /* Configure the memory side */
+                if (dst_addr_width == DMA_SLAVE_BUSWIDTH_UNDEFINED)
+                        dst_addr_width = src_addr_width;
+                if (dst_maxburst == 0)
+                        dst_maxburst = src_maxburst;
 
         } else if (config->direction == DMA_TO_DEVICE) {
                 dma_addr_t dev_addr_tx =
@@ -2208,68 +2308,39 @@ static void d40_set_runtime_config(struct dma_chan *chan,
                                 cfg->dir);
                 cfg->dir = STEDMA40_MEM_TO_PERIPH;
 
-                config_addr_width = config->dst_addr_width;
-                config_maxburst = config->dst_maxburst;
-
+                /* Configure the memory side */
+                if (src_addr_width == DMA_SLAVE_BUSWIDTH_UNDEFINED)
+                        src_addr_width = dst_addr_width;
+                if (src_maxburst == 0)
+                        src_maxburst = dst_maxburst;
         } else {
                 dev_err(d40c->base->dev,
                         "unrecognized channel direction %d\n",
                         config->direction);
-                return;
+                return -EINVAL;
         }
 
-        switch (config_addr_width) {
-        case DMA_SLAVE_BUSWIDTH_1_BYTE:
-                addr_width = STEDMA40_BYTE_WIDTH;
-                break;
-        case DMA_SLAVE_BUSWIDTH_2_BYTES:
-                addr_width = STEDMA40_HALFWORD_WIDTH;
-                break;
-        case DMA_SLAVE_BUSWIDTH_4_BYTES:
-                addr_width = STEDMA40_WORD_WIDTH;
-                break;
-        case DMA_SLAVE_BUSWIDTH_8_BYTES:
-                addr_width = STEDMA40_DOUBLEWORD_WIDTH;
-                break;
-        default:
+        if (src_maxburst * src_addr_width != dst_maxburst * dst_addr_width) {
                 dev_err(d40c->base->dev,
-                        "illegal peripheral address width "
-                        "requested (%d)\n",
-                        config->src_addr_width);
-                return;
+                        "src/dst width/maxburst mismatch: %d*%d != %d*%d\n",
+                        src_maxburst,
+                        src_addr_width,
+                        dst_maxburst,
+                        dst_addr_width);
+                return -EINVAL;
         }
 
-        if (chan_is_logical(d40c)) {
-                if (config_maxburst >= 16)
-                        psize = STEDMA40_PSIZE_LOG_16;
-                else if (config_maxburst >= 8)
-                        psize = STEDMA40_PSIZE_LOG_8;
-                else if (config_maxburst >= 4)
-                        psize = STEDMA40_PSIZE_LOG_4;
-                else
-                        psize = STEDMA40_PSIZE_LOG_1;
-        } else {
-                if (config_maxburst >= 16)
-                        psize = STEDMA40_PSIZE_PHY_16;
-                else if (config_maxburst >= 8)
-                        psize = STEDMA40_PSIZE_PHY_8;
-                else if (config_maxburst >= 4)
-                        psize = STEDMA40_PSIZE_PHY_4;
-                else if (config_maxburst >= 2)
-                        psize = STEDMA40_PSIZE_PHY_2;
-                else
-                        psize = STEDMA40_PSIZE_PHY_1;
-        }
+        ret = dma40_config_to_halfchannel(d40c, &cfg->src_info,
+                                          src_addr_width,
+                                          src_maxburst);
+        if (ret)
+                return ret;
 
-        /* Set up all the endpoint configs */
-        cfg->src_info.data_width = addr_width;
-        cfg->src_info.psize = psize;
-        cfg->src_info.big_endian = false;
-        cfg->src_info.flow_ctrl = STEDMA40_NO_FLOW_CTRL;
-        cfg->dst_info.data_width = addr_width;
-        cfg->dst_info.psize = psize;
-        cfg->dst_info.big_endian = false;
-        cfg->dst_info.flow_ctrl = STEDMA40_NO_FLOW_CTRL;
+        ret = dma40_config_to_halfchannel(d40c, &cfg->dst_info,
+                                          dst_addr_width,
+                                          dst_maxburst);
+        if (ret)
+                return ret;
 
         /* Fill in register values */
         if (chan_is_logical(d40c))
@@ -2282,12 +2353,14 @@ static void d40_set_runtime_config(struct dma_chan *chan,
         d40c->runtime_addr = config_addr;
         d40c->runtime_direction = config->direction;
         dev_dbg(d40c->base->dev,
-                "configured channel %s for %s, data width %d, "
-                "maxburst %d bytes, LE, no flow control\n",
+                "configured channel %s for %s, data width %d/%d, "
+                "maxburst %d/%d elements, LE, no flow control\n",
                 dma_chan_name(chan),
                 (config->direction == DMA_FROM_DEVICE) ? "RX" : "TX",
-                config_addr_width,
-                config_maxburst);
+                src_addr_width, dst_addr_width,
+                src_maxburst, dst_maxburst);
+
+        return 0;
 }
 
 static int d40_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
@@ -2308,9 +2381,8 @@ static int d40_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
         case DMA_RESUME:
                 return d40_resume(d40c);
         case DMA_SLAVE_CONFIG:
-                d40_set_runtime_config(chan,
+                return d40_set_runtime_config(chan,
                         (struct dma_slave_config *) arg);
-                return 0;
         default:
                 break;
         }
@@ -2341,7 +2413,9 @@ static void __init d40_chan_init(struct d40_base *base, struct dma_device *dma,
 
                 INIT_LIST_HEAD(&d40c->active);
                 INIT_LIST_HEAD(&d40c->queue);
+                INIT_LIST_HEAD(&d40c->pending_queue);
                 INIT_LIST_HEAD(&d40c->client);
+                INIT_LIST_HEAD(&d40c->prepare_queue);
 
                 tasklet_init(&d40c->tasklet, dma_tasklet,
                              (unsigned long) d40c);
@@ -2502,25 +2576,6 @@ static int __init d40_phy_res_init(struct d40_base *base)
 
 static struct d40_base * __init d40_hw_detect_init(struct platform_device *pdev)
 {
-        static const struct d40_reg_val dma_id_regs[] = {
-                /* Peripheral Id */
-                { .reg = D40_DREG_PERIPHID0, .val = 0x0040},
-                { .reg = D40_DREG_PERIPHID1, .val = 0x0000},
-                /*
-                 * D40_DREG_PERIPHID2 Depends on HW revision:
-                 *  DB8500ed has 0x0008,
-                 *  ? has 0x0018,
-                 *  DB8500v1 has 0x0028
-                 *  DB8500v2 has 0x0038
-                 */
-                { .reg = D40_DREG_PERIPHID3, .val = 0x0000},
-
-                /* PCell Id */
-                { .reg = D40_DREG_CELLID0, .val = 0x000d},
-                { .reg = D40_DREG_CELLID1, .val = 0x00f0},
-                { .reg = D40_DREG_CELLID2, .val = 0x0005},
-                { .reg = D40_DREG_CELLID3, .val = 0x00b1}
-        };
         struct stedma40_platform_data *plat_data;
         struct clk *clk = NULL;
         void __iomem *virtbase = NULL;
@@ -2529,8 +2584,9 @@ static struct d40_base * __init d40_hw_detect_init(struct platform_device *pdev)
         int num_log_chans = 0;
         int num_phy_chans;
         int i;
-        u32 val;
-        u32 rev;
+        u32 pid;
+        u32 cid;
+        u8 rev;
 
         clk = clk_get(&pdev->dev, NULL);
 
@@ -2554,32 +2610,32 @@ static struct d40_base * __init d40_hw_detect_init(struct platform_device *pdev)
         if (!virtbase)
                 goto failure;
 
-        /* HW version check */
-        for (i = 0; i < ARRAY_SIZE(dma_id_regs); i++) {
-                if (dma_id_regs[i].val !=
-                    readl(virtbase + dma_id_regs[i].reg)) {
-                        d40_err(&pdev->dev,
-                                "Unknown hardware! Expected 0x%x at 0x%x but got 0x%x\n",
-                                dma_id_regs[i].val,
-                                dma_id_regs[i].reg,
-                                readl(virtbase + dma_id_regs[i].reg));
-                        goto failure;
-                }
-        }
-
-        /* Get silicon revision and designer */
-        val = readl(virtbase + D40_DREG_PERIPHID2);
+        /* This is just a regular AMBA PrimeCell ID actually */
+        for (pid = 0, i = 0; i < 4; i++)
+                pid |= (readl(virtbase + resource_size(res) - 0x20 + 4 * i)
+                        & 255) << (i * 8);
+        for (cid = 0, i = 0; i < 4; i++)
+                cid |= (readl(virtbase + resource_size(res) - 0x10 + 4 * i)
+                        & 255) << (i * 8);
 
-        if ((val & D40_DREG_PERIPHID2_DESIGNER_MASK) !=
-            D40_HW_DESIGNER) {
+        if (cid != AMBA_CID) {
+                d40_err(&pdev->dev, "Unknown hardware! No PrimeCell ID\n");
+                goto failure;
+        }
+        if (AMBA_MANF_BITS(pid) != AMBA_VENDOR_ST) {
                 d40_err(&pdev->dev, "Unknown designer! Got %x wanted %x\n",
-                        val & D40_DREG_PERIPHID2_DESIGNER_MASK,
-                        D40_HW_DESIGNER);
+                        AMBA_MANF_BITS(pid),
+                        AMBA_VENDOR_ST);
                 goto failure;
         }
-
-        rev = (val & D40_DREG_PERIPHID2_REV_MASK) >>
-                D40_DREG_PERIPHID2_REV_POS;
+        /*
+         * HW revision:
+         * DB8500ed has revision 0
+         * ? has revision 1
+         * DB8500v1 has revision 2
+         * DB8500v2 has revision 3
+         */
+        rev = AMBA_REV_BITS(pid);
 
         /* The number of physical channels on this HW */
         num_phy_chans = 4 * (readl(virtbase + D40_DREG_ICFG) & 0x7) + 4;
diff --git a/drivers/dma/ste_dma40_ll.h b/drivers/dma/ste_dma40_ll.h
index 195ee65ee7f3..b44c455158de 100644
--- a/drivers/dma/ste_dma40_ll.h
+++ b/drivers/dma/ste_dma40_ll.h
@@ -184,9 +184,6 @@
 #define D40_DREG_PERIPHID0      0xFE0
 #define D40_DREG_PERIPHID1      0xFE4
 #define D40_DREG_PERIPHID2      0xFE8
-#define D40_DREG_PERIPHID2_REV_POS 4
-#define D40_DREG_PERIPHID2_REV_MASK (0xf << D40_DREG_PERIPHID2_REV_POS)
-#define D40_DREG_PERIPHID2_DESIGNER_MASK 0xf
 #define D40_DREG_PERIPHID3      0xFEC
 #define D40_DREG_CELLID0        0xFF0
 #define D40_DREG_CELLID1        0xFF4
diff --git a/drivers/edac/i7core_edac.c b/drivers/edac/i7core_edac.c
index 04f1e7ce02b1..f6cf448d69b4 100644
--- a/drivers/edac/i7core_edac.c
+++ b/drivers/edac/i7core_edac.c
@@ -1670,7 +1670,7 @@ static void i7core_mce_output_error(struct mem_ctl_info *mci,
         char *type, *optype, *err, *msg;
         unsigned long error = m->status & 0x1ff0000l;
         u32 optypenum = (m->status >> 4) & 0x07;
-        u32 core_err_cnt = (m->status >> 38) && 0x7fff;
+        u32 core_err_cnt = (m->status >> 38) & 0x7fff;
         u32 dimm = (m->misc >> 16) & 0x3;
         u32 channel = (m->misc >> 18) & 0x3;
         u32 syndrome = m->misc >> 32;
diff --git a/drivers/eisa/pci_eisa.c b/drivers/eisa/pci_eisa.c
index 30da70d06a6d..cdae207028a7 100644
--- a/drivers/eisa/pci_eisa.c
+++ b/drivers/eisa/pci_eisa.c
@@ -45,13 +45,13 @@ static int __init pci_eisa_init(struct pci_dev *pdev,
         return 0;
 }
 
-static struct pci_device_id __initdata pci_eisa_pci_tbl[] = {
+static struct pci_device_id pci_eisa_pci_tbl[] = {
         { PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID,
           PCI_CLASS_BRIDGE_EISA << 8, 0xffff00, 0 },
         { 0, }
 };
 
-static struct pci_driver __initdata pci_eisa_driver = {
+static struct pci_driver __refdata pci_eisa_driver = {
         .name           = "pci_eisa",
         .id_table       = pci_eisa_pci_tbl,
         .probe          = pci_eisa_init,
diff --git a/drivers/firewire/core-cdev.c b/drivers/firewire/core-cdev.c
index e6ad3bb6c1a6..4799393247c8 100644
--- a/drivers/firewire/core-cdev.c
+++ b/drivers/firewire/core-cdev.c
@@ -216,15 +216,33 @@ struct inbound_phy_packet_event {
         struct fw_cdev_event_phy_packet phy_packet;
 };
 
-static inline void __user *u64_to_uptr(__u64 value)
+#ifdef CONFIG_COMPAT
+static void __user *u64_to_uptr(u64 value)
+{
+        if (is_compat_task())
+                return compat_ptr(value);
+        else
+                return (void __user *)(unsigned long)value;
+}
+
+static u64 uptr_to_u64(void __user *ptr)
+{
+        if (is_compat_task())
+                return ptr_to_compat(ptr);
+        else
+                return (u64)(unsigned long)ptr;
+}
+#else
+static inline void __user *u64_to_uptr(u64 value)
 {
         return (void __user *)(unsigned long)value;
 }
 
-static inline __u64 uptr_to_u64(void __user *ptr)
+static inline u64 uptr_to_u64(void __user *ptr)
 {
-        return (__u64)(unsigned long)ptr;
+        return (u64)(unsigned long)ptr;
 }
+#endif /* CONFIG_COMPAT */
 
 static int fw_device_op_open(struct inode *inode, struct file *file)
 {
diff --git a/drivers/firewire/core-device.c b/drivers/firewire/core-device.c
index 8ba7f7928f1f..f3b890da1e87 100644
--- a/drivers/firewire/core-device.c
+++ b/drivers/firewire/core-device.c
@@ -455,15 +455,20 @@ static struct device_attribute fw_device_attributes[] = {
 static int read_rom(struct fw_device *device,
                     int generation, int index, u32 *data)
 {
-        int rcode;
+        u64 offset = (CSR_REGISTER_BASE | CSR_CONFIG_ROM) + index * 4;
+        int i, rcode;
 
         /* device->node_id, accessed below, must not be older than generation */
         smp_rmb();
 
-        rcode = fw_run_transaction(device->card, TCODE_READ_QUADLET_REQUEST,
-                        device->node_id, generation, device->max_speed,
-                        (CSR_REGISTER_BASE | CSR_CONFIG_ROM) + index * 4,
-                        data, 4);
+        for (i = 10; i < 100; i += 10) {
+                rcode = fw_run_transaction(device->card,
+                                TCODE_READ_QUADLET_REQUEST, device->node_id,
+                                generation, device->max_speed, offset, data, 4);
+                if (rcode != RCODE_BUSY)
+                        break;
+                msleep(i);
+        }
         be32_to_cpus(data);
 
         return rcode;
diff --git a/drivers/firewire/ohci.c b/drivers/firewire/ohci.c
index bcf792fac442..57cd3a406edf 100644
--- a/drivers/firewire/ohci.c
+++ b/drivers/firewire/ohci.c
@@ -2179,8 +2179,13 @@ static int ohci_enable(struct fw_card *card,
                         ohci_driver_name, ohci)) {
                 fw_error("Failed to allocate interrupt %d.\n", dev->irq);
                 pci_disable_msi(dev);
-                dma_free_coherent(ohci->card.device, CONFIG_ROM_SIZE,
-                                  ohci->config_rom, ohci->config_rom_bus);
+
+                if (config_rom) {
+                        dma_free_coherent(ohci->card.device, CONFIG_ROM_SIZE,
+                                          ohci->next_config_rom,
+                                          ohci->next_config_rom_bus);
+                        ohci->next_config_rom = NULL;
+                }
                 return -EIO;
         }
 
diff --git a/drivers/firewire/sbp2.c b/drivers/firewire/sbp2.c
index 41841a3e3f99..17cef864506a 100644
--- a/drivers/firewire/sbp2.c
+++ b/drivers/firewire/sbp2.c
@@ -1198,6 +1198,10 @@ static int sbp2_remove(struct device *dev)
 {
         struct fw_unit *unit = fw_unit(dev);
         struct sbp2_target *tgt = dev_get_drvdata(&unit->device);
+        struct sbp2_logical_unit *lu;
+
+        list_for_each_entry(lu, &tgt->lu_list, link)
+                cancel_delayed_work_sync(&lu->work);
 
         sbp2_target_put(tgt);
         return 0;
diff --git a/drivers/firmware/efivars.c b/drivers/firmware/efivars.c
index 5f29aafd4462..eb80b549ed8d 100644
--- a/drivers/firmware/efivars.c
+++ b/drivers/firmware/efivars.c
@@ -78,6 +78,7 @@
 #include <linux/kobject.h>
 #include <linux/device.h>
 #include <linux/slab.h>
+#include <linux/pstore.h>
 
 #include <asm/uaccess.h>
 
@@ -89,6 +90,8 @@ MODULE_DESCRIPTION("sysfs interface to EFI Variables");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(EFIVARS_VERSION);
 
+#define DUMP_NAME_LEN 52
+
 /*
  * The maximum size of VariableName + Data = 1024
  * Therefore, it's reasonable to save that much
@@ -119,6 +122,10 @@ struct efivar_attribute {
         ssize_t (*store)(struct efivar_entry *entry, const char *buf, size_t count);
 };
 
+#define PSTORE_EFI_ATTRIBUTES \
+        (EFI_VARIABLE_NON_VOLATILE | \
+         EFI_VARIABLE_BOOTSERVICE_ACCESS | \
+         EFI_VARIABLE_RUNTIME_ACCESS)
 
 #define EFIVAR_ATTR(_name, _mode, _show, _store) \
 struct efivar_attribute efivar_attr_##_name = { \
@@ -141,38 +148,72 @@ efivar_create_sysfs_entry(struct efivars *efivars,
 
 /* Return the number of unicode characters in data */
 static unsigned long
-utf8_strlen(efi_char16_t *data, unsigned long maxlength)
+utf16_strnlen(efi_char16_t *s, size_t maxlength)
 {
         unsigned long length = 0;
 
-        while (*data++ != 0 && length < maxlength)
+        while (*s++ != 0 && length < maxlength)
                 length++;
         return length;
 }
 
+static inline unsigned long
+utf16_strlen(efi_char16_t *s)
+{
+        return utf16_strnlen(s, ~0UL);
+}
+
 /*
  * Return the number of bytes is the length of this string
  * Note: this is NOT the same as the number of unicode characters
  */
 static inline unsigned long
-utf8_strsize(efi_char16_t *data, unsigned long maxlength)
+utf16_strsize(efi_char16_t *data, unsigned long maxlength)
 {
-        return utf8_strlen(data, maxlength/sizeof(efi_char16_t)) * sizeof(efi_char16_t);
+        return utf16_strnlen(data, maxlength/sizeof(efi_char16_t)) * sizeof(efi_char16_t);
+}
+
+static inline int
+utf16_strncmp(const efi_char16_t *a, const efi_char16_t *b, size_t len)
+{
+        while (1) {
+                if (len == 0)
+                        return 0;
+                if (*a < *b)
+                        return -1;
+                if (*a > *b)
+                        return 1;
+                if (*a == 0) /* implies *b == 0 */
+                        return 0;
+                a++;
+                b++;
+                len--;
+        }
 }
 
 static efi_status_t
-get_var_data(struct efivars *efivars, struct efi_variable *var)
+get_var_data_locked(struct efivars *efivars, struct efi_variable *var)
 {
         efi_status_t status;
 
-        spin_lock(&efivars->lock);
         var->DataSize = 1024;
         status = efivars->ops->get_variable(var->VariableName,
                                             &var->VendorGuid,
                                             &var->Attributes,
                                             &var->DataSize,
                                             var->Data);
+        return status;
+}
+
+static efi_status_t
+get_var_data(struct efivars *efivars, struct efi_variable *var)
+{
+        efi_status_t status;
+
+        spin_lock(&efivars->lock);
+        status = get_var_data_locked(efivars, var);
         spin_unlock(&efivars->lock);
+
         if (status != EFI_SUCCESS) {
                 printk(KERN_WARNING "efivars: get_variable() failed 0x%lx!\n",
                         status);
@@ -387,12 +428,180 @@ static struct kobj_type efivar_ktype = {
         .default_attrs = def_attrs,
 };
 
+static struct pstore_info efi_pstore_info;
+
 static inline void
 efivar_unregister(struct efivar_entry *var)
 {
         kobject_put(&var->kobj);
 }
 
+#ifdef CONFIG_PSTORE
+
+static int efi_pstore_open(struct pstore_info *psi)
+{
+        struct efivars *efivars = psi->data;
+
+        spin_lock(&efivars->lock);
+        efivars->walk_entry = list_first_entry(&efivars->list,
+                                               struct efivar_entry, list);
+        return 0;
+}
+
+static int efi_pstore_close(struct pstore_info *psi)
+{
+        struct efivars *efivars = psi->data;
+
+        spin_unlock(&efivars->lock);
+        return 0;
+}
+
+static ssize_t efi_pstore_read(u64 *id, enum pstore_type_id *type,
+                               struct timespec *timespec, struct pstore_info *psi)
+{
+        efi_guid_t vendor = LINUX_EFI_CRASH_GUID;
+        struct efivars *efivars = psi->data;
+        char name[DUMP_NAME_LEN];
+        int i;
+        unsigned int part, size;
+        unsigned long time;
+
+        while (&efivars->walk_entry->list != &efivars->list) {
+                if (!efi_guidcmp(efivars->walk_entry->var.VendorGuid,
+                                 vendor)) {
+                        for (i = 0; i < DUMP_NAME_LEN; i++) {
+                                name[i] = efivars->walk_entry->var.VariableName[i];
+                        }
+                        if (sscanf(name, "dump-type%u-%u-%lu", type, &part, &time) == 3) {
+                                *id = part;
+                                timespec->tv_sec = time;
+                                timespec->tv_nsec = 0;
+                                get_var_data_locked(efivars, &efivars->walk_entry->var);
+                                size = efivars->walk_entry->var.DataSize;
+                                memcpy(psi->buf, efivars->walk_entry->var.Data, size);
+                                efivars->walk_entry = list_entry(efivars->walk_entry->list.next,
+                                                   struct efivar_entry, list);
+                                return size;
+                        }
+                }
+                efivars->walk_entry = list_entry(efivars->walk_entry->list.next,
+                                                 struct efivar_entry, list);
+        }
+        return 0;
+}
+
+static u64 efi_pstore_write(enum pstore_type_id type, unsigned int part,
+                            size_t size, struct pstore_info *psi)
+{
+        char name[DUMP_NAME_LEN];
+        char stub_name[DUMP_NAME_LEN];
+        efi_char16_t efi_name[DUMP_NAME_LEN];
+        efi_guid_t vendor = LINUX_EFI_CRASH_GUID;
+        struct efivars *efivars = psi->data;
+        struct efivar_entry *entry, *found = NULL;
+        int i;
+
+        sprintf(stub_name, "dump-type%u-%u-", type, part);
+        sprintf(name, "%s%lu", stub_name, get_seconds());
+
+        spin_lock(&efivars->lock);
+
+        for (i = 0; i < DUMP_NAME_LEN; i++)
+                efi_name[i] = stub_name[i];
+
+        /*
+         * Clean up any entries with the same name
+         */
+
+        list_for_each_entry(entry, &efivars->list, list) {
+                get_var_data_locked(efivars, &entry->var);
+
+                if (efi_guidcmp(entry->var.VendorGuid, vendor))
+                        continue;
+                if (utf16_strncmp(entry->var.VariableName, efi_name,
+                                  utf16_strlen(efi_name)))
+                        continue;
+                /* Needs to be a prefix */
+                if (entry->var.VariableName[utf16_strlen(efi_name)] == 0)
+                        continue;
+
+                /* found */
+                found = entry;
+                efivars->ops->set_variable(entry->var.VariableName,
+                                           &entry->var.VendorGuid,
+                                           PSTORE_EFI_ATTRIBUTES,
+                                           0, NULL);
+        }
+
+        if (found)
+                list_del(&found->list);
+
+        for (i = 0; i < DUMP_NAME_LEN; i++)
+                efi_name[i] = name[i];
+
+        efivars->ops->set_variable(efi_name, &vendor, PSTORE_EFI_ATTRIBUTES,
+                                   size, psi->buf);
+
+        spin_unlock(&efivars->lock);
+
+        if (found)
+                efivar_unregister(found);
+
+        if (size)
+                efivar_create_sysfs_entry(efivars,
+                                          utf16_strsize(efi_name,
+                                                        DUMP_NAME_LEN * 2),
+                                          efi_name, &vendor);
+
+        return part;
+};
+
+static int efi_pstore_erase(enum pstore_type_id type, u64 id,
+                            struct pstore_info *psi)
+{
+        efi_pstore_write(type, id, 0, psi);
+
+        return 0;
+}
+#else
+static int efi_pstore_open(struct pstore_info *psi)
+{
+        return 0;
+}
+
+static int efi_pstore_close(struct pstore_info *psi)
+{
+        return 0;
+}
+
+static ssize_t efi_pstore_read(u64 *id, enum pstore_type_id *type,
+                               struct timespec *time, struct pstore_info *psi)
+{
+        return -1;
+}
+
+static u64 efi_pstore_write(enum pstore_type_id type, unsigned int part,
+                            size_t size, struct pstore_info *psi)
+{
+        return 0;
+}
+
+static int efi_pstore_erase(enum pstore_type_id type, u64 id,
+                            struct pstore_info *psi)
+{
+        return 0;
+}
+#endif
+
+static struct pstore_info efi_pstore_info = {
+        .owner          = THIS_MODULE,
+        .name           = "efi",
+        .open           = efi_pstore_open,
+        .close          = efi_pstore_close,
+        .read           = efi_pstore_read,
+        .write          = efi_pstore_write,
+        .erase          = efi_pstore_erase,
+};
 
 static ssize_t efivar_create(struct file *filp, struct kobject *kobj,
                              struct bin_attribute *bin_attr,
@@ -414,8 +623,8 @@ static ssize_t efivar_create(struct file *filp, struct kobject *kobj,
          * Does this variable already exist?
          */
         list_for_each_entry_safe(search_efivar, n, &efivars->list, list) {
-                strsize1 = utf8_strsize(search_efivar->var.VariableName, 1024);
-                strsize2 = utf8_strsize(new_var->VariableName, 1024);
+                strsize1 = utf16_strsize(search_efivar->var.VariableName, 1024);
+                strsize2 = utf16_strsize(new_var->VariableName, 1024);
                 if (strsize1 == strsize2 &&
                         !memcmp(&(search_efivar->var.VariableName),
                                 new_var->VariableName, strsize1) &&
@@ -447,8 +656,8 @@ static ssize_t efivar_create(struct file *filp, struct kobject *kobj,
 
         /* Create the entry in sysfs.  Locking is not required here */
         status = efivar_create_sysfs_entry(efivars,
-                                           utf8_strsize(new_var->VariableName,
-                                                        1024),
+                                           utf16_strsize(new_var->VariableName,
+                                                         1024),
                                            new_var->VariableName,
                                            &new_var->VendorGuid);
         if (status) {
@@ -477,8 +686,8 @@ static ssize_t efivar_delete(struct file *filp, struct kobject *kobj,
          * Does this variable already exist?
          */
         list_for_each_entry_safe(search_efivar, n, &efivars->list, list) {
-                strsize1 = utf8_strsize(search_efivar->var.VariableName, 1024);
-                strsize2 = utf8_strsize(del_var->VariableName, 1024);
+                strsize1 = utf16_strsize(search_efivar->var.VariableName, 1024);
+                strsize2 = utf16_strsize(del_var->VariableName, 1024);
                 if (strsize1 == strsize2 &&
                         !memcmp(&(search_efivar->var.VariableName),
                                 del_var->VariableName, strsize1) &&
@@ -763,6 +972,16 @@ int register_efivars(struct efivars *efivars,
         if (error)
                 unregister_efivars(efivars);
 
+        efivars->efi_pstore_info = efi_pstore_info;
+
+        efivars->efi_pstore_info.buf = kmalloc(4096, GFP_KERNEL);
+        if (efivars->efi_pstore_info.buf) {
+                efivars->efi_pstore_info.bufsize = 1024;
+                efivars->efi_pstore_info.data = efivars;
+                mutex_init(&efivars->efi_pstore_info.buf_mutex);
+                pstore_register(&efivars->efi_pstore_info);
+        }
+
 out:
         kfree(variable_name);
 
diff --git a/drivers/firmware/google/gsmi.c b/drivers/firmware/google/gsmi.c
index 68810fd1a59d..aa83de9db1b9 100644
--- a/drivers/firmware/google/gsmi.c
+++ b/drivers/firmware/google/gsmi.c
@@ -420,7 +420,7 @@ static efi_status_t gsmi_get_next_variable(unsigned long *name_size,
 
 static efi_status_t gsmi_set_variable(efi_char16_t *name,
                                       efi_guid_t *vendor,
-                                      unsigned long attr,
+                                      u32 attr,
                                       unsigned long data_size,
                                       void *data)
 {
diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig
index 363498697c2c..d539efd96d4b 100644
--- a/drivers/gpio/Kconfig
+++ b/drivers/gpio/Kconfig
@@ -103,6 +103,22 @@ config GPIO_MPC5200
         def_bool y
         depends on PPC_MPC52xx
 
+config GPIO_MSM_V1
+        tristate "Qualcomm MSM GPIO v1"
+        depends on GPIOLIB && ARCH_MSM
+        help
+          Say yes here to support the GPIO interface on ARM v6 based
+          Qualcomm MSM chips.  Most of the pins on the MSM can be
+          selected for GPIO, and are controlled by this driver.
+
+config GPIO_MSM_V2
+        tristate "Qualcomm MSM GPIO v2"
+        depends on GPIOLIB && ARCH_MSM
+        help
+          Say yes here to support the GPIO interface on ARM v7 based
+          Qualcomm MSM chips.  Most of the pins on the MSM can be
+          selected for GPIO, and are controlled by this driver.
+
 config GPIO_MXC
         def_bool y
         depends on ARCH_MXC
@@ -280,6 +296,12 @@ config GPIO_TC3589X
           This enables support for the GPIOs found on the TC3589X
           I/O Expander.
 
+config GPIO_TPS65912
+        tristate "TI TPS65912 GPIO"
+        depends on (MFD_TPS65912_I2C || MFD_TPS65912_SPI)
+        help
+          This driver supports TPS65912 gpio chip
+
 config GPIO_TWL4030
         tristate "TWL4030, TWL5030, and TPS659x0 GPIOs"
         depends on TWL4030_CORE
diff --git a/drivers/gpio/Makefile b/drivers/gpio/Makefile
index 720711251391..9588948c96f0 100644
--- a/drivers/gpio/Makefile
+++ b/drivers/gpio/Makefile
@@ -27,6 +27,8 @@ obj-$(CONFIG_GPIO_MC33880)	+= gpio-mc33880.o
 obj-$(CONFIG_GPIO_MCP23S08)     += gpio-mcp23s08.o
 obj-$(CONFIG_GPIO_ML_IOH)       += gpio-ml-ioh.o
 obj-$(CONFIG_GPIO_MPC5200)      += gpio-mpc5200.o
+obj-$(CONFIG_GPIO_MSM_V1)       += gpio-msm-v1.o
+obj-$(CONFIG_GPIO_MSM_V2)       += gpio-msm-v2.o
 obj-$(CONFIG_GPIO_MXC)          += gpio-mxc.o
 obj-$(CONFIG_GPIO_MXS)          += gpio-mxs.o
 obj-$(CONFIG_PLAT_NOMADIK)      += gpio-nomadik.o
@@ -48,6 +50,7 @@ obj-$(CONFIG_GPIO_TC3589X)	+= gpio-tc3589x.o
 obj-$(CONFIG_ARCH_TEGRA)        += gpio-tegra.o
 obj-$(CONFIG_GPIO_TIMBERDALE)   += gpio-timberdale.o
 obj-$(CONFIG_GPIO_TPS65910)     += gpio-tps65910.o
+obj-$(CONFIG_GPIO_TPS65912)     += gpio-tps65912.o
 obj-$(CONFIG_GPIO_TWL4030)      += gpio-twl4030.o
 obj-$(CONFIG_MACH_U300)         += gpio-u300.o
 obj-$(CONFIG_GPIO_UCB1400)      += gpio-ucb1400.o
diff --git a/drivers/gpio/gpio-ab8500.c b/drivers/gpio/gpio-ab8500.c
index ed795e64eea7..050c05d91896 100644
--- a/drivers/gpio/gpio-ab8500.c
+++ b/drivers/gpio/gpio-ab8500.c
@@ -516,5 +516,5 @@ module_exit(ab8500_gpio_exit);
 
 MODULE_AUTHOR("BIBEK BASU <bibek.basu@stericsson.com>");
 MODULE_DESCRIPTION("Driver allows to use AB8500 unused pins to be used as GPIO");
-MODULE_ALIAS("AB8500 GPIO driver");
+MODULE_ALIAS("platform:ab8500-gpio");
 MODULE_LICENSE("GPL v2");
diff --git a/drivers/gpio/gpio-msm-v1.c b/drivers/gpio/gpio-msm-v1.c
new file mode 100644
index 000000000000..52a4d4286eba
--- /dev/null
+++ b/drivers/gpio/gpio-msm-v1.c
@@ -0,0 +1,636 @@
+/*
+ * Copyright (C) 2007 Google, Inc.
+ * Copyright (c) 2009-2011, Code Aurora Forum. All rights reserved.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * 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/bitops.h>
+#include <linux/gpio.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/irq.h>
+#include <linux/module.h>
+#include <mach/cpu.h>
+#include <mach/msm_gpiomux.h>
+#include <mach/msm_iomap.h>
+
+/* see 80-VA736-2 Rev C pp 695-751
+**
+** These are actually the *shadow* gpio registers, since the
+** real ones (which allow full access) are only available to the
+** ARM9 side of the world.
+**
+** Since the _BASE need to be page-aligned when we're mapping them
+** to virtual addresses, adjust for the additional offset in these
+** macros.
+*/
+
+#define MSM_GPIO1_REG(off) (MSM_GPIO1_BASE + (off))
+#define MSM_GPIO2_REG(off) (MSM_GPIO2_BASE + 0x400 + (off))
+#define MSM_GPIO1_SHADOW_REG(off) (MSM_GPIO1_BASE + 0x800 + (off))
+#define MSM_GPIO2_SHADOW_REG(off) (MSM_GPIO2_BASE + 0xC00 + (off))
+
+/*
+ * MSM7X00 registers
+ */
+/* output value */
+#define MSM7X00_GPIO_OUT_0      MSM_GPIO1_SHADOW_REG(0x00)  /* gpio  15-0  */
+#define MSM7X00_GPIO_OUT_1      MSM_GPIO2_SHADOW_REG(0x00)  /* gpio  42-16 */
+#define MSM7X00_GPIO_OUT_2      MSM_GPIO1_SHADOW_REG(0x04)  /* gpio  67-43 */
+#define MSM7X00_GPIO_OUT_3      MSM_GPIO1_SHADOW_REG(0x08)  /* gpio  94-68 */
+#define MSM7X00_GPIO_OUT_4      MSM_GPIO1_SHADOW_REG(0x0C)  /* gpio 106-95 */
+#define MSM7X00_GPIO_OUT_5      MSM_GPIO1_SHADOW_REG(0x50)  /* gpio 107-121 */
+
+/* same pin map as above, output enable */
+#define MSM7X00_GPIO_OE_0       MSM_GPIO1_SHADOW_REG(0x10)
+#define MSM7X00_GPIO_OE_1       MSM_GPIO2_SHADOW_REG(0x08)
+#define MSM7X00_GPIO_OE_2       MSM_GPIO1_SHADOW_REG(0x14)
+#define MSM7X00_GPIO_OE_3       MSM_GPIO1_SHADOW_REG(0x18)
+#define MSM7X00_GPIO_OE_4       MSM_GPIO1_SHADOW_REG(0x1C)
+#define MSM7X00_GPIO_OE_5       MSM_GPIO1_SHADOW_REG(0x54)
+
+/* same pin map as above, input read */
+#define MSM7X00_GPIO_IN_0       MSM_GPIO1_SHADOW_REG(0x34)
+#define MSM7X00_GPIO_IN_1       MSM_GPIO2_SHADOW_REG(0x20)
+#define MSM7X00_GPIO_IN_2       MSM_GPIO1_SHADOW_REG(0x38)
+#define MSM7X00_GPIO_IN_3       MSM_GPIO1_SHADOW_REG(0x3C)
+#define MSM7X00_GPIO_IN_4       MSM_GPIO1_SHADOW_REG(0x40)
+#define MSM7X00_GPIO_IN_5       MSM_GPIO1_SHADOW_REG(0x44)
+
+/* same pin map as above, 1=edge 0=level interrup */
+#define MSM7X00_GPIO_INT_EDGE_0 MSM_GPIO1_SHADOW_REG(0x60)
+#define MSM7X00_GPIO_INT_EDGE_1 MSM_GPIO2_SHADOW_REG(0x50)
+#define MSM7X00_GPIO_INT_EDGE_2 MSM_GPIO1_SHADOW_REG(0x64)
+#define MSM7X00_GPIO_INT_EDGE_3 MSM_GPIO1_SHADOW_REG(0x68)
+#define MSM7X00_GPIO_INT_EDGE_4 MSM_GPIO1_SHADOW_REG(0x6C)
+#define MSM7X00_GPIO_INT_EDGE_5 MSM_GPIO1_SHADOW_REG(0xC0)
+
+/* same pin map as above, 1=positive 0=negative */
+#define MSM7X00_GPIO_INT_POS_0  MSM_GPIO1_SHADOW_REG(0x70)
+#define MSM7X00_GPIO_INT_POS_1  MSM_GPIO2_SHADOW_REG(0x58)
+#define MSM7X00_GPIO_INT_POS_2  MSM_GPIO1_SHADOW_REG(0x74)
+#define MSM7X00_GPIO_INT_POS_3  MSM_GPIO1_SHADOW_REG(0x78)
+#define MSM7X00_GPIO_INT_POS_4  MSM_GPIO1_SHADOW_REG(0x7C)
+#define MSM7X00_GPIO_INT_POS_5  MSM_GPIO1_SHADOW_REG(0xBC)
+
+/* same pin map as above, interrupt enable */
+#define MSM7X00_GPIO_INT_EN_0   MSM_GPIO1_SHADOW_REG(0x80)
+#define MSM7X00_GPIO_INT_EN_1   MSM_GPIO2_SHADOW_REG(0x60)
+#define MSM7X00_GPIO_INT_EN_2   MSM_GPIO1_SHADOW_REG(0x84)
+#define MSM7X00_GPIO_INT_EN_3   MSM_GPIO1_SHADOW_REG(0x88)
+#define MSM7X00_GPIO_INT_EN_4   MSM_GPIO1_SHADOW_REG(0x8C)
+#define MSM7X00_GPIO_INT_EN_5   MSM_GPIO1_SHADOW_REG(0xB8)
+
+/* same pin map as above, write 1 to clear interrupt */
+#define MSM7X00_GPIO_INT_CLEAR_0        MSM_GPIO1_SHADOW_REG(0x90)
+#define MSM7X00_GPIO_INT_CLEAR_1        MSM_GPIO2_SHADOW_REG(0x68)
+#define MSM7X00_GPIO_INT_CLEAR_2        MSM_GPIO1_SHADOW_REG(0x94)
+#define MSM7X00_GPIO_INT_CLEAR_3        MSM_GPIO1_SHADOW_REG(0x98)
+#define MSM7X00_GPIO_INT_CLEAR_4        MSM_GPIO1_SHADOW_REG(0x9C)
+#define MSM7X00_GPIO_INT_CLEAR_5        MSM_GPIO1_SHADOW_REG(0xB4)
+
+/* same pin map as above, 1=interrupt pending */
+#define MSM7X00_GPIO_INT_STATUS_0       MSM_GPIO1_SHADOW_REG(0xA0)
+#define MSM7X00_GPIO_INT_STATUS_1       MSM_GPIO2_SHADOW_REG(0x70)
+#define MSM7X00_GPIO_INT_STATUS_2       MSM_GPIO1_SHADOW_REG(0xA4)
+#define MSM7X00_GPIO_INT_STATUS_3       MSM_GPIO1_SHADOW_REG(0xA8)
+#define MSM7X00_GPIO_INT_STATUS_4       MSM_GPIO1_SHADOW_REG(0xAC)
+#define MSM7X00_GPIO_INT_STATUS_5       MSM_GPIO1_SHADOW_REG(0xB0)
+
+/*
+ * QSD8X50 registers
+ */
+/* output value */
+#define QSD8X50_GPIO_OUT_0      MSM_GPIO1_SHADOW_REG(0x00)  /* gpio  15-0   */
+#define QSD8X50_GPIO_OUT_1      MSM_GPIO2_SHADOW_REG(0x00)  /* gpio  42-16  */
+#define QSD8X50_GPIO_OUT_2      MSM_GPIO1_SHADOW_REG(0x04)  /* gpio  67-43  */
+#define QSD8X50_GPIO_OUT_3      MSM_GPIO1_SHADOW_REG(0x08)  /* gpio  94-68  */
+#define QSD8X50_GPIO_OUT_4      MSM_GPIO1_SHADOW_REG(0x0C)  /* gpio 103-95  */
+#define QSD8X50_GPIO_OUT_5      MSM_GPIO1_SHADOW_REG(0x10)  /* gpio 121-104 */
+#define QSD8X50_GPIO_OUT_6      MSM_GPIO1_SHADOW_REG(0x14)  /* gpio 152-122 */
+#define QSD8X50_GPIO_OUT_7      MSM_GPIO1_SHADOW_REG(0x18)  /* gpio 164-153 */
+
+/* same pin map as above, output enable */
+#define QSD8X50_GPIO_OE_0       MSM_GPIO1_SHADOW_REG(0x20)
+#define QSD8X50_GPIO_OE_1       MSM_GPIO2_SHADOW_REG(0x08)
+#define QSD8X50_GPIO_OE_2       MSM_GPIO1_SHADOW_REG(0x24)
+#define QSD8X50_GPIO_OE_3       MSM_GPIO1_SHADOW_REG(0x28)
+#define QSD8X50_GPIO_OE_4       MSM_GPIO1_SHADOW_REG(0x2C)
+#define QSD8X50_GPIO_OE_5       MSM_GPIO1_SHADOW_REG(0x30)
+#define QSD8X50_GPIO_OE_6       MSM_GPIO1_SHADOW_REG(0x34)
+#define QSD8X50_GPIO_OE_7       MSM_GPIO1_SHADOW_REG(0x38)
+
+/* same pin map as above, input read */
+#define QSD8X50_GPIO_IN_0       MSM_GPIO1_SHADOW_REG(0x50)
+#define QSD8X50_GPIO_IN_1       MSM_GPIO2_SHADOW_REG(0x20)
+#define QSD8X50_GPIO_IN_2       MSM_GPIO1_SHADOW_REG(0x54)
+#define QSD8X50_GPIO_IN_3       MSM_GPIO1_SHADOW_REG(0x58)
+#define QSD8X50_GPIO_IN_4       MSM_GPIO1_SHADOW_REG(0x5C)
+#define QSD8X50_GPIO_IN_5       MSM_GPIO1_SHADOW_REG(0x60)
+#define QSD8X50_GPIO_IN_6       MSM_GPIO1_SHADOW_REG(0x64)
+#define QSD8X50_GPIO_IN_7       MSM_GPIO1_SHADOW_REG(0x68)
+
+/* same pin map as above, 1=edge 0=level interrup */
+#define QSD8X50_GPIO_INT_EDGE_0 MSM_GPIO1_SHADOW_REG(0x70)
+#define QSD8X50_GPIO_INT_EDGE_1 MSM_GPIO2_SHADOW_REG(0x50)
+#define QSD8X50_GPIO_INT_EDGE_2 MSM_GPIO1_SHADOW_REG(0x74)
+#define QSD8X50_GPIO_INT_EDGE_3 MSM_GPIO1_SHADOW_REG(0x78)
+#define QSD8X50_GPIO_INT_EDGE_4 MSM_GPIO1_SHADOW_REG(0x7C)
+#define QSD8X50_GPIO_INT_EDGE_5 MSM_GPIO1_SHADOW_REG(0x80)
+#define QSD8X50_GPIO_INT_EDGE_6 MSM_GPIO1_SHADOW_REG(0x84)
+#define QSD8X50_GPIO_INT_EDGE_7 MSM_GPIO1_SHADOW_REG(0x88)
+
+/* same pin map as above, 1=positive 0=negative */
+#define QSD8X50_GPIO_INT_POS_0  MSM_GPIO1_SHADOW_REG(0x90)
+#define QSD8X50_GPIO_INT_POS_1  MSM_GPIO2_SHADOW_REG(0x58)
+#define QSD8X50_GPIO_INT_POS_2  MSM_GPIO1_SHADOW_REG(0x94)
+#define QSD8X50_GPIO_INT_POS_3  MSM_GPIO1_SHADOW_REG(0x98)
+#define QSD8X50_GPIO_INT_POS_4  MSM_GPIO1_SHADOW_REG(0x9C)
+#define QSD8X50_GPIO_INT_POS_5  MSM_GPIO1_SHADOW_REG(0xA0)
+#define QSD8X50_GPIO_INT_POS_6  MSM_GPIO1_SHADOW_REG(0xA4)
+#define QSD8X50_GPIO_INT_POS_7  MSM_GPIO1_SHADOW_REG(0xA8)
+
+/* same pin map as above, interrupt enable */
+#define QSD8X50_GPIO_INT_EN_0   MSM_GPIO1_SHADOW_REG(0xB0)
+#define QSD8X50_GPIO_INT_EN_1   MSM_GPIO2_SHADOW_REG(0x60)
+#define QSD8X50_GPIO_INT_EN_2   MSM_GPIO1_SHADOW_REG(0xB4)
+#define QSD8X50_GPIO_INT_EN_3   MSM_GPIO1_SHADOW_REG(0xB8)
+#define QSD8X50_GPIO_INT_EN_4   MSM_GPIO1_SHADOW_REG(0xBC)
+#define QSD8X50_GPIO_INT_EN_5   MSM_GPIO1_SHADOW_REG(0xC0)
+#define QSD8X50_GPIO_INT_EN_6   MSM_GPIO1_SHADOW_REG(0xC4)
+#define QSD8X50_GPIO_INT_EN_7   MSM_GPIO1_SHADOW_REG(0xC8)
+
+/* same pin map as above, write 1 to clear interrupt */
+#define QSD8X50_GPIO_INT_CLEAR_0        MSM_GPIO1_SHADOW_REG(0xD0)
+#define QSD8X50_GPIO_INT_CLEAR_1        MSM_GPIO2_SHADOW_REG(0x68)
+#define QSD8X50_GPIO_INT_CLEAR_2        MSM_GPIO1_SHADOW_REG(0xD4)
+#define QSD8X50_GPIO_INT_CLEAR_3        MSM_GPIO1_SHADOW_REG(0xD8)
+#define QSD8X50_GPIO_INT_CLEAR_4        MSM_GPIO1_SHADOW_REG(0xDC)
+#define QSD8X50_GPIO_INT_CLEAR_5        MSM_GPIO1_SHADOW_REG(0xE0)
+#define QSD8X50_GPIO_INT_CLEAR_6        MSM_GPIO1_SHADOW_REG(0xE4)
+#define QSD8X50_GPIO_INT_CLEAR_7        MSM_GPIO1_SHADOW_REG(0xE8)
+
+/* same pin map as above, 1=interrupt pending */
+#define QSD8X50_GPIO_INT_STATUS_0       MSM_GPIO1_SHADOW_REG(0xF0)
+#define QSD8X50_GPIO_INT_STATUS_1       MSM_GPIO2_SHADOW_REG(0x70)
+#define QSD8X50_GPIO_INT_STATUS_2       MSM_GPIO1_SHADOW_REG(0xF4)
+#define QSD8X50_GPIO_INT_STATUS_3       MSM_GPIO1_SHADOW_REG(0xF8)
+#define QSD8X50_GPIO_INT_STATUS_4       MSM_GPIO1_SHADOW_REG(0xFC)
+#define QSD8X50_GPIO_INT_STATUS_5       MSM_GPIO1_SHADOW_REG(0x100)
+#define QSD8X50_GPIO_INT_STATUS_6       MSM_GPIO1_SHADOW_REG(0x104)
+#define QSD8X50_GPIO_INT_STATUS_7       MSM_GPIO1_SHADOW_REG(0x108)
+
+/*
+ * MSM7X30 registers
+ */
+/* output value */
+#define MSM7X30_GPIO_OUT_0      MSM_GPIO1_REG(0x00)   /* gpio  15-0   */
+#define MSM7X30_GPIO_OUT_1      MSM_GPIO2_REG(0x00)   /* gpio  43-16  */
+#define MSM7X30_GPIO_OUT_2      MSM_GPIO1_REG(0x04)   /* gpio  67-44  */
+#define MSM7X30_GPIO_OUT_3      MSM_GPIO1_REG(0x08)   /* gpio  94-68  */
+#define MSM7X30_GPIO_OUT_4      MSM_GPIO1_REG(0x0C)   /* gpio 106-95  */
+#define MSM7X30_GPIO_OUT_5      MSM_GPIO1_REG(0x50)   /* gpio 133-107 */
+#define MSM7X30_GPIO_OUT_6      MSM_GPIO1_REG(0xC4)   /* gpio 150-134 */
+#define MSM7X30_GPIO_OUT_7      MSM_GPIO1_REG(0x214)  /* gpio 181-151 */
+
+/* same pin map as above, output enable */
+#define MSM7X30_GPIO_OE_0       MSM_GPIO1_REG(0x10)
+#define MSM7X30_GPIO_OE_1       MSM_GPIO2_REG(0x08)
+#define MSM7X30_GPIO_OE_2       MSM_GPIO1_REG(0x14)
+#define MSM7X30_GPIO_OE_3       MSM_GPIO1_REG(0x18)
+#define MSM7X30_GPIO_OE_4       MSM_GPIO1_REG(0x1C)
+#define MSM7X30_GPIO_OE_5       MSM_GPIO1_REG(0x54)
+#define MSM7X30_GPIO_OE_6       MSM_GPIO1_REG(0xC8)
+#define MSM7X30_GPIO_OE_7       MSM_GPIO1_REG(0x218)
+
+/* same pin map as above, input read */
+#define MSM7X30_GPIO_IN_0       MSM_GPIO1_REG(0x34)
+#define MSM7X30_GPIO_IN_1       MSM_GPIO2_REG(0x20)
+#define MSM7X30_GPIO_IN_2       MSM_GPIO1_REG(0x38)
+#define MSM7X30_GPIO_IN_3       MSM_GPIO1_REG(0x3C)
+#define MSM7X30_GPIO_IN_4       MSM_GPIO1_REG(0x40)
+#define MSM7X30_GPIO_IN_5       MSM_GPIO1_REG(0x44)
+#define MSM7X30_GPIO_IN_6       MSM_GPIO1_REG(0xCC)
+#define MSM7X30_GPIO_IN_7       MSM_GPIO1_REG(0x21C)
+
+/* same pin map as above, 1=edge 0=level interrup */
+#define MSM7X30_GPIO_INT_EDGE_0 MSM_GPIO1_REG(0x60)
+#define MSM7X30_GPIO_INT_EDGE_1 MSM_GPIO2_REG(0x50)
+#define MSM7X30_GPIO_INT_EDGE_2 MSM_GPIO1_REG(0x64)
+#define MSM7X30_GPIO_INT_EDGE_3 MSM_GPIO1_REG(0x68)
+#define MSM7X30_GPIO_INT_EDGE_4 MSM_GPIO1_REG(0x6C)
+#define MSM7X30_GPIO_INT_EDGE_5 MSM_GPIO1_REG(0xC0)
+#define MSM7X30_GPIO_INT_EDGE_6 MSM_GPIO1_REG(0xD0)
+#define MSM7X30_GPIO_INT_EDGE_7 MSM_GPIO1_REG(0x240)
+
+/* same pin map as above, 1=positive 0=negative */
+#define MSM7X30_GPIO_INT_POS_0  MSM_GPIO1_REG(0x70)
+#define MSM7X30_GPIO_INT_POS_1  MSM_GPIO2_REG(0x58)
+#define MSM7X30_GPIO_INT_POS_2  MSM_GPIO1_REG(0x74)
+#define MSM7X30_GPIO_INT_POS_3  MSM_GPIO1_REG(0x78)
+#define MSM7X30_GPIO_INT_POS_4  MSM_GPIO1_REG(0x7C)
+#define MSM7X30_GPIO_INT_POS_5  MSM_GPIO1_REG(0xBC)
+#define MSM7X30_GPIO_INT_POS_6  MSM_GPIO1_REG(0xD4)
+#define MSM7X30_GPIO_INT_POS_7  MSM_GPIO1_REG(0x228)
+
+/* same pin map as above, interrupt enable */
+#define MSM7X30_GPIO_INT_EN_0   MSM_GPIO1_REG(0x80)
+#define MSM7X30_GPIO_INT_EN_1   MSM_GPIO2_REG(0x60)
+#define MSM7X30_GPIO_INT_EN_2   MSM_GPIO1_REG(0x84)
+#define MSM7X30_GPIO_INT_EN_3   MSM_GPIO1_REG(0x88)
+#define MSM7X30_GPIO_INT_EN_4   MSM_GPIO1_REG(0x8C)
+#define MSM7X30_GPIO_INT_EN_5   MSM_GPIO1_REG(0xB8)
+#define MSM7X30_GPIO_INT_EN_6   MSM_GPIO1_REG(0xD8)
+#define MSM7X30_GPIO_INT_EN_7   MSM_GPIO1_REG(0x22C)
+
+/* same pin map as above, write 1 to clear interrupt */
+#define MSM7X30_GPIO_INT_CLEAR_0        MSM_GPIO1_REG(0x90)
+#define MSM7X30_GPIO_INT_CLEAR_1        MSM_GPIO2_REG(0x68)
+#define MSM7X30_GPIO_INT_CLEAR_2        MSM_GPIO1_REG(0x94)
+#define MSM7X30_GPIO_INT_CLEAR_3        MSM_GPIO1_REG(0x98)
+#define MSM7X30_GPIO_INT_CLEAR_4        MSM_GPIO1_REG(0x9C)
+#define MSM7X30_GPIO_INT_CLEAR_5        MSM_GPIO1_REG(0xB4)
+#define MSM7X30_GPIO_INT_CLEAR_6        MSM_GPIO1_REG(0xDC)
+#define MSM7X30_GPIO_INT_CLEAR_7        MSM_GPIO1_REG(0x230)
+
+/* same pin map as above, 1=interrupt pending */
+#define MSM7X30_GPIO_INT_STATUS_0       MSM_GPIO1_REG(0xA0)
+#define MSM7X30_GPIO_INT_STATUS_1       MSM_GPIO2_REG(0x70)
+#define MSM7X30_GPIO_INT_STATUS_2       MSM_GPIO1_REG(0xA4)
+#define MSM7X30_GPIO_INT_STATUS_3       MSM_GPIO1_REG(0xA8)
+#define MSM7X30_GPIO_INT_STATUS_4       MSM_GPIO1_REG(0xAC)
+#define MSM7X30_GPIO_INT_STATUS_5       MSM_GPIO1_REG(0xB0)
+#define MSM7X30_GPIO_INT_STATUS_6       MSM_GPIO1_REG(0xE0)
+#define MSM7X30_GPIO_INT_STATUS_7       MSM_GPIO1_REG(0x234)
+
+#define FIRST_GPIO_IRQ MSM_GPIO_TO_INT(0)
+
+#define MSM_GPIO_BANK(soc, bank, first, last)                           \
+        {                                                               \
+                .regs = {                                               \
+                        .out =         soc##_GPIO_OUT_##bank,           \
+                        .in =          soc##_GPIO_IN_##bank,            \
+                        .int_status =  soc##_GPIO_INT_STATUS_##bank,    \
+                        .int_clear =   soc##_GPIO_INT_CLEAR_##bank,     \
+                        .int_en =      soc##_GPIO_INT_EN_##bank,        \
+                        .int_edge =    soc##_GPIO_INT_EDGE_##bank,      \
+                        .int_pos =     soc##_GPIO_INT_POS_##bank,       \
+                        .oe =          soc##_GPIO_OE_##bank,            \
+                },                                                      \
+                .chip = {                                               \
+                        .base = (first),                                \
+                        .ngpio = (last) - (first) + 1,                  \
+                        .get = msm_gpio_get,                            \
+                        .set = msm_gpio_set,                            \
+                        .direction_input = msm_gpio_direction_input,    \
+                        .direction_output = msm_gpio_direction_output,  \
+                        .to_irq = msm_gpio_to_irq,                      \
+                        .request = msm_gpio_request,                    \
+                        .free = msm_gpio_free,                          \
+                }                                                       \
+        }
+
+#define MSM_GPIO_BROKEN_INT_CLEAR 1
+
+struct msm_gpio_regs {
+        void __iomem *out;
+        void __iomem *in;
+        void __iomem *int_status;
+        void __iomem *int_clear;
+        void __iomem *int_en;
+        void __iomem *int_edge;
+        void __iomem *int_pos;
+        void __iomem *oe;
+};
+
+struct msm_gpio_chip {
+        spinlock_t              lock;
+        struct gpio_chip        chip;
+        struct msm_gpio_regs    regs;
+#if MSM_GPIO_BROKEN_INT_CLEAR
+        unsigned                int_status_copy;
+#endif
+        unsigned int            both_edge_detect;
+        unsigned int            int_enable[2]; /* 0: awake, 1: sleep */
+};
+
+static int msm_gpio_write(struct msm_gpio_chip *msm_chip,
+                          unsigned offset, unsigned on)
+{
+        unsigned mask = BIT(offset);
+        unsigned val;
+
+        val = readl(msm_chip->regs.out);
+        if (on)
+                writel(val | mask, msm_chip->regs.out);
+        else
+                writel(val & ~mask, msm_chip->regs.out);
+        return 0;
+}
+
+static void msm_gpio_update_both_edge_detect(struct msm_gpio_chip *msm_chip)
+{
+        int loop_limit = 100;
+        unsigned pol, val, val2, intstat;
+        do {
+                val = readl(msm_chip->regs.in);
+                pol = readl(msm_chip->regs.int_pos);
+                pol = (pol & ~msm_chip->both_edge_detect) |
+                      (~val & msm_chip->both_edge_detect);
+                writel(pol, msm_chip->regs.int_pos);
+                intstat = readl(msm_chip->regs.int_status);
+                val2 = readl(msm_chip->regs.in);
+                if (((val ^ val2) & msm_chip->both_edge_detect & ~intstat) == 0)
+                        return;
+        } while (loop_limit-- > 0);
+        printk(KERN_ERR "msm_gpio_update_both_edge_detect, "
+               "failed to reach stable state %x != %x\n", val, val2);
+}
+
+static int msm_gpio_clear_detect_status(struct msm_gpio_chip *msm_chip,
+                                        unsigned offset)
+{
+        unsigned bit = BIT(offset);
+
+#if MSM_GPIO_BROKEN_INT_CLEAR
+        /* Save interrupts that already triggered before we loose them. */
+        /* Any interrupt that triggers between the read of int_status */
+        /* and the write to int_clear will still be lost though. */
+        msm_chip->int_status_copy |= readl(msm_chip->regs.int_status);
+        msm_chip->int_status_copy &= ~bit;
+#endif
+        writel(bit, msm_chip->regs.int_clear);
+        msm_gpio_update_both_edge_detect(msm_chip);
+        return 0;
+}
+
+static int msm_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
+{
+        struct msm_gpio_chip *msm_chip;
+        unsigned long irq_flags;
+
+        msm_chip = container_of(chip, struct msm_gpio_chip, chip);
+        spin_lock_irqsave(&msm_chip->lock, irq_flags);
+        writel(readl(msm_chip->regs.oe) & ~BIT(offset), msm_chip->regs.oe);
+        spin_unlock_irqrestore(&msm_chip->lock, irq_flags);
+        return 0;
+}
+
+static int
+msm_gpio_direction_output(struct gpio_chip *chip, unsigned offset, int value)
+{
+        struct msm_gpio_chip *msm_chip;
+        unsigned long irq_flags;
+
+        msm_chip = container_of(chip, struct msm_gpio_chip, chip);
+        spin_lock_irqsave(&msm_chip->lock, irq_flags);
+        msm_gpio_write(msm_chip, offset, value);
+        writel(readl(msm_chip->regs.oe) | BIT(offset), msm_chip->regs.oe);
+        spin_unlock_irqrestore(&msm_chip->lock, irq_flags);
+        return 0;
+}
+
+static int msm_gpio_get(struct gpio_chip *chip, unsigned offset)
+{
+        struct msm_gpio_chip *msm_chip;
+
+        msm_chip = container_of(chip, struct msm_gpio_chip, chip);
+        return (readl(msm_chip->regs.in) & (1U << offset)) ? 1 : 0;
+}
+
+static void msm_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
+{
+        struct msm_gpio_chip *msm_chip;
+        unsigned long irq_flags;
+
+        msm_chip = container_of(chip, struct msm_gpio_chip, chip);
+        spin_lock_irqsave(&msm_chip->lock, irq_flags);
+        msm_gpio_write(msm_chip, offset, value);
+        spin_unlock_irqrestore(&msm_chip->lock, irq_flags);
+}
+
+static int msm_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
+{
+        return MSM_GPIO_TO_INT(chip->base + offset);
+}
+
+#ifdef CONFIG_MSM_GPIOMUX
+static int msm_gpio_request(struct gpio_chip *chip, unsigned offset)
+{
+        return msm_gpiomux_get(chip->base + offset);
+}
+
+static void msm_gpio_free(struct gpio_chip *chip, unsigned offset)
+{
+        msm_gpiomux_put(chip->base + offset);
+}
+#else
+#define msm_gpio_request NULL
+#define msm_gpio_free NULL
+#endif
+
+static struct msm_gpio_chip *msm_gpio_chips;
+static int msm_gpio_count;
+
+static struct msm_gpio_chip msm_gpio_chips_msm7x01[] = {
+        MSM_GPIO_BANK(MSM7X00, 0,   0,  15),
+        MSM_GPIO_BANK(MSM7X00, 1,  16,  42),
+        MSM_GPIO_BANK(MSM7X00, 2,  43,  67),
+        MSM_GPIO_BANK(MSM7X00, 3,  68,  94),
+        MSM_GPIO_BANK(MSM7X00, 4,  95, 106),
+        MSM_GPIO_BANK(MSM7X00, 5, 107, 121),
+};
+
+static struct msm_gpio_chip msm_gpio_chips_msm7x30[] = {
+        MSM_GPIO_BANK(MSM7X30, 0,   0,  15),
+        MSM_GPIO_BANK(MSM7X30, 1,  16,  43),
+        MSM_GPIO_BANK(MSM7X30, 2,  44,  67),
+        MSM_GPIO_BANK(MSM7X30, 3,  68,  94),
+        MSM_GPIO_BANK(MSM7X30, 4,  95, 106),
+        MSM_GPIO_BANK(MSM7X30, 5, 107, 133),
+        MSM_GPIO_BANK(MSM7X30, 6, 134, 150),
+        MSM_GPIO_BANK(MSM7X30, 7, 151, 181),
+};
+
+static struct msm_gpio_chip msm_gpio_chips_qsd8x50[] = {
+        MSM_GPIO_BANK(QSD8X50, 0,   0,  15),
+        MSM_GPIO_BANK(QSD8X50, 1,  16,  42),
+        MSM_GPIO_BANK(QSD8X50, 2,  43,  67),
+        MSM_GPIO_BANK(QSD8X50, 3,  68,  94),
+        MSM_GPIO_BANK(QSD8X50, 4,  95, 103),
+        MSM_GPIO_BANK(QSD8X50, 5, 104, 121),
+        MSM_GPIO_BANK(QSD8X50, 6, 122, 152),
+        MSM_GPIO_BANK(QSD8X50, 7, 153, 164),
+};
+
+static void msm_gpio_irq_ack(struct irq_data *d)
+{
+        unsigned long irq_flags;
+        struct msm_gpio_chip *msm_chip = irq_data_get_irq_chip_data(d);
+        spin_lock_irqsave(&msm_chip->lock, irq_flags);
+        msm_gpio_clear_detect_status(msm_chip,
+                                     d->irq - gpio_to_irq(msm_chip->chip.base));
+        spin_unlock_irqrestore(&msm_chip->lock, irq_flags);
+}
+
+static void msm_gpio_irq_mask(struct irq_data *d)
+{
+        unsigned long irq_flags;
+        struct msm_gpio_chip *msm_chip = irq_data_get_irq_chip_data(d);
+        unsigned offset = d->irq - gpio_to_irq(msm_chip->chip.base);
+
+        spin_lock_irqsave(&msm_chip->lock, irq_flags);
+        /* level triggered interrupts are also latched */
+        if (!(readl(msm_chip->regs.int_edge) & BIT(offset)))
+                msm_gpio_clear_detect_status(msm_chip, offset);
+        msm_chip->int_enable[0] &= ~BIT(offset);
+        writel(msm_chip->int_enable[0], msm_chip->regs.int_en);
+        spin_unlock_irqrestore(&msm_chip->lock, irq_flags);
+}
+
+static void msm_gpio_irq_unmask(struct irq_data *d)
+{
+        unsigned long irq_flags;
+        struct msm_gpio_chip *msm_chip = irq_data_get_irq_chip_data(d);
+        unsigned offset = d->irq - gpio_to_irq(msm_chip->chip.base);
+
+        spin_lock_irqsave(&msm_chip->lock, irq_flags);
+        /* level triggered interrupts are also latched */
+        if (!(readl(msm_chip->regs.int_edge) & BIT(offset)))
+                msm_gpio_clear_detect_status(msm_chip, offset);
+        msm_chip->int_enable[0] |= BIT(offset);
+        writel(msm_chip->int_enable[0], msm_chip->regs.int_en);
+        spin_unlock_irqrestore(&msm_chip->lock, irq_flags);
+}
+
+static int msm_gpio_irq_set_wake(struct irq_data *d, unsigned int on)
+{
+        unsigned long irq_flags;
+        struct msm_gpio_chip *msm_chip = irq_data_get_irq_chip_data(d);
+        unsigned offset = d->irq - gpio_to_irq(msm_chip->chip.base);
+
+        spin_lock_irqsave(&msm_chip->lock, irq_flags);
+
+        if (on)
+                msm_chip->int_enable[1] |= BIT(offset);
+        else
+                msm_chip->int_enable[1] &= ~BIT(offset);
+
+        spin_unlock_irqrestore(&msm_chip->lock, irq_flags);
+        return 0;
+}
+
+static int msm_gpio_irq_set_type(struct irq_data *d, unsigned int flow_type)
+{
+        unsigned long irq_flags;
+        struct msm_gpio_chip *msm_chip = irq_data_get_irq_chip_data(d);
+        unsigned offset = d->irq - gpio_to_irq(msm_chip->chip.base);
+        unsigned val, mask = BIT(offset);
+
+        spin_lock_irqsave(&msm_chip->lock, irq_flags);
+        val = readl(msm_chip->regs.int_edge);
+        if (flow_type & IRQ_TYPE_EDGE_BOTH) {
+                writel(val | mask, msm_chip->regs.int_edge);
+                __irq_set_handler_locked(d->irq, handle_edge_irq);
+        } else {
+                writel(val & ~mask, msm_chip->regs.int_edge);
+                __irq_set_handler_locked(d->irq, handle_level_irq);
+        }
+        if ((flow_type & IRQ_TYPE_EDGE_BOTH) == IRQ_TYPE_EDGE_BOTH) {
+                msm_chip->both_edge_detect |= mask;
+                msm_gpio_update_both_edge_detect(msm_chip);
+        } else {
+                msm_chip->both_edge_detect &= ~mask;
+                val = readl(msm_chip->regs.int_pos);
+                if (flow_type & (IRQF_TRIGGER_RISING | IRQF_TRIGGER_HIGH))
+                        writel(val | mask, msm_chip->regs.int_pos);
+                else
+                        writel(val & ~mask, msm_chip->regs.int_pos);
+        }
+        spin_unlock_irqrestore(&msm_chip->lock, irq_flags);
+        return 0;
+}
+
+static void msm_gpio_irq_handler(unsigned int irq, struct irq_desc *desc)
+{
+        int i, j, mask;
+        unsigned val;
+
+        for (i = 0; i < msm_gpio_count; i++) {
+                struct msm_gpio_chip *msm_chip = &msm_gpio_chips[i];
+                val = readl(msm_chip->regs.int_status);
+                val &= msm_chip->int_enable[0];
+                while (val) {
+                        mask = val & -val;
+                        j = fls(mask) - 1;
+                        /* printk("%s %08x %08x bit %d gpio %d irq %d\n",
+                                __func__, v, m, j, msm_chip->chip.start + j,
+                                FIRST_GPIO_IRQ + msm_chip->chip.start + j); */
+                        val &= ~mask;
+                        generic_handle_irq(FIRST_GPIO_IRQ +
+                                           msm_chip->chip.base + j);
+                }
+        }
+        desc->irq_data.chip->irq_ack(&desc->irq_data);
+}
+
+static struct irq_chip msm_gpio_irq_chip = {
+        .name          = "msmgpio",
+        .irq_ack       = msm_gpio_irq_ack,
+        .irq_mask      = msm_gpio_irq_mask,
+        .irq_unmask    = msm_gpio_irq_unmask,
+        .irq_set_wake  = msm_gpio_irq_set_wake,
+        .irq_set_type  = msm_gpio_irq_set_type,
+};
+
+static int __init msm_init_gpio(void)
+{
+        int i, j = 0;
+
+        if (cpu_is_msm7x01()) {
+                msm_gpio_chips = msm_gpio_chips_msm7x01;
+                msm_gpio_count = ARRAY_SIZE(msm_gpio_chips_msm7x01);
+        } else if (cpu_is_msm7x30()) {
+                msm_gpio_chips = msm_gpio_chips_msm7x30;
+                msm_gpio_count = ARRAY_SIZE(msm_gpio_chips_msm7x30);
+        } else if (cpu_is_qsd8x50()) {
+                msm_gpio_chips = msm_gpio_chips_qsd8x50;
+                msm_gpio_count = ARRAY_SIZE(msm_gpio_chips_qsd8x50);
+        } else {
+                return 0;
+        }
+
+        for (i = FIRST_GPIO_IRQ; i < FIRST_GPIO_IRQ + NR_GPIO_IRQS; i++) {
+                if (i - FIRST_GPIO_IRQ >=
+                        msm_gpio_chips[j].chip.base +
+                        msm_gpio_chips[j].chip.ngpio)
+                        j++;
+                irq_set_chip_data(i, &msm_gpio_chips[j]);
+                irq_set_chip_and_handler(i, &msm_gpio_irq_chip,
+                                         handle_edge_irq);
+                set_irq_flags(i, IRQF_VALID);
+        }
+
+        for (i = 0; i < msm_gpio_count; i++) {
+                spin_lock_init(&msm_gpio_chips[i].lock);
+                writel(0, msm_gpio_chips[i].regs.int_en);
+                gpiochip_add(&msm_gpio_chips[i].chip);
+        }
+
+        irq_set_chained_handler(INT_GPIO_GROUP1, msm_gpio_irq_handler);
+        irq_set_chained_handler(INT_GPIO_GROUP2, msm_gpio_irq_handler);
+        irq_set_irq_wake(INT_GPIO_GROUP1, 1);
+        irq_set_irq_wake(INT_GPIO_GROUP2, 2);
+        return 0;
+}
+
+postcore_initcall(msm_init_gpio);
diff --git a/drivers/gpio/gpio-msm-v2.c b/drivers/gpio/gpio-msm-v2.c
new file mode 100644
index 000000000000..5cb1227d69cf
--- /dev/null
+++ b/drivers/gpio/gpio-msm-v2.c
@@ -0,0 +1,433 @@
+/* Copyright (c) 2010-2011, Code Aurora Forum. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * 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 Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ *
+ */
+#define pr_fmt(fmt) "%s: " fmt, __func__
+
+#include <linux/bitmap.h>
+#include <linux/bitops.h>
+#include <linux/gpio.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/irq.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/spinlock.h>
+
+#include <asm/mach/irq.h>
+
+#include <mach/msm_gpiomux.h>
+#include <mach/msm_iomap.h>
+
+/* Bits of interest in the GPIO_IN_OUT register.
+ */
+enum {
+        GPIO_IN  = 0,
+        GPIO_OUT = 1
+};
+
+/* Bits of interest in the GPIO_INTR_STATUS register.
+ */
+enum {
+        INTR_STATUS = 0,
+};
+
+/* Bits of interest in the GPIO_CFG register.
+ */
+enum {
+        GPIO_OE = 9,
+};
+
+/* Bits of interest in the GPIO_INTR_CFG register.
+ * When a GPIO triggers, two separate decisions are made, controlled
+ * by two separate flags.
+ *
+ * - First, INTR_RAW_STATUS_EN controls whether or not the GPIO_INTR_STATUS
+ * register for that GPIO will be updated to reflect the triggering of that
+ * gpio.  If this bit is 0, this register will not be updated.
+ * - Second, INTR_ENABLE controls whether an interrupt is triggered.
+ *
+ * If INTR_ENABLE is set and INTR_RAW_STATUS_EN is NOT set, an interrupt
+ * can be triggered but the status register will not reflect it.
+ */
+enum {
+        INTR_ENABLE        = 0,
+        INTR_POL_CTL       = 1,
+        INTR_DECT_CTL      = 2,
+        INTR_RAW_STATUS_EN = 3,
+};
+
+/* Codes of interest in GPIO_INTR_CFG_SU.
+ */
+enum {
+        TARGET_PROC_SCORPION = 4,
+        TARGET_PROC_NONE     = 7,
+};
+
+
+#define GPIO_INTR_CFG_SU(gpio)    (MSM_TLMM_BASE + 0x0400 + (0x04 * (gpio)))
+#define GPIO_CONFIG(gpio)         (MSM_TLMM_BASE + 0x1000 + (0x10 * (gpio)))
+#define GPIO_IN_OUT(gpio)         (MSM_TLMM_BASE + 0x1004 + (0x10 * (gpio)))
+#define GPIO_INTR_CFG(gpio)       (MSM_TLMM_BASE + 0x1008 + (0x10 * (gpio)))
+#define GPIO_INTR_STATUS(gpio)    (MSM_TLMM_BASE + 0x100c + (0x10 * (gpio)))
+
+/**
+ * struct msm_gpio_dev: the MSM8660 SoC GPIO device structure
+ *
+ * @enabled_irqs: a bitmap used to optimize the summary-irq handler.  By
+ * keeping track of which gpios are unmasked as irq sources, we avoid
+ * having to do readl calls on hundreds of iomapped registers each time
+ * the summary interrupt fires in order to locate the active interrupts.
+ *
+ * @wake_irqs: a bitmap for tracking which interrupt lines are enabled
+ * as wakeup sources.  When the device is suspended, interrupts which are
+ * not wakeup sources are disabled.
+ *
+ * @dual_edge_irqs: a bitmap used to track which irqs are configured
+ * as dual-edge, as this is not supported by the hardware and requires
+ * some special handling in the driver.
+ */
+struct msm_gpio_dev {
+        struct gpio_chip gpio_chip;
+        DECLARE_BITMAP(enabled_irqs, NR_GPIO_IRQS);
+        DECLARE_BITMAP(wake_irqs, NR_GPIO_IRQS);
+        DECLARE_BITMAP(dual_edge_irqs, NR_GPIO_IRQS);
+};
+
+static DEFINE_SPINLOCK(tlmm_lock);
+
+static inline struct msm_gpio_dev *to_msm_gpio_dev(struct gpio_chip *chip)
+{
+        return container_of(chip, struct msm_gpio_dev, gpio_chip);
+}
+
+static inline void set_gpio_bits(unsigned n, void __iomem *reg)
+{
+        writel(readl(reg) | n, reg);
+}
+
+static inline void clear_gpio_bits(unsigned n, void __iomem *reg)
+{
+        writel(readl(reg) & ~n, reg);
+}
+
+static int msm_gpio_get(struct gpio_chip *chip, unsigned offset)
+{
+        return readl(GPIO_IN_OUT(offset)) & BIT(GPIO_IN);
+}
+
+static void msm_gpio_set(struct gpio_chip *chip, unsigned offset, int val)
+{
+        writel(val ? BIT(GPIO_OUT) : 0, GPIO_IN_OUT(offset));
+}
+
+static int msm_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
+{
+        unsigned long irq_flags;
+
+        spin_lock_irqsave(&tlmm_lock, irq_flags);
+        clear_gpio_bits(BIT(GPIO_OE), GPIO_CONFIG(offset));
+        spin_unlock_irqrestore(&tlmm_lock, irq_flags);
+        return 0;
+}
+
+static int msm_gpio_direction_output(struct gpio_chip *chip,
+                                unsigned offset,
+                                int val)
+{
+        unsigned long irq_flags;
+
+        spin_lock_irqsave(&tlmm_lock, irq_flags);
+        msm_gpio_set(chip, offset, val);
+        set_gpio_bits(BIT(GPIO_OE), GPIO_CONFIG(offset));
+        spin_unlock_irqrestore(&tlmm_lock, irq_flags);
+        return 0;
+}
+
+static int msm_gpio_request(struct gpio_chip *chip, unsigned offset)
+{
+        return msm_gpiomux_get(chip->base + offset);
+}
+
+static void msm_gpio_free(struct gpio_chip *chip, unsigned offset)
+{
+        msm_gpiomux_put(chip->base + offset);
+}
+
+static int msm_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
+{
+        return MSM_GPIO_TO_INT(chip->base + offset);
+}
+
+static inline int msm_irq_to_gpio(struct gpio_chip *chip, unsigned irq)
+{
+        return irq - MSM_GPIO_TO_INT(chip->base);
+}
+
+static struct msm_gpio_dev msm_gpio = {
+        .gpio_chip = {
+                .base             = 0,
+                .ngpio            = NR_GPIO_IRQS,
+                .direction_input  = msm_gpio_direction_input,
+                .direction_output = msm_gpio_direction_output,
+                .get              = msm_gpio_get,
+                .set              = msm_gpio_set,
+                .to_irq           = msm_gpio_to_irq,
+                .request          = msm_gpio_request,
+                .free             = msm_gpio_free,
+        },
+};
+
+/* For dual-edge interrupts in software, since the hardware has no
+ * such support:
+ *
+ * At appropriate moments, this function may be called to flip the polarity
+ * settings of both-edge irq lines to try and catch the next edge.
+ *
+ * The attempt is considered successful if:
+ * - the status bit goes high, indicating that an edge was caught, or
+ * - the input value of the gpio doesn't change during the attempt.
+ * If the value changes twice during the process, that would cause the first
+ * test to fail but would force the second, as two opposite
+ * transitions would cause a detection no matter the polarity setting.
+ *
+ * The do-loop tries to sledge-hammer closed the timing hole between
+ * the initial value-read and the polarity-write - if the line value changes
+ * during that window, an interrupt is lost, the new polarity setting is
+ * incorrect, and the first success test will fail, causing a retry.
+ *
+ * Algorithm comes from Google's msmgpio driver, see mach-msm/gpio.c.
+ */
+static void msm_gpio_update_dual_edge_pos(unsigned gpio)
+{
+        int loop_limit = 100;
+        unsigned val, val2, intstat;
+
+        do {
+                val = readl(GPIO_IN_OUT(gpio)) & BIT(GPIO_IN);
+                if (val)
+                        clear_gpio_bits(BIT(INTR_POL_CTL), GPIO_INTR_CFG(gpio));
+                else
+                        set_gpio_bits(BIT(INTR_POL_CTL), GPIO_INTR_CFG(gpio));
+                val2 = readl(GPIO_IN_OUT(gpio)) & BIT(GPIO_IN);
+                intstat = readl(GPIO_INTR_STATUS(gpio)) & BIT(INTR_STATUS);
+                if (intstat || val == val2)
+                        return;
+        } while (loop_limit-- > 0);
+        pr_err("dual-edge irq failed to stabilize, "
+               "interrupts dropped. %#08x != %#08x\n",
+               val, val2);
+}
+
+static void msm_gpio_irq_ack(struct irq_data *d)
+{
+        int gpio = msm_irq_to_gpio(&msm_gpio.gpio_chip, d->irq);
+
+        writel(BIT(INTR_STATUS), GPIO_INTR_STATUS(gpio));
+        if (test_bit(gpio, msm_gpio.dual_edge_irqs))
+                msm_gpio_update_dual_edge_pos(gpio);
+}
+
+static void msm_gpio_irq_mask(struct irq_data *d)
+{
+        int gpio = msm_irq_to_gpio(&msm_gpio.gpio_chip, d->irq);
+        unsigned long irq_flags;
+
+        spin_lock_irqsave(&tlmm_lock, irq_flags);
+        writel(TARGET_PROC_NONE, GPIO_INTR_CFG_SU(gpio));
+        clear_gpio_bits(INTR_RAW_STATUS_EN | INTR_ENABLE, GPIO_INTR_CFG(gpio));
+        __clear_bit(gpio, msm_gpio.enabled_irqs);
+        spin_unlock_irqrestore(&tlmm_lock, irq_flags);
+}
+
+static void msm_gpio_irq_unmask(struct irq_data *d)
+{
+        int gpio = msm_irq_to_gpio(&msm_gpio.gpio_chip, d->irq);
+        unsigned long irq_flags;
+
+        spin_lock_irqsave(&tlmm_lock, irq_flags);
+        __set_bit(gpio, msm_gpio.enabled_irqs);
+        set_gpio_bits(INTR_RAW_STATUS_EN | INTR_ENABLE, GPIO_INTR_CFG(gpio));
+        writel(TARGET_PROC_SCORPION, GPIO_INTR_CFG_SU(gpio));
+        spin_unlock_irqrestore(&tlmm_lock, irq_flags);
+}
+
+static int msm_gpio_irq_set_type(struct irq_data *d, unsigned int flow_type)
+{
+        int gpio = msm_irq_to_gpio(&msm_gpio.gpio_chip, d->irq);
+        unsigned long irq_flags;
+        uint32_t bits;
+
+        spin_lock_irqsave(&tlmm_lock, irq_flags);
+
+        bits = readl(GPIO_INTR_CFG(gpio));
+
+        if (flow_type & IRQ_TYPE_EDGE_BOTH) {
+                bits |= BIT(INTR_DECT_CTL);
+                __irq_set_handler_locked(d->irq, handle_edge_irq);
+                if ((flow_type & IRQ_TYPE_EDGE_BOTH) == IRQ_TYPE_EDGE_BOTH)
+                        __set_bit(gpio, msm_gpio.dual_edge_irqs);
+                else
+                        __clear_bit(gpio, msm_gpio.dual_edge_irqs);
+        } else {
+                bits &= ~BIT(INTR_DECT_CTL);
+                __irq_set_handler_locked(d->irq, handle_level_irq);
+                __clear_bit(gpio, msm_gpio.dual_edge_irqs);
+        }
+
+        if (flow_type & (IRQ_TYPE_EDGE_RISING | IRQ_TYPE_LEVEL_HIGH))
+                bits |= BIT(INTR_POL_CTL);
+        else
+                bits &= ~BIT(INTR_POL_CTL);
+
+        writel(bits, GPIO_INTR_CFG(gpio));
+
+        if ((flow_type & IRQ_TYPE_EDGE_BOTH) == IRQ_TYPE_EDGE_BOTH)
+                msm_gpio_update_dual_edge_pos(gpio);
+
+        spin_unlock_irqrestore(&tlmm_lock, irq_flags);
+
+        return 0;
+}
+
+/*
+ * When the summary IRQ is raised, any number of GPIO lines may be high.
+ * It is the job of the summary handler to find all those GPIO lines
+ * which have been set as summary IRQ lines and which are triggered,
+ * and to call their interrupt handlers.
+ */
+static void msm_summary_irq_handler(unsigned int irq, struct irq_desc *desc)
+{
+        unsigned long i;
+        struct irq_chip *chip = irq_desc_get_chip(desc);
+
+        chained_irq_enter(chip, desc);
+
+        for (i = find_first_bit(msm_gpio.enabled_irqs, NR_GPIO_IRQS);
+             i < NR_GPIO_IRQS;
+             i = find_next_bit(msm_gpio.enabled_irqs, NR_GPIO_IRQS, i + 1)) {
+                if (readl(GPIO_INTR_STATUS(i)) & BIT(INTR_STATUS))
+                        generic_handle_irq(msm_gpio_to_irq(&msm_gpio.gpio_chip,
+                                                           i));
+        }
+
+        chained_irq_exit(chip, desc);
+}
+
+static int msm_gpio_irq_set_wake(struct irq_data *d, unsigned int on)
+{
+        int gpio = msm_irq_to_gpio(&msm_gpio.gpio_chip, d->irq);
+
+        if (on) {
+                if (bitmap_empty(msm_gpio.wake_irqs, NR_GPIO_IRQS))
+                        irq_set_irq_wake(TLMM_SCSS_SUMMARY_IRQ, 1);
+                set_bit(gpio, msm_gpio.wake_irqs);
+        } else {
+                clear_bit(gpio, msm_gpio.wake_irqs);
+                if (bitmap_empty(msm_gpio.wake_irqs, NR_GPIO_IRQS))
+                        irq_set_irq_wake(TLMM_SCSS_SUMMARY_IRQ, 0);
+        }
+
+        return 0;
+}
+
+static struct irq_chip msm_gpio_irq_chip = {
+        .name           = "msmgpio",
+        .irq_mask       = msm_gpio_irq_mask,
+        .irq_unmask     = msm_gpio_irq_unmask,
+        .irq_ack        = msm_gpio_irq_ack,
+        .irq_set_type   = msm_gpio_irq_set_type,
+        .irq_set_wake   = msm_gpio_irq_set_wake,
+};
+
+static int __devinit msm_gpio_probe(struct platform_device *dev)
+{
+        int i, irq, ret;
+
+        bitmap_zero(msm_gpio.enabled_irqs, NR_GPIO_IRQS);
+        bitmap_zero(msm_gpio.wake_irqs, NR_GPIO_IRQS);
+        bitmap_zero(msm_gpio.dual_edge_irqs, NR_GPIO_IRQS);
+        msm_gpio.gpio_chip.label = dev->name;
+        ret = gpiochip_add(&msm_gpio.gpio_chip);
+        if (ret < 0)
+                return ret;
+
+        for (i = 0; i < msm_gpio.gpio_chip.ngpio; ++i) {
+                irq = msm_gpio_to_irq(&msm_gpio.gpio_chip, i);
+                irq_set_chip_and_handler(irq, &msm_gpio_irq_chip,
+                                         handle_level_irq);
+                set_irq_flags(irq, IRQF_VALID);
+        }
+
+        irq_set_chained_handler(TLMM_SCSS_SUMMARY_IRQ,
+                                msm_summary_irq_handler);
+        return 0;
+}
+
+static int __devexit msm_gpio_remove(struct platform_device *dev)
+{
+        int ret = gpiochip_remove(&msm_gpio.gpio_chip);
+
+        if (ret < 0)
+                return ret;
+
+        irq_set_handler(TLMM_SCSS_SUMMARY_IRQ, NULL);
+
+        return 0;
+}
+
+static struct platform_driver msm_gpio_driver = {
+        .probe = msm_gpio_probe,
+        .remove = __devexit_p(msm_gpio_remove),
+        .driver = {
+                .name = "msmgpio",
+                .owner = THIS_MODULE,
+        },
+};
+
+static struct platform_device msm_device_gpio = {
+        .name = "msmgpio",
+        .id   = -1,
+};
+
+static int __init msm_gpio_init(void)
+{
+        int rc;
+
+        rc = platform_driver_register(&msm_gpio_driver);
+        if (!rc) {
+                rc = platform_device_register(&msm_device_gpio);
+                if (rc)
+                        platform_driver_unregister(&msm_gpio_driver);
+        }
+
+        return rc;
+}
+
+static void __exit msm_gpio_exit(void)
+{
+        platform_device_unregister(&msm_device_gpio);
+        platform_driver_unregister(&msm_gpio_driver);
+}
+
+postcore_initcall(msm_gpio_init);
+module_exit(msm_gpio_exit);
+
+MODULE_AUTHOR("Gregory Bean <gbean@codeaurora.org>");
+MODULE_DESCRIPTION("Driver for Qualcomm MSM TLMMv2 SoC GPIOs");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:msmgpio");
diff --git a/drivers/gpio/gpio-tps65912.c b/drivers/gpio/gpio-tps65912.c
new file mode 100644
index 000000000000..79e66c002350
--- /dev/null
+++ b/drivers/gpio/gpio-tps65912.c
@@ -0,0 +1,156 @@
+/*
+ * Copyright 2011 Texas Instruments Inc.
+ *
+ * Author: Margarita Olaya <magi@slimlogic.co.uk>
+ *
+ *  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 driver is based on wm8350 implementation.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/errno.h>
+#include <linux/gpio.h>
+#include <linux/mfd/core.h>
+#include <linux/platform_device.h>
+#include <linux/seq_file.h>
+#include <linux/slab.h>
+#include <linux/mfd/tps65912.h>
+
+struct tps65912_gpio_data {
+        struct tps65912 *tps65912;
+        struct gpio_chip gpio_chip;
+};
+
+static int tps65912_gpio_get(struct gpio_chip *gc, unsigned offset)
+{
+        struct tps65912 *tps65912 = container_of(gc, struct tps65912, gpio);
+        int val;
+
+        val = tps65912_reg_read(tps65912, TPS65912_GPIO1 + offset);
+
+        if (val & GPIO_STS_MASK)
+                return 1;
+
+        return 0;
+}
+
+static void tps65912_gpio_set(struct gpio_chip *gc, unsigned offset,
+                              int value)
+{
+        struct tps65912 *tps65912 = container_of(gc, struct tps65912, gpio);
+
+        if (value)
+                tps65912_set_bits(tps65912, TPS65912_GPIO1 + offset,
+                                                        GPIO_SET_MASK);
+        else
+                tps65912_clear_bits(tps65912, TPS65912_GPIO1 + offset,
+                                                                GPIO_SET_MASK);
+}
+
+static int tps65912_gpio_output(struct gpio_chip *gc, unsigned offset,
+                                int value)
+{
+        struct tps65912 *tps65912 = container_of(gc, struct tps65912, gpio);
+
+        /* Set the initial value */
+        tps65912_gpio_set(gc, offset, value);
+
+        return tps65912_set_bits(tps65912, TPS65912_GPIO1 + offset,
+                                                                GPIO_CFG_MASK);
+}
+
+static int tps65912_gpio_input(struct gpio_chip *gc, unsigned offset)
+{
+        struct tps65912 *tps65912 = container_of(gc, struct tps65912, gpio);
+
+        return tps65912_clear_bits(tps65912, TPS65912_GPIO1 + offset,
+                                                                GPIO_CFG_MASK);
+
+}
+
+static struct gpio_chip template_chip = {
+        .label                  = "tps65912",
+        .owner                  = THIS_MODULE,
+        .direction_input        = tps65912_gpio_input,
+        .direction_output       = tps65912_gpio_output,
+        .get                    = tps65912_gpio_get,
+        .set                    = tps65912_gpio_set,
+        .can_sleep              = 1,
+        .ngpio                  = 5,
+        .base                   = -1,
+};
+
+static int __devinit tps65912_gpio_probe(struct platform_device *pdev)
+{
+        struct tps65912 *tps65912 = dev_get_drvdata(pdev->dev.parent);
+        struct tps65912_board *pdata = tps65912->dev->platform_data;
+        struct tps65912_gpio_data *tps65912_gpio;
+        int ret;
+
+        tps65912_gpio = kzalloc(sizeof(*tps65912_gpio), GFP_KERNEL);
+        if (tps65912_gpio == NULL)
+                return -ENOMEM;
+
+        tps65912_gpio->tps65912 = tps65912;
+        tps65912_gpio->gpio_chip = template_chip;
+        tps65912_gpio->gpio_chip.dev = &pdev->dev;
+        if (pdata && pdata->gpio_base)
+                tps65912_gpio->gpio_chip.base = pdata->gpio_base;
+
+        ret = gpiochip_add(&tps65912_gpio->gpio_chip);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "Failed to register gpiochip, %d\n", ret);
+                goto err;
+        }
+
+        platform_set_drvdata(pdev, tps65912_gpio);
+
+        return ret;
+
+err:
+        kfree(tps65912_gpio);
+        return ret;
+}
+
+static int __devexit tps65912_gpio_remove(struct platform_device *pdev)
+{
+        struct tps65912_gpio_data  *tps65912_gpio = platform_get_drvdata(pdev);
+        int ret;
+
+        ret = gpiochip_remove(&tps65912_gpio->gpio_chip);
+        if (ret == 0)
+                kfree(tps65912_gpio);
+
+        return ret;
+}
+
+static struct platform_driver tps65912_gpio_driver = {
+        .driver = {
+                .name = "tps65912-gpio",
+                .owner = THIS_MODULE,
+        },
+        .probe = tps65912_gpio_probe,
+        .remove = __devexit_p(tps65912_gpio_remove),
+};
+
+static int __init tps65912_gpio_init(void)
+{
+        return platform_driver_register(&tps65912_gpio_driver);
+}
+subsys_initcall(tps65912_gpio_init);
+
+static void __exit tps65912_gpio_exit(void)
+{
+        platform_driver_unregister(&tps65912_gpio_driver);
+}
+module_exit(tps65912_gpio_exit);
+
+MODULE_AUTHOR("Margarita Olaya Cabrera <magi@slimlogic.co.uk>");
+MODULE_DESCRIPTION("GPIO interface for TPS65912 PMICs");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:tps65912-gpio");
diff --git a/drivers/gpu/drm/drm_crtc.c b/drivers/gpu/drm/drm_crtc.c
index 82db18506662..fe738f05309b 100644
--- a/drivers/gpu/drm/drm_crtc.c
+++ b/drivers/gpu/drm/drm_crtc.c
@@ -499,6 +499,7 @@ void drm_connector_cleanup(struct drm_connector *connector)
         mutex_lock(&dev->mode_config.mutex);
         drm_mode_object_put(dev, &connector->base);
         list_del(&connector->head);
+        dev->mode_config.num_connector--;
         mutex_unlock(&dev->mode_config.mutex);
 }
 EXPORT_SYMBOL(drm_connector_cleanup);
@@ -529,6 +530,7 @@ void drm_encoder_cleanup(struct drm_encoder *encoder)
         mutex_lock(&dev->mode_config.mutex);
         drm_mode_object_put(dev, &encoder->base);
         list_del(&encoder->head);
+        dev->mode_config.num_encoder--;
         mutex_unlock(&dev->mode_config.mutex);
 }
 EXPORT_SYMBOL(drm_encoder_cleanup);
diff --git a/drivers/gpu/drm/drm_debugfs.c b/drivers/gpu/drm/drm_debugfs.c
index 9d8c892d07c9..9d2668a50872 100644
--- a/drivers/gpu/drm/drm_debugfs.c
+++ b/drivers/gpu/drm/drm_debugfs.c
@@ -90,7 +90,6 @@ int drm_debugfs_create_files(struct drm_info_list *files, int count,
         struct drm_device *dev = minor->dev;
         struct dentry *ent;
         struct drm_info_node *tmp;
-        char name[64];
         int i, ret;
 
         for (i = 0; i < count; i++) {
@@ -108,6 +107,9 @@ int drm_debugfs_create_files(struct drm_info_list *files, int count,
                 ent = debugfs_create_file(files[i].name, S_IFREG | S_IRUGO,
                                           root, tmp, &drm_debugfs_fops);
                 if (!ent) {
+                        char name[64];
+                        strncpy(name, root->d_name.name,
+                                                min(root->d_name.len, 64U));
                         DRM_ERROR("Cannot create /sys/kernel/debug/dri/%s/%s\n",
                                   name, files[i].name);
                         kfree(tmp);
diff --git a/drivers/gpu/drm/drm_edid.c b/drivers/gpu/drm/drm_edid.c
index 756af4d7ec74..7425e5c9bd75 100644
--- a/drivers/gpu/drm/drm_edid.c
+++ b/drivers/gpu/drm/drm_edid.c
@@ -127,6 +127,23 @@ static const u8 edid_header[] = {
         0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00
 };
 
+ /*
+ * Sanity check the header of the base EDID block.  Return 8 if the header
+ * is perfect, down to 0 if it's totally wrong.
+ */
+int drm_edid_header_is_valid(const u8 *raw_edid)
+{
+        int i, score = 0;
+
+        for (i = 0; i < sizeof(edid_header); i++)
+                if (raw_edid[i] == edid_header[i])
+                        score++;
+
+        return score;
+}
+EXPORT_SYMBOL(drm_edid_header_is_valid);
+
+
 /*
  * Sanity check the EDID block (base or extension).  Return 0 if the block
  * doesn't check out, or 1 if it's valid.
@@ -139,12 +156,7 @@ drm_edid_block_valid(u8 *raw_edid)
         struct edid *edid = (struct edid *)raw_edid;
 
         if (raw_edid[0] == 0x00) {
-                int score = 0;
-
-                for (i = 0; i < sizeof(edid_header); i++)
-                        if (raw_edid[i] == edid_header[i])
-                                score++;
-
+                int score = drm_edid_header_is_valid(raw_edid);
                 if (score == 8) ;
                 else if (score >= 6) {
                         DRM_DEBUG("Fixing EDID header, your hardware may be failing\n");
@@ -1439,6 +1451,8 @@ EXPORT_SYMBOL(drm_detect_monitor_audio);
 static void drm_add_display_info(struct edid *edid,
                                  struct drm_display_info *info)
 {
+        u8 *edid_ext;
+
         info->width_mm = edid->width_cm * 10;
         info->height_mm = edid->height_cm * 10;
 
@@ -1483,6 +1497,13 @@ static void drm_add_display_info(struct edid *edid,
                 info->color_formats = DRM_COLOR_FORMAT_YCRCB444;
         if (info->color_formats & DRM_EDID_FEATURE_RGB_YCRCB422)
                 info->color_formats = DRM_COLOR_FORMAT_YCRCB422;
+
+        /* Get data from CEA blocks if present */
+        edid_ext = drm_find_cea_extension(edid);
+        if (!edid_ext)
+                return;
+
+        info->cea_rev = edid_ext[1];
 }
 
 /**
diff --git a/drivers/gpu/drm/drm_fb_helper.c b/drivers/gpu/drm/drm_fb_helper.c
index 802b61ac3139..f7c6854eb4dd 100644
--- a/drivers/gpu/drm/drm_fb_helper.c
+++ b/drivers/gpu/drm/drm_fb_helper.c
@@ -256,7 +256,6 @@ int drm_fb_helper_panic(struct notifier_block *n, unsigned long ununsed,
 {
         printk(KERN_ERR "panic occurred, switching back to text console\n");
         return drm_fb_helper_force_kernel_mode();
-        return 0;
 }
 EXPORT_SYMBOL(drm_fb_helper_panic);
 
diff --git a/drivers/gpu/drm/drm_irq.c b/drivers/gpu/drm/drm_irq.c
index 2022a5c966bb..3830e9e478c0 100644
--- a/drivers/gpu/drm/drm_irq.c
+++ b/drivers/gpu/drm/drm_irq.c
@@ -291,11 +291,14 @@ static void drm_irq_vgaarb_nokms(void *cookie, bool state)
         if (!dev->irq_enabled)
                 return;
 
-        if (state)
-                dev->driver->irq_uninstall(dev);
-        else {
-                dev->driver->irq_preinstall(dev);
-                dev->driver->irq_postinstall(dev);
+        if (state) {
+                if (dev->driver->irq_uninstall)
+                        dev->driver->irq_uninstall(dev);
+        } else {
+                if (dev->driver->irq_preinstall)
+                        dev->driver->irq_preinstall(dev);
+                if (dev->driver->irq_postinstall)
+                        dev->driver->irq_postinstall(dev);
         }
 }
 
@@ -338,7 +341,8 @@ int drm_irq_install(struct drm_device *dev)
         DRM_DEBUG("irq=%d\n", drm_dev_to_irq(dev));
 
         /* Before installing handler */
-        dev->driver->irq_preinstall(dev);
+        if (dev->driver->irq_preinstall)
+                dev->driver->irq_preinstall(dev);
 
         /* Install handler */
         if (drm_core_check_feature(dev, DRIVER_IRQ_SHARED))
@@ -363,11 +367,16 @@ int drm_irq_install(struct drm_device *dev)
                 vga_client_register(dev->pdev, (void *)dev, drm_irq_vgaarb_nokms, NULL);
 
         /* After installing handler */
-        ret = dev->driver->irq_postinstall(dev);
+        if (dev->driver->irq_postinstall)
+                ret = dev->driver->irq_postinstall(dev);
+
         if (ret < 0) {
                 mutex_lock(&dev->struct_mutex);
                 dev->irq_enabled = 0;
                 mutex_unlock(&dev->struct_mutex);
+                if (!drm_core_check_feature(dev, DRIVER_MODESET))
+                        vga_client_register(dev->pdev, NULL, NULL, NULL);
+                free_irq(drm_dev_to_irq(dev), dev);
         }
 
         return ret;
@@ -413,7 +422,8 @@ int drm_irq_uninstall(struct drm_device *dev)
         if (!drm_core_check_feature(dev, DRIVER_MODESET))
                 vga_client_register(dev->pdev, NULL, NULL, NULL);
 
-        dev->driver->irq_uninstall(dev);
+        if (dev->driver->irq_uninstall)
+                dev->driver->irq_uninstall(dev);
 
         free_irq(drm_dev_to_irq(dev), dev);
 
diff --git a/drivers/gpu/drm/i915/i915_debugfs.c b/drivers/gpu/drm/i915/i915_debugfs.c
index e2662497d50f..3c395a59da35 100644
--- a/drivers/gpu/drm/i915/i915_debugfs.c
+++ b/drivers/gpu/drm/i915/i915_debugfs.c
@@ -499,7 +499,7 @@ static int i915_interrupt_info(struct seq_file *m, void *data)
         seq_printf(m, "Interrupts received: %d\n",
                    atomic_read(&dev_priv->irq_received));
         for (i = 0; i < I915_NUM_RINGS; i++) {
-                if (IS_GEN6(dev)) {
+                if (IS_GEN6(dev) || IS_GEN7(dev)) {
                         seq_printf(m, "Graphics Interrupt mask (%s):    %08x\n",
                                    dev_priv->ring[i].name,
                                    I915_READ_IMR(&dev_priv->ring[i]));
@@ -1338,6 +1338,155 @@ static const struct file_operations i915_wedged_fops = {
         .llseek = default_llseek,
 };
 
+static int
+i915_max_freq_open(struct inode *inode,
+                   struct file *filp)
+{
+        filp->private_data = inode->i_private;
+        return 0;
+}
+
+static ssize_t
+i915_max_freq_read(struct file *filp,
+                   char __user *ubuf,
+                   size_t max,
+                   loff_t *ppos)
+{
+        struct drm_device *dev = filp->private_data;
+        drm_i915_private_t *dev_priv = dev->dev_private;
+        char buf[80];
+        int len;
+
+        len = snprintf(buf, sizeof (buf),
+                       "max freq: %d\n", dev_priv->max_delay * 50);
+
+        if (len > sizeof (buf))
+                len = sizeof (buf);
+
+        return simple_read_from_buffer(ubuf, max, ppos, buf, len);
+}
+
+static ssize_t
+i915_max_freq_write(struct file *filp,
+                  const char __user *ubuf,
+                  size_t cnt,
+                  loff_t *ppos)
+{
+        struct drm_device *dev = filp->private_data;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        char buf[20];
+        int val = 1;
+
+        if (cnt > 0) {
+                if (cnt > sizeof (buf) - 1)
+                        return -EINVAL;
+
+                if (copy_from_user(buf, ubuf, cnt))
+                        return -EFAULT;
+                buf[cnt] = 0;
+
+                val = simple_strtoul(buf, NULL, 0);
+        }
+
+        DRM_DEBUG_DRIVER("Manually setting max freq to %d\n", val);
+
+        /*
+         * Turbo will still be enabled, but won't go above the set value.
+         */
+        dev_priv->max_delay = val / 50;
+
+        gen6_set_rps(dev, val / 50);
+
+        return cnt;
+}
+
+static const struct file_operations i915_max_freq_fops = {
+        .owner = THIS_MODULE,
+        .open = i915_max_freq_open,
+        .read = i915_max_freq_read,
+        .write = i915_max_freq_write,
+        .llseek = default_llseek,
+};
+
+static int
+i915_cache_sharing_open(struct inode *inode,
+                   struct file *filp)
+{
+        filp->private_data = inode->i_private;
+        return 0;
+}
+
+static ssize_t
+i915_cache_sharing_read(struct file *filp,
+                   char __user *ubuf,
+                   size_t max,
+                   loff_t *ppos)
+{
+        struct drm_device *dev = filp->private_data;
+        drm_i915_private_t *dev_priv = dev->dev_private;
+        char buf[80];
+        u32 snpcr;
+        int len;
+
+        mutex_lock(&dev_priv->dev->struct_mutex);
+        snpcr = I915_READ(GEN6_MBCUNIT_SNPCR);
+        mutex_unlock(&dev_priv->dev->struct_mutex);
+
+        len = snprintf(buf, sizeof (buf),
+                       "%d\n", (snpcr & GEN6_MBC_SNPCR_MASK) >>
+                       GEN6_MBC_SNPCR_SHIFT);
+
+        if (len > sizeof (buf))
+                len = sizeof (buf);
+
+        return simple_read_from_buffer(ubuf, max, ppos, buf, len);
+}
+
+static ssize_t
+i915_cache_sharing_write(struct file *filp,
+                  const char __user *ubuf,
+                  size_t cnt,
+                  loff_t *ppos)
+{
+        struct drm_device *dev = filp->private_data;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        char buf[20];
+        u32 snpcr;
+        int val = 1;
+
+        if (cnt > 0) {
+                if (cnt > sizeof (buf) - 1)
+                        return -EINVAL;
+
+                if (copy_from_user(buf, ubuf, cnt))
+                        return -EFAULT;
+                buf[cnt] = 0;
+
+                val = simple_strtoul(buf, NULL, 0);
+        }
+
+        if (val < 0 || val > 3)
+                return -EINVAL;
+
+        DRM_DEBUG_DRIVER("Manually setting uncore sharing to %d\n", val);
+
+        /* Update the cache sharing policy here as well */
+        snpcr = I915_READ(GEN6_MBCUNIT_SNPCR);
+        snpcr &= ~GEN6_MBC_SNPCR_MASK;
+        snpcr |= (val << GEN6_MBC_SNPCR_SHIFT);
+        I915_WRITE(GEN6_MBCUNIT_SNPCR, snpcr);
+
+        return cnt;
+}
+
+static const struct file_operations i915_cache_sharing_fops = {
+        .owner = THIS_MODULE,
+        .open = i915_cache_sharing_open,
+        .read = i915_cache_sharing_read,
+        .write = i915_cache_sharing_write,
+        .llseek = default_llseek,
+};
+
 /* As the drm_debugfs_init() routines are called before dev->dev_private is
  * allocated we need to hook into the minor for release. */
 static int
@@ -1437,6 +1586,36 @@ static int i915_forcewake_create(struct dentry *root, struct drm_minor *minor)
         return drm_add_fake_info_node(minor, ent, &i915_forcewake_fops);
 }
 
+static int i915_max_freq_create(struct dentry *root, struct drm_minor *minor)
+{
+        struct drm_device *dev = minor->dev;
+        struct dentry *ent;
+
+        ent = debugfs_create_file("i915_max_freq",
+                                  S_IRUGO | S_IWUSR,
+                                  root, dev,
+                                  &i915_max_freq_fops);
+        if (IS_ERR(ent))
+                return PTR_ERR(ent);
+
+        return drm_add_fake_info_node(minor, ent, &i915_max_freq_fops);
+}
+
+static int i915_cache_sharing_create(struct dentry *root, struct drm_minor *minor)
+{
+        struct drm_device *dev = minor->dev;
+        struct dentry *ent;
+
+        ent = debugfs_create_file("i915_cache_sharing",
+                                  S_IRUGO | S_IWUSR,
+                                  root, dev,
+                                  &i915_cache_sharing_fops);
+        if (IS_ERR(ent))
+                return PTR_ERR(ent);
+
+        return drm_add_fake_info_node(minor, ent, &i915_cache_sharing_fops);
+}
+
 static struct drm_info_list i915_debugfs_list[] = {
         {"i915_capabilities", i915_capabilities, 0},
         {"i915_gem_objects", i915_gem_object_info, 0},
@@ -1490,6 +1669,12 @@ int i915_debugfs_init(struct drm_minor *minor)
         ret = i915_forcewake_create(minor->debugfs_root, minor);
         if (ret)
                 return ret;
+        ret = i915_max_freq_create(minor->debugfs_root, minor);
+        if (ret)
+                return ret;
+        ret = i915_cache_sharing_create(minor->debugfs_root, minor);
+        if (ret)
+                return ret;
 
         return drm_debugfs_create_files(i915_debugfs_list,
                                         I915_DEBUGFS_ENTRIES,
@@ -1504,6 +1689,10 @@ void i915_debugfs_cleanup(struct drm_minor *minor)
                                  1, minor);
         drm_debugfs_remove_files((struct drm_info_list *) &i915_wedged_fops,
                                  1, minor);
+        drm_debugfs_remove_files((struct drm_info_list *) &i915_max_freq_fops,
+                                 1, minor);
+        drm_debugfs_remove_files((struct drm_info_list *) &i915_cache_sharing_fops,
+                                 1, minor);
 }
 
 #endif /* CONFIG_DEBUG_FS */
diff --git a/drivers/gpu/drm/i915/i915_dma.c b/drivers/gpu/drm/i915/i915_dma.c
index 12712824a6d2..8a3942c4f099 100644
--- a/drivers/gpu/drm/i915/i915_dma.c
+++ b/drivers/gpu/drm/i915/i915_dma.c
@@ -61,7 +61,6 @@ static void i915_write_hws_pga(struct drm_device *dev)
 static int i915_init_phys_hws(struct drm_device *dev)
 {
         drm_i915_private_t *dev_priv = dev->dev_private;
-        struct intel_ring_buffer *ring = LP_RING(dev_priv);
 
         /* Program Hardware Status Page */
         dev_priv->status_page_dmah =
@@ -71,10 +70,9 @@ static int i915_init_phys_hws(struct drm_device *dev)
                 DRM_ERROR("Can not allocate hardware status page\n");
                 return -ENOMEM;
         }
-        ring->status_page.page_addr =
-                (void __force __iomem *)dev_priv->status_page_dmah->vaddr;
 
-        memset_io(ring->status_page.page_addr, 0, PAGE_SIZE);
+        memset_io((void __force __iomem *)dev_priv->status_page_dmah->vaddr,
+                  0, PAGE_SIZE);
 
         i915_write_hws_pga(dev);
 
diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h
index 6867e193d85e..7916bd97d5c1 100644
--- a/drivers/gpu/drm/i915/i915_drv.h
+++ b/drivers/gpu/drm/i915/i915_drv.h
@@ -36,6 +36,7 @@
 #include <linux/io-mapping.h>
 #include <linux/i2c.h>
 #include <drm/intel-gtt.h>
+#include <linux/backlight.h>
 
 /* General customization:
  */
@@ -544,6 +545,7 @@ typedef struct drm_i915_private {
         u32 savePIPEB_LINK_M1;
         u32 savePIPEB_LINK_N1;
         u32 saveMCHBAR_RENDER_STANDBY;
+        u32 savePCH_PORT_HOTPLUG;
 
         struct {
                 /** Bridge to intel-gtt-ko */
@@ -689,6 +691,7 @@ typedef struct drm_i915_private {
         int child_dev_num;
         struct child_device_config *child_dev;
         struct drm_connector *int_lvds_connector;
+        struct drm_connector *int_edp_connector;
 
         bool mchbar_need_disable;
 
@@ -722,6 +725,8 @@ typedef struct drm_i915_private {
         /* list of fbdev register on this device */
         struct intel_fbdev *fbdev;
 
+        struct backlight_device *backlight;
+
         struct drm_property *broadcast_rgb_property;
         struct drm_property *force_audio_property;
 
diff --git a/drivers/gpu/drm/i915/i915_gem.c b/drivers/gpu/drm/i915/i915_gem.c
index d1cd8b89f47d..a546a71fb060 100644
--- a/drivers/gpu/drm/i915/i915_gem.c
+++ b/drivers/gpu/drm/i915/i915_gem.c
@@ -3112,7 +3112,7 @@ i915_gem_object_pin_to_display_plane(struct drm_i915_gem_object *obj,
 
         if (pipelined != obj->ring) {
                 ret = i915_gem_object_wait_rendering(obj);
-                if (ret)
+                if (ret == -ERESTARTSYS)
                         return ret;
         }
 
diff --git a/drivers/gpu/drm/i915/i915_irq.c b/drivers/gpu/drm/i915/i915_irq.c
index 23d1ae67d279..9cbb0cd8f46a 100644
--- a/drivers/gpu/drm/i915/i915_irq.c
+++ b/drivers/gpu/drm/i915/i915_irq.c
@@ -306,12 +306,15 @@ static void i915_hotplug_work_func(struct work_struct *work)
         struct drm_mode_config *mode_config = &dev->mode_config;
         struct intel_encoder *encoder;
 
+        mutex_lock(&mode_config->mutex);
         DRM_DEBUG_KMS("running encoder hotplug functions\n");
 
         list_for_each_entry(encoder, &mode_config->encoder_list, base.head)
                 if (encoder->hot_plug)
                         encoder->hot_plug(encoder);
 
+        mutex_unlock(&mode_config->mutex);
+
         /* Just fire off a uevent and let userspace tell us what to do */
         drm_helper_hpd_irq_event(dev);
 }
@@ -2055,8 +2058,10 @@ void intel_irq_init(struct drm_device *dev)
                 dev->driver->get_vblank_counter = gm45_get_vblank_counter;
         }
 
-
-        dev->driver->get_vblank_timestamp = i915_get_vblank_timestamp;
+        if (drm_core_check_feature(dev, DRIVER_MODESET))
+                dev->driver->get_vblank_timestamp = i915_get_vblank_timestamp;
+        else
+                dev->driver->get_vblank_timestamp = NULL;
         dev->driver->get_scanout_position = i915_get_crtc_scanoutpos;
 
         if (IS_IVYBRIDGE(dev)) {
diff --git a/drivers/gpu/drm/i915/i915_reg.h b/drivers/gpu/drm/i915/i915_reg.h
index 02db299f621a..542453f7498c 100644
--- a/drivers/gpu/drm/i915/i915_reg.h
+++ b/drivers/gpu/drm/i915/i915_reg.h
@@ -78,6 +78,14 @@
 #define  GRDOM_RENDER   (1<<2)
 #define  GRDOM_MEDIA    (3<<2)
 
+#define GEN6_MBCUNIT_SNPCR      0x900c /* for LLC config */
+#define   GEN6_MBC_SNPCR_SHIFT  21
+#define   GEN6_MBC_SNPCR_MASK   (3<<21)
+#define   GEN6_MBC_SNPCR_MAX    (0<<21)
+#define   GEN6_MBC_SNPCR_MED    (1<<21)
+#define   GEN6_MBC_SNPCR_LOW    (2<<21)
+#define   GEN6_MBC_SNPCR_MIN    (3<<21) /* only 1/16th of the cache is shared */
+
 #define GEN6_GDRST      0x941c
 #define  GEN6_GRDOM_FULL                (1 << 0)
 #define  GEN6_GRDOM_RENDER              (1 << 1)
@@ -367,6 +375,7 @@
 # define MI_FLUSH_ENABLE                                (1 << 11)
 
 #define GFX_MODE        0x02520
+#define GFX_MODE_GEN7   0x0229c
 #define   GFX_RUN_LIST_ENABLE           (1<<15)
 #define   GFX_TLB_INVALIDATE_ALWAYS     (1<<13)
 #define   GFX_SURFACE_FAULT_ENABLE      (1<<12)
@@ -374,6 +383,9 @@
 #define   GFX_PSMI_GRANULARITY          (1<<10)
 #define   GFX_PPGTT_ENABLE              (1<<9)
 
+#define GFX_MODE_ENABLE(bit) (((bit) << 16) | (bit))
+#define GFX_MODE_DISABLE(bit) (((bit) << 16) | (0))
+
 #define SCPD0           0x0209c /* 915+ only */
 #define IER             0x020a0
 #define IIR             0x020a4
@@ -1310,6 +1322,7 @@
 #define   ADPA_PIPE_SELECT_MASK (1<<30)
 #define   ADPA_PIPE_A_SELECT    0
 #define   ADPA_PIPE_B_SELECT    (1<<30)
+#define   ADPA_PIPE_SELECT(pipe) ((pipe) << 30)
 #define   ADPA_USE_VGA_HVPOLARITY (1<<15)
 #define   ADPA_SETS_HVPOLARITY  0
 #define   ADPA_VSYNC_CNTL_DISABLE (1<<11)
@@ -1452,6 +1465,7 @@
 /* Selects pipe B for LVDS data.  Must be set on pre-965. */
 #define   LVDS_PIPEB_SELECT             (1 << 30)
 #define   LVDS_PIPE_MASK                (1 << 30)
+#define   LVDS_PIPE(pipe)               ((pipe) << 30)
 /* LVDS dithering flag on 965/g4x platform */
 #define   LVDS_ENABLE_DITHER            (1 << 25)
 /* LVDS sync polarity flags. Set to invert (i.e. negative) */
@@ -1491,9 +1505,6 @@
 #define   LVDS_B0B3_POWER_DOWN          (0 << 2)
 #define   LVDS_B0B3_POWER_UP            (3 << 2)
 
-#define LVDS_PIPE_ENABLED(V, P) \
-        (((V) & (LVDS_PIPE_MASK | LVDS_PORT_EN)) == ((P) << 30 | LVDS_PORT_EN))
-
 /* Video Data Island Packet control */
 #define VIDEO_DIP_DATA          0x61178
 #define VIDEO_DIP_CTL           0x61170
@@ -1506,6 +1517,7 @@
 #define   VIDEO_DIP_SELECT_AVI          (0 << 19)
 #define   VIDEO_DIP_SELECT_VENDOR       (1 << 19)
 #define   VIDEO_DIP_SELECT_SPD          (3 << 19)
+#define   VIDEO_DIP_SELECT_MASK         (3 << 19)
 #define   VIDEO_DIP_FREQ_ONCE           (0 << 16)
 #define   VIDEO_DIP_FREQ_VSYNC          (1 << 16)
 #define   VIDEO_DIP_FREQ_2VSYNC         (2 << 16)
@@ -2084,9 +2096,6 @@
 #define   DP_PIPEB_SELECT               (1 << 30)
 #define   DP_PIPE_MASK                  (1 << 30)
 
-#define DP_PIPE_ENABLED(V, P) \
-        (((V) & (DP_PIPE_MASK | DP_PORT_EN)) == ((P) << 30 | DP_PORT_EN))
-
 /* Link training mode - select a suitable mode for each stage */
 #define   DP_LINK_TRAIN_PAT_1           (0 << 28)
 #define   DP_LINK_TRAIN_PAT_2           (1 << 28)
@@ -3024,6 +3033,20 @@
 #define _TRANSA_DP_LINK_M2       0xe0048
 #define _TRANSA_DP_LINK_N2       0xe004c
 
+/* Per-transcoder DIP controls */
+
+#define _VIDEO_DIP_CTL_A         0xe0200
+#define _VIDEO_DIP_DATA_A        0xe0208
+#define _VIDEO_DIP_GCP_A         0xe0210
+
+#define _VIDEO_DIP_CTL_B         0xe1200
+#define _VIDEO_DIP_DATA_B        0xe1208
+#define _VIDEO_DIP_GCP_B         0xe1210
+
+#define TVIDEO_DIP_CTL(pipe) _PIPE(pipe, _VIDEO_DIP_CTL_A, _VIDEO_DIP_CTL_B)
+#define TVIDEO_DIP_DATA(pipe) _PIPE(pipe, _VIDEO_DIP_DATA_A, _VIDEO_DIP_DATA_B)
+#define TVIDEO_DIP_GCP(pipe) _PIPE(pipe, _VIDEO_DIP_GCP_A, _VIDEO_DIP_GCP_B)
+
 #define _TRANS_HTOTAL_B          0xe1000
 #define _TRANS_HBLANK_B          0xe1004
 #define _TRANS_HSYNC_B           0xe1008
@@ -3076,6 +3099,16 @@
 #define  TRANS_6BPC             (2<<5)
 #define  TRANS_12BPC            (3<<5)
 
+#define _TRANSA_CHICKEN2         0xf0064
+#define _TRANSB_CHICKEN2         0xf1064
+#define TRANS_CHICKEN2(pipe) _PIPE(pipe, _TRANSA_CHICKEN2, _TRANSB_CHICKEN2)
+#define   TRANS_AUTOTRAIN_GEN_STALL_DIS (1<<31)
+
+#define SOUTH_CHICKEN1          0xc2000
+#define  FDIA_PHASE_SYNC_SHIFT_OVR      19
+#define  FDIA_PHASE_SYNC_SHIFT_EN       18
+#define FDI_PHASE_SYNC_OVR(pipe) (1<<(FDIA_PHASE_SYNC_SHIFT_OVR - ((pipe) * 2)))
+#define FDI_PHASE_SYNC_EN(pipe) (1<<(FDIA_PHASE_SYNC_SHIFT_EN - ((pipe) * 2)))
 #define SOUTH_CHICKEN2          0xc2004
 #define  DPLS_EDP_PPS_FIX_DIS   (1<<0)
 
@@ -3226,14 +3259,12 @@
 #define  ADPA_CRT_HOTPLUG_VOLREF_475MV  (1<<17)
 #define  ADPA_CRT_HOTPLUG_FORCE_TRIGGER (1<<16)
 
-#define ADPA_PIPE_ENABLED(V, P) \
-        (((V) & (ADPA_TRANS_SELECT_MASK | ADPA_DAC_ENABLE)) == ((P) << 30 | ADPA_DAC_ENABLE))
-
 /* or SDVOB */
 #define HDMIB   0xe1140
 #define  PORT_ENABLE    (1 << 31)
 #define  TRANSCODER_A   (0)
 #define  TRANSCODER_B   (1 << 30)
+#define  TRANSCODER(pipe)       ((pipe) << 30)
 #define  TRANSCODER_MASK   (1 << 30)
 #define  COLOR_FORMAT_8bpc      (0)
 #define  COLOR_FORMAT_12bpc     (3 << 26)
@@ -3250,9 +3281,6 @@
 #define  HSYNC_ACTIVE_HIGH      (1 << 3)
 #define  PORT_DETECTED          (1 << 2)
 
-#define HDMI_PIPE_ENABLED(V, P) \
-        (((V) & (TRANSCODER_MASK | PORT_ENABLE)) == ((P) << 30 | PORT_ENABLE))
-
 /* PCH SDVOB multiplex with HDMIB */
 #define PCH_SDVOB       HDMIB
 
@@ -3319,6 +3347,7 @@
 #define  PORT_TRANS_B_SEL_CPT   (1<<29)
 #define  PORT_TRANS_C_SEL_CPT   (2<<29)
 #define  PORT_TRANS_SEL_MASK    (3<<29)
+#define  PORT_TRANS_SEL_CPT(pipe)       ((pipe) << 29)
 
 #define TRANS_DP_CTL_A          0xe0300
 #define TRANS_DP_CTL_B          0xe1300
diff --git a/drivers/gpu/drm/i915/i915_suspend.c b/drivers/gpu/drm/i915/i915_suspend.c
index 285758603ac8..f10742359ec9 100644
--- a/drivers/gpu/drm/i915/i915_suspend.c
+++ b/drivers/gpu/drm/i915/i915_suspend.c
@@ -812,6 +812,7 @@ int i915_save_state(struct drm_device *dev)
                 dev_priv->saveFDI_RXB_IMR = I915_READ(_FDI_RXB_IMR);
                 dev_priv->saveMCHBAR_RENDER_STANDBY =
                         I915_READ(RSTDBYCTL);
+                dev_priv->savePCH_PORT_HOTPLUG = I915_READ(PCH_PORT_HOTPLUG);
         } else {
                 dev_priv->saveIER = I915_READ(IER);
                 dev_priv->saveIMR = I915_READ(IMR);
@@ -863,13 +864,15 @@ int i915_restore_state(struct drm_device *dev)
                 I915_WRITE(GTIMR, dev_priv->saveGTIMR);
                 I915_WRITE(_FDI_RXA_IMR, dev_priv->saveFDI_RXA_IMR);
                 I915_WRITE(_FDI_RXB_IMR, dev_priv->saveFDI_RXB_IMR);
+                I915_WRITE(PCH_PORT_HOTPLUG, dev_priv->savePCH_PORT_HOTPLUG);
         } else {
                 I915_WRITE(IER, dev_priv->saveIER);
                 I915_WRITE(IMR, dev_priv->saveIMR);
         }
         mutex_unlock(&dev->struct_mutex);
 
-        intel_init_clock_gating(dev);
+        if (drm_core_check_feature(dev, DRIVER_MODESET))
+                intel_init_clock_gating(dev);
 
         if (IS_IRONLAKE_M(dev)) {
                 ironlake_enable_drps(dev);
diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c
index 393a39922e53..56a8554d9039 100644
--- a/drivers/gpu/drm/i915/intel_display.c
+++ b/drivers/gpu/drm/i915/intel_display.c
@@ -878,7 +878,7 @@ static void assert_panel_unlocked(struct drm_i915_private *dev_priv,
         int pp_reg, lvds_reg;
         u32 val;
         enum pipe panel_pipe = PIPE_A;
-        bool locked = locked;
+        bool locked = true;
 
         if (HAS_PCH_SPLIT(dev_priv->dev)) {
                 pp_reg = PCH_PP_CONTROL;
@@ -980,11 +980,76 @@ static void assert_transcoder_disabled(struct drm_i915_private *dev_priv,
              pipe_name(pipe));
 }
 
+static bool dp_pipe_enabled(struct drm_i915_private *dev_priv,
+                            enum pipe pipe, u32 port_sel, u32 val)
+{
+        if ((val & DP_PORT_EN) == 0)
+                return false;
+
+        if (HAS_PCH_CPT(dev_priv->dev)) {
+                u32     trans_dp_ctl_reg = TRANS_DP_CTL(pipe);
+                u32     trans_dp_ctl = I915_READ(trans_dp_ctl_reg);
+                if ((trans_dp_ctl & TRANS_DP_PORT_SEL_MASK) != port_sel)
+                        return false;
+        } else {
+                if ((val & DP_PIPE_MASK) != (pipe << 30))
+                        return false;
+        }
+        return true;
+}
+
+static bool hdmi_pipe_enabled(struct drm_i915_private *dev_priv,
+                              enum pipe pipe, u32 val)
+{
+        if ((val & PORT_ENABLE) == 0)
+                return false;
+
+        if (HAS_PCH_CPT(dev_priv->dev)) {
+                if ((val & PORT_TRANS_SEL_MASK) != PORT_TRANS_SEL_CPT(pipe))
+                        return false;
+        } else {
+                if ((val & TRANSCODER_MASK) != TRANSCODER(pipe))
+                        return false;
+        }
+        return true;
+}
+
+static bool lvds_pipe_enabled(struct drm_i915_private *dev_priv,
+                              enum pipe pipe, u32 val)
+{
+        if ((val & LVDS_PORT_EN) == 0)
+                return false;
+
+        if (HAS_PCH_CPT(dev_priv->dev)) {
+                if ((val & PORT_TRANS_SEL_MASK) != PORT_TRANS_SEL_CPT(pipe))
+                        return false;
+        } else {
+                if ((val & LVDS_PIPE_MASK) != LVDS_PIPE(pipe))
+                        return false;
+        }
+        return true;
+}
+
+static bool adpa_pipe_enabled(struct drm_i915_private *dev_priv,
+                              enum pipe pipe, u32 val)
+{
+        if ((val & ADPA_DAC_ENABLE) == 0)
+                return false;
+        if (HAS_PCH_CPT(dev_priv->dev)) {
+                if ((val & PORT_TRANS_SEL_MASK) != PORT_TRANS_SEL_CPT(pipe))
+                        return false;
+        } else {
+                if ((val & ADPA_PIPE_SELECT_MASK) != ADPA_PIPE_SELECT(pipe))
+                        return false;
+        }
+        return true;
+}
+
 static void assert_pch_dp_disabled(struct drm_i915_private *dev_priv,
-                                   enum pipe pipe, int reg)
+                                   enum pipe pipe, int reg, u32 port_sel)
 {
         u32 val = I915_READ(reg);
-        WARN(DP_PIPE_ENABLED(val, pipe),
+        WARN(dp_pipe_enabled(dev_priv, pipe, port_sel, val),
              "PCH DP (0x%08x) enabled on transcoder %c, should be disabled\n",
              reg, pipe_name(pipe));
 }
@@ -993,7 +1058,7 @@ static void assert_pch_hdmi_disabled(struct drm_i915_private *dev_priv,
                                      enum pipe pipe, int reg)
 {
         u32 val = I915_READ(reg);
-        WARN(HDMI_PIPE_ENABLED(val, pipe),
+        WARN(hdmi_pipe_enabled(dev_priv, val, pipe),
              "PCH DP (0x%08x) enabled on transcoder %c, should be disabled\n",
              reg, pipe_name(pipe));
 }
@@ -1004,19 +1069,19 @@ static void assert_pch_ports_disabled(struct drm_i915_private *dev_priv,
         int reg;
         u32 val;
 
-        assert_pch_dp_disabled(dev_priv, pipe, PCH_DP_B);
-        assert_pch_dp_disabled(dev_priv, pipe, PCH_DP_C);
-        assert_pch_dp_disabled(dev_priv, pipe, PCH_DP_D);
+        assert_pch_dp_disabled(dev_priv, pipe, PCH_DP_B, TRANS_DP_PORT_SEL_B);
+        assert_pch_dp_disabled(dev_priv, pipe, PCH_DP_C, TRANS_DP_PORT_SEL_C);
+        assert_pch_dp_disabled(dev_priv, pipe, PCH_DP_D, TRANS_DP_PORT_SEL_D);
 
         reg = PCH_ADPA;
         val = I915_READ(reg);
-        WARN(ADPA_PIPE_ENABLED(val, pipe),
+        WARN(adpa_pipe_enabled(dev_priv, val, pipe),
              "PCH VGA enabled on transcoder %c, should be disabled\n",
              pipe_name(pipe));
 
         reg = PCH_LVDS;
         val = I915_READ(reg);
-        WARN(LVDS_PIPE_ENABLED(val, pipe),
+        WARN(lvds_pipe_enabled(dev_priv, val, pipe),
              "PCH LVDS enabled on transcoder %c, should be disabled\n",
              pipe_name(pipe));
 
@@ -1276,6 +1341,17 @@ static void intel_disable_pipe(struct drm_i915_private *dev_priv,
         intel_wait_for_pipe_off(dev_priv->dev, pipe);
 }
 
+/*
+ * Plane regs are double buffered, going from enabled->disabled needs a
+ * trigger in order to latch.  The display address reg provides this.
+ */
+static void intel_flush_display_plane(struct drm_i915_private *dev_priv,
+                                      enum plane plane)
+{
+        I915_WRITE(DSPADDR(plane), I915_READ(DSPADDR(plane)));
+        I915_WRITE(DSPSURF(plane), I915_READ(DSPSURF(plane)));
+}
+
 /**
  * intel_enable_plane - enable a display plane on a given pipe
  * @dev_priv: i915 private structure
@@ -1299,20 +1375,10 @@ static void intel_enable_plane(struct drm_i915_private *dev_priv,
                 return;
 
         I915_WRITE(reg, val | DISPLAY_PLANE_ENABLE);
+        intel_flush_display_plane(dev_priv, plane);
         intel_wait_for_vblank(dev_priv->dev, pipe);
 }
 
-/*
- * Plane regs are double buffered, going from enabled->disabled needs a
- * trigger in order to latch.  The display address reg provides this.
- */
-static void intel_flush_display_plane(struct drm_i915_private *dev_priv,
-                                      enum plane plane)
-{
-        u32 reg = DSPADDR(plane);
-        I915_WRITE(reg, I915_READ(reg));
-}
-
 /**
  * intel_disable_plane - disable a display plane
  * @dev_priv: i915 private structure
@@ -1338,19 +1404,24 @@ static void intel_disable_plane(struct drm_i915_private *dev_priv,
 }
 
 static void disable_pch_dp(struct drm_i915_private *dev_priv,
-                           enum pipe pipe, int reg)
+                           enum pipe pipe, int reg, u32 port_sel)
 {
         u32 val = I915_READ(reg);
-        if (DP_PIPE_ENABLED(val, pipe))
+        if (dp_pipe_enabled(dev_priv, pipe, port_sel, val)) {
+                DRM_DEBUG_KMS("Disabling pch dp %x on pipe %d\n", reg, pipe);
                 I915_WRITE(reg, val & ~DP_PORT_EN);
+        }
 }
 
 static void disable_pch_hdmi(struct drm_i915_private *dev_priv,
                              enum pipe pipe, int reg)
 {
         u32 val = I915_READ(reg);
-        if (HDMI_PIPE_ENABLED(val, pipe))
+        if (hdmi_pipe_enabled(dev_priv, val, pipe)) {
+                DRM_DEBUG_KMS("Disabling pch HDMI %x on pipe %d\n",
+                              reg, pipe);
                 I915_WRITE(reg, val & ~PORT_ENABLE);
+        }
 }
 
 /* Disable any ports connected to this transcoder */
@@ -1362,18 +1433,19 @@ static void intel_disable_pch_ports(struct drm_i915_private *dev_priv,
         val = I915_READ(PCH_PP_CONTROL);
         I915_WRITE(PCH_PP_CONTROL, val | PANEL_UNLOCK_REGS);
 
-        disable_pch_dp(dev_priv, pipe, PCH_DP_B);
-        disable_pch_dp(dev_priv, pipe, PCH_DP_C);
-        disable_pch_dp(dev_priv, pipe, PCH_DP_D);
+        disable_pch_dp(dev_priv, pipe, PCH_DP_B, TRANS_DP_PORT_SEL_B);
+        disable_pch_dp(dev_priv, pipe, PCH_DP_C, TRANS_DP_PORT_SEL_C);
+        disable_pch_dp(dev_priv, pipe, PCH_DP_D, TRANS_DP_PORT_SEL_D);
 
         reg = PCH_ADPA;
         val = I915_READ(reg);
-        if (ADPA_PIPE_ENABLED(val, pipe))
+        if (adpa_pipe_enabled(dev_priv, val, pipe))
                 I915_WRITE(reg, val & ~ADPA_DAC_ENABLE);
 
         reg = PCH_LVDS;
         val = I915_READ(reg);
-        if (LVDS_PIPE_ENABLED(val, pipe)) {
+        if (lvds_pipe_enabled(dev_priv, val, pipe)) {
+                DRM_DEBUG_KMS("disable lvds on pipe %d val 0x%08x\n", pipe, val);
                 I915_WRITE(reg, val & ~LVDS_PORT_EN);
                 POSTING_READ(reg);
                 udelay(100);
@@ -2096,7 +2168,7 @@ intel_pipe_set_base(struct drm_crtc *crtc, int x, int y,
 
         /* no fb bound */
         if (!crtc->fb) {
-                DRM_DEBUG_KMS("No FB bound\n");
+                DRM_ERROR("No FB bound\n");
                 return 0;
         }
 
@@ -2105,6 +2177,7 @@ intel_pipe_set_base(struct drm_crtc *crtc, int x, int y,
         case 1:
                 break;
         default:
+                DRM_ERROR("no plane for crtc\n");
                 return -EINVAL;
         }
 
@@ -2114,6 +2187,7 @@ intel_pipe_set_base(struct drm_crtc *crtc, int x, int y,
                                          NULL);
         if (ret != 0) {
                 mutex_unlock(&dev->struct_mutex);
+                DRM_ERROR("pin & fence failed\n");
                 return ret;
         }
 
@@ -2142,6 +2216,7 @@ intel_pipe_set_base(struct drm_crtc *crtc, int x, int y,
         if (ret) {
                 i915_gem_object_unpin(to_intel_framebuffer(crtc->fb)->obj);
                 mutex_unlock(&dev->struct_mutex);
+                DRM_ERROR("failed to update base address\n");
                 return ret;
         }
 
@@ -2248,6 +2323,18 @@ static void intel_fdi_normal_train(struct drm_crtc *crtc)
                            FDI_FE_ERRC_ENABLE);
 }
 
+static void cpt_phase_pointer_enable(struct drm_device *dev, int pipe)
+{
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        u32 flags = I915_READ(SOUTH_CHICKEN1);
+
+        flags |= FDI_PHASE_SYNC_OVR(pipe);
+        I915_WRITE(SOUTH_CHICKEN1, flags); /* once to unlock... */
+        flags |= FDI_PHASE_SYNC_EN(pipe);
+        I915_WRITE(SOUTH_CHICKEN1, flags); /* then again to enable */
+        POSTING_READ(SOUTH_CHICKEN1);
+}
+
 /* The FDI link training functions for ILK/Ibexpeak. */
 static void ironlake_fdi_link_train(struct drm_crtc *crtc)
 {
@@ -2398,6 +2485,9 @@ static void gen6_fdi_link_train(struct drm_crtc *crtc)
         POSTING_READ(reg);
         udelay(150);
 
+        if (HAS_PCH_CPT(dev))
+                cpt_phase_pointer_enable(dev, pipe);
+
         for (i = 0; i < 4; i++ ) {
                 reg = FDI_TX_CTL(pipe);
                 temp = I915_READ(reg);
@@ -2514,6 +2604,9 @@ static void ivb_manual_fdi_link_train(struct drm_crtc *crtc)
         POSTING_READ(reg);
         udelay(150);
 
+        if (HAS_PCH_CPT(dev))
+                cpt_phase_pointer_enable(dev, pipe);
+
         for (i = 0; i < 4; i++ ) {
                 reg = FDI_TX_CTL(pipe);
                 temp = I915_READ(reg);
@@ -2623,6 +2716,17 @@ static void ironlake_fdi_pll_enable(struct drm_crtc *crtc)
         }
 }
 
+static void cpt_phase_pointer_disable(struct drm_device *dev, int pipe)
+{
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        u32 flags = I915_READ(SOUTH_CHICKEN1);
+
+        flags &= ~(FDI_PHASE_SYNC_EN(pipe));
+        I915_WRITE(SOUTH_CHICKEN1, flags); /* once to disable... */
+        flags &= ~(FDI_PHASE_SYNC_OVR(pipe));
+        I915_WRITE(SOUTH_CHICKEN1, flags); /* then again to lock */
+        POSTING_READ(SOUTH_CHICKEN1);
+}
 static void ironlake_fdi_disable(struct drm_crtc *crtc)
 {
         struct drm_device *dev = crtc->dev;
@@ -2652,6 +2756,8 @@ static void ironlake_fdi_disable(struct drm_crtc *crtc)
                 I915_WRITE(FDI_RX_CHICKEN(pipe),
                            I915_READ(FDI_RX_CHICKEN(pipe) &
                                      ~FDI_RX_PHASE_SYNC_POINTER_EN));
+        } else if (HAS_PCH_CPT(dev)) {
+                cpt_phase_pointer_disable(dev, pipe);
         }
 
         /* still set train pattern 1 */
@@ -2862,14 +2968,18 @@ static void ironlake_crtc_enable(struct drm_crtc *crtc)
                 I915_WRITE(PF_WIN_SZ(pipe), dev_priv->pch_pf_size);
         }
 
+        /*
+         * On ILK+ LUT must be loaded before the pipe is running but with
+         * clocks enabled
+         */
+        intel_crtc_load_lut(crtc);
+
         intel_enable_pipe(dev_priv, pipe, is_pch_port);
         intel_enable_plane(dev_priv, plane, pipe);
 
         if (is_pch_port)
                 ironlake_pch_enable(crtc);
 
-        intel_crtc_load_lut(crtc);
-
         mutex_lock(&dev->struct_mutex);
         intel_update_fbc(dev);
         mutex_unlock(&dev->struct_mutex);
@@ -4538,7 +4648,9 @@ static bool intel_choose_pipe_bpp_dither(struct drm_crtc *crtc,
                         if (connector->encoder != encoder)
                                 continue;
 
-                        if (connector->display_info.bpc < display_bpc) {
+                        /* Don't use an invalid EDID bpc value */
+                        if (connector->display_info.bpc &&
+                            connector->display_info.bpc < display_bpc) {
                                 DRM_DEBUG_DRIVER("clamping display bpc (was %d) to EDID reported max of %d\n", display_bpc, connector->display_info.bpc);
                                 display_bpc = connector->display_info.bpc;
                         }
@@ -4985,6 +5097,81 @@ static int i9xx_crtc_mode_set(struct drm_crtc *crtc,
         return ret;
 }
 
+static void ironlake_update_pch_refclk(struct drm_device *dev)
+{
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        struct drm_mode_config *mode_config = &dev->mode_config;
+        struct drm_crtc *crtc;
+        struct intel_encoder *encoder;
+        struct intel_encoder *has_edp_encoder = NULL;
+        u32 temp;
+        bool has_lvds = false;
+
+        /* We need to take the global config into account */
+        list_for_each_entry(crtc, &mode_config->crtc_list, head) {
+                if (!crtc->enabled)
+                        continue;
+
+                list_for_each_entry(encoder, &mode_config->encoder_list,
+                                    base.head) {
+                        if (encoder->base.crtc != crtc)
+                                continue;
+
+                        switch (encoder->type) {
+                        case INTEL_OUTPUT_LVDS:
+                                has_lvds = true;
+                        case INTEL_OUTPUT_EDP:
+                                has_edp_encoder = encoder;
+                                break;
+                        }
+                }
+        }
+
+        /* Ironlake: try to setup display ref clock before DPLL
+         * enabling. This is only under driver's control after
+         * PCH B stepping, previous chipset stepping should be
+         * ignoring this setting.
+         */
+        temp = I915_READ(PCH_DREF_CONTROL);
+        /* Always enable nonspread source */
+        temp &= ~DREF_NONSPREAD_SOURCE_MASK;
+        temp |= DREF_NONSPREAD_SOURCE_ENABLE;
+        temp &= ~DREF_SSC_SOURCE_MASK;
+        temp |= DREF_SSC_SOURCE_ENABLE;
+        I915_WRITE(PCH_DREF_CONTROL, temp);
+
+        POSTING_READ(PCH_DREF_CONTROL);
+        udelay(200);
+
+        if (has_edp_encoder) {
+                if (intel_panel_use_ssc(dev_priv)) {
+                        temp |= DREF_SSC1_ENABLE;
+                        I915_WRITE(PCH_DREF_CONTROL, temp);
+
+                        POSTING_READ(PCH_DREF_CONTROL);
+                        udelay(200);
+                }
+                temp &= ~DREF_CPU_SOURCE_OUTPUT_MASK;
+
+                /* Enable CPU source on CPU attached eDP */
+                if (!intel_encoder_is_pch_edp(&has_edp_encoder->base)) {
+                        if (intel_panel_use_ssc(dev_priv))
+                                temp |= DREF_CPU_SOURCE_OUTPUT_DOWNSPREAD;
+                        else
+                                temp |= DREF_CPU_SOURCE_OUTPUT_NONSPREAD;
+                } else {
+                        /* Enable SSC on PCH eDP if needed */
+                        if (intel_panel_use_ssc(dev_priv)) {
+                                DRM_ERROR("enabling SSC on PCH\n");
+                                temp |= DREF_SUPERSPREAD_SOURCE_ENABLE;
+                        }
+                }
+                I915_WRITE(PCH_DREF_CONTROL, temp);
+                POSTING_READ(PCH_DREF_CONTROL);
+                udelay(200);
+        }
+}
+
 static int ironlake_crtc_mode_set(struct drm_crtc *crtc,
                                   struct drm_display_mode *mode,
                                   struct drm_display_mode *adjusted_mode,
@@ -5153,7 +5340,8 @@ static int ironlake_crtc_mode_set(struct drm_crtc *crtc,
                 temp |= PIPE_12BPC;
                 break;
         default:
-                WARN(1, "intel_choose_pipe_bpp returned invalid value\n");
+                WARN(1, "intel_choose_pipe_bpp returned invalid value %d\n",
+                        pipe_bpp);
                 temp |= PIPE_8BPC;
                 pipe_bpp = 24;
                 break;
@@ -5179,49 +5367,7 @@ static int ironlake_crtc_mode_set(struct drm_crtc *crtc,
         ironlake_compute_m_n(intel_crtc->bpp, lane, target_clock, link_bw,
                              &m_n);
 
-        /* Ironlake: try to setup display ref clock before DPLL
-         * enabling. This is only under driver's control after
-         * PCH B stepping, previous chipset stepping should be
-         * ignoring this setting.
-         */
-        temp = I915_READ(PCH_DREF_CONTROL);
-        /* Always enable nonspread source */
-        temp &= ~DREF_NONSPREAD_SOURCE_MASK;
-        temp |= DREF_NONSPREAD_SOURCE_ENABLE;
-        temp &= ~DREF_SSC_SOURCE_MASK;
-        temp |= DREF_SSC_SOURCE_ENABLE;
-        I915_WRITE(PCH_DREF_CONTROL, temp);
-
-        POSTING_READ(PCH_DREF_CONTROL);
-        udelay(200);
-
-        if (has_edp_encoder) {
-                if (intel_panel_use_ssc(dev_priv)) {
-                        temp |= DREF_SSC1_ENABLE;
-                        I915_WRITE(PCH_DREF_CONTROL, temp);
-
-                        POSTING_READ(PCH_DREF_CONTROL);
-                        udelay(200);
-                }
-                temp &= ~DREF_CPU_SOURCE_OUTPUT_MASK;
-
-                /* Enable CPU source on CPU attached eDP */
-                if (!intel_encoder_is_pch_edp(&has_edp_encoder->base)) {
-                        if (intel_panel_use_ssc(dev_priv))
-                                temp |= DREF_CPU_SOURCE_OUTPUT_DOWNSPREAD;
-                        else
-                                temp |= DREF_CPU_SOURCE_OUTPUT_NONSPREAD;
-                } else {
-                        /* Enable SSC on PCH eDP if needed */
-                        if (intel_panel_use_ssc(dev_priv)) {
-                                DRM_ERROR("enabling SSC on PCH\n");
-                                temp |= DREF_SUPERSPREAD_SOURCE_ENABLE;
-                        }
-                }
-                I915_WRITE(PCH_DREF_CONTROL, temp);
-                POSTING_READ(PCH_DREF_CONTROL);
-                udelay(200);
-        }
+        ironlake_update_pch_refclk(dev);
 
         fp = clock.n << 16 | clock.m1 << 8 | clock.m2;
         if (has_reduced_clock)
@@ -5238,7 +5384,7 @@ static int ironlake_crtc_mode_set(struct drm_crtc *crtc,
         } else if (is_sdvo && is_tv)
                 factor = 20;
 
-        if (clock.m1 < factor * clock.n)
+        if (clock.m < factor * clock.n)
                 fp |= FP_CB_TUNE;
 
         dpll = 0;
@@ -5516,6 +5662,8 @@ static int intel_crtc_mode_set(struct drm_crtc *crtc,
 
         drm_vblank_post_modeset(dev, pipe);
 
+        intel_crtc->dpms_mode = DRM_MODE_DPMS_ON;
+
         return ret;
 }
 
@@ -7090,8 +7238,6 @@ static void intel_setup_outputs(struct drm_device *dev)
                         intel_encoder_clones(dev, encoder->clone_mask);
         }
 
-        intel_panel_setup_backlight(dev);
-
         /* disable all the possible outputs/crtcs before entering KMS mode */
         drm_helper_disable_unused_functions(dev);
 }
@@ -7714,10 +7860,12 @@ static void gen6_init_clock_gating(struct drm_device *dev)
                    ILK_DPARB_CLK_GATE  |
                    ILK_DPFD_CLK_GATE);
 
-        for_each_pipe(pipe)
+        for_each_pipe(pipe) {
                 I915_WRITE(DSPCNTR(pipe),
                            I915_READ(DSPCNTR(pipe)) |
                            DISPPLANE_TRICKLE_FEED_DISABLE);
+                intel_flush_display_plane(dev_priv, pipe);
+        }
 }
 
 static void ivybridge_init_clock_gating(struct drm_device *dev)
@@ -7734,10 +7882,12 @@ static void ivybridge_init_clock_gating(struct drm_device *dev)
 
         I915_WRITE(ILK_DSPCLK_GATE, IVB_VRHUNIT_CLK_GATE);
 
-        for_each_pipe(pipe)
+        for_each_pipe(pipe) {
                 I915_WRITE(DSPCNTR(pipe),
                            I915_READ(DSPCNTR(pipe)) |
                            DISPPLANE_TRICKLE_FEED_DISABLE);
+                intel_flush_display_plane(dev_priv, pipe);
+        }
 }
 
 static void g4x_init_clock_gating(struct drm_device *dev)
@@ -7820,6 +7970,7 @@ static void ibx_init_clock_gating(struct drm_device *dev)
 static void cpt_init_clock_gating(struct drm_device *dev)
 {
         struct drm_i915_private *dev_priv = dev->dev_private;
+        int pipe;
 
         /*
          * On Ibex Peak and Cougar Point, we need to disable clock
@@ -7829,6 +7980,9 @@ static void cpt_init_clock_gating(struct drm_device *dev)
         I915_WRITE(SOUTH_DSPCLK_GATE_D, PCH_DPLSUNIT_CLOCK_GATE_DISABLE);
         I915_WRITE(SOUTH_CHICKEN2, I915_READ(SOUTH_CHICKEN2) |
                    DPLS_EDP_PPS_FIX_DIS);
+        /* Without this, mode sets may fail silently on FDI */
+        for_each_pipe(pipe)
+                I915_WRITE(TRANS_CHICKEN2(pipe), TRANS_AUTOTRAIN_GEN_STALL_DIS);
 }
 
 static void ironlake_teardown_rc6(struct drm_device *dev)
@@ -8178,6 +8332,9 @@ struct intel_quirk intel_quirks[] = {
 
         /* Lenovo U160 cannot use SSC on LVDS */
         { 0x0046, 0x17aa, 0x3920, quirk_ssc_force_disable },
+
+        /* Sony Vaio Y cannot use SSC on LVDS */
+        { 0x0046, 0x104d, 0x9076, quirk_ssc_force_disable },
 };
 
 static void intel_init_quirks(struct drm_device *dev)
diff --git a/drivers/gpu/drm/i915/intel_dp.c b/drivers/gpu/drm/i915/intel_dp.c
index f797fb58ba9c..44fef5e1c490 100644
--- a/drivers/gpu/drm/i915/intel_dp.c
+++ b/drivers/gpu/drm/i915/intel_dp.c
@@ -50,9 +50,10 @@ struct intel_dp {
         bool has_audio;
         int force_audio;
         uint32_t color_range;
+        int dpms_mode;
         uint8_t link_bw;
         uint8_t lane_count;
-        uint8_t dpcd[4];
+        uint8_t dpcd[8];
         struct i2c_adapter adapter;
         struct i2c_algo_dp_aux_data algo;
         bool is_pch_edp;
@@ -316,9 +317,17 @@ intel_dp_aux_ch(struct intel_dp *intel_dp,
         else
                 precharge = 5;
 
-        if (I915_READ(ch_ctl) & DP_AUX_CH_CTL_SEND_BUSY) {
-                DRM_ERROR("dp_aux_ch not started status 0x%08x\n",
-                          I915_READ(ch_ctl));
+        /* Try to wait for any previous AUX channel activity */
+        for (try = 0; try < 3; try++) {
+                status = I915_READ(ch_ctl);
+                if ((status & DP_AUX_CH_CTL_SEND_BUSY) == 0)
+                        break;
+                msleep(1);
+        }
+
+        if (try == 3) {
+                WARN(1, "dp_aux_ch not started status 0x%08x\n",
+                     I915_READ(ch_ctl));
                 return -EBUSY;
         }
 
@@ -770,6 +779,7 @@ intel_dp_mode_set(struct drm_encoder *encoder, struct drm_display_mode *mode,
         memset(intel_dp->link_configuration, 0, DP_LINK_CONFIGURATION_SIZE);
         intel_dp->link_configuration[0] = intel_dp->link_bw;
         intel_dp->link_configuration[1] = intel_dp->lane_count;
+        intel_dp->link_configuration[8] = DP_SET_ANSI_8B10B;
 
         /*
          * Check for DPCD version > 1.1 and enhanced framing support
@@ -1011,6 +1021,8 @@ static void intel_dp_commit(struct drm_encoder *encoder)
 
         if (is_edp(intel_dp))
                 ironlake_edp_backlight_on(dev);
+
+        intel_dp->dpms_mode = DRM_MODE_DPMS_ON;
 }
 
 static void
@@ -1045,6 +1057,7 @@ intel_dp_dpms(struct drm_encoder *encoder, int mode)
                 if (is_edp(intel_dp))
                         ironlake_edp_backlight_on(dev);
         }
+        intel_dp->dpms_mode = mode;
 }
 
 /*
@@ -1334,10 +1347,16 @@ intel_dp_start_link_train(struct intel_dp *intel_dp)
         u32 reg;
         uint32_t DP = intel_dp->DP;
 
-        /* Enable output, wait for it to become active */
-        I915_WRITE(intel_dp->output_reg, intel_dp->DP);
-        POSTING_READ(intel_dp->output_reg);
-        intel_wait_for_vblank(dev, intel_crtc->pipe);
+        /*
+         * On CPT we have to enable the port in training pattern 1, which
+         * will happen below in intel_dp_set_link_train.  Otherwise, enable
+         * the port and wait for it to become active.
+         */
+        if (!HAS_PCH_CPT(dev)) {
+                I915_WRITE(intel_dp->output_reg, intel_dp->DP);
+                POSTING_READ(intel_dp->output_reg);
+                intel_wait_for_vblank(dev, intel_crtc->pipe);
+        }
 
         /* Write the link configuration data */
         intel_dp_aux_native_write(intel_dp, DP_LINK_BW_SET,
@@ -1370,7 +1389,8 @@ intel_dp_start_link_train(struct intel_dp *intel_dp)
                         reg = DP | DP_LINK_TRAIN_PAT_1;
 
                 if (!intel_dp_set_link_train(intel_dp, reg,
-                                             DP_TRAINING_PATTERN_1))
+                                             DP_TRAINING_PATTERN_1 |
+                                             DP_LINK_SCRAMBLING_DISABLE))
                         break;
                 /* Set training pattern 1 */
 
@@ -1445,7 +1465,8 @@ intel_dp_complete_link_train(struct intel_dp *intel_dp)
 
                 /* channel eq pattern */
                 if (!intel_dp_set_link_train(intel_dp, reg,
-                                             DP_TRAINING_PATTERN_2))
+                                             DP_TRAINING_PATTERN_2 |
+                                             DP_LINK_SCRAMBLING_DISABLE))
                         break;
 
                 udelay(400);
@@ -1559,6 +1580,18 @@ intel_dp_link_down(struct intel_dp *intel_dp)
         POSTING_READ(intel_dp->output_reg);
 }
 
+static bool
+intel_dp_get_dpcd(struct intel_dp *intel_dp)
+{
+        if (intel_dp_aux_native_read_retry(intel_dp, 0x000, intel_dp->dpcd,
+                                           sizeof (intel_dp->dpcd)) &&
+            (intel_dp->dpcd[DP_DPCD_REV] != 0)) {
+                return true;
+        }
+
+        return false;
+}
+
 /*
  * According to DP spec
  * 5.1.2:
@@ -1571,36 +1604,44 @@ intel_dp_link_down(struct intel_dp *intel_dp)
 static void
 intel_dp_check_link_status(struct intel_dp *intel_dp)
 {
-        int ret;
+        if (intel_dp->dpms_mode != DRM_MODE_DPMS_ON)
+                return;
 
         if (!intel_dp->base.base.crtc)
                 return;
 
+        /* Try to read receiver status if the link appears to be up */
         if (!intel_dp_get_link_status(intel_dp)) {
                 intel_dp_link_down(intel_dp);
                 return;
         }
 
-        /* Try to read receiver status if the link appears to be up */
-        ret = intel_dp_aux_native_read(intel_dp,
-                                       0x000, intel_dp->dpcd,
-                                       sizeof (intel_dp->dpcd));
-        if (ret != sizeof(intel_dp->dpcd)) {
+        /* Now read the DPCD to see if it's actually running */
+        if (!intel_dp_get_dpcd(intel_dp)) {
                 intel_dp_link_down(intel_dp);
                 return;
         }
 
         if (!intel_channel_eq_ok(intel_dp)) {
+                DRM_DEBUG_KMS("%s: channel EQ not ok, retraining\n",
+                              drm_get_encoder_name(&intel_dp->base.base));
                 intel_dp_start_link_train(intel_dp);
                 intel_dp_complete_link_train(intel_dp);
         }
 }
 
 static enum drm_connector_status
+intel_dp_detect_dpcd(struct intel_dp *intel_dp)
+{
+        if (intel_dp_get_dpcd(intel_dp))
+                return connector_status_connected;
+        return connector_status_disconnected;
+}
+
+static enum drm_connector_status
 ironlake_dp_detect(struct intel_dp *intel_dp)
 {
         enum drm_connector_status status;
-        bool ret;
 
         /* Can't disconnect eDP, but you can close the lid... */
         if (is_edp(intel_dp)) {
@@ -1610,15 +1651,7 @@ ironlake_dp_detect(struct intel_dp *intel_dp)
                 return status;
         }
 
-        status = connector_status_disconnected;
-        ret = intel_dp_aux_native_read_retry(intel_dp,
-                                             0x000, intel_dp->dpcd,
-                                             sizeof (intel_dp->dpcd));
-        if (ret && intel_dp->dpcd[DP_DPCD_REV] != 0)
-                status = connector_status_connected;
-        DRM_DEBUG_KMS("DPCD: %hx%hx%hx%hx\n", intel_dp->dpcd[0],
-                      intel_dp->dpcd[1], intel_dp->dpcd[2], intel_dp->dpcd[3]);
-        return status;
+        return intel_dp_detect_dpcd(intel_dp);
 }
 
 static enum drm_connector_status
@@ -1626,7 +1659,6 @@ g4x_dp_detect(struct intel_dp *intel_dp)
 {
         struct drm_device *dev = intel_dp->base.base.dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
-        enum drm_connector_status status;
         uint32_t temp, bit;
 
         switch (intel_dp->output_reg) {
@@ -1648,15 +1680,7 @@ g4x_dp_detect(struct intel_dp *intel_dp)
         if ((temp & bit) == 0)
                 return connector_status_disconnected;
 
-        status = connector_status_disconnected;
-        if (intel_dp_aux_native_read(intel_dp, 0x000, intel_dp->dpcd,
-                                     sizeof (intel_dp->dpcd)) == sizeof (intel_dp->dpcd))
-        {
-                if (intel_dp->dpcd[DP_DPCD_REV] != 0)
-                        status = connector_status_connected;
-        }
-
-        return status;
+        return intel_dp_detect_dpcd(intel_dp);
 }
 
 /**
@@ -1679,6 +1703,12 @@ intel_dp_detect(struct drm_connector *connector, bool force)
                 status = ironlake_dp_detect(intel_dp);
         else
                 status = g4x_dp_detect(intel_dp);
+
+        DRM_DEBUG_KMS("DPCD: %02hx%02hx%02hx%02hx%02hx%02hx%02hx%02hx\n",
+                      intel_dp->dpcd[0], intel_dp->dpcd[1], intel_dp->dpcd[2],
+                      intel_dp->dpcd[3], intel_dp->dpcd[4], intel_dp->dpcd[5],
+                      intel_dp->dpcd[6], intel_dp->dpcd[7]);
+
         if (status != connector_status_connected)
                 return status;
 
@@ -1811,6 +1841,11 @@ done:
 static void
 intel_dp_destroy (struct drm_connector *connector)
 {
+        struct drm_device *dev = connector->dev;
+
+        if (intel_dpd_is_edp(dev))
+                intel_panel_destroy_backlight(dev);
+
         drm_sysfs_connector_remove(connector);
         drm_connector_cleanup(connector);
         kfree(connector);
@@ -1924,6 +1959,7 @@ intel_dp_init(struct drm_device *dev, int output_reg)
                 return;
 
         intel_dp->output_reg = output_reg;
+        intel_dp->dpms_mode = -1;
 
         intel_connector = kzalloc(sizeof(struct intel_connector), GFP_KERNEL);
         if (!intel_connector) {
@@ -2000,7 +2036,7 @@ intel_dp_init(struct drm_device *dev, int output_reg)
 
         /* Cache some DPCD data in the eDP case */
         if (is_edp(intel_dp)) {
-                int ret;
+                bool ret;
                 u32 pp_on, pp_div;
 
                 pp_on = I915_READ(PCH_PP_ON_DELAYS);
@@ -2013,11 +2049,9 @@ intel_dp_init(struct drm_device *dev, int output_reg)
                 dev_priv->panel_t12 *= 100; /* t12 in 100ms units */
 
                 ironlake_edp_panel_vdd_on(intel_dp);
-                ret = intel_dp_aux_native_read(intel_dp, DP_DPCD_REV,
-                                               intel_dp->dpcd,
-                                               sizeof(intel_dp->dpcd));
+                ret = intel_dp_get_dpcd(intel_dp);
                 ironlake_edp_panel_vdd_off(intel_dp);
-                if (ret == sizeof(intel_dp->dpcd)) {
+                if (ret) {
                         if (intel_dp->dpcd[DP_DPCD_REV] >= 0x11)
                                 dev_priv->no_aux_handshake =
                                         intel_dp->dpcd[DP_MAX_DOWNSPREAD] &
@@ -2043,6 +2077,8 @@ intel_dp_init(struct drm_device *dev, int output_reg)
                                         DRM_MODE_TYPE_PREFERRED;
                         }
                 }
+                dev_priv->int_edp_connector = connector;
+                intel_panel_setup_backlight(dev);
         }
 
         intel_dp_add_properties(intel_dp, connector);
diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h
index 6e990f9760ef..0b2ee9d39980 100644
--- a/drivers/gpu/drm/i915/intel_drv.h
+++ b/drivers/gpu/drm/i915/intel_drv.h
@@ -178,10 +178,28 @@ struct intel_crtc {
 #define to_intel_encoder(x) container_of(x, struct intel_encoder, base)
 #define to_intel_framebuffer(x) container_of(x, struct intel_framebuffer, base)
 
+#define DIP_HEADER_SIZE 5
+
 #define DIP_TYPE_AVI    0x82
 #define DIP_VERSION_AVI 0x2
 #define DIP_LEN_AVI     13
 
+#define DIP_TYPE_SPD    0x3
+#define DIP_VERSION_SPD 0x1
+#define DIP_LEN_SPD     25
+#define DIP_SPD_UNKNOWN 0
+#define DIP_SPD_DSTB    0x1
+#define DIP_SPD_DVDP    0x2
+#define DIP_SPD_DVHS    0x3
+#define DIP_SPD_HDDVR   0x4
+#define DIP_SPD_DVC     0x5
+#define DIP_SPD_DSC     0x6
+#define DIP_SPD_VCD     0x7
+#define DIP_SPD_GAME    0x8
+#define DIP_SPD_PC      0x9
+#define DIP_SPD_BD      0xa
+#define DIP_SPD_SCD     0xb
+
 struct dip_infoframe {
         uint8_t type;           /* HB0 */
         uint8_t ver;            /* HB1 */
@@ -206,6 +224,11 @@ struct dip_infoframe {
                         uint16_t left_bar_end;
                         uint16_t right_bar_start;
                 } avi;
+                struct {
+                        uint8_t vn[8];
+                        uint8_t pd[16];
+                        uint8_t sdi;
+                } spd;
                 uint8_t payload[27];
         } __attribute__ ((packed)) body;
 } __attribute__((packed));
@@ -274,9 +297,10 @@ extern void intel_pch_panel_fitting(struct drm_device *dev,
 extern u32 intel_panel_get_max_backlight(struct drm_device *dev);
 extern u32 intel_panel_get_backlight(struct drm_device *dev);
 extern void intel_panel_set_backlight(struct drm_device *dev, u32 level);
-extern void intel_panel_setup_backlight(struct drm_device *dev);
+extern int intel_panel_setup_backlight(struct drm_device *dev);
 extern void intel_panel_enable_backlight(struct drm_device *dev);
 extern void intel_panel_disable_backlight(struct drm_device *dev);
+extern void intel_panel_destroy_backlight(struct drm_device *dev);
 extern enum drm_connector_status intel_panel_detect(struct drm_device *dev);
 
 extern void intel_crtc_load_lut(struct drm_crtc *crtc);
diff --git a/drivers/gpu/drm/i915/intel_hdmi.c b/drivers/gpu/drm/i915/intel_hdmi.c
index 1ed8e6903915..226ba830f383 100644
--- a/drivers/gpu/drm/i915/intel_hdmi.c
+++ b/drivers/gpu/drm/i915/intel_hdmi.c
@@ -45,6 +45,8 @@ struct intel_hdmi {
         bool has_hdmi_sink;
         bool has_audio;
         int force_audio;
+        void (*write_infoframe)(struct drm_encoder *encoder,
+                                struct dip_infoframe *frame);
 };
 
 static struct intel_hdmi *enc_to_intel_hdmi(struct drm_encoder *encoder)
@@ -58,37 +60,70 @@ static struct intel_hdmi *intel_attached_hdmi(struct drm_connector *connector)
                             struct intel_hdmi, base);
 }
 
-void intel_dip_infoframe_csum(struct dip_infoframe *avi_if)
+void intel_dip_infoframe_csum(struct dip_infoframe *frame)
 {
-        uint8_t *data = (uint8_t *)avi_if;
+        uint8_t *data = (uint8_t *)frame;
         uint8_t sum = 0;
         unsigned i;
 
-        avi_if->checksum = 0;
-        avi_if->ecc = 0;
+        frame->checksum = 0;
+        frame->ecc = 0;
 
-        for (i = 0; i < sizeof(*avi_if); i++)
+        /* Header isn't part of the checksum */
+        for (i = 5; i < frame->len; i++)
                 sum += data[i];
 
-        avi_if->checksum = 0x100 - sum;
+        frame->checksum = 0x100 - sum;
 }
 
-static void intel_hdmi_set_avi_infoframe(struct drm_encoder *encoder)
+static u32 intel_infoframe_index(struct dip_infoframe *frame)
 {
-        struct dip_infoframe avi_if = {
-                .type = DIP_TYPE_AVI,
-                .ver = DIP_VERSION_AVI,
-                .len = DIP_LEN_AVI,
-        };
-        uint32_t *data = (uint32_t *)&avi_if;
+        u32 flags = 0;
+
+        switch (frame->type) {
+        case DIP_TYPE_AVI:
+                flags |= VIDEO_DIP_SELECT_AVI;
+                break;
+        case DIP_TYPE_SPD:
+                flags |= VIDEO_DIP_SELECT_SPD;
+                break;
+        default:
+                DRM_DEBUG_DRIVER("unknown info frame type %d\n", frame->type);
+                break;
+        }
+
+        return flags;
+}
+
+static u32 intel_infoframe_flags(struct dip_infoframe *frame)
+{
+        u32 flags = 0;
+
+        switch (frame->type) {
+        case DIP_TYPE_AVI:
+                flags |= VIDEO_DIP_ENABLE_AVI | VIDEO_DIP_FREQ_VSYNC;
+                break;
+        case DIP_TYPE_SPD:
+                flags |= VIDEO_DIP_ENABLE_SPD | VIDEO_DIP_FREQ_2VSYNC;
+                break;
+        default:
+                DRM_DEBUG_DRIVER("unknown info frame type %d\n", frame->type);
+                break;
+        }
+
+        return flags;
+}
+
+static void i9xx_write_infoframe(struct drm_encoder *encoder,
+                                 struct dip_infoframe *frame)
+{
+        uint32_t *data = (uint32_t *)frame;
         struct drm_device *dev = encoder->dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
         struct intel_hdmi *intel_hdmi = enc_to_intel_hdmi(encoder);
-        u32 port;
-        unsigned i;
+        u32 port, flags, val = I915_READ(VIDEO_DIP_CTL);
+        unsigned i, len = DIP_HEADER_SIZE + frame->len;
 
-        if (!intel_hdmi->has_hdmi_sink)
-                return;
 
         /* XXX first guess at handling video port, is this corrent? */
         if (intel_hdmi->sdvox_reg == SDVOB)
@@ -98,18 +133,87 @@ static void intel_hdmi_set_avi_infoframe(struct drm_encoder *encoder)
         else
                 return;
 
-        I915_WRITE(VIDEO_DIP_CTL, VIDEO_DIP_ENABLE | port |
-                   VIDEO_DIP_SELECT_AVI | VIDEO_DIP_FREQ_VSYNC);
+        flags = intel_infoframe_index(frame);
+
+        val &= ~VIDEO_DIP_SELECT_MASK;
 
-        intel_dip_infoframe_csum(&avi_if);
-        for (i = 0; i < sizeof(avi_if); i += 4) {
+        I915_WRITE(VIDEO_DIP_CTL, val | port | flags);
+
+        for (i = 0; i < len; i += 4) {
                 I915_WRITE(VIDEO_DIP_DATA, *data);
                 data++;
         }
 
-        I915_WRITE(VIDEO_DIP_CTL, VIDEO_DIP_ENABLE | port |
-                   VIDEO_DIP_SELECT_AVI | VIDEO_DIP_FREQ_VSYNC |
-                   VIDEO_DIP_ENABLE_AVI);
+        flags |= intel_infoframe_flags(frame);
+
+        I915_WRITE(VIDEO_DIP_CTL, VIDEO_DIP_ENABLE | val | port | flags);
+}
+
+static void ironlake_write_infoframe(struct drm_encoder *encoder,
+                                     struct dip_infoframe *frame)
+{
+        uint32_t *data = (uint32_t *)frame;
+        struct drm_device *dev = encoder->dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        struct drm_crtc *crtc = encoder->crtc;
+        struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
+        int reg = TVIDEO_DIP_CTL(intel_crtc->pipe);
+        unsigned i, len = DIP_HEADER_SIZE + frame->len;
+        u32 flags, val = I915_READ(reg);
+
+        intel_wait_for_vblank(dev, intel_crtc->pipe);
+
+        flags = intel_infoframe_index(frame);
+
+        val &= ~VIDEO_DIP_SELECT_MASK;
+
+        I915_WRITE(reg, val | flags);
+
+        for (i = 0; i < len; i += 4) {
+                I915_WRITE(TVIDEO_DIP_DATA(intel_crtc->pipe), *data);
+                data++;
+        }
+
+        flags |= intel_infoframe_flags(frame);
+
+        I915_WRITE(reg, VIDEO_DIP_ENABLE | val | flags);
+}
+static void intel_set_infoframe(struct drm_encoder *encoder,
+                                struct dip_infoframe *frame)
+{
+        struct intel_hdmi *intel_hdmi = enc_to_intel_hdmi(encoder);
+
+        if (!intel_hdmi->has_hdmi_sink)
+                return;
+
+        intel_dip_infoframe_csum(frame);
+        intel_hdmi->write_infoframe(encoder, frame);
+}
+
+static void intel_hdmi_set_avi_infoframe(struct drm_encoder *encoder)
+{
+        struct dip_infoframe avi_if = {
+                .type = DIP_TYPE_AVI,
+                .ver = DIP_VERSION_AVI,
+                .len = DIP_LEN_AVI,
+        };
+
+        intel_set_infoframe(encoder, &avi_if);
+}
+
+static void intel_hdmi_set_spd_infoframe(struct drm_encoder *encoder)
+{
+        struct dip_infoframe spd_if;
+
+        memset(&spd_if, 0, sizeof(spd_if));
+        spd_if.type = DIP_TYPE_SPD;
+        spd_if.ver = DIP_VERSION_SPD;
+        spd_if.len = DIP_LEN_SPD;
+        strcpy(spd_if.body.spd.vn, "Intel");
+        strcpy(spd_if.body.spd.pd, "Integrated gfx");
+        spd_if.body.spd.sdi = DIP_SPD_PC;
+
+        intel_set_infoframe(encoder, &spd_if);
 }
 
 static void intel_hdmi_mode_set(struct drm_encoder *encoder,
@@ -156,6 +260,7 @@ static void intel_hdmi_mode_set(struct drm_encoder *encoder,
         POSTING_READ(intel_hdmi->sdvox_reg);
 
         intel_hdmi_set_avi_infoframe(encoder);
+        intel_hdmi_set_spd_infoframe(encoder);
 }
 
 static void intel_hdmi_dpms(struct drm_encoder *encoder, int mode)
@@ -433,6 +538,11 @@ void intel_hdmi_init(struct drm_device *dev, int sdvox_reg)
 
         intel_hdmi->sdvox_reg = sdvox_reg;
 
+        if (!HAS_PCH_SPLIT(dev))
+                intel_hdmi->write_infoframe = i9xx_write_infoframe;
+        else
+                intel_hdmi->write_infoframe = ironlake_write_infoframe;
+
         drm_encoder_helper_add(&intel_encoder->base, &intel_hdmi_helper_funcs);
 
         intel_hdmi_add_properties(intel_hdmi, connector);
diff --git a/drivers/gpu/drm/i915/intel_lvds.c b/drivers/gpu/drm/i915/intel_lvds.c
index b28f7bd9f88a..31da77f5c051 100644
--- a/drivers/gpu/drm/i915/intel_lvds.c
+++ b/drivers/gpu/drm/i915/intel_lvds.c
@@ -72,14 +72,16 @@ static void intel_lvds_enable(struct intel_lvds *intel_lvds)
 {
         struct drm_device *dev = intel_lvds->base.base.dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
-        u32 ctl_reg, lvds_reg;
+        u32 ctl_reg, lvds_reg, stat_reg;
 
         if (HAS_PCH_SPLIT(dev)) {
                 ctl_reg = PCH_PP_CONTROL;
                 lvds_reg = PCH_LVDS;
+                stat_reg = PCH_PP_STATUS;
         } else {
                 ctl_reg = PP_CONTROL;
                 lvds_reg = LVDS;
+                stat_reg = PP_STATUS;
         }
 
         I915_WRITE(lvds_reg, I915_READ(lvds_reg) | LVDS_PORT_EN);
@@ -94,17 +96,16 @@ static void intel_lvds_enable(struct intel_lvds *intel_lvds)
                 DRM_DEBUG_KMS("applying panel-fitter: %x, %x\n",
                               intel_lvds->pfit_control,
                               intel_lvds->pfit_pgm_ratios);
-                if (wait_for((I915_READ(PP_STATUS) & PP_ON) == 0, 1000)) {
-                        DRM_ERROR("timed out waiting for panel to power off\n");
-                } else {
-                        I915_WRITE(PFIT_PGM_RATIOS, intel_lvds->pfit_pgm_ratios);
-                        I915_WRITE(PFIT_CONTROL, intel_lvds->pfit_control);
-                        intel_lvds->pfit_dirty = false;
-                }
+
+                I915_WRITE(PFIT_PGM_RATIOS, intel_lvds->pfit_pgm_ratios);
+                I915_WRITE(PFIT_CONTROL, intel_lvds->pfit_control);
+                intel_lvds->pfit_dirty = false;
         }
 
         I915_WRITE(ctl_reg, I915_READ(ctl_reg) | POWER_TARGET_ON);
         POSTING_READ(lvds_reg);
+        if (wait_for((I915_READ(stat_reg) & PP_ON) != 0, 1000))
+                DRM_ERROR("timed out waiting for panel to power on\n");
 
         intel_panel_enable_backlight(dev);
 }
@@ -113,24 +114,25 @@ static void intel_lvds_disable(struct intel_lvds *intel_lvds)
 {
         struct drm_device *dev = intel_lvds->base.base.dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
-        u32 ctl_reg, lvds_reg;
+        u32 ctl_reg, lvds_reg, stat_reg;
 
         if (HAS_PCH_SPLIT(dev)) {
                 ctl_reg = PCH_PP_CONTROL;
                 lvds_reg = PCH_LVDS;
+                stat_reg = PCH_PP_STATUS;
         } else {
                 ctl_reg = PP_CONTROL;
                 lvds_reg = LVDS;
+                stat_reg = PP_STATUS;
         }
 
         intel_panel_disable_backlight(dev);
 
         I915_WRITE(ctl_reg, I915_READ(ctl_reg) & ~POWER_TARGET_ON);
+        if (wait_for((I915_READ(stat_reg) & PP_ON) == 0, 1000))
+                DRM_ERROR("timed out waiting for panel to power off\n");
 
         if (intel_lvds->pfit_control) {
-                if (wait_for((I915_READ(PP_STATUS) & PP_ON) == 0, 1000))
-                        DRM_ERROR("timed out waiting for panel to power off\n");
-
                 I915_WRITE(PFIT_CONTROL, 0);
                 intel_lvds->pfit_dirty = true;
         }
@@ -398,53 +400,21 @@ out:
 
 static void intel_lvds_prepare(struct drm_encoder *encoder)
 {
-        struct drm_device *dev = encoder->dev;
-        struct drm_i915_private *dev_priv = dev->dev_private;
         struct intel_lvds *intel_lvds = to_intel_lvds(encoder);
 
-        /* We try to do the minimum that is necessary in order to unlock
-         * the registers for mode setting.
-         *
-         * On Ironlake, this is quite simple as we just set the unlock key
-         * and ignore all subtleties. (This may cause some issues...)
-         *
+        /*
          * Prior to Ironlake, we must disable the pipe if we want to adjust
          * the panel fitter. However at all other times we can just reset
          * the registers regardless.
          */
-
-        if (HAS_PCH_SPLIT(dev)) {
-                I915_WRITE(PCH_PP_CONTROL,
-                           I915_READ(PCH_PP_CONTROL) | PANEL_UNLOCK_REGS);
-        } else if (intel_lvds->pfit_dirty) {
-                I915_WRITE(PP_CONTROL,
-                           (I915_READ(PP_CONTROL) | PANEL_UNLOCK_REGS)
-                           & ~POWER_TARGET_ON);
-        } else {
-                I915_WRITE(PP_CONTROL,
-                           I915_READ(PP_CONTROL) | PANEL_UNLOCK_REGS);
-        }
+        if (!HAS_PCH_SPLIT(encoder->dev) && intel_lvds->pfit_dirty)
+                intel_lvds_disable(intel_lvds);
 }
 
 static void intel_lvds_commit(struct drm_encoder *encoder)
 {
-        struct drm_device *dev = encoder->dev;
-        struct drm_i915_private *dev_priv = dev->dev_private;
         struct intel_lvds *intel_lvds = to_intel_lvds(encoder);
 
-        /* Undo any unlocking done in prepare to prevent accidental
-         * adjustment of the registers.
-         */
-        if (HAS_PCH_SPLIT(dev)) {
-                u32 val = I915_READ(PCH_PP_CONTROL);
-                if ((val & PANEL_UNLOCK_REGS) == PANEL_UNLOCK_REGS)
-                        I915_WRITE(PCH_PP_CONTROL, val & 0x3);
-        } else {
-                u32 val = I915_READ(PP_CONTROL);
-                if ((val & PANEL_UNLOCK_REGS) == PANEL_UNLOCK_REGS)
-                        I915_WRITE(PP_CONTROL, val & 0x3);
-        }
-
         /* Always do a full power on as we do not know what state
          * we were left in.
          */
@@ -582,6 +552,8 @@ static void intel_lvds_destroy(struct drm_connector *connector)
         struct drm_device *dev = connector->dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
 
+        intel_panel_destroy_backlight(dev);
+
         if (dev_priv->lid_notifier.notifier_call)
                 acpi_lid_notifier_unregister(&dev_priv->lid_notifier);
         drm_sysfs_connector_remove(connector);
@@ -690,6 +662,14 @@ static const struct dmi_system_id intel_no_lvds[] = {
         },
         {
                 .callback = intel_no_lvds_dmi_callback,
+                .ident = "Dell OptiPlex FX170",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex FX170"),
+                },
+        },
+        {
+                .callback = intel_no_lvds_dmi_callback,
                 .ident = "AOpen Mini PC",
                 .matches = {
                         DMI_MATCH(DMI_SYS_VENDOR, "AOpen"),
@@ -1032,6 +1012,19 @@ out:
                 pwm = I915_READ(BLC_PWM_PCH_CTL1);
                 pwm |= PWM_PCH_ENABLE;
                 I915_WRITE(BLC_PWM_PCH_CTL1, pwm);
+                /*
+                 * Unlock registers and just
+                 * leave them unlocked
+                 */
+                I915_WRITE(PCH_PP_CONTROL,
+                           I915_READ(PCH_PP_CONTROL) | PANEL_UNLOCK_REGS);
+        } else {
+                /*
+                 * Unlock registers and just
+                 * leave them unlocked
+                 */
+                I915_WRITE(PP_CONTROL,
+                           I915_READ(PP_CONTROL) | PANEL_UNLOCK_REGS);
         }
         dev_priv->lid_notifier.notifier_call = intel_lid_notify;
         if (acpi_lid_notifier_register(&dev_priv->lid_notifier)) {
@@ -1041,6 +1034,9 @@ out:
         /* keep the LVDS connector */
         dev_priv->int_lvds_connector = connector;
         drm_sysfs_connector_add(connector);
+
+        intel_panel_setup_backlight(dev);
+
         return true;
 
 failed:
diff --git a/drivers/gpu/drm/i915/intel_opregion.c b/drivers/gpu/drm/i915/intel_opregion.c
index b7c5ddb564d1..b8e8158bb16e 100644
--- a/drivers/gpu/drm/i915/intel_opregion.c
+++ b/drivers/gpu/drm/i915/intel_opregion.c
@@ -227,7 +227,6 @@ void intel_opregion_asle_intr(struct drm_device *dev)
         asle->aslc = asle_stat;
 }
 
-/* Only present on Ironlake+ */
 void intel_opregion_gse_intr(struct drm_device *dev)
 {
         struct drm_i915_private *dev_priv = dev->dev_private;
diff --git a/drivers/gpu/drm/i915/intel_panel.c b/drivers/gpu/drm/i915/intel_panel.c
index a06ff07a4d3b..a9e0c7bcd317 100644
--- a/drivers/gpu/drm/i915/intel_panel.c
+++ b/drivers/gpu/drm/i915/intel_panel.c
@@ -83,11 +83,15 @@ intel_pch_panel_fitting(struct drm_device *dev,
                         u32 scaled_height = mode->hdisplay * adjusted_mode->vdisplay;
                         if (scaled_width > scaled_height) { /* pillar */
                                 width = scaled_height / mode->vdisplay;
+                                if (width & 1)
+                                        width++;
                                 x = (adjusted_mode->hdisplay - width + 1) / 2;
                                 y = 0;
                                 height = adjusted_mode->vdisplay;
                         } else if (scaled_width < scaled_height) { /* letter */
                                 height = scaled_width / mode->hdisplay;
+                                if (height & 1)
+                                    height++;
                                 y = (adjusted_mode->vdisplay - height + 1) / 2;
                                 x = 0;
                                 width = adjusted_mode->hdisplay;
@@ -273,7 +277,7 @@ void intel_panel_enable_backlight(struct drm_device *dev)
         dev_priv->backlight_enabled = true;
 }
 
-void intel_panel_setup_backlight(struct drm_device *dev)
+static void intel_panel_init_backlight(struct drm_device *dev)
 {
         struct drm_i915_private *dev_priv = dev->dev_private;
 
@@ -305,3 +309,73 @@ intel_panel_detect(struct drm_device *dev)
 
         return connector_status_unknown;
 }
+
+#ifdef CONFIG_BACKLIGHT_CLASS_DEVICE
+static int intel_panel_update_status(struct backlight_device *bd)
+{
+        struct drm_device *dev = bl_get_data(bd);
+        intel_panel_set_backlight(dev, bd->props.brightness);
+        return 0;
+}
+
+static int intel_panel_get_brightness(struct backlight_device *bd)
+{
+        struct drm_device *dev = bl_get_data(bd);
+        return intel_panel_get_backlight(dev);
+}
+
+static const struct backlight_ops intel_panel_bl_ops = {
+        .update_status = intel_panel_update_status,
+        .get_brightness = intel_panel_get_brightness,
+};
+
+int intel_panel_setup_backlight(struct drm_device *dev)
+{
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        struct backlight_properties props;
+        struct drm_connector *connector;
+
+        intel_panel_init_backlight(dev);
+
+        if (dev_priv->int_lvds_connector)
+                connector = dev_priv->int_lvds_connector;
+        else if (dev_priv->int_edp_connector)
+                connector = dev_priv->int_edp_connector;
+        else
+                return -ENODEV;
+
+        props.type = BACKLIGHT_RAW;
+        props.max_brightness = intel_panel_get_max_backlight(dev);
+        dev_priv->backlight =
+                backlight_device_register("intel_backlight",
+                                          &connector->kdev, dev,
+                                          &intel_panel_bl_ops, &props);
+
+        if (IS_ERR(dev_priv->backlight)) {
+                DRM_ERROR("Failed to register backlight: %ld\n",
+                          PTR_ERR(dev_priv->backlight));
+                dev_priv->backlight = NULL;
+                return -ENODEV;
+        }
+        dev_priv->backlight->props.brightness = intel_panel_get_backlight(dev);
+        return 0;
+}
+
+void intel_panel_destroy_backlight(struct drm_device *dev)
+{
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        if (dev_priv->backlight)
+                backlight_device_unregister(dev_priv->backlight);
+}
+#else
+int intel_panel_setup_backlight(struct drm_device *dev)
+{
+        intel_panel_init_backlight(dev);
+        return 0;
+}
+
+void intel_panel_destroy_backlight(struct drm_device *dev)
+{
+        return;
+}
+#endif
diff --git a/drivers/gpu/drm/i915/intel_ringbuffer.c b/drivers/gpu/drm/i915/intel_ringbuffer.c
index e9615685a39c..c30626ea9f93 100644
--- a/drivers/gpu/drm/i915/intel_ringbuffer.c
+++ b/drivers/gpu/drm/i915/intel_ringbuffer.c
@@ -290,6 +290,10 @@ static int init_render_ring(struct intel_ring_buffer *ring)
                 if (IS_GEN6(dev) || IS_GEN7(dev))
                         mode |= MI_FLUSH_ENABLE << 16 | MI_FLUSH_ENABLE;
                 I915_WRITE(MI_MODE, mode);
+                if (IS_GEN7(dev))
+                        I915_WRITE(GFX_MODE_GEN7,
+                                   GFX_MODE_DISABLE(GFX_TLB_INVALIDATE_ALWAYS) |
+                                   GFX_MODE_ENABLE(GFX_REPLAY_MODE));
         }
 
         if (INTEL_INFO(dev)->gen >= 6) {
@@ -1321,6 +1325,9 @@ int intel_render_ring_init_dri(struct drm_device *dev, u64 start, u32 size)
                 ring->get_seqno = pc_render_get_seqno;
         }
 
+        if (!I915_NEED_GFX_HWS(dev))
+                ring->status_page.page_addr = dev_priv->status_page_dmah->vaddr;
+
         ring->dev = dev;
         INIT_LIST_HEAD(&ring->active_list);
         INIT_LIST_HEAD(&ring->request_list);
diff --git a/drivers/gpu/drm/nouveau/nouveau_fence.c b/drivers/gpu/drm/nouveau/nouveau_fence.c
index 8d02d875376d..c919cfc8f2fd 100644
--- a/drivers/gpu/drm/nouveau/nouveau_fence.c
+++ b/drivers/gpu/drm/nouveau/nouveau_fence.c
@@ -530,7 +530,8 @@ nouveau_fence_channel_init(struct nouveau_channel *chan)
                 nouveau_gpuobj_ref(NULL, &obj);
                 if (ret)
                         return ret;
-        } else {
+        } else
+        if (USE_SEMA(dev)) {
                 /* map fence bo into channel's vm */
                 ret = nouveau_bo_vma_add(dev_priv->fence.bo, chan->vm,
                                          &chan->fence.vma);
diff --git a/drivers/gpu/drm/nouveau/nouveau_sgdma.c b/drivers/gpu/drm/nouveau/nouveau_sgdma.c
index c444cadbf849..2706cb3d871a 100644
--- a/drivers/gpu/drm/nouveau/nouveau_sgdma.c
+++ b/drivers/gpu/drm/nouveau/nouveau_sgdma.c
@@ -37,8 +37,11 @@ nouveau_sgdma_populate(struct ttm_backend *be, unsigned long num_pages,
                 return -ENOMEM;
 
         nvbe->ttm_alloced = kmalloc(sizeof(bool) * num_pages, GFP_KERNEL);
-        if (!nvbe->ttm_alloced)
+        if (!nvbe->ttm_alloced) {
+                kfree(nvbe->pages);
+                nvbe->pages = NULL;
                 return -ENOMEM;
+        }
 
         nvbe->nr_pages = 0;
         while (num_pages--) {
@@ -126,7 +129,7 @@ nv04_sgdma_bind(struct ttm_backend *be, struct ttm_mem_reg *mem)
 
                 for (j = 0; j < PAGE_SIZE / NV_CTXDMA_PAGE_SIZE; j++, pte++) {
                         nv_wo32(gpuobj, (pte * 4) + 0, offset_l | 3);
-                        dma_offset += NV_CTXDMA_PAGE_SIZE;
+                        offset_l += NV_CTXDMA_PAGE_SIZE;
                 }
         }
 
diff --git a/drivers/gpu/drm/nouveau/nv04_crtc.c b/drivers/gpu/drm/nouveau/nv04_crtc.c
index 118261d4927a..5e45398a9e2d 100644
--- a/drivers/gpu/drm/nouveau/nv04_crtc.c
+++ b/drivers/gpu/drm/nouveau/nv04_crtc.c
@@ -781,11 +781,20 @@ nv04_crtc_do_mode_set_base(struct drm_crtc *crtc,
         struct drm_device *dev = crtc->dev;
         struct drm_nouveau_private *dev_priv = dev->dev_private;
         struct nv04_crtc_reg *regp = &dev_priv->mode_reg.crtc_reg[nv_crtc->index];
-        struct drm_framebuffer *drm_fb = nv_crtc->base.fb;
-        struct nouveau_framebuffer *fb = nouveau_framebuffer(drm_fb);
+        struct drm_framebuffer *drm_fb;
+        struct nouveau_framebuffer *fb;
         int arb_burst, arb_lwm;
         int ret;
 
+        NV_DEBUG_KMS(dev, "index %d\n", nv_crtc->index);
+
+        /* no fb bound */
+        if (!atomic && !crtc->fb) {
+                NV_DEBUG_KMS(dev, "No FB bound\n");
+                return 0;
+        }
+
+
         /* If atomic, we want to switch to the fb we were passed, so
          * now we update pointers to do that.  (We don't pin; just
          * assume we're already pinned and update the base address.)
@@ -794,6 +803,8 @@ nv04_crtc_do_mode_set_base(struct drm_crtc *crtc,
                 drm_fb = passed_fb;
                 fb = nouveau_framebuffer(passed_fb);
         } else {
+                drm_fb = crtc->fb;
+                fb = nouveau_framebuffer(crtc->fb);
                 /* If not atomic, we can go ahead and pin, and unpin the
                  * old fb we were passed.
                  */
diff --git a/drivers/gpu/drm/nouveau/nv50_crtc.c b/drivers/gpu/drm/nouveau/nv50_crtc.c
index 46ad59ea2185..5d989073ba6e 100644
--- a/drivers/gpu/drm/nouveau/nv50_crtc.c
+++ b/drivers/gpu/drm/nouveau/nv50_crtc.c
@@ -519,12 +519,18 @@ nv50_crtc_do_mode_set_base(struct drm_crtc *crtc,
         struct drm_device *dev = nv_crtc->base.dev;
         struct drm_nouveau_private *dev_priv = dev->dev_private;
         struct nouveau_channel *evo = nv50_display(dev)->master;
-        struct drm_framebuffer *drm_fb = nv_crtc->base.fb;
-        struct nouveau_framebuffer *fb = nouveau_framebuffer(drm_fb);
+        struct drm_framebuffer *drm_fb;
+        struct nouveau_framebuffer *fb;
         int ret;
 
         NV_DEBUG_KMS(dev, "index %d\n", nv_crtc->index);
 
+        /* no fb bound */
+        if (!atomic && !crtc->fb) {
+                NV_DEBUG_KMS(dev, "No FB bound\n");
+                return 0;
+        }
+
         /* If atomic, we want to switch to the fb we were passed, so
          * now we update pointers to do that.  (We don't pin; just
          * assume we're already pinned and update the base address.)
@@ -533,6 +539,8 @@ nv50_crtc_do_mode_set_base(struct drm_crtc *crtc,
                 drm_fb = passed_fb;
                 fb = nouveau_framebuffer(passed_fb);
         } else {
+                drm_fb = crtc->fb;
+                fb = nouveau_framebuffer(crtc->fb);
                 /* If not atomic, we can go ahead and pin, and unpin the
                  * old fb we were passed.
                  */
diff --git a/drivers/gpu/drm/radeon/Makefile b/drivers/gpu/drm/radeon/Makefile
index 3896ef811102..9f363e0c4b60 100644
--- a/drivers/gpu/drm/radeon/Makefile
+++ b/drivers/gpu/drm/radeon/Makefile
@@ -5,6 +5,7 @@
 ccflags-y := -Iinclude/drm
 
 hostprogs-y := mkregtable
+clean-files := rn50_reg_safe.h r100_reg_safe.h r200_reg_safe.h rv515_reg_safe.h r300_reg_safe.h r420_reg_safe.h rs600_reg_safe.h r600_reg_safe.h evergreen_reg_safe.h cayman_reg_safe.h
 
 quiet_cmd_mkregtable = MKREGTABLE $@
       cmd_mkregtable = $(obj)/mkregtable $< > $@
diff --git a/drivers/gpu/drm/radeon/atom.c b/drivers/gpu/drm/radeon/atom.c
index ebdb0fdb8348..e88c64417a8a 100644
--- a/drivers/gpu/drm/radeon/atom.c
+++ b/drivers/gpu/drm/radeon/atom.c
@@ -1245,6 +1245,9 @@ struct atom_context *atom_parse(struct card_info *card, void *bios)
         char name[512];
         int i;
 
+        if (!ctx)
+                return NULL;
+
         ctx->card = card;
         ctx->bios = bios;
 
diff --git a/drivers/gpu/drm/radeon/atombios_dp.c b/drivers/gpu/drm/radeon/atombios_dp.c
index 645b84b3d203..7ad43c6b1db7 100644
--- a/drivers/gpu/drm/radeon/atombios_dp.c
+++ b/drivers/gpu/drm/radeon/atombios_dp.c
@@ -613,6 +613,18 @@ static bool radeon_dp_get_link_status(struct radeon_connector *radeon_connector,
         return true;
 }
 
+bool radeon_dp_needs_link_train(struct radeon_connector *radeon_connector)
+{
+        u8 link_status[DP_LINK_STATUS_SIZE];
+        struct radeon_connector_atom_dig *dig = radeon_connector->con_priv;
+
+        if (!radeon_dp_get_link_status(radeon_connector, link_status))
+                return false;
+        if (dp_channel_eq_ok(link_status, dig->dp_lane_count))
+                return false;
+        return true;
+}
+
 struct radeon_dp_link_train_info {
         struct radeon_device *rdev;
         struct drm_encoder *encoder;
diff --git a/drivers/gpu/drm/radeon/evergreen.c b/drivers/gpu/drm/radeon/evergreen.c
index 14dce9f22172..dc0a5b56c81a 100644
--- a/drivers/gpu/drm/radeon/evergreen.c
+++ b/drivers/gpu/drm/radeon/evergreen.c
@@ -41,6 +41,31 @@ static void evergreen_gpu_init(struct radeon_device *rdev);
 void evergreen_fini(struct radeon_device *rdev);
 static void evergreen_pcie_gen2_enable(struct radeon_device *rdev);
 
+void evergreen_fix_pci_max_read_req_size(struct radeon_device *rdev)
+{
+        u16 ctl, v;
+        int cap, err;
+
+        cap = pci_pcie_cap(rdev->pdev);
+        if (!cap)
+                return;
+
+        err = pci_read_config_word(rdev->pdev, cap + PCI_EXP_DEVCTL, &ctl);
+        if (err)
+                return;
+
+        v = (ctl & PCI_EXP_DEVCTL_READRQ) >> 12;
+
+        /* if bios or OS sets MAX_READ_REQUEST_SIZE to an invalid value, fix it
+         * to avoid hangs or perfomance issues
+         */
+        if ((v == 0) || (v == 6) || (v == 7)) {
+                ctl &= ~PCI_EXP_DEVCTL_READRQ;
+                ctl |= (2 << 12);
+                pci_write_config_word(rdev->pdev, cap + PCI_EXP_DEVCTL, ctl);
+        }
+}
+
 void evergreen_pre_page_flip(struct radeon_device *rdev, int crtc)
 {
         /* enable the pflip int */
@@ -743,7 +768,7 @@ static void evergreen_program_watermarks(struct radeon_device *rdev,
                     !evergreen_average_bandwidth_vs_available_bandwidth(&wm) ||
                     !evergreen_check_latency_hiding(&wm) ||
                     (rdev->disp_priority == 2)) {
-                        DRM_INFO("force priority to high\n");
+                        DRM_DEBUG_KMS("force priority to high\n");
                         priority_a_cnt |= PRIORITY_ALWAYS_ON;
                         priority_b_cnt |= PRIORITY_ALWAYS_ON;
                 }
@@ -1357,6 +1382,7 @@ int evergreen_cp_resume(struct radeon_device *rdev)
                                  SOFT_RESET_PA |
                                  SOFT_RESET_SH |
                                  SOFT_RESET_VGT |
+                                 SOFT_RESET_SPI |
                                  SOFT_RESET_SX));
         RREG32(GRBM_SOFT_RESET);
         mdelay(15);
@@ -1862,6 +1888,8 @@ static void evergreen_gpu_init(struct radeon_device *rdev)
 
         WREG32(GRBM_CNTL, GRBM_READ_TIMEOUT(0xff));
 
+        evergreen_fix_pci_max_read_req_size(rdev);
+
         cc_gc_shader_pipe_config = RREG32(CC_GC_SHADER_PIPE_CONFIG) & ~2;
 
         cc_gc_shader_pipe_config |=
diff --git a/drivers/gpu/drm/radeon/evergreen_cs.c b/drivers/gpu/drm/radeon/evergreen_cs.c
index 189e86522b5b..a134790903d3 100644
--- a/drivers/gpu/drm/radeon/evergreen_cs.c
+++ b/drivers/gpu/drm/radeon/evergreen_cs.c
@@ -428,7 +428,7 @@ static inline int evergreen_cs_check_reg(struct radeon_cs_parser *p, u32 reg, u3
                 last_reg = ARRAY_SIZE(evergreen_reg_safe_bm);
 
         i = (reg >> 7);
-        if (i > last_reg) {
+        if (i >= last_reg) {
                 dev_warn(p->dev, "forbidden register 0x%08x at %d\n", reg, idx);
                 return -EINVAL;
         }
diff --git a/drivers/gpu/drm/radeon/ni.c b/drivers/gpu/drm/radeon/ni.c
index 44c4750f4518..cbf57d75d925 100644
--- a/drivers/gpu/drm/radeon/ni.c
+++ b/drivers/gpu/drm/radeon/ni.c
@@ -39,6 +39,7 @@ extern int evergreen_mc_wait_for_idle(struct radeon_device *rdev);
 extern void evergreen_mc_program(struct radeon_device *rdev);
 extern void evergreen_irq_suspend(struct radeon_device *rdev);
 extern int evergreen_mc_init(struct radeon_device *rdev);
+extern void evergreen_fix_pci_max_read_req_size(struct radeon_device *rdev);
 
 #define EVERGREEN_PFP_UCODE_SIZE 1120
 #define EVERGREEN_PM4_UCODE_SIZE 1376
@@ -669,6 +670,8 @@ static void cayman_gpu_init(struct radeon_device *rdev)
 
         WREG32(GRBM_CNTL, GRBM_READ_TIMEOUT(0xff));
 
+        evergreen_fix_pci_max_read_req_size(rdev);
+
         mc_shared_chmap = RREG32(MC_SHARED_CHMAP);
         mc_arb_ramcfg = RREG32(MC_ARB_RAMCFG);
 
@@ -1159,6 +1162,7 @@ int cayman_cp_resume(struct radeon_device *rdev)
                                  SOFT_RESET_PA |
                                  SOFT_RESET_SH |
                                  SOFT_RESET_VGT |
+                                 SOFT_RESET_SPI |
                                  SOFT_RESET_SX));
         RREG32(GRBM_SOFT_RESET);
         mdelay(15);
diff --git a/drivers/gpu/drm/radeon/r600_cs.c b/drivers/gpu/drm/radeon/r600_cs.c
index db8ef1905d5f..cf83aa05a684 100644
--- a/drivers/gpu/drm/radeon/r600_cs.c
+++ b/drivers/gpu/drm/radeon/r600_cs.c
@@ -915,12 +915,11 @@ static inline int r600_cs_check_reg(struct radeon_cs_parser *p, u32 reg, u32 idx
 {
         struct r600_cs_track *track = (struct r600_cs_track *)p->track;
         struct radeon_cs_reloc *reloc;
-        u32 last_reg = ARRAY_SIZE(r600_reg_safe_bm);
         u32 m, i, tmp, *ib;
         int r;
 
         i = (reg >> 7);
-        if (i > last_reg) {
+        if (i >= ARRAY_SIZE(r600_reg_safe_bm)) {
                 dev_warn(p->dev, "forbidden register 0x%08x at %d\n", reg, idx);
                 return -EINVAL;
         }
diff --git a/drivers/gpu/drm/radeon/radeon_clocks.c b/drivers/gpu/drm/radeon/radeon_clocks.c
index dcd0863e31ae..b6e18c8db9f5 100644
--- a/drivers/gpu/drm/radeon/radeon_clocks.c
+++ b/drivers/gpu/drm/radeon/radeon_clocks.c
@@ -219,6 +219,9 @@ void radeon_get_clock_info(struct drm_device *dev)
                 } else {
                         DRM_INFO("Using generic clock info\n");
 
+                        /* may need to be per card */
+                        rdev->clock.max_pixel_clock = 35000;
+
                         if (rdev->flags & RADEON_IS_IGP) {
                                 p1pll->reference_freq = 1432;
                                 p2pll->reference_freq = 1432;
diff --git a/drivers/gpu/drm/radeon/radeon_combios.c b/drivers/gpu/drm/radeon/radeon_combios.c
index a74217cd192f..63675241c7ff 100644
--- a/drivers/gpu/drm/radeon/radeon_combios.c
+++ b/drivers/gpu/drm/radeon/radeon_combios.c
@@ -2557,6 +2557,7 @@ void radeon_combios_get_power_modes(struct radeon_device *rdev)
         u16 offset, misc, misc2 = 0;
         u8 rev, blocks, tmp;
         int state_index = 0;
+        struct radeon_i2c_bus_rec i2c_bus;
 
         rdev->pm.default_power_state_index = -1;
 
@@ -2575,7 +2576,6 @@ void radeon_combios_get_power_modes(struct radeon_device *rdev)
         offset = combios_get_table_offset(dev, COMBIOS_OVERDRIVE_INFO_TABLE);
         if (offset) {
                 u8 thermal_controller = 0, gpio = 0, i2c_addr = 0, clk_bit = 0, data_bit = 0;
-                struct radeon_i2c_bus_rec i2c_bus;
 
                 rev = RBIOS8(offset);
 
@@ -2617,6 +2617,25 @@ void radeon_combios_get_power_modes(struct radeon_device *rdev)
                                 i2c_new_device(&rdev->pm.i2c_bus->adapter, &info);
                         }
                 }
+        } else {
+                /* boards with a thermal chip, but no overdrive table */
+
+                /* Asus 9600xt has an f75375 on the monid bus */
+                if ((dev->pdev->device == 0x4152) &&
+                    (dev->pdev->subsystem_vendor == 0x1043) &&
+                    (dev->pdev->subsystem_device == 0xc002)) {
+                        i2c_bus = combios_setup_i2c_bus(rdev, DDC_MONID, 0, 0);
+                        rdev->pm.i2c_bus = radeon_i2c_lookup(rdev, &i2c_bus);
+                        if (rdev->pm.i2c_bus) {
+                                struct i2c_board_info info = { };
+                                const char *name = "f75375";
+                                info.addr = 0x28;
+                                strlcpy(info.type, name, sizeof(info.type));
+                                i2c_new_device(&rdev->pm.i2c_bus->adapter, &info);
+                                DRM_INFO("Possible %s thermal controller at 0x%02x\n",
+                                         name, info.addr);
+                        }
+                }
         }
 
         if (rdev->flags & RADEON_IS_MOBILITY) {
@@ -3279,6 +3298,14 @@ void radeon_combios_asic_init(struct drm_device *dev)
             rdev->pdev->subsystem_device == 0x30a4)
                 return;
 
+        /* quirk for rs4xx Compaq Presario V5245EU laptop to make it resume
+         * - it hangs on resume inside the dynclk 1 table.
+         */
+        if (rdev->family == CHIP_RS480 &&
+            rdev->pdev->subsystem_vendor == 0x103c &&
+            rdev->pdev->subsystem_device == 0x30ae)
+                return;
+
         /* DYN CLK 1 */
         table = combios_get_table_offset(dev, COMBIOS_DYN_CLK_1_TABLE);
         if (table)
diff --git a/drivers/gpu/drm/radeon/radeon_connectors.c b/drivers/gpu/drm/radeon/radeon_connectors.c
index 9792d4ffdc86..c4b8741dbf58 100644
--- a/drivers/gpu/drm/radeon/radeon_connectors.c
+++ b/drivers/gpu/drm/radeon/radeon_connectors.c
@@ -60,18 +60,20 @@ void radeon_connector_hotplug(struct drm_connector *connector)
 
         radeon_hpd_set_polarity(rdev, radeon_connector->hpd.hpd);
 
-        /* powering up/down the eDP panel generates hpd events which
-         * can interfere with modesetting.
-         */
-        if (connector->connector_type == DRM_MODE_CONNECTOR_eDP)
+        /* if the connector is already off, don't turn it back on */
+        if (connector->dpms != DRM_MODE_DPMS_ON)
                 return;
 
-        /* pre-r600 did not always have the hpd pins mapped accurately to connectors */
-        if (rdev->family >= CHIP_R600) {
-                if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd))
+        /* just deal with DP (not eDP) here. */
+        if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) {
+                int saved_dpms = connector->dpms;
+
+                if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd) &&
+                    radeon_dp_needs_link_train(radeon_connector))
                         drm_helper_connector_dpms(connector, DRM_MODE_DPMS_ON);
                 else
                         drm_helper_connector_dpms(connector, DRM_MODE_DPMS_OFF);
+                connector->dpms = saved_dpms;
         }
 }
 
@@ -430,16 +432,73 @@ int radeon_connector_set_property(struct drm_connector *connector, struct drm_pr
         return 0;
 }
 
+/*
+ * Some integrated ATI Radeon chipset implementations (e. g.
+ * Asus M2A-VM HDMI) may indicate the availability of a DDC,
+ * even when there's no monitor connected. For these connectors
+ * following DDC probe extension will be applied: check also for the
+ * availability of EDID with at least a correct EDID header. Only then,
+ * DDC is assumed to be available. This prevents drm_get_edid() and
+ * drm_edid_block_valid() from periodically dumping data and kernel
+ * errors into the logs and onto the terminal.
+ */
+static bool radeon_connector_needs_extended_probe(struct radeon_device *dev,
+                                     uint32_t supported_device,
+                                     int connector_type)
+{
+        /* Asus M2A-VM HDMI board sends data to i2c bus even,
+         * if HDMI add-on card is not plugged in or HDMI is disabled in
+         * BIOS. Valid DDC can only be assumed, if also a valid EDID header
+         * can be retrieved via i2c bus during DDC probe */
+        if ((dev->pdev->device == 0x791e) &&
+            (dev->pdev->subsystem_vendor == 0x1043) &&
+            (dev->pdev->subsystem_device == 0x826d)) {
+                if ((connector_type == DRM_MODE_CONNECTOR_HDMIA) &&
+                    (supported_device == ATOM_DEVICE_DFP2_SUPPORT))
+                        return true;
+        }
+        /* ECS A740GM-M with ATI RADEON 2100 sends data to i2c bus
+         * for a DVI connector that is not implemented */
+        if ((dev->pdev->device == 0x796e) &&
+            (dev->pdev->subsystem_vendor == 0x1019) &&
+            (dev->pdev->subsystem_device == 0x2615)) {
+                if ((connector_type == DRM_MODE_CONNECTOR_DVID) &&
+                    (supported_device == ATOM_DEVICE_DFP2_SUPPORT))
+                        return true;
+        }
+        /* TOSHIBA Satellite L300D with ATI Mobility Radeon x1100
+         * (RS690M) sends data to i2c bus for a HDMI connector that
+         * is not implemented */
+        if ((dev->pdev->device == 0x791f) &&
+            (dev->pdev->subsystem_vendor == 0x1179) &&
+            (dev->pdev->subsystem_device == 0xff68)) {
+                if ((connector_type == DRM_MODE_CONNECTOR_HDMIA) &&
+                    (supported_device == ATOM_DEVICE_DFP2_SUPPORT))
+                        return true;
+        }
+
+        /* Default: no EDID header probe required for DDC probing */
+        return false;
+}
+
 static void radeon_fixup_lvds_native_mode(struct drm_encoder *encoder,
                                           struct drm_connector *connector)
 {
         struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
         struct drm_display_mode *native_mode = &radeon_encoder->native_mode;
+        struct drm_display_mode *t, *mode;
+
+        /* If the EDID preferred mode doesn't match the native mode, use it */
+        list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
+                if (mode->type & DRM_MODE_TYPE_PREFERRED) {
+                        if (mode->hdisplay != native_mode->hdisplay ||
+                            mode->vdisplay != native_mode->vdisplay)
+                                memcpy(native_mode, mode, sizeof(*mode));
+                }
+        }
 
         /* Try to get native mode details from EDID if necessary */
         if (!native_mode->clock) {
-                struct drm_display_mode *t, *mode;
-
                 list_for_each_entry_safe(mode, t, &connector->probed_modes, head) {
                         if (mode->hdisplay == native_mode->hdisplay &&
                             mode->vdisplay == native_mode->vdisplay) {
@@ -450,6 +509,7 @@ static void radeon_fixup_lvds_native_mode(struct drm_encoder *encoder,
                         }
                 }
         }
+
         if (!native_mode->clock) {
                 DRM_DEBUG_KMS("No LVDS native mode details, disabling RMX\n");
                 radeon_encoder->rmx_type = RMX_OFF;
@@ -661,7 +721,8 @@ radeon_vga_detect(struct drm_connector *connector, bool force)
                 ret = connector_status_disconnected;
 
         if (radeon_connector->ddc_bus)
-                dret = radeon_ddc_probe(radeon_connector);
+                dret = radeon_ddc_probe(radeon_connector,
+                                        radeon_connector->requires_extended_probe);
         if (dret) {
                 if (radeon_connector->edid) {
                         kfree(radeon_connector->edid);
@@ -833,7 +894,8 @@ radeon_dvi_detect(struct drm_connector *connector, bool force)
         bool dret = false;
 
         if (radeon_connector->ddc_bus)
-                dret = radeon_ddc_probe(radeon_connector);
+                dret = radeon_ddc_probe(radeon_connector,
+                                        radeon_connector->requires_extended_probe);
         if (dret) {
                 if (radeon_connector->edid) {
                         kfree(radeon_connector->edid);
@@ -1235,12 +1297,33 @@ radeon_dp_detect(struct drm_connector *connector, bool force)
                 if (!radeon_dig_connector->edp_on)
                         atombios_set_edp_panel_power(connector,
                                                      ATOM_TRANSMITTER_ACTION_POWER_OFF);
-        } else {
-                /* need to setup ddc on the bridge */
-                if (radeon_connector_encoder_is_dp_bridge(connector)) {
+        } else if (radeon_connector_encoder_is_dp_bridge(connector)) {
+                /* DP bridges are always DP */
+                radeon_dig_connector->dp_sink_type = CONNECTOR_OBJECT_ID_DISPLAYPORT;
+                /* get the DPCD from the bridge */
+                radeon_dp_getdpcd(radeon_connector);
+
+                if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd))
+                        ret = connector_status_connected;
+                else {
+                        /* need to setup ddc on the bridge */
                         if (encoder)
                                 radeon_atom_ext_encoder_setup_ddc(encoder);
+                        if (radeon_ddc_probe(radeon_connector,
+                                             radeon_connector->requires_extended_probe))
+                                ret = connector_status_connected;
+                }
+
+                if ((ret == connector_status_disconnected) &&
+                    radeon_connector->dac_load_detect) {
+                        struct drm_encoder *encoder = radeon_best_single_encoder(connector);
+                        struct drm_encoder_helper_funcs *encoder_funcs;
+                        if (encoder) {
+                                encoder_funcs = encoder->helper_private;
+                                ret = encoder_funcs->detect(encoder, connector);
+                        }
                 }
+        } else {
                 radeon_dig_connector->dp_sink_type = radeon_dp_getsinktype(radeon_connector);
                 if (radeon_hpd_sense(rdev, radeon_connector->hpd.hpd)) {
                         ret = connector_status_connected;
@@ -1251,20 +1334,11 @@ radeon_dp_detect(struct drm_connector *connector, bool force)
                                 if (radeon_dp_getdpcd(radeon_connector))
                                         ret = connector_status_connected;
                         } else {
-                                if (radeon_ddc_probe(radeon_connector))
+                                if (radeon_ddc_probe(radeon_connector,
+                                                     radeon_connector->requires_extended_probe))
                                         ret = connector_status_connected;
                         }
                 }
-
-                if ((ret == connector_status_disconnected) &&
-                    radeon_connector->dac_load_detect) {
-                        struct drm_encoder *encoder = radeon_best_single_encoder(connector);
-                        struct drm_encoder_helper_funcs *encoder_funcs;
-                        if (encoder) {
-                                encoder_funcs = encoder->helper_private;
-                                ret = encoder_funcs->detect(encoder, connector);
-                        }
-                }
         }
 
         radeon_connector_update_scratch_regs(connector, ret);
@@ -1406,6 +1480,9 @@ radeon_add_atom_connector(struct drm_device *dev,
         radeon_connector->shared_ddc = shared_ddc;
         radeon_connector->connector_object_id = connector_object_id;
         radeon_connector->hpd = *hpd;
+        radeon_connector->requires_extended_probe =
+                radeon_connector_needs_extended_probe(rdev, supported_device,
+                                                        connector_type);
         radeon_connector->router = *router;
         if (router->ddc_valid || router->cd_valid) {
                 radeon_connector->router_bus = radeon_i2c_lookup(rdev, &router->i2c_info);
@@ -1752,6 +1829,9 @@ radeon_add_legacy_connector(struct drm_device *dev,
         radeon_connector->devices = supported_device;
         radeon_connector->connector_object_id = connector_object_id;
         radeon_connector->hpd = *hpd;
+        radeon_connector->requires_extended_probe =
+                radeon_connector_needs_extended_probe(rdev, supported_device,
+                                                        connector_type);
         switch (connector_type) {
         case DRM_MODE_CONNECTOR_VGA:
                 drm_connector_init(dev, &radeon_connector->base, &radeon_vga_connector_funcs, connector_type);
diff --git a/drivers/gpu/drm/radeon/radeon_device.c b/drivers/gpu/drm/radeon/radeon_device.c
index 7cfaa7e2f3b5..b51e15725c6e 100644
--- a/drivers/gpu/drm/radeon/radeon_device.c
+++ b/drivers/gpu/drm/radeon/radeon_device.c
@@ -32,6 +32,7 @@
 #include <drm/radeon_drm.h>
 #include <linux/vgaarb.h>
 #include <linux/vga_switcheroo.h>
+#include <linux/efi.h>
 #include "radeon_reg.h"
 #include "radeon.h"
 #include "atom.h"
@@ -300,6 +301,8 @@ void radeon_vram_location(struct radeon_device *rdev, struct radeon_mc *mc, u64
                 mc->mc_vram_size = mc->aper_size;
         }
         mc->vram_end = mc->vram_start + mc->mc_vram_size - 1;
+        if (radeon_vram_limit && radeon_vram_limit < mc->real_vram_size)
+                mc->real_vram_size = radeon_vram_limit;
         dev_info(rdev->dev, "VRAM: %lluM 0x%016llX - 0x%016llX (%lluM used)\n",
                         mc->mc_vram_size >> 20, mc->vram_start,
                         mc->vram_end, mc->real_vram_size >> 20);
@@ -348,6 +351,9 @@ bool radeon_card_posted(struct radeon_device *rdev)
 {
         uint32_t reg;
 
+        if (efi_enabled && rdev->pdev->subsystem_vendor == PCI_VENDOR_ID_APPLE)
+                return false;
+
         /* first check CRTCs */
         if (ASIC_IS_DCE41(rdev)) {
                 reg = RREG32(EVERGREEN_CRTC_CONTROL + EVERGREEN_CRTC0_REGISTER_OFFSET) |
@@ -704,8 +710,9 @@ int radeon_device_init(struct radeon_device *rdev,
         rdev->gpu_lockup = false;
         rdev->accel_working = false;
 
-        DRM_INFO("initializing kernel modesetting (%s 0x%04X:0x%04X).\n",
-                radeon_family_name[rdev->family], pdev->vendor, pdev->device);
+        DRM_INFO("initializing kernel modesetting (%s 0x%04X:0x%04X 0x%04X:0x%04X).\n",
+                radeon_family_name[rdev->family], pdev->vendor, pdev->device,
+                pdev->subsystem_vendor, pdev->subsystem_device);
 
         /* mutex initialization are all done here so we
          * can recall function without having locking issues */
diff --git a/drivers/gpu/drm/radeon/radeon_display.c b/drivers/gpu/drm/radeon/radeon_display.c
index 28f4655905bc..6cc17fb96a57 100644
--- a/drivers/gpu/drm/radeon/radeon_display.c
+++ b/drivers/gpu/drm/radeon/radeon_display.c
@@ -707,16 +707,21 @@ int radeon_ddc_get_modes(struct radeon_connector *radeon_connector)
                 radeon_router_select_ddc_port(radeon_connector);
 
         if ((radeon_connector->base.connector_type == DRM_MODE_CONNECTOR_DisplayPort) ||
-            (radeon_connector->base.connector_type == DRM_MODE_CONNECTOR_eDP)) {
+            (radeon_connector->base.connector_type == DRM_MODE_CONNECTOR_eDP) ||
+            radeon_connector_encoder_is_dp_bridge(&radeon_connector->base)) {
                 struct radeon_connector_atom_dig *dig = radeon_connector->con_priv;
+
                 if ((dig->dp_sink_type == CONNECTOR_OBJECT_ID_DISPLAYPORT ||
                      dig->dp_sink_type == CONNECTOR_OBJECT_ID_eDP) && dig->dp_i2c_bus)
-                        radeon_connector->edid = drm_get_edid(&radeon_connector->base, &dig->dp_i2c_bus->adapter);
-        }
-        if (!radeon_connector->ddc_bus)
-                return -1;
-        if (!radeon_connector->edid) {
-                radeon_connector->edid = drm_get_edid(&radeon_connector->base, &radeon_connector->ddc_bus->adapter);
+                        radeon_connector->edid = drm_get_edid(&radeon_connector->base,
+                                                              &dig->dp_i2c_bus->adapter);
+                else if (radeon_connector->ddc_bus && !radeon_connector->edid)
+                        radeon_connector->edid = drm_get_edid(&radeon_connector->base,
+                                                              &radeon_connector->ddc_bus->adapter);
+        } else {
+                if (radeon_connector->ddc_bus && !radeon_connector->edid)
+                        radeon_connector->edid = drm_get_edid(&radeon_connector->base,
+                                                              &radeon_connector->ddc_bus->adapter);
         }
 
         if (!radeon_connector->edid) {
@@ -751,8 +756,17 @@ static int radeon_ddc_dump(struct drm_connector *connector)
         if (!radeon_connector->ddc_bus)
                 return -1;
         edid = drm_get_edid(connector, &radeon_connector->ddc_bus->adapter);
+        /* Log EDID retrieval status here. In particular with regard to
+         * connectors with requires_extended_probe flag set, that will prevent
+         * function radeon_dvi_detect() to fetch EDID on this connector,
+         * as long as there is no valid EDID header found */
         if (edid) {
+                DRM_INFO("Radeon display connector %s: Found valid EDID",
+                                drm_get_connector_name(connector));
                 kfree(edid);
+        } else {
+                DRM_INFO("Radeon display connector %s: No monitor connected or invalid EDID",
+                                drm_get_connector_name(connector));
         }
         return ret;
 }
diff --git a/drivers/gpu/drm/radeon/radeon_drv.c b/drivers/gpu/drm/radeon/radeon_drv.c
index 85f033f19a8a..e71d2ed7fa11 100644
--- a/drivers/gpu/drm/radeon/radeon_drv.c
+++ b/drivers/gpu/drm/radeon/radeon_drv.c
@@ -50,8 +50,8 @@
  *   2.7.0 - fixups for r600 2D tiling support. (no external ABI change), add eg dyn gpr regs
  *   2.8.0 - pageflip support, r500 US_FORMAT regs. r500 ARGB2101010 colorbuf, r300->r500 CMASK, clock crystal query
  *   2.9.0 - r600 tiling (s3tc,rgtc) working, SET_PREDICATION packet 3 on r600 + eg, backend query
- *   2.10.0 - fusion 2D tiling, initial compute support for the CS checker
- *   2.11.0 - backend map
+ *   2.10.0 - fusion 2D tiling
+ *   2.11.0 - backend map, initial compute support for the CS checker
  */
 #define KMS_DRIVER_MAJOR        2
 #define KMS_DRIVER_MINOR        11
diff --git a/drivers/gpu/drm/radeon/radeon_encoders.c b/drivers/gpu/drm/radeon/radeon_encoders.c
index b293487e5aa3..319d85d7e759 100644
--- a/drivers/gpu/drm/radeon/radeon_encoders.c
+++ b/drivers/gpu/drm/radeon/radeon_encoders.c
@@ -2323,6 +2323,9 @@ radeon_add_atom_encoder(struct drm_device *dev,
         default:
                 encoder->possible_crtcs = 0x3;
                 break;
+        case 4:
+                encoder->possible_crtcs = 0xf;
+                break;
         case 6:
                 encoder->possible_crtcs = 0x3f;
                 break;
diff --git a/drivers/gpu/drm/radeon/radeon_i2c.c b/drivers/gpu/drm/radeon/radeon_i2c.c
index 781196db792f..6c111c1fa3f9 100644
--- a/drivers/gpu/drm/radeon/radeon_i2c.c
+++ b/drivers/gpu/drm/radeon/radeon_i2c.c
@@ -32,17 +32,17 @@
  * radeon_ddc_probe
  *
  */
-bool radeon_ddc_probe(struct radeon_connector *radeon_connector)
+bool radeon_ddc_probe(struct radeon_connector *radeon_connector, bool requires_extended_probe)
 {
-        u8 out_buf[] = { 0x0, 0x0};
-        u8 buf[2];
+        u8 out = 0x0;
+        u8 buf[8];
         int ret;
         struct i2c_msg msgs[] = {
                 {
                         .addr = 0x50,
                         .flags = 0,
                         .len = 1,
-                        .buf = out_buf,
+                        .buf = &out,
                 },
                 {
                         .addr = 0x50,
@@ -52,15 +52,31 @@ bool radeon_ddc_probe(struct radeon_connector *radeon_connector)
                 }
         };
 
+        /* Read 8 bytes from i2c for extended probe of EDID header */
+        if (requires_extended_probe)
+                msgs[1].len = 8;
+
         /* on hw with routers, select right port */
         if (radeon_connector->router.ddc_valid)
                 radeon_router_select_ddc_port(radeon_connector);
 
         ret = i2c_transfer(&radeon_connector->ddc_bus->adapter, msgs, 2);
-        if (ret == 2)
-                return true;
-
-        return false;
+        if (ret != 2)
+                /* Couldn't find an accessible DDC on this connector */
+                return false;
+        if (requires_extended_probe) {
+                /* Probe also for valid EDID header
+                 * EDID header starts with:
+                 * 0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x00.
+                 * Only the first 6 bytes must be valid as
+                 * drm_edid_block_valid() can fix the last 2 bytes */
+                if (drm_edid_header_is_valid(buf) < 6) {
+                        /* Couldn't find an accessible EDID on this
+                         * connector */
+                        return false;
+                }
+        }
+        return true;
 }
 
 /* bit banging i2c */
diff --git a/drivers/gpu/drm/radeon/radeon_mode.h b/drivers/gpu/drm/radeon/radeon_mode.h
index 6df4e3cec0c2..68820f5f6303 100644
--- a/drivers/gpu/drm/radeon/radeon_mode.h
+++ b/drivers/gpu/drm/radeon/radeon_mode.h
@@ -438,6 +438,9 @@ struct radeon_connector {
         struct radeon_i2c_chan *ddc_bus;
         /* some systems have an hdmi and vga port with a shared ddc line */
         bool shared_ddc;
+        /* for some Radeon chip families we apply an additional EDID header
+           check as part of the DDC probe */
+        bool requires_extended_probe;
         bool use_digital;
         /* we need to mind the EDID between detect
            and get modes due to analog/digital/tvencoder */
@@ -476,6 +479,7 @@ extern void radeon_dp_set_link_config(struct drm_connector *connector,
                                       struct drm_display_mode *mode);
 extern void radeon_dp_link_train(struct drm_encoder *encoder,
                                  struct drm_connector *connector);
+extern bool radeon_dp_needs_link_train(struct radeon_connector *radeon_connector);
 extern u8 radeon_dp_getsinktype(struct radeon_connector *radeon_connector);
 extern bool radeon_dp_getdpcd(struct radeon_connector *radeon_connector);
 extern void atombios_dig_encoder_setup(struct drm_encoder *encoder, int action, int panel_mode);
@@ -514,7 +518,8 @@ extern void radeon_i2c_put_byte(struct radeon_i2c_chan *i2c,
                                 u8 val);
 extern void radeon_router_select_ddc_port(struct radeon_connector *radeon_connector);
 extern void radeon_router_select_cd_port(struct radeon_connector *radeon_connector);
-extern bool radeon_ddc_probe(struct radeon_connector *radeon_connector);
+extern bool radeon_ddc_probe(struct radeon_connector *radeon_connector,
+                        bool requires_extended_probe);
 extern int radeon_ddc_get_modes(struct radeon_connector *radeon_connector);
 
 extern struct drm_encoder *radeon_best_encoder(struct drm_connector *connector);
diff --git a/drivers/gpu/drm/radeon/radeon_test.c b/drivers/gpu/drm/radeon/radeon_test.c
index dee4a0c1b4b2..602fa3541c45 100644
--- a/drivers/gpu/drm/radeon/radeon_test.c
+++ b/drivers/gpu/drm/radeon/radeon_test.c
@@ -40,10 +40,14 @@ void radeon_test_moves(struct radeon_device *rdev)
         size = 1024 * 1024;
 
         /* Number of tests =
-         * (Total GTT - IB pool - writeback page - ring buffer) / test size
+         * (Total GTT - IB pool - writeback page - ring buffers) / test size
          */
-        n = ((u32)(rdev->mc.gtt_size - RADEON_IB_POOL_SIZE*64*1024 - RADEON_GPU_PAGE_SIZE -
-             rdev->cp.ring_size)) / size;
+        n = rdev->mc.gtt_size - RADEON_IB_POOL_SIZE*64*1024 - rdev->cp.ring_size;
+        if (rdev->wb.wb_obj)
+                n -= RADEON_GPU_PAGE_SIZE;
+        if (rdev->ih.ring_obj)
+                n -= rdev->ih.ring_size;
+        n /= size;
 
         gtt_obj = kzalloc(n * sizeof(*gtt_obj), GFP_KERNEL);
         if (!gtt_obj) {
@@ -132,9 +136,15 @@ void radeon_test_moves(struct radeon_device *rdev)
                      gtt_start++, vram_start++) {
                         if (*vram_start != gtt_start) {
                                 DRM_ERROR("Incorrect GTT->VRAM copy %d: Got 0x%p, "
-                                          "expected 0x%p (GTT map 0x%p-0x%p)\n",
-                                          i, *vram_start, gtt_start, gtt_map,
-                                          gtt_end);
+                                          "expected 0x%p (GTT/VRAM offset "
+                                          "0x%16llx/0x%16llx)\n",
+                                          i, *vram_start, gtt_start,
+                                          (unsigned long long)
+                                          (gtt_addr - rdev->mc.gtt_start +
+                                           (void*)gtt_start - gtt_map),
+                                          (unsigned long long)
+                                          (vram_addr - rdev->mc.vram_start +
+                                           (void*)gtt_start - gtt_map));
                                 radeon_bo_kunmap(vram_obj);
                                 goto out_cleanup;
                         }
@@ -175,9 +185,15 @@ void radeon_test_moves(struct radeon_device *rdev)
                      gtt_start++, vram_start++) {
                         if (*gtt_start != vram_start) {
                                 DRM_ERROR("Incorrect VRAM->GTT copy %d: Got 0x%p, "
-                                          "expected 0x%p (VRAM map 0x%p-0x%p)\n",
-                                          i, *gtt_start, vram_start, vram_map,
-                                          vram_end);
+                                          "expected 0x%p (VRAM/GTT offset "
+                                          "0x%16llx/0x%16llx)\n",
+                                          i, *gtt_start, vram_start,
+                                          (unsigned long long)
+                                          (vram_addr - rdev->mc.vram_start +
+                                           (void*)vram_start - vram_map),
+                                          (unsigned long long)
+                                          (gtt_addr - rdev->mc.gtt_start +
+                                           (void*)vram_start - vram_map));
                                 radeon_bo_kunmap(gtt_obj[i]);
                                 goto out_cleanup;
                         }
diff --git a/drivers/gpu/drm/radeon/radeon_ttm.c b/drivers/gpu/drm/radeon/radeon_ttm.c
index 60125ddba1e9..9b86fb0e4122 100644
--- a/drivers/gpu/drm/radeon/radeon_ttm.c
+++ b/drivers/gpu/drm/radeon/radeon_ttm.c
@@ -450,6 +450,29 @@ static int radeon_ttm_io_mem_reserve(struct ttm_bo_device *bdev, struct ttm_mem_
                         return -EINVAL;
                 mem->bus.base = rdev->mc.aper_base;
                 mem->bus.is_iomem = true;
+#ifdef __alpha__
+                /*
+                 * Alpha: use bus.addr to hold the ioremap() return,
+                 * so we can modify bus.base below.
+                 */
+                if (mem->placement & TTM_PL_FLAG_WC)
+                        mem->bus.addr =
+                                ioremap_wc(mem->bus.base + mem->bus.offset,
+                                           mem->bus.size);
+                else
+                        mem->bus.addr =
+                                ioremap_nocache(mem->bus.base + mem->bus.offset,
+                                                mem->bus.size);
+
+                /*
+                 * Alpha: Use just the bus offset plus
+                 * the hose/domain memory base for bus.base.
+                 * It then can be used to build PTEs for VRAM
+                 * access, as done in ttm_bo_vm_fault().
+                 */
+                mem->bus.base = (mem->bus.base & 0x0ffffffffUL) +
+                        rdev->ddev->hose->dense_mem_base;
+#endif
                 break;
         default:
                 return -EINVAL;
diff --git a/drivers/gpu/drm/ttm/ttm_bo.c b/drivers/gpu/drm/ttm/ttm_bo.c
index 56619f64b6bf..a4d38d85909a 100644
--- a/drivers/gpu/drm/ttm/ttm_bo.c
+++ b/drivers/gpu/drm/ttm/ttm_bo.c
@@ -353,8 +353,10 @@ static int ttm_bo_add_ttm(struct ttm_buffer_object *bo, bool zero_alloc)
 
                 ret = ttm_tt_set_user(bo->ttm, current,
                                       bo->buffer_start, bo->num_pages);
-                if (unlikely(ret != 0))
+                if (unlikely(ret != 0)) {
                         ttm_tt_destroy(bo->ttm);
+                        bo->ttm = NULL;
+                }
                 break;
         default:
                 printk(KERN_ERR TTM_PFX "Illegal buffer object type\n");
@@ -390,10 +392,12 @@ static int ttm_bo_handle_move_mem(struct ttm_buffer_object *bo,
          * Create and bind a ttm if required.
          */
 
-        if (!(new_man->flags & TTM_MEMTYPE_FLAG_FIXED) && (bo->ttm == NULL)) {
-                ret = ttm_bo_add_ttm(bo, false);
-                if (ret)
-                        goto out_err;
+        if (!(new_man->flags & TTM_MEMTYPE_FLAG_FIXED)) {
+                if (bo->ttm == NULL) {
+                        ret = ttm_bo_add_ttm(bo, false);
+                        if (ret)
+                                goto out_err;
+                }
 
                 ret = ttm_tt_set_placement_caching(bo->ttm, mem->placement);
                 if (ret)
diff --git a/drivers/gpu/drm/ttm/ttm_bo_util.c b/drivers/gpu/drm/ttm/ttm_bo_util.c
index 77dbf408c0d0..ae3c6f5dd2b7 100644
--- a/drivers/gpu/drm/ttm/ttm_bo_util.c
+++ b/drivers/gpu/drm/ttm/ttm_bo_util.c
@@ -635,13 +635,13 @@ int ttm_bo_move_accel_cleanup(struct ttm_buffer_object *bo,
                 if (ret)
                         return ret;
 
-                ttm_bo_free_old_node(bo);
                 if ((man->flags & TTM_MEMTYPE_FLAG_FIXED) &&
                     (bo->ttm != NULL)) {
                         ttm_tt_unbind(bo->ttm);
                         ttm_tt_destroy(bo->ttm);
                         bo->ttm = NULL;
                 }
+                ttm_bo_free_old_node(bo);
         } else {
                 /**
                  * This should help pipeline ordinary buffer moves.
diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig
index 306b15f39c9c..1130a8987125 100644
--- a/drivers/hid/Kconfig
+++ b/drivers/hid/Kconfig
@@ -589,6 +589,7 @@ config HID_WACOM_POWER_SUPPLY
 config HID_WIIMOTE
         tristate "Nintendo Wii Remote support"
         depends on BT_HIDP
+        depends on LEDS_CLASS
         ---help---
         Support for the Nintendo Wii Remote bluetooth device.
 
diff --git a/drivers/hid/hid-apple.c b/drivers/hid/hid-apple.c
index b85744fe8464..18b3bc646bf3 100644
--- a/drivers/hid/hid-apple.c
+++ b/drivers/hid/hid-apple.c
@@ -444,6 +444,12 @@ static const struct hid_device_id apple_devices[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS),
                 .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
                         APPLE_RDESC_JIS },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_ANSI),
+                .driver_data = APPLE_HAS_FN },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_ISO),
+                .driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_JIS),
+                .driver_data = APPLE_HAS_FN },
         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI),
                 .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO),
diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
index 1a5cf0c9cfca..242353df3dc4 100644
--- a/drivers/hid/hid-core.c
+++ b/drivers/hid/hid-core.c
@@ -1340,6 +1340,9 @@ static const struct hid_device_id hid_have_special_driver[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ANSI) },
         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ISO) },
         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_JIS) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_ANSI) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_ISO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_JIS) },
         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI) },
         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO) },
         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_JIS) },
diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h
index db63ccf21cc8..7484e1b67249 100644
--- a/drivers/hid/hid-ids.h
+++ b/drivers/hid/hid-ids.h
@@ -109,6 +109,9 @@
 #define USB_DEVICE_ID_APPLE_WELLSPRING5_ANSI    0x0245
 #define USB_DEVICE_ID_APPLE_WELLSPRING5_ISO     0x0246
 #define USB_DEVICE_ID_APPLE_WELLSPRING5_JIS     0x0247
+#define USB_DEVICE_ID_APPLE_ALU_REVB_ANSI       0x024f
+#define USB_DEVICE_ID_APPLE_ALU_REVB_ISO        0x0250
+#define USB_DEVICE_ID_APPLE_ALU_REVB_JIS        0x0251
 #define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI  0x0239
 #define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO   0x023a
 #define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_JIS   0x023b
@@ -274,6 +277,7 @@
 #define USB_DEVICE_ID_PENPOWER          0x00f4
 
 #define USB_VENDOR_ID_GREENASIA         0x0e8f
+#define USB_DEVICE_ID_GREENASIA_DUAL_USB_JOYPAD 0x3013
 
 #define USB_VENDOR_ID_GRETAGMACBETH     0x0971
 #define USB_DEVICE_ID_GRETAGMACBETH_HUEY        0x2005
@@ -576,6 +580,9 @@
 #define USB_DEVICE_ID_SAMSUNG_IR_REMOTE 0x0001
 #define USB_DEVICE_ID_SAMSUNG_WIRELESS_KBD_MOUSE        0x0600
 
+#define USB_VENDOR_ID_SIGMA_MICRO       0x1c4f
+#define USB_DEVICE_ID_SIGMA_MICRO_KEYBOARD      0x0002
+
 #define USB_VENDOR_ID_SKYCABLE                  0x1223
 #define USB_DEVICE_ID_SKYCABLE_WIRELESS_PRESENTER       0x3F07
 
diff --git a/drivers/hid/hid-magicmouse.c b/drivers/hid/hid-magicmouse.c
index 0ec91c18a421..f0fbd7bd239e 100644
--- a/drivers/hid/hid-magicmouse.c
+++ b/drivers/hid/hid-magicmouse.c
@@ -81,6 +81,28 @@ MODULE_PARM_DESC(report_undeciphered, "Report undeciphered multi-touch state fie
 #define NO_TOUCHES -1
 #define SINGLE_TOUCH_UP -2
 
+/* Touch surface information. Dimension is in hundredths of a mm, min and max
+ * are in units. */
+#define MOUSE_DIMENSION_X (float)9056
+#define MOUSE_MIN_X -1100
+#define MOUSE_MAX_X 1258
+#define MOUSE_RES_X ((MOUSE_MAX_X - MOUSE_MIN_X) / (MOUSE_DIMENSION_X / 100))
+#define MOUSE_DIMENSION_Y (float)5152
+#define MOUSE_MIN_Y -1589
+#define MOUSE_MAX_Y 2047
+#define MOUSE_RES_Y ((MOUSE_MAX_Y - MOUSE_MIN_Y) / (MOUSE_DIMENSION_Y / 100))
+
+#define TRACKPAD_DIMENSION_X (float)13000
+#define TRACKPAD_MIN_X -2909
+#define TRACKPAD_MAX_X 3167
+#define TRACKPAD_RES_X \
+        ((TRACKPAD_MAX_X - TRACKPAD_MIN_X) / (TRACKPAD_DIMENSION_X / 100))
+#define TRACKPAD_DIMENSION_Y (float)11000
+#define TRACKPAD_MIN_Y -2456
+#define TRACKPAD_MAX_Y 2565
+#define TRACKPAD_RES_Y \
+        ((TRACKPAD_MAX_Y - TRACKPAD_MIN_Y) / (TRACKPAD_DIMENSION_Y / 100))
+
 /**
  * struct magicmouse_sc - Tracks Magic Mouse-specific data.
  * @input: Input device through which we report events.
@@ -406,17 +428,31 @@ static void magicmouse_setup_input(struct input_dev *input, struct hid_device *h
                  * inverse of the reported Y.
                  */
                 if (input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE) {
-                        input_set_abs_params(input, ABS_MT_POSITION_X, -1100,
-                                1358, 4, 0);
-                        input_set_abs_params(input, ABS_MT_POSITION_Y, -1589,
-                                2047, 4, 0);
+                        input_set_abs_params(input, ABS_MT_POSITION_X,
+                                MOUSE_MIN_X, MOUSE_MAX_X, 4, 0);
+                        input_set_abs_params(input, ABS_MT_POSITION_Y,
+                                MOUSE_MIN_Y, MOUSE_MAX_Y, 4, 0);
+
+                        input_abs_set_res(input, ABS_MT_POSITION_X,
+                                MOUSE_RES_X);
+                        input_abs_set_res(input, ABS_MT_POSITION_Y,
+                                MOUSE_RES_Y);
                 } else { /* USB_DEVICE_ID_APPLE_MAGICTRACKPAD */
-                        input_set_abs_params(input, ABS_X, -2909, 3167, 4, 0);
-                        input_set_abs_params(input, ABS_Y, -2456, 2565, 4, 0);
-                        input_set_abs_params(input, ABS_MT_POSITION_X, -2909,
-                                3167, 4, 0);
-                        input_set_abs_params(input, ABS_MT_POSITION_Y, -2456,
-                                2565, 4, 0);
+                        input_set_abs_params(input, ABS_X, TRACKPAD_MIN_X,
+                                TRACKPAD_MAX_X, 4, 0);
+                        input_set_abs_params(input, ABS_Y, TRACKPAD_MIN_Y,
+                                TRACKPAD_MAX_Y, 4, 0);
+                        input_set_abs_params(input, ABS_MT_POSITION_X,
+                                TRACKPAD_MIN_X, TRACKPAD_MAX_X, 4, 0);
+                        input_set_abs_params(input, ABS_MT_POSITION_Y,
+                                TRACKPAD_MIN_Y, TRACKPAD_MAX_Y, 4, 0);
+
+                        input_abs_set_res(input, ABS_X, TRACKPAD_RES_X);
+                        input_abs_set_res(input, ABS_Y, TRACKPAD_RES_Y);
+                        input_abs_set_res(input, ABS_MT_POSITION_X,
+                                TRACKPAD_RES_X);
+                        input_abs_set_res(input, ABS_MT_POSITION_Y,
+                                TRACKPAD_RES_Y);
                 }
 
                 input_set_events_per_packet(input, 60);
@@ -501,9 +537,17 @@ static int magicmouse_probe(struct hid_device *hdev,
         }
         report->size = 6;
 
+        /*
+         * Some devices repond with 'invalid report id' when feature
+         * report switching it into multitouch mode is sent to it.
+         *
+         * This results in -EIO from the _raw low-level transport callback,
+         * but there seems to be no other way of switching the mode.
+         * Thus the super-ugly hacky success check below.
+         */
         ret = hdev->hid_output_raw_report(hdev, feature, sizeof(feature),
                         HID_FEATURE_REPORT);
-        if (ret != sizeof(feature)) {
+        if (ret != -EIO && ret != sizeof(feature)) {
                 hid_err(hdev, "unable to request touch data (%d)\n", ret);
                 goto err_stop_hw;
         }
diff --git a/drivers/hid/hid-wacom.c b/drivers/hid/hid-wacom.c
index 06888323828c..a597039d0755 100644
--- a/drivers/hid/hid-wacom.c
+++ b/drivers/hid/hid-wacom.c
@@ -353,11 +353,7 @@ static int wacom_probe(struct hid_device *hdev,
         if (ret) {
                 hid_warn(hdev, "can't create sysfs battery attribute, err: %d\n",
                          ret);
-                /*
-                 * battery attribute is not critical for the tablet, but if it
-                 * failed then there is no need to create ac attribute
-                 */
-                goto move_on;
+                goto err_battery;
         }
 
         wdata->ac.properties = wacom_ac_props;
@@ -371,14 +367,8 @@ static int wacom_probe(struct hid_device *hdev,
         if (ret) {
                 hid_warn(hdev,
                          "can't create ac battery attribute, err: %d\n", ret);
-                /*
-                 * ac attribute is not critical for the tablet, but if it
-                 * failed then we don't want to battery attribute to exist
-                 */
-                power_supply_unregister(&wdata->battery);
+                goto err_ac;
         }
-
-move_on:
 #endif
         hidinput = list_entry(hdev->inputs.next, struct hid_input, list);
         input = hidinput->input;
@@ -416,6 +406,13 @@ move_on:
 
         return 0;
 
+#ifdef CONFIG_HID_WACOM_POWER_SUPPLY
+err_ac:
+        power_supply_unregister(&wdata->battery);
+err_battery:
+        device_remove_file(&hdev->dev, &dev_attr_speed);
+        hid_hw_stop(hdev);
+#endif
 err_free:
         kfree(wdata);
         return ret;
@@ -426,6 +423,7 @@ static void wacom_remove(struct hid_device *hdev)
 #ifdef CONFIG_HID_WACOM_POWER_SUPPLY
         struct wacom_data *wdata = hid_get_drvdata(hdev);
 #endif
+        device_remove_file(&hdev->dev, &dev_attr_speed);
         hid_hw_stop(hdev);
 
 #ifdef CONFIG_HID_WACOM_POWER_SUPPLY
diff --git a/drivers/hid/hid-wiimote.c b/drivers/hid/hid-wiimote.c
index a594383ce03d..85a02e5f9fe8 100644
--- a/drivers/hid/hid-wiimote.c
+++ b/drivers/hid/hid-wiimote.c
@@ -10,10 +10,10 @@
  * any later version.
  */
 
-#include <linux/atomic.h>
 #include <linux/device.h>
 #include <linux/hid.h>
 #include <linux/input.h>
+#include <linux/leds.h>
 #include <linux/module.h>
 #include <linux/spinlock.h>
 #include "hid-ids.h"
@@ -33,9 +33,9 @@ struct wiimote_state {
 };
 
 struct wiimote_data {
-        atomic_t ready;
         struct hid_device *hdev;
         struct input_dev *input;
+        struct led_classdev *leds[4];
 
         spinlock_t qlock;
         __u8 head;
@@ -53,8 +53,15 @@ struct wiimote_data {
 #define WIIPROTO_FLAGS_LEDS (WIIPROTO_FLAG_LED1 | WIIPROTO_FLAG_LED2 | \
                                         WIIPROTO_FLAG_LED3 | WIIPROTO_FLAG_LED4)
 
+/* return flag for led \num */
+#define WIIPROTO_FLAG_LED(num) (WIIPROTO_FLAG_LED1 << (num - 1))
+
 enum wiiproto_reqs {
+        WIIPROTO_REQ_NULL = 0x0,
         WIIPROTO_REQ_LED = 0x11,
+        WIIPROTO_REQ_DRM = 0x12,
+        WIIPROTO_REQ_STATUS = 0x20,
+        WIIPROTO_REQ_RETURN = 0x22,
         WIIPROTO_REQ_DRM_K = 0x30,
 };
 
@@ -87,9 +94,6 @@ static __u16 wiiproto_keymap[] = {
         BTN_MODE,       /* WIIPROTO_KEY_HOME */
 };
 
-#define dev_to_wii(pdev) hid_get_drvdata(container_of(pdev, struct hid_device, \
-                                                                        dev))
-
 static ssize_t wiimote_hid_send(struct hid_device *hdev, __u8 *buffer,
                                                                 size_t count)
 {
@@ -192,66 +196,96 @@ static void wiiproto_req_leds(struct wiimote_data *wdata, int leds)
         wiimote_queue(wdata, cmd, sizeof(cmd));
 }
 
-#define wiifs_led_show_set(num)                                         \
-static ssize_t wiifs_led_show_##num(struct device *dev,                 \
-                        struct device_attribute *attr, char *buf)       \
-{                                                                       \
-        struct wiimote_data *wdata = dev_to_wii(dev);                   \
-        unsigned long flags;                                            \
-        int state;                                                      \
-                                                                        \
-        if (!atomic_read(&wdata->ready))                                \
-                return -EBUSY;                                          \
-                                                                        \
-        spin_lock_irqsave(&wdata->state.lock, flags);                   \
-        state = !!(wdata->state.flags & WIIPROTO_FLAG_LED##num);        \
-        spin_unlock_irqrestore(&wdata->state.lock, flags);              \
-                                                                        \
-        return sprintf(buf, "%d\n", state);                             \
-}                                                                       \
-static ssize_t wiifs_led_set_##num(struct device *dev,                  \
-        struct device_attribute *attr, const char *buf, size_t count)   \
-{                                                                       \
-        struct wiimote_data *wdata = dev_to_wii(dev);                   \
-        int tmp = simple_strtoul(buf, NULL, 10);                        \
-        unsigned long flags;                                            \
-        __u8 state;                                                     \
-                                                                        \
-        if (!atomic_read(&wdata->ready))                                \
-                return -EBUSY;                                          \
-                                                                        \
-        spin_lock_irqsave(&wdata->state.lock, flags);                   \
-                                                                        \
-        state = wdata->state.flags;                                     \
-                                                                        \
-        if (tmp)                                                        \
-                wiiproto_req_leds(wdata, state | WIIPROTO_FLAG_LED##num);\
-        else                                                            \
-                wiiproto_req_leds(wdata, state & ~WIIPROTO_FLAG_LED##num);\
-                                                                        \
-        spin_unlock_irqrestore(&wdata->state.lock, flags);              \
-                                                                        \
-        return count;                                                   \
-}                                                                       \
-static DEVICE_ATTR(led##num, S_IRUGO | S_IWUSR, wiifs_led_show_##num,   \
-                                                wiifs_led_set_##num)
-
-wiifs_led_show_set(1);
-wiifs_led_show_set(2);
-wiifs_led_show_set(3);
-wiifs_led_show_set(4);
+/*
+ * Check what peripherals of the wiimote are currently
+ * active and select a proper DRM that supports all of
+ * the requested data inputs.
+ */
+static __u8 select_drm(struct wiimote_data *wdata)
+{
+        return WIIPROTO_REQ_DRM_K;
+}
+
+static void wiiproto_req_drm(struct wiimote_data *wdata, __u8 drm)
+{
+        __u8 cmd[3];
+
+        if (drm == WIIPROTO_REQ_NULL)
+                drm = select_drm(wdata);
+
+        cmd[0] = WIIPROTO_REQ_DRM;
+        cmd[1] = 0;
+        cmd[2] = drm;
+
+        wiimote_queue(wdata, cmd, sizeof(cmd));
+}
+
+static enum led_brightness wiimote_leds_get(struct led_classdev *led_dev)
+{
+        struct wiimote_data *wdata;
+        struct device *dev = led_dev->dev->parent;
+        int i;
+        unsigned long flags;
+        bool value = false;
+
+        wdata = hid_get_drvdata(container_of(dev, struct hid_device, dev));
+
+        for (i = 0; i < 4; ++i) {
+                if (wdata->leds[i] == led_dev) {
+                        spin_lock_irqsave(&wdata->state.lock, flags);
+                        value = wdata->state.flags & WIIPROTO_FLAG_LED(i + 1);
+                        spin_unlock_irqrestore(&wdata->state.lock, flags);
+                        break;
+                }
+        }
+
+        return value ? LED_FULL : LED_OFF;
+}
+
+static void wiimote_leds_set(struct led_classdev *led_dev,
+                                                enum led_brightness value)
+{
+        struct wiimote_data *wdata;
+        struct device *dev = led_dev->dev->parent;
+        int i;
+        unsigned long flags;
+        __u8 state, flag;
+
+        wdata = hid_get_drvdata(container_of(dev, struct hid_device, dev));
+
+        for (i = 0; i < 4; ++i) {
+                if (wdata->leds[i] == led_dev) {
+                        flag = WIIPROTO_FLAG_LED(i + 1);
+                        spin_lock_irqsave(&wdata->state.lock, flags);
+                        state = wdata->state.flags;
+                        if (value == LED_OFF)
+                                wiiproto_req_leds(wdata, state & ~flag);
+                        else
+                                wiiproto_req_leds(wdata, state | flag);
+                        spin_unlock_irqrestore(&wdata->state.lock, flags);
+                        break;
+                }
+        }
+}
 
 static int wiimote_input_event(struct input_dev *dev, unsigned int type,
                                                 unsigned int code, int value)
 {
+        return 0;
+}
+
+static int wiimote_input_open(struct input_dev *dev)
+{
         struct wiimote_data *wdata = input_get_drvdata(dev);
 
-        if (!atomic_read(&wdata->ready))
-                return -EBUSY;
-        /* smp_rmb: Make sure wdata->xy is available when wdata->ready is 1 */
-        smp_rmb();
+        return hid_hw_open(wdata->hdev);
+}
 
-        return 0;
+static void wiimote_input_close(struct input_dev *dev)
+{
+        struct wiimote_data *wdata = input_get_drvdata(dev);
+
+        hid_hw_close(wdata->hdev);
 }
 
 static void handler_keys(struct wiimote_data *wdata, const __u8 *payload)
@@ -281,6 +315,26 @@ static void handler_keys(struct wiimote_data *wdata, const __u8 *payload)
         input_sync(wdata->input);
 }
 
+static void handler_status(struct wiimote_data *wdata, const __u8 *payload)
+{
+        handler_keys(wdata, payload);
+
+        /* on status reports the drm is reset so we need to resend the drm */
+        wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
+}
+
+static void handler_return(struct wiimote_data *wdata, const __u8 *payload)
+{
+        __u8 err = payload[3];
+        __u8 cmd = payload[2];
+
+        handler_keys(wdata, payload);
+
+        if (err)
+                hid_warn(wdata->hdev, "Remote error %hhu on req %hhu\n", err,
+                                                                        cmd);
+}
+
 struct wiiproto_handler {
         __u8 id;
         size_t size;
@@ -288,6 +342,8 @@ struct wiiproto_handler {
 };
 
 static struct wiiproto_handler handlers[] = {
+        { .id = WIIPROTO_REQ_STATUS, .size = 6, .func = handler_status },
+        { .id = WIIPROTO_REQ_RETURN, .size = 4, .func = handler_return },
         { .id = WIIPROTO_REQ_DRM_K, .size = 2, .func = handler_keys },
         { .id = 0 }
 };
@@ -300,11 +356,6 @@ static int wiimote_hid_event(struct hid_device *hdev, struct hid_report *report,
         int i;
         unsigned long flags;
 
-        if (!atomic_read(&wdata->ready))
-                return -EBUSY;
-        /* smp_rmb: Make sure wdata->xy is available when wdata->ready is 1 */
-        smp_rmb();
-
         if (size < 1)
                 return -EINVAL;
 
@@ -321,6 +372,58 @@ static int wiimote_hid_event(struct hid_device *hdev, struct hid_report *report,
         return 0;
 }
 
+static void wiimote_leds_destroy(struct wiimote_data *wdata)
+{
+        int i;
+        struct led_classdev *led;
+
+        for (i = 0; i < 4; ++i) {
+                if (wdata->leds[i]) {
+                        led = wdata->leds[i];
+                        wdata->leds[i] = NULL;
+                        led_classdev_unregister(led);
+                        kfree(led);
+                }
+        }
+}
+
+static int wiimote_leds_create(struct wiimote_data *wdata)
+{
+        int i, ret;
+        struct device *dev = &wdata->hdev->dev;
+        size_t namesz = strlen(dev_name(dev)) + 9;
+        struct led_classdev *led;
+        char *name;
+
+        for (i = 0; i < 4; ++i) {
+                led = kzalloc(sizeof(struct led_classdev) + namesz, GFP_KERNEL);
+                if (!led) {
+                        ret = -ENOMEM;
+                        goto err;
+                }
+                name = (void*)&led[1];
+                snprintf(name, namesz, "%s:blue:p%d", dev_name(dev), i);
+                led->name = name;
+                led->brightness = 0;
+                led->max_brightness = 1;
+                led->brightness_get = wiimote_leds_get;
+                led->brightness_set = wiimote_leds_set;
+
+                ret = led_classdev_register(dev, led);
+                if (ret) {
+                        kfree(led);
+                        goto err;
+                }
+                wdata->leds[i] = led;
+        }
+
+        return 0;
+
+err:
+        wiimote_leds_destroy(wdata);
+        return ret;
+}
+
 static struct wiimote_data *wiimote_create(struct hid_device *hdev)
 {
         struct wiimote_data *wdata;
@@ -341,6 +444,8 @@ static struct wiimote_data *wiimote_create(struct hid_device *hdev)
 
         input_set_drvdata(wdata->input, wdata);
         wdata->input->event = wiimote_input_event;
+        wdata->input->open = wiimote_input_open;
+        wdata->input->close = wiimote_input_close;
         wdata->input->dev.parent = &wdata->hdev->dev;
         wdata->input->id.bustype = wdata->hdev->bus;
         wdata->input->id.vendor = wdata->hdev->vendor;
@@ -362,6 +467,12 @@ static struct wiimote_data *wiimote_create(struct hid_device *hdev)
 
 static void wiimote_destroy(struct wiimote_data *wdata)
 {
+        wiimote_leds_destroy(wdata);
+
+        input_unregister_device(wdata->input);
+        cancel_work_sync(&wdata->worker);
+        hid_hw_stop(wdata->hdev);
+
         kfree(wdata);
 }
 
@@ -377,19 +488,6 @@ static int wiimote_hid_probe(struct hid_device *hdev,
                 return -ENOMEM;
         }
 
-        ret = device_create_file(&hdev->dev, &dev_attr_led1);
-        if (ret)
-                goto err;
-        ret = device_create_file(&hdev->dev, &dev_attr_led2);
-        if (ret)
-                goto err;
-        ret = device_create_file(&hdev->dev, &dev_attr_led3);
-        if (ret)
-                goto err;
-        ret = device_create_file(&hdev->dev, &dev_attr_led4);
-        if (ret)
-                goto err;
-
         ret = hid_parse(hdev);
         if (ret) {
                 hid_err(hdev, "HID parse failed\n");
@@ -408,9 +506,10 @@ static int wiimote_hid_probe(struct hid_device *hdev,
                 goto err_stop;
         }
 
-        /* smp_wmb: Write wdata->xy first before wdata->ready is set to 1 */
-        smp_wmb();
-        atomic_set(&wdata->ready, 1);
+        ret = wiimote_leds_create(wdata);
+        if (ret)
+                goto err_free;
+
         hid_info(hdev, "New device registered\n");
 
         /* by default set led1 after device initialization */
@@ -420,15 +519,15 @@ static int wiimote_hid_probe(struct hid_device *hdev,
 
         return 0;
 
+err_free:
+        wiimote_destroy(wdata);
+        return ret;
+
 err_stop:
         hid_hw_stop(hdev);
 err:
         input_free_device(wdata->input);
-        device_remove_file(&hdev->dev, &dev_attr_led1);
-        device_remove_file(&hdev->dev, &dev_attr_led2);
-        device_remove_file(&hdev->dev, &dev_attr_led3);
-        device_remove_file(&hdev->dev, &dev_attr_led4);
-        wiimote_destroy(wdata);
+        kfree(wdata);
         return ret;
 }
 
@@ -437,16 +536,6 @@ static void wiimote_hid_remove(struct hid_device *hdev)
         struct wiimote_data *wdata = hid_get_drvdata(hdev);
 
         hid_info(hdev, "Device removed\n");
-
-        device_remove_file(&hdev->dev, &dev_attr_led1);
-        device_remove_file(&hdev->dev, &dev_attr_led2);
-        device_remove_file(&hdev->dev, &dev_attr_led3);
-        device_remove_file(&hdev->dev, &dev_attr_led4);
-
-        hid_hw_stop(hdev);
-        input_unregister_device(wdata->input);
-
-        cancel_work_sync(&wdata->worker);
         wiimote_destroy(wdata);
 }
 
diff --git a/drivers/hid/usbhid/hid-quirks.c b/drivers/hid/usbhid/hid-quirks.c
index 621959d5cc42..3146fdcda272 100644
--- a/drivers/hid/usbhid/hid-quirks.c
+++ b/drivers/hid/usbhid/hid-quirks.c
@@ -47,6 +47,7 @@ static const struct hid_blacklist {
         { USB_VENDOR_ID_AFATECH, USB_DEVICE_ID_AFATECH_AF9016, HID_QUIRK_FULLSPEED_INTERVAL },
 
         { USB_VENDOR_ID_ETURBOTOUCH, USB_DEVICE_ID_ETURBOTOUCH, HID_QUIRK_MULTI_INPUT },
+        { USB_VENDOR_ID_GREENASIA, USB_DEVICE_ID_GREENASIA_DUAL_USB_JOYPAD, HID_QUIRK_MULTI_INPUT },
         { USB_VENDOR_ID_PANTHERLORD, USB_DEVICE_ID_PANTHERLORD_TWIN_USB_JOYSTICK, HID_QUIRK_MULTI_INPUT | HID_QUIRK_SKIP_OUTPUT_REPORTS },
         { USB_VENDOR_ID_PLAYDOTCOM, USB_DEVICE_ID_PLAYDOTCOM_EMS_USBII, HID_QUIRK_MULTI_INPUT },
         { USB_VENDOR_ID_TOUCHPACK, USB_DEVICE_ID_TOUCHPACK_RTS, HID_QUIRK_MULTI_INPUT },
@@ -89,6 +90,7 @@ static const struct hid_blacklist {
 
         { USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_MULTI_TOUCH, HID_QUIRK_MULTI_INPUT },
         { USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_WIRELESS, HID_QUIRK_MULTI_INPUT },
+        { USB_VENDOR_ID_SIGMA_MICRO, USB_DEVICE_ID_SIGMA_MICRO_KEYBOARD, HID_QUIRK_NO_INIT_REPORTS },
         { 0, 0 }
 };
 
diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
index 0598cd22edf2..0b62c3c6b7ce 100644
--- a/drivers/hwmon/Kconfig
+++ b/drivers/hwmon/Kconfig
@@ -623,7 +623,7 @@ config SENSORS_LM90
           LM86, LM89 and LM99, Analog Devices ADM1032, ADT7461, and ADT7461A,
           Maxim MAX6646, MAX6647, MAX6648, MAX6649, MAX6657, MAX6658, MAX6659,
           MAX6680, MAX6681, MAX6692, MAX6695, MAX6696, ON Semiconductor NCT1008,
-          and Winbond/Nuvoton W83L771W/G/AWG/ASG sensor chips.
+          Winbond/Nuvoton W83L771W/G/AWG/ASG and Philips SA56004 sensor chips.
 
           This driver can also be built as a module.  If so, the module
           will be called lm90.
@@ -694,14 +694,24 @@ config SENSORS_LTC4261
           be called ltc4261.
 
 config SENSORS_LM95241
-        tristate "National Semiconductor LM95241 sensor chip"
+        tristate "National Semiconductor LM95241 and compatibles"
         depends on I2C
         help
-          If you say yes here you get support for LM95241 sensor chip.
+          If you say yes here you get support for LM95231 and LM95241 sensor
+          chips.
 
           This driver can also be built as a module.  If so, the module
           will be called lm95241.
 
+config SENSORS_LM95245
+        tristate "National Semiconductor LM95245 sensor chip"
+        depends on I2C && EXPERIMENTAL
+        help
+          If you say yes here you get support for LM95245 sensor chip.
+
+          This driver can also be built as a module.  If so, the module
+          will be called lm95245.
+
 config SENSORS_MAX1111
         tristate "Maxim MAX1111 Multichannel, Serial 8-bit ADC chip"
         depends on SPI_MASTER
@@ -736,6 +746,16 @@ config SENSORS_MAX1619
           This driver can also be built as a module.  If so, the module
           will be called max1619.
 
+config SENSORS_MAX1668
+        tristate "Maxim MAX1668 and compatibles"
+        depends on I2C && EXPERIMENTAL
+        help
+          If you say yes here you get support for MAX1668, MAX1989 and
+          MAX1805 chips.
+
+          This driver can also be built as a module.  If so, the module
+          will be called max1668.
+
 config SENSORS_MAX6639
         tristate "Maxim MAX6639 sensor chip"
         depends on I2C && EXPERIMENTAL
@@ -767,6 +787,20 @@ config SENSORS_MAX6650
           This driver can also be built as a module.  If so, the module
           will be called max6650.
 
+config SENSORS_NTC_THERMISTOR
+        tristate "NTC thermistor support"
+        depends on EXPERIMENTAL
+        help
+          This driver supports NTC thermistors sensor reading and its
+          interpretation. The driver can also monitor the temperature and
+          send notifications about the temperature.
+
+          Currently, this driver supports
+          NCP15WB473, NCP18WB473, NCP21WB473, NCP03WB473, and NCP15WL333.
+
+          This driver can also be built as a module.  If so, the module
+          will be called ntc-thermistor.
+
 config SENSORS_PC87360
         tristate "National Semiconductor PC87360 family"
         select HWMON_VID
@@ -807,92 +841,7 @@ config SENSORS_PCF8591
           These devices are hard to detect and rarely found on mainstream
           hardware.  If unsure, say N.
 
-config PMBUS
-        tristate "PMBus support"
-        depends on I2C && EXPERIMENTAL
-        default n
-        help
-          Say yes here if you want to enable PMBus support.
-
-          This driver can also be built as a module. If so, the module will
-          be called pmbus_core.
-
-if PMBUS
-
-config SENSORS_PMBUS
-        tristate "Generic PMBus devices"
-        default n
-        help
-          If you say yes here you get hardware monitoring support for generic
-          PMBus devices, including but not limited to BMR450, BMR451, BMR453,
-          BMR454, and LTC2978.
-
-          This driver can also be built as a module. If so, the module will
-          be called pmbus.
-
-config SENSORS_ADM1275
-        tristate "Analog Devices ADM1275"
-        default n
-        help
-          If you say yes here you get hardware monitoring support for Analog
-          Devices ADM1275 Hot-Swap Controller and Digital Power Monitor.
-
-          This driver can also be built as a module. If so, the module will
-          be called adm1275.
-
-config SENSORS_MAX16064
-        tristate "Maxim MAX16064"
-        default n
-        help
-          If you say yes here you get hardware monitoring support for Maxim
-          MAX16064.
-
-          This driver can also be built as a module. If so, the module will
-          be called max16064.
-
-config SENSORS_MAX34440
-        tristate "Maxim MAX34440/MAX34441"
-        default n
-        help
-          If you say yes here you get hardware monitoring support for Maxim
-          MAX34440 and MAX34441.
-
-          This driver can also be built as a module. If so, the module will
-          be called max34440.
-
-config SENSORS_MAX8688
-        tristate "Maxim MAX8688"
-        default n
-        help
-          If you say yes here you get hardware monitoring support for Maxim
-          MAX8688.
-
-          This driver can also be built as a module. If so, the module will
-          be called max8688.
-
-config SENSORS_UCD9000
-        tristate "TI UCD90120, UCD90124, UCD9090, UCD90910"
-        default n
-        help
-          If you say yes here you get hardware monitoring support for TI
-          UCD90120, UCD90124, UCD9090, UCD90910 Sequencer and System Health
-          Controllers.
-
-          This driver can also be built as a module. If so, the module will
-          be called ucd9000.
-
-config SENSORS_UCD9200
-        tristate "TI UCD9220, UCD9222, UCD9224, UCD9240, UCD9244, UCD9246, UCD9248"
-        default n
-        help
-          If you say yes here you get hardware monitoring support for TI
-          UCD9220, UCD9222, UCD9224, UCD9240, UCD9244, UCD9246, and UCD9248
-          Digital PWM System Controllers.
-
-          This driver can also be built as a module. If so, the module will
-          be called ucd9200.
-
-endif # PMBUS
+source drivers/hwmon/pmbus/Kconfig
 
 config SENSORS_SHT15
         tristate "Sensiron humidity and temperature sensors. SHT15 and compat."
diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
index d7995a1d0784..3c9ccefea791 100644
--- a/drivers/hwmon/Makefile
+++ b/drivers/hwmon/Makefile
@@ -80,6 +80,7 @@ obj-$(CONFIG_SENSORS_LM90)	+= lm90.o
 obj-$(CONFIG_SENSORS_LM92)      += lm92.o
 obj-$(CONFIG_SENSORS_LM93)      += lm93.o
 obj-$(CONFIG_SENSORS_LM95241)   += lm95241.o
+obj-$(CONFIG_SENSORS_LM95245)   += lm95245.o
 obj-$(CONFIG_SENSORS_LTC4151)   += ltc4151.o
 obj-$(CONFIG_SENSORS_LTC4215)   += ltc4215.o
 obj-$(CONFIG_SENSORS_LTC4245)   += ltc4245.o
@@ -87,10 +88,12 @@ obj-$(CONFIG_SENSORS_LTC4261)	+= ltc4261.o
 obj-$(CONFIG_SENSORS_MAX1111)   += max1111.o
 obj-$(CONFIG_SENSORS_MAX16065)  += max16065.o
 obj-$(CONFIG_SENSORS_MAX1619)   += max1619.o
+obj-$(CONFIG_SENSORS_MAX1668)   += max1668.o
 obj-$(CONFIG_SENSORS_MAX6639)   += max6639.o
 obj-$(CONFIG_SENSORS_MAX6642)   += max6642.o
 obj-$(CONFIG_SENSORS_MAX6650)   += max6650.o
 obj-$(CONFIG_SENSORS_MC13783_ADC)+= mc13783-adc.o
+obj-$(CONFIG_SENSORS_NTC_THERMISTOR)    += ntc_thermistor.o
 obj-$(CONFIG_SENSORS_PC87360)   += pc87360.o
 obj-$(CONFIG_SENSORS_PC87427)   += pc87427.o
 obj-$(CONFIG_SENSORS_PCF8591)   += pcf8591.o
@@ -121,15 +124,7 @@ obj-$(CONFIG_SENSORS_W83L786NG)	+= w83l786ng.o
 obj-$(CONFIG_SENSORS_WM831X)    += wm831x-hwmon.o
 obj-$(CONFIG_SENSORS_WM8350)    += wm8350-hwmon.o
 
-# PMBus drivers
-obj-$(CONFIG_PMBUS)             += pmbus_core.o
-obj-$(CONFIG_SENSORS_PMBUS)     += pmbus.o
-obj-$(CONFIG_SENSORS_ADM1275)   += adm1275.o
-obj-$(CONFIG_SENSORS_MAX16064)  += max16064.o
-obj-$(CONFIG_SENSORS_MAX34440)  += max34440.o
-obj-$(CONFIG_SENSORS_MAX8688)   += max8688.o
-obj-$(CONFIG_SENSORS_UCD9000)   += ucd9000.o
-obj-$(CONFIG_SENSORS_UCD9200)   += ucd9200.o
+obj-$(CONFIG_PMBUS)             += pmbus/
 
 ccflags-$(CONFIG_HWMON_DEBUG_CHIP) := -DDEBUG
 
diff --git a/drivers/hwmon/coretemp.c b/drivers/hwmon/coretemp.c
index 0070d5476dd0..59d83e83da7f 100644
--- a/drivers/hwmon/coretemp.c
+++ b/drivers/hwmon/coretemp.c
@@ -44,7 +44,9 @@
 #define BASE_SYSFS_ATTR_NO      2       /* Sysfs Base attr no for coretemp */
 #define NUM_REAL_CORES          16      /* Number of Real cores per cpu */
 #define CORETEMP_NAME_LENGTH    17      /* String Length of attrs */
-#define MAX_ATTRS               5       /* Maximum no of per-core attrs */
+#define MAX_CORE_ATTRS          4       /* Maximum no of basic attrs */
+#define MAX_THRESH_ATTRS        3       /* Maximum no of Threshold attrs */
+#define TOTAL_ATTRS             (MAX_CORE_ATTRS + MAX_THRESH_ATTRS)
 #define MAX_CORE_DATA           (NUM_REAL_CORES + BASE_SYSFS_ATTR_NO)
 
 #ifdef CONFIG_SMP
@@ -67,6 +69,9 @@
  *              This value is passed as "id" field to rdmsr/wrmsr functions.
  * @status_reg: One of IA32_THERM_STATUS or IA32_PACKAGE_THERM_STATUS,
  *              from where the temperature values should be read.
+ * @intrpt_reg: One of IA32_THERM_INTERRUPT or IA32_PACKAGE_THERM_INTERRUPT,
+ *              from where the thresholds are read.
+ * @attr_size:  Total number of pre-core attrs displayed in the sysfs.
  * @is_pkg_data: If this is 1, the temp_data holds pkgtemp data.
  *              Otherwise, temp_data holds coretemp data.
  * @valid: If this is 1, the current temperature is valid.
@@ -74,15 +79,18 @@
 struct temp_data {
         int temp;
         int ttarget;
+        int tmin;
         int tjmax;
         unsigned long last_updated;
         unsigned int cpu;
         u32 cpu_core_id;
         u32 status_reg;
+        u32 intrpt_reg;
+        int attr_size;
         bool is_pkg_data;
         bool valid;
-        struct sensor_device_attribute sd_attrs[MAX_ATTRS];
-        char attr_name[MAX_ATTRS][CORETEMP_NAME_LENGTH];
+        struct sensor_device_attribute sd_attrs[TOTAL_ATTRS];
+        char attr_name[TOTAL_ATTRS][CORETEMP_NAME_LENGTH];
         struct mutex update_lock;
 };
 
@@ -135,6 +143,19 @@ static ssize_t show_crit_alarm(struct device *dev,
         return sprintf(buf, "%d\n", (eax >> 5) & 1);
 }
 
+static ssize_t show_max_alarm(struct device *dev,
+                                struct device_attribute *devattr, char *buf)
+{
+        u32 eax, edx;
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+        struct platform_data *pdata = dev_get_drvdata(dev);
+        struct temp_data *tdata = pdata->core_data[attr->index];
+
+        rdmsr_on_cpu(tdata->cpu, tdata->status_reg, &eax, &edx);
+
+        return sprintf(buf, "%d\n", !!(eax & THERM_STATUS_THRESHOLD1));
+}
+
 static ssize_t show_tjmax(struct device *dev,
                         struct device_attribute *devattr, char *buf)
 {
@@ -153,6 +174,83 @@ static ssize_t show_ttarget(struct device *dev,
         return sprintf(buf, "%d\n", pdata->core_data[attr->index]->ttarget);
 }
 
+static ssize_t store_ttarget(struct device *dev,
+                                struct device_attribute *devattr,
+                                const char *buf, size_t count)
+{
+        struct platform_data *pdata = dev_get_drvdata(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+        struct temp_data *tdata = pdata->core_data[attr->index];
+        u32 eax, edx;
+        unsigned long val;
+        int diff;
+
+        if (strict_strtoul(buf, 10, &val))
+                return -EINVAL;
+
+        /*
+         * THERM_MASK_THRESHOLD1 is 7 bits wide. Values are entered in terms
+         * of milli degree celsius. Hence don't accept val > (127 * 1000)
+         */
+        if (val > tdata->tjmax || val > 127000)
+                return -EINVAL;
+
+        diff = (tdata->tjmax - val) / 1000;
+
+        mutex_lock(&tdata->update_lock);
+        rdmsr_on_cpu(tdata->cpu, tdata->intrpt_reg, &eax, &edx);
+        eax = (eax & ~THERM_MASK_THRESHOLD1) |
+                                (diff << THERM_SHIFT_THRESHOLD1);
+        wrmsr_on_cpu(tdata->cpu, tdata->intrpt_reg, eax, edx);
+        tdata->ttarget = val;
+        mutex_unlock(&tdata->update_lock);
+
+        return count;
+}
+
+static ssize_t show_tmin(struct device *dev,
+                        struct device_attribute *devattr, char *buf)
+{
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+        struct platform_data *pdata = dev_get_drvdata(dev);
+
+        return sprintf(buf, "%d\n", pdata->core_data[attr->index]->tmin);
+}
+
+static ssize_t store_tmin(struct device *dev,
+                                struct device_attribute *devattr,
+                                const char *buf, size_t count)
+{
+        struct platform_data *pdata = dev_get_drvdata(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+        struct temp_data *tdata = pdata->core_data[attr->index];
+        u32 eax, edx;
+        unsigned long val;
+        int diff;
+
+        if (strict_strtoul(buf, 10, &val))
+                return -EINVAL;
+
+        /*
+         * THERM_MASK_THRESHOLD0 is 7 bits wide. Values are entered in terms
+         * of milli degree celsius. Hence don't accept val > (127 * 1000)
+         */
+        if (val > tdata->tjmax || val > 127000)
+                return -EINVAL;
+
+        diff = (tdata->tjmax - val) / 1000;
+
+        mutex_lock(&tdata->update_lock);
+        rdmsr_on_cpu(tdata->cpu, tdata->intrpt_reg, &eax, &edx);
+        eax = (eax & ~THERM_MASK_THRESHOLD0) |
+                                (diff << THERM_SHIFT_THRESHOLD0);
+        wrmsr_on_cpu(tdata->cpu, tdata->intrpt_reg, eax, edx);
+        tdata->tmin = val;
+        mutex_unlock(&tdata->update_lock);
+
+        return count;
+}
+
 static ssize_t show_temp(struct device *dev,
                         struct device_attribute *devattr, char *buf)
 {
@@ -344,23 +442,31 @@ static int create_core_attrs(struct temp_data *tdata, struct device *dev,
                                 int attr_no)
 {
         int err, i;
-        static ssize_t (*rd_ptr[MAX_ATTRS]) (struct device *dev,
+        static ssize_t (*rd_ptr[TOTAL_ATTRS]) (struct device *dev,
                         struct device_attribute *devattr, char *buf) = {
-                        show_label, show_crit_alarm, show_ttarget,
-                        show_temp, show_tjmax };
-        static const char *names[MAX_ATTRS] = {
+                        show_label, show_crit_alarm, show_temp, show_tjmax,
+                        show_max_alarm, show_ttarget, show_tmin };
+        static ssize_t (*rw_ptr[TOTAL_ATTRS]) (struct device *dev,
+                        struct device_attribute *devattr, const char *buf,
+                        size_t count) = { NULL, NULL, NULL, NULL, NULL,
+                                        store_ttarget, store_tmin };
+        static const char *names[TOTAL_ATTRS] = {
                                         "temp%d_label", "temp%d_crit_alarm",
-                                        "temp%d_max", "temp%d_input",
-                                        "temp%d_crit" };
+                                        "temp%d_input", "temp%d_crit",
+                                        "temp%d_max_alarm", "temp%d_max",
+                                        "temp%d_max_hyst" };
 
-        for (i = 0; i < MAX_ATTRS; i++) {
+        for (i = 0; i < tdata->attr_size; i++) {
                 snprintf(tdata->attr_name[i], CORETEMP_NAME_LENGTH, names[i],
                         attr_no);
                 sysfs_attr_init(&tdata->sd_attrs[i].dev_attr.attr);
                 tdata->sd_attrs[i].dev_attr.attr.name = tdata->attr_name[i];
                 tdata->sd_attrs[i].dev_attr.attr.mode = S_IRUGO;
+                if (rw_ptr[i]) {
+                        tdata->sd_attrs[i].dev_attr.attr.mode |= S_IWUSR;
+                        tdata->sd_attrs[i].dev_attr.store = rw_ptr[i];
+                }
                 tdata->sd_attrs[i].dev_attr.show = rd_ptr[i];
-                tdata->sd_attrs[i].dev_attr.store = NULL;
                 tdata->sd_attrs[i].index = attr_no;
                 err = device_create_file(dev, &tdata->sd_attrs[i].dev_attr);
                 if (err)
@@ -374,38 +480,6 @@ exit_free:
         return err;
 }
 
-static void update_ttarget(__u8 cpu_model, struct temp_data *tdata,
-                                struct device *dev)
-{
-        int err;
-        u32 eax, edx;
-
-        /*
-         * Initialize ttarget value. Eventually this will be
-         * initialized with the value from MSR_IA32_THERM_INTERRUPT
-         * register. If IA32_TEMPERATURE_TARGET is supported, this
-         * value will be over written below.
-         * To Do: Patch to initialize ttarget from MSR_IA32_THERM_INTERRUPT
-         */
-        tdata->ttarget = tdata->tjmax - 20000;
-
-        /*
-         * Read the still undocumented IA32_TEMPERATURE_TARGET. It exists
-         * on older CPUs but not in this register,
-         * Atoms don't have it either.
-         */
-        if (cpu_model > 0xe && cpu_model != 0x1c) {
-                err = rdmsr_safe_on_cpu(tdata->cpu,
-                                MSR_IA32_TEMPERATURE_TARGET, &eax, &edx);
-                if (err) {
-                        dev_warn(dev,
-                        "Unable to read IA32_TEMPERATURE_TARGET MSR\n");
-                } else {
-                        tdata->ttarget = tdata->tjmax -
-                                        ((eax >> 8) & 0xff) * 1000;
-                }
-        }
-}
 
 static int __devinit chk_ucode_version(struct platform_device *pdev)
 {
@@ -464,9 +538,12 @@ static struct temp_data *init_temp_data(unsigned int cpu, int pkg_flag)
 
         tdata->status_reg = pkg_flag ? MSR_IA32_PACKAGE_THERM_STATUS :
                                                         MSR_IA32_THERM_STATUS;
+        tdata->intrpt_reg = pkg_flag ? MSR_IA32_PACKAGE_THERM_INTERRUPT :
+                                                MSR_IA32_THERM_INTERRUPT;
         tdata->is_pkg_data = pkg_flag;
         tdata->cpu = cpu;
         tdata->cpu_core_id = TO_CORE_ID(cpu);
+        tdata->attr_size = MAX_CORE_ATTRS;
         mutex_init(&tdata->update_lock);
         return tdata;
 }
@@ -516,7 +593,17 @@ static int create_core_data(struct platform_data *pdata,
         else
                 tdata->tjmax = get_tjmax(c, cpu, &pdev->dev);
 
-        update_ttarget(c->x86_model, tdata, &pdev->dev);
+        /*
+         * Test if we can access the intrpt register. If so, increase the
+         * 'size' enough to have ttarget/tmin/max_alarm interfaces.
+         * Initialize ttarget with bits 16:22 of MSR_IA32_THERM_INTERRUPT
+         */
+        err = rdmsr_safe_on_cpu(cpu, tdata->intrpt_reg, &eax, &edx);
+        if (!err) {
+                tdata->attr_size += MAX_THRESH_ATTRS;
+                tdata->ttarget = tdata->tjmax - ((eax >> 16) & 0x7f) * 1000;
+        }
+
         pdata->core_data[attr_no] = tdata;
 
         /* Create sysfs interfaces */
@@ -553,7 +640,7 @@ static void coretemp_remove_core(struct platform_data *pdata,
         struct temp_data *tdata = pdata->core_data[indx];
 
         /* Remove the sysfs attributes */
-        for (i = 0; i < MAX_ATTRS; i++)
+        for (i = 0; i < tdata->attr_size; i++)
                 device_remove_file(dev, &tdata->sd_attrs[i].dev_attr);
 
         kfree(pdata->core_data[indx]);
diff --git a/drivers/hwmon/i5k_amb.c b/drivers/hwmon/i5k_amb.c
index c4c40be0edbf..d22f241b6a67 100644
--- a/drivers/hwmon/i5k_amb.c
+++ b/drivers/hwmon/i5k_amb.c
@@ -114,7 +114,6 @@ struct i5k_amb_data {
         void __iomem *amb_mmio;
         struct i5k_device_attribute *attrs;
         unsigned int num_attrs;
-        unsigned long chipset_id;
 };
 
 static ssize_t show_name(struct device *dev, struct device_attribute *devattr,
@@ -444,8 +443,6 @@ static int __devinit i5k_find_amb_registers(struct i5k_amb_data *data,
                 goto out;
         }
 
-        data->chipset_id = devid;
-
         res = 0;
 out:
         pci_dev_put(pcidev);
@@ -478,23 +475,13 @@ out:
         return res;
 }
 
-static unsigned long i5k_channel_pci_id(struct i5k_amb_data *data,
-                                        unsigned long channel)
-{
-        switch (data->chipset_id) {
-        case PCI_DEVICE_ID_INTEL_5000_ERR:
-                return PCI_DEVICE_ID_INTEL_5000_FBD0 + channel;
-        case PCI_DEVICE_ID_INTEL_5400_ERR:
-                return PCI_DEVICE_ID_INTEL_5400_FBD0 + channel;
-        default:
-                BUG();
-        }
-}
-
-static unsigned long chipset_ids[] = {
-        PCI_DEVICE_ID_INTEL_5000_ERR,
-        PCI_DEVICE_ID_INTEL_5400_ERR,
-        0
+static struct {
+        unsigned long err;
+        unsigned long fbd0;
+} chipset_ids[] __devinitdata  = {
+        { PCI_DEVICE_ID_INTEL_5000_ERR, PCI_DEVICE_ID_INTEL_5000_FBD0 },
+        { PCI_DEVICE_ID_INTEL_5400_ERR, PCI_DEVICE_ID_INTEL_5400_FBD0 },
+        { 0, 0 }
 };
 
 #ifdef MODULE
@@ -510,8 +497,7 @@ static int __devinit i5k_amb_probe(struct platform_device *pdev)
 {
         struct i5k_amb_data *data;
         struct resource *reso;
-        int i;
-        int res = -ENODEV;
+        int i, res;
 
         data = kzalloc(sizeof(*data), GFP_KERNEL);
         if (!data)
@@ -520,22 +506,22 @@ static int __devinit i5k_amb_probe(struct platform_device *pdev)
         /* Figure out where the AMB registers live */
         i = 0;
         do {
-                res = i5k_find_amb_registers(data, chipset_ids[i]);
+                res = i5k_find_amb_registers(data, chipset_ids[i].err);
+                if (res == 0)
+                        break;
                 i++;
-        } while (res && chipset_ids[i]);
+        } while (chipset_ids[i].err);
 
         if (res)
                 goto err;
 
         /* Copy the DIMM presence map for the first two channels */
-        res = i5k_channel_probe(&data->amb_present[0],
-                                i5k_channel_pci_id(data, 0));
+        res = i5k_channel_probe(&data->amb_present[0], chipset_ids[i].fbd0);
         if (res)
                 goto err;
 
         /* Copy the DIMM presence map for the optional second two channels */
-        i5k_channel_probe(&data->amb_present[2],
-                          i5k_channel_pci_id(data, 1));
+        i5k_channel_probe(&data->amb_present[2], chipset_ids[i].fbd0 + 1);
 
         /* Set up resource regions */
         reso = request_mem_region(data->amb_base, data->amb_len, DRVNAME);
diff --git a/drivers/hwmon/ibmaem.c b/drivers/hwmon/ibmaem.c
index 1a409c5bc9bc..c316294c48b4 100644
--- a/drivers/hwmon/ibmaem.c
+++ b/drivers/hwmon/ibmaem.c
@@ -432,13 +432,15 @@ static int aem_read_sensor(struct aem_data *data, u8 elt, u8 reg,
         aem_send_message(ipmi);
 
         res = wait_for_completion_timeout(&ipmi->read_complete, IPMI_TIMEOUT);
-        if (!res)
-                return -ETIMEDOUT;
+        if (!res) {
+                res = -ETIMEDOUT;
+                goto out;
+        }
 
         if (ipmi->rx_result || ipmi->rx_msg_len != rs_size ||
             memcmp(&rs_resp->id, &system_x_id, sizeof(system_x_id))) {
-                kfree(rs_resp);
-                return -ENOENT;
+                res = -ENOENT;
+                goto out;
         }
 
         switch (size) {
@@ -463,8 +465,11 @@ static int aem_read_sensor(struct aem_data *data, u8 elt, u8 reg,
                 break;
         }
         }
+        res = 0;
 
-        return 0;
+out:
+        kfree(rs_resp);
+        return res;
 }
 
 /* Update AEM energy registers */
diff --git a/drivers/hwmon/lm90.c b/drivers/hwmon/lm90.c
index 2f94f9504804..90ddb8774210 100644
--- a/drivers/hwmon/lm90.c
+++ b/drivers/hwmon/lm90.c
@@ -54,6 +54,9 @@
  * and extended mode. They are mostly compatible with LM90 except for a data
  * format difference for the temperature value registers.
  *
+ * This driver also supports the SA56004 from Philips. This device is
+ * pin-compatible with the LM86, the ED/EDP parts are also address-compatible.
+ *
  * Since the LM90 was the first chipset supported by this driver, most
  * comments will refer to this chipset, but are actually general and
  * concern all supported chipsets, unless mentioned otherwise.
@@ -96,13 +99,15 @@
  * MAX6659 can have address 0x4c, 0x4d or 0x4e.
  * MAX6680 and MAX6681 can have address 0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b,
  * 0x4c, 0x4d or 0x4e.
+ * SA56004 can have address 0x48 through 0x4F.
  */
 
 static const unsigned short normal_i2c[] = {
-        0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b, 0x4c, 0x4d, 0x4e, I2C_CLIENT_END };
+        0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b, 0x48, 0x49, 0x4a, 0x4b, 0x4c,
+        0x4d, 0x4e, 0x4f, I2C_CLIENT_END };
 
 enum chips { lm90, adm1032, lm99, lm86, max6657, max6659, adt7461, max6680,
-        max6646, w83l771, max6696 };
+        max6646, w83l771, max6696, sa56004 };
 
 /*
  * The LM90 registers
@@ -152,6 +157,10 @@ enum chips { lm90, adm1032, lm99, lm86, max6657, max6659, adt7461, max6680,
 #define MAX6659_REG_R_LOCAL_EMERG       0x17
 #define MAX6659_REG_W_LOCAL_EMERG       0x17
 
+/*  SA56004 registers */
+
+#define SA56004_REG_R_LOCAL_TEMPL 0x22
+
 #define LM90_DEF_CONVRATE_RVAL  6       /* Def conversion rate register value */
 #define LM90_MAX_CONVRATE_MS    16000   /* Maximum conversion rate in ms */
 
@@ -161,7 +170,6 @@ enum chips { lm90, adm1032, lm99, lm86, max6657, max6659, adt7461, max6680,
 #define LM90_FLAG_ADT7461_EXT   (1 << 0) /* ADT7461 extended mode       */
 /* Device features */
 #define LM90_HAVE_OFFSET        (1 << 1) /* temperature offset register */
-#define LM90_HAVE_LOCAL_EXT     (1 << 2) /* extended local temperature  */
 #define LM90_HAVE_REM_LIMIT_EXT (1 << 3) /* extended remote limit       */
 #define LM90_HAVE_EMERGENCY     (1 << 4) /* 3rd upper (emergency) limit */
 #define LM90_HAVE_EMERGENCY_ALARM (1 << 5)/* emergency alarm            */
@@ -192,6 +200,7 @@ static const struct i2c_device_id lm90_id[] = {
         { "max6696", max6696 },
         { "nct1008", adt7461 },
         { "w83l771", w83l771 },
+        { "sa56004", sa56004 },
         { }
 };
 MODULE_DEVICE_TABLE(i2c, lm90_id);
@@ -204,6 +213,7 @@ struct lm90_params {
         u16 alert_alarms;       /* Which alarm bits trigger ALERT# */
                                 /* Upper 8 bits for max6695/96 */
         u8 max_convrate;        /* Maximum conversion rate register value */
+        u8 reg_local_ext;       /* Extended local temp register (optional) */
 };
 
 static const struct lm90_params lm90_params[] = {
@@ -235,19 +245,20 @@ static const struct lm90_params lm90_params[] = {
                 .max_convrate = 9,
         },
         [max6646] = {
-                .flags = LM90_HAVE_LOCAL_EXT,
                 .alert_alarms = 0x7c,
                 .max_convrate = 6,
+                .reg_local_ext = MAX6657_REG_R_LOCAL_TEMPL,
         },
         [max6657] = {
-                .flags = LM90_HAVE_LOCAL_EXT,
                 .alert_alarms = 0x7c,
                 .max_convrate = 8,
+                .reg_local_ext = MAX6657_REG_R_LOCAL_TEMPL,
         },
         [max6659] = {
-                .flags = LM90_HAVE_LOCAL_EXT | LM90_HAVE_EMERGENCY,
+                .flags = LM90_HAVE_EMERGENCY,
                 .alert_alarms = 0x7c,
                 .max_convrate = 8,
+                .reg_local_ext = MAX6657_REG_R_LOCAL_TEMPL,
         },
         [max6680] = {
                 .flags = LM90_HAVE_OFFSET,
@@ -255,16 +266,23 @@ static const struct lm90_params lm90_params[] = {
                 .max_convrate = 7,
         },
         [max6696] = {
-                .flags = LM90_HAVE_LOCAL_EXT | LM90_HAVE_EMERGENCY
+                .flags = LM90_HAVE_EMERGENCY
                   | LM90_HAVE_EMERGENCY_ALARM | LM90_HAVE_TEMP3,
                 .alert_alarms = 0x187c,
                 .max_convrate = 6,
+                .reg_local_ext = MAX6657_REG_R_LOCAL_TEMPL,
         },
         [w83l771] = {
                 .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT,
                 .alert_alarms = 0x7c,
                 .max_convrate = 8,
         },
+        [sa56004] = {
+                .flags = LM90_HAVE_OFFSET | LM90_HAVE_REM_LIMIT_EXT,
+                .alert_alarms = 0x7b,
+                .max_convrate = 9,
+                .reg_local_ext = SA56004_REG_R_LOCAL_TEMPL,
+        },
 };
 
 /*
@@ -286,6 +304,7 @@ struct lm90_data {
         u16 alert_alarms;       /* Which alarm bits trigger ALERT# */
                                 /* Upper 8 bits for max6695/96 */
         u8 max_convrate;        /* Maximum conversion rate */
+        u8 reg_local_ext;       /* local extension register offset */
 
         /* registers values */
         s8 temp8[8];    /* 0: local low limit
@@ -452,9 +471,9 @@ static struct lm90_data *lm90_update_device(struct device *dev)
                 lm90_read_reg(client, LM90_REG_R_REMOTE_CRIT, &data->temp8[3]);
                 lm90_read_reg(client, LM90_REG_R_TCRIT_HYST, &data->temp_hyst);
 
-                if (data->flags & LM90_HAVE_LOCAL_EXT) {
+                if (data->reg_local_ext) {
                         lm90_read16(client, LM90_REG_R_LOCAL_TEMP,
-                                    MAX6657_REG_R_LOCAL_TEMPL,
+                                    data->reg_local_ext,
                                     &data->temp11[4]);
                 } else {
                         if (lm90_read_reg(client, LM90_REG_R_LOCAL_TEMP,
@@ -1092,7 +1111,7 @@ static int lm90_detect(struct i2c_client *new_client,
         struct i2c_adapter *adapter = new_client->adapter;
         int address = new_client->addr;
         const char *name = NULL;
-        int man_id, chip_id, reg_config1, reg_convrate;
+        int man_id, chip_id, reg_config1, reg_config2, reg_convrate;
 
         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                 return -ENODEV;
@@ -1108,15 +1127,16 @@ static int lm90_detect(struct i2c_client *new_client,
                                                 LM90_REG_R_CONVRATE)) < 0)
                 return -ENODEV;
 
-        if ((address == 0x4C || address == 0x4D)
-         && man_id == 0x01) { /* National Semiconductor */
-                int reg_config2;
-
+        if (man_id == 0x01 || man_id == 0x5C || man_id == 0x41) {
                 reg_config2 = i2c_smbus_read_byte_data(new_client,
                                                 LM90_REG_R_CONFIG2);
                 if (reg_config2 < 0)
                         return -ENODEV;
+        } else
+                reg_config2 = 0;        /* Make compiler happy */
 
+        if ((address == 0x4C || address == 0x4D)
+         && man_id == 0x01) { /* National Semiconductor */
                 if ((reg_config1 & 0x2A) == 0x00
                  && (reg_config2 & 0xF8) == 0x00
                  && reg_convrate <= 0x09) {
@@ -1245,13 +1265,6 @@ static int lm90_detect(struct i2c_client *new_client,
         } else
         if (address == 0x4C
          && man_id == 0x5C) { /* Winbond/Nuvoton */
-                int reg_config2;
-
-                reg_config2 = i2c_smbus_read_byte_data(new_client,
-                                                LM90_REG_R_CONFIG2);
-                if (reg_config2 < 0)
-                        return -ENODEV;
-
                 if ((reg_config1 & 0x2A) == 0x00
                  && (reg_config2 & 0xF8) == 0x00) {
                         if (chip_id == 0x01 /* W83L771W/G */
@@ -1263,6 +1276,15 @@ static int lm90_detect(struct i2c_client *new_client,
                                 name = "w83l771";
                         }
                 }
+        } else
+        if (address >= 0x48 && address <= 0x4F
+         && man_id == 0xA1) { /*  NXP Semiconductor/Philips */
+                if (chip_id == 0x00
+                 && (reg_config1 & 0x2A) == 0x00
+                 && (reg_config2 & 0xFE) == 0x00
+                 && reg_convrate <= 0x09) {
+                        name = "sa56004";
+                }
         }
 
         if (!name) { /* identification failed */
@@ -1368,6 +1390,7 @@ static int lm90_probe(struct i2c_client *new_client,
 
         /* Set chip capabilities */
         data->flags = lm90_params[data->kind].flags;
+        data->reg_local_ext = lm90_params[data->kind].reg_local_ext;
 
         /* Set maximum conversion rate */
         data->max_convrate = lm90_params[data->kind].max_convrate;
diff --git a/drivers/hwmon/lm95241.c b/drivers/hwmon/lm95241.c
index d3b464b74ced..513901d592a9 100644
--- a/drivers/hwmon/lm95241.c
+++ b/drivers/hwmon/lm95241.c
@@ -74,8 +74,9 @@ static const unsigned short normal_i2c[] = {
 #define TT_OFF 0
 #define TT_ON 1
 #define TT_MASK 7
-#define MANUFACTURER_ID 0x01
-#define DEFAULT_REVISION 0xA4
+#define NATSEMI_MAN_ID  0x01
+#define LM95231_CHIP_ID 0xA1
+#define LM95241_CHIP_ID 0xA4
 
 static const u8 lm95241_reg_address[] = {
         LM95241_REG_R_LOCAL_TEMPH,
@@ -338,20 +339,25 @@ static int lm95241_detect(struct i2c_client *new_client,
                           struct i2c_board_info *info)
 {
         struct i2c_adapter *adapter = new_client->adapter;
-        int address = new_client->addr;
         const char *name;
+        int mfg_id, chip_id;
 
         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                 return -ENODEV;
 
-        if ((i2c_smbus_read_byte_data(new_client, LM95241_REG_R_MAN_ID)
-             == MANUFACTURER_ID)
-            && (i2c_smbus_read_byte_data(new_client, LM95241_REG_R_CHIP_ID)
-                == DEFAULT_REVISION)) {
-                name = DEVNAME;
-        } else {
-                dev_dbg(&adapter->dev, "LM95241 detection failed at 0x%02x\n",
-                        address);
+        mfg_id = i2c_smbus_read_byte_data(new_client, LM95241_REG_R_MAN_ID);
+        if (mfg_id != NATSEMI_MAN_ID)
+                return -ENODEV;
+
+        chip_id = i2c_smbus_read_byte_data(new_client, LM95241_REG_R_CHIP_ID);
+        switch (chip_id) {
+        case LM95231_CHIP_ID:
+                name = "lm95231";
+                break;
+        case LM95241_CHIP_ID:
+                name = "lm95241";
+                break;
+        default:
                 return -ENODEV;
         }
 
@@ -431,7 +437,8 @@ static int lm95241_remove(struct i2c_client *client)
 
 /* Driver data (common to all clients) */
 static const struct i2c_device_id lm95241_id[] = {
-        { DEVNAME, 0 },
+        { "lm95231", 0 },
+        { "lm95241", 0 },
         { }
 };
 MODULE_DEVICE_TABLE(i2c, lm95241_id);
diff --git a/drivers/hwmon/lm95245.c b/drivers/hwmon/lm95245.c
new file mode 100644
index 000000000000..dce9e68241e6
--- /dev/null
+++ b/drivers/hwmon/lm95245.c
@@ -0,0 +1,543 @@
+/*
+ * Copyright (C) 2011 Alexander Stein <alexander.stein@systec-electronic.com>
+ *
+ * The LM95245 is a sensor chip made by National Semiconductors.
+ * It reports up to two temperatures (its own plus an external one).
+ * Complete datasheet can be obtained from National's website at:
+ *   http://www.national.com/ds.cgi/LM/LM95245.pdf
+ *
+ * This driver is based on lm95241.c
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/jiffies.h>
+#include <linux/i2c.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
+#include <linux/err.h>
+#include <linux/mutex.h>
+#include <linux/sysfs.h>
+
+#define DEVNAME "lm95245"
+
+static const unsigned short normal_i2c[] = {
+        0x18, 0x19, 0x29, 0x4c, 0x4d, I2C_CLIENT_END };
+
+/* LM95245 registers */
+/* general registers */
+#define LM95245_REG_RW_CONFIG1          0x03
+#define LM95245_REG_RW_CONVERS_RATE     0x04
+#define LM95245_REG_W_ONE_SHOT          0x0F
+
+/* diode configuration */
+#define LM95245_REG_RW_CONFIG2          0xBF
+#define LM95245_REG_RW_REMOTE_OFFH      0x11
+#define LM95245_REG_RW_REMOTE_OFFL      0x12
+
+/* status registers */
+#define LM95245_REG_R_STATUS1           0x02
+#define LM95245_REG_R_STATUS2           0x33
+
+/* limit registers */
+#define LM95245_REG_RW_REMOTE_OS_LIMIT          0x07
+#define LM95245_REG_RW_LOCAL_OS_TCRIT_LIMIT     0x20
+#define LM95245_REG_RW_REMOTE_TCRIT_LIMIT       0x19
+#define LM95245_REG_RW_COMMON_HYSTERESIS        0x21
+
+/* temperature signed */
+#define LM95245_REG_R_LOCAL_TEMPH_S     0x00
+#define LM95245_REG_R_LOCAL_TEMPL_S     0x30
+#define LM95245_REG_R_REMOTE_TEMPH_S    0x01
+#define LM95245_REG_R_REMOTE_TEMPL_S    0x10
+/* temperature unsigned */
+#define LM95245_REG_R_REMOTE_TEMPH_U    0x31
+#define LM95245_REG_R_REMOTE_TEMPL_U    0x32
+
+/* id registers */
+#define LM95245_REG_R_MAN_ID            0xFE
+#define LM95245_REG_R_CHIP_ID           0xFF
+
+/* LM95245 specific bitfields */
+#define CFG_STOP                0x40
+#define CFG_REMOTE_TCRIT_MASK   0x10
+#define CFG_REMOTE_OS_MASK      0x08
+#define CFG_LOCAL_TCRIT_MASK    0x04
+#define CFG_LOCAL_OS_MASK       0x02
+
+#define CFG2_OS_A0              0x40
+#define CFG2_DIODE_FAULT_OS     0x20
+#define CFG2_DIODE_FAULT_TCRIT  0x10
+#define CFG2_REMOTE_TT          0x08
+#define CFG2_REMOTE_FILTER_DIS  0x00
+#define CFG2_REMOTE_FILTER_EN   0x06
+
+/* conversation rate in ms */
+#define RATE_CR0063     0x00
+#define RATE_CR0364     0x01
+#define RATE_CR1000     0x02
+#define RATE_CR2500     0x03
+
+#define STATUS1_DIODE_FAULT     0x04
+#define STATUS1_RTCRIT          0x02
+#define STATUS1_LOC             0x01
+
+#define MANUFACTURER_ID         0x01
+#define DEFAULT_REVISION        0xB3
+
+static const u8 lm95245_reg_address[] = {
+        LM95245_REG_R_LOCAL_TEMPH_S,
+        LM95245_REG_R_LOCAL_TEMPL_S,
+        LM95245_REG_R_REMOTE_TEMPH_S,
+        LM95245_REG_R_REMOTE_TEMPL_S,
+        LM95245_REG_R_REMOTE_TEMPH_U,
+        LM95245_REG_R_REMOTE_TEMPL_U,
+        LM95245_REG_RW_LOCAL_OS_TCRIT_LIMIT,
+        LM95245_REG_RW_REMOTE_TCRIT_LIMIT,
+        LM95245_REG_RW_COMMON_HYSTERESIS,
+        LM95245_REG_R_STATUS1,
+};
+
+/* Client data (each client gets its own) */
+struct lm95245_data {
+        struct device *hwmon_dev;
+        struct mutex update_lock;
+        unsigned long last_updated;     /* in jiffies */
+        unsigned long interval; /* in msecs */
+        bool valid;             /* zero until following fields are valid */
+        /* registers values */
+        u8 regs[ARRAY_SIZE(lm95245_reg_address)];
+        u8 config1, config2;
+};
+
+/* Conversions */
+static int temp_from_reg_unsigned(u8 val_h, u8 val_l)
+{
+        return val_h * 1000 + val_l * 1000 / 256;
+}
+
+static int temp_from_reg_signed(u8 val_h, u8 val_l)
+{
+        if (val_h & 0x80)
+                return (val_h - 0x100) * 1000;
+        return temp_from_reg_unsigned(val_h, val_l);
+}
+
+static struct lm95245_data *lm95245_update_device(struct device *dev)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct lm95245_data *data = i2c_get_clientdata(client);
+
+        mutex_lock(&data->update_lock);
+
+        if (time_after(jiffies, data->last_updated
+                + msecs_to_jiffies(data->interval)) || !data->valid) {
+                int i;
+
+                dev_dbg(&client->dev, "Updating lm95245 data.\n");
+                for (i = 0; i < ARRAY_SIZE(lm95245_reg_address); i++)
+                        data->regs[i]
+                          = i2c_smbus_read_byte_data(client,
+                                                     lm95245_reg_address[i]);
+                data->last_updated = jiffies;
+                data->valid = 1;
+        }
+
+        mutex_unlock(&data->update_lock);
+
+        return data;
+}
+
+static unsigned long lm95245_read_conversion_rate(struct i2c_client *client)
+{
+        int rate;
+        unsigned long interval;
+
+        rate = i2c_smbus_read_byte_data(client, LM95245_REG_RW_CONVERS_RATE);
+
+        switch (rate) {
+        case RATE_CR0063:
+                interval = 63;
+                break;
+        case RATE_CR0364:
+                interval = 364;
+                break;
+        case RATE_CR1000:
+                interval = 1000;
+                break;
+        case RATE_CR2500:
+        default:
+                interval = 2500;
+                break;
+        }
+
+        return interval;
+}
+
+static unsigned long lm95245_set_conversion_rate(struct i2c_client *client,
+                        unsigned long interval)
+{
+        int rate;
+
+        if (interval <= 63) {
+                interval = 63;
+                rate = RATE_CR0063;
+        } else if (interval <= 364) {
+                interval = 364;
+                rate = RATE_CR0364;
+        } else if (interval <= 1000) {
+                interval = 1000;
+                rate = RATE_CR1000;
+        } else {
+                interval = 2500;
+                rate = RATE_CR2500;
+        }
+
+        i2c_smbus_write_byte_data(client, LM95245_REG_RW_CONVERS_RATE, rate);
+
+        return interval;
+}
+
+/* Sysfs stuff */
+static ssize_t show_input(struct device *dev, struct device_attribute *attr,
+                          char *buf)
+{
+        struct lm95245_data *data = lm95245_update_device(dev);
+        int temp;
+        int index = to_sensor_dev_attr(attr)->index;
+
+        /*
+         * Index 0 (Local temp) is always signed
+         * Index 2 (Remote temp) has both signed and unsigned data
+         * use signed calculation for remote if signed bit is set
+         */
+        if (index == 0 || data->regs[index] & 0x80)
+                temp = temp_from_reg_signed(data->regs[index],
+                            data->regs[index + 1]);
+        else
+                temp = temp_from_reg_unsigned(data->regs[index + 2],
+                            data->regs[index + 3]);
+
+        return snprintf(buf, PAGE_SIZE - 1, "%d\n", temp);
+}
+
+static ssize_t show_limit(struct device *dev, struct device_attribute *attr,
+                         char *buf)
+{
+        struct lm95245_data *data = lm95245_update_device(dev);
+        int index = to_sensor_dev_attr(attr)->index;
+
+        return snprintf(buf, PAGE_SIZE - 1, "%d\n",
+                        data->regs[index] * 1000);
+}
+
+static ssize_t set_limit(struct device *dev, struct device_attribute *attr,
+                        const char *buf, size_t count)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct lm95245_data *data = i2c_get_clientdata(client);
+        int index = to_sensor_dev_attr(attr)->index;
+        unsigned long val;
+
+        if (strict_strtoul(buf, 10, &val) < 0)
+                return -EINVAL;
+
+        val /= 1000;
+
+        val = SENSORS_LIMIT(val, 0, (index == 6 ? 127 : 255));
+
+        mutex_lock(&data->update_lock);
+
+        data->valid = 0;
+
+        i2c_smbus_write_byte_data(client, lm95245_reg_address[index], val);
+
+        mutex_unlock(&data->update_lock);
+
+        return count;
+}
+
+static ssize_t set_crit_hyst(struct device *dev, struct device_attribute *attr,
+                        const char *buf, size_t count)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct lm95245_data *data = i2c_get_clientdata(client);
+        unsigned long val;
+
+        if (strict_strtoul(buf, 10, &val) < 0)
+                return -EINVAL;
+
+        val /= 1000;
+
+        val = SENSORS_LIMIT(val, 0, 31);
+
+        mutex_lock(&data->update_lock);
+
+        data->valid = 0;
+
+        /* shared crit hysteresis */
+        i2c_smbus_write_byte_data(client, LM95245_REG_RW_COMMON_HYSTERESIS,
+                val);
+
+        mutex_unlock(&data->update_lock);
+
+        return count;
+}
+
+static ssize_t show_type(struct device *dev, struct device_attribute *attr,
+                         char *buf)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct lm95245_data *data = i2c_get_clientdata(client);
+
+        return snprintf(buf, PAGE_SIZE - 1,
+                data->config2 & CFG2_REMOTE_TT ? "1\n" : "2\n");
+}
+
+static ssize_t set_type(struct device *dev, struct device_attribute *attr,
+                        const char *buf, size_t count)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct lm95245_data *data = i2c_get_clientdata(client);
+        unsigned long val;
+
+        if (strict_strtoul(buf, 10, &val) < 0)
+                return -EINVAL;
+        if (val != 1 && val != 2)
+                return -EINVAL;
+
+        mutex_lock(&data->update_lock);
+
+        if (val == 1)
+                data->config2 |= CFG2_REMOTE_TT;
+        else
+                data->config2 &= ~CFG2_REMOTE_TT;
+
+        data->valid = 0;
+
+        i2c_smbus_write_byte_data(client, LM95245_REG_RW_CONFIG2,
+                                  data->config2);
+
+        mutex_unlock(&data->update_lock);
+
+        return count;
+}
+
+static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
+                         char *buf)
+{
+        struct lm95245_data *data = lm95245_update_device(dev);
+        int index = to_sensor_dev_attr(attr)->index;
+
+        return snprintf(buf, PAGE_SIZE - 1, "%d\n",
+                        !!(data->regs[9] & index));
+}
+
+static ssize_t show_interval(struct device *dev, struct device_attribute *attr,
+                             char *buf)
+{
+        struct lm95245_data *data = lm95245_update_device(dev);
+
+        return snprintf(buf, PAGE_SIZE - 1, "%lu\n", data->interval);
+}
+
+static ssize_t set_interval(struct device *dev, struct device_attribute *attr,
+                            const char *buf, size_t count)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct lm95245_data *data = i2c_get_clientdata(client);
+        unsigned long val;
+
+        if (strict_strtoul(buf, 10, &val) < 0)
+                return -EINVAL;
+
+        mutex_lock(&data->update_lock);
+
+        data->interval = lm95245_set_conversion_rate(client, val);
+
+        mutex_unlock(&data->update_lock);
+
+        return count;
+}
+
+static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_input, NULL, 0);
+static SENSOR_DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_limit,
+                set_limit, 6);
+static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO, show_limit,
+                set_crit_hyst, 8);
+static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL,
+                STATUS1_LOC);
+
+static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_input, NULL, 2);
+static SENSOR_DEVICE_ATTR(temp2_crit, S_IWUSR | S_IRUGO, show_limit,
+                set_limit, 7);
+static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IWUSR | S_IRUGO, show_limit,
+                set_crit_hyst, 8);
+static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL,
+                STATUS1_RTCRIT);
+static SENSOR_DEVICE_ATTR(temp2_type, S_IWUSR | S_IRUGO, show_type,
+                set_type, 0);
+static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL,
+                STATUS1_DIODE_FAULT);
+
+static DEVICE_ATTR(update_interval, S_IWUSR | S_IRUGO, show_interval,
+                set_interval);
+
+static struct attribute *lm95245_attributes[] = {
+        &sensor_dev_attr_temp1_input.dev_attr.attr,
+        &sensor_dev_attr_temp1_crit.dev_attr.attr,
+        &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr,
+        &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp2_input.dev_attr.attr,
+        &sensor_dev_attr_temp2_crit.dev_attr.attr,
+        &sensor_dev_attr_temp2_crit_hyst.dev_attr.attr,
+        &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp2_type.dev_attr.attr,
+        &sensor_dev_attr_temp2_fault.dev_attr.attr,
+        &dev_attr_update_interval.attr,
+        NULL
+};
+
+static const struct attribute_group lm95245_group = {
+        .attrs = lm95245_attributes,
+};
+
+/* Return 0 if detection is successful, -ENODEV otherwise */
+static int lm95245_detect(struct i2c_client *new_client,
+                          struct i2c_board_info *info)
+{
+        struct i2c_adapter *adapter = new_client->adapter;
+
+        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
+                return -ENODEV;
+
+        if (i2c_smbus_read_byte_data(new_client, LM95245_REG_R_MAN_ID)
+                        != MANUFACTURER_ID
+                || i2c_smbus_read_byte_data(new_client, LM95245_REG_R_CHIP_ID)
+                        != DEFAULT_REVISION)
+                return -ENODEV;
+
+        strlcpy(info->type, DEVNAME, I2C_NAME_SIZE);
+        return 0;
+}
+
+static void lm95245_init_client(struct i2c_client *client)
+{
+        struct lm95245_data *data = i2c_get_clientdata(client);
+
+        data->valid = 0;
+        data->interval = lm95245_read_conversion_rate(client);
+
+        data->config1 = i2c_smbus_read_byte_data(client,
+                LM95245_REG_RW_CONFIG1);
+        data->config2 = i2c_smbus_read_byte_data(client,
+                LM95245_REG_RW_CONFIG2);
+
+        if (data->config1 & CFG_STOP) {
+                /* Clear the standby bit */
+                data->config1 &= ~CFG_STOP;
+                i2c_smbus_write_byte_data(client, LM95245_REG_RW_CONFIG1,
+                        data->config1);
+        }
+}
+
+static int lm95245_probe(struct i2c_client *new_client,
+                         const struct i2c_device_id *id)
+{
+        struct lm95245_data *data;
+        int err;
+
+        data = kzalloc(sizeof(struct lm95245_data), GFP_KERNEL);
+        if (!data) {
+                err = -ENOMEM;
+                goto exit;
+        }
+
+        i2c_set_clientdata(new_client, data);
+        mutex_init(&data->update_lock);
+
+        /* Initialize the LM95245 chip */
+        lm95245_init_client(new_client);
+
+        /* Register sysfs hooks */
+        err = sysfs_create_group(&new_client->dev.kobj, &lm95245_group);
+        if (err)
+                goto exit_free;
+
+        data->hwmon_dev = hwmon_device_register(&new_client->dev);
+        if (IS_ERR(data->hwmon_dev)) {
+                err = PTR_ERR(data->hwmon_dev);
+                goto exit_remove_files;
+        }
+
+        return 0;
+
+exit_remove_files:
+        sysfs_remove_group(&new_client->dev.kobj, &lm95245_group);
+exit_free:
+        kfree(data);
+exit:
+        return err;
+}
+
+static int lm95245_remove(struct i2c_client *client)
+{
+        struct lm95245_data *data = i2c_get_clientdata(client);
+
+        hwmon_device_unregister(data->hwmon_dev);
+        sysfs_remove_group(&client->dev.kobj, &lm95245_group);
+
+        kfree(data);
+        return 0;
+}
+
+/* Driver data (common to all clients) */
+static const struct i2c_device_id lm95245_id[] = {
+        { DEVNAME, 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, lm95245_id);
+
+static struct i2c_driver lm95245_driver = {
+        .class          = I2C_CLASS_HWMON,
+        .driver = {
+                .name   = DEVNAME,
+        },
+        .probe          = lm95245_probe,
+        .remove         = lm95245_remove,
+        .id_table       = lm95245_id,
+        .detect         = lm95245_detect,
+        .address_list   = normal_i2c,
+};
+
+static int __init sensors_lm95245_init(void)
+{
+        return i2c_add_driver(&lm95245_driver);
+}
+
+static void __exit sensors_lm95245_exit(void)
+{
+        i2c_del_driver(&lm95245_driver);
+}
+
+MODULE_AUTHOR("Alexander Stein <alexander.stein@systec-electronic.com>");
+MODULE_DESCRIPTION("LM95245 sensor driver");
+MODULE_LICENSE("GPL");
+
+module_init(sensors_lm95245_init);
+module_exit(sensors_lm95245_exit);
diff --git a/drivers/hwmon/max16065.c b/drivers/hwmon/max16065.c
index d94a24fdf4ba..dd2d7b9620c2 100644
--- a/drivers/hwmon/max16065.c
+++ b/drivers/hwmon/max16065.c
@@ -124,7 +124,7 @@ static inline int MV_TO_LIMIT(int mv, int range)
 
 static inline int ADC_TO_CURR(int adc, int gain)
 {
-        return adc * 1400000 / gain * 255;
+        return adc * 1400000 / (gain * 255);
 }
 
 /*
diff --git a/drivers/hwmon/max1668.c b/drivers/hwmon/max1668.c
new file mode 100644
index 000000000000..20d1b2ddffb6
--- /dev/null
+++ b/drivers/hwmon/max1668.c
@@ -0,0 +1,502 @@
+/*
+    Copyright (c) 2011 David George <david.george@ska.ac.za>
+
+    based on adm1021.c
+    some credit to Christoph Scheurer, but largely a rewrite
+
+    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.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/jiffies.h>
+#include <linux/i2c.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
+#include <linux/err.h>
+#include <linux/mutex.h>
+
+/* Addresses to scan */
+static unsigned short max1668_addr_list[] = {
+        0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b, 0x4c, 0x4d, 0x4e, I2C_CLIENT_END };
+
+/* max1668 registers */
+
+#define MAX1668_REG_TEMP(nr)    (nr)
+#define MAX1668_REG_STAT1       0x05
+#define MAX1668_REG_STAT2       0x06
+#define MAX1668_REG_MAN_ID      0xfe
+#define MAX1668_REG_DEV_ID      0xff
+
+/* limits */
+
+/* write high limits */
+#define MAX1668_REG_LIMH_WR(nr) (0x13 + 2 * (nr))
+/* write low limits */
+#define MAX1668_REG_LIML_WR(nr) (0x14 + 2 * (nr))
+/* read high limits */
+#define MAX1668_REG_LIMH_RD(nr) (0x08 + 2 * (nr))
+/* read low limits */
+#define MAX1668_REG_LIML_RD(nr) (0x09 + 2 * (nr))
+
+/* manufacturer and device ID Constants */
+#define MAN_ID_MAXIM            0x4d
+#define DEV_ID_MAX1668          0x3
+#define DEV_ID_MAX1805          0x5
+#define DEV_ID_MAX1989          0xb
+
+/* read only mode module parameter */
+static int read_only;
+module_param(read_only, bool, 0);
+MODULE_PARM_DESC(read_only, "Don't set any values, read only mode");
+
+enum chips { max1668, max1805, max1989 };
+
+struct max1668_data {
+        struct device *hwmon_dev;
+        enum chips type;
+
+        struct mutex update_lock;
+        char valid;             /* !=0 if following fields are valid */
+        unsigned long last_updated;     /* In jiffies */
+
+        /* 1x local and 4x remote */
+        s8 temp_max[5];
+        s8 temp_min[5];
+        s8 temp[5];
+        u16 alarms;
+};
+
+static struct max1668_data *max1668_update_device(struct device *dev)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct max1668_data *data = i2c_get_clientdata(client);
+        struct max1668_data *ret = data;
+        s32 val;
+        int i;
+
+        mutex_lock(&data->update_lock);
+
+        if (data->valid && !time_after(jiffies,
+                        data->last_updated + HZ + HZ / 2))
+                goto abort;
+
+        for (i = 0; i < 5; i++) {
+                val = i2c_smbus_read_byte_data(client, MAX1668_REG_TEMP(i));
+                if (unlikely(val < 0)) {
+                        ret = ERR_PTR(val);
+                        goto abort;
+                }
+                data->temp[i] = (s8) val;
+
+                val = i2c_smbus_read_byte_data(client, MAX1668_REG_LIMH_RD(i));
+                if (unlikely(val < 0)) {
+                        ret = ERR_PTR(val);
+                        goto abort;
+                }
+                data->temp_max[i] = (s8) val;
+
+                val = i2c_smbus_read_byte_data(client, MAX1668_REG_LIML_RD(i));
+                if (unlikely(val < 0)) {
+                        ret = ERR_PTR(val);
+                        goto abort;
+                }
+                data->temp_min[i] = (s8) val;
+        }
+
+        val = i2c_smbus_read_byte_data(client, MAX1668_REG_STAT1);
+        if (unlikely(val < 0)) {
+                ret = ERR_PTR(val);
+                goto abort;
+        }
+        data->alarms = val << 8;
+
+        val = i2c_smbus_read_byte_data(client, MAX1668_REG_STAT2);
+        if (unlikely(val < 0)) {
+                ret = ERR_PTR(val);
+                goto abort;
+        }
+        data->alarms |= val;
+
+        data->last_updated = jiffies;
+        data->valid = 1;
+abort:
+        mutex_unlock(&data->update_lock);
+
+        return ret;
+}
+
+static ssize_t show_temp(struct device *dev,
+                         struct device_attribute *devattr, char *buf)
+{
+        int index = to_sensor_dev_attr(devattr)->index;
+        struct max1668_data *data = max1668_update_device(dev);
+
+        if (IS_ERR(data))
+                return PTR_ERR(data);
+
+        return sprintf(buf, "%d\n", data->temp[index] * 1000);
+}
+
+static ssize_t show_temp_max(struct device *dev,
+                             struct device_attribute *devattr, char *buf)
+{
+        int index = to_sensor_dev_attr(devattr)->index;
+        struct max1668_data *data = max1668_update_device(dev);
+
+        if (IS_ERR(data))
+                return PTR_ERR(data);
+
+        return sprintf(buf, "%d\n", data->temp_max[index] * 1000);
+}
+
+static ssize_t show_temp_min(struct device *dev,
+                             struct device_attribute *devattr, char *buf)
+{
+        int index = to_sensor_dev_attr(devattr)->index;
+        struct max1668_data *data = max1668_update_device(dev);
+
+        if (IS_ERR(data))
+                return PTR_ERR(data);
+
+        return sprintf(buf, "%d\n", data->temp_min[index] * 1000);
+}
+
+static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
+                          char *buf)
+{
+        int index = to_sensor_dev_attr(attr)->index;
+        struct max1668_data *data = max1668_update_device(dev);
+
+        if (IS_ERR(data))
+                return PTR_ERR(data);
+
+        return sprintf(buf, "%u\n", (data->alarms >> index) & 0x1);
+}
+
+static ssize_t show_fault(struct device *dev,
+                          struct device_attribute *devattr, char *buf)
+{
+        int index = to_sensor_dev_attr(devattr)->index;
+        struct max1668_data *data = max1668_update_device(dev);
+
+        if (IS_ERR(data))
+                return PTR_ERR(data);
+
+        return sprintf(buf, "%u\n",
+                       (data->alarms & (1 << 12)) && data->temp[index] == 127);
+}
+
+static ssize_t set_temp_max(struct device *dev,
+                            struct device_attribute *devattr,
+                            const char *buf, size_t count)
+{
+        int index = to_sensor_dev_attr(devattr)->index;
+        struct i2c_client *client = to_i2c_client(dev);
+        struct max1668_data *data = i2c_get_clientdata(client);
+        long temp;
+        int ret;
+
+        ret = kstrtol(buf, 10, &temp);
+        if (ret < 0)
+                return ret;
+
+        mutex_lock(&data->update_lock);
+        data->temp_max[index] = SENSORS_LIMIT(temp/1000, -128, 127);
+        if (i2c_smbus_write_byte_data(client,
+                                        MAX1668_REG_LIMH_WR(index),
+                                        data->temp_max[index]))
+                count = -EIO;
+        mutex_unlock(&data->update_lock);
+
+        return count;
+}
+
+static ssize_t set_temp_min(struct device *dev,
+                            struct device_attribute *devattr,
+                            const char *buf, size_t count)
+{
+        int index = to_sensor_dev_attr(devattr)->index;
+        struct i2c_client *client = to_i2c_client(dev);
+        struct max1668_data *data = i2c_get_clientdata(client);
+        long temp;
+        int ret;
+
+        ret = kstrtol(buf, 10, &temp);
+        if (ret < 0)
+                return ret;
+
+        mutex_lock(&data->update_lock);
+        data->temp_min[index] = SENSORS_LIMIT(temp/1000, -128, 127);
+        if (i2c_smbus_write_byte_data(client,
+                                        MAX1668_REG_LIML_WR(index),
+                                        data->temp_max[index]))
+                count = -EIO;
+        mutex_unlock(&data->update_lock);
+
+        return count;
+}
+
+static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
+static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO, show_temp_max,
+                                set_temp_max, 0);
+static SENSOR_DEVICE_ATTR(temp1_min, S_IRUGO, show_temp_min,
+                                set_temp_min, 0);
+static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1);
+static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO, show_temp_max,
+                                set_temp_max, 1);
+static SENSOR_DEVICE_ATTR(temp2_min, S_IRUGO, show_temp_min,
+                                set_temp_min, 1);
+static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2);
+static SENSOR_DEVICE_ATTR(temp3_max, S_IRUGO, show_temp_max,
+                                set_temp_max, 2);
+static SENSOR_DEVICE_ATTR(temp3_min, S_IRUGO, show_temp_min,
+                                set_temp_min, 2);
+static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, show_temp, NULL, 3);
+static SENSOR_DEVICE_ATTR(temp4_max, S_IRUGO, show_temp_max,
+                                set_temp_max, 3);
+static SENSOR_DEVICE_ATTR(temp4_min, S_IRUGO, show_temp_min,
+                                set_temp_min, 3);
+static SENSOR_DEVICE_ATTR(temp5_input, S_IRUGO, show_temp, NULL, 4);
+static SENSOR_DEVICE_ATTR(temp5_max, S_IRUGO, show_temp_max,
+                                set_temp_max, 4);
+static SENSOR_DEVICE_ATTR(temp5_min, S_IRUGO, show_temp_min,
+                                set_temp_min, 4);
+
+static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 14);
+static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 13);
+static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 7);
+static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 6);
+static SENSOR_DEVICE_ATTR(temp3_min_alarm, S_IRUGO, show_alarm, NULL, 5);
+static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO, show_alarm, NULL, 4);
+static SENSOR_DEVICE_ATTR(temp4_min_alarm, S_IRUGO, show_alarm, NULL, 3);
+static SENSOR_DEVICE_ATTR(temp4_max_alarm, S_IRUGO, show_alarm, NULL, 2);
+static SENSOR_DEVICE_ATTR(temp5_min_alarm, S_IRUGO, show_alarm, NULL, 1);
+static SENSOR_DEVICE_ATTR(temp5_max_alarm, S_IRUGO, show_alarm, NULL, 0);
+
+static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_fault, NULL, 1);
+static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_fault, NULL, 2);
+static SENSOR_DEVICE_ATTR(temp4_fault, S_IRUGO, show_fault, NULL, 3);
+static SENSOR_DEVICE_ATTR(temp5_fault, S_IRUGO, show_fault, NULL, 4);
+
+/* Attributes common to MAX1668, MAX1989 and MAX1805 */
+static struct attribute *max1668_attribute_common[] = {
+        &sensor_dev_attr_temp1_max.dev_attr.attr,
+        &sensor_dev_attr_temp1_min.dev_attr.attr,
+        &sensor_dev_attr_temp1_input.dev_attr.attr,
+        &sensor_dev_attr_temp2_max.dev_attr.attr,
+        &sensor_dev_attr_temp2_min.dev_attr.attr,
+        &sensor_dev_attr_temp2_input.dev_attr.attr,
+        &sensor_dev_attr_temp3_max.dev_attr.attr,
+        &sensor_dev_attr_temp3_min.dev_attr.attr,
+        &sensor_dev_attr_temp3_input.dev_attr.attr,
+
+        &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp3_min_alarm.dev_attr.attr,
+
+        &sensor_dev_attr_temp2_fault.dev_attr.attr,
+        &sensor_dev_attr_temp3_fault.dev_attr.attr,
+        NULL
+};
+
+/* Attributes not present on MAX1805 */
+static struct attribute *max1668_attribute_unique[] = {
+        &sensor_dev_attr_temp4_max.dev_attr.attr,
+        &sensor_dev_attr_temp4_min.dev_attr.attr,
+        &sensor_dev_attr_temp4_input.dev_attr.attr,
+        &sensor_dev_attr_temp5_max.dev_attr.attr,
+        &sensor_dev_attr_temp5_min.dev_attr.attr,
+        &sensor_dev_attr_temp5_input.dev_attr.attr,
+
+        &sensor_dev_attr_temp4_max_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp4_min_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp5_max_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp5_min_alarm.dev_attr.attr,
+
+        &sensor_dev_attr_temp4_fault.dev_attr.attr,
+        &sensor_dev_attr_temp5_fault.dev_attr.attr,
+        NULL
+};
+
+static mode_t max1668_attribute_mode(struct kobject *kobj,
+                                     struct attribute *attr, int index)
+{
+        int ret = S_IRUGO;
+        if (read_only)
+                return ret;
+        if (attr == &sensor_dev_attr_temp1_max.dev_attr.attr ||
+            attr == &sensor_dev_attr_temp2_max.dev_attr.attr ||
+            attr == &sensor_dev_attr_temp3_max.dev_attr.attr ||
+            attr == &sensor_dev_attr_temp4_max.dev_attr.attr ||
+            attr == &sensor_dev_attr_temp5_max.dev_attr.attr ||
+            attr == &sensor_dev_attr_temp1_min.dev_attr.attr ||
+            attr == &sensor_dev_attr_temp2_min.dev_attr.attr ||
+            attr == &sensor_dev_attr_temp3_min.dev_attr.attr ||
+            attr == &sensor_dev_attr_temp4_min.dev_attr.attr ||
+            attr == &sensor_dev_attr_temp5_min.dev_attr.attr)
+                ret |= S_IWUSR;
+        return ret;
+}
+
+static const struct attribute_group max1668_group_common = {
+        .attrs = max1668_attribute_common,
+        .is_visible = max1668_attribute_mode
+};
+
+static const struct attribute_group max1668_group_unique = {
+        .attrs = max1668_attribute_unique,
+        .is_visible = max1668_attribute_mode
+};
+
+/* Return 0 if detection is successful, -ENODEV otherwise */
+static int max1668_detect(struct i2c_client *client,
+                          struct i2c_board_info *info)
+{
+        struct i2c_adapter *adapter = client->adapter;
+        const char *type_name;
+        int man_id, dev_id;
+
+        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
+                return -ENODEV;
+
+        /* Check for unsupported part */
+        man_id = i2c_smbus_read_byte_data(client, MAX1668_REG_MAN_ID);
+        if (man_id != MAN_ID_MAXIM)
+                return -ENODEV;
+
+        dev_id = i2c_smbus_read_byte_data(client, MAX1668_REG_DEV_ID);
+        if (dev_id < 0)
+                return -ENODEV;
+
+        type_name = NULL;
+        if (dev_id == DEV_ID_MAX1668)
+                type_name = "max1668";
+        else if (dev_id == DEV_ID_MAX1805)
+                type_name = "max1805";
+        else if (dev_id == DEV_ID_MAX1989)
+                type_name = "max1989";
+
+        if (!type_name)
+                return -ENODEV;
+
+        strlcpy(info->type, type_name, I2C_NAME_SIZE);
+
+        return 0;
+}
+
+static int max1668_probe(struct i2c_client *client,
+                         const struct i2c_device_id *id)
+{
+        struct i2c_adapter *adapter = client->adapter;
+        struct max1668_data *data;
+        int err;
+
+        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
+                return -ENODEV;
+
+        data = kzalloc(sizeof(struct max1668_data), GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+
+        i2c_set_clientdata(client, data);
+        data->type = id->driver_data;
+        mutex_init(&data->update_lock);
+
+        /* Register sysfs hooks */
+        err = sysfs_create_group(&client->dev.kobj, &max1668_group_common);
+        if (err)
+                goto error_free;
+
+        if (data->type == max1668 || data->type == max1989) {
+                err = sysfs_create_group(&client->dev.kobj,
+                                         &max1668_group_unique);
+                if (err)
+                        goto error_sysrem0;
+        }
+
+        data->hwmon_dev = hwmon_device_register(&client->dev);
+        if (IS_ERR(data->hwmon_dev)) {
+                err = PTR_ERR(data->hwmon_dev);
+                goto error_sysrem1;
+        }
+
+        return 0;
+
+error_sysrem1:
+        if (data->type == max1668 || data->type == max1989)
+                sysfs_remove_group(&client->dev.kobj, &max1668_group_unique);
+error_sysrem0:
+        sysfs_remove_group(&client->dev.kobj, &max1668_group_common);
+error_free:
+        kfree(data);
+        return err;
+}
+
+static int max1668_remove(struct i2c_client *client)
+{
+        struct max1668_data *data = i2c_get_clientdata(client);
+
+        hwmon_device_unregister(data->hwmon_dev);
+        if (data->type == max1668 || data->type == max1989)
+                sysfs_remove_group(&client->dev.kobj, &max1668_group_unique);
+
+        sysfs_remove_group(&client->dev.kobj, &max1668_group_common);
+
+        kfree(data);
+        return 0;
+}
+
+static const struct i2c_device_id max1668_id[] = {
+        { "max1668", max1668 },
+        { "max1805", max1805 },
+        { "max1989", max1989 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, max1668_id);
+
+/* This is the driver that will be inserted */
+static struct i2c_driver max1668_driver = {
+        .class = I2C_CLASS_HWMON,
+        .driver = {
+                  .name = "max1668",
+                  },
+        .probe = max1668_probe,
+        .remove = max1668_remove,
+        .id_table = max1668_id,
+        .detect = max1668_detect,
+        .address_list = max1668_addr_list,
+};
+
+static int __init sensors_max1668_init(void)
+{
+        return i2c_add_driver(&max1668_driver);
+}
+
+static void __exit sensors_max1668_exit(void)
+{
+        i2c_del_driver(&max1668_driver);
+}
+
+MODULE_AUTHOR("David George <david.george@ska.ac.za>");
+MODULE_DESCRIPTION("MAX1668 remote temperature sensor driver");
+MODULE_LICENSE("GPL");
+
+module_init(sensors_max1668_init)
+module_exit(sensors_max1668_exit)
diff --git a/drivers/hwmon/ntc_thermistor.c b/drivers/hwmon/ntc_thermistor.c
new file mode 100644
index 000000000000..eab11615dced
--- /dev/null
+++ b/drivers/hwmon/ntc_thermistor.c
@@ -0,0 +1,452 @@
+/*
+ * ntc_thermistor.c - NTC Thermistors
+ *
+ *  Copyright (C) 2010 Samsung Electronics
+ *  MyungJoo Ham <myungjoo.ham@samsung.com>
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/pm_runtime.h>
+#include <linux/math64.h>
+#include <linux/platform_device.h>
+#include <linux/err.h>
+
+#include <linux/platform_data/ntc_thermistor.h>
+
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
+
+struct ntc_compensation {
+        int             temp_C;
+        unsigned int    ohm;
+};
+
+/*
+ * A compensation table should be sorted by the values of .ohm
+ * in descending order.
+ * The following compensation tables are from the specification of Murata NTC
+ * Thermistors Datasheet
+ */
+const struct ntc_compensation ncpXXwb473[] = {
+        { .temp_C       = -40, .ohm     = 1747920 },
+        { .temp_C       = -35, .ohm     = 1245428 },
+        { .temp_C       = -30, .ohm     = 898485 },
+        { .temp_C       = -25, .ohm     = 655802 },
+        { .temp_C       = -20, .ohm     = 483954 },
+        { .temp_C       = -15, .ohm     = 360850 },
+        { .temp_C       = -10, .ohm     = 271697 },
+        { .temp_C       = -5, .ohm      = 206463 },
+        { .temp_C       = 0, .ohm       = 158214 },
+        { .temp_C       = 5, .ohm       = 122259 },
+        { .temp_C       = 10, .ohm      = 95227 },
+        { .temp_C       = 15, .ohm      = 74730 },
+        { .temp_C       = 20, .ohm      = 59065 },
+        { .temp_C       = 25, .ohm      = 47000 },
+        { .temp_C       = 30, .ohm      = 37643 },
+        { .temp_C       = 35, .ohm      = 30334 },
+        { .temp_C       = 40, .ohm      = 24591 },
+        { .temp_C       = 45, .ohm      = 20048 },
+        { .temp_C       = 50, .ohm      = 16433 },
+        { .temp_C       = 55, .ohm      = 13539 },
+        { .temp_C       = 60, .ohm      = 11209 },
+        { .temp_C       = 65, .ohm      = 9328 },
+        { .temp_C       = 70, .ohm      = 7798 },
+        { .temp_C       = 75, .ohm      = 6544 },
+        { .temp_C       = 80, .ohm      = 5518 },
+        { .temp_C       = 85, .ohm      = 4674 },
+        { .temp_C       = 90, .ohm      = 3972 },
+        { .temp_C       = 95, .ohm      = 3388 },
+        { .temp_C       = 100, .ohm     = 2902 },
+        { .temp_C       = 105, .ohm     = 2494 },
+        { .temp_C       = 110, .ohm     = 2150 },
+        { .temp_C       = 115, .ohm     = 1860 },
+        { .temp_C       = 120, .ohm     = 1615 },
+        { .temp_C       = 125, .ohm     = 1406 },
+};
+const struct ntc_compensation ncpXXwl333[] = {
+        { .temp_C       = -40, .ohm     = 1610154 },
+        { .temp_C       = -35, .ohm     = 1130850 },
+        { .temp_C       = -30, .ohm     = 802609 },
+        { .temp_C       = -25, .ohm     = 575385 },
+        { .temp_C       = -20, .ohm     = 416464 },
+        { .temp_C       = -15, .ohm     = 304219 },
+        { .temp_C       = -10, .ohm     = 224193 },
+        { .temp_C       = -5, .ohm      = 166623 },
+        { .temp_C       = 0, .ohm       = 124850 },
+        { .temp_C       = 5, .ohm       = 94287 },
+        { .temp_C       = 10, .ohm      = 71747 },
+        { .temp_C       = 15, .ohm      = 54996 },
+        { .temp_C       = 20, .ohm      = 42455 },
+        { .temp_C       = 25, .ohm      = 33000 },
+        { .temp_C       = 30, .ohm      = 25822 },
+        { .temp_C       = 35, .ohm      = 20335 },
+        { .temp_C       = 40, .ohm      = 16115 },
+        { .temp_C       = 45, .ohm      = 12849 },
+        { .temp_C       = 50, .ohm      = 10306 },
+        { .temp_C       = 55, .ohm      = 8314 },
+        { .temp_C       = 60, .ohm      = 6746 },
+        { .temp_C       = 65, .ohm      = 5503 },
+        { .temp_C       = 70, .ohm      = 4513 },
+        { .temp_C       = 75, .ohm      = 3721 },
+        { .temp_C       = 80, .ohm      = 3084 },
+        { .temp_C       = 85, .ohm      = 2569 },
+        { .temp_C       = 90, .ohm      = 2151 },
+        { .temp_C       = 95, .ohm      = 1809 },
+        { .temp_C       = 100, .ohm     = 1529 },
+        { .temp_C       = 105, .ohm     = 1299 },
+        { .temp_C       = 110, .ohm     = 1108 },
+        { .temp_C       = 115, .ohm     = 949 },
+        { .temp_C       = 120, .ohm     = 817 },
+        { .temp_C       = 125, .ohm     = 707 },
+};
+
+struct ntc_data {
+        struct device *hwmon_dev;
+        struct ntc_thermistor_platform_data *pdata;
+        const struct ntc_compensation *comp;
+        struct device *dev;
+        int n_comp;
+        char name[PLATFORM_NAME_SIZE];
+};
+
+static inline u64 div64_u64_safe(u64 dividend, u64 divisor)
+{
+        if (divisor == 0 && dividend == 0)
+                return 0;
+        if (divisor == 0)
+                return UINT_MAX;
+        return div64_u64(dividend, divisor);
+}
+
+static unsigned int get_ohm_of_thermistor(struct ntc_data *data,
+                unsigned int uV)
+{
+        struct ntc_thermistor_platform_data *pdata = data->pdata;
+        u64 mV = uV / 1000;
+        u64 pmV = pdata->pullup_uV / 1000;
+        u64 N, puO, pdO;
+        puO = pdata->pullup_ohm;
+        pdO = pdata->pulldown_ohm;
+
+        if (mV == 0) {
+                if (pdata->connect == NTC_CONNECTED_POSITIVE)
+                        return UINT_MAX;
+                return 0;
+        }
+        if (mV >= pmV)
+                return (pdata->connect == NTC_CONNECTED_POSITIVE) ?
+                        0 : UINT_MAX;
+
+        if (pdata->connect == NTC_CONNECTED_POSITIVE && puO == 0)
+                N = div64_u64_safe(pdO * (pmV - mV), mV);
+        else if (pdata->connect == NTC_CONNECTED_GROUND && pdO == 0)
+                N = div64_u64_safe(puO * mV, pmV - mV);
+        else if (pdata->connect == NTC_CONNECTED_POSITIVE)
+                N = div64_u64_safe(pdO * puO * (pmV - mV),
+                                puO * mV - pdO * (pmV - mV));
+        else
+                N = div64_u64_safe(pdO * puO * mV, pdO * (pmV - mV) - puO * mV);
+
+        return (unsigned int) N;
+}
+
+static int lookup_comp(struct ntc_data *data,
+                unsigned int ohm, int *i_low, int *i_high)
+{
+        int start, end, mid = -1;
+
+        /* Do a binary search on compensation table */
+        start = 0;
+        end = data->n_comp;
+
+        while (end > start) {
+                mid = start + (end - start) / 2;
+                if (data->comp[mid].ohm < ohm)
+                        end = mid;
+                else if (data->comp[mid].ohm > ohm)
+                        start = mid + 1;
+                else
+                        break;
+        }
+
+        if (mid == 0) {
+                if (data->comp[mid].ohm > ohm) {
+                        *i_high = mid;
+                        *i_low = mid + 1;
+                        return 0;
+                } else {
+                        *i_low = mid;
+                        *i_high = -1;
+                        return -EINVAL;
+                }
+        }
+        if (mid == (data->n_comp - 1)) {
+                if (data->comp[mid].ohm <= ohm) {
+                        *i_low = mid;
+                        *i_high = mid - 1;
+                        return 0;
+                } else {
+                        *i_low = -1;
+                        *i_high = mid;
+                        return -EINVAL;
+                }
+        }
+
+        if (data->comp[mid].ohm <= ohm) {
+                *i_low = mid;
+                *i_high = mid - 1;
+        } else {
+                *i_low = mid + 1;
+                *i_high = mid;
+        }
+
+        return 0;
+}
+
+static int get_temp_mC(struct ntc_data *data, unsigned int ohm, int *temp)
+{
+        int low, high;
+        int ret;
+
+        ret = lookup_comp(data, ohm, &low, &high);
+        if (ret) {
+                /* Unable to use linear approximation */
+                if (low != -1)
+                        *temp = data->comp[low].temp_C * 1000;
+                else if (high != -1)
+                        *temp = data->comp[high].temp_C * 1000;
+                else
+                        return ret;
+        } else {
+                *temp = data->comp[low].temp_C * 1000 +
+                        ((data->comp[high].temp_C - data->comp[low].temp_C) *
+                         1000 * ((int)ohm - (int)data->comp[low].ohm)) /
+                        ((int)data->comp[high].ohm - (int)data->comp[low].ohm);
+        }
+
+        return 0;
+}
+
+static int ntc_thermistor_read(struct ntc_data *data, int *temp)
+{
+        int ret;
+        int read_ohm, read_uV;
+        unsigned int ohm = 0;
+
+        if (data->pdata->read_ohm) {
+                read_ohm = data->pdata->read_ohm();
+                if (read_ohm < 0)
+                        return read_ohm;
+                ohm = (unsigned int)read_ohm;
+        }
+
+        if (data->pdata->read_uV) {
+                read_uV = data->pdata->read_uV();
+                if (read_uV < 0)
+                        return read_uV;
+                ohm = get_ohm_of_thermistor(data, (unsigned int)read_uV);
+        }
+
+        ret = get_temp_mC(data, ohm, temp);
+        if (ret) {
+                dev_dbg(data->dev, "Sensor reading function not available.\n");
+                return ret;
+        }
+
+        return 0;
+}
+
+static ssize_t ntc_show_name(struct device *dev,
+                struct device_attribute *attr, char *buf)
+{
+        struct ntc_data *data = dev_get_drvdata(dev);
+
+        return sprintf(buf, "%s\n", data->name);
+}
+
+static ssize_t ntc_show_type(struct device *dev,
+                struct device_attribute *attr, char *buf)
+{
+        return sprintf(buf, "4\n");
+}
+
+static ssize_t ntc_show_temp(struct device *dev,
+                struct device_attribute *attr, char *buf)
+{
+        struct ntc_data *data = dev_get_drvdata(dev);
+        int temp, ret;
+
+        ret = ntc_thermistor_read(data, &temp);
+        if (ret)
+                return ret;
+        return sprintf(buf, "%d\n", temp);
+}
+
+static SENSOR_DEVICE_ATTR(temp1_type, S_IRUGO, ntc_show_type, NULL, 0);
+static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, ntc_show_temp, NULL, 0);
+static DEVICE_ATTR(name, S_IRUGO, ntc_show_name, NULL);
+
+static struct attribute *ntc_attributes[] = {
+        &dev_attr_name.attr,
+        &sensor_dev_attr_temp1_type.dev_attr.attr,
+        &sensor_dev_attr_temp1_input.dev_attr.attr,
+        NULL,
+};
+
+static const struct attribute_group ntc_attr_group = {
+        .attrs = ntc_attributes,
+};
+
+static int __devinit ntc_thermistor_probe(struct platform_device *pdev)
+{
+        struct ntc_data *data;
+        struct ntc_thermistor_platform_data *pdata = pdev->dev.platform_data;
+        int ret = 0;
+
+        if (!pdata) {
+                dev_err(&pdev->dev, "No platform init data supplied.\n");
+                return -ENODEV;
+        }
+
+        /* Either one of the two is required. */
+        if (!pdata->read_uV && !pdata->read_ohm) {
+                dev_err(&pdev->dev, "Both read_uV and read_ohm missing."
+                                "Need either one of the two.\n");
+                return -EINVAL;
+        }
+
+        if (pdata->read_uV && pdata->read_ohm) {
+                dev_warn(&pdev->dev, "Only one of read_uV and read_ohm "
+                                "is needed; ignoring read_uV.\n");
+                pdata->read_uV = NULL;
+        }
+
+        if (pdata->read_uV && (pdata->pullup_uV == 0 ||
+                                (pdata->pullup_ohm == 0 && pdata->connect ==
+                                 NTC_CONNECTED_GROUND) ||
+                                (pdata->pulldown_ohm == 0 && pdata->connect ==
+                                 NTC_CONNECTED_POSITIVE) ||
+                                (pdata->connect != NTC_CONNECTED_POSITIVE &&
+                                 pdata->connect != NTC_CONNECTED_GROUND))) {
+                dev_err(&pdev->dev, "Required data to use read_uV not "
+                                "supplied.\n");
+                return -EINVAL;
+        }
+
+        data = kzalloc(sizeof(struct ntc_data), GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+
+        data->dev = &pdev->dev;
+        data->pdata = pdata;
+        strncpy(data->name, pdev->id_entry->name, PLATFORM_NAME_SIZE);
+
+        switch (pdev->id_entry->driver_data) {
+        case TYPE_NCPXXWB473:
+                data->comp = ncpXXwb473;
+                data->n_comp = ARRAY_SIZE(ncpXXwb473);
+                break;
+        case TYPE_NCPXXWL333:
+                data->comp = ncpXXwl333;
+                data->n_comp = ARRAY_SIZE(ncpXXwl333);
+                break;
+        default:
+                dev_err(&pdev->dev, "Unknown device type: %lu(%s)\n",
+                                pdev->id_entry->driver_data,
+                                pdev->id_entry->name);
+                ret = -EINVAL;
+                goto err;
+        }
+
+        platform_set_drvdata(pdev, data);
+
+        ret = sysfs_create_group(&data->dev->kobj, &ntc_attr_group);
+        if (ret) {
+                dev_err(data->dev, "unable to create sysfs files\n");
+                goto err;
+        }
+
+        data->hwmon_dev = hwmon_device_register(data->dev);
+        if (IS_ERR_OR_NULL(data->hwmon_dev)) {
+                dev_err(data->dev, "unable to register as hwmon device.\n");
+                ret = -EINVAL;
+                goto err_after_sysfs;
+        }
+
+        dev_info(&pdev->dev, "Thermistor %s:%d (type: %s/%lu) successfully probed.\n",
+                        pdev->name, pdev->id, pdev->id_entry->name,
+                        pdev->id_entry->driver_data);
+        return 0;
+err_after_sysfs:
+        sysfs_remove_group(&data->dev->kobj, &ntc_attr_group);
+err:
+        kfree(data);
+        return ret;
+}
+
+static int __devexit ntc_thermistor_remove(struct platform_device *pdev)
+{
+        struct ntc_data *data = platform_get_drvdata(pdev);
+
+        hwmon_device_unregister(data->hwmon_dev);
+        sysfs_remove_group(&data->dev->kobj, &ntc_attr_group);
+        platform_set_drvdata(pdev, NULL);
+
+        kfree(data);
+
+        return 0;
+}
+
+static const struct platform_device_id ntc_thermistor_id[] = {
+        { "ncp15wb473", TYPE_NCPXXWB473 },
+        { "ncp18wb473", TYPE_NCPXXWB473 },
+        { "ncp21wb473", TYPE_NCPXXWB473 },
+        { "ncp03wb473", TYPE_NCPXXWB473 },
+        { "ncp15wl333", TYPE_NCPXXWL333 },
+        { },
+};
+
+static struct platform_driver ntc_thermistor_driver = {
+        .driver = {
+                .name = "ntc-thermistor",
+                .owner = THIS_MODULE,
+        },
+        .probe = ntc_thermistor_probe,
+        .remove = __devexit_p(ntc_thermistor_remove),
+        .id_table = ntc_thermistor_id,
+};
+
+static int __init ntc_thermistor_init(void)
+{
+        return platform_driver_register(&ntc_thermistor_driver);
+}
+
+module_init(ntc_thermistor_init);
+
+static void __exit ntc_thermistor_cleanup(void)
+{
+        platform_driver_unregister(&ntc_thermistor_driver);
+}
+
+module_exit(ntc_thermistor_cleanup);
+
+MODULE_DESCRIPTION("NTC Thermistor Driver");
+MODULE_AUTHOR("MyungJoo Ham <myungjoo.ham@samsung.com>");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:ntc-thermistor");
diff --git a/drivers/hwmon/pmbus/Kconfig b/drivers/hwmon/pmbus/Kconfig
new file mode 100644
index 000000000000..c9237b9dcff2
--- /dev/null
+++ b/drivers/hwmon/pmbus/Kconfig
@@ -0,0 +1,100 @@
+#
+# PMBus chip drivers configuration
+#
+
+menuconfig PMBUS
+        tristate "PMBus support"
+        depends on I2C && EXPERIMENTAL
+        default n
+        help
+          Say yes here if you want to enable PMBus support.
+
+          This driver can also be built as a module. If so, the module will
+          be called pmbus_core.
+
+if PMBUS
+
+config SENSORS_PMBUS
+        tristate "Generic PMBus devices"
+        default y
+        help
+          If you say yes here you get hardware monitoring support for generic
+          PMBus devices, including but not limited to ADP4000, BMR450, BMR451,
+          BMR453, BMR454, LTC2978, NCP4200, and NCP4208.
+
+          This driver can also be built as a module. If so, the module will
+          be called pmbus.
+
+config SENSORS_ADM1275
+        tristate "Analog Devices ADM1275"
+        default n
+        help
+          If you say yes here you get hardware monitoring support for Analog
+          Devices ADM1275 Hot-Swap Controller and Digital Power Monitor.
+
+          This driver can also be built as a module. If so, the module will
+          be called adm1275.
+
+config SENSORS_LM25066
+        tristate "National Semiconductor LM25066 and compatibles"
+        default n
+        help
+          If you say yes here you get hardware monitoring support for National
+          Semiconductor LM25066, LM5064, and LM5066.
+
+          This driver can also be built as a module. If so, the module will
+          be called lm25066.
+
+config SENSORS_MAX16064
+        tristate "Maxim MAX16064"
+        default n
+        help
+          If you say yes here you get hardware monitoring support for Maxim
+          MAX16064.
+
+          This driver can also be built as a module. If so, the module will
+          be called max16064.
+
+config SENSORS_MAX34440
+        tristate "Maxim MAX34440/MAX34441"
+        default n
+        help
+          If you say yes here you get hardware monitoring support for Maxim
+          MAX34440 and MAX34441.
+
+          This driver can also be built as a module. If so, the module will
+          be called max34440.
+
+config SENSORS_MAX8688
+        tristate "Maxim MAX8688"
+        default n
+        help
+          If you say yes here you get hardware monitoring support for Maxim
+          MAX8688.
+
+          This driver can also be built as a module. If so, the module will
+          be called max8688.
+
+config SENSORS_UCD9000
+        tristate "TI UCD90120, UCD90124, UCD9090, UCD90910"
+        default n
+        help
+          If you say yes here you get hardware monitoring support for TI
+          UCD90120, UCD90124, UCD9090, UCD90910 Sequencer and System Health
+          Controllers.
+
+          This driver can also be built as a module. If so, the module will
+          be called ucd9000.
+
+config SENSORS_UCD9200
+        tristate "TI UCD9220, UCD9222, UCD9224, UCD9240, UCD9244, UCD9246, UCD9248"
+        default n
+        help
+          If you say yes here you get hardware monitoring support for TI
+          UCD9220, UCD9222, UCD9224, UCD9240, UCD9244, UCD9246, and UCD9248
+          Digital PWM System Controllers.
+
+          This driver can also be built as a module. If so, the module will
+          be called ucd9200.
+
+endif # PMBUS
diff --git a/drivers/hwmon/pmbus/Makefile b/drivers/hwmon/pmbus/Makefile
new file mode 100644
index 000000000000..623eedb1ed9a
--- /dev/null
+++ b/drivers/hwmon/pmbus/Makefile
@@ -0,0 +1,13 @@
+#
+# Makefile for PMBus chip drivers.
+#
+
+obj-$(CONFIG_PMBUS)             += pmbus_core.o
+obj-$(CONFIG_SENSORS_PMBUS)     += pmbus.o
+obj-$(CONFIG_SENSORS_ADM1275)   += adm1275.o
+obj-$(CONFIG_SENSORS_LM25066)   += lm25066.o
+obj-$(CONFIG_SENSORS_MAX16064)  += max16064.o
+obj-$(CONFIG_SENSORS_MAX34440)  += max34440.o
+obj-$(CONFIG_SENSORS_MAX8688)   += max8688.o
+obj-$(CONFIG_SENSORS_UCD9000)   += ucd9000.o
+obj-$(CONFIG_SENSORS_UCD9200)   += ucd9200.o
diff --git a/drivers/hwmon/adm1275.c b/drivers/hwmon/pmbus/adm1275.c
index 8bc1bd663721..c936e2782309 100644
--- a/drivers/hwmon/adm1275.c
+++ b/drivers/hwmon/pmbus/adm1275.c
@@ -23,11 +23,68 @@
 #include <linux/i2c.h>
 #include "pmbus.h"
 
+#define ADM1275_PEAK_IOUT               0xd0
+#define ADM1275_PEAK_VIN                0xd1
+#define ADM1275_PEAK_VOUT               0xd2
 #define ADM1275_PMON_CONFIG             0xd4
 
 #define ADM1275_VIN_VOUT_SELECT         (1 << 6)
 #define ADM1275_VRANGE                  (1 << 5)
 
+static int adm1275_read_word_data(struct i2c_client *client, int page, int reg)
+{
+        int ret;
+
+        if (page)
+                return -EINVAL;
+
+        switch (reg) {
+        case PMBUS_VIRT_READ_IOUT_MAX:
+                ret = pmbus_read_word_data(client, 0, ADM1275_PEAK_IOUT);
+                break;
+        case PMBUS_VIRT_READ_VOUT_MAX:
+                ret = pmbus_read_word_data(client, 0, ADM1275_PEAK_VOUT);
+                break;
+        case PMBUS_VIRT_READ_VIN_MAX:
+                ret = pmbus_read_word_data(client, 0, ADM1275_PEAK_VIN);
+                break;
+        case PMBUS_VIRT_RESET_IOUT_HISTORY:
+        case PMBUS_VIRT_RESET_VOUT_HISTORY:
+        case PMBUS_VIRT_RESET_VIN_HISTORY:
+                ret = 0;
+                break;
+        default:
+                ret = -ENODATA;
+                break;
+        }
+        return ret;
+}
+
+static int adm1275_write_word_data(struct i2c_client *client, int page, int reg,
+                                   u16 word)
+{
+        int ret;
+
+        if (page)
+                return -EINVAL;
+
+        switch (reg) {
+        case PMBUS_VIRT_RESET_IOUT_HISTORY:
+                ret = pmbus_write_word_data(client, 0, ADM1275_PEAK_IOUT, 0);
+                break;
+        case PMBUS_VIRT_RESET_VOUT_HISTORY:
+                ret = pmbus_write_word_data(client, 0, ADM1275_PEAK_VOUT, 0);
+                break;
+        case PMBUS_VIRT_RESET_VIN_HISTORY:
+                ret = pmbus_write_word_data(client, 0, ADM1275_PEAK_VIN, 0);
+                break;
+        default:
+                ret = -ENODATA;
+                break;
+        }
+        return ret;
+}
+
 static int adm1275_probe(struct i2c_client *client,
                          const struct i2c_device_id *id)
 {
@@ -50,14 +107,17 @@ static int adm1275_probe(struct i2c_client *client,
         }
 
         info->pages = 1;
-        info->direct[PSC_VOLTAGE_IN] = true;
-        info->direct[PSC_VOLTAGE_OUT] = true;
-        info->direct[PSC_CURRENT_OUT] = true;
+        info->format[PSC_VOLTAGE_IN] = direct;
+        info->format[PSC_VOLTAGE_OUT] = direct;
+        info->format[PSC_CURRENT_OUT] = direct;
         info->m[PSC_CURRENT_OUT] = 807;
         info->b[PSC_CURRENT_OUT] = 20475;
         info->R[PSC_CURRENT_OUT] = -1;
         info->func[0] = PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT;
 
+        info->read_word_data = adm1275_read_word_data;
+        info->write_word_data = adm1275_write_word_data;
+
         if (config & ADM1275_VRANGE) {
                 info->m[PSC_VOLTAGE_IN] = 19199;
                 info->b[PSC_VOLTAGE_IN] = 0;
diff --git a/drivers/hwmon/pmbus/lm25066.c b/drivers/hwmon/pmbus/lm25066.c
new file mode 100644
index 000000000000..ac254fba551b
--- /dev/null
+++ b/drivers/hwmon/pmbus/lm25066.c
@@ -0,0 +1,352 @@
+/*
+ * Hardware monitoring driver for LM25066 / LM5064 / LM5066
+ *
+ * Copyright (c) 2011 Ericsson AB.
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/err.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include "pmbus.h"
+
+enum chips { lm25066, lm5064, lm5066 };
+
+#define LM25066_READ_VAUX               0xd0
+#define LM25066_MFR_READ_IIN            0xd1
+#define LM25066_MFR_READ_PIN            0xd2
+#define LM25066_MFR_IIN_OC_WARN_LIMIT   0xd3
+#define LM25066_MFR_PIN_OP_WARN_LIMIT   0xd4
+#define LM25066_READ_PIN_PEAK           0xd5
+#define LM25066_CLEAR_PIN_PEAK          0xd6
+#define LM25066_DEVICE_SETUP            0xd9
+#define LM25066_READ_AVG_VIN            0xdc
+#define LM25066_READ_AVG_VOUT           0xdd
+#define LM25066_READ_AVG_IIN            0xde
+#define LM25066_READ_AVG_PIN            0xdf
+
+#define LM25066_DEV_SETUP_CL            (1 << 4)        /* Current limit */
+
+struct lm25066_data {
+        int id;
+        struct pmbus_driver_info info;
+};
+
+#define to_lm25066_data(x)  container_of(x, struct lm25066_data, info)
+
+static int lm25066_read_word_data(struct i2c_client *client, int page, int reg)
+{
+        const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
+        const struct lm25066_data *data = to_lm25066_data(info);
+        int ret;
+
+        if (page > 1)
+                return -EINVAL;
+
+        /* Map READ_VAUX into READ_VOUT register on page 1 */
+        if (page == 1) {
+                switch (reg) {
+                case PMBUS_READ_VOUT:
+                        ret = pmbus_read_word_data(client, 0,
+                                                   LM25066_READ_VAUX);
+                        if (ret < 0)
+                                break;
+                        /* Adjust returned value to match VOUT coefficients */
+                        switch (data->id) {
+                        case lm25066:
+                                /* VOUT: 4.54 mV VAUX: 283.2 uV LSB */
+                                ret = DIV_ROUND_CLOSEST(ret * 2832, 45400);
+                                break;
+                        case lm5064:
+                                /* VOUT: 4.53 mV VAUX: 700 uV LSB */
+                                ret = DIV_ROUND_CLOSEST(ret * 70, 453);
+                                break;
+                        case lm5066:
+                                /* VOUT: 2.18 mV VAUX: 725 uV LSB */
+                                ret = DIV_ROUND_CLOSEST(ret * 725, 2180);
+                                break;
+                        }
+                        break;
+                default:
+                        /* No other valid registers on page 1 */
+                        ret = -EINVAL;
+                        break;
+                }
+                goto done;
+        }
+
+        switch (reg) {
+        case PMBUS_READ_IIN:
+                ret = pmbus_read_word_data(client, 0, LM25066_MFR_READ_IIN);
+                break;
+        case PMBUS_READ_PIN:
+                ret = pmbus_read_word_data(client, 0, LM25066_MFR_READ_PIN);
+                break;
+        case PMBUS_IIN_OC_WARN_LIMIT:
+                ret = pmbus_read_word_data(client, 0,
+                                           LM25066_MFR_IIN_OC_WARN_LIMIT);
+                break;
+        case PMBUS_PIN_OP_WARN_LIMIT:
+                ret = pmbus_read_word_data(client, 0,
+                                           LM25066_MFR_PIN_OP_WARN_LIMIT);
+                break;
+        case PMBUS_VIRT_READ_VIN_AVG:
+                ret = pmbus_read_word_data(client, 0, LM25066_READ_AVG_VIN);
+                break;
+        case PMBUS_VIRT_READ_VOUT_AVG:
+                ret = pmbus_read_word_data(client, 0, LM25066_READ_AVG_VOUT);
+                break;
+        case PMBUS_VIRT_READ_IIN_AVG:
+                ret = pmbus_read_word_data(client, 0, LM25066_READ_AVG_IIN);
+                break;
+        case PMBUS_VIRT_READ_PIN_AVG:
+                ret = pmbus_read_word_data(client, 0, LM25066_READ_AVG_PIN);
+                break;
+        case PMBUS_VIRT_READ_PIN_MAX:
+                ret = pmbus_read_word_data(client, 0, LM25066_READ_PIN_PEAK);
+                break;
+        case PMBUS_VIRT_RESET_PIN_HISTORY:
+                ret = 0;
+                break;
+        default:
+                ret = -ENODATA;
+                break;
+        }
+done:
+        return ret;
+}
+
+static int lm25066_write_word_data(struct i2c_client *client, int page, int reg,
+                                   u16 word)
+{
+        int ret;
+
+        if (page > 1)
+                return -EINVAL;
+
+        switch (reg) {
+        case PMBUS_IIN_OC_WARN_LIMIT:
+                ret = pmbus_write_word_data(client, 0,
+                                            LM25066_MFR_IIN_OC_WARN_LIMIT,
+                                            word);
+                break;
+        case PMBUS_PIN_OP_WARN_LIMIT:
+                ret = pmbus_write_word_data(client, 0,
+                                            LM25066_MFR_PIN_OP_WARN_LIMIT,
+                                            word);
+                break;
+        case PMBUS_VIRT_RESET_PIN_HISTORY:
+                ret = pmbus_write_byte(client, 0, LM25066_CLEAR_PIN_PEAK);
+                break;
+        default:
+                ret = -ENODATA;
+                break;
+        }
+        return ret;
+}
+
+static int lm25066_write_byte(struct i2c_client *client, int page, u8 value)
+{
+        if (page > 1)
+                return -EINVAL;
+
+        if (page == 0)
+                return pmbus_write_byte(client, 0, value);
+
+        return 0;
+}
+
+static int lm25066_probe(struct i2c_client *client,
+                          const struct i2c_device_id *id)
+{
+        int config;
+        int ret;
+        struct lm25066_data *data;
+        struct pmbus_driver_info *info;
+
+        if (!i2c_check_functionality(client->adapter,
+                                     I2C_FUNC_SMBUS_READ_BYTE_DATA))
+                return -ENODEV;
+
+        data = kzalloc(sizeof(struct lm25066_data), GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+
+        config = i2c_smbus_read_byte_data(client, LM25066_DEVICE_SETUP);
+        if (config < 0) {
+                ret = config;
+                goto err_mem;
+        }
+
+        data->id = id->driver_data;
+        info = &data->info;
+
+        info->pages = 2;
+        info->format[PSC_VOLTAGE_IN] = direct;
+        info->format[PSC_VOLTAGE_OUT] = direct;
+        info->format[PSC_CURRENT_IN] = direct;
+        info->format[PSC_TEMPERATURE] = direct;
+        info->format[PSC_POWER] = direct;
+
+        info->m[PSC_TEMPERATURE] = 16;
+        info->b[PSC_TEMPERATURE] = 0;
+        info->R[PSC_TEMPERATURE] = 0;
+
+        info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_VOUT
+          | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_PIN | PMBUS_HAVE_IIN
+          | PMBUS_HAVE_STATUS_INPUT | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
+        info->func[1] = PMBUS_HAVE_VOUT;
+
+        info->read_word_data = lm25066_read_word_data;
+        info->write_word_data = lm25066_write_word_data;
+        info->write_byte = lm25066_write_byte;
+
+        switch (id->driver_data) {
+        case lm25066:
+                info->m[PSC_VOLTAGE_IN] = 22070;
+                info->b[PSC_VOLTAGE_IN] = 0;
+                info->R[PSC_VOLTAGE_IN] = -2;
+                info->m[PSC_VOLTAGE_OUT] = 22070;
+                info->b[PSC_VOLTAGE_OUT] = 0;
+                info->R[PSC_VOLTAGE_OUT] = -2;
+
+                if (config & LM25066_DEV_SETUP_CL) {
+                        info->m[PSC_CURRENT_IN] = 6852;
+                        info->b[PSC_CURRENT_IN] = 0;
+                        info->R[PSC_CURRENT_IN] = -2;
+                        info->m[PSC_POWER] = 369;
+                        info->b[PSC_POWER] = 0;
+                        info->R[PSC_POWER] = -2;
+                } else {
+                        info->m[PSC_CURRENT_IN] = 13661;
+                        info->b[PSC_CURRENT_IN] = 0;
+                        info->R[PSC_CURRENT_IN] = -2;
+                        info->m[PSC_POWER] = 736;
+                        info->b[PSC_POWER] = 0;
+                        info->R[PSC_POWER] = -2;
+                }
+                break;
+        case lm5064:
+                info->m[PSC_VOLTAGE_IN] = 22075;
+                info->b[PSC_VOLTAGE_IN] = 0;
+                info->R[PSC_VOLTAGE_IN] = -2;
+                info->m[PSC_VOLTAGE_OUT] = 22075;
+                info->b[PSC_VOLTAGE_OUT] = 0;
+                info->R[PSC_VOLTAGE_OUT] = -2;
+
+                if (config & LM25066_DEV_SETUP_CL) {
+                        info->m[PSC_CURRENT_IN] = 6713;
+                        info->b[PSC_CURRENT_IN] = 0;
+                        info->R[PSC_CURRENT_IN] = -2;
+                        info->m[PSC_POWER] = 3619;
+                        info->b[PSC_POWER] = 0;
+                        info->R[PSC_POWER] = -3;
+                } else {
+                        info->m[PSC_CURRENT_IN] = 13426;
+                        info->b[PSC_CURRENT_IN] = 0;
+                        info->R[PSC_CURRENT_IN] = -2;
+                        info->m[PSC_POWER] = 7238;
+                        info->b[PSC_POWER] = 0;
+                        info->R[PSC_POWER] = -3;
+                }
+                break;
+        case lm5066:
+                info->m[PSC_VOLTAGE_IN] = 4587;
+                info->b[PSC_VOLTAGE_IN] = 0;
+                info->R[PSC_VOLTAGE_IN] = -2;
+                info->m[PSC_VOLTAGE_OUT] = 4587;
+                info->b[PSC_VOLTAGE_OUT] = 0;
+                info->R[PSC_VOLTAGE_OUT] = -2;
+
+                if (config & LM25066_DEV_SETUP_CL) {
+                        info->m[PSC_CURRENT_IN] = 10753;
+                        info->b[PSC_CURRENT_IN] = 0;
+                        info->R[PSC_CURRENT_IN] = -2;
+                        info->m[PSC_POWER] = 1204;
+                        info->b[PSC_POWER] = 0;
+                        info->R[PSC_POWER] = -3;
+                } else {
+                        info->m[PSC_CURRENT_IN] = 5405;
+                        info->b[PSC_CURRENT_IN] = 0;
+                        info->R[PSC_CURRENT_IN] = -2;
+                        info->m[PSC_POWER] = 605;
+                        info->b[PSC_POWER] = 0;
+                        info->R[PSC_POWER] = -3;
+                }
+                break;
+        default:
+                ret = -ENODEV;
+                goto err_mem;
+        }
+
+        ret = pmbus_do_probe(client, id, info);
+        if (ret)
+                goto err_mem;
+        return 0;
+
+err_mem:
+        kfree(data);
+        return ret;
+}
+
+static int lm25066_remove(struct i2c_client *client)
+{
+        const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
+        const struct lm25066_data *data = to_lm25066_data(info);
+        int ret;
+
+        ret = pmbus_do_remove(client);
+        kfree(data);
+        return ret;
+}
+
+static const struct i2c_device_id lm25066_id[] = {
+        {"lm25066", lm25066},
+        {"lm5064", lm5064},
+        {"lm5066", lm5066},
+        { }
+};
+
+MODULE_DEVICE_TABLE(i2c, lm25066_id);
+
+/* This is the driver that will be inserted */
+static struct i2c_driver lm25066_driver = {
+        .driver = {
+                   .name = "lm25066",
+                   },
+        .probe = lm25066_probe,
+        .remove = lm25066_remove,
+        .id_table = lm25066_id,
+};
+
+static int __init lm25066_init(void)
+{
+        return i2c_add_driver(&lm25066_driver);
+}
+
+static void __exit lm25066_exit(void)
+{
+        i2c_del_driver(&lm25066_driver);
+}
+
+MODULE_AUTHOR("Guenter Roeck");
+MODULE_DESCRIPTION("PMBus driver for LM25066/LM5064/LM5066");
+MODULE_LICENSE("GPL");
+module_init(lm25066_init);
+module_exit(lm25066_exit);
diff --git a/drivers/hwmon/max16064.c b/drivers/hwmon/pmbus/max16064.c
index 1d6d717060d3..e50b296e8db4 100644
--- a/drivers/hwmon/max16064.c
+++ b/drivers/hwmon/pmbus/max16064.c
@@ -25,11 +25,60 @@
 #include <linux/i2c.h>
 #include "pmbus.h"
 
+#define MAX16064_MFR_VOUT_PEAK          0xd4
+#define MAX16064_MFR_TEMPERATURE_PEAK   0xd6
+
+static int max16064_read_word_data(struct i2c_client *client, int page, int reg)
+{
+        int ret;
+
+        switch (reg) {
+        case PMBUS_VIRT_READ_VOUT_MAX:
+                ret = pmbus_read_word_data(client, page,
+                                           MAX16064_MFR_VOUT_PEAK);
+                break;
+        case PMBUS_VIRT_READ_TEMP_MAX:
+                ret = pmbus_read_word_data(client, page,
+                                           MAX16064_MFR_TEMPERATURE_PEAK);
+                break;
+        case PMBUS_VIRT_RESET_VOUT_HISTORY:
+        case PMBUS_VIRT_RESET_TEMP_HISTORY:
+                ret = 0;
+                break;
+        default:
+                ret = -ENODATA;
+                break;
+        }
+        return ret;
+}
+
+static int max16064_write_word_data(struct i2c_client *client, int page,
+                                    int reg, u16 word)
+{
+        int ret;
+
+        switch (reg) {
+        case PMBUS_VIRT_RESET_VOUT_HISTORY:
+                ret = pmbus_write_word_data(client, page,
+                                            MAX16064_MFR_VOUT_PEAK, 0);
+                break;
+        case PMBUS_VIRT_RESET_TEMP_HISTORY:
+                ret = pmbus_write_word_data(client, page,
+                                            MAX16064_MFR_TEMPERATURE_PEAK,
+                                            0xffff);
+                break;
+        default:
+                ret = -ENODATA;
+                break;
+        }
+        return ret;
+}
+
 static struct pmbus_driver_info max16064_info = {
         .pages = 4,
-        .direct[PSC_VOLTAGE_IN] = true,
-        .direct[PSC_VOLTAGE_OUT] = true,
-        .direct[PSC_TEMPERATURE] = true,
+        .format[PSC_VOLTAGE_IN] = direct,
+        .format[PSC_VOLTAGE_OUT] = direct,
+        .format[PSC_TEMPERATURE] = direct,
         .m[PSC_VOLTAGE_IN] = 19995,
         .b[PSC_VOLTAGE_IN] = 0,
         .R[PSC_VOLTAGE_IN] = -1,
@@ -44,6 +93,8 @@ static struct pmbus_driver_info max16064_info = {
         .func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT,
         .func[2] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT,
         .func[3] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT,
+        .read_word_data = max16064_read_word_data,
+        .write_word_data = max16064_write_word_data,
 };
 
 static int max16064_probe(struct i2c_client *client,
diff --git a/drivers/hwmon/max34440.c b/drivers/hwmon/pmbus/max34440.c
index db11e1a175b2..fda621d2e458 100644
--- a/drivers/hwmon/max34440.c
+++ b/drivers/hwmon/pmbus/max34440.c
@@ -27,11 +27,70 @@
 
 enum chips { max34440, max34441 };
 
+#define MAX34440_MFR_VOUT_PEAK          0xd4
+#define MAX34440_MFR_IOUT_PEAK          0xd5
+#define MAX34440_MFR_TEMPERATURE_PEAK   0xd6
+
 #define MAX34440_STATUS_OC_WARN         (1 << 0)
 #define MAX34440_STATUS_OC_FAULT        (1 << 1)
 #define MAX34440_STATUS_OT_FAULT        (1 << 5)
 #define MAX34440_STATUS_OT_WARN         (1 << 6)
 
+static int max34440_read_word_data(struct i2c_client *client, int page, int reg)
+{
+        int ret;
+
+        switch (reg) {
+        case PMBUS_VIRT_READ_VOUT_MAX:
+                ret = pmbus_read_word_data(client, page,
+                                           MAX34440_MFR_VOUT_PEAK);
+                break;
+        case PMBUS_VIRT_READ_IOUT_MAX:
+                ret = pmbus_read_word_data(client, page,
+                                           MAX34440_MFR_IOUT_PEAK);
+                break;
+        case PMBUS_VIRT_READ_TEMP_MAX:
+                ret = pmbus_read_word_data(client, page,
+                                           MAX34440_MFR_TEMPERATURE_PEAK);
+                break;
+        case PMBUS_VIRT_RESET_VOUT_HISTORY:
+        case PMBUS_VIRT_RESET_IOUT_HISTORY:
+        case PMBUS_VIRT_RESET_TEMP_HISTORY:
+                ret = 0;
+                break;
+        default:
+                ret = -ENODATA;
+                break;
+        }
+        return ret;
+}
+
+static int max34440_write_word_data(struct i2c_client *client, int page,
+                                    int reg, u16 word)
+{
+        int ret;
+
+        switch (reg) {
+        case PMBUS_VIRT_RESET_VOUT_HISTORY:
+                ret = pmbus_write_word_data(client, page,
+                                            MAX34440_MFR_VOUT_PEAK, 0);
+                break;
+        case PMBUS_VIRT_RESET_IOUT_HISTORY:
+                ret = pmbus_write_word_data(client, page,
+                                            MAX34440_MFR_IOUT_PEAK, 0);
+                break;
+        case PMBUS_VIRT_RESET_TEMP_HISTORY:
+                ret = pmbus_write_word_data(client, page,
+                                            MAX34440_MFR_TEMPERATURE_PEAK,
+                                            0xffff);
+                break;
+        default:
+                ret = -ENODATA;
+                break;
+        }
+        return ret;
+}
+
 static int max34440_read_byte_data(struct i2c_client *client, int page, int reg)
 {
         int ret;
@@ -72,10 +131,10 @@ static int max34440_read_byte_data(struct i2c_client *client, int page, int reg)
 static struct pmbus_driver_info max34440_info[] = {
         [max34440] = {
                 .pages = 14,
-                .direct[PSC_VOLTAGE_IN] = true,
-                .direct[PSC_VOLTAGE_OUT] = true,
-                .direct[PSC_TEMPERATURE] = true,
-                .direct[PSC_CURRENT_OUT] = true,
+                .format[PSC_VOLTAGE_IN] = direct,
+                .format[PSC_VOLTAGE_OUT] = direct,
+                .format[PSC_TEMPERATURE] = direct,
+                .format[PSC_CURRENT_OUT] = direct,
                 .m[PSC_VOLTAGE_IN] = 1,
                 .b[PSC_VOLTAGE_IN] = 0,
                 .R[PSC_VOLTAGE_IN] = 3,     /* R = 0 in datasheet reflects mV */
@@ -109,14 +168,16 @@ static struct pmbus_driver_info max34440_info[] = {
                 .func[12] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP,
                 .func[13] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP,
                 .read_byte_data = max34440_read_byte_data,
+                .read_word_data = max34440_read_word_data,
+                .write_word_data = max34440_write_word_data,
         },
         [max34441] = {
                 .pages = 12,
-                .direct[PSC_VOLTAGE_IN] = true,
-                .direct[PSC_VOLTAGE_OUT] = true,
-                .direct[PSC_TEMPERATURE] = true,
-                .direct[PSC_CURRENT_OUT] = true,
-                .direct[PSC_FAN] = true,
+                .format[PSC_VOLTAGE_IN] = direct,
+                .format[PSC_VOLTAGE_OUT] = direct,
+                .format[PSC_TEMPERATURE] = direct,
+                .format[PSC_CURRENT_OUT] = direct,
+                .format[PSC_FAN] = direct,
                 .m[PSC_VOLTAGE_IN] = 1,
                 .b[PSC_VOLTAGE_IN] = 0,
                 .R[PSC_VOLTAGE_IN] = 3,
@@ -150,6 +211,8 @@ static struct pmbus_driver_info max34440_info[] = {
                 .func[10] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP,
                 .func[11] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP,
                 .read_byte_data = max34440_read_byte_data,
+                .read_word_data = max34440_read_word_data,
+                .write_word_data = max34440_write_word_data,
         },
 };
 
diff --git a/drivers/hwmon/max8688.c b/drivers/hwmon/pmbus/max8688.c
index 7fb93f4e9f21..c3e72f1a3cfb 100644
--- a/drivers/hwmon/max8688.c
+++ b/drivers/hwmon/pmbus/max8688.c
@@ -25,6 +25,9 @@
 #include <linux/i2c.h>
 #include "pmbus.h"
 
+#define MAX8688_MFR_VOUT_PEAK           0xd4
+#define MAX8688_MFR_IOUT_PEAK           0xd5
+#define MAX8688_MFR_TEMPERATURE_PEAK    0xd6
 #define MAX8688_MFG_STATUS              0xd8
 
 #define MAX8688_STATUS_OC_FAULT         (1 << 4)
@@ -37,6 +40,62 @@
 #define MAX8688_STATUS_OT_FAULT         (1 << 13)
 #define MAX8688_STATUS_OT_WARNING       (1 << 14)
 
+static int max8688_read_word_data(struct i2c_client *client, int page, int reg)
+{
+        int ret;
+
+        if (page)
+                return -EINVAL;
+
+        switch (reg) {
+        case PMBUS_VIRT_READ_VOUT_MAX:
+                ret = pmbus_read_word_data(client, 0, MAX8688_MFR_VOUT_PEAK);
+                break;
+        case PMBUS_VIRT_READ_IOUT_MAX:
+                ret = pmbus_read_word_data(client, 0, MAX8688_MFR_IOUT_PEAK);
+                break;
+        case PMBUS_VIRT_READ_TEMP_MAX:
+                ret = pmbus_read_word_data(client, 0,
+                                           MAX8688_MFR_TEMPERATURE_PEAK);
+                break;
+        case PMBUS_VIRT_RESET_VOUT_HISTORY:
+        case PMBUS_VIRT_RESET_IOUT_HISTORY:
+        case PMBUS_VIRT_RESET_TEMP_HISTORY:
+                ret = 0;
+                break;
+        default:
+                ret = -ENODATA;
+                break;
+        }
+        return ret;
+}
+
+static int max8688_write_word_data(struct i2c_client *client, int page, int reg,
+                                   u16 word)
+{
+        int ret;
+
+        switch (reg) {
+        case PMBUS_VIRT_RESET_VOUT_HISTORY:
+                ret = pmbus_write_word_data(client, 0, MAX8688_MFR_VOUT_PEAK,
+                                            0);
+                break;
+        case PMBUS_VIRT_RESET_IOUT_HISTORY:
+                ret = pmbus_write_word_data(client, 0, MAX8688_MFR_IOUT_PEAK,
+                                            0);
+                break;
+        case PMBUS_VIRT_RESET_TEMP_HISTORY:
+                ret = pmbus_write_word_data(client, 0,
+                                            MAX8688_MFR_TEMPERATURE_PEAK,
+                                            0xffff);
+                break;
+        default:
+                ret = -ENODATA;
+                break;
+        }
+        return ret;
+}
+
 static int max8688_read_byte_data(struct i2c_client *client, int page, int reg)
 {
         int ret = 0;
@@ -91,10 +150,10 @@ static int max8688_read_byte_data(struct i2c_client *client, int page, int reg)
 
 static struct pmbus_driver_info max8688_info = {
         .pages = 1,
-        .direct[PSC_VOLTAGE_IN] = true,
-        .direct[PSC_VOLTAGE_OUT] = true,
-        .direct[PSC_TEMPERATURE] = true,
-        .direct[PSC_CURRENT_OUT] = true,
+        .format[PSC_VOLTAGE_IN] = direct,
+        .format[PSC_VOLTAGE_OUT] = direct,
+        .format[PSC_TEMPERATURE] = direct,
+        .format[PSC_CURRENT_OUT] = direct,
         .m[PSC_VOLTAGE_IN] = 19995,
         .b[PSC_VOLTAGE_IN] = 0,
         .R[PSC_VOLTAGE_IN] = -1,
@@ -111,6 +170,8 @@ static struct pmbus_driver_info max8688_info = {
                 | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_STATUS_IOUT
                 | PMBUS_HAVE_STATUS_TEMP,
         .read_byte_data = max8688_read_byte_data,
+        .read_word_data = max8688_read_word_data,
+        .write_word_data = max8688_write_word_data,
 };
 
 static int max8688_probe(struct i2c_client *client,
diff --git a/drivers/hwmon/pmbus.c b/drivers/hwmon/pmbus/pmbus.c
index 9b1f0c37ef77..73de9f1f3194 100644
--- a/drivers/hwmon/pmbus.c
+++ b/drivers/hwmon/pmbus/pmbus.c
@@ -96,6 +96,8 @@ static void pmbus_find_sensor_groups(struct i2c_client *client,
 static int pmbus_identify(struct i2c_client *client,
                           struct pmbus_driver_info *info)
 {
+        int ret = 0;
+
         if (!info->pages) {
                 /*
                  * Check if the PAGE command is supported. If it is,
@@ -117,6 +119,27 @@ static int pmbus_identify(struct i2c_client *client,
                 }
         }
 
+        if (pmbus_check_byte_register(client, 0, PMBUS_VOUT_MODE)) {
+                int vout_mode;
+
+                vout_mode = pmbus_read_byte_data(client, 0, PMBUS_VOUT_MODE);
+                if (vout_mode >= 0 && vout_mode != 0xff) {
+                        switch (vout_mode >> 5) {
+                        case 0:
+                                break;
+                        case 1:
+                                info->format[PSC_VOLTAGE_OUT] = vid;
+                                break;
+                        case 2:
+                                info->format[PSC_VOLTAGE_OUT] = direct;
+                                break;
+                        default:
+                                ret = -ENODEV;
+                                goto abort;
+                        }
+                }
+        }
+
         /*
          * We should check if the COEFFICIENTS register is supported.
          * If it is, and the chip is configured for direct mode, we can read
@@ -125,13 +148,18 @@ static int pmbus_identify(struct i2c_client *client,
          *
          * To do this, we will need access to a chip which actually supports the
          * COEFFICIENTS command, since the command is too complex to implement
-         * without testing it.
+         * without testing it. Until then, abort if a chip configured for direct
+         * mode was detected.
          */
+        if (info->format[PSC_VOLTAGE_OUT] == direct) {
+                ret = -ENODEV;
+                goto abort;
+        }
 
         /* Try to find sensor groups  */
         pmbus_find_sensor_groups(client, info);
-
-        return 0;
+abort:
+        return ret;
 }
 
 static int pmbus_probe(struct i2c_client *client,
@@ -172,11 +200,14 @@ static int pmbus_remove(struct i2c_client *client)
  * Use driver_data to set the number of pages supported by the chip.
  */
 static const struct i2c_device_id pmbus_id[] = {
+        {"adp4000", 1},
         {"bmr450", 1},
         {"bmr451", 1},
         {"bmr453", 1},
         {"bmr454", 1},
         {"ltc2978", 8},
+        {"ncp4200", 1},
+        {"ncp4208", 1},
         {"pmbus", 0},
         {}
 };
diff --git a/drivers/hwmon/pmbus.h b/drivers/hwmon/pmbus/pmbus.h
index 50647ab7235a..a6ae20ffef6b 100644
--- a/drivers/hwmon/pmbus.h
+++ b/drivers/hwmon/pmbus/pmbus.h
@@ -126,6 +126,42 @@
 #define PMBUS_MFR_SERIAL                0x9E
 
 /*
+ * Virtual registers.
+ * Useful to support attributes which are not supported by standard PMBus
+ * registers but exist as manufacturer specific registers on individual chips.
+ * Must be mapped to real registers in device specific code.
+ *
+ * Semantics:
+ * Virtual registers are all word size.
+ * READ registers are read-only; writes are either ignored or return an error.
+ * RESET registers are read/write. Reading returns zero (used for detection),
+ * writing any value causes the associated history to be reset.
+ */
+#define PMBUS_VIRT_BASE                 0x100
+#define PMBUS_VIRT_READ_TEMP_MIN        (PMBUS_VIRT_BASE + 0)
+#define PMBUS_VIRT_READ_TEMP_MAX        (PMBUS_VIRT_BASE + 1)
+#define PMBUS_VIRT_RESET_TEMP_HISTORY   (PMBUS_VIRT_BASE + 2)
+#define PMBUS_VIRT_READ_VIN_AVG         (PMBUS_VIRT_BASE + 3)
+#define PMBUS_VIRT_READ_VIN_MIN         (PMBUS_VIRT_BASE + 4)
+#define PMBUS_VIRT_READ_VIN_MAX         (PMBUS_VIRT_BASE + 5)
+#define PMBUS_VIRT_RESET_VIN_HISTORY    (PMBUS_VIRT_BASE + 6)
+#define PMBUS_VIRT_READ_IIN_AVG         (PMBUS_VIRT_BASE + 7)
+#define PMBUS_VIRT_READ_IIN_MIN         (PMBUS_VIRT_BASE + 8)
+#define PMBUS_VIRT_READ_IIN_MAX         (PMBUS_VIRT_BASE + 9)
+#define PMBUS_VIRT_RESET_IIN_HISTORY    (PMBUS_VIRT_BASE + 10)
+#define PMBUS_VIRT_READ_PIN_AVG         (PMBUS_VIRT_BASE + 11)
+#define PMBUS_VIRT_READ_PIN_MAX         (PMBUS_VIRT_BASE + 12)
+#define PMBUS_VIRT_RESET_PIN_HISTORY    (PMBUS_VIRT_BASE + 13)
+#define PMBUS_VIRT_READ_VOUT_AVG        (PMBUS_VIRT_BASE + 14)
+#define PMBUS_VIRT_READ_VOUT_MIN        (PMBUS_VIRT_BASE + 15)
+#define PMBUS_VIRT_READ_VOUT_MAX        (PMBUS_VIRT_BASE + 16)
+#define PMBUS_VIRT_RESET_VOUT_HISTORY   (PMBUS_VIRT_BASE + 17)
+#define PMBUS_VIRT_READ_IOUT_AVG        (PMBUS_VIRT_BASE + 18)
+#define PMBUS_VIRT_READ_IOUT_MIN        (PMBUS_VIRT_BASE + 19)
+#define PMBUS_VIRT_READ_IOUT_MAX        (PMBUS_VIRT_BASE + 20)
+#define PMBUS_VIRT_RESET_IOUT_HISTORY   (PMBUS_VIRT_BASE + 21)
+
+/*
  * CAPABILITY
  */
 #define PB_CAPABILITY_SMBALERT          (1<<4)
@@ -266,11 +302,11 @@ enum pmbus_sensor_classes {
 #define PMBUS_HAVE_STATUS_FAN12 (1 << 16)
 #define PMBUS_HAVE_STATUS_FAN34 (1 << 17)
 
+enum pmbus_data_format { linear = 0, direct, vid };
+
 struct pmbus_driver_info {
         int pages;              /* Total number of pages */
-        bool direct[PSC_NUM_CLASSES];
-                                /* true if device uses direct data format
-                                   for the given sensor class */
+        enum pmbus_data_format format[PSC_NUM_CLASSES];
         /*
          * Support one set of coefficients for each sensor type
          * Used for chips providing data in direct mode.
@@ -286,6 +322,10 @@ struct pmbus_driver_info {
          * necessary.
          */
         int (*read_byte_data)(struct i2c_client *client, int page, int reg);
+        int (*read_word_data)(struct i2c_client *client, int page, int reg);
+        int (*write_word_data)(struct i2c_client *client, int page, int reg,
+                               u16 word);
+        int (*write_byte)(struct i2c_client *client, int page, u8 value);
         /*
          * The identify function determines supported PMBus functionality.
          * This function is only necessary if a chip driver supports multiple
@@ -299,6 +339,9 @@ struct pmbus_driver_info {
 
 int pmbus_set_page(struct i2c_client *client, u8 page);
 int pmbus_read_word_data(struct i2c_client *client, u8 page, u8 reg);
+int pmbus_write_word_data(struct i2c_client *client, u8 page, u8 reg, u16 word);
+int pmbus_read_byte_data(struct i2c_client *client, int page, u8 reg);
+int pmbus_write_byte(struct i2c_client *client, int page, u8 value);
 void pmbus_clear_faults(struct i2c_client *client);
 bool pmbus_check_byte_register(struct i2c_client *client, int page, int reg);
 bool pmbus_check_word_register(struct i2c_client *client, int page, int reg);
diff --git a/drivers/hwmon/pmbus_core.c b/drivers/hwmon/pmbus/pmbus_core.c
index 8e31a8e2c746..a561c3a0e916 100644
--- a/drivers/hwmon/pmbus_core.c
+++ b/drivers/hwmon/pmbus/pmbus_core.c
@@ -33,14 +33,18 @@
 /*
  * Constants needed to determine number of sensors, booleans, and labels.
  */
-#define PMBUS_MAX_INPUT_SENSORS         11      /* 6*volt, 3*curr, 2*power */
-#define PMBUS_VOUT_SENSORS_PER_PAGE     5       /* input, min, max, lcrit,
-                                                   crit */
-#define PMBUS_IOUT_SENSORS_PER_PAGE     4       /* input, min, max, crit */
+#define PMBUS_MAX_INPUT_SENSORS         22      /* 10*volt, 7*curr, 5*power */
+#define PMBUS_VOUT_SENSORS_PER_PAGE     9       /* input, min, max, lcrit,
+                                                   crit, lowest, highest, avg,
+                                                   reset */
+#define PMBUS_IOUT_SENSORS_PER_PAGE     8       /* input, min, max, crit,
+                                                   lowest, highest, avg,
+                                                   reset */
 #define PMBUS_POUT_SENSORS_PER_PAGE     4       /* input, cap, max, crit */
 #define PMBUS_MAX_SENSORS_PER_FAN       1       /* input */
-#define PMBUS_MAX_SENSORS_PER_TEMP      5       /* input, min, max, lcrit,
-                                                   crit */
+#define PMBUS_MAX_SENSORS_PER_TEMP      8       /* input, min, max, lcrit,
+                                                   crit, lowest, highest,
+                                                   reset */
 
 #define PMBUS_MAX_INPUT_BOOLEANS        7       /* v: min_alarm, max_alarm,
                                                    lcrit_alarm, crit_alarm;
@@ -74,11 +78,13 @@
 #define PB_STATUS_INPUT_BASE    (PB_STATUS_FAN34_BASE + PMBUS_PAGES)
 #define PB_STATUS_TEMP_BASE     (PB_STATUS_INPUT_BASE + 1)
 
+#define PMBUS_NAME_SIZE         24
+
 struct pmbus_sensor {
-        char name[I2C_NAME_SIZE];       /* sysfs sensor name */
+        char name[PMBUS_NAME_SIZE];     /* sysfs sensor name */
         struct sensor_device_attribute attribute;
         u8 page;                /* page number */
-        u8 reg;                 /* register */
+        u16 reg;                /* register */
         enum pmbus_sensor_classes class;        /* sensor class */
         bool update;            /* runtime sensor update needed */
         int data;               /* Sensor data.
@@ -86,14 +92,14 @@ struct pmbus_sensor {
 };
 
 struct pmbus_boolean {
-        char name[I2C_NAME_SIZE];       /* sysfs boolean name */
+        char name[PMBUS_NAME_SIZE];     /* sysfs boolean name */
         struct sensor_device_attribute attribute;
 };
 
 struct pmbus_label {
-        char name[I2C_NAME_SIZE];       /* sysfs label name */
+        char name[PMBUS_NAME_SIZE];     /* sysfs label name */
         struct sensor_device_attribute attribute;
-        char label[I2C_NAME_SIZE];      /* label */
+        char label[PMBUS_NAME_SIZE];    /* label */
 };
 
 struct pmbus_data {
@@ -162,19 +168,39 @@ int pmbus_set_page(struct i2c_client *client, u8 page)
 }
 EXPORT_SYMBOL_GPL(pmbus_set_page);
 
-static int pmbus_write_byte(struct i2c_client *client, u8 page, u8 value)
+int pmbus_write_byte(struct i2c_client *client, int page, u8 value)
 {
         int rv;
 
-        rv = pmbus_set_page(client, page);
-        if (rv < 0)
-                return rv;
+        if (page >= 0) {
+                rv = pmbus_set_page(client, page);
+                if (rv < 0)
+                        return rv;
+        }
 
         return i2c_smbus_write_byte(client, value);
 }
+EXPORT_SYMBOL_GPL(pmbus_write_byte);
+
+/*
+ * _pmbus_write_byte() is similar to pmbus_write_byte(), but checks if
+ * a device specific mapping funcion exists and calls it if necessary.
+ */
+static int _pmbus_write_byte(struct i2c_client *client, int page, u8 value)
+{
+        struct pmbus_data *data = i2c_get_clientdata(client);
+        const struct pmbus_driver_info *info = data->info;
+        int status;
+
+        if (info->write_byte) {
+                status = info->write_byte(client, page, value);
+                if (status != -ENODATA)
+                        return status;
+        }
+        return pmbus_write_byte(client, page, value);
+}
 
-static int pmbus_write_word_data(struct i2c_client *client, u8 page, u8 reg,
-                                 u16 word)
+int pmbus_write_word_data(struct i2c_client *client, u8 page, u8 reg, u16 word)
 {
         int rv;
 
@@ -184,6 +210,28 @@ static int pmbus_write_word_data(struct i2c_client *client, u8 page, u8 reg,
 
         return i2c_smbus_write_word_data(client, reg, word);
 }
+EXPORT_SYMBOL_GPL(pmbus_write_word_data);
+
+/*
+ * _pmbus_write_word_data() is similar to pmbus_write_word_data(), but checks if
+ * a device specific mapping function exists and calls it if necessary.
+ */
+static int _pmbus_write_word_data(struct i2c_client *client, int page, int reg,
+                                  u16 word)
+{
+        struct pmbus_data *data = i2c_get_clientdata(client);
+        const struct pmbus_driver_info *info = data->info;
+        int status;
+
+        if (info->write_word_data) {
+                status = info->write_word_data(client, page, reg, word);
+                if (status != -ENODATA)
+                        return status;
+        }
+        if (reg >= PMBUS_VIRT_BASE)
+                return -EINVAL;
+        return pmbus_write_word_data(client, page, reg, word);
+}
 
 int pmbus_read_word_data(struct i2c_client *client, u8 page, u8 reg)
 {
@@ -197,20 +245,61 @@ int pmbus_read_word_data(struct i2c_client *client, u8 page, u8 reg)
 }
 EXPORT_SYMBOL_GPL(pmbus_read_word_data);
 
-static int pmbus_read_byte_data(struct i2c_client *client, u8 page, u8 reg)
+/*
+ * _pmbus_read_word_data() is similar to pmbus_read_word_data(), but checks if
+ * a device specific mapping function exists and calls it if necessary.
+ */
+static int _pmbus_read_word_data(struct i2c_client *client, int page, int reg)
+{
+        struct pmbus_data *data = i2c_get_clientdata(client);
+        const struct pmbus_driver_info *info = data->info;
+        int status;
+
+        if (info->read_word_data) {
+                status = info->read_word_data(client, page, reg);
+                if (status != -ENODATA)
+                        return status;
+        }
+        if (reg >= PMBUS_VIRT_BASE)
+                return -EINVAL;
+        return pmbus_read_word_data(client, page, reg);
+}
+
+int pmbus_read_byte_data(struct i2c_client *client, int page, u8 reg)
 {
         int rv;
 
-        rv = pmbus_set_page(client, page);
-        if (rv < 0)
-                return rv;
+        if (page >= 0) {
+                rv = pmbus_set_page(client, page);
+                if (rv < 0)
+                        return rv;
+        }
 
         return i2c_smbus_read_byte_data(client, reg);
 }
+EXPORT_SYMBOL_GPL(pmbus_read_byte_data);
+
+/*
+ * _pmbus_read_byte_data() is similar to pmbus_read_byte_data(), but checks if
+ * a device specific mapping function exists and calls it if necessary.
+ */
+static int _pmbus_read_byte_data(struct i2c_client *client, int page, int reg)
+{
+        struct pmbus_data *data = i2c_get_clientdata(client);
+        const struct pmbus_driver_info *info = data->info;
+        int status;
+
+        if (info->read_byte_data) {
+                status = info->read_byte_data(client, page, reg);
+                if (status != -ENODATA)
+                        return status;
+        }
+        return pmbus_read_byte_data(client, page, reg);
+}
 
 static void pmbus_clear_fault_page(struct i2c_client *client, int page)
 {
-        pmbus_write_byte(client, page, PMBUS_CLEAR_FAULTS);
+        _pmbus_write_byte(client, page, PMBUS_CLEAR_FAULTS);
 }
 
 void pmbus_clear_faults(struct i2c_client *client)
@@ -223,13 +312,13 @@ void pmbus_clear_faults(struct i2c_client *client)
 }
 EXPORT_SYMBOL_GPL(pmbus_clear_faults);
 
-static int pmbus_check_status_cml(struct i2c_client *client, int page)
+static int pmbus_check_status_cml(struct i2c_client *client)
 {
         int status, status2;
 
-        status = pmbus_read_byte_data(client, page, PMBUS_STATUS_BYTE);
+        status = pmbus_read_byte_data(client, -1, PMBUS_STATUS_BYTE);
         if (status < 0 || (status & PB_STATUS_CML)) {
-                status2 = pmbus_read_byte_data(client, page, PMBUS_STATUS_CML);
+                status2 = pmbus_read_byte_data(client, -1, PMBUS_STATUS_CML);
                 if (status2 < 0 || (status2 & PB_CML_FAULT_INVALID_COMMAND))
                         return -EINVAL;
         }
@@ -241,10 +330,10 @@ bool pmbus_check_byte_register(struct i2c_client *client, int page, int reg)
         int rv;
         struct pmbus_data *data = i2c_get_clientdata(client);
 
-        rv = pmbus_read_byte_data(client, page, reg);
+        rv = _pmbus_read_byte_data(client, page, reg);
         if (rv >= 0 && !(data->flags & PMBUS_SKIP_STATUS_CHECK))
-                rv = pmbus_check_status_cml(client, page);
-        pmbus_clear_fault_page(client, page);
+                rv = pmbus_check_status_cml(client);
+        pmbus_clear_fault_page(client, -1);
         return rv >= 0;
 }
 EXPORT_SYMBOL_GPL(pmbus_check_byte_register);
@@ -254,10 +343,10 @@ bool pmbus_check_word_register(struct i2c_client *client, int page, int reg)
         int rv;
         struct pmbus_data *data = i2c_get_clientdata(client);
 
-        rv = pmbus_read_word_data(client, page, reg);
+        rv = _pmbus_read_word_data(client, page, reg);
         if (rv >= 0 && !(data->flags & PMBUS_SKIP_STATUS_CHECK))
-                rv = pmbus_check_status_cml(client, page);
-        pmbus_clear_fault_page(client, page);
+                rv = pmbus_check_status_cml(client);
+        pmbus_clear_fault_page(client, -1);
         return rv >= 0;
 }
 EXPORT_SYMBOL_GPL(pmbus_check_word_register);
@@ -270,24 +359,6 @@ const struct pmbus_driver_info *pmbus_get_driver_info(struct i2c_client *client)
 }
 EXPORT_SYMBOL_GPL(pmbus_get_driver_info);
 
-/*
- * _pmbus_read_byte_data() is similar to pmbus_read_byte_data(), but checks if
- * a device specific mapping funcion exists and calls it if necessary.
- */
-static int _pmbus_read_byte_data(struct i2c_client *client, int page, int reg)
-{
-        struct pmbus_data *data = i2c_get_clientdata(client);
-        const struct pmbus_driver_info *info = data->info;
-        int status;
-
-        if (info->read_byte_data) {
-                status = info->read_byte_data(client, page, reg);
-                if (status != -ENODATA)
-                        return status;
-        }
-        return pmbus_read_byte_data(client, page, reg);
-}
-
 static struct pmbus_data *pmbus_update_device(struct device *dev)
 {
         struct i2c_client *client = to_i2c_client(dev);
@@ -347,8 +418,9 @@ static struct pmbus_data *pmbus_update_device(struct device *dev)
 
                         if (!data->valid || sensor->update)
                                 sensor->data
-                                    = pmbus_read_word_data(client, sensor->page,
-                                                           sensor->reg);
+                                    = _pmbus_read_word_data(client,
+                                                            sensor->page,
+                                                            sensor->reg);
                 }
                 pmbus_clear_faults(client);
                 data->last_updated = jiffies;
@@ -443,15 +515,37 @@ static long pmbus_reg2data_direct(struct pmbus_data *data,
         return (val - b) / m;
 }
 
+/*
+ * Convert VID sensor values to milli- or micro-units
+ * depending on sensor type.
+ * We currently only support VR11.
+ */
+static long pmbus_reg2data_vid(struct pmbus_data *data,
+                               struct pmbus_sensor *sensor)
+{
+        long val = sensor->data;
+
+        if (val < 0x02 || val > 0xb2)
+                return 0;
+        return DIV_ROUND_CLOSEST(160000 - (val - 2) * 625, 100);
+}
+
 static long pmbus_reg2data(struct pmbus_data *data, struct pmbus_sensor *sensor)
 {
         long val;
 
-        if (data->info->direct[sensor->class])
+        switch (data->info->format[sensor->class]) {
+        case direct:
                 val = pmbus_reg2data_direct(data, sensor);
-        else
+                break;
+        case vid:
+                val = pmbus_reg2data_vid(data, sensor);
+                break;
+        case linear:
+        default:
                 val = pmbus_reg2data_linear(data, sensor);
-
+                break;
+        }
         return val;
 }
 
@@ -561,16 +655,31 @@ static u16 pmbus_data2reg_direct(struct pmbus_data *data,
         return val;
 }
 
+static u16 pmbus_data2reg_vid(struct pmbus_data *data,
+                              enum pmbus_sensor_classes class, long val)
+{
+        val = SENSORS_LIMIT(val, 500, 1600);
+
+        return 2 + DIV_ROUND_CLOSEST((1600 - val) * 100, 625);
+}
+
 static u16 pmbus_data2reg(struct pmbus_data *data,
                           enum pmbus_sensor_classes class, long val)
 {
         u16 regval;
 
-        if (data->info->direct[class])
+        switch (data->info->format[class]) {
+        case direct:
                 regval = pmbus_data2reg_direct(data, class, val);
-        else
+                break;
+        case vid:
+                regval = pmbus_data2reg_vid(data, class, val);
+                break;
+        case linear:
+        default:
                 regval = pmbus_data2reg_linear(data, class, val);
-
+                break;
+        }
         return regval;
 }
 
@@ -682,7 +791,7 @@ static ssize_t pmbus_set_sensor(struct device *dev,
 
         mutex_lock(&data->update_lock);
         regval = pmbus_data2reg(data, sensor->class, val);
-        ret = pmbus_write_word_data(client, sensor->page, sensor->reg, regval);
+        ret = _pmbus_write_word_data(client, sensor->page, sensor->reg, regval);
         if (ret < 0)
                 rv = ret;
         else
@@ -867,7 +976,8 @@ static void pmbus_find_max_attr(struct i2c_client *client,
  * and its associated alarm attribute.
  */
 struct pmbus_limit_attr {
-        u8 reg;                 /* Limit register */
+        u16 reg;                /* Limit register */
+        bool update;            /* True if register needs updates */
         const char *attr;       /* Attribute name */
         const char *alarm;      /* Alarm attribute name */
         u32 sbit;               /* Alarm attribute status bit */
@@ -912,9 +1022,10 @@ static bool pmbus_add_limit_attrs(struct i2c_client *client,
                 if (pmbus_check_word_register(client, page, l->reg)) {
                         cindex = data->num_sensors;
                         pmbus_add_sensor(data, name, l->attr, index, page,
-                                         l->reg, attr->class, attr->update,
+                                         l->reg, attr->class,
+                                         attr->update || l->update,
                                          false);
-                        if (info->func[page] & attr->sfunc) {
+                        if (l->sbit && (info->func[page] & attr->sfunc)) {
                                 if (attr->compare) {
                                         pmbus_add_boolean_cmp(data, name,
                                                 l->alarm, index,
@@ -953,9 +1064,11 @@ static void pmbus_add_sensor_attrs_one(struct i2c_client *client,
                                                    index, page, cbase, attr);
                 /*
                  * Add generic alarm attribute only if there are no individual
-                 * alarm attributes, and if there is a global alarm bit.
+                 * alarm attributes, if there is a global alarm bit, and if
+                 * the generic status register for this page is accessible.
                  */
-                if (!have_alarm && attr->gbit)
+                if (!have_alarm && attr->gbit &&
+                    pmbus_check_byte_register(client, page, PMBUS_STATUS_BYTE))
                         pmbus_add_boolean_reg(data, name, "alarm", index,
                                               PB_STATUS_BASE + page,
                                               attr->gbit);
@@ -1008,6 +1121,21 @@ static const struct pmbus_limit_attr vin_limit_attrs[] = {
                 .attr = "crit",
                 .alarm = "crit_alarm",
                 .sbit = PB_VOLTAGE_OV_FAULT,
+        }, {
+                .reg = PMBUS_VIRT_READ_VIN_AVG,
+                .update = true,
+                .attr = "average",
+        }, {
+                .reg = PMBUS_VIRT_READ_VIN_MIN,
+                .update = true,
+                .attr = "lowest",
+        }, {
+                .reg = PMBUS_VIRT_READ_VIN_MAX,
+                .update = true,
+                .attr = "highest",
+        }, {
+                .reg = PMBUS_VIRT_RESET_VIN_HISTORY,
+                .attr = "reset_history",
         },
 };
 
@@ -1032,6 +1160,21 @@ static const struct pmbus_limit_attr vout_limit_attrs[] = {
                 .attr = "crit",
                 .alarm = "crit_alarm",
                 .sbit = PB_VOLTAGE_OV_FAULT,
+        }, {
+                .reg = PMBUS_VIRT_READ_VOUT_AVG,
+                .update = true,
+                .attr = "average",
+        }, {
+                .reg = PMBUS_VIRT_READ_VOUT_MIN,
+                .update = true,
+                .attr = "lowest",
+        }, {
+                .reg = PMBUS_VIRT_READ_VOUT_MAX,
+                .update = true,
+                .attr = "highest",
+        }, {
+                .reg = PMBUS_VIRT_RESET_VOUT_HISTORY,
+                .attr = "reset_history",
         }
 };
 
@@ -1078,6 +1221,21 @@ static const struct pmbus_limit_attr iin_limit_attrs[] = {
                 .attr = "crit",
                 .alarm = "crit_alarm",
                 .sbit = PB_IIN_OC_FAULT,
+        }, {
+                .reg = PMBUS_VIRT_READ_IIN_AVG,
+                .update = true,
+                .attr = "average",
+        }, {
+                .reg = PMBUS_VIRT_READ_IIN_MIN,
+                .update = true,
+                .attr = "lowest",
+        }, {
+                .reg = PMBUS_VIRT_READ_IIN_MAX,
+                .update = true,
+                .attr = "highest",
+        }, {
+                .reg = PMBUS_VIRT_RESET_IIN_HISTORY,
+                .attr = "reset_history",
         }
 };
 
@@ -1097,6 +1255,21 @@ static const struct pmbus_limit_attr iout_limit_attrs[] = {
                 .attr = "crit",
                 .alarm = "crit_alarm",
                 .sbit = PB_IOUT_OC_FAULT,
+        }, {
+                .reg = PMBUS_VIRT_READ_IOUT_AVG,
+                .update = true,
+                .attr = "average",
+        }, {
+                .reg = PMBUS_VIRT_READ_IOUT_MIN,
+                .update = true,
+                .attr = "lowest",
+        }, {
+                .reg = PMBUS_VIRT_READ_IOUT_MAX,
+                .update = true,
+                .attr = "highest",
+        }, {
+                .reg = PMBUS_VIRT_RESET_IOUT_HISTORY,
+                .attr = "reset_history",
         }
 };
 
@@ -1132,6 +1305,17 @@ static const struct pmbus_limit_attr pin_limit_attrs[] = {
                 .attr = "max",
                 .alarm = "alarm",
                 .sbit = PB_PIN_OP_WARNING,
+        }, {
+                .reg = PMBUS_VIRT_READ_PIN_AVG,
+                .update = true,
+                .attr = "average",
+        }, {
+                .reg = PMBUS_VIRT_READ_PIN_MAX,
+                .update = true,
+                .attr = "input_highest",
+        }, {
+                .reg = PMBUS_VIRT_RESET_PIN_HISTORY,
+                .attr = "reset_history",
         }
 };
 
@@ -1200,6 +1384,39 @@ static const struct pmbus_limit_attr temp_limit_attrs[] = {
                 .attr = "crit",
                 .alarm = "crit_alarm",
                 .sbit = PB_TEMP_OT_FAULT,
+        }, {
+                .reg = PMBUS_VIRT_READ_TEMP_MIN,
+                .attr = "lowest",
+        }, {
+                .reg = PMBUS_VIRT_READ_TEMP_MAX,
+                .attr = "highest",
+        }, {
+                .reg = PMBUS_VIRT_RESET_TEMP_HISTORY,
+                .attr = "reset_history",
+        }
+};
+
+static const struct pmbus_limit_attr temp_limit_attrs23[] = {
+        {
+                .reg = PMBUS_UT_WARN_LIMIT,
+                .attr = "min",
+                .alarm = "min_alarm",
+                .sbit = PB_TEMP_UT_WARNING,
+        }, {
+                .reg = PMBUS_UT_FAULT_LIMIT,
+                .attr = "lcrit",
+                .alarm = "lcrit_alarm",
+                .sbit = PB_TEMP_UT_FAULT,
+        }, {
+                .reg = PMBUS_OT_WARN_LIMIT,
+                .attr = "max",
+                .alarm = "max_alarm",
+                .sbit = PB_TEMP_OT_WARNING,
+        }, {
+                .reg = PMBUS_OT_FAULT_LIMIT,
+                .attr = "crit",
+                .alarm = "crit_alarm",
+                .sbit = PB_TEMP_OT_FAULT,
         }
 };
 
@@ -1226,8 +1443,8 @@ static const struct pmbus_sensor_attr temp_attributes[] = {
                 .sfunc = PMBUS_HAVE_STATUS_TEMP,
                 .sbase = PB_STATUS_TEMP_BASE,
                 .gbit = PB_STATUS_TEMPERATURE,
-                .limit = temp_limit_attrs,
-                .nlimit = ARRAY_SIZE(temp_limit_attrs),
+                .limit = temp_limit_attrs23,
+                .nlimit = ARRAY_SIZE(temp_limit_attrs23),
         }, {
                 .reg = PMBUS_READ_TEMPERATURE_3,
                 .class = PSC_TEMPERATURE,
@@ -1238,8 +1455,8 @@ static const struct pmbus_sensor_attr temp_attributes[] = {
                 .sfunc = PMBUS_HAVE_STATUS_TEMP,
                 .sbase = PB_STATUS_TEMP_BASE,
                 .gbit = PB_STATUS_TEMPERATURE,
-                .limit = temp_limit_attrs,
-                .nlimit = ARRAY_SIZE(temp_limit_attrs),
+                .limit = temp_limit_attrs23,
+                .nlimit = ARRAY_SIZE(temp_limit_attrs23),
         }
 };
 
@@ -1380,7 +1597,7 @@ static int pmbus_identify_common(struct i2c_client *client,
                  */
                 switch (vout_mode >> 5) {
                 case 0: /* linear mode      */
-                        if (data->info->direct[PSC_VOLTAGE_OUT])
+                        if (data->info->format[PSC_VOLTAGE_OUT] != linear)
                                 return -ENODEV;
 
                         exponent = vout_mode & 0x1f;
@@ -1389,8 +1606,12 @@ static int pmbus_identify_common(struct i2c_client *client,
                                 exponent |= ~0x1f;
                         data->exponent = exponent;
                         break;
+                case 1: /* VID mode         */
+                        if (data->info->format[PSC_VOLTAGE_OUT] != vid)
+                                return -ENODEV;
+                        break;
                 case 2: /* direct mode      */
-                        if (!data->info->direct[PSC_VOLTAGE_OUT])
+                        if (data->info->format[PSC_VOLTAGE_OUT] != direct)
                                 return -ENODEV;
                         break;
                 default:
@@ -1457,18 +1678,6 @@ int pmbus_do_probe(struct i2c_client *client, const struct i2c_device_id *id,
                 ret = -EINVAL;
                 goto out_data;
         }
-        /*
-         * Bail out if more than one page was configured, but we can not
-         * select the highest page. This is an indication that the wrong
-         * chip type was selected. Better bail out now than keep
-         * returning errors later on.
-         */
-        if (info->pages > 1 && pmbus_set_page(client, info->pages - 1) < 0) {
-                dev_err(&client->dev, "Failed to select page %d\n",
-                        info->pages - 1);
-                ret = -EINVAL;
-                goto out_data;
-        }
 
         ret = pmbus_identify_common(client, data);
         if (ret < 0) {
diff --git a/drivers/hwmon/ucd9000.c b/drivers/hwmon/pmbus/ucd9000.c
index ace1c7319734..d0ddb60155c9 100644
--- a/drivers/hwmon/ucd9000.c
+++ b/drivers/hwmon/pmbus/ucd9000.c
@@ -141,13 +141,11 @@ static int ucd9000_probe(struct i2c_client *client,
         block_buffer[ret] = '\0';
         dev_info(&client->dev, "Device ID %s\n", block_buffer);
 
-        mid = NULL;
-        for (i = 0; i < ARRAY_SIZE(ucd9000_id); i++) {
-                mid = &ucd9000_id[i];
+        for (mid = ucd9000_id; mid->name[0]; mid++) {
                 if (!strncasecmp(mid->name, block_buffer, strlen(mid->name)))
                         break;
         }
-        if (!mid || !strlen(mid->name)) {
+        if (!mid->name[0]) {
                 dev_err(&client->dev, "Unsupported device\n");
                 return -ENODEV;
         }
diff --git a/drivers/hwmon/ucd9200.c b/drivers/hwmon/pmbus/ucd9200.c
index ffcc1cf3609d..c65e9da707cc 100644
--- a/drivers/hwmon/ucd9200.c
+++ b/drivers/hwmon/pmbus/ucd9200.c
@@ -68,13 +68,11 @@ static int ucd9200_probe(struct i2c_client *client,
         block_buffer[ret] = '\0';
         dev_info(&client->dev, "Device ID %s\n", block_buffer);
 
-        mid = NULL;
-        for (i = 0; i < ARRAY_SIZE(ucd9200_id); i++) {
-                mid = &ucd9200_id[i];
+        for (mid = ucd9200_id; mid->name[0]; mid++) {
                 if (!strncasecmp(mid->name, block_buffer, strlen(mid->name)))
                         break;
         }
-        if (!mid || !strlen(mid->name)) {
+        if (!mid->name[0]) {
                 dev_err(&client->dev, "Unsupported device\n");
                 return -ENODEV;
         }
diff --git a/drivers/i2c/busses/i2c-nomadik.c b/drivers/i2c/busses/i2c-nomadik.c
index 0c731ca69f15..b228e09c5d05 100644
--- a/drivers/i2c/busses/i2c-nomadik.c
+++ b/drivers/i2c/busses/i2c-nomadik.c
@@ -146,6 +146,7 @@ struct i2c_nmk_client {
  * @stop: stop condition
  * @xfer_complete: acknowledge completion for a I2C message
  * @result: controller propogated result
+ * @regulator: pointer to i2c regulator
  * @busy: Busy doing transfer
  */
 struct nmk_i2c_dev {
@@ -417,12 +418,12 @@ static int read_i2c(struct nmk_i2c_dev *dev)
         writel(readl(dev->virtbase + I2C_IMSCR) | irq_mask,
                         dev->virtbase + I2C_IMSCR);
 
-        timeout = wait_for_completion_interruptible_timeout(
+        timeout = wait_for_completion_timeout(
                 &dev->xfer_complete, dev->adap.timeout);
 
         if (timeout < 0) {
                 dev_err(&dev->pdev->dev,
-                        "wait_for_completion_interruptible_timeout"
+                        "wait_for_completion_timeout"
                         "returned %d waiting for event\n", timeout);
                 status = timeout;
         }
@@ -504,12 +505,12 @@ static int write_i2c(struct nmk_i2c_dev *dev)
         writel(readl(dev->virtbase + I2C_IMSCR) | irq_mask,
                         dev->virtbase + I2C_IMSCR);
 
-        timeout = wait_for_completion_interruptible_timeout(
+        timeout = wait_for_completion_timeout(
                 &dev->xfer_complete, dev->adap.timeout);
 
         if (timeout < 0) {
                 dev_err(&dev->pdev->dev,
-                        "wait_for_completion_interruptible_timeout"
+                        "wait_for_completion_timeout "
                         "returned %d waiting for event\n", timeout);
                 status = timeout;
         }
diff --git a/drivers/i2c/busses/i2c-omap.c b/drivers/i2c/busses/i2c-omap.c
index 1a766cf74f6b..2dfb63176856 100644
--- a/drivers/i2c/busses/i2c-omap.c
+++ b/drivers/i2c/busses/i2c-omap.c
@@ -1139,41 +1139,12 @@ omap_i2c_remove(struct platform_device *pdev)
         return 0;
 }
 
-#ifdef CONFIG_SUSPEND
-static int omap_i2c_suspend(struct device *dev)
-{
-        if (!pm_runtime_suspended(dev))
-                if (dev->bus && dev->bus->pm && dev->bus->pm->runtime_suspend)
-                        dev->bus->pm->runtime_suspend(dev);
-
-        return 0;
-}
-
-static int omap_i2c_resume(struct device *dev)
-{
-        if (!pm_runtime_suspended(dev))
-                if (dev->bus && dev->bus->pm && dev->bus->pm->runtime_resume)
-                        dev->bus->pm->runtime_resume(dev);
-
-        return 0;
-}
-
-static struct dev_pm_ops omap_i2c_pm_ops = {
-        .suspend = omap_i2c_suspend,
-        .resume = omap_i2c_resume,
-};
-#define OMAP_I2C_PM_OPS (&omap_i2c_pm_ops)
-#else
-#define OMAP_I2C_PM_OPS NULL
-#endif
-
 static struct platform_driver omap_i2c_driver = {
         .probe          = omap_i2c_probe,
         .remove         = omap_i2c_remove,
         .driver         = {
                 .name   = "omap_i2c",
                 .owner  = THIS_MODULE,
-                .pm     = OMAP_I2C_PM_OPS,
         },
 };
 
diff --git a/drivers/i2c/busses/i2c-pxa-pci.c b/drivers/i2c/busses/i2c-pxa-pci.c
index 6659d269b841..b73da6cd6f91 100644
--- a/drivers/i2c/busses/i2c-pxa-pci.c
+++ b/drivers/i2c/busses/i2c-pxa-pci.c
@@ -109,12 +109,15 @@ static int __devinit ce4100_i2c_probe(struct pci_dev *dev,
                 return -EINVAL;
         }
         sds = kzalloc(sizeof(*sds), GFP_KERNEL);
-        if (!sds)
+        if (!sds) {
+                ret = -ENOMEM;
                 goto err_mem;
+        }
 
         for (i = 0; i < ARRAY_SIZE(sds->pdev); i++) {
                 sds->pdev[i] = add_i2c_device(dev, i);
                 if (IS_ERR(sds->pdev[i])) {
+                        ret = PTR_ERR(sds->pdev[i]);
                         while (--i >= 0)
                                 platform_device_unregister(sds->pdev[i]);
                         goto err_dev_add;
diff --git a/drivers/i2c/busses/i2c-tegra.c b/drivers/i2c/busses/i2c-tegra.c
index 2440b7411978..3c94c4a81a55 100644
--- a/drivers/i2c/busses/i2c-tegra.c
+++ b/drivers/i2c/busses/i2c-tegra.c
@@ -270,14 +270,30 @@ static int tegra_i2c_fill_tx_fifo(struct tegra_i2c_dev *i2c_dev)
 
         /* Rounds down to not include partial word at the end of buf */
         words_to_transfer = buf_remaining / BYTES_PER_FIFO_WORD;
-        if (words_to_transfer > tx_fifo_avail)
-                words_to_transfer = tx_fifo_avail;
 
-        i2c_writesl(i2c_dev, buf, I2C_TX_FIFO, words_to_transfer);
-
-        buf += words_to_transfer * BYTES_PER_FIFO_WORD;
-        buf_remaining -= words_to_transfer * BYTES_PER_FIFO_WORD;
-        tx_fifo_avail -= words_to_transfer;
+        /* It's very common to have < 4 bytes, so optimize that case. */
+        if (words_to_transfer) {
+                if (words_to_transfer > tx_fifo_avail)
+                        words_to_transfer = tx_fifo_avail;
+
+                /*
+                 * Update state before writing to FIFO.  If this casues us
+                 * to finish writing all bytes (AKA buf_remaining goes to 0) we
+                 * have a potential for an interrupt (PACKET_XFER_COMPLETE is
+                 * not maskable).  We need to make sure that the isr sees
+                 * buf_remaining as 0 and doesn't call us back re-entrantly.
+                 */
+                buf_remaining -= words_to_transfer * BYTES_PER_FIFO_WORD;
+                tx_fifo_avail -= words_to_transfer;
+                i2c_dev->msg_buf_remaining = buf_remaining;
+                i2c_dev->msg_buf = buf +
+                        words_to_transfer * BYTES_PER_FIFO_WORD;
+                barrier();
+
+                i2c_writesl(i2c_dev, buf, I2C_TX_FIFO, words_to_transfer);
+
+                buf += words_to_transfer * BYTES_PER_FIFO_WORD;
+        }
 
         /*
          * If there is a partial word at the end of buf, handle it manually to
@@ -287,14 +303,15 @@ static int tegra_i2c_fill_tx_fifo(struct tegra_i2c_dev *i2c_dev)
         if (tx_fifo_avail > 0 && buf_remaining > 0) {
                 BUG_ON(buf_remaining > 3);
                 memcpy(&val, buf, buf_remaining);
+
+                /* Again update before writing to FIFO to make sure isr sees. */
+                i2c_dev->msg_buf_remaining = 0;
+                i2c_dev->msg_buf = NULL;
+                barrier();
+
                 i2c_writel(i2c_dev, val, I2C_TX_FIFO);
-                buf_remaining = 0;
-                tx_fifo_avail--;
         }
 
-        BUG_ON(tx_fifo_avail > 0 && buf_remaining > 0);
-        i2c_dev->msg_buf_remaining = buf_remaining;
-        i2c_dev->msg_buf = buf;
         return 0;
 }
 
@@ -411,9 +428,10 @@ static irqreturn_t tegra_i2c_isr(int irq, void *dev_id)
                         tegra_i2c_mask_irq(i2c_dev, I2C_INT_TX_FIFO_DATA_REQ);
         }
 
-        if ((status & I2C_INT_PACKET_XFER_COMPLETE) &&
-                        !i2c_dev->msg_buf_remaining)
+        if (status & I2C_INT_PACKET_XFER_COMPLETE) {
+                BUG_ON(i2c_dev->msg_buf_remaining);
                 complete(&i2c_dev->msg_complete);
+        }
 
         i2c_writel(i2c_dev, status, I2C_INT_STATUS);
         if (i2c_dev->is_dvc)
@@ -531,7 +549,7 @@ static int tegra_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msgs[],
 
 static u32 tegra_i2c_func(struct i2c_adapter *adap)
 {
-        return I2C_FUNC_I2C;
+        return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
 }
 
 static const struct i2c_algorithm tegra_i2c_algo = {
@@ -719,6 +737,17 @@ static int tegra_i2c_resume(struct platform_device *pdev)
 }
 #endif
 
+#if defined(CONFIG_OF)
+/* Match table for of_platform binding */
+static const struct of_device_id tegra_i2c_of_match[] __devinitconst = {
+        { .compatible = "nvidia,tegra20-i2c", },
+        {},
+};
+MODULE_DEVICE_TABLE(of, tegra_i2c_of_match);
+#else
+#define tegra_i2c_of_match NULL
+#endif
+
 static struct platform_driver tegra_i2c_driver = {
         .probe   = tegra_i2c_probe,
         .remove  = tegra_i2c_remove,
@@ -729,6 +758,7 @@ static struct platform_driver tegra_i2c_driver = {
         .driver  = {
                 .name  = "tegra-i2c",
                 .owner = THIS_MODULE,
+                .of_match_table = tegra_i2c_of_match,
         },
 };
 
diff --git a/drivers/ide/cy82c693.c b/drivers/ide/cy82c693.c
index 3be60da52123..67cbcfa35122 100644
--- a/drivers/ide/cy82c693.c
+++ b/drivers/ide/cy82c693.c
@@ -141,6 +141,8 @@ static void cy82c693_set_pio_mode(ide_hwif_t *hwif, ide_drive_t *drive)
                 pci_write_config_byte(dev, CY82_IDE_SLAVE_IOW, time_16);
                 pci_write_config_byte(dev, CY82_IDE_SLAVE_8BIT, time_8);
         }
+        if (hwif->index > 0)
+                pci_dev_put(dev);
 }
 
 static void __devinit init_iops_cy82c693(ide_hwif_t *hwif)
diff --git a/drivers/ide/ide_platform.c b/drivers/ide/ide_platform.c
index 542603b394e4..962693b10a1c 100644
--- a/drivers/ide/ide_platform.c
+++ b/drivers/ide/ide_platform.c
@@ -19,6 +19,7 @@
 #include <linux/module.h>
 #include <linux/ata_platform.h>
 #include <linux/platform_device.h>
+#include <linux/interrupt.h>
 #include <linux/io.h>
 
 static void __devinit plat_ide_setup_ports(struct ide_hw *hw,
@@ -95,7 +96,10 @@ static int __devinit plat_ide_probe(struct platform_device *pdev)
         plat_ide_setup_ports(&hw, base, alt_base, pdata, res_irq->start);
         hw.dev = &pdev->dev;
 
-        d.irq_flags = res_irq->flags;
+        d.irq_flags = res_irq->flags & IRQF_TRIGGER_MASK;
+        if (res_irq->flags & IORESOURCE_IRQ_SHAREABLE)
+                d.irq_flags |= IRQF_SHARED;
+
         if (mmio)
                 d.host_flags |= IDE_HFLAG_MMIO;
 
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_main.c b/drivers/infiniband/ulp/ipoib/ipoib_main.c
index 43f89ba0a908..fe89c4660d55 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_main.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_main.c
@@ -717,11 +717,13 @@ static int ipoib_start_xmit(struct sk_buff *skb, struct net_device *dev)
 {
         struct ipoib_dev_priv *priv = netdev_priv(dev);
         struct ipoib_neigh *neigh;
-        struct neighbour *n;
+        struct neighbour *n = NULL;
         unsigned long flags;
 
-        n = dst_get_neighbour(skb_dst(skb));
-        if (likely(skb_dst(skb) && n)) {
+        if (likely(skb_dst(skb)))
+                n = dst_get_neighbour(skb_dst(skb));
+
+        if (likely(n)) {
                 if (unlikely(!*to_ipoib_neigh(n))) {
                         ipoib_path_lookup(skb, dev);
                         return NETDEV_TX_OK;
diff --git a/drivers/infiniband/ulp/iser/iscsi_iser.c b/drivers/infiniband/ulp/iser/iscsi_iser.c
index 8db008de5392..9c61b9c2c597 100644
--- a/drivers/infiniband/ulp/iser/iscsi_iser.c
+++ b/drivers/infiniband/ulp/iser/iscsi_iser.c
@@ -101,13 +101,17 @@ iscsi_iser_recv(struct iscsi_conn *conn,
 
         /* verify PDU length */
         datalen = ntoh24(hdr->dlength);
-        if (datalen != rx_data_len) {
-                printk(KERN_ERR "iscsi_iser: datalen %d (hdr) != %d (IB) \n",
-                       datalen, rx_data_len);
+        if (datalen > rx_data_len || (datalen + 4) < rx_data_len) {
+                iser_err("wrong datalen %d (hdr), %d (IB)\n",
+                        datalen, rx_data_len);
                 rc = ISCSI_ERR_DATALEN;
                 goto error;
         }
 
+        if (datalen != rx_data_len)
+                iser_dbg("aligned datalen (%d) hdr, %d (IB)\n",
+                        datalen, rx_data_len);
+
         /* read AHS */
         ahslen = hdr->hlength * 4;
 
diff --git a/drivers/infiniband/ulp/iser/iscsi_iser.h b/drivers/infiniband/ulp/iser/iscsi_iser.h
index 342cbc1bdaae..db6f3ce9f3bf 100644
--- a/drivers/infiniband/ulp/iser/iscsi_iser.h
+++ b/drivers/infiniband/ulp/iser/iscsi_iser.h
@@ -89,7 +89,7 @@
         } while (0)
 
 #define SHIFT_4K        12
-#define SIZE_4K (1UL << SHIFT_4K)
+#define SIZE_4K (1ULL << SHIFT_4K)
 #define MASK_4K (~(SIZE_4K-1))
 
                                         /* support up to 512KB in one RDMA */
diff --git a/drivers/infiniband/ulp/iser/iser_initiator.c b/drivers/infiniband/ulp/iser/iser_initiator.c
index 5745b7fe158c..f299de6b419b 100644
--- a/drivers/infiniband/ulp/iser/iser_initiator.c
+++ b/drivers/infiniband/ulp/iser/iser_initiator.c
@@ -412,7 +412,7 @@ int iser_send_control(struct iscsi_conn *conn,
                 memcpy(iser_conn->ib_conn->login_buf, task->data,
                                                         task->data_count);
                 tx_dsg->addr    = iser_conn->ib_conn->login_dma;
-                tx_dsg->length  = data_seg_len;
+                tx_dsg->length  = task->data_count;
                 tx_dsg->lkey    = device->mr->lkey;
                 mdesc->num_sge = 2;
         }
diff --git a/drivers/input/joystick/analog.c b/drivers/input/joystick/analog.c
index 9882971827e6..358cd7ee905b 100644
--- a/drivers/input/joystick/analog.c
+++ b/drivers/input/joystick/analog.c
@@ -139,7 +139,7 @@ struct analog_port {
 #include <linux/i8253.h>
 
 #define GET_TIME(x)     do { if (cpu_has_tsc) rdtscl(x); else x = get_time_pit(); } while (0)
-#define DELTA(x,y)      (cpu_has_tsc ? ((y) - (x)) : ((x) - (y) + ((x) < (y) ? CLOCK_TICK_RATE / HZ : 0)))
+#define DELTA(x,y)      (cpu_has_tsc ? ((y) - (x)) : ((x) - (y) + ((x) < (y) ? PIT_TICK_RATE / HZ : 0)))
 #define TIME_NAME       (cpu_has_tsc?"TSC":"PIT")
 static unsigned int get_time_pit(void)
 {
diff --git a/drivers/input/keyboard/ep93xx_keypad.c b/drivers/input/keyboard/ep93xx_keypad.c
index c8242dd190d0..aa17e024d803 100644
--- a/drivers/input/keyboard/ep93xx_keypad.c
+++ b/drivers/input/keyboard/ep93xx_keypad.c
@@ -20,6 +20,7 @@
  * flag.
  */
 
+#include <linux/module.h>
 #include <linux/platform_device.h>
 #include <linux/interrupt.h>
 #include <linux/clk.h>
diff --git a/drivers/input/keyboard/gpio_keys.c b/drivers/input/keyboard/gpio_keys.c
index ce281d152275..67df91af8424 100644
--- a/drivers/input/keyboard/gpio_keys.c
+++ b/drivers/input/keyboard/gpio_keys.c
@@ -483,7 +483,7 @@ static int gpio_keys_get_devtree_pdata(struct device *dev,
 
         buttons = kzalloc(pdata->nbuttons * (sizeof *buttons), GFP_KERNEL);
         if (!buttons)
-                return -ENODEV;
+                return -ENOMEM;
 
         pp = NULL;
         i = 0;
diff --git a/drivers/input/keyboard/lm8323.c b/drivers/input/keyboard/lm8323.c
index ab0acaf7fe8f..756348a7f93a 100644
--- a/drivers/input/keyboard/lm8323.c
+++ b/drivers/input/keyboard/lm8323.c
@@ -754,8 +754,11 @@ fail3:
         device_remove_file(&client->dev, &dev_attr_disable_kp);
 fail2:
         while (--pwm >= 0)
-                if (lm->pwm[pwm].enabled)
+                if (lm->pwm[pwm].enabled) {
+                        device_remove_file(lm->pwm[pwm].cdev.dev,
+                                           &dev_attr_time);
                         led_classdev_unregister(&lm->pwm[pwm].cdev);
+                }
 fail1:
         input_free_device(idev);
         kfree(lm);
@@ -775,8 +778,10 @@ static int __devexit lm8323_remove(struct i2c_client *client)
         device_remove_file(&lm->client->dev, &dev_attr_disable_kp);
 
         for (i = 0; i < 3; i++)
-                if (lm->pwm[i].enabled)
+                if (lm->pwm[i].enabled) {
+                        device_remove_file(lm->pwm[i].cdev.dev, &dev_attr_time);
                         led_classdev_unregister(&lm->pwm[i].cdev);
+                }
 
         kfree(lm);
 
diff --git a/drivers/input/keyboard/tegra-kbc.c b/drivers/input/keyboard/tegra-kbc.c
index da3828fc2c09..a5a77915c650 100644
--- a/drivers/input/keyboard/tegra-kbc.c
+++ b/drivers/input/keyboard/tegra-kbc.c
@@ -19,6 +19,7 @@
  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
+#include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/input.h>
 #include <linux/platform_device.h>
@@ -37,7 +38,7 @@
 #define KBC_ROW_SCAN_DLY        5
 
 /* KBC uses a 32KHz clock so a cycle = 1/32Khz */
-#define KBC_CYCLE_USEC  32
+#define KBC_CYCLE_MS    32
 
 /* KBC Registers */
 
@@ -647,7 +648,7 @@ static int __devinit tegra_kbc_probe(struct platform_device *pdev)
         debounce_cnt = min(pdata->debounce_cnt, KBC_MAX_DEBOUNCE_CNT);
         scan_time_rows = (KBC_ROW_SCAN_TIME + debounce_cnt) * num_rows;
         kbc->repoll_dly = KBC_ROW_SCAN_DLY + scan_time_rows + pdata->repeat_cnt;
-        kbc->repoll_dly = ((kbc->repoll_dly * KBC_CYCLE_USEC) + 999) / 1000;
+        kbc->repoll_dly = DIV_ROUND_UP(kbc->repoll_dly, KBC_CYCLE_MS);
 
         input_dev->name = pdev->name;
         input_dev->id.bustype = BUS_HOST;
@@ -701,7 +702,7 @@ err_iounmap:
 err_free_mem_region:
         release_mem_region(res->start, resource_size(res));
 err_free_mem:
-        input_free_device(kbc->idev);
+        input_free_device(input_dev);
         kfree(kbc);
 
         return err;
diff --git a/drivers/input/misc/ad714x-i2c.c b/drivers/input/misc/ad714x-i2c.c
index e21deb1baa8a..025417d74ca2 100644
--- a/drivers/input/misc/ad714x-i2c.c
+++ b/drivers/input/misc/ad714x-i2c.c
@@ -1,7 +1,7 @@
 /*
  * AD714X CapTouch Programmable Controller driver (I2C bus)
  *
- * Copyright 2009 Analog Devices Inc.
+ * Copyright 2009-2011 Analog Devices Inc.
  *
  * Licensed under the GPL-2 or later.
  */
@@ -27,54 +27,49 @@ static int ad714x_i2c_resume(struct device *dev)
 
 static SIMPLE_DEV_PM_OPS(ad714x_i2c_pm, ad714x_i2c_suspend, ad714x_i2c_resume);
 
-static int ad714x_i2c_write(struct device *dev, unsigned short reg,
-                                unsigned short data)
+static int ad714x_i2c_write(struct ad714x_chip *chip,
+                            unsigned short reg, unsigned short data)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        int ret = 0;
-        u8 *_reg = (u8 *)&reg;
-        u8 *_data = (u8 *)&data;
-
-        u8 tx[4] = {
-                _reg[1],
-                _reg[0],
-                _data[1],
-                _data[0]
-        };
-
-        ret = i2c_master_send(client, tx, 4);
-        if (ret < 0)
-                dev_err(&client->dev, "I2C write error\n");
-
-        return ret;
+        struct i2c_client *client = to_i2c_client(chip->dev);
+        int error;
+
+        chip->xfer_buf[0] = cpu_to_be16(reg);
+        chip->xfer_buf[1] = cpu_to_be16(data);
+
+        error = i2c_master_send(client, (u8 *)chip->xfer_buf,
+                                2 * sizeof(*chip->xfer_buf));
+        if (unlikely(error < 0)) {
+                dev_err(&client->dev, "I2C write error: %d\n", error);
+                return error;
+        }
+
+        return 0;
 }
 
-static int ad714x_i2c_read(struct device *dev, unsigned short reg,
-                                unsigned short *data)
+static int ad714x_i2c_read(struct ad714x_chip *chip,
+                           unsigned short reg, unsigned short *data, size_t len)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        int ret = 0;
-        u8 *_reg = (u8 *)&reg;
-        u8 *_data = (u8 *)data;
-
-        u8 tx[2] = {
-                _reg[1],
-                _reg[0]
-        };
-        u8 rx[2];
-
-        ret = i2c_master_send(client, tx, 2);
-        if (ret >= 0)
-                ret = i2c_master_recv(client, rx, 2);
-
-        if (unlikely(ret < 0)) {
-                dev_err(&client->dev, "I2C read error\n");
-        } else {
-                _data[0] = rx[1];
-                _data[1] = rx[0];
+        struct i2c_client *client = to_i2c_client(chip->dev);
+        int i;
+        int error;
+
+        chip->xfer_buf[0] = cpu_to_be16(reg);
+
+        error = i2c_master_send(client, (u8 *)chip->xfer_buf,
+                                sizeof(*chip->xfer_buf));
+        if (error >= 0)
+                error = i2c_master_recv(client, (u8 *)chip->xfer_buf,
+                                        len * sizeof(*chip->xfer_buf));
+
+        if (unlikely(error < 0)) {
+                dev_err(&client->dev, "I2C read error: %d\n", error);
+                return error;
         }
 
-        return ret;
+        for (i = 0; i < len; i++)
+                data[i] = be16_to_cpu(chip->xfer_buf[i]);
+
+        return 0;
 }
 
 static int __devinit ad714x_i2c_probe(struct i2c_client *client,
diff --git a/drivers/input/misc/ad714x-spi.c b/drivers/input/misc/ad714x-spi.c
index 4120dd549305..875b50811361 100644
--- a/drivers/input/misc/ad714x-spi.c
+++ b/drivers/input/misc/ad714x-spi.c
@@ -1,12 +1,12 @@
 /*
  * AD714X CapTouch Programmable Controller driver (SPI bus)
  *
- * Copyright 2009 Analog Devices Inc.
+ * Copyright 2009-2011 Analog Devices Inc.
  *
  * Licensed under the GPL-2 or later.
  */
 
-#include <linux/input.h>        /* BUS_I2C */
+#include <linux/input.h>        /* BUS_SPI */
 #include <linux/module.h>
 #include <linux/spi/spi.h>
 #include <linux/pm.h>
@@ -30,30 +30,68 @@ static int ad714x_spi_resume(struct device *dev)
 
 static SIMPLE_DEV_PM_OPS(ad714x_spi_pm, ad714x_spi_suspend, ad714x_spi_resume);
 
-static int ad714x_spi_read(struct device *dev, unsigned short reg,
-                unsigned short *data)
+static int ad714x_spi_read(struct ad714x_chip *chip,
+                           unsigned short reg, unsigned short *data, size_t len)
 {
-        struct spi_device *spi = to_spi_device(dev);
-        unsigned short tx = AD714x_SPI_CMD_PREFIX | AD714x_SPI_READ | reg;
+        struct spi_device *spi = to_spi_device(chip->dev);
+        struct spi_message message;
+        struct spi_transfer xfer[2];
+        int i;
+        int error;
+
+        spi_message_init(&message);
+        memset(xfer, 0, sizeof(xfer));
+
+        chip->xfer_buf[0] = cpu_to_be16(AD714x_SPI_CMD_PREFIX |
+                                        AD714x_SPI_READ | reg);
+        xfer[0].tx_buf = &chip->xfer_buf[0];
+        xfer[0].len = sizeof(chip->xfer_buf[0]);
+        spi_message_add_tail(&xfer[0], &message);
+
+        xfer[1].rx_buf = &chip->xfer_buf[1];
+        xfer[1].len = sizeof(chip->xfer_buf[1]) * len;
+        spi_message_add_tail(&xfer[1], &message);
+
+        error = spi_sync(spi, &message);
+        if (unlikely(error)) {
+                dev_err(chip->dev, "SPI read error: %d\n", error);
+                return error;
+        }
+
+        for (i = 0; i < len; i++)
+                data[i] = be16_to_cpu(chip->xfer_buf[i + 1]);
 
-        return spi_write_then_read(spi, (u8 *)&tx, 2, (u8 *)data, 2);
+        return 0;
 }
 
-static int ad714x_spi_write(struct device *dev, unsigned short reg,
-                unsigned short data)
+static int ad714x_spi_write(struct ad714x_chip *chip,
+                            unsigned short reg, unsigned short data)
 {
-        struct spi_device *spi = to_spi_device(dev);
-        unsigned short tx[2] = {
-                AD714x_SPI_CMD_PREFIX | reg,
-                data
-        };
+        struct spi_device *spi = to_spi_device(chip->dev);
+        int error;
+
+        chip->xfer_buf[0] = cpu_to_be16(AD714x_SPI_CMD_PREFIX | reg);
+        chip->xfer_buf[1] = cpu_to_be16(data);
+
+        error = spi_write(spi, (u8 *)chip->xfer_buf,
+                          2 * sizeof(*chip->xfer_buf));
+        if (unlikely(error)) {
+                dev_err(chip->dev, "SPI write error: %d\n", error);
+                return error;
+        }
 
-        return spi_write(spi, (u8 *)tx, 4);
+        return 0;
 }
 
 static int __devinit ad714x_spi_probe(struct spi_device *spi)
 {
         struct ad714x_chip *chip;
+        int err;
+
+        spi->bits_per_word = 8;
+        err = spi_setup(spi);
+        if (err < 0)
+                return err;
 
         chip = ad714x_probe(&spi->dev, BUS_SPI, spi->irq,
                             ad714x_spi_read, ad714x_spi_write);
diff --git a/drivers/input/misc/ad714x.c b/drivers/input/misc/ad714x.c
index c3a62c42cd28..ca42c7d2a3c7 100644
--- a/drivers/input/misc/ad714x.c
+++ b/drivers/input/misc/ad714x.c
@@ -1,7 +1,7 @@
 /*
  * AD714X CapTouch Programmable Controller driver supporting AD7142/3/7/8/7A
  *
- * Copyright 2009 Analog Devices Inc.
+ * Copyright 2009-2011 Analog Devices Inc.
  *
  * Licensed under the GPL-2 or later.
  */
@@ -59,7 +59,6 @@
 #define STAGE11_AMBIENT         0x27D
 
 #define PER_STAGE_REG_NUM      36
-#define STAGE_NUM              12
 #define STAGE_CFGREG_NUM       8
 #define SYS_CFGREG_NUM         8
 
@@ -124,27 +123,6 @@ struct ad714x_driver_data {
  * information to integrate all things which will be private data
  * of spi/i2c device
  */
-struct ad714x_chip {
-        unsigned short h_state;
-        unsigned short l_state;
-        unsigned short c_state;
-        unsigned short adc_reg[STAGE_NUM];
-        unsigned short amb_reg[STAGE_NUM];
-        unsigned short sensor_val[STAGE_NUM];
-
-        struct ad714x_platform_data *hw;
-        struct ad714x_driver_data *sw;
-
-        int irq;
-        struct device *dev;
-        ad714x_read_t read;
-        ad714x_write_t write;
-
-        struct mutex mutex;
-
-        unsigned product;
-        unsigned version;
-};
 
 static void ad714x_use_com_int(struct ad714x_chip *ad714x,
                                 int start_stage, int end_stage)
@@ -154,13 +132,13 @@ static void ad714x_use_com_int(struct ad714x_chip *ad714x,
 
         mask = ((1 << (end_stage + 1)) - 1) - ((1 << start_stage) - 1);
 
-        ad714x->read(ad714x->dev, STG_COM_INT_EN_REG, &data);
+        ad714x->read(ad714x, STG_COM_INT_EN_REG, &data, 1);
         data |= 1 << end_stage;
-        ad714x->write(ad714x->dev, STG_COM_INT_EN_REG, data);
+        ad714x->write(ad714x, STG_COM_INT_EN_REG, data);
 
-        ad714x->read(ad714x->dev, STG_HIGH_INT_EN_REG, &data);
+        ad714x->read(ad714x, STG_HIGH_INT_EN_REG, &data, 1);
         data &= ~mask;
-        ad714x->write(ad714x->dev, STG_HIGH_INT_EN_REG, data);
+        ad714x->write(ad714x, STG_HIGH_INT_EN_REG, data);
 }
 
 static void ad714x_use_thr_int(struct ad714x_chip *ad714x,
@@ -171,13 +149,13 @@ static void ad714x_use_thr_int(struct ad714x_chip *ad714x,
 
         mask = ((1 << (end_stage + 1)) - 1) - ((1 << start_stage) - 1);
 
-        ad714x->read(ad714x->dev, STG_COM_INT_EN_REG, &data);
+        ad714x->read(ad714x, STG_COM_INT_EN_REG, &data, 1);
         data &= ~(1 << end_stage);
-        ad714x->write(ad714x->dev, STG_COM_INT_EN_REG, data);
+        ad714x->write(ad714x, STG_COM_INT_EN_REG, data);
 
-        ad714x->read(ad714x->dev, STG_HIGH_INT_EN_REG, &data);
+        ad714x->read(ad714x, STG_HIGH_INT_EN_REG, &data, 1);
         data |= mask;
-        ad714x->write(ad714x->dev, STG_HIGH_INT_EN_REG, data);
+        ad714x->write(ad714x, STG_HIGH_INT_EN_REG, data);
 }
 
 static int ad714x_cal_highest_stage(struct ad714x_chip *ad714x,
@@ -273,15 +251,16 @@ static void ad714x_slider_cal_sensor_val(struct ad714x_chip *ad714x, int idx)
         struct ad714x_slider_plat *hw = &ad714x->hw->slider[idx];
         int i;
 
+        ad714x->read(ad714x, CDC_RESULT_S0 + hw->start_stage,
+                        &ad714x->adc_reg[hw->start_stage],
+                        hw->end_stage - hw->start_stage + 1);
+
         for (i = hw->start_stage; i <= hw->end_stage; i++) {
-                ad714x->read(ad714x->dev, CDC_RESULT_S0 + i,
-                        &ad714x->adc_reg[i]);
-                ad714x->read(ad714x->dev,
-                                STAGE0_AMBIENT + i * PER_STAGE_REG_NUM,
-                                &ad714x->amb_reg[i]);
-
-                ad714x->sensor_val[i] = abs(ad714x->adc_reg[i] -
-                                ad714x->amb_reg[i]);
+                ad714x->read(ad714x, STAGE0_AMBIENT + i * PER_STAGE_REG_NUM,
+                                &ad714x->amb_reg[i], 1);
+
+                ad714x->sensor_val[i] =
+                        abs(ad714x->adc_reg[i] - ad714x->amb_reg[i]);
         }
 }
 
@@ -444,15 +423,16 @@ static void ad714x_wheel_cal_sensor_val(struct ad714x_chip *ad714x, int idx)
         struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
         int i;
 
+        ad714x->read(ad714x, CDC_RESULT_S0 + hw->start_stage,
+                        &ad714x->adc_reg[hw->start_stage],
+                        hw->end_stage - hw->start_stage + 1);
+
         for (i = hw->start_stage; i <= hw->end_stage; i++) {
-                ad714x->read(ad714x->dev, CDC_RESULT_S0 + i,
-                        &ad714x->adc_reg[i]);
-                ad714x->read(ad714x->dev,
-                                STAGE0_AMBIENT + i * PER_STAGE_REG_NUM,
-                                &ad714x->amb_reg[i]);
+                ad714x->read(ad714x, STAGE0_AMBIENT + i * PER_STAGE_REG_NUM,
+                                &ad714x->amb_reg[i], 1);
                 if (ad714x->adc_reg[i] > ad714x->amb_reg[i])
-                        ad714x->sensor_val[i] = ad714x->adc_reg[i] -
-                                ad714x->amb_reg[i];
+                        ad714x->sensor_val[i] =
+                                ad714x->adc_reg[i] - ad714x->amb_reg[i];
                 else
                         ad714x->sensor_val[i] = 0;
         }
@@ -597,15 +577,16 @@ static void touchpad_cal_sensor_val(struct ad714x_chip *ad714x, int idx)
         struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
         int i;
 
+        ad714x->read(ad714x, CDC_RESULT_S0 + hw->x_start_stage,
+                        &ad714x->adc_reg[hw->x_start_stage],
+                        hw->x_end_stage - hw->x_start_stage + 1);
+
         for (i = hw->x_start_stage; i <= hw->x_end_stage; i++) {
-                ad714x->read(ad714x->dev, CDC_RESULT_S0 + i,
-                                &ad714x->adc_reg[i]);
-                ad714x->read(ad714x->dev,
-                                STAGE0_AMBIENT + i * PER_STAGE_REG_NUM,
-                                &ad714x->amb_reg[i]);
+                ad714x->read(ad714x, STAGE0_AMBIENT + i * PER_STAGE_REG_NUM,
+                                &ad714x->amb_reg[i], 1);
                 if (ad714x->adc_reg[i] > ad714x->amb_reg[i])
-                        ad714x->sensor_val[i] = ad714x->adc_reg[i] -
-                                ad714x->amb_reg[i];
+                        ad714x->sensor_val[i] =
+                                ad714x->adc_reg[i] - ad714x->amb_reg[i];
                 else
                         ad714x->sensor_val[i] = 0;
         }
@@ -891,7 +872,7 @@ static int ad714x_hw_detect(struct ad714x_chip *ad714x)
 {
         unsigned short data;
 
-        ad714x->read(ad714x->dev, AD714X_PARTID_REG, &data);
+        ad714x->read(ad714x, AD714X_PARTID_REG, &data, 1);
         switch (data & 0xFFF0) {
         case AD7142_PARTID:
                 ad714x->product = 0x7142;
@@ -940,23 +921,20 @@ static void ad714x_hw_init(struct ad714x_chip *ad714x)
         for (i = 0; i < STAGE_NUM; i++) {
                 reg_base = AD714X_STAGECFG_REG + i * STAGE_CFGREG_NUM;
                 for (j = 0; j < STAGE_CFGREG_NUM; j++)
-                        ad714x->write(ad714x->dev, reg_base + j,
+                        ad714x->write(ad714x, reg_base + j,
                                         ad714x->hw->stage_cfg_reg[i][j]);
         }
 
         for (i = 0; i < SYS_CFGREG_NUM; i++)
-                ad714x->write(ad714x->dev, AD714X_SYSCFG_REG + i,
+                ad714x->write(ad714x, AD714X_SYSCFG_REG + i,
                         ad714x->hw->sys_cfg_reg[i]);
         for (i = 0; i < SYS_CFGREG_NUM; i++)
-                ad714x->read(ad714x->dev, AD714X_SYSCFG_REG + i,
-                        &data);
+                ad714x->read(ad714x, AD714X_SYSCFG_REG + i, &data, 1);
 
-        ad714x->write(ad714x->dev, AD714X_STG_CAL_EN_REG, 0xFFF);
+        ad714x->write(ad714x, AD714X_STG_CAL_EN_REG, 0xFFF);
 
         /* clear all interrupts */
-        ad714x->read(ad714x->dev, STG_LOW_INT_STA_REG, &data);
-        ad714x->read(ad714x->dev, STG_HIGH_INT_STA_REG, &data);
-        ad714x->read(ad714x->dev, STG_COM_INT_STA_REG, &data);
+        ad714x->read(ad714x, STG_LOW_INT_STA_REG, &ad714x->l_state, 3);
 }
 
 static irqreturn_t ad714x_interrupt_thread(int irq, void *data)
@@ -966,9 +944,7 @@ static irqreturn_t ad714x_interrupt_thread(int irq, void *data)
 
         mutex_lock(&ad714x->mutex);
 
-        ad714x->read(ad714x->dev, STG_LOW_INT_STA_REG, &ad714x->l_state);
-        ad714x->read(ad714x->dev, STG_HIGH_INT_STA_REG, &ad714x->h_state);
-        ad714x->read(ad714x->dev, STG_COM_INT_STA_REG, &ad714x->c_state);
+        ad714x->read(ad714x, STG_LOW_INT_STA_REG, &ad714x->l_state, 3);
 
         for (i = 0; i < ad714x->hw->button_num; i++)
                 ad714x_button_state_machine(ad714x, i);
@@ -1245,7 +1221,7 @@ int ad714x_disable(struct ad714x_chip *ad714x)
         mutex_lock(&ad714x->mutex);
 
         data = ad714x->hw->sys_cfg_reg[AD714X_PWR_CTRL] | 0x3;
-        ad714x->write(ad714x->dev, AD714X_PWR_CTRL, data);
+        ad714x->write(ad714x, AD714X_PWR_CTRL, data);
 
         mutex_unlock(&ad714x->mutex);
 
@@ -1255,24 +1231,20 @@ EXPORT_SYMBOL(ad714x_disable);
 
 int ad714x_enable(struct ad714x_chip *ad714x)
 {
-        unsigned short data;
-
         dev_dbg(ad714x->dev, "%s enter\n", __func__);
 
         mutex_lock(&ad714x->mutex);
 
         /* resume to non-shutdown mode */
 
-        ad714x->write(ad714x->dev, AD714X_PWR_CTRL,
+        ad714x->write(ad714x, AD714X_PWR_CTRL,
                         ad714x->hw->sys_cfg_reg[AD714X_PWR_CTRL]);
 
         /* make sure the interrupt output line is not low level after resume,
          * otherwise we will get no chance to enter falling-edge irq again
          */
 
-        ad714x->read(ad714x->dev, STG_LOW_INT_STA_REG, &data);
-        ad714x->read(ad714x->dev, STG_HIGH_INT_STA_REG, &data);
-        ad714x->read(ad714x->dev, STG_COM_INT_STA_REG, &data);
+        ad714x->read(ad714x, STG_LOW_INT_STA_REG, &ad714x->l_state, 3);
 
         mutex_unlock(&ad714x->mutex);
 
diff --git a/drivers/input/misc/ad714x.h b/drivers/input/misc/ad714x.h
index 45c54fb13f07..3c85455aa66d 100644
--- a/drivers/input/misc/ad714x.h
+++ b/drivers/input/misc/ad714x.h
@@ -1,7 +1,7 @@
 /*
  * AD714X CapTouch Programmable Controller driver (bus interfaces)
  *
- * Copyright 2009 Analog Devices Inc.
+ * Copyright 2009-2011 Analog Devices Inc.
  *
  * Licensed under the GPL-2 or later.
  */
@@ -11,11 +11,40 @@
 
 #include <linux/types.h>
 
+#define STAGE_NUM              12
+
 struct device;
+struct ad714x_platform_data;
+struct ad714x_driver_data;
 struct ad714x_chip;
 
-typedef int (*ad714x_read_t)(struct device *, unsigned short, unsigned short *);
-typedef int (*ad714x_write_t)(struct device *, unsigned short, unsigned short);
+typedef int (*ad714x_read_t)(struct ad714x_chip *, unsigned short, unsigned short *, size_t);
+typedef int (*ad714x_write_t)(struct ad714x_chip *, unsigned short, unsigned short);
+
+struct ad714x_chip {
+        unsigned short l_state;
+        unsigned short h_state;
+        unsigned short c_state;
+        unsigned short adc_reg[STAGE_NUM];
+        unsigned short amb_reg[STAGE_NUM];
+        unsigned short sensor_val[STAGE_NUM];
+
+        struct ad714x_platform_data *hw;
+        struct ad714x_driver_data *sw;
+
+        int irq;
+        struct device *dev;
+        ad714x_read_t read;
+        ad714x_write_t write;
+
+        struct mutex mutex;
+
+        unsigned product;
+        unsigned version;
+
+        __be16 xfer_buf[16] ____cacheline_aligned;
+
+};
 
 int ad714x_disable(struct ad714x_chip *ad714x);
 int ad714x_enable(struct ad714x_chip *ad714x);
diff --git a/drivers/input/misc/kxtj9.c b/drivers/input/misc/kxtj9.c
index c456f63b6bae..783597a9a64a 100644
--- a/drivers/input/misc/kxtj9.c
+++ b/drivers/input/misc/kxtj9.c
@@ -21,6 +21,7 @@
 #include <linux/i2c.h>
 #include <linux/input.h>
 #include <linux/interrupt.h>
+#include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/input/kxtj9.h>
 #include <linux/input-polldev.h>
diff --git a/drivers/input/misc/mma8450.c b/drivers/input/misc/mma8450.c
index 20f8f9284f02..0794778295fc 100644
--- a/drivers/input/misc/mma8450.c
+++ b/drivers/input/misc/mma8450.c
@@ -24,6 +24,7 @@
 #include <linux/delay.h>
 #include <linux/i2c.h>
 #include <linux/input-polldev.h>
+#include <linux/of_device.h>
 
 #define MMA8450_DRV_NAME        "mma8450"
 
@@ -229,10 +230,17 @@ static const struct i2c_device_id mma8450_id[] = {
 };
 MODULE_DEVICE_TABLE(i2c, mma8450_id);
 
+static const struct of_device_id mma8450_dt_ids[] = {
+        { .compatible = "fsl,mma8450", },
+        { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, mma8450_dt_ids);
+
 static struct i2c_driver mma8450_driver = {
         .driver = {
                 .name   = MMA8450_DRV_NAME,
                 .owner  = THIS_MODULE,
+                .of_match_table = mma8450_dt_ids,
         },
         .probe          = mma8450_probe,
         .remove         = __devexit_p(mma8450_remove),
diff --git a/drivers/input/misc/mpu3050.c b/drivers/input/misc/mpu3050.c
index b95fac15b2ea..f71dc728da58 100644
--- a/drivers/input/misc/mpu3050.c
+++ b/drivers/input/misc/mpu3050.c
@@ -282,7 +282,7 @@ err_free_irq:
 err_pm_set_suspended:
         pm_runtime_set_suspended(&client->dev);
 err_free_mem:
-        input_unregister_device(idev);
+        input_free_device(idev);
         kfree(sensor);
         return error;
 }
diff --git a/drivers/input/mouse/bcm5974.c b/drivers/input/mouse/bcm5974.c
index 3126983c004a..da280189ef07 100644
--- a/drivers/input/mouse/bcm5974.c
+++ b/drivers/input/mouse/bcm5974.c
@@ -67,6 +67,14 @@
 #define USB_DEVICE_ID_APPLE_WELLSPRING5_ANSI    0x0245
 #define USB_DEVICE_ID_APPLE_WELLSPRING5_ISO     0x0246
 #define USB_DEVICE_ID_APPLE_WELLSPRING5_JIS     0x0247
+/* MacbookAir4,2 (unibody, July 2011) */
+#define USB_DEVICE_ID_APPLE_WELLSPRING6_ANSI    0x024c
+#define USB_DEVICE_ID_APPLE_WELLSPRING6_ISO     0x024d
+#define USB_DEVICE_ID_APPLE_WELLSPRING6_JIS     0x024e
+/* Macbook8,2 (unibody) */
+#define USB_DEVICE_ID_APPLE_WELLSPRING5A_ANSI   0x0252
+#define USB_DEVICE_ID_APPLE_WELLSPRING5A_ISO    0x0253
+#define USB_DEVICE_ID_APPLE_WELLSPRING5A_JIS    0x0254
 
 #define BCM5974_DEVICE(prod) {                                  \
         .match_flags = (USB_DEVICE_ID_MATCH_DEVICE |            \
@@ -104,6 +112,14 @@ static const struct usb_device_id bcm5974_table[] = {
         BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING5_ANSI),
         BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING5_ISO),
         BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING5_JIS),
+        /* MacbookAir4,2 */
+        BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING6_ANSI),
+        BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING6_ISO),
+        BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING6_JIS),
+        /* MacbookPro8,2 */
+        BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING5A_ANSI),
+        BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING5A_ISO),
+        BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING5A_JIS),
         /* Terminating entry */
         {}
 };
@@ -294,6 +310,30 @@ static const struct bcm5974_config bcm5974_config_table[] = {
                 { DIM_X, DIM_X / SN_COORD, -4415, 5050 },
                 { DIM_Y, DIM_Y / SN_COORD, -55, 6680 }
         },
+        {
+                USB_DEVICE_ID_APPLE_WELLSPRING6_ANSI,
+                USB_DEVICE_ID_APPLE_WELLSPRING6_ISO,
+                USB_DEVICE_ID_APPLE_WELLSPRING6_JIS,
+                HAS_INTEGRATED_BUTTON,
+                0x84, sizeof(struct bt_data),
+                0x81, TYPE2, FINGER_TYPE2, FINGER_TYPE2 + SIZEOF_ALL_FINGERS,
+                { DIM_PRESSURE, DIM_PRESSURE / SN_PRESSURE, 0, 300 },
+                { DIM_WIDTH, DIM_WIDTH / SN_WIDTH, 0, 2048 },
+                { DIM_X, DIM_X / SN_COORD, -4620, 5140 },
+                { DIM_Y, DIM_Y / SN_COORD, -150, 6600 }
+        },
+        {
+                USB_DEVICE_ID_APPLE_WELLSPRING5A_ANSI,
+                USB_DEVICE_ID_APPLE_WELLSPRING5A_ISO,
+                USB_DEVICE_ID_APPLE_WELLSPRING5A_JIS,
+                HAS_INTEGRATED_BUTTON,
+                0x84, sizeof(struct bt_data),
+                0x81, TYPE2, FINGER_TYPE2, FINGER_TYPE2 + SIZEOF_ALL_FINGERS,
+                { DIM_PRESSURE, DIM_PRESSURE / SN_PRESSURE, 0, 300 },
+                { DIM_WIDTH, DIM_WIDTH / SN_WIDTH, 0, 2048 },
+                { DIM_X, DIM_X / SN_COORD, -4750, 5280 },
+                { DIM_Y, DIM_Y / SN_COORD, -150, 6730 }
+        },
         {}
 };
 
diff --git a/drivers/input/mouse/hgpk.c b/drivers/input/mouse/hgpk.c
index 95577c15ae56..4d17d9f3320b 100644
--- a/drivers/input/mouse/hgpk.c
+++ b/drivers/input/mouse/hgpk.c
@@ -32,6 +32,7 @@
 #define DEBUG
 #include <linux/slab.h>
 #include <linux/input.h>
+#include <linux/module.h>
 #include <linux/serio.h>
 #include <linux/libps2.h>
 #include <linux/delay.h>
diff --git a/drivers/input/serio/xilinx_ps2.c b/drivers/input/serio/xilinx_ps2.c
index 80baa53da5b1..d64c5a43aaad 100644
--- a/drivers/input/serio/xilinx_ps2.c
+++ b/drivers/input/serio/xilinx_ps2.c
@@ -23,7 +23,7 @@
 #include <linux/init.h>
 #include <linux/list.h>
 #include <linux/io.h>
-
+#include <linux/of_address.h>
 #include <linux/of_device.h>
 #include <linux/of_platform.h>
 
diff --git a/drivers/input/tablet/wacom_sys.c b/drivers/input/tablet/wacom_sys.c
index 449c0a46dbac..d27c9d91630b 100644
--- a/drivers/input/tablet/wacom_sys.c
+++ b/drivers/input/tablet/wacom_sys.c
@@ -49,6 +49,7 @@ struct hid_descriptor {
 #define USB_REQ_GET_REPORT      0x01
 #define USB_REQ_SET_REPORT      0x09
 #define WAC_HID_FEATURE_REPORT  0x03
+#define WAC_MSG_RETRIES         5
 
 static int usb_get_report(struct usb_interface *intf, unsigned char type,
                                 unsigned char id, void *buf, int size)
@@ -165,7 +166,7 @@ static int wacom_parse_hid(struct usb_interface *intf, struct hid_descriptor *hi
                         report,
                         hid_desc->wDescriptorLength,
                         5000); /* 5 secs */
-        } while (result < 0 && limit++ < 5);
+        } while (result < 0 && limit++ < WAC_MSG_RETRIES);
 
         /* No need to parse the Descriptor. It isn't an error though */
         if (result < 0)
@@ -319,24 +320,26 @@ static int wacom_query_tablet_data(struct usb_interface *intf, struct wacom_feat
         int limit = 0, report_id = 2;
         int error = -ENOMEM;
 
-        rep_data = kmalloc(2, GFP_KERNEL);
+        rep_data = kmalloc(4, GFP_KERNEL);
         if (!rep_data)
                 return error;
 
-        /* ask to report tablet data if it is 2FGT Tablet PC or
+        /* ask to report tablet data if it is MT Tablet PC or
          * not a Tablet PC */
         if (features->type == TABLETPC2FG) {
                 do {
                         rep_data[0] = 3;
                         rep_data[1] = 4;
+                        rep_data[2] = 0;
+                        rep_data[3] = 0;
                         report_id = 3;
                         error = usb_set_report(intf, WAC_HID_FEATURE_REPORT,
-                                report_id, rep_data, 2);
+                                report_id, rep_data, 4);
                         if (error >= 0)
                                 error = usb_get_report(intf,
                                         WAC_HID_FEATURE_REPORT, report_id,
-                                        rep_data, 3);
-                } while ((error < 0 || rep_data[1] != 4) && limit++ < 5);
+                                        rep_data, 4);
+                } while ((error < 0 || rep_data[1] != 4) && limit++ < WAC_MSG_RETRIES);
         } else if (features->type != TABLETPC) {
                 do {
                         rep_data[0] = 2;
@@ -347,7 +350,7 @@ static int wacom_query_tablet_data(struct usb_interface *intf, struct wacom_feat
                                 error = usb_get_report(intf,
                                         WAC_HID_FEATURE_REPORT, report_id,
                                         rep_data, 2);
-                } while ((error < 0 || rep_data[1] != 2) && limit++ < 5);
+                } while ((error < 0 || rep_data[1] != 2) && limit++ < WAC_MSG_RETRIES);
         }
 
         kfree(rep_data);
diff --git a/drivers/input/tablet/wacom_wac.c b/drivers/input/tablet/wacom_wac.c
index 03ebcc8b24b5..c1c2f7b28d89 100644
--- a/drivers/input/tablet/wacom_wac.c
+++ b/drivers/input/tablet/wacom_wac.c
@@ -1460,6 +1460,9 @@ static const struct wacom_features wacom_features_0xD3 =
 static const struct wacom_features wacom_features_0xD4 =
         { "Wacom Bamboo Pen",     WACOM_PKGLEN_BBFUN,     14720,  9200, 1023,
           63, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
+static const struct wacom_features wacom_features_0xD5 =
+        { "Wacom Bamboo Pen 6x8",     WACOM_PKGLEN_BBFUN, 21648, 13530, 1023,
+          63, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
 static const struct wacom_features wacom_features_0xD6 =
         { "Wacom BambooPT 2FG 4x5", WACOM_PKGLEN_BBFUN,   14720,  9200, 1023,
           63, BAMBOO_PT, WACOM_INTUOS_RES, WACOM_INTUOS_RES };
@@ -1564,6 +1567,7 @@ const struct usb_device_id wacom_ids[] = {
         { USB_DEVICE_WACOM(0xD2) },
         { USB_DEVICE_WACOM(0xD3) },
         { USB_DEVICE_WACOM(0xD4) },
+        { USB_DEVICE_WACOM(0xD5) },
         { USB_DEVICE_WACOM(0xD6) },
         { USB_DEVICE_WACOM(0xD7) },
         { USB_DEVICE_WACOM(0xD8) },
diff --git a/drivers/input/touchscreen/ad7879.c b/drivers/input/touchscreen/ad7879.c
index bc3b5187f3a3..131f9d1c921b 100644
--- a/drivers/input/touchscreen/ad7879.c
+++ b/drivers/input/touchscreen/ad7879.c
@@ -249,12 +249,14 @@ static void __ad7879_enable(struct ad7879 *ts)
 
 static void __ad7879_disable(struct ad7879 *ts)
 {
+        u16 reg = (ts->cmd_crtl2 & ~AD7879_PM(-1)) |
+                AD7879_PM(AD7879_PM_SHUTDOWN);
         disable_irq(ts->irq);
 
         if (del_timer_sync(&ts->timer))
                 ad7879_ts_event_release(ts);
 
-        ad7879_write(ts, AD7879_REG_CTRL2, AD7879_PM(AD7879_PM_SHUTDOWN));
+        ad7879_write(ts, AD7879_REG_CTRL2, reg);
 }
 
 
diff --git a/drivers/input/touchscreen/atmel_mxt_ts.c b/drivers/input/touchscreen/atmel_mxt_ts.c
index ae00604a6a81..f5d66859f232 100644
--- a/drivers/input/touchscreen/atmel_mxt_ts.c
+++ b/drivers/input/touchscreen/atmel_mxt_ts.c
@@ -244,6 +244,7 @@ struct mxt_finger {
         int x;
         int y;
         int area;
+        int pressure;
 };
 
 /* Each client has this additional data */
@@ -536,6 +537,8 @@ static void mxt_input_report(struct mxt_data *data, int single_id)
                                         finger[id].x);
                         input_report_abs(input_dev, ABS_MT_POSITION_Y,
                                         finger[id].y);
+                        input_report_abs(input_dev, ABS_MT_PRESSURE,
+                                        finger[id].pressure);
                 } else {
                         finger[id].status = 0;
                 }
@@ -546,6 +549,8 @@ static void mxt_input_report(struct mxt_data *data, int single_id)
         if (status != MXT_RELEASE) {
                 input_report_abs(input_dev, ABS_X, finger[single_id].x);
                 input_report_abs(input_dev, ABS_Y, finger[single_id].y);
+                input_report_abs(input_dev,
+                                 ABS_PRESSURE, finger[single_id].pressure);
         }
 
         input_sync(input_dev);
@@ -560,6 +565,7 @@ static void mxt_input_touchevent(struct mxt_data *data,
         int x;
         int y;
         int area;
+        int pressure;
 
         /* Check the touch is present on the screen */
         if (!(status & MXT_DETECT)) {
@@ -584,6 +590,7 @@ static void mxt_input_touchevent(struct mxt_data *data,
                 y = y >> 2;
 
         area = message->message[4];
+        pressure = message->message[5];
 
         dev_dbg(dev, "[%d] %s x: %d, y: %d, area: %d\n", id,
                 status & MXT_MOVE ? "moved" : "pressed",
@@ -594,6 +601,7 @@ static void mxt_input_touchevent(struct mxt_data *data,
         finger[id].x = x;
         finger[id].y = y;
         finger[id].area = area;
+        finger[id].pressure = pressure;
 
         mxt_input_report(data, id);
 }
@@ -1116,6 +1124,8 @@ static int __devinit mxt_probe(struct i2c_client *client,
                              0, data->max_x, 0, 0);
         input_set_abs_params(input_dev, ABS_Y,
                              0, data->max_y, 0, 0);
+        input_set_abs_params(input_dev, ABS_PRESSURE,
+                             0, 255, 0, 0);
 
         /* For multi touch */
         input_mt_init_slots(input_dev, MXT_MAX_FINGER);
@@ -1125,6 +1135,8 @@ static int __devinit mxt_probe(struct i2c_client *client,
                              0, data->max_x, 0, 0);
         input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
                              0, data->max_y, 0, 0);
+        input_set_abs_params(input_dev, ABS_MT_PRESSURE,
+                             0, 255, 0, 0);
 
         input_set_drvdata(input_dev, data);
         i2c_set_clientdata(client, data);
diff --git a/drivers/input/touchscreen/max11801_ts.c b/drivers/input/touchscreen/max11801_ts.c
index 4f2713d92791..4627fe55b401 100644
--- a/drivers/input/touchscreen/max11801_ts.c
+++ b/drivers/input/touchscreen/max11801_ts.c
@@ -9,7 +9,8 @@
  *
  * 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.
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
  */
 
 /*
diff --git a/drivers/input/touchscreen/tnetv107x-ts.c b/drivers/input/touchscreen/tnetv107x-ts.c
index 089b0a0f3d8c..0e8f63e5b36f 100644
--- a/drivers/input/touchscreen/tnetv107x-ts.c
+++ b/drivers/input/touchscreen/tnetv107x-ts.c
@@ -13,6 +13,7 @@
  * GNU General Public License for more details.
  */
 
+#include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/err.h>
 #include <linux/errno.h>
diff --git a/drivers/iommu/amd_iommu.c b/drivers/iommu/amd_iommu.c
index a14f8dc23462..0e4227f457af 100644
--- a/drivers/iommu/amd_iommu.c
+++ b/drivers/iommu/amd_iommu.c
@@ -605,7 +605,9 @@ static void build_inv_all(struct iommu_cmd *cmd)
  * Writes the command to the IOMMUs command buffer and informs the
  * hardware about the new command.
  */
-static int iommu_queue_command(struct amd_iommu *iommu, struct iommu_cmd *cmd)
+static int iommu_queue_command_sync(struct amd_iommu *iommu,
+                                    struct iommu_cmd *cmd,
+                                    bool sync)
 {
         u32 left, tail, head, next_tail;
         unsigned long flags;
@@ -639,13 +641,18 @@ again:
         copy_cmd_to_buffer(iommu, cmd, tail);
 
         /* We need to sync now to make sure all commands are processed */
-        iommu->need_sync = true;
+        iommu->need_sync = sync;
 
         spin_unlock_irqrestore(&iommu->lock, flags);
 
         return 0;
 }
 
+static int iommu_queue_command(struct amd_iommu *iommu, struct iommu_cmd *cmd)
+{
+        return iommu_queue_command_sync(iommu, cmd, true);
+}
+
 /*
  * This function queues a completion wait command into the command
  * buffer of an IOMMU
@@ -661,7 +668,7 @@ static int iommu_completion_wait(struct amd_iommu *iommu)
 
         build_completion_wait(&cmd, (u64)&sem);
 
-        ret = iommu_queue_command(iommu, &cmd);
+        ret = iommu_queue_command_sync(iommu, &cmd, false);
         if (ret)
                 return ret;
 
@@ -840,14 +847,9 @@ static void domain_flush_complete(struct protection_domain *domain)
 static void domain_flush_devices(struct protection_domain *domain)
 {
         struct iommu_dev_data *dev_data;
-        unsigned long flags;
-
-        spin_lock_irqsave(&domain->lock, flags);
 
         list_for_each_entry(dev_data, &domain->dev_list, list)
                 device_flush_dte(dev_data);
-
-        spin_unlock_irqrestore(&domain->lock, flags);
 }
 
 /****************************************************************************
diff --git a/drivers/leds/leds-ams-delta.c b/drivers/leds/leds-ams-delta.c
index b9826032450b..8c00937bf7e7 100644
--- a/drivers/leds/leds-ams-delta.c
+++ b/drivers/leds/leds-ams-delta.c
@@ -8,6 +8,7 @@
  * published by the Free Software Foundation.
  */
 
+#include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/platform_device.h>
diff --git a/drivers/leds/leds-bd2802.c b/drivers/leds/leds-bd2802.c
index 3ebe3824662d..ea2185531f82 100644
--- a/drivers/leds/leds-bd2802.c
+++ b/drivers/leds/leds-bd2802.c
@@ -662,6 +662,11 @@ failed_unregister_led1_R:
 static void bd2802_unregister_led_classdev(struct bd2802_led *led)
 {
         cancel_work_sync(&led->work);
+        led_classdev_unregister(&led->cdev_led2b);
+        led_classdev_unregister(&led->cdev_led2g);
+        led_classdev_unregister(&led->cdev_led2r);
+        led_classdev_unregister(&led->cdev_led1b);
+        led_classdev_unregister(&led->cdev_led1g);
         led_classdev_unregister(&led->cdev_led1r);
 }
 
diff --git a/drivers/leds/leds-hp6xx.c b/drivers/leds/leds-hp6xx.c
index e4ce1fd46338..bcfbd3a60eab 100644
--- a/drivers/leds/leds-hp6xx.c
+++ b/drivers/leds/leds-hp6xx.c
@@ -10,6 +10,7 @@
  * published by the Free Software Foundation.
  */
 
+#include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/platform_device.h>
diff --git a/drivers/md/Kconfig b/drivers/md/Kconfig
index 8420129fc5ee..f75a66e7d312 100644
--- a/drivers/md/Kconfig
+++ b/drivers/md/Kconfig
@@ -241,12 +241,13 @@ config DM_MIRROR
          needed for live data migration tools such as 'pvmove'.
 
 config DM_RAID
-       tristate "RAID 4/5/6 target (EXPERIMENTAL)"
+       tristate "RAID 1/4/5/6 target (EXPERIMENTAL)"
        depends on BLK_DEV_DM && EXPERIMENTAL
+       select MD_RAID1
        select MD_RAID456
        select BLK_DEV_MD
        ---help---
-         A dm target that supports RAID4, RAID5 and RAID6 mappings
+         A dm target that supports RAID1, RAID4, RAID5 and RAID6 mappings
 
          A RAID-5 set of N drives with a capacity of C MB per drive provides
          the capacity of C * (N - 1) MB, and protects against a failure
diff --git a/drivers/md/dm-crypt.c b/drivers/md/dm-crypt.c
index bae6c4e23d3f..49da55c1528a 100644
--- a/drivers/md/dm-crypt.c
+++ b/drivers/md/dm-crypt.c
@@ -30,7 +30,6 @@
 #include <linux/device-mapper.h>
 
 #define DM_MSG_PREFIX "crypt"
-#define MESG_STR(x) x, sizeof(x)
 
 /*
  * context holding the current state of a multi-part conversion
@@ -239,7 +238,7 @@ static int crypt_iv_plain_gen(struct crypt_config *cc, u8 *iv,
                               struct dm_crypt_request *dmreq)
 {
         memset(iv, 0, cc->iv_size);
-        *(u32 *)iv = cpu_to_le32(dmreq->iv_sector & 0xffffffff);
+        *(__le32 *)iv = cpu_to_le32(dmreq->iv_sector & 0xffffffff);
 
         return 0;
 }
@@ -248,7 +247,7 @@ static int crypt_iv_plain64_gen(struct crypt_config *cc, u8 *iv,
                                 struct dm_crypt_request *dmreq)
 {
         memset(iv, 0, cc->iv_size);
-        *(u64 *)iv = cpu_to_le64(dmreq->iv_sector);
+        *(__le64 *)iv = cpu_to_le64(dmreq->iv_sector);
 
         return 0;
 }
@@ -415,7 +414,7 @@ static int crypt_iv_essiv_gen(struct crypt_config *cc, u8 *iv,
         struct crypto_cipher *essiv_tfm = this_crypt_config(cc)->iv_private;
 
         memset(iv, 0, cc->iv_size);
-        *(u64 *)iv = cpu_to_le64(dmreq->iv_sector);
+        *(__le64 *)iv = cpu_to_le64(dmreq->iv_sector);
         crypto_cipher_encrypt_one(essiv_tfm, iv, iv);
 
         return 0;
@@ -1575,11 +1574,17 @@ bad_mem:
 static int crypt_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 {
         struct crypt_config *cc;
-        unsigned int key_size;
+        unsigned int key_size, opt_params;
         unsigned long long tmpll;
         int ret;
+        struct dm_arg_set as;
+        const char *opt_string;
+
+        static struct dm_arg _args[] = {
+                {0, 1, "Invalid number of feature args"},
+        };
 
-        if (argc != 5) {
+        if (argc < 5) {
                 ti->error = "Not enough arguments";
                 return -EINVAL;
         }
@@ -1648,6 +1653,30 @@ static int crypt_ctr(struct dm_target *ti, unsigned int argc, char **argv)
         }
         cc->start = tmpll;
 
+        argv += 5;
+        argc -= 5;
+
+        /* Optional parameters */
+        if (argc) {
+                as.argc = argc;
+                as.argv = argv;
+
+                ret = dm_read_arg_group(_args, &as, &opt_params, &ti->error);
+                if (ret)
+                        goto bad;
+
+                opt_string = dm_shift_arg(&as);
+
+                if (opt_params == 1 && opt_string &&
+                    !strcasecmp(opt_string, "allow_discards"))
+                        ti->num_discard_requests = 1;
+                else if (opt_params) {
+                        ret = -EINVAL;
+                        ti->error = "Invalid feature arguments";
+                        goto bad;
+                }
+        }
+
         ret = -ENOMEM;
         cc->io_queue = alloc_workqueue("kcryptd_io",
                                        WQ_NON_REENTRANT|
@@ -1682,9 +1711,16 @@ static int crypt_map(struct dm_target *ti, struct bio *bio,
         struct dm_crypt_io *io;
         struct crypt_config *cc;
 
-        if (bio->bi_rw & REQ_FLUSH) {
+        /*
+         * If bio is REQ_FLUSH or REQ_DISCARD, just bypass crypt queues.
+         * - for REQ_FLUSH device-mapper core ensures that no IO is in-flight
+         * - for REQ_DISCARD caller must use flush if IO ordering matters
+         */
+        if (unlikely(bio->bi_rw & (REQ_FLUSH | REQ_DISCARD))) {
                 cc = ti->private;
                 bio->bi_bdev = cc->dev->bdev;
+                if (bio_sectors(bio))
+                        bio->bi_sector = cc->start + dm_target_offset(ti, bio->bi_sector);
                 return DM_MAPIO_REMAPPED;
         }
 
@@ -1727,6 +1763,10 @@ static int crypt_status(struct dm_target *ti, status_type_t type,
 
                 DMEMIT(" %llu %s %llu", (unsigned long long)cc->iv_offset,
                                 cc->dev->name, (unsigned long long)cc->start);
+
+                if (ti->num_discard_requests)
+                        DMEMIT(" 1 allow_discards");
+
                 break;
         }
         return 0;
@@ -1770,12 +1810,12 @@ static int crypt_message(struct dm_target *ti, unsigned argc, char **argv)
         if (argc < 2)
                 goto error;
 
-        if (!strnicmp(argv[0], MESG_STR("key"))) {
+        if (!strcasecmp(argv[0], "key")) {
                 if (!test_bit(DM_CRYPT_SUSPENDED, &cc->flags)) {
                         DMWARN("not suspended during key manipulation.");
                         return -EINVAL;
                 }
-                if (argc == 3 && !strnicmp(argv[1], MESG_STR("set"))) {
+                if (argc == 3 && !strcasecmp(argv[1], "set")) {
                         ret = crypt_set_key(cc, argv[2]);
                         if (ret)
                                 return ret;
@@ -1783,7 +1823,7 @@ static int crypt_message(struct dm_target *ti, unsigned argc, char **argv)
                                 ret = cc->iv_gen_ops->init(cc);
                         return ret;
                 }
-                if (argc == 2 && !strnicmp(argv[1], MESG_STR("wipe"))) {
+                if (argc == 2 && !strcasecmp(argv[1], "wipe")) {
                         if (cc->iv_gen_ops && cc->iv_gen_ops->wipe) {
                                 ret = cc->iv_gen_ops->wipe(cc);
                                 if (ret)
@@ -1823,7 +1863,7 @@ static int crypt_iterate_devices(struct dm_target *ti,
 
 static struct target_type crypt_target = {
         .name   = "crypt",
-        .version = {1, 10, 0},
+        .version = {1, 11, 0},
         .module = THIS_MODULE,
         .ctr    = crypt_ctr,
         .dtr    = crypt_dtr,
diff --git a/drivers/md/dm-flakey.c b/drivers/md/dm-flakey.c
index ea790623c30b..89f73ca22cfa 100644
--- a/drivers/md/dm-flakey.c
+++ b/drivers/md/dm-flakey.c
@@ -1,6 +1,6 @@
 /*
  * Copyright (C) 2003 Sistina Software (UK) Limited.
- * Copyright (C) 2004, 2010 Red Hat, Inc. All rights reserved.
+ * Copyright (C) 2004, 2010-2011 Red Hat, Inc. All rights reserved.
  *
  * This file is released under the GPL.
  */
@@ -15,6 +15,9 @@
 
 #define DM_MSG_PREFIX "flakey"
 
+#define all_corrupt_bio_flags_match(bio, fc)    \
+        (((bio)->bi_rw & (fc)->corrupt_bio_flags) == (fc)->corrupt_bio_flags)
+
 /*
  * Flakey: Used for testing only, simulates intermittent,
  * catastrophic device failure.
@@ -25,60 +28,189 @@ struct flakey_c {
         sector_t start;
         unsigned up_interval;
         unsigned down_interval;
+        unsigned long flags;
+        unsigned corrupt_bio_byte;
+        unsigned corrupt_bio_rw;
+        unsigned corrupt_bio_value;
+        unsigned corrupt_bio_flags;
+};
+
+enum feature_flag_bits {
+        DROP_WRITES
 };
 
+static int parse_features(struct dm_arg_set *as, struct flakey_c *fc,
+                          struct dm_target *ti)
+{
+        int r;
+        unsigned argc;
+        const char *arg_name;
+
+        static struct dm_arg _args[] = {
+                {0, 6, "Invalid number of feature args"},
+                {1, UINT_MAX, "Invalid corrupt bio byte"},
+                {0, 255, "Invalid corrupt value to write into bio byte (0-255)"},
+                {0, UINT_MAX, "Invalid corrupt bio flags mask"},
+        };
+
+        /* No feature arguments supplied. */
+        if (!as->argc)
+                return 0;
+
+        r = dm_read_arg_group(_args, as, &argc, &ti->error);
+        if (r)
+                return r;
+
+        while (argc) {
+                arg_name = dm_shift_arg(as);
+                argc--;
+
+                /*
+                 * drop_writes
+                 */
+                if (!strcasecmp(arg_name, "drop_writes")) {
+                        if (test_and_set_bit(DROP_WRITES, &fc->flags)) {
+                                ti->error = "Feature drop_writes duplicated";
+                                return -EINVAL;
+                        }
+
+                        continue;
+                }
+
+                /*
+                 * corrupt_bio_byte <Nth_byte> <direction> <value> <bio_flags>
+                 */
+                if (!strcasecmp(arg_name, "corrupt_bio_byte")) {
+                        if (!argc)
+                                ti->error = "Feature corrupt_bio_byte requires parameters";
+
+                        r = dm_read_arg(_args + 1, as, &fc->corrupt_bio_byte, &ti->error);
+                        if (r)
+                                return r;
+                        argc--;
+
+                        /*
+                         * Direction r or w?
+                         */
+                        arg_name = dm_shift_arg(as);
+                        if (!strcasecmp(arg_name, "w"))
+                                fc->corrupt_bio_rw = WRITE;
+                        else if (!strcasecmp(arg_name, "r"))
+                                fc->corrupt_bio_rw = READ;
+                        else {
+                                ti->error = "Invalid corrupt bio direction (r or w)";
+                                return -EINVAL;
+                        }
+                        argc--;
+
+                        /*
+                         * Value of byte (0-255) to write in place of correct one.
+                         */
+                        r = dm_read_arg(_args + 2, as, &fc->corrupt_bio_value, &ti->error);
+                        if (r)
+                                return r;
+                        argc--;
+
+                        /*
+                         * Only corrupt bios with these flags set.
+                         */
+                        r = dm_read_arg(_args + 3, as, &fc->corrupt_bio_flags, &ti->error);
+                        if (r)
+                                return r;
+                        argc--;
+
+                        continue;
+                }
+
+                ti->error = "Unrecognised flakey feature requested";
+                return -EINVAL;
+        }
+
+        if (test_bit(DROP_WRITES, &fc->flags) && (fc->corrupt_bio_rw == WRITE)) {
+                ti->error = "drop_writes is incompatible with corrupt_bio_byte with the WRITE flag set";
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
 /*
- * Construct a flakey mapping: <dev_path> <offset> <up interval> <down interval>
+ * Construct a flakey mapping:
+ * <dev_path> <offset> <up interval> <down interval> [<#feature args> [<arg>]*]
+ *
+ *   Feature args:
+ *     [drop_writes]
+ *     [corrupt_bio_byte <Nth_byte> <direction> <value> <bio_flags>]
+ *
+ *   Nth_byte starts from 1 for the first byte.
+ *   Direction is r for READ or w for WRITE.
+ *   bio_flags is ignored if 0.
  */
 static int flakey_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 {
+        static struct dm_arg _args[] = {
+                {0, UINT_MAX, "Invalid up interval"},
+                {0, UINT_MAX, "Invalid down interval"},
+        };
+
+        int r;
         struct flakey_c *fc;
-        unsigned long long tmp;
+        unsigned long long tmpll;
+        struct dm_arg_set as;
+        const char *devname;
 
-        if (argc != 4) {
-                ti->error = "dm-flakey: Invalid argument count";
+        as.argc = argc;
+        as.argv = argv;
+
+        if (argc < 4) {
+                ti->error = "Invalid argument count";
                 return -EINVAL;
         }
 
-        fc = kmalloc(sizeof(*fc), GFP_KERNEL);
+        fc = kzalloc(sizeof(*fc), GFP_KERNEL);
         if (!fc) {
-                ti->error = "dm-flakey: Cannot allocate linear context";
+                ti->error = "Cannot allocate linear context";
                 return -ENOMEM;
         }
         fc->start_time = jiffies;
 
-        if (sscanf(argv[1], "%llu", &tmp) != 1) {
-                ti->error = "dm-flakey: Invalid device sector";
+        devname = dm_shift_arg(&as);
+
+        if (sscanf(dm_shift_arg(&as), "%llu", &tmpll) != 1) {
+                ti->error = "Invalid device sector";
                 goto bad;
         }
-        fc->start = tmp;
+        fc->start = tmpll;
 
-        if (sscanf(argv[2], "%u", &fc->up_interval) != 1) {
-                ti->error = "dm-flakey: Invalid up interval";
+        r = dm_read_arg(_args, &as, &fc->up_interval, &ti->error);
+        if (r)
                 goto bad;
-        }
 
-        if (sscanf(argv[3], "%u", &fc->down_interval) != 1) {
-                ti->error = "dm-flakey: Invalid down interval";
+        r = dm_read_arg(_args, &as, &fc->down_interval, &ti->error);
+        if (r)
                 goto bad;
-        }
 
         if (!(fc->up_interval + fc->down_interval)) {
-                ti->error = "dm-flakey: Total (up + down) interval is zero";
+                ti->error = "Total (up + down) interval is zero";
                 goto bad;
         }
 
         if (fc->up_interval + fc->down_interval < fc->up_interval) {
-                ti->error = "dm-flakey: Interval overflow";
+                ti->error = "Interval overflow";
                 goto bad;
         }
 
-        if (dm_get_device(ti, argv[0], dm_table_get_mode(ti->table), &fc->dev)) {
-                ti->error = "dm-flakey: Device lookup failed";
+        r = parse_features(&as, fc, ti);
+        if (r)
+                goto bad;
+
+        if (dm_get_device(ti, devname, dm_table_get_mode(ti->table), &fc->dev)) {
+                ti->error = "Device lookup failed";
                 goto bad;
         }
 
         ti->num_flush_requests = 1;
+        ti->num_discard_requests = 1;
         ti->private = fc;
         return 0;
 
@@ -99,7 +231,7 @@ static sector_t flakey_map_sector(struct dm_target *ti, sector_t bi_sector)
 {
         struct flakey_c *fc = ti->private;
 
-        return fc->start + (bi_sector - ti->begin);
+        return fc->start + dm_target_offset(ti, bi_sector);
 }
 
 static void flakey_map_bio(struct dm_target *ti, struct bio *bio)
@@ -111,6 +243,25 @@ static void flakey_map_bio(struct dm_target *ti, struct bio *bio)
                 bio->bi_sector = flakey_map_sector(ti, bio->bi_sector);
 }
 
+static void corrupt_bio_data(struct bio *bio, struct flakey_c *fc)
+{
+        unsigned bio_bytes = bio_cur_bytes(bio);
+        char *data = bio_data(bio);
+
+        /*
+         * Overwrite the Nth byte of the data returned.
+         */
+        if (data && bio_bytes >= fc->corrupt_bio_byte) {
+                data[fc->corrupt_bio_byte - 1] = fc->corrupt_bio_value;
+
+                DMDEBUG("Corrupting data bio=%p by writing %u to byte %u "
+                        "(rw=%c bi_rw=%lu bi_sector=%llu cur_bytes=%u)\n",
+                        bio, fc->corrupt_bio_value, fc->corrupt_bio_byte,
+                        (bio_data_dir(bio) == WRITE) ? 'w' : 'r',
+                        bio->bi_rw, (unsigned long long)bio->bi_sector, bio_bytes);
+        }
+}
+
 static int flakey_map(struct dm_target *ti, struct bio *bio,
                       union map_info *map_context)
 {
@@ -119,18 +270,71 @@ static int flakey_map(struct dm_target *ti, struct bio *bio,
 
         /* Are we alive ? */
         elapsed = (jiffies - fc->start_time) / HZ;
-        if (elapsed % (fc->up_interval + fc->down_interval) >= fc->up_interval)
+        if (elapsed % (fc->up_interval + fc->down_interval) >= fc->up_interval) {
+                /*
+                 * Flag this bio as submitted while down.
+                 */
+                map_context->ll = 1;
+
+                /*
+                 * Map reads as normal.
+                 */
+                if (bio_data_dir(bio) == READ)
+                        goto map_bio;
+
+                /*
+                 * Drop writes?
+                 */
+                if (test_bit(DROP_WRITES, &fc->flags)) {
+                        bio_endio(bio, 0);
+                        return DM_MAPIO_SUBMITTED;
+                }
+
+                /*
+                 * Corrupt matching writes.
+                 */
+                if (fc->corrupt_bio_byte && (fc->corrupt_bio_rw == WRITE)) {
+                        if (all_corrupt_bio_flags_match(bio, fc))
+                                corrupt_bio_data(bio, fc);
+                        goto map_bio;
+                }
+
+                /*
+                 * By default, error all I/O.
+                 */
                 return -EIO;
+        }
 
+map_bio:
         flakey_map_bio(ti, bio);
 
         return DM_MAPIO_REMAPPED;
 }
 
+static int flakey_end_io(struct dm_target *ti, struct bio *bio,
+                         int error, union map_info *map_context)
+{
+        struct flakey_c *fc = ti->private;
+        unsigned bio_submitted_while_down = map_context->ll;
+
+        /*
+         * Corrupt successful READs while in down state.
+         * If flags were specified, only corrupt those that match.
+         */
+        if (!error && bio_submitted_while_down &&
+            (bio_data_dir(bio) == READ) && (fc->corrupt_bio_rw == READ) &&
+            all_corrupt_bio_flags_match(bio, fc))
+                corrupt_bio_data(bio, fc);
+
+        return error;
+}
+
 static int flakey_status(struct dm_target *ti, status_type_t type,
                          char *result, unsigned int maxlen)
 {
+        unsigned sz = 0;
         struct flakey_c *fc = ti->private;
+        unsigned drop_writes;
 
         switch (type) {
         case STATUSTYPE_INFO:
@@ -138,9 +342,22 @@ static int flakey_status(struct dm_target *ti, status_type_t type,
                 break;
 
         case STATUSTYPE_TABLE:
-                snprintf(result, maxlen, "%s %llu %u %u", fc->dev->name,
-                         (unsigned long long)fc->start, fc->up_interval,
-                         fc->down_interval);
+                DMEMIT("%s %llu %u %u ", fc->dev->name,
+                       (unsigned long long)fc->start, fc->up_interval,
+                       fc->down_interval);
+
+                drop_writes = test_bit(DROP_WRITES, &fc->flags);
+                DMEMIT("%u ", drop_writes + (fc->corrupt_bio_byte > 0) * 5);
+
+                if (drop_writes)
+                        DMEMIT("drop_writes ");
+
+                if (fc->corrupt_bio_byte)
+                        DMEMIT("corrupt_bio_byte %u %c %u %u ",
+                               fc->corrupt_bio_byte,
+                               (fc->corrupt_bio_rw == WRITE) ? 'w' : 'r',
+                               fc->corrupt_bio_value, fc->corrupt_bio_flags);
+
                 break;
         }
         return 0;
@@ -177,11 +394,12 @@ static int flakey_iterate_devices(struct dm_target *ti, iterate_devices_callout_
 
 static struct target_type flakey_target = {
         .name   = "flakey",
-        .version = {1, 1, 0},
+        .version = {1, 2, 0},
         .module = THIS_MODULE,
         .ctr    = flakey_ctr,
         .dtr    = flakey_dtr,
         .map    = flakey_map,
+        .end_io = flakey_end_io,
         .status = flakey_status,
         .ioctl  = flakey_ioctl,
         .merge  = flakey_merge,
diff --git a/drivers/md/dm-io.c b/drivers/md/dm-io.c
index 2067288f61f9..ad2eba40e319 100644
--- a/drivers/md/dm-io.c
+++ b/drivers/md/dm-io.c
@@ -38,6 +38,8 @@ struct io {
         struct dm_io_client *client;
         io_notify_fn callback;
         void *context;
+        void *vma_invalidate_address;
+        unsigned long vma_invalidate_size;
 } __attribute__((aligned(DM_IO_MAX_REGIONS)));
 
 static struct kmem_cache *_dm_io_cache;
@@ -116,6 +118,10 @@ static void dec_count(struct io *io, unsigned int region, int error)
                 set_bit(region, &io->error_bits);
 
         if (atomic_dec_and_test(&io->count)) {
+                if (io->vma_invalidate_size)
+                        invalidate_kernel_vmap_range(io->vma_invalidate_address,
+                                                     io->vma_invalidate_size);
+
                 if (io->sleeper)
                         wake_up_process(io->sleeper);
 
@@ -159,6 +165,9 @@ struct dpages {
 
         unsigned context_u;
         void *context_ptr;
+
+        void *vma_invalidate_address;
+        unsigned long vma_invalidate_size;
 };
 
 /*
@@ -377,6 +386,9 @@ static int sync_io(struct dm_io_client *client, unsigned int num_regions,
         io->sleeper = current;
         io->client = client;
 
+        io->vma_invalidate_address = dp->vma_invalidate_address;
+        io->vma_invalidate_size = dp->vma_invalidate_size;
+
         dispatch_io(rw, num_regions, where, dp, io, 1);
 
         while (1) {
@@ -415,13 +427,21 @@ static int async_io(struct dm_io_client *client, unsigned int num_regions,
         io->callback = fn;
         io->context = context;
 
+        io->vma_invalidate_address = dp->vma_invalidate_address;
+        io->vma_invalidate_size = dp->vma_invalidate_size;
+
         dispatch_io(rw, num_regions, where, dp, io, 0);
         return 0;
 }
 
-static int dp_init(struct dm_io_request *io_req, struct dpages *dp)
+static int dp_init(struct dm_io_request *io_req, struct dpages *dp,
+                   unsigned long size)
 {
         /* Set up dpages based on memory type */
+
+        dp->vma_invalidate_address = NULL;
+        dp->vma_invalidate_size = 0;
+
         switch (io_req->mem.type) {
         case DM_IO_PAGE_LIST:
                 list_dp_init(dp, io_req->mem.ptr.pl, io_req->mem.offset);
@@ -432,6 +452,11 @@ static int dp_init(struct dm_io_request *io_req, struct dpages *dp)
                 break;
 
         case DM_IO_VMA:
+                flush_kernel_vmap_range(io_req->mem.ptr.vma, size);
+                if ((io_req->bi_rw & RW_MASK) == READ) {
+                        dp->vma_invalidate_address = io_req->mem.ptr.vma;
+                        dp->vma_invalidate_size = size;
+                }
                 vm_dp_init(dp, io_req->mem.ptr.vma);
                 break;
 
@@ -460,7 +485,7 @@ int dm_io(struct dm_io_request *io_req, unsigned num_regions,
         int r;
         struct dpages dp;
 
-        r = dp_init(io_req, &dp);
+        r = dp_init(io_req, &dp, (unsigned long)where->count << SECTOR_SHIFT);
         if (r)
                 return r;
 
diff --git a/drivers/md/dm-ioctl.c b/drivers/md/dm-ioctl.c
index 4cacdad2270a..2e9a3ca37bdd 100644
--- a/drivers/md/dm-ioctl.c
+++ b/drivers/md/dm-ioctl.c
@@ -128,6 +128,24 @@ static struct hash_cell *__get_uuid_cell(const char *str)
         return NULL;
 }
 
+static struct hash_cell *__get_dev_cell(uint64_t dev)
+{
+        struct mapped_device *md;
+        struct hash_cell *hc;
+
+        md = dm_get_md(huge_decode_dev(dev));
+        if (!md)
+                return NULL;
+
+        hc = dm_get_mdptr(md);
+        if (!hc) {
+                dm_put(md);
+                return NULL;
+        }
+
+        return hc;
+}
+
 /*-----------------------------------------------------------------
  * Inserting, removing and renaming a device.
  *---------------------------------------------------------------*/
@@ -718,25 +736,45 @@ static int dev_create(struct dm_ioctl *param, size_t param_size)
  */
 static struct hash_cell *__find_device_hash_cell(struct dm_ioctl *param)
 {
-        struct mapped_device *md;
-        void *mdptr = NULL;
+        struct hash_cell *hc = NULL;
 
-        if (*param->uuid)
-                return __get_uuid_cell(param->uuid);
+        if (*param->uuid) {
+                if (*param->name || param->dev)
+                        return NULL;
 
-        if (*param->name)
-                return __get_name_cell(param->name);
+                hc = __get_uuid_cell(param->uuid);
+                if (!hc)
+                        return NULL;
+        } else if (*param->name) {
+                if (param->dev)
+                        return NULL;
 
-        md = dm_get_md(huge_decode_dev(param->dev));
-        if (!md)
-                goto out;
+                hc = __get_name_cell(param->name);
+                if (!hc)
+                        return NULL;
+        } else if (param->dev) {
+                hc = __get_dev_cell(param->dev);
+                if (!hc)
+                        return NULL;
+        } else
+                return NULL;
 
-        mdptr = dm_get_mdptr(md);
-        if (!mdptr)
-                dm_put(md);
+        /*
+         * Sneakily write in both the name and the uuid
+         * while we have the cell.
+         */
+        strlcpy(param->name, hc->name, sizeof(param->name));
+        if (hc->uuid)
+                strlcpy(param->uuid, hc->uuid, sizeof(param->uuid));
+        else
+                param->uuid[0] = '\0';
 
-out:
-        return mdptr;
+        if (hc->new_map)
+                param->flags |= DM_INACTIVE_PRESENT_FLAG;
+        else
+                param->flags &= ~DM_INACTIVE_PRESENT_FLAG;
+
+        return hc;
 }
 
 static struct mapped_device *find_device(struct dm_ioctl *param)
@@ -746,24 +784,8 @@ static struct mapped_device *find_device(struct dm_ioctl *param)
 
         down_read(&_hash_lock);
         hc = __find_device_hash_cell(param);
-        if (hc) {
+        if (hc)
                 md = hc->md;
-
-                /*
-                 * Sneakily write in both the name and the uuid
-                 * while we have the cell.
-                 */
-                strlcpy(param->name, hc->name, sizeof(param->name));
-                if (hc->uuid)
-                        strlcpy(param->uuid, hc->uuid, sizeof(param->uuid));
-                else
-                        param->uuid[0] = '\0';
-
-                if (hc->new_map)
-                        param->flags |= DM_INACTIVE_PRESENT_FLAG;
-                else
-                        param->flags &= ~DM_INACTIVE_PRESENT_FLAG;
-        }
         up_read(&_hash_lock);
 
         return md;
@@ -1402,6 +1424,11 @@ static int target_message(struct dm_ioctl *param, size_t param_size)
                 goto out;
         }
 
+        if (!argc) {
+                DMWARN("Empty message received.");
+                goto out;
+        }
+
         table = dm_get_live_table(md);
         if (!table)
                 goto out_argv;
diff --git a/drivers/md/dm-kcopyd.c b/drivers/md/dm-kcopyd.c
index 320401dec104..f82147029636 100644
--- a/drivers/md/dm-kcopyd.c
+++ b/drivers/md/dm-kcopyd.c
@@ -224,8 +224,6 @@ struct kcopyd_job {
         unsigned int num_dests;
         struct dm_io_region dests[DM_KCOPYD_MAX_REGIONS];
 
-        sector_t offset;
-        unsigned int nr_pages;
         struct page_list *pages;
 
         /*
@@ -380,7 +378,7 @@ static int run_io_job(struct kcopyd_job *job)
                 .bi_rw = job->rw,
                 .mem.type = DM_IO_PAGE_LIST,
                 .mem.ptr.pl = job->pages,
-                .mem.offset = job->offset,
+                .mem.offset = 0,
                 .notify.fn = complete_io,
                 .notify.context = job,
                 .client = job->kc->io_client,
@@ -397,10 +395,9 @@ static int run_io_job(struct kcopyd_job *job)
 static int run_pages_job(struct kcopyd_job *job)
 {
         int r;
+        unsigned nr_pages = dm_div_up(job->dests[0].count, PAGE_SIZE >> 9);
 
-        job->nr_pages = dm_div_up(job->dests[0].count + job->offset,
-                                  PAGE_SIZE >> 9);
-        r = kcopyd_get_pages(job->kc, job->nr_pages, &job->pages);
+        r = kcopyd_get_pages(job->kc, nr_pages, &job->pages);
         if (!r) {
                 /* this job is ready for io */
                 push(&job->kc->io_jobs, job);
@@ -602,8 +599,6 @@ int dm_kcopyd_copy(struct dm_kcopyd_client *kc, struct dm_io_region *from,
         job->num_dests = num_dests;
         memcpy(&job->dests, dests, sizeof(*dests) * num_dests);
 
-        job->offset = 0;
-        job->nr_pages = 0;
         job->pages = NULL;
 
         job->fn = fn;
@@ -622,6 +617,37 @@ int dm_kcopyd_copy(struct dm_kcopyd_client *kc, struct dm_io_region *from,
 }
 EXPORT_SYMBOL(dm_kcopyd_copy);
 
+void *dm_kcopyd_prepare_callback(struct dm_kcopyd_client *kc,
+                                 dm_kcopyd_notify_fn fn, void *context)
+{
+        struct kcopyd_job *job;
+
+        job = mempool_alloc(kc->job_pool, GFP_NOIO);
+
+        memset(job, 0, sizeof(struct kcopyd_job));
+        job->kc = kc;
+        job->fn = fn;
+        job->context = context;
+
+        atomic_inc(&kc->nr_jobs);
+
+        return job;
+}
+EXPORT_SYMBOL(dm_kcopyd_prepare_callback);
+
+void dm_kcopyd_do_callback(void *j, int read_err, unsigned long write_err)
+{
+        struct kcopyd_job *job = j;
+        struct dm_kcopyd_client *kc = job->kc;
+
+        job->read_err = read_err;
+        job->write_err = write_err;
+
+        push(&kc->complete_jobs, job);
+        wake(kc);
+}
+EXPORT_SYMBOL(dm_kcopyd_do_callback);
+
 /*
  * Cancels a kcopyd job, eg. someone might be deactivating a
  * mirror.
diff --git a/drivers/md/dm-log-userspace-base.c b/drivers/md/dm-log-userspace-base.c
index aa2e0c374ab3..1021c8986011 100644
--- a/drivers/md/dm-log-userspace-base.c
+++ b/drivers/md/dm-log-userspace-base.c
@@ -394,8 +394,7 @@ static int flush_by_group(struct log_c *lc, struct list_head *flush_list)
                         group[count] = fe->region;
                         count++;
 
-                        list_del(&fe->list);
-                        list_add(&fe->list, &tmp_list);
+                        list_move(&fe->list, &tmp_list);
 
                         type = fe->type;
                         if (count >= MAX_FLUSH_GROUP_COUNT)
diff --git a/drivers/md/dm-log.c b/drivers/md/dm-log.c
index 948e3f4925bf..3b52bb72bd1f 100644
--- a/drivers/md/dm-log.c
+++ b/drivers/md/dm-log.c
@@ -197,15 +197,21 @@ EXPORT_SYMBOL(dm_dirty_log_destroy);
 #define MIRROR_DISK_VERSION 2
 #define LOG_OFFSET 2
 
-struct log_header {
-        uint32_t magic;
+struct log_header_disk {
+        __le32 magic;
 
         /*
          * Simple, incrementing version. no backward
          * compatibility.
          */
+        __le32 version;
+        __le64 nr_regions;
+} __packed;
+
+struct log_header_core {
+        uint32_t magic;
         uint32_t version;
-        sector_t nr_regions;
+        uint64_t nr_regions;
 };
 
 struct log_c {
@@ -239,10 +245,10 @@ struct log_c {
         int log_dev_failed;
         int log_dev_flush_failed;
         struct dm_dev *log_dev;
-        struct log_header header;
+        struct log_header_core header;
 
         struct dm_io_region header_location;
-        struct log_header *disk_header;
+        struct log_header_disk *disk_header;
 };
 
 /*
@@ -251,34 +257,34 @@ struct log_c {
  */
 static inline int log_test_bit(uint32_t *bs, unsigned bit)
 {
-        return test_bit_le(bit, (unsigned long *) bs) ? 1 : 0;
+        return test_bit_le(bit, bs) ? 1 : 0;
 }
 
 static inline void log_set_bit(struct log_c *l,
                                uint32_t *bs, unsigned bit)
 {
-        __test_and_set_bit_le(bit, (unsigned long *) bs);
+        __set_bit_le(bit, bs);
         l->touched_cleaned = 1;
 }
 
 static inline void log_clear_bit(struct log_c *l,
                                  uint32_t *bs, unsigned bit)
 {
-        __test_and_clear_bit_le(bit, (unsigned long *) bs);
+        __clear_bit_le(bit, bs);
         l->touched_dirtied = 1;
 }
 
 /*----------------------------------------------------------------
  * Header IO
  *--------------------------------------------------------------*/
-static void header_to_disk(struct log_header *core, struct log_header *disk)
+static void header_to_disk(struct log_header_core *core, struct log_header_disk *disk)
 {
         disk->magic = cpu_to_le32(core->magic);
         disk->version = cpu_to_le32(core->version);
         disk->nr_regions = cpu_to_le64(core->nr_regions);
 }
 
-static void header_from_disk(struct log_header *core, struct log_header *disk)
+static void header_from_disk(struct log_header_core *core, struct log_header_disk *disk)
 {
         core->magic = le32_to_cpu(disk->magic);
         core->version = le32_to_cpu(disk->version);
@@ -486,7 +492,7 @@ static int create_log_context(struct dm_dirty_log *log, struct dm_target *ti,
         memset(lc->sync_bits, (sync == NOSYNC) ? -1 : 0, bitset_size);
         lc->sync_count = (sync == NOSYNC) ? region_count : 0;
 
-        lc->recovering_bits = vmalloc(bitset_size);
+        lc->recovering_bits = vzalloc(bitset_size);
         if (!lc->recovering_bits) {
                 DMWARN("couldn't allocate sync bitset");
                 vfree(lc->sync_bits);
@@ -498,7 +504,6 @@ static int create_log_context(struct dm_dirty_log *log, struct dm_target *ti,
                 kfree(lc);
                 return -ENOMEM;
         }
-        memset(lc->recovering_bits, 0, bitset_size);
         lc->sync_search = 0;
         log->context = lc;
 
@@ -739,8 +744,7 @@ static int core_get_resync_work(struct dm_dirty_log *log, region_t *region)
                 return 0;
 
         do {
-                *region = find_next_zero_bit_le(
-                                             (unsigned long *) lc->sync_bits,
+                *region = find_next_zero_bit_le(lc->sync_bits,
                                              lc->region_count,
                                              lc->sync_search);
                 lc->sync_search = *region + 1;
diff --git a/drivers/md/dm-mpath.c b/drivers/md/dm-mpath.c
index c3547016f0f1..5e0090ef4182 100644
--- a/drivers/md/dm-mpath.c
+++ b/drivers/md/dm-mpath.c
@@ -22,7 +22,6 @@
 #include <linux/atomic.h>
 
 #define DM_MSG_PREFIX "multipath"
-#define MESG_STR(x) x, sizeof(x)
 #define DM_PG_INIT_DELAY_MSECS 2000
 #define DM_PG_INIT_DELAY_DEFAULT ((unsigned) -1)
 
@@ -505,80 +504,29 @@ static void trigger_event(struct work_struct *work)
  *      <#paths> <#per-path selector args>
  *         [<path> [<arg>]* ]+ ]+
  *---------------------------------------------------------------*/
-struct param {
-        unsigned min;
-        unsigned max;
-        char *error;
-};
-
-static int read_param(struct param *param, char *str, unsigned *v, char **error)
-{
-        if (!str ||
-            (sscanf(str, "%u", v) != 1) ||
-            (*v < param->min) ||
-            (*v > param->max)) {
-                *error = param->error;
-                return -EINVAL;
-        }
-
-        return 0;
-}
-
-struct arg_set {
-        unsigned argc;
-        char **argv;
-};
-
-static char *shift(struct arg_set *as)
-{
-        char *r;
-
-        if (as->argc) {
-                as->argc--;
-                r = *as->argv;
-                as->argv++;
-                return r;
-        }
-
-        return NULL;
-}
-
-static void consume(struct arg_set *as, unsigned n)
-{
-        BUG_ON (as->argc < n);
-        as->argc -= n;
-        as->argv += n;
-}
-
-static int parse_path_selector(struct arg_set *as, struct priority_group *pg,
+static int parse_path_selector(struct dm_arg_set *as, struct priority_group *pg,
                                struct dm_target *ti)
 {
         int r;
         struct path_selector_type *pst;
         unsigned ps_argc;
 
-        static struct param _params[] = {
+        static struct dm_arg _args[] = {
                 {0, 1024, "invalid number of path selector args"},
         };
 
-        pst = dm_get_path_selector(shift(as));
+        pst = dm_get_path_selector(dm_shift_arg(as));
         if (!pst) {
                 ti->error = "unknown path selector type";
                 return -EINVAL;
         }
 
-        r = read_param(_params, shift(as), &ps_argc, &ti->error);
+        r = dm_read_arg_group(_args, as, &ps_argc, &ti->error);
         if (r) {
                 dm_put_path_selector(pst);
                 return -EINVAL;
         }
 
-        if (ps_argc > as->argc) {
-                dm_put_path_selector(pst);
-                ti->error = "not enough arguments for path selector";
-                return -EINVAL;
-        }
-
         r = pst->create(&pg->ps, ps_argc, as->argv);
         if (r) {
                 dm_put_path_selector(pst);
@@ -587,12 +535,12 @@ static int parse_path_selector(struct arg_set *as, struct priority_group *pg,
         }
 
         pg->ps.type = pst;
-        consume(as, ps_argc);
+        dm_consume_args(as, ps_argc);
 
         return 0;
 }
 
-static struct pgpath *parse_path(struct arg_set *as, struct path_selector *ps,
+static struct pgpath *parse_path(struct dm_arg_set *as, struct path_selector *ps,
                                struct dm_target *ti)
 {
         int r;
@@ -609,7 +557,7 @@ static struct pgpath *parse_path(struct arg_set *as, struct path_selector *ps,
         if (!p)
                 return ERR_PTR(-ENOMEM);
 
-        r = dm_get_device(ti, shift(as), dm_table_get_mode(ti->table),
+        r = dm_get_device(ti, dm_shift_arg(as), dm_table_get_mode(ti->table),
                           &p->path.dev);
         if (r) {
                 ti->error = "error getting device";
@@ -660,16 +608,16 @@ static struct pgpath *parse_path(struct arg_set *as, struct path_selector *ps,
         return ERR_PTR(r);
 }
 
-static struct priority_group *parse_priority_group(struct arg_set *as,
+static struct priority_group *parse_priority_group(struct dm_arg_set *as,
                                                    struct multipath *m)
 {
-        static struct param _params[] = {
+        static struct dm_arg _args[] = {
                 {1, 1024, "invalid number of paths"},
                 {0, 1024, "invalid number of selector args"}
         };
 
         int r;
-        unsigned i, nr_selector_args, nr_params;
+        unsigned i, nr_selector_args, nr_args;
         struct priority_group *pg;
         struct dm_target *ti = m->ti;
 
@@ -693,26 +641,26 @@ static struct priority_group *parse_priority_group(struct arg_set *as,
         /*
          * read the paths
          */
-        r = read_param(_params, shift(as), &pg->nr_pgpaths, &ti->error);
+        r = dm_read_arg(_args, as, &pg->nr_pgpaths, &ti->error);
         if (r)
                 goto bad;
 
-        r = read_param(_params + 1, shift(as), &nr_selector_args, &ti->error);
+        r = dm_read_arg(_args + 1, as, &nr_selector_args, &ti->error);
         if (r)
                 goto bad;
 
-        nr_params = 1 + nr_selector_args;
+        nr_args = 1 + nr_selector_args;
         for (i = 0; i < pg->nr_pgpaths; i++) {
                 struct pgpath *pgpath;
-                struct arg_set path_args;
+                struct dm_arg_set path_args;
 
-                if (as->argc < nr_params) {
+                if (as->argc < nr_args) {
                         ti->error = "not enough path parameters";
                         r = -EINVAL;
                         goto bad;
                 }
 
-                path_args.argc = nr_params;
+                path_args.argc = nr_args;
                 path_args.argv = as->argv;
 
                 pgpath = parse_path(&path_args, &pg->ps, ti);
@@ -723,7 +671,7 @@ static struct priority_group *parse_priority_group(struct arg_set *as,
 
                 pgpath->pg = pg;
                 list_add_tail(&pgpath->list, &pg->pgpaths);
-                consume(as, nr_params);
+                dm_consume_args(as, nr_args);
         }
 
         return pg;
@@ -733,28 +681,23 @@ static struct priority_group *parse_priority_group(struct arg_set *as,
         return ERR_PTR(r);
 }
 
-static int parse_hw_handler(struct arg_set *as, struct multipath *m)
+static int parse_hw_handler(struct dm_arg_set *as, struct multipath *m)
 {
         unsigned hw_argc;
         int ret;
         struct dm_target *ti = m->ti;
 
-        static struct param _params[] = {
+        static struct dm_arg _args[] = {
                 {0, 1024, "invalid number of hardware handler args"},
         };
 
-        if (read_param(_params, shift(as), &hw_argc, &ti->error))
+        if (dm_read_arg_group(_args, as, &hw_argc, &ti->error))
                 return -EINVAL;
 
         if (!hw_argc)
                 return 0;
 
-        if (hw_argc > as->argc) {
-                ti->error = "not enough arguments for hardware handler";
-                return -EINVAL;
-        }
-
-        m->hw_handler_name = kstrdup(shift(as), GFP_KERNEL);
+        m->hw_handler_name = kstrdup(dm_shift_arg(as), GFP_KERNEL);
         request_module("scsi_dh_%s", m->hw_handler_name);
         if (scsi_dh_handler_exist(m->hw_handler_name) == 0) {
                 ti->error = "unknown hardware handler type";
@@ -778,7 +721,7 @@ static int parse_hw_handler(struct arg_set *as, struct multipath *m)
                 for (i = 0, p+=j+1; i <= hw_argc - 2; i++, p+=j+1)
                         j = sprintf(p, "%s", as->argv[i]);
         }
-        consume(as, hw_argc - 1);
+        dm_consume_args(as, hw_argc - 1);
 
         return 0;
 fail:
@@ -787,20 +730,20 @@ fail:
         return ret;
 }
 
-static int parse_features(struct arg_set *as, struct multipath *m)
+static int parse_features(struct dm_arg_set *as, struct multipath *m)
 {
         int r;
         unsigned argc;
         struct dm_target *ti = m->ti;
-        const char *param_name;
+        const char *arg_name;
 
-        static struct param _params[] = {
+        static struct dm_arg _args[] = {
                 {0, 5, "invalid number of feature args"},
                 {1, 50, "pg_init_retries must be between 1 and 50"},
                 {0, 60000, "pg_init_delay_msecs must be between 0 and 60000"},
         };
 
-        r = read_param(_params, shift(as), &argc, &ti->error);
+        r = dm_read_arg_group(_args, as, &argc, &ti->error);
         if (r)
                 return -EINVAL;
 
@@ -808,26 +751,24 @@ static int parse_features(struct arg_set *as, struct multipath *m)
                 return 0;
 
         do {
-                param_name = shift(as);
+                arg_name = dm_shift_arg(as);
                 argc--;
 
-                if (!strnicmp(param_name, MESG_STR("queue_if_no_path"))) {
+                if (!strcasecmp(arg_name, "queue_if_no_path")) {
                         r = queue_if_no_path(m, 1, 0);
                         continue;
                 }
 
-                if (!strnicmp(param_name, MESG_STR("pg_init_retries")) &&
+                if (!strcasecmp(arg_name, "pg_init_retries") &&
                     (argc >= 1)) {
-                        r = read_param(_params + 1, shift(as),
-                                       &m->pg_init_retries, &ti->error);
+                        r = dm_read_arg(_args + 1, as, &m->pg_init_retries, &ti->error);
                         argc--;
                         continue;
                 }
 
-                if (!strnicmp(param_name, MESG_STR("pg_init_delay_msecs")) &&
+                if (!strcasecmp(arg_name, "pg_init_delay_msecs") &&
                     (argc >= 1)) {
-                        r = read_param(_params + 2, shift(as),
-                                       &m->pg_init_delay_msecs, &ti->error);
+                        r = dm_read_arg(_args + 2, as, &m->pg_init_delay_msecs, &ti->error);
                         argc--;
                         continue;
                 }
@@ -842,15 +783,15 @@ static int parse_features(struct arg_set *as, struct multipath *m)
 static int multipath_ctr(struct dm_target *ti, unsigned int argc,
                          char **argv)
 {
-        /* target parameters */
-        static struct param _params[] = {
+        /* target arguments */
+        static struct dm_arg _args[] = {
                 {0, 1024, "invalid number of priority groups"},
                 {0, 1024, "invalid initial priority group number"},
         };
 
         int r;
         struct multipath *m;
-        struct arg_set as;
+        struct dm_arg_set as;
         unsigned pg_count = 0;
         unsigned next_pg_num;
 
@@ -871,11 +812,11 @@ static int multipath_ctr(struct dm_target *ti, unsigned int argc,
         if (r)
                 goto bad;
 
-        r = read_param(_params, shift(&as), &m->nr_priority_groups, &ti->error);
+        r = dm_read_arg(_args, &as, &m->nr_priority_groups, &ti->error);
         if (r)
                 goto bad;
 
-        r = read_param(_params + 1, shift(&as), &next_pg_num, &ti->error);
+        r = dm_read_arg(_args + 1, &as, &next_pg_num, &ti->error);
         if (r)
                 goto bad;
 
@@ -1505,10 +1446,10 @@ static int multipath_message(struct dm_target *ti, unsigned argc, char **argv)
         }
 
         if (argc == 1) {
-                if (!strnicmp(argv[0], MESG_STR("queue_if_no_path"))) {
+                if (!strcasecmp(argv[0], "queue_if_no_path")) {
                         r = queue_if_no_path(m, 1, 0);
                         goto out;
-                } else if (!strnicmp(argv[0], MESG_STR("fail_if_no_path"))) {
+                } else if (!strcasecmp(argv[0], "fail_if_no_path")) {
                         r = queue_if_no_path(m, 0, 0);
                         goto out;
                 }
@@ -1519,18 +1460,18 @@ static int multipath_message(struct dm_target *ti, unsigned argc, char **argv)
                 goto out;
         }
 
-        if (!strnicmp(argv[0], MESG_STR("disable_group"))) {
+        if (!strcasecmp(argv[0], "disable_group")) {
                 r = bypass_pg_num(m, argv[1], 1);
                 goto out;
-        } else if (!strnicmp(argv[0], MESG_STR("enable_group"))) {
+        } else if (!strcasecmp(argv[0], "enable_group")) {
                 r = bypass_pg_num(m, argv[1], 0);
                 goto out;
-        } else if (!strnicmp(argv[0], MESG_STR("switch_group"))) {
+        } else if (!strcasecmp(argv[0], "switch_group")) {
                 r = switch_pg_num(m, argv[1]);
                 goto out;
-        } else if (!strnicmp(argv[0], MESG_STR("reinstate_path")))
+        } else if (!strcasecmp(argv[0], "reinstate_path"))
                 action = reinstate_path;
-        else if (!strnicmp(argv[0], MESG_STR("fail_path")))
+        else if (!strcasecmp(argv[0], "fail_path"))
                 action = fail_path;
         else {
                 DMWARN("Unrecognised multipath message received.");
diff --git a/drivers/md/dm-raid.c b/drivers/md/dm-raid.c
index e5d8904fc8f6..a002dd85db1e 100644
--- a/drivers/md/dm-raid.c
+++ b/drivers/md/dm-raid.c
@@ -8,19 +8,19 @@
 #include <linux/slab.h>
 
 #include "md.h"
+#include "raid1.h"
 #include "raid5.h"
-#include "dm.h"
 #include "bitmap.h"
 
+#include <linux/device-mapper.h>
+
 #define DM_MSG_PREFIX "raid"
 
 /*
- * If the MD doesn't support MD_SYNC_STATE_FORCED yet, then
- * make it so the flag doesn't set anything.
+ * The following flags are used by dm-raid.c to set up the array state.
+ * They must be cleared before md_run is called.
  */
-#ifndef MD_SYNC_STATE_FORCED
-#define MD_SYNC_STATE_FORCED 0
-#endif
+#define FirstUse 10             /* rdev flag */
 
 struct raid_dev {
         /*
@@ -43,14 +43,15 @@ struct raid_dev {
 /*
  * Flags for rs->print_flags field.
  */
-#define DMPF_DAEMON_SLEEP      0x1
-#define DMPF_MAX_WRITE_BEHIND  0x2
-#define DMPF_SYNC              0x4
-#define DMPF_NOSYNC            0x8
-#define DMPF_STRIPE_CACHE      0x10
-#define DMPF_MIN_RECOVERY_RATE 0x20
-#define DMPF_MAX_RECOVERY_RATE 0x40
-
+#define DMPF_SYNC              0x1
+#define DMPF_NOSYNC            0x2
+#define DMPF_REBUILD           0x4
+#define DMPF_DAEMON_SLEEP      0x8
+#define DMPF_MIN_RECOVERY_RATE 0x10
+#define DMPF_MAX_RECOVERY_RATE 0x20
+#define DMPF_MAX_WRITE_BEHIND  0x40
+#define DMPF_STRIPE_CACHE      0x80
+#define DMPF_REGION_SIZE       0X100
 struct raid_set {
         struct dm_target *ti;
 
@@ -72,6 +73,7 @@ static struct raid_type {
         const unsigned level;           /* RAID level. */
         const unsigned algorithm;       /* RAID algorithm. */
 } raid_types[] = {
+        {"raid1",    "RAID1 (mirroring)",               0, 2, 1, 0 /* NONE */},
         {"raid4",    "RAID4 (dedicated parity disk)",   1, 2, 5, ALGORITHM_PARITY_0},
         {"raid5_la", "RAID5 (left asymmetric)",         1, 2, 5, ALGORITHM_LEFT_ASYMMETRIC},
         {"raid5_ra", "RAID5 (right asymmetric)",        1, 2, 5, ALGORITHM_RIGHT_ASYMMETRIC},
@@ -105,7 +107,8 @@ static struct raid_set *context_alloc(struct dm_target *ti, struct raid_type *ra
         }
 
         sectors_per_dev = ti->len;
-        if (sector_div(sectors_per_dev, (raid_devs - raid_type->parity_devs))) {
+        if ((raid_type->level > 1) &&
+            sector_div(sectors_per_dev, (raid_devs - raid_type->parity_devs))) {
                 ti->error = "Target length not divisible by number of data devices";
                 return ERR_PTR(-EINVAL);
         }
@@ -147,9 +150,16 @@ static void context_free(struct raid_set *rs)
 {
         int i;
 
-        for (i = 0; i < rs->md.raid_disks; i++)
+        for (i = 0; i < rs->md.raid_disks; i++) {
+                if (rs->dev[i].meta_dev)
+                        dm_put_device(rs->ti, rs->dev[i].meta_dev);
+                if (rs->dev[i].rdev.sb_page)
+                        put_page(rs->dev[i].rdev.sb_page);
+                rs->dev[i].rdev.sb_page = NULL;
+                rs->dev[i].rdev.sb_loaded = 0;
                 if (rs->dev[i].data_dev)
                         dm_put_device(rs->ti, rs->dev[i].data_dev);
+        }
 
         kfree(rs);
 }
@@ -159,7 +169,16 @@ static void context_free(struct raid_set *rs)
  *  <meta_dev>: meta device name or '-' if missing
  *  <data_dev>: data device name or '-' if missing
  *
- * This code parses those words.
+ * The following are permitted:
+ *    - -
+ *    - <data_dev>
+ *    <meta_dev> <data_dev>
+ *
+ * The following is not allowed:
+ *    <meta_dev> -
+ *
+ * This code parses those words.  If there is a failure,
+ * the caller must use context_free to unwind the operations.
  */
 static int dev_parms(struct raid_set *rs, char **argv)
 {
@@ -182,8 +201,16 @@ static int dev_parms(struct raid_set *rs, char **argv)
                 rs->dev[i].rdev.mddev = &rs->md;
 
                 if (strcmp(argv[0], "-")) {
-                        rs->ti->error = "Metadata devices not supported";
-                        return -EINVAL;
+                        ret = dm_get_device(rs->ti, argv[0],
+                                            dm_table_get_mode(rs->ti->table),
+                                            &rs->dev[i].meta_dev);
+                        rs->ti->error = "RAID metadata device lookup failure";
+                        if (ret)
+                                return ret;
+
+                        rs->dev[i].rdev.sb_page = alloc_page(GFP_KERNEL);
+                        if (!rs->dev[i].rdev.sb_page)
+                                return -ENOMEM;
                 }
 
                 if (!strcmp(argv[1], "-")) {
@@ -193,6 +220,10 @@ static int dev_parms(struct raid_set *rs, char **argv)
                                 return -EINVAL;
                         }
 
+                        rs->ti->error = "No data device supplied with metadata device";
+                        if (rs->dev[i].meta_dev)
+                                return -EINVAL;
+
                         continue;
                 }
 
@@ -204,6 +235,10 @@ static int dev_parms(struct raid_set *rs, char **argv)
                         return ret;
                 }
 
+                if (rs->dev[i].meta_dev) {
+                        metadata_available = 1;
+                        rs->dev[i].rdev.meta_bdev = rs->dev[i].meta_dev->bdev;
+                }
                 rs->dev[i].rdev.bdev = rs->dev[i].data_dev->bdev;
                 list_add(&rs->dev[i].rdev.same_set, &rs->md.disks);
                 if (!test_bit(In_sync, &rs->dev[i].rdev.flags))
@@ -235,33 +270,109 @@ static int dev_parms(struct raid_set *rs, char **argv)
 }
 
 /*
+ * validate_region_size
+ * @rs
+ * @region_size:  region size in sectors.  If 0, pick a size (4MiB default).
+ *
+ * Set rs->md.bitmap_info.chunksize (which really refers to 'region size').
+ * Ensure that (ti->len/region_size < 2^21) - required by MD bitmap.
+ *
+ * Returns: 0 on success, -EINVAL on failure.
+ */
+static int validate_region_size(struct raid_set *rs, unsigned long region_size)
+{
+        unsigned long min_region_size = rs->ti->len / (1 << 21);
+
+        if (!region_size) {
+                /*
+                 * Choose a reasonable default.  All figures in sectors.
+                 */
+                if (min_region_size > (1 << 13)) {
+                        DMINFO("Choosing default region size of %lu sectors",
+                               region_size);
+                        region_size = min_region_size;
+                } else {
+                        DMINFO("Choosing default region size of 4MiB");
+                        region_size = 1 << 13; /* sectors */
+                }
+        } else {
+                /*
+                 * Validate user-supplied value.
+                 */
+                if (region_size > rs->ti->len) {
+                        rs->ti->error = "Supplied region size is too large";
+                        return -EINVAL;
+                }
+
+                if (region_size < min_region_size) {
+                        DMERR("Supplied region_size (%lu sectors) below minimum (%lu)",
+                              region_size, min_region_size);
+                        rs->ti->error = "Supplied region size is too small";
+                        return -EINVAL;
+                }
+
+                if (!is_power_of_2(region_size)) {
+                        rs->ti->error = "Region size is not a power of 2";
+                        return -EINVAL;
+                }
+
+                if (region_size < rs->md.chunk_sectors) {
+                        rs->ti->error = "Region size is smaller than the chunk size";
+                        return -EINVAL;
+                }
+        }
+
+        /*
+         * Convert sectors to bytes.
+         */
+        rs->md.bitmap_info.chunksize = (region_size << 9);
+
+        return 0;
+}
+
+/*
  * Possible arguments are...
- * RAID456:
  *      <chunk_size> [optional_args]
  *
- * Optional args:
- *    [[no]sync]                        Force or prevent recovery of the entire array
+ * Argument definitions
+ *    <chunk_size>                      The number of sectors per disk that
+ *                                      will form the "stripe"
+ *    [[no]sync]                        Force or prevent recovery of the
+ *                                      entire array
  *    [rebuild <idx>]                   Rebuild the drive indicated by the index
- *    [daemon_sleep <ms>]               Time between bitmap daemon work to clear bits
+ *    [daemon_sleep <ms>]               Time between bitmap daemon work to
+ *                                      clear bits
  *    [min_recovery_rate <kB/sec/disk>] Throttle RAID initialization
  *    [max_recovery_rate <kB/sec/disk>] Throttle RAID initialization
+ *    [write_mostly <idx>]              Indicate a write mostly drive via index
  *    [max_write_behind <sectors>]      See '-write-behind=' (man mdadm)
  *    [stripe_cache <sectors>]          Stripe cache size for higher RAIDs
+ *    [region_size <sectors>]           Defines granularity of bitmap
  */
 static int parse_raid_params(struct raid_set *rs, char **argv,
                              unsigned num_raid_params)
 {
         unsigned i, rebuild_cnt = 0;
-        unsigned long value;
+        unsigned long value, region_size = 0;
         char *key;
 
         /*
          * First, parse the in-order required arguments
+         * "chunk_size" is the only argument of this type.
          */
-        if ((strict_strtoul(argv[0], 10, &value) < 0) ||
-            !is_power_of_2(value) || (value < 8)) {
+        if ((strict_strtoul(argv[0], 10, &value) < 0)) {
                 rs->ti->error = "Bad chunk size";
                 return -EINVAL;
+        } else if (rs->raid_type->level == 1) {
+                if (value)
+                        DMERR("Ignoring chunk size parameter for RAID 1");
+                value = 0;
+        } else if (!is_power_of_2(value)) {
+                rs->ti->error = "Chunk size must be a power of 2";
+                return -EINVAL;
+        } else if (value < 8) {
+                rs->ti->error = "Chunk size value is too small";
+                return -EINVAL;
         }
 
         rs->md.new_chunk_sectors = rs->md.chunk_sectors = value;
@@ -269,22 +380,39 @@ static int parse_raid_params(struct raid_set *rs, char **argv,
         num_raid_params--;
 
         /*
-         * Second, parse the unordered optional arguments
+         * We set each individual device as In_sync with a completed
+         * 'recovery_offset'.  If there has been a device failure or
+         * replacement then one of the following cases applies:
+         *
+         *   1) User specifies 'rebuild'.
+         *      - Device is reset when param is read.
+         *   2) A new device is supplied.
+         *      - No matching superblock found, resets device.
+         *   3) Device failure was transient and returns on reload.
+         *      - Failure noticed, resets device for bitmap replay.
+         *   4) Device hadn't completed recovery after previous failure.
+         *      - Superblock is read and overrides recovery_offset.
+         *
+         * What is found in the superblocks of the devices is always
+         * authoritative, unless 'rebuild' or '[no]sync' was specified.
          */
-        for (i = 0; i < rs->md.raid_disks; i++)
+        for (i = 0; i < rs->md.raid_disks; i++) {
                 set_bit(In_sync, &rs->dev[i].rdev.flags);
+                rs->dev[i].rdev.recovery_offset = MaxSector;
+        }
 
+        /*
+         * Second, parse the unordered optional arguments
+         */
         for (i = 0; i < num_raid_params; i++) {
-                if (!strcmp(argv[i], "nosync")) {
+                if (!strcasecmp(argv[i], "nosync")) {
                         rs->md.recovery_cp = MaxSector;
                         rs->print_flags |= DMPF_NOSYNC;
-                        rs->md.flags |= MD_SYNC_STATE_FORCED;
                         continue;
                 }
-                if (!strcmp(argv[i], "sync")) {
+                if (!strcasecmp(argv[i], "sync")) {
                         rs->md.recovery_cp = 0;
                         rs->print_flags |= DMPF_SYNC;
-                        rs->md.flags |= MD_SYNC_STATE_FORCED;
                         continue;
                 }
 
@@ -300,9 +428,13 @@ static int parse_raid_params(struct raid_set *rs, char **argv,
                         return -EINVAL;
                 }
 
-                if (!strcmp(key, "rebuild")) {
-                        if (++rebuild_cnt > rs->raid_type->parity_devs) {
-                                rs->ti->error = "Too many rebuild drives given";
+                if (!strcasecmp(key, "rebuild")) {
+                        rebuild_cnt++;
+                        if (((rs->raid_type->level != 1) &&
+                             (rebuild_cnt > rs->raid_type->parity_devs)) ||
+                            ((rs->raid_type->level == 1) &&
+                             (rebuild_cnt > (rs->md.raid_disks - 1)))) {
+                                rs->ti->error = "Too many rebuild devices specified for given RAID type";
                                 return -EINVAL;
                         }
                         if (value > rs->md.raid_disks) {
@@ -311,7 +443,22 @@ static int parse_raid_params(struct raid_set *rs, char **argv,
                         }
                         clear_bit(In_sync, &rs->dev[value].rdev.flags);
                         rs->dev[value].rdev.recovery_offset = 0;
-                } else if (!strcmp(key, "max_write_behind")) {
+                        rs->print_flags |= DMPF_REBUILD;
+                } else if (!strcasecmp(key, "write_mostly")) {
+                        if (rs->raid_type->level != 1) {
+                                rs->ti->error = "write_mostly option is only valid for RAID1";
+                                return -EINVAL;
+                        }
+                        if (value > rs->md.raid_disks) {
+                                rs->ti->error = "Invalid write_mostly drive index given";
+                                return -EINVAL;
+                        }
+                        set_bit(WriteMostly, &rs->dev[value].rdev.flags);
+                } else if (!strcasecmp(key, "max_write_behind")) {
+                        if (rs->raid_type->level != 1) {
+                                rs->ti->error = "max_write_behind option is only valid for RAID1";
+                                return -EINVAL;
+                        }
                         rs->print_flags |= DMPF_MAX_WRITE_BEHIND;
 
                         /*
@@ -324,14 +471,14 @@ static int parse_raid_params(struct raid_set *rs, char **argv,
                                 return -EINVAL;
                         }
                         rs->md.bitmap_info.max_write_behind = value;
-                } else if (!strcmp(key, "daemon_sleep")) {
+                } else if (!strcasecmp(key, "daemon_sleep")) {
                         rs->print_flags |= DMPF_DAEMON_SLEEP;
                         if (!value || (value > MAX_SCHEDULE_TIMEOUT)) {
                                 rs->ti->error = "daemon sleep period out of range";
                                 return -EINVAL;
                         }
                         rs->md.bitmap_info.daemon_sleep = value;
-                } else if (!strcmp(key, "stripe_cache")) {
+                } else if (!strcasecmp(key, "stripe_cache")) {
                         rs->print_flags |= DMPF_STRIPE_CACHE;
 
                         /*
@@ -348,20 +495,23 @@ static int parse_raid_params(struct raid_set *rs, char **argv,
                                 rs->ti->error = "Bad stripe_cache size";
                                 return -EINVAL;
                         }
-                } else if (!strcmp(key, "min_recovery_rate")) {
+                } else if (!strcasecmp(key, "min_recovery_rate")) {
                         rs->print_flags |= DMPF_MIN_RECOVERY_RATE;
                         if (value > INT_MAX) {
                                 rs->ti->error = "min_recovery_rate out of range";
                                 return -EINVAL;
                         }
                         rs->md.sync_speed_min = (int)value;
-                } else if (!strcmp(key, "max_recovery_rate")) {
+                } else if (!strcasecmp(key, "max_recovery_rate")) {
                         rs->print_flags |= DMPF_MAX_RECOVERY_RATE;
                         if (value > INT_MAX) {
                                 rs->ti->error = "max_recovery_rate out of range";
                                 return -EINVAL;
                         }
                         rs->md.sync_speed_max = (int)value;
+                } else if (!strcasecmp(key, "region_size")) {
+                        rs->print_flags |= DMPF_REGION_SIZE;
+                        region_size = value;
                 } else {
                         DMERR("Unable to parse RAID parameter: %s", key);
                         rs->ti->error = "Unable to parse RAID parameters";
@@ -369,6 +519,19 @@ static int parse_raid_params(struct raid_set *rs, char **argv,
                 }
         }
 
+        if (validate_region_size(rs, region_size))
+                return -EINVAL;
+
+        if (rs->md.chunk_sectors)
+                rs->ti->split_io = rs->md.chunk_sectors;
+        else
+                rs->ti->split_io = region_size;
+
+        if (rs->md.chunk_sectors)
+                rs->ti->split_io = rs->md.chunk_sectors;
+        else
+                rs->ti->split_io = region_size;
+
         /* Assume there are no metadata devices until the drives are parsed */
         rs->md.persistent = 0;
         rs->md.external = 1;
@@ -387,17 +550,351 @@ static int raid_is_congested(struct dm_target_callbacks *cb, int bits)
 {
         struct raid_set *rs = container_of(cb, struct raid_set, callbacks);
 
+        if (rs->raid_type->level == 1)
+                return md_raid1_congested(&rs->md, bits);
+
         return md_raid5_congested(&rs->md, bits);
 }
 
 /*
+ * This structure is never routinely used by userspace, unlike md superblocks.
+ * Devices with this superblock should only ever be accessed via device-mapper.
+ */
+#define DM_RAID_MAGIC 0x64526D44
+struct dm_raid_superblock {
+        __le32 magic;           /* "DmRd" */
+        __le32 features;        /* Used to indicate possible future changes */
+
+        __le32 num_devices;     /* Number of devices in this array. (Max 64) */
+        __le32 array_position;  /* The position of this drive in the array */
+
+        __le64 events;          /* Incremented by md when superblock updated */
+        __le64 failed_devices;  /* Bit field of devices to indicate failures */
+
+        /*
+         * This offset tracks the progress of the repair or replacement of
+         * an individual drive.
+         */
+        __le64 disk_recovery_offset;
+
+        /*
+         * This offset tracks the progress of the initial array
+         * synchronisation/parity calculation.
+         */
+        __le64 array_resync_offset;
+
+        /*
+         * RAID characteristics
+         */
+        __le32 level;
+        __le32 layout;
+        __le32 stripe_sectors;
+
+        __u8 pad[452];          /* Round struct to 512 bytes. */
+                                /* Always set to 0 when writing. */
+} __packed;
+
+static int read_disk_sb(mdk_rdev_t *rdev, int size)
+{
+        BUG_ON(!rdev->sb_page);
+
+        if (rdev->sb_loaded)
+                return 0;
+
+        if (!sync_page_io(rdev, 0, size, rdev->sb_page, READ, 1)) {
+                DMERR("Failed to read device superblock");
+                return -EINVAL;
+        }
+
+        rdev->sb_loaded = 1;
+
+        return 0;
+}
+
+static void super_sync(mddev_t *mddev, mdk_rdev_t *rdev)
+{
+        mdk_rdev_t *r, *t;
+        uint64_t failed_devices;
+        struct dm_raid_superblock *sb;
+
+        sb = page_address(rdev->sb_page);
+        failed_devices = le64_to_cpu(sb->failed_devices);
+
+        rdev_for_each(r, t, mddev)
+                if ((r->raid_disk >= 0) && test_bit(Faulty, &r->flags))
+                        failed_devices |= (1ULL << r->raid_disk);
+
+        memset(sb, 0, sizeof(*sb));
+
+        sb->magic = cpu_to_le32(DM_RAID_MAGIC);
+        sb->features = cpu_to_le32(0);  /* No features yet */
+
+        sb->num_devices = cpu_to_le32(mddev->raid_disks);
+        sb->array_position = cpu_to_le32(rdev->raid_disk);
+
+        sb->events = cpu_to_le64(mddev->events);
+        sb->failed_devices = cpu_to_le64(failed_devices);
+
+        sb->disk_recovery_offset = cpu_to_le64(rdev->recovery_offset);
+        sb->array_resync_offset = cpu_to_le64(mddev->recovery_cp);
+
+        sb->level = cpu_to_le32(mddev->level);
+        sb->layout = cpu_to_le32(mddev->layout);
+        sb->stripe_sectors = cpu_to_le32(mddev->chunk_sectors);
+}
+
+/*
+ * super_load
+ *
+ * This function creates a superblock if one is not found on the device
+ * and will decide which superblock to use if there's a choice.
+ *
+ * Return: 1 if use rdev, 0 if use refdev, -Exxx otherwise
+ */
+static int super_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev)
+{
+        int ret;
+        struct dm_raid_superblock *sb;
+        struct dm_raid_superblock *refsb;
+        uint64_t events_sb, events_refsb;
+
+        rdev->sb_start = 0;
+        rdev->sb_size = sizeof(*sb);
+
+        ret = read_disk_sb(rdev, rdev->sb_size);
+        if (ret)
+                return ret;
+
+        sb = page_address(rdev->sb_page);
+        if (sb->magic != cpu_to_le32(DM_RAID_MAGIC)) {
+                super_sync(rdev->mddev, rdev);
+
+                set_bit(FirstUse, &rdev->flags);
+
+                /* Force writing of superblocks to disk */
+                set_bit(MD_CHANGE_DEVS, &rdev->mddev->flags);
+
+                /* Any superblock is better than none, choose that if given */
+                return refdev ? 0 : 1;
+        }
+
+        if (!refdev)
+                return 1;
+
+        events_sb = le64_to_cpu(sb->events);
+
+        refsb = page_address(refdev->sb_page);
+        events_refsb = le64_to_cpu(refsb->events);
+
+        return (events_sb > events_refsb) ? 1 : 0;
+}
+
+static int super_init_validation(mddev_t *mddev, mdk_rdev_t *rdev)
+{
+        int role;
+        struct raid_set *rs = container_of(mddev, struct raid_set, md);
+        uint64_t events_sb;
+        uint64_t failed_devices;
+        struct dm_raid_superblock *sb;
+        uint32_t new_devs = 0;
+        uint32_t rebuilds = 0;
+        mdk_rdev_t *r, *t;
+        struct dm_raid_superblock *sb2;
+
+        sb = page_address(rdev->sb_page);
+        events_sb = le64_to_cpu(sb->events);
+        failed_devices = le64_to_cpu(sb->failed_devices);
+
+        /*
+         * Initialise to 1 if this is a new superblock.
+         */
+        mddev->events = events_sb ? : 1;
+
+        /*
+         * Reshaping is not currently allowed
+         */
+        if ((le32_to_cpu(sb->level) != mddev->level) ||
+            (le32_to_cpu(sb->layout) != mddev->layout) ||
+            (le32_to_cpu(sb->stripe_sectors) != mddev->chunk_sectors)) {
+                DMERR("Reshaping arrays not yet supported.");
+                return -EINVAL;
+        }
+
+        /* We can only change the number of devices in RAID1 right now */
+        if ((rs->raid_type->level != 1) &&
+            (le32_to_cpu(sb->num_devices) != mddev->raid_disks)) {
+                DMERR("Reshaping arrays not yet supported.");
+                return -EINVAL;
+        }
+
+        if (!(rs->print_flags & (DMPF_SYNC | DMPF_NOSYNC)))
+                mddev->recovery_cp = le64_to_cpu(sb->array_resync_offset);
+
+        /*
+         * During load, we set FirstUse if a new superblock was written.
+         * There are two reasons we might not have a superblock:
+         * 1) The array is brand new - in which case, all of the
+         *    devices must have their In_sync bit set.  Also,
+         *    recovery_cp must be 0, unless forced.
+         * 2) This is a new device being added to an old array
+         *    and the new device needs to be rebuilt - in which
+         *    case the In_sync bit will /not/ be set and
+         *    recovery_cp must be MaxSector.
+         */
+        rdev_for_each(r, t, mddev) {
+                if (!test_bit(In_sync, &r->flags)) {
+                        if (!test_bit(FirstUse, &r->flags))
+                                DMERR("Superblock area of "
+                                      "rebuild device %d should have been "
+                                      "cleared.", r->raid_disk);
+                        set_bit(FirstUse, &r->flags);
+                        rebuilds++;
+                } else if (test_bit(FirstUse, &r->flags))
+                        new_devs++;
+        }
+
+        if (!rebuilds) {
+                if (new_devs == mddev->raid_disks) {
+                        DMINFO("Superblocks created for new array");
+                        set_bit(MD_ARRAY_FIRST_USE, &mddev->flags);
+                } else if (new_devs) {
+                        DMERR("New device injected "
+                              "into existing array without 'rebuild' "
+                              "parameter specified");
+                        return -EINVAL;
+                }
+        } else if (new_devs) {
+                DMERR("'rebuild' devices cannot be "
+                      "injected into an array with other first-time devices");
+                return -EINVAL;
+        } else if (mddev->recovery_cp != MaxSector) {
+                DMERR("'rebuild' specified while array is not in-sync");
+                return -EINVAL;
+        }
+
+        /*
+         * Now we set the Faulty bit for those devices that are
+         * recorded in the superblock as failed.
+         */
+        rdev_for_each(r, t, mddev) {
+                if (!r->sb_page)
+                        continue;
+                sb2 = page_address(r->sb_page);
+                sb2->failed_devices = 0;
+
+                /*
+                 * Check for any device re-ordering.
+                 */
+                if (!test_bit(FirstUse, &r->flags) && (r->raid_disk >= 0)) {
+                        role = le32_to_cpu(sb2->array_position);
+                        if (role != r->raid_disk) {
+                                if (rs->raid_type->level != 1) {
+                                        rs->ti->error = "Cannot change device "
+                                                "positions in RAID array";
+                                        return -EINVAL;
+                                }
+                                DMINFO("RAID1 device #%d now at position #%d",
+                                       role, r->raid_disk);
+                        }
+
+                        /*
+                         * Partial recovery is performed on
+                         * returning failed devices.
+                         */
+                        if (failed_devices & (1 << role))
+                                set_bit(Faulty, &r->flags);
+                }
+        }
+
+        return 0;
+}
+
+static int super_validate(mddev_t *mddev, mdk_rdev_t *rdev)
+{
+        struct dm_raid_superblock *sb = page_address(rdev->sb_page);
+
+        /*
+         * If mddev->events is not set, we know we have not yet initialized
+         * the array.
+         */
+        if (!mddev->events && super_init_validation(mddev, rdev))
+                return -EINVAL;
+
+        mddev->bitmap_info.offset = 4096 >> 9; /* Enable bitmap creation */
+        rdev->mddev->bitmap_info.default_offset = 4096 >> 9;
+        if (!test_bit(FirstUse, &rdev->flags)) {
+                rdev->recovery_offset = le64_to_cpu(sb->disk_recovery_offset);
+                if (rdev->recovery_offset != MaxSector)
+                        clear_bit(In_sync, &rdev->flags);
+        }
+
+        /*
+         * If a device comes back, set it as not In_sync and no longer faulty.
+         */
+        if (test_bit(Faulty, &rdev->flags)) {
+                clear_bit(Faulty, &rdev->flags);
+                clear_bit(In_sync, &rdev->flags);
+                rdev->saved_raid_disk = rdev->raid_disk;
+                rdev->recovery_offset = 0;
+        }
+
+        clear_bit(FirstUse, &rdev->flags);
+
+        return 0;
+}
+
+/*
+ * Analyse superblocks and select the freshest.
+ */
+static int analyse_superblocks(struct dm_target *ti, struct raid_set *rs)
+{
+        int ret;
+        mdk_rdev_t *rdev, *freshest, *tmp;
+        mddev_t *mddev = &rs->md;
+
+        freshest = NULL;
+        rdev_for_each(rdev, tmp, mddev) {
+                if (!rdev->meta_bdev)
+                        continue;
+
+                ret = super_load(rdev, freshest);
+
+                switch (ret) {
+                case 1:
+                        freshest = rdev;
+                        break;
+                case 0:
+                        break;
+                default:
+                        ti->error = "Failed to load superblock";
+                        return ret;
+                }
+        }
+
+        if (!freshest)
+                return 0;
+
+        /*
+         * Validation of the freshest device provides the source of
+         * validation for the remaining devices.
+         */
+        ti->error = "Unable to assemble array: Invalid superblocks";
+        if (super_validate(mddev, freshest))
+                return -EINVAL;
+
+        rdev_for_each(rdev, tmp, mddev)
+                if ((rdev != freshest) && super_validate(mddev, rdev))
+                        return -EINVAL;
+
+        return 0;
+}
+
+/*
  * Construct a RAID4/5/6 mapping:
  * Args:
  *      <raid_type> <#raid_params> <raid_params>                \
  *      <#raid_devs> { <meta_dev1> <dev1> .. <meta_devN> <devN> }
  *
- * ** metadata devices are not supported yet, use '-' instead **
- *
  * <raid_params> varies by <raid_type>.  See 'parse_raid_params' for
  * details on possible <raid_params>.
  */
@@ -465,8 +962,12 @@ static int raid_ctr(struct dm_target *ti, unsigned argc, char **argv)
         if (ret)
                 goto bad;
 
+        rs->md.sync_super = super_sync;
+        ret = analyse_superblocks(ti, rs);
+        if (ret)
+                goto bad;
+
         INIT_WORK(&rs->md.event_work, do_table_event);
-        ti->split_io = rs->md.chunk_sectors;
         ti->private = rs;
 
         mutex_lock(&rs->md.reconfig_mutex);
@@ -482,6 +983,7 @@ static int raid_ctr(struct dm_target *ti, unsigned argc, char **argv)
         rs->callbacks.congested_fn = raid_is_congested;
         dm_table_add_target_callbacks(ti->table, &rs->callbacks);
 
+        mddev_suspend(&rs->md);
         return 0;
 
 bad:
@@ -546,12 +1048,17 @@ static int raid_status(struct dm_target *ti, status_type_t type,
                 break;
         case STATUSTYPE_TABLE:
                 /* The string you would use to construct this array */
-                for (i = 0; i < rs->md.raid_disks; i++)
-                        if (rs->dev[i].data_dev &&
+                for (i = 0; i < rs->md.raid_disks; i++) {
+                        if ((rs->print_flags & DMPF_REBUILD) &&
+                            rs->dev[i].data_dev &&
                             !test_bit(In_sync, &rs->dev[i].rdev.flags))
-                                raid_param_cnt++; /* for rebuilds */
+                                raid_param_cnt += 2; /* for rebuilds */
+                        if (rs->dev[i].data_dev &&
+                            test_bit(WriteMostly, &rs->dev[i].rdev.flags))
+                                raid_param_cnt += 2;
+                }
 
-                raid_param_cnt += (hweight64(rs->print_flags) * 2);
+                raid_param_cnt += (hweight64(rs->print_flags & ~DMPF_REBUILD) * 2);
                 if (rs->print_flags & (DMPF_SYNC | DMPF_NOSYNC))
                         raid_param_cnt--;
 
@@ -565,7 +1072,8 @@ static int raid_status(struct dm_target *ti, status_type_t type,
                         DMEMIT(" nosync");
 
                 for (i = 0; i < rs->md.raid_disks; i++)
-                        if (rs->dev[i].data_dev &&
+                        if ((rs->print_flags & DMPF_REBUILD) &&
+                            rs->dev[i].data_dev &&
                             !test_bit(In_sync, &rs->dev[i].rdev.flags))
                                 DMEMIT(" rebuild %u", i);
 
@@ -579,6 +1087,11 @@ static int raid_status(struct dm_target *ti, status_type_t type,
                 if (rs->print_flags & DMPF_MAX_RECOVERY_RATE)
                         DMEMIT(" max_recovery_rate %d", rs->md.sync_speed_max);
 
+                for (i = 0; i < rs->md.raid_disks; i++)
+                        if (rs->dev[i].data_dev &&
+                            test_bit(WriteMostly, &rs->dev[i].rdev.flags))
+                                DMEMIT(" write_mostly %u", i);
+
                 if (rs->print_flags & DMPF_MAX_WRITE_BEHIND)
                         DMEMIT(" max_write_behind %lu",
                                rs->md.bitmap_info.max_write_behind);
@@ -591,9 +1104,16 @@ static int raid_status(struct dm_target *ti, status_type_t type,
                                conf ? conf->max_nr_stripes * 2 : 0);
                 }
 
+                if (rs->print_flags & DMPF_REGION_SIZE)
+                        DMEMIT(" region_size %lu",
+                               rs->md.bitmap_info.chunksize >> 9);
+
                 DMEMIT(" %d", rs->md.raid_disks);
                 for (i = 0; i < rs->md.raid_disks; i++) {
-                        DMEMIT(" -"); /* metadata device */
+                        if (rs->dev[i].meta_dev)
+                                DMEMIT(" %s", rs->dev[i].meta_dev->name);
+                        else
+                                DMEMIT(" -");
 
                         if (rs->dev[i].data_dev)
                                 DMEMIT(" %s", rs->dev[i].data_dev->name);
@@ -650,12 +1170,13 @@ static void raid_resume(struct dm_target *ti)
 {
         struct raid_set *rs = ti->private;
 
+        bitmap_load(&rs->md);
         mddev_resume(&rs->md);
 }
 
 static struct target_type raid_target = {
         .name = "raid",
-        .version = {1, 0, 0},
+        .version = {1, 1, 0},
         .module = THIS_MODULE,
         .ctr = raid_ctr,
         .dtr = raid_dtr,
diff --git a/drivers/md/dm-snap-persistent.c b/drivers/md/dm-snap-persistent.c
index 135c2f1fdbfc..d1f1d7017103 100644
--- a/drivers/md/dm-snap-persistent.c
+++ b/drivers/md/dm-snap-persistent.c
@@ -58,25 +58,30 @@
 #define NUM_SNAPSHOT_HDR_CHUNKS 1
 
 struct disk_header {
-        uint32_t magic;
+        __le32 magic;
 
         /*
          * Is this snapshot valid.  There is no way of recovering
          * an invalid snapshot.
          */
-        uint32_t valid;
+        __le32 valid;
 
         /*
          * Simple, incrementing version. no backward
          * compatibility.
          */
-        uint32_t version;
+        __le32 version;
 
         /* In sectors */
-        uint32_t chunk_size;
-};
+        __le32 chunk_size;
+} __packed;
 
 struct disk_exception {
+        __le64 old_chunk;
+        __le64 new_chunk;
+} __packed;
+
+struct core_exception {
         uint64_t old_chunk;
         uint64_t new_chunk;
 };
@@ -169,10 +174,9 @@ static int alloc_area(struct pstore *ps)
         if (!ps->area)
                 goto err_area;
 
-        ps->zero_area = vmalloc(len);
+        ps->zero_area = vzalloc(len);
         if (!ps->zero_area)
                 goto err_zero_area;
-        memset(ps->zero_area, 0, len);
 
         ps->header_area = vmalloc(len);
         if (!ps->header_area)
@@ -396,32 +400,32 @@ static struct disk_exception *get_exception(struct pstore *ps, uint32_t index)
 }
 
 static void read_exception(struct pstore *ps,
-                           uint32_t index, struct disk_exception *result)
+                           uint32_t index, struct core_exception *result)
 {
-        struct disk_exception *e = get_exception(ps, index);
+        struct disk_exception *de = get_exception(ps, index);
 
         /* copy it */
-        result->old_chunk = le64_to_cpu(e->old_chunk);
-        result->new_chunk = le64_to_cpu(e->new_chunk);
+        result->old_chunk = le64_to_cpu(de->old_chunk);
+        result->new_chunk = le64_to_cpu(de->new_chunk);
 }
 
 static void write_exception(struct pstore *ps,
-                            uint32_t index, struct disk_exception *de)
+                            uint32_t index, struct core_exception *e)
 {
-        struct disk_exception *e = get_exception(ps, index);
+        struct disk_exception *de = get_exception(ps, index);
 
         /* copy it */
-        e->old_chunk = cpu_to_le64(de->old_chunk);
-        e->new_chunk = cpu_to_le64(de->new_chunk);
+        de->old_chunk = cpu_to_le64(e->old_chunk);
+        de->new_chunk = cpu_to_le64(e->new_chunk);
 }
 
 static void clear_exception(struct pstore *ps, uint32_t index)
 {
-        struct disk_exception *e = get_exception(ps, index);
+        struct disk_exception *de = get_exception(ps, index);
 
         /* clear it */
-        e->old_chunk = 0;
-        e->new_chunk = 0;
+        de->old_chunk = 0;
+        de->new_chunk = 0;
 }
 
 /*
@@ -437,13 +441,13 @@ static int insert_exceptions(struct pstore *ps,
 {
         int r;
         unsigned int i;
-        struct disk_exception de;
+        struct core_exception e;
 
         /* presume the area is full */
         *full = 1;
 
         for (i = 0; i < ps->exceptions_per_area; i++) {
-                read_exception(ps, i, &de);
+                read_exception(ps, i, &e);
 
                 /*
                  * If the new_chunk is pointing at the start of
@@ -451,7 +455,7 @@ static int insert_exceptions(struct pstore *ps,
                  * is we know that we've hit the end of the
                  * exceptions.  Therefore the area is not full.
                  */
-                if (de.new_chunk == 0LL) {
+                if (e.new_chunk == 0LL) {
                         ps->current_committed = i;
                         *full = 0;
                         break;
@@ -460,13 +464,13 @@ static int insert_exceptions(struct pstore *ps,
                 /*
                  * Keep track of the start of the free chunks.
                  */
-                if (ps->next_free <= de.new_chunk)
-                        ps->next_free = de.new_chunk + 1;
+                if (ps->next_free <= e.new_chunk)
+                        ps->next_free = e.new_chunk + 1;
 
                 /*
                  * Otherwise we add the exception to the snapshot.
                  */
-                r = callback(callback_context, de.old_chunk, de.new_chunk);
+                r = callback(callback_context, e.old_chunk, e.new_chunk);
                 if (r)
                         return r;
         }
@@ -563,7 +567,7 @@ static int persistent_read_metadata(struct dm_exception_store *store,
         ps->exceptions_per_area = (ps->store->chunk_size << SECTOR_SHIFT) /
                                   sizeof(struct disk_exception);
         ps->callbacks = dm_vcalloc(ps->exceptions_per_area,
-                        sizeof(*ps->callbacks));
+                                   sizeof(*ps->callbacks));
         if (!ps->callbacks)
                 return -ENOMEM;
 
@@ -641,12 +645,12 @@ static void persistent_commit_exception(struct dm_exception_store *store,
 {
         unsigned int i;
         struct pstore *ps = get_info(store);
-        struct disk_exception de;
+        struct core_exception ce;
         struct commit_callback *cb;
 
-        de.old_chunk = e->old_chunk;
-        de.new_chunk = e->new_chunk;
-        write_exception(ps, ps->current_committed++, &de);
+        ce.old_chunk = e->old_chunk;
+        ce.new_chunk = e->new_chunk;
+        write_exception(ps, ps->current_committed++, &ce);
 
         /*
          * Add the callback to the back of the array.  This code
@@ -670,7 +674,7 @@ static void persistent_commit_exception(struct dm_exception_store *store,
          * If we completely filled the current area, then wipe the next one.
          */
         if ((ps->current_committed == ps->exceptions_per_area) &&
-             zero_disk_area(ps, ps->current_area + 1))
+            zero_disk_area(ps, ps->current_area + 1))
                 ps->valid = 0;
 
         /*
@@ -701,7 +705,7 @@ static int persistent_prepare_merge(struct dm_exception_store *store,
                                     chunk_t *last_new_chunk)
 {
         struct pstore *ps = get_info(store);
-        struct disk_exception de;
+        struct core_exception ce;
         int nr_consecutive;
         int r;
 
@@ -722,9 +726,9 @@ static int persistent_prepare_merge(struct dm_exception_store *store,
                 ps->current_committed = ps->exceptions_per_area;
         }
 
-        read_exception(ps, ps->current_committed - 1, &de);
-        *last_old_chunk = de.old_chunk;
-        *last_new_chunk = de.new_chunk;
+        read_exception(ps, ps->current_committed - 1, &ce);
+        *last_old_chunk = ce.old_chunk;
+        *last_new_chunk = ce.new_chunk;
 
         /*
          * Find number of consecutive chunks within the current area,
@@ -733,9 +737,9 @@ static int persistent_prepare_merge(struct dm_exception_store *store,
         for (nr_consecutive = 1; nr_consecutive < ps->current_committed;
              nr_consecutive++) {
                 read_exception(ps, ps->current_committed - 1 - nr_consecutive,
-                               &de);
-                if (de.old_chunk != *last_old_chunk - nr_consecutive ||
-                    de.new_chunk != *last_new_chunk - nr_consecutive)
+                               &ce);
+                if (ce.old_chunk != *last_old_chunk - nr_consecutive ||
+                    ce.new_chunk != *last_new_chunk - nr_consecutive)
                         break;
         }
 
@@ -753,7 +757,7 @@ static int persistent_commit_merge(struct dm_exception_store *store,
         for (i = 0; i < nr_merged; i++)
                 clear_exception(ps, ps->current_committed - 1 - i);
 
-        r = area_io(ps, WRITE);
+        r = area_io(ps, WRITE_FLUSH_FUA);
         if (r < 0)
                 return r;
 
diff --git a/drivers/md/dm-snap.c b/drivers/md/dm-snap.c
index 9ecff5f3023a..6f758870fc19 100644
--- a/drivers/md/dm-snap.c
+++ b/drivers/md/dm-snap.c
@@ -30,16 +30,6 @@ static const char dm_snapshot_merge_target_name[] = "snapshot-merge";
         ((ti)->type->name == dm_snapshot_merge_target_name)
 
 /*
- * The percentage increment we will wake up users at
- */
-#define WAKE_UP_PERCENT 5
-
-/*
- * kcopyd priority of snapshot operations
- */
-#define SNAPSHOT_COPY_PRIORITY 2
-
-/*
  * The size of the mempool used to track chunks in use.
  */
 #define MIN_IOS 256
@@ -180,6 +170,13 @@ struct dm_snap_pending_exception {
          * kcopyd.
          */
         int started;
+
+        /*
+         * For writing a complete chunk, bypassing the copy.
+         */
+        struct bio *full_bio;
+        bio_end_io_t *full_bio_end_io;
+        void *full_bio_private;
 };
 
 /*
@@ -1055,8 +1052,7 @@ static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 
         s = kmalloc(sizeof(*s), GFP_KERNEL);
         if (!s) {
-                ti->error = "Cannot allocate snapshot context private "
-                    "structure";
+                ti->error = "Cannot allocate private snapshot structure";
                 r = -ENOMEM;
                 goto bad;
         }
@@ -1380,6 +1376,7 @@ static void pending_complete(struct dm_snap_pending_exception *pe, int success)
         struct dm_snapshot *s = pe->snap;
         struct bio *origin_bios = NULL;
         struct bio *snapshot_bios = NULL;
+        struct bio *full_bio = NULL;
         int error = 0;
 
         if (!success) {
@@ -1415,10 +1412,15 @@ static void pending_complete(struct dm_snap_pending_exception *pe, int success)
          */
         dm_insert_exception(&s->complete, e);
 
- out:
+out:
         dm_remove_exception(&pe->e);
         snapshot_bios = bio_list_get(&pe->snapshot_bios);
         origin_bios = bio_list_get(&pe->origin_bios);
+        full_bio = pe->full_bio;
+        if (full_bio) {
+                full_bio->bi_end_io = pe->full_bio_end_io;
+                full_bio->bi_private = pe->full_bio_private;
+        }
         free_pending_exception(pe);
 
         increment_pending_exceptions_done_count();
@@ -1426,10 +1428,15 @@ static void pending_complete(struct dm_snap_pending_exception *pe, int success)
         up_write(&s->lock);
 
         /* Submit any pending write bios */
-        if (error)
+        if (error) {
+                if (full_bio)
+                        bio_io_error(full_bio);
                 error_bios(snapshot_bios);
-        else
+        } else {
+                if (full_bio)
+                        bio_endio(full_bio, 0);
                 flush_bios(snapshot_bios);
+        }
 
         retry_origin_bios(s, origin_bios);
 }
@@ -1480,8 +1487,33 @@ static void start_copy(struct dm_snap_pending_exception *pe)
         dest.count = src.count;
 
         /* Hand over to kcopyd */
-        dm_kcopyd_copy(s->kcopyd_client,
-                    &src, 1, &dest, 0, copy_callback, pe);
+        dm_kcopyd_copy(s->kcopyd_client, &src, 1, &dest, 0, copy_callback, pe);
+}
+
+static void full_bio_end_io(struct bio *bio, int error)
+{
+        void *callback_data = bio->bi_private;
+
+        dm_kcopyd_do_callback(callback_data, 0, error ? 1 : 0);
+}
+
+static void start_full_bio(struct dm_snap_pending_exception *pe,
+                           struct bio *bio)
+{
+        struct dm_snapshot *s = pe->snap;
+        void *callback_data;
+
+        pe->full_bio = bio;
+        pe->full_bio_end_io = bio->bi_end_io;
+        pe->full_bio_private = bio->bi_private;
+
+        callback_data = dm_kcopyd_prepare_callback(s->kcopyd_client,
+                                                   copy_callback, pe);
+
+        bio->bi_end_io = full_bio_end_io;
+        bio->bi_private = callback_data;
+
+        generic_make_request(bio);
 }
 
 static struct dm_snap_pending_exception *
@@ -1519,6 +1551,7 @@ __find_pending_exception(struct dm_snapshot *s,
         bio_list_init(&pe->origin_bios);
         bio_list_init(&pe->snapshot_bios);
         pe->started = 0;
+        pe->full_bio = NULL;
 
         if (s->store->type->prepare_exception(s->store, &pe->e)) {
                 free_pending_exception(pe);
@@ -1612,10 +1645,19 @@ static int snapshot_map(struct dm_target *ti, struct bio *bio,
                 }
 
                 remap_exception(s, &pe->e, bio, chunk);
-                bio_list_add(&pe->snapshot_bios, bio);
 
                 r = DM_MAPIO_SUBMITTED;
 
+                if (!pe->started &&
+                    bio->bi_size == (s->store->chunk_size << SECTOR_SHIFT)) {
+                        pe->started = 1;
+                        up_write(&s->lock);
+                        start_full_bio(pe, bio);
+                        goto out;
+                }
+
+                bio_list_add(&pe->snapshot_bios, bio);
+
                 if (!pe->started) {
                         /* this is protected by snap->lock */
                         pe->started = 1;
@@ -1628,9 +1670,9 @@ static int snapshot_map(struct dm_target *ti, struct bio *bio,
                 map_context->ptr = track_chunk(s, chunk);
         }
 
- out_unlock:
+out_unlock:
         up_write(&s->lock);
- out:
+out:
         return r;
 }
 
@@ -1974,7 +2016,7 @@ static int __origin_write(struct list_head *snapshots, sector_t sector,
                         pe_to_start_now = pe;
                 }
 
- next_snapshot:
+next_snapshot:
                 up_write(&snap->lock);
 
                 if (pe_to_start_now) {
diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
index bfe9c2333cea..986b8754bb08 100644
--- a/drivers/md/dm-table.c
+++ b/drivers/md/dm-table.c
@@ -54,7 +54,6 @@ struct dm_table {
         sector_t *highs;
         struct dm_target *targets;
 
-        unsigned discards_supported:1;
         unsigned integrity_supported:1;
 
         /*
@@ -154,12 +153,11 @@ void *dm_vcalloc(unsigned long nmemb, unsigned long elem_size)
                 return NULL;
 
         size = nmemb * elem_size;
-        addr = vmalloc(size);
-        if (addr)
-                memset(addr, 0, size);
+        addr = vzalloc(size);
 
         return addr;
 }
+EXPORT_SYMBOL(dm_vcalloc);
 
 /*
  * highs, and targets are managed as dynamic arrays during a
@@ -209,7 +207,6 @@ int dm_table_create(struct dm_table **result, fmode_t mode,
         INIT_LIST_HEAD(&t->devices);
         INIT_LIST_HEAD(&t->target_callbacks);
         atomic_set(&t->holders, 0);
-        t->discards_supported = 1;
 
         if (!num_targets)
                 num_targets = KEYS_PER_NODE;
@@ -281,6 +278,7 @@ void dm_table_get(struct dm_table *t)
 {
         atomic_inc(&t->holders);
 }
+EXPORT_SYMBOL(dm_table_get);
 
 void dm_table_put(struct dm_table *t)
 {
@@ -290,6 +288,7 @@ void dm_table_put(struct dm_table *t)
         smp_mb__before_atomic_dec();
         atomic_dec(&t->holders);
 }
+EXPORT_SYMBOL(dm_table_put);
 
 /*
  * Checks to see if we need to extend highs or targets.
@@ -455,13 +454,14 @@ static int upgrade_mode(struct dm_dev_internal *dd, fmode_t new_mode,
  * Add a device to the list, or just increment the usage count if
  * it's already present.
  */
-static int __table_get_device(struct dm_table *t, struct dm_target *ti,
-                      const char *path, fmode_t mode, struct dm_dev **result)
+int dm_get_device(struct dm_target *ti, const char *path, fmode_t mode,
+                  struct dm_dev **result)
 {
         int r;
         dev_t uninitialized_var(dev);
         struct dm_dev_internal *dd;
         unsigned int major, minor;
+        struct dm_table *t = ti->table;
 
         BUG_ON(!t);
 
@@ -509,6 +509,7 @@ static int __table_get_device(struct dm_table *t, struct dm_target *ti,
         *result = &dd->dm_dev;
         return 0;
 }
+EXPORT_SYMBOL(dm_get_device);
 
 int dm_set_device_limits(struct dm_target *ti, struct dm_dev *dev,
                          sector_t start, sector_t len, void *data)
@@ -539,23 +540,15 @@ int dm_set_device_limits(struct dm_target *ti, struct dm_dev *dev,
          * If not we'll force DM to use PAGE_SIZE or
          * smaller I/O, just to be safe.
          */
-
-        if (q->merge_bvec_fn && !ti->type->merge)
+        if (dm_queue_merge_is_compulsory(q) && !ti->type->merge)
                 blk_limits_max_hw_sectors(limits,
                                           (unsigned int) (PAGE_SIZE >> 9));
         return 0;
 }
 EXPORT_SYMBOL_GPL(dm_set_device_limits);
 
-int dm_get_device(struct dm_target *ti, const char *path, fmode_t mode,
-                  struct dm_dev **result)
-{
-        return __table_get_device(ti->table, ti, path, mode, result);
-}
-
-
 /*
- * Decrement a devices use count and remove it if necessary.
+ * Decrement a device's use count and remove it if necessary.
  */
 void dm_put_device(struct dm_target *ti, struct dm_dev *d)
 {
@@ -568,6 +561,7 @@ void dm_put_device(struct dm_target *ti, struct dm_dev *d)
                 kfree(dd);
         }
 }
+EXPORT_SYMBOL(dm_put_device);
 
 /*
  * Checks to see if the target joins onto the end of the table.
@@ -791,8 +785,9 @@ int dm_table_add_target(struct dm_table *t, const char *type,
 
         t->highs[t->num_targets++] = tgt->begin + tgt->len - 1;
 
-        if (!tgt->num_discard_requests)
-                t->discards_supported = 0;
+        if (!tgt->num_discard_requests && tgt->discards_supported)
+                DMWARN("%s: %s: ignoring discards_supported because num_discard_requests is zero.",
+                       dm_device_name(t->md), type);
 
         return 0;
 
@@ -802,6 +797,63 @@ int dm_table_add_target(struct dm_table *t, const char *type,
         return r;
 }
 
+/*
+ * Target argument parsing helpers.
+ */
+static int validate_next_arg(struct dm_arg *arg, struct dm_arg_set *arg_set,
+                             unsigned *value, char **error, unsigned grouped)
+{
+        const char *arg_str = dm_shift_arg(arg_set);
+
+        if (!arg_str ||
+            (sscanf(arg_str, "%u", value) != 1) ||
+            (*value < arg->min) ||
+            (*value > arg->max) ||
+            (grouped && arg_set->argc < *value)) {
+                *error = arg->error;
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+int dm_read_arg(struct dm_arg *arg, struct dm_arg_set *arg_set,
+                unsigned *value, char **error)
+{
+        return validate_next_arg(arg, arg_set, value, error, 0);
+}
+EXPORT_SYMBOL(dm_read_arg);
+
+int dm_read_arg_group(struct dm_arg *arg, struct dm_arg_set *arg_set,
+                      unsigned *value, char **error)
+{
+        return validate_next_arg(arg, arg_set, value, error, 1);
+}
+EXPORT_SYMBOL(dm_read_arg_group);
+
+const char *dm_shift_arg(struct dm_arg_set *as)
+{
+        char *r;
+
+        if (as->argc) {
+                as->argc--;
+                r = *as->argv;
+                as->argv++;
+                return r;
+        }
+
+        return NULL;
+}
+EXPORT_SYMBOL(dm_shift_arg);
+
+void dm_consume_args(struct dm_arg_set *as, unsigned num_args)
+{
+        BUG_ON(as->argc < num_args);
+        as->argc -= num_args;
+        as->argv += num_args;
+}
+EXPORT_SYMBOL(dm_consume_args);
+
 static int dm_table_set_type(struct dm_table *t)
 {
         unsigned i;
@@ -1077,11 +1129,13 @@ void dm_table_event(struct dm_table *t)
                 t->event_fn(t->event_context);
         mutex_unlock(&_event_lock);
 }
+EXPORT_SYMBOL(dm_table_event);
 
 sector_t dm_table_get_size(struct dm_table *t)
 {
         return t->num_targets ? (t->highs[t->num_targets - 1] + 1) : 0;
 }
+EXPORT_SYMBOL(dm_table_get_size);
 
 struct dm_target *dm_table_get_target(struct dm_table *t, unsigned int index)
 {
@@ -1194,9 +1248,45 @@ static void dm_table_set_integrity(struct dm_table *t)
                                blk_get_integrity(template_disk));
 }
 
+static int device_flush_capable(struct dm_target *ti, struct dm_dev *dev,
+                                sector_t start, sector_t len, void *data)
+{
+        unsigned flush = (*(unsigned *)data);
+        struct request_queue *q = bdev_get_queue(dev->bdev);
+
+        return q && (q->flush_flags & flush);
+}
+
+static bool dm_table_supports_flush(struct dm_table *t, unsigned flush)
+{
+        struct dm_target *ti;
+        unsigned i = 0;
+
+        /*
+         * Require at least one underlying device to support flushes.
+         * t->devices includes internal dm devices such as mirror logs
+         * so we need to use iterate_devices here, which targets
+         * supporting flushes must provide.
+         */
+        while (i < dm_table_get_num_targets(t)) {
+                ti = dm_table_get_target(t, i++);
+
+                if (!ti->num_flush_requests)
+                        continue;
+
+                if (ti->type->iterate_devices &&
+                    ti->type->iterate_devices(ti, device_flush_capable, &flush))
+                        return 1;
+        }
+
+        return 0;
+}
+
 void dm_table_set_restrictions(struct dm_table *t, struct request_queue *q,
                                struct queue_limits *limits)
 {
+        unsigned flush = 0;
+
         /*
          * Copy table's limits to the DM device's request_queue
          */
@@ -1207,6 +1297,13 @@ void dm_table_set_restrictions(struct dm_table *t, struct request_queue *q,
         else
                 queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, q);
 
+        if (dm_table_supports_flush(t, REQ_FLUSH)) {
+                flush |= REQ_FLUSH;
+                if (dm_table_supports_flush(t, REQ_FUA))
+                        flush |= REQ_FUA;
+        }
+        blk_queue_flush(q, flush);
+
         dm_table_set_integrity(t);
 
         /*
@@ -1237,6 +1334,7 @@ fmode_t dm_table_get_mode(struct dm_table *t)
 {
         return t->mode;
 }
+EXPORT_SYMBOL(dm_table_get_mode);
 
 static void suspend_targets(struct dm_table *t, unsigned postsuspend)
 {
@@ -1345,6 +1443,7 @@ struct mapped_device *dm_table_get_md(struct dm_table *t)
 {
         return t->md;
 }
+EXPORT_SYMBOL(dm_table_get_md);
 
 static int device_discard_capable(struct dm_target *ti, struct dm_dev *dev,
                                   sector_t start, sector_t len, void *data)
@@ -1359,19 +1458,19 @@ bool dm_table_supports_discards(struct dm_table *t)
         struct dm_target *ti;
         unsigned i = 0;
 
-        if (!t->discards_supported)
-                return 0;
-
         /*
          * Unless any target used by the table set discards_supported,
          * require at least one underlying device to support discards.
          * t->devices includes internal dm devices such as mirror logs
          * so we need to use iterate_devices here, which targets
-         * supporting discard must provide.
+         * supporting discard selectively must provide.
          */
         while (i < dm_table_get_num_targets(t)) {
                 ti = dm_table_get_target(t, i++);
 
+                if (!ti->num_discard_requests)
+                        continue;
+
                 if (ti->discards_supported)
                         return 1;
 
@@ -1382,13 +1481,3 @@ bool dm_table_supports_discards(struct dm_table *t)
 
         return 0;
 }
-
-EXPORT_SYMBOL(dm_vcalloc);
-EXPORT_SYMBOL(dm_get_device);
-EXPORT_SYMBOL(dm_put_device);
-EXPORT_SYMBOL(dm_table_event);
-EXPORT_SYMBOL(dm_table_get_size);
-EXPORT_SYMBOL(dm_table_get_mode);
-EXPORT_SYMBOL(dm_table_get_md);
-EXPORT_SYMBOL(dm_table_put);
-EXPORT_SYMBOL(dm_table_get);
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index 0cf68b478878..52b39f335bb3 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -37,6 +37,8 @@ static const char *_name = DM_NAME;
 static unsigned int major = 0;
 static unsigned int _major = 0;
 
+static DEFINE_IDR(_minor_idr);
+
 static DEFINE_SPINLOCK(_minor_lock);
 /*
  * For bio-based dm.
@@ -109,6 +111,7 @@ EXPORT_SYMBOL_GPL(dm_get_rq_mapinfo);
 #define DMF_FREEING 3
 #define DMF_DELETING 4
 #define DMF_NOFLUSH_SUSPENDING 5
+#define DMF_MERGE_IS_OPTIONAL 6
 
 /*
  * Work processed by per-device workqueue.
@@ -313,6 +316,12 @@ static void __exit dm_exit(void)
 
         while (i--)
                 _exits[i]();
+
+        /*
+         * Should be empty by this point.
+         */
+        idr_remove_all(&_minor_idr);
+        idr_destroy(&_minor_idr);
 }
 
 /*
@@ -1171,7 +1180,8 @@ static int __clone_and_map_discard(struct clone_info *ci)
 
                 /*
                  * Even though the device advertised discard support,
-                 * reconfiguration might have changed that since the
+                 * that does not mean every target supports it, and
+                 * reconfiguration might also have changed that since the
                  * check was performed.
                  */
                 if (!ti->num_discard_requests)
@@ -1705,8 +1715,6 @@ static int dm_any_congested(void *congested_data, int bdi_bits)
 /*-----------------------------------------------------------------
  * An IDR is used to keep track of allocated minor numbers.
  *---------------------------------------------------------------*/
-static DEFINE_IDR(_minor_idr);
-
 static void free_minor(int minor)
 {
         spin_lock(&_minor_lock);
@@ -1800,7 +1808,6 @@ static void dm_init_md_queue(struct mapped_device *md)
         blk_queue_make_request(md->queue, dm_request);
         blk_queue_bounce_limit(md->queue, BLK_BOUNCE_ANY);
         blk_queue_merge_bvec(md->queue, dm_merge_bvec);
-        blk_queue_flush(md->queue, REQ_FLUSH | REQ_FUA);
 }
 
 /*
@@ -1986,6 +1993,59 @@ static void __set_size(struct mapped_device *md, sector_t size)
 }
 
 /*
+ * Return 1 if the queue has a compulsory merge_bvec_fn function.
+ *
+ * If this function returns 0, then the device is either a non-dm
+ * device without a merge_bvec_fn, or it is a dm device that is
+ * able to split any bios it receives that are too big.
+ */
+int dm_queue_merge_is_compulsory(struct request_queue *q)
+{
+        struct mapped_device *dev_md;
+
+        if (!q->merge_bvec_fn)
+                return 0;
+
+        if (q->make_request_fn == dm_request) {
+                dev_md = q->queuedata;
+                if (test_bit(DMF_MERGE_IS_OPTIONAL, &dev_md->flags))
+                        return 0;
+        }
+
+        return 1;
+}
+
+static int dm_device_merge_is_compulsory(struct dm_target *ti,
+                                         struct dm_dev *dev, sector_t start,
+                                         sector_t len, void *data)
+{
+        struct block_device *bdev = dev->bdev;
+        struct request_queue *q = bdev_get_queue(bdev);
+
+        return dm_queue_merge_is_compulsory(q);
+}
+
+/*
+ * Return 1 if it is acceptable to ignore merge_bvec_fn based
+ * on the properties of the underlying devices.
+ */
+static int dm_table_merge_is_optional(struct dm_table *table)
+{
+        unsigned i = 0;
+        struct dm_target *ti;
+
+        while (i < dm_table_get_num_targets(table)) {
+                ti = dm_table_get_target(table, i++);
+
+                if (ti->type->iterate_devices &&
+                    ti->type->iterate_devices(ti, dm_device_merge_is_compulsory, NULL))
+                        return 0;
+        }
+
+        return 1;
+}
+
+/*
  * Returns old map, which caller must destroy.
  */
 static struct dm_table *__bind(struct mapped_device *md, struct dm_table *t,
@@ -1995,6 +2055,7 @@ static struct dm_table *__bind(struct mapped_device *md, struct dm_table *t,
         struct request_queue *q = md->queue;
         sector_t size;
         unsigned long flags;
+        int merge_is_optional;
 
         size = dm_table_get_size(t);
 
@@ -2020,10 +2081,16 @@ static struct dm_table *__bind(struct mapped_device *md, struct dm_table *t,
 
         __bind_mempools(md, t);
 
+        merge_is_optional = dm_table_merge_is_optional(t);
+
         write_lock_irqsave(&md->map_lock, flags);
         old_map = md->map;
         md->map = t;
         dm_table_set_restrictions(t, q, limits);
+        if (merge_is_optional)
+                set_bit(DMF_MERGE_IS_OPTIONAL, &md->flags);
+        else
+                clear_bit(DMF_MERGE_IS_OPTIONAL, &md->flags);
         write_unlock_irqrestore(&md->map_lock, flags);
 
         return old_map;
diff --git a/drivers/md/dm.h b/drivers/md/dm.h
index 1aaf16746da8..6745dbd278a4 100644
--- a/drivers/md/dm.h
+++ b/drivers/md/dm.h
@@ -66,6 +66,8 @@ int dm_table_alloc_md_mempools(struct dm_table *t);
 void dm_table_free_md_mempools(struct dm_table *t);
 struct dm_md_mempools *dm_table_get_md_mempools(struct dm_table *t);
 
+int dm_queue_merge_is_compulsory(struct request_queue *q);
+
 void dm_lock_md_type(struct mapped_device *md);
 void dm_unlock_md_type(struct mapped_device *md);
 void dm_set_md_type(struct mapped_device *md, unsigned type);
diff --git a/drivers/md/linear.h b/drivers/md/linear.h
index 0ce29b61605a..2f2da05b2ce9 100644
--- a/drivers/md/linear.h
+++ b/drivers/md/linear.h
@@ -10,9 +10,9 @@ typedef struct dev_info dev_info_t;
 
 struct linear_private_data
 {
+        struct rcu_head         rcu;
         sector_t                array_sectors;
         dev_info_t              disks[0];
-        struct rcu_head         rcu;
 };
 
 
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 8e221a20f5d9..5404b2295820 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -848,7 +848,7 @@ void md_super_write(mddev_t *mddev, mdk_rdev_t *rdev,
         bio->bi_end_io = super_written;
 
         atomic_inc(&mddev->pending_writes);
-        submit_bio(REQ_WRITE | REQ_SYNC | REQ_FLUSH | REQ_FUA, bio);
+        submit_bio(WRITE_FLUSH_FUA, bio);
 }
 
 void md_super_wait(mddev_t *mddev)
@@ -1138,8 +1138,11 @@ static int super_90_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version
                         ret = 0;
         }
         rdev->sectors = rdev->sb_start;
+        /* Limit to 4TB as metadata cannot record more than that */
+        if (rdev->sectors >= (2ULL << 32))
+                rdev->sectors = (2ULL << 32) - 2;
 
-        if (rdev->sectors < sb->size * 2 && sb->level > 1)
+        if (rdev->sectors < ((sector_t)sb->size) * 2 && sb->level >= 1)
                 /* "this cannot possibly happen" ... */
                 ret = -EINVAL;
 
@@ -1173,7 +1176,7 @@ static int super_90_validate(mddev_t *mddev, mdk_rdev_t *rdev)
                 mddev->clevel[0] = 0;
                 mddev->layout = sb->layout;
                 mddev->raid_disks = sb->raid_disks;
-                mddev->dev_sectors = sb->size * 2;
+                mddev->dev_sectors = ((sector_t)sb->size) * 2;
                 mddev->events = ev1;
                 mddev->bitmap_info.offset = 0;
                 mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;
@@ -1415,6 +1418,11 @@ super_90_rdev_size_change(mdk_rdev_t *rdev, sector_t num_sectors)
         rdev->sb_start = calc_dev_sboffset(rdev);
         if (!num_sectors || num_sectors > rdev->sb_start)
                 num_sectors = rdev->sb_start;
+        /* Limit to 4TB as metadata cannot record more than that.
+         * 4TB == 2^32 KB, or 2*2^32 sectors.
+         */
+        if (num_sectors >= (2ULL << 32))
+                num_sectors = (2ULL << 32) - 2;
         md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
                        rdev->sb_page);
         md_super_wait(rdev->mddev);
@@ -1738,6 +1746,11 @@ static void super_1_sync(mddev_t *mddev, mdk_rdev_t *rdev)
         sb->level = cpu_to_le32(mddev->level);
         sb->layout = cpu_to_le32(mddev->layout);
 
+        if (test_bit(WriteMostly, &rdev->flags))
+                sb->devflags |= WriteMostly1;
+        else
+                sb->devflags &= ~WriteMostly1;
+
         if (mddev->bitmap && mddev->bitmap_info.file == NULL) {
                 sb->bitmap_offset = cpu_to_le32((__u32)mddev->bitmap_info.offset);
                 sb->feature_map = cpu_to_le32(MD_FEATURE_BITMAP_OFFSET);
@@ -2561,7 +2574,10 @@ state_store(mdk_rdev_t *rdev, const char *buf, size_t len)
         int err = -EINVAL;
         if (cmd_match(buf, "faulty") && rdev->mddev->pers) {
                 md_error(rdev->mddev, rdev);
-                err = 0;
+                if (test_bit(Faulty, &rdev->flags))
+                        err = 0;
+                else
+                        err = -EBUSY;
         } else if (cmd_match(buf, "remove")) {
                 if (rdev->raid_disk >= 0)
                         err = -EBUSY;
@@ -2584,7 +2600,7 @@ state_store(mdk_rdev_t *rdev, const char *buf, size_t len)
                 err = 0;
         } else if (cmd_match(buf, "-blocked")) {
                 if (!test_bit(Faulty, &rdev->flags) &&
-                    test_bit(BlockedBadBlocks, &rdev->flags)) {
+                    rdev->badblocks.unacked_exist) {
                         /* metadata handler doesn't understand badblocks,
                          * so we need to fail the device
                          */
@@ -5983,6 +5999,8 @@ static int set_disk_faulty(mddev_t *mddev, dev_t dev)
                 return -ENODEV;
 
         md_error(mddev, rdev);
+        if (!test_bit(Faulty, &rdev->flags))
+                return -EBUSY;
         return 0;
 }
 
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 32323f0afd89..f4622dd8fc59 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -1099,12 +1099,11 @@ read_again:
                 bio_list_add(&conf->pending_bio_list, mbio);
                 spin_unlock_irqrestore(&conf->device_lock, flags);
         }
-        r1_bio_write_done(r1_bio);
-
-        /* In case raid1d snuck in to freeze_array */
-        wake_up(&conf->wait_barrier);
-
+        /* Mustn't call r1_bio_write_done before this next test,
+         * as it could result in the bio being freed.
+         */
         if (sectors_handled < (bio->bi_size >> 9)) {
+                r1_bio_write_done(r1_bio);
                 /* We need another r1_bio.  It has already been counted
                  * in bio->bi_phys_segments
                  */
@@ -1117,6 +1116,11 @@ read_again:
                 goto retry_write;
         }
 
+        r1_bio_write_done(r1_bio);
+
+        /* In case raid1d snuck in to freeze_array */
+        wake_up(&conf->wait_barrier);
+
         if (do_sync || !bitmap || !plugged)
                 md_wakeup_thread(mddev->thread);
 
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index 8b29cd4f01c8..d7a8468ddeab 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -337,6 +337,21 @@ static void close_write(r10bio_t *r10_bio)
         md_write_end(r10_bio->mddev);
 }
 
+static void one_write_done(r10bio_t *r10_bio)
+{
+        if (atomic_dec_and_test(&r10_bio->remaining)) {
+                if (test_bit(R10BIO_WriteError, &r10_bio->state))
+                        reschedule_retry(r10_bio);
+                else {
+                        close_write(r10_bio);
+                        if (test_bit(R10BIO_MadeGood, &r10_bio->state))
+                                reschedule_retry(r10_bio);
+                        else
+                                raid_end_bio_io(r10_bio);
+                }
+        }
+}
+
 static void raid10_end_write_request(struct bio *bio, int error)
 {
         int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
@@ -387,17 +402,7 @@ static void raid10_end_write_request(struct bio *bio, int error)
          * Let's see if all mirrored write operations have finished
          * already.
          */
-        if (atomic_dec_and_test(&r10_bio->remaining)) {
-                if (test_bit(R10BIO_WriteError, &r10_bio->state))
-                        reschedule_retry(r10_bio);
-                else {
-                        close_write(r10_bio);
-                        if (test_bit(R10BIO_MadeGood, &r10_bio->state))
-                                reschedule_retry(r10_bio);
-                        else
-                                raid_end_bio_io(r10_bio);
-                }
-        }
+        one_write_done(r10_bio);
         if (dec_rdev)
                 rdev_dec_pending(conf->mirrors[dev].rdev, conf->mddev);
 }
@@ -1127,20 +1132,12 @@ retry_write:
                 spin_unlock_irqrestore(&conf->device_lock, flags);
         }
 
-        if (atomic_dec_and_test(&r10_bio->remaining)) {
-                /* This matches the end of raid10_end_write_request() */
-                bitmap_endwrite(r10_bio->mddev->bitmap, r10_bio->sector,
-                                r10_bio->sectors,
-                                !test_bit(R10BIO_Degraded, &r10_bio->state),
-                                0);
-                md_write_end(mddev);
-                raid_end_bio_io(r10_bio);
-        }
-
-        /* In case raid10d snuck in to freeze_array */
-        wake_up(&conf->wait_barrier);
+        /* Don't remove the bias on 'remaining' (one_write_done) until
+         * after checking if we need to go around again.
+         */
 
         if (sectors_handled < (bio->bi_size >> 9)) {
+                one_write_done(r10_bio);
                 /* We need another r10_bio.  It has already been counted
                  * in bio->bi_phys_segments.
                  */
@@ -1154,6 +1151,10 @@ retry_write:
                 r10_bio->state = 0;
                 goto retry_write;
         }
+        one_write_done(r10_bio);
+
+        /* In case raid10d snuck in to freeze_array */
+        wake_up(&conf->wait_barrier);
 
         if (do_sync || !mddev->bitmap || !plugged)
                 md_wakeup_thread(mddev->thread);
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index dbae459fb02d..43709fa6b6df 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -3336,7 +3336,7 @@ static void handle_stripe(struct stripe_head *sh)
 
 finish:
         /* wait for this device to become unblocked */
-        if (unlikely(s.blocked_rdev))
+        if (conf->mddev->external && unlikely(s.blocked_rdev))
                 md_wait_for_blocked_rdev(s.blocked_rdev, conf->mddev);
 
         if (s.handle_bad_blocks)
diff --git a/drivers/media/dvb/dvb-usb/vp7045.c b/drivers/media/dvb/dvb-usb/vp7045.c
index 498024cec2d3..90873af5682e 100644
--- a/drivers/media/dvb/dvb-usb/vp7045.c
+++ b/drivers/media/dvb/dvb-usb/vp7045.c
@@ -224,26 +224,8 @@ static struct dvb_usb_device_properties vp7045_properties;
 static int vp7045_usb_probe(struct usb_interface *intf,
                 const struct usb_device_id *id)
 {
-        struct dvb_usb_device *d;
-        int ret = dvb_usb_device_init(intf, &vp7045_properties,
-                                   THIS_MODULE, &d, adapter_nr);
-        if (ret)
-                return ret;
-
-        d->priv = kmalloc(20, GFP_KERNEL);
-        if (!d->priv) {
-                dvb_usb_device_exit(intf);
-                return -ENOMEM;
-        }
-
-        return ret;
-}
-
-static void vp7045_usb_disconnect(struct usb_interface *intf)
-{
-        struct dvb_usb_device *d = usb_get_intfdata(intf);
-        kfree(d->priv);
-        dvb_usb_device_exit(intf);
+        return dvb_usb_device_init(intf, &vp7045_properties,
+                                   THIS_MODULE, NULL, adapter_nr);
 }
 
 static struct usb_device_id vp7045_usb_table [] = {
@@ -258,7 +240,7 @@ MODULE_DEVICE_TABLE(usb, vp7045_usb_table);
 static struct dvb_usb_device_properties vp7045_properties = {
         .usb_ctrl = CYPRESS_FX2,
         .firmware = "dvb-usb-vp7045-01.fw",
-        .size_of_priv = sizeof(u8 *),
+        .size_of_priv = 20,
 
         .num_adapters = 1,
         .adapter = {
@@ -308,7 +290,7 @@ static struct dvb_usb_device_properties vp7045_properties = {
 static struct usb_driver vp7045_usb_driver = {
         .name           = "dvb_usb_vp7045",
         .probe          = vp7045_usb_probe,
-        .disconnect     = vp7045_usb_disconnect,
+        .disconnect     = dvb_usb_device_exit,
         .id_table       = vp7045_usb_table,
 };
 
diff --git a/drivers/media/rc/nuvoton-cir.c b/drivers/media/rc/nuvoton-cir.c
index eae05b500476..144f3f55d765 100644
--- a/drivers/media/rc/nuvoton-cir.c
+++ b/drivers/media/rc/nuvoton-cir.c
@@ -618,7 +618,6 @@ static void nvt_dump_rx_buf(struct nvt_dev *nvt)
 static void nvt_process_rx_ir_data(struct nvt_dev *nvt)
 {
         DEFINE_IR_RAW_EVENT(rawir);
-        unsigned int count;
         u32 carrier;
         u8 sample;
         int i;
@@ -631,65 +630,38 @@ static void nvt_process_rx_ir_data(struct nvt_dev *nvt)
         if (nvt->carrier_detect_enabled)
                 carrier = nvt_rx_carrier_detect(nvt);
 
-        count = nvt->pkts;
-        nvt_dbg_verbose("Processing buffer of len %d", count);
+        nvt_dbg_verbose("Processing buffer of len %d", nvt->pkts);
 
         init_ir_raw_event(&rawir);
 
-        for (i = 0; i < count; i++) {
-                nvt->pkts--;
+        for (i = 0; i < nvt->pkts; i++) {
                 sample = nvt->buf[i];
 
                 rawir.pulse = ((sample & BUF_PULSE_BIT) != 0);
                 rawir.duration = US_TO_NS((sample & BUF_LEN_MASK)
                                           * SAMPLE_PERIOD);
 
-                if ((sample & BUF_LEN_MASK) == BUF_LEN_MASK) {
-                        if (nvt->rawir.pulse == rawir.pulse)
-                                nvt->rawir.duration += rawir.duration;
-                        else {
-                                nvt->rawir.duration = rawir.duration;
-                                nvt->rawir.pulse = rawir.pulse;
-                        }
-                        continue;
-                }
-
-                rawir.duration += nvt->rawir.duration;
+                nvt_dbg("Storing %s with duration %d",
+                        rawir.pulse ? "pulse" : "space", rawir.duration);
 
-                init_ir_raw_event(&nvt->rawir);
-                nvt->rawir.duration = 0;
-                nvt->rawir.pulse = rawir.pulse;
-
-                if (sample == BUF_PULSE_BIT)
-                        rawir.pulse = false;
-
-                if (rawir.duration) {
-                        nvt_dbg("Storing %s with duration %d",
-                                rawir.pulse ? "pulse" : "space",
-                                rawir.duration);
-
-                        ir_raw_event_store_with_filter(nvt->rdev, &rawir);
-                }
+                ir_raw_event_store_with_filter(nvt->rdev, &rawir);
 
                 /*
                  * BUF_PULSE_BIT indicates end of IR data, BUF_REPEAT_BYTE
                  * indicates end of IR signal, but new data incoming. In both
                  * cases, it means we're ready to call ir_raw_event_handle
                  */
-                if ((sample == BUF_PULSE_BIT) && nvt->pkts) {
+                if ((sample == BUF_PULSE_BIT) && (i + 1 < nvt->pkts)) {
                         nvt_dbg("Calling ir_raw_event_handle (signal end)\n");
                         ir_raw_event_handle(nvt->rdev);
                 }
         }
 
+        nvt->pkts = 0;
+
         nvt_dbg("Calling ir_raw_event_handle (buffer empty)\n");
         ir_raw_event_handle(nvt->rdev);
 
-        if (nvt->pkts) {
-                nvt_dbg("Odd, pkts should be 0 now... (its %u)", nvt->pkts);
-                nvt->pkts = 0;
-        }
-
         nvt_dbg_verbose("%s done", __func__);
 }
 
@@ -1048,7 +1020,6 @@ static int nvt_probe(struct pnp_dev *pdev, const struct pnp_device_id *dev_id)
 
         spin_lock_init(&nvt->nvt_lock);
         spin_lock_init(&nvt->tx.lock);
-        init_ir_raw_event(&nvt->rawir);
 
         ret = -EBUSY;
         /* now claim resources */
diff --git a/drivers/media/rc/nuvoton-cir.h b/drivers/media/rc/nuvoton-cir.h
index 1241fc89a36c..0d5e0872a2ea 100644
--- a/drivers/media/rc/nuvoton-cir.h
+++ b/drivers/media/rc/nuvoton-cir.h
@@ -67,7 +67,6 @@ static int debug;
 struct nvt_dev {
         struct pnp_dev *pdev;
         struct rc_dev *rdev;
-        struct ir_raw_event rawir;
 
         spinlock_t nvt_lock;
 
diff --git a/drivers/media/video/pwc/pwc-v4l.c b/drivers/media/video/pwc/pwc-v4l.c
index e9a0e94b9995..8c70e64444e7 100644
--- a/drivers/media/video/pwc/pwc-v4l.c
+++ b/drivers/media/video/pwc/pwc-v4l.c
@@ -338,7 +338,7 @@ int pwc_init_controls(struct pwc_device *pdev)
         if (pdev->restore_factory)
                 pdev->restore_factory->flags = V4L2_CTRL_FLAG_UPDATE;
 
-        if (!pdev->features & FEATURE_MOTOR_PANTILT)
+        if (!(pdev->features & FEATURE_MOTOR_PANTILT))
                 return hdl->error;
 
         /* Motor pan / tilt / reset */
diff --git a/drivers/media/video/via-camera.c b/drivers/media/video/via-camera.c
index 85d3048c1d67..bb7f17f2a33c 100644
--- a/drivers/media/video/via-camera.c
+++ b/drivers/media/video/via-camera.c
@@ -1332,6 +1332,8 @@ static __devinit bool viacam_serial_is_enabled(void)
         struct pci_bus *pbus = pci_find_bus(0, 0);
         u8 cbyte;
 
+        if (!pbus)
+                return false;
         pci_bus_read_config_byte(pbus, VIACAM_SERIAL_DEVFN,
                         VIACAM_SERIAL_CREG, &cbyte);
         if ((cbyte & VIACAM_SERIAL_BIT) == 0)
diff --git a/drivers/message/fusion/mptscsih.c b/drivers/message/fusion/mptscsih.c
index a1d4ee6671be..ce61a5769765 100644
--- a/drivers/message/fusion/mptscsih.c
+++ b/drivers/message/fusion/mptscsih.c
@@ -827,7 +827,7 @@ mptscsih_io_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr)
                                  * DID_SOFT_ERROR is set.
                                  */
                                 if (ioc->bus_type == SPI) {
-                                        if (pScsiReq->CDB[0] == READ_6  ||
+                                        if ((pScsiReq->CDB[0] == READ_6  && ((pScsiReq->CDB[1] & 0x02) == 0)) ||
                                             pScsiReq->CDB[0] == READ_10 ||
                                             pScsiReq->CDB[0] == READ_12 ||
                                             pScsiReq->CDB[0] == READ_16 ||
diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig
index 37b83eb6d703..21574bdf485f 100644
--- a/drivers/mfd/Kconfig
+++ b/drivers/mfd/Kconfig
@@ -171,6 +171,37 @@ config MFD_TPS6586X
           This driver can also be built as a module.  If so, the module
           will be called tps6586x.
 
+config MFD_TPS65910
+        bool "TPS65910 Power Management chip"
+        depends on I2C=y && GPIOLIB
+        select MFD_CORE
+        select GPIO_TPS65910
+        help
+          if you say yes here you get support for the TPS65910 series of
+          Power Management chips.
+
+config MFD_TPS65912
+        bool
+        depends on GPIOLIB
+
+config MFD_TPS65912_I2C
+        bool "TPS95612 Power Management chip with I2C"
+        select MFD_CORE
+        select MFD_TPS65912
+        depends on I2C=y && GPIOLIB
+        help
+          If you say yes here you get support for the TPS65912 series of
+          PM chips with I2C interface.
+
+config MFD_TPS65912_SPI
+        bool "TPS65912 Power Management chip with SPI"
+        select MFD_CORE
+        select MFD_TPS65912
+        depends on SPI_MASTER && GPIOLIB
+        help
+          If you say yes here you get support for the TPS65912 series of
+          PM chips with SPI interface.
+
 config MENELAUS
         bool "Texas Instruments TWL92330/Menelaus PM chip"
         depends on I2C=y && ARCH_OMAP2
@@ -662,8 +693,9 @@ config MFD_JANZ_CMODIO
           CAN and GPIO controllers.
 
 config MFD_JZ4740_ADC
-        tristate "Support for the JZ4740 SoC ADC core"
+        bool "Support for the JZ4740 SoC ADC core"
         select MFD_CORE
+        select GENERIC_IRQ_CHIP
         depends on MACH_JZ4740
         help
           Say yes here if you want support for the ADC unit in the JZ4740 SoC.
@@ -725,18 +757,19 @@ config MFD_PM8XXX_IRQ
           This is required to use certain other PM 8xxx features, such as GPIO
           and MPP.
 
-config MFD_TPS65910
-        bool "TPS65910 Power Management chip"
-        depends on I2C=y && GPIOLIB
-        select MFD_CORE
-        select GPIO_TPS65910
-        help
-          if you say yes here you get support for the TPS65910 series of
-          Power Management chips.
-
 config TPS65911_COMPARATOR
         tristate
 
+config MFD_AAT2870_CORE
+        bool "Support for the AnalogicTech AAT2870"
+        select MFD_CORE
+        depends on I2C=y && GPIOLIB
+        help
+          If you say yes here you get support for the AAT2870.
+          This driver provides common support for accessing the device,
+          additional drivers must be enabled in order to use the
+          functionality of the device.
+
 endif # MFD_SUPPORT
 
 menu "Multimedia Capabilities Port drivers"
diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile
index 22a280fcb705..c58020303d18 100644
--- a/drivers/mfd/Makefile
+++ b/drivers/mfd/Makefile
@@ -23,6 +23,7 @@ obj-$(CONFIG_MFD_TC6393XB)	+= tc6393xb.o tmio_core.o
 
 obj-$(CONFIG_MFD_WM8400)        += wm8400-core.o
 wm831x-objs                     := wm831x-core.o wm831x-irq.o wm831x-otp.o
+wm831x-objs                     += wm831x-auxadc.o
 obj-$(CONFIG_MFD_WM831X)        += wm831x.o
 obj-$(CONFIG_MFD_WM831X_I2C)    += wm831x-i2c.o
 obj-$(CONFIG_MFD_WM831X_SPI)    += wm831x-spi.o
@@ -35,6 +36,11 @@ obj-$(CONFIG_MFD_WM8994)	+= wm8994-core.o wm8994-irq.o
 obj-$(CONFIG_TPS6105X)          += tps6105x.o
 obj-$(CONFIG_TPS65010)          += tps65010.o
 obj-$(CONFIG_TPS6507X)          += tps6507x.o
+obj-$(CONFIG_MFD_TPS65910)      += tps65910.o tps65910-irq.o
+tps65912-objs                   := tps65912-core.o tps65912-irq.o
+obj-$(CONFIG_MFD_TPS65912)      += tps65912.o
+obj-$(CONFIG_MFD_TPS65912_I2C)  += tps65912-i2c.o
+obj-$(CONFIG_MFD_TPS65912_SPI)  += tps65912-spi.o
 obj-$(CONFIG_MENELAUS)          += menelaus.o
 
 obj-$(CONFIG_TWL4030_CORE)      += twl-core.o twl4030-irq.o twl6030-irq.o
@@ -94,5 +100,5 @@ obj-$(CONFIG_MFD_CS5535)	+= cs5535-mfd.o
 obj-$(CONFIG_MFD_OMAP_USB_HOST) += omap-usb-host.o
 obj-$(CONFIG_MFD_PM8921_CORE)   += pm8921-core.o
 obj-$(CONFIG_MFD_PM8XXX_IRQ)    += pm8xxx-irq.o
-obj-$(CONFIG_MFD_TPS65910)      += tps65910.o tps65910-irq.o
 obj-$(CONFIG_TPS65911_COMPARATOR)       += tps65911-comparator.o
+obj-$(CONFIG_MFD_AAT2870_CORE)  += aat2870-core.o
diff --git a/drivers/mfd/aat2870-core.c b/drivers/mfd/aat2870-core.c
new file mode 100644
index 000000000000..345dc658ef06
--- /dev/null
+++ b/drivers/mfd/aat2870-core.c
@@ -0,0 +1,535 @@
+/*
+ * linux/drivers/mfd/aat2870-core.c
+ *
+ * Copyright (c) 2011, NVIDIA Corporation.
+ * Author: Jin Park <jinyoungp@nvidia.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * 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
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/debugfs.h>
+#include <linux/slab.h>
+#include <linux/uaccess.h>
+#include <linux/i2c.h>
+#include <linux/delay.h>
+#include <linux/gpio.h>
+#include <linux/mfd/core.h>
+#include <linux/mfd/aat2870.h>
+#include <linux/regulator/machine.h>
+
+static struct aat2870_register aat2870_regs[AAT2870_REG_NUM] = {
+        /* readable, writeable, value */
+        { 0, 1, 0x00 }, /* 0x00 AAT2870_BL_CH_EN */
+        { 0, 1, 0x16 }, /* 0x01 AAT2870_BLM */
+        { 0, 1, 0x16 }, /* 0x02 AAT2870_BLS */
+        { 0, 1, 0x56 }, /* 0x03 AAT2870_BL1 */
+        { 0, 1, 0x56 }, /* 0x04 AAT2870_BL2 */
+        { 0, 1, 0x56 }, /* 0x05 AAT2870_BL3 */
+        { 0, 1, 0x56 }, /* 0x06 AAT2870_BL4 */
+        { 0, 1, 0x56 }, /* 0x07 AAT2870_BL5 */
+        { 0, 1, 0x56 }, /* 0x08 AAT2870_BL6 */
+        { 0, 1, 0x56 }, /* 0x09 AAT2870_BL7 */
+        { 0, 1, 0x56 }, /* 0x0A AAT2870_BL8 */
+        { 0, 1, 0x00 }, /* 0x0B AAT2870_FLR */
+        { 0, 1, 0x03 }, /* 0x0C AAT2870_FM */
+        { 0, 1, 0x03 }, /* 0x0D AAT2870_FS */
+        { 0, 1, 0x10 }, /* 0x0E AAT2870_ALS_CFG0 */
+        { 0, 1, 0x06 }, /* 0x0F AAT2870_ALS_CFG1 */
+        { 0, 1, 0x00 }, /* 0x10 AAT2870_ALS_CFG2 */
+        { 1, 0, 0x00 }, /* 0x11 AAT2870_AMB */
+        { 0, 1, 0x00 }, /* 0x12 AAT2870_ALS0 */
+        { 0, 1, 0x00 }, /* 0x13 AAT2870_ALS1 */
+        { 0, 1, 0x00 }, /* 0x14 AAT2870_ALS2 */
+        { 0, 1, 0x00 }, /* 0x15 AAT2870_ALS3 */
+        { 0, 1, 0x00 }, /* 0x16 AAT2870_ALS4 */
+        { 0, 1, 0x00 }, /* 0x17 AAT2870_ALS5 */
+        { 0, 1, 0x00 }, /* 0x18 AAT2870_ALS6 */
+        { 0, 1, 0x00 }, /* 0x19 AAT2870_ALS7 */
+        { 0, 1, 0x00 }, /* 0x1A AAT2870_ALS8 */
+        { 0, 1, 0x00 }, /* 0x1B AAT2870_ALS9 */
+        { 0, 1, 0x00 }, /* 0x1C AAT2870_ALSA */
+        { 0, 1, 0x00 }, /* 0x1D AAT2870_ALSB */
+        { 0, 1, 0x00 }, /* 0x1E AAT2870_ALSC */
+        { 0, 1, 0x00 }, /* 0x1F AAT2870_ALSD */
+        { 0, 1, 0x00 }, /* 0x20 AAT2870_ALSE */
+        { 0, 1, 0x00 }, /* 0x21 AAT2870_ALSF */
+        { 0, 1, 0x00 }, /* 0x22 AAT2870_SUB_SET */
+        { 0, 1, 0x00 }, /* 0x23 AAT2870_SUB_CTRL */
+        { 0, 1, 0x00 }, /* 0x24 AAT2870_LDO_AB */
+        { 0, 1, 0x00 }, /* 0x25 AAT2870_LDO_CD */
+        { 0, 1, 0x00 }, /* 0x26 AAT2870_LDO_EN */
+};
+
+static struct mfd_cell aat2870_devs[] = {
+        {
+                .name = "aat2870-backlight",
+                .id = AAT2870_ID_BL,
+                .pdata_size = sizeof(struct aat2870_bl_platform_data),
+        },
+        {
+                .name = "aat2870-regulator",
+                .id = AAT2870_ID_LDOA,
+                .pdata_size = sizeof(struct regulator_init_data),
+        },
+        {
+                .name = "aat2870-regulator",
+                .id = AAT2870_ID_LDOB,
+                .pdata_size = sizeof(struct regulator_init_data),
+        },
+        {
+                .name = "aat2870-regulator",
+                .id = AAT2870_ID_LDOC,
+                .pdata_size = sizeof(struct regulator_init_data),
+        },
+        {
+                .name = "aat2870-regulator",
+                .id = AAT2870_ID_LDOD,
+                .pdata_size = sizeof(struct regulator_init_data),
+        },
+};
+
+static int __aat2870_read(struct aat2870_data *aat2870, u8 addr, u8 *val)
+{
+        int ret;
+
+        if (addr >= AAT2870_REG_NUM) {
+                dev_err(aat2870->dev, "Invalid address, 0x%02x\n", addr);
+                return -EINVAL;
+        }
+
+        if (!aat2870->reg_cache[addr].readable) {
+                *val = aat2870->reg_cache[addr].value;
+                goto out;
+        }
+
+        ret = i2c_master_send(aat2870->client, &addr, 1);
+        if (ret < 0)
+                return ret;
+        if (ret != 1)
+                return -EIO;
+
+        ret = i2c_master_recv(aat2870->client, val, 1);
+        if (ret < 0)
+                return ret;
+        if (ret != 1)
+                return -EIO;
+
+out:
+        dev_dbg(aat2870->dev, "read: addr=0x%02x, val=0x%02x\n", addr, *val);
+        return 0;
+}
+
+static int __aat2870_write(struct aat2870_data *aat2870, u8 addr, u8 val)
+{
+        u8 msg[2];
+        int ret;
+
+        if (addr >= AAT2870_REG_NUM) {
+                dev_err(aat2870->dev, "Invalid address, 0x%02x\n", addr);
+                return -EINVAL;
+        }
+
+        if (!aat2870->reg_cache[addr].writeable) {
+                dev_err(aat2870->dev, "Address 0x%02x is not writeable\n",
+                        addr);
+                return -EINVAL;
+        }
+
+        msg[0] = addr;
+        msg[1] = val;
+        ret = i2c_master_send(aat2870->client, msg, 2);
+        if (ret < 0)
+                return ret;
+        if (ret != 2)
+                return -EIO;
+
+        aat2870->reg_cache[addr].value = val;
+
+        dev_dbg(aat2870->dev, "write: addr=0x%02x, val=0x%02x\n", addr, val);
+        return 0;
+}
+
+static int aat2870_read(struct aat2870_data *aat2870, u8 addr, u8 *val)
+{
+        int ret;
+
+        mutex_lock(&aat2870->io_lock);
+        ret = __aat2870_read(aat2870, addr, val);
+        mutex_unlock(&aat2870->io_lock);
+
+        return ret;
+}
+
+static int aat2870_write(struct aat2870_data *aat2870, u8 addr, u8 val)
+{
+        int ret;
+
+        mutex_lock(&aat2870->io_lock);
+        ret = __aat2870_write(aat2870, addr, val);
+        mutex_unlock(&aat2870->io_lock);
+
+        return ret;
+}
+
+static int aat2870_update(struct aat2870_data *aat2870, u8 addr, u8 mask,
+                          u8 val)
+{
+        int change;
+        u8 old_val, new_val;
+        int ret;
+
+        mutex_lock(&aat2870->io_lock);
+
+        ret = __aat2870_read(aat2870, addr, &old_val);
+        if (ret)
+                goto out_unlock;
+
+        new_val = (old_val & ~mask) | (val & mask);
+        change = old_val != new_val;
+        if (change)
+                ret = __aat2870_write(aat2870, addr, new_val);
+
+out_unlock:
+        mutex_unlock(&aat2870->io_lock);
+
+        return ret;
+}
+
+static inline void aat2870_enable(struct aat2870_data *aat2870)
+{
+        if (aat2870->en_pin >= 0)
+                gpio_set_value(aat2870->en_pin, 1);
+
+        aat2870->is_enable = 1;
+}
+
+static inline void aat2870_disable(struct aat2870_data *aat2870)
+{
+        if (aat2870->en_pin >= 0)
+                gpio_set_value(aat2870->en_pin, 0);
+
+        aat2870->is_enable = 0;
+}
+
+#ifdef CONFIG_DEBUG_FS
+static ssize_t aat2870_dump_reg(struct aat2870_data *aat2870, char *buf)
+{
+        u8 addr, val;
+        ssize_t count = 0;
+        int ret;
+
+        count += sprintf(buf, "aat2870 registers\n");
+        for (addr = 0; addr < AAT2870_REG_NUM; addr++) {
+                count += sprintf(buf + count, "0x%02x: ", addr);
+                if (count >= PAGE_SIZE - 1)
+                        break;
+
+                ret = aat2870->read(aat2870, addr, &val);
+                if (ret == 0)
+                        count += snprintf(buf + count, PAGE_SIZE - count,
+                                          "0x%02x", val);
+                else
+                        count += snprintf(buf + count, PAGE_SIZE - count,
+                                          "<read fail: %d>", ret);
+
+                if (count >= PAGE_SIZE - 1)
+                        break;
+
+                count += snprintf(buf + count, PAGE_SIZE - count, "\n");
+                if (count >= PAGE_SIZE - 1)
+                        break;
+        }
+
+        /* Truncate count; min() would cause a warning */
+        if (count >= PAGE_SIZE)
+                count = PAGE_SIZE - 1;
+
+        return count;
+}
+
+static int aat2870_reg_open_file(struct inode *inode, struct file *file)
+{
+        file->private_data = inode->i_private;
+
+        return 0;
+}
+
+static ssize_t aat2870_reg_read_file(struct file *file, char __user *user_buf,
+                                     size_t count, loff_t *ppos)
+{
+        struct aat2870_data *aat2870 = file->private_data;
+        char *buf;
+        ssize_t ret;
+
+        buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
+        if (!buf)
+                return -ENOMEM;
+
+        ret = aat2870_dump_reg(aat2870, buf);
+        if (ret >= 0)
+                ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
+
+        kfree(buf);
+
+        return ret;
+}
+
+static ssize_t aat2870_reg_write_file(struct file *file,
+                                      const char __user *user_buf, size_t count,
+                                      loff_t *ppos)
+{
+        struct aat2870_data *aat2870 = file->private_data;
+        char buf[32];
+        int buf_size;
+        char *start = buf;
+        unsigned long addr, val;
+        int ret;
+
+        buf_size = min(count, (sizeof(buf)-1));
+        if (copy_from_user(buf, user_buf, buf_size)) {
+                dev_err(aat2870->dev, "Failed to copy from user\n");
+                return -EFAULT;
+        }
+        buf[buf_size] = 0;
+
+        while (*start == ' ')
+                start++;
+
+        addr = simple_strtoul(start, &start, 16);
+        if (addr >= AAT2870_REG_NUM) {
+                dev_err(aat2870->dev, "Invalid address, 0x%lx\n", addr);
+                return -EINVAL;
+        }
+
+        while (*start == ' ')
+                start++;
+
+        if (strict_strtoul(start, 16, &val))
+                return -EINVAL;
+
+        ret = aat2870->write(aat2870, (u8)addr, (u8)val);
+        if (ret)
+                return ret;
+
+        return buf_size;
+}
+
+static const struct file_operations aat2870_reg_fops = {
+        .open = aat2870_reg_open_file,
+        .read = aat2870_reg_read_file,
+        .write = aat2870_reg_write_file,
+};
+
+static void aat2870_init_debugfs(struct aat2870_data *aat2870)
+{
+        aat2870->dentry_root = debugfs_create_dir("aat2870", NULL);
+        if (!aat2870->dentry_root) {
+                dev_warn(aat2870->dev,
+                         "Failed to create debugfs root directory\n");
+                return;
+        }
+
+        aat2870->dentry_reg = debugfs_create_file("regs", 0644,
+                                                  aat2870->dentry_root,
+                                                  aat2870, &aat2870_reg_fops);
+        if (!aat2870->dentry_reg)
+                dev_warn(aat2870->dev,
+                         "Failed to create debugfs register file\n");
+}
+
+static void aat2870_uninit_debugfs(struct aat2870_data *aat2870)
+{
+        debugfs_remove_recursive(aat2870->dentry_root);
+}
+#else
+static inline void aat2870_init_debugfs(struct aat2870_data *aat2870)
+{
+}
+
+static inline void aat2870_uninit_debugfs(struct aat2870_data *aat2870)
+{
+}
+#endif /* CONFIG_DEBUG_FS */
+
+static int aat2870_i2c_probe(struct i2c_client *client,
+                             const struct i2c_device_id *id)
+{
+        struct aat2870_platform_data *pdata = client->dev.platform_data;
+        struct aat2870_data *aat2870;
+        int i, j;
+        int ret = 0;
+
+        aat2870 = kzalloc(sizeof(struct aat2870_data), GFP_KERNEL);
+        if (!aat2870) {
+                dev_err(&client->dev,
+                        "Failed to allocate memory for aat2870\n");
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        aat2870->dev = &client->dev;
+        dev_set_drvdata(aat2870->dev, aat2870);
+
+        aat2870->client = client;
+        i2c_set_clientdata(client, aat2870);
+
+        aat2870->reg_cache = aat2870_regs;
+
+        if (pdata->en_pin < 0)
+                aat2870->en_pin = -1;
+        else
+                aat2870->en_pin = pdata->en_pin;
+
+        aat2870->init = pdata->init;
+        aat2870->uninit = pdata->uninit;
+        aat2870->read = aat2870_read;
+        aat2870->write = aat2870_write;
+        aat2870->update = aat2870_update;
+
+        mutex_init(&aat2870->io_lock);
+
+        if (aat2870->init)
+                aat2870->init(aat2870);
+
+        if (aat2870->en_pin >= 0) {
+                ret = gpio_request(aat2870->en_pin, "aat2870-en");
+                if (ret < 0) {
+                        dev_err(&client->dev,
+                                "Failed to request GPIO %d\n", aat2870->en_pin);
+                        goto out_kfree;
+                }
+                gpio_direction_output(aat2870->en_pin, 1);
+        }
+
+        aat2870_enable(aat2870);
+
+        for (i = 0; i < pdata->num_subdevs; i++) {
+                for (j = 0; j < ARRAY_SIZE(aat2870_devs); j++) {
+                        if ((pdata->subdevs[i].id == aat2870_devs[j].id) &&
+                                        !strcmp(pdata->subdevs[i].name,
+                                                aat2870_devs[j].name)) {
+                                aat2870_devs[j].platform_data =
+                                        pdata->subdevs[i].platform_data;
+                                break;
+                        }
+                }
+        }
+
+        ret = mfd_add_devices(aat2870->dev, 0, aat2870_devs,
+                              ARRAY_SIZE(aat2870_devs), NULL, 0);
+        if (ret != 0) {
+                dev_err(aat2870->dev, "Failed to add subdev: %d\n", ret);
+                goto out_disable;
+        }
+
+        aat2870_init_debugfs(aat2870);
+
+        return 0;
+
+out_disable:
+        aat2870_disable(aat2870);
+        if (aat2870->en_pin >= 0)
+                gpio_free(aat2870->en_pin);
+out_kfree:
+        kfree(aat2870);
+out:
+        return ret;
+}
+
+static int aat2870_i2c_remove(struct i2c_client *client)
+{
+        struct aat2870_data *aat2870 = i2c_get_clientdata(client);
+
+        aat2870_uninit_debugfs(aat2870);
+
+        mfd_remove_devices(aat2870->dev);
+        aat2870_disable(aat2870);
+        if (aat2870->en_pin >= 0)
+                gpio_free(aat2870->en_pin);
+        if (aat2870->uninit)
+                aat2870->uninit(aat2870);
+        kfree(aat2870);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int aat2870_i2c_suspend(struct i2c_client *client, pm_message_t state)
+{
+        struct aat2870_data *aat2870 = i2c_get_clientdata(client);
+
+        aat2870_disable(aat2870);
+
+        return 0;
+}
+
+static int aat2870_i2c_resume(struct i2c_client *client)
+{
+        struct aat2870_data *aat2870 = i2c_get_clientdata(client);
+        struct aat2870_register *reg = NULL;
+        int i;
+
+        aat2870_enable(aat2870);
+
+        /* restore registers */
+        for (i = 0; i < AAT2870_REG_NUM; i++) {
+                reg = &aat2870->reg_cache[i];
+                if (reg->writeable)
+                        aat2870->write(aat2870, i, reg->value);
+        }
+
+        return 0;
+}
+#else
+#define aat2870_i2c_suspend     NULL
+#define aat2870_i2c_resume      NULL
+#endif /* CONFIG_PM */
+
+static struct i2c_device_id aat2870_i2c_id_table[] = {
+        { "aat2870", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, aat2870_i2c_id_table);
+
+static struct i2c_driver aat2870_i2c_driver = {
+        .driver = {
+                .name   = "aat2870",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = aat2870_i2c_probe,
+        .remove         = aat2870_i2c_remove,
+        .suspend        = aat2870_i2c_suspend,
+        .resume         = aat2870_i2c_resume,
+        .id_table       = aat2870_i2c_id_table,
+};
+
+static int __init aat2870_init(void)
+{
+        return i2c_add_driver(&aat2870_i2c_driver);
+}
+subsys_initcall(aat2870_init);
+
+static void __exit aat2870_exit(void)
+{
+        i2c_del_driver(&aat2870_i2c_driver);
+}
+module_exit(aat2870_exit);
+
+MODULE_DESCRIPTION("Core support for the AnalogicTech AAT2870");
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Jin Park <jinyoungp@nvidia.com>");
diff --git a/drivers/mfd/ab3550-core.c b/drivers/mfd/ab3550-core.c
index 3d7dce671b93..56ba1943c91d 100644
--- a/drivers/mfd/ab3550-core.c
+++ b/drivers/mfd/ab3550-core.c
@@ -879,20 +879,13 @@ static ssize_t ab3550_bank_write(struct file *file,
         size_t count, loff_t *ppos)
 {
         struct ab3550 *ab = ((struct seq_file *)(file->private_data))->private;
-        char buf[32];
-        int buf_size;
         unsigned long user_bank;
         int err;
 
         /* Get userspace string and assure termination */
-        buf_size = min(count, (sizeof(buf) - 1));
-        if (copy_from_user(buf, user_buf, buf_size))
-                return -EFAULT;
-        buf[buf_size] = 0;
-
-        err = strict_strtoul(buf, 0, &user_bank);
+        err = kstrtoul_from_user(user_buf, count, 0, &user_bank);
         if (err)
-                return -EINVAL;
+                return err;
 
         if (user_bank >= AB3550_NUM_BANKS) {
                 dev_err(&ab->i2c_client[0]->dev,
@@ -902,7 +895,7 @@ static ssize_t ab3550_bank_write(struct file *file,
 
         ab->debug_bank = user_bank;
 
-        return buf_size;
+        return count;
 }
 
 static int ab3550_address_print(struct seq_file *s, void *p)
@@ -923,27 +916,21 @@ static ssize_t ab3550_address_write(struct file *file,
         size_t count, loff_t *ppos)
 {
         struct ab3550 *ab = ((struct seq_file *)(file->private_data))->private;
-        char buf[32];
-        int buf_size;
         unsigned long user_address;
         int err;
 
         /* Get userspace string and assure termination */
-        buf_size = min(count, (sizeof(buf) - 1));
-        if (copy_from_user(buf, user_buf, buf_size))
-                return -EFAULT;
-        buf[buf_size] = 0;
-
-        err = strict_strtoul(buf, 0, &user_address);
+        err = kstrtoul_from_user(user_buf, count, 0, &user_address);
         if (err)
-                return -EINVAL;
+                return err;
+
         if (user_address > 0xff) {
                 dev_err(&ab->i2c_client[0]->dev,
                         "debugfs error input > 0xff\n");
                 return -EINVAL;
         }
         ab->debug_address = user_address;
-        return buf_size;
+        return count;
 }
 
 static int ab3550_val_print(struct seq_file *s, void *p)
@@ -971,21 +958,15 @@ static ssize_t ab3550_val_write(struct file *file,
         size_t count, loff_t *ppos)
 {
         struct ab3550 *ab = ((struct seq_file *)(file->private_data))->private;
-        char buf[32];
-        int buf_size;
         unsigned long user_val;
         int err;
         u8 regvalue;
 
         /* Get userspace string and assure termination */
-        buf_size = min(count, (sizeof(buf)-1));
-        if (copy_from_user(buf, user_buf, buf_size))
-                return -EFAULT;
-        buf[buf_size] = 0;
-
-        err = strict_strtoul(buf, 0, &user_val);
+        err = kstrtoul_from_user(user_buf, count, 0, &user_val);
         if (err)
-                return -EINVAL;
+                return err;
+
         if (user_val > 0xff) {
                 dev_err(&ab->i2c_client[0]->dev,
                         "debugfs error input > 0xff\n");
@@ -1002,7 +983,7 @@ static ssize_t ab3550_val_write(struct file *file,
         if (err)
                 return -EINVAL;
 
-        return buf_size;
+        return count;
 }
 
 static const struct file_operations ab3550_bank_fops = {
diff --git a/drivers/mfd/ab8500-core.c b/drivers/mfd/ab8500-core.c
index fc0c1af1566e..387705e494b9 100644
--- a/drivers/mfd/ab8500-core.c
+++ b/drivers/mfd/ab8500-core.c
@@ -363,7 +363,7 @@ static void ab8500_irq_remove(struct ab8500 *ab8500)
         }
 }
 
-static struct resource ab8500_gpio_resources[] = {
+static struct resource __devinitdata ab8500_gpio_resources[] = {
         {
                 .name   = "GPIO_INT6",
                 .start  = AB8500_INT_GPIO6R,
@@ -372,7 +372,7 @@ static struct resource ab8500_gpio_resources[] = {
         }
 };
 
-static struct resource ab8500_gpadc_resources[] = {
+static struct resource __devinitdata ab8500_gpadc_resources[] = {
         {
                 .name   = "HW_CONV_END",
                 .start  = AB8500_INT_GP_HW_ADC_CONV_END,
@@ -387,7 +387,7 @@ static struct resource ab8500_gpadc_resources[] = {
         },
 };
 
-static struct resource ab8500_rtc_resources[] = {
+static struct resource __devinitdata ab8500_rtc_resources[] = {
         {
                 .name   = "60S",
                 .start  = AB8500_INT_RTC_60S,
@@ -402,7 +402,7 @@ static struct resource ab8500_rtc_resources[] = {
         },
 };
 
-static struct resource ab8500_poweronkey_db_resources[] = {
+static struct resource __devinitdata ab8500_poweronkey_db_resources[] = {
         {
                 .name   = "ONKEY_DBF",
                 .start  = AB8500_INT_PON_KEY1DB_F,
@@ -417,20 +417,47 @@ static struct resource ab8500_poweronkey_db_resources[] = {
         },
 };
 
-static struct resource ab8500_bm_resources[] = {
+static struct resource __devinitdata ab8500_av_acc_detect_resources[] = {
         {
-                .name = "MAIN_EXT_CH_NOT_OK",
-                .start = AB8500_INT_MAIN_EXT_CH_NOT_OK,
-                .end = AB8500_INT_MAIN_EXT_CH_NOT_OK,
-                .flags = IORESOURCE_IRQ,
+               .name = "ACC_DETECT_1DB_F",
+               .start = AB8500_INT_ACC_DETECT_1DB_F,
+               .end = AB8500_INT_ACC_DETECT_1DB_F,
+               .flags = IORESOURCE_IRQ,
         },
         {
-                .name = "BATT_OVV",
-                .start = AB8500_INT_BATT_OVV,
-                .end = AB8500_INT_BATT_OVV,
-                .flags = IORESOURCE_IRQ,
+               .name = "ACC_DETECT_1DB_R",
+               .start = AB8500_INT_ACC_DETECT_1DB_R,
+               .end = AB8500_INT_ACC_DETECT_1DB_R,
+               .flags = IORESOURCE_IRQ,
+        },
+        {
+               .name = "ACC_DETECT_21DB_F",
+               .start = AB8500_INT_ACC_DETECT_21DB_F,
+               .end = AB8500_INT_ACC_DETECT_21DB_F,
+               .flags = IORESOURCE_IRQ,
+        },
+        {
+               .name = "ACC_DETECT_21DB_R",
+               .start = AB8500_INT_ACC_DETECT_21DB_R,
+               .end = AB8500_INT_ACC_DETECT_21DB_R,
+               .flags = IORESOURCE_IRQ,
+        },
+        {
+               .name = "ACC_DETECT_22DB_F",
+               .start = AB8500_INT_ACC_DETECT_22DB_F,
+               .end = AB8500_INT_ACC_DETECT_22DB_F,
+               .flags = IORESOURCE_IRQ,
         },
         {
+               .name = "ACC_DETECT_22DB_R",
+               .start = AB8500_INT_ACC_DETECT_22DB_R,
+               .end = AB8500_INT_ACC_DETECT_22DB_R,
+               .flags = IORESOURCE_IRQ,
+        },
+};
+
+static struct resource __devinitdata ab8500_charger_resources[] = {
+        {
                 .name = "MAIN_CH_UNPLUG_DET",
                 .start = AB8500_INT_MAIN_CH_UNPLUG_DET,
                 .end = AB8500_INT_MAIN_CH_UNPLUG_DET,
@@ -443,27 +470,27 @@ static struct resource ab8500_bm_resources[] = {
                 .flags = IORESOURCE_IRQ,
         },
         {
-                .name = "VBUS_DET_F",
-                .start = AB8500_INT_VBUS_DET_F,
-                .end = AB8500_INT_VBUS_DET_F,
-                .flags = IORESOURCE_IRQ,
-        },
-        {
                 .name = "VBUS_DET_R",
                 .start = AB8500_INT_VBUS_DET_R,
                 .end = AB8500_INT_VBUS_DET_R,
                 .flags = IORESOURCE_IRQ,
         },
         {
-                .name = "BAT_CTRL_INDB",
-                .start = AB8500_INT_BAT_CTRL_INDB,
-                .end = AB8500_INT_BAT_CTRL_INDB,
+                .name = "VBUS_DET_F",
+                .start = AB8500_INT_VBUS_DET_F,
+                .end = AB8500_INT_VBUS_DET_F,
                 .flags = IORESOURCE_IRQ,
         },
         {
-                .name = "CH_WD_EXP",
-                .start = AB8500_INT_CH_WD_EXP,
-                .end = AB8500_INT_CH_WD_EXP,
+                .name = "USB_LINK_STATUS",
+                .start = AB8500_INT_USB_LINK_STATUS,
+                .end = AB8500_INT_USB_LINK_STATUS,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .name = "USB_CHARGE_DET_DONE",
+                .start = AB8500_INT_USB_CHG_DET_DONE,
+                .end = AB8500_INT_USB_CHG_DET_DONE,
                 .flags = IORESOURCE_IRQ,
         },
         {
@@ -473,21 +500,60 @@ static struct resource ab8500_bm_resources[] = {
                 .flags = IORESOURCE_IRQ,
         },
         {
-                .name = "NCONV_ACCU",
-                .start = AB8500_INT_CCN_CONV_ACC,
-                .end = AB8500_INT_CCN_CONV_ACC,
+                .name = "USB_CH_TH_PROT_R",
+                .start = AB8500_INT_USB_CH_TH_PROT_R,
+                .end = AB8500_INT_USB_CH_TH_PROT_R,
                 .flags = IORESOURCE_IRQ,
         },
         {
-                .name = "LOW_BAT_F",
-                .start = AB8500_INT_LOW_BAT_F,
-                .end = AB8500_INT_LOW_BAT_F,
+                .name = "USB_CH_TH_PROT_F",
+                .start = AB8500_INT_USB_CH_TH_PROT_F,
+                .end = AB8500_INT_USB_CH_TH_PROT_F,
                 .flags = IORESOURCE_IRQ,
         },
         {
-                .name = "LOW_BAT_R",
-                .start = AB8500_INT_LOW_BAT_R,
-                .end = AB8500_INT_LOW_BAT_R,
+                .name = "MAIN_EXT_CH_NOT_OK",
+                .start = AB8500_INT_MAIN_EXT_CH_NOT_OK,
+                .end = AB8500_INT_MAIN_EXT_CH_NOT_OK,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .name = "MAIN_CH_TH_PROT_R",
+                .start = AB8500_INT_MAIN_CH_TH_PROT_R,
+                .end = AB8500_INT_MAIN_CH_TH_PROT_R,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .name = "MAIN_CH_TH_PROT_F",
+                .start = AB8500_INT_MAIN_CH_TH_PROT_F,
+                .end = AB8500_INT_MAIN_CH_TH_PROT_F,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .name = "USB_CHARGER_NOT_OKR",
+                .start = AB8500_INT_USB_CHARGER_NOT_OK,
+                .end = AB8500_INT_USB_CHARGER_NOT_OK,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .name = "USB_CHARGER_NOT_OKF",
+                .start = AB8500_INT_USB_CHARGER_NOT_OKF,
+                .end = AB8500_INT_USB_CHARGER_NOT_OKF,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .name = "CH_WD_EXP",
+                .start = AB8500_INT_CH_WD_EXP,
+                .end = AB8500_INT_CH_WD_EXP,
+                .flags = IORESOURCE_IRQ,
+        },
+};
+
+static struct resource __devinitdata ab8500_btemp_resources[] = {
+        {
+                .name = "BAT_CTRL_INDB",
+                .start = AB8500_INT_BAT_CTRL_INDB,
+                .end = AB8500_INT_BAT_CTRL_INDB,
                 .flags = IORESOURCE_IRQ,
         },
         {
@@ -503,38 +569,55 @@ static struct resource ab8500_bm_resources[] = {
                 .flags = IORESOURCE_IRQ,
         },
         {
-                .name = "USB_CHARGER_NOT_OKR",
-                .start = AB8500_INT_USB_CHARGER_NOT_OK,
-                .end = AB8500_INT_USB_CHARGER_NOT_OK,
+                .name = "BTEMP_LOW_MEDIUM",
+                .start = AB8500_INT_BTEMP_LOW_MEDIUM,
+                .end = AB8500_INT_BTEMP_LOW_MEDIUM,
                 .flags = IORESOURCE_IRQ,
         },
         {
-                .name = "USB_CHARGE_DET_DONE",
-                .start = AB8500_INT_USB_CHG_DET_DONE,
-                .end = AB8500_INT_USB_CHG_DET_DONE,
+                .name = "BTEMP_MEDIUM_HIGH",
+                .start = AB8500_INT_BTEMP_MEDIUM_HIGH,
+                .end = AB8500_INT_BTEMP_MEDIUM_HIGH,
                 .flags = IORESOURCE_IRQ,
         },
+};
+
+static struct resource __devinitdata ab8500_fg_resources[] = {
         {
-                .name = "USB_CH_TH_PROT_R",
-                .start = AB8500_INT_USB_CH_TH_PROT_R,
-                .end = AB8500_INT_USB_CH_TH_PROT_R,
+                .name = "NCONV_ACCU",
+                .start = AB8500_INT_CCN_CONV_ACC,
+                .end = AB8500_INT_CCN_CONV_ACC,
                 .flags = IORESOURCE_IRQ,
         },
         {
-                .name = "MAIN_CH_TH_PROT_R",
-                .start = AB8500_INT_MAIN_CH_TH_PROT_R,
-                .end = AB8500_INT_MAIN_CH_TH_PROT_R,
+                .name = "BATT_OVV",
+                .start = AB8500_INT_BATT_OVV,
+                .end = AB8500_INT_BATT_OVV,
                 .flags = IORESOURCE_IRQ,
         },
         {
-                .name = "USB_CHARGER_NOT_OKF",
-                .start = AB8500_INT_USB_CHARGER_NOT_OKF,
-                .end = AB8500_INT_USB_CHARGER_NOT_OKF,
+                .name = "LOW_BAT_F",
+                .start = AB8500_INT_LOW_BAT_F,
+                .end = AB8500_INT_LOW_BAT_F,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .name = "LOW_BAT_R",
+                .start = AB8500_INT_LOW_BAT_R,
+                .end = AB8500_INT_LOW_BAT_R,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .name = "CC_INT_CALIB",
+                .start = AB8500_INT_CC_INT_CALIB,
+                .end = AB8500_INT_CC_INT_CALIB,
                 .flags = IORESOURCE_IRQ,
         },
 };
 
-static struct resource ab8500_debug_resources[] = {
+static struct resource __devinitdata ab8500_chargalg_resources[] = {};
+
+static struct resource __devinitdata ab8500_debug_resources[] = {
         {
                 .name   = "IRQ_FIRST",
                 .start  = AB8500_INT_MAIN_EXT_CH_NOT_OK,
@@ -549,7 +632,7 @@ static struct resource ab8500_debug_resources[] = {
         },
 };
 
-static struct resource ab8500_usb_resources[] = {
+static struct resource __devinitdata ab8500_usb_resources[] = {
         {
                 .name = "ID_WAKEUP_R",
                 .start = AB8500_INT_ID_WAKEUP_R,
@@ -580,9 +663,21 @@ static struct resource ab8500_usb_resources[] = {
                 .end = AB8500_INT_USB_LINK_STATUS,
                 .flags = IORESOURCE_IRQ,
         },
+        {
+                .name = "USB_ADP_PROBE_PLUG",
+                .start = AB8500_INT_ADP_PROBE_PLUG,
+                .end = AB8500_INT_ADP_PROBE_PLUG,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .name = "USB_ADP_PROBE_UNPLUG",
+                .start = AB8500_INT_ADP_PROBE_UNPLUG,
+                .end = AB8500_INT_ADP_PROBE_UNPLUG,
+                .flags = IORESOURCE_IRQ,
+        },
 };
 
-static struct resource ab8500_temp_resources[] = {
+static struct resource __devinitdata ab8500_temp_resources[] = {
         {
                 .name  = "AB8500_TEMP_WARM",
                 .start = AB8500_INT_TEMP_WARM,
@@ -591,7 +686,7 @@ static struct resource ab8500_temp_resources[] = {
         },
 };
 
-static struct mfd_cell ab8500_devs[] = {
+static struct mfd_cell __devinitdata ab8500_devs[] = {
 #ifdef CONFIG_DEBUG_FS
         {
                 .name = "ab8500-debug",
@@ -621,11 +716,33 @@ static struct mfd_cell ab8500_devs[] = {
                 .resources = ab8500_rtc_resources,
         },
         {
-                .name = "ab8500-bm",
-                .num_resources = ARRAY_SIZE(ab8500_bm_resources),
-                .resources = ab8500_bm_resources,
+                .name = "ab8500-charger",
+                .num_resources = ARRAY_SIZE(ab8500_charger_resources),
+                .resources = ab8500_charger_resources,
+        },
+        {
+                .name = "ab8500-btemp",
+                .num_resources = ARRAY_SIZE(ab8500_btemp_resources),
+                .resources = ab8500_btemp_resources,
+        },
+        {
+                .name = "ab8500-fg",
+                .num_resources = ARRAY_SIZE(ab8500_fg_resources),
+                .resources = ab8500_fg_resources,
+        },
+        {
+                .name = "ab8500-chargalg",
+                .num_resources = ARRAY_SIZE(ab8500_chargalg_resources),
+                .resources = ab8500_chargalg_resources,
+        },
+        {
+                .name = "ab8500-acc-det",
+                .num_resources = ARRAY_SIZE(ab8500_av_acc_detect_resources),
+                .resources = ab8500_av_acc_detect_resources,
+        },
+        {
+                .name = "ab8500-codec",
         },
-        { .name = "ab8500-codec", },
         {
                 .name = "ab8500-usb",
                 .num_resources = ARRAY_SIZE(ab8500_usb_resources),
diff --git a/drivers/mfd/ab8500-debugfs.c b/drivers/mfd/ab8500-debugfs.c
index 64748e42ac03..64bdeeb1c11a 100644
--- a/drivers/mfd/ab8500-debugfs.c
+++ b/drivers/mfd/ab8500-debugfs.c
@@ -419,20 +419,13 @@ static ssize_t ab8500_bank_write(struct file *file,
         size_t count, loff_t *ppos)
 {
         struct device *dev = ((struct seq_file *)(file->private_data))->private;
-        char buf[32];
-        int buf_size;
         unsigned long user_bank;
         int err;
 
         /* Get userspace string and assure termination */
-        buf_size = min(count, (sizeof(buf) - 1));
-        if (copy_from_user(buf, user_buf, buf_size))
-                return -EFAULT;
-        buf[buf_size] = 0;
-
-        err = strict_strtoul(buf, 0, &user_bank);
+        err = kstrtoul_from_user(user_buf, count, 0, &user_bank);
         if (err)
-                return -EINVAL;
+                return err;
 
         if (user_bank >= AB8500_NUM_BANKS) {
                 dev_err(dev, "debugfs error input > number of banks\n");
@@ -441,7 +434,7 @@ static ssize_t ab8500_bank_write(struct file *file,
 
         debug_bank = user_bank;
 
-        return buf_size;
+        return count;
 }
 
 static int ab8500_address_print(struct seq_file *s, void *p)
@@ -459,26 +452,20 @@ static ssize_t ab8500_address_write(struct file *file,
         size_t count, loff_t *ppos)
 {
         struct device *dev = ((struct seq_file *)(file->private_data))->private;
-        char buf[32];
-        int buf_size;
         unsigned long user_address;
         int err;
 
         /* Get userspace string and assure termination */
-        buf_size = min(count, (sizeof(buf) - 1));
-        if (copy_from_user(buf, user_buf, buf_size))
-                return -EFAULT;
-        buf[buf_size] = 0;
-
-        err = strict_strtoul(buf, 0, &user_address);
+        err = kstrtoul_from_user(user_buf, count, 0, &user_address);
         if (err)
-                return -EINVAL;
+                return err;
+
         if (user_address > 0xff) {
                 dev_err(dev, "debugfs error input > 0xff\n");
                 return -EINVAL;
         }
         debug_address = user_address;
-        return buf_size;
+        return count;
 }
 
 static int ab8500_val_print(struct seq_file *s, void *p)
@@ -509,20 +496,14 @@ static ssize_t ab8500_val_write(struct file *file,
         size_t count, loff_t *ppos)
 {
         struct device *dev = ((struct seq_file *)(file->private_data))->private;
-        char buf[32];
-        int buf_size;
         unsigned long user_val;
         int err;
 
         /* Get userspace string and assure termination */
-        buf_size = min(count, (sizeof(buf)-1));
-        if (copy_from_user(buf, user_buf, buf_size))
-                return -EFAULT;
-        buf[buf_size] = 0;
-
-        err = strict_strtoul(buf, 0, &user_val);
+        err = kstrtoul_from_user(user_buf, count, 0, &user_val);
         if (err)
-                return -EINVAL;
+                return err;
+
         if (user_val > 0xff) {
                 dev_err(dev, "debugfs error input > 0xff\n");
                 return -EINVAL;
@@ -534,7 +515,7 @@ static ssize_t ab8500_val_write(struct file *file,
                 return -EINVAL;
         }
 
-        return buf_size;
+        return count;
 }
 
 static const struct file_operations ab8500_bank_fops = {
diff --git a/drivers/mfd/jz4740-adc.c b/drivers/mfd/jz4740-adc.c
index a0bd0cf05af3..21131c7b0f1e 100644
--- a/drivers/mfd/jz4740-adc.c
+++ b/drivers/mfd/jz4740-adc.c
@@ -56,7 +56,7 @@ struct jz4740_adc {
         void __iomem *base;
 
         int irq;
-        int irq_base;
+        struct irq_chip_generic *gc;
 
         struct clk *clk;
         atomic_t clk_ref;
@@ -64,63 +64,17 @@ struct jz4740_adc {
         spinlock_t lock;
 };
 
-static inline void jz4740_adc_irq_set_masked(struct jz4740_adc *adc, int irq,
-        bool masked)
-{
-        unsigned long flags;
-        uint8_t val;
-
-        irq -= adc->irq_base;
-
-        spin_lock_irqsave(&adc->lock, flags);
-
-        val = readb(adc->base + JZ_REG_ADC_CTRL);
-        if (masked)
-                val |= BIT(irq);
-        else
-                val &= ~BIT(irq);
-        writeb(val, adc->base + JZ_REG_ADC_CTRL);
-
-        spin_unlock_irqrestore(&adc->lock, flags);
-}
-
-static void jz4740_adc_irq_mask(struct irq_data *data)
-{
-        struct jz4740_adc *adc = irq_data_get_irq_chip_data(data);
-        jz4740_adc_irq_set_masked(adc, data->irq, true);
-}
-
-static void jz4740_adc_irq_unmask(struct irq_data *data)
-{
-        struct jz4740_adc *adc = irq_data_get_irq_chip_data(data);
-        jz4740_adc_irq_set_masked(adc, data->irq, false);
-}
-
-static void jz4740_adc_irq_ack(struct irq_data *data)
-{
-        struct jz4740_adc *adc = irq_data_get_irq_chip_data(data);
-        unsigned int irq = data->irq - adc->irq_base;
-        writeb(BIT(irq), adc->base + JZ_REG_ADC_STATUS);
-}
-
-static struct irq_chip jz4740_adc_irq_chip = {
-        .name = "jz4740-adc",
-        .irq_mask = jz4740_adc_irq_mask,
-        .irq_unmask = jz4740_adc_irq_unmask,
-        .irq_ack = jz4740_adc_irq_ack,
-};
-
 static void jz4740_adc_irq_demux(unsigned int irq, struct irq_desc *desc)
 {
-        struct jz4740_adc *adc = irq_desc_get_handler_data(desc);
+        struct irq_chip_generic *gc = irq_desc_get_handler_data(desc);
         uint8_t status;
         unsigned int i;
 
-        status = readb(adc->base + JZ_REG_ADC_STATUS);
+        status = readb(gc->reg_base + JZ_REG_ADC_STATUS);
 
         for (i = 0; i < 5; ++i) {
                 if (status & BIT(i))
-                        generic_handle_irq(adc->irq_base + i);
+                        generic_handle_irq(gc->irq_base + i);
         }
 }
 
@@ -249,10 +203,12 @@ const struct mfd_cell jz4740_adc_cells[] = {
 
 static int __devinit jz4740_adc_probe(struct platform_device *pdev)
 {
-        int ret;
+        struct irq_chip_generic *gc;
+        struct irq_chip_type *ct;
         struct jz4740_adc *adc;
         struct resource *mem_base;
-        int irq;
+        int ret;
+        int irq_base;
 
         adc = kmalloc(sizeof(*adc), GFP_KERNEL);
         if (!adc) {
@@ -267,9 +223,9 @@ static int __devinit jz4740_adc_probe(struct platform_device *pdev)
                 goto err_free;
         }
 
-        adc->irq_base = platform_get_irq(pdev, 1);
-        if (adc->irq_base < 0) {
-                ret = adc->irq_base;
+        irq_base = platform_get_irq(pdev, 1);
+        if (irq_base < 0) {
+                ret = irq_base;
                 dev_err(&pdev->dev, "Failed to get irq base: %d\n", ret);
                 goto err_free;
         }
@@ -309,20 +265,28 @@ static int __devinit jz4740_adc_probe(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, adc);
 
-        for (irq = adc->irq_base; irq < adc->irq_base + 5; ++irq) {
-                irq_set_chip_data(irq, adc);
-                irq_set_chip_and_handler(irq, &jz4740_adc_irq_chip,
-                                         handle_level_irq);
-        }
+        gc = irq_alloc_generic_chip("INTC", 1, irq_base, adc->base,
+                handle_level_irq);
+
+        ct = gc->chip_types;
+        ct->regs.mask = JZ_REG_ADC_CTRL;
+        ct->regs.ack = JZ_REG_ADC_STATUS;
+        ct->chip.irq_mask = irq_gc_mask_set_bit;
+        ct->chip.irq_unmask = irq_gc_mask_clr_bit;
+        ct->chip.irq_ack = irq_gc_ack;
+
+        irq_setup_generic_chip(gc, IRQ_MSK(5), 0, 0, IRQ_NOPROBE | IRQ_LEVEL);
+
+        adc->gc = gc;
 
-        irq_set_handler_data(adc->irq, adc);
+        irq_set_handler_data(adc->irq, gc);
         irq_set_chained_handler(adc->irq, jz4740_adc_irq_demux);
 
         writeb(0x00, adc->base + JZ_REG_ADC_ENABLE);
         writeb(0xff, adc->base + JZ_REG_ADC_CTRL);
 
         ret = mfd_add_devices(&pdev->dev, 0, jz4740_adc_cells,
-                ARRAY_SIZE(jz4740_adc_cells), mem_base, adc->irq_base);
+                ARRAY_SIZE(jz4740_adc_cells), mem_base, irq_base);
         if (ret < 0)
                 goto err_clk_put;
 
@@ -347,6 +311,8 @@ static int __devexit jz4740_adc_remove(struct platform_device *pdev)
 
         mfd_remove_devices(&pdev->dev);
 
+        irq_remove_generic_chip(adc->gc, IRQ_MSK(5), IRQ_NOPROBE | IRQ_LEVEL, 0);
+        kfree(adc->gc);
         irq_set_handler_data(adc->irq, NULL);
         irq_set_chained_handler(adc->irq, NULL);
 
diff --git a/drivers/mfd/lpc_sch.c b/drivers/mfd/lpc_sch.c
index ea3f52c07ef7..ea1169b04779 100644
--- a/drivers/mfd/lpc_sch.c
+++ b/drivers/mfd/lpc_sch.c
@@ -37,6 +37,9 @@
 #define GPIOBASE        0x44
 #define GPIO_IO_SIZE    64
 
+#define WDTBASE         0x84
+#define WDT_IO_SIZE     64
+
 static struct resource smbus_sch_resource = {
                 .flags = IORESOURCE_IO,
 };
@@ -59,6 +62,18 @@ static struct mfd_cell lpc_sch_cells[] = {
         },
 };
 
+static struct resource wdt_sch_resource = {
+                .flags = IORESOURCE_IO,
+};
+
+static struct mfd_cell tunnelcreek_cells[] = {
+        {
+                .name = "tunnelcreek_wdt",
+                .num_resources = 1,
+                .resources = &wdt_sch_resource,
+        },
+};
+
 static struct pci_device_id lpc_sch_ids[] = {
         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_SCH_LPC) },
         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ITC_LPC) },
@@ -72,6 +87,7 @@ static int __devinit lpc_sch_probe(struct pci_dev *dev,
         unsigned int base_addr_cfg;
         unsigned short base_addr;
         int i;
+        int ret;
 
         pci_read_config_dword(dev, SMBASE, &base_addr_cfg);
         if (!(base_addr_cfg & (1 << 31))) {
@@ -104,8 +120,39 @@ static int __devinit lpc_sch_probe(struct pci_dev *dev,
         for (i=0; i < ARRAY_SIZE(lpc_sch_cells); i++)
                 lpc_sch_cells[i].id = id->device;
 
-        return mfd_add_devices(&dev->dev, 0,
+        ret = mfd_add_devices(&dev->dev, 0,
                         lpc_sch_cells, ARRAY_SIZE(lpc_sch_cells), NULL, 0);
+        if (ret)
+                goto out_dev;
+
+        if (id->device == PCI_DEVICE_ID_INTEL_ITC_LPC) {
+                pci_read_config_dword(dev, WDTBASE, &base_addr_cfg);
+                if (!(base_addr_cfg & (1 << 31))) {
+                        dev_err(&dev->dev, "Decode of the WDT I/O range disabled\n");
+                        ret = -ENODEV;
+                        goto out_dev;
+                }
+                base_addr = (unsigned short)base_addr_cfg;
+                if (base_addr == 0) {
+                        dev_err(&dev->dev, "I/O space for WDT uninitialized\n");
+                        ret = -ENODEV;
+                        goto out_dev;
+                }
+
+                wdt_sch_resource.start = base_addr;
+                wdt_sch_resource.end = base_addr + WDT_IO_SIZE - 1;
+
+                for (i = 0; i < ARRAY_SIZE(tunnelcreek_cells); i++)
+                        tunnelcreek_cells[i].id = id->device;
+
+                ret = mfd_add_devices(&dev->dev, 0, tunnelcreek_cells,
+                        ARRAY_SIZE(tunnelcreek_cells), NULL, 0);
+        }
+
+        return ret;
+out_dev:
+        mfd_remove_devices(&dev->dev);
+        return ret;
 }
 
 static void __devexit lpc_sch_remove(struct pci_dev *dev)
diff --git a/drivers/mfd/max8997-irq.c b/drivers/mfd/max8997-irq.c
index 638bf7e4d3b3..09274cf7c33b 100644
--- a/drivers/mfd/max8997-irq.c
+++ b/drivers/mfd/max8997-irq.c
@@ -58,8 +58,6 @@ static struct i2c_client *get_i2c(struct max8997_dev *max8997,
         default:
                 return ERR_PTR(-EINVAL);
         }
-
-        return ERR_PTR(-EINVAL);
 }
 
 struct max8997_irq_data {
diff --git a/drivers/mfd/max8998.c b/drivers/mfd/max8998.c
index 9ec7570f5b81..de4096aee248 100644
--- a/drivers/mfd/max8998.c
+++ b/drivers/mfd/max8998.c
@@ -39,6 +39,8 @@ static struct mfd_cell max8998_devs[] = {
                 .name = "max8998-pmic",
         }, {
                 .name = "max8998-rtc",
+        }, {
+                .name = "max8998-battery",
         },
 };
 
diff --git a/drivers/mfd/omap-usb-host.c b/drivers/mfd/omap-usb-host.c
index 1717144fe7f4..29601e7d606d 100644
--- a/drivers/mfd/omap-usb-host.c
+++ b/drivers/mfd/omap-usb-host.c
@@ -998,9 +998,9 @@ static void usbhs_disable(struct device *dev)
 
         if (is_omap_usbhs_rev2(omap)) {
                 if (is_ehci_tll_mode(pdata->port_mode[0]))
-                        clk_enable(omap->usbtll_p1_fck);
+                        clk_disable(omap->usbtll_p1_fck);
                 if (is_ehci_tll_mode(pdata->port_mode[1]))
-                        clk_enable(omap->usbtll_p2_fck);
+                        clk_disable(omap->usbtll_p2_fck);
                 clk_disable(omap->utmi_p2_fck);
                 clk_disable(omap->utmi_p1_fck);
         }
diff --git a/drivers/mfd/stmpe.c b/drivers/mfd/stmpe.c
index 7ab7746631d4..2963689cf45c 100644
--- a/drivers/mfd/stmpe.c
+++ b/drivers/mfd/stmpe.c
@@ -228,7 +228,7 @@ int stmpe_block_write(struct stmpe *stmpe, u8 reg, u8 length,
 EXPORT_SYMBOL_GPL(stmpe_block_write);
 
 /**
- * stmpe_set_altfunc: set the alternate function for STMPE pins
+ * stmpe_set_altfunc()- set the alternate function for STMPE pins
  * @stmpe:      Device to configure
  * @pins:       Bitmask of pins to affect
  * @block:      block to enable alternate functions for
diff --git a/drivers/mfd/stmpe.h b/drivers/mfd/stmpe.h
index 0dbdc4e8cd77..e4ee38956583 100644
--- a/drivers/mfd/stmpe.h
+++ b/drivers/mfd/stmpe.h
@@ -42,6 +42,7 @@ struct stmpe_variant_block {
  * @id_mask:    bits valid in CHIPID register for comparison with id_val
  * @num_gpios:  number of GPIOS
  * @af_bits:    number of bits used to specify the alternate function
+ * @regs: variant specific registers.
  * @blocks:     list of blocks present on this device
  * @num_blocks: number of blocks present on this device
  * @num_irqs:   number of internal IRQs available on this device
diff --git a/drivers/mfd/tps65910.c b/drivers/mfd/tps65910.c
index 2229e66d80db..6f5b8cf2f652 100644
--- a/drivers/mfd/tps65910.c
+++ b/drivers/mfd/tps65910.c
@@ -147,12 +147,11 @@ static int tps65910_i2c_probe(struct i2c_client *i2c,
         if (init_data == NULL)
                 return -ENOMEM;
 
-        init_data->irq = pmic_plat_data->irq;
-        init_data->irq_base = pmic_plat_data->irq;
-
         tps65910 = kzalloc(sizeof(struct tps65910), GFP_KERNEL);
-        if (tps65910 == NULL)
+        if (tps65910 == NULL) {
+                kfree(init_data);
                 return -ENOMEM;
+        }
 
         i2c_set_clientdata(i2c, tps65910);
         tps65910->dev = &i2c->dev;
@@ -168,17 +167,22 @@ static int tps65910_i2c_probe(struct i2c_client *i2c,
         if (ret < 0)
                 goto err;
 
+        init_data->irq = pmic_plat_data->irq;
+        init_data->irq_base = pmic_plat_data->irq;
+
         tps65910_gpio_init(tps65910, pmic_plat_data->gpio_base);
 
         ret = tps65910_irq_init(tps65910, init_data->irq, init_data);
         if (ret < 0)
                 goto err;
 
+        kfree(init_data);
         return ret;
 
 err:
         mfd_remove_devices(tps65910->dev);
         kfree(tps65910);
+        kfree(init_data);
         return ret;
 }
 
@@ -187,6 +191,7 @@ static int tps65910_i2c_remove(struct i2c_client *i2c)
         struct tps65910 *tps65910 = i2c_get_clientdata(i2c);
 
         mfd_remove_devices(tps65910->dev);
+        tps65910_irq_exit(tps65910);
         kfree(tps65910);
 
         return 0;
diff --git a/drivers/mfd/tps65911-comparator.c b/drivers/mfd/tps65911-comparator.c
index 283ac6759757..e7ff783aa31e 100644
--- a/drivers/mfd/tps65911-comparator.c
+++ b/drivers/mfd/tps65911-comparator.c
@@ -157,6 +157,8 @@ static __devexit int tps65911_comparator_remove(struct platform_device *pdev)
         struct tps65910 *tps65910;
 
         tps65910 = dev_get_drvdata(pdev->dev.parent);
+        device_remove_file(&pdev->dev, &dev_attr_comp2_threshold);
+        device_remove_file(&pdev->dev, &dev_attr_comp1_threshold);
 
         return 0;
 }
diff --git a/drivers/mfd/tps65912-core.c b/drivers/mfd/tps65912-core.c
new file mode 100644
index 000000000000..955bc00e4b20
--- /dev/null
+++ b/drivers/mfd/tps65912-core.c
@@ -0,0 +1,177 @@
+/*
+ * tps65912-core.c  --  TI TPS65912x
+ *
+ * Copyright 2011 Texas Instruments Inc.
+ *
+ * Author: Margarita Olaya Cabrera <magi@slimlogic.co.uk>
+ *
+ *  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 driver is based on wm8350 implementation.
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/gpio.h>
+#include <linux/mfd/core.h>
+#include <linux/mfd/tps65912.h>
+
+static struct mfd_cell tps65912s[] = {
+        {
+                .name = "tps65912-pmic",
+        },
+};
+
+int tps65912_set_bits(struct tps65912 *tps65912, u8 reg, u8 mask)
+{
+        u8 data;
+        int err;
+
+        mutex_lock(&tps65912->io_mutex);
+
+        err = tps65912->read(tps65912, reg, 1, &data);
+        if (err) {
+                dev_err(tps65912->dev, "Read from reg 0x%x failed\n", reg);
+                goto out;
+        }
+
+        data |= mask;
+        err = tps65912->write(tps65912, reg, 1, &data);
+        if (err)
+                dev_err(tps65912->dev, "Write to reg 0x%x failed\n", reg);
+
+out:
+        mutex_unlock(&tps65912->io_mutex);
+        return err;
+}
+EXPORT_SYMBOL_GPL(tps65912_set_bits);
+
+int tps65912_clear_bits(struct tps65912 *tps65912, u8 reg, u8 mask)
+{
+        u8 data;
+        int err;
+
+        mutex_lock(&tps65912->io_mutex);
+        err = tps65912->read(tps65912, reg, 1, &data);
+        if (err) {
+                dev_err(tps65912->dev, "Read from reg 0x%x failed\n", reg);
+                goto out;
+        }
+
+        data &= ~mask;
+        err = tps65912->write(tps65912, reg, 1, &data);
+        if (err)
+                dev_err(tps65912->dev, "Write to reg 0x%x failed\n", reg);
+
+out:
+        mutex_unlock(&tps65912->io_mutex);
+        return err;
+}
+EXPORT_SYMBOL_GPL(tps65912_clear_bits);
+
+static inline int tps65912_read(struct tps65912 *tps65912, u8 reg)
+{
+        u8 val;
+        int err;
+
+        err = tps65912->read(tps65912, reg, 1, &val);
+        if (err < 0)
+                return err;
+
+        return val;
+}
+
+static inline int tps65912_write(struct tps65912 *tps65912, u8 reg, u8 val)
+{
+        return tps65912->write(tps65912, reg, 1, &val);
+}
+
+int tps65912_reg_read(struct tps65912 *tps65912, u8 reg)
+{
+        int data;
+
+        mutex_lock(&tps65912->io_mutex);
+
+        data = tps65912_read(tps65912, reg);
+        if (data < 0)
+                dev_err(tps65912->dev, "Read from reg 0x%x failed\n", reg);
+
+        mutex_unlock(&tps65912->io_mutex);
+        return data;
+}
+EXPORT_SYMBOL_GPL(tps65912_reg_read);
+
+int tps65912_reg_write(struct tps65912 *tps65912, u8 reg, u8 val)
+{
+        int err;
+
+        mutex_lock(&tps65912->io_mutex);
+
+        err = tps65912_write(tps65912, reg, val);
+        if (err < 0)
+                dev_err(tps65912->dev, "Write for reg 0x%x failed\n", reg);
+
+        mutex_unlock(&tps65912->io_mutex);
+        return err;
+}
+EXPORT_SYMBOL_GPL(tps65912_reg_write);
+
+int tps65912_device_init(struct tps65912 *tps65912)
+{
+        struct tps65912_board *pmic_plat_data = tps65912->dev->platform_data;
+        struct tps65912_platform_data *init_data;
+        int ret, dcdc_avs, value;
+
+        init_data = kzalloc(sizeof(struct tps65912_platform_data), GFP_KERNEL);
+        if (init_data == NULL)
+                return -ENOMEM;
+
+        init_data->irq = pmic_plat_data->irq;
+        init_data->irq_base = pmic_plat_data->irq;
+
+        mutex_init(&tps65912->io_mutex);
+        dev_set_drvdata(tps65912->dev, tps65912);
+
+        dcdc_avs = (pmic_plat_data->is_dcdc1_avs << 0 |
+                        pmic_plat_data->is_dcdc2_avs  << 1 |
+                                pmic_plat_data->is_dcdc3_avs << 2 |
+                                        pmic_plat_data->is_dcdc4_avs << 3);
+        if (dcdc_avs) {
+                tps65912->read(tps65912, TPS65912_I2C_SPI_CFG, 1, &value);
+                dcdc_avs |= value;
+                tps65912->write(tps65912, TPS65912_I2C_SPI_CFG, 1, &dcdc_avs);
+        }
+
+        ret = mfd_add_devices(tps65912->dev, -1,
+                              tps65912s, ARRAY_SIZE(tps65912s),
+                              NULL, 0);
+        if (ret < 0)
+                goto err;
+
+        ret = tps65912_irq_init(tps65912, init_data->irq, init_data);
+        if (ret < 0)
+                goto err;
+
+        return ret;
+
+err:
+        kfree(init_data);
+        mfd_remove_devices(tps65912->dev);
+        kfree(tps65912);
+        return ret;
+}
+
+void tps65912_device_exit(struct tps65912 *tps65912)
+{
+        mfd_remove_devices(tps65912->dev);
+        kfree(tps65912);
+}
+
+MODULE_AUTHOR("Margarita Olaya  <magi@slimlogic.co.uk>");
+MODULE_DESCRIPTION("TPS65912x chip family multi-function driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/mfd/tps65912-i2c.c b/drivers/mfd/tps65912-i2c.c
new file mode 100644
index 000000000000..c041f2c3d2bd
--- /dev/null
+++ b/drivers/mfd/tps65912-i2c.c
@@ -0,0 +1,139 @@
+/*
+ * tps65912-i2c.c  --  I2C access for TI TPS65912x PMIC
+ *
+ * Copyright 2011 Texas Instruments Inc.
+ *
+ * Author: Margarita Olaya Cabrera <magi@slimlogic.co.uk>
+ *
+ *  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 driver is based on wm8350 implementation.
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/gpio.h>
+#include <linux/i2c.h>
+#include <linux/mfd/core.h>
+#include <linux/mfd/tps65912.h>
+
+static int tps65912_i2c_read(struct tps65912 *tps65912, u8 reg,
+                                  int bytes, void *dest)
+{
+        struct i2c_client *i2c = tps65912->control_data;
+        struct i2c_msg xfer[2];
+        int ret;
+
+        /* Write register */
+        xfer[0].addr = i2c->addr;
+        xfer[0].flags = 0;
+        xfer[0].len = 1;
+        xfer[0].buf = &reg;
+
+        /* Read data */
+        xfer[1].addr = i2c->addr;
+        xfer[1].flags = I2C_M_RD;
+        xfer[1].len = bytes;
+        xfer[1].buf = dest;
+
+        ret = i2c_transfer(i2c->adapter, xfer, 2);
+        if (ret == 2)
+                ret = 0;
+        else if (ret >= 0)
+                ret = -EIO;
+        return ret;
+}
+
+static int tps65912_i2c_write(struct tps65912 *tps65912, u8 reg,
+                                   int bytes, void *src)
+{
+        struct i2c_client *i2c = tps65912->control_data;
+        /* we add 1 byte for device register */
+        u8 msg[TPS6591X_MAX_REGISTER + 1];
+        int ret;
+
+        if (bytes > TPS6591X_MAX_REGISTER)
+                return -EINVAL;
+
+        msg[0] = reg;
+        memcpy(&msg[1], src, bytes);
+
+        ret = i2c_master_send(i2c, msg, bytes + 1);
+        if (ret < 0)
+                return ret;
+        if (ret != bytes + 1)
+                return -EIO;
+
+        return 0;
+}
+
+static int tps65912_i2c_probe(struct i2c_client *i2c,
+                            const struct i2c_device_id *id)
+{
+        struct tps65912 *tps65912;
+
+        tps65912 = kzalloc(sizeof(struct tps65912), GFP_KERNEL);
+        if (tps65912 == NULL)
+                return -ENOMEM;
+
+        i2c_set_clientdata(i2c, tps65912);
+        tps65912->dev = &i2c->dev;
+        tps65912->control_data = i2c;
+        tps65912->read = tps65912_i2c_read;
+        tps65912->write = tps65912_i2c_write;
+
+        return tps65912_device_init(tps65912);
+}
+
+static int tps65912_i2c_remove(struct i2c_client *i2c)
+{
+        struct tps65912 *tps65912 = i2c_get_clientdata(i2c);
+
+        tps65912_device_exit(tps65912);
+
+        return 0;
+}
+
+static const struct i2c_device_id tps65912_i2c_id[] = {
+        {"tps65912", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, tps65912_i2c_id);
+
+static struct i2c_driver tps65912_i2c_driver = {
+        .driver = {
+                   .name = "tps65912",
+                   .owner = THIS_MODULE,
+        },
+        .probe = tps65912_i2c_probe,
+        .remove = tps65912_i2c_remove,
+        .id_table = tps65912_i2c_id,
+};
+
+static int __init tps65912_i2c_init(void)
+{
+        int ret;
+
+        ret = i2c_add_driver(&tps65912_i2c_driver);
+        if (ret != 0)
+                pr_err("Failed to register TPS65912 I2C driver: %d\n", ret);
+
+        return ret;
+}
+/* init early so consumer devices can complete system boot */
+subsys_initcall(tps65912_i2c_init);
+
+static void __exit tps65912_i2c_exit(void)
+{
+        i2c_del_driver(&tps65912_i2c_driver);
+}
+module_exit(tps65912_i2c_exit);
+
+MODULE_AUTHOR("Margarita Olaya  <magi@slimlogic.co.uk>");
+MODULE_DESCRIPTION("TPS6591x chip family multi-function driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/mfd/tps65912-irq.c b/drivers/mfd/tps65912-irq.c
new file mode 100644
index 000000000000..d360a83a2738
--- /dev/null
+++ b/drivers/mfd/tps65912-irq.c
@@ -0,0 +1,224 @@
+/*
+ * tps65912-irq.c  --  TI TPS6591x
+ *
+ * Copyright 2011 Texas Instruments Inc.
+ *
+ * Author: Margarita Olaya <magi@slimlogic.co.uk>
+ *
+ *  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 driver is based on wm8350 implementation.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/bug.h>
+#include <linux/device.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+#include <linux/gpio.h>
+#include <linux/mfd/tps65912.h>
+
+static inline int irq_to_tps65912_irq(struct tps65912 *tps65912,
+                                                        int irq)
+{
+        return irq - tps65912->irq_base;
+}
+
+/*
+ * This is a threaded IRQ handler so can access I2C/SPI.  Since the
+ * IRQ handler explicitly clears the IRQ it handles the IRQ line
+ * will be reasserted and the physical IRQ will be handled again if
+ * another interrupt is asserted while we run - in the normal course
+ * of events this is a rare occurrence so we save I2C/SPI reads. We're
+ * also assuming that it's rare to get lots of interrupts firing
+ * simultaneously so try to minimise I/O.
+ */
+static irqreturn_t tps65912_irq(int irq, void *irq_data)
+{
+        struct tps65912 *tps65912 = irq_data;
+        u32 irq_sts;
+        u32 irq_mask;
+        u8 reg;
+        int i;
+
+
+        tps65912->read(tps65912, TPS65912_INT_STS, 1, &reg);
+        irq_sts = reg;
+        tps65912->read(tps65912, TPS65912_INT_STS2, 1, &reg);
+        irq_sts |= reg << 8;
+        tps65912->read(tps65912, TPS65912_INT_STS3, 1, &reg);
+        irq_sts |= reg << 16;
+        tps65912->read(tps65912, TPS65912_INT_STS4, 1, &reg);
+        irq_sts |= reg << 24;
+
+        tps65912->read(tps65912, TPS65912_INT_MSK, 1, &reg);
+        irq_mask = reg;
+        tps65912->read(tps65912, TPS65912_INT_MSK2, 1, &reg);
+        irq_mask |= reg << 8;
+        tps65912->read(tps65912, TPS65912_INT_MSK3, 1, &reg);
+        irq_mask |= reg << 16;
+        tps65912->read(tps65912, TPS65912_INT_MSK4, 1, &reg);
+        irq_mask |= reg << 24;
+
+        irq_sts &= ~irq_mask;
+        if (!irq_sts)
+                return IRQ_NONE;
+
+        for (i = 0; i < tps65912->irq_num; i++) {
+                if (!(irq_sts & (1 << i)))
+                        continue;
+
+                handle_nested_irq(tps65912->irq_base + i);
+        }
+
+        /* Write the STS register back to clear IRQs we handled */
+        reg = irq_sts & 0xFF;
+        irq_sts >>= 8;
+        if (reg)
+                tps65912->write(tps65912, TPS65912_INT_STS, 1, &reg);
+        reg = irq_sts & 0xFF;
+        irq_sts >>= 8;
+        if (reg)
+                tps65912->write(tps65912, TPS65912_INT_STS2, 1, &reg);
+        reg = irq_sts & 0xFF;
+        irq_sts >>= 8;
+        if (reg)
+                tps65912->write(tps65912, TPS65912_INT_STS3, 1, &reg);
+        reg = irq_sts & 0xFF;
+        if (reg)
+                tps65912->write(tps65912, TPS65912_INT_STS4, 1, &reg);
+
+        return IRQ_HANDLED;
+}
+
+static void tps65912_irq_lock(struct irq_data *data)
+{
+        struct tps65912 *tps65912 = irq_data_get_irq_chip_data(data);
+
+        mutex_lock(&tps65912->irq_lock);
+}
+
+static void tps65912_irq_sync_unlock(struct irq_data *data)
+{
+        struct tps65912 *tps65912 = irq_data_get_irq_chip_data(data);
+        u32 reg_mask;
+        u8 reg;
+
+        tps65912->read(tps65912, TPS65912_INT_MSK, 1, &reg);
+        reg_mask = reg;
+        tps65912->read(tps65912, TPS65912_INT_MSK2, 1, &reg);
+        reg_mask |= reg << 8;
+        tps65912->read(tps65912, TPS65912_INT_MSK3, 1, &reg);
+        reg_mask |= reg << 16;
+        tps65912->read(tps65912, TPS65912_INT_MSK4, 1, &reg);
+        reg_mask |= reg << 24;
+
+        if (tps65912->irq_mask != reg_mask) {
+                reg = tps65912->irq_mask & 0xFF;
+                tps65912->write(tps65912, TPS65912_INT_MSK, 1, &reg);
+                reg = tps65912->irq_mask >> 8 & 0xFF;
+                tps65912->write(tps65912, TPS65912_INT_MSK2, 1, &reg);
+                reg = tps65912->irq_mask >> 16 & 0xFF;
+                tps65912->write(tps65912, TPS65912_INT_MSK3, 1, &reg);
+                reg = tps65912->irq_mask >> 24 & 0xFF;
+                tps65912->write(tps65912, TPS65912_INT_MSK4, 1, &reg);
+        }
+
+        mutex_unlock(&tps65912->irq_lock);
+}
+
+static void tps65912_irq_enable(struct irq_data *data)
+{
+        struct tps65912 *tps65912 = irq_data_get_irq_chip_data(data);
+
+        tps65912->irq_mask &= ~(1 << irq_to_tps65912_irq(tps65912, data->irq));
+}
+
+static void tps65912_irq_disable(struct irq_data *data)
+{
+        struct tps65912 *tps65912 = irq_data_get_irq_chip_data(data);
+
+        tps65912->irq_mask |= (1 << irq_to_tps65912_irq(tps65912, data->irq));
+}
+
+static struct irq_chip tps65912_irq_chip = {
+        .name = "tps65912",
+        .irq_bus_lock = tps65912_irq_lock,
+        .irq_bus_sync_unlock = tps65912_irq_sync_unlock,
+        .irq_disable = tps65912_irq_disable,
+        .irq_enable = tps65912_irq_enable,
+};
+
+int tps65912_irq_init(struct tps65912 *tps65912, int irq,
+                            struct tps65912_platform_data *pdata)
+{
+        int ret, cur_irq;
+        int flags = IRQF_ONESHOT;
+        u8 reg;
+
+        if (!irq) {
+                dev_warn(tps65912->dev, "No interrupt support, no core IRQ\n");
+                return 0;
+        }
+
+        if (!pdata || !pdata->irq_base) {
+                dev_warn(tps65912->dev, "No interrupt support, no IRQ base\n");
+                return 0;
+        }
+
+        /* Clear unattended interrupts */
+        tps65912->read(tps65912, TPS65912_INT_STS, 1, &reg);
+        tps65912->write(tps65912, TPS65912_INT_STS, 1, &reg);
+        tps65912->read(tps65912, TPS65912_INT_STS2, 1, &reg);
+        tps65912->write(tps65912, TPS65912_INT_STS2, 1, &reg);
+        tps65912->read(tps65912, TPS65912_INT_STS3, 1, &reg);
+        tps65912->write(tps65912, TPS65912_INT_STS3, 1, &reg);
+        tps65912->read(tps65912, TPS65912_INT_STS4, 1, &reg);
+        tps65912->write(tps65912, TPS65912_INT_STS4, 1, &reg);
+
+        /* Mask top level interrupts */
+        tps65912->irq_mask = 0xFFFFFFFF;
+
+        mutex_init(&tps65912->irq_lock);
+        tps65912->chip_irq = irq;
+        tps65912->irq_base = pdata->irq_base;
+
+        tps65912->irq_num = TPS65912_NUM_IRQ;
+
+        /* Register with genirq */
+        for (cur_irq = tps65912->irq_base;
+             cur_irq < tps65912->irq_num + tps65912->irq_base;
+             cur_irq++) {
+                irq_set_chip_data(cur_irq, tps65912);
+                irq_set_chip_and_handler(cur_irq, &tps65912_irq_chip,
+                                         handle_edge_irq);
+                irq_set_nested_thread(cur_irq, 1);
+                /* ARM needs us to explicitly flag the IRQ as valid
+                 * and will set them noprobe when we do so. */
+#ifdef CONFIG_ARM
+                set_irq_flags(cur_irq, IRQF_VALID);
+#else
+                irq_set_noprobe(cur_irq);
+#endif
+        }
+
+        ret = request_threaded_irq(irq, NULL, tps65912_irq, flags,
+                                   "tps65912", tps65912);
+
+        irq_set_irq_type(irq, IRQ_TYPE_LEVEL_LOW);
+        if (ret != 0)
+                dev_err(tps65912->dev, "Failed to request IRQ: %d\n", ret);
+
+        return ret;
+}
+
+int tps65912_irq_exit(struct tps65912 *tps65912)
+{
+        free_irq(tps65912->chip_irq, tps65912);
+        return 0;
+}
diff --git a/drivers/mfd/tps65912-spi.c b/drivers/mfd/tps65912-spi.c
new file mode 100644
index 000000000000..6d71e0d25744
--- /dev/null
+++ b/drivers/mfd/tps65912-spi.c
@@ -0,0 +1,142 @@
+/*
+ * tps65912-spi.c  --  SPI access for TI TPS65912x PMIC
+ *
+ * Copyright 2011 Texas Instruments Inc.
+ *
+ * Author: Margarita Olaya Cabrera <magi@slimlogic.co.uk>
+ *
+ *  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 driver is based on wm8350 implementation.
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/gpio.h>
+#include <linux/spi/spi.h>
+#include <linux/mfd/core.h>
+#include <linux/mfd/tps65912.h>
+
+static int tps65912_spi_write(struct tps65912 *tps65912, u8 addr,
+                                                        int bytes, void *src)
+{
+        struct spi_device *spi = tps65912->control_data;
+        u8 *data = (u8 *) src;
+        int ret;
+        /* bit 23 is the read/write bit */
+        unsigned long spi_data = 1 << 23 | addr << 15 | *data;
+        struct spi_transfer xfer;
+        struct spi_message msg;
+        u32 tx_buf, rx_buf;
+
+        tx_buf = spi_data;
+        rx_buf = 0;
+
+        xfer.tx_buf     = &tx_buf;
+        xfer.rx_buf     = NULL;
+        xfer.len        = sizeof(unsigned long);
+        xfer.bits_per_word = 24;
+
+        spi_message_init(&msg);
+        spi_message_add_tail(&xfer, &msg);
+
+        ret = spi_sync(spi, &msg);
+        return ret;
+}
+
+static int tps65912_spi_read(struct tps65912 *tps65912, u8 addr,
+                                                        int bytes, void *dest)
+{
+        struct spi_device *spi = tps65912->control_data;
+        /* bit 23 is the read/write bit */
+        unsigned long spi_data = 0 << 23 | addr << 15;
+        struct spi_transfer xfer;
+        struct spi_message msg;
+        int ret;
+        u8 *data = (u8 *) dest;
+        u32 tx_buf, rx_buf;
+
+        tx_buf = spi_data;
+        rx_buf = 0;
+
+        xfer.tx_buf     = &tx_buf;
+        xfer.rx_buf     = &rx_buf;
+        xfer.len        = sizeof(unsigned long);
+        xfer.bits_per_word = 24;
+
+        spi_message_init(&msg);
+        spi_message_add_tail(&xfer, &msg);
+
+        if (spi == NULL)
+                return 0;
+
+        ret = spi_sync(spi, &msg);
+        if (ret == 0)
+                *data = (u8) (rx_buf & 0xFF);
+        return ret;
+}
+
+static int __devinit tps65912_spi_probe(struct spi_device *spi)
+{
+        struct tps65912 *tps65912;
+
+        tps65912 = kzalloc(sizeof(struct tps65912), GFP_KERNEL);
+        if (tps65912 == NULL)
+                return -ENOMEM;
+
+        tps65912->dev = &spi->dev;
+        tps65912->control_data = spi;
+        tps65912->read = tps65912_spi_read;
+        tps65912->write = tps65912_spi_write;
+
+        spi_set_drvdata(spi, tps65912);
+
+        return tps65912_device_init(tps65912);
+}
+
+static int __devexit tps65912_spi_remove(struct spi_device *spi)
+{
+        struct tps65912 *tps65912 = spi_get_drvdata(spi);
+
+        tps65912_device_exit(tps65912);
+
+        return 0;
+}
+
+static struct spi_driver tps65912_spi_driver = {
+        .driver = {
+                .name = "tps65912",
+                .bus = &spi_bus_type,
+                .owner = THIS_MODULE,
+        },
+        .probe  = tps65912_spi_probe,
+        .remove = __devexit_p(tps65912_spi_remove),
+};
+
+static int __init tps65912_spi_init(void)
+{
+        int ret;
+
+        ret = spi_register_driver(&tps65912_spi_driver);
+        if (ret != 0)
+                pr_err("Failed to register TPS65912 SPI driver: %d\n", ret);
+
+        return 0;
+}
+/* init early so consumer devices can complete system boot */
+subsys_initcall(tps65912_spi_init);
+
+static void __exit tps65912_spi_exit(void)
+{
+        spi_unregister_driver(&tps65912_spi_driver);
+}
+module_exit(tps65912_spi_exit);
+
+MODULE_AUTHOR("Margarita Olaya  <magi@slimlogic.co.uk>");
+MODULE_DESCRIPTION("SPI support for TPS65912 chip family mfd");
+MODULE_LICENSE("GPL");
diff --git a/drivers/mfd/twl-core.c b/drivers/mfd/twl-core.c
index a2eddc70995c..01ecfeee6524 100644
--- a/drivers/mfd/twl-core.c
+++ b/drivers/mfd/twl-core.c
@@ -1283,6 +1283,8 @@ static const struct i2c_device_id twl_ids[] = {
         { "tps65950", 0 },              /* catalog version of twl5030 */
         { "tps65930", TPS_SUBSET },     /* fewer LDOs and DACs; no charger */
         { "tps65920", TPS_SUBSET },     /* fewer LDOs; no codec or charger */
+        { "tps65921", TPS_SUBSET },     /* fewer LDOs; no codec, no LED
+                                           and vibrator. Charger in USB module*/
         { "twl6030", TWL6030_CLASS },   /* "Phoenix power chip" */
         { "twl6025", TWL6030_CLASS | TWL6025_SUBCLASS }, /* "Phoenix lite" */
         { /* end of list */ },
diff --git a/drivers/mfd/twl4030-madc.c b/drivers/mfd/twl4030-madc.c
index 3941ddcf15fe..b5d598c3aa71 100644
--- a/drivers/mfd/twl4030-madc.c
+++ b/drivers/mfd/twl4030-madc.c
@@ -530,13 +530,13 @@ int twl4030_madc_conversion(struct twl4030_madc_request *req)
         if (ret) {
                 dev_err(twl4030_madc->dev,
                         "unable to write sel register 0x%X\n", method->sel + 1);
-                return ret;
+                goto out;
         }
         ret = twl_i2c_write_u8(TWL4030_MODULE_MADC, ch_lsb, method->sel);
         if (ret) {
                 dev_err(twl4030_madc->dev,
                         "unable to write sel register 0x%X\n", method->sel + 1);
-                return ret;
+                goto out;
         }
         /* Select averaging for all channels if do_avg is set */
         if (req->do_avg) {
@@ -546,7 +546,7 @@ int twl4030_madc_conversion(struct twl4030_madc_request *req)
                         dev_err(twl4030_madc->dev,
                                 "unable to write avg register 0x%X\n",
                                 method->avg + 1);
-                        return ret;
+                        goto out;
                 }
                 ret = twl_i2c_write_u8(TWL4030_MODULE_MADC,
                                        ch_lsb, method->avg);
@@ -554,7 +554,7 @@ int twl4030_madc_conversion(struct twl4030_madc_request *req)
                         dev_err(twl4030_madc->dev,
                                 "unable to write sel reg 0x%X\n",
                                 method->sel + 1);
-                        return ret;
+                        goto out;
                 }
         }
         if (req->type == TWL4030_MADC_IRQ_ONESHOT && req->func_cb != NULL) {
diff --git a/drivers/mfd/twl6030-pwm.c b/drivers/mfd/twl6030-pwm.c
index 5d25bdc78424..e8fee147678d 100644
--- a/drivers/mfd/twl6030-pwm.c
+++ b/drivers/mfd/twl6030-pwm.c
@@ -161,3 +161,5 @@ void pwm_free(struct pwm_device *pwm)
         kfree(pwm);
 }
 EXPORT_SYMBOL(pwm_free);
+
+MODULE_LICENSE("GPL");
diff --git a/drivers/mfd/wm831x-auxadc.c b/drivers/mfd/wm831x-auxadc.c
new file mode 100644
index 000000000000..87210954a066
--- /dev/null
+++ b/drivers/mfd/wm831x-auxadc.c
@@ -0,0 +1,299 @@
+/*
+ * wm831x-auxadc.c  --  AUXADC for Wolfson WM831x PMICs
+ *
+ * Copyright 2009-2011 Wolfson Microelectronics PLC.
+ *
+ * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
+ *
+ *  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.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/mfd/core.h>
+#include <linux/slab.h>
+#include <linux/list.h>
+
+#include <linux/mfd/wm831x/core.h>
+#include <linux/mfd/wm831x/pdata.h>
+#include <linux/mfd/wm831x/irq.h>
+#include <linux/mfd/wm831x/auxadc.h>
+#include <linux/mfd/wm831x/otp.h>
+#include <linux/mfd/wm831x/regulator.h>
+
+struct wm831x_auxadc_req {
+        struct list_head list;
+        enum wm831x_auxadc input;
+        int val;
+        struct completion done;
+};
+
+static int wm831x_auxadc_read_irq(struct wm831x *wm831x,
+                                  enum wm831x_auxadc input)
+{
+        struct wm831x_auxadc_req *req;
+        int ret;
+        bool ena = false;
+
+        req = kzalloc(sizeof(*req), GFP_KERNEL);
+        if (!req)
+                return -ENOMEM;
+
+        init_completion(&req->done);
+        req->input = input;
+        req->val = -ETIMEDOUT;
+
+        mutex_lock(&wm831x->auxadc_lock);
+
+        /* Enqueue the request */
+        list_add(&req->list, &wm831x->auxadc_pending);
+
+        ena = !wm831x->auxadc_active;
+
+        if (ena) {
+                ret = wm831x_set_bits(wm831x, WM831X_AUXADC_CONTROL,
+                                      WM831X_AUX_ENA, WM831X_AUX_ENA);
+                if (ret != 0) {
+                        dev_err(wm831x->dev, "Failed to enable AUXADC: %d\n",
+                                ret);
+                        goto out;
+                }
+        }
+
+        /* Enable the conversion if not already running */
+        if (!(wm831x->auxadc_active & (1 << input))) {
+                ret = wm831x_set_bits(wm831x, WM831X_AUXADC_SOURCE,
+                                      1 << input, 1 << input);
+                if (ret != 0) {
+                        dev_err(wm831x->dev,
+                                "Failed to set AUXADC source: %d\n", ret);
+                        goto out;
+                }
+
+                wm831x->auxadc_active |= 1 << input;
+        }
+
+        /* We convert at the fastest rate possible */
+        if (ena) {
+                ret = wm831x_set_bits(wm831x, WM831X_AUXADC_CONTROL,
+                                      WM831X_AUX_CVT_ENA |
+                                      WM831X_AUX_RATE_MASK,
+                                      WM831X_AUX_CVT_ENA |
+                                      WM831X_AUX_RATE_MASK);
+                if (ret != 0) {
+                        dev_err(wm831x->dev, "Failed to start AUXADC: %d\n",
+                                ret);
+                        goto out;
+                }
+        }
+
+        mutex_unlock(&wm831x->auxadc_lock);
+
+        /* Wait for an interrupt */
+        wait_for_completion_timeout(&req->done, msecs_to_jiffies(500));
+
+        mutex_lock(&wm831x->auxadc_lock);
+
+        list_del(&req->list);
+        ret = req->val;
+
+out:
+        mutex_unlock(&wm831x->auxadc_lock);
+
+        kfree(req);
+
+        return ret;
+}
+
+static irqreturn_t wm831x_auxadc_irq(int irq, void *irq_data)
+{
+        struct wm831x *wm831x = irq_data;
+        struct wm831x_auxadc_req *req;
+        int ret, input, val;
+
+        ret = wm831x_reg_read(wm831x, WM831X_AUXADC_DATA);
+        if (ret < 0) {
+                dev_err(wm831x->dev,
+                        "Failed to read AUXADC data: %d\n", ret);
+                return IRQ_NONE;
+        }
+
+        input = ((ret & WM831X_AUX_DATA_SRC_MASK)
+                 >> WM831X_AUX_DATA_SRC_SHIFT) - 1;
+
+        if (input == 14)
+                input = WM831X_AUX_CAL;
+
+        val = ret & WM831X_AUX_DATA_MASK;
+
+        mutex_lock(&wm831x->auxadc_lock);
+
+        /* Disable this conversion, we're about to complete all users */
+        wm831x_set_bits(wm831x, WM831X_AUXADC_SOURCE,
+                        1 << input, 0);
+        wm831x->auxadc_active &= ~(1 << input);
+
+        /* Turn off the entire convertor if idle */
+        if (!wm831x->auxadc_active)
+                wm831x_reg_write(wm831x, WM831X_AUXADC_CONTROL, 0);
+
+        /* Wake up any threads waiting for this request */
+        list_for_each_entry(req, &wm831x->auxadc_pending, list) {
+                if (req->input == input) {
+                        req->val = val;
+                        complete(&req->done);
+                }
+        }
+
+        mutex_unlock(&wm831x->auxadc_lock);
+
+        return IRQ_HANDLED;
+}
+
+static int wm831x_auxadc_read_polled(struct wm831x *wm831x,
+                                     enum wm831x_auxadc input)
+{
+        int ret, src, timeout;
+
+        mutex_lock(&wm831x->auxadc_lock);
+
+        ret = wm831x_set_bits(wm831x, WM831X_AUXADC_CONTROL,
+                              WM831X_AUX_ENA, WM831X_AUX_ENA);
+        if (ret < 0) {
+                dev_err(wm831x->dev, "Failed to enable AUXADC: %d\n", ret);
+                goto out;
+        }
+
+        /* We force a single source at present */
+        src = input;
+        ret = wm831x_reg_write(wm831x, WM831X_AUXADC_SOURCE,
+                               1 << src);
+        if (ret < 0) {
+                dev_err(wm831x->dev, "Failed to set AUXADC source: %d\n", ret);
+                goto out;
+        }
+
+        ret = wm831x_set_bits(wm831x, WM831X_AUXADC_CONTROL,
+                              WM831X_AUX_CVT_ENA, WM831X_AUX_CVT_ENA);
+        if (ret < 0) {
+                dev_err(wm831x->dev, "Failed to start AUXADC: %d\n", ret);
+                goto disable;
+        }
+
+        /* If we're not using interrupts then poll the
+         * interrupt status register */
+        timeout = 5;
+        while (timeout) {
+                msleep(1);
+
+                ret = wm831x_reg_read(wm831x,
+                                      WM831X_INTERRUPT_STATUS_1);
+                if (ret < 0) {
+                        dev_err(wm831x->dev,
+                                "ISR 1 read failed: %d\n", ret);
+                        goto disable;
+                }
+
+                /* Did it complete? */
+                if (ret & WM831X_AUXADC_DATA_EINT) {
+                        wm831x_reg_write(wm831x,
+                                         WM831X_INTERRUPT_STATUS_1,
+                                         WM831X_AUXADC_DATA_EINT);
+                        break;
+                } else {
+                        dev_err(wm831x->dev,
+                                "AUXADC conversion timeout\n");
+                        ret = -EBUSY;
+                        goto disable;
+                }
+        }
+
+        ret = wm831x_reg_read(wm831x, WM831X_AUXADC_DATA);
+        if (ret < 0) {
+                dev_err(wm831x->dev,
+                        "Failed to read AUXADC data: %d\n", ret);
+                goto disable;
+        }
+
+        src = ((ret & WM831X_AUX_DATA_SRC_MASK)
+               >> WM831X_AUX_DATA_SRC_SHIFT) - 1;
+
+        if (src == 14)
+                src = WM831X_AUX_CAL;
+
+        if (src != input) {
+                dev_err(wm831x->dev, "Data from source %d not %d\n",
+                        src, input);
+                ret = -EINVAL;
+        } else {
+                ret &= WM831X_AUX_DATA_MASK;
+        }
+
+disable:
+        wm831x_set_bits(wm831x, WM831X_AUXADC_CONTROL, WM831X_AUX_ENA, 0);
+out:
+        mutex_unlock(&wm831x->auxadc_lock);
+        return ret;
+}
+
+/**
+ * wm831x_auxadc_read: Read a value from the WM831x AUXADC
+ *
+ * @wm831x: Device to read from.
+ * @input: AUXADC input to read.
+ */
+int wm831x_auxadc_read(struct wm831x *wm831x, enum wm831x_auxadc input)
+{
+        return wm831x->auxadc_read(wm831x, input);
+}
+EXPORT_SYMBOL_GPL(wm831x_auxadc_read);
+
+/**
+ * wm831x_auxadc_read_uv: Read a voltage from the WM831x AUXADC
+ *
+ * @wm831x: Device to read from.
+ * @input: AUXADC input to read.
+ */
+int wm831x_auxadc_read_uv(struct wm831x *wm831x, enum wm831x_auxadc input)
+{
+        int ret;
+
+        ret = wm831x_auxadc_read(wm831x, input);
+        if (ret < 0)
+                return ret;
+
+        ret *= 1465;
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(wm831x_auxadc_read_uv);
+
+void wm831x_auxadc_init(struct wm831x *wm831x)
+{
+        int ret;
+
+        mutex_init(&wm831x->auxadc_lock);
+        INIT_LIST_HEAD(&wm831x->auxadc_pending);
+
+        if (wm831x->irq && wm831x->irq_base) {
+                wm831x->auxadc_read = wm831x_auxadc_read_irq;
+
+                ret = request_threaded_irq(wm831x->irq_base +
+                                           WM831X_IRQ_AUXADC_DATA,
+                                           NULL, wm831x_auxadc_irq, 0,
+                                           "auxadc", wm831x);
+                if (ret < 0) {
+                        dev_err(wm831x->dev, "AUXADC IRQ request failed: %d\n",
+                                ret);
+                        wm831x->auxadc_read = NULL;
+                }
+        }
+
+        if (!wm831x->auxadc_read)
+                wm831x->auxadc_read = wm831x_auxadc_read_polled;
+}
diff --git a/drivers/mfd/wm831x-core.c b/drivers/mfd/wm831x-core.c
index 265f75fc6a25..282e76ab678f 100644
--- a/drivers/mfd/wm831x-core.c
+++ b/drivers/mfd/wm831x-core.c
@@ -295,7 +295,7 @@ int wm831x_set_bits(struct wm831x *wm831x, unsigned short reg,
                 goto out;
 
         r &= ~mask;
-        r |= val;
+        r |= val & mask;
 
         ret = wm831x_write(wm831x, reg, 2, &r);
 
@@ -306,146 +306,6 @@ out:
 }
 EXPORT_SYMBOL_GPL(wm831x_set_bits);
 
-/**
- * wm831x_auxadc_read: Read a value from the WM831x AUXADC
- *
- * @wm831x: Device to read from.
- * @input: AUXADC input to read.
- */
-int wm831x_auxadc_read(struct wm831x *wm831x, enum wm831x_auxadc input)
-{
-        int ret, src, irq_masked, timeout;
-
-        /* Are we using the interrupt? */
-        irq_masked = wm831x_reg_read(wm831x, WM831X_INTERRUPT_STATUS_1_MASK);
-        irq_masked &= WM831X_AUXADC_DATA_EINT;
-
-        mutex_lock(&wm831x->auxadc_lock);
-
-        ret = wm831x_set_bits(wm831x, WM831X_AUXADC_CONTROL,
-                              WM831X_AUX_ENA, WM831X_AUX_ENA);
-        if (ret < 0) {
-                dev_err(wm831x->dev, "Failed to enable AUXADC: %d\n", ret);
-                goto out;
-        }
-
-        /* We force a single source at present */
-        src = input;
-        ret = wm831x_reg_write(wm831x, WM831X_AUXADC_SOURCE,
-                               1 << src);
-        if (ret < 0) {
-                dev_err(wm831x->dev, "Failed to set AUXADC source: %d\n", ret);
-                goto out;
-        }
-
-        /* Clear any notification from a very late arriving interrupt */
-        try_wait_for_completion(&wm831x->auxadc_done);
-
-        ret = wm831x_set_bits(wm831x, WM831X_AUXADC_CONTROL,
-                              WM831X_AUX_CVT_ENA, WM831X_AUX_CVT_ENA);
-        if (ret < 0) {
-                dev_err(wm831x->dev, "Failed to start AUXADC: %d\n", ret);
-                goto disable;
-        }
-
-        if (irq_masked) {
-                /* If we're not using interrupts then poll the
-                 * interrupt status register */
-                timeout = 5;
-                while (timeout) {
-                        msleep(1);
-
-                        ret = wm831x_reg_read(wm831x,
-                                              WM831X_INTERRUPT_STATUS_1);
-                        if (ret < 0) {
-                                dev_err(wm831x->dev,
-                                        "ISR 1 read failed: %d\n", ret);
-                                goto disable;
-                        }
-
-                        /* Did it complete? */
-                        if (ret & WM831X_AUXADC_DATA_EINT) {
-                                wm831x_reg_write(wm831x,
-                                                 WM831X_INTERRUPT_STATUS_1,
-                                                 WM831X_AUXADC_DATA_EINT);
-                                break;
-                        } else {
-                                dev_err(wm831x->dev,
-                                        "AUXADC conversion timeout\n");
-                                ret = -EBUSY;
-                                goto disable;
-                        }
-                }
-        } else {
-                /* If we are using interrupts then wait for the
-                 * interrupt to complete.  Use an extremely long
-                 * timeout to handle situations with heavy load where
-                 * the notification of the interrupt may be delayed by
-                 * threaded IRQ handling. */
-                if (!wait_for_completion_timeout(&wm831x->auxadc_done,
-                                                 msecs_to_jiffies(500))) {
-                        dev_err(wm831x->dev, "Timed out waiting for AUXADC\n");
-                        ret = -EBUSY;
-                        goto disable;
-                }
-        }
-
-        ret = wm831x_reg_read(wm831x, WM831X_AUXADC_DATA);
-        if (ret < 0) {
-                dev_err(wm831x->dev, "Failed to read AUXADC data: %d\n", ret);
-        } else {
-                src = ((ret & WM831X_AUX_DATA_SRC_MASK)
-                       >> WM831X_AUX_DATA_SRC_SHIFT) - 1;
-
-                if (src == 14)
-                        src = WM831X_AUX_CAL;
-
-                if (src != input) {
-                        dev_err(wm831x->dev, "Data from source %d not %d\n",
-                                src, input);
-                        ret = -EINVAL;
-                } else {
-                        ret &= WM831X_AUX_DATA_MASK;
-                }
-        }
-
-disable:
-        wm831x_set_bits(wm831x, WM831X_AUXADC_CONTROL, WM831X_AUX_ENA, 0);
-out:
-        mutex_unlock(&wm831x->auxadc_lock);
-        return ret;
-}
-EXPORT_SYMBOL_GPL(wm831x_auxadc_read);
-
-static irqreturn_t wm831x_auxadc_irq(int irq, void *irq_data)
-{
-        struct wm831x *wm831x = irq_data;
-
-        complete(&wm831x->auxadc_done);
-
-        return IRQ_HANDLED;
-}
-
-/**
- * wm831x_auxadc_read_uv: Read a voltage from the WM831x AUXADC
- *
- * @wm831x: Device to read from.
- * @input: AUXADC input to read.
- */
-int wm831x_auxadc_read_uv(struct wm831x *wm831x, enum wm831x_auxadc input)
-{
-        int ret;
-
-        ret = wm831x_auxadc_read(wm831x, input);
-        if (ret < 0)
-                return ret;
-
-        ret *= 1465;
-
-        return ret;
-}
-EXPORT_SYMBOL_GPL(wm831x_auxadc_read_uv);
-
 static struct resource wm831x_dcdc1_resources[] = {
         {
                 .start = WM831X_DC1_CONTROL_1,
@@ -872,6 +732,9 @@ static struct mfd_cell wm8310_devs[] = {
                 .resources = wm831x_dcdc4_resources,
         },
         {
+                .name = "wm831x-clk",
+        },
+        {
                 .name = "wm831x-epe",
                 .id = 1,
         },
@@ -976,11 +839,6 @@ static struct mfd_cell wm8310_devs[] = {
                 .resources = wm831x_power_resources,
         },
         {
-                .name = "wm831x-rtc",
-                .num_resources = ARRAY_SIZE(wm831x_rtc_resources),
-                .resources = wm831x_rtc_resources,
-        },
-        {
                 .name = "wm831x-status",
                 .id = 1,
                 .num_resources = ARRAY_SIZE(wm831x_status1_resources),
@@ -1028,6 +886,9 @@ static struct mfd_cell wm8311_devs[] = {
                 .resources = wm831x_dcdc4_resources,
         },
         {
+                .name = "wm831x-clk",
+        },
+        {
                 .name = "wm831x-epe",
                 .id = 1,
         },
@@ -1108,11 +969,6 @@ static struct mfd_cell wm8311_devs[] = {
                 .resources = wm831x_power_resources,
         },
         {
-                .name = "wm831x-rtc",
-                .num_resources = ARRAY_SIZE(wm831x_rtc_resources),
-                .resources = wm831x_rtc_resources,
-        },
-        {
                 .name = "wm831x-status",
                 .id = 1,
                 .num_resources = ARRAY_SIZE(wm831x_status1_resources),
@@ -1125,11 +981,6 @@ static struct mfd_cell wm8311_devs[] = {
                 .resources = wm831x_status2_resources,
         },
         {
-                .name = "wm831x-touch",
-                .num_resources = ARRAY_SIZE(wm831x_touch_resources),
-                .resources = wm831x_touch_resources,
-        },
-        {
                 .name = "wm831x-watchdog",
                 .num_resources = ARRAY_SIZE(wm831x_wdt_resources),
                 .resources = wm831x_wdt_resources,
@@ -1165,6 +1016,9 @@ static struct mfd_cell wm8312_devs[] = {
                 .resources = wm831x_dcdc4_resources,
         },
         {
+                .name = "wm831x-clk",
+        },
+        {
                 .name = "wm831x-epe",
                 .id = 1,
         },
@@ -1269,11 +1123,6 @@ static struct mfd_cell wm8312_devs[] = {
                 .resources = wm831x_power_resources,
         },
         {
-                .name = "wm831x-rtc",
-                .num_resources = ARRAY_SIZE(wm831x_rtc_resources),
-                .resources = wm831x_rtc_resources,
-        },
-        {
                 .name = "wm831x-status",
                 .id = 1,
                 .num_resources = ARRAY_SIZE(wm831x_status1_resources),
@@ -1286,11 +1135,6 @@ static struct mfd_cell wm8312_devs[] = {
                 .resources = wm831x_status2_resources,
         },
         {
-                .name = "wm831x-touch",
-                .num_resources = ARRAY_SIZE(wm831x_touch_resources),
-                .resources = wm831x_touch_resources,
-        },
-        {
                 .name = "wm831x-watchdog",
                 .num_resources = ARRAY_SIZE(wm831x_wdt_resources),
                 .resources = wm831x_wdt_resources,
@@ -1326,6 +1170,9 @@ static struct mfd_cell wm8320_devs[] = {
                 .resources = wm8320_dcdc4_buck_resources,
         },
         {
+                .name = "wm831x-clk",
+        },
+        {
                 .name = "wm831x-gpio",
                 .num_resources = ARRAY_SIZE(wm831x_gpio_resources),
                 .resources = wm831x_gpio_resources,
@@ -1405,11 +1252,6 @@ static struct mfd_cell wm8320_devs[] = {
                 .resources = wm831x_on_resources,
         },
         {
-                .name = "wm831x-rtc",
-                .num_resources = ARRAY_SIZE(wm831x_rtc_resources),
-                .resources = wm831x_rtc_resources,
-        },
-        {
                 .name = "wm831x-status",
                 .id = 1,
                 .num_resources = ARRAY_SIZE(wm831x_status1_resources),
@@ -1428,6 +1270,22 @@ static struct mfd_cell wm8320_devs[] = {
         },
 };
 
+static struct mfd_cell touch_devs[] = {
+        {
+                .name = "wm831x-touch",
+                .num_resources = ARRAY_SIZE(wm831x_touch_resources),
+                .resources = wm831x_touch_resources,
+        },
+};
+
+static struct mfd_cell rtc_devs[] = {
+        {
+                .name = "wm831x-rtc",
+                .num_resources = ARRAY_SIZE(wm831x_rtc_resources),
+                .resources = wm831x_rtc_resources,
+        },
+};
+
 static struct mfd_cell backlight_devs[] = {
         {
                 .name = "wm831x-backlight",
@@ -1440,14 +1298,12 @@ static struct mfd_cell backlight_devs[] = {
 int wm831x_device_init(struct wm831x *wm831x, unsigned long id, int irq)
 {
         struct wm831x_pdata *pdata = wm831x->dev->platform_data;
-        int rev;
+        int rev, wm831x_num;
         enum wm831x_parent parent;
         int ret, i;
 
         mutex_init(&wm831x->io_lock);
         mutex_init(&wm831x->key_lock);
-        mutex_init(&wm831x->auxadc_lock);
-        init_completion(&wm831x->auxadc_done);
         dev_set_drvdata(wm831x->dev, wm831x);
 
         ret = wm831x_reg_read(wm831x, WM831X_PARENT_ID);
@@ -1592,45 +1448,51 @@ int wm831x_device_init(struct wm831x *wm831x, unsigned long id, int irq)
                 }
         }
 
+        /* Multiply by 10 as we have many subdevices of the same type */
+        if (pdata && pdata->wm831x_num)
+                wm831x_num = pdata->wm831x_num * 10;
+        else
+                wm831x_num = -1;
+
         ret = wm831x_irq_init(wm831x, irq);
         if (ret != 0)
                 goto err;
 
-        if (wm831x->irq_base) {
-                ret = request_threaded_irq(wm831x->irq_base +
-                                           WM831X_IRQ_AUXADC_DATA,
-                                           NULL, wm831x_auxadc_irq, 0,
-                                           "auxadc", wm831x);
-                if (ret < 0)
-                        dev_err(wm831x->dev, "AUXADC IRQ request failed: %d\n",
-                                ret);
-        }
+        wm831x_auxadc_init(wm831x);
 
         /* The core device is up, instantiate the subdevices. */
         switch (parent) {
         case WM8310:
-                ret = mfd_add_devices(wm831x->dev, -1,
+                ret = mfd_add_devices(wm831x->dev, wm831x_num,
                                       wm8310_devs, ARRAY_SIZE(wm8310_devs),
                                       NULL, wm831x->irq_base);
                 break;
 
         case WM8311:
-                ret = mfd_add_devices(wm831x->dev, -1,
+                ret = mfd_add_devices(wm831x->dev, wm831x_num,
                                       wm8311_devs, ARRAY_SIZE(wm8311_devs),
                                       NULL, wm831x->irq_base);
+                if (!pdata || !pdata->disable_touch)
+                        mfd_add_devices(wm831x->dev, wm831x_num,
+                                        touch_devs, ARRAY_SIZE(touch_devs),
+                                        NULL, wm831x->irq_base);
                 break;
 
         case WM8312:
-                ret = mfd_add_devices(wm831x->dev, -1,
+                ret = mfd_add_devices(wm831x->dev, wm831x_num,
                                       wm8312_devs, ARRAY_SIZE(wm8312_devs),
                                       NULL, wm831x->irq_base);
+                if (!pdata || !pdata->disable_touch)
+                        mfd_add_devices(wm831x->dev, wm831x_num,
+                                        touch_devs, ARRAY_SIZE(touch_devs),
+                                        NULL, wm831x->irq_base);
                 break;
 
         case WM8320:
         case WM8321:
         case WM8325:
         case WM8326:
-                ret = mfd_add_devices(wm831x->dev, -1,
+                ret = mfd_add_devices(wm831x->dev, wm831x_num,
                                       wm8320_devs, ARRAY_SIZE(wm8320_devs),
                                       NULL, wm831x->irq_base);
                 break;
@@ -1645,9 +1507,30 @@ int wm831x_device_init(struct wm831x *wm831x, unsigned long id, int irq)
                 goto err_irq;
         }
 
+        /* The RTC can only be used if the 32.768kHz crystal is
+         * enabled; this can't be controlled by software at runtime.
+         */
+        ret = wm831x_reg_read(wm831x, WM831X_CLOCK_CONTROL_2);
+        if (ret < 0) {
+                dev_err(wm831x->dev, "Failed to read clock status: %d\n", ret);
+                goto err_irq;
+        }
+
+        if (ret & WM831X_XTAL_ENA) {
+                ret = mfd_add_devices(wm831x->dev, wm831x_num,
+                                      rtc_devs, ARRAY_SIZE(rtc_devs),
+                                      NULL, wm831x->irq_base);
+                if (ret != 0) {
+                        dev_err(wm831x->dev, "Failed to add RTC: %d\n", ret);
+                        goto err_irq;
+                }
+        } else {
+                dev_info(wm831x->dev, "32.768kHz clock disabled, no RTC\n");
+        }
+
         if (pdata && pdata->backlight) {
                 /* Treat errors as non-critical */
-                ret = mfd_add_devices(wm831x->dev, -1, backlight_devs,
+                ret = mfd_add_devices(wm831x->dev, wm831x_num, backlight_devs,
                                       ARRAY_SIZE(backlight_devs), NULL,
                                       wm831x->irq_base);
                 if (ret < 0)
diff --git a/drivers/mfd/wm831x-irq.c b/drivers/mfd/wm831x-irq.c
index 42b928ec891e..ada1835a5455 100644
--- a/drivers/mfd/wm831x-irq.c
+++ b/drivers/mfd/wm831x-irq.c
@@ -348,6 +348,15 @@ static void wm831x_irq_sync_unlock(struct irq_data *data)
         struct wm831x *wm831x = irq_data_get_irq_chip_data(data);
         int i;
 
+        for (i = 0; i < ARRAY_SIZE(wm831x->gpio_update); i++) {
+                if (wm831x->gpio_update[i]) {
+                        wm831x_set_bits(wm831x, WM831X_GPIO1_CONTROL + i,
+                                        WM831X_GPN_INT_MODE | WM831X_GPN_POL,
+                                        wm831x->gpio_update[i]);
+                        wm831x->gpio_update[i] = 0;
+                }
+        }
+
         for (i = 0; i < ARRAY_SIZE(wm831x->irq_masks_cur); i++) {
                 /* If there's been a change in the mask write it back
                  * to the hardware. */
@@ -387,7 +396,7 @@ static void wm831x_irq_disable(struct irq_data *data)
 static int wm831x_irq_set_type(struct irq_data *data, unsigned int type)
 {
         struct wm831x *wm831x = irq_data_get_irq_chip_data(data);
-        int val, irq;
+        int irq;
 
         irq = data->irq - wm831x->irq_base;
 
@@ -399,22 +408,30 @@ static int wm831x_irq_set_type(struct irq_data *data, unsigned int type)
                         return -EINVAL;
         }
 
+        /* Rebase the IRQ into the GPIO range so we've got a sensible array
+         * index.
+         */
+        irq -= WM831X_IRQ_GPIO_1;
+
+        /* We set the high bit to flag that we need an update; don't
+         * do the update here as we can be called with the bus lock
+         * held.
+         */
         switch (type) {
         case IRQ_TYPE_EDGE_BOTH:
-                val = WM831X_GPN_INT_MODE;
+                wm831x->gpio_update[irq] = 0x10000 | WM831X_GPN_INT_MODE;
                 break;
         case IRQ_TYPE_EDGE_RISING:
-                val = WM831X_GPN_POL;
+                wm831x->gpio_update[irq] = 0x10000 | WM831X_GPN_POL;
                 break;
         case IRQ_TYPE_EDGE_FALLING:
-                val = 0;
+                wm831x->gpio_update[irq] = 0x10000;
                 break;
         default:
                 return -EINVAL;
         }
 
-        return wm831x_set_bits(wm831x, WM831X_GPIO1_CONTROL + irq,
-                               WM831X_GPN_INT_MODE | WM831X_GPN_POL, val);
+        return 0;
 }
 
 static struct irq_chip wm831x_irq_chip = {
@@ -432,7 +449,7 @@ static irqreturn_t wm831x_irq_thread(int irq, void *data)
 {
         struct wm831x *wm831x = data;
         unsigned int i;
-        int primary;
+        int primary, status_addr;
         int status_regs[WM831X_NUM_IRQ_REGS] = { 0 };
         int read[WM831X_NUM_IRQ_REGS] = { 0 };
         int *status;
@@ -467,8 +484,9 @@ static irqreturn_t wm831x_irq_thread(int irq, void *data)
                 /* Hopefully there should only be one register to read
                  * each time otherwise we ought to do a block read. */
                 if (!read[offset]) {
-                        *status = wm831x_reg_read(wm831x,
-                                     irq_data_to_status_reg(&wm831x_irqs[i]));
+                        status_addr = irq_data_to_status_reg(&wm831x_irqs[i]);
+
+                        *status = wm831x_reg_read(wm831x, status_addr);
                         if (*status < 0) {
                                 dev_err(wm831x->dev,
                                         "Failed to read IRQ status: %d\n",
@@ -477,26 +495,21 @@ static irqreturn_t wm831x_irq_thread(int irq, void *data)
                         }
 
                         read[offset] = 1;
+
+                        /* Ignore any bits that we don't think are masked */
+                        *status &= ~wm831x->irq_masks_cur[offset];
+
+                        /* Acknowledge now so we don't miss
+                         * notifications while we handle.
+                         */
+                        wm831x_reg_write(wm831x, status_addr, *status);
                 }
 
-                /* Report it if it isn't masked, or forget the status. */
-                if ((*status & ~wm831x->irq_masks_cur[offset])
-                    & wm831x_irqs[i].mask)
+                if (*status & wm831x_irqs[i].mask)
                         handle_nested_irq(wm831x->irq_base + i);
-                else
-                        *status &= ~wm831x_irqs[i].mask;
         }
 
 out:
-        /* Touchscreen interrupts are handled specially in the driver */
-        status_regs[0] &= ~(WM831X_TCHDATA_EINT | WM831X_TCHPD_EINT);
-
-        for (i = 0; i < ARRAY_SIZE(status_regs); i++) {
-                if (status_regs[i])
-                        wm831x_reg_write(wm831x, WM831X_INTERRUPT_STATUS_1 + i,
-                                         status_regs[i]);
-        }
-
         return IRQ_HANDLED;
 }
 
@@ -515,13 +528,22 @@ int wm831x_irq_init(struct wm831x *wm831x, int irq)
                                  0xffff);
         }
 
-        if (!pdata || !pdata->irq_base) {
-                dev_err(wm831x->dev,
-                        "No interrupt base specified, no interrupts\n");
+        /* Try to dynamically allocate IRQs if no base is specified */
+        if (!pdata || !pdata->irq_base)
+                wm831x->irq_base = -1;
+        else
+                wm831x->irq_base = pdata->irq_base;
+
+        wm831x->irq_base = irq_alloc_descs(wm831x->irq_base, 0,
+                                           WM831X_NUM_IRQS, 0);
+        if (wm831x->irq_base < 0) {
+                dev_warn(wm831x->dev, "Failed to allocate IRQs: %d\n",
+                         wm831x->irq_base);
+                wm831x->irq_base = 0;
                 return 0;
         }
 
-        if (pdata->irq_cmos)
+        if (pdata && pdata->irq_cmos)
                 i = 0;
         else
                 i = WM831X_IRQ_OD;
@@ -541,7 +563,6 @@ int wm831x_irq_init(struct wm831x *wm831x, int irq)
         }
 
         wm831x->irq = irq;
-        wm831x->irq_base = pdata->irq_base;
 
         /* Register them with genirq */
         for (cur_irq = wm831x->irq_base;
diff --git a/drivers/mfd/wm8350-irq.c b/drivers/mfd/wm8350-irq.c
index ed4b22a167b3..8a1fafd0bf7d 100644
--- a/drivers/mfd/wm8350-irq.c
+++ b/drivers/mfd/wm8350-irq.c
@@ -473,17 +473,13 @@ int wm8350_irq_init(struct wm8350 *wm8350, int irq,
 {
         int ret, cur_irq, i;
         int flags = IRQF_ONESHOT;
+        int irq_base = -1;
 
         if (!irq) {
                 dev_warn(wm8350->dev, "No interrupt support, no core IRQ\n");
                 return 0;
         }
 
-        if (!pdata || !pdata->irq_base) {
-                dev_warn(wm8350->dev, "No interrupt support, no IRQ base\n");
-                return 0;
-        }
-
         /* Mask top level interrupts */
         wm8350_reg_write(wm8350, WM8350_SYSTEM_INTERRUPTS_MASK, 0xFFFF);
 
@@ -502,7 +498,17 @@ int wm8350_irq_init(struct wm8350 *wm8350, int irq,
         wm8350->chip_irq = irq;
         wm8350->irq_base = pdata->irq_base;
 
-        if (pdata->irq_high) {
+        if (pdata && pdata->irq_base > 0)
+                irq_base = pdata->irq_base;
+
+        wm8350->irq_base = irq_alloc_descs(irq_base, 0, ARRAY_SIZE(wm8350_irqs), 0);
+        if (wm8350->irq_base < 0) {
+                dev_warn(wm8350->dev, "Allocating irqs failed with %d\n",
+                        wm8350->irq_base);
+                return 0;
+        }
+
+        if (pdata && pdata->irq_high) {
                 flags |= IRQF_TRIGGER_HIGH;
 
                 wm8350_set_bits(wm8350, WM8350_SYSTEM_CONTROL_1,
diff --git a/drivers/mfd/wm8994-core.c b/drivers/mfd/wm8994-core.c
index e198d40292e7..96479c9b1728 100644
--- a/drivers/mfd/wm8994-core.c
+++ b/drivers/mfd/wm8994-core.c
@@ -316,7 +316,7 @@ static int wm8994_suspend(struct device *dev)
 static int wm8994_resume(struct device *dev)
 {
         struct wm8994 *wm8994 = dev_get_drvdata(dev);
-        int ret;
+        int ret, i;
 
         /* We may have lied to the PM core about suspending */
         if (!wm8994->suspended)
@@ -329,10 +329,16 @@ static int wm8994_resume(struct device *dev)
                 return ret;
         }
 
-        ret = wm8994_write(wm8994, WM8994_INTERRUPT_STATUS_1_MASK,
-                           WM8994_NUM_IRQ_REGS * 2, &wm8994->irq_masks_cur);
-        if (ret < 0)
-                dev_err(dev, "Failed to restore interrupt masks: %d\n", ret);
+        /* Write register at a time as we use the cache on the CPU so store
+         * it in native endian.
+         */
+        for (i = 0; i < ARRAY_SIZE(wm8994->irq_masks_cur); i++) {
+                ret = wm8994_reg_write(wm8994, WM8994_INTERRUPT_STATUS_1_MASK
+                                       + i, wm8994->irq_masks_cur[i]);
+                if (ret < 0)
+                        dev_err(dev, "Failed to restore interrupt masks: %d\n",
+                                ret);
+        }
 
         ret = wm8994_write(wm8994, WM8994_LDO_1, WM8994_NUM_LDO_REGS * 2,
                            &wm8994->ldo_regs);
@@ -403,7 +409,7 @@ static int wm8994_device_init(struct wm8994 *wm8994, int irq)
                 break;
         default:
                 BUG();
-                return -EINVAL;
+                goto err;
         }
 
         wm8994->supplies = kzalloc(sizeof(struct regulator_bulk_data) *
@@ -425,7 +431,7 @@ static int wm8994_device_init(struct wm8994 *wm8994, int irq)
                 break;
         default:
                 BUG();
-                return -EINVAL;
+                goto err;
         }
                 
         ret = regulator_bulk_get(wm8994->dev, wm8994->num_supplies,
@@ -476,13 +482,18 @@ static int wm8994_device_init(struct wm8994 *wm8994, int irq)
                 goto err_enable;
         }
 
-        switch (ret) {
-        case 0:
-        case 1:
-                if (wm8994->type == WM8994)
+        switch (wm8994->type) {
+        case WM8994:
+                switch (ret) {
+                case 0:
+                case 1:
                         dev_warn(wm8994->dev,
                                  "revision %c not fully supported\n",
                                  'A' + ret);
+                        break;
+                default:
+                        break;
+                }
                 break;
         default:
                 break;
diff --git a/drivers/mfd/wm8994-irq.c b/drivers/mfd/wm8994-irq.c
index 71c6e8f9aedb..d682f7bd112c 100644
--- a/drivers/mfd/wm8994-irq.c
+++ b/drivers/mfd/wm8994-irq.c
@@ -231,12 +231,6 @@ static irqreturn_t wm8994_irq_thread(int irq, void *data)
                 status[i] &= ~wm8994->irq_masks_cur[i];
         }
 
-        /* Report */
-        for (i = 0; i < ARRAY_SIZE(wm8994_irqs); i++) {
-                if (status[wm8994_irqs[i].reg - 1] & wm8994_irqs[i].mask)
-                        handle_nested_irq(wm8994->irq_base + i);
-        }
-
         /* Ack any unmasked IRQs */
         for (i = 0; i < ARRAY_SIZE(status); i++) {
                 if (status[i])
@@ -244,6 +238,12 @@ static irqreturn_t wm8994_irq_thread(int irq, void *data)
                                          status[i]);
         }
 
+        /* Report */
+        for (i = 0; i < ARRAY_SIZE(wm8994_irqs); i++) {
+                if (status[wm8994_irqs[i].reg - 1] & wm8994_irqs[i].mask)
+                        handle_nested_irq(wm8994->irq_base + i);
+        }
+
         return IRQ_HANDLED;
 }
 
diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig
index 0a4d86c6c4a4..2d6423c2d193 100644
--- a/drivers/misc/Kconfig
+++ b/drivers/misc/Kconfig
@@ -146,6 +146,7 @@ config PHANTOM
 
 config INTEL_MID_PTI
         tristate "Parallel Trace Interface for MIPI P1149.7 cJTAG standard"
+        depends on PCI
         default n
         help
           The PTI (Parallel Trace Interface) driver directs
diff --git a/drivers/misc/ab8500-pwm.c b/drivers/misc/ab8500-pwm.c
index 54e3d05b63cc..35903154ca2e 100644
--- a/drivers/misc/ab8500-pwm.c
+++ b/drivers/misc/ab8500-pwm.c
@@ -164,5 +164,5 @@ subsys_initcall(ab8500_pwm_init);
 module_exit(ab8500_pwm_exit);
 MODULE_AUTHOR("Arun MURTHY <arun.murthy@stericsson.com>");
 MODULE_DESCRIPTION("AB8500 Pulse Width Modulation Driver");
-MODULE_ALIAS("AB8500 PWM driver");
+MODULE_ALIAS("platform:ab8500-pwm");
 MODULE_LICENSE("GPL v2");
diff --git a/drivers/misc/cb710/core.c b/drivers/misc/cb710/core.c
index efec4139c3f6..68cd05b6d829 100644
--- a/drivers/misc/cb710/core.c
+++ b/drivers/misc/cb710/core.c
@@ -33,7 +33,7 @@ EXPORT_SYMBOL_GPL(cb710_pci_update_config_reg);
 static int __devinit cb710_pci_configure(struct pci_dev *pdev)
 {
         unsigned int devfn = PCI_DEVFN(PCI_SLOT(pdev->devfn), 0);
-        struct pci_dev *pdev0 = pci_get_slot(pdev->bus, devfn);
+        struct pci_dev *pdev0;
         u32 val;
 
         cb710_pci_update_config_reg(pdev, 0x48,
@@ -43,6 +43,7 @@ static int __devinit cb710_pci_configure(struct pci_dev *pdev)
         if (val & 0x80000000)
                 return 0;
 
+        pdev0 = pci_get_slot(pdev->bus, devfn);
         if (!pdev0)
                 return -ENODEV;
 
diff --git a/drivers/misc/fsa9480.c b/drivers/misc/fsa9480.c
index 5325a7e70dcf..27dc0d21aafa 100644
--- a/drivers/misc/fsa9480.c
+++ b/drivers/misc/fsa9480.c
@@ -455,7 +455,7 @@ static int __devinit fsa9480_probe(struct i2c_client *client,
 
 fail2:
         if (client->irq)
-                free_irq(client->irq, NULL);
+                free_irq(client->irq, usbsw);
 fail1:
         i2c_set_clientdata(client, NULL);
         kfree(usbsw);
@@ -466,7 +466,7 @@ static int __devexit fsa9480_remove(struct i2c_client *client)
 {
         struct fsa9480_usbsw *usbsw = i2c_get_clientdata(client);
         if (client->irq)
-                free_irq(client->irq, NULL);
+                free_irq(client->irq, usbsw);
         i2c_set_clientdata(client, NULL);
 
         sysfs_remove_group(&client->dev.kobj, &fsa9480_group);
diff --git a/drivers/misc/pti.c b/drivers/misc/pti.c
index 8653bd0b1a33..06df1877ad0f 100644
--- a/drivers/misc/pti.c
+++ b/drivers/misc/pti.c
@@ -33,6 +33,8 @@
 #include <linux/mutex.h>
 #include <linux/miscdevice.h>
 #include <linux/pti.h>
+#include <linux/slab.h>
+#include <linux/uaccess.h>
 
 #define DRIVERNAME              "pti"
 #define PCINAME                 "pciPTI"
diff --git a/drivers/misc/ti-st/st_core.c b/drivers/misc/ti-st/st_core.c
index 54c91ffe4a91..ba168a7d54d4 100644
--- a/drivers/misc/ti-st/st_core.c
+++ b/drivers/misc/ti-st/st_core.c
@@ -338,6 +338,12 @@ void st_int_recv(void *disc_data,
                         /* Unknow packet? */
                 default:
                         type = *ptr;
+                        if (st_gdata->list[type] == NULL) {
+                                pr_err("chip/interface misbehavior dropping"
+                                        " frame starting with 0x%02x", type);
+                                goto done;
+
+                        }
                         st_gdata->rx_skb = alloc_skb(
                                         st_gdata->list[type]->max_frame_size,
                                         GFP_ATOMIC);
@@ -354,6 +360,7 @@ void st_int_recv(void *disc_data,
                 ptr++;
                 count--;
         }
+done:
         spin_unlock_irqrestore(&st_gdata->lock, flags);
         pr_debug("done %s", __func__);
         return;
@@ -717,9 +724,10 @@ static void st_tty_close(struct tty_struct *tty)
          */
         spin_lock_irqsave(&st_gdata->lock, flags);
         for (i = ST_BT; i < ST_MAX_CHANNELS; i++) {
-                if (st_gdata->list[i] != NULL)
+                if (st_gdata->is_registered[i] == true)
                         pr_err("%d not un-registered", i);
                 st_gdata->list[i] = NULL;
+                st_gdata->is_registered[i] = false;
         }
         st_gdata->protos_registered = 0;
         spin_unlock_irqrestore(&st_gdata->lock, flags);
diff --git a/drivers/misc/ti-st/st_kim.c b/drivers/misc/ti-st/st_kim.c
index 38fd2f04c07e..3a3580566dfc 100644
--- a/drivers/misc/ti-st/st_kim.c
+++ b/drivers/misc/ti-st/st_kim.c
@@ -68,6 +68,7 @@ void validate_firmware_response(struct kim_data_s *kim_gdata)
         if (unlikely(skb->data[5] != 0)) {
                 pr_err("no proper response during fw download");
                 pr_err("data6 %x", skb->data[5]);
+                kfree_skb(skb);
                 return;         /* keep waiting for the proper response */
         }
         /* becos of all the script being downloaded */
@@ -210,6 +211,7 @@ static long read_local_version(struct kim_data_s *kim_gdata, char *bts_scr_name)
                 pr_err(" waiting for ver info- timed out ");
                 return -ETIMEDOUT;
         }
+        INIT_COMPLETION(kim_gdata->kim_rcvd);
 
         version =
                 MAKEWORD(kim_gdata->resp_buffer[13],
@@ -298,6 +300,7 @@ static long download_firmware(struct kim_data_s *kim_gdata)
 
                 switch (((struct bts_action *)ptr)->type) {
                 case ACTION_SEND_COMMAND:       /* action send */
+                        pr_debug("S");
                         action_ptr = &(((struct bts_action *)ptr)->data[0]);
                         if (unlikely
                             (((struct hci_command *)action_ptr)->opcode ==
@@ -335,6 +338,10 @@ static long download_firmware(struct kim_data_s *kim_gdata)
                                 release_firmware(kim_gdata->fw_entry);
                                 return -ETIMEDOUT;
                         }
+                        /* reinit completion before sending for the
+                         * relevant wait
+                         */
+                        INIT_COMPLETION(kim_gdata->kim_rcvd);
 
                         /*
                          * Free space found in uart buffer, call st_int_write
@@ -361,6 +368,7 @@ static long download_firmware(struct kim_data_s *kim_gdata)
                         }
                         break;
                 case ACTION_WAIT_EVENT:  /* wait */
+                        pr_debug("W");
                         if (!wait_for_completion_timeout
                                         (&kim_gdata->kim_rcvd,
                                          msecs_to_jiffies(CMD_RESP_TIME))) {
@@ -434,11 +442,17 @@ long st_kim_start(void *kim_data)
 {
         long err = 0;
         long retry = POR_RETRY_COUNT;
+        struct ti_st_plat_data  *pdata;
         struct kim_data_s       *kim_gdata = (struct kim_data_s *)kim_data;
 
         pr_info(" %s", __func__);
+        pdata = kim_gdata->kim_pdev->dev.platform_data;
 
         do {
+                /* platform specific enabling code here */
+                if (pdata->chip_enable)
+                        pdata->chip_enable(kim_gdata);
+
                 /* Configure BT nShutdown to HIGH state */
                 gpio_set_value(kim_gdata->nshutdown, GPIO_LOW);
                 mdelay(5);      /* FIXME: a proper toggle */
@@ -460,6 +474,12 @@ long st_kim_start(void *kim_data)
                         pr_info("ldisc_install = 0");
                         sysfs_notify(&kim_gdata->kim_pdev->dev.kobj,
                                         NULL, "install");
+                        /* the following wait is never going to be completed,
+                         * since the ldisc was never installed, hence serving
+                         * as a mdelay of LDISC_TIME msecs */
+                        err = wait_for_completion_timeout
+                                (&kim_gdata->ldisc_installed,
+                                 msecs_to_jiffies(LDISC_TIME));
                         err = -ETIMEDOUT;
                         continue;
                 } else {
@@ -472,6 +492,13 @@ long st_kim_start(void *kim_data)
                                 pr_info("ldisc_install = 0");
                                 sysfs_notify(&kim_gdata->kim_pdev->dev.kobj,
                                                 NULL, "install");
+                                /* this wait might be completed, though in the
+                                 * tty_close() since the ldisc is already
+                                 * installed */
+                                err = wait_for_completion_timeout
+                                        (&kim_gdata->ldisc_installed,
+                                         msecs_to_jiffies(LDISC_TIME));
+                                err = -EINVAL;
                                 continue;
                         } else {        /* on success don't retry */
                                 break;
@@ -489,6 +516,8 @@ long st_kim_stop(void *kim_data)
 {
         long err = 0;
         struct kim_data_s       *kim_gdata = (struct kim_data_s *)kim_data;
+        struct ti_st_plat_data  *pdata =
+                kim_gdata->kim_pdev->dev.platform_data;
 
         INIT_COMPLETION(kim_gdata->ldisc_installed);
 
@@ -515,6 +544,10 @@ long st_kim_stop(void *kim_data)
         gpio_set_value(kim_gdata->nshutdown, GPIO_HIGH);
         mdelay(1);
         gpio_set_value(kim_gdata->nshutdown, GPIO_LOW);
+
+        /* platform specific disable */
+        if (pdata->chip_disable)
+                pdata->chip_disable(kim_gdata);
         return err;
 }
 
diff --git a/drivers/misc/ti-st/st_ll.c b/drivers/misc/ti-st/st_ll.c
index 3f2495138855..1ff460a8e9c7 100644
--- a/drivers/misc/ti-st/st_ll.c
+++ b/drivers/misc/ti-st/st_ll.c
@@ -22,6 +22,7 @@
 #define pr_fmt(fmt) "(stll) :" fmt
 #include <linux/skbuff.h>
 #include <linux/module.h>
+#include <linux/platform_device.h>
 #include <linux/ti_wilink_st.h>
 
 /**********************************************************************/
@@ -37,6 +38,9 @@ static void send_ll_cmd(struct st_data_s *st_data,
 
 static void ll_device_want_to_sleep(struct st_data_s *st_data)
 {
+        struct kim_data_s       *kim_data;
+        struct ti_st_plat_data  *pdata;
+
         pr_debug("%s", __func__);
         /* sanity check */
         if (st_data->ll_state != ST_LL_AWAKE)
@@ -46,10 +50,19 @@ static void ll_device_want_to_sleep(struct st_data_s *st_data)
         send_ll_cmd(st_data, LL_SLEEP_ACK);
         /* update state */
         st_data->ll_state = ST_LL_ASLEEP;
+
+        /* communicate to platform about chip asleep */
+        kim_data = st_data->kim_data;
+        pdata = kim_data->kim_pdev->dev.platform_data;
+        if (pdata->chip_asleep)
+                pdata->chip_asleep(NULL);
 }
 
 static void ll_device_want_to_wakeup(struct st_data_s *st_data)
 {
+        struct kim_data_s       *kim_data;
+        struct ti_st_plat_data  *pdata;
+
         /* diff actions in diff states */
         switch (st_data->ll_state) {
         case ST_LL_ASLEEP:
@@ -70,6 +83,12 @@ static void ll_device_want_to_wakeup(struct st_data_s *st_data)
         }
         /* update state */
         st_data->ll_state = ST_LL_AWAKE;
+
+        /* communicate to platform about chip wakeup */
+        kim_data = st_data->kim_data;
+        pdata = kim_data->kim_pdev->dev.platform_data;
+        if (pdata->chip_asleep)
+                pdata->chip_awake(NULL);
 }
 
 /**********************************************************************/
diff --git a/drivers/mmc/card/mmc_test.c b/drivers/mmc/card/mmc_test.c
index 006a5e9f8ab8..2bf229acd3b8 100644
--- a/drivers/mmc/card/mmc_test.c
+++ b/drivers/mmc/card/mmc_test.c
@@ -224,7 +224,7 @@ static void mmc_test_prepare_mrq(struct mmc_test_card *test,
 static int mmc_test_busy(struct mmc_command *cmd)
 {
         return !(cmd->resp[0] & R1_READY_FOR_DATA) ||
-                (R1_CURRENT_STATE(cmd->resp[0]) == 7);
+                (R1_CURRENT_STATE(cmd->resp[0]) == R1_STATE_PRG);
 }
 
 /*
@@ -2900,7 +2900,7 @@ static const struct file_operations mmc_test_fops_testlist = {
         .release        = single_release,
 };
 
-static void mmc_test_free_file_test(struct mmc_card *card)
+static void mmc_test_free_dbgfs_file(struct mmc_card *card)
 {
         struct mmc_test_dbgfs_file *df, *dfs;
 
@@ -2917,34 +2917,21 @@ static void mmc_test_free_file_test(struct mmc_card *card)
         mutex_unlock(&mmc_test_lock);
 }
 
-static int mmc_test_register_file_test(struct mmc_card *card)
+static int __mmc_test_register_dbgfs_file(struct mmc_card *card,
+        const char *name, mode_t mode, const struct file_operations *fops)
 {
         struct dentry *file = NULL;
         struct mmc_test_dbgfs_file *df;
-        int ret = 0;
-
-        mutex_lock(&mmc_test_lock);
-
-        if (card->debugfs_root)
-                file = debugfs_create_file("test", S_IWUSR | S_IRUGO,
-                        card->debugfs_root, card, &mmc_test_fops_test);
-
-        if (IS_ERR_OR_NULL(file)) {
-                dev_err(&card->dev,
-                        "Can't create test. Perhaps debugfs is disabled.\n");
-                ret = -ENODEV;
-                goto err;
-        }
 
         if (card->debugfs_root)
-                file = debugfs_create_file("testlist", S_IRUGO,
-                        card->debugfs_root, card, &mmc_test_fops_testlist);
+                file = debugfs_create_file(name, mode, card->debugfs_root,
+                        card, fops);
 
         if (IS_ERR_OR_NULL(file)) {
                 dev_err(&card->dev,
-                        "Can't create testlist. Perhaps debugfs is disabled.\n");
-                ret = -ENODEV;
-                goto err;
+                        "Can't create %s. Perhaps debugfs is disabled.\n",
+                        name);
+                return -ENODEV;
         }
 
         df = kmalloc(sizeof(struct mmc_test_dbgfs_file), GFP_KERNEL);
@@ -2952,14 +2939,31 @@ static int mmc_test_register_file_test(struct mmc_card *card)
                 debugfs_remove(file);
                 dev_err(&card->dev,
                         "Can't allocate memory for internal usage.\n");
-                ret = -ENOMEM;
-                goto err;
+                return -ENOMEM;
         }
 
         df->card = card;
         df->file = file;
 
         list_add(&df->link, &mmc_test_file_test);
+        return 0;
+}
+
+static int mmc_test_register_dbgfs_file(struct mmc_card *card)
+{
+        int ret;
+
+        mutex_lock(&mmc_test_lock);
+
+        ret = __mmc_test_register_dbgfs_file(card, "test", S_IWUSR | S_IRUGO,
+                &mmc_test_fops_test);
+        if (ret)
+                goto err;
+
+        ret = __mmc_test_register_dbgfs_file(card, "testlist", S_IRUGO,
+                &mmc_test_fops_testlist);
+        if (ret)
+                goto err;
 
 err:
         mutex_unlock(&mmc_test_lock);
@@ -2974,7 +2978,7 @@ static int mmc_test_probe(struct mmc_card *card)
         if (!mmc_card_mmc(card) && !mmc_card_sd(card))
                 return -ENODEV;
 
-        ret = mmc_test_register_file_test(card);
+        ret = mmc_test_register_dbgfs_file(card);
         if (ret)
                 return ret;
 
@@ -2986,7 +2990,7 @@ static int mmc_test_probe(struct mmc_card *card)
 static void mmc_test_remove(struct mmc_card *card)
 {
         mmc_test_free_result(card);
-        mmc_test_free_file_test(card);
+        mmc_test_free_dbgfs_file(card);
 }
 
 static struct mmc_driver mmc_driver = {
@@ -3006,7 +3010,7 @@ static void __exit mmc_test_exit(void)
 {
         /* Clear stalled data if card is still plugged */
         mmc_test_free_result(NULL);
-        mmc_test_free_file_test(NULL);
+        mmc_test_free_dbgfs_file(NULL);
 
         mmc_unregister_driver(&mmc_driver);
 }
diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
index 89bdeaec7182..b27b94078c21 100644
--- a/drivers/mmc/core/core.c
+++ b/drivers/mmc/core/core.c
@@ -133,7 +133,7 @@ void mmc_request_done(struct mmc_host *host, struct mmc_request *mrq)
                 if (mrq->done)
                         mrq->done(mrq);
 
-                mmc_host_clk_gate(host);
+                mmc_host_clk_release(host);
         }
 }
 
@@ -192,7 +192,7 @@ mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
                         mrq->stop->mrq = mrq;
                 }
         }
-        mmc_host_clk_ungate(host);
+        mmc_host_clk_hold(host);
         led_trigger_event(host->led, LED_FULL);
         host->ops->request(host, mrq);
 }
@@ -728,15 +728,17 @@ static inline void mmc_set_ios(struct mmc_host *host)
  */
 void mmc_set_chip_select(struct mmc_host *host, int mode)
 {
+        mmc_host_clk_hold(host);
         host->ios.chip_select = mode;
         mmc_set_ios(host);
+        mmc_host_clk_release(host);
 }
 
 /*
  * Sets the host clock to the highest possible frequency that
  * is below "hz".
  */
-void mmc_set_clock(struct mmc_host *host, unsigned int hz)
+static void __mmc_set_clock(struct mmc_host *host, unsigned int hz)
 {
         WARN_ON(hz < host->f_min);
 
@@ -747,6 +749,13 @@ void mmc_set_clock(struct mmc_host *host, unsigned int hz)
         mmc_set_ios(host);
 }
 
+void mmc_set_clock(struct mmc_host *host, unsigned int hz)
+{
+        mmc_host_clk_hold(host);
+        __mmc_set_clock(host, hz);
+        mmc_host_clk_release(host);
+}
+
 #ifdef CONFIG_MMC_CLKGATE
 /*
  * This gates the clock by setting it to 0 Hz.
@@ -779,7 +788,7 @@ void mmc_ungate_clock(struct mmc_host *host)
         if (host->clk_old) {
                 BUG_ON(host->ios.clock);
                 /* This call will also set host->clk_gated to false */
-                mmc_set_clock(host, host->clk_old);
+                __mmc_set_clock(host, host->clk_old);
         }
 }
 
@@ -807,8 +816,10 @@ void mmc_set_ungated(struct mmc_host *host)
  */
 void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode)
 {
+        mmc_host_clk_hold(host);
         host->ios.bus_mode = mode;
         mmc_set_ios(host);
+        mmc_host_clk_release(host);
 }
 
 /*
@@ -816,8 +827,10 @@ void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode)
  */
 void mmc_set_bus_width(struct mmc_host *host, unsigned int width)
 {
+        mmc_host_clk_hold(host);
         host->ios.bus_width = width;
         mmc_set_ios(host);
+        mmc_host_clk_release(host);
 }
 
 /**
@@ -1015,8 +1028,10 @@ u32 mmc_select_voltage(struct mmc_host *host, u32 ocr)
 
                 ocr &= 3 << bit;
 
+                mmc_host_clk_hold(host);
                 host->ios.vdd = bit;
                 mmc_set_ios(host);
+                mmc_host_clk_release(host);
         } else {
                 pr_warning("%s: host doesn't support card's voltages\n",
                                 mmc_hostname(host));
@@ -1063,8 +1078,10 @@ int mmc_set_signal_voltage(struct mmc_host *host, int signal_voltage, bool cmd11
  */
 void mmc_set_timing(struct mmc_host *host, unsigned int timing)
 {
+        mmc_host_clk_hold(host);
         host->ios.timing = timing;
         mmc_set_ios(host);
+        mmc_host_clk_release(host);
 }
 
 /*
@@ -1072,8 +1089,10 @@ void mmc_set_timing(struct mmc_host *host, unsigned int timing)
  */
 void mmc_set_driver_type(struct mmc_host *host, unsigned int drv_type)
 {
+        mmc_host_clk_hold(host);
         host->ios.drv_type = drv_type;
         mmc_set_ios(host);
+        mmc_host_clk_release(host);
 }
 
 /*
@@ -1091,6 +1110,8 @@ static void mmc_power_up(struct mmc_host *host)
 {
         int bit;
 
+        mmc_host_clk_hold(host);
+
         /* If ocr is set, we use it */
         if (host->ocr)
                 bit = ffs(host->ocr) - 1;
@@ -1126,10 +1147,14 @@ static void mmc_power_up(struct mmc_host *host)
          * time required to reach a stable voltage.
          */
         mmc_delay(10);
+
+        mmc_host_clk_release(host);
 }
 
 static void mmc_power_off(struct mmc_host *host)
 {
+        mmc_host_clk_hold(host);
+
         host->ios.clock = 0;
         host->ios.vdd = 0;
 
@@ -1147,6 +1172,8 @@ static void mmc_power_off(struct mmc_host *host)
         host->ios.bus_width = MMC_BUS_WIDTH_1;
         host->ios.timing = MMC_TIMING_LEGACY;
         mmc_set_ios(host);
+
+        mmc_host_clk_release(host);
 }
 
 /*
@@ -1502,7 +1529,7 @@ static int mmc_do_erase(struct mmc_card *card, unsigned int from,
                         goto out;
                 }
         } while (!(cmd.resp[0] & R1_READY_FOR_DATA) ||
-                 R1_CURRENT_STATE(cmd.resp[0]) == 7);
+                 R1_CURRENT_STATE(cmd.resp[0]) == R1_STATE_PRG);
 out:
         return err;
 }
diff --git a/drivers/mmc/core/host.c b/drivers/mmc/core/host.c
index b29d3e8fd3a2..793d0a0dad8d 100644
--- a/drivers/mmc/core/host.c
+++ b/drivers/mmc/core/host.c
@@ -119,14 +119,14 @@ static void mmc_host_clk_gate_work(struct work_struct *work)
 }
 
 /**
- *      mmc_host_clk_ungate - ungate hardware MCI clocks
+ *      mmc_host_clk_hold - ungate hardware MCI clocks
  *      @host: host to ungate.
  *
  *      Makes sure the host ios.clock is restored to a non-zero value
  *      past this call. Increase clock reference count and ungate clock
  *      if we're the first user.
  */
-void mmc_host_clk_ungate(struct mmc_host *host)
+void mmc_host_clk_hold(struct mmc_host *host)
 {
         unsigned long flags;
 
@@ -164,14 +164,14 @@ static bool mmc_host_may_gate_card(struct mmc_card *card)
 }
 
 /**
- *      mmc_host_clk_gate - gate off hardware MCI clocks
+ *      mmc_host_clk_release - gate off hardware MCI clocks
  *      @host: host to gate.
  *
  *      Calls the host driver with ios.clock set to zero as often as possible
  *      in order to gate off hardware MCI clocks. Decrease clock reference
  *      count and schedule disabling of clock.
  */
-void mmc_host_clk_gate(struct mmc_host *host)
+void mmc_host_clk_release(struct mmc_host *host)
 {
         unsigned long flags;
 
@@ -179,7 +179,7 @@ void mmc_host_clk_gate(struct mmc_host *host)
         host->clk_requests--;
         if (mmc_host_may_gate_card(host->card) &&
             !host->clk_requests)
-                schedule_work(&host->clk_gate_work);
+                queue_work(system_nrt_wq, &host->clk_gate_work);
         spin_unlock_irqrestore(&host->clk_lock, flags);
 }
 
@@ -231,7 +231,7 @@ static inline void mmc_host_clk_exit(struct mmc_host *host)
         if (cancel_work_sync(&host->clk_gate_work))
                 mmc_host_clk_gate_delayed(host);
         if (host->clk_gated)
-                mmc_host_clk_ungate(host);
+                mmc_host_clk_hold(host);
         /* There should be only one user now */
         WARN_ON(host->clk_requests > 1);
 }
diff --git a/drivers/mmc/core/host.h b/drivers/mmc/core/host.h
index de199f911928..fb8a5cd2e4a1 100644
--- a/drivers/mmc/core/host.h
+++ b/drivers/mmc/core/host.h
@@ -16,16 +16,16 @@ int mmc_register_host_class(void);
 void mmc_unregister_host_class(void);
 
 #ifdef CONFIG_MMC_CLKGATE
-void mmc_host_clk_ungate(struct mmc_host *host);
-void mmc_host_clk_gate(struct mmc_host *host);
+void mmc_host_clk_hold(struct mmc_host *host);
+void mmc_host_clk_release(struct mmc_host *host);
 unsigned int mmc_host_clk_rate(struct mmc_host *host);
 
 #else
-static inline void mmc_host_clk_ungate(struct mmc_host *host)
+static inline void mmc_host_clk_hold(struct mmc_host *host)
 {
 }
 
-static inline void mmc_host_clk_gate(struct mmc_host *host)
+static inline void mmc_host_clk_release(struct mmc_host *host)
 {
 }
 
diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
index aa7d1d79b8c5..5700b1cbdfec 100644
--- a/drivers/mmc/core/mmc.c
+++ b/drivers/mmc/core/mmc.c
@@ -259,7 +259,7 @@ static int mmc_read_ext_csd(struct mmc_card *card, u8 *ext_csd)
         }
 
         card->ext_csd.rev = ext_csd[EXT_CSD_REV];
-        if (card->ext_csd.rev > 5) {
+        if (card->ext_csd.rev > 6) {
                 printk(KERN_ERR "%s: unrecognised EXT_CSD revision %d\n",
                         mmc_hostname(card->host), card->ext_csd.rev);
                 err = -EINVAL;
diff --git a/drivers/mmc/core/mmc_ops.c b/drivers/mmc/core/mmc_ops.c
index 845ce7c533b9..770c3d06f5dc 100644
--- a/drivers/mmc/core/mmc_ops.c
+++ b/drivers/mmc/core/mmc_ops.c
@@ -407,7 +407,7 @@ int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value,
                         break;
                 if (mmc_host_is_spi(card->host))
                         break;
-        } while (R1_CURRENT_STATE(status) == 7);
+        } while (R1_CURRENT_STATE(status) == R1_STATE_PRG);
 
         if (mmc_host_is_spi(card->host)) {
                 if (status & R1_SPI_ILLEGAL_COMMAND)
diff --git a/drivers/mmc/core/sd.c b/drivers/mmc/core/sd.c
index 633975ff2bb3..0370e03e3142 100644
--- a/drivers/mmc/core/sd.c
+++ b/drivers/mmc/core/sd.c
@@ -469,56 +469,75 @@ static int sd_select_driver_type(struct mmc_card *card, u8 *status)
         return 0;
 }
 
-static int sd_set_bus_speed_mode(struct mmc_card *card, u8 *status)
+static void sd_update_bus_speed_mode(struct mmc_card *card)
 {
-        unsigned int bus_speed = 0, timing = 0;
-        int err;
-
         /*
          * If the host doesn't support any of the UHS-I modes, fallback on
          * default speed.
          */
         if (!(card->host->caps & (MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 |
-            MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR104 | MMC_CAP_UHS_DDR50)))
-                return 0;
+            MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR104 | MMC_CAP_UHS_DDR50))) {
+                card->sd_bus_speed = 0;
+                return;
+        }
 
         if ((card->host->caps & MMC_CAP_UHS_SDR104) &&
             (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR104)) {
-                        bus_speed = UHS_SDR104_BUS_SPEED;
-                        timing = MMC_TIMING_UHS_SDR104;
-                        card->sw_caps.uhs_max_dtr = UHS_SDR104_MAX_DTR;
+                        card->sd_bus_speed = UHS_SDR104_BUS_SPEED;
         } else if ((card->host->caps & MMC_CAP_UHS_DDR50) &&
                    (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_DDR50)) {
-                        bus_speed = UHS_DDR50_BUS_SPEED;
-                        timing = MMC_TIMING_UHS_DDR50;
-                        card->sw_caps.uhs_max_dtr = UHS_DDR50_MAX_DTR;
+                        card->sd_bus_speed = UHS_DDR50_BUS_SPEED;
         } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
                     MMC_CAP_UHS_SDR50)) && (card->sw_caps.sd3_bus_mode &
                     SD_MODE_UHS_SDR50)) {
-                        bus_speed = UHS_SDR50_BUS_SPEED;
-                        timing = MMC_TIMING_UHS_SDR50;
-                        card->sw_caps.uhs_max_dtr = UHS_SDR50_MAX_DTR;
+                        card->sd_bus_speed = UHS_SDR50_BUS_SPEED;
         } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
                     MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25)) &&
                    (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR25)) {
-                        bus_speed = UHS_SDR25_BUS_SPEED;
-                        timing = MMC_TIMING_UHS_SDR25;
-                        card->sw_caps.uhs_max_dtr = UHS_SDR25_MAX_DTR;
+                        card->sd_bus_speed = UHS_SDR25_BUS_SPEED;
         } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
                     MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25 |
                     MMC_CAP_UHS_SDR12)) && (card->sw_caps.sd3_bus_mode &
                     SD_MODE_UHS_SDR12)) {
-                        bus_speed = UHS_SDR12_BUS_SPEED;
-                        timing = MMC_TIMING_UHS_SDR12;
-                        card->sw_caps.uhs_max_dtr = UHS_SDR12_MAX_DTR;
+                        card->sd_bus_speed = UHS_SDR12_BUS_SPEED;
+        }
+}
+
+static int sd_set_bus_speed_mode(struct mmc_card *card, u8 *status)
+{
+        int err;
+        unsigned int timing = 0;
+
+        switch (card->sd_bus_speed) {
+        case UHS_SDR104_BUS_SPEED:
+                timing = MMC_TIMING_UHS_SDR104;
+                card->sw_caps.uhs_max_dtr = UHS_SDR104_MAX_DTR;
+                break;
+        case UHS_DDR50_BUS_SPEED:
+                timing = MMC_TIMING_UHS_DDR50;
+                card->sw_caps.uhs_max_dtr = UHS_DDR50_MAX_DTR;
+                break;
+        case UHS_SDR50_BUS_SPEED:
+                timing = MMC_TIMING_UHS_SDR50;
+                card->sw_caps.uhs_max_dtr = UHS_SDR50_MAX_DTR;
+                break;
+        case UHS_SDR25_BUS_SPEED:
+                timing = MMC_TIMING_UHS_SDR25;
+                card->sw_caps.uhs_max_dtr = UHS_SDR25_MAX_DTR;
+                break;
+        case UHS_SDR12_BUS_SPEED:
+                timing = MMC_TIMING_UHS_SDR12;
+                card->sw_caps.uhs_max_dtr = UHS_SDR12_MAX_DTR;
+                break;
+        default:
+                return 0;
         }
 
-        card->sd_bus_speed = bus_speed;
-        err = mmc_sd_switch(card, 1, 0, bus_speed, status);
+        err = mmc_sd_switch(card, 1, 0, card->sd_bus_speed, status);
         if (err)
                 return err;
 
-        if ((status[16] & 0xF) != bus_speed)
+        if ((status[16] & 0xF) != card->sd_bus_speed)
                 printk(KERN_WARNING "%s: Problem setting bus speed mode!\n",
                         mmc_hostname(card->host));
         else {
@@ -618,18 +637,24 @@ static int mmc_sd_init_uhs_card(struct mmc_card *card)
                 mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4);
         }
 
+        /*
+         * Select the bus speed mode depending on host
+         * and card capability.
+         */
+        sd_update_bus_speed_mode(card);
+
         /* Set the driver strength for the card */
         err = sd_select_driver_type(card, status);
         if (err)
                 goto out;
 
-        /* Set bus speed mode of the card */
-        err = sd_set_bus_speed_mode(card, status);
+        /* Set current limit for the card */
+        err = sd_set_current_limit(card, status);
         if (err)
                 goto out;
 
-        /* Set current limit for the card */
-        err = sd_set_current_limit(card, status);
+        /* Set bus speed mode of the card */
+        err = sd_set_bus_speed_mode(card, status);
         if (err)
                 goto out;
 
diff --git a/drivers/mmc/host/dw_mmc.c b/drivers/mmc/host/dw_mmc.c
index 77f0b6b1681d..ff0f714b012c 100644
--- a/drivers/mmc/host/dw_mmc.c
+++ b/drivers/mmc/host/dw_mmc.c
@@ -62,7 +62,7 @@ struct idmac_desc {
 
         u32             des1;   /* Buffer sizes */
 #define IDMAC_SET_BUFFER1_SIZE(d, s) \
-        ((d)->des1 = ((d)->des1 & 0x03ffc000) | ((s) & 0x3fff))
+        ((d)->des1 = ((d)->des1 & 0x03ffe000) | ((s) & 0x1fff))
 
         u32             des2;   /* buffer 1 physical address */
 
@@ -699,7 +699,7 @@ static void dw_mci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
         }
 
         /* DDR mode set */
-        if (ios->ddr) {
+        if (ios->timing == MMC_TIMING_UHS_DDR50) {
                 regs = mci_readl(slot->host, UHS_REG);
                 regs |= (0x1 << slot->id) << 16;
                 mci_writel(slot->host, UHS_REG, regs);
@@ -1646,7 +1646,7 @@ static int __init dw_mci_init_slot(struct dw_mci *host, unsigned int id)
                         mmc->caps |= MMC_CAP_4_BIT_DATA;
 
         if (host->pdata->quirks & DW_MCI_QUIRK_HIGHSPEED)
-                mmc->caps |= MMC_CAP_SD_HIGHSPEED;
+                mmc->caps |= MMC_CAP_SD_HIGHSPEED | MMC_CAP_MMC_HIGHSPEED;
 
 #ifdef CONFIG_MMC_DW_IDMAC
         mmc->max_segs = host->ring_size;
diff --git a/drivers/mmc/host/sdhci-esdhc-imx.c b/drivers/mmc/host/sdhci-esdhc-imx.c
index 9ebfb4b482f5..4dc0028086a3 100644
--- a/drivers/mmc/host/sdhci-esdhc-imx.c
+++ b/drivers/mmc/host/sdhci-esdhc-imx.c
@@ -16,6 +16,7 @@
 #include <linux/err.h>
 #include <linux/clk.h>
 #include <linux/gpio.h>
+#include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/mmc/host.h>
 #include <linux/mmc/mmc.h>
@@ -27,6 +28,7 @@
 #include "sdhci-pltfm.h"
 #include "sdhci-esdhc.h"
 
+#define SDHCI_CTRL_D3CD                 0x08
 /* VENDOR SPEC register */
 #define SDHCI_VENDOR_SPEC               0xC0
 #define  SDHCI_VENDOR_SPEC_SDIO_QUIRK   0x00000002
@@ -141,13 +143,32 @@ static void esdhc_writel_le(struct sdhci_host *host, u32 val, int reg)
         struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
         struct pltfm_imx_data *imx_data = pltfm_host->priv;
         struct esdhc_platform_data *boarddata = &imx_data->boarddata;
-
-        if (unlikely((reg == SDHCI_INT_ENABLE || reg == SDHCI_SIGNAL_ENABLE)
-                        && (boarddata->cd_type == ESDHC_CD_GPIO)))
-                /*
-                 * these interrupts won't work with a custom card_detect gpio
-                 */
-                val &= ~(SDHCI_INT_CARD_REMOVE | SDHCI_INT_CARD_INSERT);
+        u32 data;
+
+        if (unlikely(reg == SDHCI_INT_ENABLE || reg == SDHCI_SIGNAL_ENABLE)) {
+                if (boarddata->cd_type == ESDHC_CD_GPIO)
+                        /*
+                         * These interrupts won't work with a custom
+                         * card_detect gpio (only applied to mx25/35)
+                         */
+                        val &= ~(SDHCI_INT_CARD_REMOVE | SDHCI_INT_CARD_INSERT);
+
+                if (val & SDHCI_INT_CARD_INT) {
+                        /*
+                         * Clear and then set D3CD bit to avoid missing the
+                         * card interrupt.  This is a eSDHC controller problem
+                         * so we need to apply the following workaround: clear
+                         * and set D3CD bit will make eSDHC re-sample the card
+                         * interrupt. In case a card interrupt was lost,
+                         * re-sample it by the following steps.
+                         */
+                        data = readl(host->ioaddr + SDHCI_HOST_CONTROL);
+                        data &= ~SDHCI_CTRL_D3CD;
+                        writel(data, host->ioaddr + SDHCI_HOST_CONTROL);
+                        data |= SDHCI_CTRL_D3CD;
+                        writel(data, host->ioaddr + SDHCI_HOST_CONTROL);
+                }
+        }
 
         if (unlikely((imx_data->flags & ESDHC_FLAG_MULTIBLK_NO_INT)
                                 && (reg == SDHCI_INT_STATUS)
@@ -217,8 +238,10 @@ static void esdhc_writeb_le(struct sdhci_host *host, u8 val, int reg)
                  */
                 return;
         case SDHCI_HOST_CONTROL:
-                /* FSL messed up here, so we can just keep those two */
-                new_val = val & (SDHCI_CTRL_LED | SDHCI_CTRL_4BITBUS);
+                /* FSL messed up here, so we can just keep those three */
+                new_val = val & (SDHCI_CTRL_LED | \
+                                SDHCI_CTRL_4BITBUS | \
+                                SDHCI_CTRL_D3CD);
                 /* ensure the endianess */
                 new_val |= ESDHC_HOST_CONTROL_LE;
                 /* DMA mode bits are shifted */
diff --git a/drivers/mmc/host/sdhci-pxav3.c b/drivers/mmc/host/sdhci-pxav3.c
index 4198dbbc5c20..fc7e4a515629 100644
--- a/drivers/mmc/host/sdhci-pxav3.c
+++ b/drivers/mmc/host/sdhci-pxav3.c
@@ -195,7 +195,8 @@ static int __devinit sdhci_pxav3_probe(struct platform_device *pdev)
         clk_enable(clk);
 
         host->quirks = SDHCI_QUIRK_BROKEN_TIMEOUT_VAL
-                | SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC;
+                | SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC
+                | SDHCI_QUIRK_32BIT_ADMA_SIZE;
 
         /* enable 1/8V DDR capable */
         host->mmc->caps |= MMC_CAP_1_8V_DDR;
diff --git a/drivers/mmc/host/sdhci-s3c.c b/drivers/mmc/host/sdhci-s3c.c
index 460ffaf0f6d7..fe886d6c474a 100644
--- a/drivers/mmc/host/sdhci-s3c.c
+++ b/drivers/mmc/host/sdhci-s3c.c
@@ -19,6 +19,7 @@
 #include <linux/clk.h>
 #include <linux/io.h>
 #include <linux/gpio.h>
+#include <linux/module.h>
 
 #include <linux/mmc/host.h>
 
@@ -301,6 +302,8 @@ static int sdhci_s3c_platform_8bit_width(struct sdhci_host *host, int width)
                 ctrl &= ~SDHCI_CTRL_8BITBUS;
                 break;
         default:
+                ctrl &= ~SDHCI_CTRL_4BITBUS;
+                ctrl &= ~SDHCI_CTRL_8BITBUS;
                 break;
         }
 
@@ -502,6 +505,9 @@ static int __devinit sdhci_s3c_probe(struct platform_device *pdev)
         /* This host supports the Auto CMD12 */
         host->quirks |= SDHCI_QUIRK_MULTIBLOCK_READ_ACMD12;
 
+        /* Samsung SoCs need BROKEN_ADMA_ZEROLEN_DESC */
+        host->quirks |= SDHCI_QUIRK_BROKEN_ADMA_ZEROLEN_DESC;
+
         if (pdata->cd_type == S3C_SDHCI_CD_NONE ||
             pdata->cd_type == S3C_SDHCI_CD_PERMANENT)
                 host->quirks |= SDHCI_QUIRK_BROKEN_CARD_DETECTION;
diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
index c31a3343340d..0e02cc1df12e 100644
--- a/drivers/mmc/host/sdhci.c
+++ b/drivers/mmc/host/sdhci.c
@@ -628,12 +628,11 @@ static u8 sdhci_calc_timeout(struct sdhci_host *host, struct mmc_command *cmd)
         /* timeout in us */
         if (!data)
                 target_timeout = cmd->cmd_timeout_ms * 1000;
-        else
-                target_timeout = data->timeout_ns / 1000 +
-                        data->timeout_clks / host->clock;
-
-        if (host->quirks & SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK)
-                host->timeout_clk = host->clock / 1000;
+        else {
+                target_timeout = data->timeout_ns / 1000;
+                if (host->clock)
+                        target_timeout += data->timeout_clks / host->clock;
+        }
 
         /*
          * Figure out needed cycles.
@@ -645,7 +644,6 @@ static u8 sdhci_calc_timeout(struct sdhci_host *host, struct mmc_command *cmd)
          *     =>
          *     (1) / (2) > 2^6
          */
-        BUG_ON(!host->timeout_clk);
         count = 0;
         current_timeout = (1 << 13) * 1000 / host->timeout_clk;
         while (current_timeout < target_timeout) {
@@ -1867,9 +1865,6 @@ static void sdhci_tasklet_finish(unsigned long param)
 
         del_timer(&host->timer);
 
-        if (host->version >= SDHCI_SPEC_300)
-                del_timer(&host->tuning_timer);
-
         mrq = host->mrq;
 
         /*
@@ -2461,22 +2456,6 @@ int sdhci_add_host(struct sdhci_host *host)
                 host->max_clk = host->ops->get_max_clock(host);
         }
 
-        host->timeout_clk =
-                (caps[0] & SDHCI_TIMEOUT_CLK_MASK) >> SDHCI_TIMEOUT_CLK_SHIFT;
-        if (host->timeout_clk == 0) {
-                if (host->ops->get_timeout_clock) {
-                        host->timeout_clk = host->ops->get_timeout_clock(host);
-                } else if (!(host->quirks &
-                                SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK)) {
-                        printk(KERN_ERR
-                               "%s: Hardware doesn't specify timeout clock "
-                               "frequency.\n", mmc_hostname(mmc));
-                        return -ENODEV;
-                }
-        }
-        if (caps[0] & SDHCI_TIMEOUT_CLK_UNIT)
-                host->timeout_clk *= 1000;
-
         /*
          * In case of Host Controller v3.00, find out whether clock
          * multiplier is supported.
@@ -2509,10 +2488,26 @@ int sdhci_add_host(struct sdhci_host *host)
         } else
                 mmc->f_min = host->max_clk / SDHCI_MAX_DIV_SPEC_200;
 
+        host->timeout_clk =
+                (caps[0] & SDHCI_TIMEOUT_CLK_MASK) >> SDHCI_TIMEOUT_CLK_SHIFT;
+        if (host->timeout_clk == 0) {
+                if (host->ops->get_timeout_clock) {
+                        host->timeout_clk = host->ops->get_timeout_clock(host);
+                } else if (!(host->quirks &
+                                SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK)) {
+                        printk(KERN_ERR
+                               "%s: Hardware doesn't specify timeout clock "
+                               "frequency.\n", mmc_hostname(mmc));
+                        return -ENODEV;
+                }
+        }
+        if (caps[0] & SDHCI_TIMEOUT_CLK_UNIT)
+                host->timeout_clk *= 1000;
+
         if (host->quirks & SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK)
-                mmc->max_discard_to = (1 << 27) / (mmc->f_max / 1000);
-        else
-                mmc->max_discard_to = (1 << 27) / host->timeout_clk;
+                host->timeout_clk = mmc->f_max / 1000;
+
+        mmc->max_discard_to = (1 << 27) / host->timeout_clk;
 
         mmc->caps |= MMC_CAP_SDIO_IRQ | MMC_CAP_ERASE | MMC_CAP_CMD23;
 
diff --git a/drivers/mmc/host/sh_mobile_sdhi.c b/drivers/mmc/host/sh_mobile_sdhi.c
index 774f6439d7ce..0c4a672f5db6 100644
--- a/drivers/mmc/host/sh_mobile_sdhi.c
+++ b/drivers/mmc/host/sh_mobile_sdhi.c
@@ -120,11 +120,11 @@ static int __devinit sh_mobile_sdhi_probe(struct platform_device *pdev)
         mmc_data->hclk = clk_get_rate(priv->clk);
         mmc_data->set_pwr = sh_mobile_sdhi_set_pwr;
         mmc_data->get_cd = sh_mobile_sdhi_get_cd;
-        if (mmc_data->flags & TMIO_MMC_HAS_IDLE_WAIT)
-                mmc_data->write16_hook = sh_mobile_sdhi_write16_hook;
         mmc_data->capabilities = MMC_CAP_MMC_HIGHSPEED;
         if (p) {
                 mmc_data->flags = p->tmio_flags;
+                if (mmc_data->flags & TMIO_MMC_HAS_IDLE_WAIT)
+                        mmc_data->write16_hook = sh_mobile_sdhi_write16_hook;
                 mmc_data->ocr_mask = p->tmio_ocr_mask;
                 mmc_data->capabilities |= p->tmio_caps;
 
diff --git a/drivers/mmc/host/tmio_mmc.c b/drivers/mmc/host/tmio_mmc.c
index 8d185de90d20..44a9668c4b7a 100644
--- a/drivers/mmc/host/tmio_mmc.c
+++ b/drivers/mmc/host/tmio_mmc.c
@@ -27,7 +27,6 @@
 static int tmio_mmc_suspend(struct platform_device *dev, pm_message_t state)
 {
         const struct mfd_cell *cell = mfd_get_cell(dev);
-        struct mmc_host *mmc = platform_get_drvdata(dev);
         int ret;
 
         ret = tmio_mmc_host_suspend(&dev->dev);
@@ -42,7 +41,6 @@ static int tmio_mmc_suspend(struct platform_device *dev, pm_message_t state)
 static int tmio_mmc_resume(struct platform_device *dev)
 {
         const struct mfd_cell *cell = mfd_get_cell(dev);
-        struct mmc_host *mmc = platform_get_drvdata(dev);
         int ret = 0;
 
         /* Tell the MFD core we are ready to be enabled */
diff --git a/drivers/mtd/ubi/debug.h b/drivers/mtd/ubi/debug.h
index 65b5b76cc379..64fbb0021825 100644
--- a/drivers/mtd/ubi/debug.h
+++ b/drivers/mtd/ubi/debug.h
@@ -181,7 +181,7 @@ static inline int ubi_dbg_is_erase_failure(const struct ubi_device *ubi)
 
 #define ubi_dbg_msg(fmt, ...) do {                                           \
         if (0)                                                               \
-                pr_debug(fmt "\n", ##__VA_ARGS__);                           \
+                printk(KERN_DEBUG fmt "\n", ##__VA_ARGS__);                  \
 } while (0)
 
 #define dbg_msg(fmt, ...)  ubi_dbg_msg(fmt, ##__VA_ARGS__)
diff --git a/drivers/net/arm/am79c961a.c b/drivers/net/arm/am79c961a.c
index 52fe21e1e2cd..3b1416e3d217 100644
--- a/drivers/net/arm/am79c961a.c
+++ b/drivers/net/arm/am79c961a.c
@@ -308,8 +308,11 @@ static void am79c961_timer(unsigned long data)
         struct net_device *dev = (struct net_device *)data;
         struct dev_priv *priv = netdev_priv(dev);
         unsigned int lnkstat, carrier;
+        unsigned long flags;
 
+        spin_lock_irqsave(&priv->chip_lock, flags);
         lnkstat = read_ireg(dev->base_addr, ISALED0) & ISALED0_LNKST;
+        spin_unlock_irqrestore(&priv->chip_lock, flags);
         carrier = netif_carrier_ok(dev);
 
         if (lnkstat && !carrier) {
diff --git a/drivers/net/bnx2x/bnx2x_cmn.c b/drivers/net/bnx2x/bnx2x_cmn.c
index 5b0dba6d4efa..37e5790681ad 100644
--- a/drivers/net/bnx2x/bnx2x_cmn.c
+++ b/drivers/net/bnx2x/bnx2x_cmn.c
@@ -63,8 +63,9 @@ static inline void bnx2x_bz_fp(struct bnx2x *bp, int index)
         fp->disable_tpa = ((bp->flags & TPA_ENABLE_FLAG) == 0);
 
 #ifdef BCM_CNIC
-        /* We don't want TPA on FCoE, FWD and OOO L2 rings */
-        bnx2x_fcoe(bp, disable_tpa) = 1;
+        /* We don't want TPA on an FCoE L2 ring */
+        if (IS_FCOE_FP(fp))
+                fp->disable_tpa = 1;
 #endif
 }
 
@@ -1404,10 +1405,9 @@ void bnx2x_netif_stop(struct bnx2x *bp, int disable_hw)
 u16 bnx2x_select_queue(struct net_device *dev, struct sk_buff *skb)
 {
         struct bnx2x *bp = netdev_priv(dev);
+
 #ifdef BCM_CNIC
-        if (NO_FCOE(bp))
-                return skb_tx_hash(dev, skb);
-        else {
+        if (!NO_FCOE(bp)) {
                 struct ethhdr *hdr = (struct ethhdr *)skb->data;
                 u16 ether_type = ntohs(hdr->h_proto);
 
@@ -1424,8 +1424,7 @@ u16 bnx2x_select_queue(struct net_device *dev, struct sk_buff *skb)
                         return bnx2x_fcoe_tx(bp, txq_index);
         }
 #endif
-        /* Select a none-FCoE queue:  if FCoE is enabled, exclude FCoE L2 ring
-         */
+        /* select a non-FCoE queue */
         return __skb_tx_hash(dev, skb, BNX2X_NUM_ETH_QUEUES(bp));
 }
 
@@ -1448,6 +1447,28 @@ void bnx2x_set_num_queues(struct bnx2x *bp)
         bp->num_queues += NON_ETH_CONTEXT_USE;
 }
 
+/**
+ * bnx2x_set_real_num_queues - configure netdev->real_num_[tx,rx]_queues
+ *
+ * @bp:         Driver handle
+ *
+ * We currently support for at most 16 Tx queues for each CoS thus we will
+ * allocate a multiple of 16 for ETH L2 rings according to the value of the
+ * bp->max_cos.
+ *
+ * If there is an FCoE L2 queue the appropriate Tx queue will have the next
+ * index after all ETH L2 indices.
+ *
+ * If the actual number of Tx queues (for each CoS) is less than 16 then there
+ * will be the holes at the end of each group of 16 ETh L2 indices (0..15,
+ * 16..31,...) with indicies that are not coupled with any real Tx queue.
+ *
+ * The proper configuration of skb->queue_mapping is handled by
+ * bnx2x_select_queue() and __skb_tx_hash().
+ *
+ * bnx2x_setup_tc() takes care of the proper TC mappings so that __skb_tx_hash()
+ * will return a proper Tx index if TC is enabled (netdev->num_tc > 0).
+ */
 static inline int bnx2x_set_real_num_queues(struct bnx2x *bp)
 {
         int rc, tx, rx;
@@ -1989,14 +2010,20 @@ int bnx2x_nic_unload(struct bnx2x *bp, int unload_mode)
                 return -EINVAL;
         }
 
+        /*
+         * It's important to set the bp->state to the value different from
+         * BNX2X_STATE_OPEN and only then stop the Tx. Otherwise bnx2x_tx_int()
+         * may restart the Tx from the NAPI context (see bnx2x_tx_int()).
+         */
+        bp->state = BNX2X_STATE_CLOSING_WAIT4_HALT;
+        smp_mb();
+
         /* Stop Tx */
         bnx2x_tx_disable(bp);
 
 #ifdef BCM_CNIC
         bnx2x_cnic_notify(bp, CNIC_CTL_STOP_CMD);
 #endif
-        bp->state = BNX2X_STATE_CLOSING_WAIT4_HALT;
-        smp_mb();
 
         bp->rx_mode = BNX2X_RX_MODE_NONE;
 
diff --git a/drivers/net/bnx2x/bnx2x_dcb.c b/drivers/net/bnx2x/bnx2x_dcb.c
index a4ea35f6a456..a1e004a82f7a 100644
--- a/drivers/net/bnx2x/bnx2x_dcb.c
+++ b/drivers/net/bnx2x/bnx2x_dcb.c
@@ -920,7 +920,7 @@ static void bnx2x_dcbx_admin_mib_updated_params(struct bnx2x *bp,
 
 void bnx2x_dcbx_set_state(struct bnx2x *bp, bool dcb_on, u32 dcbx_enabled)
 {
-        if (!CHIP_IS_E1x(bp)) {
+        if (!CHIP_IS_E1x(bp) && !CHIP_IS_E3(bp)) {
                 bp->dcb_state = dcb_on;
                 bp->dcbx_enabled = dcbx_enabled;
         } else {
diff --git a/drivers/net/bnx2x/bnx2x_hsi.h b/drivers/net/bnx2x/bnx2x_hsi.h
index 06727f32e505..dc24de40e336 100644
--- a/drivers/net/bnx2x/bnx2x_hsi.h
+++ b/drivers/net/bnx2x/bnx2x_hsi.h
@@ -1204,6 +1204,8 @@ struct drv_port_mb {
 
         #define LINK_STATUS_PFC_ENABLED                         0x20000000
 
+        #define LINK_STATUS_PHYSICAL_LINK_FLAG                  0x40000000
+
         u32 port_stx;
 
         u32 stat_nig_timer;
diff --git a/drivers/net/bnx2x/bnx2x_link.c b/drivers/net/bnx2x/bnx2x_link.c
index bcd8f0038628..d45b1555a602 100644
--- a/drivers/net/bnx2x/bnx2x_link.c
+++ b/drivers/net/bnx2x/bnx2x_link.c
@@ -1546,6 +1546,12 @@ static void bnx2x_umac_enable(struct link_params *params,
                                vars->line_speed);
                 break;
         }
+        if (!(vars->flow_ctrl & BNX2X_FLOW_CTRL_TX))
+                val |= UMAC_COMMAND_CONFIG_REG_IGNORE_TX_PAUSE;
+
+        if (!(vars->flow_ctrl & BNX2X_FLOW_CTRL_RX))
+                val |= UMAC_COMMAND_CONFIG_REG_PAUSE_IGNORE;
+
         REG_WR(bp, umac_base + UMAC_REG_COMMAND_CONFIG, val);
         udelay(50);
 
@@ -1661,10 +1667,20 @@ static void bnx2x_xmac_disable(struct link_params *params)
 {
         u8 port = params->port;
         struct bnx2x *bp = params->bp;
-        u32 xmac_base = (port) ? GRCBASE_XMAC1 : GRCBASE_XMAC0;
+        u32 pfc_ctrl, xmac_base = (port) ? GRCBASE_XMAC1 : GRCBASE_XMAC0;
 
         if (REG_RD(bp, MISC_REG_RESET_REG_2) &
             MISC_REGISTERS_RESET_REG_2_XMAC) {
+                /*
+                 * Send an indication to change the state in the NIG back to XON
+                 * Clearing this bit enables the next set of this bit to get
+                 * rising edge
+                 */
+                pfc_ctrl = REG_RD(bp, xmac_base + XMAC_REG_PFC_CTRL_HI);
+                REG_WR(bp, xmac_base + XMAC_REG_PFC_CTRL_HI,
+                       (pfc_ctrl & ~(1<<1)));
+                REG_WR(bp, xmac_base + XMAC_REG_PFC_CTRL_HI,
+                       (pfc_ctrl | (1<<1)));
                 DP(NETIF_MSG_LINK, "Disable XMAC on port %x\n", port);
                 REG_WR(bp, xmac_base + XMAC_REG_CTRL, 0);
                 usleep_range(1000, 1000);
@@ -1729,6 +1745,10 @@ static int bnx2x_emac_enable(struct link_params *params,
 
         DP(NETIF_MSG_LINK, "enabling EMAC\n");
 
+        /* Disable BMAC */
+        REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR,
+               (MISC_REGISTERS_RESET_REG_2_RST_BMAC0 << port));
+
         /* enable emac and not bmac */
         REG_WR(bp, NIG_REG_EGRESS_EMAC0_PORT + port*4, 1);
 
@@ -2583,12 +2603,6 @@ static int bnx2x_bmac1_enable(struct link_params *params,
         REG_WR_DMAE(bp, bmac_addr + BIGMAC_REGISTER_RX_LLFC_MSG_FLDS,
                     wb_data, 2);
 
-        if (vars->phy_flags & PHY_TX_ERROR_CHECK_FLAG) {
-                REG_RD_DMAE(bp, bmac_addr + BIGMAC_REGISTER_RX_LSS_STATUS,
-                            wb_data, 2);
-                if (wb_data[0] > 0)
-                        return -ESRCH;
-        }
         return 0;
 }
 
@@ -2654,16 +2668,6 @@ static int bnx2x_bmac2_enable(struct link_params *params,
         udelay(30);
         bnx2x_update_pfc_bmac2(params, vars, is_lb);
 
-        if (vars->phy_flags & PHY_TX_ERROR_CHECK_FLAG) {
-                REG_RD_DMAE(bp, bmac_addr + BIGMAC2_REGISTER_RX_LSS_STAT,
-                            wb_data, 2);
-                if (wb_data[0] > 0) {
-                        DP(NETIF_MSG_LINK, "Got bad LSS status 0x%x\n",
-                                       wb_data[0]);
-                        return -ESRCH;
-                }
-        }
-
         return 0;
 }
 
@@ -2949,7 +2953,9 @@ static int bnx2x_cl45_read(struct bnx2x *bp, struct bnx2x_phy *phy,
         u32 val;
         u16 i;
         int rc = 0;
-
+        if (phy->flags & FLAGS_MDC_MDIO_WA_B0)
+                bnx2x_bits_en(bp, phy->mdio_ctrl + EMAC_REG_EMAC_MDIO_STATUS,
+                              EMAC_MDIO_STATUS_10MB);
         /* address */
         val = ((phy->addr << 21) | (devad << 16) | reg |
                EMAC_MDIO_COMM_COMMAND_ADDRESS |
@@ -3003,6 +3009,9 @@ static int bnx2x_cl45_read(struct bnx2x *bp, struct bnx2x_phy *phy,
                 }
         }
 
+        if (phy->flags & FLAGS_MDC_MDIO_WA_B0)
+                bnx2x_bits_dis(bp, phy->mdio_ctrl + EMAC_REG_EMAC_MDIO_STATUS,
+                               EMAC_MDIO_STATUS_10MB);
         return rc;
 }
 
@@ -3012,6 +3021,9 @@ static int bnx2x_cl45_write(struct bnx2x *bp, struct bnx2x_phy *phy,
         u32 tmp;
         u8 i;
         int rc = 0;
+        if (phy->flags & FLAGS_MDC_MDIO_WA_B0)
+                bnx2x_bits_en(bp, phy->mdio_ctrl + EMAC_REG_EMAC_MDIO_STATUS,
+                              EMAC_MDIO_STATUS_10MB);
 
         /* address */
 
@@ -3065,7 +3077,9 @@ static int bnx2x_cl45_write(struct bnx2x *bp, struct bnx2x_phy *phy,
                         bnx2x_cl45_read(bp, phy, devad, 0xf, &temp_val);
                 }
         }
-
+        if (phy->flags & FLAGS_MDC_MDIO_WA_B0)
+                bnx2x_bits_dis(bp, phy->mdio_ctrl + EMAC_REG_EMAC_MDIO_STATUS,
+                               EMAC_MDIO_STATUS_10MB);
         return rc;
 }
 
@@ -4353,6 +4367,9 @@ void bnx2x_link_status_update(struct link_params *params,
 
         vars->link_up = (vars->link_status & LINK_STATUS_LINK_UP);
         vars->phy_flags = PHY_XGXS_FLAG;
+        if (vars->link_status & LINK_STATUS_PHYSICAL_LINK_FLAG)
+                vars->phy_flags |= PHY_PHYSICAL_LINK_FLAG;
+
         if (vars->link_up) {
                 DP(NETIF_MSG_LINK, "phy link up\n");
 
@@ -4444,6 +4461,8 @@ void bnx2x_link_status_update(struct link_params *params,
 
                 /* indicate no mac active */
                 vars->mac_type = MAC_TYPE_NONE;
+                if (vars->link_status & LINK_STATUS_PHYSICAL_LINK_FLAG)
+                        vars->phy_flags |= PHY_HALF_OPEN_CONN_FLAG;
         }
 
         /* Sync media type */
@@ -5903,20 +5922,30 @@ int bnx2x_set_led(struct link_params *params,
                                 tmp = EMAC_RD(bp, EMAC_REG_EMAC_LED);
                                 EMAC_WR(bp, EMAC_REG_EMAC_LED,
                                         (tmp | EMAC_LED_OVERRIDE));
-                                return rc;
+                                /*
+                                 * return here without enabling traffic
+                                 * LED blink andsetting rate in ON mode.
+                                 * In oper mode, enabling LED blink
+                                 * and setting rate is needed.
+                                 */
+                                if (mode == LED_MODE_ON)
+                                        return rc;
                         }
-                } else if (SINGLE_MEDIA_DIRECT(params) &&
-                           (CHIP_IS_E1x(bp) ||
-                            CHIP_IS_E2(bp))) {
+                } else if (SINGLE_MEDIA_DIRECT(params)) {
                         /*
                          * This is a work-around for HW issue found when link
                          * is up in CL73
                          */
-                        REG_WR(bp, NIG_REG_LED_MODE_P0 + port*4, 0);
                         REG_WR(bp, NIG_REG_LED_10G_P0 + port*4, 1);
-                } else {
+                        if (CHIP_IS_E1x(bp) ||
+                            CHIP_IS_E2(bp) ||
+                            (mode == LED_MODE_ON))
+                                REG_WR(bp, NIG_REG_LED_MODE_P0 + port*4, 0);
+                        else
+                                REG_WR(bp, NIG_REG_LED_MODE_P0 + port*4,
+                                       hw_led_mode);
+                } else
                         REG_WR(bp, NIG_REG_LED_MODE_P0 + port*4, hw_led_mode);
-                }
 
                 REG_WR(bp, NIG_REG_LED_CONTROL_OVERRIDE_TRAFFIC_P0 + port*4, 0);
                 /* Set blinking rate to ~15.9Hz */
@@ -6160,6 +6189,7 @@ static int bnx2x_update_link_down(struct link_params *params,
         /* update shared memory */
         vars->link_status &= ~(LINK_STATUS_SPEED_AND_DUPLEX_MASK |
                                LINK_STATUS_LINK_UP |
+                               LINK_STATUS_PHYSICAL_LINK_FLAG |
                                LINK_STATUS_AUTO_NEGOTIATE_COMPLETE |
                                LINK_STATUS_RX_FLOW_CONTROL_FLAG_MASK |
                                LINK_STATUS_TX_FLOW_CONTROL_FLAG_MASK |
@@ -6197,7 +6227,8 @@ static int bnx2x_update_link_up(struct link_params *params,
         u8 port = params->port;
         int rc = 0;
 
-        vars->link_status |= LINK_STATUS_LINK_UP;
+        vars->link_status |= (LINK_STATUS_LINK_UP |
+                              LINK_STATUS_PHYSICAL_LINK_FLAG);
         vars->phy_flags |= PHY_PHYSICAL_LINK_FLAG;
 
         if (vars->flow_ctrl & BNX2X_FLOW_CTRL_TX)
@@ -7998,6 +8029,9 @@ static void bnx2x_warpcore_set_limiting_mode(struct link_params *params,
         bnx2x_cl45_read(bp, phy, MDIO_WC_DEVAD,
                         MDIO_WC_REG_UC_INFO_B1_FIRMWARE_MODE, &val);
 
+        /* Restart microcode to re-read the new mode */
+        bnx2x_warpcore_reset_lane(bp, phy, 1);
+        bnx2x_warpcore_reset_lane(bp, phy, 0);
 
 }
 
@@ -8116,7 +8150,6 @@ void bnx2x_handle_module_detect_int(struct link_params *params)
                                  offsetof(struct shmem_region, dev_info.
                                           port_feature_config[params->port].
                                           config));
-
                 bnx2x_set_gpio_int(bp, gpio_num,
                                    MISC_REGISTERS_GPIO_INT_OUTPUT_SET,
                                    gpio_port);
@@ -8125,8 +8158,9 @@ void bnx2x_handle_module_detect_int(struct link_params *params)
                  * Disable transmit for this module
                  */
                 phy->media_type = ETH_PHY_NOT_PRESENT;
-                if ((val & PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_MASK) ==
-                    PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_DISABLE_TX_LASER)
+                if (((val & PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_MASK) ==
+                     PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_DISABLE_TX_LASER) ||
+                    CHIP_IS_E3(bp))
                         bnx2x_sfp_set_transmitter(params, phy, 0);
         }
 }
@@ -8228,9 +8262,6 @@ static u8 bnx2x_8706_config_init(struct bnx2x_phy *phy,
         u16 cnt, val, tmp1;
         struct bnx2x *bp = params->bp;
 
-        /* SPF+ PHY: Set flag to check for Tx error */
-        vars->phy_flags = PHY_TX_ERROR_CHECK_FLAG;
-
         bnx2x_set_gpio(bp, MISC_REGISTERS_GPIO_2,
                        MISC_REGISTERS_GPIO_OUTPUT_HIGH, params->port);
         /* HW reset */
@@ -8414,9 +8445,6 @@ static int bnx2x_8726_config_init(struct bnx2x_phy *phy,
         struct bnx2x *bp = params->bp;
         DP(NETIF_MSG_LINK, "Initializing BCM8726\n");
 
-        /* SPF+ PHY: Set flag to check for Tx error */
-        vars->phy_flags = PHY_TX_ERROR_CHECK_FLAG;
-
         bnx2x_cl45_write(bp, phy, MDIO_PMA_DEVAD, MDIO_PMA_REG_CTRL, 1<<15);
         bnx2x_wait_reset_complete(bp, phy, params);
 
@@ -8585,9 +8613,6 @@ static int bnx2x_8727_config_init(struct bnx2x_phy *phy,
         struct bnx2x *bp = params->bp;
         /* Enable PMD link, MOD_ABS_FLT, and 1G link alarm */
 
-        /* SPF+ PHY: Set flag to check for Tx error */
-        vars->phy_flags = PHY_TX_ERROR_CHECK_FLAG;
-
         bnx2x_wait_reset_complete(bp, phy, params);
         rx_alarm_ctrl_val = (1<<2) | (1<<5) ;
         /* Should be 0x6 to enable XS on Tx side. */
@@ -9243,7 +9268,13 @@ static int bnx2x_848xx_cmn_config_init(struct bnx2x_phy *phy,
         if (phy->req_duplex == DUPLEX_FULL)
                 autoneg_val |= (1<<8);
 
-        bnx2x_cl45_write(bp, phy,
+        /*
+         * Always write this if this is not 84833.
+         * For 84833, write it only when it's a forced speed.
+         */
+        if ((phy->type != PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM84833) ||
+                ((autoneg_val & (1<<12)) == 0))
+                bnx2x_cl45_write(bp, phy,
                          MDIO_AN_DEVAD,
                          MDIO_AN_REG_8481_LEGACY_MII_CTRL, autoneg_val);
 
@@ -9257,13 +9288,12 @@ static int bnx2x_848xx_cmn_config_init(struct bnx2x_phy *phy,
                         bnx2x_cl45_write(bp, phy,
                                  MDIO_AN_DEVAD, MDIO_AN_REG_CTRL,
                                  0x3200);
-        } else if (phy->req_line_speed != SPEED_10 &&
-                   phy->req_line_speed != SPEED_100) {
+        } else
                 bnx2x_cl45_write(bp, phy,
                                  MDIO_AN_DEVAD,
                                  MDIO_AN_REG_8481_10GBASE_T_AN_CTRL,
                                  1);
-        }
+
         /* Save spirom version */
         bnx2x_save_848xx_spirom_version(phy, params);
 
@@ -9756,11 +9786,9 @@ static void bnx2x_848x3_link_reset(struct bnx2x_phy *phy,
                 bnx2x_cl45_read(bp, phy,
                                 MDIO_CTL_DEVAD,
                                 0x400f, &val16);
-                /* Put to low power mode on newer FW */
-                if ((val16 & 0x303f) > 0x1009)
-                        bnx2x_cl45_write(bp, phy,
-                                        MDIO_PMA_DEVAD,
-                                        MDIO_PMA_REG_CTRL, 0x800);
+                bnx2x_cl45_write(bp, phy,
+                                MDIO_PMA_DEVAD,
+                                MDIO_PMA_REG_CTRL, 0x800);
         }
 }
 
@@ -10191,8 +10219,15 @@ static void bnx2x_54618se_link_reset(struct bnx2x_phy *phy,
         u32 cfg_pin;
         u8 port;
 
-        /* This works with E3 only, no need to check the chip
-           before determining the port. */
+        /*
+         * In case of no EPIO routed to reset the GPHY, put it
+         * in low power mode.
+         */
+        bnx2x_cl22_write(bp, phy, MDIO_PMA_REG_CTRL, 0x800);
+        /*
+         * This works with E3 only, no need to check the chip
+         * before determining the port.
+         */
         port = params->port;
         cfg_pin = (REG_RD(bp, params->shmem_base +
                         offsetof(struct shmem_region,
@@ -10603,7 +10638,8 @@ static struct bnx2x_phy phy_warpcore = {
         .type           = PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT,
         .addr           = 0xff,
         .def_md_devad   = 0,
-        .flags          = FLAGS_HW_LOCK_REQUIRED,
+        .flags          = (FLAGS_HW_LOCK_REQUIRED |
+                           FLAGS_TX_ERROR_CHECK),
         .rx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
         .tx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
         .mdio_ctrl      = 0,
@@ -10729,7 +10765,8 @@ static struct bnx2x_phy phy_8706 = {
         .type           = PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8706,
         .addr           = 0xff,
         .def_md_devad   = 0,
-        .flags          = FLAGS_INIT_XGXS_FIRST,
+        .flags          = (FLAGS_INIT_XGXS_FIRST |
+                           FLAGS_TX_ERROR_CHECK),
         .rx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
         .tx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
         .mdio_ctrl      = 0,
@@ -10760,7 +10797,8 @@ static struct bnx2x_phy phy_8726 = {
         .addr           = 0xff,
         .def_md_devad   = 0,
         .flags          = (FLAGS_HW_LOCK_REQUIRED |
-                           FLAGS_INIT_XGXS_FIRST),
+                           FLAGS_INIT_XGXS_FIRST |
+                           FLAGS_TX_ERROR_CHECK),
         .rx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
         .tx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
         .mdio_ctrl      = 0,
@@ -10791,7 +10829,8 @@ static struct bnx2x_phy phy_8727 = {
         .type           = PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM8727,
         .addr           = 0xff,
         .def_md_devad   = 0,
-        .flags          = FLAGS_FAN_FAILURE_DET_REQ,
+        .flags          = (FLAGS_FAN_FAILURE_DET_REQ |
+                           FLAGS_TX_ERROR_CHECK),
         .rx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
         .tx_preemphasis = {0xffff, 0xffff, 0xffff, 0xffff},
         .mdio_ctrl      = 0,
@@ -11112,6 +11151,8 @@ static int bnx2x_populate_int_phy(struct bnx2x *bp, u32 shmem_base, u8 port,
                  */
                 if (CHIP_REV(bp) == CHIP_REV_Ax)
                         phy->flags |= FLAGS_MDC_MDIO_WA;
+                else
+                        phy->flags |= FLAGS_MDC_MDIO_WA_B0;
         } else {
                 switch (switch_cfg) {
                 case SWITCH_CFG_1G:
@@ -11500,13 +11541,12 @@ void bnx2x_init_xmac_loopback(struct link_params *params,
          * Set WC to loopback mode since link is required to provide clock
          * to the XMAC in 20G mode
          */
-        if (vars->line_speed == SPEED_20000) {
-                bnx2x_set_aer_mmd(params, &params->phy[0]);
-                bnx2x_warpcore_reset_lane(bp, &params->phy[0], 0);
-                params->phy[INT_PHY].config_loopback(
+        bnx2x_set_aer_mmd(params, &params->phy[0]);
+        bnx2x_warpcore_reset_lane(bp, &params->phy[0], 0);
+        params->phy[INT_PHY].config_loopback(
                         &params->phy[INT_PHY],
                         params);
-        }
+
         bnx2x_xmac_enable(params, vars, 1);
         REG_WR(bp, NIG_REG_EGRESS_DRAIN0_MODE + params->port*4, 0);
 }
@@ -11684,12 +11724,16 @@ int bnx2x_link_reset(struct link_params *params, struct link_vars *vars,
         bnx2x_set_led(params, vars, LED_MODE_OFF, 0);
 
         if (reset_ext_phy) {
+                bnx2x_set_mdio_clk(bp, params->chip_id, port);
                 for (phy_index = EXT_PHY1; phy_index < params->num_phys;
                       phy_index++) {
-                        if (params->phy[phy_index].link_reset)
+                        if (params->phy[phy_index].link_reset) {
+                                bnx2x_set_aer_mmd(params,
+                                                  &params->phy[phy_index]);
                                 params->phy[phy_index].link_reset(
                                         &params->phy[phy_index],
                                         params);
+                        }
                         if (params->phy[phy_index].flags &
                             FLAGS_REARM_LATCH_SIGNAL)
                                 clear_latch_ind = 1;
@@ -12178,10 +12222,6 @@ static void bnx2x_analyze_link_error(struct link_params *params,
         u8 led_mode;
         u32 half_open_conn = (vars->phy_flags & PHY_HALF_OPEN_CONN_FLAG) > 0;
 
-        /*DP(NETIF_MSG_LINK, "CHECK LINK: %x half_open:%x-> lss:%x\n",
-                       vars->link_up,
-                       half_open_conn, lss_status);*/
-
         if ((lss_status ^ half_open_conn) == 0)
                 return;
 
@@ -12194,6 +12234,7 @@ static void bnx2x_analyze_link_error(struct link_params *params,
          * b. Update link_vars->link_up
          */
         if (lss_status) {
+                DP(NETIF_MSG_LINK, "Remote Fault detected !!!\n");
                 vars->link_status &= ~LINK_STATUS_LINK_UP;
                 vars->link_up = 0;
                 vars->phy_flags |= PHY_HALF_OPEN_CONN_FLAG;
@@ -12203,6 +12244,7 @@ static void bnx2x_analyze_link_error(struct link_params *params,
                  */
                 led_mode = LED_MODE_OFF;
         } else {
+                DP(NETIF_MSG_LINK, "Remote Fault cleared\n");
                 vars->link_status |= LINK_STATUS_LINK_UP;
                 vars->link_up = 1;
                 vars->phy_flags &= ~PHY_HALF_OPEN_CONN_FLAG;
@@ -12219,6 +12261,15 @@ static void bnx2x_analyze_link_error(struct link_params *params,
         bnx2x_notify_link_changed(bp);
 }
 
+/******************************************************************************
+* Description:
+*       This function checks for half opened connection change indication.
+*       When such change occurs, it calls the bnx2x_analyze_link_error
+*       to check if Remote Fault is set or cleared. Reception of remote fault
+*       status message in the MAC indicates that the peer's MAC has detected
+*       a fault, for example, due to break in the TX side of fiber.
+*
+******************************************************************************/
 static void bnx2x_check_half_open_conn(struct link_params *params,
                                        struct link_vars *vars)
 {
@@ -12229,9 +12280,28 @@ static void bnx2x_check_half_open_conn(struct link_params *params,
         if ((vars->phy_flags & PHY_PHYSICAL_LINK_FLAG) == 0)
                 return;
 
-        if (!CHIP_IS_E3(bp) &&
+        if (CHIP_IS_E3(bp) &&
             (REG_RD(bp, MISC_REG_RESET_REG_2) &
-                   (MISC_REGISTERS_RESET_REG_2_RST_BMAC0 << params->port))) {
+              (MISC_REGISTERS_RESET_REG_2_XMAC))) {
+                /* Check E3 XMAC */
+                /*
+                 * Note that link speed cannot be queried here, since it may be
+                 * zero while link is down. In case UMAC is active, LSS will
+                 * simply not be set
+                 */
+                mac_base = (params->port) ? GRCBASE_XMAC1 : GRCBASE_XMAC0;
+
+                /* Clear stick bits (Requires rising edge) */
+                REG_WR(bp, mac_base + XMAC_REG_CLEAR_RX_LSS_STATUS, 0);
+                REG_WR(bp, mac_base + XMAC_REG_CLEAR_RX_LSS_STATUS,
+                       XMAC_CLEAR_RX_LSS_STATUS_REG_CLEAR_LOCAL_FAULT_STATUS |
+                       XMAC_CLEAR_RX_LSS_STATUS_REG_CLEAR_REMOTE_FAULT_STATUS);
+                if (REG_RD(bp, mac_base + XMAC_REG_RX_LSS_STATUS))
+                        lss_status = 1;
+
+                bnx2x_analyze_link_error(params, vars, lss_status);
+        } else if (REG_RD(bp, MISC_REG_RESET_REG_2) &
+                   (MISC_REGISTERS_RESET_REG_2_RST_BMAC0 << params->port)) {
                 /* Check E1X / E2 BMAC */
                 u32 lss_status_reg;
                 u32 wb_data[2];
@@ -12253,14 +12323,20 @@ static void bnx2x_check_half_open_conn(struct link_params *params,
 void bnx2x_period_func(struct link_params *params, struct link_vars *vars)
 {
         struct bnx2x *bp = params->bp;
+        u16 phy_idx;
         if (!params) {
-                DP(NETIF_MSG_LINK, "Ininitliazed params !\n");
+                DP(NETIF_MSG_LINK, "Uninitialized params !\n");
                 return;
         }
-        /* DP(NETIF_MSG_LINK, "Periodic called vars->phy_flags 0x%x speed 0x%x
-         RESET_REG_2 0x%x\n", vars->phy_flags, vars->line_speed,
-          REG_RD(bp, MISC_REG_RESET_REG_2)); */
-        bnx2x_check_half_open_conn(params, vars);
+
+        for (phy_idx = INT_PHY; phy_idx < MAX_PHYS; phy_idx++) {
+                if (params->phy[phy_idx].flags & FLAGS_TX_ERROR_CHECK) {
+                        bnx2x_set_aer_mmd(params, &params->phy[phy_idx]);
+                        bnx2x_check_half_open_conn(params, vars);
+                        break;
+                }
+        }
+
         if (CHIP_IS_E3(bp))
                 bnx2x_check_over_curr(params, vars);
 }
diff --git a/drivers/net/bnx2x/bnx2x_link.h b/drivers/net/bnx2x/bnx2x_link.h
index 6a7708d5da37..c12db6da213e 100644
--- a/drivers/net/bnx2x/bnx2x_link.h
+++ b/drivers/net/bnx2x/bnx2x_link.h
@@ -145,6 +145,8 @@ struct bnx2x_phy {
 #define FLAGS_SFP_NOT_APPROVED          (1<<7)
 #define FLAGS_MDC_MDIO_WA               (1<<8)
 #define FLAGS_DUMMY_READ                (1<<9)
+#define FLAGS_MDC_MDIO_WA_B0            (1<<10)
+#define FLAGS_TX_ERROR_CHECK            (1<<12)
 
         /* preemphasis values for the rx side */
         u16 rx_preemphasis[4];
@@ -276,7 +278,6 @@ struct link_vars {
 #define PHY_PHYSICAL_LINK_FLAG          (1<<2)
 #define PHY_HALF_OPEN_CONN_FLAG         (1<<3)
 #define PHY_OVER_CURRENT_FLAG           (1<<4)
-#define PHY_TX_ERROR_CHECK_FLAG         (1<<5)
 
         u8 mac_type;
 #define MAC_TYPE_NONE           0
diff --git a/drivers/net/bnx2x/bnx2x_main.c b/drivers/net/bnx2x/bnx2x_main.c
index 150709111548..f74582a22c68 100644
--- a/drivers/net/bnx2x/bnx2x_main.c
+++ b/drivers/net/bnx2x/bnx2x_main.c
@@ -5798,6 +5798,12 @@ static int bnx2x_init_hw_common(struct bnx2x *bp)
 
         DP(BNX2X_MSG_MCP, "starting common init  func %d\n", BP_ABS_FUNC(bp));
 
+        /*
+         * take the UNDI lock to protect undi_unload flow from accessing
+         * registers while we're resetting the chip
+         */
+        bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_UNDI);
+
         bnx2x_reset_common(bp);
         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET, 0xffffffff);
 
@@ -5808,6 +5814,8 @@ static int bnx2x_init_hw_common(struct bnx2x *bp)
         }
         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_SET, val);
 
+        bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_UNDI);
+
         bnx2x_init_block(bp, BLOCK_MISC, PHASE_COMMON);
 
         if (!CHIP_IS_E1x(bp)) {
@@ -10251,10 +10259,17 @@ static int __devinit bnx2x_init_dev(struct pci_dev *pdev,
         /* clean indirect addresses */
         pci_write_config_dword(bp->pdev, PCICFG_GRC_ADDRESS,
                                PCICFG_VENDOR_ID_OFFSET);
-        REG_WR(bp, PXP2_REG_PGL_ADDR_88_F0 + BP_PORT(bp)*16, 0);
-        REG_WR(bp, PXP2_REG_PGL_ADDR_8C_F0 + BP_PORT(bp)*16, 0);
-        REG_WR(bp, PXP2_REG_PGL_ADDR_90_F0 + BP_PORT(bp)*16, 0);
-        REG_WR(bp, PXP2_REG_PGL_ADDR_94_F0 + BP_PORT(bp)*16, 0);
+        /* Clean the following indirect addresses for all functions since it
+         * is not used by the driver.
+         */
+        REG_WR(bp, PXP2_REG_PGL_ADDR_88_F0, 0);
+        REG_WR(bp, PXP2_REG_PGL_ADDR_8C_F0, 0);
+        REG_WR(bp, PXP2_REG_PGL_ADDR_90_F0, 0);
+        REG_WR(bp, PXP2_REG_PGL_ADDR_94_F0, 0);
+        REG_WR(bp, PXP2_REG_PGL_ADDR_88_F1, 0);
+        REG_WR(bp, PXP2_REG_PGL_ADDR_8C_F1, 0);
+        REG_WR(bp, PXP2_REG_PGL_ADDR_90_F1, 0);
+        REG_WR(bp, PXP2_REG_PGL_ADDR_94_F1, 0);
 
         /*
          * Enable internal target-read (in case we are probed after PF FLR).
diff --git a/drivers/net/bnx2x/bnx2x_reg.h b/drivers/net/bnx2x/bnx2x_reg.h
index 02461fef8751..40266c14e6dc 100644
--- a/drivers/net/bnx2x/bnx2x_reg.h
+++ b/drivers/net/bnx2x/bnx2x_reg.h
@@ -3007,11 +3007,27 @@
 /* [R 6] Debug only: Number of used entries in the data FIFO */
 #define PXP2_REG_HST_DATA_FIFO_STATUS                            0x12047c
 /* [R 7] Debug only: Number of used entries in the header FIFO */
-#define PXP2_REG_HST_HEADER_FIFO_STATUS                          0x120478
-#define PXP2_REG_PGL_ADDR_88_F0                                  0x120534
-#define PXP2_REG_PGL_ADDR_8C_F0                                  0x120538
-#define PXP2_REG_PGL_ADDR_90_F0                                  0x12053c
-#define PXP2_REG_PGL_ADDR_94_F0                                  0x120540
+#define PXP2_REG_HST_HEADER_FIFO_STATUS                          0x120478
+#define PXP2_REG_PGL_ADDR_88_F0                                  0x120534
+/* [R 32] GRC address for configuration access to PCIE config address 0x88.
+ * any write to this PCIE address will cause a GRC write access to the
+ * address that's in t this register */
+#define PXP2_REG_PGL_ADDR_88_F1                                  0x120544
+#define PXP2_REG_PGL_ADDR_8C_F0                                  0x120538
+/* [R 32] GRC address for configuration access to PCIE config address 0x8c.
+ * any write to this PCIE address will cause a GRC write access to the
+ * address that's in t this register */
+#define PXP2_REG_PGL_ADDR_8C_F1                                  0x120548
+#define PXP2_REG_PGL_ADDR_90_F0                                  0x12053c
+/* [R 32] GRC address for configuration access to PCIE config address 0x90.
+ * any write to this PCIE address will cause a GRC write access to the
+ * address that's in t this register */
+#define PXP2_REG_PGL_ADDR_90_F1                                  0x12054c
+#define PXP2_REG_PGL_ADDR_94_F0                                  0x120540
+/* [R 32] GRC address for configuration access to PCIE config address 0x94.
+ * any write to this PCIE address will cause a GRC write access to the
+ * address that's in t this register */
+#define PXP2_REG_PGL_ADDR_94_F1                                  0x120550
 #define PXP2_REG_PGL_CONTROL0                                    0x120490
 #define PXP2_REG_PGL_CONTROL1                                    0x120514
 #define PXP2_REG_PGL_DEBUG                                       0x120520
@@ -4771,9 +4787,11 @@
    The fields are: [4:0] - tail pointer; 10:5] - Link List size; 15:11] -
    header pointer. */
 #define UCM_REG_XX_TABLE                                         0xe0300
+#define UMAC_COMMAND_CONFIG_REG_IGNORE_TX_PAUSE                  (0x1<<28)
 #define UMAC_COMMAND_CONFIG_REG_LOOP_ENA                         (0x1<<15)
 #define UMAC_COMMAND_CONFIG_REG_NO_LGTH_CHECK                    (0x1<<24)
 #define UMAC_COMMAND_CONFIG_REG_PAD_EN                           (0x1<<5)
+#define UMAC_COMMAND_CONFIG_REG_PAUSE_IGNORE                     (0x1<<8)
 #define UMAC_COMMAND_CONFIG_REG_PROMIS_EN                        (0x1<<4)
 #define UMAC_COMMAND_CONFIG_REG_RX_ENA                           (0x1<<1)
 #define UMAC_COMMAND_CONFIG_REG_SW_RESET                         (0x1<<13)
@@ -5622,8 +5640,9 @@
 #define EMAC_MDIO_COMM_START_BUSY                                (1L<<29)
 #define EMAC_MDIO_MODE_AUTO_POLL                                 (1L<<4)
 #define EMAC_MDIO_MODE_CLAUSE_45                                 (1L<<31)
-#define EMAC_MDIO_MODE_CLOCK_CNT                                 (0x3fL<<16)
+#define EMAC_MDIO_MODE_CLOCK_CNT                                 (0x3ffL<<16)
 #define EMAC_MDIO_MODE_CLOCK_CNT_BITSHIFT                        16
+#define EMAC_MDIO_STATUS_10MB                                    (1L<<1)
 #define EMAC_MODE_25G_MODE                                       (1L<<5)
 #define EMAC_MODE_HALF_DUPLEX                                    (1L<<1)
 #define EMAC_MODE_PORT_GMII                                      (2L<<2)
@@ -5634,6 +5653,7 @@
 #define EMAC_REG_EMAC_MAC_MATCH                                  0x10
 #define EMAC_REG_EMAC_MDIO_COMM                                  0xac
 #define EMAC_REG_EMAC_MDIO_MODE                                  0xb4
+#define EMAC_REG_EMAC_MDIO_STATUS                                0xb0
 #define EMAC_REG_EMAC_MODE                                       0x0
 #define EMAC_REG_EMAC_RX_MODE                                    0xc8
 #define EMAC_REG_EMAC_RX_MTU_SIZE                                0x9c
diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c
index 38a83acd502e..43f2ea541088 100644
--- a/drivers/net/bonding/bond_main.c
+++ b/drivers/net/bonding/bond_main.c
@@ -3419,9 +3419,27 @@ static int bond_xmit_hash_policy_l2(struct sk_buff *skb, int count)
 static int bond_open(struct net_device *bond_dev)
 {
         struct bonding *bond = netdev_priv(bond_dev);
+        struct slave *slave;
+        int i;
 
         bond->kill_timers = 0;
 
+        /* reset slave->backup and slave->inactive */
+        read_lock(&bond->lock);
+        if (bond->slave_cnt > 0) {
+                read_lock(&bond->curr_slave_lock);
+                bond_for_each_slave(bond, slave, i) {
+                        if ((bond->params.mode == BOND_MODE_ACTIVEBACKUP)
+                                && (slave != bond->curr_active_slave)) {
+                                bond_set_slave_inactive_flags(slave);
+                        } else {
+                                bond_set_slave_active_flags(slave);
+                        }
+                }
+                read_unlock(&bond->curr_slave_lock);
+        }
+        read_unlock(&bond->lock);
+
         INIT_DELAYED_WORK(&bond->mcast_work, bond_resend_igmp_join_requests_delayed);
 
         if (bond_is_lb(bond)) {
diff --git a/drivers/net/can/sja1000/plx_pci.c b/drivers/net/can/sja1000/plx_pci.c
index 231385b8e08f..c7f3d4ea1167 100644
--- a/drivers/net/can/sja1000/plx_pci.c
+++ b/drivers/net/can/sja1000/plx_pci.c
@@ -408,7 +408,7 @@ static void plx_pci_del_card(struct pci_dev *pdev)
         struct sja1000_priv *priv;
         int i = 0;
 
-        for (i = 0; i < card->channels; i++) {
+        for (i = 0; i < PLX_PCI_MAX_CHAN; i++) {
                 dev = card->net_dev[i];
                 if (!dev)
                         continue;
@@ -536,7 +536,6 @@ static int __devinit plx_pci_add_card(struct pci_dev *pdev,
                         if (err) {
                                 dev_err(&pdev->dev, "Registering device failed "
                                         "(err=%d)\n", err);
-                                free_sja1000dev(dev);
                                 goto failure_cleanup;
                         }
 
@@ -549,6 +548,7 @@ static int __devinit plx_pci_add_card(struct pci_dev *pdev,
                         dev_err(&pdev->dev, "Channel #%d not detected\n",
                                 i + 1);
                         free_sja1000dev(dev);
+                        card->net_dev[i] = NULL;
                 }
         }
 
diff --git a/drivers/net/can/slcan.c b/drivers/net/can/slcan.c
index f523f1cc5142..4b70b7e8bdeb 100644
--- a/drivers/net/can/slcan.c
+++ b/drivers/net/can/slcan.c
@@ -197,7 +197,7 @@ static void slc_bump(struct slcan *sl)
         skb->ip_summed = CHECKSUM_UNNECESSARY;
         memcpy(skb_put(skb, sizeof(struct can_frame)),
                &cf, sizeof(struct can_frame));
-        netif_rx(skb);
+        netif_rx_ni(skb);
 
         sl->dev->stats.rx_packets++;
         sl->dev->stats.rx_bytes += cf.can_dlc;
diff --git a/drivers/net/can/ti_hecc.c b/drivers/net/can/ti_hecc.c
index f7bbde9eb2cb..a81249246ece 100644
--- a/drivers/net/can/ti_hecc.c
+++ b/drivers/net/can/ti_hecc.c
@@ -503,9 +503,9 @@ static netdev_tx_t ti_hecc_xmit(struct sk_buff *skb, struct net_device *ndev)
         spin_unlock_irqrestore(&priv->mbx_lock, flags);
 
         /* Prepare mailbox for transmission */
+        data = cf->can_dlc | (get_tx_head_prio(priv) << 8);
         if (cf->can_id & CAN_RTR_FLAG) /* Remote transmission request */
                 data |= HECC_CANMCF_RTR;
-        data |= get_tx_head_prio(priv) << 8;
         hecc_write_mbx(priv, mbxno, HECC_CANMCF, data);
 
         if (cf->can_id & CAN_EFF_FLAG) /* Extended frame format */
@@ -923,6 +923,7 @@ static int ti_hecc_probe(struct platform_device *pdev)
         priv->can.do_get_state = ti_hecc_get_state;
         priv->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES;
 
+        spin_lock_init(&priv->mbx_lock);
         ndev->irq = irq->start;
         ndev->flags |= IFF_ECHO;
         platform_set_drvdata(pdev, ndev);
diff --git a/drivers/net/cassini.c b/drivers/net/cassini.c
index 646c86bcc545..fdb7a1756409 100644
--- a/drivers/net/cassini.c
+++ b/drivers/net/cassini.c
@@ -2452,14 +2452,13 @@ static irqreturn_t cas_interruptN(int irq, void *dev_id)
         struct net_device *dev = dev_id;
         struct cas *cp = netdev_priv(dev);
         unsigned long flags;
-        int ring;
+        int ring = (irq == cp->pci_irq_INTC) ? 2 : 3;
         u32 status = readl(cp->regs + REG_PLUS_INTRN_STATUS(ring));
 
         /* check for shared irq */
         if (status == 0)
                 return IRQ_NONE;
 
-        ring = (irq == cp->pci_irq_INTC) ? 2 : 3;
         spin_lock_irqsave(&cp->lock, flags);
         if (status & INTR_RX_DONE_ALT) { /* handle rx separately */
 #ifdef USE_NAPI
diff --git a/drivers/net/e1000/e1000_ethtool.c b/drivers/net/e1000/e1000_ethtool.c
index c5f0f04219f3..5548d464261a 100644
--- a/drivers/net/e1000/e1000_ethtool.c
+++ b/drivers/net/e1000/e1000_ethtool.c
@@ -838,6 +838,7 @@ static int e1000_intr_test(struct e1000_adapter *adapter, u64 *data)
 
         /* Disable all the interrupts */
         ew32(IMC, 0xFFFFFFFF);
+        E1000_WRITE_FLUSH();
         msleep(10);
 
         /* Test each interrupt */
@@ -856,6 +857,7 @@ static int e1000_intr_test(struct e1000_adapter *adapter, u64 *data)
                         adapter->test_icr = 0;
                         ew32(IMC, mask);
                         ew32(ICS, mask);
+                        E1000_WRITE_FLUSH();
                         msleep(10);
 
                         if (adapter->test_icr & mask) {
@@ -873,6 +875,7 @@ static int e1000_intr_test(struct e1000_adapter *adapter, u64 *data)
                 adapter->test_icr = 0;
                 ew32(IMS, mask);
                 ew32(ICS, mask);
+                E1000_WRITE_FLUSH();
                 msleep(10);
 
                 if (!(adapter->test_icr & mask)) {
@@ -890,6 +893,7 @@ static int e1000_intr_test(struct e1000_adapter *adapter, u64 *data)
                         adapter->test_icr = 0;
                         ew32(IMC, ~mask & 0x00007FFF);
                         ew32(ICS, ~mask & 0x00007FFF);
+                        E1000_WRITE_FLUSH();
                         msleep(10);
 
                         if (adapter->test_icr) {
@@ -901,6 +905,7 @@ static int e1000_intr_test(struct e1000_adapter *adapter, u64 *data)
 
         /* Disable all the interrupts */
         ew32(IMC, 0xFFFFFFFF);
+        E1000_WRITE_FLUSH();
         msleep(10);
 
         /* Unhook test interrupt handler */
@@ -1394,6 +1399,7 @@ static int e1000_run_loopback_test(struct e1000_adapter *adapter)
                         if (unlikely(++k == txdr->count)) k = 0;
                 }
                 ew32(TDT, k);
+                E1000_WRITE_FLUSH();
                 msleep(200);
                 time = jiffies; /* set the start time for the receive */
                 good_cnt = 0;
diff --git a/drivers/net/e1000/e1000_hw.c b/drivers/net/e1000/e1000_hw.c
index 1698622af434..8545c7aa93eb 100644
--- a/drivers/net/e1000/e1000_hw.c
+++ b/drivers/net/e1000/e1000_hw.c
@@ -446,6 +446,7 @@ s32 e1000_reset_hw(struct e1000_hw *hw)
         /* Must reset the PHY before resetting the MAC */
         if ((hw->mac_type == e1000_82541) || (hw->mac_type == e1000_82547)) {
                 ew32(CTRL, (ctrl | E1000_CTRL_PHY_RST));
+                E1000_WRITE_FLUSH();
                 msleep(5);
         }
 
@@ -3752,6 +3753,7 @@ static s32 e1000_acquire_eeprom(struct e1000_hw *hw)
                 /* Clear SK and CS */
                 eecd &= ~(E1000_EECD_CS | E1000_EECD_SK);
                 ew32(EECD, eecd);
+                E1000_WRITE_FLUSH();
                 udelay(1);
         }
 
@@ -3824,6 +3826,7 @@ static void e1000_release_eeprom(struct e1000_hw *hw)
                 eecd &= ~E1000_EECD_SK; /* Lower SCK */
 
                 ew32(EECD, eecd);
+                E1000_WRITE_FLUSH();
 
                 udelay(hw->eeprom.delay_usec);
         } else if (hw->eeprom.type == e1000_eeprom_microwire) {
diff --git a/drivers/net/e1000e/82571.c b/drivers/net/e1000e/82571.c
index 480f2592f8a5..536b3a55c45f 100644
--- a/drivers/net/e1000e/82571.c
+++ b/drivers/net/e1000e/82571.c
@@ -2085,7 +2085,8 @@ struct e1000_info e1000_82574_info = {
                                   | FLAG_HAS_AMT
                                   | FLAG_HAS_CTRLEXT_ON_LOAD,
         .flags2                   = FLAG2_CHECK_PHY_HANG
-                                  | FLAG2_DISABLE_ASPM_L0S,
+                                  | FLAG2_DISABLE_ASPM_L0S
+                                  | FLAG2_NO_DISABLE_RX,
         .pba                    = 32,
         .max_hw_frame_size      = DEFAULT_JUMBO,
         .get_variants           = e1000_get_variants_82571,
@@ -2104,7 +2105,8 @@ struct e1000_info e1000_82583_info = {
                                   | FLAG_HAS_AMT
                                   | FLAG_HAS_JUMBO_FRAMES
                                   | FLAG_HAS_CTRLEXT_ON_LOAD,
-        .flags2                 = FLAG2_DISABLE_ASPM_L0S,
+        .flags2                 = FLAG2_DISABLE_ASPM_L0S
+                                  | FLAG2_NO_DISABLE_RX,
         .pba                    = 32,
         .max_hw_frame_size      = DEFAULT_JUMBO,
         .get_variants           = e1000_get_variants_82571,
diff --git a/drivers/net/e1000e/e1000.h b/drivers/net/e1000e/e1000.h
index 638d175792cf..8533ad7f3559 100644
--- a/drivers/net/e1000e/e1000.h
+++ b/drivers/net/e1000e/e1000.h
@@ -155,6 +155,9 @@ struct e1000_info;
 #define HV_M_STATUS_SPEED_1000            0x0200
 #define HV_M_STATUS_LINK_UP               0x0040
 
+#define E1000_ICH_FWSM_PCIM2PCI         0x01000000 /* ME PCIm-to-PCI active */
+#define E1000_ICH_FWSM_PCIM2PCI_COUNT   2000
+
 /* Time to wait before putting the device into D3 if there's no link (in ms). */
 #define LINK_TIMEOUT            100
 
@@ -453,6 +456,8 @@ struct e1000_info {
 #define FLAG2_DISABLE_ASPM_L0S            (1 << 7)
 #define FLAG2_DISABLE_AIM                 (1 << 8)
 #define FLAG2_CHECK_PHY_HANG              (1 << 9)
+#define FLAG2_NO_DISABLE_RX               (1 << 10)
+#define FLAG2_PCIM2PCI_ARBITER_WA         (1 << 11)
 
 #define E1000_RX_DESC_PS(R, i)      \
         (&(((union e1000_rx_desc_packet_split *)((R).desc))[i]))
diff --git a/drivers/net/e1000e/es2lan.c b/drivers/net/e1000e/es2lan.c
index c0ecb2d9fdb7..e4f42257c24c 100644
--- a/drivers/net/e1000e/es2lan.c
+++ b/drivers/net/e1000e/es2lan.c
@@ -1313,6 +1313,7 @@ static s32 e1000_read_kmrn_reg_80003es2lan(struct e1000_hw *hw, u32 offset,
         kmrnctrlsta = ((offset << E1000_KMRNCTRLSTA_OFFSET_SHIFT) &
                        E1000_KMRNCTRLSTA_OFFSET) | E1000_KMRNCTRLSTA_REN;
         ew32(KMRNCTRLSTA, kmrnctrlsta);
+        e1e_flush();
 
         udelay(2);
 
@@ -1347,6 +1348,7 @@ static s32 e1000_write_kmrn_reg_80003es2lan(struct e1000_hw *hw, u32 offset,
         kmrnctrlsta = ((offset << E1000_KMRNCTRLSTA_OFFSET_SHIFT) &
                        E1000_KMRNCTRLSTA_OFFSET) | data;
         ew32(KMRNCTRLSTA, kmrnctrlsta);
+        e1e_flush();
 
         udelay(2);
 
diff --git a/drivers/net/e1000e/ethtool.c b/drivers/net/e1000e/ethtool.c
index cb1a3623253e..6a0526a59a8a 100644
--- a/drivers/net/e1000e/ethtool.c
+++ b/drivers/net/e1000e/ethtool.c
@@ -28,8 +28,8 @@
 
 /* ethtool support for e1000 */
 
-#include <linux/interrupt.h>
 #include <linux/netdevice.h>
+#include <linux/interrupt.h>
 #include <linux/ethtool.h>
 #include <linux/pci.h>
 #include <linux/slab.h>
@@ -964,6 +964,7 @@ static int e1000_intr_test(struct e1000_adapter *adapter, u64 *data)
 
         /* Disable all the interrupts */
         ew32(IMC, 0xFFFFFFFF);
+        e1e_flush();
         usleep_range(10000, 20000);
 
         /* Test each interrupt */
@@ -996,6 +997,7 @@ static int e1000_intr_test(struct e1000_adapter *adapter, u64 *data)
                         adapter->test_icr = 0;
                         ew32(IMC, mask);
                         ew32(ICS, mask);
+                        e1e_flush();
                         usleep_range(10000, 20000);
 
                         if (adapter->test_icr & mask) {
@@ -1014,6 +1016,7 @@ static int e1000_intr_test(struct e1000_adapter *adapter, u64 *data)
                 adapter->test_icr = 0;
                 ew32(IMS, mask);
                 ew32(ICS, mask);
+                e1e_flush();
                 usleep_range(10000, 20000);
 
                 if (!(adapter->test_icr & mask)) {
@@ -1032,6 +1035,7 @@ static int e1000_intr_test(struct e1000_adapter *adapter, u64 *data)
                         adapter->test_icr = 0;
                         ew32(IMC, ~mask & 0x00007FFF);
                         ew32(ICS, ~mask & 0x00007FFF);
+                        e1e_flush();
                         usleep_range(10000, 20000);
 
                         if (adapter->test_icr) {
@@ -1043,6 +1047,7 @@ static int e1000_intr_test(struct e1000_adapter *adapter, u64 *data)
 
         /* Disable all the interrupts */
         ew32(IMC, 0xFFFFFFFF);
+        e1e_flush();
         usleep_range(10000, 20000);
 
         /* Unhook test interrupt handler */
@@ -1201,7 +1206,8 @@ static int e1000_setup_desc_rings(struct e1000_adapter *adapter)
         rx_ring->next_to_clean = 0;
 
         rctl = er32(RCTL);
-        ew32(RCTL, rctl & ~E1000_RCTL_EN);
+        if (!(adapter->flags2 & FLAG2_NO_DISABLE_RX))
+                ew32(RCTL, rctl & ~E1000_RCTL_EN);
         ew32(RDBAL, ((u64) rx_ring->dma & 0xFFFFFFFF));
         ew32(RDBAH, ((u64) rx_ring->dma >> 32));
         ew32(RDLEN, rx_ring->size);
@@ -1276,6 +1282,7 @@ static int e1000_integrated_phy_loopback(struct e1000_adapter *adapter)
                              E1000_CTRL_FD);     /* Force Duplex to FULL */
 
                 ew32(CTRL, ctrl_reg);
+                e1e_flush();
                 udelay(500);
 
                 return 0;
@@ -1418,6 +1425,7 @@ static int e1000_set_82571_fiber_loopback(struct e1000_adapter *adapter)
          */
 #define E1000_SERDES_LB_ON 0x410
         ew32(SCTL, E1000_SERDES_LB_ON);
+        e1e_flush();
         usleep_range(10000, 20000);
 
         return 0;
@@ -1513,6 +1521,7 @@ static void e1000_loopback_cleanup(struct e1000_adapter *adapter)
                     hw->phy.media_type == e1000_media_type_internal_serdes) {
 #define E1000_SERDES_LB_OFF 0x400
                         ew32(SCTL, E1000_SERDES_LB_OFF);
+                        e1e_flush();
                         usleep_range(10000, 20000);
                         break;
                 }
@@ -1592,6 +1601,7 @@ static int e1000_run_loopback_test(struct e1000_adapter *adapter)
                                 k = 0;
                 }
                 ew32(TDT, k);
+                e1e_flush();
                 msleep(200);
                 time = jiffies; /* set the start time for the receive */
                 good_cnt = 0;
diff --git a/drivers/net/e1000e/ich8lan.c b/drivers/net/e1000e/ich8lan.c
index c1752124f3cd..54add27c8f76 100644
--- a/drivers/net/e1000e/ich8lan.c
+++ b/drivers/net/e1000e/ich8lan.c
@@ -137,8 +137,9 @@
 #define HV_PM_CTRL              PHY_REG(770, 17)
 
 /* PHY Low Power Idle Control */
-#define I82579_LPI_CTRL                 PHY_REG(772, 20)
-#define I82579_LPI_CTRL_ENABLE_MASK     0x6000
+#define I82579_LPI_CTRL                         PHY_REG(772, 20)
+#define I82579_LPI_CTRL_ENABLE_MASK             0x6000
+#define I82579_LPI_CTRL_FORCE_PLL_LOCK_COUNT    0x80
 
 /* EMI Registers */
 #define I82579_EMI_ADDR         0x10
@@ -163,6 +164,11 @@
 #define HV_KMRN_MODE_CTRL      PHY_REG(769, 16)
 #define HV_KMRN_MDIO_SLOW      0x0400
 
+/* KMRN FIFO Control and Status */
+#define HV_KMRN_FIFO_CTRLSTA                  PHY_REG(770, 16)
+#define HV_KMRN_FIFO_CTRLSTA_PREAMBLE_MASK    0x7000
+#define HV_KMRN_FIFO_CTRLSTA_PREAMBLE_SHIFT   12
+
 /* ICH GbE Flash Hardware Sequencing Flash Status Register bit breakdown */
 /* Offset 04h HSFSTS */
 union ich8_hws_flash_status {
@@ -283,6 +289,7 @@ static void e1000_toggle_lanphypc_value_ich8lan(struct e1000_hw *hw)
         ctrl |= E1000_CTRL_LANPHYPC_OVERRIDE;
         ctrl &= ~E1000_CTRL_LANPHYPC_VALUE;
         ew32(CTRL, ctrl);
+        e1e_flush();
         udelay(10);
         ctrl &= ~E1000_CTRL_LANPHYPC_OVERRIDE;
         ew32(CTRL, ctrl);
@@ -656,6 +663,7 @@ static s32 e1000_check_for_copper_link_ich8lan(struct e1000_hw *hw)
         struct e1000_mac_info *mac = &hw->mac;
         s32 ret_val;
         bool link;
+        u16 phy_reg;
 
         /*
          * We only want to go out to the PHY registers to see if Auto-Neg
@@ -688,16 +696,35 @@ static s32 e1000_check_for_copper_link_ich8lan(struct e1000_hw *hw)
 
         mac->get_link_status = false;
 
-        if (hw->phy.type == e1000_phy_82578) {
-                ret_val = e1000_link_stall_workaround_hv(hw);
-                if (ret_val)
-                        goto out;
-        }
-
-        if (hw->mac.type == e1000_pch2lan) {
+        switch (hw->mac.type) {
+        case e1000_pch2lan:
                 ret_val = e1000_k1_workaround_lv(hw);
                 if (ret_val)
                         goto out;
+                /* fall-thru */
+        case e1000_pchlan:
+                if (hw->phy.type == e1000_phy_82578) {
+                        ret_val = e1000_link_stall_workaround_hv(hw);
+                        if (ret_val)
+                                goto out;
+                }
+
+                /*
+                 * Workaround for PCHx parts in half-duplex:
+                 * Set the number of preambles removed from the packet
+                 * when it is passed from the PHY to the MAC to prevent
+                 * the MAC from misinterpreting the packet type.
+                 */
+                e1e_rphy(hw, HV_KMRN_FIFO_CTRLSTA, &phy_reg);
+                phy_reg &= ~HV_KMRN_FIFO_CTRLSTA_PREAMBLE_MASK;
+
+                if ((er32(STATUS) & E1000_STATUS_FD) != E1000_STATUS_FD)
+                        phy_reg |= (1 << HV_KMRN_FIFO_CTRLSTA_PREAMBLE_SHIFT);
+
+                e1e_wphy(hw, HV_KMRN_FIFO_CTRLSTA, phy_reg);
+                break;
+        default:
+                break;
         }
 
         /*
@@ -787,6 +814,11 @@ static s32 e1000_get_variants_ich8lan(struct e1000_adapter *adapter)
             (adapter->hw.phy.type == e1000_phy_igp_3))
                 adapter->flags |= FLAG_LSC_GIG_SPEED_DROP;
 
+        /* Enable workaround for 82579 w/ ME enabled */
+        if ((adapter->hw.mac.type == e1000_pch2lan) &&
+            (er32(FWSM) & E1000_ICH_FWSM_FW_VALID))
+                adapter->flags2 |= FLAG2_PCIM2PCI_ARBITER_WA;
+
         /* Disable EEE by default until IEEE802.3az spec is finalized */
         if (adapter->flags2 & FLAG2_HAS_EEE)
                 adapter->hw.dev_spec.ich8lan.eee_disable = true;
@@ -1230,9 +1262,11 @@ s32 e1000_configure_k1_ich8lan(struct e1000_hw *hw, bool k1_enable)
         ew32(CTRL, reg);
 
         ew32(CTRL_EXT, ctrl_ext | E1000_CTRL_EXT_SPD_BYPS);
+        e1e_flush();
         udelay(20);
         ew32(CTRL, ctrl_reg);
         ew32(CTRL_EXT, ctrl_ext);
+        e1e_flush();
         udelay(20);
 
 out:
@@ -1352,7 +1386,7 @@ static s32 e1000_hv_phy_workarounds_ich8lan(struct e1000_hw *hw)
                         return ret_val;
 
                 /* Preamble tuning for SSC */
-                ret_val = e1e_wphy(hw, PHY_REG(770, 16), 0xA204);
+                ret_val = e1e_wphy(hw, HV_KMRN_FIFO_CTRLSTA, 0xA204);
                 if (ret_val)
                         return ret_val;
         }
@@ -1642,6 +1676,7 @@ static s32 e1000_k1_workaround_lv(struct e1000_hw *hw)
         s32 ret_val = 0;
         u16 status_reg = 0;
         u32 mac_reg;
+        u16 phy_reg;
 
         if (hw->mac.type != e1000_pch2lan)
                 goto out;
@@ -1656,12 +1691,19 @@ static s32 e1000_k1_workaround_lv(struct e1000_hw *hw)
                 mac_reg = er32(FEXTNVM4);
                 mac_reg &= ~E1000_FEXTNVM4_BEACON_DURATION_MASK;
 
-                if (status_reg & HV_M_STATUS_SPEED_1000)
+                ret_val = e1e_rphy(hw, I82579_LPI_CTRL, &phy_reg);
+                if (ret_val)
+                        goto out;
+
+                if (status_reg & HV_M_STATUS_SPEED_1000) {
                         mac_reg |= E1000_FEXTNVM4_BEACON_DURATION_8USEC;
-                else
+                        phy_reg &= ~I82579_LPI_CTRL_FORCE_PLL_LOCK_COUNT;
+                } else {
                         mac_reg |= E1000_FEXTNVM4_BEACON_DURATION_16USEC;
-
+                        phy_reg |= I82579_LPI_CTRL_FORCE_PLL_LOCK_COUNT;
+                }
                 ew32(FEXTNVM4, mac_reg);
+                ret_val = e1e_wphy(hw, I82579_LPI_CTRL, phy_reg);
         }
 
 out:
@@ -2134,8 +2176,7 @@ static s32 e1000_read_nvm_ich8lan(struct e1000_hw *hw, u16 offset, u16 words,
 
         ret_val = 0;
         for (i = 0; i < words; i++) {
-                if ((dev_spec->shadow_ram) &&
-                    (dev_spec->shadow_ram[offset+i].modified)) {
+                if (dev_spec->shadow_ram[offset+i].modified) {
                         data[i] = dev_spec->shadow_ram[offset+i].value;
                 } else {
                         ret_val = e1000_read_flash_word_ich8lan(hw,
@@ -3090,6 +3131,7 @@ static s32 e1000_reset_hw_ich8lan(struct e1000_hw *hw)
         ret_val = e1000_acquire_swflag_ich8lan(hw);
         e_dbg("Issuing a global reset to ich8lan\n");
         ew32(CTRL, (ctrl | E1000_CTRL_RST));
+        /* cannot issue a flush here because it hangs the hardware */
         msleep(20);
 
         if (!ret_val)
diff --git a/drivers/net/e1000e/lib.c b/drivers/net/e1000e/lib.c
index 65580b405942..0893ab107adf 100644
--- a/drivers/net/e1000e/lib.c
+++ b/drivers/net/e1000e/lib.c
@@ -190,7 +190,8 @@ s32 e1000_check_alt_mac_addr_generic(struct e1000_hw *hw)
         /* Check for LOM (vs. NIC) or one of two valid mezzanine cards */
         if (!((nvm_data & NVM_COMPAT_LOM) ||
               (hw->adapter->pdev->device == E1000_DEV_ID_82571EB_SERDES_DUAL) ||
-              (hw->adapter->pdev->device == E1000_DEV_ID_82571EB_SERDES_QUAD)))
+              (hw->adapter->pdev->device == E1000_DEV_ID_82571EB_SERDES_QUAD) ||
+              (hw->adapter->pdev->device == E1000_DEV_ID_82571EB_SERDES)))
                 goto out;
 
         ret_val = e1000_read_nvm(hw, NVM_ALT_MAC_ADDR_PTR, 1,
@@ -200,10 +201,10 @@ s32 e1000_check_alt_mac_addr_generic(struct e1000_hw *hw)
                 goto out;
         }
 
-        if (nvm_alt_mac_addr_offset == 0xFFFF) {
+        if ((nvm_alt_mac_addr_offset == 0xFFFF) ||
+            (nvm_alt_mac_addr_offset == 0x0000))
                 /* There is no Alternate MAC Address */
                 goto out;
-        }
 
         if (hw->bus.func == E1000_FUNC_1)
                 nvm_alt_mac_addr_offset += E1000_ALT_MAC_ADDRESS_OFFSET_LAN1;
@@ -1986,6 +1987,7 @@ static s32 e1000_ready_nvm_eeprom(struct e1000_hw *hw)
                 /* Clear SK and CS */
                 eecd &= ~(E1000_EECD_CS | E1000_EECD_SK);
                 ew32(EECD, eecd);
+                e1e_flush();
                 udelay(1);
 
                 /*
diff --git a/drivers/net/e1000e/netdev.c b/drivers/net/e1000e/netdev.c
index 4353ad56cf16..2198e615f241 100644
--- a/drivers/net/e1000e/netdev.c
+++ b/drivers/net/e1000e/netdev.c
@@ -31,12 +31,12 @@
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/init.h>
-#include <linux/interrupt.h>
 #include <linux/pci.h>
 #include <linux/vmalloc.h>
 #include <linux/pagemap.h>
 #include <linux/delay.h>
 #include <linux/netdevice.h>
+#include <linux/interrupt.h>
 #include <linux/tcp.h>
 #include <linux/ipv6.h>
 #include <linux/slab.h>
@@ -56,7 +56,7 @@
 
 #define DRV_EXTRAVERSION "-k"
 
-#define DRV_VERSION "1.3.16" DRV_EXTRAVERSION
+#define DRV_VERSION "1.4.4" DRV_EXTRAVERSION
 char e1000e_driver_name[] = "e1000e";
 const char e1000e_driver_version[] = DRV_VERSION;
 
@@ -519,6 +519,63 @@ static void e1000_rx_checksum(struct e1000_adapter *adapter, u32 status_err,
 }
 
 /**
+ * e1000e_update_tail_wa - helper function for e1000e_update_[rt]dt_wa()
+ * @hw: pointer to the HW structure
+ * @tail: address of tail descriptor register
+ * @i: value to write to tail descriptor register
+ *
+ * When updating the tail register, the ME could be accessing Host CSR
+ * registers at the same time.  Normally, this is handled in h/w by an
+ * arbiter but on some parts there is a bug that acknowledges Host accesses
+ * later than it should which could result in the descriptor register to
+ * have an incorrect value.  Workaround this by checking the FWSM register
+ * which has bit 24 set while ME is accessing Host CSR registers, wait
+ * if it is set and try again a number of times.
+ **/
+static inline s32 e1000e_update_tail_wa(struct e1000_hw *hw, u8 __iomem * tail,
+                                        unsigned int i)
+{
+        unsigned int j = 0;
+
+        while ((j++ < E1000_ICH_FWSM_PCIM2PCI_COUNT) &&
+               (er32(FWSM) & E1000_ICH_FWSM_PCIM2PCI))
+                udelay(50);
+
+        writel(i, tail);
+
+        if ((j == E1000_ICH_FWSM_PCIM2PCI_COUNT) && (i != readl(tail)))
+                return E1000_ERR_SWFW_SYNC;
+
+        return 0;
+}
+
+static void e1000e_update_rdt_wa(struct e1000_adapter *adapter, unsigned int i)
+{
+        u8 __iomem *tail = (adapter->hw.hw_addr + adapter->rx_ring->tail);
+        struct e1000_hw *hw = &adapter->hw;
+
+        if (e1000e_update_tail_wa(hw, tail, i)) {
+                u32 rctl = er32(RCTL);
+                ew32(RCTL, rctl & ~E1000_RCTL_EN);
+                e_err("ME firmware caused invalid RDT - resetting\n");
+                schedule_work(&adapter->reset_task);
+        }
+}
+
+static void e1000e_update_tdt_wa(struct e1000_adapter *adapter, unsigned int i)
+{
+        u8 __iomem *tail = (adapter->hw.hw_addr + adapter->tx_ring->tail);
+        struct e1000_hw *hw = &adapter->hw;
+
+        if (e1000e_update_tail_wa(hw, tail, i)) {
+                u32 tctl = er32(TCTL);
+                ew32(TCTL, tctl & ~E1000_TCTL_EN);
+                e_err("ME firmware caused invalid TDT - resetting\n");
+                schedule_work(&adapter->reset_task);
+        }
+}
+
+/**
  * e1000_alloc_rx_buffers - Replace used receive buffers; legacy & extended
  * @adapter: address of board private structure
  **/
@@ -573,7 +630,10 @@ map_skb:
                          * such as IA-64).
                          */
                         wmb();
-                        writel(i, adapter->hw.hw_addr + rx_ring->tail);
+                        if (adapter->flags2 & FLAG2_PCIM2PCI_ARBITER_WA)
+                                e1000e_update_rdt_wa(adapter, i);
+                        else
+                                writel(i, adapter->hw.hw_addr + rx_ring->tail);
                 }
                 i++;
                 if (i == rx_ring->count)
@@ -673,7 +733,11 @@ static void e1000_alloc_rx_buffers_ps(struct e1000_adapter *adapter,
                          * such as IA-64).
                          */
                         wmb();
-                        writel(i << 1, adapter->hw.hw_addr + rx_ring->tail);
+                        if (adapter->flags2 & FLAG2_PCIM2PCI_ARBITER_WA)
+                                e1000e_update_rdt_wa(adapter, i << 1);
+                        else
+                                writel(i << 1,
+                                       adapter->hw.hw_addr + rx_ring->tail);
                 }
 
                 i++;
@@ -756,7 +820,10 @@ check_page:
                  * applicable for weak-ordered memory model archs,
                  * such as IA-64). */
                 wmb();
-                writel(i, adapter->hw.hw_addr + rx_ring->tail);
+                if (adapter->flags2 & FLAG2_PCIM2PCI_ARBITER_WA)
+                        e1000e_update_rdt_wa(adapter, i);
+                else
+                        writel(i, adapter->hw.hw_addr + rx_ring->tail);
         }
 }
 
@@ -2915,7 +2982,8 @@ static void e1000_configure_rx(struct e1000_adapter *adapter)
 
         /* disable receives while setting up the descriptors */
         rctl = er32(RCTL);
-        ew32(RCTL, rctl & ~E1000_RCTL_EN);
+        if (!(adapter->flags2 & FLAG2_NO_DISABLE_RX))
+                ew32(RCTL, rctl & ~E1000_RCTL_EN);
         e1e_flush();
         usleep_range(10000, 20000);
 
@@ -3394,7 +3462,8 @@ void e1000e_down(struct e1000_adapter *adapter)
 
         /* disable receives in the hardware */
         rctl = er32(RCTL);
-        ew32(RCTL, rctl & ~E1000_RCTL_EN);
+        if (!(adapter->flags2 & FLAG2_NO_DISABLE_RX))
+                ew32(RCTL, rctl & ~E1000_RCTL_EN);
         /* flush and sleep below */
 
         netif_stop_queue(netdev);
@@ -3403,6 +3472,7 @@ void e1000e_down(struct e1000_adapter *adapter)
         tctl = er32(TCTL);
         tctl &= ~E1000_TCTL_EN;
         ew32(TCTL, tctl);
+
         /* flush both disables and wait for them to finish */
         e1e_flush();
         usleep_range(10000, 20000);
@@ -4686,7 +4756,12 @@ static void e1000_tx_queue(struct e1000_adapter *adapter,
         wmb();
 
         tx_ring->next_to_use = i;
-        writel(i, adapter->hw.hw_addr + tx_ring->tail);
+
+        if (adapter->flags2 & FLAG2_PCIM2PCI_ARBITER_WA)
+                e1000e_update_tdt_wa(adapter, i);
+        else
+                writel(i, adapter->hw.hw_addr + tx_ring->tail);
+
         /*
          * we need this if more than one processor can write to our tail
          * at a time, it synchronizes IO on IA64/Altix systems
diff --git a/drivers/net/e1000e/phy.c b/drivers/net/e1000e/phy.c
index 2a6ee13285b1..8666476cb9be 100644
--- a/drivers/net/e1000e/phy.c
+++ b/drivers/net/e1000e/phy.c
@@ -537,6 +537,7 @@ static s32 __e1000_read_kmrn_reg(struct e1000_hw *hw, u32 offset, u16 *data,
         kmrnctrlsta = ((offset << E1000_KMRNCTRLSTA_OFFSET_SHIFT) &
                        E1000_KMRNCTRLSTA_OFFSET) | E1000_KMRNCTRLSTA_REN;
         ew32(KMRNCTRLSTA, kmrnctrlsta);
+        e1e_flush();
 
         udelay(2);
 
@@ -609,6 +610,7 @@ static s32 __e1000_write_kmrn_reg(struct e1000_hw *hw, u32 offset, u16 data,
         kmrnctrlsta = ((offset << E1000_KMRNCTRLSTA_OFFSET_SHIFT) &
                        E1000_KMRNCTRLSTA_OFFSET) | data;
         ew32(KMRNCTRLSTA, kmrnctrlsta);
+        e1e_flush();
 
         udelay(2);
 
diff --git a/drivers/net/forcedeth.c b/drivers/net/forcedeth.c
index e55df308a3af..6d5fbd4d4256 100644
--- a/drivers/net/forcedeth.c
+++ b/drivers/net/forcedeth.c
@@ -5615,7 +5615,8 @@ static int __devinit nv_probe(struct pci_dev *pci_dev, const struct pci_device_i
                 goto out_error;
         }
 
-        nv_vlan_mode(dev, dev->features);
+        if (id->driver_data & DEV_HAS_VLAN)
+                nv_vlan_mode(dev, dev->features);
 
         netif_carrier_off(dev);
 
diff --git a/drivers/net/gianfar.c b/drivers/net/gianfar.c
index 2659daad783d..31d5c574e5a9 100644
--- a/drivers/net/gianfar.c
+++ b/drivers/net/gianfar.c
@@ -2710,8 +2710,13 @@ static int gfar_process_frame(struct net_device *dev, struct sk_buff *skb,
         /* Tell the skb what kind of packet this is */
         skb->protocol = eth_type_trans(skb, dev);
 
-        /* Set vlan tag */
-        if (fcb->flags & RXFCB_VLN)
+        /*
+         * There's need to check for NETIF_F_HW_VLAN_RX here.
+         * Even if vlan rx accel is disabled, on some chips
+         * RXFCB_VLN is pseudo randomly set.
+         */
+        if (dev->features & NETIF_F_HW_VLAN_RX &&
+            fcb->flags & RXFCB_VLN)
                 __vlan_hwaccel_put_tag(skb, fcb->vlctl);
 
         /* Send the packet up the stack */
diff --git a/drivers/net/gianfar_ethtool.c b/drivers/net/gianfar_ethtool.c
index 6e350692d118..25a8c2adb001 100644
--- a/drivers/net/gianfar_ethtool.c
+++ b/drivers/net/gianfar_ethtool.c
@@ -686,10 +686,21 @@ static int gfar_ethflow_to_filer_table(struct gfar_private *priv, u64 ethflow, u
 {
         unsigned int last_rule_idx = priv->cur_filer_idx;
         unsigned int cmp_rqfpr;
-        unsigned int local_rqfpr[MAX_FILER_IDX + 1];
-        unsigned int local_rqfcr[MAX_FILER_IDX + 1];
+        unsigned int *local_rqfpr;
+        unsigned int *local_rqfcr;
         int i = 0x0, k = 0x0;
         int j = MAX_FILER_IDX, l = 0x0;
+        int ret = 1;
+
+        local_rqfpr = kmalloc(sizeof(unsigned int) * (MAX_FILER_IDX + 1),
+                GFP_KERNEL);
+        local_rqfcr = kmalloc(sizeof(unsigned int) * (MAX_FILER_IDX + 1),
+                GFP_KERNEL);
+        if (!local_rqfpr || !local_rqfcr) {
+                pr_err("Out of memory\n");
+                ret = 0;
+                goto err;
+        }
 
         switch (class) {
         case TCP_V4_FLOW:
@@ -706,7 +717,8 @@ static int gfar_ethflow_to_filer_table(struct gfar_private *priv, u64 ethflow, u
                 break;
         default:
                 pr_err("Right now this class is not supported\n");
-                return 0;
+                ret = 0;
+                goto err;
         }
 
         for (i = 0; i < MAX_FILER_IDX + 1; i++) {
@@ -721,7 +733,8 @@ static int gfar_ethflow_to_filer_table(struct gfar_private *priv, u64 ethflow, u
 
         if (i == MAX_FILER_IDX + 1) {
                 pr_err("No parse rule found, can't create hash rules\n");
-                return 0;
+                ret = 0;
+                goto err;
         }
 
         /* If a match was found, then it begins the starting of a cluster rule
@@ -765,7 +778,10 @@ static int gfar_ethflow_to_filer_table(struct gfar_private *priv, u64 ethflow, u
                 priv->cur_filer_idx = priv->cur_filer_idx - 1;
         }
 
-        return 1;
+err:
+        kfree(local_rqfcr);
+        kfree(local_rqfpr);
+        return ret;
 }
 
 static int gfar_set_hash_opts(struct gfar_private *priv, struct ethtool_rxnfc *cmd)
diff --git a/drivers/net/gianfar_ptp.c b/drivers/net/gianfar_ptp.c
index 1c97861596f0..f67b8aebc89c 100644
--- a/drivers/net/gianfar_ptp.c
+++ b/drivers/net/gianfar_ptp.c
@@ -193,14 +193,9 @@ static void set_alarm(struct etsects *etsects)
 /* Caller must hold etsects->lock. */
 static void set_fipers(struct etsects *etsects)
 {
-        u32 tmr_ctrl = gfar_read(&etsects->regs->tmr_ctrl);
-
-        gfar_write(&etsects->regs->tmr_ctrl,   tmr_ctrl & (~TE));
-        gfar_write(&etsects->regs->tmr_prsc,   etsects->tmr_prsc);
+        set_alarm(etsects);
         gfar_write(&etsects->regs->tmr_fiper1, etsects->tmr_fiper1);
         gfar_write(&etsects->regs->tmr_fiper2, etsects->tmr_fiper2);
-        set_alarm(etsects);
-        gfar_write(&etsects->regs->tmr_ctrl,   tmr_ctrl|TE);
 }
 
 /*
@@ -511,7 +506,7 @@ static int gianfar_ptp_probe(struct platform_device *dev)
         gfar_write(&etsects->regs->tmr_fiper1, etsects->tmr_fiper1);
         gfar_write(&etsects->regs->tmr_fiper2, etsects->tmr_fiper2);
         set_alarm(etsects);
-        gfar_write(&etsects->regs->tmr_ctrl,   tmr_ctrl|FS|RTPE|TE);
+        gfar_write(&etsects->regs->tmr_ctrl,   tmr_ctrl|FS|RTPE|TE|FRD);
 
         spin_unlock_irqrestore(&etsects->lock, flags);
 
diff --git a/drivers/net/ibmveth.c b/drivers/net/ibmveth.c
index ba99af05bf62..3e6679269400 100644
--- a/drivers/net/ibmveth.c
+++ b/drivers/net/ibmveth.c
@@ -395,7 +395,7 @@ static inline struct sk_buff *ibmveth_rxq_get_buffer(struct ibmveth_adapter *ada
 }
 
 /* recycle the current buffer on the rx queue */
-static void ibmveth_rxq_recycle_buffer(struct ibmveth_adapter *adapter)
+static int ibmveth_rxq_recycle_buffer(struct ibmveth_adapter *adapter)
 {
         u32 q_index = adapter->rx_queue.index;
         u64 correlator = adapter->rx_queue.queue_addr[q_index].correlator;
@@ -403,6 +403,7 @@ static void ibmveth_rxq_recycle_buffer(struct ibmveth_adapter *adapter)
         unsigned int index = correlator & 0xffffffffUL;
         union ibmveth_buf_desc desc;
         unsigned long lpar_rc;
+        int ret = 1;
 
         BUG_ON(pool >= IBMVETH_NUM_BUFF_POOLS);
         BUG_ON(index >= adapter->rx_buff_pool[pool].size);
@@ -410,7 +411,7 @@ static void ibmveth_rxq_recycle_buffer(struct ibmveth_adapter *adapter)
         if (!adapter->rx_buff_pool[pool].active) {
                 ibmveth_rxq_harvest_buffer(adapter);
                 ibmveth_free_buffer_pool(adapter, &adapter->rx_buff_pool[pool]);
-                return;
+                goto out;
         }
 
         desc.fields.flags_len = IBMVETH_BUF_VALID |
@@ -423,12 +424,16 @@ static void ibmveth_rxq_recycle_buffer(struct ibmveth_adapter *adapter)
                 netdev_dbg(adapter->netdev, "h_add_logical_lan_buffer failed "
                            "during recycle rc=%ld", lpar_rc);
                 ibmveth_remove_buffer_from_pool(adapter, adapter->rx_queue.queue_addr[adapter->rx_queue.index].correlator);
+                ret = 0;
         }
 
         if (++adapter->rx_queue.index == adapter->rx_queue.num_slots) {
                 adapter->rx_queue.index = 0;
                 adapter->rx_queue.toggle = !adapter->rx_queue.toggle;
         }
+
+out:
+        return ret;
 }
 
 static void ibmveth_rxq_harvest_buffer(struct ibmveth_adapter *adapter)
@@ -1084,8 +1089,9 @@ restart_poll:
                                 if (rx_flush)
                                         ibmveth_flush_buffer(skb->data,
                                                 length + offset);
+                                if (!ibmveth_rxq_recycle_buffer(adapter))
+                                        kfree_skb(skb);
                                 skb = new_skb;
-                                ibmveth_rxq_recycle_buffer(adapter);
                         } else {
                                 ibmveth_rxq_harvest_buffer(adapter);
                                 skb_reserve(skb, offset);
diff --git a/drivers/net/igb/e1000_nvm.c b/drivers/net/igb/e1000_nvm.c
index 7dcd65cede56..40407124e722 100644
--- a/drivers/net/igb/e1000_nvm.c
+++ b/drivers/net/igb/e1000_nvm.c
@@ -285,6 +285,7 @@ static s32 igb_ready_nvm_eeprom(struct e1000_hw *hw)
                 /* Clear SK and CS */
                 eecd &= ~(E1000_EECD_CS | E1000_EECD_SK);
                 wr32(E1000_EECD, eecd);
+                wrfl();
                 udelay(1);
                 timeout = NVM_MAX_RETRY_SPI;
 
diff --git a/drivers/net/igb/igb_ethtool.c b/drivers/net/igb/igb_ethtool.c
index ff244ce803ce..414b0225be89 100644
--- a/drivers/net/igb/igb_ethtool.c
+++ b/drivers/net/igb/igb_ethtool.c
@@ -1225,6 +1225,7 @@ static int igb_intr_test(struct igb_adapter *adapter, u64 *data)
 
         /* Disable all the interrupts */
         wr32(E1000_IMC, ~0);
+        wrfl();
         msleep(10);
 
         /* Define all writable bits for ICS */
@@ -1268,6 +1269,7 @@ static int igb_intr_test(struct igb_adapter *adapter, u64 *data)
 
                         wr32(E1000_IMC, mask);
                         wr32(E1000_ICS, mask);
+                        wrfl();
                         msleep(10);
 
                         if (adapter->test_icr & mask) {
@@ -1289,6 +1291,7 @@ static int igb_intr_test(struct igb_adapter *adapter, u64 *data)
 
                 wr32(E1000_IMS, mask);
                 wr32(E1000_ICS, mask);
+                wrfl();
                 msleep(10);
 
                 if (!(adapter->test_icr & mask)) {
@@ -1310,6 +1313,7 @@ static int igb_intr_test(struct igb_adapter *adapter, u64 *data)
 
                         wr32(E1000_IMC, ~mask);
                         wr32(E1000_ICS, ~mask);
+                        wrfl();
                         msleep(10);
 
                         if (adapter->test_icr & mask) {
@@ -1321,6 +1325,7 @@ static int igb_intr_test(struct igb_adapter *adapter, u64 *data)
 
         /* Disable all the interrupts */
         wr32(E1000_IMC, ~0);
+        wrfl();
         msleep(10);
 
         /* Unhook test interrupt handler */
diff --git a/drivers/net/igb/igb_main.c b/drivers/net/igb/igb_main.c
index dc599059512a..40d4c405fd7e 100644
--- a/drivers/net/igb/igb_main.c
+++ b/drivers/net/igb/igb_main.c
@@ -1052,6 +1052,7 @@ msi_only:
                 kfree(adapter->vf_data);
                 adapter->vf_data = NULL;
                 wr32(E1000_IOVCTL, E1000_IOVCTL_REUSE_VFQ);
+                wrfl();
                 msleep(100);
                 dev_info(&adapter->pdev->dev, "IOV Disabled\n");
         }
@@ -2022,7 +2023,7 @@ static int __devinit igb_probe(struct pci_dev *pdev,
 
         if (hw->bus.func == 0)
                 hw->nvm.ops.read(hw, NVM_INIT_CONTROL3_PORT_A, 1, &eeprom_data);
-        else if (hw->mac.type == e1000_82580)
+        else if (hw->mac.type >= e1000_82580)
                 hw->nvm.ops.read(hw, NVM_INIT_CONTROL3_PORT_A +
                                  NVM_82580_LAN_FUNC_OFFSET(hw->bus.func), 1,
                                  &eeprom_data);
@@ -2198,6 +2199,7 @@ static void __devexit igb_remove(struct pci_dev *pdev)
                 kfree(adapter->vf_data);
                 adapter->vf_data = NULL;
                 wr32(E1000_IOVCTL, E1000_IOVCTL_REUSE_VFQ);
+                wrfl();
                 msleep(100);
                 dev_info(&pdev->dev, "IOV Disabled\n");
         }
diff --git a/drivers/net/igbvf/netdev.c b/drivers/net/igbvf/netdev.c
index 1330c8e932da..40ed066e3ef4 100644
--- a/drivers/net/igbvf/netdev.c
+++ b/drivers/net/igbvf/netdev.c
@@ -1226,6 +1226,7 @@ static void igbvf_configure_tx(struct igbvf_adapter *adapter)
         /* disable transmits */
         txdctl = er32(TXDCTL(0));
         ew32(TXDCTL(0), txdctl & ~E1000_TXDCTL_QUEUE_ENABLE);
+        e1e_flush();
         msleep(10);
 
         /* Setup the HW Tx Head and Tail descriptor pointers */
@@ -1306,6 +1307,7 @@ static void igbvf_configure_rx(struct igbvf_adapter *adapter)
         /* disable receives */
         rxdctl = er32(RXDCTL(0));
         ew32(RXDCTL(0), rxdctl & ~E1000_RXDCTL_QUEUE_ENABLE);
+        e1e_flush();
         msleep(10);
 
         rdlen = rx_ring->count * sizeof(union e1000_adv_rx_desc);
diff --git a/drivers/net/irda/sh_irda.c b/drivers/net/irda/sh_irda.c
index 4488bd581eca..82660672dcd9 100644
--- a/drivers/net/irda/sh_irda.c
+++ b/drivers/net/irda/sh_irda.c
@@ -22,6 +22,8 @@
  *  - DMA transfer support
  *  - FIFO mode support
  */
+#include <linux/io.h>
+#include <linux/interrupt.h>
 #include <linux/module.h>
 #include <linux/platform_device.h>
 #include <linux/clk.h>
diff --git a/drivers/net/irda/sh_sir.c b/drivers/net/irda/sh_sir.c
index 52a7c86af663..ed7d7d62bf68 100644
--- a/drivers/net/irda/sh_sir.c
+++ b/drivers/net/irda/sh_sir.c
@@ -12,6 +12,8 @@
  * published by the Free Software Foundation.
  */
 
+#include <linux/io.h>
+#include <linux/interrupt.h>
 #include <linux/module.h>
 #include <linux/platform_device.h>
 #include <linux/slab.h>
@@ -511,7 +513,7 @@ static void sh_sir_tx(struct sh_sir_self *self, int phase)
 
 static int sh_sir_read_data(struct sh_sir_self *self)
 {
-        u16 val;
+        u16 val = 0;
         int timeout = 1024;
 
         while (timeout--) {
diff --git a/drivers/net/irda/smsc-ircc2.c b/drivers/net/irda/smsc-ircc2.c
index 954f6e938fb7..8b1c3484d271 100644
--- a/drivers/net/irda/smsc-ircc2.c
+++ b/drivers/net/irda/smsc-ircc2.c
@@ -2405,8 +2405,6 @@ static int __init smsc_superio_lpc(unsigned short cfg_base)
  * addresses making a subsystem device table necessary.
  */
 #ifdef CONFIG_PCI
-#define PCIID_VENDOR_INTEL 0x8086
-#define PCIID_VENDOR_ALI 0x10b9
 static struct smsc_ircc_subsystem_configuration subsystem_configurations[] __initdata = {
         /*
          * Subsystems needing entries:
@@ -2416,7 +2414,7 @@ static struct smsc_ircc_subsystem_configuration subsystem_configurations[] __ini
          */
         {
                 /* Guessed entry */
-                .vendor = PCIID_VENDOR_INTEL, /* Intel 82801DBM LPC bridge */
+                .vendor = PCI_VENDOR_ID_INTEL, /* Intel 82801DBM LPC bridge */
                 .device = 0x24cc,
                 .subvendor = 0x103c,
                 .subdevice = 0x08bc,
@@ -2429,7 +2427,7 @@ static struct smsc_ircc_subsystem_configuration subsystem_configurations[] __ini
                 .name = "HP nx5000 family",
         },
         {
-                .vendor = PCIID_VENDOR_INTEL, /* Intel 82801DBM LPC bridge */
+                .vendor = PCI_VENDOR_ID_INTEL, /* Intel 82801DBM LPC bridge */
                 .device = 0x24cc,
                 .subvendor = 0x103c,
                 .subdevice = 0x088c,
@@ -2443,7 +2441,7 @@ static struct smsc_ircc_subsystem_configuration subsystem_configurations[] __ini
                 .name = "HP nc8000 family",
         },
         {
-                .vendor = PCIID_VENDOR_INTEL, /* Intel 82801DBM LPC bridge */
+                .vendor = PCI_VENDOR_ID_INTEL, /* Intel 82801DBM LPC bridge */
                 .device = 0x24cc,
                 .subvendor = 0x103c,
                 .subdevice = 0x0890,
@@ -2456,7 +2454,7 @@ static struct smsc_ircc_subsystem_configuration subsystem_configurations[] __ini
                 .name = "HP nc6000 family",
         },
         {
-                .vendor = PCIID_VENDOR_INTEL, /* Intel 82801DBM LPC bridge */
+                .vendor = PCI_VENDOR_ID_INTEL, /* Intel 82801DBM LPC bridge */
                 .device = 0x24cc,
                 .subvendor = 0x0e11,
                 .subdevice = 0x0860,
@@ -2471,7 +2469,7 @@ static struct smsc_ircc_subsystem_configuration subsystem_configurations[] __ini
         },
         {
                 /* Intel 82801DB/DBL (ICH4/ICH4-L) LPC Interface Bridge */
-                .vendor = PCIID_VENDOR_INTEL,
+                .vendor = PCI_VENDOR_ID_INTEL,
                 .device = 0x24c0,
                 .subvendor = 0x1179,
                 .subdevice = 0xffff, /* 0xffff is "any" */
@@ -2484,7 +2482,7 @@ static struct smsc_ircc_subsystem_configuration subsystem_configurations[] __ini
                 .name = "Toshiba laptop with Intel 82801DB/DBL LPC bridge",
         },
         {
-                .vendor = PCIID_VENDOR_INTEL, /* Intel 82801CAM ISA bridge */
+                .vendor = PCI_VENDOR_ID_INTEL, /* Intel 82801CAM ISA bridge */
                 .device = 0x248c,
                 .subvendor = 0x1179,
                 .subdevice = 0xffff, /* 0xffff is "any" */
@@ -2498,7 +2496,7 @@ static struct smsc_ircc_subsystem_configuration subsystem_configurations[] __ini
         },
         {
                 /* 82801DBM (ICH4-M) LPC Interface Bridge */
-                .vendor = PCIID_VENDOR_INTEL,
+                .vendor = PCI_VENDOR_ID_INTEL,
                 .device = 0x24cc,
                 .subvendor = 0x1179,
                 .subdevice = 0xffff, /* 0xffff is "any" */
@@ -2512,7 +2510,7 @@ static struct smsc_ircc_subsystem_configuration subsystem_configurations[] __ini
         },
         {
                 /* ALi M1533/M1535 PCI to ISA Bridge [Aladdin IV/V/V+] */
-                .vendor = PCIID_VENDOR_ALI,
+                .vendor = PCI_VENDOR_ID_AL,
                 .device = 0x1533,
                 .subvendor = 0x1179,
                 .subdevice = 0xffff, /* 0xffff is "any" */
diff --git a/drivers/net/ixgb/ixgb_ee.c b/drivers/net/ixgb/ixgb_ee.c
index c982ab9f9005..38b362b67857 100644
--- a/drivers/net/ixgb/ixgb_ee.c
+++ b/drivers/net/ixgb/ixgb_ee.c
@@ -57,6 +57,7 @@ ixgb_raise_clock(struct ixgb_hw *hw,
          */
         *eecd_reg = *eecd_reg | IXGB_EECD_SK;
         IXGB_WRITE_REG(hw, EECD, *eecd_reg);
+        IXGB_WRITE_FLUSH(hw);
         udelay(50);
 }
 
@@ -75,6 +76,7 @@ ixgb_lower_clock(struct ixgb_hw *hw,
          */
         *eecd_reg = *eecd_reg & ~IXGB_EECD_SK;
         IXGB_WRITE_REG(hw, EECD, *eecd_reg);
+        IXGB_WRITE_FLUSH(hw);
         udelay(50);
 }
 
@@ -112,6 +114,7 @@ ixgb_shift_out_bits(struct ixgb_hw *hw,
                         eecd_reg |= IXGB_EECD_DI;
 
                 IXGB_WRITE_REG(hw, EECD, eecd_reg);
+                IXGB_WRITE_FLUSH(hw);
 
                 udelay(50);
 
@@ -206,21 +209,25 @@ ixgb_standby_eeprom(struct ixgb_hw *hw)
         /*  Deselect EEPROM  */
         eecd_reg &= ~(IXGB_EECD_CS | IXGB_EECD_SK);
         IXGB_WRITE_REG(hw, EECD, eecd_reg);
+        IXGB_WRITE_FLUSH(hw);
         udelay(50);
 
         /*  Clock high  */
         eecd_reg |= IXGB_EECD_SK;
         IXGB_WRITE_REG(hw, EECD, eecd_reg);
+        IXGB_WRITE_FLUSH(hw);
         udelay(50);
 
         /*  Select EEPROM  */
         eecd_reg |= IXGB_EECD_CS;
         IXGB_WRITE_REG(hw, EECD, eecd_reg);
+        IXGB_WRITE_FLUSH(hw);
         udelay(50);
 
         /*  Clock low  */
         eecd_reg &= ~IXGB_EECD_SK;
         IXGB_WRITE_REG(hw, EECD, eecd_reg);
+        IXGB_WRITE_FLUSH(hw);
         udelay(50);
 }
 
@@ -239,11 +246,13 @@ ixgb_clock_eeprom(struct ixgb_hw *hw)
         /*  Rising edge of clock  */
         eecd_reg |= IXGB_EECD_SK;
         IXGB_WRITE_REG(hw, EECD, eecd_reg);
+        IXGB_WRITE_FLUSH(hw);
         udelay(50);
 
         /*  Falling edge of clock  */
         eecd_reg &= ~IXGB_EECD_SK;
         IXGB_WRITE_REG(hw, EECD, eecd_reg);
+        IXGB_WRITE_FLUSH(hw);
         udelay(50);
 }
 
diff --git a/drivers/net/ixgb/ixgb_hw.c b/drivers/net/ixgb/ixgb_hw.c
index 6cb2e42ff4c1..3d61a9e4faf7 100644
--- a/drivers/net/ixgb/ixgb_hw.c
+++ b/drivers/net/ixgb/ixgb_hw.c
@@ -149,6 +149,7 @@ ixgb_adapter_stop(struct ixgb_hw *hw)
          */
         IXGB_WRITE_REG(hw, RCTL, IXGB_READ_REG(hw, RCTL) & ~IXGB_RCTL_RXEN);
         IXGB_WRITE_REG(hw, TCTL, IXGB_READ_REG(hw, TCTL) & ~IXGB_TCTL_TXEN);
+        IXGB_WRITE_FLUSH(hw);
         msleep(IXGB_DELAY_BEFORE_RESET);
 
         /* Issue a global reset to the MAC.  This will reset the chip's
@@ -1220,6 +1221,7 @@ ixgb_optics_reset_bcm(struct ixgb_hw *hw)
         ctrl &= ~IXGB_CTRL0_SDP2;
         ctrl |= IXGB_CTRL0_SDP3;
         IXGB_WRITE_REG(hw, CTRL0, ctrl);
+        IXGB_WRITE_FLUSH(hw);
 
         /* SerDes needs extra delay */
         msleep(IXGB_SUN_PHY_RESET_DELAY);
diff --git a/drivers/net/ixgbe/ixgbe_82599.c b/drivers/net/ixgbe/ixgbe_82599.c
index 3b3dd4df4c5c..34f30ec79c2e 100644
--- a/drivers/net/ixgbe/ixgbe_82599.c
+++ b/drivers/net/ixgbe/ixgbe_82599.c
@@ -213,6 +213,7 @@ static s32 ixgbe_init_phy_ops_82599(struct ixgbe_hw *hw)
         switch (hw->phy.type) {
         case ixgbe_phy_tn:
                 phy->ops.check_link = &ixgbe_check_phy_link_tnx;
+                phy->ops.setup_link = &ixgbe_setup_phy_link_tnx;
                 phy->ops.get_firmware_version =
                              &ixgbe_get_phy_firmware_version_tnx;
                 break;
diff --git a/drivers/net/ixgbe/ixgbe_common.c b/drivers/net/ixgbe/ixgbe_common.c
index 777051f54e53..fc1375f26fe5 100644
--- a/drivers/net/ixgbe/ixgbe_common.c
+++ b/drivers/net/ixgbe/ixgbe_common.c
@@ -2632,6 +2632,7 @@ s32 ixgbe_blink_led_start_generic(struct ixgbe_hw *hw, u32 index)
                 autoc_reg |= IXGBE_AUTOC_AN_RESTART;
                 autoc_reg |= IXGBE_AUTOC_FLU;
                 IXGBE_WRITE_REG(hw, IXGBE_AUTOC, autoc_reg);
+                IXGBE_WRITE_FLUSH(hw);
                 usleep_range(10000, 20000);
         }
 
diff --git a/drivers/net/ixgbe/ixgbe_ethtool.c b/drivers/net/ixgbe/ixgbe_ethtool.c
index dc649553a0a6..82d4244c6e10 100644
--- a/drivers/net/ixgbe/ixgbe_ethtool.c
+++ b/drivers/net/ixgbe/ixgbe_ethtool.c
@@ -1378,6 +1378,7 @@ static int ixgbe_intr_test(struct ixgbe_adapter *adapter, u64 *data)
 
         /* Disable all the interrupts */
         IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMC, 0xFFFFFFFF);
+        IXGBE_WRITE_FLUSH(&adapter->hw);
         usleep_range(10000, 20000);
 
         /* Test each interrupt */
@@ -1398,6 +1399,7 @@ static int ixgbe_intr_test(struct ixgbe_adapter *adapter, u64 *data)
                                         ~mask & 0x00007FFF);
                         IXGBE_WRITE_REG(&adapter->hw, IXGBE_EICS,
                                         ~mask & 0x00007FFF);
+                        IXGBE_WRITE_FLUSH(&adapter->hw);
                         usleep_range(10000, 20000);
 
                         if (adapter->test_icr & mask) {
@@ -1415,6 +1417,7 @@ static int ixgbe_intr_test(struct ixgbe_adapter *adapter, u64 *data)
                 adapter->test_icr = 0;
                 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMS, mask);
                 IXGBE_WRITE_REG(&adapter->hw, IXGBE_EICS, mask);
+                IXGBE_WRITE_FLUSH(&adapter->hw);
                 usleep_range(10000, 20000);
 
                 if (!(adapter->test_icr &mask)) {
@@ -1435,6 +1438,7 @@ static int ixgbe_intr_test(struct ixgbe_adapter *adapter, u64 *data)
                                         ~mask & 0x00007FFF);
                         IXGBE_WRITE_REG(&adapter->hw, IXGBE_EICS,
                                         ~mask & 0x00007FFF);
+                        IXGBE_WRITE_FLUSH(&adapter->hw);
                         usleep_range(10000, 20000);
 
                         if (adapter->test_icr) {
@@ -1446,6 +1450,7 @@ static int ixgbe_intr_test(struct ixgbe_adapter *adapter, u64 *data)
 
         /* Disable all the interrupts */
         IXGBE_WRITE_REG(&adapter->hw, IXGBE_EIMC, 0xFFFFFFFF);
+        IXGBE_WRITE_FLUSH(&adapter->hw);
         usleep_range(10000, 20000);
 
         /* Unhook test interrupt handler */
diff --git a/drivers/net/ixgbe/ixgbe_main.c b/drivers/net/ixgbe/ixgbe_main.c
index 1be617545dc9..22790394318a 100644
--- a/drivers/net/ixgbe/ixgbe_main.c
+++ b/drivers/net/ixgbe/ixgbe_main.c
@@ -184,6 +184,7 @@ static inline void ixgbe_disable_sriov(struct ixgbe_adapter *adapter)
         vmdctl = IXGBE_READ_REG(hw, IXGBE_VT_CTL);
         vmdctl &= ~IXGBE_VT_CTL_POOL_MASK;
         IXGBE_WRITE_REG(hw, IXGBE_VT_CTL, vmdctl);
+        IXGBE_WRITE_FLUSH(hw);
 
         /* take a breather then clean up driver data */
         msleep(100);
@@ -1005,7 +1006,7 @@ static int __ixgbe_notify_dca(struct device *dev, void *data)
         struct ixgbe_adapter *adapter = dev_get_drvdata(dev);
         unsigned long event = *(unsigned long *)data;
 
-        if (!(adapter->flags & IXGBE_FLAG_DCA_ENABLED))
+        if (!(adapter->flags & IXGBE_FLAG_DCA_CAPABLE))
                 return 0;
 
         switch (event) {
@@ -1458,8 +1459,10 @@ static void ixgbe_clean_rx_irq(struct ixgbe_q_vector *q_vector,
                 if (ixgbe_rx_is_fcoe(adapter, rx_desc)) {
                         ddp_bytes = ixgbe_fcoe_ddp(adapter, rx_desc, skb,
                                                    staterr);
-                        if (!ddp_bytes)
+                        if (!ddp_bytes) {
+                                dev_kfree_skb_any(skb);
                                 goto next_desc;
+                        }
                 }
 #endif /* IXGBE_FCOE */
                 ixgbe_receive_skb(q_vector, skb, staterr, rx_ring, rx_desc);
diff --git a/drivers/net/ixgbe/ixgbe_phy.c b/drivers/net/ixgbe/ixgbe_phy.c
index 735f686c3b36..f7ca3511b9fe 100644
--- a/drivers/net/ixgbe/ixgbe_phy.c
+++ b/drivers/net/ixgbe/ixgbe_phy.c
@@ -1585,6 +1585,7 @@ static s32 ixgbe_raise_i2c_clk(struct ixgbe_hw *hw, u32 *i2cctl)
         *i2cctl |= IXGBE_I2C_CLK_OUT;
 
         IXGBE_WRITE_REG(hw, IXGBE_I2CCTL, *i2cctl);
+        IXGBE_WRITE_FLUSH(hw);
 
         /* SCL rise time (1000ns) */
         udelay(IXGBE_I2C_T_RISE);
@@ -1605,6 +1606,7 @@ static void ixgbe_lower_i2c_clk(struct ixgbe_hw *hw, u32 *i2cctl)
         *i2cctl &= ~IXGBE_I2C_CLK_OUT;
 
         IXGBE_WRITE_REG(hw, IXGBE_I2CCTL, *i2cctl);
+        IXGBE_WRITE_FLUSH(hw);
 
         /* SCL fall time (300ns) */
         udelay(IXGBE_I2C_T_FALL);
@@ -1628,6 +1630,7 @@ static s32 ixgbe_set_i2c_data(struct ixgbe_hw *hw, u32 *i2cctl, bool data)
                 *i2cctl &= ~IXGBE_I2C_DATA_OUT;
 
         IXGBE_WRITE_REG(hw, IXGBE_I2CCTL, *i2cctl);
+        IXGBE_WRITE_FLUSH(hw);
 
         /* Data rise/fall (1000ns/300ns) and set-up time (250ns) */
         udelay(IXGBE_I2C_T_RISE + IXGBE_I2C_T_FALL + IXGBE_I2C_T_SU_DATA);
diff --git a/drivers/net/ixgbe/ixgbe_x540.c b/drivers/net/ixgbe/ixgbe_x540.c
index bec30ed91adc..2696c78e9f46 100644
--- a/drivers/net/ixgbe/ixgbe_x540.c
+++ b/drivers/net/ixgbe/ixgbe_x540.c
@@ -162,6 +162,7 @@ mac_reset_top:
         ctrl_ext = IXGBE_READ_REG(hw, IXGBE_CTRL_EXT);
         ctrl_ext |= IXGBE_CTRL_EXT_PFRSTD;
         IXGBE_WRITE_REG(hw, IXGBE_CTRL_EXT, ctrl_ext);
+        IXGBE_WRITE_FLUSH(hw);
 
         msleep(50);
 
diff --git a/drivers/net/macb.c b/drivers/net/macb.c
index 0fcdc25699d8..dc4e305a1087 100644
--- a/drivers/net/macb.c
+++ b/drivers/net/macb.c
@@ -322,6 +322,9 @@ static void macb_tx(struct macb *bp)
                 for (i = 0; i < TX_RING_SIZE; i++)
                         bp->tx_ring[i].ctrl = MACB_BIT(TX_USED);
 
+                /* Add wrap bit */
+                bp->tx_ring[TX_RING_SIZE - 1].ctrl |= MACB_BIT(TX_WRAP);
+
                 /* free transmit buffer in upper layer*/
                 for (tail = bp->tx_tail; tail != head; tail = NEXT_TX(tail)) {
                         struct ring_info *rp = &bp->tx_skb[tail];
diff --git a/drivers/net/mlx4/en_port.c b/drivers/net/mlx4/en_port.c
index 5e7109178061..5ada5b469112 100644
--- a/drivers/net/mlx4/en_port.c
+++ b/drivers/net/mlx4/en_port.c
@@ -128,7 +128,7 @@ int mlx4_SET_PORT_qpn_calc(struct mlx4_dev *dev, u8 port, u32 base_qpn,
         memset(context, 0, sizeof *context);
 
         context->base_qpn = cpu_to_be32(base_qpn);
-        context->n_mac = 0x7;
+        context->n_mac = 0x2;
         context->promisc = cpu_to_be32(promisc << SET_PORT_PROMISC_SHIFT |
                                        base_qpn);
         context->mcast = cpu_to_be32(m_promisc << SET_PORT_MC_PROMISC_SHIFT |
diff --git a/drivers/net/mlx4/main.c b/drivers/net/mlx4/main.c
index c94b3426d355..f0ee35df4dd7 100644
--- a/drivers/net/mlx4/main.c
+++ b/drivers/net/mlx4/main.c
@@ -1117,6 +1117,8 @@ static int mlx4_init_port_info(struct mlx4_dev *dev, int port)
         info->port = port;
         mlx4_init_mac_table(dev, &info->mac_table);
         mlx4_init_vlan_table(dev, &info->vlan_table);
+        info->base_qpn = dev->caps.reserved_qps_base[MLX4_QP_REGION_ETH_ADDR] +
+                        (port - 1) * (1 << log_num_mac);
 
         sprintf(info->dev_name, "mlx4_port%d", port);
         info->port_attr.attr.name = info->dev_name;
diff --git a/drivers/net/mlx4/port.c b/drivers/net/mlx4/port.c
index 1f95afda6841..609e0ec14cee 100644
--- a/drivers/net/mlx4/port.c
+++ b/drivers/net/mlx4/port.c
@@ -258,9 +258,12 @@ void mlx4_unregister_mac(struct mlx4_dev *dev, u8 port, int qpn)
         if (validate_index(dev, table, index))
                 goto out;
 
-        table->entries[index] = 0;
-        mlx4_set_port_mac_table(dev, port, table->entries);
-        --table->total;
+        /* Check whether this address has reference count */
+        if (!(--table->refs[index])) {
+                table->entries[index] = 0;
+                mlx4_set_port_mac_table(dev, port, table->entries);
+                --table->total;
+        }
 out:
         mutex_unlock(&table->mutex);
 }
diff --git a/drivers/net/niu.c b/drivers/net/niu.c
index cd6c2317e29e..ed47585a6862 100644
--- a/drivers/net/niu.c
+++ b/drivers/net/niu.c
@@ -9201,7 +9201,7 @@ static int __devinit niu_ldg_init(struct niu *np)
 
         first_chan = 0;
         for (i = 0; i < port; i++)
-                first_chan += parent->rxchan_per_port[port];
+                first_chan += parent->rxchan_per_port[i];
         num_chan = parent->rxchan_per_port[port];
 
         for (i = first_chan; i < (first_chan + num_chan); i++) {
@@ -9217,7 +9217,7 @@ static int __devinit niu_ldg_init(struct niu *np)
 
         first_chan = 0;
         for (i = 0; i < port; i++)
-                first_chan += parent->txchan_per_port[port];
+                first_chan += parent->txchan_per_port[i];
         num_chan = parent->txchan_per_port[port];
         for (i = first_chan; i < (first_chan + num_chan); i++) {
                 err = niu_ldg_assign_ldn(np, parent,
diff --git a/drivers/net/pcmcia/smc91c92_cs.c b/drivers/net/pcmcia/smc91c92_cs.c
index 1cd9394c3359..cffbc0373fa9 100644
--- a/drivers/net/pcmcia/smc91c92_cs.c
+++ b/drivers/net/pcmcia/smc91c92_cs.c
@@ -809,7 +809,7 @@ static int smc91c92_config(struct pcmcia_device *link)
     struct net_device *dev = link->priv;
     struct smc_private *smc = netdev_priv(dev);
     char *name;
-    int i, j, rev;
+    int i, rev, j = 0;
     unsigned int ioaddr;
     u_long mir;
 
diff --git a/drivers/net/pcnet32.c b/drivers/net/pcnet32.c
index 8b3090dc4bcd..80b6f36a8074 100644
--- a/drivers/net/pcnet32.c
+++ b/drivers/net/pcnet32.c
@@ -82,7 +82,7 @@ static int cards_found;
 /*
  * VLB I/O addresses
  */
-static unsigned int pcnet32_portlist[] __initdata =
+static unsigned int pcnet32_portlist[] =
     { 0x300, 0x320, 0x340, 0x360, 0 };
 
 static int pcnet32_debug;
diff --git a/drivers/net/phy/dp83640.c b/drivers/net/phy/dp83640.c
index 2cd8dc5847b4..cb6e0b486b1e 100644
--- a/drivers/net/phy/dp83640.c
+++ b/drivers/net/phy/dp83640.c
@@ -34,8 +34,7 @@
 #define PAGESEL         0x13
 #define LAYER4          0x02
 #define LAYER2          0x01
-#define MAX_RXTS        4
-#define MAX_TXTS        4
+#define MAX_RXTS        64
 #define N_EXT_TS        1
 #define PSF_PTPVER      2
 #define PSF_EVNT        0x4000
@@ -218,7 +217,7 @@ static void phy2rxts(struct phy_rxts *p, struct rxts *rxts)
         rxts->seqid = p->seqid;
         rxts->msgtype = (p->msgtype >> 12) & 0xf;
         rxts->hash = p->msgtype & 0x0fff;
-        rxts->tmo = jiffies + HZ;
+        rxts->tmo = jiffies + 2;
 }
 
 static u64 phy2txts(struct phy_txts *p)
diff --git a/drivers/net/phy/national.c b/drivers/net/phy/national.c
index 0620ba963508..04bb8fcc0cb5 100644
--- a/drivers/net/phy/national.c
+++ b/drivers/net/phy/national.c
@@ -25,8 +25,9 @@
 /* DP83865 phy identifier values */
 #define DP83865_PHY_ID  0x20005c7a
 
-#define DP83865_INT_MASK_REG 0x15
-#define DP83865_INT_MASK_STATUS 0x14
+#define DP83865_INT_STATUS      0x14
+#define DP83865_INT_MASK        0x15
+#define DP83865_INT_CLEAR       0x17
 
 #define DP83865_INT_REMOTE_FAULT 0x0008
 #define DP83865_INT_ANE_COMPLETED 0x0010
@@ -68,21 +69,25 @@ static int ns_config_intr(struct phy_device *phydev)
         int err;
 
         if (phydev->interrupts == PHY_INTERRUPT_ENABLED)
-                err = phy_write(phydev, DP83865_INT_MASK_REG,
+                err = phy_write(phydev, DP83865_INT_MASK,
                                 DP83865_INT_MASK_DEFAULT);
         else
-                err = phy_write(phydev, DP83865_INT_MASK_REG, 0);
+                err = phy_write(phydev, DP83865_INT_MASK, 0);
 
         return err;
 }
 
 static int ns_ack_interrupt(struct phy_device *phydev)
 {
-        int ret = phy_read(phydev, DP83865_INT_MASK_STATUS);
+        int ret = phy_read(phydev, DP83865_INT_STATUS);
         if (ret < 0)
                 return ret;
 
-        return 0;
+        /* Clear the interrupt status bit by writing a “1”
+         * to the corresponding bit in INT_CLEAR (2:0 are reserved) */
+        ret = phy_write(phydev, DP83865_INT_CLEAR, ret & ~0x7);
+
+        return ret;
 }
 
 static void ns_giga_speed_fallback(struct phy_device *phydev, int mode)
diff --git a/drivers/net/r8169.c b/drivers/net/r8169.c
index 7d9c650f395e..02339b3352e7 100644
--- a/drivers/net/r8169.c
+++ b/drivers/net/r8169.c
@@ -239,6 +239,7 @@ static DEFINE_PCI_DEVICE_TABLE(rtl8169_pci_tbl) = {
         { PCI_DEVICE(PCI_VENDOR_ID_REALTEK,     0x8168), 0, 0, RTL_CFG_1 },
         { PCI_DEVICE(PCI_VENDOR_ID_REALTEK,     0x8169), 0, 0, RTL_CFG_0 },
         { PCI_DEVICE(PCI_VENDOR_ID_DLINK,       0x4300), 0, 0, RTL_CFG_0 },
+        { PCI_DEVICE(PCI_VENDOR_ID_DLINK,       0x4302), 0, 0, RTL_CFG_0 },
         { PCI_DEVICE(PCI_VENDOR_ID_AT,          0xc107), 0, 0, RTL_CFG_0 },
         { PCI_DEVICE(0x16ec,                    0x0116), 0, 0, RTL_CFG_0 },
         { PCI_VENDOR_ID_LINKSYS,                0x1032,
@@ -1091,6 +1092,21 @@ rtl_w1w0_eri(void __iomem *ioaddr, int addr, u32 mask, u32 p, u32 m, int type)
         rtl_eri_write(ioaddr, addr, mask, (val & ~m) | p, type);
 }
 
+struct exgmac_reg {
+        u16 addr;
+        u16 mask;
+        u32 val;
+};
+
+static void rtl_write_exgmac_batch(void __iomem *ioaddr,
+                                   const struct exgmac_reg *r, int len)
+{
+        while (len-- > 0) {
+                rtl_eri_write(ioaddr, r->addr, r->mask, r->val, ERIAR_EXGMAC);
+                r++;
+        }
+}
+
 static u8 rtl8168d_efuse_read(void __iomem *ioaddr, int reg_addr)
 {
         u8 value = 0xff;
@@ -3116,6 +3132,18 @@ static void rtl_rar_set(struct rtl8169_private *tp, u8 *addr)
         RTL_W32(MAC0, low);
         RTL_R32(MAC0);
 
+        if (tp->mac_version == RTL_GIGA_MAC_VER_34) {
+                const struct exgmac_reg e[] = {
+                        { .addr = 0xe0, ERIAR_MASK_1111, .val = low },
+                        { .addr = 0xe4, ERIAR_MASK_1111, .val = high },
+                        { .addr = 0xf0, ERIAR_MASK_1111, .val = low << 16 },
+                        { .addr = 0xf4, ERIAR_MASK_1111, .val = high << 16 |
+                                                                low  >> 16 },
+                };
+
+                rtl_write_exgmac_batch(ioaddr, e, ARRAY_SIZE(e));
+        }
+
         RTL_W8(Cfg9346, Cfg9346_Lock);
 
         spin_unlock_irq(&tp->lock);
diff --git a/drivers/net/rionet.c b/drivers/net/rionet.c
index 86ac38c96bcf..3bb131137033 100644
--- a/drivers/net/rionet.c
+++ b/drivers/net/rionet.c
@@ -80,13 +80,13 @@ static int rionet_capable = 1;
  */
 static struct rio_dev **rionet_active;
 
-#define is_rionet_capable(pef, src_ops, dst_ops)                \
-                        ((pef & RIO_PEF_INB_MBOX) &&            \
-                         (pef & RIO_PEF_INB_DOORBELL) &&        \
+#define is_rionet_capable(src_ops, dst_ops)                     \
+                        ((src_ops & RIO_SRC_OPS_DATA_MSG) &&    \
+                         (dst_ops & RIO_DST_OPS_DATA_MSG) &&    \
                          (src_ops & RIO_SRC_OPS_DOORBELL) &&    \
                          (dst_ops & RIO_DST_OPS_DOORBELL))
 #define dev_rionet_capable(dev) \
-        is_rionet_capable(dev->pef, dev->src_ops, dev->dst_ops)
+        is_rionet_capable(dev->src_ops, dev->dst_ops)
 
 #define RIONET_MAC_MATCH(x)     (*(u32 *)x == 0x00010001)
 #define RIONET_GET_DESTID(x)    (*(u16 *)(x + 4))
@@ -282,7 +282,6 @@ static int rionet_open(struct net_device *ndev)
 {
         int i, rc = 0;
         struct rionet_peer *peer, *tmp;
-        u32 pwdcsr;
         struct rionet_private *rnet = netdev_priv(ndev);
 
         if (netif_msg_ifup(rnet))
@@ -332,13 +331,8 @@ static int rionet_open(struct net_device *ndev)
                         continue;
                 }
 
-                /*
-                 * If device has initialized inbound doorbells,
-                 * send a join message
-                 */
-                rio_read_config_32(peer->rdev, RIO_WRITE_PORT_CSR, &pwdcsr);
-                if (pwdcsr & RIO_DOORBELL_AVAIL)
-                        rio_send_doorbell(peer->rdev, RIONET_DOORBELL_JOIN);
+                /* Send a join message */
+                rio_send_doorbell(peer->rdev, RIONET_DOORBELL_JOIN);
         }
 
       out:
@@ -492,7 +486,7 @@ static int rionet_setup_netdev(struct rio_mport *mport, struct net_device *ndev)
 static int rionet_probe(struct rio_dev *rdev, const struct rio_device_id *id)
 {
         int rc = -ENODEV;
-        u32 lpef, lsrc_ops, ldst_ops;
+        u32 lsrc_ops, ldst_ops;
         struct rionet_peer *peer;
         struct net_device *ndev = NULL;
 
@@ -515,12 +509,11 @@ static int rionet_probe(struct rio_dev *rdev, const struct rio_device_id *id)
          * on later probes
          */
         if (!rionet_check) {
-                rio_local_read_config_32(rdev->net->hport, RIO_PEF_CAR, &lpef);
                 rio_local_read_config_32(rdev->net->hport, RIO_SRC_OPS_CAR,
                                          &lsrc_ops);
                 rio_local_read_config_32(rdev->net->hport, RIO_DST_OPS_CAR,
                                          &ldst_ops);
-                if (!is_rionet_capable(lpef, lsrc_ops, ldst_ops)) {
+                if (!is_rionet_capable(lsrc_ops, ldst_ops)) {
                         printk(KERN_ERR
                                "%s: local device is not network capable\n",
                                DRV_NAME);
diff --git a/drivers/net/sh_eth.c b/drivers/net/sh_eth.c
index ad35c210b839..1c1666e99106 100644
--- a/drivers/net/sh_eth.c
+++ b/drivers/net/sh_eth.c
@@ -21,6 +21,7 @@
  */
 
 #include <linux/init.h>
+#include <linux/interrupt.h>
 #include <linux/dma-mapping.h>
 #include <linux/etherdevice.h>
 #include <linux/delay.h>
@@ -30,6 +31,7 @@
 #include <linux/phy.h>
 #include <linux/cache.h>
 #include <linux/io.h>
+#include <linux/interrupt.h>
 #include <linux/pm_runtime.h>
 #include <linux/slab.h>
 #include <linux/ethtool.h>
diff --git a/drivers/net/sis190.c b/drivers/net/sis190.c
index 8ad7bfbaa3af..3c0f1312b391 100644
--- a/drivers/net/sis190.c
+++ b/drivers/net/sis190.c
@@ -1825,6 +1825,16 @@ static int sis190_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
                 generic_mii_ioctl(&tp->mii_if, if_mii(ifr), cmd, NULL);
 }
 
+static int sis190_mac_addr(struct net_device  *dev, void *p)
+{
+        int rc;
+
+        rc = eth_mac_addr(dev, p);
+        if (!rc)
+                sis190_init_rxfilter(dev);
+        return rc;
+}
+
 static const struct net_device_ops sis190_netdev_ops = {
         .ndo_open               = sis190_open,
         .ndo_stop               = sis190_close,
@@ -1833,7 +1843,7 @@ static const struct net_device_ops sis190_netdev_ops = {
         .ndo_tx_timeout         = sis190_tx_timeout,
         .ndo_set_multicast_list = sis190_set_rx_mode,
         .ndo_change_mtu         = eth_change_mtu,
-        .ndo_set_mac_address    = eth_mac_addr,
+        .ndo_set_mac_address    = sis190_mac_addr,
         .ndo_validate_addr      = eth_validate_addr,
 #ifdef CONFIG_NET_POLL_CONTROLLER
         .ndo_poll_controller     = sis190_netpoll,
diff --git a/drivers/net/slip.c b/drivers/net/slip.c
index f11b3f3df24f..4c617534f937 100644
--- a/drivers/net/slip.c
+++ b/drivers/net/slip.c
@@ -367,7 +367,7 @@ static void sl_bump(struct slip *sl)
         memcpy(skb_put(skb, count), sl->rbuff, count);
         skb_reset_mac_header(skb);
         skb->protocol = htons(ETH_P_IP);
-        netif_rx(skb);
+        netif_rx_ni(skb);
         dev->stats.rx_packets++;
 }
 
diff --git a/drivers/net/sungem.c b/drivers/net/sungem.c
index be745ae8f4e3..ade35dde5b51 100644
--- a/drivers/net/sungem.c
+++ b/drivers/net/sungem.c
@@ -46,14 +46,15 @@
 #include <asm/byteorder.h>
 #include <asm/uaccess.h>
 #include <asm/irq.h>
-#include <asm/prom.h>
 
 #ifdef CONFIG_SPARC
 #include <asm/idprom.h>
+#include <asm/prom.h>
 #endif
 
 #ifdef CONFIG_PPC_PMAC
 #include <asm/pci-bridge.h>
+#include <asm/prom.h>
 #include <asm/machdep.h>
 #include <asm/pmac_feature.h>
 #endif
diff --git a/drivers/net/usb/cdc_ncm.c b/drivers/net/usb/cdc_ncm.c
index fd622a66ebbf..f06fb78383a1 100644
--- a/drivers/net/usb/cdc_ncm.c
+++ b/drivers/net/usb/cdc_ncm.c
@@ -53,7 +53,7 @@
 #include <linux/usb/usbnet.h>
 #include <linux/usb/cdc.h>
 
-#define DRIVER_VERSION                          "01-June-2011"
+#define DRIVER_VERSION                          "04-Aug-2011"
 
 /* CDC NCM subclass 3.2.1 */
 #define USB_CDC_NCM_NDP16_LENGTH_MIN            0x10
@@ -163,35 +163,8 @@ cdc_ncm_get_drvinfo(struct net_device *net, struct ethtool_drvinfo *info)
         usb_make_path(dev->udev, info->bus_info, sizeof(info->bus_info));
 }
 
-static int
-cdc_ncm_do_request(struct cdc_ncm_ctx *ctx, struct usb_cdc_notification *req,
-                   void *data, u16 flags, u16 *actlen, u16 timeout)
-{
-        int err;
-
-        err = usb_control_msg(ctx->udev, (req->bmRequestType & USB_DIR_IN) ?
-                                usb_rcvctrlpipe(ctx->udev, 0) :
-                                usb_sndctrlpipe(ctx->udev, 0),
-                                req->bNotificationType, req->bmRequestType,
-                                req->wValue,
-                                req->wIndex, data,
-                                req->wLength, timeout);
-
-        if (err < 0) {
-                if (actlen)
-                        *actlen = 0;
-                return err;
-        }
-
-        if (actlen)
-                *actlen = err;
-
-        return 0;
-}
-
 static u8 cdc_ncm_setup(struct cdc_ncm_ctx *ctx)
 {
-        struct usb_cdc_notification req;
         u32 val;
         u8 flags;
         u8 iface_no;
@@ -200,14 +173,14 @@ static u8 cdc_ncm_setup(struct cdc_ncm_ctx *ctx)
 
         iface_no = ctx->control->cur_altsetting->desc.bInterfaceNumber;
 
-        req.bmRequestType = USB_TYPE_CLASS | USB_DIR_IN | USB_RECIP_INTERFACE;
-        req.bNotificationType = USB_CDC_GET_NTB_PARAMETERS;
-        req.wValue = 0;
-        req.wIndex = cpu_to_le16(iface_no);
-        req.wLength = cpu_to_le16(sizeof(ctx->ncm_parm));
-
-        err = cdc_ncm_do_request(ctx, &req, &ctx->ncm_parm, 0, NULL, 1000);
-        if (err) {
+        err = usb_control_msg(ctx->udev,
+                                usb_rcvctrlpipe(ctx->udev, 0),
+                                USB_CDC_GET_NTB_PARAMETERS,
+                                USB_TYPE_CLASS | USB_DIR_IN
+                                 | USB_RECIP_INTERFACE,
+                                0, iface_no, &ctx->ncm_parm,
+                                sizeof(ctx->ncm_parm), 10000);
+        if (err < 0) {
                 pr_debug("failed GET_NTB_PARAMETERS\n");
                 return 1;
         }
@@ -253,31 +226,43 @@ static u8 cdc_ncm_setup(struct cdc_ncm_ctx *ctx)
 
         /* inform device about NTB input size changes */
         if (ctx->rx_max != le32_to_cpu(ctx->ncm_parm.dwNtbInMaxSize)) {
-                req.bmRequestType = USB_TYPE_CLASS | USB_DIR_OUT |
-                                                        USB_RECIP_INTERFACE;
-                req.bNotificationType = USB_CDC_SET_NTB_INPUT_SIZE;
-                req.wValue = 0;
-                req.wIndex = cpu_to_le16(iface_no);
 
                 if (flags & USB_CDC_NCM_NCAP_NTB_INPUT_SIZE) {
-                        struct usb_cdc_ncm_ndp_input_size ndp_in_sz;
-
-                        req.wLength = 8;
-                        ndp_in_sz.dwNtbInMaxSize = cpu_to_le32(ctx->rx_max);
-                        ndp_in_sz.wNtbInMaxDatagrams =
-                                        cpu_to_le16(CDC_NCM_DPT_DATAGRAMS_MAX);
-                        ndp_in_sz.wReserved = 0;
-                        err = cdc_ncm_do_request(ctx, &req, &ndp_in_sz, 0, NULL,
-                                                                        1000);
-                } else {
-                        __le32 dwNtbInMaxSize = cpu_to_le32(ctx->rx_max);
+                        struct usb_cdc_ncm_ndp_input_size *ndp_in_sz;
 
-                        req.wLength = 4;
-                        err = cdc_ncm_do_request(ctx, &req, &dwNtbInMaxSize, 0,
-                                                                NULL, 1000);
-                }
+                        ndp_in_sz = kzalloc(sizeof(*ndp_in_sz), GFP_KERNEL);
+                        if (!ndp_in_sz) {
+                                err = -ENOMEM;
+                                goto size_err;
+                        }
 
-                if (err)
+                        err = usb_control_msg(ctx->udev,
+                                        usb_sndctrlpipe(ctx->udev, 0),
+                                        USB_CDC_SET_NTB_INPUT_SIZE,
+                                        USB_TYPE_CLASS | USB_DIR_OUT
+                                         | USB_RECIP_INTERFACE,
+                                        0, iface_no, ndp_in_sz, 8, 1000);
+                        kfree(ndp_in_sz);
+                } else {
+                        __le32 *dwNtbInMaxSize;
+                        dwNtbInMaxSize = kzalloc(sizeof(*dwNtbInMaxSize),
+                                        GFP_KERNEL);
+                        if (!dwNtbInMaxSize) {
+                                err = -ENOMEM;
+                                goto size_err;
+                        }
+                        *dwNtbInMaxSize = cpu_to_le32(ctx->rx_max);
+
+                        err = usb_control_msg(ctx->udev,
+                                        usb_sndctrlpipe(ctx->udev, 0),
+                                        USB_CDC_SET_NTB_INPUT_SIZE,
+                                        USB_TYPE_CLASS | USB_DIR_OUT
+                                         | USB_RECIP_INTERFACE,
+                                        0, iface_no, dwNtbInMaxSize, 4, 1000);
+                        kfree(dwNtbInMaxSize);
+                }
+size_err:
+                if (err < 0)
                         pr_debug("Setting NTB Input Size failed\n");
         }
 
@@ -332,29 +317,24 @@ static u8 cdc_ncm_setup(struct cdc_ncm_ctx *ctx)
 
         /* set CRC Mode */
         if (flags & USB_CDC_NCM_NCAP_CRC_MODE) {
-                req.bmRequestType = USB_TYPE_CLASS | USB_DIR_OUT |
-                                                        USB_RECIP_INTERFACE;
-                req.bNotificationType = USB_CDC_SET_CRC_MODE;
-                req.wValue = cpu_to_le16(USB_CDC_NCM_CRC_NOT_APPENDED);
-                req.wIndex = cpu_to_le16(iface_no);
-                req.wLength = 0;
-
-                err = cdc_ncm_do_request(ctx, &req, NULL, 0, NULL, 1000);
-                if (err)
+                err = usb_control_msg(ctx->udev, usb_sndctrlpipe(ctx->udev, 0),
+                                USB_CDC_SET_CRC_MODE,
+                                USB_TYPE_CLASS | USB_DIR_OUT
+                                 | USB_RECIP_INTERFACE,
+                                USB_CDC_NCM_CRC_NOT_APPENDED,
+                                iface_no, NULL, 0, 1000);
+                if (err < 0)
                         pr_debug("Setting CRC mode off failed\n");
         }
 
         /* set NTB format, if both formats are supported */
         if (ntb_fmt_supported & USB_CDC_NCM_NTH32_SIGN) {
-                req.bmRequestType = USB_TYPE_CLASS | USB_DIR_OUT |
-                                                        USB_RECIP_INTERFACE;
-                req.bNotificationType = USB_CDC_SET_NTB_FORMAT;
-                req.wValue = cpu_to_le16(USB_CDC_NCM_NTB16_FORMAT);
-                req.wIndex = cpu_to_le16(iface_no);
-                req.wLength = 0;
-
-                err = cdc_ncm_do_request(ctx, &req, NULL, 0, NULL, 1000);
-                if (err)
+                err = usb_control_msg(ctx->udev, usb_sndctrlpipe(ctx->udev, 0),
+                                USB_CDC_SET_NTB_FORMAT, USB_TYPE_CLASS
+                                 | USB_DIR_OUT | USB_RECIP_INTERFACE,
+                                USB_CDC_NCM_NTB16_FORMAT,
+                                iface_no, NULL, 0, 1000);
+                if (err < 0)
                         pr_debug("Setting NTB format to 16-bit failed\n");
         }
 
@@ -362,23 +342,29 @@ static u8 cdc_ncm_setup(struct cdc_ncm_ctx *ctx)
 
         /* set Max Datagram Size (MTU) */
         if (flags & USB_CDC_NCM_NCAP_MAX_DATAGRAM_SIZE) {
-                __le16 max_datagram_size;
+                __le16 *max_datagram_size;
                 u16 eth_max_sz = le16_to_cpu(ctx->ether_desc->wMaxSegmentSize);
 
-                req.bmRequestType = USB_TYPE_CLASS | USB_DIR_IN |
-                                                        USB_RECIP_INTERFACE;
-                req.bNotificationType = USB_CDC_GET_MAX_DATAGRAM_SIZE;
-                req.wValue = 0;
-                req.wIndex = cpu_to_le16(iface_no);
-                req.wLength = cpu_to_le16(2);
+                max_datagram_size = kzalloc(sizeof(*max_datagram_size),
+                                GFP_KERNEL);
+                if (!max_datagram_size) {
+                        err = -ENOMEM;
+                        goto max_dgram_err;
+                }
 
-                err = cdc_ncm_do_request(ctx, &req, &max_datagram_size, 0, NULL,
-                                                                        1000);
-                if (err) {
+                err = usb_control_msg(ctx->udev, usb_rcvctrlpipe(ctx->udev, 0),
+                                USB_CDC_GET_MAX_DATAGRAM_SIZE,
+                                USB_TYPE_CLASS | USB_DIR_IN
+                                 | USB_RECIP_INTERFACE,
+                                0, iface_no, max_datagram_size,
+                                2, 1000);
+                if (err < 0) {
                         pr_debug("GET_MAX_DATAGRAM_SIZE failed, use size=%u\n",
                                                 CDC_NCM_MIN_DATAGRAM_SIZE);
+                        kfree(max_datagram_size);
                 } else {
-                        ctx->max_datagram_size = le16_to_cpu(max_datagram_size);
+                        ctx->max_datagram_size =
+                                le16_to_cpu(*max_datagram_size);
                         /* Check Eth descriptor value */
                         if (eth_max_sz < CDC_NCM_MAX_DATAGRAM_SIZE) {
                                 if (ctx->max_datagram_size > eth_max_sz)
@@ -395,17 +381,17 @@ static u8 cdc_ncm_setup(struct cdc_ncm_ctx *ctx)
                                         CDC_NCM_MIN_DATAGRAM_SIZE;
 
                         /* if value changed, update device */
-                        req.bmRequestType = USB_TYPE_CLASS | USB_DIR_OUT |
-                                                        USB_RECIP_INTERFACE;
-                        req.bNotificationType = USB_CDC_SET_MAX_DATAGRAM_SIZE;
-                        req.wValue = 0;
-                        req.wIndex = cpu_to_le16(iface_no);
-                        req.wLength = 2;
-                        max_datagram_size = cpu_to_le16(ctx->max_datagram_size);
-
-                        err = cdc_ncm_do_request(ctx, &req, &max_datagram_size,
-                                                                0, NULL, 1000);
-                        if (err)
+                        err = usb_control_msg(ctx->udev,
+                                                usb_sndctrlpipe(ctx->udev, 0),
+                                                USB_CDC_SET_MAX_DATAGRAM_SIZE,
+                                                USB_TYPE_CLASS | USB_DIR_OUT
+                                                 | USB_RECIP_INTERFACE,
+                                                0,
+                                                iface_no, max_datagram_size,
+                                                2, 1000);
+                        kfree(max_datagram_size);
+max_dgram_err:
+                        if (err < 0)
                                 pr_debug("SET_MAX_DATAGRAM_SIZE failed\n");
                 }
 
@@ -671,7 +657,7 @@ cdc_ncm_fill_tx_frame(struct cdc_ncm_ctx *ctx, struct sk_buff *skb)
         u32 rem;
         u32 offset;
         u32 last_offset;
-        u16 n = 0;
+        u16 n = 0, index;
         u8 ready2send = 0;
 
         /* if there is a remaining skb, it gets priority */
@@ -859,8 +845,8 @@ cdc_ncm_fill_tx_frame(struct cdc_ncm_ctx *ctx, struct sk_buff *skb)
                                         cpu_to_le16(sizeof(ctx->tx_ncm.nth16));
         ctx->tx_ncm.nth16.wSequence = cpu_to_le16(ctx->tx_seq);
         ctx->tx_ncm.nth16.wBlockLength = cpu_to_le16(last_offset);
-        ctx->tx_ncm.nth16.wNdpIndex = ALIGN(sizeof(struct usb_cdc_ncm_nth16),
-                                                        ctx->tx_ndp_modulus);
+        index = ALIGN(sizeof(struct usb_cdc_ncm_nth16), ctx->tx_ndp_modulus);
+        ctx->tx_ncm.nth16.wNdpIndex = cpu_to_le16(index);
 
         memcpy(skb_out->data, &(ctx->tx_ncm.nth16), sizeof(ctx->tx_ncm.nth16));
         ctx->tx_seq++;
@@ -873,12 +859,11 @@ cdc_ncm_fill_tx_frame(struct cdc_ncm_ctx *ctx, struct sk_buff *skb)
         ctx->tx_ncm.ndp16.wLength = cpu_to_le16(rem);
         ctx->tx_ncm.ndp16.wNextNdpIndex = 0; /* reserved */
 
-        memcpy(((u8 *)skb_out->data) + ctx->tx_ncm.nth16.wNdpIndex,
+        memcpy(((u8 *)skb_out->data) + index,
                                                 &(ctx->tx_ncm.ndp16),
                                                 sizeof(ctx->tx_ncm.ndp16));
 
-        memcpy(((u8 *)skb_out->data) + ctx->tx_ncm.nth16.wNdpIndex +
-                                        sizeof(ctx->tx_ncm.ndp16),
+        memcpy(((u8 *)skb_out->data) + index + sizeof(ctx->tx_ncm.ndp16),
                                         &(ctx->tx_ncm.dpe16),
                                         (ctx->tx_curr_frame_num + 1) *
                                         sizeof(struct usb_cdc_ncm_dpe16));
diff --git a/drivers/net/usb/rtl8150.c b/drivers/net/usb/rtl8150.c
index 041fb7d43c4f..ef3b236b5145 100644
--- a/drivers/net/usb/rtl8150.c
+++ b/drivers/net/usb/rtl8150.c
@@ -977,7 +977,6 @@ static void rtl8150_disconnect(struct usb_interface *intf)
         usb_set_intfdata(intf, NULL);
         if (dev) {
                 set_bit(RTL8150_UNPLUG, &dev->flags);
-                tasklet_disable(&dev->tl);
                 tasklet_kill(&dev->tl);
                 unregister_netdev(dev->netdev);
                 unlink_all_urbs(dev);
diff --git a/drivers/net/via-velocity.c b/drivers/net/via-velocity.c
index deb1eca13c9f..7c5336c5c37f 100644
--- a/drivers/net/via-velocity.c
+++ b/drivers/net/via-velocity.c
@@ -515,10 +515,6 @@ static void velocity_init_cam_filter(struct velocity_info *vptr)
         mac_set_cam_mask(regs, vptr->mCAMmask);
 
         /* Enable VCAMs */
-
-        if (test_bit(0, vptr->active_vlans))
-                WORD_REG_BITS_ON(MCFG_RTGOPT, &regs->MCFG);
-
         for_each_set_bit(vid, vptr->active_vlans, VLAN_N_VID) {
                 mac_set_vlan_cam(regs, i, (u8 *) &vid);
                 vptr->vCAMmask[i / 8] |= 0x1 << (i % 8);
diff --git a/drivers/net/vmxnet3/vmxnet3_drv.c b/drivers/net/vmxnet3/vmxnet3_drv.c
index 1cbacb389652..0959583feb27 100644
--- a/drivers/net/vmxnet3/vmxnet3_drv.c
+++ b/drivers/net/vmxnet3/vmxnet3_drv.c
@@ -1929,14 +1929,17 @@ static void
 vmxnet3_vlan_rx_add_vid(struct net_device *netdev, u16 vid)
 {
         struct vmxnet3_adapter *adapter = netdev_priv(netdev);
-        u32 *vfTable = adapter->shared->devRead.rxFilterConf.vfTable;
-        unsigned long flags;
 
-        VMXNET3_SET_VFTABLE_ENTRY(vfTable, vid);
-        spin_lock_irqsave(&adapter->cmd_lock, flags);
-        VMXNET3_WRITE_BAR1_REG(adapter, VMXNET3_REG_CMD,
-                               VMXNET3_CMD_UPDATE_VLAN_FILTERS);
-        spin_unlock_irqrestore(&adapter->cmd_lock, flags);
+        if (!(netdev->flags & IFF_PROMISC)) {
+                u32 *vfTable = adapter->shared->devRead.rxFilterConf.vfTable;
+                unsigned long flags;
+
+                VMXNET3_SET_VFTABLE_ENTRY(vfTable, vid);
+                spin_lock_irqsave(&adapter->cmd_lock, flags);
+                VMXNET3_WRITE_BAR1_REG(adapter, VMXNET3_REG_CMD,
+                                       VMXNET3_CMD_UPDATE_VLAN_FILTERS);
+                spin_unlock_irqrestore(&adapter->cmd_lock, flags);
+        }
 
         set_bit(vid, adapter->active_vlans);
 }
@@ -1946,14 +1949,17 @@ static void
 vmxnet3_vlan_rx_kill_vid(struct net_device *netdev, u16 vid)
 {
         struct vmxnet3_adapter *adapter = netdev_priv(netdev);
-        u32 *vfTable = adapter->shared->devRead.rxFilterConf.vfTable;
-        unsigned long flags;
 
-        VMXNET3_CLEAR_VFTABLE_ENTRY(vfTable, vid);
-        spin_lock_irqsave(&adapter->cmd_lock, flags);
-        VMXNET3_WRITE_BAR1_REG(adapter, VMXNET3_REG_CMD,
-                               VMXNET3_CMD_UPDATE_VLAN_FILTERS);
-        spin_unlock_irqrestore(&adapter->cmd_lock, flags);
+        if (!(netdev->flags & IFF_PROMISC)) {
+                u32 *vfTable = adapter->shared->devRead.rxFilterConf.vfTable;
+                unsigned long flags;
+
+                VMXNET3_CLEAR_VFTABLE_ENTRY(vfTable, vid);
+                spin_lock_irqsave(&adapter->cmd_lock, flags);
+                VMXNET3_WRITE_BAR1_REG(adapter, VMXNET3_REG_CMD,
+                                       VMXNET3_CMD_UPDATE_VLAN_FILTERS);
+                spin_unlock_irqrestore(&adapter->cmd_lock, flags);
+        }
 
         clear_bit(vid, adapter->active_vlans);
 }
diff --git a/drivers/net/wireless/ath/ath5k/base.c b/drivers/net/wireless/ath/ath5k/base.c
index f54dff44ed50..c3119a6caace 100644
--- a/drivers/net/wireless/ath/ath5k/base.c
+++ b/drivers/net/wireless/ath/ath5k/base.c
@@ -1735,6 +1735,8 @@ ath5k_beacon_setup(struct ath5k_hw *ah, struct ath5k_buf *bf)
 
         if (dma_mapping_error(ah->dev, bf->skbaddr)) {
                 ATH5K_ERR(ah, "beacon DMA mapping failed\n");
+                dev_kfree_skb_any(skb);
+                bf->skb = NULL;
                 return -EIO;
         }
 
@@ -1819,8 +1821,6 @@ ath5k_beacon_update(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
         ath5k_txbuf_free_skb(ah, avf->bbuf);
         avf->bbuf->skb = skb;
         ret = ath5k_beacon_setup(ah, avf->bbuf);
-        if (ret)
-                avf->bbuf->skb = NULL;
 out:
         return ret;
 }
@@ -1840,6 +1840,7 @@ ath5k_beacon_send(struct ath5k_hw *ah)
         struct ath5k_vif *avf;
         struct ath5k_buf *bf;
         struct sk_buff *skb;
+        int err;
 
         ATH5K_DBG_UNLIMIT(ah, ATH5K_DEBUG_BEACON, "in beacon_send\n");
 
@@ -1888,11 +1889,6 @@ ath5k_beacon_send(struct ath5k_hw *ah)
 
         avf = (void *)vif->drv_priv;
         bf = avf->bbuf;
-        if (unlikely(bf->skb == NULL || ah->opmode == NL80211_IFTYPE_STATION ||
-                     ah->opmode == NL80211_IFTYPE_MONITOR)) {
-                ATH5K_WARN(ah, "bf=%p bf_skb=%p\n", bf, bf ? bf->skb : NULL);
-                return;
-        }
 
         /*
          * Stop any current dma and put the new frame on the queue.
@@ -1906,8 +1902,17 @@ ath5k_beacon_send(struct ath5k_hw *ah)
 
         /* refresh the beacon for AP or MESH mode */
         if (ah->opmode == NL80211_IFTYPE_AP ||
-            ah->opmode == NL80211_IFTYPE_MESH_POINT)
-                ath5k_beacon_update(ah->hw, vif);
+            ah->opmode == NL80211_IFTYPE_MESH_POINT) {
+                err = ath5k_beacon_update(ah->hw, vif);
+                if (err)
+                        return;
+        }
+
+        if (unlikely(bf->skb == NULL || ah->opmode == NL80211_IFTYPE_STATION ||
+                     ah->opmode == NL80211_IFTYPE_MONITOR)) {
+                ATH5K_WARN(ah, "bf=%p bf_skb=%p\n", bf, bf->skb);
+                return;
+        }
 
         trace_ath5k_tx(ah, bf->skb, &ah->txqs[ah->bhalq]);
 
diff --git a/drivers/net/wireless/ath/ath9k/ar9002_hw.c b/drivers/net/wireless/ath/ath9k/ar9002_hw.c
index 9ff7c30573b8..44d9d8d56490 100644
--- a/drivers/net/wireless/ath/ath9k/ar9002_hw.c
+++ b/drivers/net/wireless/ath/ath9k/ar9002_hw.c
@@ -309,11 +309,7 @@ static void ar9002_hw_configpcipowersave(struct ath_hw *ah,
         u8 i;
         u32 val;
 
-        if (ah->is_pciexpress != true)
-                return;
-
-        /* Do not touch SerDes registers */
-        if (ah->config.pcie_powersave_enable == 2)
+        if (ah->is_pciexpress != true || ah->aspm_enabled != true)
                 return;
 
         /* Nothing to do on restore for 11N */
diff --git a/drivers/net/wireless/ath/ath9k/ar9003_eeprom.c b/drivers/net/wireless/ath/ath9k/ar9003_eeprom.c
index d109c25417f4..1b9400371eaf 100644
--- a/drivers/net/wireless/ath/ath9k/ar9003_eeprom.c
+++ b/drivers/net/wireless/ath/ath9k/ar9003_eeprom.c
@@ -69,7 +69,7 @@ static int ar9003_hw_power_interpolate(int32_t x,
 static const struct ar9300_eeprom ar9300_default = {
         .eepromVersion = 2,
         .templateVersion = 2,
-        .macAddr = {1, 2, 3, 4, 5, 6},
+        .macAddr = {0, 2, 3, 4, 5, 6},
         .custData = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                      0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
         .baseEepHeader = {
@@ -307,7 +307,7 @@ static const struct ar9300_eeprom ar9300_default = {
                  { { CTL(60, 0), CTL(60, 1), CTL(60, 0), CTL(60, 0) } },
                  { { CTL(60, 1), CTL(60, 0), CTL(60, 0), CTL(60, 1) } },
 
-                 { { CTL(60, 1), CTL(60, 0), CTL(0, 0), CTL(0, 0) } },
+                 { { CTL(60, 1), CTL(60, 0), CTL(60, 0), CTL(60, 0) } },
                  { { CTL(60, 0), CTL(60, 1), CTL(60, 0), CTL(60, 0) } },
                  { { CTL(60, 0), CTL(60, 1), CTL(60, 0), CTL(60, 0) } },
 
@@ -884,7 +884,7 @@ static const struct ar9300_eeprom ar9300_x113 = {
                  { { CTL(60, 0), CTL(60, 1), CTL(60, 0), CTL(60, 0) } },
                  { { CTL(60, 1), CTL(60, 0), CTL(60, 0), CTL(60, 1) } },
 
-                 { { CTL(60, 1), CTL(60, 0), CTL(0, 0), CTL(0, 0) } },
+                 { { CTL(60, 1), CTL(60, 0), CTL(60, 0), CTL(60, 0) } },
                  { { CTL(60, 0), CTL(60, 1), CTL(60, 0), CTL(60, 0) } },
                  { { CTL(60, 0), CTL(60, 1), CTL(60, 0), CTL(60, 0) } },
 
@@ -2040,7 +2040,7 @@ static const struct ar9300_eeprom ar9300_x112 = {
                 { { CTL(60, 0), CTL(60, 1), CTL(60, 0), CTL(60, 0) } },
                 { { CTL(60, 1), CTL(60, 0), CTL(60, 0), CTL(60, 1) } },
 
-                { { CTL(60, 1), CTL(60, 0), CTL(0, 0), CTL(0, 0) } },
+                { { CTL(60, 1), CTL(60, 0), CTL(60, 0), CTL(60, 0) } },
                 { { CTL(60, 0), CTL(60, 1), CTL(60, 0), CTL(60, 0) } },
                 { { CTL(60, 0), CTL(60, 1), CTL(60, 0), CTL(60, 0) } },
 
@@ -3734,7 +3734,7 @@ static void ar9003_hw_internal_regulator_apply(struct ath_hw *ah)
                                 }
                         } else {
                                 reg_pmu_set = (5 << 1) | (7 << 4) |
-                                              (1 << 8) | (2 << 14) |
+                                              (2 << 8) | (2 << 14) |
                                               (6 << 17) | (1 << 20) |
                                               (3 << 24) | (1 << 28);
                         }
diff --git a/drivers/net/wireless/ath/ath9k/ar9003_hw.c b/drivers/net/wireless/ath/ath9k/ar9003_hw.c
index 8efdec247c02..ad2bb2bf4e8a 100644
--- a/drivers/net/wireless/ath/ath9k/ar9003_hw.c
+++ b/drivers/net/wireless/ath/ath9k/ar9003_hw.c
@@ -519,11 +519,7 @@ static void ar9003_hw_configpcipowersave(struct ath_hw *ah,
                                          int restore,
                                          int power_off)
 {
-        if (ah->is_pciexpress != true)
-                return;
-
-        /* Do not touch SerDes registers */
-        if (ah->config.pcie_powersave_enable == 2)
+        if (ah->is_pciexpress != true || ah->aspm_enabled != true)
                 return;
 
         /* Nothing to do on restore for 11N */
diff --git a/drivers/net/wireless/ath/ath9k/ar9003_phy.h b/drivers/net/wireless/ath/ath9k/ar9003_phy.h
index 6de3f0bc18e6..5c590429f120 100644
--- a/drivers/net/wireless/ath/ath9k/ar9003_phy.h
+++ b/drivers/net/wireless/ath/ath9k/ar9003_phy.h
@@ -850,7 +850,7 @@
 #define AR_PHY_TPC_11_B1         (AR_SM1_BASE + 0x220)
 #define AR_PHY_PDADC_TAB_1       (AR_SM1_BASE + 0x240)
 #define AR_PHY_TX_IQCAL_STATUS_B1   (AR_SM1_BASE + 0x48c)
-#define AR_PHY_TX_IQCAL_CORR_COEFF_B1(_i)    (AR_SM_BASE + 0x450 + ((_i) << 2))
+#define AR_PHY_TX_IQCAL_CORR_COEFF_B1(_i)    (AR_SM1_BASE + 0x450 + ((_i) << 2))
 
 /*
  * Channel 2 Register Map
diff --git a/drivers/net/wireless/ath/ath9k/hw.c b/drivers/net/wireless/ath/ath9k/hw.c
index 8006ce0c7357..8dcefe74f4c3 100644
--- a/drivers/net/wireless/ath/ath9k/hw.c
+++ b/drivers/net/wireless/ath/ath9k/hw.c
@@ -318,6 +318,14 @@ static void ath9k_hw_disablepcie(struct ath_hw *ah)
         REG_WRITE(ah, AR_PCIE_SERDES2, 0x00000000);
 }
 
+static void ath9k_hw_aspm_init(struct ath_hw *ah)
+{
+        struct ath_common *common = ath9k_hw_common(ah);
+
+        if (common->bus_ops->aspm_init)
+                common->bus_ops->aspm_init(common);
+}
+
 /* This should work for all families including legacy */
 static bool ath9k_hw_chip_test(struct ath_hw *ah)
 {
@@ -378,7 +386,6 @@ static void ath9k_hw_init_config(struct ath_hw *ah)
         ah->config.additional_swba_backoff = 0;
         ah->config.ack_6mb = 0x0;
         ah->config.cwm_ignore_extcca = 0;
-        ah->config.pcie_powersave_enable = 0;
         ah->config.pcie_clock_req = 0;
         ah->config.pcie_waen = 0;
         ah->config.analog_shiftreg = 1;
@@ -598,7 +605,7 @@ static int __ath9k_hw_init(struct ath_hw *ah)
 
 
         if (ah->is_pciexpress)
-                ath9k_hw_configpcipowersave(ah, 0, 0);
+                ath9k_hw_aspm_init(ah);
         else
                 ath9k_hw_disablepcie(ah);
 
diff --git a/drivers/net/wireless/ath/ath9k/hw.h b/drivers/net/wireless/ath/ath9k/hw.h
index 6acd0f975ae1..c79889036ec4 100644
--- a/drivers/net/wireless/ath/ath9k/hw.h
+++ b/drivers/net/wireless/ath/ath9k/hw.h
@@ -219,7 +219,6 @@ struct ath9k_ops_config {
         int additional_swba_backoff;
         int ack_6mb;
         u32 cwm_ignore_extcca;
-        u8 pcie_powersave_enable;
         bool pcieSerDesWrite;
         u8 pcie_clock_req;
         u32 pcie_waen;
@@ -673,6 +672,7 @@ struct ath_hw {
 
         bool sw_mgmt_crypto;
         bool is_pciexpress;
+        bool aspm_enabled;
         bool is_monitoring;
         bool need_an_top2_fixup;
         u16 tx_trig_level;
@@ -874,6 +874,7 @@ struct ath_bus_ops {
         bool (*eeprom_read)(struct ath_common *common, u32 off, u16 *data);
         void (*bt_coex_prep)(struct ath_common *common);
         void (*extn_synch_en)(struct ath_common *common);
+        void (*aspm_init)(struct ath_common *common);
 };
 
 static inline struct ath_common *ath9k_hw_common(struct ath_hw *ah)
diff --git a/drivers/net/wireless/ath/ath9k/init.c b/drivers/net/wireless/ath/ath9k/init.c
index ac5107172f94..aa0ff7e2c922 100644
--- a/drivers/net/wireless/ath/ath9k/init.c
+++ b/drivers/net/wireless/ath/ath9k/init.c
@@ -670,8 +670,10 @@ static void ath9k_init_band_txpower(struct ath_softc *sc, int band)
 static void ath9k_init_txpower_limits(struct ath_softc *sc)
 {
         struct ath_hw *ah = sc->sc_ah;
+        struct ath_common *common = ath9k_hw_common(sc->sc_ah);
         struct ath9k_channel *curchan = ah->curchan;
 
+        ah->txchainmask = common->tx_chainmask;
         if (ah->caps.hw_caps & ATH9K_HW_CAP_2GHZ)
                 ath9k_init_band_txpower(sc, IEEE80211_BAND_2GHZ);
         if (ah->caps.hw_caps & ATH9K_HW_CAP_5GHZ)
diff --git a/drivers/net/wireless/ath/ath9k/main.c b/drivers/net/wireless/ath/ath9k/main.c
index 9098aaad97a9..6530694a59ae 100644
--- a/drivers/net/wireless/ath/ath9k/main.c
+++ b/drivers/net/wireless/ath/ath9k/main.c
@@ -2283,7 +2283,11 @@ static void ath9k_set_coverage_class(struct ieee80211_hw *hw, u8 coverage_class)
 
         mutex_lock(&sc->mutex);
         ah->coverage_class = coverage_class;
+
+        ath9k_ps_wakeup(sc);
         ath9k_hw_init_global_settings(ah);
+        ath9k_ps_restore(sc);
+
         mutex_unlock(&sc->mutex);
 }
 
diff --git a/drivers/net/wireless/ath/ath9k/pci.c b/drivers/net/wireless/ath/ath9k/pci.c
index 3bad0b2cf9a3..be4ea1329813 100644
--- a/drivers/net/wireless/ath/ath9k/pci.c
+++ b/drivers/net/wireless/ath/ath9k/pci.c
@@ -16,6 +16,7 @@
 
 #include <linux/nl80211.h>
 #include <linux/pci.h>
+#include <linux/pci-aspm.h>
 #include <linux/ath9k_platform.h>
 #include "ath9k.h"
 
@@ -115,12 +116,38 @@ static void ath_pci_extn_synch_enable(struct ath_common *common)
         pci_write_config_byte(pdev, sc->sc_ah->caps.pcie_lcr_offset, lnkctl);
 }
 
+static void ath_pci_aspm_init(struct ath_common *common)
+{
+        struct ath_softc *sc = (struct ath_softc *) common->priv;
+        struct ath_hw *ah = sc->sc_ah;
+        struct pci_dev *pdev = to_pci_dev(sc->dev);
+        struct pci_dev *parent;
+        int pos;
+        u8 aspm;
+
+        if (!pci_is_pcie(pdev))
+                return;
+
+        parent = pdev->bus->self;
+        if (WARN_ON(!parent))
+                return;
+
+        pos = pci_pcie_cap(parent);
+        pci_read_config_byte(parent, pos +  PCI_EXP_LNKCTL, &aspm);
+        if (aspm & (PCIE_LINK_STATE_L0S | PCIE_LINK_STATE_L1)) {
+                ah->aspm_enabled = true;
+                /* Initialize PCIe PM and SERDES registers. */
+                ath9k_hw_configpcipowersave(ah, 0, 0);
+        }
+}
+
 static const struct ath_bus_ops ath_pci_bus_ops = {
         .ath_bus_type = ATH_PCI,
         .read_cachesize = ath_pci_read_cachesize,
         .eeprom_read = ath_pci_eeprom_read,
         .bt_coex_prep = ath_pci_bt_coex_prep,
         .extn_synch_en = ath_pci_extn_synch_enable,
+        .aspm_init = ath_pci_aspm_init,
 };
 
 static int ath_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
diff --git a/drivers/net/wireless/ath/carl9170/main.c b/drivers/net/wireless/ath/carl9170/main.c
index 0122930b14c7..0474e6638d21 100644
--- a/drivers/net/wireless/ath/carl9170/main.c
+++ b/drivers/net/wireless/ath/carl9170/main.c
@@ -1066,8 +1066,10 @@ static int carl9170_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
          * the high througput speed in 802.11n networks.
          */
 
-        if (!is_main_vif(ar, vif))
+        if (!is_main_vif(ar, vif)) {
+                mutex_lock(&ar->mutex);
                 goto err_softw;
+        }
 
         /*
          * While the hardware supports *catch-all* key, for offloading
diff --git a/drivers/net/wireless/b43/dma.c b/drivers/net/wireless/b43/dma.c
index 83cba22ac6e8..481e534534eb 100644
--- a/drivers/net/wireless/b43/dma.c
+++ b/drivers/net/wireless/b43/dma.c
@@ -795,9 +795,23 @@ static u64 supported_dma_mask(struct b43_wldev *dev)
         u32 tmp;
         u16 mmio_base;
 
-        tmp = b43_read32(dev, SSB_TMSHIGH);
-        if (tmp & SSB_TMSHIGH_DMA64)
-                return DMA_BIT_MASK(64);
+        switch (dev->dev->bus_type) {
+#ifdef CONFIG_B43_BCMA
+        case B43_BUS_BCMA:
+                tmp = bcma_aread32(dev->dev->bdev, BCMA_IOST);
+                if (tmp & BCMA_IOST_DMA64)
+                        return DMA_BIT_MASK(64);
+                break;
+#endif
+#ifdef CONFIG_B43_SSB
+        case B43_BUS_SSB:
+                tmp = ssb_read32(dev->dev->sdev, SSB_TMSHIGH);
+                if (tmp & SSB_TMSHIGH_DMA64)
+                        return DMA_BIT_MASK(64);
+                break;
+#endif
+        }
+
         mmio_base = b43_dmacontroller_base(0, 0);
         b43_write32(dev, mmio_base + B43_DMA32_TXCTL, B43_DMA32_TXADDREXT_MASK);
         tmp = b43_read32(dev, mmio_base + B43_DMA32_TXCTL);
diff --git a/drivers/net/wireless/hostap/hostap_cs.c b/drivers/net/wireless/hostap/hostap_cs.c
index c052a0d5cbdd..5441ad195119 100644
--- a/drivers/net/wireless/hostap/hostap_cs.c
+++ b/drivers/net/wireless/hostap/hostap_cs.c
@@ -648,6 +648,8 @@ static const struct pcmcia_device_id hostap_cs_ids[] = {
                                          0x74c5e40d),
         PCMCIA_DEVICE_MANF_CARD_PROD_ID1(0x0156, 0x0002, "Intersil",
                                          0x4b801a17),
+        PCMCIA_DEVICE_MANF_CARD_PROD_ID3(0x0156, 0x0002, "Version 01.02",
+                                         0x4b74baa0),
         PCMCIA_MFC_DEVICE_PROD_ID12(0, "SanDisk", "ConnectPlus",
                                     0x7a954bd9, 0x74be00c6),
         PCMCIA_DEVICE_PROD_ID123(
diff --git a/drivers/net/wireless/iwlegacy/iwl-3945.c b/drivers/net/wireless/iwlegacy/iwl-3945.c
index dab67a12d73b..73fe3cdf796b 100644
--- a/drivers/net/wireless/iwlegacy/iwl-3945.c
+++ b/drivers/net/wireless/iwlegacy/iwl-3945.c
@@ -1746,7 +1746,11 @@ int iwl3945_commit_rxon(struct iwl_priv *priv, struct iwl_rxon_context *ctx)
                 }
 
                 memcpy(active_rxon, staging_rxon, sizeof(*active_rxon));
-
+                /*
+                 * We do not commit tx power settings while channel changing,
+                 * do it now if tx power changed.
+                 */
+                iwl_legacy_set_tx_power(priv, priv->tx_power_next, false);
                 return 0;
         }
 
diff --git a/drivers/net/wireless/iwlegacy/iwl-4965.c b/drivers/net/wireless/iwlegacy/iwl-4965.c
index bd4b000733f7..ecdc6e557428 100644
--- a/drivers/net/wireless/iwlegacy/iwl-4965.c
+++ b/drivers/net/wireless/iwlegacy/iwl-4965.c
@@ -1235,7 +1235,12 @@ static int iwl4965_commit_rxon(struct iwl_priv *priv, struct iwl_rxon_context *c
 
                 memcpy(active_rxon, &ctx->staging, sizeof(*active_rxon));
                 iwl_legacy_print_rx_config_cmd(priv, ctx);
-                goto set_tx_power;
+                /*
+                 * We do not commit tx power settings while channel changing,
+                 * do it now if tx power changed.
+                 */
+                iwl_legacy_set_tx_power(priv, priv->tx_power_next, false);
+                return 0;
         }
 
         /* If we are currently associated and the new config requires
@@ -1315,7 +1320,6 @@ static int iwl4965_commit_rxon(struct iwl_priv *priv, struct iwl_rxon_context *c
 
         iwl4965_init_sensitivity(priv);
 
-set_tx_power:
         /* If we issue a new RXON command which required a tune then we must
          * send a new TXPOWER command or we won't be able to Tx any frames */
         ret = iwl_legacy_set_tx_power(priv, priv->tx_power_next, true);
diff --git a/drivers/net/wireless/iwlwifi/iwl-5000.c b/drivers/net/wireless/iwlwifi/iwl-5000.c
index 3eeb12ebe6e9..c95cefd529dc 100644
--- a/drivers/net/wireless/iwlwifi/iwl-5000.c
+++ b/drivers/net/wireless/iwlwifi/iwl-5000.c
@@ -365,6 +365,7 @@ static struct iwl_base_params iwl5000_base_params = {
         .chain_noise_scale = 1000,
         .wd_timeout = IWL_LONG_WD_TIMEOUT,
         .max_event_log_size = 512,
+        .no_idle_support = true,
 };
 static struct iwl_ht_params iwl5000_ht_params = {
         .ht_greenfield_support = true,
diff --git a/drivers/net/wireless/iwlwifi/iwl-core.h b/drivers/net/wireless/iwlwifi/iwl-core.h
index 3e6bb734dcb7..02817a438550 100644
--- a/drivers/net/wireless/iwlwifi/iwl-core.h
+++ b/drivers/net/wireless/iwlwifi/iwl-core.h
@@ -135,6 +135,7 @@ struct iwl_mod_params {
  * @temperature_kelvin: temperature report by uCode in kelvin
  * @max_event_log_size: size of event log buffer size for ucode event logging
  * @shadow_reg_enable: HW shadhow register bit
+ * @no_idle_support: do not support idle mode
  */
 struct iwl_base_params {
         int eeprom_size;
@@ -156,6 +157,7 @@ struct iwl_base_params {
         bool temperature_kelvin;
         u32 max_event_log_size;
         const bool shadow_reg_enable;
+        const bool no_idle_support;
 };
 /*
  * @advanced_bt_coexist: support advanced bt coexist
diff --git a/drivers/net/wireless/iwlwifi/iwl-pci.c b/drivers/net/wireless/iwlwifi/iwl-pci.c
index fb7e436b40c7..2fdbffa079c1 100644
--- a/drivers/net/wireless/iwlwifi/iwl-pci.c
+++ b/drivers/net/wireless/iwlwifi/iwl-pci.c
@@ -134,6 +134,7 @@ static void iwl_pci_apm_config(struct iwl_bus *bus)
 static void iwl_pci_set_drv_data(struct iwl_bus *bus, void *drv_data)
 {
         bus->drv_data = drv_data;
+        pci_set_drvdata(IWL_BUS_GET_PCI_DEV(bus), drv_data);
 }
 
 static void iwl_pci_get_hw_id(struct iwl_bus *bus, char buf[],
@@ -454,8 +455,6 @@ static int iwl_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                 pci_write_config_word(pdev, PCI_COMMAND, pci_cmd);
         }
 
-        pci_set_drvdata(pdev, bus);
-
         bus->dev = &pdev->dev;
         bus->irq = pdev->irq;
         bus->ops = &pci_ops;
@@ -479,26 +478,22 @@ out_no_pci:
         return err;
 }
 
-static void iwl_pci_down(struct iwl_bus *bus)
-{
-        struct iwl_pci_bus *pci_bus = (struct iwl_pci_bus *) bus->bus_specific;
-
-        pci_disable_msi(pci_bus->pci_dev);
-        pci_iounmap(pci_bus->pci_dev, pci_bus->hw_base);
-        pci_release_regions(pci_bus->pci_dev);
-        pci_disable_device(pci_bus->pci_dev);
-        pci_set_drvdata(pci_bus->pci_dev, NULL);
-
-        kfree(bus);
-}
-
 static void __devexit iwl_pci_remove(struct pci_dev *pdev)
 {
-        struct iwl_bus *bus = pci_get_drvdata(pdev);
+        struct iwl_priv *priv = pci_get_drvdata(pdev);
+        struct iwl_bus *bus = priv->bus;
+        struct iwl_pci_bus *pci_bus = IWL_BUS_GET_PCI_BUS(bus);
+        struct pci_dev *pci_dev = IWL_BUS_GET_PCI_DEV(bus);
 
-        iwl_remove(bus->drv_data);
+        iwl_remove(priv);
 
-        iwl_pci_down(bus);
+        pci_disable_msi(pci_dev);
+        pci_iounmap(pci_dev, pci_bus->hw_base);
+        pci_release_regions(pci_dev);
+        pci_disable_device(pci_dev);
+        pci_set_drvdata(pci_dev, NULL);
+
+        kfree(bus);
 }
 
 #ifdef CONFIG_PM
@@ -506,20 +501,20 @@ static void __devexit iwl_pci_remove(struct pci_dev *pdev)
 static int iwl_pci_suspend(struct device *device)
 {
         struct pci_dev *pdev = to_pci_dev(device);
-        struct iwl_bus *bus = pci_get_drvdata(pdev);
+        struct iwl_priv *priv = pci_get_drvdata(pdev);
 
         /* Before you put code here, think about WoWLAN. You cannot check here
          * whether WoWLAN is enabled or not, and your code will run even if
          * WoWLAN is enabled - don't kill the NIC, someone may need it in Sx.
          */
 
-        return iwl_suspend(bus->drv_data);
+        return iwl_suspend(priv);
 }
 
 static int iwl_pci_resume(struct device *device)
 {
         struct pci_dev *pdev = to_pci_dev(device);
-        struct iwl_bus *bus = pci_get_drvdata(pdev);
+        struct iwl_priv *priv = pci_get_drvdata(pdev);
 
         /* Before you put code here, think about WoWLAN. You cannot check here
          * whether WoWLAN is enabled or not, and your code will run even if
@@ -532,7 +527,7 @@ static int iwl_pci_resume(struct device *device)
          */
         pci_write_config_byte(pdev, PCI_CFG_RETRY_TIMEOUT, 0x00);
 
-        return iwl_resume(bus->drv_data);
+        return iwl_resume(priv);
 }
 
 static SIMPLE_DEV_PM_OPS(iwl_dev_pm_ops, iwl_pci_suspend, iwl_pci_resume);
diff --git a/drivers/net/wireless/iwlwifi/iwl-power.c b/drivers/net/wireless/iwlwifi/iwl-power.c
index 3ec619c6881c..cd64df05f9ed 100644
--- a/drivers/net/wireless/iwlwifi/iwl-power.c
+++ b/drivers/net/wireless/iwlwifi/iwl-power.c
@@ -349,7 +349,8 @@ static void iwl_power_build_cmd(struct iwl_priv *priv,
 
         if (priv->wowlan)
                 iwl_static_sleep_cmd(priv, cmd, IWL_POWER_INDEX_5, dtimper);
-        else if (priv->hw->conf.flags & IEEE80211_CONF_IDLE)
+        else if (!priv->cfg->base_params->no_idle_support &&
+                 priv->hw->conf.flags & IEEE80211_CONF_IDLE)
                 iwl_static_sleep_cmd(priv, cmd, IWL_POWER_INDEX_5, 20);
         else if (iwl_tt_is_low_power_state(priv)) {
                 /* in thermal throttling low power state */
diff --git a/drivers/net/wireless/orinoco/orinoco_cs.c b/drivers/net/wireless/orinoco/orinoco_cs.c
index 3f7fc4a0b43d..d7dbc00bcfbe 100644
--- a/drivers/net/wireless/orinoco/orinoco_cs.c
+++ b/drivers/net/wireless/orinoco/orinoco_cs.c
@@ -239,7 +239,6 @@ static int orinoco_cs_resume(struct pcmcia_device *link)
 
 static const struct pcmcia_device_id orinoco_cs_ids[] = {
         PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0777), /* 3Com AirConnect PCI 777A */
-        PCMCIA_DEVICE_MANF_CARD(0x0156, 0x0002), /* Lucent Orinoco and old Intersil */
         PCMCIA_DEVICE_MANF_CARD(0x016b, 0x0001), /* Ericsson WLAN Card C11 */
         PCMCIA_DEVICE_MANF_CARD(0x01eb, 0x080a), /* Nortel Networks eMobility 802.11 Wireless Adapter */
         PCMCIA_DEVICE_MANF_CARD(0x0261, 0x0002), /* AirWay 802.11 Adapter (PCMCIA) */
@@ -272,6 +271,7 @@ static const struct pcmcia_device_id orinoco_cs_ids[] = {
         PCMCIA_DEVICE_PROD_ID12("PROXIM", "LAN PCI CARD HARMONY 80211B", 0xc6536a5e, 0x9f494e26),
         PCMCIA_DEVICE_PROD_ID12("SAMSUNG", "11Mbps WLAN Card", 0x43d74cb4, 0x579bd91b),
         PCMCIA_DEVICE_PROD_ID12("Symbol Technologies", "LA4111 Spectrum24 Wireless LAN PC Card", 0x3f02b4d6, 0x3663cb0e),
+        PCMCIA_DEVICE_MANF_CARD_PROD_ID3(0x0156, 0x0002, "Version 01.01", 0xd27deb1a), /* Lucent Orinoco */
 #ifdef CONFIG_HERMES_PRISM
         /* Only entries that certainly identify Prism chipset */
         PCMCIA_DEVICE_MANF_CARD(0x000b, 0x7100), /* SonicWALL Long Range Wireless Card */
@@ -321,6 +321,9 @@ static const struct pcmcia_device_id orinoco_cs_ids[] = {
         PCMCIA_DEVICE_PROD_ID3("ISL37100P", 0x630d52b2),
         PCMCIA_DEVICE_PROD_ID3("ISL37101P-10", 0xdd97a26b),
         PCMCIA_DEVICE_PROD_ID3("ISL37300P", 0xc9049a39),
+
+        /* This may be Agere or Intersil Firmware */
+        PCMCIA_DEVICE_MANF_CARD(0x0156, 0x0002),
 #endif
         PCMCIA_DEVICE_NULL,
 };
diff --git a/drivers/net/wireless/rt2x00/rt2800lib.c b/drivers/net/wireless/rt2x00/rt2800lib.c
index 84ab7d1acb6a..ef67f6786a84 100644
--- a/drivers/net/wireless/rt2x00/rt2800lib.c
+++ b/drivers/net/wireless/rt2x00/rt2800lib.c
@@ -703,8 +703,7 @@ void rt2800_write_beacon(struct queue_entry *entry, struct txentry_desc *txdesc)
         /*
          * Add space for the TXWI in front of the skb.
          */
-        skb_push(entry->skb, TXWI_DESC_SIZE);
-        memset(entry->skb, 0, TXWI_DESC_SIZE);
+        memset(skb_push(entry->skb, TXWI_DESC_SIZE), 0, TXWI_DESC_SIZE);
 
         /*
          * Register descriptor details in skb frame descriptor.
diff --git a/drivers/net/wireless/rt2x00/rt2800usb.c b/drivers/net/wireless/rt2x00/rt2800usb.c
index 507559361d87..dbf501ca317f 100644
--- a/drivers/net/wireless/rt2x00/rt2800usb.c
+++ b/drivers/net/wireless/rt2x00/rt2800usb.c
@@ -464,6 +464,15 @@ static bool rt2800usb_txdone_entry_check(struct queue_entry *entry, u32 reg)
         int wcid, ack, pid;
         int tx_wcid, tx_ack, tx_pid;
 
+        if (test_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags) ||
+            !test_bit(ENTRY_DATA_STATUS_PENDING, &entry->flags)) {
+                WARNING(entry->queue->rt2x00dev,
+                        "Data pending for entry %u in queue %u\n",
+                        entry->entry_idx, entry->queue->qid);
+                cond_resched();
+                return false;
+        }
+
         wcid    = rt2x00_get_field32(reg, TX_STA_FIFO_WCID);
         ack     = rt2x00_get_field32(reg, TX_STA_FIFO_TX_ACK_REQUIRED);
         pid     = rt2x00_get_field32(reg, TX_STA_FIFO_PID_TYPE);
@@ -529,12 +538,11 @@ static void rt2800usb_txdone(struct rt2x00_dev *rt2x00dev)
                         entry = rt2x00queue_get_entry(queue, Q_INDEX_DONE);
                         if (rt2800usb_txdone_entry_check(entry, reg))
                                 break;
+                        entry = NULL;
                 }
 
-                if (!entry || rt2x00queue_empty(queue))
-                        break;
-
-                rt2800_txdone_entry(entry, reg);
+                if (entry)
+                        rt2800_txdone_entry(entry, reg);
         }
 }
 
@@ -558,8 +566,10 @@ static void rt2800usb_work_txdone(struct work_struct *work)
                 while (!rt2x00queue_empty(queue)) {
                         entry = rt2x00queue_get_entry(queue, Q_INDEX_DONE);
 
-                        if (test_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags))
+                        if (test_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags) ||
+                            !test_bit(ENTRY_DATA_STATUS_PENDING, &entry->flags))
                                 break;
+
                         if (test_bit(ENTRY_DATA_IO_FAILED, &entry->flags))
                                 rt2x00lib_txdone_noinfo(entry, TXDONE_FAILURE);
                         else if (rt2x00queue_status_timeout(entry))
@@ -921,6 +931,8 @@ static struct usb_device_id rt2800usb_device_table[] = {
         { USB_DEVICE(0x07d1, 0x3c16) },
         /* Draytek */
         { USB_DEVICE(0x07fa, 0x7712) },
+        /* DVICO */
+        { USB_DEVICE(0x0fe9, 0xb307) },
         /* Edimax */
         { USB_DEVICE(0x7392, 0x7711) },
         { USB_DEVICE(0x7392, 0x7717) },
diff --git a/drivers/net/wireless/rt2x00/rt2x00lib.h b/drivers/net/wireless/rt2x00/rt2x00lib.h
index 15cdc7e57fc4..4cdf247a870d 100644
--- a/drivers/net/wireless/rt2x00/rt2x00lib.h
+++ b/drivers/net/wireless/rt2x00/rt2x00lib.h
@@ -355,7 +355,8 @@ static inline enum cipher rt2x00crypto_key_to_cipher(struct ieee80211_key_conf *
         return CIPHER_NONE;
 }
 
-static inline void rt2x00crypto_create_tx_descriptor(struct queue_entry *entry,
+static inline void rt2x00crypto_create_tx_descriptor(struct rt2x00_dev *rt2x00dev,
+                                                     struct sk_buff *skb,
                                                      struct txentry_desc *txdesc)
 {
 }
diff --git a/drivers/net/wireless/rt2x00/rt2x00mac.c b/drivers/net/wireless/rt2x00/rt2x00mac.c
index 8efab3983528..4ccf23805973 100644
--- a/drivers/net/wireless/rt2x00/rt2x00mac.c
+++ b/drivers/net/wireless/rt2x00/rt2x00mac.c
@@ -113,7 +113,7 @@ void rt2x00mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
          * due to possible race conditions in mac80211.
          */
         if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))
-                goto exit_fail;
+                goto exit_free_skb;
 
         /*
          * Use the ATIM queue if appropriate and present.
@@ -127,7 +127,7 @@ void rt2x00mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
                 ERROR(rt2x00dev,
                       "Attempt to send packet over invalid queue %d.\n"
                       "Please file bug report to %s.\n", qid, DRV_PROJECT);
-                goto exit_fail;
+                goto exit_free_skb;
         }
 
         /*
@@ -159,6 +159,7 @@ void rt2x00mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
 
  exit_fail:
         rt2x00queue_pause_queue(queue);
+ exit_free_skb:
         dev_kfree_skb_any(skb);
 }
 EXPORT_SYMBOL_GPL(rt2x00mac_tx);
diff --git a/drivers/net/wireless/rt2x00/rt2x00usb.c b/drivers/net/wireless/rt2x00/rt2x00usb.c
index b6b4542c2460..1e31050dafc9 100644
--- a/drivers/net/wireless/rt2x00/rt2x00usb.c
+++ b/drivers/net/wireless/rt2x00/rt2x00usb.c
@@ -262,23 +262,20 @@ static void rt2x00usb_interrupt_txdone(struct urb *urb)
         struct queue_entry *entry = (struct queue_entry *)urb->context;
         struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
 
-        if (!test_and_clear_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags))
+        if (!test_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags))
                 return;
-
-        if (rt2x00dev->ops->lib->tx_dma_done)
-                rt2x00dev->ops->lib->tx_dma_done(entry);
-
-        /*
-         * Report the frame as DMA done
-         */
-        rt2x00lib_dmadone(entry);
-
         /*
          * Check if the frame was correctly uploaded
          */
         if (urb->status)
                 set_bit(ENTRY_DATA_IO_FAILED, &entry->flags);
+        /*
+         * Report the frame as DMA done
+         */
+        rt2x00lib_dmadone(entry);
 
+        if (rt2x00dev->ops->lib->tx_dma_done)
+                rt2x00dev->ops->lib->tx_dma_done(entry);
         /*
          * Schedule the delayed work for reading the TX status
          * from the device.
@@ -874,18 +871,8 @@ int rt2x00usb_suspend(struct usb_interface *usb_intf, pm_message_t state)
 {
         struct ieee80211_hw *hw = usb_get_intfdata(usb_intf);
         struct rt2x00_dev *rt2x00dev = hw->priv;
-        int retval;
-
-        retval = rt2x00lib_suspend(rt2x00dev, state);
-        if (retval)
-                return retval;
 
-        /*
-         * Decrease usbdev refcount.
-         */
-        usb_put_dev(interface_to_usbdev(usb_intf));
-
-        return 0;
+        return rt2x00lib_suspend(rt2x00dev, state);
 }
 EXPORT_SYMBOL_GPL(rt2x00usb_suspend);
 
@@ -894,8 +881,6 @@ int rt2x00usb_resume(struct usb_interface *usb_intf)
         struct ieee80211_hw *hw = usb_get_intfdata(usb_intf);
         struct rt2x00_dev *rt2x00dev = hw->priv;
 
-        usb_get_dev(interface_to_usbdev(usb_intf));
-
         return rt2x00lib_resume(rt2x00dev);
 }
 EXPORT_SYMBOL_GPL(rt2x00usb_resume);
diff --git a/drivers/net/wireless/rt2x00/rt73usb.c b/drivers/net/wireless/rt2x00/rt73usb.c
index 6a93939f44e8..0baeb894f093 100644
--- a/drivers/net/wireless/rt2x00/rt73usb.c
+++ b/drivers/net/wireless/rt2x00/rt73usb.c
@@ -2420,6 +2420,7 @@ static struct usb_device_id rt73usb_device_table[] = {
         /* Buffalo */
         { USB_DEVICE(0x0411, 0x00d8) },
         { USB_DEVICE(0x0411, 0x00d9) },
+        { USB_DEVICE(0x0411, 0x00e6) },
         { USB_DEVICE(0x0411, 0x00f4) },
         { USB_DEVICE(0x0411, 0x0116) },
         { USB_DEVICE(0x0411, 0x0119) },
diff --git a/drivers/net/wireless/rtlwifi/pci.c b/drivers/net/wireless/rtlwifi/pci.c
index 5efd57833489..56f12358389d 100644
--- a/drivers/net/wireless/rtlwifi/pci.c
+++ b/drivers/net/wireless/rtlwifi/pci.c
@@ -1696,15 +1696,17 @@ static bool _rtl_pci_find_adapter(struct pci_dev *pdev,
         pcipriv->ndis_adapter.devnumber = PCI_SLOT(pdev->devfn);
         pcipriv->ndis_adapter.funcnumber = PCI_FUNC(pdev->devfn);
 
-        /*find bridge info */
-        pcipriv->ndis_adapter.pcibridge_vendorid = bridge_pdev->vendor;
-        for (tmp = 0; tmp < PCI_BRIDGE_VENDOR_MAX; tmp++) {
-                if (bridge_pdev->vendor == pcibridge_vendors[tmp]) {
-                        pcipriv->ndis_adapter.pcibridge_vendor = tmp;
-                        RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
-                                 ("Pci Bridge Vendor is found index: %d\n",
-                                  tmp));
-                        break;
+        if (bridge_pdev) {
+                /*find bridge info if available */
+                pcipriv->ndis_adapter.pcibridge_vendorid = bridge_pdev->vendor;
+                for (tmp = 0; tmp < PCI_BRIDGE_VENDOR_MAX; tmp++) {
+                        if (bridge_pdev->vendor == pcibridge_vendors[tmp]) {
+                                pcipriv->ndis_adapter.pcibridge_vendor = tmp;
+                                RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
+                                         ("Pci Bridge Vendor is found index:"
+                                         " %d\n", tmp));
+                                break;
+                        }
                 }
         }
 
diff --git a/drivers/net/wireless/rtlwifi/rtl8192cu/sw.c b/drivers/net/wireless/rtlwifi/rtl8192cu/sw.c
index 942f7a3969a7..ef63c0df006a 100644
--- a/drivers/net/wireless/rtlwifi/rtl8192cu/sw.c
+++ b/drivers/net/wireless/rtlwifi/rtl8192cu/sw.c
@@ -281,6 +281,8 @@ static struct usb_device_id rtl8192c_usb_ids[] = {
         {RTL_USB_DEVICE(USB_VENDER_ID_REALTEK, 0x817d, rtl92cu_hal_cfg)},
         /* 8188CE-VAU USB minCard (b/g mode only) */
         {RTL_USB_DEVICE(USB_VENDER_ID_REALTEK, 0x817e, rtl92cu_hal_cfg)},
+        /* 8188RU in Alfa AWUS036NHR */
+        {RTL_USB_DEVICE(USB_VENDER_ID_REALTEK, 0x817f, rtl92cu_hal_cfg)},
         /* 8188 Combo for BC4 */
         {RTL_USB_DEVICE(USB_VENDER_ID_REALTEK, 0x8754, rtl92cu_hal_cfg)},
 
@@ -303,20 +305,23 @@ static struct usb_device_id rtl8192c_usb_ids[] = {
         {RTL_USB_DEVICE(0x0eb0, 0x9071, rtl92cu_hal_cfg)}, /*NO Brand - Etop*/
         /* HP - Lite-On ,8188CUS Slim Combo */
         {RTL_USB_DEVICE(0x103c, 0x1629, rtl92cu_hal_cfg)},
+        {RTL_USB_DEVICE(0x13d3, 0x3357, rtl92cu_hal_cfg)}, /* AzureWave */
         {RTL_USB_DEVICE(0x2001, 0x3308, rtl92cu_hal_cfg)}, /*D-Link - Alpha*/
         {RTL_USB_DEVICE(0x2019, 0xab2a, rtl92cu_hal_cfg)}, /*Planex - Abocom*/
         {RTL_USB_DEVICE(0x2019, 0xed17, rtl92cu_hal_cfg)}, /*PCI - Edimax*/
         {RTL_USB_DEVICE(0x20f4, 0x648b, rtl92cu_hal_cfg)}, /*TRENDnet - Cameo*/
         {RTL_USB_DEVICE(0x7392, 0x7811, rtl92cu_hal_cfg)}, /*Edimax - Edimax*/
-        {RTL_USB_DEVICE(0x3358, 0x13d3, rtl92cu_hal_cfg)}, /*Azwave 8188CE-VAU*/
+        {RTL_USB_DEVICE(0x13d3, 0x3358, rtl92cu_hal_cfg)}, /*Azwave 8188CE-VAU*/
         /* Russian customer -Azwave (8188CE-VAU  b/g mode only) */
-        {RTL_USB_DEVICE(0x3359, 0x13d3, rtl92cu_hal_cfg)},
+        {RTL_USB_DEVICE(0x13d3, 0x3359, rtl92cu_hal_cfg)},
+        {RTL_USB_DEVICE(0x4855, 0x0090, rtl92cu_hal_cfg)}, /* Feixun */
+        {RTL_USB_DEVICE(0x4855, 0x0091, rtl92cu_hal_cfg)}, /* NetweeN-Feixun */
+        {RTL_USB_DEVICE(0x9846, 0x9041, rtl92cu_hal_cfg)}, /* Netgear Cameo */
 
         /****** 8192CU ********/
         {RTL_USB_DEVICE(0x0586, 0x341f, rtl92cu_hal_cfg)}, /*Zyxel -Abocom*/
         {RTL_USB_DEVICE(0x07aa, 0x0056, rtl92cu_hal_cfg)}, /*ATKK-Gemtek*/
         {RTL_USB_DEVICE(0x07b8, 0x8178, rtl92cu_hal_cfg)}, /*Funai -Abocom*/
-        {RTL_USB_DEVICE(0x07b8, 0x8178, rtl92cu_hal_cfg)}, /*Abocom -Abocom*/
         {RTL_USB_DEVICE(0x2001, 0x3307, rtl92cu_hal_cfg)}, /*D-Link-Cameo*/
         {RTL_USB_DEVICE(0x2001, 0x3309, rtl92cu_hal_cfg)}, /*D-Link-Alpha*/
         {RTL_USB_DEVICE(0x2001, 0x330a, rtl92cu_hal_cfg)}, /*D-Link-Alpha*/
diff --git a/drivers/net/wireless/wl1251/acx.c b/drivers/net/wireless/wl1251/acx.c
index ef8370edace7..ad87a1ac6462 100644
--- a/drivers/net/wireless/wl1251/acx.c
+++ b/drivers/net/wireless/wl1251/acx.c
@@ -140,8 +140,6 @@ int wl1251_acx_sleep_auth(struct wl1251 *wl, u8 sleep_auth)
         auth->sleep_auth = sleep_auth;
 
         ret = wl1251_cmd_configure(wl, ACX_SLEEP_AUTH, auth, sizeof(*auth));
-        if (ret < 0)
-                return ret;
 
 out:
         kfree(auth);
@@ -681,10 +679,8 @@ int wl1251_acx_cca_threshold(struct wl1251 *wl)
 
         ret = wl1251_cmd_configure(wl, ACX_CCA_THRESHOLD,
                                    detection, sizeof(*detection));
-        if (ret < 0) {
+        if (ret < 0)
                 wl1251_warning("failed to set cca threshold: %d", ret);
-                return ret;
-        }
 
 out:
         kfree(detection);
diff --git a/drivers/net/wireless/wl1251/cmd.c b/drivers/net/wireless/wl1251/cmd.c
index 81f164bc4888..d14d69d733a0 100644
--- a/drivers/net/wireless/wl1251/cmd.c
+++ b/drivers/net/wireless/wl1251/cmd.c
@@ -241,7 +241,7 @@ int wl1251_cmd_data_path(struct wl1251 *wl, u8 channel, bool enable)
         if (ret < 0) {
                 wl1251_error("tx %s cmd for channel %d failed",
                              enable ? "start" : "stop", channel);
-                return ret;
+                goto out;
         }
 
         wl1251_debug(DEBUG_BOOT, "tx %s cmd channel %d",
diff --git a/drivers/net/wireless/wl12xx/acx.c b/drivers/net/wireless/wl12xx/acx.c
index 7e33f1f4f3d4..34f6ab53e519 100644
--- a/drivers/net/wireless/wl12xx/acx.c
+++ b/drivers/net/wireless/wl12xx/acx.c
@@ -77,8 +77,6 @@ int wl1271_acx_sleep_auth(struct wl1271 *wl, u8 sleep_auth)
         auth->sleep_auth = sleep_auth;
 
         ret = wl1271_cmd_configure(wl, ACX_SLEEP_AUTH, auth, sizeof(*auth));
-        if (ret < 0)
-                return ret;
 
 out:
         kfree(auth);
@@ -624,10 +622,8 @@ int wl1271_acx_cca_threshold(struct wl1271 *wl)
 
         ret = wl1271_cmd_configure(wl, ACX_CCA_THRESHOLD,
                                    detection, sizeof(*detection));
-        if (ret < 0) {
+        if (ret < 0)
                 wl1271_warning("failed to set cca threshold: %d", ret);
-                return ret;
-        }
 
 out:
         kfree(detection);
diff --git a/drivers/net/wireless/wl12xx/main.c b/drivers/net/wireless/wl12xx/main.c
index e58c22d21e39..b70ae40ad660 100644
--- a/drivers/net/wireless/wl12xx/main.c
+++ b/drivers/net/wireless/wl12xx/main.c
@@ -4283,6 +4283,7 @@ int wl1271_init_ieee80211(struct wl1271 *wl)
         wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
                 BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP);
         wl->hw->wiphy->max_scan_ssids = 1;
+        wl->hw->wiphy->max_sched_scan_ssids = 1;
         /*
          * Maximum length of elements in scanning probe request templates
          * should be the maximum length possible for a template, without
diff --git a/drivers/net/wireless/wl12xx/sdio.c b/drivers/net/wireless/wl12xx/sdio.c
index 5cf18c2c23f0..fb1fd5af75ea 100644
--- a/drivers/net/wireless/wl12xx/sdio.c
+++ b/drivers/net/wireless/wl12xx/sdio.c
@@ -164,7 +164,7 @@ static int wl1271_sdio_power_on(struct wl1271 *wl)
         /* If enabled, tell runtime PM not to power off the card */
         if (pm_runtime_enabled(&func->dev)) {
                 ret = pm_runtime_get_sync(&func->dev);
-                if (ret)
+                if (ret < 0)
                         goto out;
         } else {
                 /* Runtime PM is disabled: power up the card manually */
diff --git a/drivers/net/wireless/wl12xx/testmode.c b/drivers/net/wireless/wl12xx/testmode.c
index 5d5e1ef87206..4ae8effaee22 100644
--- a/drivers/net/wireless/wl12xx/testmode.c
+++ b/drivers/net/wireless/wl12xx/testmode.c
@@ -36,7 +36,6 @@ enum wl1271_tm_commands {
         WL1271_TM_CMD_TEST,
         WL1271_TM_CMD_INTERROGATE,
         WL1271_TM_CMD_CONFIGURE,
-        WL1271_TM_CMD_NVS_PUSH,
         WL1271_TM_CMD_SET_PLT_MODE,
         WL1271_TM_CMD_RECOVER,
 
@@ -139,12 +138,15 @@ static int wl1271_tm_cmd_interrogate(struct wl1271 *wl, struct nlattr *tb[])
 
         if (ret < 0) {
                 wl1271_warning("testmode cmd interrogate failed: %d", ret);
+                kfree(cmd);
                 return ret;
         }
 
         skb = cfg80211_testmode_alloc_reply_skb(wl->hw->wiphy, sizeof(*cmd));
-        if (!skb)
+        if (!skb) {
+                kfree(cmd);
                 return -ENOMEM;
+        }
 
         NLA_PUT(skb, WL1271_TM_ATTR_DATA, sizeof(*cmd), cmd);
 
@@ -187,48 +189,6 @@ static int wl1271_tm_cmd_configure(struct wl1271 *wl, struct nlattr *tb[])
         return 0;
 }
 
-static int wl1271_tm_cmd_nvs_push(struct wl1271 *wl, struct nlattr *tb[])
-{
-        int ret = 0;
-        size_t len;
-        void *buf;
-
-        wl1271_debug(DEBUG_TESTMODE, "testmode cmd nvs push");
-
-        if (!tb[WL1271_TM_ATTR_DATA])
-                return -EINVAL;
-
-        buf = nla_data(tb[WL1271_TM_ATTR_DATA]);
-        len = nla_len(tb[WL1271_TM_ATTR_DATA]);
-
-        mutex_lock(&wl->mutex);
-
-        kfree(wl->nvs);
-
-        if ((wl->chip.id == CHIP_ID_1283_PG20) &&
-            (len != sizeof(struct wl128x_nvs_file)))
-                return -EINVAL;
-        else if (len != sizeof(struct wl1271_nvs_file))
-                return -EINVAL;
-
-        wl->nvs = kzalloc(len, GFP_KERNEL);
-        if (!wl->nvs) {
-                wl1271_error("could not allocate memory for the nvs file");
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        memcpy(wl->nvs, buf, len);
-        wl->nvs_len = len;
-
-        wl1271_debug(DEBUG_TESTMODE, "testmode pushed nvs");
-
-out:
-        mutex_unlock(&wl->mutex);
-
-        return ret;
-}
-
 static int wl1271_tm_cmd_set_plt_mode(struct wl1271 *wl, struct nlattr *tb[])
 {
         u32 val;
@@ -285,8 +245,6 @@ int wl1271_tm_cmd(struct ieee80211_hw *hw, void *data, int len)
                 return wl1271_tm_cmd_interrogate(wl, tb);
         case WL1271_TM_CMD_CONFIGURE:
                 return wl1271_tm_cmd_configure(wl, tb);
-        case WL1271_TM_CMD_NVS_PUSH:
-                return wl1271_tm_cmd_nvs_push(wl, tb);
         case WL1271_TM_CMD_SET_PLT_MODE:
                 return wl1271_tm_cmd_set_plt_mode(wl, tb);
         case WL1271_TM_CMD_RECOVER:
diff --git a/drivers/of/address.c b/drivers/of/address.c
index da1f4b9605df..72c33fbe451d 100644
--- a/drivers/of/address.c
+++ b/drivers/of/address.c
@@ -610,6 +610,6 @@ void __iomem *of_iomap(struct device_node *np, int index)
         if (of_address_to_resource(np, index, &res))
                 return NULL;
 
-        return ioremap(res.start, 1 + res.end - res.start);
+        return ioremap(res.start, resource_size(&res));
 }
 EXPORT_SYMBOL(of_iomap);
diff --git a/drivers/of/base.c b/drivers/of/base.c
index 02ed36719def..3ff22e32b602 100644
--- a/drivers/of/base.c
+++ b/drivers/of/base.c
@@ -610,8 +610,9 @@ EXPORT_SYMBOL(of_find_node_by_phandle);
  *
  * The out_value is modified only if a valid u32 value can be decoded.
  */
-int of_property_read_u32_array(const struct device_node *np, char *propname,
-                               u32 *out_values, size_t sz)
+int of_property_read_u32_array(const struct device_node *np,
+                               const char *propname, u32 *out_values,
+                               size_t sz)
 {
         struct property *prop = of_find_property(np, propname, NULL);
         const __be32 *val;
@@ -645,7 +646,7 @@ EXPORT_SYMBOL_GPL(of_property_read_u32_array);
  *
  * The out_string pointer is modified only if a valid string can be decoded.
  */
-int of_property_read_string(struct device_node *np, char *propname,
+int of_property_read_string(struct device_node *np, const char *propname,
                                 const char **out_string)
 {
         struct property *prop = of_find_property(np, propname, NULL);
diff --git a/drivers/of/gpio.c b/drivers/of/gpio.c
index 3007662ac614..ef0105fa52b1 100644
--- a/drivers/of/gpio.c
+++ b/drivers/of/gpio.c
@@ -127,8 +127,8 @@ EXPORT_SYMBOL(of_gpio_count);
  * gpio chips. This function performs only one sanity check: whether gpio
  * is less than ngpios (that is specified in the gpio_chip).
  */
-static int of_gpio_simple_xlate(struct gpio_chip *gc, struct device_node *np,
-                                const void *gpio_spec, u32 *flags)
+int of_gpio_simple_xlate(struct gpio_chip *gc, struct device_node *np,
+                         const void *gpio_spec, u32 *flags)
 {
         const __be32 *gpio = gpio_spec;
         const u32 n = be32_to_cpup(gpio);
@@ -152,6 +152,7 @@ static int of_gpio_simple_xlate(struct gpio_chip *gc, struct device_node *np,
 
         return n;
 }
+EXPORT_SYMBOL(of_gpio_simple_xlate);
 
 /**
  * of_mm_gpiochip_add - Add memory mapped GPIO chip (bank)
diff --git a/drivers/pci/hotplug/acpiphp_glue.c b/drivers/pci/hotplug/acpiphp_glue.c
index a70fa89f76fd..220285760b68 100644
--- a/drivers/pci/hotplug/acpiphp_glue.c
+++ b/drivers/pci/hotplug/acpiphp_glue.c
@@ -110,7 +110,7 @@ static int post_dock_fixups(struct notifier_block *nb, unsigned long val,
 }
 
 
-static struct acpi_dock_ops acpiphp_dock_ops = {
+static const struct acpi_dock_ops acpiphp_dock_ops = {
         .handler = handle_hotplug_event_func,
 };
 
diff --git a/drivers/pci/hotplug/pcihp_slot.c b/drivers/pci/hotplug/pcihp_slot.c
index 749fdf070319..3ffd9c1acc0a 100644
--- a/drivers/pci/hotplug/pcihp_slot.c
+++ b/drivers/pci/hotplug/pcihp_slot.c
@@ -158,47 +158,6 @@ static void program_hpp_type2(struct pci_dev *dev, struct hpp_type2 *hpp)
          */
 }
 
-/* Program PCIE MaxPayload setting on device: ensure parent maxpayload <= device */
-static int pci_set_payload(struct pci_dev *dev)
-{
-       int pos, ppos;
-       u16 pctl, psz;
-       u16 dctl, dsz, dcap, dmax;
-       struct pci_dev *parent;
-
-       parent = dev->bus->self;
-       pos = pci_find_capability(dev, PCI_CAP_ID_EXP);
-       if (!pos)
-               return 0;
-
-       /* Read Device MaxPayload capability and setting */
-       pci_read_config_word(dev, pos + PCI_EXP_DEVCTL, &dctl);
-       pci_read_config_word(dev, pos + PCI_EXP_DEVCAP, &dcap);
-       dsz = (dctl & PCI_EXP_DEVCTL_PAYLOAD) >> 5;
-       dmax = (dcap & PCI_EXP_DEVCAP_PAYLOAD);
-
-       /* Read Parent MaxPayload setting */
-       ppos = pci_find_capability(parent, PCI_CAP_ID_EXP);
-       if (!ppos)
-               return 0;
-       pci_read_config_word(parent, ppos + PCI_EXP_DEVCTL, &pctl);
-       psz = (pctl &  PCI_EXP_DEVCTL_PAYLOAD) >> 5;
-
-       /* If parent payload > device max payload -> error
-        * If parent payload > device payload -> set speed
-        * If parent payload <= device payload -> do nothing
-        */
-       if (psz > dmax)
-               return -1;
-       else if (psz > dsz) {
-               dev_info(&dev->dev, "Setting MaxPayload to %d\n", 128 << psz);
-               pci_write_config_word(dev, pos + PCI_EXP_DEVCTL,
-                                     (dctl & ~PCI_EXP_DEVCTL_PAYLOAD) +
-                                     (psz << 5));
-       }
-       return 0;
-}
-
 void pci_configure_slot(struct pci_dev *dev)
 {
         struct pci_dev *cdev;
@@ -210,9 +169,9 @@ void pci_configure_slot(struct pci_dev *dev)
                         (dev->class >> 8) == PCI_CLASS_BRIDGE_PCI)))
                 return;
 
-       ret = pci_set_payload(dev);
-       if (ret)
-               dev_warn(&dev->dev, "could not set device max payload\n");
+        if (dev->bus && dev->bus->self)
+                pcie_bus_configure_settings(dev->bus,
+                                            dev->bus->self->pcie_mpss);
 
         memset(&hpp, 0, sizeof(hpp));
         ret = pci_get_hp_params(dev, &hpp);
diff --git a/drivers/pci/of.c b/drivers/pci/of.c
index c94d37ec55c8..f0929934bb7a 100644
--- a/drivers/pci/of.c
+++ b/drivers/pci/of.c
@@ -55,7 +55,7 @@ struct device_node * __weak pcibios_get_phb_of_node(struct pci_bus *bus)
          */
         if (bus->bridge->of_node)
                 return of_node_get(bus->bridge->of_node);
-        if (bus->bridge->parent->of_node)
+        if (bus->bridge->parent && bus->bridge->parent->of_node)
                 return of_node_get(bus->bridge->parent->of_node);
         return NULL;
 }
diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index 08a95b369d85..4e84fd4a4312 100644
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -77,6 +77,8 @@ unsigned long pci_cardbus_mem_size = DEFAULT_CARDBUS_MEM_SIZE;
 unsigned long pci_hotplug_io_size  = DEFAULT_HOTPLUG_IO_SIZE;
 unsigned long pci_hotplug_mem_size = DEFAULT_HOTPLUG_MEM_SIZE;
 
+enum pcie_bus_config_types pcie_bus_config = PCIE_BUS_SAFE;
+
 /*
  * The default CLS is used if arch didn't set CLS explicitly and not
  * all pci devices agree on the same value.  Arch can override either
@@ -3223,6 +3225,67 @@ out:
 EXPORT_SYMBOL(pcie_set_readrq);
 
 /**
+ * pcie_get_mps - get PCI Express maximum payload size
+ * @dev: PCI device to query
+ *
+ * Returns maximum payload size in bytes
+ *    or appropriate error value.
+ */
+int pcie_get_mps(struct pci_dev *dev)
+{
+        int ret, cap;
+        u16 ctl;
+
+        cap = pci_pcie_cap(dev);
+        if (!cap)
+                return -EINVAL;
+
+        ret = pci_read_config_word(dev, cap + PCI_EXP_DEVCTL, &ctl);
+        if (!ret)
+                ret = 128 << ((ctl & PCI_EXP_DEVCTL_PAYLOAD) >> 5);
+
+        return ret;
+}
+
+/**
+ * pcie_set_mps - set PCI Express maximum payload size
+ * @dev: PCI device to query
+ * @mps: maximum payload size in bytes
+ *    valid values are 128, 256, 512, 1024, 2048, 4096
+ *
+ * If possible sets maximum payload size
+ */
+int pcie_set_mps(struct pci_dev *dev, int mps)
+{
+        int cap, err = -EINVAL;
+        u16 ctl, v;
+
+        if (mps < 128 || mps > 4096 || !is_power_of_2(mps))
+                goto out;
+
+        v = ffs(mps) - 8;
+        if (v > dev->pcie_mpss) 
+                goto out;
+        v <<= 5;
+
+        cap = pci_pcie_cap(dev);
+        if (!cap)
+                goto out;
+
+        err = pci_read_config_word(dev, cap + PCI_EXP_DEVCTL, &ctl);
+        if (err)
+                goto out;
+
+        if ((ctl & PCI_EXP_DEVCTL_PAYLOAD) != v) {
+                ctl &= ~PCI_EXP_DEVCTL_PAYLOAD;
+                ctl |= v;
+                err = pci_write_config_word(dev, cap + PCI_EXP_DEVCTL, ctl);
+        }
+out:
+        return err;
+}
+
+/**
  * pci_select_bars - Make BAR mask from the type of resource
  * @dev: the PCI device for which BAR mask is made
  * @flags: resource type mask to be selected
@@ -3505,6 +3568,10 @@ static int __init pci_setup(char *str)
                                 pci_hotplug_io_size = memparse(str + 9, &str);
                         } else if (!strncmp(str, "hpmemsize=", 10)) {
                                 pci_hotplug_mem_size = memparse(str + 10, &str);
+                        } else if (!strncmp(str, "pcie_bus_safe", 13)) {
+                                pcie_bus_config = PCIE_BUS_SAFE;
+                        } else if (!strncmp(str, "pcie_bus_perf", 13)) {
+                                pcie_bus_config = PCIE_BUS_PERFORMANCE;
                         } else {
                                 printk(KERN_ERR "PCI: Unknown option `%s'\n",
                                                 str);
diff --git a/drivers/pci/pci.h b/drivers/pci/pci.h
index c8cee764b0de..b74084e9ca12 100644
--- a/drivers/pci/pci.h
+++ b/drivers/pci/pci.h
@@ -283,6 +283,8 @@ static inline int pci_iov_bus_range(struct pci_bus *bus)
 
 #endif /* CONFIG_PCI_IOV */
 
+extern unsigned long pci_cardbus_resource_alignment(struct resource *);
+
 static inline resource_size_t pci_resource_alignment(struct pci_dev *dev,
                                          struct resource *res)
 {
@@ -292,6 +294,8 @@ static inline resource_size_t pci_resource_alignment(struct pci_dev *dev,
         if (resno >= PCI_IOV_RESOURCES && resno <= PCI_IOV_RESOURCE_END)
                 return pci_sriov_resource_alignment(dev, resno);
 #endif
+        if (dev->class >> 8  == PCI_CLASS_BRIDGE_CARDBUS)
+                return pci_cardbus_resource_alignment(res);
         return resource_alignment(res);
 }
 
diff --git a/drivers/pci/probe.c b/drivers/pci/probe.c
index 795c9026d55f..b1187ff31d89 100644
--- a/drivers/pci/probe.c
+++ b/drivers/pci/probe.c
@@ -856,6 +856,8 @@ void set_pcie_port_type(struct pci_dev *pdev)
         pdev->pcie_cap = pos;
         pci_read_config_word(pdev, pos + PCI_EXP_FLAGS, &reg16);
         pdev->pcie_type = (reg16 & PCI_EXP_FLAGS_TYPE) >> 4;
+        pci_read_config_word(pdev, pos + PCI_EXP_DEVCAP, &reg16);
+        pdev->pcie_mpss = reg16 & PCI_EXP_DEVCAP_PAYLOAD;
 }
 
 void set_pcie_hotplug_bridge(struct pci_dev *pdev)
@@ -1326,6 +1328,150 @@ int pci_scan_slot(struct pci_bus *bus, int devfn)
         return nr;
 }
 
+static int pcie_find_smpss(struct pci_dev *dev, void *data)
+{
+        u8 *smpss = data;
+
+        if (!pci_is_pcie(dev))
+                return 0;
+
+        /* For PCIE hotplug enabled slots not connected directly to a
+         * PCI-E root port, there can be problems when hotplugging
+         * devices.  This is due to the possibility of hotplugging a
+         * device into the fabric with a smaller MPS that the devices
+         * currently running have configured.  Modifying the MPS on the
+         * running devices could cause a fatal bus error due to an
+         * incoming frame being larger than the newly configured MPS.
+         * To work around this, the MPS for the entire fabric must be
+         * set to the minimum size.  Any devices hotplugged into this
+         * fabric will have the minimum MPS set.  If the PCI hotplug
+         * slot is directly connected to the root port and there are not
+         * other devices on the fabric (which seems to be the most
+         * common case), then this is not an issue and MPS discovery
+         * will occur as normal.
+         */
+        if (dev->is_hotplug_bridge && (!list_is_singular(&dev->bus->devices) ||
+            dev->bus->self->pcie_type != PCI_EXP_TYPE_ROOT_PORT))
+                *smpss = 0;
+
+        if (*smpss > dev->pcie_mpss)
+                *smpss = dev->pcie_mpss;
+
+        return 0;
+}
+
+static void pcie_write_mps(struct pci_dev *dev, int mps)
+{
+        int rc, dev_mpss;
+
+        dev_mpss = 128 << dev->pcie_mpss;
+
+        if (pcie_bus_config == PCIE_BUS_PERFORMANCE) {
+                if (dev->bus->self) {
+                        dev_dbg(&dev->bus->dev, "Bus MPSS %d\n",
+                                128 << dev->bus->self->pcie_mpss);
+
+                        /* For "MPS Force Max", the assumption is made that
+                         * downstream communication will never be larger than
+                         * the MRRS.  So, the MPS only needs to be configured
+                         * for the upstream communication.  This being the case,
+                         * walk from the top down and set the MPS of the child
+                         * to that of the parent bus.
+                         */
+                        mps = 128 << dev->bus->self->pcie_mpss;
+                        if (mps > dev_mpss)
+                                dev_warn(&dev->dev, "MPS configured higher than"
+                                         " maximum supported by the device.  If"
+                                         " a bus issue occurs, try running with"
+                                         " pci=pcie_bus_safe.\n");
+                }
+
+                dev->pcie_mpss = ffs(mps) - 8;
+        }
+
+        rc = pcie_set_mps(dev, mps);
+        if (rc)
+                dev_err(&dev->dev, "Failed attempting to set the MPS\n");
+}
+
+static void pcie_write_mrrs(struct pci_dev *dev, int mps)
+{
+        int rc, mrrs, dev_mpss;
+
+        /* In the "safe" case, do not configure the MRRS.  There appear to be
+         * issues with setting MRRS to 0 on a number of devices.
+         */
+
+        if (pcie_bus_config != PCIE_BUS_PERFORMANCE)
+                return;
+
+        dev_mpss = 128 << dev->pcie_mpss;
+
+        /* For Max performance, the MRRS must be set to the largest supported
+         * value.  However, it cannot be configured larger than the MPS the
+         * device or the bus can support.  This assumes that the largest MRRS
+         * available on the device cannot be smaller than the device MPSS.
+         */
+        mrrs = min(mps, dev_mpss);
+
+        /* MRRS is a R/W register.  Invalid values can be written, but a
+         * subsequent read will verify if the value is acceptable or not.
+         * If the MRRS value provided is not acceptable (e.g., too large),
+         * shrink the value until it is acceptable to the HW.
+         */
+        while (mrrs != pcie_get_readrq(dev) && mrrs >= 128) {
+                dev_warn(&dev->dev, "Attempting to modify the PCI-E MRRS value"
+                         " to %d.  If any issues are encountered, please try "
+                         "running with pci=pcie_bus_safe\n", mrrs);
+                rc = pcie_set_readrq(dev, mrrs);
+                if (rc)
+                        dev_err(&dev->dev,
+                                "Failed attempting to set the MRRS\n");
+
+                mrrs /= 2;
+        }
+}
+
+static int pcie_bus_configure_set(struct pci_dev *dev, void *data)
+{
+        int mps = 128 << *(u8 *)data;
+
+        if (!pci_is_pcie(dev))
+                return 0;
+
+        dev_dbg(&dev->dev, "Dev MPS %d MPSS %d MRRS %d\n",
+                 pcie_get_mps(dev), 128<<dev->pcie_mpss, pcie_get_readrq(dev));
+
+        pcie_write_mps(dev, mps);
+        pcie_write_mrrs(dev, mps);
+
+        dev_dbg(&dev->dev, "Dev MPS %d MPSS %d MRRS %d\n",
+                 pcie_get_mps(dev), 128<<dev->pcie_mpss, pcie_get_readrq(dev));
+
+        return 0;
+}
+
+/* pcie_bus_configure_mps requires that pci_walk_bus work in a top-down,
+ * parents then children fashion.  If this changes, then this code will not
+ * work as designed.
+ */
+void pcie_bus_configure_settings(struct pci_bus *bus, u8 mpss)
+{
+        u8 smpss = mpss;
+
+        if (!pci_is_pcie(bus->self))
+                return;
+
+        if (pcie_bus_config == PCIE_BUS_SAFE) {
+                pcie_find_smpss(bus->self, &smpss);
+                pci_walk_bus(bus, pcie_find_smpss, &smpss);
+        }
+
+        pcie_bus_configure_set(bus->self, &smpss);
+        pci_walk_bus(bus, pcie_bus_configure_set, &smpss);
+}
+EXPORT_SYMBOL_GPL(pcie_bus_configure_settings);
+
 unsigned int __devinit pci_scan_child_bus(struct pci_bus *bus)
 {
         unsigned int devfn, pass, max = bus->secondary;
diff --git a/drivers/pci/setup-bus.c b/drivers/pci/setup-bus.c
index 8a1d3c7863a8..784da9d36029 100644
--- a/drivers/pci/setup-bus.c
+++ b/drivers/pci/setup-bus.c
@@ -34,6 +34,7 @@ struct resource_list_x {
         resource_size_t start;
         resource_size_t end;
         resource_size_t add_size;
+        resource_size_t min_align;
         unsigned long flags;
 };
 
@@ -65,7 +66,7 @@ void pci_realloc(void)
  */
 static void add_to_list(struct resource_list_x *head,
                  struct pci_dev *dev, struct resource *res,
-                 resource_size_t add_size)
+                 resource_size_t add_size, resource_size_t min_align)
 {
         struct resource_list_x *list = head;
         struct resource_list_x *ln = list->next;
@@ -84,13 +85,16 @@ static void add_to_list(struct resource_list_x *head,
         tmp->end = res->end;
         tmp->flags = res->flags;
         tmp->add_size = add_size;
+        tmp->min_align = min_align;
         list->next = tmp;
 }
 
 static void add_to_failed_list(struct resource_list_x *head,
                                 struct pci_dev *dev, struct resource *res)
 {
-        add_to_list(head, dev, res, 0);
+        add_to_list(head, dev, res,
+                        0 /* dont care */,
+                        0 /* dont care */);
 }
 
 static void __dev_sort_resources(struct pci_dev *dev,
@@ -121,18 +125,18 @@ static inline void reset_resource(struct resource *res)
 }
 
 /**
- * adjust_resources_sorted() - satisfy any additional resource requests
+ * reassign_resources_sorted() - satisfy any additional resource requests
  *
- * @add_head : head of the list tracking requests requiring additional
+ * @realloc_head : head of the list tracking requests requiring additional
  *             resources
  * @head     : head of the list tracking requests with allocated
  *             resources
  *
- * Walk through each element of the add_head and try to procure
+ * Walk through each element of the realloc_head and try to procure
  * additional resources for the element, provided the element
  * is in the head list.
  */
-static void adjust_resources_sorted(struct resource_list_x *add_head,
+static void reassign_resources_sorted(struct resource_list_x *realloc_head,
                 struct resource_list *head)
 {
         struct resource *res;
@@ -141,8 +145,8 @@ static void adjust_resources_sorted(struct resource_list_x *add_head,
         resource_size_t add_size;
         int idx;
 
-        prev = add_head;
-        for (list = add_head->next; list;) {
+        prev = realloc_head;
+        for (list = realloc_head->next; list;) {
                 res = list->res;
                 /* skip resource that has been reset */
                 if (!res->flags)
@@ -159,13 +163,17 @@ static void adjust_resources_sorted(struct resource_list_x *add_head,
 
                 idx = res - &list->dev->resource[0];
                 add_size=list->add_size;
-                if (!resource_size(res) && add_size) {
-                         res->end = res->start + add_size - 1;
-                         if(pci_assign_resource(list->dev, idx))
+                if (!resource_size(res)) {
+                        res->start = list->start;
+                        res->end = res->start + add_size - 1;
+                        if(pci_assign_resource(list->dev, idx))
                                 reset_resource(res);
-                } else if (add_size) {
-                        adjust_resource(res, res->start,
-                                resource_size(res) + add_size);
+                } else {
+                        resource_size_t align = list->min_align;
+                        res->flags |= list->flags & (IORESOURCE_STARTALIGN|IORESOURCE_SIZEALIGN);
+                        if (pci_reassign_resource(list->dev, idx, add_size, align))
+                                dev_printk(KERN_DEBUG, &list->dev->dev, "failed to add optional resources res=%pR\n",
+                                                        res);
                 }
 out:
                 tmp = list;
@@ -210,16 +218,16 @@ static void assign_requested_resources_sorted(struct resource_list *head,
 }
 
 static void __assign_resources_sorted(struct resource_list *head,
-                                 struct resource_list_x *add_head,
+                                 struct resource_list_x *realloc_head,
                                  struct resource_list_x *fail_head)
 {
         /* Satisfy the must-have resource requests */
         assign_requested_resources_sorted(head, fail_head);
 
-        /* Try to satisfy any additional nice-to-have resource
+        /* Try to satisfy any additional optional resource
                 requests */
-        if (add_head)
-                adjust_resources_sorted(add_head, head);
+        if (realloc_head)
+                reassign_resources_sorted(realloc_head, head);
         free_list(resource_list, head);
 }
 
@@ -235,7 +243,7 @@ static void pdev_assign_resources_sorted(struct pci_dev *dev,
 }
 
 static void pbus_assign_resources_sorted(const struct pci_bus *bus,
-                                         struct resource_list_x *add_head,
+                                         struct resource_list_x *realloc_head,
                                          struct resource_list_x *fail_head)
 {
         struct pci_dev *dev;
@@ -245,7 +253,7 @@ static void pbus_assign_resources_sorted(const struct pci_bus *bus,
         list_for_each_entry(dev, &bus->devices, bus_list)
                 __dev_sort_resources(dev, &head);
 
-        __assign_resources_sorted(&head, add_head, fail_head);
+        __assign_resources_sorted(&head, realloc_head, fail_head);
 }
 
 void pci_setup_cardbus(struct pci_bus *bus)
@@ -540,13 +548,27 @@ static resource_size_t calculate_memsize(resource_size_t size,
         return size;
 }
 
+static resource_size_t get_res_add_size(struct resource_list_x *realloc_head,
+                                        struct resource *res)
+{
+        struct resource_list_x *list;
+
+        /* check if it is in realloc_head list */
+        for (list = realloc_head->next; list && list->res != res;
+                        list = list->next);
+        if (list)
+                return list->add_size;
+
+        return 0;
+}
+
 /**
  * pbus_size_io() - size the io window of a given bus
  *
  * @bus : the bus
  * @min_size : the minimum io window that must to be allocated
  * @add_size : additional optional io window
- * @add_head : track the additional io window on this list
+ * @realloc_head : track the additional io window on this list
  *
  * Sizing the IO windows of the PCI-PCI bridge is trivial,
  * since these windows have 4K granularity and the IO ranges
@@ -554,11 +576,12 @@ static resource_size_t calculate_memsize(resource_size_t size,
  * We must be careful with the ISA aliasing though.
  */
 static void pbus_size_io(struct pci_bus *bus, resource_size_t min_size,
-                resource_size_t add_size, struct resource_list_x *add_head)
+                resource_size_t add_size, struct resource_list_x *realloc_head)
 {
         struct pci_dev *dev;
         struct resource *b_res = find_free_bus_resource(bus, IORESOURCE_IO);
         unsigned long size = 0, size0 = 0, size1 = 0;
+        resource_size_t children_add_size = 0;
 
         if (!b_res)
                 return;
@@ -579,11 +602,16 @@ static void pbus_size_io(struct pci_bus *bus, resource_size_t min_size,
                                 size += r_size;
                         else
                                 size1 += r_size;
+
+                        if (realloc_head)
+                                children_add_size += get_res_add_size(realloc_head, r);
                 }
         }
         size0 = calculate_iosize(size, min_size, size1,
                         resource_size(b_res), 4096);
-        size1 = (!add_head || (add_head && !add_size)) ? size0 :
+        if (children_add_size > add_size)
+                add_size = children_add_size;
+        size1 = (!realloc_head || (realloc_head && !add_size)) ? size0 :
                 calculate_iosize(size, min_size+add_size, size1,
                         resource_size(b_res), 4096);
         if (!size0 && !size1) {
@@ -598,8 +626,8 @@ static void pbus_size_io(struct pci_bus *bus, resource_size_t min_size,
         b_res->start = 4096;
         b_res->end = b_res->start + size0 - 1;
         b_res->flags |= IORESOURCE_STARTALIGN;
-        if (size1 > size0 && add_head)
-                add_to_list(add_head, bus->self, b_res, size1-size0);
+        if (size1 > size0 && realloc_head)
+                add_to_list(realloc_head, bus->self, b_res, size1-size0, 4096);
 }
 
 /**
@@ -608,7 +636,7 @@ static void pbus_size_io(struct pci_bus *bus, resource_size_t min_size,
  * @bus : the bus
  * @min_size : the minimum memory window that must to be allocated
  * @add_size : additional optional memory window
- * @add_head : track the additional memory window on this list
+ * @realloc_head : track the additional memory window on this list
  *
  * Calculate the size of the bus and minimal alignment which
  * guarantees that all child resources fit in this size.
@@ -616,7 +644,7 @@ static void pbus_size_io(struct pci_bus *bus, resource_size_t min_size,
 static int pbus_size_mem(struct pci_bus *bus, unsigned long mask,
                          unsigned long type, resource_size_t min_size,
                         resource_size_t add_size,
-                        struct resource_list_x *add_head)
+                        struct resource_list_x *realloc_head)
 {
         struct pci_dev *dev;
         resource_size_t min_align, align, size, size0, size1;
@@ -624,6 +652,7 @@ static int pbus_size_mem(struct pci_bus *bus, unsigned long mask,
         int order, max_order;
         struct resource *b_res = find_free_bus_resource(bus, type);
         unsigned int mem64_mask = 0;
+        resource_size_t children_add_size = 0;
 
         if (!b_res)
                 return 0;
@@ -645,6 +674,16 @@ static int pbus_size_mem(struct pci_bus *bus, unsigned long mask,
                         if (r->parent || (r->flags & mask) != type)
                                 continue;
                         r_size = resource_size(r);
+#ifdef CONFIG_PCI_IOV
+                        /* put SRIOV requested res to the optional list */
+                        if (realloc_head && i >= PCI_IOV_RESOURCES &&
+                                        i <= PCI_IOV_RESOURCE_END) {
+                                r->end = r->start - 1;
+                                add_to_list(realloc_head, dev, r, r_size, 0/* dont' care */);
+                                children_add_size += r_size;
+                                continue;
+                        }
+#endif
                         /* For bridges size != alignment */
                         align = pci_resource_alignment(dev, r);
                         order = __ffs(align) - 20;
@@ -665,6 +704,9 @@ static int pbus_size_mem(struct pci_bus *bus, unsigned long mask,
                         if (order > max_order)
                                 max_order = order;
                         mem64_mask &= r->flags & IORESOURCE_MEM_64;
+
+                        if (realloc_head)
+                                children_add_size += get_res_add_size(realloc_head, r);
                 }
         }
         align = 0;
@@ -681,7 +723,9 @@ static int pbus_size_mem(struct pci_bus *bus, unsigned long mask,
                 align += aligns[order];
         }
         size0 = calculate_memsize(size, min_size, 0, resource_size(b_res), min_align);
-        size1 = (!add_head || (add_head && !add_size)) ? size0 :
+        if (children_add_size > add_size)
+                add_size = children_add_size;
+        size1 = (!realloc_head || (realloc_head && !add_size)) ? size0 :
                 calculate_memsize(size, min_size+add_size, 0,
                                 resource_size(b_res), min_align);
         if (!size0 && !size1) {
@@ -695,12 +739,22 @@ static int pbus_size_mem(struct pci_bus *bus, unsigned long mask,
         b_res->start = min_align;
         b_res->end = size0 + min_align - 1;
         b_res->flags |= IORESOURCE_STARTALIGN | mem64_mask;
-        if (size1 > size0 && add_head)
-                add_to_list(add_head, bus->self, b_res, size1-size0);
+        if (size1 > size0 && realloc_head)
+                add_to_list(realloc_head, bus->self, b_res, size1-size0, min_align);
         return 1;
 }
 
-static void pci_bus_size_cardbus(struct pci_bus *bus)
+unsigned long pci_cardbus_resource_alignment(struct resource *res)
+{
+        if (res->flags & IORESOURCE_IO)
+                return pci_cardbus_io_size;
+        if (res->flags & IORESOURCE_MEM)
+                return pci_cardbus_mem_size;
+        return 0;
+}
+
+static void pci_bus_size_cardbus(struct pci_bus *bus,
+                        struct resource_list_x *realloc_head)
 {
         struct pci_dev *bridge = bus->self;
         struct resource *b_res = &bridge->resource[PCI_BRIDGE_RESOURCES];
@@ -711,12 +765,14 @@ static void pci_bus_size_cardbus(struct pci_bus *bus)
          * a fixed amount of bus space for CardBus bridges.
          */
         b_res[0].start = 0;
-        b_res[0].end = pci_cardbus_io_size - 1;
         b_res[0].flags |= IORESOURCE_IO | IORESOURCE_SIZEALIGN;
+        if (realloc_head)
+                add_to_list(realloc_head, bridge, b_res, pci_cardbus_io_size, 0 /* dont care */);
 
         b_res[1].start = 0;
-        b_res[1].end = pci_cardbus_io_size - 1;
         b_res[1].flags |= IORESOURCE_IO | IORESOURCE_SIZEALIGN;
+        if (realloc_head)
+                add_to_list(realloc_head, bridge, b_res+1, pci_cardbus_io_size, 0 /* dont care */);
 
         /*
          * Check whether prefetchable memory is supported
@@ -736,21 +792,31 @@ static void pci_bus_size_cardbus(struct pci_bus *bus)
          */
         if (ctrl & PCI_CB_BRIDGE_CTL_PREFETCH_MEM0) {
                 b_res[2].start = 0;
-                b_res[2].end = pci_cardbus_mem_size - 1;
                 b_res[2].flags |= IORESOURCE_MEM | IORESOURCE_PREFETCH | IORESOURCE_SIZEALIGN;
+                if (realloc_head)
+                        add_to_list(realloc_head, bridge, b_res+2, pci_cardbus_mem_size, 0 /* dont care */);
 
                 b_res[3].start = 0;
-                b_res[3].end = pci_cardbus_mem_size - 1;
                 b_res[3].flags |= IORESOURCE_MEM | IORESOURCE_SIZEALIGN;
+                if (realloc_head)
+                        add_to_list(realloc_head, bridge, b_res+3, pci_cardbus_mem_size, 0 /* dont care */);
         } else {
                 b_res[3].start = 0;
-                b_res[3].end = pci_cardbus_mem_size * 2 - 1;
                 b_res[3].flags |= IORESOURCE_MEM | IORESOURCE_SIZEALIGN;
+                if (realloc_head)
+                        add_to_list(realloc_head, bridge, b_res+3, pci_cardbus_mem_size * 2, 0 /* dont care */);
         }
+
+        /* set the size of the resource to zero, so that the resource does not
+         * get assigned during required-resource allocation cycle but gets assigned
+         * during the optional-resource allocation cycle.
+         */
+        b_res[0].start = b_res[1].start = b_res[2].start = b_res[3].start = 1;
+        b_res[0].end = b_res[1].end = b_res[2].end = b_res[3].end = 0;
 }
 
 void __ref __pci_bus_size_bridges(struct pci_bus *bus,
-                        struct resource_list_x *add_head)
+                        struct resource_list_x *realloc_head)
 {
         struct pci_dev *dev;
         unsigned long mask, prefmask;
@@ -763,12 +829,12 @@ void __ref __pci_bus_size_bridges(struct pci_bus *bus,
 
                 switch (dev->class >> 8) {
                 case PCI_CLASS_BRIDGE_CARDBUS:
-                        pci_bus_size_cardbus(b);
+                        pci_bus_size_cardbus(b, realloc_head);
                         break;
 
                 case PCI_CLASS_BRIDGE_PCI:
                 default:
-                        __pci_bus_size_bridges(b, add_head);
+                        __pci_bus_size_bridges(b, realloc_head);
                         break;
                 }
         }
@@ -792,7 +858,7 @@ void __ref __pci_bus_size_bridges(struct pci_bus *bus,
                  * Follow thru
                  */
         default:
-                pbus_size_io(bus, 0, additional_io_size, add_head);
+                pbus_size_io(bus, 0, additional_io_size, realloc_head);
                 /* If the bridge supports prefetchable range, size it
                    separately. If it doesn't, or its prefetchable window
                    has already been allocated by arch code, try
@@ -800,11 +866,11 @@ void __ref __pci_bus_size_bridges(struct pci_bus *bus,
                    resources. */
                 mask = IORESOURCE_MEM;
                 prefmask = IORESOURCE_MEM | IORESOURCE_PREFETCH;
-                if (pbus_size_mem(bus, prefmask, prefmask, 0, additional_mem_size, add_head))
+                if (pbus_size_mem(bus, prefmask, prefmask, 0, additional_mem_size, realloc_head))
                         mask = prefmask; /* Success, size non-prefetch only. */
                 else
                         additional_mem_size += additional_mem_size;
-                pbus_size_mem(bus, mask, IORESOURCE_MEM, 0, additional_mem_size, add_head);
+                pbus_size_mem(bus, mask, IORESOURCE_MEM, 0, additional_mem_size, realloc_head);
                 break;
         }
 }
@@ -816,20 +882,20 @@ void __ref pci_bus_size_bridges(struct pci_bus *bus)
 EXPORT_SYMBOL(pci_bus_size_bridges);
 
 static void __ref __pci_bus_assign_resources(const struct pci_bus *bus,
-                                         struct resource_list_x *add_head,
+                                         struct resource_list_x *realloc_head,
                                          struct resource_list_x *fail_head)
 {
         struct pci_bus *b;
         struct pci_dev *dev;
 
-        pbus_assign_resources_sorted(bus, add_head, fail_head);
+        pbus_assign_resources_sorted(bus, realloc_head, fail_head);
 
         list_for_each_entry(dev, &bus->devices, bus_list) {
                 b = dev->subordinate;
                 if (!b)
                         continue;
 
-                __pci_bus_assign_resources(b, add_head, fail_head);
+                __pci_bus_assign_resources(b, realloc_head, fail_head);
 
                 switch (dev->class >> 8) {
                 case PCI_CLASS_BRIDGE_PCI:
@@ -1039,7 +1105,7 @@ void __init
 pci_assign_unassigned_resources(void)
 {
         struct pci_bus *bus;
-        struct resource_list_x add_list; /* list of resources that
+        struct resource_list_x realloc_list; /* list of resources that
                                         want additional resources */
         int tried_times = 0;
         enum release_type rel_type = leaf_only;
@@ -1052,7 +1118,7 @@ pci_assign_unassigned_resources(void)
 
 
         head.next = NULL;
-        add_list.next = NULL;
+        realloc_list.next = NULL;
 
         pci_try_num = max_depth + 1;
         printk(KERN_DEBUG "PCI: max bus depth: %d pci_try_num: %d\n",
@@ -1062,12 +1128,12 @@ again:
         /* Depth first, calculate sizes and alignments of all
            subordinate buses. */
         list_for_each_entry(bus, &pci_root_buses, node)
-                __pci_bus_size_bridges(bus, &add_list);
+                __pci_bus_size_bridges(bus, &realloc_list);
 
         /* Depth last, allocate resources and update the hardware. */
         list_for_each_entry(bus, &pci_root_buses, node)
-                __pci_bus_assign_resources(bus, &add_list, &head);
-        BUG_ON(add_list.next);
+                __pci_bus_assign_resources(bus, &realloc_list, &head);
+        BUG_ON(realloc_list.next);
         tried_times++;
 
         /* any device complain? */
diff --git a/drivers/pci/setup-res.c b/drivers/pci/setup-res.c
index 319f359906e8..51a9095c7da4 100644
--- a/drivers/pci/setup-res.c
+++ b/drivers/pci/setup-res.c
@@ -128,16 +128,16 @@ void pci_disable_bridge_window(struct pci_dev *dev)
 }
 #endif  /* CONFIG_PCI_QUIRKS */
 
+
+
 static int __pci_assign_resource(struct pci_bus *bus, struct pci_dev *dev,
-                                 int resno)
+                int resno, resource_size_t size, resource_size_t align)
 {
         struct resource *res = dev->resource + resno;
-        resource_size_t size, min, align;
+        resource_size_t min;
         int ret;
 
-        size = resource_size(res);
         min = (res->flags & IORESOURCE_IO) ? PCIBIOS_MIN_IO : PCIBIOS_MIN_MEM;
-        align = pci_resource_alignment(dev, res);
 
         /* First, try exact prefetching match.. */
         ret = pci_bus_alloc_resource(bus, res, size, align, min,
@@ -154,56 +154,101 @@ static int __pci_assign_resource(struct pci_bus *bus, struct pci_dev *dev,
                 ret = pci_bus_alloc_resource(bus, res, size, align, min, 0,
                                              pcibios_align_resource, dev);
         }
+        return ret;
+}
 
-        if (ret < 0 && dev->fw_addr[resno]) {
-                struct resource *root, *conflict;
-                resource_size_t start, end;
+static int pci_revert_fw_address(struct resource *res, struct pci_dev *dev, 
+                int resno, resource_size_t size)
+{
+        struct resource *root, *conflict;
+        resource_size_t start, end;
+        int ret = 0;
 
-                /*
-                 * If we failed to assign anything, let's try the address
-                 * where firmware left it.  That at least has a chance of
-                 * working, which is better than just leaving it disabled.
-                 */
+        if (res->flags & IORESOURCE_IO)
+                root = &ioport_resource;
+        else
+                root = &iomem_resource;
+
+        start = res->start;
+        end = res->end;
+        res->start = dev->fw_addr[resno];
+        res->end = res->start + size - 1;
+        dev_info(&dev->dev, "BAR %d: trying firmware assignment %pR\n",
+                 resno, res);
+        conflict = request_resource_conflict(root, res);
+        if (conflict) {
+                dev_info(&dev->dev,
+                         "BAR %d: %pR conflicts with %s %pR\n", resno,
+                         res, conflict->name, conflict);
+                res->start = start;
+                res->end = end;
+                ret = 1;
+        }
+        return ret;
+}
+
+static int _pci_assign_resource(struct pci_dev *dev, int resno, int size, resource_size_t min_align)
+{
+        struct resource *res = dev->resource + resno;
+        struct pci_bus *bus;
+        int ret;
+        char *type;
 
-                if (res->flags & IORESOURCE_IO)
-                        root = &ioport_resource;
+        bus = dev->bus;
+        while ((ret = __pci_assign_resource(bus, dev, resno, size, min_align))) {
+                if (!bus->parent || !bus->self->transparent)
+                        break;
+                bus = bus->parent;
+        }
+
+        if (ret) {
+                if (res->flags & IORESOURCE_MEM)
+                        if (res->flags & IORESOURCE_PREFETCH)
+                                type = "mem pref";
+                        else
+                                type = "mem";
+                else if (res->flags & IORESOURCE_IO)
+                        type = "io";
                 else
-                        root = &iomem_resource;
-
-                start = res->start;
-                end = res->end;
-                res->start = dev->fw_addr[resno];
-                res->end = res->start + size - 1;
-                dev_info(&dev->dev, "BAR %d: trying firmware assignment %pR\n",
-                         resno, res);
-                conflict = request_resource_conflict(root, res);
-                if (conflict) {
-                        dev_info(&dev->dev,
-                                 "BAR %d: %pR conflicts with %s %pR\n", resno,
-                                 res, conflict->name, conflict);
-                        res->start = start;
-                        res->end = end;
-                } else
-                        ret = 0;
+                        type = "unknown";
+                dev_info(&dev->dev,
+                         "BAR %d: can't assign %s (size %#llx)\n",
+                         resno, type, (unsigned long long) resource_size(res));
         }
 
+        return ret;
+}
+
+int pci_reassign_resource(struct pci_dev *dev, int resno, resource_size_t addsize,
+                        resource_size_t min_align)
+{
+        struct resource *res = dev->resource + resno;
+        resource_size_t new_size;
+        int ret;
+
+        if (!res->parent) {
+                dev_info(&dev->dev, "BAR %d: can't reassign an unassigned resouce %pR "
+                         "\n", resno, res);
+                return -EINVAL;
+        }
+
+        new_size = resource_size(res) + addsize + min_align;
+        ret = _pci_assign_resource(dev, resno, new_size, min_align);
         if (!ret) {
                 res->flags &= ~IORESOURCE_STARTALIGN;
                 dev_info(&dev->dev, "BAR %d: assigned %pR\n", resno, res);
                 if (resno < PCI_BRIDGE_RESOURCES)
                         pci_update_resource(dev, resno);
         }
-
         return ret;
 }
 
 int pci_assign_resource(struct pci_dev *dev, int resno)
 {
         struct resource *res = dev->resource + resno;
-        resource_size_t align;
+        resource_size_t align, size;
         struct pci_bus *bus;
         int ret;
-        char *type;
 
         align = pci_resource_alignment(dev, res);
         if (!align) {
@@ -213,34 +258,27 @@ int pci_assign_resource(struct pci_dev *dev, int resno)
         }
 
         bus = dev->bus;
-        while ((ret = __pci_assign_resource(bus, dev, resno))) {
-                if (bus->parent && bus->self->transparent)
-                        bus = bus->parent;
-                else
-                        bus = NULL;
-                if (bus)
-                        continue;
-                break;
-        }
+        size = resource_size(res);
+        ret = _pci_assign_resource(dev, resno, size, align);
 
-        if (ret) {
-                if (res->flags & IORESOURCE_MEM)
-                        if (res->flags & IORESOURCE_PREFETCH)
-                                type = "mem pref";
-                        else
-                                type = "mem";
-                else if (res->flags & IORESOURCE_IO)
-                        type = "io";
-                else
-                        type = "unknown";
-                dev_info(&dev->dev,
-                         "BAR %d: can't assign %s (size %#llx)\n",
-                         resno, type, (unsigned long long) resource_size(res));
-        }
+        /*
+         * If we failed to assign anything, let's try the address
+         * where firmware left it.  That at least has a chance of
+         * working, which is better than just leaving it disabled.
+         */
+        if (ret < 0 && dev->fw_addr[resno])
+                ret = pci_revert_fw_address(res, dev, resno, size);
 
+        if (!ret) {
+                res->flags &= ~IORESOURCE_STARTALIGN;
+                dev_info(&dev->dev, "BAR %d: assigned %pR\n", resno, res);
+                if (resno < PCI_BRIDGE_RESOURCES)
+                        pci_update_resource(dev, resno);
+        }
         return ret;
 }
 
+
 /* Sort resources by alignment */
 void pdev_sort_resources(struct pci_dev *dev, struct resource_list *head)
 {
diff --git a/drivers/pcmcia/pxa2xx_balloon3.c b/drivers/pcmcia/pxa2xx_balloon3.c
index 4c3e94c0ae85..f56d7de7c751 100644
--- a/drivers/pcmcia/pxa2xx_balloon3.c
+++ b/drivers/pcmcia/pxa2xx_balloon3.c
@@ -103,22 +103,12 @@ static int balloon3_pcmcia_configure_socket(struct soc_pcmcia_socket *skt,
         return 0;
 }
 
-static void balloon3_pcmcia_socket_init(struct soc_pcmcia_socket *skt)
-{
-}
-
-static void balloon3_pcmcia_socket_suspend(struct soc_pcmcia_socket *skt)
-{
-}
-
 static struct pcmcia_low_level balloon3_pcmcia_ops = {
         .owner                  = THIS_MODULE,
         .hw_init                = balloon3_pcmcia_hw_init,
         .hw_shutdown            = balloon3_pcmcia_hw_shutdown,
         .socket_state           = balloon3_pcmcia_socket_state,
         .configure_socket       = balloon3_pcmcia_configure_socket,
-        .socket_init            = balloon3_pcmcia_socket_init,
-        .socket_suspend         = balloon3_pcmcia_socket_suspend,
         .first                  = 0,
         .nr                     = 1,
 };
diff --git a/drivers/pcmcia/pxa2xx_cm_x255.c b/drivers/pcmcia/pxa2xx_cm_x255.c
index 05913d0bbdbe..63f4d5211ed2 100644
--- a/drivers/pcmcia/pxa2xx_cm_x255.c
+++ b/drivers/pcmcia/pxa2xx_cm_x255.c
@@ -102,23 +102,12 @@ static int cmx255_pcmcia_configure_socket(struct soc_pcmcia_socket *skt,
         return 0;
 }
 
-static void cmx255_pcmcia_socket_init(struct soc_pcmcia_socket *skt)
-{
-}
-
-static void cmx255_pcmcia_socket_suspend(struct soc_pcmcia_socket *skt)
-{
-}
-
-
 static struct pcmcia_low_level cmx255_pcmcia_ops __initdata = {
         .owner                  = THIS_MODULE,
         .hw_init                = cmx255_pcmcia_hw_init,
         .hw_shutdown            = cmx255_pcmcia_shutdown,
         .socket_state           = cmx255_pcmcia_socket_state,
         .configure_socket       = cmx255_pcmcia_configure_socket,
-        .socket_init            = cmx255_pcmcia_socket_init,
-        .socket_suspend         = cmx255_pcmcia_socket_suspend,
         .nr                     = 1,
 };
 
diff --git a/drivers/pcmcia/pxa2xx_cm_x270.c b/drivers/pcmcia/pxa2xx_cm_x270.c
index 5662646b84da..6ee42b4c3e68 100644
--- a/drivers/pcmcia/pxa2xx_cm_x270.c
+++ b/drivers/pcmcia/pxa2xx_cm_x270.c
@@ -82,23 +82,12 @@ static int cmx270_pcmcia_configure_socket(struct soc_pcmcia_socket *skt,
         return 0;
 }
 
-static void cmx270_pcmcia_socket_init(struct soc_pcmcia_socket *skt)
-{
-}
-
-static void cmx270_pcmcia_socket_suspend(struct soc_pcmcia_socket *skt)
-{
-}
-
-
 static struct pcmcia_low_level cmx270_pcmcia_ops __initdata = {
         .owner                  = THIS_MODULE,
         .hw_init                = cmx270_pcmcia_hw_init,
         .hw_shutdown            = cmx270_pcmcia_shutdown,
         .socket_state           = cmx270_pcmcia_socket_state,
         .configure_socket       = cmx270_pcmcia_configure_socket,
-        .socket_init            = cmx270_pcmcia_socket_init,
-        .socket_suspend         = cmx270_pcmcia_socket_suspend,
         .nr                     = 1,
 };
 
diff --git a/drivers/pcmcia/pxa2xx_colibri.c b/drivers/pcmcia/pxa2xx_colibri.c
index 443cb7fc872d..c6dec572a05d 100644
--- a/drivers/pcmcia/pxa2xx_colibri.c
+++ b/drivers/pcmcia/pxa2xx_colibri.c
@@ -116,14 +116,6 @@ colibri_pcmcia_configure_socket(struct soc_pcmcia_socket *skt,
         return 0;
 }
 
-static void colibri_pcmcia_socket_init(struct soc_pcmcia_socket *skt)
-{
-}
-
-static void colibri_pcmcia_socket_suspend(struct soc_pcmcia_socket *skt)
-{
-}
-
 static struct pcmcia_low_level colibri_pcmcia_ops = {
         .owner                  = THIS_MODULE,
 
@@ -135,9 +127,6 @@ static struct pcmcia_low_level colibri_pcmcia_ops = {
 
         .socket_state           = colibri_pcmcia_socket_state,
         .configure_socket       = colibri_pcmcia_configure_socket,
-
-        .socket_init            = colibri_pcmcia_socket_init,
-        .socket_suspend         = colibri_pcmcia_socket_suspend,
 };
 
 static struct platform_device *colibri_pcmcia_device;
diff --git a/drivers/pcmcia/pxa2xx_mainstone.c b/drivers/pcmcia/pxa2xx_mainstone.c
index 92016fe932b4..aded706c0b9f 100644
--- a/drivers/pcmcia/pxa2xx_mainstone.c
+++ b/drivers/pcmcia/pxa2xx_mainstone.c
@@ -128,22 +128,12 @@ static int mst_pcmcia_configure_socket(struct soc_pcmcia_socket *skt,
         return ret;
 }
 
-static void mst_pcmcia_socket_init(struct soc_pcmcia_socket *skt)
-{
-}
-
-static void mst_pcmcia_socket_suspend(struct soc_pcmcia_socket *skt)
-{
-}
-
 static struct pcmcia_low_level mst_pcmcia_ops __initdata = {
         .owner                  = THIS_MODULE,
         .hw_init                = mst_pcmcia_hw_init,
         .hw_shutdown            = mst_pcmcia_hw_shutdown,
         .socket_state           = mst_pcmcia_socket_state,
         .configure_socket       = mst_pcmcia_configure_socket,
-        .socket_init            = mst_pcmcia_socket_init,
-        .socket_suspend         = mst_pcmcia_socket_suspend,
         .nr                     = 2,
 };
 
diff --git a/drivers/pcmcia/pxa2xx_palmld.c b/drivers/pcmcia/pxa2xx_palmld.c
index 69f73670949a..d589ad1dcd4c 100644
--- a/drivers/pcmcia/pxa2xx_palmld.c
+++ b/drivers/pcmcia/pxa2xx_palmld.c
@@ -65,14 +65,6 @@ static int palmld_pcmcia_configure_socket(struct soc_pcmcia_socket *skt,
         return 0;
 }
 
-static void palmld_pcmcia_socket_init(struct soc_pcmcia_socket *skt)
-{
-}
-
-static void palmld_pcmcia_socket_suspend(struct soc_pcmcia_socket *skt)
-{
-}
-
 static struct pcmcia_low_level palmld_pcmcia_ops = {
         .owner                  = THIS_MODULE,
 
@@ -84,9 +76,6 @@ static struct pcmcia_low_level palmld_pcmcia_ops = {
 
         .socket_state           = palmld_pcmcia_socket_state,
         .configure_socket       = palmld_pcmcia_configure_socket,
-
-        .socket_init            = palmld_pcmcia_socket_init,
-        .socket_suspend         = palmld_pcmcia_socket_suspend,
 };
 
 static struct platform_device *palmld_pcmcia_device;
diff --git a/drivers/pcmcia/pxa2xx_palmtc.c b/drivers/pcmcia/pxa2xx_palmtc.c
index d0ad6a76bbde..9c6a04b2f71b 100644
--- a/drivers/pcmcia/pxa2xx_palmtc.c
+++ b/drivers/pcmcia/pxa2xx_palmtc.c
@@ -117,14 +117,6 @@ static int palmtc_pcmcia_configure_socket(struct soc_pcmcia_socket *skt,
         return ret;
 }
 
-static void palmtc_pcmcia_socket_init(struct soc_pcmcia_socket *skt)
-{
-}
-
-static void palmtc_pcmcia_socket_suspend(struct soc_pcmcia_socket *skt)
-{
-}
-
 static struct pcmcia_low_level palmtc_pcmcia_ops = {
         .owner                  = THIS_MODULE,
 
@@ -136,9 +128,6 @@ static struct pcmcia_low_level palmtc_pcmcia_ops = {
 
         .socket_state           = palmtc_pcmcia_socket_state,
         .configure_socket       = palmtc_pcmcia_configure_socket,
-
-        .socket_init            = palmtc_pcmcia_socket_init,
-        .socket_suspend         = palmtc_pcmcia_socket_suspend,
 };
 
 static struct platform_device *palmtc_pcmcia_device;
diff --git a/drivers/pcmcia/pxa2xx_palmtx.c b/drivers/pcmcia/pxa2xx_palmtx.c
index 1a2580450402..80645a688ee3 100644
--- a/drivers/pcmcia/pxa2xx_palmtx.c
+++ b/drivers/pcmcia/pxa2xx_palmtx.c
@@ -67,14 +67,6 @@ palmtx_pcmcia_configure_socket(struct soc_pcmcia_socket *skt,
         return 0;
 }
 
-static void palmtx_pcmcia_socket_init(struct soc_pcmcia_socket *skt)
-{
-}
-
-static void palmtx_pcmcia_socket_suspend(struct soc_pcmcia_socket *skt)
-{
-}
-
 static struct pcmcia_low_level palmtx_pcmcia_ops = {
         .owner                  = THIS_MODULE,
 
@@ -86,9 +78,6 @@ static struct pcmcia_low_level palmtx_pcmcia_ops = {
 
         .socket_state           = palmtx_pcmcia_socket_state,
         .configure_socket       = palmtx_pcmcia_configure_socket,
-
-        .socket_init            = palmtx_pcmcia_socket_init,
-        .socket_suspend         = palmtx_pcmcia_socket_suspend,
 };
 
 static struct platform_device *palmtx_pcmcia_device;
diff --git a/drivers/pcmcia/pxa2xx_stargate2.c b/drivers/pcmcia/pxa2xx_stargate2.c
index d08802fe35f9..939622251dfb 100644
--- a/drivers/pcmcia/pxa2xx_stargate2.c
+++ b/drivers/pcmcia/pxa2xx_stargate2.c
@@ -28,7 +28,6 @@
 
 #include "soc_common.h"
 
-#define SG2_S0_BUFF_CTL         120
 #define SG2_S0_POWER_CTL        108
 #define SG2_S0_GPIO_RESET       82
 #define SG2_S0_GPIO_DETECT      53
@@ -38,6 +37,11 @@ static struct pcmcia_irqs irqs[] = {
         { 0, IRQ_GPIO(SG2_S0_GPIO_DETECT), "PCMCIA0 CD" },
 };
 
+static struct gpio sg2_pcmcia_gpios[] = {
+        { SG2_S0_GPIO_RESET, GPIOF_OUT_INIT_HIGH, "PCMCIA Reset" },
+        { SG2_S0_POWER_CTL, GPIOF_OUT_INIT_HIGH, "PCMCIA Power Ctrl" },
+};
+
 static int sg2_pcmcia_hw_init(struct soc_pcmcia_socket *skt)
 {
         skt->socket.pci_irq = IRQ_GPIO(SG2_S0_GPIO_READY);
@@ -122,37 +126,23 @@ static int __init sg2_pcmcia_init(void)
         if (!sg2_pcmcia_device)
                 return -ENOMEM;
 
-        ret = gpio_request(SG2_S0_BUFF_CTL, "SG2 CF buff ctl");
+        ret = gpio_request_array(sg2_pcmcia_gpios, ARRAY_SIZE(sg2_pcmcia_gpios));
         if (ret)
                 goto error_put_platform_device;
-        ret = gpio_request(SG2_S0_POWER_CTL, "SG2 CF power ctl");
-        if (ret)
-                goto error_free_gpio_buff_ctl;
-        ret = gpio_request(SG2_S0_GPIO_RESET, "SG2 CF reset");
-        if (ret)
-                goto error_free_gpio_power_ctl;
-        /* Set gpio directions */
-        gpio_direction_output(SG2_S0_BUFF_CTL, 0);
-        gpio_direction_output(SG2_S0_POWER_CTL, 1);
-        gpio_direction_output(SG2_S0_GPIO_RESET, 1);
 
         ret = platform_device_add_data(sg2_pcmcia_device,
                                        &sg2_pcmcia_ops,
                                        sizeof(sg2_pcmcia_ops));
         if (ret)
-                goto error_free_gpio_reset;
+                goto error_free_gpios;
 
         ret = platform_device_add(sg2_pcmcia_device);
         if (ret)
-                goto error_free_gpio_reset;
+                goto error_free_gpios;
 
         return 0;
-error_free_gpio_reset:
-        gpio_free(SG2_S0_GPIO_RESET);
-error_free_gpio_power_ctl:
-        gpio_free(SG2_S0_POWER_CTL);
-error_free_gpio_buff_ctl:
-        gpio_free(SG2_S0_BUFF_CTL);
+error_free_gpios:
+        gpio_free_array(sg2_pcmcia_gpios, ARRAY_SIZE(sg2_pcmcia_gpios));
 error_put_platform_device:
         platform_device_put(sg2_pcmcia_device);
 
@@ -162,9 +152,7 @@ error_put_platform_device:
 static void __exit sg2_pcmcia_exit(void)
 {
         platform_device_unregister(sg2_pcmcia_device);
-        gpio_free(SG2_S0_BUFF_CTL);
-        gpio_free(SG2_S0_POWER_CTL);
-        gpio_free(SG2_S0_GPIO_RESET);
+        gpio_free_array(sg2_pcmcia_gpios, ARRAY_SIZE(sg2_pcmcia_gpios));
 }
 
 fs_initcall(sg2_pcmcia_init);
diff --git a/drivers/pcmcia/pxa2xx_viper.c b/drivers/pcmcia/pxa2xx_viper.c
index a51f2077644a..1064b1c2869d 100644
--- a/drivers/pcmcia/pxa2xx_viper.c
+++ b/drivers/pcmcia/pxa2xx_viper.c
@@ -136,22 +136,12 @@ static int viper_pcmcia_configure_socket(struct soc_pcmcia_socket *skt,
         return 0;
 }
 
-static void viper_pcmcia_socket_init(struct soc_pcmcia_socket *skt)
-{
-}
-
-static void viper_pcmcia_socket_suspend(struct soc_pcmcia_socket *skt)
-{
-}
-
 static struct pcmcia_low_level viper_pcmcia_ops = {
         .owner                  = THIS_MODULE,
         .hw_init                = viper_pcmcia_hw_init,
         .hw_shutdown            = viper_pcmcia_hw_shutdown,
         .socket_state           = viper_pcmcia_socket_state,
         .configure_socket       = viper_pcmcia_configure_socket,
-        .socket_init            = viper_pcmcia_socket_init,
-        .socket_suspend         = viper_pcmcia_socket_suspend,
         .nr                     = 1,
 };
 
diff --git a/drivers/pcmcia/soc_common.c b/drivers/pcmcia/soc_common.c
index 768f9572a8c8..a0a9c2aa8d78 100644
--- a/drivers/pcmcia/soc_common.c
+++ b/drivers/pcmcia/soc_common.c
@@ -186,8 +186,8 @@ static int soc_common_pcmcia_sock_init(struct pcmcia_socket *sock)
         struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
 
         debug(skt, 2, "initializing socket\n");
-
-        skt->ops->socket_init(skt);
+        if (skt->ops->socket_init)
+                skt->ops->socket_init(skt);
         return 0;
 }
 
@@ -207,7 +207,8 @@ static int soc_common_pcmcia_suspend(struct pcmcia_socket *sock)
 
         debug(skt, 2, "suspending socket\n");
 
-        skt->ops->socket_suspend(skt);
+        if (skt->ops->socket_suspend)
+                skt->ops->socket_suspend(skt);
 
         return 0;
 }
diff --git a/drivers/platform/x86/Kconfig b/drivers/platform/x86/Kconfig
index 45e0191c35dd..1e88d4785321 100644
--- a/drivers/platform/x86/Kconfig
+++ b/drivers/platform/x86/Kconfig
@@ -769,4 +769,12 @@ config INTEL_OAKTRAIL
           enable/disable the Camera, WiFi, BT etc. devices. If in doubt, say Y
           here; it will only load on supported platforms.
 
+config SAMSUNG_Q10
+        tristate "Samsung Q10 Extras"
+        depends on SERIO_I8042
+        select BACKLIGHT_CLASS_DEVICE
+        ---help---
+          This driver provides support for backlight control on Samsung Q10
+          and related laptops, including Dell Latitude X200.
+
 endif # X86_PLATFORM_DEVICES
diff --git a/drivers/platform/x86/Makefile b/drivers/platform/x86/Makefile
index afc1f832aa67..293a320d9faa 100644
--- a/drivers/platform/x86/Makefile
+++ b/drivers/platform/x86/Makefile
@@ -44,3 +44,4 @@ obj-$(CONFIG_SAMSUNG_LAPTOP)	+= samsung-laptop.o
 obj-$(CONFIG_MXM_WMI)           += mxm-wmi.o
 obj-$(CONFIG_INTEL_MID_POWER_BUTTON)    += intel_mid_powerbtn.o
 obj-$(CONFIG_INTEL_OAKTRAIL)    += intel_oaktrail.o
+obj-$(CONFIG_SAMSUNG_Q10)       += samsung-q10.o
diff --git a/drivers/platform/x86/acer-wmi.c b/drivers/platform/x86/acer-wmi.c
index e1c4938b301b..af2bb20cb2fb 100644
--- a/drivers/platform/x86/acer-wmi.c
+++ b/drivers/platform/x86/acer-wmi.c
@@ -99,6 +99,7 @@ enum acer_wmi_event_ids {
 static const struct key_entry acer_wmi_keymap[] = {
         {KE_KEY, 0x01, {KEY_WLAN} },     /* WiFi */
         {KE_KEY, 0x03, {KEY_WLAN} },     /* WiFi */
+        {KE_KEY, 0x04, {KEY_WLAN} },     /* WiFi */
         {KE_KEY, 0x12, {KEY_BLUETOOTH} },       /* BT */
         {KE_KEY, 0x21, {KEY_PROG1} },    /* Backup */
         {KE_KEY, 0x22, {KEY_PROG2} },    /* Arcade */
@@ -304,6 +305,10 @@ static struct quirk_entry quirk_fujitsu_amilo_li_1718 = {
         .wireless = 2,
 };
 
+static struct quirk_entry quirk_lenovo_ideapad_s205 = {
+        .wireless = 3,
+};
+
 /* The Aspire One has a dummy ACPI-WMI interface - disable it */
 static struct dmi_system_id __devinitdata acer_blacklist[] = {
         {
@@ -450,6 +455,15 @@ static struct dmi_system_id acer_quirks[] = {
                 },
                 .driver_data = &quirk_medion_md_98300,
         },
+        {
+                .callback = dmi_matched,
+                .ident = "Lenovo Ideapad S205",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "10382LG"),
+                },
+                .driver_data = &quirk_lenovo_ideapad_s205,
+        },
         {}
 };
 
@@ -542,6 +556,12 @@ struct wmi_interface *iface)
                                 return AE_ERROR;
                         *value = result & 0x1;
                         return AE_OK;
+                case 3:
+                        err = ec_read(0x78, &result);
+                        if (err)
+                                return AE_ERROR;
+                        *value = result & 0x1;
+                        return AE_OK;
                 default:
                         err = ec_read(0xA, &result);
                         if (err)
@@ -1266,8 +1286,13 @@ static void acer_rfkill_update(struct work_struct *ignored)
         acpi_status status;
 
         status = get_u32(&state, ACER_CAP_WIRELESS);
-        if (ACPI_SUCCESS(status))
-                rfkill_set_sw_state(wireless_rfkill, !state);
+        if (ACPI_SUCCESS(status)) {
+                if (quirks->wireless == 3) {
+                        rfkill_set_hw_state(wireless_rfkill, !state);
+                } else {
+                        rfkill_set_sw_state(wireless_rfkill, !state);
+                }
+        }
 
         if (has_cap(ACER_CAP_BLUETOOTH)) {
                 status = get_u32(&state, ACER_CAP_BLUETOOTH);
@@ -1400,6 +1425,9 @@ static ssize_t show_bool_threeg(struct device *dev,
 {
         u32 result; \
         acpi_status status;
+
+        pr_info("This threeg sysfs will be removed in 2012"
+                " - used by: %s\n", current->comm);
         if (wmi_has_guid(WMID_GUID3))
                 status = wmid3_get_device_status(&result,
                                 ACER_WMID3_GDS_THREEG);
@@ -1415,8 +1443,10 @@ static ssize_t set_bool_threeg(struct device *dev,
 {
         u32 tmp = simple_strtoul(buf, NULL, 10);
         acpi_status status = set_u32(tmp, ACER_CAP_THREEG);
-                if (ACPI_FAILURE(status))
-                        return -EINVAL;
+        pr_info("This threeg sysfs will be removed in 2012"
+                " - used by: %s\n", current->comm);
+        if (ACPI_FAILURE(status))
+                return -EINVAL;
         return count;
 }
 static DEVICE_ATTR(threeg, S_IRUGO | S_IWUSR, show_bool_threeg,
@@ -1425,6 +1455,8 @@ static DEVICE_ATTR(threeg, S_IRUGO | S_IWUSR, show_bool_threeg,
 static ssize_t show_interface(struct device *dev, struct device_attribute *attr,
         char *buf)
 {
+        pr_info("This interface sysfs will be removed in 2012"
+                " - used by: %s\n", current->comm);
         switch (interface->type) {
         case ACER_AMW0:
                 return sprintf(buf, "AMW0\n");
diff --git a/drivers/platform/x86/acerhdf.c b/drivers/platform/x86/acerhdf.c
index fca3489218b7..760c6d7624fe 100644
--- a/drivers/platform/x86/acerhdf.c
+++ b/drivers/platform/x86/acerhdf.c
@@ -182,6 +182,7 @@ static const struct bios_settings_t bios_tbl[] = {
         {"Acer", "Aspire 1810T",  "v1.3308", 0x55, 0x58, {0x9e, 0x00} },
         {"Acer", "Aspire 1810TZ", "v1.3310", 0x55, 0x58, {0x9e, 0x00} },
         {"Acer", "Aspire 1810T",  "v1.3310", 0x55, 0x58, {0x9e, 0x00} },
+        {"Acer", "Aspire 1810TZ", "v1.3314", 0x55, 0x58, {0x9e, 0x00} },
         /* Acer 531 */
         {"Acer", "AO531h", "v0.3201", 0x55, 0x58, {0x20, 0x00} },
         /* Gateway */
@@ -703,15 +704,15 @@ MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Peter Feuerer");
 MODULE_DESCRIPTION("Aspire One temperature and fan driver");
 MODULE_ALIAS("dmi:*:*Acer*:pnAOA*:");
-MODULE_ALIAS("dmi:*:*Acer*:pnAspire 1410*:");
-MODULE_ALIAS("dmi:*:*Acer*:pnAspire 1810*:");
+MODULE_ALIAS("dmi:*:*Acer*:pnAspire*1410*:");
+MODULE_ALIAS("dmi:*:*Acer*:pnAspire*1810*:");
 MODULE_ALIAS("dmi:*:*Acer*:pnAO531*:");
 MODULE_ALIAS("dmi:*:*Gateway*:pnAOA*:");
 MODULE_ALIAS("dmi:*:*Gateway*:pnLT31*:");
-MODULE_ALIAS("dmi:*:*Packard Bell*:pnAOA*:");
-MODULE_ALIAS("dmi:*:*Packard Bell*:pnDOA*:");
-MODULE_ALIAS("dmi:*:*Packard Bell*:pnDOTMU*:");
-MODULE_ALIAS("dmi:*:*Packard Bell*:pnDOTMA*:");
+MODULE_ALIAS("dmi:*:*Packard*Bell*:pnAOA*:");
+MODULE_ALIAS("dmi:*:*Packard*Bell*:pnDOA*:");
+MODULE_ALIAS("dmi:*:*Packard*Bell*:pnDOTMU*:");
+MODULE_ALIAS("dmi:*:*Packard*Bell*:pnDOTMA*:");
 
 module_init(acerhdf_init);
 module_exit(acerhdf_exit);
diff --git a/drivers/platform/x86/asus-laptop.c b/drivers/platform/x86/asus-laptop.c
index d65df92e2acc..fa6d7ec68b26 100644
--- a/drivers/platform/x86/asus-laptop.c
+++ b/drivers/platform/x86/asus-laptop.c
@@ -70,11 +70,10 @@ MODULE_LICENSE("GPL");
  * WAPF defines the behavior of the Fn+Fx wlan key
  * The significance of values is yet to be found, but
  * most of the time:
- * 0x0 will do nothing
- * 0x1 will allow to control the device with Fn+Fx key.
- * 0x4 will send an ACPI event (0x88) while pressing the Fn+Fx key
- * 0x5 like 0x1 or 0x4
- * So, if something doesn't work as you want, just try other values =)
+ * Bit | Bluetooth | WLAN
+ *  0  | Hardware  | Hardware
+ *  1  | Hardware  | Software
+ *  4  | Software  | Software
  */
 static uint wapf = 1;
 module_param(wapf, uint, 0444);
diff --git a/drivers/platform/x86/asus-nb-wmi.c b/drivers/platform/x86/asus-nb-wmi.c
index 0580d99b0798..b0859d4183e8 100644
--- a/drivers/platform/x86/asus-nb-wmi.c
+++ b/drivers/platform/x86/asus-nb-wmi.c
@@ -38,6 +38,24 @@ MODULE_LICENSE("GPL");
 
 MODULE_ALIAS("wmi:"ASUS_NB_WMI_EVENT_GUID);
 
+/*
+ * WAPF defines the behavior of the Fn+Fx wlan key
+ * The significance of values is yet to be found, but
+ * most of the time:
+ * Bit | Bluetooth | WLAN
+ *  0  | Hardware  | Hardware
+ *  1  | Hardware  | Software
+ *  4  | Software  | Software
+ */
+static uint wapf;
+module_param(wapf, uint, 0444);
+MODULE_PARM_DESC(wapf, "WAPF value");
+
+static void asus_nb_wmi_quirks(struct asus_wmi_driver *driver)
+{
+        driver->wapf = wapf;
+}
+
 static const struct key_entry asus_nb_wmi_keymap[] = {
         { KE_KEY, 0x30, { KEY_VOLUMEUP } },
         { KE_KEY, 0x31, { KEY_VOLUMEDOWN } },
@@ -53,16 +71,16 @@ static const struct key_entry asus_nb_wmi_keymap[] = {
         { KE_KEY, 0x51, { KEY_WWW } },
         { KE_KEY, 0x55, { KEY_CALC } },
         { KE_KEY, 0x5C, { KEY_F15 } },  /* Power Gear key */
-        { KE_KEY, 0x5D, { KEY_WLAN } },
-        { KE_KEY, 0x5E, { KEY_WLAN } },
-        { KE_KEY, 0x5F, { KEY_WLAN } },
+        { KE_KEY, 0x5D, { KEY_WLAN } }, /* Wireless console Toggle */
+        { KE_KEY, 0x5E, { KEY_WLAN } }, /* Wireless console Enable */
+        { KE_KEY, 0x5F, { KEY_WLAN } }, /* Wireless console Disable */
         { KE_KEY, 0x60, { KEY_SWITCHVIDEOMODE } },
         { KE_KEY, 0x61, { KEY_SWITCHVIDEOMODE } },
         { KE_KEY, 0x62, { KEY_SWITCHVIDEOMODE } },
         { KE_KEY, 0x63, { KEY_SWITCHVIDEOMODE } },
         { KE_KEY, 0x6B, { KEY_TOUCHPAD_TOGGLE } },
-        { KE_KEY, 0x7E, { KEY_BLUETOOTH } },
         { KE_KEY, 0x7D, { KEY_BLUETOOTH } },
+        { KE_KEY, 0x7E, { KEY_BLUETOOTH } },
         { KE_KEY, 0x82, { KEY_CAMERA } },
         { KE_KEY, 0x88, { KEY_RFKILL  } },
         { KE_KEY, 0x8A, { KEY_PROG1 } },
@@ -81,6 +99,7 @@ static struct asus_wmi_driver asus_nb_wmi_driver = {
         .keymap = asus_nb_wmi_keymap,
         .input_name = "Asus WMI hotkeys",
         .input_phys = ASUS_NB_WMI_FILE "/input0",
+        .quirks = asus_nb_wmi_quirks,
 };
 
 
diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c
index 65b66aa44c78..95cba9ebf6c0 100644
--- a/drivers/platform/x86/asus-wmi.c
+++ b/drivers/platform/x86/asus-wmi.c
@@ -44,6 +44,7 @@
 #include <linux/debugfs.h>
 #include <linux/seq_file.h>
 #include <linux/platform_device.h>
+#include <linux/thermal.h>
 #include <acpi/acpi_bus.h>
 #include <acpi/acpi_drivers.h>
 
@@ -66,6 +67,8 @@ MODULE_LICENSE("GPL");
 #define NOTIFY_BRNUP_MAX                0x1f
 #define NOTIFY_BRNDOWN_MIN              0x20
 #define NOTIFY_BRNDOWN_MAX              0x2e
+#define NOTIFY_KBD_BRTUP                0xc4
+#define NOTIFY_KBD_BRTDWN               0xc5
 
 /* WMI Methods */
 #define ASUS_WMI_METHODID_SPEC          0x43455053 /* BIOS SPECification */
@@ -93,6 +96,7 @@ MODULE_LICENSE("GPL");
 /* Wireless */
 #define ASUS_WMI_DEVID_HW_SWITCH        0x00010001
 #define ASUS_WMI_DEVID_WIRELESS_LED     0x00010002
+#define ASUS_WMI_DEVID_CWAP             0x00010003
 #define ASUS_WMI_DEVID_WLAN             0x00010011
 #define ASUS_WMI_DEVID_BLUETOOTH        0x00010013
 #define ASUS_WMI_DEVID_GPS              0x00010015
@@ -102,6 +106,12 @@ MODULE_LICENSE("GPL");
 
 /* Leds */
 /* 0x000200XX and 0x000400XX */
+#define ASUS_WMI_DEVID_LED1             0x00020011
+#define ASUS_WMI_DEVID_LED2             0x00020012
+#define ASUS_WMI_DEVID_LED3             0x00020013
+#define ASUS_WMI_DEVID_LED4             0x00020014
+#define ASUS_WMI_DEVID_LED5             0x00020015
+#define ASUS_WMI_DEVID_LED6             0x00020016
 
 /* Backlight and Brightness */
 #define ASUS_WMI_DEVID_BACKLIGHT        0x00050011
@@ -174,13 +184,18 @@ struct asus_wmi {
 
         struct led_classdev tpd_led;
         int tpd_led_wk;
+        struct led_classdev kbd_led;
+        int kbd_led_wk;
         struct workqueue_struct *led_workqueue;
         struct work_struct tpd_led_work;
+        struct work_struct kbd_led_work;
 
         struct asus_rfkill wlan;
         struct asus_rfkill bluetooth;
         struct asus_rfkill wimax;
         struct asus_rfkill wwan3g;
+        struct asus_rfkill gps;
+        struct asus_rfkill uwb;
 
         struct hotplug_slot *hotplug_slot;
         struct mutex hotplug_lock;
@@ -205,6 +220,7 @@ static int asus_wmi_input_init(struct asus_wmi *asus)
         asus->inputdev->phys = asus->driver->input_phys;
         asus->inputdev->id.bustype = BUS_HOST;
         asus->inputdev->dev.parent = &asus->platform_device->dev;
+        set_bit(EV_REP, asus->inputdev->evbit);
 
         err = sparse_keymap_setup(asus->inputdev, asus->driver->keymap, NULL);
         if (err)
@@ -359,30 +375,80 @@ static enum led_brightness tpd_led_get(struct led_classdev *led_cdev)
         return read_tpd_led_state(asus);
 }
 
-static int asus_wmi_led_init(struct asus_wmi *asus)
+static void kbd_led_update(struct work_struct *work)
 {
-        int rv;
+        int ctrl_param = 0;
+        struct asus_wmi *asus;
 
-        if (read_tpd_led_state(asus) < 0)
-                return 0;
+        asus = container_of(work, struct asus_wmi, kbd_led_work);
 
-        asus->led_workqueue = create_singlethread_workqueue("led_workqueue");
-        if (!asus->led_workqueue)
-                return -ENOMEM;
-        INIT_WORK(&asus->tpd_led_work, tpd_led_update);
+        /*
+         * bits 0-2: level
+         * bit 7: light on/off
+         */
+        if (asus->kbd_led_wk > 0)
+                ctrl_param = 0x80 | (asus->kbd_led_wk & 0x7F);
 
-        asus->tpd_led.name = "asus::touchpad";
-        asus->tpd_led.brightness_set = tpd_led_set;
-        asus->tpd_led.brightness_get = tpd_led_get;
-        asus->tpd_led.max_brightness = 1;
+        asus_wmi_set_devstate(ASUS_WMI_DEVID_KBD_BACKLIGHT, ctrl_param, NULL);
+}
 
-        rv = led_classdev_register(&asus->platform_device->dev, &asus->tpd_led);
-        if (rv) {
-                destroy_workqueue(asus->led_workqueue);
-                return rv;
+static int kbd_led_read(struct asus_wmi *asus, int *level, int *env)
+{
+        int retval;
+
+        /*
+         * bits 0-2: level
+         * bit 7: light on/off
+         * bit 8-10: environment (0: dark, 1: normal, 2: light)
+         * bit 17: status unknown
+         */
+        retval = asus_wmi_get_devstate_bits(asus, ASUS_WMI_DEVID_KBD_BACKLIGHT,
+                                            0xFFFF);
+
+        /* Unknown status is considered as off */
+        if (retval == 0x8000)
+                retval = 0;
+
+        if (retval >= 0) {
+                if (level)
+                        *level = retval & 0x80 ? retval & 0x7F : 0;
+                if (env)
+                        *env = (retval >> 8) & 0x7F;
+                retval = 0;
         }
 
-        return 0;
+        return retval;
+}
+
+static void kbd_led_set(struct led_classdev *led_cdev,
+                        enum led_brightness value)
+{
+        struct asus_wmi *asus;
+
+        asus = container_of(led_cdev, struct asus_wmi, kbd_led);
+
+        if (value > asus->kbd_led.max_brightness)
+                value = asus->kbd_led.max_brightness;
+        else if (value < 0)
+                value = 0;
+
+        asus->kbd_led_wk = value;
+        queue_work(asus->led_workqueue, &asus->kbd_led_work);
+}
+
+static enum led_brightness kbd_led_get(struct led_classdev *led_cdev)
+{
+        struct asus_wmi *asus;
+        int retval, value;
+
+        asus = container_of(led_cdev, struct asus_wmi, kbd_led);
+
+        retval = kbd_led_read(asus, &value, NULL);
+
+        if (retval < 0)
+                return retval;
+
+        return value;
 }
 
 static void asus_wmi_led_exit(struct asus_wmi *asus)
@@ -393,6 +459,48 @@ static void asus_wmi_led_exit(struct asus_wmi *asus)
                 destroy_workqueue(asus->led_workqueue);
 }
 
+static int asus_wmi_led_init(struct asus_wmi *asus)
+{
+        int rv = 0;
+
+        asus->led_workqueue = create_singlethread_workqueue("led_workqueue");
+        if (!asus->led_workqueue)
+                return -ENOMEM;
+
+        if (read_tpd_led_state(asus) >= 0) {
+                INIT_WORK(&asus->tpd_led_work, tpd_led_update);
+
+                asus->tpd_led.name = "asus::touchpad";
+                asus->tpd_led.brightness_set = tpd_led_set;
+                asus->tpd_led.brightness_get = tpd_led_get;
+                asus->tpd_led.max_brightness = 1;
+
+                rv = led_classdev_register(&asus->platform_device->dev,
+                                           &asus->tpd_led);
+                if (rv)
+                        goto error;
+        }
+
+        if (kbd_led_read(asus, NULL, NULL) >= 0) {
+                INIT_WORK(&asus->kbd_led_work, kbd_led_update);
+
+                asus->kbd_led.name = "asus::kbd_backlight";
+                asus->kbd_led.brightness_set = kbd_led_set;
+                asus->kbd_led.brightness_get = kbd_led_get;
+                asus->kbd_led.max_brightness = 3;
+
+                rv = led_classdev_register(&asus->platform_device->dev,
+                                           &asus->kbd_led);
+        }
+
+error:
+        if (rv)
+                asus_wmi_led_exit(asus);
+
+        return rv;
+}
+
+
 /*
  * PCI hotplug (for wlan rfkill)
  */
@@ -729,6 +837,16 @@ static void asus_wmi_rfkill_exit(struct asus_wmi *asus)
                 rfkill_destroy(asus->wwan3g.rfkill);
                 asus->wwan3g.rfkill = NULL;
         }
+        if (asus->gps.rfkill) {
+                rfkill_unregister(asus->gps.rfkill);
+                rfkill_destroy(asus->gps.rfkill);
+                asus->gps.rfkill = NULL;
+        }
+        if (asus->uwb.rfkill) {
+                rfkill_unregister(asus->uwb.rfkill);
+                rfkill_destroy(asus->uwb.rfkill);
+                asus->uwb.rfkill = NULL;
+        }
 }
 
 static int asus_wmi_rfkill_init(struct asus_wmi *asus)
@@ -763,6 +881,18 @@ static int asus_wmi_rfkill_init(struct asus_wmi *asus)
         if (result && result != -ENODEV)
                 goto exit;
 
+        result = asus_new_rfkill(asus, &asus->gps, "asus-gps",
+                                 RFKILL_TYPE_GPS, ASUS_WMI_DEVID_GPS);
+
+        if (result && result != -ENODEV)
+                goto exit;
+
+        result = asus_new_rfkill(asus, &asus->uwb, "asus-uwb",
+                                 RFKILL_TYPE_UWB, ASUS_WMI_DEVID_UWB);
+
+        if (result && result != -ENODEV)
+                goto exit;
+
         if (!asus->driver->hotplug_wireless)
                 goto exit;
 
@@ -797,8 +927,8 @@ exit:
  * Hwmon device
  */
 static ssize_t asus_hwmon_pwm1(struct device *dev,
-                            struct device_attribute *attr,
-                            char *buf)
+                               struct device_attribute *attr,
+                               char *buf)
 {
         struct asus_wmi *asus = dev_get_drvdata(dev);
         u32 value;
@@ -809,7 +939,7 @@ static ssize_t asus_hwmon_pwm1(struct device *dev,
         if (err < 0)
                 return err;
 
-        value |= 0xFF;
+        value &= 0xFF;
 
         if (value == 1) /* Low Speed */
                 value = 85;
@@ -825,7 +955,26 @@ static ssize_t asus_hwmon_pwm1(struct device *dev,
         return sprintf(buf, "%d\n", value);
 }
 
+static ssize_t asus_hwmon_temp1(struct device *dev,
+                                struct device_attribute *attr,
+                                char *buf)
+{
+        struct asus_wmi *asus = dev_get_drvdata(dev);
+        u32 value;
+        int err;
+
+        err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_THERMAL_CTRL, &value);
+
+        if (err < 0)
+                return err;
+
+        value = KELVIN_TO_CELSIUS((value & 0xFFFF)) * 1000;
+
+        return sprintf(buf, "%d\n", value);
+}
+
 static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO, asus_hwmon_pwm1, NULL, 0);
+static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, asus_hwmon_temp1, NULL, 0);
 
 static ssize_t
 show_name(struct device *dev, struct device_attribute *attr, char *buf)
@@ -836,12 +985,13 @@ static SENSOR_DEVICE_ATTR(name, S_IRUGO, show_name, NULL, 0);
 
 static struct attribute *hwmon_attributes[] = {
         &sensor_dev_attr_pwm1.dev_attr.attr,
+        &sensor_dev_attr_temp1_input.dev_attr.attr,
         &sensor_dev_attr_name.dev_attr.attr,
         NULL
 };
 
 static mode_t asus_hwmon_sysfs_is_visible(struct kobject *kobj,
-                                    struct attribute *attr, int idx)
+                                          struct attribute *attr, int idx)
 {
         struct device *dev = container_of(kobj, struct device, kobj);
         struct platform_device *pdev = to_platform_device(dev->parent);
@@ -852,6 +1002,8 @@ static mode_t asus_hwmon_sysfs_is_visible(struct kobject *kobj,
 
         if (attr == &sensor_dev_attr_pwm1.dev_attr.attr)
                 dev_id = ASUS_WMI_DEVID_FAN_CTRL;
+        else if (attr == &sensor_dev_attr_temp1_input.dev_attr.attr)
+                dev_id = ASUS_WMI_DEVID_THERMAL_CTRL;
 
         if (dev_id != -1) {
                 int err = asus_wmi_get_devstate(asus, dev_id, &value);
@@ -869,9 +1021,13 @@ static mode_t asus_hwmon_sysfs_is_visible(struct kobject *kobj,
                  * - reverved bits are non-zero
                  * - sfun and presence bit are not set
                  */
-                if (value != ASUS_WMI_UNSUPPORTED_METHOD || value & 0xFFF80000
+                if (value == ASUS_WMI_UNSUPPORTED_METHOD || value & 0xFFF80000
                     || (!asus->sfun && !(value & ASUS_WMI_DSTS_PRESENCE_BIT)))
                         ok = false;
+        } else if (dev_id == ASUS_WMI_DEVID_THERMAL_CTRL) {
+                /* If value is zero, something is clearly wrong */
+                if (value == 0)
+                        ok = false;
         }
 
         return ok ? attr->mode : 0;
@@ -904,6 +1060,7 @@ static int asus_wmi_hwmon_init(struct asus_wmi *asus)
                 pr_err("Could not register asus hwmon device\n");
                 return PTR_ERR(hwmon);
         }
+        dev_set_drvdata(hwmon, asus);
         asus->hwmon_device = hwmon;
         result = sysfs_create_group(&hwmon->kobj, &hwmon_attribute_group);
         if (result)
@@ -1060,6 +1217,8 @@ static void asus_wmi_notify(u32 value, void *context)
         acpi_status status;
         int code;
         int orig_code;
+        unsigned int key_value = 1;
+        bool autorelease = 1;
 
         status = wmi_get_event_data(value, &response);
         if (status != AE_OK) {
@@ -1075,6 +1234,13 @@ static void asus_wmi_notify(u32 value, void *context)
         code = obj->integer.value;
         orig_code = code;
 
+        if (asus->driver->key_filter) {
+                asus->driver->key_filter(asus->driver, &code, &key_value,
+                                         &autorelease);
+                if (code == ASUS_WMI_KEY_IGNORE)
+                        goto exit;
+        }
+
         if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
                 code = NOTIFY_BRNUP_MIN;
         else if (code >= NOTIFY_BRNDOWN_MIN &&
@@ -1084,7 +1250,8 @@ static void asus_wmi_notify(u32 value, void *context)
         if (code == NOTIFY_BRNUP_MIN || code == NOTIFY_BRNDOWN_MIN) {
                 if (!acpi_video_backlight_support())
                         asus_wmi_backlight_notify(asus, orig_code);
-        } else if (!sparse_keymap_report_event(asus->inputdev, code, 1, true))
+        } else if (!sparse_keymap_report_event(asus->inputdev, code,
+                                               key_value, autorelease))
                 pr_info("Unknown key %x pressed\n", code);
 
 exit:
@@ -1164,14 +1331,18 @@ ASUS_WMI_CREATE_DEVICE_ATTR(cardr, 0644, ASUS_WMI_DEVID_CARDREADER);
 static ssize_t store_cpufv(struct device *dev, struct device_attribute *attr,
                            const char *buf, size_t count)
 {
-        int value;
+        int value, rv;
 
         if (!count || sscanf(buf, "%i", &value) != 1)
                 return -EINVAL;
         if (value < 0 || value > 2)
                 return -EINVAL;
 
-        return asus_wmi_evaluate_method(ASUS_WMI_METHODID_CFVS, value, 0, NULL);
+        rv = asus_wmi_evaluate_method(ASUS_WMI_METHODID_CFVS, value, 0, NULL);
+        if (rv < 0)
+                return rv;
+
+        return count;
 }
 
 static DEVICE_ATTR(cpufv, S_IRUGO | S_IWUSR, NULL, store_cpufv);
@@ -1234,7 +1405,7 @@ static int asus_wmi_platform_init(struct asus_wmi *asus)
 
         /* We don't know yet what to do with this version... */
         if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SPEC, 0, 0x9, &rv)) {
-                pr_info("BIOS WMI version: %d.%d", rv >> 8, rv & 0xFF);
+                pr_info("BIOS WMI version: %d.%d", rv >> 16, rv & 0xFF);
                 asus->spec = rv;
         }
 
@@ -1266,6 +1437,12 @@ static int asus_wmi_platform_init(struct asus_wmi *asus)
                 return -ENODEV;
         }
 
+        /* CWAP allow to define the behavior of the Fn+F2 key,
+         * this method doesn't seems to be present on Eee PCs */
+        if (asus->driver->wapf >= 0)
+                asus_wmi_set_devstate(ASUS_WMI_DEVID_CWAP,
+                                      asus->driver->wapf, NULL);
+
         return asus_wmi_sysfs_init(asus->platform_device);
 }
 
@@ -1568,6 +1745,14 @@ static int asus_hotk_restore(struct device *device)
                 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WWAN3G);
                 rfkill_set_sw_state(asus->wwan3g.rfkill, bl);
         }
+        if (asus->gps.rfkill) {
+                bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_GPS);
+                rfkill_set_sw_state(asus->gps.rfkill, bl);
+        }
+        if (asus->uwb.rfkill) {
+                bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_UWB);
+                rfkill_set_sw_state(asus->uwb.rfkill, bl);
+        }
 
         return 0;
 }
@@ -1604,7 +1789,7 @@ static int asus_wmi_probe(struct platform_device *pdev)
 
 static bool used;
 
-int asus_wmi_register_driver(struct asus_wmi_driver *driver)
+int __init_or_module asus_wmi_register_driver(struct asus_wmi_driver *driver)
 {
         struct platform_driver *platform_driver;
         struct platform_device *platform_device;
diff --git a/drivers/platform/x86/asus-wmi.h b/drivers/platform/x86/asus-wmi.h
index c044522c8766..8147c10161cc 100644
--- a/drivers/platform/x86/asus-wmi.h
+++ b/drivers/platform/x86/asus-wmi.h
@@ -29,12 +29,15 @@
 
 #include <linux/platform_device.h>
 
+#define ASUS_WMI_KEY_IGNORE (-1)
+
 struct module;
 struct key_entry;
 struct asus_wmi;
 
 struct asus_wmi_driver {
         bool                    hotplug_wireless;
+        int                     wapf;
 
         const char              *name;
         struct module           *owner;
@@ -44,6 +47,10 @@ struct asus_wmi_driver {
         const struct key_entry  *keymap;
         const char              *input_name;
         const char              *input_phys;
+        /* Returns new code, value, and autorelease values in arguments.
+         * Return ASUS_WMI_KEY_IGNORE in code if event should be ignored. */
+        void (*key_filter) (struct asus_wmi_driver *driver, int *code,
+                            unsigned int *value, bool *autorelease);
 
         int (*probe) (struct platform_device *device);
         void (*quirks) (struct asus_wmi_driver *driver);
diff --git a/drivers/platform/x86/dell-laptop.c b/drivers/platform/x86/dell-laptop.c
index e39ab1d3ed87..f31fa4efa725 100644
--- a/drivers/platform/x86/dell-laptop.c
+++ b/drivers/platform/x86/dell-laptop.c
@@ -612,7 +612,6 @@ static int __init dell_init(void)
         if (!bufferpage)
                 goto fail_buffer;
         buffer = page_address(bufferpage);
-        mutex_init(&buffer_mutex);
 
         ret = dell_setup_rfkill();
 
diff --git a/drivers/platform/x86/dell-wmi.c b/drivers/platform/x86/dell-wmi.c
index ce790827e199..fa9a2171cc13 100644
--- a/drivers/platform/x86/dell-wmi.c
+++ b/drivers/platform/x86/dell-wmi.c
@@ -54,6 +54,8 @@ MODULE_ALIAS("wmi:"DELL_EVENT_GUID);
  */
 
 static const struct key_entry dell_wmi_legacy_keymap[] __initconst = {
+        { KE_IGNORE, 0x003a, { KEY_CAPSLOCK } },
+
         { KE_KEY, 0xe045, { KEY_PROG1 } },
         { KE_KEY, 0xe009, { KEY_EJECTCD } },
 
@@ -85,6 +87,11 @@ static const struct key_entry dell_wmi_legacy_keymap[] __initconst = {
         { KE_IGNORE, 0xe013, { KEY_RESERVED } },
 
         { KE_IGNORE, 0xe020, { KEY_MUTE } },
+
+        /* Shortcut and audio panel keys */
+        { KE_IGNORE, 0xe025, { KEY_RESERVED } },
+        { KE_IGNORE, 0xe026, { KEY_RESERVED } },
+
         { KE_IGNORE, 0xe02e, { KEY_VOLUMEDOWN } },
         { KE_IGNORE, 0xe030, { KEY_VOLUMEUP } },
         { KE_IGNORE, 0xe033, { KEY_KBDILLUMUP } },
@@ -92,6 +99,9 @@ static const struct key_entry dell_wmi_legacy_keymap[] __initconst = {
         { KE_IGNORE, 0xe03a, { KEY_CAPSLOCK } },
         { KE_IGNORE, 0xe045, { KEY_NUMLOCK } },
         { KE_IGNORE, 0xe046, { KEY_SCROLLLOCK } },
+        { KE_IGNORE, 0xe0f7, { KEY_MUTE } },
+        { KE_IGNORE, 0xe0f8, { KEY_VOLUMEDOWN } },
+        { KE_IGNORE, 0xe0f9, { KEY_VOLUMEUP } },
         { KE_END, 0 }
 };
 
diff --git a/drivers/platform/x86/eeepc-wmi.c b/drivers/platform/x86/eeepc-wmi.c
index 4aa867a9b88b..9f6e64302b45 100644
--- a/drivers/platform/x86/eeepc-wmi.c
+++ b/drivers/platform/x86/eeepc-wmi.c
@@ -56,6 +56,11 @@ MODULE_PARM_DESC(hotplug_wireless,
                  "If your laptop needs that, please report to "
                  "acpi4asus-user@lists.sourceforge.net.");
 
+/* Values for T101MT "Home" key */
+#define HOME_PRESS      0xe4
+#define HOME_HOLD       0xea
+#define HOME_RELEASE    0xe5
+
 static const struct key_entry eeepc_wmi_keymap[] = {
         /* Sleep already handled via generic ACPI code */
         { KE_KEY, 0x30, { KEY_VOLUMEUP } },
@@ -71,6 +76,7 @@ static const struct key_entry eeepc_wmi_keymap[] = {
         { KE_KEY, 0xcc, { KEY_SWITCHVIDEOMODE } },
         { KE_KEY, 0xe0, { KEY_PROG1 } }, /* Task Manager */
         { KE_KEY, 0xe1, { KEY_F14 } }, /* Change Resolution */
+        { KE_KEY, HOME_PRESS, { KEY_CONFIG } }, /* Home/Express gate key */
         { KE_KEY, 0xe8, { KEY_SCREENLOCK } },
         { KE_KEY, 0xe9, { KEY_BRIGHTNESS_ZERO } },
         { KE_KEY, 0xeb, { KEY_CAMERA_ZOOMOUT } },
@@ -81,6 +87,25 @@ static const struct key_entry eeepc_wmi_keymap[] = {
         { KE_END, 0},
 };
 
+static void eeepc_wmi_key_filter(struct asus_wmi_driver *asus_wmi, int *code,
+                                 unsigned int *value, bool *autorelease)
+{
+        switch (*code) {
+        case HOME_PRESS:
+                *value = 1;
+                *autorelease = 0;
+                break;
+        case HOME_HOLD:
+                *code = ASUS_WMI_KEY_IGNORE;
+                break;
+        case HOME_RELEASE:
+                *code = HOME_PRESS;
+                *value = 0;
+                *autorelease = 0;
+                break;
+        }
+}
+
 static acpi_status eeepc_wmi_parse_device(acpi_handle handle, u32 level,
                                                  void *context, void **retval)
 {
@@ -141,6 +166,7 @@ static void eeepc_dmi_check(struct asus_wmi_driver *driver)
 static void eeepc_wmi_quirks(struct asus_wmi_driver *driver)
 {
         driver->hotplug_wireless = hotplug_wireless;
+        driver->wapf = -1;
         eeepc_dmi_check(driver);
 }
 
@@ -151,6 +177,7 @@ static struct asus_wmi_driver asus_wmi_driver = {
         .keymap = eeepc_wmi_keymap,
         .input_name = "Eee PC WMI hotkeys",
         .input_phys = EEEPC_WMI_FILE "/input0",
+        .key_filter = eeepc_wmi_key_filter,
         .probe = eeepc_wmi_probe,
         .quirks = eeepc_wmi_quirks,
 };
diff --git a/drivers/platform/x86/ideapad-laptop.c b/drivers/platform/x86/ideapad-laptop.c
index bfdda33feb26..0c595410e788 100644
--- a/drivers/platform/x86/ideapad-laptop.c
+++ b/drivers/platform/x86/ideapad-laptop.c
@@ -32,13 +32,22 @@
 #include <linux/platform_device.h>
 #include <linux/input.h>
 #include <linux/input/sparse-keymap.h>
+#include <linux/backlight.h>
+#include <linux/fb.h>
 
 #define IDEAPAD_RFKILL_DEV_NUM  (3)
 
+#define CFG_BT_BIT      (16)
+#define CFG_3G_BIT      (17)
+#define CFG_WIFI_BIT    (18)
+#define CFG_CAMERA_BIT  (19)
+
 struct ideapad_private {
         struct rfkill *rfk[IDEAPAD_RFKILL_DEV_NUM];
         struct platform_device *platform_device;
         struct input_dev *inputdev;
+        struct backlight_device *blightdev;
+        unsigned long cfg;
 };
 
 static acpi_handle ideapad_handle;
@@ -155,7 +164,7 @@ static int write_ec_cmd(acpi_handle handle, int cmd, unsigned long data)
 }
 
 /*
- * camera power
+ * sysfs
  */
 static ssize_t show_ideapad_cam(struct device *dev,
                                 struct device_attribute *attr,
@@ -186,6 +195,44 @@ static ssize_t store_ideapad_cam(struct device *dev,
 
 static DEVICE_ATTR(camera_power, 0644, show_ideapad_cam, store_ideapad_cam);
 
+static ssize_t show_ideapad_cfg(struct device *dev,
+                                struct device_attribute *attr,
+                                char *buf)
+{
+        struct ideapad_private *priv = dev_get_drvdata(dev);
+
+        return sprintf(buf, "0x%.8lX\n", priv->cfg);
+}
+
+static DEVICE_ATTR(cfg, 0444, show_ideapad_cfg, NULL);
+
+static struct attribute *ideapad_attributes[] = {
+        &dev_attr_camera_power.attr,
+        &dev_attr_cfg.attr,
+        NULL
+};
+
+static mode_t ideapad_is_visible(struct kobject *kobj,
+                                 struct attribute *attr,
+                                 int idx)
+{
+        struct device *dev = container_of(kobj, struct device, kobj);
+        struct ideapad_private *priv = dev_get_drvdata(dev);
+        bool supported;
+
+        if (attr == &dev_attr_camera_power.attr)
+                supported = test_bit(CFG_CAMERA_BIT, &(priv->cfg));
+        else
+                supported = true;
+
+        return supported ? attr->mode : 0;
+}
+
+static struct attribute_group ideapad_attribute_group = {
+        .is_visible = ideapad_is_visible,
+        .attrs = ideapad_attributes
+};
+
 /*
  * Rfkill
  */
@@ -197,9 +244,9 @@ struct ideapad_rfk_data {
 };
 
 const struct ideapad_rfk_data ideapad_rfk_data[] = {
-        { "ideapad_wlan",       18, 0x15, RFKILL_TYPE_WLAN },
-        { "ideapad_bluetooth",  16, 0x17, RFKILL_TYPE_BLUETOOTH },
-        { "ideapad_3g",         17, 0x20, RFKILL_TYPE_WWAN },
+        { "ideapad_wlan",      CFG_WIFI_BIT, 0x15, RFKILL_TYPE_WLAN },
+        { "ideapad_bluetooth", CFG_BT_BIT,   0x17, RFKILL_TYPE_BLUETOOTH },
+        { "ideapad_3g",        CFG_3G_BIT,   0x20, RFKILL_TYPE_WWAN },
 };
 
 static int ideapad_rfk_set(void *data, bool blocked)
@@ -265,8 +312,7 @@ static int __devinit ideapad_register_rfkill(struct acpi_device *adevice,
         return 0;
 }
 
-static void __devexit ideapad_unregister_rfkill(struct acpi_device *adevice,
-                                                int dev)
+static void ideapad_unregister_rfkill(struct acpi_device *adevice, int dev)
 {
         struct ideapad_private *priv = dev_get_drvdata(&adevice->dev);
 
@@ -280,15 +326,6 @@ static void __devexit ideapad_unregister_rfkill(struct acpi_device *adevice,
 /*
  * Platform device
  */
-static struct attribute *ideapad_attributes[] = {
-        &dev_attr_camera_power.attr,
-        NULL
-};
-
-static struct attribute_group ideapad_attribute_group = {
-        .attrs = ideapad_attributes
-};
-
 static int __devinit ideapad_platform_init(struct ideapad_private *priv)
 {
         int result;
@@ -369,7 +406,7 @@ err_free_dev:
         return error;
 }
 
-static void __devexit ideapad_input_exit(struct ideapad_private *priv)
+static void ideapad_input_exit(struct ideapad_private *priv)
 {
         sparse_keymap_free(priv->inputdev);
         input_unregister_device(priv->inputdev);
@@ -383,6 +420,98 @@ static void ideapad_input_report(struct ideapad_private *priv,
 }
 
 /*
+ * backlight
+ */
+static int ideapad_backlight_get_brightness(struct backlight_device *blightdev)
+{
+        unsigned long now;
+
+        if (read_ec_data(ideapad_handle, 0x12, &now))
+                return -EIO;
+        return now;
+}
+
+static int ideapad_backlight_update_status(struct backlight_device *blightdev)
+{
+        if (write_ec_cmd(ideapad_handle, 0x13, blightdev->props.brightness))
+                return -EIO;
+        if (write_ec_cmd(ideapad_handle, 0x33,
+                         blightdev->props.power == FB_BLANK_POWERDOWN ? 0 : 1))
+                return -EIO;
+
+        return 0;
+}
+
+static const struct backlight_ops ideapad_backlight_ops = {
+        .get_brightness = ideapad_backlight_get_brightness,
+        .update_status = ideapad_backlight_update_status,
+};
+
+static int ideapad_backlight_init(struct ideapad_private *priv)
+{
+        struct backlight_device *blightdev;
+        struct backlight_properties props;
+        unsigned long max, now, power;
+
+        if (read_ec_data(ideapad_handle, 0x11, &max))
+                return -EIO;
+        if (read_ec_data(ideapad_handle, 0x12, &now))
+                return -EIO;
+        if (read_ec_data(ideapad_handle, 0x18, &power))
+                return -EIO;
+
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.max_brightness = max;
+        props.type = BACKLIGHT_PLATFORM;
+        blightdev = backlight_device_register("ideapad",
+                                              &priv->platform_device->dev,
+                                              priv,
+                                              &ideapad_backlight_ops,
+                                              &props);
+        if (IS_ERR(blightdev)) {
+                pr_err("Could not register backlight device\n");
+                return PTR_ERR(blightdev);
+        }
+
+        priv->blightdev = blightdev;
+        blightdev->props.brightness = now;
+        blightdev->props.power = power ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
+        backlight_update_status(blightdev);
+
+        return 0;
+}
+
+static void ideapad_backlight_exit(struct ideapad_private *priv)
+{
+        if (priv->blightdev)
+                backlight_device_unregister(priv->blightdev);
+        priv->blightdev = NULL;
+}
+
+static void ideapad_backlight_notify_power(struct ideapad_private *priv)
+{
+        unsigned long power;
+        struct backlight_device *blightdev = priv->blightdev;
+
+        if (read_ec_data(ideapad_handle, 0x18, &power))
+                return;
+        blightdev->props.power = power ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
+}
+
+static void ideapad_backlight_notify_brightness(struct ideapad_private *priv)
+{
+        unsigned long now;
+
+        /* if we control brightness via acpi video driver */
+        if (priv->blightdev == NULL) {
+                read_ec_data(ideapad_handle, 0x12, &now);
+                return;
+        }
+
+        backlight_force_update(priv->blightdev, BACKLIGHT_UPDATE_HOTKEY);
+}
+
+/*
  * module init/exit
  */
 static const struct acpi_device_id ideapad_device_ids[] = {
@@ -393,10 +522,11 @@ MODULE_DEVICE_TABLE(acpi, ideapad_device_ids);
 
 static int __devinit ideapad_acpi_add(struct acpi_device *adevice)
 {
-        int ret, i, cfg;
+        int ret, i;
+        unsigned long cfg;
         struct ideapad_private *priv;
 
-        if (read_method_int(adevice->handle, "_CFG", &cfg))
+        if (read_method_int(adevice->handle, "_CFG", (int *)&cfg))
                 return -ENODEV;
 
         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
@@ -404,6 +534,7 @@ static int __devinit ideapad_acpi_add(struct acpi_device *adevice)
                 return -ENOMEM;
         dev_set_drvdata(&adevice->dev, priv);
         ideapad_handle = adevice->handle;
+        priv->cfg = cfg;
 
         ret = ideapad_platform_init(priv);
         if (ret)
@@ -414,15 +545,25 @@ static int __devinit ideapad_acpi_add(struct acpi_device *adevice)
                 goto input_failed;
 
         for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++) {
-                if (test_bit(ideapad_rfk_data[i].cfgbit, (unsigned long *)&cfg))
+                if (test_bit(ideapad_rfk_data[i].cfgbit, &cfg))
                         ideapad_register_rfkill(adevice, i);
                 else
                         priv->rfk[i] = NULL;
         }
         ideapad_sync_rfk_state(adevice);
 
+        if (!acpi_video_backlight_support()) {
+                ret = ideapad_backlight_init(priv);
+                if (ret && ret != -ENODEV)
+                        goto backlight_failed;
+        }
+
         return 0;
 
+backlight_failed:
+        for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++)
+                ideapad_unregister_rfkill(adevice, i);
+        ideapad_input_exit(priv);
 input_failed:
         ideapad_platform_exit(priv);
 platform_failed:
@@ -435,6 +576,7 @@ static int __devexit ideapad_acpi_remove(struct acpi_device *adevice, int type)
         struct ideapad_private *priv = dev_get_drvdata(&adevice->dev);
         int i;
 
+        ideapad_backlight_exit(priv);
         for (i = 0; i < IDEAPAD_RFKILL_DEV_NUM; i++)
                 ideapad_unregister_rfkill(adevice, i);
         ideapad_input_exit(priv);
@@ -459,12 +601,19 @@ static void ideapad_acpi_notify(struct acpi_device *adevice, u32 event)
         vpc1 = (vpc2 << 8) | vpc1;
         for (vpc_bit = 0; vpc_bit < 16; vpc_bit++) {
                 if (test_bit(vpc_bit, &vpc1)) {
-                        if (vpc_bit == 9)
+                        switch (vpc_bit) {
+                        case 9:
                                 ideapad_sync_rfk_state(adevice);
-                        else if (vpc_bit == 4)
-                                read_ec_data(handle, 0x12, &vpc2);
-                        else
+                                break;
+                        case 4:
+                                ideapad_backlight_notify_brightness(priv);
+                                break;
+                        case 2:
+                                ideapad_backlight_notify_power(priv);
+                                break;
+                        default:
                                 ideapad_input_report(priv, vpc_bit);
+                        }
                 }
         }
 }
diff --git a/drivers/platform/x86/intel_ips.c b/drivers/platform/x86/intel_ips.c
index 5ffe7c398148..809a3ae943c6 100644
--- a/drivers/platform/x86/intel_ips.c
+++ b/drivers/platform/x86/intel_ips.c
@@ -403,7 +403,7 @@ static void ips_cpu_raise(struct ips_driver *ips)
 
         thm_writew(THM_MPCPC, (new_tdp_limit * 10) / 8);
 
-        turbo_override |= TURBO_TDC_OVR_EN | TURBO_TDC_OVR_EN;
+        turbo_override |= TURBO_TDC_OVR_EN | TURBO_TDP_OVR_EN;
         wrmsrl(TURBO_POWER_CURRENT_LIMIT, turbo_override);
 
         turbo_override &= ~TURBO_TDP_MASK;
@@ -438,7 +438,7 @@ static void ips_cpu_lower(struct ips_driver *ips)
 
         thm_writew(THM_MPCPC, (new_limit * 10) / 8);
 
-        turbo_override |= TURBO_TDC_OVR_EN | TURBO_TDC_OVR_EN;
+        turbo_override |= TURBO_TDC_OVR_EN | TURBO_TDP_OVR_EN;
         wrmsrl(TURBO_POWER_CURRENT_LIMIT, turbo_override);
 
         turbo_override &= ~TURBO_TDP_MASK;
diff --git a/drivers/platform/x86/intel_menlow.c b/drivers/platform/x86/intel_menlow.c
index 809adea4965f..abddc83e9fd7 100644
--- a/drivers/platform/x86/intel_menlow.c
+++ b/drivers/platform/x86/intel_menlow.c
@@ -477,6 +477,8 @@ static acpi_status intel_menlow_register_sensor(acpi_handle handle, u32 lvl,
                 return AE_ERROR;
         }
 
+        return AE_OK;
+
  aux1_not_found:
         if (status == AE_NOT_FOUND)
                 return AE_OK;
diff --git a/drivers/platform/x86/intel_mid_thermal.c b/drivers/platform/x86/intel_mid_thermal.c
index 3a578323122b..ccd7b1f83519 100644
--- a/drivers/platform/x86/intel_mid_thermal.c
+++ b/drivers/platform/x86/intel_mid_thermal.c
@@ -493,20 +493,30 @@ static int mid_thermal_probe(struct platform_device *pdev)
 
         /* Register each sensor with the generic thermal framework*/
         for (i = 0; i < MSIC_THERMAL_SENSORS; i++) {
+                struct thermal_device_info *td_info = initialize_sensor(i);
+
+                if (!td_info) {
+                        ret = -ENOMEM;
+                        goto err;
+                }
                 pinfo->tzd[i] = thermal_zone_device_register(name[i],
-                                0, initialize_sensor(i), &tzd_ops, 0, 0, 0, 0);
-                if (IS_ERR(pinfo->tzd[i]))
-                        goto reg_fail;
+                                0, td_info, &tzd_ops, 0, 0, 0, 0);
+                if (IS_ERR(pinfo->tzd[i])) {
+                        kfree(td_info);
+                        ret = PTR_ERR(pinfo->tzd[i]);
+                        goto err;
+                }
         }
 
         pinfo->pdev = pdev;
         platform_set_drvdata(pdev, pinfo);
         return 0;
 
-reg_fail:
-        ret = PTR_ERR(pinfo->tzd[i]);
-        while (--i >= 0)
+err:
+        while (--i >= 0) {
+                kfree(pinfo->tzd[i]->devdata);
                 thermal_zone_device_unregister(pinfo->tzd[i]);
+        }
         configure_adc(0);
         kfree(pinfo);
         return ret;
@@ -524,8 +534,10 @@ static int mid_thermal_remove(struct platform_device *pdev)
         int i;
         struct platform_info *pinfo = platform_get_drvdata(pdev);
 
-        for (i = 0; i < MSIC_THERMAL_SENSORS; i++)
+        for (i = 0; i < MSIC_THERMAL_SENSORS; i++) {
+                kfree(pinfo->tzd[i]->devdata);
                 thermal_zone_device_unregister(pinfo->tzd[i]);
+        }
 
         kfree(pinfo);
         platform_set_drvdata(pdev, NULL);
diff --git a/drivers/platform/x86/intel_rar_register.c b/drivers/platform/x86/intel_rar_register.c
index bde47e9080cd..c8a6aed45277 100644
--- a/drivers/platform/x86/intel_rar_register.c
+++ b/drivers/platform/x86/intel_rar_register.c
@@ -637,15 +637,13 @@ end_function:
         return error;
 }
 
-const struct pci_device_id rar_pci_id_tbl[] = {
+static DEFINE_PCI_DEVICE_TABLE(rar_pci_id_tbl) = {
         { PCI_VDEVICE(INTEL, 0x4110) },
         { 0 }
 };
 
 MODULE_DEVICE_TABLE(pci, rar_pci_id_tbl);
 
-const struct pci_device_id *my_id_table = rar_pci_id_tbl;
-
 /* field for registering driver to PCI device */
 static struct pci_driver rar_pci_driver = {
         .name = "rar_register_driver",
diff --git a/drivers/platform/x86/intel_scu_ipc.c b/drivers/platform/x86/intel_scu_ipc.c
index 940accbe28d3..c86665369a22 100644
--- a/drivers/platform/x86/intel_scu_ipc.c
+++ b/drivers/platform/x86/intel_scu_ipc.c
@@ -725,7 +725,7 @@ static void ipc_remove(struct pci_dev *pdev)
         intel_scu_devices_destroy();
 }
 
-static const struct pci_device_id pci_ids[] = {
+static DEFINE_PCI_DEVICE_TABLE(pci_ids) = {
         {PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x080e)},
         {PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x082a)},
         { 0,}
diff --git a/drivers/platform/x86/msi-laptop.c b/drivers/platform/x86/msi-laptop.c
index 3ff629df9f01..f204643c5052 100644
--- a/drivers/platform/x86/msi-laptop.c
+++ b/drivers/platform/x86/msi-laptop.c
@@ -538,6 +538,15 @@ static struct dmi_system_id __initdata msi_load_scm_models_dmi_table[] = {
                 },
                 .callback = dmi_check_cb
         },
+        {
+                .ident = "MSI U270",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                "Micro-Star International Co., Ltd."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "U270 series"),
+                },
+                .callback = dmi_check_cb
+        },
         { }
 };
 
@@ -996,3 +1005,4 @@ MODULE_ALIAS("dmi:*:svnMICRO-STARINTERNATIONAL*:pnMS-N034:*");
 MODULE_ALIAS("dmi:*:svnMICRO-STARINTERNATIONAL*:pnMS-N051:*");
 MODULE_ALIAS("dmi:*:svnMICRO-STARINTERNATIONAL*:pnMS-N014:*");
 MODULE_ALIAS("dmi:*:svnMicro-StarInternational*:pnCR620:*");
+MODULE_ALIAS("dmi:*:svnMicro-StarInternational*:pnU270series:*");
diff --git a/drivers/platform/x86/msi-wmi.c b/drivers/platform/x86/msi-wmi.c
index c832e3356cd6..6f40bf202dc7 100644
--- a/drivers/platform/x86/msi-wmi.c
+++ b/drivers/platform/x86/msi-wmi.c
@@ -272,6 +272,7 @@ static int __init msi_wmi_init(void)
 err_free_backlight:
         backlight_device_unregister(backlight);
 err_free_input:
+        sparse_keymap_free(msi_wmi_input_dev);
         input_unregister_device(msi_wmi_input_dev);
 err_uninstall_notifier:
         wmi_remove_notify_handler(MSIWMI_EVENT_GUID);
diff --git a/drivers/platform/x86/samsung-laptop.c b/drivers/platform/x86/samsung-laptop.c
index d347116d150e..359163011044 100644
--- a/drivers/platform/x86/samsung-laptop.c
+++ b/drivers/platform/x86/samsung-laptop.c
@@ -521,6 +521,16 @@ static struct dmi_system_id __initdata samsung_dmi_table[] = {
                 .callback = dmi_check_cb,
         },
         {
+                .ident = "N510",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "N510"),
+                        DMI_MATCH(DMI_BOARD_NAME, "N510"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
                 .ident = "X125",
                 .matches = {
                         DMI_MATCH(DMI_SYS_VENDOR,
@@ -601,6 +611,16 @@ static struct dmi_system_id __initdata samsung_dmi_table[] = {
                 .callback = dmi_check_cb,
         },
         {
+                .ident = "N150/N210/N220",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                        "SAMSUNG ELECTRONICS CO., LTD."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "N150/N210/N220"),
+                        DMI_MATCH(DMI_BOARD_NAME, "N150/N210/N220"),
+                },
+                .callback = dmi_check_cb,
+        },
+        {
                 .ident = "N150/N210/N220/N230",
                 .matches = {
                         DMI_MATCH(DMI_SYS_VENDOR,
diff --git a/drivers/platform/x86/samsung-q10.c b/drivers/platform/x86/samsung-q10.c
new file mode 100644
index 000000000000..1e54ae74274c
--- /dev/null
+++ b/drivers/platform/x86/samsung-q10.c
@@ -0,0 +1,196 @@
+/*
+ *  Driver for Samsung Q10 and related laptops: controls the backlight
+ *
+ *  Copyright (c) 2011 Frederick van der Wyck <fvanderwyck@gmail.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/backlight.h>
+#include <linux/i8042.h>
+#include <linux/dmi.h>
+
+#define SAMSUNGQ10_BL_MAX_INTENSITY      255
+#define SAMSUNGQ10_BL_DEFAULT_INTENSITY  185
+
+#define SAMSUNGQ10_BL_8042_CMD           0xbe
+#define SAMSUNGQ10_BL_8042_DATA          { 0x89, 0x91 }
+
+static int samsungq10_bl_brightness;
+
+static bool force;
+module_param(force, bool, 0);
+MODULE_PARM_DESC(force,
+                "Disable the DMI check and force the driver to be loaded");
+
+static int samsungq10_bl_set_intensity(struct backlight_device *bd)
+{
+
+        int brightness = bd->props.brightness;
+        unsigned char c[3] = SAMSUNGQ10_BL_8042_DATA;
+
+        c[2] = (unsigned char)brightness;
+        i8042_lock_chip();
+        i8042_command(c, (0x30 << 8) | SAMSUNGQ10_BL_8042_CMD);
+        i8042_unlock_chip();
+        samsungq10_bl_brightness = brightness;
+
+        return 0;
+}
+
+static int samsungq10_bl_get_intensity(struct backlight_device *bd)
+{
+        return samsungq10_bl_brightness;
+}
+
+static const struct backlight_ops samsungq10_bl_ops = {
+        .get_brightness = samsungq10_bl_get_intensity,
+        .update_status  = samsungq10_bl_set_intensity,
+};
+
+#ifdef CONFIG_PM_SLEEP
+static int samsungq10_suspend(struct device *dev)
+{
+        return 0;
+}
+
+static int samsungq10_resume(struct device *dev)
+{
+
+        struct backlight_device *bd = dev_get_drvdata(dev);
+
+        samsungq10_bl_set_intensity(bd);
+        return 0;
+}
+#else
+#define samsungq10_suspend NULL
+#define samsungq10_resume  NULL
+#endif
+
+static SIMPLE_DEV_PM_OPS(samsungq10_pm_ops,
+                          samsungq10_suspend, samsungq10_resume);
+
+static int __devinit samsungq10_probe(struct platform_device *pdev)
+{
+
+        struct backlight_properties props;
+        struct backlight_device *bd;
+
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_PLATFORM;
+        props.max_brightness = SAMSUNGQ10_BL_MAX_INTENSITY;
+        bd = backlight_device_register("samsung", &pdev->dev, NULL,
+                                       &samsungq10_bl_ops, &props);
+        if (IS_ERR(bd))
+                return PTR_ERR(bd);
+
+        platform_set_drvdata(pdev, bd);
+
+        bd->props.brightness = SAMSUNGQ10_BL_DEFAULT_INTENSITY;
+        samsungq10_bl_set_intensity(bd);
+
+        return 0;
+}
+
+static int __devexit samsungq10_remove(struct platform_device *pdev)
+{
+
+        struct backlight_device *bd = platform_get_drvdata(pdev);
+
+        bd->props.brightness = SAMSUNGQ10_BL_DEFAULT_INTENSITY;
+        samsungq10_bl_set_intensity(bd);
+
+        backlight_device_unregister(bd);
+
+        return 0;
+}
+
+static struct platform_driver samsungq10_driver = {
+        .driver         = {
+                .name   = KBUILD_MODNAME,
+                .owner  = THIS_MODULE,
+                .pm     = &samsungq10_pm_ops,
+        },
+        .probe          = samsungq10_probe,
+        .remove         = __devexit_p(samsungq10_remove),
+};
+
+static struct platform_device *samsungq10_device;
+
+static int __init dmi_check_callback(const struct dmi_system_id *id)
+{
+        printk(KERN_INFO KBUILD_MODNAME ": found model '%s'\n", id->ident);
+        return 1;
+}
+
+static struct dmi_system_id __initdata samsungq10_dmi_table[] = {
+        {
+                .ident = "Samsung Q10",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Samsung"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "SQ10"),
+                },
+                .callback = dmi_check_callback,
+        },
+        {
+                .ident = "Samsung Q20",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG Electronics"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "SENS Q20"),
+                },
+                .callback = dmi_check_callback,
+        },
+        {
+                .ident = "Samsung Q25",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG Electronics"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "NQ25"),
+                },
+                .callback = dmi_check_callback,
+        },
+        {
+                .ident = "Dell Latitude X200",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "X200"),
+                },
+                .callback = dmi_check_callback,
+        },
+        { },
+};
+MODULE_DEVICE_TABLE(dmi, samsungq10_dmi_table);
+
+static int __init samsungq10_init(void)
+{
+        if (!force && !dmi_check_system(samsungq10_dmi_table))
+                return -ENODEV;
+
+        samsungq10_device = platform_create_bundle(&samsungq10_driver,
+                                                   samsungq10_probe,
+                                                   NULL, 0, NULL, 0);
+
+        if (IS_ERR(samsungq10_device))
+                return PTR_ERR(samsungq10_device);
+
+        return 0;
+}
+
+static void __exit samsungq10_exit(void)
+{
+        platform_device_unregister(samsungq10_device);
+        platform_driver_unregister(&samsungq10_driver);
+}
+
+module_init(samsungq10_init);
+module_exit(samsungq10_exit);
+
+MODULE_AUTHOR("Frederick van der Wyck <fvanderwyck@gmail.com>");
+MODULE_DESCRIPTION("Samsung Q10 Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/platform/x86/thinkpad_acpi.c b/drivers/platform/x86/thinkpad_acpi.c
index 26c5b117df22..7bd829f247eb 100644
--- a/drivers/platform/x86/thinkpad_acpi.c
+++ b/drivers/platform/x86/thinkpad_acpi.c
@@ -3186,8 +3186,17 @@ static int __init hotkey_init(struct ibm_init_struct *iibm)
                 KEY_VENDOR,     /* 0x17: Thinkpad/AccessIBM/Lenovo */
 
                 /* (assignments unknown, please report if found) */
+                KEY_UNKNOWN, KEY_UNKNOWN,
+
+                /*
+                 * The mic mute button only sends 0x1a.  It does not
+                 * automatically mute the mic or change the mute light.
+                 */
+                KEY_MICMUTE,    /* 0x1a: Mic mute (since ?400 or so) */
+
+                /* (assignments unknown, please report if found) */
                 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
-                KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
+                KEY_UNKNOWN,
                 },
         };
 
diff --git a/drivers/power/Kconfig b/drivers/power/Kconfig
index e57b50b38565..57de051a74b3 100644
--- a/drivers/power/Kconfig
+++ b/drivers/power/Kconfig
@@ -235,4 +235,18 @@ config CHARGER_GPIO
           This driver can be build as a module. If so, the module will be
           called gpio-charger.
 
+config CHARGER_MAX8997
+        tristate "Maxim MAX8997/MAX8966 PMIC battery charger driver"
+        depends on MFD_MAX8997 && REGULATOR_MAX8997
+        help
+          Say Y to enable support for the battery charger control sysfs and
+          platform data of MAX8997/LP3974 PMICs.
+
+config CHARGER_MAX8998
+        tristate "Maxim MAX8998/LP3974 PMIC battery charger driver"
+        depends on MFD_MAX8998 && REGULATOR_MAX8998
+        help
+          Say Y to enable support for the battery charger control sysfs and
+          platform data of MAX8998/LP3974 PMICs.
+
 endif # POWER_SUPPLY
diff --git a/drivers/power/Makefile b/drivers/power/Makefile
index 009a90fa8ac9..b4af13dd8b66 100644
--- a/drivers/power/Makefile
+++ b/drivers/power/Makefile
@@ -36,3 +36,5 @@ obj-$(CONFIG_CHARGER_ISP1704)	+= isp1704_charger.o
 obj-$(CONFIG_CHARGER_MAX8903)   += max8903_charger.o
 obj-$(CONFIG_CHARGER_TWL4030)   += twl4030_charger.o
 obj-$(CONFIG_CHARGER_GPIO)      += gpio-charger.o
+obj-$(CONFIG_CHARGER_MAX8997)   += max8997_charger.o
+obj-$(CONFIG_CHARGER_MAX8998)   += max8998_charger.o
diff --git a/drivers/power/apm_power.c b/drivers/power/apm_power.c
index dc628cb2e762..8a612dec9139 100644
--- a/drivers/power/apm_power.c
+++ b/drivers/power/apm_power.c
@@ -14,11 +14,11 @@
 #include <linux/apm-emulation.h>
 
 
-#define PSY_PROP(psy, prop, val) psy->get_property(psy, \
-                         POWER_SUPPLY_PROP_##prop, val)
+#define PSY_PROP(psy, prop, val) (psy->get_property(psy, \
+                         POWER_SUPPLY_PROP_##prop, val))
 
-#define _MPSY_PROP(prop, val) main_battery->get_property(main_battery, \
-                                                         prop, val)
+#define _MPSY_PROP(prop, val) (main_battery->get_property(main_battery, \
+                                                         prop, val))
 
 #define MPSY_PROP(prop, val) _MPSY_PROP(POWER_SUPPLY_PROP_##prop, val)
 
diff --git a/drivers/power/bq20z75.c b/drivers/power/bq20z75.c
index 506585e31a5b..9c5e5beda3a8 100644
--- a/drivers/power/bq20z75.c
+++ b/drivers/power/bq20z75.c
@@ -152,6 +152,10 @@ struct bq20z75_info {
         bool                            gpio_detect;
         bool                            enable_detection;
         int                             irq;
+        int                             last_state;
+        int                             poll_time;
+        struct delayed_work             work;
+        int                             ignore_changes;
 };
 
 static int bq20z75_read_word_data(struct i2c_client *client, u8 address)
@@ -279,6 +283,7 @@ static int bq20z75_get_battery_property(struct i2c_client *client,
         int reg_offset, enum power_supply_property psp,
         union power_supply_propval *val)
 {
+        struct bq20z75_info *bq20z75_device = i2c_get_clientdata(client);
         s32 ret;
 
         ret = bq20z75_read_word_data(client,
@@ -293,15 +298,24 @@ static int bq20z75_get_battery_property(struct i2c_client *client,
         if (ret >= bq20z75_data[reg_offset].min_value &&
             ret <= bq20z75_data[reg_offset].max_value) {
                 val->intval = ret;
-                if (psp == POWER_SUPPLY_PROP_STATUS) {
-                        if (ret & BATTERY_FULL_CHARGED)
-                                val->intval = POWER_SUPPLY_STATUS_FULL;
-                        else if (ret & BATTERY_FULL_DISCHARGED)
-                                val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
-                        else if (ret & BATTERY_DISCHARGING)
-                                val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
-                        else
-                                val->intval = POWER_SUPPLY_STATUS_CHARGING;
+                if (psp != POWER_SUPPLY_PROP_STATUS)
+                        return 0;
+
+                if (ret & BATTERY_FULL_CHARGED)
+                        val->intval = POWER_SUPPLY_STATUS_FULL;
+                else if (ret & BATTERY_FULL_DISCHARGED)
+                        val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
+                else if (ret & BATTERY_DISCHARGING)
+                        val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
+                else
+                        val->intval = POWER_SUPPLY_STATUS_CHARGING;
+
+                if (bq20z75_device->poll_time == 0)
+                        bq20z75_device->last_state = val->intval;
+                else if (bq20z75_device->last_state != val->intval) {
+                        cancel_delayed_work_sync(&bq20z75_device->work);
+                        power_supply_changed(&bq20z75_device->power_supply);
+                        bq20z75_device->poll_time = 0;
                 }
         } else {
                 if (psp == POWER_SUPPLY_PROP_STATUS)
@@ -545,6 +559,60 @@ static irqreturn_t bq20z75_irq(int irq, void *devid)
         return IRQ_HANDLED;
 }
 
+static void bq20z75_external_power_changed(struct power_supply *psy)
+{
+        struct bq20z75_info *bq20z75_device;
+
+        bq20z75_device = container_of(psy, struct bq20z75_info, power_supply);
+
+        if (bq20z75_device->ignore_changes > 0) {
+                bq20z75_device->ignore_changes--;
+                return;
+        }
+
+        /* cancel outstanding work */
+        cancel_delayed_work_sync(&bq20z75_device->work);
+
+        schedule_delayed_work(&bq20z75_device->work, HZ);
+        bq20z75_device->poll_time = bq20z75_device->pdata->poll_retry_count;
+}
+
+static void bq20z75_delayed_work(struct work_struct *work)
+{
+        struct bq20z75_info *bq20z75_device;
+        s32 ret;
+
+        bq20z75_device = container_of(work, struct bq20z75_info, work.work);
+
+        ret = bq20z75_read_word_data(bq20z75_device->client,
+                                     bq20z75_data[REG_STATUS].addr);
+        /* if the read failed, give up on this work */
+        if (ret < 0) {
+                bq20z75_device->poll_time = 0;
+                return;
+        }
+
+        if (ret & BATTERY_FULL_CHARGED)
+                ret = POWER_SUPPLY_STATUS_FULL;
+        else if (ret & BATTERY_FULL_DISCHARGED)
+                ret = POWER_SUPPLY_STATUS_NOT_CHARGING;
+        else if (ret & BATTERY_DISCHARGING)
+                ret = POWER_SUPPLY_STATUS_DISCHARGING;
+        else
+                ret = POWER_SUPPLY_STATUS_CHARGING;
+
+        if (bq20z75_device->last_state != ret) {
+                bq20z75_device->poll_time = 0;
+                power_supply_changed(&bq20z75_device->power_supply);
+                return;
+        }
+        if (bq20z75_device->poll_time > 0) {
+                schedule_delayed_work(&bq20z75_device->work, HZ);
+                bq20z75_device->poll_time--;
+                return;
+        }
+}
+
 static int __devinit bq20z75_probe(struct i2c_client *client,
         const struct i2c_device_id *id)
 {
@@ -566,6 +634,13 @@ static int __devinit bq20z75_probe(struct i2c_client *client,
         bq20z75_device->power_supply.num_properties =
                 ARRAY_SIZE(bq20z75_properties);
         bq20z75_device->power_supply.get_property = bq20z75_get_property;
+        /* ignore first notification of external change, it is generated
+         * from the power_supply_register call back
+         */
+        bq20z75_device->ignore_changes = 1;
+        bq20z75_device->last_state = POWER_SUPPLY_STATUS_UNKNOWN;
+        bq20z75_device->power_supply.external_power_changed =
+                bq20z75_external_power_changed;
 
         if (pdata) {
                 bq20z75_device->gpio_detect =
@@ -625,6 +700,10 @@ skip_gpio:
         dev_info(&client->dev,
                 "%s: battery gas gauge device registered\n", client->name);
 
+        INIT_DELAYED_WORK(&bq20z75_device->work, bq20z75_delayed_work);
+
+        bq20z75_device->enable_detection = true;
+
         return 0;
 
 exit_psupply:
@@ -648,6 +727,9 @@ static int __devexit bq20z75_remove(struct i2c_client *client)
                 gpio_free(bq20z75_device->pdata->battery_detect);
 
         power_supply_unregister(&bq20z75_device->power_supply);
+
+        cancel_delayed_work_sync(&bq20z75_device->work);
+
         kfree(bq20z75_device);
         bq20z75_device = NULL;
 
@@ -661,6 +743,9 @@ static int bq20z75_suspend(struct i2c_client *client,
         struct bq20z75_info *bq20z75_device = i2c_get_clientdata(client);
         s32 ret;
 
+        if (bq20z75_device->poll_time > 0)
+                cancel_delayed_work_sync(&bq20z75_device->work);
+
         /* write to manufacturer access with sleep command */
         ret = bq20z75_write_word_data(client,
                 bq20z75_data[REG_MANUFACTURER_DATA].addr,
diff --git a/drivers/power/gpio-charger.c b/drivers/power/gpio-charger.c
index 718f2c537827..a64b8854cfd5 100644
--- a/drivers/power/gpio-charger.c
+++ b/drivers/power/gpio-charger.c
@@ -127,7 +127,7 @@ static int __devinit gpio_charger_probe(struct platform_device *pdev)
                 ret = request_any_context_irq(irq, gpio_charger_irq,
                                 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
                                 dev_name(&pdev->dev), charger);
-                if (ret)
+                if (ret < 0)
                         dev_warn(&pdev->dev, "Failed to request irq: %d\n", ret);
                 else
                         gpio_charger->irq = irq;
diff --git a/drivers/power/max17042_battery.c b/drivers/power/max17042_battery.c
index c5c8805156cb..98bfab35b8e9 100644
--- a/drivers/power/max17042_battery.c
+++ b/drivers/power/max17042_battery.c
@@ -29,74 +29,6 @@
 #include <linux/power_supply.h>
 #include <linux/power/max17042_battery.h>
 
-enum max17042_register {
-        MAX17042_STATUS         = 0x00,
-        MAX17042_VALRT_Th       = 0x01,
-        MAX17042_TALRT_Th       = 0x02,
-        MAX17042_SALRT_Th       = 0x03,
-        MAX17042_AtRate         = 0x04,
-        MAX17042_RepCap         = 0x05,
-        MAX17042_RepSOC         = 0x06,
-        MAX17042_Age            = 0x07,
-        MAX17042_TEMP           = 0x08,
-        MAX17042_VCELL          = 0x09,
-        MAX17042_Current        = 0x0A,
-        MAX17042_AvgCurrent     = 0x0B,
-        MAX17042_Qresidual      = 0x0C,
-        MAX17042_SOC            = 0x0D,
-        MAX17042_AvSOC          = 0x0E,
-        MAX17042_RemCap         = 0x0F,
-        MAX17402_FullCAP        = 0x10,
-        MAX17042_TTE            = 0x11,
-        MAX17042_V_empty        = 0x12,
-
-        MAX17042_RSLOW          = 0x14,
-
-        MAX17042_AvgTA          = 0x16,
-        MAX17042_Cycles         = 0x17,
-        MAX17042_DesignCap      = 0x18,
-        MAX17042_AvgVCELL       = 0x19,
-        MAX17042_MinMaxTemp     = 0x1A,
-        MAX17042_MinMaxVolt     = 0x1B,
-        MAX17042_MinMaxCurr     = 0x1C,
-        MAX17042_CONFIG         = 0x1D,
-        MAX17042_ICHGTerm       = 0x1E,
-        MAX17042_AvCap          = 0x1F,
-        MAX17042_ManName        = 0x20,
-        MAX17042_DevName        = 0x21,
-        MAX17042_DevChem        = 0x22,
-
-        MAX17042_TempNom        = 0x24,
-        MAX17042_TempCold       = 0x25,
-        MAX17042_TempHot        = 0x26,
-        MAX17042_AIN            = 0x27,
-        MAX17042_LearnCFG       = 0x28,
-        MAX17042_SHFTCFG        = 0x29,
-        MAX17042_RelaxCFG       = 0x2A,
-        MAX17042_MiscCFG        = 0x2B,
-        MAX17042_TGAIN          = 0x2C,
-        MAx17042_TOFF           = 0x2D,
-        MAX17042_CGAIN          = 0x2E,
-        MAX17042_COFF           = 0x2F,
-
-        MAX17042_Q_empty        = 0x33,
-        MAX17042_T_empty        = 0x34,
-
-        MAX17042_RCOMP0         = 0x38,
-        MAX17042_TempCo         = 0x39,
-        MAX17042_Rx             = 0x3A,
-        MAX17042_T_empty0       = 0x3B,
-        MAX17042_TaskPeriod     = 0x3C,
-        MAX17042_FSTAT          = 0x3D,
-
-        MAX17042_SHDNTIMER      = 0x3F,
-
-        MAX17042_VFRemCap       = 0x4A,
-
-        MAX17042_QH             = 0x4D,
-        MAX17042_QL             = 0x4E,
-};
-
 struct max17042_chip {
         struct i2c_client *client;
         struct power_supply battery;
@@ -123,10 +55,27 @@ static int max17042_read_reg(struct i2c_client *client, u8 reg)
         return ret;
 }
 
+static void max17042_set_reg(struct i2c_client *client,
+                             struct max17042_reg_data *data, int size)
+{
+        int i;
+
+        for (i = 0; i < size; i++)
+                max17042_write_reg(client, data[i].addr, data[i].data);
+}
+
 static enum power_supply_property max17042_battery_props[] = {
+        POWER_SUPPLY_PROP_PRESENT,
+        POWER_SUPPLY_PROP_CYCLE_COUNT,
+        POWER_SUPPLY_PROP_VOLTAGE_MAX,
+        POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
         POWER_SUPPLY_PROP_VOLTAGE_NOW,
         POWER_SUPPLY_PROP_VOLTAGE_AVG,
         POWER_SUPPLY_PROP_CAPACITY,
+        POWER_SUPPLY_PROP_CHARGE_FULL,
+        POWER_SUPPLY_PROP_TEMP,
+        POWER_SUPPLY_PROP_CURRENT_NOW,
+        POWER_SUPPLY_PROP_CURRENT_AVG,
 };
 
 static int max17042_get_property(struct power_supply *psy,
@@ -137,6 +86,30 @@ static int max17042_get_property(struct power_supply *psy,
                                 struct max17042_chip, battery);
 
         switch (psp) {
+        case POWER_SUPPLY_PROP_PRESENT:
+                val->intval = max17042_read_reg(chip->client,
+                                MAX17042_STATUS);
+                if (val->intval & MAX17042_STATUS_BattAbsent)
+                        val->intval = 0;
+                else
+                        val->intval = 1;
+                break;
+        case POWER_SUPPLY_PROP_CYCLE_COUNT:
+                val->intval = max17042_read_reg(chip->client,
+                                MAX17042_Cycles);
+                break;
+        case POWER_SUPPLY_PROP_VOLTAGE_MAX:
+                val->intval = max17042_read_reg(chip->client,
+                                MAX17042_MinMaxVolt);
+                val->intval >>= 8;
+                val->intval *= 20000; /* Units of LSB = 20mV */
+                break;
+        case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
+                val->intval = max17042_read_reg(chip->client,
+                                MAX17042_V_empty);
+                val->intval >>= 7;
+                val->intval *= 10000; /* Units of LSB = 10mV */
+                break;
         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
                 val->intval = max17042_read_reg(chip->client,
                                 MAX17042_VCELL) * 83; /* 1000 / 12 = 83 */
@@ -149,6 +122,57 @@ static int max17042_get_property(struct power_supply *psy,
                 val->intval = max17042_read_reg(chip->client,
                                 MAX17042_SOC) / 256;
                 break;
+        case POWER_SUPPLY_PROP_CHARGE_FULL:
+                val->intval = max17042_read_reg(chip->client,
+                                MAX17042_RepSOC);
+                if ((val->intval / 256) >= MAX17042_BATTERY_FULL)
+                        val->intval = 1;
+                else if (val->intval >= 0)
+                        val->intval = 0;
+                break;
+        case POWER_SUPPLY_PROP_TEMP:
+                val->intval = max17042_read_reg(chip->client,
+                                MAX17042_TEMP);
+                /* The value is signed. */
+                if (val->intval & 0x8000) {
+                        val->intval = (0x7fff & ~val->intval) + 1;
+                        val->intval *= -1;
+                }
+                /* The value is converted into deci-centigrade scale */
+                /* Units of LSB = 1 / 256 degree Celsius */
+                val->intval = val->intval * 10 / 256;
+                break;
+        case POWER_SUPPLY_PROP_CURRENT_NOW:
+                if (chip->pdata->enable_current_sense) {
+                        val->intval = max17042_read_reg(chip->client,
+                                        MAX17042_Current);
+                        if (val->intval & 0x8000) {
+                                /* Negative */
+                                val->intval = ~val->intval & 0x7fff;
+                                val->intval++;
+                                val->intval *= -1;
+                        }
+                        val->intval >>= 4;
+                        val->intval *= 1000000 * 25 / chip->pdata->r_sns;
+                } else {
+                        return -EINVAL;
+                }
+                break;
+        case POWER_SUPPLY_PROP_CURRENT_AVG:
+                if (chip->pdata->enable_current_sense) {
+                        val->intval = max17042_read_reg(chip->client,
+                                        MAX17042_AvgCurrent);
+                        if (val->intval & 0x8000) {
+                                /* Negative */
+                                val->intval = ~val->intval & 0x7fff;
+                                val->intval++;
+                                val->intval *= -1;
+                        }
+                        val->intval *= 1562500 / chip->pdata->r_sns;
+                } else {
+                        return -EINVAL;
+                }
+                break;
         default:
                 return -EINVAL;
         }
@@ -180,18 +204,30 @@ static int __devinit max17042_probe(struct i2c_client *client,
         chip->battery.properties        = max17042_battery_props;
         chip->battery.num_properties    = ARRAY_SIZE(max17042_battery_props);
 
+        /* When current is not measured,
+         * CURRENT_NOW and CURRENT_AVG properties should be invisible. */
+        if (!chip->pdata->enable_current_sense)
+                chip->battery.num_properties -= 2;
+
         ret = power_supply_register(&client->dev, &chip->battery);
         if (ret) {
                 dev_err(&client->dev, "failed: power supply register\n");
-                i2c_set_clientdata(client, NULL);
                 kfree(chip);
                 return ret;
         }
 
+        /* Initialize registers according to values from the platform data */
+        if (chip->pdata->init_data)
+                max17042_set_reg(client, chip->pdata->init_data,
+                                 chip->pdata->num_init_data);
+
         if (!chip->pdata->enable_current_sense) {
                 max17042_write_reg(client, MAX17042_CGAIN, 0x0000);
                 max17042_write_reg(client, MAX17042_MiscCFG, 0x0003);
                 max17042_write_reg(client, MAX17042_LearnCFG, 0x0007);
+        } else {
+                if (chip->pdata->r_sns == 0)
+                        chip->pdata->r_sns = MAX17042_DEFAULT_SNS_RESISTOR;
         }
 
         return 0;
@@ -202,7 +238,6 @@ static int __devexit max17042_remove(struct i2c_client *client)
         struct max17042_chip *chip = i2c_get_clientdata(client);
 
         power_supply_unregister(&chip->battery);
-        i2c_set_clientdata(client, NULL);
         kfree(chip);
         return 0;
 }
diff --git a/drivers/power/max8903_charger.c b/drivers/power/max8903_charger.c
index 33ff0e37809e..a9b0209a2f55 100644
--- a/drivers/power/max8903_charger.c
+++ b/drivers/power/max8903_charger.c
@@ -28,7 +28,7 @@
 #include <linux/power/max8903_charger.h>
 
 struct max8903_data {
-        struct max8903_pdata *pdata;
+        struct max8903_pdata pdata;
         struct device *dev;
         struct power_supply psy;
         bool fault;
@@ -52,8 +52,8 @@ static int max8903_get_property(struct power_supply *psy,
         switch (psp) {
         case POWER_SUPPLY_PROP_STATUS:
                 val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
-                if (data->pdata->chg) {
-                        if (gpio_get_value(data->pdata->chg) == 0)
+                if (data->pdata.chg) {
+                        if (gpio_get_value(data->pdata.chg) == 0)
                                 val->intval = POWER_SUPPLY_STATUS_CHARGING;
                         else if (data->usb_in || data->ta_in)
                                 val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
@@ -80,7 +80,7 @@ static int max8903_get_property(struct power_supply *psy,
 static irqreturn_t max8903_dcin(int irq, void *_data)
 {
         struct max8903_data *data = _data;
-        struct max8903_pdata *pdata = data->pdata;
+        struct max8903_pdata *pdata = &data->pdata;
         bool ta_in;
         enum power_supply_type old_type;
 
@@ -121,7 +121,7 @@ static irqreturn_t max8903_dcin(int irq, void *_data)
 static irqreturn_t max8903_usbin(int irq, void *_data)
 {
         struct max8903_data *data = _data;
-        struct max8903_pdata *pdata = data->pdata;
+        struct max8903_pdata *pdata = &data->pdata;
         bool usb_in;
         enum power_supply_type old_type;
 
@@ -160,7 +160,7 @@ static irqreturn_t max8903_usbin(int irq, void *_data)
 static irqreturn_t max8903_fault(int irq, void *_data)
 {
         struct max8903_data *data = _data;
-        struct max8903_pdata *pdata = data->pdata;
+        struct max8903_pdata *pdata = &data->pdata;
         bool fault;
 
         fault = gpio_get_value(pdata->flt) ? false : true;
@@ -193,7 +193,7 @@ static __devinit int max8903_probe(struct platform_device *pdev)
                 dev_err(dev, "Cannot allocate memory.\n");
                 return -ENOMEM;
         }
-        data->pdata = pdata;
+        memcpy(&data->pdata, pdata, sizeof(struct max8903_pdata));
         data->dev = dev;
         platform_set_drvdata(pdev, data);
 
@@ -349,7 +349,7 @@ static __devexit int max8903_remove(struct platform_device *pdev)
         struct max8903_data *data = platform_get_drvdata(pdev);
 
         if (data) {
-                struct max8903_pdata *pdata = data->pdata;
+                struct max8903_pdata *pdata = &data->pdata;
 
                 if (pdata->flt)
                         free_irq(gpio_to_irq(pdata->flt), data);
diff --git a/drivers/power/max8997_charger.c b/drivers/power/max8997_charger.c
new file mode 100644
index 000000000000..ffc5033ea9c9
--- /dev/null
+++ b/drivers/power/max8997_charger.c
@@ -0,0 +1,207 @@
+/*
+ * max8997_charger.c - Power supply consumer driver for the Maxim 8997/8966
+ *
+ *  Copyright (C) 2011 Samsung Electronics
+ *  MyungJoo Ham <myungjoo.ham@samsung.com>
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include <linux/err.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/platform_device.h>
+#include <linux/power_supply.h>
+#include <linux/mfd/max8997.h>
+#include <linux/mfd/max8997-private.h>
+
+struct charger_data {
+        struct device *dev;
+        struct max8997_dev *iodev;
+        struct power_supply battery;
+};
+
+static enum power_supply_property max8997_battery_props[] = {
+        POWER_SUPPLY_PROP_STATUS, /* "FULL" or "NOT FULL" only. */
+        POWER_SUPPLY_PROP_PRESENT, /* the presence of battery */
+        POWER_SUPPLY_PROP_ONLINE, /* charger is active or not */
+};
+
+/* Note that the charger control is done by a current regulator "CHARGER" */
+static int max8997_battery_get_property(struct power_supply *psy,
+                enum power_supply_property psp,
+                union power_supply_propval *val)
+{
+        struct charger_data *charger = container_of(psy,
+                        struct charger_data, battery);
+        struct i2c_client *i2c = charger->iodev->i2c;
+        int ret;
+        u8 reg;
+
+        switch (psp) {
+        case POWER_SUPPLY_PROP_STATUS:
+                val->intval = 0;
+                ret = max8997_read_reg(i2c, MAX8997_REG_STATUS4, &reg);
+                if (ret)
+                        return ret;
+                if ((reg & (1 << 0)) == 0x1)
+                        val->intval = POWER_SUPPLY_STATUS_FULL;
+
+                break;
+        case POWER_SUPPLY_PROP_PRESENT:
+                val->intval = 0;
+                ret = max8997_read_reg(i2c, MAX8997_REG_STATUS4, &reg);
+                if (ret)
+                        return ret;
+                if ((reg & (1 << 2)) == 0x0)
+                        val->intval = 1;
+
+                break;
+        case POWER_SUPPLY_PROP_ONLINE:
+                val->intval = 0;
+                ret = max8997_read_reg(i2c, MAX8997_REG_STATUS4, &reg);
+                if (ret)
+                        return ret;
+                /* DCINOK */
+                if (reg & (1 << 1))
+                        val->intval = 1;
+
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static __devinit int max8997_battery_probe(struct platform_device *pdev)
+{
+        int ret = 0;
+        struct charger_data *charger;
+        struct max8997_dev *iodev = dev_get_drvdata(pdev->dev.parent);
+        struct max8997_platform_data *pdata = dev_get_platdata(iodev->dev);
+
+        if (!pdata)
+                return -EINVAL;
+
+        if (pdata->eoc_mA) {
+                u8 val = (pdata->eoc_mA - 50) / 10;
+                if (val < 0)
+                        val = 0;
+                if (val > 0xf)
+                        val = 0xf;
+
+                ret = max8997_update_reg(iodev->i2c,
+                                MAX8997_REG_MBCCTRL5, val, 0xf);
+                if (ret < 0) {
+                        dev_err(&pdev->dev, "Cannot use i2c bus.\n");
+                        return ret;
+                }
+        }
+
+        switch (pdata->timeout) {
+        case 5:
+                ret = max8997_update_reg(iodev->i2c, MAX8997_REG_MBCCTRL1,
+                                0x2 << 4, 0x7 << 4);
+                break;
+        case 6:
+                ret = max8997_update_reg(iodev->i2c, MAX8997_REG_MBCCTRL1,
+                                0x3 << 4, 0x7 << 4);
+                break;
+        case 7:
+                ret = max8997_update_reg(iodev->i2c, MAX8997_REG_MBCCTRL1,
+                                0x4 << 4, 0x7 << 4);
+                break;
+        case 0:
+                ret = max8997_update_reg(iodev->i2c, MAX8997_REG_MBCCTRL1,
+                                0x7 << 4, 0x7 << 4);
+                break;
+        default:
+                dev_err(&pdev->dev, "incorrect timeout value (%d)\n",
+                                pdata->timeout);
+                return -EINVAL;
+        }
+        if (ret < 0) {
+                dev_err(&pdev->dev, "Cannot use i2c bus.\n");
+                return ret;
+        }
+
+        charger = kzalloc(sizeof(struct charger_data), GFP_KERNEL);
+        if (charger == NULL) {
+                dev_err(&pdev->dev, "Cannot allocate memory.\n");
+                return -ENOMEM;
+        }
+
+        platform_set_drvdata(pdev, charger);
+
+        charger->battery.name = "max8997_pmic";
+        charger->battery.type = POWER_SUPPLY_TYPE_BATTERY;
+        charger->battery.get_property = max8997_battery_get_property;
+        charger->battery.properties = max8997_battery_props;
+        charger->battery.num_properties = ARRAY_SIZE(max8997_battery_props);
+
+        charger->dev = &pdev->dev;
+        charger->iodev = iodev;
+
+        ret = power_supply_register(&pdev->dev, &charger->battery);
+        if (ret) {
+                dev_err(&pdev->dev, "failed: power supply register\n");
+                goto err;
+        }
+
+        return 0;
+err:
+        kfree(charger);
+        return ret;
+}
+
+static int __devexit max8997_battery_remove(struct platform_device *pdev)
+{
+        struct charger_data *charger = platform_get_drvdata(pdev);
+
+        power_supply_unregister(&charger->battery);
+        kfree(charger);
+        return 0;
+}
+
+static const struct platform_device_id max8997_battery_id[] = {
+        { "max8997-battery", 0 },
+};
+
+static struct platform_driver max8997_battery_driver = {
+        .driver = {
+                .name = "max8997-battery",
+                .owner = THIS_MODULE,
+        },
+        .probe = max8997_battery_probe,
+        .remove = __devexit_p(max8997_battery_remove),
+        .id_table = max8997_battery_id,
+};
+
+static int __init max8997_battery_init(void)
+{
+        return platform_driver_register(&max8997_battery_driver);
+}
+subsys_initcall(max8997_battery_init);
+
+static void __exit max8997_battery_cleanup(void)
+{
+        platform_driver_unregister(&max8997_battery_driver);
+}
+module_exit(max8997_battery_cleanup);
+
+MODULE_DESCRIPTION("MAXIM 8997/8966 battery control driver");
+MODULE_AUTHOR("MyungJoo Ham <myungjoo.ham@samsung.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/power/max8998_charger.c b/drivers/power/max8998_charger.c
new file mode 100644
index 000000000000..ef8efadb58cb
--- /dev/null
+++ b/drivers/power/max8998_charger.c
@@ -0,0 +1,219 @@
+/*
+ * max8998_charger.c - Power supply consumer driver for the Maxim 8998/LP3974
+ *
+ *  Copyright (C) 2009-2010 Samsung Electronics
+ *  MyungJoo Ham <myungjoo.ham@samsung.com>
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include <linux/err.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/platform_device.h>
+#include <linux/power_supply.h>
+#include <linux/mfd/max8998.h>
+#include <linux/mfd/max8998-private.h>
+
+struct max8998_battery_data {
+        struct device *dev;
+        struct max8998_dev *iodev;
+        struct power_supply battery;
+};
+
+static enum power_supply_property max8998_battery_props[] = {
+        POWER_SUPPLY_PROP_PRESENT, /* the presence of battery */
+        POWER_SUPPLY_PROP_ONLINE, /* charger is active or not */
+};
+
+/* Note that the charger control is done by a current regulator "CHARGER" */
+static int max8998_battery_get_property(struct power_supply *psy,
+                enum power_supply_property psp,
+                union power_supply_propval *val)
+{
+        struct max8998_battery_data *max8998 = container_of(psy,
+                        struct max8998_battery_data, battery);
+        struct i2c_client *i2c = max8998->iodev->i2c;
+        int ret;
+        u8 reg;
+
+        switch (psp) {
+        case POWER_SUPPLY_PROP_PRESENT:
+                ret = max8998_read_reg(i2c, MAX8998_REG_STATUS2, &reg);
+                if (ret)
+                        return ret;
+                if (reg & (1 << 4))
+                        val->intval = 0;
+                else
+                        val->intval = 1;
+                break;
+        case POWER_SUPPLY_PROP_ONLINE:
+                ret = max8998_read_reg(i2c, MAX8998_REG_STATUS2, &reg);
+                if (ret)
+                        return ret;
+                if (reg & (1 << 3))
+                        val->intval = 0;
+                else
+                        val->intval = 1;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static __devinit int max8998_battery_probe(struct platform_device *pdev)
+{
+        struct max8998_dev *iodev = dev_get_drvdata(pdev->dev.parent);
+        struct max8998_platform_data *pdata = dev_get_platdata(iodev->dev);
+        struct max8998_battery_data *max8998;
+        struct i2c_client *i2c;
+        int ret = 0;
+
+        if (!pdata) {
+                dev_err(pdev->dev.parent, "No platform init data supplied\n");
+                return -ENODEV;
+        }
+
+        max8998 = kzalloc(sizeof(struct max8998_battery_data), GFP_KERNEL);
+        if (!max8998)
+                return -ENOMEM;
+
+        max8998->dev = &pdev->dev;
+        max8998->iodev = iodev;
+        platform_set_drvdata(pdev, max8998);
+        i2c = max8998->iodev->i2c;
+
+        /* Setup "End of Charge" */
+        /* If EOC value equals 0,
+         * remain value set from bootloader or default value */
+        if (pdata->eoc >= 10 && pdata->eoc <= 45) {
+                max8998_update_reg(i2c, MAX8998_REG_CHGR1,
+                                (pdata->eoc / 5 - 2) << 5, 0x7 << 5);
+        } else if (pdata->eoc == 0) {
+                dev_dbg(max8998->dev,
+                        "EOC value not set: leave it unchanged.\n");
+        } else {
+                dev_err(max8998->dev, "Invalid EOC value\n");
+                ret = -EINVAL;
+                goto err;
+        }
+
+        /* Setup Charge Restart Level */
+        switch (pdata->restart) {
+        case 100:
+                max8998_update_reg(i2c, MAX8998_REG_CHGR1, 0x1 << 3, 0x3 << 3);
+                break;
+        case 150:
+                max8998_update_reg(i2c, MAX8998_REG_CHGR1, 0x0 << 3, 0x3 << 3);
+                break;
+        case 200:
+                max8998_update_reg(i2c, MAX8998_REG_CHGR1, 0x2 << 3, 0x3 << 3);
+                break;
+        case -1:
+                max8998_update_reg(i2c, MAX8998_REG_CHGR1, 0x3 << 3, 0x3 << 3);
+                break;
+        case 0:
+                dev_dbg(max8998->dev,
+                        "Restart Level not set: leave it unchanged.\n");
+                break;
+        default:
+                dev_err(max8998->dev, "Invalid Restart Level\n");
+                ret = -EINVAL;
+                goto err;
+        }
+
+        /* Setup Charge Full Timeout */
+        switch (pdata->timeout) {
+        case 5:
+                max8998_update_reg(i2c, MAX8998_REG_CHGR2, 0x0 << 4, 0x3 << 4);
+                break;
+        case 6:
+                max8998_update_reg(i2c, MAX8998_REG_CHGR2, 0x1 << 4, 0x3 << 4);
+                break;
+        case 7:
+                max8998_update_reg(i2c, MAX8998_REG_CHGR2, 0x2 << 4, 0x3 << 4);
+                break;
+        case -1:
+                max8998_update_reg(i2c, MAX8998_REG_CHGR2, 0x3 << 4, 0x3 << 4);
+                break;
+        case 0:
+                dev_dbg(max8998->dev,
+                        "Full Timeout not set: leave it unchanged.\n");
+        default:
+                dev_err(max8998->dev, "Invalid Full Timeout value\n");
+                ret = -EINVAL;
+                goto err;
+        }
+
+        max8998->battery.name = "max8998_pmic";
+        max8998->battery.type = POWER_SUPPLY_TYPE_BATTERY;
+        max8998->battery.get_property = max8998_battery_get_property;
+        max8998->battery.properties = max8998_battery_props;
+        max8998->battery.num_properties = ARRAY_SIZE(max8998_battery_props);
+
+        ret = power_supply_register(max8998->dev, &max8998->battery);
+        if (ret) {
+                dev_err(max8998->dev, "failed: power supply register\n");
+                goto err;
+        }
+
+        return 0;
+err:
+        kfree(max8998);
+        return ret;
+}
+
+static int __devexit max8998_battery_remove(struct platform_device *pdev)
+{
+        struct max8998_battery_data *max8998 = platform_get_drvdata(pdev);
+
+        power_supply_unregister(&max8998->battery);
+        kfree(max8998);
+
+        return 0;
+}
+
+static const struct platform_device_id max8998_battery_id[] = {
+        { "max8998-battery", TYPE_MAX8998 },
+};
+
+static struct platform_driver max8998_battery_driver = {
+        .driver = {
+                .name = "max8998-battery",
+                .owner = THIS_MODULE,
+        },
+        .probe = max8998_battery_probe,
+        .remove = __devexit_p(max8998_battery_remove),
+        .id_table = max8998_battery_id,
+};
+
+static int __init max8998_battery_init(void)
+{
+        return platform_driver_register(&max8998_battery_driver);
+}
+module_init(max8998_battery_init);
+
+static void __exit max8998_battery_cleanup(void)
+{
+        platform_driver_unregister(&max8998_battery_driver);
+}
+module_exit(max8998_battery_cleanup);
+
+MODULE_DESCRIPTION("MAXIM 8998 battery control driver");
+MODULE_AUTHOR("MyungJoo Ham <myungjoo.ham@samsung.com>");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:max8998-battery");
diff --git a/drivers/power/s3c_adc_battery.c b/drivers/power/s3c_adc_battery.c
index d36c289aaef5..d32d0d70f9ba 100644
--- a/drivers/power/s3c_adc_battery.c
+++ b/drivers/power/s3c_adc_battery.c
@@ -20,6 +20,7 @@
 #include <linux/s3c_adc_battery.h>
 #include <linux/errno.h>
 #include <linux/init.h>
+#include <linux/module.h>
 
 #include <plat/adc.h>
 
@@ -266,7 +267,7 @@ static irqreturn_t s3c_adc_bat_charged(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
-static int __init s3c_adc_bat_probe(struct platform_device *pdev)
+static int __devinit s3c_adc_bat_probe(struct platform_device *pdev)
 {
         struct s3c_adc_client   *client;
         struct s3c_adc_bat_pdata *pdata = pdev->dev.platform_data;
diff --git a/drivers/power/twl4030_charger.c b/drivers/power/twl4030_charger.c
index 92c16e1677bd..54b9198fa576 100644
--- a/drivers/power/twl4030_charger.c
+++ b/drivers/power/twl4030_charger.c
@@ -62,7 +62,7 @@
 #define TWL4030_MSTATEC_COMPLETE4       0x0e
 
 static bool allow_usb;
-module_param(allow_usb, bool, 1);
+module_param(allow_usb, bool, 0644);
 MODULE_PARM_DESC(allow_usb, "Allow USB charge drawing default current");
 
 struct twl4030_bci {
@@ -425,7 +425,7 @@ static int __init twl4030_bci_probe(struct platform_device *pdev)
 {
         struct twl4030_bci *bci;
         int ret;
-        int reg;
+        u32 reg;
 
         bci = kzalloc(sizeof(*bci), GFP_KERNEL);
         if (bci == NULL)
@@ -486,7 +486,7 @@ static int __init twl4030_bci_probe(struct platform_device *pdev)
         }
 
         /* Enable interrupts now. */
-        reg = ~(TWL4030_ICHGLOW | TWL4030_ICHGEOC | TWL4030_TBATOR2 |
+        reg = ~(u32)(TWL4030_ICHGLOW | TWL4030_ICHGEOC | TWL4030_TBATOR2 |
                 TWL4030_TBATOR1 | TWL4030_BATSTS);
         ret = twl_i2c_write_u8(TWL4030_MODULE_INTERRUPTS, reg,
                                TWL4030_INTERRUPTS_BCIIMR1A);
@@ -495,7 +495,7 @@ static int __init twl4030_bci_probe(struct platform_device *pdev)
                 goto fail_unmask_interrupts;
         }
 
-        reg = ~(TWL4030_VBATOV | TWL4030_VBUSOV | TWL4030_ACCHGOV);
+        reg = ~(u32)(TWL4030_VBATOV | TWL4030_VBUSOV | TWL4030_ACCHGOV);
         ret = twl_i2c_write_u8(TWL4030_MODULE_INTERRUPTS, reg,
                                TWL4030_INTERRUPTS_BCIIMR2A);
         if (ret < 0)
@@ -572,7 +572,7 @@ static void __exit twl4030_bci_exit(void)
 }
 module_exit(twl4030_bci_exit);
 
-MODULE_AUTHOR("Gražydas Ignotas");
+MODULE_AUTHOR("Gražvydas Ignotas");
 MODULE_DESCRIPTION("TWL4030 Battery Charger Interface driver");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS("platform:twl4030_bci");
diff --git a/drivers/power/wm831x_backup.c b/drivers/power/wm831x_backup.c
index 0fd130d80f5d..e648cbea1e6a 100644
--- a/drivers/power/wm831x_backup.c
+++ b/drivers/power/wm831x_backup.c
@@ -22,6 +22,7 @@
 struct wm831x_backup {
         struct wm831x *wm831x;
         struct power_supply backup;
+        char name[20];
 };
 
 static int wm831x_backup_read_voltage(struct wm831x *wm831x,
@@ -163,6 +164,7 @@ static enum power_supply_property wm831x_backup_props[] = {
 static __devinit int wm831x_backup_probe(struct platform_device *pdev)
 {
         struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
+        struct wm831x_pdata *wm831x_pdata = wm831x->dev->platform_data;
         struct wm831x_backup *devdata;
         struct power_supply *backup;
         int ret;
@@ -182,7 +184,14 @@ static __devinit int wm831x_backup_probe(struct platform_device *pdev)
          */
         wm831x_config_backup(wm831x);
 
-        backup->name = "wm831x-backup";
+        if (wm831x_pdata && wm831x_pdata->wm831x_num)
+                snprintf(devdata->name, sizeof(devdata->name),
+                         "wm831x-backup.%d", wm831x_pdata->wm831x_num);
+        else
+                snprintf(devdata->name, sizeof(devdata->name),
+                         "wm831x-backup");
+
+        backup->name = devdata->name;
         backup->type = POWER_SUPPLY_TYPE_BATTERY;
         backup->properties = wm831x_backup_props;
         backup->num_properties = ARRAY_SIZE(wm831x_backup_props);
@@ -203,6 +212,7 @@ static __devexit int wm831x_backup_remove(struct platform_device *pdev)
         struct wm831x_backup *devdata = platform_get_drvdata(pdev);
 
         power_supply_unregister(&devdata->backup);
+        kfree(devdata->backup.name);
         kfree(devdata);
 
         return 0;
diff --git a/drivers/power/wm831x_power.c b/drivers/power/wm831x_power.c
index ddf8cf5f3204..6cc2ca6427f3 100644
--- a/drivers/power/wm831x_power.c
+++ b/drivers/power/wm831x_power.c
@@ -24,6 +24,9 @@ struct wm831x_power {
         struct power_supply wall;
         struct power_supply usb;
         struct power_supply battery;
+        char wall_name[20];
+        char usb_name[20];
+        char battery_name[20];
 };
 
 static int wm831x_power_check_online(struct wm831x *wm831x, int supply,
@@ -486,6 +489,7 @@ static irqreturn_t wm831x_pwr_src_irq(int irq, void *data)
 static __devinit int wm831x_power_probe(struct platform_device *pdev)
 {
         struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
+        struct wm831x_pdata *wm831x_pdata = wm831x->dev->platform_data;
         struct wm831x_power *power;
         struct power_supply *usb;
         struct power_supply *battery;
@@ -503,12 +507,28 @@ static __devinit int wm831x_power_probe(struct platform_device *pdev)
         battery = &power->battery;
         wall = &power->wall;
 
+        if (wm831x_pdata && wm831x_pdata->wm831x_num) {
+                snprintf(power->wall_name, sizeof(power->wall_name),
+                         "wm831x-wall.%d", wm831x_pdata->wm831x_num);
+                snprintf(power->battery_name, sizeof(power->wall_name),
+                         "wm831x-battery.%d", wm831x_pdata->wm831x_num);
+                snprintf(power->usb_name, sizeof(power->wall_name),
+                         "wm831x-usb.%d", wm831x_pdata->wm831x_num);
+        } else {
+                snprintf(power->wall_name, sizeof(power->wall_name),
+                         "wm831x-wall");
+                snprintf(power->battery_name, sizeof(power->wall_name),
+                         "wm831x-battery");
+                snprintf(power->usb_name, sizeof(power->wall_name),
+                         "wm831x-usb");
+        }
+
         /* We ignore configuration failures since we can still read back
          * the status without enabling the charger.
          */
         wm831x_config_battery(wm831x);
 
-        wall->name = "wm831x-wall";
+        wall->name = power->wall_name;
         wall->type = POWER_SUPPLY_TYPE_MAINS;
         wall->properties = wm831x_wall_props;
         wall->num_properties = ARRAY_SIZE(wm831x_wall_props);
@@ -517,7 +537,7 @@ static __devinit int wm831x_power_probe(struct platform_device *pdev)
         if (ret)
                 goto err_kmalloc;
 
-        battery->name = "wm831x-battery";
+        battery->name = power->battery_name;
         battery->properties = wm831x_bat_props;
         battery->num_properties = ARRAY_SIZE(wm831x_bat_props);
         battery->get_property = wm831x_bat_get_prop;
@@ -526,7 +546,7 @@ static __devinit int wm831x_power_probe(struct platform_device *pdev)
         if (ret)
                 goto err_wall;
 
-        usb->name = "wm831x-usb",
+        usb->name = power->usb_name,
         usb->type = POWER_SUPPLY_TYPE_USB;
         usb->properties = wm831x_usb_props;
         usb->num_properties = ARRAY_SIZE(wm831x_usb_props);
diff --git a/drivers/rapidio/rio-scan.c b/drivers/rapidio/rio-scan.c
index ee893581d4b7..ebe77dd87daf 100644
--- a/drivers/rapidio/rio-scan.c
+++ b/drivers/rapidio/rio-scan.c
@@ -505,8 +505,7 @@ static struct rio_dev __devinit *rio_setup_device(struct rio_net *net,
         rdev->dev.dma_mask = &rdev->dma_mask;
         rdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
 
-        if ((rdev->pef & RIO_PEF_INB_DOORBELL) &&
-            (rdev->dst_ops & RIO_DST_OPS_DOORBELL))
+        if (rdev->dst_ops & RIO_DST_OPS_DOORBELL)
                 rio_init_dbell_res(&rdev->riores[RIO_DOORBELL_RESOURCE],
                                    0, 0xffff);
 
diff --git a/drivers/regulator/Kconfig b/drivers/regulator/Kconfig
index 118eb213eb3a..c7fd2c0e3f2b 100644
--- a/drivers/regulator/Kconfig
+++ b/drivers/regulator/Kconfig
@@ -249,6 +249,12 @@ config REGULATOR_TPS6507X
           three step-down converters and two general-purpose LDO voltage regulators.
           It supports TI's software based Class-2 SmartReflex implementation.
 
+config REGULATOR_TPS65912
+        tristate "TI TPS65912 Power regulator"
+        depends on (MFD_TPS65912_I2C || MFD_TPS65912_SPI)
+        help
+            This driver supports TPS65912 voltage regulator chip.
+
 config REGULATOR_88PM8607
         bool "Marvell 88PM8607 Power regulators"
         depends on MFD_88PM860X=y
@@ -304,5 +310,12 @@ config REGULATOR_TPS65910
         help
           This driver supports TPS65910 voltage regulator chips.
 
+config REGULATOR_AAT2870
+        tristate "AnalogicTech AAT2870 Regulators"
+        depends on MFD_AAT2870_CORE
+        help
+          If you have a AnalogicTech AAT2870 say Y to enable the
+          regulator driver.
+
 endif
 
diff --git a/drivers/regulator/Makefile b/drivers/regulator/Makefile
index 3932d2ec38f3..040d5aa63535 100644
--- a/drivers/regulator/Makefile
+++ b/drivers/regulator/Makefile
@@ -38,10 +38,12 @@ obj-$(CONFIG_REGULATOR_TPS6105X) += tps6105x-regulator.o
 obj-$(CONFIG_REGULATOR_TPS65023) += tps65023-regulator.o
 obj-$(CONFIG_REGULATOR_TPS6507X) += tps6507x-regulator.o
 obj-$(CONFIG_REGULATOR_TPS6524X) += tps6524x-regulator.o
+obj-$(CONFIG_REGULATOR_TPS65912) += tps65912-regulator.o
 obj-$(CONFIG_REGULATOR_88PM8607) += 88pm8607.o
 obj-$(CONFIG_REGULATOR_ISL6271A) += isl6271a-regulator.o
 obj-$(CONFIG_REGULATOR_AB8500)  += ab8500.o
 obj-$(CONFIG_REGULATOR_DB8500_PRCMU) += db8500-prcmu.o
 obj-$(CONFIG_REGULATOR_TPS65910) += tps65910-regulator.o
+obj-$(CONFIG_REGULATOR_AAT2870) += aat2870-regulator.o
 
 ccflags-$(CONFIG_REGULATOR_DEBUG) += -DDEBUG
diff --git a/drivers/regulator/aat2870-regulator.c b/drivers/regulator/aat2870-regulator.c
new file mode 100644
index 000000000000..cd4104542f0d
--- /dev/null
+++ b/drivers/regulator/aat2870-regulator.c
@@ -0,0 +1,232 @@
+/*
+ * linux/drivers/regulator/aat2870-regulator.c
+ *
+ * Copyright (c) 2011, NVIDIA Corporation.
+ * Author: Jin Park <jinyoungp@nvidia.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * 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
+ */
+
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/err.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/driver.h>
+#include <linux/regulator/machine.h>
+#include <linux/mfd/aat2870.h>
+
+struct aat2870_regulator {
+        struct platform_device *pdev;
+        struct regulator_desc desc;
+
+        const int *voltages; /* uV */
+
+        int min_uV;
+        int max_uV;
+
+        u8 enable_addr;
+        u8 enable_shift;
+        u8 enable_mask;
+
+        u8 voltage_addr;
+        u8 voltage_shift;
+        u8 voltage_mask;
+};
+
+static int aat2870_ldo_list_voltage(struct regulator_dev *rdev,
+                                    unsigned selector)
+{
+        struct aat2870_regulator *ri = rdev_get_drvdata(rdev);
+
+        return ri->voltages[selector];
+}
+
+static int aat2870_ldo_set_voltage_sel(struct regulator_dev *rdev,
+                                       unsigned selector)
+{
+        struct aat2870_regulator *ri = rdev_get_drvdata(rdev);
+        struct aat2870_data *aat2870 = dev_get_drvdata(ri->pdev->dev.parent);
+
+        return aat2870->update(aat2870, ri->voltage_addr, ri->voltage_mask,
+                        (selector << ri->voltage_shift) & ri->voltage_mask);
+}
+
+static int aat2870_ldo_get_voltage_sel(struct regulator_dev *rdev)
+{
+        struct aat2870_regulator *ri = rdev_get_drvdata(rdev);
+        struct aat2870_data *aat2870 = dev_get_drvdata(ri->pdev->dev.parent);
+        u8 val;
+        int ret;
+
+        ret = aat2870->read(aat2870, ri->voltage_addr, &val);
+        if (ret)
+                return ret;
+
+        return (val & ri->voltage_mask) >> ri->voltage_shift;
+}
+
+static int aat2870_ldo_enable(struct regulator_dev *rdev)
+{
+        struct aat2870_regulator *ri = rdev_get_drvdata(rdev);
+        struct aat2870_data *aat2870 = dev_get_drvdata(ri->pdev->dev.parent);
+
+        return aat2870->update(aat2870, ri->enable_addr, ri->enable_mask,
+                               ri->enable_mask);
+}
+
+static int aat2870_ldo_disable(struct regulator_dev *rdev)
+{
+        struct aat2870_regulator *ri = rdev_get_drvdata(rdev);
+        struct aat2870_data *aat2870 = dev_get_drvdata(ri->pdev->dev.parent);
+
+        return aat2870->update(aat2870, ri->enable_addr, ri->enable_mask, 0);
+}
+
+static int aat2870_ldo_is_enabled(struct regulator_dev *rdev)
+{
+        struct aat2870_regulator *ri = rdev_get_drvdata(rdev);
+        struct aat2870_data *aat2870 = dev_get_drvdata(ri->pdev->dev.parent);
+        u8 val;
+        int ret;
+
+        ret = aat2870->read(aat2870, ri->enable_addr, &val);
+        if (ret)
+                return ret;
+
+        return val & ri->enable_mask ? 1 : 0;
+}
+
+static struct regulator_ops aat2870_ldo_ops = {
+        .list_voltage = aat2870_ldo_list_voltage,
+        .set_voltage_sel = aat2870_ldo_set_voltage_sel,
+        .get_voltage_sel = aat2870_ldo_get_voltage_sel,
+        .enable = aat2870_ldo_enable,
+        .disable = aat2870_ldo_disable,
+        .is_enabled = aat2870_ldo_is_enabled,
+};
+
+static const int aat2870_ldo_voltages[] = {
+        1200000, 1300000, 1500000, 1600000,
+        1800000, 2000000, 2200000, 2500000,
+        2600000, 2700000, 2800000, 2900000,
+        3000000, 3100000, 3200000, 3300000,
+};
+
+#define AAT2870_LDO(ids)                                \
+        {                                               \
+                .desc = {                               \
+                        .name = #ids,                   \
+                        .id = AAT2870_ID_##ids,         \
+                        .n_voltages = ARRAY_SIZE(aat2870_ldo_voltages), \
+                        .ops = &aat2870_ldo_ops,        \
+                        .type = REGULATOR_VOLTAGE,      \
+                        .owner = THIS_MODULE,           \
+                },                                      \
+                .voltages = aat2870_ldo_voltages,       \
+                .min_uV = 1200000,                      \
+                .max_uV = 3300000,                      \
+        }
+
+static struct aat2870_regulator aat2870_regulators[] = {
+        AAT2870_LDO(LDOA),
+        AAT2870_LDO(LDOB),
+        AAT2870_LDO(LDOC),
+        AAT2870_LDO(LDOD),
+};
+
+static struct aat2870_regulator *aat2870_get_regulator(int id)
+{
+        struct aat2870_regulator *ri = NULL;
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(aat2870_regulators); i++) {
+                ri = &aat2870_regulators[i];
+                if (ri->desc.id == id)
+                        break;
+        }
+
+        if (!ri)
+                return NULL;
+
+        ri->enable_addr = AAT2870_LDO_EN;
+        ri->enable_shift = id - AAT2870_ID_LDOA;
+        ri->enable_mask = 0x1 << ri->enable_shift;
+
+        ri->voltage_addr = (id - AAT2870_ID_LDOA) / 2 ?
+                           AAT2870_LDO_CD : AAT2870_LDO_AB;
+        ri->voltage_shift = (id - AAT2870_ID_LDOA) % 2 ? 0 : 4;
+        ri->voltage_mask = 0xF << ri->voltage_shift;
+
+        return ri;
+}
+
+static int aat2870_regulator_probe(struct platform_device *pdev)
+{
+        struct aat2870_regulator *ri;
+        struct regulator_dev *rdev;
+
+        ri = aat2870_get_regulator(pdev->id);
+        if (!ri) {
+                dev_err(&pdev->dev, "Invalid device ID, %d\n", pdev->id);
+                return -EINVAL;
+        }
+        ri->pdev = pdev;
+
+        rdev = regulator_register(&ri->desc, &pdev->dev,
+                                  pdev->dev.platform_data, ri);
+        if (IS_ERR(rdev)) {
+                dev_err(&pdev->dev, "Failed to register regulator %s\n",
+                        ri->desc.name);
+                return PTR_ERR(rdev);
+        }
+        platform_set_drvdata(pdev, rdev);
+
+        return 0;
+}
+
+static int __devexit aat2870_regulator_remove(struct platform_device *pdev)
+{
+        struct regulator_dev *rdev = platform_get_drvdata(pdev);
+
+        regulator_unregister(rdev);
+        return 0;
+}
+
+static struct platform_driver aat2870_regulator_driver = {
+        .driver = {
+                .name   = "aat2870-regulator",
+                .owner  = THIS_MODULE,
+        },
+        .probe  = aat2870_regulator_probe,
+        .remove = __devexit_p(aat2870_regulator_remove),
+};
+
+static int __init aat2870_regulator_init(void)
+{
+        return platform_driver_register(&aat2870_regulator_driver);
+}
+subsys_initcall(aat2870_regulator_init);
+
+static void __exit aat2870_regulator_exit(void)
+{
+        platform_driver_unregister(&aat2870_regulator_driver);
+}
+module_exit(aat2870_regulator_exit);
+
+MODULE_DESCRIPTION("AnalogicTech AAT2870 Regulator");
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Jin Park <jinyoungp@nvidia.com>");
diff --git a/drivers/regulator/core.c b/drivers/regulator/core.c
index d3e38790906e..d8e6a429e8ba 100644
--- a/drivers/regulator/core.c
+++ b/drivers/regulator/core.c
@@ -20,6 +20,7 @@
 #include <linux/debugfs.h>
 #include <linux/device.h>
 #include <linux/slab.h>
+#include <linux/async.h>
 #include <linux/err.h>
 #include <linux/mutex.h>
 #include <linux/suspend.h>
@@ -33,6 +34,8 @@
 
 #include "dummy.h"
 
+#define rdev_crit(rdev, fmt, ...)                                       \
+        pr_crit("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
 #define rdev_err(rdev, fmt, ...)                                        \
         pr_err("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
 #define rdev_warn(rdev, fmt, ...)                                       \
@@ -78,11 +81,13 @@ struct regulator {
         char *supply_name;
         struct device_attribute dev_attr;
         struct regulator_dev *rdev;
+#ifdef CONFIG_DEBUG_FS
+        struct dentry *debugfs;
+#endif
 };
 
 static int _regulator_is_enabled(struct regulator_dev *rdev);
-static int _regulator_disable(struct regulator_dev *rdev,
-                struct regulator_dev **supply_rdev_ptr);
+static int _regulator_disable(struct regulator_dev *rdev);
 static int _regulator_get_voltage(struct regulator_dev *rdev);
 static int _regulator_get_current_limit(struct regulator_dev *rdev);
 static unsigned int _regulator_get_mode(struct regulator_dev *rdev);
@@ -90,6 +95,9 @@ static void _notifier_call_chain(struct regulator_dev *rdev,
                                   unsigned long event, void *data);
 static int _regulator_do_set_voltage(struct regulator_dev *rdev,
                                      int min_uV, int max_uV);
+static struct regulator *create_regulator(struct regulator_dev *rdev,
+                                          struct device *dev,
+                                          const char *supply_name);
 
 static const char *rdev_get_name(struct regulator_dev *rdev)
 {
@@ -143,8 +151,11 @@ static int regulator_check_voltage(struct regulator_dev *rdev,
         if (*min_uV < rdev->constraints->min_uV)
                 *min_uV = rdev->constraints->min_uV;
 
-        if (*min_uV > *max_uV)
+        if (*min_uV > *max_uV) {
+                rdev_err(rdev, "unsupportable voltage range: %d-%duV\n",
+                         *min_uV, *max_uV);
                 return -EINVAL;
+        }
 
         return 0;
 }
@@ -197,8 +208,11 @@ static int regulator_check_current_limit(struct regulator_dev *rdev,
         if (*min_uA < rdev->constraints->min_uA)
                 *min_uA = rdev->constraints->min_uA;
 
-        if (*min_uA > *max_uA)
+        if (*min_uA > *max_uA) {
+                rdev_err(rdev, "unsupportable current range: %d-%duA\n",
+                         *min_uA, *max_uA);
                 return -EINVAL;
+        }
 
         return 0;
 }
@@ -213,6 +227,7 @@ static int regulator_mode_constrain(struct regulator_dev *rdev, int *mode)
         case REGULATOR_MODE_STANDBY:
                 break;
         default:
+                rdev_err(rdev, "invalid mode %x specified\n", *mode);
                 return -EINVAL;
         }
 
@@ -779,7 +794,6 @@ static int machine_constraints_voltage(struct regulator_dev *rdev,
                 if (ret < 0) {
                         rdev_err(rdev, "failed to apply %duV constraint\n",
                                  rdev->constraints->min_uV);
-                        rdev->constraints = NULL;
                         return ret;
                 }
         }
@@ -882,7 +896,6 @@ static int set_machine_constraints(struct regulator_dev *rdev,
                 ret = suspend_prepare(rdev, rdev->constraints->initial_state);
                 if (ret < 0) {
                         rdev_err(rdev, "failed to set suspend state\n");
-                        rdev->constraints = NULL;
                         goto out;
                 }
         }
@@ -909,13 +922,15 @@ static int set_machine_constraints(struct regulator_dev *rdev,
                 ret = ops->enable(rdev);
                 if (ret < 0) {
                         rdev_err(rdev, "failed to enable\n");
-                        rdev->constraints = NULL;
                         goto out;
                 }
         }
 
         print_constraints(rdev);
+        return 0;
 out:
+        kfree(rdev->constraints);
+        rdev->constraints = NULL;
         return ret;
 }
 
@@ -929,21 +944,20 @@ out:
  * core if it's child is enabled.
  */
 static int set_supply(struct regulator_dev *rdev,
-        struct regulator_dev *supply_rdev)
+                      struct regulator_dev *supply_rdev)
 {
         int err;
 
-        err = sysfs_create_link(&rdev->dev.kobj, &supply_rdev->dev.kobj,
-                                "supply");
-        if (err) {
-                rdev_err(rdev, "could not add device link %s err %d\n",
-                         supply_rdev->dev.kobj.name, err);
-                       goto out;
+        rdev_info(rdev, "supplied by %s\n", rdev_get_name(supply_rdev));
+
+        rdev->supply = create_regulator(supply_rdev, &rdev->dev, "SUPPLY");
+        if (IS_ERR(rdev->supply)) {
+                err = PTR_ERR(rdev->supply);
+                rdev->supply = NULL;
+                return err;
         }
-        rdev->supply = supply_rdev;
-        list_add(&rdev->slist, &supply_rdev->supply_list);
-out:
-        return err;
+
+        return 0;
 }
 
 /**
@@ -1032,7 +1046,7 @@ static void unset_regulator_supplies(struct regulator_dev *rdev)
         }
 }
 
-#define REG_STR_SIZE    32
+#define REG_STR_SIZE    64
 
 static struct regulator *create_regulator(struct regulator_dev *rdev,
                                           struct device *dev,
@@ -1052,8 +1066,9 @@ static struct regulator *create_regulator(struct regulator_dev *rdev,
 
         if (dev) {
                 /* create a 'requested_microamps_name' sysfs entry */
-                size = scnprintf(buf, REG_STR_SIZE, "microamps_requested_%s",
-                        supply_name);
+                size = scnprintf(buf, REG_STR_SIZE,
+                                 "microamps_requested_%s-%s",
+                                 dev_name(dev), supply_name);
                 if (size >= REG_STR_SIZE)
                         goto overflow_err;
 
@@ -1088,7 +1103,28 @@ static struct regulator *create_regulator(struct regulator_dev *rdev,
                                   dev->kobj.name, err);
                         goto link_name_err;
                 }
+        } else {
+                regulator->supply_name = kstrdup(supply_name, GFP_KERNEL);
+                if (regulator->supply_name == NULL)
+                        goto attr_err;
+        }
+
+#ifdef CONFIG_DEBUG_FS
+        regulator->debugfs = debugfs_create_dir(regulator->supply_name,
+                                                rdev->debugfs);
+        if (IS_ERR_OR_NULL(regulator->debugfs)) {
+                rdev_warn(rdev, "Failed to create debugfs directory\n");
+                regulator->debugfs = NULL;
+        } else {
+                debugfs_create_u32("uA_load", 0444, regulator->debugfs,
+                                   &regulator->uA_load);
+                debugfs_create_u32("min_uV", 0444, regulator->debugfs,
+                                   &regulator->min_uV);
+                debugfs_create_u32("max_uV", 0444, regulator->debugfs,
+                                   &regulator->max_uV);
         }
+#endif
+
         mutex_unlock(&rdev->mutex);
         return regulator;
 link_name_err:
@@ -1267,13 +1303,17 @@ void regulator_put(struct regulator *regulator)
         mutex_lock(&regulator_list_mutex);
         rdev = regulator->rdev;
 
+#ifdef CONFIG_DEBUG_FS
+        debugfs_remove_recursive(regulator->debugfs);
+#endif
+
         /* remove any sysfs entries */
         if (regulator->dev) {
                 sysfs_remove_link(&rdev->dev.kobj, regulator->supply_name);
-                kfree(regulator->supply_name);
                 device_remove_file(regulator->dev, &regulator->dev_attr);
                 kfree(regulator->dev_attr.attr.name);
         }
+        kfree(regulator->supply_name);
         list_del(&regulator->list);
         kfree(regulator);
 
@@ -1301,19 +1341,6 @@ static int _regulator_enable(struct regulator_dev *rdev)
 {
         int ret, delay;
 
-        if (rdev->use_count == 0) {
-                /* do we need to enable the supply regulator first */
-                if (rdev->supply) {
-                        mutex_lock(&rdev->supply->mutex);
-                        ret = _regulator_enable(rdev->supply);
-                        mutex_unlock(&rdev->supply->mutex);
-                        if (ret < 0) {
-                                rdev_err(rdev, "failed to enable: %d\n", ret);
-                                return ret;
-                        }
-                }
-        }
-
         /* check voltage and requested load before enabling */
         if (rdev->constraints &&
             (rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_DRMS))
@@ -1388,19 +1415,27 @@ int regulator_enable(struct regulator *regulator)
         struct regulator_dev *rdev = regulator->rdev;
         int ret = 0;
 
+        if (rdev->supply) {
+                ret = regulator_enable(rdev->supply);
+                if (ret != 0)
+                        return ret;
+        }
+
         mutex_lock(&rdev->mutex);
         ret = _regulator_enable(rdev);
         mutex_unlock(&rdev->mutex);
+
+        if (ret != 0)
+                regulator_disable(rdev->supply);
+
         return ret;
 }
 EXPORT_SYMBOL_GPL(regulator_enable);
 
 /* locks held by regulator_disable() */
-static int _regulator_disable(struct regulator_dev *rdev,
-                struct regulator_dev **supply_rdev_ptr)
+static int _regulator_disable(struct regulator_dev *rdev)
 {
         int ret = 0;
-        *supply_rdev_ptr = NULL;
 
         if (WARN(rdev->use_count <= 0,
                  "unbalanced disables for %s\n", rdev_get_name(rdev)))
@@ -1427,9 +1462,6 @@ static int _regulator_disable(struct regulator_dev *rdev,
                                              NULL);
                 }
 
-                /* decrease our supplies ref count and disable if required */
-                *supply_rdev_ptr = rdev->supply;
-
                 rdev->use_count = 0;
         } else if (rdev->use_count > 1) {
 
@@ -1440,6 +1472,7 @@ static int _regulator_disable(struct regulator_dev *rdev,
 
                 rdev->use_count--;
         }
+
         return ret;
 }
 
@@ -1458,29 +1491,21 @@ static int _regulator_disable(struct regulator_dev *rdev,
 int regulator_disable(struct regulator *regulator)
 {
         struct regulator_dev *rdev = regulator->rdev;
-        struct regulator_dev *supply_rdev = NULL;
         int ret = 0;
 
         mutex_lock(&rdev->mutex);
-        ret = _regulator_disable(rdev, &supply_rdev);
+        ret = _regulator_disable(rdev);
         mutex_unlock(&rdev->mutex);
 
-        /* decrease our supplies ref count and disable if required */
-        while (supply_rdev != NULL) {
-                rdev = supply_rdev;
-
-                mutex_lock(&rdev->mutex);
-                _regulator_disable(rdev, &supply_rdev);
-                mutex_unlock(&rdev->mutex);
-        }
+        if (ret == 0 && rdev->supply)
+                regulator_disable(rdev->supply);
 
         return ret;
 }
 EXPORT_SYMBOL_GPL(regulator_disable);
 
 /* locks held by regulator_force_disable() */
-static int _regulator_force_disable(struct regulator_dev *rdev,
-                struct regulator_dev **supply_rdev_ptr)
+static int _regulator_force_disable(struct regulator_dev *rdev)
 {
         int ret = 0;
 
@@ -1497,10 +1522,6 @@ static int _regulator_force_disable(struct regulator_dev *rdev,
                         REGULATOR_EVENT_DISABLE, NULL);
         }
 
-        /* decrease our supplies ref count and disable if required */
-        *supply_rdev_ptr = rdev->supply;
-
-        rdev->use_count = 0;
         return ret;
 }
 
@@ -1516,16 +1537,16 @@ static int _regulator_force_disable(struct regulator_dev *rdev,
 int regulator_force_disable(struct regulator *regulator)
 {
         struct regulator_dev *rdev = regulator->rdev;
-        struct regulator_dev *supply_rdev = NULL;
         int ret;
 
         mutex_lock(&rdev->mutex);
         regulator->uA_load = 0;
-        ret = _regulator_force_disable(rdev, &supply_rdev);
+        ret = _regulator_force_disable(regulator->rdev);
         mutex_unlock(&rdev->mutex);
 
-        if (supply_rdev)
-                regulator_disable(get_device_regulator(rdev_get_dev(supply_rdev)));
+        if (rdev->supply)
+                while (rdev->open_count--)
+                        regulator_disable(rdev->supply);
 
         return ret;
 }
@@ -2136,7 +2157,7 @@ int regulator_set_optimum_mode(struct regulator *regulator, int uA_load)
         /* get input voltage */
         input_uV = 0;
         if (rdev->supply)
-                input_uV = _regulator_get_voltage(rdev->supply);
+                input_uV = regulator_get_voltage(rdev->supply);
         if (input_uV <= 0)
                 input_uV = rdev->constraints->input_uV;
         if (input_uV <= 0) {
@@ -2206,17 +2227,8 @@ EXPORT_SYMBOL_GPL(regulator_unregister_notifier);
 static void _notifier_call_chain(struct regulator_dev *rdev,
                                   unsigned long event, void *data)
 {
-        struct regulator_dev *_rdev;
-
         /* call rdev chain first */
         blocking_notifier_call_chain(&rdev->notifier, event, NULL);
-
-        /* now notify regulator we supply */
-        list_for_each_entry(_rdev, &rdev->supply_list, slist) {
-                mutex_lock(&_rdev->mutex);
-                _notifier_call_chain(_rdev, event, data);
-                mutex_unlock(&_rdev->mutex);
-        }
 }
 
 /**
@@ -2264,6 +2276,13 @@ err:
 }
 EXPORT_SYMBOL_GPL(regulator_bulk_get);
 
+static void regulator_bulk_enable_async(void *data, async_cookie_t cookie)
+{
+        struct regulator_bulk_data *bulk = data;
+
+        bulk->ret = regulator_enable(bulk->consumer);
+}
+
 /**
  * regulator_bulk_enable - enable multiple regulator consumers
  *
@@ -2279,21 +2298,33 @@ EXPORT_SYMBOL_GPL(regulator_bulk_get);
 int regulator_bulk_enable(int num_consumers,
                           struct regulator_bulk_data *consumers)
 {
+        LIST_HEAD(async_domain);
         int i;
-        int ret;
+        int ret = 0;
+
+        for (i = 0; i < num_consumers; i++)
+                async_schedule_domain(regulator_bulk_enable_async,
+                                      &consumers[i], &async_domain);
+
+        async_synchronize_full_domain(&async_domain);
 
+        /* If any consumer failed we need to unwind any that succeeded */
         for (i = 0; i < num_consumers; i++) {
-                ret = regulator_enable(consumers[i].consumer);
-                if (ret != 0)
+                if (consumers[i].ret != 0) {
+                        ret = consumers[i].ret;
                         goto err;
+                }
         }
 
         return 0;
 
 err:
-        pr_err("Failed to enable %s: %d\n", consumers[i].supply, ret);
-        for (--i; i >= 0; --i)
-                regulator_disable(consumers[i].consumer);
+        for (i = 0; i < num_consumers; i++)
+                if (consumers[i].ret == 0)
+                        regulator_disable(consumers[i].consumer);
+                else
+                        pr_err("Failed to enable %s: %d\n",
+                               consumers[i].supply, consumers[i].ret);
 
         return ret;
 }
@@ -2589,9 +2620,7 @@ struct regulator_dev *regulator_register(struct regulator_desc *regulator_desc,
         rdev->owner = regulator_desc->owner;
         rdev->desc = regulator_desc;
         INIT_LIST_HEAD(&rdev->consumer_list);
-        INIT_LIST_HEAD(&rdev->supply_list);
         INIT_LIST_HEAD(&rdev->list);
-        INIT_LIST_HEAD(&rdev->slist);
         BLOCKING_INIT_NOTIFIER_HEAD(&rdev->notifier);
 
         /* preform any regulator specific init */
@@ -2672,6 +2701,7 @@ unset_supplies:
         unset_regulator_supplies(rdev);
 
 scrub:
+        kfree(rdev->constraints);
         device_unregister(&rdev->dev);
         /* device core frees rdev */
         rdev = ERR_PTR(ret);
@@ -2703,7 +2733,7 @@ void regulator_unregister(struct regulator_dev *rdev)
         unset_regulator_supplies(rdev);
         list_del(&rdev->list);
         if (rdev->supply)
-                sysfs_remove_link(&rdev->dev.kobj, "supply");
+                regulator_put(rdev->supply);
         device_unregister(&rdev->dev);
         kfree(rdev->constraints);
         mutex_unlock(&regulator_list_mutex);
diff --git a/drivers/regulator/dummy.c b/drivers/regulator/dummy.c
index c7410bde7b5d..f6ef6694ab98 100644
--- a/drivers/regulator/dummy.c
+++ b/drivers/regulator/dummy.c
@@ -36,6 +36,29 @@ static struct regulator_desc dummy_desc = {
         .ops = &dummy_ops,
 };
 
+static int __devinit dummy_regulator_probe(struct platform_device *pdev)
+{
+        int ret;
+
+        dummy_regulator_rdev = regulator_register(&dummy_desc, NULL,
+                                                  &dummy_initdata, NULL);
+        if (IS_ERR(dummy_regulator_rdev)) {
+                ret = PTR_ERR(dummy_regulator_rdev);
+                pr_err("Failed to register regulator: %d\n", ret);
+                return ret;
+        }
+
+        return 0;
+}
+
+static struct platform_driver dummy_regulator_driver = {
+        .probe          = dummy_regulator_probe,
+        .driver         = {
+                .name           = "reg-dummy",
+                .owner          = THIS_MODULE,
+        },
+};
+
 static struct platform_device *dummy_pdev;
 
 void __init regulator_dummy_init(void)
@@ -55,12 +78,9 @@ void __init regulator_dummy_init(void)
                 return;
         }
 
-        dummy_regulator_rdev = regulator_register(&dummy_desc, NULL,
-                                                  &dummy_initdata, NULL);
-        if (IS_ERR(dummy_regulator_rdev)) {
-                ret = PTR_ERR(dummy_regulator_rdev);
-                pr_err("Failed to register regulator: %d\n", ret);
+        ret = platform_driver_register(&dummy_regulator_driver);
+        if (ret != 0) {
+                pr_err("Failed to register dummy regulator driver: %d\n", ret);
                 platform_device_unregister(dummy_pdev);
-                return;
         }
 }
diff --git a/drivers/regulator/tps65910-regulator.c b/drivers/regulator/tps65910-regulator.c
index 55dd4e6650db..66d2d60b436a 100644
--- a/drivers/regulator/tps65910-regulator.c
+++ b/drivers/regulator/tps65910-regulator.c
@@ -49,7 +49,6 @@
 #define TPS65911_REG_LDO7               11
 #define TPS65911_REG_LDO8               12
 
-#define TPS65910_NUM_REGULATOR          13
 #define TPS65910_SUPPLY_STATE_ENABLED   0x1
 
 /* supported VIO voltages in milivolts */
@@ -264,11 +263,12 @@ static struct tps_info tps65911_regs[] = {
 };
 
 struct tps65910_reg {
-        struct regulator_desc desc[TPS65910_NUM_REGULATOR];
+        struct regulator_desc *desc;
         struct tps65910 *mfd;
-        struct regulator_dev *rdev[TPS65910_NUM_REGULATOR];
-        struct tps_info *info[TPS65910_NUM_REGULATOR];
+        struct regulator_dev **rdev;
+        struct tps_info **info;
         struct mutex mutex;
+        int num_regulators;
         int mode;
         int  (*get_ctrl_reg)(int);
 };
@@ -759,8 +759,13 @@ static int tps65910_list_voltage_dcdc(struct regulator_dev *dev,
                 mult = (selector / VDD1_2_NUM_VOLTS) + 1;
                 volt = VDD1_2_MIN_VOLT +
                                 (selector % VDD1_2_NUM_VOLTS) * VDD1_2_OFFSET;
+                break;
         case TPS65911_REG_VDDCTRL:
                 volt = VDDCTRL_MIN_VOLT + (selector * VDDCTRL_OFFSET);
+                break;
+        default:
+                BUG();
+                return -EINVAL;
         }
 
         return  volt * 100 * mult;
@@ -897,16 +902,42 @@ static __devinit int tps65910_probe(struct platform_device *pdev)
         switch(tps65910_chip_id(tps65910)) {
         case TPS65910:
                 pmic->get_ctrl_reg = &tps65910_get_ctrl_register;
+                pmic->num_regulators = ARRAY_SIZE(tps65910_regs);
                 info = tps65910_regs;
+                break;
         case TPS65911:
                 pmic->get_ctrl_reg = &tps65911_get_ctrl_register;
+                pmic->num_regulators = ARRAY_SIZE(tps65911_regs);
                 info = tps65911_regs;
+                break;
         default:
                 pr_err("Invalid tps chip version\n");
+                kfree(pmic);
                 return -ENODEV;
         }
 
-        for (i = 0; i < TPS65910_NUM_REGULATOR; i++, info++, reg_data++) {
+        pmic->desc = kcalloc(pmic->num_regulators,
+                        sizeof(struct regulator_desc), GFP_KERNEL);
+        if (!pmic->desc) {
+                err = -ENOMEM;
+                goto err_free_pmic;
+        }
+
+        pmic->info = kcalloc(pmic->num_regulators,
+                        sizeof(struct tps_info *), GFP_KERNEL);
+        if (!pmic->info) {
+                err = -ENOMEM;
+                goto err_free_desc;
+        }
+
+        pmic->rdev = kcalloc(pmic->num_regulators,
+                        sizeof(struct regulator_dev *), GFP_KERNEL);
+        if (!pmic->rdev) {
+                err = -ENOMEM;
+                goto err_free_info;
+        }
+
+        for (i = 0; i < pmic->num_regulators; i++, info++, reg_data++) {
                 /* Register the regulators */
                 pmic->info[i] = info;
 
@@ -938,7 +969,7 @@ static __devinit int tps65910_probe(struct platform_device *pdev)
                                 "failed to register %s regulator\n",
                                 pdev->name);
                         err = PTR_ERR(rdev);
-                        goto err;
+                        goto err_unregister_regulator;
                 }
 
                 /* Save regulator for cleanup */
@@ -946,23 +977,31 @@ static __devinit int tps65910_probe(struct platform_device *pdev)
         }
         return 0;
 
-err:
+err_unregister_regulator:
         while (--i >= 0)
                 regulator_unregister(pmic->rdev[i]);
-
+        kfree(pmic->rdev);
+err_free_info:
+        kfree(pmic->info);
+err_free_desc:
+        kfree(pmic->desc);
+err_free_pmic:
         kfree(pmic);
         return err;
 }
 
 static int __devexit tps65910_remove(struct platform_device *pdev)
 {
-        struct tps65910_reg *tps65910_reg = platform_get_drvdata(pdev);
+        struct tps65910_reg *pmic = platform_get_drvdata(pdev);
         int i;
 
-        for (i = 0; i < TPS65910_NUM_REGULATOR; i++)
-                regulator_unregister(tps65910_reg->rdev[i]);
+        for (i = 0; i < pmic->num_regulators; i++)
+                regulator_unregister(pmic->rdev[i]);
 
-        kfree(tps65910_reg);
+        kfree(pmic->rdev);
+        kfree(pmic->info);
+        kfree(pmic->desc);
+        kfree(pmic);
         return 0;
 }
 
diff --git a/drivers/regulator/tps65912-regulator.c b/drivers/regulator/tps65912-regulator.c
new file mode 100644
index 000000000000..3a9313e00fac
--- /dev/null
+++ b/drivers/regulator/tps65912-regulator.c
@@ -0,0 +1,800 @@
+/*
+ * tps65912.c  --  TI tps65912
+ *
+ * Copyright 2011 Texas Instruments Inc.
+ *
+ * Author: Margarita Olaya Cabrera <magi@slimlogic.co.uk>
+ *
+ *  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 driver is based on wm8350 implementation.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/err.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/driver.h>
+#include <linux/regulator/machine.h>
+#include <linux/delay.h>
+#include <linux/slab.h>
+#include <linux/gpio.h>
+#include <linux/mfd/tps65912.h>
+
+/* DCDC's */
+#define TPS65912_REG_DCDC1      0
+#define TPS65912_REG_DCDC2      1
+#define TPS65912_REG_DCDC3      2
+#define TPS65912_REG_DCDC4      3
+
+/* LDOs */
+#define TPS65912_REG_LDO1       4
+#define TPS65912_REG_LDO2       5
+#define TPS65912_REG_LDO3       6
+#define TPS65912_REG_LDO4       7
+#define TPS65912_REG_LDO5       8
+#define TPS65912_REG_LDO6       9
+#define TPS65912_REG_LDO7       10
+#define TPS65912_REG_LDO8       11
+#define TPS65912_REG_LDO9       12
+#define TPS65912_REG_LDO10      13
+
+#define TPS65912_MAX_REG_ID     TPS65912_REG_LDO_10
+
+/* Number of step-down converters available */
+#define TPS65912_NUM_DCDC       4
+
+/* Number of LDO voltage regulators  available */
+#define TPS65912_NUM_LDO        10
+
+/* Number of total regulators available */
+#define TPS65912_NUM_REGULATOR          (TPS65912_NUM_DCDC + TPS65912_NUM_LDO)
+
+#define TPS65912_REG_ENABLED    0x80
+#define OP_SELREG_MASK          0x40
+#define OP_SELREG_SHIFT         6
+
+struct tps_info {
+        const char *name;
+};
+
+static struct tps_info tps65912_regs[] = {
+        {
+                .name = "DCDC1",
+        },
+        {
+                .name = "DCDC2",
+        },
+        {
+                .name = "DCDC3",
+        },
+        {
+                .name = "DCDC4",
+        },
+        {
+                .name = "LDO1",
+        },
+        {
+                .name = "LDO2",
+        },
+        {
+                .name = "LDO3",
+        },
+        {
+                .name = "LDO4",
+        },
+        {
+                .name = "LDO5",
+        },
+        {
+                .name = "LDO6",
+        },
+        {
+                .name = "LDO7",
+        },
+        {
+                .name = "LDO8",
+        },
+        {
+                .name = "LDO9",
+        },
+        {
+                .name = "LDO10",
+        },
+};
+
+struct tps65912_reg {
+        struct regulator_desc desc[TPS65912_NUM_REGULATOR];
+        struct tps65912 *mfd;
+        struct regulator_dev *rdev[TPS65912_NUM_REGULATOR];
+        struct tps_info *info[TPS65912_NUM_REGULATOR];
+        /* for read/write access */
+        struct mutex io_lock;
+        int mode;
+        int (*get_ctrl_reg)(int);
+        int dcdc1_range;
+        int dcdc2_range;
+        int dcdc3_range;
+        int dcdc4_range;
+        int pwm_mode_reg;
+        int eco_reg;
+};
+
+static int tps65912_get_range(struct tps65912_reg *pmic, int id)
+{
+        struct tps65912 *mfd = pmic->mfd;
+
+        if (id > TPS65912_REG_DCDC4)
+                return 0;
+
+        switch (id) {
+        case TPS65912_REG_DCDC1:
+                pmic->dcdc1_range = tps65912_reg_read(mfd,
+                                                        TPS65912_DCDC1_LIMIT);
+                if (pmic->dcdc1_range < 0)
+                        return pmic->dcdc1_range;
+                pmic->dcdc1_range = (pmic->dcdc1_range &
+                        DCDC_LIMIT_RANGE_MASK) >> DCDC_LIMIT_RANGE_SHIFT;
+                return pmic->dcdc1_range;
+        case TPS65912_REG_DCDC2:
+                pmic->dcdc2_range = tps65912_reg_read(mfd,
+                                                        TPS65912_DCDC2_LIMIT);
+                if (pmic->dcdc2_range < 0)
+                        return pmic->dcdc2_range;
+                pmic->dcdc2_range = (pmic->dcdc2_range &
+                        DCDC_LIMIT_RANGE_MASK) >> DCDC_LIMIT_RANGE_SHIFT;
+                return pmic->dcdc2_range;
+        case TPS65912_REG_DCDC3:
+                pmic->dcdc3_range = tps65912_reg_read(mfd,
+                                                        TPS65912_DCDC3_LIMIT);
+                if (pmic->dcdc3_range < 0)
+                        return pmic->dcdc3_range;
+                pmic->dcdc3_range = (pmic->dcdc3_range &
+                        DCDC_LIMIT_RANGE_MASK) >> DCDC_LIMIT_RANGE_SHIFT;
+                return pmic->dcdc3_range;
+        case TPS65912_REG_DCDC4:
+                pmic->dcdc4_range = tps65912_reg_read(mfd,
+                                                        TPS65912_DCDC4_LIMIT);
+                if (pmic->dcdc4_range < 0)
+                        return pmic->dcdc4_range;
+                pmic->dcdc4_range = (pmic->dcdc4_range &
+                        DCDC_LIMIT_RANGE_MASK) >> DCDC_LIMIT_RANGE_SHIFT;
+                return pmic->dcdc4_range;
+        default:
+                return 0;
+        }
+}
+
+static unsigned long tps65912_vsel_to_uv_range0(u8 vsel)
+{
+        unsigned long uv;
+
+        uv = ((vsel * 12500) + 500000);
+        return uv;
+}
+
+static unsigned long tps65912_vsel_to_uv_range1(u8 vsel)
+{
+        unsigned long uv;
+
+         uv = ((vsel * 12500) + 700000);
+        return uv;
+}
+
+static unsigned long tps65912_vsel_to_uv_range2(u8 vsel)
+{
+        unsigned long uv;
+
+        uv = ((vsel * 25000) + 500000);
+        return uv;
+}
+
+static unsigned long tps65912_vsel_to_uv_range3(u8 vsel)
+{
+        unsigned long uv;
+
+        if (vsel == 0x3f)
+                uv = 3800000;
+        else
+                uv = ((vsel * 50000) + 500000);
+
+        return uv;
+}
+
+static unsigned long tps65912_vsel_to_uv_ldo(u8 vsel)
+{
+        unsigned long uv = 0;
+
+        if (vsel <= 32)
+                uv = ((vsel * 25000) + 800000);
+        else if (vsel > 32 && vsel <= 60)
+                uv = (((vsel - 32) * 50000) + 1600000);
+        else if (vsel > 60)
+                uv = (((vsel - 60) * 100000) + 3000000);
+
+        return uv;
+}
+
+static int tps65912_get_ctrl_register(int id)
+{
+        switch (id) {
+        case TPS65912_REG_DCDC1:
+                return TPS65912_DCDC1_AVS;
+        case TPS65912_REG_DCDC2:
+                return TPS65912_DCDC2_AVS;
+        case TPS65912_REG_DCDC3:
+                return TPS65912_DCDC3_AVS;
+        case TPS65912_REG_DCDC4:
+                return TPS65912_DCDC4_AVS;
+        case TPS65912_REG_LDO1:
+                return TPS65912_LDO1_AVS;
+        case TPS65912_REG_LDO2:
+                return TPS65912_LDO2_AVS;
+        case TPS65912_REG_LDO3:
+                return TPS65912_LDO3_AVS;
+        case TPS65912_REG_LDO4:
+                return TPS65912_LDO4_AVS;
+        case TPS65912_REG_LDO5:
+                return TPS65912_LDO5;
+        case TPS65912_REG_LDO6:
+                return TPS65912_LDO6;
+        case TPS65912_REG_LDO7:
+                return TPS65912_LDO7;
+        case TPS65912_REG_LDO8:
+                return TPS65912_LDO8;
+        case TPS65912_REG_LDO9:
+                return TPS65912_LDO9;
+        case TPS65912_REG_LDO10:
+                return TPS65912_LDO10;
+        default:
+                return -EINVAL;
+        }
+}
+
+static int tps65912_get_dcdc_sel_register(struct tps65912_reg *pmic, int id)
+{
+        struct tps65912 *mfd = pmic->mfd;
+        int opvsel = 0, sr = 0;
+        u8 reg = 0;
+
+        if (id < TPS65912_REG_DCDC1 || id > TPS65912_REG_DCDC4)
+                return -EINVAL;
+
+        switch (id) {
+        case TPS65912_REG_DCDC1:
+                opvsel = tps65912_reg_read(mfd, TPS65912_DCDC1_OP);
+                sr = ((opvsel & OP_SELREG_MASK) >> OP_SELREG_SHIFT);
+                if (sr)
+                        reg = TPS65912_DCDC1_AVS;
+                else
+                        reg = TPS65912_DCDC1_OP;
+                break;
+        case TPS65912_REG_DCDC2:
+                opvsel = tps65912_reg_read(mfd, TPS65912_DCDC2_OP);
+                sr = (opvsel & OP_SELREG_MASK) >> OP_SELREG_SHIFT;
+                if (sr)
+                        reg = TPS65912_DCDC2_AVS;
+                else
+                        reg = TPS65912_DCDC2_OP;
+                break;
+        case TPS65912_REG_DCDC3:
+                opvsel = tps65912_reg_read(mfd, TPS65912_DCDC3_OP);
+                sr = (opvsel & OP_SELREG_MASK) >> OP_SELREG_SHIFT;
+                if (sr)
+                        reg = TPS65912_DCDC3_AVS;
+                else
+                        reg = TPS65912_DCDC3_OP;
+                break;
+        case TPS65912_REG_DCDC4:
+                opvsel = tps65912_reg_read(mfd, TPS65912_DCDC4_OP);
+                sr = (opvsel & OP_SELREG_MASK) >> OP_SELREG_SHIFT;
+                if (sr)
+                        reg = TPS65912_DCDC4_AVS;
+                else
+                        reg = TPS65912_DCDC4_OP;
+                break;
+        }
+        return reg;
+}
+
+static int tps65912_get_ldo_sel_register(struct tps65912_reg *pmic, int id)
+{
+        struct tps65912 *mfd = pmic->mfd;
+        int opvsel = 0, sr = 0;
+        u8 reg = 0;
+
+        if (id < TPS65912_REG_LDO1 || id > TPS65912_REG_LDO10)
+                return -EINVAL;
+
+        switch (id) {
+        case TPS65912_REG_LDO1:
+                opvsel = tps65912_reg_read(mfd, TPS65912_LDO1_OP);
+                sr = (opvsel & OP_SELREG_MASK) >> OP_SELREG_SHIFT;
+                if (sr)
+                        reg = TPS65912_LDO1_AVS;
+                else
+                        reg = TPS65912_LDO1_OP;
+                break;
+        case TPS65912_REG_LDO2:
+                opvsel = tps65912_reg_read(mfd, TPS65912_LDO2_OP);
+                sr = (opvsel & OP_SELREG_MASK) >> OP_SELREG_SHIFT;
+                if (sr)
+                        reg = TPS65912_LDO2_AVS;
+                else
+                        reg = TPS65912_LDO2_OP;
+                break;
+        case TPS65912_REG_LDO3:
+                opvsel = tps65912_reg_read(mfd, TPS65912_LDO3_OP);
+                sr = (opvsel & OP_SELREG_MASK) >> OP_SELREG_SHIFT;
+                if (sr)
+                        reg = TPS65912_LDO3_AVS;
+                else
+                        reg = TPS65912_LDO3_OP;
+                break;
+        case TPS65912_REG_LDO4:
+                opvsel = tps65912_reg_read(mfd, TPS65912_LDO4_OP);
+                sr = (opvsel & OP_SELREG_MASK) >> OP_SELREG_SHIFT;
+                if (sr)
+                        reg = TPS65912_LDO4_AVS;
+                else
+                        reg = TPS65912_LDO4_OP;
+                break;
+        case TPS65912_REG_LDO5:
+                reg = TPS65912_LDO5;
+                break;
+        case TPS65912_REG_LDO6:
+                reg = TPS65912_LDO6;
+                break;
+        case TPS65912_REG_LDO7:
+                reg = TPS65912_LDO7;
+                break;
+        case TPS65912_REG_LDO8:
+                reg = TPS65912_LDO8;
+                break;
+        case TPS65912_REG_LDO9:
+                reg = TPS65912_LDO9;
+                break;
+        case TPS65912_REG_LDO10:
+                reg = TPS65912_LDO10;
+                break;
+        }
+
+        return reg;
+}
+
+static int tps65912_get_mode_regiters(struct tps65912_reg *pmic, int id)
+{
+        switch (id) {
+        case TPS65912_REG_DCDC1:
+                pmic->pwm_mode_reg = TPS65912_DCDC1_CTRL;
+                pmic->eco_reg = TPS65912_DCDC1_AVS;
+                break;
+        case TPS65912_REG_DCDC2:
+                pmic->pwm_mode_reg = TPS65912_DCDC2_CTRL;
+                pmic->eco_reg = TPS65912_DCDC2_AVS;
+                break;
+        case TPS65912_REG_DCDC3:
+                pmic->pwm_mode_reg = TPS65912_DCDC3_CTRL;
+                pmic->eco_reg = TPS65912_DCDC3_AVS;
+                break;
+        case TPS65912_REG_DCDC4:
+                pmic->pwm_mode_reg = TPS65912_DCDC4_CTRL;
+                pmic->eco_reg = TPS65912_DCDC4_AVS;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int tps65912_reg_is_enabled(struct regulator_dev *dev)
+{
+        struct tps65912_reg *pmic = rdev_get_drvdata(dev);
+        struct tps65912 *mfd = pmic->mfd;
+        int reg, value, id = rdev_get_id(dev);
+
+        if (id < TPS65912_REG_DCDC1 || id > TPS65912_REG_LDO10)
+                return -EINVAL;
+
+        reg = pmic->get_ctrl_reg(id);
+        if (reg < 0)
+                return reg;
+
+        value = tps65912_reg_read(mfd, reg);
+        if (value < 0)
+                return value;
+
+        return value & TPS65912_REG_ENABLED;
+}
+
+static int tps65912_reg_enable(struct regulator_dev *dev)
+{
+        struct tps65912_reg *pmic = rdev_get_drvdata(dev);
+        struct tps65912 *mfd = pmic->mfd;
+        int id = rdev_get_id(dev);
+        int reg;
+
+        if (id < TPS65912_REG_DCDC1 || id > TPS65912_REG_LDO10)
+                return -EINVAL;
+
+        reg = pmic->get_ctrl_reg(id);
+        if (reg < 0)
+                return reg;
+
+        return tps65912_set_bits(mfd, reg, TPS65912_REG_ENABLED);
+}
+
+static int tps65912_reg_disable(struct regulator_dev *dev)
+{
+        struct tps65912_reg *pmic = rdev_get_drvdata(dev);
+        struct tps65912 *mfd = pmic->mfd;
+        int id = rdev_get_id(dev), reg;
+
+        reg = pmic->get_ctrl_reg(id);
+        if (reg < 0)
+                return reg;
+
+        return tps65912_clear_bits(mfd, reg, TPS65912_REG_ENABLED);
+}
+
+static int tps65912_set_mode(struct regulator_dev *dev, unsigned int mode)
+{
+        struct tps65912_reg *pmic = rdev_get_drvdata(dev);
+        struct tps65912 *mfd = pmic->mfd;
+        int pwm_mode, eco, id = rdev_get_id(dev);
+
+        tps65912_get_mode_regiters(pmic, id);
+
+        pwm_mode = tps65912_reg_read(mfd, pmic->pwm_mode_reg);
+        eco = tps65912_reg_read(mfd, pmic->eco_reg);
+
+        pwm_mode &= DCDCCTRL_DCDC_MODE_MASK;
+        eco &= DCDC_AVS_ECO_MASK;
+
+        switch (mode) {
+        case REGULATOR_MODE_FAST:
+                /* Verify if mode alredy set */
+                if (pwm_mode && !eco)
+                        break;
+                tps65912_set_bits(mfd, pmic->pwm_mode_reg, DCDCCTRL_DCDC_MODE_MASK);
+                tps65912_clear_bits(mfd, pmic->eco_reg, DCDC_AVS_ECO_MASK);
+                break;
+        case REGULATOR_MODE_NORMAL:
+        case REGULATOR_MODE_IDLE:
+                if (!pwm_mode && !eco)
+                        break;
+                tps65912_clear_bits(mfd, pmic->pwm_mode_reg, DCDCCTRL_DCDC_MODE_MASK);
+                tps65912_clear_bits(mfd, pmic->eco_reg, DCDC_AVS_ECO_MASK);
+                break;
+        case REGULATOR_MODE_STANDBY:
+                if (!pwm_mode && eco)
+                        break;
+                tps65912_clear_bits(mfd, pmic->pwm_mode_reg, DCDCCTRL_DCDC_MODE_MASK);
+                tps65912_set_bits(mfd, pmic->eco_reg, DCDC_AVS_ECO_MASK);
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static unsigned int tps65912_get_mode(struct regulator_dev *dev)
+{
+        struct tps65912_reg *pmic = rdev_get_drvdata(dev);
+        struct tps65912 *mfd = pmic->mfd;
+        int pwm_mode, eco, mode = 0, id = rdev_get_id(dev);
+
+        tps65912_get_mode_regiters(pmic, id);
+
+        pwm_mode = tps65912_reg_read(mfd, pmic->pwm_mode_reg);
+        eco = tps65912_reg_read(mfd, pmic->eco_reg);
+
+        pwm_mode &= DCDCCTRL_DCDC_MODE_MASK;
+        eco &= DCDC_AVS_ECO_MASK;
+
+        if (pwm_mode && !eco)
+                mode = REGULATOR_MODE_FAST;
+        else if (!pwm_mode && !eco)
+                mode = REGULATOR_MODE_NORMAL;
+        else if (!pwm_mode && eco)
+                mode = REGULATOR_MODE_STANDBY;
+
+        return mode;
+}
+
+static int tps65912_get_voltage_dcdc(struct regulator_dev *dev)
+{
+        struct tps65912_reg *pmic = rdev_get_drvdata(dev);
+        struct tps65912 *mfd = pmic->mfd;
+        int id = rdev_get_id(dev), voltage = 0, range;
+        int opvsel = 0, avsel = 0, sr, vsel;
+
+        switch (id) {
+        case TPS65912_REG_DCDC1:
+                opvsel = tps65912_reg_read(mfd, TPS65912_DCDC1_OP);
+                avsel = tps65912_reg_read(mfd, TPS65912_DCDC1_AVS);
+                range = pmic->dcdc1_range;
+                break;
+        case TPS65912_REG_DCDC2:
+                opvsel = tps65912_reg_read(mfd, TPS65912_DCDC2_OP);
+                avsel = tps65912_reg_read(mfd, TPS65912_DCDC2_AVS);
+                range = pmic->dcdc2_range;
+                break;
+        case TPS65912_REG_DCDC3:
+                opvsel = tps65912_reg_read(mfd, TPS65912_DCDC3_OP);
+                avsel = tps65912_reg_read(mfd, TPS65912_DCDC3_AVS);
+                range = pmic->dcdc3_range;
+                break;
+        case TPS65912_REG_DCDC4:
+                opvsel = tps65912_reg_read(mfd, TPS65912_DCDC4_OP);
+                avsel = tps65912_reg_read(mfd, TPS65912_DCDC4_AVS);
+                range = pmic->dcdc4_range;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        sr = (opvsel & OP_SELREG_MASK) >> OP_SELREG_SHIFT;
+        if (sr)
+                vsel = avsel;
+        else
+                vsel = opvsel;
+        vsel &= 0x3F;
+
+        switch (range) {
+        case 0:
+                /* 0.5 - 1.2875V in 12.5mV steps */
+                voltage = tps65912_vsel_to_uv_range0(vsel);
+                break;
+        case 1:
+                /* 0.7 - 1.4875V in 12.5mV steps */
+                voltage = tps65912_vsel_to_uv_range1(vsel);
+                break;
+        case 2:
+                /* 0.5 - 2.075V in 25mV steps */
+                voltage = tps65912_vsel_to_uv_range2(vsel);
+                break;
+        case 3:
+                /* 0.5 - 3.8V in 50mV steps */
+                voltage = tps65912_vsel_to_uv_range3(vsel);
+                break;
+        }
+        return voltage;
+}
+
+static int tps65912_set_voltage_dcdc(struct regulator_dev *dev,
+                                                unsigned selector)
+{
+        struct tps65912_reg *pmic = rdev_get_drvdata(dev);
+        struct tps65912 *mfd = pmic->mfd;
+        int id = rdev_get_id(dev);
+        int value;
+        u8 reg;
+
+        reg = tps65912_get_dcdc_sel_register(pmic, id);
+        value = tps65912_reg_read(mfd, reg);
+        value &= 0xC0;
+        return tps65912_reg_write(mfd, reg, selector | value);
+}
+
+static int tps65912_get_voltage_ldo(struct regulator_dev *dev)
+{
+        struct tps65912_reg *pmic = rdev_get_drvdata(dev);
+        struct tps65912 *mfd = pmic->mfd;
+        int id = rdev_get_id(dev);
+        int vsel = 0;
+        u8 reg;
+
+        reg = tps65912_get_ldo_sel_register(pmic, id);
+        vsel = tps65912_reg_read(mfd, reg);
+        vsel &= 0x3F;
+
+        return tps65912_vsel_to_uv_ldo(vsel);
+}
+
+static int tps65912_set_voltage_ldo(struct regulator_dev *dev,
+                                                unsigned selector)
+{
+        struct tps65912_reg *pmic = rdev_get_drvdata(dev);
+        struct tps65912 *mfd = pmic->mfd;
+        int id = rdev_get_id(dev), reg, value;
+
+        reg = tps65912_get_ldo_sel_register(pmic, id);
+        value = tps65912_reg_read(mfd, reg);
+        value &= 0xC0;
+        return tps65912_reg_write(mfd, reg, selector | value);
+}
+
+static int tps65912_list_voltage_dcdc(struct regulator_dev *dev,
+                                        unsigned selector)
+{
+        struct tps65912_reg *pmic = rdev_get_drvdata(dev);
+        int range, voltage = 0, id = rdev_get_id(dev);
+
+        switch (id) {
+        case TPS65912_REG_DCDC1:
+                range = pmic->dcdc1_range;
+                break;
+        case TPS65912_REG_DCDC2:
+                range = pmic->dcdc2_range;
+                break;
+        case TPS65912_REG_DCDC3:
+                range = pmic->dcdc3_range;
+                break;
+        case TPS65912_REG_DCDC4:
+                range = pmic->dcdc4_range;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        switch (range) {
+        case 0:
+                /* 0.5 - 1.2875V in 12.5mV steps */
+                voltage = tps65912_vsel_to_uv_range0(selector);
+                break;
+        case 1:
+                /* 0.7 - 1.4875V in 12.5mV steps */
+                voltage = tps65912_vsel_to_uv_range1(selector);
+                break;
+        case 2:
+                /* 0.5 - 2.075V in 25mV steps */
+                voltage = tps65912_vsel_to_uv_range2(selector);
+                break;
+        case 3:
+                /* 0.5 - 3.8V in 50mV steps */
+                voltage = tps65912_vsel_to_uv_range3(selector);
+                break;
+        }
+        return voltage;
+}
+
+static int tps65912_list_voltage_ldo(struct regulator_dev *dev,
+                                        unsigned selector)
+{
+        int ldo = rdev_get_id(dev);
+
+        if (ldo < TPS65912_REG_LDO1 || ldo > TPS65912_REG_LDO10)
+                return -EINVAL;
+
+        return tps65912_vsel_to_uv_ldo(selector);
+}
+
+/* Operations permitted on DCDCx */
+static struct regulator_ops tps65912_ops_dcdc = {
+        .is_enabled = tps65912_reg_is_enabled,
+        .enable = tps65912_reg_enable,
+        .disable = tps65912_reg_disable,
+        .set_mode = tps65912_set_mode,
+        .get_mode = tps65912_get_mode,
+        .get_voltage = tps65912_get_voltage_dcdc,
+        .set_voltage_sel = tps65912_set_voltage_dcdc,
+        .list_voltage = tps65912_list_voltage_dcdc,
+};
+
+/* Operations permitted on LDOx */
+static struct regulator_ops tps65912_ops_ldo = {
+        .is_enabled = tps65912_reg_is_enabled,
+        .enable = tps65912_reg_enable,
+        .disable = tps65912_reg_disable,
+        .get_voltage = tps65912_get_voltage_ldo,
+        .set_voltage_sel = tps65912_set_voltage_ldo,
+        .list_voltage = tps65912_list_voltage_ldo,
+};
+
+static __devinit int tps65912_probe(struct platform_device *pdev)
+{
+        struct tps65912 *tps65912 = dev_get_drvdata(pdev->dev.parent);
+        struct tps_info *info;
+        struct regulator_init_data *reg_data;
+        struct regulator_dev *rdev;
+        struct tps65912_reg *pmic;
+        struct tps65912_board *pmic_plat_data;
+        int i, err;
+
+        pmic_plat_data = dev_get_platdata(tps65912->dev);
+        if (!pmic_plat_data)
+                return -EINVAL;
+
+        reg_data = pmic_plat_data->tps65912_pmic_init_data;
+
+        pmic = kzalloc(sizeof(*pmic), GFP_KERNEL);
+        if (!pmic)
+                return -ENOMEM;
+
+        mutex_init(&pmic->io_lock);
+        pmic->mfd = tps65912;
+        platform_set_drvdata(pdev, pmic);
+
+        pmic->get_ctrl_reg = &tps65912_get_ctrl_register;
+        info = tps65912_regs;
+
+        for (i = 0; i < TPS65912_NUM_REGULATOR; i++, info++, reg_data++) {
+                int range = 0;
+                /* Register the regulators */
+                pmic->info[i] = info;
+
+                pmic->desc[i].name = info->name;
+                pmic->desc[i].id = i;
+                pmic->desc[i].n_voltages = 64;
+                pmic->desc[i].ops = (i > TPS65912_REG_DCDC4 ?
+                        &tps65912_ops_ldo : &tps65912_ops_dcdc);
+                pmic->desc[i].type = REGULATOR_VOLTAGE;
+                pmic->desc[i].owner = THIS_MODULE;
+                range = tps65912_get_range(pmic, i);
+                rdev = regulator_register(&pmic->desc[i],
+                                        tps65912->dev, reg_data, pmic);
+                if (IS_ERR(rdev)) {
+                        dev_err(tps65912->dev,
+                                "failed to register %s regulator\n",
+                                pdev->name);
+                        err = PTR_ERR(rdev);
+                        goto err;
+                }
+
+                /* Save regulator for cleanup */
+                pmic->rdev[i] = rdev;
+        }
+        return 0;
+
+err:
+        while (--i >= 0)
+                regulator_unregister(pmic->rdev[i]);
+
+        kfree(pmic);
+        return err;
+}
+
+static int __devexit tps65912_remove(struct platform_device *pdev)
+{
+        struct tps65912_reg *tps65912_reg = platform_get_drvdata(pdev);
+        int i;
+
+        for (i = 0; i < TPS65912_NUM_REGULATOR; i++)
+                regulator_unregister(tps65912_reg->rdev[i]);
+
+        kfree(tps65912_reg);
+        return 0;
+}
+
+static struct platform_driver tps65912_driver = {
+        .driver = {
+                .name = "tps65912-pmic",
+                .owner = THIS_MODULE,
+        },
+        .probe = tps65912_probe,
+        .remove = __devexit_p(tps65912_remove),
+};
+
+/**
+ * tps65912_init
+ *
+ * Module init function
+ */
+static int __init tps65912_init(void)
+{
+        return platform_driver_register(&tps65912_driver);
+}
+subsys_initcall(tps65912_init);
+
+/**
+ * tps65912_cleanup
+ *
+ * Module exit function
+ */
+static void __exit tps65912_cleanup(void)
+{
+        platform_driver_unregister(&tps65912_driver);
+}
+module_exit(tps65912_cleanup);
+
+MODULE_AUTHOR("Margarita Olaya Cabrera <magi@slimlogic.co.uk>");
+MODULE_DESCRIPTION("TPS65912 voltage regulator driver");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:tps65912-pmic");
diff --git a/drivers/regulator/twl-regulator.c b/drivers/regulator/twl-regulator.c
index 87fe0f75a56e..ee8747f4fa08 100644
--- a/drivers/regulator/twl-regulator.c
+++ b/drivers/regulator/twl-regulator.c
@@ -835,8 +835,8 @@ static struct regulator_ops twlsmps_ops = {
                         remap_conf) \
                 TWL_FIXED_LDO(label, offset, mVolts, num, turnon_delay, \
                         remap_conf, TWL4030, twl4030fixed_ops)
-#define TWL6030_FIXED_LDO(label, offset, mVolts, num, turnon_delay) \
-                TWL_FIXED_LDO(label, offset, mVolts, num, turnon_delay, \
+#define TWL6030_FIXED_LDO(label, offset, mVolts, turnon_delay) \
+                TWL_FIXED_LDO(label, offset, mVolts, 0x0, turnon_delay, \
                         0x0, TWL6030, twl6030fixed_ops)
 
 #define TWL4030_ADJUSTABLE_LDO(label, offset, num, turnon_delay, remap_conf) { \
@@ -856,24 +856,22 @@ static struct regulator_ops twlsmps_ops = {
                 }, \
         }
 
-#define TWL6030_ADJUSTABLE_LDO(label, offset, min_mVolts, max_mVolts, num) { \
+#define TWL6030_ADJUSTABLE_LDO(label, offset, min_mVolts, max_mVolts) { \
         .base = offset, \
-        .id = num, \
         .min_mV = min_mVolts, \
         .max_mV = max_mVolts, \
         .desc = { \
                 .name = #label, \
                 .id = TWL6030_REG_##label, \
-                .n_voltages = (max_mVolts - min_mVolts)/100, \
+                .n_voltages = (max_mVolts - min_mVolts)/100 + 1, \
                 .ops = &twl6030ldo_ops, \
                 .type = REGULATOR_VOLTAGE, \
                 .owner = THIS_MODULE, \
                 }, \
         }
 
-#define TWL6025_ADJUSTABLE_LDO(label, offset, min_mVolts, max_mVolts, num) { \
+#define TWL6025_ADJUSTABLE_LDO(label, offset, min_mVolts, max_mVolts) { \
         .base = offset, \
-        .id = num, \
         .min_mV = min_mVolts, \
         .max_mV = max_mVolts, \
         .desc = { \
@@ -903,9 +901,8 @@ static struct regulator_ops twlsmps_ops = {
                 }, \
         }
 
-#define TWL6030_FIXED_RESOURCE(label, offset, num, turnon_delay) { \
+#define TWL6030_FIXED_RESOURCE(label, offset, turnon_delay) { \
         .base = offset, \
-        .id = num, \
         .delay = turnon_delay, \
         .desc = { \
                 .name = #label, \
@@ -916,9 +913,8 @@ static struct regulator_ops twlsmps_ops = {
                 }, \
         }
 
-#define TWL6025_ADJUSTABLE_SMPS(label, offset, num) { \
+#define TWL6025_ADJUSTABLE_SMPS(label, offset) { \
         .base = offset, \
-        .id = num, \
         .min_mV = 600, \
         .max_mV = 2100, \
         .desc = { \
@@ -961,32 +957,32 @@ static struct twlreg_info twl_regs[] = {
         /* 6030 REG with base as PMC Slave Misc : 0x0030 */
         /* Turnon-delay and remap configuration values for 6030 are not
            verified since the specification is not public */
-        TWL6030_ADJUSTABLE_LDO(VAUX1_6030, 0x54, 1000, 3300, 1),
-        TWL6030_ADJUSTABLE_LDO(VAUX2_6030, 0x58, 1000, 3300, 2),
-        TWL6030_ADJUSTABLE_LDO(VAUX3_6030, 0x5c, 1000, 3300, 3),
-        TWL6030_ADJUSTABLE_LDO(VMMC, 0x68, 1000, 3300, 4),
-        TWL6030_ADJUSTABLE_LDO(VPP, 0x6c, 1000, 3300, 5),
-        TWL6030_ADJUSTABLE_LDO(VUSIM, 0x74, 1000, 3300, 7),
-        TWL6030_FIXED_LDO(VANA, 0x50, 2100, 15, 0),
-        TWL6030_FIXED_LDO(VCXIO, 0x60, 1800, 16, 0),
-        TWL6030_FIXED_LDO(VDAC, 0x64, 1800, 17, 0),
-        TWL6030_FIXED_LDO(VUSB, 0x70, 3300, 18, 0),
-        TWL6030_FIXED_RESOURCE(CLK32KG, 0x8C, 48, 0),
+        TWL6030_ADJUSTABLE_LDO(VAUX1_6030, 0x54, 1000, 3300),
+        TWL6030_ADJUSTABLE_LDO(VAUX2_6030, 0x58, 1000, 3300),
+        TWL6030_ADJUSTABLE_LDO(VAUX3_6030, 0x5c, 1000, 3300),
+        TWL6030_ADJUSTABLE_LDO(VMMC, 0x68, 1000, 3300),
+        TWL6030_ADJUSTABLE_LDO(VPP, 0x6c, 1000, 3300),
+        TWL6030_ADJUSTABLE_LDO(VUSIM, 0x74, 1000, 3300),
+        TWL6030_FIXED_LDO(VANA, 0x50, 2100, 0),
+        TWL6030_FIXED_LDO(VCXIO, 0x60, 1800, 0),
+        TWL6030_FIXED_LDO(VDAC, 0x64, 1800, 0),
+        TWL6030_FIXED_LDO(VUSB, 0x70, 3300, 0),
+        TWL6030_FIXED_RESOURCE(CLK32KG, 0x8C, 0),
 
         /* 6025 are renamed compared to 6030 versions */
-        TWL6025_ADJUSTABLE_LDO(LDO2, 0x54, 1000, 3300, 1),
-        TWL6025_ADJUSTABLE_LDO(LDO4, 0x58, 1000, 3300, 2),
-        TWL6025_ADJUSTABLE_LDO(LDO3, 0x5c, 1000, 3300, 3),
-        TWL6025_ADJUSTABLE_LDO(LDO5, 0x68, 1000, 3300, 4),
-        TWL6025_ADJUSTABLE_LDO(LDO1, 0x6c, 1000, 3300, 5),
-        TWL6025_ADJUSTABLE_LDO(LDO7, 0x74, 1000, 3300, 7),
-        TWL6025_ADJUSTABLE_LDO(LDO6, 0x60, 1000, 3300, 16),
-        TWL6025_ADJUSTABLE_LDO(LDOLN, 0x64, 1000, 3300, 17),
-        TWL6025_ADJUSTABLE_LDO(LDOUSB, 0x70, 1000, 3300, 18),
-
-        TWL6025_ADJUSTABLE_SMPS(SMPS3, 0x34, 1),
-        TWL6025_ADJUSTABLE_SMPS(SMPS4, 0x10, 2),
-        TWL6025_ADJUSTABLE_SMPS(VIO, 0x16, 3),
+        TWL6025_ADJUSTABLE_LDO(LDO2, 0x54, 1000, 3300),
+        TWL6025_ADJUSTABLE_LDO(LDO4, 0x58, 1000, 3300),
+        TWL6025_ADJUSTABLE_LDO(LDO3, 0x5c, 1000, 3300),
+        TWL6025_ADJUSTABLE_LDO(LDO5, 0x68, 1000, 3300),
+        TWL6025_ADJUSTABLE_LDO(LDO1, 0x6c, 1000, 3300),
+        TWL6025_ADJUSTABLE_LDO(LDO7, 0x74, 1000, 3300),
+        TWL6025_ADJUSTABLE_LDO(LDO6, 0x60, 1000, 3300),
+        TWL6025_ADJUSTABLE_LDO(LDOLN, 0x64, 1000, 3300),
+        TWL6025_ADJUSTABLE_LDO(LDOUSB, 0x70, 1000, 3300),
+
+        TWL6025_ADJUSTABLE_SMPS(SMPS3, 0x34),
+        TWL6025_ADJUSTABLE_SMPS(SMPS4, 0x10),
+        TWL6025_ADJUSTABLE_SMPS(VIO, 0x16),
 };
 
 static u8 twl_get_smps_offset(void)
diff --git a/drivers/regulator/wm831x-dcdc.c b/drivers/regulator/wm831x-dcdc.c
index a0982e809851..bd3531d8b2ac 100644
--- a/drivers/regulator/wm831x-dcdc.c
+++ b/drivers/regulator/wm831x-dcdc.c
@@ -267,23 +267,6 @@ static int wm831x_buckv_select_min_voltage(struct regulator_dev *rdev,
         return vsel;
 }
 
-static int wm831x_buckv_select_max_voltage(struct regulator_dev *rdev,
-                                           int min_uV, int max_uV)
-{
-        u16 vsel;
-
-        if (max_uV < 600000 || max_uV > 1800000)
-                return -EINVAL;
-
-        vsel = ((max_uV - 600000) / 12500) + 8;
-
-        if (wm831x_buckv_list_voltage(rdev, vsel) < min_uV ||
-            wm831x_buckv_list_voltage(rdev, vsel) < max_uV)
-                return -EINVAL;
-
-        return vsel;
-}
-
 static int wm831x_buckv_set_dvs(struct regulator_dev *rdev, int state)
 {
         struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
@@ -338,28 +321,23 @@ static int wm831x_buckv_set_voltage(struct regulator_dev *rdev,
         if (ret < 0)
                 return ret;
 
-        /* Set the high voltage as the DVS voltage.  This is optimised
-         * for CPUfreq usage, most processors will keep the maximum
-         * voltage constant and lower the minimum with the frequency. */
-        vsel = wm831x_buckv_select_max_voltage(rdev, min_uV, max_uV);
-        if (vsel < 0) {
-                /* This should never happen - at worst the same vsel
-                 * should be chosen */
-                WARN_ON(vsel < 0);
-                return 0;
+        /*
+         * If this VSEL is higher than the last one we've seen then
+         * remember it as the DVS VSEL.  This is optimised for CPUfreq
+         * usage where we want to get to the highest voltage very
+         * quickly.
+         */
+        if (vsel > dcdc->dvs_vsel) {
+                ret = wm831x_set_bits(wm831x, dvs_reg,
+                                      WM831X_DC1_DVS_VSEL_MASK,
+                                      dcdc->dvs_vsel);
+                if (ret == 0)
+                        dcdc->dvs_vsel = vsel;
+                else
+                        dev_warn(wm831x->dev,
+                                 "Failed to set DCDC DVS VSEL: %d\n", ret);
         }
 
-        /* Don't bother if it's the same VSEL we're already using */
-        if (vsel == dcdc->on_vsel)
-                return 0;
-
-        ret = wm831x_set_bits(wm831x, dvs_reg, WM831X_DC1_DVS_VSEL_MASK, vsel);
-        if (ret == 0)
-                dcdc->dvs_vsel = vsel;
-        else
-                dev_warn(wm831x->dev, "Failed to set DCDC DVS VSEL: %d\n",
-                         ret);
-
         return 0;
 }
 
@@ -456,27 +434,6 @@ static __devinit void wm831x_buckv_dvs_init(struct wm831x_dcdc *dcdc,
         if (!pdata || !pdata->dvs_gpio)
                 return;
 
-        switch (pdata->dvs_control_src) {
-        case 1:
-                ctrl = 2 << WM831X_DC1_DVS_SRC_SHIFT;
-                break;
-        case 2:
-                ctrl = 3 << WM831X_DC1_DVS_SRC_SHIFT;
-                break;
-        default:
-                dev_err(wm831x->dev, "Invalid DVS control source %d for %s\n",
-                        pdata->dvs_control_src, dcdc->name);
-                return;
-        }
-
-        ret = wm831x_set_bits(wm831x, dcdc->base + WM831X_DCDC_DVS_CONTROL,
-                              WM831X_DC1_DVS_SRC_MASK, ctrl);
-        if (ret < 0) {
-                dev_err(wm831x->dev, "Failed to set %s DVS source: %d\n",
-                        dcdc->name, ret);
-                return;
-        }
-
         ret = gpio_request(pdata->dvs_gpio, "DCDC DVS");
         if (ret < 0) {
                 dev_err(wm831x->dev, "Failed to get %s DVS GPIO: %d\n",
@@ -498,17 +455,57 @@ static __devinit void wm831x_buckv_dvs_init(struct wm831x_dcdc *dcdc,
         }
 
         dcdc->dvs_gpio = pdata->dvs_gpio;
+
+        switch (pdata->dvs_control_src) {
+        case 1:
+                ctrl = 2 << WM831X_DC1_DVS_SRC_SHIFT;
+                break;
+        case 2:
+                ctrl = 3 << WM831X_DC1_DVS_SRC_SHIFT;
+                break;
+        default:
+                dev_err(wm831x->dev, "Invalid DVS control source %d for %s\n",
+                        pdata->dvs_control_src, dcdc->name);
+                return;
+        }
+
+        /* If DVS_VSEL is set to the minimum value then raise it to ON_VSEL
+         * to make bootstrapping a bit smoother.
+         */
+        if (!dcdc->dvs_vsel) {
+                ret = wm831x_set_bits(wm831x,
+                                      dcdc->base + WM831X_DCDC_DVS_CONTROL,
+                                      WM831X_DC1_DVS_VSEL_MASK, dcdc->on_vsel);
+                if (ret == 0)
+                        dcdc->dvs_vsel = dcdc->on_vsel;
+                else
+                        dev_warn(wm831x->dev, "Failed to set DVS_VSEL: %d\n",
+                                 ret);
+        }
+
+        ret = wm831x_set_bits(wm831x, dcdc->base + WM831X_DCDC_DVS_CONTROL,
+                              WM831X_DC1_DVS_SRC_MASK, ctrl);
+        if (ret < 0) {
+                dev_err(wm831x->dev, "Failed to set %s DVS source: %d\n",
+                        dcdc->name, ret);
+        }
 }
 
 static __devinit int wm831x_buckv_probe(struct platform_device *pdev)
 {
         struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
         struct wm831x_pdata *pdata = wm831x->dev->platform_data;
-        int id = pdev->id % ARRAY_SIZE(pdata->dcdc);
+        int id;
         struct wm831x_dcdc *dcdc;
         struct resource *res;
         int ret, irq;
 
+        if (pdata && pdata->wm831x_num)
+                id = (pdata->wm831x_num * 10) + 1;
+        else
+                id = 0;
+        id = pdev->id - id;
+
         dev_dbg(&pdev->dev, "Probing DCDC%d\n", id + 1);
 
         if (pdata == NULL || pdata->dcdc[id] == NULL)
@@ -545,7 +542,7 @@ static __devinit int wm831x_buckv_probe(struct platform_device *pdev)
         }
         dcdc->on_vsel = ret & WM831X_DC1_ON_VSEL_MASK;
 
-        ret = wm831x_reg_read(wm831x, dcdc->base + WM831X_DCDC_ON_CONFIG);
+        ret = wm831x_reg_read(wm831x, dcdc->base + WM831X_DCDC_DVS_CONTROL);
         if (ret < 0) {
                 dev_err(wm831x->dev, "Failed to read DVS VSEL: %d\n", ret);
                 goto err;
@@ -709,11 +706,17 @@ static __devinit int wm831x_buckp_probe(struct platform_device *pdev)
 {
         struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
         struct wm831x_pdata *pdata = wm831x->dev->platform_data;
-        int id = pdev->id % ARRAY_SIZE(pdata->dcdc);
+        int id;
         struct wm831x_dcdc *dcdc;
         struct resource *res;
         int ret, irq;
 
+        if (pdata && pdata->wm831x_num)
+                id = (pdata->wm831x_num * 10) + 1;
+        else
+                id = 0;
+        id = pdev->id - id;
+
         dev_dbg(&pdev->dev, "Probing DCDC%d\n", id + 1);
 
         if (pdata == NULL || pdata->dcdc[id] == NULL)
@@ -1046,3 +1049,4 @@ MODULE_DESCRIPTION("WM831x DC-DC convertor driver");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS("platform:wm831x-buckv");
 MODULE_ALIAS("platform:wm831x-buckp");
+MODULE_ALIAS("platform:wm831x-epe");
diff --git a/drivers/regulator/wm831x-ldo.c b/drivers/regulator/wm831x-ldo.c
index 2220cf8defb1..6709710a059e 100644
--- a/drivers/regulator/wm831x-ldo.c
+++ b/drivers/regulator/wm831x-ldo.c
@@ -310,11 +310,17 @@ static __devinit int wm831x_gp_ldo_probe(struct platform_device *pdev)
 {
         struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
         struct wm831x_pdata *pdata = wm831x->dev->platform_data;
-        int id = pdev->id % ARRAY_SIZE(pdata->ldo);
+        int id;
         struct wm831x_ldo *ldo;
         struct resource *res;
         int ret, irq;
 
+        if (pdata && pdata->wm831x_num)
+                id = (pdata->wm831x_num * 10) + 1;
+        else
+                id = 0;
+        id = pdev->id - id;
+
         dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1);
 
         if (pdata == NULL || pdata->ldo[id] == NULL)
@@ -574,11 +580,17 @@ static __devinit int wm831x_aldo_probe(struct platform_device *pdev)
 {
         struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
         struct wm831x_pdata *pdata = wm831x->dev->platform_data;
-        int id = pdev->id % ARRAY_SIZE(pdata->ldo);
+        int id;
         struct wm831x_ldo *ldo;
         struct resource *res;
         int ret, irq;
 
+        if (pdata && pdata->wm831x_num)
+                id = (pdata->wm831x_num * 10) + 1;
+        else
+                id = 0;
+        id = pdev->id - id;
+
         dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1);
 
         if (pdata == NULL || pdata->ldo[id] == NULL)
@@ -764,11 +776,18 @@ static __devinit int wm831x_alive_ldo_probe(struct platform_device *pdev)
 {
         struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
         struct wm831x_pdata *pdata = wm831x->dev->platform_data;
-        int id = pdev->id % ARRAY_SIZE(pdata->ldo);
+        int id;
         struct wm831x_ldo *ldo;
         struct resource *res;
         int ret;
 
+        if (pdata && pdata->wm831x_num)
+                id = (pdata->wm831x_num * 10) + 1;
+        else
+                id = 0;
+        id = pdev->id - id;
+
+
         dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1);
 
         if (pdata == NULL || pdata->ldo[id] == NULL)
diff --git a/drivers/regulator/wm8994-regulator.c b/drivers/regulator/wm8994-regulator.c
index 35b2958d5106..1a6a690f24db 100644
--- a/drivers/regulator/wm8994-regulator.c
+++ b/drivers/regulator/wm8994-regulator.c
@@ -43,7 +43,7 @@ static int wm8994_ldo_enable(struct regulator_dev *rdev)
         if (!ldo->enable)
                 return 0;
 
-        gpio_set_value(ldo->enable, 1);
+        gpio_set_value_cansleep(ldo->enable, 1);
         ldo->is_enabled = true;
 
         return 0;
@@ -57,7 +57,7 @@ static int wm8994_ldo_disable(struct regulator_dev *rdev)
         if (!ldo->enable)
                 return -EINVAL;
 
-        gpio_set_value(ldo->enable, 0);
+        gpio_set_value_cansleep(ldo->enable, 0);
         ldo->is_enabled = false;
 
         return 0;
diff --git a/drivers/rtc/interface.c b/drivers/rtc/interface.c
index 3195dbd3ec34..44e91e598f8d 100644
--- a/drivers/rtc/interface.c
+++ b/drivers/rtc/interface.c
@@ -639,7 +639,7 @@ EXPORT_SYMBOL_GPL(rtc_irq_unregister);
 static int rtc_update_hrtimer(struct rtc_device *rtc, int enabled)
 {
         /*
-         * We unconditionally cancel the timer here, because otherwise
+         * We always cancel the timer here first, because otherwise
          * we could run into BUG_ON(timer->state != HRTIMER_STATE_CALLBACK);
          * when we manage to start the timer before the callback
          * returns HRTIMER_RESTART.
@@ -708,7 +708,7 @@ int rtc_irq_set_freq(struct rtc_device *rtc, struct rtc_task *task, int freq)
         int err = 0;
         unsigned long flags;
 
-        if (freq <= 0 || freq > 5000)
+        if (freq <= 0 || freq > RTC_MAX_FREQ)
                 return -EINVAL;
 retry:
         spin_lock_irqsave(&rtc->irq_task_lock, flags);
diff --git a/drivers/rtc/rtc-ep93xx.c b/drivers/rtc/rtc-ep93xx.c
index 335551d333b2..14a42a1edc66 100644
--- a/drivers/rtc/rtc-ep93xx.c
+++ b/drivers/rtc/rtc-ep93xx.c
@@ -36,6 +36,7 @@
  */
 struct ep93xx_rtc {
         void __iomem    *mmio_base;
+        struct rtc_device *rtc;
 };
 
 static int ep93xx_rtc_get_swcomp(struct device *dev, unsigned short *preload,
@@ -130,7 +131,6 @@ static int __init ep93xx_rtc_probe(struct platform_device *pdev)
 {
         struct ep93xx_rtc *ep93xx_rtc;
         struct resource *res;
-        struct rtc_device *rtc;
         int err;
 
         ep93xx_rtc = devm_kzalloc(&pdev->dev, sizeof(*ep93xx_rtc), GFP_KERNEL);
@@ -151,12 +151,12 @@ static int __init ep93xx_rtc_probe(struct platform_device *pdev)
                 return -ENXIO;
 
         pdev->dev.platform_data = ep93xx_rtc;
-        platform_set_drvdata(pdev, rtc);
+        platform_set_drvdata(pdev, ep93xx_rtc);
 
-        rtc = rtc_device_register(pdev->name,
+        ep93xx_rtc->rtc = rtc_device_register(pdev->name,
                                 &pdev->dev, &ep93xx_rtc_ops, THIS_MODULE);
-        if (IS_ERR(rtc)) {
-                err = PTR_ERR(rtc);
+        if (IS_ERR(ep93xx_rtc->rtc)) {
+                err = PTR_ERR(ep93xx_rtc->rtc);
                 goto exit;
         }
 
@@ -167,7 +167,7 @@ static int __init ep93xx_rtc_probe(struct platform_device *pdev)
         return 0;
 
 fail:
-        rtc_device_unregister(rtc);
+        rtc_device_unregister(ep93xx_rtc->rtc);
 exit:
         platform_set_drvdata(pdev, NULL);
         pdev->dev.platform_data = NULL;
@@ -176,11 +176,11 @@ exit:
 
 static int __exit ep93xx_rtc_remove(struct platform_device *pdev)
 {
-        struct rtc_device *rtc = platform_get_drvdata(pdev);
+        struct ep93xx_rtc *ep93xx_rtc = platform_get_drvdata(pdev);
 
         sysfs_remove_group(&pdev->dev.kobj, &ep93xx_rtc_sysfs_files);
         platform_set_drvdata(pdev, NULL);
-        rtc_device_unregister(rtc);
+        rtc_device_unregister(ep93xx_rtc->rtc);
         pdev->dev.platform_data = NULL;
 
         return 0;
diff --git a/drivers/rtc/rtc-lib.c b/drivers/rtc/rtc-lib.c
index 075f1708deae..c4cf05731118 100644
--- a/drivers/rtc/rtc-lib.c
+++ b/drivers/rtc/rtc-lib.c
@@ -85,6 +85,8 @@ void rtc_time_to_tm(unsigned long time, struct rtc_time *tm)
         time -= tm->tm_hour * 3600;
         tm->tm_min = time / 60;
         tm->tm_sec = time - tm->tm_min * 60;
+
+        tm->tm_isdst = 0;
 }
 EXPORT_SYMBOL(rtc_time_to_tm);
 
diff --git a/drivers/rtc/rtc-omap.c b/drivers/rtc/rtc-omap.c
index bcae8dd41496..7789002bdd5c 100644
--- a/drivers/rtc/rtc-omap.c
+++ b/drivers/rtc/rtc-omap.c
@@ -368,7 +368,7 @@ static int __init omap_rtc_probe(struct platform_device *pdev)
                 pr_info("%s: already running\n", pdev->name);
 
         /* force to 24 hour mode */
-        new_ctrl = reg & ~(OMAP_RTC_CTRL_SPLIT|OMAP_RTC_CTRL_AUTO_COMP);
+        new_ctrl = reg & (OMAP_RTC_CTRL_SPLIT|OMAP_RTC_CTRL_AUTO_COMP);
         new_ctrl |= OMAP_RTC_CTRL_STOP;
 
         /* BOARD-SPECIFIC CUSTOMIZATION CAN GO HERE:
diff --git a/drivers/rtc/rtc-s3c.c b/drivers/rtc/rtc-s3c.c
index 9329dbb9ebab..4e7c04e773e0 100644
--- a/drivers/rtc/rtc-s3c.c
+++ b/drivers/rtc/rtc-s3c.c
@@ -152,10 +152,6 @@ static int s3c_rtc_gettime(struct device *dev, struct rtc_time *rtc_tm)
                 goto retry_get_time;
         }
 
-        pr_debug("read time %04d.%02d.%02d %02d:%02d:%02d\n",
-                 1900 + rtc_tm->tm_year, rtc_tm->tm_mon, rtc_tm->tm_mday,
-                 rtc_tm->tm_hour, rtc_tm->tm_min, rtc_tm->tm_sec);
-
         rtc_tm->tm_sec = bcd2bin(rtc_tm->tm_sec);
         rtc_tm->tm_min = bcd2bin(rtc_tm->tm_min);
         rtc_tm->tm_hour = bcd2bin(rtc_tm->tm_hour);
@@ -164,6 +160,11 @@ static int s3c_rtc_gettime(struct device *dev, struct rtc_time *rtc_tm)
         rtc_tm->tm_year = bcd2bin(rtc_tm->tm_year);
 
         rtc_tm->tm_year += 100;
+
+        pr_debug("read time %04d.%02d.%02d %02d:%02d:%02d\n",
+                 1900 + rtc_tm->tm_year, rtc_tm->tm_mon, rtc_tm->tm_mday,
+                 rtc_tm->tm_hour, rtc_tm->tm_min, rtc_tm->tm_sec);
+
         rtc_tm->tm_mon -= 1;
 
         clk_disable(rtc_clk);
@@ -269,10 +270,9 @@ static int s3c_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
         clk_enable(rtc_clk);
         pr_debug("s3c_rtc_setalarm: %d, %04d.%02d.%02d %02d:%02d:%02d\n",
                  alrm->enabled,
-                 1900 + tm->tm_year, tm->tm_mon, tm->tm_mday,
+                 1900 + tm->tm_year, tm->tm_mon + 1, tm->tm_mday,
                  tm->tm_hour, tm->tm_min, tm->tm_sec);
 
-
         alrm_en = readb(base + S3C2410_RTCALM) & S3C2410_RTCALM_ALMEN;
         writeb(0x00, base + S3C2410_RTCALM);
 
@@ -319,49 +319,7 @@ static int s3c_rtc_proc(struct device *dev, struct seq_file *seq)
         return 0;
 }
 
-static int s3c_rtc_open(struct device *dev)
-{
-        struct platform_device *pdev = to_platform_device(dev);
-        struct rtc_device *rtc_dev = platform_get_drvdata(pdev);
-        int ret;
-
-        ret = request_irq(s3c_rtc_alarmno, s3c_rtc_alarmirq,
-                          IRQF_DISABLED,  "s3c2410-rtc alarm", rtc_dev);
-
-        if (ret) {
-                dev_err(dev, "IRQ%d error %d\n", s3c_rtc_alarmno, ret);
-                return ret;
-        }
-
-        ret = request_irq(s3c_rtc_tickno, s3c_rtc_tickirq,
-                          IRQF_DISABLED,  "s3c2410-rtc tick", rtc_dev);
-
-        if (ret) {
-                dev_err(dev, "IRQ%d error %d\n", s3c_rtc_tickno, ret);
-                goto tick_err;
-        }
-
-        return ret;
-
- tick_err:
-        free_irq(s3c_rtc_alarmno, rtc_dev);
-        return ret;
-}
-
-static void s3c_rtc_release(struct device *dev)
-{
-        struct platform_device *pdev = to_platform_device(dev);
-        struct rtc_device *rtc_dev = platform_get_drvdata(pdev);
-
-        /* do not clear AIE here, it may be needed for wake */
-
-        free_irq(s3c_rtc_alarmno, rtc_dev);
-        free_irq(s3c_rtc_tickno, rtc_dev);
-}
-
 static const struct rtc_class_ops s3c_rtcops = {
-        .open           = s3c_rtc_open,
-        .release        = s3c_rtc_release,
         .read_time      = s3c_rtc_gettime,
         .set_time       = s3c_rtc_settime,
         .read_alarm     = s3c_rtc_getalarm,
@@ -425,6 +383,9 @@ static int __devexit s3c_rtc_remove(struct platform_device *dev)
 {
         struct rtc_device *rtc = platform_get_drvdata(dev);
 
+        free_irq(s3c_rtc_alarmno, rtc);
+        free_irq(s3c_rtc_tickno, rtc);
+
         platform_set_drvdata(dev, NULL);
         rtc_device_unregister(rtc);
 
@@ -548,10 +509,32 @@ static int __devinit s3c_rtc_probe(struct platform_device *pdev)
 
         s3c_rtc_setfreq(&pdev->dev, 1);
 
+        ret = request_irq(s3c_rtc_alarmno, s3c_rtc_alarmirq,
+                          IRQF_DISABLED,  "s3c2410-rtc alarm", rtc);
+        if (ret) {
+                dev_err(&pdev->dev, "IRQ%d error %d\n", s3c_rtc_alarmno, ret);
+                goto err_alarm_irq;
+        }
+
+        ret = request_irq(s3c_rtc_tickno, s3c_rtc_tickirq,
+                          IRQF_DISABLED,  "s3c2410-rtc tick", rtc);
+        if (ret) {
+                dev_err(&pdev->dev, "IRQ%d error %d\n", s3c_rtc_tickno, ret);
+                free_irq(s3c_rtc_alarmno, rtc);
+                goto err_tick_irq;
+        }
+
         clk_disable(rtc_clk);
 
         return 0;
 
+ err_tick_irq:
+        free_irq(s3c_rtc_alarmno, rtc);
+
+ err_alarm_irq:
+        platform_set_drvdata(pdev, NULL);
+        rtc_device_unregister(rtc);
+
  err_nortc:
         s3c_rtc_enable(pdev, 0);
         clk_disable(rtc_clk);
diff --git a/drivers/rtc/rtc-twl.c b/drivers/rtc/rtc-twl.c
index 9a81f778d6b2..20687d55e7a7 100644
--- a/drivers/rtc/rtc-twl.c
+++ b/drivers/rtc/rtc-twl.c
@@ -362,14 +362,6 @@ static irqreturn_t twl_rtc_interrupt(int irq, void *rtc)
         int res;
         u8 rd_reg;
 
-#ifdef CONFIG_LOCKDEP
-        /* WORKAROUND for lockdep forcing IRQF_DISABLED on us, which
-         * we don't want and can't tolerate.  Although it might be
-         * friendlier not to borrow this thread context...
-         */
-        local_irq_enable();
-#endif
-
         res = twl_rtc_read_u8(&rd_reg, REG_RTC_STATUS_REG);
         if (res)
                 goto out;
@@ -428,24 +420,12 @@ static struct rtc_class_ops twl_rtc_ops = {
 static int __devinit twl_rtc_probe(struct platform_device *pdev)
 {
         struct rtc_device *rtc;
-        int ret = 0;
+        int ret = -EINVAL;
         int irq = platform_get_irq(pdev, 0);
         u8 rd_reg;
 
         if (irq <= 0)
-                return -EINVAL;
-
-        rtc = rtc_device_register(pdev->name,
-                                  &pdev->dev, &twl_rtc_ops, THIS_MODULE);
-        if (IS_ERR(rtc)) {
-                ret = PTR_ERR(rtc);
-                dev_err(&pdev->dev, "can't register RTC device, err %ld\n",
-                        PTR_ERR(rtc));
-                goto out0;
-
-        }
-
-        platform_set_drvdata(pdev, rtc);
+                goto out1;
 
         ret = twl_rtc_read_u8(&rd_reg, REG_RTC_STATUS_REG);
         if (ret < 0)
@@ -462,14 +442,6 @@ static int __devinit twl_rtc_probe(struct platform_device *pdev)
         if (ret < 0)
                 goto out1;
 
-        ret = request_irq(irq, twl_rtc_interrupt,
-                                IRQF_TRIGGER_RISING,
-                                dev_name(&rtc->dev), rtc);
-        if (ret < 0) {
-                dev_err(&pdev->dev, "IRQ is not free.\n");
-                goto out1;
-        }
-
         if (twl_class_is_6030()) {
                 twl6030_interrupt_unmask(TWL6030_RTC_INT_MASK,
                         REG_INT_MSK_LINE_A);
@@ -480,28 +452,44 @@ static int __devinit twl_rtc_probe(struct platform_device *pdev)
         /* Check RTC module status, Enable if it is off */
         ret = twl_rtc_read_u8(&rd_reg, REG_RTC_CTRL_REG);
         if (ret < 0)
-                goto out2;
+                goto out1;
 
         if (!(rd_reg & BIT_RTC_CTRL_REG_STOP_RTC_M)) {
                 dev_info(&pdev->dev, "Enabling TWL-RTC.\n");
                 rd_reg = BIT_RTC_CTRL_REG_STOP_RTC_M;
                 ret = twl_rtc_write_u8(rd_reg, REG_RTC_CTRL_REG);
                 if (ret < 0)
-                        goto out2;
+                        goto out1;
         }
 
         /* init cached IRQ enable bits */
         ret = twl_rtc_read_u8(&rtc_irq_bits, REG_RTC_INTERRUPTS_REG);
         if (ret < 0)
+                goto out1;
+
+        rtc = rtc_device_register(pdev->name,
+                                  &pdev->dev, &twl_rtc_ops, THIS_MODULE);
+        if (IS_ERR(rtc)) {
+                ret = PTR_ERR(rtc);
+                dev_err(&pdev->dev, "can't register RTC device, err %ld\n",
+                        PTR_ERR(rtc));
+                goto out1;
+        }
+
+        ret = request_threaded_irq(irq, NULL, twl_rtc_interrupt,
+                                   IRQF_TRIGGER_RISING,
+                                   dev_name(&rtc->dev), rtc);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "IRQ is not free.\n");
                 goto out2;
+        }
 
-        return ret;
+        platform_set_drvdata(pdev, rtc);
+        return 0;
 
 out2:
-        free_irq(irq, rtc);
-out1:
         rtc_device_unregister(rtc);
-out0:
+out1:
         return ret;
 }
 
diff --git a/drivers/s390/block/dasd.c b/drivers/s390/block/dasd.c
index 432444af7ee4..a1d3ddba99cc 100644
--- a/drivers/s390/block/dasd.c
+++ b/drivers/s390/block/dasd.c
@@ -24,6 +24,7 @@
 #include <linux/mutex.h>
 #include <linux/debugfs.h>
 #include <linux/seq_file.h>
+#include <linux/vmalloc.h>
 
 #include <asm/ccwdev.h>
 #include <asm/ebcdic.h>
@@ -888,11 +889,11 @@ char *dasd_get_user_string(const char __user *user_buf, size_t user_len)
 {
         char *buffer;
 
-        buffer = kmalloc(user_len + 1, GFP_KERNEL);
+        buffer = vmalloc(user_len + 1);
         if (buffer == NULL)
                 return ERR_PTR(-ENOMEM);
         if (copy_from_user(buffer, user_buf, user_len) != 0) {
-                kfree(buffer);
+                vfree(buffer);
                 return ERR_PTR(-EFAULT);
         }
         /* got the string, now strip linefeed. */
@@ -930,7 +931,7 @@ static ssize_t dasd_stats_write(struct file *file,
                 dasd_profile_off(prof);
         } else
                 rc = -EINVAL;
-        kfree(buffer);
+        vfree(buffer);
         return rc;
 }
 
@@ -1042,7 +1043,7 @@ static ssize_t dasd_stats_global_write(struct file *file,
                 dasd_global_profile_level = DASD_PROFILE_OFF;
         } else
                 rc = -EINVAL;
-        kfree(buffer);
+        vfree(buffer);
         return rc;
 }
 
diff --git a/drivers/s390/block/dasd_eckd.c b/drivers/s390/block/dasd_eckd.c
index 30fb979d684d..6e835c9fdfcb 100644
--- a/drivers/s390/block/dasd_eckd.c
+++ b/drivers/s390/block/dasd_eckd.c
@@ -1461,6 +1461,15 @@ dasd_eckd_check_characteristics(struct dasd_device *device)
                                 "Read device characteristic failed, rc=%d", rc);
                 goto out_err3;
         }
+
+        if ((device->features & DASD_FEATURE_USERAW) &&
+            !(private->rdc_data.facilities.RT_in_LR)) {
+                dev_err(&device->cdev->dev, "The storage server does not "
+                        "support raw-track access\n");
+                rc = -EINVAL;
+                goto out_err3;
+        }
+
         /* find the valid cylinder size */
         if (private->rdc_data.no_cyl == LV_COMPAT_CYL &&
             private->rdc_data.long_no_cyl)
diff --git a/drivers/s390/block/dasd_ioctl.c b/drivers/s390/block/dasd_ioctl.c
index eb4e034378cd..f1a2016829fc 100644
--- a/drivers/s390/block/dasd_ioctl.c
+++ b/drivers/s390/block/dasd_ioctl.c
@@ -249,6 +249,7 @@ static int dasd_ioctl_reset_profile(struct dasd_block *block)
 static int dasd_ioctl_read_profile(struct dasd_block *block, void __user *argp)
 {
         struct dasd_profile_info_t *data;
+        int rc = 0;
 
         data = kmalloc(sizeof(*data), GFP_KERNEL);
         if (!data)
@@ -279,11 +280,14 @@ static int dasd_ioctl_read_profile(struct dasd_block *block, void __user *argp)
                 spin_unlock_bh(&block->profile.lock);
         } else {
                 spin_unlock_bh(&block->profile.lock);
-                return -EIO;
+                rc = -EIO;
+                goto out;
         }
         if (copy_to_user(argp, data, sizeof(*data)))
-                return -EFAULT;
-        return 0;
+                rc = -EFAULT;
+out:
+        kfree(data);
+        return rc;
 }
 #else
 static int dasd_ioctl_reset_profile(struct dasd_block *block)
diff --git a/drivers/s390/block/dasd_proc.c b/drivers/s390/block/dasd_proc.c
index 6c3c5364d082..e12989fff4ff 100644
--- a/drivers/s390/block/dasd_proc.c
+++ b/drivers/s390/block/dasd_proc.c
@@ -312,14 +312,14 @@ static ssize_t dasd_stats_proc_write(struct file *file,
                 pr_info("The statistics have been reset\n");
         } else
                 goto out_parse_error;
-        kfree(buffer);
+        vfree(buffer);
         return user_len;
 out_parse_error:
         rc = -EINVAL;
         pr_warning("%s is not a supported value for /proc/dasd/statistics\n",
                 str);
 out_error:
-        kfree(buffer);
+        vfree(buffer);
         return rc;
 #else
         pr_warning("/proc/dasd/statistics: is not activated in this kernel\n");
diff --git a/drivers/s390/char/sclp_async.c b/drivers/s390/char/sclp_async.c
index 7ad30e72f868..5f9f929e891c 100644
--- a/drivers/s390/char/sclp_async.c
+++ b/drivers/s390/char/sclp_async.c
@@ -82,12 +82,9 @@ static int proc_handler_callhome(struct ctl_table *ctl, int write,
                         return -EFAULT;
         } else {
                 len = *count;
-                rc = copy_from_user(buf, buffer, sizeof(buf));
-                if (rc != 0)
-                        return -EFAULT;
-                buf[sizeof(buf) - 1] = '\0';
-                if (strict_strtoul(buf, 0, &val) != 0)
-                        return -EINVAL;
+                rc = kstrtoul_from_user(buffer, len, 0, &val);
+                if (rc)
+                        return rc;
                 if (val != 0 && val != 1)
                         return -EINVAL;
                 callhome_enabled = val;
diff --git a/drivers/s390/char/sclp_cmd.c b/drivers/s390/char/sclp_cmd.c
index be55fb2b1b1c..837e010299a8 100644
--- a/drivers/s390/char/sclp_cmd.c
+++ b/drivers/s390/char/sclp_cmd.c
@@ -383,8 +383,10 @@ static int sclp_attach_storage(u8 id)
         switch (sccb->header.response_code) {
         case 0x0020:
                 set_bit(id, sclp_storage_ids);
-                for (i = 0; i < sccb->assigned; i++)
-                        sclp_unassign_storage(sccb->entries[i] >> 16);
+                for (i = 0; i < sccb->assigned; i++) {
+                        if (sccb->entries[i])
+                                sclp_unassign_storage(sccb->entries[i] >> 16);
+                }
                 break;
         default:
                 rc = -EIO;
diff --git a/drivers/s390/cio/qdio.h b/drivers/s390/cio/qdio.h
index 7bc643f3f5ab..e5c966462c5a 100644
--- a/drivers/s390/cio/qdio.h
+++ b/drivers/s390/cio/qdio.h
@@ -14,6 +14,8 @@
 #include "chsc.h"
 
 #define QDIO_BUSY_BIT_PATIENCE          (100 << 12)     /* 100 microseconds */
+#define QDIO_BUSY_BIT_RETRY_DELAY       10              /* 10 milliseconds */
+#define QDIO_BUSY_BIT_RETRIES           1000            /* = 10s retry time */
 #define QDIO_INPUT_THRESHOLD            (500 << 12)     /* 500 microseconds */
 
 /*
diff --git a/drivers/s390/cio/qdio_debug.c b/drivers/s390/cio/qdio_debug.c
index f8b03a636e49..0e615cb912d0 100644
--- a/drivers/s390/cio/qdio_debug.c
+++ b/drivers/s390/cio/qdio_debug.c
@@ -188,19 +188,13 @@ static ssize_t qperf_seq_write(struct file *file, const char __user *ubuf,
         struct qdio_irq *irq_ptr = seq->private;
         struct qdio_q *q;
         unsigned long val;
-        char buf[8];
         int ret, i;
 
         if (!irq_ptr)
                 return 0;
-        if (count >= sizeof(buf))
-                return -EINVAL;
-        if (copy_from_user(&buf, ubuf, count))
-                return -EFAULT;
-        buf[count] = 0;
-
-        ret = strict_strtoul(buf, 10, &val);
-        if (ret < 0)
+
+        ret = kstrtoul_from_user(ubuf, count, 10, &val);
+        if (ret)
                 return ret;
 
         switch (val) {
diff --git a/drivers/s390/cio/qdio_main.c b/drivers/s390/cio/qdio_main.c
index e58169c32474..288c9140290e 100644
--- a/drivers/s390/cio/qdio_main.c
+++ b/drivers/s390/cio/qdio_main.c
@@ -313,7 +313,7 @@ static int qdio_siga_output(struct qdio_q *q, unsigned int *busy_bit)
         unsigned long schid = *((u32 *) &q->irq_ptr->schid);
         unsigned int fc = QDIO_SIGA_WRITE;
         u64 start_time = 0;
-        int cc;
+        int retries = 0, cc;
 
         if (is_qebsm(q)) {
                 schid = q->irq_ptr->sch_token;
@@ -325,6 +325,7 @@ again:
         /* hipersocket busy condition */
         if (unlikely(*busy_bit)) {
                 WARN_ON(queue_type(q) != QDIO_IQDIO_QFMT || cc != 2);
+                retries++;
 
                 if (!start_time) {
                         start_time = get_clock();
@@ -333,6 +334,11 @@ again:
                 if ((get_clock() - start_time) < QDIO_BUSY_BIT_PATIENCE)
                         goto again;
         }
+        if (retries) {
+                DBF_DEV_EVENT(DBF_WARN, q->irq_ptr,
+                              "%4x cc2 BB1:%1d", SCH_NO(q), q->nr);
+                DBF_DEV_EVENT(DBF_WARN, q->irq_ptr, "count:%u", retries);
+        }
         return cc;
 }
 
@@ -728,13 +734,14 @@ static inline int qdio_outbound_q_moved(struct qdio_q *q)
 
 static int qdio_kick_outbound_q(struct qdio_q *q)
 {
+        int retries = 0, cc;
         unsigned int busy_bit;
-        int cc;
 
         if (!need_siga_out(q))
                 return 0;
 
         DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "siga-w:%1d", q->nr);
+retry:
         qperf_inc(q, siga_write);
 
         cc = qdio_siga_output(q, &busy_bit);
@@ -743,7 +750,11 @@ static int qdio_kick_outbound_q(struct qdio_q *q)
                 break;
         case 2:
                 if (busy_bit) {
-                        DBF_ERROR("%4x cc2 REP:%1d", SCH_NO(q), q->nr);
+                        while (++retries < QDIO_BUSY_BIT_RETRIES) {
+                                mdelay(QDIO_BUSY_BIT_RETRY_DELAY);
+                                goto retry;
+                        }
+                        DBF_ERROR("%4x cc2 BBC:%1d", SCH_NO(q), q->nr);
                         cc |= QDIO_ERROR_SIGA_BUSY;
                 } else
                         DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "siga-w cc2:%1d", q->nr);
@@ -753,6 +764,10 @@ static int qdio_kick_outbound_q(struct qdio_q *q)
                 DBF_ERROR("%4x SIGA-W:%1d", SCH_NO(q), cc);
                 break;
         }
+        if (retries) {
+                DBF_ERROR("%4x cc2 BB2:%1d", SCH_NO(q), q->nr);
+                DBF_ERROR("count:%u", retries);
+        }
         return cc;
 }
 
diff --git a/drivers/scsi/bfa/bfa.h b/drivers/scsi/bfa/bfa.h
index 3b0af1102bf4..a796de935054 100644
--- a/drivers/scsi/bfa/bfa.h
+++ b/drivers/scsi/bfa/bfa.h
@@ -27,6 +27,7 @@
 struct bfa_s;
 
 typedef void (*bfa_isr_func_t) (struct bfa_s *bfa, struct bfi_msg_s *m);
+typedef void (*bfa_cb_cbfn_status_t) (void *cbarg, bfa_status_t status);
 
 /*
  * Interrupt message handlers
@@ -121,6 +122,7 @@ bfa_reqq_winit(struct bfa_reqq_wait_s *wqe, void (*qresume) (void *cbarg),
 #define bfa_cb_queue(__bfa, __hcb_qe, __cbfn, __cbarg) do {     \
                 (__hcb_qe)->cbfn  = (__cbfn);      \
                 (__hcb_qe)->cbarg = (__cbarg);      \
+                (__hcb_qe)->pre_rmv = BFA_FALSE;                \
                 list_add_tail(&(__hcb_qe)->qe, &(__bfa)->comp_q);      \
         } while (0)
 
@@ -135,6 +137,11 @@ bfa_reqq_winit(struct bfa_reqq_wait_s *wqe, void (*qresume) (void *cbarg),
                 }                                                       \
         } while (0)
 
+#define bfa_cb_queue_status(__bfa, __hcb_qe, __status) do {             \
+                (__hcb_qe)->fw_status = (__status);                     \
+                list_add_tail(&(__hcb_qe)->qe, &(__bfa)->comp_q);       \
+} while (0)
+
 #define bfa_cb_queue_done(__hcb_qe) do {        \
                 (__hcb_qe)->once = BFA_FALSE;   \
         } while (0)
@@ -177,7 +184,7 @@ struct bfa_msix_s {
 struct bfa_hwif_s {
         void (*hw_reginit)(struct bfa_s *bfa);
         void (*hw_reqq_ack)(struct bfa_s *bfa, int reqq);
-        void (*hw_rspq_ack)(struct bfa_s *bfa, int rspq);
+        void (*hw_rspq_ack)(struct bfa_s *bfa, int rspq, u32 ci);
         void (*hw_msix_init)(struct bfa_s *bfa, int nvecs);
         void (*hw_msix_ctrl_install)(struct bfa_s *bfa);
         void (*hw_msix_queue_install)(struct bfa_s *bfa);
@@ -268,10 +275,8 @@ struct bfa_iocfc_s {
         ((__bfa)->iocfc.hwif.hw_msix_queue_install(__bfa))
 #define bfa_msix_uninstall(__bfa)                                       \
         ((__bfa)->iocfc.hwif.hw_msix_uninstall(__bfa))
-#define bfa_isr_rspq_ack(__bfa, __queue) do {                           \
-        if ((__bfa)->iocfc.hwif.hw_rspq_ack)                            \
-                (__bfa)->iocfc.hwif.hw_rspq_ack(__bfa, __queue);        \
-} while (0)
+#define bfa_isr_rspq_ack(__bfa, __queue, __ci)                          \
+        ((__bfa)->iocfc.hwif.hw_rspq_ack(__bfa, __queue, __ci))
 #define bfa_isr_reqq_ack(__bfa, __queue) do {                           \
         if ((__bfa)->iocfc.hwif.hw_reqq_ack)                            \
                 (__bfa)->iocfc.hwif.hw_reqq_ack(__bfa, __queue);        \
@@ -311,7 +316,7 @@ void bfa_msix_rspq(struct bfa_s *bfa, int vec);
 void bfa_msix_lpu_err(struct bfa_s *bfa, int vec);
 
 void bfa_hwcb_reginit(struct bfa_s *bfa);
-void bfa_hwcb_rspq_ack(struct bfa_s *bfa, int rspq);
+void bfa_hwcb_rspq_ack(struct bfa_s *bfa, int rspq, u32 ci);
 void bfa_hwcb_msix_init(struct bfa_s *bfa, int nvecs);
 void bfa_hwcb_msix_ctrl_install(struct bfa_s *bfa);
 void bfa_hwcb_msix_queue_install(struct bfa_s *bfa);
@@ -324,7 +329,8 @@ void bfa_hwcb_msix_get_rme_range(struct bfa_s *bfa, u32 *start,
 void bfa_hwct_reginit(struct bfa_s *bfa);
 void bfa_hwct2_reginit(struct bfa_s *bfa);
 void bfa_hwct_reqq_ack(struct bfa_s *bfa, int rspq);
-void bfa_hwct_rspq_ack(struct bfa_s *bfa, int rspq);
+void bfa_hwct_rspq_ack(struct bfa_s *bfa, int rspq, u32 ci);
+void bfa_hwct2_rspq_ack(struct bfa_s *bfa, int rspq, u32 ci);
 void bfa_hwct_msix_init(struct bfa_s *bfa, int nvecs);
 void bfa_hwct_msix_ctrl_install(struct bfa_s *bfa);
 void bfa_hwct_msix_queue_install(struct bfa_s *bfa);
@@ -376,6 +382,22 @@ int bfa_iocfc_get_pbc_vports(struct bfa_s *bfa,
 #define bfa_get_fw_clock_res(__bfa)             \
         ((__bfa)->iocfc.cfgrsp->fwcfg.fw_tick_res)
 
+/*
+ * lun mask macros return NULL when min cfg is enabled and there is
+ * no memory allocated for lunmask.
+ */
+#define bfa_get_lun_mask(__bfa)                                 \
+        ((&(__bfa)->modules.dconf_mod)->min_cfg) ? NULL :       \
+         (&(BFA_DCONF_MOD(__bfa)->dconf->lun_mask))
+
+#define bfa_get_lun_mask_list(_bfa)                             \
+        ((&(_bfa)->modules.dconf_mod)->min_cfg) ? NULL :        \
+         (bfa_get_lun_mask(_bfa)->lun_list)
+
+#define bfa_get_lun_mask_status(_bfa)                           \
+        (((&(_bfa)->modules.dconf_mod)->min_cfg)                \
+         ? BFA_LUNMASK_MINCFG : ((bfa_get_lun_mask(_bfa))->status))
+
 void bfa_get_pciids(struct bfa_pciid_s **pciids, int *npciids);
 void bfa_cfg_get_default(struct bfa_iocfc_cfg_s *cfg);
 void bfa_cfg_get_min(struct bfa_iocfc_cfg_s *cfg);
@@ -406,7 +428,22 @@ bfa_status_t bfa_iocfc_israttr_set(struct bfa_s *bfa,
 
 void bfa_iocfc_enable(struct bfa_s *bfa);
 void bfa_iocfc_disable(struct bfa_s *bfa);
+void bfa_iocfc_cb_dconf_modinit(struct bfa_s *bfa, bfa_status_t status);
 #define bfa_timer_start(_bfa, _timer, _timercb, _arg, _timeout)         \
         bfa_timer_begin(&(_bfa)->timer_mod, _timer, _timercb, _arg, _timeout)
 
+struct bfa_cb_pending_q_s {
+        struct bfa_cb_qe_s      hcb_qe;
+        void                    *data;  /* Driver buffer */
+};
+
+/* Common macros to operate on pending stats/attr apis */
+#define bfa_pending_q_init(__qe, __cbfn, __cbarg, __data) do {  \
+        bfa_q_qe_init(&((__qe)->hcb_qe.qe));                    \
+        (__qe)->hcb_qe.cbfn = (__cbfn);                         \
+        (__qe)->hcb_qe.cbarg = (__cbarg);                       \
+        (__qe)->hcb_qe.pre_rmv = BFA_TRUE;                      \
+        (__qe)->data = (__data);                                \
+} while (0)
+
 #endif /* __BFA_H__ */
diff --git a/drivers/scsi/bfa/bfa_core.c b/drivers/scsi/bfa/bfa_core.c
index c38e589105a5..4bd546bcc240 100644
--- a/drivers/scsi/bfa/bfa_core.c
+++ b/drivers/scsi/bfa/bfa_core.c
@@ -33,6 +33,7 @@ static struct bfa_module_s *hal_mods[] = {
         &hal_mod_uf,
         &hal_mod_rport,
         &hal_mod_fcp,
+        &hal_mod_dconf,
         NULL
 };
 
@@ -237,8 +238,6 @@ bfa_isr_rspq(struct bfa_s *bfa, int qid)
         u32     pi, ci;
         struct list_head *waitq;
 
-        bfa_isr_rspq_ack(bfa, qid);
-
         ci = bfa_rspq_ci(bfa, qid);
         pi = bfa_rspq_pi(bfa, qid);
 
@@ -251,11 +250,9 @@ bfa_isr_rspq(struct bfa_s *bfa, int qid)
         }
 
         /*
-         * update CI
+         * acknowledge RME completions and update CI
          */
-        bfa_rspq_ci(bfa, qid) = pi;
-        writel(pi, bfa->iocfc.bfa_regs.rme_q_ci[qid]);
-        mmiowb();
+        bfa_isr_rspq_ack(bfa, qid, ci);
 
         /*
          * Resume any pending requests in the corresponding reqq.
@@ -325,23 +322,19 @@ bfa_intx(struct bfa_s *bfa)
         int queue;
 
         intr = readl(bfa->iocfc.bfa_regs.intr_status);
-        if (!intr)
-                return BFA_FALSE;
 
         qintr = intr & (__HFN_INT_RME_MASK | __HFN_INT_CPE_MASK);
         if (qintr)
                 writel(qintr, bfa->iocfc.bfa_regs.intr_status);
 
         /*
-         * RME completion queue interrupt
+         * Unconditional RME completion queue interrupt
          */
-        qintr = intr & __HFN_INT_RME_MASK;
-        if (qintr && bfa->queue_process) {
+        if (bfa->queue_process) {
                 for (queue = 0; queue < BFI_IOC_MAX_CQS; queue++)
                         bfa_isr_rspq(bfa, queue);
         }
 
-        intr &= ~qintr;
         if (!intr)
                 return BFA_TRUE;
 
@@ -432,7 +425,8 @@ bfa_msix_lpu_err(struct bfa_s *bfa, int vec)
                                    __HFN_INT_MBOX_LPU1_CT2);
                 intr    &= __HFN_INT_ERR_MASK_CT2;
         } else {
-                halt_isr = intr & __HFN_INT_LL_HALT;
+                halt_isr = bfa_asic_id_ct(bfa->ioc.pcidev.device_id) ?
+                                          (intr & __HFN_INT_LL_HALT) : 0;
                 pss_isr  = intr & __HFN_INT_ERR_PSS;
                 lpu_isr  = intr & (__HFN_INT_MBOX_LPU0 | __HFN_INT_MBOX_LPU1);
                 intr    &= __HFN_INT_ERR_MASK;
@@ -578,7 +572,7 @@ bfa_iocfc_init_mem(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
         } else {
                 iocfc->hwif.hw_reginit = bfa_hwcb_reginit;
                 iocfc->hwif.hw_reqq_ack = NULL;
-                iocfc->hwif.hw_rspq_ack = NULL;
+                iocfc->hwif.hw_rspq_ack = bfa_hwcb_rspq_ack;
                 iocfc->hwif.hw_msix_init = bfa_hwcb_msix_init;
                 iocfc->hwif.hw_msix_ctrl_install = bfa_hwcb_msix_ctrl_install;
                 iocfc->hwif.hw_msix_queue_install = bfa_hwcb_msix_queue_install;
@@ -595,7 +589,7 @@ bfa_iocfc_init_mem(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
         if (bfa_asic_id_ct2(bfa_ioc_devid(&bfa->ioc))) {
                 iocfc->hwif.hw_reginit = bfa_hwct2_reginit;
                 iocfc->hwif.hw_isr_mode_set = NULL;
-                iocfc->hwif.hw_rspq_ack = NULL;
+                iocfc->hwif.hw_rspq_ack = bfa_hwct2_rspq_ack;
         }
 
         iocfc->hwif.hw_reginit(bfa);
@@ -685,7 +679,7 @@ bfa_iocfc_start_submod(struct bfa_s *bfa)
 
         bfa->queue_process = BFA_TRUE;
         for (i = 0; i < BFI_IOC_MAX_CQS; i++)
-                bfa_isr_rspq_ack(bfa, i);
+                bfa_isr_rspq_ack(bfa, i, bfa_rspq_ci(bfa, i));
 
         for (i = 0; hal_mods[i]; i++)
                 hal_mods[i]->start(bfa);
@@ -709,7 +703,7 @@ bfa_iocfc_init_cb(void *bfa_arg, bfa_boolean_t complete)
         struct bfa_s    *bfa = bfa_arg;
 
         if (complete) {
-                if (bfa->iocfc.cfgdone)
+                if (bfa->iocfc.cfgdone && BFA_DCONF_MOD(bfa)->flashdone)
                         bfa_cb_init(bfa->bfad, BFA_STATUS_OK);
                 else
                         bfa_cb_init(bfa->bfad, BFA_STATUS_FAILED);
@@ -822,9 +816,11 @@ bfa_iocfc_cfgrsp(struct bfa_s *bfa)
          */
         bfa_fcport_init(bfa);
 
-        if (iocfc->action == BFA_IOCFC_ACT_INIT)
-                bfa_cb_queue(bfa, &iocfc->init_hcb_qe, bfa_iocfc_init_cb, bfa);
-        else {
+        if (iocfc->action == BFA_IOCFC_ACT_INIT) {
+                if (BFA_DCONF_MOD(bfa)->flashdone == BFA_TRUE)
+                        bfa_cb_queue(bfa, &iocfc->init_hcb_qe,
+                                bfa_iocfc_init_cb, bfa);
+        } else {
                 if (bfa->iocfc.action == BFA_IOCFC_ACT_ENABLE)
                         bfa_cb_queue(bfa, &bfa->iocfc.en_hcb_qe,
                                         bfa_iocfc_enable_cb, bfa);
@@ -1045,6 +1041,7 @@ bfa_iocfc_enable_cbfn(void *bfa_arg, enum bfa_status status)
         }
 
         bfa_iocfc_send_cfg(bfa);
+        bfa_dconf_modinit(bfa);
 }
 
 /*
@@ -1207,7 +1204,9 @@ bfa_iocfc_stop(struct bfa_s *bfa)
         bfa->iocfc.action = BFA_IOCFC_ACT_STOP;
 
         bfa->queue_process = BFA_FALSE;
-        bfa_ioc_disable(&bfa->ioc);
+        bfa_dconf_modexit(bfa);
+        if (BFA_DCONF_MOD(bfa)->flashdone == BFA_TRUE)
+                bfa_ioc_disable(&bfa->ioc);
 }
 
 void
@@ -1540,10 +1539,17 @@ bfa_comp_process(struct bfa_s *bfa, struct list_head *comp_q)
         struct list_head                *qe;
         struct list_head                *qen;
         struct bfa_cb_qe_s      *hcb_qe;
+        bfa_cb_cbfn_status_t    cbfn;
 
         list_for_each_safe(qe, qen, comp_q) {
                 hcb_qe = (struct bfa_cb_qe_s *) qe;
-                hcb_qe->cbfn(hcb_qe->cbarg, BFA_TRUE);
+                if (hcb_qe->pre_rmv) {
+                        /* qe is invalid after return, dequeue before cbfn() */
+                        list_del(qe);
+                        cbfn = (bfa_cb_cbfn_status_t)(hcb_qe->cbfn);
+                        cbfn(hcb_qe->cbarg, hcb_qe->fw_status);
+                } else
+                        hcb_qe->cbfn(hcb_qe->cbarg, BFA_TRUE);
         }
 }
 
@@ -1556,10 +1562,20 @@ bfa_comp_free(struct bfa_s *bfa, struct list_head *comp_q)
         while (!list_empty(comp_q)) {
                 bfa_q_deq(comp_q, &qe);
                 hcb_qe = (struct bfa_cb_qe_s *) qe;
+                WARN_ON(hcb_qe->pre_rmv);
                 hcb_qe->cbfn(hcb_qe->cbarg, BFA_FALSE);
         }
 }
 
+void
+bfa_iocfc_cb_dconf_modinit(struct bfa_s *bfa, bfa_status_t status)
+{
+        if (bfa->iocfc.action == BFA_IOCFC_ACT_INIT) {
+                if (bfa->iocfc.cfgdone == BFA_TRUE)
+                        bfa_cb_queue(bfa, &bfa->iocfc.init_hcb_qe,
+                                bfa_iocfc_init_cb, bfa);
+        }
+}
 
 /*
  * Return the list of PCI vendor/device id lists supported by this
diff --git a/drivers/scsi/bfa/bfa_defs.h b/drivers/scsi/bfa/bfa_defs.h
index ed8d31b0188b..7b3d235d20b4 100644
--- a/drivers/scsi/bfa/bfa_defs.h
+++ b/drivers/scsi/bfa/bfa_defs.h
@@ -144,6 +144,7 @@ enum bfa_status {
         BFA_STATUS_INVLD_DFSZ   = 24,   /*  Invalid Max data field size */
         BFA_STATUS_CMD_NOTSUPP  = 26,   /*  Command/API not supported */
         BFA_STATUS_FABRIC_RJT   = 29,   /*  Reject from attached fabric */
+        BFA_STATUS_UNKNOWN_VWWN = 30,   /*  VPORT PWWN not found */
         BFA_STATUS_PORT_OFFLINE = 34,   /*  Port is not online */
         BFA_STATUS_VPORT_WWN_BP = 46,   /*  WWN is same as base port's WWN */
         BFA_STATUS_PORT_NOT_DISABLED = 47, /* Port not disabled disable port */
@@ -164,6 +165,8 @@ enum bfa_status {
         BFA_STATUS_INVALID_MAC  = 134, /*  Invalid MAC address */
         BFA_STATUS_PBC          = 154, /*  Operation not allowed for pre-boot
                                         *  configuration */
+        BFA_STATUS_BAD_FWCFG = 156,     /* Bad firmware configuration */
+        BFA_STATUS_INVALID_VENDOR = 158, /* Invalid switch vendor */
         BFA_STATUS_SFP_NOT_READY = 159, /* SFP info is not ready. Retry */
         BFA_STATUS_TRUNK_ENABLED = 164, /* Trunk is already enabled on
                                          * this adapter */
@@ -172,11 +175,15 @@ enum bfa_status {
         BFA_STATUS_IOPROFILE_OFF = 175, /* IO profile OFF */
         BFA_STATUS_PHY_NOT_PRESENT = 183, /* PHY module not present */
         BFA_STATUS_FEATURE_NOT_SUPPORTED = 192, /* Feature not supported */
+        BFA_STATUS_ENTRY_EXISTS = 193,  /* Entry already exists */
+        BFA_STATUS_ENTRY_NOT_EXISTS = 194, /* Entry does not exist */
+        BFA_STATUS_NO_CHANGE = 195,     /* Feature already in that state */
         BFA_STATUS_FAA_ENABLED = 197,   /* FAA is already enabled */
         BFA_STATUS_FAA_DISABLED = 198,  /* FAA is already disabled */
         BFA_STATUS_FAA_ACQUIRED = 199,  /* FAA is already acquired */
         BFA_STATUS_FAA_ACQ_ADDR = 200,  /* Acquiring addr */
         BFA_STATUS_ERROR_TRUNK_ENABLED = 203,   /* Trunk enabled on adapter */
+        BFA_STATUS_MAX_ENTRY_REACHED = 212,     /* MAX entry reached */
         BFA_STATUS_MAX_VAL              /* Unknown error code */
 };
 #define bfa_status_t enum bfa_status
@@ -359,6 +366,139 @@ struct bfa_ioc_attr_s {
 };
 
 /*
+ *                      AEN related definitions
+ */
+enum bfa_aen_category {
+        BFA_AEN_CAT_ADAPTER     = 1,
+        BFA_AEN_CAT_PORT        = 2,
+        BFA_AEN_CAT_LPORT       = 3,
+        BFA_AEN_CAT_RPORT       = 4,
+        BFA_AEN_CAT_ITNIM       = 5,
+        BFA_AEN_CAT_AUDIT       = 8,
+        BFA_AEN_CAT_IOC         = 9,
+};
+
+/* BFA adapter level events */
+enum bfa_adapter_aen_event {
+        BFA_ADAPTER_AEN_ADD     = 1,    /* New Adapter found event */
+        BFA_ADAPTER_AEN_REMOVE  = 2,    /* Adapter removed event */
+};
+
+struct bfa_adapter_aen_data_s {
+        char    serial_num[BFA_ADAPTER_SERIAL_NUM_LEN];
+        u32     nports; /* Number of NPorts */
+        wwn_t   pwwn;   /* WWN of one of its physical port */
+};
+
+/* BFA physical port Level events */
+enum bfa_port_aen_event {
+        BFA_PORT_AEN_ONLINE     = 1,    /* Physical Port online event */
+        BFA_PORT_AEN_OFFLINE    = 2,    /* Physical Port offline event */
+        BFA_PORT_AEN_RLIR       = 3,    /* RLIR event, not supported */
+        BFA_PORT_AEN_SFP_INSERT = 4,    /* SFP inserted event */
+        BFA_PORT_AEN_SFP_REMOVE = 5,    /* SFP removed event */
+        BFA_PORT_AEN_SFP_POM    = 6,    /* SFP POM event */
+        BFA_PORT_AEN_ENABLE     = 7,    /* Physical Port enable event */
+        BFA_PORT_AEN_DISABLE    = 8,    /* Physical Port disable event */
+        BFA_PORT_AEN_AUTH_ON    = 9,    /* Physical Port auth success event */
+        BFA_PORT_AEN_AUTH_OFF   = 10,   /* Physical Port auth fail event */
+        BFA_PORT_AEN_DISCONNECT = 11,   /* Physical Port disconnect event */
+        BFA_PORT_AEN_QOS_NEG    = 12,   /* Base Port QOS negotiation event */
+        BFA_PORT_AEN_FABRIC_NAME_CHANGE = 13, /* Fabric Name/WWN change */
+        BFA_PORT_AEN_SFP_ACCESS_ERROR   = 14, /* SFP read error event */
+        BFA_PORT_AEN_SFP_UNSUPPORT      = 15, /* Unsupported SFP event */
+};
+
+enum bfa_port_aen_sfp_pom {
+        BFA_PORT_AEN_SFP_POM_GREEN = 1, /* Normal */
+        BFA_PORT_AEN_SFP_POM_AMBER = 2, /* Warning */
+        BFA_PORT_AEN_SFP_POM_RED   = 3, /* Critical */
+        BFA_PORT_AEN_SFP_POM_MAX   = BFA_PORT_AEN_SFP_POM_RED
+};
+
+struct bfa_port_aen_data_s {
+        wwn_t           pwwn;           /* WWN of the physical port */
+        wwn_t           fwwn;           /* WWN of the fabric port */
+        u32             phy_port_num;   /* For SFP related events */
+        u16             ioc_type;
+        u16             level;          /* Only transitions will be informed */
+        mac_t           mac;            /* MAC address of the ethernet port */
+        u16             rsvd;
+};
+
+/* BFA AEN logical port events */
+enum bfa_lport_aen_event {
+        BFA_LPORT_AEN_NEW       = 1,            /* LPort created event */
+        BFA_LPORT_AEN_DELETE    = 2,            /* LPort deleted event */
+        BFA_LPORT_AEN_ONLINE    = 3,            /* LPort online event */
+        BFA_LPORT_AEN_OFFLINE   = 4,            /* LPort offline event */
+        BFA_LPORT_AEN_DISCONNECT = 5,           /* LPort disconnect event */
+        BFA_LPORT_AEN_NEW_PROP  = 6,            /* VPort created event */
+        BFA_LPORT_AEN_DELETE_PROP = 7,          /* VPort deleted event */
+        BFA_LPORT_AEN_NEW_STANDARD = 8,         /* VPort created event */
+        BFA_LPORT_AEN_DELETE_STANDARD = 9,      /* VPort deleted event */
+        BFA_LPORT_AEN_NPIV_DUP_WWN = 10,        /* VPort with duplicate WWN */
+        BFA_LPORT_AEN_NPIV_FABRIC_MAX = 11,     /* Max NPIV in fabric/fport */
+        BFA_LPORT_AEN_NPIV_UNKNOWN = 12,        /* Unknown NPIV Error code */
+};
+
+struct bfa_lport_aen_data_s {
+        u16     vf_id;  /* vf_id of this logical port */
+        u16     roles;  /* Logical port mode,IM/TM/IP etc */
+        u32     rsvd;
+        wwn_t   ppwwn;  /* WWN of its physical port */
+        wwn_t   lpwwn;  /* WWN of this logical port */
+};
+
+/* BFA ITNIM events */
+enum bfa_itnim_aen_event {
+        BFA_ITNIM_AEN_ONLINE     = 1,   /* Target online */
+        BFA_ITNIM_AEN_OFFLINE    = 2,   /* Target offline */
+        BFA_ITNIM_AEN_DISCONNECT = 3,   /* Target disconnected */
+};
+
+struct bfa_itnim_aen_data_s {
+        u16             vf_id;          /* vf_id of the IT nexus */
+        u16             rsvd[3];
+        wwn_t           ppwwn;          /* WWN of its physical port */
+        wwn_t           lpwwn;          /* WWN of logical port */
+        wwn_t           rpwwn;          /* WWN of remote(target) port */
+};
+
+/* BFA audit events */
+enum bfa_audit_aen_event {
+        BFA_AUDIT_AEN_AUTH_ENABLE       = 1,
+        BFA_AUDIT_AEN_AUTH_DISABLE      = 2,
+        BFA_AUDIT_AEN_FLASH_ERASE       = 3,
+        BFA_AUDIT_AEN_FLASH_UPDATE      = 4,
+};
+
+struct bfa_audit_aen_data_s {
+        wwn_t   pwwn;
+        int     partition_inst;
+        int     partition_type;
+};
+
+/* BFA IOC level events */
+enum bfa_ioc_aen_event {
+        BFA_IOC_AEN_HBGOOD  = 1,        /* Heart Beat restore event     */
+        BFA_IOC_AEN_HBFAIL  = 2,        /* Heart Beat failure event     */
+        BFA_IOC_AEN_ENABLE  = 3,        /* IOC enabled event            */
+        BFA_IOC_AEN_DISABLE = 4,        /* IOC disabled event           */
+        BFA_IOC_AEN_FWMISMATCH  = 5,    /* IOC firmware mismatch        */
+        BFA_IOC_AEN_FWCFG_ERROR = 6,    /* IOC firmware config error    */
+        BFA_IOC_AEN_INVALID_VENDOR = 7,
+        BFA_IOC_AEN_INVALID_NWWN = 8,   /* Zero NWWN                    */
+        BFA_IOC_AEN_INVALID_PWWN = 9    /* Zero PWWN                    */
+};
+
+struct bfa_ioc_aen_data_s {
+        wwn_t   pwwn;
+        u16     ioc_type;
+        mac_t   mac;
+};
+
+/*
  * ---------------------- mfg definitions ------------
  */
 
@@ -520,6 +660,20 @@ struct bfa_boot_bootlun_s {
 /*
  * BOOT boot configuraton
  */
+struct bfa_boot_cfg_s {
+        u8              version;
+        u8              rsvd1;
+        u16             chksum;
+        u8              enable;         /* enable/disable SAN boot */
+        u8              speed;          /* boot speed settings */
+        u8              topology;       /* boot topology setting */
+        u8              bootopt;        /* bfa_boot_bootopt_t */
+        u32             nbluns;         /* number of boot luns */
+        u32             rsvd2;
+        struct bfa_boot_bootlun_s blun[BFA_BOOT_BOOTLUN_MAX];
+        struct bfa_boot_bootlun_s blun_disc[BFA_BOOT_BOOTLUN_MAX];
+};
+
 struct bfa_boot_pbc_s {
         u8              enable;         /*  enable/disable SAN boot */
         u8              speed;          /*  boot speed settings */
@@ -529,6 +683,15 @@ struct bfa_boot_pbc_s {
         struct bfa_boot_bootlun_s pblun[BFA_PREBOOT_BOOTLUN_MAX];
 };
 
+struct bfa_ethboot_cfg_s {
+        u8              version;
+        u8              rsvd1;
+        u16             chksum;
+        u8              enable; /* enable/disable Eth/PXE boot */
+        u8              rsvd2;
+        u16             vlan;
+};
+
 /*
  * ASIC block configuration related structures
  */
@@ -587,6 +750,14 @@ struct bfa_ablk_cfg_s {
  */
 #define SFP_DIAGMON_SIZE        10 /* num bytes of diag monitor data */
 
+/* SFP state change notification event */
+#define BFA_SFP_SCN_REMOVED     0
+#define BFA_SFP_SCN_INSERTED    1
+#define BFA_SFP_SCN_POM         2
+#define BFA_SFP_SCN_FAILED      3
+#define BFA_SFP_SCN_UNSUPPORT   4
+#define BFA_SFP_SCN_VALID       5
+
 enum bfa_defs_sfp_media_e {
         BFA_SFP_MEDIA_UNKNOWN   = 0x00,
         BFA_SFP_MEDIA_CU        = 0x01,
diff --git a/drivers/scsi/bfa/bfa_defs_svc.h b/drivers/scsi/bfa/bfa_defs_svc.h
index 0b97525803fb..863c6ba7d5eb 100644
--- a/drivers/scsi/bfa/bfa_defs_svc.h
+++ b/drivers/scsi/bfa/bfa_defs_svc.h
@@ -268,6 +268,7 @@ struct bfa_fw_port_snsm_stats_s {
     u32    error_resets;       /*  error resets initiated by upsm      */
     u32    sync_lost;          /*  Sync loss count                     */
     u32    sig_lost;           /*  Signal loss count                   */
+        u32     asn8g_attempts; /* SNSM HWSM at 8Gbps attempts */
 };
 
 struct bfa_fw_port_physm_stats_s {
@@ -468,6 +469,7 @@ struct bfa_fw_stats_s {
  * QoS states
  */
 enum bfa_qos_state {
+        BFA_QOS_DISABLED = 0,           /* QoS is disabled */
         BFA_QOS_ONLINE = 1,             /*  QoS is online */
         BFA_QOS_OFFLINE = 2,            /*  QoS is offline */
 };
@@ -670,6 +672,12 @@ struct bfa_itnim_iostats_s {
         u32     tm_iocdowns;            /*  TM cleaned-up due to IOC down   */
         u32     tm_cleanups;            /*  TM cleanup requests */
         u32     tm_cleanup_comps;       /*  TM cleanup completions      */
+        u32     lm_lun_across_sg;       /*  LM lun is across sg data buf */
+        u32     lm_lun_not_sup;         /*  LM lun not supported */
+        u32     lm_rpl_data_changed;    /*  LM report-lun data changed */
+        u32     lm_wire_residue_changed; /* LM report-lun rsp residue changed */
+        u32     lm_small_buf_addresidue; /* LM buf smaller than reported cnt */
+        u32     lm_lun_not_rdy;         /* LM lun not ready */
 };
 
 /* Modify char* port_stt[] in bfal_port.c if a new state was added */
@@ -785,8 +793,51 @@ enum bfa_port_linkstate_rsn {
         CEE_ISCSI_PRI_PFC_OFF                   = 42,
         CEE_ISCSI_PRI_OVERLAP_FCOE_PRI          = 43
 };
+
+#define MAX_LUN_MASK_CFG 16
+
+/*
+ * Initially flash content may be fff. On making LUN mask enable and disable
+ * state chnage.  when report lun command is being processed it goes from
+ * BFA_LUN_MASK_ACTIVE to BFA_LUN_MASK_FETCH and comes back to
+ * BFA_LUN_MASK_ACTIVE.
+ */
+enum bfa_ioim_lun_mask_state_s {
+        BFA_IOIM_LUN_MASK_INACTIVE = 0,
+        BFA_IOIM_LUN_MASK_ACTIVE = 1,
+        BFA_IOIM_LUN_MASK_FETCHED = 2,
+};
+
+enum bfa_lunmask_state_s {
+        BFA_LUNMASK_DISABLED = 0x00,
+        BFA_LUNMASK_ENABLED = 0x01,
+        BFA_LUNMASK_MINCFG = 0x02,
+        BFA_LUNMASK_UNINITIALIZED = 0xff,
+};
+
 #pragma pack(1)
 /*
+ * LUN mask configuration
+ */
+struct bfa_lun_mask_s {
+        wwn_t           lp_wwn;
+        wwn_t           rp_wwn;
+        struct scsi_lun lun;
+        u8              ua;
+        u8              rsvd[3];
+        u16             rp_tag;
+        u8              lp_tag;
+        u8              state;
+};
+
+#define MAX_LUN_MASK_CFG 16
+struct bfa_lunmask_cfg_s {
+        u32     status;
+        u32     rsvd;
+        struct bfa_lun_mask_s   lun_list[MAX_LUN_MASK_CFG];
+};
+
+/*
  *      Physical port configuration
  */
 struct bfa_port_cfg_s {
@@ -1228,4 +1279,52 @@ struct bfa_cee_stats_s {
 
 #pragma pack()
 
+/*
+ *                      AEN related definitions
+ */
+#define BFAD_NL_VENDOR_ID (((u64)0x01 << SCSI_NL_VID_TYPE_SHIFT) \
+                           | BFA_PCI_VENDOR_ID_BROCADE)
+
+/* BFA remote port events */
+enum bfa_rport_aen_event {
+        BFA_RPORT_AEN_ONLINE     = 1,   /* RPort online event */
+        BFA_RPORT_AEN_OFFLINE    = 2,   /* RPort offline event */
+        BFA_RPORT_AEN_DISCONNECT = 3,   /* RPort disconnect event */
+        BFA_RPORT_AEN_QOS_PRIO   = 4,   /* QOS priority change event */
+        BFA_RPORT_AEN_QOS_FLOWID = 5,   /* QOS flow Id change event */
+};
+
+struct bfa_rport_aen_data_s {
+        u16             vf_id;  /* vf_id of this logical port */
+        u16             rsvd[3];
+        wwn_t           ppwwn;  /* WWN of its physical port */
+        wwn_t           lpwwn;  /* WWN of this logical port */
+        wwn_t           rpwwn;  /* WWN of this remote port */
+        union {
+                struct bfa_rport_qos_attr_s qos;
+        } priv;
+};
+
+union bfa_aen_data_u {
+        struct bfa_adapter_aen_data_s   adapter;
+        struct bfa_port_aen_data_s      port;
+        struct bfa_lport_aen_data_s     lport;
+        struct bfa_rport_aen_data_s     rport;
+        struct bfa_itnim_aen_data_s     itnim;
+        struct bfa_audit_aen_data_s     audit;
+        struct bfa_ioc_aen_data_s       ioc;
+};
+
+#define BFA_AEN_MAX_ENTRY       512
+
+struct bfa_aen_entry_s {
+        struct list_head        qe;
+        enum bfa_aen_category   aen_category;
+        u32                     aen_type;
+        union bfa_aen_data_u    aen_data;
+        struct timeval          aen_tv;
+        u32                     seq_num;
+        u32                     bfad_num;
+};
+
 #endif /* __BFA_DEFS_SVC_H__ */
diff --git a/drivers/scsi/bfa/bfa_fc.h b/drivers/scsi/bfa/bfa_fc.h
index 8d0b88f67a38..50b6a1c86195 100644
--- a/drivers/scsi/bfa/bfa_fc.h
+++ b/drivers/scsi/bfa/bfa_fc.h
@@ -56,6 +56,161 @@ struct scsi_cdb_s {
 
 #define SCSI_MAX_ALLOC_LEN      0xFF    /* maximum allocarion length */
 
+#define SCSI_SENSE_CUR_ERR      0x70
+#define SCSI_SENSE_DEF_ERR      0x71
+
+/*
+ * SCSI additional sense codes
+ */
+#define SCSI_ASC_LUN_NOT_READY          0x04
+#define SCSI_ASC_LUN_NOT_SUPPORTED      0x25
+#define SCSI_ASC_TOCC                   0x3F
+
+/*
+ * SCSI additional sense code qualifiers
+ */
+#define SCSI_ASCQ_MAN_INTR_REQ          0x03    /* manual intervention req */
+#define SCSI_ASCQ_RL_DATA_CHANGED       0x0E    /* report luns data changed */
+
+/*
+ * Methods of reporting informational exceptions
+ */
+#define SCSI_MP_IEC_UNIT_ATTN           0x2     /* generate unit attention */
+
+struct scsi_report_luns_data_s {
+        u32             lun_list_length;        /* length of LUN list length */
+        u32             reserved;
+        struct scsi_lun lun[1];                 /* first LUN in lun list */
+};
+
+struct scsi_inquiry_vendor_s {
+        u8      vendor_id[8];
+};
+
+struct scsi_inquiry_prodid_s {
+        u8      product_id[16];
+};
+
+struct scsi_inquiry_prodrev_s {
+        u8      product_rev[4];
+};
+
+struct scsi_inquiry_data_s {
+#ifdef __BIG_ENDIAN
+        u8              peripheral_qual:3;      /* peripheral qualifier */
+        u8              device_type:5;          /* peripheral device type */
+        u8              rmb:1;                  /* removable medium bit */
+        u8              device_type_mod:7;      /* device type modifier */
+        u8              version;
+        u8              aenc:1;         /* async evt notification capability */
+        u8              trm_iop:1;      /* terminate I/O process */
+        u8              norm_aca:1;     /* normal ACA supported */
+        u8              hi_support:1;   /* SCSI-3: supports REPORT LUNS */
+        u8              rsp_data_format:4;
+        u8              additional_len;
+        u8              sccs:1;
+        u8              reserved1:7;
+        u8              reserved2:1;
+        u8              enc_serv:1;     /* enclosure service component */
+        u8              reserved3:1;
+        u8              multi_port:1;   /* multi-port device */
+        u8              m_chngr:1;      /* device in medium transport element */
+        u8              ack_req_q:1;    /* SIP specific bit */
+        u8              addr32:1;       /* SIP specific bit */
+        u8              addr16:1;       /* SIP specific bit */
+        u8              rel_adr:1;      /* relative address */
+        u8              w_bus32:1;
+        u8              w_bus16:1;
+        u8              synchronous:1;
+        u8              linked_commands:1;
+        u8              trans_dis:1;
+        u8              cmd_queue:1;    /* command queueing supported */
+        u8              soft_reset:1;   /* soft reset alternative (VS) */
+#else
+        u8              device_type:5;  /* peripheral device type */
+        u8              peripheral_qual:3; /* peripheral qualifier */
+        u8              device_type_mod:7; /* device type modifier */
+        u8              rmb:1;          /* removable medium bit */
+        u8              version;
+        u8              rsp_data_format:4;
+        u8              hi_support:1;   /* SCSI-3: supports REPORT LUNS */
+        u8              norm_aca:1;     /* normal ACA supported */
+        u8              terminate_iop:1;/* terminate I/O process */
+        u8              aenc:1;         /* async evt notification capability */
+        u8              additional_len;
+        u8              reserved1:7;
+        u8              sccs:1;
+        u8              addr16:1;       /* SIP specific bit */
+        u8              addr32:1;       /* SIP specific bit */
+        u8              ack_req_q:1;    /* SIP specific bit */
+        u8              m_chngr:1;      /* device in medium transport element */
+        u8              multi_port:1;   /* multi-port device */
+        u8              reserved3:1;    /* TBD - Vendor Specific */
+        u8              enc_serv:1;     /* enclosure service component */
+        u8              reserved2:1;
+        u8              soft_seset:1;   /* soft reset alternative (VS) */
+        u8              cmd_queue:1;    /* command queueing supported */
+        u8              trans_dis:1;
+        u8              linked_commands:1;
+        u8              synchronous:1;
+        u8              w_bus16:1;
+        u8              w_bus32:1;
+        u8              rel_adr:1;      /* relative address */
+#endif
+        struct scsi_inquiry_vendor_s    vendor_id;
+        struct scsi_inquiry_prodid_s    product_id;
+        struct scsi_inquiry_prodrev_s   product_rev;
+        u8              vendor_specific[20];
+        u8              reserved4[40];
+};
+
+/*
+ *      SCSI sense data format
+ */
+struct scsi_sense_s {
+#ifdef __BIG_ENDIAN
+        u8              valid:1;
+        u8              rsp_code:7;
+#else
+        u8              rsp_code:7;
+        u8              valid:1;
+#endif
+        u8              seg_num;
+#ifdef __BIG_ENDIAN
+        u8              file_mark:1;
+        u8              eom:1;          /* end of media */
+        u8              ili:1;          /* incorrect length indicator */
+        u8              reserved:1;
+        u8              sense_key:4;
+#else
+        u8              sense_key:4;
+        u8              reserved:1;
+        u8              ili:1;          /* incorrect length indicator */
+        u8              eom:1;          /* end of media */
+        u8              file_mark:1;
+#endif
+        u8              information[4]; /* device-type or cmd specific info */
+        u8              add_sense_length; /* additional sense length */
+        u8              command_info[4];/* command specific information */
+        u8              asc;            /* additional sense code */
+        u8              ascq;           /* additional sense code qualifier */
+        u8              fru_code;       /* field replaceable unit code */
+#ifdef __BIG_ENDIAN
+        u8              sksv:1;         /* sense key specific valid */
+        u8              c_d:1;          /* command/data bit */
+        u8              res1:2;
+        u8              bpv:1;          /* bit pointer valid */
+        u8              bpointer:3;     /* bit pointer */
+#else
+        u8              bpointer:3;     /* bit pointer */
+        u8              bpv:1;          /* bit pointer valid */
+        u8              res1:2;
+        u8              c_d:1;          /* command/data bit */
+        u8              sksv:1;         /* sense key specific valid */
+#endif
+        u8              fpointer[2];    /* field pointer */
+};
+
 /*
  * Fibre Channel Header Structure (FCHS) definition
  */
diff --git a/drivers/scsi/bfa/bfa_fcpim.c b/drivers/scsi/bfa/bfa_fcpim.c
index a4e7951c6063..e07bd4745d8b 100644
--- a/drivers/scsi/bfa/bfa_fcpim.c
+++ b/drivers/scsi/bfa/bfa_fcpim.c
@@ -24,6 +24,9 @@ BFA_TRC_FILE(HAL, FCPIM);
  *  BFA ITNIM Related definitions
  */
 static void bfa_itnim_update_del_itn_stats(struct bfa_itnim_s *itnim);
+static bfa_boolean_t bfa_ioim_lm_proc_rpl_data(struct bfa_ioim_s *ioim);
+static bfa_boolean_t bfa_ioim_lm_proc_inq_data(struct bfa_ioim_s *ioim);
+static void bfa_ioim_lm_init(struct bfa_s *bfa);
 
 #define BFA_ITNIM_FROM_TAG(_fcpim, _tag)                                \
         (((_fcpim)->itnim_arr + ((_tag) & ((_fcpim)->num_itnims - 1))))
@@ -57,6 +60,14 @@ static void bfa_itnim_update_del_itn_stats(struct bfa_itnim_s *itnim);
         }                                                               \
 } while (0)
 
+#define bfa_ioim_rp_wwn(__ioim)                                         \
+        (((struct bfa_fcs_rport_s *)                                    \
+         (__ioim)->itnim->rport->rport_drv)->pwwn)
+
+#define bfa_ioim_lp_wwn(__ioim)                                         \
+        ((BFA_LPS_FROM_TAG(BFA_LPS_MOD((__ioim)->bfa),                  \
+        (__ioim)->itnim->rport->rport_info.lp_tag))->pwwn)              \
+
 #define bfa_itnim_sler_cb(__itnim) do {                                 \
         if ((__itnim)->bfa->fcs)                                        \
                 bfa_cb_itnim_sler((__itnim)->ditn);      \
@@ -66,6 +77,18 @@ static void bfa_itnim_update_del_itn_stats(struct bfa_itnim_s *itnim);
         }                                                               \
 } while (0)
 
+enum bfa_ioim_lm_status {
+        BFA_IOIM_LM_PRESENT = 1,
+        BFA_IOIM_LM_LUN_NOT_SUP = 2,
+        BFA_IOIM_LM_RPL_DATA_CHANGED = 3,
+        BFA_IOIM_LM_LUN_NOT_RDY = 4,
+};
+
+enum bfa_ioim_lm_ua_status {
+        BFA_IOIM_LM_UA_RESET = 0,
+        BFA_IOIM_LM_UA_SET = 1,
+};
+
 /*
  *  itnim state machine event
  */
@@ -122,6 +145,9 @@ enum bfa_ioim_event {
         BFA_IOIM_SM_TMDONE      = 16,   /*  IO cleanup from tskim */
         BFA_IOIM_SM_HWFAIL      = 17,   /*  IOC h/w failure event */
         BFA_IOIM_SM_IOTOV       = 18,   /*  ITN offline TOV */
+        BFA_IOIM_SM_LM_LUN_NOT_SUP = 19,/*  lunmask lun not supported */
+        BFA_IOIM_SM_LM_RPL_DC = 20,     /*  lunmask report-lun data changed */
+        BFA_IOIM_SM_LM_LUN_NOT_RDY = 21,/*  lunmask lun not ready */
 };
 
 
@@ -219,6 +245,9 @@ static void __bfa_cb_ioim_abort(void *cbarg, bfa_boolean_t complete);
 static void __bfa_cb_ioim_failed(void *cbarg, bfa_boolean_t complete);
 static void __bfa_cb_ioim_pathtov(void *cbarg, bfa_boolean_t complete);
 static bfa_boolean_t    bfa_ioim_is_abortable(struct bfa_ioim_s *ioim);
+static void __bfa_cb_ioim_lm_lun_not_sup(void *cbarg, bfa_boolean_t complete);
+static void __bfa_cb_ioim_lm_rpl_dc(void *cbarg, bfa_boolean_t complete);
+static void __bfa_cb_ioim_lm_lun_not_rdy(void *cbarg, bfa_boolean_t complete);
 
 /*
  * forward declaration of BFA IO state machine
@@ -416,6 +445,12 @@ bfa_fcpim_add_stats(struct bfa_itnim_iostats_s *lstats,
         bfa_fcpim_add_iostats(lstats, rstats, output_reqs);
         bfa_fcpim_add_iostats(lstats, rstats, rd_throughput);
         bfa_fcpim_add_iostats(lstats, rstats, wr_throughput);
+        bfa_fcpim_add_iostats(lstats, rstats, lm_lun_across_sg);
+        bfa_fcpim_add_iostats(lstats, rstats, lm_lun_not_sup);
+        bfa_fcpim_add_iostats(lstats, rstats, lm_rpl_data_changed);
+        bfa_fcpim_add_iostats(lstats, rstats, lm_wire_residue_changed);
+        bfa_fcpim_add_iostats(lstats, rstats, lm_small_buf_addresidue);
+        bfa_fcpim_add_iostats(lstats, rstats, lm_lun_not_rdy);
 }
 
 bfa_status_t
@@ -437,6 +472,59 @@ bfa_fcpim_port_iostats(struct bfa_s *bfa,
         return BFA_STATUS_OK;
 }
 
+void
+bfa_ioim_profile_comp(struct bfa_ioim_s *ioim)
+{
+        struct bfa_itnim_latency_s *io_lat =
+                        &(ioim->itnim->ioprofile.io_latency);
+        u32 val, idx;
+
+        val = (u32)(jiffies - ioim->start_time);
+        idx = bfa_ioim_get_index(scsi_bufflen((struct scsi_cmnd *)ioim->dio));
+        bfa_itnim_ioprofile_update(ioim->itnim, idx);
+
+        io_lat->count[idx]++;
+        io_lat->min[idx] = (io_lat->min[idx] < val) ? io_lat->min[idx] : val;
+        io_lat->max[idx] = (io_lat->max[idx] > val) ? io_lat->max[idx] : val;
+        io_lat->avg[idx] += val;
+}
+
+void
+bfa_ioim_profile_start(struct bfa_ioim_s *ioim)
+{
+        ioim->start_time = jiffies;
+}
+
+bfa_status_t
+bfa_fcpim_profile_on(struct bfa_s *bfa, u32 time)
+{
+        struct bfa_itnim_s *itnim;
+        struct bfa_fcpim_s *fcpim = BFA_FCPIM(bfa);
+        struct list_head *qe, *qen;
+
+        /* accumulate IO stats from itnim */
+        list_for_each_safe(qe, qen, &fcpim->itnim_q) {
+                itnim = (struct bfa_itnim_s *) qe;
+                bfa_itnim_clear_stats(itnim);
+        }
+        fcpim->io_profile = BFA_TRUE;
+        fcpim->io_profile_start_time = time;
+        fcpim->profile_comp = bfa_ioim_profile_comp;
+        fcpim->profile_start = bfa_ioim_profile_start;
+        return BFA_STATUS_OK;
+}
+
+bfa_status_t
+bfa_fcpim_profile_off(struct bfa_s *bfa)
+{
+        struct bfa_fcpim_s *fcpim = BFA_FCPIM(bfa);
+        fcpim->io_profile = BFA_FALSE;
+        fcpim->io_profile_start_time = 0;
+        fcpim->profile_comp = NULL;
+        fcpim->profile_start = NULL;
+        return BFA_STATUS_OK;
+}
+
 u16
 bfa_fcpim_qdepth_get(struct bfa_s *bfa)
 {
@@ -1401,6 +1489,26 @@ bfa_itnim_hold_io(struct bfa_itnim_s *itnim)
                  bfa_sm_cmp_state(itnim, bfa_itnim_sm_iocdisable));
 }
 
+#define bfa_io_lat_clock_res_div        HZ
+#define bfa_io_lat_clock_res_mul        1000
+bfa_status_t
+bfa_itnim_get_ioprofile(struct bfa_itnim_s *itnim,
+                        struct bfa_itnim_ioprofile_s *ioprofile)
+{
+        struct bfa_fcpim_s *fcpim = BFA_FCPIM(itnim->bfa);
+        if (!fcpim->io_profile)
+                return BFA_STATUS_IOPROFILE_OFF;
+
+        itnim->ioprofile.index = BFA_IOBUCKET_MAX;
+        itnim->ioprofile.io_profile_start_time =
+                                bfa_io_profile_start_time(itnim->bfa);
+        itnim->ioprofile.clock_res_mul = bfa_io_lat_clock_res_mul;
+        itnim->ioprofile.clock_res_div = bfa_io_lat_clock_res_div;
+        *ioprofile = itnim->ioprofile;
+
+        return BFA_STATUS_OK;
+}
+
 void
 bfa_itnim_clear_stats(struct bfa_itnim_s *itnim)
 {
@@ -1469,7 +1577,28 @@ bfa_ioim_sm_uninit(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
                 WARN_ON(!bfa_q_is_on_q(&ioim->itnim->pending_q, ioim));
                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe,
-                                __bfa_cb_ioim_abort, ioim);
+                        __bfa_cb_ioim_abort, ioim);
+                break;
+
+        case BFA_IOIM_SM_LM_LUN_NOT_SUP:
+                bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
+                bfa_ioim_move_to_comp_q(ioim);
+                bfa_cb_queue(ioim->bfa, &ioim->hcb_qe,
+                        __bfa_cb_ioim_lm_lun_not_sup, ioim);
+                break;
+
+        case BFA_IOIM_SM_LM_RPL_DC:
+                bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
+                bfa_ioim_move_to_comp_q(ioim);
+                bfa_cb_queue(ioim->bfa, &ioim->hcb_qe,
+                                __bfa_cb_ioim_lm_rpl_dc, ioim);
+                break;
+
+        case BFA_IOIM_SM_LM_LUN_NOT_RDY:
+                bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
+                bfa_ioim_move_to_comp_q(ioim);
+                bfa_cb_queue(ioim->bfa, &ioim->hcb_qe,
+                        __bfa_cb_ioim_lm_lun_not_rdy, ioim);
                 break;
 
         default:
@@ -2009,6 +2138,264 @@ bfa_ioim_sm_resfree(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
         }
 }
 
+/*
+ * This is called from bfa_fcpim_start after the bfa_init() with flash read
+ * is complete by driver. now invalidate the stale content of lun mask
+ * like unit attention, rp tag and lp tag.
+ */
+static void
+bfa_ioim_lm_init(struct bfa_s *bfa)
+{
+        struct bfa_lun_mask_s *lunm_list;
+        int     i;
+
+        if (bfa_get_lun_mask_status(bfa) == BFA_LUNMASK_MINCFG)
+                return;
+
+        lunm_list = bfa_get_lun_mask_list(bfa);
+        for (i = 0; i < MAX_LUN_MASK_CFG; i++) {
+                lunm_list[i].ua = BFA_IOIM_LM_UA_RESET;
+                lunm_list[i].lp_tag = BFA_LP_TAG_INVALID;
+                lunm_list[i].rp_tag = BFA_RPORT_TAG_INVALID;
+        }
+}
+
+/*
+ * Validate LUN for LUN masking
+ */
+static enum bfa_ioim_lm_status
+bfa_ioim_lm_check(struct bfa_ioim_s *ioim, struct bfa_lps_s *lps,
+                struct bfa_rport_s *rp, struct scsi_lun lun)
+{
+        u8 i;
+        struct bfa_lun_mask_s *lun_list = bfa_get_lun_mask_list(ioim->bfa);
+        struct scsi_cmnd *cmnd = (struct scsi_cmnd *)ioim->dio;
+        struct scsi_cdb_s *cdb = (struct scsi_cdb_s *)cmnd->cmnd;
+
+        if ((cdb->scsi_cdb[0] == REPORT_LUNS) &&
+            (scsilun_to_int((struct scsi_lun *)&lun) == 0)) {
+                ioim->proc_rsp_data = bfa_ioim_lm_proc_rpl_data;
+                return BFA_IOIM_LM_PRESENT;
+        }
+
+        for (i = 0; i < MAX_LUN_MASK_CFG; i++) {
+
+                if (lun_list[i].state != BFA_IOIM_LUN_MASK_ACTIVE)
+                        continue;
+
+                if ((scsilun_to_int((struct scsi_lun *)&lun_list[i].lun) ==
+                    scsilun_to_int((struct scsi_lun *)&lun))
+                    && (rp->rport_tag == lun_list[i].rp_tag)
+                    && ((u8)ioim->itnim->rport->rport_info.lp_tag ==
+                                                lun_list[i].lp_tag)) {
+                        bfa_trc(ioim->bfa, lun_list[i].rp_tag);
+                        bfa_trc(ioim->bfa, lun_list[i].lp_tag);
+                        bfa_trc(ioim->bfa, scsilun_to_int(
+                                (struct scsi_lun *)&lun_list[i].lun));
+
+                        if ((lun_list[i].ua == BFA_IOIM_LM_UA_SET) &&
+                            ((cdb->scsi_cdb[0] != INQUIRY) ||
+                            (cdb->scsi_cdb[0] != REPORT_LUNS))) {
+                                lun_list[i].ua = BFA_IOIM_LM_UA_RESET;
+                                return BFA_IOIM_LM_RPL_DATA_CHANGED;
+                        }
+
+                        if (cdb->scsi_cdb[0] == REPORT_LUNS)
+                                ioim->proc_rsp_data = bfa_ioim_lm_proc_rpl_data;
+
+                        return BFA_IOIM_LM_PRESENT;
+                }
+        }
+
+        if ((cdb->scsi_cdb[0] == INQUIRY) &&
+            (scsilun_to_int((struct scsi_lun *)&lun) == 0)) {
+                ioim->proc_rsp_data = bfa_ioim_lm_proc_inq_data;
+                return BFA_IOIM_LM_PRESENT;
+        }
+
+        if (cdb->scsi_cdb[0] == TEST_UNIT_READY)
+                return BFA_IOIM_LM_LUN_NOT_RDY;
+
+        return BFA_IOIM_LM_LUN_NOT_SUP;
+}
+
+static bfa_boolean_t
+bfa_ioim_lm_proc_rsp_data_dummy(struct bfa_ioim_s *ioim)
+{
+        return BFA_TRUE;
+}
+
+static void
+bfa_ioim_lm_fetch_lun(struct bfa_ioim_s *ioim, u8 *rl_data, int offset,
+                int buf_lun_cnt)
+{
+        struct bfa_lun_mask_s *lun_list = bfa_get_lun_mask_list(ioim->bfa);
+        struct scsi_lun *lun_data = (struct scsi_lun *)(rl_data + offset);
+        struct scsi_lun lun;
+        int i, j;
+
+        bfa_trc(ioim->bfa, buf_lun_cnt);
+        for (j = 0; j < buf_lun_cnt; j++) {
+                lun = *((struct scsi_lun *)(lun_data + j));
+                for (i = 0; i < MAX_LUN_MASK_CFG; i++) {
+                        if (lun_list[i].state != BFA_IOIM_LUN_MASK_ACTIVE)
+                                continue;
+                        if ((lun_list[i].rp_wwn == bfa_ioim_rp_wwn(ioim)) &&
+                            (lun_list[i].lp_wwn == bfa_ioim_lp_wwn(ioim)) &&
+                            (scsilun_to_int((struct scsi_lun *)&lun_list[i].lun)
+                                == scsilun_to_int((struct scsi_lun *)&lun))) {
+                                lun_list[i].state = BFA_IOIM_LUN_MASK_FETCHED;
+                                break;
+                        }
+                } /* next lun in mask DB */
+        } /* next lun in buf */
+}
+
+static int
+bfa_ioim_lm_update_lun_sg(struct bfa_ioim_s *ioim, u32 *pgdlen,
+                struct scsi_report_luns_data_s *rl)
+{
+        struct scsi_cmnd *cmnd = (struct scsi_cmnd *)ioim->dio;
+        struct scatterlist *sg = scsi_sglist(cmnd);
+        struct bfa_lun_mask_s *lun_list = bfa_get_lun_mask_list(ioim->bfa);
+        struct scsi_lun *prev_rl_data = NULL, *base_rl_data;
+        int i, j, sgeid, lun_fetched_cnt = 0, prev_sg_len = 0, base_count;
+        int lun_across_sg_bytes, bytes_from_next_buf;
+        u64     last_lun, temp_last_lun;
+
+        /* fetch luns from the first sg element */
+        bfa_ioim_lm_fetch_lun(ioim, (u8 *)(rl->lun), 0,
+                        (sg_dma_len(sg) / sizeof(struct scsi_lun)) - 1);
+
+        /* fetch luns from multiple sg elements */
+        scsi_for_each_sg(cmnd, sg, scsi_sg_count(cmnd), sgeid) {
+                if (sgeid == 0) {
+                        prev_sg_len = sg_dma_len(sg);
+                        prev_rl_data = (struct scsi_lun *)
+                                        phys_to_virt(sg_dma_address(sg));
+                        continue;
+                }
+
+                /* if the buf is having more data */
+                lun_across_sg_bytes = prev_sg_len % sizeof(struct scsi_lun);
+                if (lun_across_sg_bytes) {
+                        bfa_trc(ioim->bfa, lun_across_sg_bytes);
+                        bfa_stats(ioim->itnim, lm_lun_across_sg);
+                        bytes_from_next_buf = sizeof(struct scsi_lun) -
+                                              lun_across_sg_bytes;
+
+                        /* from next buf take higher bytes */
+                        temp_last_lun = *((u64 *)
+                                          phys_to_virt(sg_dma_address(sg)));
+                        last_lun |= temp_last_lun >>
+                                    (lun_across_sg_bytes * BITS_PER_BYTE);
+
+                        /* from prev buf take higher bytes */
+                        temp_last_lun = *((u64 *)(prev_rl_data +
+                                          (prev_sg_len - lun_across_sg_bytes)));
+                        temp_last_lun >>= bytes_from_next_buf * BITS_PER_BYTE;
+                        last_lun = last_lun | (temp_last_lun <<
+                                   (bytes_from_next_buf * BITS_PER_BYTE));
+
+                        bfa_ioim_lm_fetch_lun(ioim, (u8 *)&last_lun, 0, 1);
+                } else
+                        bytes_from_next_buf = 0;
+
+                *pgdlen += sg_dma_len(sg);
+                prev_sg_len = sg_dma_len(sg);
+                prev_rl_data = (struct scsi_lun *)
+                                phys_to_virt(sg_dma_address(sg));
+                bfa_ioim_lm_fetch_lun(ioim, (u8 *)prev_rl_data,
+                                bytes_from_next_buf,
+                                sg_dma_len(sg) / sizeof(struct scsi_lun));
+        }
+
+        /* update the report luns data - based on fetched luns */
+        sg = scsi_sglist(cmnd);
+        base_rl_data = (struct scsi_lun *)rl->lun;
+        base_count = (sg_dma_len(sg) / sizeof(struct scsi_lun)) - 1;
+        for (i = 0, j = 0; i < MAX_LUN_MASK_CFG; i++) {
+                if (lun_list[i].state == BFA_IOIM_LUN_MASK_FETCHED) {
+                        base_rl_data[j] = lun_list[i].lun;
+                        lun_list[i].state = BFA_IOIM_LUN_MASK_ACTIVE;
+                        j++;
+                        lun_fetched_cnt++;
+                }
+
+                if (j > base_count) {
+                        j = 0;
+                        sg = sg_next(sg);
+                        base_rl_data = (struct scsi_lun *)
+                                        phys_to_virt(sg_dma_address(sg));
+                        base_count = sg_dma_len(sg) / sizeof(struct scsi_lun);
+                }
+        }
+
+        bfa_trc(ioim->bfa, lun_fetched_cnt);
+        return lun_fetched_cnt;
+}
+
+static bfa_boolean_t
+bfa_ioim_lm_proc_inq_data(struct bfa_ioim_s *ioim)
+{
+        struct scsi_inquiry_data_s *inq;
+        struct scatterlist *sg = scsi_sglist((struct scsi_cmnd *)ioim->dio);
+
+        ioim->proc_rsp_data = bfa_ioim_lm_proc_rsp_data_dummy;
+        inq = (struct scsi_inquiry_data_s *)phys_to_virt(sg_dma_address(sg));
+
+        bfa_trc(ioim->bfa, inq->device_type);
+        inq->peripheral_qual = SCSI_INQ_PQ_NOT_CON;
+        return 0;
+}
+
+static bfa_boolean_t
+bfa_ioim_lm_proc_rpl_data(struct bfa_ioim_s *ioim)
+{
+        struct scsi_cmnd *cmnd = (struct scsi_cmnd *)ioim->dio;
+        struct scatterlist *sg = scsi_sglist(cmnd);
+        struct bfi_ioim_rsp_s *m;
+        struct scsi_report_luns_data_s *rl = NULL;
+        int lun_count = 0, lun_fetched_cnt = 0;
+        u32 residue, pgdlen = 0;
+
+        ioim->proc_rsp_data = bfa_ioim_lm_proc_rsp_data_dummy;
+        if (bfa_get_lun_mask_status(ioim->bfa) != BFA_LUNMASK_ENABLED)
+                return BFA_TRUE;
+
+        m = (struct bfi_ioim_rsp_s *) &ioim->iosp->comp_rspmsg;
+        if (m->scsi_status == SCSI_STATUS_CHECK_CONDITION)
+                return BFA_TRUE;
+
+        pgdlen = sg_dma_len(sg);
+        bfa_trc(ioim->bfa, pgdlen);
+        rl = (struct scsi_report_luns_data_s *)phys_to_virt(sg_dma_address(sg));
+        lun_count = cpu_to_be32(rl->lun_list_length) / sizeof(struct scsi_lun);
+        lun_fetched_cnt = bfa_ioim_lm_update_lun_sg(ioim, &pgdlen, rl);
+
+        if (lun_count == lun_fetched_cnt)
+                return BFA_TRUE;
+
+        bfa_trc(ioim->bfa, lun_count);
+        bfa_trc(ioim->bfa, lun_fetched_cnt);
+        bfa_trc(ioim->bfa, be32_to_cpu(rl->lun_list_length));
+
+        if (be32_to_cpu(rl->lun_list_length) <= pgdlen)
+                rl->lun_list_length = be32_to_cpu(lun_fetched_cnt) *
+                                      sizeof(struct scsi_lun);
+        else
+                bfa_stats(ioim->itnim, lm_small_buf_addresidue);
+
+        bfa_trc(ioim->bfa, be32_to_cpu(rl->lun_list_length));
+        bfa_trc(ioim->bfa, be32_to_cpu(m->residue));
+
+        residue = be32_to_cpu(m->residue);
+        residue += (lun_count - lun_fetched_cnt) * sizeof(struct scsi_lun);
+        bfa_stats(ioim->itnim, lm_wire_residue_changed);
+        m->residue = be32_to_cpu(residue);
+        bfa_trc(ioim->bfa, ioim->nsges);
+        return BFA_FALSE;
+}
 
 static void
 __bfa_cb_ioim_good_comp(void *cbarg, bfa_boolean_t complete)
@@ -2068,6 +2455,299 @@ __bfa_cb_ioim_comp(void *cbarg, bfa_boolean_t complete)
 }
 
 static void
+__bfa_cb_ioim_lm_lun_not_sup(void *cbarg, bfa_boolean_t complete)
+{
+        struct bfa_ioim_s *ioim = cbarg;
+        int sns_len = 0xD;
+        u32 residue = scsi_bufflen((struct scsi_cmnd *)ioim->dio);
+        struct scsi_sense_s *snsinfo;
+
+        if (!complete) {
+                bfa_sm_send_event(ioim, BFA_IOIM_SM_HCB);
+                return;
+        }
+
+        snsinfo = (struct scsi_sense_s *)BFA_SNSINFO_FROM_TAG(
+                                        ioim->fcpim->fcp, ioim->iotag);
+        snsinfo->rsp_code = SCSI_SENSE_CUR_ERR;
+        snsinfo->add_sense_length = 0xa;
+        snsinfo->asc = SCSI_ASC_LUN_NOT_SUPPORTED;
+        snsinfo->sense_key = ILLEGAL_REQUEST;
+        bfa_trc(ioim->bfa, residue);
+        bfa_cb_ioim_done(ioim->bfa->bfad, ioim->dio, BFI_IOIM_STS_OK,
+                        SCSI_STATUS_CHECK_CONDITION, sns_len,
+                        (u8 *)snsinfo, residue);
+}
+
+static void
+__bfa_cb_ioim_lm_rpl_dc(void *cbarg, bfa_boolean_t complete)
+{
+        struct bfa_ioim_s *ioim = cbarg;
+        int sns_len = 0xD;
+        u32 residue = scsi_bufflen((struct scsi_cmnd *)ioim->dio);
+        struct scsi_sense_s *snsinfo;
+
+        if (!complete) {
+                bfa_sm_send_event(ioim, BFA_IOIM_SM_HCB);
+                return;
+        }
+
+        snsinfo = (struct scsi_sense_s *)BFA_SNSINFO_FROM_TAG(ioim->fcpim->fcp,
+                                                       ioim->iotag);
+        snsinfo->rsp_code = SCSI_SENSE_CUR_ERR;
+        snsinfo->sense_key = SCSI_MP_IEC_UNIT_ATTN;
+        snsinfo->asc = SCSI_ASC_TOCC;
+        snsinfo->add_sense_length = 0x6;
+        snsinfo->ascq = SCSI_ASCQ_RL_DATA_CHANGED;
+        bfa_trc(ioim->bfa, residue);
+        bfa_cb_ioim_done(ioim->bfa->bfad, ioim->dio, BFI_IOIM_STS_OK,
+                        SCSI_STATUS_CHECK_CONDITION, sns_len,
+                        (u8 *)snsinfo, residue);
+}
+
+static void
+__bfa_cb_ioim_lm_lun_not_rdy(void *cbarg, bfa_boolean_t complete)
+{
+        struct bfa_ioim_s *ioim = cbarg;
+        int sns_len = 0xD;
+        u32 residue = scsi_bufflen((struct scsi_cmnd *)ioim->dio);
+        struct scsi_sense_s *snsinfo;
+
+        if (!complete) {
+                bfa_sm_send_event(ioim, BFA_IOIM_SM_HCB);
+                return;
+        }
+
+        snsinfo = (struct scsi_sense_s *)BFA_SNSINFO_FROM_TAG(
+                                        ioim->fcpim->fcp, ioim->iotag);
+        snsinfo->rsp_code = SCSI_SENSE_CUR_ERR;
+        snsinfo->add_sense_length = 0xa;
+        snsinfo->sense_key = NOT_READY;
+        snsinfo->asc = SCSI_ASC_LUN_NOT_READY;
+        snsinfo->ascq = SCSI_ASCQ_MAN_INTR_REQ;
+        bfa_trc(ioim->bfa, residue);
+        bfa_cb_ioim_done(ioim->bfa->bfad, ioim->dio, BFI_IOIM_STS_OK,
+                        SCSI_STATUS_CHECK_CONDITION, sns_len,
+                        (u8 *)snsinfo, residue);
+}
+
+void
+bfa_fcpim_lunmask_rp_update(struct bfa_s *bfa, wwn_t lp_wwn, wwn_t rp_wwn,
+                        u16 rp_tag, u8 lp_tag)
+{
+        struct bfa_lun_mask_s *lun_list;
+        u8      i;
+
+        if (bfa_get_lun_mask_status(bfa) == BFA_LUNMASK_MINCFG)
+                return;
+
+        lun_list = bfa_get_lun_mask_list(bfa);
+        for (i = 0; i < MAX_LUN_MASK_CFG; i++) {
+                if (lun_list[i].state == BFA_IOIM_LUN_MASK_ACTIVE) {
+                        if ((lun_list[i].lp_wwn == lp_wwn) &&
+                            (lun_list[i].rp_wwn == rp_wwn)) {
+                                lun_list[i].rp_tag = rp_tag;
+                                lun_list[i].lp_tag = lp_tag;
+                        }
+                }
+        }
+}
+
+/*
+ * set UA for all active luns in LM DB
+ */
+static void
+bfa_ioim_lm_set_ua(struct bfa_s *bfa)
+{
+        struct bfa_lun_mask_s   *lunm_list;
+        int     i;
+
+        lunm_list = bfa_get_lun_mask_list(bfa);
+        for (i = 0; i < MAX_LUN_MASK_CFG; i++) {
+                if (lunm_list[i].state != BFA_IOIM_LUN_MASK_ACTIVE)
+                        continue;
+                lunm_list[i].ua = BFA_IOIM_LM_UA_SET;
+        }
+}
+
+bfa_status_t
+bfa_fcpim_lunmask_update(struct bfa_s *bfa, u32 update)
+{
+        struct bfa_lunmask_cfg_s        *lun_mask;
+
+        bfa_trc(bfa, bfa_get_lun_mask_status(bfa));
+        if (bfa_get_lun_mask_status(bfa) == BFA_LUNMASK_MINCFG)
+                return BFA_STATUS_FAILED;
+
+        if (bfa_get_lun_mask_status(bfa) == update)
+                return BFA_STATUS_NO_CHANGE;
+
+        lun_mask = bfa_get_lun_mask(bfa);
+        lun_mask->status = update;
+
+        if (bfa_get_lun_mask_status(bfa) == BFA_LUNMASK_ENABLED)
+                bfa_ioim_lm_set_ua(bfa);
+
+        return  bfa_dconf_update(bfa);
+}
+
+bfa_status_t
+bfa_fcpim_lunmask_clear(struct bfa_s *bfa)
+{
+        int i;
+        struct bfa_lun_mask_s   *lunm_list;
+
+        bfa_trc(bfa, bfa_get_lun_mask_status(bfa));
+        if (bfa_get_lun_mask_status(bfa) == BFA_LUNMASK_MINCFG)
+                return BFA_STATUS_FAILED;
+
+        lunm_list = bfa_get_lun_mask_list(bfa);
+        for (i = 0; i < MAX_LUN_MASK_CFG; i++) {
+                if (lunm_list[i].state == BFA_IOIM_LUN_MASK_ACTIVE) {
+                        if (lunm_list[i].rp_tag != BFA_RPORT_TAG_INVALID)
+                                bfa_rport_unset_lunmask(bfa,
+                                  BFA_RPORT_FROM_TAG(bfa, lunm_list[i].rp_tag));
+                }
+        }
+
+        memset(lunm_list, 0, sizeof(struct bfa_lun_mask_s) * MAX_LUN_MASK_CFG);
+        return bfa_dconf_update(bfa);
+}
+
+bfa_status_t
+bfa_fcpim_lunmask_query(struct bfa_s *bfa, void *buf)
+{
+        struct bfa_lunmask_cfg_s *lun_mask;
+
+        bfa_trc(bfa, bfa_get_lun_mask_status(bfa));
+        if (bfa_get_lun_mask_status(bfa) == BFA_LUNMASK_MINCFG)
+                return BFA_STATUS_FAILED;
+
+        lun_mask = bfa_get_lun_mask(bfa);
+        memcpy(buf, lun_mask, sizeof(struct bfa_lunmask_cfg_s));
+        return BFA_STATUS_OK;
+}
+
+bfa_status_t
+bfa_fcpim_lunmask_add(struct bfa_s *bfa, u16 vf_id, wwn_t *pwwn,
+                      wwn_t rpwwn, struct scsi_lun lun)
+{
+        struct bfa_lun_mask_s *lunm_list;
+        struct bfa_rport_s *rp = NULL;
+        int i, free_index = MAX_LUN_MASK_CFG + 1;
+        struct bfa_fcs_lport_s *port = NULL;
+        struct bfa_fcs_rport_s *rp_fcs;
+
+        bfa_trc(bfa, bfa_get_lun_mask_status(bfa));
+        if (bfa_get_lun_mask_status(bfa) == BFA_LUNMASK_MINCFG)
+                return BFA_STATUS_FAILED;
+
+        port = bfa_fcs_lookup_port(&((struct bfad_s *)bfa->bfad)->bfa_fcs,
+                                   vf_id, *pwwn);
+        if (port) {
+                *pwwn = port->port_cfg.pwwn;
+                rp_fcs = bfa_fcs_lport_get_rport_by_pwwn(port, rpwwn);
+                rp = rp_fcs->bfa_rport;
+        }
+
+        lunm_list = bfa_get_lun_mask_list(bfa);
+        /* if entry exists */
+        for (i = 0; i < MAX_LUN_MASK_CFG; i++) {
+                if (lunm_list[i].state != BFA_IOIM_LUN_MASK_ACTIVE)
+                        free_index = i;
+                if ((lunm_list[i].lp_wwn == *pwwn) &&
+                    (lunm_list[i].rp_wwn == rpwwn) &&
+                    (scsilun_to_int((struct scsi_lun *)&lunm_list[i].lun) ==
+                     scsilun_to_int((struct scsi_lun *)&lun)))
+                        return  BFA_STATUS_ENTRY_EXISTS;
+        }
+
+        if (free_index > MAX_LUN_MASK_CFG)
+                return BFA_STATUS_MAX_ENTRY_REACHED;
+
+        if (rp) {
+                lunm_list[free_index].lp_tag = bfa_lps_get_tag_from_pid(bfa,
+                                                   rp->rport_info.local_pid);
+                lunm_list[free_index].rp_tag = rp->rport_tag;
+        } else {
+                lunm_list[free_index].lp_tag = BFA_LP_TAG_INVALID;
+                lunm_list[free_index].rp_tag = BFA_RPORT_TAG_INVALID;
+        }
+
+        lunm_list[free_index].lp_wwn = *pwwn;
+        lunm_list[free_index].rp_wwn = rpwwn;
+        lunm_list[free_index].lun = lun;
+        lunm_list[free_index].state = BFA_IOIM_LUN_MASK_ACTIVE;
+
+        /* set for all luns in this rp */
+        for (i = 0; i < MAX_LUN_MASK_CFG; i++) {
+                if ((lunm_list[i].lp_wwn == *pwwn) &&
+                    (lunm_list[i].rp_wwn == rpwwn))
+                        lunm_list[i].ua = BFA_IOIM_LM_UA_SET;
+        }
+
+        return bfa_dconf_update(bfa);
+}
+
+bfa_status_t
+bfa_fcpim_lunmask_delete(struct bfa_s *bfa, u16 vf_id, wwn_t *pwwn,
+                         wwn_t rpwwn, struct scsi_lun lun)
+{
+        struct bfa_lun_mask_s   *lunm_list;
+        struct bfa_rport_s      *rp = NULL;
+        struct bfa_fcs_lport_s *port = NULL;
+        struct bfa_fcs_rport_s *rp_fcs;
+        int     i;
+
+        /* in min cfg lunm_list could be NULL but  no commands should run. */
+        if (bfa_get_lun_mask_status(bfa) == BFA_LUNMASK_MINCFG)
+                return BFA_STATUS_FAILED;
+
+        bfa_trc(bfa, bfa_get_lun_mask_status(bfa));
+        bfa_trc(bfa, *pwwn);
+        bfa_trc(bfa, rpwwn);
+        bfa_trc(bfa, scsilun_to_int((struct scsi_lun *)&lun));
+
+        if (*pwwn == 0) {
+                port = bfa_fcs_lookup_port(
+                                &((struct bfad_s *)bfa->bfad)->bfa_fcs,
+                                vf_id, *pwwn);
+                if (port) {
+                        *pwwn = port->port_cfg.pwwn;
+                        rp_fcs = bfa_fcs_lport_get_rport_by_pwwn(port, rpwwn);
+                        rp = rp_fcs->bfa_rport;
+                }
+        }
+
+        lunm_list = bfa_get_lun_mask_list(bfa);
+        for (i = 0; i < MAX_LUN_MASK_CFG; i++) {
+                if ((lunm_list[i].lp_wwn == *pwwn) &&
+                    (lunm_list[i].rp_wwn == rpwwn) &&
+                    (scsilun_to_int((struct scsi_lun *)&lunm_list[i].lun) ==
+                     scsilun_to_int((struct scsi_lun *)&lun))) {
+                        lunm_list[i].lp_wwn = 0;
+                        lunm_list[i].rp_wwn = 0;
+                        int_to_scsilun(0, &lunm_list[i].lun);
+                        lunm_list[i].state = BFA_IOIM_LUN_MASK_INACTIVE;
+                        if (lunm_list[i].rp_tag != BFA_RPORT_TAG_INVALID) {
+                                lunm_list[i].rp_tag = BFA_RPORT_TAG_INVALID;
+                                lunm_list[i].lp_tag = BFA_LP_TAG_INVALID;
+                        }
+                        return bfa_dconf_update(bfa);
+                }
+        }
+
+        /* set for all luns in this rp */
+        for (i = 0; i < MAX_LUN_MASK_CFG; i++) {
+                if ((lunm_list[i].lp_wwn == *pwwn) &&
+                    (lunm_list[i].rp_wwn == rpwwn))
+                        lunm_list[i].ua = BFA_IOIM_LM_UA_SET;
+        }
+
+        return BFA_STATUS_ENTRY_NOT_EXISTS;
+}
+
+static void
 __bfa_cb_ioim_failed(void *cbarg, bfa_boolean_t complete)
 {
         struct bfa_ioim_s *ioim = cbarg;
@@ -2077,6 +2757,7 @@ __bfa_cb_ioim_failed(void *cbarg, bfa_boolean_t complete)
                 return;
         }
 
+        ioim->proc_rsp_data = bfa_ioim_lm_proc_rsp_data_dummy;
         bfa_cb_ioim_done(ioim->bfa->bfad, ioim->dio, BFI_IOIM_STS_ABORTED,
                           0, 0, NULL, 0);
 }
@@ -2092,6 +2773,7 @@ __bfa_cb_ioim_pathtov(void *cbarg, bfa_boolean_t complete)
                 return;
         }
 
+        ioim->proc_rsp_data = bfa_ioim_lm_proc_rsp_data_dummy;
         bfa_cb_ioim_done(ioim->bfa->bfad, ioim->dio, BFI_IOIM_STS_PATHTOV,
                           0, 0, NULL, 0);
 }
@@ -2106,6 +2788,7 @@ __bfa_cb_ioim_abort(void *cbarg, bfa_boolean_t complete)
                 return;
         }
 
+        ioim->proc_rsp_data = bfa_ioim_lm_proc_rsp_data_dummy;
         bfa_cb_ioim_abort(ioim->bfa->bfad, ioim->dio);
 }
 
@@ -2449,6 +3132,7 @@ bfa_ioim_attach(struct bfa_fcpim_s *fcpim)
                 ioim->bfa     = fcpim->bfa;
                 ioim->fcpim   = fcpim;
                 ioim->iosp    = iosp;
+                ioim->proc_rsp_data = bfa_ioim_lm_proc_rsp_data_dummy;
                 INIT_LIST_HEAD(&ioim->sgpg_q);
                 bfa_reqq_winit(&ioim->iosp->reqq_wait,
                                    bfa_ioim_qresume, ioim);
@@ -2486,6 +3170,7 @@ bfa_ioim_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
                         evt = BFA_IOIM_SM_DONE;
                 else
                         evt = BFA_IOIM_SM_COMP;
+                ioim->proc_rsp_data(ioim);
                 break;
 
         case BFI_IOIM_STS_TIMEDOUT:
@@ -2521,6 +3206,7 @@ bfa_ioim_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
                 if (rsp->abort_tag != ioim->abort_tag) {
                         bfa_trc(ioim->bfa, rsp->abort_tag);
                         bfa_trc(ioim->bfa, ioim->abort_tag);
+                        ioim->proc_rsp_data = bfa_ioim_lm_proc_rsp_data_dummy;
                         return;
                 }
 
@@ -2539,6 +3225,7 @@ bfa_ioim_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
                 WARN_ON(1);
         }
 
+        ioim->proc_rsp_data = bfa_ioim_lm_proc_rsp_data_dummy;
         bfa_sm_send_event(ioim, evt);
 }
 
@@ -2556,7 +3243,16 @@ bfa_ioim_good_comp_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
         WARN_ON(BFA_IOIM_TAG_2_ID(ioim->iotag) != iotag);
 
         bfa_ioim_cb_profile_comp(fcpim, ioim);
-        bfa_sm_send_event(ioim, BFA_IOIM_SM_COMP_GOOD);
+
+        if (bfa_get_lun_mask_status(bfa) != BFA_LUNMASK_ENABLED)  {
+                bfa_sm_send_event(ioim, BFA_IOIM_SM_COMP_GOOD);
+                return;
+        }
+
+        if (ioim->proc_rsp_data(ioim) == BFA_TRUE)
+                bfa_sm_send_event(ioim, BFA_IOIM_SM_COMP_GOOD);
+        else
+                bfa_sm_send_event(ioim, BFA_IOIM_SM_COMP);
 }
 
 /*
@@ -2668,6 +3364,35 @@ bfa_ioim_free(struct bfa_ioim_s *ioim)
 void
 bfa_ioim_start(struct bfa_ioim_s *ioim)
 {
+        struct scsi_cmnd *cmnd = (struct scsi_cmnd *)ioim->dio;
+        struct bfa_lps_s        *lps;
+        enum bfa_ioim_lm_status status;
+        struct scsi_lun scsilun;
+
+        if (bfa_get_lun_mask_status(ioim->bfa) == BFA_LUNMASK_ENABLED) {
+                lps = BFA_IOIM_TO_LPS(ioim);
+                int_to_scsilun(cmnd->device->lun, &scsilun);
+                status = bfa_ioim_lm_check(ioim, lps,
+                                ioim->itnim->rport, scsilun);
+                if (status == BFA_IOIM_LM_LUN_NOT_RDY) {
+                        bfa_sm_send_event(ioim, BFA_IOIM_SM_LM_LUN_NOT_RDY);
+                        bfa_stats(ioim->itnim, lm_lun_not_rdy);
+                        return;
+                }
+
+                if (status == BFA_IOIM_LM_LUN_NOT_SUP) {
+                        bfa_sm_send_event(ioim, BFA_IOIM_SM_LM_LUN_NOT_SUP);
+                        bfa_stats(ioim->itnim, lm_lun_not_sup);
+                        return;
+                }
+
+                if (status == BFA_IOIM_LM_RPL_DATA_CHANGED) {
+                        bfa_sm_send_event(ioim, BFA_IOIM_SM_LM_RPL_DC);
+                        bfa_stats(ioim->itnim, lm_rpl_data_changed);
+                        return;
+                }
+        }
+
         bfa_ioim_cb_profile_start(ioim->fcpim, ioim);
 
         /*
@@ -3411,6 +4136,13 @@ bfa_fcp_detach(struct bfa_s *bfa)
 static void
 bfa_fcp_start(struct bfa_s *bfa)
 {
+        struct bfa_fcp_mod_s *fcp = BFA_FCP_MOD(bfa);
+
+        /*
+         * bfa_init() with flash read is complete. now invalidate the stale
+         * content of lun mask like unit attention, rp tag and lp tag.
+         */
+        bfa_ioim_lm_init(fcp->bfa);
 }
 
 static void
diff --git a/drivers/scsi/bfa/bfa_fcpim.h b/drivers/scsi/bfa/bfa_fcpim.h
index 57b695ad4ee5..1080bcb81cb7 100644
--- a/drivers/scsi/bfa/bfa_fcpim.h
+++ b/drivers/scsi/bfa/bfa_fcpim.h
@@ -79,14 +79,22 @@ bfa_ioim_get_index(u32 n) {
         if (n >= (1UL)<<22)
                 return BFA_IOBUCKET_MAX - 1;
         n >>= 8;
-        if (n >= (1UL)<<16)
-                n >>= 16; pos += 16;
-        if (n >= 1 << 8)
-                n >>= 8; pos += 8;
-        if (n >= 1 << 4)
-                n >>= 4; pos += 4;
-        if (n >= 1 << 2)
-                n >>= 2; pos += 2;
+        if (n >= (1UL)<<16) {
+                n >>= 16;
+                pos += 16;
+        }
+        if (n >= 1 << 8) {
+                n >>= 8;
+                pos += 8;
+        }
+        if (n >= 1 << 4) {
+                n >>= 4;
+                pos += 4;
+        }
+        if (n >= 1 << 2) {
+                n >>= 2;
+                pos += 2;
+        }
         if (n >= 1 << 1)
                 pos += 1;
 
@@ -102,6 +110,7 @@ struct bfad_ioim_s;
 struct bfad_tskim_s;
 
 typedef void    (*bfa_fcpim_profile_t) (struct bfa_ioim_s *ioim);
+typedef bfa_boolean_t (*bfa_ioim_lm_proc_rsp_data_t) (struct bfa_ioim_s *ioim);
 
 struct bfa_fcpim_s {
         struct bfa_s            *bfa;
@@ -115,7 +124,7 @@ struct bfa_fcpim_s {
         u32                     path_tov;
         u16                     q_depth;
         u8                      reqq;           /*  Request queue to be used */
-        u8                      rsvd;
+        u8                      lun_masking_pending;
         struct list_head        itnim_q;        /*  queue of active itnim */
         struct list_head        ioim_resfree_q; /*  IOs waiting for f/w */
         struct list_head        ioim_comp_q;    /*  IO global comp Q    */
@@ -170,7 +179,9 @@ struct bfa_ioim_s {
         bfa_cb_cbfn_t           io_cbfn;        /*  IO completion handler */
         struct bfa_ioim_sp_s    *iosp;          /*  slow-path IO handling */
         u8                      reqq;           /*  Request queue for I/O */
+        u8                      mode;           /*  IO is passthrough or not */
         u64                     start_time;     /*  IO's Profile start val */
+        bfa_ioim_lm_proc_rsp_data_t proc_rsp_data; /* RSP data adjust */
 };
 
 struct bfa_ioim_sp_s {
@@ -250,6 +261,10 @@ struct bfa_itnim_s {
         (__ioim)->iotag |= k << BFA_IOIM_RETRY_TAG_OFFSET;              \
 } while (0)
 
+#define BFA_IOIM_TO_LPS(__ioim)         \
+        BFA_LPS_FROM_TAG(BFA_LPS_MOD(__ioim->bfa),      \
+                __ioim->itnim->rport->rport_info.lp_tag)
+
 static inline bfa_boolean_t
 bfa_ioim_maxretry_reached(struct bfa_ioim_s *ioim)
 {
@@ -297,6 +312,8 @@ bfa_status_t bfa_fcpim_port_iostats(struct bfa_s *bfa,
                         struct bfa_itnim_iostats_s *stats, u8 lp_tag);
 void bfa_fcpim_add_stats(struct bfa_itnim_iostats_s *fcpim_stats,
                         struct bfa_itnim_iostats_s *itnim_stats);
+bfa_status_t bfa_fcpim_profile_on(struct bfa_s *bfa, u32 time);
+bfa_status_t bfa_fcpim_profile_off(struct bfa_s *bfa);
 
 #define bfa_fcpim_ioredirect_enabled(__bfa)                             \
         (((struct bfa_fcpim_s *)(BFA_FCPIM(__bfa)))->ioredirect)
@@ -397,4 +414,14 @@ void bfa_tskim_start(struct bfa_tskim_s *tskim,
 void bfa_cb_tskim_done(void *bfad, struct bfad_tskim_s *dtsk,
                         enum bfi_tskim_status tsk_status);
 
+void    bfa_fcpim_lunmask_rp_update(struct bfa_s *bfa, wwn_t lp_wwn,
+                        wwn_t rp_wwn, u16 rp_tag, u8 lp_tag);
+bfa_status_t    bfa_fcpim_lunmask_update(struct bfa_s *bfa, u32 on_off);
+bfa_status_t    bfa_fcpim_lunmask_query(struct bfa_s *bfa, void *buf);
+bfa_status_t    bfa_fcpim_lunmask_delete(struct bfa_s *bfa, u16 vf_id,
+                                wwn_t *pwwn, wwn_t rpwwn, struct scsi_lun lun);
+bfa_status_t    bfa_fcpim_lunmask_add(struct bfa_s *bfa, u16 vf_id,
+                                wwn_t *pwwn, wwn_t rpwwn, struct scsi_lun lun);
+bfa_status_t    bfa_fcpim_lunmask_clear(struct bfa_s *bfa);
+
 #endif /* __BFA_FCPIM_H__ */
diff --git a/drivers/scsi/bfa/bfa_fcs.c b/drivers/scsi/bfa/bfa_fcs.c
index a9b22bc48bc3..eaac57e1ddec 100644
--- a/drivers/scsi/bfa/bfa_fcs.c
+++ b/drivers/scsi/bfa/bfa_fcs.c
@@ -20,6 +20,7 @@
  */
 
 #include "bfad_drv.h"
+#include "bfad_im.h"
 #include "bfa_fcs.h"
 #include "bfa_fcbuild.h"
 
@@ -1327,6 +1328,29 @@ bfa_fcs_fabric_flogiacc_comp(void *fcsarg, struct bfa_fcxp_s *fcxp, void *cbarg,
         bfa_trc(fabric->fcs, status);
 }
 
+
+/*
+ * Send AEN notification
+ */
+static void
+bfa_fcs_fabric_aen_post(struct bfa_fcs_lport_s *port,
+                        enum bfa_port_aen_event event)
+{
+        struct bfad_s *bfad = (struct bfad_s *)port->fabric->fcs->bfad;
+        struct bfa_aen_entry_s  *aen_entry;
+
+        bfad_get_aen_entry(bfad, aen_entry);
+        if (!aen_entry)
+                return;
+
+        aen_entry->aen_data.port.pwwn = bfa_fcs_lport_get_pwwn(port);
+        aen_entry->aen_data.port.fwwn = bfa_fcs_lport_get_fabric_name(port);
+
+        /* Send the AEN notification */
+        bfad_im_post_vendor_event(aen_entry, bfad, ++port->fcs->fcs_aen_seq,
+                                  BFA_AEN_CAT_PORT, event);
+}
+
 /*
  *
  * @param[in] fabric - fabric
@@ -1358,6 +1382,8 @@ bfa_fcs_fabric_set_fabric_name(struct bfa_fcs_fabric_s *fabric,
                 BFA_LOG(KERN_WARNING, bfad, bfa_log_level,
                         "Base port WWN = %s Fabric WWN = %s\n",
                         pwwn_ptr, fwwn_ptr);
+                bfa_fcs_fabric_aen_post(&fabric->bport,
+                                BFA_PORT_AEN_FABRIC_NAME_CHANGE);
         }
 }
 
diff --git a/drivers/scsi/bfa/bfa_fcs.h b/drivers/scsi/bfa/bfa_fcs.h
index a5f1faf335a7..e75e07d25915 100644
--- a/drivers/scsi/bfa/bfa_fcs.h
+++ b/drivers/scsi/bfa/bfa_fcs.h
@@ -675,6 +675,7 @@ struct bfa_fcs_s {
         struct bfa_fcs_fabric_s fabric; /*  base fabric state machine */
         struct bfa_fcs_stats_s  stats;  /*  FCS statistics */
         struct bfa_wc_s         wc;     /*  waiting counter */
+        int                     fcs_aen_seq;
 };
 
 /*
diff --git a/drivers/scsi/bfa/bfa_fcs_fcpim.c b/drivers/scsi/bfa/bfa_fcs_fcpim.c
index 29b4108be269..9272840a2409 100644
--- a/drivers/scsi/bfa/bfa_fcs_fcpim.c
+++ b/drivers/scsi/bfa/bfa_fcs_fcpim.c
@@ -37,6 +37,8 @@ static void	bfa_fcs_itnim_prli_response(void *fcsarg,
                          struct bfa_fcxp_s *fcxp, void *cbarg,
                             bfa_status_t req_status, u32 rsp_len,
                             u32 resid_len, struct fchs_s *rsp_fchs);
+static void     bfa_fcs_itnim_aen_post(struct bfa_fcs_itnim_s *itnim,
+                        enum bfa_itnim_aen_event event);
 
 /*
  *  fcs_itnim_sm FCS itnim state machine events
@@ -269,6 +271,7 @@ bfa_fcs_itnim_sm_hcb_online(struct bfa_fcs_itnim_s *itnim,
                 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
                 "Target (WWN = %s) is online for initiator (WWN = %s)\n",
                 rpwwn_buf, lpwwn_buf);
+                bfa_fcs_itnim_aen_post(itnim, BFA_ITNIM_AEN_ONLINE);
                 break;
 
         case BFA_FCS_ITNIM_SM_OFFLINE:
@@ -305,14 +308,17 @@ bfa_fcs_itnim_sm_online(struct bfa_fcs_itnim_s *itnim,
                 bfa_itnim_offline(itnim->bfa_itnim);
                 wwn2str(lpwwn_buf, bfa_fcs_lport_get_pwwn(itnim->rport->port));
                 wwn2str(rpwwn_buf, itnim->rport->pwwn);
-                if (bfa_fcs_lport_is_online(itnim->rport->port) == BFA_TRUE)
+                if (bfa_fcs_lport_is_online(itnim->rport->port) == BFA_TRUE) {
                         BFA_LOG(KERN_ERR, bfad, bfa_log_level,
                         "Target (WWN = %s) connectivity lost for "
                         "initiator (WWN = %s)\n", rpwwn_buf, lpwwn_buf);
-                else
+                        bfa_fcs_itnim_aen_post(itnim, BFA_ITNIM_AEN_DISCONNECT);
+                } else {
                         BFA_LOG(KERN_INFO, bfad, bfa_log_level,
                         "Target (WWN = %s) offlined by initiator (WWN = %s)\n",
                         rpwwn_buf, lpwwn_buf);
+                        bfa_fcs_itnim_aen_post(itnim, BFA_ITNIM_AEN_OFFLINE);
+                }
                 break;
 
         case BFA_FCS_ITNIM_SM_DELETE:
@@ -382,6 +388,33 @@ bfa_fcs_itnim_sm_initiator(struct bfa_fcs_itnim_s *itnim,
 }
 
 static void
+bfa_fcs_itnim_aen_post(struct bfa_fcs_itnim_s *itnim,
+                        enum bfa_itnim_aen_event event)
+{
+        struct bfa_fcs_rport_s *rport = itnim->rport;
+        struct bfad_s *bfad = (struct bfad_s *)itnim->fcs->bfad;
+        struct bfa_aen_entry_s  *aen_entry;
+
+        /* Don't post events for well known addresses */
+        if (BFA_FCS_PID_IS_WKA(rport->pid))
+                return;
+
+        bfad_get_aen_entry(bfad, aen_entry);
+        if (!aen_entry)
+                return;
+
+        aen_entry->aen_data.itnim.vf_id = rport->port->fabric->vf_id;
+        aen_entry->aen_data.itnim.ppwwn = bfa_fcs_lport_get_pwwn(
+                                        bfa_fcs_get_base_port(itnim->fcs));
+        aen_entry->aen_data.itnim.lpwwn = bfa_fcs_lport_get_pwwn(rport->port);
+        aen_entry->aen_data.itnim.rpwwn = rport->pwwn;
+
+        /* Send the AEN notification */
+        bfad_im_post_vendor_event(aen_entry, bfad, ++rport->fcs->fcs_aen_seq,
+                                  BFA_AEN_CAT_ITNIM, event);
+}
+
+static void
 bfa_fcs_itnim_send_prli(void *itnim_cbarg, struct bfa_fcxp_s *fcxp_alloced)
 {
         struct bfa_fcs_itnim_s *itnim = itnim_cbarg;
diff --git a/drivers/scsi/bfa/bfa_fcs_lport.c b/drivers/scsi/bfa/bfa_fcs_lport.c
index f8251a91ba91..d4f951fe753e 100644
--- a/drivers/scsi/bfa/bfa_fcs_lport.c
+++ b/drivers/scsi/bfa/bfa_fcs_lport.c
@@ -16,6 +16,7 @@
  */
 
 #include "bfad_drv.h"
+#include "bfad_im.h"
 #include "bfa_fcs.h"
 #include "bfa_fcbuild.h"
 #include "bfa_fc.h"
@@ -300,6 +301,31 @@ bfa_fcs_lport_sm_deleting(
  */
 
 /*
+ * Send AEN notification
+ */
+static void
+bfa_fcs_lport_aen_post(struct bfa_fcs_lport_s *port,
+                        enum bfa_lport_aen_event event)
+{
+        struct bfad_s *bfad = (struct bfad_s *)port->fabric->fcs->bfad;
+        struct bfa_aen_entry_s  *aen_entry;
+
+        bfad_get_aen_entry(bfad, aen_entry);
+        if (!aen_entry)
+                return;
+
+        aen_entry->aen_data.lport.vf_id = port->fabric->vf_id;
+        aen_entry->aen_data.lport.roles = port->port_cfg.roles;
+        aen_entry->aen_data.lport.ppwwn = bfa_fcs_lport_get_pwwn(
+                                        bfa_fcs_get_base_port(port->fcs));
+        aen_entry->aen_data.lport.lpwwn = bfa_fcs_lport_get_pwwn(port);
+
+        /* Send the AEN notification */
+        bfad_im_post_vendor_event(aen_entry, bfad, ++port->fcs->fcs_aen_seq,
+                                  BFA_AEN_CAT_LPORT, event);
+}
+
+/*
  * Send a LS reject
  */
 static void
@@ -593,6 +619,7 @@ bfa_fcs_lport_online_actions(struct bfa_fcs_lport_s *port)
         BFA_LOG(KERN_INFO, bfad, bfa_log_level,
                 "Logical port online: WWN = %s Role = %s\n",
                 lpwwn_buf, "Initiator");
+        bfa_fcs_lport_aen_post(port, BFA_LPORT_AEN_ONLINE);
 
         bfad->bfad_flags |= BFAD_PORT_ONLINE;
 }
@@ -611,14 +638,17 @@ bfa_fcs_lport_offline_actions(struct bfa_fcs_lport_s *port)
 
         wwn2str(lpwwn_buf, bfa_fcs_lport_get_pwwn(port));
         if (bfa_sm_cmp_state(port->fabric,
-                        bfa_fcs_fabric_sm_online) == BFA_TRUE)
+                        bfa_fcs_fabric_sm_online) == BFA_TRUE) {
                 BFA_LOG(KERN_ERR, bfad, bfa_log_level,
                 "Logical port lost fabric connectivity: WWN = %s Role = %s\n",
                 lpwwn_buf, "Initiator");
-        else
+                bfa_fcs_lport_aen_post(port, BFA_LPORT_AEN_DISCONNECT);
+        } else {
                 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
                 "Logical port taken offline: WWN = %s Role = %s\n",
                 lpwwn_buf, "Initiator");
+                bfa_fcs_lport_aen_post(port, BFA_LPORT_AEN_OFFLINE);
+        }
 
         list_for_each_safe(qe, qen, &port->rport_q) {
                 rport = (struct bfa_fcs_rport_s *) qe;
@@ -676,6 +706,7 @@ bfa_fcs_lport_deleted(struct bfa_fcs_lport_s *port)
         BFA_LOG(KERN_INFO, bfad, bfa_log_level,
                 "Logical port deleted: WWN = %s Role = %s\n",
                 lpwwn_buf, "Initiator");
+        bfa_fcs_lport_aen_post(port, BFA_LPORT_AEN_DELETE);
 
         /* Base port will be deleted by the OS driver */
         if (port->vport) {
@@ -973,6 +1004,7 @@ bfa_fcs_lport_init(struct bfa_fcs_lport_s *lport,
         BFA_LOG(KERN_INFO, bfad, bfa_log_level,
                 "New logical port created: WWN = %s Role = %s\n",
                 lpwwn_buf, "Initiator");
+        bfa_fcs_lport_aen_post(lport, BFA_LPORT_AEN_NEW);
 
         bfa_sm_set_state(lport, bfa_fcs_lport_sm_uninit);
         bfa_sm_send_event(lport, BFA_FCS_PORT_SM_CREATE);
@@ -5559,6 +5591,31 @@ bfa_fcs_vport_sm_logo(struct bfa_fcs_vport_s *vport,
  *  fcs_vport_private FCS virtual port private functions
  */
 /*
+ * Send AEN notification
+ */
+static void
+bfa_fcs_vport_aen_post(struct bfa_fcs_lport_s *port,
+                       enum bfa_lport_aen_event event)
+{
+        struct bfad_s *bfad = (struct bfad_s *)port->fabric->fcs->bfad;
+        struct bfa_aen_entry_s  *aen_entry;
+
+        bfad_get_aen_entry(bfad, aen_entry);
+        if (!aen_entry)
+                return;
+
+        aen_entry->aen_data.lport.vf_id = port->fabric->vf_id;
+        aen_entry->aen_data.lport.roles = port->port_cfg.roles;
+        aen_entry->aen_data.lport.ppwwn = bfa_fcs_lport_get_pwwn(
+                                        bfa_fcs_get_base_port(port->fcs));
+        aen_entry->aen_data.lport.lpwwn = bfa_fcs_lport_get_pwwn(port);
+
+        /* Send the AEN notification */
+        bfad_im_post_vendor_event(aen_entry, bfad, ++port->fcs->fcs_aen_seq,
+                                  BFA_AEN_CAT_LPORT, event);
+}
+
+/*
  * This routine will be called to send a FDISC command.
  */
 static void
@@ -5585,8 +5642,11 @@ bfa_fcs_vport_fdisc_rejected(struct bfa_fcs_vport_s *vport)
         case FC_LS_RJT_EXP_INVALID_NPORT_ID: /* by Cisco */
                 if (vport->fdisc_retries < BFA_FCS_VPORT_MAX_RETRIES)
                         bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_ERROR);
-                else
+                else {
+                        bfa_fcs_vport_aen_post(&vport->lport,
+                                        BFA_LPORT_AEN_NPIV_DUP_WWN);
                         bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_DUP_WWN);
+                }
                 break;
 
         case FC_LS_RJT_EXP_INSUFF_RES:
@@ -5596,11 +5656,17 @@ bfa_fcs_vport_fdisc_rejected(struct bfa_fcs_vport_s *vport)
                  */
                 if (vport->fdisc_retries < BFA_FCS_VPORT_MAX_RETRIES)
                         bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_ERROR);
-                else
+                else {
+                        bfa_fcs_vport_aen_post(&vport->lport,
+                                        BFA_LPORT_AEN_NPIV_FABRIC_MAX);
                         bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_FAILED);
+                }
                 break;
 
         default:
+                if (vport->fdisc_retries == 0)
+                        bfa_fcs_vport_aen_post(&vport->lport,
+                                        BFA_LPORT_AEN_NPIV_UNKNOWN);
                 bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_ERROR);
         }
 }
diff --git a/drivers/scsi/bfa/bfa_fcs_rport.c b/drivers/scsi/bfa/bfa_fcs_rport.c
index 2c514458a6b4..52628d5d3c9b 100644
--- a/drivers/scsi/bfa/bfa_fcs_rport.c
+++ b/drivers/scsi/bfa/bfa_fcs_rport.c
@@ -20,6 +20,7 @@
  */
 
 #include "bfad_drv.h"
+#include "bfad_im.h"
 #include "bfa_fcs.h"
 #include "bfa_fcbuild.h"
 
@@ -2041,6 +2042,35 @@ bfa_fcs_rport_free(struct bfa_fcs_rport_s *rport)
 }
 
 static void
+bfa_fcs_rport_aen_post(struct bfa_fcs_rport_s *rport,
+                        enum bfa_rport_aen_event event,
+                        struct bfa_rport_aen_data_s *data)
+{
+        struct bfa_fcs_lport_s *port = rport->port;
+        struct bfad_s *bfad = (struct bfad_s *)port->fcs->bfad;
+        struct bfa_aen_entry_s  *aen_entry;
+
+        bfad_get_aen_entry(bfad, aen_entry);
+        if (!aen_entry)
+                return;
+
+        if (event == BFA_RPORT_AEN_QOS_PRIO)
+                aen_entry->aen_data.rport.priv.qos = data->priv.qos;
+        else if (event == BFA_RPORT_AEN_QOS_FLOWID)
+                aen_entry->aen_data.rport.priv.qos = data->priv.qos;
+
+        aen_entry->aen_data.rport.vf_id = rport->port->fabric->vf_id;
+        aen_entry->aen_data.rport.ppwwn = bfa_fcs_lport_get_pwwn(
+                                        bfa_fcs_get_base_port(rport->fcs));
+        aen_entry->aen_data.rport.lpwwn = bfa_fcs_lport_get_pwwn(rport->port);
+        aen_entry->aen_data.rport.rpwwn = rport->pwwn;
+
+        /* Send the AEN notification */
+        bfad_im_post_vendor_event(aen_entry, bfad, ++rport->fcs->fcs_aen_seq,
+                                  BFA_AEN_CAT_RPORT, event);
+}
+
+static void
 bfa_fcs_rport_online_action(struct bfa_fcs_rport_s *rport)
 {
         struct bfa_fcs_lport_s *port = rport->port;
@@ -2063,10 +2093,12 @@ bfa_fcs_rport_online_action(struct bfa_fcs_rport_s *rport)
 
         wwn2str(lpwwn_buf, bfa_fcs_lport_get_pwwn(port));
         wwn2str(rpwwn_buf, rport->pwwn);
-        if (!BFA_FCS_PID_IS_WKA(rport->pid))
+        if (!BFA_FCS_PID_IS_WKA(rport->pid)) {
                 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
                 "Remote port (WWN = %s) online for logical port (WWN = %s)\n",
                 rpwwn_buf, lpwwn_buf);
+                bfa_fcs_rport_aen_post(rport, BFA_RPORT_AEN_ONLINE, NULL);
+        }
 }
 
 static void
@@ -2083,16 +2115,21 @@ bfa_fcs_rport_offline_action(struct bfa_fcs_rport_s *rport)
         wwn2str(lpwwn_buf, bfa_fcs_lport_get_pwwn(port));
         wwn2str(rpwwn_buf, rport->pwwn);
         if (!BFA_FCS_PID_IS_WKA(rport->pid)) {
-                if (bfa_fcs_lport_is_online(rport->port) == BFA_TRUE)
+                if (bfa_fcs_lport_is_online(rport->port) == BFA_TRUE) {
                         BFA_LOG(KERN_ERR, bfad, bfa_log_level,
                                 "Remote port (WWN = %s) connectivity lost for "
                                 "logical port (WWN = %s)\n",
                                 rpwwn_buf, lpwwn_buf);
-                else
+                        bfa_fcs_rport_aen_post(rport,
+                                BFA_RPORT_AEN_DISCONNECT, NULL);
+                } else {
                         BFA_LOG(KERN_INFO, bfad, bfa_log_level,
                                 "Remote port (WWN = %s) offlined by "
                                 "logical port (WWN = %s)\n",
                                 rpwwn_buf, lpwwn_buf);
+                        bfa_fcs_rport_aen_post(rport,
+                                BFA_RPORT_AEN_OFFLINE, NULL);
+                }
         }
 
         if (bfa_fcs_lport_is_initiator(port)) {
@@ -2366,8 +2403,11 @@ bfa_cb_rport_qos_scn_flowid(void *cbarg,
                 struct bfa_rport_qos_attr_s new_qos_attr)
 {
         struct bfa_fcs_rport_s *rport = (struct bfa_fcs_rport_s *) cbarg;
+        struct bfa_rport_aen_data_s aen_data;
 
         bfa_trc(rport->fcs, rport->pwwn);
+        aen_data.priv.qos = new_qos_attr;
+        bfa_fcs_rport_aen_post(rport, BFA_RPORT_AEN_QOS_FLOWID, &aen_data);
 }
 
 /*
@@ -2390,8 +2430,11 @@ bfa_cb_rport_qos_scn_prio(void *cbarg,
                 struct bfa_rport_qos_attr_s new_qos_attr)
 {
         struct bfa_fcs_rport_s *rport = (struct bfa_fcs_rport_s *) cbarg;
+        struct bfa_rport_aen_data_s aen_data;
 
         bfa_trc(rport->fcs, rport->pwwn);
+        aen_data.priv.qos = new_qos_attr;
+        bfa_fcs_rport_aen_post(rport, BFA_RPORT_AEN_QOS_PRIO, &aen_data);
 }
 
 /*
diff --git a/drivers/scsi/bfa/bfa_hw_cb.c b/drivers/scsi/bfa/bfa_hw_cb.c
index e7ffd8205dc7..ea24d4c6e67a 100644
--- a/drivers/scsi/bfa/bfa_hw_cb.c
+++ b/drivers/scsi/bfa/bfa_hw_cb.c
@@ -42,11 +42,36 @@ bfa_hwcb_reqq_ack_msix(struct bfa_s *bfa, int reqq)
                         bfa->iocfc.bfa_regs.intr_status);
 }
 
+/*
+ * Actions to respond RME Interrupt for Crossbow ASIC:
+ * - Write 1 to Interrupt Status register
+ *              INTX - done in bfa_intx()
+ *              MSIX - done in bfa_hwcb_rspq_ack_msix()
+ * - Update CI (only if new CI)
+ */
 static void
-bfa_hwcb_rspq_ack_msix(struct bfa_s *bfa, int rspq)
+bfa_hwcb_rspq_ack_msix(struct bfa_s *bfa, int rspq, u32 ci)
 {
         writel(__HFN_INT_RME_Q0 << RME_Q_NUM(bfa_ioc_pcifn(&bfa->ioc), rspq),
-                        bfa->iocfc.bfa_regs.intr_status);
+                bfa->iocfc.bfa_regs.intr_status);
+
+        if (bfa_rspq_ci(bfa, rspq) == ci)
+                return;
+
+        bfa_rspq_ci(bfa, rspq) = ci;
+        writel(ci, bfa->iocfc.bfa_regs.rme_q_ci[rspq]);
+        mmiowb();
+}
+
+void
+bfa_hwcb_rspq_ack(struct bfa_s *bfa, int rspq, u32 ci)
+{
+        if (bfa_rspq_ci(bfa, rspq) == ci)
+                return;
+
+        bfa_rspq_ci(bfa, rspq) = ci;
+        writel(ci, bfa->iocfc.bfa_regs.rme_q_ci[rspq]);
+        mmiowb();
 }
 
 void
@@ -149,8 +174,13 @@ bfa_hwcb_msix_uninstall(struct bfa_s *bfa)
 void
 bfa_hwcb_isr_mode_set(struct bfa_s *bfa, bfa_boolean_t msix)
 {
-        bfa->iocfc.hwif.hw_reqq_ack = bfa_hwcb_reqq_ack_msix;
-        bfa->iocfc.hwif.hw_rspq_ack = bfa_hwcb_rspq_ack_msix;
+        if (msix) {
+                bfa->iocfc.hwif.hw_reqq_ack = bfa_hwcb_reqq_ack_msix;
+                bfa->iocfc.hwif.hw_rspq_ack = bfa_hwcb_rspq_ack_msix;
+        } else {
+                bfa->iocfc.hwif.hw_reqq_ack = NULL;
+                bfa->iocfc.hwif.hw_rspq_ack = bfa_hwcb_rspq_ack;
+        }
 }
 
 void
diff --git a/drivers/scsi/bfa/bfa_hw_ct.c b/drivers/scsi/bfa/bfa_hw_ct.c
index 989bbce9b296..637527f48b40 100644
--- a/drivers/scsi/bfa/bfa_hw_ct.c
+++ b/drivers/scsi/bfa/bfa_hw_ct.c
@@ -64,13 +64,36 @@ bfa_hwct_reqq_ack(struct bfa_s *bfa, int reqq)
         writel(r32, bfa->iocfc.bfa_regs.cpe_q_ctrl[reqq]);
 }
 
+/*
+ * Actions to respond RME Interrupt for Catapult ASIC:
+ * - Write 1 to Interrupt Status register (INTx only - done in bfa_intx())
+ * - Acknowledge by writing to RME Queue Control register
+ * - Update CI
+ */
 void
-bfa_hwct_rspq_ack(struct bfa_s *bfa, int rspq)
+bfa_hwct_rspq_ack(struct bfa_s *bfa, int rspq, u32 ci)
 {
         u32     r32;
 
         r32 = readl(bfa->iocfc.bfa_regs.rme_q_ctrl[rspq]);
         writel(r32, bfa->iocfc.bfa_regs.rme_q_ctrl[rspq]);
+
+        bfa_rspq_ci(bfa, rspq) = ci;
+        writel(ci, bfa->iocfc.bfa_regs.rme_q_ci[rspq]);
+        mmiowb();
+}
+
+/*
+ * Actions to respond RME Interrupt for Catapult2 ASIC:
+ * - Write 1 to Interrupt Status register (INTx only - done in bfa_intx())
+ * - Update CI
+ */
+void
+bfa_hwct2_rspq_ack(struct bfa_s *bfa, int rspq, u32 ci)
+{
+        bfa_rspq_ci(bfa, rspq) = ci;
+        writel(ci, bfa->iocfc.bfa_regs.rme_q_ci[rspq]);
+        mmiowb();
 }
 
 void
diff --git a/drivers/scsi/bfa/bfa_ioc.c b/drivers/scsi/bfa/bfa_ioc.c
index d6c2bf3865d2..1ac5aecf25a6 100644
--- a/drivers/scsi/bfa/bfa_ioc.c
+++ b/drivers/scsi/bfa/bfa_ioc.c
@@ -16,6 +16,7 @@
  */
 
 #include "bfad_drv.h"
+#include "bfad_im.h"
 #include "bfa_ioc.h"
 #include "bfi_reg.h"
 #include "bfa_defs.h"
@@ -458,6 +459,7 @@ bfa_ioc_sm_op_entry(struct bfa_ioc_s *ioc)
         ioc->cbfn->enable_cbfn(ioc->bfa, BFA_STATUS_OK);
         bfa_ioc_event_notify(ioc, BFA_IOC_E_ENABLED);
         BFA_LOG(KERN_INFO, bfad, bfa_log_level, "IOC enabled\n");
+        bfa_ioc_aen_post(ioc, BFA_IOC_AEN_ENABLE);
 }
 
 static void
@@ -502,6 +504,7 @@ bfa_ioc_sm_disabling_entry(struct bfa_ioc_s *ioc)
         struct bfad_s *bfad = (struct bfad_s *)ioc->bfa->bfad;
         bfa_fsm_send_event(&ioc->iocpf, IOCPF_E_DISABLE);
         BFA_LOG(KERN_INFO, bfad, bfa_log_level, "IOC disabled\n");
+        bfa_ioc_aen_post(ioc, BFA_IOC_AEN_DISABLE);
 }
 
 /*
@@ -1966,6 +1969,7 @@ bfa_ioc_fail_notify(struct bfa_ioc_s *ioc)
 
         BFA_LOG(KERN_CRIT, bfad, bfa_log_level,
                 "Heart Beat of IOC has failed\n");
+        bfa_ioc_aen_post(ioc, BFA_IOC_AEN_HBFAIL);
 
 }
 
@@ -1980,6 +1984,7 @@ bfa_ioc_pf_fwmismatch(struct bfa_ioc_s *ioc)
         BFA_LOG(KERN_WARNING, bfad, bfa_log_level,
                 "Running firmware version is incompatible "
                 "with the driver version\n");
+        bfa_ioc_aen_post(ioc, BFA_IOC_AEN_FWMISMATCH);
 }
 
 bfa_status_t
@@ -2679,6 +2684,43 @@ bfa_ioc_get_mfg_mac(struct bfa_ioc_s *ioc)
 }
 
 /*
+ * Send AEN notification
+ */
+void
+bfa_ioc_aen_post(struct bfa_ioc_s *ioc, enum bfa_ioc_aen_event event)
+{
+        struct bfad_s *bfad = (struct bfad_s *)ioc->bfa->bfad;
+        struct bfa_aen_entry_s  *aen_entry;
+        enum bfa_ioc_type_e ioc_type;
+
+        bfad_get_aen_entry(bfad, aen_entry);
+        if (!aen_entry)
+                return;
+
+        ioc_type = bfa_ioc_get_type(ioc);
+        switch (ioc_type) {
+        case BFA_IOC_TYPE_FC:
+                aen_entry->aen_data.ioc.pwwn = ioc->attr->pwwn;
+                break;
+        case BFA_IOC_TYPE_FCoE:
+                aen_entry->aen_data.ioc.pwwn = ioc->attr->pwwn;
+                aen_entry->aen_data.ioc.mac = bfa_ioc_get_mac(ioc);
+                break;
+        case BFA_IOC_TYPE_LL:
+                aen_entry->aen_data.ioc.mac = bfa_ioc_get_mac(ioc);
+                break;
+        default:
+                WARN_ON(ioc_type != BFA_IOC_TYPE_FC);
+                break;
+        }
+
+        /* Send the AEN notification */
+        aen_entry->aen_data.ioc.ioc_type = ioc_type;
+        bfad_im_post_vendor_event(aen_entry, bfad, ++ioc->ioc_aen_seq,
+                                  BFA_AEN_CAT_IOC, event);
+}
+
+/*
  * Retrieve saved firmware trace from a prior IOC failure.
  */
 bfa_status_t
@@ -2879,6 +2921,10 @@ bfa_ioc_check_attr_wwns(struct bfa_ioc_s *ioc)
 {
         if (bfa_ioc_get_type(ioc) == BFA_IOC_TYPE_LL)
                 return;
+        if (ioc->attr->nwwn == 0)
+                bfa_ioc_aen_post(ioc, BFA_IOC_AEN_INVALID_NWWN);
+        if (ioc->attr->pwwn == 0)
+                bfa_ioc_aen_post(ioc, BFA_IOC_AEN_INVALID_PWWN);
 }
 
 /*
@@ -3443,6 +3489,54 @@ bfa_sfp_notify(void *sfp_arg, enum bfa_ioc_event_e event)
 }
 
 /*
+ * SFP's State Change Notification post to AEN
+ */
+static void
+bfa_sfp_scn_aen_post(struct bfa_sfp_s *sfp, struct bfi_sfp_scn_s *rsp)
+{
+        struct bfad_s *bfad = (struct bfad_s *)sfp->ioc->bfa->bfad;
+        struct bfa_aen_entry_s  *aen_entry;
+        enum bfa_port_aen_event aen_evt = 0;
+
+        bfa_trc(sfp, (((u64)rsp->pomlvl) << 16) | (((u64)rsp->sfpid) << 8) |
+                      ((u64)rsp->event));
+
+        bfad_get_aen_entry(bfad, aen_entry);
+        if (!aen_entry)
+                return;
+
+        aen_entry->aen_data.port.ioc_type = bfa_ioc_get_type(sfp->ioc);
+        aen_entry->aen_data.port.pwwn = sfp->ioc->attr->pwwn;
+        aen_entry->aen_data.port.mac = bfa_ioc_get_mac(sfp->ioc);
+
+        switch (rsp->event) {
+        case BFA_SFP_SCN_INSERTED:
+                aen_evt = BFA_PORT_AEN_SFP_INSERT;
+                break;
+        case BFA_SFP_SCN_REMOVED:
+                aen_evt = BFA_PORT_AEN_SFP_REMOVE;
+                break;
+        case BFA_SFP_SCN_FAILED:
+                aen_evt = BFA_PORT_AEN_SFP_ACCESS_ERROR;
+                break;
+        case BFA_SFP_SCN_UNSUPPORT:
+                aen_evt = BFA_PORT_AEN_SFP_UNSUPPORT;
+                break;
+        case BFA_SFP_SCN_POM:
+                aen_evt = BFA_PORT_AEN_SFP_POM;
+                aen_entry->aen_data.port.level = rsp->pomlvl;
+                break;
+        default:
+                bfa_trc(sfp, rsp->event);
+                WARN_ON(1);
+        }
+
+        /* Send the AEN notification */
+        bfad_im_post_vendor_event(aen_entry, bfad, ++sfp->ioc->ioc_aen_seq,
+                                  BFA_AEN_CAT_PORT, aen_evt);
+}
+
+/*
  *      SFP get data send
  */
 static void
@@ -3482,6 +3576,50 @@ bfa_sfp_getdata(struct bfa_sfp_s *sfp, enum bfi_sfp_mem_e memtype)
 }
 
 /*
+ *      SFP scn handler
+ */
+static void
+bfa_sfp_scn(struct bfa_sfp_s *sfp, struct bfi_mbmsg_s *msg)
+{
+        struct bfi_sfp_scn_s *rsp = (struct bfi_sfp_scn_s *) msg;
+
+        switch (rsp->event) {
+        case BFA_SFP_SCN_INSERTED:
+                sfp->state = BFA_SFP_STATE_INSERTED;
+                sfp->data_valid = 0;
+                bfa_sfp_scn_aen_post(sfp, rsp);
+                break;
+        case BFA_SFP_SCN_REMOVED:
+                sfp->state = BFA_SFP_STATE_REMOVED;
+                sfp->data_valid = 0;
+                bfa_sfp_scn_aen_post(sfp, rsp);
+                 break;
+        case BFA_SFP_SCN_FAILED:
+                sfp->state = BFA_SFP_STATE_FAILED;
+                sfp->data_valid = 0;
+                bfa_sfp_scn_aen_post(sfp, rsp);
+                break;
+        case BFA_SFP_SCN_UNSUPPORT:
+                sfp->state = BFA_SFP_STATE_UNSUPPORT;
+                bfa_sfp_scn_aen_post(sfp, rsp);
+                if (!sfp->lock)
+                        bfa_sfp_getdata(sfp, BFI_SFP_MEM_ALL);
+                break;
+        case BFA_SFP_SCN_POM:
+                bfa_sfp_scn_aen_post(sfp, rsp);
+                break;
+        case BFA_SFP_SCN_VALID:
+                sfp->state = BFA_SFP_STATE_VALID;
+                if (!sfp->lock)
+                        bfa_sfp_getdata(sfp, BFI_SFP_MEM_ALL);
+                break;
+        default:
+                bfa_trc(sfp, rsp->event);
+                WARN_ON(1);
+        }
+}
+
+/*
  * SFP show complete
  */
 static void
@@ -3645,7 +3783,7 @@ bfa_sfp_intr(void *sfparg, struct bfi_mbmsg_s *msg)
                 break;
 
         case BFI_SFP_I2H_SCN:
-                bfa_trc(sfp, msg->mh.msg_id);
+                bfa_sfp_scn(sfp, msg);
                 break;
 
         default:
@@ -3838,6 +3976,26 @@ bfa_sfp_speed(struct bfa_sfp_s *sfp, enum bfa_port_speed portspeed,
         BFA_ROUNDUP(0x010000 + sizeof(struct bfa_mfg_block_s), BFA_FLASH_SEG_SZ)
 
 static void
+bfa_flash_aen_audit_post(struct bfa_ioc_s *ioc, enum bfa_audit_aen_event event,
+                        int inst, int type)
+{
+        struct bfad_s *bfad = (struct bfad_s *)ioc->bfa->bfad;
+        struct bfa_aen_entry_s  *aen_entry;
+
+        bfad_get_aen_entry(bfad, aen_entry);
+        if (!aen_entry)
+                return;
+
+        aen_entry->aen_data.audit.pwwn = ioc->attr->pwwn;
+        aen_entry->aen_data.audit.partition_inst = inst;
+        aen_entry->aen_data.audit.partition_type = type;
+
+        /* Send the AEN notification */
+        bfad_im_post_vendor_event(aen_entry, bfad, ++ioc->ioc_aen_seq,
+                                  BFA_AEN_CAT_AUDIT, event);
+}
+
+static void
 bfa_flash_cb(struct bfa_flash_s *flash)
 {
         flash->op_busy = 0;
@@ -3978,6 +4136,7 @@ bfa_flash_intr(void *flasharg, struct bfi_mbmsg_s *msg)
                 struct bfi_flash_erase_rsp_s *erase;
                 struct bfi_flash_write_rsp_s *write;
                 struct bfi_flash_read_rsp_s *read;
+                struct bfi_flash_event_s *event;
                 struct bfi_mbmsg_s   *msg;
         } m;
 
@@ -4061,8 +4220,19 @@ bfa_flash_intr(void *flasharg, struct bfi_mbmsg_s *msg)
                 }
                 break;
         case BFI_FLASH_I2H_BOOT_VER_RSP:
+                break;
         case BFI_FLASH_I2H_EVENT:
-                bfa_trc(flash, msg->mh.msg_id);
+                status = be32_to_cpu(m.event->status);
+                bfa_trc(flash, status);
+                if (status == BFA_STATUS_BAD_FWCFG)
+                        bfa_ioc_aen_post(flash->ioc, BFA_IOC_AEN_FWCFG_ERROR);
+                else if (status == BFA_STATUS_INVALID_VENDOR) {
+                        u32 param;
+                        param = be32_to_cpu(m.event->param);
+                        bfa_trc(flash, param);
+                        bfa_ioc_aen_post(flash->ioc,
+                                BFA_IOC_AEN_INVALID_VENDOR);
+                }
                 break;
 
         default:
@@ -4204,6 +4374,8 @@ bfa_flash_erase_part(struct bfa_flash_s *flash, enum bfa_flash_part_type type,
         flash->instance = instance;
 
         bfa_flash_erase_send(flash);
+        bfa_flash_aen_audit_post(flash->ioc, BFA_AUDIT_AEN_FLASH_ERASE,
+                                instance, type);
         return BFA_STATUS_OK;
 }
 
@@ -5416,3 +5588,396 @@ bfa_phy_intr(void *phyarg, struct bfi_mbmsg_s *msg)
                 WARN_ON(1);
         }
 }
+
+/*
+ *      DCONF module specific
+ */
+
+BFA_MODULE(dconf);
+
+/*
+ * DCONF state machine events
+ */
+enum bfa_dconf_event {
+        BFA_DCONF_SM_INIT               = 1,    /* dconf Init */
+        BFA_DCONF_SM_FLASH_COMP         = 2,    /* read/write to flash */
+        BFA_DCONF_SM_WR                 = 3,    /* binding change, map */
+        BFA_DCONF_SM_TIMEOUT            = 4,    /* Start timer */
+        BFA_DCONF_SM_EXIT               = 5,    /* exit dconf module */
+        BFA_DCONF_SM_IOCDISABLE         = 6,    /* IOC disable event */
+};
+
+/* forward declaration of DCONF state machine */
+static void bfa_dconf_sm_uninit(struct bfa_dconf_mod_s *dconf,
+                                enum bfa_dconf_event event);
+static void bfa_dconf_sm_flash_read(struct bfa_dconf_mod_s *dconf,
+                                enum bfa_dconf_event event);
+static void bfa_dconf_sm_ready(struct bfa_dconf_mod_s *dconf,
+                                enum bfa_dconf_event event);
+static void bfa_dconf_sm_dirty(struct bfa_dconf_mod_s *dconf,
+                                enum bfa_dconf_event event);
+static void bfa_dconf_sm_sync(struct bfa_dconf_mod_s *dconf,
+                                enum bfa_dconf_event event);
+static void bfa_dconf_sm_final_sync(struct bfa_dconf_mod_s *dconf,
+                                enum bfa_dconf_event event);
+static void bfa_dconf_sm_iocdown_dirty(struct bfa_dconf_mod_s *dconf,
+                                enum bfa_dconf_event event);
+
+static void bfa_dconf_cbfn(void *dconf, bfa_status_t status);
+static void bfa_dconf_timer(void *cbarg);
+static bfa_status_t bfa_dconf_flash_write(struct bfa_dconf_mod_s *dconf);
+static void bfa_dconf_init_cb(void *arg, bfa_status_t status);
+
+/*
+ * Begining state of dconf module. Waiting for an event to start.
+ */
+static void
+bfa_dconf_sm_uninit(struct bfa_dconf_mod_s *dconf, enum bfa_dconf_event event)
+{
+        bfa_status_t bfa_status;
+        bfa_trc(dconf->bfa, event);
+
+        switch (event) {
+        case BFA_DCONF_SM_INIT:
+                if (dconf->min_cfg) {
+                        bfa_trc(dconf->bfa, dconf->min_cfg);
+                        return;
+                }
+                bfa_sm_set_state(dconf, bfa_dconf_sm_flash_read);
+                dconf->flashdone = BFA_FALSE;
+                bfa_trc(dconf->bfa, dconf->flashdone);
+                bfa_status = bfa_flash_read_part(BFA_FLASH(dconf->bfa),
+                                        BFA_FLASH_PART_DRV, dconf->instance,
+                                        dconf->dconf,
+                                        sizeof(struct bfa_dconf_s), 0,
+                                        bfa_dconf_init_cb, dconf->bfa);
+                if (bfa_status != BFA_STATUS_OK) {
+                        bfa_dconf_init_cb(dconf->bfa, BFA_STATUS_FAILED);
+                        bfa_sm_set_state(dconf, bfa_dconf_sm_uninit);
+                        return;
+                }
+                break;
+        case BFA_DCONF_SM_EXIT:
+                dconf->flashdone = BFA_TRUE;
+        case BFA_DCONF_SM_IOCDISABLE:
+        case BFA_DCONF_SM_WR:
+        case BFA_DCONF_SM_FLASH_COMP:
+                break;
+        default:
+                bfa_sm_fault(dconf->bfa, event);
+        }
+}
+
+/*
+ * Read flash for dconf entries and make a call back to the driver once done.
+ */
+static void
+bfa_dconf_sm_flash_read(struct bfa_dconf_mod_s *dconf,
+                        enum bfa_dconf_event event)
+{
+        bfa_trc(dconf->bfa, event);
+
+        switch (event) {
+        case BFA_DCONF_SM_FLASH_COMP:
+                bfa_sm_set_state(dconf, bfa_dconf_sm_ready);
+                break;
+        case BFA_DCONF_SM_TIMEOUT:
+                bfa_sm_set_state(dconf, bfa_dconf_sm_ready);
+                break;
+        case BFA_DCONF_SM_EXIT:
+                dconf->flashdone = BFA_TRUE;
+                bfa_trc(dconf->bfa, dconf->flashdone);
+        case BFA_DCONF_SM_IOCDISABLE:
+                bfa_sm_set_state(dconf, bfa_dconf_sm_uninit);
+                break;
+        default:
+                bfa_sm_fault(dconf->bfa, event);
+        }
+}
+
+/*
+ * DCONF Module is in ready state. Has completed the initialization.
+ */
+static void
+bfa_dconf_sm_ready(struct bfa_dconf_mod_s *dconf, enum bfa_dconf_event event)
+{
+        bfa_trc(dconf->bfa, event);
+
+        switch (event) {
+        case BFA_DCONF_SM_WR:
+                bfa_timer_start(dconf->bfa, &dconf->timer,
+                        bfa_dconf_timer, dconf, BFA_DCONF_UPDATE_TOV);
+                bfa_sm_set_state(dconf, bfa_dconf_sm_dirty);
+                break;
+        case BFA_DCONF_SM_EXIT:
+                dconf->flashdone = BFA_TRUE;
+                bfa_trc(dconf->bfa, dconf->flashdone);
+                bfa_sm_set_state(dconf, bfa_dconf_sm_uninit);
+                break;
+        case BFA_DCONF_SM_INIT:
+        case BFA_DCONF_SM_IOCDISABLE:
+                break;
+        default:
+                bfa_sm_fault(dconf->bfa, event);
+        }
+}
+
+/*
+ * entries are dirty, write back to the flash.
+ */
+
+static void
+bfa_dconf_sm_dirty(struct bfa_dconf_mod_s *dconf, enum bfa_dconf_event event)
+{
+        bfa_trc(dconf->bfa, event);
+
+        switch (event) {
+        case BFA_DCONF_SM_TIMEOUT:
+                bfa_sm_set_state(dconf, bfa_dconf_sm_sync);
+                bfa_dconf_flash_write(dconf);
+                break;
+        case BFA_DCONF_SM_WR:
+                bfa_timer_stop(&dconf->timer);
+                bfa_timer_start(dconf->bfa, &dconf->timer,
+                        bfa_dconf_timer, dconf, BFA_DCONF_UPDATE_TOV);
+                break;
+        case BFA_DCONF_SM_EXIT:
+                bfa_timer_stop(&dconf->timer);
+                bfa_timer_start(dconf->bfa, &dconf->timer,
+                        bfa_dconf_timer, dconf, BFA_DCONF_UPDATE_TOV);
+                bfa_sm_set_state(dconf, bfa_dconf_sm_final_sync);
+                bfa_dconf_flash_write(dconf);
+                break;
+        case BFA_DCONF_SM_FLASH_COMP:
+                break;
+        case BFA_DCONF_SM_IOCDISABLE:
+                bfa_timer_stop(&dconf->timer);
+                bfa_sm_set_state(dconf, bfa_dconf_sm_iocdown_dirty);
+                break;
+        default:
+                bfa_sm_fault(dconf->bfa, event);
+        }
+}
+
+/*
+ * Sync the dconf entries to the flash.
+ */
+static void
+bfa_dconf_sm_final_sync(struct bfa_dconf_mod_s *dconf,
+                        enum bfa_dconf_event event)
+{
+        bfa_trc(dconf->bfa, event);
+
+        switch (event) {
+        case BFA_DCONF_SM_IOCDISABLE:
+        case BFA_DCONF_SM_FLASH_COMP:
+                bfa_timer_stop(&dconf->timer);
+        case BFA_DCONF_SM_TIMEOUT:
+                bfa_sm_set_state(dconf, bfa_dconf_sm_uninit);
+                dconf->flashdone = BFA_TRUE;
+                bfa_trc(dconf->bfa, dconf->flashdone);
+                bfa_ioc_disable(&dconf->bfa->ioc);
+                break;
+        default:
+                bfa_sm_fault(dconf->bfa, event);
+        }
+}
+
+static void
+bfa_dconf_sm_sync(struct bfa_dconf_mod_s *dconf, enum bfa_dconf_event event)
+{
+        bfa_trc(dconf->bfa, event);
+
+        switch (event) {
+        case BFA_DCONF_SM_FLASH_COMP:
+                bfa_sm_set_state(dconf, bfa_dconf_sm_ready);
+                break;
+        case BFA_DCONF_SM_WR:
+                bfa_timer_start(dconf->bfa, &dconf->timer,
+                        bfa_dconf_timer, dconf, BFA_DCONF_UPDATE_TOV);
+                bfa_sm_set_state(dconf, bfa_dconf_sm_dirty);
+                break;
+        case BFA_DCONF_SM_EXIT:
+                bfa_timer_start(dconf->bfa, &dconf->timer,
+                        bfa_dconf_timer, dconf, BFA_DCONF_UPDATE_TOV);
+                bfa_sm_set_state(dconf, bfa_dconf_sm_final_sync);
+                break;
+        case BFA_DCONF_SM_IOCDISABLE:
+                bfa_sm_set_state(dconf, bfa_dconf_sm_iocdown_dirty);
+                break;
+        default:
+                bfa_sm_fault(dconf->bfa, event);
+        }
+}
+
+static void
+bfa_dconf_sm_iocdown_dirty(struct bfa_dconf_mod_s *dconf,
+                        enum bfa_dconf_event event)
+{
+        bfa_trc(dconf->bfa, event);
+
+        switch (event) {
+        case BFA_DCONF_SM_INIT:
+                bfa_timer_start(dconf->bfa, &dconf->timer,
+                        bfa_dconf_timer, dconf, BFA_DCONF_UPDATE_TOV);
+                bfa_sm_set_state(dconf, bfa_dconf_sm_dirty);
+                break;
+        case BFA_DCONF_SM_EXIT:
+                dconf->flashdone = BFA_TRUE;
+                bfa_sm_set_state(dconf, bfa_dconf_sm_uninit);
+                break;
+        case BFA_DCONF_SM_IOCDISABLE:
+                break;
+        default:
+                bfa_sm_fault(dconf->bfa, event);
+        }
+}
+
+/*
+ * Compute and return memory needed by DRV_CFG module.
+ */
+static void
+bfa_dconf_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *meminfo,
+                  struct bfa_s *bfa)
+{
+        struct bfa_mem_kva_s *dconf_kva = BFA_MEM_DCONF_KVA(bfa);
+
+        if (cfg->drvcfg.min_cfg)
+                bfa_mem_kva_setup(meminfo, dconf_kva,
+                                sizeof(struct bfa_dconf_hdr_s));
+        else
+                bfa_mem_kva_setup(meminfo, dconf_kva,
+                                sizeof(struct bfa_dconf_s));
+}
+
+static void
+bfa_dconf_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
+                struct bfa_pcidev_s *pcidev)
+{
+        struct bfa_dconf_mod_s *dconf = BFA_DCONF_MOD(bfa);
+
+        dconf->bfad = bfad;
+        dconf->bfa = bfa;
+        dconf->instance = bfa->ioc.port_id;
+        bfa_trc(bfa, dconf->instance);
+
+        dconf->dconf = (struct bfa_dconf_s *) bfa_mem_kva_curp(dconf);
+        if (cfg->drvcfg.min_cfg) {
+                bfa_mem_kva_curp(dconf) += sizeof(struct bfa_dconf_hdr_s);
+                dconf->min_cfg = BFA_TRUE;
+                /*
+                 * Set the flashdone flag to TRUE explicitly as no flash
+                 * write will happen in min_cfg mode.
+                 */
+                dconf->flashdone = BFA_TRUE;
+        } else {
+                dconf->min_cfg = BFA_FALSE;
+                bfa_mem_kva_curp(dconf) += sizeof(struct bfa_dconf_s);
+        }
+
+        bfa_dconf_read_data_valid(bfa) = BFA_FALSE;
+        bfa_sm_set_state(dconf, bfa_dconf_sm_uninit);
+}
+
+static void
+bfa_dconf_init_cb(void *arg, bfa_status_t status)
+{
+        struct bfa_s *bfa = arg;
+        struct bfa_dconf_mod_s *dconf = BFA_DCONF_MOD(bfa);
+
+        dconf->flashdone = BFA_TRUE;
+        bfa_trc(bfa, dconf->flashdone);
+        bfa_iocfc_cb_dconf_modinit(bfa, status);
+        if (status == BFA_STATUS_OK) {
+                bfa_dconf_read_data_valid(bfa) = BFA_TRUE;
+                if (dconf->dconf->hdr.signature != BFI_DCONF_SIGNATURE)
+                        dconf->dconf->hdr.signature = BFI_DCONF_SIGNATURE;
+                if (dconf->dconf->hdr.version != BFI_DCONF_VERSION)
+                        dconf->dconf->hdr.version = BFI_DCONF_VERSION;
+        }
+        bfa_sm_send_event(dconf, BFA_DCONF_SM_FLASH_COMP);
+}
+
+void
+bfa_dconf_modinit(struct bfa_s *bfa)
+{
+        struct bfa_dconf_mod_s *dconf = BFA_DCONF_MOD(bfa);
+        bfa_sm_send_event(dconf, BFA_DCONF_SM_INIT);
+}
+static void
+bfa_dconf_start(struct bfa_s *bfa)
+{
+}
+
+static void
+bfa_dconf_stop(struct bfa_s *bfa)
+{
+}
+
+static void bfa_dconf_timer(void *cbarg)
+{
+        struct bfa_dconf_mod_s *dconf = cbarg;
+        bfa_sm_send_event(dconf, BFA_DCONF_SM_TIMEOUT);
+}
+static void
+bfa_dconf_iocdisable(struct bfa_s *bfa)
+{
+        struct bfa_dconf_mod_s *dconf = BFA_DCONF_MOD(bfa);
+        bfa_sm_send_event(dconf, BFA_DCONF_SM_IOCDISABLE);
+}
+
+static void
+bfa_dconf_detach(struct bfa_s *bfa)
+{
+}
+
+static bfa_status_t
+bfa_dconf_flash_write(struct bfa_dconf_mod_s *dconf)
+{
+        bfa_status_t bfa_status;
+        bfa_trc(dconf->bfa, 0);
+
+        bfa_status = bfa_flash_update_part(BFA_FLASH(dconf->bfa),
+                                BFA_FLASH_PART_DRV, dconf->instance,
+                                dconf->dconf,  sizeof(struct bfa_dconf_s), 0,
+                                bfa_dconf_cbfn, dconf);
+        if (bfa_status != BFA_STATUS_OK)
+                WARN_ON(bfa_status);
+        bfa_trc(dconf->bfa, bfa_status);
+
+        return bfa_status;
+}
+
+bfa_status_t
+bfa_dconf_update(struct bfa_s *bfa)
+{
+        struct bfa_dconf_mod_s *dconf = BFA_DCONF_MOD(bfa);
+        bfa_trc(dconf->bfa, 0);
+        if (bfa_sm_cmp_state(dconf, bfa_dconf_sm_iocdown_dirty))
+                return BFA_STATUS_FAILED;
+
+        if (dconf->min_cfg) {
+                bfa_trc(dconf->bfa, dconf->min_cfg);
+                return BFA_STATUS_FAILED;
+        }
+
+        bfa_sm_send_event(dconf, BFA_DCONF_SM_WR);
+        return BFA_STATUS_OK;
+}
+
+static void
+bfa_dconf_cbfn(void *arg, bfa_status_t status)
+{
+        struct bfa_dconf_mod_s *dconf = arg;
+        WARN_ON(status);
+        bfa_sm_send_event(dconf, BFA_DCONF_SM_FLASH_COMP);
+}
+
+void
+bfa_dconf_modexit(struct bfa_s *bfa)
+{
+        struct bfa_dconf_mod_s *dconf = BFA_DCONF_MOD(bfa);
+        BFA_DCONF_MOD(bfa)->flashdone = BFA_FALSE;
+        bfa_trc(bfa, BFA_DCONF_MOD(bfa)->flashdone);
+        bfa_sm_send_event(dconf, BFA_DCONF_SM_EXIT);
+}
diff --git a/drivers/scsi/bfa/bfa_ioc.h b/drivers/scsi/bfa/bfa_ioc.h
index c5ecd2edc95d..546d46b37101 100644
--- a/drivers/scsi/bfa/bfa_ioc.h
+++ b/drivers/scsi/bfa/bfa_ioc.h
@@ -327,6 +327,7 @@ struct bfa_ioc_s {
         enum bfa_mode_s         port_mode;
         u8                      ad_cap_bm;      /* adapter cap bit mask */
         u8                      port_mode_cfg;  /* config port mode */
+        int                     ioc_aen_seq;
 };
 
 struct bfa_ioc_hwif_s {
@@ -366,6 +367,8 @@ struct bfa_cb_qe_s {
         struct list_head        qe;
         bfa_cb_cbfn_t   cbfn;
         bfa_boolean_t   once;
+        bfa_boolean_t   pre_rmv;        /* set for stack based qe(s) */
+        bfa_status_t    fw_status;      /* to access fw status in comp proc */
         void            *cbarg;
 };
 
@@ -658,7 +661,6 @@ struct bfa_phy_s {
         struct bfa_ioc_notify_s ioc_notify; /* ioc event notify */
         struct bfa_mem_dma_s    phy_dma;
 };
-
 #define BFA_PHY(__bfa)  (&(__bfa)->modules.phy)
 #define BFA_MEM_PHY_DMA(__bfa)  (&(BFA_PHY(__bfa)->phy_dma))
 
@@ -684,6 +686,49 @@ void bfa_phy_memclaim(struct bfa_phy_s *phy,
 void bfa_phy_intr(void *phyarg, struct bfi_mbmsg_s *msg);
 
 /*
+ * Driver Config( dconf) specific
+ */
+#define BFI_DCONF_SIGNATURE     0xabcdabcd
+#define BFI_DCONF_VERSION       1
+
+#pragma pack(1)
+struct bfa_dconf_hdr_s {
+        u32     signature;
+        u32     version;
+};
+
+struct bfa_dconf_s {
+        struct bfa_dconf_hdr_s          hdr;
+        struct bfa_lunmask_cfg_s        lun_mask;
+};
+#pragma pack()
+
+struct bfa_dconf_mod_s {
+        bfa_sm_t                sm;
+        u8                      instance;
+        bfa_boolean_t           flashdone;
+        bfa_boolean_t           read_data_valid;
+        bfa_boolean_t           min_cfg;
+        struct bfa_timer_s      timer;
+        struct bfa_s            *bfa;
+        void                    *bfad;
+        void                    *trcmod;
+        struct bfa_dconf_s      *dconf;
+        struct bfa_mem_kva_s    kva_seg;
+};
+
+#define BFA_DCONF_MOD(__bfa)    \
+        (&(__bfa)->modules.dconf_mod)
+#define BFA_MEM_DCONF_KVA(__bfa)        (&(BFA_DCONF_MOD(__bfa)->kva_seg))
+#define bfa_dconf_read_data_valid(__bfa)        \
+        (BFA_DCONF_MOD(__bfa)->read_data_valid)
+#define BFA_DCONF_UPDATE_TOV    5000    /* memtest timeout in msec */
+
+void    bfa_dconf_modinit(struct bfa_s *bfa);
+void    bfa_dconf_modexit(struct bfa_s *bfa);
+bfa_status_t    bfa_dconf_update(struct bfa_s *bfa);
+
+/*
  *      IOC specfic macros
  */
 #define bfa_ioc_pcifn(__ioc)            ((__ioc)->pcidev.pci_func)
@@ -803,6 +848,7 @@ void bfa_ioc_fwver_get(struct bfa_ioc_s *ioc,
                         struct bfi_ioc_image_hdr_s *fwhdr);
 bfa_boolean_t bfa_ioc_fwver_cmp(struct bfa_ioc_s *ioc,
                         struct bfi_ioc_image_hdr_s *fwhdr);
+void bfa_ioc_aen_post(struct bfa_ioc_s *ioc, enum bfa_ioc_aen_event event);
 bfa_status_t bfa_ioc_fw_stats_get(struct bfa_ioc_s *ioc, void *stats);
 bfa_status_t bfa_ioc_fw_stats_clear(struct bfa_ioc_s *ioc);
 
diff --git a/drivers/scsi/bfa/bfa_modules.h b/drivers/scsi/bfa/bfa_modules.h
index 1c6efd40a673..2d36e4823835 100644
--- a/drivers/scsi/bfa/bfa_modules.h
+++ b/drivers/scsi/bfa/bfa_modules.h
@@ -44,6 +44,7 @@ struct bfa_modules_s {
         struct bfa_flash_s      flash;          /*  flash module */
         struct bfa_diag_s       diag_mod;       /*  diagnostics module  */
         struct bfa_phy_s        phy;            /*  phy module          */
+        struct bfa_dconf_mod_s  dconf_mod;      /*  DCONF common module */
 };
 
 /*
@@ -119,6 +120,7 @@ struct bfa_s {
         struct list_head        reqq_waitq[BFI_IOC_MAX_CQS];
         bfa_boolean_t           fcs;            /*  FCS is attached to BFA */
         struct bfa_msix_s       msix;
+        int                     bfa_aen_seq;
 };
 
 extern bfa_boolean_t bfa_auto_recover;
@@ -130,5 +132,6 @@ extern struct bfa_module_s hal_mod_lps;
 extern struct bfa_module_s hal_mod_uf;
 extern struct bfa_module_s hal_mod_rport;
 extern struct bfa_module_s hal_mod_fcp;
+extern struct bfa_module_s hal_mod_dconf;
 
 #endif /* __BFA_MODULES_H__ */
diff --git a/drivers/scsi/bfa/bfa_svc.c b/drivers/scsi/bfa/bfa_svc.c
index 21caaefce99f..aa8a0eaf91f9 100644
--- a/drivers/scsi/bfa/bfa_svc.c
+++ b/drivers/scsi/bfa/bfa_svc.c
@@ -16,6 +16,7 @@
  */
 
 #include "bfad_drv.h"
+#include "bfad_im.h"
 #include "bfa_plog.h"
 #include "bfa_cs.h"
 #include "bfa_modules.h"
@@ -2007,6 +2008,24 @@ bfa_lps_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
         }
 }
 
+static void
+bfa_fcport_aen_post(struct bfa_fcport_s *fcport, enum bfa_port_aen_event event)
+{
+        struct bfad_s *bfad = (struct bfad_s *)fcport->bfa->bfad;
+        struct bfa_aen_entry_s  *aen_entry;
+
+        bfad_get_aen_entry(bfad, aen_entry);
+        if (!aen_entry)
+                return;
+
+        aen_entry->aen_data.port.ioc_type = bfa_get_type(fcport->bfa);
+        aen_entry->aen_data.port.pwwn = fcport->pwwn;
+
+        /* Send the AEN notification */
+        bfad_im_post_vendor_event(aen_entry, bfad, ++fcport->bfa->bfa_aen_seq,
+                                  BFA_AEN_CAT_PORT, event);
+}
+
 /*
  * FC PORT state machine functions
  */
@@ -2095,6 +2114,7 @@ bfa_fcport_sm_enabling_qwait(struct bfa_fcport_s *fcport,
                 wwn2str(pwwn_buf, fcport->pwwn);
                 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
                         "Base port disabled: WWN = %s\n", pwwn_buf);
+                bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISABLE);
                 break;
 
         case BFA_FCPORT_SM_LINKUP:
@@ -2155,6 +2175,7 @@ bfa_fcport_sm_enabling(struct bfa_fcport_s *fcport,
                 wwn2str(pwwn_buf, fcport->pwwn);
                 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
                         "Base port disabled: WWN = %s\n", pwwn_buf);
+                bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISABLE);
                 break;
 
         case BFA_FCPORT_SM_STOP:
@@ -2208,6 +2229,12 @@ bfa_fcport_sm_linkdown(struct bfa_fcport_s *fcport,
                 wwn2str(pwwn_buf, fcport->pwwn);
                 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
                         "Base port online: WWN = %s\n", pwwn_buf);
+                bfa_fcport_aen_post(fcport, BFA_PORT_AEN_ONLINE);
+
+                /* If QoS is enabled and it is not online, send AEN */
+                if (fcport->cfg.qos_enabled &&
+                    fcport->qos_attr.state != BFA_QOS_ONLINE)
+                        bfa_fcport_aen_post(fcport, BFA_PORT_AEN_QOS_NEG);
                 break;
 
         case BFA_FCPORT_SM_LINKDOWN:
@@ -2234,6 +2261,7 @@ bfa_fcport_sm_linkdown(struct bfa_fcport_s *fcport,
                 wwn2str(pwwn_buf, fcport->pwwn);
                 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
                         "Base port disabled: WWN = %s\n", pwwn_buf);
+                bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISABLE);
                 break;
 
         case BFA_FCPORT_SM_STOP:
@@ -2279,8 +2307,10 @@ bfa_fcport_sm_linkup(struct bfa_fcport_s *fcport,
                 wwn2str(pwwn_buf, fcport->pwwn);
                 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
                         "Base port offline: WWN = %s\n", pwwn_buf);
+                bfa_fcport_aen_post(fcport, BFA_PORT_AEN_OFFLINE);
                 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
                         "Base port disabled: WWN = %s\n", pwwn_buf);
+                bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISABLE);
                 break;
 
         case BFA_FCPORT_SM_LINKDOWN:
@@ -2290,26 +2320,32 @@ bfa_fcport_sm_linkup(struct bfa_fcport_s *fcport,
                 bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
                                 BFA_PL_EID_PORT_ST_CHANGE, 0, "Port Linkdown");
                 wwn2str(pwwn_buf, fcport->pwwn);
-                if (BFA_PORT_IS_DISABLED(fcport->bfa))
+                if (BFA_PORT_IS_DISABLED(fcport->bfa)) {
                         BFA_LOG(KERN_INFO, bfad, bfa_log_level,
                                 "Base port offline: WWN = %s\n", pwwn_buf);
-                else
+                        bfa_fcport_aen_post(fcport, BFA_PORT_AEN_OFFLINE);
+                } else {
                         BFA_LOG(KERN_ERR, bfad, bfa_log_level,
                                 "Base port (WWN = %s) "
                                 "lost fabric connectivity\n", pwwn_buf);
+                        bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT);
+                }
                 break;
 
         case BFA_FCPORT_SM_STOP:
                 bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
                 bfa_fcport_reset_linkinfo(fcport);
                 wwn2str(pwwn_buf, fcport->pwwn);
-                if (BFA_PORT_IS_DISABLED(fcport->bfa))
+                if (BFA_PORT_IS_DISABLED(fcport->bfa)) {
                         BFA_LOG(KERN_INFO, bfad, bfa_log_level,
                                 "Base port offline: WWN = %s\n", pwwn_buf);
-                else
+                        bfa_fcport_aen_post(fcport, BFA_PORT_AEN_OFFLINE);
+                } else {
                         BFA_LOG(KERN_ERR, bfad, bfa_log_level,
                                 "Base port (WWN = %s) "
                                 "lost fabric connectivity\n", pwwn_buf);
+                        bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT);
+                }
                 break;
 
         case BFA_FCPORT_SM_HWFAIL:
@@ -2317,13 +2353,16 @@ bfa_fcport_sm_linkup(struct bfa_fcport_s *fcport,
                 bfa_fcport_reset_linkinfo(fcport);
                 bfa_fcport_scn(fcport, BFA_PORT_LINKDOWN, BFA_FALSE);
                 wwn2str(pwwn_buf, fcport->pwwn);
-                if (BFA_PORT_IS_DISABLED(fcport->bfa))
+                if (BFA_PORT_IS_DISABLED(fcport->bfa)) {
                         BFA_LOG(KERN_INFO, bfad, bfa_log_level,
                                 "Base port offline: WWN = %s\n", pwwn_buf);
-                else
+                        bfa_fcport_aen_post(fcport, BFA_PORT_AEN_OFFLINE);
+                } else {
                         BFA_LOG(KERN_ERR, bfad, bfa_log_level,
                                 "Base port (WWN = %s) "
                                 "lost fabric connectivity\n", pwwn_buf);
+                        bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT);
+                }
                 break;
 
         default:
@@ -2454,6 +2493,7 @@ bfa_fcport_sm_disabling(struct bfa_fcport_s *fcport,
                 wwn2str(pwwn_buf, fcport->pwwn);
                 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
                         "Base port enabled: WWN = %s\n", pwwn_buf);
+                bfa_fcport_aen_post(fcport, BFA_PORT_AEN_ENABLE);
                 break;
 
         case BFA_FCPORT_SM_STOP:
@@ -2508,6 +2548,7 @@ bfa_fcport_sm_disabled(struct bfa_fcport_s *fcport,
                 wwn2str(pwwn_buf, fcport->pwwn);
                 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
                         "Base port enabled: WWN = %s\n", pwwn_buf);
+                bfa_fcport_aen_post(fcport, BFA_PORT_AEN_ENABLE);
                 break;
 
         case BFA_FCPORT_SM_DISABLE:
@@ -2874,6 +2915,9 @@ bfa_fcport_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
 
         port_cfg->trl_def_speed = BFA_PORT_SPEED_1GBPS;
 
+        INIT_LIST_HEAD(&fcport->stats_pending_q);
+        INIT_LIST_HEAD(&fcport->statsclr_pending_q);
+
         bfa_reqq_winit(&fcport->reqq_wait, bfa_fcport_qresume, fcport);
 }
 
@@ -3102,30 +3146,38 @@ bfa_fcport_fcoe_stats_swap(struct bfa_fcoe_stats_s *d,
 static void
 __bfa_cb_fcport_stats_get(void *cbarg, bfa_boolean_t complete)
 {
-        struct bfa_fcport_s *fcport = cbarg;
+        struct bfa_fcport_s *fcport = (struct bfa_fcport_s *)cbarg;
+        struct bfa_cb_pending_q_s *cb;
+        struct list_head *qe, *qen;
+        union bfa_fcport_stats_u *ret;
 
         if (complete) {
-                if (fcport->stats_status == BFA_STATUS_OK) {
-                        struct timeval tv;
-
-                        /* Swap FC QoS or FCoE stats */
-                        if (bfa_ioc_get_fcmode(&fcport->bfa->ioc)) {
-                                bfa_fcport_qos_stats_swap(
-                                        &fcport->stats_ret->fcqos,
-                                        &fcport->stats->fcqos);
-                        } else {
-                                bfa_fcport_fcoe_stats_swap(
-                                        &fcport->stats_ret->fcoe,
-                                        &fcport->stats->fcoe);
-
-                                do_gettimeofday(&tv);
-                                fcport->stats_ret->fcoe.secs_reset =
+                struct timeval tv;
+                if (fcport->stats_status == BFA_STATUS_OK)
+                        do_gettimeofday(&tv);
+
+                list_for_each_safe(qe, qen, &fcport->stats_pending_q) {
+                        bfa_q_deq(&fcport->stats_pending_q, &qe);
+                        cb = (struct bfa_cb_pending_q_s *)qe;
+                        if (fcport->stats_status == BFA_STATUS_OK) {
+                                ret = (union bfa_fcport_stats_u *)cb->data;
+                                /* Swap FC QoS or FCoE stats */
+                                if (bfa_ioc_get_fcmode(&fcport->bfa->ioc))
+                                        bfa_fcport_qos_stats_swap(&ret->fcqos,
+                                                        &fcport->stats->fcqos);
+                                else {
+                                        bfa_fcport_fcoe_stats_swap(&ret->fcoe,
+                                                        &fcport->stats->fcoe);
+                                        ret->fcoe.secs_reset =
                                         tv.tv_sec - fcport->stats_reset_time;
+                                }
                         }
+                        bfa_cb_queue_status(fcport->bfa, &cb->hcb_qe,
+                                        fcport->stats_status);
                 }
-                fcport->stats_cbfn(fcport->stats_cbarg, fcport->stats_status);
+                fcport->stats_status = BFA_STATUS_OK;
         } else {
-                fcport->stats_busy = BFA_FALSE;
+                INIT_LIST_HEAD(&fcport->stats_pending_q);
                 fcport->stats_status = BFA_STATUS_OK;
         }
 }
@@ -3143,8 +3195,7 @@ bfa_fcport_stats_get_timeout(void *cbarg)
         }
 
         fcport->stats_status = BFA_STATUS_ETIMER;
-        bfa_cb_queue(fcport->bfa, &fcport->hcb_qe, __bfa_cb_fcport_stats_get,
-                fcport);
+        __bfa_cb_fcport_stats_get(fcport, BFA_TRUE);
 }
 
 static void
@@ -3174,7 +3225,9 @@ bfa_fcport_send_stats_get(void *cbarg)
 static void
 __bfa_cb_fcport_stats_clr(void *cbarg, bfa_boolean_t complete)
 {
-        struct bfa_fcport_s *fcport = cbarg;
+        struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
+        struct bfa_cb_pending_q_s *cb;
+        struct list_head *qe, *qen;
 
         if (complete) {
                 struct timeval tv;
@@ -3184,10 +3237,15 @@ __bfa_cb_fcport_stats_clr(void *cbarg, bfa_boolean_t complete)
                  */
                 do_gettimeofday(&tv);
                 fcport->stats_reset_time = tv.tv_sec;
-
-                fcport->stats_cbfn(fcport->stats_cbarg, fcport->stats_status);
+                list_for_each_safe(qe, qen, &fcport->statsclr_pending_q) {
+                        bfa_q_deq(&fcport->statsclr_pending_q, &qe);
+                        cb = (struct bfa_cb_pending_q_s *)qe;
+                        bfa_cb_queue_status(fcport->bfa, &cb->hcb_qe,
+                                                fcport->stats_status);
+                }
+                fcport->stats_status = BFA_STATUS_OK;
         } else {
-                fcport->stats_busy = BFA_FALSE;
+                INIT_LIST_HEAD(&fcport->statsclr_pending_q);
                 fcport->stats_status = BFA_STATUS_OK;
         }
 }
@@ -3205,8 +3263,7 @@ bfa_fcport_stats_clr_timeout(void *cbarg)
         }
 
         fcport->stats_status = BFA_STATUS_ETIMER;
-        bfa_cb_queue(fcport->bfa, &fcport->hcb_qe,
-                        __bfa_cb_fcport_stats_clr, fcport);
+        __bfa_cb_fcport_stats_clr(fcport, BFA_TRUE);
 }
 
 static void
@@ -3402,6 +3459,11 @@ bfa_fcport_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
                                 fcport->use_flash_cfg = BFA_FALSE;
                         }
 
+                        if (fcport->cfg.qos_enabled)
+                                fcport->qos_attr.state = BFA_QOS_OFFLINE;
+                        else
+                                fcport->qos_attr.state = BFA_QOS_DISABLED;
+
                         bfa_sm_send_event(fcport, BFA_FCPORT_SM_FWRSP);
                 }
                 break;
@@ -3426,28 +3488,26 @@ bfa_fcport_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
                 /*
                  * check for timer pop before processing the rsp
                  */
-                if (fcport->stats_busy == BFA_FALSE ||
-                    fcport->stats_status == BFA_STATUS_ETIMER)
+                if (list_empty(&fcport->stats_pending_q) ||
+                    (fcport->stats_status == BFA_STATUS_ETIMER))
                         break;
 
                 bfa_timer_stop(&fcport->timer);
                 fcport->stats_status = i2hmsg.pstatsget_rsp->status;
-                bfa_cb_queue(fcport->bfa, &fcport->hcb_qe,
-                                __bfa_cb_fcport_stats_get, fcport);
+                __bfa_cb_fcport_stats_get(fcport, BFA_TRUE);
                 break;
 
         case BFI_FCPORT_I2H_STATS_CLEAR_RSP:
                 /*
                  * check for timer pop before processing the rsp
                  */
-                if (fcport->stats_busy == BFA_FALSE ||
-                    fcport->stats_status == BFA_STATUS_ETIMER)
+                if (list_empty(&fcport->statsclr_pending_q) ||
+                    (fcport->stats_status == BFA_STATUS_ETIMER))
                         break;
 
                 bfa_timer_stop(&fcport->timer);
                 fcport->stats_status = BFA_STATUS_OK;
-                bfa_cb_queue(fcport->bfa, &fcport->hcb_qe,
-                                __bfa_cb_fcport_stats_clr, fcport);
+                __bfa_cb_fcport_stats_clr(fcport, BFA_TRUE);
                 break;
 
         case BFI_FCPORT_I2H_ENABLE_AEN:
@@ -3779,25 +3839,25 @@ bfa_fcport_get_attr(struct bfa_s *bfa, struct bfa_port_attr_s *attr)
  * Fetch port statistics (FCQoS or FCoE).
  */
 bfa_status_t
-bfa_fcport_get_stats(struct bfa_s *bfa, union bfa_fcport_stats_u *stats,
-        bfa_cb_port_t cbfn, void *cbarg)
+bfa_fcport_get_stats(struct bfa_s *bfa, struct bfa_cb_pending_q_s *cb)
 {
         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
 
-        if (fcport->stats_busy) {
-                bfa_trc(bfa, fcport->stats_busy);
-                return BFA_STATUS_DEVBUSY;
-        }
+        if (bfa_ioc_is_disabled(&bfa->ioc))
+                return BFA_STATUS_IOC_DISABLED;
 
-        fcport->stats_busy  = BFA_TRUE;
-        fcport->stats_ret   = stats;
-        fcport->stats_cbfn  = cbfn;
-        fcport->stats_cbarg = cbarg;
+        if (!list_empty(&fcport->statsclr_pending_q))
+                return BFA_STATUS_DEVBUSY;
 
-        bfa_fcport_send_stats_get(fcport);
+        if (list_empty(&fcport->stats_pending_q)) {
+                list_add_tail(&cb->hcb_qe.qe, &fcport->stats_pending_q);
+                bfa_fcport_send_stats_get(fcport);
+                bfa_timer_start(bfa, &fcport->timer,
+                                bfa_fcport_stats_get_timeout,
+                                fcport, BFA_FCPORT_STATS_TOV);
+        } else
+                list_add_tail(&cb->hcb_qe.qe, &fcport->stats_pending_q);
 
-        bfa_timer_start(bfa, &fcport->timer, bfa_fcport_stats_get_timeout,
-                        fcport, BFA_FCPORT_STATS_TOV);
         return BFA_STATUS_OK;
 }
 
@@ -3805,27 +3865,25 @@ bfa_fcport_get_stats(struct bfa_s *bfa, union bfa_fcport_stats_u *stats,
  * Reset port statistics (FCQoS or FCoE).
  */
 bfa_status_t
-bfa_fcport_clear_stats(struct bfa_s *bfa, bfa_cb_port_t cbfn, void *cbarg)
+bfa_fcport_clear_stats(struct bfa_s *bfa, struct bfa_cb_pending_q_s *cb)
 {
         struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
 
-        if (fcport->stats_busy) {
-                bfa_trc(bfa, fcport->stats_busy);
+        if (!list_empty(&fcport->stats_pending_q))
                 return BFA_STATUS_DEVBUSY;
-        }
-
-        fcport->stats_busy  = BFA_TRUE;
-        fcport->stats_cbfn  = cbfn;
-        fcport->stats_cbarg = cbarg;
 
-        bfa_fcport_send_stats_clear(fcport);
+        if (list_empty(&fcport->statsclr_pending_q)) {
+                list_add_tail(&cb->hcb_qe.qe, &fcport->statsclr_pending_q);
+                bfa_fcport_send_stats_clear(fcport);
+                bfa_timer_start(bfa, &fcport->timer,
+                                bfa_fcport_stats_clr_timeout,
+                                fcport, BFA_FCPORT_STATS_TOV);
+        } else
+                list_add_tail(&cb->hcb_qe.qe, &fcport->statsclr_pending_q);
 
-        bfa_timer_start(bfa, &fcport->timer, bfa_fcport_stats_clr_timeout,
-                        fcport, BFA_FCPORT_STATS_TOV);
         return BFA_STATUS_OK;
 }
 
-
 /*
  * Fetch port attributes.
  */
@@ -4619,6 +4677,7 @@ bfa_rport_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
                 rp = BFA_RPORT_FROM_TAG(bfa, msg.create_rsp->bfa_handle);
                 rp->fw_handle = msg.create_rsp->fw_handle;
                 rp->qos_attr = msg.create_rsp->qos_attr;
+                bfa_rport_set_lunmask(bfa, rp);
                 WARN_ON(msg.create_rsp->status != BFA_STATUS_OK);
                 bfa_sm_send_event(rp, BFA_RPORT_SM_FWRSP);
                 break;
@@ -4626,6 +4685,7 @@ bfa_rport_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
         case BFI_RPORT_I2H_DELETE_RSP:
                 rp = BFA_RPORT_FROM_TAG(bfa, msg.delete_rsp->bfa_handle);
                 WARN_ON(msg.delete_rsp->status != BFA_STATUS_OK);
+                bfa_rport_unset_lunmask(bfa, rp);
                 bfa_sm_send_event(rp, BFA_RPORT_SM_FWRSP);
                 break;
 
@@ -4706,6 +4766,37 @@ bfa_rport_speed(struct bfa_rport_s *rport, enum bfa_port_speed speed)
         bfa_sm_send_event(rport, BFA_RPORT_SM_SET_SPEED);
 }
 
+/* Set Rport LUN Mask */
+void
+bfa_rport_set_lunmask(struct bfa_s *bfa, struct bfa_rport_s *rp)
+{
+        struct bfa_lps_mod_s    *lps_mod = BFA_LPS_MOD(bfa);
+        wwn_t   lp_wwn, rp_wwn;
+        u8 lp_tag = (u8)rp->rport_info.lp_tag;
+
+        rp_wwn = ((struct bfa_fcs_rport_s *)rp->rport_drv)->pwwn;
+        lp_wwn = (BFA_LPS_FROM_TAG(lps_mod, rp->rport_info.lp_tag))->pwwn;
+
+        BFA_LPS_FROM_TAG(lps_mod, rp->rport_info.lp_tag)->lun_mask =
+                                        rp->lun_mask = BFA_TRUE;
+        bfa_fcpim_lunmask_rp_update(bfa, lp_wwn, rp_wwn, rp->rport_tag, lp_tag);
+}
+
+/* Unset Rport LUN mask */
+void
+bfa_rport_unset_lunmask(struct bfa_s *bfa, struct bfa_rport_s *rp)
+{
+        struct bfa_lps_mod_s    *lps_mod = BFA_LPS_MOD(bfa);
+        wwn_t   lp_wwn, rp_wwn;
+
+        rp_wwn = ((struct bfa_fcs_rport_s *)rp->rport_drv)->pwwn;
+        lp_wwn = (BFA_LPS_FROM_TAG(lps_mod, rp->rport_info.lp_tag))->pwwn;
+
+        BFA_LPS_FROM_TAG(lps_mod, rp->rport_info.lp_tag)->lun_mask =
+                                rp->lun_mask = BFA_FALSE;
+        bfa_fcpim_lunmask_rp_update(bfa, lp_wwn, rp_wwn,
+                        BFA_RPORT_TAG_INVALID, BFA_LP_TAG_INVALID);
+}
 
 /*
  * SGPG related functions
@@ -5517,11 +5608,29 @@ bfa_fcdiag_loopback(struct bfa_s *bfa, enum bfa_port_opmode opmode,
                 return BFA_STATUS_PORT_NOT_DISABLED;
         }
 
-        /* Check if the speed is supported */
-        bfa_fcport_get_attr(bfa, &attr);
-        bfa_trc(fcdiag, attr.speed_supported);
-        if (speed > attr.speed_supported)
-                return BFA_STATUS_UNSUPP_SPEED;
+        /*
+         * Check if input speed is supported by the port mode
+         */
+        if (bfa_ioc_get_type(&bfa->ioc) == BFA_IOC_TYPE_FC) {
+                if (!(speed == BFA_PORT_SPEED_1GBPS ||
+                      speed == BFA_PORT_SPEED_2GBPS ||
+                      speed == BFA_PORT_SPEED_4GBPS ||
+                      speed == BFA_PORT_SPEED_8GBPS ||
+                      speed == BFA_PORT_SPEED_16GBPS ||
+                      speed == BFA_PORT_SPEED_AUTO)) {
+                        bfa_trc(fcdiag, speed);
+                        return BFA_STATUS_UNSUPP_SPEED;
+                }
+                bfa_fcport_get_attr(bfa, &attr);
+                bfa_trc(fcdiag, attr.speed_supported);
+                if (speed > attr.speed_supported)
+                        return BFA_STATUS_UNSUPP_SPEED;
+        } else {
+                if (speed != BFA_PORT_SPEED_10GBPS) {
+                        bfa_trc(fcdiag, speed);
+                        return BFA_STATUS_UNSUPP_SPEED;
+                }
+        }
 
         /* For Mezz card, port speed entered needs to be checked */
         if (bfa_mfg_is_mezz(bfa->ioc.attr->card_type)) {
diff --git a/drivers/scsi/bfa/bfa_svc.h b/drivers/scsi/bfa/bfa_svc.h
index fbe513a671b5..95adb86d3769 100644
--- a/drivers/scsi/bfa/bfa_svc.h
+++ b/drivers/scsi/bfa/bfa_svc.h
@@ -297,6 +297,7 @@ struct bfa_rport_s {
         void            *rport_drv;     /*  fcs/driver rport object         */
         u16     fw_handle;      /*  firmware rport handle           */
         u16     rport_tag;      /*  BFA rport tag                   */
+        u8      lun_mask;       /*  LUN mask flag                   */
         struct bfa_rport_info_s rport_info; /*  rport info from fcs/driver */
         struct bfa_reqq_wait_s reqq_wait; /*  to wait for room in reqq     */
         struct bfa_cb_qe_s hcb_qe;      /*  BFA callback qelem              */
@@ -404,6 +405,7 @@ struct bfa_lps_s {
         u8              bb_scn;         /*  local BB_SCN                */
         u8              lsrjt_rsn;      /*  LSRJT reason                */
         u8              lsrjt_expl;     /*  LSRJT explanation           */
+        u8              lun_mask;       /*  LUN mask flag               */
         wwn_t           pwwn;           /*  port wwn of lport           */
         wwn_t           nwwn;           /*  node wwn of lport           */
         wwn_t           pr_pwwn;        /*  port wwn of lport peer      */
@@ -441,7 +443,6 @@ void	bfa_lps_isr(struct bfa_s *bfa, struct bfi_msg_s *msg);
  */
 
 #define BFA_FCPORT(_bfa)        (&((_bfa)->modules.port))
-typedef void (*bfa_cb_port_t) (void *cbarg, enum bfa_status status);
 
 /*
  * Link notification data structure
@@ -495,13 +496,11 @@ struct bfa_fcport_s {
         u8                      *stats_kva;
         u64             stats_pa;
         union bfa_fcport_stats_u *stats;
-        union bfa_fcport_stats_u *stats_ret; /*  driver stats location */
         bfa_status_t            stats_status; /*  stats/statsclr status */
-        bfa_boolean_t           stats_busy; /*  outstanding stats/statsclr */
+        struct list_head        stats_pending_q;
+        struct list_head        statsclr_pending_q;
         bfa_boolean_t           stats_qfull;
         u32             stats_reset_time; /*  stats reset time stamp */
-        bfa_cb_port_t           stats_cbfn; /*  driver callback function */
-        void                    *stats_cbarg; /* *!< user callback arg */
         bfa_boolean_t           diag_busy; /*  diag busy status */
         bfa_boolean_t           beacon; /*  port beacon status */
         bfa_boolean_t           link_e2e_beacon; /*  link beacon status */
@@ -552,10 +551,9 @@ void bfa_fcport_beacon(void *dev, bfa_boolean_t beacon,
                         bfa_boolean_t link_e2e_beacon);
 bfa_boolean_t   bfa_fcport_is_linkup(struct bfa_s *bfa);
 bfa_status_t bfa_fcport_get_stats(struct bfa_s *bfa,
-                                  union bfa_fcport_stats_u *stats,
-                                  bfa_cb_port_t cbfn, void *cbarg);
-bfa_status_t bfa_fcport_clear_stats(struct bfa_s *bfa, bfa_cb_port_t cbfn,
-                                    void *cbarg);
+                        struct bfa_cb_pending_q_s *cb);
+bfa_status_t bfa_fcport_clear_stats(struct bfa_s *bfa,
+                        struct bfa_cb_pending_q_s *cb);
 bfa_boolean_t bfa_fcport_is_qos_enabled(struct bfa_s *bfa);
 bfa_boolean_t bfa_fcport_is_trunk_enabled(struct bfa_s *bfa);
 bfa_status_t bfa_fcport_is_pbcdisabled(struct bfa_s *bfa);
@@ -578,6 +576,19 @@ void bfa_cb_rport_qos_scn_prio(void *rport,
                                struct bfa_rport_qos_attr_s new_qos_attr);
 
 /*
+ *      Rport LUN masking related
+ */
+#define BFA_RPORT_TAG_INVALID   0xffff
+#define BFA_LP_TAG_INVALID      0xff
+void    bfa_rport_set_lunmask(struct bfa_s *bfa, struct bfa_rport_s *rp);
+void    bfa_rport_unset_lunmask(struct bfa_s *bfa, struct bfa_rport_s *rp);
+bfa_boolean_t   bfa_rport_lunmask_active(struct bfa_rport_s *rp);
+wwn_t   bfa_rport_get_pwwn(struct bfa_s *bfa, struct bfa_rport_s *rp);
+struct bfa_rport_s *bfa_rport_get_by_wwn(struct bfa_s *bfa, u16 vf_id,
+                                         wwn_t *lpwwn, wwn_t rpwwn);
+void *bfa_cb_get_rp_by_wwn(void *arg, u16 vf_id, wwn_t *lpwwn, wwn_t rpwwn);
+
+/*
  * bfa fcxp API functions
  */
 struct bfa_fcxp_s *bfa_fcxp_alloc(void *bfad_fcxp, struct bfa_s *bfa,
diff --git a/drivers/scsi/bfa/bfad.c b/drivers/scsi/bfa/bfad.c
index beb30a748ea5..66fb72531b34 100644
--- a/drivers/scsi/bfa/bfad.c
+++ b/drivers/scsi/bfa/bfad.c
@@ -1348,7 +1348,7 @@ int
 bfad_pci_probe(struct pci_dev *pdev, const struct pci_device_id *pid)
 {
         struct bfad_s   *bfad;
-        int             error = -ENODEV, retval;
+        int             error = -ENODEV, retval, i;
 
         /* For single port cards - only claim function 0 */
         if ((pdev->device == BFA_PCI_DEVICE_ID_FC_8G1P) &&
@@ -1372,6 +1372,12 @@ bfad_pci_probe(struct pci_dev *pdev, const struct pci_device_id *pid)
         bfa_trc_init(bfad->trcmod);
         bfa_trc(bfad, bfad_inst);
 
+        /* AEN INIT */
+        INIT_LIST_HEAD(&bfad->free_aen_q);
+        INIT_LIST_HEAD(&bfad->active_aen_q);
+        for (i = 0; i < BFA_AEN_MAX_ENTRY; i++)
+                list_add_tail(&bfad->aen_list[i].qe, &bfad->free_aen_q);
+
         if (!(bfad_load_fwimg(pdev))) {
                 kfree(bfad->trcmod);
                 goto out_alloc_trace_failure;
diff --git a/drivers/scsi/bfa/bfad_bsg.c b/drivers/scsi/bfa/bfad_bsg.c
index 89f863ed2334..06fc00caeb41 100644
--- a/drivers/scsi/bfa/bfad_bsg.c
+++ b/drivers/scsi/bfa/bfad_bsg.c
@@ -56,7 +56,7 @@ bfad_iocmd_ioc_disable(struct bfad_s *bfad, void *cmd)
         spin_lock_irqsave(&bfad->bfad_lock, flags);
         if (bfad->disable_active) {
                 spin_unlock_irqrestore(&bfad->bfad_lock, flags);
-                return EBUSY;
+                return -EBUSY;
         }
 
         bfad->disable_active = BFA_TRUE;
@@ -90,6 +90,7 @@ bfad_iocmd_ioc_get_info(struct bfad_s *bfad, void *cmd)
         bfa_get_adapter_serial_num(&bfad->bfa, iocmd->serialnum);
         iocmd->factorynwwn = pattr.factorynwwn;
         iocmd->factorypwwn = pattr.factorypwwn;
+        iocmd->bfad_num = bfad->inst_no;
         im_port = bfad->pport.im_port;
         iocmd->host = im_port->shost->host_no;
         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
@@ -178,6 +179,38 @@ out:
 }
 
 int
+bfad_iocmd_ioc_reset_stats(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)
+{
+        struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
+        unsigned long   flags;
+
+        if (v_cmd == IOCMD_IOC_RESET_STATS) {
+                bfa_ioc_clear_stats(&bfad->bfa);
+                iocmd->status = BFA_STATUS_OK;
+        } else if (v_cmd == IOCMD_IOC_RESET_FWSTATS) {
+                spin_lock_irqsave(&bfad->bfad_lock, flags);
+                iocmd->status = bfa_ioc_fw_stats_clear(&bfad->bfa.ioc);
+                spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+        }
+
+        return 0;
+}
+
+int
+bfad_iocmd_ioc_set_name(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)
+{
+        struct bfa_bsg_ioc_name_s *iocmd = (struct bfa_bsg_ioc_name_s *) cmd;
+
+        if (v_cmd == IOCMD_IOC_SET_ADAPTER_NAME)
+                strcpy(bfad->adapter_name, iocmd->name);
+        else if (v_cmd == IOCMD_IOC_SET_PORT_NAME)
+                strcpy(bfad->port_name, iocmd->name);
+
+        iocmd->status = BFA_STATUS_OK;
+        return 0;
+}
+
+int
 bfad_iocmd_iocfc_get_attr(struct bfad_s *bfad, void *cmd)
 {
         struct bfa_bsg_iocfc_attr_s *iocmd = (struct bfa_bsg_iocfc_attr_s *)cmd;
@@ -306,6 +339,81 @@ out:
         return 0;
 }
 
+int
+bfad_iocmd_port_reset_stats(struct bfad_s *bfad, void *cmd)
+{
+        struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
+        struct bfad_hal_comp fcomp;
+        unsigned long   flags;
+
+        init_completion(&fcomp.comp);
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        iocmd->status = bfa_port_clear_stats(&bfad->bfa.modules.port,
+                                        bfad_hcb_comp, &fcomp);
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+        if (iocmd->status != BFA_STATUS_OK) {
+                bfa_trc(bfad, iocmd->status);
+                return 0;
+        }
+        wait_for_completion(&fcomp.comp);
+        iocmd->status = fcomp.status;
+        return 0;
+}
+
+int
+bfad_iocmd_set_port_cfg(struct bfad_s *bfad, void *iocmd, unsigned int v_cmd)
+{
+        struct bfa_bsg_port_cfg_s *cmd = (struct bfa_bsg_port_cfg_s *)iocmd;
+        unsigned long   flags;
+
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        if (v_cmd == IOCMD_PORT_CFG_TOPO)
+                cmd->status = bfa_fcport_cfg_topology(&bfad->bfa, cmd->param);
+        else if (v_cmd == IOCMD_PORT_CFG_SPEED)
+                cmd->status = bfa_fcport_cfg_speed(&bfad->bfa, cmd->param);
+        else if (v_cmd == IOCMD_PORT_CFG_ALPA)
+                cmd->status = bfa_fcport_cfg_hardalpa(&bfad->bfa, cmd->param);
+        else if (v_cmd == IOCMD_PORT_CLR_ALPA)
+                cmd->status = bfa_fcport_clr_hardalpa(&bfad->bfa);
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+
+        return 0;
+}
+
+int
+bfad_iocmd_port_cfg_maxfrsize(struct bfad_s *bfad, void *cmd)
+{
+        struct bfa_bsg_port_cfg_maxfrsize_s *iocmd =
+                                (struct bfa_bsg_port_cfg_maxfrsize_s *)cmd;
+        unsigned long   flags;
+
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        iocmd->status = bfa_fcport_cfg_maxfrsize(&bfad->bfa, iocmd->maxfrsize);
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+
+        return 0;
+}
+
+int
+bfad_iocmd_port_cfg_bbsc(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)
+{
+        struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
+        unsigned long   flags;
+
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        if (bfa_ioc_get_type(&bfad->bfa.ioc) == BFA_IOC_TYPE_FC) {
+                if (v_cmd == IOCMD_PORT_BBSC_ENABLE)
+                        fcport->cfg.bb_scn_state = BFA_TRUE;
+                else if (v_cmd == IOCMD_PORT_BBSC_DISABLE)
+                        fcport->cfg.bb_scn_state = BFA_FALSE;
+        }
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+
+        iocmd->status = BFA_STATUS_OK;
+        return 0;
+}
+
 static int
 bfad_iocmd_lport_get_attr(struct bfad_s *bfad, void *cmd)
 {
@@ -354,6 +462,40 @@ out:
 }
 
 int
+bfad_iocmd_lport_reset_stats(struct bfad_s *bfad, void *cmd)
+{
+        struct bfa_fcs_lport_s *fcs_port;
+        struct bfa_bsg_reset_stats_s *iocmd =
+                        (struct bfa_bsg_reset_stats_s *)cmd;
+        struct bfa_fcpim_s *fcpim = BFA_FCPIM(&bfad->bfa);
+        struct list_head *qe, *qen;
+        struct bfa_itnim_s *itnim;
+        unsigned long   flags;
+
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
+                                iocmd->vf_id, iocmd->vpwwn);
+        if (fcs_port == NULL) {
+                spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+                iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
+                goto out;
+        }
+
+        bfa_fcs_lport_clear_stats(fcs_port);
+        /* clear IO stats from all active itnims */
+        list_for_each_safe(qe, qen, &fcpim->itnim_q) {
+                itnim = (struct bfa_itnim_s *) qe;
+                if (itnim->rport->rport_info.lp_tag != fcs_port->lp_tag)
+                        continue;
+                bfa_itnim_clear_stats(itnim);
+        }
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+        iocmd->status = BFA_STATUS_OK;
+out:
+        return 0;
+}
+
+int
 bfad_iocmd_lport_get_iostats(struct bfad_s *bfad, void *cmd)
 {
         struct bfa_fcs_lport_s *fcs_port;
@@ -389,7 +531,7 @@ bfad_iocmd_lport_get_rports(struct bfad_s *bfad, void *cmd,
         void    *iocmd_bufptr;
 
         if (iocmd->nrports == 0)
-                return EINVAL;
+                return -EINVAL;
 
         if (bfad_chk_iocmd_sz(payload_len,
                         sizeof(struct bfa_bsg_lport_get_rports_s),
@@ -539,6 +681,152 @@ out:
         return 0;
 }
 
+int
+bfad_iocmd_rport_clr_stats(struct bfad_s *bfad, void *cmd)
+{
+        struct bfa_bsg_rport_reset_stats_s *iocmd =
+                                (struct bfa_bsg_rport_reset_stats_s *)cmd;
+        struct bfa_fcs_lport_s *fcs_port;
+        struct bfa_fcs_rport_s *fcs_rport;
+        struct bfa_rport_s *rport;
+        unsigned long   flags;
+
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
+                                iocmd->vf_id, iocmd->pwwn);
+        if (fcs_port == NULL) {
+                spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+                iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
+                goto out;
+        }
+
+        fcs_rport = bfa_fcs_rport_lookup(fcs_port, iocmd->rpwwn);
+        if (fcs_rport == NULL) {
+                spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+                iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
+                goto out;
+        }
+
+        memset((char *)&fcs_rport->stats, 0, sizeof(struct bfa_rport_stats_s));
+        rport = bfa_fcs_rport_get_halrport(fcs_rport);
+        memset(&rport->stats, 0, sizeof(rport->stats));
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+        iocmd->status = BFA_STATUS_OK;
+out:
+        return 0;
+}
+
+int
+bfad_iocmd_rport_set_speed(struct bfad_s *bfad, void *cmd)
+{
+        struct bfa_bsg_rport_set_speed_s *iocmd =
+                                (struct bfa_bsg_rport_set_speed_s *)cmd;
+        struct bfa_fcs_lport_s *fcs_port;
+        struct bfa_fcs_rport_s *fcs_rport;
+        unsigned long   flags;
+
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
+                                iocmd->vf_id, iocmd->pwwn);
+        if (fcs_port == NULL) {
+                spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+                iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
+                goto out;
+        }
+
+        fcs_rport = bfa_fcs_rport_lookup(fcs_port, iocmd->rpwwn);
+        if (fcs_rport == NULL) {
+                spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+                iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
+                goto out;
+        }
+
+        fcs_rport->rpf.assigned_speed  = iocmd->speed;
+        /* Set this speed in f/w only if the RPSC speed is not available */
+        if (fcs_rport->rpf.rpsc_speed == BFA_PORT_SPEED_UNKNOWN)
+                bfa_rport_speed(fcs_rport->bfa_rport, iocmd->speed);
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+        iocmd->status = BFA_STATUS_OK;
+out:
+        return 0;
+}
+
+int
+bfad_iocmd_vport_get_attr(struct bfad_s *bfad, void *cmd)
+{
+        struct bfa_fcs_vport_s *fcs_vport;
+        struct bfa_bsg_vport_attr_s *iocmd = (struct bfa_bsg_vport_attr_s *)cmd;
+        unsigned long   flags;
+
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        fcs_vport = bfa_fcs_vport_lookup(&bfad->bfa_fcs,
+                                iocmd->vf_id, iocmd->vpwwn);
+        if (fcs_vport == NULL) {
+                spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+                iocmd->status = BFA_STATUS_UNKNOWN_VWWN;
+                goto out;
+        }
+
+        bfa_fcs_vport_get_attr(fcs_vport, &iocmd->vport_attr);
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+        iocmd->status = BFA_STATUS_OK;
+out:
+        return 0;
+}
+
+int
+bfad_iocmd_vport_get_stats(struct bfad_s *bfad, void *cmd)
+{
+        struct bfa_fcs_vport_s *fcs_vport;
+        struct bfa_bsg_vport_stats_s *iocmd =
+                                (struct bfa_bsg_vport_stats_s *)cmd;
+        unsigned long   flags;
+
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        fcs_vport = bfa_fcs_vport_lookup(&bfad->bfa_fcs,
+                                iocmd->vf_id, iocmd->vpwwn);
+        if (fcs_vport == NULL) {
+                spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+                iocmd->status = BFA_STATUS_UNKNOWN_VWWN;
+                goto out;
+        }
+
+        memcpy((void *)&iocmd->vport_stats, (void *)&fcs_vport->vport_stats,
+                sizeof(struct bfa_vport_stats_s));
+        memcpy((void *)&iocmd->vport_stats.port_stats,
+               (void *)&fcs_vport->lport.stats,
+                sizeof(struct bfa_lport_stats_s));
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+        iocmd->status = BFA_STATUS_OK;
+out:
+        return 0;
+}
+
+int
+bfad_iocmd_vport_clr_stats(struct bfad_s *bfad, void *cmd)
+{
+        struct bfa_fcs_vport_s *fcs_vport;
+        struct bfa_bsg_reset_stats_s *iocmd =
+                                (struct bfa_bsg_reset_stats_s *)cmd;
+        unsigned long   flags;
+
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        fcs_vport = bfa_fcs_vport_lookup(&bfad->bfa_fcs,
+                                iocmd->vf_id, iocmd->vpwwn);
+        if (fcs_vport == NULL) {
+                spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+                iocmd->status = BFA_STATUS_UNKNOWN_VWWN;
+                goto out;
+        }
+
+        memset(&fcs_vport->vport_stats, 0, sizeof(struct bfa_vport_stats_s));
+        memset(&fcs_vport->lport.stats, 0, sizeof(struct bfa_lport_stats_s));
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+        iocmd->status = BFA_STATUS_OK;
+out:
+        return 0;
+}
+
 static int
 bfad_iocmd_fabric_get_lports(struct bfad_s *bfad, void *cmd,
                         unsigned int payload_len)
@@ -582,6 +870,66 @@ out:
 }
 
 int
+bfad_iocmd_ratelim(struct bfad_s *bfad, unsigned int cmd, void *pcmd)
+{
+        struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)pcmd;
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
+        unsigned long   flags;
+
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+
+        if (cmd == IOCMD_RATELIM_ENABLE)
+                fcport->cfg.ratelimit = BFA_TRUE;
+        else if (cmd == IOCMD_RATELIM_DISABLE)
+                fcport->cfg.ratelimit = BFA_FALSE;
+
+        if (fcport->cfg.trl_def_speed == BFA_PORT_SPEED_UNKNOWN)
+                fcport->cfg.trl_def_speed = BFA_PORT_SPEED_1GBPS;
+
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+        iocmd->status = BFA_STATUS_OK;
+
+        return 0;
+}
+
+int
+bfad_iocmd_ratelim_speed(struct bfad_s *bfad, unsigned int cmd, void *pcmd)
+{
+        struct bfa_bsg_trl_speed_s *iocmd = (struct bfa_bsg_trl_speed_s *)pcmd;
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
+        unsigned long   flags;
+
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+
+        /* Auto and speeds greater than the supported speed, are invalid */
+        if ((iocmd->speed == BFA_PORT_SPEED_AUTO) ||
+            (iocmd->speed > fcport->speed_sup)) {
+                iocmd->status = BFA_STATUS_UNSUPP_SPEED;
+                spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+                return 0;
+        }
+
+        fcport->cfg.trl_def_speed = iocmd->speed;
+        iocmd->status = BFA_STATUS_OK;
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+
+        return 0;
+}
+
+int
+bfad_iocmd_cfg_fcpim(struct bfad_s *bfad, void *cmd)
+{
+        struct bfa_bsg_fcpim_s *iocmd = (struct bfa_bsg_fcpim_s *)cmd;
+        unsigned long   flags;
+
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        bfa_fcpim_path_tov_set(&bfad->bfa, iocmd->param);
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+        iocmd->status = BFA_STATUS_OK;
+        return 0;
+}
+
+int
 bfad_iocmd_fcpim_get_modstats(struct bfad_s *bfad, void *cmd)
 {
         struct bfa_bsg_fcpim_modstats_s *iocmd =
@@ -604,6 +952,28 @@ bfad_iocmd_fcpim_get_modstats(struct bfad_s *bfad, void *cmd)
 }
 
 int
+bfad_iocmd_fcpim_clr_modstats(struct bfad_s *bfad, void *cmd)
+{
+        struct bfa_bsg_fcpim_modstatsclr_s *iocmd =
+                                (struct bfa_bsg_fcpim_modstatsclr_s *)cmd;
+        struct bfa_fcpim_s *fcpim = BFA_FCPIM(&bfad->bfa);
+        struct list_head *qe, *qen;
+        struct bfa_itnim_s *itnim;
+        unsigned long   flags;
+
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        list_for_each_safe(qe, qen, &fcpim->itnim_q) {
+                itnim = (struct bfa_itnim_s *) qe;
+                bfa_itnim_clear_stats(itnim);
+        }
+        memset(&fcpim->del_itn_stats, 0,
+                sizeof(struct bfa_fcpim_del_itn_stats_s));
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+        iocmd->status = BFA_STATUS_OK;
+        return 0;
+}
+
+int
 bfad_iocmd_fcpim_get_del_itn_stats(struct bfad_s *bfad, void *cmd)
 {
         struct bfa_bsg_fcpim_del_itn_stats_s *iocmd =
@@ -670,6 +1040,35 @@ bfad_iocmd_itnim_get_iostats(struct bfad_s *bfad, void *cmd)
 }
 
 static int
+bfad_iocmd_itnim_reset_stats(struct bfad_s *bfad, void *cmd)
+{
+        struct bfa_bsg_rport_reset_stats_s *iocmd =
+                        (struct bfa_bsg_rport_reset_stats_s *)cmd;
+        struct bfa_fcs_lport_s  *fcs_port;
+        struct bfa_fcs_itnim_s  *itnim;
+        unsigned long   flags;
+
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
+                                iocmd->vf_id, iocmd->pwwn);
+        if (!fcs_port)
+                iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
+        else {
+                itnim = bfa_fcs_itnim_lookup(fcs_port, iocmd->rpwwn);
+                if (itnim == NULL)
+                        iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
+                else {
+                        iocmd->status = BFA_STATUS_OK;
+                        bfa_fcs_itnim_stats_clear(fcs_port, iocmd->rpwwn);
+                        bfa_itnim_clear_stats(bfa_fcs_itnim_get_halitn(itnim));
+                }
+        }
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+
+        return 0;
+}
+
+static int
 bfad_iocmd_itnim_get_itnstats(struct bfad_s *bfad, void *cmd)
 {
         struct bfa_bsg_itnim_itnstats_s *iocmd =
@@ -1511,11 +1910,545 @@ out:
         return 0;
 }
 
+#define BFA_DEBUG_FW_CORE_CHUNK_SZ      0x4000U /* 16K chunks for FW dump */
+int
+bfad_iocmd_debug_fw_core(struct bfad_s *bfad, void *cmd,
+                        unsigned int payload_len)
+{
+        struct bfa_bsg_debug_s *iocmd = (struct bfa_bsg_debug_s *)cmd;
+        void    *iocmd_bufptr;
+        unsigned long   flags;
+
+        if (bfad_chk_iocmd_sz(payload_len, sizeof(struct bfa_bsg_debug_s),
+                        BFA_DEBUG_FW_CORE_CHUNK_SZ) != BFA_STATUS_OK) {
+                iocmd->status = BFA_STATUS_VERSION_FAIL;
+                return 0;
+        }
+
+        if (iocmd->bufsz < BFA_DEBUG_FW_CORE_CHUNK_SZ ||
+                        !IS_ALIGNED(iocmd->bufsz, sizeof(u16)) ||
+                        !IS_ALIGNED(iocmd->offset, sizeof(u32))) {
+                bfa_trc(bfad, BFA_DEBUG_FW_CORE_CHUNK_SZ);
+                iocmd->status = BFA_STATUS_EINVAL;
+                goto out;
+        }
+
+        iocmd_bufptr = (char *)iocmd + sizeof(struct bfa_bsg_debug_s);
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        iocmd->status = bfa_ioc_debug_fwcore(&bfad->bfa.ioc, iocmd_bufptr,
+                                (u32 *)&iocmd->offset, &iocmd->bufsz);
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+out:
+        return 0;
+}
+
+int
+bfad_iocmd_debug_ctl(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)
+{
+        struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
+        unsigned long   flags;
+
+        if (v_cmd == IOCMD_DEBUG_FW_STATE_CLR) {
+                spin_lock_irqsave(&bfad->bfad_lock, flags);
+                bfad->bfa.ioc.dbg_fwsave_once = BFA_TRUE;
+                spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+        } else if (v_cmd == IOCMD_DEBUG_PORTLOG_CLR)
+                bfad->plog_buf.head = bfad->plog_buf.tail = 0;
+        else if (v_cmd == IOCMD_DEBUG_START_DTRC)
+                bfa_trc_init(bfad->trcmod);
+        else if (v_cmd == IOCMD_DEBUG_STOP_DTRC)
+                bfa_trc_stop(bfad->trcmod);
+
+        iocmd->status = BFA_STATUS_OK;
+        return 0;
+}
+
+int
+bfad_iocmd_porglog_ctl(struct bfad_s *bfad, void *cmd)
+{
+        struct bfa_bsg_portlogctl_s *iocmd = (struct bfa_bsg_portlogctl_s *)cmd;
+
+        if (iocmd->ctl == BFA_TRUE)
+                bfad->plog_buf.plog_enabled = 1;
+        else
+                bfad->plog_buf.plog_enabled = 0;
+
+        iocmd->status = BFA_STATUS_OK;
+        return 0;
+}
+
+int
+bfad_iocmd_fcpim_cfg_profile(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)
+{
+        struct bfa_bsg_fcpim_profile_s *iocmd =
+                                (struct bfa_bsg_fcpim_profile_s *)cmd;
+        struct timeval  tv;
+        unsigned long   flags;
+
+        do_gettimeofday(&tv);
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        if (v_cmd == IOCMD_FCPIM_PROFILE_ON)
+                iocmd->status = bfa_fcpim_profile_on(&bfad->bfa, tv.tv_sec);
+        else if (v_cmd == IOCMD_FCPIM_PROFILE_OFF)
+                iocmd->status = bfa_fcpim_profile_off(&bfad->bfa);
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+
+        return 0;
+}
+
+static int
+bfad_iocmd_itnim_get_ioprofile(struct bfad_s *bfad, void *cmd)
+{
+        struct bfa_bsg_itnim_ioprofile_s *iocmd =
+                                (struct bfa_bsg_itnim_ioprofile_s *)cmd;
+        struct bfa_fcs_lport_s *fcs_port;
+        struct bfa_fcs_itnim_s *itnim;
+        unsigned long   flags;
+
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
+                                iocmd->vf_id, iocmd->lpwwn);
+        if (!fcs_port)
+                iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
+        else {
+                itnim = bfa_fcs_itnim_lookup(fcs_port, iocmd->rpwwn);
+                if (itnim == NULL)
+                        iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
+                else
+                        iocmd->status = bfa_itnim_get_ioprofile(
+                                                bfa_fcs_itnim_get_halitn(itnim),
+                                                &iocmd->ioprofile);
+        }
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+        return 0;
+}
+
+int
+bfad_iocmd_fcport_get_stats(struct bfad_s *bfad, void *cmd)
+{
+        struct bfa_bsg_fcport_stats_s *iocmd =
+                                (struct bfa_bsg_fcport_stats_s *)cmd;
+        struct bfad_hal_comp fcomp;
+        unsigned long   flags;
+        struct bfa_cb_pending_q_s cb_qe;
+
+        init_completion(&fcomp.comp);
+        bfa_pending_q_init(&cb_qe, (bfa_cb_cbfn_t)bfad_hcb_comp,
+                           &fcomp, &iocmd->stats);
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        iocmd->status = bfa_fcport_get_stats(&bfad->bfa, &cb_qe);
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+        if (iocmd->status != BFA_STATUS_OK) {
+                bfa_trc(bfad, iocmd->status);
+                goto out;
+        }
+        wait_for_completion(&fcomp.comp);
+        iocmd->status = fcomp.status;
+out:
+        return 0;
+}
+
+int
+bfad_iocmd_fcport_reset_stats(struct bfad_s *bfad, void *cmd)
+{
+        struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
+        struct bfad_hal_comp fcomp;
+        unsigned long   flags;
+        struct bfa_cb_pending_q_s cb_qe;
+
+        init_completion(&fcomp.comp);
+        bfa_pending_q_init(&cb_qe, (bfa_cb_cbfn_t)bfad_hcb_comp, &fcomp, NULL);
+
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        iocmd->status = bfa_fcport_clear_stats(&bfad->bfa, &cb_qe);
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+        if (iocmd->status != BFA_STATUS_OK) {
+                bfa_trc(bfad, iocmd->status);
+                goto out;
+        }
+        wait_for_completion(&fcomp.comp);
+        iocmd->status = fcomp.status;
+out:
+        return 0;
+}
+
+int
+bfad_iocmd_boot_cfg(struct bfad_s *bfad, void *cmd)
+{
+        struct bfa_bsg_boot_s *iocmd = (struct bfa_bsg_boot_s *)cmd;
+        struct bfad_hal_comp fcomp;
+        unsigned long   flags;
+
+        init_completion(&fcomp.comp);
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        iocmd->status = bfa_flash_update_part(BFA_FLASH(&bfad->bfa),
+                        BFA_FLASH_PART_BOOT, PCI_FUNC(bfad->pcidev->devfn),
+                        &iocmd->cfg, sizeof(struct bfa_boot_cfg_s), 0,
+                        bfad_hcb_comp, &fcomp);
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+        if (iocmd->status != BFA_STATUS_OK)
+                goto out;
+        wait_for_completion(&fcomp.comp);
+        iocmd->status = fcomp.status;
+out:
+        return 0;
+}
+
+int
+bfad_iocmd_boot_query(struct bfad_s *bfad, void *cmd)
+{
+        struct bfa_bsg_boot_s *iocmd = (struct bfa_bsg_boot_s *)cmd;
+        struct bfad_hal_comp fcomp;
+        unsigned long   flags;
+
+        init_completion(&fcomp.comp);
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        iocmd->status = bfa_flash_read_part(BFA_FLASH(&bfad->bfa),
+                        BFA_FLASH_PART_BOOT, PCI_FUNC(bfad->pcidev->devfn),
+                        &iocmd->cfg, sizeof(struct bfa_boot_cfg_s), 0,
+                        bfad_hcb_comp, &fcomp);
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+        if (iocmd->status != BFA_STATUS_OK)
+                goto out;
+        wait_for_completion(&fcomp.comp);
+        iocmd->status = fcomp.status;
+out:
+        return 0;
+}
+
+int
+bfad_iocmd_preboot_query(struct bfad_s *bfad, void *cmd)
+{
+        struct bfa_bsg_preboot_s *iocmd = (struct bfa_bsg_preboot_s *)cmd;
+        struct bfi_iocfc_cfgrsp_s *cfgrsp = bfad->bfa.iocfc.cfgrsp;
+        struct bfa_boot_pbc_s *pbcfg = &iocmd->cfg;
+        unsigned long   flags;
+
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        pbcfg->enable = cfgrsp->pbc_cfg.boot_enabled;
+        pbcfg->nbluns = cfgrsp->pbc_cfg.nbluns;
+        pbcfg->speed = cfgrsp->pbc_cfg.port_speed;
+        memcpy(pbcfg->pblun, cfgrsp->pbc_cfg.blun, sizeof(pbcfg->pblun));
+        iocmd->status = BFA_STATUS_OK;
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+
+        return 0;
+}
+
+int
+bfad_iocmd_ethboot_cfg(struct bfad_s *bfad, void *cmd)
+{
+        struct bfa_bsg_ethboot_s *iocmd = (struct bfa_bsg_ethboot_s *)cmd;
+        struct bfad_hal_comp fcomp;
+        unsigned long   flags;
+
+        init_completion(&fcomp.comp);
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        iocmd->status = bfa_flash_update_part(BFA_FLASH(&bfad->bfa),
+                                BFA_FLASH_PART_PXECFG,
+                                bfad->bfa.ioc.port_id, &iocmd->cfg,
+                                sizeof(struct bfa_ethboot_cfg_s), 0,
+                                bfad_hcb_comp, &fcomp);
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+        if (iocmd->status != BFA_STATUS_OK)
+                goto out;
+        wait_for_completion(&fcomp.comp);
+        iocmd->status = fcomp.status;
+out:
+        return 0;
+}
+
+int
+bfad_iocmd_ethboot_query(struct bfad_s *bfad, void *cmd)
+{
+        struct bfa_bsg_ethboot_s *iocmd = (struct bfa_bsg_ethboot_s *)cmd;
+        struct bfad_hal_comp fcomp;
+        unsigned long   flags;
+
+        init_completion(&fcomp.comp);
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        iocmd->status = bfa_flash_read_part(BFA_FLASH(&bfad->bfa),
+                                BFA_FLASH_PART_PXECFG,
+                                bfad->bfa.ioc.port_id, &iocmd->cfg,
+                                sizeof(struct bfa_ethboot_cfg_s), 0,
+                                bfad_hcb_comp, &fcomp);
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+        if (iocmd->status != BFA_STATUS_OK)
+                goto out;
+        wait_for_completion(&fcomp.comp);
+        iocmd->status = fcomp.status;
+out:
+        return 0;
+}
+
+int
+bfad_iocmd_cfg_trunk(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)
+{
+        struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
+        struct bfa_fcport_trunk_s *trunk = &fcport->trunk;
+        unsigned long   flags;
+
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+
+        if (v_cmd == IOCMD_TRUNK_ENABLE) {
+                trunk->attr.state = BFA_TRUNK_OFFLINE;
+                bfa_fcport_disable(&bfad->bfa);
+                fcport->cfg.trunked = BFA_TRUE;
+        } else if (v_cmd == IOCMD_TRUNK_DISABLE) {
+                trunk->attr.state = BFA_TRUNK_DISABLED;
+                bfa_fcport_disable(&bfad->bfa);
+                fcport->cfg.trunked = BFA_FALSE;
+        }
+
+        if (!bfa_fcport_is_disabled(&bfad->bfa))
+                bfa_fcport_enable(&bfad->bfa);
+
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+
+        iocmd->status = BFA_STATUS_OK;
+        return 0;
+}
+
+int
+bfad_iocmd_trunk_get_attr(struct bfad_s *bfad, void *cmd)
+{
+        struct bfa_bsg_trunk_attr_s *iocmd = (struct bfa_bsg_trunk_attr_s *)cmd;
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
+        struct bfa_fcport_trunk_s *trunk = &fcport->trunk;
+        unsigned long   flags;
+
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        memcpy((void *)&iocmd->attr, (void *)&trunk->attr,
+                sizeof(struct bfa_trunk_attr_s));
+        iocmd->attr.port_id = bfa_lps_get_base_pid(&bfad->bfa);
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+
+        iocmd->status = BFA_STATUS_OK;
+        return 0;
+}
+
+int
+bfad_iocmd_qos(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)
+{
+        struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
+        unsigned long   flags;
+
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        if (bfa_ioc_get_type(&bfad->bfa.ioc) == BFA_IOC_TYPE_FC) {
+                if (v_cmd == IOCMD_QOS_ENABLE)
+                        fcport->cfg.qos_enabled = BFA_TRUE;
+                else if (v_cmd == IOCMD_QOS_DISABLE)
+                        fcport->cfg.qos_enabled = BFA_FALSE;
+        }
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+
+        iocmd->status = BFA_STATUS_OK;
+        return 0;
+}
+
+int
+bfad_iocmd_qos_get_attr(struct bfad_s *bfad, void *cmd)
+{
+        struct bfa_bsg_qos_attr_s *iocmd = (struct bfa_bsg_qos_attr_s *)cmd;
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
+        unsigned long   flags;
+
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        iocmd->attr.state = fcport->qos_attr.state;
+        iocmd->attr.total_bb_cr = be32_to_cpu(fcport->qos_attr.total_bb_cr);
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+
+        iocmd->status = BFA_STATUS_OK;
+        return 0;
+}
+
+int
+bfad_iocmd_qos_get_vc_attr(struct bfad_s *bfad, void *cmd)
+{
+        struct bfa_bsg_qos_vc_attr_s *iocmd =
+                                (struct bfa_bsg_qos_vc_attr_s *)cmd;
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);
+        struct bfa_qos_vc_attr_s *bfa_vc_attr = &fcport->qos_vc_attr;
+        unsigned long   flags;
+        u32     i = 0;
+
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        iocmd->attr.total_vc_count = be16_to_cpu(bfa_vc_attr->total_vc_count);
+        iocmd->attr.shared_credit  = be16_to_cpu(bfa_vc_attr->shared_credit);
+        iocmd->attr.elp_opmode_flags  =
+                                be32_to_cpu(bfa_vc_attr->elp_opmode_flags);
+
+        /* Individual VC info */
+        while (i < iocmd->attr.total_vc_count) {
+                iocmd->attr.vc_info[i].vc_credit =
+                                bfa_vc_attr->vc_info[i].vc_credit;
+                iocmd->attr.vc_info[i].borrow_credit =
+                                bfa_vc_attr->vc_info[i].borrow_credit;
+                iocmd->attr.vc_info[i].priority =
+                                bfa_vc_attr->vc_info[i].priority;
+                i++;
+        }
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+
+        iocmd->status = BFA_STATUS_OK;
+        return 0;
+}
+
+int
+bfad_iocmd_qos_get_stats(struct bfad_s *bfad, void *cmd)
+{
+        struct bfa_bsg_fcport_stats_s *iocmd =
+                                (struct bfa_bsg_fcport_stats_s *)cmd;
+        struct bfad_hal_comp fcomp;
+        unsigned long   flags;
+        struct bfa_cb_pending_q_s cb_qe;
+
+        init_completion(&fcomp.comp);
+        bfa_pending_q_init(&cb_qe, (bfa_cb_cbfn_t)bfad_hcb_comp,
+                           &fcomp, &iocmd->stats);
+
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        WARN_ON(!bfa_ioc_get_fcmode(&bfad->bfa.ioc));
+        iocmd->status = bfa_fcport_get_stats(&bfad->bfa, &cb_qe);
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+        if (iocmd->status != BFA_STATUS_OK) {
+                bfa_trc(bfad, iocmd->status);
+                goto out;
+        }
+        wait_for_completion(&fcomp.comp);
+        iocmd->status = fcomp.status;
+out:
+        return 0;
+}
+
+int
+bfad_iocmd_qos_reset_stats(struct bfad_s *bfad, void *cmd)
+{
+        struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
+        struct bfad_hal_comp fcomp;
+        unsigned long   flags;
+        struct bfa_cb_pending_q_s cb_qe;
+
+        init_completion(&fcomp.comp);
+        bfa_pending_q_init(&cb_qe, (bfa_cb_cbfn_t)bfad_hcb_comp,
+                           &fcomp, NULL);
+
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        WARN_ON(!bfa_ioc_get_fcmode(&bfad->bfa.ioc));
+        iocmd->status = bfa_fcport_clear_stats(&bfad->bfa, &cb_qe);
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+        if (iocmd->status != BFA_STATUS_OK) {
+                bfa_trc(bfad, iocmd->status);
+                goto out;
+        }
+        wait_for_completion(&fcomp.comp);
+        iocmd->status = fcomp.status;
+out:
+        return 0;
+}
+
+int
+bfad_iocmd_vf_get_stats(struct bfad_s *bfad, void *cmd)
+{
+        struct bfa_bsg_vf_stats_s *iocmd =
+                        (struct bfa_bsg_vf_stats_s *)cmd;
+        struct bfa_fcs_fabric_s *fcs_vf;
+        unsigned long   flags;
+
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        fcs_vf = bfa_fcs_vf_lookup(&bfad->bfa_fcs, iocmd->vf_id);
+        if (fcs_vf == NULL) {
+                spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+                iocmd->status = BFA_STATUS_UNKNOWN_VFID;
+                goto out;
+        }
+        memcpy((void *)&iocmd->stats, (void *)&fcs_vf->stats,
+                sizeof(struct bfa_vf_stats_s));
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+        iocmd->status = BFA_STATUS_OK;
+out:
+        return 0;
+}
+
+int
+bfad_iocmd_vf_clr_stats(struct bfad_s *bfad, void *cmd)
+{
+        struct bfa_bsg_vf_reset_stats_s *iocmd =
+                        (struct bfa_bsg_vf_reset_stats_s *)cmd;
+        struct bfa_fcs_fabric_s *fcs_vf;
+        unsigned long   flags;
+
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        fcs_vf = bfa_fcs_vf_lookup(&bfad->bfa_fcs, iocmd->vf_id);
+        if (fcs_vf == NULL) {
+                spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+                iocmd->status = BFA_STATUS_UNKNOWN_VFID;
+                goto out;
+        }
+        memset((void *)&fcs_vf->stats, 0, sizeof(struct bfa_vf_stats_s));
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+        iocmd->status = BFA_STATUS_OK;
+out:
+        return 0;
+}
+
+int
+bfad_iocmd_lunmask(struct bfad_s *bfad, void *pcmd, unsigned int v_cmd)
+{
+        struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)pcmd;
+        unsigned long   flags;
+
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        if (v_cmd == IOCMD_FCPIM_LUNMASK_ENABLE)
+                iocmd->status = bfa_fcpim_lunmask_update(&bfad->bfa, BFA_TRUE);
+        else if (v_cmd == IOCMD_FCPIM_LUNMASK_DISABLE)
+                iocmd->status = bfa_fcpim_lunmask_update(&bfad->bfa, BFA_FALSE);
+        else if (v_cmd == IOCMD_FCPIM_LUNMASK_CLEAR)
+                iocmd->status = bfa_fcpim_lunmask_clear(&bfad->bfa);
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+        return 0;
+}
+
+int
+bfad_iocmd_fcpim_lunmask_query(struct bfad_s *bfad, void *cmd)
+{
+        struct bfa_bsg_fcpim_lunmask_query_s *iocmd =
+                        (struct bfa_bsg_fcpim_lunmask_query_s *)cmd;
+        struct bfa_lunmask_cfg_s *lun_mask = &iocmd->lun_mask;
+        unsigned long   flags;
+
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        iocmd->status = bfa_fcpim_lunmask_query(&bfad->bfa, lun_mask);
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+        return 0;
+}
+
+int
+bfad_iocmd_fcpim_cfg_lunmask(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)
+{
+        struct bfa_bsg_fcpim_lunmask_s *iocmd =
+                                (struct bfa_bsg_fcpim_lunmask_s *)cmd;
+        unsigned long   flags;
+
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        if (v_cmd == IOCMD_FCPIM_LUNMASK_ADD)
+                iocmd->status = bfa_fcpim_lunmask_add(&bfad->bfa, iocmd->vf_id,
+                                        &iocmd->pwwn, iocmd->rpwwn, iocmd->lun);
+        else if (v_cmd == IOCMD_FCPIM_LUNMASK_DELETE)
+                iocmd->status = bfa_fcpim_lunmask_delete(&bfad->bfa,
+                                        iocmd->vf_id, &iocmd->pwwn,
+                                        iocmd->rpwwn, iocmd->lun);
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+        return 0;
+}
+
 static int
 bfad_iocmd_handler(struct bfad_s *bfad, unsigned int cmd, void *iocmd,
                 unsigned int payload_len)
 {
-        int rc = EINVAL;
+        int rc = -EINVAL;
 
         switch (cmd) {
         case IOCMD_IOC_ENABLE:
@@ -1536,6 +2469,14 @@ bfad_iocmd_handler(struct bfad_s *bfad, unsigned int cmd, void *iocmd,
         case IOCMD_IOC_GET_FWSTATS:
                 rc = bfad_iocmd_ioc_get_fwstats(bfad, iocmd, payload_len);
                 break;
+        case IOCMD_IOC_RESET_STATS:
+        case IOCMD_IOC_RESET_FWSTATS:
+                rc = bfad_iocmd_ioc_reset_stats(bfad, iocmd, cmd);
+                break;
+        case IOCMD_IOC_SET_ADAPTER_NAME:
+        case IOCMD_IOC_SET_PORT_NAME:
+                rc = bfad_iocmd_ioc_set_name(bfad, iocmd, cmd);
+                break;
         case IOCMD_IOCFC_GET_ATTR:
                 rc = bfad_iocmd_iocfc_get_attr(bfad, iocmd);
                 break;
@@ -1554,12 +2495,31 @@ bfad_iocmd_handler(struct bfad_s *bfad, unsigned int cmd, void *iocmd,
         case IOCMD_PORT_GET_STATS:
                 rc = bfad_iocmd_port_get_stats(bfad, iocmd, payload_len);
                 break;
+        case IOCMD_PORT_RESET_STATS:
+                rc = bfad_iocmd_port_reset_stats(bfad, iocmd);
+                break;
+        case IOCMD_PORT_CFG_TOPO:
+        case IOCMD_PORT_CFG_SPEED:
+        case IOCMD_PORT_CFG_ALPA:
+        case IOCMD_PORT_CLR_ALPA:
+                rc = bfad_iocmd_set_port_cfg(bfad, iocmd, cmd);
+                break;
+        case IOCMD_PORT_CFG_MAXFRSZ:
+                rc = bfad_iocmd_port_cfg_maxfrsize(bfad, iocmd);
+                break;
+        case IOCMD_PORT_BBSC_ENABLE:
+        case IOCMD_PORT_BBSC_DISABLE:
+                rc = bfad_iocmd_port_cfg_bbsc(bfad, iocmd, cmd);
+                break;
         case IOCMD_LPORT_GET_ATTR:
                 rc = bfad_iocmd_lport_get_attr(bfad, iocmd);
                 break;
         case IOCMD_LPORT_GET_STATS:
                 rc = bfad_iocmd_lport_get_stats(bfad, iocmd);
                 break;
+        case IOCMD_LPORT_RESET_STATS:
+                rc = bfad_iocmd_lport_reset_stats(bfad, iocmd);
+                break;
         case IOCMD_LPORT_GET_IOSTATS:
                 rc = bfad_iocmd_lport_get_iostats(bfad, iocmd);
                 break;
@@ -1575,12 +2535,40 @@ bfad_iocmd_handler(struct bfad_s *bfad, unsigned int cmd, void *iocmd,
         case IOCMD_RPORT_GET_STATS:
                 rc = bfad_iocmd_rport_get_stats(bfad, iocmd);
                 break;
+        case IOCMD_RPORT_RESET_STATS:
+                rc = bfad_iocmd_rport_clr_stats(bfad, iocmd);
+                break;
+        case IOCMD_RPORT_SET_SPEED:
+                rc = bfad_iocmd_rport_set_speed(bfad, iocmd);
+                break;
+        case IOCMD_VPORT_GET_ATTR:
+                rc = bfad_iocmd_vport_get_attr(bfad, iocmd);
+                break;
+        case IOCMD_VPORT_GET_STATS:
+                rc = bfad_iocmd_vport_get_stats(bfad, iocmd);
+                break;
+        case IOCMD_VPORT_RESET_STATS:
+                rc = bfad_iocmd_vport_clr_stats(bfad, iocmd);
+                break;
         case IOCMD_FABRIC_GET_LPORTS:
                 rc = bfad_iocmd_fabric_get_lports(bfad, iocmd, payload_len);
                 break;
+        case IOCMD_RATELIM_ENABLE:
+        case IOCMD_RATELIM_DISABLE:
+                rc = bfad_iocmd_ratelim(bfad, cmd, iocmd);
+                break;
+        case IOCMD_RATELIM_DEF_SPEED:
+                rc = bfad_iocmd_ratelim_speed(bfad, cmd, iocmd);
+                break;
+        case IOCMD_FCPIM_FAILOVER:
+                rc = bfad_iocmd_cfg_fcpim(bfad, iocmd);
+                break;
         case IOCMD_FCPIM_MODSTATS:
                 rc = bfad_iocmd_fcpim_get_modstats(bfad, iocmd);
                 break;
+        case IOCMD_FCPIM_MODSTATSCLR:
+                rc = bfad_iocmd_fcpim_clr_modstats(bfad, iocmd);
+                break;
         case IOCMD_FCPIM_DEL_ITN_STATS:
                 rc = bfad_iocmd_fcpim_get_del_itn_stats(bfad, iocmd);
                 break;
@@ -1590,6 +2578,9 @@ bfad_iocmd_handler(struct bfad_s *bfad, unsigned int cmd, void *iocmd,
         case IOCMD_ITNIM_GET_IOSTATS:
                 rc = bfad_iocmd_itnim_get_iostats(bfad, iocmd);
                 break;
+        case IOCMD_ITNIM_RESET_STATS:
+                rc = bfad_iocmd_itnim_reset_stats(bfad, iocmd);
+                break;
         case IOCMD_ITNIM_GET_ITNSTATS:
                 rc = bfad_iocmd_itnim_get_itnstats(bfad, iocmd);
                 break;
@@ -1702,11 +2693,92 @@ bfad_iocmd_handler(struct bfad_s *bfad, unsigned int cmd, void *iocmd,
         case IOCMD_DEBUG_PORTLOG:
                 rc = bfad_iocmd_porglog_get(bfad, iocmd);
                 break;
+        case IOCMD_DEBUG_FW_CORE:
+                rc = bfad_iocmd_debug_fw_core(bfad, iocmd, payload_len);
+                break;
+        case IOCMD_DEBUG_FW_STATE_CLR:
+        case IOCMD_DEBUG_PORTLOG_CLR:
+        case IOCMD_DEBUG_START_DTRC:
+        case IOCMD_DEBUG_STOP_DTRC:
+                rc = bfad_iocmd_debug_ctl(bfad, iocmd, cmd);
+                break;
+        case IOCMD_DEBUG_PORTLOG_CTL:
+                rc = bfad_iocmd_porglog_ctl(bfad, iocmd);
+                break;
+        case IOCMD_FCPIM_PROFILE_ON:
+        case IOCMD_FCPIM_PROFILE_OFF:
+                rc = bfad_iocmd_fcpim_cfg_profile(bfad, iocmd, cmd);
+                break;
+        case IOCMD_ITNIM_GET_IOPROFILE:
+                rc = bfad_iocmd_itnim_get_ioprofile(bfad, iocmd);
+                break;
+        case IOCMD_FCPORT_GET_STATS:
+                rc = bfad_iocmd_fcport_get_stats(bfad, iocmd);
+                break;
+        case IOCMD_FCPORT_RESET_STATS:
+                rc = bfad_iocmd_fcport_reset_stats(bfad, iocmd);
+                break;
+        case IOCMD_BOOT_CFG:
+                rc = bfad_iocmd_boot_cfg(bfad, iocmd);
+                break;
+        case IOCMD_BOOT_QUERY:
+                rc = bfad_iocmd_boot_query(bfad, iocmd);
+                break;
+        case IOCMD_PREBOOT_QUERY:
+                rc = bfad_iocmd_preboot_query(bfad, iocmd);
+                break;
+        case IOCMD_ETHBOOT_CFG:
+                rc = bfad_iocmd_ethboot_cfg(bfad, iocmd);
+                break;
+        case IOCMD_ETHBOOT_QUERY:
+                rc = bfad_iocmd_ethboot_query(bfad, iocmd);
+                break;
+        case IOCMD_TRUNK_ENABLE:
+        case IOCMD_TRUNK_DISABLE:
+                rc = bfad_iocmd_cfg_trunk(bfad, iocmd, cmd);
+                break;
+        case IOCMD_TRUNK_GET_ATTR:
+                rc = bfad_iocmd_trunk_get_attr(bfad, iocmd);
+                break;
+        case IOCMD_QOS_ENABLE:
+        case IOCMD_QOS_DISABLE:
+                rc = bfad_iocmd_qos(bfad, iocmd, cmd);
+                break;
+        case IOCMD_QOS_GET_ATTR:
+                rc = bfad_iocmd_qos_get_attr(bfad, iocmd);
+                break;
+        case IOCMD_QOS_GET_VC_ATTR:
+                rc = bfad_iocmd_qos_get_vc_attr(bfad, iocmd);
+                break;
+        case IOCMD_QOS_GET_STATS:
+                rc = bfad_iocmd_qos_get_stats(bfad, iocmd);
+                break;
+        case IOCMD_QOS_RESET_STATS:
+                rc = bfad_iocmd_qos_reset_stats(bfad, iocmd);
+                break;
+        case IOCMD_VF_GET_STATS:
+                rc = bfad_iocmd_vf_get_stats(bfad, iocmd);
+                break;
+        case IOCMD_VF_RESET_STATS:
+                rc = bfad_iocmd_vf_clr_stats(bfad, iocmd);
+                break;
+        case IOCMD_FCPIM_LUNMASK_ENABLE:
+        case IOCMD_FCPIM_LUNMASK_DISABLE:
+        case IOCMD_FCPIM_LUNMASK_CLEAR:
+                rc = bfad_iocmd_lunmask(bfad, iocmd, cmd);
+                break;
+        case IOCMD_FCPIM_LUNMASK_QUERY:
+                rc = bfad_iocmd_fcpim_lunmask_query(bfad, iocmd);
+                break;
+        case IOCMD_FCPIM_LUNMASK_ADD:
+        case IOCMD_FCPIM_LUNMASK_DELETE:
+                rc = bfad_iocmd_fcpim_cfg_lunmask(bfad, iocmd, cmd);
+                break;
         default:
-                rc = EINVAL;
+                rc = -EINVAL;
                 break;
         }
-        return -rc;
+        return rc;
 }
 
 static int
diff --git a/drivers/scsi/bfa/bfad_bsg.h b/drivers/scsi/bfa/bfad_bsg.h
index 99b0e8a70c89..e859adb9aa9e 100644
--- a/drivers/scsi/bfa/bfad_bsg.h
+++ b/drivers/scsi/bfa/bfad_bsg.h
@@ -30,24 +30,48 @@ enum {
         IOCMD_IOC_GET_INFO,
         IOCMD_IOC_GET_STATS,
         IOCMD_IOC_GET_FWSTATS,
+        IOCMD_IOC_RESET_STATS,
+        IOCMD_IOC_RESET_FWSTATS,
+        IOCMD_IOC_SET_ADAPTER_NAME,
+        IOCMD_IOC_SET_PORT_NAME,
         IOCMD_IOCFC_GET_ATTR,
         IOCMD_IOCFC_SET_INTR,
         IOCMD_PORT_ENABLE,
         IOCMD_PORT_DISABLE,
         IOCMD_PORT_GET_ATTR,
         IOCMD_PORT_GET_STATS,
+        IOCMD_PORT_RESET_STATS,
+        IOCMD_PORT_CFG_TOPO,
+        IOCMD_PORT_CFG_SPEED,
+        IOCMD_PORT_CFG_ALPA,
+        IOCMD_PORT_CFG_MAXFRSZ,
+        IOCMD_PORT_CLR_ALPA,
+        IOCMD_PORT_BBSC_ENABLE,
+        IOCMD_PORT_BBSC_DISABLE,
         IOCMD_LPORT_GET_ATTR,
         IOCMD_LPORT_GET_RPORTS,
         IOCMD_LPORT_GET_STATS,
+        IOCMD_LPORT_RESET_STATS,
         IOCMD_LPORT_GET_IOSTATS,
         IOCMD_RPORT_GET_ATTR,
         IOCMD_RPORT_GET_ADDR,
         IOCMD_RPORT_GET_STATS,
+        IOCMD_RPORT_RESET_STATS,
+        IOCMD_RPORT_SET_SPEED,
+        IOCMD_VPORT_GET_ATTR,
+        IOCMD_VPORT_GET_STATS,
+        IOCMD_VPORT_RESET_STATS,
         IOCMD_FABRIC_GET_LPORTS,
+        IOCMD_RATELIM_ENABLE,
+        IOCMD_RATELIM_DISABLE,
+        IOCMD_RATELIM_DEF_SPEED,
+        IOCMD_FCPIM_FAILOVER,
         IOCMD_FCPIM_MODSTATS,
+        IOCMD_FCPIM_MODSTATSCLR,
         IOCMD_FCPIM_DEL_ITN_STATS,
         IOCMD_ITNIM_GET_ATTR,
         IOCMD_ITNIM_GET_IOSTATS,
+        IOCMD_ITNIM_RESET_STATS,
         IOCMD_ITNIM_GET_ITNSTATS,
         IOCMD_IOC_PCIFN_CFG,
         IOCMD_FCPORT_ENABLE,
@@ -86,6 +110,39 @@ enum {
         IOCMD_PHY_READ_FW,
         IOCMD_VHBA_QUERY,
         IOCMD_DEBUG_PORTLOG,
+        IOCMD_DEBUG_FW_CORE,
+        IOCMD_DEBUG_FW_STATE_CLR,
+        IOCMD_DEBUG_PORTLOG_CLR,
+        IOCMD_DEBUG_START_DTRC,
+        IOCMD_DEBUG_STOP_DTRC,
+        IOCMD_DEBUG_PORTLOG_CTL,
+        IOCMD_FCPIM_PROFILE_ON,
+        IOCMD_FCPIM_PROFILE_OFF,
+        IOCMD_ITNIM_GET_IOPROFILE,
+        IOCMD_FCPORT_GET_STATS,
+        IOCMD_FCPORT_RESET_STATS,
+        IOCMD_BOOT_CFG,
+        IOCMD_BOOT_QUERY,
+        IOCMD_PREBOOT_QUERY,
+        IOCMD_ETHBOOT_CFG,
+        IOCMD_ETHBOOT_QUERY,
+        IOCMD_TRUNK_ENABLE,
+        IOCMD_TRUNK_DISABLE,
+        IOCMD_TRUNK_GET_ATTR,
+        IOCMD_QOS_ENABLE,
+        IOCMD_QOS_DISABLE,
+        IOCMD_QOS_GET_ATTR,
+        IOCMD_QOS_GET_VC_ATTR,
+        IOCMD_QOS_GET_STATS,
+        IOCMD_QOS_RESET_STATS,
+        IOCMD_VF_GET_STATS,
+        IOCMD_VF_RESET_STATS,
+        IOCMD_FCPIM_LUNMASK_ENABLE,
+        IOCMD_FCPIM_LUNMASK_DISABLE,
+        IOCMD_FCPIM_LUNMASK_CLEAR,
+        IOCMD_FCPIM_LUNMASK_QUERY,
+        IOCMD_FCPIM_LUNMASK_ADD,
+        IOCMD_FCPIM_LUNMASK_DELETE,
 };
 
 struct bfa_bsg_gen_s {
@@ -94,6 +151,43 @@ struct bfa_bsg_gen_s {
         u16             rsvd;
 };
 
+struct bfa_bsg_portlogctl_s {
+        bfa_status_t    status;
+        u16             bfad_num;
+        u16             rsvd;
+        bfa_boolean_t   ctl;
+        int             inst_no;
+};
+
+struct bfa_bsg_fcpim_profile_s {
+        bfa_status_t    status;
+        u16             bfad_num;
+        u16             rsvd;
+};
+
+struct bfa_bsg_itnim_ioprofile_s {
+        bfa_status_t    status;
+        u16             bfad_num;
+        u16             vf_id;
+        wwn_t           lpwwn;
+        wwn_t           rpwwn;
+        struct bfa_itnim_ioprofile_s ioprofile;
+};
+
+struct bfa_bsg_fcport_stats_s {
+        bfa_status_t    status;
+        u16             bfad_num;
+        u16             rsvd;
+        union bfa_fcport_stats_u stats;
+};
+
+struct bfa_bsg_ioc_name_s {
+        bfa_status_t    status;
+        u16             bfad_num;
+        u16             rsvd;
+        char            name[BFA_ADAPTER_SYM_NAME_LEN];
+};
+
 struct bfa_bsg_ioc_info_s {
         bfa_status_t    status;
         u16             bfad_num;
@@ -164,6 +258,20 @@ struct bfa_bsg_port_attr_s {
         struct bfa_port_attr_s  attr;
 };
 
+struct bfa_bsg_port_cfg_s {
+        bfa_status_t    status;
+        u16             bfad_num;
+        u16             rsvd;
+        u32             param;
+        u32             rsvd1;
+};
+
+struct bfa_bsg_port_cfg_maxfrsize_s {
+        bfa_status_t    status;
+        u16             bfad_num;
+        u16             maxfrsize;
+};
+
 struct bfa_bsg_port_stats_s {
         bfa_status_t    status;
         u16             bfad_num;
@@ -237,6 +345,47 @@ struct bfa_bsg_rport_scsi_addr_s {
         u32             lun;
 };
 
+struct bfa_bsg_rport_reset_stats_s {
+        bfa_status_t    status;
+        u16             bfad_num;
+        u16             vf_id;
+        wwn_t           pwwn;
+        wwn_t           rpwwn;
+};
+
+struct bfa_bsg_rport_set_speed_s {
+        bfa_status_t            status;
+        u16                     bfad_num;
+        u16                     vf_id;
+        enum bfa_port_speed     speed;
+        u32                     rsvd;
+        wwn_t                   pwwn;
+        wwn_t                   rpwwn;
+};
+
+struct bfa_bsg_vport_attr_s {
+        bfa_status_t    status;
+        u16             bfad_num;
+        u16             vf_id;
+        wwn_t           vpwwn;
+        struct bfa_vport_attr_s vport_attr;
+};
+
+struct bfa_bsg_vport_stats_s {
+        bfa_status_t    status;
+        u16             bfad_num;
+        u16             vf_id;
+        wwn_t           vpwwn;
+        struct bfa_vport_stats_s vport_stats;
+};
+
+struct bfa_bsg_reset_stats_s {
+        bfa_status_t    status;
+        u16             bfad_num;
+        u16             vf_id;
+        wwn_t           vpwwn;
+};
+
 struct bfa_bsg_fabric_get_lports_s {
         bfa_status_t    status;
         u16             bfad_num;
@@ -246,6 +395,19 @@ struct bfa_bsg_fabric_get_lports_s {
         u32             rsvd;
 };
 
+struct bfa_bsg_trl_speed_s {
+        bfa_status_t    status;
+        u16             bfad_num;
+        u16             rsvd;
+        enum bfa_port_speed speed;
+};
+
+struct bfa_bsg_fcpim_s {
+        bfa_status_t    status;
+        u16             bfad_num;
+        u16             param;
+};
+
 struct bfa_bsg_fcpim_modstats_s {
         bfa_status_t    status;
         u16             bfad_num;
@@ -258,6 +420,11 @@ struct bfa_bsg_fcpim_del_itn_stats_s {
         struct bfa_fcpim_del_itn_stats_s modstats;
 };
 
+struct bfa_bsg_fcpim_modstatsclr_s {
+        bfa_status_t    status;
+        u16             bfad_num;
+};
+
 struct bfa_bsg_itnim_attr_s {
         bfa_status_t    status;
         u16             bfad_num;
@@ -485,6 +652,76 @@ struct bfa_bsg_vhba_attr_s {
         struct bfa_vhba_attr_s  attr;
 };
 
+struct bfa_bsg_boot_s {
+        bfa_status_t    status;
+        u16             bfad_num;
+        u16             rsvd;
+        struct bfa_boot_cfg_s   cfg;
+};
+
+struct bfa_bsg_preboot_s {
+        bfa_status_t    status;
+        u16             bfad_num;
+        u16             rsvd;
+        struct bfa_boot_pbc_s   cfg;
+};
+
+struct bfa_bsg_ethboot_s {
+        bfa_status_t    status;
+        u16             bfad_num;
+        u16             rsvd;
+        struct  bfa_ethboot_cfg_s  cfg;
+};
+
+struct bfa_bsg_trunk_attr_s {
+        bfa_status_t    status;
+        u16             bfad_num;
+        u16             rsvd;
+        struct bfa_trunk_attr_s attr;
+};
+
+struct bfa_bsg_qos_attr_s {
+        bfa_status_t    status;
+        u16             bfad_num;
+        u16             rsvd;
+        struct bfa_qos_attr_s   attr;
+};
+
+struct bfa_bsg_qos_vc_attr_s {
+        bfa_status_t    status;
+        u16             bfad_num;
+        u16             rsvd;
+        struct bfa_qos_vc_attr_s attr;
+};
+
+struct bfa_bsg_vf_stats_s {
+        bfa_status_t    status;
+        u16             bfad_num;
+        u16             vf_id;
+        struct bfa_vf_stats_s   stats;
+};
+
+struct bfa_bsg_vf_reset_stats_s {
+        bfa_status_t    status;
+        u16             bfad_num;
+        u16             vf_id;
+};
+
+struct bfa_bsg_fcpim_lunmask_query_s {
+        bfa_status_t    status;
+        u16             bfad_num;
+        struct bfa_lunmask_cfg_s lun_mask;
+};
+
+struct bfa_bsg_fcpim_lunmask_s {
+        bfa_status_t    status;
+        u16             bfad_num;
+        u16             vf_id;
+        wwn_t           pwwn;
+        wwn_t           rpwwn;
+        struct scsi_lun lun;
+};
+
 struct bfa_bsg_fcpt_s {
         bfa_status_t    status;
         u16             vf_id;
diff --git a/drivers/scsi/bfa/bfad_drv.h b/drivers/scsi/bfa/bfad_drv.h
index 48661a2726d7..bda999ad9f52 100644
--- a/drivers/scsi/bfa/bfad_drv.h
+++ b/drivers/scsi/bfa/bfad_drv.h
@@ -56,7 +56,7 @@
 #ifdef BFA_DRIVER_VERSION
 #define BFAD_DRIVER_VERSION    BFA_DRIVER_VERSION
 #else
-#define BFAD_DRIVER_VERSION    "3.0.2.1"
+#define BFAD_DRIVER_VERSION    "3.0.2.2"
 #endif
 
 #define BFAD_PROTO_NAME FCPI_NAME
@@ -224,6 +224,10 @@ struct bfad_s {
         char *regdata;
         u32 reglen;
         struct dentry *bfad_dentry_files[5];
+        struct list_head        free_aen_q;
+        struct list_head        active_aen_q;
+        struct bfa_aen_entry_s  aen_list[BFA_AEN_MAX_ENTRY];
+        spinlock_t              bfad_aen_spinlock;
 };
 
 /* BFAD state machine events */
diff --git a/drivers/scsi/bfa/bfad_im.c b/drivers/scsi/bfa/bfad_im.c
index f2bf81265ae5..01312381639f 100644
--- a/drivers/scsi/bfa/bfad_im.c
+++ b/drivers/scsi/bfa/bfad_im.c
@@ -656,6 +656,31 @@ bfad_im_port_clean(struct bfad_im_port_s *im_port)
         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 }
 
+static void bfad_aen_im_notify_handler(struct work_struct *work)
+{
+        struct bfad_im_s *im =
+                container_of(work, struct bfad_im_s, aen_im_notify_work);
+        struct bfa_aen_entry_s *aen_entry;
+        struct bfad_s *bfad = im->bfad;
+        struct Scsi_Host *shost = bfad->pport.im_port->shost;
+        void *event_data;
+        unsigned long flags;
+
+        while (!list_empty(&bfad->active_aen_q)) {
+                spin_lock_irqsave(&bfad->bfad_aen_spinlock, flags);
+                bfa_q_deq(&bfad->active_aen_q, &aen_entry);
+                spin_unlock_irqrestore(&bfad->bfad_aen_spinlock, flags);
+                event_data = (char *)aen_entry + sizeof(struct list_head);
+                fc_host_post_vendor_event(shost, fc_get_event_number(),
+                                sizeof(struct bfa_aen_entry_s) -
+                                sizeof(struct list_head),
+                                (char *)event_data, BFAD_NL_VENDOR_ID);
+                spin_lock_irqsave(&bfad->bfad_aen_spinlock, flags);
+                list_add_tail(&aen_entry->qe, &bfad->free_aen_q);
+                spin_unlock_irqrestore(&bfad->bfad_aen_spinlock, flags);
+        }
+}
+
 bfa_status_t
 bfad_im_probe(struct bfad_s *bfad)
 {
@@ -676,6 +701,7 @@ bfad_im_probe(struct bfad_s *bfad)
                 rc = BFA_STATUS_FAILED;
         }
 
+        INIT_WORK(&im->aen_im_notify_work, bfad_aen_im_notify_handler);
 ext:
         return rc;
 }
diff --git a/drivers/scsi/bfa/bfad_im.h b/drivers/scsi/bfa/bfad_im.h
index 4fe34d576b05..004b6cf848d9 100644
--- a/drivers/scsi/bfa/bfad_im.h
+++ b/drivers/scsi/bfa/bfad_im.h
@@ -115,8 +115,30 @@ struct bfad_im_s {
         struct bfad_s         *bfad;
         struct workqueue_struct *drv_workq;
         char            drv_workq_name[KOBJ_NAME_LEN];
+        struct work_struct      aen_im_notify_work;
 };
 
+#define bfad_get_aen_entry(_drv, _entry) do {                           \
+        unsigned long   _flags;                                         \
+        spin_lock_irqsave(&(_drv)->bfad_aen_spinlock, _flags);          \
+        bfa_q_deq(&(_drv)->free_aen_q, &(_entry));                      \
+        if (_entry)                                                     \
+                list_add_tail(&(_entry)->qe, &(_drv)->active_aen_q);    \
+        spin_unlock_irqrestore(&(_drv)->bfad_aen_spinlock, _flags);     \
+} while (0)
+
+/* post fc_host vendor event */
+#define bfad_im_post_vendor_event(_entry, _drv, _cnt, _cat, _evt) do {        \
+        do_gettimeofday(&(_entry)->aen_tv);                                   \
+        (_entry)->bfad_num = (_drv)->inst_no;                                 \
+        (_entry)->seq_num = (_cnt);                                           \
+        (_entry)->aen_category = (_cat);                                      \
+        (_entry)->aen_type = (_evt);                                          \
+        if ((_drv)->bfad_flags & BFAD_FC4_PROBE_DONE)                         \
+                queue_work((_drv)->im->drv_workq,                             \
+                           &(_drv)->im->aen_im_notify_work);                  \
+} while (0)
+
 struct Scsi_Host *bfad_scsi_host_alloc(struct bfad_im_port_s *im_port,
                                 struct bfad_s *);
 bfa_status_t bfad_thread_workq(struct bfad_s *bfad);
diff --git a/drivers/scsi/bfa/bfi.h b/drivers/scsi/bfa/bfi.h
index 1e258d5f8aec..b2ba0b2e91b2 100644
--- a/drivers/scsi/bfa/bfi.h
+++ b/drivers/scsi/bfa/bfi.h
@@ -784,6 +784,17 @@ enum bfi_sfp_i2h_e {
 };
 
 /*
+ *      SFP state change notification
+ */
+struct bfi_sfp_scn_s {
+        struct bfi_mhdr_s mhr;  /* host msg header        */
+        u8      event;
+        u8      sfpid;
+        u8      pomlvl; /* pom level: normal/warning/alarm */
+        u8      is_elb; /* e-loopback */
+};
+
+/*
  *      SFP state
  */
 enum bfa_sfp_stat_e {
@@ -926,6 +937,15 @@ struct bfi_flash_erase_rsp_s {
 };
 
 /*
+ * Flash event notification
+ */
+struct bfi_flash_event_s {
+        struct bfi_mhdr_s       mh;     /* Common msg header */
+        bfa_status_t            status;
+        u32                     param;
+};
+
+/*
  *----------------------------------------------------------------------
  *                              DIAG
  *----------------------------------------------------------------------
diff --git a/drivers/scsi/bnx2fc/bnx2fc.h b/drivers/scsi/bnx2fc/bnx2fc.h
index d924236e1b91..42228ca5a9d2 100644
--- a/drivers/scsi/bnx2fc/bnx2fc.h
+++ b/drivers/scsi/bnx2fc/bnx2fc.h
@@ -2,7 +2,7 @@
 #define _BNX2FC_H_
 /* bnx2fc.h: Broadcom NetXtreme II Linux FCoE offload driver.
  *
- * Copyright (c) 2008 - 2010 Broadcom Corporation
+ * Copyright (c) 2008 - 2011 Broadcom Corporation
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -62,7 +62,7 @@
 #include "bnx2fc_constants.h"
 
 #define BNX2FC_NAME             "bnx2fc"
-#define BNX2FC_VERSION          "1.0.3"
+#define BNX2FC_VERSION          "1.0.4"
 
 #define PFX                     "bnx2fc: "
 
@@ -141,6 +141,10 @@
 
 #define BNX2FC_RNID_HBA                 0x7
 
+#define SRR_RETRY_COUNT                 5
+#define REC_RETRY_COUNT                 1
+#define BNX2FC_NUM_ERR_BITS             63
+
 /* bnx2fc driver uses only one instance of fcoe_percpu_s */
 extern struct fcoe_percpu_s bnx2fc_global;
 
@@ -153,18 +157,13 @@ struct bnx2fc_percpu_s {
 };
 
 struct bnx2fc_hba {
-        struct list_head link;
+        struct list_head list;
         struct cnic_dev *cnic;
         struct pci_dev *pcidev;
-        struct net_device *netdev;
         struct net_device *phys_dev;
         unsigned long reg_with_cnic;
                 #define BNX2FC_CNIC_REGISTERED           1
-        struct packet_type fcoe_packet_type;
-        struct packet_type fip_packet_type;
         struct bnx2fc_cmd_mgr *cmd_mgr;
-        struct workqueue_struct *timer_work_queue;
-        struct kref kref;
         spinlock_t hba_lock;
         struct mutex hba_mutex;
         unsigned long adapter_state;
@@ -172,15 +171,9 @@ struct bnx2fc_hba {
                 #define ADAPTER_STATE_GOING_DOWN        1
                 #define ADAPTER_STATE_LINK_DOWN         2
                 #define ADAPTER_STATE_READY             3
-        u32 flags;
-        unsigned long init_done;
-                #define BNX2FC_FW_INIT_DONE             0
-                #define BNX2FC_CTLR_INIT_DONE           1
-                #define BNX2FC_CREATE_DONE              2
-        struct fcoe_ctlr ctlr;
-        struct list_head vports;
-        u8 vlan_enabled;
-        int vlan_id;
+        unsigned long flags;
+                #define BNX2FC_FLAG_FW_INIT_DONE        0
+                #define BNX2FC_FLAG_DESTROY_CMPL        1
         u32 next_conn_id;
         struct fcoe_task_ctx_entry **task_ctx;
         dma_addr_t *task_ctx_dma;
@@ -199,38 +192,41 @@ struct bnx2fc_hba {
         char *dummy_buffer;
         dma_addr_t dummy_buf_dma;
 
+        /* Active list of offloaded sessions */
+        struct bnx2fc_rport **tgt_ofld_list;
+
+        /* statistics */
         struct fcoe_statistics_params *stats_buffer;
         dma_addr_t stats_buf_dma;
-
-        /*
-         * PCI related info.
-         */
-        u16 pci_did;
-        u16 pci_vid;
-        u16 pci_sdid;
-        u16 pci_svid;
-        u16 pci_func;
-        u16 pci_devno;
-
-        struct task_struct *l2_thread;
-
-        /* linkdown handling */
-        wait_queue_head_t shutdown_wait;
-        int wait_for_link_down;
+        struct completion stat_req_done;
 
         /*destroy handling */
         struct timer_list destroy_timer;
         wait_queue_head_t destroy_wait;
 
-        /* Active list of offloaded sessions */
-        struct bnx2fc_rport *tgt_ofld_list[BNX2FC_NUM_MAX_SESS];
+        /* linkdown handling */
+        wait_queue_head_t shutdown_wait;
+        int wait_for_link_down;
         int num_ofld_sess;
+        struct list_head vports;
+};
 
-        /* statistics */
-        struct completion stat_req_done;
+struct bnx2fc_interface {
+        struct list_head list;
+        unsigned long if_flags;
+                #define BNX2FC_CTLR_INIT_DONE           0
+        struct bnx2fc_hba *hba;
+        struct net_device *netdev;
+        struct packet_type fcoe_packet_type;
+        struct packet_type fip_packet_type;
+        struct workqueue_struct *timer_work_queue;
+        struct kref kref;
+        struct fcoe_ctlr ctlr;
+        u8 vlan_enabled;
+        int vlan_id;
 };
 
-#define bnx2fc_from_ctlr(fip) container_of(fip, struct bnx2fc_hba, ctlr)
+#define bnx2fc_from_ctlr(fip) container_of(fip, struct bnx2fc_interface, ctlr)
 
 struct bnx2fc_lport {
         struct list_head list;
@@ -252,9 +248,11 @@ struct bnx2fc_rport {
         struct fc_rport_priv *rdata;
         void __iomem *ctx_base;
 #define DPM_TRIGER_TYPE         0x40
+        u32 io_timeout;
         u32 fcoe_conn_id;
         u32 context_id;
         u32 sid;
+        int dev_type;
 
         unsigned long flags;
 #define BNX2FC_FLAG_SESSION_READY       0x1
@@ -262,10 +260,9 @@ struct bnx2fc_rport {
 #define BNX2FC_FLAG_DISABLED            0x3
 #define BNX2FC_FLAG_DESTROYED           0x4
 #define BNX2FC_FLAG_OFLD_REQ_CMPL       0x5
-#define BNX2FC_FLAG_DESTROY_CMPL        0x6
-#define BNX2FC_FLAG_CTX_ALLOC_FAILURE   0x7
-#define BNX2FC_FLAG_UPLD_REQ_COMPL      0x8
-#define BNX2FC_FLAG_EXPL_LOGO           0x9
+#define BNX2FC_FLAG_CTX_ALLOC_FAILURE   0x6
+#define BNX2FC_FLAG_UPLD_REQ_COMPL      0x7
+#define BNX2FC_FLAG_EXPL_LOGO           0x8
 
         u8 src_addr[ETH_ALEN];
         u32 max_sqes;
@@ -327,12 +324,9 @@ struct bnx2fc_rport {
         spinlock_t cq_lock;
         atomic_t num_active_ios;
         u32 flush_in_prog;
-        unsigned long work_time_slice;
         unsigned long timestamp;
         struct list_head free_task_list;
         struct bnx2fc_cmd *pending_queue[BNX2FC_SQ_WQES_MAX+1];
-        atomic_t pi;
-        atomic_t ci;
         struct list_head active_cmd_queue;
         struct list_head els_queue;
         struct list_head io_retire_queue;
@@ -367,6 +361,8 @@ struct bnx2fc_els_cb_arg {
         struct bnx2fc_cmd *aborted_io_req;
         struct bnx2fc_cmd *io_req;
         u16 l2_oxid;
+        u32 offset;
+        enum fc_rctl r_ctl;
 };
 
 /* bnx2fc command structure */
@@ -380,6 +376,7 @@ struct bnx2fc_cmd {
 #define BNX2FC_ABTS                     3
 #define BNX2FC_ELS                      4
 #define BNX2FC_CLEANUP                  5
+#define BNX2FC_SEQ_CLEANUP              6
         u8 io_req_flags;
         struct kref refcount;
         struct fcoe_port *port;
@@ -393,6 +390,7 @@ struct bnx2fc_cmd {
         struct completion tm_done;
         int wait_for_comp;
         u16 xid;
+        struct fcoe_err_report_entry err_entry;
         struct fcoe_task_ctx_entry *task;
         struct io_bdt *bd_tbl;
         struct fcp_rsp *rsp;
@@ -409,6 +407,12 @@ struct bnx2fc_cmd {
 #define BNX2FC_FLAG_IO_COMPL            0x9
 #define BNX2FC_FLAG_ELS_DONE            0xa
 #define BNX2FC_FLAG_ELS_TIMEOUT         0xb
+#define BNX2FC_FLAG_CMD_LOST            0xc
+#define BNX2FC_FLAG_SRR_SENT            0xd
+        u8 rec_retry;
+        u8 srr_retry;
+        u32 srr_offset;
+        u8 srr_rctl;
         u32 fcp_resid;
         u32 fcp_rsp_len;
         u32 fcp_sns_len;
@@ -439,6 +443,7 @@ struct bnx2fc_unsol_els {
 
 
 
+struct bnx2fc_cmd *bnx2fc_cmd_alloc(struct bnx2fc_rport *tgt);
 struct bnx2fc_cmd *bnx2fc_elstm_alloc(struct bnx2fc_rport *tgt, int type);
 void bnx2fc_cmd_release(struct kref *ref);
 int bnx2fc_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *sc_cmd);
@@ -476,6 +481,10 @@ int bnx2fc_init_mp_req(struct bnx2fc_cmd *io_req);
 void bnx2fc_init_cleanup_task(struct bnx2fc_cmd *io_req,
                               struct fcoe_task_ctx_entry *task,
                               u16 orig_xid);
+void bnx2fc_init_seq_cleanup_task(struct bnx2fc_cmd *seq_clnup_req,
+                                  struct fcoe_task_ctx_entry *task,
+                                  struct bnx2fc_cmd *orig_io_req,
+                                  u32 offset);
 void bnx2fc_init_mp_task(struct bnx2fc_cmd *io_req,
                          struct fcoe_task_ctx_entry *task);
 void bnx2fc_init_task(struct bnx2fc_cmd *io_req,
@@ -525,5 +534,13 @@ void bnx2fc_process_l2_frame_compl(struct bnx2fc_rport *tgt,
                                    unsigned char *buf,
                                    u32 frame_len, u16 l2_oxid);
 int bnx2fc_send_stat_req(struct bnx2fc_hba *hba);
+int bnx2fc_post_io_req(struct bnx2fc_rport *tgt, struct bnx2fc_cmd *io_req);
+int bnx2fc_send_rec(struct bnx2fc_cmd *orig_io_req);
+int bnx2fc_send_srr(struct bnx2fc_cmd *orig_io_req, u32 offset, u8 r_ctl);
+void bnx2fc_process_seq_cleanup_compl(struct bnx2fc_cmd *seq_clnup_req,
+                                      struct fcoe_task_ctx_entry *task,
+                                      u8 rx_state);
+int bnx2fc_initiate_seq_cleanup(struct bnx2fc_cmd *orig_io_req, u32 offset,
+                                enum fc_rctl r_ctl);
 
 #endif
diff --git a/drivers/scsi/bnx2fc/bnx2fc_debug.h b/drivers/scsi/bnx2fc/bnx2fc_debug.h
index 7f6aff68cc53..3416d9a746c7 100644
--- a/drivers/scsi/bnx2fc/bnx2fc_debug.h
+++ b/drivers/scsi/bnx2fc/bnx2fc_debug.h
@@ -21,21 +21,21 @@ extern unsigned int bnx2fc_debug_level;
 
 #define BNX2FC_ELS_DBG(fmt, arg...)                                     \
         BNX2FC_CHK_LOGGING(LOG_ELS,                                     \
-                           printk(KERN_ALERT PFX fmt, ##arg))
+                           printk(KERN_INFO PFX fmt, ##arg))
 
 #define BNX2FC_MISC_DBG(fmt, arg...)                                    \
         BNX2FC_CHK_LOGGING(LOG_MISC,                                    \
-                           printk(KERN_ALERT PFX fmt, ##arg))
+                           printk(KERN_INFO PFX fmt, ##arg))
 
 #define BNX2FC_IO_DBG(io_req, fmt, arg...)                              \
         do {                                                            \
                 if (!io_req || !io_req->port || !io_req->port->lport || \
                     !io_req->port->lport->host)                         \
                         BNX2FC_CHK_LOGGING(LOG_IO,                      \
-                           printk(KERN_ALERT PFX "NULL " fmt, ##arg));  \
+                           printk(KERN_INFO PFX "NULL " fmt, ##arg));   \
                 else                                                    \
                         BNX2FC_CHK_LOGGING(LOG_IO,                      \
-                           shost_printk(KERN_ALERT,                     \
+                           shost_printk(KERN_INFO,                      \
                                    (io_req)->port->lport->host,         \
                                    PFX "xid:0x%x " fmt,                 \
                                    (io_req)->xid, ##arg));              \
@@ -46,10 +46,10 @@ extern unsigned int bnx2fc_debug_level;
                 if (!tgt || !tgt->port || !tgt->port->lport ||          \
                     !tgt->port->lport->host || !tgt->rport)             \
                         BNX2FC_CHK_LOGGING(LOG_TGT,                     \
-                           printk(KERN_ALERT PFX "NULL " fmt, ##arg));  \
+                           printk(KERN_INFO PFX "NULL " fmt, ##arg));   \
                 else                                                    \
                         BNX2FC_CHK_LOGGING(LOG_TGT,                     \
-                           shost_printk(KERN_ALERT,                     \
+                           shost_printk(KERN_INFO,                      \
                                    (tgt)->port->lport->host,            \
                                    PFX "port:%x " fmt,                  \
                                    (tgt)->rport->port_id, ##arg));      \
@@ -60,10 +60,10 @@ extern unsigned int bnx2fc_debug_level;
         do {                                                            \
                 if (!lport || !lport->host)                             \
                         BNX2FC_CHK_LOGGING(LOG_HBA,                     \
-                           printk(KERN_ALERT PFX "NULL " fmt, ##arg));  \
+                           printk(KERN_INFO PFX "NULL " fmt, ##arg));   \
                 else                                                    \
                         BNX2FC_CHK_LOGGING(LOG_HBA,                     \
-                           shost_printk(KERN_ALERT, lport->host,        \
+                           shost_printk(KERN_INFO, lport->host, \
                                    PFX fmt, ##arg));                    \
         } while (0)
 
diff --git a/drivers/scsi/bnx2fc/bnx2fc_els.c b/drivers/scsi/bnx2fc/bnx2fc_els.c
index 7e89143f15cf..d66dcbd0df10 100644
--- a/drivers/scsi/bnx2fc/bnx2fc_els.c
+++ b/drivers/scsi/bnx2fc/bnx2fc_els.c
@@ -3,7 +3,7 @@
  * This file contains helper routines that handle ELS requests
  * and responses.
  *
- * Copyright (c) 2008 - 2010 Broadcom Corporation
+ * Copyright (c) 2008 - 2011 Broadcom Corporation
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -253,13 +253,417 @@ int bnx2fc_send_rls(struct bnx2fc_rport *tgt, struct fc_frame *fp)
         return rc;
 }
 
+void bnx2fc_srr_compl(struct bnx2fc_els_cb_arg *cb_arg)
+{
+        struct bnx2fc_mp_req *mp_req;
+        struct fc_frame_header *fc_hdr, *fh;
+        struct bnx2fc_cmd *srr_req;
+        struct bnx2fc_cmd *orig_io_req;
+        struct fc_frame *fp;
+        unsigned char *buf;
+        void *resp_buf;
+        u32 resp_len, hdr_len;
+        u8 opcode;
+        int rc = 0;
+
+        orig_io_req = cb_arg->aborted_io_req;
+        srr_req = cb_arg->io_req;
+        if (test_bit(BNX2FC_FLAG_IO_COMPL, &orig_io_req->req_flags)) {
+                BNX2FC_IO_DBG(srr_req, "srr_compl: xid - 0x%x completed",
+                        orig_io_req->xid);
+                goto srr_compl_done;
+        }
+        if (test_bit(BNX2FC_FLAG_ISSUE_ABTS, &orig_io_req->req_flags)) {
+                BNX2FC_IO_DBG(srr_req, "rec abts in prog "
+                       "orig_io - 0x%x\n",
+                        orig_io_req->xid);
+                goto srr_compl_done;
+        }
+        if (test_and_clear_bit(BNX2FC_FLAG_ELS_TIMEOUT, &srr_req->req_flags)) {
+                /* SRR timedout */
+                BNX2FC_IO_DBG(srr_req, "srr timed out, abort "
+                       "orig_io - 0x%x\n",
+                        orig_io_req->xid);
+                rc = bnx2fc_initiate_abts(srr_req);
+                if (rc != SUCCESS) {
+                        BNX2FC_IO_DBG(srr_req, "srr_compl: initiate_abts "
+                                "failed. issue cleanup\n");
+                        bnx2fc_initiate_cleanup(srr_req);
+                }
+                orig_io_req->srr_retry++;
+                if (orig_io_req->srr_retry <= SRR_RETRY_COUNT) {
+                        struct bnx2fc_rport *tgt = orig_io_req->tgt;
+                        spin_unlock_bh(&tgt->tgt_lock);
+                        rc = bnx2fc_send_srr(orig_io_req,
+                                             orig_io_req->srr_offset,
+                                             orig_io_req->srr_rctl);
+                        spin_lock_bh(&tgt->tgt_lock);
+                        if (!rc)
+                                goto srr_compl_done;
+                }
+
+                rc = bnx2fc_initiate_abts(orig_io_req);
+                if (rc != SUCCESS) {
+                        BNX2FC_IO_DBG(srr_req, "srr_compl: initiate_abts "
+                                "failed xid = 0x%x. issue cleanup\n",
+                                orig_io_req->xid);
+                        bnx2fc_initiate_cleanup(orig_io_req);
+                }
+                goto srr_compl_done;
+        }
+        mp_req = &(srr_req->mp_req);
+        fc_hdr = &(mp_req->resp_fc_hdr);
+        resp_len = mp_req->resp_len;
+        resp_buf = mp_req->resp_buf;
+
+        hdr_len = sizeof(*fc_hdr);
+        buf = kzalloc(PAGE_SIZE, GFP_ATOMIC);
+        if (!buf) {
+                printk(KERN_ERR PFX "srr buf: mem alloc failure\n");
+                goto srr_compl_done;
+        }
+        memcpy(buf, fc_hdr, hdr_len);
+        memcpy(buf + hdr_len, resp_buf, resp_len);
+
+        fp = fc_frame_alloc(NULL, resp_len);
+        if (!fp) {
+                printk(KERN_ERR PFX "fc_frame_alloc failure\n");
+                goto free_buf;
+        }
+
+        fh = (struct fc_frame_header *) fc_frame_header_get(fp);
+        /* Copy FC Frame header and payload into the frame */
+        memcpy(fh, buf, hdr_len + resp_len);
+
+        opcode = fc_frame_payload_op(fp);
+        switch (opcode) {
+        case ELS_LS_ACC:
+                BNX2FC_IO_DBG(srr_req, "SRR success\n");
+                break;
+        case ELS_LS_RJT:
+                BNX2FC_IO_DBG(srr_req, "SRR rejected\n");
+                rc = bnx2fc_initiate_abts(orig_io_req);
+                if (rc != SUCCESS) {
+                        BNX2FC_IO_DBG(srr_req, "srr_compl: initiate_abts "
+                                "failed xid = 0x%x. issue cleanup\n",
+                                orig_io_req->xid);
+                        bnx2fc_initiate_cleanup(orig_io_req);
+                }
+                break;
+        default:
+                BNX2FC_IO_DBG(srr_req, "srr compl - invalid opcode = %d\n",
+                        opcode);
+                break;
+        }
+        fc_frame_free(fp);
+free_buf:
+        kfree(buf);
+srr_compl_done:
+        kref_put(&orig_io_req->refcount, bnx2fc_cmd_release);
+}
+
+void bnx2fc_rec_compl(struct bnx2fc_els_cb_arg *cb_arg)
+{
+        struct bnx2fc_cmd *orig_io_req, *new_io_req;
+        struct bnx2fc_cmd *rec_req;
+        struct bnx2fc_mp_req *mp_req;
+        struct fc_frame_header *fc_hdr, *fh;
+        struct fc_els_ls_rjt *rjt;
+        struct fc_els_rec_acc *acc;
+        struct bnx2fc_rport *tgt;
+        struct fcoe_err_report_entry *err_entry;
+        struct scsi_cmnd *sc_cmd;
+        enum fc_rctl r_ctl;
+        unsigned char *buf;
+        void *resp_buf;
+        struct fc_frame *fp;
+        u8 opcode;
+        u32 offset;
+        u32 e_stat;
+        u32 resp_len, hdr_len;
+        int rc = 0;
+        bool send_seq_clnp = false;
+        bool abort_io = false;
+
+        BNX2FC_MISC_DBG("Entered rec_compl callback\n");
+        rec_req = cb_arg->io_req;
+        orig_io_req = cb_arg->aborted_io_req;
+        BNX2FC_IO_DBG(rec_req, "rec_compl: orig xid = 0x%x", orig_io_req->xid);
+        tgt = orig_io_req->tgt;
+
+        if (test_bit(BNX2FC_FLAG_IO_COMPL, &orig_io_req->req_flags)) {
+                BNX2FC_IO_DBG(rec_req, "completed"
+                       "orig_io - 0x%x\n",
+                        orig_io_req->xid);
+                goto rec_compl_done;
+        }
+        if (test_bit(BNX2FC_FLAG_ISSUE_ABTS, &orig_io_req->req_flags)) {
+                BNX2FC_IO_DBG(rec_req, "abts in prog "
+                       "orig_io - 0x%x\n",
+                        orig_io_req->xid);
+                goto rec_compl_done;
+        }
+        /* Handle REC timeout case */
+        if (test_and_clear_bit(BNX2FC_FLAG_ELS_TIMEOUT, &rec_req->req_flags)) {
+                BNX2FC_IO_DBG(rec_req, "timed out, abort "
+                       "orig_io - 0x%x\n",
+                        orig_io_req->xid);
+                /* els req is timed out. send abts for els */
+                rc = bnx2fc_initiate_abts(rec_req);
+                if (rc != SUCCESS) {
+                        BNX2FC_IO_DBG(rec_req, "rec_compl: initiate_abts "
+                                "failed. issue cleanup\n");
+                        bnx2fc_initiate_cleanup(rec_req);
+                }
+                orig_io_req->rec_retry++;
+                /* REC timedout. send ABTS to the orig IO req */
+                if (orig_io_req->rec_retry <= REC_RETRY_COUNT) {
+                        spin_unlock_bh(&tgt->tgt_lock);
+                        rc = bnx2fc_send_rec(orig_io_req);
+                        spin_lock_bh(&tgt->tgt_lock);
+                        if (!rc)
+                                goto rec_compl_done;
+                }
+                rc = bnx2fc_initiate_abts(orig_io_req);
+                if (rc != SUCCESS) {
+                        BNX2FC_IO_DBG(rec_req, "rec_compl: initiate_abts "
+                                "failed xid = 0x%x. issue cleanup\n",
+                                orig_io_req->xid);
+                        bnx2fc_initiate_cleanup(orig_io_req);
+                }
+                goto rec_compl_done;
+        }
+        mp_req = &(rec_req->mp_req);
+        fc_hdr = &(mp_req->resp_fc_hdr);
+        resp_len = mp_req->resp_len;
+        acc = resp_buf = mp_req->resp_buf;
+
+        hdr_len = sizeof(*fc_hdr);
+
+        buf = kzalloc(PAGE_SIZE, GFP_ATOMIC);
+        if (!buf) {
+                printk(KERN_ERR PFX "rec buf: mem alloc failure\n");
+                goto rec_compl_done;
+        }
+        memcpy(buf, fc_hdr, hdr_len);
+        memcpy(buf + hdr_len, resp_buf, resp_len);
+
+        fp = fc_frame_alloc(NULL, resp_len);
+        if (!fp) {
+                printk(KERN_ERR PFX "fc_frame_alloc failure\n");
+                goto free_buf;
+        }
+
+        fh = (struct fc_frame_header *) fc_frame_header_get(fp);
+        /* Copy FC Frame header and payload into the frame */
+        memcpy(fh, buf, hdr_len + resp_len);
+
+        opcode = fc_frame_payload_op(fp);
+        if (opcode == ELS_LS_RJT) {
+                BNX2FC_IO_DBG(rec_req, "opcode is RJT\n");
+                rjt = fc_frame_payload_get(fp, sizeof(*rjt));
+                if ((rjt->er_reason == ELS_RJT_LOGIC ||
+                    rjt->er_reason == ELS_RJT_UNAB) &&
+                    rjt->er_explan == ELS_EXPL_OXID_RXID) {
+                        BNX2FC_IO_DBG(rec_req, "handle CMD LOST case\n");
+                        new_io_req = bnx2fc_cmd_alloc(tgt);
+                        if (!new_io_req)
+                                goto abort_io;
+                        new_io_req->sc_cmd = orig_io_req->sc_cmd;
+                        /* cleanup orig_io_req that is with the FW */
+                        set_bit(BNX2FC_FLAG_CMD_LOST,
+                                &orig_io_req->req_flags);
+                        bnx2fc_initiate_cleanup(orig_io_req);
+                        /* Post a new IO req with the same sc_cmd */
+                        BNX2FC_IO_DBG(rec_req, "Post IO request again\n");
+                        spin_unlock_bh(&tgt->tgt_lock);
+                        rc = bnx2fc_post_io_req(tgt, new_io_req);
+                        spin_lock_bh(&tgt->tgt_lock);
+                        if (!rc)
+                                goto free_frame;
+                        BNX2FC_IO_DBG(rec_req, "REC: io post err\n");
+                }
+abort_io:
+                rc = bnx2fc_initiate_abts(orig_io_req);
+                if (rc != SUCCESS) {
+                        BNX2FC_IO_DBG(rec_req, "rec_compl: initiate_abts "
+                                "failed. issue cleanup\n");
+                        bnx2fc_initiate_cleanup(orig_io_req);
+                }
+        } else if (opcode == ELS_LS_ACC) {
+                /* REVISIT: Check if the exchange is already aborted */
+                offset = ntohl(acc->reca_fc4value);
+                e_stat = ntohl(acc->reca_e_stat);
+                if (e_stat & ESB_ST_SEQ_INIT)  {
+                        BNX2FC_IO_DBG(rec_req, "target has the seq init\n");
+                        goto free_frame;
+                }
+                BNX2FC_IO_DBG(rec_req, "e_stat = 0x%x, offset = 0x%x\n",
+                        e_stat, offset);
+                /* Seq initiative is with us */
+                err_entry = (struct fcoe_err_report_entry *)
+                             &orig_io_req->err_entry;
+                sc_cmd = orig_io_req->sc_cmd;
+                if (sc_cmd->sc_data_direction == DMA_TO_DEVICE) {
+                        /* SCSI WRITE command */
+                        if (offset == orig_io_req->data_xfer_len) {
+                                BNX2FC_IO_DBG(rec_req, "WRITE - resp lost\n");
+                                /* FCP_RSP lost */
+                                r_ctl = FC_RCTL_DD_CMD_STATUS;
+                                offset = 0;
+                        } else  {
+                                /* start transmitting from offset */
+                                BNX2FC_IO_DBG(rec_req, "XFER_RDY/DATA lost\n");
+                                send_seq_clnp = true;
+                                r_ctl = FC_RCTL_DD_DATA_DESC;
+                                if (bnx2fc_initiate_seq_cleanup(orig_io_req,
+                                                                offset, r_ctl))
+                                        abort_io = true;
+                                /* XFER_RDY */
+                        }
+                } else {
+                        /* SCSI READ command */
+                        if (err_entry->data.rx_buf_off ==
+                                        orig_io_req->data_xfer_len) {
+                                /* FCP_RSP lost */
+                                BNX2FC_IO_DBG(rec_req, "READ - resp lost\n");
+                                r_ctl = FC_RCTL_DD_CMD_STATUS;
+                                offset = 0;
+                        } else  {
+                                /* request retransmission from this offset */
+                                send_seq_clnp = true;
+                                offset = err_entry->data.rx_buf_off;
+                                BNX2FC_IO_DBG(rec_req, "RD DATA lost\n");
+                                /* FCP_DATA lost */
+                                r_ctl = FC_RCTL_DD_SOL_DATA;
+                                if (bnx2fc_initiate_seq_cleanup(orig_io_req,
+                                                                offset, r_ctl))
+                                        abort_io = true;
+                        }
+                }
+                if (abort_io) {
+                        rc = bnx2fc_initiate_abts(orig_io_req);
+                        if (rc != SUCCESS) {
+                                BNX2FC_IO_DBG(rec_req, "rec_compl:initiate_abts"
+                                              " failed. issue cleanup\n");
+                                bnx2fc_initiate_cleanup(orig_io_req);
+                        }
+                } else if (!send_seq_clnp) {
+                        BNX2FC_IO_DBG(rec_req, "Send SRR - FCP_RSP\n");
+                        spin_unlock_bh(&tgt->tgt_lock);
+                        rc = bnx2fc_send_srr(orig_io_req, offset, r_ctl);
+                        spin_lock_bh(&tgt->tgt_lock);
+
+                        if (rc) {
+                                BNX2FC_IO_DBG(rec_req, "Unable to send SRR"
+                                        " IO will abort\n");
+                        }
+                }
+        }
+free_frame:
+        fc_frame_free(fp);
+free_buf:
+        kfree(buf);
+rec_compl_done:
+        kref_put(&orig_io_req->refcount, bnx2fc_cmd_release);
+        kfree(cb_arg);
+}
+
+int bnx2fc_send_rec(struct bnx2fc_cmd *orig_io_req)
+{
+        struct fc_els_rec rec;
+        struct bnx2fc_rport *tgt = orig_io_req->tgt;
+        struct fc_lport *lport = tgt->rdata->local_port;
+        struct bnx2fc_els_cb_arg *cb_arg = NULL;
+        u32 sid = tgt->sid;
+        u32 r_a_tov = lport->r_a_tov;
+        int rc;
+
+        BNX2FC_IO_DBG(orig_io_req, "Sending REC\n");
+        memset(&rec, 0, sizeof(rec));
+
+        cb_arg = kzalloc(sizeof(struct bnx2fc_els_cb_arg), GFP_ATOMIC);
+        if (!cb_arg) {
+                printk(KERN_ERR PFX "Unable to allocate cb_arg for REC\n");
+                rc = -ENOMEM;
+                goto rec_err;
+        }
+        kref_get(&orig_io_req->refcount);
+
+        cb_arg->aborted_io_req = orig_io_req;
+
+        rec.rec_cmd = ELS_REC;
+        hton24(rec.rec_s_id, sid);
+        rec.rec_ox_id = htons(orig_io_req->xid);
+        rec.rec_rx_id = htons(orig_io_req->task->rxwr_txrd.var_ctx.rx_id);
+
+        rc = bnx2fc_initiate_els(tgt, ELS_REC, &rec, sizeof(rec),
+                                 bnx2fc_rec_compl, cb_arg,
+                                 r_a_tov);
+rec_err:
+        if (rc) {
+                BNX2FC_IO_DBG(orig_io_req, "REC failed - release\n");
+                spin_lock_bh(&tgt->tgt_lock);
+                kref_put(&orig_io_req->refcount, bnx2fc_cmd_release);
+                spin_unlock_bh(&tgt->tgt_lock);
+                kfree(cb_arg);
+        }
+        return rc;
+}
+
+int bnx2fc_send_srr(struct bnx2fc_cmd *orig_io_req, u32 offset, u8 r_ctl)
+{
+        struct fcp_srr srr;
+        struct bnx2fc_rport *tgt = orig_io_req->tgt;
+        struct fc_lport *lport = tgt->rdata->local_port;
+        struct bnx2fc_els_cb_arg *cb_arg = NULL;
+        u32 r_a_tov = lport->r_a_tov;
+        int rc;
+
+        BNX2FC_IO_DBG(orig_io_req, "Sending SRR\n");
+        memset(&srr, 0, sizeof(srr));
+
+        cb_arg = kzalloc(sizeof(struct bnx2fc_els_cb_arg), GFP_ATOMIC);
+        if (!cb_arg) {
+                printk(KERN_ERR PFX "Unable to allocate cb_arg for SRR\n");
+                rc = -ENOMEM;
+                goto srr_err;
+        }
+        kref_get(&orig_io_req->refcount);
+
+        cb_arg->aborted_io_req = orig_io_req;
+
+        srr.srr_op = ELS_SRR;
+        srr.srr_ox_id = htons(orig_io_req->xid);
+        srr.srr_rx_id = htons(orig_io_req->task->rxwr_txrd.var_ctx.rx_id);
+        srr.srr_rel_off = htonl(offset);
+        srr.srr_r_ctl = r_ctl;
+        orig_io_req->srr_offset = offset;
+        orig_io_req->srr_rctl = r_ctl;
+
+        rc = bnx2fc_initiate_els(tgt, ELS_SRR, &srr, sizeof(srr),
+                                 bnx2fc_srr_compl, cb_arg,
+                                 r_a_tov);
+srr_err:
+        if (rc) {
+                BNX2FC_IO_DBG(orig_io_req, "SRR failed - release\n");
+                spin_lock_bh(&tgt->tgt_lock);
+                kref_put(&orig_io_req->refcount, bnx2fc_cmd_release);
+                spin_unlock_bh(&tgt->tgt_lock);
+                kfree(cb_arg);
+        } else
+                set_bit(BNX2FC_FLAG_SRR_SENT, &orig_io_req->req_flags);
+
+        return rc;
+}
+
 static int bnx2fc_initiate_els(struct bnx2fc_rport *tgt, unsigned int op,
                         void *data, u32 data_len,
                         void (*cb_func)(struct bnx2fc_els_cb_arg *cb_arg),
                         struct bnx2fc_els_cb_arg *cb_arg, u32 timer_msec)
 {
         struct fcoe_port *port = tgt->port;
-        struct bnx2fc_hba *hba = port->priv;
+        struct bnx2fc_interface *interface = port->priv;
         struct fc_rport *rport = tgt->rport;
         struct fc_lport *lport = port->lport;
         struct bnx2fc_cmd *els_req;
@@ -274,12 +678,12 @@ static int bnx2fc_initiate_els(struct bnx2fc_rport *tgt, unsigned int op,
 
         rc = fc_remote_port_chkready(rport);
         if (rc) {
-                printk(KERN_ALERT PFX "els 0x%x: rport not ready\n", op);
+                printk(KERN_ERR PFX "els 0x%x: rport not ready\n", op);
                 rc = -EINVAL;
                 goto els_err;
         }
         if (lport->state != LPORT_ST_READY || !(lport->link_up)) {
-                printk(KERN_ALERT PFX "els 0x%x: link is not ready\n", op);
+                printk(KERN_ERR PFX "els 0x%x: link is not ready\n", op);
                 rc = -EINVAL;
                 goto els_err;
         }
@@ -305,7 +709,7 @@ static int bnx2fc_initiate_els(struct bnx2fc_rport *tgt, unsigned int op,
         mp_req = (struct bnx2fc_mp_req *)&(els_req->mp_req);
         rc = bnx2fc_init_mp_req(els_req);
         if (rc == FAILED) {
-                printk(KERN_ALERT PFX "ELS MP request init failed\n");
+                printk(KERN_ERR PFX "ELS MP request init failed\n");
                 spin_lock_bh(&tgt->tgt_lock);
                 kref_put(&els_req->refcount, bnx2fc_cmd_release);
                 spin_unlock_bh(&tgt->tgt_lock);
@@ -324,7 +728,7 @@ static int bnx2fc_initiate_els(struct bnx2fc_rport *tgt, unsigned int op,
         if ((op >= ELS_LS_RJT) && (op <= ELS_AUTH_ELS)) {
                 memcpy(mp_req->req_buf, data, data_len);
         } else {
-                printk(KERN_ALERT PFX "Invalid ELS op 0x%x\n", op);
+                printk(KERN_ERR PFX "Invalid ELS op 0x%x\n", op);
                 els_req->cb_func = NULL;
                 els_req->cb_arg = NULL;
                 spin_lock_bh(&tgt->tgt_lock);
@@ -342,9 +746,14 @@ static int bnx2fc_initiate_els(struct bnx2fc_rport *tgt, unsigned int op,
         did = tgt->rport->port_id;
         sid = tgt->sid;
 
-        __fc_fill_fc_hdr(fc_hdr, FC_RCTL_ELS_REQ, did, sid,
-                           FC_TYPE_ELS, FC_FC_FIRST_SEQ | FC_FC_END_SEQ |
-                           FC_FC_SEQ_INIT, 0);
+        if (op == ELS_SRR)
+                __fc_fill_fc_hdr(fc_hdr, FC_RCTL_ELS4_REQ, did, sid,
+                                   FC_TYPE_FCP, FC_FC_FIRST_SEQ |
+                                   FC_FC_END_SEQ | FC_FC_SEQ_INIT, 0);
+        else
+                __fc_fill_fc_hdr(fc_hdr, FC_RCTL_ELS_REQ, did, sid,
+                                   FC_TYPE_ELS, FC_FC_FIRST_SEQ |
+                                   FC_FC_END_SEQ | FC_FC_SEQ_INIT, 0);
 
         /* Obtain exchange id */
         xid = els_req->xid;
@@ -352,7 +761,8 @@ static int bnx2fc_initiate_els(struct bnx2fc_rport *tgt, unsigned int op,
         index = xid % BNX2FC_TASKS_PER_PAGE;
 
         /* Initialize task context for this IO request */
-        task_page = (struct fcoe_task_ctx_entry *) hba->task_ctx[task_idx];
+        task_page = (struct fcoe_task_ctx_entry *)
+                        interface->hba->task_ctx[task_idx];
         task = &(task_page[index]);
         bnx2fc_init_mp_task(els_req, task);
 
@@ -496,8 +906,8 @@ struct fc_seq *bnx2fc_elsct_send(struct fc_lport *lport, u32 did,
                                       void *arg, u32 timeout)
 {
         struct fcoe_port *port = lport_priv(lport);
-        struct bnx2fc_hba *hba = port->priv;
-        struct fcoe_ctlr *fip = &hba->ctlr;
+        struct bnx2fc_interface *interface = port->priv;
+        struct fcoe_ctlr *fip = &interface->ctlr;
         struct fc_frame_header *fh = fc_frame_header_get(fp);
 
         switch (op) {
diff --git a/drivers/scsi/bnx2fc/bnx2fc_fcoe.c b/drivers/scsi/bnx2fc/bnx2fc_fcoe.c
index a97aff3a0662..7cb2cd48b17b 100644
--- a/drivers/scsi/bnx2fc/bnx2fc_fcoe.c
+++ b/drivers/scsi/bnx2fc/bnx2fc_fcoe.c
@@ -3,7 +3,7 @@
  * cnic modules to create FCoE instances, send/receive non-offloaded
  * FIP/FCoE packets, listen to link events etc.
  *
- * Copyright (c) 2008 - 2010 Broadcom Corporation
+ * Copyright (c) 2008 - 2011 Broadcom Corporation
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -15,13 +15,14 @@
 #include "bnx2fc.h"
 
 static struct list_head adapter_list;
+static struct list_head if_list;
 static u32 adapter_count;
 static DEFINE_MUTEX(bnx2fc_dev_lock);
 DEFINE_PER_CPU(struct bnx2fc_percpu_s, bnx2fc_percpu);
 
 #define DRV_MODULE_NAME         "bnx2fc"
 #define DRV_MODULE_VERSION      BNX2FC_VERSION
-#define DRV_MODULE_RELDATE      "Jun 10, 2011"
+#define DRV_MODULE_RELDATE      "Jun 23, 2011"
 
 
 static char version[] __devinitdata =
@@ -61,7 +62,7 @@ static int bnx2fc_disable(struct net_device *netdev);
 
 static void bnx2fc_recv_frame(struct sk_buff *skb);
 
-static void bnx2fc_start_disc(struct bnx2fc_hba *hba);
+static void bnx2fc_start_disc(struct bnx2fc_interface *interface);
 static int bnx2fc_shost_config(struct fc_lport *lport, struct device *dev);
 static int bnx2fc_net_config(struct fc_lport *lp);
 static int bnx2fc_lport_config(struct fc_lport *lport);
@@ -70,18 +71,20 @@ static int bnx2fc_bind_adapter_devices(struct bnx2fc_hba *hba);
 static void bnx2fc_unbind_adapter_devices(struct bnx2fc_hba *hba);
 static int bnx2fc_bind_pcidev(struct bnx2fc_hba *hba);
 static void bnx2fc_unbind_pcidev(struct bnx2fc_hba *hba);
-static struct fc_lport *bnx2fc_if_create(struct bnx2fc_hba *hba,
+static struct fc_lport *bnx2fc_if_create(struct bnx2fc_interface *interface,
                                   struct device *parent, int npiv);
 static void bnx2fc_destroy_work(struct work_struct *work);
 
 static struct bnx2fc_hba *bnx2fc_hba_lookup(struct net_device *phys_dev);
+static struct bnx2fc_interface *bnx2fc_interface_lookup(struct net_device
+                                                        *phys_dev);
 static struct bnx2fc_hba *bnx2fc_find_hba_for_cnic(struct cnic_dev *cnic);
 
 static int bnx2fc_fw_init(struct bnx2fc_hba *hba);
 static void bnx2fc_fw_destroy(struct bnx2fc_hba *hba);
 
 static void bnx2fc_port_shutdown(struct fc_lport *lport);
-static void bnx2fc_stop(struct bnx2fc_hba *hba);
+static void bnx2fc_stop(struct bnx2fc_interface *interface);
 static int __init bnx2fc_mod_init(void);
 static void __exit bnx2fc_mod_exit(void);
 
@@ -142,7 +145,8 @@ static void bnx2fc_abort_io(struct fc_lport *lport)
 static void bnx2fc_cleanup(struct fc_lport *lport)
 {
         struct fcoe_port *port = lport_priv(lport);
-        struct bnx2fc_hba *hba = port->priv;
+        struct bnx2fc_interface *interface = port->priv;
+        struct bnx2fc_hba *hba = interface->hba;
         struct bnx2fc_rport *tgt;
         int i;
 
@@ -219,7 +223,8 @@ static int bnx2fc_xmit(struct fc_lport *lport, struct fc_frame *fp)
         struct fcoe_crc_eof     *cp;
         struct sk_buff          *skb;
         struct fc_frame_header  *fh;
-        struct bnx2fc_hba       *hba;
+        struct bnx2fc_interface *interface;
+        struct bnx2fc_hba *hba;
         struct fcoe_port        *port;
         struct fcoe_hdr         *hp;
         struct bnx2fc_rport     *tgt;
@@ -230,7 +235,8 @@ static int bnx2fc_xmit(struct fc_lport *lport, struct fc_frame *fp)
         int                     wlen, rc = 0;
 
         port = (struct fcoe_port *)lport_priv(lport);
-        hba = port->priv;
+        interface = port->priv;
+        hba = interface->hba;
 
         fh = fc_frame_header_get(fp);
 
@@ -242,12 +248,12 @@ static int bnx2fc_xmit(struct fc_lport *lport, struct fc_frame *fp)
         }
 
         if (unlikely(fh->fh_r_ctl == FC_RCTL_ELS_REQ)) {
-                if (!hba->ctlr.sel_fcf) {
+                if (!interface->ctlr.sel_fcf) {
                         BNX2FC_HBA_DBG(lport, "FCF not selected yet!\n");
                         kfree_skb(skb);
                         return -EINVAL;
                 }
-                if (fcoe_ctlr_els_send(&hba->ctlr, lport, skb))
+                if (fcoe_ctlr_els_send(&interface->ctlr, lport, skb))
                         return 0;
         }
 
@@ -316,19 +322,19 @@ static int bnx2fc_xmit(struct fc_lport *lport, struct fc_frame *fp)
         skb_reset_network_header(skb);
         skb->mac_len = elen;
         skb->protocol = htons(ETH_P_FCOE);
-        skb->dev = hba->netdev;
+        skb->dev = interface->netdev;
 
         /* fill up mac and fcoe headers */
         eh = eth_hdr(skb);
         eh->h_proto = htons(ETH_P_FCOE);
-        if (hba->ctlr.map_dest)
+        if (interface->ctlr.map_dest)
                 fc_fcoe_set_mac(eh->h_dest, fh->fh_d_id);
         else
                 /* insert GW address */
-                memcpy(eh->h_dest, hba->ctlr.dest_addr, ETH_ALEN);
+                memcpy(eh->h_dest, interface->ctlr.dest_addr, ETH_ALEN);
 
-        if (unlikely(hba->ctlr.flogi_oxid != FC_XID_UNKNOWN))
-                memcpy(eh->h_source, hba->ctlr.ctl_src_addr, ETH_ALEN);
+        if (unlikely(interface->ctlr.flogi_oxid != FC_XID_UNKNOWN))
+                memcpy(eh->h_source, interface->ctlr.ctl_src_addr, ETH_ALEN);
         else
                 memcpy(eh->h_source, port->data_src_addr, ETH_ALEN);
 
@@ -377,22 +383,23 @@ static int bnx2fc_rcv(struct sk_buff *skb, struct net_device *dev,
                 struct packet_type *ptype, struct net_device *olddev)
 {
         struct fc_lport *lport;
-        struct bnx2fc_hba *hba;
+        struct bnx2fc_interface *interface;
         struct fc_frame_header *fh;
         struct fcoe_rcv_info *fr;
         struct fcoe_percpu_s *bg;
         unsigned short oxid;
 
-        hba = container_of(ptype, struct bnx2fc_hba, fcoe_packet_type);
-        lport = hba->ctlr.lp;
+        interface = container_of(ptype, struct bnx2fc_interface,
+                                 fcoe_packet_type);
+        lport = interface->ctlr.lp;
 
         if (unlikely(lport == NULL)) {
-                printk(KERN_ALERT PFX "bnx2fc_rcv: lport is NULL\n");
+                printk(KERN_ERR PFX "bnx2fc_rcv: lport is NULL\n");
                 goto err;
         }
 
         if (unlikely(eth_hdr(skb)->h_proto != htons(ETH_P_FCOE))) {
-                printk(KERN_ALERT PFX "bnx2fc_rcv: Wrong FC type frame\n");
+                printk(KERN_ERR PFX "bnx2fc_rcv: Wrong FC type frame\n");
                 goto err;
         }
 
@@ -411,7 +418,6 @@ static int bnx2fc_rcv(struct sk_buff *skb, struct net_device *dev,
 
         fr = fcoe_dev_from_skb(skb);
         fr->fr_dev = lport;
-        fr->ptype = ptype;
 
         bg = &bnx2fc_global;
         spin_lock_bh(&bg->fcoe_rx_list.lock);
@@ -469,7 +475,7 @@ static void bnx2fc_recv_frame(struct sk_buff *skb)
         fr = fcoe_dev_from_skb(skb);
         lport = fr->fr_dev;
         if (unlikely(lport == NULL)) {
-                printk(KERN_ALERT PFX "Invalid lport struct\n");
+                printk(KERN_ERR PFX "Invalid lport struct\n");
                 kfree_skb(skb);
                 return;
         }
@@ -594,7 +600,8 @@ static struct fc_host_statistics *bnx2fc_get_host_stats(struct Scsi_Host *shost)
         struct fc_host_statistics *bnx2fc_stats;
         struct fc_lport *lport = shost_priv(shost);
         struct fcoe_port *port = lport_priv(lport);
-        struct bnx2fc_hba *hba = port->priv;
+        struct bnx2fc_interface *interface = port->priv;
+        struct bnx2fc_hba *hba = interface->hba;
         struct fcoe_statistics_params *fw_stats;
         int rc = 0;
 
@@ -631,7 +638,7 @@ static struct fc_host_statistics *bnx2fc_get_host_stats(struct Scsi_Host *shost)
 static int bnx2fc_shost_config(struct fc_lport *lport, struct device *dev)
 {
         struct fcoe_port *port = lport_priv(lport);
-        struct bnx2fc_hba *hba = port->priv;
+        struct bnx2fc_interface *interface = port->priv;
         struct Scsi_Host *shost = lport->host;
         int rc = 0;
 
@@ -654,7 +661,7 @@ static int bnx2fc_shost_config(struct fc_lport *lport, struct device *dev)
                 fc_host_max_npiv_vports(lport->host) = USHRT_MAX;
         sprintf(fc_host_symbolic_name(lport->host), "%s v%s over %s",
                 BNX2FC_NAME, BNX2FC_VERSION,
-                hba->netdev->name);
+                interface->netdev->name);
 
         return 0;
 }
@@ -662,8 +669,8 @@ static int bnx2fc_shost_config(struct fc_lport *lport, struct device *dev)
 static void bnx2fc_link_speed_update(struct fc_lport *lport)
 {
         struct fcoe_port *port = lport_priv(lport);
-        struct bnx2fc_hba *hba = port->priv;
-        struct net_device *netdev = hba->netdev;
+        struct bnx2fc_interface *interface = port->priv;
+        struct net_device *netdev = interface->netdev;
         struct ethtool_cmd ecmd;
 
         if (!dev_ethtool_get_settings(netdev, &ecmd)) {
@@ -691,7 +698,8 @@ static void bnx2fc_link_speed_update(struct fc_lport *lport)
 static int bnx2fc_link_ok(struct fc_lport *lport)
 {
         struct fcoe_port *port = lport_priv(lport);
-        struct bnx2fc_hba *hba = port->priv;
+        struct bnx2fc_interface *interface = port->priv;
+        struct bnx2fc_hba *hba = interface->hba;
         struct net_device *dev = hba->phys_dev;
         int rc = 0;
 
@@ -713,7 +721,7 @@ static int bnx2fc_link_ok(struct fc_lport *lport)
  */
 void bnx2fc_get_link_state(struct bnx2fc_hba *hba)
 {
-        if (test_bit(__LINK_STATE_NOCARRIER, &hba->netdev->state))
+        if (test_bit(__LINK_STATE_NOCARRIER, &hba->phys_dev->state))
                 set_bit(ADAPTER_STATE_LINK_DOWN, &hba->adapter_state);
         else
                 clear_bit(ADAPTER_STATE_LINK_DOWN, &hba->adapter_state);
@@ -722,11 +730,13 @@ void bnx2fc_get_link_state(struct bnx2fc_hba *hba)
 static int bnx2fc_net_config(struct fc_lport *lport)
 {
         struct bnx2fc_hba *hba;
+        struct bnx2fc_interface *interface;
         struct fcoe_port *port;
         u64 wwnn, wwpn;
 
         port = lport_priv(lport);
-        hba = port->priv;
+        interface = port->priv;
+        hba = interface->hba;
 
         /* require support for get_pauseparam ethtool op. */
         if (!hba->phys_dev->ethtool_ops ||
@@ -743,11 +753,11 @@ static int bnx2fc_net_config(struct fc_lport *lport)
         bnx2fc_link_speed_update(lport);
 
         if (!lport->vport) {
-                wwnn = fcoe_wwn_from_mac(hba->ctlr.ctl_src_addr, 1, 0);
+                wwnn = fcoe_wwn_from_mac(interface->ctlr.ctl_src_addr, 1, 0);
                 BNX2FC_HBA_DBG(lport, "WWNN = 0x%llx\n", wwnn);
                 fc_set_wwnn(lport, wwnn);
 
-                wwpn = fcoe_wwn_from_mac(hba->ctlr.ctl_src_addr, 2, 0);
+                wwpn = fcoe_wwn_from_mac(interface->ctlr.ctl_src_addr, 2, 0);
                 BNX2FC_HBA_DBG(lport, "WWPN = 0x%llx\n", wwpn);
                 fc_set_wwpn(lport, wwpn);
         }
@@ -759,9 +769,9 @@ static void bnx2fc_destroy_timer(unsigned long data)
 {
         struct bnx2fc_hba *hba = (struct bnx2fc_hba *)data;
 
-        BNX2FC_HBA_DBG(hba->ctlr.lp, "ERROR:bnx2fc_destroy_timer - "
+        BNX2FC_MISC_DBG("ERROR:bnx2fc_destroy_timer - "
                    "Destroy compl not received!!\n");
-        hba->flags |= BNX2FC_FLAG_DESTROY_CMPL;
+        set_bit(BNX2FC_FLAG_DESTROY_CMPL, &hba->flags);
         wake_up_interruptible(&hba->destroy_wait);
 }
 
@@ -779,54 +789,35 @@ static void bnx2fc_indicate_netevent(void *context, unsigned long event,
                                      u16 vlan_id)
 {
         struct bnx2fc_hba *hba = (struct bnx2fc_hba *)context;
-        struct fc_lport *lport = hba->ctlr.lp;
+        struct fc_lport *lport;
         struct fc_lport *vport;
+        struct bnx2fc_interface *interface;
+        int wait_for_upload = 0;
         u32 link_possible = 1;
 
         /* Ignore vlans for now */
         if (vlan_id != 0)
                 return;
 
-        if (!test_bit(BNX2FC_CREATE_DONE, &hba->init_done)) {
-                BNX2FC_MISC_DBG("driver not ready. event=%s %ld\n",
-                           hba->netdev->name, event);
-                return;
-        }
-
-        /*
-         * ASSUMPTION:
-         * indicate_netevent cannot be called from cnic unless bnx2fc
-         * does register_device
-         */
-        BUG_ON(!lport);
-
-        BNX2FC_HBA_DBG(lport, "enter netevent handler - event=%s %ld\n",
-                                hba->netdev->name, event);
-
         switch (event) {
         case NETDEV_UP:
-                BNX2FC_HBA_DBG(lport, "Port up, adapter_state = %ld\n",
-                        hba->adapter_state);
                 if (!test_bit(ADAPTER_STATE_UP, &hba->adapter_state))
                         printk(KERN_ERR "indicate_netevent: "\
-                                        "adapter is not UP!!\n");
+                                        "hba is not UP!!\n");
                 break;
 
         case NETDEV_DOWN:
-                BNX2FC_HBA_DBG(lport, "Port down\n");
                 clear_bit(ADAPTER_STATE_GOING_DOWN, &hba->adapter_state);
                 clear_bit(ADAPTER_STATE_UP, &hba->adapter_state);
                 link_possible = 0;
                 break;
 
         case NETDEV_GOING_DOWN:
-                BNX2FC_HBA_DBG(lport, "Port going down\n");
                 set_bit(ADAPTER_STATE_GOING_DOWN, &hba->adapter_state);
                 link_possible = 0;
                 break;
 
         case NETDEV_CHANGE:
-                BNX2FC_HBA_DBG(lport, "NETDEV_CHANGE\n");
                 break;
 
         default:
@@ -834,15 +825,22 @@ static void bnx2fc_indicate_netevent(void *context, unsigned long event,
                 return;
         }
 
-        bnx2fc_link_speed_update(lport);
+        mutex_lock(&bnx2fc_dev_lock);
+        list_for_each_entry(interface, &if_list, list) {
 
-        if (link_possible && !bnx2fc_link_ok(lport)) {
-                printk(KERN_ERR "indicate_netevent: call ctlr_link_up\n");
-                fcoe_ctlr_link_up(&hba->ctlr);
-        } else {
-                printk(KERN_ERR "indicate_netevent: call ctlr_link_down\n");
-                if (fcoe_ctlr_link_down(&hba->ctlr)) {
-                        clear_bit(ADAPTER_STATE_READY, &hba->adapter_state);
+                if (interface->hba != hba)
+                        continue;
+
+                lport = interface->ctlr.lp;
+                BNX2FC_HBA_DBG(lport, "netevent handler - event=%s %ld\n",
+                                interface->netdev->name, event);
+
+                bnx2fc_link_speed_update(lport);
+
+                if (link_possible && !bnx2fc_link_ok(lport)) {
+                        printk(KERN_ERR "indicate_netevent: ctlr_link_up\n");
+                        fcoe_ctlr_link_up(&interface->ctlr);
+                } else if (fcoe_ctlr_link_down(&interface->ctlr)) {
                         mutex_lock(&lport->lp_mutex);
                         list_for_each_entry(vport, &lport->vports, list)
                                 fc_host_port_type(vport->host) =
@@ -853,24 +851,26 @@ static void bnx2fc_indicate_netevent(void *context, unsigned long event,
                                     get_cpu())->LinkFailureCount++;
                         put_cpu();
                         fcoe_clean_pending_queue(lport);
+                        wait_for_upload = 1;
+                }
+        }
+        mutex_unlock(&bnx2fc_dev_lock);
 
-                        init_waitqueue_head(&hba->shutdown_wait);
-                        BNX2FC_HBA_DBG(lport, "indicate_netevent "
-                                             "num_ofld_sess = %d\n",
-                                   hba->num_ofld_sess);
-                        hba->wait_for_link_down = 1;
-                        BNX2FC_HBA_DBG(lport, "waiting for uploads to "
-                                             "compl proc = %s\n",
-                                   current->comm);
-                        wait_event_interruptible(hba->shutdown_wait,
-                                                 (hba->num_ofld_sess == 0));
-                        BNX2FC_HBA_DBG(lport, "wakeup - num_ofld_sess = %d\n",
+        if (wait_for_upload) {
+                clear_bit(ADAPTER_STATE_READY, &hba->adapter_state);
+                init_waitqueue_head(&hba->shutdown_wait);
+                BNX2FC_MISC_DBG("indicate_netevent "
+                                "num_ofld_sess = %d\n",
+                                hba->num_ofld_sess);
+                hba->wait_for_link_down = 1;
+                wait_event_interruptible(hba->shutdown_wait,
+                                         (hba->num_ofld_sess == 0));
+                BNX2FC_MISC_DBG("wakeup - num_ofld_sess = %d\n",
                                 hba->num_ofld_sess);
-                        hba->wait_for_link_down = 0;
+                hba->wait_for_link_down = 0;
 
-                        if (signal_pending(current))
-                                flush_signals(current);
-                }
+                if (signal_pending(current))
+                        flush_signals(current);
         }
 }
 
@@ -889,23 +889,12 @@ static int bnx2fc_libfc_config(struct fc_lport *lport)
 
 static int bnx2fc_em_config(struct fc_lport *lport)
 {
-        struct fcoe_port *port = lport_priv(lport);
-        struct bnx2fc_hba *hba = port->priv;
-
         if (!fc_exch_mgr_alloc(lport, FC_CLASS_3, FCOE_MIN_XID,
                                 FCOE_MAX_XID, NULL)) {
                 printk(KERN_ERR PFX "em_config:fc_exch_mgr_alloc failed\n");
                 return -ENOMEM;
         }
 
-        hba->cmd_mgr = bnx2fc_cmd_mgr_alloc(hba, BNX2FC_MIN_XID,
-                                            BNX2FC_MAX_XID);
-
-        if (!hba->cmd_mgr) {
-                printk(KERN_ERR PFX "em_config:bnx2fc_cmd_mgr_alloc failed\n");
-                fc_exch_mgr_free(lport);
-                return -ENOMEM;
-        }
         return 0;
 }
 
@@ -918,11 +907,8 @@ static int bnx2fc_lport_config(struct fc_lport *lport)
         lport->e_d_tov = 2 * 1000;
         lport->r_a_tov = 10 * 1000;
 
-        /* REVISIT: enable when supporting tape devices
         lport->service_params = (FCP_SPPF_INIT_FCN | FCP_SPPF_RD_XRDY_DIS |
                                 FCP_SPPF_RETRY | FCP_SPPF_CONF_COMPL);
-        */
-        lport->service_params = (FCP_SPPF_INIT_FCN | FCP_SPPF_RD_XRDY_DIS);
         lport->does_npiv = 1;
 
         memset(&lport->rnid_gen, 0, sizeof(struct fc_els_rnid_gen));
@@ -952,9 +938,10 @@ static int bnx2fc_fip_recv(struct sk_buff *skb, struct net_device *dev,
                            struct packet_type *ptype,
                            struct net_device *orig_dev)
 {
-        struct bnx2fc_hba *hba;
-        hba = container_of(ptype, struct bnx2fc_hba, fip_packet_type);
-        fcoe_ctlr_recv(&hba->ctlr, skb);
+        struct bnx2fc_interface *interface;
+        interface = container_of(ptype, struct bnx2fc_interface,
+                                 fip_packet_type);
+        fcoe_ctlr_recv(&interface->ctlr, skb);
         return 0;
 }
 
@@ -1005,17 +992,17 @@ static int bnx2fc_vport_create(struct fc_vport *vport, bool disabled)
         struct Scsi_Host *shost = vport_to_shost(vport);
         struct fc_lport *n_port = shost_priv(shost);
         struct fcoe_port *port = lport_priv(n_port);
-        struct bnx2fc_hba *hba = port->priv;
-        struct net_device *netdev = hba->netdev;
+        struct bnx2fc_interface *interface = port->priv;
+        struct net_device *netdev = interface->netdev;
         struct fc_lport *vn_port;
 
-        if (!test_bit(BNX2FC_FW_INIT_DONE, &hba->init_done)) {
+        if (!test_bit(BNX2FC_FLAG_FW_INIT_DONE, &interface->hba->flags)) {
                 printk(KERN_ERR PFX "vn ports cannot be created on"
-                        "this hba\n");
+                        "this interface\n");
                 return -EIO;
         }
         mutex_lock(&bnx2fc_dev_lock);
-        vn_port = bnx2fc_if_create(hba, &vport->dev, 1);
+        vn_port = bnx2fc_if_create(interface, &vport->dev, 1);
         mutex_unlock(&bnx2fc_dev_lock);
 
         if (IS_ERR(vn_port)) {
@@ -1065,10 +1052,10 @@ static int bnx2fc_vport_disable(struct fc_vport *vport, bool disable)
 }
 
 
-static int bnx2fc_netdev_setup(struct bnx2fc_hba *hba)
+static int bnx2fc_netdev_setup(struct bnx2fc_interface *interface)
 {
-        struct net_device *netdev = hba->netdev;
-        struct net_device *physdev = hba->phys_dev;
+        struct net_device *netdev = interface->netdev;
+        struct net_device *physdev = interface->hba->phys_dev;
         struct netdev_hw_addr *ha;
         int sel_san_mac = 0;
 
@@ -1083,7 +1070,8 @@ static int bnx2fc_netdev_setup(struct bnx2fc_hba *hba)
 
                 if ((ha->type == NETDEV_HW_ADDR_T_SAN) &&
                     (is_valid_ether_addr(ha->addr))) {
-                        memcpy(hba->ctlr.ctl_src_addr, ha->addr, ETH_ALEN);
+                        memcpy(interface->ctlr.ctl_src_addr, ha->addr,
+                               ETH_ALEN);
                         sel_san_mac = 1;
                         BNX2FC_MISC_DBG("Found SAN MAC\n");
                 }
@@ -1093,15 +1081,15 @@ static int bnx2fc_netdev_setup(struct bnx2fc_hba *hba)
         if (!sel_san_mac)
                 return -ENODEV;
 
-        hba->fip_packet_type.func = bnx2fc_fip_recv;
-        hba->fip_packet_type.type = htons(ETH_P_FIP);
-        hba->fip_packet_type.dev = netdev;
-        dev_add_pack(&hba->fip_packet_type);
+        interface->fip_packet_type.func = bnx2fc_fip_recv;
+        interface->fip_packet_type.type = htons(ETH_P_FIP);
+        interface->fip_packet_type.dev = netdev;
+        dev_add_pack(&interface->fip_packet_type);
 
-        hba->fcoe_packet_type.func = bnx2fc_rcv;
-        hba->fcoe_packet_type.type = __constant_htons(ETH_P_FCOE);
-        hba->fcoe_packet_type.dev = netdev;
-        dev_add_pack(&hba->fcoe_packet_type);
+        interface->fcoe_packet_type.func = bnx2fc_rcv;
+        interface->fcoe_packet_type.type = __constant_htons(ETH_P_FCOE);
+        interface->fcoe_packet_type.dev = netdev;
+        dev_add_pack(&interface->fcoe_packet_type);
 
         return 0;
 }
@@ -1137,53 +1125,54 @@ static void bnx2fc_release_transport(void)
 
 static void bnx2fc_interface_release(struct kref *kref)
 {
-        struct bnx2fc_hba *hba;
+        struct bnx2fc_interface *interface;
         struct net_device *netdev;
-        struct net_device *phys_dev;
 
-        hba = container_of(kref, struct bnx2fc_hba, kref);
+        interface = container_of(kref, struct bnx2fc_interface, kref);
         BNX2FC_MISC_DBG("Interface is being released\n");
 
-        netdev = hba->netdev;
-        phys_dev = hba->phys_dev;
+        netdev = interface->netdev;
 
         /* tear-down FIP controller */
-        if (test_and_clear_bit(BNX2FC_CTLR_INIT_DONE, &hba->init_done))
-                fcoe_ctlr_destroy(&hba->ctlr);
+        if (test_and_clear_bit(BNX2FC_CTLR_INIT_DONE, &interface->if_flags))
+                fcoe_ctlr_destroy(&interface->ctlr);
+
+        kfree(interface);
 
-        /* Free the command manager */
-        if (hba->cmd_mgr) {
-                bnx2fc_cmd_mgr_free(hba->cmd_mgr);
-                hba->cmd_mgr = NULL;
-        }
         dev_put(netdev);
         module_put(THIS_MODULE);
 }
 
-static inline void bnx2fc_interface_get(struct bnx2fc_hba *hba)
+static inline void bnx2fc_interface_get(struct bnx2fc_interface *interface)
 {
-        kref_get(&hba->kref);
+        kref_get(&interface->kref);
 }
 
-static inline void bnx2fc_interface_put(struct bnx2fc_hba *hba)
+static inline void bnx2fc_interface_put(struct bnx2fc_interface *interface)
 {
-        kref_put(&hba->kref, bnx2fc_interface_release);
+        kref_put(&interface->kref, bnx2fc_interface_release);
 }
-static void bnx2fc_interface_destroy(struct bnx2fc_hba *hba)
+static void bnx2fc_hba_destroy(struct bnx2fc_hba *hba)
 {
+        /* Free the command manager */
+        if (hba->cmd_mgr) {
+                bnx2fc_cmd_mgr_free(hba->cmd_mgr);
+                hba->cmd_mgr = NULL;
+        }
+        kfree(hba->tgt_ofld_list);
         bnx2fc_unbind_pcidev(hba);
         kfree(hba);
 }
 
 /**
- * bnx2fc_interface_create - create a new fcoe instance
+ * bnx2fc_hba_create - create a new bnx2fc hba
  *
  * @cnic:       pointer to cnic device
  *
- * Creates a new FCoE instance on the given device which include allocating
- *      hba structure, scsi_host and lport structures.
+ * Creates a new FCoE hba on the given device.
+ *
  */
-static struct bnx2fc_hba *bnx2fc_interface_create(struct cnic_dev *cnic)
+static struct bnx2fc_hba *bnx2fc_hba_create(struct cnic_dev *cnic)
 {
         struct bnx2fc_hba *hba;
         int rc;
@@ -1198,65 +1187,83 @@ static struct bnx2fc_hba *bnx2fc_interface_create(struct cnic_dev *cnic)
 
         hba->cnic = cnic;
         rc = bnx2fc_bind_pcidev(hba);
-        if (rc)
+        if (rc) {
+                printk(KERN_ERR PFX "create_adapter:  bind error\n");
                 goto bind_err;
+        }
         hba->phys_dev = cnic->netdev;
-        /* will get overwritten after we do vlan discovery */
-        hba->netdev = hba->phys_dev;
+        hba->next_conn_id = 0;
+
+        hba->tgt_ofld_list =
+                kzalloc(sizeof(struct bnx2fc_rport *) * BNX2FC_NUM_MAX_SESS,
+                        GFP_KERNEL);
+        if (!hba->tgt_ofld_list) {
+                printk(KERN_ERR PFX "Unable to allocate tgt offload list\n");
+                goto tgtofld_err;
+        }
+
+        hba->num_ofld_sess = 0;
+
+        hba->cmd_mgr = bnx2fc_cmd_mgr_alloc(hba, BNX2FC_MIN_XID,
+                                                BNX2FC_MAX_XID);
+        if (!hba->cmd_mgr) {
+                printk(KERN_ERR PFX "em_config:bnx2fc_cmd_mgr_alloc failed\n");
+                goto cmgr_err;
+        }
 
         init_waitqueue_head(&hba->shutdown_wait);
         init_waitqueue_head(&hba->destroy_wait);
+        INIT_LIST_HEAD(&hba->vports);
 
         return hba;
+
+cmgr_err:
+        kfree(hba->tgt_ofld_list);
+tgtofld_err:
+        bnx2fc_unbind_pcidev(hba);
 bind_err:
-        printk(KERN_ERR PFX "create_interface: bind error\n");
         kfree(hba);
         return NULL;
 }
 
-static int bnx2fc_interface_setup(struct bnx2fc_hba *hba,
-                                  enum fip_state fip_mode)
+struct bnx2fc_interface *bnx2fc_interface_create(struct bnx2fc_hba *hba,
+                                      struct net_device *netdev,
+                                      enum fip_state fip_mode)
 {
+        struct bnx2fc_interface *interface;
         int rc = 0;
-        struct net_device *netdev = hba->netdev;
-        struct fcoe_ctlr *fip = &hba->ctlr;
 
+        interface = kzalloc(sizeof(*interface), GFP_KERNEL);
+        if (!interface) {
+                printk(KERN_ERR PFX "Unable to allocate interface structure\n");
+                return NULL;
+        }
         dev_hold(netdev);
-        kref_init(&hba->kref);
-
-        hba->flags = 0;
+        kref_init(&interface->kref);
+        interface->hba = hba;
+        interface->netdev = netdev;
 
         /* Initialize FIP */
-        memset(fip, 0, sizeof(*fip));
-        fcoe_ctlr_init(fip, fip_mode);
-        hba->ctlr.send = bnx2fc_fip_send;
-        hba->ctlr.update_mac = bnx2fc_update_src_mac;
-        hba->ctlr.get_src_addr = bnx2fc_get_src_mac;
-        set_bit(BNX2FC_CTLR_INIT_DONE, &hba->init_done);
-
-        INIT_LIST_HEAD(&hba->vports);
-        rc = bnx2fc_netdev_setup(hba);
-        if (rc)
-                goto setup_err;
+        fcoe_ctlr_init(&interface->ctlr, fip_mode);
+        interface->ctlr.send = bnx2fc_fip_send;
+        interface->ctlr.update_mac = bnx2fc_update_src_mac;
+        interface->ctlr.get_src_addr = bnx2fc_get_src_mac;
+        set_bit(BNX2FC_CTLR_INIT_DONE, &interface->if_flags);
 
-        hba->next_conn_id = 0;
+        rc = bnx2fc_netdev_setup(interface);
+        if (!rc)
+                return interface;
 
-        memset(hba->tgt_ofld_list, 0, sizeof(hba->tgt_ofld_list));
-        hba->num_ofld_sess = 0;
-
-        return 0;
-
-setup_err:
-        fcoe_ctlr_destroy(&hba->ctlr);
+        fcoe_ctlr_destroy(&interface->ctlr);
         dev_put(netdev);
-        bnx2fc_interface_put(hba);
-        return rc;
+        kfree(interface);
+        return NULL;
 }
 
 /**
  * bnx2fc_if_create - Create FCoE instance on a given interface
  *
- * @hba:        FCoE interface to create a local port on
+ * @interface:  FCoE interface to create a local port on
  * @parent:     Device pointer to be the parent in sysfs for the SCSI host
  * @npiv:       Indicates if the port is vport or not
  *
@@ -1264,7 +1271,7 @@ setup_err:
  *
  * Returns:     Allocated fc_lport or an error pointer
  */
-static struct fc_lport *bnx2fc_if_create(struct bnx2fc_hba *hba,
+static struct fc_lport *bnx2fc_if_create(struct bnx2fc_interface *interface,
                                   struct device *parent, int npiv)
 {
         struct fc_lport         *lport, *n_port;
@@ -1272,11 +1279,12 @@ static struct fc_lport *bnx2fc_if_create(struct bnx2fc_hba *hba,
         struct Scsi_Host        *shost;
         struct fc_vport         *vport = dev_to_vport(parent);
         struct bnx2fc_lport     *blport;
+        struct bnx2fc_hba       *hba;
         int                     rc = 0;
 
         blport = kzalloc(sizeof(struct bnx2fc_lport), GFP_KERNEL);
         if (!blport) {
-                BNX2FC_HBA_DBG(hba->ctlr.lp, "Unable to alloc bnx2fc_lport\n");
+                BNX2FC_HBA_DBG(interface->ctlr.lp, "Unable to alloc blport\n");
                 return NULL;
         }
 
@@ -1293,7 +1301,7 @@ static struct fc_lport *bnx2fc_if_create(struct bnx2fc_hba *hba,
         shost = lport->host;
         port = lport_priv(lport);
         port->lport = lport;
-        port->priv = hba;
+        port->priv = interface;
         INIT_WORK(&port->destroy_work, bnx2fc_destroy_work);
 
         /* Configure fcoe_port */
@@ -1317,7 +1325,7 @@ static struct fc_lport *bnx2fc_if_create(struct bnx2fc_hba *hba,
         rc = bnx2fc_shost_config(lport, parent);
         if (rc) {
                 printk(KERN_ERR PFX "Couldnt configure shost for %s\n",
-                        hba->netdev->name);
+                        interface->netdev->name);
                 goto lp_config_err;
         }
 
@@ -1343,8 +1351,9 @@ static struct fc_lport *bnx2fc_if_create(struct bnx2fc_hba *hba,
                 goto shost_err;
         }
 
-        bnx2fc_interface_get(hba);
+        bnx2fc_interface_get(interface);
 
+        hba = interface->hba;
         spin_lock_bh(&hba->hba_lock);
         blport->lport = lport;
         list_add_tail(&blport->list, &hba->vports);
@@ -1361,21 +1370,19 @@ free_blport:
         return NULL;
 }
 
-static void bnx2fc_netdev_cleanup(struct bnx2fc_hba *hba)
+static void bnx2fc_netdev_cleanup(struct bnx2fc_interface *interface)
 {
         /* Dont listen for Ethernet packets anymore */
-        __dev_remove_pack(&hba->fcoe_packet_type);
-        __dev_remove_pack(&hba->fip_packet_type);
+        __dev_remove_pack(&interface->fcoe_packet_type);
+        __dev_remove_pack(&interface->fip_packet_type);
         synchronize_net();
 }
 
-static void bnx2fc_if_destroy(struct fc_lport *lport)
+static void bnx2fc_if_destroy(struct fc_lport *lport, struct bnx2fc_hba *hba)
 {
         struct fcoe_port *port = lport_priv(lport);
-        struct bnx2fc_hba *hba = port->priv;
         struct bnx2fc_lport *blport, *tmp;
 
-        BNX2FC_HBA_DBG(hba->ctlr.lp, "ENTERED bnx2fc_if_destroy\n");
         /* Stop the transmit retry timer */
         del_timer_sync(&port->timer);
 
@@ -1409,8 +1416,6 @@ static void bnx2fc_if_destroy(struct fc_lport *lport)
 
         /* Release Scsi_Host */
         scsi_host_put(lport->host);
-
-        bnx2fc_interface_put(hba);
 }
 
 /**
@@ -1425,46 +1430,31 @@ static void bnx2fc_if_destroy(struct fc_lport *lport)
  */
 static int bnx2fc_destroy(struct net_device *netdev)
 {
-        struct bnx2fc_hba *hba = NULL;
-        struct net_device *phys_dev;
+        struct bnx2fc_interface *interface = NULL;
+        struct bnx2fc_hba *hba;
+        struct fc_lport *lport;
         int rc = 0;
 
         rtnl_lock();
-
         mutex_lock(&bnx2fc_dev_lock);
-        /* obtain physical netdev */
-        if (netdev->priv_flags & IFF_802_1Q_VLAN)
-                phys_dev = vlan_dev_real_dev(netdev);
-        else {
-                printk(KERN_ERR PFX "Not a vlan device\n");
-                rc = -ENODEV;
-                goto netdev_err;
-        }
 
-        hba = bnx2fc_hba_lookup(phys_dev);
-        if (!hba || !hba->ctlr.lp) {
+        interface = bnx2fc_interface_lookup(netdev);
+        if (!interface || !interface->ctlr.lp) {
                 rc = -ENODEV;
-                printk(KERN_ERR PFX "bnx2fc_destroy: hba or lport not found\n");
-                goto netdev_err;
-        }
-
-        if (!test_bit(BNX2FC_CREATE_DONE, &hba->init_done)) {
-                printk(KERN_ERR PFX "bnx2fc_destroy: Create not called\n");
+                printk(KERN_ERR PFX "bnx2fc_destroy: interface or lport not found\n");
                 goto netdev_err;
         }
 
-        bnx2fc_netdev_cleanup(hba);
-
-        bnx2fc_stop(hba);
-
-        bnx2fc_if_destroy(hba->ctlr.lp);
+        hba = interface->hba;
 
-        destroy_workqueue(hba->timer_work_queue);
+        bnx2fc_netdev_cleanup(interface);
+        lport = interface->ctlr.lp;
+        bnx2fc_stop(interface);
+        list_del(&interface->list);
+        destroy_workqueue(interface->timer_work_queue);
+        bnx2fc_interface_put(interface);
+        bnx2fc_if_destroy(lport, hba);
 
-        if (test_bit(BNX2FC_FW_INIT_DONE, &hba->init_done))
-                bnx2fc_fw_destroy(hba);
-
-        clear_bit(BNX2FC_CREATE_DONE, &hba->init_done);
 netdev_err:
         mutex_unlock(&bnx2fc_dev_lock);
         rtnl_unlock();
@@ -1475,16 +1465,20 @@ static void bnx2fc_destroy_work(struct work_struct *work)
 {
         struct fcoe_port *port;
         struct fc_lport *lport;
+        struct bnx2fc_interface *interface;
+        struct bnx2fc_hba *hba;
 
         port = container_of(work, struct fcoe_port, destroy_work);
         lport = port->lport;
+        interface = port->priv;
+        hba = interface->hba;
 
         BNX2FC_HBA_DBG(lport, "Entered bnx2fc_destroy_work\n");
 
         bnx2fc_port_shutdown(lport);
         rtnl_lock();
         mutex_lock(&bnx2fc_dev_lock);
-        bnx2fc_if_destroy(lport);
+        bnx2fc_if_destroy(lport, hba);
         mutex_unlock(&bnx2fc_dev_lock);
         rtnl_unlock();
 }
@@ -1556,28 +1550,27 @@ static void bnx2fc_unbind_pcidev(struct bnx2fc_hba *hba)
 static void bnx2fc_ulp_start(void *handle)
 {
         struct bnx2fc_hba *hba = handle;
-        struct fc_lport *lport = hba->ctlr.lp;
+        struct bnx2fc_interface *interface;
+        struct fc_lport *lport;
 
-        BNX2FC_MISC_DBG("Entered %s\n", __func__);
         mutex_lock(&bnx2fc_dev_lock);
 
-        if (test_bit(BNX2FC_FW_INIT_DONE, &hba->init_done))
-                goto start_disc;
-
-        if (test_bit(BNX2FC_CREATE_DONE, &hba->init_done))
+        if (!test_bit(BNX2FC_FLAG_FW_INIT_DONE, &hba->flags))
                 bnx2fc_fw_init(hba);
 
-start_disc:
-        mutex_unlock(&bnx2fc_dev_lock);
-
         BNX2FC_MISC_DBG("bnx2fc started.\n");
 
-        /* Kick off Fabric discovery*/
-        if (test_bit(BNX2FC_CREATE_DONE, &hba->init_done)) {
-                printk(KERN_ERR PFX "ulp_init: start discovery\n");
-                lport->tt.frame_send = bnx2fc_xmit;
-                bnx2fc_start_disc(hba);
+        list_for_each_entry(interface, &if_list, list) {
+                if (interface->hba == hba) {
+                        lport = interface->ctlr.lp;
+                        /* Kick off Fabric discovery*/
+                        printk(KERN_ERR PFX "ulp_init: start discovery\n");
+                        lport->tt.frame_send = bnx2fc_xmit;
+                        bnx2fc_start_disc(interface);
+                }
         }
+
+        mutex_unlock(&bnx2fc_dev_lock);
 }
 
 static void bnx2fc_port_shutdown(struct fc_lport *lport)
@@ -1587,37 +1580,25 @@ static void bnx2fc_port_shutdown(struct fc_lport *lport)
         fc_lport_destroy(lport);
 }
 
-static void bnx2fc_stop(struct bnx2fc_hba *hba)
+static void bnx2fc_stop(struct bnx2fc_interface *interface)
 {
         struct fc_lport *lport;
         struct fc_lport *vport;
 
-        BNX2FC_MISC_DBG("ENTERED %s - init_done = %ld\n", __func__,
-                   hba->init_done);
-        if (test_bit(BNX2FC_FW_INIT_DONE, &hba->init_done) &&
-            test_bit(BNX2FC_CREATE_DONE, &hba->init_done)) {
-                lport = hba->ctlr.lp;
-                bnx2fc_port_shutdown(lport);
-                BNX2FC_HBA_DBG(lport, "bnx2fc_stop: waiting for %d "
-                                "offloaded sessions\n",
-                                hba->num_ofld_sess);
-                wait_event_interruptible(hba->shutdown_wait,
-                                         (hba->num_ofld_sess == 0));
-                mutex_lock(&lport->lp_mutex);
-                list_for_each_entry(vport, &lport->vports, list)
-                        fc_host_port_type(vport->host) = FC_PORTTYPE_UNKNOWN;
-                mutex_unlock(&lport->lp_mutex);
-                fc_host_port_type(lport->host) = FC_PORTTYPE_UNKNOWN;
-                fcoe_ctlr_link_down(&hba->ctlr);
-                fcoe_clean_pending_queue(lport);
-
-                mutex_lock(&hba->hba_mutex);
-                clear_bit(ADAPTER_STATE_UP, &hba->adapter_state);
-                clear_bit(ADAPTER_STATE_GOING_DOWN, &hba->adapter_state);
+        if (!test_bit(BNX2FC_FLAG_FW_INIT_DONE, &interface->hba->flags))
+                return;
 
-                clear_bit(ADAPTER_STATE_READY, &hba->adapter_state);
-                mutex_unlock(&hba->hba_mutex);
-        }
+        lport = interface->ctlr.lp;
+        bnx2fc_port_shutdown(lport);
+
+        mutex_lock(&lport->lp_mutex);
+        list_for_each_entry(vport, &lport->vports, list)
+                fc_host_port_type(vport->host) =
+                                        FC_PORTTYPE_UNKNOWN;
+        mutex_unlock(&lport->lp_mutex);
+        fc_host_port_type(lport->host) = FC_PORTTYPE_UNKNOWN;
+        fcoe_ctlr_link_down(&interface->ctlr);
+        fcoe_clean_pending_queue(lport);
 }
 
 static int bnx2fc_fw_init(struct bnx2fc_hba *hba)
@@ -1656,8 +1637,7 @@ static int bnx2fc_fw_init(struct bnx2fc_hba *hba)
         }
 
 
-        /* Mark HBA to indicate that the FW INIT is done */
-        set_bit(BNX2FC_FW_INIT_DONE, &hba->init_done);
+        set_bit(BNX2FC_FLAG_FW_INIT_DONE, &hba->flags);
         return 0;
 
 err_unbind:
@@ -1668,7 +1648,7 @@ err_out:
 
 static void bnx2fc_fw_destroy(struct bnx2fc_hba *hba)
 {
-        if (test_and_clear_bit(BNX2FC_FW_INIT_DONE, &hba->init_done)) {
+        if (test_and_clear_bit(BNX2FC_FLAG_FW_INIT_DONE, &hba->flags)) {
                 if (bnx2fc_send_fw_fcoe_destroy_msg(hba) == 0) {
                         init_timer(&hba->destroy_timer);
                         hba->destroy_timer.expires = BNX2FC_FW_TIMEOUT +
@@ -1677,8 +1657,8 @@ static void bnx2fc_fw_destroy(struct bnx2fc_hba *hba)
                         hba->destroy_timer.data = (unsigned long)hba;
                         add_timer(&hba->destroy_timer);
                         wait_event_interruptible(hba->destroy_wait,
-                                                 (hba->flags &
-                                                  BNX2FC_FLAG_DESTROY_CMPL));
+                                        test_bit(BNX2FC_FLAG_DESTROY_CMPL,
+                                                 &hba->flags));
                         /* This should never happen */
                         if (signal_pending(current))
                                 flush_signals(current);
@@ -1699,40 +1679,57 @@ static void bnx2fc_fw_destroy(struct bnx2fc_hba *hba)
  */
 static void bnx2fc_ulp_stop(void *handle)
 {
-        struct bnx2fc_hba *hba = (struct bnx2fc_hba *)handle;
+        struct bnx2fc_hba *hba = handle;
+        struct bnx2fc_interface *interface;
 
         printk(KERN_ERR "ULP_STOP\n");
 
         mutex_lock(&bnx2fc_dev_lock);
-        bnx2fc_stop(hba);
+        if (!test_bit(BNX2FC_FLAG_FW_INIT_DONE, &hba->flags))
+                goto exit;
+        list_for_each_entry(interface, &if_list, list) {
+                if (interface->hba == hba)
+                        bnx2fc_stop(interface);
+        }
+        BUG_ON(hba->num_ofld_sess != 0);
+
+        mutex_lock(&hba->hba_mutex);
+        clear_bit(ADAPTER_STATE_UP, &hba->adapter_state);
+        clear_bit(ADAPTER_STATE_GOING_DOWN,
+                  &hba->adapter_state);
+
+        clear_bit(ADAPTER_STATE_READY, &hba->adapter_state);
+        mutex_unlock(&hba->hba_mutex);
+
         bnx2fc_fw_destroy(hba);
+exit:
         mutex_unlock(&bnx2fc_dev_lock);
 }
 
-static void bnx2fc_start_disc(struct bnx2fc_hba *hba)
+static void bnx2fc_start_disc(struct bnx2fc_interface *interface)
 {
         struct fc_lport *lport;
         int wait_cnt = 0;
 
         BNX2FC_MISC_DBG("Entered %s\n", __func__);
         /* Kick off FIP/FLOGI */
-        if (!test_bit(BNX2FC_FW_INIT_DONE, &hba->init_done)) {
+        if (!test_bit(BNX2FC_FLAG_FW_INIT_DONE, &interface->hba->flags)) {
                 printk(KERN_ERR PFX "Init not done yet\n");
                 return;
         }
 
-        lport = hba->ctlr.lp;
+        lport = interface->ctlr.lp;
         BNX2FC_HBA_DBG(lport, "calling fc_fabric_login\n");
 
         if (!bnx2fc_link_ok(lport)) {
                 BNX2FC_HBA_DBG(lport, "ctlr_link_up\n");
-                fcoe_ctlr_link_up(&hba->ctlr);
+                fcoe_ctlr_link_up(&interface->ctlr);
                 fc_host_port_type(lport->host) = FC_PORTTYPE_NPORT;
-                set_bit(ADAPTER_STATE_READY, &hba->adapter_state);
+                set_bit(ADAPTER_STATE_READY, &interface->hba->adapter_state);
         }
 
         /* wait for the FCF to be selected before issuing FLOGI */
-        while (!hba->ctlr.sel_fcf) {
+        while (!interface->ctlr.sel_fcf) {
                 msleep(250);
                 /* give up after 3 secs */
                 if (++wait_cnt > 12)
@@ -1758,15 +1755,15 @@ static void bnx2fc_ulp_init(struct cnic_dev *dev)
 
         BNX2FC_MISC_DBG("Entered %s\n", __func__);
         /* bnx2fc works only when bnx2x is loaded */
-        if (!test_bit(CNIC_F_BNX2X_CLASS, &dev->flags)) {
+        if (!test_bit(CNIC_F_BNX2X_CLASS, &dev->flags) ||
+            (dev->max_fcoe_conn == 0)) {
                 printk(KERN_ERR PFX "bnx2fc FCoE not supported on %s,"
-                                    " flags: %lx\n",
-                        dev->netdev->name, dev->flags);
+                                    " flags: %lx fcoe_conn: %d\n",
+                        dev->netdev->name, dev->flags, dev->max_fcoe_conn);
                 return;
         }
 
-        /* Configure FCoE interface */
-        hba = bnx2fc_interface_create(dev);
+        hba = bnx2fc_hba_create(dev);
         if (!hba) {
                 printk(KERN_ERR PFX "hba initialization failed\n");
                 return;
@@ -1774,7 +1771,7 @@ static void bnx2fc_ulp_init(struct cnic_dev *dev)
 
         /* Add HBA to the adapter list */
         mutex_lock(&bnx2fc_dev_lock);
-        list_add_tail(&hba->link, &adapter_list);
+        list_add_tail(&hba->list, &adapter_list);
         adapter_count++;
         mutex_unlock(&bnx2fc_dev_lock);
 
@@ -1782,7 +1779,7 @@ static void bnx2fc_ulp_init(struct cnic_dev *dev)
         rc = dev->register_device(dev, CNIC_ULP_FCOE,
                                                 (void *) hba);
         if (rc)
-                printk(KERN_ALERT PFX "register_device failed, rc = %d\n", rc);
+                printk(KERN_ERR PFX "register_device failed, rc = %d\n", rc);
         else
                 set_bit(BNX2FC_CNIC_REGISTERED, &hba->reg_with_cnic);
 }
@@ -1790,52 +1787,21 @@ static void bnx2fc_ulp_init(struct cnic_dev *dev)
 
 static int bnx2fc_disable(struct net_device *netdev)
 {
-        struct bnx2fc_hba *hba;
-        struct net_device *phys_dev;
-        struct ethtool_drvinfo drvinfo;
+        struct bnx2fc_interface *interface;
         int rc = 0;
 
         rtnl_lock();
-
         mutex_lock(&bnx2fc_dev_lock);
 
-        /* obtain physical netdev */
-        if (netdev->priv_flags & IFF_802_1Q_VLAN)
-                phys_dev = vlan_dev_real_dev(netdev);
-        else {
-                printk(KERN_ERR PFX "Not a vlan device\n");
-                rc = -ENODEV;
-                goto nodev;
-        }
-
-        /* verify if the physical device is a netxtreme2 device */
-        if (phys_dev->ethtool_ops && phys_dev->ethtool_ops->get_drvinfo) {
-                memset(&drvinfo, 0, sizeof(drvinfo));
-                phys_dev->ethtool_ops->get_drvinfo(phys_dev, &drvinfo);
-                if (strcmp(drvinfo.driver, "bnx2x")) {
-                        printk(KERN_ERR PFX "Not a netxtreme2 device\n");
-                        rc = -ENODEV;
-                        goto nodev;
-                }
-        } else {
-                printk(KERN_ERR PFX "unable to obtain drv_info\n");
-                rc = -ENODEV;
-                goto nodev;
-        }
-
-        printk(KERN_ERR PFX "phys_dev is netxtreme2 device\n");
-
-        /* obtain hba and initialize rest of the structure */
-        hba = bnx2fc_hba_lookup(phys_dev);
-        if (!hba || !hba->ctlr.lp) {
+        interface = bnx2fc_interface_lookup(netdev);
+        if (!interface || !interface->ctlr.lp) {
                 rc = -ENODEV;
-                printk(KERN_ERR PFX "bnx2fc_disable: hba or lport not found\n");
+                printk(KERN_ERR PFX "bnx2fc_disable: interface or lport not found\n");
         } else {
-                fcoe_ctlr_link_down(&hba->ctlr);
-                fcoe_clean_pending_queue(hba->ctlr.lp);
+                fcoe_ctlr_link_down(&interface->ctlr);
+                fcoe_clean_pending_queue(interface->ctlr.lp);
         }
 
-nodev:
         mutex_unlock(&bnx2fc_dev_lock);
         rtnl_unlock();
         return rc;
@@ -1844,48 +1810,19 @@ nodev:
 
 static int bnx2fc_enable(struct net_device *netdev)
 {
-        struct bnx2fc_hba *hba;
-        struct net_device *phys_dev;
-        struct ethtool_drvinfo drvinfo;
+        struct bnx2fc_interface *interface;
         int rc = 0;
 
         rtnl_lock();
-
-        BNX2FC_MISC_DBG("Entered %s\n", __func__);
         mutex_lock(&bnx2fc_dev_lock);
 
-        /* obtain physical netdev */
-        if (netdev->priv_flags & IFF_802_1Q_VLAN)
-                phys_dev = vlan_dev_real_dev(netdev);
-        else {
-                printk(KERN_ERR PFX "Not a vlan device\n");
-                rc = -ENODEV;
-                goto nodev;
-        }
-        /* verify if the physical device is a netxtreme2 device */
-        if (phys_dev->ethtool_ops && phys_dev->ethtool_ops->get_drvinfo) {
-                memset(&drvinfo, 0, sizeof(drvinfo));
-                phys_dev->ethtool_ops->get_drvinfo(phys_dev, &drvinfo);
-                if (strcmp(drvinfo.driver, "bnx2x")) {
-                        printk(KERN_ERR PFX "Not a netxtreme2 device\n");
-                        rc = -ENODEV;
-                        goto nodev;
-                }
-        } else {
-                printk(KERN_ERR PFX "unable to obtain drv_info\n");
+        interface = bnx2fc_interface_lookup(netdev);
+        if (!interface || !interface->ctlr.lp) {
                 rc = -ENODEV;
-                goto nodev;
-        }
-
-        /* obtain hba and initialize rest of the structure */
-        hba = bnx2fc_hba_lookup(phys_dev);
-        if (!hba || !hba->ctlr.lp) {
-                rc = -ENODEV;
-                printk(KERN_ERR PFX "bnx2fc_enable: hba or lport not found\n");
-        } else if (!bnx2fc_link_ok(hba->ctlr.lp))
-                fcoe_ctlr_link_up(&hba->ctlr);
+                printk(KERN_ERR PFX "bnx2fc_enable: interface or lport not found\n");
+        } else if (!bnx2fc_link_ok(interface->ctlr.lp))
+                fcoe_ctlr_link_up(&interface->ctlr);
 
-nodev:
         mutex_unlock(&bnx2fc_dev_lock);
         rtnl_unlock();
         return rc;
@@ -1903,6 +1840,7 @@ nodev:
  */
 static int bnx2fc_create(struct net_device *netdev, enum fip_state fip_mode)
 {
+        struct bnx2fc_interface *interface;
         struct bnx2fc_hba *hba;
         struct net_device *phys_dev;
         struct fc_lport *lport;
@@ -1938,7 +1876,7 @@ static int bnx2fc_create(struct net_device *netdev, enum fip_state fip_mode)
         if (phys_dev->ethtool_ops && phys_dev->ethtool_ops->get_drvinfo) {
                 memset(&drvinfo, 0, sizeof(drvinfo));
                 phys_dev->ethtool_ops->get_drvinfo(phys_dev, &drvinfo);
-                if (strcmp(drvinfo.driver, "bnx2x")) {
+                if (strncmp(drvinfo.driver, "bnx2x", strlen("bnx2x"))) {
                         printk(KERN_ERR PFX "Not a netxtreme2 device\n");
                         rc = -EINVAL;
                         goto netdev_err;
@@ -1949,7 +1887,7 @@ static int bnx2fc_create(struct net_device *netdev, enum fip_state fip_mode)
                 goto netdev_err;
         }
 
-        /* obtain hba and initialize rest of the structure */
+        /* obtain interface and initialize rest of the structure */
         hba = bnx2fc_hba_lookup(phys_dev);
         if (!hba) {
                 rc = -ENODEV;
@@ -1957,67 +1895,61 @@ static int bnx2fc_create(struct net_device *netdev, enum fip_state fip_mode)
                 goto netdev_err;
         }
 
-        if (!test_bit(BNX2FC_FW_INIT_DONE, &hba->init_done)) {
-                rc = bnx2fc_fw_init(hba);
-                if (rc)
-                        goto netdev_err;
-        }
-
-        if (test_bit(BNX2FC_CREATE_DONE, &hba->init_done)) {
+        if (bnx2fc_interface_lookup(netdev)) {
                 rc = -EEXIST;
                 goto netdev_err;
         }
 
-        /* update netdev with vlan netdev */
-        hba->netdev = netdev;
-        hba->vlan_id = vlan_id;
-        hba->vlan_enabled = 1;
-
-        rc = bnx2fc_interface_setup(hba, fip_mode);
-        if (rc) {
-                printk(KERN_ERR PFX "bnx2fc_interface_setup failed\n");
+        interface = bnx2fc_interface_create(hba, netdev, fip_mode);
+        if (!interface) {
+                printk(KERN_ERR PFX "bnx2fc_interface_create failed\n");
                 goto ifput_err;
         }
 
-        hba->timer_work_queue =
+        interface->vlan_id = vlan_id;
+        interface->vlan_enabled = 1;
+
+        interface->timer_work_queue =
                         create_singlethread_workqueue("bnx2fc_timer_wq");
-        if (!hba->timer_work_queue) {
+        if (!interface->timer_work_queue) {
                 printk(KERN_ERR PFX "ulp_init could not create timer_wq\n");
                 rc = -EINVAL;
                 goto ifput_err;
         }
 
-        lport = bnx2fc_if_create(hba, &hba->pcidev->dev, 0);
+        lport = bnx2fc_if_create(interface, &interface->hba->pcidev->dev, 0);
         if (!lport) {
                 printk(KERN_ERR PFX "Failed to create interface (%s)\n",
                         netdev->name);
-                bnx2fc_netdev_cleanup(hba);
+                bnx2fc_netdev_cleanup(interface);
                 rc = -EINVAL;
                 goto if_create_err;
         }
 
+        /* Add interface to if_list */
+        list_add_tail(&interface->list, &if_list);
+
         lport->boot_time = jiffies;
 
         /* Make this master N_port */
-        hba->ctlr.lp = lport;
+        interface->ctlr.lp = lport;
 
-        set_bit(BNX2FC_CREATE_DONE, &hba->init_done);
-        printk(KERN_ERR PFX "create: START DISC\n");
-        bnx2fc_start_disc(hba);
+        BNX2FC_HBA_DBG(lport, "create: START DISC\n");
+        bnx2fc_start_disc(interface);
         /*
          * Release from kref_init in bnx2fc_interface_setup, on success
          * lport should be holding a reference taken in bnx2fc_if_create
          */
-        bnx2fc_interface_put(hba);
+        bnx2fc_interface_put(interface);
         /* put netdev that was held while calling dev_get_by_name */
         mutex_unlock(&bnx2fc_dev_lock);
         rtnl_unlock();
         return 0;
 
 if_create_err:
-        destroy_workqueue(hba->timer_work_queue);
+        destroy_workqueue(interface->timer_work_queue);
 ifput_err:
-        bnx2fc_interface_put(hba);
+        bnx2fc_interface_put(interface);
 netdev_err:
         module_put(THIS_MODULE);
 mod_err:
@@ -2027,7 +1959,7 @@ mod_err:
 }
 
 /**
- * bnx2fc_find_hba_for_cnic - maps cnic instance to bnx2fc adapter instance
+ * bnx2fc_find_hba_for_cnic - maps cnic instance to bnx2fc hba instance
  *
  * @cnic:       Pointer to cnic device instance
  *
@@ -2047,19 +1979,30 @@ static struct bnx2fc_hba *bnx2fc_find_hba_for_cnic(struct cnic_dev *cnic)
         return NULL;
 }
 
-static struct bnx2fc_hba *bnx2fc_hba_lookup(struct net_device *phys_dev)
+static struct bnx2fc_interface *bnx2fc_interface_lookup(struct net_device
+                                                        *netdev)
+{
+        struct bnx2fc_interface *interface;
+
+        /* Called with bnx2fc_dev_lock held */
+        list_for_each_entry(interface, &if_list, list) {
+                if (interface->netdev == netdev)
+                        return interface;
+        }
+        return NULL;
+}
+
+static struct bnx2fc_hba *bnx2fc_hba_lookup(struct net_device
+                                                      *phys_dev)
 {
-        struct list_head *list;
-        struct list_head *temp;
         struct bnx2fc_hba *hba;
 
         /* Called with bnx2fc_dev_lock held */
-        list_for_each_safe(list, temp, &adapter_list) {
-                hba = (struct bnx2fc_hba *)list;
+        list_for_each_entry(hba, &adapter_list, list) {
                 if (hba->phys_dev == phys_dev)
                         return hba;
         }
-        printk(KERN_ERR PFX "hba_lookup: hba NULL\n");
+        printk(KERN_ERR PFX "adapter_lookup: hba NULL\n");
         return NULL;
 }
 
@@ -2071,6 +2014,8 @@ static struct bnx2fc_hba *bnx2fc_hba_lookup(struct net_device *phys_dev)
 static void bnx2fc_ulp_exit(struct cnic_dev *dev)
 {
         struct bnx2fc_hba *hba;
+        struct bnx2fc_interface *interface, *tmp;
+        struct fc_lport *lport;
 
         BNX2FC_MISC_DBG("Entered bnx2fc_ulp_exit\n");
 
@@ -2089,13 +2034,20 @@ static void bnx2fc_ulp_exit(struct cnic_dev *dev)
                 return;
         }
 
-        list_del_init(&hba->link);
+        list_del_init(&hba->list);
         adapter_count--;
 
-        if (test_bit(BNX2FC_CREATE_DONE, &hba->init_done)) {
+        list_for_each_entry_safe(interface, tmp, &if_list, list) {
                 /* destroy not called yet, move to quiesced list */
-                bnx2fc_netdev_cleanup(hba);
-                bnx2fc_if_destroy(hba->ctlr.lp);
+                if (interface->hba == hba) {
+                        bnx2fc_netdev_cleanup(interface);
+                        bnx2fc_stop(interface);
+
+                        list_del(&interface->list);
+                        lport = interface->ctlr.lp;
+                        bnx2fc_interface_put(interface);
+                        bnx2fc_if_destroy(lport, hba);
+                }
         }
         mutex_unlock(&bnx2fc_dev_lock);
 
@@ -2103,7 +2055,7 @@ static void bnx2fc_ulp_exit(struct cnic_dev *dev)
         /* unregister cnic device */
         if (test_and_clear_bit(BNX2FC_CNIC_REGISTERED, &hba->reg_with_cnic))
                 hba->cnic->unregister_device(hba->cnic, CNIC_ULP_FCOE);
-        bnx2fc_interface_destroy(hba);
+        bnx2fc_hba_destroy(hba);
 }
 
 /**
@@ -2259,6 +2211,7 @@ static int __init bnx2fc_mod_init(void)
         }
 
         INIT_LIST_HEAD(&adapter_list);
+        INIT_LIST_HEAD(&if_list);
         mutex_init(&bnx2fc_dev_lock);
         adapter_count = 0;
 
@@ -2336,16 +2289,17 @@ static void __exit bnx2fc_mod_exit(void)
         mutex_unlock(&bnx2fc_dev_lock);
 
         /* Unregister with cnic */
-        list_for_each_entry_safe(hba, next, &to_be_deleted, link) {
-                list_del_init(&hba->link);
-                printk(KERN_ERR PFX "MOD_EXIT:destroy hba = 0x%p, kref = %d\n",
-                        hba, atomic_read(&hba->kref.refcount));
+        list_for_each_entry_safe(hba, next, &to_be_deleted, list) {
+                list_del_init(&hba->list);
+                printk(KERN_ERR PFX "MOD_EXIT:destroy hba = 0x%p\n",
+                       hba);
                 bnx2fc_ulp_stop(hba);
                 /* unregister cnic device */
                 if (test_and_clear_bit(BNX2FC_CNIC_REGISTERED,
                                        &hba->reg_with_cnic))
-                        hba->cnic->unregister_device(hba->cnic, CNIC_ULP_FCOE);
-                bnx2fc_interface_destroy(hba);
+                        hba->cnic->unregister_device(hba->cnic,
+                                                         CNIC_ULP_FCOE);
+                bnx2fc_hba_destroy(hba);
         }
         cnic_unregister_driver(CNIC_ULP_FCOE);
 
diff --git a/drivers/scsi/bnx2fc/bnx2fc_hwi.c b/drivers/scsi/bnx2fc/bnx2fc_hwi.c
index 09bdd9b88d1a..72cfb14acd3a 100644
--- a/drivers/scsi/bnx2fc/bnx2fc_hwi.c
+++ b/drivers/scsi/bnx2fc/bnx2fc_hwi.c
@@ -2,7 +2,7 @@
  * This file contains the code that low level functions that interact
  * with 57712 FCoE firmware.
  *
- * Copyright (c) 2008 - 2010 Broadcom Corporation
+ * Copyright (c) 2008 - 2011 Broadcom Corporation
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -23,7 +23,7 @@ static void bnx2fc_process_enable_conn_cmpl(struct bnx2fc_hba *hba,
                                                 struct fcoe_kcqe *ofld_kcqe);
 static void bnx2fc_init_failure(struct bnx2fc_hba *hba, u32 err_code);
 static void bnx2fc_process_conn_destroy_cmpl(struct bnx2fc_hba *hba,
-                                        struct fcoe_kcqe *conn_destroy);
+                                        struct fcoe_kcqe *destroy_kcqe);
 
 int bnx2fc_send_stat_req(struct bnx2fc_hba *hba)
 {
@@ -67,7 +67,7 @@ int bnx2fc_send_fw_fcoe_init_msg(struct bnx2fc_hba *hba)
         int rc = 0;
 
         if (!hba->cnic) {
-                printk(KERN_ALERT PFX "hba->cnic NULL during fcoe fw init\n");
+                printk(KERN_ERR PFX "hba->cnic NULL during fcoe fw init\n");
                 return -ENODEV;
         }
 
@@ -103,6 +103,7 @@ int bnx2fc_send_fw_fcoe_init_msg(struct bnx2fc_hba *hba)
         fcoe_init2.hsi_major_version = FCOE_HSI_MAJOR_VERSION;
         fcoe_init2.hsi_minor_version = FCOE_HSI_MINOR_VERSION;
 
+
         fcoe_init2.hash_tbl_pbl_addr_lo = (u32) hba->hash_tbl_pbl_dma;
         fcoe_init2.hash_tbl_pbl_addr_hi = (u32)
                                            ((u64) hba->hash_tbl_pbl_dma >> 32);
@@ -165,7 +166,8 @@ int bnx2fc_send_session_ofld_req(struct fcoe_port *port,
                                         struct bnx2fc_rport *tgt)
 {
         struct fc_lport *lport = port->lport;
-        struct bnx2fc_hba *hba = port->priv;
+        struct bnx2fc_interface *interface = port->priv;
+        struct bnx2fc_hba *hba = interface->hba;
         struct kwqe *kwqe_arr[4];
         struct fcoe_kwqe_conn_offload1 ofld_req1;
         struct fcoe_kwqe_conn_offload2 ofld_req2;
@@ -227,7 +229,7 @@ int bnx2fc_send_session_ofld_req(struct fcoe_port *port,
         ofld_req3.hdr.flags =
                 (FCOE_KWQE_LAYER_CODE << FCOE_KWQE_HEADER_LAYER_CODE_SHIFT);
 
-        ofld_req3.vlan_tag = hba->vlan_id <<
+        ofld_req3.vlan_tag = interface->vlan_id <<
                                 FCOE_KWQE_CONN_OFFLOAD3_VLAN_ID_SHIFT;
         ofld_req3.vlan_tag |= 3 << FCOE_KWQE_CONN_OFFLOAD3_PRIORITY_SHIFT;
 
@@ -277,8 +279,20 @@ int bnx2fc_send_session_ofld_req(struct fcoe_port *port,
         ofld_req3.flags |= (((rdata->sp_features & FC_SP_FT_SEQC) ? 1 : 0) <<
                              FCOE_KWQE_CONN_OFFLOAD3_B_CONT_INCR_SEQ_CNT_SHIFT);
 
+        /*
+         * Info from PRLI response, this info is used for sequence level error
+         * recovery support
+         */
+        if (tgt->dev_type == TYPE_TAPE) {
+                ofld_req3.flags |= 1 <<
+                                    FCOE_KWQE_CONN_OFFLOAD3_B_CONF_REQ_SHIFT;
+                ofld_req3.flags |= (((rdata->flags & FC_RP_FLAGS_REC_SUPPORTED)
+                                    ? 1 : 0) <<
+                                    FCOE_KWQE_CONN_OFFLOAD3_B_REC_VALID_SHIFT);
+        }
+
         /* vlan flag */
-        ofld_req3.flags |= (hba->vlan_enabled <<
+        ofld_req3.flags |= (interface->vlan_enabled <<
                             FCOE_KWQE_CONN_OFFLOAD3_B_VLAN_FLAG_SHIFT);
 
         /* C2_VALID and ACK flags are not set as they are not suppported */
@@ -300,12 +314,13 @@ int bnx2fc_send_session_ofld_req(struct fcoe_port *port,
         ofld_req4.src_mac_addr_mid[1] =  port->data_src_addr[2];
         ofld_req4.src_mac_addr_hi[0] =  port->data_src_addr[1];
         ofld_req4.src_mac_addr_hi[1] =  port->data_src_addr[0];
-        ofld_req4.dst_mac_addr_lo[0] =  hba->ctlr.dest_addr[5];/* fcf mac */
-        ofld_req4.dst_mac_addr_lo[1] =  hba->ctlr.dest_addr[4];
-        ofld_req4.dst_mac_addr_mid[0] =  hba->ctlr.dest_addr[3];
-        ofld_req4.dst_mac_addr_mid[1] =  hba->ctlr.dest_addr[2];
-        ofld_req4.dst_mac_addr_hi[0] =  hba->ctlr.dest_addr[1];
-        ofld_req4.dst_mac_addr_hi[1] =  hba->ctlr.dest_addr[0];
+        ofld_req4.dst_mac_addr_lo[0] =  interface->ctlr.dest_addr[5];
+                                                        /* fcf mac */
+        ofld_req4.dst_mac_addr_lo[1] =  interface->ctlr.dest_addr[4];
+        ofld_req4.dst_mac_addr_mid[0] =  interface->ctlr.dest_addr[3];
+        ofld_req4.dst_mac_addr_mid[1] =  interface->ctlr.dest_addr[2];
+        ofld_req4.dst_mac_addr_hi[0] =  interface->ctlr.dest_addr[1];
+        ofld_req4.dst_mac_addr_hi[1] =  interface->ctlr.dest_addr[0];
 
         ofld_req4.lcq_addr_lo = (u32) tgt->lcq_dma;
         ofld_req4.lcq_addr_hi = (u32)((u64) tgt->lcq_dma >> 32);
@@ -335,7 +350,8 @@ static int bnx2fc_send_session_enable_req(struct fcoe_port *port,
                                         struct bnx2fc_rport *tgt)
 {
         struct kwqe *kwqe_arr[2];
-        struct bnx2fc_hba *hba = port->priv;
+        struct bnx2fc_interface *interface = port->priv;
+        struct bnx2fc_hba *hba = interface->hba;
         struct fcoe_kwqe_conn_enable_disable enbl_req;
         struct fc_lport *lport = port->lport;
         struct fc_rport *rport = tgt->rport;
@@ -358,12 +374,12 @@ static int bnx2fc_send_session_enable_req(struct fcoe_port *port,
         enbl_req.src_mac_addr_hi[1] =  port->data_src_addr[0];
         memcpy(tgt->src_addr, port->data_src_addr, ETH_ALEN);
 
-        enbl_req.dst_mac_addr_lo[0] =  hba->ctlr.dest_addr[5];/* fcf mac */
-        enbl_req.dst_mac_addr_lo[1] =  hba->ctlr.dest_addr[4];
-        enbl_req.dst_mac_addr_mid[0] =  hba->ctlr.dest_addr[3];
-        enbl_req.dst_mac_addr_mid[1] =  hba->ctlr.dest_addr[2];
-        enbl_req.dst_mac_addr_hi[0] =  hba->ctlr.dest_addr[1];
-        enbl_req.dst_mac_addr_hi[1] =  hba->ctlr.dest_addr[0];
+        enbl_req.dst_mac_addr_lo[0] =  interface->ctlr.dest_addr[5];
+        enbl_req.dst_mac_addr_lo[1] =  interface->ctlr.dest_addr[4];
+        enbl_req.dst_mac_addr_mid[0] =  interface->ctlr.dest_addr[3];
+        enbl_req.dst_mac_addr_mid[1] =  interface->ctlr.dest_addr[2];
+        enbl_req.dst_mac_addr_hi[0] =  interface->ctlr.dest_addr[1];
+        enbl_req.dst_mac_addr_hi[1] =  interface->ctlr.dest_addr[0];
 
         port_id = fc_host_port_id(lport->host);
         if (port_id != tgt->sid) {
@@ -379,10 +395,10 @@ static int bnx2fc_send_session_enable_req(struct fcoe_port *port,
         enbl_req.d_id[0] = (port_id & 0x000000FF);
         enbl_req.d_id[1] = (port_id & 0x0000FF00) >> 8;
         enbl_req.d_id[2] = (port_id & 0x00FF0000) >> 16;
-        enbl_req.vlan_tag = hba->vlan_id <<
+        enbl_req.vlan_tag = interface->vlan_id <<
                                 FCOE_KWQE_CONN_ENABLE_DISABLE_VLAN_ID_SHIFT;
         enbl_req.vlan_tag |= 3 << FCOE_KWQE_CONN_ENABLE_DISABLE_PRIORITY_SHIFT;
-        enbl_req.vlan_flag = hba->vlan_enabled;
+        enbl_req.vlan_flag = interface->vlan_enabled;
         enbl_req.context_id = tgt->context_id;
         enbl_req.conn_id = tgt->fcoe_conn_id;
 
@@ -402,7 +418,8 @@ static int bnx2fc_send_session_enable_req(struct fcoe_port *port,
 int bnx2fc_send_session_disable_req(struct fcoe_port *port,
                                     struct bnx2fc_rport *tgt)
 {
-        struct bnx2fc_hba *hba = port->priv;
+        struct bnx2fc_interface *interface = port->priv;
+        struct bnx2fc_hba *hba = interface->hba;
         struct fcoe_kwqe_conn_enable_disable disable_req;
         struct kwqe *kwqe_arr[2];
         struct fc_rport *rport = tgt->rport;
@@ -423,12 +440,12 @@ int bnx2fc_send_session_disable_req(struct fcoe_port *port,
         disable_req.src_mac_addr_hi[0] =  tgt->src_addr[1];
         disable_req.src_mac_addr_hi[1] =  tgt->src_addr[0];
 
-        disable_req.dst_mac_addr_lo[0] =  hba->ctlr.dest_addr[5];/* fcf mac */
-        disable_req.dst_mac_addr_lo[1] =  hba->ctlr.dest_addr[4];
-        disable_req.dst_mac_addr_mid[0] =  hba->ctlr.dest_addr[3];
-        disable_req.dst_mac_addr_mid[1] =  hba->ctlr.dest_addr[2];
-        disable_req.dst_mac_addr_hi[0] =  hba->ctlr.dest_addr[1];
-        disable_req.dst_mac_addr_hi[1] =  hba->ctlr.dest_addr[0];
+        disable_req.dst_mac_addr_lo[0] =  interface->ctlr.dest_addr[5];
+        disable_req.dst_mac_addr_lo[1] =  interface->ctlr.dest_addr[4];
+        disable_req.dst_mac_addr_mid[0] =  interface->ctlr.dest_addr[3];
+        disable_req.dst_mac_addr_mid[1] =  interface->ctlr.dest_addr[2];
+        disable_req.dst_mac_addr_hi[0] =  interface->ctlr.dest_addr[1];
+        disable_req.dst_mac_addr_hi[1] =  interface->ctlr.dest_addr[0];
 
         port_id = tgt->sid;
         disable_req.s_id[0] = (port_id & 0x000000FF);
@@ -442,11 +459,11 @@ int bnx2fc_send_session_disable_req(struct fcoe_port *port,
         disable_req.d_id[2] = (port_id & 0x00FF0000) >> 16;
         disable_req.context_id = tgt->context_id;
         disable_req.conn_id = tgt->fcoe_conn_id;
-        disable_req.vlan_tag = hba->vlan_id <<
+        disable_req.vlan_tag = interface->vlan_id <<
                                 FCOE_KWQE_CONN_ENABLE_DISABLE_VLAN_ID_SHIFT;
         disable_req.vlan_tag |=
                         3 << FCOE_KWQE_CONN_ENABLE_DISABLE_PRIORITY_SHIFT;
-        disable_req.vlan_flag = hba->vlan_enabled;
+        disable_req.vlan_flag = interface->vlan_enabled;
 
         kwqe_arr[0] = (struct kwqe *) &disable_req;
 
@@ -525,7 +542,7 @@ void bnx2fc_process_l2_frame_compl(struct bnx2fc_rport *tgt,
 {
         struct fcoe_port *port = tgt->port;
         struct fc_lport *lport = port->lport;
-        struct bnx2fc_hba *hba = port->priv;
+        struct bnx2fc_interface *interface = port->priv;
         struct bnx2fc_unsol_els *unsol_els;
         struct fc_frame_header *fh;
         struct fc_frame *fp;
@@ -586,7 +603,7 @@ void bnx2fc_process_l2_frame_compl(struct bnx2fc_rport *tgt,
                 fr_eof(fp) = FC_EOF_T;
                 fr_crc(fp) = cpu_to_le32(~crc);
                 unsol_els->lport = lport;
-                unsol_els->hba = hba;
+                unsol_els->hba = interface->hba;
                 unsol_els->fp = fp;
                 INIT_WORK(&unsol_els->unsol_els_work, bnx2fc_unsol_els_work);
                 queue_work(bnx2fc_wq, &unsol_els->unsol_els_work);
@@ -608,9 +625,12 @@ static void bnx2fc_process_unsol_compl(struct bnx2fc_rport *tgt, u16 wqe)
         u32 frame_len, len;
         struct bnx2fc_cmd *io_req = NULL;
         struct fcoe_task_ctx_entry *task, *task_page;
-        struct bnx2fc_hba *hba = tgt->port->priv;
+        struct bnx2fc_interface *interface = tgt->port->priv;
+        struct bnx2fc_hba *hba = interface->hba;
         int task_idx, index;
         int rc = 0;
+        u64 err_warn_bit_map;
+        u8 err_warn = 0xff;
 
 
         BNX2FC_TGT_DBG(tgt, "Entered UNSOL COMPLETION wqe = 0x%x\n", wqe);
@@ -673,39 +693,43 @@ static void bnx2fc_process_unsol_compl(struct bnx2fc_rport *tgt, u16 wqe)
                 BNX2FC_TGT_DBG(tgt, "buf_offsets - tx = 0x%x, rx = 0x%x\n",
                         err_entry->data.tx_buf_off, err_entry->data.rx_buf_off);
 
-                bnx2fc_return_rqe(tgt, 1);
 
                 if (xid > BNX2FC_MAX_XID) {
                         BNX2FC_TGT_DBG(tgt, "xid(0x%x) out of FW range\n",
                                    xid);
-                        spin_unlock_bh(&tgt->tgt_lock);
-                        break;
+                        goto ret_err_rqe;
                 }
 
                 task_idx = xid / BNX2FC_TASKS_PER_PAGE;
                 index = xid % BNX2FC_TASKS_PER_PAGE;
                 task_page = (struct fcoe_task_ctx_entry *)
-                                                hba->task_ctx[task_idx];
+                                        hba->task_ctx[task_idx];
                 task = &(task_page[index]);
 
                 io_req = (struct bnx2fc_cmd *)hba->cmd_mgr->cmds[xid];
-                if (!io_req) {
-                        spin_unlock_bh(&tgt->tgt_lock);
-                        break;
-                }
+                if (!io_req)
+                        goto ret_err_rqe;
 
                 if (io_req->cmd_type != BNX2FC_SCSI_CMD) {
                         printk(KERN_ERR PFX "err_warn: Not a SCSI cmd\n");
-                        spin_unlock_bh(&tgt->tgt_lock);
-                        break;
+                        goto ret_err_rqe;
                 }
 
                 if (test_and_clear_bit(BNX2FC_FLAG_IO_CLEANUP,
                                        &io_req->req_flags)) {
                         BNX2FC_IO_DBG(io_req, "unsol_err: cleanup in "
                                             "progress.. ignore unsol err\n");
-                        spin_unlock_bh(&tgt->tgt_lock);
-                        break;
+                        goto ret_err_rqe;
+                }
+
+                err_warn_bit_map = (u64)
+                        ((u64)err_entry->data.err_warn_bitmap_hi << 32) |
+                        (u64)err_entry->data.err_warn_bitmap_lo;
+                for (i = 0; i < BNX2FC_NUM_ERR_BITS; i++) {
+                        if (err_warn_bit_map & (u64)((u64)1 << i)) {
+                                err_warn = i;
+                                break;
+                        }
                 }
 
                 /*
@@ -715,26 +739,61 @@ static void bnx2fc_process_unsol_compl(struct bnx2fc_rport *tgt, u16 wqe)
                  * logging out the target, when the ABTS eventually
                  * times out.
                  */
-                if (!test_and_set_bit(BNX2FC_FLAG_ISSUE_ABTS,
-                                      &io_req->req_flags)) {
-                        /*
-                         * Cancel the timeout_work, as we received IO
-                         * completion with FW error.
-                         */
-                        if (cancel_delayed_work(&io_req->timeout_work))
-                                kref_put(&io_req->refcount,
-                                         bnx2fc_cmd_release); /* timer hold */
-
-                        rc = bnx2fc_initiate_abts(io_req);
-                        if (rc != SUCCESS) {
-                                BNX2FC_IO_DBG(io_req, "err_warn: initiate_abts "
-                                        "failed. issue cleanup\n");
-                                rc = bnx2fc_initiate_cleanup(io_req);
-                                BUG_ON(rc);
-                        }
-                } else
+                if (test_bit(BNX2FC_FLAG_ISSUE_ABTS, &io_req->req_flags)) {
                         printk(KERN_ERR PFX "err_warn: io_req (0x%x) already "
                                             "in ABTS processing\n", xid);
+                        goto ret_err_rqe;
+                }
+                BNX2FC_TGT_DBG(tgt, "err = 0x%x\n", err_warn);
+                if (tgt->dev_type != TYPE_TAPE)
+                        goto skip_rec;
+                switch (err_warn) {
+                case FCOE_ERROR_CODE_REC_TOV_TIMER_EXPIRATION:
+                case FCOE_ERROR_CODE_DATA_OOO_RO:
+                case FCOE_ERROR_CODE_COMMON_INCORRECT_SEQ_CNT:
+                case FCOE_ERROR_CODE_DATA_SOFI3_SEQ_ACTIVE_SET:
+                case FCOE_ERROR_CODE_FCP_RSP_OPENED_SEQ:
+                case FCOE_ERROR_CODE_DATA_SOFN_SEQ_ACTIVE_RESET:
+                        BNX2FC_TGT_DBG(tgt, "REC TOV popped for xid - 0x%x\n",
+                                   xid);
+                        memset(&io_req->err_entry, 0,
+                               sizeof(struct fcoe_err_report_entry));
+                        memcpy(&io_req->err_entry, err_entry,
+                               sizeof(struct fcoe_err_report_entry));
+                        if (!test_bit(BNX2FC_FLAG_SRR_SENT,
+                                      &io_req->req_flags)) {
+                                spin_unlock_bh(&tgt->tgt_lock);
+                                rc = bnx2fc_send_rec(io_req);
+                                spin_lock_bh(&tgt->tgt_lock);
+
+                                if (rc)
+                                        goto skip_rec;
+                        } else
+                                printk(KERN_ERR PFX "SRR in progress\n");
+                        goto ret_err_rqe;
+                        break;
+                default:
+                        break;
+                }
+
+skip_rec:
+                set_bit(BNX2FC_FLAG_ISSUE_ABTS, &io_req->req_flags);
+                /*
+                 * Cancel the timeout_work, as we received IO
+                 * completion with FW error.
+                 */
+                if (cancel_delayed_work(&io_req->timeout_work))
+                        kref_put(&io_req->refcount, bnx2fc_cmd_release);
+
+                rc = bnx2fc_initiate_abts(io_req);
+                if (rc != SUCCESS) {
+                        printk(KERN_ERR PFX "err_warn: initiate_abts "
+                                "failed xid = 0x%x. issue cleanup\n",
+                                io_req->xid);
+                        bnx2fc_initiate_cleanup(io_req);
+                }
+ret_err_rqe:
+                bnx2fc_return_rqe(tgt, 1);
                 spin_unlock_bh(&tgt->tgt_lock);
                 break;
 
@@ -755,6 +814,47 @@ static void bnx2fc_process_unsol_compl(struct bnx2fc_rport *tgt, u16 wqe)
                 BNX2FC_TGT_DBG(tgt, "buf_offsets - tx = 0x%x, rx = 0x%x",
                         err_entry->data.tx_buf_off, err_entry->data.rx_buf_off);
 
+                if (xid > BNX2FC_MAX_XID) {
+                        BNX2FC_TGT_DBG(tgt, "xid(0x%x) out of FW range\n", xid);
+                        goto ret_warn_rqe;
+                }
+
+                err_warn_bit_map = (u64)
+                        ((u64)err_entry->data.err_warn_bitmap_hi << 32) |
+                        (u64)err_entry->data.err_warn_bitmap_lo;
+                for (i = 0; i < BNX2FC_NUM_ERR_BITS; i++) {
+                        if (err_warn_bit_map & (u64) (1 << i)) {
+                                err_warn = i;
+                                break;
+                        }
+                }
+                BNX2FC_TGT_DBG(tgt, "warn = 0x%x\n", err_warn);
+
+                task_idx = xid / BNX2FC_TASKS_PER_PAGE;
+                index = xid % BNX2FC_TASKS_PER_PAGE;
+                task_page = (struct fcoe_task_ctx_entry *)
+                             interface->hba->task_ctx[task_idx];
+                task = &(task_page[index]);
+                io_req = (struct bnx2fc_cmd *)hba->cmd_mgr->cmds[xid];
+                if (!io_req)
+                        goto ret_warn_rqe;
+
+                if (io_req->cmd_type != BNX2FC_SCSI_CMD) {
+                        printk(KERN_ERR PFX "err_warn: Not a SCSI cmd\n");
+                        goto ret_warn_rqe;
+                }
+
+                memset(&io_req->err_entry, 0,
+                       sizeof(struct fcoe_err_report_entry));
+                memcpy(&io_req->err_entry, err_entry,
+                       sizeof(struct fcoe_err_report_entry));
+
+                if (err_warn == FCOE_ERROR_CODE_REC_TOV_TIMER_EXPIRATION)
+                        /* REC_TOV is not a warning code */
+                        BUG_ON(1);
+                else
+                        BNX2FC_TGT_DBG(tgt, "Unsolicited warning\n");
+ret_warn_rqe:
                 bnx2fc_return_rqe(tgt, 1);
                 spin_unlock_bh(&tgt->tgt_lock);
                 break;
@@ -770,7 +870,8 @@ void bnx2fc_process_cq_compl(struct bnx2fc_rport *tgt, u16 wqe)
         struct fcoe_task_ctx_entry *task;
         struct fcoe_task_ctx_entry *task_page;
         struct fcoe_port *port = tgt->port;
-        struct bnx2fc_hba *hba = port->priv;
+        struct bnx2fc_interface *interface = port->priv;
+        struct bnx2fc_hba *hba = interface->hba;
         struct bnx2fc_cmd *io_req;
         int task_idx, index;
         u16 xid;
@@ -781,7 +882,7 @@ void bnx2fc_process_cq_compl(struct bnx2fc_rport *tgt, u16 wqe)
         spin_lock_bh(&tgt->tgt_lock);
         xid = wqe & FCOE_PEND_WQ_CQE_TASK_ID;
         if (xid >= BNX2FC_MAX_TASKS) {
-                printk(KERN_ALERT PFX "ERROR:xid out of range\n");
+                printk(KERN_ERR PFX "ERROR:xid out of range\n");
                 spin_unlock_bh(&tgt->tgt_lock);
                 return;
         }
@@ -861,6 +962,13 @@ void bnx2fc_process_cq_compl(struct bnx2fc_rport *tgt, u16 wqe)
                 kref_put(&io_req->refcount, bnx2fc_cmd_release);
                 break;
 
+        case BNX2FC_SEQ_CLEANUP:
+                BNX2FC_IO_DBG(io_req, "cq_compl(0x%x) - seq cleanup resp\n",
+                              io_req->xid);
+                bnx2fc_process_seq_cleanup_compl(io_req, task, rx_state);
+                kref_put(&io_req->refcount, bnx2fc_cmd_release);
+                break;
+
         default:
                 printk(KERN_ERR PFX "Invalid cmd_type %d\n", cmd_type);
                 break;
@@ -962,8 +1070,10 @@ unlock:
                                 1 - tgt->cq_curr_toggle_bit;
                 }
         }
-        bnx2fc_arm_cq(tgt);
-        atomic_add(num_free_sqes, &tgt->free_sqes);
+        if (num_free_sqes) {
+                bnx2fc_arm_cq(tgt);
+                atomic_add(num_free_sqes, &tgt->free_sqes);
+        }
         spin_unlock_bh(&tgt->cq_lock);
         return 0;
 }
@@ -983,7 +1093,7 @@ static void bnx2fc_fastpath_notification(struct bnx2fc_hba *hba,
         struct bnx2fc_rport *tgt = hba->tgt_ofld_list[conn_id];
 
         if (!tgt) {
-                printk(KERN_ALERT PFX "conn_id 0x%x not valid\n", conn_id);
+                printk(KERN_ERR PFX "conn_id 0x%x not valid\n", conn_id);
                 return;
         }
 
@@ -1004,6 +1114,7 @@ static void bnx2fc_process_ofld_cmpl(struct bnx2fc_hba *hba,
 {
         struct bnx2fc_rport             *tgt;
         struct fcoe_port                *port;
+        struct bnx2fc_interface         *interface;
         u32                             conn_id;
         u32                             context_id;
         int                             rc;
@@ -1018,8 +1129,9 @@ static void bnx2fc_process_ofld_cmpl(struct bnx2fc_hba *hba,
         BNX2FC_TGT_DBG(tgt, "Entered ofld compl - context_id = 0x%x\n",
                 ofld_kcqe->fcoe_conn_context_id);
         port = tgt->port;
-        if (hba != tgt->port->priv) {
-                printk(KERN_ALERT PFX "ERROR:ofld_cmpl: HBA mis-match\n");
+        interface = tgt->port->priv;
+        if (hba != interface->hba) {
+                printk(KERN_ERR PFX "ERROR:ofld_cmpl: HBA mis-match\n");
                 goto ofld_cmpl_err;
         }
         /*
@@ -1040,7 +1152,7 @@ static void bnx2fc_process_ofld_cmpl(struct bnx2fc_hba *hba,
                 /* now enable the session */
                 rc = bnx2fc_send_session_enable_req(port, tgt);
                 if (rc) {
-                        printk(KERN_ALERT PFX "enable session failed\n");
+                        printk(KERN_ERR PFX "enable session failed\n");
                         goto ofld_cmpl_err;
                 }
         }
@@ -1063,6 +1175,7 @@ static void bnx2fc_process_enable_conn_cmpl(struct bnx2fc_hba *hba,
                                                 struct fcoe_kcqe *ofld_kcqe)
 {
         struct bnx2fc_rport             *tgt;
+        struct bnx2fc_interface         *interface;
         u32                             conn_id;
         u32                             context_id;
 
@@ -1070,7 +1183,7 @@ static void bnx2fc_process_enable_conn_cmpl(struct bnx2fc_hba *hba,
         conn_id = ofld_kcqe->fcoe_conn_id;
         tgt = hba->tgt_ofld_list[conn_id];
         if (!tgt) {
-                printk(KERN_ALERT PFX "ERROR:enbl_cmpl: No pending ofld req\n");
+                printk(KERN_ERR PFX "ERROR:enbl_cmpl: No pending ofld req\n");
                 return;
         }
 
@@ -1082,16 +1195,17 @@ static void bnx2fc_process_enable_conn_cmpl(struct bnx2fc_hba *hba,
          * and enable
          */
         if (tgt->context_id != context_id) {
-                printk(KERN_ALERT PFX "context id mis-match\n");
+                printk(KERN_ERR PFX "context id mis-match\n");
                 return;
         }
-        if (hba != tgt->port->priv) {
-                printk(KERN_ALERT PFX "bnx2fc-enbl_cmpl: HBA mis-match\n");
+        interface = tgt->port->priv;
+        if (hba != interface->hba) {
+                printk(KERN_ERR PFX "bnx2fc-enbl_cmpl: HBA mis-match\n");
                 goto enbl_cmpl_err;
         }
-        if (ofld_kcqe->completion_status) {
+        if (ofld_kcqe->completion_status)
                 goto enbl_cmpl_err;
-        } else {
+        else {
                 /* enable successful - rport ready for issuing IOs */
                 set_bit(BNX2FC_FLAG_OFFLOADED, &tgt->flags);
                 set_bit(BNX2FC_FLAG_OFLD_REQ_CMPL, &tgt->flags);
@@ -1114,14 +1228,14 @@ static void bnx2fc_process_conn_disable_cmpl(struct bnx2fc_hba *hba,
         conn_id = disable_kcqe->fcoe_conn_id;
         tgt = hba->tgt_ofld_list[conn_id];
         if (!tgt) {
-                printk(KERN_ALERT PFX "ERROR: disable_cmpl: No disable req\n");
+                printk(KERN_ERR PFX "ERROR: disable_cmpl: No disable req\n");
                 return;
         }
 
         BNX2FC_TGT_DBG(tgt, PFX "disable_cmpl: conn_id %d\n", conn_id);
 
         if (disable_kcqe->completion_status) {
-                printk(KERN_ALERT PFX "ERROR: Disable failed with cmpl status %d\n",
+                printk(KERN_ERR PFX "Disable failed with cmpl status %d\n",
                         disable_kcqe->completion_status);
                 return;
         } else {
@@ -1143,14 +1257,14 @@ static void bnx2fc_process_conn_destroy_cmpl(struct bnx2fc_hba *hba,
         conn_id = destroy_kcqe->fcoe_conn_id;
         tgt = hba->tgt_ofld_list[conn_id];
         if (!tgt) {
-                printk(KERN_ALERT PFX "destroy_cmpl: No destroy req\n");
+                printk(KERN_ERR PFX "destroy_cmpl: No destroy req\n");
                 return;
         }
 
         BNX2FC_TGT_DBG(tgt, "destroy_cmpl: conn_id %d\n", conn_id);
 
         if (destroy_kcqe->completion_status) {
-                printk(KERN_ALERT PFX "Destroy conn failed, cmpl status %d\n",
+                printk(KERN_ERR PFX "Destroy conn failed, cmpl status %d\n",
                         destroy_kcqe->completion_status);
                 return;
         } else {
@@ -1182,6 +1296,7 @@ static void bnx2fc_init_failure(struct bnx2fc_hba *hba, u32 err_code)
                 break;
         case FCOE_KCQE_COMPLETION_STATUS_WRONG_HSI_VERSION:
                 printk(KERN_ERR PFX "init failure due to HSI mismatch\n");
+                break;
         default:
                 printk(KERN_ERR PFX "Unknown Error code %d\n", err_code);
         }
@@ -1240,7 +1355,7 @@ void bnx2fc_indicate_kcqe(void *context, struct kcqe *kcq[],
                         } else {
                                 printk(KERN_ERR PFX "DESTROY success\n");
                         }
-                        hba->flags |= BNX2FC_FLAG_DESTROY_CMPL;
+                        set_bit(BNX2FC_FLAG_DESTROY_CMPL, &hba->flags);
                         wake_up_interruptible(&hba->destroy_wait);
                         break;
 
@@ -1262,7 +1377,7 @@ void bnx2fc_indicate_kcqe(void *context, struct kcqe *kcq[],
                 case FCOE_KCQE_OPCODE_FCOE_ERROR:
                         /* fall thru */
                 default:
-                        printk(KERN_ALERT PFX "unknown opcode 0x%x\n",
+                        printk(KERN_ERR PFX "unknown opcode 0x%x\n",
                                                                 kcqe->op_code);
                 }
         }
@@ -1305,7 +1420,8 @@ int bnx2fc_map_doorbell(struct bnx2fc_rport *tgt)
         struct fcoe_port *port = tgt->port;
         u32 reg_off;
         resource_size_t reg_base;
-        struct bnx2fc_hba *hba = port->priv;
+        struct bnx2fc_interface *interface = port->priv;
+        struct bnx2fc_hba *hba = interface->hba;
 
         reg_base = pci_resource_start(hba->pcidev,
                                         BNX2X_DOORBELL_PCI_BAR);
@@ -1344,6 +1460,96 @@ void bnx2fc_return_rqe(struct bnx2fc_rport *tgt, u8 num_items)
         tgt->conn_db->rq_prod = tgt->rq_prod_idx;
 }
 
+void bnx2fc_init_seq_cleanup_task(struct bnx2fc_cmd *seq_clnp_req,
+                                  struct fcoe_task_ctx_entry *task,
+                                  struct bnx2fc_cmd *orig_io_req,
+                                  u32 offset)
+{
+        struct scsi_cmnd *sc_cmd = orig_io_req->sc_cmd;
+        struct bnx2fc_rport *tgt = seq_clnp_req->tgt;
+        struct bnx2fc_interface *interface = tgt->port->priv;
+        struct fcoe_bd_ctx *bd = orig_io_req->bd_tbl->bd_tbl;
+        struct fcoe_task_ctx_entry *orig_task;
+        struct fcoe_task_ctx_entry *task_page;
+        struct fcoe_ext_mul_sges_ctx *sgl;
+        u8 task_type = FCOE_TASK_TYPE_SEQUENCE_CLEANUP;
+        u8 orig_task_type;
+        u16 orig_xid = orig_io_req->xid;
+        u32 context_id = tgt->context_id;
+        u64 phys_addr = (u64)orig_io_req->bd_tbl->bd_tbl_dma;
+        u32 orig_offset = offset;
+        int bd_count;
+        int orig_task_idx, index;
+        int i;
+
+        memset(task, 0, sizeof(struct fcoe_task_ctx_entry));
+
+        if (sc_cmd->sc_data_direction == DMA_TO_DEVICE)
+                orig_task_type = FCOE_TASK_TYPE_WRITE;
+        else
+                orig_task_type = FCOE_TASK_TYPE_READ;
+
+        /* Tx flags */
+        task->txwr_rxrd.const_ctx.tx_flags =
+                                FCOE_TASK_TX_STATE_SEQUENCE_CLEANUP <<
+                                FCOE_TCE_TX_WR_RX_RD_CONST_TX_STATE_SHIFT;
+        /* init flags */
+        task->txwr_rxrd.const_ctx.init_flags = task_type <<
+                                FCOE_TCE_TX_WR_RX_RD_CONST_TASK_TYPE_SHIFT;
+        task->txwr_rxrd.const_ctx.init_flags |= FCOE_TASK_CLASS_TYPE_3 <<
+                                FCOE_TCE_TX_WR_RX_RD_CONST_CLASS_TYPE_SHIFT;
+        task->rxwr_txrd.const_ctx.init_flags = context_id <<
+                                FCOE_TCE_RX_WR_TX_RD_CONST_CID_SHIFT;
+        task->rxwr_txrd.const_ctx.init_flags = context_id <<
+                                FCOE_TCE_RX_WR_TX_RD_CONST_CID_SHIFT;
+
+        task->txwr_rxrd.union_ctx.cleanup.ctx.cleaned_task_id = orig_xid;
+
+        task->txwr_rxrd.union_ctx.cleanup.ctx.rolled_tx_seq_cnt = 0;
+        task->txwr_rxrd.union_ctx.cleanup.ctx.rolled_tx_data_offset = offset;
+
+        bd_count = orig_io_req->bd_tbl->bd_valid;
+
+        /* obtain the appropriate bd entry from relative offset */
+        for (i = 0; i < bd_count; i++) {
+                if (offset < bd[i].buf_len)
+                        break;
+                offset -= bd[i].buf_len;
+        }
+        phys_addr += (i * sizeof(struct fcoe_bd_ctx));
+
+        if (orig_task_type == FCOE_TASK_TYPE_WRITE) {
+                task->txwr_only.sgl_ctx.sgl.mul_sgl.cur_sge_addr.lo =
+                                (u32)phys_addr;
+                task->txwr_only.sgl_ctx.sgl.mul_sgl.cur_sge_addr.hi =
+                                (u32)((u64)phys_addr >> 32);
+                task->txwr_only.sgl_ctx.sgl.mul_sgl.sgl_size =
+                                bd_count;
+                task->txwr_only.sgl_ctx.sgl.mul_sgl.cur_sge_off =
+                                offset; /* adjusted offset */
+                task->txwr_only.sgl_ctx.sgl.mul_sgl.cur_sge_idx = i;
+        } else {
+                orig_task_idx = orig_xid / BNX2FC_TASKS_PER_PAGE;
+                index = orig_xid % BNX2FC_TASKS_PER_PAGE;
+
+                task_page = (struct fcoe_task_ctx_entry *)
+                             interface->hba->task_ctx[orig_task_idx];
+                orig_task = &(task_page[index]);
+
+                /* Multiple SGEs were used for this IO */
+                sgl = &task->rxwr_only.union_ctx.read_info.sgl_ctx.sgl;
+                sgl->mul_sgl.cur_sge_addr.lo = (u32)phys_addr;
+                sgl->mul_sgl.cur_sge_addr.hi = (u32)((u64)phys_addr >> 32);
+                sgl->mul_sgl.sgl_size = bd_count;
+                sgl->mul_sgl.cur_sge_off = offset; /*adjusted offset */
+                sgl->mul_sgl.cur_sge_idx = i;
+
+                memset(&task->rxwr_only.rx_seq_ctx, 0,
+                       sizeof(struct fcoe_rx_seq_ctx));
+                task->rxwr_only.rx_seq_ctx.low_exp_ro = orig_offset;
+                task->rxwr_only.rx_seq_ctx.high_exp_ro = orig_offset;
+        }
+}
 void bnx2fc_init_cleanup_task(struct bnx2fc_cmd *io_req,
                               struct fcoe_task_ctx_entry *task,
                               u16 orig_xid)
@@ -1360,7 +1566,12 @@ void bnx2fc_init_cleanup_task(struct bnx2fc_cmd *io_req,
                                 FCOE_TCE_TX_WR_RX_RD_CONST_TASK_TYPE_SHIFT;
         task->txwr_rxrd.const_ctx.init_flags |= FCOE_TASK_CLASS_TYPE_3 <<
                                 FCOE_TCE_TX_WR_RX_RD_CONST_CLASS_TYPE_SHIFT;
-        task->txwr_rxrd.const_ctx.init_flags |=
+        if (tgt->dev_type == TYPE_TAPE)
+                task->txwr_rxrd.const_ctx.init_flags |=
+                                FCOE_TASK_DEV_TYPE_TAPE <<
+                                FCOE_TCE_TX_WR_RX_RD_CONST_DEV_TYPE_SHIFT;
+        else
+                task->txwr_rxrd.const_ctx.init_flags |=
                                 FCOE_TASK_DEV_TYPE_DISK <<
                                 FCOE_TCE_TX_WR_RX_RD_CONST_DEV_TYPE_SHIFT;
         task->txwr_rxrd.union_ctx.cleanup.ctx.cleaned_task_id = orig_xid;
@@ -1420,7 +1631,12 @@ void bnx2fc_init_mp_task(struct bnx2fc_cmd *io_req,
         /* init flags */
         task->txwr_rxrd.const_ctx.init_flags = task_type <<
                                 FCOE_TCE_TX_WR_RX_RD_CONST_TASK_TYPE_SHIFT;
-        task->txwr_rxrd.const_ctx.init_flags |=
+        if (tgt->dev_type == TYPE_TAPE)
+                task->txwr_rxrd.const_ctx.init_flags |=
+                                FCOE_TASK_DEV_TYPE_TAPE <<
+                                FCOE_TCE_TX_WR_RX_RD_CONST_DEV_TYPE_SHIFT;
+        else
+                task->txwr_rxrd.const_ctx.init_flags |=
                                 FCOE_TASK_DEV_TYPE_DISK <<
                                 FCOE_TCE_TX_WR_RX_RD_CONST_DEV_TYPE_SHIFT;
         task->txwr_rxrd.const_ctx.init_flags |= FCOE_TASK_CLASS_TYPE_3 <<
@@ -1477,6 +1693,7 @@ void bnx2fc_init_task(struct bnx2fc_cmd *io_req,
         struct bnx2fc_rport *tgt = io_req->tgt;
         struct fcoe_cached_sge_ctx *cached_sge;
         struct fcoe_ext_mul_sges_ctx *sgl;
+        int dev_type = tgt->dev_type;
         u64 *fcp_cmnd;
         u64 tmp_fcp_cmnd[4];
         u32 context_id;
@@ -1494,20 +1711,40 @@ void bnx2fc_init_task(struct bnx2fc_cmd *io_req,
                 task_type = FCOE_TASK_TYPE_READ;
 
         /* Tx only */
+        bd_count = bd_tbl->bd_valid;
         if (task_type == FCOE_TASK_TYPE_WRITE) {
-                task->txwr_only.sgl_ctx.sgl.mul_sgl.cur_sge_addr.lo =
-                                (u32)bd_tbl->bd_tbl_dma;
-                task->txwr_only.sgl_ctx.sgl.mul_sgl.cur_sge_addr.hi =
-                                (u32)((u64)bd_tbl->bd_tbl_dma >> 32);
-                task->txwr_only.sgl_ctx.sgl.mul_sgl.sgl_size =
-                                bd_tbl->bd_valid;
+                if ((dev_type == TYPE_DISK) && (bd_count == 1)) {
+                        struct fcoe_bd_ctx *fcoe_bd_tbl = bd_tbl->bd_tbl;
+
+                        task->txwr_only.sgl_ctx.cached_sge.cur_buf_addr.lo =
+                                        fcoe_bd_tbl->buf_addr_lo;
+                        task->txwr_only.sgl_ctx.cached_sge.cur_buf_addr.hi =
+                                        fcoe_bd_tbl->buf_addr_hi;
+                        task->txwr_only.sgl_ctx.cached_sge.cur_buf_rem =
+                                        fcoe_bd_tbl->buf_len;
+
+                        task->txwr_rxrd.const_ctx.init_flags |= 1 <<
+                                FCOE_TCE_TX_WR_RX_RD_CONST_CACHED_SGE_SHIFT;
+                } else {
+                        task->txwr_only.sgl_ctx.sgl.mul_sgl.cur_sge_addr.lo =
+                                        (u32)bd_tbl->bd_tbl_dma;
+                        task->txwr_only.sgl_ctx.sgl.mul_sgl.cur_sge_addr.hi =
+                                        (u32)((u64)bd_tbl->bd_tbl_dma >> 32);
+                        task->txwr_only.sgl_ctx.sgl.mul_sgl.sgl_size =
+                                        bd_tbl->bd_valid;
+                }
         }
 
         /*Tx Write Rx Read */
         /* Init state to NORMAL */
-        task->txwr_rxrd.const_ctx.init_flags = task_type <<
+        task->txwr_rxrd.const_ctx.init_flags |= task_type <<
                                 FCOE_TCE_TX_WR_RX_RD_CONST_TASK_TYPE_SHIFT;
-        task->txwr_rxrd.const_ctx.init_flags |=
+        if (dev_type == TYPE_TAPE)
+                task->txwr_rxrd.const_ctx.init_flags |=
+                                FCOE_TASK_DEV_TYPE_TAPE <<
+                                FCOE_TCE_TX_WR_RX_RD_CONST_DEV_TYPE_SHIFT;
+        else
+                task->txwr_rxrd.const_ctx.init_flags |=
                                 FCOE_TASK_DEV_TYPE_DISK <<
                                 FCOE_TCE_TX_WR_RX_RD_CONST_DEV_TYPE_SHIFT;
         task->txwr_rxrd.const_ctx.init_flags |= FCOE_TASK_CLASS_TYPE_3 <<
@@ -1550,7 +1787,8 @@ void bnx2fc_init_task(struct bnx2fc_cmd *io_req,
         cached_sge = &task->rxwr_only.union_ctx.read_info.sgl_ctx.cached_sge;
         sgl = &task->rxwr_only.union_ctx.read_info.sgl_ctx.sgl;
         bd_count = bd_tbl->bd_valid;
-        if (task_type == FCOE_TASK_TYPE_READ) {
+        if (task_type == FCOE_TASK_TYPE_READ &&
+            dev_type == TYPE_DISK) {
                 if (bd_count == 1) {
 
                         struct fcoe_bd_ctx *fcoe_bd_tbl = bd_tbl->bd_tbl;
@@ -1582,6 +1820,11 @@ void bnx2fc_init_task(struct bnx2fc_cmd *io_req,
                                         (u32)((u64)bd_tbl->bd_tbl_dma >> 32);
                         sgl->mul_sgl.sgl_size = bd_count;
                 }
+        } else {
+                sgl->mul_sgl.cur_sge_addr.lo = (u32)bd_tbl->bd_tbl_dma;
+                sgl->mul_sgl.cur_sge_addr.hi =
+                                (u32)((u64)bd_tbl->bd_tbl_dma >> 32);
+                sgl->mul_sgl.sgl_size = bd_count;
         }
 }
 
diff --git a/drivers/scsi/bnx2fc/bnx2fc_io.c b/drivers/scsi/bnx2fc/bnx2fc_io.c
index 45eba6d609c9..6cc3789075bc 100644
--- a/drivers/scsi/bnx2fc/bnx2fc_io.c
+++ b/drivers/scsi/bnx2fc/bnx2fc_io.c
@@ -1,7 +1,7 @@
 /* bnx2fc_io.c: Broadcom NetXtreme II Linux FCoE offload driver.
  * IO manager and SCSI IO processing.
  *
- * Copyright (c) 2008 - 2010 Broadcom Corporation
+ * Copyright (c) 2008 - 2011 Broadcom Corporation
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -18,8 +18,6 @@ static int bnx2fc_split_bd(struct bnx2fc_cmd *io_req, u64 addr, int sg_len,
                            int bd_index);
 static int bnx2fc_map_sg(struct bnx2fc_cmd *io_req);
 static void bnx2fc_build_bd_list_from_sg(struct bnx2fc_cmd *io_req);
-static int bnx2fc_post_io_req(struct bnx2fc_rport *tgt,
-                               struct bnx2fc_cmd *io_req);
 static void bnx2fc_unmap_sg_list(struct bnx2fc_cmd *io_req);
 static void bnx2fc_free_mp_resc(struct bnx2fc_cmd *io_req);
 static void bnx2fc_parse_fcp_rsp(struct bnx2fc_cmd *io_req,
@@ -29,10 +27,11 @@ static void bnx2fc_parse_fcp_rsp(struct bnx2fc_cmd *io_req,
 void bnx2fc_cmd_timer_set(struct bnx2fc_cmd *io_req,
                           unsigned int timer_msec)
 {
-        struct bnx2fc_hba *hba = io_req->port->priv;
+        struct bnx2fc_interface *interface = io_req->port->priv;
 
-        if (queue_delayed_work(hba->timer_work_queue, &io_req->timeout_work,
-                                  msecs_to_jiffies(timer_msec)))
+        if (queue_delayed_work(interface->timer_work_queue,
+                               &io_req->timeout_work,
+                               msecs_to_jiffies(timer_msec)))
                 kref_get(&io_req->refcount);
 }
 
@@ -217,6 +216,11 @@ static void bnx2fc_scsi_done(struct bnx2fc_cmd *io_req, int err_code)
                 return;
 
         BNX2FC_IO_DBG(io_req, "scsi_done. err_code = 0x%x\n", err_code);
+        if (test_bit(BNX2FC_FLAG_CMD_LOST, &io_req->req_flags)) {
+                /* Do not call scsi done for this IO */
+                return;
+        }
+
         bnx2fc_unmap_sg_list(io_req);
         io_req->sc_cmd = NULL;
         if (!sc_cmd) {
@@ -419,8 +423,8 @@ free_cmgr:
 struct bnx2fc_cmd *bnx2fc_elstm_alloc(struct bnx2fc_rport *tgt, int type)
 {
         struct fcoe_port *port = tgt->port;
-        struct bnx2fc_hba *hba = port->priv;
-        struct bnx2fc_cmd_mgr *cmd_mgr = hba->cmd_mgr;
+        struct bnx2fc_interface *interface = port->priv;
+        struct bnx2fc_cmd_mgr *cmd_mgr = interface->hba->cmd_mgr;
         struct bnx2fc_cmd *io_req;
         struct list_head *listp;
         struct io_bdt *bd_tbl;
@@ -485,11 +489,12 @@ struct bnx2fc_cmd *bnx2fc_elstm_alloc(struct bnx2fc_rport *tgt, int type)
         kref_init(&io_req->refcount);
         return io_req;
 }
-static struct bnx2fc_cmd *bnx2fc_cmd_alloc(struct bnx2fc_rport *tgt)
+
+struct bnx2fc_cmd *bnx2fc_cmd_alloc(struct bnx2fc_rport *tgt)
 {
         struct fcoe_port *port = tgt->port;
-        struct bnx2fc_hba *hba = port->priv;
-        struct bnx2fc_cmd_mgr *cmd_mgr = hba->cmd_mgr;
+        struct bnx2fc_interface *interface = port->priv;
+        struct bnx2fc_cmd_mgr *cmd_mgr = interface->hba->cmd_mgr;
         struct bnx2fc_cmd *io_req;
         struct list_head *listp;
         struct io_bdt *bd_tbl;
@@ -570,7 +575,8 @@ void bnx2fc_cmd_release(struct kref *ref)
 static void bnx2fc_free_mp_resc(struct bnx2fc_cmd *io_req)
 {
         struct bnx2fc_mp_req *mp_req = &(io_req->mp_req);
-        struct bnx2fc_hba *hba = io_req->port->priv;
+        struct bnx2fc_interface *interface = io_req->port->priv;
+        struct bnx2fc_hba *hba = interface->hba;
         size_t sz = sizeof(struct fcoe_bd_ctx);
 
         /* clear tm flags */
@@ -606,7 +612,8 @@ int bnx2fc_init_mp_req(struct bnx2fc_cmd *io_req)
         struct bnx2fc_mp_req *mp_req;
         struct fcoe_bd_ctx *mp_req_bd;
         struct fcoe_bd_ctx *mp_resp_bd;
-        struct bnx2fc_hba *hba = io_req->port->priv;
+        struct bnx2fc_interface *interface = io_req->port->priv;
+        struct bnx2fc_hba *hba = interface->hba;
         dma_addr_t addr;
         size_t sz;
 
@@ -682,7 +689,7 @@ static int bnx2fc_initiate_tmf(struct scsi_cmnd *sc_cmd, u8 tm_flags)
         struct fc_rport *rport = starget_to_rport(scsi_target(sc_cmd->device));
         struct fc_rport_libfc_priv *rp = rport->dd_data;
         struct fcoe_port *port;
-        struct bnx2fc_hba *hba;
+        struct bnx2fc_interface *interface;
         struct bnx2fc_rport *tgt;
         struct bnx2fc_cmd *io_req;
         struct bnx2fc_mp_req *tm_req;
@@ -699,10 +706,10 @@ static int bnx2fc_initiate_tmf(struct scsi_cmnd *sc_cmd, u8 tm_flags)
 
         lport = shost_priv(host);
         port = lport_priv(lport);
-        hba = port->priv;
+        interface = port->priv;
 
         if (rport == NULL) {
-                printk(KERN_ALERT PFX "device_reset: rport is NULL\n");
+                printk(KERN_ERR PFX "device_reset: rport is NULL\n");
                 rc = FAILED;
                 goto tmf_err;
         }
@@ -745,7 +752,9 @@ retry_tmf:
         rc = bnx2fc_init_mp_req(io_req);
         if (rc == FAILED) {
                 printk(KERN_ERR PFX "Task mgmt MP request init failed\n");
+                spin_lock_bh(&tgt->tgt_lock);
                 kref_put(&io_req->refcount, bnx2fc_cmd_release);
+                spin_unlock_bh(&tgt->tgt_lock);
                 goto tmf_err;
         }
 
@@ -774,7 +783,8 @@ retry_tmf:
         index = xid % BNX2FC_TASKS_PER_PAGE;
 
         /* Initialize task context for this IO request */
-        task_page = (struct fcoe_task_ctx_entry *) hba->task_ctx[task_idx];
+        task_page = (struct fcoe_task_ctx_entry *)
+                        interface->hba->task_ctx[task_idx];
         task = &(task_page[index]);
         bnx2fc_init_mp_task(io_req, task);
 
@@ -806,10 +816,10 @@ retry_tmf:
         spin_unlock_bh(&tgt->tgt_lock);
 
         if (!rc) {
-                printk(KERN_ERR PFX "task mgmt command failed...\n");
+                BNX2FC_TGT_DBG(tgt, "task mgmt command failed...\n");
                 rc = FAILED;
         } else {
-                printk(KERN_ERR PFX "task mgmt command success...\n");
+                BNX2FC_TGT_DBG(tgt, "task mgmt command success...\n");
                 rc = SUCCESS;
         }
 tmf_err:
@@ -822,7 +832,7 @@ int bnx2fc_initiate_abts(struct bnx2fc_cmd *io_req)
         struct bnx2fc_rport *tgt = io_req->tgt;
         struct fc_rport *rport = tgt->rport;
         struct fc_rport_priv *rdata = tgt->rdata;
-        struct bnx2fc_hba *hba;
+        struct bnx2fc_interface *interface;
         struct fcoe_port *port;
         struct bnx2fc_cmd *abts_io_req;
         struct fcoe_task_ctx_entry *task;
@@ -839,7 +849,7 @@ int bnx2fc_initiate_abts(struct bnx2fc_cmd *io_req)
         BNX2FC_IO_DBG(io_req, "Entered bnx2fc_initiate_abts\n");
 
         port = io_req->port;
-        hba = port->priv;
+        interface = port->priv;
         lport = port->lport;
 
         if (!test_bit(BNX2FC_FLAG_SESSION_READY, &tgt->flags)) {
@@ -849,7 +859,7 @@ int bnx2fc_initiate_abts(struct bnx2fc_cmd *io_req)
         }
 
         if (rport == NULL) {
-                printk(KERN_ALERT PFX "initiate_abts: rport is NULL\n");
+                printk(KERN_ERR PFX "initiate_abts: rport is NULL\n");
                 rc = FAILED;
                 goto abts_err;
         }
@@ -896,7 +906,8 @@ int bnx2fc_initiate_abts(struct bnx2fc_cmd *io_req)
         index = xid % BNX2FC_TASKS_PER_PAGE;
 
         /* Initialize task context for this IO request */
-        task_page = (struct fcoe_task_ctx_entry *) hba->task_ctx[task_idx];
+        task_page = (struct fcoe_task_ctx_entry *)
+                        interface->hba->task_ctx[task_idx];
         task = &(task_page[index]);
         bnx2fc_init_mp_task(abts_io_req, task);
 
@@ -924,11 +935,81 @@ abts_err:
         return rc;
 }
 
+int bnx2fc_initiate_seq_cleanup(struct bnx2fc_cmd *orig_io_req, u32 offset,
+                                enum fc_rctl r_ctl)
+{
+        struct fc_lport *lport;
+        struct bnx2fc_rport *tgt = orig_io_req->tgt;
+        struct bnx2fc_interface *interface;
+        struct fcoe_port *port;
+        struct bnx2fc_cmd *seq_clnp_req;
+        struct fcoe_task_ctx_entry *task;
+        struct fcoe_task_ctx_entry *task_page;
+        struct bnx2fc_els_cb_arg *cb_arg = NULL;
+        int task_idx, index;
+        u16 xid;
+        int rc = 0;
+
+        BNX2FC_IO_DBG(orig_io_req, "bnx2fc_initiate_seq_cleanup xid = 0x%x\n",
+                   orig_io_req->xid);
+        kref_get(&orig_io_req->refcount);
+
+        port = orig_io_req->port;
+        interface = port->priv;
+        lport = port->lport;
+
+        cb_arg = kzalloc(sizeof(struct bnx2fc_els_cb_arg), GFP_ATOMIC);
+        if (!cb_arg) {
+                printk(KERN_ERR PFX "Unable to alloc cb_arg for seq clnup\n");
+                rc = -ENOMEM;
+                goto cleanup_err;
+        }
+
+        seq_clnp_req = bnx2fc_elstm_alloc(tgt, BNX2FC_SEQ_CLEANUP);
+        if (!seq_clnp_req) {
+                printk(KERN_ERR PFX "cleanup: couldnt allocate cmd\n");
+                rc = -ENOMEM;
+                kfree(cb_arg);
+                goto cleanup_err;
+        }
+        /* Initialize rest of io_req fields */
+        seq_clnp_req->sc_cmd = NULL;
+        seq_clnp_req->port = port;
+        seq_clnp_req->tgt = tgt;
+        seq_clnp_req->data_xfer_len = 0; /* No data transfer for cleanup */
+
+        xid = seq_clnp_req->xid;
+
+        task_idx = xid/BNX2FC_TASKS_PER_PAGE;
+        index = xid % BNX2FC_TASKS_PER_PAGE;
+
+        /* Initialize task context for this IO request */
+        task_page = (struct fcoe_task_ctx_entry *)
+                     interface->hba->task_ctx[task_idx];
+        task = &(task_page[index]);
+        cb_arg->aborted_io_req = orig_io_req;
+        cb_arg->io_req = seq_clnp_req;
+        cb_arg->r_ctl = r_ctl;
+        cb_arg->offset = offset;
+        seq_clnp_req->cb_arg = cb_arg;
+
+        printk(KERN_ERR PFX "call init_seq_cleanup_task\n");
+        bnx2fc_init_seq_cleanup_task(seq_clnp_req, task, orig_io_req, offset);
+
+        /* Obtain free SQ entry */
+        bnx2fc_add_2_sq(tgt, xid);
+
+        /* Ring doorbell */
+        bnx2fc_ring_doorbell(tgt);
+cleanup_err:
+        return rc;
+}
+
 int bnx2fc_initiate_cleanup(struct bnx2fc_cmd *io_req)
 {
         struct fc_lport *lport;
         struct bnx2fc_rport *tgt = io_req->tgt;
-        struct bnx2fc_hba *hba;
+        struct bnx2fc_interface *interface;
         struct fcoe_port *port;
         struct bnx2fc_cmd *cleanup_io_req;
         struct fcoe_task_ctx_entry *task;
@@ -941,7 +1022,7 @@ int bnx2fc_initiate_cleanup(struct bnx2fc_cmd *io_req)
         BNX2FC_IO_DBG(io_req, "Entered bnx2fc_initiate_cleanup\n");
 
         port = io_req->port;
-        hba = port->priv;
+        interface = port->priv;
         lport = port->lport;
 
         cleanup_io_req = bnx2fc_elstm_alloc(tgt, BNX2FC_CLEANUP);
@@ -963,7 +1044,8 @@ int bnx2fc_initiate_cleanup(struct bnx2fc_cmd *io_req)
         index = xid % BNX2FC_TASKS_PER_PAGE;
 
         /* Initialize task context for this IO request */
-        task_page = (struct fcoe_task_ctx_entry *) hba->task_ctx[task_idx];
+        task_page = (struct fcoe_task_ctx_entry *)
+                        interface->hba->task_ctx[task_idx];
         task = &(task_page[index]);
         orig_xid = io_req->xid;
 
@@ -1031,7 +1113,7 @@ int bnx2fc_eh_abort(struct scsi_cmnd *sc_cmd)
 
         lport = shost_priv(sc_cmd->device->host);
         if ((lport->state != LPORT_ST_READY) || !(lport->link_up)) {
-                printk(KERN_ALERT PFX "eh_abort: link not ready\n");
+                printk(KERN_ERR PFX "eh_abort: link not ready\n");
                 return rc;
         }
 
@@ -1062,7 +1144,7 @@ int bnx2fc_eh_abort(struct scsi_cmnd *sc_cmd)
          * io_req is no longer in the active_q.
          */
         if (tgt->flush_in_prog) {
-                printk(KERN_ALERT PFX "eh_abort: io_req (xid = 0x%x) "
+                printk(KERN_ERR PFX "eh_abort: io_req (xid = 0x%x) "
                         "flush in progress\n", io_req->xid);
                 kref_put(&io_req->refcount, bnx2fc_cmd_release);
                 spin_unlock_bh(&tgt->tgt_lock);
@@ -1070,7 +1152,7 @@ int bnx2fc_eh_abort(struct scsi_cmnd *sc_cmd)
         }
 
         if (io_req->on_active_queue == 0) {
-                printk(KERN_ALERT PFX "eh_abort: io_req (xid = 0x%x) "
+                printk(KERN_ERR PFX "eh_abort: io_req (xid = 0x%x) "
                                 "not on active_q\n", io_req->xid);
                 /*
                  * This condition can happen only due to the FW bug,
@@ -1108,7 +1190,7 @@ int bnx2fc_eh_abort(struct scsi_cmnd *sc_cmd)
                 set_bit(BNX2FC_FLAG_EH_ABORT, &io_req->req_flags);
                 rc = bnx2fc_initiate_abts(io_req);
         } else {
-                printk(KERN_ALERT PFX "eh_abort: io_req (xid = 0x%x) "
+                printk(KERN_ERR PFX "eh_abort: io_req (xid = 0x%x) "
                                 "already in abts processing\n", io_req->xid);
                 kref_put(&io_req->refcount, bnx2fc_cmd_release);
                 spin_unlock_bh(&tgt->tgt_lock);
@@ -1149,6 +1231,42 @@ int bnx2fc_eh_abort(struct scsi_cmnd *sc_cmd)
         return rc;
 }
 
+void bnx2fc_process_seq_cleanup_compl(struct bnx2fc_cmd *seq_clnp_req,
+                                      struct fcoe_task_ctx_entry *task,
+                                      u8 rx_state)
+{
+        struct bnx2fc_els_cb_arg *cb_arg = seq_clnp_req->cb_arg;
+        struct bnx2fc_cmd *orig_io_req = cb_arg->aborted_io_req;
+        u32 offset = cb_arg->offset;
+        enum fc_rctl r_ctl = cb_arg->r_ctl;
+        int rc = 0;
+        struct bnx2fc_rport *tgt = orig_io_req->tgt;
+
+        BNX2FC_IO_DBG(orig_io_req, "Entered process_cleanup_compl xid = 0x%x"
+                              "cmd_type = %d\n",
+                   seq_clnp_req->xid, seq_clnp_req->cmd_type);
+
+        if (rx_state == FCOE_TASK_RX_STATE_IGNORED_SEQUENCE_CLEANUP) {
+                printk(KERN_ERR PFX "seq cleanup ignored - xid = 0x%x\n",
+                        seq_clnp_req->xid);
+                goto free_cb_arg;
+        }
+        kref_get(&orig_io_req->refcount);
+
+        spin_unlock_bh(&tgt->tgt_lock);
+        rc = bnx2fc_send_srr(orig_io_req, offset, r_ctl);
+        spin_lock_bh(&tgt->tgt_lock);
+
+        if (rc)
+                printk(KERN_ERR PFX "clnup_compl: Unable to send SRR"
+                        " IO will abort\n");
+        seq_clnp_req->cb_arg = NULL;
+        kref_put(&orig_io_req->refcount, bnx2fc_cmd_release);
+free_cb_arg:
+        kfree(cb_arg);
+        return;
+}
+
 void bnx2fc_process_cleanup_compl(struct bnx2fc_cmd *io_req,
                                   struct fcoe_task_ctx_entry *task,
                                   u8 num_rq)
@@ -1378,7 +1496,7 @@ void bnx2fc_process_tm_compl(struct bnx2fc_cmd *io_req,
                         fc_hdr->fh_r_ctl);
         }
         if (!sc_cmd->SCp.ptr) {
-                printk(KERN_ALERT PFX "tm_compl: SCp.ptr is NULL\n");
+                printk(KERN_ERR PFX "tm_compl: SCp.ptr is NULL\n");
                 return;
         }
         switch (io_req->fcp_status) {
@@ -1410,7 +1528,7 @@ void bnx2fc_process_tm_compl(struct bnx2fc_cmd *io_req,
                 io_req->on_tmf_queue = 0;
         } else {
 
-                printk(KERN_ALERT PFX "Command not on active_cmd_queue!\n");
+                printk(KERN_ERR PFX "Command not on active_cmd_queue!\n");
                 return;
         }
 
@@ -1597,7 +1715,7 @@ static void bnx2fc_parse_fcp_rsp(struct bnx2fc_cmd *io_req,
 
                 if (rq_buff_len > num_rq * BNX2FC_RQ_BUF_SZ) {
                         /* Invalid sense sense length. */
-                        printk(KERN_ALERT PFX "invalid sns length %d\n",
+                        printk(KERN_ERR PFX "invalid sns length %d\n",
                                 rq_buff_len);
                         /* reset rq_buff_len */
                         rq_buff_len =  num_rq * BNX2FC_RQ_BUF_SZ;
@@ -1780,7 +1898,7 @@ void bnx2fc_process_scsi_cmd_compl(struct bnx2fc_cmd *io_req,
                         scsi_set_resid(sc_cmd, io_req->fcp_resid);
                 break;
         default:
-                printk(KERN_ALERT PFX "scsi_cmd_compl: fcp_status = %d\n",
+                printk(KERN_ERR PFX "scsi_cmd_compl: fcp_status = %d\n",
                         io_req->fcp_status);
                 break;
         }
@@ -1789,14 +1907,15 @@ void bnx2fc_process_scsi_cmd_compl(struct bnx2fc_cmd *io_req,
         kref_put(&io_req->refcount, bnx2fc_cmd_release);
 }
 
-static int bnx2fc_post_io_req(struct bnx2fc_rport *tgt,
+int bnx2fc_post_io_req(struct bnx2fc_rport *tgt,
                                struct bnx2fc_cmd *io_req)
 {
         struct fcoe_task_ctx_entry *task;
         struct fcoe_task_ctx_entry *task_page;
         struct scsi_cmnd *sc_cmd = io_req->sc_cmd;
         struct fcoe_port *port = tgt->port;
-        struct bnx2fc_hba *hba = port->priv;
+        struct bnx2fc_interface *interface = port->priv;
+        struct bnx2fc_hba *hba = interface->hba;
         struct fc_lport *lport = port->lport;
         struct fcoe_dev_stats *stats;
         int task_idx, index;
@@ -1854,7 +1973,8 @@ static int bnx2fc_post_io_req(struct bnx2fc_rport *tgt,
         }
 
         /* Time IO req */
-        bnx2fc_cmd_timer_set(io_req, BNX2FC_IO_TIMEOUT);
+        if (tgt->io_timeout)
+                bnx2fc_cmd_timer_set(io_req, BNX2FC_IO_TIMEOUT);
         /* Obtain free SQ entry */
         bnx2fc_add_2_sq(tgt, xid);
 
diff --git a/drivers/scsi/bnx2fc/bnx2fc_tgt.c b/drivers/scsi/bnx2fc/bnx2fc_tgt.c
index 3e892bd66fbe..d5311b577cca 100644
--- a/drivers/scsi/bnx2fc/bnx2fc_tgt.c
+++ b/drivers/scsi/bnx2fc/bnx2fc_tgt.c
@@ -2,7 +2,7 @@
  * Handles operations such as session offload/upload etc, and manages
  * session resources such as connection id and qp resources.
  *
- * Copyright (c) 2008 - 2010 Broadcom Corporation
+ * Copyright (c) 2008 - 2011 Broadcom Corporation
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -65,7 +65,8 @@ static void bnx2fc_offload_session(struct fcoe_port *port,
 {
         struct fc_lport *lport = rdata->local_port;
         struct fc_rport *rport = rdata->rport;
-        struct bnx2fc_hba *hba = port->priv;
+        struct bnx2fc_interface *interface = port->priv;
+        struct bnx2fc_hba *hba = interface->hba;
         int rval;
         int i = 0;
 
@@ -237,7 +238,8 @@ void bnx2fc_flush_active_ios(struct bnx2fc_rport *tgt)
 static void bnx2fc_upload_session(struct fcoe_port *port,
                                         struct bnx2fc_rport *tgt)
 {
-        struct bnx2fc_hba *hba = port->priv;
+        struct bnx2fc_interface *interface = port->priv;
+        struct bnx2fc_hba *hba = interface->hba;
 
         BNX2FC_TGT_DBG(tgt, "upload_session: active_ios = %d\n",
                 tgt->num_active_ios.counter);
@@ -316,7 +318,8 @@ static int bnx2fc_init_tgt(struct bnx2fc_rport *tgt,
 {
 
         struct fc_rport *rport = rdata->rport;
-        struct bnx2fc_hba *hba = port->priv;
+        struct bnx2fc_interface *interface = port->priv;
+        struct bnx2fc_hba *hba = interface->hba;
         struct b577xx_doorbell_set_prod *sq_db = &tgt->sq_db;
         struct b577xx_fcoe_rx_doorbell *rx_db = &tgt->rx_db;
 
@@ -350,6 +353,14 @@ static int bnx2fc_init_tgt(struct bnx2fc_rport *tgt,
         tgt->rq_cons_idx = 0;
         atomic_set(&tgt->num_active_ios, 0);
 
+        if (rdata->flags & FC_RP_FLAGS_RETRY) {
+                tgt->dev_type = TYPE_TAPE;
+                tgt->io_timeout = 0; /* use default ULP timeout */
+        } else {
+                tgt->dev_type = TYPE_DISK;
+                tgt->io_timeout = BNX2FC_IO_TIMEOUT;
+        }
+
         /* initialize sq doorbell */
         sq_db->header.header = B577XX_DOORBELL_HDR_DB_TYPE;
         sq_db->header.header |= B577XX_FCOE_CONNECTION_TYPE <<
@@ -392,7 +403,8 @@ void bnx2fc_rport_event_handler(struct fc_lport *lport,
                                 enum fc_rport_event event)
 {
         struct fcoe_port *port = lport_priv(lport);
-        struct bnx2fc_hba *hba = port->priv;
+        struct bnx2fc_interface *interface = port->priv;
+        struct bnx2fc_hba *hba = interface->hba;
         struct fc_rport *rport = rdata->rport;
         struct fc_rport_libfc_priv *rp;
         struct bnx2fc_rport *tgt;
@@ -403,7 +415,7 @@ void bnx2fc_rport_event_handler(struct fc_lport *lport,
         switch (event) {
         case RPORT_EV_READY:
                 if (!rport) {
-                        printk(KERN_ALERT PFX "rport is NULL: ERROR!\n");
+                        printk(KERN_ERR PFX "rport is NULL: ERROR!\n");
                         break;
                 }
 
@@ -415,7 +427,7 @@ void bnx2fc_rport_event_handler(struct fc_lport *lport,
                          * We should not come here, as lport will
                          * take care of fabric login
                          */
-                        printk(KERN_ALERT PFX "%x - rport_event_handler ERROR\n",
+                        printk(KERN_ERR PFX "%x - rport_event_handler ERROR\n",
                                 rdata->ids.port_id);
                         break;
                 }
@@ -483,7 +495,7 @@ void bnx2fc_rport_event_handler(struct fc_lport *lport,
                         break;
 
                 if (!rport) {
-                        printk(KERN_ALERT PFX "%x - rport not created Yet!!\n",
+                        printk(KERN_INFO PFX "%x - rport not created Yet!!\n",
                                 port_id);
                         break;
                 }
@@ -537,7 +549,8 @@ void bnx2fc_rport_event_handler(struct fc_lport *lport,
 struct bnx2fc_rport *bnx2fc_tgt_lookup(struct fcoe_port *port,
                                              u32 port_id)
 {
-        struct bnx2fc_hba *hba = port->priv;
+        struct bnx2fc_interface *interface = port->priv;
+        struct bnx2fc_hba *hba = interface->hba;
         struct bnx2fc_rport *tgt;
         struct fc_rport_priv *rdata;
         int i;
@@ -552,7 +565,7 @@ struct bnx2fc_rport *bnx2fc_tgt_lookup(struct fcoe_port *port,
                                                 "obtained\n");
                                         return tgt;
                                 } else {
-                                        printk(KERN_ERR PFX "rport 0x%x "
+                                        BNX2FC_TGT_DBG(tgt, "rport 0x%x "
                                                 "is in DELETED state\n",
                                                 rdata->ids.port_id);
                                         return NULL;
@@ -633,7 +646,7 @@ static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba,
         tgt->sq = dma_alloc_coherent(&hba->pcidev->dev, tgt->sq_mem_size,
                                      &tgt->sq_dma, GFP_KERNEL);
         if (!tgt->sq) {
-                printk(KERN_ALERT PFX "unable to allocate SQ memory %d\n",
+                printk(KERN_ERR PFX "unable to allocate SQ memory %d\n",
                         tgt->sq_mem_size);
                 goto mem_alloc_failure;
         }
@@ -646,7 +659,7 @@ static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba,
         tgt->cq = dma_alloc_coherent(&hba->pcidev->dev, tgt->cq_mem_size,
                                      &tgt->cq_dma, GFP_KERNEL);
         if (!tgt->cq) {
-                printk(KERN_ALERT PFX "unable to allocate CQ memory %d\n",
+                printk(KERN_ERR PFX "unable to allocate CQ memory %d\n",
                         tgt->cq_mem_size);
                 goto mem_alloc_failure;
         }
@@ -659,7 +672,7 @@ static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba,
         tgt->rq = dma_alloc_coherent(&hba->pcidev->dev, tgt->rq_mem_size,
                                         &tgt->rq_dma, GFP_KERNEL);
         if (!tgt->rq) {
-                printk(KERN_ALERT PFX "unable to allocate RQ memory %d\n",
+                printk(KERN_ERR PFX "unable to allocate RQ memory %d\n",
                         tgt->rq_mem_size);
                 goto mem_alloc_failure;
         }
@@ -671,7 +684,7 @@ static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba,
         tgt->rq_pbl = dma_alloc_coherent(&hba->pcidev->dev, tgt->rq_pbl_size,
                                          &tgt->rq_pbl_dma, GFP_KERNEL);
         if (!tgt->rq_pbl) {
-                printk(KERN_ALERT PFX "unable to allocate RQ PBL %d\n",
+                printk(KERN_ERR PFX "unable to allocate RQ PBL %d\n",
                         tgt->rq_pbl_size);
                 goto mem_alloc_failure;
         }
@@ -697,7 +710,7 @@ static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba,
         tgt->xferq = dma_alloc_coherent(&hba->pcidev->dev, tgt->xferq_mem_size,
                                         &tgt->xferq_dma, GFP_KERNEL);
         if (!tgt->xferq) {
-                printk(KERN_ALERT PFX "unable to allocate XFERQ %d\n",
+                printk(KERN_ERR PFX "unable to allocate XFERQ %d\n",
                         tgt->xferq_mem_size);
                 goto mem_alloc_failure;
         }
@@ -711,7 +724,7 @@ static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba,
         tgt->confq = dma_alloc_coherent(&hba->pcidev->dev, tgt->confq_mem_size,
                                         &tgt->confq_dma, GFP_KERNEL);
         if (!tgt->confq) {
-                printk(KERN_ALERT PFX "unable to allocate CONFQ %d\n",
+                printk(KERN_ERR PFX "unable to allocate CONFQ %d\n",
                         tgt->confq_mem_size);
                 goto mem_alloc_failure;
         }
@@ -726,7 +739,7 @@ static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba,
                                             tgt->confq_pbl_size,
                                             &tgt->confq_pbl_dma, GFP_KERNEL);
         if (!tgt->confq_pbl) {
-                printk(KERN_ALERT PFX "unable to allocate CONFQ PBL %d\n",
+                printk(KERN_ERR PFX "unable to allocate CONFQ PBL %d\n",
                         tgt->confq_pbl_size);
                 goto mem_alloc_failure;
         }
@@ -751,7 +764,7 @@ static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba,
                                           tgt->conn_db_mem_size,
                                           &tgt->conn_db_dma, GFP_KERNEL);
         if (!tgt->conn_db) {
-                printk(KERN_ALERT PFX "unable to allocate conn_db %d\n",
+                printk(KERN_ERR PFX "unable to allocate conn_db %d\n",
                                                 tgt->conn_db_mem_size);
                 goto mem_alloc_failure;
         }
@@ -767,7 +780,7 @@ static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba,
                                       &tgt->lcq_dma, GFP_KERNEL);
 
         if (!tgt->lcq) {
-                printk(KERN_ALERT PFX "unable to allocate lcq %d\n",
+                printk(KERN_ERR PFX "unable to allocate lcq %d\n",
                        tgt->lcq_mem_size);
                 goto mem_alloc_failure;
         }
diff --git a/drivers/scsi/device_handler/scsi_dh_rdac.c b/drivers/scsi/device_handler/scsi_dh_rdac.c
index 2e7c136bb805..27c9d65d54a9 100644
--- a/drivers/scsi/device_handler/scsi_dh_rdac.c
+++ b/drivers/scsi/device_handler/scsi_dh_rdac.c
@@ -128,25 +128,7 @@ struct c4_inquiry {
         u8      reserved[2];
 };
 
-struct rdac_controller {
-        u8                      subsys_id[SUBSYS_ID_LEN];
-        u8                      slot_id[SLOT_ID_LEN];
-        int                     use_ms10;
-        struct kref             kref;
-        struct list_head        node; /* list of all controllers */
-        union                   {
-                struct rdac_pg_legacy legacy;
-                struct rdac_pg_expanded expanded;
-        } mode_select;
-        u8      index;
-        u8      array_name[ARRAY_LABEL_LEN];
-        spinlock_t              ms_lock;
-        int                     ms_queued;
-        struct work_struct      ms_work;
-        struct scsi_device      *ms_sdev;
-        struct list_head        ms_head;
-};
-
+#define UNIQUE_ID_LEN 16
 struct c8_inquiry {
         u8      peripheral_info;
         u8      page_code; /* 0xC8 */
@@ -159,12 +141,31 @@ struct c8_inquiry {
         u8      vol_user_label_len;
         u8      vol_user_label[60];
         u8      array_uniq_id_len;
-        u8      array_unique_id[16];
+        u8      array_unique_id[UNIQUE_ID_LEN];
         u8      array_user_label_len;
         u8      array_user_label[60];
         u8      lun[8];
 };
 
+struct rdac_controller {
+        u8                      array_id[UNIQUE_ID_LEN];
+        int                     use_ms10;
+        struct kref             kref;
+        struct list_head        node; /* list of all controllers */
+        union                   {
+                struct rdac_pg_legacy legacy;
+                struct rdac_pg_expanded expanded;
+        } mode_select;
+        u8      index;
+        u8      array_name[ARRAY_LABEL_LEN];
+        struct Scsi_Host        *host;
+        spinlock_t              ms_lock;
+        int                     ms_queued;
+        struct work_struct      ms_work;
+        struct scsi_device      *ms_sdev;
+        struct list_head        ms_head;
+};
+
 struct c2_inquiry {
         u8      peripheral_info;
         u8      page_code;      /* 0xC2 */
@@ -369,16 +370,17 @@ static void release_controller(struct kref *kref)
         kfree(ctlr);
 }
 
-static struct rdac_controller *get_controller(u8 *subsys_id, u8 *slot_id,
-                                                char *array_name)
+static struct rdac_controller *get_controller(int index, char *array_name,
+                        u8 *array_id, struct scsi_device *sdev)
 {
         struct rdac_controller *ctlr, *tmp;
 
         spin_lock(&list_lock);
 
         list_for_each_entry(tmp, &ctlr_list, node) {
-                if ((memcmp(tmp->subsys_id, subsys_id, SUBSYS_ID_LEN) == 0) &&
-                          (memcmp(tmp->slot_id, slot_id, SLOT_ID_LEN) == 0)) {
+                if ((memcmp(tmp->array_id, array_id, UNIQUE_ID_LEN) == 0) &&
+                          (tmp->index == index) &&
+                          (tmp->host == sdev->host)) {
                         kref_get(&tmp->kref);
                         spin_unlock(&list_lock);
                         return tmp;
@@ -389,16 +391,11 @@ static struct rdac_controller *get_controller(u8 *subsys_id, u8 *slot_id,
                 goto done;
 
         /* initialize fields of controller */
-        memcpy(ctlr->subsys_id, subsys_id, SUBSYS_ID_LEN);
-        memcpy(ctlr->slot_id, slot_id, SLOT_ID_LEN);
+        memcpy(ctlr->array_id, array_id, UNIQUE_ID_LEN);
+        ctlr->index = index;
+        ctlr->host = sdev->host;
         memcpy(ctlr->array_name, array_name, ARRAY_LABEL_LEN);
 
-        /* update the controller index */
-        if (slot_id[1] == 0x31)
-                ctlr->index = 0;
-        else
-                ctlr->index = 1;
-
         kref_init(&ctlr->kref);
         ctlr->use_ms10 = -1;
         ctlr->ms_queued = 0;
@@ -444,7 +441,7 @@ done:
 }
 
 static int get_lun_info(struct scsi_device *sdev, struct rdac_dh_data *h,
-                        char *array_name)
+                        char *array_name, u8 *array_id)
 {
         int err, i;
         struct c8_inquiry *inqp;
@@ -463,6 +460,8 @@ static int get_lun_info(struct scsi_device *sdev, struct rdac_dh_data *h,
                         *(array_name+i) = inqp->array_user_label[(2*i)+1];
 
                 *(array_name+ARRAY_LABEL_LEN-1) = '\0';
+                memset(array_id, 0, UNIQUE_ID_LEN);
+                memcpy(array_id, inqp->array_unique_id, inqp->array_uniq_id_len);
         }
         return err;
 }
@@ -504,16 +503,20 @@ static int check_ownership(struct scsi_device *sdev, struct rdac_dh_data *h)
 }
 
 static int initialize_controller(struct scsi_device *sdev,
-                                 struct rdac_dh_data *h, char *array_name)
+                struct rdac_dh_data *h, char *array_name, u8 *array_id)
 {
-        int err;
+        int err, index;
         struct c4_inquiry *inqp;
 
         err = submit_inquiry(sdev, 0xC4, sizeof(struct c4_inquiry), h);
         if (err == SCSI_DH_OK) {
                 inqp = &h->inq.c4;
-                h->ctlr = get_controller(inqp->subsys_id, inqp->slot_id,
-                                        array_name);
+                /* get the controller index */
+                if (inqp->slot_id[1] == 0x31)
+                        index = 0;
+                else
+                        index = 1;
+                h->ctlr = get_controller(index, array_name, array_id, sdev);
                 if (!h->ctlr)
                         err = SCSI_DH_RES_TEMP_UNAVAIL;
         }
@@ -835,6 +838,7 @@ static int rdac_bus_attach(struct scsi_device *sdev)
         unsigned long flags;
         int err;
         char array_name[ARRAY_LABEL_LEN];
+        char array_id[UNIQUE_ID_LEN];
 
         scsi_dh_data = kzalloc(sizeof(*scsi_dh_data)
                                + sizeof(*h) , GFP_KERNEL);
@@ -849,11 +853,11 @@ static int rdac_bus_attach(struct scsi_device *sdev)
         h->lun = UNINITIALIZED_LUN;
         h->state = RDAC_STATE_ACTIVE;
 
-        err = get_lun_info(sdev, h, array_name);
+        err = get_lun_info(sdev, h, array_name, array_id);
         if (err != SCSI_DH_OK)
                 goto failed;
 
-        err = initialize_controller(sdev, h, array_name);
+        err = initialize_controller(sdev, h, array_name, array_id);
         if (err != SCSI_DH_OK)
                 goto failed;
 
diff --git a/drivers/scsi/fcoe/fcoe.c b/drivers/scsi/fcoe/fcoe.c
index 204fa8d4b4ab..ba710e350ac5 100644
--- a/drivers/scsi/fcoe/fcoe.c
+++ b/drivers/scsi/fcoe/fcoe.c
@@ -487,6 +487,19 @@ static int fcoe_fip_recv(struct sk_buff *skb, struct net_device *netdev,
 }
 
 /**
+ * fcoe_port_send() - Send an Ethernet-encapsulated FIP/FCoE frame
+ * @port: The FCoE port
+ * @skb: The FIP/FCoE packet to be sent
+ */
+static void fcoe_port_send(struct fcoe_port *port, struct sk_buff *skb)
+{
+        if (port->fcoe_pending_queue.qlen)
+                fcoe_check_wait_queue(port->lport, skb);
+        else if (fcoe_start_io(skb))
+                fcoe_check_wait_queue(port->lport, skb);
+}
+
+/**
  * fcoe_fip_send() - Send an Ethernet-encapsulated FIP frame
  * @fip: The FCoE controller
  * @skb: The FIP packet to be sent
@@ -494,7 +507,7 @@ static int fcoe_fip_recv(struct sk_buff *skb, struct net_device *netdev,
 static void fcoe_fip_send(struct fcoe_ctlr *fip, struct sk_buff *skb)
 {
         skb->dev = fcoe_from_ctlr(fip)->netdev;
-        dev_queue_xmit(skb);
+        fcoe_port_send(lport_priv(fip->lp), skb);
 }
 
 /**
@@ -1257,30 +1270,20 @@ static int fcoe_cpu_callback(struct notifier_block *nfb,
 /**
  * fcoe_select_cpu() - Selects CPU to handle post-processing of incoming
  *                      command.
- * @curr_cpu:   CPU which received request
  *
- * This routine selects next CPU based on cpumask.
+ * This routine selects next CPU based on cpumask to distribute
+ * incoming requests in round robin.
  *
- * Returns: int (CPU number). Caller to verify if returned CPU is online or not.
+ * Returns: int CPU number
  */
-static unsigned int fcoe_select_cpu(unsigned int curr_cpu)
+static inline unsigned int fcoe_select_cpu(void)
 {
         static unsigned int selected_cpu;
 
-        if (num_online_cpus() == 1)
-                return curr_cpu;
-        /*
-         * Doing following check, to skip "curr_cpu (smp_processor_id)"
-         * from selection of CPU is intentional. This is to avoid same CPU
-         * doing post-processing of command. "curr_cpu" to just receive
-         * incoming request in case where rx_id is UNKNOWN and all other
-         * CPU to actually process the command(s)
-         */
-        do {
-                selected_cpu = cpumask_next(selected_cpu, cpu_online_mask);
-                if (selected_cpu >= nr_cpu_ids)
-                        selected_cpu = cpumask_first(cpu_online_mask);
-        } while (selected_cpu == curr_cpu);
+        selected_cpu = cpumask_next(selected_cpu, cpu_online_mask);
+        if (selected_cpu >= nr_cpu_ids)
+                selected_cpu = cpumask_first(cpu_online_mask);
+
         return selected_cpu;
 }
 
@@ -1350,30 +1353,26 @@ int fcoe_rcv(struct sk_buff *skb, struct net_device *netdev,
 
         fr = fcoe_dev_from_skb(skb);
         fr->fr_dev = lport;
-        fr->ptype = ptype;
 
         /*
          * In case the incoming frame's exchange is originated from
          * the initiator, then received frame's exchange id is ANDed
          * with fc_cpu_mask bits to get the same cpu on which exchange
-         * was originated, otherwise just use the current cpu.
+         * was originated, otherwise select cpu using rx exchange id
+         * or fcoe_select_cpu().
          */
         if (ntoh24(fh->fh_f_ctl) & FC_FC_EX_CTX)
                 cpu = ntohs(fh->fh_ox_id) & fc_cpu_mask;
         else {
-                cpu = smp_processor_id();
-
-                if ((fh->fh_type == FC_TYPE_FCP) &&
-                    (ntohs(fh->fh_rx_id) == FC_XID_UNKNOWN)) {
-                        do {
-                                cpu = fcoe_select_cpu(cpu);
-                        } while (!cpu_online(cpu));
-                } else  if ((fh->fh_type == FC_TYPE_FCP) &&
-                            (ntohs(fh->fh_rx_id) != FC_XID_UNKNOWN)) {
+                if (ntohs(fh->fh_rx_id) == FC_XID_UNKNOWN)
+                        cpu = fcoe_select_cpu();
+                else
                         cpu = ntohs(fh->fh_rx_id) & fc_cpu_mask;
-                } else
-                        cpu = smp_processor_id();
         }
+
+        if (cpu >= nr_cpu_ids)
+                goto err;
+
         fps = &per_cpu(fcoe_percpu, cpu);
         spin_lock_bh(&fps->fcoe_rx_list.lock);
         if (unlikely(!fps->thread)) {
@@ -1572,11 +1571,7 @@ int fcoe_xmit(struct fc_lport *lport, struct fc_frame *fp)
 
         /* send down to lld */
         fr_dev(fp) = lport;
-        if (port->fcoe_pending_queue.qlen)
-                fcoe_check_wait_queue(lport, skb);
-        else if (fcoe_start_io(skb))
-                fcoe_check_wait_queue(lport, skb);
-
+        fcoe_port_send(port, skb);
         return 0;
 }
 
diff --git a/drivers/scsi/hpsa.c b/drivers/scsi/hpsa.c
index c6f99b1d2383..ec61bdb833ac 100644
--- a/drivers/scsi/hpsa.c
+++ b/drivers/scsi/hpsa.c
@@ -1219,8 +1219,8 @@ static void complete_scsi_command(struct CommandList *cp)
                 dev_warn(&h->pdev->dev, "cp %p reports abort failed\n", cp);
                 break;
         case CMD_UNSOLICITED_ABORT:
-                cmd->result = DID_RESET << 16;
-                dev_warn(&h->pdev->dev, "cp %p aborted do to an unsolicited "
+                cmd->result = DID_SOFT_ERROR << 16; /* retry the command */
+                dev_warn(&h->pdev->dev, "cp %p aborted due to an unsolicited "
                         "abort\n", cp);
                 break;
         case CMD_TIMEOUT:
diff --git a/drivers/scsi/hpsa.h b/drivers/scsi/hpsa.h
index 6d8dcd4dd06b..7f53ceaa7239 100644
--- a/drivers/scsi/hpsa.h
+++ b/drivers/scsi/hpsa.h
@@ -214,7 +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);
+        (void) readl(h->vaddr + SA5_SCRATCHPAD_OFFSET);
         h->commands_outstanding++;
         if (h->commands_outstanding > h->max_outstanding)
                 h->max_outstanding = h->commands_outstanding;
diff --git a/drivers/scsi/ipr.c b/drivers/scsi/ipr.c
index 888086c4e709..8d636301e32c 100644
--- a/drivers/scsi/ipr.c
+++ b/drivers/scsi/ipr.c
@@ -8778,14 +8778,14 @@ static int __devinit ipr_probe_ioa(struct pci_dev *pdev,
         if (rc != PCIBIOS_SUCCESSFUL) {
                 dev_err(&pdev->dev, "Failed to save PCI config space\n");
                 rc = -EIO;
-                goto cleanup_nomem;
+                goto out_msi_disable;
         }
 
         if ((rc = ipr_save_pcix_cmd_reg(ioa_cfg)))
-                goto cleanup_nomem;
+                goto out_msi_disable;
 
         if ((rc = ipr_set_pcix_cmd_reg(ioa_cfg)))
-                goto cleanup_nomem;
+                goto out_msi_disable;
 
         if (ioa_cfg->sis64)
                 ioa_cfg->cfg_table_size = (sizeof(struct ipr_config_table_hdr64)
@@ -8800,7 +8800,7 @@ static int __devinit ipr_probe_ioa(struct pci_dev *pdev,
         if (rc < 0) {
                 dev_err(&pdev->dev,
                         "Couldn't allocate enough memory for device driver!\n");
-                goto cleanup_nomem;
+                goto out_msi_disable;
         }
 
         /*
@@ -8845,10 +8845,10 @@ out:
 
 cleanup_nolog:
         ipr_free_mem(ioa_cfg);
-cleanup_nomem:
-        iounmap(ipr_regs);
 out_msi_disable:
         pci_disable_msi(pdev);
+cleanup_nomem:
+        iounmap(ipr_regs);
 out_release_regions:
         pci_release_regions(pdev);
 out_scsi_host_put:
diff --git a/drivers/scsi/libfc/fc_exch.c b/drivers/scsi/libfc/fc_exch.c
index f5a0665b6773..01ff082dc34c 100644
--- a/drivers/scsi/libfc/fc_exch.c
+++ b/drivers/scsi/libfc/fc_exch.c
@@ -802,10 +802,8 @@ static struct fc_exch *fc_exch_find(struct fc_exch_mgr *mp, u16 xid)
                 pool = per_cpu_ptr(mp->pool, xid & fc_cpu_mask);
                 spin_lock_bh(&pool->lock);
                 ep = fc_exch_ptr_get(pool, (xid - mp->min_xid) >> fc_cpu_order);
-                if (ep) {
+                if (ep && ep->xid == xid)
                         fc_exch_hold(ep);
-                        WARN_ON(ep->xid != xid);
-                }
                 spin_unlock_bh(&pool->lock);
         }
         return ep;
@@ -2465,8 +2463,11 @@ int fc_setup_exch_mgr(void)
 
         fc_exch_workqueue = create_singlethread_workqueue("fc_exch_workqueue");
         if (!fc_exch_workqueue)
-                return -ENOMEM;
+                goto err;
         return 0;
+err:
+        kmem_cache_destroy(fc_em_cachep);
+        return -ENOMEM;
 }
 
 /**
diff --git a/drivers/scsi/libfc/fc_fcp.c b/drivers/scsi/libfc/fc_fcp.c
index 9cd2149519ac..afb63c843144 100644
--- a/drivers/scsi/libfc/fc_fcp.c
+++ b/drivers/scsi/libfc/fc_fcp.c
@@ -498,7 +498,7 @@ crc_err:
                         stats = per_cpu_ptr(lport->dev_stats, get_cpu());
                         stats->ErrorFrames++;
                         /* per cpu count, not total count, but OK for limit */
-                        if (stats->InvalidCRCCount++ < 5)
+                        if (stats->InvalidCRCCount++ < FC_MAX_ERROR_CNT)
                                 printk(KERN_WARNING "libfc: CRC error on data "
                                        "frame for port (%6.6x)\n",
                                        lport->port_id);
@@ -690,7 +690,7 @@ static int fc_fcp_send_data(struct fc_fcp_pkt *fsp, struct fc_seq *seq,
 }
 
 /**
- * fc_fcp_abts_resp() - Send an ABTS response
+ * fc_fcp_abts_resp() - Receive an ABTS response
  * @fsp: The FCP packet that is being aborted
  * @fp:  The response frame
  */
@@ -730,7 +730,7 @@ static void fc_fcp_abts_resp(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
 }
 
 /**
- * fc_fcp_recv() - Reveive an FCP frame
+ * fc_fcp_recv() - Receive an FCP frame
  * @seq: The sequence the frame is on
  * @fp:  The received frame
  * @arg: The related FCP packet
@@ -1084,6 +1084,7 @@ static int fc_fcp_pkt_send(struct fc_lport *lport, struct fc_fcp_pkt *fsp)
         rc = lport->tt.fcp_cmd_send(lport, fsp, fc_fcp_recv);
         if (unlikely(rc)) {
                 spin_lock_irqsave(&si->scsi_queue_lock, flags);
+                fsp->cmd->SCp.ptr = NULL;
                 list_del(&fsp->list);
                 spin_unlock_irqrestore(&si->scsi_queue_lock, flags);
         }
@@ -1645,12 +1646,10 @@ static void fc_fcp_srr(struct fc_fcp_pkt *fsp, enum fc_rctl r_ctl, u32 offset)
         struct fc_seq *seq;
         struct fcp_srr *srr;
         struct fc_frame *fp;
-        u8 cdb_op;
         unsigned int rec_tov;
 
         rport = fsp->rport;
         rpriv = rport->dd_data;
-        cdb_op = fsp->cdb_cmd.fc_cdb[0];
 
         if (!(rpriv->flags & FC_RP_FLAGS_RETRY) ||
             rpriv->rp_state != RPORT_ST_READY)
diff --git a/drivers/scsi/libfc/fc_lport.c b/drivers/scsi/libfc/fc_lport.c
index e008b1673507..e55ed9cf23fb 100644
--- a/drivers/scsi/libfc/fc_lport.c
+++ b/drivers/scsi/libfc/fc_lport.c
@@ -1352,7 +1352,6 @@ static void fc_lport_timeout(struct work_struct *work)
                 WARN_ON(1);
                 break;
         case LPORT_ST_READY:
-                WARN_ON(1);
                 break;
         case LPORT_ST_RESET:
                 break;
diff --git a/drivers/scsi/libsas/sas_expander.c b/drivers/scsi/libsas/sas_expander.c
index 874e29d9533f..f84084bba2f0 100644
--- a/drivers/scsi/libsas/sas_expander.c
+++ b/drivers/scsi/libsas/sas_expander.c
@@ -849,6 +849,9 @@ static struct domain_device *sas_ex_discover_expander(
 
         res = sas_discover_expander(child);
         if (res) {
+                spin_lock_irq(&parent->port->dev_list_lock);
+                list_del(&child->dev_list_node);
+                spin_unlock_irq(&parent->port->dev_list_lock);
                 kfree(child);
                 return NULL;
         }
diff --git a/drivers/scsi/lpfc/lpfc.h b/drivers/scsi/lpfc/lpfc.h
index 8ec2c86a49d4..c088a36d1f33 100644
--- a/drivers/scsi/lpfc/lpfc.h
+++ b/drivers/scsi/lpfc/lpfc.h
@@ -20,6 +20,11 @@
  *******************************************************************/
 
 #include <scsi/scsi_host.h>
+
+#if defined(CONFIG_DEBUG_FS) && !defined(CONFIG_SCSI_LPFC_DEBUG_FS)
+#define CONFIG_SCSI_LPFC_DEBUG_FS
+#endif
+
 struct lpfc_sli2_slim;
 
 #define LPFC_PCI_DEV_LP         0x1
@@ -465,9 +470,10 @@ enum intr_type_t {
 struct unsol_rcv_ct_ctx {
         uint32_t ctxt_id;
         uint32_t SID;
-        uint32_t oxid;
         uint32_t flags;
 #define UNSOL_VALID     0x00000001
+        uint16_t oxid;
+        uint16_t rxid;
 };
 
 #define LPFC_USER_LINK_SPEED_AUTO       0       /* auto select (default)*/
@@ -674,6 +680,9 @@ struct lpfc_hba {
         uint32_t cfg_enable_rrq;
         uint32_t cfg_topology;
         uint32_t cfg_link_speed;
+#define LPFC_FCF_FOV 1          /* Fast fcf failover */
+#define LPFC_FCF_PRIORITY 2     /* Priority fcf failover */
+        uint32_t cfg_fcf_failover_policy;
         uint32_t cfg_cr_delay;
         uint32_t cfg_cr_count;
         uint32_t cfg_multi_ring_support;
@@ -845,9 +854,13 @@ struct lpfc_hba {
         /* iDiag debugfs sub-directory */
         struct dentry *idiag_root;
         struct dentry *idiag_pci_cfg;
+        struct dentry *idiag_bar_acc;
         struct dentry *idiag_que_info;
         struct dentry *idiag_que_acc;
         struct dentry *idiag_drb_acc;
+        struct dentry *idiag_ctl_acc;
+        struct dentry *idiag_mbx_acc;
+        struct dentry *idiag_ext_acc;
 #endif
 
         /* Used for deferred freeing of ELS data buffers */
diff --git a/drivers/scsi/lpfc/lpfc_attr.c b/drivers/scsi/lpfc/lpfc_attr.c
index 135a53baa735..2542f1f8bf86 100644
--- a/drivers/scsi/lpfc/lpfc_attr.c
+++ b/drivers/scsi/lpfc/lpfc_attr.c
@@ -755,6 +755,47 @@ lpfc_issue_reset(struct device *dev, struct device_attribute *attr,
 }
 
 /**
+ * lpfc_sli4_pdev_status_reg_wait - Wait for pdev status register for readyness
+ * @phba: lpfc_hba pointer.
+ *
+ * Description:
+ * SLI4 interface type-2 device to wait on the sliport status register for
+ * the readyness after performing a firmware reset.
+ *
+ * Returns:
+ * zero for success
+ **/
+static int
+lpfc_sli4_pdev_status_reg_wait(struct lpfc_hba *phba)
+{
+        struct lpfc_register portstat_reg;
+        int i;
+
+
+        lpfc_readl(phba->sli4_hba.u.if_type2.STATUSregaddr,
+                   &portstat_reg.word0);
+
+        /* wait for the SLI port firmware ready after firmware reset */
+        for (i = 0; i < LPFC_FW_RESET_MAXIMUM_WAIT_10MS_CNT; i++) {
+                msleep(10);
+                lpfc_readl(phba->sli4_hba.u.if_type2.STATUSregaddr,
+                           &portstat_reg.word0);
+                if (!bf_get(lpfc_sliport_status_err, &portstat_reg))
+                        continue;
+                if (!bf_get(lpfc_sliport_status_rn, &portstat_reg))
+                        continue;
+                if (!bf_get(lpfc_sliport_status_rdy, &portstat_reg))
+                        continue;
+                break;
+        }
+
+        if (i < LPFC_FW_RESET_MAXIMUM_WAIT_10MS_CNT)
+                return 0;
+        else
+                return -EIO;
+}
+
+/**
  * lpfc_sli4_pdev_reg_request - Request physical dev to perform a register acc
  * @phba: lpfc_hba pointer.
  *
@@ -769,6 +810,7 @@ static ssize_t
 lpfc_sli4_pdev_reg_request(struct lpfc_hba *phba, uint32_t opcode)
 {
         struct completion online_compl;
+        struct pci_dev *pdev = phba->pcidev;
         uint32_t reg_val;
         int status = 0;
         int rc;
@@ -781,6 +823,14 @@ lpfc_sli4_pdev_reg_request(struct lpfc_hba *phba, uint32_t opcode)
              LPFC_SLI_INTF_IF_TYPE_2))
                 return -EPERM;
 
+        if (!pdev->is_physfn)
+                return -EPERM;
+
+        /* Disable SR-IOV virtual functions if enabled */
+        if (phba->cfg_sriov_nr_virtfn) {
+                pci_disable_sriov(pdev);
+                phba->cfg_sriov_nr_virtfn = 0;
+        }
         status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
 
         if (status != 0)
@@ -805,7 +855,10 @@ lpfc_sli4_pdev_reg_request(struct lpfc_hba *phba, uint32_t opcode)
         readl(phba->sli4_hba.conf_regs_memmap_p + LPFC_CTL_PDEV_CTL_OFFSET);
 
         /* delay driver action following IF_TYPE_2 reset */
-        msleep(100);
+        rc = lpfc_sli4_pdev_status_reg_wait(phba);
+
+        if (rc)
+                return -EIO;
 
         init_completion(&online_compl);
         rc = lpfc_workq_post_event(phba, &status, &online_compl,
@@ -895,6 +948,10 @@ lpfc_board_mode_store(struct device *dev, struct device_attribute *attr,
 
         if (!phba->cfg_enable_hba_reset)
                 return -EACCES;
+
+        lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
+                "3050 lpfc_board_mode set to %s\n", buf);
+
         init_completion(&online_compl);
 
         if(strncmp(buf, "online", sizeof("online") - 1) == 0) {
@@ -1290,6 +1347,10 @@ lpfc_poll_store(struct device *dev, struct device_attribute *attr,
         if (phba->sli_rev == LPFC_SLI_REV4)
                 val = 0;
 
+        lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
+                "3051 lpfc_poll changed from %d to %d\n",
+                phba->cfg_poll, val);
+
         spin_lock_irq(&phba->hbalock);
 
         old_val = phba->cfg_poll;
@@ -1414,80 +1475,10 @@ lpfc_sriov_hw_max_virtfn_show(struct device *dev,
         struct Scsi_Host *shost = class_to_shost(dev);
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
         struct lpfc_hba *phba = vport->phba;
-        struct pci_dev *pdev = phba->pcidev;
-        union  lpfc_sli4_cfg_shdr *shdr;
-        uint32_t shdr_status, shdr_add_status;
-        LPFC_MBOXQ_t *mboxq;
-        struct lpfc_mbx_get_prof_cfg *get_prof_cfg;
-        struct lpfc_rsrc_desc_pcie *desc;
-        uint32_t max_nr_virtfn;
-        uint32_t desc_count;
-        int length, rc, i;
-
-        if ((phba->sli_rev < LPFC_SLI_REV4) ||
-            (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) !=
-             LPFC_SLI_INTF_IF_TYPE_2))
-                return -EPERM;
-
-        if (!pdev->is_physfn)
-                return snprintf(buf, PAGE_SIZE, "%d\n", 0);
-
-        mboxq = (LPFC_MBOXQ_t *)mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
-        if (!mboxq)
-                return -ENOMEM;
-
-        /* get the maximum number of virtfn support by physfn */
-        length = (sizeof(struct lpfc_mbx_get_prof_cfg) -
-                  sizeof(struct lpfc_sli4_cfg_mhdr));
-        lpfc_sli4_config(phba, mboxq, LPFC_MBOX_SUBSYSTEM_COMMON,
-                         LPFC_MBOX_OPCODE_GET_PROFILE_CONFIG,
-                         length, LPFC_SLI4_MBX_EMBED);
-        shdr = (union lpfc_sli4_cfg_shdr *)
-                &mboxq->u.mqe.un.sli4_config.header.cfg_shdr;
-        bf_set(lpfc_mbox_hdr_pf_num, &shdr->request,
-               phba->sli4_hba.iov.pf_number + 1);
-
-        get_prof_cfg = &mboxq->u.mqe.un.get_prof_cfg;
-        bf_set(lpfc_mbx_get_prof_cfg_prof_tp, &get_prof_cfg->u.request,
-               LPFC_CFG_TYPE_CURRENT_ACTIVE);
-
-        rc = lpfc_sli_issue_mbox_wait(phba, mboxq,
-                                lpfc_mbox_tmo_val(phba, MBX_SLI4_CONFIG));
-
-        if (rc != MBX_TIMEOUT) {
-                /* check return status */
-                shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
-                shdr_add_status = bf_get(lpfc_mbox_hdr_add_status,
-                                         &shdr->response);
-                if (shdr_status || shdr_add_status || rc)
-                        goto error_out;
-
-        } else
-                goto error_out;
-
-        desc_count = get_prof_cfg->u.response.prof_cfg.rsrc_desc_count;
-
-        for (i = 0; i < LPFC_RSRC_DESC_MAX_NUM; i++) {
-                desc = (struct lpfc_rsrc_desc_pcie *)
-                        &get_prof_cfg->u.response.prof_cfg.desc[i];
-                if (LPFC_RSRC_DESC_TYPE_PCIE ==
-                    bf_get(lpfc_rsrc_desc_pcie_type, desc)) {
-                        max_nr_virtfn = bf_get(lpfc_rsrc_desc_pcie_nr_virtfn,
-                                               desc);
-                        break;
-                }
-        }
-
-        if (i < LPFC_RSRC_DESC_MAX_NUM) {
-                if (rc != MBX_TIMEOUT)
-                        mempool_free(mboxq, phba->mbox_mem_pool);
-                return snprintf(buf, PAGE_SIZE, "%d\n", max_nr_virtfn);
-        }
+        uint16_t max_nr_virtfn;
 
-error_out:
-        if (rc != MBX_TIMEOUT)
-                mempool_free(mboxq, phba->mbox_mem_pool);
-        return -EIO;
+        max_nr_virtfn = lpfc_sli_sriov_nr_virtfn_get(phba);
+        return snprintf(buf, PAGE_SIZE, "%d\n", max_nr_virtfn);
 }
 
 /**
@@ -1605,6 +1596,9 @@ static int \
 lpfc_##attr##_set(struct lpfc_hba *phba, uint val) \
 { \
         if (val >= minval && val <= maxval) {\
+                lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
+                        "3052 lpfc_" #attr " changed from %d to %d\n", \
+                        phba->cfg_##attr, val); \
                 phba->cfg_##attr = val;\
                 return 0;\
         }\
@@ -1762,6 +1756,9 @@ static int \
 lpfc_##attr##_set(struct lpfc_vport *vport, uint val) \
 { \
         if (val >= minval && val <= maxval) {\
+                lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
+                        "3053 lpfc_" #attr " changed from %d to %d\n", \
+                        vport->cfg_##attr, val); \
                 vport->cfg_##attr = val;\
                 return 0;\
         }\
@@ -2196,6 +2193,9 @@ lpfc_param_show(enable_npiv);
 lpfc_param_init(enable_npiv, 1, 0, 1);
 static DEVICE_ATTR(lpfc_enable_npiv, S_IRUGO, lpfc_enable_npiv_show, NULL);
 
+LPFC_ATTR_R(fcf_failover_policy, 1, 1, 2,
+        "FCF Fast failover=1 Priority failover=2");
+
 int lpfc_enable_rrq;
 module_param(lpfc_enable_rrq, int, S_IRUGO);
 MODULE_PARM_DESC(lpfc_enable_rrq, "Enable RRQ functionality");
@@ -2678,6 +2678,9 @@ lpfc_topology_store(struct device *dev, struct device_attribute *attr,
                 if (nolip)
                         return strlen(buf);
 
+                lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
+                        "3054 lpfc_topology changed from %d to %d\n",
+                        prev_val, val);
                 err = lpfc_issue_lip(lpfc_shost_from_vport(phba->pport));
                 if (err) {
                         phba->cfg_topology = prev_val;
@@ -3101,6 +3104,10 @@ lpfc_link_speed_store(struct device *dev, struct device_attribute *attr,
         if (sscanf(val_buf, "%i", &val) != 1)
                 return -EINVAL;
 
+        lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
+                "3055 lpfc_link_speed changed from %d to %d %s\n",
+                phba->cfg_link_speed, val, nolip ? "(nolip)" : "(lip)");
+
         if (((val == LPFC_USER_LINK_SPEED_1G) && !(phba->lmt & LMT_1Gb)) ||
             ((val == LPFC_USER_LINK_SPEED_2G) && !(phba->lmt & LMT_2Gb)) ||
             ((val == LPFC_USER_LINK_SPEED_4G) && !(phba->lmt & LMT_4Gb)) ||
@@ -3678,7 +3685,9 @@ LPFC_ATTR_R(enable_bg, 0, 0, 1, "Enable BlockGuard Support");
 #       - Default will result in registering capabilities for all profiles.
 #
 */
-unsigned int lpfc_prot_mask = SHOST_DIF_TYPE1_PROTECTION;
+unsigned int lpfc_prot_mask = SHOST_DIF_TYPE1_PROTECTION |
+                              SHOST_DIX_TYPE0_PROTECTION |
+                              SHOST_DIX_TYPE1_PROTECTION;
 
 module_param(lpfc_prot_mask, uint, S_IRUGO);
 MODULE_PARM_DESC(lpfc_prot_mask, "host protection mask");
@@ -3769,6 +3778,7 @@ struct device_attribute *lpfc_hba_attrs[] = {
         &dev_attr_lpfc_fdmi_on,
         &dev_attr_lpfc_max_luns,
         &dev_attr_lpfc_enable_npiv,
+        &dev_attr_lpfc_fcf_failover_policy,
         &dev_attr_lpfc_enable_rrq,
         &dev_attr_nport_evt_cnt,
         &dev_attr_board_mode,
@@ -4989,6 +4999,7 @@ lpfc_get_cfgparam(struct lpfc_hba *phba)
         lpfc_link_speed_init(phba, lpfc_link_speed);
         lpfc_poll_tmo_init(phba, lpfc_poll_tmo);
         lpfc_enable_npiv_init(phba, lpfc_enable_npiv);
+        lpfc_fcf_failover_policy_init(phba, lpfc_fcf_failover_policy);
         lpfc_enable_rrq_init(phba, lpfc_enable_rrq);
         lpfc_use_msi_init(phba, lpfc_use_msi);
         lpfc_fcp_imax_init(phba, lpfc_fcp_imax);
diff --git a/drivers/scsi/lpfc/lpfc_bsg.c b/drivers/scsi/lpfc/lpfc_bsg.c
index 7fb0ba4cbfa7..6760c69f5253 100644
--- a/drivers/scsi/lpfc/lpfc_bsg.c
+++ b/drivers/scsi/lpfc/lpfc_bsg.c
@@ -42,6 +42,7 @@
 #include "lpfc.h"
 #include "lpfc_logmsg.h"
 #include "lpfc_crtn.h"
+#include "lpfc_debugfs.h"
 #include "lpfc_vport.h"
 #include "lpfc_version.h"
 
@@ -960,8 +961,10 @@ lpfc_bsg_ct_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
                                                     evt_dat->immed_dat].oxid,
                                                 phba->ct_ctx[
                                                     evt_dat->immed_dat].SID);
+                        phba->ct_ctx[evt_dat->immed_dat].rxid =
+                                piocbq->iocb.ulpContext;
                         phba->ct_ctx[evt_dat->immed_dat].oxid =
-                                                piocbq->iocb.ulpContext;
+                                piocbq->iocb.unsli3.rcvsli3.ox_id;
                         phba->ct_ctx[evt_dat->immed_dat].SID =
                                 piocbq->iocb.un.rcvels.remoteID;
                         phba->ct_ctx[evt_dat->immed_dat].flags = UNSOL_VALID;
@@ -1312,7 +1315,8 @@ lpfc_issue_ct_rsp(struct lpfc_hba *phba, struct fc_bsg_job *job, uint32_t tag,
                         rc = IOCB_ERROR;
                         goto issue_ct_rsp_exit;
                 }
-                icmd->ulpContext = phba->ct_ctx[tag].oxid;
+                icmd->ulpContext = phba->ct_ctx[tag].rxid;
+                icmd->unsli3.rcvsli3.ox_id = phba->ct_ctx[tag].oxid;
                 ndlp = lpfc_findnode_did(phba->pport, phba->ct_ctx[tag].SID);
                 if (!ndlp) {
                         lpfc_printf_log(phba, KERN_WARNING, LOG_ELS,
@@ -1337,9 +1341,7 @@ lpfc_issue_ct_rsp(struct lpfc_hba *phba, struct fc_bsg_job *job, uint32_t tag,
                         goto issue_ct_rsp_exit;
                 }
 
-                icmd->un.ulpWord[3] = ndlp->nlp_rpi;
-                if (phba->sli_rev == LPFC_SLI_REV4)
-                        icmd->ulpContext =
+                icmd->un.ulpWord[3] =
                                 phba->sli4_hba.rpi_ids[ndlp->nlp_rpi];
 
                 /* The exchange is done, mark the entry as invalid */
@@ -1351,8 +1353,8 @@ lpfc_issue_ct_rsp(struct lpfc_hba *phba, struct fc_bsg_job *job, uint32_t tag,
 
         /* Xmit CT response on exchange <xid> */
         lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
-                        "2722 Xmit CT response on exchange x%x Data: x%x x%x\n",
-                        icmd->ulpContext, icmd->ulpIoTag, phba->link_state);
+                "2722 Xmit CT response on exchange x%x Data: x%x x%x x%x\n",
+                icmd->ulpContext, icmd->ulpIoTag, tag, phba->link_state);
 
         ctiocb->iocb_cmpl = NULL;
         ctiocb->iocb_flag |= LPFC_IO_LIBDFC;
@@ -1471,13 +1473,12 @@ send_mgmt_rsp_exit:
 /**
  * lpfc_bsg_diag_mode_enter - process preparing into device diag loopback mode
  * @phba: Pointer to HBA context object.
- * @job: LPFC_BSG_VENDOR_DIAG_MODE
  *
  * This function is responsible for preparing driver for diag loopback
  * on device.
  */
 static int
-lpfc_bsg_diag_mode_enter(struct lpfc_hba *phba, struct fc_bsg_job *job)
+lpfc_bsg_diag_mode_enter(struct lpfc_hba *phba)
 {
         struct lpfc_vport **vports;
         struct Scsi_Host *shost;
@@ -1521,7 +1522,6 @@ lpfc_bsg_diag_mode_enter(struct lpfc_hba *phba, struct fc_bsg_job *job)
 /**
  * lpfc_bsg_diag_mode_exit - exit process from device diag loopback mode
  * @phba: Pointer to HBA context object.
- * @job: LPFC_BSG_VENDOR_DIAG_MODE
  *
  * This function is responsible for driver exit processing of setting up
  * diag loopback mode on device.
@@ -1567,7 +1567,7 @@ lpfc_sli3_bsg_diag_loopback_mode(struct lpfc_hba *phba, struct fc_bsg_job *job)
         uint32_t link_flags;
         uint32_t timeout;
         LPFC_MBOXQ_t *pmboxq;
-        int mbxstatus;
+        int mbxstatus = MBX_SUCCESS;
         int i = 0;
         int rc = 0;
 
@@ -1586,7 +1586,7 @@ lpfc_sli3_bsg_diag_loopback_mode(struct lpfc_hba *phba, struct fc_bsg_job *job)
                 goto job_error;
         }
 
-        rc = lpfc_bsg_diag_mode_enter(phba, job);
+        rc = lpfc_bsg_diag_mode_enter(phba);
         if (rc)
                 goto job_error;
 
@@ -1741,7 +1741,7 @@ lpfc_sli4_bsg_diag_loopback_mode(struct lpfc_hba *phba, struct fc_bsg_job *job)
         uint32_t link_flags, timeout, req_len, alloc_len;
         struct lpfc_mbx_set_link_diag_loopback *link_diag_loopback;
         LPFC_MBOXQ_t *pmboxq = NULL;
-        int mbxstatus, i, rc = 0;
+        int mbxstatus = MBX_SUCCESS, i, rc = 0;
 
         /* no data to return just the return code */
         job->reply->reply_payload_rcv_len = 0;
@@ -1758,7 +1758,7 @@ lpfc_sli4_bsg_diag_loopback_mode(struct lpfc_hba *phba, struct fc_bsg_job *job)
                 goto job_error;
         }
 
-        rc = lpfc_bsg_diag_mode_enter(phba, job);
+        rc = lpfc_bsg_diag_mode_enter(phba);
         if (rc)
                 goto job_error;
 
@@ -1982,7 +1982,7 @@ lpfc_sli4_bsg_link_diag_test(struct fc_bsg_job *job)
                 goto job_error;
         }
 
-        rc = lpfc_bsg_diag_mode_enter(phba, job);
+        rc = lpfc_bsg_diag_mode_enter(phba);
         if (rc)
                 goto job_error;
 
@@ -3178,6 +3178,11 @@ lpfc_bsg_issue_mbox_ext_handle_job(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)
                                 "(x%x/x%x) complete bsg job done, bsize:%d\n",
                                 phba->mbox_ext_buf_ctx.nembType,
                                 phba->mbox_ext_buf_ctx.mboxType, size);
+                lpfc_idiag_mbxacc_dump_bsg_mbox(phba,
+                                        phba->mbox_ext_buf_ctx.nembType,
+                                        phba->mbox_ext_buf_ctx.mboxType,
+                                        dma_ebuf, sta_pos_addr,
+                                        phba->mbox_ext_buf_ctx.mbx_dmabuf, 0);
         } else
                 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
 
@@ -3430,6 +3435,10 @@ lpfc_bsg_sli_cfg_read_cmd_ext(struct lpfc_hba *phba, struct fc_bsg_job *job,
                                 "ext_buf_cnt:%d\n", ext_buf_cnt);
         }
 
+        /* before dma descriptor setup */
+        lpfc_idiag_mbxacc_dump_bsg_mbox(phba, nemb_tp, mbox_rd, dma_mbox,
+                                        sta_pre_addr, dmabuf, ext_buf_cnt);
+
         /* reject non-embedded mailbox command with none external buffer */
         if (ext_buf_cnt == 0) {
                 rc = -EPERM;
@@ -3477,6 +3486,10 @@ lpfc_bsg_sli_cfg_read_cmd_ext(struct lpfc_hba *phba, struct fc_bsg_job *job,
                 }
         }
 
+        /* after dma descriptor setup */
+        lpfc_idiag_mbxacc_dump_bsg_mbox(phba, nemb_tp, mbox_rd, dma_mbox,
+                                        sta_pos_addr, dmabuf, ext_buf_cnt);
+
         /* construct base driver mbox command */
         pmb = &pmboxq->u.mb;
         pmbx = (uint8_t *)dmabuf->virt;
@@ -3511,7 +3524,7 @@ lpfc_bsg_sli_cfg_read_cmd_ext(struct lpfc_hba *phba, struct fc_bsg_job *job,
                 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
                                 "2947 Issued SLI_CONFIG ext-buffer "
                                 "maibox command, rc:x%x\n", rc);
-                return 1;
+                return SLI_CONFIG_HANDLED;
         }
         lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
                         "2948 Failed to issue SLI_CONFIG ext-buffer "
@@ -3549,7 +3562,7 @@ lpfc_bsg_sli_cfg_write_cmd_ext(struct lpfc_hba *phba, struct fc_bsg_job *job,
         LPFC_MBOXQ_t *pmboxq = NULL;
         MAILBOX_t *pmb;
         uint8_t *mbx;
-        int rc = 0, i;
+        int rc = SLI_CONFIG_NOT_HANDLED, i;
 
         mbox_req =
            (struct dfc_mbox_req *)job->request->rqst_data.h_vendor.vendor_cmd;
@@ -3591,12 +3604,20 @@ lpfc_bsg_sli_cfg_write_cmd_ext(struct lpfc_hba *phba, struct fc_bsg_job *job,
                                 "ext_buf_cnt:%d\n", ext_buf_cnt);
         }
 
+        /* before dma buffer descriptor setup */
+        lpfc_idiag_mbxacc_dump_bsg_mbox(phba, nemb_tp, mbox_wr, dma_mbox,
+                                        sta_pre_addr, dmabuf, ext_buf_cnt);
+
         if (ext_buf_cnt == 0)
                 return -EPERM;
 
         /* for the first external buffer */
         lpfc_bsg_sli_cfg_dma_desc_setup(phba, nemb_tp, 0, dmabuf, dmabuf);
 
+        /* after dma descriptor setup */
+        lpfc_idiag_mbxacc_dump_bsg_mbox(phba, nemb_tp, mbox_wr, dma_mbox,
+                                        sta_pos_addr, dmabuf, ext_buf_cnt);
+
         /* log for looking forward */
         for (i = 1; i < ext_buf_cnt; i++) {
                 if (nemb_tp == nemb_mse)
@@ -3660,7 +3681,7 @@ lpfc_bsg_sli_cfg_write_cmd_ext(struct lpfc_hba *phba, struct fc_bsg_job *job,
                         lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
                                         "2955 Issued SLI_CONFIG ext-buffer "
                                         "maibox command, rc:x%x\n", rc);
-                        return 1;
+                        return SLI_CONFIG_HANDLED;
                 }
                 lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
                                 "2956 Failed to issue SLI_CONFIG ext-buffer "
@@ -3668,6 +3689,11 @@ lpfc_bsg_sli_cfg_write_cmd_ext(struct lpfc_hba *phba, struct fc_bsg_job *job,
                 rc = -EPIPE;
         }
 
+        /* wait for additoinal external buffers */
+        job->reply->result = 0;
+        job->job_done(job);
+        return SLI_CONFIG_HANDLED;
+
 job_error:
         if (pmboxq)
                 mempool_free(pmboxq, phba->mbox_mem_pool);
@@ -3840,6 +3866,12 @@ lpfc_bsg_read_ebuf_get(struct lpfc_hba *phba, struct fc_bsg_job *job)
         dmabuf = list_first_entry(&phba->mbox_ext_buf_ctx.ext_dmabuf_list,
                                   struct lpfc_dmabuf, list);
         list_del_init(&dmabuf->list);
+
+        /* after dma buffer descriptor setup */
+        lpfc_idiag_mbxacc_dump_bsg_mbox(phba, phba->mbox_ext_buf_ctx.nembType,
+                                        mbox_rd, dma_ebuf, sta_pos_addr,
+                                        dmabuf, index);
+
         pbuf = (uint8_t *)dmabuf->virt;
         job->reply->reply_payload_rcv_len =
                 sg_copy_from_buffer(job->reply_payload.sg_list,
@@ -3922,6 +3954,11 @@ lpfc_bsg_write_ebuf_set(struct lpfc_hba *phba, struct fc_bsg_job *job,
                                         dmabuf);
         list_add_tail(&dmabuf->list, &phba->mbox_ext_buf_ctx.ext_dmabuf_list);
 
+        /* after write dma buffer */
+        lpfc_idiag_mbxacc_dump_bsg_mbox(phba, phba->mbox_ext_buf_ctx.nembType,
+                                        mbox_wr, dma_ebuf, sta_pos_addr,
+                                        dmabuf, index);
+
         if (phba->mbox_ext_buf_ctx.seqNum == phba->mbox_ext_buf_ctx.numBuf) {
                 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
                                 "2968 SLI_CONFIG ext-buffer wr all %d "
@@ -3959,7 +3996,7 @@ lpfc_bsg_write_ebuf_set(struct lpfc_hba *phba, struct fc_bsg_job *job,
                         lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
                                         "2969 Issued SLI_CONFIG ext-buffer "
                                         "maibox command, rc:x%x\n", rc);
-                        return 1;
+                        return SLI_CONFIG_HANDLED;
                 }
                 lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
                                 "2970 Failed to issue SLI_CONFIG ext-buffer "
@@ -4039,14 +4076,14 @@ lpfc_bsg_handle_sli_cfg_ext(struct lpfc_hba *phba, struct fc_bsg_job *job,
                             struct lpfc_dmabuf *dmabuf)
 {
         struct dfc_mbox_req *mbox_req;
-        int rc;
+        int rc = SLI_CONFIG_NOT_HANDLED;
 
         mbox_req =
            (struct dfc_mbox_req *)job->request->rqst_data.h_vendor.vendor_cmd;
 
         /* mbox command with/without single external buffer */
         if (mbox_req->extMboxTag == 0 && mbox_req->extSeqNum == 0)
-                return SLI_CONFIG_NOT_HANDLED;
+                return rc;
 
         /* mbox command and first external buffer */
         if (phba->mbox_ext_buf_ctx.state == LPFC_BSG_MBOX_IDLE) {
@@ -4249,7 +4286,7 @@ lpfc_bsg_issue_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
                  * mailbox extension size
                  */
                 if ((transmit_length > receive_length) ||
-                        (transmit_length > MAILBOX_EXT_SIZE)) {
+                        (transmit_length > BSG_MBOX_SIZE - sizeof(MAILBOX_t))) {
                         rc = -ERANGE;
                         goto job_done;
                 }
@@ -4272,7 +4309,7 @@ lpfc_bsg_issue_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
                 /* receive length cannot be greater than mailbox
                  * extension size
                  */
-                if (receive_length > MAILBOX_EXT_SIZE) {
+                if (receive_length > BSG_MBOX_SIZE - sizeof(MAILBOX_t)) {
                         rc = -ERANGE;
                         goto job_done;
                 }
@@ -4306,7 +4343,8 @@ lpfc_bsg_issue_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
                         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) {
+                        if (bde->tus.f.bdeSize >
+                            BSG_MBOX_SIZE - sizeof(MAILBOX_t)) {
                                 rc = -ERANGE;
                                 goto job_done;
                         }
@@ -4332,7 +4370,8 @@ lpfc_bsg_issue_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
                                  * mailbox extension size
                                  */
                                 if ((receive_length == 0) ||
-                                    (receive_length > MAILBOX_EXT_SIZE)) {
+                                    (receive_length >
+                                     BSG_MBOX_SIZE - sizeof(MAILBOX_t))) {
                                         rc = -ERANGE;
                                         goto job_done;
                                 }
diff --git a/drivers/scsi/lpfc/lpfc_crtn.h b/drivers/scsi/lpfc/lpfc_crtn.h
index fc20c247f36b..a6db6aef1331 100644
--- a/drivers/scsi/lpfc/lpfc_crtn.h
+++ b/drivers/scsi/lpfc/lpfc_crtn.h
@@ -235,9 +235,11 @@ int lpfc_sli4_redisc_fcf_table(struct lpfc_hba *);
 void lpfc_fcf_redisc_wait_start_timer(struct lpfc_hba *);
 void lpfc_sli4_fcf_dead_failthrough(struct lpfc_hba *);
 uint16_t lpfc_sli4_fcf_rr_next_index_get(struct lpfc_hba *);
+void lpfc_sli4_set_fcf_flogi_fail(struct lpfc_hba *, uint16_t);
 int lpfc_sli4_fcf_rr_index_set(struct lpfc_hba *, uint16_t);
 void lpfc_sli4_fcf_rr_index_clear(struct lpfc_hba *, uint16_t);
 int lpfc_sli4_fcf_rr_next_proc(struct lpfc_vport *, uint16_t);
+void lpfc_sli4_clear_fcf_rr_bmask(struct lpfc_hba *);
 
 int lpfc_mem_alloc(struct lpfc_hba *, int align);
 void lpfc_mem_free(struct lpfc_hba *);
@@ -371,6 +373,10 @@ extern struct lpfc_hbq_init *lpfc_hbq_defs[];
 /* SLI4 if_type 2 externs. */
 int lpfc_sli4_alloc_resource_identifiers(struct lpfc_hba *);
 int lpfc_sli4_dealloc_resource_identifiers(struct lpfc_hba *);
+int lpfc_sli4_get_allocated_extnts(struct lpfc_hba *, uint16_t,
+                                   uint16_t *, uint16_t *);
+int lpfc_sli4_get_avail_extnt_rsrc(struct lpfc_hba *, uint16_t,
+                                          uint16_t *, uint16_t *);
 
 /* externs BlockGuard */
 extern char *_dump_buf_data;
@@ -432,10 +438,16 @@ void lpfc_handle_rrq_active(struct lpfc_hba *);
 int lpfc_send_rrq(struct lpfc_hba *, struct lpfc_node_rrq *);
 int lpfc_set_rrq_active(struct lpfc_hba *, struct lpfc_nodelist *,
         uint16_t, uint16_t, uint16_t);
+uint16_t lpfc_sli4_xri_inrange(struct lpfc_hba *, uint16_t);
 void lpfc_cleanup_wt_rrqs(struct lpfc_hba *);
 void lpfc_cleanup_vports_rrqs(struct lpfc_vport *, struct lpfc_nodelist *);
 struct lpfc_node_rrq *lpfc_get_active_rrq(struct lpfc_vport *, uint16_t,
         uint32_t);
+void lpfc_idiag_mbxacc_dump_bsg_mbox(struct lpfc_hba *, enum nemb_type,
+        enum mbox_type, enum dma_type, enum sta_type,
+        struct lpfc_dmabuf *, uint32_t);
+void lpfc_idiag_mbxacc_dump_issue_mbox(struct lpfc_hba *, MAILBOX_t *);
 int lpfc_wr_object(struct lpfc_hba *, struct list_head *, uint32_t, uint32_t *);
 /* functions to support SR-IOV */
 int lpfc_sli_probe_sriov_nr_virtfn(struct lpfc_hba *, int);
+uint16_t lpfc_sli_sriov_nr_virtfn_get(struct lpfc_hba *);
diff --git a/drivers/scsi/lpfc/lpfc_debugfs.c b/drivers/scsi/lpfc/lpfc_debugfs.c
index 30b25c5fdd7e..a0424dd90e40 100644
--- a/drivers/scsi/lpfc/lpfc_debugfs.c
+++ b/drivers/scsi/lpfc/lpfc_debugfs.c
@@ -48,6 +48,7 @@
 #include "lpfc_version.h"
 #include "lpfc_compat.h"
 #include "lpfc_debugfs.h"
+#include "lpfc_bsg.h"
 
 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
 /*
@@ -135,7 +136,11 @@ lpfc_debugfs_disc_trc_data(struct lpfc_vport *vport, char *buf, int size)
         int i, index, len, enable;
         uint32_t ms;
         struct lpfc_debugfs_trc *dtp;
-        char buffer[LPFC_DEBUG_TRC_ENTRY_SIZE];
+        char *buffer;
+
+        buffer = kmalloc(LPFC_DEBUG_TRC_ENTRY_SIZE, GFP_KERNEL);
+        if (!buffer)
+                return 0;
 
         enable = lpfc_debugfs_enable;
         lpfc_debugfs_enable = 0;
@@ -167,6 +172,8 @@ lpfc_debugfs_disc_trc_data(struct lpfc_vport *vport, char *buf, int size)
         }
 
         lpfc_debugfs_enable = enable;
+        kfree(buffer);
+
         return len;
 }
 
@@ -195,8 +202,11 @@ lpfc_debugfs_slow_ring_trc_data(struct lpfc_hba *phba, char *buf, int size)
         int i, index, len, enable;
         uint32_t ms;
         struct lpfc_debugfs_trc *dtp;
-        char buffer[LPFC_DEBUG_TRC_ENTRY_SIZE];
+        char *buffer;
 
+        buffer = kmalloc(LPFC_DEBUG_TRC_ENTRY_SIZE, GFP_KERNEL);
+        if (!buffer)
+                return 0;
 
         enable = lpfc_debugfs_enable;
         lpfc_debugfs_enable = 0;
@@ -228,6 +238,8 @@ lpfc_debugfs_slow_ring_trc_data(struct lpfc_hba *phba, char *buf, int size)
         }
 
         lpfc_debugfs_enable = enable;
+        kfree(buffer);
+
         return len;
 }
 
@@ -378,7 +390,11 @@ lpfc_debugfs_dumpHBASlim_data(struct lpfc_hba *phba, char *buf, int size)
         int len = 0;
         int i, off;
         uint32_t *ptr;
-        char buffer[1024];
+        char *buffer;
+
+        buffer = kmalloc(1024, GFP_KERNEL);
+        if (!buffer)
+                return 0;
 
         off = 0;
         spin_lock_irq(&phba->hbalock);
@@ -407,6 +423,8 @@ lpfc_debugfs_dumpHBASlim_data(struct lpfc_hba *phba, char *buf, int size)
         }
 
         spin_unlock_irq(&phba->hbalock);
+        kfree(buffer);
+
         return len;
 }
 
@@ -1327,8 +1345,8 @@ lpfc_idiag_pcicfg_read(struct file *file, char __user *buf, size_t nbytes,
                 return 0;
 
         if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_RD) {
-                where = idiag.cmd.data[0];
-                count = idiag.cmd.data[1];
+                where = idiag.cmd.data[IDIAG_PCICFG_WHERE_INDX];
+                count = idiag.cmd.data[IDIAG_PCICFG_COUNT_INDX];
         } else
                 return 0;
 
@@ -1373,6 +1391,11 @@ pcicfg_browse:
                 len += snprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
                                 "%08x ", u32val);
                 offset += sizeof(uint32_t);
+                if (offset >= LPFC_PCI_CFG_SIZE) {
+                        len += snprintf(pbuffer+len,
+                                        LPFC_PCI_CFG_SIZE-len, "\n");
+                        break;
+                }
                 index -= sizeof(uint32_t);
                 if (!index)
                         len += snprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
@@ -1385,8 +1408,11 @@ pcicfg_browse:
         }
 
         /* Set up the offset for next portion of pci cfg read */
-        idiag.offset.last_rd += LPFC_PCI_CFG_RD_SIZE;
-        if (idiag.offset.last_rd >= LPFC_PCI_CFG_SIZE)
+        if (index == 0) {
+                idiag.offset.last_rd += LPFC_PCI_CFG_RD_SIZE;
+                if (idiag.offset.last_rd >= LPFC_PCI_CFG_SIZE)
+                        idiag.offset.last_rd = 0;
+        } else
                 idiag.offset.last_rd = 0;
 
         return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
@@ -1439,8 +1465,8 @@ lpfc_idiag_pcicfg_write(struct file *file, const char __user *buf,
                 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];
+                where = idiag.cmd.data[IDIAG_PCICFG_WHERE_INDX];
+                count = idiag.cmd.data[IDIAG_PCICFG_COUNT_INDX];
                 if (count == LPFC_PCI_CFG_BROWSE) {
                         if (where % sizeof(uint32_t))
                                 goto error_out;
@@ -1475,9 +1501,9 @@ lpfc_idiag_pcicfg_write(struct file *file, const char __user *buf,
                 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];
-                value = idiag.cmd.data[2];
+                where = idiag.cmd.data[IDIAG_PCICFG_WHERE_INDX];
+                count = idiag.cmd.data[IDIAG_PCICFG_COUNT_INDX];
+                value = idiag.cmd.data[IDIAG_PCICFG_VALUE_INDX];
                 /* Sanity checks */
                 if ((count != sizeof(uint8_t)) &&
                     (count != sizeof(uint16_t)) &&
@@ -1570,6 +1596,292 @@ error_out:
 }
 
 /**
+ * lpfc_idiag_baracc_read - idiag debugfs pci bar access read
+ * @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 pci bar memory mapped space
+ * according to the idiag command, and copies to user @buf.
+ *
+ * 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_baracc_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;
+        int offset_label, offset, offset_run, len = 0, index;
+        int bar_num, acc_range, bar_size;
+        char *pbuffer;
+        void __iomem *mem_mapped_bar;
+        uint32_t if_type;
+        struct pci_dev *pdev;
+        uint32_t u32val;
+
+        pdev = phba->pcidev;
+        if (!pdev)
+                return 0;
+
+        /* This is a user read operation */
+        debug->op = LPFC_IDIAG_OP_RD;
+
+        if (!debug->buffer)
+                debug->buffer = kmalloc(LPFC_PCI_BAR_RD_BUF_SIZE, GFP_KERNEL);
+        if (!debug->buffer)
+                return 0;
+        pbuffer = debug->buffer;
+
+        if (*ppos)
+                return 0;
+
+        if (idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_RD) {
+                bar_num   = idiag.cmd.data[IDIAG_BARACC_BAR_NUM_INDX];
+                offset    = idiag.cmd.data[IDIAG_BARACC_OFF_SET_INDX];
+                acc_range = idiag.cmd.data[IDIAG_BARACC_ACC_MOD_INDX];
+                bar_size = idiag.cmd.data[IDIAG_BARACC_BAR_SZE_INDX];
+        } else
+                return 0;
+
+        if (acc_range == 0)
+                return 0;
+
+        if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf);
+        if (if_type == LPFC_SLI_INTF_IF_TYPE_0) {
+                if (bar_num == IDIAG_BARACC_BAR_0)
+                        mem_mapped_bar = phba->sli4_hba.conf_regs_memmap_p;
+                else if (bar_num == IDIAG_BARACC_BAR_1)
+                        mem_mapped_bar = phba->sli4_hba.ctrl_regs_memmap_p;
+                else if (bar_num == IDIAG_BARACC_BAR_2)
+                        mem_mapped_bar = phba->sli4_hba.drbl_regs_memmap_p;
+                else
+                        return 0;
+        } else if (if_type == LPFC_SLI_INTF_IF_TYPE_2) {
+                if (bar_num == IDIAG_BARACC_BAR_0)
+                        mem_mapped_bar = phba->sli4_hba.conf_regs_memmap_p;
+                else
+                        return 0;
+        } else
+                return 0;
+
+        /* Read single PCI bar space register */
+        if (acc_range == SINGLE_WORD) {
+                offset_run = offset;
+                u32val = readl(mem_mapped_bar + offset_run);
+                len += snprintf(pbuffer+len, LPFC_PCI_BAR_RD_BUF_SIZE-len,
+                                "%05x: %08x\n", offset_run, u32val);
+        } else
+                goto baracc_browse;
+
+        return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
+
+baracc_browse:
+
+        /* Browse all PCI bar space registers */
+        offset_label = idiag.offset.last_rd;
+        offset_run = offset_label;
+
+        /* Read PCI bar memory mapped space */
+        len += snprintf(pbuffer+len, LPFC_PCI_BAR_RD_BUF_SIZE-len,
+                        "%05x: ", offset_label);
+        index = LPFC_PCI_BAR_RD_SIZE;
+        while (index > 0) {
+                u32val = readl(mem_mapped_bar + offset_run);
+                len += snprintf(pbuffer+len, LPFC_PCI_BAR_RD_BUF_SIZE-len,
+                                "%08x ", u32val);
+                offset_run += sizeof(uint32_t);
+                if (acc_range == LPFC_PCI_BAR_BROWSE) {
+                        if (offset_run >= bar_size) {
+                                len += snprintf(pbuffer+len,
+                                        LPFC_PCI_BAR_RD_BUF_SIZE-len, "\n");
+                                break;
+                        }
+                } else {
+                        if (offset_run >= offset +
+                            (acc_range * sizeof(uint32_t))) {
+                                len += snprintf(pbuffer+len,
+                                        LPFC_PCI_BAR_RD_BUF_SIZE-len, "\n");
+                                break;
+                        }
+                }
+                index -= sizeof(uint32_t);
+                if (!index)
+                        len += snprintf(pbuffer+len,
+                                        LPFC_PCI_BAR_RD_BUF_SIZE-len, "\n");
+                else if (!(index % (8 * sizeof(uint32_t)))) {
+                        offset_label += (8 * sizeof(uint32_t));
+                        len += snprintf(pbuffer+len,
+                                        LPFC_PCI_BAR_RD_BUF_SIZE-len,
+                                        "\n%05x: ", offset_label);
+                }
+        }
+
+        /* Set up the offset for next portion of pci bar read */
+        if (index == 0) {
+                idiag.offset.last_rd += LPFC_PCI_BAR_RD_SIZE;
+                if (acc_range == LPFC_PCI_BAR_BROWSE) {
+                        if (idiag.offset.last_rd >= bar_size)
+                                idiag.offset.last_rd = 0;
+                } else {
+                        if (offset_run >= offset +
+                            (acc_range * sizeof(uint32_t)))
+                                idiag.offset.last_rd = offset;
+                }
+        } else {
+                if (acc_range == LPFC_PCI_BAR_BROWSE)
+                        idiag.offset.last_rd = 0;
+                else
+                        idiag.offset.last_rd = offset;
+        }
+
+        return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
+}
+
+/**
+ * lpfc_idiag_baracc_write - Syntax check and set up idiag bar access 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 PCI bar memory mapped space read or
+ * write command accordingly. In the case of PCI bar memory mapped space
+ * read command, it sets up the command in the idiag command struct for
+ * the debugfs read operation. In the case of PCI bar memorpy mapped space
+ * write operation, it executes the write operation into the PCI bar memory
+ * mapped space 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_baracc_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 bar_num, bar_size, offset, value, acc_range;
+        struct pci_dev *pdev;
+        void __iomem *mem_mapped_bar;
+        uint32_t if_type;
+        uint32_t u32val;
+        int rc;
+
+        pdev = phba->pcidev;
+        if (!pdev)
+                return -EFAULT;
+
+        /* 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;
+
+        if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf);
+        bar_num = idiag.cmd.data[IDIAG_BARACC_BAR_NUM_INDX];
+
+        if (if_type == LPFC_SLI_INTF_IF_TYPE_0) {
+                if ((bar_num != IDIAG_BARACC_BAR_0) &&
+                    (bar_num != IDIAG_BARACC_BAR_1) &&
+                    (bar_num != IDIAG_BARACC_BAR_2))
+                        goto error_out;
+        } else if (if_type == LPFC_SLI_INTF_IF_TYPE_2) {
+                if (bar_num != IDIAG_BARACC_BAR_0)
+                        goto error_out;
+        } else
+                goto error_out;
+
+        if (if_type == LPFC_SLI_INTF_IF_TYPE_0) {
+                if (bar_num == IDIAG_BARACC_BAR_0) {
+                        idiag.cmd.data[IDIAG_BARACC_BAR_SZE_INDX] =
+                                LPFC_PCI_IF0_BAR0_SIZE;
+                        mem_mapped_bar = phba->sli4_hba.conf_regs_memmap_p;
+                } else if (bar_num == IDIAG_BARACC_BAR_1) {
+                        idiag.cmd.data[IDIAG_BARACC_BAR_SZE_INDX] =
+                                LPFC_PCI_IF0_BAR1_SIZE;
+                        mem_mapped_bar = phba->sli4_hba.ctrl_regs_memmap_p;
+                } else if (bar_num == IDIAG_BARACC_BAR_2) {
+                        idiag.cmd.data[IDIAG_BARACC_BAR_SZE_INDX] =
+                                LPFC_PCI_IF0_BAR2_SIZE;
+                        mem_mapped_bar = phba->sli4_hba.drbl_regs_memmap_p;
+                } else
+                        goto error_out;
+        } else if (if_type == LPFC_SLI_INTF_IF_TYPE_2) {
+                if (bar_num == IDIAG_BARACC_BAR_0) {
+                        idiag.cmd.data[IDIAG_BARACC_BAR_SZE_INDX] =
+                                LPFC_PCI_IF2_BAR0_SIZE;
+                        mem_mapped_bar = phba->sli4_hba.conf_regs_memmap_p;
+                } else
+                        goto error_out;
+        } else
+                goto error_out;
+
+        offset = idiag.cmd.data[IDIAG_BARACC_OFF_SET_INDX];
+        if (offset % sizeof(uint32_t))
+                goto error_out;
+
+        bar_size = idiag.cmd.data[IDIAG_BARACC_BAR_SZE_INDX];
+        if (idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_RD) {
+                /* Sanity check on PCI config read command line arguments */
+                if (rc != LPFC_PCI_BAR_RD_CMD_ARG)
+                        goto error_out;
+                acc_range = idiag.cmd.data[IDIAG_BARACC_ACC_MOD_INDX];
+                if (acc_range == LPFC_PCI_BAR_BROWSE) {
+                        if (offset > bar_size - sizeof(uint32_t))
+                                goto error_out;
+                        /* Starting offset to browse */
+                        idiag.offset.last_rd = offset;
+                } else if (acc_range > SINGLE_WORD) {
+                        if (offset + acc_range * sizeof(uint32_t) > bar_size)
+                                goto error_out;
+                        /* Starting offset to browse */
+                        idiag.offset.last_rd = offset;
+                } else if (acc_range != SINGLE_WORD)
+                        goto error_out;
+        } else if (idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_WR ||
+                   idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_ST ||
+                   idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_CL) {
+                /* Sanity check on PCI bar write command line arguments */
+                if (rc != LPFC_PCI_BAR_WR_CMD_ARG)
+                        goto error_out;
+                /* Write command to PCI bar space, read-modify-write */
+                acc_range = SINGLE_WORD;
+                value = idiag.cmd.data[IDIAG_BARACC_REG_VAL_INDX];
+                if (idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_WR) {
+                        writel(value, mem_mapped_bar + offset);
+                        readl(mem_mapped_bar + offset);
+                }
+                if (idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_ST) {
+                        u32val = readl(mem_mapped_bar + offset);
+                        u32val |= value;
+                        writel(u32val, mem_mapped_bar + offset);
+                        readl(mem_mapped_bar + offset);
+                }
+                if (idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_CL) {
+                        u32val = readl(mem_mapped_bar + offset);
+                        u32val &= ~value;
+                        writel(u32val, mem_mapped_bar + offset);
+                        readl(mem_mapped_bar + offset);
+                }
+        } else
+                /* All other opecodes are illegal for now */
+                goto error_out;
+
+        return nbytes;
+error_out:
+        memset(&idiag, 0, sizeof(idiag));
+        return -EINVAL;
+}
+
+/**
  * lpfc_idiag_queinfo_read - idiag debugfs read queue information
  * @file: The file pointer to read from.
  * @buf: The buffer to copy the data to.
@@ -1871,8 +2183,8 @@ lpfc_idiag_queacc_read(struct file *file, char __user *buf, size_t nbytes,
                 return 0;
 
         if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_RD) {
-                index = idiag.cmd.data[2];
-                count = idiag.cmd.data[3];
+                index = idiag.cmd.data[IDIAG_QUEACC_INDEX_INDX];
+                count = idiag.cmd.data[IDIAG_QUEACC_COUNT_INDX];
                 pque = (struct lpfc_queue *)idiag.ptr_private;
         } else
                 return 0;
@@ -1944,12 +2256,12 @@ lpfc_idiag_queacc_write(struct file *file, const char __user *buf,
                 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];
+        quetp  = idiag.cmd.data[IDIAG_QUEACC_QUETP_INDX];
+        queid  = idiag.cmd.data[IDIAG_QUEACC_QUEID_INDX];
+        index  = idiag.cmd.data[IDIAG_QUEACC_INDEX_INDX];
+        count  = idiag.cmd.data[IDIAG_QUEACC_COUNT_INDX];
+        offset = idiag.cmd.data[IDIAG_QUEACC_OFFST_INDX];
+        value  = idiag.cmd.data[IDIAG_QUEACC_VALUE_INDX];
 
         /* Sanity check on command line arguments */
         if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_WR ||
@@ -2218,7 +2530,7 @@ lpfc_idiag_drbacc_read(struct file *file, char __user *buf, size_t nbytes,
                 return 0;
 
         if (idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_RD)
-                drb_reg_id = idiag.cmd.data[0];
+                drb_reg_id = idiag.cmd.data[IDIAG_DRBACC_REGID_INDX];
         else
                 return 0;
 
@@ -2257,7 +2569,7 @@ lpfc_idiag_drbacc_write(struct file *file, const char __user *buf,
 {
         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;
+        uint32_t drb_reg_id, value, reg_val = 0;
         void __iomem *drb_reg;
         int rc;
 
@@ -2269,8 +2581,8 @@ lpfc_idiag_drbacc_write(struct file *file, const char __user *buf,
                 return rc;
 
         /* Sanity check on command line arguments */
-        drb_reg_id = idiag.cmd.data[0];
-        value = idiag.cmd.data[1];
+        drb_reg_id = idiag.cmd.data[IDIAG_DRBACC_REGID_INDX];
+        value = idiag.cmd.data[IDIAG_DRBACC_VALUE_INDX];
 
         if (idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_WR ||
             idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_ST ||
@@ -2330,6 +2642,679 @@ error_out:
         return -EINVAL;
 }
 
+/**
+ * lpfc_idiag_ctlacc_read_reg - idiag debugfs read a control registers
+ * @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 control 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_ctlacc_read_reg(struct lpfc_hba *phba, char *pbuffer,
+                           int len, uint32_t ctlregid)
+{
+
+        if (!pbuffer)
+                return 0;
+
+        switch (ctlregid) {
+        case LPFC_CTL_PORT_SEM:
+                len += snprintf(pbuffer+len, LPFC_CTL_ACC_BUF_SIZE-len,
+                                "Port SemReg:   0x%08x\n",
+                                readl(phba->sli4_hba.conf_regs_memmap_p +
+                                      LPFC_CTL_PORT_SEM_OFFSET));
+                break;
+        case LPFC_CTL_PORT_STA:
+                len += snprintf(pbuffer+len, LPFC_CTL_ACC_BUF_SIZE-len,
+                                "Port StaReg:   0x%08x\n",
+                                readl(phba->sli4_hba.conf_regs_memmap_p +
+                                      LPFC_CTL_PORT_STA_OFFSET));
+                break;
+        case LPFC_CTL_PORT_CTL:
+                len += snprintf(pbuffer+len, LPFC_CTL_ACC_BUF_SIZE-len,
+                                "Port CtlReg:   0x%08x\n",
+                                readl(phba->sli4_hba.conf_regs_memmap_p +
+                                      LPFC_CTL_PORT_CTL_OFFSET));
+                break;
+        case LPFC_CTL_PORT_ER1:
+                len += snprintf(pbuffer+len, LPFC_CTL_ACC_BUF_SIZE-len,
+                                "Port Er1Reg:   0x%08x\n",
+                                readl(phba->sli4_hba.conf_regs_memmap_p +
+                                      LPFC_CTL_PORT_ER1_OFFSET));
+                break;
+        case LPFC_CTL_PORT_ER2:
+                len += snprintf(pbuffer+len, LPFC_CTL_ACC_BUF_SIZE-len,
+                                "Port Er2Reg:   0x%08x\n",
+                                readl(phba->sli4_hba.conf_regs_memmap_p +
+                                      LPFC_CTL_PORT_ER2_OFFSET));
+                break;
+        case LPFC_CTL_PDEV_CTL:
+                len += snprintf(pbuffer+len, LPFC_CTL_ACC_BUF_SIZE-len,
+                                "PDev CtlReg:   0x%08x\n",
+                                readl(phba->sli4_hba.conf_regs_memmap_p +
+                                      LPFC_CTL_PDEV_CTL_OFFSET));
+                break;
+        default:
+                break;
+        }
+        return len;
+}
+
+/**
+ * lpfc_idiag_ctlacc_read - idiag debugfs read port and device control register
+ * @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 port and device registers according
+ * to the idiag command, and copies to user @buf.
+ *
+ * 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_ctlacc_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 ctl_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_CTL_ACC_BUF_SIZE, GFP_KERNEL);
+        if (!debug->buffer)
+                return 0;
+        pbuffer = debug->buffer;
+
+        if (*ppos)
+                return 0;
+
+        if (idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_RD)
+                ctl_reg_id = idiag.cmd.data[IDIAG_CTLACC_REGID_INDX];
+        else
+                return 0;
+
+        if (ctl_reg_id == LPFC_CTL_ACC_ALL)
+                for (i = 1; i <= LPFC_CTL_MAX; i++)
+                        len = lpfc_idiag_ctlacc_read_reg(phba,
+                                                         pbuffer, len, i);
+        else
+                len = lpfc_idiag_ctlacc_read_reg(phba,
+                                                 pbuffer, len, ctl_reg_id);
+
+        return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
+}
+
+/**
+ * lpfc_idiag_ctlacc_write - Syntax check and set up idiag ctlacc 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 and device control register read (dump)
+ * or write (set) command 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_ctlacc_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 ctl_reg_id, value, reg_val = 0;
+        void __iomem *ctl_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 */
+        ctl_reg_id = idiag.cmd.data[IDIAG_CTLACC_REGID_INDX];
+        value = idiag.cmd.data[IDIAG_CTLACC_VALUE_INDX];
+
+        if (idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_WR ||
+            idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_ST ||
+            idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_CL) {
+                if (rc != LPFC_CTL_ACC_WR_CMD_ARG)
+                        goto error_out;
+                if (ctl_reg_id > LPFC_CTL_MAX)
+                        goto error_out;
+        } else if (idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_RD) {
+                if (rc != LPFC_CTL_ACC_RD_CMD_ARG)
+                        goto error_out;
+                if ((ctl_reg_id > LPFC_CTL_MAX) &&
+                    (ctl_reg_id != LPFC_CTL_ACC_ALL))
+                        goto error_out;
+        } else
+                goto error_out;
+
+        /* Perform the write access operation */
+        if (idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_WR ||
+            idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_ST ||
+            idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_CL) {
+                switch (ctl_reg_id) {
+                case LPFC_CTL_PORT_SEM:
+                        ctl_reg = phba->sli4_hba.conf_regs_memmap_p +
+                                        LPFC_CTL_PORT_SEM_OFFSET;
+                        break;
+                case LPFC_CTL_PORT_STA:
+                        ctl_reg = phba->sli4_hba.conf_regs_memmap_p +
+                                        LPFC_CTL_PORT_STA_OFFSET;
+                        break;
+                case LPFC_CTL_PORT_CTL:
+                        ctl_reg = phba->sli4_hba.conf_regs_memmap_p +
+                                        LPFC_CTL_PORT_CTL_OFFSET;
+                        break;
+                case LPFC_CTL_PORT_ER1:
+                        ctl_reg = phba->sli4_hba.conf_regs_memmap_p +
+                                        LPFC_CTL_PORT_ER1_OFFSET;
+                        break;
+                case LPFC_CTL_PORT_ER2:
+                        ctl_reg = phba->sli4_hba.conf_regs_memmap_p +
+                                        LPFC_CTL_PORT_ER2_OFFSET;
+                        break;
+                case LPFC_CTL_PDEV_CTL:
+                        ctl_reg = phba->sli4_hba.conf_regs_memmap_p +
+                                        LPFC_CTL_PDEV_CTL_OFFSET;
+                        break;
+                default:
+                        goto error_out;
+                }
+
+                if (idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_WR)
+                        reg_val = value;
+                if (idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_ST) {
+                        reg_val = readl(ctl_reg);
+                        reg_val |= value;
+                }
+                if (idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_CL) {
+                        reg_val = readl(ctl_reg);
+                        reg_val &= ~value;
+                }
+                writel(reg_val, ctl_reg);
+                readl(ctl_reg); /* flush */
+        }
+        return nbytes;
+
+error_out:
+        /* Clean out command structure on command error out */
+        memset(&idiag, 0, sizeof(idiag));
+        return -EINVAL;
+}
+
+/**
+ * lpfc_idiag_mbxacc_get_setup - idiag debugfs get mailbox access setup
+ * @phba: Pointer to HBA context object.
+ * @pbuffer: Pointer to data buffer.
+ *
+ * Description:
+ * This routine gets the driver mailbox access debugfs setup information.
+ *
+ * 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 int
+lpfc_idiag_mbxacc_get_setup(struct lpfc_hba *phba, char *pbuffer)
+{
+        uint32_t mbx_dump_map, mbx_dump_cnt, mbx_word_cnt, mbx_mbox_cmd;
+        int len = 0;
+
+        mbx_mbox_cmd = idiag.cmd.data[IDIAG_MBXACC_MBCMD_INDX];
+        mbx_dump_map = idiag.cmd.data[IDIAG_MBXACC_DPMAP_INDX];
+        mbx_dump_cnt = idiag.cmd.data[IDIAG_MBXACC_DPCNT_INDX];
+        mbx_word_cnt = idiag.cmd.data[IDIAG_MBXACC_WDCNT_INDX];
+
+        len += snprintf(pbuffer+len, LPFC_MBX_ACC_BUF_SIZE-len,
+                        "mbx_dump_map: 0x%08x\n", mbx_dump_map);
+        len += snprintf(pbuffer+len, LPFC_MBX_ACC_BUF_SIZE-len,
+                        "mbx_dump_cnt: %04d\n", mbx_dump_cnt);
+        len += snprintf(pbuffer+len, LPFC_MBX_ACC_BUF_SIZE-len,
+                        "mbx_word_cnt: %04d\n", mbx_word_cnt);
+        len += snprintf(pbuffer+len, LPFC_MBX_ACC_BUF_SIZE-len,
+                        "mbx_mbox_cmd: 0x%02x\n", mbx_mbox_cmd);
+
+        return len;
+}
+
+/**
+ * lpfc_idiag_mbxacc_read - idiag debugfs read on mailbox access
+ * @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 driver mailbox access debugfs setup
+ * information.
+ *
+ * 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_mbxacc_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;
+        char *pbuffer;
+        int len = 0;
+
+        /* This is a user read operation */
+        debug->op = LPFC_IDIAG_OP_RD;
+
+        if (!debug->buffer)
+                debug->buffer = kmalloc(LPFC_MBX_ACC_BUF_SIZE, GFP_KERNEL);
+        if (!debug->buffer)
+                return 0;
+        pbuffer = debug->buffer;
+
+        if (*ppos)
+                return 0;
+
+        if ((idiag.cmd.opcode != LPFC_IDIAG_CMD_MBXACC_DP) &&
+            (idiag.cmd.opcode != LPFC_IDIAG_BSG_MBXACC_DP))
+                return 0;
+
+        len = lpfc_idiag_mbxacc_get_setup(phba, pbuffer);
+
+        return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
+}
+
+/**
+ * lpfc_idiag_mbxacc_write - Syntax check and set up idiag mbxacc 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 driver mailbox command (dump) and sets up the
+ * necessary states in the idiag command struct 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_mbxacc_write(struct file *file, const char __user *buf,
+                        size_t nbytes, loff_t *ppos)
+{
+        struct lpfc_debug *debug = file->private_data;
+        uint32_t mbx_dump_map, mbx_dump_cnt, mbx_word_cnt, mbx_mbox_cmd;
+        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 */
+        mbx_mbox_cmd = idiag.cmd.data[IDIAG_MBXACC_MBCMD_INDX];
+        mbx_dump_map = idiag.cmd.data[IDIAG_MBXACC_DPMAP_INDX];
+        mbx_dump_cnt = idiag.cmd.data[IDIAG_MBXACC_DPCNT_INDX];
+        mbx_word_cnt = idiag.cmd.data[IDIAG_MBXACC_WDCNT_INDX];
+
+        if (idiag.cmd.opcode == LPFC_IDIAG_CMD_MBXACC_DP) {
+                if (!(mbx_dump_map & LPFC_MBX_DMP_MBX_ALL))
+                        goto error_out;
+                if ((mbx_dump_map & ~LPFC_MBX_DMP_MBX_ALL) &&
+                    (mbx_dump_map != LPFC_MBX_DMP_ALL))
+                        goto error_out;
+                if (mbx_word_cnt > sizeof(MAILBOX_t))
+                        goto error_out;
+        } else if (idiag.cmd.opcode == LPFC_IDIAG_BSG_MBXACC_DP) {
+                if (!(mbx_dump_map & LPFC_BSG_DMP_MBX_ALL))
+                        goto error_out;
+                if ((mbx_dump_map & ~LPFC_BSG_DMP_MBX_ALL) &&
+                    (mbx_dump_map != LPFC_MBX_DMP_ALL))
+                        goto error_out;
+                if (mbx_word_cnt > (BSG_MBOX_SIZE)/4)
+                        goto error_out;
+                if (mbx_mbox_cmd != 0x9b)
+                        goto error_out;
+        } else
+                goto error_out;
+
+        if (mbx_word_cnt == 0)
+                goto error_out;
+        if (rc != LPFC_MBX_DMP_ARG)
+                goto error_out;
+        if (mbx_mbox_cmd & ~0xff)
+                goto error_out;
+
+        /* condition for stop mailbox dump */
+        if (mbx_dump_cnt == 0)
+                goto reset_out;
+
+        return nbytes;
+
+reset_out:
+        /* Clean out command structure on command error out */
+        memset(&idiag, 0, sizeof(idiag));
+        return nbytes;
+
+error_out:
+        /* Clean out command structure on command error out */
+        memset(&idiag, 0, sizeof(idiag));
+        return -EINVAL;
+}
+
+/**
+ * lpfc_idiag_extacc_avail_get - get the available extents information
+ * @phba: pointer to lpfc hba data structure.
+ * @pbuffer: pointer to internal buffer.
+ * @len: length into the internal buffer data has been copied.
+ *
+ * Description:
+ * This routine is to get the available extent information.
+ *
+ * Returns:
+ * overall lenth of the data read into the internal buffer.
+ **/
+static int
+lpfc_idiag_extacc_avail_get(struct lpfc_hba *phba, char *pbuffer, int len)
+{
+        uint16_t ext_cnt, ext_size;
+
+        len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
+                        "\nAvailable Extents Information:\n");
+
+        len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
+                        "\tPort Available VPI extents: ");
+        lpfc_sli4_get_avail_extnt_rsrc(phba, LPFC_RSC_TYPE_FCOE_VPI,
+                                       &ext_cnt, &ext_size);
+        len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
+                        "Count %3d, Size %3d\n", ext_cnt, ext_size);
+
+        len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
+                        "\tPort Available VFI extents: ");
+        lpfc_sli4_get_avail_extnt_rsrc(phba, LPFC_RSC_TYPE_FCOE_VFI,
+                                       &ext_cnt, &ext_size);
+        len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
+                        "Count %3d, Size %3d\n", ext_cnt, ext_size);
+
+        len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
+                        "\tPort Available RPI extents: ");
+        lpfc_sli4_get_avail_extnt_rsrc(phba, LPFC_RSC_TYPE_FCOE_RPI,
+                                       &ext_cnt, &ext_size);
+        len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
+                        "Count %3d, Size %3d\n", ext_cnt, ext_size);
+
+        len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
+                        "\tPort Available XRI extents: ");
+        lpfc_sli4_get_avail_extnt_rsrc(phba, LPFC_RSC_TYPE_FCOE_XRI,
+                                       &ext_cnt, &ext_size);
+        len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
+                        "Count %3d, Size %3d\n", ext_cnt, ext_size);
+
+        return len;
+}
+
+/**
+ * lpfc_idiag_extacc_alloc_get - get the allocated extents information
+ * @phba: pointer to lpfc hba data structure.
+ * @pbuffer: pointer to internal buffer.
+ * @len: length into the internal buffer data has been copied.
+ *
+ * Description:
+ * This routine is to get the allocated extent information.
+ *
+ * Returns:
+ * overall lenth of the data read into the internal buffer.
+ **/
+static int
+lpfc_idiag_extacc_alloc_get(struct lpfc_hba *phba, char *pbuffer, int len)
+{
+        uint16_t ext_cnt, ext_size;
+        int rc;
+
+        len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
+                        "\nAllocated Extents Information:\n");
+
+        len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
+                        "\tHost Allocated VPI extents: ");
+        rc = lpfc_sli4_get_allocated_extnts(phba, LPFC_RSC_TYPE_FCOE_VPI,
+                                            &ext_cnt, &ext_size);
+        if (!rc)
+                len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
+                                "Port %d Extent %3d, Size %3d\n",
+                                phba->brd_no, ext_cnt, ext_size);
+        else
+                len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
+                                "N/A\n");
+
+        len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
+                        "\tHost Allocated VFI extents: ");
+        rc = lpfc_sli4_get_allocated_extnts(phba, LPFC_RSC_TYPE_FCOE_VFI,
+                                            &ext_cnt, &ext_size);
+        if (!rc)
+                len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
+                                "Port %d Extent %3d, Size %3d\n",
+                                phba->brd_no, ext_cnt, ext_size);
+        else
+                len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
+                                "N/A\n");
+
+        len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
+                        "\tHost Allocated RPI extents: ");
+        rc = lpfc_sli4_get_allocated_extnts(phba, LPFC_RSC_TYPE_FCOE_RPI,
+                                            &ext_cnt, &ext_size);
+        if (!rc)
+                len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
+                                "Port %d Extent %3d, Size %3d\n",
+                                phba->brd_no, ext_cnt, ext_size);
+        else
+                len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
+                                "N/A\n");
+
+        len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
+                        "\tHost Allocated XRI extents: ");
+        rc = lpfc_sli4_get_allocated_extnts(phba, LPFC_RSC_TYPE_FCOE_XRI,
+                                            &ext_cnt, &ext_size);
+        if (!rc)
+                len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
+                                "Port %d Extent %3d, Size %3d\n",
+                                phba->brd_no, ext_cnt, ext_size);
+        else
+                len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
+                                "N/A\n");
+
+        return len;
+}
+
+/**
+ * lpfc_idiag_extacc_drivr_get - get driver extent information
+ * @phba: pointer to lpfc hba data structure.
+ * @pbuffer: pointer to internal buffer.
+ * @len: length into the internal buffer data has been copied.
+ *
+ * Description:
+ * This routine is to get the driver extent information.
+ *
+ * Returns:
+ * overall lenth of the data read into the internal buffer.
+ **/
+static int
+lpfc_idiag_extacc_drivr_get(struct lpfc_hba *phba, char *pbuffer, int len)
+{
+        struct lpfc_rsrc_blks *rsrc_blks;
+        int index;
+
+        len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
+                        "\nDriver Extents Information:\n");
+
+        len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
+                        "\tVPI extents:\n");
+        index = 0;
+        list_for_each_entry(rsrc_blks, &phba->lpfc_vpi_blk_list, list) {
+                len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
+                                "\t\tBlock %3d: Start %4d, Count %4d\n",
+                                index, rsrc_blks->rsrc_start,
+                                rsrc_blks->rsrc_size);
+                index++;
+        }
+        len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
+                        "\tVFI extents:\n");
+        index = 0;
+        list_for_each_entry(rsrc_blks, &phba->sli4_hba.lpfc_vfi_blk_list,
+                            list) {
+                len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
+                                "\t\tBlock %3d: Start %4d, Count %4d\n",
+                                index, rsrc_blks->rsrc_start,
+                                rsrc_blks->rsrc_size);
+                index++;
+        }
+
+        len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
+                        "\tRPI extents:\n");
+        index = 0;
+        list_for_each_entry(rsrc_blks, &phba->sli4_hba.lpfc_rpi_blk_list,
+                            list) {
+                len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
+                                "\t\tBlock %3d: Start %4d, Count %4d\n",
+                                index, rsrc_blks->rsrc_start,
+                                rsrc_blks->rsrc_size);
+                index++;
+        }
+
+        len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
+                        "\tXRI extents:\n");
+        index = 0;
+        list_for_each_entry(rsrc_blks, &phba->sli4_hba.lpfc_xri_blk_list,
+                            list) {
+                len += snprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
+                                "\t\tBlock %3d: Start %4d, Count %4d\n",
+                                index, rsrc_blks->rsrc_start,
+                                rsrc_blks->rsrc_size);
+                index++;
+        }
+
+        return len;
+}
+
+/**
+ * lpfc_idiag_extacc_write - Syntax check and set up idiag extacc 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 extent information access commands and sets
+ * up the necessary states in the idiag command struct 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_extacc_write(struct file *file, const char __user *buf,
+                        size_t nbytes, loff_t *ppos)
+{
+        struct lpfc_debug *debug = file->private_data;
+        uint32_t ext_map;
+        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;
+
+        ext_map = idiag.cmd.data[IDIAG_EXTACC_EXMAP_INDX];
+
+        if (idiag.cmd.opcode != LPFC_IDIAG_CMD_EXTACC_RD)
+                goto error_out;
+        if (rc != LPFC_EXT_ACC_CMD_ARG)
+                goto error_out;
+        if (!(ext_map & LPFC_EXT_ACC_ALL))
+                goto error_out;
+
+        return nbytes;
+error_out:
+        /* Clean out command structure on command error out */
+        memset(&idiag, 0, sizeof(idiag));
+        return -EINVAL;
+}
+
+/**
+ * lpfc_idiag_extacc_read - idiag debugfs read access to extent information
+ * @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 proper extent information according to
+ * the idiag command, and copies to user @buf.
+ *
+ * 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_extacc_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;
+        char *pbuffer;
+        uint32_t ext_map;
+        int len = 0;
+
+        /* This is a user read operation */
+        debug->op = LPFC_IDIAG_OP_RD;
+
+        if (!debug->buffer)
+                debug->buffer = kmalloc(LPFC_EXT_ACC_BUF_SIZE, GFP_KERNEL);
+        if (!debug->buffer)
+                return 0;
+        pbuffer = debug->buffer;
+        if (*ppos)
+                return 0;
+        if (idiag.cmd.opcode != LPFC_IDIAG_CMD_EXTACC_RD)
+                return 0;
+
+        ext_map = idiag.cmd.data[IDIAG_EXTACC_EXMAP_INDX];
+        if (ext_map & LPFC_EXT_ACC_AVAIL)
+                len = lpfc_idiag_extacc_avail_get(phba, pbuffer, len);
+        if (ext_map & LPFC_EXT_ACC_ALLOC)
+                len = lpfc_idiag_extacc_alloc_get(phba, pbuffer, len);
+        if (ext_map & LPFC_EXT_ACC_DRIVR)
+                len = lpfc_idiag_extacc_drivr_get(phba, pbuffer, len);
+
+        return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
+}
+
 #undef lpfc_debugfs_op_disc_trc
 static const struct file_operations lpfc_debugfs_op_disc_trc = {
         .owner =        THIS_MODULE,
@@ -2420,6 +3405,16 @@ static const struct file_operations lpfc_idiag_op_pciCfg = {
         .release =      lpfc_idiag_cmd_release,
 };
 
+#undef lpfc_idiag_op_barAcc
+static const struct file_operations lpfc_idiag_op_barAcc = {
+        .owner =        THIS_MODULE,
+        .open =         lpfc_idiag_open,
+        .llseek =       lpfc_debugfs_lseek,
+        .read =         lpfc_idiag_baracc_read,
+        .write =        lpfc_idiag_baracc_write,
+        .release =      lpfc_idiag_cmd_release,
+};
+
 #undef lpfc_idiag_op_queInfo
 static const struct file_operations lpfc_idiag_op_queInfo = {
         .owner =        THIS_MODULE,
@@ -2428,7 +3423,7 @@ static const struct file_operations lpfc_idiag_op_queInfo = {
         .release =      lpfc_idiag_release,
 };
 
-#undef lpfc_idiag_op_queacc
+#undef lpfc_idiag_op_queAcc
 static const struct file_operations lpfc_idiag_op_queAcc = {
         .owner =        THIS_MODULE,
         .open =         lpfc_idiag_open,
@@ -2438,7 +3433,7 @@ static const struct file_operations lpfc_idiag_op_queAcc = {
         .release =      lpfc_idiag_cmd_release,
 };
 
-#undef lpfc_idiag_op_drbacc
+#undef lpfc_idiag_op_drbAcc
 static const struct file_operations lpfc_idiag_op_drbAcc = {
         .owner =        THIS_MODULE,
         .open =         lpfc_idiag_open,
@@ -2448,8 +3443,234 @@ static const struct file_operations lpfc_idiag_op_drbAcc = {
         .release =      lpfc_idiag_cmd_release,
 };
 
+#undef lpfc_idiag_op_ctlAcc
+static const struct file_operations lpfc_idiag_op_ctlAcc = {
+        .owner =        THIS_MODULE,
+        .open =         lpfc_idiag_open,
+        .llseek =       lpfc_debugfs_lseek,
+        .read =         lpfc_idiag_ctlacc_read,
+        .write =        lpfc_idiag_ctlacc_write,
+        .release =      lpfc_idiag_cmd_release,
+};
+
+#undef lpfc_idiag_op_mbxAcc
+static const struct file_operations lpfc_idiag_op_mbxAcc = {
+        .owner =        THIS_MODULE,
+        .open =         lpfc_idiag_open,
+        .llseek =       lpfc_debugfs_lseek,
+        .read =         lpfc_idiag_mbxacc_read,
+        .write =        lpfc_idiag_mbxacc_write,
+        .release =      lpfc_idiag_cmd_release,
+};
+
+#undef lpfc_idiag_op_extAcc
+static const struct file_operations lpfc_idiag_op_extAcc = {
+        .owner =        THIS_MODULE,
+        .open =         lpfc_idiag_open,
+        .llseek =       lpfc_debugfs_lseek,
+        .read =         lpfc_idiag_extacc_read,
+        .write =        lpfc_idiag_extacc_write,
+        .release =      lpfc_idiag_cmd_release,
+};
+
 #endif
 
+/* lpfc_idiag_mbxacc_dump_bsg_mbox - idiag debugfs dump bsg mailbox command
+ * @phba: Pointer to HBA context object.
+ * @dmabuf: Pointer to a DMA buffer descriptor.
+ *
+ * Description:
+ * This routine dump a bsg pass-through non-embedded mailbox command with
+ * external buffer.
+ **/
+void
+lpfc_idiag_mbxacc_dump_bsg_mbox(struct lpfc_hba *phba, enum nemb_type nemb_tp,
+                                enum mbox_type mbox_tp, enum dma_type dma_tp,
+                                enum sta_type sta_tp,
+                                struct lpfc_dmabuf *dmabuf, uint32_t ext_buf)
+{
+#ifdef CONFIG_SCSI_LPFC_DEBUG_FS
+        uint32_t *mbx_mbox_cmd, *mbx_dump_map, *mbx_dump_cnt, *mbx_word_cnt;
+        char line_buf[LPFC_MBX_ACC_LBUF_SZ];
+        int len = 0;
+        uint32_t do_dump = 0;
+        uint32_t *pword;
+        uint32_t i;
+
+        if (idiag.cmd.opcode != LPFC_IDIAG_BSG_MBXACC_DP)
+                return;
+
+        mbx_mbox_cmd = &idiag.cmd.data[IDIAG_MBXACC_MBCMD_INDX];
+        mbx_dump_map = &idiag.cmd.data[IDIAG_MBXACC_DPMAP_INDX];
+        mbx_dump_cnt = &idiag.cmd.data[IDIAG_MBXACC_DPCNT_INDX];
+        mbx_word_cnt = &idiag.cmd.data[IDIAG_MBXACC_WDCNT_INDX];
+
+        if (!(*mbx_dump_map & LPFC_MBX_DMP_ALL) ||
+            (*mbx_dump_cnt == 0) ||
+            (*mbx_word_cnt == 0))
+                return;
+
+        if (*mbx_mbox_cmd != 0x9B)
+                return;
+
+        if ((mbox_tp == mbox_rd) && (dma_tp == dma_mbox)) {
+                if (*mbx_dump_map & LPFC_BSG_DMP_MBX_RD_MBX) {
+                        do_dump |= LPFC_BSG_DMP_MBX_RD_MBX;
+                        printk(KERN_ERR "\nRead mbox command (x%x), "
+                               "nemb:0x%x, extbuf_cnt:%d:\n",
+                               sta_tp, nemb_tp, ext_buf);
+                }
+        }
+        if ((mbox_tp == mbox_rd) && (dma_tp == dma_ebuf)) {
+                if (*mbx_dump_map & LPFC_BSG_DMP_MBX_RD_BUF) {
+                        do_dump |= LPFC_BSG_DMP_MBX_RD_BUF;
+                        printk(KERN_ERR "\nRead mbox buffer (x%x), "
+                               "nemb:0x%x, extbuf_seq:%d:\n",
+                               sta_tp, nemb_tp, ext_buf);
+                }
+        }
+        if ((mbox_tp == mbox_wr) && (dma_tp == dma_mbox)) {
+                if (*mbx_dump_map & LPFC_BSG_DMP_MBX_WR_MBX) {
+                        do_dump |= LPFC_BSG_DMP_MBX_WR_MBX;
+                        printk(KERN_ERR "\nWrite mbox command (x%x), "
+                               "nemb:0x%x, extbuf_cnt:%d:\n",
+                               sta_tp, nemb_tp, ext_buf);
+                }
+        }
+        if ((mbox_tp == mbox_wr) && (dma_tp == dma_ebuf)) {
+                if (*mbx_dump_map & LPFC_BSG_DMP_MBX_WR_BUF) {
+                        do_dump |= LPFC_BSG_DMP_MBX_WR_BUF;
+                        printk(KERN_ERR "\nWrite mbox buffer (x%x), "
+                               "nemb:0x%x, extbuf_seq:%d:\n",
+                               sta_tp, nemb_tp, ext_buf);
+                }
+        }
+
+        /* dump buffer content */
+        if (do_dump) {
+                pword = (uint32_t *)dmabuf->virt;
+                for (i = 0; i < *mbx_word_cnt; i++) {
+                        if (!(i % 8)) {
+                                if (i != 0)
+                                        printk(KERN_ERR "%s\n", line_buf);
+                                len = 0;
+                                len += snprintf(line_buf+len,
+                                                LPFC_MBX_ACC_LBUF_SZ-len,
+                                                "%03d: ", i);
+                        }
+                        len += snprintf(line_buf+len, LPFC_MBX_ACC_LBUF_SZ-len,
+                                        "%08x ", (uint32_t)*pword);
+                        pword++;
+                }
+                if ((i - 1) % 8)
+                        printk(KERN_ERR "%s\n", line_buf);
+                (*mbx_dump_cnt)--;
+        }
+
+        /* Clean out command structure on reaching dump count */
+        if (*mbx_dump_cnt == 0)
+                memset(&idiag, 0, sizeof(idiag));
+        return;
+#endif
+}
+
+/* lpfc_idiag_mbxacc_dump_issue_mbox - idiag debugfs dump issue mailbox command
+ * @phba: Pointer to HBA context object.
+ * @dmabuf: Pointer to a DMA buffer descriptor.
+ *
+ * Description:
+ * This routine dump a pass-through non-embedded mailbox command from issue
+ * mailbox command.
+ **/
+void
+lpfc_idiag_mbxacc_dump_issue_mbox(struct lpfc_hba *phba, MAILBOX_t *pmbox)
+{
+#ifdef CONFIG_SCSI_LPFC_DEBUG_FS
+        uint32_t *mbx_dump_map, *mbx_dump_cnt, *mbx_word_cnt, *mbx_mbox_cmd;
+        char line_buf[LPFC_MBX_ACC_LBUF_SZ];
+        int len = 0;
+        uint32_t *pword;
+        uint8_t *pbyte;
+        uint32_t i, j;
+
+        if (idiag.cmd.opcode != LPFC_IDIAG_CMD_MBXACC_DP)
+                return;
+
+        mbx_mbox_cmd = &idiag.cmd.data[IDIAG_MBXACC_MBCMD_INDX];
+        mbx_dump_map = &idiag.cmd.data[IDIAG_MBXACC_DPMAP_INDX];
+        mbx_dump_cnt = &idiag.cmd.data[IDIAG_MBXACC_DPCNT_INDX];
+        mbx_word_cnt = &idiag.cmd.data[IDIAG_MBXACC_WDCNT_INDX];
+
+        if (!(*mbx_dump_map & LPFC_MBX_DMP_MBX_ALL) ||
+            (*mbx_dump_cnt == 0) ||
+            (*mbx_word_cnt == 0))
+                return;
+
+        if ((*mbx_mbox_cmd != LPFC_MBX_ALL_CMD) &&
+            (*mbx_mbox_cmd != pmbox->mbxCommand))
+                return;
+
+        /* dump buffer content */
+        if (*mbx_dump_map & LPFC_MBX_DMP_MBX_WORD) {
+                printk(KERN_ERR "Mailbox command:0x%x dump by word:\n",
+                       pmbox->mbxCommand);
+                pword = (uint32_t *)pmbox;
+                for (i = 0; i < *mbx_word_cnt; i++) {
+                        if (!(i % 8)) {
+                                if (i != 0)
+                                        printk(KERN_ERR "%s\n", line_buf);
+                                len = 0;
+                                memset(line_buf, 0, LPFC_MBX_ACC_LBUF_SZ);
+                                len += snprintf(line_buf+len,
+                                                LPFC_MBX_ACC_LBUF_SZ-len,
+                                                "%03d: ", i);
+                        }
+                        len += snprintf(line_buf+len, LPFC_MBX_ACC_LBUF_SZ-len,
+                                        "%08x ",
+                                        ((uint32_t)*pword) & 0xffffffff);
+                        pword++;
+                }
+                if ((i - 1) % 8)
+                        printk(KERN_ERR "%s\n", line_buf);
+                printk(KERN_ERR "\n");
+        }
+        if (*mbx_dump_map & LPFC_MBX_DMP_MBX_BYTE) {
+                printk(KERN_ERR "Mailbox command:0x%x dump by byte:\n",
+                       pmbox->mbxCommand);
+                pbyte = (uint8_t *)pmbox;
+                for (i = 0; i < *mbx_word_cnt; i++) {
+                        if (!(i % 8)) {
+                                if (i != 0)
+                                        printk(KERN_ERR "%s\n", line_buf);
+                                len = 0;
+                                memset(line_buf, 0, LPFC_MBX_ACC_LBUF_SZ);
+                                len += snprintf(line_buf+len,
+                                                LPFC_MBX_ACC_LBUF_SZ-len,
+                                                "%03d: ", i);
+                        }
+                        for (j = 0; j < 4; j++) {
+                                len += snprintf(line_buf+len,
+                                                LPFC_MBX_ACC_LBUF_SZ-len,
+                                                "%02x",
+                                                ((uint8_t)*pbyte) & 0xff);
+                                pbyte++;
+                        }
+                        len += snprintf(line_buf+len,
+                                        LPFC_MBX_ACC_LBUF_SZ-len, " ");
+                }
+                if ((i - 1) % 8)
+                        printk(KERN_ERR "%s\n", line_buf);
+                printk(KERN_ERR "\n");
+        }
+        (*mbx_dump_cnt)--;
+
+        /* Clean out command structure on reaching dump count */
+        if (*mbx_dump_cnt == 0)
+                memset(&idiag, 0, sizeof(idiag));
+        return;
+#endif
+}
+
 /**
  * lpfc_debugfs_initialize - Initialize debugfs for a vport
  * @vport: The vport pointer to initialize.
@@ -2673,7 +3894,7 @@ lpfc_debugfs_initialize(struct lpfc_vport *vport)
                                  vport, &lpfc_debugfs_op_nodelist);
         if (!vport->debug_nodelist) {
                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
-                                 "0409 Can't create debugfs nodelist\n");
+                                 "2985 Can't create debugfs nodelist\n");
                 goto debug_failed;
         }
 
@@ -2710,6 +3931,20 @@ lpfc_debugfs_initialize(struct lpfc_vport *vport)
                 idiag.offset.last_rd = 0;
         }
 
+        /* iDiag PCI BAR access */
+        snprintf(name, sizeof(name), "barAcc");
+        if (!phba->idiag_bar_acc) {
+                phba->idiag_bar_acc =
+                        debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
+                                phba->idiag_root, phba, &lpfc_idiag_op_barAcc);
+                if (!phba->idiag_bar_acc) {
+                        lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
+                                        "3056 Can't create idiag debugfs\n");
+                        goto debug_failed;
+                }
+                idiag.offset.last_rd = 0;
+        }
+
         /* iDiag get PCI function queue information */
         snprintf(name, sizeof(name), "queInfo");
         if (!phba->idiag_que_info) {
@@ -2749,6 +3984,50 @@ lpfc_debugfs_initialize(struct lpfc_vport *vport)
                 }
         }
 
+        /* iDiag access PCI function control registers */
+        snprintf(name, sizeof(name), "ctlAcc");
+        if (!phba->idiag_ctl_acc) {
+                phba->idiag_ctl_acc =
+                        debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
+                                phba->idiag_root, phba, &lpfc_idiag_op_ctlAcc);
+                if (!phba->idiag_ctl_acc) {
+                        lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
+                                         "2981 Can't create idiag debugfs\n");
+                        goto debug_failed;
+                }
+        }
+
+        /* iDiag access mbox commands */
+        snprintf(name, sizeof(name), "mbxAcc");
+        if (!phba->idiag_mbx_acc) {
+                phba->idiag_mbx_acc =
+                        debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
+                                phba->idiag_root, phba, &lpfc_idiag_op_mbxAcc);
+                if (!phba->idiag_mbx_acc) {
+                        lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
+                                        "2980 Can't create idiag debugfs\n");
+                        goto debug_failed;
+                }
+        }
+
+        /* iDiag extents access commands */
+        if (phba->sli4_hba.extents_in_use) {
+                snprintf(name, sizeof(name), "extAcc");
+                if (!phba->idiag_ext_acc) {
+                        phba->idiag_ext_acc =
+                                debugfs_create_file(name,
+                                                    S_IFREG|S_IRUGO|S_IWUSR,
+                                                    phba->idiag_root, phba,
+                                                    &lpfc_idiag_op_extAcc);
+                        if (!phba->idiag_ext_acc) {
+                                lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
+                                                "2986 Cant create "
+                                                "idiag debugfs\n");
+                                goto debug_failed;
+                        }
+                }
+        }
+
 debug_failed:
         return;
 #endif
@@ -2783,7 +4062,6 @@ lpfc_debugfs_terminate(struct lpfc_vport *vport)
                 debugfs_remove(vport->debug_nodelist); /* nodelist */
                 vport->debug_nodelist = NULL;
         }
-
         if (vport->vport_debugfs_root) {
                 debugfs_remove(vport->vport_debugfs_root); /* vportX */
                 vport->vport_debugfs_root = NULL;
@@ -2827,6 +4105,21 @@ lpfc_debugfs_terminate(struct lpfc_vport *vport)
                  * iDiag release
                  */
                 if (phba->sli_rev == LPFC_SLI_REV4) {
+                        if (phba->idiag_ext_acc) {
+                                /* iDiag extAcc */
+                                debugfs_remove(phba->idiag_ext_acc);
+                                phba->idiag_ext_acc = NULL;
+                        }
+                        if (phba->idiag_mbx_acc) {
+                                /* iDiag mbxAcc */
+                                debugfs_remove(phba->idiag_mbx_acc);
+                                phba->idiag_mbx_acc = NULL;
+                        }
+                        if (phba->idiag_ctl_acc) {
+                                /* iDiag ctlAcc */
+                                debugfs_remove(phba->idiag_ctl_acc);
+                                phba->idiag_ctl_acc = NULL;
+                        }
                         if (phba->idiag_drb_acc) {
                                 /* iDiag drbAcc */
                                 debugfs_remove(phba->idiag_drb_acc);
@@ -2842,6 +4135,11 @@ lpfc_debugfs_terminate(struct lpfc_vport *vport)
                                 debugfs_remove(phba->idiag_que_info);
                                 phba->idiag_que_info = NULL;
                         }
+                        if (phba->idiag_bar_acc) {
+                                /* iDiag barAcc */
+                                debugfs_remove(phba->idiag_bar_acc);
+                                phba->idiag_bar_acc = NULL;
+                        }
                         if (phba->idiag_pci_cfg) {
                                 /* iDiag pciCfg */
                                 debugfs_remove(phba->idiag_pci_cfg);
diff --git a/drivers/scsi/lpfc/lpfc_debugfs.h b/drivers/scsi/lpfc/lpfc_debugfs.h
index 6525a5e62d27..f83bd944edd8 100644
--- a/drivers/scsi/lpfc/lpfc_debugfs.h
+++ b/drivers/scsi/lpfc/lpfc_debugfs.h
@@ -39,14 +39,51 @@
 /* hbqinfo output buffer size */
 #define LPFC_HBQINFO_SIZE 8192
 
+/*
+ * For SLI4 iDiag debugfs diagnostics tool
+ */
+
 /* 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)
 
+#define IDIAG_PCICFG_WHERE_INDX 0
+#define IDIAG_PCICFG_COUNT_INDX 1
+#define IDIAG_PCICFG_VALUE_INDX 2
+
+/* barAcc */
+#define LPFC_PCI_BAR_BROWSE 0xffff
+#define LPFC_PCI_BAR_RD_CMD_ARG 3
+#define LPFC_PCI_BAR_WR_CMD_ARG 3
+
+#define LPFC_PCI_IF0_BAR0_SIZE (1024 *  16)
+#define LPFC_PCI_IF0_BAR1_SIZE (1024 * 128)
+#define LPFC_PCI_IF0_BAR2_SIZE (1024 * 128)
+#define LPFC_PCI_IF2_BAR0_SIZE (1024 *  32)
+
+#define LPFC_PCI_BAR_RD_BUF_SIZE 4096
+#define LPFC_PCI_BAR_RD_SIZE (LPFC_PCI_BAR_RD_BUF_SIZE/4)
+
+#define LPFC_PCI_IF0_BAR0_RD_SIZE (LPFC_PCI_IF0_BAR0_SIZE/4)
+#define LPFC_PCI_IF0_BAR1_RD_SIZE (LPFC_PCI_IF0_BAR1_SIZE/4)
+#define LPFC_PCI_IF0_BAR2_RD_SIZE (LPFC_PCI_IF0_BAR2_SIZE/4)
+#define LPFC_PCI_IF2_BAR0_RD_SIZE (LPFC_PCI_IF2_BAR0_SIZE/4)
+
+#define IDIAG_BARACC_BAR_NUM_INDX 0
+#define IDIAG_BARACC_OFF_SET_INDX 1
+#define IDIAG_BARACC_ACC_MOD_INDX 2
+#define IDIAG_BARACC_REG_VAL_INDX 2
+#define IDIAG_BARACC_BAR_SZE_INDX 3
+
+#define IDIAG_BARACC_BAR_0 0
+#define IDIAG_BARACC_BAR_1 1
+#define IDIAG_BARACC_BAR_2 2
+
+#define SINGLE_WORD 1
+
 /* queue info */
 #define LPFC_QUE_INFO_GET_BUF_SIZE 4096
 
@@ -63,7 +100,14 @@
 #define LPFC_IDIAG_WQ 4
 #define LPFC_IDIAG_RQ 5
 
-/* doorbell acc */
+#define IDIAG_QUEACC_QUETP_INDX 0
+#define IDIAG_QUEACC_QUEID_INDX 1
+#define IDIAG_QUEACC_INDEX_INDX 2
+#define IDIAG_QUEACC_COUNT_INDX 3
+#define IDIAG_QUEACC_OFFST_INDX 4
+#define IDIAG_QUEACC_VALUE_INDX 5
+
+/* doorbell register acc */
 #define LPFC_DRB_ACC_ALL 0xffff
 #define LPFC_DRB_ACC_RD_CMD_ARG 1
 #define LPFC_DRB_ACC_WR_CMD_ARG 2
@@ -76,6 +120,67 @@
 
 #define LPFC_DRB_MAX  4
 
+#define IDIAG_DRBACC_REGID_INDX 0
+#define IDIAG_DRBACC_VALUE_INDX 1
+
+/* control register acc */
+#define LPFC_CTL_ACC_ALL 0xffff
+#define LPFC_CTL_ACC_RD_CMD_ARG 1
+#define LPFC_CTL_ACC_WR_CMD_ARG 2
+#define LPFC_CTL_ACC_BUF_SIZE 256
+
+#define LPFC_CTL_PORT_SEM  1
+#define LPFC_CTL_PORT_STA  2
+#define LPFC_CTL_PORT_CTL  3
+#define LPFC_CTL_PORT_ER1  4
+#define LPFC_CTL_PORT_ER2  5
+#define LPFC_CTL_PDEV_CTL  6
+
+#define LPFC_CTL_MAX  6
+
+#define IDIAG_CTLACC_REGID_INDX 0
+#define IDIAG_CTLACC_VALUE_INDX 1
+
+/* mailbox access */
+#define LPFC_MBX_DMP_ARG 4
+
+#define LPFC_MBX_ACC_BUF_SIZE 512
+#define LPFC_MBX_ACC_LBUF_SZ 128
+
+#define LPFC_MBX_DMP_MBX_WORD 0x00000001
+#define LPFC_MBX_DMP_MBX_BYTE 0x00000002
+#define LPFC_MBX_DMP_MBX_ALL (LPFC_MBX_DMP_MBX_WORD | LPFC_MBX_DMP_MBX_BYTE)
+
+#define LPFC_BSG_DMP_MBX_RD_MBX 0x00000001
+#define LPFC_BSG_DMP_MBX_RD_BUF 0x00000002
+#define LPFC_BSG_DMP_MBX_WR_MBX 0x00000004
+#define LPFC_BSG_DMP_MBX_WR_BUF 0x00000008
+#define LPFC_BSG_DMP_MBX_ALL (LPFC_BSG_DMP_MBX_RD_MBX | \
+                              LPFC_BSG_DMP_MBX_RD_BUF | \
+                              LPFC_BSG_DMP_MBX_WR_MBX | \
+                              LPFC_BSG_DMP_MBX_WR_BUF)
+
+#define LPFC_MBX_DMP_ALL 0xffff
+#define LPFC_MBX_ALL_CMD 0xff
+
+#define IDIAG_MBXACC_MBCMD_INDX 0
+#define IDIAG_MBXACC_DPMAP_INDX 1
+#define IDIAG_MBXACC_DPCNT_INDX 2
+#define IDIAG_MBXACC_WDCNT_INDX 3
+
+/* extents access */
+#define LPFC_EXT_ACC_CMD_ARG 1
+#define LPFC_EXT_ACC_BUF_SIZE 4096
+
+#define LPFC_EXT_ACC_AVAIL 0x1
+#define LPFC_EXT_ACC_ALLOC 0x2
+#define LPFC_EXT_ACC_DRIVR 0x4
+#define LPFC_EXT_ACC_ALL   (LPFC_EXT_ACC_DRIVR | \
+                            LPFC_EXT_ACC_AVAIL | \
+                            LPFC_EXT_ACC_ALLOC)
+
+#define IDIAG_EXTACC_EXMAP_INDX 0
+
 #define SIZE_U8  sizeof(uint8_t)
 #define SIZE_U16 sizeof(uint16_t)
 #define SIZE_U32 sizeof(uint32_t)
@@ -110,6 +215,11 @@ struct lpfc_idiag_cmd {
 #define LPFC_IDIAG_CMD_PCICFG_ST 0x00000003
 #define LPFC_IDIAG_CMD_PCICFG_CL 0x00000004
 
+#define LPFC_IDIAG_CMD_BARACC_RD 0x00000008
+#define LPFC_IDIAG_CMD_BARACC_WR 0x00000009
+#define LPFC_IDIAG_CMD_BARACC_ST 0x0000000a
+#define LPFC_IDIAG_CMD_BARACC_CL 0x0000000b
+
 #define LPFC_IDIAG_CMD_QUEACC_RD 0x00000011
 #define LPFC_IDIAG_CMD_QUEACC_WR 0x00000012
 #define LPFC_IDIAG_CMD_QUEACC_ST 0x00000013
@@ -119,6 +229,17 @@ struct lpfc_idiag_cmd {
 #define LPFC_IDIAG_CMD_DRBACC_WR 0x00000022
 #define LPFC_IDIAG_CMD_DRBACC_ST 0x00000023
 #define LPFC_IDIAG_CMD_DRBACC_CL 0x00000024
+
+#define LPFC_IDIAG_CMD_CTLACC_RD 0x00000031
+#define LPFC_IDIAG_CMD_CTLACC_WR 0x00000032
+#define LPFC_IDIAG_CMD_CTLACC_ST 0x00000033
+#define LPFC_IDIAG_CMD_CTLACC_CL 0x00000034
+
+#define LPFC_IDIAG_CMD_MBXACC_DP 0x00000041
+#define LPFC_IDIAG_BSG_MBXACC_DP 0x00000042
+
+#define LPFC_IDIAG_CMD_EXTACC_RD 0x00000051
+
         uint32_t data[LPFC_IDIAG_CMD_DATA_SIZE];
 };
 
diff --git a/drivers/scsi/lpfc/lpfc_els.c b/drivers/scsi/lpfc/lpfc_els.c
index 32a084534f3e..023da0e00d38 100644
--- a/drivers/scsi/lpfc/lpfc_els.c
+++ b/drivers/scsi/lpfc/lpfc_els.c
@@ -647,21 +647,15 @@ lpfc_cmpl_els_flogi_fabric(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
                 }
                 lpfc_cleanup_pending_mbox(vport);
 
-                if (phba->sli_rev == LPFC_SLI_REV4)
+                if (phba->sli_rev == LPFC_SLI_REV4) {
                         lpfc_sli4_unreg_all_rpis(vport);
-
-                if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) {
                         lpfc_mbx_unreg_vpi(vport);
                         spin_lock_irq(shost->host_lock);
                         vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
-                        spin_unlock_irq(shost->host_lock);
-                }
-                /*
-                 * If VPI is unreged, driver need to do INIT_VPI
-                 * before re-registering
-                 */
-                if (phba->sli_rev == LPFC_SLI_REV4) {
-                        spin_lock_irq(shost->host_lock);
+                        /*
+                        * If VPI is unreged, driver need to do INIT_VPI
+                        * before re-registering
+                        */
                         vport->fc_flag |= FC_VPORT_NEEDS_INIT_VPI;
                         spin_unlock_irq(shost->host_lock);
                 }
@@ -880,6 +874,8 @@ lpfc_cmpl_els_flogi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
                                         phba->fcf.current_rec.fcf_indx,
                                         irsp->ulpStatus, irsp->un.ulpWord[4],
                                         irsp->ulpTimeout);
+                        lpfc_sli4_set_fcf_flogi_fail(phba,
+                                        phba->fcf.current_rec.fcf_indx);
                         fcf_index = lpfc_sli4_fcf_rr_next_index_get(phba);
                         rc = lpfc_sli4_fcf_rr_next_proc(vport, fcf_index);
                         if (rc)
@@ -1096,11 +1092,14 @@ lpfc_issue_els_flogi(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
                         /* 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 */
-                icmd->ulpCt_h = 1;
-                icmd->ulpCt_l = 0;
+        } 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 */
+                        icmd->ulpCt_h = 1;
+                        icmd->ulpCt_l = 0;
+                } else
+                        sp->cmn.request_multiple_Nport = 0;
         }
 
         if (phba->fc_topology != LPFC_TOPOLOGY_LOOP) {
@@ -3656,7 +3655,8 @@ lpfc_els_rsp_acc(struct lpfc_vport *vport, uint32_t flag,
                 }
 
                 icmd = &elsiocb->iocb;
-                icmd->ulpContext = oldcmd->ulpContext;  /* Xri */
+                icmd->ulpContext = oldcmd->ulpContext;  /* Xri / rx_id */
+                icmd->unsli3.rcvsli3.ox_id = oldcmd->unsli3.rcvsli3.ox_id;
                 pcmd = (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
                 *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
                 pcmd += sizeof(uint32_t);
@@ -3673,7 +3673,8 @@ lpfc_els_rsp_acc(struct lpfc_vport *vport, uint32_t flag,
                         return 1;
 
                 icmd = &elsiocb->iocb;
-                icmd->ulpContext = oldcmd->ulpContext;  /* Xri */
+                icmd->ulpContext = oldcmd->ulpContext;  /* Xri / rx_id */
+                icmd->unsli3.rcvsli3.ox_id = oldcmd->unsli3.rcvsli3.ox_id;
                 pcmd = (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
 
                 if (mbox)
@@ -3695,7 +3696,8 @@ lpfc_els_rsp_acc(struct lpfc_vport *vport, uint32_t flag,
                         return 1;
 
                 icmd = &elsiocb->iocb;
-                icmd->ulpContext = oldcmd->ulpContext; /* Xri */
+                icmd->ulpContext = oldcmd->ulpContext;  /* Xri / rx_id */
+                icmd->unsli3.rcvsli3.ox_id = oldcmd->unsli3.rcvsli3.ox_id;
                 pcmd = (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
 
                 memcpy(pcmd, ((struct lpfc_dmabuf *) oldiocb->context2)->virt,
@@ -3781,7 +3783,8 @@ lpfc_els_rsp_reject(struct lpfc_vport *vport, uint32_t rejectError,
 
         icmd = &elsiocb->iocb;
         oldcmd = &oldiocb->iocb;
-        icmd->ulpContext = oldcmd->ulpContext;  /* Xri */
+        icmd->ulpContext = oldcmd->ulpContext;  /* Xri / rx_id */
+        icmd->unsli3.rcvsli3.ox_id = oldcmd->unsli3.rcvsli3.ox_id;
         pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
 
         *((uint32_t *) (pcmd)) = ELS_CMD_LS_RJT;
@@ -3853,7 +3856,8 @@ lpfc_els_rsp_adisc_acc(struct lpfc_vport *vport, struct lpfc_iocbq *oldiocb,
 
         icmd = &elsiocb->iocb;
         oldcmd = &oldiocb->iocb;
-        icmd->ulpContext = oldcmd->ulpContext;  /* Xri */
+        icmd->ulpContext = oldcmd->ulpContext;  /* Xri / rx_id */
+        icmd->unsli3.rcvsli3.ox_id = oldcmd->unsli3.rcvsli3.ox_id;
 
         /* Xmit ADISC ACC response tag <ulpIoTag> */
         lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
@@ -3931,7 +3935,9 @@ lpfc_els_rsp_prli_acc(struct lpfc_vport *vport, struct lpfc_iocbq *oldiocb,
 
         icmd = &elsiocb->iocb;
         oldcmd = &oldiocb->iocb;
-        icmd->ulpContext = oldcmd->ulpContext;  /* Xri */
+        icmd->ulpContext = oldcmd->ulpContext;  /* Xri / rx_id */
+        icmd->unsli3.rcvsli3.ox_id = oldcmd->unsli3.rcvsli3.ox_id;
+
         /* Xmit PRLI ACC response tag <ulpIoTag> */
         lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
                          "0131 Xmit PRLI ACC response tag x%x xri x%x, "
@@ -4035,7 +4041,9 @@ lpfc_els_rsp_rnid_acc(struct lpfc_vport *vport, uint8_t format,
 
         icmd = &elsiocb->iocb;
         oldcmd = &oldiocb->iocb;
-        icmd->ulpContext = oldcmd->ulpContext;  /* Xri */
+        icmd->ulpContext = oldcmd->ulpContext;  /* Xri / rx_id */
+        icmd->unsli3.rcvsli3.ox_id = oldcmd->unsli3.rcvsli3.ox_id;
+
         /* Xmit RNID ACC response tag <ulpIoTag> */
         lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
                          "0132 Xmit RNID ACC response tag x%x xri x%x\n",
@@ -4163,7 +4171,9 @@ lpfc_els_rsp_echo_acc(struct lpfc_vport *vport, uint8_t *data,
         if (!elsiocb)
                 return 1;
 
-        elsiocb->iocb.ulpContext = oldiocb->iocb.ulpContext;    /* Xri */
+        elsiocb->iocb.ulpContext = oldiocb->iocb.ulpContext;  /* Xri / rx_id */
+        elsiocb->iocb.unsli3.rcvsli3.ox_id = oldiocb->iocb.unsli3.rcvsli3.ox_id;
+
         /* Xmit ECHO ACC response tag <ulpIoTag> */
         lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
                          "2876 Xmit ECHO ACC response tag x%x xri x%x\n",
@@ -5054,13 +5064,15 @@ lpfc_els_rsp_rls_acc(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
         uint8_t *pcmd;
         struct lpfc_iocbq *elsiocb;
         struct lpfc_nodelist *ndlp;
-        uint16_t xri;
+        uint16_t oxid;
+        uint16_t rxid;
         uint32_t cmdsize;
 
         mb = &pmb->u.mb;
 
         ndlp = (struct lpfc_nodelist *) pmb->context2;
-        xri = (uint16_t) ((unsigned long)(pmb->context1));
+        rxid = (uint16_t) ((unsigned long)(pmb->context1) & 0xffff);
+        oxid = (uint16_t) (((unsigned long)(pmb->context1) >> 16) & 0xffff);
         pmb->context1 = NULL;
         pmb->context2 = NULL;
 
@@ -5082,7 +5094,8 @@ lpfc_els_rsp_rls_acc(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
                 return;
 
         icmd = &elsiocb->iocb;
-        icmd->ulpContext = xri;
+        icmd->ulpContext = rxid;
+        icmd->unsli3.rcvsli3.ox_id = oxid;
 
         pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
         *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
@@ -5137,13 +5150,16 @@ lpfc_els_rsp_rps_acc(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
         uint8_t *pcmd;
         struct lpfc_iocbq *elsiocb;
         struct lpfc_nodelist *ndlp;
-        uint16_t xri, status;
+        uint16_t status;
+        uint16_t oxid;
+        uint16_t rxid;
         uint32_t cmdsize;
 
         mb = &pmb->u.mb;
 
         ndlp = (struct lpfc_nodelist *) pmb->context2;
-        xri = (uint16_t) ((unsigned long)(pmb->context1));
+        rxid = (uint16_t) ((unsigned long)(pmb->context1) & 0xffff);
+        oxid = (uint16_t) (((unsigned long)(pmb->context1) >> 16) & 0xffff);
         pmb->context1 = NULL;
         pmb->context2 = NULL;
 
@@ -5165,7 +5181,8 @@ lpfc_els_rsp_rps_acc(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
                 return;
 
         icmd = &elsiocb->iocb;
-        icmd->ulpContext = xri;
+        icmd->ulpContext = rxid;
+        icmd->unsli3.rcvsli3.ox_id = oxid;
 
         pcmd = (uint8_t *) (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
         *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
@@ -5238,8 +5255,9 @@ lpfc_els_rcv_rls(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
         mbox = mempool_alloc(phba->mbox_mem_pool, GFP_ATOMIC);
         if (mbox) {
                 lpfc_read_lnk_stat(phba, mbox);
-                mbox->context1 =
-                    (void *)((unsigned long) cmdiocb->iocb.ulpContext);
+                mbox->context1 = (void *)((unsigned long)
+                        ((cmdiocb->iocb.unsli3.rcvsli3.ox_id << 16) |
+                        cmdiocb->iocb.ulpContext)); /* rx_id */
                 mbox->context2 = lpfc_nlp_get(ndlp);
                 mbox->vport = vport;
                 mbox->mbox_cmpl = lpfc_els_rsp_rls_acc;
@@ -5314,7 +5332,8 @@ lpfc_els_rcv_rtv(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
         pcmd += sizeof(uint32_t); /* Skip past command */
 
         /* use the command's xri in the response */
-        elsiocb->iocb.ulpContext = cmdiocb->iocb.ulpContext;
+        elsiocb->iocb.ulpContext = cmdiocb->iocb.ulpContext;  /* Xri / rx_id */
+        elsiocb->iocb.unsli3.rcvsli3.ox_id = cmdiocb->iocb.unsli3.rcvsli3.ox_id;
 
         rtv_rsp = (struct RTV_RSP *)pcmd;
 
@@ -5399,8 +5418,9 @@ lpfc_els_rcv_rps(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
                 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_ATOMIC);
                 if (mbox) {
                         lpfc_read_lnk_stat(phba, mbox);
-                        mbox->context1 =
-                            (void *)((unsigned long) cmdiocb->iocb.ulpContext);
+                        mbox->context1 = (void *)((unsigned long)
+                                ((cmdiocb->iocb.unsli3.rcvsli3.ox_id << 16) |
+                                cmdiocb->iocb.ulpContext)); /* rx_id */
                         mbox->context2 = lpfc_nlp_get(ndlp);
                         mbox->vport = vport;
                         mbox->mbox_cmpl = lpfc_els_rsp_rps_acc;
@@ -5554,7 +5574,8 @@ lpfc_els_rsp_rpl_acc(struct lpfc_vport *vport, uint16_t cmdsize,
 
         icmd = &elsiocb->iocb;
         oldcmd = &oldiocb->iocb;
-        icmd->ulpContext = oldcmd->ulpContext;  /* Xri */
+        icmd->ulpContext = oldcmd->ulpContext;  /* Xri / rx_id */
+        icmd->unsli3.rcvsli3.ox_id = oldcmd->unsli3.rcvsli3.ox_id;
 
         pcmd = (((struct lpfc_dmabuf *) elsiocb->context2)->virt);
         *((uint32_t *) (pcmd)) = ELS_CMD_ACC;
@@ -6586,7 +6607,7 @@ lpfc_find_vport_by_vpid(struct lpfc_hba *phba, uint16_t vpi)
 {
         struct lpfc_vport *vport;
         unsigned long flags;
-        int i;
+        int i = 0;
 
         /* The physical ports are always vpi 0 - translate is unnecessary. */
         if (vpi > 0) {
@@ -6609,7 +6630,7 @@ lpfc_find_vport_by_vpid(struct lpfc_hba *phba, uint16_t vpi)
 
         spin_lock_irqsave(&phba->hbalock, flags);
         list_for_each_entry(vport, &phba->port_list, listentry) {
-                if (vport->vpi == vpi) {
+                if (vport->vpi == i) {
                         spin_unlock_irqrestore(&phba->hbalock, flags);
                         return vport;
                 }
@@ -7787,6 +7808,7 @@ lpfc_sli4_els_xri_aborted(struct lpfc_hba *phba,
 {
         uint16_t xri = bf_get(lpfc_wcqe_xa_xri, axri);
         uint16_t rxid = bf_get(lpfc_wcqe_xa_remote_xid, axri);
+        uint16_t lxri = 0;
 
         struct lpfc_sglq *sglq_entry = NULL, *sglq_next = NULL;
         unsigned long iflag = 0;
@@ -7815,7 +7837,12 @@ lpfc_sli4_els_xri_aborted(struct lpfc_hba *phba,
                 }
         }
         spin_unlock(&phba->sli4_hba.abts_sgl_list_lock);
-        sglq_entry = __lpfc_get_active_sglq(phba, xri);
+        lxri = lpfc_sli4_xri_inrange(phba, xri);
+        if (lxri == NO_XRI) {
+                spin_unlock_irqrestore(&phba->hbalock, iflag);
+                return;
+        }
+        sglq_entry = __lpfc_get_active_sglq(phba, lxri);
         if (!sglq_entry || (sglq_entry->sli4_xritag != xri)) {
                 spin_unlock_irqrestore(&phba->hbalock, iflag);
                 return;
diff --git a/drivers/scsi/lpfc/lpfc_hbadisc.c b/drivers/scsi/lpfc/lpfc_hbadisc.c
index 18d0dbfda2bc..0b47adf9fee8 100644
--- a/drivers/scsi/lpfc/lpfc_hbadisc.c
+++ b/drivers/scsi/lpfc/lpfc_hbadisc.c
@@ -1109,6 +1109,28 @@ out:
         return;
 }
 
+/**
+ * lpfc_sli4_clear_fcf_rr_bmask
+ * @phba pointer to the struct lpfc_hba for this port.
+ * This fucnction resets the round robin bit mask and clears the
+ * fcf priority list. The list deletions are done while holding the
+ * hbalock. The ON_LIST flag and the FLOGI_FAILED flags are cleared
+ * from the lpfc_fcf_pri record.
+ **/
+void
+lpfc_sli4_clear_fcf_rr_bmask(struct lpfc_hba *phba)
+{
+        struct lpfc_fcf_pri *fcf_pri;
+        struct lpfc_fcf_pri *next_fcf_pri;
+        memset(phba->fcf.fcf_rr_bmask, 0, sizeof(*phba->fcf.fcf_rr_bmask));
+        spin_lock_irq(&phba->hbalock);
+        list_for_each_entry_safe(fcf_pri, next_fcf_pri,
+                                &phba->fcf.fcf_pri_list, list) {
+                list_del_init(&fcf_pri->list);
+                fcf_pri->fcf_rec.flag = 0;
+        }
+        spin_unlock_irq(&phba->hbalock);
+}
 static void
 lpfc_mbx_cmpl_reg_fcfi(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
 {
@@ -1130,7 +1152,8 @@ lpfc_mbx_cmpl_reg_fcfi(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
         spin_unlock_irq(&phba->hbalock);
 
         /* If there is a pending FCoE event, restart FCF table scan. */
-        if (lpfc_check_pending_fcoe_event(phba, LPFC_UNREG_FCF))
+        if ((!(phba->hba_flag & FCF_RR_INPROG)) &&
+                lpfc_check_pending_fcoe_event(phba, LPFC_UNREG_FCF))
                 goto fail_out;
 
         /* Mark successful completion of FCF table scan */
@@ -1250,6 +1273,30 @@ lpfc_vlan_id_match(uint16_t curr_vlan_id, uint16_t new_vlan_id)
 }
 
 /**
+ * lpfc_update_fcf_record - Update driver fcf record
+ * __lpfc_update_fcf_record_pri - update the lpfc_fcf_pri record.
+ * @phba: pointer to lpfc hba data structure.
+ * @fcf_index: Index for the lpfc_fcf_record.
+ * @new_fcf_record: pointer to hba fcf record.
+ *
+ * This routine updates the driver FCF priority record from the new HBA FCF
+ * record. This routine is called with the host lock held.
+ **/
+static void
+__lpfc_update_fcf_record_pri(struct lpfc_hba *phba, uint16_t fcf_index,
+                                 struct fcf_record *new_fcf_record
+                                 )
+{
+        struct lpfc_fcf_pri *fcf_pri;
+
+        fcf_pri = &phba->fcf.fcf_pri[fcf_index];
+        fcf_pri->fcf_rec.fcf_index = fcf_index;
+        /* FCF record priority */
+        fcf_pri->fcf_rec.priority = new_fcf_record->fip_priority;
+
+}
+
+/**
  * lpfc_copy_fcf_record - Copy fcf information to lpfc_hba.
  * @fcf: pointer to driver fcf record.
  * @new_fcf_record: pointer to fcf record.
@@ -1332,6 +1379,9 @@ __lpfc_update_fcf_record(struct lpfc_hba *phba, struct lpfc_fcf_rec *fcf_rec,
         fcf_rec->addr_mode = addr_mode;
         fcf_rec->vlan_id = vlan_id;
         fcf_rec->flag |= (flag | RECORD_VALID);
+        __lpfc_update_fcf_record_pri(phba,
+                bf_get(lpfc_fcf_record_fcf_index, new_fcf_record),
+                                 new_fcf_record);
 }
 
 /**
@@ -1834,6 +1884,8 @@ lpfc_sli4_fcf_record_match(struct lpfc_hba *phba,
                 return false;
         if (!lpfc_fab_name_match(fcf_rec->fabric_name, new_fcf_record))
                 return false;
+        if (fcf_rec->priority != new_fcf_record->fip_priority)
+                return false;
         return true;
 }
 
@@ -1897,6 +1949,152 @@ stop_flogi_current_fcf:
 }
 
 /**
+ * lpfc_sli4_fcf_pri_list_del
+ * @phba: pointer to lpfc hba data structure.
+ * @fcf_index the index of the fcf record to delete
+ * This routine checks the on list flag of the fcf_index to be deleted.
+ * If it is one the list then it is removed from the list, and the flag
+ * is cleared. This routine grab the hbalock before removing the fcf
+ * record from the list.
+ **/
+static void lpfc_sli4_fcf_pri_list_del(struct lpfc_hba *phba,
+                        uint16_t fcf_index)
+{
+        struct lpfc_fcf_pri *new_fcf_pri;
+
+        new_fcf_pri = &phba->fcf.fcf_pri[fcf_index];
+        lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
+                "3058 deleting idx x%x pri x%x flg x%x\n",
+                fcf_index, new_fcf_pri->fcf_rec.priority,
+                 new_fcf_pri->fcf_rec.flag);
+        spin_lock_irq(&phba->hbalock);
+        if (new_fcf_pri->fcf_rec.flag & LPFC_FCF_ON_PRI_LIST) {
+                if (phba->fcf.current_rec.priority ==
+                                new_fcf_pri->fcf_rec.priority)
+                        phba->fcf.eligible_fcf_cnt--;
+                list_del_init(&new_fcf_pri->list);
+                new_fcf_pri->fcf_rec.flag &= ~LPFC_FCF_ON_PRI_LIST;
+        }
+        spin_unlock_irq(&phba->hbalock);
+}
+
+/**
+ * lpfc_sli4_set_fcf_flogi_fail
+ * @phba: pointer to lpfc hba data structure.
+ * @fcf_index the index of the fcf record to update
+ * This routine acquires the hbalock and then set the LPFC_FCF_FLOGI_FAILED
+ * flag so the the round robin slection for the particular priority level
+ * will try a different fcf record that does not have this bit set.
+ * If the fcf record is re-read for any reason this flag is cleared brfore
+ * adding it to the priority list.
+ **/
+void
+lpfc_sli4_set_fcf_flogi_fail(struct lpfc_hba *phba, uint16_t fcf_index)
+{
+        struct lpfc_fcf_pri *new_fcf_pri;
+        new_fcf_pri = &phba->fcf.fcf_pri[fcf_index];
+        spin_lock_irq(&phba->hbalock);
+        new_fcf_pri->fcf_rec.flag |= LPFC_FCF_FLOGI_FAILED;
+        spin_unlock_irq(&phba->hbalock);
+}
+
+/**
+ * lpfc_sli4_fcf_pri_list_add
+ * @phba: pointer to lpfc hba data structure.
+ * @fcf_index the index of the fcf record to add
+ * This routine checks the priority of the fcf_index to be added.
+ * If it is a lower priority than the current head of the fcf_pri list
+ * then it is added to the list in the right order.
+ * If it is the same priority as the current head of the list then it
+ * is added to the head of the list and its bit in the rr_bmask is set.
+ * If the fcf_index to be added is of a higher priority than the current
+ * head of the list then the rr_bmask is cleared, its bit is set in the
+ * rr_bmask and it is added to the head of the list.
+ * returns:
+ * 0=success 1=failure
+ **/
+int lpfc_sli4_fcf_pri_list_add(struct lpfc_hba *phba, uint16_t fcf_index,
+        struct fcf_record *new_fcf_record)
+{
+        uint16_t current_fcf_pri;
+        uint16_t last_index;
+        struct lpfc_fcf_pri *fcf_pri;
+        struct lpfc_fcf_pri *next_fcf_pri;
+        struct lpfc_fcf_pri *new_fcf_pri;
+        int ret;
+
+        new_fcf_pri = &phba->fcf.fcf_pri[fcf_index];
+        lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
+                "3059 adding idx x%x pri x%x flg x%x\n",
+                fcf_index, new_fcf_record->fip_priority,
+                 new_fcf_pri->fcf_rec.flag);
+        spin_lock_irq(&phba->hbalock);
+        if (new_fcf_pri->fcf_rec.flag & LPFC_FCF_ON_PRI_LIST)
+                list_del_init(&new_fcf_pri->list);
+        new_fcf_pri->fcf_rec.fcf_index = fcf_index;
+        new_fcf_pri->fcf_rec.priority = new_fcf_record->fip_priority;
+        if (list_empty(&phba->fcf.fcf_pri_list)) {
+                list_add(&new_fcf_pri->list, &phba->fcf.fcf_pri_list);
+                ret = lpfc_sli4_fcf_rr_index_set(phba,
+                                new_fcf_pri->fcf_rec.fcf_index);
+                goto out;
+        }
+
+        last_index = find_first_bit(phba->fcf.fcf_rr_bmask,
+                                LPFC_SLI4_FCF_TBL_INDX_MAX);
+        if (last_index >= LPFC_SLI4_FCF_TBL_INDX_MAX) {
+                ret = 0; /* Empty rr list */
+                goto out;
+        }
+        current_fcf_pri = phba->fcf.fcf_pri[last_index].fcf_rec.priority;
+        if (new_fcf_pri->fcf_rec.priority <=  current_fcf_pri) {
+                list_add(&new_fcf_pri->list, &phba->fcf.fcf_pri_list);
+                if (new_fcf_pri->fcf_rec.priority <  current_fcf_pri) {
+                        memset(phba->fcf.fcf_rr_bmask, 0,
+                                sizeof(*phba->fcf.fcf_rr_bmask));
+                        /* fcfs_at_this_priority_level = 1; */
+                        phba->fcf.eligible_fcf_cnt = 1;
+                } else
+                        /* fcfs_at_this_priority_level++; */
+                        phba->fcf.eligible_fcf_cnt++;
+                ret = lpfc_sli4_fcf_rr_index_set(phba,
+                                new_fcf_pri->fcf_rec.fcf_index);
+                goto out;
+        }
+
+        list_for_each_entry_safe(fcf_pri, next_fcf_pri,
+                                &phba->fcf.fcf_pri_list, list) {
+                if (new_fcf_pri->fcf_rec.priority <=
+                                fcf_pri->fcf_rec.priority) {
+                        if (fcf_pri->list.prev == &phba->fcf.fcf_pri_list)
+                                list_add(&new_fcf_pri->list,
+                                                &phba->fcf.fcf_pri_list);
+                        else
+                                list_add(&new_fcf_pri->list,
+                                         &((struct lpfc_fcf_pri *)
+                                        fcf_pri->list.prev)->list);
+                        ret = 0;
+                        goto out;
+                } else if (fcf_pri->list.next == &phba->fcf.fcf_pri_list
+                        || new_fcf_pri->fcf_rec.priority <
+                                next_fcf_pri->fcf_rec.priority) {
+                        list_add(&new_fcf_pri->list, &fcf_pri->list);
+                        ret = 0;
+                        goto out;
+                }
+                if (new_fcf_pri->fcf_rec.priority > fcf_pri->fcf_rec.priority)
+                        continue;
+
+        }
+        ret = 1;
+out:
+        /* we use = instead of |= to clear the FLOGI_FAILED flag. */
+        new_fcf_pri->fcf_rec.flag = LPFC_FCF_ON_PRI_LIST;
+        spin_unlock_irq(&phba->hbalock);
+        return ret;
+}
+
+/**
  * lpfc_mbx_cmpl_fcf_scan_read_fcf_rec - fcf scan read_fcf mbox cmpl handler.
  * @phba: pointer to lpfc hba data structure.
  * @mboxq: pointer to mailbox object.
@@ -1958,6 +2156,9 @@ lpfc_mbx_cmpl_fcf_scan_read_fcf_rec(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
          * record for roundrobin FCF failover.
          */
         if (!rc) {
+                lpfc_sli4_fcf_pri_list_del(phba,
+                                        bf_get(lpfc_fcf_record_fcf_index,
+                                               new_fcf_record));
                 lpfc_printf_log(phba, KERN_WARNING, LOG_FIP,
                                 "2781 FCF (x%x) failed connection "
                                 "list check: (x%x/x%x)\n",
@@ -2005,7 +2206,8 @@ lpfc_mbx_cmpl_fcf_scan_read_fcf_rec(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
                 goto read_next_fcf;
         } else {
                 fcf_index = bf_get(lpfc_fcf_record_fcf_index, new_fcf_record);
-                rc = lpfc_sli4_fcf_rr_index_set(phba, fcf_index);
+                rc = lpfc_sli4_fcf_pri_list_add(phba, fcf_index,
+                                                        new_fcf_record);
                 if (rc)
                         goto read_next_fcf;
         }
@@ -2018,7 +2220,8 @@ lpfc_mbx_cmpl_fcf_scan_read_fcf_rec(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
          */
         spin_lock_irq(&phba->hbalock);
         if (phba->fcf.fcf_flag & FCF_IN_USE) {
-                if (lpfc_sli4_fcf_record_match(phba, &phba->fcf.current_rec,
+                if (phba->cfg_fcf_failover_policy == LPFC_FCF_FOV &&
+                        lpfc_sli4_fcf_record_match(phba, &phba->fcf.current_rec,
                     new_fcf_record, vlan_id)) {
                         if (bf_get(lpfc_fcf_record_fcf_index, new_fcf_record) ==
                             phba->fcf.current_rec.fcf_indx) {
@@ -2232,7 +2435,8 @@ read_next_fcf:
                             (phba->fcf.fcf_flag & FCF_REDISC_PEND))
                                 return;
 
-                        if (phba->fcf.fcf_flag & FCF_IN_USE) {
+                        if (phba->cfg_fcf_failover_policy == LPFC_FCF_FOV &&
+                                phba->fcf.fcf_flag & FCF_IN_USE) {
                                 /*
                                  * In case the current in-use FCF record no
                                  * longer existed during FCF discovery that
@@ -2247,7 +2451,6 @@ read_next_fcf:
                                 spin_lock_irq(&phba->hbalock);
                                 phba->fcf.fcf_flag |= FCF_REDISC_FOV;
                                 spin_unlock_irq(&phba->hbalock);
-                                lpfc_sli4_mbox_cmd_free(phba, mboxq);
                                 lpfc_sli4_fcf_scan_read_fcf_rec(phba,
                                                 LPFC_FCOE_FCF_GET_FIRST);
                                 return;
@@ -2424,7 +2627,8 @@ lpfc_mbx_cmpl_read_fcf_rec(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
 
         /* Update the eligible FCF record index bmask */
         fcf_index = bf_get(lpfc_fcf_record_fcf_index, new_fcf_record);
-        rc = lpfc_sli4_fcf_rr_index_set(phba, fcf_index);
+
+        rc = lpfc_sli4_fcf_pri_list_add(phba, fcf_index, new_fcf_record);
 
 out:
         lpfc_sli4_mbox_cmd_free(phba, mboxq);
@@ -2645,6 +2849,7 @@ lpfc_mbx_cmpl_reg_vfi(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
         vport->vpi_state |= LPFC_VPI_REGISTERED;
         vport->fc_flag |= FC_VFI_REGISTERED;
         vport->fc_flag &= ~FC_VPORT_NEEDS_REG_VPI;
+        vport->fc_flag &= ~FC_VPORT_NEEDS_INIT_VPI;
         spin_unlock_irq(shost->host_lock);
 
         if (vport->port_state == LPFC_FABRIC_CFG_LINK) {
@@ -2893,8 +3098,7 @@ lpfc_mbx_process_link_up(struct lpfc_hba *phba, struct lpfc_mbx_read_top *la)
                         goto out;
                 }
                 /* Reset FCF roundrobin bmask for new discovery */
-                memset(phba->fcf.fcf_rr_bmask, 0,
-                       sizeof(*phba->fcf.fcf_rr_bmask));
+                lpfc_sli4_clear_fcf_rr_bmask(phba);
         }
 
         return;
@@ -5592,7 +5796,7 @@ lpfc_unregister_fcf_rescan(struct lpfc_hba *phba)
         spin_unlock_irq(&phba->hbalock);
 
         /* Reset FCF roundrobin bmask for new discovery */
-        memset(phba->fcf.fcf_rr_bmask, 0, sizeof(*phba->fcf.fcf_rr_bmask));
+        lpfc_sli4_clear_fcf_rr_bmask(phba);
 
         rc = lpfc_sli4_fcf_scan_read_fcf_rec(phba, LPFC_FCOE_FCF_GET_FIRST);
 
diff --git a/drivers/scsi/lpfc/lpfc_hw.h b/drivers/scsi/lpfc/lpfc_hw.h
index ab4c4d651d0c..046edc4ab35f 100644
--- a/drivers/scsi/lpfc/lpfc_hw.h
+++ b/drivers/scsi/lpfc/lpfc_hw.h
@@ -3470,11 +3470,16 @@ typedef struct {
    or CMD_IOCB_RCV_SEQ64_CX (0xB5) */
 
 struct rcv_sli3 {
-        uint32_t word8Rsvd;
 #ifdef __BIG_ENDIAN_BITFIELD
+        uint16_t ox_id;
+        uint16_t seq_cnt;
+
         uint16_t vpi;
         uint16_t word9Rsvd;
 #else  /*  __LITTLE_ENDIAN */
+        uint16_t seq_cnt;
+        uint16_t ox_id;
+
         uint16_t word9Rsvd;
         uint16_t vpi;
 #endif
diff --git a/drivers/scsi/lpfc/lpfc_hw4.h b/drivers/scsi/lpfc/lpfc_hw4.h
index 11e26a26b5d1..7f8003b5181e 100644
--- a/drivers/scsi/lpfc/lpfc_hw4.h
+++ b/drivers/scsi/lpfc/lpfc_hw4.h
@@ -170,15 +170,8 @@ struct lpfc_sli_intf {
 #define LPFC_PCI_FUNC3          3
 #define LPFC_PCI_FUNC4          4
 
-/* SLI4 interface type-2 control register offsets */
-#define LPFC_CTL_PORT_SEM_OFFSET        0x400
-#define LPFC_CTL_PORT_STA_OFFSET        0x404
-#define LPFC_CTL_PORT_CTL_OFFSET        0x408
-#define LPFC_CTL_PORT_ER1_OFFSET        0x40C
-#define LPFC_CTL_PORT_ER2_OFFSET        0x410
+/* SLI4 interface type-2 PDEV_CTL register */
 #define LPFC_CTL_PDEV_CTL_OFFSET        0x414
-
-/* Some SLI4 interface type-2 PDEV_CTL register bits */
 #define LPFC_CTL_PDEV_CTL_DRST          0x00000001
 #define LPFC_CTL_PDEV_CTL_FRST          0x00000002
 #define LPFC_CTL_PDEV_CTL_DD            0x00000004
@@ -337,6 +330,7 @@ struct lpfc_cqe {
 #define CQE_CODE_RELEASE_WQE            0x2
 #define CQE_CODE_RECEIVE                0x4
 #define CQE_CODE_XRI_ABORTED            0x5
+#define CQE_CODE_RECEIVE_V1             0x9
 
 /* completion queue entry for wqe completions */
 struct lpfc_wcqe_complete {
@@ -440,7 +434,10 @@ struct lpfc_rcqe {
 #define FC_STATUS_RQ_BUF_LEN_EXCEEDED   0x11 /* payload truncated */
 #define FC_STATUS_INSUFF_BUF_NEED_BUF   0x12 /* Insufficient buffers */
 #define FC_STATUS_INSUFF_BUF_FRM_DISC   0x13 /* Frame Discard */
-        uint32_t reserved1;
+        uint32_t word1;
+#define lpfc_rcqe_fcf_id_v1_SHIFT       0
+#define lpfc_rcqe_fcf_id_v1_MASK        0x0000003F
+#define lpfc_rcqe_fcf_id_v1_WORD        word1
         uint32_t word2;
 #define lpfc_rcqe_length_SHIFT          16
 #define lpfc_rcqe_length_MASK           0x0000FFFF
@@ -451,6 +448,9 @@ struct lpfc_rcqe {
 #define lpfc_rcqe_fcf_id_SHIFT          0
 #define lpfc_rcqe_fcf_id_MASK           0x0000003F
 #define lpfc_rcqe_fcf_id_WORD           word2
+#define lpfc_rcqe_rq_id_v1_SHIFT        0
+#define lpfc_rcqe_rq_id_v1_MASK         0x0000FFFF
+#define lpfc_rcqe_rq_id_v1_WORD         word2
         uint32_t word3;
 #define lpfc_rcqe_valid_SHIFT           lpfc_cqe_valid_SHIFT
 #define lpfc_rcqe_valid_MASK            lpfc_cqe_valid_MASK
@@ -515,7 +515,7 @@ struct lpfc_register {
 /* The following BAR0 register sets are defined for if_type 0 and 2 UCNAs. */
 #define LPFC_SLI_INTF                   0x0058
 
-#define LPFC_SLIPORT_IF2_SMPHR          0x0400
+#define LPFC_CTL_PORT_SEM_OFFSET        0x400
 #define lpfc_port_smphr_perr_SHIFT      31
 #define lpfc_port_smphr_perr_MASK       0x1
 #define lpfc_port_smphr_perr_WORD       word0
@@ -575,7 +575,7 @@ struct lpfc_register {
 #define LPFC_POST_STAGE_PORT_READY                      0xC000
 #define LPFC_POST_STAGE_PORT_UE                         0xF000
 
-#define LPFC_SLIPORT_STATUS             0x0404
+#define LPFC_CTL_PORT_STA_OFFSET        0x404
 #define lpfc_sliport_status_err_SHIFT   31
 #define lpfc_sliport_status_err_MASK    0x1
 #define lpfc_sliport_status_err_WORD    word0
@@ -593,7 +593,7 @@ struct lpfc_register {
 #define lpfc_sliport_status_rdy_WORD    word0
 #define MAX_IF_TYPE_2_RESETS    1000
 
-#define LPFC_SLIPORT_CNTRL              0x0408
+#define LPFC_CTL_PORT_CTL_OFFSET        0x408
 #define lpfc_sliport_ctrl_end_SHIFT     30
 #define lpfc_sliport_ctrl_end_MASK      0x1
 #define lpfc_sliport_ctrl_end_WORD      word0
@@ -604,8 +604,8 @@ struct lpfc_register {
 #define lpfc_sliport_ctrl_ip_WORD       word0
 #define LPFC_SLIPORT_INIT_PORT  1
 
-#define LPFC_SLIPORT_ERR_1              0x040C
-#define LPFC_SLIPORT_ERR_2              0x0410
+#define LPFC_CTL_PORT_ER1_OFFSET        0x40C
+#define LPFC_CTL_PORT_ER2_OFFSET        0x410
 
 /* The following Registers apply to SLI4 if_type 0 UCNAs. They typically
  * reside in BAR 2.
@@ -3198,6 +3198,8 @@ struct lpfc_grp_hdr {
 #define lpfc_grp_hdr_id_MASK            0x000000FF
 #define lpfc_grp_hdr_id_WORD            word2
         uint8_t rev_name[128];
+        uint8_t date[12];
+        uint8_t revision[32];
 };
 
 #define FCP_COMMAND 0x0
diff --git a/drivers/scsi/lpfc/lpfc_init.c b/drivers/scsi/lpfc/lpfc_init.c
index 148b98ddbb1d..a3c820083c36 100644
--- a/drivers/scsi/lpfc/lpfc_init.c
+++ b/drivers/scsi/lpfc/lpfc_init.c
@@ -2927,6 +2927,8 @@ void lpfc_host_attrib_init(struct Scsi_Host *shost)
                                  sizeof fc_host_symbolic_name(shost));
 
         fc_host_supported_speeds(shost) = 0;
+        if (phba->lmt & LMT_16Gb)
+                fc_host_supported_speeds(shost) |= FC_PORTSPEED_16GBIT;
         if (phba->lmt & LMT_10Gb)
                 fc_host_supported_speeds(shost) |= FC_PORTSPEED_10GBIT;
         if (phba->lmt & LMT_8Gb)
@@ -3632,8 +3634,7 @@ lpfc_sli4_async_fip_evt(struct lpfc_hba *phba,
                         lpfc_sli4_fcf_dead_failthrough(phba);
                 } else {
                         /* Reset FCF roundrobin bmask for new discovery */
-                        memset(phba->fcf.fcf_rr_bmask, 0,
-                               sizeof(*phba->fcf.fcf_rr_bmask));
+                        lpfc_sli4_clear_fcf_rr_bmask(phba);
                         /*
                          * Handling fast FCF failover to a DEAD FCF event is
                          * considered equalivant to receiving CVL to all vports.
@@ -3647,7 +3648,7 @@ lpfc_sli4_async_fip_evt(struct lpfc_hba *phba,
                         " tag 0x%x\n", acqe_fip->index, acqe_fip->event_tag);
 
                 vport = lpfc_find_vport_by_vpid(phba,
-                                acqe_fip->index - phba->vpi_base);
+                                                acqe_fip->index);
                 ndlp = lpfc_sli4_perform_vport_cvl(vport);
                 if (!ndlp)
                         break;
@@ -3719,8 +3720,7 @@ lpfc_sli4_async_fip_evt(struct lpfc_hba *phba,
                                  * Reset FCF roundrobin bmask for new
                                  * discovery.
                                  */
-                                memset(phba->fcf.fcf_rr_bmask, 0,
-                                       sizeof(*phba->fcf.fcf_rr_bmask));
+                                lpfc_sli4_clear_fcf_rr_bmask(phba);
                 }
                 break;
         default:
@@ -4035,6 +4035,34 @@ lpfc_reset_hba(struct lpfc_hba *phba)
 }
 
 /**
+ * lpfc_sli_sriov_nr_virtfn_get - Get the number of sr-iov virtual functions
+ * @phba: pointer to lpfc hba data structure.
+ *
+ * This function enables the PCI SR-IOV virtual functions to a physical
+ * function. It invokes the PCI SR-IOV api with the @nr_vfn provided to
+ * enable the number of virtual functions to the physical function. As
+ * not all devices support SR-IOV, the return code from the pci_enable_sriov()
+ * API call does not considered as an error condition for most of the device.
+ **/
+uint16_t
+lpfc_sli_sriov_nr_virtfn_get(struct lpfc_hba *phba)
+{
+        struct pci_dev *pdev = phba->pcidev;
+        uint16_t nr_virtfn;
+        int pos;
+
+        if (!pdev->is_physfn)
+                return 0;
+
+        pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_SRIOV);
+        if (pos == 0)
+                return 0;
+
+        pci_read_config_word(pdev, pos + PCI_SRIOV_TOTAL_VF, &nr_virtfn);
+        return nr_virtfn;
+}
+
+/**
  * lpfc_sli_probe_sriov_nr_virtfn - Enable a number of sr-iov virtual functions
  * @phba: pointer to lpfc hba data structure.
  * @nr_vfn: number of virtual functions to be enabled.
@@ -4049,8 +4077,17 @@ int
 lpfc_sli_probe_sriov_nr_virtfn(struct lpfc_hba *phba, int nr_vfn)
 {
         struct pci_dev *pdev = phba->pcidev;
+        uint16_t max_nr_vfn;
         int rc;
 
+        max_nr_vfn = lpfc_sli_sriov_nr_virtfn_get(phba);
+        if (nr_vfn > max_nr_vfn) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                "3057 Requested vfs (%d) greater than "
+                                "supported vfs (%d)", nr_vfn, max_nr_vfn);
+                return -EINVAL;
+        }
+
         rc = pci_enable_sriov(pdev, nr_vfn);
         if (rc) {
                 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
@@ -4516,7 +4553,7 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba)
                 }
         }
 
-        return rc;
+        return 0;
 
 out_free_fcp_eq_hdl:
         kfree(phba->sli4_hba.fcp_eq_hdl);
@@ -4966,17 +5003,14 @@ out_free_mem:
  * @phba: pointer to lpfc hba data structure.
  *
  * This routine is invoked to post rpi header templates to the
- * HBA consistent with the SLI-4 interface spec.  This routine
+ * port for those SLI4 ports that do not support extents.  This routine
  * posts a PAGE_SIZE memory region to the port to hold up to
- * PAGE_SIZE modulo 64 rpi context headers.
- * No locks are held here because this is an initialization routine
- * called only from probe or lpfc_online when interrupts are not
- * enabled and the driver is reinitializing the device.
+ * PAGE_SIZE modulo 64 rpi context headers.  This is an initialization routine
+ * and should be called only when interrupts are disabled.
  *
  * Return codes
  *      0 - successful
- *      -ENOMEM - No available memory
- *      -EIO - The mailbox failed to complete successfully.
+ *      -ERROR - otherwise.
  **/
 int
 lpfc_sli4_init_rpi_hdrs(struct lpfc_hba *phba)
@@ -5687,17 +5721,22 @@ lpfc_sli4_bar0_register_memmap(struct lpfc_hba *phba, uint32_t if_type)
                 break;
         case LPFC_SLI_INTF_IF_TYPE_2:
                 phba->sli4_hba.u.if_type2.ERR1regaddr =
-                        phba->sli4_hba.conf_regs_memmap_p + LPFC_SLIPORT_ERR_1;
+                        phba->sli4_hba.conf_regs_memmap_p +
+                                                LPFC_CTL_PORT_ER1_OFFSET;
                 phba->sli4_hba.u.if_type2.ERR2regaddr =
-                        phba->sli4_hba.conf_regs_memmap_p + LPFC_SLIPORT_ERR_2;
+                        phba->sli4_hba.conf_regs_memmap_p +
+                                                LPFC_CTL_PORT_ER2_OFFSET;
                 phba->sli4_hba.u.if_type2.CTRLregaddr =
-                        phba->sli4_hba.conf_regs_memmap_p + LPFC_SLIPORT_CNTRL;
+                        phba->sli4_hba.conf_regs_memmap_p +
+                                                LPFC_CTL_PORT_CTL_OFFSET;
                 phba->sli4_hba.u.if_type2.STATUSregaddr =
-                        phba->sli4_hba.conf_regs_memmap_p + LPFC_SLIPORT_STATUS;
+                        phba->sli4_hba.conf_regs_memmap_p +
+                                                LPFC_CTL_PORT_STA_OFFSET;
                 phba->sli4_hba.SLIINTFregaddr =
                         phba->sli4_hba.conf_regs_memmap_p + LPFC_SLI_INTF;
                 phba->sli4_hba.PSMPHRregaddr =
-                     phba->sli4_hba.conf_regs_memmap_p + LPFC_SLIPORT_IF2_SMPHR;
+                        phba->sli4_hba.conf_regs_memmap_p +
+                                                LPFC_CTL_PORT_SEM_OFFSET;
                 phba->sli4_hba.RQDBregaddr =
                         phba->sli4_hba.conf_regs_memmap_p + LPFC_RQ_DOORBELL;
                 phba->sli4_hba.WQDBregaddr =
@@ -8859,11 +8898,11 @@ lpfc_write_firmware(struct lpfc_hba *phba, const struct firmware *fw)
                 return -EINVAL;
         }
         lpfc_decode_firmware_rev(phba, fwrev, 1);
-        if (strncmp(fwrev, image->rev_name, strnlen(fwrev, 16))) {
+        if (strncmp(fwrev, image->revision, strnlen(image->revision, 16))) {
                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
                                 "3023 Updating Firmware. Current Version:%s "
                                 "New Version:%s\n",
-                                fwrev, image->rev_name);
+                                fwrev, image->revision);
                 for (i = 0; i < LPFC_MBX_WR_CONFIG_MAX_BDE; i++) {
                         dmabuf = kzalloc(sizeof(struct lpfc_dmabuf),
                                          GFP_KERNEL);
@@ -8892,9 +8931,9 @@ lpfc_write_firmware(struct lpfc_hba *phba, const struct firmware *fw)
                                                fw->size - offset);
                                         break;
                                 }
-                                temp_offset += SLI4_PAGE_SIZE;
                                 memcpy(dmabuf->virt, fw->data + temp_offset,
                                        SLI4_PAGE_SIZE);
+                                temp_offset += SLI4_PAGE_SIZE;
                         }
                         rc = lpfc_wr_object(phba, &dma_buffer_list,
                                     (fw->size - offset), &offset);
@@ -9005,6 +9044,7 @@ lpfc_pci_probe_one_s4(struct pci_dev *pdev, const struct pci_device_id *pid)
         }
 
         INIT_LIST_HEAD(&phba->active_rrq_list);
+        INIT_LIST_HEAD(&phba->fcf.fcf_pri_list);
 
         /* Set up common device driver resources */
         error = lpfc_setup_driver_resource_phase2(phba);
@@ -9112,7 +9152,6 @@ lpfc_pci_probe_one_s4(struct pci_dev *pdev, const struct pci_device_id *pid)
 
         /* Check if there are static vports to be created. */
         lpfc_create_static_vport(phba);
-
         return 0;
 
 out_disable_intr:
@@ -9483,6 +9522,13 @@ lpfc_io_slot_reset_s4(struct pci_dev *pdev)
         }
 
         pci_restore_state(pdev);
+
+        /*
+         * As the new kernel behavior of pci_restore_state() API call clears
+         * device saved_state flag, need to save the restored state again.
+         */
+        pci_save_state(pdev);
+
         if (pdev->is_busmaster)
                 pci_set_master(pdev);
 
diff --git a/drivers/scsi/lpfc/lpfc_mbox.c b/drivers/scsi/lpfc/lpfc_mbox.c
index 556767028353..83450cc5c4d3 100644
--- a/drivers/scsi/lpfc/lpfc_mbox.c
+++ b/drivers/scsi/lpfc/lpfc_mbox.c
@@ -2031,7 +2031,7 @@ lpfc_init_vfi(struct lpfcMboxq *mbox, struct lpfc_vport *vport)
         bf_set(lpfc_init_vfi_vp, init_vfi, 1);
         bf_set(lpfc_init_vfi_vfi, init_vfi,
                vport->phba->sli4_hba.vfi_ids[vport->vfi]);
-        bf_set(lpfc_init_vpi_vpi, init_vfi,
+        bf_set(lpfc_init_vfi_vpi, init_vfi,
                vport->phba->vpi_ids[vport->vpi]);
         bf_set(lpfc_init_vfi_fcfi, init_vfi,
                vport->phba->fcf.fcfi);
diff --git a/drivers/scsi/lpfc/lpfc_scsi.c b/drivers/scsi/lpfc/lpfc_scsi.c
index 3ccc97496ebf..eadd241eeff1 100644
--- a/drivers/scsi/lpfc/lpfc_scsi.c
+++ b/drivers/scsi/lpfc/lpfc_scsi.c
@@ -1302,13 +1302,13 @@ lpfc_sc_to_bg_opcodes(struct lpfc_hba *phba, struct scsi_cmnd *sc,
                 case SCSI_PROT_NORMAL:
                 default:
                         lpfc_printf_log(phba, KERN_ERR, LOG_BG,
-                                "9063 BLKGRD: Bad op/guard:%d/%d combination\n",
-                                        scsi_get_prot_op(sc), guard_type);
+                                "9063 BLKGRD: Bad op/guard:%d/IP combination\n",
+                                        scsi_get_prot_op(sc));
                         ret = 1;
                         break;
 
                 }
-        } else if (guard_type == SHOST_DIX_GUARD_CRC) {
+        } else {
                 switch (scsi_get_prot_op(sc)) {
                 case SCSI_PROT_READ_STRIP:
                 case SCSI_PROT_WRITE_INSERT:
@@ -1324,17 +1324,18 @@ lpfc_sc_to_bg_opcodes(struct lpfc_hba *phba, struct scsi_cmnd *sc,
 
                 case SCSI_PROT_READ_INSERT:
                 case SCSI_PROT_WRITE_STRIP:
+                        *txop = BG_OP_IN_CRC_OUT_NODIF;
+                        *rxop = BG_OP_IN_NODIF_OUT_CRC;
+                        break;
+
                 case SCSI_PROT_NORMAL:
                 default:
                         lpfc_printf_log(phba, KERN_ERR, LOG_BG,
-                                "9075 BLKGRD: Bad op/guard:%d/%d combination\n",
-                                        scsi_get_prot_op(sc), guard_type);
+                                "9075 BLKGRD: Bad op/guard:%d/CRC combination\n",
+                                        scsi_get_prot_op(sc));
                         ret = 1;
                         break;
                 }
-        } else {
-                /* unsupported format */
-                BUG();
         }
 
         return ret;
@@ -1352,45 +1353,6 @@ lpfc_cmd_blksize(struct scsi_cmnd *sc)
         return sc->device->sector_size;
 }
 
-/**
- * lpfc_get_cmd_dif_parms - Extract DIF parameters from SCSI command
- * @sc:             in: SCSI command
- * @apptagmask:     out: app tag mask
- * @apptagval:      out: app tag value
- * @reftag:         out: ref tag (reference tag)
- *
- * Description:
- *   Extract DIF parameters from the command if possible.  Otherwise,
- *   use default parameters.
- *
- **/
-static inline void
-lpfc_get_cmd_dif_parms(struct scsi_cmnd *sc, uint16_t *apptagmask,
-                uint16_t *apptagval, uint32_t *reftag)
-{
-        struct  scsi_dif_tuple *spt;
-        unsigned char op = scsi_get_prot_op(sc);
-        unsigned int protcnt = scsi_prot_sg_count(sc);
-        static int cnt;
-
-        if (protcnt && (op == SCSI_PROT_WRITE_STRIP ||
-                                op == SCSI_PROT_WRITE_PASS)) {
-
-                cnt++;
-                spt = page_address(sg_page(scsi_prot_sglist(sc))) +
-                        scsi_prot_sglist(sc)[0].offset;
-                *apptagmask = 0;
-                *apptagval = 0;
-                *reftag = cpu_to_be32(spt->ref_tag);
-
-        } else {
-                /* SBC defines ref tag to be lower 32bits of LBA */
-                *reftag = (uint32_t) (0xffffffff & scsi_get_lba(sc));
-                *apptagmask = 0;
-                *apptagval = 0;
-        }
-}
-
 /*
  * This function sets up buffer list for protection groups of
  * type LPFC_PG_TYPE_NO_DIF
@@ -1427,9 +1389,8 @@ lpfc_bg_setup_bpl(struct lpfc_hba *phba, struct scsi_cmnd *sc,
         dma_addr_t physaddr;
         int i = 0, num_bde = 0, status;
         int datadir = sc->sc_data_direction;
-        unsigned blksize;
         uint32_t reftag;
-        uint16_t apptagmask, apptagval;
+        unsigned blksize;
         uint8_t txop, rxop;
 
         status  = lpfc_sc_to_bg_opcodes(phba, sc, &txop, &rxop);
@@ -1438,17 +1399,16 @@ lpfc_bg_setup_bpl(struct lpfc_hba *phba, struct scsi_cmnd *sc,
 
         /* extract some info from the scsi command for pde*/
         blksize = lpfc_cmd_blksize(sc);
-        lpfc_get_cmd_dif_parms(sc, &apptagmask, &apptagval, &reftag);
+        reftag = scsi_get_lba(sc) & 0xffffffff;
 
         /* setup PDE5 with what we have */
         pde5 = (struct lpfc_pde5 *) bpl;
         memset(pde5, 0, sizeof(struct lpfc_pde5));
         bf_set(pde5_type, pde5, LPFC_PDE5_DESCRIPTOR);
-        pde5->reftag = reftag;
 
         /* Endianness conversion if necessary for PDE5 */
         pde5->word0 = cpu_to_le32(pde5->word0);
-        pde5->reftag = cpu_to_le32(pde5->reftag);
+        pde5->reftag = cpu_to_le32(reftag);
 
         /* advance bpl and increment bde count */
         num_bde++;
@@ -1463,10 +1423,10 @@ lpfc_bg_setup_bpl(struct lpfc_hba *phba, struct scsi_cmnd *sc,
         if (datadir == DMA_FROM_DEVICE) {
                 bf_set(pde6_ce, pde6, 1);
                 bf_set(pde6_re, pde6, 1);
-                bf_set(pde6_ae, pde6, 1);
         }
         bf_set(pde6_ai, pde6, 1);
-        bf_set(pde6_apptagval, pde6, apptagval);
+        bf_set(pde6_ae, pde6, 0);
+        bf_set(pde6_apptagval, pde6, 0);
 
         /* Endianness conversion if necessary for PDE6 */
         pde6->word0 = cpu_to_le32(pde6->word0);
@@ -1551,7 +1511,6 @@ lpfc_bg_setup_bpl_prot(struct lpfc_hba *phba, struct scsi_cmnd *sc,
         unsigned char pgdone = 0, alldone = 0;
         unsigned blksize;
         uint32_t reftag;
-        uint16_t apptagmask, apptagval;
         uint8_t txop, rxop;
         int num_bde = 0;
 
@@ -1571,7 +1530,7 @@ lpfc_bg_setup_bpl_prot(struct lpfc_hba *phba, struct scsi_cmnd *sc,
 
         /* extract some info from the scsi command */
         blksize = lpfc_cmd_blksize(sc);
-        lpfc_get_cmd_dif_parms(sc, &apptagmask, &apptagval, &reftag);
+        reftag = scsi_get_lba(sc) & 0xffffffff;
 
         split_offset = 0;
         do {
@@ -1579,11 +1538,10 @@ lpfc_bg_setup_bpl_prot(struct lpfc_hba *phba, struct scsi_cmnd *sc,
                 pde5 = (struct lpfc_pde5 *) bpl;
                 memset(pde5, 0, sizeof(struct lpfc_pde5));
                 bf_set(pde5_type, pde5, LPFC_PDE5_DESCRIPTOR);
-                pde5->reftag = reftag;
 
                 /* Endianness conversion if necessary for PDE5 */
                 pde5->word0 = cpu_to_le32(pde5->word0);
-                pde5->reftag = cpu_to_le32(pde5->reftag);
+                pde5->reftag = cpu_to_le32(reftag);
 
                 /* advance bpl and increment bde count */
                 num_bde++;
@@ -1597,9 +1555,9 @@ lpfc_bg_setup_bpl_prot(struct lpfc_hba *phba, struct scsi_cmnd *sc,
                 bf_set(pde6_oprx, pde6, rxop);
                 bf_set(pde6_ce, pde6, 1);
                 bf_set(pde6_re, pde6, 1);
-                bf_set(pde6_ae, pde6, 1);
                 bf_set(pde6_ai, pde6, 1);
-                bf_set(pde6_apptagval, pde6, apptagval);
+                bf_set(pde6_ae, pde6, 0);
+                bf_set(pde6_apptagval, pde6, 0);
 
                 /* Endianness conversion if necessary for PDE6 */
                 pde6->word0 = cpu_to_le32(pde6->word0);
@@ -1621,8 +1579,8 @@ lpfc_bg_setup_bpl_prot(struct lpfc_hba *phba, struct scsi_cmnd *sc,
                 memset(pde7, 0, sizeof(struct lpfc_pde7));
                 bf_set(pde7_type, pde7, LPFC_PDE7_DESCRIPTOR);
 
-                pde7->addrHigh = le32_to_cpu(putPaddrLow(protphysaddr));
-                pde7->addrLow = le32_to_cpu(putPaddrHigh(protphysaddr));
+                pde7->addrHigh = le32_to_cpu(putPaddrHigh(protphysaddr));
+                pde7->addrLow = le32_to_cpu(putPaddrLow(protphysaddr));
 
                 protgrp_blks = protgroup_len / 8;
                 protgrp_bytes = protgrp_blks * blksize;
@@ -1632,7 +1590,7 @@ lpfc_bg_setup_bpl_prot(struct lpfc_hba *phba, struct scsi_cmnd *sc,
                         protgroup_remainder = 0x1000 - (pde7->addrLow & 0xfff);
                         protgroup_offset += protgroup_remainder;
                         protgrp_blks = protgroup_remainder / 8;
-                        protgrp_bytes = protgroup_remainder * blksize;
+                        protgrp_bytes = protgrp_blks * blksize;
                 } else {
                         protgroup_offset = 0;
                         curr_prot++;
@@ -2006,16 +1964,21 @@ lpfc_parse_bg_err(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd,
         if (lpfc_bgs_get_hi_water_mark_present(bgstat)) {
                 /*
                  * setup sense data descriptor 0 per SPC-4 as an information
-                 * field, and put the failing LBA in it
+                 * field, and put the failing LBA in it.
+                 * This code assumes there was also a guard/app/ref tag error
+                 * indication.
                  */
-                cmd->sense_buffer[8] = 0;     /* Information */
-                cmd->sense_buffer[9] = 0xa;   /* Add. length */
+                cmd->sense_buffer[7] = 0xc;   /* Additional sense length */
+                cmd->sense_buffer[8] = 0;     /* Information descriptor type */
+                cmd->sense_buffer[9] = 0xa;   /* Additional descriptor length */
+                cmd->sense_buffer[10] = 0x80; /* Validity bit */
                 bghm /= cmd->device->sector_size;
 
                 failing_sector = scsi_get_lba(cmd);
                 failing_sector += bghm;
 
-                put_unaligned_be64(failing_sector, &cmd->sense_buffer[10]);
+                /* Descriptor Information */
+                put_unaligned_be64(failing_sector, &cmd->sense_buffer[12]);
         }
 
         if (!ret) {
diff --git a/drivers/scsi/lpfc/lpfc_sli.c b/drivers/scsi/lpfc/lpfc_sli.c
index 98999bbd8cbf..8b799f047a99 100644
--- a/drivers/scsi/lpfc/lpfc_sli.c
+++ b/drivers/scsi/lpfc/lpfc_sli.c
@@ -560,7 +560,7 @@ __lpfc_set_rrq_active(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
         rrq = mempool_alloc(phba->rrq_pool, GFP_KERNEL);
         if (rrq) {
                 rrq->send_rrq = send_rrq;
-                rrq->xritag = phba->sli4_hba.xri_ids[xritag];
+                rrq->xritag = xritag;
                 rrq->rrq_stop_time = jiffies + HZ * (phba->fc_ratov + 1);
                 rrq->ndlp = ndlp;
                 rrq->nlp_DID = ndlp->nlp_DID;
@@ -2452,7 +2452,8 @@ lpfc_sli_process_unsol_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
 
                 /* search continue save q for same XRI */
                 list_for_each_entry(iocbq, &pring->iocb_continue_saveq, clist) {
-                        if (iocbq->iocb.ulpContext == saveq->iocb.ulpContext) {
+                        if (iocbq->iocb.unsli3.rcvsli3.ox_id ==
+                                saveq->iocb.unsli3.rcvsli3.ox_id) {
                                 list_add_tail(&saveq->list, &iocbq->list);
                                 found = 1;
                                 break;
@@ -3355,6 +3356,7 @@ lpfc_sli_handle_slow_ring_event_s4(struct lpfc_hba *phba,
                                                            irspiocbq);
                         break;
                 case CQE_CODE_RECEIVE:
+                case CQE_CODE_RECEIVE_V1:
                         dmabuf = container_of(cq_event, struct hbq_dmabuf,
                                               cq_event);
                         lpfc_sli4_handle_received_buffer(phba, dmabuf);
@@ -4712,10 +4714,15 @@ lpfc_sli4_arm_cqeq_intr(struct lpfc_hba *phba)
  * lpfc_sli4_get_avail_extnt_rsrc - Get available resource extent count.
  * @phba: Pointer to HBA context object.
  * @type: The resource extent type.
+ * @extnt_count: buffer to hold port available extent count.
+ * @extnt_size: buffer to hold element count per extent.
  *
- * This function allocates all SLI4 resource identifiers.
+ * This function calls the port and retrievs the number of available
+ * extents and their size for a particular extent type.
+ *
+ * Returns: 0 if successful.  Nonzero otherwise.
  **/
-static int
+int
 lpfc_sli4_get_avail_extnt_rsrc(struct lpfc_hba *phba, uint16_t type,
                                uint16_t *extnt_count, uint16_t *extnt_size)
 {
@@ -4892,7 +4899,7 @@ lpfc_sli4_cfg_post_extnts(struct lpfc_hba *phba, uint16_t *extnt_cnt,
                                      req_len, *emb);
         if (alloc_len < req_len) {
                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
-                        "9000 Allocated DMA memory size (x%x) is "
+                        "2982 Allocated DMA memory size (x%x) is "
                         "less than the requested DMA memory "
                         "size (x%x)\n", alloc_len, req_len);
                 return -ENOMEM;
@@ -5506,6 +5513,154 @@ lpfc_sli4_dealloc_resource_identifiers(struct lpfc_hba *phba)
 }
 
 /**
+ * lpfc_sli4_get_allocated_extnts - Get the port's allocated extents.
+ * @phba: Pointer to HBA context object.
+ * @type: The resource extent type.
+ * @extnt_count: buffer to hold port extent count response
+ * @extnt_size: buffer to hold port extent size response.
+ *
+ * This function calls the port to read the host allocated extents
+ * for a particular type.
+ **/
+int
+lpfc_sli4_get_allocated_extnts(struct lpfc_hba *phba, uint16_t type,
+                               uint16_t *extnt_cnt, uint16_t *extnt_size)
+{
+        bool emb;
+        int rc = 0;
+        uint16_t curr_blks = 0;
+        uint32_t req_len, emb_len;
+        uint32_t alloc_len, mbox_tmo;
+        struct list_head *blk_list_head;
+        struct lpfc_rsrc_blks *rsrc_blk;
+        LPFC_MBOXQ_t *mbox;
+        void *virtaddr = NULL;
+        struct lpfc_mbx_nembed_rsrc_extent *n_rsrc;
+        struct lpfc_mbx_alloc_rsrc_extents *rsrc_ext;
+        union  lpfc_sli4_cfg_shdr *shdr;
+
+        switch (type) {
+        case LPFC_RSC_TYPE_FCOE_VPI:
+                blk_list_head = &phba->lpfc_vpi_blk_list;
+                break;
+        case LPFC_RSC_TYPE_FCOE_XRI:
+                blk_list_head = &phba->sli4_hba.lpfc_xri_blk_list;
+                break;
+        case LPFC_RSC_TYPE_FCOE_VFI:
+                blk_list_head = &phba->sli4_hba.lpfc_vfi_blk_list;
+                break;
+        case LPFC_RSC_TYPE_FCOE_RPI:
+                blk_list_head = &phba->sli4_hba.lpfc_rpi_blk_list;
+                break;
+        default:
+                return -EIO;
+        }
+
+        /* Count the number of extents currently allocatd for this type. */
+        list_for_each_entry(rsrc_blk, blk_list_head, list) {
+                if (curr_blks == 0) {
+                        /*
+                         * The GET_ALLOCATED mailbox does not return the size,
+                         * just the count.  The size should be just the size
+                         * stored in the current allocated block and all sizes
+                         * for an extent type are the same so set the return
+                         * value now.
+                         */
+                        *extnt_size = rsrc_blk->rsrc_size;
+                }
+                curr_blks++;
+        }
+
+        /* Calculate the total requested length of the dma memory. */
+        req_len = curr_blks * sizeof(uint16_t);
+
+        /*
+         * Calculate the size of an embedded mailbox.  The uint32_t
+         * accounts for extents-specific word.
+         */
+        emb_len = sizeof(MAILBOX_t) - sizeof(struct mbox_header) -
+                sizeof(uint32_t);
+
+        /*
+         * Presume the allocation and response will fit into an embedded
+         * mailbox.  If not true, reconfigure to a non-embedded mailbox.
+         */
+        emb = LPFC_SLI4_MBX_EMBED;
+        req_len = emb_len;
+        if (req_len > emb_len) {
+                req_len = curr_blks * sizeof(uint16_t) +
+                        sizeof(union lpfc_sli4_cfg_shdr) +
+                        sizeof(uint32_t);
+                emb = LPFC_SLI4_MBX_NEMBED;
+        }
+
+        mbox = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
+        if (!mbox)
+                return -ENOMEM;
+        memset(mbox, 0, sizeof(LPFC_MBOXQ_t));
+
+        alloc_len = lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_COMMON,
+                                     LPFC_MBOX_OPCODE_GET_ALLOC_RSRC_EXTENT,
+                                     req_len, emb);
+        if (alloc_len < req_len) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                        "2983 Allocated DMA memory size (x%x) is "
+                        "less than the requested DMA memory "
+                        "size (x%x)\n", alloc_len, req_len);
+                rc = -ENOMEM;
+                goto err_exit;
+        }
+        rc = lpfc_sli4_mbox_rsrc_extent(phba, mbox, curr_blks, type, emb);
+        if (unlikely(rc)) {
+                rc = -EIO;
+                goto err_exit;
+        }
+
+        if (!phba->sli4_hba.intr_enable)
+                rc = lpfc_sli_issue_mbox(phba, mbox, MBX_POLL);
+        else {
+                mbox_tmo = lpfc_mbox_tmo_val(phba, MBX_SLI4_CONFIG);
+                rc = lpfc_sli_issue_mbox_wait(phba, mbox, mbox_tmo);
+        }
+
+        if (unlikely(rc)) {
+                rc = -EIO;
+                goto err_exit;
+        }
+
+        /*
+         * Figure out where the response is located.  Then get local pointers
+         * to the response data.  The port does not guarantee to respond to
+         * all extents counts request so update the local variable with the
+         * allocated count from the port.
+         */
+        if (emb == LPFC_SLI4_MBX_EMBED) {
+                rsrc_ext = &mbox->u.mqe.un.alloc_rsrc_extents;
+                shdr = &rsrc_ext->header.cfg_shdr;
+                *extnt_cnt = bf_get(lpfc_mbx_rsrc_cnt, &rsrc_ext->u.rsp);
+        } else {
+                virtaddr = mbox->sge_array->addr[0];
+                n_rsrc = (struct lpfc_mbx_nembed_rsrc_extent *) virtaddr;
+                shdr = &n_rsrc->cfg_shdr;
+                *extnt_cnt = bf_get(lpfc_mbx_rsrc_cnt, n_rsrc);
+        }
+
+        if (bf_get(lpfc_mbox_hdr_status, &shdr->response)) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_INIT,
+                        "2984 Failed to read allocated resources "
+                        "for type %d - Status 0x%x Add'l Status 0x%x.\n",
+                        type,
+                        bf_get(lpfc_mbox_hdr_status, &shdr->response),
+                        bf_get(lpfc_mbox_hdr_add_status, &shdr->response));
+                rc = -EIO;
+                goto err_exit;
+        }
+ err_exit:
+        lpfc_sli4_mbox_cmd_free(phba, mbox);
+        return rc;
+}
+
+/**
  * lpfc_sli4_hba_setup - SLI4 device intialization PCI function
  * @phba: Pointer to HBA context object.
  *
@@ -5837,6 +5992,7 @@ lpfc_sli4_hba_setup(struct lpfc_hba *phba)
                                         "Advanced Error Reporting (AER)\n");
                         phba->cfg_aer_support = 0;
                 }
+                rc = 0;
         }
 
         if (!(phba->hba_flag & HBA_FCOE_MODE)) {
@@ -6634,6 +6790,9 @@ lpfc_sli_issue_mbox_s4(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq,
         unsigned long iflags;
         int rc;
 
+        /* dump from issue mailbox command if setup */
+        lpfc_idiag_mbxacc_dump_issue_mbox(phba, &mboxq->u.mb);
+
         rc = lpfc_mbox_dev_check(phba);
         if (unlikely(rc)) {
                 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
@@ -7318,12 +7477,12 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                 bf_set(wqe_qosd, &wqe->els_req.wqe_com, 1);
                 bf_set(wqe_lenloc, &wqe->els_req.wqe_com, LPFC_WQE_LENLOC_NONE);
                 bf_set(wqe_ebde_cnt, &wqe->els_req.wqe_com, 0);
-        break;
+                break;
         case CMD_XMIT_SEQUENCE64_CX:
                 bf_set(wqe_ctxt_tag, &wqe->xmit_sequence.wqe_com,
                        iocbq->iocb.un.ulpWord[3]);
                 bf_set(wqe_rcvoxid, &wqe->xmit_sequence.wqe_com,
-                       iocbq->iocb.ulpContext);
+                       iocbq->iocb.unsli3.rcvsli3.ox_id);
                 /* The entire sequence is transmitted for this IOCB */
                 xmit_len = total_len;
                 cmnd = CMD_XMIT_SEQUENCE64_CR;
@@ -7341,7 +7500,7 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                 bf_set(wqe_ebde_cnt, &wqe->xmit_sequence.wqe_com, 0);
                 wqe->xmit_sequence.xmit_len = xmit_len;
                 command_type = OTHER_COMMAND;
-        break;
+                break;
         case CMD_XMIT_BCAST64_CN:
                 /* word3 iocb=iotag32 wqe=seq_payload_len */
                 wqe->xmit_bcast64.seq_payload_len = xmit_len;
@@ -7355,7 +7514,7 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                 bf_set(wqe_lenloc, &wqe->xmit_bcast64.wqe_com,
                        LPFC_WQE_LENLOC_WORD3);
                 bf_set(wqe_ebde_cnt, &wqe->xmit_bcast64.wqe_com, 0);
-        break;
+                break;
         case CMD_FCP_IWRITE64_CR:
                 command_type = FCP_COMMAND_DATA_OUT;
                 /* word3 iocb=iotag wqe=payload_offset_len */
@@ -7375,7 +7534,7 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                        LPFC_WQE_LENLOC_WORD4);
                 bf_set(wqe_ebde_cnt, &wqe->fcp_iwrite.wqe_com, 0);
                 bf_set(wqe_pu, &wqe->fcp_iwrite.wqe_com, iocbq->iocb.ulpPU);
-        break;
+                break;
         case CMD_FCP_IREAD64_CR:
                 /* word3 iocb=iotag wqe=payload_offset_len */
                 /* Add the FCP_CMD and FCP_RSP sizes to get the offset */
@@ -7394,7 +7553,7 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                        LPFC_WQE_LENLOC_WORD4);
                 bf_set(wqe_ebde_cnt, &wqe->fcp_iread.wqe_com, 0);
                 bf_set(wqe_pu, &wqe->fcp_iread.wqe_com, iocbq->iocb.ulpPU);
-        break;
+                break;
         case CMD_FCP_ICMND64_CR:
                 /* word3 iocb=IO_TAG wqe=reserved */
                 wqe->fcp_icmd.rsrvd3 = 0;
@@ -7407,7 +7566,7 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                 bf_set(wqe_lenloc, &wqe->fcp_icmd.wqe_com,
                        LPFC_WQE_LENLOC_NONE);
                 bf_set(wqe_ebde_cnt, &wqe->fcp_icmd.wqe_com, 0);
-        break;
+                break;
         case CMD_GEN_REQUEST64_CR:
                 /* For this command calculate the xmit length of the
                  * request bde.
@@ -7442,7 +7601,7 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                 bf_set(wqe_lenloc, &wqe->gen_req.wqe_com, LPFC_WQE_LENLOC_NONE);
                 bf_set(wqe_ebde_cnt, &wqe->gen_req.wqe_com, 0);
                 command_type = OTHER_COMMAND;
-        break;
+                break;
         case CMD_XMIT_ELS_RSP64_CX:
                 ndlp = (struct lpfc_nodelist *)iocbq->context1;
                 /* words0-2 BDE memcpy */
@@ -7457,7 +7616,7 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                        ((iocbq->iocb.ulpCt_h << 1) | iocbq->iocb.ulpCt_l));
                 bf_set(wqe_pu, &wqe->xmit_els_rsp.wqe_com, iocbq->iocb.ulpPU);
                 bf_set(wqe_rcvoxid, &wqe->xmit_els_rsp.wqe_com,
-                       iocbq->iocb.ulpContext);
+                       iocbq->iocb.unsli3.rcvsli3.ox_id);
                 if (!iocbq->iocb.ulpCt_h && iocbq->iocb.ulpCt_l)
                         bf_set(wqe_ctxt_tag, &wqe->xmit_els_rsp.wqe_com,
                                phba->vpi_ids[iocbq->vport->vpi]);
@@ -7470,7 +7629,7 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                 bf_set(wqe_rsp_temp_rpi, &wqe->xmit_els_rsp,
                        phba->sli4_hba.rpi_ids[ndlp->nlp_rpi]);
                 command_type = OTHER_COMMAND;
-        break;
+                break;
         case CMD_CLOSE_XRI_CN:
         case CMD_ABORT_XRI_CN:
         case CMD_ABORT_XRI_CX:
@@ -7509,7 +7668,7 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                 cmnd = CMD_ABORT_XRI_CX;
                 command_type = OTHER_COMMAND;
                 xritag = 0;
-        break;
+                break;
         case CMD_XMIT_BLS_RSP64_CX:
                 /* As BLS ABTS RSP WQE is very different from other WQEs,
                  * we re-construct this WQE here based on information in
@@ -7553,7 +7712,7 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                                bf_get(lpfc_rsn_code, &iocbq->iocb.un.bls_rsp));
                 }
 
-        break;
+                break;
         case CMD_XRI_ABORTED_CX:
         case CMD_CREATE_XRI_CR: /* Do we expect to use this? */
         case CMD_IOCB_FCP_IBIDIR64_CR: /* bidirectional xfer */
@@ -7565,7 +7724,7 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                                 "2014 Invalid command 0x%x\n",
                                 iocbq->iocb.ulpCommand);
                 return IOCB_ERROR;
-        break;
+                break;
         }
 
         bf_set(wqe_xri_tag, &wqe->generic.wqe_com, xritag);
@@ -10481,10 +10640,14 @@ lpfc_sli4_sp_handle_rcqe(struct lpfc_hba *phba, struct lpfc_rcqe *rcqe)
         struct lpfc_queue *hrq = phba->sli4_hba.hdr_rq;
         struct lpfc_queue *drq = phba->sli4_hba.dat_rq;
         struct hbq_dmabuf *dma_buf;
-        uint32_t status;
+        uint32_t status, rq_id;
         unsigned long iflags;
 
-        if (bf_get(lpfc_rcqe_rq_id, rcqe) != hrq->queue_id)
+        if (bf_get(lpfc_cqe_code, rcqe) == CQE_CODE_RECEIVE_V1)
+                rq_id = bf_get(lpfc_rcqe_rq_id_v1, rcqe);
+        else
+                rq_id = bf_get(lpfc_rcqe_rq_id, rcqe);
+        if (rq_id != hrq->queue_id)
                 goto out;
 
         status = bf_get(lpfc_rcqe_status, rcqe);
@@ -10563,6 +10726,7 @@ lpfc_sli4_sp_handle_cqe(struct lpfc_hba *phba, struct lpfc_queue *cq,
                                 (struct sli4_wcqe_xri_aborted *)&cqevt);
                 break;
         case CQE_CODE_RECEIVE:
+        case CQE_CODE_RECEIVE_V1:
                 /* Process the RQ event */
                 phba->last_completion_time = jiffies;
                 workposted = lpfc_sli4_sp_handle_rcqe(phba,
@@ -12345,19 +12509,18 @@ lpfc_sli4_post_sgl(struct lpfc_hba *phba,
 }
 
 /**
- * lpfc_sli4_init_rpi_hdrs - Post the rpi header memory region to the port
+ * lpfc_sli4_alloc_xri - Get an available rpi in the device's range
  * @phba: pointer to lpfc hba data structure.
  *
  * This routine is invoked to post rpi header templates to the
- * port for those SLI4 ports that do not support extents.  This routine
- * posts a PAGE_SIZE memory region to the port to hold up to
- * PAGE_SIZE modulo 64 rpi context headers.  This is an initialization routine
- * and should be called only when interrupts are disabled.
+ * HBA consistent with the SLI-4 interface spec.  This routine
+ * posts a SLI4_PAGE_SIZE memory region to the port to hold up to
+ * SLI4_PAGE_SIZE modulo 64 rpi context headers.
  *
- * Return codes
- *      0 - successful
- *      -ERROR - otherwise.
- */
+ * Returns
+ *      A nonzero rpi defined as rpi_base <= rpi < max_rpi if successful
+ *      LPFC_RPI_ALLOC_ERROR if no rpis are available.
+ **/
 uint16_t
 lpfc_sli4_alloc_xri(struct lpfc_hba *phba)
 {
@@ -13406,7 +13569,7 @@ lpfc_sli4_seq_abort_rsp_cmpl(struct lpfc_hba *phba,
  * This function validates the xri maps to the known range of XRIs allocated an
  * used by the driver.
  **/
-static uint16_t
+uint16_t
 lpfc_sli4_xri_inrange(struct lpfc_hba *phba,
                       uint16_t xri)
 {
@@ -13643,10 +13806,12 @@ lpfc_seq_complete(struct hbq_dmabuf *dmabuf)
 static struct lpfc_iocbq *
 lpfc_prep_seq(struct lpfc_vport *vport, struct hbq_dmabuf *seq_dmabuf)
 {
+        struct hbq_dmabuf *hbq_buf;
         struct lpfc_dmabuf *d_buf, *n_buf;
         struct lpfc_iocbq *first_iocbq, *iocbq;
         struct fc_frame_header *fc_hdr;
         uint32_t sid;
+        uint32_t len, tot_len;
         struct ulp_bde64 *pbde;
 
         fc_hdr = (struct fc_frame_header *)seq_dmabuf->hbuf.virt;
@@ -13655,6 +13820,7 @@ lpfc_prep_seq(struct lpfc_vport *vport, struct hbq_dmabuf *seq_dmabuf)
         lpfc_update_rcv_time_stamp(vport);
         /* get the Remote Port's SID */
         sid = sli4_sid_from_fc_hdr(fc_hdr);
+        tot_len = 0;
         /* Get an iocbq struct to fill in. */
         first_iocbq = lpfc_sli_get_iocbq(vport->phba);
         if (first_iocbq) {
@@ -13662,9 +13828,12 @@ lpfc_prep_seq(struct lpfc_vport *vport, struct hbq_dmabuf *seq_dmabuf)
                 first_iocbq->iocb.unsli3.rcvsli3.acc_len = 0;
                 first_iocbq->iocb.ulpStatus = IOSTAT_SUCCESS;
                 first_iocbq->iocb.ulpCommand = CMD_IOCB_RCV_SEQ64_CX;
-                first_iocbq->iocb.ulpContext = be16_to_cpu(fc_hdr->fh_ox_id);
-                /* iocbq is prepped for internal consumption.  Logical vpi. */
-                first_iocbq->iocb.unsli3.rcvsli3.vpi = vport->vpi;
+                first_iocbq->iocb.ulpContext = NO_XRI;
+                first_iocbq->iocb.unsli3.rcvsli3.ox_id =
+                        be16_to_cpu(fc_hdr->fh_ox_id);
+                /* iocbq is prepped for internal consumption.  Physical vpi. */
+                first_iocbq->iocb.unsli3.rcvsli3.vpi =
+                        vport->phba->vpi_ids[vport->vpi];
                 /* put the first buffer into the first IOCBq */
                 first_iocbq->context2 = &seq_dmabuf->dbuf;
                 first_iocbq->context3 = NULL;
@@ -13672,9 +13841,9 @@ lpfc_prep_seq(struct lpfc_vport *vport, struct hbq_dmabuf *seq_dmabuf)
                 first_iocbq->iocb.un.cont64[0].tus.f.bdeSize =
                                                         LPFC_DATA_BUF_SIZE;
                 first_iocbq->iocb.un.rcvels.remoteID = sid;
-                first_iocbq->iocb.unsli3.rcvsli3.acc_len +=
-                                bf_get(lpfc_rcqe_length,
+                tot_len = bf_get(lpfc_rcqe_length,
                                        &seq_dmabuf->cq_event.cqe.rcqe_cmpl);
+                first_iocbq->iocb.unsli3.rcvsli3.acc_len = tot_len;
         }
         iocbq = first_iocbq;
         /*
@@ -13692,9 +13861,13 @@ lpfc_prep_seq(struct lpfc_vport *vport, struct hbq_dmabuf *seq_dmabuf)
                         pbde = (struct ulp_bde64 *)
                                         &iocbq->iocb.unsli3.sli3Words[4];
                         pbde->tus.f.bdeSize = LPFC_DATA_BUF_SIZE;
-                        first_iocbq->iocb.unsli3.rcvsli3.acc_len +=
-                                bf_get(lpfc_rcqe_length,
-                                       &seq_dmabuf->cq_event.cqe.rcqe_cmpl);
+
+                        /* We need to get the size out of the right CQE */
+                        hbq_buf = container_of(d_buf, struct hbq_dmabuf, dbuf);
+                        len = bf_get(lpfc_rcqe_length,
+                                       &hbq_buf->cq_event.cqe.rcqe_cmpl);
+                        iocbq->iocb.unsli3.rcvsli3.acc_len += len;
+                        tot_len += len;
                 } else {
                         iocbq = lpfc_sli_get_iocbq(vport->phba);
                         if (!iocbq) {
@@ -13712,9 +13885,14 @@ lpfc_prep_seq(struct lpfc_vport *vport, struct hbq_dmabuf *seq_dmabuf)
                         iocbq->iocb.ulpBdeCount = 1;
                         iocbq->iocb.un.cont64[0].tus.f.bdeSize =
                                                         LPFC_DATA_BUF_SIZE;
-                        first_iocbq->iocb.unsli3.rcvsli3.acc_len +=
-                                bf_get(lpfc_rcqe_length,
-                                       &seq_dmabuf->cq_event.cqe.rcqe_cmpl);
+
+                        /* We need to get the size out of the right CQE */
+                        hbq_buf = container_of(d_buf, struct hbq_dmabuf, dbuf);
+                        len = bf_get(lpfc_rcqe_length,
+                                       &hbq_buf->cq_event.cqe.rcqe_cmpl);
+                        tot_len += len;
+                        iocbq->iocb.unsli3.rcvsli3.acc_len = tot_len;
+
                         iocbq->iocb.un.rcvels.remoteID = sid;
                         list_add_tail(&iocbq->list, &first_iocbq->list);
                 }
@@ -13787,7 +13965,13 @@ lpfc_sli4_handle_received_buffer(struct lpfc_hba *phba,
                 lpfc_in_buf_free(phba, &dmabuf->dbuf);
                 return;
         }
-        fcfi = bf_get(lpfc_rcqe_fcf_id, &dmabuf->cq_event.cqe.rcqe_cmpl);
+        if ((bf_get(lpfc_cqe_code,
+                    &dmabuf->cq_event.cqe.rcqe_cmpl) == CQE_CODE_RECEIVE_V1))
+                fcfi = bf_get(lpfc_rcqe_fcf_id_v1,
+                              &dmabuf->cq_event.cqe.rcqe_cmpl);
+        else
+                fcfi = bf_get(lpfc_rcqe_fcf_id,
+                              &dmabuf->cq_event.cqe.rcqe_cmpl);
         vport = lpfc_fc_frame_to_vport(phba, fc_hdr, fcfi);
         if (!vport || !(vport->vpi_state & LPFC_VPI_REGISTERED)) {
                 /* throw out the frame */
@@ -14451,6 +14635,92 @@ fail_fcf_read:
 }
 
 /**
+ * lpfc_check_next_fcf_pri
+ * phba pointer to the lpfc_hba struct for this port.
+ * This routine is called from the lpfc_sli4_fcf_rr_next_index_get
+ * routine when the rr_bmask is empty. The FCF indecies are put into the
+ * rr_bmask based on their priority level. Starting from the highest priority
+ * to the lowest. The most likely FCF candidate will be in the highest
+ * priority group. When this routine is called it searches the fcf_pri list for
+ * next lowest priority group and repopulates the rr_bmask with only those
+ * fcf_indexes.
+ * returns:
+ * 1=success 0=failure
+ **/
+int
+lpfc_check_next_fcf_pri_level(struct lpfc_hba *phba)
+{
+        uint16_t next_fcf_pri;
+        uint16_t last_index;
+        struct lpfc_fcf_pri *fcf_pri;
+        int rc;
+        int ret = 0;
+
+        last_index = find_first_bit(phba->fcf.fcf_rr_bmask,
+                        LPFC_SLI4_FCF_TBL_INDX_MAX);
+        lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
+                        "3060 Last IDX %d\n", last_index);
+        if (list_empty(&phba->fcf.fcf_pri_list)) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_FIP,
+                        "3061 Last IDX %d\n", last_index);
+                return 0; /* Empty rr list */
+        }
+        next_fcf_pri = 0;
+        /*
+         * Clear the rr_bmask and set all of the bits that are at this
+         * priority.
+         */
+        memset(phba->fcf.fcf_rr_bmask, 0,
+                        sizeof(*phba->fcf.fcf_rr_bmask));
+        spin_lock_irq(&phba->hbalock);
+        list_for_each_entry(fcf_pri, &phba->fcf.fcf_pri_list, list) {
+                if (fcf_pri->fcf_rec.flag & LPFC_FCF_FLOGI_FAILED)
+                        continue;
+                /*
+                 * the 1st priority that has not FLOGI failed
+                 * will be the highest.
+                 */
+                if (!next_fcf_pri)
+                        next_fcf_pri = fcf_pri->fcf_rec.priority;
+                spin_unlock_irq(&phba->hbalock);
+                if (fcf_pri->fcf_rec.priority == next_fcf_pri) {
+                        rc = lpfc_sli4_fcf_rr_index_set(phba,
+                                                fcf_pri->fcf_rec.fcf_index);
+                        if (rc)
+                                return 0;
+                }
+                spin_lock_irq(&phba->hbalock);
+        }
+        /*
+         * if next_fcf_pri was not set above and the list is not empty then
+         * we have failed flogis on all of them. So reset flogi failed
+         * and start at the begining.
+         */
+        if (!next_fcf_pri && !list_empty(&phba->fcf.fcf_pri_list)) {
+                list_for_each_entry(fcf_pri, &phba->fcf.fcf_pri_list, list) {
+                        fcf_pri->fcf_rec.flag &= ~LPFC_FCF_FLOGI_FAILED;
+                        /*
+                         * the 1st priority that has not FLOGI failed
+                         * will be the highest.
+                         */
+                        if (!next_fcf_pri)
+                                next_fcf_pri = fcf_pri->fcf_rec.priority;
+                        spin_unlock_irq(&phba->hbalock);
+                        if (fcf_pri->fcf_rec.priority == next_fcf_pri) {
+                                rc = lpfc_sli4_fcf_rr_index_set(phba,
+                                                fcf_pri->fcf_rec.fcf_index);
+                                if (rc)
+                                        return 0;
+                        }
+                        spin_lock_irq(&phba->hbalock);
+                }
+        } else
+                ret = 1;
+        spin_unlock_irq(&phba->hbalock);
+
+        return ret;
+}
+/**
  * lpfc_sli4_fcf_rr_next_index_get - Get next eligible fcf record index
  * @phba: pointer to lpfc hba data structure.
  *
@@ -14466,6 +14736,7 @@ lpfc_sli4_fcf_rr_next_index_get(struct lpfc_hba *phba)
         uint16_t next_fcf_index;
 
         /* Search start from next bit of currently registered FCF index */
+next_priority:
         next_fcf_index = (phba->fcf.current_rec.fcf_indx + 1) %
                                         LPFC_SLI4_FCF_TBL_INDX_MAX;
         next_fcf_index = find_next_bit(phba->fcf.fcf_rr_bmask,
@@ -14473,17 +14744,46 @@ lpfc_sli4_fcf_rr_next_index_get(struct lpfc_hba *phba)
                                        next_fcf_index);
 
         /* Wrap around condition on phba->fcf.fcf_rr_bmask */
-        if (next_fcf_index >= LPFC_SLI4_FCF_TBL_INDX_MAX)
+        if (next_fcf_index >= LPFC_SLI4_FCF_TBL_INDX_MAX) {
+                /*
+                 * If we have wrapped then we need to clear the bits that
+                 * have been tested so that we can detect when we should
+                 * change the priority level.
+                 */
                 next_fcf_index = find_next_bit(phba->fcf.fcf_rr_bmask,
                                                LPFC_SLI4_FCF_TBL_INDX_MAX, 0);
+        }
+
 
         /* Check roundrobin failover list empty condition */
-        if (next_fcf_index >= LPFC_SLI4_FCF_TBL_INDX_MAX) {
+        if (next_fcf_index >= LPFC_SLI4_FCF_TBL_INDX_MAX ||
+                next_fcf_index == phba->fcf.current_rec.fcf_indx) {
+                /*
+                 * If next fcf index is not found check if there are lower
+                 * Priority level fcf's in the fcf_priority list.
+                 * Set up the rr_bmask with all of the avaiable fcf bits
+                 * at that level and continue the selection process.
+                 */
+                if (lpfc_check_next_fcf_pri_level(phba))
+                        goto next_priority;
                 lpfc_printf_log(phba, KERN_WARNING, LOG_FIP,
                                 "2844 No roundrobin failover FCF available\n");
-                return LPFC_FCOE_FCF_NEXT_NONE;
+                if (next_fcf_index >= LPFC_SLI4_FCF_TBL_INDX_MAX)
+                        return LPFC_FCOE_FCF_NEXT_NONE;
+                else {
+                        lpfc_printf_log(phba, KERN_WARNING, LOG_FIP,
+                                "3063 Only FCF available idx %d, flag %x\n",
+                                next_fcf_index,
+                        phba->fcf.fcf_pri[next_fcf_index].fcf_rec.flag);
+                        return next_fcf_index;
+                }
         }
 
+        if (next_fcf_index < LPFC_SLI4_FCF_TBL_INDX_MAX &&
+                phba->fcf.fcf_pri[next_fcf_index].fcf_rec.flag &
+                LPFC_FCF_FLOGI_FAILED)
+                goto next_priority;
+
         lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
                         "2845 Get next roundrobin failover FCF (x%x)\n",
                         next_fcf_index);
@@ -14535,6 +14835,7 @@ lpfc_sli4_fcf_rr_index_set(struct lpfc_hba *phba, uint16_t fcf_index)
 void
 lpfc_sli4_fcf_rr_index_clear(struct lpfc_hba *phba, uint16_t fcf_index)
 {
+        struct lpfc_fcf_pri *fcf_pri;
         if (fcf_index >= LPFC_SLI4_FCF_TBL_INDX_MAX) {
                 lpfc_printf_log(phba, KERN_ERR, LOG_FIP,
                                 "2762 FCF (x%x) reached driver's book "
@@ -14543,6 +14844,14 @@ lpfc_sli4_fcf_rr_index_clear(struct lpfc_hba *phba, uint16_t fcf_index)
                 return;
         }
         /* Clear the eligible FCF record index bmask */
+        spin_lock_irq(&phba->hbalock);
+        list_for_each_entry(fcf_pri, &phba->fcf.fcf_pri_list, list) {
+                if (fcf_pri->fcf_rec.fcf_index == fcf_index) {
+                        list_del_init(&fcf_pri->list);
+                        break;
+                }
+        }
+        spin_unlock_irq(&phba->hbalock);
         clear_bit(fcf_index, phba->fcf.fcf_rr_bmask);
 
         lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
diff --git a/drivers/scsi/lpfc/lpfc_sli4.h b/drivers/scsi/lpfc/lpfc_sli4.h
index 4b1703554a26..19bb87ae8597 100644
--- a/drivers/scsi/lpfc/lpfc_sli4.h
+++ b/drivers/scsi/lpfc/lpfc_sli4.h
@@ -81,6 +81,8 @@
          (fc_hdr)->fh_f_ctl[1] <<  8 | \
          (fc_hdr)->fh_f_ctl[2])
 
+#define LPFC_FW_RESET_MAXIMUM_WAIT_10MS_CNT 12000
+
 enum lpfc_sli4_queue_type {
         LPFC_EQ,
         LPFC_GCQ,
@@ -157,6 +159,25 @@ struct lpfc_fcf_rec {
 #define RECORD_VALID    0x02
 };
 
+struct lpfc_fcf_pri_rec {
+        uint16_t fcf_index;
+#define LPFC_FCF_ON_PRI_LIST 0x0001
+#define LPFC_FCF_FLOGI_FAILED 0x0002
+        uint16_t flag;
+        uint32_t priority;
+};
+
+struct lpfc_fcf_pri {
+        struct list_head list;
+        struct lpfc_fcf_pri_rec fcf_rec;
+};
+
+/*
+ * Maximum FCF table index, it is for driver internal book keeping, it
+ * just needs to be no less than the supported HBA's FCF table size.
+ */
+#define LPFC_SLI4_FCF_TBL_INDX_MAX      32
+
 struct lpfc_fcf {
         uint16_t fcfi;
         uint32_t fcf_flag;
@@ -176,15 +197,13 @@ struct lpfc_fcf {
         uint32_t eligible_fcf_cnt;
         struct lpfc_fcf_rec current_rec;
         struct lpfc_fcf_rec failover_rec;
+        struct list_head fcf_pri_list;
+        struct lpfc_fcf_pri fcf_pri[LPFC_SLI4_FCF_TBL_INDX_MAX];
+        uint32_t current_fcf_scan_pri;
         struct timer_list redisc_wait;
         unsigned long *fcf_rr_bmask; /* Eligible FCF indexes for RR failover */
 };
 
-/*
- * Maximum FCF table index, it is for driver internal book keeping, it
- * just needs to be no less than the supported HBA's FCF table size.
- */
-#define LPFC_SLI4_FCF_TBL_INDX_MAX      32
 
 #define LPFC_REGION23_SIGNATURE "RG23"
 #define LPFC_REGION23_VERSION   1
diff --git a/drivers/scsi/lpfc/lpfc_version.h b/drivers/scsi/lpfc/lpfc_version.h
index c03921b1232c..c1e0ae94d9f4 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.23"
+#define LPFC_DRIVER_VERSION "8.3.25"
 #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/megaraid_sas.h b/drivers/scsi/megaraid/megaraid_sas.h
index 7370c084b178..3948a00d81f4 100644
--- a/drivers/scsi/megaraid/megaraid_sas.h
+++ b/drivers/scsi/megaraid/megaraid_sas.h
@@ -33,9 +33,9 @@
 /*
  * MegaRAID SAS Driver meta data
  */
-#define MEGASAS_VERSION                         "00.00.05.38-rc1"
-#define MEGASAS_RELDATE                         "May. 11, 2011"
-#define MEGASAS_EXT_VERSION                     "Wed. May. 11 17:00:00 PDT 2011"
+#define MEGASAS_VERSION                         "00.00.05.40-rc1"
+#define MEGASAS_RELDATE                         "Jul. 26, 2011"
+#define MEGASAS_EXT_VERSION                     "Tue. Jul. 26 17:00:00 PDT 2011"
 
 /*
  * Device IDs
diff --git a/drivers/scsi/megaraid/megaraid_sas_base.c b/drivers/scsi/megaraid/megaraid_sas_base.c
index 2d8cdce7b2f5..776d01988660 100644
--- a/drivers/scsi/megaraid/megaraid_sas_base.c
+++ b/drivers/scsi/megaraid/megaraid_sas_base.c
@@ -18,7 +18,7 @@
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  *
  *  FILE: megaraid_sas_base.c
- *  Version : v00.00.05.38-rc1
+ *  Version : v00.00.05.40-rc1
  *
  *  Authors: LSI Corporation
  *           Sreenivas Bagalkote
@@ -54,6 +54,7 @@
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_host.h>
+#include <scsi/scsi_tcq.h>
 #include "megaraid_sas_fusion.h"
 #include "megaraid_sas.h"
 
@@ -2057,6 +2058,20 @@ megasas_service_aen(struct megasas_instance *instance, struct megasas_cmd *cmd)
         }
 }
 
+static int megasas_change_queue_depth(struct scsi_device *sdev,
+                                      int queue_depth, int reason)
+{
+        if (reason != SCSI_QDEPTH_DEFAULT)
+                return -EOPNOTSUPP;
+
+        if (queue_depth > sdev->host->can_queue)
+                queue_depth = sdev->host->can_queue;
+        scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev),
+                                queue_depth);
+
+        return queue_depth;
+}
+
 /*
  * Scsi host template for megaraid_sas driver
  */
@@ -2074,6 +2089,7 @@ static struct scsi_host_template megasas_template = {
         .eh_timed_out = megasas_reset_timer,
         .bios_param = megasas_bios_param,
         .use_clustering = ENABLE_CLUSTERING,
+        .change_queue_depth = megasas_change_queue_depth,
 };
 
 /**
diff --git a/drivers/scsi/megaraid/megaraid_sas_fp.c b/drivers/scsi/megaraid/megaraid_sas_fp.c
index 8fe3a45794fc..5a5af1fe7581 100644
--- a/drivers/scsi/megaraid/megaraid_sas_fp.c
+++ b/drivers/scsi/megaraid/megaraid_sas_fp.c
@@ -288,7 +288,6 @@ u8 MR_GetPhyParams(u32 ld, u64 stripRow, u16 stripRef, u64 *pdBlock,
                                 /* Get dev handle from Pd */
                                 *pDevHandle = MR_PdDevHandleGet(pd, map);
                 }
-                retval = FALSE;
         }
 
         *pdBlock += stripRef + MR_LdSpanPtrGet(ld, span, map)->startBlk;
diff --git a/drivers/scsi/mpt2sas/mpt2sas_scsih.c b/drivers/scsi/mpt2sas/mpt2sas_scsih.c
index 939f283d0c28..6abd2fcc43e2 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_scsih.c
+++ b/drivers/scsi/mpt2sas/mpt2sas_scsih.c
@@ -4258,6 +4258,7 @@ _scsih_io_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
         u32 log_info;
         struct MPT2SAS_DEVICE *sas_device_priv_data;
         u32 response_code = 0;
+        unsigned long flags;
 
         mpi_reply = mpt2sas_base_get_reply_virt_addr(ioc, reply);
         scmd = _scsih_scsi_lookup_get_clear(ioc, smid);
@@ -4282,6 +4283,9 @@ _scsih_io_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
          * the failed direct I/O should be redirected to volume
          */
         if (_scsih_scsi_direct_io_get(ioc, smid)) {
+                spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
+                ioc->scsi_lookup[smid - 1].scmd = scmd;
+                spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
                 _scsih_scsi_direct_io_set(ioc, smid, 0);
                 memcpy(mpi_request->CDB.CDB32, scmd->cmnd, scmd->cmd_len);
                 mpi_request->DevHandle =
diff --git a/drivers/scsi/mvsas/Kconfig b/drivers/scsi/mvsas/Kconfig
index c82b012aba37..78f7e20a0c1c 100644
--- a/drivers/scsi/mvsas/Kconfig
+++ b/drivers/scsi/mvsas/Kconfig
@@ -3,7 +3,7 @@
 #
 # Copyright 2007 Red Hat, Inc.
 # Copyright 2008 Marvell. <kewei@marvell.com>
-# Copyright 2009-20011 Marvell. <yuxiangl@marvell.com>
+# Copyright 2009-2011 Marvell. <yuxiangl@marvell.com>
 #
 # This file is licensed under GPLv2.
 #
@@ -41,3 +41,10 @@ config SCSI_MVSAS_DEBUG
         help
                 Compiles the 88SE64XX/88SE94XX driver in debug mode.  In debug mode,
                 the driver prints some messages to the console.
+config SCSI_MVSAS_TASKLET
+        bool "Support for interrupt tasklet"
+        default n
+        depends on SCSI_MVSAS
+        help
+                Compiles the 88SE64xx/88SE94xx driver in interrupt tasklet mode.In this mode,
+                the interrupt will schedule a tasklet.
diff --git a/drivers/scsi/mvsas/mv_64xx.c b/drivers/scsi/mvsas/mv_64xx.c
index 13c960481391..8ba47229049f 100644
--- a/drivers/scsi/mvsas/mv_64xx.c
+++ b/drivers/scsi/mvsas/mv_64xx.c
@@ -33,7 +33,6 @@ static void mvs_64xx_detect_porttype(struct mvs_info *mvi, int i)
         u32 reg;
         struct mvs_phy *phy = &mvi->phy[i];
 
-        /* TODO check & save device type */
         reg = mr32(MVS_GBL_PORT_TYPE);
         phy->phy_type &= ~(PORT_TYPE_SAS | PORT_TYPE_SATA);
         if (reg & MODE_SAS_SATA & (1 << i))
@@ -48,7 +47,7 @@ static void __devinit mvs_64xx_enable_xmt(struct mvs_info *mvi, int phy_id)
         u32 tmp;
 
         tmp = mr32(MVS_PCS);
-        if (mvi->chip->n_phy <= 4)
+        if (mvi->chip->n_phy <= MVS_SOC_PORTS)
                 tmp |= 1 << (phy_id + PCS_EN_PORT_XMT_SHIFT);
         else
                 tmp |= 1 << (phy_id + PCS_EN_PORT_XMT_SHIFT2);
@@ -58,24 +57,16 @@ static void __devinit mvs_64xx_enable_xmt(struct mvs_info *mvi, int phy_id)
 static void __devinit mvs_64xx_phy_hacks(struct mvs_info *mvi)
 {
         void __iomem *regs = mvi->regs;
+        int i;
 
         mvs_phy_hacks(mvi);
 
         if (!(mvi->flags & MVF_FLAG_SOC)) {
-                /* TEST - for phy decoding error, adjust voltage levels */
-                mw32(MVS_P0_VSR_ADDR + 0, 0x8);
-                mw32(MVS_P0_VSR_DATA + 0, 0x2F0);
-
-                mw32(MVS_P0_VSR_ADDR + 8, 0x8);
-                mw32(MVS_P0_VSR_DATA + 8, 0x2F0);
-
-                mw32(MVS_P0_VSR_ADDR + 16, 0x8);
-                mw32(MVS_P0_VSR_DATA + 16, 0x2F0);
-
-                mw32(MVS_P0_VSR_ADDR + 24, 0x8);
-                mw32(MVS_P0_VSR_DATA + 24, 0x2F0);
+                for (i = 0; i < MVS_SOC_PORTS; i++) {
+                        mvs_write_port_vsr_addr(mvi, i, VSR_PHY_MODE8);
+                        mvs_write_port_vsr_data(mvi, i, 0x2F0);
+                }
         } else {
-                int i;
                 /* disable auto port detection */
                 mw32(MVS_GBL_PORT_TYPE, 0);
                 for (i = 0; i < mvi->chip->n_phy; i++) {
@@ -95,7 +86,7 @@ static void mvs_64xx_stp_reset(struct mvs_info *mvi, u32 phy_id)
         u32 reg, tmp;
 
         if (!(mvi->flags & MVF_FLAG_SOC)) {
-                if (phy_id < 4)
+                if (phy_id < MVS_SOC_PORTS)
                         pci_read_config_dword(mvi->pdev, PCR_PHY_CTL, &reg);
                 else
                         pci_read_config_dword(mvi->pdev, PCR_PHY_CTL2, &reg);
@@ -104,13 +95,13 @@ static void mvs_64xx_stp_reset(struct mvs_info *mvi, u32 phy_id)
                 reg = mr32(MVS_PHY_CTL);
 
         tmp = reg;
-        if (phy_id < 4)
+        if (phy_id < MVS_SOC_PORTS)
                 tmp |= (1U << phy_id) << PCTL_LINK_OFFS;
         else
-                tmp |= (1U << (phy_id - 4)) << PCTL_LINK_OFFS;
+                tmp |= (1U << (phy_id - MVS_SOC_PORTS)) << PCTL_LINK_OFFS;
 
         if (!(mvi->flags & MVF_FLAG_SOC)) {
-                if (phy_id < 4) {
+                if (phy_id < MVS_SOC_PORTS) {
                         pci_write_config_dword(mvi->pdev, PCR_PHY_CTL, tmp);
                         mdelay(10);
                         pci_write_config_dword(mvi->pdev, PCR_PHY_CTL, reg);
@@ -133,9 +124,9 @@ static void mvs_64xx_phy_reset(struct mvs_info *mvi, u32 phy_id, int hard)
         tmp &= ~PHYEV_RDY_CH;
         mvs_write_port_irq_stat(mvi, phy_id, tmp);
         tmp = mvs_read_phy_ctl(mvi, phy_id);
-        if (hard == 1)
+        if (hard == MVS_HARD_RESET)
                 tmp |= PHY_RST_HARD;
-        else if (hard == 0)
+        else if (hard == MVS_SOFT_RESET)
                 tmp |= PHY_RST;
         mvs_write_phy_ctl(mvi, phy_id, tmp);
         if (hard) {
@@ -321,6 +312,11 @@ static int __devinit mvs_64xx_init(struct mvs_info *mvi)
         /* init phys */
         mvs_64xx_phy_hacks(mvi);
 
+        tmp = mvs_cr32(mvi, CMD_PHY_MODE_21);
+        tmp &= 0x0000ffff;
+        tmp |= 0x00fa0000;
+        mvs_cw32(mvi, CMD_PHY_MODE_21, tmp);
+
         /* enable auto port detection */
         mw32(MVS_GBL_PORT_TYPE, MODE_AUTO_DET_EN);
 
@@ -346,7 +342,7 @@ static int __devinit mvs_64xx_init(struct mvs_info *mvi)
 
                 mvs_64xx_enable_xmt(mvi, i);
 
-                mvs_64xx_phy_reset(mvi, i, 1);
+                mvs_64xx_phy_reset(mvi, i, MVS_HARD_RESET);
                 msleep(500);
                 mvs_64xx_detect_porttype(mvi, i);
         }
@@ -377,13 +373,7 @@ static int __devinit mvs_64xx_init(struct mvs_info *mvi)
                 mvs_update_phyinfo(mvi, i, 1);
         }
 
-        /* FIXME: update wide port bitmaps */
-
         /* little endian for open address and command table, etc. */
-        /*
-         * it seems that ( from the spec ) turning on big-endian won't
-         * do us any good on big-endian machines, need further confirmation
-         */
         cctl = mr32(MVS_CTL);
         cctl |= CCTL_ENDIAN_CMD;
         cctl |= CCTL_ENDIAN_DATA;
@@ -394,15 +384,19 @@ static int __devinit mvs_64xx_init(struct mvs_info *mvi)
         /* reset CMD queue */
         tmp = mr32(MVS_PCS);
         tmp |= PCS_CMD_RST;
+        tmp &= ~PCS_SELF_CLEAR;
         mw32(MVS_PCS, tmp);
-        /* interrupt coalescing may cause missing HW interrput in some case,
-         * and the max count is 0x1ff, while our max slot is 0x200,
+        /*
+         * the max count is 0x1ff, while our max slot is 0x200,
          * it will make count 0.
          */
         tmp = 0;
-        mw32(MVS_INT_COAL, tmp);
+        if (MVS_CHIP_SLOT_SZ > 0x1ff)
+                mw32(MVS_INT_COAL, 0x1ff | COAL_EN);
+        else
+                mw32(MVS_INT_COAL, MVS_CHIP_SLOT_SZ | COAL_EN);
 
-        tmp = 0x100;
+        tmp = 0x10000 | interrupt_coalescing;
         mw32(MVS_INT_COAL_TMOUT, tmp);
 
         /* ladies and gentlemen, start your engines */
@@ -477,13 +471,11 @@ static irqreturn_t mvs_64xx_isr(struct mvs_info *mvi, int irq, u32 stat)
 
         /* clear CMD_CMPLT ASAP */
         mw32_f(MVS_INT_STAT, CINT_DONE);
-#ifndef MVS_USE_TASKLET
+
         spin_lock(&mvi->lock);
-#endif
         mvs_int_full(mvi);
-#ifndef MVS_USE_TASKLET
         spin_unlock(&mvi->lock);
-#endif
+
         return IRQ_HANDLED;
 }
 
@@ -630,7 +622,6 @@ static void mvs_64xx_phy_work_around(struct mvs_info *mvi, int i)
 {
         u32 tmp;
         struct mvs_phy *phy = &mvi->phy[i];
-        /* workaround for HW phy decoding error on 1.5g disk drive */
         mvs_write_port_vsr_addr(mvi, i, VSR_PHY_MODE6);
         tmp = mvs_read_port_vsr_data(mvi, i);
         if (((phy->phy_status & PHY_NEG_SPP_PHYS_LINK_RATE_MASK) >>
@@ -661,7 +652,7 @@ void mvs_64xx_phy_set_link_rate(struct mvs_info *mvi, u32 phy_id,
                 tmp |= lrmax;
         }
         mvs_write_phy_ctl(mvi, phy_id, tmp);
-        mvs_64xx_phy_reset(mvi, phy_id, 1);
+        mvs_64xx_phy_reset(mvi, phy_id, MVS_HARD_RESET);
 }
 
 static void mvs_64xx_clear_active_cmds(struct mvs_info *mvi)
@@ -744,11 +735,13 @@ int mvs_64xx_spi_waitdataready(struct mvs_info *mvi, u32 timeout)
         return -1;
 }
 
-#ifndef DISABLE_HOTPLUG_DMA_FIX
-void mvs_64xx_fix_dma(dma_addr_t buf_dma, int buf_len, int from, void *prd)
+void mvs_64xx_fix_dma(struct mvs_info *mvi, u32 phy_mask,
+                                int buf_len, int from, void *prd)
 {
         int i;
         struct mvs_prd *buf_prd = prd;
+        dma_addr_t buf_dma = mvi->bulk_buffer_dma;
+
         buf_prd += from;
         for (i = 0; i < MAX_SG_ENTRY - from; i++) {
                 buf_prd->addr = cpu_to_le64(buf_dma);
@@ -756,7 +749,28 @@ void mvs_64xx_fix_dma(dma_addr_t buf_dma, int buf_len, int from, void *prd)
                 ++buf_prd;
         }
 }
-#endif
+
+static void mvs_64xx_tune_interrupt(struct mvs_info *mvi, u32 time)
+{
+        void __iomem *regs = mvi->regs;
+        u32 tmp = 0;
+        /*
+         * the max count is 0x1ff, while our max slot is 0x200,
+         * it will make count 0.
+         */
+        if (time == 0) {
+                mw32(MVS_INT_COAL, 0);
+                mw32(MVS_INT_COAL_TMOUT, 0x10000);
+        } else {
+                if (MVS_CHIP_SLOT_SZ > 0x1ff)
+                        mw32(MVS_INT_COAL, 0x1ff|COAL_EN);
+                else
+                        mw32(MVS_INT_COAL, MVS_CHIP_SLOT_SZ|COAL_EN);
+
+                tmp = 0x10000 | time;
+                mw32(MVS_INT_COAL_TMOUT, tmp);
+        }
+}
 
 const struct mvs_dispatch mvs_64xx_dispatch = {
         "mv64xx",
@@ -780,7 +794,6 @@ const struct mvs_dispatch mvs_64xx_dispatch = {
         mvs_write_port_irq_stat,
         mvs_read_port_irq_mask,
         mvs_write_port_irq_mask,
-        mvs_get_sas_addr,
         mvs_64xx_command_active,
         mvs_64xx_clear_srs_irq,
         mvs_64xx_issue_stop,
@@ -808,8 +821,8 @@ const struct mvs_dispatch mvs_64xx_dispatch = {
         mvs_64xx_spi_buildcmd,
         mvs_64xx_spi_issuecmd,
         mvs_64xx_spi_waitdataready,
-#ifndef DISABLE_HOTPLUG_DMA_FIX
         mvs_64xx_fix_dma,
-#endif
+        mvs_64xx_tune_interrupt,
+        NULL,
 };
 
diff --git a/drivers/scsi/mvsas/mv_94xx.c b/drivers/scsi/mvsas/mv_94xx.c
index 78162c3c36e6..3501291618fd 100644
--- a/drivers/scsi/mvsas/mv_94xx.c
+++ b/drivers/scsi/mvsas/mv_94xx.c
@@ -48,6 +48,216 @@ static void mvs_94xx_detect_porttype(struct mvs_info *mvi, int i)
         }
 }
 
+void set_phy_tuning(struct mvs_info *mvi, int phy_id,
+                        struct phy_tuning phy_tuning)
+{
+        u32 tmp, setting_0 = 0, setting_1 = 0;
+        u8 i;
+
+        /* Remap information for B0 chip:
+        *
+        * R0Ch -> R118h[15:0] (Adapted DFE F3 - F5 coefficient)
+        * R0Dh -> R118h[31:16] (Generation 1 Setting 0)
+        * R0Eh -> R11Ch[15:0]  (Generation 1 Setting 1)
+        * R0Fh -> R11Ch[31:16] (Generation 2 Setting 0)
+        * R10h -> R120h[15:0]  (Generation 2 Setting 1)
+        * R11h -> R120h[31:16] (Generation 3 Setting 0)
+        * R12h -> R124h[15:0]  (Generation 3 Setting 1)
+        * R13h -> R124h[31:16] (Generation 4 Setting 0 (Reserved))
+        */
+
+        /* A0 has a different set of registers */
+        if (mvi->pdev->revision == VANIR_A0_REV)
+                return;
+
+        for (i = 0; i < 3; i++) {
+                /* loop 3 times, set Gen 1, Gen 2, Gen 3 */
+                switch (i) {
+                case 0:
+                        setting_0 = GENERATION_1_SETTING;
+                        setting_1 = GENERATION_1_2_SETTING;
+                        break;
+                case 1:
+                        setting_0 = GENERATION_1_2_SETTING;
+                        setting_1 = GENERATION_2_3_SETTING;
+                        break;
+                case 2:
+                        setting_0 = GENERATION_2_3_SETTING;
+                        setting_1 = GENERATION_3_4_SETTING;
+                        break;
+                }
+
+                /* Set:
+                *
+                * Transmitter Emphasis Enable
+                * Transmitter Emphasis Amplitude
+                * Transmitter Amplitude
+                */
+                mvs_write_port_vsr_addr(mvi, phy_id, setting_0);
+                tmp = mvs_read_port_vsr_data(mvi, phy_id);
+                tmp &= ~(0xFBE << 16);
+                tmp |= (((phy_tuning.trans_emp_en << 11) |
+                        (phy_tuning.trans_emp_amp << 7) |
+                        (phy_tuning.trans_amp << 1)) << 16);
+                mvs_write_port_vsr_data(mvi, phy_id, tmp);
+
+                /* Set Transmitter Amplitude Adjust */
+                mvs_write_port_vsr_addr(mvi, phy_id, setting_1);
+                tmp = mvs_read_port_vsr_data(mvi, phy_id);
+                tmp &= ~(0xC000);
+                tmp |= (phy_tuning.trans_amp_adj << 14);
+                mvs_write_port_vsr_data(mvi, phy_id, tmp);
+        }
+}
+
+void set_phy_ffe_tuning(struct mvs_info *mvi, int phy_id,
+                                struct ffe_control ffe)
+{
+        u32 tmp;
+
+        /* Don't run this if A0/B0 */
+        if ((mvi->pdev->revision == VANIR_A0_REV)
+                || (mvi->pdev->revision == VANIR_B0_REV))
+                return;
+
+        /* FFE Resistor and Capacitor */
+        /* R10Ch DFE Resolution Control/Squelch and FFE Setting
+         *
+         * FFE_FORCE            [7]
+         * FFE_RES_SEL          [6:4]
+         * FFE_CAP_SEL          [3:0]
+         */
+        mvs_write_port_vsr_addr(mvi, phy_id, VSR_PHY_FFE_CONTROL);
+        tmp = mvs_read_port_vsr_data(mvi, phy_id);
+        tmp &= ~0xFF;
+
+        /* Read from HBA_Info_Page */
+        tmp |= ((0x1 << 7) |
+                (ffe.ffe_rss_sel << 4) |
+                (ffe.ffe_cap_sel << 0));
+
+        mvs_write_port_vsr_data(mvi, phy_id, tmp);
+
+        /* R064h PHY Mode Register 1
+         *
+         * DFE_DIS              18
+         */
+        mvs_write_port_vsr_addr(mvi, phy_id, VSR_REF_CLOCK_CRTL);
+        tmp = mvs_read_port_vsr_data(mvi, phy_id);
+        tmp &= ~0x40001;
+        /* Hard coding */
+        /* No defines in HBA_Info_Page */
+        tmp |= (0 << 18);
+        mvs_write_port_vsr_data(mvi, phy_id, tmp);
+
+        /* R110h DFE F0-F1 Coefficient Control/DFE Update Control
+         *
+         * DFE_UPDATE_EN        [11:6]
+         * DFE_FX_FORCE         [5:0]
+         */
+        mvs_write_port_vsr_addr(mvi, phy_id, VSR_PHY_DFE_UPDATE_CRTL);
+        tmp = mvs_read_port_vsr_data(mvi, phy_id);
+        tmp &= ~0xFFF;
+        /* Hard coding */
+        /* No defines in HBA_Info_Page */
+        tmp |= ((0x3F << 6) | (0x0 << 0));
+        mvs_write_port_vsr_data(mvi, phy_id, tmp);
+
+        /* R1A0h Interface and Digital Reference Clock Control/Reserved_50h
+         *
+         * FFE_TRAIN_EN         3
+         */
+        mvs_write_port_vsr_addr(mvi, phy_id, VSR_REF_CLOCK_CRTL);
+        tmp = mvs_read_port_vsr_data(mvi, phy_id);
+        tmp &= ~0x8;
+        /* Hard coding */
+        /* No defines in HBA_Info_Page */
+        tmp |= (0 << 3);
+        mvs_write_port_vsr_data(mvi, phy_id, tmp);
+}
+
+/*Notice: this function must be called when phy is disabled*/
+void set_phy_rate(struct mvs_info *mvi, int phy_id, u8 rate)
+{
+        union reg_phy_cfg phy_cfg, phy_cfg_tmp;
+        mvs_write_port_vsr_addr(mvi, phy_id, VSR_PHY_MODE2);
+        phy_cfg_tmp.v = mvs_read_port_vsr_data(mvi, phy_id);
+        phy_cfg.v = 0;
+        phy_cfg.u.disable_phy = phy_cfg_tmp.u.disable_phy;
+        phy_cfg.u.sas_support = 1;
+        phy_cfg.u.sata_support = 1;
+        phy_cfg.u.sata_host_mode = 1;
+
+        switch (rate) {
+        case 0x0:
+                /* support 1.5 Gbps */
+                phy_cfg.u.speed_support = 1;
+                phy_cfg.u.snw_3_support = 0;
+                phy_cfg.u.tx_lnk_parity = 1;
+                phy_cfg.u.tx_spt_phs_lnk_rate = 0x30;
+                break;
+        case 0x1:
+
+                /* support 1.5, 3.0 Gbps */
+                phy_cfg.u.speed_support = 3;
+                phy_cfg.u.tx_spt_phs_lnk_rate = 0x3c;
+                phy_cfg.u.tx_lgcl_lnk_rate = 0x08;
+                break;
+        case 0x2:
+        default:
+                /* support 1.5, 3.0, 6.0 Gbps */
+                phy_cfg.u.speed_support = 7;
+                phy_cfg.u.snw_3_support = 1;
+                phy_cfg.u.tx_lnk_parity = 1;
+                phy_cfg.u.tx_spt_phs_lnk_rate = 0x3f;
+                phy_cfg.u.tx_lgcl_lnk_rate = 0x09;
+                break;
+        }
+        mvs_write_port_vsr_data(mvi, phy_id, phy_cfg.v);
+}
+
+static void __devinit
+mvs_94xx_config_reg_from_hba(struct mvs_info *mvi, int phy_id)
+{
+        u32 temp;
+        temp = (u32)(*(u32 *)&mvi->hba_info_param.phy_tuning[phy_id]);
+        if (temp == 0xFFFFFFFFL) {
+                mvi->hba_info_param.phy_tuning[phy_id].trans_emp_amp = 0x6;
+                mvi->hba_info_param.phy_tuning[phy_id].trans_amp = 0x1A;
+                mvi->hba_info_param.phy_tuning[phy_id].trans_amp_adj = 0x3;
+        }
+
+        temp = (u8)(*(u8 *)&mvi->hba_info_param.ffe_ctl[phy_id]);
+        if (temp == 0xFFL) {
+                switch (mvi->pdev->revision) {
+                case VANIR_A0_REV:
+                case VANIR_B0_REV:
+                        mvi->hba_info_param.ffe_ctl[phy_id].ffe_rss_sel = 0x7;
+                        mvi->hba_info_param.ffe_ctl[phy_id].ffe_cap_sel = 0x7;
+                        break;
+                case VANIR_C0_REV:
+                case VANIR_C1_REV:
+                case VANIR_C2_REV:
+                default:
+                        mvi->hba_info_param.ffe_ctl[phy_id].ffe_rss_sel = 0x7;
+                        mvi->hba_info_param.ffe_ctl[phy_id].ffe_cap_sel = 0xC;
+                        break;
+                }
+        }
+
+        temp = (u8)(*(u8 *)&mvi->hba_info_param.phy_rate[phy_id]);
+        if (temp == 0xFFL)
+                /*set default phy_rate = 6Gbps*/
+                mvi->hba_info_param.phy_rate[phy_id] = 0x2;
+
+        set_phy_tuning(mvi, phy_id,
+                mvi->hba_info_param.phy_tuning[phy_id]);
+        set_phy_ffe_tuning(mvi, phy_id,
+                mvi->hba_info_param.ffe_ctl[phy_id]);
+        set_phy_rate(mvi, phy_id,
+                mvi->hba_info_param.phy_rate[phy_id]);
+}
+
 static void __devinit mvs_94xx_enable_xmt(struct mvs_info *mvi, int phy_id)
 {
         void __iomem *regs = mvi->regs;
@@ -61,7 +271,14 @@ static void __devinit mvs_94xx_enable_xmt(struct mvs_info *mvi, int phy_id)
 static void mvs_94xx_phy_reset(struct mvs_info *mvi, u32 phy_id, int hard)
 {
         u32 tmp;
-
+        u32 delay = 5000;
+        if (hard == MVS_PHY_TUNE) {
+                mvs_write_port_cfg_addr(mvi, phy_id, PHYR_SATA_CTL);
+                tmp = mvs_read_port_cfg_data(mvi, phy_id);
+                mvs_write_port_cfg_data(mvi, phy_id, tmp|0x20000000);
+                mvs_write_port_cfg_data(mvi, phy_id, tmp|0x100000);
+                return;
+        }
         tmp = mvs_read_port_irq_stat(mvi, phy_id);
         tmp &= ~PHYEV_RDY_CH;
         mvs_write_port_irq_stat(mvi, phy_id, tmp);
@@ -71,12 +288,15 @@ static void mvs_94xx_phy_reset(struct mvs_info *mvi, u32 phy_id, int hard)
                 mvs_write_phy_ctl(mvi, phy_id, tmp);
                 do {
                         tmp = mvs_read_phy_ctl(mvi, phy_id);
-                } while (tmp & PHY_RST_HARD);
+                        udelay(10);
+                        delay--;
+                } while ((tmp & PHY_RST_HARD) && delay);
+                if (!delay)
+                        mv_dprintk("phy hard reset failed.\n");
         } else {
-                mvs_write_port_vsr_addr(mvi, phy_id, VSR_PHY_STAT);
-                tmp = mvs_read_port_vsr_data(mvi, phy_id);
+                tmp = mvs_read_phy_ctl(mvi, phy_id);
                 tmp |= PHY_RST;
-                mvs_write_port_vsr_data(mvi, phy_id, tmp);
+                mvs_write_phy_ctl(mvi, phy_id, tmp);
         }
 }
 
@@ -90,12 +310,25 @@ static void mvs_94xx_phy_disable(struct mvs_info *mvi, u32 phy_id)
 
 static void mvs_94xx_phy_enable(struct mvs_info *mvi, u32 phy_id)
 {
-        mvs_write_port_vsr_addr(mvi, phy_id, 0x1B4);
-        mvs_write_port_vsr_data(mvi, phy_id, 0x8300ffc1);
-        mvs_write_port_vsr_addr(mvi, phy_id, 0x104);
-        mvs_write_port_vsr_data(mvi, phy_id, 0x00018080);
+        u32 tmp;
+        u8 revision = 0;
+
+        revision = mvi->pdev->revision;
+        if (revision == VANIR_A0_REV) {
+                mvs_write_port_vsr_addr(mvi, phy_id, CMD_HOST_RD_DATA);
+                mvs_write_port_vsr_data(mvi, phy_id, 0x8300ffc1);
+        }
+        if (revision == VANIR_B0_REV) {
+                mvs_write_port_vsr_addr(mvi, phy_id, CMD_APP_MEM_CTL);
+                mvs_write_port_vsr_data(mvi, phy_id, 0x08001006);
+                mvs_write_port_vsr_addr(mvi, phy_id, CMD_HOST_RD_DATA);
+                mvs_write_port_vsr_data(mvi, phy_id, 0x0000705f);
+        }
+
         mvs_write_port_vsr_addr(mvi, phy_id, VSR_PHY_MODE2);
-        mvs_write_port_vsr_data(mvi, phy_id, 0x00207fff);
+        tmp = mvs_read_port_vsr_data(mvi, phy_id);
+        tmp |= bit(0);
+        mvs_write_port_vsr_data(mvi, phy_id, tmp & 0xfd7fffff);
 }
 
 static int __devinit mvs_94xx_init(struct mvs_info *mvi)
@@ -103,7 +336,9 @@ static int __devinit mvs_94xx_init(struct mvs_info *mvi)
         void __iomem *regs = mvi->regs;
         int i;
         u32 tmp, cctl;
+        u8 revision;
 
+        revision = mvi->pdev->revision;
         mvs_show_pcie_usage(mvi);
         if (mvi->flags & MVF_FLAG_SOC) {
                 tmp = mr32(MVS_PHY_CTL);
@@ -133,6 +368,28 @@ static int __devinit mvs_94xx_init(struct mvs_info *mvi)
                 msleep(100);
         }
 
+        /* disable Multiplexing, enable phy implemented */
+        mw32(MVS_PORTS_IMP, 0xFF);
+
+        if (revision == VANIR_A0_REV) {
+                mw32(MVS_PA_VSR_ADDR, CMD_CMWK_OOB_DET);
+                mw32(MVS_PA_VSR_PORT, 0x00018080);
+        }
+        mw32(MVS_PA_VSR_ADDR, VSR_PHY_MODE2);
+        if (revision == VANIR_A0_REV || revision == VANIR_B0_REV)
+                /* set 6G/3G/1.5G, multiplexing, without SSC */
+                mw32(MVS_PA_VSR_PORT, 0x0084d4fe);
+        else
+                /* set 6G/3G/1.5G, multiplexing, with and without SSC */
+                mw32(MVS_PA_VSR_PORT, 0x0084fffe);
+
+        if (revision == VANIR_B0_REV) {
+                mw32(MVS_PA_VSR_ADDR, CMD_APP_MEM_CTL);
+                mw32(MVS_PA_VSR_PORT, 0x08001006);
+                mw32(MVS_PA_VSR_ADDR, CMD_HOST_RD_DATA);
+                mw32(MVS_PA_VSR_PORT, 0x0000705f);
+        }
+
         /* reset control */
         mw32(MVS_PCS, 0);               /* MVS_PCS */
         mw32(MVS_STP_REG_SET_0, 0);
@@ -141,17 +398,8 @@ static int __devinit mvs_94xx_init(struct mvs_info *mvi)
         /* init phys */
         mvs_phy_hacks(mvi);
 
-        /* disable Multiplexing, enable phy implemented */
-        mw32(MVS_PORTS_IMP, 0xFF);
-
-
-        mw32(MVS_PA_VSR_ADDR, 0x00000104);
-        mw32(MVS_PA_VSR_PORT, 0x00018080);
-        mw32(MVS_PA_VSR_ADDR, VSR_PHY_MODE8);
-        mw32(MVS_PA_VSR_PORT, 0x0084ffff);
-
         /* set LED blink when IO*/
-        mw32(MVS_PA_VSR_ADDR, 0x00000030);
+        mw32(MVS_PA_VSR_ADDR, VSR_PHY_ACT_LED);
         tmp = mr32(MVS_PA_VSR_PORT);
         tmp &= 0xFFFF00FF;
         tmp |= 0x00003300;
@@ -175,12 +423,13 @@ static int __devinit mvs_94xx_init(struct mvs_info *mvi)
                 mvs_94xx_phy_disable(mvi, i);
                 /* set phy local SAS address */
                 mvs_set_sas_addr(mvi, i, CONFIG_ID_FRAME3, CONFIG_ID_FRAME4,
-                                                (mvi->phy[i].dev_sas_addr));
+                                                cpu_to_le64(mvi->phy[i].dev_sas_addr));
 
                 mvs_94xx_enable_xmt(mvi, i);
+                mvs_94xx_config_reg_from_hba(mvi, i);
                 mvs_94xx_phy_enable(mvi, i);
 
-                mvs_94xx_phy_reset(mvi, i, 1);
+                mvs_94xx_phy_reset(mvi, i, PHY_RST_HARD);
                 msleep(500);
                 mvs_94xx_detect_porttype(mvi, i);
         }
@@ -211,16 +460,9 @@ static int __devinit mvs_94xx_init(struct mvs_info *mvi)
                 mvs_update_phyinfo(mvi, i, 1);
         }
 
-        /* FIXME: update wide port bitmaps */
-
         /* little endian for open address and command table, etc. */
-        /*
-         * it seems that ( from the spec ) turning on big-endian won't
-         * do us any good on big-endian machines, need further confirmation
-         */
         cctl = mr32(MVS_CTL);
         cctl |= CCTL_ENDIAN_CMD;
-        cctl |= CCTL_ENDIAN_DATA;
         cctl &= ~CCTL_ENDIAN_OPEN;
         cctl |= CCTL_ENDIAN_RSP;
         mw32_f(MVS_CTL, cctl);
@@ -228,15 +470,20 @@ static int __devinit mvs_94xx_init(struct mvs_info *mvi)
         /* reset CMD queue */
         tmp = mr32(MVS_PCS);
         tmp |= PCS_CMD_RST;
+        tmp &= ~PCS_SELF_CLEAR;
         mw32(MVS_PCS, tmp);
-        /* interrupt coalescing may cause missing HW interrput in some case,
-         * and the max count is 0x1ff, while our max slot is 0x200,
+        /*
+         * the max count is 0x1ff, while our max slot is 0x200,
          * it will make count 0.
          */
         tmp = 0;
-        mw32(MVS_INT_COAL, tmp);
+        if (MVS_CHIP_SLOT_SZ > 0x1ff)
+                mw32(MVS_INT_COAL, 0x1ff | COAL_EN);
+        else
+                mw32(MVS_INT_COAL, MVS_CHIP_SLOT_SZ | COAL_EN);
 
-        tmp = 0x100;
+        /* default interrupt coalescing time is 128us */
+        tmp = 0x10000 | interrupt_coalescing;
         mw32(MVS_INT_COAL_TMOUT, tmp);
 
         /* ladies and gentlemen, start your engines */
@@ -249,7 +496,7 @@ static int __devinit mvs_94xx_init(struct mvs_info *mvi)
 
         /* enable completion queue interrupt */
         tmp = (CINT_PORT_MASK | CINT_DONE | CINT_MEM | CINT_SRS | CINT_CI_STOP |
-                CINT_DMA_PCIE);
+                CINT_DMA_PCIE | CINT_NON_SPEC_NCQ_ERROR);
         tmp |= CINT_PHY_MASK;
         mw32(MVS_INT_MASK, tmp);
 
@@ -332,13 +579,10 @@ static irqreturn_t mvs_94xx_isr(struct mvs_info *mvi, int irq, u32 stat)
         if (((stat & IRQ_SAS_A) && mvi->id == 0) ||
                         ((stat & IRQ_SAS_B) && mvi->id == 1)) {
                 mw32_f(MVS_INT_STAT, CINT_DONE);
-        #ifndef MVS_USE_TASKLET
+
                 spin_lock(&mvi->lock);
-        #endif
                 mvs_int_full(mvi);
-        #ifndef MVS_USE_TASKLET
                 spin_unlock(&mvi->lock);
-        #endif
         }
         return IRQ_HANDLED;
 }
@@ -346,10 +590,48 @@ static irqreturn_t mvs_94xx_isr(struct mvs_info *mvi, int irq, u32 stat)
 static void mvs_94xx_command_active(struct mvs_info *mvi, u32 slot_idx)
 {
         u32 tmp;
-        mvs_cw32(mvi, 0x300 + (slot_idx >> 3), 1 << (slot_idx % 32));
-        do {
-                tmp = mvs_cr32(mvi, 0x300 + (slot_idx >> 3));
-        } while (tmp & 1 << (slot_idx % 32));
+        tmp = mvs_cr32(mvi, MVS_COMMAND_ACTIVE+(slot_idx >> 3));
+        if (tmp && 1 << (slot_idx % 32)) {
+                mv_printk("command active %08X,  slot [%x].\n", tmp, slot_idx);
+                mvs_cw32(mvi, MVS_COMMAND_ACTIVE + (slot_idx >> 3),
+                        1 << (slot_idx % 32));
+                do {
+                        tmp = mvs_cr32(mvi,
+                                MVS_COMMAND_ACTIVE + (slot_idx >> 3));
+                } while (tmp & 1 << (slot_idx % 32));
+        }
+}
+
+void mvs_94xx_clear_srs_irq(struct mvs_info *mvi, u8 reg_set, u8 clear_all)
+{
+        void __iomem *regs = mvi->regs;
+        u32 tmp;
+
+        if (clear_all) {
+                tmp = mr32(MVS_INT_STAT_SRS_0);
+                if (tmp) {
+                        mv_dprintk("check SRS 0 %08X.\n", tmp);
+                        mw32(MVS_INT_STAT_SRS_0, tmp);
+                }
+                tmp = mr32(MVS_INT_STAT_SRS_1);
+                if (tmp) {
+                        mv_dprintk("check SRS 1 %08X.\n", tmp);
+                        mw32(MVS_INT_STAT_SRS_1, tmp);
+                }
+        } else {
+                if (reg_set > 31)
+                        tmp = mr32(MVS_INT_STAT_SRS_1);
+                else
+                        tmp = mr32(MVS_INT_STAT_SRS_0);
+
+                if (tmp & (1 << (reg_set % 32))) {
+                        mv_dprintk("register set 0x%x was stopped.\n", reg_set);
+                        if (reg_set > 31)
+                                mw32(MVS_INT_STAT_SRS_1, 1 << (reg_set % 32));
+                        else
+                                mw32(MVS_INT_STAT_SRS_0, 1 << (reg_set % 32));
+                }
+        }
 }
 
 static void mvs_94xx_issue_stop(struct mvs_info *mvi, enum mvs_port_type type,
@@ -357,37 +639,56 @@ static void mvs_94xx_issue_stop(struct mvs_info *mvi, enum mvs_port_type type,
 {
         void __iomem *regs = mvi->regs;
         u32 tmp;
+        mvs_94xx_clear_srs_irq(mvi, 0, 1);
 
-        if (type == PORT_TYPE_SATA) {
-                tmp = mr32(MVS_INT_STAT_SRS_0) | (1U << tfs);
-                mw32(MVS_INT_STAT_SRS_0, tmp);
-        }
-        mw32(MVS_INT_STAT, CINT_CI_STOP);
+        tmp = mr32(MVS_INT_STAT);
+        mw32(MVS_INT_STAT, tmp | CINT_CI_STOP);
         tmp = mr32(MVS_PCS) | 0xFF00;
         mw32(MVS_PCS, tmp);
 }
 
+static void mvs_94xx_non_spec_ncq_error(struct mvs_info *mvi)
+{
+        void __iomem *regs = mvi->regs;
+        u32 err_0, err_1;
+        u8 i;
+        struct mvs_device *device;
+
+        err_0 = mr32(MVS_NON_NCQ_ERR_0);
+        err_1 = mr32(MVS_NON_NCQ_ERR_1);
+
+        mv_dprintk("non specific ncq error err_0:%x,err_1:%x.\n",
+                        err_0, err_1);
+        for (i = 0; i < 32; i++) {
+                if (err_0 & bit(i)) {
+                        device = mvs_find_dev_by_reg_set(mvi, i);
+                        if (device)
+                                mvs_release_task(mvi, device->sas_device);
+                }
+                if (err_1 & bit(i)) {
+                        device = mvs_find_dev_by_reg_set(mvi, i+32);
+                        if (device)
+                                mvs_release_task(mvi, device->sas_device);
+                }
+        }
+
+        mw32(MVS_NON_NCQ_ERR_0, err_0);
+        mw32(MVS_NON_NCQ_ERR_1, err_1);
+}
+
 static void mvs_94xx_free_reg_set(struct mvs_info *mvi, u8 *tfs)
 {
         void __iomem *regs = mvi->regs;
-        u32 tmp;
         u8 reg_set = *tfs;
 
         if (*tfs == MVS_ID_NOT_MAPPED)
                 return;
 
         mvi->sata_reg_set &= ~bit(reg_set);
-        if (reg_set < 32) {
+        if (reg_set < 32)
                 w_reg_set_enable(reg_set, (u32)mvi->sata_reg_set);
-                tmp = mr32(MVS_INT_STAT_SRS_0) & (u32)mvi->sata_reg_set;
-                if (tmp)
-                        mw32(MVS_INT_STAT_SRS_0, tmp);
-        } else {
-                w_reg_set_enable(reg_set, mvi->sata_reg_set);
-                tmp = mr32(MVS_INT_STAT_SRS_1) & mvi->sata_reg_set;
-                if (tmp)
-                        mw32(MVS_INT_STAT_SRS_1, tmp);
-        }
+        else
+                w_reg_set_enable(reg_set, (u32)(mvi->sata_reg_set >> 32));
 
         *tfs = MVS_ID_NOT_MAPPED;
 
@@ -403,7 +704,7 @@ static u8 mvs_94xx_assign_reg_set(struct mvs_info *mvi, u8 *tfs)
                 return 0;
 
         i = mv_ffc64(mvi->sata_reg_set);
-        if (i > 32) {
+        if (i >= 32) {
                 mvi->sata_reg_set |= bit(i);
                 w_reg_set_enable(i, (u32)(mvi->sata_reg_set >> 32));
                 *tfs = i;
@@ -422,9 +723,12 @@ static void mvs_94xx_make_prd(struct scatterlist *scatter, int nr, void *prd)
         int i;
         struct scatterlist *sg;
         struct mvs_prd *buf_prd = prd;
+        struct mvs_prd_imt im_len;
+        *(u32 *)&im_len = 0;
         for_each_sg(scatter, sg, nr, i) {
                 buf_prd->addr = cpu_to_le64(sg_dma_address(sg));
-                buf_prd->im_len.len = cpu_to_le32(sg_dma_len(sg));
+                im_len.len = sg_dma_len(sg);
+                buf_prd->im_len = cpu_to_le32(*(u32 *)&im_len);
                 buf_prd++;
         }
 }
@@ -433,7 +737,7 @@ static int mvs_94xx_oob_done(struct mvs_info *mvi, int i)
 {
         u32 phy_st;
         phy_st = mvs_read_phy_ctl(mvi, i);
-        if (phy_st & PHY_READY_MASK)    /* phy ready */
+        if (phy_st & PHY_READY_MASK)
                 return 1;
         return 0;
 }
@@ -447,7 +751,7 @@ static void mvs_94xx_get_dev_identify_frame(struct mvs_info *mvi, int port_id,
         for (i = 0; i < 7; i++) {
                 mvs_write_port_cfg_addr(mvi, port_id,
                                         CONFIG_ID_FRAME0 + i * 4);
-                id_frame[i] = mvs_read_port_cfg_data(mvi, port_id);
+                id_frame[i] = cpu_to_le32(mvs_read_port_cfg_data(mvi, port_id));
         }
         memcpy(id, id_frame, 28);
 }
@@ -458,15 +762,13 @@ static void mvs_94xx_get_att_identify_frame(struct mvs_info *mvi, int port_id,
         int i;
         u32 id_frame[7];
 
-        /* mvs_hexdump(28, (u8 *)id_frame, 0); */
         for (i = 0; i < 7; i++) {
                 mvs_write_port_cfg_addr(mvi, port_id,
                                         CONFIG_ATT_ID_FRAME0 + i * 4);
-                id_frame[i] = mvs_read_port_cfg_data(mvi, port_id);
+                id_frame[i] = cpu_to_le32(mvs_read_port_cfg_data(mvi, port_id));
                 mv_dprintk("94xx phy %d atta frame %d %x.\n",
                         port_id + mvi->id * mvi->chip->n_phy, i, id_frame[i]);
         }
-        /* mvs_hexdump(28, (u8 *)id_frame, 0); */
         memcpy(id, id_frame, 28);
 }
 
@@ -526,7 +828,18 @@ static void mvs_94xx_fix_phy_info(struct mvs_info *mvi, int i,
 void mvs_94xx_phy_set_link_rate(struct mvs_info *mvi, u32 phy_id,
                         struct sas_phy_linkrates *rates)
 {
-        /* TODO */
+        u32 lrmax = 0;
+        u32 tmp;
+
+        tmp = mvs_read_phy_ctl(mvi, phy_id);
+        lrmax = (rates->maximum_linkrate - SAS_LINK_RATE_1_5_GBPS) << 12;
+
+        if (lrmax) {
+                tmp &= ~(0x3 << 12);
+                tmp |= lrmax;
+        }
+        mvs_write_phy_ctl(mvi, phy_id, tmp);
+        mvs_94xx_phy_reset(mvi, phy_id, PHY_RST_HARD);
 }
 
 static void mvs_94xx_clear_active_cmds(struct mvs_info *mvi)
@@ -603,27 +916,59 @@ int mvs_94xx_spi_waitdataready(struct mvs_info *mvi, u32 timeout)
         return -1;
 }
 
-#ifndef DISABLE_HOTPLUG_DMA_FIX
-void mvs_94xx_fix_dma(dma_addr_t buf_dma, int buf_len, int from, void *prd)
+void mvs_94xx_fix_dma(struct mvs_info *mvi, u32 phy_mask,
+                                int buf_len, int from, void *prd)
 {
         int i;
         struct mvs_prd *buf_prd = prd;
+        dma_addr_t buf_dma;
+        struct mvs_prd_imt im_len;
+
+        *(u32 *)&im_len = 0;
         buf_prd += from;
-        for (i = 0; i < MAX_SG_ENTRY - from; i++) {
-                buf_prd->addr = cpu_to_le64(buf_dma);
-                buf_prd->im_len.len = cpu_to_le32(buf_len);
-                ++buf_prd;
+
+#define PRD_CHAINED_ENTRY 0x01
+        if ((mvi->pdev->revision == VANIR_A0_REV) ||
+                        (mvi->pdev->revision == VANIR_B0_REV))
+                buf_dma = (phy_mask <= 0x08) ?
+                                mvi->bulk_buffer_dma : mvi->bulk_buffer_dma1;
+        else
+                return;
+
+        for (i = from; i < MAX_SG_ENTRY; i++, ++buf_prd) {
+                if (i == MAX_SG_ENTRY - 1) {
+                        buf_prd->addr = cpu_to_le64(virt_to_phys(buf_prd - 1));
+                        im_len.len = 2;
+                        im_len.misc_ctl = PRD_CHAINED_ENTRY;
+                } else {
+                        buf_prd->addr = cpu_to_le64(buf_dma);
+                        im_len.len = buf_len;
+                }
+                buf_prd->im_len = cpu_to_le32(*(u32 *)&im_len);
         }
 }
-#endif
 
-/*
- * FIXME JEJB: temporary nop clear_srs_irq to make 94xx still work
- * with 64xx fixes
- */
-static void mvs_94xx_clear_srs_irq(struct mvs_info *mvi, u8 reg_set,
-                                   u8 clear_all)
+static void mvs_94xx_tune_interrupt(struct mvs_info *mvi, u32 time)
 {
+        void __iomem *regs = mvi->regs;
+        u32 tmp = 0;
+        /*
+         * the max count is 0x1ff, while our max slot is 0x200,
+         * it will make count 0.
+         */
+        if (time == 0) {
+                mw32(MVS_INT_COAL, 0);
+                mw32(MVS_INT_COAL_TMOUT, 0x10000);
+        } else {
+                if (MVS_CHIP_SLOT_SZ > 0x1ff)
+                        mw32(MVS_INT_COAL, 0x1ff|COAL_EN);
+                else
+                        mw32(MVS_INT_COAL, MVS_CHIP_SLOT_SZ|COAL_EN);
+
+                tmp = 0x10000 | time;
+                mw32(MVS_INT_COAL_TMOUT, tmp);
+        }
+
 }
 
 const struct mvs_dispatch mvs_94xx_dispatch = {
@@ -648,7 +993,6 @@ const struct mvs_dispatch mvs_94xx_dispatch = {
         mvs_write_port_irq_stat,
         mvs_read_port_irq_mask,
         mvs_write_port_irq_mask,
-        mvs_get_sas_addr,
         mvs_94xx_command_active,
         mvs_94xx_clear_srs_irq,
         mvs_94xx_issue_stop,
@@ -676,8 +1020,8 @@ const struct mvs_dispatch mvs_94xx_dispatch = {
         mvs_94xx_spi_buildcmd,
         mvs_94xx_spi_issuecmd,
         mvs_94xx_spi_waitdataready,
-#ifndef DISABLE_HOTPLUG_DMA_FIX
         mvs_94xx_fix_dma,
-#endif
+        mvs_94xx_tune_interrupt,
+        mvs_94xx_non_spec_ncq_error,
 };
 
diff --git a/drivers/scsi/mvsas/mv_94xx.h b/drivers/scsi/mvsas/mv_94xx.h
index 8835befe2c0e..8f7eb4f21140 100644
--- a/drivers/scsi/mvsas/mv_94xx.h
+++ b/drivers/scsi/mvsas/mv_94xx.h
@@ -30,6 +30,14 @@
 
 #define MAX_LINK_RATE           SAS_LINK_RATE_6_0_GBPS
 
+enum VANIR_REVISION_ID {
+        VANIR_A0_REV            = 0xA0,
+        VANIR_B0_REV            = 0x01,
+        VANIR_C0_REV            = 0x02,
+        VANIR_C1_REV            = 0x03,
+        VANIR_C2_REV            = 0xC2,
+};
+
 enum hw_registers {
         MVS_GBL_CTL             = 0x04,  /* global control */
         MVS_GBL_INT_STAT        = 0x00,  /* global irq status */
@@ -101,6 +109,7 @@ enum hw_registers {
         MVS_P4_VSR_DATA         = 0x254, /* phy4 VSR data */
         MVS_PA_VSR_ADDR         = 0x290, /* All port VSR addr */
         MVS_PA_VSR_PORT         = 0x294, /* All port VSR data */
+        MVS_COMMAND_ACTIVE      = 0x300,
 };
 
 enum pci_cfg_registers {
@@ -112,26 +121,29 @@ enum pci_cfg_registers {
 
 /*  SAS/SATA Vendor Specific Port Registers */
 enum sas_sata_vsp_regs {
-        VSR_PHY_STAT            = 0x00 * 4, /* Phy Status */
-        VSR_PHY_MODE1           = 0x01 * 4, /* phy tx */
-        VSR_PHY_MODE2           = 0x02 * 4, /* tx scc */
-        VSR_PHY_MODE3           = 0x03 * 4, /* pll */
-        VSR_PHY_MODE4           = 0x04 * 4, /* VCO */
-        VSR_PHY_MODE5           = 0x05 * 4, /* Rx */
-        VSR_PHY_MODE6           = 0x06 * 4, /* CDR */
-        VSR_PHY_MODE7           = 0x07 * 4, /* Impedance */
-        VSR_PHY_MODE8           = 0x08 * 4, /* Voltage */
-        VSR_PHY_MODE9           = 0x09 * 4, /* Test */
-        VSR_PHY_MODE10          = 0x0A * 4, /* Power */
-        VSR_PHY_MODE11          = 0x0B * 4, /* Phy Mode */
-        VSR_PHY_VS0             = 0x0C * 4, /* Vednor Specific 0 */
-        VSR_PHY_VS1             = 0x0D * 4, /* Vednor Specific 1 */
+        VSR_PHY_STAT            = 0x00 * 4, /* Phy Interrupt Status */
+        VSR_PHY_MODE1           = 0x01 * 4, /* phy Interrupt Enable */
+        VSR_PHY_MODE2           = 0x02 * 4, /* Phy Configuration */
+        VSR_PHY_MODE3           = 0x03 * 4, /* Phy Status */
+        VSR_PHY_MODE4           = 0x04 * 4, /* Phy Counter 0 */
+        VSR_PHY_MODE5           = 0x05 * 4, /* Phy Counter 1 */
+        VSR_PHY_MODE6           = 0x06 * 4, /* Event Counter Control */
+        VSR_PHY_MODE7           = 0x07 * 4, /* Event Counter Select */
+        VSR_PHY_MODE8           = 0x08 * 4, /* Event Counter 0 */
+        VSR_PHY_MODE9           = 0x09 * 4, /* Event Counter 1 */
+        VSR_PHY_MODE10          = 0x0A * 4, /* Event Counter 2 */
+        VSR_PHY_MODE11          = 0x0B * 4, /* Event Counter 3 */
+        VSR_PHY_ACT_LED         = 0x0C * 4, /* Activity LED control */
+
+        VSR_PHY_FFE_CONTROL     = 0x10C,
+        VSR_PHY_DFE_UPDATE_CRTL = 0x110,
+        VSR_REF_CLOCK_CRTL      = 0x1A0,
 };
 
 enum chip_register_bits {
         PHY_MIN_SPP_PHYS_LINK_RATE_MASK = (0x7 << 8),
-        PHY_MAX_SPP_PHYS_LINK_RATE_MASK = (0x7 << 8),
-        PHY_NEG_SPP_PHYS_LINK_RATE_MASK_OFFSET = (12),
+        PHY_MAX_SPP_PHYS_LINK_RATE_MASK = (0x7 << 12),
+        PHY_NEG_SPP_PHYS_LINK_RATE_MASK_OFFSET = (16),
         PHY_NEG_SPP_PHYS_LINK_RATE_MASK =
                         (0x3 << PHY_NEG_SPP_PHYS_LINK_RATE_MASK_OFFSET),
 };
@@ -169,22 +181,75 @@ enum pci_interrupt_cause {
         IRQ_PCIE_ERR                   = (1 << 31),
 };
 
+union reg_phy_cfg {
+        u32 v;
+        struct {
+                u32 phy_reset:1;
+                u32 sas_support:1;
+                u32 sata_support:1;
+                u32 sata_host_mode:1;
+                /*
+                 * bit 2: 6Gbps support
+                 * bit 1: 3Gbps support
+                 * bit 0: 1.5Gbps support
+                 */
+                u32 speed_support:3;
+                u32 snw_3_support:1;
+                u32 tx_lnk_parity:1;
+                /*
+                 * bit 5: G1 (1.5Gbps) Without SSC
+                 * bit 4: G1 (1.5Gbps) with SSC
+                 * bit 3: G2 (3.0Gbps) Without SSC
+                 * bit 2: G2 (3.0Gbps) with SSC
+                 * bit 1: G3 (6.0Gbps) without SSC
+                 * bit 0: G3 (6.0Gbps) with SSC
+                 */
+                u32 tx_spt_phs_lnk_rate:6;
+                /* 8h: 1.5Gbps 9h: 3Gbps Ah: 6Gbps */
+                u32 tx_lgcl_lnk_rate:4;
+                u32 tx_ssc_type:1;
+                u32 sata_spin_up_spt:1;
+                u32 sata_spin_up_en:1;
+                u32 bypass_oob:1;
+                u32 disable_phy:1;
+                u32 rsvd:8;
+        } u;
+};
+
 #define MAX_SG_ENTRY            255
 
 struct mvs_prd_imt {
+#ifndef __BIG_ENDIAN
         __le32                  len:22;
         u8                      _r_a:2;
         u8                      misc_ctl:4;
         u8                      inter_sel:4;
+#else
+        u32                     inter_sel:4;
+        u32                     misc_ctl:4;
+        u32                     _r_a:2;
+        u32                     len:22;
+#endif
 };
 
 struct mvs_prd {
         /* 64-bit buffer address */
         __le64                  addr;
         /* 22-bit length */
-        struct mvs_prd_imt      im_len;
+        __le32                  im_len;
 } __attribute__ ((packed));
 
+/*
+ * these registers are accessed through port vendor
+ * specific address/data registers
+ */
+enum sas_sata_phy_regs {
+        GENERATION_1_SETTING            = 0x118,
+        GENERATION_1_2_SETTING          = 0x11C,
+        GENERATION_2_3_SETTING          = 0x120,
+        GENERATION_3_4_SETTING          = 0x124,
+};
+
 #define SPI_CTRL_REG_94XX               0xc800
 #define SPI_ADDR_REG_94XX               0xc804
 #define SPI_WR_DATA_REG_94XX         0xc808
diff --git a/drivers/scsi/mvsas/mv_chips.h b/drivers/scsi/mvsas/mv_chips.h
index 1753a6fc42d0..bcc408042cee 100644
--- a/drivers/scsi/mvsas/mv_chips.h
+++ b/drivers/scsi/mvsas/mv_chips.h
@@ -164,7 +164,6 @@ static inline void __devinit mvs_phy_hacks(struct mvs_info *mvi)
 {
         u32 tmp;
 
-        /* workaround for SATA R-ERR, to ignore phy glitch */
         tmp = mvs_cr32(mvi, CMD_PHY_TIMER);
         tmp &= ~(1 << 9);
         tmp |= (1 << 10);
@@ -179,23 +178,10 @@ static inline void __devinit mvs_phy_hacks(struct mvs_info *mvi)
         tmp |= 0x3fff;
         mvs_cw32(mvi, CMD_SAS_CTL0, tmp);
 
-        /* workaround for WDTIMEOUT , set to 550 ms */
         mvs_cw32(mvi, CMD_WD_TIMER, 0x7a0000);
 
         /* not to halt for different port op during wideport link change */
         mvs_cw32(mvi, CMD_APP_ERR_CONFIG, 0xffefbf7d);
-
-        /* workaround for Seagate disk not-found OOB sequence, recv
-         * COMINIT before sending out COMWAKE */
-        tmp = mvs_cr32(mvi, CMD_PHY_MODE_21);
-        tmp &= 0x0000ffff;
-        tmp |= 0x00fa0000;
-        mvs_cw32(mvi, CMD_PHY_MODE_21, tmp);
-
-        tmp = mvs_cr32(mvi, CMD_PHY_TIMER);
-        tmp &= 0x1fffffff;
-        tmp |= (2U << 29);      /* 8 ms retry */
-        mvs_cw32(mvi, CMD_PHY_TIMER, tmp);
 }
 
 static inline void mvs_int_sata(struct mvs_info *mvi)
@@ -223,6 +209,9 @@ static inline void mvs_int_full(struct mvs_info *mvi)
                         mvs_int_port(mvi, i, tmp);
         }
 
+        if (stat & CINT_NON_SPEC_NCQ_ERROR)
+                MVS_CHIP_DISP->non_spec_ncq_error(mvi);
+
         if (stat & CINT_SRS)
                 mvs_int_sata(mvi);
 
diff --git a/drivers/scsi/mvsas/mv_defs.h b/drivers/scsi/mvsas/mv_defs.h
index bc00c940743c..dec7cadb7485 100644
--- a/drivers/scsi/mvsas/mv_defs.h
+++ b/drivers/scsi/mvsas/mv_defs.h
@@ -43,7 +43,6 @@ enum chip_flavors {
 
 /* driver compile-time configuration */
 enum driver_configuration {
-        MVS_SLOTS               = 512,  /* command slots */
         MVS_TX_RING_SZ          = 1024, /* TX ring size (12-bit) */
         MVS_RX_RING_SZ          = 1024, /* RX ring size (12-bit) */
                                         /* software requires power-of-2
@@ -56,8 +55,7 @@ enum driver_configuration {
         MVS_SSP_CMD_SZ          = 64,   /* SSP command table buffer size */
         MVS_ATA_CMD_SZ          = 96,   /* SATA command table buffer size */
         MVS_OAF_SZ              = 64,   /* Open address frame buffer size */
-        MVS_QUEUE_SIZE  = 32,   /* Support Queue depth */
-        MVS_CAN_QUEUE           = MVS_SLOTS - 2,        /* SCSI Queue depth */
+        MVS_QUEUE_SIZE          = 64,   /* Support Queue depth */
         MVS_SOC_CAN_QUEUE       = MVS_SOC_SLOTS - 2,
 };
 
@@ -144,6 +142,7 @@ enum hw_register_bits {
         CINT_DMA_PCIE           = (1U << 27),   /* DMA to PCIE timeout */
         CINT_MEM                = (1U << 26),   /* int mem parity err */
         CINT_I2C_SLAVE          = (1U << 25),   /* slave I2C event */
+        CINT_NON_SPEC_NCQ_ERROR = (1U << 25),   /* Non specific NCQ error */
         CINT_SRS                = (1U << 3),    /* SRS event */
         CINT_CI_STOP            = (1U << 1),    /* cmd issue stopped */
         CINT_DONE               = (1U << 0),    /* cmd completion */
@@ -161,7 +160,7 @@ enum hw_register_bits {
         TXQ_CMD_SSP             = 1,            /* SSP protocol */
         TXQ_CMD_SMP             = 2,            /* SMP protocol */
         TXQ_CMD_STP             = 3,            /* STP/SATA protocol */
-        TXQ_CMD_SSP_FREE_LIST   = 4,            /* add to SSP targ free list */
+        TXQ_CMD_SSP_FREE_LIST   = 4,            /* add to SSP target free list */
         TXQ_CMD_SLOT_RESET      = 7,            /* reset command slot */
         TXQ_MODE_I              = (1U << 28),   /* mode: 0=target,1=initiator */
         TXQ_MODE_TARGET         = 0,
@@ -391,15 +390,15 @@ enum sas_cmd_port_registers {
 };
 
 enum mvs_info_flags {
-        MVF_MSI         = (1U << 0),    /* MSI is enabled */
         MVF_PHY_PWR_FIX = (1U << 1),    /* bug workaround */
         MVF_FLAG_SOC            = (1U << 2),    /* SoC integrated controllers */
 };
 
 enum mvs_event_flags {
-        PHY_PLUG_EVENT  = (3U),
+        PHY_PLUG_EVENT          = (3U),
         PHY_PLUG_IN             = (1U << 0),    /* phy plug in */
         PHY_PLUG_OUT            = (1U << 1),    /* phy plug out */
+        EXP_BRCT_CHG            = (1U << 2),    /* broadcast change */
 };
 
 enum mvs_port_type {
diff --git a/drivers/scsi/mvsas/mv_init.c b/drivers/scsi/mvsas/mv_init.c
index 90b636611cde..4e9af66fd1d3 100644
--- a/drivers/scsi/mvsas/mv_init.c
+++ b/drivers/scsi/mvsas/mv_init.c
@@ -34,22 +34,25 @@ MODULE_PARM_DESC(collector, "\n"
         "\tThe mvsas SAS LLDD supports both modes.\n"
         "\tDefault: 1 (Direct Mode).\n");
 
+int interrupt_coalescing = 0x80;
+
 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, },
+        [chip_6320] =   { 1, 2, 0x400, 17, 16, 6,  9, &mvs_64xx_dispatch, },
+        [chip_6440] =   { 1, 4, 0x400, 17, 16, 6,  9, &mvs_64xx_dispatch, },
+        [chip_6485] =   { 1, 8, 0x800, 33, 32, 6, 10, &mvs_64xx_dispatch, },
+        [chip_9180] =   { 2, 4, 0x800, 17, 64, 8,  9, &mvs_94xx_dispatch, },
+        [chip_9480] =   { 2, 4, 0x800, 17, 64, 8,  9, &mvs_94xx_dispatch, },
+        [chip_9445] =   { 1, 4, 0x800, 17, 64, 8, 11, &mvs_94xx_dispatch, },
+        [chip_9485] =   { 2, 4, 0x800, 17, 64, 8, 11, &mvs_94xx_dispatch, },
+        [chip_1300] =   { 1, 4, 0x400, 17, 16, 6,  9, &mvs_64xx_dispatch, },
+        [chip_1320] =   { 2, 4, 0x800, 17, 64, 8,  9, &mvs_94xx_dispatch, },
 };
 
+struct device_attribute *mvst_host_attrs[];
+
 #define SOC_SAS_NUM 2
-#define SG_MX 64
 
 static struct scsi_host_template mvs_sht = {
         .module                 = THIS_MODULE,
@@ -66,7 +69,7 @@ static struct scsi_host_template mvs_sht = {
         .can_queue              = 1,
         .cmd_per_lun            = 1,
         .this_id                = -1,
-        .sg_tablesize           = SG_MX,
+        .sg_tablesize           = SG_ALL,
         .max_sectors            = SCSI_DEFAULT_MAX_SECTORS,
         .use_clustering         = ENABLE_CLUSTERING,
         .eh_device_reset_handler = sas_eh_device_reset_handler,
@@ -74,6 +77,7 @@ static struct scsi_host_template mvs_sht = {
         .slave_alloc            = mvs_slave_alloc,
         .target_destroy         = sas_target_destroy,
         .ioctl                  = sas_ioctl,
+        .shost_attrs            = mvst_host_attrs,
 };
 
 static struct sas_domain_function_template mvs_transport_ops = {
@@ -100,6 +104,7 @@ static void __devinit mvs_phy_init(struct mvs_info *mvi, int phy_id)
         struct asd_sas_phy *sas_phy = &phy->sas_phy;
 
         phy->mvi = mvi;
+        phy->port = NULL;
         init_timer(&phy->timer);
         sas_phy->enabled = (phy_id < mvi->chip->n_phy) ? 1 : 0;
         sas_phy->class = SAS;
@@ -128,7 +133,7 @@ static void mvs_free(struct mvs_info *mvi)
         if (mvi->flags & MVF_FLAG_SOC)
                 slot_nr = MVS_SOC_SLOTS;
         else
-                slot_nr = MVS_SLOTS;
+                slot_nr = MVS_CHIP_SLOT_SZ;
 
         if (mvi->dma_pool)
                 pci_pool_destroy(mvi->dma_pool);
@@ -148,25 +153,26 @@ static void mvs_free(struct mvs_info *mvi)
                 dma_free_coherent(mvi->dev,
                                   sizeof(*mvi->slot) * slot_nr,
                                   mvi->slot, mvi->slot_dma);
-#ifndef DISABLE_HOTPLUG_DMA_FIX
+
         if (mvi->bulk_buffer)
                 dma_free_coherent(mvi->dev, TRASH_BUCKET_SIZE,
                                   mvi->bulk_buffer, mvi->bulk_buffer_dma);
-#endif
+        if (mvi->bulk_buffer1)
+                dma_free_coherent(mvi->dev, TRASH_BUCKET_SIZE,
+                                  mvi->bulk_buffer1, mvi->bulk_buffer_dma1);
 
         MVS_CHIP_DISP->chip_iounmap(mvi);
         if (mvi->shost)
                 scsi_host_put(mvi->shost);
         list_for_each_entry(mwq, &mvi->wq_list, entry)
                 cancel_delayed_work(&mwq->work_q);
+        kfree(mvi->tags);
         kfree(mvi);
 }
 
-#ifdef MVS_USE_TASKLET
-struct tasklet_struct   mv_tasklet;
+#ifdef CONFIG_SCSI_MVSAS_TASKLET
 static void mvs_tasklet(unsigned long opaque)
 {
-        unsigned long flags;
         u32 stat;
         u16 core_nr, i = 0;
 
@@ -179,35 +185,49 @@ static void mvs_tasklet(unsigned long opaque)
         if (unlikely(!mvi))
                 BUG_ON(1);
 
+        stat = MVS_CHIP_DISP->isr_status(mvi, mvi->pdev->irq);
+        if (!stat)
+                goto out;
+
         for (i = 0; i < core_nr; i++) {
                 mvi = ((struct mvs_prv_info *)sha->lldd_ha)->mvi[i];
-                stat = MVS_CHIP_DISP->isr_status(mvi, mvi->irq);
-                if (stat)
-                        MVS_CHIP_DISP->isr(mvi, mvi->irq, stat);
+                MVS_CHIP_DISP->isr(mvi, mvi->pdev->irq, stat);
         }
+out:
+        MVS_CHIP_DISP->interrupt_enable(mvi);
 
 }
 #endif
 
 static irqreturn_t mvs_interrupt(int irq, void *opaque)
 {
-        u32 core_nr, i = 0;
+        u32 core_nr;
         u32 stat;
         struct mvs_info *mvi;
         struct sas_ha_struct *sha = opaque;
+#ifndef CONFIG_SCSI_MVSAS_TASKLET
+        u32 i;
+#endif
 
         core_nr = ((struct mvs_prv_info *)sha->lldd_ha)->n_host;
         mvi = ((struct mvs_prv_info *)sha->lldd_ha)->mvi[0];
 
         if (unlikely(!mvi))
                 return IRQ_NONE;
+#ifdef CONFIG_SCSI_MVSAS_TASKLET
+        MVS_CHIP_DISP->interrupt_disable(mvi);
+#endif
 
         stat = MVS_CHIP_DISP->isr_status(mvi, irq);
-        if (!stat)
+        if (!stat) {
+        #ifdef CONFIG_SCSI_MVSAS_TASKLET
+                MVS_CHIP_DISP->interrupt_enable(mvi);
+        #endif
                 return IRQ_NONE;
+        }
 
-#ifdef MVS_USE_TASKLET
-        tasklet_schedule(&mv_tasklet);
+#ifdef CONFIG_SCSI_MVSAS_TASKLET
+        tasklet_schedule(&((struct mvs_prv_info *)sha->lldd_ha)->mv_tasklet);
 #else
         for (i = 0; i < core_nr; i++) {
                 mvi = ((struct mvs_prv_info *)sha->lldd_ha)->mvi[i];
@@ -225,7 +245,7 @@ static int __devinit mvs_alloc(struct mvs_info *mvi, struct Scsi_Host *shost)
         if (mvi->flags & MVF_FLAG_SOC)
                 slot_nr = MVS_SOC_SLOTS;
         else
-                slot_nr = MVS_SLOTS;
+                slot_nr = MVS_CHIP_SLOT_SZ;
 
         spin_lock_init(&mvi->lock);
         for (i = 0; i < mvi->chip->n_phy; i++) {
@@ -273,13 +293,18 @@ static int __devinit mvs_alloc(struct mvs_info *mvi, struct Scsi_Host *shost)
                 goto err_out;
         memset(mvi->slot, 0, sizeof(*mvi->slot) * slot_nr);
 
-#ifndef DISABLE_HOTPLUG_DMA_FIX
         mvi->bulk_buffer = dma_alloc_coherent(mvi->dev,
                                        TRASH_BUCKET_SIZE,
                                        &mvi->bulk_buffer_dma, GFP_KERNEL);
         if (!mvi->bulk_buffer)
                 goto err_out;
-#endif
+
+        mvi->bulk_buffer1 = dma_alloc_coherent(mvi->dev,
+                                       TRASH_BUCKET_SIZE,
+                                       &mvi->bulk_buffer_dma1, GFP_KERNEL);
+        if (!mvi->bulk_buffer1)
+                goto err_out;
+
         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) {
@@ -354,11 +379,12 @@ static struct mvs_info *__devinit mvs_pci_alloc(struct pci_dev *pdev,
                                 const struct pci_device_id *ent,
                                 struct Scsi_Host *shost, unsigned int id)
 {
-        struct mvs_info *mvi;
+        struct mvs_info *mvi = NULL;
         struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
 
-        mvi = kzalloc(sizeof(*mvi) + MVS_SLOTS * sizeof(struct mvs_slot_info),
-                        GFP_KERNEL);
+        mvi = kzalloc(sizeof(*mvi) +
+                (1L << mvs_chips[ent->driver_data].slot_width) *
+                sizeof(struct mvs_slot_info), GFP_KERNEL);
         if (!mvi)
                 return NULL;
 
@@ -367,7 +393,6 @@ static struct mvs_info *__devinit mvs_pci_alloc(struct pci_dev *pdev,
         mvi->chip_id = ent->driver_data;
         mvi->chip = &mvs_chips[mvi->chip_id];
         INIT_LIST_HEAD(&mvi->wq_list);
-        mvi->irq = pdev->irq;
 
         ((struct mvs_prv_info *)sha->lldd_ha)->mvi[id] = mvi;
         ((struct mvs_prv_info *)sha->lldd_ha)->n_phy = mvi->chip->n_phy;
@@ -375,9 +400,10 @@ static struct mvs_info *__devinit mvs_pci_alloc(struct pci_dev *pdev,
         mvi->id = id;
         mvi->sas = sha;
         mvi->shost = shost;
-#ifdef MVS_USE_TASKLET
-        tasklet_init(&mv_tasklet, mvs_tasklet, (unsigned long)sha);
-#endif
+
+        mvi->tags = kzalloc(MVS_CHIP_SLOT_SZ>>3, GFP_KERNEL);
+        if (!mvi->tags)
+                goto err_out;
 
         if (MVS_CHIP_DISP->chip_ioremap(mvi))
                 goto err_out;
@@ -388,7 +414,6 @@ err_out:
         return NULL;
 }
 
-/* move to PCI layer or libata core? */
 static int pci_go_64(struct pci_dev *pdev)
 {
         int rc;
@@ -450,7 +475,7 @@ static int __devinit mvs_prep_sas_ha_init(struct Scsi_Host *shost,
         ((struct mvs_prv_info *)sha->lldd_ha)->n_host = core_nr;
 
         shost->transportt = mvs_stt;
-        shost->max_id = 128;
+        shost->max_id = MVS_MAX_DEVICES;
         shost->max_lun = ~0;
         shost->max_channel = 1;
         shost->max_cmd_len = 16;
@@ -493,11 +518,12 @@ static void  __devinit mvs_post_sas_ha_init(struct Scsi_Host *shost,
         if (mvi->flags & MVF_FLAG_SOC)
                 can_queue = MVS_SOC_CAN_QUEUE;
         else
-                can_queue = MVS_CAN_QUEUE;
+                can_queue = MVS_CHIP_SLOT_SZ;
 
         sha->lldd_queue_size = can_queue;
+        shost->sg_tablesize = min_t(u16, SG_ALL, MVS_MAX_SG);
         shost->can_queue = can_queue;
-        mvi->shost->cmd_per_lun = MVS_SLOTS/sha->num_phys;
+        mvi->shost->cmd_per_lun = MVS_QUEUE_SIZE;
         sha->core.shost = mvi->shost;
 }
 
@@ -518,6 +544,7 @@ static int __devinit mvs_pci_init(struct pci_dev *pdev,
 {
         unsigned int rc, nhost = 0;
         struct mvs_info *mvi;
+        struct mvs_prv_info *mpi;
         irq_handler_t irq_handler = mvs_interrupt;
         struct Scsi_Host *shost = NULL;
         const struct mvs_chip_info *chip;
@@ -569,6 +596,9 @@ static int __devinit mvs_pci_init(struct pci_dev *pdev,
                         goto err_out_regions;
                 }
 
+                memset(&mvi->hba_info_param, 0xFF,
+                        sizeof(struct hba_info_page));
+
                 mvs_init_sas_add(mvi);
 
                 mvi->instance = nhost;
@@ -579,8 +609,9 @@ static int __devinit mvs_pci_init(struct pci_dev *pdev,
                 }
                 nhost++;
         } while (nhost < chip->n_host);
-#ifdef MVS_USE_TASKLET
-        tasklet_init(&mv_tasklet, mvs_tasklet,
+        mpi = (struct mvs_prv_info *)(SHOST_TO_SAS_HA(shost)->lldd_ha);
+#ifdef CONFIG_SCSI_MVSAS_TASKLET
+        tasklet_init(&(mpi->mv_tasklet), mvs_tasklet,
                      (unsigned long)SHOST_TO_SAS_HA(shost));
 #endif
 
@@ -625,8 +656,8 @@ static void __devexit mvs_pci_remove(struct pci_dev *pdev)
         core_nr = ((struct mvs_prv_info *)sha->lldd_ha)->n_host;
         mvi = ((struct mvs_prv_info *)sha->lldd_ha)->mvi[0];
 
-#ifdef MVS_USE_TASKLET
-        tasklet_kill(&mv_tasklet);
+#ifdef CONFIG_SCSI_MVSAS_TASKLET
+        tasklet_kill(&((struct mvs_prv_info *)sha->lldd_ha)->mv_tasklet);
 #endif
 
         pci_set_drvdata(pdev, NULL);
@@ -635,7 +666,7 @@ static void __devexit mvs_pci_remove(struct pci_dev *pdev)
         scsi_remove_host(mvi->shost);
 
         MVS_CHIP_DISP->interrupt_disable(mvi);
-        free_irq(mvi->irq, sha);
+        free_irq(mvi->pdev->irq, sha);
         for (i = 0; i < core_nr; i++) {
                 mvi = ((struct mvs_prv_info *)sha->lldd_ha)->mvi[i];
                 mvs_free(mvi);
@@ -703,6 +734,70 @@ static struct pci_driver mvs_pci_driver = {
         .remove         = __devexit_p(mvs_pci_remove),
 };
 
+static ssize_t
+mvs_show_driver_version(struct device *cdev,
+                struct device_attribute *attr,  char *buffer)
+{
+        return snprintf(buffer, PAGE_SIZE, "%s\n", DRV_VERSION);
+}
+
+static DEVICE_ATTR(driver_version,
+                         S_IRUGO,
+                         mvs_show_driver_version,
+                         NULL);
+
+static ssize_t
+mvs_store_interrupt_coalescing(struct device *cdev,
+                        struct device_attribute *attr,
+                        const char *buffer, size_t size)
+{
+        int val = 0;
+        struct mvs_info *mvi = NULL;
+        struct Scsi_Host *shost = class_to_shost(cdev);
+        struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
+        u8 i, core_nr;
+        if (buffer == NULL)
+                return size;
+
+        if (sscanf(buffer, "%d", &val) != 1)
+                return -EINVAL;
+
+        if (val >= 0x10000) {
+                mv_dprintk("interrupt coalescing timer %d us is"
+                        "too long\n", val);
+                return strlen(buffer);
+        }
+
+        interrupt_coalescing = val;
+
+        core_nr = ((struct mvs_prv_info *)sha->lldd_ha)->n_host;
+        mvi = ((struct mvs_prv_info *)sha->lldd_ha)->mvi[0];
+
+        if (unlikely(!mvi))
+                return -EINVAL;
+
+        for (i = 0; i < core_nr; i++) {
+                mvi = ((struct mvs_prv_info *)sha->lldd_ha)->mvi[i];
+                if (MVS_CHIP_DISP->tune_interrupt)
+                        MVS_CHIP_DISP->tune_interrupt(mvi,
+                                interrupt_coalescing);
+        }
+        mv_dprintk("set interrupt coalescing time to %d us\n",
+                interrupt_coalescing);
+        return strlen(buffer);
+}
+
+static ssize_t mvs_show_interrupt_coalescing(struct device *cdev,
+                        struct device_attribute *attr, char *buffer)
+{
+        return snprintf(buffer, PAGE_SIZE, "%d\n", interrupt_coalescing);
+}
+
+static DEVICE_ATTR(interrupt_coalescing,
+                         S_IRUGO|S_IWUSR,
+                         mvs_show_interrupt_coalescing,
+                         mvs_store_interrupt_coalescing);
+
 /* task handler */
 struct task_struct *mvs_th;
 static int __init mvs_init(void)
@@ -739,6 +834,12 @@ static void __exit mvs_exit(void)
         kmem_cache_destroy(mvs_task_list_cache);
 }
 
+struct device_attribute *mvst_host_attrs[] = {
+        &dev_attr_driver_version,
+        &dev_attr_interrupt_coalescing,
+        NULL,
+};
+
 module_init(mvs_init);
 module_exit(mvs_exit);
 
diff --git a/drivers/scsi/mvsas/mv_sas.c b/drivers/scsi/mvsas/mv_sas.c
index 0ef27425c447..4958fefff365 100644
--- a/drivers/scsi/mvsas/mv_sas.c
+++ b/drivers/scsi/mvsas/mv_sas.c
@@ -38,7 +38,7 @@ static int mvs_find_tag(struct mvs_info *mvi, struct sas_task *task, u32 *tag)
 
 void mvs_tag_clear(struct mvs_info *mvi, u32 tag)
 {
-        void *bitmap = &mvi->tags;
+        void *bitmap = mvi->tags;
         clear_bit(tag, bitmap);
 }
 
@@ -49,14 +49,14 @@ void mvs_tag_free(struct mvs_info *mvi, u32 tag)
 
 void mvs_tag_set(struct mvs_info *mvi, unsigned int tag)
 {
-        void *bitmap = &mvi->tags;
+        void *bitmap = mvi->tags;
         set_bit(tag, bitmap);
 }
 
 inline int mvs_tag_alloc(struct mvs_info *mvi, u32 *tag_out)
 {
         unsigned int index, tag;
-        void *bitmap = &mvi->tags;
+        void *bitmap = mvi->tags;
 
         index = find_first_zero_bit(bitmap, mvi->tags_num);
         tag = index;
@@ -74,126 +74,6 @@ void mvs_tag_init(struct mvs_info *mvi)
                 mvs_tag_clear(mvi, i);
 }
 
-void mvs_hexdump(u32 size, u8 *data, u32 baseaddr)
-{
-        u32 i;
-        u32 run;
-        u32 offset;
-
-        offset = 0;
-        while (size) {
-                printk(KERN_DEBUG"%08X : ", baseaddr + offset);
-                if (size >= 16)
-                        run = 16;
-                else
-                        run = size;
-                size -= run;
-                for (i = 0; i < 16; i++) {
-                        if (i < run)
-                                printk(KERN_DEBUG"%02X ", (u32)data[i]);
-                        else
-                                printk(KERN_DEBUG"   ");
-                }
-                printk(KERN_DEBUG": ");
-                for (i = 0; i < run; i++)
-                        printk(KERN_DEBUG"%c",
-                                isalnum(data[i]) ? data[i] : '.');
-                printk(KERN_DEBUG"\n");
-                data = &data[16];
-                offset += run;
-        }
-        printk(KERN_DEBUG"\n");
-}
-
-#if (_MV_DUMP > 1)
-static void mvs_hba_sb_dump(struct mvs_info *mvi, u32 tag,
-                                   enum sas_protocol proto)
-{
-        u32 offset;
-        struct mvs_slot_info *slot = &mvi->slot_info[tag];
-
-        offset = slot->cmd_size + MVS_OAF_SZ +
-            MVS_CHIP_DISP->prd_size() * slot->n_elem;
-        dev_printk(KERN_DEBUG, mvi->dev, "+---->Status buffer[%d] :\n",
-                        tag);
-        mvs_hexdump(32, (u8 *) slot->response,
-                    (u32) slot->buf_dma + offset);
-}
-#endif
-
-static void mvs_hba_memory_dump(struct mvs_info *mvi, u32 tag,
-                                enum sas_protocol proto)
-{
-#if (_MV_DUMP > 1)
-        u32 sz, w_ptr;
-        u64 addr;
-        struct mvs_slot_info *slot = &mvi->slot_info[tag];
-
-        /*Delivery Queue */
-        sz = MVS_CHIP_SLOT_SZ;
-        w_ptr = slot->tx;
-        addr = mvi->tx_dma;
-        dev_printk(KERN_DEBUG, mvi->dev,
-                "Delivery Queue Size=%04d , WRT_PTR=%04X\n", sz, w_ptr);
-        dev_printk(KERN_DEBUG, mvi->dev,
-                "Delivery Queue Base Address=0x%llX (PA)"
-                "(tx_dma=0x%llX), Entry=%04d\n",
-                addr, (unsigned long long)mvi->tx_dma, w_ptr);
-        mvs_hexdump(sizeof(u32), (u8 *)(&mvi->tx[mvi->tx_prod]),
-                        (u32) mvi->tx_dma + sizeof(u32) * w_ptr);
-        /*Command List */
-        addr = mvi->slot_dma;
-        dev_printk(KERN_DEBUG, mvi->dev,
-                "Command List Base Address=0x%llX (PA)"
-                "(slot_dma=0x%llX), Header=%03d\n",
-                addr, (unsigned long long)slot->buf_dma, tag);
-        dev_printk(KERN_DEBUG, mvi->dev, "Command Header[%03d]:\n", tag);
-        /*mvs_cmd_hdr */
-        mvs_hexdump(sizeof(struct mvs_cmd_hdr), (u8 *)(&mvi->slot[tag]),
-                (u32) mvi->slot_dma + tag * sizeof(struct mvs_cmd_hdr));
-        /*1.command table area */
-        dev_printk(KERN_DEBUG, mvi->dev, "+---->Command Table :\n");
-        mvs_hexdump(slot->cmd_size, (u8 *) slot->buf, (u32) slot->buf_dma);
-        /*2.open address frame area */
-        dev_printk(KERN_DEBUG, mvi->dev, "+---->Open Address Frame :\n");
-        mvs_hexdump(MVS_OAF_SZ, (u8 *) slot->buf + slot->cmd_size,
-                                (u32) slot->buf_dma + slot->cmd_size);
-        /*3.status buffer */
-        mvs_hba_sb_dump(mvi, tag, proto);
-        /*4.PRD table */
-        dev_printk(KERN_DEBUG, mvi->dev, "+---->PRD table :\n");
-        mvs_hexdump(MVS_CHIP_DISP->prd_size() * slot->n_elem,
-                (u8 *) slot->buf + slot->cmd_size + MVS_OAF_SZ,
-                (u32) slot->buf_dma + slot->cmd_size + MVS_OAF_SZ);
-#endif
-}
-
-static void mvs_hba_cq_dump(struct mvs_info *mvi)
-{
-#if (_MV_DUMP > 2)
-        u64 addr;
-        void __iomem *regs = mvi->regs;
-        u32 entry = mvi->rx_cons + 1;
-        u32 rx_desc = le32_to_cpu(mvi->rx[entry]);
-
-        /*Completion Queue */
-        addr = mr32(RX_HI) << 16 << 16 | mr32(RX_LO);
-        dev_printk(KERN_DEBUG, mvi->dev, "Completion Task = 0x%p\n",
-                   mvi->slot_info[rx_desc & RXQ_SLOT_MASK].task);
-        dev_printk(KERN_DEBUG, mvi->dev,
-                "Completion List Base Address=0x%llX (PA), "
-                "CQ_Entry=%04d, CQ_WP=0x%08X\n",
-                addr, entry - 1, mvi->rx[0]);
-        mvs_hexdump(sizeof(u32), (u8 *)(&rx_desc),
-                    mvi->rx_dma + sizeof(u32) * entry);
-#endif
-}
-
-void mvs_get_sas_addr(void *buf, u32 buflen)
-{
-        /*memcpy(buf, "\x50\x05\x04\x30\x11\xab\x64\x40", 8);*/
-}
-
 struct mvs_info *mvs_find_dev_mvi(struct domain_device *dev)
 {
         unsigned long i = 0, j = 0, hi = 0;
@@ -222,7 +102,6 @@ struct mvs_info *mvs_find_dev_mvi(struct domain_device *dev)
 
 }
 
-/* FIXME */
 int mvs_find_dev_phyno(struct domain_device *dev, int *phyno)
 {
         unsigned long i = 0, j = 0, n = 0, num = 0;
@@ -253,6 +132,20 @@ int mvs_find_dev_phyno(struct domain_device *dev, int *phyno)
         return num;
 }
 
+struct mvs_device *mvs_find_dev_by_reg_set(struct mvs_info *mvi,
+                                                u8 reg_set)
+{
+        u32 dev_no;
+        for (dev_no = 0; dev_no < MVS_MAX_DEVICES; dev_no++) {
+                if (mvi->devices[dev_no].taskfileset == MVS_ID_NOT_MAPPED)
+                        continue;
+
+                if (mvi->devices[dev_no].taskfileset == reg_set)
+                        return &mvi->devices[dev_no];
+        }
+        return NULL;
+}
+
 static inline void mvs_free_reg_set(struct mvs_info *mvi,
                                 struct mvs_device *dev)
 {
@@ -283,7 +176,6 @@ void mvs_phys_reset(struct mvs_info *mvi, u32 phy_mask, int hard)
         }
 }
 
-/* FIXME: locking? */
 int mvs_phy_control(struct asd_sas_phy *sas_phy, enum phy_func func,
                         void *funcdata)
 {
@@ -309,12 +201,12 @@ int mvs_phy_control(struct asd_sas_phy *sas_phy, enum phy_func func,
                 tmp = MVS_CHIP_DISP->read_phy_ctl(mvi, phy_id);
                 if (tmp & PHY_RST_HARD)
                         break;
-                MVS_CHIP_DISP->phy_reset(mvi, phy_id, 1);
+                MVS_CHIP_DISP->phy_reset(mvi, phy_id, MVS_HARD_RESET);
                 break;
 
         case PHY_FUNC_LINK_RESET:
                 MVS_CHIP_DISP->phy_enable(mvi, phy_id);
-                MVS_CHIP_DISP->phy_reset(mvi, phy_id, 0);
+                MVS_CHIP_DISP->phy_reset(mvi, phy_id, MVS_SOFT_RESET);
                 break;
 
         case PHY_FUNC_DISABLE:
@@ -406,14 +298,10 @@ int mvs_slave_configure(struct scsi_device *sdev)
 
         if (ret)
                 return ret;
-        if (dev_is_sata(dev)) {
-                /* may set PIO mode */
-        #if MV_DISABLE_NCQ
-                struct ata_port *ap = dev->sata_dev.ap;
-                struct ata_device *adev = ap->link.device;
-                adev->flags |= ATA_DFLAG_NCQ_OFF;
-                scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, 1);
-        #endif
+        if (!dev_is_sata(dev)) {
+                sas_change_queue_depth(sdev,
+                        MVS_QUEUE_SIZE,
+                        SCSI_QDEPTH_DEFAULT);
         }
         return 0;
 }
@@ -424,6 +312,7 @@ void mvs_scan_start(struct Scsi_Host *shost)
         unsigned short core_nr;
         struct mvs_info *mvi;
         struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
+        struct mvs_prv_info *mvs_prv = sha->lldd_ha;
 
         core_nr = ((struct mvs_prv_info *)sha->lldd_ha)->n_host;
 
@@ -432,15 +321,17 @@ void mvs_scan_start(struct Scsi_Host *shost)
                 for (i = 0; i < mvi->chip->n_phy; ++i)
                         mvs_bytes_dmaed(mvi, i);
         }
+        mvs_prv->scan_finished = 1;
 }
 
 int mvs_scan_finished(struct Scsi_Host *shost, unsigned long time)
 {
-        /* give the phy enabling interrupt event time to come in (1s
-         * is empirically about all it takes) */
-        if (time < HZ)
+        struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
+        struct mvs_prv_info *mvs_prv = sha->lldd_ha;
+
+        if (mvs_prv->scan_finished == 0)
                 return 0;
-        /* Wait for discovery to finish */
+
         scsi_flush_work(shost);
         return 1;
 }
@@ -461,10 +352,7 @@ static int mvs_task_prep_smp(struct mvs_info *mvi,
         void *buf_prd;
         struct mvs_slot_info *slot = &mvi->slot_info[tag];
         u32 flags = (tei->n_elem << MCH_PRD_LEN_SHIFT);
-#if _MV_DUMP
-        u8 *buf_cmd;
-        void *from;
-#endif
+
         /*
          * DMA-map SMP request, response buffers
          */
@@ -496,15 +384,7 @@ static int mvs_task_prep_smp(struct mvs_info *mvi,
         buf_tmp = slot->buf;
         buf_tmp_dma = slot->buf_dma;
 
-#if _MV_DUMP
-        buf_cmd = buf_tmp;
-        hdr->cmd_tbl = cpu_to_le64(buf_tmp_dma);
-        buf_tmp += req_len;
-        buf_tmp_dma += req_len;
-        slot->cmd_size = req_len;
-#else
         hdr->cmd_tbl = cpu_to_le64(sg_dma_address(sg_req));
-#endif
 
         /* region 2: open address frame area (MVS_OAF_SZ bytes) ********* */
         buf_oaf = buf_tmp;
@@ -553,12 +433,6 @@ static int mvs_task_prep_smp(struct mvs_info *mvi,
         /* fill in PRD (scatter/gather) table, if any */
         MVS_CHIP_DISP->make_prd(task->scatter, tei->n_elem, buf_prd);
 
-#if _MV_DUMP
-        /* copy cmd table */
-        from = kmap_atomic(sg_page(sg_req), KM_IRQ0);
-        memcpy(buf_cmd, from + sg_req->offset, req_len);
-        kunmap_atomic(from, KM_IRQ0);
-#endif
         return 0;
 
 err_out_2:
@@ -616,14 +490,11 @@ static int mvs_task_prep_ata(struct mvs_info *mvi,
                 (mvi_dev->taskfileset << TXQ_SRS_SHIFT);
         mvi->tx[mvi->tx_prod] = cpu_to_le32(del_q);
 
-#ifndef DISABLE_HOTPLUG_DMA_FIX
         if (task->data_dir == DMA_FROM_DEVICE)
                 flags = (MVS_CHIP_DISP->prd_count() << MCH_PRD_LEN_SHIFT);
         else
                 flags = (tei->n_elem << MCH_PRD_LEN_SHIFT);
-#else
-        flags = (tei->n_elem << MCH_PRD_LEN_SHIFT);
-#endif
+
         if (task->ata_task.use_ncq)
                 flags |= MCH_FPDMA;
         if (dev->sata_dev.command_set == ATAPI_COMMAND_SET) {
@@ -631,11 +502,8 @@ static int mvs_task_prep_ata(struct mvs_info *mvi,
                         flags |= MCH_ATAPI;
         }
 
-        /* FIXME: fill in port multiplier number */
-
         hdr->flags = cpu_to_le32(flags);
 
-        /* FIXME: the low order order 5 bits for the TAG if enable NCQ */
         if (task->ata_task.use_ncq && mvs_get_ncq_tag(task, &hdr_tag))
                 task->ata_task.fis.sector_count |= (u8) (hdr_tag << 3);
         else
@@ -657,9 +525,6 @@ static int mvs_task_prep_ata(struct mvs_info *mvi,
 
         buf_tmp += MVS_ATA_CMD_SZ;
         buf_tmp_dma += MVS_ATA_CMD_SZ;
-#if _MV_DUMP
-        slot->cmd_size = MVS_ATA_CMD_SZ;
-#endif
 
         /* region 2: open address frame area (MVS_OAF_SZ bytes) ********* */
         /* used for STP.  unused for SATA? */
@@ -682,9 +547,6 @@ static int mvs_task_prep_ata(struct mvs_info *mvi,
         buf_tmp_dma += i;
 
         /* region 4: status buffer (larger the PRD, smaller this buf) ****** */
-        /* FIXME: probably unused, for SATA.  kept here just in case
-         * we get a STP/SATA error information record
-         */
         slot->response = buf_tmp;
         hdr->status_buf = cpu_to_le64(buf_tmp_dma);
         if (mvi->flags & MVF_FLAG_SOC)
@@ -715,11 +577,11 @@ static int mvs_task_prep_ata(struct mvs_info *mvi,
 
         /* fill in PRD (scatter/gather) table, if any */
         MVS_CHIP_DISP->make_prd(task->scatter, tei->n_elem, buf_prd);
-#ifndef DISABLE_HOTPLUG_DMA_FIX
+
         if (task->data_dir == DMA_FROM_DEVICE)
-                MVS_CHIP_DISP->dma_fix(mvi->bulk_buffer_dma,
+                MVS_CHIP_DISP->dma_fix(mvi, sas_port->phy_mask,
                                 TRASH_BUCKET_SIZE, tei->n_elem, buf_prd);
-#endif
+
         return 0;
 }
 
@@ -761,6 +623,9 @@ static int mvs_task_prep_ssp(struct mvs_info *mvi,
         }
         if (is_tmf)
                 flags |= (MCH_SSP_FR_TASK << MCH_SSP_FR_TYPE_SHIFT);
+        else
+                flags |= (MCH_SSP_FR_CMD << MCH_SSP_FR_TYPE_SHIFT);
+
         hdr->flags = cpu_to_le32(flags | (tei->n_elem << MCH_PRD_LEN_SHIFT));
         hdr->tags = cpu_to_le32(tag);
         hdr->data_len = cpu_to_le32(task->total_xfer_len);
@@ -777,9 +642,6 @@ static int mvs_task_prep_ssp(struct mvs_info *mvi,
 
         buf_tmp += MVS_SSP_CMD_SZ;
         buf_tmp_dma += MVS_SSP_CMD_SZ;
-#if _MV_DUMP
-        slot->cmd_size = MVS_SSP_CMD_SZ;
-#endif
 
         /* region 2: open address frame area (MVS_OAF_SZ bytes) ********* */
         buf_oaf = buf_tmp;
@@ -986,7 +848,6 @@ static int mvs_task_prep(struct sas_task *task, struct mvs_info *mvi, int is_tmf
         task->task_state_flags |= SAS_TASK_AT_INITIATOR;
         spin_unlock(&task->task_state_lock);
 
-        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);
@@ -1189,9 +1050,9 @@ static void mvs_slot_task_free(struct mvs_info *mvi, struct sas_task *task,
         mvs_slot_free(mvi, slot_idx);
 }
 
-static void mvs_update_wideport(struct mvs_info *mvi, int i)
+static void mvs_update_wideport(struct mvs_info *mvi, int phy_no)
 {
-        struct mvs_phy *phy = &mvi->phy[i];
+        struct mvs_phy *phy = &mvi->phy[phy_no];
         struct mvs_port *port = phy->port;
         int j, no;
 
@@ -1246,18 +1107,17 @@ static void *mvs_get_d2h_reg(struct mvs_info *mvi, int i, void *buf)
                 return NULL;
 
         MVS_CHIP_DISP->write_port_cfg_addr(mvi, i, PHYR_SATA_SIG3);
-        s[3] = MVS_CHIP_DISP->read_port_cfg_data(mvi, i);
+        s[3] = cpu_to_le32(MVS_CHIP_DISP->read_port_cfg_data(mvi, i));
 
         MVS_CHIP_DISP->write_port_cfg_addr(mvi, i, PHYR_SATA_SIG2);
-        s[2] = MVS_CHIP_DISP->read_port_cfg_data(mvi, i);
+        s[2] = cpu_to_le32(MVS_CHIP_DISP->read_port_cfg_data(mvi, i));
 
         MVS_CHIP_DISP->write_port_cfg_addr(mvi, i, PHYR_SATA_SIG1);
-        s[1] = MVS_CHIP_DISP->read_port_cfg_data(mvi, i);
+        s[1] = cpu_to_le32(MVS_CHIP_DISP->read_port_cfg_data(mvi, i));
 
         MVS_CHIP_DISP->write_port_cfg_addr(mvi, i, PHYR_SATA_SIG0);
-        s[0] = MVS_CHIP_DISP->read_port_cfg_data(mvi, i);
+        s[0] = cpu_to_le32(MVS_CHIP_DISP->read_port_cfg_data(mvi, i));
 
-        /* Workaround: take some ATAPI devices for ATA */
         if (((s[1] & 0x00FFFFFF) == 0x00EB1401) && (*(u8 *)&s[3] == 0x01))
                 s[1] = 0x00EB1401 | (*((u8 *)&s[1] + 3) & 0x10);
 
@@ -1269,6 +1129,13 @@ static u32 mvs_is_sig_fis_received(u32 irq_status)
         return irq_status & PHYEV_SIG_FIS;
 }
 
+static void mvs_sig_remove_timer(struct mvs_phy *phy)
+{
+        if (phy->timer.function)
+                del_timer(&phy->timer);
+        phy->timer.function = NULL;
+}
+
 void mvs_update_phyinfo(struct mvs_info *mvi, int i, int get_st)
 {
         struct mvs_phy *phy = &mvi->phy[i];
@@ -1291,6 +1158,7 @@ void mvs_update_phyinfo(struct mvs_info *mvi, int i, int get_st)
                 if (phy->phy_type & PORT_TYPE_SATA) {
                         phy->identify.target_port_protocols = SAS_PROTOCOL_STP;
                         if (mvs_is_sig_fis_received(phy->irq_status)) {
+                                mvs_sig_remove_timer(phy);
                                 phy->phy_attached = 1;
                                 phy->att_dev_sas_addr =
                                         i + mvi->id * mvi->chip->n_phy;
@@ -1308,7 +1176,6 @@ void mvs_update_phyinfo(struct mvs_info *mvi, int i, int get_st)
                                                 tmp | PHYEV_SIG_FIS);
                                 phy->phy_attached = 0;
                                 phy->phy_type &= ~PORT_TYPE_SATA;
-                                MVS_CHIP_DISP->phy_reset(mvi, i, 0);
                                 goto out_done;
                         }
                 }       else if (phy->phy_type & PORT_TYPE_SAS
@@ -1334,9 +1201,9 @@ void mvs_update_phyinfo(struct mvs_info *mvi, int i, int get_st)
                 if (MVS_CHIP_DISP->phy_work_around)
                         MVS_CHIP_DISP->phy_work_around(mvi, i);
         }
-        mv_dprintk("port %d attach dev info is %x\n",
+        mv_dprintk("phy %d attach dev info is %x\n",
                 i + mvi->id * mvi->chip->n_phy, phy->att_dev_info);
-        mv_dprintk("port %d attach sas addr is %llx\n",
+        mv_dprintk("phy %d attach sas addr is %llx\n",
                 i + mvi->id * mvi->chip->n_phy, phy->att_dev_sas_addr);
 out_done:
         if (get_st)
@@ -1361,10 +1228,10 @@ static void mvs_port_notify_formed(struct asd_sas_phy *sas_phy, int lock)
         }
         hi = i/((struct mvs_prv_info *)sas_ha->lldd_ha)->n_phy;
         mvi = ((struct mvs_prv_info *)sas_ha->lldd_ha)->mvi[hi];
-        if (sas_port->id >= mvi->chip->n_phy)
-                port = &mvi->port[sas_port->id - mvi->chip->n_phy];
+        if (i >= mvi->chip->n_phy)
+                port = &mvi->port[i - mvi->chip->n_phy];
         else
-                port = &mvi->port[sas_port->id];
+                port = &mvi->port[i];
         if (lock)
                 spin_lock_irqsave(&mvi->lock, flags);
         port->port_attached = 1;
@@ -1393,7 +1260,7 @@ static void mvs_port_notify_deformed(struct asd_sas_phy *sas_phy, int lock)
                         return;
         }
         list_for_each_entry(dev, &port->dev_list, dev_list_node)
-                mvs_do_release_task(phy->mvi, phy_no, NULL);
+                mvs_do_release_task(phy->mvi, phy_no, dev);
 
 }
 
@@ -1457,6 +1324,7 @@ int mvs_dev_found_notify(struct domain_device *dev, int lock)
         mvi_device->dev_status = MVS_DEV_NORMAL;
         mvi_device->dev_type = dev->dev_type;
         mvi_device->mvi_info = mvi;
+        mvi_device->sas_device = dev;
         if (parent_dev && DEV_IS_EXPANDER(parent_dev->dev_type)) {
                 int phy_id;
                 u8 phy_num = parent_dev->ex_dev.num_phys;
@@ -1508,6 +1376,7 @@ void mvs_dev_gone_notify(struct domain_device *dev)
                 mv_dprintk("found dev has gone.\n");
         }
         dev->lldd_dev = NULL;
+        mvi_dev->sas_device = NULL;
 
         spin_unlock_irqrestore(&mvi->lock, flags);
 }
@@ -1555,7 +1424,6 @@ static void mvs_tmf_timedout(unsigned long data)
         complete(&task->completion);
 }
 
-/* XXX */
 #define MVS_TASK_TIMEOUT 20
 static int mvs_exec_internal_tmf_task(struct domain_device *dev,
                         void *parameter, u32 para_len, struct mvs_tmf_task *tmf)
@@ -1588,7 +1456,7 @@ static int mvs_exec_internal_tmf_task(struct domain_device *dev,
                 }
 
                 wait_for_completion(&task->completion);
-                res = -TMF_RESP_FUNC_FAILED;
+                res = TMF_RESP_FUNC_FAILED;
                 /* Even TMF timed out, return direct. */
                 if ((task->task_state_flags & SAS_TASK_STATE_ABORTED)) {
                         if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) {
@@ -1638,11 +1506,10 @@ static int mvs_debug_issue_ssp_tmf(struct domain_device *dev,
                                 u8 *lun, struct mvs_tmf_task *tmf)
 {
         struct sas_ssp_task ssp_task;
-        DECLARE_COMPLETION_ONSTACK(completion);
         if (!(dev->tproto & SAS_PROTOCOL_SSP))
                 return TMF_RESP_FUNC_ESUPP;
 
-        strncpy((u8 *)&ssp_task.LUN, lun, 8);
+        memcpy(ssp_task.LUN, lun, 8);
 
         return mvs_exec_internal_tmf_task(dev, &ssp_task,
                                 sizeof(ssp_task), tmf);
@@ -1666,7 +1533,7 @@ static int mvs_debug_I_T_nexus_reset(struct domain_device *dev)
 int mvs_lu_reset(struct domain_device *dev, u8 *lun)
 {
         unsigned long flags;
-        int i, phyno[WIDE_PORT_MAX_PHY], num , rc = TMF_RESP_FUNC_FAILED;
+        int rc = TMF_RESP_FUNC_FAILED;
         struct mvs_tmf_task tmf_task;
         struct mvs_device * mvi_dev = dev->lldd_dev;
         struct mvs_info *mvi = mvi_dev->mvi_info;
@@ -1675,10 +1542,8 @@ int mvs_lu_reset(struct domain_device *dev, u8 *lun)
         mvi_dev->dev_status = MVS_DEV_EH;
         rc = mvs_debug_issue_ssp_tmf(dev, lun, &tmf_task);
         if (rc == TMF_RESP_FUNC_COMPLETE) {
-                num = mvs_find_dev_phyno(dev, phyno);
                 spin_lock_irqsave(&mvi->lock, flags);
-                for (i = 0; i < num; i++)
-                        mvs_release_task(mvi, dev);
+                mvs_release_task(mvi, dev);
                 spin_unlock_irqrestore(&mvi->lock, flags);
         }
         /* If failed, fall-through I_T_Nexus reset */
@@ -1696,11 +1561,12 @@ int mvs_I_T_nexus_reset(struct domain_device *dev)
 
         if (mvi_dev->dev_status != MVS_DEV_EH)
                 return TMF_RESP_FUNC_COMPLETE;
+        else
+                mvi_dev->dev_status = MVS_DEV_NORMAL;
         rc = mvs_debug_I_T_nexus_reset(dev);
         mv_printk("%s for device[%x]:rc= %d\n",
                 __func__, mvi_dev->device_id, rc);
 
-        /* housekeeper */
         spin_lock_irqsave(&mvi->lock, flags);
         mvs_release_task(mvi, dev);
         spin_unlock_irqrestore(&mvi->lock, flags);
@@ -1739,9 +1605,6 @@ int mvs_query_task(struct sas_task *task)
                 case TMF_RESP_FUNC_FAILED:
                 case TMF_RESP_FUNC_COMPLETE:
                         break;
-                default:
-                        rc = TMF_RESP_FUNC_COMPLETE;
-                        break;
                 }
         }
         mv_printk("%s:rc= %d\n", __func__, rc);
@@ -1761,8 +1624,8 @@ int mvs_abort_task(struct sas_task *task)
         u32 tag;
 
         if (!mvi_dev) {
-                mv_printk("%s:%d TMF_RESP_FUNC_FAILED\n", __func__, __LINE__);
-                rc = TMF_RESP_FUNC_FAILED;
+                mv_printk("Device has removed\n");
+                return TMF_RESP_FUNC_FAILED;
         }
 
         mvi = mvi_dev->mvi_info;
@@ -1807,25 +1670,17 @@ int mvs_abort_task(struct sas_task *task)
 
         } else if (task->task_proto & SAS_PROTOCOL_SATA ||
                 task->task_proto & SAS_PROTOCOL_STP) {
-                /* to do free register_set */
                 if (SATA_DEV == dev->dev_type) {
                         struct mvs_slot_info *slot = task->lldd_task;
-                        struct task_status_struct *tstat;
                         u32 slot_idx = (u32)(slot - mvi->slot_info);
-                        tstat = &task->task_status;
-                        mv_dprintk(KERN_DEBUG "mv_abort_task() mvi=%p task=%p "
+                        mv_dprintk("mvs_abort_task() mvi=%p task=%p "
                                    "slot=%p slot_idx=x%x\n",
                                    mvi, task, slot, slot_idx);
-                        tstat->stat = SAS_ABORTED_TASK;
-                        if (mvi_dev && mvi_dev->running_req)
-                                mvi_dev->running_req--;
-                        if (sas_protocol_ata(task->task_proto))
-                                mvs_free_reg_set(mvi, mvi_dev);
+                        mvs_tmf_timedout((unsigned long)task);
                         mvs_slot_task_free(mvi, task, slot, slot_idx);
-                        return -1;
+                        rc = TMF_RESP_FUNC_COMPLETE;
+                        goto out;
                 }
-        } else {
-                /* SMP */
 
         }
 out:
@@ -1891,12 +1746,63 @@ static int mvs_sata_done(struct mvs_info *mvi, struct sas_task *task,
         return stat;
 }
 
+void mvs_set_sense(u8 *buffer, int len, int d_sense,
+                int key, int asc, int ascq)
+{
+        memset(buffer, 0, len);
+
+        if (d_sense) {
+                /* Descriptor format */
+                if (len < 4) {
+                        mv_printk("Length %d of sense buffer too small to "
+                                "fit sense %x:%x:%x", len, key, asc, ascq);
+                }
+
+                buffer[0] = 0x72;               /* Response Code        */
+                if (len > 1)
+                        buffer[1] = key;        /* Sense Key */
+                if (len > 2)
+                        buffer[2] = asc;        /* ASC  */
+                if (len > 3)
+                        buffer[3] = ascq;       /* ASCQ */
+        } else {
+                if (len < 14) {
+                        mv_printk("Length %d of sense buffer too small to "
+                                "fit sense %x:%x:%x", len, key, asc, ascq);
+                }
+
+                buffer[0] = 0x70;               /* Response Code        */
+                if (len > 2)
+                        buffer[2] = key;        /* Sense Key */
+                if (len > 7)
+                        buffer[7] = 0x0a;       /* Additional Sense Length */
+                if (len > 12)
+                        buffer[12] = asc;       /* ASC */
+                if (len > 13)
+                        buffer[13] = ascq; /* ASCQ */
+        }
+
+        return;
+}
+
+void mvs_fill_ssp_resp_iu(struct ssp_response_iu *iu,
+                                u8 key, u8 asc, u8 asc_q)
+{
+        iu->datapres = 2;
+        iu->response_data_len = 0;
+        iu->sense_data_len = 17;
+        iu->status = 02;
+        mvs_set_sense(iu->sense_data, 17, 0,
+                        key, asc, asc_q);
+}
+
 static int mvs_slot_err(struct mvs_info *mvi, struct sas_task *task,
                          u32 slot_idx)
 {
         struct mvs_slot_info *slot = &mvi->slot_info[slot_idx];
         int stat;
-        u32 err_dw0 = le32_to_cpu(*(u32 *) (slot->response));
+        u32 err_dw0 = le32_to_cpu(*(u32 *)slot->response);
+        u32 err_dw1 = le32_to_cpu(*((u32 *)slot->response + 1));
         u32 tfs = 0;
         enum mvs_port_type type = PORT_TYPE_SAS;
 
@@ -1908,8 +1814,19 @@ static int mvs_slot_err(struct mvs_info *mvi, struct sas_task *task,
         stat = SAM_STAT_CHECK_CONDITION;
         switch (task->task_proto) {
         case SAS_PROTOCOL_SSP:
+        {
                 stat = SAS_ABORTED_TASK;
+                if ((err_dw0 & NO_DEST) || err_dw1 & bit(31)) {
+                        struct ssp_response_iu *iu = slot->response +
+                                sizeof(struct mvs_err_info);
+                        mvs_fill_ssp_resp_iu(iu, NOT_READY, 0x04, 01);
+                        sas_ssp_task_response(mvi->dev, task, iu);
+                        stat = SAM_STAT_CHECK_CONDITION;
+                }
+                if (err_dw1 & bit(31))
+                        mv_printk("reuse same slot, retry command.\n");
                 break;
+        }
         case SAS_PROTOCOL_SMP:
                 stat = SAM_STAT_CHECK_CONDITION;
                 break;
@@ -1918,10 +1835,8 @@ static int mvs_slot_err(struct mvs_info *mvi, struct sas_task *task,
         case SAS_PROTOCOL_STP:
         case SAS_PROTOCOL_SATA | SAS_PROTOCOL_STP:
         {
-                if (err_dw0 == 0x80400002)
-                        mv_printk("find reserved error, why?\n");
-
                 task->ata_task.use_ncq = 0;
+                stat = SAS_PROTO_RESPONSE;
                 mvs_sata_done(mvi, task, slot_idx, err_dw0);
         }
                 break;
@@ -1945,8 +1860,6 @@ int mvs_slot_complete(struct mvs_info *mvi, u32 rx_desc, u32 flags)
         void *to;
         enum exec_status sts;
 
-        if (mvi->exp_req)
-                mvi->exp_req--;
         if (unlikely(!task || !task->lldd_task || !task->dev))
                 return -1;
 
@@ -1954,8 +1867,6 @@ int mvs_slot_complete(struct mvs_info *mvi, u32 rx_desc, u32 flags)
         dev = task->dev;
         mvi_dev = dev->lldd_dev;
 
-        mvs_hba_cq_dump(mvi);
-
         spin_lock(&task->task_state_lock);
         task->task_state_flags &=
                 ~(SAS_TASK_STATE_PENDING | SAS_TASK_AT_INITIATOR);
@@ -1978,6 +1889,7 @@ int mvs_slot_complete(struct mvs_info *mvi, u32 rx_desc, u32 flags)
                 return -1;
         }
 
+        /* when no device attaching, go ahead and complete by error handling*/
         if (unlikely(!mvi_dev || flags)) {
                 if (!mvi_dev)
                         mv_dprintk("port has not device.\n");
@@ -1987,6 +1899,9 @@ int mvs_slot_complete(struct mvs_info *mvi, u32 rx_desc, u32 flags)
 
         /* error info record present */
         if (unlikely((rx_desc & RXQ_ERR) && (*(u64 *) slot->response))) {
+                mv_dprintk("port %d slot %d rx_desc %X has error info"
+                        "%016llX.\n", slot->port->sas_port.id, slot_idx,
+                         rx_desc, (u64)(*(u64 *)slot->response));
                 tstat->stat = mvs_slot_err(mvi, task, slot_idx);
                 tstat->resp = SAS_TASK_COMPLETE;
                 goto out;
@@ -2048,8 +1963,7 @@ out:
         spin_unlock(&mvi->lock);
         if (task->task_done)
                 task->task_done(task);
-        else
-                mv_dprintk("why has not task_done.\n");
+
         spin_lock(&mvi->lock);
 
         return sts;
@@ -2092,7 +2006,6 @@ void mvs_release_task(struct mvs_info *mvi,
                       struct domain_device *dev)
 {
         int i, phyno[WIDE_PORT_MAX_PHY], num;
-        /* housekeeper */
         num = mvs_find_dev_phyno(dev, phyno);
         for (i = 0; i < num; i++)
                 mvs_do_release_task(mvi, phyno[i], dev);
@@ -2111,13 +2024,13 @@ static void mvs_work_queue(struct work_struct *work)
         struct mvs_wq *mwq = container_of(dw, struct mvs_wq, work_q);
         struct mvs_info *mvi = mwq->mvi;
         unsigned long flags;
+        u32 phy_no = (unsigned long) mwq->data;
+        struct sas_ha_struct *sas_ha = mvi->sas;
+        struct mvs_phy *phy = &mvi->phy[phy_no];
+        struct asd_sas_phy *sas_phy = &phy->sas_phy;
 
         spin_lock_irqsave(&mvi->lock, flags);
         if (mwq->handler & PHY_PLUG_EVENT) {
-                u32 phy_no = (unsigned long) mwq->data;
-                struct sas_ha_struct *sas_ha = mvi->sas;
-                struct mvs_phy *phy = &mvi->phy[phy_no];
-                struct asd_sas_phy *sas_phy = &phy->sas_phy;
 
                 if (phy->phy_event & PHY_PLUG_OUT) {
                         u32 tmp;
@@ -2139,6 +2052,11 @@ static void mvs_work_queue(struct work_struct *work)
                                 mv_dprintk("phy%d Attached Device\n", phy_no);
                         }
                 }
+        } else if (mwq->handler & EXP_BRCT_CHG) {
+                phy->phy_event &= ~EXP_BRCT_CHG;
+                sas_ha->notify_port_event(sas_phy,
+                                PORTE_BROADCAST_RCVD);
+                mv_dprintk("phy%d Got Broadcast Change\n", phy_no);
         }
         list_del(&mwq->entry);
         spin_unlock_irqrestore(&mvi->lock, flags);
@@ -2174,29 +2092,21 @@ static void mvs_sig_time_out(unsigned long tphy)
                 if (&mvi->phy[phy_no] == phy) {
                         mv_dprintk("Get signature time out, reset phy %d\n",
                                 phy_no+mvi->id*mvi->chip->n_phy);
-                        MVS_CHIP_DISP->phy_reset(mvi, phy_no, 1);
+                        MVS_CHIP_DISP->phy_reset(mvi, phy_no, MVS_HARD_RESET);
                 }
         }
 }
 
-static void mvs_sig_remove_timer(struct mvs_phy *phy)
-{
-        if (phy->timer.function)
-                del_timer(&phy->timer);
-        phy->timer.function = NULL;
-}
-
 void mvs_int_port(struct mvs_info *mvi, int phy_no, u32 events)
 {
         u32 tmp;
-        struct sas_ha_struct *sas_ha = mvi->sas;
         struct mvs_phy *phy = &mvi->phy[phy_no];
-        struct asd_sas_phy *sas_phy = &phy->sas_phy;
 
         phy->irq_status = MVS_CHIP_DISP->read_port_irq_stat(mvi, phy_no);
-        mv_dprintk("port %d ctrl sts=0x%X.\n", phy_no+mvi->id*mvi->chip->n_phy,
+        MVS_CHIP_DISP->write_port_irq_stat(mvi, phy_no, phy->irq_status);
+        mv_dprintk("phy %d ctrl sts=0x%08X.\n", phy_no+mvi->id*mvi->chip->n_phy,
                 MVS_CHIP_DISP->read_phy_ctl(mvi, phy_no));
-        mv_dprintk("Port %d irq sts = 0x%X\n", phy_no+mvi->id*mvi->chip->n_phy,
+        mv_dprintk("phy %d irq sts = 0x%08X\n", phy_no+mvi->id*mvi->chip->n_phy,
                 phy->irq_status);
 
         /*
@@ -2205,11 +2115,12 @@ void mvs_int_port(struct mvs_info *mvi, int phy_no, u32 events)
         */
 
         if (phy->irq_status & PHYEV_DCDR_ERR) {
-                mv_dprintk("port %d STP decoding error.\n",
+                mv_dprintk("phy %d STP decoding error.\n",
                 phy_no + mvi->id*mvi->chip->n_phy);
         }
 
         if (phy->irq_status & PHYEV_POOF) {
+                mdelay(500);
                 if (!(phy->phy_event & PHY_PLUG_OUT)) {
                         int dev_sata = phy->phy_type & PORT_TYPE_SATA;
                         int ready;
@@ -2220,17 +2131,13 @@ void mvs_int_port(struct mvs_info *mvi, int phy_no, u32 events)
                                 (void *)(unsigned long)phy_no,
                                 PHY_PLUG_EVENT);
                         ready = mvs_is_phy_ready(mvi, phy_no);
-                        if (!ready)
-                                mv_dprintk("phy%d Unplug Notice\n",
-                                        phy_no +
-                                        mvi->id * mvi->chip->n_phy);
                         if (ready || dev_sata) {
                                 if (MVS_CHIP_DISP->stp_reset)
                                         MVS_CHIP_DISP->stp_reset(mvi,
                                                         phy_no);
                                 else
                                         MVS_CHIP_DISP->phy_reset(mvi,
-                                                        phy_no, 0);
+                                                        phy_no, MVS_SOFT_RESET);
                                 return;
                         }
                 }
@@ -2243,13 +2150,12 @@ void mvs_int_port(struct mvs_info *mvi, int phy_no, u32 events)
                 if (phy->timer.function == NULL) {
                         phy->timer.data = (unsigned long)phy;
                         phy->timer.function = mvs_sig_time_out;
-                        phy->timer.expires = jiffies + 10*HZ;
+                        phy->timer.expires = jiffies + 5*HZ;
                         add_timer(&phy->timer);
                 }
         }
         if (phy->irq_status & (PHYEV_SIG_FIS | PHYEV_ID_DONE)) {
                 phy->phy_status = mvs_is_phy_ready(mvi, phy_no);
-                mvs_sig_remove_timer(phy);
                 mv_dprintk("notify plug in on phy[%d]\n", phy_no);
                 if (phy->phy_status) {
                         mdelay(10);
@@ -2263,14 +2169,14 @@ void mvs_int_port(struct mvs_info *mvi, int phy_no, u32 events)
                         }
                         mvs_update_phyinfo(mvi, phy_no, 0);
                         if (phy->phy_type & PORT_TYPE_SAS) {
-                                MVS_CHIP_DISP->phy_reset(mvi, phy_no, 2);
+                                MVS_CHIP_DISP->phy_reset(mvi, phy_no, MVS_PHY_TUNE);
                                 mdelay(10);
                         }
 
                         mvs_bytes_dmaed(mvi, phy_no);
                         /* whether driver is going to handle hot plug */
                         if (phy->phy_event & PHY_PLUG_OUT) {
-                                mvs_port_notify_formed(sas_phy, 0);
+                                mvs_port_notify_formed(&phy->sas_phy, 0);
                                 phy->phy_event &= ~PHY_PLUG_OUT;
                         }
                 } else {
@@ -2278,13 +2184,11 @@ void mvs_int_port(struct mvs_info *mvi, int phy_no, u32 events)
                                 phy_no + mvi->id*mvi->chip->n_phy);
                 }
         } else if (phy->irq_status & PHYEV_BROAD_CH) {
-                mv_dprintk("port %d broadcast change.\n",
+                mv_dprintk("phy %d broadcast change.\n",
                         phy_no + mvi->id*mvi->chip->n_phy);
-                /* exception for Samsung disk drive*/
-                mdelay(1000);
-                sas_ha->notify_port_event(sas_phy, PORTE_BROADCAST_RCVD);
+                mvs_handle_event(mvi, (void *)(unsigned long)phy_no,
+                                EXP_BRCT_CHG);
         }
-        MVS_CHIP_DISP->write_port_irq_stat(mvi, phy_no, phy->irq_status);
 }
 
 int mvs_int_rx(struct mvs_info *mvi, bool self_clear)
diff --git a/drivers/scsi/mvsas/mv_sas.h b/drivers/scsi/mvsas/mv_sas.h
index 1367d8b9350d..44d7885a4a1d 100644
--- a/drivers/scsi/mvsas/mv_sas.h
+++ b/drivers/scsi/mvsas/mv_sas.h
@@ -48,12 +48,8 @@
 
 #define DRV_NAME                "mvsas"
 #define DRV_VERSION             "0.8.2"
-#define _MV_DUMP                0
 #define MVS_ID_NOT_MAPPED       0x7f
-/* #define DISABLE_HOTPLUG_DMA_FIX */
-// #define MAX_EXP_RUNNING_REQ  2
 #define WIDE_PORT_MAX_PHY               4
-#define MV_DISABLE_NCQ  0
 #define mv_printk(fmt, arg ...) \
         printk(KERN_DEBUG"%s %d:" fmt, __FILE__, __LINE__, ## arg)
 #ifdef MV_DEBUG
@@ -64,6 +60,7 @@
 #endif
 #define MV_MAX_U32                      0xffffffff
 
+extern int interrupt_coalescing;
 extern struct mvs_tgt_initiator mvs_tgt;
 extern struct mvs_info *tgt_mvi;
 extern const struct mvs_dispatch mvs_64xx_dispatch;
@@ -99,6 +96,11 @@ enum dev_status {
         MVS_DEV_EH      = 0x1,
 };
 
+enum dev_reset {
+        MVS_SOFT_RESET  = 0,
+        MVS_HARD_RESET  = 1,
+        MVS_PHY_TUNE    = 2,
+};
 
 struct mvs_info;
 
@@ -130,7 +132,6 @@ struct mvs_dispatch {
         u32 (*read_port_irq_mask)(struct mvs_info *mvi, u32 port);
         void (*write_port_irq_mask)(struct mvs_info *mvi, u32 port, u32 val);
 
-        void (*get_sas_addr)(void *buf, u32 buflen);
         void (*command_active)(struct mvs_info *mvi, u32 slot_idx);
         void (*clear_srs_irq)(struct mvs_info *mvi, u8 reg_set, u8 clear_all);
         void (*issue_stop)(struct mvs_info *mvi, enum mvs_port_type type,
@@ -167,9 +168,10 @@ struct mvs_dispatch {
                                                 );
         int (*spi_issuecmd)(struct mvs_info *mvi, u32 cmd);
         int (*spi_waitdataready)(struct mvs_info *mvi, u32 timeout);
-#ifndef DISABLE_HOTPLUG_DMA_FIX
-        void (*dma_fix)(dma_addr_t buf_dma, int buf_len, int from, void *prd);
-#endif
+        void (*dma_fix)(struct mvs_info *mvi, u32 phy_mask,
+                                int buf_len, int from, void *prd);
+        void (*tune_interrupt)(struct mvs_info *mvi, u32 time);
+        void (*non_spec_ncq_error)(struct mvs_info *mvi);
 
 };
 
@@ -179,9 +181,11 @@ struct mvs_chip_info {
         u32             fis_offs;
         u32             fis_count;
         u32             srs_sz;
+        u32             sg_width;
         u32             slot_width;
         const struct mvs_dispatch *dispatch;
 };
+#define MVS_MAX_SG              (1U << mvi->chip->sg_width)
 #define MVS_CHIP_SLOT_SZ        (1U << mvi->chip->slot_width)
 #define MVS_RX_FISL_SZ          \
         (mvi->chip->fis_offs + (mvi->chip->fis_count * 0x100))
@@ -249,6 +253,73 @@ struct mvs_device {
         u16 reserved;
 };
 
+/* Generate  PHY tunning parameters */
+struct phy_tuning {
+        /* 1 bit,  transmitter emphasis enable  */
+        u8      trans_emp_en:1;
+        /* 4 bits, transmitter emphasis amplitude */
+        u8      trans_emp_amp:4;
+        /* 3 bits, reserved space */
+        u8      Reserved_2bit_1:3;
+        /* 5 bits, transmitter amplitude */
+        u8      trans_amp:5;
+        /* 2 bits, transmitter amplitude adjust */
+        u8      trans_amp_adj:2;
+        /* 1 bit, reserved space */
+        u8      resv_2bit_2:1;
+        /* 2 bytes, reserved space */
+        u8      reserved[2];
+};
+
+struct ffe_control {
+        /* 4 bits,  FFE Capacitor Select  (value range 0~F)  */
+        u8 ffe_cap_sel:4;
+        /* 3 bits,  FFE Resistor Select (value range 0~7) */
+        u8 ffe_rss_sel:3;
+        /* 1 bit reserve*/
+        u8 reserved:1;
+};
+
+/*
+ * HBA_Info_Page is saved in Flash/NVRAM, total 256 bytes.
+ * The data area is valid only Signature="MRVL".
+ * If any member fills with 0xFF, the member is invalid.
+ */
+struct hba_info_page {
+        /* Dword 0 */
+        /* 4 bytes, structure signature,should be "MRVL" at first initial */
+        u8 signature[4];
+
+        /* Dword 1-13 */
+        u32 reserved1[13];
+
+        /* Dword 14-29 */
+        /* 64 bytes, SAS address for each port */
+        u64 sas_addr[8];
+
+        /* Dword 30-31 */
+        /* 8 bytes for vanir 8 port PHY FFE seeting
+         * BIT 0~3 : FFE Capacitor select(value range 0~F)
+         * BIT 4~6 : FFE Resistor select(value range 0~7)
+         * BIT 7: reserve.
+         */
+
+        struct ffe_control  ffe_ctl[8];
+        /* Dword 32 -43 */
+        u32 reserved2[12];
+
+        /* Dword 44-45 */
+        /* 8 bytes,  0:  1.5G, 1: 3.0G, should be 0x01 at first initial */
+        u8 phy_rate[8];
+
+        /* Dword 46-53 */
+        /* 32 bytes, PHY tuning parameters for each PHY*/
+        struct phy_tuning   phy_tuning[8];
+
+        /* Dword 54-63 */
+        u32 reserved3[10];
+};      /* total 256 bytes */
+
 struct mvs_slot_info {
         struct list_head entry;
         union {
@@ -264,9 +335,6 @@ struct mvs_slot_info {
          */
         void *buf;
         dma_addr_t buf_dma;
-#if _MV_DUMP
-        u32 cmd_size;
-#endif
         void *response;
         struct mvs_port *port;
         struct mvs_device       *device;
@@ -320,12 +388,10 @@ struct mvs_info {
         const struct mvs_chip_info *chip;
 
         int tags_num;
-        DECLARE_BITMAP(tags, MVS_SLOTS);
+        unsigned long *tags;
         /* further per-slot information */
         struct mvs_phy phy[MVS_MAX_PHYS];
         struct mvs_port port[MVS_MAX_PHYS];
-        u32 irq;
-        u32 exp_req;
         u32 id;
         u64 sata_reg_set;
         struct list_head *hba_list;
@@ -337,12 +403,13 @@ struct mvs_info {
         u32 flashsectSize;
 
         void *addon;
+        struct hba_info_page hba_info_param;
         struct mvs_device       devices[MVS_MAX_DEVICES];
-#ifndef DISABLE_HOTPLUG_DMA_FIX
         void *bulk_buffer;
         dma_addr_t bulk_buffer_dma;
+        void *bulk_buffer1;
+        dma_addr_t bulk_buffer_dma1;
 #define TRASH_BUCKET_SIZE       0x20000
-#endif
         void *dma_pool;
         struct mvs_slot_info slot_info[0];
 };
@@ -350,8 +417,10 @@ struct mvs_info {
 struct mvs_prv_info{
         u8 n_host;
         u8 n_phy;
-        u16 reserve;
+        u8 scan_finished;
+        u8 reserve;
         struct mvs_info *mvi[2];
+        struct tasklet_struct mv_tasklet;
 };
 
 struct mvs_wq {
@@ -415,6 +484,6 @@ void mvs_do_release_task(struct mvs_info *mvi, int phy_no,
 void mvs_int_port(struct mvs_info *mvi, int phy_no, u32 events);
 void mvs_update_phyinfo(struct mvs_info *mvi, int i, int get_st);
 int mvs_int_rx(struct mvs_info *mvi, bool self_clear);
-void mvs_hexdump(u32 size, u8 *data, u32 baseaddr);
+struct mvs_device *mvs_find_dev_by_reg_set(struct mvs_info *mvi, u8 reg_set);
 #endif
 
diff --git a/drivers/scsi/pmcraid.c b/drivers/scsi/pmcraid.c
index fca6a8953070..d079f9a3c6b3 100644
--- a/drivers/scsi/pmcraid.c
+++ b/drivers/scsi/pmcraid.c
@@ -3871,6 +3871,9 @@ static long pmcraid_ioctl_passthrough(
                         pmcraid_err("couldn't build passthrough ioadls\n");
                         goto out_free_buffer;
                 }
+        } else if (request_size < 0) {
+                rc = -EINVAL;
+                goto out_free_buffer;
         }
 
         /* If data is being written into the device, copy the data from user
diff --git a/drivers/scsi/qla2xxx/qla_attr.c b/drivers/scsi/qla2xxx/qla_attr.c
index 532313e0725e..7836eb01c7fc 100644
--- a/drivers/scsi/qla2xxx/qla_attr.c
+++ b/drivers/scsi/qla2xxx/qla_attr.c
@@ -42,8 +42,8 @@ qla2x00_sysfs_write_fw_dump(struct file *filp, struct kobject *kobj,
         int reading;
 
         if (IS_QLA82XX(ha)) {
-                DEBUG2(qla_printk(KERN_INFO, ha,
-                        "Firmware dump not supported for ISP82xx\n"));
+                ql_dbg(ql_dbg_user, vha, 0x705b,
+                    "Firmware dump not supported for ISP82xx\n");
                 return count;
         }
 
@@ -56,7 +56,7 @@ qla2x00_sysfs_write_fw_dump(struct file *filp, struct kobject *kobj,
                 if (!ha->fw_dump_reading)
                         break;
 
-                qla_printk(KERN_INFO, ha,
+                ql_log(ql_log_info, vha, 0x705d,
                     "Firmware dump cleared on (%ld).\n", vha->host_no);
 
                 ha->fw_dump_reading = 0;
@@ -66,7 +66,7 @@ qla2x00_sysfs_write_fw_dump(struct file *filp, struct kobject *kobj,
                 if (ha->fw_dumped && !ha->fw_dump_reading) {
                         ha->fw_dump_reading = 1;
 
-                        qla_printk(KERN_INFO, ha,
+                        ql_log(ql_log_info, vha, 0x705e,
                             "Raw firmware dump ready for read on (%ld).\n",
                             vha->host_no);
                 }
@@ -148,7 +148,7 @@ qla2x00_sysfs_write_nvram(struct file *filp, struct kobject *kobj,
         }
 
         if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) {
-                qla_printk(KERN_WARNING, ha,
+                ql_log(ql_log_warn, vha, 0x705f,
                     "HBA not online, failing NVRAM update.\n");
                 return -EAGAIN;
         }
@@ -158,6 +158,8 @@ qla2x00_sysfs_write_nvram(struct file *filp, struct kobject *kobj,
         ha->isp_ops->read_nvram(vha, (uint8_t *)ha->nvram, ha->nvram_base,
             count);
 
+        ql_dbg(ql_dbg_user, vha, 0x7060,
+            "Setting ISP_ABORT_NEEDED\n");
         /* NVRAM settings take effect immediately. */
         set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
         qla2xxx_wake_dpc(vha);
@@ -255,9 +257,9 @@ qla2x00_sysfs_write_optrom_ctl(struct file *filp, struct kobject *kobj,
 
                 ha->optrom_state = QLA_SWAITING;
 
-                DEBUG2(qla_printk(KERN_INFO, ha,
+                ql_dbg(ql_dbg_user, vha, 0x7061,
                     "Freeing flash region allocation -- 0x%x bytes.\n",
-                    ha->optrom_region_size));
+                    ha->optrom_region_size);
 
                 vfree(ha->optrom_buffer);
                 ha->optrom_buffer = NULL;
@@ -273,7 +275,7 @@ qla2x00_sysfs_write_optrom_ctl(struct file *filp, struct kobject *kobj,
                 ha->optrom_state = QLA_SREADING;
                 ha->optrom_buffer = vmalloc(ha->optrom_region_size);
                 if (ha->optrom_buffer == NULL) {
-                        qla_printk(KERN_WARNING, ha,
+                        ql_log(ql_log_warn, vha, 0x7062,
                             "Unable to allocate memory for optrom retrieval "
                             "(%x).\n", ha->optrom_region_size);
 
@@ -282,14 +284,14 @@ qla2x00_sysfs_write_optrom_ctl(struct file *filp, struct kobject *kobj,
                 }
 
                 if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) {
-                        qla_printk(KERN_WARNING, ha,
-                                "HBA not online, failing NVRAM update.\n");
+                        ql_log(ql_log_warn, vha, 0x7063,
+                            "HBA not online, failing NVRAM update.\n");
                         return -EAGAIN;
                 }
 
-                DEBUG2(qla_printk(KERN_INFO, ha,
+                ql_dbg(ql_dbg_user, vha, 0x7064,
                     "Reading flash region -- 0x%x/0x%x.\n",
-                    ha->optrom_region_start, ha->optrom_region_size));
+                    ha->optrom_region_start, ha->optrom_region_size);
 
                 memset(ha->optrom_buffer, 0, ha->optrom_region_size);
                 ha->isp_ops->read_optrom(vha, ha->optrom_buffer,
@@ -328,7 +330,7 @@ qla2x00_sysfs_write_optrom_ctl(struct file *filp, struct kobject *kobj,
                 else if (IS_QLA25XX(ha) || IS_QLA8XXX_TYPE(ha))
                         valid = 1;
                 if (!valid) {
-                        qla_printk(KERN_WARNING, ha,
+                        ql_log(ql_log_warn, vha, 0x7065,
                             "Invalid start region 0x%x/0x%x.\n", start, size);
                         return -EINVAL;
                 }
@@ -340,17 +342,17 @@ qla2x00_sysfs_write_optrom_ctl(struct file *filp, struct kobject *kobj,
                 ha->optrom_state = QLA_SWRITING;
                 ha->optrom_buffer = vmalloc(ha->optrom_region_size);
                 if (ha->optrom_buffer == NULL) {
-                        qla_printk(KERN_WARNING, ha,
+                        ql_log(ql_log_warn, vha, 0x7066,
                             "Unable to allocate memory for optrom update "
-                            "(%x).\n", ha->optrom_region_size);
+                            "(%x)\n", ha->optrom_region_size);
 
                         ha->optrom_state = QLA_SWAITING;
                         return count;
                 }
 
-                DEBUG2(qla_printk(KERN_INFO, ha,
+                ql_dbg(ql_dbg_user, vha, 0x7067,
                     "Staging flash region write -- 0x%x/0x%x.\n",
-                    ha->optrom_region_start, ha->optrom_region_size));
+                    ha->optrom_region_start, ha->optrom_region_size);
 
                 memset(ha->optrom_buffer, 0, ha->optrom_region_size);
                 break;
@@ -359,14 +361,14 @@ qla2x00_sysfs_write_optrom_ctl(struct file *filp, struct kobject *kobj,
                         break;
 
                 if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) {
-                        qla_printk(KERN_WARNING, ha,
+                        ql_log(ql_log_warn, vha, 0x7068,
                             "HBA not online, failing flash update.\n");
                         return -EAGAIN;
                 }
 
-                DEBUG2(qla_printk(KERN_INFO, ha,
+                ql_dbg(ql_dbg_user, vha, 0x7069,
                     "Writing flash region -- 0x%x/0x%x.\n",
-                    ha->optrom_region_start, ha->optrom_region_size));
+                    ha->optrom_region_start, ha->optrom_region_size);
 
                 ha->isp_ops->write_optrom(vha, ha->optrom_buffer,
                     ha->optrom_region_start, ha->optrom_region_size);
@@ -425,7 +427,7 @@ qla2x00_sysfs_write_vpd(struct file *filp, struct kobject *kobj,
                 return 0;
 
         if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) {
-                qla_printk(KERN_WARNING, ha,
+                ql_log(ql_log_warn, vha, 0x706a,
                     "HBA not online, failing VPD update.\n");
                 return -EAGAIN;
         }
@@ -440,7 +442,7 @@ qla2x00_sysfs_write_vpd(struct file *filp, struct kobject *kobj,
 
         tmp_data = vmalloc(256);
         if (!tmp_data) {
-                qla_printk(KERN_WARNING, ha,
+                ql_log(ql_log_warn, vha, 0x706b,
                     "Unable to allocate memory for VPD information update.\n");
                 goto done;
         }
@@ -480,7 +482,7 @@ qla2x00_sysfs_read_sfp(struct file *filp, struct kobject *kobj,
         ha->sfp_data = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL,
             &ha->sfp_data_dma);
         if (!ha->sfp_data) {
-                qla_printk(KERN_WARNING, ha,
+                ql_log(ql_log_warn, vha, 0x706c,
                     "Unable to allocate memory for SFP read-data.\n");
                 return 0;
         }
@@ -499,9 +501,10 @@ do_read:
                 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,
+                        ql_log(ql_log_warn, vha, 0x706d,
                             "Unable to read SFP data (%x/%x/%x).\n", rval,
                             addr, offset);
+
                         count = 0;
                         break;
                 }
@@ -538,8 +541,8 @@ qla2x00_sysfs_write_reset(struct file *filp, struct kobject *kobj,
         type = simple_strtol(buf, NULL, 10);
         switch (type) {
         case 0x2025c:
-                qla_printk(KERN_INFO, ha,
-                    "Issuing ISP reset on (%ld).\n", vha->host_no);
+                ql_log(ql_log_info, vha, 0x706e,
+                    "Issuing ISP reset.\n");
 
                 scsi_block_requests(vha->host);
                 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
@@ -551,8 +554,8 @@ qla2x00_sysfs_write_reset(struct file *filp, struct kobject *kobj,
                 if (!IS_QLA81XX(ha))
                         break;
 
-                qla_printk(KERN_INFO, ha,
-                    "Issuing MPI reset on (%ld).\n", vha->host_no);
+                ql_log(ql_log_info, vha, 0x706f,
+                    "Issuing MPI reset.\n");
 
                 /* Make sure FC side is not in reset */
                 qla2x00_wait_for_hba_online(vha);
@@ -560,20 +563,19 @@ qla2x00_sysfs_write_reset(struct file *filp, struct kobject *kobj,
                 /* Issue MPI reset */
                 scsi_block_requests(vha->host);
                 if (qla81xx_restart_mpi_firmware(vha) != QLA_SUCCESS)
-                        qla_printk(KERN_WARNING, ha,
-                            "MPI reset failed on (%ld).\n", vha->host_no);
+                        ql_log(ql_log_warn, vha, 0x7070,
+                            "MPI reset failed.\n");
                 scsi_unblock_requests(vha->host);
                 break;
         case 0x2025e:
                 if (!IS_QLA82XX(ha) || vha != base_vha) {
-                        qla_printk(KERN_INFO, ha,
-                            "FCoE ctx reset not supported for host%ld.\n",
-                            vha->host_no);
+                        ql_log(ql_log_info, vha, 0x7071,
+                            "FCoE ctx reset no supported.\n");
                         return count;
                 }
 
-                qla_printk(KERN_INFO, ha,
-                    "Issuing FCoE CTX reset on host%ld.\n", vha->host_no);
+                ql_log(ql_log_info, vha, 0x7072,
+                    "Issuing FCoE ctx reset.\n");
                 set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
                 qla2xxx_wake_dpc(vha);
                 qla2x00_wait_for_fcoe_ctx_reset(vha);
@@ -611,8 +613,8 @@ qla2x00_sysfs_write_edc(struct file *filp, struct kobject *kobj,
                 ha->edc_data = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL,
                     &ha->edc_data_dma);
                 if (!ha->edc_data) {
-                        DEBUG2(qla_printk(KERN_INFO, ha,
-                            "Unable to allocate memory for EDC write.\n"));
+                        ql_log(ql_log_warn, vha, 0x7073,
+                            "Unable to allocate memory for EDC write.\n");
                         return 0;
                 }
         }
@@ -631,9 +633,9 @@ qla2x00_sysfs_write_edc(struct file *filp, struct kobject *kobj,
         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[8]));
+                ql_log(ql_log_warn, vha, 0x7074,
+                    "Unable to write EDC (%x) %02x:%04x:%02x:%02x\n",
+                    rval, dev, adr, opt, len, buf[8]);
                 return 0;
         }
 
@@ -669,8 +671,8 @@ qla2x00_sysfs_write_edc_status(struct file *filp, struct kobject *kobj,
                 ha->edc_data = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL,
                     &ha->edc_data_dma);
                 if (!ha->edc_data) {
-                        DEBUG2(qla_printk(KERN_INFO, ha,
-                            "Unable to allocate memory for EDC status.\n"));
+                        ql_log(ql_log_warn, vha, 0x708c,
+                            "Unable to allocate memory for EDC status.\n");
                         return 0;
                 }
         }
@@ -688,9 +690,9 @@ qla2x00_sysfs_write_edc_status(struct file *filp, struct kobject *kobj,
         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",
-                    rval, dev, adr, opt, len));
+                ql_log(ql_log_info, vha, 0x7075,
+                    "Unable to write EDC status (%x) %02x:%04x:%02x.\n",
+                    rval, dev, adr, opt, len);
                 return 0;
         }
 
@@ -749,7 +751,7 @@ qla2x00_sysfs_read_xgmac_stats(struct file *filp, struct kobject *kobj,
         ha->xgmac_data = dma_alloc_coherent(&ha->pdev->dev, XGMAC_DATA_SIZE,
             &ha->xgmac_data_dma, GFP_KERNEL);
         if (!ha->xgmac_data) {
-                qla_printk(KERN_WARNING, ha,
+                ql_log(ql_log_warn, vha, 0x7076,
                     "Unable to allocate memory for XGMAC read-data.\n");
                 return 0;
         }
@@ -761,7 +763,7 @@ do_read:
         rval = qla2x00_get_xgmac_stats(vha, ha->xgmac_data_dma,
             XGMAC_DATA_SIZE, &actual_size);
         if (rval != QLA_SUCCESS) {
-                qla_printk(KERN_WARNING, ha,
+                ql_log(ql_log_warn, vha, 0x7077,
                     "Unable to read XGMAC data (%x).\n", rval);
                 count = 0;
         }
@@ -801,7 +803,7 @@ qla2x00_sysfs_read_dcbx_tlv(struct file *filp, struct kobject *kobj,
         ha->dcbx_tlv = dma_alloc_coherent(&ha->pdev->dev, DCBX_TLV_DATA_SIZE,
             &ha->dcbx_tlv_dma, GFP_KERNEL);
         if (!ha->dcbx_tlv) {
-                qla_printk(KERN_WARNING, ha,
+                ql_log(ql_log_warn, vha, 0x7078,
                     "Unable to allocate memory for DCBX TLV read-data.\n");
                 return 0;
         }
@@ -813,8 +815,8 @@ do_read:
         rval = qla2x00_get_dcbx_params(vha, ha->dcbx_tlv_dma,
             DCBX_TLV_DATA_SIZE);
         if (rval != QLA_SUCCESS) {
-                qla_printk(KERN_WARNING, ha,
-                    "Unable to read DCBX TLV data (%x).\n", rval);
+                ql_log(ql_log_warn, vha, 0x7079,
+                    "Unable to read DCBX TLV (%x).\n", rval);
                 count = 0;
         }
 
@@ -869,9 +871,13 @@ qla2x00_alloc_sysfs_attr(scsi_qla_host_t *vha)
                 ret = sysfs_create_bin_file(&host->shost_gendev.kobj,
                     iter->attr);
                 if (ret)
-                        qla_printk(KERN_INFO, vha->hw,
-                            "Unable to create sysfs %s binary attribute "
-                            "(%d).\n", iter->name, ret);
+                        ql_log(ql_log_warn, vha, 0x00f3,
+                            "Unable to create sysfs %s binary attribute (%d).\n",
+                            iter->name, ret);
+                else
+                        ql_dbg(ql_dbg_init, vha, 0x00f4,
+                            "Successfully created sysfs %s binary attribure.\n",
+                            iter->name);
         }
 }
 
@@ -1126,7 +1132,7 @@ qla2x00_beacon_store(struct device *dev, struct device_attribute *attr,
                 return -EPERM;
 
         if (test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags)) {
-                qla_printk(KERN_WARNING, ha,
+                ql_log(ql_log_warn, vha, 0x707a,
                     "Abort ISP active -- ignoring beacon request.\n");
                 return -EBUSY;
         }
@@ -1322,9 +1328,8 @@ qla2x00_thermal_temp_show(struct device *dev,
         temp = frac = 0;
         if (test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags) ||
             test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags))
-                DEBUG2_3_11(printk(KERN_WARNING
-                    "%s(%ld): isp reset in progress.\n",
-                    __func__, vha->host_no));
+                ql_log(ql_log_warn, vha, 0x707b,
+                    "ISP reset active.\n");
         else if (!vha->hw->flags.eeh_busy)
                 rval = qla2x00_get_thermal_temp(vha, &temp, &frac);
         if (rval != QLA_SUCCESS)
@@ -1343,8 +1348,8 @@ qla2x00_fw_state_show(struct device *dev, struct device_attribute *attr,
 
         if (test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags) ||
                 test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags))
-                DEBUG2_3_11(printk("%s(%ld): isp reset in progress.\n",
-                        __func__, vha->host_no));
+                ql_log(ql_log_warn, vha, 0x707c,
+                    "ISP reset active.\n");
         else if (!vha->hw->flags.eeh_busy)
                 rval = qla2x00_get_firmware_state(vha, state);
         if (rval != QLA_SUCCESS)
@@ -1645,8 +1650,8 @@ qla2x00_get_fc_host_stats(struct Scsi_Host *shost)
 
         stats = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &stats_dma);
         if (stats == NULL) {
-                DEBUG2_3_11(printk("%s(%ld): Failed to allocate memory.\n",
-                    __func__, base_vha->host_no));
+                ql_log(ql_log_warn, vha, 0x707d,
+                    "Failed to allocate memory for stats.\n");
                 goto done;
         }
         memset(stats, 0, DMA_POOL_SIZE);
@@ -1746,15 +1751,14 @@ qla24xx_vport_create(struct fc_vport *fc_vport, bool disable)
 
         ret = qla24xx_vport_create_req_sanity_check(fc_vport);
         if (ret) {
-                DEBUG15(printk("qla24xx_vport_create_req_sanity_check failed, "
-                    "status %x\n", ret));
+                ql_log(ql_log_warn, vha, 0x707e,
+                    "Vport sanity check failed, status %x\n", ret);
                 return (ret);
         }
 
         vha = qla24xx_create_vhost(fc_vport);
         if (vha == NULL) {
-                DEBUG15(printk ("qla24xx_create_vhost failed, vha = %p\n",
-                    vha));
+                ql_log(ql_log_warn, vha, 0x707f, "Vport create host failed.\n");
                 return FC_VPORT_FAILED;
         }
         if (disable) {
@@ -1764,8 +1768,8 @@ qla24xx_vport_create(struct fc_vport *fc_vport, bool disable)
                 atomic_set(&vha->vp_state, VP_FAILED);
 
         /* ready to create vport */
-        qla_printk(KERN_INFO, vha->hw, "VP entry id %d assigned.\n",
-                                                        vha->vp_idx);
+        ql_log(ql_log_info, vha, 0x7080,
+            "VP entry id %d assigned.\n", vha->vp_idx);
 
         /* initialized vport states */
         atomic_set(&vha->loop_state, LOOP_DOWN);
@@ -1775,8 +1779,8 @@ qla24xx_vport_create(struct fc_vport *fc_vport, bool disable)
         if (atomic_read(&base_vha->loop_state) == LOOP_DOWN ||
             atomic_read(&base_vha->loop_state) == LOOP_DEAD) {
                 /* Don't retry or attempt login of this virtual port */
-                DEBUG15(printk ("scsi(%ld): pport loop_state is not UP.\n",
-                    base_vha->host_no));
+                ql_dbg(ql_dbg_user, vha, 0x7081,
+                    "Vport loop state is not UP.\n");
                 atomic_set(&vha->loop_state, LOOP_DEAD);
                 if (!disable)
                         fc_vport_set_state(fc_vport, FC_VPORT_LINKDOWN);
@@ -1785,9 +1789,8 @@ qla24xx_vport_create(struct fc_vport *fc_vport, bool disable)
         if ((IS_QLA25XX(ha) || IS_QLA81XX(ha)) && ql2xenabledif) {
                 if (ha->fw_attributes & BIT_4) {
                         vha->flags.difdix_supported = 1;
-                        DEBUG18(qla_printk(KERN_INFO, ha,
-                            "Registering for DIF/DIX type 1 and 3"
-                            " protection.\n"));
+                        ql_dbg(ql_dbg_user, vha, 0x7082,
+                            "Registered for DIF/DIX type 1 and 3 protection.\n");
                         scsi_host_set_prot(vha->host,
                             SHOST_DIF_TYPE1_PROTECTION
                             | SHOST_DIF_TYPE2_PROTECTION
@@ -1802,8 +1805,8 @@ qla24xx_vport_create(struct fc_vport *fc_vport, bool disable)
 
         if (scsi_add_host_with_dma(vha->host, &fc_vport->dev,
                                    &ha->pdev->dev)) {
-                DEBUG15(printk("scsi(%ld): scsi_add_host failure for VP[%d].\n",
-                        vha->host_no, vha->vp_idx));
+                ql_dbg(ql_dbg_user, vha, 0x7083,
+                    "scsi_add_host failure for VP[%d].\n", vha->vp_idx);
                 goto vport_create_failed_2;
         }
 
@@ -1820,6 +1823,10 @@ qla24xx_vport_create(struct fc_vport *fc_vport, bool disable)
 
         if (ha->flags.cpu_affinity_enabled) {
                 req = ha->req_q_map[1];
+                ql_dbg(ql_dbg_multiq, vha, 0xc000,
+                    "Request queue %p attached with "
+                    "VP[%d], cpu affinity =%d\n",
+                    req, vha->vp_idx, ha->flags.cpu_affinity_enabled);
                 goto vport_queue;
         } else if (ql2xmaxqueues == 1 || !ha->npiv_info)
                 goto vport_queue;
@@ -1836,13 +1843,16 @@ qla24xx_vport_create(struct fc_vport *fc_vport, bool disable)
                 ret = qla25xx_create_req_que(ha, options, vha->vp_idx, 0, 0,
                         qos);
                 if (!ret)
-                        qla_printk(KERN_WARNING, ha,
-                        "Can't create request queue for vp_idx:%d\n",
-                        vha->vp_idx);
+                        ql_log(ql_log_warn, vha, 0x7084,
+                            "Can't create request queue for VP[%d]\n",
+                            vha->vp_idx);
                 else {
-                        DEBUG2(qla_printk(KERN_INFO, ha,
-                        "Request Que:%d (QoS: %d) created for vp_idx:%d\n",
-                        ret, qos, vha->vp_idx));
+                        ql_dbg(ql_dbg_multiq, vha, 0xc001,
+                            "Request Que:%d Q0s: %d) created for VP[%d]\n",
+                            ret, qos, vha->vp_idx);
+                        ql_dbg(ql_dbg_user, vha, 0x7085,
+                            "Request Que:%d Q0s: %d) created for VP[%d]\n",
+                            ret, qos, vha->vp_idx);
                         req = ha->req_q_map[ret];
                 }
         }
@@ -1882,12 +1892,13 @@ qla24xx_vport_delete(struct fc_vport *fc_vport)
 
         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));
+                ql_dbg(ql_dbg_user, vha, 0x7086,
+                    "Timer for the VP[%d] has stopped\n", vha->vp_idx);
         }
 
         /* No pending activities shall be there on the vha now */
-        DEBUG(msleep(random32()%10));  /* Just to see if something falls on
+        if (ql2xextended_error_logging & ql_dbg_user)
+                msleep(random32()%10);  /* Just to see if something falls on
                                         * the net we have placed below */
 
         BUG_ON(atomic_read(&vha->vref_count));
@@ -1901,12 +1912,12 @@ qla24xx_vport_delete(struct fc_vport *fc_vport)
 
         if (vha->req->id && !ha->flags.cpu_affinity_enabled) {
                 if (qla25xx_delete_req_que(vha, vha->req) != QLA_SUCCESS)
-                        qla_printk(KERN_WARNING, ha,
-                                "Queue delete failed.\n");
+                        ql_log(ql_log_warn, vha, 0x7087,
+                            "Queue delete failed.\n");
         }
 
         scsi_host_put(vha->host);
-        qla_printk(KERN_INFO, ha, "vport %d deleted\n", id);
+        ql_log(ql_log_info, vha, 0x7088, "VP[%d] deleted.\n", id);
         return 0;
 }
 
diff --git a/drivers/scsi/qla2xxx/qla_bsg.c b/drivers/scsi/qla2xxx/qla_bsg.c
index 8c10e2c4928e..07d1767cd26b 100644
--- a/drivers/scsi/qla2xxx/qla_bsg.c
+++ b/drivers/scsi/qla2xxx/qla_bsg.c
@@ -36,7 +36,8 @@ done:
 }
 
 int
-qla24xx_fcp_prio_cfg_valid(struct qla_fcp_prio_cfg *pri_cfg, uint8_t flag)
+qla24xx_fcp_prio_cfg_valid(scsi_qla_host_t *vha,
+        struct qla_fcp_prio_cfg *pri_cfg, uint8_t flag)
 {
         int i, ret, num_valid;
         uint8_t *bcode;
@@ -51,18 +52,17 @@ qla24xx_fcp_prio_cfg_valid(struct qla_fcp_prio_cfg *pri_cfg, uint8_t flag)
 
         if (bcode_val == 0xFFFFFFFF) {
                 /* No FCP Priority config data in flash */
-                DEBUG2(printk(KERN_INFO
-                    "%s: No FCP priority config data.\n",
-                    __func__));
+                ql_dbg(ql_dbg_user, vha, 0x7051,
+                    "No FCP Priority config data.\n");
                 return 0;
         }
 
         if (bcode[0] != 'H' || bcode[1] != 'Q' || bcode[2] != 'O' ||
                         bcode[3] != 'S') {
                 /* Invalid FCP priority data header*/
-                DEBUG2(printk(KERN_ERR
-                    "%s: Invalid FCP Priority data header. bcode=0x%x\n",
-                    __func__, bcode_val));
+                ql_dbg(ql_dbg_user, vha, 0x7052,
+                    "Invalid FCP Priority data header. bcode=0x%x.\n",
+                    bcode_val);
                 return 0;
         }
         if (flag != 1)
@@ -77,15 +77,14 @@ qla24xx_fcp_prio_cfg_valid(struct qla_fcp_prio_cfg *pri_cfg, uint8_t flag)
 
         if (num_valid == 0) {
                 /* No valid FCP priority data entries */
-                DEBUG2(printk(KERN_ERR
-                    "%s: No valid FCP Priority data entries.\n",
-                    __func__));
+                ql_dbg(ql_dbg_user, vha, 0x7053,
+                    "No valid FCP Priority data entries.\n");
                 ret = 0;
         } else {
                 /* FCP priority data is valid */
-                DEBUG2(printk(KERN_INFO
-                    "%s: Valid FCP priority data. num entries = %d\n",
-                    __func__, num_valid));
+                ql_dbg(ql_dbg_user, vha, 0x7054,
+                    "Valid FCP priority data. num entries = %d.\n",
+                    num_valid);
         }
 
         return ret;
@@ -182,10 +181,9 @@ qla24xx_proc_fcp_prio_cfg_cmd(struct fc_bsg_job *bsg_job)
                 if (!ha->fcp_prio_cfg) {
                         ha->fcp_prio_cfg = vmalloc(FCP_PRIO_CFG_SIZE);
                         if (!ha->fcp_prio_cfg) {
-                                qla_printk(KERN_WARNING, ha,
-                                        "Unable to allocate memory "
-                                        "for fcp prio config data (%x).\n",
-                                        FCP_PRIO_CFG_SIZE);
+                                ql_log(ql_log_warn, vha, 0x7050,
+                                    "Unable to allocate memory for fcp prio "
+                                    "config data (%x).\n", FCP_PRIO_CFG_SIZE);
                                 bsg_job->reply->result = (DID_ERROR << 16);
                                 ret = -ENOMEM;
                                 goto exit_fcp_prio_cfg;
@@ -198,9 +196,9 @@ qla24xx_proc_fcp_prio_cfg_cmd(struct fc_bsg_job *bsg_job)
                         FCP_PRIO_CFG_SIZE);
 
                 /* validate fcp priority data */
-                if (!qla24xx_fcp_prio_cfg_valid(
-                        (struct qla_fcp_prio_cfg *)
-                        ha->fcp_prio_cfg, 1)) {
+
+                if (!qla24xx_fcp_prio_cfg_valid(vha,
+                    (struct qla_fcp_prio_cfg *) ha->fcp_prio_cfg, 1)) {
                         bsg_job->reply->result = (DID_ERROR << 16);
                         ret = -EINVAL;
                         /* If buffer was invalidatic int
@@ -256,9 +254,8 @@ qla2x00_process_els(struct fc_bsg_job *bsg_job)
 
         /* pass through is supported only for ISP 4Gb or higher */
         if (!IS_FWI2_CAPABLE(ha)) {
-                DEBUG2(qla_printk(KERN_INFO, ha,
-                    "scsi(%ld):ELS passthru not supported for ISP23xx based "
-                    "adapters\n", vha->host_no));
+                ql_dbg(ql_dbg_user, vha, 0x7001,
+                    "ELS passthru not supported for ISP23xx based adapters.\n");
                 rval = -EPERM;
                 goto done;
         }
@@ -266,11 +263,11 @@ qla2x00_process_els(struct fc_bsg_job *bsg_job)
         /*  Multiple SG's are not supported for ELS requests */
         if (bsg_job->request_payload.sg_cnt > 1 ||
                 bsg_job->reply_payload.sg_cnt > 1) {
-                DEBUG2(printk(KERN_INFO
-                        "multiple SG's are not supported for ELS requests"
-                        " [request_sg_cnt: %x reply_sg_cnt: %x]\n",
-                        bsg_job->request_payload.sg_cnt,
-                        bsg_job->reply_payload.sg_cnt));
+                ql_dbg(ql_dbg_user, vha, 0x7002,
+                    "Multiple SG's are not suppored for ELS requests, "
+                    "request_sg_cnt=%x reply_sg_cnt=%x.\n",
+                    bsg_job->request_payload.sg_cnt,
+                    bsg_job->reply_payload.sg_cnt);
                 rval = -EPERM;
                 goto done;
         }
@@ -281,9 +278,9 @@ qla2x00_process_els(struct fc_bsg_job *bsg_job)
                  * if not perform fabric login
                  */
                 if (qla2x00_fabric_login(vha, fcport, &nextlid)) {
-                        DEBUG2(qla_printk(KERN_WARNING, ha,
-                        "failed to login port %06X for ELS passthru\n",
-                        fcport->d_id.b24));
+                        ql_dbg(ql_dbg_user, vha, 0x7003,
+                            "Failed to login port %06X for ELS passthru.\n",
+                            fcport->d_id.b24);
                         rval = -EIO;
                         goto done;
                 }
@@ -314,8 +311,7 @@ qla2x00_process_els(struct fc_bsg_job *bsg_job)
         }
 
         if (!vha->flags.online) {
-                DEBUG2(qla_printk(KERN_WARNING, ha,
-                "host not online\n"));
+                ql_log(ql_log_warn, vha, 0x7005, "Host not online.\n");
                 rval = -EIO;
                 goto done;
         }
@@ -337,12 +333,11 @@ qla2x00_process_els(struct fc_bsg_job *bsg_job)
 
         if ((req_sg_cnt !=  bsg_job->request_payload.sg_cnt) ||
                 (rsp_sg_cnt != bsg_job->reply_payload.sg_cnt)) {
-                DEBUG2(printk(KERN_INFO
-                        "dma mapping resulted in different sg counts \
-                        [request_sg_cnt: %x dma_request_sg_cnt: %x\
-                        reply_sg_cnt: %x dma_reply_sg_cnt: %x]\n",
-                        bsg_job->request_payload.sg_cnt, req_sg_cnt,
-                        bsg_job->reply_payload.sg_cnt, rsp_sg_cnt));
+                ql_log(ql_log_warn, vha, 0x7008,
+                    "dma mapping resulted in different sg counts, "
+                    "request_sg_cnt: %x dma_request_sg_cnt:%x reply_sg_cnt:%x "
+                    "dma_reply_sg_cnt:%x.\n", bsg_job->request_payload.sg_cnt,
+                    req_sg_cnt, bsg_job->reply_payload.sg_cnt, rsp_sg_cnt);
                 rval = -EAGAIN;
                 goto done_unmap_sg;
         }
@@ -363,15 +358,16 @@ qla2x00_process_els(struct fc_bsg_job *bsg_job)
                 "bsg_els_rpt" : "bsg_els_hst");
         els->u.bsg_job = bsg_job;
 
-        DEBUG2(qla_printk(KERN_INFO, ha,
-                "scsi(%ld:%x): bsg rqst type: %s els type: %x - loop-id=%x "
-                "portid=%02x%02x%02x.\n", vha->host_no, sp->handle, type,
-                bsg_job->request->rqst_data.h_els.command_code,
-                fcport->loop_id, fcport->d_id.b.domain, fcport->d_id.b.area,
-                fcport->d_id.b.al_pa));
+        ql_dbg(ql_dbg_user, vha, 0x700a,
+            "bsg rqst type: %s els type: %x - loop-id=%x "
+            "portid=%-2x%02x%02x.\n", type,
+            bsg_job->request->rqst_data.h_els.command_code, fcport->loop_id,
+            fcport->d_id.b.domain, fcport->d_id.b.area, fcport->d_id.b.al_pa);
 
         rval = qla2x00_start_sp(sp);
         if (rval != QLA_SUCCESS) {
+                ql_log(ql_log_warn, vha, 0x700e,
+                    "qla2x00_start_sp failed = %d\n", rval);
                 kfree(sp->ctx);
                 mempool_free(sp, ha->srb_mempool);
                 rval = -EIO;
@@ -411,6 +407,8 @@ qla2x00_process_ct(struct fc_bsg_job *bsg_job)
                 dma_map_sg(&ha->pdev->dev, bsg_job->request_payload.sg_list,
                         bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
         if (!req_sg_cnt) {
+                ql_log(ql_log_warn, vha, 0x700f,
+                    "dma_map_sg return %d for request\n", req_sg_cnt);
                 rval = -ENOMEM;
                 goto done;
         }
@@ -418,24 +416,25 @@ qla2x00_process_ct(struct fc_bsg_job *bsg_job)
         rsp_sg_cnt = dma_map_sg(&ha->pdev->dev, bsg_job->reply_payload.sg_list,
                 bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
         if (!rsp_sg_cnt) {
+                ql_log(ql_log_warn, vha, 0x7010,
+                    "dma_map_sg return %d for reply\n", rsp_sg_cnt);
                 rval = -ENOMEM;
                 goto done;
         }
 
         if ((req_sg_cnt !=  bsg_job->request_payload.sg_cnt) ||
             (rsp_sg_cnt != bsg_job->reply_payload.sg_cnt)) {
-                DEBUG2(qla_printk(KERN_WARNING, ha,
-                    "[request_sg_cnt: %x dma_request_sg_cnt: %x\
-                    reply_sg_cnt: %x dma_reply_sg_cnt: %x]\n",
-                    bsg_job->request_payload.sg_cnt, req_sg_cnt,
-                    bsg_job->reply_payload.sg_cnt, rsp_sg_cnt));
+                ql_log(ql_log_warn, vha, 0x7011,
+                    "request_sg_cnt: %x dma_request_sg_cnt: %x reply_sg_cnt:%x "
+                    "dma_reply_sg_cnt: %x\n", bsg_job->request_payload.sg_cnt,
+                    req_sg_cnt, bsg_job->reply_payload.sg_cnt, rsp_sg_cnt);
                 rval = -EAGAIN;
                 goto done_unmap_sg;
         }
 
         if (!vha->flags.online) {
-                DEBUG2(qla_printk(KERN_WARNING, ha,
-                        "host not online\n"));
+                ql_log(ql_log_warn, vha, 0x7012,
+                    "Host is not online.\n");
                 rval = -EIO;
                 goto done_unmap_sg;
         }
@@ -451,8 +450,8 @@ qla2x00_process_ct(struct fc_bsg_job *bsg_job)
                 loop_id = vha->mgmt_svr_loop_id;
                 break;
         default:
-                DEBUG2(qla_printk(KERN_INFO, ha,
-                    "Unknown loop id: %x\n", loop_id));
+                ql_dbg(ql_dbg_user, vha, 0x7013,
+                    "Unknown loop id: %x.\n", loop_id);
                 rval = -EINVAL;
                 goto done_unmap_sg;
         }
@@ -464,6 +463,8 @@ qla2x00_process_ct(struct fc_bsg_job *bsg_job)
          */
         fcport = qla2x00_alloc_fcport(vha, GFP_KERNEL);
         if (!fcport) {
+                ql_log(ql_log_warn, vha, 0x7014,
+                    "Failed to allocate fcport.\n");
                 rval = -ENOMEM;
                 goto done_unmap_sg;
         }
@@ -479,6 +480,8 @@ qla2x00_process_ct(struct fc_bsg_job *bsg_job)
         /* Alloc SRB structure */
         sp = qla2x00_get_ctx_bsg_sp(vha, fcport, sizeof(struct srb_ctx));
         if (!sp) {
+                ql_log(ql_log_warn, vha, 0x7015,
+                    "qla2x00_get_ctx_bsg_sp failed.\n");
                 rval = -ENOMEM;
                 goto done_free_fcport;
         }
@@ -488,15 +491,17 @@ qla2x00_process_ct(struct fc_bsg_job *bsg_job)
         ct->name = "bsg_ct";
         ct->u.bsg_job = bsg_job;
 
-        DEBUG2(qla_printk(KERN_INFO, ha,
-                "scsi(%ld:%x): bsg rqst type: %s els type: %x - loop-id=%x "
-                "portid=%02x%02x%02x.\n", vha->host_no, sp->handle, type,
-                (bsg_job->request->rqst_data.h_ct.preamble_word2 >> 16),
-                fcport->loop_id, fcport->d_id.b.domain, fcport->d_id.b.area,
-                fcport->d_id.b.al_pa));
+        ql_dbg(ql_dbg_user, vha, 0x7016,
+            "bsg rqst type: %s else type: %x - "
+            "loop-id=%x portid=%02x%02x%02x.\n", type,
+            (bsg_job->request->rqst_data.h_ct.preamble_word2 >> 16),
+            fcport->loop_id, fcport->d_id.b.domain, fcport->d_id.b.area,
+            fcport->d_id.b.al_pa);
 
         rval = qla2x00_start_sp(sp);
         if (rval != QLA_SUCCESS) {
+                ql_log(ql_log_warn, vha, 0x7017,
+                    "qla2x00_start_sp failed=%d.\n", rval);
                 kfree(sp->ctx);
                 mempool_free(sp, ha->srb_mempool);
                 rval = -EIO;
@@ -535,9 +540,8 @@ qla81xx_set_internal_loopback(scsi_qla_host_t *vha, uint16_t *config,
         ha->notify_dcbx_comp = 1;
         ret = qla81xx_set_port_config(vha, new_config);
         if (ret != QLA_SUCCESS) {
-                DEBUG2(printk(KERN_ERR
-                    "%s(%lu): Set port config failed\n",
-                    __func__, vha->host_no));
+                ql_log(ql_log_warn, vha, 0x7021,
+                    "set port config failed.\n");
                 ha->notify_dcbx_comp = 0;
                 rval = -EINVAL;
                 goto done_set_internal;
@@ -545,11 +549,11 @@ qla81xx_set_internal_loopback(scsi_qla_host_t *vha, uint16_t *config,
 
         /* Wait for DCBX complete event */
         if (!wait_for_completion_timeout(&ha->dcbx_comp, (20 * HZ))) {
-                DEBUG2(qla_printk(KERN_WARNING, ha,
-                    "State change notificaition not received.\n"));
+                ql_dbg(ql_dbg_user, vha, 0x7022,
+                    "State change notification not received.\n");
         } else
-                DEBUG2(qla_printk(KERN_INFO, ha,
-                    "State change RECEIVED\n"));
+                ql_dbg(ql_dbg_user, vha, 0x7023,
+                    "State change received.\n");
 
         ha->notify_dcbx_comp = 0;
 
@@ -581,9 +585,8 @@ qla81xx_reset_internal_loopback(scsi_qla_host_t *vha, uint16_t *config,
                 ha->notify_dcbx_comp = wait;
                 ret = qla81xx_set_port_config(vha, new_config);
                 if (ret != QLA_SUCCESS) {
-                        DEBUG2(printk(KERN_ERR
-                            "%s(%lu): Set port config failed\n",
-                             __func__, vha->host_no));
+                        ql_log(ql_log_warn, vha, 0x7025,
+                            "Set port config failed.\n");
                         ha->notify_dcbx_comp = 0;
                         rval = -EINVAL;
                         goto done_reset_internal;
@@ -592,14 +595,14 @@ qla81xx_reset_internal_loopback(scsi_qla_host_t *vha, uint16_t *config,
                 /* Wait for DCBX complete event */
                 if (wait && !wait_for_completion_timeout(&ha->dcbx_comp,
                         (20 * HZ))) {
-                        DEBUG2(qla_printk(KERN_WARNING, ha,
-                            "State change notificaition not received.\n"));
+                        ql_dbg(ql_dbg_user, vha, 0x7026,
+                            "State change notification not received.\n");
                         ha->notify_dcbx_comp = 0;
                         rval = -EINVAL;
                         goto done_reset_internal;
                 } else
-                        DEBUG2(qla_printk(KERN_INFO, ha,
-                            "State change RECEIVED\n"));
+                        ql_dbg(ql_dbg_user, vha, 0x7027,
+                            "State change received.\n");
 
                 ha->notify_dcbx_comp = 0;
         }
@@ -629,11 +632,13 @@ qla2x00_process_loopback(struct fc_bsg_job *bsg_job)
 
         if (test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags) ||
                 test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags) ||
-                test_bit(ISP_ABORT_RETRY, &vha->dpc_flags))
+                test_bit(ISP_ABORT_RETRY, &vha->dpc_flags)) {
+                ql_log(ql_log_warn, vha, 0x7018, "Abort active or needed.\n");
                 return -EBUSY;
+        }
 
         if (!vha->flags.online) {
-                DEBUG2(qla_printk(KERN_WARNING, ha, "host not online\n"));
+                ql_log(ql_log_warn, vha, 0x7019, "Host is not online.\n");
                 return -EIO;
         }
 
@@ -641,26 +646,31 @@ qla2x00_process_loopback(struct fc_bsg_job *bsg_job)
                 bsg_job->request_payload.sg_list, bsg_job->request_payload.sg_cnt,
                 DMA_TO_DEVICE);
 
-        if (!elreq.req_sg_cnt)
+        if (!elreq.req_sg_cnt) {
+                ql_log(ql_log_warn, vha, 0x701a,
+                    "dma_map_sg returned %d for request.\n", elreq.req_sg_cnt);
                 return -ENOMEM;
+        }
 
         elreq.rsp_sg_cnt = dma_map_sg(&ha->pdev->dev,
                 bsg_job->reply_payload.sg_list, bsg_job->reply_payload.sg_cnt,
                 DMA_FROM_DEVICE);
 
         if (!elreq.rsp_sg_cnt) {
+                ql_log(ql_log_warn, vha, 0x701b,
+                    "dma_map_sg returned %d for reply.\n", elreq.rsp_sg_cnt);
                 rval = -ENOMEM;
                 goto done_unmap_req_sg;
         }
 
         if ((elreq.req_sg_cnt !=  bsg_job->request_payload.sg_cnt) ||
                 (elreq.rsp_sg_cnt != bsg_job->reply_payload.sg_cnt)) {
-                DEBUG2(printk(KERN_INFO
-                        "dma mapping resulted in different sg counts "
-                        "[request_sg_cnt: %x dma_request_sg_cnt: %x "
-                        "reply_sg_cnt: %x dma_reply_sg_cnt: %x]\n",
-                        bsg_job->request_payload.sg_cnt, elreq.req_sg_cnt,
-                        bsg_job->reply_payload.sg_cnt, elreq.rsp_sg_cnt));
+                ql_log(ql_log_warn, vha, 0x701c,
+                    "dma mapping resulted in different sg counts, "
+                    "request_sg_cnt: %x dma_request_sg_cnt: %x "
+                    "reply_sg_cnt: %x dma_reply_sg_cnt: %x.\n",
+                    bsg_job->request_payload.sg_cnt, elreq.req_sg_cnt,
+                    bsg_job->reply_payload.sg_cnt, elreq.rsp_sg_cnt);
                 rval = -EAGAIN;
                 goto done_unmap_sg;
         }
@@ -668,8 +678,8 @@ qla2x00_process_loopback(struct fc_bsg_job *bsg_job)
         req_data = dma_alloc_coherent(&ha->pdev->dev, req_data_len,
                 &req_data_dma, GFP_KERNEL);
         if (!req_data) {
-                DEBUG2(printk(KERN_ERR "%s: dma alloc for req_data "
-                        "failed for host=%lu\n", __func__, vha->host_no));
+                ql_log(ql_log_warn, vha, 0x701d,
+                    "dma alloc failed for req_data.\n");
                 rval = -ENOMEM;
                 goto done_unmap_sg;
         }
@@ -677,8 +687,8 @@ qla2x00_process_loopback(struct fc_bsg_job *bsg_job)
         rsp_data = dma_alloc_coherent(&ha->pdev->dev, rsp_data_len,
                 &rsp_data_dma, GFP_KERNEL);
         if (!rsp_data) {
-                DEBUG2(printk(KERN_ERR "%s: dma alloc for rsp_data "
-                        "failed for host=%lu\n", __func__, vha->host_no));
+                ql_log(ql_log_warn, vha, 0x7004,
+                    "dma alloc failed for rsp_data.\n");
                 rval = -ENOMEM;
                 goto done_free_dma_req;
         }
@@ -699,8 +709,8 @@ qla2x00_process_loopback(struct fc_bsg_job *bsg_job)
             && req_data_len == MAX_ELS_FRAME_PAYLOAD)) &&
                 elreq.options == EXTERNAL_LOOPBACK) {
                 type = "FC_BSG_HST_VENDOR_ECHO_DIAG";
-                DEBUG2(qla_printk(KERN_INFO, ha,
-                        "scsi(%ld) bsg rqst type: %s\n", vha->host_no, type));
+                ql_dbg(ql_dbg_user, vha, 0x701e,
+                    "BSG request type: %s.\n", type);
                 command_sent = INT_DEF_LB_ECHO_CMD;
                 rval = qla2x00_echo_test(vha, &elreq, response);
         } else {
@@ -708,9 +718,8 @@ qla2x00_process_loopback(struct fc_bsg_job *bsg_job)
                         memset(config, 0, sizeof(config));
                         memset(new_config, 0, sizeof(new_config));
                         if (qla81xx_get_port_config(vha, config)) {
-                                DEBUG2(printk(KERN_ERR
-                                        "%s(%lu): Get port config failed\n",
-                                        __func__, vha->host_no));
+                                ql_log(ql_log_warn, vha, 0x701f,
+                                    "Get port config failed.\n");
                                 bsg_job->reply->reply_payload_rcv_len = 0;
                                 bsg_job->reply->result = (DID_ERROR << 16);
                                 rval = -EPERM;
@@ -718,11 +727,13 @@ qla2x00_process_loopback(struct fc_bsg_job *bsg_job)
                         }
 
                         if (elreq.options != EXTERNAL_LOOPBACK) {
-                                DEBUG2(qla_printk(KERN_INFO, ha,
-                                        "Internal: current port config = %x\n",
-                                        config[0]));
+                                ql_dbg(ql_dbg_user, vha, 0x7020,
+                                    "Internal: curent port config = %x\n",
+                                    config[0]);
                                 if (qla81xx_set_internal_loopback(vha, config,
                                         new_config)) {
+                                        ql_log(ql_log_warn, vha, 0x7024,
+                                            "Internal loopback failed.\n");
                                         bsg_job->reply->reply_payload_rcv_len =
                                                 0;
                                         bsg_job->reply->result =
@@ -746,9 +757,8 @@ qla2x00_process_loopback(struct fc_bsg_job *bsg_job)
                         }
 
                         type = "FC_BSG_HST_VENDOR_LOOPBACK";
-                        DEBUG2(qla_printk(KERN_INFO, ha,
-                                "scsi(%ld) bsg rqst type: %s\n",
-                                vha->host_no, type));
+                        ql_dbg(ql_dbg_user, vha, 0x7028,
+                            "BSG request type: %s.\n", type);
 
                         command_sent = INT_DEF_LB_LOOPBACK_CMD;
                         rval = qla2x00_loopback_test(vha, &elreq, response);
@@ -763,17 +773,16 @@ qla2x00_process_loopback(struct fc_bsg_job *bsg_job)
 
                         if (response[0] == MBS_COMMAND_ERROR &&
                                         response[1] == MBS_LB_RESET) {
-                                DEBUG2(printk(KERN_ERR "%s(%ld): ABORTing "
-                                        "ISP\n", __func__, vha->host_no));
+                                ql_log(ql_log_warn, vha, 0x7029,
+                                    "MBX command error, Aborting ISP.\n");
                                 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
                                 qla2xxx_wake_dpc(vha);
                                 qla2x00_wait_for_chip_reset(vha);
                                 /* Also reset the MPI */
                                 if (qla81xx_restart_mpi_firmware(vha) !=
                                     QLA_SUCCESS) {
-                                        qla_printk(KERN_INFO, ha,
-                                            "MPI reset failed for host%ld.\n",
-                                            vha->host_no);
+                                        ql_log(ql_log_warn, vha, 0x702a,
+                                            "MPI reset failed.\n");
                                 }
 
                                 bsg_job->reply->reply_payload_rcv_len = 0;
@@ -783,17 +792,16 @@ qla2x00_process_loopback(struct fc_bsg_job *bsg_job)
                         }
                 } else {
                         type = "FC_BSG_HST_VENDOR_LOOPBACK";
-                        DEBUG2(qla_printk(KERN_INFO, ha,
-                                "scsi(%ld) bsg rqst type: %s\n",
-                                vha->host_no, type));
+                        ql_dbg(ql_dbg_user, vha, 0x702b,
+                            "BSG request type: %s.\n", type);
                         command_sent = INT_DEF_LB_LOOPBACK_CMD;
                         rval = qla2x00_loopback_test(vha, &elreq, response);
                 }
         }
 
         if (rval) {
-                DEBUG2(qla_printk(KERN_WARNING, ha, "scsi(%ld) Vendor "
-                    "request %s failed\n", vha->host_no, type));
+                ql_log(ql_log_warn, vha, 0x702c,
+                    "Vendor request %s failed.\n", type);
 
                 fw_sts_ptr = ((uint8_t *)bsg_job->req->sense) +
                     sizeof(struct fc_bsg_reply);
@@ -805,8 +813,8 @@ qla2x00_process_loopback(struct fc_bsg_job *bsg_job)
                 bsg_job->reply->reply_payload_rcv_len = 0;
                 bsg_job->reply->result = (DID_ERROR << 16);
         } else {
-                DEBUG2(qla_printk(KERN_WARNING, ha, "scsi(%ld) Vendor "
-                        "request %s completed\n", vha->host_no, type));
+                ql_dbg(ql_dbg_user, vha, 0x702d,
+                    "Vendor request %s completed.\n", type);
 
                 bsg_job->reply_len = sizeof(struct fc_bsg_reply) +
                         sizeof(response) + sizeof(uint8_t);
@@ -851,12 +859,13 @@ qla84xx_reset(struct fc_bsg_job *bsg_job)
 
         if (test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags) ||
             test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags) ||
-            test_bit(ISP_ABORT_RETRY, &vha->dpc_flags))
+            test_bit(ISP_ABORT_RETRY, &vha->dpc_flags)) {
+                ql_log(ql_log_warn, vha, 0x702e, "Abort active or needed.\n");
                 return -EBUSY;
+        }
 
         if (!IS_QLA84XX(ha)) {
-                DEBUG2(qla_printk(KERN_WARNING, ha, "scsi(%ld): Not 84xx, "
-                   "exiting.\n", vha->host_no));
+                ql_dbg(ql_dbg_user, vha, 0x702f, "Not 84xx, exiting.\n");
                 return -EINVAL;
         }
 
@@ -865,14 +874,14 @@ qla84xx_reset(struct fc_bsg_job *bsg_job)
         rval = qla84xx_reset_chip(vha, flag == A84_ISSUE_RESET_DIAG_FW);
 
         if (rval) {
-                DEBUG2(qla_printk(KERN_WARNING, ha, "scsi(%ld) Vendor "
-                    "request 84xx reset failed\n", vha->host_no));
+                ql_log(ql_log_warn, vha, 0x7030,
+                    "Vendor request 84xx reset failed.\n");
                 rval = bsg_job->reply->reply_payload_rcv_len = 0;
                 bsg_job->reply->result = (DID_ERROR << 16);
 
         } else {
-                DEBUG2(qla_printk(KERN_WARNING, ha, "scsi(%ld) Vendor "
-                    "request 84xx reset completed\n", vha->host_no));
+                ql_dbg(ql_dbg_user, vha, 0x7031,
+                    "Vendor request 84xx reset completed.\n");
                 bsg_job->reply->result = DID_OK;
         }
 
@@ -902,21 +911,24 @@ qla84xx_updatefw(struct fc_bsg_job *bsg_job)
                 return -EBUSY;
 
         if (!IS_QLA84XX(ha)) {
-                DEBUG2(qla_printk(KERN_WARNING, ha, "scsi(%ld): Not 84xx, "
-                        "exiting.\n", vha->host_no));
+                ql_dbg(ql_dbg_user, vha, 0x7032,
+                    "Not 84xx, exiting.\n");
                 return -EINVAL;
         }
 
         sg_cnt = dma_map_sg(&ha->pdev->dev, bsg_job->request_payload.sg_list,
                 bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
-        if (!sg_cnt)
+        if (!sg_cnt) {
+                ql_log(ql_log_warn, vha, 0x7033,
+                    "dma_map_sg returned %d for request.\n", sg_cnt);
                 return -ENOMEM;
+        }
 
         if (sg_cnt != bsg_job->request_payload.sg_cnt) {
-                DEBUG2(printk(KERN_INFO
-                        "dma mapping resulted in different sg counts "
-                        "request_sg_cnt: %x dma_request_sg_cnt: %x ",
-                        bsg_job->request_payload.sg_cnt, sg_cnt));
+                ql_log(ql_log_warn, vha, 0x7034,
+                    "DMA mapping resulted in different sg counts, "
+                    "request_sg_cnt: %x dma_request_sg_cnt: %x.\n",
+                    bsg_job->request_payload.sg_cnt, sg_cnt);
                 rval = -EAGAIN;
                 goto done_unmap_sg;
         }
@@ -925,8 +937,8 @@ qla84xx_updatefw(struct fc_bsg_job *bsg_job)
         fw_buf = dma_alloc_coherent(&ha->pdev->dev, data_len,
                 &fw_dma, GFP_KERNEL);
         if (!fw_buf) {
-                DEBUG2(printk(KERN_ERR "%s: dma alloc for fw_buf "
-                        "failed for host=%lu\n", __func__, vha->host_no));
+                ql_log(ql_log_warn, vha, 0x7035,
+                    "DMA alloc failed for fw_buf.\n");
                 rval = -ENOMEM;
                 goto done_unmap_sg;
         }
@@ -936,8 +948,8 @@ qla84xx_updatefw(struct fc_bsg_job *bsg_job)
 
         mn = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &mn_dma);
         if (!mn) {
-                DEBUG2(printk(KERN_ERR "%s: dma alloc for fw buffer "
-                        "failed for host=%lu\n", __func__, vha->host_no));
+                ql_log(ql_log_warn, vha, 0x7036,
+                    "DMA alloc failed for fw buffer.\n");
                 rval = -ENOMEM;
                 goto done_free_fw_buf;
         }
@@ -965,15 +977,15 @@ qla84xx_updatefw(struct fc_bsg_job *bsg_job)
         rval = qla2x00_issue_iocb_timeout(vha, mn, mn_dma, 0, 120);
 
         if (rval) {
-                DEBUG2(qla_printk(KERN_WARNING, ha, "scsi(%ld) Vendor "
-                        "request 84xx updatefw failed\n", vha->host_no));
+                ql_log(ql_log_warn, vha, 0x7037,
+                    "Vendor request 84xx updatefw failed.\n");
 
                 rval = bsg_job->reply->reply_payload_rcv_len = 0;
                 bsg_job->reply->result = (DID_ERROR << 16);
 
         } else {
-                DEBUG2(qla_printk(KERN_WARNING, ha, "scsi(%ld) Vendor "
-                        "request 84xx updatefw completed\n", vha->host_no));
+                ql_dbg(ql_dbg_user, vha, 0x7038,
+                    "Vendor request 84xx updatefw completed.\n");
 
                 bsg_job->reply_len = sizeof(struct fc_bsg_reply);
                 bsg_job->reply->result = DID_OK;
@@ -1009,27 +1021,30 @@ qla84xx_mgmt_cmd(struct fc_bsg_job *bsg_job)
 
         if (test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags) ||
                 test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags) ||
-                test_bit(ISP_ABORT_RETRY, &vha->dpc_flags))
+                test_bit(ISP_ABORT_RETRY, &vha->dpc_flags)) {
+                ql_log(ql_log_warn, vha, 0x7039,
+                    "Abort active or needed.\n");
                 return -EBUSY;
+        }
 
         if (!IS_QLA84XX(ha)) {
-                DEBUG2(qla_printk(KERN_WARNING, ha, "scsi(%ld): Not 84xx, "
-                        "exiting.\n", vha->host_no));
+                ql_log(ql_log_warn, vha, 0x703a,
+                    "Not 84xx, exiting.\n");
                 return -EINVAL;
         }
 
         ql84_mgmt = (struct qla_bsg_a84_mgmt *)((char *)bsg_job->request +
                 sizeof(struct fc_bsg_request));
         if (!ql84_mgmt) {
-                DEBUG2(printk("%s(%ld): mgmt header not provided, exiting.\n",
-                        __func__, vha->host_no));
+                ql_log(ql_log_warn, vha, 0x703b,
+                    "MGMT header not provided, exiting.\n");
                 return -EINVAL;
         }
 
         mn = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &mn_dma);
         if (!mn) {
-                DEBUG2(printk(KERN_ERR "%s: dma alloc for fw buffer "
-                        "failed for host=%lu\n", __func__, vha->host_no));
+                ql_log(ql_log_warn, vha, 0x703c,
+                    "DMA alloc failed for fw buffer.\n");
                 return -ENOMEM;
         }
 
@@ -1044,6 +1059,8 @@ qla84xx_mgmt_cmd(struct fc_bsg_job *bsg_job)
                         bsg_job->reply_payload.sg_list,
                         bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
                 if (!sg_cnt) {
+                        ql_log(ql_log_warn, vha, 0x703d,
+                            "dma_map_sg returned %d for reply.\n", sg_cnt);
                         rval = -ENOMEM;
                         goto exit_mgmt;
                 }
@@ -1051,10 +1068,10 @@ qla84xx_mgmt_cmd(struct fc_bsg_job *bsg_job)
                 dma_direction = DMA_FROM_DEVICE;
 
                 if (sg_cnt != bsg_job->reply_payload.sg_cnt) {
-                        DEBUG2(printk(KERN_INFO
-                                "dma mapping resulted in different sg counts "
-                                "reply_sg_cnt: %x dma_reply_sg_cnt: %x\n",
-                                bsg_job->reply_payload.sg_cnt, sg_cnt));
+                        ql_log(ql_log_warn, vha, 0x703e,
+                            "DMA mapping resulted in different sg counts, "
+                            "reply_sg_cnt: %x dma_reply_sg_cnt: %x.\n",
+                            bsg_job->reply_payload.sg_cnt, sg_cnt);
                         rval = -EAGAIN;
                         goto done_unmap_sg;
                 }
@@ -1064,9 +1081,8 @@ qla84xx_mgmt_cmd(struct fc_bsg_job *bsg_job)
                 mgmt_b = dma_alloc_coherent(&ha->pdev->dev, data_len,
                     &mgmt_dma, GFP_KERNEL);
                 if (!mgmt_b) {
-                        DEBUG2(printk(KERN_ERR "%s: dma alloc for mgmt_b "
-                                "failed for host=%lu\n",
-                                __func__, vha->host_no));
+                        ql_log(ql_log_warn, vha, 0x703f,
+                            "DMA alloc failed for mgmt_b.\n");
                         rval = -ENOMEM;
                         goto done_unmap_sg;
                 }
@@ -1094,6 +1110,8 @@ qla84xx_mgmt_cmd(struct fc_bsg_job *bsg_job)
                         bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
 
                 if (!sg_cnt) {
+                        ql_log(ql_log_warn, vha, 0x7040,
+                            "dma_map_sg returned %d.\n", sg_cnt);
                         rval = -ENOMEM;
                         goto exit_mgmt;
                 }
@@ -1101,10 +1119,10 @@ qla84xx_mgmt_cmd(struct fc_bsg_job *bsg_job)
                 dma_direction = DMA_TO_DEVICE;
 
                 if (sg_cnt != bsg_job->request_payload.sg_cnt) {
-                        DEBUG2(printk(KERN_INFO
-                                "dma mapping resulted in different sg counts "
-                                "request_sg_cnt: %x dma_request_sg_cnt: %x ",
-                                bsg_job->request_payload.sg_cnt, sg_cnt));
+                        ql_log(ql_log_warn, vha, 0x7041,
+                            "DMA mapping resulted in different sg counts, "
+                            "request_sg_cnt: %x dma_request_sg_cnt: %x.\n",
+                            bsg_job->request_payload.sg_cnt, sg_cnt);
                         rval = -EAGAIN;
                         goto done_unmap_sg;
                 }
@@ -1113,9 +1131,8 @@ qla84xx_mgmt_cmd(struct fc_bsg_job *bsg_job)
                 mgmt_b = dma_alloc_coherent(&ha->pdev->dev, data_len,
                         &mgmt_dma, GFP_KERNEL);
                 if (!mgmt_b) {
-                        DEBUG2(printk(KERN_ERR "%s: dma alloc for mgmt_b "
-                                "failed for host=%lu\n",
-                                __func__, vha->host_no));
+                        ql_log(ql_log_warn, vha, 0x7042,
+                            "DMA alloc failed for mgmt_b.\n");
                         rval = -ENOMEM;
                         goto done_unmap_sg;
                 }
@@ -1156,15 +1173,15 @@ qla84xx_mgmt_cmd(struct fc_bsg_job *bsg_job)
         rval = qla2x00_issue_iocb(vha, mn, mn_dma, 0);
 
         if (rval) {
-                DEBUG2(qla_printk(KERN_WARNING, ha, "scsi(%ld) Vendor "
-                        "request 84xx mgmt failed\n", vha->host_no));
+                ql_log(ql_log_warn, vha, 0x7043,
+                    "Vendor request 84xx mgmt failed.\n");
 
                 rval = bsg_job->reply->reply_payload_rcv_len = 0;
                 bsg_job->reply->result = (DID_ERROR << 16);
 
         } else {
-                DEBUG2(qla_printk(KERN_WARNING, ha, "scsi(%ld) Vendor "
-                        "request 84xx mgmt completed\n", vha->host_no));
+                ql_dbg(ql_dbg_user, vha, 0x7044,
+                    "Vendor request 84xx mgmt completed.\n");
 
                 bsg_job->reply_len = sizeof(struct fc_bsg_reply);
                 bsg_job->reply->result = DID_OK;
@@ -1204,7 +1221,6 @@ qla24xx_iidma(struct fc_bsg_job *bsg_job)
 {
         struct Scsi_Host *host = bsg_job->shost;
         scsi_qla_host_t *vha = shost_priv(host);
-        struct qla_hw_data *ha = vha->hw;
         int rval = 0;
         struct qla_port_param *port_param = NULL;
         fc_port_t *fcport = NULL;
@@ -1215,26 +1231,27 @@ qla24xx_iidma(struct fc_bsg_job *bsg_job)
 
         if (test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags) ||
                 test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags) ||
-                test_bit(ISP_ABORT_RETRY, &vha->dpc_flags))
+                test_bit(ISP_ABORT_RETRY, &vha->dpc_flags)) {
+                ql_log(ql_log_warn, vha, 0x7045, "abort active or needed.\n");
                 return -EBUSY;
+        }
 
         if (!IS_IIDMA_CAPABLE(vha->hw)) {
-                DEBUG2(qla_printk(KERN_WARNING, ha, "%s(%lu): iiDMA not "
-                        "supported\n",  __func__, vha->host_no));
+                ql_log(ql_log_info, vha, 0x7046, "iiDMA not supported.\n");
                 return -EINVAL;
         }
 
         port_param = (struct qla_port_param *)((char *)bsg_job->request +
                 sizeof(struct fc_bsg_request));
         if (!port_param) {
-                DEBUG2(printk("%s(%ld): port_param header not provided, "
-                        "exiting.\n", __func__, vha->host_no));
+                ql_log(ql_log_warn, vha, 0x7047,
+                    "port_param header not provided.\n");
                 return -EINVAL;
         }
 
         if (port_param->fc_scsi_addr.dest_type != EXT_DEF_TYPE_WWPN) {
-                DEBUG2(printk(KERN_ERR "%s(%ld): Invalid destination type\n",
-                        __func__, vha->host_no));
+                ql_log(ql_log_warn, vha, 0x7048,
+                    "Invalid destination type.\n");
                 return -EINVAL;
         }
 
@@ -1249,21 +1266,20 @@ qla24xx_iidma(struct fc_bsg_job *bsg_job)
         }
 
         if (!fcport) {
-                DEBUG2(printk(KERN_ERR "%s(%ld): Failed to find port\n",
-                        __func__, vha->host_no));
+                ql_log(ql_log_warn, vha, 0x7049,
+                    "Failed to find port.\n");
                 return -EINVAL;
         }
 
         if (atomic_read(&fcport->state) != FCS_ONLINE) {
-                DEBUG2(printk(KERN_ERR "%s(%ld): Port not online\n",
-                        __func__, vha->host_no));
+                ql_log(ql_log_warn, vha, 0x704a,
+                    "Port is not online.\n");
                 return -EINVAL;
         }
 
         if (fcport->flags & FCF_LOGIN_NEEDED) {
-                DEBUG2(printk(KERN_ERR "%s(%ld): Remote port not logged in, "
-                    "flags = 0x%x\n",
-                    __func__, vha->host_no, fcport->flags));
+                ql_log(ql_log_warn, vha, 0x704b,
+                    "Remote port not logged in flags = 0x%x.\n", fcport->flags);
                 return -EINVAL;
         }
 
@@ -1275,15 +1291,13 @@ qla24xx_iidma(struct fc_bsg_job *bsg_job)
                         &port_param->speed, mb);
 
         if (rval) {
-                DEBUG16(printk(KERN_ERR "scsi(%ld): iIDMA cmd failed for "
-                        "%02x%02x%02x%02x%02x%02x%02x%02x -- "
-                        "%04x %x %04x %04x.\n",
-                        vha->host_no, fcport->port_name[0],
-                        fcport->port_name[1],
-                        fcport->port_name[2], fcport->port_name[3],
-                        fcport->port_name[4], fcport->port_name[5],
-                        fcport->port_name[6], fcport->port_name[7], rval,
-                        fcport->fp_speed, mb[0], mb[1]));
+                ql_log(ql_log_warn, vha, 0x704c,
+                    "iIDMA cmd failed for %02x%02x%02x%02x%02x%02x%02x%02x -- "
+                    "%04x %x %04x %04x.\n", fcport->port_name[0],
+                    fcport->port_name[1], fcport->port_name[2],
+                    fcport->port_name[3], fcport->port_name[4],
+                    fcport->port_name[5], fcport->port_name[6],
+                    fcport->port_name[7], rval, fcport->fp_speed, mb[0], mb[1]);
                 rval = 0;
                 bsg_job->reply->result = (DID_ERROR << 16);
 
@@ -1307,11 +1321,12 @@ qla24xx_iidma(struct fc_bsg_job *bsg_job)
 }
 
 static int
-qla2x00_optrom_setup(struct fc_bsg_job *bsg_job, struct qla_hw_data *ha,
+qla2x00_optrom_setup(struct fc_bsg_job *bsg_job, scsi_qla_host_t *vha,
         uint8_t is_update)
 {
         uint32_t start = 0;
         int valid = 0;
+        struct qla_hw_data *ha = vha->hw;
 
         bsg_job->reply->reply_payload_rcv_len = 0;
 
@@ -1319,14 +1334,20 @@ qla2x00_optrom_setup(struct fc_bsg_job *bsg_job, struct qla_hw_data *ha,
                 return -EINVAL;
 
         start = bsg_job->request->rqst_data.h_vendor.vendor_cmd[1];
-        if (start > ha->optrom_size)
+        if (start > ha->optrom_size) {
+                ql_log(ql_log_warn, vha, 0x7055,
+                    "start %d > optrom_size %d.\n", start, ha->optrom_size);
                 return -EINVAL;
+        }
 
-        if (ha->optrom_state != QLA_SWAITING)
+        if (ha->optrom_state != QLA_SWAITING) {
+                ql_log(ql_log_info, vha, 0x7056,
+                    "optrom_state %d.\n", ha->optrom_state);
                 return -EBUSY;
+        }
 
         ha->optrom_region_start = start;
-
+        ql_dbg(ql_dbg_user, vha, 0x7057, "is_update=%d.\n", is_update);
         if (is_update) {
                 if (ha->optrom_size == OPTROM_SIZE_2300 && start == 0)
                         valid = 1;
@@ -1337,9 +1358,9 @@ qla2x00_optrom_setup(struct fc_bsg_job *bsg_job, struct qla_hw_data *ha,
                     IS_QLA8XXX_TYPE(ha))
                         valid = 1;
                 if (!valid) {
-                        qla_printk(KERN_WARNING, ha,
-                            "Invalid start region 0x%x/0x%x.\n",
-                            start, bsg_job->request_payload.payload_len);
+                        ql_log(ql_log_warn, vha, 0x7058,
+                            "Invalid start region 0x%x/0x%x.\n", start,
+                            bsg_job->request_payload.payload_len);
                         return -EINVAL;
                 }
 
@@ -1358,9 +1379,9 @@ qla2x00_optrom_setup(struct fc_bsg_job *bsg_job, struct qla_hw_data *ha,
 
         ha->optrom_buffer = vmalloc(ha->optrom_region_size);
         if (!ha->optrom_buffer) {
-                qla_printk(KERN_WARNING, ha,
+                ql_log(ql_log_warn, vha, 0x7059,
                     "Read: Unable to allocate memory for optrom retrieval "
-                    "(%x).\n", ha->optrom_region_size);
+                    "(%x)\n", ha->optrom_region_size);
 
                 ha->optrom_state = QLA_SWAITING;
                 return -ENOMEM;
@@ -1378,7 +1399,7 @@ qla2x00_read_optrom(struct fc_bsg_job *bsg_job)
         struct qla_hw_data *ha = vha->hw;
         int rval = 0;
 
-        rval = qla2x00_optrom_setup(bsg_job, ha, 0);
+        rval = qla2x00_optrom_setup(bsg_job, vha, 0);
         if (rval)
                 return rval;
 
@@ -1406,7 +1427,7 @@ qla2x00_update_optrom(struct fc_bsg_job *bsg_job)
         struct qla_hw_data *ha = vha->hw;
         int rval = 0;
 
-        rval = qla2x00_optrom_setup(bsg_job, ha, 1);
+        rval = qla2x00_optrom_setup(bsg_job, vha, 1);
         if (rval)
                 return rval;
 
@@ -1464,6 +1485,23 @@ int
 qla24xx_bsg_request(struct fc_bsg_job *bsg_job)
 {
         int ret = -EINVAL;
+        struct fc_rport *rport;
+        fc_port_t *fcport = NULL;
+        struct Scsi_Host *host;
+        scsi_qla_host_t *vha;
+
+        if (bsg_job->request->msgcode == FC_BSG_RPT_ELS) {
+                rport = bsg_job->rport;
+                fcport = *(fc_port_t **) rport->dd_data;
+                host = rport_to_shost(rport);
+                vha = shost_priv(host);
+        } else {
+                host = bsg_job->shost;
+                vha = shost_priv(host);
+        }
+
+        ql_dbg(ql_dbg_user, vha, 0x7000,
+            "Entered %s msgcode=%d.\n", __func__, bsg_job->request->msgcode);
 
         switch (bsg_job->request->msgcode) {
         case FC_BSG_RPT_ELS:
@@ -1480,7 +1518,7 @@ qla24xx_bsg_request(struct fc_bsg_job *bsg_job)
         case FC_BSG_HST_DEL_RPORT:
         case FC_BSG_RPT_CT:
         default:
-                DEBUG2(printk("qla2xxx: unsupported BSG request\n"));
+                ql_log(ql_log_warn, vha, 0x705a, "Unsupported BSG request.\n");
                 break;
         }
         return ret;
@@ -1514,17 +1552,15 @@ qla24xx_bsg_timeout(struct fc_bsg_job *bsg_job)
                                         && (sp_bsg->u.bsg_job == bsg_job)) {
                                         spin_unlock_irqrestore(&ha->hardware_lock, flags);
                                         if (ha->isp_ops->abort_command(sp)) {
-                                                DEBUG2(qla_printk(KERN_INFO, ha,
-                                                    "scsi(%ld): mbx "
-                                                    "abort_command failed\n",
-                                                    vha->host_no));
+                                                ql_log(ql_log_warn, vha, 0x7089,
+                                                    "mbx abort_command "
+                                                    "failed.\n");
                                                 bsg_job->req->errors =
                                                 bsg_job->reply->result = -EIO;
                                         } else {
-                                                DEBUG2(qla_printk(KERN_INFO, ha,
-                                                    "scsi(%ld): mbx "
-                                                    "abort_command success\n",
-                                                    vha->host_no));
+                                                ql_dbg(ql_dbg_user, vha, 0x708a,
+                                                    "mbx abort_command "
+                                                    "success.\n");
                                                 bsg_job->req->errors =
                                                 bsg_job->reply->result = 0;
                                         }
@@ -1535,8 +1571,7 @@ qla24xx_bsg_timeout(struct fc_bsg_job *bsg_job)
                 }
         }
         spin_unlock_irqrestore(&ha->hardware_lock, flags);
-        DEBUG2(qla_printk(KERN_INFO, ha,
-                "scsi(%ld) SRB not found to abort\n", vha->host_no));
+        ql_log(ql_log_info, vha, 0x708b, "SRB not found to abort.\n");
         bsg_job->req->errors = bsg_job->reply->result = -ENXIO;
         return 0;
 
diff --git a/drivers/scsi/qla2xxx/qla_dbg.c b/drivers/scsi/qla2xxx/qla_dbg.c
index c53719a9a747..2155071f3100 100644
--- a/drivers/scsi/qla2xxx/qla_dbg.c
+++ b/drivers/scsi/qla2xxx/qla_dbg.c
@@ -4,10 +4,36 @@
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
+
+/*
+ * Table for showing the current message id in use for particular level
+ * Change this table for addition of log/debug messages.
+ * -----------------------------------------------------
+ * |             Level            |   Last Value Used  |
+ * -----------------------------------------------------
+ * | Module Init and Probe        |       0x0116       |
+ * | Mailbox commands             |       0x111e       |
+ * | Device Discovery             |       0x2083       |
+ * | Queue Command and IO tracing |       0x302e       |
+ * | DPC Thread                   |       0x401c       |
+ * | Async Events                 |       0x5059       |
+ * | Timer Routines               |       0x600d       |
+ * | User Space Interactions      |       0x709c       |
+ * | Task Management              |       0x8043       |
+ * | AER/EEH                      |       0x900f       |
+ * | Virtual Port                 |       0xa007       |
+ * | ISP82XX Specific             |       0xb027       |
+ * | MultiQ                       |       0xc00b       |
+ * | Misc                         |       0xd00b       |
+ * -----------------------------------------------------
+ */
+
 #include "qla_def.h"
 
 #include <linux/delay.h>
 
+static uint32_t ql_dbg_offset = 0x800;
+
 static inline void
 qla2xxx_prep_dump(struct qla_hw_data *ha, struct qla2xxx_fw_dump *fw_dump)
 {
@@ -383,11 +409,11 @@ qla2xxx_dump_post_process(scsi_qla_host_t *vha, int rval)
         struct qla_hw_data *ha = vha->hw;
 
         if (rval != QLA_SUCCESS) {
-                qla_printk(KERN_WARNING, ha,
-                    "Failed to dump firmware (%x)!!!\n", rval);
+                ql_log(ql_log_warn, vha, 0xd000,
+                    "Failed to dump firmware (%x).\n", rval);
                 ha->fw_dumped = 0;
         } else {
-                qla_printk(KERN_INFO, ha,
+                ql_log(ql_log_info, vha, 0xd001,
                     "Firmware dump saved to temp buffer (%ld/%p).\n",
                     vha->host_no, ha->fw_dump);
                 ha->fw_dumped = 1;
@@ -419,15 +445,16 @@ qla2300_fw_dump(scsi_qla_host_t *vha, int hardware_locked)
                 spin_lock_irqsave(&ha->hardware_lock, flags);
 
         if (!ha->fw_dump) {
-                qla_printk(KERN_WARNING, ha,
-                    "No buffer available for dump!!!\n");
+                ql_log(ql_log_warn, vha, 0xd002,
+                    "No buffer available for dump.\n");
                 goto qla2300_fw_dump_failed;
         }
 
         if (ha->fw_dumped) {
-                qla_printk(KERN_WARNING, ha,
-                    "Firmware has been previously dumped (%p) -- ignoring "
-                    "request...\n", ha->fw_dump);
+                ql_log(ql_log_warn, vha, 0xd003,
+                    "Firmware has been previously dumped (%p) "
+                    "-- ignoring request.\n",
+                    ha->fw_dump);
                 goto qla2300_fw_dump_failed;
         }
         fw = &ha->fw_dump->isp.isp23;
@@ -582,15 +609,16 @@ qla2100_fw_dump(scsi_qla_host_t *vha, int hardware_locked)
                 spin_lock_irqsave(&ha->hardware_lock, flags);
 
         if (!ha->fw_dump) {
-                qla_printk(KERN_WARNING, ha,
-                    "No buffer available for dump!!!\n");
+                ql_log(ql_log_warn, vha, 0xd004,
+                    "No buffer available for dump.\n");
                 goto qla2100_fw_dump_failed;
         }
 
         if (ha->fw_dumped) {
-                qla_printk(KERN_WARNING, ha,
-                    "Firmware has been previously dumped (%p) -- ignoring "
-                    "request...\n", ha->fw_dump);
+                ql_log(ql_log_warn, vha, 0xd005,
+                    "Firmware has been previously dumped (%p) "
+                    "-- ignoring request.\n",
+                    ha->fw_dump);
                 goto qla2100_fw_dump_failed;
         }
         fw = &ha->fw_dump->isp.isp21;
@@ -779,15 +807,16 @@ qla24xx_fw_dump(scsi_qla_host_t *vha, int hardware_locked)
                 spin_lock_irqsave(&ha->hardware_lock, flags);
 
         if (!ha->fw_dump) {
-                qla_printk(KERN_WARNING, ha,
-                    "No buffer available for dump!!!\n");
+                ql_log(ql_log_warn, vha, 0xd006,
+                    "No buffer available for dump.\n");
                 goto qla24xx_fw_dump_failed;
         }
 
         if (ha->fw_dumped) {
-                qla_printk(KERN_WARNING, ha,
-                    "Firmware has been previously dumped (%p) -- ignoring "
-                    "request...\n", ha->fw_dump);
+                ql_log(ql_log_warn, vha, 0xd007,
+                    "Firmware has been previously dumped (%p) "
+                    "-- ignoring request.\n",
+                    ha->fw_dump);
                 goto qla24xx_fw_dump_failed;
         }
         fw = &ha->fw_dump->isp.isp24;
@@ -1017,15 +1046,16 @@ qla25xx_fw_dump(scsi_qla_host_t *vha, int hardware_locked)
                 spin_lock_irqsave(&ha->hardware_lock, flags);
 
         if (!ha->fw_dump) {
-                qla_printk(KERN_WARNING, ha,
-                    "No buffer available for dump!!!\n");
+                ql_log(ql_log_warn, vha, 0xd008,
+                    "No buffer available for dump.\n");
                 goto qla25xx_fw_dump_failed;
         }
 
         if (ha->fw_dumped) {
-                qla_printk(KERN_WARNING, ha,
-                    "Firmware has been previously dumped (%p) -- ignoring "
-                    "request...\n", ha->fw_dump);
+                ql_log(ql_log_warn, vha, 0xd009,
+                    "Firmware has been previously dumped (%p) "
+                    "-- ignoring request.\n",
+                    ha->fw_dump);
                 goto qla25xx_fw_dump_failed;
         }
         fw = &ha->fw_dump->isp.isp25;
@@ -1328,15 +1358,16 @@ qla81xx_fw_dump(scsi_qla_host_t *vha, int hardware_locked)
                 spin_lock_irqsave(&ha->hardware_lock, flags);
 
         if (!ha->fw_dump) {
-                qla_printk(KERN_WARNING, ha,
-                    "No buffer available for dump!!!\n");
+                ql_log(ql_log_warn, vha, 0xd00a,
+                    "No buffer available for dump.\n");
                 goto qla81xx_fw_dump_failed;
         }
 
         if (ha->fw_dumped) {
-                qla_printk(KERN_WARNING, ha,
-                    "Firmware has been previously dumped (%p) -- ignoring "
-                    "request...\n", ha->fw_dump);
+                ql_log(ql_log_warn, vha, 0xd00b,
+                    "Firmware has been previously dumped (%p) "
+                    "-- ignoring request.\n",
+                    ha->fw_dump);
                 goto qla81xx_fw_dump_failed;
         }
         fw = &ha->fw_dump->isp.isp81;
@@ -1619,106 +1650,255 @@ qla81xx_fw_dump_failed:
 /****************************************************************************/
 /*                         Driver Debug Functions.                          */
 /****************************************************************************/
-
+/*
+ * This function is for formatting and logging debug information.
+ * It is to be used when vha is available. It formats the message
+ * and logs it to the messages file.
+ * parameters:
+ * level: The level of the debug messages to be printed.
+ *        If ql2xextended_error_logging value is correctly set,
+ *        this message will appear in the messages file.
+ * vha:   Pointer to the scsi_qla_host_t.
+ * id:    This is a unique identifier for the level. It identifies the
+ *        part of the code from where the message originated.
+ * msg:   The message to be displayed.
+ */
 void
-qla2x00_dump_regs(scsi_qla_host_t *vha)
-{
-        int i;
-        struct qla_hw_data *ha = vha->hw;
-        struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
-        struct device_reg_24xx __iomem *reg24 = &ha->iobase->isp24;
-        uint16_t __iomem *mbx_reg;
+ql_dbg(uint32_t level, scsi_qla_host_t *vha, int32_t id, char *msg, ...) {
+
+        char pbuf[QL_DBG_BUF_LEN];
+        va_list ap;
+        uint32_t len;
+        struct pci_dev *pdev = NULL;
+
+        memset(pbuf, 0, QL_DBG_BUF_LEN);
+
+        va_start(ap, msg);
+
+        if ((level & ql2xextended_error_logging) == level) {
+                if (vha != NULL) {
+                        pdev = vha->hw->pdev;
+                        /* <module-name> <pci-name> <msg-id>:<host> Message */
+                        sprintf(pbuf, "%s [%s]-%04x:%ld: ", QL_MSGHDR,
+                            dev_name(&(pdev->dev)), id + ql_dbg_offset,
+                            vha->host_no);
+                } else
+                        sprintf(pbuf, "%s [%s]-%04x: : ", QL_MSGHDR,
+                            "0000:00:00.0", id + ql_dbg_offset);
+
+                len = strlen(pbuf);
+                vsprintf(pbuf+len, msg, ap);
+                pr_warning("%s", pbuf);
+        }
 
-        mbx_reg = IS_FWI2_CAPABLE(ha) ? &reg24->mailbox0:
-            MAILBOX_REG(ha, reg, 0);
+        va_end(ap);
 
-        printk("Mailbox registers:\n");
-        for (i = 0; i < 6; i++)
-                printk("scsi(%ld): mbox %d 0x%04x \n", vha->host_no, i,
-                    RD_REG_WORD(mbx_reg++));
 }
 
-
+/*
+ * This function is for formatting and logging debug information.
+ * It is to be used when vha is not available and pci is availble,
+ * i.e., before host allocation. It formats the message and logs it
+ * to the messages file.
+ * parameters:
+ * level: The level of the debug messages to be printed.
+ *        If ql2xextended_error_logging value is correctly set,
+ *        this message will appear in the messages file.
+ * pdev:  Pointer to the struct pci_dev.
+ * id:    This is a unique id for the level. It identifies the part
+ *        of the code from where the message originated.
+ * msg:   The message to be displayed.
+ */
 void
-qla2x00_dump_buffer(uint8_t * b, uint32_t size)
-{
-        uint32_t cnt;
-        uint8_t c;
+ql_dbg_pci(uint32_t level, struct pci_dev *pdev, int32_t id, char *msg, ...) {
 
-        printk(" 0   1   2   3   4   5   6   7   8   9  "
-            "Ah  Bh  Ch  Dh  Eh  Fh\n");
-        printk("----------------------------------------"
-            "----------------------\n");
-
-        for (cnt = 0; cnt < size;) {
-                c = *b++;
-                printk("%02x",(uint32_t) c);
-                cnt++;
-                if (!(cnt % 16))
-                        printk("\n");
-                else
-                        printk("  ");
+        char pbuf[QL_DBG_BUF_LEN];
+        va_list ap;
+        uint32_t len;
+
+        if (pdev == NULL)
+                return;
+
+        memset(pbuf, 0, QL_DBG_BUF_LEN);
+
+        va_start(ap, msg);
+
+        if ((level & ql2xextended_error_logging) == level) {
+                /* <module-name> <dev-name>:<msg-id> Message */
+                sprintf(pbuf, "%s [%s]-%04x: : ", QL_MSGHDR,
+                    dev_name(&(pdev->dev)), id + ql_dbg_offset);
+
+                len = strlen(pbuf);
+                vsprintf(pbuf+len, msg, ap);
+                pr_warning("%s", pbuf);
         }
-        if (cnt % 16)
-                printk("\n");
+
+        va_end(ap);
+
 }
 
+/*
+ * This function is for formatting and logging log messages.
+ * It is to be used when vha is available. It formats the message
+ * and logs it to the messages file. All the messages will be logged
+ * irrespective of value of ql2xextended_error_logging.
+ * parameters:
+ * level: The level of the log messages to be printed in the
+ *        messages file.
+ * vha:   Pointer to the scsi_qla_host_t
+ * id:    This is a unique id for the level. It identifies the
+ *        part of the code from where the message originated.
+ * msg:   The message to be displayed.
+ */
 void
-qla2x00_dump_buffer_zipped(uint8_t *b, uint32_t size)
-{
-        uint32_t cnt;
-        uint8_t c;
-        uint8_t  last16[16], cur16[16];
-        uint32_t lc = 0, num_same16 = 0, j;
+ql_log(uint32_t level, scsi_qla_host_t *vha, int32_t id, char *msg, ...) {
 
-        printk(KERN_DEBUG " 0   1   2   3   4   5   6   7   8   9  "
-            "Ah  Bh  Ch  Dh  Eh  Fh\n");
-        printk(KERN_DEBUG "----------------------------------------"
-            "----------------------\n");
+        char pbuf[QL_DBG_BUF_LEN];
+        va_list ap;
+        uint32_t len;
+        struct pci_dev *pdev = NULL;
 
-        for (cnt = 0; cnt < size;) {
-                c = *b++;
+        memset(pbuf, 0, QL_DBG_BUF_LEN);
 
-                cur16[lc++] = c;
+        va_start(ap, msg);
 
-                cnt++;
-                if (cnt % 16)
-                        continue;
-
-                /* We have 16 now */
-                lc = 0;
-                if (num_same16 == 0) {
-                        memcpy(last16, cur16, 16);
-                        num_same16++;
-                        continue;
+        if (level <= ql_errlev) {
+                if (vha != NULL) {
+                        pdev = vha->hw->pdev;
+                        /* <module-name> <msg-id>:<host> Message */
+                        sprintf(pbuf, "%s [%s]-%04x:%ld: ", QL_MSGHDR,
+                            dev_name(&(pdev->dev)), id, vha->host_no);
+                } else
+                        sprintf(pbuf, "%s [%s]-%04x: : ", QL_MSGHDR,
+                            "0000:00:00.0", id);
+
+                len = strlen(pbuf);
+                        vsprintf(pbuf+len, msg, ap);
+
+                switch (level) {
+                case 0: /* FATAL LOG */
+                        pr_crit("%s", pbuf);
+                        break;
+                case 1:
+                        pr_err("%s", pbuf);
+                        break;
+                case 2:
+                        pr_warn("%s", pbuf);
+                        break;
+                default:
+                        pr_info("%s", pbuf);
+                        break;
                 }
-                if (memcmp(cur16, last16, 16) == 0) {
-                        num_same16++;
-                        continue;
+        }
+
+        va_end(ap);
+}
+
+/*
+ * This function is for formatting and logging log messages.
+ * It is to be used when vha is not available and pci is availble,
+ * i.e., before host allocation. It formats the message and logs
+ * it to the messages file. All the messages are logged irrespective
+ * of the value of ql2xextended_error_logging.
+ * parameters:
+ * level: The level of the log messages to be printed in the
+ *        messages file.
+ * pdev:  Pointer to the struct pci_dev.
+ * id:    This is a unique id for the level. It identifies the
+ *        part of the code from where the message originated.
+ * msg:   The message to be displayed.
+ */
+void
+ql_log_pci(uint32_t level, struct pci_dev *pdev, int32_t id, char *msg, ...) {
+
+        char pbuf[QL_DBG_BUF_LEN];
+        va_list ap;
+        uint32_t len;
+
+        if (pdev == NULL)
+                return;
+
+        memset(pbuf, 0, QL_DBG_BUF_LEN);
+
+        va_start(ap, msg);
+
+        if (level <= ql_errlev) {
+                /* <module-name> <dev-name>:<msg-id> Message */
+                sprintf(pbuf, "%s [%s]-%04x: : ", QL_MSGHDR,
+                    dev_name(&(pdev->dev)), id);
+
+                len = strlen(pbuf);
+                vsprintf(pbuf+len, msg, ap);
+                switch (level) {
+                case 0: /* FATAL LOG */
+                        pr_crit("%s", pbuf);
+                        break;
+                case 1:
+                        pr_err("%s", pbuf);
+                        break;
+                case 2:
+                        pr_warn("%s", pbuf);
+                        break;
+                default:
+                        pr_info("%s", pbuf);
+                        break;
                 }
-                for (j = 0; j < 16; j++)
-                        printk(KERN_DEBUG "%02x  ", (uint32_t)last16[j]);
-                printk(KERN_DEBUG "\n");
-
-                if (num_same16 > 1)
-                        printk(KERN_DEBUG "> prev pattern repeats (%u)"
-                            "more times\n", num_same16-1);
-                memcpy(last16, cur16, 16);
-                num_same16 = 1;
         }
 
-        if (num_same16) {
-                for (j = 0; j < 16; j++)
-                        printk(KERN_DEBUG "%02x  ", (uint32_t)last16[j]);
-                printk(KERN_DEBUG "\n");
+        va_end(ap);
+}
 
-                if (num_same16 > 1)
-                        printk(KERN_DEBUG "> prev pattern repeats (%u)"
-                            "more times\n", num_same16-1);
+void
+ql_dump_regs(uint32_t level, scsi_qla_host_t *vha, int32_t id)
+{
+        int i;
+        struct qla_hw_data *ha = vha->hw;
+        struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
+        struct device_reg_24xx __iomem *reg24 = &ha->iobase->isp24;
+        struct device_reg_82xx __iomem *reg82 = &ha->iobase->isp82;
+        uint16_t __iomem *mbx_reg;
+
+        if ((level & ql2xextended_error_logging) == level) {
+
+                if (IS_QLA82XX(ha))
+                        mbx_reg = &reg82->mailbox_in[0];
+                else if (IS_FWI2_CAPABLE(ha))
+                        mbx_reg = &reg24->mailbox0;
+                else
+                        mbx_reg = MAILBOX_REG(ha, reg, 0);
+
+                ql_dbg(level, vha, id, "Mailbox registers:\n");
+                for (i = 0; i < 6; i++)
+                        ql_dbg(level, vha, id,
+                            "mbox[%d] 0x%04x\n", i, RD_REG_WORD(mbx_reg++));
         }
-        if (lc) {
-                for (j = 0; j < lc; j++)
-                        printk(KERN_DEBUG "%02x  ", (uint32_t)cur16[j]);
-                printk(KERN_DEBUG "\n");
+}
+
+
+void
+ql_dump_buffer(uint32_t level, scsi_qla_host_t *vha, int32_t id,
+        uint8_t *b, uint32_t size)
+{
+        uint32_t cnt;
+        uint8_t c;
+        if ((level & ql2xextended_error_logging) == level) {
+
+                ql_dbg(level, vha, id, " 0   1   2   3   4   5   6   7   8   "
+                    "9  Ah  Bh  Ch  Dh  Eh  Fh\n");
+                ql_dbg(level, vha, id, "----------------------------------"
+                    "----------------------------\n");
+
+                ql_dbg(level, vha, id, "");
+                for (cnt = 0; cnt < size;) {
+                        c = *b++;
+                        printk("%02x", (uint32_t) c);
+                        cnt++;
+                        if (!(cnt % 16))
+                                printk("\n");
+                        else
+                                printk("  ");
+                }
+                if (cnt % 16)
+                        ql_dbg(level, vha, id, "\n");
         }
 }
diff --git a/drivers/scsi/qla2xxx/qla_dbg.h b/drivers/scsi/qla2xxx/qla_dbg.h
index 930414541ec6..98a377b99017 100644
--- a/drivers/scsi/qla2xxx/qla_dbg.h
+++ b/drivers/scsi/qla2xxx/qla_dbg.h
@@ -8,146 +8,6 @@
 #include "qla_def.h"
 
 /*
- * Driver debug definitions.
- */
-/* #define QL_DEBUG_LEVEL_1  */ /* Output register accesses to COM1 */
-/* #define QL_DEBUG_LEVEL_2  */ /* Output error msgs to COM1 */
-/* #define QL_DEBUG_LEVEL_3  */ /* Output function trace msgs to COM1 */
-/* #define QL_DEBUG_LEVEL_4  */ /* Output NVRAM trace msgs to COM1 */
-/* #define QL_DEBUG_LEVEL_5  */ /* Output ring trace msgs to COM1 */
-/* #define QL_DEBUG_LEVEL_6  */ /* Output WATCHDOG timer trace to COM1 */
-/* #define QL_DEBUG_LEVEL_7  */ /* Output RISC load trace msgs to COM1 */
-/* #define QL_DEBUG_LEVEL_8  */ /* Output ring saturation msgs to COM1 */
-/* #define QL_DEBUG_LEVEL_9  */ /* Output IOCTL trace msgs */
-/* #define QL_DEBUG_LEVEL_10 */ /* Output IOCTL error msgs */
-/* #define QL_DEBUG_LEVEL_11 */ /* Output Mbx Cmd trace msgs */
-/* #define QL_DEBUG_LEVEL_12 */ /* Output IP trace msgs */
-/* #define QL_DEBUG_LEVEL_13 */ /* Output fdmi function trace msgs */
-/* #define QL_DEBUG_LEVEL_14 */ /* Output RSCN trace msgs */
-/* #define QL_DEBUG_LEVEL_15 */ /* Output NPIV trace msgs */
-/* #define QL_DEBUG_LEVEL_16 */ /* Output ISP84XX trace msgs */
-/* #define QL_DEBUG_LEVEL_17 */ /* Output EEH trace messages */
-/* #define QL_DEBUG_LEVEL_18 */ /* Output T10 CRC trace messages */
-
-/*
-* Macros use for debugging the driver.
-*/
-
-#define DEBUG(x)        do { if (ql2xextended_error_logging) { x; } } while (0)
-
-#if defined(QL_DEBUG_LEVEL_1)
-#define DEBUG1(x)       do {x;} while (0)
-#else
-#define DEBUG1(x)       do {} while (0)
-#endif
-
-#define DEBUG2(x)       do { if (ql2xextended_error_logging) { x; } } while (0)
-#define DEBUG2_3(x)     do { if (ql2xextended_error_logging) { x; } } while (0)
-#define DEBUG2_3_11(x)  do { if (ql2xextended_error_logging) { x; } } while (0)
-#define DEBUG2_9_10(x)  do { if (ql2xextended_error_logging) { x; } } while (0)
-#define DEBUG2_11(x)    do { if (ql2xextended_error_logging) { x; } } while (0)
-#define DEBUG2_13(x)    do { if (ql2xextended_error_logging) { x; } } while (0)
-#define DEBUG2_16(x)    do { if (ql2xextended_error_logging) { x; } } while (0)
-#define DEBUG2_17(x)    do { if (ql2xextended_error_logging) { x; } } while (0)
-
-#if defined(QL_DEBUG_LEVEL_3)
-#define DEBUG3(x)       do {x;} while (0)
-#define DEBUG3_11(x)    do {x;} while (0)
-#else
-#define DEBUG3(x)       do {} while (0)
-#endif
-
-#if defined(QL_DEBUG_LEVEL_4)
-#define DEBUG4(x)       do {x;} while (0)
-#else
-#define DEBUG4(x)       do {} while (0)
-#endif
-
-#if defined(QL_DEBUG_LEVEL_5)
-#define DEBUG5(x)          do {x;} while (0)
-#else
-#define DEBUG5(x)       do {} while (0)
-#endif
-
-#if defined(QL_DEBUG_LEVEL_7)
-#define DEBUG7(x)          do {x;} while (0)
-#else
-#define DEBUG7(x)          do {} while (0)
-#endif
-
-#if defined(QL_DEBUG_LEVEL_9)
-#define DEBUG9(x)       do {x;} while (0)
-#define DEBUG9_10(x)    do {x;} while (0)
-#else
-#define DEBUG9(x)       do {} while (0)
-#endif
-
-#if defined(QL_DEBUG_LEVEL_10)
-#define DEBUG10(x)      do {x;} while (0)
-#define DEBUG9_10(x)    do {x;} while (0)
-#else
-#define DEBUG10(x)      do {} while (0)
-  #if !defined(DEBUG9_10)
-  #define DEBUG9_10(x)  do {} while (0)
-  #endif
-#endif
-
-#if defined(QL_DEBUG_LEVEL_11)
-#define DEBUG11(x)      do{x;} while(0)
-#if !defined(DEBUG3_11)
-#define DEBUG3_11(x)    do{x;} while(0)
-#endif
-#else
-#define DEBUG11(x)      do{} while(0)
-  #if !defined(QL_DEBUG_LEVEL_3)
-  #define DEBUG3_11(x)  do{} while(0)
-  #endif
-#endif
-
-#if defined(QL_DEBUG_LEVEL_12)
-#define DEBUG12(x)      do {x;} while (0)
-#else
-#define DEBUG12(x)      do {} while (0)
-#endif
-
-#if defined(QL_DEBUG_LEVEL_13)
-#define DEBUG13(x)      do {x;} while (0)
-#else
-#define DEBUG13(x)      do {} while (0)
-#endif
-
-#if defined(QL_DEBUG_LEVEL_14)
-#define DEBUG14(x)      do {x;} while (0)
-#else
-#define DEBUG14(x)      do {} while (0)
-#endif
-
-#if defined(QL_DEBUG_LEVEL_15)
-#define DEBUG15(x)      do {x;} while (0)
-#else
-#define DEBUG15(x)      do {} while (0)
-#endif
-
-#if defined(QL_DEBUG_LEVEL_16)
-#define DEBUG16(x)      do {x;} while (0)
-#else
-#define DEBUG16(x)      do {} while (0)
-#endif
-
-#if defined(QL_DEBUG_LEVEL_17)
-#define DEBUG17(x)      do {x;} while (0)
-#else
-#define DEBUG17(x)      do {} while (0)
-#endif
-
-#if defined(QL_DEBUG_LEVEL_18)
-#define DEBUG18(x)      do {if (ql2xextended_error_logging) x; } while (0)
-#else
-#define DEBUG18(x)      do {} while (0)
-#endif
-
-
-/*
  * Firmware Dump structure definition
  */
 
@@ -370,3 +230,50 @@ struct qla2xxx_fw_dump {
                 struct qla81xx_fw_dump isp81;
         } isp;
 };
+
+#define QL_MSGHDR "qla2xxx"
+
+#define ql_log_fatal            0 /* display fatal errors */
+#define ql_log_warn             1 /* display critical errors */
+#define ql_log_info             2 /* display all recovered errors */
+#define ql_log_all              3 /* This value is only used by ql_errlev.
+                                   * No messages will use this value.
+                                   * This should be always highest value
+                                   * as compared to other log levels.
+                                   */
+
+extern int ql_errlev;
+
+void
+ql_dbg(uint32_t, scsi_qla_host_t *vha, int32_t, char *, ...);
+void
+ql_dbg_pci(uint32_t, struct pci_dev *pdev, int32_t, char *, ...);
+
+void
+ql_log(uint32_t, scsi_qla_host_t *vha, int32_t, char *, ...);
+void
+ql_log_pci(uint32_t, struct pci_dev *pdev, int32_t, char *, ...);
+
+/* Debug Levels */
+/* The 0x40000000 is the max value any debug level can have
+ * as ql2xextended_error_logging is of type signed int
+ */
+#define ql_dbg_init     0x40000000 /* Init Debug */
+#define ql_dbg_mbx      0x20000000 /* MBX Debug */
+#define ql_dbg_disc     0x10000000 /* Device Discovery Debug */
+#define ql_dbg_io       0x08000000 /* IO Tracing Debug */
+#define ql_dbg_dpc      0x04000000 /* DPC Thead Debug */
+#define ql_dbg_async    0x02000000 /* Async events Debug */
+#define ql_dbg_timer    0x01000000 /* Timer Debug */
+#define ql_dbg_user     0x00800000 /* User Space Interations Debug */
+#define ql_dbg_taskm    0x00400000 /* Task Management Debug */
+#define ql_dbg_aer      0x00200000 /* AER/EEH Debug */
+#define ql_dbg_multiq   0x00100000 /* MultiQ Debug */
+#define ql_dbg_p3p      0x00080000 /* P3P specific Debug */
+#define ql_dbg_vport    0x00040000 /* Virtual Port Debug */
+#define ql_dbg_buffer   0x00020000 /* For dumping the buffer/regs */
+#define ql_dbg_misc     0x00010000 /* For dumping everything that is not
+                                    * not covered by upper categories
+                                    */
+
+#define QL_DBG_BUF_LEN  512
diff --git a/drivers/scsi/qla2xxx/qla_dfs.c b/drivers/scsi/qla2xxx/qla_dfs.c
index a5a4e1275bf2..0b4c2b794c6f 100644
--- a/drivers/scsi/qla2xxx/qla_dfs.c
+++ b/drivers/scsi/qla2xxx/qla_dfs.c
@@ -64,7 +64,7 @@ qla2x00_dfs_fce_open(struct inode *inode, struct file *file)
         /* Pause tracing to flush FCE buffers. */
         rval = qla2x00_disable_fce_trace(vha, &ha->fce_wr, &ha->fce_rd);
         if (rval)
-                qla_printk(KERN_WARNING, ha,
+                ql_dbg(ql_dbg_user, vha, 0x705c,
                     "DebugFS: Unable to disable FCE (%d).\n", rval);
 
         ha->flags.fce_enabled = 0;
@@ -92,7 +92,7 @@ qla2x00_dfs_fce_release(struct inode *inode, struct file *file)
         rval = qla2x00_enable_fce_trace(vha, ha->fce_dma, ha->fce_bufs,
             ha->fce_mb, &ha->fce_bufs);
         if (rval) {
-                qla_printk(KERN_WARNING, ha,
+                ql_dbg(ql_dbg_user, vha, 0x700d,
                     "DebugFS: Unable to reinitialize FCE (%d).\n", rval);
                 ha->flags.fce_enabled = 0;
         }
@@ -125,8 +125,8 @@ qla2x00_dfs_setup(scsi_qla_host_t *vha)
         atomic_set(&qla2x00_dfs_root_count, 0);
         qla2x00_dfs_root = debugfs_create_dir(QLA2XXX_DRIVER_NAME, NULL);
         if (!qla2x00_dfs_root) {
-                qla_printk(KERN_NOTICE, ha,
-                    "DebugFS: Unable to create root directory.\n");
+                ql_log(ql_log_warn, vha, 0x00f7,
+                    "Unable to create debugfs root directory.\n");
                 goto out;
         }
 
@@ -137,8 +137,8 @@ create_dir:
         mutex_init(&ha->fce_mutex);
         ha->dfs_dir = debugfs_create_dir(vha->host_str, qla2x00_dfs_root);
         if (!ha->dfs_dir) {
-                qla_printk(KERN_NOTICE, ha,
-                    "DebugFS: Unable to create ha directory.\n");
+                ql_log(ql_log_warn, vha, 0x00f8,
+                    "Unable to create debugfs ha directory.\n");
                 goto out;
         }
 
@@ -148,8 +148,8 @@ create_nodes:
         ha->dfs_fce = debugfs_create_file("fce", S_IRUSR, ha->dfs_dir, vha,
             &dfs_fce_ops);
         if (!ha->dfs_fce) {
-                qla_printk(KERN_NOTICE, ha,
-                    "DebugFS: Unable to fce node.\n");
+                ql_log(ql_log_warn, vha, 0x00f9,
+                    "Unable to create debugfs fce node.\n");
                 goto out;
         }
 out:
diff --git a/drivers/scsi/qla2xxx/qla_gbl.h b/drivers/scsi/qla2xxx/qla_gbl.h
index 0b381224ae4b..29b1a3e28231 100644
--- a/drivers/scsi/qla2xxx/qla_gbl.h
+++ b/drivers/scsi/qla2xxx/qla_gbl.h
@@ -185,7 +185,7 @@ extern int qla24xx_start_scsi(srb_t *sp);
 int qla2x00_marker(struct scsi_qla_host *, struct req_que *, struct rsp_que *,
                                                 uint16_t, uint16_t, uint8_t);
 extern int qla2x00_start_sp(srb_t *);
-extern uint16_t qla24xx_calc_iocbs(uint16_t);
+extern uint16_t qla24xx_calc_iocbs(scsi_qla_host_t *, uint16_t);
 extern void qla24xx_build_scsi_iocbs(srb_t *, struct cmd_type_7 *, uint16_t);
 extern int qla24xx_dif_start_scsi(srb_t *);
 
@@ -439,6 +439,9 @@ extern void qla81xx_fw_dump(scsi_qla_host_t *, int);
 extern void qla2x00_dump_regs(scsi_qla_host_t *);
 extern void qla2x00_dump_buffer(uint8_t *, uint32_t);
 extern void qla2x00_dump_buffer_zipped(uint8_t *, uint32_t);
+extern void ql_dump_regs(uint32_t, scsi_qla_host_t *, int32_t);
+extern void ql_dump_buffer(uint32_t, scsi_qla_host_t *, int32_t,
+        uint8_t *, uint32_t);
 
 /*
  * Global Function Prototypes in qla_gs.c source file.
@@ -478,7 +481,8 @@ extern int qla2x00_loopback_test(scsi_qla_host_t *, struct msg_echo_lb *, uint16
 extern int qla2x00_echo_test(scsi_qla_host_t *,
         struct msg_echo_lb *, uint16_t *);
 extern int qla24xx_update_all_fcp_prio(scsi_qla_host_t *);
-extern int qla24xx_fcp_prio_cfg_valid(struct qla_fcp_prio_cfg *, uint8_t);
+extern int qla24xx_fcp_prio_cfg_valid(scsi_qla_host_t *,
+        struct qla_fcp_prio_cfg *, uint8_t);
 
 /*
  * Global Function Prototypes in qla_dfs.c source file.
diff --git a/drivers/scsi/qla2xxx/qla_gs.c b/drivers/scsi/qla2xxx/qla_gs.c
index 8cd9066ad906..37937aa3c3b8 100644
--- a/drivers/scsi/qla2xxx/qla_gs.c
+++ b/drivers/scsi/qla2xxx/qla_gs.c
@@ -121,11 +121,10 @@ qla2x00_chk_ms_status(scsi_qla_host_t *vha, ms_iocb_entry_t *ms_pkt,
 
         rval = QLA_FUNCTION_FAILED;
         if (ms_pkt->entry_status != 0) {
-                DEBUG2_3(printk(KERN_WARNING "scsi(%ld): %s failed, error status "
-                    "(%x) on port_id: %02x%02x%02x.\n",
-                    vha->host_no, routine, ms_pkt->entry_status,
-                    vha->d_id.b.domain, vha->d_id.b.area,
-                    vha->d_id.b.al_pa));
+                ql_dbg(ql_dbg_disc, vha, 0x2031,
+                    "%s failed, error status (%x) on port_id: %02x%02x%02x.\n",
+                    routine, ms_pkt->entry_status, vha->d_id.b.domain,
+                    vha->d_id.b.area, vha->d_id.b.al_pa);
         } else {
                 if (IS_FWI2_CAPABLE(ha))
                         comp_status = le16_to_cpu(
@@ -138,24 +137,24 @@ qla2x00_chk_ms_status(scsi_qla_host_t *vha, ms_iocb_entry_t *ms_pkt,
                 case CS_DATA_OVERRUN:           /* Overrun? */
                         if (ct_rsp->header.response !=
                             __constant_cpu_to_be16(CT_ACCEPT_RESPONSE)) {
-                                DEBUG2_3(printk("scsi(%ld): %s failed, "
-                                    "rejected request on port_id: %02x%02x%02x\n",
-                                    vha->host_no, routine,
+                                ql_dbg(ql_dbg_disc + ql_dbg_buffer, vha, 0x2077,
+                                    "%s failed rejected request on port_id: "
+                                    "%02x%02x%02x.\n", routine,
                                     vha->d_id.b.domain, vha->d_id.b.area,
-                                    vha->d_id.b.al_pa));
-                                DEBUG2_3(qla2x00_dump_buffer(
-                                    (uint8_t *)&ct_rsp->header,
-                                    sizeof(struct ct_rsp_hdr)));
+                                    vha->d_id.b.al_pa);
+                                ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha,
+                                    0x2078, (uint8_t *)&ct_rsp->header,
+                                    sizeof(struct ct_rsp_hdr));
                                 rval = QLA_INVALID_COMMAND;
                         } else
                                 rval = QLA_SUCCESS;
                         break;
                 default:
-                        DEBUG2_3(printk("scsi(%ld): %s failed, completion "
-                            "status (%x) on port_id: %02x%02x%02x.\n",
-                            vha->host_no, routine, comp_status,
+                        ql_dbg(ql_dbg_disc, vha, 0x2033,
+                            "%s failed, completion status (%x) on port_id: "
+                            "%02x%02x%02x.\n", routine, comp_status,
                             vha->d_id.b.domain, vha->d_id.b.area,
-                            vha->d_id.b.al_pa));
+                            vha->d_id.b.al_pa);
                         break;
                 }
         }
@@ -202,8 +201,8 @@ qla2x00_ga_nxt(scsi_qla_host_t *vha, fc_port_t *fcport)
             sizeof(ms_iocb_entry_t));
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
-                DEBUG2_3(printk("scsi(%ld): GA_NXT issue IOCB failed (%d).\n",
-                    vha->host_no, rval));
+                ql_dbg(ql_dbg_disc, vha, 0x2062,
+                    "GA_NXT issue IOCB failed (%d).\n", rval);
         } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "GA_NXT") !=
             QLA_SUCCESS) {
                 rval = QLA_FUNCTION_FAILED;
@@ -222,11 +221,10 @@ qla2x00_ga_nxt(scsi_qla_host_t *vha, fc_port_t *fcport)
                     ct_rsp->rsp.ga_nxt.port_type != NS_NL_PORT_TYPE)
                         fcport->d_id.b.domain = 0xf0;
 
-                DEBUG2_3(printk("scsi(%ld): GA_NXT entry - "
-                    "nn %02x%02x%02x%02x%02x%02x%02x%02x "
+                ql_dbg(ql_dbg_disc, vha, 0x2063,
+                    "GA_NXT entry - nn %02x%02x%02x%02x%02x%02x%02x%02x "
                     "pn %02x%02x%02x%02x%02x%02x%02x%02x "
-                    "portid=%02x%02x%02x.\n",
-                    vha->host_no,
+                    "port_id=%02x%02x%02x.\n",
                     fcport->node_name[0], fcport->node_name[1],
                     fcport->node_name[2], fcport->node_name[3],
                     fcport->node_name[4], fcport->node_name[5],
@@ -236,7 +234,7 @@ qla2x00_ga_nxt(scsi_qla_host_t *vha, fc_port_t *fcport)
                     fcport->port_name[4], fcport->port_name[5],
                     fcport->port_name[6], fcport->port_name[7],
                     fcport->d_id.b.domain, fcport->d_id.b.area,
-                    fcport->d_id.b.al_pa));
+                    fcport->d_id.b.al_pa);
         }
 
         return (rval);
@@ -287,8 +285,8 @@ qla2x00_gid_pt(scsi_qla_host_t *vha, sw_info_t *list)
             sizeof(ms_iocb_entry_t));
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
-                DEBUG2_3(printk("scsi(%ld): GID_PT issue IOCB failed (%d).\n",
-                    vha->host_no, rval));
+                ql_dbg(ql_dbg_disc, vha, 0x2055,
+                    "GID_PT issue IOCB failed (%d).\n", rval);
         } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "GID_PT") !=
             QLA_SUCCESS) {
                 rval = QLA_FUNCTION_FAILED;
@@ -364,8 +362,8 @@ qla2x00_gpn_id(scsi_qla_host_t *vha, sw_info_t *list)
                     sizeof(ms_iocb_entry_t));
                 if (rval != QLA_SUCCESS) {
                         /*EMPTY*/
-                        DEBUG2_3(printk("scsi(%ld): GPN_ID issue IOCB failed "
-                            "(%d).\n", vha->host_no, rval));
+                        ql_dbg(ql_dbg_disc, vha, 0x2056,
+                            "GPN_ID issue IOCB failed (%d).\n", rval);
                 } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp,
                     "GPN_ID") != QLA_SUCCESS) {
                         rval = QLA_FUNCTION_FAILED;
@@ -424,8 +422,8 @@ qla2x00_gnn_id(scsi_qla_host_t *vha, sw_info_t *list)
                     sizeof(ms_iocb_entry_t));
                 if (rval != QLA_SUCCESS) {
                         /*EMPTY*/
-                        DEBUG2_3(printk("scsi(%ld): GNN_ID issue IOCB failed "
-                            "(%d).\n", vha->host_no, rval));
+                        ql_dbg(ql_dbg_disc, vha, 0x2057,
+                            "GNN_ID issue IOCB failed (%d).\n", rval);
                 } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp,
                     "GNN_ID") != QLA_SUCCESS) {
                         rval = QLA_FUNCTION_FAILED;
@@ -434,11 +432,10 @@ qla2x00_gnn_id(scsi_qla_host_t *vha, sw_info_t *list)
                         memcpy(list[i].node_name,
                             ct_rsp->rsp.gnn_id.node_name, WWN_SIZE);
 
-                        DEBUG2_3(printk("scsi(%ld): GID_PT entry - "
-                            "nn %02x%02x%02x%02x%02x%02x%02x%02x "
-                            "pn %02x%02x%02x%02x%02x%02x%02x%02x "
+                        ql_dbg(ql_dbg_disc, vha, 0x2058,
+                            "GID_PT entry - nn %02x%02x%02x%02x%02x%02x%02X%02x "
+                            "pn %02x%02x%02x%02x%02x%02x%02X%02x "
                             "portid=%02x%02x%02x.\n",
-                            vha->host_no,
                             list[i].node_name[0], list[i].node_name[1],
                             list[i].node_name[2], list[i].node_name[3],
                             list[i].node_name[4], list[i].node_name[5],
@@ -448,7 +445,7 @@ qla2x00_gnn_id(scsi_qla_host_t *vha, sw_info_t *list)
                             list[i].port_name[4], list[i].port_name[5],
                             list[i].port_name[6], list[i].port_name[7],
                             list[i].d_id.b.domain, list[i].d_id.b.area,
-                            list[i].d_id.b.al_pa));
+                            list[i].d_id.b.al_pa);
                 }
 
                 /* Last device exit. */
@@ -499,14 +496,14 @@ qla2x00_rft_id(scsi_qla_host_t *vha)
             sizeof(ms_iocb_entry_t));
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
-                DEBUG2_3(printk("scsi(%ld): RFT_ID issue IOCB failed (%d).\n",
-                    vha->host_no, rval));
+                ql_dbg(ql_dbg_disc, vha, 0x2043,
+                    "RFT_ID issue IOCB failed (%d).\n", rval);
         } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "RFT_ID") !=
             QLA_SUCCESS) {
                 rval = QLA_FUNCTION_FAILED;
         } else {
-                DEBUG2(printk("scsi(%ld): RFT_ID exiting normally.\n",
-                    vha->host_no));
+                ql_dbg(ql_dbg_disc, vha, 0x2044,
+                    "RFT_ID exiting normally.\n");
         }
 
         return (rval);
@@ -528,8 +525,8 @@ qla2x00_rff_id(scsi_qla_host_t *vha)
         struct ct_sns_rsp       *ct_rsp;
 
         if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
-                DEBUG2(printk("scsi(%ld): RFF_ID call unsupported on "
-                    "ISP2100/ISP2200.\n", vha->host_no));
+                ql_dbg(ql_dbg_disc, vha, 0x2046,
+                    "RFF_ID call not supported on ISP2100/ISP2200.\n");
                 return (QLA_SUCCESS);
         }
 
@@ -556,14 +553,14 @@ qla2x00_rff_id(scsi_qla_host_t *vha)
             sizeof(ms_iocb_entry_t));
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
-                DEBUG2_3(printk("scsi(%ld): RFF_ID issue IOCB failed (%d).\n",
-                    vha->host_no, rval));
+                ql_dbg(ql_dbg_disc, vha, 0x2047,
+                    "RFF_ID issue IOCB failed (%d).\n", rval);
         } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "RFF_ID") !=
             QLA_SUCCESS) {
                 rval = QLA_FUNCTION_FAILED;
         } else {
-                DEBUG2(printk("scsi(%ld): RFF_ID exiting normally.\n",
-                    vha->host_no));
+                ql_dbg(ql_dbg_disc, vha, 0x2048,
+                    "RFF_ID exiting normally.\n");
         }
 
         return (rval);
@@ -609,14 +606,14 @@ qla2x00_rnn_id(scsi_qla_host_t *vha)
             sizeof(ms_iocb_entry_t));
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
-                DEBUG2_3(printk("scsi(%ld): RNN_ID issue IOCB failed (%d).\n",
-                    vha->host_no, rval));
+                ql_dbg(ql_dbg_disc, vha, 0x204d,
+                    "RNN_ID issue IOCB failed (%d).\n", rval);
         } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "RNN_ID") !=
             QLA_SUCCESS) {
                 rval = QLA_FUNCTION_FAILED;
         } else {
-                DEBUG2(printk("scsi(%ld): RNN_ID exiting normally.\n",
-                    vha->host_no));
+                ql_dbg(ql_dbg_disc, vha, 0x204e,
+                    "RNN_ID exiting normally.\n");
         }
 
         return (rval);
@@ -647,8 +644,8 @@ qla2x00_rsnn_nn(scsi_qla_host_t *vha)
         struct ct_sns_rsp       *ct_rsp;
 
         if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
-                DEBUG2(printk("scsi(%ld): RSNN_ID call unsupported on "
-                    "ISP2100/ISP2200.\n", vha->host_no));
+                ql_dbg(ql_dbg_disc, vha, 0x2050,
+                    "RSNN_ID call unsupported on ISP2100/ISP2200.\n");
                 return (QLA_SUCCESS);
         }
 
@@ -682,14 +679,14 @@ qla2x00_rsnn_nn(scsi_qla_host_t *vha)
             sizeof(ms_iocb_entry_t));
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
-                DEBUG2_3(printk("scsi(%ld): RSNN_NN issue IOCB failed (%d).\n",
-                    vha->host_no, rval));
+                ql_dbg(ql_dbg_disc, vha, 0x2051,
+                    "RSNN_NN issue IOCB failed (%d).\n", rval);
         } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "RSNN_NN") !=
             QLA_SUCCESS) {
                 rval = QLA_FUNCTION_FAILED;
         } else {
-                DEBUG2(printk("scsi(%ld): RSNN_NN exiting normally.\n",
-                    vha->host_no));
+                ql_dbg(ql_dbg_disc, vha, 0x2052,
+                    "RSNN_NN exiting normally.\n");
         }
 
         return (rval);
@@ -757,13 +754,14 @@ qla2x00_sns_ga_nxt(scsi_qla_host_t *vha, fc_port_t *fcport)
             sizeof(struct sns_cmd_pkt));
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
-                DEBUG2_3(printk("scsi(%ld): GA_NXT Send SNS failed (%d).\n",
-                    vha->host_no, rval));
+                ql_dbg(ql_dbg_disc, vha, 0x205f,
+                    "GA_NXT Send SNS failed (%d).\n", rval);
         } else if (sns_cmd->p.gan_data[8] != 0x80 ||
             sns_cmd->p.gan_data[9] != 0x02) {
-                DEBUG2_3(printk("scsi(%ld): GA_NXT failed, rejected request, "
-                    "ga_nxt_rsp:\n", vha->host_no));
-                DEBUG2_3(qla2x00_dump_buffer(sns_cmd->p.gan_data, 16));
+                ql_dbg(ql_dbg_disc + ql_dbg_buffer, vha, 0x207d,
+                    "GA_NXT failed, rejected request ga_nxt_rsp:\n");
+                ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x2074,
+                    sns_cmd->p.gan_data, 16);
                 rval = QLA_FUNCTION_FAILED;
         } else {
                 /* Populate fc_port_t entry. */
@@ -778,11 +776,10 @@ qla2x00_sns_ga_nxt(scsi_qla_host_t *vha, fc_port_t *fcport)
                     sns_cmd->p.gan_data[16] != NS_NL_PORT_TYPE)
                         fcport->d_id.b.domain = 0xf0;
 
-                DEBUG2_3(printk("scsi(%ld): GA_NXT entry - "
-                    "nn %02x%02x%02x%02x%02x%02x%02x%02x "
+                ql_dbg(ql_dbg_disc, vha, 0x2061,
+                    "GA_NXT entry - nn %02x%02x%02x%02x%02x%02x%02x%02x "
                     "pn %02x%02x%02x%02x%02x%02x%02x%02x "
-                    "portid=%02x%02x%02x.\n",
-                    vha->host_no,
+                    "port_id=%02x%02x%02x.\n",
                     fcport->node_name[0], fcport->node_name[1],
                     fcport->node_name[2], fcport->node_name[3],
                     fcport->node_name[4], fcport->node_name[5],
@@ -792,7 +789,7 @@ qla2x00_sns_ga_nxt(scsi_qla_host_t *vha, fc_port_t *fcport)
                     fcport->port_name[4], fcport->port_name[5],
                     fcport->port_name[6], fcport->port_name[7],
                     fcport->d_id.b.domain, fcport->d_id.b.area,
-                    fcport->d_id.b.al_pa));
+                    fcport->d_id.b.al_pa);
         }
 
         return (rval);
@@ -831,13 +828,14 @@ qla2x00_sns_gid_pt(scsi_qla_host_t *vha, sw_info_t *list)
             sizeof(struct sns_cmd_pkt));
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
-                DEBUG2_3(printk("scsi(%ld): GID_PT Send SNS failed (%d).\n",
-                    vha->host_no, rval));
+                ql_dbg(ql_dbg_disc, vha, 0x206d,
+                    "GID_PT Send SNS failed (%d).\n", rval);
         } else if (sns_cmd->p.gid_data[8] != 0x80 ||
             sns_cmd->p.gid_data[9] != 0x02) {
-                DEBUG2_3(printk("scsi(%ld): GID_PT failed, rejected request, "
-                    "gid_rsp:\n", vha->host_no));
-                DEBUG2_3(qla2x00_dump_buffer(sns_cmd->p.gid_data, 16));
+                ql_dbg(ql_dbg_disc, vha, 0x202f,
+                    "GID_PT failed, rejected request, gid_rsp:\n");
+                ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x2081,
+                    sns_cmd->p.gid_data, 16);
                 rval = QLA_FUNCTION_FAILED;
         } else {
                 /* Set port IDs in switch info list. */
@@ -900,13 +898,14 @@ qla2x00_sns_gpn_id(scsi_qla_host_t *vha, sw_info_t *list)
                     GPN_ID_SNS_CMD_SIZE / 2, sizeof(struct sns_cmd_pkt));
                 if (rval != QLA_SUCCESS) {
                         /*EMPTY*/
-                        DEBUG2_3(printk("scsi(%ld): GPN_ID Send SNS failed "
-                            "(%d).\n", vha->host_no, rval));
+                        ql_dbg(ql_dbg_disc, vha, 0x2032,
+                            "GPN_ID Send SNS failed (%d).\n", rval);
                 } else if (sns_cmd->p.gpn_data[8] != 0x80 ||
                     sns_cmd->p.gpn_data[9] != 0x02) {
-                        DEBUG2_3(printk("scsi(%ld): GPN_ID failed, rejected "
-                            "request, gpn_rsp:\n", vha->host_no));
-                        DEBUG2_3(qla2x00_dump_buffer(sns_cmd->p.gpn_data, 16));
+                        ql_dbg(ql_dbg_disc + ql_dbg_buffer, vha, 0x207e,
+                            "GPN_ID failed, rejected request, gpn_rsp:\n");
+                        ql_dump_buffer(ql_dbg_disc, vha, 0x207f,
+                            sns_cmd->p.gpn_data, 16);
                         rval = QLA_FUNCTION_FAILED;
                 } else {
                         /* Save portname */
@@ -955,24 +954,24 @@ qla2x00_sns_gnn_id(scsi_qla_host_t *vha, sw_info_t *list)
                     GNN_ID_SNS_CMD_SIZE / 2, sizeof(struct sns_cmd_pkt));
                 if (rval != QLA_SUCCESS) {
                         /*EMPTY*/
-                        DEBUG2_3(printk("scsi(%ld): GNN_ID Send SNS failed "
-                            "(%d).\n", vha->host_no, rval));
+                        ql_dbg(ql_dbg_disc, vha, 0x203f,
+                            "GNN_ID Send SNS failed (%d).\n", rval);
                 } else if (sns_cmd->p.gnn_data[8] != 0x80 ||
                     sns_cmd->p.gnn_data[9] != 0x02) {
-                        DEBUG2_3(printk("scsi(%ld): GNN_ID failed, rejected "
-                            "request, gnn_rsp:\n", vha->host_no));
-                        DEBUG2_3(qla2x00_dump_buffer(sns_cmd->p.gnn_data, 16));
+                        ql_dbg(ql_dbg_disc + ql_dbg_buffer, vha, 0x2082,
+                            "GNN_ID failed, rejected request, gnn_rsp:\n");
+                        ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x207a,
+                            sns_cmd->p.gnn_data, 16);
                         rval = QLA_FUNCTION_FAILED;
                 } else {
                         /* Save nodename */
                         memcpy(list[i].node_name, &sns_cmd->p.gnn_data[16],
                             WWN_SIZE);
 
-                        DEBUG2_3(printk("scsi(%ld): GID_PT entry - "
-                            "nn %02x%02x%02x%02x%02x%02x%02x%02x "
+                        ql_dbg(ql_dbg_disc, vha, 0x206e,
+                            "GID_PT entry - nn %02x%02x%02x%02x%02x%02x%02x%02x "
                             "pn %02x%02x%02x%02x%02x%02x%02x%02x "
-                            "portid=%02x%02x%02x.\n",
-                            vha->host_no,
+                            "port_id=%02x%02x%02x.\n",
                             list[i].node_name[0], list[i].node_name[1],
                             list[i].node_name[2], list[i].node_name[3],
                             list[i].node_name[4], list[i].node_name[5],
@@ -982,7 +981,7 @@ qla2x00_sns_gnn_id(scsi_qla_host_t *vha, sw_info_t *list)
                             list[i].port_name[4], list[i].port_name[5],
                             list[i].port_name[6], list[i].port_name[7],
                             list[i].d_id.b.domain, list[i].d_id.b.area,
-                            list[i].d_id.b.al_pa));
+                            list[i].d_id.b.al_pa);
                 }
 
                 /* Last device exit. */
@@ -1025,17 +1024,18 @@ qla2x00_sns_rft_id(scsi_qla_host_t *vha)
             sizeof(struct sns_cmd_pkt));
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
-                DEBUG2_3(printk("scsi(%ld): RFT_ID Send SNS failed (%d).\n",
-                    vha->host_no, rval));
+                ql_dbg(ql_dbg_disc, vha, 0x2060,
+                    "RFT_ID Send SNS failed (%d).\n", rval);
         } else if (sns_cmd->p.rft_data[8] != 0x80 ||
             sns_cmd->p.rft_data[9] != 0x02) {
-                DEBUG2_3(printk("scsi(%ld): RFT_ID failed, rejected request, "
-                    "rft_rsp:\n", vha->host_no));
-                DEBUG2_3(qla2x00_dump_buffer(sns_cmd->p.rft_data, 16));
+                ql_dbg(ql_dbg_disc + ql_dbg_buffer, vha, 0x2083,
+                    "RFT_ID failed, rejected request rft_rsp:\n");
+                ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x2080,
+                    sns_cmd->p.rft_data, 16);
                 rval = QLA_FUNCTION_FAILED;
         } else {
-                DEBUG2(printk("scsi(%ld): RFT_ID exiting normally.\n",
-                    vha->host_no));
+                ql_dbg(ql_dbg_disc, vha, 0x2073,
+                    "RFT_ID exiting normally.\n");
         }
 
         return (rval);
@@ -1081,17 +1081,18 @@ qla2x00_sns_rnn_id(scsi_qla_host_t *vha)
             sizeof(struct sns_cmd_pkt));
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
-                DEBUG2_3(printk("scsi(%ld): RNN_ID Send SNS failed (%d).\n",
-                    vha->host_no, rval));
+                ql_dbg(ql_dbg_disc, vha, 0x204a,
+                    "RNN_ID Send SNS failed (%d).\n", rval);
         } else if (sns_cmd->p.rnn_data[8] != 0x80 ||
             sns_cmd->p.rnn_data[9] != 0x02) {
-                DEBUG2_3(printk("scsi(%ld): RNN_ID failed, rejected request, "
-                    "rnn_rsp:\n", vha->host_no));
-                DEBUG2_3(qla2x00_dump_buffer(sns_cmd->p.rnn_data, 16));
+                ql_dbg(ql_dbg_disc + ql_dbg_buffer, vha, 0x207b,
+                    "RNN_ID failed, rejected request, rnn_rsp:\n");
+                ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x207c,
+                    sns_cmd->p.rnn_data, 16);
                 rval = QLA_FUNCTION_FAILED;
         } else {
-                DEBUG2(printk("scsi(%ld): RNN_ID exiting normally.\n",
-                    vha->host_no));
+                ql_dbg(ql_dbg_disc, vha, 0x204c,
+                    "RNN_ID exiting normally.\n");
         }
 
         return (rval);
@@ -1116,10 +1117,10 @@ qla2x00_mgmt_svr_login(scsi_qla_host_t *vha)
         ha->isp_ops->fabric_login(vha, vha->mgmt_svr_loop_id, 0xff, 0xff, 0xfa,
             mb, BIT_1|BIT_0);
         if (mb[0] != MBS_COMMAND_COMPLETE) {
-                DEBUG2_13(printk("%s(%ld): Failed MANAGEMENT_SERVER login: "
-                    "loop_id=%x mb[0]=%x mb[1]=%x mb[2]=%x mb[6]=%x mb[7]=%x\n",
-                    __func__, vha->host_no, vha->mgmt_svr_loop_id, mb[0], mb[1],
-                    mb[2], mb[6], mb[7]));
+                ql_dbg(ql_dbg_disc, vha, 0x2024,
+                    "Failed management_server login: loopid=%x mb[0]=%x "
+                    "mb[1]=%x mb[2]=%x mb[6]=%x mb[7]=%x.\n",
+                    vha->mgmt_svr_loop_id, mb[0], mb[1], mb[2], mb[6], mb[7]);
                 ret = QLA_FUNCTION_FAILED;
         } else
                 vha->flags.management_server_logged_in = 1;
@@ -1292,11 +1293,12 @@ qla2x00_fdmi_rhba(scsi_qla_host_t *vha)
         memcpy(eiter->a.node_name, vha->node_name, WWN_SIZE);
         size += 4 + WWN_SIZE;
 
-        DEBUG13(printk("%s(%ld): NODENAME=%02x%02x%02x%02x%02x%02x%02x%02x.\n",
-            __func__, vha->host_no,
-            eiter->a.node_name[0], eiter->a.node_name[1], eiter->a.node_name[2],
-            eiter->a.node_name[3], eiter->a.node_name[4], eiter->a.node_name[5],
-            eiter->a.node_name[6], eiter->a.node_name[7]));
+        ql_dbg(ql_dbg_disc, vha, 0x2025,
+            "NodeName = %02x%02x%02x%02x%02x%02x%02x%02x.\n",
+            eiter->a.node_name[0], eiter->a.node_name[1],
+            eiter->a.node_name[2], eiter->a.node_name[3],
+            eiter->a.node_name[4], eiter->a.node_name[5],
+            eiter->a.node_name[6], eiter->a.node_name[7]);
 
         /* Manufacturer. */
         eiter = (struct ct_fdmi_hba_attr *) (entries + size);
@@ -1307,8 +1309,8 @@ qla2x00_fdmi_rhba(scsi_qla_host_t *vha)
         eiter->len = cpu_to_be16(4 + alen);
         size += 4 + alen;
 
-        DEBUG13(printk("%s(%ld): MANUFACTURER=%s.\n", __func__, vha->host_no,
-            eiter->a.manufacturer));
+        ql_dbg(ql_dbg_disc, vha, 0x2026,
+            "Manufacturer = %s.\n", eiter->a.manufacturer);
 
         /* Serial number. */
         eiter = (struct ct_fdmi_hba_attr *) (entries + size);
@@ -1320,8 +1322,8 @@ qla2x00_fdmi_rhba(scsi_qla_host_t *vha)
         eiter->len = cpu_to_be16(4 + alen);
         size += 4 + alen;
 
-        DEBUG13(printk("%s(%ld): SERIALNO=%s.\n", __func__, vha->host_no,
-            eiter->a.serial_num));
+        ql_dbg(ql_dbg_disc, vha, 0x2027,
+            "Serial no. = %s.\n", eiter->a.serial_num);
 
         /* Model name. */
         eiter = (struct ct_fdmi_hba_attr *) (entries + size);
@@ -1332,8 +1334,8 @@ qla2x00_fdmi_rhba(scsi_qla_host_t *vha)
         eiter->len = cpu_to_be16(4 + alen);
         size += 4 + alen;
 
-        DEBUG13(printk("%s(%ld): MODEL_NAME=%s.\n", __func__, vha->host_no,
-            eiter->a.model));
+        ql_dbg(ql_dbg_disc, vha, 0x2028,
+            "Model Name = %s.\n", eiter->a.model);
 
         /* Model description. */
         eiter = (struct ct_fdmi_hba_attr *) (entries + size);
@@ -1345,8 +1347,8 @@ qla2x00_fdmi_rhba(scsi_qla_host_t *vha)
         eiter->len = cpu_to_be16(4 + alen);
         size += 4 + alen;
 
-        DEBUG13(printk("%s(%ld): MODEL_DESC=%s.\n", __func__, vha->host_no,
-            eiter->a.model_desc));
+        ql_dbg(ql_dbg_disc, vha, 0x2029,
+            "Model Desc = %s.\n", eiter->a.model_desc);
 
         /* Hardware version. */
         eiter = (struct ct_fdmi_hba_attr *) (entries + size);
@@ -1357,8 +1359,8 @@ qla2x00_fdmi_rhba(scsi_qla_host_t *vha)
         eiter->len = cpu_to_be16(4 + alen);
         size += 4 + alen;
 
-        DEBUG13(printk("%s(%ld): HARDWAREVER=%s.\n", __func__, vha->host_no,
-            eiter->a.hw_version));
+        ql_dbg(ql_dbg_disc, vha, 0x202a,
+            "Hardware ver = %s.\n", eiter->a.hw_version);
 
         /* Driver version. */
         eiter = (struct ct_fdmi_hba_attr *) (entries + size);
@@ -1369,8 +1371,8 @@ qla2x00_fdmi_rhba(scsi_qla_host_t *vha)
         eiter->len = cpu_to_be16(4 + alen);
         size += 4 + alen;
 
-        DEBUG13(printk("%s(%ld): DRIVERVER=%s.\n", __func__, vha->host_no,
-            eiter->a.driver_version));
+        ql_dbg(ql_dbg_disc, vha, 0x202b,
+            "Driver ver = %s.\n", eiter->a.driver_version);
 
         /* Option ROM version. */
         eiter = (struct ct_fdmi_hba_attr *) (entries + size);
@@ -1381,8 +1383,8 @@ qla2x00_fdmi_rhba(scsi_qla_host_t *vha)
         eiter->len = cpu_to_be16(4 + alen);
         size += 4 + alen;
 
-        DEBUG13(printk("%s(%ld): OPTROMVER=%s.\n", __func__, vha->host_no,
-            eiter->a.orom_version));
+        ql_dbg(ql_dbg_disc, vha , 0x202c,
+            "Optrom vers = %s.\n", eiter->a.orom_version);
 
         /* Firmware version */
         eiter = (struct ct_fdmi_hba_attr *) (entries + size);
@@ -1393,44 +1395,46 @@ qla2x00_fdmi_rhba(scsi_qla_host_t *vha)
         eiter->len = cpu_to_be16(4 + alen);
         size += 4 + alen;
 
-        DEBUG13(printk("%s(%ld): FIRMWAREVER=%s.\n", __func__, vha->host_no,
-            eiter->a.fw_version));
+        ql_dbg(ql_dbg_disc, vha, 0x202d,
+            "Firmware vers = %s.\n", eiter->a.fw_version);
 
         /* Update MS request size. */
         qla2x00_update_ms_fdmi_iocb(vha, size + 16);
 
-        DEBUG13(printk("%s(%ld): RHBA identifier="
-            "%02x%02x%02x%02x%02x%02x%02x%02x size=%d.\n", __func__,
-            vha->host_no, ct_req->req.rhba.hba_identifier[0],
+        ql_dbg(ql_dbg_disc, vha, 0x202e,
+            "RHBA identifier = "
+            "%02x%02x%02x%02x%02x%02x%02x%02x size=%d.\n",
+            ct_req->req.rhba.hba_identifier[0],
             ct_req->req.rhba.hba_identifier[1],
             ct_req->req.rhba.hba_identifier[2],
             ct_req->req.rhba.hba_identifier[3],
             ct_req->req.rhba.hba_identifier[4],
             ct_req->req.rhba.hba_identifier[5],
             ct_req->req.rhba.hba_identifier[6],
-            ct_req->req.rhba.hba_identifier[7], size));
-        DEBUG13(qla2x00_dump_buffer(entries, size));
+            ct_req->req.rhba.hba_identifier[7], size);
+        ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x2076,
+            entries, size);
 
         /* Execute MS IOCB */
         rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
             sizeof(ms_iocb_entry_t));
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
-                DEBUG2_3(printk("scsi(%ld): RHBA issue IOCB failed (%d).\n",
-                    vha->host_no, rval));
+                ql_dbg(ql_dbg_disc, vha, 0x2030,
+                    "RHBA issue IOCB failed (%d).\n", rval);
         } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "RHBA") !=
             QLA_SUCCESS) {
                 rval = QLA_FUNCTION_FAILED;
                 if (ct_rsp->header.reason_code == CT_REASON_CANNOT_PERFORM &&
                     ct_rsp->header.explanation_code ==
                     CT_EXPL_ALREADY_REGISTERED) {
-                        DEBUG2_13(printk("%s(%ld): HBA already registered.\n",
-                            __func__, vha->host_no));
+                        ql_dbg(ql_dbg_disc, vha, 0x2034,
+                            "HBA already registered.\n");
                         rval = QLA_ALREADY_REGISTERED;
                 }
         } else {
-                DEBUG2(printk("scsi(%ld): RHBA exiting normally.\n",
-                    vha->host_no));
+                ql_dbg(ql_dbg_disc, vha, 0x2035,
+                    "RHBA exiting normally.\n");
         }
 
         return rval;
@@ -1464,26 +1468,26 @@ qla2x00_fdmi_dhba(scsi_qla_host_t *vha)
         /* Prepare FDMI command arguments -- portname. */
         memcpy(ct_req->req.dhba.port_name, vha->port_name, WWN_SIZE);
 
-        DEBUG13(printk("%s(%ld): DHBA portname="
-            "%02x%02x%02x%02x%02x%02x%02x%02x.\n", __func__, vha->host_no,
+        ql_dbg(ql_dbg_disc, vha, 0x2036,
+            "DHBA portname = %02x%02x%02x%02x%02x%02x%02x%02x.\n",
             ct_req->req.dhba.port_name[0], ct_req->req.dhba.port_name[1],
             ct_req->req.dhba.port_name[2], ct_req->req.dhba.port_name[3],
             ct_req->req.dhba.port_name[4], ct_req->req.dhba.port_name[5],
-            ct_req->req.dhba.port_name[6], ct_req->req.dhba.port_name[7]));
+            ct_req->req.dhba.port_name[6], ct_req->req.dhba.port_name[7]);
 
         /* Execute MS IOCB */
         rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
             sizeof(ms_iocb_entry_t));
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
-                DEBUG2_3(printk("scsi(%ld): DHBA issue IOCB failed (%d).\n",
-                    vha->host_no, rval));
+                ql_dbg(ql_dbg_disc, vha, 0x2037,
+                    "DHBA issue IOCB failed (%d).\n", rval);
         } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "DHBA") !=
             QLA_SUCCESS) {
                 rval = QLA_FUNCTION_FAILED;
         } else {
-                DEBUG2(printk("scsi(%ld): DHBA exiting normally.\n",
-                    vha->host_no));
+                ql_dbg(ql_dbg_disc, vha, 0x2038,
+                    "DHBA exiting normally.\n");
         }
 
         return rval;
@@ -1534,9 +1538,10 @@ qla2x00_fdmi_rpa(scsi_qla_host_t *vha)
         eiter->a.fc4_types[2] = 0x01;
         size += 4 + 32;
 
-        DEBUG13(printk("%s(%ld): FC4_TYPES=%02x %02x.\n", __func__,
-                vha->host_no, eiter->a.fc4_types[2],
-                eiter->a.fc4_types[1]));
+        ql_dbg(ql_dbg_disc, vha, 0x2039,
+            "FC4_TYPES=%02x %02x.\n",
+            eiter->a.fc4_types[2],
+            eiter->a.fc4_types[1]);
 
         /* Supported speed. */
         eiter = (struct ct_fdmi_port_attr *) (entries + size);
@@ -1561,8 +1566,8 @@ qla2x00_fdmi_rpa(scsi_qla_host_t *vha)
                     FDMI_PORT_SPEED_1GB);
         size += 4 + 4;
 
-        DEBUG13(printk("%s(%ld): SUPPORTED_SPEED=%x.\n", __func__, vha->host_no,
-            eiter->a.sup_speed));
+        ql_dbg(ql_dbg_disc, vha, 0x203a,
+            "Supported_Speed=%x.\n", eiter->a.sup_speed);
 
         /* Current speed. */
         eiter = (struct ct_fdmi_port_attr *) (entries + size);
@@ -1596,8 +1601,8 @@ qla2x00_fdmi_rpa(scsi_qla_host_t *vha)
         }
         size += 4 + 4;
 
-        DEBUG13(printk("%s(%ld): CURRENT_SPEED=%x.\n", __func__, vha->host_no,
-            eiter->a.cur_speed));
+        ql_dbg(ql_dbg_disc, vha, 0x203b,
+            "Current_Speed=%x.\n", eiter->a.cur_speed);
 
         /* Max frame size. */
         eiter = (struct ct_fdmi_port_attr *) (entries + size);
@@ -1609,8 +1614,8 @@ qla2x00_fdmi_rpa(scsi_qla_host_t *vha)
         eiter->a.max_frame_size = cpu_to_be32(max_frame_size);
         size += 4 + 4;
 
-        DEBUG13(printk("%s(%ld): MAX_FRAME_SIZE=%x.\n", __func__, vha->host_no,
-            eiter->a.max_frame_size));
+        ql_dbg(ql_dbg_disc, vha, 0x203c,
+            "Max_Frame_Size=%x.\n", eiter->a.max_frame_size);
 
         /* OS device name. */
         eiter = (struct ct_fdmi_port_attr *) (entries + size);
@@ -1621,8 +1626,8 @@ qla2x00_fdmi_rpa(scsi_qla_host_t *vha)
         eiter->len = cpu_to_be16(4 + alen);
         size += 4 + alen;
 
-        DEBUG13(printk("%s(%ld): OS_DEVICE_NAME=%s.\n", __func__, vha->host_no,
-            eiter->a.os_dev_name));
+        ql_dbg(ql_dbg_disc, vha, 0x204b,
+            "OS_Device_Name=%s.\n", eiter->a.os_dev_name);
 
         /* Hostname. */
         if (strlen(fc_host_system_hostname(vha->host))) {
@@ -1637,35 +1642,36 @@ qla2x00_fdmi_rpa(scsi_qla_host_t *vha)
                 eiter->len = cpu_to_be16(4 + alen);
                 size += 4 + alen;
 
-                DEBUG13(printk("%s(%ld): HOSTNAME=%s.\n", __func__,
-                    vha->host_no, eiter->a.host_name));
+                ql_dbg(ql_dbg_disc, vha, 0x203d,
+                    "HostName=%s.\n", eiter->a.host_name);
         }
 
         /* Update MS request size. */
         qla2x00_update_ms_fdmi_iocb(vha, size + 16);
 
-        DEBUG13(printk("%s(%ld): RPA portname="
-            "%02x%02x%02x%02x%02x%02x%02x%02x size=%d.\n", __func__,
-            vha->host_no, ct_req->req.rpa.port_name[0],
-            ct_req->req.rpa.port_name[1], ct_req->req.rpa.port_name[2],
-            ct_req->req.rpa.port_name[3], ct_req->req.rpa.port_name[4],
-            ct_req->req.rpa.port_name[5], ct_req->req.rpa.port_name[6],
-            ct_req->req.rpa.port_name[7], size));
-        DEBUG13(qla2x00_dump_buffer(entries, size));
+        ql_dbg(ql_dbg_disc, vha, 0x203e,
+            "RPA portname= %02x%02x%02x%02x%02X%02x%02x%02x size=%d.\n",
+            ct_req->req.rpa.port_name[0], ct_req->req.rpa.port_name[1],
+            ct_req->req.rpa.port_name[2], ct_req->req.rpa.port_name[3],
+            ct_req->req.rpa.port_name[4], ct_req->req.rpa.port_name[5],
+            ct_req->req.rpa.port_name[6], ct_req->req.rpa.port_name[7],
+            size);
+        ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x2079,
+            entries, size);
 
         /* Execute MS IOCB */
         rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
             sizeof(ms_iocb_entry_t));
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
-                DEBUG2_3(printk("scsi(%ld): RPA issue IOCB failed (%d).\n",
-                    vha->host_no, rval));
+                ql_dbg(ql_dbg_disc, vha, 0x2040,
+                    "RPA issue IOCB failed (%d).\n", rval);
         } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "RPA") !=
             QLA_SUCCESS) {
                 rval = QLA_FUNCTION_FAILED;
         } else {
-                DEBUG2(printk("scsi(%ld): RPA exiting normally.\n",
-                    vha->host_no));
+                ql_dbg(ql_dbg_disc, vha, 0x2041,
+                    "RPA exiting nornally.\n");
         }
 
         return rval;
@@ -1749,8 +1755,8 @@ qla2x00_gfpn_id(scsi_qla_host_t *vha, sw_info_t *list)
                     sizeof(ms_iocb_entry_t));
                 if (rval != QLA_SUCCESS) {
                         /*EMPTY*/
-                        DEBUG2_3(printk("scsi(%ld): GFPN_ID issue IOCB "
-                            "failed (%d).\n", vha->host_no, rval));
+                        ql_dbg(ql_dbg_disc, vha, 0x2023,
+                            "GFPN_ID issue IOCB failed (%d).\n", rval);
                 } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp,
                     "GFPN_ID") != QLA_SUCCESS) {
                         rval = QLA_FUNCTION_FAILED;
@@ -1860,8 +1866,8 @@ qla2x00_gpsc(scsi_qla_host_t *vha, sw_info_t *list)
                     sizeof(ms_iocb_entry_t));
                 if (rval != QLA_SUCCESS) {
                         /*EMPTY*/
-                        DEBUG2_3(printk("scsi(%ld): GPSC issue IOCB "
-                            "failed (%d).\n", vha->host_no, rval));
+                        ql_dbg(ql_dbg_disc, vha, 0x2059,
+                            "GPSC issue IOCB failed (%d).\n", rval);
                 } else if ((rval = qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp,
                     "GPSC")) != QLA_SUCCESS) {
                         /* FM command unsupported? */
@@ -1870,9 +1876,9 @@ qla2x00_gpsc(scsi_qla_host_t *vha, sw_info_t *list)
                                 CT_REASON_INVALID_COMMAND_CODE ||
                              ct_rsp->header.reason_code ==
                                 CT_REASON_COMMAND_UNSUPPORTED)) {
-                                DEBUG2(printk("scsi(%ld): GPSC command "
-                                    "unsupported, disabling query...\n",
-                                    vha->host_no));
+                                ql_dbg(ql_dbg_disc, vha, 0x205a,
+                                    "GPSC command unsupported, disabling "
+                                    "query.\n");
                                 ha->flags.gpsc_supported = 0;
                                 rval = QLA_FUNCTION_FAILED;
                                 break;
@@ -1898,9 +1904,10 @@ qla2x00_gpsc(scsi_qla_host_t *vha, sw_info_t *list)
                                 break;
                         }
 
-                        DEBUG2_3(printk("scsi(%ld): GPSC ext entry - "
-                            "fpn %02x%02x%02x%02x%02x%02x%02x%02x speeds=%04x "
-                            "speed=%04x.\n", vha->host_no,
+                        ql_dbg(ql_dbg_disc, vha, 0x205b,
+                            "GPSC ext entry - fpn "
+                            "%02x%02x%02x%02x%02x%02x%02x%02x speeds=%04x "
+                            "speed=%04x.\n",
                             list[i].fabric_port_name[0],
                             list[i].fabric_port_name[1],
                             list[i].fabric_port_name[2],
@@ -1910,7 +1917,7 @@ qla2x00_gpsc(scsi_qla_host_t *vha, sw_info_t *list)
                             list[i].fabric_port_name[6],
                             list[i].fabric_port_name[7],
                             be16_to_cpu(ct_rsp->rsp.gpsc.speeds),
-                            be16_to_cpu(ct_rsp->rsp.gpsc.speed)));
+                            be16_to_cpu(ct_rsp->rsp.gpsc.speed));
                 }
 
                 /* Last device exit. */
@@ -1968,14 +1975,12 @@ qla2x00_gff_id(scsi_qla_host_t *vha, sw_info_t *list)
                    sizeof(ms_iocb_entry_t));
 
                 if (rval != QLA_SUCCESS) {
-                        DEBUG2_3(printk(KERN_INFO
-                            "scsi(%ld): GFF_ID issue IOCB failed "
-                            "(%d).\n", vha->host_no, rval));
+                        ql_dbg(ql_dbg_disc, vha, 0x205c,
+                            "GFF_ID issue IOCB failed (%d).\n", rval);
                 } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp,
                                "GFF_ID") != QLA_SUCCESS) {
-                        DEBUG2_3(printk(KERN_INFO
-                            "scsi(%ld): GFF_ID IOCB status had a "
-                            "failure status code\n", vha->host_no));
+                        ql_dbg(ql_dbg_disc, vha, 0x205d,
+                            "GFF_ID IOCB status had a failure status code.\n");
                 } else {
                         fcp_scsi_features =
                            ct_rsp->rsp.gff_id.fc4_features[GFF_FCP_SCSI_OFFSET];
diff --git a/drivers/scsi/qla2xxx/qla_init.c b/drivers/scsi/qla2xxx/qla_init.c
index 920b76bfbb93..def694271bf7 100644
--- a/drivers/scsi/qla2xxx/qla_init.c
+++ b/drivers/scsi/qla2xxx/qla_init.c
@@ -153,11 +153,10 @@ qla2x00_async_iocb_timeout(srb_t *sp)
         fc_port_t *fcport = sp->fcport;
         struct srb_ctx *ctx = sp->ctx;
 
-        DEBUG2(printk(KERN_WARNING
-                "scsi(%ld:%x): Async-%s timeout - portid=%02x%02x%02x.\n",
-                fcport->vha->host_no, sp->handle,
-                ctx->name, fcport->d_id.b.domain,
-                fcport->d_id.b.area, fcport->d_id.b.al_pa));
+        ql_dbg(ql_dbg_disc, fcport->vha, 0x2071,
+            "Async-%s timeout - portid=%02x%02x%02x.\n",
+            ctx->name, fcport->d_id.b.domain, fcport->d_id.b.area,
+            fcport->d_id.b.al_pa);
 
         fcport->flags &= ~FCF_ASYNC_SENT;
         if (ctx->type == SRB_LOGIN_CMD) {
@@ -211,11 +210,10 @@ qla2x00_async_login(struct scsi_qla_host *vha, fc_port_t *fcport,
         if (rval != QLA_SUCCESS)
                 goto done_free_sp;
 
-        DEBUG2(printk(KERN_DEBUG
-            "scsi(%ld:%x): Async-login - loop-id=%x portid=%02x%02x%02x "
-            "retries=%d.\n", fcport->vha->host_no, sp->handle, fcport->loop_id,
-            fcport->d_id.b.domain, fcport->d_id.b.area, fcport->d_id.b.al_pa,
-            fcport->login_retry));
+        ql_dbg(ql_dbg_disc, vha, 0x2072,
+            "Async-login - loopid=%x portid=%02x%02x%02x retries=%d.\n",
+            fcport->loop_id, fcport->d_id.b.domain, fcport->d_id.b.area,
+            fcport->d_id.b.al_pa, fcport->login_retry);
         return rval;
 
 done_free_sp:
@@ -259,10 +257,10 @@ qla2x00_async_logout(struct scsi_qla_host *vha, fc_port_t *fcport)
         if (rval != QLA_SUCCESS)
                 goto done_free_sp;
 
-        DEBUG2(printk(KERN_DEBUG
-            "scsi(%ld:%x): Async-logout - loop-id=%x portid=%02x%02x%02x.\n",
-            fcport->vha->host_no, sp->handle, fcport->loop_id,
-            fcport->d_id.b.domain, fcport->d_id.b.area, fcport->d_id.b.al_pa));
+        ql_dbg(ql_dbg_disc, vha, 0x2070,
+            "Async-logout - loop-id=%x portid=%02x%02x%02x.\n",
+            fcport->loop_id, fcport->d_id.b.domain, fcport->d_id.b.area,
+            fcport->d_id.b.al_pa);
         return rval;
 
 done_free_sp:
@@ -309,11 +307,10 @@ qla2x00_async_adisc(struct scsi_qla_host *vha, fc_port_t *fcport,
         if (rval != QLA_SUCCESS)
                 goto done_free_sp;
 
-        DEBUG2(printk(KERN_DEBUG
-            "scsi(%ld:%x): Async-adisc - loop-id=%x portid=%02x%02x%02x.\n",
-            fcport->vha->host_no, sp->handle, fcport->loop_id,
-            fcport->d_id.b.domain, fcport->d_id.b.area, fcport->d_id.b.al_pa));
-
+        ql_dbg(ql_dbg_disc, vha, 0x206f,
+            "Async-adisc - loopid=%x portid=%02x%02x%02x.\n",
+            fcport->loop_id, fcport->d_id.b.domain, fcport->d_id.b.area,
+            fcport->d_id.b.al_pa);
         return rval;
 
 done_free_sp:
@@ -362,11 +359,10 @@ qla2x00_async_tm_cmd(fc_port_t *fcport, uint32_t flags, uint32_t lun,
         if (rval != QLA_SUCCESS)
                 goto done_free_sp;
 
-        DEBUG2(printk(KERN_DEBUG
-            "scsi(%ld:%x): Async-tmf - loop-id=%x portid=%02x%02x%02x.\n",
-            fcport->vha->host_no, sp->handle, fcport->loop_id,
-            fcport->d_id.b.domain, fcport->d_id.b.area, fcport->d_id.b.al_pa));
-
+        ql_dbg(ql_dbg_taskm, vha, 0x802f,
+            "Async-tmf loop-id=%x portid=%02x%02x%02x.\n",
+            fcport->loop_id, fcport->d_id.b.domain, fcport->d_id.b.area,
+            fcport->d_id.b.al_pa);
         return rval;
 
 done_free_sp:
@@ -471,9 +467,8 @@ qla2x00_async_tm_cmd_done(struct scsi_qla_host *vha, fc_port_t *fcport,
                 flags == TCF_LUN_RESET ? MK_SYNC_ID_LUN : MK_SYNC_ID);
 
         if ((rval != QLA_SUCCESS) || iocb->u.tmf.data) {
-                DEBUG2_3_11(printk(KERN_WARNING
-                        "%s(%ld): TM IOCB failed (%x).\n",
-                        __func__, vha->host_no, rval));
+                ql_dbg(ql_dbg_taskm, vha, 0x8030,
+                    "TM IOCB failed (%x).\n", rval);
         }
 
         return;
@@ -519,11 +514,12 @@ qla2x00_initialize_adapter(scsi_qla_host_t *vha)
         set_bit(0, ha->req_qid_map);
         set_bit(0, ha->rsp_qid_map);
 
-        qla_printk(KERN_INFO, ha, "Configuring PCI space...\n");
+        ql_log(ql_log_info, vha, 0x0040,
+            "Configuring PCI space...\n");
         rval = ha->isp_ops->pci_config(vha);
         if (rval) {
-                DEBUG2(printk("scsi(%ld): Unable to configure PCI space.\n",
-                    vha->host_no));
+                ql_log(ql_log_warn, vha, 0x0044,
+                    "Unable to configure PCI space.\n");
                 return (rval);
         }
 
@@ -531,20 +527,21 @@ qla2x00_initialize_adapter(scsi_qla_host_t *vha)
 
         rval = qla2xxx_get_flash_info(vha);
         if (rval) {
-                DEBUG2(printk("scsi(%ld): Unable to validate FLASH data.\n",
-                    vha->host_no));
+                ql_log(ql_log_fatal, vha, 0x004f,
+                    "Unable to validate FLASH data.\n");
                 return (rval);
         }
 
         ha->isp_ops->get_flash_version(vha, req->ring);
-
-        qla_printk(KERN_INFO, ha, "Configure NVRAM parameters...\n");
+        ql_log(ql_log_info, vha, 0x0061,
+            "Configure NVRAM parameters...\n");
 
         ha->isp_ops->nvram_config(vha);
 
         if (ha->flags.disable_serdes) {
                 /* Mask HBA via NVRAM settings? */
-                qla_printk(KERN_INFO, ha, "Masking HBA WWPN "
+                ql_log(ql_log_info, vha, 0x0077,
+                    "Masking HBA WWPN "
                     "%02x%02x%02x%02x%02x%02x%02x%02x (via NVRAM).\n",
                     vha->port_name[0], vha->port_name[1],
                     vha->port_name[2], vha->port_name[3],
@@ -553,7 +550,8 @@ qla2x00_initialize_adapter(scsi_qla_host_t *vha)
                 return QLA_FUNCTION_FAILED;
         }
 
-        qla_printk(KERN_INFO, ha, "Verifying loaded RISC code...\n");
+        ql_log(ql_log_info, vha, 0x0078,
+            "Verifying loaded RISC code...\n");
 
         if (qla2x00_isp_firmware(vha) != QLA_SUCCESS) {
                 rval = ha->isp_ops->chip_diag(vha);
@@ -567,7 +565,7 @@ qla2x00_initialize_adapter(scsi_qla_host_t *vha)
         if (IS_QLA84XX(ha)) {
                 ha->cs84xx = qla84xx_get_chip(vha);
                 if (!ha->cs84xx) {
-                        qla_printk(KERN_ERR, ha,
+                        ql_log(ql_log_warn, vha, 0x00d0,
                             "Unable to configure ISP84XX.\n");
                         return QLA_FUNCTION_FAILED;
                 }
@@ -579,8 +577,8 @@ qla2x00_initialize_adapter(scsi_qla_host_t *vha)
                 /* Issue verify 84xx FW IOCB to complete 84xx initialization */
                 rval = qla84xx_init_chip(vha);
                 if (rval != QLA_SUCCESS) {
-                        qla_printk(KERN_ERR, ha,
-                                "Unable to initialize ISP84XX.\n");
+                        ql_log(ql_log_warn, vha, 0x00d4,
+                            "Unable to initialize ISP84XX.\n");
                 qla84xx_put_chip(vha);
                 }
         }
@@ -797,9 +795,7 @@ qla2x00_isp_firmware(scsi_qla_host_t *vha)
         rval = QLA_FUNCTION_FAILED;
 
         if (ha->flags.disable_risc_code_load) {
-                DEBUG2(printk("scsi(%ld): RISC CODE NOT loaded\n",
-                    vha->host_no));
-                qla_printk(KERN_INFO, ha, "RISC CODE NOT loaded\n");
+                ql_log(ql_log_info, vha, 0x0079, "RISC CODE NOT loaded.\n");
 
                 /* Verify checksum of loaded RISC code. */
                 rval = qla2x00_verify_checksum(vha, ha->fw_srisc_address);
@@ -810,10 +806,9 @@ qla2x00_isp_firmware(scsi_qla_host_t *vha)
                 }
         }
 
-        if (rval) {
-                DEBUG2_3(printk("scsi(%ld): **** Load RISC code ****\n",
-                    vha->host_no));
-        }
+        if (rval)
+                ql_dbg(ql_dbg_init, vha, 0x007a,
+                    "**** Load RISC code ****.\n");
 
         return (rval);
 }
@@ -1105,8 +1100,8 @@ qla2x00_chip_diag(scsi_qla_host_t *vha)
         /* Assume a failed state */
         rval = QLA_FUNCTION_FAILED;
 
-        DEBUG3(printk("scsi(%ld): Testing device at %lx.\n",
-            vha->host_no, (u_long)&reg->flash_address));
+        ql_dbg(ql_dbg_init, vha, 0x007b,
+            "Testing device at %lx.\n", (u_long)&reg->flash_address);
 
         spin_lock_irqsave(&ha->hardware_lock, flags);
 
@@ -1128,8 +1123,8 @@ qla2x00_chip_diag(scsi_qla_host_t *vha)
         if (!cnt)
                 goto chip_diag_failed;
 
-        DEBUG3(printk("scsi(%ld): Reset register cleared by chip reset\n",
-            vha->host_no));
+        ql_dbg(ql_dbg_init, vha, 0x007c,
+            "Reset register cleared by chip reset.\n");
 
         /* Reset RISC processor. */
         WRT_REG_WORD(&reg->hccr, HCCR_RESET_RISC);
@@ -1150,7 +1145,7 @@ qla2x00_chip_diag(scsi_qla_host_t *vha)
                 goto chip_diag_failed;
 
         /* Check product ID of chip */
-        DEBUG3(printk("scsi(%ld): Checking product ID of chip\n", vha->host_no));
+        ql_dbg(ql_dbg_init, vha, 0x007d, "Checking product Id of chip.\n");
 
         mb[1] = RD_MAILBOX_REG(ha, reg, 1);
         mb[2] = RD_MAILBOX_REG(ha, reg, 2);
@@ -1158,8 +1153,9 @@ qla2x00_chip_diag(scsi_qla_host_t *vha)
         mb[4] = qla2x00_debounce_register(MAILBOX_REG(ha, reg, 4));
         if (mb[1] != PROD_ID_1 || (mb[2] != PROD_ID_2 && mb[2] != PROD_ID_2a) ||
             mb[3] != PROD_ID_3) {
-                qla_printk(KERN_WARNING, ha,
-                    "Wrong product ID = 0x%x,0x%x,0x%x\n", mb[1], mb[2], mb[3]);
+                ql_log(ql_log_warn, vha, 0x0062,
+                    "Wrong product ID = 0x%x,0x%x,0x%x.\n",
+                    mb[1], mb[2], mb[3]);
 
                 goto chip_diag_failed;
         }
@@ -1178,8 +1174,7 @@ qla2x00_chip_diag(scsi_qla_host_t *vha)
         if (IS_QLA2200(ha) &&
             RD_MAILBOX_REG(ha, reg, 7) == QLA2200A_RISC_ROM_VER) {
                 /* Limit firmware transfer size with a 2200A */
-                DEBUG3(printk("scsi(%ld): Found QLA2200A chip.\n",
-                    vha->host_no));
+                ql_dbg(ql_dbg_init, vha, 0x007e, "Found QLA2200A Chip.\n");
 
                 ha->device_type |= DT_ISP2200A;
                 ha->fw_transfer_size = 128;
@@ -1188,24 +1183,20 @@ qla2x00_chip_diag(scsi_qla_host_t *vha)
         /* Wrap Incoming Mailboxes Test. */
         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 
-        DEBUG3(printk("scsi(%ld): Checking mailboxes.\n", vha->host_no));
+        ql_dbg(ql_dbg_init, vha, 0x007f, "Checking mailboxes.\n");
         rval = qla2x00_mbx_reg_test(vha);
-        if (rval) {
-                DEBUG(printk("scsi(%ld): Failed mailbox send register test\n",
-                    vha->host_no));
-                qla_printk(KERN_WARNING, ha,
-                    "Failed mailbox send register test\n");
-        }
-        else {
+        if (rval)
+                ql_log(ql_log_warn, vha, 0x0080,
+                    "Failed mailbox send register test.\n");
+        else
                 /* Flag a successful rval */
                 rval = QLA_SUCCESS;
-        }
         spin_lock_irqsave(&ha->hardware_lock, flags);
 
 chip_diag_failed:
         if (rval)
-                DEBUG2_3(printk("scsi(%ld): Chip diagnostics **** FAILED "
-                    "****\n", vha->host_no));
+                ql_log(ql_log_info, vha, 0x0081,
+                    "Chip diagnostics **** FAILED ****.\n");
 
         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 
@@ -1232,10 +1223,8 @@ qla24xx_chip_diag(scsi_qla_host_t *vha)
 
         rval = qla2x00_mbx_reg_test(vha);
         if (rval) {
-                DEBUG(printk("scsi(%ld): Failed mailbox send register test\n",
-                    vha->host_no));
-                qla_printk(KERN_WARNING, ha,
-                    "Failed mailbox send register test\n");
+                ql_log(ql_log_warn, vha, 0x0082,
+                    "Failed mailbox send register test.\n");
         } else {
                 /* Flag a successful rval */
                 rval = QLA_SUCCESS;
@@ -1257,8 +1246,8 @@ qla2x00_alloc_fw_dump(scsi_qla_host_t *vha)
         struct rsp_que *rsp = ha->rsp_q_map[0];
 
         if (ha->fw_dump) {
-                qla_printk(KERN_WARNING, ha,
-                    "Firmware dump previously allocated.\n");
+                ql_dbg(ql_dbg_init, vha, 0x00bd,
+                    "Firmware dump already allocated.\n");
                 return;
         }
 
@@ -1288,8 +1277,9 @@ qla2x00_alloc_fw_dump(scsi_qla_host_t *vha)
                 tc = dma_alloc_coherent(&ha->pdev->dev, FCE_SIZE, &tc_dma,
                     GFP_KERNEL);
                 if (!tc) {
-                        qla_printk(KERN_WARNING, ha, "Unable to allocate "
-                            "(%d KB) for FCE.\n", FCE_SIZE / 1024);
+                        ql_log(ql_log_warn, vha, 0x00be,
+                            "Unable to allocate (%d KB) for FCE.\n",
+                            FCE_SIZE / 1024);
                         goto try_eft;
                 }
 
@@ -1297,16 +1287,15 @@ qla2x00_alloc_fw_dump(scsi_qla_host_t *vha)
                 rval = qla2x00_enable_fce_trace(vha, tc_dma, FCE_NUM_BUFFERS,
                     ha->fce_mb, &ha->fce_bufs);
                 if (rval) {
-                        qla_printk(KERN_WARNING, ha, "Unable to initialize "
-                            "FCE (%d).\n", rval);
+                        ql_log(ql_log_warn, vha, 0x00bf,
+                            "Unable to initialize FCE (%d).\n", rval);
                         dma_free_coherent(&ha->pdev->dev, FCE_SIZE, tc,
                             tc_dma);
                         ha->flags.fce_enabled = 0;
                         goto try_eft;
                 }
-
-                qla_printk(KERN_INFO, ha, "Allocated (%d KB) for FCE...\n",
-                    FCE_SIZE / 1024);
+                ql_log(ql_log_info, vha, 0x00c0,
+                    "Allocate (%d KB) for FCE...\n", FCE_SIZE / 1024);
 
                 fce_size = sizeof(struct qla2xxx_fce_chain) + FCE_SIZE;
                 ha->flags.fce_enabled = 1;
@@ -1317,23 +1306,23 @@ try_eft:
                 tc = dma_alloc_coherent(&ha->pdev->dev, EFT_SIZE, &tc_dma,
                     GFP_KERNEL);
                 if (!tc) {
-                        qla_printk(KERN_WARNING, ha, "Unable to allocate "
-                            "(%d KB) for EFT.\n", EFT_SIZE / 1024);
+                        ql_log(ql_log_warn, vha, 0x00c1,
+                            "Unable to allocate (%d KB) for EFT.\n",
+                            EFT_SIZE / 1024);
                         goto cont_alloc;
                 }
 
                 memset(tc, 0, EFT_SIZE);
                 rval = qla2x00_enable_eft_trace(vha, tc_dma, EFT_NUM_BUFFERS);
                 if (rval) {
-                        qla_printk(KERN_WARNING, ha, "Unable to initialize "
-                            "EFT (%d).\n", rval);
+                        ql_log(ql_log_warn, vha, 0x00c2,
+                            "Unable to initialize EFT (%d).\n", rval);
                         dma_free_coherent(&ha->pdev->dev, EFT_SIZE, tc,
                             tc_dma);
                         goto cont_alloc;
                 }
-
-                qla_printk(KERN_INFO, ha, "Allocated (%d KB) for EFT...\n",
-                    EFT_SIZE / 1024);
+                ql_log(ql_log_info, vha, 0x00c3,
+                    "Allocated (%d KB) EFT ...\n", EFT_SIZE / 1024);
 
                 eft_size = EFT_SIZE;
                 ha->eft_dma = tc_dma;
@@ -1350,8 +1339,9 @@ cont_alloc:
 
         ha->fw_dump = vmalloc(dump_size);
         if (!ha->fw_dump) {
-                qla_printk(KERN_WARNING, ha, "Unable to allocate (%d KB) for "
-                    "firmware dump!!!\n", dump_size / 1024);
+                ql_log(ql_log_warn, vha, 0x00c4,
+                    "Unable to allocate (%d KB) for firmware dump.\n",
+                    dump_size / 1024);
 
                 if (ha->fce) {
                         dma_free_coherent(&ha->pdev->dev, FCE_SIZE, ha->fce,
@@ -1368,8 +1358,8 @@ cont_alloc:
                 }
                 return;
         }
-        qla_printk(KERN_INFO, ha, "Allocated (%d KB) for firmware dump...\n",
-            dump_size / 1024);
+        ql_log(ql_log_info, vha, 0x00c5,
+            "Allocated (%d KB) for firmware dump.\n", dump_size / 1024);
 
         ha->fw_dump_len = dump_size;
         ha->fw_dump->signature[0] = 'Q';
@@ -1398,23 +1388,21 @@ qla81xx_mpi_sync(scsi_qla_host_t *vha)
         int rval;
         uint16_t dc;
         uint32_t dw;
-        struct qla_hw_data *ha = vha->hw;
 
         if (!IS_QLA81XX(vha->hw))
                 return QLA_SUCCESS;
 
         rval = qla2x00_write_ram_word(vha, 0x7c00, 1);
         if (rval != QLA_SUCCESS) {
-                DEBUG2(qla_printk(KERN_WARNING, ha,
-                    "Sync-MPI: Unable to acquire semaphore.\n"));
+                ql_log(ql_log_warn, vha, 0x0105,
+                    "Unable to acquire semaphore.\n");
                 goto done;
         }
 
         pci_read_config_word(vha->hw->pdev, 0x54, &dc);
         rval = qla2x00_read_ram_word(vha, 0x7a15, &dw);
         if (rval != QLA_SUCCESS) {
-                DEBUG2(qla_printk(KERN_WARNING, ha,
-                    "Sync-MPI: Unable to read sync.\n"));
+                ql_log(ql_log_warn, vha, 0x0067, "Unable to read sync.\n");
                 goto done_release;
         }
 
@@ -1426,15 +1414,14 @@ qla81xx_mpi_sync(scsi_qla_host_t *vha)
         dw |= dc;
         rval = qla2x00_write_ram_word(vha, 0x7a15, dw);
         if (rval != QLA_SUCCESS) {
-                DEBUG2(qla_printk(KERN_WARNING, ha,
-                    "Sync-MPI: Unable to gain sync.\n"));
+                ql_log(ql_log_warn, vha, 0x0114, "Unable to gain sync.\n");
         }
 
 done_release:
         rval = qla2x00_write_ram_word(vha, 0x7c00, 0);
         if (rval != QLA_SUCCESS) {
-                DEBUG2(qla_printk(KERN_WARNING, ha,
-                    "Sync-MPI: Unable to release semaphore.\n"));
+                ql_log(ql_log_warn, vha, 0x006d,
+                    "Unable to release semaphore.\n");
         }
 
 done:
@@ -1479,14 +1466,14 @@ qla2x00_setup_chip(scsi_qla_host_t *vha)
         /* Load firmware sequences */
         rval = ha->isp_ops->load_risc(vha, &srisc_address);
         if (rval == QLA_SUCCESS) {
-                DEBUG(printk("scsi(%ld): Verifying Checksum of loaded RISC "
-                    "code.\n", vha->host_no));
+                ql_dbg(ql_dbg_init, vha, 0x00c9,
+                    "Verifying Checksum of loaded RISC code.\n");
 
                 rval = qla2x00_verify_checksum(vha, srisc_address);
                 if (rval == QLA_SUCCESS) {
                         /* Start firmware execution. */
-                        DEBUG(printk("scsi(%ld): Checksum OK, start "
-                            "firmware.\n", vha->host_no));
+                        ql_dbg(ql_dbg_init, vha, 0x00ca,
+                            "Starting firmware.\n");
 
                         rval = qla2x00_execute_fw(vha, srisc_address);
                         /* Retrieve firmware information. */
@@ -1522,9 +1509,9 @@ enable_82xx_npiv:
                                 }
                         }
                 } else {
-                        DEBUG2(printk(KERN_INFO
-                            "scsi(%ld): ISP Firmware failed checksum.\n",
-                            vha->host_no));
+                        ql_log(ql_log_fatal, vha, 0x00cd,
+                            "ISP Firmware failed checksum.\n");
+                        goto failed;
                 }
         }
 
@@ -1549,7 +1536,7 @@ enable_82xx_npiv:
                         ha->flags.fac_supported = 1;
                         ha->fdt_block_size = size << 2;
                 } else {
-                        qla_printk(KERN_ERR, ha,
+                        ql_log(ql_log_warn, vha, 0x00ce,
                             "Unsupported FAC firmware (%d.%02d.%02d).\n",
                             ha->fw_major_version, ha->fw_minor_version,
                             ha->fw_subminor_version);
@@ -1557,8 +1544,8 @@ enable_82xx_npiv:
         }
 failed:
         if (rval) {
-                DEBUG2_3(printk("scsi(%ld): Setup chip **** FAILED ****.\n",
-                    vha->host_no));
+                ql_log(ql_log_fatal, vha, 0x00cf,
+                    "Setup chip ****FAILED****.\n");
         }
 
         return (rval);
@@ -1608,10 +1595,11 @@ qla2x00_update_fw_options(scsi_qla_host_t *vha)
                 return;
 
         /* Serial Link options. */
-        DEBUG3(printk("scsi(%ld): Serial link options:\n",
-            vha->host_no));
-        DEBUG3(qla2x00_dump_buffer((uint8_t *)&ha->fw_seriallink_options,
-            sizeof(ha->fw_seriallink_options)));
+        ql_dbg(ql_dbg_init + ql_dbg_buffer, vha, 0x0115,
+            "Serial link options.\n");
+        ql_dump_buffer(ql_dbg_init + ql_dbg_buffer, vha, 0x0109,
+            (uint8_t *)&ha->fw_seriallink_options,
+            sizeof(ha->fw_seriallink_options));
 
         ha->fw_options[1] &= ~FO1_SET_EMPHASIS_SWING;
         if (ha->fw_seriallink_options[3] & BIT_2) {
@@ -1688,7 +1676,7 @@ qla24xx_update_fw_options(scsi_qla_host_t *vha)
             le16_to_cpu(ha->fw_seriallink_options24[2]),
             le16_to_cpu(ha->fw_seriallink_options24[3]));
         if (rval != QLA_SUCCESS) {
-                qla_printk(KERN_WARNING, ha,
+                ql_log(ql_log_warn, vha, 0x0104,
                     "Unable to update Serial Link options (%x).\n", rval);
         }
 }
@@ -1746,8 +1734,9 @@ qla24xx_config_rings(struct scsi_qla_host *vha)
                 icb->rid = __constant_cpu_to_le16(rid);
                 if (ha->flags.msix_enabled) {
                         msix = &ha->msix_entries[1];
-                        DEBUG2_17(printk(KERN_INFO
-                        "Registering vector 0x%x for base que\n", msix->entry));
+                        ql_dbg(ql_dbg_init, vha, 0x00fd,
+                            "Registering vector 0x%x for base que.\n",
+                            msix->entry);
                         icb->msix = cpu_to_le16(msix->entry);
                 }
                 /* Use alternate PCI bus number */
@@ -1764,8 +1753,8 @@ qla24xx_config_rings(struct scsi_qla_host *vha)
                         icb->firmware_options_2 &=
                                 __constant_cpu_to_le32(~BIT_22);
                         ha->flags.disable_msix_handshake = 1;
-                        qla_printk(KERN_INFO, ha,
-                                "MSIX Handshake Disable Mode turned on\n");
+                        ql_dbg(ql_dbg_init, vha, 0x00fe,
+                            "MSIX Handshake Disable Mode turned on.\n");
                 } else {
                         icb->firmware_options_2 |=
                                 __constant_cpu_to_le32(BIT_22);
@@ -1850,7 +1839,7 @@ qla2x00_init_rings(scsi_qla_host_t *vha)
         /* Update any ISP specific firmware options before initialization. */
         ha->isp_ops->update_fw_options(vha);
 
-        DEBUG(printk("scsi(%ld): Issue init firmware.\n", vha->host_no));
+        ql_dbg(ql_dbg_init, vha, 0x00d1, "Issue init firmware.\n");
 
         if (ha->flags.npiv_supported) {
                 if (ha->operating_mode == LOOP)
@@ -1866,11 +1855,11 @@ qla2x00_init_rings(scsi_qla_host_t *vha)
 
         rval = qla2x00_init_firmware(vha, ha->init_cb_size);
         if (rval) {
-                DEBUG2_3(printk("scsi(%ld): Init firmware **** FAILED ****.\n",
-                    vha->host_no));
+                ql_log(ql_log_fatal, vha, 0x00d2,
+                    "Init Firmware **** FAILED ****.\n");
         } else {
-                DEBUG3(printk("scsi(%ld): Init firmware -- success.\n",
-                    vha->host_no));
+                ql_dbg(ql_dbg_init, vha, 0x00d3,
+                    "Init Firmware -- success.\n");
         }
 
         return (rval);
@@ -1913,10 +1902,8 @@ qla2x00_fw_ready(scsi_qla_host_t *vha)
 
         /* Wait for ISP to finish LIP */
         if (!vha->flags.init_done)
-                qla_printk(KERN_INFO, ha, "Waiting for LIP to complete...\n");
-
-        DEBUG3(printk("scsi(%ld): Waiting for LIP to complete...\n",
-            vha->host_no));
+                ql_log(ql_log_info, vha, 0x801e,
+                    "Waiting for LIP to complete.\n");
 
         do {
                 rval = qla2x00_get_firmware_state(vha, state);
@@ -1925,30 +1912,35 @@ qla2x00_fw_ready(scsi_qla_host_t *vha)
                                 vha->device_flags &= ~DFLG_NO_CABLE;
                         }
                         if (IS_QLA84XX(ha) && state[0] != FSTATE_READY) {
-                                DEBUG16(printk("scsi(%ld): fw_state=%x "
-                                    "84xx=%x.\n", vha->host_no, state[0],
-                                    state[2]));
+                                ql_dbg(ql_dbg_taskm, vha, 0x801f,
+                                    "fw_state=%x 84xx=%x.\n", state[0],
+                                    state[2]);
                                 if ((state[2] & FSTATE_LOGGED_IN) &&
                                      (state[2] & FSTATE_WAITING_FOR_VERIFY)) {
-                                        DEBUG16(printk("scsi(%ld): Sending "
-                                            "verify iocb.\n", vha->host_no));
+                                        ql_dbg(ql_dbg_taskm, vha, 0x8028,
+                                            "Sending verify iocb.\n");
 
                                         cs84xx_time = jiffies;
                                         rval = qla84xx_init_chip(vha);
-                                        if (rval != QLA_SUCCESS)
+                                        if (rval != QLA_SUCCESS) {
+                                                ql_log(ql_log_warn,
+                                                    vha, 0x8043,
+                                                    "Init chip failed.\n");
                                                 break;
+                                        }
 
                                         /* Add time taken to initialize. */
                                         cs84xx_time = jiffies - cs84xx_time;
                                         wtime += cs84xx_time;
                                         mtime += cs84xx_time;
-                                        DEBUG16(printk("scsi(%ld): Increasing "
-                                            "wait time by %ld. New time %ld\n",
-                                            vha->host_no, cs84xx_time, wtime));
+                                        ql_dbg(ql_dbg_taskm, vha, 0x8042,
+                                            "Increasing wait time by %ld. "
+                                            "New time %ld.\n", cs84xx_time,
+                                            wtime);
                                 }
                         } else if (state[0] == FSTATE_READY) {
-                                DEBUG(printk("scsi(%ld): F/W Ready - OK \n",
-                                    vha->host_no));
+                                ql_dbg(ql_dbg_taskm, vha, 0x8037,
+                                    "F/W Ready - OK.\n");
 
                                 qla2x00_get_retry_cnt(vha, &ha->retry_count,
                                     &ha->login_timeout, &ha->r_a_tov);
@@ -1965,7 +1957,7 @@ qla2x00_fw_ready(scsi_qla_host_t *vha)
                                  * other than Wait for Login.
                                  */
                                 if (time_after_eq(jiffies, mtime)) {
-                                        qla_printk(KERN_INFO, ha,
+                                        ql_log(ql_log_info, vha, 0x8038,
                                             "Cable is unplugged...\n");
 
                                         vha->device_flags |= DFLG_NO_CABLE;
@@ -1985,17 +1977,17 @@ qla2x00_fw_ready(scsi_qla_host_t *vha)
                 /* Delay for a while */
                 msleep(500);
 
-                DEBUG3(printk("scsi(%ld): fw_state=%x curr time=%lx.\n",
-                    vha->host_no, state[0], jiffies));
+                ql_dbg(ql_dbg_taskm, vha, 0x8039,
+                    "fw_state=%x curr time=%lx.\n", state[0], jiffies);
         } while (1);
 
-        DEBUG(printk("scsi(%ld): fw_state=%x (%x, %x, %x, %x) curr time=%lx.\n",
-            vha->host_no, state[0], state[1], state[2], state[3], state[4],
-            jiffies));
+        ql_dbg(ql_dbg_taskm, vha, 0x803a,
+            "fw_state=%x (%x, %x, %x, %x) " "curr time=%lx.\n", state[0],
+            state[1], state[2], state[3], state[4], jiffies);
 
         if (rval) {
-                DEBUG2_3(printk("scsi(%ld): Firmware ready **** FAILED ****.\n",
-                    vha->host_no));
+                ql_log(ql_log_warn, vha, 0x803b,
+                    "Firmware ready **** FAILED ****.\n");
         }
 
         return (rval);
@@ -2034,19 +2026,19 @@ qla2x00_configure_hba(scsi_qla_host_t *vha)
                 if (LOOP_TRANSITION(vha) || atomic_read(&ha->loop_down_timer) ||
                     IS_QLA8XXX_TYPE(ha) ||
                     (rval == QLA_COMMAND_ERROR && loop_id == 0x7)) {
-                        DEBUG2(printk("%s(%ld) Loop is in a transition state\n",
-                            __func__, vha->host_no));
+                        ql_dbg(ql_dbg_disc, vha, 0x2008,
+                            "Loop is in a transition state.\n");
                 } else {
-                        qla_printk(KERN_WARNING, ha,
-                            "ERROR -- Unable to get host loop ID.\n");
+                        ql_log(ql_log_warn, vha, 0x2009,
+                            "Unable to get host loop ID.\n");
                         set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
                 }
                 return (rval);
         }
 
         if (topo == 4) {
-                qla_printk(KERN_INFO, ha,
-                        "Cannot get topology - retrying.\n");
+                ql_log(ql_log_info, vha, 0x200a,
+                    "Cannot get topology - retrying.\n");
                 return (QLA_FUNCTION_FAILED);
         }
 
@@ -2059,31 +2051,27 @@ qla2x00_configure_hba(scsi_qla_host_t *vha)
 
         switch (topo) {
         case 0:
-                DEBUG3(printk("scsi(%ld): HBA in NL topology.\n",
-                    vha->host_no));
+                ql_dbg(ql_dbg_disc, vha, 0x200b, "HBA in NL topology.\n");
                 ha->current_topology = ISP_CFG_NL;
                 strcpy(connect_type, "(Loop)");
                 break;
 
         case 1:
-                DEBUG3(printk("scsi(%ld): HBA in FL topology.\n",
-                    vha->host_no));
+                ql_dbg(ql_dbg_disc, vha, 0x200c, "HBA in FL topology.\n");
                 ha->switch_cap = sw_cap;
                 ha->current_topology = ISP_CFG_FL;
                 strcpy(connect_type, "(FL_Port)");
                 break;
 
         case 2:
-                DEBUG3(printk("scsi(%ld): HBA in N P2P topology.\n",
-                    vha->host_no));
+                ql_dbg(ql_dbg_disc, vha, 0x200d, "HBA in N P2P topology.\n");
                 ha->operating_mode = P2P;
                 ha->current_topology = ISP_CFG_N;
                 strcpy(connect_type, "(N_Port-to-N_Port)");
                 break;
 
         case 3:
-                DEBUG3(printk("scsi(%ld): HBA in F P2P topology.\n",
-                    vha->host_no));
+                ql_dbg(ql_dbg_disc, vha, 0x200e, "HBA in F P2P topology.\n");
                 ha->switch_cap = sw_cap;
                 ha->operating_mode = P2P;
                 ha->current_topology = ISP_CFG_F;
@@ -2091,9 +2079,8 @@ qla2x00_configure_hba(scsi_qla_host_t *vha)
                 break;
 
         default:
-                DEBUG3(printk("scsi(%ld): HBA in unknown topology %x. "
-                    "Using NL.\n",
-                    vha->host_no, topo));
+                ql_dbg(ql_dbg_disc, vha, 0x200f,
+                    "HBA in unknown topology %x, using NL.\n", topo);
                 ha->current_topology = ISP_CFG_NL;
                 strcpy(connect_type, "(Loop)");
                 break;
@@ -2106,14 +2093,16 @@ qla2x00_configure_hba(scsi_qla_host_t *vha)
         vha->d_id.b.al_pa = al_pa;
 
         if (!vha->flags.init_done)
-                qla_printk(KERN_INFO, ha,
-                    "Topology - %s, Host Loop address 0x%x\n",
+                ql_log(ql_log_info, vha, 0x2010,
+                    "Topology - %s, Host Loop address 0x%x.\n",
                     connect_type, vha->loop_id);
 
         if (rval) {
-                DEBUG2_3(printk("scsi(%ld): FAILED.\n", vha->host_no));
+                ql_log(ql_log_warn, vha, 0x2011,
+                    "%s FAILED\n", __func__);
         } else {
-                DEBUG3(printk("scsi(%ld): exiting normally.\n", vha->host_no));
+                ql_dbg(ql_dbg_disc, vha, 0x2012,
+                    "%s success\n", __func__);
         }
 
         return(rval);
@@ -2227,18 +2216,22 @@ qla2x00_nvram_config(scsi_qla_host_t *vha)
         for (cnt = 0, chksum = 0; cnt < ha->nvram_size; cnt++)
                 chksum += *ptr++;
 
-        DEBUG5(printk("scsi(%ld): Contents of NVRAM\n", vha->host_no));
-        DEBUG5(qla2x00_dump_buffer((uint8_t *)nv, ha->nvram_size));
+        ql_dbg(ql_dbg_init + ql_dbg_buffer, vha, 0x010f,
+            "Contents of NVRAM.\n");
+        ql_dump_buffer(ql_dbg_init + ql_dbg_buffer, vha, 0x0110,
+            (uint8_t *)nv, ha->nvram_size);
 
         /* Bad NVRAM data, set defaults parameters. */
         if (chksum || nv->id[0] != 'I' || nv->id[1] != 'S' ||
             nv->id[2] != 'P' || nv->id[3] != ' ' || nv->nvram_version < 1) {
                 /* Reset NVRAM data. */
-                qla_printk(KERN_WARNING, ha, "Inconsistent NVRAM detected: "
-                    "checksum=0x%x id=%c version=0x%x.\n", chksum, nv->id[0],
-                    nv->nvram_version);
-                qla_printk(KERN_WARNING, ha, "Falling back to functioning (yet "
-                    "invalid -- WWPN) defaults.\n");
+                ql_log(ql_log_warn, vha, 0x0064,
+                    "Inconisistent NVRAM "
+                    "detected: checksum=0x%x id=%c version=0x%x.\n",
+                    chksum, nv->id[0], nv->nvram_version);
+                ql_log(ql_log_warn, vha, 0x0065,
+                    "Falling back to "
+                    "functioning (yet invalid -- WWPN) defaults.\n");
 
                 /*
                  * Set default initialization control block.
@@ -2382,8 +2375,13 @@ qla2x00_nvram_config(scsi_qla_host_t *vha)
         /*
          * Set host adapter parameters.
          */
+
+        /*
+         * BIT_7 in the host-parameters section allows for modification to
+         * internal driver logging.
+         */
         if (nv->host_p[0] & BIT_7)
-                ql2xextended_error_logging = 1;
+                ql2xextended_error_logging = 0x7fffffff;
         ha->flags.disable_risc_code_load = ((nv->host_p[0] & BIT_4) ? 1 : 0);
         /* Always load RISC code on non ISP2[12]00 chips. */
         if (!IS_QLA2100(ha) && !IS_QLA2200(ha))
@@ -2488,10 +2486,7 @@ qla2x00_nvram_config(scsi_qla_host_t *vha)
                 if (ha->zio_mode != QLA_ZIO_DISABLED) {
                         ha->zio_mode = QLA_ZIO_MODE_6;
 
-                        DEBUG2(printk("scsi(%ld): ZIO mode %d enabled; timer "
-                            "delay (%d us).\n", vha->host_no, ha->zio_mode,
-                            ha->zio_timer * 100));
-                        qla_printk(KERN_INFO, ha,
+                        ql_log(ql_log_info, vha, 0x0068,
                             "ZIO mode %d enabled; timer delay (%d us).\n",
                             ha->zio_mode, ha->zio_timer * 100);
 
@@ -2502,8 +2497,8 @@ qla2x00_nvram_config(scsi_qla_host_t *vha)
         }
 
         if (rval) {
-                DEBUG2_3(printk(KERN_WARNING
-                    "scsi(%ld): NVRAM configuration failed!\n", vha->host_no));
+                ql_log(ql_log_warn, vha, 0x0069,
+                    "NVRAM configuration failed.\n");
         }
         return (rval);
 }
@@ -2574,15 +2569,15 @@ qla2x00_configure_loop(scsi_qla_host_t *vha)
         if (test_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags)) {
                 rval = qla2x00_configure_hba(vha);
                 if (rval != QLA_SUCCESS) {
-                        DEBUG(printk("scsi(%ld): Unable to configure HBA.\n",
-                            vha->host_no));
+                        ql_dbg(ql_dbg_disc, vha, 0x2013,
+                            "Unable to configure HBA.\n");
                         return (rval);
                 }
         }
 
         save_flags = flags = vha->dpc_flags;
-        DEBUG(printk("scsi(%ld): Configure loop -- dpc flags =0x%lx\n",
-            vha->host_no, flags));
+        ql_dbg(ql_dbg_disc, vha, 0x2014,
+            "Configure loop -- dpc flags = 0x%lx.\n", flags);
 
         /*
          * If we have both an RSCN and PORT UPDATE pending then handle them
@@ -2619,15 +2614,21 @@ qla2x00_configure_loop(scsi_qla_host_t *vha)
         }
 
         if (test_bit(LOCAL_LOOP_UPDATE, &flags)) {
-                if (test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags))
+                if (test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags)) {
+                        ql_dbg(ql_dbg_disc, vha, 0x2015,
+                            "Loop resync needed, failing.\n");
                         rval = QLA_FUNCTION_FAILED;
+                }
                 else
                         rval = qla2x00_configure_local_loop(vha);
         }
 
         if (rval == QLA_SUCCESS && test_bit(RSCN_UPDATE, &flags)) {
-                if (LOOP_TRANSITION(vha))
+                if (LOOP_TRANSITION(vha)) {
+                        ql_dbg(ql_dbg_disc, vha, 0x201e,
+                            "Needs RSCN update and loop transition.\n");
                         rval = QLA_FUNCTION_FAILED;
+                }
                 else
                         rval = qla2x00_configure_fabric(vha);
         }
@@ -2638,16 +2639,17 @@ qla2x00_configure_loop(scsi_qla_host_t *vha)
                         rval = QLA_FUNCTION_FAILED;
                 } else {
                         atomic_set(&vha->loop_state, LOOP_READY);
-
-                        DEBUG(printk("scsi(%ld): LOOP READY\n", vha->host_no));
+                        ql_dbg(ql_dbg_disc, vha, 0x2069,
+                            "LOOP READY.\n");
                 }
         }
 
         if (rval) {
-                DEBUG2_3(printk("%s(%ld): *** FAILED ***\n",
-                    __func__, vha->host_no));
+                ql_dbg(ql_dbg_disc, vha, 0x206a,
+                    "%s *** FAILED ***.\n", __func__);
         } else {
-                DEBUG3(printk("%s: exiting normally\n", __func__));
+                ql_dbg(ql_dbg_disc, vha, 0x206b,
+                    "%s: exiting normally.\n", __func__);
         }
 
         /* Restore state if a resync event occurred during processing */
@@ -2695,8 +2697,10 @@ qla2x00_configure_local_loop(scsi_qla_host_t *vha)
         new_fcport = NULL;
         entries = MAX_FIBRE_DEVICES;
 
-        DEBUG3(printk("scsi(%ld): Getting FCAL position map\n", vha->host_no));
-        DEBUG3(qla2x00_get_fcal_position_map(vha, NULL));
+        ql_dbg(ql_dbg_disc, vha, 0x2016,
+            "Getting FCAL position map.\n");
+        if (ql2xextended_error_logging & ql_dbg_disc)
+                qla2x00_get_fcal_position_map(vha, NULL);
 
         /* Get list of logged in devices. */
         memset(ha->gid_list, 0, GID_LIST_SIZE);
@@ -2705,14 +2709,17 @@ qla2x00_configure_local_loop(scsi_qla_host_t *vha)
         if (rval != QLA_SUCCESS)
                 goto cleanup_allocation;
 
-        DEBUG3(printk("scsi(%ld): Entries in ID list (%d)\n",
-            vha->host_no, entries));
-        DEBUG3(qla2x00_dump_buffer((uint8_t *)ha->gid_list,
-            entries * sizeof(struct gid_list_info)));
+        ql_dbg(ql_dbg_disc, vha, 0x2017,
+            "Entries in ID list (%d).\n", entries);
+        ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x2075,
+            (uint8_t *)ha->gid_list,
+            entries * sizeof(struct gid_list_info));
 
         /* Allocate temporary fcport for any new fcports discovered. */
         new_fcport = qla2x00_alloc_fcport(vha, GFP_KERNEL);
         if (new_fcport == NULL) {
+                ql_log(ql_log_warn, vha, 0x2018,
+                    "Memory allocation failed for fcport.\n");
                 rval = QLA_MEMORY_ALLOC_FAILED;
                 goto cleanup_allocation;
         }
@@ -2726,9 +2733,9 @@ qla2x00_configure_local_loop(scsi_qla_host_t *vha)
                     fcport->port_type != FCT_BROADCAST &&
                     (fcport->flags & FCF_FABRIC_DEVICE) == 0) {
 
-                        DEBUG(printk("scsi(%ld): Marking port lost, "
-                            "loop_id=0x%04x\n",
-                            vha->host_no, fcport->loop_id));
+                        ql_dbg(ql_dbg_disc, vha, 0x2019,
+                            "Marking port lost loop_id=0x%04x.\n",
+                            fcport->loop_id);
 
                         qla2x00_set_fcport_state(fcport, FCS_DEVICE_LOST);
                 }
@@ -2769,12 +2776,12 @@ qla2x00_configure_local_loop(scsi_qla_host_t *vha)
                 new_fcport->vp_idx = vha->vp_idx;
                 rval2 = qla2x00_get_port_database(vha, new_fcport, 0);
                 if (rval2 != QLA_SUCCESS) {
-                        DEBUG2(printk("scsi(%ld): Failed to retrieve fcport "
-                            "information -- get_port_database=%x, "
-                            "loop_id=0x%04x\n",
-                            vha->host_no, rval2, new_fcport->loop_id));
-                        DEBUG2(printk("scsi(%ld): Scheduling resync...\n",
-                            vha->host_no));
+                        ql_dbg(ql_dbg_disc, vha, 0x201a,
+                            "Failed to retrieve fcport information "
+                            "-- get_port_database=%x, loop_id=0x%04x.\n",
+                            rval2, new_fcport->loop_id);
+                        ql_dbg(ql_dbg_disc, vha, 0x201b,
+                            "Scheduling resync.\n");
                         set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
                         continue;
                 }
@@ -2810,6 +2817,8 @@ qla2x00_configure_local_loop(scsi_qla_host_t *vha)
                         fcport = new_fcport;
                         new_fcport = qla2x00_alloc_fcport(vha, GFP_KERNEL);
                         if (new_fcport == NULL) {
+                                ql_log(ql_log_warn, vha, 0x201c,
+                                    "Failed to allocate memory for fcport.\n");
                                 rval = QLA_MEMORY_ALLOC_FAILED;
                                 goto cleanup_allocation;
                         }
@@ -2828,8 +2837,8 @@ cleanup_allocation:
         kfree(new_fcport);
 
         if (rval != QLA_SUCCESS) {
-                DEBUG2(printk("scsi(%ld): Configure local loop error exit: "
-                    "rval=%x\n", vha->host_no, rval));
+                ql_dbg(ql_dbg_disc, vha, 0x201d,
+                    "Configure local loop error exit: rval=%x.\n", rval);
         }
 
         return (rval);
@@ -2858,27 +2867,27 @@ qla2x00_iidma_fcport(scsi_qla_host_t *vha, fc_port_t *fcport)
         rval = qla2x00_set_idma_speed(vha, fcport->loop_id, fcport->fp_speed,
             mb);
         if (rval != QLA_SUCCESS) {
-                DEBUG2(printk("scsi(%ld): Unable to adjust iIDMA "
-                    "%02x%02x%02x%02x%02x%02x%02x%02x -- %04x %x %04x %04x.\n",
-                    vha->host_no, fcport->port_name[0], fcport->port_name[1],
+                ql_dbg(ql_dbg_disc, vha, 0x2004,
+                    "Unable to adjust iIDMA "
+                    "%02x%02x%02x%02x%02x%02x%02x%02x -- %04x %x %04x "
+                    "%04x.\n", fcport->port_name[0], fcport->port_name[1],
                     fcport->port_name[2], fcport->port_name[3],
                     fcport->port_name[4], fcport->port_name[5],
                     fcport->port_name[6], fcport->port_name[7], rval,
-                    fcport->fp_speed, mb[0], mb[1]));
+                    fcport->fp_speed, mb[0], mb[1]);
         } else {
                 link_speed = link_speeds[LS_UNKNOWN];
                 if (fcport->fp_speed < 5)
                         link_speed = link_speeds[fcport->fp_speed];
                 else if (fcport->fp_speed == 0x13)
                         link_speed = link_speeds[5];
-                DEBUG2(qla_printk(KERN_INFO, ha,
-                    "iIDMA adjusted to %s GB/s on "
-                    "%02x%02x%02x%02x%02x%02x%02x%02x.\n",
-                    link_speed, fcport->port_name[0],
-                    fcport->port_name[1], fcport->port_name[2],
-                    fcport->port_name[3], fcport->port_name[4],
-                    fcport->port_name[5], fcport->port_name[6],
-                    fcport->port_name[7]));
+                ql_dbg(ql_dbg_disc, vha, 0x2005,
+                    "iIDMA adjusted to %s GB/s "
+                    "on %02x%02x%02x%02x%02x%02x%02x%02x.\n", link_speed,
+                    fcport->port_name[0], fcport->port_name[1],
+                    fcport->port_name[2], fcport->port_name[3],
+                    fcport->port_name[4], fcport->port_name[5],
+                    fcport->port_name[6], fcport->port_name[7]);
         }
 }
 
@@ -2887,7 +2896,6 @@ qla2x00_reg_remote_port(scsi_qla_host_t *vha, fc_port_t *fcport)
 {
         struct fc_rport_identifiers rport_ids;
         struct fc_rport *rport;
-        struct qla_hw_data *ha = vha->hw;
         unsigned long flags;
 
         qla2x00_rport_del(fcport);
@@ -2899,8 +2907,8 @@ qla2x00_reg_remote_port(scsi_qla_host_t *vha, fc_port_t *fcport)
         rport_ids.roles = FC_RPORT_ROLE_UNKNOWN;
         fcport->rport = rport = fc_remote_port_add(vha->host, 0, &rport_ids);
         if (!rport) {
-                qla_printk(KERN_WARNING, ha,
-                    "Unable to allocate fc remote port!\n");
+                ql_log(ql_log_warn, vha, 0x2006,
+                    "Unable to allocate fc remote port.\n");
                 return;
         }
         spin_lock_irqsave(fcport->vha->host->host_lock, flags);
@@ -2975,8 +2983,8 @@ qla2x00_configure_fabric(scsi_qla_host_t *vha)
                 loop_id = SNS_FL_PORT;
         rval = qla2x00_get_port_name(vha, loop_id, vha->fabric_node_name, 1);
         if (rval != QLA_SUCCESS) {
-                DEBUG2(printk("scsi(%ld): MBC_GET_PORT_NAME Failed, No FL "
-                    "Port\n", vha->host_no));
+                ql_dbg(ql_dbg_disc, vha, 0x201f,
+                    "MBX_GET_PORT_NAME failed, No FL Port.\n");
 
                 vha->device_flags &= ~SWITCH_FOUND;
                 return (QLA_SUCCESS);
@@ -3003,32 +3011,32 @@ qla2x00_configure_fabric(scsi_qla_host_t *vha)
                 ha->isp_ops->fabric_login(vha, loop_id, 0xff, 0xff,
                     0xfc, mb, BIT_1 | BIT_0);
                 if (mb[0] != MBS_COMMAND_COMPLETE) {
-                        DEBUG2(qla_printk(KERN_INFO, ha,
-                            "Failed SNS login: loop_id=%x mb[0]=%x mb[1]=%x "
-                            "mb[2]=%x mb[6]=%x mb[7]=%x\n", loop_id,
-                            mb[0], mb[1], mb[2], mb[6], mb[7]));
+                        ql_dbg(ql_dbg_disc, vha, 0x2042,
+                            "Failed SNS login: loop_id=%x mb[0]=%x mb[1]=%x mb[2]=%x "
+                            "mb[6]=%x mb[7]=%x.\n", loop_id, mb[0], mb[1],
+                            mb[2], mb[6], mb[7]);
                         return (QLA_SUCCESS);
                 }
 
                 if (test_and_clear_bit(REGISTER_FC4_NEEDED, &vha->dpc_flags)) {
                         if (qla2x00_rft_id(vha)) {
                                 /* EMPTY */
-                                DEBUG2(printk("scsi(%ld): Register FC-4 "
-                                    "TYPE failed.\n", vha->host_no));
+                                ql_dbg(ql_dbg_disc, vha, 0x2045,
+                                    "Register FC-4 TYPE failed.\n");
                         }
                         if (qla2x00_rff_id(vha)) {
                                 /* EMPTY */
-                                DEBUG2(printk("scsi(%ld): Register FC-4 "
-                                    "Features failed.\n", vha->host_no));
+                                ql_dbg(ql_dbg_disc, vha, 0x2049,
+                                    "Register FC-4 Features failed.\n");
                         }
                         if (qla2x00_rnn_id(vha)) {
                                 /* EMPTY */
-                                DEBUG2(printk("scsi(%ld): Register Node Name "
-                                    "failed.\n", vha->host_no));
+                                ql_dbg(ql_dbg_disc, vha, 0x204f,
+                                    "Register Node Name failed.\n");
                         } else if (qla2x00_rsnn_nn(vha)) {
                                 /* EMPTY */
-                                DEBUG2(printk("scsi(%ld): Register Symbolic "
-                                    "Node Name failed.\n", vha->host_no));
+                                ql_dbg(ql_dbg_disc, vha, 0x2053,
+                                    "Register Symobilic Node Name failed.\n");
                         }
                 }
 
@@ -3132,8 +3140,8 @@ qla2x00_configure_fabric(scsi_qla_host_t *vha)
         }
 
         if (rval) {
-                DEBUG2(printk("scsi(%ld): Configure fabric error exit: "
-                    "rval=%d\n", vha->host_no, rval));
+                ql_dbg(ql_dbg_disc, vha, 0x2068,
+                    "Configure fabric error exit rval=%d.\n", rval);
         }
 
         return (rval);
@@ -3175,8 +3183,8 @@ qla2x00_find_all_fabric_devs(scsi_qla_host_t *vha,
         swl = kcalloc(MAX_FIBRE_DEVICES, sizeof(sw_info_t), GFP_KERNEL);
         if (!swl) {
                 /*EMPTY*/
-                DEBUG2(printk("scsi(%ld): GID_PT allocations failed, fallback "
-                    "on GA_NXT\n", vha->host_no));
+                ql_dbg(ql_dbg_disc, vha, 0x2054,
+                    "GID_PT allocations failed, fallback on GA_NXT.\n");
         } else {
                 if (qla2x00_gid_pt(vha, swl) != QLA_SUCCESS) {
                         kfree(swl);
@@ -3201,6 +3209,8 @@ qla2x00_find_all_fabric_devs(scsi_qla_host_t *vha,
         /* Allocate temporary fcport for any new fcports discovered. */
         new_fcport = qla2x00_alloc_fcport(vha, GFP_KERNEL);
         if (new_fcport == NULL) {
+                ql_log(ql_log_warn, vha, 0x205e,
+                    "Failed to allocate memory for fcport.\n");
                 kfree(swl);
                 return (QLA_MEMORY_ALLOC_FAILED);
         }
@@ -3247,9 +3257,9 @@ qla2x00_find_all_fabric_devs(scsi_qla_host_t *vha,
                         /* Send GA_NXT to the switch */
                         rval = qla2x00_ga_nxt(vha, new_fcport);
                         if (rval != QLA_SUCCESS) {
-                                qla_printk(KERN_WARNING, ha,
-                                    "SNS scan failed -- assuming zero-entry "
-                                    "result...\n");
+                                ql_log(ql_log_warn, vha, 0x2064,
+                                    "SNS scan failed -- assuming "
+                                    "zero-entry result.\n");
                                 list_for_each_entry_safe(fcport, fcptemp,
                                     new_fcports, list) {
                                         list_del(&fcport->list);
@@ -3265,9 +3275,11 @@ qla2x00_find_all_fabric_devs(scsi_qla_host_t *vha,
                         wrap.b24 = new_fcport->d_id.b24;
                         first_dev = 0;
                 } else if (new_fcport->d_id.b24 == wrap.b24) {
-                        DEBUG2(printk("scsi(%ld): device wrap (%02x%02x%02x)\n",
-                            vha->host_no, new_fcport->d_id.b.domain,
-                            new_fcport->d_id.b.area, new_fcport->d_id.b.al_pa));
+                        ql_dbg(ql_dbg_disc, vha, 0x2065,
+                            "Device wrap (%02x%02x%02x).\n",
+                            new_fcport->d_id.b.domain,
+                            new_fcport->d_id.b.area,
+                            new_fcport->d_id.b.al_pa);
                         break;
                 }
 
@@ -3372,6 +3384,8 @@ qla2x00_find_all_fabric_devs(scsi_qla_host_t *vha,
                 nxt_d_id.b24 = new_fcport->d_id.b24;
                 new_fcport = qla2x00_alloc_fcport(vha, GFP_KERNEL);
                 if (new_fcport == NULL) {
+                        ql_log(ql_log_warn, vha, 0x2066,
+                            "Memory allocation failed for fcport.\n");
                         kfree(swl);
                         return (QLA_MEMORY_ALLOC_FAILED);
                 }
@@ -3501,10 +3515,10 @@ qla2x00_device_resync(scsi_qla_host_t *vha)
                 d_id.b.area = MSB(LSW(rscn_entry));
                 d_id.b.al_pa = LSB(LSW(rscn_entry));
 
-                DEBUG(printk("scsi(%ld): RSCN queue entry[%d] = "
-                    "[%02x/%02x%02x%02x].\n",
-                    vha->host_no, vha->rscn_out_ptr, format, d_id.b.domain,
-                    d_id.b.area, d_id.b.al_pa));
+                ql_dbg(ql_dbg_disc, vha, 0x2020,
+                    "RSCN queue entry[%d] = [%02x/%02x%02x%02x].\n",
+                    vha->rscn_out_ptr, format, d_id.b.domain, d_id.b.area,
+                    d_id.b.al_pa);
 
                 vha->rscn_out_ptr++;
                 if (vha->rscn_out_ptr == MAX_RSCN_COUNT)
@@ -3520,17 +3534,17 @@ qla2x00_device_resync(scsi_qla_host_t *vha)
                         if (rscn_entry != vha->rscn_queue[rscn_out_iter])
                                 break;
 
-                        DEBUG(printk("scsi(%ld): Skipping duplicate RSCN queue "
-                            "entry found at [%d].\n", vha->host_no,
-                            rscn_out_iter));
+                        ql_dbg(ql_dbg_disc, vha, 0x2021,
+                            "Skipping duplicate RSCN queue entry found at "
+                            "[%d].\n", rscn_out_iter);
 
                         vha->rscn_out_ptr = rscn_out_iter;
                 }
 
                 /* Queue overflow, set switch default case. */
                 if (vha->flags.rscn_queue_overflow) {
-                        DEBUG(printk("scsi(%ld): device_resync: rscn "
-                            "overflow.\n", vha->host_no));
+                        ql_dbg(ql_dbg_disc, vha, 0x2022,
+                            "device_resync: rscn overflow.\n");
 
                         format = 3;
                         vha->flags.rscn_queue_overflow = 0;
@@ -3659,10 +3673,11 @@ qla2x00_fabric_login(scsi_qla_host_t *vha, fc_port_t *fcport,
         tmp_loopid = 0;
 
         for (;;) {
-                DEBUG(printk("scsi(%ld): Trying Fabric Login w/loop id 0x%04x "
-                    "for port %02x%02x%02x.\n",
-                    vha->host_no, fcport->loop_id, fcport->d_id.b.domain,
-                    fcport->d_id.b.area, fcport->d_id.b.al_pa));
+                ql_dbg(ql_dbg_disc, vha, 0x2000,
+                    "Trying Fabric Login w/loop id 0x%04x for port "
+                    "%02x%02x%02x.\n",
+                    fcport->loop_id, fcport->d_id.b.domain,
+                    fcport->d_id.b.area, fcport->d_id.b.al_pa);
 
                 /* Login fcport on switch. */
                 ha->isp_ops->fabric_login(vha, fcport->loop_id,
@@ -3680,10 +3695,11 @@ qla2x00_fabric_login(scsi_qla_host_t *vha, fc_port_t *fcport,
                         tmp_loopid = fcport->loop_id;
                         fcport->loop_id = mb[1];
 
-                        DEBUG(printk("Fabric Login: port in use - next "
-                            "loop id=0x%04x, port Id=%02x%02x%02x.\n",
+                        ql_dbg(ql_dbg_disc, vha, 0x2001,
+                            "Fabric Login: port in use - next loop "
+                            "id=0x%04x, port id= %02x%02x%02x.\n",
                             fcport->loop_id, fcport->d_id.b.domain,
-                            fcport->d_id.b.area, fcport->d_id.b.al_pa));
+                            fcport->d_id.b.area, fcport->d_id.b.al_pa);
 
                 } else if (mb[0] == MBS_COMMAND_COMPLETE) {
                         /*
@@ -3744,11 +3760,11 @@ qla2x00_fabric_login(scsi_qla_host_t *vha, fc_port_t *fcport,
                         /*
                          * unrecoverable / not handled error
                          */
-                        DEBUG2(printk("%s(%ld): failed=%x port_id=%02x%02x%02x "
-                            "loop_id=%x jiffies=%lx.\n",
-                            __func__, vha->host_no, mb[0],
-                            fcport->d_id.b.domain, fcport->d_id.b.area,
-                            fcport->d_id.b.al_pa, fcport->loop_id, jiffies));
+                        ql_dbg(ql_dbg_disc, vha, 0x2002,
+                            "Failed=%x port_id=%02x%02x%02x loop_id=%x "
+                            "jiffies=%lx.\n", mb[0], fcport->d_id.b.domain,
+                            fcport->d_id.b.area, fcport->d_id.b.al_pa,
+                            fcport->loop_id, jiffies);
 
                         *next_loopid = fcport->loop_id;
                         ha->isp_ops->fabric_logout(vha, fcport->loop_id,
@@ -3852,7 +3868,8 @@ qla2x00_loop_resync(scsi_qla_host_t *vha)
                 return (QLA_FUNCTION_FAILED);
 
         if (rval)
-                DEBUG2_3(printk("%s(): **** FAILED ****\n", __func__));
+                ql_dbg(ql_dbg_disc, vha, 0x206c,
+                    "%s *** FAILED ***.\n", __func__);
 
         return (rval);
 }
@@ -3929,8 +3946,8 @@ qla82xx_quiescent_state_cleanup(scsi_qla_host_t *vha)
         struct qla_hw_data *ha = vha->hw;
         struct scsi_qla_host *vp;
 
-        qla_printk(KERN_INFO, ha,
-                        "Performing ISP error recovery - ha= %p.\n", ha);
+        ql_dbg(ql_dbg_p3p, vha, 0xb002,
+            "Performing ISP error recovery - ha=%p.\n", ha);
 
         atomic_set(&ha->loop_down_timer, LOOP_DOWN_TIME);
         if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
@@ -3964,8 +3981,8 @@ qla2x00_abort_isp_cleanup(scsi_qla_host_t *vha)
         clear_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
         ha->qla_stats.total_isp_aborts++;
 
-        qla_printk(KERN_INFO, ha,
-            "Performing ISP error recovery - ha= %p.\n", ha);
+        ql_log(ql_log_info, vha, 0x00af,
+            "Performing ISP error recovery - ha=%p.\n", ha);
 
         /* For ISP82XX, reset_chip is just disabling interrupts.
          * Driver waits for the completion of the commands.
@@ -4016,6 +4033,8 @@ qla2x00_abort_isp_cleanup(scsi_qla_host_t *vha)
                 /* Make sure for ISP 82XX IO DMA is complete */
                 if (IS_QLA82XX(ha)) {
                         qla82xx_chip_reset_cleanup(vha);
+                        ql_log(ql_log_info, vha, 0x00b4,
+                            "Done chip reset cleanup.\n");
 
                         /* Done waiting for pending commands.
                          * Reset the online flag.
@@ -4097,7 +4116,7 @@ qla2x00_abort_isp(scsi_qla_host_t *vha)
                                     ha->fce_dma, ha->fce_bufs, ha->fce_mb,
                                     &ha->fce_bufs);
                                 if (rval) {
-                                        qla_printk(KERN_WARNING, ha,
+                                        ql_log(ql_log_warn, vha, 0x8033,
                                             "Unable to reinitialize FCE "
                                             "(%d).\n", rval);
                                         ha->flags.fce_enabled = 0;
@@ -4109,7 +4128,7 @@ qla2x00_abort_isp(scsi_qla_host_t *vha)
                                 rval = qla2x00_enable_eft_trace(vha,
                                     ha->eft_dma, EFT_NUM_BUFFERS);
                                 if (rval) {
-                                        qla_printk(KERN_WARNING, ha,
+                                        ql_log(ql_log_warn, vha, 0x8034,
                                             "Unable to reinitialize EFT "
                                             "(%d).\n", rval);
                                 }
@@ -4118,9 +4137,9 @@ qla2x00_abort_isp(scsi_qla_host_t *vha)
                         vha->flags.online = 1;
                         if (test_bit(ISP_ABORT_RETRY, &vha->dpc_flags)) {
                                 if (ha->isp_abort_cnt == 0) {
-                                        qla_printk(KERN_WARNING, ha,
-                                            "ISP error recovery failed - "
-                                            "board disabled\n");
+                                        ql_log(ql_log_fatal, vha, 0x8035,
+                                            "ISP error recover failed - "
+                                            "board disabled.\n");
                                         /*
                                          * The next call disables the board
                                          * completely.
@@ -4132,16 +4151,16 @@ qla2x00_abort_isp(scsi_qla_host_t *vha)
                                         status = 0;
                                 } else { /* schedule another ISP abort */
                                         ha->isp_abort_cnt--;
-                                        DEBUG(printk("qla%ld: ISP abort - "
-                                            "retry remaining %d\n",
-                                            vha->host_no, ha->isp_abort_cnt));
+                                        ql_dbg(ql_dbg_taskm, vha, 0x8020,
+                                            "ISP abort - retry remaining %d.\n",
+                                            ha->isp_abort_cnt);
                                         status = 1;
                                 }
                         } else {
                                 ha->isp_abort_cnt = MAX_RETRIES_OF_ISP_ABORT;
-                                DEBUG(printk("qla2x00(%ld): ISP error recovery "
-                                    "- retrying (%d) more times\n",
-                                    vha->host_no, ha->isp_abort_cnt));
+                                ql_dbg(ql_dbg_taskm, vha, 0x8021,
+                                    "ISP error recovery - retrying (%d) "
+                                    "more times.\n", ha->isp_abort_cnt);
                                 set_bit(ISP_ABORT_RETRY, &vha->dpc_flags);
                                 status = 1;
                         }
@@ -4150,9 +4169,7 @@ qla2x00_abort_isp(scsi_qla_host_t *vha)
         }
 
         if (!status) {
-                DEBUG(printk(KERN_INFO
-                                "qla2x00_abort_isp(%ld): succeeded.\n",
-                                vha->host_no));
+                ql_dbg(ql_dbg_taskm, vha, 0x8022, "%s succeeded.\n", __func__);
 
                 spin_lock_irqsave(&ha->vport_slock, flags);
                 list_for_each_entry(vp, &ha->vp_list, list) {
@@ -4169,8 +4186,7 @@ qla2x00_abort_isp(scsi_qla_host_t *vha)
                 spin_unlock_irqrestore(&ha->vport_slock, flags);
 
         } else {
-                qla_printk(KERN_INFO, ha,
-                        "qla2x00_abort_isp: **** FAILED ****\n");
+                ql_log(ql_log_warn, vha, 0x8023, "%s **** FAILED ****.\n");
         }
 
         return(status);
@@ -4211,8 +4227,8 @@ qla2x00_restart_isp(scsi_qla_host_t *vha)
 
                 status = qla2x00_fw_ready(vha);
                 if (!status) {
-                        DEBUG(printk("%s(): Start configure loop, "
-                            "status = %d\n", __func__, status));
+                        ql_dbg(ql_dbg_taskm, vha, 0x8031,
+                            "Start configure loop status = %d.\n", status);
 
                         /* Issue a marker after FW becomes ready. */
                         qla2x00_marker(vha, req, rsp, 0, 0, MK_SYNC_ALL);
@@ -4234,9 +4250,8 @@ qla2x00_restart_isp(scsi_qla_host_t *vha)
                 if ((vha->device_flags & DFLG_NO_CABLE))
                         status = 0;
 
-                DEBUG(printk("%s(): Configure loop done, status = 0x%x\n",
-                                __func__,
-                                status));
+                ql_dbg(ql_dbg_taskm, vha, 0x8032,
+                    "Configure loop done, status = 0x%x.\n", status);
         }
         return (status);
 }
@@ -4256,13 +4271,13 @@ qla25xx_init_queues(struct qla_hw_data *ha)
                         rsp->options &= ~BIT_0;
                         ret = qla25xx_init_rsp_que(base_vha, rsp);
                         if (ret != QLA_SUCCESS)
-                                DEBUG2_17(printk(KERN_WARNING
-                                        "%s Rsp que:%d init failed\n", __func__,
-                                                rsp->id));
+                                ql_dbg(ql_dbg_init, base_vha, 0x00ff,
+                                    "%s Rsp que: %d init failed.\n",
+                                    __func__, rsp->id);
                         else
-                                DEBUG2_17(printk(KERN_INFO
-                                        "%s Rsp que:%d inited\n", __func__,
-                                                rsp->id));
+                                ql_dbg(ql_dbg_init, base_vha, 0x0100,
+                                    "%s Rsp que: %d inited.\n",
+                                    __func__, rsp->id);
                 }
         }
         for (i = 1; i < ha->max_req_queues; i++) {
@@ -4272,13 +4287,13 @@ qla25xx_init_queues(struct qla_hw_data *ha)
                         req->options &= ~BIT_0;
                         ret = qla25xx_init_req_que(base_vha, req);
                         if (ret != QLA_SUCCESS)
-                                DEBUG2_17(printk(KERN_WARNING
-                                        "%s Req que:%d init failed\n", __func__,
-                                                req->id));
+                                ql_dbg(ql_dbg_init, base_vha, 0x0101,
+                                    "%s Req que: %d init failed.\n",
+                                    __func__, req->id);
                         else
-                                DEBUG2_17(printk(KERN_WARNING
-                                        "%s Req que:%d inited\n", __func__,
-                                                req->id));
+                                ql_dbg(ql_dbg_init, base_vha, 0x0102,
+                                    "%s Req que: %d inited.\n",
+                                    __func__, req->id);
                 }
         }
         return ret;
@@ -4397,19 +4412,22 @@ qla24xx_nvram_config(scsi_qla_host_t *vha)
         for (cnt = 0, chksum = 0; cnt < ha->nvram_size >> 2; cnt++)
                 chksum += le32_to_cpu(*dptr++);
 
-        DEBUG5(printk("scsi(%ld): Contents of NVRAM\n", vha->host_no));
-        DEBUG5(qla2x00_dump_buffer((uint8_t *)nv, ha->nvram_size));
+        ql_dbg(ql_dbg_init + ql_dbg_buffer, vha, 0x006a,
+            "Contents of NVRAM\n");
+        ql_dump_buffer(ql_dbg_init + ql_dbg_buffer, vha, 0x010d,
+            (uint8_t *)nv, ha->nvram_size);
 
         /* Bad NVRAM data, set defaults parameters. */
         if (chksum || nv->id[0] != 'I' || nv->id[1] != 'S' || nv->id[2] != 'P'
             || nv->id[3] != ' ' ||
             nv->nvram_version < __constant_cpu_to_le16(ICB_VERSION)) {
                 /* Reset NVRAM data. */
-                qla_printk(KERN_WARNING, ha, "Inconsistent NVRAM detected: "
-                    "checksum=0x%x id=%c version=0x%x.\n", chksum, nv->id[0],
-                    le16_to_cpu(nv->nvram_version));
-                qla_printk(KERN_WARNING, ha, "Falling back to functioning (yet "
-                    "invalid -- WWPN) defaults.\n");
+                ql_log(ql_log_warn, vha, 0x006b,
+                    "Inconisistent NVRAM detected: checksum=0x%x id=%c "
+                    "version=0x%x.\n", chksum, nv->id[0], nv->nvram_version);
+                ql_log(ql_log_warn, vha, 0x006c,
+                    "Falling back to functioning (yet invalid -- WWPN) "
+                    "defaults.\n");
 
                 /*
                  * Set default initialization control block.
@@ -4587,10 +4605,7 @@ qla24xx_nvram_config(scsi_qla_host_t *vha)
         if (ha->zio_mode != QLA_ZIO_DISABLED) {
                 ha->zio_mode = QLA_ZIO_MODE_6;
 
-                DEBUG2(printk("scsi(%ld): ZIO mode %d enabled; timer delay "
-                    "(%d us).\n", vha->host_no, ha->zio_mode,
-                    ha->zio_timer * 100));
-                qla_printk(KERN_INFO, ha,
+                ql_log(ql_log_info, vha, 0x006f,
                     "ZIO mode %d enabled; timer delay (%d us).\n",
                     ha->zio_mode, ha->zio_timer * 100);
 
@@ -4601,8 +4616,8 @@ qla24xx_nvram_config(scsi_qla_host_t *vha)
         }
 
         if (rval) {
-                DEBUG2_3(printk(KERN_WARNING
-                    "scsi(%ld): NVRAM configuration failed!\n", vha->host_no));
+                ql_log(ql_log_warn, vha, 0x0070,
+                    "NVRAM configuration failed.\n");
         }
         return (rval);
 }
@@ -4620,8 +4635,8 @@ qla24xx_load_risc_flash(scsi_qla_host_t *vha, uint32_t *srisc_addr,
         struct qla_hw_data *ha = vha->hw;
         struct req_que *req = ha->req_q_map[0];
 
-        qla_printk(KERN_INFO, ha,
-            "FW: Loading from flash (%x)...\n", faddr);
+        ql_dbg(ql_dbg_init, vha, 0x008b,
+            "Loading firmware from flash (%x).\n", faddr);
 
         rval = QLA_SUCCESS;
 
@@ -4637,11 +4652,12 @@ qla24xx_load_risc_flash(scsi_qla_host_t *vha, uint32_t *srisc_addr,
             dcode[2] == 0xffffffff && dcode[3] == 0xffffffff) ||
             (dcode[0] == 0 && dcode[1] == 0 && dcode[2] == 0 &&
                 dcode[3] == 0)) {
-                qla_printk(KERN_WARNING, ha,
-                    "Unable to verify integrity of flash firmware image!\n");
-                qla_printk(KERN_WARNING, ha,
-                    "Firmware data: %08x %08x %08x %08x!\n", dcode[0],
-                    dcode[1], dcode[2], dcode[3]);
+                ql_log(ql_log_fatal, vha, 0x008c,
+                    "Unable to verify the integrity of flash firmware "
+                    "image.\n");
+                ql_log(ql_log_fatal, vha, 0x008d,
+                    "Firmware data: %08x %08x %08x %08x.\n",
+                    dcode[0], dcode[1], dcode[2], dcode[3]);
 
                 return QLA_FUNCTION_FAILED;
         }
@@ -4660,9 +4676,10 @@ qla24xx_load_risc_flash(scsi_qla_host_t *vha, uint32_t *srisc_addr,
                         if (dlen > risc_size)
                                 dlen = risc_size;
 
-                        DEBUG7(printk("scsi(%ld): Loading risc segment@ risc "
-                            "addr %x, number of dwords 0x%x, offset 0x%x.\n",
-                            vha->host_no, risc_addr, dlen, faddr));
+                        ql_dbg(ql_dbg_init, vha, 0x008e,
+                            "Loading risc segment@ risc addr %x "
+                            "number of dwords 0x%x offset 0x%x.\n",
+                            risc_addr, dlen, faddr);
 
                         qla24xx_read_flash_data(vha, dcode, faddr, dlen);
                         for (i = 0; i < dlen; i++)
@@ -4671,12 +4688,9 @@ qla24xx_load_risc_flash(scsi_qla_host_t *vha, uint32_t *srisc_addr,
                         rval = qla2x00_load_ram(vha, req->dma, risc_addr,
                             dlen);
                         if (rval) {
-                                DEBUG(printk("scsi(%ld):[ERROR] Failed to load "
-                                    "segment %d of firmware\n", vha->host_no,
-                                    fragment));
-                                qla_printk(KERN_WARNING, ha,
-                                    "[ERROR] Failed to load segment %d of "
-                                    "firmware\n", fragment);
+                                ql_log(ql_log_fatal, vha, 0x008f,
+                                    "Failed to load segment %d of firmware.\n",
+                                    fragment);
                                 break;
                         }
 
@@ -4709,9 +4723,10 @@ qla2x00_load_risc(scsi_qla_host_t *vha, uint32_t *srisc_addr)
         /* Load firmware blob. */
         blob = qla2x00_request_firmware(vha);
         if (!blob) {
-                qla_printk(KERN_ERR, ha, "Firmware image unavailable.\n");
-                qla_printk(KERN_ERR, ha, "Firmware images can be retrieved "
-                    "from: " QLA_FW_URL ".\n");
+                ql_log(ql_log_info, vha, 0x0083,
+                    "Fimware image unavailable.\n");
+                ql_log(ql_log_info, vha, 0x0084,
+                    "Firmware images can be retrieved from: "QLA_FW_URL ".\n");
                 return QLA_FUNCTION_FAILED;
         }
 
@@ -4724,8 +4739,8 @@ qla2x00_load_risc(scsi_qla_host_t *vha, uint32_t *srisc_addr)
 
         /* Validate firmware image by checking version. */
         if (blob->fw->size < 8 * sizeof(uint16_t)) {
-                qla_printk(KERN_WARNING, ha,
-                    "Unable to verify integrity of firmware image (%Zd)!\n",
+                ql_log(ql_log_fatal, vha, 0x0085,
+                    "Unable to verify integrity of firmware image (%Zd).\n",
                     blob->fw->size);
                 goto fail_fw_integrity;
         }
@@ -4734,11 +4749,11 @@ qla2x00_load_risc(scsi_qla_host_t *vha, uint32_t *srisc_addr)
         if ((wcode[0] == 0xffff && wcode[1] == 0xffff && wcode[2] == 0xffff &&
             wcode[3] == 0xffff) || (wcode[0] == 0 && wcode[1] == 0 &&
                 wcode[2] == 0 && wcode[3] == 0)) {
-                qla_printk(KERN_WARNING, ha,
-                    "Unable to verify integrity of firmware image!\n");
-                qla_printk(KERN_WARNING, ha,
-                    "Firmware data: %04x %04x %04x %04x!\n", wcode[0],
-                    wcode[1], wcode[2], wcode[3]);
+                ql_log(ql_log_fatal, vha, 0x0086,
+                    "Unable to verify integrity of firmware image.\n");
+                ql_log(ql_log_fatal, vha, 0x0087,
+                    "Firmware data: %04x %04x %04x %04x.\n",
+                    wcode[0], wcode[1], wcode[2], wcode[3]);
                 goto fail_fw_integrity;
         }
 
@@ -4751,9 +4766,9 @@ qla2x00_load_risc(scsi_qla_host_t *vha, uint32_t *srisc_addr)
                 /* Validate firmware image size. */
                 fwclen += risc_size * sizeof(uint16_t);
                 if (blob->fw->size < fwclen) {
-                        qla_printk(KERN_WARNING, ha,
+                        ql_log(ql_log_fatal, vha, 0x0088,
                             "Unable to verify integrity of firmware image "
-                            "(%Zd)!\n", blob->fw->size);
+                            "(%Zd).\n", blob->fw->size);
                         goto fail_fw_integrity;
                 }
 
@@ -4762,10 +4777,9 @@ qla2x00_load_risc(scsi_qla_host_t *vha, uint32_t *srisc_addr)
                         wlen = (uint16_t)(ha->fw_transfer_size >> 1);
                         if (wlen > risc_size)
                                 wlen = risc_size;
-
-                        DEBUG7(printk("scsi(%ld): Loading risc segment@ risc "
-                            "addr %x, number of words 0x%x.\n", vha->host_no,
-                            risc_addr, wlen));
+                        ql_dbg(ql_dbg_init, vha, 0x0089,
+                            "Loading risc segment@ risc addr %x number of "
+                            "words 0x%x.\n", risc_addr, wlen);
 
                         for (i = 0; i < wlen; i++)
                                 wcode[i] = swab16(fwcode[i]);
@@ -4773,12 +4787,9 @@ qla2x00_load_risc(scsi_qla_host_t *vha, uint32_t *srisc_addr)
                         rval = qla2x00_load_ram(vha, req->dma, risc_addr,
                             wlen);
                         if (rval) {
-                                DEBUG(printk("scsi(%ld):[ERROR] Failed to load "
-                                    "segment %d of firmware\n", vha->host_no,
-                                    fragment));
-                                qla_printk(KERN_WARNING, ha,
-                                    "[ERROR] Failed to load segment %d of "
-                                    "firmware\n", fragment);
+                                ql_log(ql_log_fatal, vha, 0x008a,
+                                    "Failed to load segment %d of firmware.\n",
+                                    fragment);
                                 break;
                         }
 
@@ -4814,15 +4825,17 @@ qla24xx_load_risc_blob(scsi_qla_host_t *vha, uint32_t *srisc_addr)
         /* Load firmware blob. */
         blob = qla2x00_request_firmware(vha);
         if (!blob) {
-                qla_printk(KERN_ERR, ha, "Firmware image unavailable.\n");
-                qla_printk(KERN_ERR, ha, "Firmware images can be retrieved "
-                    "from: " QLA_FW_URL ".\n");
+                ql_log(ql_log_warn, vha, 0x0090,
+                    "Fimware image unavailable.\n");
+                ql_log(ql_log_warn, vha, 0x0091,
+                    "Firmware images can be retrieved from: "
+                    QLA_FW_URL ".\n");
 
                 return QLA_FUNCTION_FAILED;
         }
 
-        qla_printk(KERN_INFO, ha,
-            "FW: Loading via request-firmware...\n");
+        ql_log(ql_log_info, vha, 0x0092,
+            "Loading via request-firmware.\n");
 
         rval = QLA_SUCCESS;
 
@@ -4834,8 +4847,8 @@ qla24xx_load_risc_blob(scsi_qla_host_t *vha, uint32_t *srisc_addr)
 
         /* Validate firmware image by checking version. */
         if (blob->fw->size < 8 * sizeof(uint32_t)) {
-                qla_printk(KERN_WARNING, ha,
-                    "Unable to verify integrity of firmware image (%Zd)!\n",
+                ql_log(ql_log_fatal, vha, 0x0093,
+                    "Unable to verify integrity of firmware image (%Zd).\n",
                     blob->fw->size);
                 goto fail_fw_integrity;
         }
@@ -4845,11 +4858,12 @@ qla24xx_load_risc_blob(scsi_qla_host_t *vha, uint32_t *srisc_addr)
             dcode[2] == 0xffffffff && dcode[3] == 0xffffffff) ||
             (dcode[0] == 0 && dcode[1] == 0 && dcode[2] == 0 &&
                 dcode[3] == 0)) {
-                qla_printk(KERN_WARNING, ha,
-                    "Unable to verify integrity of firmware image!\n");
-                qla_printk(KERN_WARNING, ha,
-                    "Firmware data: %08x %08x %08x %08x!\n", dcode[0],
-                    dcode[1], dcode[2], dcode[3]);
+                ql_log(ql_log_fatal, vha, 0x0094,
+                    "Unable to verify integrity of firmware image (%Zd).\n",
+                    blob->fw->size);
+                ql_log(ql_log_fatal, vha, 0x0095,
+                    "Firmware data: %08x %08x %08x %08x.\n",
+                    dcode[0], dcode[1], dcode[2], dcode[3]);
                 goto fail_fw_integrity;
         }
 
@@ -4861,9 +4875,9 @@ qla24xx_load_risc_blob(scsi_qla_host_t *vha, uint32_t *srisc_addr)
                 /* Validate firmware image size. */
                 fwclen += risc_size * sizeof(uint32_t);
                 if (blob->fw->size < fwclen) {
-                        qla_printk(KERN_WARNING, ha,
+                        ql_log(ql_log_fatal, vha, 0x0096,
                             "Unable to verify integrity of firmware image "
-                            "(%Zd)!\n", blob->fw->size);
+                            "(%Zd).\n", blob->fw->size);
 
                         goto fail_fw_integrity;
                 }
@@ -4874,9 +4888,9 @@ qla24xx_load_risc_blob(scsi_qla_host_t *vha, uint32_t *srisc_addr)
                         if (dlen > risc_size)
                                 dlen = risc_size;
 
-                        DEBUG7(printk("scsi(%ld): Loading risc segment@ risc "
-                            "addr %x, number of dwords 0x%x.\n", vha->host_no,
-                            risc_addr, dlen));
+                        ql_dbg(ql_dbg_init, vha, 0x0097,
+                            "Loading risc segment@ risc addr %x "
+                            "number of dwords 0x%x.\n", risc_addr, dlen);
 
                         for (i = 0; i < dlen; i++)
                                 dcode[i] = swab32(fwcode[i]);
@@ -4884,12 +4898,9 @@ qla24xx_load_risc_blob(scsi_qla_host_t *vha, uint32_t *srisc_addr)
                         rval = qla2x00_load_ram(vha, req->dma, risc_addr,
                             dlen);
                         if (rval) {
-                                DEBUG(printk("scsi(%ld):[ERROR] Failed to load "
-                                    "segment %d of firmware\n", vha->host_no,
-                                    fragment));
-                                qla_printk(KERN_WARNING, ha,
-                                    "[ERROR] Failed to load segment %d of "
-                                    "firmware\n", fragment);
+                                ql_log(ql_log_fatal, vha, 0x0098,
+                                    "Failed to load segment %d of firmware.\n",
+                                    fragment);
                                 break;
                         }
 
@@ -4953,14 +4964,13 @@ try_blob_fw:
         if (rval == QLA_SUCCESS || !ha->flt_region_gold_fw)
                 return rval;
 
-        qla_printk(KERN_ERR, ha,
-            "FW: Attempting to fallback to golden firmware...\n");
+        ql_log(ql_log_info, vha, 0x0099,
+            "Attempting to fallback to golden firmware.\n");
         rval = qla24xx_load_risc_flash(vha, srisc_addr, ha->flt_region_gold_fw);
         if (rval != QLA_SUCCESS)
                 return rval;
 
-        qla_printk(KERN_ERR, ha,
-            "FW: Please update operational firmware...\n");
+        ql_log(ql_log_info, vha, 0x009a, "Update operational firmware.\n");
         ha->flags.running_gold_fw = 1;
 
         return rval;
@@ -4987,8 +4997,8 @@ qla2x00_try_to_stop_firmware(scsi_qla_host_t *vha)
                         continue;
                 if (qla2x00_setup_chip(vha) != QLA_SUCCESS)
                         continue;
-                qla_printk(KERN_INFO, ha,
-                    "Attempting retry of stop-firmware command...\n");
+                ql_log(ql_log_info, vha, 0x8015,
+                    "Attempting retry of stop-firmware command.\n");
                 ret = qla2x00_stop_firmware(vha);
         }
 }
@@ -5023,10 +5033,10 @@ qla24xx_configure_vhba(scsi_qla_host_t *vha)
         /* Login to SNS first */
         ha->isp_ops->fabric_login(vha, NPH_SNS, 0xff, 0xff, 0xfc, mb, BIT_1);
         if (mb[0] != MBS_COMMAND_COMPLETE) {
-                DEBUG15(qla_printk(KERN_INFO, ha,
-                    "Failed SNS login: loop_id=%x mb[0]=%x mb[1]=%x "
-                    "mb[2]=%x mb[6]=%x mb[7]=%x\n", NPH_SNS,
-                    mb[0], mb[1], mb[2], mb[6], mb[7]));
+                ql_dbg(ql_dbg_init, vha, 0x0103,
+                    "Failed SNS login: loop_id=%x mb[0]=%x mb[1]=%x mb[2]=%x "
+                    "mb[6]=%x mb[7]=%x.\n",
+                    NPH_SNS, mb[0], mb[1], mb[2], mb[6], mb[7]);
                 return (QLA_FUNCTION_FAILED);
         }
 
@@ -5146,19 +5156,23 @@ qla81xx_nvram_config(scsi_qla_host_t *vha)
         for (cnt = 0, chksum = 0; cnt < ha->nvram_size >> 2; cnt++)
                 chksum += le32_to_cpu(*dptr++);
 
-        DEBUG5(printk("scsi(%ld): Contents of NVRAM\n", vha->host_no));
-        DEBUG5(qla2x00_dump_buffer((uint8_t *)nv, ha->nvram_size));
+        ql_dbg(ql_dbg_init + ql_dbg_buffer, vha, 0x0111,
+            "Contents of NVRAM:\n");
+        ql_dump_buffer(ql_dbg_init + ql_dbg_buffer, vha, 0x0112,
+            (uint8_t *)nv, ha->nvram_size);
 
         /* Bad NVRAM data, set defaults parameters. */
         if (chksum || nv->id[0] != 'I' || nv->id[1] != 'S' || nv->id[2] != 'P'
             || nv->id[3] != ' ' ||
             nv->nvram_version < __constant_cpu_to_le16(ICB_VERSION)) {
                 /* Reset NVRAM data. */
-                qla_printk(KERN_WARNING, ha, "Inconsistent NVRAM detected: "
-                    "checksum=0x%x id=%c version=0x%x.\n", chksum, nv->id[0],
+                ql_log(ql_log_info, vha, 0x0073,
+                    "Inconisistent NVRAM detected: checksum=0x%x id=%c "
+                    "version=0x%x.\n", chksum, nv->id[0],
                     le16_to_cpu(nv->nvram_version));
-                qla_printk(KERN_WARNING, ha, "Falling back to functioning (yet "
-                    "invalid -- WWPN) defaults.\n");
+                ql_log(ql_log_info, vha, 0x0074,
+                    "Falling back to functioning (yet invalid -- WWPN) "
+                    "defaults.\n");
 
                 /*
                  * Set default initialization control block.
@@ -5350,12 +5364,10 @@ qla81xx_nvram_config(scsi_qla_host_t *vha)
         if (ha->zio_mode != QLA_ZIO_DISABLED) {
                 ha->zio_mode = QLA_ZIO_MODE_6;
 
-                DEBUG2(printk("scsi(%ld): ZIO mode %d enabled; timer delay "
-                    "(%d us).\n", vha->host_no, ha->zio_mode,
-                    ha->zio_timer * 100));
-                qla_printk(KERN_INFO, ha,
+                ql_log(ql_log_info, vha, 0x0075,
                     "ZIO mode %d enabled; timer delay (%d us).\n",
-                    ha->zio_mode, ha->zio_timer * 100);
+                    ha->zio_mode,
+                    ha->zio_timer * 100);
 
                 icb->firmware_options_2 |= cpu_to_le32(
                     (uint32_t)ha->zio_mode);
@@ -5364,8 +5376,8 @@ qla81xx_nvram_config(scsi_qla_host_t *vha)
         }
 
         if (rval) {
-                DEBUG2_3(printk(KERN_WARNING
-                    "scsi(%ld): NVRAM configuration failed!\n", vha->host_no));
+                ql_log(ql_log_warn, vha, 0x0076,
+                    "NVRAM configuration failed.\n");
         }
         return (rval);
 }
@@ -5388,9 +5400,8 @@ qla82xx_restart_isp(scsi_qla_host_t *vha)
 
                 status = qla2x00_fw_ready(vha);
                 if (!status) {
-                        qla_printk(KERN_INFO, ha,
-                        "%s(): Start configure loop, "
-                        "status = %d\n", __func__, status);
+                        ql_log(ql_log_info, vha, 0x803c,
+                            "Start configure loop, status =%d.\n", status);
 
                         /* Issue a marker after FW becomes ready. */
                         qla2x00_marker(vha, req, rsp, 0, 0, MK_SYNC_ALL);
@@ -5412,9 +5423,8 @@ qla82xx_restart_isp(scsi_qla_host_t *vha)
                 if ((vha->device_flags & DFLG_NO_CABLE))
                         status = 0;
 
-                qla_printk(KERN_INFO, ha,
-                        "%s(): Configure loop done, status = 0x%x\n",
-                        __func__, status);
+                ql_log(ql_log_info, vha, 0x803d,
+                    "Configure loop done, status = 0x%x.\n", status);
         }
 
         if (!status) {
@@ -5450,9 +5460,9 @@ qla82xx_restart_isp(scsi_qla_host_t *vha)
                             ha->fce_dma, ha->fce_bufs, ha->fce_mb,
                             &ha->fce_bufs);
                         if (rval) {
-                                qla_printk(KERN_WARNING, ha,
-                                    "Unable to reinitialize FCE "
-                                    "(%d).\n", rval);
+                                ql_log(ql_log_warn, vha, 0x803e,
+                                    "Unable to reinitialize FCE (%d).\n",
+                                    rval);
                                 ha->flags.fce_enabled = 0;
                         }
                 }
@@ -5462,17 +5472,16 @@ qla82xx_restart_isp(scsi_qla_host_t *vha)
                         rval = qla2x00_enable_eft_trace(vha,
                             ha->eft_dma, EFT_NUM_BUFFERS);
                         if (rval) {
-                                qla_printk(KERN_WARNING, ha,
-                                    "Unable to reinitialize EFT "
-                                    "(%d).\n", rval);
+                                ql_log(ql_log_warn, vha, 0x803f,
+                                    "Unable to reinitialize EFT (%d).\n",
+                                    rval);
                         }
                 }
         }
 
         if (!status) {
-                DEBUG(printk(KERN_INFO
-                        "qla82xx_restart_isp(%ld): succeeded.\n",
-                        vha->host_no));
+                ql_dbg(ql_dbg_taskm, vha, 0x8040,
+                    "qla82xx_restart_isp succeeded.\n");
 
                 spin_lock_irqsave(&ha->vport_slock, flags);
                 list_for_each_entry(vp, &ha->vp_list, list) {
@@ -5489,8 +5498,8 @@ qla82xx_restart_isp(scsi_qla_host_t *vha)
                 spin_unlock_irqrestore(&ha->vport_slock, flags);
 
         } else {
-                qla_printk(KERN_INFO, ha,
-                        "qla82xx_restart_isp: **** FAILED ****\n");
+                ql_log(ql_log_warn, vha, 0x8041,
+                    "qla82xx_restart_isp **** FAILED ****.\n");
         }
 
         return status;
@@ -5640,9 +5649,8 @@ qla24xx_update_fcport_fcp_prio(scsi_qla_host_t *vha, fc_port_t *fcport)
         if (ret == QLA_SUCCESS)
                 fcport->fcp_prio = priority;
         else
-                DEBUG2(printk(KERN_WARNING
-                        "scsi(%ld): Unable to activate fcp priority, "
-                        " ret=0x%x\n", vha->host_no, ret));
+                ql_dbg(ql_dbg_user, vha, 0x704f,
+                    "Unable to activate fcp priority, ret=0x%x.\n", ret);
 
         return  ret;
 }
diff --git a/drivers/scsi/qla2xxx/qla_inline.h b/drivers/scsi/qla2xxx/qla_inline.h
index 4c8167e11f69..d2e904bc21c0 100644
--- a/drivers/scsi/qla2xxx/qla_inline.h
+++ b/drivers/scsi/qla2xxx/qla_inline.h
@@ -94,11 +94,11 @@ qla2x00_set_fcport_state(fc_port_t *fcport, int 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,
+                ql_dbg(ql_dbg_disc, fcport->vha, 0x207d,
+                    "FCPort state transitioned from %s to %s - "
+                    "portid=%02x%02x%02x.\n",
                     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));
+                    fcport->d_id.b.al_pa);
         }
 }
diff --git a/drivers/scsi/qla2xxx/qla_iocb.c b/drivers/scsi/qla2xxx/qla_iocb.c
index 7bac3cd109d6..49d6906af886 100644
--- a/drivers/scsi/qla2xxx/qla_iocb.c
+++ b/drivers/scsi/qla2xxx/qla_iocb.c
@@ -150,7 +150,8 @@ qla24xx_configure_prot_mode(srb_t *sp, uint16_t *fw_prot_opts)
 
         /* We only support T10 DIF right now */
         if (guard != SHOST_DIX_GUARD_CRC) {
-                DEBUG2(printk(KERN_ERR "Unsupported guard: %d\n", guard));
+                ql_dbg(ql_dbg_io, sp->fcport->vha, 0x3007,
+                    "Unsupported guard: %d for cmd=%p.\n", guard, sp->cmd);
                 return 0;
         }
 
@@ -343,9 +344,10 @@ qla2x00_start_scsi(srb_t *sp)
 
         /* Send marker if required */
         if (vha->marker_needed != 0) {
-                if (qla2x00_marker(vha, req, rsp, 0, 0, MK_SYNC_ALL)
-                                                        != QLA_SUCCESS)
+                if (qla2x00_marker(vha, req, rsp, 0, 0, MK_SYNC_ALL) !=
+                    QLA_SUCCESS) {
                         return (QLA_FUNCTION_FAILED);
+                }
                 vha->marker_needed = 0;
         }
 
@@ -490,8 +492,8 @@ __qla2x00_marker(struct scsi_qla_host *vha, struct req_que *req,
         mrk24 = NULL;
         mrk = (mrk_entry_t *)qla2x00_alloc_iocbs(vha, 0);
         if (mrk == NULL) {
-                DEBUG2_3(printk("%s(%ld): failed to allocate Marker IOCB.\n",
-                    __func__, base_vha->host_no));
+                ql_log(ql_log_warn, base_vha, 0x3026,
+                    "Failed to allocate Marker IOCB.\n");
 
                 return (QLA_FUNCTION_FAILED);
         }
@@ -547,9 +549,10 @@ qla2x00_isp_cmd(struct scsi_qla_host *vha, struct req_que *req)
         device_reg_t __iomem *reg = ISP_QUE_REG(ha, req->id);
         struct device_reg_2xxx __iomem *ioreg = &ha->iobase->isp;
 
-        DEBUG5(printk("%s(): IOCB data:\n", __func__));
-        DEBUG5(qla2x00_dump_buffer(
-            (uint8_t *)req->ring_ptr, REQUEST_ENTRY_SIZE));
+        ql_dbg(ql_dbg_io + ql_dbg_buffer, vha, 0x302d,
+            "IOCB data:\n");
+        ql_dump_buffer(ql_dbg_io + ql_dbg_buffer, vha, 0x302e,
+            (uint8_t *)req->ring_ptr, REQUEST_ENTRY_SIZE);
 
         /* Adjust ring index. */
         req->ring_index++;
@@ -604,7 +607,7 @@ qla2x00_isp_cmd(struct scsi_qla_host *vha, struct req_que *req)
  * Returns the number of IOCB entries needed to store @dsds.
  */
 inline uint16_t
-qla24xx_calc_iocbs(uint16_t dsds)
+qla24xx_calc_iocbs(scsi_qla_host_t *vha, uint16_t dsds)
 {
         uint16_t iocbs;
 
@@ -614,8 +617,6 @@ qla24xx_calc_iocbs(uint16_t dsds)
                 if ((dsds - 1) % 5)
                         iocbs++;
         }
-        DEBUG3(printk(KERN_DEBUG "%s(): Required PKT(s) = %d\n",
-            __func__, iocbs));
         return iocbs;
 }
 
@@ -712,6 +713,7 @@ qla24xx_set_t10dif_tags(struct scsi_cmnd *cmd, struct fw_dif_context *pkt,
     unsigned int protcnt)
 {
         struct sd_dif_tuple *spt;
+        scsi_qla_host_t *vha = shost_priv(cmd->device->host);
         unsigned char op = scsi_get_prot_op(cmd);
 
         switch (scsi_get_prot_type(cmd)) {
@@ -768,9 +770,9 @@ qla24xx_set_t10dif_tags(struct scsi_cmnd *cmd, struct fw_dif_context *pkt,
                     op == SCSI_PROT_WRITE_PASS)) {
                         spt = page_address(sg_page(scsi_prot_sglist(cmd))) +
                             scsi_prot_sglist(cmd)[0].offset;
-                        DEBUG18(printk(KERN_DEBUG
-                            "%s(): LBA from user %p, lba = 0x%x\n",
-                            __func__, spt, (int)spt->ref_tag));
+                        ql_dbg(ql_dbg_io, vha, 0x3008,
+                            "LBA from user %p, lba = 0x%x for cmd=%p.\n",
+                            spt, (int)spt->ref_tag, cmd);
                         pkt->ref_tag = swab32(spt->ref_tag);
                         pkt->app_tag_mask[0] = 0x0;
                         pkt->app_tag_mask[1] = 0x0;
@@ -789,11 +791,11 @@ qla24xx_set_t10dif_tags(struct scsi_cmnd *cmd, struct fw_dif_context *pkt,
                 break;
         }
 
-        DEBUG18(printk(KERN_DEBUG
-            "%s(): Setting protection Tags: (BIG) ref tag = 0x%x,"
-            " app tag = 0x%x, prot SG count %d , cmd lba 0x%x,"
-            " prot_type=%u\n", __func__, pkt->ref_tag, pkt->app_tag, protcnt,
-            (int)scsi_get_lba(cmd), scsi_get_prot_type(cmd)));
+        ql_dbg(ql_dbg_io, vha, 0x3009,
+            "Setting protection Tags: (BIG) ref tag = 0x%x, app tag = 0x%x, "
+            "prot SG count %d, cmd lba 0x%x, prot_type=%u cmd=%p.\n",
+            pkt->ref_tag, pkt->app_tag, protcnt, (int)scsi_get_lba(cmd),
+            scsi_get_prot_type(cmd), cmd);
 }
 
 
@@ -809,6 +811,7 @@ qla24xx_walk_and_build_sglist(struct qla_hw_data *ha, srb_t *sp, uint32_t *dsd,
         uint32_t *cur_dsd = dsd;
         int     i;
         uint16_t        used_dsds = tot_dsds;
+        scsi_qla_host_t *vha = shost_priv(sp->cmd->device->host);
 
         uint8_t         *cp;
 
@@ -853,9 +856,10 @@ qla24xx_walk_and_build_sglist(struct qla_hw_data *ha, srb_t *sp, uint32_t *dsd,
                         cur_dsd = (uint32_t *)next_dsd;
                 }
                 sle_dma = sg_dma_address(sg);
-                DEBUG18(printk("%s(): %p, sg entry %d - addr =0x%x 0x%x,"
-                    " len =%d\n", __func__ , cur_dsd, i, LSD(sle_dma),
-                    MSD(sle_dma), sg_dma_len(sg)));
+                ql_dbg(ql_dbg_io, vha, 0x300a,
+                    "sg entry %d - addr=0x%x 0x%x, " "len=%d for cmd=%p.\n",
+                    cur_dsd, i, LSD(sle_dma), MSD(sle_dma), sg_dma_len(sg),
+                    sp->cmd);
                 *cur_dsd++ = cpu_to_le32(LSD(sle_dma));
                 *cur_dsd++ = cpu_to_le32(MSD(sle_dma));
                 *cur_dsd++ = cpu_to_le32(sg_dma_len(sg));
@@ -863,8 +867,8 @@ qla24xx_walk_and_build_sglist(struct qla_hw_data *ha, srb_t *sp, uint32_t *dsd,
 
                 if (scsi_get_prot_op(sp->cmd) == SCSI_PROT_WRITE_PASS) {
                         cp = page_address(sg_page(sg)) + sg->offset;
-                        DEBUG18(printk("%s(): User Data buffer= %p:\n",
-                            __func__ , cp));
+                        ql_dbg(ql_dbg_io, vha, 0x300b,
+                            "User data buffer=%p for cmd=%p.\n", cp, sp->cmd);
                 }
         }
         /* Null termination */
@@ -888,7 +892,7 @@ qla24xx_walk_and_build_prot_sglist(struct qla_hw_data *ha, srb_t *sp,
         struct scsi_cmnd *cmd;
         uint32_t *cur_dsd = dsd;
         uint16_t        used_dsds = tot_dsds;
-
+        scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
         uint8_t         *cp;
 
 
@@ -935,10 +939,11 @@ qla24xx_walk_and_build_prot_sglist(struct qla_hw_data *ha, srb_t *sp,
                 }
                 sle_dma = sg_dma_address(sg);
                 if (scsi_get_prot_op(sp->cmd) == SCSI_PROT_WRITE_PASS) {
-                        DEBUG18(printk(KERN_DEBUG
-                            "%s(): %p, sg entry %d - addr =0x%x"
-                            "0x%x, len =%d\n", __func__ , cur_dsd, i,
-                            LSD(sle_dma), MSD(sle_dma), sg_dma_len(sg)));
+                        ql_dbg(ql_dbg_io, vha, 0x3027,
+                            "%s(): %p, sg_entry %d - "
+                            "addr=0x%x0x%x, len=%d.\n",
+                            __func__, cur_dsd, i,
+                            LSD(sle_dma), MSD(sle_dma), sg_dma_len(sg));
                 }
                 *cur_dsd++ = cpu_to_le32(LSD(sle_dma));
                 *cur_dsd++ = cpu_to_le32(MSD(sle_dma));
@@ -946,8 +951,9 @@ qla24xx_walk_and_build_prot_sglist(struct qla_hw_data *ha, srb_t *sp,
 
                 if (scsi_get_prot_op(sp->cmd) == SCSI_PROT_WRITE_PASS) {
                         cp = page_address(sg_page(sg)) + sg->offset;
-                        DEBUG18(printk("%s(): Protection Data buffer = %p:\n",
-                            __func__ , cp));
+                        ql_dbg(ql_dbg_io, vha, 0x3028,
+                            "%s(): Protection Data buffer = %p.\n", __func__,
+                            cp);
                 }
                 avail_dsds--;
         }
@@ -996,22 +1002,16 @@ qla24xx_build_scsi_crc_2_iocbs(srb_t *sp, struct cmd_type_crc_2 *cmd_pkt,
         *((uint32_t *)(&cmd_pkt->entry_type)) =
             __constant_cpu_to_le32(COMMAND_TYPE_CRC_2);
 
+        vha = sp->fcport->vha;
+        ha = vha->hw;
+
         /* No data transfer */
         data_bytes = scsi_bufflen(cmd);
         if (!data_bytes || cmd->sc_data_direction == DMA_NONE) {
-                DEBUG18(printk(KERN_INFO "%s: Zero data bytes or DMA-NONE %d\n",
-                    __func__, data_bytes));
                 cmd_pkt->byte_count = __constant_cpu_to_le32(0);
                 return QLA_SUCCESS;
         }
 
-        vha = sp->fcport->vha;
-        ha = vha->hw;
-
-        DEBUG18(printk(KERN_DEBUG
-            "%s(%ld): Executing cmd sp %p, prot_op=%u.\n", __func__,
-            vha->host_no, sp, scsi_get_prot_op(sp->cmd)));
-
         cmd_pkt->vp_index = sp->fcport->vp_idx;
 
         /* Set transfer direction */
@@ -1056,8 +1056,6 @@ qla24xx_build_scsi_crc_2_iocbs(srb_t *sp, struct cmd_type_crc_2 *cmd_pkt,
 
         /* Determine SCSI command length -- align to 4 byte boundary */
         if (cmd->cmd_len > 16) {
-                DEBUG18(printk(KERN_INFO "%s(): **** SCSI CMD > 16\n",
-                    __func__));
                 additional_fcpcdb_len = cmd->cmd_len - 16;
                 if ((cmd->cmd_len % 4) != 0) {
                         /* SCSI cmd > 16 bytes must be multiple of 4 */
@@ -1108,11 +1106,6 @@ qla24xx_build_scsi_crc_2_iocbs(srb_t *sp, struct cmd_type_crc_2 *cmd_pkt,
 
         cmd_pkt->fcp_rsp_dseg_len = 0; /* Let response come in status iocb */
 
-        DEBUG18(printk(KERN_INFO "%s(%ld): Total SG(s) Entries %d, Data"
-            "entries %d, data bytes %d, Protection entries %d\n",
-            __func__, vha->host_no, tot_dsds, (tot_dsds-tot_prot_dsds),
-            data_bytes, tot_prot_dsds));
-
         /* Compute dif len and adjust data len to incude protection */
         total_bytes = data_bytes;
         dif_bytes = 0;
@@ -1150,14 +1143,7 @@ qla24xx_build_scsi_crc_2_iocbs(srb_t *sp, struct cmd_type_crc_2 *cmd_pkt,
             additional_fcpcdb_len);
         *fcp_dl = htonl(total_bytes);
 
-        DEBUG18(printk(KERN_INFO "%s(%ld): dif bytes = 0x%x (%d), total bytes"
-            " = 0x%x (%d), dat block size =0x%x (%d)\n", __func__,
-            vha->host_no, dif_bytes, dif_bytes, total_bytes, total_bytes,
-            crc_ctx_pkt->blk_size, crc_ctx_pkt->blk_size));
-
         if (!data_bytes || cmd->sc_data_direction == DMA_NONE) {
-                DEBUG18(printk(KERN_INFO "%s: Zero data bytes or DMA-NONE %d\n",
-                    __func__, data_bytes));
                 cmd_pkt->byte_count = __constant_cpu_to_le32(0);
                 return QLA_SUCCESS;
         }
@@ -1182,8 +1168,6 @@ qla24xx_build_scsi_crc_2_iocbs(srb_t *sp, struct cmd_type_crc_2 *cmd_pkt,
         return QLA_SUCCESS;
 
 crc_queuing_error:
-        DEBUG18(qla_printk(KERN_INFO, ha,
-            "CMD sent FAILED crc_q error:sp = %p\n", sp));
         /* Cleanup will be performed by the caller */
 
         return QLA_FUNCTION_FAILED;
@@ -1225,8 +1209,8 @@ qla24xx_start_scsi(srb_t *sp)
 
         /* Send marker if required */
         if (vha->marker_needed != 0) {
-                if (qla2x00_marker(vha, req, rsp, 0, 0, MK_SYNC_ALL)
-                                                        != QLA_SUCCESS)
+                if (qla2x00_marker(vha, req, rsp, 0, 0, MK_SYNC_ALL) !=
+                    QLA_SUCCESS)
                         return QLA_FUNCTION_FAILED;
                 vha->marker_needed = 0;
         }
@@ -1243,8 +1227,9 @@ qla24xx_start_scsi(srb_t *sp)
                 if (!req->outstanding_cmds[handle])
                         break;
         }
-        if (index == MAX_OUTSTANDING_COMMANDS)
+        if (index == MAX_OUTSTANDING_COMMANDS) {
                 goto queuing_error;
+        }
 
         /* Map the sg table so we have an accurate count of sg entries needed */
         if (scsi_sg_count(cmd)) {
@@ -1256,8 +1241,7 @@ qla24xx_start_scsi(srb_t *sp)
                 nseg = 0;
 
         tot_dsds = nseg;
-
-        req_cnt = qla24xx_calc_iocbs(tot_dsds);
+        req_cnt = qla24xx_calc_iocbs(vha, tot_dsds);
         if (req->cnt < (req_cnt + 2)) {
                 cnt = RD_REG_DWORD_RELAXED(req->req_q_out);
 
@@ -1322,7 +1306,6 @@ qla24xx_start_scsi(srb_t *sp)
         /* Specify response queue number where completion should happen */
         cmd_pkt->entry_status = (uint8_t) rsp->id;
         wmb();
-
         /* Adjust ring index. */
         req->ring_index++;
         if (req->ring_index == req->length) {
@@ -1534,9 +1517,6 @@ queuing_error:
         /* Cleanup will be performed by the caller (queuecommand) */
 
         spin_unlock_irqrestore(&ha->hardware_lock, flags);
-
-        DEBUG18(qla_printk(KERN_INFO, ha,
-            "CMD sent FAILED SCSI prot_op:%02x\n", scsi_get_prot_op(cmd)));
         return QLA_FUNCTION_FAILED;
 }
 
@@ -1581,8 +1561,11 @@ qla2x00_alloc_iocbs(scsi_qla_host_t *vha, srb_t *sp)
                 if (!req->outstanding_cmds[handle])
                         break;
         }
-        if (index == MAX_OUTSTANDING_COMMANDS)
+        if (index == MAX_OUTSTANDING_COMMANDS) {
+                ql_log(ql_log_warn, vha, 0x700b,
+                    "No room on oustanding cmd array.\n");
                 goto queuing_error;
+        }
 
         /* Prep command array. */
         req->current_outstanding_cmd = handle;
@@ -1999,8 +1982,11 @@ qla2x00_start_sp(srb_t *sp)
         rval = QLA_FUNCTION_FAILED;
         spin_lock_irqsave(&ha->hardware_lock, flags);
         pkt = qla2x00_alloc_iocbs(sp->fcport->vha, sp);
-        if (!pkt)
+        if (!pkt) {
+                ql_log(ql_log_warn, sp->fcport->vha, 0x700c,
+                    "qla2x00_alloc_iocbs failed.\n");
                 goto done;
+        }
 
         rval = QLA_SUCCESS;
         switch (ctx->type) {
diff --git a/drivers/scsi/qla2xxx/qla_isr.c b/drivers/scsi/qla2xxx/qla_isr.c
index ae8e298746ba..b16b7725dee0 100644
--- a/drivers/scsi/qla2xxx/qla_isr.c
+++ b/drivers/scsi/qla2xxx/qla_isr.c
@@ -45,7 +45,7 @@ qla2100_intr_handler(int irq, void *dev_id)
         rsp = (struct rsp_que *) dev_id;
         if (!rsp) {
                 printk(KERN_INFO
-                    "%s(): NULL response queue pointer\n", __func__);
+                    "%s(): NULL response queue pointer.\n", __func__);
                 return (IRQ_NONE);
         }
 
@@ -91,9 +91,9 @@ qla2100_intr_handler(int irq, void *dev_id)
                                 qla2x00_async_event(vha, rsp, mb);
                         } else {
                                 /*EMPTY*/
-                                DEBUG2(printk("scsi(%ld): Unrecognized "
-                                    "interrupt type (%d).\n",
-                                    vha->host_no, mb[0]));
+                                ql_dbg(ql_dbg_async, vha, 0x5025,
+                                    "Unrecognized interrupt type (%d).\n",
+                                    mb[0]);
                         }
                         /* Release mailbox registers. */
                         WRT_REG_WORD(&reg->semaphore, 0);
@@ -142,7 +142,7 @@ qla2300_intr_handler(int irq, void *dev_id)
         rsp = (struct rsp_que *) dev_id;
         if (!rsp) {
                 printk(KERN_INFO
-                    "%s(): NULL response queue pointer\n", __func__);
+                    "%s(): NULL response queue pointer.\n", __func__);
                 return (IRQ_NONE);
         }
 
@@ -160,11 +160,13 @@ qla2300_intr_handler(int irq, void *dev_id)
 
                         hccr = RD_REG_WORD(&reg->hccr);
                         if (hccr & (BIT_15 | BIT_13 | BIT_11 | BIT_8))
-                                qla_printk(KERN_INFO, ha, "Parity error -- "
-                                    "HCCR=%x, Dumping firmware!\n", hccr);
+                                ql_log(ql_log_warn, vha, 0x5026,
+                                    "Parity error -- HCCR=%x, Dumping "
+                                    "firmware.\n", hccr);
                         else
-                                qla_printk(KERN_INFO, ha, "RISC paused -- "
-                                    "HCCR=%x, Dumping firmware!\n", hccr);
+                                ql_log(ql_log_warn, vha, 0x5027,
+                                    "RISC paused -- HCCR=%x, Dumping "
+                                    "firmware.\n", hccr);
 
                         /*
                          * Issue a "HARD" reset in order for the RISC
@@ -213,9 +215,8 @@ qla2300_intr_handler(int irq, void *dev_id)
                         qla2x00_async_event(vha, rsp, mb);
                         break;
                 default:
-                        DEBUG2(printk("scsi(%ld): Unrecognized interrupt type "
-                            "(%d).\n",
-                            vha->host_no, stat & 0xff));
+                        ql_dbg(ql_dbg_async, vha, 0x5028,
+                            "Unrecognized interrupt type (%d).\n", stat & 0xff);
                         break;
                 }
                 WRT_REG_WORD(&reg->hccr, HCCR_CLR_RISC_INT);
@@ -262,11 +263,11 @@ qla2x00_mbx_completion(scsi_qla_host_t *vha, uint16_t mb0)
         }
 
         if (ha->mcp) {
-                DEBUG3(printk("%s(%ld): Got mailbox completion. cmd=%x.\n",
-                    __func__, vha->host_no, ha->mcp->mb[0]));
+                ql_dbg(ql_dbg_async, vha, 0x5000,
+                    "Got mbx completion. cmd=%x.\n", ha->mcp->mb[0]);
         } else {
-                DEBUG2_3(printk("%s(%ld): MBX pointer ERROR!\n",
-                    __func__, vha->host_no));
+                ql_dbg(ql_dbg_async, vha, 0x5001,
+                    "MBX pointer ERROR.\n");
         }
 }
 
@@ -285,22 +286,24 @@ qla81xx_idc_event(scsi_qla_host_t *vha, uint16_t aen, uint16_t descr)
         for (cnt = 0; cnt < QLA_IDC_ACK_REGS; cnt++, wptr++)
                 mb[cnt] = RD_REG_WORD(wptr);
 
-        DEBUG2(printk("scsi(%ld): Inter-Driver Commucation %s -- "
-            "%04x %04x %04x %04x %04x %04x %04x.\n", vha->host_no,
-            event[aen & 0xff],
-            mb[0], mb[1], mb[2], mb[3], mb[4], mb[5], mb[6]));
+        ql_dbg(ql_dbg_async, vha, 0x5021,
+            "Inter-Driver Commucation %s -- "
+            "%04x %04x %04x %04x %04x %04x %04x.\n",
+            event[aen & 0xff], mb[0], mb[1], mb[2], mb[3],
+            mb[4], mb[5], mb[6]);
 
         /* Acknowledgement needed? [Notify && non-zero timeout]. */
         timeout = (descr >> 8) & 0xf;
         if (aen != MBA_IDC_NOTIFY || !timeout)
                 return;
 
-        DEBUG2(printk("scsi(%ld): Inter-Driver Commucation %s -- "
-            "ACK timeout=%d.\n", vha->host_no, event[aen & 0xff], timeout));
+        ql_dbg(ql_dbg_async, vha, 0x5022,
+            "Inter-Driver Commucation %s -- ACK timeout=%d.\n",
+            vha->host_no, event[aen & 0xff], timeout);
 
         rval = qla2x00_post_idc_ack_work(vha, mb);
         if (rval != QLA_SUCCESS)
-                qla_printk(KERN_WARNING, vha->hw,
+                ql_log(ql_log_warn, vha, 0x5023,
                     "IDC failed to post ACK.\n");
 }
 
@@ -393,15 +396,15 @@ skip_rio:
                 break;
 
         case MBA_RESET:                 /* Reset */
-                DEBUG2(printk("scsi(%ld): Asynchronous RESET.\n",
-                        vha->host_no));
+                ql_dbg(ql_dbg_async, vha, 0x5002,
+                    "Asynchronous RESET.\n");
 
                 set_bit(RESET_MARKER_NEEDED, &vha->dpc_flags);
                 break;
 
         case MBA_SYSTEM_ERR:            /* System Error */
                 mbx = IS_QLA81XX(ha) ? RD_REG_WORD(&reg24->mailbox7) : 0;
-                qla_printk(KERN_INFO, ha,
+                ql_log(ql_log_warn, vha, 0x5003,
                     "ISP System Error - mbx1=%xh mbx2=%xh mbx3=%xh "
                     "mbx7=%xh.\n", mb[1], mb[2], mb[3], mbx);
 
@@ -409,7 +412,7 @@ skip_rio:
 
                 if (IS_FWI2_CAPABLE(ha)) {
                         if (mb[1] == 0 && mb[2] == 0) {
-                                qla_printk(KERN_ERR, ha,
+                                ql_log(ql_log_fatal, vha, 0x5004,
                                     "Unrecoverable Hardware Error: adapter "
                                     "marked OFFLINE!\n");
                                 vha->flags.online = 0;
@@ -422,7 +425,7 @@ skip_rio:
                                 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
                         }
                 } else if (mb[1] == 0) {
-                        qla_printk(KERN_INFO, ha,
+                        ql_log(ql_log_fatal, vha, 0x5005,
                             "Unrecoverable Hardware Error: adapter marked "
                             "OFFLINE!\n");
                         vha->flags.online = 0;
@@ -431,31 +434,27 @@ skip_rio:
                 break;
 
         case MBA_REQ_TRANSFER_ERR:      /* Request Transfer Error */
-                DEBUG2(printk("scsi(%ld): ISP Request Transfer Error (%x).\n",
-                    vha->host_no, mb[1]));
-                qla_printk(KERN_WARNING, ha,
-                    "ISP Request Transfer Error (%x).\n", mb[1]);
+                ql_log(ql_log_warn, vha, 0x5006,
+                    "ISP Request Transfer Error (%x).\n",  mb[1]);
 
                 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
                 break;
 
         case MBA_RSP_TRANSFER_ERR:      /* Response Transfer Error */
-                DEBUG2(printk("scsi(%ld): ISP Response Transfer Error.\n",
-                    vha->host_no));
-                qla_printk(KERN_WARNING, ha, "ISP Response Transfer Error.\n");
+                ql_log(ql_log_warn, vha, 0x5007,
+                    "ISP Response Transfer Error.\n");
 
                 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
                 break;
 
         case MBA_WAKEUP_THRES:          /* Request Queue Wake-up */
-                DEBUG2(printk("scsi(%ld): Asynchronous WAKEUP_THRES.\n",
-                    vha->host_no));
+                ql_dbg(ql_dbg_async, vha, 0x5008,
+                    "Asynchronous WAKEUP_THRES.\n");
                 break;
 
         case MBA_LIP_OCCURRED:          /* Loop Initialization Procedure */
-                DEBUG2(printk("scsi(%ld): LIP occurred (%x).\n", vha->host_no,
-                    mb[1]));
-                qla_printk(KERN_INFO, ha, "LIP occurred (%x).\n", mb[1]);
+                ql_log(ql_log_info, vha, 0x5009,
+                    "LIP occurred (%x).\n", mb[1]);
 
                 if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
                         atomic_set(&vha->loop_state, LOOP_DOWN);
@@ -488,10 +487,8 @@ skip_rio:
                         ha->link_data_rate = mb[1];
                 }
 
-                DEBUG2(printk("scsi(%ld): Asynchronous LOOP UP (%s Gbps).\n",
-                    vha->host_no, link_speed));
-                qla_printk(KERN_INFO, ha, "LOOP UP detected (%s Gbps).\n",
-                    link_speed);
+                ql_log(ql_log_info, vha, 0x500a,
+                    "LOOP UP detected (%s Gbps).\n", link_speed);
 
                 vha->flags.management_server_logged_in = 0;
                 qla2x00_post_aen_work(vha, FCH_EVT_LINKUP, ha->link_data_rate);
@@ -500,12 +497,9 @@ skip_rio:
         case MBA_LOOP_DOWN:             /* Loop Down Event */
                 mbx = IS_QLA81XX(ha) ? RD_REG_WORD(&reg24->mailbox4) : 0;
                 mbx = IS_QLA82XX(ha) ? RD_REG_WORD(&reg82->mailbox_out[4]) : mbx;
-                DEBUG2(printk("scsi(%ld): Asynchronous LOOP DOWN "
-                    "(%x %x %x %x).\n", vha->host_no, mb[1], mb[2], mb[3],
-                    mbx));
-                qla_printk(KERN_INFO, ha,
-                    "LOOP DOWN detected (%x %x %x %x).\n", mb[1], mb[2], mb[3],
-                    mbx);
+                ql_log(ql_log_info, vha, 0x500b,
+                    "LOOP DOWN detected (%x %x %x %x).\n",
+                    mb[1], mb[2], mb[3], mbx);
 
                 if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
                         atomic_set(&vha->loop_state, LOOP_DOWN);
@@ -525,9 +519,7 @@ skip_rio:
                 break;
 
         case MBA_LIP_RESET:             /* LIP reset occurred */
-                DEBUG2(printk("scsi(%ld): Asynchronous LIP RESET (%x).\n",
-                    vha->host_no, mb[1]));
-                qla_printk(KERN_INFO, ha,
+                ql_log(ql_log_info, vha, 0x500c,
                     "LIP reset occurred (%x).\n", mb[1]);
 
                 if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
@@ -554,14 +546,15 @@ skip_rio:
                         break;
 
                 if (IS_QLA8XXX_TYPE(ha)) {
-                        DEBUG2(printk("scsi(%ld): DCBX Completed -- %04x %04x "
-                            "%04x\n", vha->host_no, mb[1], mb[2], mb[3]));
+                        ql_dbg(ql_dbg_async, vha, 0x500d,
+                            "DCBX Completed -- %04x %04x %04x.\n",
+                            mb[1], mb[2], mb[3]);
                         if (ha->notify_dcbx_comp)
                                 complete(&ha->dcbx_comp);
 
                 } else
-                        DEBUG2(printk("scsi(%ld): Asynchronous P2P MODE "
-                            "received.\n", vha->host_no));
+                        ql_dbg(ql_dbg_async, vha, 0x500e,
+                            "Asynchronous P2P MODE received.\n");
 
                 /*
                  * Until there's a transition from loop down to loop up, treat
@@ -594,10 +587,7 @@ skip_rio:
                 if (IS_QLA2100(ha))
                         break;
 
-                DEBUG2(printk("scsi(%ld): Asynchronous Change In Connection "
-                    "received.\n",
-                    vha->host_no));
-                qla_printk(KERN_INFO, ha,
+                ql_log(ql_log_info, vha, 0x500f,
                     "Configuration change detected: value=%x.\n", mb[1]);
 
                 if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
@@ -640,11 +630,9 @@ skip_rio:
 
                 /* Global event -- port logout or port unavailable. */
                 if (mb[1] == 0xffff && mb[2] == 0x7) {
-                        DEBUG2(printk("scsi(%ld): Asynchronous PORT UPDATE.\n",
-                            vha->host_no));
-                        DEBUG(printk(KERN_INFO
-                            "scsi(%ld): Port unavailable %04x %04x %04x.\n",
-                            vha->host_no, mb[1], mb[2], mb[3]));
+                        ql_dbg(ql_dbg_async, vha, 0x5010,
+                            "Port unavailable %04x %04x %04x.\n",
+                            mb[1], mb[2], mb[3]);
 
                         if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
                                 atomic_set(&vha->loop_state, LOOP_DOWN);
@@ -674,17 +662,15 @@ skip_rio:
                 atomic_set(&vha->loop_down_timer, 0);
                 if (atomic_read(&vha->loop_state) != LOOP_DOWN &&
                     atomic_read(&vha->loop_state) != LOOP_DEAD) {
-                        DEBUG2(printk("scsi(%ld): Asynchronous PORT UPDATE "
-                            "ignored %04x/%04x/%04x.\n", vha->host_no, mb[1],
-                            mb[2], mb[3]));
+                        ql_dbg(ql_dbg_async, vha, 0x5011,
+                            "Asynchronous PORT UPDATE ignored %04x/%04x/%04x.\n",
+                            mb[1], mb[2], mb[3]);
                         break;
                 }
 
-                DEBUG2(printk("scsi(%ld): Asynchronous PORT UPDATE.\n",
-                    vha->host_no));
-                DEBUG(printk(KERN_INFO
-                    "scsi(%ld): Port database changed %04x %04x %04x.\n",
-                    vha->host_no, mb[1], mb[2], mb[3]));
+                ql_dbg(ql_dbg_async, vha, 0x5012,
+                    "Port database changed %04x %04x %04x.\n",
+                    mb[1], mb[2], mb[3]);
 
                 /*
                  * Mark all devices as missing so we will login again.
@@ -707,20 +693,17 @@ skip_rio:
                 if (ha->flags.npiv_supported && vha->vp_idx != (mb[3] & 0xff))
                         break;
 
-                DEBUG2(printk("scsi(%ld): Asynchronous RSCR UPDATE.\n",
-                    vha->host_no));
-                DEBUG(printk(KERN_INFO
-                    "scsi(%ld): RSCN database changed -- %04x %04x %04x.\n",
-                    vha->host_no, mb[1], mb[2], mb[3]));
+                ql_dbg(ql_dbg_async, vha, 0x5013,
+                    "RSCN database changed -- %04x %04x %04x.\n",
+                    mb[1], mb[2], mb[3]);
 
                 rscn_entry = ((mb[1] & 0xff) << 16) | mb[2];
                 host_pid = (vha->d_id.b.domain << 16) | (vha->d_id.b.area << 8)
                                 | vha->d_id.b.al_pa;
                 if (rscn_entry == host_pid) {
-                        DEBUG(printk(KERN_INFO
-                            "scsi(%ld): Ignoring RSCN update to local host "
-                            "port ID (%06x)\n",
-                            vha->host_no, host_pid));
+                        ql_dbg(ql_dbg_async, vha, 0x5014,
+                            "Ignoring RSCN update to local host "
+                            "port ID (%06x).\n", host_pid);
                         break;
                 }
 
@@ -747,8 +730,8 @@ skip_rio:
 
         /* case MBA_RIO_RESPONSE: */
         case MBA_ZIO_RESPONSE:
-                DEBUG3(printk("scsi(%ld): [R|Z]IO update completion.\n",
-                    vha->host_no));
+                ql_dbg(ql_dbg_async, vha, 0x5015,
+                    "[R|Z]IO update completion.\n");
 
                 if (IS_FWI2_CAPABLE(ha))
                         qla24xx_process_response_queue(vha, rsp);
@@ -757,61 +740,68 @@ skip_rio:
                 break;
 
         case MBA_DISCARD_RND_FRAME:
-                DEBUG2(printk("scsi(%ld): Discard RND Frame -- %04x %04x "
-                    "%04x.\n", vha->host_no, mb[1], mb[2], mb[3]));
+                ql_dbg(ql_dbg_async, vha, 0x5016,
+                    "Discard RND Frame -- %04x %04x %04x.\n",
+                    mb[1], mb[2], mb[3]);
                 break;
 
         case MBA_TRACE_NOTIFICATION:
-                DEBUG2(printk("scsi(%ld): Trace Notification -- %04x %04x.\n",
-                vha->host_no, mb[1], mb[2]));
+                ql_dbg(ql_dbg_async, vha, 0x5017,
+                    "Trace Notification -- %04x %04x.\n", mb[1], mb[2]);
                 break;
 
         case MBA_ISP84XX_ALERT:
-                DEBUG2(printk("scsi(%ld): ISP84XX Alert Notification -- "
-                    "%04x %04x %04x\n", vha->host_no, mb[1], mb[2], mb[3]));
+                ql_dbg(ql_dbg_async, vha, 0x5018,
+                    "ISP84XX Alert Notification -- %04x %04x %04x.\n",
+                    mb[1], mb[2], mb[3]);
 
                 spin_lock_irqsave(&ha->cs84xx->access_lock, flags);
                 switch (mb[1]) {
                 case A84_PANIC_RECOVERY:
-                        qla_printk(KERN_INFO, ha, "Alert 84XX: panic recovery "
-                            "%04x %04x\n", mb[2], mb[3]);
+                        ql_log(ql_log_info, vha, 0x5019,
+                            "Alert 84XX: panic recovery %04x %04x.\n",
+                            mb[2], mb[3]);
                         break;
                 case A84_OP_LOGIN_COMPLETE:
                         ha->cs84xx->op_fw_version = mb[3] << 16 | mb[2];
-                        DEBUG2(qla_printk(KERN_INFO, ha, "Alert 84XX:"
-                            "firmware version %x\n", ha->cs84xx->op_fw_version));
+                        ql_log(ql_log_info, vha, 0x501a,
+                            "Alert 84XX: firmware version %x.\n",
+                            ha->cs84xx->op_fw_version);
                         break;
                 case A84_DIAG_LOGIN_COMPLETE:
                         ha->cs84xx->diag_fw_version = mb[3] << 16 | mb[2];
-                        DEBUG2(qla_printk(KERN_INFO, ha, "Alert 84XX:"
-                            "diagnostic firmware version %x\n",
-                            ha->cs84xx->diag_fw_version));
+                        ql_log(ql_log_info, vha, 0x501b,
+                            "Alert 84XX: diagnostic firmware version %x.\n",
+                            ha->cs84xx->diag_fw_version);
                         break;
                 case A84_GOLD_LOGIN_COMPLETE:
                         ha->cs84xx->diag_fw_version = mb[3] << 16 | mb[2];
                         ha->cs84xx->fw_update = 1;
-                        DEBUG2(qla_printk(KERN_INFO, ha, "Alert 84XX: gold "
-                            "firmware version %x\n",
-                            ha->cs84xx->gold_fw_version));
+                        ql_log(ql_log_info, vha, 0x501c,
+                            "Alert 84XX: gold firmware version %x.\n",
+                            ha->cs84xx->gold_fw_version);
                         break;
                 default:
-                        qla_printk(KERN_ERR, ha,
-                            "Alert 84xx: Invalid Alert %04x %04x %04x\n",
+                        ql_log(ql_log_warn, vha, 0x501d,
+                            "Alert 84xx: Invalid Alert %04x %04x %04x.\n",
                             mb[1], mb[2], mb[3]);
                 }
                 spin_unlock_irqrestore(&ha->cs84xx->access_lock, flags);
                 break;
         case MBA_DCBX_START:
-                DEBUG2(printk("scsi(%ld): DCBX Started -- %04x %04x %04x\n",
-                    vha->host_no, mb[1], mb[2], mb[3]));
+                ql_dbg(ql_dbg_async, vha, 0x501e,
+                    "DCBX Started -- %04x %04x %04x.\n",
+                    mb[1], mb[2], mb[3]);
                 break;
         case MBA_DCBX_PARAM_UPDATE:
-                DEBUG2(printk("scsi(%ld): DCBX Parameters Updated -- "
-                    "%04x %04x %04x\n", vha->host_no, mb[1], mb[2], mb[3]));
+                ql_dbg(ql_dbg_async, vha, 0x501f,
+                    "DCBX Parameters Updated -- %04x %04x %04x.\n",
+                    mb[1], mb[2], mb[3]);
                 break;
         case MBA_FCF_CONF_ERR:
-                DEBUG2(printk("scsi(%ld): FCF Configuration Error -- "
-                    "%04x %04x %04x\n", vha->host_no, mb[1], mb[2], mb[3]));
+                ql_dbg(ql_dbg_async, vha, 0x5020,
+                    "FCF Configuration Error -- %04x %04x %04x.\n",
+                    mb[1], mb[2], mb[3]);
                 break;
         case MBA_IDC_COMPLETE:
         case MBA_IDC_NOTIFY:
@@ -838,10 +828,8 @@ qla2x00_process_completed_request(struct scsi_qla_host *vha,
 
         /* Validate handle. */
         if (index >= MAX_OUTSTANDING_COMMANDS) {
-                DEBUG2(printk("scsi(%ld): Invalid SCSI completion handle %d.\n",
-                    vha->host_no, index));
-                qla_printk(KERN_WARNING, ha,
-                    "Invalid SCSI completion handle %d.\n", index);
+                ql_log(ql_log_warn, vha, 0x3014,
+                    "Invalid SCSI command index (%x).\n", index);
 
                 if (IS_QLA82XX(ha))
                         set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
@@ -859,10 +847,7 @@ qla2x00_process_completed_request(struct scsi_qla_host *vha,
                 sp->cmd->result = DID_OK << 16;
                 qla2x00_sp_compl(ha, sp);
         } else {
-                DEBUG2(printk("scsi(%ld) Req:%d: Invalid ISP SCSI completion"
-                        " handle(0x%x)\n", vha->host_no, req->id, index));
-                qla_printk(KERN_WARNING, ha,
-                    "Invalid ISP SCSI completion handle\n");
+                ql_log(ql_log_warn, vha, 0x3016, "Invalid SCSI SRB.\n");
 
                 if (IS_QLA82XX(ha))
                         set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
@@ -882,8 +867,8 @@ qla2x00_get_sp_from_handle(scsi_qla_host_t *vha, const char *func,
 
         index = LSW(pkt->handle);
         if (index >= MAX_OUTSTANDING_COMMANDS) {
-                qla_printk(KERN_WARNING, ha,
-                    "%s: Invalid completion handle (%x).\n", func, index);
+                ql_log(ql_log_warn, vha, 0x5031,
+                    "Invalid command index (%x).\n", index);
                 if (IS_QLA82XX(ha))
                         set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
                 else
@@ -892,15 +877,13 @@ qla2x00_get_sp_from_handle(scsi_qla_host_t *vha, const char *func,
         }
         sp = req->outstanding_cmds[index];
         if (!sp) {
-                qla_printk(KERN_WARNING, ha,
-                    "%s: Invalid completion handle (%x) -- timed-out.\n", func,
-                    index);
+                ql_log(ql_log_warn, vha, 0x5032,
+                    "Invalid completion handle (%x) -- timed-out.\n", index);
                 return sp;
         }
         if (sp->handle != index) {
-                qla_printk(KERN_WARNING, ha,
-                    "%s: SRB handle (%x) mismatch %x.\n", func, sp->handle,
-                    index);
+                ql_log(ql_log_warn, vha, 0x5033,
+                    "SRB handle (%x) mismatch %x.\n", sp->handle, index);
                 return NULL;
         }
 
@@ -937,17 +920,17 @@ qla2x00_mbx_iocb_entry(scsi_qla_host_t *vha, struct req_que *req,
         data[1] = lio->u.logio.flags & SRB_LOGIN_RETRIED ?
             QLA_LOGIO_LOGIN_RETRIED : 0;
         if (mbx->entry_status) {
-                DEBUG2(printk(KERN_WARNING
-                    "scsi(%ld:%x): Async-%s error entry - portid=%02x%02x%02x "
+                ql_dbg(ql_dbg_async, vha, 0x5043,
+                    "Async-%s error entry - portid=%02x%02x%02x "
                     "entry-status=%x status=%x state-flag=%x "
                     "status-flags=%x.\n",
-                    fcport->vha->host_no, sp->handle, type,
-                    fcport->d_id.b.domain, fcport->d_id.b.area,
+                    type, fcport->d_id.b.domain, fcport->d_id.b.area,
                     fcport->d_id.b.al_pa, mbx->entry_status,
                     le16_to_cpu(mbx->status), le16_to_cpu(mbx->state_flags),
-                    le16_to_cpu(mbx->status_flags)));
+                    le16_to_cpu(mbx->status_flags));
 
-                DEBUG2(qla2x00_dump_buffer((uint8_t *)mbx, sizeof(*mbx)));
+                ql_dump_buffer(ql_dbg_async + ql_dbg_buffer, vha, 0x5057,
+                    (uint8_t *)mbx, sizeof(*mbx));
 
                 goto logio_done;
         }
@@ -957,12 +940,10 @@ qla2x00_mbx_iocb_entry(scsi_qla_host_t *vha, struct req_que *req,
             le16_to_cpu(mbx->mb0) == MBS_COMMAND_COMPLETE)
                 status = 0;
         if (!status && le16_to_cpu(mbx->mb0) == MBS_COMMAND_COMPLETE) {
-                DEBUG2(printk(KERN_DEBUG
-                    "scsi(%ld:%x): Async-%s complete - portid=%02x%02x%02x "
-                    "mbx1=%x.\n",
-                    fcport->vha->host_no, sp->handle, type,
-                    fcport->d_id.b.domain, fcport->d_id.b.area,
-                    fcport->d_id.b.al_pa, le16_to_cpu(mbx->mb1)));
+                ql_dbg(ql_dbg_async, vha, 0x5045,
+                    "Async-%s complete - portid=%02x%02x%02x mbx1=%x.\n",
+                    type, fcport->d_id.b.domain, fcport->d_id.b.area,
+                    fcport->d_id.b.al_pa, le16_to_cpu(mbx->mb1));
 
                 data[0] = MBS_COMMAND_COMPLETE;
                 if (ctx->type == SRB_LOGIN_CMD) {
@@ -987,14 +968,14 @@ qla2x00_mbx_iocb_entry(scsi_qla_host_t *vha, struct req_que *req,
                 break;
         }
 
-        DEBUG2(printk(KERN_WARNING
-            "scsi(%ld:%x): Async-%s failed - portid=%02x%02x%02x status=%x "
+        ql_log(ql_log_warn, vha, 0x5046,
+            "Async-%s failed - portid=%02x%02x%02x status=%x "
             "mb0=%x mb1=%x mb2=%x mb6=%x mb7=%x.\n",
-            fcport->vha->host_no, sp->handle, type, fcport->d_id.b.domain,
+            type, fcport->d_id.b.domain,
             fcport->d_id.b.area, fcport->d_id.b.al_pa, status,
             le16_to_cpu(mbx->mb0), le16_to_cpu(mbx->mb1),
             le16_to_cpu(mbx->mb2), le16_to_cpu(mbx->mb6),
-            le16_to_cpu(mbx->mb7)));
+            le16_to_cpu(mbx->mb7));
 
 logio_done:
         lio->done(sp);
@@ -1025,9 +1006,8 @@ qla2x00_ct_entry(scsi_qla_host_t *vha, struct req_que *req,
                 type = "ct pass-through";
                 break;
         default:
-                qla_printk(KERN_WARNING, ha,
-                    "%s: Unrecognized SRB: (%p) type=%d.\n", func, sp,
-                    sp_bsg->type);
+                ql_log(ql_log_warn, vha, 0x5047,
+                    "Unrecognized SRB: (%p) type=%d.\n", sp, sp_bsg->type);
                 return;
         }
 
@@ -1045,20 +1025,20 @@ qla2x00_ct_entry(scsi_qla_host_t *vha, struct req_que *req,
                         bsg_job->reply->reply_payload_rcv_len =
                             le16_to_cpu(((sts_entry_t *)pkt)->rsp_info_len);
 
-                        DEBUG2(qla_printk(KERN_WARNING, ha,
-                            "scsi(%ld): CT pass-through-%s error "
+                        ql_log(ql_log_warn, vha, 0x5048,
+                            "CT pass-through-%s error "
                             "comp_status-status=0x%x total_byte = 0x%x.\n",
-                            vha->host_no, type, comp_status,
-                            bsg_job->reply->reply_payload_rcv_len));
+                            type, comp_status,
+                            bsg_job->reply->reply_payload_rcv_len);
                 } else {
-                        DEBUG2(qla_printk(KERN_WARNING, ha,
-                            "scsi(%ld): CT pass-through-%s error "
-                            "comp_status-status=0x%x.\n",
-                            vha->host_no, type, comp_status));
+                        ql_log(ql_log_warn, vha, 0x5049,
+                            "CT pass-through-%s error "
+                            "comp_status-status=0x%x.\n", type, comp_status);
                         bsg_job->reply->result = DID_ERROR << 16;
                         bsg_job->reply->reply_payload_rcv_len = 0;
                 }
-                DEBUG2(qla2x00_dump_buffer((uint8_t *)pkt, sizeof(*pkt)));
+                ql_dump_buffer(ql_dbg_async + ql_dbg_buffer, vha, 0x5058,
+                    (uint8_t *)pkt, sizeof(*pkt));
         } else {
                 bsg_job->reply->result =  DID_OK << 16;
                 bsg_job->reply->reply_payload_rcv_len =
@@ -1110,9 +1090,8 @@ qla24xx_els_ct_entry(scsi_qla_host_t *vha, struct req_que *req,
                 type = "ct pass-through";
                 break;
         default:
-                qla_printk(KERN_WARNING, ha,
-                    "%s: Unrecognized SRB: (%p) type=%d.\n", func, sp,
-                    sp_bsg->type);
+                ql_log(ql_log_warn, vha, 0x503e,
+                    "Unrecognized SRB: (%p) type=%d.\n", sp, sp_bsg->type);
                 return;
         }
 
@@ -1132,27 +1111,31 @@ qla24xx_els_ct_entry(scsi_qla_host_t *vha, struct req_que *req,
                         bsg_job->reply->reply_payload_rcv_len =
                                 le16_to_cpu(((struct els_sts_entry_24xx*)pkt)->total_byte_count);
 
-                        DEBUG2(qla_printk(KERN_WARNING, ha,
-                            "scsi(%ld:0x%x): ELS-CT pass-through-%s error comp_status-status=0x%x "
+                        ql_log(ql_log_info, vha, 0x503f,
+                            "ELS-CT pass-through-%s error comp_status-status=0x%x "
                             "error subcode 1=0x%x error subcode 2=0x%x total_byte = 0x%x.\n",
-                                vha->host_no, sp->handle, type, comp_status, fw_status[1], fw_status[2],
-                                le16_to_cpu(((struct els_sts_entry_24xx*)pkt)->total_byte_count)));
+                            type, comp_status, fw_status[1], fw_status[2],
+                            le16_to_cpu(((struct els_sts_entry_24xx *)
+                                pkt)->total_byte_count));
                         fw_sts_ptr = ((uint8_t*)bsg_job->req->sense) + sizeof(struct fc_bsg_reply);
                         memcpy( fw_sts_ptr, fw_status, sizeof(fw_status));
                 }
                 else {
-                        DEBUG2(qla_printk(KERN_WARNING, ha,
-                            "scsi(%ld:0x%x): ELS-CT pass-through-%s error comp_status-status=0x%x "
+                        ql_log(ql_log_info, vha, 0x5040,
+                            "ELS-CT pass-through-%s error comp_status-status=0x%x "
                             "error subcode 1=0x%x error subcode 2=0x%x.\n",
-                                vha->host_no, sp->handle, type, comp_status,
-                                le16_to_cpu(((struct els_sts_entry_24xx*)pkt)->error_subcode_1),
-                                le16_to_cpu(((struct els_sts_entry_24xx*)pkt)->error_subcode_2)));
+                            type, comp_status,
+                            le16_to_cpu(((struct els_sts_entry_24xx *)
+                                pkt)->error_subcode_1),
+                            le16_to_cpu(((struct els_sts_entry_24xx *)
+                                    pkt)->error_subcode_2));
                         bsg_job->reply->result = DID_ERROR << 16;
                         bsg_job->reply->reply_payload_rcv_len = 0;
                         fw_sts_ptr = ((uint8_t*)bsg_job->req->sense) + sizeof(struct fc_bsg_reply);
                         memcpy( fw_sts_ptr, fw_status, sizeof(fw_status));
                 }
-                DEBUG2(qla2x00_dump_buffer((uint8_t *)pkt, sizeof(*pkt)));
+                ql_dump_buffer(ql_dbg_async + ql_dbg_buffer, vha, 0x5056,
+                                (uint8_t *)pkt, sizeof(*pkt));
         }
         else {
                 bsg_job->reply->result =  DID_OK << 16;
@@ -1201,25 +1184,24 @@ qla24xx_logio_entry(scsi_qla_host_t *vha, struct req_que *req,
         data[1] = lio->u.logio.flags & SRB_LOGIN_RETRIED ?
                 QLA_LOGIO_LOGIN_RETRIED : 0;
         if (logio->entry_status) {
-                DEBUG2(printk(KERN_WARNING
-                    "scsi(%ld:%x): Async-%s error entry - "
+                ql_log(ql_log_warn, vha, 0x5034,
+                    "Async-%s error entry - "
                     "portid=%02x%02x%02x entry-status=%x.\n",
-                    fcport->vha->host_no, sp->handle, type,
-                    fcport->d_id.b.domain, fcport->d_id.b.area,
-                    fcport->d_id.b.al_pa, logio->entry_status));
-                DEBUG2(qla2x00_dump_buffer((uint8_t *)logio, sizeof(*logio)));
+                    type, fcport->d_id.b.domain, fcport->d_id.b.area,
+                    fcport->d_id.b.al_pa, logio->entry_status);
+                ql_dump_buffer(ql_dbg_async + ql_dbg_buffer, vha, 0x5059,
+                    (uint8_t *)logio, sizeof(*logio));
 
                 goto logio_done;
         }
 
         if (le16_to_cpu(logio->comp_status) == CS_COMPLETE) {
-                DEBUG2(printk(KERN_DEBUG
-                    "scsi(%ld:%x): Async-%s complete - portid=%02x%02x%02x "
+                ql_dbg(ql_dbg_async, vha, 0x5036,
+                    "Async-%s complete - portid=%02x%02x%02x "
                     "iop0=%x.\n",
-                    fcport->vha->host_no, sp->handle, type,
-                    fcport->d_id.b.domain, fcport->d_id.b.area,
+                    type, fcport->d_id.b.domain, fcport->d_id.b.area,
                     fcport->d_id.b.al_pa,
-                    le32_to_cpu(logio->io_parameter[0])));
+                    le32_to_cpu(logio->io_parameter[0]));
 
                 data[0] = MBS_COMMAND_COMPLETE;
                 if (ctx->type != SRB_LOGIN_CMD)
@@ -1256,14 +1238,14 @@ qla24xx_logio_entry(scsi_qla_host_t *vha, struct req_que *req,
                 break;
         }
 
-        DEBUG2(printk(KERN_WARNING
-            "scsi(%ld:%x): Async-%s failed - portid=%02x%02x%02x comp=%x "
+        ql_dbg(ql_dbg_async, vha, 0x5037,
+            "Async-%s failed - portid=%02x%02x%02x comp=%x "
             "iop0=%x iop1=%x.\n",
-            fcport->vha->host_no, sp->handle, type, fcport->d_id.b.domain,
+            type, fcport->d_id.b.domain,
             fcport->d_id.b.area, fcport->d_id.b.al_pa,
             le16_to_cpu(logio->comp_status),
             le32_to_cpu(logio->io_parameter[0]),
-            le32_to_cpu(logio->io_parameter[1])));
+            le32_to_cpu(logio->io_parameter[1]));
 
 logio_done:
         lio->done(sp);
@@ -1292,38 +1274,34 @@ qla24xx_tm_iocb_entry(scsi_qla_host_t *vha, struct req_que *req,
         fcport = sp->fcport;
 
         if (sts->entry_status) {
-                DEBUG2(printk(KERN_WARNING
-                    "scsi(%ld:%x): Async-%s error - entry-status(%x).\n",
-                    fcport->vha->host_no, sp->handle, type,
-                    sts->entry_status));
+                ql_log(ql_log_warn, vha, 0x5038,
+                    "Async-%s error - entry-status(%x).\n",
+                    type, sts->entry_status);
         } else if (sts->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) {
-                DEBUG2(printk(KERN_WARNING
-                    "scsi(%ld:%x): Async-%s error - completion status(%x).\n",
-                    fcport->vha->host_no, sp->handle, type,
-                    sts->comp_status));
+                ql_log(ql_log_warn, vha, 0x5039,
+                    "Async-%s error - completion status(%x).\n",
+                    type, sts->comp_status);
         } else if (!(le16_to_cpu(sts->scsi_status) &
             SS_RESPONSE_INFO_LEN_VALID)) {
-                DEBUG2(printk(KERN_WARNING
-                    "scsi(%ld:%x): Async-%s error - no response info(%x).\n",
-                    fcport->vha->host_no, sp->handle, type,
-                    sts->scsi_status));
+                ql_log(ql_log_warn, vha, 0x503a,
+                    "Async-%s error - no response info(%x).\n",
+                    type, sts->scsi_status);
         } else if (le32_to_cpu(sts->rsp_data_len) < 4) {
-                DEBUG2(printk(KERN_WARNING
-                    "scsi(%ld:%x): Async-%s error - not enough response(%d).\n",
-                    fcport->vha->host_no, sp->handle, type,
-                    sts->rsp_data_len));
+                ql_log(ql_log_warn, vha, 0x503b,
+                    "Async-%s error - not enough response(%d).\n",
+                    type, sts->rsp_data_len);
         } else if (sts->data[3]) {
-                DEBUG2(printk(KERN_WARNING
-                    "scsi(%ld:%x): Async-%s error - response(%x).\n",
-                    fcport->vha->host_no, sp->handle, type,
-                    sts->data[3]));
+                ql_log(ql_log_warn, vha, 0x503c,
+                    "Async-%s error - response(%x).\n",
+                    type, sts->data[3]);
         } else {
                 error = 0;
         }
 
         if (error) {
                 iocb->u.tmf.data = error;
-                DEBUG2(qla2x00_dump_buffer((uint8_t *)sts, sizeof(*sts)));
+                ql_dump_buffer(ql_dbg_async + ql_dbg_buffer, vha, 0x5055,
+                    (uint8_t *)sts, sizeof(*sts));
         }
 
         iocb->done(sp);
@@ -1360,8 +1338,8 @@ qla2x00_process_response_queue(struct rsp_que *rsp)
                 }
 
                 if (pkt->entry_status != 0) {
-                        DEBUG3(printk(KERN_INFO
-                            "scsi(%ld): Process error entry.\n", vha->host_no));
+                        ql_log(ql_log_warn, vha, 0x5035,
+                            "Process error entry.\n");
 
                         qla2x00_error_entry(vha, rsp, pkt);
                         ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
@@ -1399,10 +1377,10 @@ qla2x00_process_response_queue(struct rsp_que *rsp)
                         break;
                 default:
                         /* Type Not Supported. */
-                        DEBUG4(printk(KERN_WARNING
-                            "scsi(%ld): Received unknown response pkt type %x "
+                        ql_log(ql_log_warn, vha, 0x504a,
+                            "Received unknown response pkt type %x "
                             "entry status=%x.\n",
-                            vha->host_no, pkt->entry_type, pkt->entry_status));
+                            pkt->entry_type, pkt->entry_status);
                         break;
                 }
                 ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
@@ -1418,6 +1396,7 @@ static inline void
 qla2x00_handle_sense(srb_t *sp, uint8_t *sense_data, uint32_t par_sense_len,
     uint32_t sense_len, struct rsp_que *rsp)
 {
+        struct scsi_qla_host *vha = sp->fcport->vha;
         struct scsi_cmnd *cp = sp->cmd;
 
         if (sense_len >= SCSI_SENSE_BUFFERSIZE)
@@ -1435,11 +1414,13 @@ qla2x00_handle_sense(srb_t *sp, uint8_t *sense_data, uint32_t par_sense_len,
         if (sp->request_sense_length != 0)
                 rsp->status_srb = sp;
 
-        DEBUG5(printk("%s(): Check condition Sense data, scsi(%ld:%d:%d:%d) "
-            "cmd=%p\n", __func__, sp->fcport->vha->host_no,
-            cp->device->channel, cp->device->id, cp->device->lun, cp));
+        ql_dbg(ql_dbg_io, vha, 0x301c,
+            "Check condition Sense data, scsi(%ld:%d:%d:%d) cmd=%p.\n",
+            sp->fcport->vha->host_no, cp->device->channel, cp->device->id,
+            cp->device->lun, cp);
         if (sense_len)
-                DEBUG5(qla2x00_dump_buffer(cp->sense_buffer, sense_len));
+                ql_dump_buffer(ql_dbg_io + ql_dbg_buffer, vha, 0x302b,
+                    cp->sense_buffer, sense_len);
 }
 
 struct scsi_dif_tuple {
@@ -1457,6 +1438,7 @@ struct scsi_dif_tuple {
 static inline void
 qla2x00_handle_dif_error(srb_t *sp, struct sts_entry_24xx *sts24)
 {
+        struct scsi_qla_host *vha = sp->fcport->vha;
         struct scsi_cmnd *cmd = sp->cmd;
         struct scsi_dif_tuple   *ep =
                         (struct scsi_dif_tuple *)&sts24->data[20];
@@ -1473,15 +1455,15 @@ qla2x00_handle_dif_error(srb_t *sp, struct sts_entry_24xx *sts24)
         e_guard = be16_to_cpu(ep->guard);
         a_guard = be16_to_cpu(ap->guard);
 
-        DEBUG18(printk(KERN_DEBUG
-            "%s(): iocb(s) %p Returned STATUS\n", __func__, sts24));
+        ql_dbg(ql_dbg_io, vha, 0x3023,
+            "iocb(s) %p Returned STATUS.\n", sts24);
 
-        DEBUG18(printk(KERN_ERR "DIF ERROR in cmd 0x%x lba 0x%llx act ref"
+        ql_dbg(ql_dbg_io, vha, 0x3024,
+            "DIF ERROR in cmd 0x%x lba 0x%llx act ref"
             " tag=0x%x, exp ref_tag=0x%x, act app tag=0x%x, exp app"
-            " tag=0x%x, act guard=0x%x, exp guard=0x%x\n",
+            " tag=0x%x, act guard=0x%x, exp guard=0x%x.\n",
             cmd->cmnd[0], (u64)scsi_get_lba(cmd), a_ref_tag, e_ref_tag,
-            a_app_tag, e_app_tag, a_guard, e_guard));
-
+            a_app_tag, e_app_tag, a_guard, e_guard);
 
         /* check guard */
         if (e_guard != a_guard) {
@@ -1569,9 +1551,8 @@ qla2x00_status_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, void *pkt)
                 sp = NULL;
 
         if (sp == NULL) {
-                qla_printk(KERN_WARNING, ha,
-                    "scsi(%ld): Invalid status handle (0x%x).\n", vha->host_no,
-                    sts->handle);
+                ql_log(ql_log_warn, vha, 0x3017,
+                    "Invalid status handle (0x%x).\n", sts->handle);
 
                 if (IS_QLA82XX(ha))
                         set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
@@ -1582,9 +1563,9 @@ qla2x00_status_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, void *pkt)
         }
         cp = sp->cmd;
         if (cp == NULL) {
-                qla_printk(KERN_WARNING, ha,
-                    "scsi(%ld): Command already returned (0x%x/%p).\n",
-                    vha->host_no, sts->handle, sp);
+                ql_log(ql_log_warn, vha, 0x3018,
+                    "Command already returned (0x%x/%p).\n",
+                    sts->handle, sp);
 
                 return;
         }
@@ -1629,10 +1610,9 @@ qla2x00_status_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, void *pkt)
                         par_sense_len -= rsp_info_len;
                 }
                 if (rsp_info_len > 3 && rsp_info[3]) {
-                        DEBUG2(qla_printk(KERN_INFO, ha,
-                            "scsi(%ld:%d:%d): FCP I/O protocol failure "
-                            "(0x%x/0x%x).\n", vha->host_no, cp->device->id,
-                            cp->device->lun, rsp_info_len, rsp_info[3]));
+                        ql_log(ql_log_warn, vha, 0x3019,
+                            "FCP I/O protocol failure (0x%x/0x%x).\n",
+                            rsp_info_len, rsp_info[3]);
 
                         cp->result = DID_BUS_BUSY << 16;
                         goto out;
@@ -1661,11 +1641,10 @@ qla2x00_status_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, void *pkt)
                         if (!lscsi_status &&
                             ((unsigned)(scsi_bufflen(cp) - resid) <
                              cp->underflow)) {
-                                qla_printk(KERN_INFO, ha,
-                                    "scsi(%ld:%d:%d): Mid-layer underflow "
+                                ql_log(ql_log_warn, vha, 0x301a,
+                                    "Mid-layer underflow "
                                     "detected (0x%x of 0x%x bytes).\n",
-                                    vha->host_no, cp->device->id,
-                                    cp->device->lun, resid, scsi_bufflen(cp));
+                                    resid, scsi_bufflen(cp));
 
                                 cp->result = DID_ERROR << 16;
                                 break;
@@ -1674,9 +1653,8 @@ qla2x00_status_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, void *pkt)
                 cp->result = DID_OK << 16 | lscsi_status;
 
                 if (lscsi_status == SAM_STAT_TASK_SET_FULL) {
-                        DEBUG2(qla_printk(KERN_INFO, ha,
-                            "scsi(%ld:%d:%d) QUEUE FULL detected.\n",
-                            vha->host_no, cp->device->id, cp->device->lun));
+                        ql_log(ql_log_warn, vha, 0x301b,
+                            "QUEUE FULL detected.\n");
                         break;
                 }
                 logit = 0;
@@ -1697,11 +1675,10 @@ qla2x00_status_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, void *pkt)
                 scsi_set_resid(cp, resid);
                 if (scsi_status & SS_RESIDUAL_UNDER) {
                         if (IS_FWI2_CAPABLE(ha) && fw_resid_len != resid_len) {
-                                DEBUG2(qla_printk(KERN_INFO, ha,
-                                    "scsi(%ld:%d:%d) Dropped frame(s) detected "
-                                    "(0x%x of 0x%x bytes).\n", vha->host_no,
-                                    cp->device->id, cp->device->lun, resid,
-                                    scsi_bufflen(cp)));
+                                ql_log(ql_log_warn, vha, 0x301d,
+                                    "Dropped frame(s) detected "
+                                    "(0x%x of 0x%x bytes).\n",
+                                    resid, scsi_bufflen(cp));
 
                                 cp->result = DID_ERROR << 16 | lscsi_status;
                                 break;
@@ -1710,20 +1687,18 @@ qla2x00_status_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, void *pkt)
                         if (!lscsi_status &&
                             ((unsigned)(scsi_bufflen(cp) - resid) <
                             cp->underflow)) {
-                                qla_printk(KERN_INFO, ha,
-                                    "scsi(%ld:%d:%d): Mid-layer underflow "
+                                ql_log(ql_log_warn, vha, 0x301e,
+                                    "Mid-layer underflow "
                                     "detected (0x%x of 0x%x bytes).\n",
-                                    vha->host_no, cp->device->id,
-                                    cp->device->lun, resid, scsi_bufflen(cp));
+                                    resid, scsi_bufflen(cp));
 
                                 cp->result = DID_ERROR << 16;
                                 break;
                         }
                 } else {
-                        DEBUG2(qla_printk(KERN_INFO, ha,
-                            "scsi(%ld:%d:%d) Dropped frame(s) detected (0x%x "
-                            "of 0x%x bytes).\n", vha->host_no, cp->device->id,
-                            cp->device->lun, resid, scsi_bufflen(cp)));
+                        ql_log(ql_log_warn, vha, 0x301f,
+                            "Dropped frame(s) detected (0x%x "
+                            "of 0x%x bytes).\n", resid, scsi_bufflen(cp));
 
                         cp->result = DID_ERROR << 16 | lscsi_status;
                         goto check_scsi_status;
@@ -1739,10 +1714,8 @@ check_scsi_status:
                  */
                 if (lscsi_status != 0) {
                         if (lscsi_status == SAM_STAT_TASK_SET_FULL) {
-                                DEBUG2(qla_printk(KERN_INFO, ha,
-                                    "scsi(%ld:%d:%d) QUEUE FULL detected.\n",
-                                    vha->host_no, cp->device->id,
-                                    cp->device->lun));
+                                ql_log(ql_log_warn, vha, 0x3020,
+                                    "QUEUE FULL detected.\n");
                                 logit = 1;
                                 break;
                         }
@@ -1781,10 +1754,9 @@ check_scsi_status:
                                 break;
                 }
 
-                DEBUG2(qla_printk(KERN_INFO, ha,
-                        "scsi(%ld:%d:%d) Port down status: port-state=0x%x\n",
-                        vha->host_no, cp->device->id, cp->device->lun,
-                        atomic_read(&fcport->state)));
+                ql_dbg(ql_dbg_io, vha, 0x3021,
+                    "Port down status: port-state=0x%x.\n",
+                    atomic_read(&fcport->state));
 
                 if (atomic_read(&fcport->state) == FCS_ONLINE)
                         qla2x00_mark_device_lost(fcport->vha, fcport, 1, 1);
@@ -1804,15 +1776,13 @@ check_scsi_status:
 
 out:
         if (logit)
-                DEBUG2(qla_printk(KERN_INFO, ha,
-                    "scsi(%ld:%d:%d) FCP command status: 0x%x-0x%x (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, 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));
+                ql_dbg(ql_dbg_io, vha, 0x3022,
+                    "FCP command status: 0x%x-0x%x (0x%x) "
+                    "oxid=0x%x cdb=%02x%02x%02x len=0x%x "
+                    "rsp_info=0x%x resid=0x%x fw_resid=0x%x.\n",
+                    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);
 
         if (rsp->status_srb == NULL)
                 qla2x00_sp_compl(ha, sp);
@@ -1830,16 +1800,15 @@ qla2x00_status_cont_entry(struct rsp_que *rsp, sts_cont_entry_t *pkt)
 {
         uint8_t         sense_sz = 0;
         struct qla_hw_data *ha = rsp->hw;
+        struct scsi_qla_host *vha = pci_get_drvdata(ha->pdev);
         srb_t           *sp = rsp->status_srb;
         struct scsi_cmnd *cp;
 
         if (sp != NULL && sp->request_sense_length != 0) {
                 cp = sp->cmd;
                 if (cp == NULL) {
-                        DEBUG2(printk("%s(): Cmd already returned back to OS "
-                            "sp=%p.\n", __func__, sp));
-                        qla_printk(KERN_INFO, ha,
-                            "cmd is NULL: already returned to OS (sp=%p)\n",
+                        ql_log(ql_log_warn, vha, 0x3025,
+                            "cmd is NULL: already returned to OS (sp=%p).\n",
                             sp);
 
                         rsp->status_srb = NULL;
@@ -1856,7 +1825,8 @@ qla2x00_status_cont_entry(struct rsp_que *rsp, sts_cont_entry_t *pkt)
                 if (IS_FWI2_CAPABLE(ha))
                         host_to_fcp_swap(pkt->data, sizeof(pkt->data));
                 memcpy(sp->request_sense_ptr, pkt->data, sense_sz);
-                DEBUG5(qla2x00_dump_buffer(sp->request_sense_ptr, sense_sz));
+                ql_dump_buffer(ql_dbg_io + ql_dbg_buffer, vha, 0x302c,
+                        sp->request_sense_ptr, sense_sz);
 
                 sp->request_sense_ptr += sense_sz;
                 sp->request_sense_length -= sense_sz;
@@ -1882,21 +1852,25 @@ qla2x00_error_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, sts_entry_t *pkt)
         uint32_t handle = LSW(pkt->handle);
         uint16_t que = MSW(pkt->handle);
         struct req_que *req = ha->req_q_map[que];
-#if defined(QL_DEBUG_LEVEL_2)
+
         if (pkt->entry_status & RF_INV_E_ORDER)
-                qla_printk(KERN_ERR, ha, "%s: Invalid Entry Order\n", __func__);
+                ql_dbg(ql_dbg_async, vha, 0x502a,
+                    "Invalid Entry Order.\n");
         else if (pkt->entry_status & RF_INV_E_COUNT)
-                qla_printk(KERN_ERR, ha, "%s: Invalid Entry Count\n", __func__);
+                ql_dbg(ql_dbg_async, vha, 0x502b,
+                    "Invalid Entry Count.\n");
         else if (pkt->entry_status & RF_INV_E_PARAM)
-                qla_printk(KERN_ERR, ha,
-                    "%s: Invalid Entry Parameter\n", __func__);
+                ql_dbg(ql_dbg_async, vha, 0x502c,
+                    "Invalid Entry Parameter.\n");
         else if (pkt->entry_status & RF_INV_E_TYPE)
-                qla_printk(KERN_ERR, ha, "%s: Invalid Entry Type\n", __func__);
+                ql_dbg(ql_dbg_async, vha, 0x502d,
+                    "Invalid Entry Type.\n");
         else if (pkt->entry_status & RF_BUSY)
-                qla_printk(KERN_ERR, ha, "%s: Busy\n", __func__);
+                ql_dbg(ql_dbg_async, vha, 0x502e,
+                    "Busy.\n");
         else
-                qla_printk(KERN_ERR, ha, "%s: UNKNOWN flag error\n", __func__);
-#endif
+                ql_dbg(ql_dbg_async, vha, 0x502f,
+                    "UNKNOWN flag error.\n");
 
         /* Validate handle. */
         if (handle < MAX_OUTSTANDING_COMMANDS)
@@ -1923,10 +1897,8 @@ qla2x00_error_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, sts_entry_t *pkt)
         } else if (pkt->entry_type == COMMAND_A64_TYPE || pkt->entry_type ==
                 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));
-                qla_printk(KERN_WARNING, ha,
-                        "Error entry - invalid handle\n");
+                ql_log(ql_log_warn, vha, 0x5030,
+                    "Error entry - invalid handle.\n");
 
                 if (IS_QLA82XX(ha))
                         set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
@@ -1960,11 +1932,11 @@ qla24xx_mbx_completion(scsi_qla_host_t *vha, uint16_t mb0)
         }
 
         if (ha->mcp) {
-                DEBUG3(printk("%s(%ld): Got mailbox completion. cmd=%x.\n",
-                    __func__, vha->host_no, ha->mcp->mb[0]));
+                ql_dbg(ql_dbg_async, vha, 0x504d,
+                    "Got mailbox completion. cmd=%x.\n", ha->mcp->mb[0]);
         } else {
-                DEBUG2_3(printk("%s(%ld): MBX pointer ERROR!\n",
-                    __func__, vha->host_no));
+                ql_dbg(ql_dbg_async, vha, 0x504e,
+                    "MBX pointer ERROR.\n");
         }
 }
 
@@ -1993,8 +1965,8 @@ void qla24xx_process_response_queue(struct scsi_qla_host *vha,
                 }
 
                 if (pkt->entry_status != 0) {
-                        DEBUG3(printk(KERN_INFO
-                            "scsi(%ld): Process error entry.\n", vha->host_no));
+                        ql_dbg(ql_dbg_async, vha, 0x5029,
+                            "Process error entry.\n");
 
                         qla2x00_error_entry(vha, rsp, (sts_entry_t *) pkt);
                         ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
@@ -2030,10 +2002,10 @@ void qla24xx_process_response_queue(struct scsi_qla_host *vha,
                         break;
                 default:
                         /* Type Not Supported. */
-                        DEBUG4(printk(KERN_WARNING
-                            "scsi(%ld): Received unknown response pkt type %x "
+                        ql_dbg(ql_dbg_async, vha, 0x5042,
+                            "Received unknown response pkt type %x "
                             "entry status=%x.\n",
-                            vha->host_no, pkt->entry_type, pkt->entry_status));
+                            pkt->entry_type, pkt->entry_status);
                         break;
                 }
                 ((response_t *)pkt)->signature = RESPONSE_PROCESSED;
@@ -2088,7 +2060,8 @@ qla2xxx_check_risc_status(scsi_qla_host_t *vha)
 
 next_test:
         if (RD_REG_DWORD(&reg->iobase_c8) & BIT_3)
-                qla_printk(KERN_INFO, ha, "Additional code -- 0x55AA.\n");
+                ql_log(ql_log_info, vha, 0x504c,
+                    "Additional code -- 0x55AA.\n");
 
 done:
         WRT_REG_DWORD(&reg->iobase_window, 0x0000);
@@ -2121,7 +2094,7 @@ qla24xx_intr_handler(int irq, void *dev_id)
         rsp = (struct rsp_que *) dev_id;
         if (!rsp) {
                 printk(KERN_INFO
-                    "%s(): NULL response queue pointer\n", __func__);
+                    "%s(): NULL response queue pointer.\n", __func__);
                 return IRQ_NONE;
         }
 
@@ -2142,8 +2115,9 @@ qla24xx_intr_handler(int irq, void *dev_id)
 
                         hccr = RD_REG_DWORD(&reg->hccr);
 
-                        qla_printk(KERN_INFO, ha, "RISC paused -- HCCR=%x, "
-                            "Dumping firmware!\n", hccr);
+                        ql_log(ql_log_warn, vha, 0x504b,
+                            "RISC paused -- HCCR=%x, Dumping firmware.\n",
+                            hccr);
 
                         qla2xxx_check_risc_status(vha);
 
@@ -2174,9 +2148,8 @@ qla24xx_intr_handler(int irq, void *dev_id)
                         qla24xx_process_response_queue(vha, rsp);
                         break;
                 default:
-                        DEBUG2(printk("scsi(%ld): Unrecognized interrupt type "
-                            "(%d).\n",
-                            vha->host_no, stat & 0xff));
+                        ql_dbg(ql_dbg_async, vha, 0x504f,
+                            "Unrecognized interrupt type (%d).\n", stat * 0xff);
                         break;
                 }
                 WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
@@ -2205,7 +2178,7 @@ qla24xx_msix_rsp_q(int irq, void *dev_id)
         rsp = (struct rsp_que *) dev_id;
         if (!rsp) {
                 printk(KERN_INFO
-                "%s(): NULL response queue pointer\n", __func__);
+                "%s(): NULL response queue pointer.\n", __func__);
                 return IRQ_NONE;
         }
         ha = rsp->hw;
@@ -2235,7 +2208,7 @@ qla25xx_msix_rsp_q(int irq, void *dev_id)
         rsp = (struct rsp_que *) dev_id;
         if (!rsp) {
                 printk(KERN_INFO
-                        "%s(): NULL response queue pointer\n", __func__);
+                        "%s(): NULL response queue pointer.\n", __func__);
                 return IRQ_NONE;
         }
         ha = rsp->hw;
@@ -2268,8 +2241,8 @@ qla24xx_msix_default(int irq, void *dev_id)
 
         rsp = (struct rsp_que *) dev_id;
         if (!rsp) {
-                DEBUG(printk(
-                "%s(): NULL response queue pointer\n", __func__));
+                printk(KERN_INFO
+                        "%s(): NULL response queue pointer.\n", __func__);
                 return IRQ_NONE;
         }
         ha = rsp->hw;
@@ -2286,8 +2259,9 @@ qla24xx_msix_default(int irq, void *dev_id)
 
                         hccr = RD_REG_DWORD(&reg->hccr);
 
-                        qla_printk(KERN_INFO, ha, "RISC paused -- HCCR=%x, "
-                            "Dumping firmware!\n", hccr);
+                        ql_log(ql_log_info, vha, 0x5050,
+                            "RISC paused -- HCCR=%x, Dumping firmware.\n",
+                            hccr);
 
                         qla2xxx_check_risc_status(vha);
 
@@ -2318,9 +2292,8 @@ qla24xx_msix_default(int irq, void *dev_id)
                         qla24xx_process_response_queue(vha, rsp);
                         break;
                 default:
-                        DEBUG2(printk("scsi(%ld): Unrecognized interrupt type "
-                            "(%d).\n",
-                            vha->host_no, stat & 0xff));
+                        ql_dbg(ql_dbg_async, vha, 0x5051,
+                            "Unrecognized interrupt type (%d).\n", stat & 0xff);
                         break;
                 }
                 WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
@@ -2358,6 +2331,7 @@ qla24xx_disable_msix(struct qla_hw_data *ha)
 {
         int i;
         struct qla_msix_entry *qentry;
+        scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
 
         for (i = 0; i < ha->msix_count; i++) {
                 qentry = &ha->msix_entries[i];
@@ -2368,6 +2342,8 @@ qla24xx_disable_msix(struct qla_hw_data *ha)
         kfree(ha->msix_entries);
         ha->msix_entries = NULL;
         ha->flags.msix_enabled = 0;
+        ql_dbg(ql_dbg_init, vha, 0x0042,
+            "Disabled the MSI.\n");
 }
 
 static int
@@ -2377,11 +2353,15 @@ qla24xx_enable_msix(struct qla_hw_data *ha, struct rsp_que *rsp)
         int i, ret;
         struct msix_entry *entries;
         struct qla_msix_entry *qentry;
+        scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
 
         entries = kzalloc(sizeof(struct msix_entry) * ha->msix_count,
                         GFP_KERNEL);
-        if (!entries)
+        if (!entries) {
+                ql_log(ql_log_warn, vha, 0x00bc,
+                    "Failed to allocate memory for msix_entry.\n");
                 return -ENOMEM;
+        }
 
         for (i = 0; i < ha->msix_count; i++)
                 entries[i].entry = i;
@@ -2391,16 +2371,18 @@ qla24xx_enable_msix(struct qla_hw_data *ha, struct rsp_que *rsp)
                 if (ret < MIN_MSIX_COUNT)
                         goto msix_failed;
 
-                qla_printk(KERN_WARNING, ha,
-                        "MSI-X: Failed to enable support -- %d/%d\n"
-                        " Retry with %d vectors\n", ha->msix_count, ret, ret);
+                ql_log(ql_log_warn, vha, 0x00c6,
+                    "MSI-X: Failed to enable support "
+                    "-- %d/%d\n Retry with %d vectors.\n",
+                    ha->msix_count, ret, ret);
                 ha->msix_count = ret;
                 ret = pci_enable_msix(ha->pdev, entries, ha->msix_count);
                 if (ret) {
 msix_failed:
-                        qla_printk(KERN_WARNING, ha, "MSI-X: Failed to enable"
-                                " support, giving up -- %d/%d\n",
-                                ha->msix_count, ret);
+                        ql_log(ql_log_fatal, vha, 0x00c7,
+                            "MSI-X: Failed to enable support, "
+                            "giving   up -- %d/%d.\n",
+                            ha->msix_count, ret);
                         goto msix_out;
                 }
                 ha->max_rsp_queues = ha->msix_count - 1;
@@ -2408,6 +2390,8 @@ msix_failed:
         ha->msix_entries = kzalloc(sizeof(struct qla_msix_entry) *
                                 ha->msix_count, GFP_KERNEL);
         if (!ha->msix_entries) {
+                ql_log(ql_log_fatal, vha, 0x00c8,
+                    "Failed to allocate memory for ha->msix_entries.\n");
                 ret = -ENOMEM;
                 goto msix_out;
         }
@@ -2434,9 +2418,9 @@ msix_failed:
                                 0, msix_entries[i].name, rsp);
                 }
                 if (ret) {
-                        qla_printk(KERN_WARNING, ha,
-                        "MSI-X: Unable to register handler -- %x/%d.\n",
-                        qentry->vector, ret);
+                        ql_log(ql_log_fatal, vha, 0x00cb,
+                            "MSI-X: unable to register handler -- %x/%d.\n",
+                            qentry->vector, ret);
                         qla24xx_disable_msix(ha);
                         ha->mqenable = 0;
                         goto msix_out;
@@ -2449,6 +2433,12 @@ msix_failed:
         /* Enable MSI-X vector for response queue update for queue 0 */
         if (ha->mqiobase &&  (ha->max_rsp_queues > 1 || ha->max_req_queues > 1))
                 ha->mqenable = 1;
+        ql_dbg(ql_dbg_multiq, vha, 0xc005,
+            "mqiobase=%p, max_rsp_queues=%d, max_req_queues=%d.\n",
+            ha->mqiobase, ha->max_rsp_queues, ha->max_req_queues);
+        ql_dbg(ql_dbg_init, vha, 0x0055,
+            "mqiobase=%p, max_rsp_queues=%d, max_req_queues=%d.\n",
+            ha->mqiobase, ha->max_rsp_queues, ha->max_req_queues);
 
 msix_out:
         kfree(entries);
@@ -2460,6 +2450,7 @@ qla2x00_request_irqs(struct qla_hw_data *ha, struct rsp_que *rsp)
 {
         int ret;
         device_reg_t __iomem *reg = ha->iobase;
+        scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
 
         /* If possible, enable MSI-X. */
         if (!IS_QLA2432(ha) && !IS_QLA2532(ha) &&
@@ -2470,30 +2461,30 @@ qla2x00_request_irqs(struct qla_hw_data *ha, struct rsp_que *rsp)
                 (ha->pdev->subsystem_device == 0x7040 ||
                 ha->pdev->subsystem_device == 0x7041 ||
                 ha->pdev->subsystem_device == 0x1705)) {
-                DEBUG2(qla_printk(KERN_WARNING, ha,
-                        "MSI-X: Unsupported ISP2432 SSVID/SSDID (0x%X,0x%X).\n",
+                ql_log(ql_log_warn, vha, 0x0034,
+                    "MSI-X: Unsupported ISP 2432 SSVID/SSDID (0x%X,0x%X).\n",
                         ha->pdev->subsystem_vendor,
-                        ha->pdev->subsystem_device));
+                        ha->pdev->subsystem_device);
                 goto skip_msi;
         }
 
         if (IS_QLA2432(ha) && (ha->pdev->revision < QLA_MSIX_CHIP_REV_24XX ||
                 !QLA_MSIX_FW_MODE_1(ha->fw_attributes))) {
-                DEBUG2(qla_printk(KERN_WARNING, ha,
-                "MSI-X: Unsupported ISP2432 (0x%X, 0x%X).\n",
-                        ha->pdev->revision, ha->fw_attributes));
+                ql_log(ql_log_warn, vha, 0x0035,
+                    "MSI-X; Unsupported ISP2432 (0x%X, 0x%X).\n",
+                    ha->pdev->revision, ha->fw_attributes);
                 goto skip_msix;
         }
 
         ret = qla24xx_enable_msix(ha, rsp);
         if (!ret) {
-                DEBUG2(qla_printk(KERN_INFO, ha,
-                    "MSI-X: Enabled (0x%X, 0x%X).\n", ha->chip_revision,
-                    ha->fw_attributes));
+                ql_dbg(ql_dbg_init, vha, 0x0036,
+                    "MSI-X: Enabled (0x%X, 0x%X).\n",
+                    ha->chip_revision, ha->fw_attributes);
                 goto clear_risc_ints;
         }
-        qla_printk(KERN_WARNING, ha,
-            "MSI-X: Falling back-to MSI mode -- %d.\n", ret);
+        ql_log(ql_log_info, vha, 0x0037,
+            "MSI-X Falling back-to MSI mode -%d.\n", ret);
 skip_msix:
 
         if (!IS_QLA24XX(ha) && !IS_QLA2532(ha) && !IS_QLA8432(ha) &&
@@ -2502,18 +2493,19 @@ skip_msix:
 
         ret = pci_enable_msi(ha->pdev);
         if (!ret) {
-                DEBUG2(qla_printk(KERN_INFO, ha, "MSI: Enabled.\n"));
+                ql_dbg(ql_dbg_init, vha, 0x0038,
+                    "MSI: Enabled.\n");
                 ha->flags.msi_enabled = 1;
         } else
-                qla_printk(KERN_WARNING, ha,
-                    "MSI-X: Falling back-to INTa mode -- %d.\n", ret);
+                ql_log(ql_log_warn, vha, 0x0039,
+                    "MSI-X; Falling back-to INTa mode -- %d.\n", ret);
 skip_msi:
 
         ret = request_irq(ha->pdev->irq, ha->isp_ops->intr_handler,
             ha->flags.msi_enabled ? 0 : IRQF_SHARED,
             QLA2XXX_DRIVER_NAME, rsp);
         if (ret) {
-                qla_printk(KERN_WARNING, ha,
+                ql_log(ql_log_warn, vha, 0x003a,
                     "Failed to reserve interrupt %d already in use.\n",
                     ha->pdev->irq);
                 goto fail;
@@ -2563,13 +2555,14 @@ int qla25xx_request_irq(struct rsp_que *rsp)
         struct qla_hw_data *ha = rsp->hw;
         struct qla_init_msix_entry *intr = &msix_entries[2];
         struct qla_msix_entry *msix = rsp->msix;
+        scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
         int ret;
 
         ret = request_irq(msix->vector, intr->handler, 0, intr->name, rsp);
         if (ret) {
-                qla_printk(KERN_WARNING, ha,
-                        "MSI-X: Unable to register handler -- %x/%d.\n",
-                        msix->vector, ret);
+                ql_log(ql_log_fatal, vha, 0x00e6,
+                    "MSI-X: Unable to register handler -- %x/%d.\n",
+                    msix->vector, ret);
                 return ret;
         }
         msix->have_irq = 1;
diff --git a/drivers/scsi/qla2xxx/qla_mbx.c b/drivers/scsi/qla2xxx/qla_mbx.c
index c26f0acdfecc..f7604ea1af83 100644
--- a/drivers/scsi/qla2xxx/qla_mbx.c
+++ b/drivers/scsi/qla2xxx/qla_mbx.c
@@ -46,14 +46,18 @@ qla2x00_mailbox_command(scsi_qla_host_t *vha, mbx_cmd_t *mcp)
         struct qla_hw_data *ha = vha->hw;
         scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
 
-        if (ha->pdev->error_state > pci_channel_io_frozen)
+        ql_dbg(ql_dbg_mbx, base_vha, 0x1000, "Entered %s.\n", __func__);
+
+        if (ha->pdev->error_state > pci_channel_io_frozen) {
+                ql_log(ql_log_warn, base_vha, 0x1001,
+                    "error_state is greater than pci_channel_io_frozen, "
+                    "exiting.\n");
                 return QLA_FUNCTION_TIMEOUT;
+        }
 
         if (vha->device_flags & DFLG_DEV_FAILED) {
-                DEBUG2_3_11(qla_printk(KERN_WARNING, ha,
-                        "%s(%ld): Device in failed state, "
-                        "timeout MBX Exiting.\n",
-                        __func__, base_vha->host_no));
+                ql_log(ql_log_warn, base_vha, 0x1002,
+                    "Device in failed state, exiting.\n");
                 return QLA_FUNCTION_TIMEOUT;
         }
 
@@ -63,17 +67,18 @@ qla2x00_mailbox_command(scsi_qla_host_t *vha, mbx_cmd_t *mcp)
         rval = QLA_SUCCESS;
         abort_active = test_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);
 
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, base_vha->host_no));
 
         if (ha->flags.pci_channel_io_perm_failure) {
-                DEBUG(printk("%s(%ld): Perm failure on EEH, timeout MBX "
-                             "Exiting.\n", __func__, vha->host_no));
+                ql_log(ql_log_warn, base_vha, 0x1003,
+                    "Perm failure on EEH timeout MBX, exiting.\n");
                 return QLA_FUNCTION_TIMEOUT;
         }
 
         if (ha->flags.isp82xx_fw_hung) {
                 /* Setting Link-Down error */
                 mcp->mb[0] = MBS_LINK_DOWN_ERROR;
+                ql_log(ql_log_warn, base_vha, 0x1004,
+                    "FW hung = %d.\n", ha->flags.isp82xx_fw_hung);
                 rval = QLA_FUNCTION_FAILED;
                 goto premature_exit;
         }
@@ -85,8 +90,8 @@ qla2x00_mailbox_command(scsi_qla_host_t *vha, mbx_cmd_t *mcp)
          */
         if (!wait_for_completion_timeout(&ha->mbx_cmd_comp, mcp->tov * HZ)) {
                 /* Timeout occurred. Return error. */
-                DEBUG2_3_11(printk("%s(%ld): cmd access timeout. "
-                    "Exiting.\n", __func__, base_vha->host_no));
+                ql_log(ql_log_warn, base_vha, 0x1005,
+                    "Cmd access timeout, Exiting.\n");
                 return QLA_FUNCTION_TIMEOUT;
         }
 
@@ -94,8 +99,8 @@ qla2x00_mailbox_command(scsi_qla_host_t *vha, mbx_cmd_t *mcp)
         /* Save mailbox command for debug */
         ha->mcp = mcp;
 
-        DEBUG11(printk("scsi(%ld): prepare to issue mbox cmd=0x%x.\n",
-            base_vha->host_no, mcp->mb[0]));
+        ql_dbg(ql_dbg_mbx, base_vha, 0x1006,
+            "Prepare to issue mbox cmd=0x%x.\n", mcp->mb[0]);
 
         spin_lock_irqsave(&ha->hardware_lock, flags);
 
@@ -123,27 +128,30 @@ qla2x00_mailbox_command(scsi_qla_host_t *vha, mbx_cmd_t *mcp)
                 iptr++;
         }
 
-#if defined(QL_DEBUG_LEVEL_1)
-        printk("%s(%ld): Loaded MBX registers (displayed in bytes) = \n",
-            __func__, base_vha->host_no);
-        qla2x00_dump_buffer((uint8_t *)mcp->mb, 16);
-        printk("\n");
-        qla2x00_dump_buffer(((uint8_t *)mcp->mb + 0x10), 16);
-        printk("\n");
-        qla2x00_dump_buffer(((uint8_t *)mcp->mb + 0x20), 8);
-        printk("\n");
-        printk("%s(%ld): I/O address = %p.\n", __func__, base_vha->host_no,
-                optr);
-        qla2x00_dump_regs(base_vha);
-#endif
+        ql_dbg(ql_dbg_mbx + ql_dbg_buffer, base_vha, 0x1111,
+            "Loaded MBX registers (displayed in bytes) =.\n");
+        ql_dump_buffer(ql_dbg_mbx + ql_dbg_buffer, base_vha, 0x1112,
+            (uint8_t *)mcp->mb, 16);
+        ql_dbg(ql_dbg_mbx + ql_dbg_buffer, base_vha, 0x1113,
+            ".\n");
+        ql_dump_buffer(ql_dbg_mbx + ql_dbg_buffer, base_vha, 0x1114,
+            ((uint8_t *)mcp->mb + 0x10), 16);
+        ql_dbg(ql_dbg_mbx + ql_dbg_buffer, base_vha, 0x1115,
+            ".\n");
+        ql_dump_buffer(ql_dbg_mbx + ql_dbg_buffer, base_vha, 0x1116,
+            ((uint8_t *)mcp->mb + 0x20), 8);
+        ql_dbg(ql_dbg_mbx + ql_dbg_buffer, base_vha, 0x1117,
+            "I/O Address = %p.\n", optr);
+        ql_dump_regs(ql_dbg_mbx + ql_dbg_buffer, base_vha, 0x100e);
 
         /* Issue set host interrupt command to send cmd out. */
         ha->flags.mbox_int = 0;
         clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
 
         /* Unlock mbx registers and wait for interrupt */
-        DEBUG11(printk("%s(%ld): going to unlock irq & waiting for interrupt. "
-            "jiffies=%lx.\n", __func__, base_vha->host_no, jiffies));
+        ql_dbg(ql_dbg_mbx, base_vha, 0x100f,
+            "Going to unlock irq & waiting for interrupts. "
+            "jiffies=%lx.\n", jiffies);
 
         /* Wait for mbx cmd completion until timeout */
 
@@ -155,9 +163,8 @@ qla2x00_mailbox_command(scsi_qla_host_t *vha, mbx_cmd_t *mcp)
                                 HINT_MBX_INT_PENDING) {
                                 spin_unlock_irqrestore(&ha->hardware_lock,
                                         flags);
-                                DEBUG2_3_11(printk(KERN_INFO
-                                    "%s(%ld): Pending Mailbox timeout. "
-                                    "Exiting.\n", __func__, base_vha->host_no));
+                                ql_dbg(ql_dbg_mbx, base_vha, 0x1010,
+                                    "Pending mailbox timeout, exiting.\n");
                                 rval = QLA_FUNCTION_TIMEOUT;
                                 goto premature_exit;
                         }
@@ -173,17 +180,16 @@ qla2x00_mailbox_command(scsi_qla_host_t *vha, mbx_cmd_t *mcp)
                 clear_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags);
 
         } else {
-                DEBUG3_11(printk("%s(%ld): cmd=%x POLLING MODE.\n", __func__,
-                    base_vha->host_no, command));
+                ql_dbg(ql_dbg_mbx, base_vha, 0x1011,
+                    "Cmd=%x Polling Mode.\n", command);
 
                 if (IS_QLA82XX(ha)) {
                         if (RD_REG_DWORD(&reg->isp82.hint) &
                                 HINT_MBX_INT_PENDING) {
                                 spin_unlock_irqrestore(&ha->hardware_lock,
                                         flags);
-                                DEBUG2_3_11(printk(KERN_INFO
-                                    "%s(%ld): Pending Mailbox timeout. "
-                                    "Exiting.\n", __func__, base_vha->host_no));
+                                ql_dbg(ql_dbg_mbx, base_vha, 0x1012,
+                                    "Pending mailbox timeout, exiting.\n");
                                 rval = QLA_FUNCTION_TIMEOUT;
                                 goto premature_exit;
                         }
@@ -207,17 +213,17 @@ qla2x00_mailbox_command(scsi_qla_host_t *vha, mbx_cmd_t *mcp)
                             command == MBC_LOAD_RISC_RAM_EXTENDED))
                                 msleep(10);
                 } /* while */
-                DEBUG17(qla_printk(KERN_WARNING, ha,
-                        "Waited %d sec\n",
-                        (uint)((jiffies - (wait_time - (mcp->tov * HZ)))/HZ)));
+                ql_dbg(ql_dbg_mbx, base_vha, 0x1013,
+                    "Waited %d sec.\n",
+                    (uint)((jiffies - (wait_time - (mcp->tov * HZ)))/HZ));
         }
 
         /* Check whether we timed out */
         if (ha->flags.mbox_int) {
                 uint16_t *iptr2;
 
-                DEBUG3_11(printk("%s(%ld): cmd %x completed.\n", __func__,
-                    base_vha->host_no, command));
+                ql_dbg(ql_dbg_mbx, base_vha, 0x1014,
+                    "Cmd=%x completed.\n", command);
 
                 /* Got interrupt. Clear the flag. */
                 ha->flags.mbox_int = 0;
@@ -229,6 +235,8 @@ qla2x00_mailbox_command(scsi_qla_host_t *vha, mbx_cmd_t *mcp)
                         mcp->mb[0] = MBS_LINK_DOWN_ERROR;
                         ha->mcp = NULL;
                         rval = QLA_FUNCTION_FAILED;
+                        ql_log(ql_log_warn, base_vha, 0x1015,
+                            "FW hung = %d.\n", ha->flags.isp82xx_fw_hung);
                         goto premature_exit;
                 }
 
@@ -249,8 +257,6 @@ qla2x00_mailbox_command(scsi_qla_host_t *vha, mbx_cmd_t *mcp)
                 }
         } else {
 
-#if defined(QL_DEBUG_LEVEL_2) || defined(QL_DEBUG_LEVEL_3) || \
-                defined(QL_DEBUG_LEVEL_11)
                 uint16_t mb0;
                 uint32_t ictrl;
 
@@ -261,14 +267,13 @@ qla2x00_mailbox_command(scsi_qla_host_t *vha, mbx_cmd_t *mcp)
                         mb0 = RD_MAILBOX_REG(ha, &reg->isp, 0);
                         ictrl = RD_REG_WORD(&reg->isp.ictrl);
                 }
-                printk("%s(%ld): **** MB Command Timeout for cmd %x ****\n",
-                    __func__, base_vha->host_no, command);
-                printk("%s(%ld): icontrol=%x jiffies=%lx\n", __func__,
-                    base_vha->host_no, ictrl, jiffies);
-                printk("%s(%ld): *** mailbox[0] = 0x%x ***\n", __func__,
-                    base_vha->host_no, mb0);
-                qla2x00_dump_regs(base_vha);
-#endif
+                ql_dbg(ql_dbg_mbx + ql_dbg_buffer, base_vha, 0x1119,
+                    "MBX Command timeout for cmd %x.\n", command);
+                ql_dbg(ql_dbg_mbx + ql_dbg_buffer, base_vha, 0x111a,
+                    "iocontrol=%x jiffies=%lx.\n", ictrl, jiffies);
+                ql_dbg(ql_dbg_mbx + ql_dbg_buffer, base_vha, 0x111b,
+                    "mb[0] = 0x%x.\n", mb0);
+                ql_dump_regs(ql_dbg_mbx + ql_dbg_buffer, base_vha, 0x1019);
 
                 rval = QLA_FUNCTION_TIMEOUT;
         }
@@ -279,8 +284,8 @@ qla2x00_mailbox_command(scsi_qla_host_t *vha, mbx_cmd_t *mcp)
         ha->mcp = NULL;
 
         if ((abort_active || !io_lock_on) && !IS_NOPOLLING_TYPE(ha)) {
-                DEBUG11(printk("%s(%ld): checking for additional resp "
-                    "interrupt.\n", __func__, base_vha->host_no));
+                ql_dbg(ql_dbg_mbx, base_vha, 0x101a,
+                    "Checking for additional resp interrupt.\n");
 
                 /* polling mode for non isp_abort commands. */
                 qla2x00_poll(ha->rsp_q_map[0]);
@@ -291,38 +296,32 @@ qla2x00_mailbox_command(scsi_qla_host_t *vha, mbx_cmd_t *mcp)
                 if (!io_lock_on || (mcp->flags & IOCTL_CMD) ||
                     ha->flags.eeh_busy) {
                         /* not in dpc. schedule it for dpc to take over. */
-                        DEBUG(printk("%s(%ld): timeout schedule "
-                        "isp_abort_needed.\n", __func__,
-                        base_vha->host_no));
-                        DEBUG2_3_11(printk("%s(%ld): timeout schedule "
-                        "isp_abort_needed.\n", __func__,
-                        base_vha->host_no));
+                        ql_dbg(ql_dbg_mbx, base_vha, 0x101b,
+                            "Timeout, schedule isp_abort_needed.\n");
 
                         if (!test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags) &&
                             !test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags) &&
                             !test_bit(ISP_ABORT_RETRY, &vha->dpc_flags)) {
 
-                                qla_printk(KERN_WARNING, ha,
-                                    "Mailbox command timeout occurred. "
-                                    "Scheduling ISP " "abort. eeh_busy: 0x%x\n",
-                                    ha->flags.eeh_busy);
+                                ql_log(ql_log_info, base_vha, 0x101c,
+                                    "Mailbox cmd timeout occured. "
+                                    "Scheduling ISP abort eeh_busy=0x%x.\n",
+                                        ha->flags.eeh_busy);
                                 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
                                 qla2xxx_wake_dpc(vha);
                         }
                 } else if (!abort_active) {
                         /* call abort directly since we are in the DPC thread */
-                        DEBUG(printk("%s(%ld): timeout calling abort_isp\n",
-                            __func__, base_vha->host_no));
-                        DEBUG2_3_11(printk("%s(%ld): timeout calling "
-                            "abort_isp\n", __func__, base_vha->host_no));
+                        ql_dbg(ql_dbg_mbx, base_vha, 0x101d,
+                            "Timeout, calling abort_isp.\n");
 
                         if (!test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags) &&
                             !test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags) &&
                             !test_bit(ISP_ABORT_RETRY, &vha->dpc_flags)) {
 
-                                qla_printk(KERN_WARNING, ha,
-                                    "Mailbox command timeout occurred. "
-                                    "Issuing ISP abort.\n");
+                                ql_log(ql_log_info, base_vha, 0x101e,
+                                    "Mailbox cmd timeout occured. "
+                                    "Scheduling ISP abort.\n");
 
                                 set_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags);
                                 clear_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
@@ -332,11 +331,8 @@ qla2x00_mailbox_command(scsi_qla_host_t *vha, mbx_cmd_t *mcp)
                                             &vha->dpc_flags);
                                 }
                                 clear_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags);
-                                DEBUG(printk("%s(%ld): finished abort_isp\n",
-                                    __func__, vha->host_no));
-                                DEBUG2_3_11(printk(
-                                    "%s(%ld): finished abort_isp\n",
-                                    __func__, vha->host_no));
+                                ql_dbg(ql_dbg_mbx, base_vha, 0x101f,
+                                    "Finished abort_isp.\n");
                         }
                 }
         }
@@ -346,12 +342,11 @@ premature_exit:
         complete(&ha->mbx_cmd_comp);
 
         if (rval) {
-                DEBUG2_3_11(printk("%s(%ld): **** FAILED. mbx0=%x, mbx1=%x, "
-                    "mbx2=%x, cmd=%x ****\n", __func__, base_vha->host_no,
-                    mcp->mb[0], mcp->mb[1], mcp->mb[2], command));
+                ql_dbg(ql_dbg_mbx, base_vha, 0x1020,
+                    "**** Failed mbx[0]=%x, mb[1]=%x, mb[2]=%x, cmd=%x ****.\n",
+                    mcp->mb[0], mcp->mb[1], mcp->mb[2], command);
         } else {
-                DEBUG11(printk("%s(%ld): done.\n", __func__,
-                base_vha->host_no));
+                ql_dbg(ql_dbg_mbx, base_vha, 0x1021, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -366,7 +361,7 @@ qla2x00_load_ram(scsi_qla_host_t *vha, dma_addr_t req_dma, uint32_t risc_addr,
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
 
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x1022, "Entered %s.\n", __func__);
 
         if (MSW(risc_addr) || IS_FWI2_CAPABLE(ha)) {
                 mcp->mb[0] = MBC_LOAD_RISC_RAM_EXTENDED;
@@ -397,10 +392,10 @@ qla2x00_load_ram(scsi_qla_host_t *vha, dma_addr_t req_dma, uint32_t risc_addr,
         rval = qla2x00_mailbox_command(vha, mcp);
 
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x.\n", __func__,
-                    vha->host_no, rval, mcp->mb[0]));
+                ql_dbg(ql_dbg_mbx, vha, 0x1023,
+                    "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
         } else {
-                DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x1024, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -430,7 +425,7 @@ qla2x00_execute_fw(scsi_qla_host_t *vha, uint32_t risc_addr)
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
 
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x1025, "Entered %s.\n", __func__);
 
         mcp->mb[0] = MBC_EXECUTE_FIRMWARE;
         mcp->out_mb = MBX_0;
@@ -461,15 +456,14 @@ qla2x00_execute_fw(scsi_qla_host_t *vha, uint32_t risc_addr)
         rval = qla2x00_mailbox_command(vha, mcp);
 
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x.\n", __func__,
-                    vha->host_no, rval, mcp->mb[0]));
+                ql_dbg(ql_dbg_mbx, vha, 0x1026,
+                    "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
         } else {
                 if (IS_FWI2_CAPABLE(ha)) {
-                        DEBUG11(printk("%s(%ld): done exchanges=%x.\n",
-                            __func__, vha->host_no, mcp->mb[1]));
+                        ql_dbg(ql_dbg_mbx, vha, 0x1027,
+                            "Done exchanges=%x.\n", mcp->mb[1]);
                 } else {
-                        DEBUG11(printk("%s(%ld): done.\n", __func__,
-                            vha->host_no));
+                        ql_dbg(ql_dbg_mbx, vha, 0x1028, "Done %s.\n", __func__);
                 }
         }
 
@@ -501,7 +495,7 @@ qla2x00_get_fw_version(scsi_qla_host_t *vha, uint16_t *major, uint16_t *minor,
         mbx_cmd_t       mc;
         mbx_cmd_t       *mcp = &mc;
 
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x1029, "Entered %s.\n", __func__);
 
         mcp->mb[0] = MBC_GET_FIRMWARE_VERSION;
         mcp->out_mb = MBX_0;
@@ -535,11 +529,10 @@ qla2x00_get_fw_version(scsi_qla_host_t *vha, uint16_t *major, uint16_t *minor,
 failed:
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
-                DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
-                    vha->host_no, rval));
+                ql_dbg(ql_dbg_mbx, vha, 0x102a, "Failed=%x.\n", rval);
         } else {
                 /*EMPTY*/
-                DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x102b, "Done %s.\n", __func__);
         }
         return rval;
 }
@@ -565,7 +558,7 @@ qla2x00_get_fw_options(scsi_qla_host_t *vha, uint16_t *fwopts)
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
 
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x102c, "Entered %s.\n", __func__);
 
         mcp->mb[0] = MBC_GET_FIRMWARE_OPTION;
         mcp->out_mb = MBX_0;
@@ -576,15 +569,14 @@ qla2x00_get_fw_options(scsi_qla_host_t *vha, uint16_t *fwopts)
 
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
-                DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
-                    vha->host_no, rval));
+                ql_dbg(ql_dbg_mbx, vha, 0x102d, "Failed=%x.\n", rval);
         } else {
                 fwopts[0] = mcp->mb[0];
                 fwopts[1] = mcp->mb[1];
                 fwopts[2] = mcp->mb[2];
                 fwopts[3] = mcp->mb[3];
 
-                DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x102e, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -612,7 +604,7 @@ qla2x00_set_fw_options(scsi_qla_host_t *vha, uint16_t *fwopts)
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
 
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x102f, "Entered %s.\n", __func__);
 
         mcp->mb[0] = MBC_SET_FIRMWARE_OPTION;
         mcp->mb[1] = fwopts[1];
@@ -636,11 +628,11 @@ qla2x00_set_fw_options(scsi_qla_host_t *vha, uint16_t *fwopts)
 
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
-                DEBUG2_3_11(printk("%s(%ld): failed=%x (%x/%x).\n", __func__,
-                    vha->host_no, rval, mcp->mb[0], mcp->mb[1]));
+                ql_dbg(ql_dbg_mbx, vha, 0x1030,
+                    "Failed=%x (%x/%x).\n", rval, mcp->mb[0], mcp->mb[1]);
         } else {
                 /*EMPTY*/
-                DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x1031, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -668,7 +660,7 @@ qla2x00_mbx_reg_test(scsi_qla_host_t *vha)
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
 
-        DEBUG11(printk("qla2x00_mbx_reg_test(%ld): entered.\n", vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x1032, "Entered %s.\n", __func__);
 
         mcp->mb[0] = MBC_MAILBOX_REGISTER_TEST;
         mcp->mb[1] = 0xAAAA;
@@ -695,12 +687,10 @@ qla2x00_mbx_reg_test(scsi_qla_host_t *vha)
 
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
-                DEBUG2_3_11(printk("qla2x00_mbx_reg_test(%ld): failed=%x.\n",
-                    vha->host_no, rval));
+                ql_dbg(ql_dbg_mbx, vha, 0x1033, "Failed=%x.\n", rval);
         } else {
                 /*EMPTY*/
-                DEBUG11(printk("qla2x00_mbx_reg_test(%ld): done.\n",
-                    vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x1034, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -728,7 +718,7 @@ qla2x00_verify_checksum(scsi_qla_host_t *vha, uint32_t risc_addr)
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
 
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x1035, "Entered %s.\n", __func__);
 
         mcp->mb[0] = MBC_VERIFY_CHECKSUM;
         mcp->out_mb = MBX_0;
@@ -749,11 +739,11 @@ qla2x00_verify_checksum(scsi_qla_host_t *vha, uint32_t risc_addr)
         rval = qla2x00_mailbox_command(vha, mcp);
 
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk("%s(%ld): failed=%x chk sum=%x.\n", __func__,
-                    vha->host_no, rval, IS_FWI2_CAPABLE(vha->hw) ?
-                    (mcp->mb[2] << 16) | mcp->mb[1]: mcp->mb[1]));
+                ql_dbg(ql_dbg_mbx, vha, 0x1036,
+                    "Failed=%x chm sum=%x.\n", rval, IS_FWI2_CAPABLE(vha->hw) ?
+                    (mcp->mb[2] << 16) | mcp->mb[1] : mcp->mb[1]);
         } else {
-                DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x1037, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -785,6 +775,8 @@ qla2x00_issue_iocb_timeout(scsi_qla_host_t *vha, void *buffer,
         mbx_cmd_t       mc;
         mbx_cmd_t       *mcp = &mc;
 
+        ql_dbg(ql_dbg_mbx, vha, 0x1038, "Entered %s.\n", __func__);
+
         mcp->mb[0] = MBC_IOCB_COMMAND_A64;
         mcp->mb[1] = 0;
         mcp->mb[2] = MSW(phys_addr);
@@ -799,14 +791,14 @@ qla2x00_issue_iocb_timeout(scsi_qla_host_t *vha, void *buffer,
 
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
-                DEBUG(printk("qla2x00_issue_iocb(%ld): failed rval 0x%x\n",
-                    vha->host_no, rval));
+                ql_dbg(ql_dbg_mbx, vha, 0x1039, "Failed=%x.\n", rval);
         } else {
                 sts_entry_t *sts_entry = (sts_entry_t *) buffer;
 
                 /* Mask reserved bits. */
                 sts_entry->entry_status &=
                     IS_FWI2_CAPABLE(vha->hw) ? RF_MASK_24XX : RF_MASK;
+                ql_dbg(ql_dbg_mbx, vha, 0x103a, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -847,7 +839,7 @@ qla2x00_abort_command(srb_t *sp)
         struct qla_hw_data *ha = vha->hw;
         struct req_que *req = vha->req;
 
-        DEBUG11(printk("qla2x00_abort_command(%ld): entered.\n", vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x103b, "Entered %s.\n", __func__);
 
         spin_lock_irqsave(&ha->hardware_lock, flags);
         for (handle = 1; handle < MAX_OUTSTANDING_COMMANDS; handle++) {
@@ -876,11 +868,9 @@ qla2x00_abort_command(srb_t *sp)
         rval = qla2x00_mailbox_command(vha, mcp);
 
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk("qla2x00_abort_command(%ld): failed=%x.\n",
-                    vha->host_no, rval));
+                ql_dbg(ql_dbg_mbx, vha, 0x103c, "Failed=%x.\n", rval);
         } else {
-                DEBUG11(printk("qla2x00_abort_command(%ld): done.\n",
-                    vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x103d, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -896,10 +886,11 @@ qla2x00_abort_target(struct fc_port *fcport, unsigned int l, int tag)
         struct req_que *req;
         struct rsp_que *rsp;
 
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, fcport->vha->host_no));
-
         l = l;
         vha = fcport->vha;
+
+        ql_dbg(ql_dbg_mbx, vha, 0x103e, "Entered %s.\n", __func__);
+
         req = vha->hw->req_q_map[0];
         rsp = req->rsp;
         mcp->mb[0] = MBC_ABORT_TARGET;
@@ -919,18 +910,17 @@ qla2x00_abort_target(struct fc_port *fcport, unsigned int l, int tag)
         mcp->flags = 0;
         rval = qla2x00_mailbox_command(vha, mcp);
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
-                    vha->host_no, rval));
+                ql_dbg(ql_dbg_mbx, vha, 0x103f, "Failed=%x.\n", rval);
         }
 
         /* Issue marker IOCB. */
         rval2 = qla2x00_marker(vha, req, rsp, fcport->loop_id, 0,
                                                         MK_SYNC_ID);
         if (rval2 != QLA_SUCCESS) {
-                DEBUG2_3_11(printk("%s(%ld): failed to issue Marker IOCB "
-                    "(%x).\n", __func__, vha->host_no, rval2));
+                ql_dbg(ql_dbg_mbx, vha, 0x1040,
+                    "Failed to issue marker IOCB (%x).\n", rval2);
         } else {
-                DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x1041, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -946,9 +936,10 @@ qla2x00_lun_reset(struct fc_port *fcport, unsigned int l, int tag)
         struct req_que *req;
         struct rsp_que *rsp;
 
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, fcport->vha->host_no));
-
         vha = fcport->vha;
+
+        ql_dbg(ql_dbg_mbx, vha, 0x1042, "Entered %s.\n", __func__);
+
         req = vha->hw->req_q_map[0];
         rsp = req->rsp;
         mcp->mb[0] = MBC_LUN_RESET;
@@ -966,18 +957,17 @@ qla2x00_lun_reset(struct fc_port *fcport, unsigned int l, int tag)
         mcp->flags = 0;
         rval = qla2x00_mailbox_command(vha, mcp);
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
-                    vha->host_no, rval));
+                ql_dbg(ql_dbg_mbx, vha, 0x1043, "Failed=%x.\n", rval);
         }
 
         /* Issue marker IOCB. */
         rval2 = qla2x00_marker(vha, req, rsp, fcport->loop_id, l,
                                                                 MK_SYNC_ID_LUN);
         if (rval2 != QLA_SUCCESS) {
-                DEBUG2_3_11(printk("%s(%ld): failed to issue Marker IOCB "
-                    "(%x).\n", __func__, vha->host_no, rval2));
+                ql_dbg(ql_dbg_mbx, vha, 0x1044,
+                    "Failed to issue marker IOCB (%x).\n", rval2);
         } else {
-                DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x1045, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -1011,8 +1001,7 @@ qla2x00_get_adapter_id(scsi_qla_host_t *vha, uint16_t *id, uint8_t *al_pa,
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
 
-        DEBUG11(printk("qla2x00_get_adapter_id(%ld): entered.\n",
-            vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x1046, "Entered %s.\n", __func__);
 
         mcp->mb[0] = MBC_GET_ADAPTER_LOOP_ID;
         mcp->mb[9] = vha->vp_idx;
@@ -1038,11 +1027,9 @@ qla2x00_get_adapter_id(scsi_qla_host_t *vha, uint16_t *id, uint8_t *al_pa,
 
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
-                DEBUG2_3_11(printk("qla2x00_get_adapter_id(%ld): failed=%x.\n",
-                    vha->host_no, rval));
+                ql_dbg(ql_dbg_mbx, vha, 0x1047, "Failed=%x.\n", rval);
         } else {
-                DEBUG11(printk("qla2x00_get_adapter_id(%ld): done.\n",
-                    vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x1048, "Done %s.\n", __func__);
 
                 if (IS_QLA8XXX_TYPE(vha->hw)) {
                         vha->fcoe_vlan_id = mcp->mb[9] & 0xfff;
@@ -1083,8 +1070,7 @@ qla2x00_get_retry_cnt(scsi_qla_host_t *vha, uint8_t *retry_cnt, uint8_t *tov,
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
 
-        DEBUG11(printk("qla2x00_get_retry_cnt(%ld): entered.\n",
-                        vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x1049, "Entered %s.\n", __func__);
 
         mcp->mb[0] = MBC_GET_RETRY_COUNT;
         mcp->out_mb = MBX_0;
@@ -1095,8 +1081,8 @@ qla2x00_get_retry_cnt(scsi_qla_host_t *vha, uint8_t *retry_cnt, uint8_t *tov,
 
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
-                DEBUG2_3_11(printk("qla2x00_get_retry_cnt(%ld): failed = %x.\n",
-                    vha->host_no, mcp->mb[0]));
+                ql_dbg(ql_dbg_mbx, vha, 0x104a,
+                    "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
         } else {
                 /* Convert returned data and check our values. */
                 *r_a_tov = mcp->mb[3] / 2;
@@ -1107,8 +1093,8 @@ qla2x00_get_retry_cnt(scsi_qla_host_t *vha, uint8_t *retry_cnt, uint8_t *tov,
                         *tov = ratov;
                 }
 
-                DEBUG11(printk("qla2x00_get_retry_cnt(%ld): done. mb3=%d "
-                    "ratov=%d.\n", vha->host_no, mcp->mb[3], ratov));
+                ql_dbg(ql_dbg_mbx, vha, 0x104b,
+                    "Done %s mb3=%d ratov=%d.\n", __func__, mcp->mb[3], ratov);
         }
 
         return rval;
@@ -1139,8 +1125,7 @@ qla2x00_init_firmware(scsi_qla_host_t *vha, uint16_t size)
         mbx_cmd_t *mcp = &mc;
         struct qla_hw_data *ha = vha->hw;
 
-        DEBUG11(printk("qla2x00_init_firmware(%ld): entered.\n",
-            vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x104c, "Entered %s.\n", __func__);
 
         if (IS_QLA82XX(ha) && ql2xdbwr)
                 qla82xx_wr_32(ha, ha->nxdb_wr_ptr,
@@ -1174,13 +1159,11 @@ qla2x00_init_firmware(scsi_qla_host_t *vha, uint16_t size)
 
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
-                DEBUG2_3_11(printk("qla2x00_init_firmware(%ld): failed=%x "
-                    "mb0=%x.\n",
-                    vha->host_no, rval, mcp->mb[0]));
+                ql_dbg(ql_dbg_mbx, vha, 0x104d,
+                    "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
         } else {
                 /*EMPTY*/
-                DEBUG11(printk("qla2x00_init_firmware(%ld): done.\n",
-                    vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x104e, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -1213,13 +1196,13 @@ qla2x00_get_port_database(scsi_qla_host_t *vha, fc_port_t *fcport, uint8_t opt)
         dma_addr_t pd_dma;
         struct qla_hw_data *ha = vha->hw;
 
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x104f, "Entered %s.\n", __func__);
 
         pd24 = NULL;
         pd = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &pd_dma);
         if (pd  == NULL) {
-                DEBUG2_3(printk("%s(%ld): failed to allocate Port Database "
-                    "structure.\n", __func__, vha->host_no));
+                ql_log(ql_log_warn, vha, 0x1050,
+                    "Failed to allocate port database structure.\n");
                 return QLA_MEMORY_ALLOC_FAILED;
         }
         memset(pd, 0, max(PORT_DATABASE_SIZE, PORT_DATABASE_24XX_SIZE));
@@ -1261,12 +1244,10 @@ 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(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));
+                        ql_dbg(ql_dbg_mbx, vha, 0x1051,
+                            "Unable to verify login-state (%x/%x) for "
+                            "loop_id %x.\n", pd24->current_login_state,
+                            pd24->last_login_state, fcport->loop_id);
                         rval = QLA_FUNCTION_FAILED;
                         goto gpd_error_out;
                 }
@@ -1290,12 +1271,11 @@ 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));
+                        ql_dbg(ql_dbg_mbx, vha, 0x100a,
+                            "Unable to verify login-state (%x/%x) - "
+                            "portid=%02x%02x%02x.\n", 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;
                 }
@@ -1325,10 +1305,11 @@ gpd_error_out:
         dma_pool_free(ha->s_dma_pool, pd, pd_dma);
 
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x.\n",
-                    __func__, vha->host_no, rval, mcp->mb[0], mcp->mb[1]));
+                ql_dbg(ql_dbg_mbx, vha, 0x1052,
+                    "Failed=%x mb[0]=%x mb[1]=%x.\n", rval,
+                    mcp->mb[0], mcp->mb[1]);
         } else {
-                DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x1053, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -1357,8 +1338,7 @@ qla2x00_get_firmware_state(scsi_qla_host_t *vha, uint16_t *states)
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
 
-        DEBUG11(printk("qla2x00_get_firmware_state(%ld): entered.\n",
-            vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x1054, "Entered %s.\n", __func__);
 
         mcp->mb[0] = MBC_GET_FIRMWARE_STATE;
         mcp->out_mb = MBX_0;
@@ -1381,12 +1361,10 @@ qla2x00_get_firmware_state(scsi_qla_host_t *vha, uint16_t *states)
 
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
-                DEBUG2_3_11(printk("qla2x00_get_firmware_state(%ld): "
-                    "failed=%x.\n", vha->host_no, rval));
+                ql_dbg(ql_dbg_mbx, vha, 0x1055, "Failed=%x.\n", rval);
         } else {
                 /*EMPTY*/
-                DEBUG11(printk("qla2x00_get_firmware_state(%ld): done.\n",
-                    vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x1056, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -1418,8 +1396,7 @@ qla2x00_get_port_name(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t *name,
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
 
-        DEBUG11(printk("qla2x00_get_port_name(%ld): entered.\n",
-            vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x1057, "Entered %s.\n", __func__);
 
         mcp->mb[0] = MBC_GET_PORT_NAME;
         mcp->mb[9] = vha->vp_idx;
@@ -1439,8 +1416,7 @@ qla2x00_get_port_name(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t *name,
 
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
-                DEBUG2_3_11(printk("qla2x00_get_port_name(%ld): failed=%x.\n",
-                    vha->host_no, rval));
+                ql_dbg(ql_dbg_mbx, vha, 0x1058, "Failed=%x.\n", rval);
         } else {
                 if (name != NULL) {
                         /* This function returns name in big endian. */
@@ -1454,8 +1430,7 @@ qla2x00_get_port_name(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t *name,
                         name[7] = LSB(mcp->mb[7]);
                 }
 
-                DEBUG11(printk("qla2x00_get_port_name(%ld): done.\n",
-                    vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x1059, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -1483,7 +1458,7 @@ qla2x00_lip_reset(scsi_qla_host_t *vha)
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
 
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x105a, "Entered %s.\n", __func__);
 
         if (IS_QLA8XXX_TYPE(vha->hw)) {
                 /* Logout across all FCFs. */
@@ -1517,11 +1492,10 @@ qla2x00_lip_reset(scsi_qla_host_t *vha)
 
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
-                DEBUG2_3_11(printk("%s(%ld): failed=%x.\n",
-                    __func__, vha->host_no, rval));
+                ql_dbg(ql_dbg_mbx, vha, 0x105b, "Failed=%x.\n", rval);
         } else {
                 /*EMPTY*/
-                DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x105c, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -1553,12 +1527,11 @@ qla2x00_send_sns(scsi_qla_host_t *vha, dma_addr_t sns_phys_address,
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
 
-        DEBUG11(printk("qla2x00_send_sns(%ld): entered.\n",
-            vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x105d, "Entered %s.\n", __func__);
 
-        DEBUG11(printk("qla2x00_send_sns: retry cnt=%d ratov=%d total "
-                "tov=%d.\n", vha->hw->retry_count, vha->hw->login_timeout,
-                mcp->tov));
+        ql_dbg(ql_dbg_mbx, vha, 0x105e,
+            "Retry cnt=%d ratov=%d total tov=%d.\n",
+            vha->hw->retry_count, vha->hw->login_timeout, mcp->tov);
 
         mcp->mb[0] = MBC_SEND_SNS_COMMAND;
         mcp->mb[1] = cmd_size;
@@ -1575,13 +1548,12 @@ qla2x00_send_sns(scsi_qla_host_t *vha, dma_addr_t sns_phys_address,
 
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
-                DEBUG(printk("qla2x00_send_sns(%ld): failed=%x mb[0]=%x "
-                    "mb[1]=%x.\n", vha->host_no, rval, mcp->mb[0], mcp->mb[1]));
-                DEBUG2_3_11(printk("qla2x00_send_sns(%ld): failed=%x mb[0]=%x "
-                    "mb[1]=%x.\n", vha->host_no, rval, mcp->mb[0], mcp->mb[1]));
+                ql_dbg(ql_dbg_mbx, vha, 0x105f,
+                    "Failed=%x mb[0]=%x mb[1]=%x.\n",
+                    rval, mcp->mb[0], mcp->mb[1]);
         } else {
                 /*EMPTY*/
-                DEBUG11(printk("qla2x00_send_sns(%ld): done.\n", vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x1060, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -1600,7 +1572,7 @@ qla24xx_login_fabric(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
         struct req_que *req;
         struct rsp_que *rsp;
 
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x1061, "Entered %s.\n", __func__);
 
         if (ha->flags.cpu_affinity_enabled)
                 req = ha->req_q_map[0];
@@ -1610,8 +1582,8 @@ qla24xx_login_fabric(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
 
         lg = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &lg_dma);
         if (lg == NULL) {
-                DEBUG2_3(printk("%s(%ld): failed to allocate Login IOCB.\n",
-                    __func__, vha->host_no));
+                ql_log(ql_log_warn, vha, 0x1062,
+                    "Failed to allocate login IOCB.\n");
                 return QLA_MEMORY_ALLOC_FAILED;
         }
         memset(lg, 0, sizeof(struct logio_entry_24xx));
@@ -1631,21 +1603,21 @@ qla24xx_login_fabric(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
         lg->vp_index = vha->vp_idx;
         rval = qla2x00_issue_iocb(vha, lg, lg_dma, 0);
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk("%s(%ld): failed to issue Login IOCB "
-                    "(%x).\n", __func__, vha->host_no, rval));
+                ql_dbg(ql_dbg_mbx, vha, 0x1063,
+                    "Failed to issue login IOCB (%x).\n", rval);
         } else if (lg->entry_status != 0) {
-                DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
-                    "-- error status (%x).\n", __func__, vha->host_no,
-                    lg->entry_status));
+                ql_dbg(ql_dbg_mbx, vha, 0x1064,
+                    "Failed to complete IOCB -- error status (%x).\n",
+                    lg->entry_status);
                 rval = QLA_FUNCTION_FAILED;
         } else if (lg->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) {
                 iop[0] = le32_to_cpu(lg->io_parameter[0]);
                 iop[1] = le32_to_cpu(lg->io_parameter[1]);
 
-                DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
-                    "-- completion status (%x)  ioparam=%x/%x.\n", __func__,
-                    vha->host_no, le16_to_cpu(lg->comp_status), iop[0],
-                    iop[1]));
+                ql_dbg(ql_dbg_mbx, vha, 0x1065,
+                    "Failed to complete IOCB -- completion  status (%x) "
+                    "ioparam=%x/%x.\n", le16_to_cpu(lg->comp_status),
+                    iop[0], iop[1]);
 
                 switch (iop[0]) {
                 case LSC_SCODE_PORTID_USED:
@@ -1673,7 +1645,7 @@ qla24xx_login_fabric(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
                         break;
                 }
         } else {
-                DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x1066, "Done %s.\n", __func__);
 
                 iop[0] = le32_to_cpu(lg->io_parameter[0]);
 
@@ -1728,7 +1700,7 @@ qla2x00_login_fabric(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
         mbx_cmd_t *mcp = &mc;
         struct qla_hw_data *ha = vha->hw;
 
-        DEBUG11(printk("qla2x00_login_fabric(%ld): entered.\n", vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x1067, "Entered %s.\n", __func__);
 
         mcp->mb[0] = MBC_LOGIN_FABRIC_PORT;
         mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
@@ -1771,13 +1743,12 @@ qla2x00_login_fabric(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
                         rval = QLA_SUCCESS;
 
                 /*EMPTY*/
-                DEBUG2_3_11(printk("qla2x00_login_fabric(%ld): failed=%x "
-                    "mb[0]=%x mb[1]=%x mb[2]=%x.\n", vha->host_no, rval,
-                    mcp->mb[0], mcp->mb[1], mcp->mb[2]));
+                ql_dbg(ql_dbg_mbx, vha, 0x1068,
+                    "Failed=%x mb[0]=%x mb[1]=%x mb[2]=%x.\n",
+                    rval, mcp->mb[0], mcp->mb[1], mcp->mb[2]);
         } else {
                 /*EMPTY*/
-                DEBUG11(printk("qla2x00_login_fabric(%ld): done.\n",
-                    vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x1069, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -1808,13 +1779,13 @@ qla2x00_login_local_device(scsi_qla_host_t *vha, fc_port_t *fcport,
         mbx_cmd_t *mcp = &mc;
         struct qla_hw_data *ha = vha->hw;
 
+        ql_dbg(ql_dbg_mbx, vha, 0x106a, "Entered %s.\n", __func__);
+
         if (IS_FWI2_CAPABLE(ha))
                 return qla24xx_login_fabric(vha, fcport->loop_id,
                     fcport->d_id.b.domain, fcport->d_id.b.area,
                     fcport->d_id.b.al_pa, mb_ret, opt);
 
-        DEBUG3(printk("%s(%ld): entered.\n", __func__, vha->host_no));
-
         mcp->mb[0] = MBC_LOGIN_LOOP_PORT;
         if (HAS_EXTENDED_IDS(ha))
                 mcp->mb[1] = fcport->loop_id;
@@ -1845,15 +1816,12 @@ qla2x00_login_local_device(scsi_qla_host_t *vha, fc_port_t *fcport,
                 if (mcp->mb[0] == 0x4005 || mcp->mb[0] == 0x4006)
                         rval = QLA_SUCCESS;
 
-                DEBUG(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x "
-                    "mb[6]=%x mb[7]=%x.\n", __func__, vha->host_no, rval,
-                    mcp->mb[0], mcp->mb[1], mcp->mb[6], mcp->mb[7]));
-                DEBUG2_3(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x "
-                    "mb[6]=%x mb[7]=%x.\n", __func__, vha->host_no, rval,
-                    mcp->mb[0], mcp->mb[1], mcp->mb[6], mcp->mb[7]));
+                ql_dbg(ql_dbg_mbx, vha, 0x106b,
+                    "Failed=%x mb[0]=%x mb[1]=%x mb[6]=%x mb[7]=%x.\n",
+                    rval, mcp->mb[0], mcp->mb[1], mcp->mb[6], mcp->mb[7]);
         } else {
                 /*EMPTY*/
-                DEBUG3(printk("%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x106c, "Done %s.\n", __func__);
         }
 
         return (rval);
@@ -1870,12 +1838,12 @@ qla24xx_fabric_logout(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
         struct req_que *req;
         struct rsp_que *rsp;
 
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x106d, "Entered %s.\n", __func__);
 
         lg = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &lg_dma);
         if (lg == NULL) {
-                DEBUG2_3(printk("%s(%ld): failed to allocate Logout IOCB.\n",
-                    __func__, vha->host_no));
+                ql_log(ql_log_warn, vha, 0x106e,
+                    "Failed to allocate logout IOCB.\n");
                 return QLA_MEMORY_ALLOC_FAILED;
         }
         memset(lg, 0, sizeof(struct logio_entry_24xx));
@@ -1899,22 +1867,22 @@ qla24xx_fabric_logout(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
 
         rval = qla2x00_issue_iocb(vha, lg, lg_dma, 0);
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk("%s(%ld): failed to issue Logout IOCB "
-                    "(%x).\n", __func__, vha->host_no, rval));
+                ql_dbg(ql_dbg_mbx, vha, 0x106f,
+                    "Failed to issue logout IOCB (%x).\n", rval);
         } else if (lg->entry_status != 0) {
-                DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
-                    "-- error status (%x).\n", __func__, vha->host_no,
-                    lg->entry_status));
+                ql_dbg(ql_dbg_mbx, vha, 0x1070,
+                    "Failed to complete IOCB -- error status (%x).\n",
+                    lg->entry_status);
                 rval = QLA_FUNCTION_FAILED;
         } else if (lg->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) {
-                DEBUG2_3_11(printk("%s(%ld %d): failed to complete IOCB "
-                    "-- completion status (%x)  ioparam=%x/%x.\n", __func__,
-                    vha->host_no, vha->vp_idx, le16_to_cpu(lg->comp_status),
+                ql_dbg(ql_dbg_mbx, vha, 0x1071,
+                    "Failed to complete IOCB -- completion status (%x) "
+                    "ioparam=%x/%x.\n", le16_to_cpu(lg->comp_status),
                     le32_to_cpu(lg->io_parameter[0]),
-                    le32_to_cpu(lg->io_parameter[1])));
+                    le32_to_cpu(lg->io_parameter[1]));
         } else {
                 /*EMPTY*/
-                DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x1072, "Done %s.\n", __func__);
         }
 
         dma_pool_free(ha->s_dma_pool, lg, lg_dma);
@@ -1946,8 +1914,7 @@ qla2x00_fabric_logout(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
 
-        DEBUG11(printk("qla2x00_fabric_logout(%ld): entered.\n",
-            vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x1073, "Entered %s.\n", __func__);
 
         mcp->mb[0] = MBC_LOGOUT_FABRIC_PORT;
         mcp->out_mb = MBX_1|MBX_0;
@@ -1966,12 +1933,11 @@ qla2x00_fabric_logout(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
 
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
-                DEBUG2_3_11(printk("qla2x00_fabric_logout(%ld): failed=%x "
-                    "mbx1=%x.\n", vha->host_no, rval, mcp->mb[1]));
+                ql_dbg(ql_dbg_mbx, vha, 0x1074,
+                    "Failed=%x mb[1]=%x.\n", rval, mcp->mb[1]);
         } else {
                 /*EMPTY*/
-                DEBUG11(printk("qla2x00_fabric_logout(%ld): done.\n",
-                    vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x1075, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -1999,8 +1965,7 @@ qla2x00_full_login_lip(scsi_qla_host_t *vha)
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
 
-        DEBUG11(printk("qla2x00_full_login_lip(%ld): entered.\n",
-            vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x1076, "Entered %s.\n", __func__);
 
         mcp->mb[0] = MBC_LIP_FULL_LOGIN;
         mcp->mb[1] = IS_FWI2_CAPABLE(vha->hw) ? BIT_3 : 0;
@@ -2014,12 +1979,10 @@ qla2x00_full_login_lip(scsi_qla_host_t *vha)
 
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
-                DEBUG2_3_11(printk("qla2x00_full_login_lip(%ld): failed=%x.\n",
-                    vha->host_no, rval));
+                ql_dbg(ql_dbg_mbx, vha, 0x1077, "Failed=%x.\n", rval);
         } else {
                 /*EMPTY*/
-                DEBUG11(printk("qla2x00_full_login_lip(%ld): done.\n",
-                    vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x1078, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -2045,8 +2008,7 @@ qla2x00_get_id_list(scsi_qla_host_t *vha, void *id_list, dma_addr_t id_list_dma,
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
 
-        DEBUG11(printk("qla2x00_get_id_list(%ld): entered.\n",
-            vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x1079, "Entered %s.\n", __func__);
 
         if (id_list == NULL)
                 return QLA_FUNCTION_FAILED;
@@ -2075,12 +2037,10 @@ qla2x00_get_id_list(scsi_qla_host_t *vha, void *id_list, dma_addr_t id_list_dma,
 
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
-                DEBUG2_3_11(printk("qla2x00_get_id_list(%ld): failed=%x.\n",
-                    vha->host_no, rval));
+                ql_dbg(ql_dbg_mbx, vha, 0x107a, "Failed=%x.\n", rval);
         } else {
                 *entries = mcp->mb[1];
-                DEBUG11(printk("qla2x00_get_id_list(%ld): done.\n",
-                    vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x107b, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -2108,7 +2068,7 @@ qla2x00_get_resource_cnts(scsi_qla_host_t *vha, uint16_t *cur_xchg_cnt,
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
 
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x107c, "Entered %s.\n", __func__);
 
         mcp->mb[0] = MBC_GET_RESOURCE_COUNTS;
         mcp->out_mb = MBX_0;
@@ -2121,14 +2081,14 @@ qla2x00_get_resource_cnts(scsi_qla_host_t *vha, uint16_t *cur_xchg_cnt,
 
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
-                DEBUG2_3_11(printk("%s(%ld): failed = %x.\n", __func__,
-                    vha->host_no, mcp->mb[0]));
+                ql_dbg(ql_dbg_mbx, vha, 0x107d,
+                    "Failed mb[0]=%x.\n", mcp->mb[0]);
         } else {
-                DEBUG11(printk("%s(%ld): done. mb1=%x mb2=%x mb3=%x mb6=%x "
-                    "mb7=%x mb10=%x mb11=%x mb12=%x.\n", __func__,
-                    vha->host_no, mcp->mb[1], mcp->mb[2], mcp->mb[3],
-                    mcp->mb[6], mcp->mb[7], mcp->mb[10], mcp->mb[11],
-                    mcp->mb[12]));
+                ql_dbg(ql_dbg_mbx, vha, 0x107e,
+                    "Done %s mb1=%x mb2=%x mb3=%x mb6=%x mb7=%x mb10=%x "
+                    "mb11=%x mb12=%x.\n", __func__, mcp->mb[1], mcp->mb[2],
+                    mcp->mb[3], mcp->mb[6], mcp->mb[7], mcp->mb[10],
+                    mcp->mb[11], mcp->mb[12]);
 
                 if (cur_xchg_cnt)
                         *cur_xchg_cnt = mcp->mb[3];
@@ -2147,7 +2107,6 @@ qla2x00_get_resource_cnts(scsi_qla_host_t *vha, uint16_t *cur_xchg_cnt,
         return (rval);
 }
 
-#if defined(QL_DEBUG_LEVEL_3)
 /*
  * qla2x00_get_fcal_position_map
  *      Get FCAL (LILP) position map using mailbox command
@@ -2172,10 +2131,12 @@ qla2x00_get_fcal_position_map(scsi_qla_host_t *vha, char *pos_map)
         dma_addr_t pmap_dma;
         struct qla_hw_data *ha = vha->hw;
 
+        ql_dbg(ql_dbg_mbx, vha, 0x107f, "Entered %s.\n", __func__);
+
         pmap = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &pmap_dma);
         if (pmap  == NULL) {
-                DEBUG2_3_11(printk("%s(%ld): **** Mem Alloc Failed ****",
-                    __func__, vha->host_no));
+                ql_log(ql_log_warn, vha, 0x1080,
+                    "Memory alloc failed.\n");
                 return QLA_MEMORY_ALLOC_FAILED;
         }
         memset(pmap, 0, FCAL_MAP_SIZE);
@@ -2193,10 +2154,11 @@ qla2x00_get_fcal_position_map(scsi_qla_host_t *vha, char *pos_map)
         rval = qla2x00_mailbox_command(vha, mcp);
 
         if (rval == QLA_SUCCESS) {
-                DEBUG11(printk("%s(%ld): (mb0=%x/mb1=%x) FC/AL Position Map "
-                    "size (%x)\n", __func__, vha->host_no, mcp->mb[0],
-                    mcp->mb[1], (unsigned)pmap[0]));
-                DEBUG11(qla2x00_dump_buffer(pmap, pmap[0] + 1));
+                ql_dbg(ql_dbg_mbx, vha, 0x1081,
+                    "mb0/mb1=%x/%X FC/AL position map size (%x).\n",
+                    mcp->mb[0], mcp->mb[1], (unsigned)pmap[0]);
+                ql_dump_buffer(ql_dbg_mbx + ql_dbg_buffer, vha, 0x111d,
+                    pmap, pmap[0] + 1);
 
                 if (pos_map)
                         memcpy(pos_map, pmap, FCAL_MAP_SIZE);
@@ -2204,15 +2166,13 @@ qla2x00_get_fcal_position_map(scsi_qla_host_t *vha, char *pos_map)
         dma_pool_free(ha->s_dma_pool, pmap, pmap_dma);
 
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
-                    vha->host_no, rval));
+                ql_dbg(ql_dbg_mbx, vha, 0x1082, "Failed=%x.\n", rval);
         } else {
-                DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x1083, "Done %s.\n", __func__);
         }
 
         return rval;
 }
-#endif
 
 /*
  * qla2x00_get_link_status
@@ -2237,7 +2197,7 @@ qla2x00_get_link_status(scsi_qla_host_t *vha, uint16_t loop_id,
         uint32_t *siter, *diter, dwords;
         struct qla_hw_data *ha = vha->hw;
 
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x1084, "Entered %s.\n", __func__);
 
         mcp->mb[0] = MBC_GET_LINK_STATUS;
         mcp->mb[2] = MSW(stats_dma);
@@ -2266,11 +2226,12 @@ qla2x00_get_link_status(scsi_qla_host_t *vha, uint16_t loop_id,
 
         if (rval == QLA_SUCCESS) {
                 if (mcp->mb[0] != MBS_COMMAND_COMPLETE) {
-                        DEBUG2_3_11(printk("%s(%ld): cmd failed. mbx0=%x.\n",
-                            __func__, vha->host_no, mcp->mb[0]));
+                        ql_dbg(ql_dbg_mbx, vha, 0x1085,
+                            "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
                         rval = QLA_FUNCTION_FAILED;
                 } else {
                         /* Copy over data -- firmware data is LE. */
+                        ql_dbg(ql_dbg_mbx, vha, 0x1086, "Done %s.\n", __func__);
                         dwords = offsetof(struct link_statistics, unused1) / 4;
                         siter = diter = &stats->link_fail_cnt;
                         while (dwords--)
@@ -2278,8 +2239,7 @@ qla2x00_get_link_status(scsi_qla_host_t *vha, uint16_t loop_id,
                 }
         } else {
                 /* Failed. */
-                DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
-                    vha->host_no, rval));
+                ql_dbg(ql_dbg_mbx, vha, 0x1087, "Failed=%x.\n", rval);
         }
 
         return rval;
@@ -2294,7 +2254,7 @@ qla24xx_get_isp_stats(scsi_qla_host_t *vha, struct link_statistics *stats,
         mbx_cmd_t *mcp = &mc;
         uint32_t *siter, *diter, dwords;
 
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x1088, "Entered %s.\n", __func__);
 
         mcp->mb[0] = MBC_GET_LINK_PRIV_STATS;
         mcp->mb[2] = MSW(stats_dma);
@@ -2312,10 +2272,11 @@ qla24xx_get_isp_stats(scsi_qla_host_t *vha, struct link_statistics *stats,
 
         if (rval == QLA_SUCCESS) {
                 if (mcp->mb[0] != MBS_COMMAND_COMPLETE) {
-                        DEBUG2_3_11(printk("%s(%ld): cmd failed. mbx0=%x.\n",
-                            __func__, vha->host_no, mcp->mb[0]));
+                        ql_dbg(ql_dbg_mbx, vha, 0x1089,
+                            "Failed mb[0]=%x.\n", mcp->mb[0]);
                         rval = QLA_FUNCTION_FAILED;
                 } else {
+                        ql_dbg(ql_dbg_mbx, vha, 0x108a, "Done %s.\n", __func__);
                         /* Copy over data -- firmware data is LE. */
                         dwords = sizeof(struct link_statistics) / 4;
                         siter = diter = &stats->link_fail_cnt;
@@ -2324,8 +2285,7 @@ qla24xx_get_isp_stats(scsi_qla_host_t *vha, struct link_statistics *stats,
                 }
         } else {
                 /* Failed. */
-                DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
-                    vha->host_no, rval));
+                ql_dbg(ql_dbg_mbx, vha, 0x108b, "Failed=%x.\n", rval);
         }
 
         return rval;
@@ -2345,7 +2305,7 @@ qla24xx_abort_command(srb_t *sp)
         struct qla_hw_data *ha = vha->hw;
         struct req_que *req = vha->req;
 
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x108c, "Entered %s.\n", __func__);
 
         spin_lock_irqsave(&ha->hardware_lock, flags);
         for (handle = 1; handle < MAX_OUTSTANDING_COMMANDS; handle++) {
@@ -2360,8 +2320,8 @@ qla24xx_abort_command(srb_t *sp)
 
         abt = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &abt_dma);
         if (abt == NULL) {
-                DEBUG2_3(printk("%s(%ld): failed to allocate Abort IOCB.\n",
-                    __func__, vha->host_no));
+                ql_log(ql_log_warn, vha, 0x108d,
+                    "Failed to allocate abort IOCB.\n");
                 return QLA_MEMORY_ALLOC_FAILED;
         }
         memset(abt, 0, sizeof(struct abort_entry_24xx));
@@ -2380,20 +2340,20 @@ qla24xx_abort_command(srb_t *sp)
 
         rval = qla2x00_issue_iocb(vha, abt, abt_dma, 0);
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk("%s(%ld): failed to issue IOCB (%x).\n",
-                    __func__, vha->host_no, rval));
+                ql_dbg(ql_dbg_mbx, vha, 0x108e,
+                    "Failed to issue IOCB (%x).\n", rval);
         } else if (abt->entry_status != 0) {
-                DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
-                    "-- error status (%x).\n", __func__, vha->host_no,
-                    abt->entry_status));
+                ql_dbg(ql_dbg_mbx, vha, 0x108f,
+                    "Failed to complete IOCB -- error status (%x).\n",
+                    abt->entry_status);
                 rval = QLA_FUNCTION_FAILED;
         } else if (abt->nport_handle != __constant_cpu_to_le16(0)) {
-                DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
-                    "-- completion status (%x).\n", __func__, vha->host_no,
-                    le16_to_cpu(abt->nport_handle)));
+                ql_dbg(ql_dbg_mbx, vha, 0x1090,
+                    "Failed to complete IOCB -- completion status (%x).\n",
+                    le16_to_cpu(abt->nport_handle));
                 rval = QLA_FUNCTION_FAILED;
         } else {
-                DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x1091, "Done %s.\n", __func__);
         }
 
         dma_pool_free(ha->s_dma_pool, abt, abt_dma);
@@ -2421,19 +2381,20 @@ __qla24xx_issue_tmf(char *name, uint32_t type, struct fc_port *fcport,
         struct req_que *req;
         struct rsp_que *rsp;
 
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, fcport->vha->host_no));
-
         vha = fcport->vha;
         ha = vha->hw;
         req = vha->req;
+
+        ql_dbg(ql_dbg_mbx, vha, 0x1092, "Entered %s.\n", __func__);
+
         if (ha->flags.cpu_affinity_enabled)
                 rsp = ha->rsp_q_map[tag + 1];
         else
                 rsp = req->rsp;
         tsk = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &tsk_dma);
         if (tsk == NULL) {
-                DEBUG2_3(printk("%s(%ld): failed to allocate Task Management "
-                    "IOCB.\n", __func__, vha->host_no));
+                ql_log(ql_log_warn, vha, 0x1093,
+                    "Failed to allocate task management IOCB.\n");
                 return QLA_MEMORY_ALLOC_FAILED;
         }
         memset(tsk, 0, sizeof(struct tsk_mgmt_cmd));
@@ -2457,30 +2418,30 @@ __qla24xx_issue_tmf(char *name, uint32_t type, struct fc_port *fcport,
         sts = &tsk->p.sts;
         rval = qla2x00_issue_iocb(vha, tsk, tsk_dma, 0);
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk("%s(%ld): failed to issue %s Reset IOCB "
-                    "(%x).\n", __func__, vha->host_no, name, rval));
+                ql_dbg(ql_dbg_mbx, vha, 0x1094,
+                    "Failed to issue %s reset IOCB (%x).\n", name, rval);
         } else if (sts->entry_status != 0) {
-                DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
-                    "-- error status (%x).\n", __func__, vha->host_no,
-                    sts->entry_status));
+                ql_dbg(ql_dbg_mbx, vha, 0x1095,
+                    "Failed to complete IOCB -- error status (%x).\n",
+                    sts->entry_status);
                 rval = QLA_FUNCTION_FAILED;
         } else if (sts->comp_status !=
             __constant_cpu_to_le16(CS_COMPLETE)) {
-                DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
-                    "-- completion status (%x).\n", __func__,
-                    vha->host_no, le16_to_cpu(sts->comp_status)));
+                ql_dbg(ql_dbg_mbx, vha, 0x1096,
+                    "Failed to complete IOCB -- completion status (%x).\n",
+                    le16_to_cpu(sts->comp_status));
                 rval = QLA_FUNCTION_FAILED;
         } else if (le16_to_cpu(sts->scsi_status) &
             SS_RESPONSE_INFO_LEN_VALID) {
                 if (le32_to_cpu(sts->rsp_data_len) < 4) {
-                        DEBUG2_3_11(printk("%s(%ld): ignoring inconsistent "
-                            "data length -- not enough response info (%d).\n",
-                            __func__, vha->host_no,
-                            le32_to_cpu(sts->rsp_data_len)));
+                        ql_dbg(ql_dbg_mbx, vha, 0x1097,
+                            "Ignoring inconsistent data length -- not enough "
+                            "response info (%d).\n",
+                            le32_to_cpu(sts->rsp_data_len));
                 } else if (sts->data[3]) {
-                        DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
-                            "-- response (%x).\n", __func__,
-                            vha->host_no, sts->data[3]));
+                        ql_dbg(ql_dbg_mbx, vha, 0x1098,
+                            "Failed to complete IOCB -- response (%x).\n",
+                            sts->data[3]);
                         rval = QLA_FUNCTION_FAILED;
                 }
         }
@@ -2489,10 +2450,10 @@ __qla24xx_issue_tmf(char *name, uint32_t type, struct fc_port *fcport,
         rval2 = qla2x00_marker(vha, req, rsp, fcport->loop_id, l,
             type == TCF_LUN_RESET ? MK_SYNC_ID_LUN: MK_SYNC_ID);
         if (rval2 != QLA_SUCCESS) {
-                DEBUG2_3_11(printk("%s(%ld): failed to issue Marker IOCB "
-                    "(%x).\n", __func__, vha->host_no, rval2));
+                ql_dbg(ql_dbg_mbx, vha, 0x1099,
+                    "Failed to issue marker IOCB (%x).\n", rval2);
         } else {
-                DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x109a, "Done %s.\n", __func__);
         }
 
         dma_pool_free(ha->s_dma_pool, tsk, tsk_dma);
@@ -2533,7 +2494,7 @@ qla2x00_system_error(scsi_qla_host_t *vha)
         if (!IS_QLA23XX(ha) && !IS_FWI2_CAPABLE(ha))
                 return QLA_FUNCTION_FAILED;
 
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x109b, "Entered %s.\n", __func__);
 
         mcp->mb[0] = MBC_GEN_SYSTEM_ERROR;
         mcp->out_mb = MBX_0;
@@ -2543,10 +2504,9 @@ qla2x00_system_error(scsi_qla_host_t *vha)
         rval = qla2x00_mailbox_command(vha, mcp);
 
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
-                    vha->host_no, rval));
+                ql_dbg(ql_dbg_mbx, vha, 0x109c, "Failed=%x.\n", rval);
         } else {
-                DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x109d, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -2566,7 +2526,7 @@ qla2x00_set_serdes_params(scsi_qla_host_t *vha, uint16_t sw_em_1g,
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
 
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x109e, "Entered %s.\n", __func__);
 
         mcp->mb[0] = MBC_SERDES_PARAMS;
         mcp->mb[1] = BIT_0;
@@ -2581,11 +2541,11 @@ qla2x00_set_serdes_params(scsi_qla_host_t *vha, uint16_t sw_em_1g,
 
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
-                DEBUG2_3_11(printk("%s(%ld): failed=%x (%x).\n", __func__,
-                    vha->host_no, rval, mcp->mb[0]));
+                ql_dbg(ql_dbg_mbx, vha, 0x109f,
+                    "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
         } else {
                 /*EMPTY*/
-                DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x10a0, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -2601,7 +2561,7 @@ qla2x00_stop_firmware(scsi_qla_host_t *vha)
         if (!IS_FWI2_CAPABLE(vha->hw))
                 return QLA_FUNCTION_FAILED;
 
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x10a1, "Entered %s.\n", __func__);
 
         mcp->mb[0] = MBC_STOP_FIRMWARE;
         mcp->out_mb = MBX_0;
@@ -2611,12 +2571,11 @@ qla2x00_stop_firmware(scsi_qla_host_t *vha)
         rval = qla2x00_mailbox_command(vha, mcp);
 
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
-                    vha->host_no, rval));
+                ql_dbg(ql_dbg_mbx, vha, 0x10a2, "Failed=%x.\n", rval);
                 if (mcp->mb[0] == MBS_INVALID_COMMAND)
                         rval = QLA_INVALID_COMMAND;
         } else {
-                DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x10a3, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -2630,14 +2589,14 @@ qla2x00_enable_eft_trace(scsi_qla_host_t *vha, dma_addr_t eft_dma,
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
 
+        ql_dbg(ql_dbg_mbx, vha, 0x10a4, "Entered %s.\n", __func__);
+
         if (!IS_FWI2_CAPABLE(vha->hw))
                 return QLA_FUNCTION_FAILED;
 
         if (unlikely(pci_channel_offline(vha->hw->pdev)))
                 return QLA_FUNCTION_FAILED;
 
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
-
         mcp->mb[0] = MBC_TRACE_CONTROL;
         mcp->mb[1] = TC_EFT_ENABLE;
         mcp->mb[2] = LSW(eft_dma);
@@ -2652,10 +2611,11 @@ qla2x00_enable_eft_trace(scsi_qla_host_t *vha, dma_addr_t eft_dma,
         mcp->flags = 0;
         rval = qla2x00_mailbox_command(vha, mcp);
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x.\n",
-                    __func__, vha->host_no, rval, mcp->mb[0], mcp->mb[1]));
+                ql_dbg(ql_dbg_mbx, vha, 0x10a5,
+                    "Failed=%x mb[0]=%x mb[1]=%x.\n",
+                    rval, mcp->mb[0], mcp->mb[1]);
         } else {
-                DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x10a6, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -2668,14 +2628,14 @@ qla2x00_disable_eft_trace(scsi_qla_host_t *vha)
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
 
+        ql_dbg(ql_dbg_mbx, vha, 0x10a7, "Entered %s.\n", __func__);
+
         if (!IS_FWI2_CAPABLE(vha->hw))
                 return QLA_FUNCTION_FAILED;
 
         if (unlikely(pci_channel_offline(vha->hw->pdev)))
                 return QLA_FUNCTION_FAILED;
 
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
-
         mcp->mb[0] = MBC_TRACE_CONTROL;
         mcp->mb[1] = TC_EFT_DISABLE;
         mcp->out_mb = MBX_1|MBX_0;
@@ -2684,10 +2644,11 @@ qla2x00_disable_eft_trace(scsi_qla_host_t *vha)
         mcp->flags = 0;
         rval = qla2x00_mailbox_command(vha, mcp);
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x.\n",
-                    __func__, vha->host_no, rval, mcp->mb[0], mcp->mb[1]));
+                ql_dbg(ql_dbg_mbx, vha, 0x10a8,
+                    "Failed=%x mb[0]=%x mb[1]=%x.\n",
+                    rval, mcp->mb[0], mcp->mb[1]);
         } else {
-                DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x10a9, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -2701,14 +2662,14 @@ qla2x00_enable_fce_trace(scsi_qla_host_t *vha, dma_addr_t fce_dma,
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
 
+        ql_dbg(ql_dbg_mbx, vha, 0x10aa, "Entered %s.\n", __func__);
+
         if (!IS_QLA25XX(vha->hw) && !IS_QLA81XX(vha->hw))
                 return QLA_FUNCTION_FAILED;
 
         if (unlikely(pci_channel_offline(vha->hw->pdev)))
                 return QLA_FUNCTION_FAILED;
 
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
-
         mcp->mb[0] = MBC_TRACE_CONTROL;
         mcp->mb[1] = TC_FCE_ENABLE;
         mcp->mb[2] = LSW(fce_dma);
@@ -2727,10 +2688,11 @@ qla2x00_enable_fce_trace(scsi_qla_host_t *vha, dma_addr_t fce_dma,
         mcp->flags = 0;
         rval = qla2x00_mailbox_command(vha, mcp);
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x.\n",
-                    __func__, vha->host_no, rval, mcp->mb[0], mcp->mb[1]));
+                ql_dbg(ql_dbg_mbx, vha, 0x10ab,
+                    "Failed=%x mb[0]=%x mb[1]=%x.\n",
+                    rval, mcp->mb[0], mcp->mb[1]);
         } else {
-                DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x10ac, "Done %s.\n", __func__);
 
                 if (mb)
                         memcpy(mb, mcp->mb, 8 * sizeof(*mb));
@@ -2748,14 +2710,14 @@ qla2x00_disable_fce_trace(scsi_qla_host_t *vha, uint64_t *wr, uint64_t *rd)
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
 
+        ql_dbg(ql_dbg_mbx, vha, 0x10ad, "Entered %s.\n", __func__);
+
         if (!IS_FWI2_CAPABLE(vha->hw))
                 return QLA_FUNCTION_FAILED;
 
         if (unlikely(pci_channel_offline(vha->hw->pdev)))
                 return QLA_FUNCTION_FAILED;
 
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
-
         mcp->mb[0] = MBC_TRACE_CONTROL;
         mcp->mb[1] = TC_FCE_DISABLE;
         mcp->mb[2] = TC_FCE_DISABLE_TRACE;
@@ -2766,10 +2728,11 @@ qla2x00_disable_fce_trace(scsi_qla_host_t *vha, uint64_t *wr, uint64_t *rd)
         mcp->flags = 0;
         rval = qla2x00_mailbox_command(vha, mcp);
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x.\n",
-                    __func__, vha->host_no, rval, mcp->mb[0], mcp->mb[1]));
+                ql_dbg(ql_dbg_mbx, vha, 0x10ae,
+                    "Failed=%x mb[0]=%x mb[1]=%x.\n",
+                    rval, mcp->mb[0], mcp->mb[1]);
         } else {
-                DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x10af, "Done %s.\n", __func__);
 
                 if (wr)
                         *wr = (uint64_t) mcp->mb[5] << 48 |
@@ -2794,11 +2757,11 @@ qla2x00_get_idma_speed(scsi_qla_host_t *vha, uint16_t loop_id,
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
 
+        ql_dbg(ql_dbg_mbx, vha, 0x10b0, "Entered %s.\n", __func__);
+
         if (!IS_IIDMA_CAPABLE(vha->hw))
                 return QLA_FUNCTION_FAILED;
 
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
-
         mcp->mb[0] = MBC_PORT_PARAMS;
         mcp->mb[1] = loop_id;
         mcp->mb[2] = mcp->mb[3] = 0;
@@ -2817,10 +2780,9 @@ qla2x00_get_idma_speed(scsi_qla_host_t *vha, uint16_t loop_id,
         }
 
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
-                    vha->host_no, rval));
+                ql_dbg(ql_dbg_mbx, vha, 0x10b1, "Failed=%x.\n", rval);
         } else {
-                DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x10b2, "Done %s.\n", __func__);
                 if (port_speed)
                         *port_speed = mcp->mb[3];
         }
@@ -2836,11 +2798,11 @@ qla2x00_set_idma_speed(scsi_qla_host_t *vha, uint16_t loop_id,
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
 
+        ql_dbg(ql_dbg_mbx, vha, 0x10b3, "Entered %s.\n", __func__);
+
         if (!IS_IIDMA_CAPABLE(vha->hw))
                 return QLA_FUNCTION_FAILED;
 
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
-
         mcp->mb[0] = MBC_PORT_PARAMS;
         mcp->mb[1] = loop_id;
         mcp->mb[2] = BIT_0;
@@ -2863,10 +2825,9 @@ qla2x00_set_idma_speed(scsi_qla_host_t *vha, uint16_t loop_id,
         }
 
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk("%s(%ld): failed=%x.\n", __func__,
-                    vha->host_no, rval));
+                ql_dbg(ql_dbg_mbx, vha, 0x10b4, "Failed=%x.\n", rval);
         } else {
-                DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x10b5, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -2882,33 +2843,36 @@ qla24xx_report_id_acquisition(scsi_qla_host_t *vha,
         scsi_qla_host_t *vp;
         unsigned long   flags;
 
+        ql_dbg(ql_dbg_mbx, vha, 0x10b6, "Entered %s.\n", __func__);
+
         if (rptid_entry->entry_status != 0)
                 return;
 
         if (rptid_entry->format == 0) {
-                DEBUG15(printk("%s:format 0 : scsi(%ld) number of VPs setup %d,"
-                        " number of VPs acquired %d\n", __func__, vha->host_no,
-                        MSB(le16_to_cpu(rptid_entry->vp_count)),
-                        LSB(le16_to_cpu(rptid_entry->vp_count))));
-                DEBUG15(printk("%s primary port id %02x%02x%02x\n", __func__,
-                        rptid_entry->port_id[2], rptid_entry->port_id[1],
-                        rptid_entry->port_id[0]));
+                ql_dbg(ql_dbg_mbx, vha, 0x10b7,
+                    "Format 0 : Number of VPs setup %d, number of "
+                    "VPs acquired %d.\n",
+                    MSB(le16_to_cpu(rptid_entry->vp_count)),
+                    LSB(le16_to_cpu(rptid_entry->vp_count)));
+                ql_dbg(ql_dbg_mbx, vha, 0x10b8,
+                    "Primary port id %02x%02x%02x.\n",
+                    rptid_entry->port_id[2], rptid_entry->port_id[1],
+                    rptid_entry->port_id[0]);
         } else if (rptid_entry->format == 1) {
                 vp_idx = LSB(stat);
-                DEBUG15(printk("%s:format 1: scsi(%ld): VP[%d] enabled "
-                    "- status %d - "
-                    "with port id %02x%02x%02x\n", __func__, vha->host_no,
-                    vp_idx, MSB(stat),
+                ql_dbg(ql_dbg_mbx, vha, 0x10b9,
+                    "Format 1: VP[%d] enabled - status %d - with "
+                    "port id %02x%02x%02x.\n", vp_idx, MSB(stat),
                     rptid_entry->port_id[2], rptid_entry->port_id[1],
-                    rptid_entry->port_id[0]));
+                    rptid_entry->port_id[0]);
 
                 vp = vha;
                 if (vp_idx == 0 && (MSB(stat) != 1))
                         goto reg_needed;
 
                 if (MSB(stat) == 1) {
-                        DEBUG2(printk("scsi(%ld): Could not acquire ID for "
-                            "VP[%d].\n", vha->host_no, vp_idx));
+                        ql_dbg(ql_dbg_mbx, vha, 0x10ba,
+                            "Could not acquire ID for VP[%d].\n", vp_idx);
                         return;
                 }
 
@@ -2963,10 +2927,12 @@ qla24xx_modify_vp_config(scsi_qla_host_t *vha)
 
         /* This can be called by the parent */
 
+        ql_dbg(ql_dbg_mbx, vha, 0x10bb, "Entered %s.\n", __func__);
+
         vpmod = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &vpmod_dma);
         if (!vpmod) {
-                DEBUG2_3(printk("%s(%ld): failed to allocate Modify VP "
-                    "IOCB.\n", __func__, vha->host_no));
+                ql_log(ql_log_warn, vha, 0x10bc,
+                    "Failed to allocate modify VP IOCB.\n");
                 return QLA_MEMORY_ALLOC_FAILED;
         }
 
@@ -2983,22 +2949,21 @@ qla24xx_modify_vp_config(scsi_qla_host_t *vha)
 
         rval = qla2x00_issue_iocb(base_vha, vpmod, vpmod_dma, 0);
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk("%s(%ld): failed to issue VP config IOCB"
-                        "(%x).\n", __func__, base_vha->host_no, rval));
+                ql_dbg(ql_dbg_mbx, vha, 0x10bd,
+                    "Failed to issue VP config IOCB (%x).\n", rval);
         } else if (vpmod->comp_status != 0) {
-                DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
-                        "-- error status (%x).\n", __func__, base_vha->host_no,
-                        vpmod->comp_status));
+                ql_dbg(ql_dbg_mbx, vha, 0x10be,
+                    "Failed to complete IOCB -- error status (%x).\n",
+                    vpmod->comp_status);
                 rval = QLA_FUNCTION_FAILED;
         } else if (vpmod->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) {
-                DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
-                    "-- completion status (%x).\n", __func__, base_vha->host_no,
-                    le16_to_cpu(vpmod->comp_status)));
+                ql_dbg(ql_dbg_mbx, vha, 0x10bf,
+                    "Failed to complete IOCB -- completion status (%x).\n",
+                    le16_to_cpu(vpmod->comp_status));
                 rval = QLA_FUNCTION_FAILED;
         } else {
                 /* EMPTY */
-                DEBUG11(printk("%s(%ld): done.\n", __func__,
-                                                        base_vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x10c0, "Done %s.\n", __func__);
                 fc_vport_set_state(vha->fc_vport, FC_VPORT_INITIALIZING);
         }
         dma_pool_free(ha->s_dma_pool, vpmod, vpmod_dma);
@@ -3032,17 +2997,16 @@ qla24xx_control_vp(scsi_qla_host_t *vha, int cmd)
         int     vp_index = vha->vp_idx;
         struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
 
-        DEBUG11(printk("%s(%ld): entered. Enabling index %d\n", __func__,
-            vha->host_no, vp_index));
+        ql_dbg(ql_dbg_mbx, vha, 0x10c1,
+            "Entered %s enabling index %d.\n", __func__, vp_index);
 
         if (vp_index == 0 || vp_index >= ha->max_npiv_vports)
                 return QLA_PARAMETER_ERROR;
 
         vce = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &vce_dma);
         if (!vce) {
-                DEBUG2_3(printk("%s(%ld): "
-                    "failed to allocate VP Control IOCB.\n", __func__,
-                    base_vha->host_no));
+                ql_log(ql_log_warn, vha, 0x10c2,
+                    "Failed to allocate VP control IOCB.\n");
                 return QLA_MEMORY_ALLOC_FAILED;
         }
         memset(vce, 0, sizeof(struct vp_ctrl_entry_24xx));
@@ -3063,28 +3027,20 @@ qla24xx_control_vp(scsi_qla_host_t *vha, int cmd)
 
         rval = qla2x00_issue_iocb(base_vha, vce, vce_dma, 0);
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk("%s(%ld): failed to issue VP control IOCB"
-                    "(%x).\n", __func__, base_vha->host_no, rval));
-                printk("%s(%ld): failed to issue VP control IOCB"
-                    "(%x).\n", __func__, base_vha->host_no, rval);
+                ql_dbg(ql_dbg_mbx, vha, 0x10c3,
+                    "Failed to issue VP control IOCB (%x).\n", rval);
         } else if (vce->entry_status != 0) {
-                DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
-                    "-- error status (%x).\n", __func__, base_vha->host_no,
-                    vce->entry_status));
-                printk("%s(%ld): failed to complete IOCB "
-                    "-- error status (%x).\n", __func__, base_vha->host_no,
+                ql_dbg(ql_dbg_mbx, vha, 0x10c4,
+                    "Failed to complete IOCB -- error status (%x).\n",
                     vce->entry_status);
                 rval = QLA_FUNCTION_FAILED;
         } else if (vce->comp_status != __constant_cpu_to_le16(CS_COMPLETE)) {
-                DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
-                    "-- completion status (%x).\n", __func__, base_vha->host_no,
-                    le16_to_cpu(vce->comp_status)));
-                printk("%s(%ld): failed to complete IOCB "
-                    "-- completion status (%x).\n", __func__, base_vha->host_no,
+                ql_dbg(ql_dbg_mbx, vha, 0x10c5,
+                    "Failed to complet IOCB -- completion status (%x).\n",
                     le16_to_cpu(vce->comp_status));
                 rval = QLA_FUNCTION_FAILED;
         } else {
-                DEBUG2(printk("%s(%ld): done.\n", __func__, base_vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x10c6, "Done %s.\n", __func__);
         }
 
         dma_pool_free(ha->s_dma_pool, vce, vce_dma);
@@ -3121,6 +3077,8 @@ qla2x00_send_change_request(scsi_qla_host_t *vha, uint16_t format,
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
 
+        ql_dbg(ql_dbg_mbx, vha, 0x10c7, "Entered %s.\n", __func__);
+
         /*
          * This command is implicitly executed by firmware during login for the
          * physical hosts
@@ -3155,7 +3113,7 @@ qla2x00_dump_ram(scsi_qla_host_t *vha, dma_addr_t req_dma, uint32_t addr,
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
 
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x1009, "Entered %s.\n", __func__);
 
         if (MSW(addr) || IS_FWI2_CAPABLE(vha->hw)) {
                 mcp->mb[0] = MBC_DUMP_RISC_RAM_EXTENDED;
@@ -3186,10 +3144,10 @@ qla2x00_dump_ram(scsi_qla_host_t *vha, dma_addr_t req_dma, uint32_t addr,
         rval = qla2x00_mailbox_command(vha, mcp);
 
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x.\n", __func__,
-                    vha->host_no, rval, mcp->mb[0]));
+                ql_dbg(ql_dbg_mbx, vha, 0x1008,
+                    "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
         } else {
-                DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x1007, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -3214,12 +3172,10 @@ qla84xx_verify_chip(struct scsi_qla_host *vha, uint16_t *status)
         unsigned long flags;
         struct qla_hw_data *ha = vha->hw;
 
-        DEBUG16(printk("%s(%ld): entered.\n", __func__, vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x10c8, "Entered %s.\n", __func__);
 
         mn = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &mn_dma);
         if (mn == NULL) {
-                DEBUG2_3(printk("%s(%ld): failed to allocate Verify ISP84XX "
-                    "IOCB.\n", __func__, vha->host_no));
                 return QLA_MEMORY_ALLOC_FAILED;
         }
 
@@ -3237,43 +3193,43 @@ qla84xx_verify_chip(struct scsi_qla_host *vha, uint16_t *status)
                 mn->p.req.entry_count = 1;
                 mn->p.req.options = cpu_to_le16(options);
 
-                DEBUG16(printk("%s(%ld): Dump of Verify Request.\n", __func__,
-                    vha->host_no));
-                DEBUG16(qla2x00_dump_buffer((uint8_t *)mn,
-                    sizeof(*mn)));
+                ql_dbg(ql_dbg_mbx + ql_dbg_buffer, vha, 0x111c,
+                    "Dump of Verify Request.\n");
+                ql_dump_buffer(ql_dbg_mbx + ql_dbg_buffer, vha, 0x111e,
+                    (uint8_t *)mn, sizeof(*mn));
 
                 rval = qla2x00_issue_iocb_timeout(vha, mn, mn_dma, 0, 120);
                 if (rval != QLA_SUCCESS) {
-                        DEBUG2_16(printk("%s(%ld): failed to issue Verify "
-                            "IOCB (%x).\n", __func__, vha->host_no, rval));
+                        ql_dbg(ql_dbg_mbx, vha, 0x10cb,
+                            "Failed to issue verify IOCB (%x).\n", rval);
                         goto verify_done;
                 }
 
-                DEBUG16(printk("%s(%ld): Dump of Verify Response.\n", __func__,
-                    vha->host_no));
-                DEBUG16(qla2x00_dump_buffer((uint8_t *)mn,
-                    sizeof(*mn)));
+                ql_dbg(ql_dbg_mbx + ql_dbg_buffer, vha, 0x1110,
+                    "Dump of Verify Response.\n");
+                ql_dump_buffer(ql_dbg_mbx + ql_dbg_buffer, vha, 0x1118,
+                    (uint8_t *)mn, sizeof(*mn));
 
                 status[0] = le16_to_cpu(mn->p.rsp.comp_status);
                 status[1] = status[0] == CS_VCS_CHIP_FAILURE ?
                     le16_to_cpu(mn->p.rsp.failure_code) : 0;
-                DEBUG2_16(printk("%s(%ld): cs=%x fc=%x\n", __func__,
-                    vha->host_no, status[0], status[1]));
+                ql_dbg(ql_dbg_mbx, vha, 0x10ce,
+                    "cs=%x fc=%x.\n", status[0], status[1]);
 
                 if (status[0] != CS_COMPLETE) {
                         rval = QLA_FUNCTION_FAILED;
                         if (!(options & VCO_DONT_UPDATE_FW)) {
-                                DEBUG2_16(printk("%s(%ld): Firmware update "
-                                    "failed. Retrying without update "
-                                    "firmware.\n", __func__, vha->host_no));
+                                ql_dbg(ql_dbg_mbx, vha, 0x10cf,
+                                    "Firmware update failed. Retrying "
+                                    "without update firmware.\n");
                                 options |= VCO_DONT_UPDATE_FW;
                                 options &= ~VCO_FORCE_UPDATE;
                                 retry = 1;
                         }
                 } else {
-                        DEBUG2_16(printk("%s(%ld): firmware updated to %x.\n",
-                            __func__, vha->host_no,
-                            le32_to_cpu(mn->p.rsp.fw_ver)));
+                        ql_dbg(ql_dbg_mbx, vha, 0x10d0,
+                            "Firmware updated to %x.\n",
+                            le32_to_cpu(mn->p.rsp.fw_ver));
 
                         /* NOTE: we only update OP firmware. */
                         spin_lock_irqsave(&ha->cs84xx->access_lock, flags);
@@ -3288,10 +3244,9 @@ verify_done:
         dma_pool_free(ha->s_dma_pool, mn, mn_dma);
 
         if (rval != QLA_SUCCESS) {
-                DEBUG2_16(printk("%s(%ld): failed=%x.\n", __func__,
-                    vha->host_no, rval));
+                ql_dbg(ql_dbg_mbx, vha, 0x10d1, "Failed=%x.\n", rval);
         } else {
-                DEBUG16(printk("%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x10d2, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -3307,6 +3262,8 @@ qla25xx_init_req_que(struct scsi_qla_host *vha, struct req_que *req)
         struct device_reg_25xxmq __iomem *reg;
         struct qla_hw_data *ha = vha->hw;
 
+        ql_dbg(ql_dbg_mbx, vha, 0x10d3, "Entered %s.\n", __func__);
+
         mcp->mb[0] = MBC_INITIALIZE_MULTIQ;
         mcp->mb[1] = req->options;
         mcp->mb[2] = MSW(LSD(req->dma));
@@ -3344,9 +3301,13 @@ qla25xx_init_req_que(struct scsi_qla_host *vha, struct req_que *req)
         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 
         rval = qla2x00_mailbox_command(vha, mcp);
-        if (rval != QLA_SUCCESS)
-                DEBUG2_3_11(printk(KERN_WARNING "%s(%ld): failed=%x mb0=%x.\n",
-                        __func__, vha->host_no, rval, mcp->mb[0]));
+        if (rval != QLA_SUCCESS) {
+                ql_dbg(ql_dbg_mbx, vha, 0x10d4,
+                    "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
+        } else {
+                ql_dbg(ql_dbg_mbx, vha, 0x10d5, "Done %s.\n", __func__);
+        }
+
         return rval;
 }
 
@@ -3360,6 +3321,8 @@ qla25xx_init_rsp_que(struct scsi_qla_host *vha, struct rsp_que *rsp)
         struct device_reg_25xxmq __iomem *reg;
         struct qla_hw_data *ha = vha->hw;
 
+        ql_dbg(ql_dbg_mbx, vha, 0x10d6, "Entered %s.\n", __func__);
+
         mcp->mb[0] = MBC_INITIALIZE_MULTIQ;
         mcp->mb[1] = rsp->options;
         mcp->mb[2] = MSW(LSD(rsp->dma));
@@ -3393,10 +3356,13 @@ qla25xx_init_rsp_que(struct scsi_qla_host *vha, struct rsp_que *rsp)
         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 
         rval = qla2x00_mailbox_command(vha, mcp);
-        if (rval != QLA_SUCCESS)
-                DEBUG2_3_11(printk(KERN_WARNING "%s(%ld): failed=%x "
-                        "mb0=%x.\n", __func__,
-                        vha->host_no, rval, mcp->mb[0]));
+        if (rval != QLA_SUCCESS) {
+                ql_dbg(ql_dbg_mbx, vha, 0x10d7,
+                    "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
+        } else {
+                ql_dbg(ql_dbg_mbx, vha, 0x10d8, "Done %s.\n", __func__);
+        }
+
         return rval;
 }
 
@@ -3407,7 +3373,7 @@ qla81xx_idc_ack(scsi_qla_host_t *vha, uint16_t *mb)
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
 
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x10d9, "Entered %s.\n", __func__);
 
         mcp->mb[0] = MBC_IDC_ACK;
         memcpy(&mcp->mb[1], mb, QLA_IDC_ACK_REGS * sizeof(uint16_t));
@@ -3418,10 +3384,10 @@ qla81xx_idc_ack(scsi_qla_host_t *vha, uint16_t *mb)
         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]));
+                ql_dbg(ql_dbg_mbx, vha, 0x10da,
+                    "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
         } else {
-                DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x10db, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -3434,11 +3400,11 @@ qla81xx_fac_get_sector_size(scsi_qla_host_t *vha, uint32_t *sector_size)
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
 
+        ql_dbg(ql_dbg_mbx, vha, 0x10dc, "Entered %s.\n", __func__);
+
         if (!IS_QLA81XX(vha->hw))
                 return QLA_FUNCTION_FAILED;
 
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
-
         mcp->mb[0] = MBC_FLASH_ACCESS_CTRL;
         mcp->mb[1] = FAC_OPT_CMD_GET_SECTOR_SIZE;
         mcp->out_mb = MBX_1|MBX_0;
@@ -3448,10 +3414,11 @@ qla81xx_fac_get_sector_size(scsi_qla_host_t *vha, uint32_t *sector_size)
         rval = qla2x00_mailbox_command(vha, mcp);
 
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x.\n",
-                    __func__, vha->host_no, rval, mcp->mb[0], mcp->mb[1]));
+                ql_dbg(ql_dbg_mbx, vha, 0x10dd,
+                    "Failed=%x mb[0]=%x mb[1]=%x.\n",
+                    rval, mcp->mb[0], mcp->mb[1]);
         } else {
-                DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x10de, "Done %s.\n", __func__);
                 *sector_size = mcp->mb[1];
         }
 
@@ -3468,7 +3435,7 @@ qla81xx_fac_do_write_enable(scsi_qla_host_t *vha, int enable)
         if (!IS_QLA81XX(vha->hw))
                 return QLA_FUNCTION_FAILED;
 
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x10df, "Entered %s.\n", __func__);
 
         mcp->mb[0] = MBC_FLASH_ACCESS_CTRL;
         mcp->mb[1] = enable ? FAC_OPT_CMD_WRITE_ENABLE :
@@ -3480,10 +3447,11 @@ qla81xx_fac_do_write_enable(scsi_qla_host_t *vha, int enable)
         rval = qla2x00_mailbox_command(vha, mcp);
 
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x.\n",
-                    __func__, vha->host_no, rval, mcp->mb[0], mcp->mb[1]));
+                ql_dbg(ql_dbg_mbx, vha, 0x10e0,
+                    "Failed=%x mb[0]=%x mb[1]=%x.\n",
+                    rval, mcp->mb[0], mcp->mb[1]);
         } else {
-                DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x10e1, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -3499,7 +3467,7 @@ qla81xx_fac_erase_sector(scsi_qla_host_t *vha, uint32_t start, uint32_t finish)
         if (!IS_QLA81XX(vha->hw))
                 return QLA_FUNCTION_FAILED;
 
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x10e2, "Entered %s.\n", __func__);
 
         mcp->mb[0] = MBC_FLASH_ACCESS_CTRL;
         mcp->mb[1] = FAC_OPT_CMD_ERASE_SECTOR;
@@ -3514,11 +3482,11 @@ qla81xx_fac_erase_sector(scsi_qla_host_t *vha, uint32_t start, uint32_t finish)
         rval = qla2x00_mailbox_command(vha, mcp);
 
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x mb[1]=%x "
-                    "mb[2]=%x.\n", __func__, vha->host_no, rval, mcp->mb[0],
-                    mcp->mb[1], mcp->mb[2]));
+                ql_dbg(ql_dbg_mbx, vha, 0x10e3,
+                    "Failed=%x mb[0]=%x mb[1]=%x mb[2]=%x.\n",
+                    rval, mcp->mb[0], mcp->mb[1], mcp->mb[2]);
         } else {
-                DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x10e4, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -3531,7 +3499,7 @@ qla81xx_restart_mpi_firmware(scsi_qla_host_t *vha)
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
 
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x10e5, "Entered %s.\n", __func__);
 
         mcp->mb[0] = MBC_RESTART_MPI_FW;
         mcp->out_mb = MBX_0;
@@ -3541,10 +3509,11 @@ qla81xx_restart_mpi_firmware(scsi_qla_host_t *vha)
         rval = qla2x00_mailbox_command(vha, mcp);
 
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=0x%x mb[1]=0x%x.\n",
-                    __func__, vha->host_no, rval, mcp->mb[0], mcp->mb[1]));
+                ql_dbg(ql_dbg_mbx, vha, 0x10e6,
+                    "Failed=%x mb[0]=%x mb[1]=%x.\n",
+                    rval, mcp->mb[0], mcp->mb[1]);
         } else {
-                DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x10e7, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -3559,11 +3528,11 @@ qla2x00_read_sfp(scsi_qla_host_t *vha, dma_addr_t sfp_dma, uint8_t *sfp,
         mbx_cmd_t *mcp = &mc;
         struct qla_hw_data *ha = vha->hw;
 
+        ql_dbg(ql_dbg_mbx, vha, 0x10e8, "Entered %s.\n", __func__);
+
         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;
 
@@ -3586,10 +3555,10 @@ qla2x00_read_sfp(scsi_qla_host_t *vha, dma_addr_t sfp_dma, uint8_t *sfp,
                 *sfp = mcp->mb[1];
 
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk("%s(%ld): failed=%x (%x).\n", __func__,
-                    vha->host_no, rval, mcp->mb[0]));
+                ql_dbg(ql_dbg_mbx, vha, 0x10e9,
+                    "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
         } else {
-                DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x10ea, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -3604,11 +3573,11 @@ qla2x00_write_sfp(scsi_qla_host_t *vha, dma_addr_t sfp_dma, uint8_t *sfp,
         mbx_cmd_t *mcp = &mc;
         struct qla_hw_data *ha = vha->hw;
 
+        ql_dbg(ql_dbg_mbx, vha, 0x10eb, "Entered %s.\n", __func__);
+
         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;
 
@@ -3631,10 +3600,10 @@ qla2x00_write_sfp(scsi_qla_host_t *vha, dma_addr_t sfp_dma, uint8_t *sfp,
         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]));
+                ql_dbg(ql_dbg_mbx, vha, 0x10ec,
+                    "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
         } else {
-                DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x10ed, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -3648,11 +3617,11 @@ qla2x00_get_xgmac_stats(scsi_qla_host_t *vha, dma_addr_t stats_dma,
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
 
+        ql_dbg(ql_dbg_mbx, vha, 0x10ee, "Entered %s.\n", __func__);
+
         if (!IS_QLA8XXX_TYPE(vha->hw))
                 return QLA_FUNCTION_FAILED;
 
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
-
         mcp->mb[0] = MBC_GET_XGMAC_STATS;
         mcp->mb[2] = MSW(stats_dma);
         mcp->mb[3] = LSW(stats_dma);
@@ -3666,11 +3635,12 @@ qla2x00_get_xgmac_stats(scsi_qla_host_t *vha, dma_addr_t stats_dma,
         rval = qla2x00_mailbox_command(vha, mcp);
 
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=0x%x "
-                    "mb[1]=0x%x mb[2]=0x%x.\n", __func__, vha->host_no, rval,
-                    mcp->mb[0], mcp->mb[1], mcp->mb[2]));
+                ql_dbg(ql_dbg_mbx, vha, 0x10ef,
+                    "Failed=%x mb[0]=%x mb[1]=%x mb[2]=%x.\n",
+                    rval, mcp->mb[0], mcp->mb[1], mcp->mb[2]);
         } else {
-                DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x10f0, "Done %s.\n", __func__);
+
 
                 *actual_size = mcp->mb[2] << 2;
         }
@@ -3686,11 +3656,11 @@ qla2x00_get_dcbx_params(scsi_qla_host_t *vha, dma_addr_t tlv_dma,
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
 
+        ql_dbg(ql_dbg_mbx, vha, 0x10f1, "Entered %s.\n", __func__);
+
         if (!IS_QLA8XXX_TYPE(vha->hw))
                 return QLA_FUNCTION_FAILED;
 
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
-
         mcp->mb[0] = MBC_GET_DCBX_PARAMS;
         mcp->mb[1] = 0;
         mcp->mb[2] = MSW(tlv_dma);
@@ -3705,11 +3675,11 @@ qla2x00_get_dcbx_params(scsi_qla_host_t *vha, dma_addr_t tlv_dma,
         rval = qla2x00_mailbox_command(vha, mcp);
 
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=0x%x "
-                    "mb[1]=0x%x mb[2]=0x%x.\n", __func__, vha->host_no, rval,
-                    mcp->mb[0], mcp->mb[1], mcp->mb[2]));
+                ql_dbg(ql_dbg_mbx, vha, 0x10f2,
+                    "Failed=%x mb[0]=%x mb[1]=%x mb[2]=%x.\n",
+                    rval, mcp->mb[0], mcp->mb[1], mcp->mb[2]);
         } else {
-                DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x10f3, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -3722,11 +3692,11 @@ qla2x00_read_ram_word(scsi_qla_host_t *vha, uint32_t risc_addr, uint32_t *data)
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
 
+        ql_dbg(ql_dbg_mbx, vha, 0x10f4, "Entered %s.\n", __func__);
+
         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_RAM_EXTENDED;
         mcp->mb[1] = LSW(risc_addr);
         mcp->mb[8] = MSW(risc_addr);
@@ -3736,10 +3706,10 @@ qla2x00_read_ram_word(scsi_qla_host_t *vha, uint32_t risc_addr, uint32_t *data)
         mcp->flags = 0;
         rval = qla2x00_mailbox_command(vha, mcp);
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x.\n", __func__,
-                    vha->host_no, rval, mcp->mb[0]));
+                ql_dbg(ql_dbg_mbx, vha, 0x10f5,
+                    "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
         } else {
-                DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x10f6, "Done %s.\n", __func__);
                 *data = mcp->mb[3] << 16 | mcp->mb[2];
         }
 
@@ -3755,7 +3725,7 @@ qla2x00_loopback_test(scsi_qla_host_t *vha, struct msg_echo_lb *mreq,
         mbx_cmd_t *mcp = &mc;
         uint32_t iter_cnt = 0x1;
 
-        DEBUG11(printk("scsi(%ld): entered.\n", vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x10f7, "Entered %s.\n", __func__);
 
         memset(mcp->mb, 0 , sizeof(mcp->mb));
         mcp->mb[0] = MBC_DIAGNOSTIC_LOOP_BACK;
@@ -3794,15 +3764,12 @@ qla2x00_loopback_test(scsi_qla_host_t *vha, struct msg_echo_lb *mreq,
         rval = qla2x00_mailbox_command(vha, mcp);
 
         if (rval != QLA_SUCCESS) {
-                DEBUG2(printk(KERN_WARNING
-                        "(%ld): failed=%x mb[0]=0x%x "
-                        "mb[1]=0x%x mb[2]=0x%x mb[3]=0x%x mb[18]=0x%x "
-                        "mb[19]=0x%x.\n",
-                        vha->host_no, rval, mcp->mb[0], mcp->mb[1], mcp->mb[2],
-                        mcp->mb[3], mcp->mb[18], mcp->mb[19]));
+                ql_dbg(ql_dbg_mbx, vha, 0x10f8,
+                    "Failed=%x mb[0]=%x mb[1]=%x mb[2]=%x mb[3]=%x mb[18]=%x "
+                    "mb[19]=%x.\n", rval, mcp->mb[0], mcp->mb[1], mcp->mb[2],
+                    mcp->mb[3], mcp->mb[18], mcp->mb[19]);
         } else {
-                DEBUG2(printk(KERN_WARNING
-                    "scsi(%ld): done.\n", vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x10f9, "Done %s.\n", __func__);
         }
 
         /* Copy mailbox information */
@@ -3819,7 +3786,7 @@ qla2x00_echo_test(scsi_qla_host_t *vha, struct msg_echo_lb *mreq,
         mbx_cmd_t *mcp = &mc;
         struct qla_hw_data *ha = vha->hw;
 
-        DEBUG11(printk("scsi(%ld): entered.\n", vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x10fa, "Entered %s.\n", __func__);
 
         memset(mcp->mb, 0 , sizeof(mcp->mb));
         mcp->mb[0] = MBC_DIAGNOSTIC_ECHO;
@@ -3858,12 +3825,11 @@ qla2x00_echo_test(scsi_qla_host_t *vha, struct msg_echo_lb *mreq,
         rval = qla2x00_mailbox_command(vha, mcp);
 
         if (rval != QLA_SUCCESS) {
-                DEBUG2(printk(KERN_WARNING
-                    "(%ld): failed=%x mb[0]=0x%x mb[1]=0x%x.\n",
-                    vha->host_no, rval, mcp->mb[0], mcp->mb[1]));
+                ql_dbg(ql_dbg_mbx, vha, 0x10fb,
+                    "Failed=%x mb[0]=%x mb[1]=%x.\n",
+                    rval, mcp->mb[0], mcp->mb[1]);
         } else {
-                DEBUG2(printk(KERN_WARNING
-                    "scsi(%ld): done.\n", vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x10fc, "Done %s.\n", __func__);
         }
 
         /* Copy mailbox information */
@@ -3872,14 +3838,14 @@ qla2x00_echo_test(scsi_qla_host_t *vha, struct msg_echo_lb *mreq,
 }
 
 int
-qla84xx_reset_chip(scsi_qla_host_t *ha, uint16_t enable_diagnostic)
+qla84xx_reset_chip(scsi_qla_host_t *vha, uint16_t enable_diagnostic)
 {
         int rval;
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
 
-        DEBUG16(printk("%s(%ld): enable_diag=%d entered.\n", __func__,
-                ha->host_no, enable_diagnostic));
+        ql_dbg(ql_dbg_mbx, vha, 0x10fd,
+            "Entered %s enable_diag=%d.\n", __func__, enable_diagnostic);
 
         mcp->mb[0] = MBC_ISP84XX_RESET;
         mcp->mb[1] = enable_diagnostic;
@@ -3887,13 +3853,12 @@ qla84xx_reset_chip(scsi_qla_host_t *ha, uint16_t enable_diagnostic)
         mcp->in_mb = MBX_1|MBX_0;
         mcp->tov = MBX_TOV_SECONDS;
         mcp->flags = MBX_DMA_OUT|MBX_DMA_IN|IOCTL_CMD;
-        rval = qla2x00_mailbox_command(ha, mcp);
+        rval = qla2x00_mailbox_command(vha, mcp);
 
         if (rval != QLA_SUCCESS)
-                DEBUG16(printk("%s(%ld): failed=%x.\n", __func__, ha->host_no,
-                        rval));
+                ql_dbg(ql_dbg_mbx, vha, 0x10fe, "Failed=%x.\n", rval);
         else
-                DEBUG16(printk("%s(%ld): done.\n", __func__, ha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x10ff, "Done %s.\n", __func__);
 
         return rval;
 }
@@ -3905,11 +3870,11 @@ qla2x00_write_ram_word(scsi_qla_host_t *vha, uint32_t risc_addr, uint32_t data)
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
 
+        ql_dbg(ql_dbg_mbx, vha, 0x1100, "Entered %s.\n", __func__);
+
         if (!IS_FWI2_CAPABLE(vha->hw))
                 return QLA_FUNCTION_FAILED;
 
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
-
         mcp->mb[0] = MBC_WRITE_RAM_WORD_EXTENDED;
         mcp->mb[1] = LSW(risc_addr);
         mcp->mb[2] = LSW(data);
@@ -3921,10 +3886,10 @@ qla2x00_write_ram_word(scsi_qla_host_t *vha, uint32_t risc_addr, uint32_t data)
         mcp->flags = 0;
         rval = qla2x00_mailbox_command(vha, mcp);
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk("%s(%ld): failed=%x mb[0]=%x.\n", __func__,
-                    vha->host_no, rval, mcp->mb[0]));
+                ql_dbg(ql_dbg_mbx, vha, 0x1101,
+                    "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
         } else {
-                DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x1102, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -3941,8 +3906,7 @@ qla81xx_write_mpi_register(scsi_qla_host_t *vha, uint16_t *mb)
 
         rval = QLA_SUCCESS;
 
-        DEBUG11(qla_printk(KERN_INFO, ha,
-            "%s(%ld): entered.\n", __func__, vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x1103, "Entered %s.\n", __func__);
 
         clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
 
@@ -3982,11 +3946,10 @@ qla81xx_write_mpi_register(scsi_qla_host_t *vha, uint16_t *mb)
                 rval = QLA_FUNCTION_FAILED;
 
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk(KERN_INFO "%s(%ld): failed=%x mb[0]=%x.\n",
-                    __func__, vha->host_no, rval, mb[0]));
+                ql_dbg(ql_dbg_mbx, vha, 0x1104,
+                    "Failed=%x mb[0]=%x.\n", rval, mb[0]);
         } else {
-                DEBUG11(printk(KERN_INFO
-                    "%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x1105, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -3999,12 +3962,11 @@ qla2x00_get_data_rate(scsi_qla_host_t *vha)
         mbx_cmd_t *mcp = &mc;
         struct qla_hw_data *ha = vha->hw;
 
+        ql_dbg(ql_dbg_mbx, vha, 0x1106, "Entered %s.\n", __func__);
+
         if (!IS_FWI2_CAPABLE(ha))
                 return QLA_FUNCTION_FAILED;
 
-        DEBUG11(qla_printk(KERN_INFO, ha,
-                "%s(%ld): entered.\n", __func__, vha->host_no));
-
         mcp->mb[0] = MBC_DATA_RATE;
         mcp->mb[1] = 0;
         mcp->out_mb = MBX_1|MBX_0;
@@ -4013,11 +3975,10 @@ qla2x00_get_data_rate(scsi_qla_host_t *vha)
         mcp->flags = 0;
         rval = qla2x00_mailbox_command(vha, mcp);
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk(KERN_INFO "%s(%ld): failed=%x mb[0]=%x.\n",
-                    __func__, vha->host_no, rval, mcp->mb[0]));
+                ql_dbg(ql_dbg_mbx, vha, 0x1107,
+                    "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
         } else {
-                DEBUG11(printk(KERN_INFO
-                    "%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x1108, "Done %s.\n", __func__);
                 if (mcp->mb[1] != 0x7)
                         ha->link_data_rate = mcp->mb[1];
         }
@@ -4033,8 +3994,7 @@ qla81xx_get_port_config(scsi_qla_host_t *vha, uint16_t *mb)
         mbx_cmd_t *mcp = &mc;
         struct qla_hw_data *ha = vha->hw;
 
-        DEBUG11(printk(KERN_INFO
-            "%s(%ld): entered.\n", __func__, vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x1109, "Entered %s.\n", __func__);
 
         if (!IS_QLA81XX(ha))
                 return QLA_FUNCTION_FAILED;
@@ -4047,15 +4007,13 @@ qla81xx_get_port_config(scsi_qla_host_t *vha, uint16_t *mb)
         rval = qla2x00_mailbox_command(vha, mcp);
 
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk(KERN_WARNING
-                    "%s(%ld): failed=%x (%x).\n", __func__,
-                    vha->host_no, rval, mcp->mb[0]));
+                ql_dbg(ql_dbg_mbx, vha, 0x110a,
+                    "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
         } else {
                 /* Copy all bits to preserve original value */
                 memcpy(mb, &mcp->mb[1], sizeof(uint16_t) * 4);
 
-                DEBUG11(printk(KERN_INFO
-                    "%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x110b, "Done %s.\n", __func__);
         }
         return rval;
 }
@@ -4067,8 +4025,7 @@ qla81xx_set_port_config(scsi_qla_host_t *vha, uint16_t *mb)
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
 
-        DEBUG11(printk(KERN_INFO
-            "%s(%ld): entered.\n", __func__, vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x110c, "Entered %s.\n", __func__);
 
         mcp->mb[0] = MBC_SET_PORT_CONFIG;
         /* Copy all bits to preserve original setting */
@@ -4080,12 +4037,10 @@ qla81xx_set_port_config(scsi_qla_host_t *vha, uint16_t *mb)
         rval = qla2x00_mailbox_command(vha, mcp);
 
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk(KERN_WARNING
-                    "%s(%ld): failed=%x (%x).\n", __func__,
-                    vha->host_no, rval, mcp->mb[0]));
+                ql_dbg(ql_dbg_mbx, vha, 0x110d,
+                    "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
         } else
-                DEBUG11(printk(KERN_INFO
-                    "%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x110e, "Done %s.\n", __func__);
 
         return rval;
 }
@@ -4100,12 +4055,11 @@ qla24xx_set_fcp_prio(scsi_qla_host_t *vha, uint16_t loop_id, uint16_t priority,
         mbx_cmd_t *mcp = &mc;
         struct qla_hw_data *ha = vha->hw;
 
+        ql_dbg(ql_dbg_mbx, vha, 0x110f, "Entered %s.\n", __func__);
+
         if (!IS_QLA24XX_TYPE(ha) && !IS_QLA25XX(ha))
                 return QLA_FUNCTION_FAILED;
 
-        DEBUG11(printk(KERN_INFO
-            "%s(%ld): entered.\n", __func__, vha->host_no));
-
         mcp->mb[0] = MBC_PORT_PARAMS;
         mcp->mb[1] = loop_id;
         if (ha->flags.fcp_prio_enabled)
@@ -4127,12 +4081,9 @@ qla24xx_set_fcp_prio(scsi_qla_host_t *vha, uint16_t loop_id, uint16_t priority,
         }
 
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk(KERN_WARNING
-                    "%s(%ld): failed=%x.\n", __func__,
-                    vha->host_no, rval));
+                ql_dbg(ql_dbg_mbx, vha, 0x10cd, "Failed=%x.\n", rval);
         } else {
-                DEBUG11(printk(KERN_INFO
-                    "%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x10cc, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -4145,13 +4096,12 @@ qla2x00_get_thermal_temp(scsi_qla_host_t *vha, uint16_t *temp, uint16_t *frac)
         uint8_t byte;
         struct qla_hw_data *ha = vha->hw;
 
-        DEBUG11(printk(KERN_INFO "%s(%ld): entered.\n", __func__, vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x10ca, "Entered %s.\n", __func__);
 
         /* 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.\n", __func__, vha->host_no, rval));
+                ql_dbg(ql_dbg_mbx, vha, 0x10c9, "Failed=%x.\n", rval);
                 ha->flags.thermal_supported = 0;
                 goto fail;
         }
@@ -4160,14 +4110,13 @@ qla2x00_get_thermal_temp(scsi_qla_host_t *vha, uint16_t *temp, uint16_t *frac)
         /* 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.\n", __func__, vha->host_no, rval));
+                ql_dbg(ql_dbg_mbx, vha, 0x1019, "Failed=%x.\n", rval);
                 ha->flags.thermal_supported = 0;
                 goto fail;
         }
         *frac = (byte >> 6) * 25;
 
-        DEBUG11(printk(KERN_INFO "%s(%ld): done.\n", __func__, vha->host_no));
+        ql_dbg(ql_dbg_mbx, vha, 0x1018, "Done %s.\n", __func__);
 fail:
         return rval;
 }
@@ -4180,12 +4129,11 @@ qla82xx_mbx_intr_enable(scsi_qla_host_t *vha)
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
 
+        ql_dbg(ql_dbg_mbx, vha, 0x1017, "Entered %s.\n", __func__);
+
         if (!IS_FWI2_CAPABLE(ha))
                 return QLA_FUNCTION_FAILED;
 
-        DEBUG11(qla_printk(KERN_INFO, ha,
-                "%s(%ld): entered.\n", __func__, vha->host_no));
-
         memset(mcp, 0, sizeof(mbx_cmd_t));
         mcp->mb[0] = MBC_TOGGLE_INTERRUPT;
         mcp->mb[1] = 1;
@@ -4197,12 +4145,10 @@ qla82xx_mbx_intr_enable(scsi_qla_host_t *vha)
 
         rval = qla2x00_mailbox_command(vha, mcp);
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(qla_printk(KERN_WARNING, ha,
-                        "%s(%ld): failed=%x mb[0]=%x.\n", __func__,
-                        vha->host_no, rval, mcp->mb[0]));
+                ql_dbg(ql_dbg_mbx, vha, 0x1016,
+                    "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
         } else {
-                DEBUG11(qla_printk(KERN_INFO, ha,
-                        "%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x100e, "Done %s.\n", __func__);
         }
 
         return rval;
@@ -4216,12 +4162,11 @@ qla82xx_mbx_intr_disable(scsi_qla_host_t *vha)
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
 
+        ql_dbg(ql_dbg_mbx, vha, 0x100d, "Entered %s.\n", __func__);
+
         if (!IS_QLA82XX(ha))
                 return QLA_FUNCTION_FAILED;
 
-        DEBUG11(qla_printk(KERN_INFO, ha,
-                "%s(%ld): entered.\n", __func__, vha->host_no));
-
         memset(mcp, 0, sizeof(mbx_cmd_t));
         mcp->mb[0] = MBC_TOGGLE_INTERRUPT;
         mcp->mb[1] = 0;
@@ -4233,12 +4178,10 @@ qla82xx_mbx_intr_disable(scsi_qla_host_t *vha)
 
         rval = qla2x00_mailbox_command(vha, mcp);
         if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(qla_printk(KERN_WARNING, ha,
-                        "%s(%ld): failed=%x mb[0]=%x.\n", __func__,
-                        vha->host_no, rval, mcp->mb[0]));
+                ql_dbg(ql_dbg_mbx, vha, 0x100c,
+                    "Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
         } else {
-                DEBUG11(qla_printk(KERN_INFO, ha,
-                        "%s(%ld): done.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_mbx, vha, 0x100b, "Done %s.\n", __func__);
         }
 
         return rval;
diff --git a/drivers/scsi/qla2xxx/qla_mid.c b/drivers/scsi/qla2xxx/qla_mid.c
index 5e343919acad..c706ed370000 100644
--- a/drivers/scsi/qla2xxx/qla_mid.c
+++ b/drivers/scsi/qla2xxx/qla_mid.c
@@ -36,8 +36,9 @@ qla24xx_allocate_vp_id(scsi_qla_host_t *vha)
         mutex_lock(&ha->vport_lock);
         vp_id = find_first_zero_bit(ha->vp_idx_map, ha->max_npiv_vports + 1);
         if (vp_id > ha->max_npiv_vports) {
-                DEBUG15(printk ("vp_id %d is bigger than max-supported %d.\n",
-                    vp_id, ha->max_npiv_vports));
+                ql_dbg(ql_dbg_vport, vha, 0xa000,
+                    "vp_id %d is bigger than max-supported %d.\n",
+                    vp_id, ha->max_npiv_vports);
                 mutex_unlock(&ha->vport_lock);
                 return vp_id;
         }
@@ -131,9 +132,9 @@ qla2x00_mark_vp_devices_dead(scsi_qla_host_t *vha)
         fc_port_t *fcport;
 
         list_for_each_entry(fcport, &vha->vp_fcports, list) {
-                DEBUG15(printk("scsi(%ld): Marking port dead, "
-                    "loop_id=0x%04x :%x\n",
-                    vha->host_no, fcport->loop_id, fcport->vp_idx));
+                ql_dbg(ql_dbg_vport, vha, 0xa001,
+                    "Marking port dead, loop_id=0x%04x : %x.\n",
+                    fcport->loop_id, fcport->vp_idx);
 
                 qla2x00_mark_device_lost(vha, fcport, 0, 0);
                 qla2x00_set_fcport_state(fcport, FCS_UNCONFIGURED);
@@ -187,13 +188,13 @@ qla24xx_enable_vp(scsi_qla_host_t *vha)
                 goto enable_failed;
         }
 
-        DEBUG15(qla_printk(KERN_INFO, ha,
-            "Virtual port with id: %d - Enabled\n", vha->vp_idx));
+        ql_dbg(ql_dbg_taskm, vha, 0x801a,
+            "Virtual port with id: %d - Enabled.\n", vha->vp_idx);
         return 0;
 
 enable_failed:
-        DEBUG15(qla_printk(KERN_INFO, ha,
-            "Virtual port with id: %d - Disabled\n", vha->vp_idx));
+        ql_dbg(ql_dbg_taskm, vha, 0x801b,
+            "Virtual port with id: %d - Disabled.\n", vha->vp_idx);
         return 1;
 }
 
@@ -205,12 +206,12 @@ qla24xx_configure_vp(scsi_qla_host_t *vha)
 
         fc_vport = vha->fc_vport;
 
-        DEBUG15(printk("scsi(%ld): %s: change request #3 for this host.\n",
-            vha->host_no, __func__));
+        ql_dbg(ql_dbg_vport, vha, 0xa002,
+            "%s: change request #3.\n", __func__);
         ret = qla2x00_send_change_request(vha, 0x3, vha->vp_idx);
         if (ret != QLA_SUCCESS) {
-                DEBUG15(qla_printk(KERN_ERR, vha->hw, "Failed to enable "
-                    "receiving of RSCN requests: 0x%x\n", ret));
+                ql_dbg(ql_dbg_vport, vha, 0xa003, "Failed to enable "
+                    "receiving of RSCN requests: 0x%x.\n", ret);
                 return;
         } else {
                 /* Corresponds to SCR enabled */
@@ -248,9 +249,9 @@ qla2x00_alert_all_vps(struct rsp_que *rsp, uint16_t *mb)
                         case MBA_CHG_IN_CONNECTION:
                         case MBA_PORT_UPDATE:
                         case MBA_RSCN_UPDATE:
-                                DEBUG15(printk("scsi(%ld)%s: Async_event for"
-                                " VP[%d], mb = 0x%x, vha=%p\n",
-                                vha->host_no, __func__, i, *mb, vha));
+                                ql_dbg(ql_dbg_async, vha, 0x5024,
+                                    "Async_event for VP[%d], mb=0x%x vha=%p.\n",
+                                    i, *mb, vha);
                                 qla2x00_async_event(vha, rsp, mb);
                                 break;
                         }
@@ -286,37 +287,49 @@ qla2x00_vp_abort_isp(scsi_qla_host_t *vha)
         if (!test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags))
                 qla24xx_control_vp(vha, VCE_COMMAND_DISABLE_VPS_LOGO_ALL);
 
-        DEBUG15(printk("scsi(%ld): Scheduling enable of Vport %d...\n",
-            vha->host_no, vha->vp_idx));
+        ql_dbg(ql_dbg_taskm, vha, 0x801d,
+            "Scheduling enable of Vport %d.\n", vha->vp_idx);
         return qla24xx_enable_vp(vha);
 }
 
 static int
 qla2x00_do_dpc_vp(scsi_qla_host_t *vha)
 {
+        ql_dbg(ql_dbg_dpc, vha, 0x4012,
+            "Entering %s.\n", __func__);
+        ql_dbg(ql_dbg_dpc, vha, 0x4013,
+            "vp_flags: 0x%lx.\n", vha->vp_flags);
+
         qla2x00_do_work(vha);
 
         if (test_and_clear_bit(VP_IDX_ACQUIRED, &vha->vp_flags)) {
                 /* VP acquired. complete port configuration */
+                ql_dbg(ql_dbg_dpc, vha, 0x4014,
+                    "Configure VP scheduled.\n");
                 qla24xx_configure_vp(vha);
+                ql_dbg(ql_dbg_dpc, vha, 0x4015,
+                    "Configure VP end.\n");
                 return 0;
         }
 
         if (test_bit(FCPORT_UPDATE_NEEDED, &vha->dpc_flags)) {
+                ql_dbg(ql_dbg_dpc, vha, 0x4016,
+                    "FCPort update scheduled.\n");
                 qla2x00_update_fcports(vha);
                 clear_bit(FCPORT_UPDATE_NEEDED, &vha->dpc_flags);
+                ql_dbg(ql_dbg_dpc, vha, 0x4017,
+                    "FCPort update end.\n");
         }
 
         if ((test_and_clear_bit(RELOGIN_NEEDED, &vha->dpc_flags)) &&
                 !test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags) &&
                 atomic_read(&vha->loop_state) != LOOP_DOWN) {
 
-                DEBUG(printk("scsi(%ld): qla2x00_port_login()\n",
-                                                vha->host_no));
+                ql_dbg(ql_dbg_dpc, vha, 0x4018,
+                    "Relogin needed scheduled.\n");
                 qla2x00_relogin(vha);
-
-                DEBUG(printk("scsi(%ld): qla2x00_port_login - end\n",
-                                                        vha->host_no));
+                ql_dbg(ql_dbg_dpc, vha, 0x4019,
+                    "Relogin needed end.\n");
         }
 
         if (test_and_clear_bit(RESET_MARKER_NEEDED, &vha->dpc_flags) &&
@@ -326,11 +339,17 @@ qla2x00_do_dpc_vp(scsi_qla_host_t *vha)
 
         if (test_and_clear_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags)) {
                 if (!(test_and_set_bit(LOOP_RESYNC_ACTIVE, &vha->dpc_flags))) {
+                        ql_dbg(ql_dbg_dpc, vha, 0x401a,
+                            "Loop resync scheduled.\n");
                         qla2x00_loop_resync(vha);
                         clear_bit(LOOP_RESYNC_ACTIVE, &vha->dpc_flags);
+                        ql_dbg(ql_dbg_dpc, vha, 0x401b,
+                            "Loop resync end.\n");
                 }
         }
 
+        ql_dbg(ql_dbg_dpc, vha, 0x401c,
+            "Exiting %s.\n", __func__);
         return 0;
 }
 
@@ -396,9 +415,10 @@ qla24xx_vport_create_req_sanity_check(struct fc_vport *fc_vport)
 
         /* Check up max-npiv-supports */
         if (ha->num_vhosts > ha->max_npiv_vports) {
-                DEBUG15(printk("scsi(%ld): num_vhosts %ud is bigger than "
-                    "max_npv_vports %ud.\n", base_vha->host_no,
-                    ha->num_vhosts, ha->max_npiv_vports));
+                ql_dbg(ql_dbg_vport, vha, 0xa004,
+                    "num_vhosts %ud is bigger "
+                    "than max_npiv_vports %ud.\n",
+                    ha->num_vhosts, ha->max_npiv_vports);
                 return VPCERR_UNSUPPORTED;
         }
         return 0;
@@ -415,7 +435,8 @@ qla24xx_create_vhost(struct fc_vport *fc_vport)
 
         vha = qla2x00_create_host(sht, ha);
         if (!vha) {
-                DEBUG(printk("qla2xxx: scsi_host_alloc() failed for vport\n"));
+                ql_log(ql_log_warn, vha, 0xa005,
+                    "scsi_host_alloc() failed for vport.\n");
                 return(NULL);
         }
 
@@ -429,8 +450,8 @@ qla24xx_create_vhost(struct fc_vport *fc_vport)
         vha->device_flags = 0;
         vha->vp_idx = qla24xx_allocate_vp_id(vha);
         if (vha->vp_idx > ha->max_npiv_vports) {
-                DEBUG15(printk("scsi(%ld): Couldn't allocate vp_id.\n",
-                        vha->host_no));
+                ql_dbg(ql_dbg_vport, vha, 0xa006,
+                    "Couldn't allocate vp_id.\n");
                 goto create_vhost_failed;
         }
         vha->mgmt_svr_loop_id = 10 + vha->vp_idx;
@@ -461,8 +482,9 @@ qla24xx_create_vhost(struct fc_vport *fc_vport)
         host->max_id = MAX_TARGETS_2200;
         host->transportt = qla2xxx_transport_vport_template;
 
-        DEBUG15(printk("DEBUG: detect vport hba %ld at address = %p\n",
-            vha->host_no, vha));
+        ql_dbg(ql_dbg_vport, vha, 0xa007,
+            "Detect vport hba %ld at address = %p.\n",
+            vha->host_no, vha);
 
         vha->flags.init_done = 1;
 
@@ -567,9 +589,9 @@ qla25xx_delete_queues(struct scsi_qla_host *vha)
                 if (req) {
                         ret = qla25xx_delete_req_que(vha, req);
                         if (ret != QLA_SUCCESS) {
-                                qla_printk(KERN_WARNING, ha,
-                                "Couldn't delete req que %d\n",
-                                req->id);
+                                ql_log(ql_log_warn, vha, 0x00ea,
+                                    "Couldn't delete req que %d.\n",
+                                    req->id);
                                 return ret;
                         }
                 }
@@ -581,9 +603,9 @@ qla25xx_delete_queues(struct scsi_qla_host *vha)
                 if (rsp) {
                         ret = qla25xx_delete_rsp_que(vha, rsp);
                         if (ret != QLA_SUCCESS) {
-                                qla_printk(KERN_WARNING, ha,
-                                "Couldn't delete rsp que %d\n",
-                                rsp->id);
+                                ql_log(ql_log_warn, vha, 0x00eb,
+                                    "Couldn't delete rsp que %d.\n",
+                                    rsp->id);
                                 return ret;
                         }
                 }
@@ -604,8 +626,8 @@ qla25xx_create_req_que(struct qla_hw_data *ha, uint16_t options,
 
         req = kzalloc(sizeof(struct req_que), GFP_KERNEL);
         if (req == NULL) {
-                qla_printk(KERN_WARNING, ha, "could not allocate memory"
-                        "for request que\n");
+                ql_log(ql_log_fatal, base_vha, 0x00d9,
+                    "Failed to allocate memory for request queue.\n");
                 goto failed;
         }
 
@@ -614,8 +636,8 @@ qla25xx_create_req_que(struct qla_hw_data *ha, uint16_t options,
                         (req->length + 1) * sizeof(request_t),
                         &req->dma, GFP_KERNEL);
         if (req->ring == NULL) {
-                qla_printk(KERN_WARNING, ha,
-                "Memory Allocation failed - request_ring\n");
+                ql_log(ql_log_fatal, base_vha, 0x00da,
+                    "Failed to allocte memory for request_ring.\n");
                 goto que_failed;
         }
 
@@ -623,8 +645,8 @@ qla25xx_create_req_que(struct qla_hw_data *ha, uint16_t options,
         que_id = find_first_zero_bit(ha->req_qid_map, ha->max_req_queues);
         if (que_id >= ha->max_req_queues) {
                 mutex_unlock(&ha->vport_lock);
-                qla_printk(KERN_INFO, ha, "No resources to create "
-                         "additional request queue\n");
+                ql_log(ql_log_warn, base_vha, 0x00db,
+                    "No resources to create additional request queue.\n");
                 goto que_failed;
         }
         set_bit(que_id, ha->req_qid_map);
@@ -633,6 +655,12 @@ qla25xx_create_req_que(struct qla_hw_data *ha, uint16_t options,
         req->vp_idx = vp_idx;
         req->qos = qos;
 
+        ql_dbg(ql_dbg_multiq, base_vha, 0xc002,
+            "queue_id=%d rid=%d vp_idx=%d qos=%d.\n",
+            que_id, req->rid, req->vp_idx, req->qos);
+        ql_dbg(ql_dbg_init, base_vha, 0x00dc,
+            "queue_id=%d rid=%d vp_idx=%d qos=%d.\n",
+            que_id, req->rid, req->vp_idx, req->qos);
         if (rsp_que < 0)
                 req->rsp = NULL;
         else
@@ -645,6 +673,10 @@ qla25xx_create_req_que(struct qla_hw_data *ha, uint16_t options,
                 options |= BIT_5;
         req->options = options;
 
+        ql_dbg(ql_dbg_multiq, base_vha, 0xc003,
+            "options=0x%x.\n", req->options);
+        ql_dbg(ql_dbg_init, base_vha, 0x00dd,
+            "options=0x%x.\n", req->options);
         for (cnt = 1; cnt < MAX_OUTSTANDING_COMMANDS; cnt++)
                 req->outstanding_cmds[cnt] = NULL;
         req->current_outstanding_cmd = 1;
@@ -656,10 +688,21 @@ qla25xx_create_req_que(struct qla_hw_data *ha, uint16_t options,
         reg = ISP_QUE_REG(ha, que_id);
         req->max_q_depth = ha->req_q_map[0]->max_q_depth;
         mutex_unlock(&ha->vport_lock);
+        ql_dbg(ql_dbg_multiq, base_vha, 0xc004,
+            "ring_ptr=%p ring_index=%d, "
+            "cnt=%d id=%d max_q_depth=%d.\n",
+            req->ring_ptr, req->ring_index,
+            req->cnt, req->id, req->max_q_depth);
+        ql_dbg(ql_dbg_init, base_vha, 0x00de,
+            "ring_ptr=%p ring_index=%d, "
+            "cnt=%d id=%d max_q_depth=%d.\n",
+            req->ring_ptr, req->ring_index, req->cnt,
+            req->id, req->max_q_depth);
 
         ret = qla25xx_init_req_que(base_vha, req);
         if (ret != QLA_SUCCESS) {
-                qla_printk(KERN_WARNING, ha, "%s failed\n", __func__);
+                ql_log(ql_log_fatal, base_vha, 0x00df,
+                    "%s failed.\n", __func__);
                 mutex_lock(&ha->vport_lock);
                 clear_bit(que_id, ha->req_qid_map);
                 mutex_unlock(&ha->vport_lock);
@@ -700,8 +743,8 @@ qla25xx_create_rsp_que(struct qla_hw_data *ha, uint16_t options,
 
         rsp = kzalloc(sizeof(struct rsp_que), GFP_KERNEL);
         if (rsp == NULL) {
-                qla_printk(KERN_WARNING, ha, "could not allocate memory for"
-                                " response que\n");
+                ql_log(ql_log_warn, base_vha, 0x0066,
+                    "Failed to allocate memory for response queue.\n");
                 goto failed;
         }
 
@@ -710,8 +753,8 @@ qla25xx_create_rsp_que(struct qla_hw_data *ha, uint16_t options,
                         (rsp->length + 1) * sizeof(response_t),
                         &rsp->dma, GFP_KERNEL);
         if (rsp->ring == NULL) {
-                qla_printk(KERN_WARNING, ha,
-                "Memory Allocation failed - response_ring\n");
+                ql_log(ql_log_warn, base_vha, 0x00e1,
+                    "Failed to allocate memory for response ring.\n");
                 goto que_failed;
         }
 
@@ -719,8 +762,8 @@ qla25xx_create_rsp_que(struct qla_hw_data *ha, uint16_t options,
         que_id = find_first_zero_bit(ha->rsp_qid_map, ha->max_rsp_queues);
         if (que_id >= ha->max_rsp_queues) {
                 mutex_unlock(&ha->vport_lock);
-                qla_printk(KERN_INFO, ha, "No resources to create "
-                         "additional response queue\n");
+                ql_log(ql_log_warn, base_vha, 0x00e2,
+                    "No resources to create additional request queue.\n");
                 goto que_failed;
         }
         set_bit(que_id, ha->rsp_qid_map);
@@ -728,12 +771,16 @@ qla25xx_create_rsp_que(struct qla_hw_data *ha, uint16_t options,
         if (ha->flags.msix_enabled)
                 rsp->msix = &ha->msix_entries[que_id + 1];
         else
-                qla_printk(KERN_WARNING, ha, "msix not enabled\n");
+                ql_log(ql_log_warn, base_vha, 0x00e3,
+                    "MSIX not enalbled.\n");
 
         ha->rsp_q_map[que_id] = rsp;
         rsp->rid = rid;
         rsp->vp_idx = vp_idx;
         rsp->hw = ha;
+        ql_dbg(ql_dbg_init, base_vha, 0x00e4,
+            "queue_id=%d rid=%d vp_idx=%d hw=%p.\n",
+            que_id, rsp->rid, rsp->vp_idx, rsp->hw);
         /* Use alternate PCI bus number */
         if (MSB(rsp->rid))
                 options |= BIT_4;
@@ -750,6 +797,14 @@ qla25xx_create_rsp_que(struct qla_hw_data *ha, uint16_t options,
         rsp->rsp_q_in = &reg->isp25mq.rsp_q_in;
         rsp->rsp_q_out = &reg->isp25mq.rsp_q_out;
         mutex_unlock(&ha->vport_lock);
+        ql_dbg(ql_dbg_multiq, base_vha, 0xc00b,
+            "options=%x id=%d rsp_q_in=%p rsp_q_out=%p",
+            rsp->options, rsp->id, rsp->rsp_q_in,
+            rsp->rsp_q_out);
+        ql_dbg(ql_dbg_init, base_vha, 0x00e5,
+            "options=%x id=%d rsp_q_in=%p rsp_q_out=%p",
+            rsp->options, rsp->id, rsp->rsp_q_in,
+            rsp->rsp_q_out);
 
         ret = qla25xx_request_irq(rsp);
         if (ret)
@@ -757,7 +812,8 @@ qla25xx_create_rsp_que(struct qla_hw_data *ha, uint16_t options,
 
         ret = qla25xx_init_rsp_que(base_vha, rsp);
         if (ret != QLA_SUCCESS) {
-                qla_printk(KERN_WARNING, ha, "%s failed\n", __func__);
+                ql_log(ql_log_fatal, base_vha, 0x00e7,
+                    "%s failed.\n", __func__);
                 mutex_lock(&ha->vport_lock);
                 clear_bit(que_id, ha->rsp_qid_map);
                 mutex_unlock(&ha->vport_lock);
diff --git a/drivers/scsi/qla2xxx/qla_nx.c b/drivers/scsi/qla2xxx/qla_nx.c
index e1138bcc834c..5cbf33a50b14 100644
--- a/drivers/scsi/qla2xxx/qla_nx.c
+++ b/drivers/scsi/qla2xxx/qla_nx.c
@@ -348,6 +348,7 @@ static void
 qla82xx_pci_set_crbwindow_2M(struct qla_hw_data *ha, ulong *off)
 {
         u32 win_read;
+        scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
 
         ha->crb_win = CRB_HI(*off);
         writel(ha->crb_win,
@@ -358,9 +359,10 @@ qla82xx_pci_set_crbwindow_2M(struct qla_hw_data *ha, ulong *off)
          */
         win_read = RD_REG_DWORD((void *)(CRB_WINDOW_2M + ha->nx_pcibase));
         if (win_read != ha->crb_win) {
-                DEBUG2(qla_printk(KERN_INFO, ha,
-                    "%s: Written crbwin (0x%x) != Read crbwin (0x%x), "
-                    "off=0x%lx\n", __func__, ha->crb_win, win_read, *off));
+                ql_dbg(ql_dbg_p3p, vha, 0xb000,
+                    "%s: Written crbwin (0x%x) "
+                    "!= Read crbwin (0x%x), off=0x%lx.\n",
+                    ha->crb_win, win_read, *off);
         }
         *off = (*off & MASK(16)) + CRB_INDIRECT_2M + ha->nx_pcibase;
 }
@@ -368,6 +370,7 @@ qla82xx_pci_set_crbwindow_2M(struct qla_hw_data *ha, ulong *off)
 static inline unsigned long
 qla82xx_pci_set_crbwindow(struct qla_hw_data *ha, u64 off)
 {
+        scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
         /* See if we are currently pointing to the region we want to use next */
         if ((off >= QLA82XX_CRB_PCIX_HOST) && (off < QLA82XX_CRB_DDR_NET)) {
                 /* No need to change window. PCIX and PCIEregs are in both
@@ -398,9 +401,10 @@ qla82xx_pci_set_crbwindow(struct qla_hw_data *ha, u64 off)
                         return off;
         }
         /* strange address given */
-        qla_printk(KERN_WARNING, ha,
-                "%s: Warning: unm_nic_pci_set_crbwindow called with"
-                " an unknown address(%llx)\n", QLA2XXX_DRIVER_NAME, off);
+        ql_dbg(ql_dbg_p3p, vha, 0xb001,
+            "%x: Warning: unm_nic_pci_set_crbwindow "
+            "called with an unknown address(%llx).\n",
+            QLA2XXX_DRIVER_NAME, off);
         return off;
 }
 
@@ -563,6 +567,7 @@ qla82xx_pci_set_window(struct qla_hw_data *ha, unsigned long long addr)
 {
         int window;
         u32 win_read;
+        scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
 
         if (QLA82XX_ADDR_IN_RANGE(addr, QLA82XX_ADDR_DDR_NET,
                 QLA82XX_ADDR_DDR_NET_MAX)) {
@@ -574,8 +579,8 @@ qla82xx_pci_set_window(struct qla_hw_data *ha, unsigned long long addr)
                 win_read = qla82xx_rd_32(ha,
                         ha->mn_win_crb | QLA82XX_PCI_CRBSPACE);
                 if ((win_read << 17) != window) {
-                        qla_printk(KERN_WARNING, ha,
-                            "%s: Written MNwin (0x%x) != Read MNwin (0x%x)\n",
+                        ql_dbg(ql_dbg_p3p, vha, 0xb003,
+                            "%s: Written MNwin (0x%x) != Read MNwin (0x%x).\n",
                             __func__, window, win_read);
                 }
                 addr = GET_MEM_OFFS_2M(addr) + QLA82XX_PCI_DDR_NET;
@@ -583,7 +588,7 @@ qla82xx_pci_set_window(struct qla_hw_data *ha, unsigned long long addr)
                 QLA82XX_ADDR_OCM0_MAX)) {
                 unsigned int temp1;
                 if ((addr & 0x00ff800) == 0xff800) {
-                        qla_printk(KERN_WARNING, ha,
+                        ql_log(ql_log_warn, vha, 0xb004,
                             "%s: QM access not handled.\n", __func__);
                         addr = -1UL;
                 }
@@ -596,8 +601,8 @@ qla82xx_pci_set_window(struct qla_hw_data *ha, unsigned long long addr)
                 temp1 = ((window & 0x1FF) << 7) |
                     ((window & 0x0FFFE0000) >> 17);
                 if (win_read != temp1) {
-                        qla_printk(KERN_WARNING, ha,
-                            "%s: Written OCMwin (0x%x) != Read OCMwin (0x%x)\n",
+                        ql_log(ql_log_warn, vha, 0xb005,
+                            "%s: Written OCMwin (0x%x) != Read OCMwin (0x%x).\n",
                             __func__, temp1, win_read);
                 }
                 addr = GET_MEM_OFFS_2M(addr) + QLA82XX_PCI_OCM0_2M;
@@ -612,8 +617,8 @@ qla82xx_pci_set_window(struct qla_hw_data *ha, unsigned long long addr)
                 win_read = qla82xx_rd_32(ha,
                         ha->ms_win_crb | QLA82XX_PCI_CRBSPACE);
                 if (win_read != window) {
-                        qla_printk(KERN_WARNING, ha,
-                            "%s: Written MSwin (0x%x) != Read MSwin (0x%x)\n",
+                        ql_log(ql_log_warn, vha, 0xb006,
+                            "%s: Written MSwin (0x%x) != Read MSwin (0x%x).\n",
                             __func__, window, win_read);
                 }
                 addr = GET_MEM_OFFS_2M(addr) + QLA82XX_PCI_QDR_NET;
@@ -624,9 +629,9 @@ qla82xx_pci_set_window(struct qla_hw_data *ha, unsigned long long addr)
                  */
                 if ((qla82xx_pci_set_window_warning_count++ < 8) ||
                     (qla82xx_pci_set_window_warning_count%64 == 0)) {
-                        qla_printk(KERN_WARNING, ha,
-                            "%s: Warning:%s Unknown address range!\n", __func__,
-                            QLA2XXX_DRIVER_NAME);
+                        ql_log(ql_log_warn, vha, 0xb007,
+                            "%s: Warning:%s Unknown address range!.\n",
+                            __func__, QLA2XXX_DRIVER_NAME);
                 }
                 addr = -1UL;
         }
@@ -671,6 +676,7 @@ static int qla82xx_pci_mem_read_direct(struct qla_hw_data *ha,
         uint8_t         *mem_ptr = NULL;
         unsigned long   mem_base;
         unsigned long   mem_page;
+        scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
 
         write_lock_irqsave(&ha->hw_lock, flags);
 
@@ -682,9 +688,10 @@ static int qla82xx_pci_mem_read_direct(struct qla_hw_data *ha,
         if ((start == -1UL) ||
                 (qla82xx_pci_is_same_window(ha, off + size - 1) == 0)) {
                 write_unlock_irqrestore(&ha->hw_lock, flags);
-                qla_printk(KERN_ERR, ha,
-                        "%s out of bound pci memory access. "
-                        "offset is 0x%llx\n", QLA2XXX_DRIVER_NAME, off);
+                ql_log(ql_log_fatal, vha, 0xb008,
+                    "%s out of bound pci memory "
+                    "access, offset is 0x%llx.\n",
+                    QLA2XXX_DRIVER_NAME, off);
                 return -1;
         }
 
@@ -741,6 +748,7 @@ qla82xx_pci_mem_write_direct(struct qla_hw_data *ha,
         uint8_t         *mem_ptr = NULL;
         unsigned long   mem_base;
         unsigned long   mem_page;
+        scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
 
         write_lock_irqsave(&ha->hw_lock, flags);
 
@@ -752,9 +760,10 @@ qla82xx_pci_mem_write_direct(struct qla_hw_data *ha,
         if ((start == -1UL) ||
                 (qla82xx_pci_is_same_window(ha, off + size - 1) == 0)) {
                 write_unlock_irqrestore(&ha->hw_lock, flags);
-                qla_printk(KERN_ERR, ha,
-                        "%s out of bound pci memory access. "
-                        "offset is 0x%llx\n", QLA2XXX_DRIVER_NAME, off);
+                ql_log(ql_log_fatal, vha, 0xb009,
+                    "%s out of bount memory "
+                    "access, offset is 0x%llx.\n",
+                    QLA2XXX_DRIVER_NAME, off);
                 return -1;
         }
 
@@ -855,15 +864,16 @@ qla82xx_wait_rom_busy(struct qla_hw_data *ha)
 {
         long timeout = 0;
         long done = 0 ;
+        scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
 
         while (done == 0) {
                 done = qla82xx_rd_32(ha, QLA82XX_ROMUSB_GLB_STATUS);
                 done &= 4;
                 timeout++;
                 if (timeout >= rom_max_timeout) {
-                        DEBUG(qla_printk(KERN_INFO, ha,
-                                "%s: Timeout reached waiting for rom busy",
-                                QLA2XXX_DRIVER_NAME));
+                        ql_dbg(ql_dbg_p3p, vha, 0xb00a,
+                            "%s: Timeout reached waiting for rom busy.\n",
+                            QLA2XXX_DRIVER_NAME);
                         return -1;
                 }
         }
@@ -875,15 +885,16 @@ qla82xx_wait_rom_done(struct qla_hw_data *ha)
 {
         long timeout = 0;
         long done = 0 ;
+        scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
 
         while (done == 0) {
                 done = qla82xx_rd_32(ha, QLA82XX_ROMUSB_GLB_STATUS);
                 done &= 2;
                 timeout++;
                 if (timeout >= rom_max_timeout) {
-                        DEBUG(qla_printk(KERN_INFO, ha,
-                                "%s: Timeout reached  waiting for rom done",
-                                QLA2XXX_DRIVER_NAME));
+                        ql_dbg(ql_dbg_p3p, vha, 0xb00b,
+                            "%s: Timeout reached waiting for rom done.\n",
+                            QLA2XXX_DRIVER_NAME);
                         return -1;
                 }
         }
@@ -893,15 +904,16 @@ qla82xx_wait_rom_done(struct qla_hw_data *ha)
 static int
 qla82xx_do_rom_fast_read(struct qla_hw_data *ha, int addr, int *valp)
 {
+        scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
+
         qla82xx_wr_32(ha, QLA82XX_ROMUSB_ROM_ADDRESS, addr);
         qla82xx_wr_32(ha, QLA82XX_ROMUSB_ROM_DUMMY_BYTE_CNT, 0);
         qla82xx_wr_32(ha, QLA82XX_ROMUSB_ROM_ABYTE_CNT, 3);
         qla82xx_wr_32(ha, QLA82XX_ROMUSB_ROM_INSTR_OPCODE, 0xb);
         qla82xx_wait_rom_busy(ha);
         if (qla82xx_wait_rom_done(ha)) {
-                qla_printk(KERN_WARNING, ha,
-                        "%s: Error waiting for rom done\n",
-                        QLA2XXX_DRIVER_NAME);
+                ql_log(ql_log_fatal, vha, 0x00ba,
+                    "Error waiting for rom done.\n");
                 return -1;
         }
         /* Reset abyte_cnt and dummy_byte_cnt */
@@ -917,6 +929,7 @@ static int
 qla82xx_rom_fast_read(struct qla_hw_data *ha, int addr, int *valp)
 {
         int ret, loops = 0;
+        scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
 
         while ((qla82xx_rom_lock(ha) != 0) && (loops < 50000)) {
                 udelay(100);
@@ -924,9 +937,8 @@ qla82xx_rom_fast_read(struct qla_hw_data *ha, int addr, int *valp)
                 loops++;
         }
         if (loops >= 50000) {
-                qla_printk(KERN_INFO, ha,
-                        "%s: qla82xx_rom_lock failed\n",
-                        QLA2XXX_DRIVER_NAME);
+                ql_log(ql_log_fatal, vha, 0x00b9,
+                    "Failed to aquire SEM2 lock.\n");
                 return -1;
         }
         ret = qla82xx_do_rom_fast_read(ha, addr, valp);
@@ -937,11 +949,12 @@ qla82xx_rom_fast_read(struct qla_hw_data *ha, int addr, int *valp)
 static int
 qla82xx_read_status_reg(struct qla_hw_data *ha, uint32_t *val)
 {
+        scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
         qla82xx_wr_32(ha, QLA82XX_ROMUSB_ROM_INSTR_OPCODE, M25P_INSTR_RDSR);
         qla82xx_wait_rom_busy(ha);
         if (qla82xx_wait_rom_done(ha)) {
-                qla_printk(KERN_WARNING, ha,
-                    "Error waiting for rom done\n");
+                ql_log(ql_log_warn, vha, 0xb00c,
+                    "Error waiting for rom done.\n");
                 return -1;
         }
         *val = qla82xx_rd_32(ha, QLA82XX_ROMUSB_ROM_RDATA);
@@ -955,6 +968,7 @@ qla82xx_flash_wait_write_finish(struct qla_hw_data *ha)
         uint32_t done = 1 ;
         uint32_t val;
         int ret = 0;
+        scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
 
         qla82xx_wr_32(ha, QLA82XX_ROMUSB_ROM_ABYTE_CNT, 0);
         while ((done != 0) && (ret == 0)) {
@@ -964,8 +978,8 @@ qla82xx_flash_wait_write_finish(struct qla_hw_data *ha)
                 udelay(10);
                 cond_resched();
                 if (timeout >= 50000) {
-                        qla_printk(KERN_WARNING, ha,
-                            "Timeout reached  waiting for write finish");
+                        ql_log(ql_log_warn, vha, 0xb00d,
+                            "Timeout reached waiting for write finish.\n");
                         return -1;
                 }
         }
@@ -992,13 +1006,14 @@ qla82xx_flash_set_write_enable(struct qla_hw_data *ha)
 static int
 qla82xx_write_status_reg(struct qla_hw_data *ha, uint32_t val)
 {
+        scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
         if (qla82xx_flash_set_write_enable(ha))
                 return -1;
         qla82xx_wr_32(ha, QLA82XX_ROMUSB_ROM_WDATA, val);
         qla82xx_wr_32(ha, QLA82XX_ROMUSB_ROM_INSTR_OPCODE, 0x1);
         if (qla82xx_wait_rom_done(ha)) {
-                qla_printk(KERN_WARNING, ha,
-                    "Error waiting for rom done\n");
+                ql_log(ql_log_warn, vha, 0xb00e,
+                    "Error waiting for rom done.\n");
                 return -1;
         }
         return qla82xx_flash_wait_write_finish(ha);
@@ -1007,10 +1022,11 @@ qla82xx_write_status_reg(struct qla_hw_data *ha, uint32_t val)
 static int
 qla82xx_write_disable_flash(struct qla_hw_data *ha)
 {
+        scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
         qla82xx_wr_32(ha, QLA82XX_ROMUSB_ROM_INSTR_OPCODE, M25P_INSTR_WRDI);
         if (qla82xx_wait_rom_done(ha)) {
-                qla_printk(KERN_WARNING, ha,
-                    "Error waiting for rom done\n");
+                ql_log(ql_log_warn, vha, 0xb00f,
+                    "Error waiting for rom done.\n");
                 return -1;
         }
         return 0;
@@ -1020,13 +1036,16 @@ static int
 ql82xx_rom_lock_d(struct qla_hw_data *ha)
 {
         int loops = 0;
+        scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
+
         while ((qla82xx_rom_lock(ha) != 0) && (loops < 50000)) {
                 udelay(100);
                 cond_resched();
                 loops++;
         }
         if (loops >= 50000) {
-                qla_printk(KERN_WARNING, ha, "ROM lock failed\n");
+                ql_log(ql_log_warn, vha, 0xb010,
+                    "ROM lock failed.\n");
                 return -1;
         }
         return 0;;
@@ -1037,10 +1056,12 @@ qla82xx_write_flash_dword(struct qla_hw_data *ha, uint32_t flashaddr,
         uint32_t data)
 {
         int ret = 0;
+        scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
 
         ret = ql82xx_rom_lock_d(ha);
         if (ret < 0) {
-                qla_printk(KERN_WARNING, ha, "ROM Lock failed\n");
+                ql_log(ql_log_warn, vha, 0xb011,
+                    "ROM lock failed.\n");
                 return ret;
         }
 
@@ -1053,8 +1074,8 @@ qla82xx_write_flash_dword(struct qla_hw_data *ha, uint32_t flashaddr,
         qla82xx_wr_32(ha, QLA82XX_ROMUSB_ROM_INSTR_OPCODE, M25P_INSTR_PP);
         qla82xx_wait_rom_busy(ha);
         if (qla82xx_wait_rom_done(ha)) {
-                qla_printk(KERN_WARNING, ha,
-                        "Error waiting for rom done\n");
+                ql_log(ql_log_warn, vha, 0xb012,
+                    "Error waiting for rom done.\n");
                 ret = -1;
                 goto done_write;
         }
@@ -1159,8 +1180,8 @@ qla82xx_pinit_from_rom(scsi_qla_host_t *vha)
          */
         if (qla82xx_rom_fast_read(ha, 0, &n) != 0 || n != 0xcafecafeUL ||
             qla82xx_rom_fast_read(ha, 4, &n) != 0) {
-                qla_printk(KERN_WARNING, ha,
-                    "[ERROR] Reading crb_init area: n: %08x\n", n);
+                ql_log(ql_log_fatal, vha, 0x006e,
+                    "Error Reading crb_init area: n: %08x.\n", n);
                 return -1;
         }
 
@@ -1172,20 +1193,18 @@ qla82xx_pinit_from_rom(scsi_qla_host_t *vha)
 
         /* number of addr/value pair should not exceed 1024 enteries */
         if (n  >= 1024) {
-                qla_printk(KERN_WARNING, ha,
-                    "%s: %s:n=0x%x [ERROR] Card flash not initialized.\n",
-                    QLA2XXX_DRIVER_NAME, __func__, n);
+                ql_log(ql_log_fatal, vha, 0x0071,
+                    "Card flash not initialized:n=0x%x.\n", n);
                 return -1;
         }
 
-        qla_printk(KERN_INFO, ha,
-            "%s: %d CRB init values found in ROM.\n", QLA2XXX_DRIVER_NAME, n);
+        ql_log(ql_log_info, vha, 0x0072,
+            "%d CRB init values found in ROM.\n", n);
 
         buf = kmalloc(n * sizeof(struct crb_addr_pair), GFP_KERNEL);
         if (buf == NULL) {
-                qla_printk(KERN_WARNING, ha,
-                    "%s: [ERROR] Unable to malloc memory.\n",
-                    QLA2XXX_DRIVER_NAME);
+                ql_log(ql_log_fatal, vha, 0x010c,
+                    "Unable to allocate memory.\n");
                 return -1;
         }
 
@@ -1236,9 +1255,8 @@ qla82xx_pinit_from_rom(scsi_qla_host_t *vha)
                         continue;
 
                 if (off == ADDR_ERROR) {
-                        qla_printk(KERN_WARNING, ha,
-                            "%s: [ERROR] Unknown addr: 0x%08lx\n",
-                            QLA2XXX_DRIVER_NAME, buf[i].addr);
+                        ql_log(ql_log_fatal, vha, 0x0116,
+                            "Unknow addr: 0x%08lx.\n", buf[i].addr);
                         continue;
                 }
 
@@ -1370,7 +1388,7 @@ qla82xx_pci_mem_write_2M(struct qla_hw_data *ha,
                 if (j >= MAX_CTL_CHECK) {
                         if (printk_ratelimit())
                                 dev_err(&ha->pdev->dev,
-                                    "failed to write through agent\n");
+                                    "failed to write through agent.\n");
                         ret = -1;
                         break;
                 }
@@ -1460,7 +1478,7 @@ qla82xx_pci_mem_read_2M(struct qla_hw_data *ha,
                 if (j >= MAX_CTL_CHECK) {
                         if (printk_ratelimit())
                                 dev_err(&ha->pdev->dev,
-                                    "failed to read through agent\n");
+                                    "failed to read through agent.\n");
                         break;
                 }
 
@@ -1633,17 +1651,15 @@ qla82xx_iospace_config(struct qla_hw_data *ha)
         uint32_t len = 0;
 
         if (pci_request_regions(ha->pdev, QLA2XXX_DRIVER_NAME)) {
-                qla_printk(KERN_WARNING, ha,
-                        "Failed to reserve selected regions (%s)\n",
-                        pci_name(ha->pdev));
+                ql_log_pci(ql_log_fatal, ha->pdev, 0x000c,
+                    "Failed to reserver selected regions.\n");
                 goto iospace_error_exit;
         }
 
         /* Use MMIO operations for all accesses. */
         if (!(pci_resource_flags(ha->pdev, 0) & IORESOURCE_MEM)) {
-                qla_printk(KERN_ERR, ha,
-                        "region #0 not an MMIO resource (%s), aborting\n",
-                        pci_name(ha->pdev));
+                ql_log_pci(ql_log_fatal, ha->pdev, 0x000d,
+                    "Region #0 not an MMIO resource, aborting.\n");
                 goto iospace_error_exit;
         }
 
@@ -1651,9 +1667,8 @@ qla82xx_iospace_config(struct qla_hw_data *ha)
         ha->nx_pcibase =
             (unsigned long)ioremap(pci_resource_start(ha->pdev, 0), len);
         if (!ha->nx_pcibase) {
-                qla_printk(KERN_ERR, ha,
-                    "cannot remap pcibase MMIO (%s), aborting\n",
-                    pci_name(ha->pdev));
+                ql_log_pci(ql_log_fatal, ha->pdev, 0x000e,
+                    "Cannot remap pcibase MMIO, aborting.\n");
                 pci_release_regions(ha->pdev);
                 goto iospace_error_exit;
         }
@@ -1667,9 +1682,8 @@ qla82xx_iospace_config(struct qla_hw_data *ha)
                     (unsigned long)ioremap((pci_resource_start(ha->pdev, 4) +
                     (ha->pdev->devfn << 12)), 4);
                 if (!ha->nxdb_wr_ptr) {
-                        qla_printk(KERN_ERR, ha,
-                            "cannot remap MMIO (%s), aborting\n",
-                            pci_name(ha->pdev));
+                        ql_log_pci(ql_log_fatal, ha->pdev, 0x000f,
+                            "Cannot remap MMIO, aborting.\n");
                         pci_release_regions(ha->pdev);
                         goto iospace_error_exit;
                 }
@@ -1687,6 +1701,16 @@ qla82xx_iospace_config(struct qla_hw_data *ha)
 
         ha->max_req_queues = ha->max_rsp_queues = 1;
         ha->msix_count = ha->max_rsp_queues + 1;
+        ql_dbg_pci(ql_dbg_multiq, ha->pdev, 0xc006,
+            "nx_pci_base=%p iobase=%p "
+            "max_req_queues=%d msix_count=%d.\n",
+            ha->nx_pcibase, ha->iobase,
+            ha->max_req_queues, ha->msix_count);
+        ql_dbg_pci(ql_dbg_init, ha->pdev, 0x0010,
+            "nx_pci_base=%p iobase=%p "
+            "max_req_queues=%d msix_count=%d.\n",
+            ha->nx_pcibase, ha->iobase,
+            ha->max_req_queues, ha->msix_count);
         return 0;
 
 iospace_error_exit:
@@ -1712,6 +1736,9 @@ qla82xx_pci_config(scsi_qla_host_t *vha)
         pci_set_master(ha->pdev);
         ret = pci_set_mwi(ha->pdev);
         ha->chip_revision = ha->pdev->revision;
+        ql_dbg(ql_dbg_init, vha, 0x0043,
+            "Chip revision:%ld.\n",
+            ha->chip_revision);
         return 0;
 }
 
@@ -1877,6 +1904,7 @@ qla82xx_check_cmdpeg_state(struct qla_hw_data *ha)
 {
         u32 val = 0;
         int retries = 60;
+        scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
 
         do {
                 read_lock(&ha->hw_lock);
@@ -1892,15 +1920,15 @@ qla82xx_check_cmdpeg_state(struct qla_hw_data *ha)
                 default:
                         break;
                 }
-                qla_printk(KERN_WARNING, ha,
-                        "CRB_CMDPEG_STATE: 0x%x and retries: 0x%x\n",
-                        val, retries);
+                ql_log(ql_log_info, vha, 0x00a8,
+                    "CRB_CMDPEG_STATE: 0x%x and retries:0x%x.\n",
+                    val, retries);
 
                 msleep(500);
 
         } while (--retries);
 
-        qla_printk(KERN_INFO, ha,
+        ql_log(ql_log_fatal, vha, 0x00a9,
             "Cmd Peg initialization failed: 0x%x.\n", val);
 
         val = qla82xx_rd_32(ha, QLA82XX_ROMUSB_GLB_PEGTUNE_DONE);
@@ -1915,6 +1943,7 @@ qla82xx_check_rcvpeg_state(struct qla_hw_data *ha)
 {
         u32 val = 0;
         int retries = 60;
+        scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
 
         do {
                 read_lock(&ha->hw_lock);
@@ -1930,17 +1959,16 @@ qla82xx_check_rcvpeg_state(struct qla_hw_data *ha)
                 default:
                         break;
                 }
-
-                qla_printk(KERN_WARNING, ha,
-                        "CRB_RCVPEG_STATE: 0x%x and retries: 0x%x\n",
-                        val, retries);
+                ql_log(ql_log_info, vha, 0x00ab,
+                    "CRB_RCVPEG_STATE: 0x%x and retries: 0x%x.\n",
+                    val, retries);
 
                 msleep(500);
 
         } while (--retries);
 
-        qla_printk(KERN_INFO, ha,
-                "Rcv Peg initialization failed: 0x%x.\n", val);
+        ql_log(ql_log_fatal, vha, 0x00ac,
+            "Rcv Peg initializatin failed: 0x%x.\n", val);
         read_lock(&ha->hw_lock);
         qla82xx_wr_32(ha, CRB_RCVPEG_STATE, PHAN_INITIALIZE_FAILED);
         read_unlock(&ha->hw_lock);
@@ -1989,13 +2017,11 @@ qla82xx_mbx_completion(scsi_qla_host_t *vha, uint16_t mb0)
         }
 
         if (ha->mcp) {
-                DEBUG3_11(printk(KERN_INFO "%s(%ld): "
-                        "Got mailbox completion. cmd=%x.\n",
-                        __func__, vha->host_no, ha->mcp->mb[0]));
+                ql_dbg(ql_dbg_async, vha, 0x5052,
+                    "Got mailbox completion. cmd=%x.\n", ha->mcp->mb[0]);
         } else {
-                qla_printk(KERN_INFO, ha,
-                        "%s(%ld): MBX pointer ERROR!\n",
-                        __func__, vha->host_no);
+                ql_dbg(ql_dbg_async, vha, 0x5053,
+                    "MBX pointer ERROR.\n");
         }
 }
 
@@ -2019,13 +2045,13 @@ qla82xx_intr_handler(int irq, void *dev_id)
         int status = 0, status1 = 0;
         unsigned long   flags;
         unsigned long   iter;
-        uint32_t        stat;
+        uint32_t        stat = 0;
         uint16_t        mb[4];
 
         rsp = (struct rsp_que *) dev_id;
         if (!rsp) {
                 printk(KERN_INFO
-                        "%s(): NULL response queue pointer\n", __func__);
+                        "%s(): NULL response queue pointer.\n", __func__);
                 return IRQ_NONE;
         }
         ha = rsp->hw;
@@ -2075,9 +2101,9 @@ qla82xx_intr_handler(int irq, void *dev_id)
                                 qla24xx_process_response_queue(vha, rsp);
                                 break;
                         default:
-                                DEBUG2(printk("scsi(%ld): "
-                                        " Unrecognized interrupt type (%d).\n",
-                                        vha->host_no, stat & 0xff));
+                                ql_dbg(ql_dbg_async, vha, 0x5054,
+                                    "Unrecognized interrupt type (%d).\n",
+                                    stat & 0xff);
                                 break;
                         }
                 }
@@ -2089,8 +2115,8 @@ qla82xx_intr_handler(int irq, void *dev_id)
 
 #ifdef QL_DEBUG_LEVEL_17
         if (!irq && ha->flags.eeh_busy)
-                qla_printk(KERN_WARNING, ha,
-                    "isr: status %x, cmd_flags %lx, mbox_int %x, stat %x\n",
+                ql_log(ql_log_warn, vha, 0x503d,
+                    "isr:status %x, cmd_flags %lx, mbox_int %x, stat %x.\n",
                     status, ha->mbx_cmd_flags, ha->flags.mbox_int, stat);
 #endif
 
@@ -2111,13 +2137,13 @@ qla82xx_msix_default(int irq, void *dev_id)
         struct device_reg_82xx __iomem *reg;
         int status = 0;
         unsigned long flags;
-        uint32_t stat;
+        uint32_t stat = 0;
         uint16_t mb[4];
 
         rsp = (struct rsp_que *) dev_id;
         if (!rsp) {
                 printk(KERN_INFO
-                        "%s(): NULL response queue pointer\n", __func__);
+                        "%s(): NULL response queue pointer.\n", __func__);
                 return IRQ_NONE;
         }
         ha = rsp->hw;
@@ -2149,9 +2175,9 @@ qla82xx_msix_default(int irq, void *dev_id)
                                 qla24xx_process_response_queue(vha, rsp);
                                 break;
                         default:
-                                DEBUG2(printk("scsi(%ld): "
-                                        " Unrecognized interrupt type (%d).\n",
-                                        vha->host_no, stat & 0xff));
+                                ql_dbg(ql_dbg_async, vha, 0x5041,
+                                    "Unrecognized interrupt type (%d).\n",
+                                    stat & 0xff);
                                 break;
                         }
                 }
@@ -2162,9 +2188,9 @@ qla82xx_msix_default(int irq, void *dev_id)
 
 #ifdef QL_DEBUG_LEVEL_17
         if (!irq && ha->flags.eeh_busy)
-                qla_printk(KERN_WARNING, ha,
-                        "isr: status %x, cmd_flags %lx, mbox_int %x, stat %x\n",
-                        status, ha->mbx_cmd_flags, ha->flags.mbox_int, stat);
+                ql_log(ql_log_warn, vha, 0x5044,
+                    "isr:status %x, cmd_flags %lx, mbox_int %x, stat %x.\n",
+                    status, ha->mbx_cmd_flags, ha->flags.mbox_int, stat);
 #endif
 
         if (test_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags) &&
@@ -2186,7 +2212,7 @@ qla82xx_msix_rsp_q(int irq, void *dev_id)
         rsp = (struct rsp_que *) dev_id;
         if (!rsp) {
                 printk(KERN_INFO
-                        "%s(): NULL response queue pointer\n", __func__);
+                        "%s(): NULL response queue pointer.\n", __func__);
                 return IRQ_NONE;
         }
 
@@ -2215,7 +2241,7 @@ qla82xx_poll(int irq, void *dev_id)
         rsp = (struct rsp_que *) dev_id;
         if (!rsp) {
                 printk(KERN_INFO
-                        "%s(): NULL response queue pointer\n", __func__);
+                        "%s(): NULL response queue pointer.\n", __func__);
                 return;
         }
         ha = rsp->hw;
@@ -2245,9 +2271,9 @@ qla82xx_poll(int irq, void *dev_id)
                         qla24xx_process_response_queue(vha, rsp);
                         break;
                 default:
-                        DEBUG2(printk("scsi(%ld): Unrecognized interrupt type "
-                                "(%d).\n",
-                                vha->host_no, stat & 0xff));
+                        ql_dbg(ql_dbg_p3p, vha, 0xb013,
+                            "Unrecognized interrupt type (%d).\n",
+                            stat * 0xff);
                         break;
                 }
         }
@@ -2347,9 +2373,8 @@ qla82xx_set_rst_ready(struct qla_hw_data *ha)
                 drv_state = qla82xx_rd_32(ha, QLA82XX_CRB_DRV_STATE);
         }
         drv_state |= (QLA82XX_DRVST_RST_RDY << (ha->portnum * 4));
-        qla_printk(KERN_INFO, ha,
-                "%s(%ld):drv_state = 0x%x\n",
-                __func__, vha->host_no, drv_state);
+        ql_log(ql_log_info, vha, 0x00bb,
+            "drv_state = 0x%x.\n", drv_state);
         qla82xx_wr_32(ha, QLA82XX_CRB_DRV_STATE, drv_state);
 }
 
@@ -2392,8 +2417,8 @@ qla82xx_load_fw(scsi_qla_host_t *vha)
         struct qla_hw_data *ha = vha->hw;
 
         if (qla82xx_pinit_from_rom(vha) != QLA_SUCCESS) {
-                qla_printk(KERN_ERR, ha,
-                        "%s: Error during CRB Initialization\n", __func__);
+                ql_log(ql_log_fatal, vha, 0x009f,
+                    "Error during CRB initialization.\n");
                 return QLA_FUNCTION_FAILED;
         }
         udelay(500);
@@ -2411,27 +2436,27 @@ qla82xx_load_fw(scsi_qla_host_t *vha)
         if (ql2xfwloadbin == 2)
                 goto try_blob_fw;
 
-        qla_printk(KERN_INFO, ha,
-                "Attempting to load firmware from flash\n");
+        ql_log(ql_log_info, vha, 0x00a0,
+            "Attempting to load firmware from flash.\n");
 
         if (qla82xx_fw_load_from_flash(ha) == QLA_SUCCESS) {
-                qla_printk(KERN_ERR, ha,
-                    "Firmware loaded successfully from flash\n");
+                ql_log(ql_log_info, vha, 0x00a1,
+                    "Firmware loaded successully from flash.\n");
                 return QLA_SUCCESS;
         } else {
-                qla_printk(KERN_ERR, ha,
-                    "Firmware load from flash failed\n");
+                ql_log(ql_log_warn, vha, 0x0108,
+                    "Firmware load from flash failed.\n");
         }
 
 try_blob_fw:
-        qla_printk(KERN_INFO, ha,
-            "Attempting to load firmware from blob\n");
+        ql_log(ql_log_info, vha, 0x00a2,
+            "Attempting to load firmware from blob.\n");
 
         /* Load firmware blob. */
         blob = ha->hablob = qla2x00_request_firmware(vha);
         if (!blob) {
-                qla_printk(KERN_ERR, ha,
-                        "Firmware image not present.\n");
+                ql_log(ql_log_fatal, vha, 0x00a3,
+                    "Firmware image not preset.\n");
                 goto fw_load_failed;
         }
 
@@ -2441,20 +2466,19 @@ try_blob_fw:
                 /* Fallback to URI format */
                 if (qla82xx_validate_firmware_blob(vha,
                         QLA82XX_UNIFIED_ROMIMAGE)) {
-                        qla_printk(KERN_ERR, ha,
-                                "No valid firmware image found!!!");
+                        ql_log(ql_log_fatal, vha, 0x00a4,
+                            "No valid firmware image found.\n");
                         return QLA_FUNCTION_FAILED;
                 }
         }
 
         if (qla82xx_fw_load_from_blob(ha) == QLA_SUCCESS) {
-                qla_printk(KERN_ERR, ha,
-                        "%s: Firmware loaded successfully "
-                        " from binary blob\n", __func__);
+                ql_log(ql_log_info, vha, 0x00a5,
+                    "Firmware loaded successfully from binary blob.\n");
                 return QLA_SUCCESS;
         } else {
-                qla_printk(KERN_ERR, ha,
-                    "Firmware load failed from binary blob\n");
+                ql_log(ql_log_fatal, vha, 0x00a6,
+                    "Firmware load failed for binary blob.\n");
                 blob->fw = NULL;
                 blob = NULL;
                 goto fw_load_failed;
@@ -2486,15 +2510,15 @@ qla82xx_start_firmware(scsi_qla_host_t *vha)
         qla82xx_wr_32(ha, QLA82XX_PEG_HALT_STATUS2, 0);
 
         if (qla82xx_load_fw(vha) != QLA_SUCCESS) {
-                qla_printk(KERN_INFO, ha,
-                        "%s: Error trying to start fw!\n", __func__);
+                ql_log(ql_log_fatal, vha, 0x00a7,
+                    "Error trying to start fw.\n");
                 return QLA_FUNCTION_FAILED;
         }
 
         /* Handshake with the card before we register the devices. */
         if (qla82xx_check_cmdpeg_state(ha) != QLA_SUCCESS) {
-                qla_printk(KERN_INFO, ha,
-                        "%s: Error during card handshake!\n", __func__);
+                ql_log(ql_log_fatal, vha, 0x00aa,
+                    "Error during card handshake.\n");
                 return QLA_FUNCTION_FAILED;
         }
 
@@ -2663,8 +2687,11 @@ qla82xx_start_scsi(srb_t *sp)
         /* Send marker if required */
         if (vha->marker_needed != 0) {
                 if (qla2x00_marker(vha, req,
-                        rsp, 0, 0, MK_SYNC_ALL) != QLA_SUCCESS)
+                        rsp, 0, 0, MK_SYNC_ALL) != QLA_SUCCESS) {
+                        ql_log(ql_log_warn, vha, 0x300c,
+                            "qla2x00_marker failed for cmd=%p.\n", cmd);
                         return QLA_FUNCTION_FAILED;
+                }
                 vha->marker_needed = 0;
         }
 
@@ -2701,8 +2728,13 @@ qla82xx_start_scsi(srb_t *sp)
                 uint16_t i;
 
                 more_dsd_lists = qla82xx_calc_dsd_lists(tot_dsds);
-                if ((more_dsd_lists + ha->gbl_dsd_inuse) >= NUM_DSD_CHAIN)
+                if ((more_dsd_lists + ha->gbl_dsd_inuse) >= NUM_DSD_CHAIN) {
+                        ql_dbg(ql_dbg_io, vha, 0x300d,
+                            "Num of DSD list %d is than %d for cmd=%p.\n",
+                            more_dsd_lists + ha->gbl_dsd_inuse, NUM_DSD_CHAIN,
+                            cmd);
                         goto queuing_error;
+                }
 
                 if (more_dsd_lists <= ha->gbl_dsd_avail)
                         goto sufficient_dsds;
@@ -2711,13 +2743,20 @@ qla82xx_start_scsi(srb_t *sp)
 
                 for (i = 0; i < more_dsd_lists; i++) {
                         dsd_ptr = kzalloc(sizeof(struct dsd_dma), GFP_ATOMIC);
-                        if (!dsd_ptr)
+                        if (!dsd_ptr) {
+                                ql_log(ql_log_fatal, vha, 0x300e,
+                                    "Failed to allocate memory for dsd_dma "
+                                    "for cmd=%p.\n", cmd);
                                 goto queuing_error;
+                        }
 
                         dsd_ptr->dsd_addr = dma_pool_alloc(ha->dl_dma_pool,
                                 GFP_ATOMIC, &dsd_ptr->dsd_list_dma);
                         if (!dsd_ptr->dsd_addr) {
                                 kfree(dsd_ptr);
+                                ql_log(ql_log_fatal, vha, 0x300f,
+                                    "Failed to allocate memory for dsd_addr "
+                                    "for cmd=%p.\n", cmd);
                                 goto queuing_error;
                         }
                         list_add_tail(&dsd_ptr->list, &ha->gbl_dsd_list);
@@ -2742,17 +2781,16 @@ sufficient_dsds:
 
                 ctx = sp->ctx = mempool_alloc(ha->ctx_mempool, GFP_ATOMIC);
                 if (!sp->ctx) {
-                        DEBUG(printk(KERN_INFO
-                                "%s(%ld): failed to allocate"
-                                " ctx.\n", __func__, vha->host_no));
+                        ql_log(ql_log_fatal, vha, 0x3010,
+                            "Failed to allocate ctx for cmd=%p.\n", cmd);
                         goto queuing_error;
                 }
                 memset(ctx, 0, sizeof(struct ct6_dsd));
                 ctx->fcp_cmnd = dma_pool_alloc(ha->fcp_cmnd_dma_pool,
                         GFP_ATOMIC, &ctx->fcp_cmnd_dma);
                 if (!ctx->fcp_cmnd) {
-                        DEBUG2_3(printk("%s(%ld): failed to allocate"
-                                " fcp_cmnd.\n", __func__, vha->host_no));
+                        ql_log(ql_log_fatal, vha, 0x3011,
+                            "Failed to allocate fcp_cmnd for cmd=%p.\n", cmd);
                         goto queuing_error_fcp_cmnd;
                 }
 
@@ -2766,6 +2804,9 @@ sufficient_dsds:
                                 /* SCSI command bigger than 16 bytes must be
                                  * multiple of 4
                                  */
+                                ql_log(ql_log_warn, vha, 0x3012,
+                                    "scsi cmd len %d not multiple of 4 "
+                                    "for cmd=%p.\n", cmd->cmd_len, cmd);
                                 goto queuing_error_fcp_cmnd;
                         }
                         ctx->fcp_cmnd_len = 12 + cmd->cmd_len + 4;
@@ -2845,7 +2886,7 @@ sufficient_dsds:
                 cmd_pkt->entry_status = (uint8_t) rsp->id;
         } else {
                 struct cmd_type_7 *cmd_pkt;
-                req_cnt = qla24xx_calc_iocbs(tot_dsds);
+                req_cnt = qla24xx_calc_iocbs(vha, tot_dsds);
                 if (req->cnt < (req_cnt + 2)) {
                         cnt = (uint16_t)RD_REG_DWORD_RELAXED(
                             &reg->req_q_out[0]);
@@ -2979,8 +3020,8 @@ qla82xx_read_flash_data(scsi_qla_host_t *vha, uint32_t *dwptr, uint32_t faddr,
         /* Dword reads to flash. */
         for (i = 0; i < length/4; i++, faddr += 4) {
                 if (qla82xx_rom_fast_read(ha, faddr, &val)) {
-                        qla_printk(KERN_WARNING, ha,
-                            "Do ROM fast read failed\n");
+                        ql_log(ql_log_warn, vha, 0x0106,
+                            "Do ROM fast read failed.\n");
                         goto done_read;
                 }
                 dwptr[i] = __constant_cpu_to_le32(val);
@@ -2994,10 +3035,12 @@ qla82xx_unprotect_flash(struct qla_hw_data *ha)
 {
         int ret;
         uint32_t val;
+        scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
 
         ret = ql82xx_rom_lock_d(ha);
         if (ret < 0) {
-                qla_printk(KERN_WARNING, ha, "ROM Lock failed\n");
+                ql_log(ql_log_warn, vha, 0xb014,
+                    "ROM Lock failed.\n");
                 return ret;
         }
 
@@ -3013,7 +3056,8 @@ qla82xx_unprotect_flash(struct qla_hw_data *ha)
         }
 
         if (qla82xx_write_disable_flash(ha) != 0)
-                qla_printk(KERN_WARNING, ha, "Write disable failed\n");
+                ql_log(ql_log_warn, vha, 0xb015,
+                    "Write disable failed.\n");
 
 done_unprotect:
         qla82xx_rom_unlock(ha);
@@ -3025,10 +3069,12 @@ qla82xx_protect_flash(struct qla_hw_data *ha)
 {
         int ret;
         uint32_t val;
+        scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
 
         ret = ql82xx_rom_lock_d(ha);
         if (ret < 0) {
-                qla_printk(KERN_WARNING, ha, "ROM Lock failed\n");
+                ql_log(ql_log_warn, vha, 0xb016,
+                    "ROM Lock failed.\n");
                 return ret;
         }
 
@@ -3040,10 +3086,12 @@ qla82xx_protect_flash(struct qla_hw_data *ha)
         /* LOCK all sectors */
         ret = qla82xx_write_status_reg(ha, val);
         if (ret < 0)
-                qla_printk(KERN_WARNING, ha, "Write status register failed\n");
+                ql_log(ql_log_warn, vha, 0xb017,
+                    "Write status register failed.\n");
 
         if (qla82xx_write_disable_flash(ha) != 0)
-                qla_printk(KERN_WARNING, ha, "Write disable failed\n");
+                ql_log(ql_log_warn, vha, 0xb018,
+                    "Write disable failed.\n");
 done_protect:
         qla82xx_rom_unlock(ha);
         return ret;
@@ -3053,10 +3101,12 @@ static int
 qla82xx_erase_sector(struct qla_hw_data *ha, int addr)
 {
         int ret = 0;
+        scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
 
         ret = ql82xx_rom_lock_d(ha);
         if (ret < 0) {
-                qla_printk(KERN_WARNING, ha, "ROM Lock failed\n");
+                ql_log(ql_log_warn, vha, 0xb019,
+                    "ROM Lock failed.\n");
                 return ret;
         }
 
@@ -3066,8 +3116,8 @@ qla82xx_erase_sector(struct qla_hw_data *ha, int addr)
         qla82xx_wr_32(ha, QLA82XX_ROMUSB_ROM_INSTR_OPCODE, M25P_INSTR_SE);
 
         if (qla82xx_wait_rom_done(ha)) {
-                qla_printk(KERN_WARNING, ha,
-                    "Error waiting for rom done\n");
+                ql_log(ql_log_warn, vha, 0xb01a,
+                    "Error waiting for rom done.\n");
                 ret = -1;
                 goto done;
         }
@@ -3110,10 +3160,10 @@ qla82xx_write_flash_data(struct scsi_qla_host *vha, uint32_t *dwptr,
                 optrom = dma_alloc_coherent(&ha->pdev->dev, OPTROM_BURST_SIZE,
                     &optrom_dma, GFP_KERNEL);
                 if (!optrom) {
-                        qla_printk(KERN_DEBUG, ha,
-                                "Unable to allocate memory for optrom "
-                                "burst write (%x KB).\n",
-                                OPTROM_BURST_SIZE / 1024);
+                        ql_log(ql_log_warn, vha, 0xb01b,
+                            "Unable to allocate memory "
+                            "for optron burst write (%x KB).\n",
+                            OPTROM_BURST_SIZE / 1024);
                 }
         }
 
@@ -3122,8 +3172,8 @@ qla82xx_write_flash_data(struct scsi_qla_host *vha, uint32_t *dwptr,
 
         ret = qla82xx_unprotect_flash(ha);
         if (ret) {
-                qla_printk(KERN_WARNING, ha,
-                        "Unable to unprotect flash for update.\n");
+                ql_log(ql_log_warn, vha, 0xb01c,
+                    "Unable to unprotect flash for update.\n");
                 goto write_done;
         }
 
@@ -3133,9 +3183,9 @@ qla82xx_write_flash_data(struct scsi_qla_host *vha, uint32_t *dwptr,
 
                         ret = qla82xx_erase_sector(ha, faddr);
                         if (ret) {
-                                DEBUG9(qla_printk(KERN_ERR, ha,
-                                    "Unable to erase sector: "
-                                    "address=%x.\n", faddr));
+                                ql_log(ql_log_warn, vha, 0xb01d,
+                                    "Unable to erase sector: address=%x.\n",
+                                    faddr);
                                 break;
                         }
                 }
@@ -3149,12 +3199,12 @@ qla82xx_write_flash_data(struct scsi_qla_host *vha, uint32_t *dwptr,
                             (ha->flash_data_off | faddr),
                             OPTROM_BURST_DWORDS);
                         if (ret != QLA_SUCCESS) {
-                                qla_printk(KERN_WARNING, ha,
+                                ql_log(ql_log_warn, vha, 0xb01e,
                                     "Unable to burst-write optrom segment "
                                     "(%x/%x/%llx).\n", ret,
                                     (ha->flash_data_off | faddr),
                                     (unsigned long long)optrom_dma);
-                                qla_printk(KERN_WARNING, ha,
+                                ql_log(ql_log_warn, vha, 0xb01f,
                                     "Reverting to slow-write.\n");
 
                                 dma_free_coherent(&ha->pdev->dev,
@@ -3171,16 +3221,16 @@ qla82xx_write_flash_data(struct scsi_qla_host *vha, uint32_t *dwptr,
                 ret = qla82xx_write_flash_dword(ha, faddr,
                     cpu_to_le32(*dwptr));
                 if (ret) {
-                        DEBUG9(printk(KERN_DEBUG "%s(%ld) Unable to program"
-                            "flash address=%x data=%x.\n", __func__,
-                            ha->host_no, faddr, *dwptr));
+                        ql_dbg(ql_dbg_p3p, vha, 0xb020,
+                            "Unable to program flash address=%x data=%x.\n",
+                            faddr, *dwptr);
                         break;
                 }
         }
 
         ret = qla82xx_protect_flash(ha);
         if (ret)
-                qla_printk(KERN_WARNING, ha,
+                ql_log(ql_log_warn, vha, 0xb021,
                     "Unable to protect flash after update.\n");
 write_done:
         if (optrom)
@@ -3244,9 +3294,12 @@ qla82xx_start_iocbs(srb_t *sp)
 
 void qla82xx_rom_lock_recovery(struct qla_hw_data *ha)
 {
+        scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
+
         if (qla82xx_rom_lock(ha))
                 /* Someone else is holding the lock. */
-                qla_printk(KERN_INFO, ha, "Resetting rom_lock\n");
+                ql_log(ql_log_info, vha, 0xb022,
+                    "Resetting rom_lock.\n");
 
         /*
          * Either we got the lock, or someone
@@ -3313,7 +3366,8 @@ qla82xx_device_bootstrap(scsi_qla_host_t *vha)
 
 dev_initialize:
         /* set to DEV_INITIALIZING */
-        qla_printk(KERN_INFO, ha, "HW State: INITIALIZING\n");
+        ql_log(ql_log_info, vha, 0x009e,
+            "HW State: INITIALIZING.\n");
         qla82xx_wr_32(ha, QLA82XX_CRB_DEV_STATE, QLA82XX_DEV_INITIALIZING);
 
         /* Driver that sets device state to initializating sets IDC version */
@@ -3324,14 +3378,16 @@ dev_initialize:
         qla82xx_idc_lock(ha);
 
         if (rval != QLA_SUCCESS) {
-                qla_printk(KERN_INFO, ha, "HW State: FAILED\n");
+                ql_log(ql_log_fatal, vha, 0x00ad,
+                    "HW State: FAILED.\n");
                 qla82xx_clear_drv_active(ha);
                 qla82xx_wr_32(ha, QLA82XX_CRB_DEV_STATE, QLA82XX_DEV_FAILED);
                 return rval;
         }
 
 dev_ready:
-        qla_printk(KERN_INFO, ha, "HW State: READY\n");
+        ql_log(ql_log_info, vha, 0x00ae,
+            "HW State: READY.\n");
         qla82xx_wr_32(ha, QLA82XX_CRB_DEV_STATE, QLA82XX_DEV_READY);
 
         return QLA_SUCCESS;
@@ -3376,15 +3432,15 @@ qla82xx_need_qsnt_handler(scsi_qla_host_t *vha)
                         /* quiescence timeout, other functions didn't ack
                          * changing the state to DEV_READY
                          */
-                        qla_printk(KERN_INFO, ha,
-                            "%s: QUIESCENT TIMEOUT\n", QLA2XXX_DRIVER_NAME);
-                        qla_printk(KERN_INFO, ha,
-                            "DRV_ACTIVE:%d DRV_STATE:%d\n", drv_active,
-                            drv_state);
+                        ql_log(ql_log_info, vha, 0xb023,
+                            "%s : QUIESCENT TIMEOUT.\n", QLA2XXX_DRIVER_NAME);
+                        ql_log(ql_log_info, vha, 0xb024,
+                            "DRV_ACTIVE:%d DRV_STATE:%d.\n",
+                            drv_active, drv_state);
                         qla82xx_wr_32(ha, QLA82XX_CRB_DEV_STATE,
-                                                QLA82XX_DEV_READY);
-                        qla_printk(KERN_INFO, ha,
-                            "HW State: DEV_READY\n");
+                            QLA82XX_DEV_READY);
+                        ql_log(ql_log_info, vha, 0xb025,
+                            "HW State: DEV_READY.\n");
                         qla82xx_idc_unlock(ha);
                         qla2x00_perform_loop_resync(vha);
                         qla82xx_idc_lock(ha);
@@ -3404,7 +3460,8 @@ qla82xx_need_qsnt_handler(scsi_qla_host_t *vha)
         dev_state = qla82xx_rd_32(ha, QLA82XX_CRB_DEV_STATE);
         /* everyone acked so set the state to DEV_QUIESCENCE */
         if (dev_state == QLA82XX_DEV_NEED_QUIESCENT) {
-                qla_printk(KERN_INFO, ha, "HW State: DEV_QUIESCENT\n");
+                ql_log(ql_log_info, vha, 0xb026,
+                    "HW State: DEV_QUIESCENT.\n");
                 qla82xx_wr_32(ha, QLA82XX_CRB_DEV_STATE, QLA82XX_DEV_QUIESCENT);
         }
 }
@@ -3441,7 +3498,8 @@ qla82xx_dev_failed_handler(scsi_qla_host_t *vha)
         struct qla_hw_data *ha = vha->hw;
 
         /* Disable the board */
-        qla_printk(KERN_INFO, ha, "Disabling the board\n");
+        ql_log(ql_log_fatal, vha, 0x00b8,
+            "Disabling the board.\n");
 
         qla82xx_idc_lock(ha);
         qla82xx_clear_drv_active(ha);
@@ -3492,8 +3550,8 @@ qla82xx_need_reset_handler(scsi_qla_host_t *vha)
 
         while (drv_state != drv_active) {
                 if (time_after_eq(jiffies, reset_timeout)) {
-                        qla_printk(KERN_INFO, ha,
-                                "%s: RESET TIMEOUT!\n", QLA2XXX_DRIVER_NAME);
+                        ql_log(ql_log_warn, vha, 0x00b5,
+                            "Reset timeout.\n");
                         break;
                 }
                 qla82xx_idc_unlock(ha);
@@ -3504,12 +3562,15 @@ qla82xx_need_reset_handler(scsi_qla_host_t *vha)
         }
 
         dev_state = qla82xx_rd_32(ha, QLA82XX_CRB_DEV_STATE);
-        qla_printk(KERN_INFO, ha, "3:Device state is 0x%x = %s\n", dev_state,
-                dev_state < MAX_STATES ? qdev_state[dev_state] : "Unknown");
+        ql_log(ql_log_info, vha, 0x00b6,
+            "Device state is 0x%x = %s.\n",
+            dev_state,
+            dev_state < MAX_STATES ? qdev_state[dev_state] : "Unknown");
 
         /* Force to DEV_COLD unless someone else is starting a reset */
         if (dev_state != QLA82XX_DEV_INITIALIZING) {
-                qla_printk(KERN_INFO, ha, "HW State: COLD/RE-INIT\n");
+                ql_log(ql_log_info, vha, 0x00b7,
+                    "HW State: COLD/RE-INIT.\n");
                 qla82xx_wr_32(ha, QLA82XX_CRB_DEV_STATE, QLA82XX_DEV_COLD);
         }
 }
@@ -3523,8 +3584,12 @@ qla82xx_check_fw_alive(scsi_qla_host_t *vha)
         fw_heartbeat_counter = qla82xx_rd_32(vha->hw,
                 QLA82XX_PEG_ALIVE_COUNTER);
         /* all 0xff, assume AER/EEH in progress, ignore */
-        if (fw_heartbeat_counter == 0xffffffff)
+        if (fw_heartbeat_counter == 0xffffffff) {
+                ql_dbg(ql_dbg_timer, vha, 0x6003,
+                    "FW heartbeat counter is 0xffffffff, "
+                    "returning status=%d.\n", status);
                 return status;
+        }
         if (vha->fw_heartbeat_counter == fw_heartbeat_counter) {
                 vha->seconds_since_last_heartbeat++;
                 /* FW not alive after 2 seconds */
@@ -3535,6 +3600,9 @@ qla82xx_check_fw_alive(scsi_qla_host_t *vha)
         } else
                 vha->seconds_since_last_heartbeat = 0;
         vha->fw_heartbeat_counter = fw_heartbeat_counter;
+        if (status)
+                ql_dbg(ql_dbg_timer, vha, 0x6004,
+                    "Returning status=%d.\n", status);
         return status;
 }
 
@@ -3565,8 +3633,10 @@ qla82xx_device_state_handler(scsi_qla_host_t *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");
+        ql_log(ql_log_info, vha, 0x009b,
+            "Device state is 0x%x = %s.\n",
+            dev_state,
+            dev_state < MAX_STATES ? qdev_state[dev_state] : "Unknown");
 
         /* wait for 30 seconds for device to go ready */
         dev_init_timeout = jiffies + (ha->nx_dev_init_timeout * HZ);
@@ -3574,9 +3644,8 @@ qla82xx_device_state_handler(scsi_qla_host_t *vha)
         while (1) {
 
                 if (time_after_eq(jiffies, dev_init_timeout)) {
-                        DEBUG(qla_printk(KERN_INFO, ha,
-                                "%s: device init failed!\n",
-                                QLA2XXX_DRIVER_NAME));
+                        ql_log(ql_log_fatal, vha, 0x009c,
+                            "Device init failed.\n");
                         rval = QLA_FUNCTION_FAILED;
                         break;
                 }
@@ -3586,10 +3655,11 @@ qla82xx_device_state_handler(scsi_qla_host_t *vha)
                         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");
+                        ql_log(ql_log_info, vha, 0x009d,
+                            "Device state is 0x%x = %s.\n",
+                            dev_state,
+                            dev_state < MAX_STATES ? qdev_state[dev_state] :
+                            "Unknown");
                 }
 
                 switch (dev_state) {
@@ -3656,29 +3726,26 @@ void qla82xx_watchdog(scsi_qla_host_t *vha)
                 dev_state = qla82xx_rd_32(ha, QLA82XX_CRB_DEV_STATE);
                 if (dev_state == QLA82XX_DEV_NEED_RESET &&
                     !test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags)) {
-                        qla_printk(KERN_WARNING, ha,
-                            "scsi(%ld) %s: Adapter reset needed!\n",
-                                vha->host_no, __func__);
+                        ql_log(ql_log_warn, vha, 0x6001,
+                            "Adapter reset needed.\n");
                         set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
                         qla2xxx_wake_dpc(vha);
                 } else if (dev_state == QLA82XX_DEV_NEED_QUIESCENT &&
                         !test_bit(ISP_QUIESCE_NEEDED, &vha->dpc_flags)) {
-                        DEBUG(qla_printk(KERN_INFO, ha,
-                                "scsi(%ld) %s - detected quiescence needed\n",
-                                vha->host_no, __func__));
+                        ql_log(ql_log_warn, vha, 0x6002,
+                            "Quiescent needed.\n");
                         set_bit(ISP_QUIESCE_NEEDED, &vha->dpc_flags);
                         qla2xxx_wake_dpc(vha);
                 } else {
                         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,
+                                ql_dbg(ql_dbg_timer, vha, 0x6005,
+                                    "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", halt_status,
                                     qla82xx_rd_32(ha, QLA82XX_PEG_HALT_STATUS2),
                                     qla82xx_rd_32(ha,
                                             QLA82XX_CRB_PEG_NET_0 + 0x3c),
@@ -3694,9 +3761,8 @@ void qla82xx_watchdog(scsi_qla_host_t *vha)
                                         set_bit(ISP_UNRECOVERABLE,
                                             &vha->dpc_flags);
                                 } else {
-                                        qla_printk(KERN_INFO, ha,
-                                            "scsi(%ld): %s - detect abort needed\n",
-                                            vha->host_no, __func__);
+                                        ql_log(ql_log_info, vha, 0x6006,
+                                            "Detect abort  needed.\n");
                                         set_bit(ISP_ABORT_NEEDED,
                                             &vha->dpc_flags);
                                 }
@@ -3704,10 +3770,10 @@ void qla82xx_watchdog(scsi_qla_host_t *vha)
                                 ha->flags.isp82xx_fw_hung = 1;
                                 if (ha->flags.mbox_busy) {
                                         ha->flags.mbox_int = 1;
-                                        DEBUG2(qla_printk(KERN_ERR, ha,
-                                            "scsi(%ld) Due to fw hung, doing "
+                                        ql_log(ql_log_warn, vha, 0x6007,
+                                            "Due to FW hung, doing "
                                             "premature completion of mbx "
-                                            "command\n", vha->host_no));
+                                            "command.\n");
                                         if (test_bit(MBX_INTR_WAIT,
                                             &ha->mbx_cmd_flags))
                                                 complete(&ha->mbx_intr_comp);
@@ -3742,9 +3808,8 @@ qla82xx_abort_isp(scsi_qla_host_t *vha)
         uint32_t dev_state;
 
         if (vha->device_flags & DFLG_DEV_FAILED) {
-                qla_printk(KERN_WARNING, ha,
-                        "%s(%ld): Device in failed state, "
-                        "Exiting.\n", __func__, vha->host_no);
+                ql_log(ql_log_warn, vha, 0x8024,
+                    "Device in failed state, exiting.\n");
                 return QLA_SUCCESS;
         }
         ha->flags.isp82xx_reset_hdlr_active = 1;
@@ -3752,13 +3817,14 @@ qla82xx_abort_isp(scsi_qla_host_t *vha)
         qla82xx_idc_lock(ha);
         dev_state = qla82xx_rd_32(ha, QLA82XX_CRB_DEV_STATE);
         if (dev_state == QLA82XX_DEV_READY) {
-                qla_printk(KERN_INFO, ha, "HW State: NEED RESET\n");
+                ql_log(ql_log_info, vha, 0x8025,
+                    "HW State: NEED RESET.\n");
                 qla82xx_wr_32(ha, QLA82XX_CRB_DEV_STATE,
                         QLA82XX_DEV_NEED_RESET);
         } else
-                qla_printk(KERN_INFO, ha, "HW State: %s\n",
-                        dev_state < MAX_STATES ?
-                        qdev_state[dev_state] : "Unknown");
+                ql_log(ql_log_info, vha, 0x8026,
+                    "Hw State: %s.\n", dev_state < MAX_STATES ?
+                    qdev_state[dev_state] : "Unknown");
         qla82xx_idc_unlock(ha);
 
         rval = qla82xx_device_state_handler(vha);
@@ -3777,9 +3843,9 @@ qla82xx_abort_isp(scsi_qla_host_t *vha)
                 vha->flags.online = 1;
                 if (test_bit(ISP_ABORT_RETRY, &vha->dpc_flags)) {
                         if (ha->isp_abort_cnt == 0) {
-                                qla_printk(KERN_WARNING, ha,
-                                    "ISP error recovery failed - "
-                                    "board disabled\n");
+                                ql_log(ql_log_warn, vha, 0x8027,
+                                    "ISP error recover failed - board "
+                                    "disabled.\n");
                                 /*
                                  * The next call disables the board
                                  * completely.
@@ -3791,16 +3857,16 @@ qla82xx_abort_isp(scsi_qla_host_t *vha)
                                 rval = QLA_SUCCESS;
                         } else { /* schedule another ISP abort */
                                 ha->isp_abort_cnt--;
-                                DEBUG(qla_printk(KERN_INFO, ha,
-                                    "qla%ld: ISP abort - retry remaining %d\n",
-                                    vha->host_no, ha->isp_abort_cnt));
+                                ql_log(ql_log_warn, vha, 0x8036,
+                                    "ISP abort - retry remaining %d.\n",
+                                    ha->isp_abort_cnt);
                                 rval = QLA_FUNCTION_FAILED;
                         }
                 } else {
                         ha->isp_abort_cnt = MAX_RETRIES_OF_ISP_ABORT;
-                        DEBUG(qla_printk(KERN_INFO, ha,
-                            "(%ld): ISP error recovery - retrying (%d) "
-                            "more times\n", vha->host_no, ha->isp_abort_cnt));
+                        ql_dbg(ql_dbg_taskm, vha, 0x8029,
+                            "ISP error recovery - retrying (%d) more times.\n",
+                            ha->isp_abort_cnt);
                         set_bit(ISP_ABORT_RETRY, &vha->dpc_flags);
                         rval = QLA_FUNCTION_FAILED;
                 }
@@ -3872,8 +3938,8 @@ int qla2x00_wait_for_fcoe_ctx_reset(scsi_qla_host_t *vha)
                         break;
                 }
         }
-        DEBUG2(printk(KERN_INFO
-            "%s status=%d\n", __func__, status));
+        ql_dbg(ql_dbg_p3p, vha, 0xb027,
+            "%s status=%d.\n", status);
 
         return status;
 }
@@ -3902,6 +3968,9 @@ qla82xx_chip_reset_cleanup(scsi_qla_host_t *vha)
                         }
                 }
         }
+        ql_dbg(ql_dbg_init, vha, 0x00b0,
+            "Entered %s fw_hung=%d.\n",
+            __func__, ha->flags.isp82xx_fw_hung);
 
         /* Abort all commands gracefully if fw NOT hung */
         if (!ha->flags.isp82xx_fw_hung) {
@@ -3922,13 +3991,13 @@ qla82xx_chip_reset_cleanup(scsi_qla_host_t *vha)
                                                 spin_unlock_irqrestore(
                                                     &ha->hardware_lock, flags);
                                                 if (ha->isp_ops->abort_command(sp)) {
-                                                        qla_printk(KERN_INFO, ha,
-                                                            "scsi(%ld): mbx abort command failed in %s\n",
-                                                            vha->host_no, __func__);
+                                                        ql_log(ql_log_info, vha,
+                                                            0x00b1,
+                                                            "mbx abort failed.\n");
                                                 } else {
-                                                        qla_printk(KERN_INFO, ha,
-                                                            "scsi(%ld): mbx abort command success in %s\n",
-                                                            vha->host_no, __func__);
+                                                        ql_log(ql_log_info, vha,
+                                                            0x00b2,
+                                                            "mbx abort success.\n");
                                                 }
                                                 spin_lock_irqsave(&ha->hardware_lock, flags);
                                         }
@@ -3940,8 +4009,9 @@ qla82xx_chip_reset_cleanup(scsi_qla_host_t *vha)
                 /* Wait for pending cmds (physical and virtual) to complete */
                 if (!qla2x00_eh_wait_for_pending_commands(vha, 0, 0,
                     WAIT_HOST) == QLA_SUCCESS) {
-                        DEBUG2(qla_printk(KERN_INFO, ha,
-                            "Done wait for pending commands\n"));
+                        ql_dbg(ql_dbg_init, vha, 0x00b3,
+                            "Done wait for "
+                            "pending commands.\n");
                 }
         }
 }
diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c
index f461925a9dfc..e02df276804e 100644
--- a/drivers/scsi/qla2xxx/qla_os.c
+++ b/drivers/scsi/qla2xxx/qla_os.c
@@ -35,6 +35,10 @@ static struct kmem_cache *srb_cachep;
  * CT6 CTX allocation cache
  */
 static struct kmem_cache *ctx_cachep;
+/*
+ * error level for logging
+ */
+int ql_errlev = ql_log_all;
 
 int ql2xlogintimeout = 20;
 module_param(ql2xlogintimeout, int, S_IRUGO);
@@ -69,8 +73,17 @@ MODULE_PARM_DESC(ql2xallocfwdump,
 int ql2xextended_error_logging;
 module_param(ql2xextended_error_logging, int, S_IRUGO|S_IWUSR);
 MODULE_PARM_DESC(ql2xextended_error_logging,
-                "Option to enable extended error logging, "
-                "Default is 0 - no logging. 1 - log errors.");
+                "Option to enable extended error logging,\n"
+                "\t\tDefault is 0 - no logging.  0x40000000 - Module Init & Probe.\n"
+                "\t\t0x20000000 - Mailbox Cmnds. 0x10000000 - Device Discovery.\n"
+                "\t\t0x08000000 - IO tracing.    0x04000000 - DPC Thread.\n"
+                "\t\t0x02000000 - Async events.  0x01000000 - Timer routines.\n"
+                "\t\t0x00800000 - User space.    0x00400000 - Task Management.\n"
+                "\t\t0x00200000 - AER/EEH.       0x00100000 - Multi Q.\n"
+                "\t\t0x00080000 - P3P Specific.  0x00040000 - Virtual Port.\n"
+                "\t\t0x00020000 - Buffer Dump.   0x00010000 - Misc.\n"
+                "\t\t0x7fffffff - For enabling all logs, can be too many logs.\n"
+                "\t\tDo LOGICAL OR of the value to enable more than one level");
 
 int ql2xshiftctondsd = 6;
 module_param(ql2xshiftctondsd, int, S_IRUGO);
@@ -128,8 +141,8 @@ MODULE_PARM_DESC(ql2xmultique_tag,
 int ql2xfwloadbin;
 module_param(ql2xfwloadbin, int, S_IRUGO);
 MODULE_PARM_DESC(ql2xfwloadbin,
-                "Option to specify location from which to load ISP firmware:\n"
-                " 2 -- load firmware via the request_firmware() (hotplug)\n"
+                "Option to specify location from which to load ISP firmware:.\n"
+                " 2 -- load firmware via the request_firmware() (hotplug).\n"
                 "      interface.\n"
                 " 1 -- load firmware from flash.\n"
                 " 0 -- use default semantics.\n");
@@ -143,7 +156,7 @@ MODULE_PARM_DESC(ql2xetsenable,
 int ql2xdbwr = 1;
 module_param(ql2xdbwr, int, S_IRUGO);
 MODULE_PARM_DESC(ql2xdbwr,
-        "Option to specify scheme for request queue posting\n"
+        "Option to specify scheme for request queue posting.\n"
         " 0 -- Regular doorbell.\n"
         " 1 -- CAMRAM doorbell (faster).\n");
 
@@ -168,7 +181,7 @@ MODULE_PARM_DESC(ql2xasynctmfenable,
 int ql2xdontresethba;
 module_param(ql2xdontresethba, int, S_IRUGO);
 MODULE_PARM_DESC(ql2xdontresethba,
-        "Option to specify reset behaviour\n"
+        "Option to specify reset behaviour.\n"
         " 0 (Default) -- Reset on failure.\n"
         " 1 -- Do not reset on failure.\n");
 
@@ -247,8 +260,11 @@ static inline void
 qla2x00_restart_timer(scsi_qla_host_t *vha, unsigned long interval)
 {
         /* Currently used for 82XX only. */
-        if (vha->device_flags & DFLG_DEV_FAILED)
+        if (vha->device_flags & DFLG_DEV_FAILED) {
+                ql_dbg(ql_dbg_timer, vha, 0x600d,
+                    "Device in a failed state, returning.\n");
                 return;
+        }
 
         mod_timer(&vha->timer, jiffies + interval * HZ);
 }
@@ -273,19 +289,20 @@ static void qla2x00_sp_free_dma(srb_t *);
 /* -------------------------------------------------------------------------- */
 static int qla2x00_alloc_queues(struct qla_hw_data *ha)
 {
+        scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
         ha->req_q_map = kzalloc(sizeof(struct req_que *) * ha->max_req_queues,
                                 GFP_KERNEL);
         if (!ha->req_q_map) {
-                qla_printk(KERN_WARNING, ha,
-                        "Unable to allocate memory for request queue ptrs\n");
+                ql_log(ql_log_fatal, vha, 0x003b,
+                    "Unable to allocate memory for request queue ptrs.\n");
                 goto fail_req_map;
         }
 
         ha->rsp_q_map = kzalloc(sizeof(struct rsp_que *) * ha->max_rsp_queues,
                                 GFP_KERNEL);
         if (!ha->rsp_q_map) {
-                qla_printk(KERN_WARNING, ha,
-                        "Unable to allocate memory for response queue ptrs\n");
+                ql_log(ql_log_fatal, vha, 0x003c,
+                    "Unable to allocate memory for response queue ptrs.\n");
                 goto fail_rsp_map;
         }
         set_bit(0, ha->rsp_qid_map);
@@ -349,8 +366,8 @@ static int qla25xx_setup_mode(struct scsi_qla_host *vha)
         struct qla_hw_data *ha = vha->hw;
 
         if (!(ha->fw_attributes & BIT_6)) {
-                qla_printk(KERN_INFO, ha,
-                        "Firmware is not multi-queue capable\n");
+                ql_log(ql_log_warn, vha, 0x00d8,
+                    "Firmware is not multi-queue capable.\n");
                 goto fail;
         }
         if (ql2xmultique_tag) {
@@ -359,8 +376,8 @@ static int qla25xx_setup_mode(struct scsi_qla_host *vha)
                 req = qla25xx_create_req_que(ha, options, 0, 0, -1,
                         QLA_DEFAULT_QUE_QOS);
                 if (!req) {
-                        qla_printk(KERN_WARNING, ha,
-                                "Can't create request queue\n");
+                        ql_log(ql_log_warn, vha, 0x00e0,
+                            "Failed to create request queue.\n");
                         goto fail;
                 }
                 ha->wq = alloc_workqueue("qla2xxx_wq", WQ_MEM_RECLAIM, 1);
@@ -369,17 +386,20 @@ static int qla25xx_setup_mode(struct scsi_qla_host *vha)
                 for (ques = 1; ques < ha->max_rsp_queues; ques++) {
                         ret = qla25xx_create_rsp_que(ha, options, 0, 0, req);
                         if (!ret) {
-                                qla_printk(KERN_WARNING, ha,
-                                        "Response Queue create failed\n");
+                                ql_log(ql_log_warn, vha, 0x00e8,
+                                    "Failed to create response queue.\n");
                                 goto fail2;
                         }
                 }
                 ha->flags.cpu_affinity_enabled = 1;
-
-                DEBUG2(qla_printk(KERN_INFO, ha,
-                        "CPU affinity mode enabled, no. of response"
-                        " queues:%d, no. of request queues:%d\n",
-                        ha->max_rsp_queues, ha->max_req_queues));
+                ql_dbg(ql_dbg_multiq, vha, 0xc007,
+                    "CPU affinity mode enalbed, "
+                    "no. of response queues:%d no. of request queues:%d.\n",
+                    ha->max_rsp_queues, ha->max_req_queues);
+                ql_dbg(ql_dbg_init, vha, 0x00e9,
+                    "CPU affinity mode enalbed, "
+                    "no. of response queues:%d no. of request queues:%d.\n",
+                    ha->max_rsp_queues, ha->max_req_queues);
         }
         return 0;
 fail2:
@@ -526,8 +546,11 @@ qla2x00_get_new_sp(scsi_qla_host_t *vha, fc_port_t *fcport,
         struct qla_hw_data *ha = vha->hw;
 
         sp = mempool_alloc(ha->srb_mempool, GFP_ATOMIC);
-        if (!sp)
+        if (!sp) {
+                ql_log(ql_log_warn, vha, 0x3006,
+                    "Memory allocation failed for sp.\n");
                 return sp;
+        }
 
         atomic_set(&sp->ref_count, 1);
         sp->fcport = fcport;
@@ -551,30 +574,43 @@ qla2xxx_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd)
         int rval;
 
         if (ha->flags.eeh_busy) {
-                if (ha->flags.pci_channel_io_perm_failure)
+                if (ha->flags.pci_channel_io_perm_failure) {
+                        ql_dbg(ql_dbg_io, vha, 0x3001,
+                            "PCI Channel IO permanent failure, exiting "
+                            "cmd=%p.\n", cmd);
                         cmd->result = DID_NO_CONNECT << 16;
-                else
+                } else {
+                        ql_dbg(ql_dbg_io, vha, 0x3002,
+                            "EEH_Busy, Requeuing the cmd=%p.\n", cmd);
                         cmd->result = DID_REQUEUE << 16;
+                }
                 goto qc24_fail_command;
         }
 
         rval = fc_remote_port_chkready(rport);
         if (rval) {
                 cmd->result = rval;
+                ql_dbg(ql_dbg_io, vha, 0x3003,
+                    "fc_remote_port_chkready failed for cmd=%p, rval=0x%x.\n",
+                    cmd, rval);
                 goto qc24_fail_command;
         }
 
         if (!vha->flags.difdix_supported &&
                 scsi_get_prot_op(cmd) != SCSI_PROT_NORMAL) {
-                        DEBUG2(qla_printk(KERN_ERR, ha,
-                            "DIF Cap Not Reg, fail DIF capable cmd's:%x\n",
-                            cmd->cmnd[0]));
+                        ql_dbg(ql_dbg_io, vha, 0x3004,
+                            "DIF Cap not reg, fail DIF capable cmd's:%p.\n",
+                            cmd);
                         cmd->result = DID_NO_CONNECT << 16;
                         goto qc24_fail_command;
         }
         if (atomic_read(&fcport->state) != FCS_ONLINE) {
                 if (atomic_read(&fcport->state) == FCS_DEVICE_DEAD ||
                         atomic_read(&base_vha->loop_state) == LOOP_DEAD) {
+                        ql_dbg(ql_dbg_io, vha, 0x3005,
+                            "Returning DNC, fcport_state=%d loop_state=%d.\n",
+                            atomic_read(&fcport->state),
+                            atomic_read(&base_vha->loop_state));
                         cmd->result = DID_NO_CONNECT << 16;
                         goto qc24_fail_command;
                 }
@@ -586,8 +622,11 @@ qla2xxx_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd)
                 goto qc24_host_busy;
 
         rval = ha->isp_ops->start_scsi(sp);
-        if (rval != QLA_SUCCESS)
+        if (rval != QLA_SUCCESS) {
+                ql_dbg(ql_dbg_io, vha, 0x3013,
+                    "Start scsi failed rval=%d for cmd=%p.\n", rval, cmd);
                 goto qc24_host_busy_free_sp;
+        }
 
         return 0;
 
@@ -630,7 +669,8 @@ qla2x00_eh_wait_on_command(struct scsi_cmnd *cmd)
         int ret = QLA_SUCCESS;
 
         if (unlikely(pci_channel_offline(ha->pdev)) || ha->flags.eeh_busy) {
-                DEBUG17(qla_printk(KERN_WARNING, ha, "return:eh_wait\n"));
+                ql_dbg(ql_dbg_taskm, vha, 0x8005,
+                    "Return:eh_wait.\n");
                 return ret;
         }
 
@@ -723,7 +763,8 @@ qla2x00_wait_for_reset_ready(scsi_qla_host_t *vha)
         else
                 return_status = QLA_FUNCTION_FAILED;
 
-        DEBUG2(printk("%s return_status=%d\n", __func__, return_status));
+        ql_dbg(ql_dbg_taskm, vha, 0x8019,
+            "%s return status=%d.\n", __func__, return_status);
 
         return return_status;
 }
@@ -831,10 +872,14 @@ qla2xxx_eh_abort(struct scsi_cmnd *cmd)
         int wait = 0;
         struct qla_hw_data *ha = vha->hw;
 
+        ql_dbg(ql_dbg_taskm, vha, 0x8000,
+            "Entered %s for cmd=%p.\n", __func__, cmd);
         if (!CMD_SP(cmd))
                 return SUCCESS;
 
         ret = fc_block_scsi_eh(cmd);
+        ql_dbg(ql_dbg_taskm, vha, 0x8001,
+            "Return value of fc_block_scsi_eh=%d.\n", ret);
         if (ret != 0)
                 return ret;
         ret = SUCCESS;
@@ -849,20 +894,19 @@ qla2xxx_eh_abort(struct scsi_cmnd *cmd)
                 return SUCCESS;
         }
 
-        DEBUG2(printk("%s(%ld): aborting sp %p from RISC.",
-            __func__, vha->host_no, sp));
+        ql_dbg(ql_dbg_taskm, vha, 0x8002,
+            "Aborting sp=%p cmd=%p from RISC ", sp, cmd);
 
         /* Get a reference to the sp and drop the lock.*/
         sp_get(sp);
 
         spin_unlock_irqrestore(&ha->hardware_lock, flags);
         if (ha->isp_ops->abort_command(sp)) {
-                DEBUG2(printk("%s(%ld): abort_command "
-                "mbx failed.\n", __func__, vha->host_no));
-                ret = FAILED;
+                ql_dbg(ql_dbg_taskm, vha, 0x8003,
+                    "Abort command mbx failed for cmd=%p.\n", cmd);
         } else {
-                DEBUG3(printk("%s(%ld): abort_command "
-                "mbx success.\n", __func__, vha->host_no));
+                ql_dbg(ql_dbg_taskm, vha, 0x8004,
+                    "Abort command mbx success.\n");
                 wait = 1;
         }
         qla2x00_sp_compl(ha, sp);
@@ -870,16 +914,14 @@ qla2xxx_eh_abort(struct scsi_cmnd *cmd)
         /* Wait for the command to be returned. */
         if (wait) {
                 if (qla2x00_eh_wait_on_command(cmd) != QLA_SUCCESS) {
-                        qla_printk(KERN_ERR, ha,
-                            "scsi(%ld:%d:%d): Abort handler timed out -- %x.\n",
-                            vha->host_no, id, lun, ret);
+                        ql_log(ql_log_warn, vha, 0x8006,
+                            "Abort handler timed out for cmd=%p.\n", cmd);
                         ret = FAILED;
                 }
         }
 
-        qla_printk(KERN_INFO, ha,
-            "scsi(%ld:%d:%d): Abort command issued -- %d %x.\n",
-            vha->host_no, id, lun, wait, ret);
+        ql_log(ql_log_info, vha, 0x801c,
+            "Abort command issued --  %d %x.\n", wait, ret);
 
         return ret;
 }
@@ -947,40 +989,59 @@ __qla2xxx_eh_generic_reset(char *name, enum nexus_wait_type type,
         fc_port_t *fcport = (struct fc_port *) cmd->device->hostdata;
         int err;
 
-        if (!fcport)
+        if (!fcport) {
+                ql_log(ql_log_warn, vha, 0x8007,
+                    "fcport is NULL.\n");
                 return FAILED;
+        }
 
         err = fc_block_scsi_eh(cmd);
+        ql_dbg(ql_dbg_taskm, vha, 0x8008,
+            "fc_block_scsi_eh ret=%d.\n", err);
         if (err != 0)
                 return err;
 
-        qla_printk(KERN_INFO, vha->hw, "scsi(%ld:%d:%d): %s RESET ISSUED.\n",
-            vha->host_no, cmd->device->id, cmd->device->lun, name);
+        ql_log(ql_log_info, vha, 0x8009,
+            "%s RESET ISSUED for id %d lun %d cmd=%p.\n", name,
+            cmd->device->id, cmd->device->lun, cmd);
 
         err = 0;
-        if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS)
+        if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) {
+                ql_log(ql_log_warn, vha, 0x800a,
+                    "Wait for hba online failed for cmd=%p.\n", cmd);
                 goto eh_reset_failed;
+        }
         err = 1;
-        if (qla2x00_wait_for_loop_ready(vha) != QLA_SUCCESS)
+        if (qla2x00_wait_for_loop_ready(vha) != QLA_SUCCESS) {
+                ql_log(ql_log_warn, vha, 0x800b,
+                    "Wait for loop ready failed for cmd=%p.\n", cmd);
                 goto eh_reset_failed;
+        }
         err = 2;
         if (do_reset(fcport, cmd->device->lun, cmd->request->cpu + 1)
-                != QLA_SUCCESS)
+                != QLA_SUCCESS) {
+                ql_log(ql_log_warn, vha, 0x800c,
+                    "do_reset failed for cmd=%p.\n", cmd);
                 goto eh_reset_failed;
+        }
         err = 3;
         if (qla2x00_eh_wait_for_pending_commands(vha, cmd->device->id,
-            cmd->device->lun, type) != QLA_SUCCESS)
+            cmd->device->lun, type) != QLA_SUCCESS) {
+                ql_log(ql_log_warn, vha, 0x800d,
+                    "wait for peding cmds failed for cmd=%p.\n", cmd);
                 goto eh_reset_failed;
+        }
 
-        qla_printk(KERN_INFO, vha->hw, "scsi(%ld:%d:%d): %s RESET SUCCEEDED.\n",
-            vha->host_no, cmd->device->id, cmd->device->lun, name);
+        ql_log(ql_log_info, vha, 0x800e,
+            "%s RESET SUCCEEDED for id %d lun %d cmd=%p.\n", name,
+            cmd->device->id, cmd->device->lun, cmd);
 
         return SUCCESS;
 
 eh_reset_failed:
-        qla_printk(KERN_INFO, vha->hw, "scsi(%ld:%d:%d): %s RESET FAILED: %s.\n"
-            , vha->host_no, cmd->device->id, cmd->device->lun, name,
-            reset_errors[err]);
+        ql_log(ql_log_info, vha, 0x800f,
+            "%s RESET FAILED: %s for id %d lun %d cmd=%p.\n", name,
+            reset_errors[err], cmd->device->id, cmd->device->lun);
         return FAILED;
 }
 
@@ -1030,19 +1091,25 @@ qla2xxx_eh_bus_reset(struct scsi_cmnd *cmd)
         id = cmd->device->id;
         lun = cmd->device->lun;
 
-        if (!fcport)
+        if (!fcport) {
+                ql_log(ql_log_warn, vha, 0x8010,
+                    "fcport is NULL.\n");
                 return ret;
+        }
 
         ret = fc_block_scsi_eh(cmd);
+        ql_dbg(ql_dbg_taskm, vha, 0x8011,
+            "fc_block_scsi_eh ret=%d.\n", ret);
         if (ret != 0)
                 return ret;
         ret = FAILED;
 
-        qla_printk(KERN_INFO, vha->hw,
-            "scsi(%ld:%d:%d): BUS RESET ISSUED.\n", vha->host_no, id, lun);
+        ql_log(ql_log_info, vha, 0x8012,
+            "BUS RESET ISSUED for id %d lun %d.\n", id, lun);
 
         if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) {
-                DEBUG2(printk("%s failed:board disabled\n",__func__));
+                ql_log(ql_log_fatal, vha, 0x8013,
+                    "Wait for hba online failed board disabled.\n");
                 goto eh_bus_reset_done;
         }
 
@@ -1055,12 +1122,15 @@ qla2xxx_eh_bus_reset(struct scsi_cmnd *cmd)
 
         /* Flush outstanding commands. */
         if (qla2x00_eh_wait_for_pending_commands(vha, 0, 0, WAIT_HOST) !=
-            QLA_SUCCESS)
+            QLA_SUCCESS) {
+                ql_log(ql_log_warn, vha, 0x8014,
+                    "Wait for pending commands failed.\n");
                 ret = FAILED;
+        }
 
 eh_bus_reset_done:
-        qla_printk(KERN_INFO, vha->hw, "%s: reset %s\n", __func__,
-            (ret == FAILED) ? "failed" : "succeeded");
+        ql_log(ql_log_warn, vha, 0x802b,
+            "BUS RESET %s.\n", (ret == FAILED) ? "FAILED" : "SUCCEDED");
 
         return ret;
 }
@@ -1093,16 +1163,21 @@ qla2xxx_eh_host_reset(struct scsi_cmnd *cmd)
         id = cmd->device->id;
         lun = cmd->device->lun;
 
-        if (!fcport)
+        if (!fcport) {
+                ql_log(ql_log_warn, vha, 0x8016,
+                    "fcport is NULL.\n");
                 return ret;
+        }
 
         ret = fc_block_scsi_eh(cmd);
+        ql_dbg(ql_dbg_taskm, vha, 0x8017,
+            "fc_block_scsi_eh ret=%d.\n", ret);
         if (ret != 0)
                 return ret;
         ret = FAILED;
 
-        qla_printk(KERN_INFO, ha,
-            "scsi(%ld:%d:%d): ADAPTER RESET ISSUED.\n", vha->host_no, id, lun);
+        ql_log(ql_log_info, vha, 0x8018,
+            "ADAPTER RESET ISSUED for id %d lun %d.\n", id, lun);
 
         if (qla2x00_wait_for_reset_ready(vha) != QLA_SUCCESS)
                 goto eh_host_reset_lock;
@@ -1137,8 +1212,11 @@ qla2xxx_eh_host_reset(struct scsi_cmnd *cmd)
                         /* failed. schedule dpc to try */
                         set_bit(ISP_ABORT_NEEDED, &base_vha->dpc_flags);
 
-                        if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS)
+                        if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) {
+                                ql_log(ql_log_warn, vha, 0x802a,
+                                    "wait for hba online failed.\n");
                                 goto eh_host_reset_lock;
+                        }
                 }
                 clear_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);
         }
@@ -1149,7 +1227,7 @@ qla2xxx_eh_host_reset(struct scsi_cmnd *cmd)
                 ret = SUCCESS;
 
 eh_host_reset_lock:
-        qla_printk(KERN_INFO, ha, "%s: reset %s\n", __func__,
+        qla_printk(KERN_INFO, ha, "%s: reset %s.\n", __func__,
             (ret == FAILED) ? "failed" : "succeeded");
 
         return ret;
@@ -1179,9 +1257,9 @@ qla2x00_loop_reset(scsi_qla_host_t *vha)
 
                         ret = ha->isp_ops->target_reset(fcport, 0, 0);
                         if (ret != QLA_SUCCESS) {
-                                DEBUG2_3(printk("%s(%ld): bus_reset failed: "
-                                    "target_reset=%d d_id=%x.\n", __func__,
-                                    vha->host_no, ret, fcport->d_id.b24));
+                                ql_dbg(ql_dbg_taskm, vha, 0x802c,
+                                    "Bus Reset failed: Target Reset=%d "
+                                    "d_id=%x.\n", ret, fcport->d_id.b24);
                         }
                 }
         }
@@ -1189,9 +1267,8 @@ qla2x00_loop_reset(scsi_qla_host_t *vha)
         if (ha->flags.enable_lip_full_login && !IS_QLA8XXX_TYPE(ha)) {
                 ret = qla2x00_full_login_lip(vha);
                 if (ret != QLA_SUCCESS) {
-                        DEBUG2_3(printk("%s(%ld): failed: "
-                            "full_login_lip=%d.\n", __func__, vha->host_no,
-                            ret));
+                        ql_dbg(ql_dbg_taskm, vha, 0x802d,
+                            "full_login_lip=%d.\n", ret);
                 }
                 atomic_set(&vha->loop_state, LOOP_DOWN);
                 atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
@@ -1202,8 +1279,8 @@ qla2x00_loop_reset(scsi_qla_host_t *vha)
         if (ha->flags.enable_lip_reset) {
                 ret = qla2x00_lip_reset(vha);
                 if (ret != QLA_SUCCESS) {
-                        DEBUG2_3(printk("%s(%ld): failed: "
-                            "lip_reset=%d.\n", __func__, vha->host_no, ret));
+                        ql_dbg(ql_dbg_taskm, vha, 0x802e,
+                            "lip_reset failed (%d).\n", ret);
                 } else
                         qla2x00_wait_for_loop_ready(vha);
         }
@@ -1302,17 +1379,17 @@ static void qla2x00_handle_queue_full(struct scsi_device *sdev, int qdepth)
         if (!scsi_track_queue_full(sdev, qdepth))
                 return;
 
-        DEBUG2(qla_printk(KERN_INFO, fcport->vha->hw,
-                "scsi(%ld:%d:%d:%d): Queue depth adjusted-down to %d.\n",
-                fcport->vha->host_no, sdev->channel, sdev->id, sdev->lun,
-                sdev->queue_depth));
+        ql_dbg(ql_dbg_io, fcport->vha, 0x3029,
+            "Queue depth adjusted-down "
+            "to %d for scsi(%ld:%d:%d:%d).\n",
+            sdev->queue_depth, fcport->vha->host_no,
+            sdev->channel, sdev->id, sdev->lun);
 }
 
 static void qla2x00_adjust_sdev_qdepth_up(struct scsi_device *sdev, int qdepth)
 {
         fc_port_t *fcport = sdev->hostdata;
         struct scsi_qla_host *vha = fcport->vha;
-        struct qla_hw_data *ha = vha->hw;
         struct req_que *req = NULL;
 
         req = vha->req;
@@ -1327,10 +1404,11 @@ static void qla2x00_adjust_sdev_qdepth_up(struct scsi_device *sdev, int qdepth)
         else
                 scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, qdepth);
 
-        DEBUG2(qla_printk(KERN_INFO, ha,
-               "scsi(%ld:%d:%d:%d): Queue depth adjusted-up to %d.\n",
-               fcport->vha->host_no, sdev->channel, sdev->id, sdev->lun,
-               sdev->queue_depth));
+        ql_dbg(ql_dbg_io, vha, 0x302a,
+            "Queue depth adjusted-up to %d for "
+            "scsi(%ld:%d:%d:%d).\n",
+            sdev->queue_depth, fcport->vha->host_no,
+            sdev->channel, sdev->id, sdev->lun);
 }
 
 static int
@@ -1776,6 +1854,9 @@ qla2x00_set_isp_flags(struct qla_hw_data *ha)
                 ha->flags.port0 = 1;
         else
                 ha->flags.port0 = 0;
+        ql_dbg_pci(ql_dbg_init, ha->pdev, 0x000b,
+            "device_type=0x%x port=%d fw_srisc_address=%p.\n",
+            ha->device_type, ha->flags.port0, ha->fw_srisc_address);
 }
 
 static int
@@ -1790,10 +1871,9 @@ qla2x00_iospace_config(struct qla_hw_data *ha)
 
         if (pci_request_selected_regions(ha->pdev, ha->bars,
             QLA2XXX_DRIVER_NAME)) {
-                qla_printk(KERN_WARNING, ha,
-                    "Failed to reserve PIO/MMIO regions (%s)\n",
+                ql_log_pci(ql_log_fatal, ha->pdev, 0x0011,
+                    "Failed to reserve PIO/MMIO regions (%s), aborting.\n",
                     pci_name(ha->pdev));
-
                 goto iospace_error_exit;
         }
         if (!(ha->bars & 1))
@@ -1803,39 +1883,42 @@ qla2x00_iospace_config(struct qla_hw_data *ha)
         pio = pci_resource_start(ha->pdev, 0);
         if (pci_resource_flags(ha->pdev, 0) & IORESOURCE_IO) {
                 if (pci_resource_len(ha->pdev, 0) < MIN_IOBASE_LEN) {
-                        qla_printk(KERN_WARNING, ha,
-                            "Invalid PCI I/O region size (%s)...\n",
-                                pci_name(ha->pdev));
+                        ql_log_pci(ql_log_warn, ha->pdev, 0x0012,
+                            "Invalid pci I/O region size (%s).\n",
+                            pci_name(ha->pdev));
                         pio = 0;
                 }
         } else {
-                qla_printk(KERN_WARNING, ha,
-                    "region #0 not a PIO resource (%s)...\n",
+                ql_log_pci(ql_log_warn, ha->pdev, 0x0013,
+                    "Region #0 no a PIO resource (%s).\n",
                     pci_name(ha->pdev));
                 pio = 0;
         }
         ha->pio_address = pio;
+        ql_dbg_pci(ql_dbg_init, ha->pdev, 0x0014,
+            "PIO address=%p.\n",
+            ha->pio_address);
 
 skip_pio:
         /* Use MMIO operations for all accesses. */
         if (!(pci_resource_flags(ha->pdev, 1) & IORESOURCE_MEM)) {
-                qla_printk(KERN_ERR, ha,
-                    "region #1 not an MMIO resource (%s), aborting\n",
+                ql_log_pci(ql_log_fatal, ha->pdev, 0x0015,
+                    "Region #1 not an MMIO resource (%s), aborting.\n",
                     pci_name(ha->pdev));
                 goto iospace_error_exit;
         }
         if (pci_resource_len(ha->pdev, 1) < MIN_IOBASE_LEN) {
-                qla_printk(KERN_ERR, ha,
-                    "Invalid PCI mem region size (%s), aborting\n",
-                        pci_name(ha->pdev));
+                ql_log_pci(ql_log_fatal, ha->pdev, 0x0016,
+                    "Invalid PCI mem region size (%s), aborting.\n",
+                    pci_name(ha->pdev));
                 goto iospace_error_exit;
         }
 
         ha->iobase = ioremap(pci_resource_start(ha->pdev, 1), MIN_IOBASE_LEN);
         if (!ha->iobase) {
-                qla_printk(KERN_ERR, ha,
-                    "cannot remap MMIO (%s), aborting\n", pci_name(ha->pdev));
-
+                ql_log_pci(ql_log_fatal, ha->pdev, 0x0017,
+                    "Cannot remap MMIO (%s), aborting.\n",
+                    pci_name(ha->pdev));
                 goto iospace_error_exit;
         }
 
@@ -1849,6 +1932,8 @@ skip_pio:
         ha->mqiobase = ioremap(pci_resource_start(ha->pdev, 3),
                         pci_resource_len(ha->pdev, 3));
         if (ha->mqiobase) {
+                ql_dbg_pci(ql_dbg_init, ha->pdev, 0x0018,
+                    "MQIO Base=%p.\n", ha->mqiobase);
                 /* Read MSIX vector size of the board */
                 pci_read_config_word(ha->pdev, QLA_PCI_MSIX_CONTROL, &msix);
                 ha->msix_count = msix;
@@ -1861,17 +1946,24 @@ skip_pio:
                         ha->max_req_queues = 2;
                 } else if (ql2xmaxqueues > 1) {
                         ha->max_req_queues = ql2xmaxqueues > QLA_MQ_SIZE ?
-                                                QLA_MQ_SIZE : ql2xmaxqueues;
-                        DEBUG2(qla_printk(KERN_INFO, ha, "QoS mode set, max no"
-                        " of request queues:%d\n", ha->max_req_queues));
+                            QLA_MQ_SIZE : ql2xmaxqueues;
+                        ql_dbg_pci(ql_dbg_multiq, ha->pdev, 0xc008,
+                            "QoS mode set, max no of request queues:%d.\n",
+                            ha->max_req_queues);
+                        ql_dbg_pci(ql_dbg_init, ha->pdev, 0x0019,
+                            "QoS mode set, max no of request queues:%d.\n",
+                            ha->max_req_queues);
                 }
-                qla_printk(KERN_INFO, ha,
-                        "MSI-X vector count: %d\n", msix);
+                ql_log_pci(ql_log_info, ha->pdev, 0x001a,
+                    "MSI-X vector count: %d.\n", msix);
         } else
-                qla_printk(KERN_INFO, ha, "BAR 3 not enabled\n");
+                ql_log_pci(ql_log_info, ha->pdev, 0x001b,
+                    "BAR 3 not enabled.\n");
 
 mqiobase_exit:
         ha->msix_count = ha->max_rsp_queues + 1;
+        ql_dbg_pci(ql_dbg_init, ha->pdev, 0x001c,
+            "MSIX Count:%d.\n", ha->msix_count);
         return (0);
 
 iospace_error_exit:
@@ -1935,7 +2027,11 @@ qla2x00_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
             pdev->device == PCI_DEVICE_ID_QLOGIC_ISP8021) {
                 bars = pci_select_bars(pdev, IORESOURCE_MEM);
                 mem_only = 1;
+                ql_dbg_pci(ql_dbg_init, pdev, 0x0007,
+                    "Mem only adapter.\n");
         }
+        ql_dbg_pci(ql_dbg_init, pdev, 0x0008,
+            "Bars=%d.\n", bars);
 
         if (mem_only) {
                 if (pci_enable_device_mem(pdev))
@@ -1950,9 +2046,12 @@ qla2x00_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
 
         ha = kzalloc(sizeof(struct qla_hw_data), GFP_KERNEL);
         if (!ha) {
-                DEBUG(printk("Unable to allocate memory for ha\n"));
+                ql_log_pci(ql_log_fatal, pdev, 0x0009,
+                    "Unable to allocate memory for ha.\n");
                 goto probe_out;
         }
+        ql_dbg_pci(ql_dbg_init, pdev, 0x000a,
+            "Memory allocated for ha=%p.\n", ha);
         ha->pdev = pdev;
 
         /* Clear our data area */
@@ -1974,10 +2073,9 @@ qla2x00_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
         if (ret)
                 goto probe_hw_failed;
 
-        qla_printk(KERN_INFO, ha,
-            "Found an ISP%04X, irq %d, iobase 0x%p\n", pdev->device, pdev->irq,
-            ha->iobase);
-
+        ql_log_pci(ql_log_info, pdev, 0x001d,
+            "Found an ISP%04X irq %d iobase 0x%p.\n",
+            pdev->device, pdev->irq, ha->iobase);
         ha->prev_topology = 0;
         ha->init_cb_size = sizeof(init_cb_t);
         ha->link_data_rate = PORT_SPEED_UNKNOWN;
@@ -2078,7 +2176,18 @@ qla2x00_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
                 ha->nvram_conf_off = FARX_ACCESS_NVRAM_CONF;
                 ha->nvram_data_off = FARX_ACCESS_NVRAM_DATA;
         }
-
+        ql_dbg_pci(ql_dbg_init, pdev, 0x001e,
+            "mbx_count=%d, req_length=%d, "
+            "rsp_length=%d, max_loop_id=%d, init_cb_size=%d, "
+            "gid_list_info_size=%d, optrom_size=%d, nvram_npiv_size=%d, .\n",
+            ha->mbx_count, req_length, rsp_length, ha->max_loop_id,
+            ha->init_cb_size, ha->gid_list_info_size, ha->optrom_size,
+            ha->nvram_npiv_size);
+        ql_dbg_pci(ql_dbg_init, pdev, 0x001f,
+            "isp_ops=%p, flash_conf_off=%d, "
+            "flash_data_off=%d, nvram_conf_off=%d, nvram_data_off=%d.\n",
+            ha->isp_ops, ha->flash_conf_off, ha->flash_data_off,
+            ha->nvram_conf_off, ha->nvram_data_off);
         mutex_init(&ha->vport_lock);
         init_completion(&ha->mbx_cmd_comp);
         complete(&ha->mbx_cmd_comp);
@@ -2088,10 +2197,14 @@ qla2x00_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
         set_bit(0, (unsigned long *) ha->vp_idx_map);
 
         qla2x00_config_dma_addressing(ha);
+        ql_dbg_pci(ql_dbg_init, pdev, 0x0020,
+            "64 Bit addressing is %s.\n",
+            ha->flags.enable_64bit_addressing ? "enable" :
+            "disable");
         ret = qla2x00_mem_alloc(ha, req_length, rsp_length, &req, &rsp);
         if (!ret) {
-                qla_printk(KERN_WARNING, ha,
-                    "[ERROR] Failed to allocate memory for adapter\n");
+                ql_log_pci(ql_log_fatal, pdev, 0x0031,
+                    "Failed to allocate memory for adapter, aborting.\n");
 
                 goto probe_hw_failed;
         }
@@ -2103,9 +2216,6 @@ qla2x00_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
 
         base_vha = qla2x00_create_host(sht, ha);
         if (!base_vha) {
-                qla_printk(KERN_WARNING, ha,
-                    "[ERROR] Failed to allocate memory for scsi_host\n");
-
                 ret = -ENOMEM;
                 qla2x00_mem_free(ha);
                 qla2x00_free_req_que(ha, req);
@@ -2132,7 +2242,11 @@ qla2x00_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
                 if (!IS_QLA82XX(ha))
                         host->sg_tablesize = QLA_SG_ALL;
         }
-
+        ql_dbg(ql_dbg_init, base_vha, 0x0032,
+            "can_queue=%d, req=%p, "
+            "mgmt_svr_loop_id=%d, sg_tablesize=%d.\n",
+            host->can_queue, base_vha->req,
+            base_vha->mgmt_svr_loop_id, host->sg_tablesize);
         host->max_id = max_id;
         host->this_id = 255;
         host->cmd_per_lun = 3;
@@ -2146,6 +2260,14 @@ qla2x00_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
         host->transportt = qla2xxx_transport_template;
         sht->vendor_id = (SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_QLOGIC);
 
+        ql_dbg(ql_dbg_init, base_vha, 0x0033,
+            "max_id=%d this_id=%d "
+            "cmd_per_len=%d unique_id=%d max_cmd_len=%d max_channel=%d "
+            "max_lun=%d transportt=%p, vendor_id=%d.\n", host->max_id,
+            host->this_id, host->cmd_per_lun, host->unique_id,
+            host->max_cmd_len, host->max_channel, host->max_lun,
+            host->transportt, sht->vendor_id);
+
         /* Set up the irqs */
         ret = qla2x00_request_irqs(ha, rsp);
         if (ret)
@@ -2156,9 +2278,8 @@ qla2x00_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
         /* Alloc arrays of request and response ring ptrs */
 que_init:
         if (!qla2x00_alloc_queues(ha)) {
-                qla_printk(KERN_WARNING, ha,
-                "[ERROR] Failed to allocate memory for queue"
-                " pointers\n");
+                ql_log(ql_log_fatal, base_vha, 0x003d,
+                    "Failed to allocate memory for queue pointers.. aborting.\n");
                 goto probe_init_failed;
         }
 
@@ -2186,20 +2307,33 @@ que_init:
                 rsp->rsp_q_out = &ha->iobase->isp82.rsp_q_out[0];
         }
 
-        if (qla2x00_initialize_adapter(base_vha)) {
-                qla_printk(KERN_WARNING, ha,
-                    "Failed to initialize adapter\n");
+        ql_dbg(ql_dbg_multiq, base_vha, 0xc009,
+            "rsp_q_map=%p req_q_map=%p rsp->req=%p req->rsp=%p.\n",
+            ha->rsp_q_map, ha->req_q_map, rsp->req, req->rsp);
+        ql_dbg(ql_dbg_multiq, base_vha, 0xc00a,
+            "req->req_q_in=%p req->req_q_out=%p "
+            "rsp->rsp_q_in=%p rsp->rsp_q_out=%p.\n",
+            req->req_q_in, req->req_q_out,
+            rsp->rsp_q_in, rsp->rsp_q_out);
+        ql_dbg(ql_dbg_init, base_vha, 0x003e,
+            "rsp_q_map=%p req_q_map=%p rsp->req=%p req->rsp=%p.\n",
+            ha->rsp_q_map, ha->req_q_map, rsp->req, req->rsp);
+        ql_dbg(ql_dbg_init, base_vha, 0x003f,
+            "req->req_q_in=%p req->req_q_out=%p rsp->rsp_q_in=%p rsp->rsp_q_out=%p.\n",
+            req->req_q_in, req->req_q_out, rsp->rsp_q_in, rsp->rsp_q_out);
 
-                DEBUG2(printk("scsi(%ld): Failed to initialize adapter - "
-                    "Adapter flags %x.\n",
-                    base_vha->host_no, base_vha->device_flags));
+        if (qla2x00_initialize_adapter(base_vha)) {
+                ql_log(ql_log_fatal, base_vha, 0x00d6,
+                    "Failed to initialize adapter - Adapter flags %x.\n",
+                    base_vha->device_flags);
 
                 if (IS_QLA82XX(ha)) {
                         qla82xx_idc_lock(ha);
                         qla82xx_wr_32(ha, QLA82XX_CRB_DEV_STATE,
                                 QLA82XX_DEV_FAILED);
                         qla82xx_idc_unlock(ha);
-                        qla_printk(KERN_INFO, ha, "HW State: FAILED\n");
+                        ql_log(ql_log_fatal, base_vha, 0x00d7,
+                            "HW State: FAILED.\n");
                 }
 
                 ret = -ENODEV;
@@ -2208,9 +2342,8 @@ que_init:
 
         if (ha->mqenable) {
                 if (qla25xx_setup_mode(base_vha)) {
-                        qla_printk(KERN_WARNING, ha,
-                                "Can't create queues, falling back to single"
-                                " queue mode\n");
+                        ql_log(ql_log_warn, base_vha, 0x00ec,
+                            "Failed to create queues, falling back to single queue mode.\n");
                         goto que_init;
                 }
         }
@@ -2222,13 +2355,15 @@ que_init:
          * Startup the kernel thread for this host adapter
          */
         ha->dpc_thread = kthread_create(qla2x00_do_dpc, ha,
-                        "%s_dpc", base_vha->host_str);
+            "%s_dpc", base_vha->host_str);
         if (IS_ERR(ha->dpc_thread)) {
-                qla_printk(KERN_WARNING, ha,
-                    "Unable to start DPC thread!\n");
+                ql_log(ql_log_fatal, base_vha, 0x00ed,
+                    "Failed to start DPC thread.\n");
                 ret = PTR_ERR(ha->dpc_thread);
                 goto probe_failed;
         }
+        ql_dbg(ql_dbg_init, base_vha, 0x00ee,
+            "DPC thread started successfully.\n");
 
 skip_dpc:
         list_add_tail(&base_vha->list, &ha->vp_list);
@@ -2236,16 +2371,18 @@ skip_dpc:
 
         /* Initialized the timer */
         qla2x00_start_timer(base_vha, qla2x00_timer, WATCH_INTERVAL);
-
-        DEBUG2(printk("DEBUG: detect hba %ld at address = %p\n",
-            base_vha->host_no, ha));
+        ql_dbg(ql_dbg_init, base_vha, 0x00ef,
+            "Started qla2x00_timer with "
+            "interval=%d.\n", WATCH_INTERVAL);
+        ql_dbg(ql_dbg_init, base_vha, 0x00f0,
+            "Detected hba at address=%p.\n",
+            ha);
 
         if ((IS_QLA25XX(ha) || IS_QLA81XX(ha)) && ql2xenabledif) {
                 if (ha->fw_attributes & BIT_4) {
                         base_vha->flags.difdix_supported = 1;
-                        DEBUG18(qla_printk(KERN_INFO, ha,
-                            "Registering for DIF/DIX type 1 and 3"
-                            " protection.\n"));
+                        ql_dbg(ql_dbg_init, base_vha, 0x00f1,
+                            "Registering for DIF/DIX type 1 and 3 protection.\n");
                         scsi_host_set_prot(host,
                             SHOST_DIF_TYPE1_PROTECTION
                             | SHOST_DIF_TYPE2_PROTECTION
@@ -2267,6 +2404,9 @@ skip_dpc:
         base_vha->flags.init_done = 1;
         base_vha->flags.online = 1;
 
+        ql_dbg(ql_dbg_init, base_vha, 0x00f2,
+            "Init done and hba is online.\n");
+
         scsi_scan_host(host);
 
         qla2x00_alloc_sysfs_attr(base_vha);
@@ -2275,14 +2415,17 @@ skip_dpc:
 
         qla2x00_dfs_setup(base_vha);
 
-        qla_printk(KERN_INFO, ha, "\n"
-            " QLogic Fibre Channel HBA Driver: %s\n"
-            "  QLogic %s - %s\n"
-            "  ISP%04X: %s @ %s hdma%c, host#=%ld, fw=%s\n",
-            qla2x00_version_str, ha->model_number,
-            ha->model_desc ? ha->model_desc : "", pdev->device,
-            ha->isp_ops->pci_info_str(base_vha, pci_info), pci_name(pdev),
-            ha->flags.enable_64bit_addressing ? '+' : '-', base_vha->host_no,
+        ql_log(ql_log_info, base_vha, 0x00fa,
+            "QLogic Fibre Channed HBA Driver: %s.\n",
+            qla2x00_version_str);
+        ql_log(ql_log_info, base_vha, 0x00fb,
+            "QLogic %s - %s.\n",
+            ha->model_number, ha->model_desc ? ha->model_desc : "");
+        ql_log(ql_log_info, base_vha, 0x00fc,
+            "ISP%04X: %s @ %s hdma%c host#=%ld fw=%s.\n",
+            pdev->device, ha->isp_ops->pci_info_str(base_vha, pci_info),
+            pci_name(pdev), ha->flags.enable_64bit_addressing ? '+' : '-',
+            base_vha->host_no,
             ha->isp_ops->fw_version_str(base_vha, fw_str));
 
         return 0;
@@ -2580,20 +2723,15 @@ void qla2x00_mark_device_lost(scsi_qla_host_t *vha, fc_port_t *fcport,
                 fcport->login_retry = vha->hw->login_retry_count;
                 set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
 
-                DEBUG(printk("scsi(%ld): Port login retry: "
+                ql_dbg(ql_dbg_disc, vha, 0x2067,
+                    "Port login retry "
                     "%02x%02x%02x%02x%02x%02x%02x%02x, "
-                    "id = 0x%04x retry cnt=%d\n",
-                    vha->host_no,
-                    fcport->port_name[0],
-                    fcport->port_name[1],
-                    fcport->port_name[2],
-                    fcport->port_name[3],
-                    fcport->port_name[4],
-                    fcport->port_name[5],
-                    fcport->port_name[6],
-                    fcport->port_name[7],
-                    fcport->loop_id,
-                    fcport->login_retry));
+                    "id = 0x%04x retry cnt=%d.\n",
+                    fcport->port_name[0], fcport->port_name[1],
+                    fcport->port_name[2], fcport->port_name[3],
+                    fcport->port_name[4], fcport->port_name[5],
+                    fcport->port_name[6], fcport->port_name[7],
+                    fcport->loop_id, fcport->login_retry);
         }
 }
 
@@ -2676,6 +2814,9 @@ qla2x00_mem_alloc(struct qla_hw_data *ha, uint16_t req_len, uint16_t rsp_len,
                         ctx_cachep);
                 if (!ha->ctx_mempool)
                         goto fail_free_srb_mempool;
+                ql_dbg_pci(ql_dbg_init, ha->pdev, 0x0021,
+                    "ctx_cachep=%p ctx_mempool=%p.\n",
+                    ctx_cachep, ha->ctx_mempool);
         }
 
         /* Get memory for cached NVRAM */
@@ -2690,22 +2831,29 @@ qla2x00_mem_alloc(struct qla_hw_data *ha, uint16_t req_len, uint16_t rsp_len,
         if (!ha->s_dma_pool)
                 goto fail_free_nvram;
 
+        ql_dbg_pci(ql_dbg_init, ha->pdev, 0x0022,
+            "init_cb=%p gid_list=%p, srb_mempool=%p s_dma_pool=%p.\n",
+            ha->init_cb, ha->gid_list, ha->srb_mempool, ha->s_dma_pool);
+
         if (IS_QLA82XX(ha) || ql2xenabledif) {
                 ha->dl_dma_pool = dma_pool_create(name, &ha->pdev->dev,
                         DSD_LIST_DMA_POOL_SIZE, 8, 0);
                 if (!ha->dl_dma_pool) {
-                        qla_printk(KERN_WARNING, ha,
-                            "Memory Allocation failed - dl_dma_pool\n");
+                        ql_log_pci(ql_log_fatal, ha->pdev, 0x0023,
+                            "Failed to allocate memory for dl_dma_pool.\n");
                         goto fail_s_dma_pool;
                 }
 
                 ha->fcp_cmnd_dma_pool = dma_pool_create(name, &ha->pdev->dev,
                         FCP_CMND_DMA_POOL_SIZE, 8, 0);
                 if (!ha->fcp_cmnd_dma_pool) {
-                        qla_printk(KERN_WARNING, ha,
-                            "Memory Allocation failed - fcp_cmnd_dma_pool\n");
+                        ql_log_pci(ql_log_fatal, ha->pdev, 0x0024,
+                            "Failed to allocate memory for fcp_cmnd_dma_pool.\n");
                         goto fail_dl_dma_pool;
                 }
+                ql_dbg_pci(ql_dbg_init, ha->pdev, 0x0025,
+                    "dl_dma_pool=%p fcp_cmnd_dma_pool=%p.\n",
+                    ha->dl_dma_pool, ha->fcp_cmnd_dma_pool);
         }
 
         /* Allocate memory for SNS commands */
@@ -2715,6 +2863,8 @@ qla2x00_mem_alloc(struct qla_hw_data *ha, uint16_t req_len, uint16_t rsp_len,
                 sizeof(struct sns_cmd_pkt), &ha->sns_cmd_dma, GFP_KERNEL);
                 if (!ha->sns_cmd)
                         goto fail_dma_pool;
+                ql_dbg_pci(ql_dbg_init, ha->pdev, 0x0026,
+                    "sns_cmd.\n", ha->sns_cmd);
         } else {
         /* Get consistent memory allocated for MS IOCB */
                 ha->ms_iocb = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL,
@@ -2726,12 +2876,16 @@ qla2x00_mem_alloc(struct qla_hw_data *ha, uint16_t req_len, uint16_t rsp_len,
                         sizeof(struct ct_sns_pkt), &ha->ct_sns_dma, GFP_KERNEL);
                 if (!ha->ct_sns)
                         goto fail_free_ms_iocb;
+                ql_dbg_pci(ql_dbg_init, ha->pdev, 0x0027,
+                    "ms_iocb=%p ct_sns=%p.\n",
+                    ha->ms_iocb, ha->ct_sns);
         }
 
         /* Allocate memory for request ring */
         *req = kzalloc(sizeof(struct req_que), GFP_KERNEL);
         if (!*req) {
-                DEBUG(printk("Unable to allocate memory for req\n"));
+                ql_log_pci(ql_log_fatal, ha->pdev, 0x0028,
+                    "Failed to allocate memory for req.\n");
                 goto fail_req;
         }
         (*req)->length = req_len;
@@ -2739,14 +2893,15 @@ qla2x00_mem_alloc(struct qla_hw_data *ha, uint16_t req_len, uint16_t rsp_len,
                 ((*req)->length + 1) * sizeof(request_t),
                 &(*req)->dma, GFP_KERNEL);
         if (!(*req)->ring) {
-                DEBUG(printk("Unable to allocate memory for req_ring\n"));
+                ql_log_pci(ql_log_fatal, ha->pdev, 0x0029,
+                    "Failed to allocate memory for req_ring.\n");
                 goto fail_req_ring;
         }
         /* Allocate memory for response ring */
         *rsp = kzalloc(sizeof(struct rsp_que), GFP_KERNEL);
         if (!*rsp) {
-                qla_printk(KERN_WARNING, ha,
-                        "Unable to allocate memory for rsp\n");
+                ql_log_pci(ql_log_fatal, ha->pdev, 0x002a,
+                    "Failed to allocate memory for rsp.\n");
                 goto fail_rsp;
         }
         (*rsp)->hw = ha;
@@ -2755,19 +2910,24 @@ qla2x00_mem_alloc(struct qla_hw_data *ha, uint16_t req_len, uint16_t rsp_len,
                 ((*rsp)->length + 1) * sizeof(response_t),
                 &(*rsp)->dma, GFP_KERNEL);
         if (!(*rsp)->ring) {
-                qla_printk(KERN_WARNING, ha,
-                        "Unable to allocate memory for rsp_ring\n");
+                ql_log_pci(ql_log_fatal, ha->pdev, 0x002b,
+                    "Failed to allocate memory for rsp_ring.\n");
                 goto fail_rsp_ring;
         }
         (*req)->rsp = *rsp;
         (*rsp)->req = *req;
+        ql_dbg_pci(ql_dbg_init, ha->pdev, 0x002c,
+            "req=%p req->length=%d req->ring=%p rsp=%p "
+            "rsp->length=%d rsp->ring=%p.\n",
+            *req, (*req)->length, (*req)->ring, *rsp, (*rsp)->length,
+            (*rsp)->ring);
         /* Allocate memory for NVRAM data for vports */
         if (ha->nvram_npiv_size) {
                 ha->npiv_info = kzalloc(sizeof(struct qla_npiv_entry) *
-                                        ha->nvram_npiv_size, GFP_KERNEL);
+                    ha->nvram_npiv_size, GFP_KERNEL);
                 if (!ha->npiv_info) {
-                        qla_printk(KERN_WARNING, ha,
-                                "Unable to allocate memory for npiv info\n");
+                        ql_log_pci(ql_log_fatal, ha->pdev, 0x002d,
+                            "Failed to allocate memory for npiv_info.\n");
                         goto fail_npiv_info;
                 }
         } else
@@ -2779,6 +2939,8 @@ qla2x00_mem_alloc(struct qla_hw_data *ha, uint16_t req_len, uint16_t rsp_len,
                     &ha->ex_init_cb_dma);
                 if (!ha->ex_init_cb)
                         goto fail_ex_init_cb;
+                ql_dbg_pci(ql_dbg_init, ha->pdev, 0x002e,
+                    "ex_init_cb=%p.\n", ha->ex_init_cb);
         }
 
         INIT_LIST_HEAD(&ha->gbl_dsd_list);
@@ -2789,6 +2951,8 @@ qla2x00_mem_alloc(struct qla_hw_data *ha, uint16_t req_len, uint16_t rsp_len,
                         &ha->async_pd_dma);
                 if (!ha->async_pd)
                         goto fail_async_pd;
+                ql_dbg_pci(ql_dbg_init, ha->pdev, 0x002f,
+                    "async_pd=%p.\n", ha->async_pd);
         }
 
         INIT_LIST_HEAD(&ha->vp_list);
@@ -2854,7 +3018,8 @@ fail_free_init_cb:
         ha->init_cb = NULL;
         ha->init_cb_dma = 0;
 fail:
-        DEBUG(printk("%s: Memory allocation failure\n", __func__));
+        ql_log(ql_log_fatal, NULL, 0x0030,
+            "Memory allocation failure.\n");
         return -ENOMEM;
 }
 
@@ -3003,8 +3168,8 @@ struct scsi_qla_host *qla2x00_create_host(struct scsi_host_template *sht,
 
         host = scsi_host_alloc(sht, sizeof(scsi_qla_host_t));
         if (host == NULL) {
-                printk(KERN_WARNING
-                "qla2xxx: Couldn't allocate host from scsi layer!\n");
+                ql_log_pci(ql_log_fatal, ha->pdev, 0x0107,
+                    "Failed to allocate host from the scsi layer, aborting.\n");
                 goto fail;
         }
 
@@ -3023,6 +3188,11 @@ struct scsi_qla_host *qla2x00_create_host(struct scsi_host_template *sht,
         spin_lock_init(&vha->work_lock);
 
         sprintf(vha->host_str, "%s_%ld", QLA2XXX_DRIVER_NAME, vha->host_no);
+        ql_dbg(ql_dbg_init, vha, 0x0041,
+            "Allocated the host=%p hw=%p vha=%p dev_name=%s",
+            vha->host, vha->hw, vha,
+            dev_name(&(ha->pdev->dev)));
+
         return vha;
 
 fail:
@@ -3264,18 +3434,18 @@ void qla2x00_relogin(struct scsi_qla_host *vha)
                         if (status == QLA_SUCCESS) {
                                 fcport->old_loop_id = fcport->loop_id;
 
-                                DEBUG(printk("scsi(%ld): port login OK: logged "
-                                "in ID 0x%x\n", vha->host_no, fcport->loop_id));
+                                ql_dbg(ql_dbg_disc, vha, 0x2003,
+                                    "Port login OK: logged in ID 0x%x.\n",
+                                    fcport->loop_id);
 
                                 qla2x00_update_fcport(vha, fcport);
 
                         } else if (status == 1) {
                                 set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
                                 /* retry the login again */
-                                DEBUG(printk("scsi(%ld): Retrying"
-                                " %d login again loop_id 0x%x\n",
-                                vha->host_no, fcport->login_retry,
-                                                fcport->loop_id));
+                                ql_dbg(ql_dbg_disc, vha, 0x2007,
+                                    "Retrying %d login again loop_id 0x%x.\n",
+                                    fcport->login_retry, fcport->loop_id);
                         } else {
                                 fcport->login_retry = 0;
                         }
@@ -3315,26 +3485,27 @@ qla2x00_do_dpc(void *data)
 
         set_current_state(TASK_INTERRUPTIBLE);
         while (!kthread_should_stop()) {
-                DEBUG3(printk("qla2x00: DPC handler sleeping\n"));
+                ql_dbg(ql_dbg_dpc, base_vha, 0x4000,
+                    "DPC handler sleeping.\n");
 
                 schedule();
                 __set_current_state(TASK_RUNNING);
 
-                DEBUG3(printk("qla2x00: DPC handler waking up\n"));
+                ql_dbg(ql_dbg_dpc, base_vha, 0x4001,
+                    "DPC handler waking up.\n");
+                ql_dbg(ql_dbg_dpc, base_vha, 0x4002,
+                    "dpc_flags=0x%lx.\n", base_vha->dpc_flags);
 
                 /* Initialization not yet finished. Don't do anything yet. */
                 if (!base_vha->flags.init_done)
                         continue;
 
                 if (ha->flags.eeh_busy) {
-                        DEBUG17(qla_printk(KERN_WARNING, ha,
-                            "qla2x00_do_dpc: dpc_flags: %lx\n",
-                            base_vha->dpc_flags));
+                        ql_dbg(ql_dbg_dpc, base_vha, 0x4003,
+                            "eeh_busy=%d.\n", ha->flags.eeh_busy);
                         continue;
                 }
 
-                DEBUG3(printk("scsi(%ld): DPC handler\n", base_vha->host_no));
-
                 ha->dpc_active = 1;
 
                 if (ha->flags.mbox_busy) {
@@ -3351,8 +3522,8 @@ qla2x00_do_dpc(void *data)
                                 qla82xx_wr_32(ha, QLA82XX_CRB_DEV_STATE,
                                         QLA82XX_DEV_FAILED);
                                 qla82xx_idc_unlock(ha);
-                                qla_printk(KERN_INFO, ha,
-                                        "HW State: FAILED\n");
+                                ql_log(ql_log_info, base_vha, 0x4004,
+                                    "HW State: FAILED.\n");
                                 qla82xx_device_state_handler(base_vha);
                                 continue;
                         }
@@ -3360,10 +3531,8 @@ qla2x00_do_dpc(void *data)
                         if (test_and_clear_bit(FCOE_CTX_RESET_NEEDED,
                                 &base_vha->dpc_flags)) {
 
-                                DEBUG(printk(KERN_INFO
-                                        "scsi(%ld): dpc: sched "
-                                        "qla82xx_fcoe_ctx_reset ha = %p\n",
-                                        base_vha->host_no, ha));
+                                ql_dbg(ql_dbg_dpc, base_vha, 0x4005,
+                                    "FCoE context reset scheduled.\n");
                                 if (!(test_and_set_bit(ABORT_ISP_ACTIVE,
                                         &base_vha->dpc_flags))) {
                                         if (qla82xx_fcoe_ctx_reset(base_vha)) {
@@ -3377,18 +3546,16 @@ qla2x00_do_dpc(void *data)
                                                 &base_vha->dpc_flags);
                                 }
 
-                                DEBUG(printk("scsi(%ld): dpc:"
-                                        " qla82xx_fcoe_ctx_reset end\n",
-                                        base_vha->host_no));
+                                ql_dbg(ql_dbg_dpc, base_vha, 0x4006,
+                                    "FCoE context reset end.\n");
                         }
                 }
 
                 if (test_and_clear_bit(ISP_ABORT_NEEDED,
                                                 &base_vha->dpc_flags)) {
 
-                        DEBUG(printk("scsi(%ld): dpc: sched "
-                            "qla2x00_abort_isp ha = %p\n",
-                            base_vha->host_no, ha));
+                        ql_dbg(ql_dbg_dpc, base_vha, 0x4007,
+                            "ISP abort scheduled.\n");
                         if (!(test_and_set_bit(ABORT_ISP_ACTIVE,
                             &base_vha->dpc_flags))) {
 
@@ -3401,8 +3568,8 @@ qla2x00_do_dpc(void *data)
                                                 &base_vha->dpc_flags);
                         }
 
-                        DEBUG(printk("scsi(%ld): dpc: qla2x00_abort_isp end\n",
-                            base_vha->host_no));
+                        ql_dbg(ql_dbg_dpc, base_vha, 0x4008,
+                            "ISP abort end.\n");
                 }
 
                 if (test_bit(FCPORT_UPDATE_NEEDED, &base_vha->dpc_flags)) {
@@ -3411,9 +3578,8 @@ qla2x00_do_dpc(void *data)
                 }
 
                 if (test_bit(ISP_QUIESCE_NEEDED, &base_vha->dpc_flags)) {
-                        DEBUG(printk(KERN_INFO "scsi(%ld): dpc: sched "
-                            "qla2x00_quiesce_needed ha = %p\n",
-                            base_vha->host_no, ha));
+                        ql_dbg(ql_dbg_dpc, base_vha, 0x4009,
+                            "Quiescence mode scheduled.\n");
                         qla82xx_device_state_handler(base_vha);
                         clear_bit(ISP_QUIESCE_NEEDED, &base_vha->dpc_flags);
                         if (!ha->flags.quiesce_owner) {
@@ -3423,17 +3589,20 @@ qla2x00_do_dpc(void *data)
                                 qla82xx_clear_qsnt_ready(base_vha);
                                 qla82xx_idc_unlock(ha);
                         }
+                        ql_dbg(ql_dbg_dpc, base_vha, 0x400a,
+                            "Quiescence mode end.\n");
                 }
 
                 if (test_and_clear_bit(RESET_MARKER_NEEDED,
                                                         &base_vha->dpc_flags) &&
                     (!(test_and_set_bit(RESET_ACTIVE, &base_vha->dpc_flags)))) {
 
-                        DEBUG(printk("scsi(%ld): qla2x00_reset_marker()\n",
-                            base_vha->host_no));
-
+                        ql_dbg(ql_dbg_dpc, base_vha, 0x400b,
+                            "Reset marker scheduled.\n");
                         qla2x00_rst_aen(base_vha);
                         clear_bit(RESET_ACTIVE, &base_vha->dpc_flags);
+                        ql_dbg(ql_dbg_dpc, base_vha, 0x400c,
+                            "Reset marker end.\n");
                 }
 
                 /* Retry each device up to login retry count */
@@ -3442,19 +3611,18 @@ qla2x00_do_dpc(void *data)
                     !test_bit(LOOP_RESYNC_NEEDED, &base_vha->dpc_flags) &&
                     atomic_read(&base_vha->loop_state) != LOOP_DOWN) {
 
-                        DEBUG(printk("scsi(%ld): qla2x00_port_login()\n",
-                                        base_vha->host_no));
+                        ql_dbg(ql_dbg_dpc, base_vha, 0x400d,
+                            "Relogin scheduled.\n");
                         qla2x00_relogin(base_vha);
-
-                        DEBUG(printk("scsi(%ld): qla2x00_port_login - end\n",
-                            base_vha->host_no));
+                        ql_dbg(ql_dbg_dpc, base_vha, 0x400e,
+                            "Relogin end.\n");
                 }
 
                 if (test_and_clear_bit(LOOP_RESYNC_NEEDED,
                                                         &base_vha->dpc_flags)) {
 
-                        DEBUG(printk("scsi(%ld): qla2x00_loop_resync()\n",
-                                base_vha->host_no));
+                        ql_dbg(ql_dbg_dpc, base_vha, 0x400f,
+                            "Loop resync scheduled.\n");
 
                         if (!(test_and_set_bit(LOOP_RESYNC_ACTIVE,
                             &base_vha->dpc_flags))) {
@@ -3465,8 +3633,8 @@ qla2x00_do_dpc(void *data)
                                                 &base_vha->dpc_flags);
                         }
 
-                        DEBUG(printk("scsi(%ld): qla2x00_loop_resync - end\n",
-                            base_vha->host_no));
+                        ql_dbg(ql_dbg_dpc, base_vha, 0x4010,
+                            "Loop resync end.\n");
                 }
 
                 if (test_bit(NPIV_CONFIG_NEEDED, &base_vha->dpc_flags) &&
@@ -3489,7 +3657,8 @@ qla2x00_do_dpc(void *data)
         } /* End of while(1) */
         __set_current_state(TASK_RUNNING);
 
-        DEBUG(printk("scsi(%ld): DPC handler exiting\n", base_vha->host_no));
+        ql_dbg(ql_dbg_dpc, base_vha, 0x4011,
+            "DPC handler exiting.\n");
 
         /*
          * Make sure that nobody tries to wake us up again.
@@ -3596,9 +3765,11 @@ void
 qla2x00_sp_compl(struct qla_hw_data *ha, srb_t *sp)
 {
         if (atomic_read(&sp->ref_count) == 0) {
-                DEBUG2(qla_printk(KERN_WARNING, ha,
-                    "SP reference-count to ZERO -- sp=%p\n", sp));
-                DEBUG2(BUG());
+                ql_dbg(ql_dbg_io, sp->fcport->vha, 0x3015,
+                    "SP reference-count to ZERO -- sp=%p cmd=%p.\n",
+                    sp, sp->cmd);
+                if (ql2xextended_error_logging & ql_dbg_io)
+                        BUG();
                 return;
         }
         if (!atomic_dec_and_test(&sp->ref_count))
@@ -3626,6 +3797,9 @@ qla2x00_timer(scsi_qla_host_t *vha)
         struct req_que *req;
 
         if (ha->flags.eeh_busy) {
+                ql_dbg(ql_dbg_timer, vha, 0x6000,
+                    "EEH = %d, restarting timer.\n",
+                    ha->flags.eeh_busy);
                 qla2x00_restart_timer(vha, WATCH_INTERVAL);
                 return;
         }
@@ -3650,9 +3824,8 @@ qla2x00_timer(scsi_qla_host_t *vha)
                 if (atomic_read(&vha->loop_down_timer) ==
                     vha->loop_down_abort_time) {
 
-                        DEBUG(printk("scsi(%ld): Loop Down - aborting the "
-                            "queues before time expire\n",
-                            vha->host_no));
+                        ql_log(ql_log_info, vha, 0x6008,
+                            "Loop down - aborting the queues before time expires.\n");
 
                         if (!IS_QLA2100(ha) && vha->link_down_timeout)
                                 atomic_set(&vha->loop_state, LOOP_DEAD);
@@ -3697,10 +3870,7 @@ qla2x00_timer(scsi_qla_host_t *vha)
                 /* if the loop has been down for 4 minutes, reinit adapter */
                 if (atomic_dec_and_test(&vha->loop_down_timer) != 0) {
                         if (!(vha->device_flags & DFLG_NO_CABLE)) {
-                                DEBUG(printk("scsi(%ld): Loop down - "
-                                    "aborting ISP.\n",
-                                    vha->host_no));
-                                qla_printk(KERN_WARNING, ha,
+                                ql_log(ql_log_warn, vha, 0x6009,
                                     "Loop down - aborting ISP.\n");
 
                                 if (IS_QLA82XX(ha))
@@ -3711,9 +3881,9 @@ qla2x00_timer(scsi_qla_host_t *vha)
                                                 &vha->dpc_flags);
                         }
                 }
-                DEBUG3(printk("scsi(%ld): Loop Down - seconds remaining %d\n",
-                    vha->host_no,
-                    atomic_read(&vha->loop_down_timer)));
+                ql_dbg(ql_dbg_timer, vha, 0x600a,
+                    "Loop down - seconds remaining %d.\n",
+                    atomic_read(&vha->loop_down_timer));
         }
 
         /* Check if beacon LED needs to be blinked for physical host only */
@@ -3736,8 +3906,27 @@ qla2x00_timer(scsi_qla_host_t *vha)
             test_bit(ISP_UNRECOVERABLE, &vha->dpc_flags) ||
             test_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags) ||
             test_bit(VP_DPC_NEEDED, &vha->dpc_flags) ||
-            test_bit(RELOGIN_NEEDED, &vha->dpc_flags)))
+            test_bit(RELOGIN_NEEDED, &vha->dpc_flags))) {
+                ql_dbg(ql_dbg_timer, vha, 0x600b,
+                    "isp_abort_needed=%d loop_resync_needed=%d "
+                    "fcport_update_needed=%d start_dpc=%d "
+                    "reset_marker_needed=%d",
+                    test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags),
+                    test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags),
+                    test_bit(FCPORT_UPDATE_NEEDED, &vha->dpc_flags),
+                    start_dpc,
+                    test_bit(RESET_MARKER_NEEDED, &vha->dpc_flags));
+                ql_dbg(ql_dbg_timer, vha, 0x600c,
+                    "beacon_blink_needed=%d isp_unrecoverable=%d "
+                    "fcoe_ctx_reset_needed=%d vp_dpc_needed=%d "
+                    "relogin_needed=%d.\n",
+                    test_bit(BEACON_BLINK_NEEDED, &vha->dpc_flags),
+                    test_bit(ISP_UNRECOVERABLE, &vha->dpc_flags),
+                    test_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags),
+                    test_bit(VP_DPC_NEEDED, &vha->dpc_flags),
+                    test_bit(RELOGIN_NEEDED, &vha->dpc_flags));
                 qla2xxx_wake_dpc(vha);
+        }
 
         qla2x00_restart_timer(vha, WATCH_INTERVAL);
 }
@@ -3806,8 +3995,8 @@ qla2x00_request_firmware(scsi_qla_host_t *vha)
                 goto out;
 
         if (request_firmware(&blob->fw, blob->name, &ha->pdev->dev)) {
-                DEBUG2(printk("scsi(%ld): Failed to load firmware image "
-                    "(%s).\n", vha->host_no, blob->name));
+                ql_log(ql_log_warn, vha, 0x0063,
+                    "Failed to load firmware image (%s).\n", blob->name);
                 blob->fw = NULL;
                 blob = NULL;
                 goto out;
@@ -3836,8 +4025,8 @@ qla2xxx_pci_error_detected(struct pci_dev *pdev, pci_channel_state_t state)
         scsi_qla_host_t *vha = pci_get_drvdata(pdev);
         struct qla_hw_data *ha = vha->hw;
 
-        DEBUG2(qla_printk(KERN_WARNING, ha, "error_detected:state %x\n",
-            state));
+        ql_dbg(ql_dbg_aer, vha, 0x9000,
+            "PCI error detected, state %x.\n", state);
 
         switch (state) {
         case pci_channel_io_normal:
@@ -3850,9 +4039,9 @@ qla2xxx_pci_error_detected(struct pci_dev *pdev, pci_channel_state_t state)
                         ha->flags.isp82xx_fw_hung = 1;
                         if (ha->flags.mbox_busy) {
                                 ha->flags.mbox_int = 1;
-                                DEBUG2(qla_printk(KERN_ERR, ha,
-                                        "Due to pci channel io frozen, doing premature "
-                                        "completion of mbx command\n"));
+                                ql_dbg(ql_dbg_aer, vha, 0x9001,
+                                    "Due to pci channel io frozen, doing premature "
+                                    "completion of mbx command.\n");
                                 complete(&ha->mbx_intr_comp);
                         }
                 }
@@ -3900,8 +4089,8 @@ qla2xxx_pci_mmio_enabled(struct pci_dev *pdev)
         spin_unlock_irqrestore(&ha->hardware_lock, flags);
 
         if (risc_paused) {
-                qla_printk(KERN_INFO, ha, "RISC paused -- mmio_enabled, "
-                    "Dumping firmware!\n");
+                ql_log(ql_log_info, base_vha, 0x9003,
+                    "RISC paused -- mmio_enabled, Dumping firmware.\n");
                 ha->isp_ops->fw_dump(base_vha, 0);
 
                 return PCI_ERS_RESULT_NEED_RESET;
@@ -3917,8 +4106,8 @@ uint32_t qla82xx_error_recovery(scsi_qla_host_t *base_vha)
         int fn;
         struct pci_dev *other_pdev = NULL;
 
-        DEBUG17(qla_printk(KERN_INFO, ha,
-            "scsi(%ld): In qla82xx_error_recovery\n", base_vha->host_no));
+        ql_dbg(ql_dbg_aer, base_vha, 0x9006,
+            "Entered %s.\n", __func__);
 
         set_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);
 
@@ -3932,8 +4121,8 @@ uint32_t qla82xx_error_recovery(scsi_qla_host_t *base_vha)
         fn = PCI_FUNC(ha->pdev->devfn);
         while (fn > 0) {
                 fn--;
-                DEBUG17(qla_printk(KERN_INFO, ha,
-                    "Finding pci device at function = 0x%x\n", fn));
+                ql_dbg(ql_dbg_aer, base_vha, 0x9007,
+                    "Finding pci device at function = 0x%x.\n", fn);
                 other_pdev =
                     pci_get_domain_bus_and_slot(pci_domain_nr(ha->pdev->bus),
                     ha->pdev->bus->number, PCI_DEVFN(PCI_SLOT(ha->pdev->devfn),
@@ -3942,9 +4131,9 @@ uint32_t qla82xx_error_recovery(scsi_qla_host_t *base_vha)
                 if (!other_pdev)
                         continue;
                 if (atomic_read(&other_pdev->enable_cnt)) {
-                        DEBUG17(qla_printk(KERN_INFO, ha,
-                            "Found PCI func available and enabled at 0x%x\n",
-                            fn));
+                        ql_dbg(ql_dbg_aer, base_vha, 0x9008,
+                            "Found PCI func available and enable at 0x%x.\n",
+                            fn);
                         pci_dev_put(other_pdev);
                         break;
                 }
@@ -3953,8 +4142,9 @@ uint32_t qla82xx_error_recovery(scsi_qla_host_t *base_vha)
 
         if (!fn) {
                 /* Reset owner */
-                DEBUG17(qla_printk(KERN_INFO, ha,
-                    "This devfn is reset owner = 0x%x\n", ha->pdev->devfn));
+                ql_dbg(ql_dbg_aer, base_vha, 0x9009,
+                    "This devfn is reset owner = 0x%x.\n",
+                    ha->pdev->devfn);
                 qla82xx_idc_lock(ha);
 
                 qla82xx_wr_32(ha, QLA82XX_CRB_DEV_STATE,
@@ -3964,8 +4154,8 @@ uint32_t qla82xx_error_recovery(scsi_qla_host_t *base_vha)
                     QLA82XX_IDC_VERSION);
 
                 drv_active = qla82xx_rd_32(ha, QLA82XX_CRB_DRV_ACTIVE);
-                DEBUG17(qla_printk(KERN_INFO, ha,
-                    "drv_active = 0x%x\n", drv_active));
+                ql_dbg(ql_dbg_aer, base_vha, 0x900a,
+                    "drv_active = 0x%x.\n", drv_active);
 
                 qla82xx_idc_unlock(ha);
                 /* Reset if device is not already reset
@@ -3978,12 +4168,14 @@ uint32_t qla82xx_error_recovery(scsi_qla_host_t *base_vha)
                 qla82xx_idc_lock(ha);
 
                 if (rval != QLA_SUCCESS) {
-                        qla_printk(KERN_INFO, ha, "HW State: FAILED\n");
+                        ql_log(ql_log_info, base_vha, 0x900b,
+                            "HW State: FAILED.\n");
                         qla82xx_clear_drv_active(ha);
                         qla82xx_wr_32(ha, QLA82XX_CRB_DEV_STATE,
                             QLA82XX_DEV_FAILED);
                 } else {
-                        qla_printk(KERN_INFO, ha, "HW State: READY\n");
+                        ql_log(ql_log_info, base_vha, 0x900c,
+                            "HW State: READY.\n");
                         qla82xx_wr_32(ha, QLA82XX_CRB_DEV_STATE,
                             QLA82XX_DEV_READY);
                         qla82xx_idc_unlock(ha);
@@ -3996,8 +4188,9 @@ uint32_t qla82xx_error_recovery(scsi_qla_host_t *base_vha)
                 }
                 qla82xx_idc_unlock(ha);
         } else {
-                DEBUG17(qla_printk(KERN_INFO, ha,
-                    "This devfn is not reset owner = 0x%x\n", ha->pdev->devfn));
+                ql_dbg(ql_dbg_aer, base_vha, 0x900d,
+                    "This devfn is not reset owner = 0x%x.\n",
+                    ha->pdev->devfn);
                 if ((qla82xx_rd_32(ha, QLA82XX_CRB_DEV_STATE) ==
                     QLA82XX_DEV_READY)) {
                         ha->flags.isp82xx_fw_hung = 0;
@@ -4021,7 +4214,8 @@ qla2xxx_pci_slot_reset(struct pci_dev *pdev)
         struct rsp_que *rsp;
         int rc, retries = 10;
 
-        DEBUG17(qla_printk(KERN_WARNING, ha, "slot_reset\n"));
+        ql_dbg(ql_dbg_aer, base_vha, 0x9004,
+            "Slot Reset.\n");
 
         /* Workaround: qla2xxx driver which access hardware earlier
          * needs error state to be pci_channel_io_online.
@@ -4042,7 +4236,7 @@ qla2xxx_pci_slot_reset(struct pci_dev *pdev)
                 rc = pci_enable_device(pdev);
 
         if (rc) {
-                qla_printk(KERN_WARNING, ha,
+                ql_log(ql_log_warn, base_vha, 0x9005,
                     "Can't re-enable PCI device after reset.\n");
                 goto exit_slot_reset;
         }
@@ -4072,8 +4266,8 @@ qla2xxx_pci_slot_reset(struct pci_dev *pdev)
 
 
 exit_slot_reset:
-        DEBUG17(qla_printk(KERN_WARNING, ha,
-            "slot_reset-return:ret=%x\n", ret));
+        ql_dbg(ql_dbg_aer, base_vha, 0x900e,
+            "slot_reset return %x.\n", ret);
 
         return ret;
 }
@@ -4085,13 +4279,13 @@ qla2xxx_pci_resume(struct pci_dev *pdev)
         struct qla_hw_data *ha = base_vha->hw;
         int ret;
 
-        DEBUG17(qla_printk(KERN_WARNING, ha, "pci_resume\n"));
+        ql_dbg(ql_dbg_aer, base_vha, 0x900f,
+            "pci_resume.\n");
 
         ret = qla2x00_wait_for_hba_online(base_vha);
         if (ret != QLA_SUCCESS) {
-                qla_printk(KERN_ERR, ha,
-                    "the device failed to resume I/O "
-                    "from slot/link_reset");
+                ql_log(ql_log_fatal, base_vha, 0x9002,
+                    "The device failed to resume I/O from slot/link_reset.\n");
         }
 
         pci_cleanup_aer_uncorrect_error_status(pdev);
@@ -4155,8 +4349,8 @@ qla2x00_module_init(void)
         srb_cachep = kmem_cache_create("qla2xxx_srbs", sizeof(srb_t), 0,
             SLAB_HWCACHE_ALIGN, NULL);
         if (srb_cachep == NULL) {
-                printk(KERN_ERR
-                    "qla2xxx: Unable to allocate SRB cache...Failing load!\n");
+                ql_log(ql_log_fatal, NULL, 0x0001,
+                    "Unable to allocate SRB cache...Failing load!.\n");
                 return -ENOMEM;
         }
 
@@ -4169,13 +4363,15 @@ qla2x00_module_init(void)
             fc_attach_transport(&qla2xxx_transport_functions);
         if (!qla2xxx_transport_template) {
                 kmem_cache_destroy(srb_cachep);
+                ql_log(ql_log_fatal, NULL, 0x0002,
+                    "fc_attach_transport failed...Failing load!.\n");
                 return -ENODEV;
         }
 
         apidev_major = register_chrdev(0, QLA2XXX_APIDEV, &apidev_fops);
         if (apidev_major < 0) {
-                printk(KERN_WARNING "qla2xxx: Unable to register char device "
-                    "%s\n", QLA2XXX_APIDEV);
+                ql_log(ql_log_fatal, NULL, 0x0003,
+                    "Unable to register char device %s.\n", QLA2XXX_APIDEV);
         }
 
         qla2xxx_transport_vport_template =
@@ -4183,16 +4379,21 @@ qla2x00_module_init(void)
         if (!qla2xxx_transport_vport_template) {
                 kmem_cache_destroy(srb_cachep);
                 fc_release_transport(qla2xxx_transport_template);
+                ql_log(ql_log_fatal, NULL, 0x0004,
+                    "fc_attach_transport vport failed...Failing load!.\n");
                 return -ENODEV;
         }
-
-        printk(KERN_INFO "QLogic Fibre Channel HBA Driver: %s\n",
+        ql_log(ql_log_info, NULL, 0x0005,
+            "QLogic Fibre Channel HBA Driver: %s.\n",
             qla2x00_version_str);
         ret = pci_register_driver(&qla2xxx_pci_driver);
         if (ret) {
                 kmem_cache_destroy(srb_cachep);
                 fc_release_transport(qla2xxx_transport_template);
                 fc_release_transport(qla2xxx_transport_vport_template);
+                ql_log(ql_log_fatal, NULL, 0x0006,
+                    "pci_register_driver failed...ret=%d Failing load!.\n",
+                    ret);
         }
         return ret;
 }
diff --git a/drivers/scsi/qla2xxx/qla_sup.c b/drivers/scsi/qla2xxx/qla_sup.c
index 693647661ed1..eff13563c82d 100644
--- a/drivers/scsi/qla2xxx/qla_sup.c
+++ b/drivers/scsi/qla2xxx/qla_sup.c
@@ -189,6 +189,7 @@ qla2x00_write_nvram_word(struct qla_hw_data *ha, uint32_t addr, uint16_t data)
         uint16_t word;
         uint32_t nv_cmd, wait_cnt;
         struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
+        scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
 
         qla2x00_nv_write(ha, NVR_DATA_OUT);
         qla2x00_nv_write(ha, 0);
@@ -220,8 +221,8 @@ qla2x00_write_nvram_word(struct qla_hw_data *ha, uint32_t addr, uint16_t data)
         wait_cnt = NVR_WAIT_CNT;
         do {
                 if (!--wait_cnt) {
-                        DEBUG9_10(qla_printk(KERN_WARNING, ha,
-                            "NVRAM didn't go ready...\n"));
+                        ql_dbg(ql_dbg_user, vha, 0x708d,
+                            "NVRAM didn't go ready...\n");
                         break;
                 }
                 NVRAM_DELAY();
@@ -308,6 +309,7 @@ qla2x00_clear_nvram_protection(struct qla_hw_data *ha)
         struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
         uint32_t word, wait_cnt;
         uint16_t wprot, wprot_old;
+        scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
 
         /* Clear NVRAM write protection. */
         ret = QLA_FUNCTION_FAILED;
@@ -350,8 +352,8 @@ qla2x00_clear_nvram_protection(struct qla_hw_data *ha)
                 wait_cnt = NVR_WAIT_CNT;
                 do {
                         if (!--wait_cnt) {
-                                DEBUG9_10(qla_printk(KERN_WARNING, ha,
-                                    "NVRAM didn't go ready...\n"));
+                                ql_dbg(ql_dbg_user, vha, 0x708e,
+                                    "NVRAM didn't go ready...\n");
                                 break;
                         }
                         NVRAM_DELAY();
@@ -371,6 +373,7 @@ qla2x00_set_nvram_protection(struct qla_hw_data *ha, int stat)
 {
         struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
         uint32_t word, wait_cnt;
+        scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev);
 
         if (stat != QLA_SUCCESS)
                 return;
@@ -409,8 +412,8 @@ qla2x00_set_nvram_protection(struct qla_hw_data *ha, int stat)
         wait_cnt = NVR_WAIT_CNT;
         do {
                 if (!--wait_cnt) {
-                        DEBUG9_10(qla_printk(KERN_WARNING, ha,
-                            "NVRAM didn't go ready...\n"));
+                        ql_dbg(ql_dbg_user, vha, 0x708f,
+                            "NVRAM didn't go ready...\n");
                         break;
                 }
                 NVRAM_DELAY();
@@ -607,9 +610,10 @@ qla2xxx_find_flt_start(scsi_qla_host_t *vha, uint32_t *start)
         for (chksum = 0; cnt; cnt--)
                 chksum += le16_to_cpu(*wptr++);
         if (chksum) {
-                qla_printk(KERN_ERR, ha,
+                ql_log(ql_log_fatal, vha, 0x0045,
                     "Inconsistent FLTL detected: checksum=0x%x.\n", chksum);
-                qla2x00_dump_buffer(buf, sizeof(struct qla_flt_location));
+                ql_dump_buffer(ql_dbg_init + ql_dbg_buffer, vha, 0x010e,
+                    buf, sizeof(struct qla_flt_location));
                 return QLA_FUNCTION_FAILED;
         }
 
@@ -618,7 +622,9 @@ qla2xxx_find_flt_start(scsi_qla_host_t *vha, uint32_t *start)
         *start = (le16_to_cpu(fltl->start_hi) << 16 |
             le16_to_cpu(fltl->start_lo)) >> 2;
 end:
-        DEBUG2(qla_printk(KERN_DEBUG, ha, "FLTL[%s] = 0x%x.\n", loc, *start));
+        ql_dbg(ql_dbg_init, vha, 0x0046,
+            "FLTL[%s] = 0x%x.\n",
+            loc, *start);
         return QLA_SUCCESS;
 }
 
@@ -685,10 +691,10 @@ qla2xxx_get_flt_info(scsi_qla_host_t *vha, uint32_t flt_addr)
         if (*wptr == __constant_cpu_to_le16(0xffff))
                 goto no_flash_data;
         if (flt->version != __constant_cpu_to_le16(1)) {
-                DEBUG2(qla_printk(KERN_INFO, ha, "Unsupported FLT detected: "
-                    "version=0x%x length=0x%x checksum=0x%x.\n",
+                ql_log(ql_log_warn, vha, 0x0047,
+                    "Unsupported FLT detected: version=0x%x length=0x%x checksum=0x%x.\n",
                     le16_to_cpu(flt->version), le16_to_cpu(flt->length),
-                    le16_to_cpu(flt->checksum)));
+                    le16_to_cpu(flt->checksum));
                 goto no_flash_data;
         }
 
@@ -696,10 +702,10 @@ qla2xxx_get_flt_info(scsi_qla_host_t *vha, uint32_t flt_addr)
         for (chksum = 0; cnt; cnt--)
                 chksum += le16_to_cpu(*wptr++);
         if (chksum) {
-                DEBUG2(qla_printk(KERN_INFO, ha, "Inconsistent FLT detected: "
-                    "version=0x%x length=0x%x checksum=0x%x.\n",
+                ql_log(ql_log_fatal, vha, 0x0048,
+                    "Inconsistent FLT detected: version=0x%x length=0x%x checksum=0x%x.\n",
                     le16_to_cpu(flt->version), le16_to_cpu(flt->length),
-                    chksum));
+                    le16_to_cpu(flt->checksum));
                 goto no_flash_data;
         }
 
@@ -708,10 +714,11 @@ qla2xxx_get_flt_info(scsi_qla_host_t *vha, uint32_t flt_addr)
         for ( ; cnt; cnt--, region++) {
                 /* Store addresses as DWORD offsets. */
                 start = le32_to_cpu(region->start) >> 2;
-
-                DEBUG3(qla_printk(KERN_DEBUG, ha, "FLT[%02x]: start=0x%x "
-                    "end=0x%x size=0x%x.\n", le32_to_cpu(region->code), start,
-                    le32_to_cpu(region->end) >> 2, le32_to_cpu(region->size)));
+                ql_dbg(ql_dbg_init, vha, 0x0049,
+                    "FLT[%02x]: start=0x%x "
+                    "end=0x%x size=0x%x.\n", le32_to_cpu(region->code),
+                    start, le32_to_cpu(region->end) >> 2,
+                    le32_to_cpu(region->size));
 
                 switch (le32_to_cpu(region->code) & 0xff) {
                 case FLT_REG_FW:
@@ -796,12 +803,16 @@ no_flash_data:
         ha->flt_region_npiv_conf = ha->flags.port0 ?
             def_npiv_conf0[def] : def_npiv_conf1[def];
 done:
-        DEBUG2(qla_printk(KERN_DEBUG, ha, "FLT[%s]: boot=0x%x fw=0x%x "
-            "vpd_nvram=0x%x vpd=0x%x nvram=0x%x fdt=0x%x flt=0x%x "
-            "npiv=0x%x. fcp_prio_cfg=0x%x\n", loc, ha->flt_region_boot,
-            ha->flt_region_fw, ha->flt_region_vpd_nvram, ha->flt_region_vpd,
-            ha->flt_region_nvram, ha->flt_region_fdt, ha->flt_region_flt,
-            ha->flt_region_npiv_conf, ha->flt_region_fcp_prio));
+        ql_dbg(ql_dbg_init, vha, 0x004a,
+            "FLT[%s]: boot=0x%x fw=0x%x vpd_nvram=0x%x vpd=0x%x.\n",
+            loc, ha->flt_region_boot,
+            ha->flt_region_fw, ha->flt_region_vpd_nvram,
+            ha->flt_region_vpd);
+        ql_dbg(ql_dbg_init, vha, 0x004b,
+            "nvram=0x%x fdt=0x%x flt=0x%x npiv=0x%x fcp_prif_cfg=0x%x.\n",
+            ha->flt_region_nvram,
+            ha->flt_region_fdt, ha->flt_region_flt,
+            ha->flt_region_npiv_conf, ha->flt_region_fcp_prio);
 }
 
 static void
@@ -833,10 +844,12 @@ qla2xxx_get_fdt_info(scsi_qla_host_t *vha)
             cnt++)
                 chksum += le16_to_cpu(*wptr++);
         if (chksum) {
-                DEBUG2(qla_printk(KERN_INFO, ha, "Inconsistent FDT detected: "
-                    "checksum=0x%x id=%c version=0x%x.\n", chksum, fdt->sig[0],
-                    le16_to_cpu(fdt->version)));
-                DEBUG9(qla2x00_dump_buffer((uint8_t *)fdt, sizeof(*fdt)));
+                ql_dbg(ql_dbg_init, vha, 0x004c,
+                    "Inconsistent FDT detected:"
+                    " checksum=0x%x id=%c version0x%x.\n", chksum,
+                    fdt->sig[0], le16_to_cpu(fdt->version));
+                ql_dump_buffer(ql_dbg_init + ql_dbg_buffer, vha, 0x0113,
+                    (uint8_t *)fdt, sizeof(*fdt));
                 goto no_flash_data;
         }
 
@@ -890,11 +903,12 @@ no_flash_data:
                 break;
         }
 done:
-        DEBUG2(qla_printk(KERN_DEBUG, ha, "FDT[%s]: (0x%x/0x%x) erase=0x%x "
-            "pro=%x upro=%x wrtd=0x%x blk=0x%x.\n", loc, mid, fid,
+        ql_dbg(ql_dbg_init, vha, 0x004d,
+            "FDT[%x]: (0x%x/0x%x) erase=0x%x "
+            "pr=%x upro=%x wrtd=0x%x blk=0x%x.\n", loc, mid, fid,
             ha->fdt_erase_cmd, ha->fdt_protect_sec_cmd,
-            ha->fdt_unprotect_sec_cmd, ha->fdt_wrt_disable,
-            ha->fdt_block_size));
+            ha->fdt_wrt_disable, ha->fdt_block_size);
+
 }
 
 static void
@@ -919,6 +933,10 @@ qla2xxx_get_idc_param(scsi_qla_host_t *vha)
                 ha->nx_dev_init_timeout = le32_to_cpu(*wptr++);
                 ha->nx_reset_timeout = le32_to_cpu(*wptr);
         }
+        ql_dbg(ql_dbg_init, vha, 0x004e,
+            "nx_dev_init_timeout=%d "
+            "nx_reset_timeout=%d.\n", ha->nx_dev_init_timeout,
+            ha->nx_reset_timeout);
         return;
 }
 
@@ -963,17 +981,18 @@ qla2xxx_flash_npiv_conf(scsi_qla_host_t *vha)
         if (hdr.version == __constant_cpu_to_le16(0xffff))
                 return;
         if (hdr.version != __constant_cpu_to_le16(1)) {
-                DEBUG2(qla_printk(KERN_INFO, ha, "Unsupported NPIV-Config "
+                ql_dbg(ql_dbg_user, vha, 0x7090,
+                    "Unsupported NPIV-Config "
                     "detected: version=0x%x entries=0x%x checksum=0x%x.\n",
                     le16_to_cpu(hdr.version), le16_to_cpu(hdr.entries),
-                    le16_to_cpu(hdr.checksum)));
+                    le16_to_cpu(hdr.checksum));
                 return;
         }
 
         data = kmalloc(NPIV_CONFIG_SIZE, GFP_KERNEL);
         if (!data) {
-                DEBUG2(qla_printk(KERN_INFO, ha, "NPIV-Config: Unable to "
-                    "allocate memory.\n"));
+                ql_log(ql_log_warn, vha, 0x7091,
+                    "Unable to allocate memory for data.\n");
                 return;
         }
 
@@ -985,10 +1004,11 @@ qla2xxx_flash_npiv_conf(scsi_qla_host_t *vha)
         for (wptr = data, chksum = 0; cnt; cnt--)
                 chksum += le16_to_cpu(*wptr++);
         if (chksum) {
-                DEBUG2(qla_printk(KERN_INFO, ha, "Inconsistent NPIV-Config "
+                ql_dbg(ql_dbg_user, vha, 0x7092,
+                    "Inconsistent NPIV-Config "
                     "detected: version=0x%x entries=0x%x checksum=0x%x.\n",
                     le16_to_cpu(hdr.version), le16_to_cpu(hdr.entries),
-                    chksum));
+                    le16_to_cpu(hdr.checksum));
                 goto done;
         }
 
@@ -1014,21 +1034,22 @@ qla2xxx_flash_npiv_conf(scsi_qla_host_t *vha)
                 vid.port_name = wwn_to_u64(entry->port_name);
                 vid.node_name = wwn_to_u64(entry->node_name);
 
-                DEBUG2(qla_printk(KERN_INFO, ha, "NPIV[%02x]: wwpn=%llx "
-                        "wwnn=%llx vf_id=0x%x Q_qos=0x%x F_qos=0x%x.\n", cnt,
-                        (unsigned long long)vid.port_name,
-                        (unsigned long long)vid.node_name,
-                        le16_to_cpu(entry->vf_id),
-                        entry->q_qos, entry->f_qos));
+                ql_dbg(ql_dbg_user, vha, 0x7093,
+                    "NPIV[%02x]: wwpn=%llx "
+                    "wwnn=%llx vf_id=0x%x Q_qos=0x%x F_qos=0x%x.\n", cnt,
+                    (unsigned long long)vid.port_name,
+                    (unsigned long long)vid.node_name,
+                    le16_to_cpu(entry->vf_id),
+                    entry->q_qos, entry->f_qos);
 
                 if (i < QLA_PRECONFIG_VPORTS) {
                         vport = fc_vport_create(vha->host, 0, &vid);
                         if (!vport)
-                                qla_printk(KERN_INFO, ha,
-                                "NPIV-Config: Failed to create vport [%02x]: "
-                                "wwpn=%llx wwnn=%llx.\n", cnt,
-                                (unsigned long long)vid.port_name,
-                                (unsigned long long)vid.node_name);
+                                ql_log(ql_log_warn, vha, 0x7094,
+                                    "NPIV-Config Failed to create vport [%02x]: "
+                                    "wwpn=%llx wwnn=%llx.\n", cnt,
+                                    (unsigned long long)vid.port_name,
+                                    (unsigned long long)vid.node_name);
                 }
         }
 done:
@@ -1127,9 +1148,10 @@ qla24xx_write_flash_data(scsi_qla_host_t *vha, uint32_t *dwptr, uint32_t faddr,
                 optrom = dma_alloc_coherent(&ha->pdev->dev, OPTROM_BURST_SIZE,
                     &optrom_dma, GFP_KERNEL);
                 if (!optrom) {
-                        qla_printk(KERN_DEBUG, ha,
-                            "Unable to allocate memory for optrom burst write "
-                            "(%x KB).\n", OPTROM_BURST_SIZE / 1024);
+                        ql_log(ql_log_warn, vha, 0x7095,
+                            "Unable to allocate "
+                            "memory for optrom burst write (%x KB).\n",
+                            OPTROM_BURST_SIZE / 1024);
                 }
         }
 
@@ -1138,7 +1160,7 @@ qla24xx_write_flash_data(scsi_qla_host_t *vha, uint32_t *dwptr, uint32_t faddr,
 
         ret = qla24xx_unprotect_flash(vha);
         if (ret != QLA_SUCCESS) {
-                qla_printk(KERN_WARNING, ha,
+                ql_log(ql_log_warn, vha, 0x7096,
                     "Unable to unprotect flash for update.\n");
                 goto done;
         }
@@ -1156,9 +1178,9 @@ qla24xx_write_flash_data(scsi_qla_host_t *vha, uint32_t *dwptr, uint32_t faddr,
                                     0xff0000) | ((fdata >> 16) & 0xff));
                         ret = qla24xx_erase_sector(vha, fdata);
                         if (ret != QLA_SUCCESS) {
-                                DEBUG9(qla_printk(KERN_WARNING, ha,
-                                    "Unable to erase sector: address=%x.\n",
-                                    faddr));
+                                ql_dbg(ql_dbg_user, vha, 0x7007,
+                                    "Unable to erase erase sector: address=%x.\n",
+                                    faddr);
                                 break;
                         }
                 }
@@ -1172,12 +1194,12 @@ qla24xx_write_flash_data(scsi_qla_host_t *vha, uint32_t *dwptr, uint32_t faddr,
                             flash_data_addr(ha, faddr),
                             OPTROM_BURST_DWORDS);
                         if (ret != QLA_SUCCESS) {
-                                qla_printk(KERN_WARNING, ha,
+                                ql_log(ql_log_warn, vha, 0x7097,
                                     "Unable to burst-write optrom segment "
                                     "(%x/%x/%llx).\n", ret,
                                     flash_data_addr(ha, faddr),
                                     (unsigned long long)optrom_dma);
-                                qla_printk(KERN_WARNING, ha,
+                                ql_log(ql_log_warn, vha, 0x7098,
                                     "Reverting to slow-write.\n");
 
                                 dma_free_coherent(&ha->pdev->dev,
@@ -1194,9 +1216,9 @@ qla24xx_write_flash_data(scsi_qla_host_t *vha, uint32_t *dwptr, uint32_t faddr,
                 ret = qla24xx_write_flash_dword(ha,
                     flash_data_addr(ha, faddr), cpu_to_le32(*dwptr));
                 if (ret != QLA_SUCCESS) {
-                        DEBUG9(printk("%s(%ld) Unable to program flash "
-                            "address=%x data=%x.\n", __func__,
-                            vha->host_no, faddr, *dwptr));
+                        ql_dbg(ql_dbg_user, vha, 0x7006,
+                            "Unable to program flash address=%x data=%x.\n",
+                            faddr, *dwptr);
                         break;
                 }
 
@@ -1211,7 +1233,7 @@ qla24xx_write_flash_data(scsi_qla_host_t *vha, uint32_t *dwptr, uint32_t faddr,
 
         ret = qla24xx_protect_flash(vha);
         if (ret != QLA_SUCCESS)
-                qla_printk(KERN_WARNING, ha,
+                ql_log(ql_log_warn, vha, 0x7099,
                     "Unable to protect flash after update.\n");
 done:
         if (optrom)
@@ -1324,9 +1346,9 @@ qla24xx_write_nvram_data(scsi_qla_host_t *vha, uint8_t *buf, uint32_t naddr,
                 ret = qla24xx_write_flash_dword(ha,
                     nvram_data_addr(ha, naddr), cpu_to_le32(*dwptr));
                 if (ret != QLA_SUCCESS) {
-                        DEBUG9(qla_printk(KERN_WARNING, ha,
+                        ql_dbg(ql_dbg_user, vha, 0x709a,
                             "Unable to program nvram address=%x data=%x.\n",
-                            naddr, *dwptr));
+                            naddr, *dwptr);
                         break;
                 }
         }
@@ -1476,7 +1498,7 @@ qla2x00_beacon_on(struct scsi_qla_host *vha)
         ha->fw_options[1] |= FO1_DISABLE_GPIO6_7;
 
         if (qla2x00_set_fw_options(vha, ha->fw_options) != QLA_SUCCESS) {
-                qla_printk(KERN_WARNING, ha,
+                ql_log(ql_log_warn, vha, 0x709b,
                     "Unable to update fw options (beacon on).\n");
                 return QLA_FUNCTION_FAILED;
         }
@@ -1541,7 +1563,7 @@ qla2x00_beacon_off(struct scsi_qla_host *vha)
 
         rval = qla2x00_set_fw_options(vha, ha->fw_options);
         if (rval != QLA_SUCCESS)
-                qla_printk(KERN_WARNING, ha,
+                ql_log(ql_log_warn, vha, 0x709c,
                     "Unable to update fw options (beacon off).\n");
         return rval;
 }
@@ -1616,7 +1638,7 @@ qla24xx_beacon_on(struct scsi_qla_host *vha)
 
                 if (qla2x00_get_fw_options(vha, ha->fw_options) !=
                     QLA_SUCCESS) {
-                        qla_printk(KERN_WARNING, ha,
+                        ql_log(ql_log_warn, vha, 0x7009,
                             "Unable to update fw options (beacon on).\n");
                         return QLA_FUNCTION_FAILED;
                 }
@@ -1670,14 +1692,14 @@ qla24xx_beacon_off(struct scsi_qla_host *vha)
         ha->fw_options[1] &= ~ADD_FO1_DISABLE_GPIO_LED_CTRL;
 
         if (qla2x00_set_fw_options(vha, ha->fw_options) != QLA_SUCCESS) {
-                qla_printk(KERN_WARNING, ha,
-                    "Unable to update fw options (beacon off).\n");
+                ql_log(ql_log_warn, vha, 0x704d,
+                    "Unable to update fw options (beacon on).\n");
                 return QLA_FUNCTION_FAILED;
         }
 
         if (qla2x00_get_fw_options(vha, ha->fw_options) != QLA_SUCCESS) {
-                qla_printk(KERN_WARNING, ha,
-                    "Unable to get fw options (beacon off).\n");
+                ql_log(ql_log_warn, vha, 0x704e,
+                    "Unable to update fw options (beacon on).\n");
                 return QLA_FUNCTION_FAILED;
         }
 
@@ -2389,10 +2411,9 @@ try_fast:
         optrom = dma_alloc_coherent(&ha->pdev->dev, OPTROM_BURST_SIZE,
             &optrom_dma, GFP_KERNEL);
         if (!optrom) {
-                qla_printk(KERN_DEBUG, ha,
-                    "Unable to allocate memory for optrom burst read "
-                    "(%x KB).\n", OPTROM_BURST_SIZE / 1024);
-
+                ql_log(ql_log_warn, vha, 0x00cc,
+                    "Unable to allocate memory for optrom burst read (%x KB).\n",
+                    OPTROM_BURST_SIZE / 1024);
                 goto slow_read;
         }
 
@@ -2407,12 +2428,11 @@ try_fast:
                 rval = qla2x00_dump_ram(vha, optrom_dma,
                     flash_data_addr(ha, faddr), burst);
                 if (rval) {
-                        qla_printk(KERN_WARNING, ha,
-                            "Unable to burst-read optrom segment "
-                            "(%x/%x/%llx).\n", rval,
-                            flash_data_addr(ha, faddr),
+                        ql_log(ql_log_warn, vha, 0x00f5,
+                            "Unable to burst-read optrom segment (%x/%x/%llx).\n",
+                            rval, flash_data_addr(ha, faddr),
                             (unsigned long long)optrom_dma);
-                        qla_printk(KERN_WARNING, ha,
+                        ql_log(ql_log_warn, vha, 0x00f6,
                             "Reverting to slow-read.\n");
 
                         dma_free_coherent(&ha->pdev->dev, OPTROM_BURST_SIZE,
@@ -2556,8 +2576,8 @@ qla2x00_get_flash_version(scsi_qla_host_t *vha, void *mbuf)
                 if (qla2x00_read_flash_byte(ha, pcihdr) != 0x55 ||
                     qla2x00_read_flash_byte(ha, pcihdr + 0x01) != 0xaa) {
                         /* No signature */
-                        DEBUG2(qla_printk(KERN_DEBUG, ha, "No matching ROM "
-                            "signature.\n"));
+                        ql_log(ql_log_fatal, vha, 0x0050,
+                            "No matching ROM signature.\n");
                         ret = QLA_FUNCTION_FAILED;
                         break;
                 }
@@ -2573,8 +2593,8 @@ qla2x00_get_flash_version(scsi_qla_host_t *vha, void *mbuf)
                     qla2x00_read_flash_byte(ha, pcids + 0x2) != 'I' ||
                     qla2x00_read_flash_byte(ha, pcids + 0x3) != 'R') {
                         /* Incorrect header. */
-                        DEBUG2(qla_printk(KERN_INFO, ha, "PCI data struct not "
-                            "found pcir_adr=%x.\n", pcids));
+                        ql_log(ql_log_fatal, vha, 0x0051,
+                            "PCI data struct not found pcir_adr=%x.\n", pcids);
                         ret = QLA_FUNCTION_FAILED;
                         break;
                 }
@@ -2588,8 +2608,9 @@ qla2x00_get_flash_version(scsi_qla_host_t *vha, void *mbuf)
                             qla2x00_read_flash_byte(ha, pcids + 0x12);
                         ha->bios_revision[1] =
                             qla2x00_read_flash_byte(ha, pcids + 0x13);
-                        DEBUG3(qla_printk(KERN_DEBUG, ha, "read BIOS %d.%d.\n",
-                            ha->bios_revision[1], ha->bios_revision[0]));
+                        ql_dbg(ql_dbg_init, vha, 0x0052,
+                            "Read BIOS %d.%d.\n",
+                            ha->bios_revision[1], ha->bios_revision[0]);
                         break;
                 case ROM_CODE_TYPE_FCODE:
                         /* Open Firmware standard for PCI (FCode). */
@@ -2602,12 +2623,14 @@ qla2x00_get_flash_version(scsi_qla_host_t *vha, void *mbuf)
                             qla2x00_read_flash_byte(ha, pcids + 0x12);
                         ha->efi_revision[1] =
                             qla2x00_read_flash_byte(ha, pcids + 0x13);
-                        DEBUG3(qla_printk(KERN_DEBUG, ha, "read EFI %d.%d.\n",
-                            ha->efi_revision[1], ha->efi_revision[0]));
+                        ql_dbg(ql_dbg_init, vha, 0x0053,
+                            "Read EFI %d.%d.\n",
+                            ha->efi_revision[1], ha->efi_revision[0]);
                         break;
                 default:
-                        DEBUG2(qla_printk(KERN_INFO, ha, "Unrecognized code "
-                            "type %x at pcids %x.\n", code_type, pcids));
+                        ql_log(ql_log_warn, vha, 0x0054,
+                            "Unrecognized code type %x at pcids %x.\n",
+                            code_type, pcids);
                         break;
                 }
 
@@ -2627,21 +2650,28 @@ qla2x00_get_flash_version(scsi_qla_host_t *vha, void *mbuf)
 
                 qla2x00_read_flash_data(ha, dbyte, ha->flt_region_fw * 4 + 10,
                     8);
-                DEBUG3(qla_printk(KERN_DEBUG, ha, "dumping fw ver from "
-                    "flash:\n"));
-                DEBUG3(qla2x00_dump_buffer((uint8_t *)dbyte, 8));
+                ql_dbg(ql_dbg_init + ql_dbg_buffer, vha, 0x010a,
+                    "Dumping fw "
+                    "ver from flash:.\n");
+                ql_dump_buffer(ql_dbg_init + ql_dbg_buffer, vha, 0x010b,
+                    (uint8_t *)dbyte, 8);
 
                 if ((dcode[0] == 0xffff && dcode[1] == 0xffff &&
                     dcode[2] == 0xffff && dcode[3] == 0xffff) ||
                     (dcode[0] == 0 && dcode[1] == 0 && dcode[2] == 0 &&
                     dcode[3] == 0)) {
-                        DEBUG2(qla_printk(KERN_INFO, ha, "Unrecognized fw "
-                            "revision at %x.\n", ha->flt_region_fw * 4));
+                        ql_log(ql_log_warn, vha, 0x0057,
+                            "Unrecognized fw revision at %x.\n",
+                            ha->flt_region_fw * 4);
                 } else {
                         /* values are in big endian */
                         ha->fw_revision[0] = dbyte[0] << 16 | dbyte[1];
                         ha->fw_revision[1] = dbyte[2] << 16 | dbyte[3];
                         ha->fw_revision[2] = dbyte[4] << 16 | dbyte[5];
+                        ql_dbg(ql_dbg_init, vha, 0x0058,
+                            "FW Version: "
+                            "%d.%d.%d.\n", ha->fw_revision[0],
+                            ha->fw_revision[1], ha->fw_revision[2]);
                 }
         }
 
@@ -2683,8 +2713,8 @@ qla24xx_get_flash_version(scsi_qla_host_t *vha, void *mbuf)
                 bcode = mbuf + (pcihdr % 4);
                 if (bcode[0x0] != 0x55 || bcode[0x1] != 0xaa) {
                         /* No signature */
-                        DEBUG2(qla_printk(KERN_DEBUG, ha, "No matching ROM "
-                            "signature.\n"));
+                        ql_log(ql_log_fatal, vha, 0x0059,
+                            "No matching ROM signature.\n");
                         ret = QLA_FUNCTION_FAILED;
                         break;
                 }
@@ -2699,8 +2729,8 @@ qla24xx_get_flash_version(scsi_qla_host_t *vha, void *mbuf)
                 if (bcode[0x0] != 'P' || bcode[0x1] != 'C' ||
                     bcode[0x2] != 'I' || bcode[0x3] != 'R') {
                         /* Incorrect header. */
-                        DEBUG2(qla_printk(KERN_INFO, ha, "PCI data struct not "
-                            "found pcir_adr=%x.\n", pcids));
+                        ql_log(ql_log_fatal, vha, 0x005a,
+                            "PCI data struct not found pcir_adr=%x.\n", pcids);
                         ret = QLA_FUNCTION_FAILED;
                         break;
                 }
@@ -2712,26 +2742,30 @@ qla24xx_get_flash_version(scsi_qla_host_t *vha, void *mbuf)
                         /* Intel x86, PC-AT compatible. */
                         ha->bios_revision[0] = bcode[0x12];
                         ha->bios_revision[1] = bcode[0x13];
-                        DEBUG3(qla_printk(KERN_DEBUG, ha, "read BIOS %d.%d.\n",
-                            ha->bios_revision[1], ha->bios_revision[0]));
+                        ql_dbg(ql_dbg_init, vha, 0x005b,
+                            "Read BIOS %d.%d.\n",
+                            ha->bios_revision[1], ha->bios_revision[0]);
                         break;
                 case ROM_CODE_TYPE_FCODE:
                         /* Open Firmware standard for PCI (FCode). */
                         ha->fcode_revision[0] = bcode[0x12];
                         ha->fcode_revision[1] = bcode[0x13];
-                        DEBUG3(qla_printk(KERN_DEBUG, ha, "read FCODE %d.%d.\n",
-                            ha->fcode_revision[1], ha->fcode_revision[0]));
+                        ql_dbg(ql_dbg_init, vha, 0x005c,
+                            "Read FCODE %d.%d.\n",
+                            ha->fcode_revision[1], ha->fcode_revision[0]);
                         break;
                 case ROM_CODE_TYPE_EFI:
                         /* Extensible Firmware Interface (EFI). */
                         ha->efi_revision[0] = bcode[0x12];
                         ha->efi_revision[1] = bcode[0x13];
-                        DEBUG3(qla_printk(KERN_DEBUG, ha, "read EFI %d.%d.\n",
-                            ha->efi_revision[1], ha->efi_revision[0]));
+                        ql_dbg(ql_dbg_init, vha, 0x005d,
+                            "Read EFI %d.%d.\n",
+                            ha->efi_revision[1], ha->efi_revision[0]);
                         break;
                 default:
-                        DEBUG2(qla_printk(KERN_INFO, ha, "Unrecognized code "
-                            "type %x at pcids %x.\n", code_type, pcids));
+                        ql_log(ql_log_warn, vha, 0x005e,
+                            "Unrecognized code type %x at pcids %x.\n",
+                            code_type, pcids);
                         break;
                 }
 
@@ -2753,13 +2787,18 @@ qla24xx_get_flash_version(scsi_qla_host_t *vha, void *mbuf)
             dcode[2] == 0xffffffff && dcode[3] == 0xffffffff) ||
             (dcode[0] == 0 && dcode[1] == 0 && dcode[2] == 0 &&
             dcode[3] == 0)) {
-                DEBUG2(qla_printk(KERN_INFO, ha, "Unrecognized fw "
-                    "revision at %x.\n", ha->flt_region_fw * 4));
+                ql_log(ql_log_warn, vha, 0x005f,
+                    "Unrecognized fw revision at %x.\n",
+                    ha->flt_region_fw * 4);
         } else {
                 ha->fw_revision[0] = dcode[0];
                 ha->fw_revision[1] = dcode[1];
                 ha->fw_revision[2] = dcode[2];
                 ha->fw_revision[3] = dcode[3];
+                ql_dbg(ql_dbg_init, vha, 0x0060,
+                    "Firmware revision %d.%d.%d.%d.\n",
+                    ha->fw_revision[0], ha->fw_revision[1],
+                    ha->fw_revision[2], ha->fw_revision[3]);
         }
 
         /* Check for golden firmware and get version if available */
@@ -2775,9 +2814,9 @@ qla24xx_get_flash_version(scsi_qla_host_t *vha, void *mbuf)
 
         if (dcode[4] == 0xFFFFFFFF && dcode[5] == 0xFFFFFFFF &&
             dcode[6] == 0xFFFFFFFF && dcode[7] == 0xFFFFFFFF) {
-                DEBUG2(qla_printk(KERN_INFO, ha,
-                    "%s(%ld): Unrecognized golden fw at 0x%x.\n",
-                    __func__, vha->host_no, ha->flt_region_gold_fw * 4));
+                ql_log(ql_log_warn, vha, 0x0056,
+                    "Unrecognized golden fw at 0x%x.\n",
+                    ha->flt_region_gold_fw * 4);
                 return ret;
         }
 
@@ -2843,9 +2882,9 @@ qla24xx_read_fcp_prio_cfg(scsi_qla_host_t *vha)
         if (!ha->fcp_prio_cfg) {
                 ha->fcp_prio_cfg = vmalloc(FCP_PRIO_CFG_SIZE);
                 if (!ha->fcp_prio_cfg) {
-                        qla_printk(KERN_WARNING, ha,
-                        "Unable to allocate memory for fcp priority data "
-                                        "(%x).\n", FCP_PRIO_CFG_SIZE);
+                        ql_log(ql_log_warn, vha, 0x00d5,
+                            "Unable to allocate memory for fcp priorty data (%x).\n",
+                            FCP_PRIO_CFG_SIZE);
                         return QLA_FUNCTION_FAILED;
                 }
         }
@@ -2857,7 +2896,7 @@ qla24xx_read_fcp_prio_cfg(scsi_qla_host_t *vha)
         ha->isp_ops->read_optrom(vha, (uint8_t *)ha->fcp_prio_cfg,
                         fcp_prio_addr << 2, FCP_PRIO_CFG_HDR_SIZE);
 
-        if (!qla24xx_fcp_prio_cfg_valid(ha->fcp_prio_cfg, 0))
+        if (!qla24xx_fcp_prio_cfg_valid(vha, ha->fcp_prio_cfg, 0))
                 goto fail;
 
         /* read remaining FCP CMD config data from flash */
@@ -2869,7 +2908,7 @@ qla24xx_read_fcp_prio_cfg(scsi_qla_host_t *vha)
                         fcp_prio_addr << 2, (len < max_len ? len : max_len));
 
         /* revalidate the entire FCP priority config data, including entries */
-        if (!qla24xx_fcp_prio_cfg_valid(ha->fcp_prio_cfg, 1))
+        if (!qla24xx_fcp_prio_cfg_valid(vha, ha->fcp_prio_cfg, 1))
                 goto fail;
 
         ha->flags.fcp_prio_enabled = 1;
diff --git a/drivers/scsi/qla4xxx/Kconfig b/drivers/scsi/qla4xxx/Kconfig
index 2c33ce6eac1e..0f5599e0abf6 100644
--- a/drivers/scsi/qla4xxx/Kconfig
+++ b/drivers/scsi/qla4xxx/Kconfig
@@ -1,6 +1,6 @@
 config SCSI_QLA_ISCSI
         tristate "QLogic ISP4XXX and ISP82XX host adapter family support"
-        depends on PCI && SCSI
+        depends on PCI && SCSI && NET
         select SCSI_ISCSI_ATTRS
         ---help---
         This driver supports the QLogic 40xx (ISP4XXX) and 8022 (ISP82XX)
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index 28d9c9d6b4b4..fc3f168decb4 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -137,6 +137,7 @@ static int __scsi_queue_insert(struct scsi_cmnd *cmd, int reason, int unbusy)
                 host->host_blocked = host->max_host_blocked;
                 break;
         case SCSI_MLQUEUE_DEVICE_BUSY:
+        case SCSI_MLQUEUE_EH_RETRY:
                 device->device_blocked = device->max_device_blocked;
                 break;
         case SCSI_MLQUEUE_TARGET_BUSY:
diff --git a/drivers/scsi/scsi_transport_spi.c b/drivers/scsi/scsi_transport_spi.c
index 8a172d4f4564..5fbeadd96819 100644
--- a/drivers/scsi/scsi_transport_spi.c
+++ b/drivers/scsi/scsi_transport_spi.c
@@ -597,6 +597,28 @@ static DEVICE_ATTR(signalling, S_IRUGO,
                    show_spi_host_signalling,
                    store_spi_host_signalling);
 
+static ssize_t show_spi_host_width(struct device *cdev,
+                                      struct device_attribute *attr,
+                                      char *buf)
+{
+        struct Scsi_Host *shost = transport_class_to_shost(cdev);
+
+        return sprintf(buf, "%s\n", shost->max_id == 16 ? "wide" : "narrow");
+}
+static DEVICE_ATTR(host_width, S_IRUGO,
+                   show_spi_host_width, NULL);
+
+static ssize_t show_spi_host_hba_id(struct device *cdev,
+                                    struct device_attribute *attr,
+                                    char *buf)
+{
+        struct Scsi_Host *shost = transport_class_to_shost(cdev);
+
+        return sprintf(buf, "%d\n", shost->this_id);
+}
+static DEVICE_ATTR(hba_id, S_IRUGO,
+                   show_spi_host_hba_id, NULL);
+
 #define DV_SET(x, y)                    \
         if(i->f->set_##x)               \
                 i->f->set_##x(sdev->sdev_target, y)
@@ -1380,6 +1402,8 @@ static DECLARE_ANON_TRANSPORT_CLASS(spi_device_class,
 
 static struct attribute *host_attributes[] = {
         &dev_attr_signalling.attr,
+        &dev_attr_host_width.attr,
+        &dev_attr_hba_id.attr,
         NULL
 };
 
diff --git a/drivers/sh/clk/core.c b/drivers/sh/clk/core.c
index d6702e57d428..dc8d022c07a1 100644
--- a/drivers/sh/clk/core.c
+++ b/drivers/sh/clk/core.c
@@ -34,6 +34,9 @@ static LIST_HEAD(clock_list);
 static DEFINE_SPINLOCK(clock_lock);
 static DEFINE_MUTEX(clock_list_sem);
 
+/* clock disable operations are not passed on to hardware during boot */
+static int allow_disable;
+
 void clk_rate_table_build(struct clk *clk,
                           struct cpufreq_frequency_table *freq_table,
                           int nr_freqs,
@@ -228,7 +231,7 @@ static void __clk_disable(struct clk *clk)
                 return;
 
         if (!(--clk->usecount)) {
-                if (likely(clk->ops && clk->ops->disable))
+                if (likely(allow_disable && clk->ops && clk->ops->disable))
                         clk->ops->disable(clk);
                 if (likely(clk->parent))
                         __clk_disable(clk->parent);
@@ -393,7 +396,7 @@ int clk_register(struct clk *clk)
 {
         int ret;
 
-        if (clk == NULL || IS_ERR(clk))
+        if (IS_ERR_OR_NULL(clk))
                 return -EINVAL;
 
         /*
@@ -744,3 +747,25 @@ err_out:
         return err;
 }
 late_initcall(clk_debugfs_init);
+
+static int __init clk_late_init(void)
+{
+        unsigned long flags;
+        struct clk *clk;
+
+        /* disable all clocks with zero use count */
+        mutex_lock(&clock_list_sem);
+        spin_lock_irqsave(&clock_lock, flags);
+
+        list_for_each_entry(clk, &clock_list, node)
+                if (!clk->usecount && clk->ops && clk->ops->disable)
+                        clk->ops->disable(clk);
+
+        /* from now on allow clock disable operations */
+        allow_disable = 1;
+
+        spin_unlock_irqrestore(&clock_lock, flags);
+        mutex_unlock(&clock_list_sem);
+        return 0;
+}
+late_initcall(clk_late_init);
diff --git a/drivers/sh/intc/chip.c b/drivers/sh/intc/chip.c
index f33e2dd97934..33b2ed451e09 100644
--- a/drivers/sh/intc/chip.c
+++ b/drivers/sh/intc/chip.c
@@ -186,6 +186,9 @@ static unsigned char intc_irq_sense_table[IRQ_TYPE_SENSE_MASK + 1] = {
     !defined(CONFIG_CPU_SUBTYPE_SH7709)
         [IRQ_TYPE_LEVEL_HIGH] = VALID(3),
 #endif
+#if defined(CONFIG_ARCH_SH7372)
+        [IRQ_TYPE_EDGE_BOTH] = VALID(4),
+#endif
 };
 
 static int intc_set_type(struct irq_data *data, unsigned int type)
diff --git a/drivers/spi/spi-pl022.c b/drivers/spi/spi-pl022.c
index eba88c749fb1..730b4a37b823 100644
--- a/drivers/spi/spi-pl022.c
+++ b/drivers/spi/spi-pl022.c
@@ -2267,17 +2267,13 @@ static int __devexit
 pl022_remove(struct amba_device *adev)
 {
         struct pl022 *pl022 = amba_get_drvdata(adev);
-        int status = 0;
+
         if (!pl022)
                 return 0;
 
         /* Remove the queue */
-        status = destroy_queue(pl022);
-        if (status != 0) {
-                dev_err(&adev->dev,
-                        "queue remove failed (%d)\n", status);
-                return status;
-        }
+        if (destroy_queue(pl022) != 0)
+                dev_err(&adev->dev, "queue remove failed\n");
         load_ssp_default_config(pl022);
         pl022_dma_remove(pl022);
         free_irq(adev->irq[0], pl022);
@@ -2289,7 +2285,6 @@ pl022_remove(struct amba_device *adev)
         spi_unregister_master(pl022->master);
         spi_master_put(pl022->master);
         amba_set_drvdata(adev, NULL);
-        dev_dbg(&adev->dev, "remove succeeded\n");
         return 0;
 }
 
diff --git a/drivers/staging/ath6kl/miscdrv/ar3kps/ar3kpsparser.c b/drivers/staging/ath6kl/miscdrv/ar3kps/ar3kpsparser.c
index c01c0cb0af4e..b99a11a9dd69 100644
--- a/drivers/staging/ath6kl/miscdrv/ar3kps/ar3kpsparser.c
+++ b/drivers/staging/ath6kl/miscdrv/ar3kps/ar3kpsparser.c
@@ -812,7 +812,7 @@ int AthCreateCommandList(struct ps_cmd_packet **HciPacketList, u32 *numPackets)
     for(count = 0; count < Patch_Count; count++) {
 
         AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Freeing Patch Buffer %d \r\n",count));
-        kfree(RamPatch[Patch_Count].Data);
+        kfree(RamPatch[count].Data);
     }
 
     for(count = 0; count < Tag_Count; count++) {
diff --git a/drivers/staging/brcm80211/brcmsmac/otp.c b/drivers/staging/brcm80211/brcmsmac/otp.c
index 34253cf37812..4a70180eba5d 100644
--- a/drivers/staging/brcm80211/brcmsmac/otp.c
+++ b/drivers/staging/brcm80211/brcmsmac/otp.c
@@ -16,6 +16,7 @@
 
 #include <linux/io.h>
 #include <linux/errno.h>
+#include <linux/string.h>
 
 #include <brcm_hw_ids.h>
 #include <chipcommon.h>
diff --git a/drivers/staging/brcm80211/brcmsmac/types.h b/drivers/staging/brcm80211/brcmsmac/types.h
index bbf21897ae0e..823b5e4672e2 100644
--- a/drivers/staging/brcm80211/brcmsmac/types.h
+++ b/drivers/staging/brcm80211/brcmsmac/types.h
@@ -18,6 +18,7 @@
 #define _BRCM_TYPES_H_
 
 #include <linux/types.h>
+#include <linux/io.h>
 
 /* Bus types */
 #define SI_BUS                  0       /* SOC Interconnect */
diff --git a/drivers/staging/dt3155v4l/dt3155v4l.c b/drivers/staging/dt3155v4l/dt3155v4l.c
index fe02d22274b4..05aa41cf875b 100644
--- a/drivers/staging/dt3155v4l/dt3155v4l.c
+++ b/drivers/staging/dt3155v4l/dt3155v4l.c
@@ -22,6 +22,7 @@
 #include <linux/stringify.h>
 #include <linux/delay.h>
 #include <linux/kthread.h>
+#include <linux/slab.h>
 #include <media/v4l2-dev.h>
 #include <media/v4l2-ioctl.h>
 #include <media/videobuf2-dma-contig.h>
diff --git a/drivers/staging/ft1000/ft1000-pcmcia/ft1000_proc.c b/drivers/staging/ft1000/ft1000-pcmcia/ft1000_proc.c
index 627a98b4ec30..9e728b3415e3 100644
--- a/drivers/staging/ft1000/ft1000-pcmcia/ft1000_proc.c
+++ b/drivers/staging/ft1000/ft1000-pcmcia/ft1000_proc.c
@@ -22,6 +22,7 @@
 #include <linux/string.h>
 #include <linux/vmalloc.h>
 #include <linux/netdevice.h>
+#include <asm/io.h>
 #include <asm/uaccess.h>
 #include "ft1000.h"
 
diff --git a/drivers/staging/gma500/gem_glue.c b/drivers/staging/gma500/gem_glue.c
index 779ac1a12d24..daac12120653 100644
--- a/drivers/staging/gma500/gem_glue.c
+++ b/drivers/staging/gma500/gem_glue.c
@@ -20,26 +20,6 @@
 #include <drm/drmP.h>
 #include <drm/drm.h>
 
-/**
- * Initialize an already allocated GEM object of the specified size with
- * no GEM provided backing store. Instead the caller is responsible for
- * backing the object and handling it.
- */
-int drm_gem_private_object_init(struct drm_device *dev,
-                        struct drm_gem_object *obj, size_t size)
-{
-        BUG_ON((size & (PAGE_SIZE - 1)) != 0);
-
-        obj->dev = dev;
-        obj->filp = NULL;
-
-        kref_init(&obj->refcount);
-        atomic_set(&obj->handle_count, 0);
-        obj->size = size;
-
-        return 0;
-}
-
 void drm_gem_object_release_wrap(struct drm_gem_object *obj)
 {
         /* Remove the list map if one is present */
@@ -51,8 +31,7 @@ void drm_gem_object_release_wrap(struct drm_gem_object *obj)
                 kfree(list->map);
                 list->map = NULL;
         }
-        if (obj->filp)
-                drm_gem_object_release(obj);
+        drm_gem_object_release(obj);
 }
 
 /**
diff --git a/drivers/staging/gma500/gem_glue.h b/drivers/staging/gma500/gem_glue.h
index a0f2bc4e4ae7..ce5ce30f74db 100644
--- a/drivers/staging/gma500/gem_glue.h
+++ b/drivers/staging/gma500/gem_glue.h
@@ -1,4 +1,2 @@
 extern void drm_gem_object_release_wrap(struct drm_gem_object *obj);
-extern int drm_gem_private_object_init(struct drm_device *dev,
-                        struct drm_gem_object *obj, size_t size);
 extern int gem_create_mmap_offset(struct drm_gem_object *obj);
diff --git a/drivers/staging/gma500/mdfld_dsi_dbi.c b/drivers/staging/gma500/mdfld_dsi_dbi.c
index 02e17c9c8637..fd211f3467c4 100644
--- a/drivers/staging/gma500/mdfld_dsi_dbi.c
+++ b/drivers/staging/gma500/mdfld_dsi_dbi.c
@@ -711,10 +711,11 @@ struct mdfld_dsi_encoder *mdfld_dsi_dbi_init(struct drm_device *dev,
         /* Create drm encoder object */
         connector = &dsi_connector->base.base;
         encoder = &dbi_output->base.base;
+        /* Review this if we ever get MIPI-HDMI bridges or similar */
         drm_encoder_init(dev,
                         encoder,
                         p_funcs->encoder_funcs,
-                        DRM_MODE_ENCODER_MIPI);
+                        DRM_MODE_ENCODER_LVDS);
         drm_encoder_helper_add(encoder, p_funcs->encoder_helper_funcs);
 
         /* Attach to given connector */
diff --git a/drivers/staging/gma500/mdfld_dsi_dbi.h b/drivers/staging/gma500/mdfld_dsi_dbi.h
index dc6242c51d0b..f0fa986fd934 100644
--- a/drivers/staging/gma500/mdfld_dsi_dbi.h
+++ b/drivers/staging/gma500/mdfld_dsi_dbi.h
@@ -42,9 +42,6 @@
 #include "mdfld_dsi_output.h"
 #include "mdfld_output.h"
 
-#define DRM_MODE_ENCODER_MIPI  5
-
-
 /*
  * DBI encoder which inherits from mdfld_dsi_encoder
  */
diff --git a/drivers/staging/gma500/mdfld_dsi_dpi.c b/drivers/staging/gma500/mdfld_dsi_dpi.c
index 6e03a91e947e..e685f1217baa 100644
--- a/drivers/staging/gma500/mdfld_dsi_dpi.c
+++ b/drivers/staging/gma500/mdfld_dsi_dpi.c
@@ -777,10 +777,15 @@ struct mdfld_dsi_encoder *mdfld_dsi_dpi_init(struct drm_device *dev,
         /* Create drm encoder object */
         connector = &dsi_connector->base.base;
         encoder = &dpi_output->base.base;
+        /*
+         * On existing hardware this will be a panel of some form,
+         * if future devices also have HDMI bridges this will need
+         * revisiting
+         */
         drm_encoder_init(dev,
                         encoder,
                         p_funcs->encoder_funcs,
-                        DRM_MODE_ENCODER_MIPI);
+                        DRM_MODE_ENCODER_LVDS);
         drm_encoder_helper_add(encoder,
                                 p_funcs->encoder_helper_funcs);
         
diff --git a/drivers/staging/gma500/mdfld_dsi_output.c b/drivers/staging/gma500/mdfld_dsi_output.c
index 7536095c30a0..9050c0f78b15 100644
--- a/drivers/staging/gma500/mdfld_dsi_output.c
+++ b/drivers/staging/gma500/mdfld_dsi_output.c
@@ -955,7 +955,9 @@ void mdfld_dsi_output_init(struct drm_device *dev,
         psb_output->type = (pipe == 0) ? INTEL_OUTPUT_MIPI : INTEL_OUTPUT_MIPI2;
 
         connector = &psb_output->base;
-        drm_connector_init(dev, connector, &mdfld_dsi_connector_funcs, DRM_MODE_CONNECTOR_MIPI);
+        /* Revisit type if MIPI/HDMI bridges ever appear on Medfield */
+        drm_connector_init(dev, connector, &mdfld_dsi_connector_funcs,
+                                                DRM_MODE_CONNECTOR_LVDS);
         drm_connector_helper_add(connector, &mdfld_dsi_connector_helper_funcs);
         
         connector->display_info.subpixel_order = SubPixelHorizontalRGB;
diff --git a/drivers/staging/gma500/medfield.h b/drivers/staging/gma500/medfield.h
index 38165e8367e5..09e9687431f1 100644
--- a/drivers/staging/gma500/medfield.h
+++ b/drivers/staging/gma500/medfield.h
@@ -21,8 +21,6 @@
  * DEALINGS IN THE SOFTWARE.
  */
 
-#define DRM_MODE_ENCODER_MIPI  5
-
 /* Medfield DSI controller registers */
 
 #define MIPIA_DEVICE_READY_REG                          0xb000
diff --git a/drivers/staging/gma500/psb_drv.h b/drivers/staging/gma500/psb_drv.h
index 72f487a2a1b7..fd4732dd783a 100644
--- a/drivers/staging/gma500/psb_drv.h
+++ b/drivers/staging/gma500/psb_drv.h
@@ -35,7 +35,6 @@
 
 /* Append new drm mode definition here, align with libdrm definition */
 #define DRM_MODE_SCALE_NO_SCALE         2
-#define DRM_MODE_CONNECTOR_MIPI         15
 
 enum {
         CHIP_PSB_8108 = 0,              /* Poulsbo */
diff --git a/drivers/staging/hv/blkvsc_drv.c b/drivers/staging/hv/blkvsc_drv.c
index 3612574ca520..d286b2223181 100644
--- a/drivers/staging/hv/blkvsc_drv.c
+++ b/drivers/staging/hv/blkvsc_drv.c
@@ -325,7 +325,7 @@ static int blkvsc_do_operation(struct block_device_context *blkdev,
 
         page_buf = alloc_page(GFP_KERNEL);
         if (!page_buf) {
-                kmem_cache_free(blkvsc_req->dev->request_pool, blkvsc_req);
+                kmem_cache_free(blkdev->request_pool, blkvsc_req);
                 return -ENOMEM;
         }
 
@@ -422,7 +422,7 @@ cleanup:
 
         __free_page(page_buf);
 
-        kmem_cache_free(blkvsc_req->dev->request_pool, blkvsc_req);
+        kmem_cache_free(blkdev->request_pool, blkvsc_req);
 
         return ret;
 }
diff --git a/drivers/staging/iio/accel/adis16203_core.c b/drivers/staging/iio/accel/adis16203_core.c
index bf1988884e93..cf5d15da76ad 100644
--- a/drivers/staging/iio/accel/adis16203_core.c
+++ b/drivers/staging/iio/accel/adis16203_core.c
@@ -311,13 +311,17 @@ static int adis16203_read_raw(struct iio_dev *indio_dev,
                 mutex_lock(&indio_dev->mlock);
                 addr = adis16203_addresses[chan->address][0];
                 ret = adis16203_spi_read_reg_16(indio_dev, addr, &val16);
-                if (ret)
+                if (ret) {
+                        mutex_unlock(&indio_dev->mlock);
                         return ret;
+                }
 
                 if (val16 & ADIS16203_ERROR_ACTIVE) {
                         ret = adis16203_check_status(indio_dev);
-                        if (ret)
+                        if (ret) {
+                                mutex_unlock(&indio_dev->mlock);
                                 return ret;
+                        }
                 }
                 val16 = val16 & ((1 << chan->scan_type.realbits) - 1);
                 if (chan->scan_type.sign == 's')
diff --git a/drivers/staging/iio/accel/adis16204_core.c b/drivers/staging/iio/accel/adis16204_core.c
index cfd09b3b9937..3e2b62654b7d 100644
--- a/drivers/staging/iio/accel/adis16204_core.c
+++ b/drivers/staging/iio/accel/adis16204_core.c
@@ -341,13 +341,17 @@ static int adis16204_read_raw(struct iio_dev *indio_dev,
                 mutex_lock(&indio_dev->mlock);
                 addr = adis16204_addresses[chan->address][0];
                 ret = adis16204_spi_read_reg_16(indio_dev, addr, &val16);
-                if (ret)
+                if (ret) {
+                        mutex_unlock(&indio_dev->mlock);
                         return ret;
+                }
 
                 if (val16 & ADIS16204_ERROR_ACTIVE) {
                         ret = adis16204_check_status(indio_dev);
-                        if (ret)
+                        if (ret) {
+                                mutex_unlock(&indio_dev->mlock);
                                 return ret;
+                        }
                 }
                 val16 = val16 & ((1 << chan->scan_type.realbits) - 1);
                 if (chan->scan_type.sign == 's')
diff --git a/drivers/staging/iio/accel/adis16209_core.c b/drivers/staging/iio/accel/adis16209_core.c
index 55f3a7bcaf0a..bec1fa8de9b9 100644
--- a/drivers/staging/iio/accel/adis16209_core.c
+++ b/drivers/staging/iio/accel/adis16209_core.c
@@ -337,13 +337,17 @@ static int adis16209_read_raw(struct iio_dev *indio_dev,
                 mutex_lock(&indio_dev->mlock);
                 addr = adis16209_addresses[chan->address][0];
                 ret = adis16209_spi_read_reg_16(indio_dev, addr, &val16);
-                if (ret)
+                if (ret) {
+                        mutex_unlock(&indio_dev->mlock);
                         return ret;
+                }
 
                 if (val16 & ADIS16209_ERROR_ACTIVE) {
                         ret = adis16209_check_status(indio_dev);
-                        if (ret)
+                        if (ret) {
+                                mutex_unlock(&indio_dev->mlock);
                                 return ret;
+                        }
                 }
                 val16 = val16 & ((1 << chan->scan_type.realbits) - 1);
                 if (chan->scan_type.sign == 's')
diff --git a/drivers/staging/iio/accel/adis16240_core.c b/drivers/staging/iio/accel/adis16240_core.c
index 4a4eafc58630..aee8b69173c4 100644
--- a/drivers/staging/iio/accel/adis16240_core.c
+++ b/drivers/staging/iio/accel/adis16240_core.c
@@ -370,13 +370,17 @@ static int adis16240_read_raw(struct iio_dev *indio_dev,
                 mutex_lock(&indio_dev->mlock);
                 addr = adis16240_addresses[chan->address][0];
                 ret = adis16240_spi_read_reg_16(indio_dev, addr, &val16);
-                if (ret)
+                if (ret) {
+                        mutex_unlock(&indio_dev->mlock);
                         return ret;
+                }
 
                 if (val16 & ADIS16240_ERROR_ACTIVE) {
                         ret = adis16240_check_status(indio_dev);
-                        if (ret)
+                        if (ret) {
+                                mutex_unlock(&indio_dev->mlock);
                                 return ret;
+                        }
                 }
                 val16 = val16 & ((1 << chan->scan_type.realbits) - 1);
                 if (chan->scan_type.sign == 's')
diff --git a/drivers/staging/iio/gyro/adis16260_core.c b/drivers/staging/iio/gyro/adis16260_core.c
index 05797f404bea..f2d43cfcc493 100644
--- a/drivers/staging/iio/gyro/adis16260_core.c
+++ b/drivers/staging/iio/gyro/adis16260_core.c
@@ -446,13 +446,17 @@ static int adis16260_read_raw(struct iio_dev *indio_dev,
                 mutex_lock(&indio_dev->mlock);
                 addr = adis16260_addresses[chan->address][0];
                 ret = adis16260_spi_read_reg_16(indio_dev, addr, &val16);
-                if (ret)
+                if (ret) {
+                        mutex_unlock(&indio_dev->mlock);
                         return ret;
+                }
 
                 if (val16 & ADIS16260_ERROR_ACTIVE) {
                         ret = adis16260_check_status(indio_dev);
-                        if (ret)
+                        if (ret) {
+                                mutex_unlock(&indio_dev->mlock);
                                 return ret;
+                        }
                 }
                 val16 = val16 & ((1 << chan->scan_type.realbits) - 1);
                 if (chan->scan_type.sign == 's')
diff --git a/drivers/staging/nvec/TODO b/drivers/staging/nvec/TODO
index 77b47f763f22..649d6b70deaa 100644
--- a/drivers/staging/nvec/TODO
+++ b/drivers/staging/nvec/TODO
@@ -4,5 +4,7 @@ ToDo list (incomplete, unordered)
         - add compile as module support
         - move nvec devices to mfd cells?
         - adjust to kernel style
-
-
+        - fix clk usage
+          should not be using clk_get_sys(), but clk_get(&pdev->dev, conn)
+          where conn is either NULL if the device only has one clock, or
+          the device specific name if it has multiple clocks.
diff --git a/drivers/staging/octeon/ethernet-rgmii.c b/drivers/staging/octeon/ethernet-rgmii.c
index 9c0d2936e486..c3d73f8431ae 100644
--- a/drivers/staging/octeon/ethernet-rgmii.c
+++ b/drivers/staging/octeon/ethernet-rgmii.c
@@ -26,6 +26,7 @@
 **********************************************************************/
 #include <linux/kernel.h>
 #include <linux/netdevice.h>
+#include <linux/interrupt.h>
 #include <linux/phy.h>
 #include <linux/ratelimit.h>
 #include <net/dst.h>
diff --git a/drivers/staging/octeon/ethernet-spi.c b/drivers/staging/octeon/ethernet-spi.c
index 970825421884..d0e2d514968a 100644
--- a/drivers/staging/octeon/ethernet-spi.c
+++ b/drivers/staging/octeon/ethernet-spi.c
@@ -26,6 +26,7 @@
 **********************************************************************/
 #include <linux/kernel.h>
 #include <linux/netdevice.h>
+#include <linux/interrupt.h>
 #include <net/dst.h>
 
 #include <asm/octeon/octeon.h>
diff --git a/drivers/staging/rtl8192u/r819xU_firmware.c b/drivers/staging/rtl8192u/r819xU_firmware.c
index 6766f468639f..4bb5fffca5b9 100644
--- a/drivers/staging/rtl8192u/r819xU_firmware.c
+++ b/drivers/staging/rtl8192u/r819xU_firmware.c
@@ -399,10 +399,7 @@ download_firmware_fail:
 
 }
 
-
-
-
-
-
-
+MODULE_FIRMWARE("RTL8192U/boot.img");
+MODULE_FIRMWARE("RTL8192U/main.img");
+MODULE_FIRMWARE("RTL8192U/data.img");
 
diff --git a/drivers/staging/rts_pstor/rtsx.c b/drivers/staging/rts_pstor/rtsx.c
index 5ff59f27d101..16c73fbff51f 100644
--- a/drivers/staging/rts_pstor/rtsx.c
+++ b/drivers/staging/rts_pstor/rtsx.c
@@ -66,12 +66,6 @@ static int msi_en;
 module_param(msi_en, int, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(msi_en, "enable msi");
 
-/* These are used to make sure the module doesn't unload before all the
- * threads have exited.
- */
-static atomic_t total_threads = ATOMIC_INIT(0);
-static DECLARE_COMPLETION(threads_gone);
-
 static irqreturn_t rtsx_interrupt(int irq, void *dev_id);
 
 /***********************************************************************
@@ -192,7 +186,7 @@ static int queuecommand_lck(struct scsi_cmnd *srb,
         /* enqueue the command and wake up the control thread */
         srb->scsi_done = done;
         chip->srb = srb;
-        up(&(dev->sema));
+        complete(&dev->cmnd_ready);
 
         return 0;
 }
@@ -475,7 +469,7 @@ static int rtsx_control_thread(void *__dev)
         current->flags |= PF_NOFREEZE;
 
         for (;;) {
-                if (down_interruptible(&dev->sema))
+                if (wait_for_completion_interruptible(&dev->cmnd_ready))
                         break;
 
                 /* lock the device pointers */
@@ -557,8 +551,6 @@ SkipForAbort:
                 mutex_unlock(&dev->dev_mutex);
         } /* for (;;) */
 
-        scsi_host_put(host);
-
         /* notify the exit routine that we're actually exiting now
          *
          * complete()/wait_for_completion() is similar to up()/down(),
@@ -573,7 +565,7 @@ SkipForAbort:
          * This is important in preemption kernels, which transfer the flow
          * of execution immediately upon a complete().
          */
-        complete_and_exit(&threads_gone, 0);
+        complete_and_exit(&dev->control_exit, 0);
 }
 
 
@@ -581,7 +573,6 @@ static int rtsx_polling_thread(void *__dev)
 {
         struct rtsx_dev *dev = (struct rtsx_dev *)__dev;
         struct rtsx_chip *chip = dev->chip;
-        struct Scsi_Host *host = rtsx_to_host(dev);
         struct sd_info *sd_card = &(chip->sd_card);
         struct xd_info *xd_card = &(chip->xd_card);
         struct ms_info *ms_card = &(chip->ms_card);
@@ -621,8 +612,7 @@ static int rtsx_polling_thread(void *__dev)
                 mutex_unlock(&dev->dev_mutex);
         }
 
-        scsi_host_put(host);
-        complete_and_exit(&threads_gone, 0);
+        complete_and_exit(&dev->polling_exit, 0);
 }
 
 /*
@@ -699,29 +689,38 @@ static void rtsx_release_resources(struct rtsx_dev *dev)
 {
         printk(KERN_INFO "-- %s\n", __func__);
 
+        /* Tell the control thread to exit.  The SCSI host must
+         * already have been removed so it won't try to queue
+         * any more commands.
+         */
+        printk(KERN_INFO "-- sending exit command to thread\n");
+        complete(&dev->cmnd_ready);
+        if (dev->ctl_thread)
+                wait_for_completion(&dev->control_exit);
+        if (dev->polling_thread)
+                wait_for_completion(&dev->polling_exit);
+
+        wait_timeout(200);
+
         if (dev->rtsx_resv_buf) {
-                dma_free_coherent(&(dev->pci->dev), HOST_CMDS_BUF_LEN,
+                dma_free_coherent(&(dev->pci->dev), RTSX_RESV_BUF_LEN,
                                 dev->rtsx_resv_buf, dev->rtsx_resv_buf_addr);
                 dev->chip->host_cmds_ptr = NULL;
                 dev->chip->host_sg_tbl_ptr = NULL;
         }
 
-        pci_disable_device(dev->pci);
-        pci_release_regions(dev->pci);
-
-        if (dev->irq > 0) {
+        if (dev->irq > 0)
                 free_irq(dev->irq, (void *)dev);
-        }
-        if (dev->chip->msi_en) {
+        if (dev->chip->msi_en)
                 pci_disable_msi(dev->pci);
-        }
+        if (dev->remap_addr)
+                iounmap(dev->remap_addr);
 
-        /* Tell the control thread to exit.  The SCSI host must
-         * already have been removed so it won't try to queue
-         * any more commands.
-         */
-        printk(KERN_INFO "-- sending exit command to thread\n");
-        up(&dev->sema);
+        pci_disable_device(dev->pci);
+        pci_release_regions(dev->pci);
+
+        rtsx_release_chip(dev->chip);
+        kfree(dev->chip);
 }
 
 /* First stage of disconnect processing: stop all commands and remove
@@ -739,6 +738,7 @@ static void quiesce_and_remove_host(struct rtsx_dev *dev)
         scsi_unlock(host);
         mutex_unlock(&dev->dev_mutex);
         wake_up(&dev->delay_wait);
+        wait_for_completion(&dev->scanning_done);
 
         /* Wait some time to let other threads exist */
         wait_timeout(100);
@@ -793,8 +793,7 @@ static int rtsx_scan_thread(void *__dev)
                 /* Should we unbind if no devices were detected? */
         }
 
-        scsi_host_put(rtsx_to_host(dev));
-        complete_and_exit(&threads_gone, 0);
+        complete_and_exit(&dev->scanning_done, 0);
 }
 
 static void rtsx_init_options(struct rtsx_chip *chip)
@@ -941,8 +940,11 @@ static int __devinit rtsx_probe(struct pci_dev *pci, const struct pci_device_id
 
         spin_lock_init(&dev->reg_lock);
         mutex_init(&(dev->dev_mutex));
-        sema_init(&(dev->sema), 0);
+        init_completion(&dev->cmnd_ready);
+        init_completion(&dev->control_exit);
+        init_completion(&dev->polling_exit);
         init_completion(&(dev->notify));
+        init_completion(&dev->scanning_done);
         init_waitqueue_head(&dev->delay_wait);
 
         dev->pci = pci;
@@ -992,28 +994,22 @@ static int __devinit rtsx_probe(struct pci_dev *pci, const struct pci_device_id
         pci_set_master(pci);
         synchronize_irq(dev->irq);
 
-        err = scsi_add_host(host, &pci->dev);
-        if (err) {
-                printk(KERN_ERR "Unable to add the scsi host\n");
-                goto errout;
-        }
-
         rtsx_init_chip(dev->chip);
 
         /* Start up our control thread */
-        th = kthread_create(rtsx_control_thread, dev, CR_DRIVER_NAME);
+        th = kthread_run(rtsx_control_thread, dev, CR_DRIVER_NAME);
         if (IS_ERR(th)) {
                 printk(KERN_ERR "Unable to start control thread\n");
                 err = PTR_ERR(th);
                 goto errout;
         }
+        dev->ctl_thread = th;
 
-        /* Take a reference to the host for the control thread and
-         * count it among all the threads we have launched.  Then
-         * start it up. */
-        scsi_host_get(rtsx_to_host(dev));
-        atomic_inc(&total_threads);
-        wake_up_process(th);
+        err = scsi_add_host(host, &pci->dev);
+        if (err) {
+                printk(KERN_ERR "Unable to add the scsi host\n");
+                goto errout;
+        }
 
         /* Start up the thread for delayed SCSI-device scanning */
         th = kthread_create(rtsx_scan_thread, dev, "rtsx-scan");
@@ -1024,28 +1020,17 @@ static int __devinit rtsx_probe(struct pci_dev *pci, const struct pci_device_id
                 goto errout;
         }
 
-        /* Take a reference to the host for the scanning thread and
-         * count it among all the threads we have launched.  Then
-         * start it up. */
-        scsi_host_get(rtsx_to_host(dev));
-        atomic_inc(&total_threads);
         wake_up_process(th);
 
         /* Start up the thread for polling thread */
-        th = kthread_create(rtsx_polling_thread, dev, "rtsx-polling");
+        th = kthread_run(rtsx_polling_thread, dev, "rtsx-polling");
         if (IS_ERR(th)) {
                 printk(KERN_ERR "Unable to start the device-polling thread\n");
                 quiesce_and_remove_host(dev);
                 err = PTR_ERR(th);
                 goto errout;
         }
-
-        /* Take a reference to the host for the polling thread and
-         * count it among all the threads we have launched.  Then
-         * start it up. */
-        scsi_host_get(rtsx_to_host(dev));
-        atomic_inc(&total_threads);
-        wake_up_process(th);
+        dev->polling_thread = th;
 
         pci_set_drvdata(pci, dev);
 
@@ -1108,16 +1093,6 @@ static void __exit rtsx_exit(void)
 
         pci_unregister_driver(&driver);
 
-        /* Don't return until all of our control and scanning threads
-         * have exited.  Since each thread signals threads_gone as its
-         * last act, we have to call wait_for_completion the right number
-         * of times.
-         */
-        while (atomic_read(&total_threads) > 0) {
-                wait_for_completion(&threads_gone);
-                atomic_dec(&total_threads);
-        }
-
         printk(KERN_INFO "%s module exit\n", CR_DRIVER_NAME);
 }
 
diff --git a/drivers/staging/rts_pstor/rtsx.h b/drivers/staging/rts_pstor/rtsx.h
index 247615ba1d2a..86e47c2e3e3c 100644
--- a/drivers/staging/rts_pstor/rtsx.h
+++ b/drivers/staging/rts_pstor/rtsx.h
@@ -112,9 +112,16 @@ struct rtsx_dev {
         /* locks */
         spinlock_t              reg_lock;
 
+        struct task_struct      *ctl_thread;     /* the control thread   */
+        struct task_struct      *polling_thread; /* the polling thread   */
+
         /* mutual exclusion and synchronization structures */
-        struct semaphore        sema;            /* to sleep thread on      */
+        struct completion       cmnd_ready;      /* to sleep thread on      */
+        struct completion       control_exit;    /* control thread exit     */
+        struct completion       polling_exit;    /* polling thread exit     */
         struct completion       notify;          /* thread begin/end        */
+        struct completion       scanning_done;   /* wait for scan thread    */
+
         wait_queue_head_t       delay_wait;      /* wait during scan, reset */
         struct mutex            dev_mutex;
 
diff --git a/drivers/staging/solo6x10/core.c b/drivers/staging/solo6x10/core.c
index 76779949f141..f974f6412ad7 100644
--- a/drivers/staging/solo6x10/core.c
+++ b/drivers/staging/solo6x10/core.c
@@ -21,6 +21,7 @@
 #include <linux/module.h>
 #include <linux/pci.h>
 #include <linux/interrupt.h>
+#include <linux/slab.h>
 #include <linux/videodev2.h>
 #include "solo6x10.h"
 #include "tw28.h"
diff --git a/drivers/staging/solo6x10/enc.c b/drivers/staging/solo6x10/enc.c
index 285f7f350062..de502599bb19 100644
--- a/drivers/staging/solo6x10/enc.c
+++ b/drivers/staging/solo6x10/enc.c
@@ -18,6 +18,7 @@
  */
 
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include "solo6x10.h"
 #include "osd-font.h"
 
diff --git a/drivers/staging/solo6x10/g723.c b/drivers/staging/solo6x10/g723.c
index bd8eb92c94b1..59274bfca95b 100644
--- a/drivers/staging/solo6x10/g723.c
+++ b/drivers/staging/solo6x10/g723.c
@@ -21,6 +21,7 @@
 #include <linux/mempool.h>
 #include <linux/poll.h>
 #include <linux/kthread.h>
+#include <linux/slab.h>
 #include <linux/freezer.h>
 #include <sound/core.h>
 #include <sound/initval.h>
diff --git a/drivers/staging/solo6x10/p2m.c b/drivers/staging/solo6x10/p2m.c
index 5717eabb04a4..56210f0fc5ec 100644
--- a/drivers/staging/solo6x10/p2m.c
+++ b/drivers/staging/solo6x10/p2m.c
@@ -18,6 +18,7 @@
  */
 
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <linux/scatterlist.h>
 #include "solo6x10.h"
 
diff --git a/drivers/staging/solo6x10/solo6x10.h b/drivers/staging/solo6x10/solo6x10.h
index 17c06bd6cc91..abee7213202f 100644
--- a/drivers/staging/solo6x10/solo6x10.h
+++ b/drivers/staging/solo6x10/solo6x10.h
@@ -28,6 +28,7 @@
 #include <linux/list.h>
 #include <linux/wait.h>
 #include <linux/delay.h>
+#include <linux/slab.h>
 #include <asm/io.h>
 #include <linux/atomic.h>
 #include <linux/videodev2.h>
diff --git a/drivers/staging/speakup/devsynth.c b/drivers/staging/speakup/devsynth.c
index 39dc586fc8bb..940769ef883f 100644
--- a/drivers/staging/speakup/devsynth.c
+++ b/drivers/staging/speakup/devsynth.c
@@ -18,13 +18,14 @@ static ssize_t speakup_file_write(struct file *fp, const char *buffer,
 {
         size_t count = nbytes;
         const char *ptr = buffer;
-        int bytes;
+        size_t bytes;
         unsigned long flags;
         u_char buf[256];
+
         if (synth == NULL)
                 return -ENODEV;
         while (count > 0) {
-                bytes = min_t(size_t, count, sizeof(buf));
+                bytes = min(count, sizeof(buf));
                 if (copy_from_user(buf, ptr, bytes))
                         return -EFAULT;
                 count -= bytes;
diff --git a/drivers/staging/tidspbridge/core/dsp-clock.c b/drivers/staging/tidspbridge/core/dsp-clock.c
index 589a0554332e..3d1279c424a8 100644
--- a/drivers/staging/tidspbridge/core/dsp-clock.c
+++ b/drivers/staging/tidspbridge/core/dsp-clock.c
@@ -209,7 +209,6 @@ int dsp_clk_enable(enum dsp_clk_id clk_id)
                 break;
 #ifdef CONFIG_OMAP_MCBSP
         case MCBSP_CLK:
-                omap_mcbsp_set_io_type(MCBSP_ID(clk_id), OMAP_MCBSP_POLL_IO);
                 omap_mcbsp_request(MCBSP_ID(clk_id));
                 omap2_mcbsp_set_clks_src(MCBSP_ID(clk_id), MCBSP_CLKS_PAD_SRC);
                 break;
diff --git a/drivers/staging/zcache/Makefile b/drivers/staging/zcache/Makefile
index f5ec64f94470..60daa272c204 100644
--- a/drivers/staging/zcache/Makefile
+++ b/drivers/staging/zcache/Makefile
@@ -1,3 +1,3 @@
-zcache-y        :=      tmem.o
+zcache-y        :=      zcache-main.o tmem.o
 
 obj-$(CONFIG_ZCACHE)    +=      zcache.o
diff --git a/drivers/staging/zcache/tmem.c b/drivers/staging/zcache/tmem.c
index 975e34bcd722..1ca66ea9b281 100644
--- a/drivers/staging/zcache/tmem.c
+++ b/drivers/staging/zcache/tmem.c
@@ -604,7 +604,7 @@ int tmem_get(struct tmem_pool *pool, struct tmem_oid *oidp, uint32_t index,
         struct tmem_obj *obj;
         void *pampd;
         bool ephemeral = is_ephemeral(pool);
-        uint32_t ret = -1;
+        int ret = -1;
         struct tmem_hashbucket *hb;
         bool free = (get_and_free == 1) || ((get_and_free == 0) && ephemeral);
         bool lock_held = false;
diff --git a/drivers/staging/zcache/zcache.c b/drivers/staging/zcache/zcache-main.c
index 65a81a0d7c49..a3f5162bfedc 100644
--- a/drivers/staging/zcache/zcache.c
+++ b/drivers/staging/zcache/zcache-main.c
@@ -19,6 +19,7 @@
  *   http://marc.info/?l=linux-mm&m=127811271605009
  */
 
+#include <linux/module.h>
 #include <linux/cpu.h>
 #include <linux/highmem.h>
 #include <linux/list.h>
@@ -27,6 +28,7 @@
 #include <linux/spinlock.h>
 #include <linux/types.h>
 #include <linux/atomic.h>
+#include <linux/math64.h>
 #include "tmem.h"
 
 #include "../zram/xvmalloc.h" /* if built in drivers/staging */
@@ -53,6 +55,9 @@
 
 #define MAX_CLIENTS 16
 #define LOCAL_CLIENT ((uint16_t)-1)
+
+MODULE_LICENSE("GPL");
+
 struct zcache_client {
         struct tmem_pool *tmem_pools[MAX_POOLS_PER_CLIENT];
         struct xv_pool *xvpool;
@@ -1153,11 +1158,12 @@ static void *zcache_pampd_create(char *data, size_t size, bool raw, int eph,
         size_t clen;
         int ret;
         unsigned long count;
-        struct page *page = virt_to_page(data);
+        struct page *page = (struct page *)(data);
         struct zcache_client *cli = pool->client;
         uint16_t client_id = get_client_id_from_client(cli);
         unsigned long zv_mean_zsize;
         unsigned long curr_pers_pampd_count;
+        u64 total_zsize;
 
         if (eph) {
                 ret = zcache_compress(page, &cdata, &clen);
@@ -1190,8 +1196,9 @@ static void *zcache_pampd_create(char *data, size_t size, bool raw, int eph,
                 }
                 /* reject if mean compression is too poor */
                 if ((clen > zv_max_mean_zsize) && (curr_pers_pampd_count > 0)) {
-                        zv_mean_zsize = xv_get_total_size_bytes(cli->xvpool) /
-                                                curr_pers_pampd_count;
+                        total_zsize = xv_get_total_size_bytes(cli->xvpool);
+                        zv_mean_zsize = div_u64(total_zsize,
+                                                curr_pers_pampd_count);
                         if (zv_mean_zsize > zv_max_mean_zsize) {
                                 zcache_mean_compress_poor++;
                                 goto out;
@@ -1220,7 +1227,7 @@ static int zcache_pampd_get_data(char *data, size_t *bufsize, bool raw,
         int ret = 0;
 
         BUG_ON(is_ephemeral(pool));
-        zv_decompress(virt_to_page(data), pampd);
+        zv_decompress((struct page *)(data), pampd);
         return ret;
 }
 
@@ -1532,7 +1539,7 @@ static int zcache_put_page(int cli_id, int pool_id, struct tmem_oid *oidp,
                 goto out;
         if (!zcache_freeze && zcache_do_preload(pool) == 0) {
                 /* preload does preempt_disable on success */
-                ret = tmem_put(pool, oidp, index, page_address(page),
+                ret = tmem_put(pool, oidp, index, (char *)(page),
                                 PAGE_SIZE, 0, is_ephemeral(pool));
                 if (ret < 0) {
                         if (is_ephemeral(pool))
@@ -1565,7 +1572,7 @@ static int zcache_get_page(int cli_id, int pool_id, struct tmem_oid *oidp,
         pool = zcache_get_pool_by_id(cli_id, pool_id);
         if (likely(pool != NULL)) {
                 if (atomic_read(&pool->obj_count) > 0)
-                        ret = tmem_get(pool, oidp, index, page_address(page),
+                        ret = tmem_get(pool, oidp, index, (char *)(page),
                                         &size, 0, is_ephemeral(pool));
                 zcache_put_pool(pool);
         }
@@ -1929,9 +1936,9 @@ __setup("nofrontswap", no_frontswap);
 
 static int __init zcache_init(void)
 {
-#ifdef CONFIG_SYSFS
         int ret = 0;
 
+#ifdef CONFIG_SYSFS
         ret = sysfs_create_group(mm_kobj, &zcache_attr_group);
         if (ret) {
                 pr_err("zcache: can't create sysfs\n");
diff --git a/drivers/target/iscsi/Kconfig b/drivers/target/iscsi/Kconfig
index 564ff4e0dbc4..8345fb457a40 100644
--- a/drivers/target/iscsi/Kconfig
+++ b/drivers/target/iscsi/Kconfig
@@ -1,5 +1,6 @@
 config ISCSI_TARGET
         tristate "Linux-iSCSI.org iSCSI Target Mode Stack"
+        depends on NET
         select CRYPTO
         select CRYPTO_CRC32C
         select CRYPTO_CRC32C_INTEL if X86
diff --git a/drivers/target/iscsi/iscsi_target.c b/drivers/target/iscsi/iscsi_target.c
index 14c81c4265bd..6a4ea29c2f36 100644
--- a/drivers/target/iscsi/iscsi_target.c
+++ b/drivers/target/iscsi/iscsi_target.c
@@ -120,7 +120,7 @@ struct iscsi_tiqn *iscsit_add_tiqn(unsigned char *buf)
         struct iscsi_tiqn *tiqn = NULL;
         int ret;
 
-        if (strlen(buf) > ISCSI_IQN_LEN) {
+        if (strlen(buf) >= ISCSI_IQN_LEN) {
                 pr_err("Target IQN exceeds %d bytes\n",
                                 ISCSI_IQN_LEN);
                 return ERR_PTR(-EINVAL);
@@ -1857,7 +1857,7 @@ static int iscsit_handle_text_cmd(
         char *text_ptr, *text_in;
         int cmdsn_ret, niov = 0, rx_got, rx_size;
         u32 checksum = 0, data_crc = 0, payload_length;
-        u32 padding = 0, text_length = 0;
+        u32 padding = 0, pad_bytes = 0, text_length = 0;
         struct iscsi_cmd *cmd;
         struct kvec iov[3];
         struct iscsi_text *hdr;
@@ -1896,7 +1896,7 @@ static int iscsit_handle_text_cmd(
 
                 padding = ((-payload_length) & 3);
                 if (padding != 0) {
-                        iov[niov].iov_base = cmd->pad_bytes;
+                        iov[niov].iov_base = &pad_bytes;
                         iov[niov++].iov_len  = padding;
                         rx_size += padding;
                         pr_debug("Receiving %u additional bytes"
@@ -1917,7 +1917,7 @@ static int iscsit_handle_text_cmd(
                 if (conn->conn_ops->DataDigest) {
                         iscsit_do_crypto_hash_buf(&conn->conn_rx_hash,
                                         text_in, text_length,
-                                        padding, cmd->pad_bytes,
+                                        padding, (u8 *)&pad_bytes,
                                         (u8 *)&data_crc);
 
                         if (checksum != data_crc) {
@@ -2243,7 +2243,6 @@ static int iscsit_handle_snack(
         case 0:
                 return iscsit_handle_recovery_datain_or_r2t(conn, buf,
                         hdr->itt, hdr->ttt, hdr->begrun, hdr->runlength);
-                return 0;
         case ISCSI_FLAG_SNACK_TYPE_STATUS:
                 return iscsit_handle_status_snack(conn, hdr->itt, hdr->ttt,
                         hdr->begrun, hdr->runlength);
@@ -3468,7 +3467,12 @@ static inline void iscsit_thread_check_cpumask(
 }
 
 #else
-#define iscsit_thread_get_cpumask(X) ({})
+
+void iscsit_thread_get_cpumask(struct iscsi_conn *conn)
+{
+        return;
+}
+
 #define iscsit_thread_check_cpumask(X, Y, Z) ({})
 #endif /* CONFIG_SMP */
 
diff --git a/drivers/target/iscsi/iscsi_target_configfs.c b/drivers/target/iscsi/iscsi_target_configfs.c
index 32bb92c44450..f1643dbf6a92 100644
--- a/drivers/target/iscsi/iscsi_target_configfs.c
+++ b/drivers/target/iscsi/iscsi_target_configfs.c
@@ -181,7 +181,7 @@ struct se_tpg_np *lio_target_call_addnptotpg(
                 return ERR_PTR(-EOVERFLOW);
         }
         memset(buf, 0, MAX_PORTAL_LEN + 1);
-        snprintf(buf, MAX_PORTAL_LEN, "%s", name);
+        snprintf(buf, MAX_PORTAL_LEN + 1, "%s", name);
 
         memset(&sockaddr, 0, sizeof(struct __kernel_sockaddr_storage));
 
@@ -268,7 +268,7 @@ struct se_tpg_np *lio_target_call_addnptotpg(
                                 ISCSI_TCP);
         if (IS_ERR(tpg_np)) {
                 iscsit_put_tpg(tpg);
-                return ERR_PTR(PTR_ERR(tpg_np));
+                return ERR_CAST(tpg_np);
         }
         pr_debug("LIO_Target_ConfigFS: addnptotpg done!\n");
 
@@ -1285,7 +1285,7 @@ struct se_wwn *lio_target_call_coreaddtiqn(
 
         tiqn = iscsit_add_tiqn((unsigned char *)name);
         if (IS_ERR(tiqn))
-                return ERR_PTR(PTR_ERR(tiqn));
+                return ERR_CAST(tiqn);
         /*
          * Setup struct iscsi_wwn_stat_grps for se_wwn->fabric_stat_group.
          */
diff --git a/drivers/target/iscsi/iscsi_target_erl1.c b/drivers/target/iscsi/iscsi_target_erl1.c
index 980650792cf6..c4c68da3e500 100644
--- a/drivers/target/iscsi/iscsi_target_erl1.c
+++ b/drivers/target/iscsi/iscsi_target_erl1.c
@@ -834,7 +834,7 @@ static int iscsit_attach_ooo_cmdsn(
                          */
                         list_for_each_entry(ooo_tmp, &sess->sess_ooo_cmdsn_list,
                                                 ooo_list) {
-                                while (ooo_tmp->cmdsn < ooo_cmdsn->cmdsn)
+                                if (ooo_tmp->cmdsn < ooo_cmdsn->cmdsn)
                                         continue;
 
                                 list_add(&ooo_cmdsn->ooo_list,
diff --git a/drivers/target/iscsi/iscsi_target_login.c b/drivers/target/iscsi/iscsi_target_login.c
index bcaf82f47037..daad362a93ce 100644
--- a/drivers/target/iscsi/iscsi_target_login.c
+++ b/drivers/target/iscsi/iscsi_target_login.c
@@ -1013,19 +1013,9 @@ static int __iscsi_target_login_thread(struct iscsi_np *np)
                                         ISCSI_LOGIN_STATUS_TARGET_ERROR);
                         goto new_sess_out;
                 }
-#if 0
-                if (!iscsi_ntop6((const unsigned char *)
-                                &sock_in6.sin6_addr.in6_u,
-                                (char *)&conn->ipv6_login_ip[0],
-                                IPV6_ADDRESS_SPACE)) {
-                        pr_err("iscsi_ntop6() failed\n");
-                        iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
-                                        ISCSI_LOGIN_STATUS_TARGET_ERROR);
-                        goto new_sess_out;
-                }
-#else
-                pr_debug("Skipping iscsi_ntop6()\n");
-#endif
+                snprintf(conn->login_ip, sizeof(conn->login_ip), "%pI6c",
+                                &sock_in6.sin6_addr.in6_u);
+                conn->login_port = ntohs(sock_in6.sin6_port);
         } else {
                 memset(&sock_in, 0, sizeof(struct sockaddr_in));
 
diff --git a/drivers/target/iscsi/iscsi_target_nego.c b/drivers/target/iscsi/iscsi_target_nego.c
index 713a4d23557a..4d087ac11067 100644
--- a/drivers/target/iscsi/iscsi_target_nego.c
+++ b/drivers/target/iscsi/iscsi_target_nego.c
@@ -978,7 +978,7 @@ struct iscsi_login *iscsi_target_init_negotiation(
                 pr_err("Unable to allocate memory for struct iscsi_login.\n");
                 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
                                 ISCSI_LOGIN_STATUS_NO_RESOURCES);
-                goto out;
+                return NULL;
         }
 
         login->req = kzalloc(ISCSI_HDR_LEN, GFP_KERNEL);
diff --git a/drivers/target/iscsi/iscsi_target_parameters.c b/drivers/target/iscsi/iscsi_target_parameters.c
index 252e246cf51e..497b2e718a76 100644
--- a/drivers/target/iscsi/iscsi_target_parameters.c
+++ b/drivers/target/iscsi/iscsi_target_parameters.c
@@ -545,13 +545,13 @@ int iscsi_copy_param_list(
         struct iscsi_param_list *src_param_list,
         int leading)
 {
-        struct iscsi_param *new_param = NULL, *param = NULL;
+        struct iscsi_param *param = NULL;
+        struct iscsi_param *new_param = NULL;
         struct iscsi_param_list *param_list = NULL;
 
         param_list = kzalloc(sizeof(struct iscsi_param_list), GFP_KERNEL);
         if (!param_list) {
-                pr_err("Unable to allocate memory for"
-                                " struct iscsi_param_list.\n");
+                pr_err("Unable to allocate memory for struct iscsi_param_list.\n");
                 goto err_out;
         }
         INIT_LIST_HEAD(&param_list->param_list);
@@ -567,8 +567,17 @@ int iscsi_copy_param_list(
 
                 new_param = kzalloc(sizeof(struct iscsi_param), GFP_KERNEL);
                 if (!new_param) {
-                        pr_err("Unable to allocate memory for"
-                                " struct iscsi_param.\n");
+                        pr_err("Unable to allocate memory for struct iscsi_param.\n");
+                        goto err_out;
+                }
+
+                new_param->name = kstrdup(param->name, GFP_KERNEL);
+                new_param->value = kstrdup(param->value, GFP_KERNEL);
+                if (!new_param->value || !new_param->name) {
+                        kfree(new_param->value);
+                        kfree(new_param->name);
+                        kfree(new_param);
+                        pr_err("Unable to allocate memory for parameter name/value.\n");
                         goto err_out;
                 }
 
@@ -580,32 +589,12 @@ int iscsi_copy_param_list(
                 new_param->use = param->use;
                 new_param->type_range = param->type_range;
 
-                new_param->name = kzalloc(strlen(param->name) + 1, GFP_KERNEL);
-                if (!new_param->name) {
-                        pr_err("Unable to allocate memory for"
-                                " parameter name.\n");
-                        goto err_out;
-                }
-
-                new_param->value = kzalloc(strlen(param->value) + 1,
-                                GFP_KERNEL);
-                if (!new_param->value) {
-                        pr_err("Unable to allocate memory for"
-                                " parameter value.\n");
-                        goto err_out;
-                }
-
-                memcpy(new_param->name, param->name, strlen(param->name));
-                new_param->name[strlen(param->name)] = '\0';
-                memcpy(new_param->value, param->value, strlen(param->value));
-                new_param->value[strlen(param->value)] = '\0';
-
                 list_add_tail(&new_param->p_list, &param_list->param_list);
         }
 
-        if (!list_empty(&param_list->param_list))
+        if (!list_empty(&param_list->param_list)) {
                 *dst_param_list = param_list;
-        else {
+        } else {
                 pr_err("No parameters allocated.\n");
                 goto err_out;
         }
diff --git a/drivers/target/iscsi/iscsi_target_util.c b/drivers/target/iscsi/iscsi_target_util.c
index a1acb0167902..a0d23bc0fc98 100644
--- a/drivers/target/iscsi/iscsi_target_util.c
+++ b/drivers/target/iscsi/iscsi_target_util.c
@@ -243,7 +243,7 @@ struct iscsi_cmd *iscsit_allocate_se_cmd_for_tmr(
         if (!cmd->tmr_req) {
                 pr_err("Unable to allocate memory for"
                         " Task Management command!\n");
-                return NULL;
+                goto out;
         }
         /*
          * TASK_REASSIGN for ERL=2 / connection stays inside of
@@ -298,8 +298,6 @@ struct iscsi_cmd *iscsit_allocate_se_cmd_for_tmr(
         return cmd;
 out:
         iscsit_release_cmd(cmd);
-        if (se_cmd)
-                transport_free_se_cmd(se_cmd);
         return NULL;
 }
 
diff --git a/drivers/target/target_core_cdb.c b/drivers/target/target_core_cdb.c
index 8ae09a1bdf74..89ae923c5da6 100644
--- a/drivers/target/target_core_cdb.c
+++ b/drivers/target/target_core_cdb.c
@@ -67,6 +67,7 @@ target_emulate_inquiry_std(struct se_cmd *cmd)
 {
         struct se_lun *lun = cmd->se_lun;
         struct se_device *dev = cmd->se_dev;
+        struct se_portal_group *tpg = lun->lun_sep->sep_tpg;
         unsigned char *buf;
 
         /*
@@ -81,9 +82,13 @@ target_emulate_inquiry_std(struct se_cmd *cmd)
 
         buf = transport_kmap_first_data_page(cmd);
 
-        buf[0] = dev->transport->get_device_type(dev);
-        if (buf[0] == TYPE_TAPE)
-                buf[1] = 0x80;
+        if (dev == tpg->tpg_virt_lun0.lun_se_dev) {
+                buf[0] = 0x3f; /* Not connected */
+        } else {
+                buf[0] = dev->transport->get_device_type(dev);
+                if (buf[0] == TYPE_TAPE)
+                        buf[1] = 0x80;
+        }
         buf[2] = dev->transport->get_device_rev(dev);
 
         /*
@@ -915,8 +920,8 @@ target_emulate_modesense(struct se_cmd *cmd, int ten)
                 length += target_modesense_control(dev, &buf[offset+length]);
                 break;
         default:
-                pr_err("Got Unknown Mode Page: 0x%02x\n",
-                                cdb[2] & 0x3f);
+                pr_err("MODE SENSE: unimplemented page/subpage: 0x%02x/0x%02x\n",
+                       cdb[2] & 0x3f, cdb[3]);
                 return PYX_TRANSPORT_UNKNOWN_MODE_PAGE;
         }
         offset += length;
@@ -1072,8 +1077,6 @@ target_emulate_unmap(struct se_task *task)
                 size -= 16;
         }
 
-        task->task_scsi_status = GOOD;
-        transport_complete_task(task, 1);
 err:
         transport_kunmap_first_data_page(cmd);
 
@@ -1085,24 +1088,17 @@ err:
  * Note this is not used for TCM/pSCSI passthrough
  */
 static int
-target_emulate_write_same(struct se_task *task, int write_same32)
+target_emulate_write_same(struct se_task *task, u32 num_blocks)
 {
         struct se_cmd *cmd = task->task_se_cmd;
         struct se_device *dev = cmd->se_dev;
         sector_t range;
         sector_t lba = cmd->t_task_lba;
-        unsigned int num_blocks;
         int ret;
         /*
-         * Extract num_blocks from the WRITE_SAME_* CDB.  Then use the explict
-         * range when non zero is supplied, otherwise calculate the remaining
-         * range based on ->get_blocks() - starting LBA.
+         * Use the explicit range when non zero is supplied, otherwise calculate
+         * the remaining range based on ->get_blocks() - starting LBA.
          */
-        if (write_same32)
-                num_blocks = get_unaligned_be32(&cmd->t_task_cdb[28]);
-        else
-                num_blocks = get_unaligned_be32(&cmd->t_task_cdb[10]);
-
         if (num_blocks != 0)
                 range = num_blocks;
         else
@@ -1117,8 +1113,6 @@ target_emulate_write_same(struct se_task *task, int write_same32)
                 return ret;
         }
 
-        task->task_scsi_status = GOOD;
-        transport_complete_task(task, 1);
         return 0;
 }
 
@@ -1165,13 +1159,23 @@ transport_emulate_control_cdb(struct se_task *task)
                 }
                 ret = target_emulate_unmap(task);
                 break;
+        case WRITE_SAME:
+                if (!dev->transport->do_discard) {
+                        pr_err("WRITE_SAME emulation not supported"
+                                        " for: %s\n", dev->transport->name);
+                        return PYX_TRANSPORT_UNKNOWN_SAM_OPCODE;
+                }
+                ret = target_emulate_write_same(task,
+                                get_unaligned_be16(&cmd->t_task_cdb[7]));
+                break;
         case WRITE_SAME_16:
                 if (!dev->transport->do_discard) {
                         pr_err("WRITE_SAME_16 emulation not supported"
                                         " for: %s\n", dev->transport->name);
                         return PYX_TRANSPORT_UNKNOWN_SAM_OPCODE;
                 }
-                ret = target_emulate_write_same(task, 0);
+                ret = target_emulate_write_same(task,
+                                get_unaligned_be32(&cmd->t_task_cdb[10]));
                 break;
         case VARIABLE_LENGTH_CMD:
                 service_action =
@@ -1184,7 +1188,8 @@ transport_emulate_control_cdb(struct se_task *task)
                                         dev->transport->name);
                                 return PYX_TRANSPORT_UNKNOWN_SAM_OPCODE;
                         }
-                        ret = target_emulate_write_same(task, 1);
+                        ret = target_emulate_write_same(task,
+                                get_unaligned_be32(&cmd->t_task_cdb[28]));
                         break;
                 default:
                         pr_err("Unsupported VARIABLE_LENGTH_CMD SA:"
@@ -1219,8 +1224,14 @@ transport_emulate_control_cdb(struct se_task *task)
 
         if (ret < 0)
                 return ret;
-        task->task_scsi_status = GOOD;
-        transport_complete_task(task, 1);
+        /*
+         * Handle the successful completion here unless a caller
+         * has explictly requested an asychronous completion.
+         */
+        if (!(cmd->se_cmd_flags & SCF_EMULATE_CDB_ASYNC)) {
+                task->task_scsi_status = GOOD;
+                transport_complete_task(task, 1);
+        }
 
         return PYX_TRANSPORT_SENT_TO_TRANSPORT;
 }
diff --git a/drivers/target/target_core_device.c b/drivers/target/target_core_device.c
index b38b6c993e65..ca6e4a4df134 100644
--- a/drivers/target/target_core_device.c
+++ b/drivers/target/target_core_device.c
@@ -472,9 +472,9 @@ void core_clear_lun_from_tpg(struct se_lun *lun, struct se_portal_group *tpg)
         struct se_dev_entry *deve;
         u32 i;
 
-        spin_lock_bh(&tpg->acl_node_lock);
+        spin_lock_irq(&tpg->acl_node_lock);
         list_for_each_entry(nacl, &tpg->acl_node_list, acl_list) {
-                spin_unlock_bh(&tpg->acl_node_lock);
+                spin_unlock_irq(&tpg->acl_node_lock);
 
                 spin_lock_irq(&nacl->device_list_lock);
                 for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) {
@@ -491,9 +491,9 @@ void core_clear_lun_from_tpg(struct se_lun *lun, struct se_portal_group *tpg)
                 }
                 spin_unlock_irq(&nacl->device_list_lock);
 
-                spin_lock_bh(&tpg->acl_node_lock);
+                spin_lock_irq(&tpg->acl_node_lock);
         }
-        spin_unlock_bh(&tpg->acl_node_lock);
+        spin_unlock_irq(&tpg->acl_node_lock);
 }
 
 static struct se_port *core_alloc_port(struct se_device *dev)
@@ -839,6 +839,24 @@ int se_dev_check_shutdown(struct se_device *dev)
         return ret;
 }
 
+u32 se_dev_align_max_sectors(u32 max_sectors, u32 block_size)
+{
+        u32 tmp, aligned_max_sectors;
+        /*
+         * Limit max_sectors to a PAGE_SIZE aligned value for modern
+         * transport_allocate_data_tasks() operation.
+         */
+        tmp = rounddown((max_sectors * block_size), PAGE_SIZE);
+        aligned_max_sectors = (tmp / block_size);
+        if (max_sectors != aligned_max_sectors) {
+                printk(KERN_INFO "Rounding down aligned max_sectors from %u"
+                                " to %u\n", max_sectors, aligned_max_sectors);
+                return aligned_max_sectors;
+        }
+
+        return max_sectors;
+}
+
 void se_dev_set_default_attribs(
         struct se_device *dev,
         struct se_dev_limits *dev_limits)
@@ -878,6 +896,11 @@ void se_dev_set_default_attribs(
          * max_sectors is based on subsystem plugin dependent requirements.
          */
         dev->se_sub_dev->se_dev_attrib.hw_max_sectors = limits->max_hw_sectors;
+        /*
+         * Align max_sectors down to PAGE_SIZE to follow transport_allocate_data_tasks()
+         */
+        limits->max_sectors = se_dev_align_max_sectors(limits->max_sectors,
+                                                limits->logical_block_size);
         dev->se_sub_dev->se_dev_attrib.max_sectors = limits->max_sectors;
         /*
          * Set optimal_sectors from max_sectors, which can be lowered via
@@ -1242,6 +1265,11 @@ int se_dev_set_max_sectors(struct se_device *dev, u32 max_sectors)
                         return -EINVAL;
                 }
         }
+        /*
+         * Align max_sectors down to PAGE_SIZE to follow transport_allocate_data_tasks()
+         */
+        max_sectors = se_dev_align_max_sectors(max_sectors,
+                                dev->se_sub_dev->se_dev_attrib.block_size);
 
         dev->se_sub_dev->se_dev_attrib.max_sectors = max_sectors;
         pr_debug("dev[%p]: SE Device max_sectors changed to %u\n",
@@ -1344,15 +1372,17 @@ struct se_lun *core_dev_add_lun(
          */
         if (tpg->se_tpg_tfo->tpg_check_demo_mode(tpg)) {
                 struct se_node_acl *acl;
-                spin_lock_bh(&tpg->acl_node_lock);
+                spin_lock_irq(&tpg->acl_node_lock);
                 list_for_each_entry(acl, &tpg->acl_node_list, acl_list) {
-                        if (acl->dynamic_node_acl) {
-                                spin_unlock_bh(&tpg->acl_node_lock);
+                        if (acl->dynamic_node_acl &&
+                            (!tpg->se_tpg_tfo->tpg_check_demo_mode_login_only ||
+                             !tpg->se_tpg_tfo->tpg_check_demo_mode_login_only(tpg))) {
+                                spin_unlock_irq(&tpg->acl_node_lock);
                                 core_tpg_add_node_to_devs(acl, tpg);
-                                spin_lock_bh(&tpg->acl_node_lock);
+                                spin_lock_irq(&tpg->acl_node_lock);
                         }
                 }
-                spin_unlock_bh(&tpg->acl_node_lock);
+                spin_unlock_irq(&tpg->acl_node_lock);
         }
 
         return lun_p;
diff --git a/drivers/target/target_core_fabric_configfs.c b/drivers/target/target_core_fabric_configfs.c
index f1654694f4ea..55bbe0847a6d 100644
--- a/drivers/target/target_core_fabric_configfs.c
+++ b/drivers/target/target_core_fabric_configfs.c
@@ -481,7 +481,7 @@ static struct config_group *target_fabric_make_nodeacl(
 
         se_nacl = tf->tf_ops.fabric_make_nodeacl(se_tpg, group, name);
         if (IS_ERR(se_nacl))
-                return ERR_PTR(PTR_ERR(se_nacl));
+                return ERR_CAST(se_nacl);
 
         nacl_cg = &se_nacl->acl_group;
         nacl_cg->default_groups = se_nacl->acl_default_groups;
diff --git a/drivers/target/target_core_pr.c b/drivers/target/target_core_pr.c
index 1c1b849cd4fb..7fd3a161f7cc 100644
--- a/drivers/target/target_core_pr.c
+++ b/drivers/target/target_core_pr.c
@@ -1598,14 +1598,14 @@ static int core_scsi3_decode_spec_i_port(
                          * from the decoded fabric module specific TransportID
                          * at *i_str.
                          */
-                        spin_lock_bh(&tmp_tpg->acl_node_lock);
+                        spin_lock_irq(&tmp_tpg->acl_node_lock);
                         dest_node_acl = __core_tpg_get_initiator_node_acl(
                                                 tmp_tpg, i_str);
                         if (dest_node_acl) {
                                 atomic_inc(&dest_node_acl->acl_pr_ref_count);
                                 smp_mb__after_atomic_inc();
                         }
-                        spin_unlock_bh(&tmp_tpg->acl_node_lock);
+                        spin_unlock_irq(&tmp_tpg->acl_node_lock);
 
                         if (!dest_node_acl) {
                                 core_scsi3_tpg_undepend_item(tmp_tpg);
@@ -3496,14 +3496,14 @@ after_iport_check:
         /*
          * Locate the destination struct se_node_acl from the received Transport ID
          */
-        spin_lock_bh(&dest_se_tpg->acl_node_lock);
+        spin_lock_irq(&dest_se_tpg->acl_node_lock);
         dest_node_acl = __core_tpg_get_initiator_node_acl(dest_se_tpg,
                                 initiator_str);
         if (dest_node_acl) {
                 atomic_inc(&dest_node_acl->acl_pr_ref_count);
                 smp_mb__after_atomic_inc();
         }
-        spin_unlock_bh(&dest_se_tpg->acl_node_lock);
+        spin_unlock_irq(&dest_se_tpg->acl_node_lock);
 
         if (!dest_node_acl) {
                 pr_err("Unable to locate %s dest_node_acl for"
diff --git a/drivers/target/target_core_rd.c b/drivers/target/target_core_rd.c
index 3dd81d24d9a9..e567e129c697 100644
--- a/drivers/target/target_core_rd.c
+++ b/drivers/target/target_core_rd.c
@@ -390,12 +390,10 @@ static int rd_MEMCPY_read(struct rd_request *req)
                                 length = req->rd_size;
 
                         dst = sg_virt(&sg_d[i++]) + dst_offset;
-                        if (!dst)
-                                BUG();
+                        BUG_ON(!dst);
 
                         src = sg_virt(&sg_s[j]) + src_offset;
-                        if (!src)
-                                BUG();
+                        BUG_ON(!src);
 
                         dst_offset = 0;
                         src_offset = length;
@@ -415,8 +413,7 @@ static int rd_MEMCPY_read(struct rd_request *req)
                                 length = req->rd_size;
 
                         dst = sg_virt(&sg_d[i]) + dst_offset;
-                        if (!dst)
-                                BUG();
+                        BUG_ON(!dst);
 
                         if (sg_d[i].length == length) {
                                 i++;
@@ -425,8 +422,7 @@ static int rd_MEMCPY_read(struct rd_request *req)
                                 dst_offset = length;
 
                         src = sg_virt(&sg_s[j++]) + src_offset;
-                        if (!src)
-                                BUG();
+                        BUG_ON(!src);
 
                         src_offset = 0;
                         page_end = 1;
@@ -510,12 +506,10 @@ static int rd_MEMCPY_write(struct rd_request *req)
                                 length = req->rd_size;
 
                         src = sg_virt(&sg_s[i++]) + src_offset;
-                        if (!src)
-                                BUG();
+                        BUG_ON(!src);
 
                         dst = sg_virt(&sg_d[j]) + dst_offset;
-                        if (!dst)
-                                BUG();
+                        BUG_ON(!dst);
 
                         src_offset = 0;
                         dst_offset = length;
@@ -535,8 +529,7 @@ static int rd_MEMCPY_write(struct rd_request *req)
                                 length = req->rd_size;
 
                         src = sg_virt(&sg_s[i]) + src_offset;
-                        if (!src)
-                                BUG();
+                        BUG_ON(!src);
 
                         if (sg_s[i].length == length) {
                                 i++;
@@ -545,8 +538,7 @@ static int rd_MEMCPY_write(struct rd_request *req)
                                 src_offset = length;
 
                         dst = sg_virt(&sg_d[j++]) + dst_offset;
-                        if (!dst)
-                                BUG();
+                        BUG_ON(!dst);
 
                         dst_offset = 0;
                         page_end = 1;
diff --git a/drivers/target/target_core_tpg.c b/drivers/target/target_core_tpg.c
index 4f1ba4c5ef11..162b736c7342 100644
--- a/drivers/target/target_core_tpg.c
+++ b/drivers/target/target_core_tpg.c
@@ -137,15 +137,15 @@ struct se_node_acl *core_tpg_get_initiator_node_acl(
 {
         struct se_node_acl *acl;
 
-        spin_lock_bh(&tpg->acl_node_lock);
+        spin_lock_irq(&tpg->acl_node_lock);
         list_for_each_entry(acl, &tpg->acl_node_list, acl_list) {
                 if (!strcmp(acl->initiatorname, initiatorname) &&
                     !acl->dynamic_node_acl) {
-                        spin_unlock_bh(&tpg->acl_node_lock);
+                        spin_unlock_irq(&tpg->acl_node_lock);
                         return acl;
                 }
         }
-        spin_unlock_bh(&tpg->acl_node_lock);
+        spin_unlock_irq(&tpg->acl_node_lock);
 
         return NULL;
 }
@@ -298,13 +298,21 @@ struct se_node_acl *core_tpg_check_initiator_node_acl(
                 tpg->se_tpg_tfo->tpg_release_fabric_acl(tpg, acl);
                 return NULL;
         }
+        /*
+         * Here we only create demo-mode MappedLUNs from the active
+         * TPG LUNs if the fabric is not explictly asking for
+         * tpg_check_demo_mode_login_only() == 1.
+         */
+        if ((tpg->se_tpg_tfo->tpg_check_demo_mode_login_only != NULL) &&
+            (tpg->se_tpg_tfo->tpg_check_demo_mode_login_only(tpg) == 1))
+                do { ; } while (0);
+        else
+                core_tpg_add_node_to_devs(acl, tpg);
 
-        core_tpg_add_node_to_devs(acl, tpg);
-
-        spin_lock_bh(&tpg->acl_node_lock);
+        spin_lock_irq(&tpg->acl_node_lock);
         list_add_tail(&acl->acl_list, &tpg->acl_node_list);
         tpg->num_node_acls++;
-        spin_unlock_bh(&tpg->acl_node_lock);
+        spin_unlock_irq(&tpg->acl_node_lock);
 
         pr_debug("%s_TPG[%u] - Added DYNAMIC ACL with TCQ Depth: %d for %s"
                 " Initiator Node: %s\n", tpg->se_tpg_tfo->get_fabric_name(),
@@ -354,7 +362,7 @@ struct se_node_acl *core_tpg_add_initiator_node_acl(
 {
         struct se_node_acl *acl = NULL;
 
-        spin_lock_bh(&tpg->acl_node_lock);
+        spin_lock_irq(&tpg->acl_node_lock);
         acl = __core_tpg_get_initiator_node_acl(tpg, initiatorname);
         if (acl) {
                 if (acl->dynamic_node_acl) {
@@ -362,7 +370,7 @@ struct se_node_acl *core_tpg_add_initiator_node_acl(
                         pr_debug("%s_TPG[%u] - Replacing dynamic ACL"
                                 " for %s\n", tpg->se_tpg_tfo->get_fabric_name(),
                                 tpg->se_tpg_tfo->tpg_get_tag(tpg), initiatorname);
-                        spin_unlock_bh(&tpg->acl_node_lock);
+                        spin_unlock_irq(&tpg->acl_node_lock);
                         /*
                          * Release the locally allocated struct se_node_acl
                          * because * core_tpg_add_initiator_node_acl() returned
@@ -378,10 +386,10 @@ struct se_node_acl *core_tpg_add_initiator_node_acl(
                         " Node %s already exists for TPG %u, ignoring"
                         " request.\n",  tpg->se_tpg_tfo->get_fabric_name(),
                         initiatorname, tpg->se_tpg_tfo->tpg_get_tag(tpg));
-                spin_unlock_bh(&tpg->acl_node_lock);
+                spin_unlock_irq(&tpg->acl_node_lock);
                 return ERR_PTR(-EEXIST);
         }
-        spin_unlock_bh(&tpg->acl_node_lock);
+        spin_unlock_irq(&tpg->acl_node_lock);
 
         if (!se_nacl) {
                 pr_err("struct se_node_acl pointer is NULL\n");
@@ -418,10 +426,10 @@ struct se_node_acl *core_tpg_add_initiator_node_acl(
                 return ERR_PTR(-EINVAL);
         }
 
-        spin_lock_bh(&tpg->acl_node_lock);
+        spin_lock_irq(&tpg->acl_node_lock);
         list_add_tail(&acl->acl_list, &tpg->acl_node_list);
         tpg->num_node_acls++;
-        spin_unlock_bh(&tpg->acl_node_lock);
+        spin_unlock_irq(&tpg->acl_node_lock);
 
 done:
         pr_debug("%s_TPG[%hu] - Added ACL with TCQ Depth: %d for %s"
@@ -445,14 +453,14 @@ int core_tpg_del_initiator_node_acl(
         struct se_session *sess, *sess_tmp;
         int dynamic_acl = 0;
 
-        spin_lock_bh(&tpg->acl_node_lock);
+        spin_lock_irq(&tpg->acl_node_lock);
         if (acl->dynamic_node_acl) {
                 acl->dynamic_node_acl = 0;
                 dynamic_acl = 1;
         }
         list_del(&acl->acl_list);
         tpg->num_node_acls--;
-        spin_unlock_bh(&tpg->acl_node_lock);
+        spin_unlock_irq(&tpg->acl_node_lock);
 
         spin_lock_bh(&tpg->session_lock);
         list_for_each_entry_safe(sess, sess_tmp,
@@ -503,21 +511,21 @@ int core_tpg_set_initiator_node_queue_depth(
         struct se_node_acl *acl;
         int dynamic_acl = 0;
 
-        spin_lock_bh(&tpg->acl_node_lock);
+        spin_lock_irq(&tpg->acl_node_lock);
         acl = __core_tpg_get_initiator_node_acl(tpg, initiatorname);
         if (!acl) {
                 pr_err("Access Control List entry for %s Initiator"
                         " Node %s does not exists for TPG %hu, ignoring"
                         " request.\n", tpg->se_tpg_tfo->get_fabric_name(),
                         initiatorname, tpg->se_tpg_tfo->tpg_get_tag(tpg));
-                spin_unlock_bh(&tpg->acl_node_lock);
+                spin_unlock_irq(&tpg->acl_node_lock);
                 return -ENODEV;
         }
         if (acl->dynamic_node_acl) {
                 acl->dynamic_node_acl = 0;
                 dynamic_acl = 1;
         }
-        spin_unlock_bh(&tpg->acl_node_lock);
+        spin_unlock_irq(&tpg->acl_node_lock);
 
         spin_lock_bh(&tpg->session_lock);
         list_for_each_entry(sess, &tpg->tpg_sess_list, sess_list) {
@@ -533,10 +541,10 @@ int core_tpg_set_initiator_node_queue_depth(
                                 tpg->se_tpg_tfo->get_fabric_name(), initiatorname);
                         spin_unlock_bh(&tpg->session_lock);
 
-                        spin_lock_bh(&tpg->acl_node_lock);
+                        spin_lock_irq(&tpg->acl_node_lock);
                         if (dynamic_acl)
                                 acl->dynamic_node_acl = 1;
-                        spin_unlock_bh(&tpg->acl_node_lock);
+                        spin_unlock_irq(&tpg->acl_node_lock);
                         return -EEXIST;
                 }
                 /*
@@ -571,10 +579,10 @@ int core_tpg_set_initiator_node_queue_depth(
                 if (init_sess)
                         tpg->se_tpg_tfo->close_session(init_sess);
 
-                spin_lock_bh(&tpg->acl_node_lock);
+                spin_lock_irq(&tpg->acl_node_lock);
                 if (dynamic_acl)
                         acl->dynamic_node_acl = 1;
-                spin_unlock_bh(&tpg->acl_node_lock);
+                spin_unlock_irq(&tpg->acl_node_lock);
                 return -EINVAL;
         }
         spin_unlock_bh(&tpg->session_lock);
@@ -590,10 +598,10 @@ int core_tpg_set_initiator_node_queue_depth(
                 initiatorname, tpg->se_tpg_tfo->get_fabric_name(),
                 tpg->se_tpg_tfo->tpg_get_tag(tpg));
 
-        spin_lock_bh(&tpg->acl_node_lock);
+        spin_lock_irq(&tpg->acl_node_lock);
         if (dynamic_acl)
                 acl->dynamic_node_acl = 1;
-        spin_unlock_bh(&tpg->acl_node_lock);
+        spin_unlock_irq(&tpg->acl_node_lock);
 
         return 0;
 }
@@ -717,20 +725,20 @@ int core_tpg_deregister(struct se_portal_group *se_tpg)
          * not been released because of TFO->tpg_check_demo_mode_cache() == 1
          * in transport_deregister_session().
          */
-        spin_lock_bh(&se_tpg->acl_node_lock);
+        spin_lock_irq(&se_tpg->acl_node_lock);
         list_for_each_entry_safe(nacl, nacl_tmp, &se_tpg->acl_node_list,
                         acl_list) {
                 list_del(&nacl->acl_list);
                 se_tpg->num_node_acls--;
-                spin_unlock_bh(&se_tpg->acl_node_lock);
+                spin_unlock_irq(&se_tpg->acl_node_lock);
 
                 core_tpg_wait_for_nacl_pr_ref(nacl);
                 core_free_device_list_for_node(nacl, se_tpg);
                 se_tpg->se_tpg_tfo->tpg_release_fabric_acl(se_tpg, nacl);
 
-                spin_lock_bh(&se_tpg->acl_node_lock);
+                spin_lock_irq(&se_tpg->acl_node_lock);
         }
-        spin_unlock_bh(&se_tpg->acl_node_lock);
+        spin_unlock_irq(&se_tpg->acl_node_lock);
 
         if (se_tpg->se_tpg_type == TRANSPORT_TPG_TYPE_NORMAL)
                 core_tpg_release_virtual_lun0(se_tpg);
diff --git a/drivers/target/target_core_transport.c b/drivers/target/target_core_transport.c
index c75a01a1c475..8d0c58ea6316 100644
--- a/drivers/target/target_core_transport.c
+++ b/drivers/target/target_core_transport.c
@@ -389,17 +389,18 @@ void transport_deregister_session(struct se_session *se_sess)
 {
         struct se_portal_group *se_tpg = se_sess->se_tpg;
         struct se_node_acl *se_nacl;
+        unsigned long flags;
 
         if (!se_tpg) {
                 transport_free_session(se_sess);
                 return;
         }
 
-        spin_lock_bh(&se_tpg->session_lock);
+        spin_lock_irqsave(&se_tpg->session_lock, flags);
         list_del(&se_sess->sess_list);
         se_sess->se_tpg = NULL;
         se_sess->fabric_sess_ptr = NULL;
-        spin_unlock_bh(&se_tpg->session_lock);
+        spin_unlock_irqrestore(&se_tpg->session_lock, flags);
 
         /*
          * Determine if we need to do extra work for this initiator node's
@@ -407,22 +408,22 @@ void transport_deregister_session(struct se_session *se_sess)
          */
         se_nacl = se_sess->se_node_acl;
         if (se_nacl) {
-                spin_lock_bh(&se_tpg->acl_node_lock);
+                spin_lock_irqsave(&se_tpg->acl_node_lock, flags);
                 if (se_nacl->dynamic_node_acl) {
                         if (!se_tpg->se_tpg_tfo->tpg_check_demo_mode_cache(
                                         se_tpg)) {
                                 list_del(&se_nacl->acl_list);
                                 se_tpg->num_node_acls--;
-                                spin_unlock_bh(&se_tpg->acl_node_lock);
+                                spin_unlock_irqrestore(&se_tpg->acl_node_lock, flags);
 
                                 core_tpg_wait_for_nacl_pr_ref(se_nacl);
                                 core_free_device_list_for_node(se_nacl, se_tpg);
                                 se_tpg->se_tpg_tfo->tpg_release_fabric_acl(se_tpg,
                                                 se_nacl);
-                                spin_lock_bh(&se_tpg->acl_node_lock);
+                                spin_lock_irqsave(&se_tpg->acl_node_lock, flags);
                         }
                 }
-                spin_unlock_bh(&se_tpg->acl_node_lock);
+                spin_unlock_irqrestore(&se_tpg->acl_node_lock, flags);
         }
 
         transport_free_session(se_sess);
@@ -1747,6 +1748,8 @@ int transport_generic_handle_cdb(
 }
 EXPORT_SYMBOL(transport_generic_handle_cdb);
 
+static void transport_generic_request_failure(struct se_cmd *,
+                        struct se_device *, int, int);
 /*
  * Used by fabric module frontends to queue tasks directly.
  * Many only be used from process context only
@@ -1754,6 +1757,8 @@ EXPORT_SYMBOL(transport_generic_handle_cdb);
 int transport_handle_cdb_direct(
         struct se_cmd *cmd)
 {
+        int ret;
+
         if (!cmd->se_lun) {
                 dump_stack();
                 pr_err("cmd->se_lun is NULL\n");
@@ -1765,8 +1770,31 @@ int transport_handle_cdb_direct(
                                 " from interrupt context\n");
                 return -EINVAL;
         }
-
-        return transport_generic_new_cmd(cmd);
+        /*
+         * Set TRANSPORT_NEW_CMD state and cmd->t_transport_active=1 following
+         * transport_generic_handle_cdb*() -> transport_add_cmd_to_queue()
+         * in existing usage to ensure that outstanding descriptors are handled
+         * correctly during shutdown via transport_generic_wait_for_tasks()
+         *
+         * Also, we don't take cmd->t_state_lock here as we only expect
+         * this to be called for initial descriptor submission.
+         */
+        cmd->t_state = TRANSPORT_NEW_CMD;
+        atomic_set(&cmd->t_transport_active, 1);
+        /*
+         * transport_generic_new_cmd() is already handling QUEUE_FULL,
+         * so follow TRANSPORT_NEW_CMD processing thread context usage
+         * and call transport_generic_request_failure() if necessary..
+         */
+        ret = transport_generic_new_cmd(cmd);
+        if (ret == -EAGAIN)
+                return 0;
+        else if (ret < 0) {
+                cmd->transport_error_status = ret;
+                transport_generic_request_failure(cmd, NULL, 0,
+                                (cmd->data_direction != DMA_TO_DEVICE));
+        }
+        return 0;
 }
 EXPORT_SYMBOL(transport_handle_cdb_direct);
 
@@ -2026,8 +2054,14 @@ static void transport_generic_request_failure(
                 cmd->scsi_sense_reason = TCM_UNSUPPORTED_SCSI_OPCODE;
                 break;
         }
-
-        if (!sc)
+        /*
+         * If a fabric does not define a cmd->se_tfo->new_cmd_map caller,
+         * make the call to transport_send_check_condition_and_sense()
+         * directly.  Otherwise expect the fabric to make the call to
+         * transport_send_check_condition_and_sense() after handling
+         * possible unsoliticied write data payloads.
+         */
+        if (!sc && !cmd->se_tfo->new_cmd_map)
                 transport_new_cmd_failure(cmd);
         else {
                 ret = transport_send_check_condition_and_sense(cmd,
@@ -2820,12 +2854,42 @@ static int transport_cmd_get_valid_sectors(struct se_cmd *cmd)
                         " transport_dev_end_lba(): %llu\n",
                         cmd->t_task_lba, sectors,
                         transport_dev_end_lba(dev));
-                pr_err("  We should return CHECK_CONDITION"
-                       " but we don't yet\n");
-                return 0;
+                return -EINVAL;
         }
 
-        return sectors;
+        return 0;
+}
+
+static int target_check_write_same_discard(unsigned char *flags, struct se_device *dev)
+{
+        /*
+         * Determine if the received WRITE_SAME is used to for direct
+         * passthrough into Linux/SCSI with struct request via TCM/pSCSI
+         * or we are signaling the use of internal WRITE_SAME + UNMAP=1
+         * emulation for -> Linux/BLOCK disbard with TCM/IBLOCK code.
+         */
+        int passthrough = (dev->transport->transport_type ==
+                                TRANSPORT_PLUGIN_PHBA_PDEV);
+
+        if (!passthrough) {
+                if ((flags[0] & 0x04) || (flags[0] & 0x02)) {
+                        pr_err("WRITE_SAME PBDATA and LBDATA"
+                                " bits not supported for Block Discard"
+                                " Emulation\n");
+                        return -ENOSYS;
+                }
+                /*
+                 * Currently for the emulated case we only accept
+                 * tpws with the UNMAP=1 bit set.
+                 */
+                if (!(flags[0] & 0x08)) {
+                        pr_err("WRITE_SAME w/o UNMAP bit not"
+                                " supported for Block Discard Emulation\n");
+                        return -ENOSYS;
+                }
+        }
+
+        return 0;
 }
 
 /*      transport_generic_cmd_sequencer():
@@ -3038,7 +3102,7 @@ static int transport_generic_cmd_sequencer(
                                 goto out_unsupported_cdb;
 
                         if (sectors)
-                                size = transport_get_size(sectors, cdb, cmd);
+                                size = transport_get_size(1, cdb, cmd);
                         else {
                                 pr_err("WSNZ=1, WRITE_SAME w/sectors=0 not"
                                        " supported\n");
@@ -3048,27 +3112,9 @@ static int transport_generic_cmd_sequencer(
                         cmd->t_task_lba = get_unaligned_be64(&cdb[12]);
                         cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
 
-                        /*
-                         * Skip the remaining assignments for TCM/PSCSI passthrough
-                         */
-                        if (passthrough)
-                                break;
-
-                        if ((cdb[10] & 0x04) || (cdb[10] & 0x02)) {
-                                pr_err("WRITE_SAME PBDATA and LBDATA"
-                                        " bits not supported for Block Discard"
-                                        " Emulation\n");
-                                goto out_invalid_cdb_field;
-                        }
-                        /*
-                         * Currently for the emulated case we only accept
-                         * tpws with the UNMAP=1 bit set.
-                         */
-                        if (!(cdb[10] & 0x08)) {
-                                pr_err("WRITE_SAME w/o UNMAP bit not"
-                                        " supported for Block Discard Emulation\n");
+                        if (target_check_write_same_discard(&cdb[10], dev) < 0)
                                 goto out_invalid_cdb_field;
-                        }
+
                         break;
                 default:
                         pr_err("VARIABLE_LENGTH_CMD service action"
@@ -3303,10 +3349,12 @@ static int transport_generic_cmd_sequencer(
                 cmd->se_cmd_flags |= SCF_EMULATE_CDB_ASYNC;
                 /*
                  * Check to ensure that LBA + Range does not exceed past end of
-                 * device.
+                 * device for IBLOCK and FILEIO ->do_sync_cache() backend calls
                  */
-                if (!transport_cmd_get_valid_sectors(cmd))
-                        goto out_invalid_cdb_field;
+                if ((cmd->t_task_lba != 0) || (sectors != 0)) {
+                        if (transport_cmd_get_valid_sectors(cmd) < 0)
+                                goto out_invalid_cdb_field;
+                }
                 break;
         case UNMAP:
                 size = get_unaligned_be16(&cdb[7]);
@@ -3318,40 +3366,38 @@ static int transport_generic_cmd_sequencer(
                         goto out_unsupported_cdb;
 
                 if (sectors)
-                        size = transport_get_size(sectors, cdb, cmd);
+                        size = transport_get_size(1, cdb, cmd);
                 else {
                         pr_err("WSNZ=1, WRITE_SAME w/sectors=0 not supported\n");
                         goto out_invalid_cdb_field;
                 }
 
-                cmd->t_task_lba = get_unaligned_be16(&cdb[2]);
-                passthrough = (dev->transport->transport_type ==
-                                TRANSPORT_PLUGIN_PHBA_PDEV);
-                /*
-                 * Determine if the received WRITE_SAME_16 is used to for direct
-                 * passthrough into Linux/SCSI with struct request via TCM/pSCSI
-                 * or we are signaling the use of internal WRITE_SAME + UNMAP=1
-                 * emulation for -> Linux/BLOCK disbard with TCM/IBLOCK and
-                 * TCM/FILEIO subsystem plugin backstores.
-                 */
-                if (!passthrough) {
-                        if ((cdb[1] & 0x04) || (cdb[1] & 0x02)) {
-                                pr_err("WRITE_SAME PBDATA and LBDATA"
-                                        " bits not supported for Block Discard"
-                                        " Emulation\n");
-                                goto out_invalid_cdb_field;
-                        }
-                        /*
-                         * Currently for the emulated case we only accept
-                         * tpws with the UNMAP=1 bit set.
-                         */
-                        if (!(cdb[1] & 0x08)) {
-                                pr_err("WRITE_SAME w/o UNMAP bit not "
-                                        " supported for Block Discard Emulation\n");
-                                goto out_invalid_cdb_field;
-                        }
+                cmd->t_task_lba = get_unaligned_be64(&cdb[2]);
+                cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
+
+                if (target_check_write_same_discard(&cdb[1], dev) < 0)
+                        goto out_invalid_cdb_field;
+                break;
+        case WRITE_SAME:
+                sectors = transport_get_sectors_10(cdb, cmd, &sector_ret);
+                if (sector_ret)
+                        goto out_unsupported_cdb;
+
+                if (sectors)
+                        size = transport_get_size(1, cdb, cmd);
+                else {
+                        pr_err("WSNZ=1, WRITE_SAME w/sectors=0 not supported\n");
+                        goto out_invalid_cdb_field;
                 }
+
+                cmd->t_task_lba = get_unaligned_be32(&cdb[2]);
                 cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
+                /*
+                 * Follow sbcr26 with WRITE_SAME (10) and check for the existence
+                 * of byte 1 bit 3 UNMAP instead of original reserved field
+                 */
+                if (target_check_write_same_discard(&cdb[1], dev) < 0)
+                        goto out_invalid_cdb_field;
                 break;
         case ALLOW_MEDIUM_REMOVAL:
         case GPCMD_CLOSE_TRACK:
@@ -3846,9 +3892,7 @@ EXPORT_SYMBOL(transport_generic_map_mem_to_cmd);
 static int transport_new_cmd_obj(struct se_cmd *cmd)
 {
         struct se_device *dev = cmd->se_dev;
-        u32 task_cdbs;
-        u32 rc;
-        int set_counts = 1;
+        int set_counts = 1, rc, task_cdbs;
 
         /*
          * Setup any BIDI READ tasks and memory from
@@ -3866,7 +3910,7 @@ static int transport_new_cmd_obj(struct se_cmd *cmd)
                         cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION;
                         cmd->scsi_sense_reason =
                                 TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
-                        return PYX_TRANSPORT_LU_COMM_FAILURE;
+                        return -EINVAL;
                 }
                 atomic_inc(&cmd->t_fe_count);
                 atomic_inc(&cmd->t_se_count);
@@ -3885,7 +3929,7 @@ static int transport_new_cmd_obj(struct se_cmd *cmd)
                 cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION;
                 cmd->scsi_sense_reason =
                         TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
-                return PYX_TRANSPORT_LU_COMM_FAILURE;
+                return -EINVAL;
         }
 
         if (set_counts) {
@@ -4001,8 +4045,6 @@ void transport_do_task_sg_chain(struct se_cmd *cmd)
                 if (!task->task_sg)
                         continue;
 
-                BUG_ON(!task->task_padded_sg);
-
                 if (!sg_first) {
                         sg_first = task->task_sg;
                         chained_nents = task->task_sg_nents;
@@ -4010,9 +4052,19 @@ void transport_do_task_sg_chain(struct se_cmd *cmd)
                         sg_chain(sg_prev, sg_prev_nents, task->task_sg);
                         chained_nents += task->task_sg_nents;
                 }
+                /*
+                 * For the padded tasks, use the extra SGL vector allocated
+                 * in transport_allocate_data_tasks() for the sg_prev_nents
+                 * offset into sg_chain() above..  The last task of a
+                 * multi-task list, or a single task will not have
+                 * task->task_sg_padded set..
+                 */
+                if (task->task_padded_sg)
+                        sg_prev_nents = (task->task_sg_nents + 1);
+                else
+                        sg_prev_nents = task->task_sg_nents;
 
                 sg_prev = task->task_sg;
-                sg_prev_nents = task->task_sg_nents;
         }
         /*
          * Setup the starting pointer and total t_tasks_sg_linked_no including
@@ -4064,7 +4116,7 @@ static int transport_allocate_data_tasks(
         
         cmd_sg = sgl;
         for (i = 0; i < task_count; i++) {
-                unsigned int task_size;
+                unsigned int task_size, task_sg_nents_padded;
                 int count;
 
                 task = transport_generic_get_task(cmd, data_direction);
@@ -4083,30 +4135,33 @@ static int transport_allocate_data_tasks(
 
                 /* Update new cdb with updated lba/sectors */
                 cmd->transport_split_cdb(task->task_lba, task->task_sectors, cdb);
-
+                /*
+                 * This now assumes that passed sg_ents are in PAGE_SIZE chunks
+                 * in order to calculate the number per task SGL entries
+                 */
+                task->task_sg_nents = DIV_ROUND_UP(task->task_size, PAGE_SIZE);
                 /*
                  * Check if the fabric module driver is requesting that all
                  * struct se_task->task_sg[] be chained together..  If so,
                  * then allocate an extra padding SG entry for linking and
-                 * marking the end of the chained SGL.
-                 * Possibly over-allocate task sgl size by using cmd sgl size.
-                 * It's so much easier and only a waste when task_count > 1.
-                 * That is extremely rare.
+                 * marking the end of the chained SGL for every task except
+                 * the last one for (task_count > 1) operation, or skipping
+                 * the extra padding for the (task_count == 1) case.
                  */
-                task->task_sg_nents = sgl_nents;
-                if (cmd->se_tfo->task_sg_chaining) {
-                        task->task_sg_nents++;
+                if (cmd->se_tfo->task_sg_chaining && (i < (task_count - 1))) {
+                        task_sg_nents_padded = (task->task_sg_nents + 1);
                         task->task_padded_sg = 1;
-                }
+                } else
+                        task_sg_nents_padded = task->task_sg_nents;
 
                 task->task_sg = kmalloc(sizeof(struct scatterlist) *
-                                        task->task_sg_nents, GFP_KERNEL);
+                                        task_sg_nents_padded, GFP_KERNEL);
                 if (!task->task_sg) {
                         cmd->se_dev->transport->free_task(task);
                         return -ENOMEM;
                 }
 
-                sg_init_table(task->task_sg, task->task_sg_nents);
+                sg_init_table(task->task_sg, task_sg_nents_padded);
 
                 task_size = task->task_size;
 
@@ -4203,10 +4258,13 @@ static u32 transport_allocate_tasks(
         struct scatterlist *sgl,
         unsigned int sgl_nents)
 {
-        if (cmd->se_cmd_flags & SCF_SCSI_DATA_SG_IO_CDB)
+        if (cmd->se_cmd_flags & SCF_SCSI_DATA_SG_IO_CDB) {
+                if (transport_cmd_get_valid_sectors(cmd) < 0)
+                        return -EINVAL;
+
                 return transport_allocate_data_tasks(cmd, lba, data_direction,
                                                      sgl, sgl_nents);
-        else
+        } else
                 return transport_allocate_control_task(cmd);
 
 }
@@ -4699,6 +4757,13 @@ int transport_send_check_condition_and_sense(
          */
         switch (reason) {
         case TCM_NON_EXISTENT_LUN:
+                /* CURRENT ERROR */
+                buffer[offset] = 0x70;
+                /* ILLEGAL REQUEST */
+                buffer[offset+SPC_SENSE_KEY_OFFSET] = ILLEGAL_REQUEST;
+                /* LOGICAL UNIT NOT SUPPORTED */
+                buffer[offset+SPC_ASC_KEY_OFFSET] = 0x25;
+                break;
         case TCM_UNSUPPORTED_SCSI_OPCODE:
         case TCM_SECTOR_COUNT_TOO_MANY:
                 /* CURRENT ERROR */
diff --git a/drivers/target/tcm_fc/tcm_fc.h b/drivers/target/tcm_fc/tcm_fc.h
index f7fff7ed63c3..bd4fe21a23b8 100644
--- a/drivers/target/tcm_fc/tcm_fc.h
+++ b/drivers/target/tcm_fc/tcm_fc.h
@@ -187,4 +187,9 @@ void ft_dump_cmd(struct ft_cmd *, const char *caller);
 
 ssize_t ft_format_wwn(char *, size_t, u64);
 
+/*
+ * Underlying HW specific helper function
+ */
+void ft_invl_hw_context(struct ft_cmd *);
+
 #endif /* __TCM_FC_H__ */
diff --git a/drivers/target/tcm_fc/tfc_cmd.c b/drivers/target/tcm_fc/tfc_cmd.c
index 09df38b4610c..5654dc22f7ae 100644
--- a/drivers/target/tcm_fc/tfc_cmd.c
+++ b/drivers/target/tcm_fc/tfc_cmd.c
@@ -320,6 +320,7 @@ static void ft_recv_seq(struct fc_seq *sp, struct fc_frame *fp, void *arg)
         default:
                 pr_debug("%s: unhandled frame r_ctl %x\n",
                        __func__, fh->fh_r_ctl);
+                ft_invl_hw_context(cmd);
                 fc_frame_free(fp);
                 transport_generic_free_cmd(&cmd->se_cmd, 0, 0);
                 break;
diff --git a/drivers/target/tcm_fc/tfc_conf.c b/drivers/target/tcm_fc/tfc_conf.c
index 8781d1e423df..b15879d43e22 100644
--- a/drivers/target/tcm_fc/tfc_conf.c
+++ b/drivers/target/tcm_fc/tfc_conf.c
@@ -256,7 +256,7 @@ struct ft_node_acl *ft_acl_get(struct ft_tpg *tpg, struct fc_rport_priv *rdata)
         struct se_portal_group *se_tpg = &tpg->se_tpg;
         struct se_node_acl *se_acl;
 
-        spin_lock_bh(&se_tpg->acl_node_lock);
+        spin_lock_irq(&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);
                 pr_debug("acl %p port_name %llx\n",
@@ -270,7 +270,7 @@ struct ft_node_acl *ft_acl_get(struct ft_tpg *tpg, struct fc_rport_priv *rdata)
                         break;
                 }
         }
-        spin_unlock_bh(&se_tpg->acl_node_lock);
+        spin_unlock_irq(&se_tpg->acl_node_lock);
         return found;
 }
 
@@ -655,9 +655,7 @@ static void __exit ft_exit(void)
         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
index 8e2a46ddcccb..c37f4cd96452 100644
--- a/drivers/target/tcm_fc/tfc_io.c
+++ b/drivers/target/tcm_fc/tfc_io.c
@@ -213,62 +213,49 @@ void ft_recv_write_data(struct ft_cmd *cmd, struct fc_frame *fp)
         if (!(ntoh24(fh->fh_f_ctl) & FC_FC_REL_OFF))
                 goto drop;
 
+        f_ctl = ntoh24(fh->fh_f_ctl);
+        ep = fc_seq_exch(seq);
+        lport = ep->lp;
+        if (cmd->was_ddp_setup) {
+                BUG_ON(!ep);
+                BUG_ON(!lport);
+        }
+
         /*
-         * Doesn't expect even single byte of payload. Payload
+         * Doesn't expect payload if DDP is setup. 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
+         * due to DDP (Large Rx offload),
          */
         buf = fc_frame_payload_get(fp, 1);
-        if (cmd->was_ddp_setup && buf) {
-                pr_debug("%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 (buf)
+                pr_err("%s: xid 0x%x, f_ctl 0x%x, cmd->sg %p, "
+                                "cmd->sg_cnt 0x%x. DDP was setup"
+                                " hence not expected to receive frame with "
+                                "payload, Frame will be dropped if "
+                                "'Sequence Initiative' bit in f_ctl is "
+                                "not set\n", __func__, ep->xid, f_ctl,
+                                cmd->sg, cmd->sg_cnt);
+        /*
+         * Invalidate HW DDP context if it was setup for respective
+         * command. Invalidation of HW DDP context is requited in both
+         * situation (success and error). 
+         */
+        ft_invl_hw_context(cmd);
 
         /*
-         * 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.
+         * If "Sequence Initiative (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 receive queue.
+         *
+         * If "Sequence Initiative (TSI)" bit is not set, means error
+         * condition w.r.t. DDP, hence drop the packet and let explict
+         * ABORTS from other end of exchange timer trigger the recovery.
          */
-        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
-                         */
-                        pr_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;
-                }
-        }
+        if (f_ctl & FC_FC_SEQ_INIT)
+                goto last_frame;
+        else
+                goto drop;
 
         rel_off = ntohl(fh->fh_parm_offset);
         frame_len = fr_len(fp);
@@ -331,3 +318,39 @@ last_frame:
 drop:
         fc_frame_free(fp);
 }
+
+/*
+ * Handle and cleanup any HW specific resources if
+ * received ABORTS, errors, timeouts.
+ */
+void ft_invl_hw_context(struct ft_cmd *cmd)
+{
+        struct fc_seq *seq = cmd->seq;
+        struct fc_exch *ep = NULL;
+        struct fc_lport *lport = NULL;
+
+        BUG_ON(!cmd);
+
+        /* Cleanup the DDP context in HW if DDP was setup */
+        if (cmd->was_ddp_setup && seq) {
+                ep = fc_seq_exch(seq);
+                if (ep) {
+                        lport = ep->lp;
+                        if (lport && (ep->xid <= lport->lro_xid))
+                                /*
+                                 * "ddp_done" trigger invalidation of HW
+                                 * specific DDP context
+                                 */
+                                cmd->write_data_len = lport->tt.ddp_done(lport,
+                                                                      ep->xid);
+
+                                /*
+                                 * Resetting same variable to indicate HW's
+                                 * DDP context has been invalidated to avoid
+                                 * re_invalidation of same context (context is
+                                 * identified using ep->xid)
+                                 */
+                                cmd->was_ddp_setup = 0;
+                }
+        }
+}
diff --git a/drivers/thermal/Kconfig b/drivers/thermal/Kconfig
index bf7c687519ef..f7f71b2d3101 100644
--- a/drivers/thermal/Kconfig
+++ b/drivers/thermal/Kconfig
@@ -14,11 +14,7 @@ menuconfig THERMAL
           If you want this support, you should say Y or M here.
 
 config THERMAL_HWMON
-        bool "Hardware monitoring support"
+        bool
         depends on THERMAL
         depends on HWMON=y || HWMON=THERMAL
-        help
-          The generic thermal sysfs driver's hardware monitoring support
-          requires a 2.10.7/3.0.2 or later lm-sensors userspace.
-
-          Say Y if your user-space is new enough.
+        default y
diff --git a/drivers/thermal/thermal_sys.c b/drivers/thermal/thermal_sys.c
index 0b1c82ad6805..708f8e92771a 100644
--- a/drivers/thermal/thermal_sys.c
+++ b/drivers/thermal/thermal_sys.c
@@ -420,6 +420,29 @@ thermal_cooling_device_trip_point_show(struct device *dev,
 
 /* hwmon sys I/F */
 #include <linux/hwmon.h>
+
+/* thermal zone devices with the same type share one hwmon device */
+struct thermal_hwmon_device {
+        char type[THERMAL_NAME_LENGTH];
+        struct device *device;
+        int count;
+        struct list_head tz_list;
+        struct list_head node;
+};
+
+struct thermal_hwmon_attr {
+        struct device_attribute attr;
+        char name[16];
+};
+
+/* one temperature input for each thermal zone */
+struct thermal_hwmon_temp {
+        struct list_head hwmon_node;
+        struct thermal_zone_device *tz;
+        struct thermal_hwmon_attr temp_input;   /* hwmon sys attr */
+        struct thermal_hwmon_attr temp_crit;    /* hwmon sys attr */
+};
+
 static LIST_HEAD(thermal_hwmon_list);
 
 static ssize_t
@@ -437,9 +460,10 @@ temp_input_show(struct device *dev, struct device_attribute *attr, char *buf)
         int ret;
         struct thermal_hwmon_attr *hwmon_attr
                         = container_of(attr, struct thermal_hwmon_attr, attr);
-        struct thermal_zone_device *tz
-                        = container_of(hwmon_attr, struct thermal_zone_device,
+        struct thermal_hwmon_temp *temp
+                        = container_of(hwmon_attr, struct thermal_hwmon_temp,
                                        temp_input);
+        struct thermal_zone_device *tz = temp->tz;
 
         ret = tz->ops->get_temp(tz, &temperature);
 
@@ -455,9 +479,10 @@ temp_crit_show(struct device *dev, struct device_attribute *attr,
 {
         struct thermal_hwmon_attr *hwmon_attr
                         = container_of(attr, struct thermal_hwmon_attr, attr);
-        struct thermal_zone_device *tz
-                        = container_of(hwmon_attr, struct thermal_zone_device,
+        struct thermal_hwmon_temp *temp
+                        = container_of(hwmon_attr, struct thermal_hwmon_temp,
                                        temp_crit);
+        struct thermal_zone_device *tz = temp->tz;
         long temperature;
         int ret;
 
@@ -469,22 +494,54 @@ temp_crit_show(struct device *dev, struct device_attribute *attr,
 }
 
 
-static int
-thermal_add_hwmon_sysfs(struct thermal_zone_device *tz)
+static struct thermal_hwmon_device *
+thermal_hwmon_lookup_by_type(const struct thermal_zone_device *tz)
 {
         struct thermal_hwmon_device *hwmon;
-        int new_hwmon_device = 1;
-        int result;
 
         mutex_lock(&thermal_list_lock);
         list_for_each_entry(hwmon, &thermal_hwmon_list, node)
                 if (!strcmp(hwmon->type, tz->type)) {
-                        new_hwmon_device = 0;
                         mutex_unlock(&thermal_list_lock);
-                        goto register_sys_interface;
+                        return hwmon;
+                }
+        mutex_unlock(&thermal_list_lock);
+
+        return NULL;
+}
+
+/* Find the temperature input matching a given thermal zone */
+static struct thermal_hwmon_temp *
+thermal_hwmon_lookup_temp(const struct thermal_hwmon_device *hwmon,
+                          const struct thermal_zone_device *tz)
+{
+        struct thermal_hwmon_temp *temp;
+
+        mutex_lock(&thermal_list_lock);
+        list_for_each_entry(temp, &hwmon->tz_list, hwmon_node)
+                if (temp->tz == tz) {
+                        mutex_unlock(&thermal_list_lock);
+                        return temp;
                 }
         mutex_unlock(&thermal_list_lock);
 
+        return NULL;
+}
+
+static int
+thermal_add_hwmon_sysfs(struct thermal_zone_device *tz)
+{
+        struct thermal_hwmon_device *hwmon;
+        struct thermal_hwmon_temp *temp;
+        int new_hwmon_device = 1;
+        int result;
+
+        hwmon = thermal_hwmon_lookup_by_type(tz);
+        if (hwmon) {
+                new_hwmon_device = 0;
+                goto register_sys_interface;
+        }
+
         hwmon = kzalloc(sizeof(struct thermal_hwmon_device), GFP_KERNEL);
         if (!hwmon)
                 return -ENOMEM;
@@ -502,30 +559,36 @@ thermal_add_hwmon_sysfs(struct thermal_zone_device *tz)
                 goto free_mem;
 
  register_sys_interface:
-        tz->hwmon = hwmon;
+        temp = kzalloc(sizeof(struct thermal_hwmon_temp), GFP_KERNEL);
+        if (!temp) {
+                result = -ENOMEM;
+                goto unregister_name;
+        }
+
+        temp->tz = tz;
         hwmon->count++;
 
-        snprintf(tz->temp_input.name, THERMAL_NAME_LENGTH,
+        snprintf(temp->temp_input.name, THERMAL_NAME_LENGTH,
                  "temp%d_input", hwmon->count);
-        tz->temp_input.attr.attr.name = tz->temp_input.name;
-        tz->temp_input.attr.attr.mode = 0444;
-        tz->temp_input.attr.show = temp_input_show;
-        sysfs_attr_init(&tz->temp_input.attr.attr);
-        result = device_create_file(hwmon->device, &tz->temp_input.attr);
+        temp->temp_input.attr.attr.name = temp->temp_input.name;
+        temp->temp_input.attr.attr.mode = 0444;
+        temp->temp_input.attr.show = temp_input_show;
+        sysfs_attr_init(&temp->temp_input.attr.attr);
+        result = device_create_file(hwmon->device, &temp->temp_input.attr);
         if (result)
-                goto unregister_name;
+                goto free_temp_mem;
 
         if (tz->ops->get_crit_temp) {
                 unsigned long temperature;
                 if (!tz->ops->get_crit_temp(tz, &temperature)) {
-                        snprintf(tz->temp_crit.name, THERMAL_NAME_LENGTH,
+                        snprintf(temp->temp_crit.name, THERMAL_NAME_LENGTH,
                                 "temp%d_crit", hwmon->count);
-                        tz->temp_crit.attr.attr.name = tz->temp_crit.name;
-                        tz->temp_crit.attr.attr.mode = 0444;
-                        tz->temp_crit.attr.show = temp_crit_show;
-                        sysfs_attr_init(&tz->temp_crit.attr.attr);
+                        temp->temp_crit.attr.attr.name = temp->temp_crit.name;
+                        temp->temp_crit.attr.attr.mode = 0444;
+                        temp->temp_crit.attr.show = temp_crit_show;
+                        sysfs_attr_init(&temp->temp_crit.attr.attr);
                         result = device_create_file(hwmon->device,
-                                                    &tz->temp_crit.attr);
+                                                    &temp->temp_crit.attr);
                         if (result)
                                 goto unregister_input;
                 }
@@ -534,13 +597,15 @@ thermal_add_hwmon_sysfs(struct thermal_zone_device *tz)
         mutex_lock(&thermal_list_lock);
         if (new_hwmon_device)
                 list_add_tail(&hwmon->node, &thermal_hwmon_list);
-        list_add_tail(&tz->hwmon_node, &hwmon->tz_list);
+        list_add_tail(&temp->hwmon_node, &hwmon->tz_list);
         mutex_unlock(&thermal_list_lock);
 
         return 0;
 
  unregister_input:
-        device_remove_file(hwmon->device, &tz->temp_input.attr);
+        device_remove_file(hwmon->device, &temp->temp_input.attr);
+ free_temp_mem:
+        kfree(temp);
  unregister_name:
         if (new_hwmon_device) {
                 device_remove_file(hwmon->device, &dev_attr_name);
@@ -556,15 +621,30 @@ thermal_add_hwmon_sysfs(struct thermal_zone_device *tz)
 static void
 thermal_remove_hwmon_sysfs(struct thermal_zone_device *tz)
 {
-        struct thermal_hwmon_device *hwmon = tz->hwmon;
+        struct thermal_hwmon_device *hwmon;
+        struct thermal_hwmon_temp *temp;
+
+        hwmon = thermal_hwmon_lookup_by_type(tz);
+        if (unlikely(!hwmon)) {
+                /* Should never happen... */
+                dev_dbg(&tz->device, "hwmon device lookup failed!\n");
+                return;
+        }
+
+        temp = thermal_hwmon_lookup_temp(hwmon, tz);
+        if (unlikely(!temp)) {
+                /* Should never happen... */
+                dev_dbg(&tz->device, "temperature input lookup failed!\n");
+                return;
+        }
 
-        tz->hwmon = NULL;
-        device_remove_file(hwmon->device, &tz->temp_input.attr);
+        device_remove_file(hwmon->device, &temp->temp_input.attr);
         if (tz->ops->get_crit_temp)
-                device_remove_file(hwmon->device, &tz->temp_crit.attr);
+                device_remove_file(hwmon->device, &temp->temp_crit.attr);
 
         mutex_lock(&thermal_list_lock);
-        list_del(&tz->hwmon_node);
+        list_del(&temp->hwmon_node);
+        kfree(temp);
         if (!list_empty(&hwmon->tz_list)) {
                 mutex_unlock(&thermal_list_lock);
                 return;
diff --git a/drivers/tty/pty.c b/drivers/tty/pty.c
index 98b6e3bdb000..e809e9d4683c 100644
--- a/drivers/tty/pty.c
+++ b/drivers/tty/pty.c
@@ -446,8 +446,19 @@ static inline void legacy_pty_init(void) { }
 int pty_limit = NR_UNIX98_PTY_DEFAULT;
 static int pty_limit_min;
 static int pty_limit_max = NR_UNIX98_PTY_MAX;
+static int tty_count;
 static int pty_count;
 
+static inline void pty_inc_count(void)
+{
+        pty_count = (++tty_count) / 2;
+}
+
+static inline void pty_dec_count(void)
+{
+        pty_count = (--tty_count) / 2;
+}
+
 static struct cdev ptmx_cdev;
 
 static struct ctl_table pty_table[] = {
@@ -542,6 +553,7 @@ static struct tty_struct *pts_unix98_lookup(struct tty_driver *driver,
 
 static void pty_unix98_shutdown(struct tty_struct *tty)
 {
+        tty_driver_remove_tty(tty->driver, tty);
         /* We have our own method as we don't use the tty index */
         kfree(tty->termios);
 }
@@ -588,7 +600,8 @@ static int pty_unix98_install(struct tty_driver *driver, struct tty_struct *tty)
          */
         tty_driver_kref_get(driver);
         tty->count++;
-        pty_count++;
+        pty_inc_count(); /* tty */
+        pty_inc_count(); /* tty->link */
         return 0;
 err_free_mem:
         deinitialize_tty_struct(o_tty);
@@ -602,7 +615,7 @@ err_free_tty:
 
 static void pty_unix98_remove(struct tty_driver *driver, struct tty_struct *tty)
 {
-        pty_count--;
+        pty_dec_count();
 }
 
 static const struct tty_operations ptm_unix98_ops = {
diff --git a/drivers/tty/serial/8250.c b/drivers/tty/serial/8250.c
index f2dfec82faf8..7f50999eebc2 100644
--- a/drivers/tty/serial/8250.c
+++ b/drivers/tty/serial/8250.c
@@ -1819,6 +1819,8 @@ static void serial8250_backup_timeout(unsigned long data)
         unsigned int iir, ier = 0, lsr;
         unsigned long flags;
 
+        spin_lock_irqsave(&up->port.lock, flags);
+
         /*
          * Must disable interrupts or else we risk racing with the interrupt
          * based handler.
@@ -1836,10 +1838,8 @@ static void serial8250_backup_timeout(unsigned long data)
          * the "Diva" UART used on the management processor on many HP
          * ia64 and parisc boxes.
          */
-        spin_lock_irqsave(&up->port.lock, flags);
         lsr = serial_in(up, UART_LSR);
         up->lsr_saved_flags |= lsr & LSR_SAVE_FLAGS;
-        spin_unlock_irqrestore(&up->port.lock, flags);
         if ((iir & UART_IIR_NO_INT) && (up->ier & UART_IER_THRI) &&
             (!uart_circ_empty(&up->port.state->xmit) || up->port.x_char) &&
             (lsr & UART_LSR_THRE)) {
@@ -1848,11 +1848,13 @@ static void serial8250_backup_timeout(unsigned long data)
         }
 
         if (!(iir & UART_IIR_NO_INT))
-                serial8250_handle_port(up);
+                transmit_chars(up);
 
         if (is_real_interrupt(up->port.irq))
                 serial_out(up, UART_IER, ier);
 
+        spin_unlock_irqrestore(&up->port.lock, flags);
+
         /* Standard timer interval plus 0.2s to keep the port running */
         mod_timer(&up->timer,
                 jiffies + uart_poll_timeout(&up->port) + HZ / 5);
diff --git a/drivers/tty/serial/8250_pci.c b/drivers/tty/serial/8250_pci.c
index 6b887d90a205..3abeca2a2a1b 100644
--- a/drivers/tty/serial/8250_pci.c
+++ b/drivers/tty/serial/8250_pci.c
@@ -1599,11 +1599,6 @@ static struct pci_serial_quirk pci_serial_quirks[] __refdata = {
                 .device         = 0x800D,
                 .init           = pci_eg20t_init,
         },
-        {
-                .vendor         = 0x10DB,
-                .device         = 0x800D,
-                .init           = pci_eg20t_init,
-        },
         /*
          * Cronyx Omega PCI (PLX-chip based)
          */
@@ -4021,7 +4016,7 @@ static struct pci_device_id serial_pci_tbl[] = {
                 0, 0, pbn_NETMOS9900_2s_115200 },
 
         /*
-         * Best Connectivity PCI Multi I/O cards
+         * Best Connectivity and Rosewill PCI Multi I/O cards
          */
 
         {       PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9865,
@@ -4029,6 +4024,10 @@ static struct pci_device_id serial_pci_tbl[] = {
                 0, 0, pbn_b0_1_115200 },
 
         {       PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9865,
+                0xA000, 0x3002,
+                0, 0, pbn_b0_bt_2_115200 },
+
+        {       PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9865,
                 0xA000, 0x3004,
                 0, 0, pbn_b0_bt_4_115200 },
         /* Intel CE4100 */
diff --git a/drivers/tty/serial/8250_pnp.c b/drivers/tty/serial/8250_pnp.c
index fc301f6722e1..a2f236510ff1 100644
--- a/drivers/tty/serial/8250_pnp.c
+++ b/drivers/tty/serial/8250_pnp.c
@@ -109,6 +109,9 @@ static const struct pnp_device_id pnp_dev_table[] = {
         /* IBM */
         /* IBM Thinkpad 701 Internal Modem Voice */
         {       "IBM0033",              0       },
+        /* Intermec */
+        /* Intermec CV60 touchscreen port */
+        {       "PNP4972",              0       },
         /* Intertex */
         /* Intertex 28k8 33k6 Voice EXT PnP */
         {       "IXDC801",              0       },
diff --git a/drivers/tty/serial/Kconfig b/drivers/tty/serial/Kconfig
index cb40b82daf36..4dcb37bbdf92 100644
--- a/drivers/tty/serial/Kconfig
+++ b/drivers/tty/serial/Kconfig
@@ -959,7 +959,7 @@ config SERIAL_IP22_ZILOG_CONSOLE
 
 config SERIAL_SH_SCI
         tristate "SuperH SCI(F) serial port support"
-        depends on HAVE_CLK && (SUPERH || H8300 || ARCH_SHMOBILE)
+        depends on HAVE_CLK && (SUPERH || ARCH_SHMOBILE)
         select SERIAL_CORE
 
 config SERIAL_SH_SCI_NR_UARTS
diff --git a/drivers/tty/serial/atmel_serial.c b/drivers/tty/serial/atmel_serial.c
index af9b7814965a..b922f5d2e61e 100644
--- a/drivers/tty/serial/atmel_serial.c
+++ b/drivers/tty/serial/atmel_serial.c
@@ -1609,9 +1609,11 @@ static struct console atmel_console = {
 static int __init atmel_console_init(void)
 {
         if (atmel_default_console_device) {
-                add_preferred_console(ATMEL_DEVICENAME,
-                                      atmel_default_console_device->id, NULL);
-                atmel_init_port(&atmel_ports[atmel_default_console_device->id],
+                struct atmel_uart_data *pdata =
+                        atmel_default_console_device->dev.platform_data;
+
+                add_preferred_console(ATMEL_DEVICENAME, pdata->num, NULL);
+                atmel_init_port(&atmel_ports[pdata->num],
                                 atmel_default_console_device);
                 register_console(&atmel_console);
         }
diff --git a/drivers/tty/serial/imx.c b/drivers/tty/serial/imx.c
index 827db7654594..7e91b3d368cd 100644
--- a/drivers/tty/serial/imx.c
+++ b/drivers/tty/serial/imx.c
@@ -1286,22 +1286,17 @@ static int serial_imx_resume(struct platform_device *dev)
 static int serial_imx_probe_dt(struct imx_port *sport,
                 struct platform_device *pdev)
 {
+        static int portnum = 0;
         struct device_node *np = pdev->dev.of_node;
         const struct of_device_id *of_id =
                         of_match_device(imx_uart_dt_ids, &pdev->dev);
-        int ret;
 
         if (!np)
                 return -ENODEV;
 
-        ret = of_alias_get_id(np, "serial");
-        if (ret < 0) {
-                pr_err("%s: failed to get alias id, errno %d\n",
-                        __func__, ret);
-                return -ENODEV;
-        } else {
-                sport->port.line = ret;
-        }
+        sport->port.line = portnum++;
+        if (sport->port.line >= UART_NR)
+                return -EINVAL;
 
         if (of_get_property(np, "fsl,uart-has-rtscts", NULL))
                 sport->have_rtscts = 1;
diff --git a/drivers/tty/serial/max3107-aava.c b/drivers/tty/serial/max3107-aava.c
index a1fe304f2f52..d73aadd7a9ad 100644
--- a/drivers/tty/serial/max3107-aava.c
+++ b/drivers/tty/serial/max3107-aava.c
@@ -340,5 +340,5 @@ module_exit(max3107_exit);
 
 MODULE_DESCRIPTION("MAX3107 driver");
 MODULE_AUTHOR("Aavamobile");
-MODULE_ALIAS("aava-max3107-spi");
+MODULE_ALIAS("spi:aava-max3107");
 MODULE_LICENSE("GPL v2");
diff --git a/drivers/tty/serial/max3107.c b/drivers/tty/serial/max3107.c
index 750b4f627315..a8164601c0ea 100644
--- a/drivers/tty/serial/max3107.c
+++ b/drivers/tty/serial/max3107.c
@@ -1209,5 +1209,5 @@ module_exit(max3107_exit);
 
 MODULE_DESCRIPTION("MAX3107 driver");
 MODULE_AUTHOR("Aavamobile");
-MODULE_ALIAS("max3107-spi");
+MODULE_ALIAS("spi:max3107");
 MODULE_LICENSE("GPL v2");
diff --git a/drivers/tty/serial/mrst_max3110.c b/drivers/tty/serial/mrst_max3110.c
index a764bf99743b..23bc743f2a22 100644
--- a/drivers/tty/serial/mrst_max3110.c
+++ b/drivers/tty/serial/mrst_max3110.c
@@ -917,4 +917,4 @@ module_init(serial_m3110_init);
 module_exit(serial_m3110_exit);
 
 MODULE_LICENSE("GPL v2");
-MODULE_ALIAS("max3110-uart");
+MODULE_ALIAS("spi:max3110-uart");
diff --git a/drivers/tty/serial/omap-serial.c b/drivers/tty/serial/omap-serial.c
index c37df8d0fa28..5e713d3ef1f4 100644
--- a/drivers/tty/serial/omap-serial.c
+++ b/drivers/tty/serial/omap-serial.c
@@ -806,8 +806,7 @@ serial_omap_set_termios(struct uart_port *port, struct ktermios *termios,
 
         serial_omap_set_mctrl(&up->port, up->port.mctrl);
         /* Software Flow Control Configuration */
-        if (termios->c_iflag & (IXON | IXOFF))
-                serial_omap_configure_xonxoff(up, termios);
+        serial_omap_configure_xonxoff(up, termios);
 
         spin_unlock_irqrestore(&up->port.lock, flags);
         dev_dbg(up->port.dev, "serial_omap_set_termios+%d\n", up->pdev->id);
diff --git a/drivers/tty/serial/pch_uart.c b/drivers/tty/serial/pch_uart.c
index 846dfcd3ce0d..b46218d679e2 100644
--- a/drivers/tty/serial/pch_uart.c
+++ b/drivers/tty/serial/pch_uart.c
@@ -598,7 +598,8 @@ static void pch_request_dma(struct uart_port *port)
         dma_cap_zero(mask);
         dma_cap_set(DMA_SLAVE, mask);
 
-        dma_dev = pci_get_bus_and_slot(2, PCI_DEVFN(0xa, 0)); /* Get DMA's dev
+        dma_dev = pci_get_bus_and_slot(priv->pdev->bus->number,
+                                       PCI_DEVFN(0xa, 0)); /* Get DMA's dev
                                                                 information */
         /* Set Tx DMA */
         param = &priv->param_tx;
diff --git a/drivers/tty/serial/samsung.c b/drivers/tty/serial/samsung.c
index afc629423152..6edafb5ace18 100644
--- a/drivers/tty/serial/samsung.c
+++ b/drivers/tty/serial/samsung.c
@@ -1225,15 +1225,19 @@ static const struct dev_pm_ops s3c24xx_serial_pm_ops = {
         .suspend = s3c24xx_serial_suspend,
         .resume = s3c24xx_serial_resume,
 };
+#define SERIAL_SAMSUNG_PM_OPS   (&s3c24xx_serial_pm_ops)
+
 #else /* !CONFIG_PM_SLEEP */
-#define s3c24xx_serial_pm_ops   NULL
+
+#define SERIAL_SAMSUNG_PM_OPS   NULL
 #endif /* CONFIG_PM_SLEEP */
 
 int s3c24xx_serial_init(struct platform_driver *drv,
                         struct s3c24xx_uart_info *info)
 {
         dbg("s3c24xx_serial_init(%p,%p)\n", drv, info);
-        drv->driver.pm = &s3c24xx_serial_pm_ops;
+
+        drv->driver.pm = SERIAL_SAMSUNG_PM_OPS;
 
         return platform_driver_register(drv);
 }
diff --git a/drivers/tty/serial/serial_core.c b/drivers/tty/serial/serial_core.c
index db7912cb7ae0..a3efbea5dbba 100644
--- a/drivers/tty/serial/serial_core.c
+++ b/drivers/tty/serial/serial_core.c
@@ -200,6 +200,11 @@ static int uart_startup(struct tty_struct *tty, struct uart_state *state, int in
                 clear_bit(TTY_IO_ERROR, &tty->flags);
         }
 
+        /*
+         * This is to allow setserial on this port. People may want to set
+         * port/irq/type and then reconfigure the port properly if it failed
+         * now.
+         */
         if (retval && capable(CAP_SYS_ADMIN))
                 retval = 0;
 
diff --git a/drivers/tty/serial/sh-sci.c b/drivers/tty/serial/sh-sci.c
index ebd8629c108d..5ea6ec3442e6 100644
--- a/drivers/tty/serial/sh-sci.c
+++ b/drivers/tty/serial/sh-sci.c
@@ -47,6 +47,7 @@
 #include <linux/ctype.h>
 #include <linux/err.h>
 #include <linux/dmaengine.h>
+#include <linux/dma-mapping.h>
 #include <linux/scatterlist.h>
 #include <linux/slab.h>
 
@@ -54,10 +55,6 @@
 #include <asm/sh_bios.h>
 #endif
 
-#ifdef CONFIG_H8300
-#include <asm/gpio.h>
-#endif
-
 #include "sh-sci.h"
 
 struct sci_port {
@@ -66,12 +63,6 @@ struct sci_port {
         /* Platform configuration */
         struct plat_sci_port    *cfg;
 
-        /* Port enable callback */
-        void                    (*enable)(struct uart_port *port);
-
-        /* Port disable callback */
-        void                    (*disable)(struct uart_port *port);
-
         /* Break timer */
         struct timer_list       break_timer;
         int                     break_flag;
@@ -81,6 +72,8 @@ struct sci_port {
         /* Function clock */
         struct clk              *fclk;
 
+        char                    *irqstr[SCIx_NR_IRQS];
+
         struct dma_chan                 *chan_tx;
         struct dma_chan                 *chan_rx;
 
@@ -103,6 +96,12 @@ struct sci_port {
 #endif
 
         struct notifier_block           freq_transition;
+
+#ifdef CONFIG_SERIAL_SH_SCI_CONSOLE
+        unsigned short saved_smr;
+        unsigned short saved_fcr;
+        unsigned char saved_brr;
+#endif
 };
 
 /* Function prototypes */
@@ -121,6 +120,278 @@ to_sci_port(struct uart_port *uart)
         return container_of(uart, struct sci_port, port);
 }
 
+struct plat_sci_reg {
+        u8 offset, size;
+};
+
+/* Helper for invalidating specific entries of an inherited map. */
+#define sci_reg_invalid { .offset = 0, .size = 0 }
+
+static struct plat_sci_reg sci_regmap[SCIx_NR_REGTYPES][SCIx_NR_REGS] = {
+        [SCIx_PROBE_REGTYPE] = {
+                [0 ... SCIx_NR_REGS - 1] = sci_reg_invalid,
+        },
+
+        /*
+         * Common SCI definitions, dependent on the port's regshift
+         * value.
+         */
+        [SCIx_SCI_REGTYPE] = {
+                [SCSMR]         = { 0x00,  8 },
+                [SCBRR]         = { 0x01,  8 },
+                [SCSCR]         = { 0x02,  8 },
+                [SCxTDR]        = { 0x03,  8 },
+                [SCxSR]         = { 0x04,  8 },
+                [SCxRDR]        = { 0x05,  8 },
+                [SCFCR]         = sci_reg_invalid,
+                [SCFDR]         = sci_reg_invalid,
+                [SCTFDR]        = sci_reg_invalid,
+                [SCRFDR]        = sci_reg_invalid,
+                [SCSPTR]        = sci_reg_invalid,
+                [SCLSR]         = sci_reg_invalid,
+        },
+
+        /*
+         * Common definitions for legacy IrDA ports, dependent on
+         * regshift value.
+         */
+        [SCIx_IRDA_REGTYPE] = {
+                [SCSMR]         = { 0x00,  8 },
+                [SCBRR]         = { 0x01,  8 },
+                [SCSCR]         = { 0x02,  8 },
+                [SCxTDR]        = { 0x03,  8 },
+                [SCxSR]         = { 0x04,  8 },
+                [SCxRDR]        = { 0x05,  8 },
+                [SCFCR]         = { 0x06,  8 },
+                [SCFDR]         = { 0x07, 16 },
+                [SCTFDR]        = sci_reg_invalid,
+                [SCRFDR]        = sci_reg_invalid,
+                [SCSPTR]        = sci_reg_invalid,
+                [SCLSR]         = sci_reg_invalid,
+        },
+
+        /*
+         * Common SCIFA definitions.
+         */
+        [SCIx_SCIFA_REGTYPE] = {
+                [SCSMR]         = { 0x00, 16 },
+                [SCBRR]         = { 0x04,  8 },
+                [SCSCR]         = { 0x08, 16 },
+                [SCxTDR]        = { 0x20,  8 },
+                [SCxSR]         = { 0x14, 16 },
+                [SCxRDR]        = { 0x24,  8 },
+                [SCFCR]         = { 0x18, 16 },
+                [SCFDR]         = { 0x1c, 16 },
+                [SCTFDR]        = sci_reg_invalid,
+                [SCRFDR]        = sci_reg_invalid,
+                [SCSPTR]        = sci_reg_invalid,
+                [SCLSR]         = sci_reg_invalid,
+        },
+
+        /*
+         * Common SCIFB definitions.
+         */
+        [SCIx_SCIFB_REGTYPE] = {
+                [SCSMR]         = { 0x00, 16 },
+                [SCBRR]         = { 0x04,  8 },
+                [SCSCR]         = { 0x08, 16 },
+                [SCxTDR]        = { 0x40,  8 },
+                [SCxSR]         = { 0x14, 16 },
+                [SCxRDR]        = { 0x60,  8 },
+                [SCFCR]         = { 0x18, 16 },
+                [SCFDR]         = { 0x1c, 16 },
+                [SCTFDR]        = sci_reg_invalid,
+                [SCRFDR]        = sci_reg_invalid,
+                [SCSPTR]        = sci_reg_invalid,
+                [SCLSR]         = sci_reg_invalid,
+        },
+
+        /*
+         * Common SH-3 SCIF definitions.
+         */
+        [SCIx_SH3_SCIF_REGTYPE] = {
+                [SCSMR]         = { 0x00,  8 },
+                [SCBRR]         = { 0x02,  8 },
+                [SCSCR]         = { 0x04,  8 },
+                [SCxTDR]        = { 0x06,  8 },
+                [SCxSR]         = { 0x08, 16 },
+                [SCxRDR]        = { 0x0a,  8 },
+                [SCFCR]         = { 0x0c,  8 },
+                [SCFDR]         = { 0x0e, 16 },
+                [SCTFDR]        = sci_reg_invalid,
+                [SCRFDR]        = sci_reg_invalid,
+                [SCSPTR]        = sci_reg_invalid,
+                [SCLSR]         = sci_reg_invalid,
+        },
+
+        /*
+         * Common SH-4(A) SCIF(B) definitions.
+         */
+        [SCIx_SH4_SCIF_REGTYPE] = {
+                [SCSMR]         = { 0x00, 16 },
+                [SCBRR]         = { 0x04,  8 },
+                [SCSCR]         = { 0x08, 16 },
+                [SCxTDR]        = { 0x0c,  8 },
+                [SCxSR]         = { 0x10, 16 },
+                [SCxRDR]        = { 0x14,  8 },
+                [SCFCR]         = { 0x18, 16 },
+                [SCFDR]         = { 0x1c, 16 },
+                [SCTFDR]        = sci_reg_invalid,
+                [SCRFDR]        = sci_reg_invalid,
+                [SCSPTR]        = { 0x20, 16 },
+                [SCLSR]         = { 0x24, 16 },
+        },
+
+        /*
+         * Common SH-4(A) SCIF(B) definitions for ports without an SCSPTR
+         * register.
+         */
+        [SCIx_SH4_SCIF_NO_SCSPTR_REGTYPE] = {
+                [SCSMR]         = { 0x00, 16 },
+                [SCBRR]         = { 0x04,  8 },
+                [SCSCR]         = { 0x08, 16 },
+                [SCxTDR]        = { 0x0c,  8 },
+                [SCxSR]         = { 0x10, 16 },
+                [SCxRDR]        = { 0x14,  8 },
+                [SCFCR]         = { 0x18, 16 },
+                [SCFDR]         = { 0x1c, 16 },
+                [SCTFDR]        = sci_reg_invalid,
+                [SCRFDR]        = sci_reg_invalid,
+                [SCSPTR]        = sci_reg_invalid,
+                [SCLSR]         = { 0x24, 16 },
+        },
+
+        /*
+         * Common SH-4(A) SCIF(B) definitions for ports with FIFO data
+         * count registers.
+         */
+        [SCIx_SH4_SCIF_FIFODATA_REGTYPE] = {
+                [SCSMR]         = { 0x00, 16 },
+                [SCBRR]         = { 0x04,  8 },
+                [SCSCR]         = { 0x08, 16 },
+                [SCxTDR]        = { 0x0c,  8 },
+                [SCxSR]         = { 0x10, 16 },
+                [SCxRDR]        = { 0x14,  8 },
+                [SCFCR]         = { 0x18, 16 },
+                [SCFDR]         = { 0x1c, 16 },
+                [SCTFDR]        = { 0x1c, 16 }, /* aliased to SCFDR */
+                [SCRFDR]        = { 0x20, 16 },
+                [SCSPTR]        = { 0x24, 16 },
+                [SCLSR]         = { 0x28, 16 },
+        },
+
+        /*
+         * SH7705-style SCIF(B) ports, lacking both SCSPTR and SCLSR
+         * registers.
+         */
+        [SCIx_SH7705_SCIF_REGTYPE] = {
+                [SCSMR]         = { 0x00, 16 },
+                [SCBRR]         = { 0x04,  8 },
+                [SCSCR]         = { 0x08, 16 },
+                [SCxTDR]        = { 0x20,  8 },
+                [SCxSR]         = { 0x14, 16 },
+                [SCxRDR]        = { 0x24,  8 },
+                [SCFCR]         = { 0x18, 16 },
+                [SCFDR]         = { 0x1c, 16 },
+                [SCTFDR]        = sci_reg_invalid,
+                [SCRFDR]        = sci_reg_invalid,
+                [SCSPTR]        = sci_reg_invalid,
+                [SCLSR]         = sci_reg_invalid,
+        },
+};
+
+#define sci_getreg(up, offset)          (sci_regmap[to_sci_port(up)->cfg->regtype] + offset)
+
+/*
+ * The "offset" here is rather misleading, in that it refers to an enum
+ * value relative to the port mapping rather than the fixed offset
+ * itself, which needs to be manually retrieved from the platform's
+ * register map for the given port.
+ */
+static unsigned int sci_serial_in(struct uart_port *p, int offset)
+{
+        struct plat_sci_reg *reg = sci_getreg(p, offset);
+
+        if (reg->size == 8)
+                return ioread8(p->membase + (reg->offset << p->regshift));
+        else if (reg->size == 16)
+                return ioread16(p->membase + (reg->offset << p->regshift));
+        else
+                WARN(1, "Invalid register access\n");
+
+        return 0;
+}
+
+static void sci_serial_out(struct uart_port *p, int offset, int value)
+{
+        struct plat_sci_reg *reg = sci_getreg(p, offset);
+
+        if (reg->size == 8)
+                iowrite8(value, p->membase + (reg->offset << p->regshift));
+        else if (reg->size == 16)
+                iowrite16(value, p->membase + (reg->offset << p->regshift));
+        else
+                WARN(1, "Invalid register access\n");
+}
+
+#define sci_in(up, offset)              (up->serial_in(up, offset))
+#define sci_out(up, offset, value)      (up->serial_out(up, offset, value))
+
+static int sci_probe_regmap(struct plat_sci_port *cfg)
+{
+        switch (cfg->type) {
+        case PORT_SCI:
+                cfg->regtype = SCIx_SCI_REGTYPE;
+                break;
+        case PORT_IRDA:
+                cfg->regtype = SCIx_IRDA_REGTYPE;
+                break;
+        case PORT_SCIFA:
+                cfg->regtype = SCIx_SCIFA_REGTYPE;
+                break;
+        case PORT_SCIFB:
+                cfg->regtype = SCIx_SCIFB_REGTYPE;
+                break;
+        case PORT_SCIF:
+                /*
+                 * The SH-4 is a bit of a misnomer here, although that's
+                 * where this particular port layout originated. This
+                 * configuration (or some slight variation thereof)
+                 * remains the dominant model for all SCIFs.
+                 */
+                cfg->regtype = SCIx_SH4_SCIF_REGTYPE;
+                break;
+        default:
+                printk(KERN_ERR "Can't probe register map for given port\n");
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static void sci_port_enable(struct sci_port *sci_port)
+{
+        if (!sci_port->port.dev)
+                return;
+
+        pm_runtime_get_sync(sci_port->port.dev);
+
+        clk_enable(sci_port->iclk);
+        sci_port->port.uartclk = clk_get_rate(sci_port->iclk);
+        clk_enable(sci_port->fclk);
+}
+
+static void sci_port_disable(struct sci_port *sci_port)
+{
+        if (!sci_port->port.dev)
+                return;
+
+        clk_disable(sci_port->fclk);
+        clk_disable(sci_port->iclk);
+
+        pm_runtime_put_sync(sci_port->port.dev);
+}
+
 #if defined(CONFIG_CONSOLE_POLL) || defined(CONFIG_SERIAL_SH_SCI_CONSOLE)
 
 #ifdef CONFIG_CONSOLE_POLL
@@ -164,223 +435,76 @@ static void sci_poll_put_char(struct uart_port *port, unsigned char c)
 }
 #endif /* CONFIG_CONSOLE_POLL || CONFIG_SERIAL_SH_SCI_CONSOLE */
 
-#if defined(__H8300H__) || defined(__H8300S__)
 static void sci_init_pins(struct uart_port *port, unsigned int cflag)
 {
-        int ch = (port->mapbase - SMR0) >> 3;
-
-        /* set DDR regs */
-        H8300_GPIO_DDR(h8300_sci_pins[ch].port,
-                       h8300_sci_pins[ch].rx,
-                       H8300_GPIO_INPUT);
-        H8300_GPIO_DDR(h8300_sci_pins[ch].port,
-                       h8300_sci_pins[ch].tx,
-                       H8300_GPIO_OUTPUT);
-
-        /* tx mark output*/
-        H8300_SCI_DR(ch) |= h8300_sci_pins[ch].tx;
-}
-#elif defined(CONFIG_CPU_SUBTYPE_SH7710) || defined(CONFIG_CPU_SUBTYPE_SH7712)
-static inline void sci_init_pins(struct uart_port *port, unsigned int cflag)
-{
-        if (port->mapbase == 0xA4400000) {
-                __raw_writew(__raw_readw(PACR) & 0xffc0, PACR);
-                __raw_writew(__raw_readw(PBCR) & 0x0fff, PBCR);
-        } else if (port->mapbase == 0xA4410000)
-                __raw_writew(__raw_readw(PBCR) & 0xf003, PBCR);
-}
-#elif defined(CONFIG_CPU_SUBTYPE_SH7720) || defined(CONFIG_CPU_SUBTYPE_SH7721)
-static inline void sci_init_pins(struct uart_port *port, unsigned int cflag)
-{
-        unsigned short data;
-
-        if (cflag & CRTSCTS) {
-                /* enable RTS/CTS */
-                if (port->mapbase == 0xa4430000) { /* SCIF0 */
-                        /* Clear PTCR bit 9-2; enable all scif pins but sck */
-                        data = __raw_readw(PORT_PTCR);
-                        __raw_writew((data & 0xfc03), PORT_PTCR);
-                } else if (port->mapbase == 0xa4438000) { /* SCIF1 */
-                        /* Clear PVCR bit 9-2 */
-                        data = __raw_readw(PORT_PVCR);
-                        __raw_writew((data & 0xfc03), PORT_PVCR);
-                }
-        } else {
-                if (port->mapbase == 0xa4430000) { /* SCIF0 */
-                        /* Clear PTCR bit 5-2; enable only tx and rx  */
-                        data = __raw_readw(PORT_PTCR);
-                        __raw_writew((data & 0xffc3), PORT_PTCR);
-                } else if (port->mapbase == 0xa4438000) { /* SCIF1 */
-                        /* Clear PVCR bit 5-2 */
-                        data = __raw_readw(PORT_PVCR);
-                        __raw_writew((data & 0xffc3), PORT_PVCR);
-                }
-        }
-}
-#elif defined(CONFIG_CPU_SH3)
-/* For SH7705, SH7706, SH7707, SH7709, SH7709A, SH7729 */
-static inline void sci_init_pins(struct uart_port *port, unsigned int cflag)
-{
-        unsigned short data;
-
-        /* We need to set SCPCR to enable RTS/CTS */
-        data = __raw_readw(SCPCR);
-        /* Clear out SCP7MD1,0, SCP6MD1,0, SCP4MD1,0*/
-        __raw_writew(data & 0x0fcf, SCPCR);
-
-        if (!(cflag & CRTSCTS)) {
-                /* We need to set SCPCR to enable RTS/CTS */
-                data = __raw_readw(SCPCR);
-                /* Clear out SCP7MD1,0, SCP4MD1,0,
-                   Set SCP6MD1,0 = {01} (output)  */
-                __raw_writew((data & 0x0fcf) | 0x1000, SCPCR);
+        struct sci_port *s = to_sci_port(port);
+        struct plat_sci_reg *reg = sci_regmap[s->cfg->regtype] + SCSPTR;
 
-                data = __raw_readb(SCPDR);
-                /* Set /RTS2 (bit6) = 0 */
-                __raw_writeb(data & 0xbf, SCPDR);
+        /*
+         * Use port-specific handler if provided.
+         */
+        if (s->cfg->ops && s->cfg->ops->init_pins) {
+                s->cfg->ops->init_pins(port, cflag);
+                return;
         }
-}
-#elif defined(CONFIG_CPU_SUBTYPE_SH7722)
-static inline void sci_init_pins(struct uart_port *port, unsigned int cflag)
-{
-        unsigned short data;
 
-        if (port->mapbase == 0xffe00000) {
-                data = __raw_readw(PSCR);
-                data &= ~0x03cf;
-                if (!(cflag & CRTSCTS))
-                        data |= 0x0340;
+        /*
+         * For the generic path SCSPTR is necessary. Bail out if that's
+         * unavailable, too.
+         */
+        if (!reg->size)
+                return;
 
-                __raw_writew(data, PSCR);
-        }
-}
-#elif defined(CONFIG_CPU_SUBTYPE_SH7757) || \
-      defined(CONFIG_CPU_SUBTYPE_SH7763) || \
-      defined(CONFIG_CPU_SUBTYPE_SH7780) || \
-      defined(CONFIG_CPU_SUBTYPE_SH7785) || \
-      defined(CONFIG_CPU_SUBTYPE_SH7786) || \
-      defined(CONFIG_CPU_SUBTYPE_SHX3)
-static inline void sci_init_pins(struct uart_port *port, unsigned int cflag)
-{
-        if (!(cflag & CRTSCTS))
-                __raw_writew(0x0080, SCSPTR0); /* Set RTS = 1 */
-}
-#elif defined(CONFIG_CPU_SH4) && !defined(CONFIG_CPU_SH4A)
-static inline void sci_init_pins(struct uart_port *port, unsigned int cflag)
-{
         if (!(cflag & CRTSCTS))
-                __raw_writew(0x0080, SCSPTR2); /* Set RTS = 1 */
+                sci_out(port, SCSPTR, 0x0080); /* Set RTS = 1 */
 }
-#else
-static inline void sci_init_pins(struct uart_port *port, unsigned int cflag)
-{
-        /* Nothing to do */
-}
-#endif
 
-#if defined(CONFIG_CPU_SUBTYPE_SH7760) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7780) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7785) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7786)
-static int scif_txfill(struct uart_port *port)
-{
-        return sci_in(port, SCTFDR) & 0xff;
-}
-
-static int scif_txroom(struct uart_port *port)
+static int sci_txfill(struct uart_port *port)
 {
-        return SCIF_TXROOM_MAX - scif_txfill(port);
-}
+        struct plat_sci_reg *reg;
 
-static int scif_rxfill(struct uart_port *port)
-{
-        return sci_in(port, SCRFDR) & 0xff;
-}
-#elif defined(CONFIG_CPU_SUBTYPE_SH7763)
-static int scif_txfill(struct uart_port *port)
-{
-        if (port->mapbase == 0xffe00000 ||
-            port->mapbase == 0xffe08000)
-                /* SCIF0/1*/
+        reg = sci_getreg(port, SCTFDR);
+        if (reg->size)
                 return sci_in(port, SCTFDR) & 0xff;
-        else
-                /* SCIF2 */
+
+        reg = sci_getreg(port, SCFDR);
+        if (reg->size)
                 return sci_in(port, SCFDR) >> 8;
-}
 
-static int scif_txroom(struct uart_port *port)
-{
-        if (port->mapbase == 0xffe00000 ||
-            port->mapbase == 0xffe08000)
-                /* SCIF0/1*/
-                return SCIF_TXROOM_MAX - scif_txfill(port);
-        else
-                /* SCIF2 */
-                return SCIF2_TXROOM_MAX - scif_txfill(port);
+        return !(sci_in(port, SCxSR) & SCI_TDRE);
 }
 
-static int scif_rxfill(struct uart_port *port)
-{
-        if ((port->mapbase == 0xffe00000) ||
-            (port->mapbase == 0xffe08000)) {
-                /* SCIF0/1*/
-                return sci_in(port, SCRFDR) & 0xff;
-        } else {
-                /* SCIF2 */
-                return sci_in(port, SCFDR) & SCIF2_RFDC_MASK;
-        }
-}
-#elif defined(CONFIG_ARCH_SH7372)
-static int scif_txfill(struct uart_port *port)
+static int sci_txroom(struct uart_port *port)
 {
-        if (port->type == PORT_SCIFA)
-                return sci_in(port, SCFDR) >> 8;
-        else
-                return sci_in(port, SCTFDR);
+        return port->fifosize - sci_txfill(port);
 }
 
-static int scif_txroom(struct uart_port *port)
+static int sci_rxfill(struct uart_port *port)
 {
-        return port->fifosize - scif_txfill(port);
-}
+        struct plat_sci_reg *reg;
 
-static int scif_rxfill(struct uart_port *port)
-{
-        if (port->type == PORT_SCIFA)
-                return sci_in(port, SCFDR) & SCIF_RFDC_MASK;
-        else
-                return sci_in(port, SCRFDR);
-}
-#else
-static int scif_txfill(struct uart_port *port)
-{
-        return sci_in(port, SCFDR) >> 8;
-}
+        reg = sci_getreg(port, SCRFDR);
+        if (reg->size)
+                return sci_in(port, SCRFDR) & 0xff;
 
-static int scif_txroom(struct uart_port *port)
-{
-        return SCIF_TXROOM_MAX - scif_txfill(port);
-}
+        reg = sci_getreg(port, SCFDR);
+        if (reg->size)
+                return sci_in(port, SCFDR) & ((port->fifosize << 1) - 1);
 
-static int scif_rxfill(struct uart_port *port)
-{
-        return sci_in(port, SCFDR) & SCIF_RFDC_MASK;
+        return (sci_in(port, SCxSR) & SCxSR_RDxF(port)) != 0;
 }
-#endif
 
-static int sci_txfill(struct uart_port *port)
+/*
+ * SCI helper for checking the state of the muxed port/RXD pins.
+ */
+static inline int sci_rxd_in(struct uart_port *port)
 {
-        return !(sci_in(port, SCxSR) & SCI_TDRE);
-}
+        struct sci_port *s = to_sci_port(port);
 
-static int sci_txroom(struct uart_port *port)
-{
-        return !sci_txfill(port);
-}
+        if (s->cfg->port_reg <= 0)
+                return 1;
 
-static int sci_rxfill(struct uart_port *port)
-{
-        return (sci_in(port, SCxSR) & SCxSR_RDxF(port)) != 0;
+        return !!__raw_readb(s->cfg->port_reg);
 }
 
 /* ********************************************************************** *
@@ -406,10 +530,7 @@ static void sci_transmit_chars(struct uart_port *port)
                 return;
         }
 
-        if (port->type == PORT_SCI)
-                count = sci_txroom(port);
-        else
-                count = scif_txroom(port);
+        count = sci_txroom(port);
 
         do {
                 unsigned char c;
@@ -464,13 +585,8 @@ static void sci_receive_chars(struct uart_port *port)
                 return;
 
         while (1) {
-                if (port->type == PORT_SCI)
-                        count = sci_rxfill(port);
-                else
-                        count = scif_rxfill(port);
-
                 /* Don't copy more bytes than there is room for in the buffer */
-                count = tty_buffer_request_room(tty, count);
+                count = tty_buffer_request_room(tty, sci_rxfill(port));
 
                 /* If for any reason we can't copy more data, we're done! */
                 if (count == 0)
@@ -561,8 +677,7 @@ static void sci_break_timer(unsigned long data)
 {
         struct sci_port *port = (struct sci_port *)data;
 
-        if (port->enable)
-                port->enable(&port->port);
+        sci_port_enable(port);
 
         if (sci_rxd_in(&port->port) == 0) {
                 port->break_flag = 1;
@@ -574,8 +689,7 @@ static void sci_break_timer(unsigned long data)
         } else
                 port->break_flag = 0;
 
-        if (port->disable)
-                port->disable(&port->port);
+        sci_port_disable(port);
 }
 
 static int sci_handle_errors(struct uart_port *port)
@@ -583,13 +697,19 @@ static int sci_handle_errors(struct uart_port *port)
         int copied = 0;
         unsigned short status = sci_in(port, SCxSR);
         struct tty_struct *tty = port->state->port.tty;
+        struct sci_port *s = to_sci_port(port);
 
-        if (status & SCxSR_ORER(port)) {
-                /* overrun error */
-                if (tty_insert_flip_char(tty, 0, TTY_OVERRUN))
-                        copied++;
+        /*
+         * Handle overruns, if supported.
+         */
+        if (s->cfg->overrun_bit != SCIx_NOT_SUPPORTED) {
+                if (status & (1 << s->cfg->overrun_bit)) {
+                        /* overrun error */
+                        if (tty_insert_flip_char(tty, 0, TTY_OVERRUN))
+                                copied++;
 
-                dev_notice(port->dev, "overrun error");
+                        dev_notice(port->dev, "overrun error");
+                }
         }
 
         if (status & SCxSR_FER(port)) {
@@ -637,12 +757,15 @@ static int sci_handle_errors(struct uart_port *port)
 static int sci_handle_fifo_overrun(struct uart_port *port)
 {
         struct tty_struct *tty = port->state->port.tty;
+        struct sci_port *s = to_sci_port(port);
+        struct plat_sci_reg *reg;
         int copied = 0;
 
-        if (port->type != PORT_SCIF)
+        reg = sci_getreg(port, SCLSR);
+        if (!reg->size)
                 return 0;
 
-        if ((sci_in(port, SCLSR) & SCIF_ORER) != 0) {
+        if ((sci_in(port, SCLSR) & (1 << s->cfg->overrun_bit))) {
                 sci_out(port, SCLSR, 0);
 
                 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
@@ -840,74 +963,102 @@ static int sci_notifier(struct notifier_block *self,
         return NOTIFY_OK;
 }
 
-static void sci_clk_enable(struct uart_port *port)
-{
-        struct sci_port *sci_port = to_sci_port(port);
-
-        pm_runtime_get_sync(port->dev);
+static struct sci_irq_desc {
+        const char      *desc;
+        irq_handler_t   handler;
+} sci_irq_desc[] = {
+        /*
+         * Split out handlers, the default case.
+         */
+        [SCIx_ERI_IRQ] = {
+                .desc = "rx err",
+                .handler = sci_er_interrupt,
+        },
 
-        clk_enable(sci_port->iclk);
-        sci_port->port.uartclk = clk_get_rate(sci_port->iclk);
-        clk_enable(sci_port->fclk);
-}
+        [SCIx_RXI_IRQ] = {
+                .desc = "rx full",
+                .handler = sci_rx_interrupt,
+        },
 
-static void sci_clk_disable(struct uart_port *port)
-{
-        struct sci_port *sci_port = to_sci_port(port);
+        [SCIx_TXI_IRQ] = {
+                .desc = "tx empty",
+                .handler = sci_tx_interrupt,
+        },
 
-        clk_disable(sci_port->fclk);
-        clk_disable(sci_port->iclk);
+        [SCIx_BRI_IRQ] = {
+                .desc = "break",
+                .handler = sci_br_interrupt,
+        },
 
-        pm_runtime_put_sync(port->dev);
-}
+        /*
+         * Special muxed handler.
+         */
+        [SCIx_MUX_IRQ] = {
+                .desc = "mux",
+                .handler = sci_mpxed_interrupt,
+        },
+};
 
 static int sci_request_irq(struct sci_port *port)
 {
-        int i;
-        irqreturn_t (*handlers[4])(int irq, void *ptr) = {
-                sci_er_interrupt, sci_rx_interrupt, sci_tx_interrupt,
-                sci_br_interrupt,
-        };
-        const char *desc[] = { "SCI Receive Error", "SCI Receive Data Full",
-                               "SCI Transmit Data Empty", "SCI Break" };
-
-        if (port->cfg->irqs[0] == port->cfg->irqs[1]) {
-                if (unlikely(!port->cfg->irqs[0]))
-                        return -ENODEV;
-
-                if (request_irq(port->cfg->irqs[0], sci_mpxed_interrupt,
-                                IRQF_DISABLED, "sci", port)) {
-                        dev_err(port->port.dev, "Can't allocate IRQ\n");
-                        return -ENODEV;
+        struct uart_port *up = &port->port;
+        int i, j, ret = 0;
+
+        for (i = j = 0; i < SCIx_NR_IRQS; i++, j++) {
+                struct sci_irq_desc *desc;
+                unsigned int irq;
+
+                if (SCIx_IRQ_IS_MUXED(port)) {
+                        i = SCIx_MUX_IRQ;
+                        irq = up->irq;
+                } else
+                        irq = port->cfg->irqs[i];
+
+                desc = sci_irq_desc + i;
+                port->irqstr[j] = kasprintf(GFP_KERNEL, "%s:%s",
+                                            dev_name(up->dev), desc->desc);
+                if (!port->irqstr[j]) {
+                        dev_err(up->dev, "Failed to allocate %s IRQ string\n",
+                                desc->desc);
+                        goto out_nomem;
                 }
-        } else {
-                for (i = 0; i < ARRAY_SIZE(handlers); i++) {
-                        if (unlikely(!port->cfg->irqs[i]))
-                                continue;
-
-                        if (request_irq(port->cfg->irqs[i], handlers[i],
-                                        IRQF_DISABLED, desc[i], port)) {
-                                dev_err(port->port.dev, "Can't allocate IRQ\n");
-                                return -ENODEV;
-                        }
+
+                ret = request_irq(irq, desc->handler, up->irqflags,
+                                  port->irqstr[j], port);
+                if (unlikely(ret)) {
+                        dev_err(up->dev, "Can't allocate %s IRQ\n", desc->desc);
+                        goto out_noirq;
                 }
         }
 
         return 0;
+
+out_noirq:
+        while (--i >= 0)
+                free_irq(port->cfg->irqs[i], port);
+
+out_nomem:
+        while (--j >= 0)
+                kfree(port->irqstr[j]);
+
+        return ret;
 }
 
 static void sci_free_irq(struct sci_port *port)
 {
         int i;
 
-        if (port->cfg->irqs[0] == port->cfg->irqs[1])
-                free_irq(port->cfg->irqs[0], port);
-        else {
-                for (i = 0; i < ARRAY_SIZE(port->cfg->irqs); i++) {
-                        if (!port->cfg->irqs[i])
-                                continue;
+        /*
+         * Intentionally in reverse order so we iterate over the muxed
+         * IRQ first.
+         */
+        for (i = 0; i < SCIx_NR_IRQS; i++) {
+                free_irq(port->cfg->irqs[i], port);
+                kfree(port->irqstr[i]);
 
-                        free_irq(port->cfg->irqs[i], port);
+                if (SCIx_IRQ_IS_MUXED(port)) {
+                        /* If there's only one IRQ, we're done. */
+                        return;
                 }
         }
 }
@@ -915,7 +1066,7 @@ static void sci_free_irq(struct sci_port *port)
 static unsigned int sci_tx_empty(struct uart_port *port)
 {
         unsigned short status = sci_in(port, SCxSR);
-        unsigned short in_tx_fifo = scif_txfill(port);
+        unsigned short in_tx_fifo = sci_txfill(port);
 
         return (status & SCxSR_TEND(port)) && !in_tx_fifo ? TIOCSER_TEMT : 0;
 }
@@ -932,7 +1083,7 @@ static unsigned int sci_get_mctrl(struct uart_port *port)
         /* This routine is used for getting signals of: DTR, DCD, DSR, RI,
            and CTS/RTS */
 
-        return TIOCM_DTR | TIOCM_RTS | TIOCM_DSR;
+        return TIOCM_DTR | TIOCM_RTS | TIOCM_CTS | TIOCM_DSR;
 }
 
 #ifdef CONFIG_SERIAL_SH_SCI_DMA
@@ -1438,8 +1589,7 @@ static int sci_startup(struct uart_port *port)
 
         dev_dbg(port->dev, "%s(%d)\n", __func__, port->line);
 
-        if (s->enable)
-                s->enable(port);
+        sci_port_enable(s);
 
         ret = sci_request_irq(s);
         if (unlikely(ret < 0))
@@ -1465,8 +1615,7 @@ static void sci_shutdown(struct uart_port *port)
         sci_free_dma(port);
         sci_free_irq(s);
 
-        if (s->disable)
-                s->disable(port);
+        sci_port_disable(s);
 }
 
 static unsigned int sci_scbrr_calc(unsigned int algo_id, unsigned int bps,
@@ -1491,11 +1640,25 @@ static unsigned int sci_scbrr_calc(unsigned int algo_id, unsigned int bps,
         return ((freq + 16 * bps) / (32 * bps) - 1);
 }
 
+static void sci_reset(struct uart_port *port)
+{
+        unsigned int status;
+
+        do {
+                status = sci_in(port, SCxSR);
+        } while (!(status & SCxSR_TEND(port)));
+
+        sci_out(port, SCSCR, 0x00);     /* TE=0, RE=0, CKE1=0 */
+
+        if (port->type != PORT_SCI)
+                sci_out(port, SCFCR, SCFCR_RFRST | SCFCR_TFRST);
+}
+
 static void sci_set_termios(struct uart_port *port, struct ktermios *termios,
                             struct ktermios *old)
 {
         struct sci_port *s = to_sci_port(port);
-        unsigned int status, baud, smr_val, max_baud;
+        unsigned int baud, smr_val, max_baud;
         int t = -1;
         u16 scfcr = 0;
 
@@ -1513,17 +1676,9 @@ static void sci_set_termios(struct uart_port *port, struct ktermios *termios,
         if (likely(baud && port->uartclk))
                 t = sci_scbrr_calc(s->cfg->scbrr_algo_id, baud, port->uartclk);
 
-        if (s->enable)
-                s->enable(port);
-
-        do {
-                status = sci_in(port, SCxSR);
-        } while (!(status & SCxSR_TEND(port)));
-
-        sci_out(port, SCSCR, 0x00);     /* TE=0, RE=0, CKE1=0 */
+        sci_port_enable(s);
 
-        if (port->type != PORT_SCI)
-                sci_out(port, SCFCR, scfcr | SCFCR_RFRST | SCFCR_TFRST);
+        sci_reset(port);
 
         smr_val = sci_in(port, SCSMR) & 3;
 
@@ -1584,8 +1739,7 @@ static void sci_set_termios(struct uart_port *port, struct ktermios *termios,
         if ((termios->c_cflag & CREAD) != 0)
                 sci_start_rx(port);
 
-        if (s->disable)
-                s->disable(port);
+        sci_port_disable(s);
 }
 
 static const char *sci_type(struct uart_port *port)
@@ -1726,6 +1880,7 @@ static int __devinit sci_init_single(struct platform_device *dev,
                                      struct plat_sci_port *p)
 {
         struct uart_port *port = &sci_port->port;
+        int ret;
 
         port->ops       = &sci_uart_ops;
         port->iotype    = UPIO_MEM;
@@ -1746,6 +1901,12 @@ static int __devinit sci_init_single(struct platform_device *dev,
                 break;
         }
 
+        if (p->regtype == SCIx_PROBE_REGTYPE) {
+                ret = sci_probe_regmap(p);
+                if (unlikely(ret))
+                        return ret;
+        }
+
         if (dev) {
                 sci_port->iclk = clk_get(&dev->dev, "sci_ick");
                 if (IS_ERR(sci_port->iclk)) {
@@ -1764,10 +1925,9 @@ static int __devinit sci_init_single(struct platform_device *dev,
                 if (IS_ERR(sci_port->fclk))
                         sci_port->fclk = NULL;
 
-                sci_port->enable = sci_clk_enable;
-                sci_port->disable = sci_clk_disable;
                 port->dev = &dev->dev;
 
+                pm_runtime_irq_safe(&dev->dev);
                 pm_runtime_enable(&dev->dev);
         }
 
@@ -1775,20 +1935,51 @@ static int __devinit sci_init_single(struct platform_device *dev,
         sci_port->break_timer.function = sci_break_timer;
         init_timer(&sci_port->break_timer);
 
+        /*
+         * Establish some sensible defaults for the error detection.
+         */
+        if (!p->error_mask)
+                p->error_mask = (p->type == PORT_SCI) ?
+                        SCI_DEFAULT_ERROR_MASK : SCIF_DEFAULT_ERROR_MASK;
+
+        /*
+         * Establish sensible defaults for the overrun detection, unless
+         * the part has explicitly disabled support for it.
+         */
+        if (p->overrun_bit != SCIx_NOT_SUPPORTED) {
+                if (p->type == PORT_SCI)
+                        p->overrun_bit = 5;
+                else if (p->scbrr_algo_id == SCBRR_ALGO_4)
+                        p->overrun_bit = 9;
+                else
+                        p->overrun_bit = 0;
+
+                /*
+                 * Make the error mask inclusive of overrun detection, if
+                 * supported.
+                 */
+                p->error_mask |= (1 << p->overrun_bit);
+        }
+
         sci_port->cfg           = p;
 
         port->mapbase           = p->mapbase;
         port->type              = p->type;
         port->flags             = p->flags;
+        port->regshift          = p->regshift;
 
         /*
-         * The UART port needs an IRQ value, so we peg this to the TX IRQ
+         * The UART port needs an IRQ value, so we peg this to the RX IRQ
          * for the multi-IRQ ports, which is where we are primarily
          * concerned with the shutdown path synchronization.
          *
          * For the muxed case there's nothing more to do.
          */
         port->irq               = p->irqs[SCIx_RXI_IRQ];
+        port->irqflags          = IRQF_DISABLED;
+
+        port->serial_in         = sci_serial_in;
+        port->serial_out        = sci_serial_out;
 
         if (p->dma_dev)
                 dev_dbg(port->dev, "DMA device %p, tx %d, rx %d\n",
@@ -1814,8 +2005,7 @@ static void serial_console_write(struct console *co, const char *s,
         struct uart_port *port = &sci_port->port;
         unsigned short bits;
 
-        if (sci_port->enable)
-                sci_port->enable(port);
+        sci_port_enable(sci_port);
 
         uart_console_write(port, s, count, serial_console_putchar);
 
@@ -1824,8 +2014,7 @@ static void serial_console_write(struct console *co, const char *s,
         while ((sci_in(port, SCxSR) & bits) != bits)
                 cpu_relax();
 
-        if (sci_port->disable)
-                sci_port->disable(port);
+        sci_port_disable(sci_port);
 }
 
 static int __devinit serial_console_setup(struct console *co, char *options)
@@ -1857,20 +2046,14 @@ static int __devinit serial_console_setup(struct console *co, char *options)
         if (unlikely(ret != 0))
                 return ret;
 
-        if (sci_port->enable)
-                sci_port->enable(port);
+        sci_port_enable(sci_port);
 
         if (options)
                 uart_parse_options(options, &baud, &parity, &bits, &flow);
 
-        ret = uart_set_options(port, co, baud, parity, bits, flow);
-#if defined(__H8300H__) || defined(__H8300S__)
-        /* disable rx interrupt */
-        if (ret == 0)
-                sci_stop_rx(port);
-#endif
-        /* TODO: disable clock */
-        return ret;
+        sci_port_disable(sci_port);
+
+        return uart_set_options(port, co, baud, parity, bits, flow);
 }
 
 static struct console serial_console = {
@@ -1912,6 +2095,36 @@ static int __devinit sci_probe_earlyprintk(struct platform_device *pdev)
         return 0;
 }
 
+#define uart_console(port)      ((port)->cons->index == (port)->line)
+
+static int sci_runtime_suspend(struct device *dev)
+{
+        struct sci_port *sci_port = dev_get_drvdata(dev);
+        struct uart_port *port = &sci_port->port;
+
+        if (uart_console(port)) {
+                sci_port->saved_smr = sci_in(port, SCSMR);
+                sci_port->saved_brr = sci_in(port, SCBRR);
+                sci_port->saved_fcr = sci_in(port, SCFCR);
+        }
+        return 0;
+}
+
+static int sci_runtime_resume(struct device *dev)
+{
+        struct sci_port *sci_port = dev_get_drvdata(dev);
+        struct uart_port *port = &sci_port->port;
+
+        if (uart_console(port)) {
+                sci_reset(port);
+                sci_out(port, SCSMR, sci_port->saved_smr);
+                sci_out(port, SCBRR, sci_port->saved_brr);
+                sci_out(port, SCFCR, sci_port->saved_fcr);
+                sci_out(port, SCSCR, sci_port->cfg->scscr);
+        }
+        return 0;
+}
+
 #define SCI_CONSOLE     (&serial_console)
 
 #else
@@ -1921,6 +2134,8 @@ static inline int __devinit sci_probe_earlyprintk(struct platform_device *pdev)
 }
 
 #define SCI_CONSOLE     NULL
+#define sci_runtime_suspend     NULL
+#define sci_runtime_resume      NULL
 
 #endif /* CONFIG_SERIAL_SH_SCI_CONSOLE */
 
@@ -2036,6 +2251,8 @@ static int sci_resume(struct device *dev)
 }
 
 static const struct dev_pm_ops sci_dev_pm_ops = {
+        .runtime_suspend = sci_runtime_suspend,
+        .runtime_resume = sci_runtime_resume,
         .suspend        = sci_suspend,
         .resume         = sci_resume,
 };
@@ -2081,3 +2298,5 @@ module_exit(sci_exit);
 
 MODULE_LICENSE("GPL");
 MODULE_ALIAS("platform:sh-sci");
+MODULE_AUTHOR("Paul Mundt");
+MODULE_DESCRIPTION("SuperH SCI(F) serial driver");
diff --git a/drivers/tty/serial/sh-sci.h b/drivers/tty/serial/sh-sci.h
index b04d937c9110..e9bed038aa1f 100644
--- a/drivers/tty/serial/sh-sci.h
+++ b/drivers/tty/serial/sh-sci.h
@@ -2,169 +2,14 @@
 #include <linux/io.h>
 #include <linux/gpio.h>
 
-#if defined(CONFIG_H83007) || defined(CONFIG_H83068)
-#include <asm/regs306x.h>
-#endif
-#if defined(CONFIG_H8S2678)
-#include <asm/regs267x.h>
-#endif
-
-#if defined(CONFIG_CPU_SUBTYPE_SH7706) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7707) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7708) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7709)
-# define SCPCR  0xA4000116 /* 16 bit SCI and SCIF */
-# define SCPDR  0xA4000136 /* 8  bit SCI and SCIF */
-#elif defined(CONFIG_CPU_SUBTYPE_SH7705)
-# define SCIF0          0xA4400000
-# define SCIF2          0xA4410000
-# define SCPCR 0xA4000116
-# define SCPDR 0xA4000136
-#elif defined(CONFIG_CPU_SUBTYPE_SH7720) || \
-      defined(CONFIG_CPU_SUBTYPE_SH7721) || \
-      defined(CONFIG_ARCH_SH73A0) || \
-      defined(CONFIG_ARCH_SH7367) || \
-      defined(CONFIG_ARCH_SH7377) || \
-      defined(CONFIG_ARCH_SH7372)
-# define PORT_PTCR         0xA405011EUL
-# define PORT_PVCR         0xA4050122UL
-# define SCIF_ORER         0x0200   /* overrun error bit */
-#elif defined(CONFIG_SH_RTS7751R2D)
-# define SCSPTR1 0xFFE0001C /* 8 bit SCIF */
-# define SCSPTR2 0xFFE80020 /* 16 bit SCIF */
-# define SCIF_ORER 0x0001   /* overrun error bit */
-#elif defined(CONFIG_CPU_SUBTYPE_SH7750)  || \
-      defined(CONFIG_CPU_SUBTYPE_SH7750R) || \
-      defined(CONFIG_CPU_SUBTYPE_SH7750S) || \
-      defined(CONFIG_CPU_SUBTYPE_SH7091)  || \
-      defined(CONFIG_CPU_SUBTYPE_SH7751)  || \
-      defined(CONFIG_CPU_SUBTYPE_SH7751R)
-# define SCSPTR1 0xffe0001c /* 8  bit SCI */
-# define SCSPTR2 0xFFE80020 /* 16 bit SCIF */
-# define SCIF_ORER 0x0001   /* overrun error bit */
-#elif defined(CONFIG_CPU_SUBTYPE_SH7760)
-# define SCSPTR0 0xfe600024 /* 16 bit SCIF */
-# define SCSPTR1 0xfe610024 /* 16 bit SCIF */
-# define SCSPTR2 0xfe620024 /* 16 bit SCIF */
-# define SCIF_ORER 0x0001  /* overrun error bit */
-#elif defined(CONFIG_CPU_SUBTYPE_SH7710) || defined(CONFIG_CPU_SUBTYPE_SH7712)
-# define SCSPTR0 0xA4400000       /* 16 bit SCIF */
-# define SCIF_ORER 0x0001   /* overrun error bit */
-# define PACR 0xa4050100
-# define PBCR 0xa4050102
-#elif defined(CONFIG_CPU_SUBTYPE_SH7343)
-# define SCSPTR0 0xffe00010     /* 16 bit SCIF */
-#elif defined(CONFIG_CPU_SUBTYPE_SH7722)
-# define PADR                   0xA4050120
-# define PSDR                   0xA405013e
-# define PWDR                   0xA4050166
-# define PSCR                   0xA405011E
-# define SCIF_ORER              0x0001  /* overrun error bit */
-#elif defined(CONFIG_CPU_SUBTYPE_SH7366)
-# define SCPDR0                 0xA405013E      /* 16 bit SCIF0 PSDR */
-# define SCSPTR0                SCPDR0
-# define SCIF_ORER              0x0001  /* overrun error bit */
-#elif defined(CONFIG_CPU_SUBTYPE_SH7723)
-# define SCSPTR0                0xa4050160
-# define SCIF_ORER              0x0001  /* overrun error bit */
-#elif defined(CONFIG_CPU_SUBTYPE_SH7724)
-# define SCIF_ORER              0x0001  /* overrun error bit */
-#elif defined(CONFIG_CPU_SUBTYPE_SH4_202)
-# define SCSPTR2 0xffe80020 /* 16 bit SCIF */
-# define SCIF_ORER 0x0001   /* overrun error bit */
-#elif defined(CONFIG_H83007) || defined(CONFIG_H83068)
-# define H8300_SCI_DR(ch) *(volatile char *)(P1DR + h8300_sci_pins[ch].port)
-#elif defined(CONFIG_H8S2678)
-# define H8300_SCI_DR(ch) *(volatile char *)(P1DR + h8300_sci_pins[ch].port)
-#elif defined(CONFIG_CPU_SUBTYPE_SH7757)
-# define SCSPTR0 0xfe4b0020
-# define SCIF_ORER 0x0001
-#elif defined(CONFIG_CPU_SUBTYPE_SH7763)
-# define SCSPTR0 0xffe00024 /* 16 bit SCIF */
-# define SCIF_ORER 0x0001  /* overrun error bit */
-#elif defined(CONFIG_CPU_SUBTYPE_SH7770)
-# define SCSPTR0 0xff923020 /* 16 bit SCIF */
-# define SCIF_ORER 0x0001  /* overrun error bit */
-#elif defined(CONFIG_CPU_SUBTYPE_SH7780)
-# define SCSPTR0        0xffe00024      /* 16 bit SCIF */
-# define SCIF_ORER      0x0001          /* Overrun error bit */
-#elif defined(CONFIG_CPU_SUBTYPE_SH7785) || \
-      defined(CONFIG_CPU_SUBTYPE_SH7786)
-# define SCSPTR0        0xffea0024      /* 16 bit SCIF */
-# define SCIF_ORER      0x0001          /* Overrun error bit */
-#elif defined(CONFIG_CPU_SUBTYPE_SH7201) || \
-      defined(CONFIG_CPU_SUBTYPE_SH7203) || \
-      defined(CONFIG_CPU_SUBTYPE_SH7206) || \
-      defined(CONFIG_CPU_SUBTYPE_SH7263)
-# define SCSPTR0 0xfffe8020 /* 16 bit SCIF */
-#elif defined(CONFIG_CPU_SUBTYPE_SH7619)
-# define SCSPTR0 0xf8400020 /* 16 bit SCIF */
-# define SCIF_ORER 0x0001  /* overrun error bit */
-#elif defined(CONFIG_CPU_SUBTYPE_SHX3)
-# define SCSPTR0 0xffc30020             /* 16 bit SCIF */
-# define SCIF_ORER 0x0001               /* Overrun error bit */
-#else
-# error CPU subtype not defined
-#endif
-
-/* SCxSR SCI */
-#define SCI_TDRE  0x80 /* 7707 SCI, 7708 SCI, 7709 SCI, 7750 SCI */
-#define SCI_RDRF  0x40 /* 7707 SCI, 7708 SCI, 7709 SCI, 7750 SCI */
-#define SCI_ORER  0x20 /* 7707 SCI, 7708 SCI, 7709 SCI, 7750 SCI */
-#define SCI_FER   0x10 /* 7707 SCI, 7708 SCI, 7709 SCI, 7750 SCI */
-#define SCI_PER   0x08 /* 7707 SCI, 7708 SCI, 7709 SCI, 7750 SCI */
-#define SCI_TEND  0x04 /* 7707 SCI, 7708 SCI, 7709 SCI, 7750 SCI */
-/*      SCI_MPB   0x02  * 7707 SCI, 7708 SCI, 7709 SCI, 7750 SCI */
-/*      SCI_MPBT  0x01  * 7707 SCI, 7708 SCI, 7709 SCI, 7750 SCI */
-
-#define SCI_ERRORS ( SCI_PER | SCI_FER | SCI_ORER)
-
-/* SCxSR SCIF */
-#define SCIF_ER    0x0080 /* 7705 SCIF, 7707 SCIF, 7709 SCIF, 7750 SCIF */
-#define SCIF_TEND  0x0040 /* 7705 SCIF, 7707 SCIF, 7709 SCIF, 7750 SCIF */
-#define SCIF_TDFE  0x0020 /* 7705 SCIF, 7707 SCIF, 7709 SCIF, 7750 SCIF */
-#define SCIF_BRK   0x0010 /* 7705 SCIF, 7707 SCIF, 7709 SCIF, 7750 SCIF */
-#define SCIF_FER   0x0008 /* 7705 SCIF, 7707 SCIF, 7709 SCIF, 7750 SCIF */
-#define SCIF_PER   0x0004 /* 7705 SCIF, 7707 SCIF, 7709 SCIF, 7750 SCIF */
-#define SCIF_RDF   0x0002 /* 7705 SCIF, 7707 SCIF, 7709 SCIF, 7750 SCIF */
-#define SCIF_DR    0x0001 /* 7705 SCIF, 7707 SCIF, 7709 SCIF, 7750 SCIF */
-
-#if defined(CONFIG_CPU_SUBTYPE_SH7705) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7720) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7721) || \
-    defined(CONFIG_ARCH_SH73A0) || \
-    defined(CONFIG_ARCH_SH7367) || \
-    defined(CONFIG_ARCH_SH7377) || \
-    defined(CONFIG_ARCH_SH7372)
-# define SCIF_ORER    0x0200
-# define SCIF_ERRORS ( SCIF_PER | SCIF_FER | SCIF_ER | SCIF_BRK | SCIF_ORER)
-# define SCIF_RFDC_MASK 0x007f
-# define SCIF_TXROOM_MAX 64
-#elif defined(CONFIG_CPU_SUBTYPE_SH7763)
-# define SCIF_ERRORS ( SCIF_PER | SCIF_FER | SCIF_ER | SCIF_BRK )
-# define SCIF_RFDC_MASK 0x007f
-# define SCIF_TXROOM_MAX 64
-/* SH7763 SCIF2 support */
-# define SCIF2_RFDC_MASK 0x001f
-# define SCIF2_TXROOM_MAX 16
-#else
-# define SCIF_ERRORS ( SCIF_PER | SCIF_FER | SCIF_ER | SCIF_BRK)
-# define SCIF_RFDC_MASK 0x001f
-# define SCIF_TXROOM_MAX 16
-#endif
-
-#ifndef SCIF_ORER
-#define SCIF_ORER       0x0000
-#endif
-
 #define SCxSR_TEND(port)        (((port)->type == PORT_SCI) ? SCI_TEND   : SCIF_TEND)
-#define SCxSR_ERRORS(port)      (((port)->type == PORT_SCI) ? SCI_ERRORS : SCIF_ERRORS)
 #define SCxSR_RDxF(port)        (((port)->type == PORT_SCI) ? SCI_RDRF   : SCIF_RDF)
 #define SCxSR_TDxE(port)        (((port)->type == PORT_SCI) ? SCI_TDRE   : SCIF_TDFE)
 #define SCxSR_FER(port)         (((port)->type == PORT_SCI) ? SCI_FER    : SCIF_FER)
 #define SCxSR_PER(port)         (((port)->type == PORT_SCI) ? SCI_PER    : SCIF_PER)
 #define SCxSR_BRK(port)         (((port)->type == PORT_SCI) ? 0x00       : SCIF_BRK)
-#define SCxSR_ORER(port)        (((port)->type == PORT_SCI) ? SCI_ORER   : SCIF_ORER)
+
+#define SCxSR_ERRORS(port)      (to_sci_port(port)->cfg->error_mask)
 
 #if defined(CONFIG_CPU_SUBTYPE_SH7705) || \
     defined(CONFIG_CPU_SUBTYPE_SH7720) || \
@@ -191,278 +36,3 @@
 
 #define SCI_MAJOR               204
 #define SCI_MINOR_START         8
-
-#define SCI_IN(size, offset)                                    \
-  if ((size) == 8) {                                            \
-    return ioread8(port->membase + (offset));                   \
-  } else {                                                      \
-    return ioread16(port->membase + (offset));                  \
-  }
-#define SCI_OUT(size, offset, value)                            \
-  if ((size) == 8) {                                            \
-    iowrite8(value, port->membase + (offset));                  \
-  } else if ((size) == 16) {                                    \
-    iowrite16(value, port->membase + (offset));                 \
-  }
-
-#define CPU_SCIx_FNS(name, sci_offset, sci_size, scif_offset, scif_size)\
-  static inline unsigned int sci_##name##_in(struct uart_port *port)    \
-  {                                                                     \
-    if (port->type == PORT_SCIF || port->type == PORT_SCIFB) {          \
-      SCI_IN(scif_size, scif_offset)                                    \
-    } else {    /* PORT_SCI or PORT_SCIFA */                            \
-      SCI_IN(sci_size, sci_offset);                                     \
-    }                                                                   \
-  }                                                                     \
-  static inline void sci_##name##_out(struct uart_port *port, unsigned int value) \
-  {                                                                     \
-    if (port->type == PORT_SCIF || port->type == PORT_SCIFB) {          \
-      SCI_OUT(scif_size, scif_offset, value)                            \
-    } else {    /* PORT_SCI or PORT_SCIFA */                            \
-      SCI_OUT(sci_size, sci_offset, value);                             \
-    }                                                                   \
-  }
-
-#ifdef CONFIG_H8300
-/* h8300 don't have SCIF */
-#define CPU_SCIF_FNS(name)                                              \
-  static inline unsigned int sci_##name##_in(struct uart_port *port)    \
-  {                                                                     \
-    return 0;                                                           \
-  }                                                                     \
-  static inline void sci_##name##_out(struct uart_port *port, unsigned int value) \
-  {                                                                     \
-  }
-#else
-#define CPU_SCIF_FNS(name, scif_offset, scif_size)                      \
-  static inline unsigned int sci_##name##_in(struct uart_port *port)    \
-  {                                                                     \
-    SCI_IN(scif_size, scif_offset);                                     \
-  }                                                                     \
-  static inline void sci_##name##_out(struct uart_port *port, unsigned int value) \
-  {                                                                     \
-    SCI_OUT(scif_size, scif_offset, value);                             \
-  }
-#endif
-
-#define CPU_SCI_FNS(name, sci_offset, sci_size)                         \
-  static inline unsigned int sci_##name##_in(struct uart_port* port)    \
-  {                                                                     \
-    SCI_IN(sci_size, sci_offset);                                       \
-  }                                                                     \
-  static inline void sci_##name##_out(struct uart_port* port, unsigned int value) \
-  {                                                                     \
-    SCI_OUT(sci_size, sci_offset, value);                               \
-  }
-
-#if defined(CONFIG_CPU_SH3) || \
-    defined(CONFIG_ARCH_SH73A0) || \
-    defined(CONFIG_ARCH_SH7367) || \
-    defined(CONFIG_ARCH_SH7377) || \
-    defined(CONFIG_ARCH_SH7372)
-#if defined(CONFIG_CPU_SUBTYPE_SH7710) || defined(CONFIG_CPU_SUBTYPE_SH7712)
-#define SCIx_FNS(name, sh3_sci_offset, sh3_sci_size, sh4_sci_offset, sh4_sci_size, \
-                                sh3_scif_offset, sh3_scif_size, sh4_scif_offset, sh4_scif_size, \
-                                 h8_sci_offset, h8_sci_size) \
-  CPU_SCIx_FNS(name, sh4_sci_offset, sh4_sci_size, sh4_scif_offset, sh4_scif_size)
-#define SCIF_FNS(name, sh3_scif_offset, sh3_scif_size, sh4_scif_offset, sh4_scif_size) \
-          CPU_SCIF_FNS(name, sh4_scif_offset, sh4_scif_size)
-#elif defined(CONFIG_CPU_SUBTYPE_SH7705) || \
-      defined(CONFIG_CPU_SUBTYPE_SH7720) || \
-      defined(CONFIG_CPU_SUBTYPE_SH7721) || \
-      defined(CONFIG_ARCH_SH7367)
-#define SCIF_FNS(name, scif_offset, scif_size) \
-  CPU_SCIF_FNS(name, scif_offset, scif_size)
-#elif defined(CONFIG_ARCH_SH7377) || \
-      defined(CONFIG_ARCH_SH7372) || \
-      defined(CONFIG_ARCH_SH73A0)
-#define SCIx_FNS(name, sh4_scifa_offset, sh4_scifa_size, sh4_scifb_offset, sh4_scifb_size) \
-  CPU_SCIx_FNS(name, sh4_scifa_offset, sh4_scifa_size, sh4_scifb_offset, sh4_scifb_size)
-#define SCIF_FNS(name, scif_offset, scif_size) \
-  CPU_SCIF_FNS(name, scif_offset, scif_size)
-#else
-#define SCIx_FNS(name, sh3_sci_offset, sh3_sci_size, sh4_sci_offset, sh4_sci_size, \
-                 sh3_scif_offset, sh3_scif_size, sh4_scif_offset, sh4_scif_size, \
-                 h8_sci_offset, h8_sci_size) \
-  CPU_SCIx_FNS(name, sh3_sci_offset, sh3_sci_size, sh3_scif_offset, sh3_scif_size)
-#define SCIF_FNS(name, sh3_scif_offset, sh3_scif_size, sh4_scif_offset, sh4_scif_size) \
-  CPU_SCIF_FNS(name, sh3_scif_offset, sh3_scif_size)
-#endif
-#elif defined(__H8300H__) || defined(__H8300S__)
-#define SCIx_FNS(name, sh3_sci_offset, sh3_sci_size, sh4_sci_offset, sh4_sci_size, \
-                 sh3_scif_offset, sh3_scif_size, sh4_scif_offset, sh4_scif_size, \
-                 h8_sci_offset, h8_sci_size) \
-  CPU_SCI_FNS(name, h8_sci_offset, h8_sci_size)
-#define SCIF_FNS(name, sh3_scif_offset, sh3_scif_size, sh4_scif_offset, sh4_scif_size) \
-  CPU_SCIF_FNS(name)
-#elif defined(CONFIG_CPU_SUBTYPE_SH7723) ||\
-      defined(CONFIG_CPU_SUBTYPE_SH7724)
-        #define SCIx_FNS(name, sh4_scifa_offset, sh4_scifa_size, sh4_scif_offset, sh4_scif_size) \
-                CPU_SCIx_FNS(name, sh4_scifa_offset, sh4_scifa_size, sh4_scif_offset, sh4_scif_size)
-        #define SCIF_FNS(name, sh4_scif_offset, sh4_scif_size) \
-                CPU_SCIF_FNS(name, sh4_scif_offset, sh4_scif_size)
-#else
-#define SCIx_FNS(name, sh3_sci_offset, sh3_sci_size, sh4_sci_offset, sh4_sci_size, \
-                 sh3_scif_offset, sh3_scif_size, sh4_scif_offset, sh4_scif_size, \
-                 h8_sci_offset, h8_sci_size) \
-  CPU_SCIx_FNS(name, sh4_sci_offset, sh4_sci_size, sh4_scif_offset, sh4_scif_size)
-#define SCIF_FNS(name, sh3_scif_offset, sh3_scif_size, sh4_scif_offset, sh4_scif_size) \
-  CPU_SCIF_FNS(name, sh4_scif_offset, sh4_scif_size)
-#endif
-
-#if defined(CONFIG_CPU_SUBTYPE_SH7705) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7720) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7721) || \
-    defined(CONFIG_ARCH_SH7367)
-
-SCIF_FNS(SCSMR,  0x00, 16)
-SCIF_FNS(SCBRR,  0x04,  8)
-SCIF_FNS(SCSCR,  0x08, 16)
-SCIF_FNS(SCxSR,  0x14, 16)
-SCIF_FNS(SCFCR,  0x18, 16)
-SCIF_FNS(SCFDR,  0x1c, 16)
-SCIF_FNS(SCxTDR, 0x20,  8)
-SCIF_FNS(SCxRDR, 0x24,  8)
-SCIF_FNS(SCLSR,  0x00,  0)
-#elif defined(CONFIG_ARCH_SH7377) || \
-      defined(CONFIG_ARCH_SH7372) || \
-      defined(CONFIG_ARCH_SH73A0)
-SCIF_FNS(SCSMR,  0x00, 16)
-SCIF_FNS(SCBRR,  0x04,  8)
-SCIF_FNS(SCSCR,  0x08, 16)
-SCIF_FNS(SCTDSR, 0x0c, 16)
-SCIF_FNS(SCFER,  0x10, 16)
-SCIF_FNS(SCxSR,  0x14, 16)
-SCIF_FNS(SCFCR,  0x18, 16)
-SCIF_FNS(SCFDR,  0x1c, 16)
-SCIF_FNS(SCTFDR, 0x38, 16)
-SCIF_FNS(SCRFDR, 0x3c, 16)
-SCIx_FNS(SCxTDR, 0x20,  8, 0x40,  8)
-SCIx_FNS(SCxRDR, 0x24,  8, 0x60,  8)
-SCIF_FNS(SCLSR,  0x00,  0)
-#elif defined(CONFIG_CPU_SUBTYPE_SH7723) ||\
-      defined(CONFIG_CPU_SUBTYPE_SH7724)
-SCIx_FNS(SCSMR,  0x00, 16, 0x00, 16)
-SCIx_FNS(SCBRR,  0x04,  8, 0x04,  8)
-SCIx_FNS(SCSCR,  0x08, 16, 0x08, 16)
-SCIx_FNS(SCxTDR, 0x20,  8, 0x0c,  8)
-SCIx_FNS(SCxSR,  0x14, 16, 0x10, 16)
-SCIx_FNS(SCxRDR, 0x24,  8, 0x14,  8)
-SCIx_FNS(SCSPTR, 0,     0,    0,  0)
-SCIF_FNS(SCFCR,  0x18, 16)
-SCIF_FNS(SCFDR,  0x1c, 16)
-SCIF_FNS(SCLSR,  0x24, 16)
-#else
-/*      reg      SCI/SH3   SCI/SH4  SCIF/SH3   SCIF/SH4  SCI/H8*/
-/*      name     off  sz   off  sz   off  sz   off  sz   off  sz*/
-SCIx_FNS(SCSMR,  0x00,  8, 0x00,  8, 0x00,  8, 0x00, 16, 0x00,  8)
-SCIx_FNS(SCBRR,  0x02,  8, 0x04,  8, 0x02,  8, 0x04,  8, 0x01,  8)
-SCIx_FNS(SCSCR,  0x04,  8, 0x08,  8, 0x04,  8, 0x08, 16, 0x02,  8)
-SCIx_FNS(SCxTDR, 0x06,  8, 0x0c,  8, 0x06,  8, 0x0C,  8, 0x03,  8)
-SCIx_FNS(SCxSR,  0x08,  8, 0x10,  8, 0x08, 16, 0x10, 16, 0x04,  8)
-SCIx_FNS(SCxRDR, 0x0a,  8, 0x14,  8, 0x0A,  8, 0x14,  8, 0x05,  8)
-SCIF_FNS(SCFCR,                      0x0c,  8, 0x18, 16)
-#if defined(CONFIG_CPU_SUBTYPE_SH7760) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7780) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7785) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7786)
-SCIF_FNS(SCFDR,                      0x0e, 16, 0x1C, 16)
-SCIF_FNS(SCTFDR,                     0x0e, 16, 0x1C, 16)
-SCIF_FNS(SCRFDR,                     0x0e, 16, 0x20, 16)
-SCIF_FNS(SCSPTR,                        0,  0, 0x24, 16)
-SCIF_FNS(SCLSR,                         0,  0, 0x28, 16)
-#elif defined(CONFIG_CPU_SUBTYPE_SH7763)
-SCIF_FNS(SCFDR,                         0,  0, 0x1C, 16)
-SCIF_FNS(SCTFDR,                     0x0e, 16, 0x1C, 16)
-SCIF_FNS(SCRFDR,                     0x0e, 16, 0x20, 16)
-SCIF_FNS(SCSPTR,                        0,  0, 0x24, 16)
-SCIF_FNS(SCLSR,                         0,  0, 0x28, 16)
-#else
-SCIF_FNS(SCFDR,                      0x0e, 16, 0x1C, 16)
-#if defined(CONFIG_CPU_SUBTYPE_SH7722)
-SCIF_FNS(SCSPTR,                        0,  0, 0, 0)
-#else
-SCIF_FNS(SCSPTR,                        0,  0, 0x20, 16)
-#endif
-SCIF_FNS(SCLSR,                         0,  0, 0x24, 16)
-#endif
-#endif
-#define sci_in(port, reg) sci_##reg##_in(port)
-#define sci_out(port, reg, value) sci_##reg##_out(port, value)
-
-/* H8/300 series SCI pins assignment */
-#if defined(__H8300H__) || defined(__H8300S__)
-static const struct __attribute__((packed)) {
-        int port;             /* GPIO port no */
-        unsigned short rx,tx; /* GPIO bit no */
-} h8300_sci_pins[] = {
-#if defined(CONFIG_H83007) || defined(CONFIG_H83068)
-        {    /* SCI0 */
-                .port = H8300_GPIO_P9,
-                .rx   = H8300_GPIO_B2,
-                .tx   = H8300_GPIO_B0,
-        },
-        {    /* SCI1 */
-                .port = H8300_GPIO_P9,
-                .rx   = H8300_GPIO_B3,
-                .tx   = H8300_GPIO_B1,
-        },
-        {    /* SCI2 */
-                .port = H8300_GPIO_PB,
-                .rx   = H8300_GPIO_B7,
-                .tx   = H8300_GPIO_B6,
-        }
-#elif defined(CONFIG_H8S2678)
-        {    /* SCI0 */
-                .port = H8300_GPIO_P3,
-                .rx   = H8300_GPIO_B2,
-                .tx   = H8300_GPIO_B0,
-        },
-        {    /* SCI1 */
-                .port = H8300_GPIO_P3,
-                .rx   = H8300_GPIO_B3,
-                .tx   = H8300_GPIO_B1,
-        },
-        {    /* SCI2 */
-                .port = H8300_GPIO_P5,
-                .rx   = H8300_GPIO_B1,
-                .tx   = H8300_GPIO_B0,
-        }
-#endif
-};
-#endif
-
-#if defined(CONFIG_CPU_SUBTYPE_SH7706) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7707) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7708) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7709)
-static inline int sci_rxd_in(struct uart_port *port)
-{
-        if (port->mapbase == 0xfffffe80)
-                return __raw_readb(SCPDR)&0x01 ? 1 : 0; /* SCI */
-        return 1;
-}
-#elif defined(CONFIG_CPU_SUBTYPE_SH7750)  || \
-      defined(CONFIG_CPU_SUBTYPE_SH7751)  || \
-      defined(CONFIG_CPU_SUBTYPE_SH7751R) || \
-      defined(CONFIG_CPU_SUBTYPE_SH7750R) || \
-      defined(CONFIG_CPU_SUBTYPE_SH7750S) || \
-      defined(CONFIG_CPU_SUBTYPE_SH7091)
-static inline int sci_rxd_in(struct uart_port *port)
-{
-        if (port->mapbase == 0xffe00000)
-                return __raw_readb(SCSPTR1)&0x01 ? 1 : 0; /* SCI */
-        return 1;
-}
-#elif defined(__H8300H__) || defined(__H8300S__)
-static inline int sci_rxd_in(struct uart_port *port)
-{
-        int ch = (port->mapbase - SMR0) >> 3;
-        return (H8300_SCI_DR(ch) & h8300_sci_pins[ch].rx) ? 1 : 0;
-}
-#else /* default case for non-SCI processors */
-static inline int sci_rxd_in(struct uart_port *port)
-{
-        return 1;
-}
-#endif
diff --git a/drivers/tty/serial/ucc_uart.c b/drivers/tty/serial/ucc_uart.c
index c327218cad44..9af9f0879a24 100644
--- a/drivers/tty/serial/ucc_uart.c
+++ b/drivers/tty/serial/ucc_uart.c
@@ -235,7 +235,7 @@ static inline void *qe2cpu_addr(dma_addr_t addr, struct uart_qe_port *qe_port)
                 return qe_port->bd_virt + (addr - qe_port->bd_dma_addr);
 
         /* something nasty happened */
-        printk(KERN_ERR "%s: addr=%x\n", __func__, addr);
+        printk(KERN_ERR "%s: addr=%llx\n", __func__, (u64)addr);
         BUG();
         return NULL;
 }
diff --git a/drivers/tty/tty_io.c b/drivers/tty/tty_io.c
index 150e4f747c7d..4f1fc81112e6 100644
--- a/drivers/tty/tty_io.c
+++ b/drivers/tty/tty_io.c
@@ -1295,8 +1295,7 @@ static int tty_driver_install_tty(struct tty_driver *driver,
  *
  *      Locking: tty_mutex for now
  */
-static void tty_driver_remove_tty(struct tty_driver *driver,
-                                                struct tty_struct *tty)
+void tty_driver_remove_tty(struct tty_driver *driver, struct tty_struct *tty)
 {
         if (driver->ops->remove)
                 driver->ops->remove(driver, tty);
diff --git a/drivers/usb/class/usbtmc.c b/drivers/usb/class/usbtmc.c
index 385acb895ab3..3f94ac34dce3 100644
--- a/drivers/usb/class/usbtmc.c
+++ b/drivers/usb/class/usbtmc.c
@@ -268,7 +268,7 @@ usbtmc_abort_bulk_in_status:
                                 dev_err(dev, "usb_bulk_msg returned %d\n", rv);
                                 goto exit;
                         }
-                } while ((actual = max_size) &&
+                } while ((actual == max_size) &&
                          (n < USBTMC_MAX_READS_TO_CLEAR_BULK_IN));
 
         if (actual == max_size) {
diff --git a/drivers/usb/core/config.c b/drivers/usb/core/config.c
index c962608b4b9a..26678cadfb21 100644
--- a/drivers/usb/core/config.c
+++ b/drivers/usb/core/config.c
@@ -123,10 +123,11 @@ static void usb_parse_ss_endpoint_companion(struct device *ddev, int cfgno,
         }
 
         if (usb_endpoint_xfer_isoc(&ep->desc))
-                max_tx = ep->desc.wMaxPacketSize * (desc->bMaxBurst + 1) *
-                        (desc->bmAttributes + 1);
+                max_tx = (desc->bMaxBurst + 1) * (desc->bmAttributes + 1) *
+                        le16_to_cpu(ep->desc.wMaxPacketSize);
         else if (usb_endpoint_xfer_int(&ep->desc))
-                max_tx = ep->desc.wMaxPacketSize * (desc->bMaxBurst + 1);
+                max_tx = le16_to_cpu(ep->desc.wMaxPacketSize) *
+                        (desc->bMaxBurst + 1);
         else
                 max_tx = 999999;
         if (le16_to_cpu(desc->wBytesPerInterval) > max_tx) {
@@ -134,10 +135,10 @@ static void usb_parse_ss_endpoint_companion(struct device *ddev, int cfgno,
                                 "config %d interface %d altsetting %d ep %d: "
                                 "setting to %d\n",
                                 usb_endpoint_xfer_isoc(&ep->desc) ? "Isoc" : "Int",
-                                desc->wBytesPerInterval,
+                                le16_to_cpu(desc->wBytesPerInterval),
                                 cfgno, inum, asnum, ep->desc.bEndpointAddress,
                                 max_tx);
-                ep->ss_ep_comp.wBytesPerInterval = max_tx;
+                ep->ss_ep_comp.wBytesPerInterval = cpu_to_le16(max_tx);
         }
 }
 
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index 8669ba3fe794..73cbbd85219f 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -1775,6 +1775,8 @@ int usb_hcd_alloc_bandwidth(struct usb_device *udev,
                 struct usb_interface *iface = usb_ifnum_to_if(udev,
                                 cur_alt->desc.bInterfaceNumber);
 
+                if (!iface)
+                        return -EINVAL;
                 if (iface->resetting_device) {
                         /*
                          * The USB core just reset the device, so the xHCI host
diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
index 44b6b40aafb4..5a084b9cfa3c 100644
--- a/drivers/usb/gadget/Kconfig
+++ b/drivers/usb/gadget/Kconfig
@@ -310,7 +310,7 @@ config USB_PXA_U2O
 # musb builds in ../musb along with host support
 config USB_GADGET_MUSB_HDRC
         tristate "Inventra HDRC USB Peripheral (TI, ADI, ...)"
-        depends on USB_MUSB_HDRC && (USB_MUSB_PERIPHERAL || USB_MUSB_OTG)
+        depends on USB_MUSB_HDRC
         select USB_GADGET_DUALSPEED
         help
           This OTG-capable silicon IP is used in dual designs including
diff --git a/drivers/usb/gadget/at91_udc.c b/drivers/usb/gadget/at91_udc.c
index 98cbc06c30fd..ddb118a76807 100644
--- a/drivers/usb/gadget/at91_udc.c
+++ b/drivers/usb/gadget/at91_udc.c
@@ -35,6 +35,7 @@
 #include <linux/list.h>
 #include <linux/interrupt.h>
 #include <linux/proc_fs.h>
+#include <linux/prefetch.h>
 #include <linux/clk.h>
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
diff --git a/drivers/usb/gadget/composite.c b/drivers/usb/gadget/composite.c
index 5ef87794fd32..aef47414f5d5 100644
--- a/drivers/usb/gadget/composite.c
+++ b/drivers/usb/gadget/composite.c
@@ -1079,10 +1079,12 @@ composite_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
                         cdev->desc.bMaxPacketSize0 =
                                 cdev->gadget->ep0->maxpacket;
                         if (gadget_is_superspeed(gadget)) {
-                                if (gadget->speed >= USB_SPEED_SUPER)
+                                if (gadget->speed >= USB_SPEED_SUPER) {
                                         cdev->desc.bcdUSB = cpu_to_le16(0x0300);
-                                else
+                                        cdev->desc.bMaxPacketSize0 = 9;
+                                } else {
                                         cdev->desc.bcdUSB = cpu_to_le16(0x0210);
+                                }
                         }
 
                         value = min(w_length, (u16) sizeof cdev->desc);
diff --git a/drivers/usb/gadget/f_hid.c b/drivers/usb/gadget/f_hid.c
index 403a48bcf560..83a266bdb40e 100644
--- a/drivers/usb/gadget/f_hid.c
+++ b/drivers/usb/gadget/f_hid.c
@@ -367,6 +367,13 @@ static int hidg_setup(struct usb_function *f,
         case ((USB_DIR_IN | USB_TYPE_STANDARD | USB_RECIP_INTERFACE) << 8
                   | USB_REQ_GET_DESCRIPTOR):
                 switch (value >> 8) {
+                case HID_DT_HID:
+                        VDBG(cdev, "USB_REQ_GET_DESCRIPTOR: HID\n");
+                        length = min_t(unsigned short, length,
+                                                   hidg_desc.bLength);
+                        memcpy(req->buf, &hidg_desc, length);
+                        goto respond;
+                        break;
                 case HID_DT_REPORT:
                         VDBG(cdev, "USB_REQ_GET_DESCRIPTOR: REPORT\n");
                         length = min_t(unsigned short, length,
diff --git a/drivers/usb/gadget/f_phonet.c b/drivers/usb/gadget/f_phonet.c
index 8f8d3f6cd89e..8f3eab1af885 100644
--- a/drivers/usb/gadget/f_phonet.c
+++ b/drivers/usb/gadget/f_phonet.c
@@ -434,6 +434,7 @@ static int pn_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
                             config_ep_by_speed(gadget, f, fp->out_ep)) {
                                 fp->in_ep->desc = NULL;
                                 fp->out_ep->desc = NULL;
+                                spin_unlock(&port->lock);
                                 return -EINVAL;
                         }
                         usb_ep_enable(fp->out_ep);
diff --git a/drivers/usb/gadget/fusb300_udc.c b/drivers/usb/gadget/fusb300_udc.c
index 24a924330c81..4ec888f90002 100644
--- a/drivers/usb/gadget/fusb300_udc.c
+++ b/drivers/usb/gadget/fusb300_udc.c
@@ -609,107 +609,6 @@ void fusb300_rdcxf(struct fusb300 *fusb300,
         }
 }
 
-#if 0
-static void fusb300_dbg_fifo(struct fusb300_ep *ep,
-                                u8 entry, u16 length)
-{
-        u32 reg;
-        u32 i = 0;
-        u32 j = 0;
-
-        reg = ioread32(ep->fusb300->reg + FUSB300_OFFSET_GTM);
-        reg &= ~(FUSB300_GTM_TST_EP_ENTRY(0xF) |
-                FUSB300_GTM_TST_EP_NUM(0xF) | FUSB300_GTM_TST_FIFO_DEG);
-        reg |= (FUSB300_GTM_TST_EP_ENTRY(entry) |
-                FUSB300_GTM_TST_EP_NUM(ep->epnum) | FUSB300_GTM_TST_FIFO_DEG);
-        iowrite32(reg, ep->fusb300->reg + FUSB300_OFFSET_GTM);
-
-        for (i = 0; i < (length >> 2); i++) {
-                if (i * 4 == 1024)
-                        break;
-                reg = ioread32(ep->fusb300->reg +
-                        FUSB300_OFFSET_BUFDBG_START + i * 4);
-                printk(KERN_DEBUG"  0x%-8x", reg);
-                j++;
-                if ((j % 4)  == 0)
-                        printk(KERN_DEBUG "\n");
-        }
-
-        if (length % 4) {
-                reg = ioread32(ep->fusb300->reg +
-                        FUSB300_OFFSET_BUFDBG_START + i * 4);
-                printk(KERN_DEBUG "  0x%x\n", reg);
-        }
-
-        if ((j % 4)  != 0)
-                printk(KERN_DEBUG "\n");
-
-        fusb300_disable_bit(ep->fusb300, FUSB300_OFFSET_GTM,
-                FUSB300_GTM_TST_FIFO_DEG);
-}
-
-static void fusb300_cmp_dbg_fifo(struct fusb300_ep *ep,
-                                u8 entry, u16 length, u8 *golden)
-{
-        u32 reg;
-        u32 i = 0;
-        u32 golden_value;
-        u8 *tmp;
-
-        tmp = golden;
-
-        printk(KERN_DEBUG "fusb300_cmp_dbg_fifo (entry %d) : start\n", entry);
-
-        reg = ioread32(ep->fusb300->reg + FUSB300_OFFSET_GTM);
-        reg &= ~(FUSB300_GTM_TST_EP_ENTRY(0xF) |
-                FUSB300_GTM_TST_EP_NUM(0xF) | FUSB300_GTM_TST_FIFO_DEG);
-        reg |= (FUSB300_GTM_TST_EP_ENTRY(entry) |
-                FUSB300_GTM_TST_EP_NUM(ep->epnum) | FUSB300_GTM_TST_FIFO_DEG);
-        iowrite32(reg, ep->fusb300->reg + FUSB300_OFFSET_GTM);
-
-        for (i = 0; i < (length >> 2); i++) {
-                if (i * 4 == 1024)
-                        break;
-                golden_value = *tmp | *(tmp + 1) << 8 |
-                                *(tmp + 2) << 16 | *(tmp + 3) << 24;
-
-                reg = ioread32(ep->fusb300->reg +
-                        FUSB300_OFFSET_BUFDBG_START + i*4);
-
-                if (reg != golden_value) {
-                        printk(KERN_DEBUG "0x%x  :  ", (u32)(ep->fusb300->reg +
-                                FUSB300_OFFSET_BUFDBG_START + i*4));
-                        printk(KERN_DEBUG "    golden = 0x%x, reg = 0x%x\n",
-                                golden_value, reg);
-                }
-                tmp += 4;
-        }
-
-        switch (length % 4) {
-        case 1:
-                golden_value = *tmp;
-        case 2:
-                golden_value = *tmp | *(tmp + 1) << 8;
-        case 3:
-                golden_value = *tmp | *(tmp + 1) << 8 | *(tmp + 2) << 16;
-        default:
-                break;
-
-        reg = ioread32(ep->fusb300->reg + FUSB300_OFFSET_BUFDBG_START + i*4);
-        if (reg != golden_value) {
-                printk(KERN_DEBUG "0x%x:", (u32)(ep->fusb300->reg +
-                        FUSB300_OFFSET_BUFDBG_START + i*4));
-                printk(KERN_DEBUG "  golden = 0x%x, reg = 0x%x\n",
-                        golden_value, reg);
-        }
-        }
-
-        printk(KERN_DEBUG "fusb300_cmp_dbg_fifo : end\n");
-        fusb300_disable_bit(ep->fusb300, FUSB300_OFFSET_GTM,
-                FUSB300_GTM_TST_FIFO_DEG);
-}
-#endif
-
 static void fusb300_rdfifo(struct fusb300_ep *ep,
                           struct fusb300_request *req,
                           u32 length)
diff --git a/drivers/usb/gadget/net2272.c b/drivers/usb/gadget/net2272.c
index 7c7b0e120d88..ab98ea926a11 100644
--- a/drivers/usb/gadget/net2272.c
+++ b/drivers/usb/gadget/net2272.c
@@ -27,13 +27,13 @@
 #include <linux/interrupt.h>
 #include <linux/io.h>
 #include <linux/ioport.h>
-#include <linux/irq.h>
 #include <linux/kernel.h>
 #include <linux/list.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/pci.h>
 #include <linux/platform_device.h>
+#include <linux/prefetch.h>
 #include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/timer.h>
diff --git a/drivers/usb/gadget/s3c2410_udc.c b/drivers/usb/gadget/s3c2410_udc.c
index 85c1b0d66293..8d31848aab09 100644
--- a/drivers/usb/gadget/s3c2410_udc.c
+++ b/drivers/usb/gadget/s3c2410_udc.c
@@ -2060,6 +2060,7 @@ static int s3c2410_udc_resume(struct platform_device *pdev)
 static const struct platform_device_id s3c_udc_ids[] = {
         { "s3c2410-usbgadget", },
         { "s3c2440-usbgadget", },
+        { }
 };
 MODULE_DEVICE_TABLE(platform, s3c_udc_ids);
 
diff --git a/drivers/usb/host/ehci-hub.c b/drivers/usb/host/ehci-hub.c
index bf2c8f65e1ae..4c32cb19b405 100644
--- a/drivers/usb/host/ehci-hub.c
+++ b/drivers/usb/host/ehci-hub.c
@@ -343,7 +343,7 @@ static int ehci_bus_resume (struct usb_hcd *hcd)
         u32                     temp;
         u32                     power_okay;
         int                     i;
-        u8                      resume_needed = 0;
+        unsigned long           resume_needed = 0;
 
         if (time_before (jiffies, ehci->next_statechange))
                 msleep(5);
@@ -416,7 +416,7 @@ static int ehci_bus_resume (struct usb_hcd *hcd)
                 if (test_bit(i, &ehci->bus_suspended) &&
                                 (temp & PORT_SUSPEND)) {
                         temp |= PORT_RESUME;
-                        resume_needed = 1;
+                        set_bit(i, &resume_needed);
                 }
                 ehci_writel(ehci, temp, &ehci->regs->port_status [i]);
         }
@@ -431,8 +431,7 @@ static int ehci_bus_resume (struct usb_hcd *hcd)
         i = HCS_N_PORTS (ehci->hcs_params);
         while (i--) {
                 temp = ehci_readl(ehci, &ehci->regs->port_status [i]);
-                if (test_bit(i, &ehci->bus_suspended) &&
-                                (temp & PORT_SUSPEND)) {
+                if (test_bit(i, &resume_needed)) {
                         temp &= ~(PORT_RWC_BITS | PORT_RESUME);
                         ehci_writel(ehci, temp, &ehci->regs->port_status [i]);
                         ehci_vdbg (ehci, "resumed port %d\n", i + 1);
@@ -1046,7 +1045,19 @@ static int ehci_hub_control (
                         if (!selector || selector > 5)
                                 goto error;
                         ehci_quiesce(ehci);
+
+                        /* Put all enabled ports into suspend */
+                        while (ports--) {
+                                u32 __iomem *sreg =
+                                                &ehci->regs->port_status[ports];
+
+                                temp = ehci_readl(ehci, sreg) & ~PORT_RWC_BITS;
+                                if (temp & PORT_PE)
+                                        ehci_writel(ehci, temp | PORT_SUSPEND,
+                                                        sreg);
+                        }
                         ehci_halt(ehci);
+                        temp = ehci_readl(ehci, status_reg);
                         temp |= selector << 16;
                         ehci_writel(ehci, temp, status_reg);
                         break;
diff --git a/drivers/usb/host/ehci-mxc.c b/drivers/usb/host/ehci-mxc.c
index 0c058be35a38..555a73c864b5 100644
--- a/drivers/usb/host/ehci-mxc.c
+++ b/drivers/usb/host/ehci-mxc.c
@@ -24,6 +24,7 @@
 #include <linux/usb/ulpi.h>
 #include <linux/slab.h>
 
+#include <mach/hardware.h>
 #include <mach/mxc_ehci.h>
 
 #include <asm/mach-types.h>
diff --git a/drivers/usb/host/ehci-omap.c b/drivers/usb/host/ehci-omap.c
index 55a57c23dd0f..45240321ca09 100644
--- a/drivers/usb/host/ehci-omap.c
+++ b/drivers/usb/host/ehci-omap.c
@@ -98,6 +98,18 @@ static void omap_ehci_soft_phy_reset(struct platform_device *pdev, u8 port)
         }
 }
 
+static void disable_put_regulator(
+                struct ehci_hcd_omap_platform_data *pdata)
+{
+        int i;
+
+        for (i = 0 ; i < OMAP3_HS_USB_PORTS ; i++) {
+                if (pdata->regulator[i]) {
+                        regulator_disable(pdata->regulator[i]);
+                        regulator_put(pdata->regulator[i]);
+                }
+        }
+}
 
 /* configure so an HC device and id are always provided */
 /* always called with process context; sleeping is OK */
@@ -231,9 +243,11 @@ err_add_hcd:
         omap_usbhs_disable(dev);
 
 err_enable:
+        disable_put_regulator(pdata);
         usb_put_hcd(hcd);
 
 err_io:
+        iounmap(regs);
         return ret;
 }
 
@@ -253,6 +267,8 @@ static int ehci_hcd_omap_remove(struct platform_device *pdev)
 
         usb_remove_hcd(hcd);
         omap_usbhs_disable(dev);
+        disable_put_regulator(dev->platform_data);
+        iounmap(hcd->regs);
         usb_put_hcd(hcd);
         return 0;
 }
diff --git a/drivers/usb/host/ehci-s5p.c b/drivers/usb/host/ehci-s5p.c
index b3958b3d3163..9e77f1c8bdbd 100644
--- a/drivers/usb/host/ehci-s5p.c
+++ b/drivers/usb/host/ehci-s5p.c
@@ -86,6 +86,7 @@ static int __devinit s5p_ehci_probe(struct platform_device *pdev)
                 goto fail_hcd;
         }
 
+        s5p_ehci->hcd = hcd;
         s5p_ehci->clk = clk_get(&pdev->dev, "usbhost");
 
         if (IS_ERR(s5p_ehci->clk)) {
diff --git a/drivers/usb/host/isp1760-hcd.c b/drivers/usb/host/isp1760-hcd.c
index 55d3d5859ac5..840beda66dd9 100644
--- a/drivers/usb/host/isp1760-hcd.c
+++ b/drivers/usb/host/isp1760-hcd.c
@@ -1583,6 +1583,9 @@ static int isp1760_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
         int retval = 0;
 
         spin_lock_irqsave(&priv->lock, spinflags);
+        retval = usb_hcd_check_unlink_urb(hcd, urb, status);
+        if (retval)
+                goto out;
 
         qh = urb->ep->hcpriv;
         if (!qh) {
diff --git a/drivers/usb/host/pci-quirks.c b/drivers/usb/host/pci-quirks.c
index a9d315906e3d..629a96813fd6 100644
--- a/drivers/usb/host/pci-quirks.c
+++ b/drivers/usb/host/pci-quirks.c
@@ -535,7 +535,7 @@ static void __devinit quirk_usb_handoff_ohci(struct pci_dev *pdev)
         iounmap(base);
 }
 
-static const struct dmi_system_id __initconst ehci_dmi_nohandoff_table[] = {
+static const struct dmi_system_id __devinitconst ehci_dmi_nohandoff_table[] = {
         {
                 /*  Pegatron Lucid (ExoPC) */
                 .matches = {
@@ -817,7 +817,7 @@ static void __devinit quirk_usb_handoff_xhci(struct pci_dev *pdev)
 
         /* If the BIOS owns the HC, signal that the OS wants it, and wait */
         if (val & XHCI_HC_BIOS_OWNED) {
-                writel(val & XHCI_HC_OS_OWNED, base + ext_cap_offset);
+                writel(val | XHCI_HC_OS_OWNED, base + ext_cap_offset);
 
                 /* Wait for 5 seconds with 10 microsecond polling interval */
                 timeout = handshake(base + ext_cap_offset, XHCI_HC_BIOS_OWNED,
diff --git a/drivers/usb/host/xhci-hub.c b/drivers/usb/host/xhci-hub.c
index 0be788cc2fdb..1e96d1f1fe6b 100644
--- a/drivers/usb/host/xhci-hub.c
+++ b/drivers/usb/host/xhci-hub.c
@@ -463,11 +463,12 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                                         && (temp & PORT_POWER))
                                 status |= USB_PORT_STAT_SUSPEND;
                 }
-                if ((temp & PORT_PLS_MASK) == XDEV_RESUME) {
+                if ((temp & PORT_PLS_MASK) == XDEV_RESUME &&
+                                !DEV_SUPERSPEED(temp)) {
                         if ((temp & PORT_RESET) || !(temp & PORT_PE))
                                 goto error;
-                        if (!DEV_SUPERSPEED(temp) && time_after_eq(jiffies,
-                                                bus_state->resume_done[wIndex])) {
+                        if (time_after_eq(jiffies,
+                                        bus_state->resume_done[wIndex])) {
                                 xhci_dbg(xhci, "Resume USB2 port %d\n",
                                         wIndex + 1);
                                 bus_state->resume_done[wIndex] = 0;
@@ -487,6 +488,14 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                                 xhci_ring_device(xhci, slot_id);
                                 bus_state->port_c_suspend |= 1 << wIndex;
                                 bus_state->suspended_ports &= ~(1 << wIndex);
+                        } else {
+                                /*
+                                 * The resume has been signaling for less than
+                                 * 20ms. Report the port status as SUSPEND,
+                                 * let the usbcore check port status again
+                                 * and clear resume signaling later.
+                                 */
+                                status |= USB_PORT_STAT_SUSPEND;
                         }
                 }
                 if ((temp & PORT_PLS_MASK) == XDEV_U0
@@ -664,7 +673,7 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                         xhci_dbg(xhci, "PORTSC %04x\n", temp);
                         if (temp & PORT_RESET)
                                 goto error;
-                        if (temp & XDEV_U3) {
+                        if ((temp & PORT_PLS_MASK) == XDEV_U3) {
                                 if ((temp & PORT_PE) == 0)
                                         goto error;
 
diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
index 7113d16e2d3a..54139a2f06ce 100644
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -514,8 +514,12 @@ void xhci_find_new_dequeue_state(struct xhci_hcd *xhci,
                         (unsigned long long) addr);
 }
 
+/* flip_cycle means flip the cycle bit of all but the first and last TRB.
+ * (The last TRB actually points to the ring enqueue pointer, which is not part
+ * of this TD.)  This is used to remove partially enqueued isoc TDs from a ring.
+ */
 static void td_to_noop(struct xhci_hcd *xhci, struct xhci_ring *ep_ring,
-                struct xhci_td *cur_td)
+                struct xhci_td *cur_td, bool flip_cycle)
 {
         struct xhci_segment *cur_seg;
         union xhci_trb *cur_trb;
@@ -528,6 +532,12 @@ static void td_to_noop(struct xhci_hcd *xhci, struct xhci_ring *ep_ring,
                          * leave the pointers intact.
                          */
                         cur_trb->generic.field[3] &= cpu_to_le32(~TRB_CHAIN);
+                        /* Flip the cycle bit (link TRBs can't be the first
+                         * or last TRB).
+                         */
+                        if (flip_cycle)
+                                cur_trb->generic.field[3] ^=
+                                        cpu_to_le32(TRB_CYCLE);
                         xhci_dbg(xhci, "Cancel (unchain) link TRB\n");
                         xhci_dbg(xhci, "Address = %p (0x%llx dma); "
                                         "in seg %p (0x%llx dma)\n",
@@ -541,6 +551,11 @@ static void td_to_noop(struct xhci_hcd *xhci, struct xhci_ring *ep_ring,
                         cur_trb->generic.field[2] = 0;
                         /* Preserve only the cycle bit of this TRB */
                         cur_trb->generic.field[3] &= cpu_to_le32(TRB_CYCLE);
+                        /* Flip the cycle bit except on the first or last TRB */
+                        if (flip_cycle && cur_trb != cur_td->first_trb &&
+                                        cur_trb != cur_td->last_trb)
+                                cur_trb->generic.field[3] ^=
+                                        cpu_to_le32(TRB_CYCLE);
                         cur_trb->generic.field[3] |= cpu_to_le32(
                                 TRB_TYPE(TRB_TR_NOOP));
                         xhci_dbg(xhci, "Cancel TRB %p (0x%llx dma) "
@@ -719,14 +734,14 @@ static void handle_stopped_endpoint(struct xhci_hcd *xhci,
                                         cur_td->urb->stream_id,
                                         cur_td, &deq_state);
                 else
-                        td_to_noop(xhci, ep_ring, cur_td);
+                        td_to_noop(xhci, ep_ring, cur_td, false);
 remove_finished_td:
                 /*
                  * The event handler won't see a completion for this TD anymore,
                  * so remove it from the endpoint ring's TD list.  Keep it in
                  * the cancelled TD list for URB completion later.
                  */
-                list_del(&cur_td->td_list);
+                list_del_init(&cur_td->td_list);
         }
         last_unlinked_td = cur_td;
         xhci_stop_watchdog_timer_in_irq(xhci, ep);
@@ -754,7 +769,7 @@ remove_finished_td:
         do {
                 cur_td = list_entry(ep->cancelled_td_list.next,
                                 struct xhci_td, cancelled_td_list);
-                list_del(&cur_td->cancelled_td_list);
+                list_del_init(&cur_td->cancelled_td_list);
 
                 /* Clean up the cancelled URB */
                 /* Doesn't matter what we pass for status, since the core will
@@ -862,9 +877,9 @@ void xhci_stop_endpoint_command_watchdog(unsigned long arg)
                                 cur_td = list_first_entry(&ring->td_list,
                                                 struct xhci_td,
                                                 td_list);
-                                list_del(&cur_td->td_list);
+                                list_del_init(&cur_td->td_list);
                                 if (!list_empty(&cur_td->cancelled_td_list))
-                                        list_del(&cur_td->cancelled_td_list);
+                                        list_del_init(&cur_td->cancelled_td_list);
                                 xhci_giveback_urb_in_irq(xhci, cur_td,
                                                 -ESHUTDOWN, "killed");
                         }
@@ -873,7 +888,7 @@ void xhci_stop_endpoint_command_watchdog(unsigned long arg)
                                                 &temp_ep->cancelled_td_list,
                                                 struct xhci_td,
                                                 cancelled_td_list);
-                                list_del(&cur_td->cancelled_td_list);
+                                list_del_init(&cur_td->cancelled_td_list);
                                 xhci_giveback_urb_in_irq(xhci, cur_td,
                                                 -ESHUTDOWN, "killed");
                         }
@@ -1565,10 +1580,10 @@ td_cleanup:
                         else
                                 *status = 0;
                 }
-                list_del(&td->td_list);
+                list_del_init(&td->td_list);
                 /* Was this TD slated to be cancelled but completed anyway? */
                 if (!list_empty(&td->cancelled_td_list))
-                        list_del(&td->cancelled_td_list);
+                        list_del_init(&td->cancelled_td_list);
 
                 urb_priv->td_cnt++;
                 /* Giveback the urb when all the tds are completed */
@@ -2500,11 +2515,8 @@ static int prepare_transfer(struct xhci_hcd *xhci,
 
         if (td_index == 0) {
                 ret = usb_hcd_link_urb_to_ep(bus_to_hcd(urb->dev->bus), urb);
-                if (unlikely(ret)) {
-                        xhci_urb_free_priv(xhci, urb_priv);
-                        urb->hcpriv = NULL;
+                if (unlikely(ret))
                         return ret;
-                }
         }
 
         td->urb = urb;
@@ -2672,6 +2684,10 @@ static u32 xhci_v1_0_td_remainder(int running_total, int trb_buff_len,
 {
         int packets_transferred;
 
+        /* One TRB with a zero-length data packet. */
+        if (running_total == 0 && trb_buff_len == 0)
+                return 0;
+
         /* All the TRB queueing functions don't count the current TRB in
          * running_total.
          */
@@ -3113,20 +3129,15 @@ static int count_isoc_trbs_needed(struct xhci_hcd *xhci,
                 struct urb *urb, int i)
 {
         int num_trbs = 0;
-        u64 addr, td_len, running_total;
+        u64 addr, td_len;
 
         addr = (u64) (urb->transfer_dma + urb->iso_frame_desc[i].offset);
         td_len = urb->iso_frame_desc[i].length;
 
-        running_total = TRB_MAX_BUFF_SIZE - (addr & (TRB_MAX_BUFF_SIZE - 1));
-        running_total &= TRB_MAX_BUFF_SIZE - 1;
-        if (running_total != 0)
-                num_trbs++;
-
-        while (running_total < td_len) {
+        num_trbs = DIV_ROUND_UP(td_len + (addr & (TRB_MAX_BUFF_SIZE - 1)),
+                        TRB_MAX_BUFF_SIZE);
+        if (num_trbs == 0)
                 num_trbs++;
-                running_total += TRB_MAX_BUFF_SIZE;
-        }
 
         return num_trbs;
 }
@@ -3226,6 +3237,7 @@ static int xhci_queue_isoc_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
         start_trb = &ep_ring->enqueue->generic;
         start_cycle = ep_ring->cycle_state;
 
+        urb_priv = urb->hcpriv;
         /* Queue the first TRB, even if it's zero-length */
         for (i = 0; i < num_tds; i++) {
                 unsigned int total_packet_count;
@@ -3237,9 +3249,11 @@ static int xhci_queue_isoc_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                 addr = start_addr + urb->iso_frame_desc[i].offset;
                 td_len = urb->iso_frame_desc[i].length;
                 td_remain_len = td_len;
-                /* FIXME: Ignoring zero-length packets, can those happen? */
                 total_packet_count = roundup(td_len,
                                 le16_to_cpu(urb->ep->desc.wMaxPacketSize));
+                /* A zero-length transfer still involves at least one packet. */
+                if (total_packet_count == 0)
+                        total_packet_count++;
                 burst_count = xhci_get_burst_count(xhci, urb->dev, urb,
                                 total_packet_count);
                 residue = xhci_get_last_burst_packet_count(xhci,
@@ -3249,12 +3263,13 @@ static int xhci_queue_isoc_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
 
                 ret = prepare_transfer(xhci, xhci->devs[slot_id], ep_index,
                                 urb->stream_id, trbs_per_td, urb, i, mem_flags);
-                if (ret < 0)
-                        return ret;
+                if (ret < 0) {
+                        if (i == 0)
+                                return ret;
+                        goto cleanup;
+                }
 
-                urb_priv = urb->hcpriv;
                 td = urb_priv->td[i];
-
                 for (j = 0; j < trbs_per_td; j++) {
                         u32 remainder = 0;
                         field = TRB_TBC(burst_count) | TRB_TLBPC(residue);
@@ -3344,6 +3359,27 @@ static int xhci_queue_isoc_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
         giveback_first_trb(xhci, slot_id, ep_index, urb->stream_id,
                         start_cycle, start_trb);
         return 0;
+cleanup:
+        /* Clean up a partially enqueued isoc transfer. */
+
+        for (i--; i >= 0; i--)
+                list_del_init(&urb_priv->td[i]->td_list);
+
+        /* Use the first TD as a temporary variable to turn the TDs we've queued
+         * into No-ops with a software-owned cycle bit. That way the hardware
+         * won't accidentally start executing bogus TDs when we partially
+         * overwrite them.  td->first_trb and td->start_seg are already set.
+         */
+        urb_priv->td[0]->last_trb = ep_ring->enqueue;
+        /* Every TRB except the first & last will have its cycle bit flipped. */
+        td_to_noop(xhci, ep_ring, urb_priv->td[0], true);
+
+        /* Reset the ring enqueue back to the first TRB and its cycle bit. */
+        ep_ring->enqueue = urb_priv->td[0]->first_trb;
+        ep_ring->enq_seg = urb_priv->td[0]->start_seg;
+        ep_ring->cycle_state = start_cycle;
+        usb_hcd_unlink_urb_from_ep(bus_to_hcd(urb->dev->bus), urb);
+        return ret;
 }
 
 /*
diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index 763f484bc092..3a0f695138f4 100644
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -345,7 +345,8 @@ static void xhci_event_ring_work(unsigned long arg)
         spin_lock_irqsave(&xhci->lock, flags);
         temp = xhci_readl(xhci, &xhci->op_regs->status);
         xhci_dbg(xhci, "op reg status = 0x%x\n", temp);
-        if (temp == 0xffffffff || (xhci->xhc_state & XHCI_STATE_DYING)) {
+        if (temp == 0xffffffff || (xhci->xhc_state & XHCI_STATE_DYING) ||
+                        (xhci->xhc_state & XHCI_STATE_HALTED)) {
                 xhci_dbg(xhci, "HW died, polling stopped.\n");
                 spin_unlock_irqrestore(&xhci->lock, flags);
                 return;
@@ -939,8 +940,11 @@ static int xhci_check_args(struct usb_hcd *hcd, struct usb_device *udev,
                 return 0;
         }
 
+        xhci = hcd_to_xhci(hcd);
+        if (xhci->xhc_state & XHCI_STATE_HALTED)
+                return -ENODEV;
+
         if (check_virt_dev) {
-                xhci = hcd_to_xhci(hcd);
                 if (!udev->slot_id || !xhci->devs
                         || !xhci->devs[udev->slot_id]) {
                         printk(KERN_DEBUG "xHCI %s called with unaddressed "
@@ -1081,8 +1085,11 @@ int xhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
                 if (urb->dev->speed == USB_SPEED_FULL) {
                         ret = xhci_check_maxpacket(xhci, slot_id,
                                         ep_index, urb);
-                        if (ret < 0)
+                        if (ret < 0) {
+                                xhci_urb_free_priv(xhci, urb_priv);
+                                urb->hcpriv = NULL;
                                 return ret;
+                        }
                 }
 
                 /* We have a spinlock and interrupts disabled, so we must pass
@@ -1093,6 +1100,8 @@ int xhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
                         goto dying;
                 ret = xhci_queue_ctrl_tx(xhci, GFP_ATOMIC, urb,
                                 slot_id, ep_index);
+                if (ret)
+                        goto free_priv;
                 spin_unlock_irqrestore(&xhci->lock, flags);
         } else if (usb_endpoint_xfer_bulk(&urb->ep->desc)) {
                 spin_lock_irqsave(&xhci->lock, flags);
@@ -1113,6 +1122,8 @@ int xhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
                         ret = xhci_queue_bulk_tx(xhci, GFP_ATOMIC, urb,
                                         slot_id, ep_index);
                 }
+                if (ret)
+                        goto free_priv;
                 spin_unlock_irqrestore(&xhci->lock, flags);
         } else if (usb_endpoint_xfer_int(&urb->ep->desc)) {
                 spin_lock_irqsave(&xhci->lock, flags);
@@ -1120,6 +1131,8 @@ int xhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
                         goto dying;
                 ret = xhci_queue_intr_tx(xhci, GFP_ATOMIC, urb,
                                 slot_id, ep_index);
+                if (ret)
+                        goto free_priv;
                 spin_unlock_irqrestore(&xhci->lock, flags);
         } else {
                 spin_lock_irqsave(&xhci->lock, flags);
@@ -1127,18 +1140,22 @@ int xhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
                         goto dying;
                 ret = xhci_queue_isoc_tx_prepare(xhci, GFP_ATOMIC, urb,
                                 slot_id, ep_index);
+                if (ret)
+                        goto free_priv;
                 spin_unlock_irqrestore(&xhci->lock, flags);
         }
 exit:
         return ret;
 dying:
-        xhci_urb_free_priv(xhci, urb_priv);
-        urb->hcpriv = NULL;
         xhci_dbg(xhci, "Ep 0x%x: URB %p submitted for "
                         "non-responsive xHCI host.\n",
                         urb->ep->desc.bEndpointAddress, urb);
+        ret = -ESHUTDOWN;
+free_priv:
+        xhci_urb_free_priv(xhci, urb_priv);
+        urb->hcpriv = NULL;
         spin_unlock_irqrestore(&xhci->lock, flags);
-        return -ESHUTDOWN;
+        return ret;
 }
 
 /* Get the right ring for the given URB.
@@ -1235,6 +1252,13 @@ int xhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
         if (temp == 0xffffffff || (xhci->xhc_state & XHCI_STATE_HALTED)) {
                 xhci_dbg(xhci, "HW died, freeing TD.\n");
                 urb_priv = urb->hcpriv;
+                for (i = urb_priv->td_cnt; i < urb_priv->length; i++) {
+                        td = urb_priv->td[i];
+                        if (!list_empty(&td->td_list))
+                                list_del_init(&td->td_list);
+                        if (!list_empty(&td->cancelled_td_list))
+                                list_del_init(&td->cancelled_td_list);
+                }
 
                 usb_hcd_unlink_urb_from_ep(hcd, urb);
                 spin_unlock_irqrestore(&xhci->lock, flags);
@@ -1242,7 +1266,8 @@ int xhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
                 xhci_urb_free_priv(xhci, urb_priv);
                 return ret;
         }
-        if (xhci->xhc_state & XHCI_STATE_DYING) {
+        if ((xhci->xhc_state & XHCI_STATE_DYING) ||
+                        (xhci->xhc_state & XHCI_STATE_HALTED)) {
                 xhci_dbg(xhci, "Ep 0x%x: URB %p to be canceled on "
                                 "non-responsive xHCI host.\n",
                                 urb->ep->desc.bEndpointAddress, urb);
@@ -2665,7 +2690,10 @@ void xhci_free_dev(struct usb_hcd *hcd, struct usb_device *udev)
         int i, ret;
 
         ret = xhci_check_args(hcd, udev, NULL, 0, true, __func__);
-        if (ret <= 0)
+        /* If the host is halted due to driver unload, we still need to free the
+         * device.
+         */
+        if (ret <= 0 && ret != -ENODEV)
                 return;
 
         virt_dev = xhci->devs[udev->slot_id];
@@ -2679,7 +2707,8 @@ void xhci_free_dev(struct usb_hcd *hcd, struct usb_device *udev)
         spin_lock_irqsave(&xhci->lock, flags);
         /* Don't disable the slot if the host controller is dead. */
         state = xhci_readl(xhci, &xhci->op_regs->status);
-        if (state == 0xffffffff || (xhci->xhc_state & XHCI_STATE_DYING)) {
+        if (state == 0xffffffff || (xhci->xhc_state & XHCI_STATE_DYING) ||
+                        (xhci->xhc_state & XHCI_STATE_HALTED)) {
                 xhci_free_virt_device(xhci, udev->slot_id);
                 spin_unlock_irqrestore(&xhci->lock, flags);
                 return;
diff --git a/drivers/usb/musb/Kconfig b/drivers/usb/musb/Kconfig
index 6192b45959f4..fc34b8b11910 100644
--- a/drivers/usb/musb/Kconfig
+++ b/drivers/usb/musb/Kconfig
@@ -3,9 +3,6 @@
 # for silicon based on Mentor Graphics INVENTRA designs
 #
 
-comment "Enable Host or Gadget support to see Inventra options"
-        depends on !USB && USB_GADGET=n
-
 # (M)HDRC = (Multipoint) Highspeed Dual-Role Controller
 config USB_MUSB_HDRC
         depends on USB && USB_GADGET
diff --git a/drivers/usb/musb/blackfin.c b/drivers/usb/musb/blackfin.c
index ae8c39617743..5e7cfba5b079 100644
--- a/drivers/usb/musb/blackfin.c
+++ b/drivers/usb/musb/blackfin.c
@@ -17,6 +17,7 @@
 #include <linux/io.h>
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
+#include <linux/prefetch.h>
 
 #include <asm/cacheflush.h>
 
diff --git a/drivers/usb/musb/cppi_dma.c b/drivers/usb/musb/cppi_dma.c
index 149f3f310a0a..318fb4e8a885 100644
--- a/drivers/usb/musb/cppi_dma.c
+++ b/drivers/usb/musb/cppi_dma.c
@@ -226,8 +226,10 @@ static int cppi_controller_stop(struct dma_controller *c)
         struct cppi             *controller;
         void __iomem            *tibase;
         int                     i;
+        struct musb             *musb;
 
         controller = container_of(c, struct cppi, controller);
+        musb = controller->musb;
 
         tibase = controller->tibase;
         /* DISABLE INDIVIDUAL CHANNEL Interrupts */
@@ -289,9 +291,11 @@ cppi_channel_allocate(struct dma_controller *c,
         u8                      index;
         struct cppi_channel     *cppi_ch;
         void __iomem            *tibase;
+        struct musb             *musb;
 
         controller = container_of(c, struct cppi, controller);
         tibase = controller->tibase;
+        musb = controller->musb;
 
         /* ep0 doesn't use DMA; remember cppi indices are 0..N-1 */
         index = ep->epnum - 1;
@@ -339,7 +343,8 @@ static void cppi_channel_release(struct dma_channel *channel)
         c = container_of(channel, struct cppi_channel, channel);
         tibase = c->controller->tibase;
         if (!c->hw_ep)
-                dev_dbg(musb->controller, "releasing idle DMA channel %p\n", c);
+                dev_dbg(c->controller->musb->controller,
+                        "releasing idle DMA channel %p\n", c);
         else if (!c->transmit)
                 core_rxirq_enable(tibase, c->index + 1);
 
@@ -357,10 +362,11 @@ cppi_dump_rx(int level, struct cppi_channel *c, const char *tag)
 
         musb_ep_select(base, c->index + 1);
 
-        DBG(level, "RX DMA%d%s: %d left, csr %04x, "
-                        "%08x H%08x S%08x C%08x, "
-                        "B%08x L%08x %08x .. %08x"
-                        "\n",
+        dev_dbg(c->controller->musb->controller,
+                "RX DMA%d%s: %d left, csr %04x, "
+                "%08x H%08x S%08x C%08x, "
+                "B%08x L%08x %08x .. %08x"
+                "\n",
                 c->index, tag,
                 musb_readl(c->controller->tibase,
                         DAVINCI_RXCPPI_BUFCNT0_REG + 4 * c->index),
@@ -387,10 +393,11 @@ cppi_dump_tx(int level, struct cppi_channel *c, const char *tag)
 
         musb_ep_select(base, c->index + 1);
 
-        DBG(level, "TX DMA%d%s: csr %04x, "
-                        "H%08x S%08x C%08x %08x, "
-                        "F%08x L%08x .. %08x"
-                        "\n",
+        dev_dbg(c->controller->musb->controller,
+                "TX DMA%d%s: csr %04x, "
+                "H%08x S%08x C%08x %08x, "
+                "F%08x L%08x .. %08x"
+                "\n",
                 c->index, tag,
                 musb_readw(c->hw_ep->regs, MUSB_TXCSR),
 
@@ -1022,6 +1029,7 @@ static bool cppi_rx_scan(struct cppi *cppi, unsigned ch)
         int                             i;
         dma_addr_t                      safe2ack;
         void __iomem                    *regs = rx->hw_ep->regs;
+        struct musb                     *musb = cppi->musb;
 
         cppi_dump_rx(6, rx, "/K");
 
diff --git a/drivers/usb/musb/musb_core.h b/drivers/usb/musb/musb_core.h
index 668eeef601ae..b3c065ab9dbc 100644
--- a/drivers/usb/musb/musb_core.h
+++ b/drivers/usb/musb/musb_core.h
@@ -172,7 +172,8 @@ enum musb_g_ep0_state {
 #endif
 
 /* TUSB mapping: "flat" plus ep0 special cases */
-#if     defined(CONFIG_USB_MUSB_TUSB6010)
+#if defined(CONFIG_USB_MUSB_TUSB6010) || \
+        defined(CONFIG_USB_MUSB_TUSB6010_MODULE)
 #define musb_ep_select(_mbase, _epnum) \
         musb_writeb((_mbase), MUSB_INDEX, (_epnum))
 #define MUSB_EP_OFFSET                  MUSB_TUSB_OFFSET
@@ -241,7 +242,8 @@ struct musb_hw_ep {
         void __iomem            *fifo;
         void __iomem            *regs;
 
-#ifdef CONFIG_USB_MUSB_TUSB6010
+#if defined(CONFIG_USB_MUSB_TUSB6010) || \
+        defined(CONFIG_USB_MUSB_TUSB6010_MODULE)
         void __iomem            *conf;
 #endif
 
@@ -258,7 +260,8 @@ struct musb_hw_ep {
         struct dma_channel      *tx_channel;
         struct dma_channel      *rx_channel;
 
-#ifdef CONFIG_USB_MUSB_TUSB6010
+#if defined(CONFIG_USB_MUSB_TUSB6010) || \
+        defined(CONFIG_USB_MUSB_TUSB6010_MODULE)
         /* TUSB has "asynchronous" and "synchronous" dma modes */
         dma_addr_t              fifo_async;
         dma_addr_t              fifo_sync;
@@ -356,7 +359,8 @@ struct musb {
         void __iomem            *ctrl_base;
         void __iomem            *mregs;
 
-#ifdef CONFIG_USB_MUSB_TUSB6010
+#if defined(CONFIG_USB_MUSB_TUSB6010) || \
+        defined(CONFIG_USB_MUSB_TUSB6010_MODULE)
         dma_addr_t              async;
         dma_addr_t              sync;
         void __iomem            *sync_va;
diff --git a/drivers/usb/musb/musb_gadget.c b/drivers/usb/musb/musb_gadget.c
index b67a062f556b..e81820370d6f 100644
--- a/drivers/usb/musb/musb_gadget.c
+++ b/drivers/usb/musb/musb_gadget.c
@@ -1698,6 +1698,8 @@ static int musb_gadget_pullup(struct usb_gadget *gadget, int is_on)
 
         is_on = !!is_on;
 
+        pm_runtime_get_sync(musb->controller);
+
         /* NOTE: this assumes we are sensing vbus; we'd rather
          * not pullup unless the B-session is active.
          */
@@ -1707,6 +1709,9 @@ static int musb_gadget_pullup(struct usb_gadget *gadget, int is_on)
                 musb_pullup(musb, is_on);
         }
         spin_unlock_irqrestore(&musb->lock, flags);
+
+        pm_runtime_put(musb->controller);
+
         return 0;
 }
 
@@ -1851,6 +1856,7 @@ int __init musb_gadget_setup(struct musb *musb)
 
         return 0;
 err:
+        musb->g.dev.parent = NULL;
         device_unregister(&musb->g.dev);
         return status;
 }
@@ -1858,7 +1864,8 @@ err:
 void musb_gadget_cleanup(struct musb *musb)
 {
         usb_del_gadget_udc(&musb->g);
-        device_unregister(&musb->g.dev);
+        if (musb->g.dev.parent)
+                device_unregister(&musb->g.dev);
 }
 
 /*
diff --git a/drivers/usb/musb/musb_regs.h b/drivers/usb/musb/musb_regs.h
index 82410703dcd3..03f2655af290 100644
--- a/drivers/usb/musb/musb_regs.h
+++ b/drivers/usb/musb/musb_regs.h
@@ -234,7 +234,8 @@
 #define MUSB_TESTMODE           0x0F    /* 8 bit */
 
 /* Get offset for a given FIFO from musb->mregs */
-#ifdef  CONFIG_USB_MUSB_TUSB6010
+#if defined(CONFIG_USB_MUSB_TUSB6010) ||        \
+        defined(CONFIG_USB_MUSB_TUSB6010_MODULE)
 #define MUSB_FIFO_OFFSET(epnum) (0x200 + ((epnum) * 0x20))
 #else
 #define MUSB_FIFO_OFFSET(epnum) (0x20 + ((epnum) * 4))
@@ -295,7 +296,8 @@
 #define MUSB_FLAT_OFFSET(_epnum, _offset)       \
         (0x100 + (0x10*(_epnum)) + (_offset))
 
-#ifdef CONFIG_USB_MUSB_TUSB6010
+#if defined(CONFIG_USB_MUSB_TUSB6010) ||        \
+        defined(CONFIG_USB_MUSB_TUSB6010_MODULE)
 /* TUSB6010 EP0 configuration register is special */
 #define MUSB_TUSB_OFFSET(_epnum, _offset)       \
         (0x10 + _offset)
diff --git a/drivers/usb/musb/tusb6010.c b/drivers/usb/musb/tusb6010.c
index 9eec41fbf3a4..ec1480191f78 100644
--- a/drivers/usb/musb/tusb6010.c
+++ b/drivers/usb/musb/tusb6010.c
@@ -18,6 +18,7 @@
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/init.h>
+#include <linux/prefetch.h>
 #include <linux/usb.h>
 #include <linux/irq.h>
 #include <linux/platform_device.h>
diff --git a/drivers/usb/musb/tusb6010_omap.c b/drivers/usb/musb/tusb6010_omap.c
index c784e6c03aac..b67b4bc596c1 100644
--- a/drivers/usb/musb/tusb6010_omap.c
+++ b/drivers/usb/musb/tusb6010_omap.c
@@ -20,6 +20,7 @@
 #include <plat/mux.h>
 
 #include "musb_core.h"
+#include "tusb6010.h"
 
 #define to_chdat(c)             ((struct tusb_omap_dma_ch *)(c)->private_data)
 
@@ -89,7 +90,7 @@ static inline int tusb_omap_use_shared_dmareq(struct tusb_omap_dma_ch *chdat)
         u32             reg = musb_readl(chdat->tbase, TUSB_DMA_EP_MAP);
 
         if (reg != 0) {
-                dev_dbg(musb->controller, "ep%i dmareq0 is busy for ep%i\n",
+                dev_dbg(chdat->musb->controller, "ep%i dmareq0 is busy for ep%i\n",
                         chdat->epnum, reg & 0xf);
                 return -EAGAIN;
         }
diff --git a/drivers/usb/musb/ux500_dma.c b/drivers/usb/musb/ux500_dma.c
index cecace411832..ef4333f4bbe0 100644
--- a/drivers/usb/musb/ux500_dma.c
+++ b/drivers/usb/musb/ux500_dma.c
@@ -65,7 +65,8 @@ static void ux500_tx_work(struct work_struct *data)
         struct musb *musb = hw_ep->musb;
         unsigned long flags;
 
-        DBG(4, "DMA tx transfer done on hw_ep=%d\n", hw_ep->epnum);
+        dev_dbg(musb->controller, "DMA tx transfer done on hw_ep=%d\n",
+                hw_ep->epnum);
 
         spin_lock_irqsave(&musb->lock, flags);
         ux500_channel->channel.actual_len = ux500_channel->cur_len;
@@ -84,7 +85,8 @@ static void ux500_rx_work(struct work_struct *data)
         struct musb *musb = hw_ep->musb;
         unsigned long flags;
 
-        DBG(4, "DMA rx transfer done on hw_ep=%d\n", hw_ep->epnum);
+        dev_dbg(musb->controller, "DMA rx transfer done on hw_ep=%d\n",
+                hw_ep->epnum);
 
         spin_lock_irqsave(&musb->lock, flags);
         ux500_channel->channel.actual_len = ux500_channel->cur_len;
@@ -116,9 +118,11 @@ static bool ux500_configure_channel(struct dma_channel *channel,
         enum dma_slave_buswidth addr_width;
         dma_addr_t usb_fifo_addr = (MUSB_FIFO_OFFSET(hw_ep->epnum) +
                                         ux500_channel->controller->phy_base);
+        struct musb *musb = ux500_channel->controller->private_data;
 
-        DBG(4, "packet_sz=%d, mode=%d, dma_addr=0x%x, len=%d is_tx=%d\n",
-                        packet_sz, mode, dma_addr, len, ux500_channel->is_tx);
+        dev_dbg(musb->controller,
+                "packet_sz=%d, mode=%d, dma_addr=0x%x, len=%d is_tx=%d\n",
+                packet_sz, mode, dma_addr, len, ux500_channel->is_tx);
 
         ux500_channel->cur_len = len;
 
@@ -133,15 +137,13 @@ static bool ux500_configure_channel(struct dma_channel *channel,
                                         DMA_SLAVE_BUSWIDTH_4_BYTES;
 
         slave_conf.direction = direction;
-        if (direction == DMA_FROM_DEVICE) {
-                slave_conf.src_addr = usb_fifo_addr;
-                slave_conf.src_addr_width = addr_width;
-                slave_conf.src_maxburst = 16;
-        } else {
-                slave_conf.dst_addr = usb_fifo_addr;
-                slave_conf.dst_addr_width = addr_width;
-                slave_conf.dst_maxburst = 16;
-        }
+        slave_conf.src_addr = usb_fifo_addr;
+        slave_conf.src_addr_width = addr_width;
+        slave_conf.src_maxburst = 16;
+        slave_conf.dst_addr = usb_fifo_addr;
+        slave_conf.dst_addr_width = addr_width;
+        slave_conf.dst_maxburst = 16;
+
         dma_chan->device->device_control(dma_chan, DMA_SLAVE_CONFIG,
                                              (unsigned long) &slave_conf);
 
@@ -166,6 +168,7 @@ static struct dma_channel *ux500_dma_channel_allocate(struct dma_controller *c,
         struct ux500_dma_controller *controller = container_of(c,
                         struct ux500_dma_controller, controller);
         struct ux500_dma_channel *ux500_channel = NULL;
+        struct musb *musb = controller->private_data;
         u8 ch_num = hw_ep->epnum - 1;
         u32 max_ch;
 
@@ -192,7 +195,7 @@ static struct dma_channel *ux500_dma_channel_allocate(struct dma_controller *c,
         ux500_channel->hw_ep = hw_ep;
         ux500_channel->is_allocated = 1;
 
-        DBG(7, "hw_ep=%d, is_tx=0x%x, channel=%d\n",
+        dev_dbg(musb->controller, "hw_ep=%d, is_tx=0x%x, channel=%d\n",
                 hw_ep->epnum, is_tx, ch_num);
 
         return &(ux500_channel->channel);
@@ -201,8 +204,9 @@ static struct dma_channel *ux500_dma_channel_allocate(struct dma_controller *c,
 static void ux500_dma_channel_release(struct dma_channel *channel)
 {
         struct ux500_dma_channel *ux500_channel = channel->private_data;
+        struct musb *musb = ux500_channel->controller->private_data;
 
-        DBG(7, "channel=%d\n", ux500_channel->ch_num);
+        dev_dbg(musb->controller, "channel=%d\n", ux500_channel->ch_num);
 
         if (ux500_channel->is_allocated) {
                 ux500_channel->is_allocated = 0;
@@ -252,8 +256,8 @@ static int ux500_dma_channel_abort(struct dma_channel *channel)
         void __iomem *epio = musb->endpoints[ux500_channel->hw_ep->epnum].regs;
         u16 csr;
 
-        DBG(4, "channel=%d, is_tx=%d\n", ux500_channel->ch_num,
-                                                ux500_channel->is_tx);
+        dev_dbg(musb->controller, "channel=%d, is_tx=%d\n",
+                ux500_channel->ch_num, ux500_channel->is_tx);
 
         if (channel->status == MUSB_DMA_STATUS_BUSY) {
                 if (ux500_channel->is_tx) {
diff --git a/drivers/usb/renesas_usbhs/mod_gadget.c b/drivers/usb/renesas_usbhs/mod_gadget.c
index ba79dbf5adbc..cb2d451d511e 100644
--- a/drivers/usb/renesas_usbhs/mod_gadget.c
+++ b/drivers/usb/renesas_usbhs/mod_gadget.c
@@ -14,6 +14,7 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  */
+#include <linux/dma-mapping.h>
 #include <linux/io.h>
 #include <linux/module.h>
 #include <linux/platform_device.h>
@@ -76,7 +77,7 @@ struct usbhsg_recip_handle {
                 struct usbhsg_gpriv, mod)
 
 #define __usbhsg_for_each_uep(start, pos, g, i) \
-        for (i = start, pos = (g)->uep;         \
+        for (i = start, pos = (g)->uep + i;     \
              i < (g)->uep_size;                 \
              i++, pos = (g)->uep + i)
 
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index 2e06b90aa1f8..5fc13e717911 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -101,6 +101,7 @@ static int   ftdi_jtag_probe(struct usb_serial *serial);
 static int   ftdi_mtxorb_hack_setup(struct usb_serial *serial);
 static int   ftdi_NDI_device_setup(struct usb_serial *serial);
 static int   ftdi_stmclite_probe(struct usb_serial *serial);
+static int   ftdi_8u2232c_probe(struct usb_serial *serial);
 static void  ftdi_USB_UIRT_setup(struct ftdi_private *priv);
 static void  ftdi_HE_TIRA1_setup(struct ftdi_private *priv);
 
@@ -128,6 +129,10 @@ static struct ftdi_sio_quirk ftdi_stmclite_quirk = {
         .probe  = ftdi_stmclite_probe,
 };
 
+static struct ftdi_sio_quirk ftdi_8u2232c_quirk = {
+        .probe  = ftdi_8u2232c_probe,
+};
+
 /*
  * The 8U232AM has the same API as the sio except for:
  * - it can support MUCH higher baudrates; up to:
@@ -151,6 +156,7 @@ static struct ftdi_sio_quirk ftdi_stmclite_quirk = {
  * /sys/bus/usb/ftdi_sio/new_id, then send patch/report!
  */
 static struct usb_device_id id_table_combined [] = {
+        { USB_DEVICE(FTDI_VID, FTDI_ZEITCONTROL_TAGTRACE_MIFARE_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_CTI_MINI_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_CTI_NANO_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_AMC232_PID) },
@@ -177,7 +183,8 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(FTDI_VID, FTDI_8U232AM_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_8U232AM_ALT_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_232RL_PID) },
-        { USB_DEVICE(FTDI_VID, FTDI_8U2232C_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_8U2232C_PID) ,
+                .driver_info = (kernel_ulong_t)&ftdi_8u2232c_quirk },
         { USB_DEVICE(FTDI_VID, FTDI_4232H_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_232H_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_MICRO_CHAMELEON_PID) },
@@ -1171,7 +1178,7 @@ static __u32 get_ftdi_divisor(struct tty_struct *tty,
         case FT2232H: /* FT2232H chip */
         case FT4232H: /* FT4232H chip */
         case FT232H:  /* FT232H chip */
-                if ((baud <= 12000000) & (baud >= 1200)) {
+                if ((baud <= 12000000) && (baud >= 1200)) {
                         div_value = ftdi_2232h_baud_to_divisor(baud);
                 } else if (baud < 1200) {
                         div_value = ftdi_232bm_baud_to_divisor(baud);
@@ -1205,7 +1212,10 @@ static int change_speed(struct tty_struct *tty, struct usb_serial_port *port)
         urb_index_value = get_ftdi_divisor(tty, port);
         urb_value = (__u16)urb_index_value;
         urb_index = (__u16)(urb_index_value >> 16);
-        if (priv->interface) {  /* FT2232C */
+        if ((priv->chip_type == FT2232C) || (priv->chip_type == FT2232H) ||
+                (priv->chip_type == FT4232H) || (priv->chip_type == FT232H)) {
+                /* Probably the BM type needs the MSB of the encoded fractional
+                 * divider also moved like for the chips above. Any infos? */
                 urb_index = (__u16)((urb_index << 8) | priv->interface);
         }
 
@@ -1733,6 +1743,18 @@ static int ftdi_jtag_probe(struct usb_serial *serial)
         return 0;
 }
 
+static int ftdi_8u2232c_probe(struct usb_serial *serial)
+{
+        struct usb_device *udev = serial->dev;
+
+        dbg("%s", __func__);
+
+        if (strcmp(udev->manufacturer, "CALAO Systems") == 0)
+                return ftdi_jtag_probe(serial);
+
+        return 0;
+}
+
 /*
  * First and second port on STMCLiteadaptors is reserved for JTAG interface
  * and the forth port for pio
diff --git a/drivers/usb/serial/ftdi_sio_ids.h b/drivers/usb/serial/ftdi_sio_ids.h
index 19156d1049fe..bf5227ad3ef7 100644
--- a/drivers/usb/serial/ftdi_sio_ids.h
+++ b/drivers/usb/serial/ftdi_sio_ids.h
@@ -1159,4 +1159,8 @@
 /* USB-Nano-485*/
 #define FTDI_CTI_NANO_PID       0xF60B
 
-
+/*
+ * ZeitControl cardsystems GmbH rfid-readers http://zeitconrol.de
+ */
+/* TagTracer MIFARE*/
+#define FTDI_ZEITCONTROL_TAGTRACE_MIFARE_PID    0xF7C0
diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
index 60b25d8ea0e2..fe22e90bc879 100644
--- a/drivers/usb/serial/option.c
+++ b/drivers/usb/serial/option.c
@@ -148,6 +148,12 @@ static void option_instat_callback(struct urb *urb);
 #define HUAWEI_PRODUCT_K4505                    0x1464
 #define HUAWEI_PRODUCT_K3765                    0x1465
 #define HUAWEI_PRODUCT_E14AC                    0x14AC
+#define HUAWEI_PRODUCT_K3806                    0x14AE
+#define HUAWEI_PRODUCT_K4605                    0x14C6
+#define HUAWEI_PRODUCT_K3770                    0x14C9
+#define HUAWEI_PRODUCT_K3771                    0x14CA
+#define HUAWEI_PRODUCT_K4510                    0x14CB
+#define HUAWEI_PRODUCT_K4511                    0x14CC
 #define HUAWEI_PRODUCT_ETS1220                  0x1803
 #define HUAWEI_PRODUCT_E353                     0x1506
 
@@ -412,6 +418,56 @@ static void option_instat_callback(struct urb *urb);
 #define SAMSUNG_VENDOR_ID                       0x04e8
 #define SAMSUNG_PRODUCT_GT_B3730                0x6889
 
+/* YUGA products  www.yuga-info.com*/
+#define YUGA_VENDOR_ID                          0x257A
+#define YUGA_PRODUCT_CEM600                     0x1601
+#define YUGA_PRODUCT_CEM610                     0x1602
+#define YUGA_PRODUCT_CEM500                     0x1603
+#define YUGA_PRODUCT_CEM510                     0x1604
+#define YUGA_PRODUCT_CEM800                     0x1605
+#define YUGA_PRODUCT_CEM900                     0x1606
+
+#define YUGA_PRODUCT_CEU818                     0x1607
+#define YUGA_PRODUCT_CEU816                     0x1608
+#define YUGA_PRODUCT_CEU828                     0x1609
+#define YUGA_PRODUCT_CEU826                     0x160A
+#define YUGA_PRODUCT_CEU518                     0x160B
+#define YUGA_PRODUCT_CEU516                     0x160C
+#define YUGA_PRODUCT_CEU528                     0x160D
+#define YUGA_PRODUCT_CEU526                     0x160F
+
+#define YUGA_PRODUCT_CWM600                     0x2601
+#define YUGA_PRODUCT_CWM610                     0x2602
+#define YUGA_PRODUCT_CWM500                     0x2603
+#define YUGA_PRODUCT_CWM510                     0x2604
+#define YUGA_PRODUCT_CWM800                     0x2605
+#define YUGA_PRODUCT_CWM900                     0x2606
+
+#define YUGA_PRODUCT_CWU718                     0x2607
+#define YUGA_PRODUCT_CWU716                     0x2608
+#define YUGA_PRODUCT_CWU728                     0x2609
+#define YUGA_PRODUCT_CWU726                     0x260A
+#define YUGA_PRODUCT_CWU518                     0x260B
+#define YUGA_PRODUCT_CWU516                     0x260C
+#define YUGA_PRODUCT_CWU528                     0x260D
+#define YUGA_PRODUCT_CWU526                     0x260F
+
+#define YUGA_PRODUCT_CLM600                     0x2601
+#define YUGA_PRODUCT_CLM610                     0x2602
+#define YUGA_PRODUCT_CLM500                     0x2603
+#define YUGA_PRODUCT_CLM510                     0x2604
+#define YUGA_PRODUCT_CLM800                     0x2605
+#define YUGA_PRODUCT_CLM900                     0x2606
+
+#define YUGA_PRODUCT_CLU718                     0x2607
+#define YUGA_PRODUCT_CLU716                     0x2608
+#define YUGA_PRODUCT_CLU728                     0x2609
+#define YUGA_PRODUCT_CLU726                     0x260A
+#define YUGA_PRODUCT_CLU518                     0x260B
+#define YUGA_PRODUCT_CLU516                     0x260C
+#define YUGA_PRODUCT_CLU528                     0x260D
+#define YUGA_PRODUCT_CLU526                     0x260F
+
 /* some devices interfaces need special handling due to a number of reasons */
 enum option_blacklist_reason {
                 OPTION_BLACKLIST_NONE = 0,
@@ -547,6 +603,16 @@ static const struct usb_device_id option_ids[] = {
         { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K3765, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_ETS1220, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E14AC, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K3806, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K4605, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K3770, 0xff, 0x02, 0x31) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K3770, 0xff, 0x02, 0x32) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K3771, 0xff, 0x02, 0x31) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K3771, 0xff, 0x02, 0x32) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K4510, 0xff, 0x01, 0x31) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K4510, 0xff, 0x01, 0x32) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K4511, 0xff, 0x01, 0x31) },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K4511, 0xff, 0x01, 0x32) },
         { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E353, 0xff, 0x01, 0x01) },
         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_V640) },
         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_V620) },
@@ -993,6 +1059,48 @@ static const struct usb_device_id option_ids[] = {
         { USB_DEVICE(CELOT_VENDOR_ID, CELOT_PRODUCT_CT680M) }, /* CT-650 CDMA 450 1xEVDO modem */
         { USB_DEVICE(ONDA_VENDOR_ID, ONDA_MT825UP) }, /* ONDA MT825UP modem */
         { USB_DEVICE_AND_INTERFACE_INFO(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_GT_B3730, USB_CLASS_CDC_DATA, 0x00, 0x00) }, /* Samsung GT-B3730 LTE USB modem.*/
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEM600) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEM610) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEM500) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEM510) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEM800) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEM900) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEU818) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEU816) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEU828) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEU826) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEU518) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEU516) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEU528) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEU526) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWM600) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWM610) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWM500) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWM510) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWM800) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWM900) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWU718) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWU716) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWU728) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWU726) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWU518) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWU516) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWU528) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CWU526) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLM600) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLM610) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLM500) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLM510) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLM800) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLM900) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLU718) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLU716) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLU728) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLU726) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLU518) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLU516) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLU528) },
+        { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CLU526) },
         { } /* Terminating entry */
 };
 MODULE_DEVICE_TABLE(usb, option_ids);
@@ -1122,11 +1230,13 @@ static int option_probe(struct usb_serial *serial,
                 serial->interface->cur_altsetting->desc.bInterfaceClass != 0xff)
                 return -ENODEV;
 
-        /* Don't bind network interfaces on Huawei K3765 & K4505 */
+        /* Don't bind network interfaces on Huawei K3765, K4505 & K4605 */
         if (serial->dev->descriptor.idVendor == HUAWEI_VENDOR_ID &&
                 (serial->dev->descriptor.idProduct == HUAWEI_PRODUCT_K3765 ||
-                        serial->dev->descriptor.idProduct == HUAWEI_PRODUCT_K4505) &&
-                serial->interface->cur_altsetting->desc.bInterfaceNumber == 1)
+                        serial->dev->descriptor.idProduct == HUAWEI_PRODUCT_K4505 ||
+                        serial->dev->descriptor.idProduct == HUAWEI_PRODUCT_K4605) &&
+                (serial->interface->cur_altsetting->desc.bInterfaceNumber == 1 ||
+                        serial->interface->cur_altsetting->desc.bInterfaceNumber == 2))
                 return -ENODEV;
 
         /* Don't bind network interface on Samsung GT-B3730, it is handled by a separate module */
diff --git a/drivers/usb/serial/qcserial.c b/drivers/usb/serial/qcserial.c
index 54a9dab1f33b..aeccc7f0a93c 100644
--- a/drivers/usb/serial/qcserial.c
+++ b/drivers/usb/serial/qcserial.c
@@ -45,6 +45,7 @@ static const struct usb_device_id id_table[] = {
         {USB_DEVICE(0x05c6, 0x9203)},   /* Generic Gobi Modem device */
         {USB_DEVICE(0x05c6, 0x9222)},   /* Generic Gobi Modem device */
         {USB_DEVICE(0x05c6, 0x9008)},   /* Generic Gobi QDL device */
+        {USB_DEVICE(0x05c6, 0x9009)},   /* Generic Gobi Modem device */
         {USB_DEVICE(0x05c6, 0x9201)},   /* Generic Gobi QDL device */
         {USB_DEVICE(0x05c6, 0x9221)},   /* Generic Gobi QDL device */
         {USB_DEVICE(0x05c6, 0x9231)},   /* Generic Gobi QDL device */
@@ -78,6 +79,7 @@ static const struct usb_device_id id_table[] = {
         {USB_DEVICE(0x1199, 0x9008)},   /* Sierra Wireless Gobi 2000 Modem device (VT773) */
         {USB_DEVICE(0x1199, 0x9009)},   /* Sierra Wireless Gobi 2000 Modem device (VT773) */
         {USB_DEVICE(0x1199, 0x900a)},   /* Sierra Wireless Gobi 2000 Modem device (VT773) */
+        {USB_DEVICE(0x1199, 0x9011)},   /* Sierra Wireless Gobi 2000 Modem device (MC8305) */
         {USB_DEVICE(0x16d8, 0x8001)},   /* CMDTech Gobi 2000 QDL device (VU922) */
         {USB_DEVICE(0x16d8, 0x8002)},   /* CMDTech Gobi 2000 Modem device (VU922) */
         {USB_DEVICE(0x05c6, 0x9204)},   /* Gobi 2000 QDL device */
diff --git a/drivers/usb/storage/unusual_devs.h b/drivers/usb/storage/unusual_devs.h
index ccff3483eebc..3041a974faf3 100644
--- a/drivers/usb/storage/unusual_devs.h
+++ b/drivers/usb/storage/unusual_devs.h
@@ -1988,6 +1988,16 @@ UNUSUAL_DEV(  0x4146, 0xba01, 0x0100, 0x0100,
                 "Micro Mini 1GB",
                 USB_SC_DEVICE, USB_PR_DEVICE, NULL, US_FL_NOT_LOCKABLE ),
 
+/*
+ * Nick Bowler <nbowler@elliptictech.com>
+ * SCSI stack spams (otherwise harmless) error messages.
+ */
+UNUSUAL_DEV(  0xc251, 0x4003, 0x0100, 0x0100,
+                "Keil Software, Inc.",
+                "V2M MotherBoard",
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
+                US_FL_NOT_LOCKABLE),
+
 /* Reported by Andrew Simmons <andrew.simmons@gmail.com> */
 UNUSUAL_DEV(  0xed06, 0x4500, 0x0001, 0x0001,
                 "DataStor",
diff --git a/drivers/video/backlight/Kconfig b/drivers/video/backlight/Kconfig
index 1e54b8b7f698..278aeaa92505 100644
--- a/drivers/video/backlight/Kconfig
+++ b/drivers/video/backlight/Kconfig
@@ -335,6 +335,13 @@ config BACKLIGHT_PCF50633
           If you have a backlight driven by a NXP PCF50633 MFD, say Y here to
           enable its driver.
 
+config BACKLIGHT_AAT2870
+        tristate "AnalogicTech AAT2870 Backlight"
+        depends on BACKLIGHT_CLASS_DEVICE && MFD_AAT2870_CORE
+        help
+          If you have a AnalogicTech AAT2870 say Y to enable the
+          backlight driver.
+
 endif # BACKLIGHT_CLASS_DEVICE
 
 endif # BACKLIGHT_LCD_SUPPORT
diff --git a/drivers/video/backlight/Makefile b/drivers/video/backlight/Makefile
index bf1dd92b7527..fdd1fc4b2770 100644
--- a/drivers/video/backlight/Makefile
+++ b/drivers/video/backlight/Makefile
@@ -38,4 +38,5 @@ obj-$(CONFIG_BACKLIGHT_ADP8860)	+= adp8860_bl.o
 obj-$(CONFIG_BACKLIGHT_ADP8870) += adp8870_bl.o
 obj-$(CONFIG_BACKLIGHT_88PM860X) += 88pm860x_bl.o
 obj-$(CONFIG_BACKLIGHT_PCF50633)        += pcf50633-backlight.o
+obj-$(CONFIG_BACKLIGHT_AAT2870) += aat2870_bl.o
 
diff --git a/drivers/video/backlight/aat2870_bl.c b/drivers/video/backlight/aat2870_bl.c
new file mode 100644
index 000000000000..331f1ef1dad5
--- /dev/null
+++ b/drivers/video/backlight/aat2870_bl.c
@@ -0,0 +1,246 @@
+/*
+ * linux/drivers/video/backlight/aat2870_bl.c
+ *
+ * Copyright (c) 2011, NVIDIA Corporation.
+ * Author: Jin Park <jinyoungp@nvidia.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * 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
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/mutex.h>
+#include <linux/delay.h>
+#include <linux/fb.h>
+#include <linux/backlight.h>
+#include <linux/mfd/aat2870.h>
+
+struct aat2870_bl_driver_data {
+        struct platform_device *pdev;
+        struct backlight_device *bd;
+
+        int channels;
+        int max_current;
+        int brightness; /* current brightness */
+};
+
+static inline int aat2870_brightness(struct aat2870_bl_driver_data *aat2870_bl,
+                                     int brightness)
+{
+        struct backlight_device *bd = aat2870_bl->bd;
+        int val;
+
+        val = brightness * (aat2870_bl->max_current - 1);
+        val /= bd->props.max_brightness;
+
+        return val;
+}
+
+static inline int aat2870_bl_enable(struct aat2870_bl_driver_data *aat2870_bl)
+{
+        struct aat2870_data *aat2870
+                        = dev_get_drvdata(aat2870_bl->pdev->dev.parent);
+
+        return aat2870->write(aat2870, AAT2870_BL_CH_EN,
+                              (u8)aat2870_bl->channels);
+}
+
+static inline int aat2870_bl_disable(struct aat2870_bl_driver_data *aat2870_bl)
+{
+        struct aat2870_data *aat2870
+                        = dev_get_drvdata(aat2870_bl->pdev->dev.parent);
+
+        return aat2870->write(aat2870, AAT2870_BL_CH_EN, 0x0);
+}
+
+static int aat2870_bl_get_brightness(struct backlight_device *bd)
+{
+        return bd->props.brightness;
+}
+
+static int aat2870_bl_update_status(struct backlight_device *bd)
+{
+        struct aat2870_bl_driver_data *aat2870_bl = dev_get_drvdata(&bd->dev);
+        struct aat2870_data *aat2870 =
+                        dev_get_drvdata(aat2870_bl->pdev->dev.parent);
+        int brightness = bd->props.brightness;
+        int ret;
+
+        if ((brightness < 0) || (bd->props.max_brightness < brightness)) {
+                dev_err(&bd->dev, "invalid brightness, %d\n", brightness);
+                return -EINVAL;
+        }
+
+        dev_dbg(&bd->dev, "brightness=%d, power=%d, state=%d\n",
+                 bd->props.brightness, bd->props.power, bd->props.state);
+
+        if ((bd->props.power != FB_BLANK_UNBLANK) ||
+                        (bd->props.state & BL_CORE_FBBLANK) ||
+                        (bd->props.state & BL_CORE_SUSPENDED))
+                brightness = 0;
+
+        ret = aat2870->write(aat2870, AAT2870_BLM,
+                             (u8)aat2870_brightness(aat2870_bl, brightness));
+        if (ret < 0)
+                return ret;
+
+        if (brightness == 0) {
+                ret = aat2870_bl_disable(aat2870_bl);
+                if (ret < 0)
+                        return ret;
+        } else if (aat2870_bl->brightness == 0) {
+                ret = aat2870_bl_enable(aat2870_bl);
+                if (ret < 0)
+                        return ret;
+        }
+
+        aat2870_bl->brightness = brightness;
+
+        return 0;
+}
+
+static int aat2870_bl_check_fb(struct backlight_device *bd, struct fb_info *fi)
+{
+        return 1;
+}
+
+static const struct backlight_ops aat2870_bl_ops = {
+        .options = BL_CORE_SUSPENDRESUME,
+        .get_brightness = aat2870_bl_get_brightness,
+        .update_status = aat2870_bl_update_status,
+        .check_fb = aat2870_bl_check_fb,
+};
+
+static int aat2870_bl_probe(struct platform_device *pdev)
+{
+        struct aat2870_bl_platform_data *pdata = pdev->dev.platform_data;
+        struct aat2870_bl_driver_data *aat2870_bl;
+        struct backlight_device *bd;
+        struct backlight_properties props;
+        int ret = 0;
+
+        if (!pdata) {
+                dev_err(&pdev->dev, "No platform data\n");
+                ret = -ENXIO;
+                goto out;
+        }
+
+        if (pdev->id != AAT2870_ID_BL) {
+                dev_err(&pdev->dev, "Invalid device ID, %d\n", pdev->id);
+                ret = -EINVAL;
+                goto out;
+        }
+
+        aat2870_bl = kzalloc(sizeof(struct aat2870_bl_driver_data), GFP_KERNEL);
+        if (!aat2870_bl) {
+                dev_err(&pdev->dev,
+                        "Failed to allocate memory for aat2870 backlight\n");
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        memset(&props, 0, sizeof(struct backlight_properties));
+
+        props.type = BACKLIGHT_RAW;
+        bd = backlight_device_register("aat2870-backlight", &pdev->dev,
+                                       aat2870_bl, &aat2870_bl_ops, &props);
+        if (IS_ERR(bd)) {
+                dev_err(&pdev->dev,
+                        "Failed allocate memory for backlight device\n");
+                ret = PTR_ERR(bd);
+                goto out_kfree;
+        }
+
+        aat2870_bl->pdev = pdev;
+        platform_set_drvdata(pdev, aat2870_bl);
+
+        aat2870_bl->bd = bd;
+
+        if (pdata->channels > 0)
+                aat2870_bl->channels = pdata->channels;
+        else
+                aat2870_bl->channels = AAT2870_BL_CH_ALL;
+
+        if (pdata->max_current > 0)
+                aat2870_bl->max_current = pdata->max_current;
+        else
+                aat2870_bl->max_current = AAT2870_CURRENT_27_9;
+
+        if (pdata->max_brightness > 0)
+                bd->props.max_brightness = pdata->max_brightness;
+        else
+                bd->props.max_brightness = 255;
+
+        aat2870_bl->brightness = 0;
+        bd->props.power = FB_BLANK_UNBLANK;
+        bd->props.brightness = bd->props.max_brightness;
+
+        ret = aat2870_bl_update_status(bd);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "Failed to initialize\n");
+                goto out_bl_dev_unregister;
+        }
+
+        return 0;
+
+out_bl_dev_unregister:
+        backlight_device_unregister(bd);
+out_kfree:
+        kfree(aat2870_bl);
+out:
+        return ret;
+}
+
+static int aat2870_bl_remove(struct platform_device *pdev)
+{
+        struct aat2870_bl_driver_data *aat2870_bl = platform_get_drvdata(pdev);
+        struct backlight_device *bd = aat2870_bl->bd;
+
+        bd->props.power = FB_BLANK_POWERDOWN;
+        bd->props.brightness = 0;
+        backlight_update_status(bd);
+
+        backlight_device_unregister(bd);
+        kfree(aat2870_bl);
+
+        return 0;
+}
+
+static struct platform_driver aat2870_bl_driver = {
+        .driver = {
+                .name   = "aat2870-backlight",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = aat2870_bl_probe,
+        .remove         = aat2870_bl_remove,
+};
+
+static int __init aat2870_bl_init(void)
+{
+        return platform_driver_register(&aat2870_bl_driver);
+}
+subsys_initcall(aat2870_bl_init);
+
+static void __exit aat2870_bl_exit(void)
+{
+        platform_driver_unregister(&aat2870_bl_driver);
+}
+module_exit(aat2870_bl_exit);
+
+MODULE_DESCRIPTION("AnalogicTech AAT2870 Backlight");
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Jin Park <jinyoungp@nvidia.com>");
diff --git a/drivers/video/backlight/adp8870_bl.c b/drivers/video/backlight/adp8870_bl.c
index 05a8832bb3eb..d06886a2bfb5 100644
--- a/drivers/video/backlight/adp8870_bl.c
+++ b/drivers/video/backlight/adp8870_bl.c
@@ -1009,4 +1009,4 @@ module_exit(adp8870_exit);
 MODULE_LICENSE("GPL v2");
 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
 MODULE_DESCRIPTION("ADP8870 Backlight driver");
-MODULE_ALIAS("platform:adp8870-backlight");
+MODULE_ALIAS("i2c:adp8870-backlight");
diff --git a/drivers/video/backlight/backlight.c b/drivers/video/backlight/backlight.c
index 80d292fb92d8..7363c1b169e8 100644
--- a/drivers/video/backlight/backlight.c
+++ b/drivers/video/backlight/backlight.c
@@ -19,7 +19,7 @@
 #include <asm/backlight.h>
 #endif
 
-static const char const *backlight_types[] = {
+static const char *const backlight_types[] = {
         [BACKLIGHT_RAW] = "raw",
         [BACKLIGHT_PLATFORM] = "platform",
         [BACKLIGHT_FIRMWARE] = "firmware",
diff --git a/drivers/video/backlight/ep93xx_bl.c b/drivers/video/backlight/ep93xx_bl.c
index 9f1e389d51d2..b0582917f0c8 100644
--- a/drivers/video/backlight/ep93xx_bl.c
+++ b/drivers/video/backlight/ep93xx_bl.c
@@ -11,7 +11,7 @@
  * BRIGHT, on the Cirrus EP9307, EP9312, and EP9315 processors.
  */
 
-
+#include <linux/module.h>
 #include <linux/platform_device.h>
 #include <linux/io.h>
 #include <linux/fb.h>
diff --git a/drivers/video/backlight/pwm_bl.c b/drivers/video/backlight/pwm_bl.c
index b8f38ec6eb18..8b5b2a4124c7 100644
--- a/drivers/video/backlight/pwm_bl.c
+++ b/drivers/video/backlight/pwm_bl.c
@@ -28,6 +28,8 @@ struct pwm_bl_data {
         unsigned int            lth_brightness;
         int                     (*notify)(struct device *,
                                           int brightness);
+        void                    (*notify_after)(struct device *,
+                                        int brightness);
         int                     (*check_fb)(struct device *, struct fb_info *);
 };
 
@@ -55,6 +57,10 @@ static int pwm_backlight_update_status(struct backlight_device *bl)
                 pwm_config(pb->pwm, brightness, pb->period);
                 pwm_enable(pb->pwm);
         }
+
+        if (pb->notify_after)
+                pb->notify_after(pb->dev, brightness);
+
         return 0;
 }
 
@@ -105,6 +111,7 @@ static int pwm_backlight_probe(struct platform_device *pdev)
 
         pb->period = data->pwm_period_ns;
         pb->notify = data->notify;
+        pb->notify_after = data->notify_after;
         pb->check_fb = data->check_fb;
         pb->lth_brightness = data->lth_brightness *
                 (data->pwm_period_ns / data->max_brightness);
@@ -172,6 +179,8 @@ static int pwm_backlight_suspend(struct platform_device *pdev,
                 pb->notify(pb->dev, 0);
         pwm_config(pb->pwm, 0, pb->period);
         pwm_disable(pb->pwm);
+        if (pb->notify_after)
+                pb->notify_after(pb->dev, 0);
         return 0;
 }
 
diff --git a/drivers/video/omap2/displays/panel-taal.c b/drivers/video/omap2/displays/panel-taal.c
index fdd5d4ae437d..4e888ac09b3f 100644
--- a/drivers/video/omap2/displays/panel-taal.c
+++ b/drivers/video/omap2/displays/panel-taal.c
@@ -504,14 +504,18 @@ static int taal_exit_ulps(struct omap_dss_device *dssdev)
                 return 0;
 
         r = omapdss_dsi_display_enable(dssdev);
-        if (r)
-                goto err;
+        if (r) {
+                dev_err(&dssdev->dev, "failed to enable DSI\n");
+                goto err1;
+        }
 
         omapdss_dsi_vc_enable_hs(dssdev, td->channel, true);
 
         r = _taal_enable_te(dssdev, true);
-        if (r)
-                goto err;
+        if (r) {
+                dev_err(&dssdev->dev, "failed to re-enable TE");
+                goto err2;
+        }
 
         enable_irq(gpio_to_irq(panel_data->ext_te_gpio));
 
@@ -521,13 +525,15 @@ static int taal_exit_ulps(struct omap_dss_device *dssdev)
 
         return 0;
 
-err:
-        dev_err(&dssdev->dev, "exit ULPS failed");
-        r = taal_panel_reset(dssdev);
-
-        enable_irq(gpio_to_irq(panel_data->ext_te_gpio));
-        td->ulps_enabled = false;
+err2:
+        dev_err(&dssdev->dev, "failed to exit ULPS");
 
+        r = taal_panel_reset(dssdev);
+        if (!r) {
+                enable_irq(gpio_to_irq(panel_data->ext_te_gpio));
+                td->ulps_enabled = false;
+        }
+err1:
         taal_queue_ulps_work(dssdev);
 
         return r;
@@ -1241,11 +1247,8 @@ static void taal_power_off(struct omap_dss_device *dssdev)
         int r;
 
         r = taal_dcs_write_0(td, DCS_DISPLAY_OFF);
-        if (!r) {
+        if (!r)
                 r = taal_sleep_in(td);
-                /* HACK: wait a bit so that the message goes through */
-                msleep(10);
-        }
 
         if (r) {
                 dev_err(&dssdev->dev,
@@ -1317,8 +1320,11 @@ static void taal_disable(struct omap_dss_device *dssdev)
         dsi_bus_lock(dssdev);
 
         if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE) {
-                taal_wake_up(dssdev);
-                taal_power_off(dssdev);
+                int r;
+
+                r = taal_wake_up(dssdev);
+                if (!r)
+                        taal_power_off(dssdev);
         }
 
         dsi_bus_unlock(dssdev);
@@ -1897,20 +1903,6 @@ err:
         mutex_unlock(&td->lock);
 }
 
-static int taal_set_update_mode(struct omap_dss_device *dssdev,
-                enum omap_dss_update_mode mode)
-{
-        if (mode != OMAP_DSS_UPDATE_MANUAL)
-                return -EINVAL;
-        return 0;
-}
-
-static enum omap_dss_update_mode taal_get_update_mode(
-                struct omap_dss_device *dssdev)
-{
-        return OMAP_DSS_UPDATE_MANUAL;
-}
-
 static struct omap_dss_driver taal_driver = {
         .probe          = taal_probe,
         .remove         = __exit_p(taal_remove),
@@ -1920,9 +1912,6 @@ static struct omap_dss_driver taal_driver = {
         .suspend        = taal_suspend,
         .resume         = taal_resume,
 
-        .set_update_mode = taal_set_update_mode,
-        .get_update_mode = taal_get_update_mode,
-
         .update         = taal_update,
         .sync           = taal_sync,
 
diff --git a/drivers/video/omap2/dss/Kconfig b/drivers/video/omap2/dss/Kconfig
index 6b3e2da11419..0d12524db14b 100644
--- a/drivers/video/omap2/dss/Kconfig
+++ b/drivers/video/omap2/dss/Kconfig
@@ -117,18 +117,6 @@ config OMAP2_DSS_MIN_FCK_PER_PCK
           Max FCK is 173MHz, so this doesn't work if your PCK
           is very high.
 
-config OMAP2_DSS_SLEEP_BEFORE_RESET
-        bool "Sleep 50ms before DSS reset"
-        default y
-        help
-          For some unknown reason we may get SYNC_LOST errors from the display
-          subsystem at initialization time if we don't sleep before resetting
-          the DSS. See the source (dss.c) for more comments.
-
-          However, 50ms is quite long time to sleep, and with some
-          configurations the SYNC_LOST may never happen, so the sleep can
-          be disabled here.
-
 config OMAP2_DSS_SLEEP_AFTER_VENC_RESET
         bool "Sleep 20ms after VENC reset"
         default y
diff --git a/drivers/video/omap2/dss/core.c b/drivers/video/omap2/dss/core.c
index 3da426719dd6..76821fefce9a 100644
--- a/drivers/video/omap2/dss/core.c
+++ b/drivers/video/omap2/dss/core.c
@@ -183,8 +183,11 @@ static int omap_dss_probe(struct platform_device *pdev)
                 goto err_dss;
         }
 
-        /* keep clocks enabled to prevent context saves/restores during init */
-        dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK);
+        r = dispc_init_platform_driver();
+        if (r) {
+                DSSERR("Failed to initialize dispc platform driver\n");
+                goto err_dispc;
+        }
 
         r = rfbi_init_platform_driver();
         if (r) {
@@ -192,12 +195,6 @@ static int omap_dss_probe(struct platform_device *pdev)
                 goto err_rfbi;
         }
 
-        r = dispc_init_platform_driver();
-        if (r) {
-                DSSERR("Failed to initialize dispc platform driver\n");
-                goto err_dispc;
-        }
-
         r = venc_init_platform_driver();
         if (r) {
                 DSSERR("Failed to initialize venc platform driver\n");
@@ -238,8 +235,6 @@ static int omap_dss_probe(struct platform_device *pdev)
                         pdata->default_device = dssdev;
         }
 
-        dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK);
-
         return 0;
 
 err_register:
@@ -268,11 +263,11 @@ static int omap_dss_remove(struct platform_device *pdev)
 
         dss_uninitialize_debugfs();
 
+        hdmi_uninit_platform_driver();
+        dsi_uninit_platform_driver();
         venc_uninit_platform_driver();
-        dispc_uninit_platform_driver();
         rfbi_uninit_platform_driver();
-        dsi_uninit_platform_driver();
-        hdmi_uninit_platform_driver();
+        dispc_uninit_platform_driver();
         dss_uninit_platform_driver();
 
         dss_uninit_overlays(pdev);
diff --git a/drivers/video/omap2/dss/dispc.c b/drivers/video/omap2/dss/dispc.c
index 7a9a2e7d9685..0f3961a1ce26 100644
--- a/drivers/video/omap2/dss/dispc.c
+++ b/drivers/video/omap2/dss/dispc.c
@@ -33,6 +33,8 @@
 #include <linux/workqueue.h>
 #include <linux/hardirq.h>
 #include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/pm_runtime.h>
 
 #include <plat/sram.h>
 #include <plat/clock.h>
@@ -77,6 +79,12 @@ struct dispc_v_coef {
         s8 vc00;
 };
 
+enum omap_burst_size {
+        BURST_SIZE_X2 = 0,
+        BURST_SIZE_X4 = 1,
+        BURST_SIZE_X8 = 2,
+};
+
 #define REG_GET(idx, start, end) \
         FLD_GET(dispc_read_reg(idx), start, end)
 
@@ -92,7 +100,11 @@ struct dispc_irq_stats {
 static struct {
         struct platform_device *pdev;
         void __iomem    *base;
+
+        int             ctx_loss_cnt;
+
         int irq;
+        struct clk *dss_clk;
 
         u32     fifo_size[3];
 
@@ -102,6 +114,7 @@ static struct {
         u32 error_irqs;
         struct work_struct error_work;
 
+        bool            ctx_valid;
         u32             ctx[DISPC_SZ_REGS / sizeof(u32)];
 
 #ifdef CONFIG_OMAP2_DSS_COLLECT_IRQ_STATS
@@ -134,18 +147,34 @@ static inline u32 dispc_read_reg(const u16 idx)
         return __raw_readl(dispc.base + idx);
 }
 
+static int dispc_get_ctx_loss_count(void)
+{
+        struct device *dev = &dispc.pdev->dev;
+        struct omap_display_platform_data *pdata = dev->platform_data;
+        struct omap_dss_board_info *board_data = pdata->board_data;
+        int cnt;
+
+        if (!board_data->get_context_loss_count)
+                return -ENOENT;
+
+        cnt = board_data->get_context_loss_count(dev);
+
+        WARN_ONCE(cnt < 0, "get_context_loss_count failed: %d\n", cnt);
+
+        return cnt;
+}
+
 #define SR(reg) \
         dispc.ctx[DISPC_##reg / sizeof(u32)] = dispc_read_reg(DISPC_##reg)
 #define RR(reg) \
         dispc_write_reg(DISPC_##reg, dispc.ctx[DISPC_##reg / sizeof(u32)])
 
-void dispc_save_context(void)
+static void dispc_save_context(void)
 {
         int i;
-        if (cpu_is_omap24xx())
-                return;
 
-        SR(SYSCONFIG);
+        DSSDBG("dispc_save_context\n");
+
         SR(IRQENABLE);
         SR(CONTROL);
         SR(CONFIG);
@@ -158,7 +187,8 @@ void dispc_save_context(void)
         SR(TIMING_V(OMAP_DSS_CHANNEL_LCD));
         SR(POL_FREQ(OMAP_DSS_CHANNEL_LCD));
         SR(DIVISORo(OMAP_DSS_CHANNEL_LCD));
-        SR(GLOBAL_ALPHA);
+        if (dss_has_feature(FEAT_GLOBAL_ALPHA))
+                SR(GLOBAL_ALPHA);
         SR(SIZE_MGR(OMAP_DSS_CHANNEL_DIGIT));
         SR(SIZE_MGR(OMAP_DSS_CHANNEL_LCD));
         if (dss_has_feature(FEAT_MGR_LCD2)) {
@@ -188,20 +218,25 @@ void dispc_save_context(void)
         SR(DATA_CYCLE2(OMAP_DSS_CHANNEL_LCD));
         SR(DATA_CYCLE3(OMAP_DSS_CHANNEL_LCD));
 
-        SR(CPR_COEF_R(OMAP_DSS_CHANNEL_LCD));
-        SR(CPR_COEF_G(OMAP_DSS_CHANNEL_LCD));
-        SR(CPR_COEF_B(OMAP_DSS_CHANNEL_LCD));
+        if (dss_has_feature(FEAT_CPR)) {
+                SR(CPR_COEF_R(OMAP_DSS_CHANNEL_LCD));
+                SR(CPR_COEF_G(OMAP_DSS_CHANNEL_LCD));
+                SR(CPR_COEF_B(OMAP_DSS_CHANNEL_LCD));
+        }
         if (dss_has_feature(FEAT_MGR_LCD2)) {
-                SR(CPR_COEF_B(OMAP_DSS_CHANNEL_LCD2));
-                SR(CPR_COEF_G(OMAP_DSS_CHANNEL_LCD2));
-                SR(CPR_COEF_R(OMAP_DSS_CHANNEL_LCD2));
+                if (dss_has_feature(FEAT_CPR)) {
+                        SR(CPR_COEF_B(OMAP_DSS_CHANNEL_LCD2));
+                        SR(CPR_COEF_G(OMAP_DSS_CHANNEL_LCD2));
+                        SR(CPR_COEF_R(OMAP_DSS_CHANNEL_LCD2));
+                }
 
                 SR(DATA_CYCLE1(OMAP_DSS_CHANNEL_LCD2));
                 SR(DATA_CYCLE2(OMAP_DSS_CHANNEL_LCD2));
                 SR(DATA_CYCLE3(OMAP_DSS_CHANNEL_LCD2));
         }
 
-        SR(OVL_PRELOAD(OMAP_DSS_GFX));
+        if (dss_has_feature(FEAT_PRELOAD))
+                SR(OVL_PRELOAD(OMAP_DSS_GFX));
 
         /* VID1 */
         SR(OVL_BA0(OMAP_DSS_VIDEO1));
@@ -226,8 +261,10 @@ void dispc_save_context(void)
         for (i = 0; i < 5; i++)
                 SR(OVL_CONV_COEF(OMAP_DSS_VIDEO1, i));
 
-        for (i = 0; i < 8; i++)
-                SR(OVL_FIR_COEF_V(OMAP_DSS_VIDEO1, i));
+        if (dss_has_feature(FEAT_FIR_COEF_V)) {
+                for (i = 0; i < 8; i++)
+                        SR(OVL_FIR_COEF_V(OMAP_DSS_VIDEO1, i));
+        }
 
         if (dss_has_feature(FEAT_HANDLE_UV_SEPARATE)) {
                 SR(OVL_BA0_UV(OMAP_DSS_VIDEO1));
@@ -248,7 +285,8 @@ void dispc_save_context(void)
         if (dss_has_feature(FEAT_ATTR2))
                 SR(OVL_ATTRIBUTES2(OMAP_DSS_VIDEO1));
 
-        SR(OVL_PRELOAD(OMAP_DSS_VIDEO1));
+        if (dss_has_feature(FEAT_PRELOAD))
+                SR(OVL_PRELOAD(OMAP_DSS_VIDEO1));
 
         /* VID2 */
         SR(OVL_BA0(OMAP_DSS_VIDEO2));
@@ -273,8 +311,10 @@ void dispc_save_context(void)
         for (i = 0; i < 5; i++)
                 SR(OVL_CONV_COEF(OMAP_DSS_VIDEO2, i));
 
-        for (i = 0; i < 8; i++)
-                SR(OVL_FIR_COEF_V(OMAP_DSS_VIDEO2, i));
+        if (dss_has_feature(FEAT_FIR_COEF_V)) {
+                for (i = 0; i < 8; i++)
+                        SR(OVL_FIR_COEF_V(OMAP_DSS_VIDEO2, i));
+        }
 
         if (dss_has_feature(FEAT_HANDLE_UV_SEPARATE)) {
                 SR(OVL_BA0_UV(OMAP_DSS_VIDEO2));
@@ -295,16 +335,35 @@ void dispc_save_context(void)
         if (dss_has_feature(FEAT_ATTR2))
                 SR(OVL_ATTRIBUTES2(OMAP_DSS_VIDEO2));
 
-        SR(OVL_PRELOAD(OMAP_DSS_VIDEO2));
+        if (dss_has_feature(FEAT_PRELOAD))
+                SR(OVL_PRELOAD(OMAP_DSS_VIDEO2));
 
         if (dss_has_feature(FEAT_CORE_CLK_DIV))
                 SR(DIVISOR);
+
+        dispc.ctx_loss_cnt = dispc_get_ctx_loss_count();
+        dispc.ctx_valid = true;
+
+        DSSDBG("context saved, ctx_loss_count %d\n", dispc.ctx_loss_cnt);
 }
 
-void dispc_restore_context(void)
+static void dispc_restore_context(void)
 {
-        int i;
-        RR(SYSCONFIG);
+        int i, ctx;
+
+        DSSDBG("dispc_restore_context\n");
+
+        if (!dispc.ctx_valid)
+                return;
+
+        ctx = dispc_get_ctx_loss_count();
+
+        if (ctx >= 0 && ctx == dispc.ctx_loss_cnt)
+                return;
+
+        DSSDBG("ctx_loss_count: saved %d, current %d\n",
+                        dispc.ctx_loss_cnt, ctx);
+
         /*RR(IRQENABLE);*/
         /*RR(CONTROL);*/
         RR(CONFIG);
@@ -317,7 +376,8 @@ void dispc_restore_context(void)
         RR(TIMING_V(OMAP_DSS_CHANNEL_LCD));
         RR(POL_FREQ(OMAP_DSS_CHANNEL_LCD));
         RR(DIVISORo(OMAP_DSS_CHANNEL_LCD));
-        RR(GLOBAL_ALPHA);
+        if (dss_has_feature(FEAT_GLOBAL_ALPHA))
+                RR(GLOBAL_ALPHA);
         RR(SIZE_MGR(OMAP_DSS_CHANNEL_DIGIT));
         RR(SIZE_MGR(OMAP_DSS_CHANNEL_LCD));
         if (dss_has_feature(FEAT_MGR_LCD2)) {
@@ -347,20 +407,25 @@ void dispc_restore_context(void)
         RR(DATA_CYCLE2(OMAP_DSS_CHANNEL_LCD));
         RR(DATA_CYCLE3(OMAP_DSS_CHANNEL_LCD));
 
-        RR(CPR_COEF_R(OMAP_DSS_CHANNEL_LCD));
-        RR(CPR_COEF_G(OMAP_DSS_CHANNEL_LCD));
-        RR(CPR_COEF_B(OMAP_DSS_CHANNEL_LCD));
+        if (dss_has_feature(FEAT_CPR)) {
+                RR(CPR_COEF_R(OMAP_DSS_CHANNEL_LCD));
+                RR(CPR_COEF_G(OMAP_DSS_CHANNEL_LCD));
+                RR(CPR_COEF_B(OMAP_DSS_CHANNEL_LCD));
+        }
         if (dss_has_feature(FEAT_MGR_LCD2)) {
                 RR(DATA_CYCLE1(OMAP_DSS_CHANNEL_LCD2));
                 RR(DATA_CYCLE2(OMAP_DSS_CHANNEL_LCD2));
                 RR(DATA_CYCLE3(OMAP_DSS_CHANNEL_LCD2));
 
-                RR(CPR_COEF_B(OMAP_DSS_CHANNEL_LCD2));
-                RR(CPR_COEF_G(OMAP_DSS_CHANNEL_LCD2));
-                RR(CPR_COEF_R(OMAP_DSS_CHANNEL_LCD2));
+                if (dss_has_feature(FEAT_CPR)) {
+                        RR(CPR_COEF_B(OMAP_DSS_CHANNEL_LCD2));
+                        RR(CPR_COEF_G(OMAP_DSS_CHANNEL_LCD2));
+                        RR(CPR_COEF_R(OMAP_DSS_CHANNEL_LCD2));
+                }
         }
 
-        RR(OVL_PRELOAD(OMAP_DSS_GFX));
+        if (dss_has_feature(FEAT_PRELOAD))
+                RR(OVL_PRELOAD(OMAP_DSS_GFX));
 
         /* VID1 */
         RR(OVL_BA0(OMAP_DSS_VIDEO1));
@@ -385,8 +450,10 @@ void dispc_restore_context(void)
         for (i = 0; i < 5; i++)
                 RR(OVL_CONV_COEF(OMAP_DSS_VIDEO1, i));
 
-        for (i = 0; i < 8; i++)
-                RR(OVL_FIR_COEF_V(OMAP_DSS_VIDEO1, i));
+        if (dss_has_feature(FEAT_FIR_COEF_V)) {
+                for (i = 0; i < 8; i++)
+                        RR(OVL_FIR_COEF_V(OMAP_DSS_VIDEO1, i));
+        }
 
         if (dss_has_feature(FEAT_HANDLE_UV_SEPARATE)) {
                 RR(OVL_BA0_UV(OMAP_DSS_VIDEO1));
@@ -407,7 +474,8 @@ void dispc_restore_context(void)
         if (dss_has_feature(FEAT_ATTR2))
                 RR(OVL_ATTRIBUTES2(OMAP_DSS_VIDEO1));
 
-        RR(OVL_PRELOAD(OMAP_DSS_VIDEO1));
+        if (dss_has_feature(FEAT_PRELOAD))
+                RR(OVL_PRELOAD(OMAP_DSS_VIDEO1));
 
         /* VID2 */
         RR(OVL_BA0(OMAP_DSS_VIDEO2));
@@ -432,8 +500,10 @@ void dispc_restore_context(void)
         for (i = 0; i < 5; i++)
                 RR(OVL_CONV_COEF(OMAP_DSS_VIDEO2, i));
 
-        for (i = 0; i < 8; i++)
-                RR(OVL_FIR_COEF_V(OMAP_DSS_VIDEO2, i));
+        if (dss_has_feature(FEAT_FIR_COEF_V)) {
+                for (i = 0; i < 8; i++)
+                        RR(OVL_FIR_COEF_V(OMAP_DSS_VIDEO2, i));
+        }
 
         if (dss_has_feature(FEAT_HANDLE_UV_SEPARATE)) {
                 RR(OVL_BA0_UV(OMAP_DSS_VIDEO2));
@@ -454,7 +524,8 @@ void dispc_restore_context(void)
         if (dss_has_feature(FEAT_ATTR2))
                 RR(OVL_ATTRIBUTES2(OMAP_DSS_VIDEO2));
 
-        RR(OVL_PRELOAD(OMAP_DSS_VIDEO2));
+        if (dss_has_feature(FEAT_PRELOAD))
+                RR(OVL_PRELOAD(OMAP_DSS_VIDEO2));
 
         if (dss_has_feature(FEAT_CORE_CLK_DIV))
                 RR(DIVISOR);
@@ -471,19 +542,35 @@ void dispc_restore_context(void)
          * the context is fully restored
          */
         RR(IRQENABLE);
+
+        DSSDBG("context restored\n");
 }
 
 #undef SR
 #undef RR
 
-static inline void enable_clocks(bool enable)
+int dispc_runtime_get(void)
 {
-        if (enable)
-                dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK);
-        else
-                dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK);
+        int r;
+
+        DSSDBG("dispc_runtime_get\n");
+
+        r = pm_runtime_get_sync(&dispc.pdev->dev);
+        WARN_ON(r < 0);
+        return r < 0 ? r : 0;
 }
 
+void dispc_runtime_put(void)
+{
+        int r;
+
+        DSSDBG("dispc_runtime_put\n");
+
+        r = pm_runtime_put(&dispc.pdev->dev);
+        WARN_ON(r < 0);
+}
+
+
 bool dispc_go_busy(enum omap_channel channel)
 {
         int bit;
@@ -505,8 +592,6 @@ void dispc_go(enum omap_channel channel)
         int bit;
         bool enable_bit, go_bit;
 
-        enable_clocks(1);
-
         if (channel == OMAP_DSS_CHANNEL_LCD ||
                         channel == OMAP_DSS_CHANNEL_LCD2)
                 bit = 0; /* LCDENABLE */
@@ -520,7 +605,7 @@ void dispc_go(enum omap_channel channel)
                 enable_bit = REG_GET(DISPC_CONTROL, bit, bit) == 1;
 
         if (!enable_bit)
-                goto end;
+                return;
 
         if (channel == OMAP_DSS_CHANNEL_LCD ||
                         channel == OMAP_DSS_CHANNEL_LCD2)
@@ -535,7 +620,7 @@ void dispc_go(enum omap_channel channel)
 
         if (go_bit) {
                 DSSERR("GO bit not down for channel %d\n", channel);
-                goto end;
+                return;
         }
 
         DSSDBG("GO %s\n", channel == OMAP_DSS_CHANNEL_LCD ? "LCD" :
@@ -545,8 +630,6 @@ void dispc_go(enum omap_channel channel)
                 REG_FLD_MOD(DISPC_CONTROL2, 1, bit, bit);
         else
                 REG_FLD_MOD(DISPC_CONTROL, 1, bit, bit);
-end:
-        enable_clocks(0);
 }
 
 static void _dispc_write_firh_reg(enum omap_plane plane, int reg, u32 value)
@@ -920,7 +1003,7 @@ static void _dispc_set_color_mode(enum omap_plane plane,
         REG_FLD_MOD(DISPC_OVL_ATTRIBUTES(plane), m, 4, 1);
 }
 
-static void _dispc_set_channel_out(enum omap_plane plane,
+void dispc_set_channel_out(enum omap_plane plane,
                 enum omap_channel channel)
 {
         int shift;
@@ -967,13 +1050,10 @@ static void _dispc_set_channel_out(enum omap_plane plane,
         dispc_write_reg(DISPC_OVL_ATTRIBUTES(plane), val);
 }
 
-void dispc_set_burst_size(enum omap_plane plane,
+static void dispc_set_burst_size(enum omap_plane plane,
                 enum omap_burst_size burst_size)
 {
         int shift;
-        u32 val;
-
-        enable_clocks(1);
 
         switch (plane) {
         case OMAP_DSS_GFX:
@@ -988,11 +1068,24 @@ void dispc_set_burst_size(enum omap_plane plane,
                 return;
         }
 
-        val = dispc_read_reg(DISPC_OVL_ATTRIBUTES(plane));
-        val = FLD_MOD(val, burst_size, shift+1, shift);
-        dispc_write_reg(DISPC_OVL_ATTRIBUTES(plane), val);
+        REG_FLD_MOD(DISPC_OVL_ATTRIBUTES(plane), burst_size, shift + 1, shift);
+}
 
-        enable_clocks(0);
+static void dispc_configure_burst_sizes(void)
+{
+        int i;
+        const int burst_size = BURST_SIZE_X8;
+
+        /* Configure burst size always to maximum size */
+        for (i = 0; i < omap_dss_get_num_overlays(); ++i)
+                dispc_set_burst_size(i, burst_size);
+}
+
+u32 dispc_get_burst_size(enum omap_plane plane)
+{
+        unsigned unit = dss_feat_get_burst_size_unit();
+        /* burst multiplier is always x8 (see dispc_configure_burst_sizes()) */
+        return unit * 8;
 }
 
 void dispc_enable_gamma_table(bool enable)
@@ -1009,6 +1102,40 @@ void dispc_enable_gamma_table(bool enable)
         REG_FLD_MOD(DISPC_CONFIG, enable, 9, 9);
 }
 
+void dispc_enable_cpr(enum omap_channel channel, bool enable)
+{
+        u16 reg;
+
+        if (channel == OMAP_DSS_CHANNEL_LCD)
+                reg = DISPC_CONFIG;
+        else if (channel == OMAP_DSS_CHANNEL_LCD2)
+                reg = DISPC_CONFIG2;
+        else
+                return;
+
+        REG_FLD_MOD(reg, enable, 15, 15);
+}
+
+void dispc_set_cpr_coef(enum omap_channel channel,
+                struct omap_dss_cpr_coefs *coefs)
+{
+        u32 coef_r, coef_g, coef_b;
+
+        if (channel != OMAP_DSS_CHANNEL_LCD && channel != OMAP_DSS_CHANNEL_LCD2)
+                return;
+
+        coef_r = FLD_VAL(coefs->rr, 31, 22) | FLD_VAL(coefs->rg, 20, 11) |
+                FLD_VAL(coefs->rb, 9, 0);
+        coef_g = FLD_VAL(coefs->gr, 31, 22) | FLD_VAL(coefs->gg, 20, 11) |
+                FLD_VAL(coefs->gb, 9, 0);
+        coef_b = FLD_VAL(coefs->br, 31, 22) | FLD_VAL(coefs->bg, 20, 11) |
+                FLD_VAL(coefs->bb, 9, 0);
+
+        dispc_write_reg(DISPC_CPR_COEF_R(channel), coef_r);
+        dispc_write_reg(DISPC_CPR_COEF_G(channel), coef_g);
+        dispc_write_reg(DISPC_CPR_COEF_B(channel), coef_b);
+}
+
 static void _dispc_set_vid_color_conv(enum omap_plane plane, bool enable)
 {
         u32 val;
@@ -1029,9 +1156,7 @@ void dispc_enable_replication(enum omap_plane plane, bool enable)
         else
                 bit = 10;
 
-        enable_clocks(1);
         REG_FLD_MOD(DISPC_OVL_ATTRIBUTES(plane), enable, bit, bit);
-        enable_clocks(0);
 }
 
 void dispc_set_lcd_size(enum omap_channel channel, u16 width, u16 height)
@@ -1039,9 +1164,7 @@ void dispc_set_lcd_size(enum omap_channel channel, u16 width, u16 height)
         u32 val;
         BUG_ON((width > (1 << 11)) || (height > (1 << 11)));
         val = FLD_VAL(height - 1, 26, 16) | FLD_VAL(width - 1, 10, 0);
-        enable_clocks(1);
         dispc_write_reg(DISPC_SIZE_MGR(channel), val);
-        enable_clocks(0);
 }
 
 void dispc_set_digit_size(u16 width, u16 height)
@@ -1049,9 +1172,7 @@ void dispc_set_digit_size(u16 width, u16 height)
         u32 val;
         BUG_ON((width > (1 << 11)) || (height > (1 << 11)));
         val = FLD_VAL(height - 1, 26, 16) | FLD_VAL(width - 1, 10, 0);
-        enable_clocks(1);
         dispc_write_reg(DISPC_SIZE_MGR(OMAP_DSS_CHANNEL_DIGIT), val);
-        enable_clocks(0);
 }
 
 static void dispc_read_plane_fifo_sizes(void)
@@ -1059,18 +1180,17 @@ static void dispc_read_plane_fifo_sizes(void)
         u32 size;
         int plane;
         u8 start, end;
+        u32 unit;
 
-        enable_clocks(1);
+        unit = dss_feat_get_buffer_size_unit();
 
         dss_feat_get_reg_field(FEAT_REG_FIFOSIZE, &start, &end);
 
         for (plane = 0; plane < ARRAY_SIZE(dispc.fifo_size); ++plane) {
-                size = FLD_GET(dispc_read_reg(DISPC_OVL_FIFO_SIZE_STATUS(plane)),
-                        start, end);
+                size = REG_GET(DISPC_OVL_FIFO_SIZE_STATUS(plane), start, end);
+                size *= unit;
                 dispc.fifo_size[plane] = size;
         }
-
-        enable_clocks(0);
 }
 
 u32 dispc_get_plane_fifo_size(enum omap_plane plane)
@@ -1078,15 +1198,22 @@ u32 dispc_get_plane_fifo_size(enum omap_plane plane)
         return dispc.fifo_size[plane];
 }
 
-void dispc_setup_plane_fifo(enum omap_plane plane, u32 low, u32 high)
+void dispc_set_fifo_threshold(enum omap_plane plane, u32 low, u32 high)
 {
         u8 hi_start, hi_end, lo_start, lo_end;
+        u32 unit;
+
+        unit = dss_feat_get_buffer_size_unit();
+
+        WARN_ON(low % unit != 0);
+        WARN_ON(high % unit != 0);
+
+        low /= unit;
+        high /= unit;
 
         dss_feat_get_reg_field(FEAT_REG_FIFOHIGHTHRESHOLD, &hi_start, &hi_end);
         dss_feat_get_reg_field(FEAT_REG_FIFOLOWTHRESHOLD, &lo_start, &lo_end);
 
-        enable_clocks(1);
-
         DSSDBG("fifo(%d) low/high old %u/%u, new %u/%u\n",
                         plane,
                         REG_GET(DISPC_OVL_FIFO_THRESHOLD(plane),
@@ -1098,18 +1225,12 @@ void dispc_setup_plane_fifo(enum omap_plane plane, u32 low, u32 high)
         dispc_write_reg(DISPC_OVL_FIFO_THRESHOLD(plane),
                         FLD_VAL(high, hi_start, hi_end) |
                         FLD_VAL(low, lo_start, lo_end));
-
-        enable_clocks(0);
 }
 
 void dispc_enable_fifomerge(bool enable)
 {
-        enable_clocks(1);
-
         DSSDBG("FIFO merge %s\n", enable ? "enabled" : "disabled");
         REG_FLD_MOD(DISPC_CONFIG, enable ? 1 : 0, 14, 14);
-
-        enable_clocks(0);
 }
 
 static void _dispc_set_fir(enum omap_plane plane,
@@ -1729,14 +1850,7 @@ static unsigned long calc_fclk(enum omap_channel channel, u16 width,
         return dispc_pclk_rate(channel) * vf * hf;
 }
 
-void dispc_set_channel_out(enum omap_plane plane, enum omap_channel channel_out)
-{
-        enable_clocks(1);
-        _dispc_set_channel_out(plane, channel_out);
-        enable_clocks(0);
-}
-
-static int _dispc_setup_plane(enum omap_plane plane,
+int dispc_setup_plane(enum omap_plane plane,
                 u32 paddr, u16 screen_width,
                 u16 pos_x, u16 pos_y,
                 u16 width, u16 height,
@@ -1744,7 +1858,7 @@ static int _dispc_setup_plane(enum omap_plane plane,
                 enum omap_color_mode color_mode,
                 bool ilace,
                 enum omap_dss_rotation_type rotation_type,
-                u8 rotation, int mirror,
+                u8 rotation, bool mirror,
                 u8 global_alpha, u8 pre_mult_alpha,
                 enum omap_channel channel, u32 puv_addr)
 {
@@ -1758,6 +1872,14 @@ static int _dispc_setup_plane(enum omap_plane plane,
         u16 frame_height = height;
         unsigned int field_offset = 0;
 
+        DSSDBG("dispc_setup_plane %d, pa %x, sw %d, %d,%d, %dx%d -> "
+               "%dx%d, ilace %d, cmode %x, rot %d, mir %d chan %d\n",
+               plane, paddr, screen_width, pos_x, pos_y,
+               width, height,
+               out_width, out_height,
+               ilace, color_mode,
+               rotation, mirror, channel);
+
         if (paddr == 0)
                 return -EINVAL;
 
@@ -1903,9 +2025,13 @@ static int _dispc_setup_plane(enum omap_plane plane,
         return 0;
 }
 
-static void _dispc_enable_plane(enum omap_plane plane, bool enable)
+int dispc_enable_plane(enum omap_plane plane, bool enable)
 {
+        DSSDBG("dispc_enable_plane %d, %d\n", plane, enable);
+
         REG_FLD_MOD(DISPC_OVL_ATTRIBUTES(plane), enable ? 1 : 0, 0, 0);
+
+        return 0;
 }
 
 static void dispc_disable_isr(void *data, u32 mask)
@@ -1929,8 +2055,6 @@ static void dispc_enable_lcd_out(enum omap_channel channel, bool enable)
         int r;
         u32 irq;
 
-        enable_clocks(1);
-
         /* When we disable LCD output, we need to wait until frame is done.
          * Otherwise the DSS is still working, and turning off the clocks
          * prevents DSS from going to OFF mode */
@@ -1964,8 +2088,6 @@ static void dispc_enable_lcd_out(enum omap_channel channel, bool enable)
                 if (r)
                         DSSERR("failed to unregister FRAMEDONE isr\n");
         }
-
-        enable_clocks(0);
 }
 
 static void _enable_digit_out(bool enable)
@@ -1978,12 +2100,8 @@ static void dispc_enable_digit_out(bool enable)
         struct completion frame_done_completion;
         int r;
 
-        enable_clocks(1);
-
-        if (REG_GET(DISPC_CONTROL, 1, 1) == enable) {
-                enable_clocks(0);
+        if (REG_GET(DISPC_CONTROL, 1, 1) == enable)
                 return;
-        }
 
         if (enable) {
                 unsigned long flags;
@@ -2035,8 +2153,6 @@ static void dispc_enable_digit_out(bool enable)
                 _omap_dispc_set_irqs();
                 spin_unlock_irqrestore(&dispc.irq_lock, flags);
         }
-
-        enable_clocks(0);
 }
 
 bool dispc_is_channel_enabled(enum omap_channel channel)
@@ -2067,9 +2183,7 @@ void dispc_lcd_enable_signal_polarity(bool act_high)
         if (!dss_has_feature(FEAT_LCDENABLEPOL))
                 return;
 
-        enable_clocks(1);
         REG_FLD_MOD(DISPC_CONTROL, act_high ? 1 : 0, 29, 29);
-        enable_clocks(0);
 }
 
 void dispc_lcd_enable_signal(bool enable)
@@ -2077,9 +2191,7 @@ void dispc_lcd_enable_signal(bool enable)
         if (!dss_has_feature(FEAT_LCDENABLESIGNAL))
                 return;
 
-        enable_clocks(1);
         REG_FLD_MOD(DISPC_CONTROL, enable ? 1 : 0, 28, 28);
-        enable_clocks(0);
 }
 
 void dispc_pck_free_enable(bool enable)
@@ -2087,19 +2199,15 @@ void dispc_pck_free_enable(bool enable)
         if (!dss_has_feature(FEAT_PCKFREEENABLE))
                 return;
 
-        enable_clocks(1);
         REG_FLD_MOD(DISPC_CONTROL, enable ? 1 : 0, 27, 27);
-        enable_clocks(0);
 }
 
 void dispc_enable_fifohandcheck(enum omap_channel channel, bool enable)
 {
-        enable_clocks(1);
         if (channel == OMAP_DSS_CHANNEL_LCD2)
                 REG_FLD_MOD(DISPC_CONFIG2, enable ? 1 : 0, 16, 16);
         else
                 REG_FLD_MOD(DISPC_CONFIG, enable ? 1 : 0, 16, 16);
-        enable_clocks(0);
 }
 
 
@@ -2122,27 +2230,21 @@ void dispc_set_lcd_display_type(enum omap_channel channel,
                 return;
         }
 
-        enable_clocks(1);
         if (channel == OMAP_DSS_CHANNEL_LCD2)
                 REG_FLD_MOD(DISPC_CONTROL2, mode, 3, 3);
         else
                 REG_FLD_MOD(DISPC_CONTROL, mode, 3, 3);
-        enable_clocks(0);
 }
 
 void dispc_set_loadmode(enum omap_dss_load_mode mode)
 {
-        enable_clocks(1);
         REG_FLD_MOD(DISPC_CONFIG, mode, 2, 1);
-        enable_clocks(0);
 }
 
 
 void dispc_set_default_color(enum omap_channel channel, u32 color)
 {
-        enable_clocks(1);
         dispc_write_reg(DISPC_DEFAULT_COLOR(channel), color);
-        enable_clocks(0);
 }
 
 u32 dispc_get_default_color(enum omap_channel channel)
@@ -2153,9 +2255,7 @@ u32 dispc_get_default_color(enum omap_channel channel)
                 channel != OMAP_DSS_CHANNEL_LCD &&
                 channel != OMAP_DSS_CHANNEL_LCD2);
 
-        enable_clocks(1);
         l = dispc_read_reg(DISPC_DEFAULT_COLOR(channel));
-        enable_clocks(0);
 
         return l;
 }
@@ -2164,7 +2264,6 @@ void dispc_set_trans_key(enum omap_channel ch,
                 enum omap_dss_trans_key_type type,
                 u32 trans_key)
 {
-        enable_clocks(1);
         if (ch == OMAP_DSS_CHANNEL_LCD)
                 REG_FLD_MOD(DISPC_CONFIG, type, 11, 11);
         else if (ch == OMAP_DSS_CHANNEL_DIGIT)
@@ -2173,14 +2272,12 @@ void dispc_set_trans_key(enum omap_channel ch,
                 REG_FLD_MOD(DISPC_CONFIG2, type, 11, 11);
 
         dispc_write_reg(DISPC_TRANS_COLOR(ch), trans_key);
-        enable_clocks(0);
 }
 
 void dispc_get_trans_key(enum omap_channel ch,
                 enum omap_dss_trans_key_type *type,
                 u32 *trans_key)
 {
-        enable_clocks(1);
         if (type) {
                 if (ch == OMAP_DSS_CHANNEL_LCD)
                         *type = REG_GET(DISPC_CONFIG, 11, 11);
@@ -2194,33 +2291,28 @@ void dispc_get_trans_key(enum omap_channel ch,
 
         if (trans_key)
                 *trans_key = dispc_read_reg(DISPC_TRANS_COLOR(ch));
-        enable_clocks(0);
 }
 
 void dispc_enable_trans_key(enum omap_channel ch, bool enable)
 {
-        enable_clocks(1);
         if (ch == OMAP_DSS_CHANNEL_LCD)
                 REG_FLD_MOD(DISPC_CONFIG, enable, 10, 10);
         else if (ch == OMAP_DSS_CHANNEL_DIGIT)
                 REG_FLD_MOD(DISPC_CONFIG, enable, 12, 12);
         else /* OMAP_DSS_CHANNEL_LCD2 */
                 REG_FLD_MOD(DISPC_CONFIG2, enable, 10, 10);
-        enable_clocks(0);
 }
 void dispc_enable_alpha_blending(enum omap_channel ch, bool enable)
 {
         if (!dss_has_feature(FEAT_GLOBAL_ALPHA))
                 return;
 
-        enable_clocks(1);
         if (ch == OMAP_DSS_CHANNEL_LCD)
                 REG_FLD_MOD(DISPC_CONFIG, enable, 18, 18);
         else if (ch == OMAP_DSS_CHANNEL_DIGIT)
                 REG_FLD_MOD(DISPC_CONFIG, enable, 19, 19);
         else /* OMAP_DSS_CHANNEL_LCD2 */
                 REG_FLD_MOD(DISPC_CONFIG2, enable, 18, 18);
-        enable_clocks(0);
 }
 bool dispc_alpha_blending_enabled(enum omap_channel ch)
 {
@@ -2229,7 +2321,6 @@ bool dispc_alpha_blending_enabled(enum omap_channel ch)
         if (!dss_has_feature(FEAT_GLOBAL_ALPHA))
                 return false;
 
-        enable_clocks(1);
         if (ch == OMAP_DSS_CHANNEL_LCD)
                 enabled = REG_GET(DISPC_CONFIG, 18, 18);
         else if (ch == OMAP_DSS_CHANNEL_DIGIT)
@@ -2238,7 +2329,6 @@ bool dispc_alpha_blending_enabled(enum omap_channel ch)
                 enabled = REG_GET(DISPC_CONFIG2, 18, 18);
         else
                 BUG();
-        enable_clocks(0);
 
         return enabled;
 }
@@ -2248,7 +2338,6 @@ bool dispc_trans_key_enabled(enum omap_channel ch)
 {
         bool enabled;
 
-        enable_clocks(1);
         if (ch == OMAP_DSS_CHANNEL_LCD)
                 enabled = REG_GET(DISPC_CONFIG, 10, 10);
         else if (ch == OMAP_DSS_CHANNEL_DIGIT)
@@ -2257,7 +2346,6 @@ bool dispc_trans_key_enabled(enum omap_channel ch)
                 enabled = REG_GET(DISPC_CONFIG2, 10, 10);
         else
                 BUG();
-        enable_clocks(0);
 
         return enabled;
 }
@@ -2285,12 +2373,10 @@ void dispc_set_tft_data_lines(enum omap_channel channel, u8 data_lines)
                 return;
         }
 
-        enable_clocks(1);
         if (channel == OMAP_DSS_CHANNEL_LCD2)
                 REG_FLD_MOD(DISPC_CONTROL2, code, 9, 8);
         else
                 REG_FLD_MOD(DISPC_CONTROL, code, 9, 8);
-        enable_clocks(0);
 }
 
 void dispc_set_parallel_interface_mode(enum omap_channel channel,
@@ -2322,8 +2408,6 @@ void dispc_set_parallel_interface_mode(enum omap_channel channel,
                 return;
         }
 
-        enable_clocks(1);
-
         if (channel == OMAP_DSS_CHANNEL_LCD2) {
                 l = dispc_read_reg(DISPC_CONTROL2);
                 l = FLD_MOD(l, stallmode, 11, 11);
@@ -2335,8 +2419,6 @@ void dispc_set_parallel_interface_mode(enum omap_channel channel,
                 l = FLD_MOD(l, gpout1, 16, 16);
                 dispc_write_reg(DISPC_CONTROL, l);
         }
-
-        enable_clocks(0);
 }
 
 static bool _dispc_lcd_timings_ok(int hsw, int hfp, int hbp,
@@ -2389,10 +2471,8 @@ static void _dispc_set_lcd_timings(enum omap_channel channel, int hsw,
                         FLD_VAL(vbp, 31, 20);
         }
 
-        enable_clocks(1);
         dispc_write_reg(DISPC_TIMING_H(channel), timing_h);
         dispc_write_reg(DISPC_TIMING_V(channel), timing_v);
-        enable_clocks(0);
 }
 
 /* change name to mode? */
@@ -2435,10 +2515,8 @@ static void dispc_set_lcd_divisor(enum omap_channel channel, u16 lck_div,
         BUG_ON(lck_div < 1);
         BUG_ON(pck_div < 2);
 
-        enable_clocks(1);
         dispc_write_reg(DISPC_DIVISORo(channel),
                         FLD_VAL(lck_div, 23, 16) | FLD_VAL(pck_div, 7, 0));
-        enable_clocks(0);
 }
 
 static void dispc_get_lcd_divisor(enum omap_channel channel, int *lck_div,
@@ -2457,7 +2535,7 @@ unsigned long dispc_fclk_rate(void)
 
         switch (dss_get_dispc_clk_source()) {
         case OMAP_DSS_CLK_SRC_FCK:
-                r = dss_clk_get_rate(DSS_CLK_FCK);
+                r = clk_get_rate(dispc.dss_clk);
                 break;
         case OMAP_DSS_CLK_SRC_DSI_PLL_HSDIV_DISPC:
                 dsidev = dsi_get_dsidev_from_id(0);
@@ -2487,7 +2565,7 @@ unsigned long dispc_lclk_rate(enum omap_channel channel)
 
         switch (dss_get_lcd_clk_source(channel)) {
         case OMAP_DSS_CLK_SRC_FCK:
-                r = dss_clk_get_rate(DSS_CLK_FCK);
+                r = clk_get_rate(dispc.dss_clk);
                 break;
         case OMAP_DSS_CLK_SRC_DSI_PLL_HSDIV_DISPC:
                 dsidev = dsi_get_dsidev_from_id(0);
@@ -2526,7 +2604,8 @@ void dispc_dump_clocks(struct seq_file *s)
         enum omap_dss_clk_source dispc_clk_src = dss_get_dispc_clk_source();
         enum omap_dss_clk_source lcd_clk_src;
 
-        enable_clocks(1);
+        if (dispc_runtime_get())
+                return;
 
         seq_printf(s, "- DISPC -\n");
 
@@ -2574,7 +2653,8 @@ void dispc_dump_clocks(struct seq_file *s)
                 seq_printf(s, "pck\t\t%-16lupck div\t%u\n",
                                 dispc_pclk_rate(OMAP_DSS_CHANNEL_LCD2), pcd);
         }
-        enable_clocks(0);
+
+        dispc_runtime_put();
 }
 
 #ifdef CONFIG_OMAP2_DSS_COLLECT_IRQ_STATS
@@ -2629,7 +2709,8 @@ void dispc_dump_regs(struct seq_file *s)
 {
 #define DUMPREG(r) seq_printf(s, "%-50s %08x\n", #r, dispc_read_reg(r))
 
-        dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK);
+        if (dispc_runtime_get())
+                return;
 
         DUMPREG(DISPC_REVISION);
         DUMPREG(DISPC_SYSCONFIG);
@@ -2649,7 +2730,8 @@ void dispc_dump_regs(struct seq_file *s)
         DUMPREG(DISPC_TIMING_V(OMAP_DSS_CHANNEL_LCD));
         DUMPREG(DISPC_POL_FREQ(OMAP_DSS_CHANNEL_LCD));
         DUMPREG(DISPC_DIVISORo(OMAP_DSS_CHANNEL_LCD));
-        DUMPREG(DISPC_GLOBAL_ALPHA);
+        if (dss_has_feature(FEAT_GLOBAL_ALPHA))
+                DUMPREG(DISPC_GLOBAL_ALPHA);
         DUMPREG(DISPC_SIZE_MGR(OMAP_DSS_CHANNEL_DIGIT));
         DUMPREG(DISPC_SIZE_MGR(OMAP_DSS_CHANNEL_LCD));
         if (dss_has_feature(FEAT_MGR_LCD2)) {
@@ -2680,20 +2762,25 @@ void dispc_dump_regs(struct seq_file *s)
         DUMPREG(DISPC_DATA_CYCLE2(OMAP_DSS_CHANNEL_LCD));
         DUMPREG(DISPC_DATA_CYCLE3(OMAP_DSS_CHANNEL_LCD));
 
-        DUMPREG(DISPC_CPR_COEF_R(OMAP_DSS_CHANNEL_LCD));
-        DUMPREG(DISPC_CPR_COEF_G(OMAP_DSS_CHANNEL_LCD));
-        DUMPREG(DISPC_CPR_COEF_B(OMAP_DSS_CHANNEL_LCD));
+        if (dss_has_feature(FEAT_CPR)) {
+                DUMPREG(DISPC_CPR_COEF_R(OMAP_DSS_CHANNEL_LCD));
+                DUMPREG(DISPC_CPR_COEF_G(OMAP_DSS_CHANNEL_LCD));
+                DUMPREG(DISPC_CPR_COEF_B(OMAP_DSS_CHANNEL_LCD));
+        }
         if (dss_has_feature(FEAT_MGR_LCD2)) {
                 DUMPREG(DISPC_DATA_CYCLE1(OMAP_DSS_CHANNEL_LCD2));
                 DUMPREG(DISPC_DATA_CYCLE2(OMAP_DSS_CHANNEL_LCD2));
                 DUMPREG(DISPC_DATA_CYCLE3(OMAP_DSS_CHANNEL_LCD2));
 
-                DUMPREG(DISPC_CPR_COEF_R(OMAP_DSS_CHANNEL_LCD2));
-                DUMPREG(DISPC_CPR_COEF_G(OMAP_DSS_CHANNEL_LCD2));
-                DUMPREG(DISPC_CPR_COEF_B(OMAP_DSS_CHANNEL_LCD2));
+                if (dss_has_feature(FEAT_CPR)) {
+                        DUMPREG(DISPC_CPR_COEF_R(OMAP_DSS_CHANNEL_LCD2));
+                        DUMPREG(DISPC_CPR_COEF_G(OMAP_DSS_CHANNEL_LCD2));
+                        DUMPREG(DISPC_CPR_COEF_B(OMAP_DSS_CHANNEL_LCD2));
+                }
         }
 
-        DUMPREG(DISPC_OVL_PRELOAD(OMAP_DSS_GFX));
+        if (dss_has_feature(FEAT_PRELOAD))
+                DUMPREG(DISPC_OVL_PRELOAD(OMAP_DSS_GFX));
 
         DUMPREG(DISPC_OVL_BA0(OMAP_DSS_VIDEO1));
         DUMPREG(DISPC_OVL_BA1(OMAP_DSS_VIDEO1));
@@ -2744,14 +2831,16 @@ void dispc_dump_regs(struct seq_file *s)
         DUMPREG(DISPC_OVL_CONV_COEF(OMAP_DSS_VIDEO1, 2));
         DUMPREG(DISPC_OVL_CONV_COEF(OMAP_DSS_VIDEO1, 3));
         DUMPREG(DISPC_OVL_CONV_COEF(OMAP_DSS_VIDEO1, 4));
-        DUMPREG(DISPC_OVL_FIR_COEF_V(OMAP_DSS_VIDEO1, 0));
-        DUMPREG(DISPC_OVL_FIR_COEF_V(OMAP_DSS_VIDEO1, 1));
-        DUMPREG(DISPC_OVL_FIR_COEF_V(OMAP_DSS_VIDEO1, 2));
-        DUMPREG(DISPC_OVL_FIR_COEF_V(OMAP_DSS_VIDEO1, 3));
-        DUMPREG(DISPC_OVL_FIR_COEF_V(OMAP_DSS_VIDEO1, 4));
-        DUMPREG(DISPC_OVL_FIR_COEF_V(OMAP_DSS_VIDEO1, 5));
-        DUMPREG(DISPC_OVL_FIR_COEF_V(OMAP_DSS_VIDEO1, 6));
-        DUMPREG(DISPC_OVL_FIR_COEF_V(OMAP_DSS_VIDEO1, 7));
+        if (dss_has_feature(FEAT_FIR_COEF_V)) {
+                DUMPREG(DISPC_OVL_FIR_COEF_V(OMAP_DSS_VIDEO1, 0));
+                DUMPREG(DISPC_OVL_FIR_COEF_V(OMAP_DSS_VIDEO1, 1));
+                DUMPREG(DISPC_OVL_FIR_COEF_V(OMAP_DSS_VIDEO1, 2));
+                DUMPREG(DISPC_OVL_FIR_COEF_V(OMAP_DSS_VIDEO1, 3));
+                DUMPREG(DISPC_OVL_FIR_COEF_V(OMAP_DSS_VIDEO1, 4));
+                DUMPREG(DISPC_OVL_FIR_COEF_V(OMAP_DSS_VIDEO1, 5));
+                DUMPREG(DISPC_OVL_FIR_COEF_V(OMAP_DSS_VIDEO1, 6));
+                DUMPREG(DISPC_OVL_FIR_COEF_V(OMAP_DSS_VIDEO1, 7));
+        }
 
         if (dss_has_feature(FEAT_HANDLE_UV_SEPARATE)) {
                 DUMPREG(DISPC_OVL_BA0_UV(OMAP_DSS_VIDEO1));
@@ -2812,14 +2901,17 @@ void dispc_dump_regs(struct seq_file *s)
         DUMPREG(DISPC_OVL_CONV_COEF(OMAP_DSS_VIDEO2, 2));
         DUMPREG(DISPC_OVL_CONV_COEF(OMAP_DSS_VIDEO2, 3));
         DUMPREG(DISPC_OVL_CONV_COEF(OMAP_DSS_VIDEO2, 4));
-        DUMPREG(DISPC_OVL_FIR_COEF_V(OMAP_DSS_VIDEO2, 0));
-        DUMPREG(DISPC_OVL_FIR_COEF_V(OMAP_DSS_VIDEO2, 1));
-        DUMPREG(DISPC_OVL_FIR_COEF_V(OMAP_DSS_VIDEO2, 2));
-        DUMPREG(DISPC_OVL_FIR_COEF_V(OMAP_DSS_VIDEO2, 3));
-        DUMPREG(DISPC_OVL_FIR_COEF_V(OMAP_DSS_VIDEO2, 4));
-        DUMPREG(DISPC_OVL_FIR_COEF_V(OMAP_DSS_VIDEO2, 5));
-        DUMPREG(DISPC_OVL_FIR_COEF_V(OMAP_DSS_VIDEO2, 6));
-        DUMPREG(DISPC_OVL_FIR_COEF_V(OMAP_DSS_VIDEO2, 7));
+
+        if (dss_has_feature(FEAT_FIR_COEF_V)) {
+                DUMPREG(DISPC_OVL_FIR_COEF_V(OMAP_DSS_VIDEO2, 0));
+                DUMPREG(DISPC_OVL_FIR_COEF_V(OMAP_DSS_VIDEO2, 1));
+                DUMPREG(DISPC_OVL_FIR_COEF_V(OMAP_DSS_VIDEO2, 2));
+                DUMPREG(DISPC_OVL_FIR_COEF_V(OMAP_DSS_VIDEO2, 3));
+                DUMPREG(DISPC_OVL_FIR_COEF_V(OMAP_DSS_VIDEO2, 4));
+                DUMPREG(DISPC_OVL_FIR_COEF_V(OMAP_DSS_VIDEO2, 5));
+                DUMPREG(DISPC_OVL_FIR_COEF_V(OMAP_DSS_VIDEO2, 6));
+                DUMPREG(DISPC_OVL_FIR_COEF_V(OMAP_DSS_VIDEO2, 7));
+        }
 
         if (dss_has_feature(FEAT_HANDLE_UV_SEPARATE)) {
                 DUMPREG(DISPC_OVL_BA0_UV(OMAP_DSS_VIDEO2));
@@ -2858,10 +2950,12 @@ void dispc_dump_regs(struct seq_file *s)
         if (dss_has_feature(FEAT_ATTR2))
                 DUMPREG(DISPC_OVL_ATTRIBUTES2(OMAP_DSS_VIDEO2));
 
-        DUMPREG(DISPC_OVL_PRELOAD(OMAP_DSS_VIDEO1));
-        DUMPREG(DISPC_OVL_PRELOAD(OMAP_DSS_VIDEO2));
+        if (dss_has_feature(FEAT_PRELOAD)) {
+                DUMPREG(DISPC_OVL_PRELOAD(OMAP_DSS_VIDEO1));
+                DUMPREG(DISPC_OVL_PRELOAD(OMAP_DSS_VIDEO2));
+        }
 
-        dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK);
+        dispc_runtime_put();
 #undef DUMPREG
 }
 
@@ -2882,9 +2976,7 @@ static void _dispc_set_pol_freq(enum omap_channel channel, bool onoff, bool rf,
         l |= FLD_VAL(acbi, 11, 8);
         l |= FLD_VAL(acb, 7, 0);
 
-        enable_clocks(1);
         dispc_write_reg(DISPC_POL_FREQ(channel), l);
-        enable_clocks(0);
 }
 
 void dispc_set_pol_freq(enum omap_channel channel,
@@ -3005,15 +3097,11 @@ static void _omap_dispc_set_irqs(void)
                 mask |= isr_data->mask;
         }
 
-        enable_clocks(1);
-
         old_mask = dispc_read_reg(DISPC_IRQENABLE);
         /* clear the irqstatus for newly enabled irqs */
         dispc_write_reg(DISPC_IRQSTATUS, (mask ^ old_mask) & mask);
 
         dispc_write_reg(DISPC_IRQENABLE, mask);
-
-        enable_clocks(0);
 }
 
 int omap_dispc_register_isr(omap_dispc_isr_t isr, void *arg, u32 mask)
@@ -3522,13 +3610,6 @@ static void _omap_dispc_initial_config(void)
 {
         u32 l;
 
-        l = dispc_read_reg(DISPC_SYSCONFIG);
-        l = FLD_MOD(l, 2, 13, 12);      /* MIDLEMODE: smart standby */
-        l = FLD_MOD(l, 2, 4, 3);        /* SIDLEMODE: smart idle */
-        l = FLD_MOD(l, 1, 2, 2);        /* ENWAKEUP */
-        l = FLD_MOD(l, 1, 0, 0);        /* AUTOIDLE */
-        dispc_write_reg(DISPC_SYSCONFIG, l);
-
         /* Exclusively enable DISPC_CORE_CLK and set divider to 1 */
         if (dss_has_feature(FEAT_CORE_CLK_DIV)) {
                 l = dispc_read_reg(DISPC_DIVISOR);
@@ -3552,58 +3633,8 @@ static void _omap_dispc_initial_config(void)
         dispc_set_loadmode(OMAP_DSS_LOAD_FRAME_ONLY);
 
         dispc_read_plane_fifo_sizes();
-}
 
-int dispc_enable_plane(enum omap_plane plane, bool enable)
-{
-        DSSDBG("dispc_enable_plane %d, %d\n", plane, enable);
-
-        enable_clocks(1);
-        _dispc_enable_plane(plane, enable);
-        enable_clocks(0);
-
-        return 0;
-}
-
-int dispc_setup_plane(enum omap_plane plane,
-                       u32 paddr, u16 screen_width,
-                       u16 pos_x, u16 pos_y,
-                       u16 width, u16 height,
-                       u16 out_width, u16 out_height,
-                       enum omap_color_mode color_mode,
-                       bool ilace,
-                       enum omap_dss_rotation_type rotation_type,
-                       u8 rotation, bool mirror, u8 global_alpha,
-                       u8 pre_mult_alpha, enum omap_channel channel,
-                       u32 puv_addr)
-{
-        int r = 0;
-
-        DSSDBG("dispc_setup_plane %d, pa %x, sw %d, %d, %d, %dx%d -> "
-               "%dx%d, ilace %d, cmode %x, rot %d, mir %d chan %d\n",
-               plane, paddr, screen_width, pos_x, pos_y,
-               width, height,
-               out_width, out_height,
-               ilace, color_mode,
-               rotation, mirror, channel);
-
-        enable_clocks(1);
-
-        r = _dispc_setup_plane(plane,
-                           paddr, screen_width,
-                           pos_x, pos_y,
-                           width, height,
-                           out_width, out_height,
-                           color_mode, ilace,
-                           rotation_type,
-                           rotation, mirror,
-                           global_alpha,
-                           pre_mult_alpha,
-                           channel, puv_addr);
-
-        enable_clocks(0);
-
-        return r;
+        dispc_configure_burst_sizes();
 }
 
 /* DISPC HW IP initialisation */
@@ -3612,9 +3643,19 @@ static int omap_dispchw_probe(struct platform_device *pdev)
         u32 rev;
         int r = 0;
         struct resource *dispc_mem;
+        struct clk *clk;
 
         dispc.pdev = pdev;
 
+        clk = clk_get(&pdev->dev, "fck");
+        if (IS_ERR(clk)) {
+                DSSERR("can't get fck\n");
+                r = PTR_ERR(clk);
+                goto err_get_clk;
+        }
+
+        dispc.dss_clk = clk;
+
         spin_lock_init(&dispc.irq_lock);
 
 #ifdef CONFIG_OMAP2_DSS_COLLECT_IRQ_STATS
@@ -3628,62 +3669,103 @@ static int omap_dispchw_probe(struct platform_device *pdev)
         if (!dispc_mem) {
                 DSSERR("can't get IORESOURCE_MEM DISPC\n");
                 r = -EINVAL;
-                goto fail0;
+                goto err_ioremap;
         }
         dispc.base = ioremap(dispc_mem->start, resource_size(dispc_mem));
         if (!dispc.base) {
                 DSSERR("can't ioremap DISPC\n");
                 r = -ENOMEM;
-                goto fail0;
+                goto err_ioremap;
         }
         dispc.irq = platform_get_irq(dispc.pdev, 0);
         if (dispc.irq < 0) {
                 DSSERR("platform_get_irq failed\n");
                 r = -ENODEV;
-                goto fail1;
+                goto err_irq;
         }
 
         r = request_irq(dispc.irq, omap_dispc_irq_handler, IRQF_SHARED,
                 "OMAP DISPC", dispc.pdev);
         if (r < 0) {
                 DSSERR("request_irq failed\n");
-                goto fail1;
+                goto err_irq;
         }
 
-        enable_clocks(1);
+        pm_runtime_enable(&pdev->dev);
+
+        r = dispc_runtime_get();
+        if (r)
+                goto err_runtime_get;
 
         _omap_dispc_initial_config();
 
         _omap_dispc_initialize_irq();
 
-        dispc_save_context();
-
         rev = dispc_read_reg(DISPC_REVISION);
         dev_dbg(&pdev->dev, "OMAP DISPC rev %d.%d\n",
                FLD_GET(rev, 7, 4), FLD_GET(rev, 3, 0));
 
-        enable_clocks(0);
+        dispc_runtime_put();
 
         return 0;
-fail1:
+
+err_runtime_get:
+        pm_runtime_disable(&pdev->dev);
+        free_irq(dispc.irq, dispc.pdev);
+err_irq:
         iounmap(dispc.base);
-fail0:
+err_ioremap:
+        clk_put(dispc.dss_clk);
+err_get_clk:
         return r;
 }
 
 static int omap_dispchw_remove(struct platform_device *pdev)
 {
+        pm_runtime_disable(&pdev->dev);
+
+        clk_put(dispc.dss_clk);
+
         free_irq(dispc.irq, dispc.pdev);
         iounmap(dispc.base);
         return 0;
 }
 
+static int dispc_runtime_suspend(struct device *dev)
+{
+        dispc_save_context();
+        clk_disable(dispc.dss_clk);
+        dss_runtime_put();
+
+        return 0;
+}
+
+static int dispc_runtime_resume(struct device *dev)
+{
+        int r;
+
+        r = dss_runtime_get();
+        if (r < 0)
+                return r;
+
+        clk_enable(dispc.dss_clk);
+        dispc_restore_context();
+
+        return 0;
+}
+
+static const struct dev_pm_ops dispc_pm_ops = {
+        .runtime_suspend = dispc_runtime_suspend,
+        .runtime_resume = dispc_runtime_resume,
+};
+
 static struct platform_driver omap_dispchw_driver = {
         .probe          = omap_dispchw_probe,
         .remove         = omap_dispchw_remove,
         .driver         = {
                 .name   = "omapdss_dispc",
                 .owner  = THIS_MODULE,
+                .pm     = &dispc_pm_ops,
         },
 };
 
diff --git a/drivers/video/omap2/dss/display.c b/drivers/video/omap2/dss/display.c
index c2dfc8c50057..94495e45ec5a 100644
--- a/drivers/video/omap2/dss/display.c
+++ b/drivers/video/omap2/dss/display.c
@@ -29,6 +29,7 @@
 
 #include <video/omapdss.h>
 #include "dss.h"
+#include "dss_features.h"
 
 static ssize_t display_enabled_show(struct device *dev,
                 struct device_attribute *attr, char *buf)
@@ -65,48 +66,6 @@ static ssize_t display_enabled_store(struct device *dev,
         return size;
 }
 
-static ssize_t display_upd_mode_show(struct device *dev,
-                struct device_attribute *attr, char *buf)
-{
-        struct omap_dss_device *dssdev = to_dss_device(dev);
-        enum omap_dss_update_mode mode = OMAP_DSS_UPDATE_AUTO;
-        if (dssdev->driver->get_update_mode)
-                mode = dssdev->driver->get_update_mode(dssdev);
-        return snprintf(buf, PAGE_SIZE, "%d\n", mode);
-}
-
-static ssize_t display_upd_mode_store(struct device *dev,
-                struct device_attribute *attr,
-                const char *buf, size_t size)
-{
-        struct omap_dss_device *dssdev = to_dss_device(dev);
-        int val, r;
-        enum omap_dss_update_mode mode;
-
-        if (!dssdev->driver->set_update_mode)
-                return -EINVAL;
-
-        r = kstrtoint(buf, 0, &val);
-        if (r)
-                return r;
-
-        switch (val) {
-        case OMAP_DSS_UPDATE_DISABLED:
-        case OMAP_DSS_UPDATE_AUTO:
-        case OMAP_DSS_UPDATE_MANUAL:
-                mode = (enum omap_dss_update_mode)val;
-                break;
-        default:
-                return -EINVAL;
-        }
-
-        r = dssdev->driver->set_update_mode(dssdev, mode);
-        if (r)
-                return r;
-
-        return size;
-}
-
 static ssize_t display_tear_show(struct device *dev,
                 struct device_attribute *attr, char *buf)
 {
@@ -294,8 +253,6 @@ static ssize_t display_wss_store(struct device *dev,
 
 static DEVICE_ATTR(enabled, S_IRUGO|S_IWUSR,
                 display_enabled_show, display_enabled_store);
-static DEVICE_ATTR(update_mode, S_IRUGO|S_IWUSR,
-                display_upd_mode_show, display_upd_mode_store);
 static DEVICE_ATTR(tear_elim, S_IRUGO|S_IWUSR,
                 display_tear_show, display_tear_store);
 static DEVICE_ATTR(timings, S_IRUGO|S_IWUSR,
@@ -309,7 +266,6 @@ static DEVICE_ATTR(wss, S_IRUGO|S_IWUSR,
 
 static struct device_attribute *display_sysfs_attrs[] = {
         &dev_attr_enabled,
-        &dev_attr_update_mode,
         &dev_attr_tear_elim,
         &dev_attr_timings,
         &dev_attr_rotate,
@@ -327,16 +283,13 @@ void omapdss_default_get_resolution(struct omap_dss_device *dssdev,
 EXPORT_SYMBOL(omapdss_default_get_resolution);
 
 void default_get_overlay_fifo_thresholds(enum omap_plane plane,
-                u32 fifo_size, enum omap_burst_size *burst_size,
+                u32 fifo_size, u32 burst_size,
                 u32 *fifo_low, u32 *fifo_high)
 {
-        unsigned burst_size_bytes;
-
-        *burst_size = OMAP_DSS_BURST_16x32;
-        burst_size_bytes = 16 * 32 / 8;
+        unsigned buf_unit = dss_feat_get_buffer_size_unit();
 
-        *fifo_high = fifo_size - 1;
-        *fifo_low = fifo_size - burst_size_bytes;
+        *fifo_high = fifo_size - buf_unit;
+        *fifo_low = fifo_size - burst_size;
 }
 
 int omapdss_default_get_recommended_bpp(struct omap_dss_device *dssdev)
diff --git a/drivers/video/omap2/dss/dpi.c b/drivers/video/omap2/dss/dpi.c
index ff6bd30132df..f053b180ecd7 100644
--- a/drivers/video/omap2/dss/dpi.c
+++ b/drivers/video/omap2/dss/dpi.c
@@ -23,7 +23,6 @@
 #define DSS_SUBSYS_NAME "DPI"
 
 #include <linux/kernel.h>
-#include <linux/clk.h>
 #include <linux/delay.h>
 #include <linux/err.h>
 #include <linux/errno.h>
@@ -130,8 +129,6 @@ static int dpi_set_mode(struct omap_dss_device *dssdev)
         bool is_tft;
         int r = 0;
 
-        dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK);
-
         dispc_set_pol_freq(dssdev->manager->id, dssdev->panel.config,
                         dssdev->panel.acbi, dssdev->panel.acb);
 
@@ -144,7 +141,7 @@ static int dpi_set_mode(struct omap_dss_device *dssdev)
                 r = dpi_set_dispc_clk(dssdev, is_tft, t->pixel_clock * 1000,
                                 &fck, &lck_div, &pck_div);
         if (r)
-                goto err0;
+                return r;
 
         pck = fck / lck_div / pck_div / 1000;
 
@@ -158,12 +155,10 @@ static int dpi_set_mode(struct omap_dss_device *dssdev)
 
         dispc_set_lcd_timings(dssdev->manager->id, t);
 
-err0:
-        dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK);
-        return r;
+        return 0;
 }
 
-static int dpi_basic_init(struct omap_dss_device *dssdev)
+static void dpi_basic_init(struct omap_dss_device *dssdev)
 {
         bool is_tft;
 
@@ -175,8 +170,6 @@ static int dpi_basic_init(struct omap_dss_device *dssdev)
                         OMAP_DSS_LCD_DISPLAY_TFT : OMAP_DSS_LCD_DISPLAY_STN);
         dispc_set_tft_data_lines(dssdev->manager->id,
                         dssdev->phy.dpi.data_lines);
-
-        return 0;
 }
 
 int omapdss_dpi_display_enable(struct omap_dss_device *dssdev)
@@ -186,31 +179,38 @@ int omapdss_dpi_display_enable(struct omap_dss_device *dssdev)
         r = omap_dss_start_device(dssdev);
         if (r) {
                 DSSERR("failed to start device\n");
-                goto err0;
+                goto err_start_dev;
         }
 
         if (cpu_is_omap34xx()) {
                 r = regulator_enable(dpi.vdds_dsi_reg);
                 if (r)
-                        goto err1;
+                        goto err_reg_enable;
         }
 
-        dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK);
+        r = dss_runtime_get();
+        if (r)
+                goto err_get_dss;
 
-        r = dpi_basic_init(dssdev);
+        r = dispc_runtime_get();
         if (r)
-                goto err2;
+                goto err_get_dispc;
+
+        dpi_basic_init(dssdev);
 
         if (dpi_use_dsi_pll(dssdev)) {
-                dss_clk_enable(DSS_CLK_SYSCK);
+                r = dsi_runtime_get(dpi.dsidev);
+                if (r)
+                        goto err_get_dsi;
+
                 r = dsi_pll_init(dpi.dsidev, 0, 1);
                 if (r)
-                        goto err3;
+                        goto err_dsi_pll_init;
         }
 
         r = dpi_set_mode(dssdev);
         if (r)
-                goto err4;
+                goto err_set_mode;
 
         mdelay(2);
 
@@ -218,19 +218,22 @@ int omapdss_dpi_display_enable(struct omap_dss_device *dssdev)
 
         return 0;
 
-err4:
+err_set_mode:
         if (dpi_use_dsi_pll(dssdev))
                 dsi_pll_uninit(dpi.dsidev, true);
-err3:
+err_dsi_pll_init:
         if (dpi_use_dsi_pll(dssdev))
-                dss_clk_disable(DSS_CLK_SYSCK);
-err2:
-        dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK);
+                dsi_runtime_put(dpi.dsidev);
+err_get_dsi:
+        dispc_runtime_put();
+err_get_dispc:
+        dss_runtime_put();
+err_get_dss:
         if (cpu_is_omap34xx())
                 regulator_disable(dpi.vdds_dsi_reg);
-err1:
+err_reg_enable:
         omap_dss_stop_device(dssdev);
-err0:
+err_start_dev:
         return r;
 }
 EXPORT_SYMBOL(omapdss_dpi_display_enable);
@@ -242,10 +245,11 @@ void omapdss_dpi_display_disable(struct omap_dss_device *dssdev)
         if (dpi_use_dsi_pll(dssdev)) {
                 dss_select_dispc_clk_source(OMAP_DSS_CLK_SRC_FCK);
                 dsi_pll_uninit(dpi.dsidev, true);
-                dss_clk_disable(DSS_CLK_SYSCK);
+                dsi_runtime_put(dpi.dsidev);
         }
 
-        dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK);
+        dispc_runtime_put();
+        dss_runtime_put();
 
         if (cpu_is_omap34xx())
                 regulator_disable(dpi.vdds_dsi_reg);
@@ -257,11 +261,26 @@ EXPORT_SYMBOL(omapdss_dpi_display_disable);
 void dpi_set_timings(struct omap_dss_device *dssdev,
                         struct omap_video_timings *timings)
 {
+        int r;
+
         DSSDBG("dpi_set_timings\n");
         dssdev->panel.timings = *timings;
         if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE) {
+                r = dss_runtime_get();
+                if (r)
+                        return;
+
+                r = dispc_runtime_get();
+                if (r) {
+                        dss_runtime_put();
+                        return;
+                }
+
                 dpi_set_mode(dssdev);
                 dispc_go(dssdev->manager->id);
+
+                dispc_runtime_put();
+                dss_runtime_put();
         }
 }
 EXPORT_SYMBOL(dpi_set_timings);
diff --git a/drivers/video/omap2/dss/dsi.c b/drivers/video/omap2/dss/dsi.c
index 345757cfcbee..7adbbeb84334 100644
--- a/drivers/video/omap2/dss/dsi.c
+++ b/drivers/video/omap2/dss/dsi.c
@@ -36,6 +36,7 @@
 #include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/debugfs.h>
+#include <linux/pm_runtime.h>
 
 #include <video/omapdss.h>
 #include <plat/clock.h>
@@ -267,8 +268,12 @@ struct dsi_isr_tables {
 struct dsi_data {
         struct platform_device *pdev;
         void __iomem    *base;
+
         int irq;
 
+        struct clk *dss_clk;
+        struct clk *sys_clk;
+
         void (*dsi_mux_pads)(bool enable);
 
         struct dsi_clock_info current_cinfo;
@@ -389,15 +394,6 @@ static inline u32 dsi_read_reg(struct platform_device *dsidev,
         return __raw_readl(dsi->base + idx.idx);
 }
 
-
-void dsi_save_context(void)
-{
-}
-
-void dsi_restore_context(void)
-{
-}
-
 void dsi_bus_lock(struct omap_dss_device *dssdev)
 {
         struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
@@ -493,9 +489,18 @@ static void dsi_perf_show(struct platform_device *dsidev, const char *name)
                         total_bytes * 1000 / total_us);
 }
 #else
-#define dsi_perf_mark_setup(x)
-#define dsi_perf_mark_start(x)
-#define dsi_perf_show(x, y)
+static inline void dsi_perf_mark_setup(struct platform_device *dsidev)
+{
+}
+
+static inline void dsi_perf_mark_start(struct platform_device *dsidev)
+{
+}
+
+static inline void dsi_perf_show(struct platform_device *dsidev,
+                const char *name)
+{
+}
 #endif
 
 static void print_irq_status(u32 status)
@@ -1039,13 +1044,27 @@ static u32 dsi_get_errors(struct platform_device *dsidev)
         return e;
 }
 
-/* DSI func clock. this could also be dsi_pll_hsdiv_dsi_clk */
-static inline void enable_clocks(bool enable)
+int dsi_runtime_get(struct platform_device *dsidev)
 {
-        if (enable)
-                dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK);
-        else
-                dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK);
+        int r;
+        struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
+
+        DSSDBG("dsi_runtime_get\n");
+
+        r = pm_runtime_get_sync(&dsi->pdev->dev);
+        WARN_ON(r < 0);
+        return r < 0 ? r : 0;
+}
+
+void dsi_runtime_put(struct platform_device *dsidev)
+{
+        struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
+        int r;
+
+        DSSDBG("dsi_runtime_put\n");
+
+        r = pm_runtime_put(&dsi->pdev->dev);
+        WARN_ON(r < 0);
 }
 
 /* source clock for DSI PLL. this could also be PCLKFREE */
@@ -1055,9 +1074,9 @@ static inline void dsi_enable_pll_clock(struct platform_device *dsidev,
         struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
 
         if (enable)
-                dss_clk_enable(DSS_CLK_SYSCK);
+                clk_enable(dsi->sys_clk);
         else
-                dss_clk_disable(DSS_CLK_SYSCK);
+                clk_disable(dsi->sys_clk);
 
         if (enable && dsi->pll_locked) {
                 if (wait_for_bit_change(dsidev, DSI_PLL_STATUS, 1, 1) != 1)
@@ -1150,10 +1169,11 @@ static unsigned long dsi_fclk_rate(struct platform_device *dsidev)
 {
         unsigned long r;
         int dsi_module = dsi_get_dsidev_id(dsidev);
+        struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
 
         if (dss_get_dsi_clk_source(dsi_module) == OMAP_DSS_CLK_SRC_FCK) {
                 /* DSI FCLK source is DSS_CLK_FCK */
-                r = dss_clk_get_rate(DSS_CLK_FCK);
+                r = clk_get_rate(dsi->dss_clk);
         } else {
                 /* DSI FCLK source is dsi_pll_hsdiv_dsi_clk */
                 r = dsi_get_pll_hsdiv_dsi_rate(dsidev);
@@ -1262,7 +1282,7 @@ static int dsi_calc_clock_rates(struct omap_dss_device *dssdev,
                 return -EINVAL;
 
         if (cinfo->use_sys_clk) {
-                cinfo->clkin = dss_clk_get_rate(DSS_CLK_SYSCK);
+                cinfo->clkin = clk_get_rate(dsi->sys_clk);
                 /* XXX it is unclear if highfreq should be used
                  * with DSS_SYS_CLK source also */
                 cinfo->highfreq = 0;
@@ -1311,7 +1331,7 @@ int dsi_pll_calc_clock_div_pck(struct platform_device *dsidev, bool is_tft,
         int match = 0;
         unsigned long dss_sys_clk, max_dss_fck;
 
-        dss_sys_clk = dss_clk_get_rate(DSS_CLK_SYSCK);
+        dss_sys_clk = clk_get_rate(dsi->sys_clk);
 
         max_dss_fck = dss_feat_get_param_max(FEAT_PARAM_DSS_FCK);
 
@@ -1601,7 +1621,6 @@ int dsi_pll_init(struct platform_device *dsidev, bool enable_hsclk,
                 dsi->vdds_dsi_reg = vdds_dsi;
         }
 
-        enable_clocks(1);
         dsi_enable_pll_clock(dsidev, 1);
         /*
          * Note: SCP CLK is not required on OMAP3, but it is required on OMAP4.
@@ -1653,7 +1672,6 @@ err1:
         }
 err0:
         dsi_disable_scp_clk(dsidev);
-        enable_clocks(0);
         dsi_enable_pll_clock(dsidev, 0);
         return r;
 }
@@ -1671,7 +1689,6 @@ void dsi_pll_uninit(struct platform_device *dsidev, bool disconnect_lanes)
         }
 
         dsi_disable_scp_clk(dsidev);
-        enable_clocks(0);
         dsi_enable_pll_clock(dsidev, 0);
 
         DSSDBG("PLL uninit done\n");
@@ -1688,7 +1705,8 @@ static void dsi_dump_dsidev_clocks(struct platform_device *dsidev,
         dispc_clk_src = dss_get_dispc_clk_source();
         dsi_clk_src = dss_get_dsi_clk_source(dsi_module);
 
-        enable_clocks(1);
+        if (dsi_runtime_get(dsidev))
+                return;
 
         seq_printf(s,   "- DSI%d PLL -\n", dsi_module + 1);
 
@@ -1731,7 +1749,7 @@ static void dsi_dump_dsidev_clocks(struct platform_device *dsidev,
 
         seq_printf(s,   "LP_CLK\t\t%lu\n", cinfo->lp_clk);
 
-        enable_clocks(0);
+        dsi_runtime_put(dsidev);
 }
 
 void dsi_dump_clocks(struct seq_file *s)
@@ -1873,7 +1891,8 @@ static void dsi_dump_dsidev_regs(struct platform_device *dsidev,
 {
 #define DUMPREG(r) seq_printf(s, "%-35s %08x\n", #r, dsi_read_reg(dsidev, r))
 
-        dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK);
+        if (dsi_runtime_get(dsidev))
+                return;
         dsi_enable_scp_clk(dsidev);
 
         DUMPREG(DSI_REVISION);
@@ -1947,7 +1966,7 @@ static void dsi_dump_dsidev_regs(struct platform_device *dsidev,
         DUMPREG(DSI_PLL_CONFIGURATION2);
 
         dsi_disable_scp_clk(dsidev);
-        dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK);
+        dsi_runtime_put(dsidev);
 #undef DUMPREG
 }
 
@@ -2463,28 +2482,6 @@ static void dsi_cio_uninit(struct platform_device *dsidev)
                 dsi->dsi_mux_pads(false);
 }
 
-static int _dsi_wait_reset(struct platform_device *dsidev)
-{
-        int t = 0;
-
-        while (REG_GET(dsidev, DSI_SYSSTATUS, 0, 0) == 0) {
-                if (++t > 5) {
-                        DSSERR("soft reset failed\n");
-                        return -ENODEV;
-                }
-                udelay(1);
-        }
-
-        return 0;
-}
-
-static int _dsi_reset(struct platform_device *dsidev)
-{
-        /* Soft reset */
-        REG_FLD_MOD(dsidev, DSI_SYSCONFIG, 1, 1, 1);
-        return _dsi_wait_reset(dsidev);
-}
-
 static void dsi_config_tx_fifo(struct platform_device *dsidev,
                 enum fifo_size size1, enum fifo_size size2,
                 enum fifo_size size3, enum fifo_size size4)
@@ -3386,6 +3383,10 @@ static int dsi_enter_ulps(struct platform_device *dsidev)
         dsi_unregister_isr_cio(dsidev, dsi_completion_handler, &completion,
                         DSI_CIO_IRQ_ULPSACTIVENOT_ALL0);
 
+        /* Reset LANEx_ULPS_SIG2 */
+        REG_FLD_MOD(dsidev, DSI_COMPLEXIO_CFG2, (0 << 0) | (0 << 1) | (0 << 2),
+                7, 5);
+
         dsi_cio_power(dsidev, DSI_COMPLEXIO_POWER_ULPS);
 
         dsi_if_enable(dsidev, false);
@@ -4198,22 +4199,6 @@ static void dsi_display_uninit_dsi(struct omap_dss_device *dssdev,
         dsi_pll_uninit(dsidev, disconnect_lanes);
 }
 
-static int dsi_core_init(struct platform_device *dsidev)
-{
-        /* Autoidle */
-        REG_FLD_MOD(dsidev, DSI_SYSCONFIG, 1, 0, 0);
-
-        /* ENWAKEUP */
-        REG_FLD_MOD(dsidev, DSI_SYSCONFIG, 1, 2, 2);
-
-        /* SIDLEMODE smart-idle */
-        REG_FLD_MOD(dsidev, DSI_SYSCONFIG, 2, 4, 3);
-
-        _dsi_initialize_irq(dsidev);
-
-        return 0;
-}
-
 int omapdss_dsi_display_enable(struct omap_dss_device *dssdev)
 {
         struct platform_device *dsidev = dsi_get_dsidev_from_dssdev(dssdev);
@@ -4229,37 +4214,37 @@ int omapdss_dsi_display_enable(struct omap_dss_device *dssdev)
         r = omap_dss_start_device(dssdev);
         if (r) {
                 DSSERR("failed to start device\n");
-                goto err0;
+                goto err_start_dev;
         }
 
-        enable_clocks(1);
-        dsi_enable_pll_clock(dsidev, 1);
-
-        r = _dsi_reset(dsidev);
+        r = dsi_runtime_get(dsidev);
         if (r)
-                goto err1;
+                goto err_get_dsi;
 
-        dsi_core_init(dsidev);
+        dsi_enable_pll_clock(dsidev, 1);
+
+        _dsi_initialize_irq(dsidev);
 
         r = dsi_display_init_dispc(dssdev);
         if (r)
-                goto err1;
+                goto err_init_dispc;
 
         r = dsi_display_init_dsi(dssdev);
         if (r)
-                goto err2;
+                goto err_init_dsi;
 
         mutex_unlock(&dsi->lock);
 
         return 0;
 
-err2:
+err_init_dsi:
         dsi_display_uninit_dispc(dssdev);
-err1:
-        enable_clocks(0);
+err_init_dispc:
         dsi_enable_pll_clock(dsidev, 0);
+        dsi_runtime_put(dsidev);
+err_get_dsi:
         omap_dss_stop_device(dssdev);
-err0:
+err_start_dev:
         mutex_unlock(&dsi->lock);
         DSSDBG("dsi_display_enable FAILED\n");
         return r;
@@ -4278,11 +4263,16 @@ void omapdss_dsi_display_disable(struct omap_dss_device *dssdev,
 
         mutex_lock(&dsi->lock);
 
+        dsi_sync_vc(dsidev, 0);
+        dsi_sync_vc(dsidev, 1);
+        dsi_sync_vc(dsidev, 2);
+        dsi_sync_vc(dsidev, 3);
+
         dsi_display_uninit_dispc(dssdev);
 
         dsi_display_uninit_dsi(dssdev, disconnect_lanes, enter_ulps);
 
-        enable_clocks(0);
+        dsi_runtime_put(dsidev);
         dsi_enable_pll_clock(dsidev, 0);
 
         omap_dss_stop_device(dssdev);
@@ -4302,16 +4292,11 @@ int omapdss_dsi_enable_te(struct omap_dss_device *dssdev, bool enable)
 EXPORT_SYMBOL(omapdss_dsi_enable_te);
 
 void dsi_get_overlay_fifo_thresholds(enum omap_plane plane,
-                u32 fifo_size, enum omap_burst_size *burst_size,
+                u32 fifo_size, u32 burst_size,
                 u32 *fifo_low, u32 *fifo_high)
 {
-        unsigned burst_size_bytes;
-
-        *burst_size = OMAP_DSS_BURST_16x32;
-        burst_size_bytes = 16 * 32 / 8;
-
-        *fifo_high = fifo_size - burst_size_bytes;
-        *fifo_low = fifo_size - burst_size_bytes * 2;
+        *fifo_high = fifo_size - burst_size;
+        *fifo_low = fifo_size - burst_size * 2;
 }
 
 int dsi_init_display(struct omap_dss_device *dssdev)
@@ -4437,7 +4422,47 @@ static void dsi_calc_clock_param_ranges(struct platform_device *dsidev)
         dsi->lpdiv_max = dss_feat_get_param_max(FEAT_PARAM_DSIPLL_LPDIV);
 }
 
-static int dsi_init(struct platform_device *dsidev)
+static int dsi_get_clocks(struct platform_device *dsidev)
+{
+        struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
+        struct clk *clk;
+
+        clk = clk_get(&dsidev->dev, "fck");
+        if (IS_ERR(clk)) {
+                DSSERR("can't get fck\n");
+                return PTR_ERR(clk);
+        }
+
+        dsi->dss_clk = clk;
+
+        if (cpu_is_omap34xx() || cpu_is_omap3630())
+                clk = clk_get(&dsidev->dev, "dss2_alwon_fck");
+        else
+                clk = clk_get(&dsidev->dev, "sys_clk");
+        if (IS_ERR(clk)) {
+                DSSERR("can't get sys_clk\n");
+                clk_put(dsi->dss_clk);
+                dsi->dss_clk = NULL;
+                return PTR_ERR(clk);
+        }
+
+        dsi->sys_clk = clk;
+
+        return 0;
+}
+
+static void dsi_put_clocks(struct platform_device *dsidev)
+{
+        struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
+
+        if (dsi->dss_clk)
+                clk_put(dsi->dss_clk);
+        if (dsi->sys_clk)
+                clk_put(dsi->sys_clk);
+}
+
+/* DSI1 HW IP initialisation */
+static int omap_dsi1hw_probe(struct platform_device *dsidev)
 {
         struct omap_display_platform_data *dss_plat_data;
         struct omap_dss_board_info *board_info;
@@ -4449,7 +4474,7 @@ static int dsi_init(struct platform_device *dsidev)
         dsi = kzalloc(sizeof(*dsi), GFP_KERNEL);
         if (!dsi) {
                 r = -ENOMEM;
-                goto err0;
+                goto err_alloc;
         }
 
         dsi->pdev = dsidev;
@@ -4472,6 +4497,12 @@ static int dsi_init(struct platform_device *dsidev)
         mutex_init(&dsi->lock);
         sema_init(&dsi->bus_lock, 1);
 
+        r = dsi_get_clocks(dsidev);
+        if (r)
+                goto err_get_clk;
+
+        pm_runtime_enable(&dsidev->dev);
+
         INIT_DELAYED_WORK_DEFERRABLE(&dsi->framedone_timeout_work,
                         dsi_framedone_timeout_work_callback);
 
@@ -4484,26 +4515,26 @@ static int dsi_init(struct platform_device *dsidev)
         if (!dsi_mem) {
                 DSSERR("can't get IORESOURCE_MEM DSI\n");
                 r = -EINVAL;
-                goto err1;
+                goto err_ioremap;
         }
         dsi->base = ioremap(dsi_mem->start, resource_size(dsi_mem));
         if (!dsi->base) {
                 DSSERR("can't ioremap DSI\n");
                 r = -ENOMEM;
-                goto err1;
+                goto err_ioremap;
         }
         dsi->irq = platform_get_irq(dsi->pdev, 0);
         if (dsi->irq < 0) {
                 DSSERR("platform_get_irq failed\n");
                 r = -ENODEV;
-                goto err2;
+                goto err_get_irq;
         }
 
         r = request_irq(dsi->irq, omap_dsi_irq_handler, IRQF_SHARED,
                 dev_name(&dsidev->dev), dsi->pdev);
         if (r < 0) {
                 DSSERR("request_irq failed\n");
-                goto err2;
+                goto err_get_irq;
         }
 
         /* DSI VCs initialization */
@@ -4515,7 +4546,9 @@ static int dsi_init(struct platform_device *dsidev)
 
         dsi_calc_clock_param_ranges(dsidev);
 
-        enable_clocks(1);
+        r = dsi_runtime_get(dsidev);
+        if (r)
+                goto err_get_dsi;
 
         rev = dsi_read_reg(dsidev, DSI_REVISION);
         dev_dbg(&dsidev->dev, "OMAP DSI rev %d.%d\n",
@@ -4523,21 +4556,32 @@ static int dsi_init(struct platform_device *dsidev)
 
         dsi->num_data_lanes = dsi_get_num_data_lanes(dsidev);
 
-        enable_clocks(0);
+        dsi_runtime_put(dsidev);
 
         return 0;
-err2:
+
+err_get_dsi:
+        free_irq(dsi->irq, dsi->pdev);
+err_get_irq:
         iounmap(dsi->base);
-err1:
+err_ioremap:
+        pm_runtime_disable(&dsidev->dev);
+err_get_clk:
         kfree(dsi);
-err0:
+err_alloc:
         return r;
 }
 
-static void dsi_exit(struct platform_device *dsidev)
+static int omap_dsi1hw_remove(struct platform_device *dsidev)
 {
         struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
 
+        WARN_ON(dsi->scp_clk_refcount > 0);
+
+        pm_runtime_disable(&dsidev->dev);
+
+        dsi_put_clocks(dsidev);
+
         if (dsi->vdds_dsi_reg != NULL) {
                 if (dsi->vdds_dsi_enabled) {
                         regulator_disable(dsi->vdds_dsi_reg);
@@ -4553,38 +4597,56 @@ static void dsi_exit(struct platform_device *dsidev)
 
         kfree(dsi);
 
-        DSSDBG("omap_dsi_exit\n");
+        return 0;
 }
 
-/* DSI1 HW IP initialisation */
-static int omap_dsi1hw_probe(struct platform_device *dsidev)
+static int dsi_runtime_suspend(struct device *dev)
 {
-        int r;
+        struct dsi_data *dsi = dsi_get_dsidrv_data(to_platform_device(dev));
 
-        r = dsi_init(dsidev);
-        if (r) {
-                DSSERR("Failed to initialize DSI\n");
-                goto err_dsi;
-        }
-err_dsi:
-        return r;
+        clk_disable(dsi->dss_clk);
+
+        dispc_runtime_put();
+        dss_runtime_put();
+
+        return 0;
 }
 
-static int omap_dsi1hw_remove(struct platform_device *dsidev)
+static int dsi_runtime_resume(struct device *dev)
 {
-        struct dsi_data *dsi = dsi_get_dsidrv_data(dsidev);
+        struct dsi_data *dsi = dsi_get_dsidrv_data(to_platform_device(dev));
+        int r;
+
+        r = dss_runtime_get();
+        if (r)
+                goto err_get_dss;
+
+        r = dispc_runtime_get();
+        if (r)
+                goto err_get_dispc;
+
+        clk_enable(dsi->dss_clk);
 
-        dsi_exit(dsidev);
-        WARN_ON(dsi->scp_clk_refcount > 0);
         return 0;
+
+err_get_dispc:
+        dss_runtime_put();
+err_get_dss:
+        return r;
 }
 
+static const struct dev_pm_ops dsi_pm_ops = {
+        .runtime_suspend = dsi_runtime_suspend,
+        .runtime_resume = dsi_runtime_resume,
+};
+
 static struct platform_driver omap_dsi1hw_driver = {
         .probe          = omap_dsi1hw_probe,
         .remove         = omap_dsi1hw_remove,
         .driver         = {
                 .name   = "omapdss_dsi1",
                 .owner  = THIS_MODULE,
+                .pm     = &dsi_pm_ops,
         },
 };
 
diff --git a/drivers/video/omap2/dss/dss.c b/drivers/video/omap2/dss/dss.c
index d9489d5c4f08..0f9c3a6457a5 100644
--- a/drivers/video/omap2/dss/dss.c
+++ b/drivers/video/omap2/dss/dss.c
@@ -28,6 +28,8 @@
 #include <linux/delay.h>
 #include <linux/seq_file.h>
 #include <linux/clk.h>
+#include <linux/platform_device.h>
+#include <linux/pm_runtime.h>
 
 #include <video/omapdss.h>
 #include <plat/clock.h>
@@ -59,15 +61,9 @@ struct dss_reg {
 static struct {
         struct platform_device *pdev;
         void __iomem    *base;
-        int             ctx_id;
 
         struct clk      *dpll4_m4_ck;
-        struct clk      *dss_ick;
-        struct clk      *dss_fck;
-        struct clk      *dss_sys_clk;
-        struct clk      *dss_tv_fck;
-        struct clk      *dss_video_fck;
-        unsigned        num_clks_enabled;
+        struct clk      *dss_clk;
 
         unsigned long   cache_req_pck;
         unsigned long   cache_prate;
@@ -78,6 +74,7 @@ static struct {
         enum omap_dss_clk_source dispc_clk_source;
         enum omap_dss_clk_source lcd_clk_source[MAX_DSS_LCD_MANAGERS];
 
+        bool            ctx_valid;
         u32             ctx[DSS_SZ_REGS / sizeof(u32)];
 } dss;
 
@@ -87,13 +84,6 @@ static const char * const dss_generic_clk_source_names[] = {
         [OMAP_DSS_CLK_SRC_FCK]                  = "DSS_FCK",
 };
 
-static void dss_clk_enable_all_no_ctx(void);
-static void dss_clk_disable_all_no_ctx(void);
-static void dss_clk_enable_no_ctx(enum dss_clock clks);
-static void dss_clk_disable_no_ctx(enum dss_clock clks);
-
-static int _omap_dss_wait_reset(void);
-
 static inline void dss_write_reg(const struct dss_reg idx, u32 val)
 {
         __raw_writel(val, dss.base + idx.idx);
@@ -109,12 +99,10 @@ static inline u32 dss_read_reg(const struct dss_reg idx)
 #define RR(reg) \
         dss_write_reg(DSS_##reg, dss.ctx[(DSS_##reg).idx / sizeof(u32)])
 
-void dss_save_context(void)
+static void dss_save_context(void)
 {
-        if (cpu_is_omap24xx())
-                return;
+        DSSDBG("dss_save_context\n");
 
-        SR(SYSCONFIG);
         SR(CONTROL);
 
         if (dss_feat_get_supported_displays(OMAP_DSS_CHANNEL_LCD) &
@@ -122,14 +110,19 @@ void dss_save_context(void)
                 SR(SDI_CONTROL);
                 SR(PLL_CONTROL);
         }
+
+        dss.ctx_valid = true;
+
+        DSSDBG("context saved\n");
 }
 
-void dss_restore_context(void)
+static void dss_restore_context(void)
 {
-        if (_omap_dss_wait_reset())
-                DSSERR("DSS not coming out of reset after sleep\n");
+        DSSDBG("dss_restore_context\n");
+
+        if (!dss.ctx_valid)
+                return;
 
-        RR(SYSCONFIG);
         RR(CONTROL);
 
         if (dss_feat_get_supported_displays(OMAP_DSS_CHANNEL_LCD) &
@@ -137,6 +130,8 @@ void dss_restore_context(void)
                 RR(SDI_CONTROL);
                 RR(PLL_CONTROL);
         }
+
+        DSSDBG("context restored\n");
 }
 
 #undef SR
@@ -234,6 +229,7 @@ const char *dss_get_generic_clk_source_name(enum omap_dss_clk_source clk_src)
         return dss_generic_clk_source_names[clk_src];
 }
 
+
 void dss_dump_clocks(struct seq_file *s)
 {
         unsigned long dpll4_ck_rate;
@@ -241,13 +237,14 @@ void dss_dump_clocks(struct seq_file *s)
         const char *fclk_name, *fclk_real_name;
         unsigned long fclk_rate;
 
-        dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK);
+        if (dss_runtime_get())
+                return;
 
         seq_printf(s, "- DSS -\n");
 
         fclk_name = dss_get_generic_clk_source_name(OMAP_DSS_CLK_SRC_FCK);
         fclk_real_name = dss_feat_get_clk_source_name(OMAP_DSS_CLK_SRC_FCK);
-        fclk_rate = dss_clk_get_rate(DSS_CLK_FCK);
+        fclk_rate = clk_get_rate(dss.dss_clk);
 
         if (dss.dpll4_m4_ck) {
                 dpll4_ck_rate = clk_get_rate(clk_get_parent(dss.dpll4_m4_ck));
@@ -273,14 +270,15 @@ void dss_dump_clocks(struct seq_file *s)
                                 fclk_rate);
         }
 
-        dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK);
+        dss_runtime_put();
 }
 
 void dss_dump_regs(struct seq_file *s)
 {
 #define DUMPREG(r) seq_printf(s, "%-35s %08x\n", #r, dss_read_reg(r))
 
-        dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK);
+        if (dss_runtime_get())
+                return;
 
         DUMPREG(DSS_REVISION);
         DUMPREG(DSS_SYSCONFIG);
@@ -294,7 +292,7 @@ void dss_dump_regs(struct seq_file *s)
                 DUMPREG(DSS_SDI_STATUS);
         }
 
-        dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK);
+        dss_runtime_put();
 #undef DUMPREG
 }
 
@@ -437,7 +435,7 @@ int dss_calc_clock_rates(struct dss_clock_info *cinfo)
         } else {
                 if (cinfo->fck_div != 0)
                         return -EINVAL;
-                cinfo->fck = dss_clk_get_rate(DSS_CLK_FCK);
+                cinfo->fck = clk_get_rate(dss.dss_clk);
         }
 
         return 0;
@@ -467,7 +465,7 @@ int dss_set_clock_div(struct dss_clock_info *cinfo)
 
 int dss_get_clock_div(struct dss_clock_info *cinfo)
 {
-        cinfo->fck = dss_clk_get_rate(DSS_CLK_FCK);
+        cinfo->fck = clk_get_rate(dss.dss_clk);
 
         if (dss.dpll4_m4_ck) {
                 unsigned long prate;
@@ -512,7 +510,7 @@ int dss_calc_clock_div(bool is_tft, unsigned long req_pck,
 
         max_dss_fck = dss_feat_get_param_max(FEAT_PARAM_DSS_FCK);
 
-        fck = dss_clk_get_rate(DSS_CLK_FCK);
+        fck = clk_get_rate(dss.dss_clk);
         if (req_pck == dss.cache_req_pck &&
                         ((cpu_is_omap34xx() && prate == dss.cache_prate) ||
                          dss.cache_dss_cinfo.fck == fck)) {
@@ -539,7 +537,7 @@ retry:
         if (dss.dpll4_m4_ck == NULL) {
                 struct dispc_clock_info cur_dispc;
                 /* XXX can we change the clock on omap2? */
-                fck = dss_clk_get_rate(DSS_CLK_FCK);
+                fck = clk_get_rate(dss.dss_clk);
                 fck_div = 1;
 
                 dispc_find_clk_divs(is_tft, req_pck, fck, &cur_dispc);
@@ -616,28 +614,6 @@ found:
         return 0;
 }
 
-static int _omap_dss_wait_reset(void)
-{
-        int t = 0;
-
-        while (REG_GET(DSS_SYSSTATUS, 0, 0) == 0) {
-                if (++t > 1000) {
-                        DSSERR("soft reset failed\n");
-                        return -ENODEV;
-                }
-                udelay(1);
-        }
-
-        return 0;
-}
-
-static int _omap_dss_reset(void)
-{
-        /* Soft reset */
-        REG_FLD_MOD(DSS_SYSCONFIG, 1, 1, 1);
-        return _omap_dss_wait_reset();
-}
-
 void dss_set_venc_output(enum omap_dss_venc_type type)
 {
         int l = 0;
@@ -663,424 +639,88 @@ void dss_select_hdmi_venc_clk_source(enum dss_hdmi_venc_clk_source_select hdmi)
         REG_FLD_MOD(DSS_CONTROL, hdmi, 15, 15); /* VENC_HDMI_SWITCH */
 }
 
-static int dss_init(void)
+static int dss_get_clocks(void)
 {
+        struct clk *clk;
         int r;
-        u32 rev;
-        struct resource *dss_mem;
-        struct clk *dpll4_m4_ck;
 
-        dss_mem = platform_get_resource(dss.pdev, IORESOURCE_MEM, 0);
-        if (!dss_mem) {
-                DSSERR("can't get IORESOURCE_MEM DSS\n");
-                r = -EINVAL;
-                goto fail0;
-        }
-        dss.base = ioremap(dss_mem->start, resource_size(dss_mem));
-        if (!dss.base) {
-                DSSERR("can't ioremap DSS\n");
-                r = -ENOMEM;
-                goto fail0;
+        clk = clk_get(&dss.pdev->dev, "fck");
+        if (IS_ERR(clk)) {
+                DSSERR("can't get clock fck\n");
+                r = PTR_ERR(clk);
+                goto err;
         }
 
-        /* disable LCD and DIGIT output. This seems to fix the synclost
-         * problem that we get, if the bootloader starts the DSS and
-         * the kernel resets it */
-        omap_writel(omap_readl(0x48050440) & ~0x3, 0x48050440);
-
-#ifdef CONFIG_OMAP2_DSS_SLEEP_BEFORE_RESET
-        /* We need to wait here a bit, otherwise we sometimes start to
-         * get synclost errors, and after that only power cycle will
-         * restore DSS functionality. I have no idea why this happens.
-         * And we have to wait _before_ resetting the DSS, but after
-         * enabling clocks.
-         *
-         * This bug was at least present on OMAP3430. It's unknown
-         * if it happens on OMAP2 or OMAP3630.
-         */
-        msleep(50);
-#endif
-
-        _omap_dss_reset();
+        dss.dss_clk = clk;
 
-        /* autoidle */
-        REG_FLD_MOD(DSS_SYSCONFIG, 1, 0, 0);
-
-        /* Select DPLL */
-        REG_FLD_MOD(DSS_CONTROL, 0, 0, 0);
-
-#ifdef CONFIG_OMAP2_DSS_VENC
-        REG_FLD_MOD(DSS_CONTROL, 1, 4, 4);      /* venc dac demen */
-        REG_FLD_MOD(DSS_CONTROL, 1, 3, 3);      /* venc clock 4x enable */
-        REG_FLD_MOD(DSS_CONTROL, 0, 2, 2);      /* venc clock mode = normal */
-#endif
         if (cpu_is_omap34xx()) {
-                dpll4_m4_ck = clk_get(NULL, "dpll4_m4_ck");
-                if (IS_ERR(dpll4_m4_ck)) {
+                clk = clk_get(NULL, "dpll4_m4_ck");
+                if (IS_ERR(clk)) {
                         DSSERR("Failed to get dpll4_m4_ck\n");
-                        r = PTR_ERR(dpll4_m4_ck);
-                        goto fail1;
+                        r = PTR_ERR(clk);
+                        goto err;
                 }
         } else if (cpu_is_omap44xx()) {
-                dpll4_m4_ck = clk_get(NULL, "dpll_per_m5x2_ck");
-                if (IS_ERR(dpll4_m4_ck)) {
-                        DSSERR("Failed to get dpll4_m4_ck\n");
-                        r = PTR_ERR(dpll4_m4_ck);
-                        goto fail1;
+                clk = clk_get(NULL, "dpll_per_m5x2_ck");
+                if (IS_ERR(clk)) {
+                        DSSERR("Failed to get dpll_per_m5x2_ck\n");
+                        r = PTR_ERR(clk);
+                        goto err;
                 }
         } else { /* omap24xx */
-                dpll4_m4_ck = NULL;
+                clk = NULL;
         }
 
-        dss.dpll4_m4_ck = dpll4_m4_ck;
-
-        dss.dsi_clk_source[0] = OMAP_DSS_CLK_SRC_FCK;
-        dss.dsi_clk_source[1] = OMAP_DSS_CLK_SRC_FCK;
-        dss.dispc_clk_source = OMAP_DSS_CLK_SRC_FCK;
-        dss.lcd_clk_source[0] = OMAP_DSS_CLK_SRC_FCK;
-        dss.lcd_clk_source[1] = OMAP_DSS_CLK_SRC_FCK;
-
-        dss_save_context();
-
-        rev = dss_read_reg(DSS_REVISION);
-        printk(KERN_INFO "OMAP DSS rev %d.%d\n",
-                        FLD_GET(rev, 7, 4), FLD_GET(rev, 3, 0));
+        dss.dpll4_m4_ck = clk;
 
         return 0;
 
-fail1:
-        iounmap(dss.base);
-fail0:
-        return r;
-}
-
-static void dss_exit(void)
-{
+err:
+        if (dss.dss_clk)
+                clk_put(dss.dss_clk);
         if (dss.dpll4_m4_ck)
                 clk_put(dss.dpll4_m4_ck);
 
-        iounmap(dss.base);
-}
-
-/* CONTEXT */
-static int dss_get_ctx_id(void)
-{
-        struct omap_display_platform_data *pdata = dss.pdev->dev.platform_data;
-        int r;
-
-        if (!pdata->board_data->get_last_off_on_transaction_id)
-                return 0;
-        r = pdata->board_data->get_last_off_on_transaction_id(&dss.pdev->dev);
-        if (r < 0) {
-                dev_err(&dss.pdev->dev, "getting transaction ID failed, "
-                                "will force context restore\n");
-                r = -1;
-        }
-        return r;
-}
-
-int dss_need_ctx_restore(void)
-{
-        int id = dss_get_ctx_id();
-
-        if (id < 0 || id != dss.ctx_id) {
-                DSSDBG("ctx id %d -> id %d\n",
-                                dss.ctx_id, id);
-                dss.ctx_id = id;
-                return 1;
-        } else {
-                return 0;
-        }
-}
-
-static void save_all_ctx(void)
-{
-        DSSDBG("save context\n");
-
-        dss_clk_enable_no_ctx(DSS_CLK_ICK | DSS_CLK_FCK);
-
-        dss_save_context();
-        dispc_save_context();
-#ifdef CONFIG_OMAP2_DSS_DSI
-        dsi_save_context();
-#endif
-
-        dss_clk_disable_no_ctx(DSS_CLK_ICK | DSS_CLK_FCK);
-}
-
-static void restore_all_ctx(void)
-{
-        DSSDBG("restore context\n");
-
-        dss_clk_enable_all_no_ctx();
-
-        dss_restore_context();
-        dispc_restore_context();
-#ifdef CONFIG_OMAP2_DSS_DSI
-        dsi_restore_context();
-#endif
-
-        dss_clk_disable_all_no_ctx();
-}
-
-static int dss_get_clock(struct clk **clock, const char *clk_name)
-{
-        struct clk *clk;
-
-        clk = clk_get(&dss.pdev->dev, clk_name);
-
-        if (IS_ERR(clk)) {
-                DSSERR("can't get clock %s", clk_name);
-                return PTR_ERR(clk);
-        }
-
-        *clock = clk;
-
-        DSSDBG("clk %s, rate %ld\n", clk_name, clk_get_rate(clk));
-
-        return 0;
-}
-
-static int dss_get_clocks(void)
-{
-        int r;
-        struct omap_display_platform_data *pdata = dss.pdev->dev.platform_data;
-
-        dss.dss_ick = NULL;
-        dss.dss_fck = NULL;
-        dss.dss_sys_clk = NULL;
-        dss.dss_tv_fck = NULL;
-        dss.dss_video_fck = NULL;
-
-        r = dss_get_clock(&dss.dss_ick, "ick");
-        if (r)
-                goto err;
-
-        r = dss_get_clock(&dss.dss_fck, "fck");
-        if (r)
-                goto err;
-
-        if (!pdata->opt_clock_available) {
-                r = -ENODEV;
-                goto err;
-        }
-
-        if (pdata->opt_clock_available("sys_clk")) {
-                r = dss_get_clock(&dss.dss_sys_clk, "sys_clk");
-                if (r)
-                        goto err;
-        }
-
-        if (pdata->opt_clock_available("tv_clk")) {
-                r = dss_get_clock(&dss.dss_tv_fck, "tv_clk");
-                if (r)
-                        goto err;
-        }
-
-        if (pdata->opt_clock_available("video_clk")) {
-                r = dss_get_clock(&dss.dss_video_fck, "video_clk");
-                if (r)
-                        goto err;
-        }
-
-        return 0;
-
-err:
-        if (dss.dss_ick)
-                clk_put(dss.dss_ick);
-        if (dss.dss_fck)
-                clk_put(dss.dss_fck);
-        if (dss.dss_sys_clk)
-                clk_put(dss.dss_sys_clk);
-        if (dss.dss_tv_fck)
-                clk_put(dss.dss_tv_fck);
-        if (dss.dss_video_fck)
-                clk_put(dss.dss_video_fck);
-
         return r;
 }
 
 static void dss_put_clocks(void)
 {
-        if (dss.dss_video_fck)
-                clk_put(dss.dss_video_fck);
-        if (dss.dss_tv_fck)
-                clk_put(dss.dss_tv_fck);
-        if (dss.dss_sys_clk)
-                clk_put(dss.dss_sys_clk);
-        clk_put(dss.dss_fck);
-        clk_put(dss.dss_ick);
-}
-
-unsigned long dss_clk_get_rate(enum dss_clock clk)
-{
-        switch (clk) {
-        case DSS_CLK_ICK:
-                return clk_get_rate(dss.dss_ick);
-        case DSS_CLK_FCK:
-                return clk_get_rate(dss.dss_fck);
-        case DSS_CLK_SYSCK:
-                return clk_get_rate(dss.dss_sys_clk);
-        case DSS_CLK_TVFCK:
-                return clk_get_rate(dss.dss_tv_fck);
-        case DSS_CLK_VIDFCK:
-                return clk_get_rate(dss.dss_video_fck);
-        }
-
-        BUG();
-        return 0;
-}
-
-static unsigned count_clk_bits(enum dss_clock clks)
-{
-        unsigned num_clks = 0;
-
-        if (clks & DSS_CLK_ICK)
-                ++num_clks;
-        if (clks & DSS_CLK_FCK)
-                ++num_clks;
-        if (clks & DSS_CLK_SYSCK)
-                ++num_clks;
-        if (clks & DSS_CLK_TVFCK)
-                ++num_clks;
-        if (clks & DSS_CLK_VIDFCK)
-                ++num_clks;
-
-        return num_clks;
-}
-
-static void dss_clk_enable_no_ctx(enum dss_clock clks)
-{
-        unsigned num_clks = count_clk_bits(clks);
-
-        if (clks & DSS_CLK_ICK)
-                clk_enable(dss.dss_ick);
-        if (clks & DSS_CLK_FCK)
-                clk_enable(dss.dss_fck);
-        if ((clks & DSS_CLK_SYSCK) && dss.dss_sys_clk)
-                clk_enable(dss.dss_sys_clk);
-        if ((clks & DSS_CLK_TVFCK) && dss.dss_tv_fck)
-                clk_enable(dss.dss_tv_fck);
-        if ((clks & DSS_CLK_VIDFCK) && dss.dss_video_fck)
-                clk_enable(dss.dss_video_fck);
-
-        dss.num_clks_enabled += num_clks;
-}
-
-void dss_clk_enable(enum dss_clock clks)
-{
-        bool check_ctx = dss.num_clks_enabled == 0;
-
-        dss_clk_enable_no_ctx(clks);
-
-        /*
-         * HACK: On omap4 the registers may not be accessible right after
-         * enabling the clocks. At some point this will be handled by
-         * pm_runtime, but for the time begin this should make things work.
-         */
-        if (cpu_is_omap44xx() && check_ctx)
-                udelay(10);
-
-        if (check_ctx && cpu_is_omap34xx() && dss_need_ctx_restore())
-                restore_all_ctx();
+        if (dss.dpll4_m4_ck)
+                clk_put(dss.dpll4_m4_ck);
+        clk_put(dss.dss_clk);
 }
 
-static void dss_clk_disable_no_ctx(enum dss_clock clks)
+struct clk *dss_get_ick(void)
 {
-        unsigned num_clks = count_clk_bits(clks);
-
-        if (clks & DSS_CLK_ICK)
-                clk_disable(dss.dss_ick);
-        if (clks & DSS_CLK_FCK)
-                clk_disable(dss.dss_fck);
-        if ((clks & DSS_CLK_SYSCK) && dss.dss_sys_clk)
-                clk_disable(dss.dss_sys_clk);
-        if ((clks & DSS_CLK_TVFCK) && dss.dss_tv_fck)
-                clk_disable(dss.dss_tv_fck);
-        if ((clks & DSS_CLK_VIDFCK) && dss.dss_video_fck)
-                clk_disable(dss.dss_video_fck);
-
-        dss.num_clks_enabled -= num_clks;
+        return clk_get(&dss.pdev->dev, "ick");
 }
 
-void dss_clk_disable(enum dss_clock clks)
+int dss_runtime_get(void)
 {
-        if (cpu_is_omap34xx()) {
-                unsigned num_clks = count_clk_bits(clks);
-
-                BUG_ON(dss.num_clks_enabled < num_clks);
+        int r;
 
-                if (dss.num_clks_enabled == num_clks)
-                        save_all_ctx();
-        }
+        DSSDBG("dss_runtime_get\n");
 
-        dss_clk_disable_no_ctx(clks);
+        r = pm_runtime_get_sync(&dss.pdev->dev);
+        WARN_ON(r < 0);
+        return r < 0 ? r : 0;
 }
 
-static void dss_clk_enable_all_no_ctx(void)
+void dss_runtime_put(void)
 {
-        enum dss_clock clks;
-
-        clks = DSS_CLK_ICK | DSS_CLK_FCK | DSS_CLK_SYSCK | DSS_CLK_TVFCK;
-        if (cpu_is_omap34xx())
-                clks |= DSS_CLK_VIDFCK;
-        dss_clk_enable_no_ctx(clks);
-}
-
-static void dss_clk_disable_all_no_ctx(void)
-{
-        enum dss_clock clks;
+        int r;
 
-        clks = DSS_CLK_ICK | DSS_CLK_FCK | DSS_CLK_SYSCK | DSS_CLK_TVFCK;
-        if (cpu_is_omap34xx())
-                clks |= DSS_CLK_VIDFCK;
-        dss_clk_disable_no_ctx(clks);
-}
+        DSSDBG("dss_runtime_put\n");
 
-#if defined(CONFIG_DEBUG_FS) && defined(CONFIG_OMAP2_DSS_DEBUG_SUPPORT)
-/* CLOCKS */
-static void core_dump_clocks(struct seq_file *s)
-{
-        int i;
-        struct clk *clocks[5] = {
-                dss.dss_ick,
-                dss.dss_fck,
-                dss.dss_sys_clk,
-                dss.dss_tv_fck,
-                dss.dss_video_fck
-        };
-
-        const char *names[5] = {
-                "ick",
-                "fck",
-                "sys_clk",
-                "tv_fck",
-                "video_fck"
-        };
-
-        seq_printf(s, "- CORE -\n");
-
-        seq_printf(s, "internal clk count\t\t%u\n", dss.num_clks_enabled);
-
-        for (i = 0; i < 5; i++) {
-                if (!clocks[i])
-                        continue;
-                seq_printf(s, "%s (%s)%*s\t%lu\t%d\n",
-                                names[i],
-                                clocks[i]->name,
-                                24 - strlen(names[i]) - strlen(clocks[i]->name),
-                                "",
-                                clk_get_rate(clocks[i]),
-                                clocks[i]->usecount);
-        }
+        r = pm_runtime_put(&dss.pdev->dev);
+        WARN_ON(r < 0);
 }
-#endif /* defined(CONFIG_DEBUG_FS) && defined(CONFIG_OMAP2_DSS_DEBUG_SUPPORT) */
 
 /* DEBUGFS */
 #if defined(CONFIG_DEBUG_FS) && defined(CONFIG_OMAP2_DSS_DEBUG_SUPPORT)
 void dss_debug_dump_clocks(struct seq_file *s)
 {
-        core_dump_clocks(s);
         dss_dump_clocks(s);
         dispc_dump_clocks(s);
 #ifdef CONFIG_OMAP2_DSS_DSI
@@ -1089,28 +729,51 @@ void dss_debug_dump_clocks(struct seq_file *s)
 }
 #endif
 
-
 /* DSS HW IP initialisation */
 static int omap_dsshw_probe(struct platform_device *pdev)
 {
+        struct resource *dss_mem;
+        u32 rev;
         int r;
 
         dss.pdev = pdev;
 
+        dss_mem = platform_get_resource(dss.pdev, IORESOURCE_MEM, 0);
+        if (!dss_mem) {
+                DSSERR("can't get IORESOURCE_MEM DSS\n");
+                r = -EINVAL;
+                goto err_ioremap;
+        }
+        dss.base = ioremap(dss_mem->start, resource_size(dss_mem));
+        if (!dss.base) {
+                DSSERR("can't ioremap DSS\n");
+                r = -ENOMEM;
+                goto err_ioremap;
+        }
+
         r = dss_get_clocks();
         if (r)
                 goto err_clocks;
 
-        dss_clk_enable_all_no_ctx();
+        pm_runtime_enable(&pdev->dev);
 
-        dss.ctx_id = dss_get_ctx_id();
-        DSSDBG("initial ctx id %u\n", dss.ctx_id);
+        r = dss_runtime_get();
+        if (r)
+                goto err_runtime_get;
 
-        r = dss_init();
-        if (r) {
-                DSSERR("Failed to initialize DSS\n");
-                goto err_dss;
-        }
+        /* Select DPLL */
+        REG_FLD_MOD(DSS_CONTROL, 0, 0, 0);
+
+#ifdef CONFIG_OMAP2_DSS_VENC
+        REG_FLD_MOD(DSS_CONTROL, 1, 4, 4);      /* venc dac demen */
+        REG_FLD_MOD(DSS_CONTROL, 1, 3, 3);      /* venc clock 4x enable */
+        REG_FLD_MOD(DSS_CONTROL, 0, 2, 2);      /* venc clock mode = normal */
+#endif
+        dss.dsi_clk_source[0] = OMAP_DSS_CLK_SRC_FCK;
+        dss.dsi_clk_source[1] = OMAP_DSS_CLK_SRC_FCK;
+        dss.dispc_clk_source = OMAP_DSS_CLK_SRC_FCK;
+        dss.lcd_clk_source[0] = OMAP_DSS_CLK_SRC_FCK;
+        dss.lcd_clk_source[1] = OMAP_DSS_CLK_SRC_FCK;
 
         r = dpi_init();
         if (r) {
@@ -1124,42 +787,66 @@ static int omap_dsshw_probe(struct platform_device *pdev)
                 goto err_sdi;
         }
 
-        dss_clk_disable_all_no_ctx();
+        rev = dss_read_reg(DSS_REVISION);
+        printk(KERN_INFO "OMAP DSS rev %d.%d\n",
+                        FLD_GET(rev, 7, 4), FLD_GET(rev, 3, 0));
+
+        dss_runtime_put();
+
         return 0;
 err_sdi:
         dpi_exit();
 err_dpi:
-        dss_exit();
-err_dss:
-        dss_clk_disable_all_no_ctx();
+        dss_runtime_put();
+err_runtime_get:
+        pm_runtime_disable(&pdev->dev);
         dss_put_clocks();
 err_clocks:
+        iounmap(dss.base);
+err_ioremap:
         return r;
 }
 
 static int omap_dsshw_remove(struct platform_device *pdev)
 {
+        dpi_exit();
+        sdi_exit();
 
-        dss_exit();
+        iounmap(dss.base);
 
-        /*
-         * As part of hwmod changes, DSS is not the only controller of dss
-         * clocks; hwmod framework itself will also enable clocks during hwmod
-         * init for dss, and autoidle is set in h/w for DSS. Hence, there's no
-         * need to disable clocks if their usecounts > 1.
-         */
-        WARN_ON(dss.num_clks_enabled > 0);
+        pm_runtime_disable(&pdev->dev);
 
         dss_put_clocks();
+
+        return 0;
+}
+
+static int dss_runtime_suspend(struct device *dev)
+{
+        dss_save_context();
+        clk_disable(dss.dss_clk);
         return 0;
 }
 
+static int dss_runtime_resume(struct device *dev)
+{
+        clk_enable(dss.dss_clk);
+        dss_restore_context();
+        return 0;
+}
+
+static const struct dev_pm_ops dss_pm_ops = {
+        .runtime_suspend = dss_runtime_suspend,
+        .runtime_resume = dss_runtime_resume,
+};
+
 static struct platform_driver omap_dsshw_driver = {
         .probe          = omap_dsshw_probe,
         .remove         = omap_dsshw_remove,
         .driver         = {
                 .name   = "omapdss_dss",
                 .owner  = THIS_MODULE,
+                .pm     = &dss_pm_ops,
         },
 };
 
diff --git a/drivers/video/omap2/dss/dss.h b/drivers/video/omap2/dss/dss.h
index 8ab6d43329bb..9c94b1152c20 100644
--- a/drivers/video/omap2/dss/dss.h
+++ b/drivers/video/omap2/dss/dss.h
@@ -97,26 +97,12 @@ extern unsigned int dss_debug;
 #define FLD_MOD(orig, val, start, end) \
         (((orig) & ~FLD_MASK(start, end)) | FLD_VAL(val, start, end))
 
-enum omap_burst_size {
-        OMAP_DSS_BURST_4x32 = 0,
-        OMAP_DSS_BURST_8x32 = 1,
-        OMAP_DSS_BURST_16x32 = 2,
-};
-
 enum omap_parallel_interface_mode {
         OMAP_DSS_PARALLELMODE_BYPASS,           /* MIPI DPI */
         OMAP_DSS_PARALLELMODE_RFBI,             /* MIPI DBI */
         OMAP_DSS_PARALLELMODE_DSI,
 };
 
-enum dss_clock {
-        DSS_CLK_ICK     = 1 << 0,       /* DSS_L3_ICLK and DSS_L4_ICLK */
-        DSS_CLK_FCK     = 1 << 1,       /* DSS1_ALWON_FCLK */
-        DSS_CLK_SYSCK   = 1 << 2,       /* DSS2_ALWON_FCLK */
-        DSS_CLK_TVFCK   = 1 << 3,       /* DSS_TV_FCLK */
-        DSS_CLK_VIDFCK  = 1 << 4,       /* DSS_96M_FCLK*/
-};
-
 enum dss_hdmi_venc_clk_source_select {
         DSS_VENC_TV_CLK = 0,
         DSS_HDMI_M_PCLK = 1,
@@ -194,7 +180,7 @@ void dss_uninit_device(struct platform_device *pdev,
 bool dss_use_replication(struct omap_dss_device *dssdev,
                 enum omap_color_mode mode);
 void default_get_overlay_fifo_thresholds(enum omap_plane plane,
-                u32 fifo_size, enum omap_burst_size *burst_size,
+                u32 fifo_size, u32 burst_size,
                 u32 *fifo_low, u32 *fifo_high);
 
 /* manager */
@@ -220,13 +206,12 @@ void dss_recheck_connections(struct omap_dss_device *dssdev, bool force);
 int dss_init_platform_driver(void);
 void dss_uninit_platform_driver(void);
 
+int dss_runtime_get(void);
+void dss_runtime_put(void);
+
+struct clk *dss_get_ick(void);
+
 void dss_select_hdmi_venc_clk_source(enum dss_hdmi_venc_clk_source_select);
-void dss_save_context(void);
-void dss_restore_context(void);
-void dss_clk_enable(enum dss_clock clks);
-void dss_clk_disable(enum dss_clock clks);
-unsigned long dss_clk_get_rate(enum dss_clock clk);
-int dss_need_ctx_restore(void);
 const char *dss_get_generic_clk_source_name(enum omap_dss_clk_source clk_src);
 void dss_dump_clocks(struct seq_file *s);
 
@@ -283,15 +268,15 @@ struct file_operations;
 int dsi_init_platform_driver(void);
 void dsi_uninit_platform_driver(void);
 
+int dsi_runtime_get(struct platform_device *dsidev);
+void dsi_runtime_put(struct platform_device *dsidev);
+
 void dsi_dump_clocks(struct seq_file *s);
 void dsi_create_debugfs_files_irq(struct dentry *debugfs_dir,
                 const struct file_operations *debug_fops);
 void dsi_create_debugfs_files_reg(struct dentry *debugfs_dir,
                 const struct file_operations *debug_fops);
 
-void dsi_save_context(void);
-void dsi_restore_context(void);
-
 int dsi_init_display(struct omap_dss_device *display);
 void dsi_irq_handler(void);
 unsigned long dsi_get_pll_hsdiv_dispc_rate(struct platform_device *dsidev);
@@ -304,7 +289,7 @@ int dsi_pll_init(struct platform_device *dsidev, bool enable_hsclk,
                 bool enable_hsdiv);
 void dsi_pll_uninit(struct platform_device *dsidev, bool disconnect_lanes);
 void dsi_get_overlay_fifo_thresholds(enum omap_plane plane,
-                u32 fifo_size, enum omap_burst_size *burst_size,
+                u32 fifo_size, u32 burst_size,
                 u32 *fifo_low, u32 *fifo_high);
 void dsi_wait_pll_hsdiv_dispc_active(struct platform_device *dsidev);
 void dsi_wait_pll_hsdiv_dsi_active(struct platform_device *dsidev);
@@ -317,6 +302,13 @@ static inline int dsi_init_platform_driver(void)
 static inline void dsi_uninit_platform_driver(void)
 {
 }
+static inline int dsi_runtime_get(struct platform_device *dsidev)
+{
+        return 0;
+}
+static inline void dsi_runtime_put(struct platform_device *dsidev)
+{
+}
 static inline unsigned long dsi_get_pll_hsdiv_dispc_rate(struct platform_device *dsidev)
 {
         WARN("%s: DSI not compiled in, returning rate as 0\n", __func__);
@@ -384,8 +376,8 @@ void dispc_dump_regs(struct seq_file *s);
 void dispc_irq_handler(void);
 void dispc_fake_vsync_irq(void);
 
-void dispc_save_context(void);
-void dispc_restore_context(void);
+int dispc_runtime_get(void);
+void dispc_runtime_put(void);
 
 void dispc_enable_sidle(void);
 void dispc_disable_sidle(void);
@@ -398,10 +390,12 @@ void dispc_enable_fifohandcheck(enum omap_channel channel, bool enable);
 void dispc_set_lcd_size(enum omap_channel channel, u16 width, u16 height);
 void dispc_set_digit_size(u16 width, u16 height);
 u32 dispc_get_plane_fifo_size(enum omap_plane plane);
-void dispc_setup_plane_fifo(enum omap_plane plane, u32 low, u32 high);
+void dispc_set_fifo_threshold(enum omap_plane plane, u32 low, u32 high);
 void dispc_enable_fifomerge(bool enable);
-void dispc_set_burst_size(enum omap_plane plane,
-                enum omap_burst_size burst_size);
+u32 dispc_get_burst_size(enum omap_plane plane);
+void dispc_enable_cpr(enum omap_channel channel, bool enable);
+void dispc_set_cpr_coef(enum omap_channel channel,
+                struct omap_dss_cpr_coefs *coefs);
 
 void dispc_set_plane_ba0(enum omap_plane plane, u32 paddr);
 void dispc_set_plane_ba1(enum omap_plane plane, u32 paddr);
diff --git a/drivers/video/omap2/dss/dss_features.c b/drivers/video/omap2/dss/dss_features.c
index 1c18888e5df3..b415c4ee621d 100644
--- a/drivers/video/omap2/dss/dss_features.c
+++ b/drivers/video/omap2/dss/dss_features.c
@@ -49,6 +49,9 @@ struct omap_dss_features {
         const enum omap_color_mode *supported_color_modes;
         const char * const *clksrc_names;
         const struct dss_param_range *dss_params;
+
+        const u32 buffer_size_unit;
+        const u32 burst_size_unit;
 };
 
 /* This struct is assigned to one of the below during initialization */
@@ -274,6 +277,8 @@ static const struct omap_dss_features omap2_dss_features = {
         .supported_color_modes = omap2_dss_supported_color_modes,
         .clksrc_names = omap2_dss_clk_source_names,
         .dss_params = omap2_dss_param_range,
+        .buffer_size_unit = 1,
+        .burst_size_unit = 8,
 };
 
 /* OMAP3 DSS Features */
@@ -286,7 +291,9 @@ static const struct omap_dss_features omap3430_dss_features = {
                 FEAT_LCDENABLESIGNAL | FEAT_PCKFREEENABLE |
                 FEAT_FUNCGATED | FEAT_ROWREPEATENABLE |
                 FEAT_LINEBUFFERSPLIT | FEAT_RESIZECONF |
-                FEAT_DSI_PLL_FREQSEL | FEAT_DSI_REVERSE_TXCLKESC,
+                FEAT_DSI_PLL_FREQSEL | FEAT_DSI_REVERSE_TXCLKESC |
+                FEAT_VENC_REQUIRES_TV_DAC_CLK | FEAT_CPR | FEAT_PRELOAD |
+                FEAT_FIR_COEF_V,
 
         .num_mgrs = 2,
         .num_ovls = 3,
@@ -294,6 +301,8 @@ static const struct omap_dss_features omap3430_dss_features = {
         .supported_color_modes = omap3_dss_supported_color_modes,
         .clksrc_names = omap3_dss_clk_source_names,
         .dss_params = omap3_dss_param_range,
+        .buffer_size_unit = 1,
+        .burst_size_unit = 8,
 };
 
 static const struct omap_dss_features omap3630_dss_features = {
@@ -306,7 +315,8 @@ static const struct omap_dss_features omap3630_dss_features = {
                 FEAT_PRE_MULT_ALPHA | FEAT_FUNCGATED |
                 FEAT_ROWREPEATENABLE | FEAT_LINEBUFFERSPLIT |
                 FEAT_RESIZECONF | FEAT_DSI_PLL_PWR_BUG |
-                FEAT_DSI_PLL_FREQSEL,
+                FEAT_DSI_PLL_FREQSEL | FEAT_CPR | FEAT_PRELOAD |
+                FEAT_FIR_COEF_V,
 
         .num_mgrs = 2,
         .num_ovls = 3,
@@ -314,6 +324,8 @@ static const struct omap_dss_features omap3630_dss_features = {
         .supported_color_modes = omap3_dss_supported_color_modes,
         .clksrc_names = omap3_dss_clk_source_names,
         .dss_params = omap3_dss_param_range,
+        .buffer_size_unit = 1,
+        .burst_size_unit = 8,
 };
 
 /* OMAP4 DSS Features */
@@ -327,7 +339,8 @@ static const struct omap_dss_features omap4430_es1_0_dss_features  = {
                 FEAT_MGR_LCD2 | FEAT_GLOBAL_ALPHA_VID1 |
                 FEAT_CORE_CLK_DIV | FEAT_LCD_CLK_SRC |
                 FEAT_DSI_DCS_CMD_CONFIG_VC | FEAT_DSI_VC_OCP_WIDTH |
-                FEAT_DSI_GNQ | FEAT_HANDLE_UV_SEPARATE | FEAT_ATTR2,
+                FEAT_DSI_GNQ | FEAT_HANDLE_UV_SEPARATE | FEAT_ATTR2 |
+                FEAT_CPR | FEAT_PRELOAD | FEAT_FIR_COEF_V,
 
         .num_mgrs = 3,
         .num_ovls = 3,
@@ -335,6 +348,8 @@ static const struct omap_dss_features omap4430_es1_0_dss_features  = {
         .supported_color_modes = omap4_dss_supported_color_modes,
         .clksrc_names = omap4_dss_clk_source_names,
         .dss_params = omap4_dss_param_range,
+        .buffer_size_unit = 16,
+        .burst_size_unit = 16,
 };
 
 /* For all the other OMAP4 versions */
@@ -348,7 +363,8 @@ static const struct omap_dss_features omap4_dss_features = {
                 FEAT_CORE_CLK_DIV | FEAT_LCD_CLK_SRC |
                 FEAT_DSI_DCS_CMD_CONFIG_VC | FEAT_DSI_VC_OCP_WIDTH |
                 FEAT_DSI_GNQ | FEAT_HDMI_CTS_SWMODE |
-                FEAT_HANDLE_UV_SEPARATE | FEAT_ATTR2,
+                FEAT_HANDLE_UV_SEPARATE | FEAT_ATTR2 | FEAT_CPR |
+                FEAT_PRELOAD | FEAT_FIR_COEF_V,
 
         .num_mgrs = 3,
         .num_ovls = 3,
@@ -356,6 +372,8 @@ static const struct omap_dss_features omap4_dss_features = {
         .supported_color_modes = omap4_dss_supported_color_modes,
         .clksrc_names = omap4_dss_clk_source_names,
         .dss_params = omap4_dss_param_range,
+        .buffer_size_unit = 16,
+        .burst_size_unit = 16,
 };
 
 /* Functions returning values related to a DSS feature */
@@ -401,6 +419,16 @@ const char *dss_feat_get_clk_source_name(enum omap_dss_clk_source id)
         return omap_current_dss_features->clksrc_names[id];
 }
 
+u32 dss_feat_get_buffer_size_unit(void)
+{
+        return omap_current_dss_features->buffer_size_unit;
+}
+
+u32 dss_feat_get_burst_size_unit(void)
+{
+        return omap_current_dss_features->burst_size_unit;
+}
+
 /* DSS has_feature check */
 bool dss_has_feature(enum dss_feat_id id)
 {
diff --git a/drivers/video/omap2/dss/dss_features.h b/drivers/video/omap2/dss/dss_features.h
index 07b346f7d916..b7398cbcda5f 100644
--- a/drivers/video/omap2/dss/dss_features.h
+++ b/drivers/video/omap2/dss/dss_features.h
@@ -51,6 +51,10 @@ enum dss_feat_id {
         FEAT_HDMI_CTS_SWMODE            = 1 << 19,
         FEAT_HANDLE_UV_SEPARATE         = 1 << 20,
         FEAT_ATTR2                      = 1 << 21,
+        FEAT_VENC_REQUIRES_TV_DAC_CLK   = 1 << 22,
+        FEAT_CPR                        = 1 << 23,
+        FEAT_PRELOAD                    = 1 << 24,
+        FEAT_FIR_COEF_V                 = 1 << 25,
 };
 
 /* DSS register field id */
@@ -90,6 +94,9 @@ bool dss_feat_color_mode_supported(enum omap_plane plane,
                 enum omap_color_mode color_mode);
 const char *dss_feat_get_clk_source_name(enum omap_dss_clk_source id);
 
+u32 dss_feat_get_buffer_size_unit(void);        /* in bytes */
+u32 dss_feat_get_burst_size_unit(void);         /* in bytes */
+
 bool dss_has_feature(enum dss_feat_id id);
 void dss_feat_get_reg_field(enum dss_feat_reg_field id, u8 *start, u8 *end);
 void dss_features_init(void);
diff --git a/drivers/video/omap2/dss/hdmi.c b/drivers/video/omap2/dss/hdmi.c
index b0555f4f0a78..256f27a9064a 100644
--- a/drivers/video/omap2/dss/hdmi.c
+++ b/drivers/video/omap2/dss/hdmi.c
@@ -29,6 +29,9 @@
 #include <linux/mutex.h>
 #include <linux/delay.h>
 #include <linux/string.h>
+#include <linux/platform_device.h>
+#include <linux/pm_runtime.h>
+#include <linux/clk.h>
 #include <video/omapdss.h>
 #if defined(CONFIG_SND_OMAP_SOC_OMAP4_HDMI) || \
         defined(CONFIG_SND_OMAP_SOC_OMAP4_HDMI_MODULE)
@@ -51,6 +54,9 @@ static struct {
         u8 edid_set;
         bool custom_set;
         struct hdmi_config cfg;
+
+        struct clk *sys_clk;
+        struct clk *hdmi_clk;
 } hdmi;
 
 /*
@@ -162,6 +168,27 @@ static inline int hdmi_wait_for_bit_change(const struct hdmi_reg idx,
         return val;
 }
 
+static int hdmi_runtime_get(void)
+{
+        int r;
+
+        DSSDBG("hdmi_runtime_get\n");
+
+        r = pm_runtime_get_sync(&hdmi.pdev->dev);
+        WARN_ON(r < 0);
+        return r < 0 ? r : 0;
+}
+
+static void hdmi_runtime_put(void)
+{
+        int r;
+
+        DSSDBG("hdmi_runtime_put\n");
+
+        r = pm_runtime_put(&hdmi.pdev->dev);
+        WARN_ON(r < 0);
+}
+
 int hdmi_init_display(struct omap_dss_device *dssdev)
 {
         DSSDBG("init_display\n");
@@ -311,30 +338,11 @@ static int hdmi_phy_init(void)
         return 0;
 }
 
-static int hdmi_wait_softreset(void)
-{
-        /* reset W1 */
-        REG_FLD_MOD(HDMI_WP_SYSCONFIG, 0x1, 0, 0);
-
-        /* wait till SOFTRESET == 0 */
-        if (hdmi_wait_for_bit_change(HDMI_WP_SYSCONFIG, 0, 0, 0) != 0) {
-                DSSERR("sysconfig reset failed\n");
-                return -ETIMEDOUT;
-        }
-
-        return 0;
-}
-
 static int hdmi_pll_program(struct hdmi_pll_info *fmt)
 {
         u16 r = 0;
         enum hdmi_clk_refsel refsel;
 
-        /* wait for wrapper reset */
-        r = hdmi_wait_softreset();
-        if (r)
-                return r;
-
         r = hdmi_set_pll_pwr(HDMI_PLLPWRCMD_ALLOFF);
         if (r)
                 return r;
@@ -1064,7 +1072,7 @@ static void hdmi_compute_pll(struct omap_dss_device *dssdev, int phy,
         unsigned long clkin, refclk;
         u32 mf;
 
-        clkin = dss_clk_get_rate(DSS_CLK_SYSCK) / 10000;
+        clkin = clk_get_rate(hdmi.sys_clk) / 10000;
         /*
          * Input clock is predivided by N + 1
          * out put of which is reference clk
@@ -1098,16 +1106,6 @@ static void hdmi_compute_pll(struct omap_dss_device *dssdev, int phy,
         DSSDBG("range = %d sd = %d\n", pi->dcofreq, pi->regsd);
 }
 
-static void hdmi_enable_clocks(int enable)
-{
-        if (enable)
-                dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK |
-                                DSS_CLK_SYSCK | DSS_CLK_VIDFCK);
-        else
-                dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK |
-                                DSS_CLK_SYSCK | DSS_CLK_VIDFCK);
-}
-
 static int hdmi_power_on(struct omap_dss_device *dssdev)
 {
         int r, code = 0;
@@ -1115,7 +1113,9 @@ static int hdmi_power_on(struct omap_dss_device *dssdev)
         struct omap_video_timings *p;
         unsigned long phy;
 
-        hdmi_enable_clocks(1);
+        r = hdmi_runtime_get();
+        if (r)
+                return r;
 
         dispc_enable_channel(OMAP_DSS_CHANNEL_DIGIT, 0);
 
@@ -1180,7 +1180,7 @@ static int hdmi_power_on(struct omap_dss_device *dssdev)
 
         return 0;
 err:
-        hdmi_enable_clocks(0);
+        hdmi_runtime_put();
         return -EIO;
 }
 
@@ -1191,7 +1191,7 @@ static void hdmi_power_off(struct omap_dss_device *dssdev)
         hdmi_wp_video_start(0);
         hdmi_phy_off();
         hdmi_set_pll_pwr(HDMI_PLLPWRCMD_ALLOFF);
-        hdmi_enable_clocks(0);
+        hdmi_runtime_put();
 
         hdmi.edid_set = 0;
 }
@@ -1686,14 +1686,43 @@ static struct snd_soc_dai_driver hdmi_codec_dai_drv = {
 };
 #endif
 
+static int hdmi_get_clocks(struct platform_device *pdev)
+{
+        struct clk *clk;
+
+        clk = clk_get(&pdev->dev, "sys_clk");
+        if (IS_ERR(clk)) {
+                DSSERR("can't get sys_clk\n");
+                return PTR_ERR(clk);
+        }
+
+        hdmi.sys_clk = clk;
+
+        clk = clk_get(&pdev->dev, "dss_48mhz_clk");
+        if (IS_ERR(clk)) {
+                DSSERR("can't get hdmi_clk\n");
+                clk_put(hdmi.sys_clk);
+                return PTR_ERR(clk);
+        }
+
+        hdmi.hdmi_clk = clk;
+
+        return 0;
+}
+
+static void hdmi_put_clocks(void)
+{
+        if (hdmi.sys_clk)
+                clk_put(hdmi.sys_clk);
+        if (hdmi.hdmi_clk)
+                clk_put(hdmi.hdmi_clk);
+}
+
 /* HDMI HW IP initialisation */
 static int omapdss_hdmihw_probe(struct platform_device *pdev)
 {
         struct resource *hdmi_mem;
-#if defined(CONFIG_SND_OMAP_SOC_OMAP4_HDMI) || \
-        defined(CONFIG_SND_OMAP_SOC_OMAP4_HDMI_MODULE)
-        int ret;
-#endif
+        int r;
 
         hdmi.pdata = pdev->dev.platform_data;
         hdmi.pdev = pdev;
@@ -1713,17 +1742,25 @@ static int omapdss_hdmihw_probe(struct platform_device *pdev)
                 return -ENOMEM;
         }
 
+        r = hdmi_get_clocks(pdev);
+        if (r) {
+                iounmap(hdmi.base_wp);
+                return r;
+        }
+
+        pm_runtime_enable(&pdev->dev);
+
         hdmi_panel_init();
 
 #if defined(CONFIG_SND_OMAP_SOC_OMAP4_HDMI) || \
         defined(CONFIG_SND_OMAP_SOC_OMAP4_HDMI_MODULE)
 
         /* Register ASoC codec DAI */
-        ret = snd_soc_register_codec(&pdev->dev, &hdmi_audio_codec_drv,
+        r = snd_soc_register_codec(&pdev->dev, &hdmi_audio_codec_drv,
                                         &hdmi_codec_dai_drv, 1);
-        if (ret) {
+        if (r) {
                 DSSERR("can't register ASoC HDMI audio codec\n");
-                return ret;
+                return r;
         }
 #endif
         return 0;
@@ -1738,17 +1775,62 @@ static int omapdss_hdmihw_remove(struct platform_device *pdev)
         snd_soc_unregister_codec(&pdev->dev);
 #endif
 
+        pm_runtime_disable(&pdev->dev);
+
+        hdmi_put_clocks();
+
         iounmap(hdmi.base_wp);
 
         return 0;
 }
 
+static int hdmi_runtime_suspend(struct device *dev)
+{
+        clk_disable(hdmi.hdmi_clk);
+        clk_disable(hdmi.sys_clk);
+
+        dispc_runtime_put();
+        dss_runtime_put();
+
+        return 0;
+}
+
+static int hdmi_runtime_resume(struct device *dev)
+{
+        int r;
+
+        r = dss_runtime_get();
+        if (r < 0)
+                goto err_get_dss;
+
+        r = dispc_runtime_get();
+        if (r < 0)
+                goto err_get_dispc;
+
+
+        clk_enable(hdmi.sys_clk);
+        clk_enable(hdmi.hdmi_clk);
+
+        return 0;
+
+err_get_dispc:
+        dss_runtime_put();
+err_get_dss:
+        return r;
+}
+
+static const struct dev_pm_ops hdmi_pm_ops = {
+        .runtime_suspend = hdmi_runtime_suspend,
+        .runtime_resume = hdmi_runtime_resume,
+};
+
 static struct platform_driver omapdss_hdmihw_driver = {
         .probe          = omapdss_hdmihw_probe,
         .remove         = omapdss_hdmihw_remove,
         .driver         = {
                 .name   = "omapdss_hdmi",
                 .owner  = THIS_MODULE,
+                .pm     = &hdmi_pm_ops,
         },
 };
 
diff --git a/drivers/video/omap2/dss/manager.c b/drivers/video/omap2/dss/manager.c
index 9aeea50e33ff..13d72d5c714b 100644
--- a/drivers/video/omap2/dss/manager.c
+++ b/drivers/video/omap2/dss/manager.c
@@ -275,6 +275,108 @@ static ssize_t manager_alpha_blending_enabled_store(
         return size;
 }
 
+static ssize_t manager_cpr_enable_show(struct omap_overlay_manager *mgr,
+                char *buf)
+{
+        return snprintf(buf, PAGE_SIZE, "%d\n", mgr->info.cpr_enable);
+}
+
+static ssize_t manager_cpr_enable_store(struct omap_overlay_manager *mgr,
+                const char *buf, size_t size)
+{
+        struct omap_overlay_manager_info info;
+        int v;
+        int r;
+        bool enable;
+
+        if (!dss_has_feature(FEAT_CPR))
+                return -ENODEV;
+
+        r = kstrtoint(buf, 0, &v);
+        if (r)
+                return r;
+
+        enable = !!v;
+
+        mgr->get_manager_info(mgr, &info);
+
+        if (info.cpr_enable == enable)
+                return size;
+
+        info.cpr_enable = enable;
+
+        r = mgr->set_manager_info(mgr, &info);
+        if (r)
+                return r;
+
+        r = mgr->apply(mgr);
+        if (r)
+                return r;
+
+        return size;
+}
+
+static ssize_t manager_cpr_coef_show(struct omap_overlay_manager *mgr,
+                char *buf)
+{
+        struct omap_overlay_manager_info info;
+
+        mgr->get_manager_info(mgr, &info);
+
+        return snprintf(buf, PAGE_SIZE,
+                        "%d %d %d %d %d %d %d %d %d\n",
+                        info.cpr_coefs.rr,
+                        info.cpr_coefs.rg,
+                        info.cpr_coefs.rb,
+                        info.cpr_coefs.gr,
+                        info.cpr_coefs.gg,
+                        info.cpr_coefs.gb,
+                        info.cpr_coefs.br,
+                        info.cpr_coefs.bg,
+                        info.cpr_coefs.bb);
+}
+
+static ssize_t manager_cpr_coef_store(struct omap_overlay_manager *mgr,
+                const char *buf, size_t size)
+{
+        struct omap_overlay_manager_info info;
+        struct omap_dss_cpr_coefs coefs;
+        int r, i;
+        s16 *arr;
+
+        if (!dss_has_feature(FEAT_CPR))
+                return -ENODEV;
+
+        if (sscanf(buf, "%hd %hd %hd %hd %hd %hd %hd %hd %hd",
+                                &coefs.rr, &coefs.rg, &coefs.rb,
+                                &coefs.gr, &coefs.gg, &coefs.gb,
+                                &coefs.br, &coefs.bg, &coefs.bb) != 9)
+                return -EINVAL;
+
+        arr = (s16[]){ coefs.rr, coefs.rg, coefs.rb,
+                coefs.gr, coefs.gg, coefs.gb,
+                coefs.br, coefs.bg, coefs.bb };
+
+        for (i = 0; i < 9; ++i) {
+                if (arr[i] < -512 || arr[i] > 511)
+                        return -EINVAL;
+        }
+
+        mgr->get_manager_info(mgr, &info);
+
+        info.cpr_coefs = coefs;
+
+        r = mgr->set_manager_info(mgr, &info);
+        if (r)
+                return r;
+
+        r = mgr->apply(mgr);
+        if (r)
+                return r;
+
+        return size;
+}
+
 struct manager_attribute {
         struct attribute attr;
         ssize_t (*show)(struct omap_overlay_manager *, char *);
@@ -300,6 +402,12 @@ static MANAGER_ATTR(trans_key_enabled, S_IRUGO|S_IWUSR,
 static MANAGER_ATTR(alpha_blending_enabled, S_IRUGO|S_IWUSR,
                 manager_alpha_blending_enabled_show,
                 manager_alpha_blending_enabled_store);
+static MANAGER_ATTR(cpr_enable, S_IRUGO|S_IWUSR,
+                manager_cpr_enable_show,
+                manager_cpr_enable_store);
+static MANAGER_ATTR(cpr_coef, S_IRUGO|S_IWUSR,
+                manager_cpr_coef_show,
+                manager_cpr_coef_store);
 
 
 static struct attribute *manager_sysfs_attrs[] = {
@@ -310,6 +418,8 @@ static struct attribute *manager_sysfs_attrs[] = {
         &manager_attr_trans_key_value.attr,
         &manager_attr_trans_key_enabled.attr,
         &manager_attr_alpha_blending_enabled.attr,
+        &manager_attr_cpr_enable.attr,
+        &manager_attr_cpr_coef.attr,
         NULL
 };
 
@@ -391,33 +501,14 @@ struct overlay_cache_data {
 
         bool enabled;
 
-        u32 paddr;
-        void __iomem *vaddr;
-        u32 p_uv_addr; /* relevant for NV12 format only */
-        u16 screen_width;
-        u16 width;
-        u16 height;
-        enum omap_color_mode color_mode;
-        u8 rotation;
-        enum omap_dss_rotation_type rotation_type;
-        bool mirror;
-
-        u16 pos_x;
-        u16 pos_y;
-        u16 out_width;  /* if 0, out_width == width */
-        u16 out_height; /* if 0, out_height == height */
-        u8 global_alpha;
-        u8 pre_mult_alpha;
+        struct omap_overlay_info info;
 
         enum omap_channel channel;
         bool replication;
         bool ilace;
 
-        enum omap_burst_size burst_size;
         u32 fifo_low;
         u32 fifo_high;
-
-        bool manual_update;
 };
 
 struct manager_cache_data {
@@ -429,15 +520,8 @@ struct manager_cache_data {
          * VSYNC/EVSYNC */
         bool shadow_dirty;
 
-        u32 default_color;
-
-        enum omap_dss_trans_key_type trans_key_type;
-        u32 trans_key;
-        bool trans_enabled;
-
-        bool alpha_enabled;
+        struct omap_overlay_manager_info info;
 
-        bool manual_upd_display;
         bool manual_update;
         bool do_manual_update;
 
@@ -539,24 +623,15 @@ static int dss_mgr_wait_for_go(struct omap_overlay_manager *mgr)
         if (!dssdev || dssdev->state != OMAP_DSS_DISPLAY_ACTIVE)
                 return 0;
 
+        if (dssdev->caps & OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE)
+                return 0;
+
         if (dssdev->type == OMAP_DISPLAY_TYPE_VENC
                         || dssdev->type == OMAP_DISPLAY_TYPE_HDMI) {
                 irq = DISPC_IRQ_EVSYNC_ODD | DISPC_IRQ_EVSYNC_EVEN;
         } else {
-                if (dssdev->caps & OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE) {
-                        enum omap_dss_update_mode mode;
-                        mode = dssdev->driver->get_update_mode(dssdev);
-                        if (mode != OMAP_DSS_UPDATE_AUTO)
-                                return 0;
-
-                        irq = (dssdev->manager->id == OMAP_DSS_CHANNEL_LCD) ?
-                                DISPC_IRQ_FRAMEDONE
-                                : DISPC_IRQ_FRAMEDONE2;
-                } else {
-                        irq = (dssdev->manager->id == OMAP_DSS_CHANNEL_LCD) ?
-                                DISPC_IRQ_VSYNC
-                                : DISPC_IRQ_VSYNC2;
-                }
+                irq = (dssdev->manager->id == OMAP_DSS_CHANNEL_LCD) ?
+                        DISPC_IRQ_VSYNC : DISPC_IRQ_VSYNC2;
         }
 
         mc = &dss_cache.manager_cache[mgr->id];
@@ -617,24 +692,15 @@ int dss_mgr_wait_for_go_ovl(struct omap_overlay *ovl)
         if (!dssdev || dssdev->state != OMAP_DSS_DISPLAY_ACTIVE)
                 return 0;
 
+        if (dssdev->caps & OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE)
+                return 0;
+
         if (dssdev->type == OMAP_DISPLAY_TYPE_VENC
                         || dssdev->type == OMAP_DISPLAY_TYPE_HDMI) {
                 irq = DISPC_IRQ_EVSYNC_ODD | DISPC_IRQ_EVSYNC_EVEN;
         } else {
-                if (dssdev->caps & OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE) {
-                        enum omap_dss_update_mode mode;
-                        mode = dssdev->driver->get_update_mode(dssdev);
-                        if (mode != OMAP_DSS_UPDATE_AUTO)
-                                return 0;
-
-                        irq = (dssdev->manager->id == OMAP_DSS_CHANNEL_LCD) ?
-                                DISPC_IRQ_FRAMEDONE
-                                : DISPC_IRQ_FRAMEDONE2;
-                } else {
-                        irq = (dssdev->manager->id == OMAP_DSS_CHANNEL_LCD) ?
-                                DISPC_IRQ_VSYNC
-                                : DISPC_IRQ_VSYNC2;
-                }
+                irq = (dssdev->manager->id == OMAP_DSS_CHANNEL_LCD) ?
+                        DISPC_IRQ_VSYNC : DISPC_IRQ_VSYNC2;
         }
 
         oc = &dss_cache.overlay_cache[ovl->id];
@@ -720,10 +786,12 @@ static bool rectangle_intersects(int x1, int y1, int w1, int h1,
 
 static bool dispc_is_overlay_scaled(struct overlay_cache_data *oc)
 {
-        if (oc->out_width != 0 && oc->width != oc->out_width)
+        struct omap_overlay_info *oi = &oc->info;
+
+        if (oi->out_width != 0 && oi->width != oi->out_width)
                 return true;
 
-        if (oc->out_height != 0 && oc->height != oc->out_height)
+        if (oi->out_height != 0 && oi->height != oi->out_height)
                 return true;
 
         return false;
@@ -733,6 +801,8 @@ static int configure_overlay(enum omap_plane plane)
 {
         struct overlay_cache_data *c;
         struct manager_cache_data *mc;
+        struct omap_overlay_info *oi;
+        struct omap_overlay_manager_info *mi;
         u16 outw, outh;
         u16 x, y, w, h;
         u32 paddr;
@@ -742,6 +812,7 @@ static int configure_overlay(enum omap_plane plane)
         DSSDBGF("%d", plane);
 
         c = &dss_cache.overlay_cache[plane];
+        oi = &c->info;
 
         if (!c->enabled) {
                 dispc_enable_plane(plane, 0);
@@ -749,21 +820,22 @@ static int configure_overlay(enum omap_plane plane)
         }
 
         mc = &dss_cache.manager_cache[c->channel];
+        mi = &mc->info;
 
-        x = c->pos_x;
-        y = c->pos_y;
-        w = c->width;
-        h = c->height;
-        outw = c->out_width == 0 ? c->width : c->out_width;
-        outh = c->out_height == 0 ? c->height : c->out_height;
-        paddr = c->paddr;
+        x = oi->pos_x;
+        y = oi->pos_y;
+        w = oi->width;
+        h = oi->height;
+        outw = oi->out_width == 0 ? oi->width : oi->out_width;
+        outh = oi->out_height == 0 ? oi->height : oi->out_height;
+        paddr = oi->paddr;
 
         orig_w = w;
         orig_h = h;
         orig_outw = outw;
         orig_outh = outh;
 
-        if (c->manual_update && mc->do_manual_update) {
+        if (mc->manual_update && mc->do_manual_update) {
                 unsigned bpp;
                 unsigned scale_x_m = w, scale_x_d = outw;
                 unsigned scale_y_m = h, scale_y_d = outh;
@@ -775,7 +847,7 @@ static int configure_overlay(enum omap_plane plane)
                         return 0;
                 }
 
-                switch (c->color_mode) {
+                switch (oi->color_mode) {
                 case OMAP_DSS_COLOR_NV12:
                         bpp = 8;
                         break;
@@ -805,23 +877,23 @@ static int configure_overlay(enum omap_plane plane)
                         BUG();
                 }
 
-                if (mc->x > c->pos_x) {
+                if (mc->x > oi->pos_x) {
                         x = 0;
-                        outw -= (mc->x - c->pos_x);
-                        paddr += (mc->x - c->pos_x) *
+                        outw -= (mc->x - oi->pos_x);
+                        paddr += (mc->x - oi->pos_x) *
                                 scale_x_m / scale_x_d * bpp / 8;
                 } else {
-                        x = c->pos_x - mc->x;
+                        x = oi->pos_x - mc->x;
                 }
 
-                if (mc->y > c->pos_y) {
+                if (mc->y > oi->pos_y) {
                         y = 0;
-                        outh -= (mc->y - c->pos_y);
-                        paddr += (mc->y - c->pos_y) *
+                        outh -= (mc->y - oi->pos_y);
+                        paddr += (mc->y - oi->pos_y) *
                                 scale_y_m / scale_y_d *
-                                c->screen_width * bpp / 8;
+                                oi->screen_width * bpp / 8;
                 } else {
-                        y = c->pos_y - mc->y;
+                        y = oi->pos_y - mc->y;
                 }
 
                 if (mc->w < (x + outw))
@@ -840,8 +912,8 @@ static int configure_overlay(enum omap_plane plane)
                  * the width if the original width was bigger.
                  */
                 if ((w & 1) &&
-                                (c->color_mode == OMAP_DSS_COLOR_YUV2 ||
-                                 c->color_mode == OMAP_DSS_COLOR_UYVY)) {
+                                (oi->color_mode == OMAP_DSS_COLOR_YUV2 ||
+                                 oi->color_mode == OMAP_DSS_COLOR_UYVY)) {
                         if (orig_w > w)
                                 w += 1;
                         else
@@ -851,19 +923,19 @@ static int configure_overlay(enum omap_plane plane)
 
         r = dispc_setup_plane(plane,
                         paddr,
-                        c->screen_width,
+                        oi->screen_width,
                         x, y,
                         w, h,
                         outw, outh,
-                        c->color_mode,
+                        oi->color_mode,
                         c->ilace,
-                        c->rotation_type,
-                        c->rotation,
-                        c->mirror,
-                        c->global_alpha,
-                        c->pre_mult_alpha,
+                        oi->rotation_type,
+                        oi->rotation,
+                        oi->mirror,
+                        oi->global_alpha,
+                        oi->pre_mult_alpha,
                         c->channel,
-                        c->p_uv_addr);
+                        oi->p_uv_addr);
 
         if (r) {
                 /* this shouldn't happen */
@@ -874,8 +946,7 @@ static int configure_overlay(enum omap_plane plane)
 
         dispc_enable_replication(plane, c->replication);
 
-        dispc_set_burst_size(plane, c->burst_size);
-        dispc_setup_plane_fifo(plane, c->fifo_low, c->fifo_high);
+        dispc_set_fifo_threshold(plane, c->fifo_low, c->fifo_high);
 
         dispc_enable_plane(plane, 1);
 
@@ -884,16 +955,21 @@ static int configure_overlay(enum omap_plane plane)
 
 static void configure_manager(enum omap_channel channel)
 {
-        struct manager_cache_data *c;
+        struct omap_overlay_manager_info *mi;
 
         DSSDBGF("%d", channel);
 
-        c = &dss_cache.manager_cache[channel];
+        /* picking info from the cache */
+        mi = &dss_cache.manager_cache[channel].info;
 
-        dispc_set_default_color(channel, c->default_color);
-        dispc_set_trans_key(channel, c->trans_key_type, c->trans_key);
-        dispc_enable_trans_key(channel, c->trans_enabled);
-        dispc_enable_alpha_blending(channel, c->alpha_enabled);
+        dispc_set_default_color(channel, mi->default_color);
+        dispc_set_trans_key(channel, mi->trans_key_type, mi->trans_key);
+        dispc_enable_trans_key(channel, mi->trans_enabled);
+        dispc_enable_alpha_blending(channel, mi->alpha_enabled);
+        if (dss_has_feature(FEAT_CPR)) {
+                dispc_enable_cpr(channel, mi->cpr_enable);
+                dispc_set_cpr_coef(channel, &mi->cpr_coefs);
+        }
 }
 
 /* configure_dispc() tries to write values from cache to shadow registers.
@@ -928,7 +1004,7 @@ static int configure_dispc(void)
                 if (!oc->dirty)
                         continue;
 
-                if (oc->manual_update && !mc->do_manual_update)
+                if (mc->manual_update && !mc->do_manual_update)
                         continue;
 
                 if (mgr_busy[oc->channel]) {
@@ -976,7 +1052,7 @@ static int configure_dispc(void)
                 /* We don't need GO with manual update display. LCD iface will
                  * always be turned off after frame, and new settings will be
                  * taken in to use at next update */
-                if (!mc->manual_upd_display)
+                if (!mc->manual_update)
                         dispc_go(i);
         }
 
@@ -1011,6 +1087,7 @@ void dss_setup_partial_planes(struct omap_dss_device *dssdev,
 {
         struct overlay_cache_data *oc;
         struct manager_cache_data *mc;
+        struct omap_overlay_info *oi;
         const int num_ovls = dss_feat_get_num_ovls();
         struct omap_overlay_manager *mgr;
         int i;
@@ -1053,6 +1130,7 @@ void dss_setup_partial_planes(struct omap_dss_device *dssdev,
                         unsigned outw, outh;
 
                         oc = &dss_cache.overlay_cache[i];
+                        oi = &oc->info;
 
                         if (oc->channel != mgr->id)
                                 continue;
@@ -1068,39 +1146,39 @@ void dss_setup_partial_planes(struct omap_dss_device *dssdev,
                         if (!dispc_is_overlay_scaled(oc))
                                 continue;
 
-                        outw = oc->out_width == 0 ?
-                                oc->width : oc->out_width;
-                        outh = oc->out_height == 0 ?
-                                oc->height : oc->out_height;
+                        outw = oi->out_width == 0 ?
+                                oi->width : oi->out_width;
+                        outh = oi->out_height == 0 ?
+                                oi->height : oi->out_height;
 
                         /* is the overlay outside the update region? */
                         if (!rectangle_intersects(x, y, w, h,
-                                                oc->pos_x, oc->pos_y,
+                                                oi->pos_x, oi->pos_y,
                                                 outw, outh))
                                 continue;
 
                         /* if the overlay totally inside the update region? */
-                        if (rectangle_subset(oc->pos_x, oc->pos_y, outw, outh,
+                        if (rectangle_subset(oi->pos_x, oi->pos_y, outw, outh,
                                                 x, y, w, h))
                                 continue;
 
-                        if (x > oc->pos_x)
-                                x1 = oc->pos_x;
+                        if (x > oi->pos_x)
+                                x1 = oi->pos_x;
                         else
                                 x1 = x;
 
-                        if (y > oc->pos_y)
-                                y1 = oc->pos_y;
+                        if (y > oi->pos_y)
+                                y1 = oi->pos_y;
                         else
                                 y1 = y;
 
-                        if ((x + w) < (oc->pos_x + outw))
-                                x2 = oc->pos_x + outw;
+                        if ((x + w) < (oi->pos_x + outw))
+                                x2 = oi->pos_x + outw;
                         else
                                 x2 = x + w;
 
-                        if ((y + h) < (oc->pos_y + outh))
-                                y2 = oc->pos_y + outh;
+                        if ((y + h) < (oi->pos_y + outh))
+                                y2 = oi->pos_y + outh;
                         else
                                 y2 = y + h;
 
@@ -1236,6 +1314,10 @@ static int omap_dss_mgr_apply(struct omap_overlay_manager *mgr)
 
         DSSDBG("omap_dss_mgr_apply(%s)\n", mgr->name);
 
+        r = dispc_runtime_get();
+        if (r)
+                return r;
+
         spin_lock_irqsave(&dss_cache.lock, flags);
 
         /* Configure overlays */
@@ -1275,23 +1357,7 @@ static int omap_dss_mgr_apply(struct omap_overlay_manager *mgr)
 
                 ovl->info_dirty = false;
                 oc->dirty = true;
-
-                oc->paddr = ovl->info.paddr;
-                oc->vaddr = ovl->info.vaddr;
-                oc->p_uv_addr = ovl->info.p_uv_addr;
-                oc->screen_width = ovl->info.screen_width;
-                oc->width = ovl->info.width;
-                oc->height = ovl->info.height;
-                oc->color_mode = ovl->info.color_mode;
-                oc->rotation = ovl->info.rotation;
-                oc->rotation_type = ovl->info.rotation_type;
-                oc->mirror = ovl->info.mirror;
-                oc->pos_x = ovl->info.pos_x;
-                oc->pos_y = ovl->info.pos_y;
-                oc->out_width = ovl->info.out_width;
-                oc->out_height = ovl->info.out_height;
-                oc->global_alpha = ovl->info.global_alpha;
-                oc->pre_mult_alpha = ovl->info.pre_mult_alpha;
+                oc->info = ovl->info;
 
                 oc->replication =
                         dss_use_replication(dssdev, ovl->info.color_mode);
@@ -1302,11 +1368,6 @@ static int omap_dss_mgr_apply(struct omap_overlay_manager *mgr)
 
                 oc->enabled = true;
 
-                oc->manual_update =
-                        dssdev->caps & OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE &&
-                        dssdev->driver->get_update_mode(dssdev) !=
-                                OMAP_DSS_UPDATE_AUTO;
-
                 ++num_planes_enabled;
         }
 
@@ -1334,20 +1395,10 @@ static int omap_dss_mgr_apply(struct omap_overlay_manager *mgr)
 
                 mgr->info_dirty = false;
                 mc->dirty = true;
-
-                mc->default_color = mgr->info.default_color;
-                mc->trans_key_type = mgr->info.trans_key_type;
-                mc->trans_key = mgr->info.trans_key;
-                mc->trans_enabled = mgr->info.trans_enabled;
-                mc->alpha_enabled = mgr->info.alpha_enabled;
-
-                mc->manual_upd_display =
-                        dssdev->caps & OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE;
+                mc->info = mgr->info;
 
                 mc->manual_update =
-                        dssdev->caps & OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE &&
-                        dssdev->driver->get_update_mode(dssdev) !=
-                                OMAP_DSS_UPDATE_AUTO;
+                        dssdev->caps & OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE;
         }
 
         /* XXX TODO: Try to get fifomerge working. The problem is that it
@@ -1368,7 +1419,7 @@ static int omap_dss_mgr_apply(struct omap_overlay_manager *mgr)
         /* Configure overlay fifos */
         for (i = 0; i < omap_dss_get_num_overlays(); ++i) {
                 struct omap_dss_device *dssdev;
-                u32 size;
+                u32 size, burst_size;
 
                 ovl = omap_dss_get_overlay(i);
 
@@ -1386,6 +1437,8 @@ static int omap_dss_mgr_apply(struct omap_overlay_manager *mgr)
                 if (use_fifomerge)
                         size *= 3;
 
+                burst_size = dispc_get_burst_size(ovl->id);
+
                 switch (dssdev->type) {
                 case OMAP_DISPLAY_TYPE_DPI:
                 case OMAP_DISPLAY_TYPE_DBI:
@@ -1393,13 +1446,13 @@ static int omap_dss_mgr_apply(struct omap_overlay_manager *mgr)
                 case OMAP_DISPLAY_TYPE_VENC:
                 case OMAP_DISPLAY_TYPE_HDMI:
                         default_get_overlay_fifo_thresholds(ovl->id, size,
-                                        &oc->burst_size, &oc->fifo_low,
+                                        burst_size, &oc->fifo_low,
                                         &oc->fifo_high);
                         break;
 #ifdef CONFIG_OMAP2_DSS_DSI
                 case OMAP_DISPLAY_TYPE_DSI:
                         dsi_get_overlay_fifo_thresholds(ovl->id, size,
-                                        &oc->burst_size, &oc->fifo_low,
+                                        burst_size, &oc->fifo_low,
                                         &oc->fifo_high);
                         break;
 #endif
@@ -1409,7 +1462,6 @@ static int omap_dss_mgr_apply(struct omap_overlay_manager *mgr)
         }
 
         r = 0;
-        dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK);
         if (!dss_cache.irq_enabled) {
                 u32 mask;
 
@@ -1422,10 +1474,11 @@ static int omap_dss_mgr_apply(struct omap_overlay_manager *mgr)
                 dss_cache.irq_enabled = true;
         }
         configure_dispc();
-        dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK);
 
         spin_unlock_irqrestore(&dss_cache.lock, flags);
 
+        dispc_runtime_put();
+
         return r;
 }
 
diff --git a/drivers/video/omap2/dss/overlay.c b/drivers/video/omap2/dss/overlay.c
index 0f08025b1f0e..c84380c53c39 100644
--- a/drivers/video/omap2/dss/overlay.c
+++ b/drivers/video/omap2/dss/overlay.c
@@ -84,32 +84,42 @@ static ssize_t overlay_manager_store(struct omap_overlay *ovl, const char *buf,
 
         old_mgr = ovl->manager;
 
+        r = dispc_runtime_get();
+        if (r)
+                return r;
+
         /* detach old manager */
         if (old_mgr) {
                 r = ovl->unset_manager(ovl);
                 if (r) {
                         DSSERR("detach failed\n");
-                        return r;
+                        goto err;
                 }
 
                 r = old_mgr->apply(old_mgr);
                 if (r)
-                        return r;
+                        goto err;
         }
 
         if (mgr) {
                 r = ovl->set_manager(ovl, mgr);
                 if (r) {
                         DSSERR("Failed to attach overlay\n");
-                        return r;
+                        goto err;
                 }
 
                 r = mgr->apply(mgr);
                 if (r)
-                        return r;
+                        goto err;
         }
 
+        dispc_runtime_put();
+
         return size;
+
+err:
+        dispc_runtime_put();
+        return r;
 }
 
 static ssize_t overlay_input_size_show(struct omap_overlay *ovl, char *buf)
@@ -238,6 +248,9 @@ static ssize_t overlay_global_alpha_store(struct omap_overlay *ovl,
         u8 alpha;
         struct omap_overlay_info info;
 
+        if (!dss_has_feature(FEAT_GLOBAL_ALPHA))
+                return -ENODEV;
+
         r = kstrtou8(buf, 0, &alpha);
         if (r)
                 return r;
@@ -504,7 +517,6 @@ static int omap_dss_set_manager(struct omap_overlay *ovl,
 
         ovl->manager = mgr;
 
-        dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK);
         /* XXX: When there is an overlay on a DSI manual update display, and
          * the overlay is first disabled, then moved to tv, and enabled, we
          * seem to get SYNC_LOST_DIGIT error.
@@ -518,7 +530,6 @@ static int omap_dss_set_manager(struct omap_overlay *ovl,
          * the overlay, but before moving the overlay to TV.
          */
         dispc_set_channel_out(ovl->id, mgr->id);
-        dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK);
 
         return 0;
 }
@@ -719,6 +730,8 @@ void dss_recheck_connections(struct omap_dss_device *dssdev, bool force)
         }
 
         if (mgr) {
+                dispc_runtime_get();
+
                 for (i = 0; i < dss_feat_get_num_ovls(); i++) {
                         struct omap_overlay *ovl;
                         ovl = omap_dss_get_overlay(i);
@@ -728,6 +741,8 @@ void dss_recheck_connections(struct omap_dss_device *dssdev, bool force)
                                 omap_dss_set_manager(ovl, mgr);
                         }
                 }
+
+                dispc_runtime_put();
         }
 }
 
diff --git a/drivers/video/omap2/dss/rfbi.c b/drivers/video/omap2/dss/rfbi.c
index c06fbe0bc678..39f4c597026a 100644
--- a/drivers/video/omap2/dss/rfbi.c
+++ b/drivers/video/omap2/dss/rfbi.c
@@ -33,6 +33,8 @@
 #include <linux/hrtimer.h>
 #include <linux/seq_file.h>
 #include <linux/semaphore.h>
+#include <linux/platform_device.h>
+#include <linux/pm_runtime.h>
 
 #include <video/omapdss.h>
 #include "dss.h"
@@ -120,12 +122,25 @@ static inline u32 rfbi_read_reg(const struct rfbi_reg idx)
         return __raw_readl(rfbi.base + idx.idx);
 }
 
-static void rfbi_enable_clocks(bool enable)
+static int rfbi_runtime_get(void)
 {
-        if (enable)
-                dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK);
-        else
-                dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK);
+        int r;
+
+        DSSDBG("rfbi_runtime_get\n");
+
+        r = pm_runtime_get_sync(&rfbi.pdev->dev);
+        WARN_ON(r < 0);
+        return r < 0 ? r : 0;
+}
+
+static void rfbi_runtime_put(void)
+{
+        int r;
+
+        DSSDBG("rfbi_runtime_put\n");
+
+        r = pm_runtime_put(&rfbi.pdev->dev);
+        WARN_ON(r < 0);
 }
 
 void rfbi_bus_lock(void)
@@ -805,7 +820,8 @@ void rfbi_dump_regs(struct seq_file *s)
 {
 #define DUMPREG(r) seq_printf(s, "%-35s %08x\n", #r, rfbi_read_reg(r))
 
-        dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK);
+        if (rfbi_runtime_get())
+                return;
 
         DUMPREG(RFBI_REVISION);
         DUMPREG(RFBI_SYSCONFIG);
@@ -836,7 +852,7 @@ void rfbi_dump_regs(struct seq_file *s)
         DUMPREG(RFBI_VSYNC_WIDTH);
         DUMPREG(RFBI_HSYNC_WIDTH);
 
-        dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK);
+        rfbi_runtime_put();
 #undef DUMPREG
 }
 
@@ -844,7 +860,9 @@ int omapdss_rfbi_display_enable(struct omap_dss_device *dssdev)
 {
         int r;
 
-        rfbi_enable_clocks(1);
+        r = rfbi_runtime_get();
+        if (r)
+                return r;
 
         r = omap_dss_start_device(dssdev);
         if (r) {
@@ -879,6 +897,7 @@ int omapdss_rfbi_display_enable(struct omap_dss_device *dssdev)
 err1:
         omap_dss_stop_device(dssdev);
 err0:
+        rfbi_runtime_put();
         return r;
 }
 EXPORT_SYMBOL(omapdss_rfbi_display_enable);
@@ -889,7 +908,7 @@ void omapdss_rfbi_display_disable(struct omap_dss_device *dssdev)
                         DISPC_IRQ_FRAMEDONE);
         omap_dss_stop_device(dssdev);
 
-        rfbi_enable_clocks(0);
+        rfbi_runtime_put();
 }
 EXPORT_SYMBOL(omapdss_rfbi_display_disable);
 
@@ -904,8 +923,9 @@ int rfbi_init_display(struct omap_dss_device *dssdev)
 static int omap_rfbihw_probe(struct platform_device *pdev)
 {
         u32 rev;
-        u32 l;
         struct resource *rfbi_mem;
+        struct clk *clk;
+        int r;
 
         rfbi.pdev = pdev;
 
@@ -914,46 +934,102 @@ static int omap_rfbihw_probe(struct platform_device *pdev)
         rfbi_mem = platform_get_resource(rfbi.pdev, IORESOURCE_MEM, 0);
         if (!rfbi_mem) {
                 DSSERR("can't get IORESOURCE_MEM RFBI\n");
-                return -EINVAL;
+                r = -EINVAL;
+                goto err_ioremap;
         }
         rfbi.base = ioremap(rfbi_mem->start, resource_size(rfbi_mem));
         if (!rfbi.base) {
                 DSSERR("can't ioremap RFBI\n");
-                return -ENOMEM;
+                r = -ENOMEM;
+                goto err_ioremap;
         }
 
-        rfbi_enable_clocks(1);
+        pm_runtime_enable(&pdev->dev);
+
+        r = rfbi_runtime_get();
+        if (r)
+                goto err_get_rfbi;
 
         msleep(10);
 
-        rfbi.l4_khz = dss_clk_get_rate(DSS_CLK_ICK) / 1000;
+        if (cpu_is_omap24xx() || cpu_is_omap34xx() || cpu_is_omap3630())
+                clk = dss_get_ick();
+        else
+                clk = clk_get(&pdev->dev, "ick");
+        if (IS_ERR(clk)) {
+                DSSERR("can't get ick\n");
+                r = PTR_ERR(clk);
+                goto err_get_ick;
+        }
+
+        rfbi.l4_khz = clk_get_rate(clk) / 1000;
 
-        /* Enable autoidle and smart-idle */
-        l = rfbi_read_reg(RFBI_SYSCONFIG);
-        l |= (1 << 0) | (2 << 3);
-        rfbi_write_reg(RFBI_SYSCONFIG, l);
+        clk_put(clk);
 
         rev = rfbi_read_reg(RFBI_REVISION);
         dev_dbg(&pdev->dev, "OMAP RFBI rev %d.%d\n",
                FLD_GET(rev, 7, 4), FLD_GET(rev, 3, 0));
 
-        rfbi_enable_clocks(0);
+        rfbi_runtime_put();
 
         return 0;
+
+err_get_ick:
+        rfbi_runtime_put();
+err_get_rfbi:
+        pm_runtime_disable(&pdev->dev);
+        iounmap(rfbi.base);
+err_ioremap:
+        return r;
 }
 
 static int omap_rfbihw_remove(struct platform_device *pdev)
 {
+        pm_runtime_disable(&pdev->dev);
         iounmap(rfbi.base);
         return 0;
 }
 
+static int rfbi_runtime_suspend(struct device *dev)
+{
+        dispc_runtime_put();
+        dss_runtime_put();
+
+        return 0;
+}
+
+static int rfbi_runtime_resume(struct device *dev)
+{
+        int r;
+
+        r = dss_runtime_get();
+        if (r < 0)
+                goto err_get_dss;
+
+        r = dispc_runtime_get();
+        if (r < 0)
+                goto err_get_dispc;
+
+        return 0;
+
+err_get_dispc:
+        dss_runtime_put();
+err_get_dss:
+        return r;
+}
+
+static const struct dev_pm_ops rfbi_pm_ops = {
+        .runtime_suspend = rfbi_runtime_suspend,
+        .runtime_resume = rfbi_runtime_resume,
+};
+
 static struct platform_driver omap_rfbihw_driver = {
         .probe          = omap_rfbihw_probe,
         .remove         = omap_rfbihw_remove,
         .driver         = {
                 .name   = "omapdss_rfbi",
                 .owner  = THIS_MODULE,
+                .pm     = &rfbi_pm_ops,
         },
 };
 
diff --git a/drivers/video/omap2/dss/sdi.c b/drivers/video/omap2/dss/sdi.c
index 0bd4b0350f80..3a688c871a45 100644
--- a/drivers/video/omap2/dss/sdi.c
+++ b/drivers/video/omap2/dss/sdi.c
@@ -20,13 +20,11 @@
 #define DSS_SUBSYS_NAME "SDI"
 
 #include <linux/kernel.h>
-#include <linux/clk.h>
 #include <linux/delay.h>
 #include <linux/err.h>
 #include <linux/regulator/consumer.h>
 
 #include <video/omapdss.h>
-#include <plat/cpu.h>
 #include "dss.h"
 
 static struct {
@@ -60,14 +58,20 @@ int omapdss_sdi_display_enable(struct omap_dss_device *dssdev)
         r = omap_dss_start_device(dssdev);
         if (r) {
                 DSSERR("failed to start device\n");
-                goto err0;
+                goto err_start_dev;
         }
 
         r = regulator_enable(sdi.vdds_sdi_reg);
         if (r)
-                goto err1;
+                goto err_reg_enable;
 
-        dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK);
+        r = dss_runtime_get();
+        if (r)
+                goto err_get_dss;
+
+        r = dispc_runtime_get();
+        if (r)
+                goto err_get_dispc;
 
         sdi_basic_init(dssdev);
 
@@ -80,7 +84,7 @@ int omapdss_sdi_display_enable(struct omap_dss_device *dssdev)
         r = dss_calc_clock_div(1, t->pixel_clock * 1000,
                         &dss_cinfo, &dispc_cinfo);
         if (r)
-                goto err2;
+                goto err_calc_clock_div;
 
         fck = dss_cinfo.fck;
         lck_div = dispc_cinfo.lck_div;
@@ -101,27 +105,34 @@ int omapdss_sdi_display_enable(struct omap_dss_device *dssdev)
 
         r = dss_set_clock_div(&dss_cinfo);
         if (r)
-                goto err2;
+                goto err_set_dss_clock_div;
 
         r = dispc_set_clock_div(dssdev->manager->id, &dispc_cinfo);
         if (r)
-                goto err2;
+                goto err_set_dispc_clock_div;
 
         dss_sdi_init(dssdev->phy.sdi.datapairs);
         r = dss_sdi_enable();
         if (r)
-                goto err1;
+                goto err_sdi_enable;
         mdelay(2);
 
         dssdev->manager->enable(dssdev->manager);
 
         return 0;
-err2:
-        dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK);
+
+err_sdi_enable:
+err_set_dispc_clock_div:
+err_set_dss_clock_div:
+err_calc_clock_div:
+        dispc_runtime_put();
+err_get_dispc:
+        dss_runtime_put();
+err_get_dss:
         regulator_disable(sdi.vdds_sdi_reg);
-err1:
+err_reg_enable:
         omap_dss_stop_device(dssdev);
-err0:
+err_start_dev:
         return r;
 }
 EXPORT_SYMBOL(omapdss_sdi_display_enable);
@@ -132,7 +143,8 @@ void omapdss_sdi_display_disable(struct omap_dss_device *dssdev)
 
         dss_sdi_disable();
 
-        dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK);
+        dispc_runtime_put();
+        dss_runtime_put();
 
         regulator_disable(sdi.vdds_sdi_reg);
 
diff --git a/drivers/video/omap2/dss/venc.c b/drivers/video/omap2/dss/venc.c
index 980f919ed987..173c66430dad 100644
--- a/drivers/video/omap2/dss/venc.c
+++ b/drivers/video/omap2/dss/venc.c
@@ -33,11 +33,13 @@
 #include <linux/seq_file.h>
 #include <linux/platform_device.h>
 #include <linux/regulator/consumer.h>
+#include <linux/pm_runtime.h>
 
 #include <video/omapdss.h>
 #include <plat/cpu.h>
 
 #include "dss.h"
+#include "dss_features.h"
 
 /* Venc registers */
 #define VENC_REV_ID                             0x00
@@ -292,6 +294,9 @@ static struct {
         struct mutex venc_lock;
         u32 wss_data;
         struct regulator *vdda_dac_reg;
+
+        struct clk      *tv_clk;
+        struct clk      *tv_dac_clk;
 } venc;
 
 static inline void venc_write_reg(int idx, u32 val)
@@ -380,14 +385,25 @@ static void venc_reset(void)
 #endif
 }
 
-static void venc_enable_clocks(int enable)
+static int venc_runtime_get(void)
+{
+        int r;
+
+        DSSDBG("venc_runtime_get\n");
+
+        r = pm_runtime_get_sync(&venc.pdev->dev);
+        WARN_ON(r < 0);
+        return r < 0 ? r : 0;
+}
+
+static void venc_runtime_put(void)
 {
-        if (enable)
-                dss_clk_enable(DSS_CLK_ICK | DSS_CLK_FCK | DSS_CLK_TVFCK |
-                                DSS_CLK_VIDFCK);
-        else
-                dss_clk_disable(DSS_CLK_ICK | DSS_CLK_FCK | DSS_CLK_TVFCK |
-                                DSS_CLK_VIDFCK);
+        int r;
+
+        DSSDBG("venc_runtime_put\n");
+
+        r = pm_runtime_put(&venc.pdev->dev);
+        WARN_ON(r < 0);
 }
 
 static const struct venc_config *venc_timings_to_config(
@@ -406,8 +422,6 @@ static void venc_power_on(struct omap_dss_device *dssdev)
 {
         u32 l;
 
-        venc_enable_clocks(1);
-
         venc_reset();
         venc_write_config(venc_timings_to_config(&dssdev->panel.timings));
 
@@ -448,8 +462,6 @@ static void venc_power_off(struct omap_dss_device *dssdev)
                 dssdev->platform_disable(dssdev);
 
         regulator_disable(venc.vdda_dac_reg);
-
-        venc_enable_clocks(0);
 }
 
 
@@ -487,6 +499,10 @@ static int venc_panel_enable(struct omap_dss_device *dssdev)
                 goto err1;
         }
 
+        r = venc_runtime_get();
+        if (r)
+                goto err1;
+
         venc_power_on(dssdev);
 
         venc.wss_data = 0;
@@ -520,6 +536,8 @@ static void venc_panel_disable(struct omap_dss_device *dssdev)
 
         venc_power_off(dssdev);
 
+        venc_runtime_put();
+
         dssdev->state = OMAP_DSS_DISPLAY_DISABLED;
 
         omap_dss_stop_device(dssdev);
@@ -538,20 +556,6 @@ static int venc_panel_resume(struct omap_dss_device *dssdev)
         return venc_panel_enable(dssdev);
 }
 
-static enum omap_dss_update_mode venc_get_update_mode(
-                struct omap_dss_device *dssdev)
-{
-        return OMAP_DSS_UPDATE_AUTO;
-}
-
-static int venc_set_update_mode(struct omap_dss_device *dssdev,
-                enum omap_dss_update_mode mode)
-{
-        if (mode != OMAP_DSS_UPDATE_AUTO)
-                return -EINVAL;
-        return 0;
-}
-
 static void venc_get_timings(struct omap_dss_device *dssdev,
                         struct omap_video_timings *timings)
 {
@@ -598,6 +602,7 @@ static u32 venc_get_wss(struct omap_dss_device *dssdev)
 static int venc_set_wss(struct omap_dss_device *dssdev, u32 wss)
 {
         const struct venc_config *config;
+        int r;
 
         DSSDBG("venc_set_wss\n");
 
@@ -608,16 +613,19 @@ static int venc_set_wss(struct omap_dss_device *dssdev,	u32 wss)
         /* Invert due to VENC_L21_WC_CTL:INV=1 */
         venc.wss_data = (wss ^ 0xfffff) << 8;
 
-        venc_enable_clocks(1);
+        r = venc_runtime_get();
+        if (r)
+                goto err;
 
         venc_write_reg(VENC_BSTAMP_WSS_DATA, config->bstamp_wss_data |
                         venc.wss_data);
 
-        venc_enable_clocks(0);
+        venc_runtime_put();
 
+err:
         mutex_unlock(&venc.venc_lock);
 
-        return 0;
+        return r;
 }
 
 static struct omap_dss_driver venc_driver = {
@@ -632,9 +640,6 @@ static struct omap_dss_driver venc_driver = {
         .get_resolution = omapdss_default_get_resolution,
         .get_recommended_bpp = omapdss_default_get_recommended_bpp,
 
-        .set_update_mode = venc_set_update_mode,
-        .get_update_mode = venc_get_update_mode,
-
         .get_timings    = venc_get_timings,
         .set_timings    = venc_set_timings,
         .check_timings  = venc_check_timings,
@@ -673,7 +678,8 @@ void venc_dump_regs(struct seq_file *s)
 {
 #define DUMPREG(r) seq_printf(s, "%-35s %08x\n", #r, venc_read_reg(r))
 
-        venc_enable_clocks(1);
+        if (venc_runtime_get())
+                return;
 
         DUMPREG(VENC_F_CONTROL);
         DUMPREG(VENC_VIDOUT_CTRL);
@@ -717,16 +723,56 @@ void venc_dump_regs(struct seq_file *s)
         DUMPREG(VENC_OUTPUT_CONTROL);
         DUMPREG(VENC_OUTPUT_TEST);
 
-        venc_enable_clocks(0);
+        venc_runtime_put();
 
 #undef DUMPREG
 }
 
+static int venc_get_clocks(struct platform_device *pdev)
+{
+        struct clk *clk;
+
+        clk = clk_get(&pdev->dev, "fck");
+        if (IS_ERR(clk)) {
+                DSSERR("can't get fck\n");
+                return PTR_ERR(clk);
+        }
+
+        venc.tv_clk = clk;
+
+        if (dss_has_feature(FEAT_VENC_REQUIRES_TV_DAC_CLK)) {
+                if (cpu_is_omap34xx() || cpu_is_omap3630())
+                        clk = clk_get(&pdev->dev, "dss_96m_fck");
+                else
+                        clk = clk_get(&pdev->dev, "tv_dac_clk");
+                if (IS_ERR(clk)) {
+                        DSSERR("can't get tv_dac_clk\n");
+                        clk_put(venc.tv_clk);
+                        return PTR_ERR(clk);
+                }
+        } else {
+                clk = NULL;
+        }
+
+        venc.tv_dac_clk = clk;
+
+        return 0;
+}
+
+static void venc_put_clocks(void)
+{
+        if (venc.tv_clk)
+                clk_put(venc.tv_clk);
+        if (venc.tv_dac_clk)
+                clk_put(venc.tv_dac_clk);
+}
+
 /* VENC HW IP initialisation */
 static int omap_venchw_probe(struct platform_device *pdev)
 {
         u8 rev_id;
         struct resource *venc_mem;
+        int r;
 
         venc.pdev = pdev;
 
@@ -737,22 +783,40 @@ static int omap_venchw_probe(struct platform_device *pdev)
         venc_mem = platform_get_resource(venc.pdev, IORESOURCE_MEM, 0);
         if (!venc_mem) {
                 DSSERR("can't get IORESOURCE_MEM VENC\n");
-                return -EINVAL;
+                r = -EINVAL;
+                goto err_ioremap;
         }
         venc.base = ioremap(venc_mem->start, resource_size(venc_mem));
         if (!venc.base) {
                 DSSERR("can't ioremap VENC\n");
-                return -ENOMEM;
+                r = -ENOMEM;
+                goto err_ioremap;
         }
 
-        venc_enable_clocks(1);
+        r = venc_get_clocks(pdev);
+        if (r)
+                goto err_get_clk;
+
+        pm_runtime_enable(&pdev->dev);
+
+        r = venc_runtime_get();
+        if (r)
+                goto err_get_venc;
 
         rev_id = (u8)(venc_read_reg(VENC_REV_ID) & 0xff);
         dev_dbg(&pdev->dev, "OMAP VENC rev %d\n", rev_id);
 
-        venc_enable_clocks(0);
+        venc_runtime_put();
 
         return omap_dss_register_driver(&venc_driver);
+
+err_get_venc:
+        pm_runtime_disable(&pdev->dev);
+        venc_put_clocks();
+err_get_clk:
+        iounmap(venc.base);
+err_ioremap:
+        return r;
 }
 
 static int omap_venchw_remove(struct platform_device *pdev)
@@ -763,16 +827,61 @@ static int omap_venchw_remove(struct platform_device *pdev)
         }
         omap_dss_unregister_driver(&venc_driver);
 
+        pm_runtime_disable(&pdev->dev);
+        venc_put_clocks();
+
         iounmap(venc.base);
         return 0;
 }
 
+static int venc_runtime_suspend(struct device *dev)
+{
+        if (venc.tv_dac_clk)
+                clk_disable(venc.tv_dac_clk);
+        clk_disable(venc.tv_clk);
+
+        dispc_runtime_put();
+        dss_runtime_put();
+
+        return 0;
+}
+
+static int venc_runtime_resume(struct device *dev)
+{
+        int r;
+
+        r = dss_runtime_get();
+        if (r < 0)
+                goto err_get_dss;
+
+        r = dispc_runtime_get();
+        if (r < 0)
+                goto err_get_dispc;
+
+        clk_enable(venc.tv_clk);
+        if (venc.tv_dac_clk)
+                clk_enable(venc.tv_dac_clk);
+
+        return 0;
+
+err_get_dispc:
+        dss_runtime_put();
+err_get_dss:
+        return r;
+}
+
+static const struct dev_pm_ops venc_pm_ops = {
+        .runtime_suspend = venc_runtime_suspend,
+        .runtime_resume = venc_runtime_resume,
+};
+
 static struct platform_driver omap_venchw_driver = {
         .probe          = omap_venchw_probe,
         .remove         = omap_venchw_remove,
         .driver         = {
                 .name   = "omapdss_venc",
                 .owner  = THIS_MODULE,
+                .pm     = &venc_pm_ops,
         },
 };
 
diff --git a/drivers/video/omap2/omapfb/omapfb-ioctl.c b/drivers/video/omap2/omapfb/omapfb-ioctl.c
index cff450392b79..6b1ac23dbbd3 100644
--- a/drivers/video/omap2/omapfb/omapfb-ioctl.c
+++ b/drivers/video/omap2/omapfb/omapfb-ioctl.c
@@ -316,67 +316,67 @@ int omapfb_update_window(struct fb_info *fbi,
 }
 EXPORT_SYMBOL(omapfb_update_window);
 
-static int omapfb_set_update_mode(struct fb_info *fbi,
+int omapfb_set_update_mode(struct fb_info *fbi,
                                    enum omapfb_update_mode mode)
 {
         struct omap_dss_device *display = fb2display(fbi);
-        enum omap_dss_update_mode um;
+        struct omapfb_info *ofbi = FB2OFB(fbi);
+        struct omapfb2_device *fbdev = ofbi->fbdev;
+        struct omapfb_display_data *d;
         int r;
 
-        if (!display || !display->driver->set_update_mode)
+        if (!display)
                 return -EINVAL;
 
-        switch (mode) {
-        case OMAPFB_UPDATE_DISABLED:
-                um = OMAP_DSS_UPDATE_DISABLED;
-                break;
+        if (mode != OMAPFB_AUTO_UPDATE && mode != OMAPFB_MANUAL_UPDATE)
+                return -EINVAL;
 
-        case OMAPFB_AUTO_UPDATE:
-                um = OMAP_DSS_UPDATE_AUTO;
-                break;
+        omapfb_lock(fbdev);
 
-        case OMAPFB_MANUAL_UPDATE:
-                um = OMAP_DSS_UPDATE_MANUAL;
-                break;
+        d = get_display_data(fbdev, display);
 
-        default:
-                return -EINVAL;
+        if (d->update_mode == mode) {
+                omapfb_unlock(fbdev);
+                return 0;
         }
 
-        r = display->driver->set_update_mode(display, um);
+        r = 0;
+
+        if (display->caps & OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE) {
+                if (mode == OMAPFB_AUTO_UPDATE)
+                        omapfb_start_auto_update(fbdev, display);
+                else /* MANUAL_UPDATE */
+                        omapfb_stop_auto_update(fbdev, display);
+
+                d->update_mode = mode;
+        } else { /* AUTO_UPDATE */
+                if (mode == OMAPFB_MANUAL_UPDATE)
+                        r = -EINVAL;
+        }
+
+        omapfb_unlock(fbdev);
 
         return r;
 }
 
-static int omapfb_get_update_mode(struct fb_info *fbi,
+int omapfb_get_update_mode(struct fb_info *fbi,
                 enum omapfb_update_mode *mode)
 {
         struct omap_dss_device *display = fb2display(fbi);
-        enum omap_dss_update_mode m;
+        struct omapfb_info *ofbi = FB2OFB(fbi);
+        struct omapfb2_device *fbdev = ofbi->fbdev;
+        struct omapfb_display_data *d;
 
         if (!display)
                 return -EINVAL;
 
-        if (!display->driver->get_update_mode) {
-                *mode = OMAPFB_AUTO_UPDATE;
-                return 0;
-        }
+        omapfb_lock(fbdev);
 
-        m = display->driver->get_update_mode(display);
+        d = get_display_data(fbdev, display);
 
-        switch (m) {
-        case OMAP_DSS_UPDATE_DISABLED:
-                *mode = OMAPFB_UPDATE_DISABLED;
-                break;
-        case OMAP_DSS_UPDATE_AUTO:
-                *mode = OMAPFB_AUTO_UPDATE;
-                break;
-        case OMAP_DSS_UPDATE_MANUAL:
-                *mode = OMAPFB_MANUAL_UPDATE;
-                break;
-        default:
-                BUG();
-        }
+        *mode = d->update_mode;
+
+        omapfb_unlock(fbdev);
 
         return 0;
 }
diff --git a/drivers/video/omap2/omapfb/omapfb-main.c b/drivers/video/omap2/omapfb/omapfb-main.c
index 505bc12a3031..602b71a92d3c 100644
--- a/drivers/video/omap2/omapfb/omapfb-main.c
+++ b/drivers/video/omap2/omapfb/omapfb-main.c
@@ -46,6 +46,10 @@ static char *def_vram;
 static int def_vrfb;
 static int def_rotate;
 static int def_mirror;
+static bool auto_update;
+static unsigned int auto_update_freq;
+module_param(auto_update, bool, 0);
+module_param(auto_update_freq, uint, 0644);
 
 #ifdef DEBUG
 unsigned int omapfb_debug;
@@ -1242,6 +1246,7 @@ static int omapfb_blank(int blank, struct fb_info *fbi)
         struct omapfb_info *ofbi = FB2OFB(fbi);
         struct omapfb2_device *fbdev = ofbi->fbdev;
         struct omap_dss_device *display = fb2display(fbi);
+        struct omapfb_display_data *d;
         int r = 0;
 
         if (!display)
@@ -1249,6 +1254,8 @@ static int omapfb_blank(int blank, struct fb_info *fbi)
 
         omapfb_lock(fbdev);
 
+        d = get_display_data(fbdev, display);
+
         switch (blank) {
         case FB_BLANK_UNBLANK:
                 if (display->state != OMAP_DSS_DISPLAY_SUSPENDED)
@@ -1257,6 +1264,11 @@ static int omapfb_blank(int blank, struct fb_info *fbi)
                 if (display->driver->resume)
                         r = display->driver->resume(display);
 
+                if ((display->caps & OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE) &&
+                                d->update_mode == OMAPFB_AUTO_UPDATE &&
+                                !d->auto_update_work_enabled)
+                        omapfb_start_auto_update(fbdev, display);
+
                 break;
 
         case FB_BLANK_NORMAL:
@@ -1268,6 +1280,9 @@ static int omapfb_blank(int blank, struct fb_info *fbi)
                 if (display->state != OMAP_DSS_DISPLAY_ACTIVE)
                         goto exit;
 
+                if (d->auto_update_work_enabled)
+                        omapfb_stop_auto_update(fbdev, display);
+
                 if (display->driver->suspend)
                         r = display->driver->suspend(display);
 
@@ -1724,6 +1739,78 @@ err:
         return r;
 }
 
+static void omapfb_auto_update_work(struct work_struct *work)
+{
+        struct omap_dss_device *dssdev;
+        struct omap_dss_driver *dssdrv;
+        struct omapfb_display_data *d;
+        u16 w, h;
+        unsigned int freq;
+        struct omapfb2_device *fbdev;
+
+        d = container_of(work, struct omapfb_display_data,
+                        auto_update_work.work);
+
+        dssdev = d->dssdev;
+        dssdrv = dssdev->driver;
+        fbdev = d->fbdev;
+
+        if (!dssdrv || !dssdrv->update)
+                return;
+
+        if (dssdrv->sync)
+                dssdrv->sync(dssdev);
+
+        dssdrv->get_resolution(dssdev, &w, &h);
+        dssdrv->update(dssdev, 0, 0, w, h);
+
+        freq = auto_update_freq;
+        if (freq == 0)
+                freq = 20;
+        queue_delayed_work(fbdev->auto_update_wq,
+                        &d->auto_update_work, HZ / freq);
+}
+
+void omapfb_start_auto_update(struct omapfb2_device *fbdev,
+                struct omap_dss_device *display)
+{
+        struct omapfb_display_data *d;
+
+        if (fbdev->auto_update_wq == NULL) {
+                struct workqueue_struct *wq;
+
+                wq = create_singlethread_workqueue("omapfb_auto_update");
+
+                if (wq == NULL) {
+                        dev_err(fbdev->dev, "Failed to create workqueue for "
+                                        "auto-update\n");
+                        return;
+                }
+
+                fbdev->auto_update_wq = wq;
+        }
+
+        d = get_display_data(fbdev, display);
+
+        INIT_DELAYED_WORK(&d->auto_update_work, omapfb_auto_update_work);
+
+        d->auto_update_work_enabled = true;
+
+        omapfb_auto_update_work(&d->auto_update_work.work);
+}
+
+void omapfb_stop_auto_update(struct omapfb2_device *fbdev,
+                struct omap_dss_device *display)
+{
+        struct omapfb_display_data *d;
+
+        d = get_display_data(fbdev, display);
+
+        cancel_delayed_work_sync(&d->auto_update_work);
+
+        d->auto_update_work_enabled = false;
+}
+
 /* initialize fb_info, var, fix to something sane based on the display */
 static int omapfb_fb_init(struct omapfb2_device *fbdev, struct fb_info *fbi)
 {
@@ -1858,10 +1945,21 @@ static void omapfb_free_resources(struct omapfb2_device *fbdev)
         }
 
         for (i = 0; i < fbdev->num_displays; i++) {
-                if (fbdev->displays[i]->state != OMAP_DSS_DISPLAY_DISABLED)
-                        fbdev->displays[i]->driver->disable(fbdev->displays[i]);
+                struct omap_dss_device *dssdev = fbdev->displays[i].dssdev;
+
+                if (fbdev->displays[i].auto_update_work_enabled)
+                        omapfb_stop_auto_update(fbdev, dssdev);
+
+                if (dssdev->state != OMAP_DSS_DISPLAY_DISABLED)
+                        dssdev->driver->disable(dssdev);
+
+                omap_dss_put_device(dssdev);
+        }
 
-                omap_dss_put_device(fbdev->displays[i]);
+        if (fbdev->auto_update_wq != NULL) {
+                flush_workqueue(fbdev->auto_update_wq);
+                destroy_workqueue(fbdev->auto_update_wq);
+                fbdev->auto_update_wq = NULL;
         }
 
         dev_set_drvdata(fbdev->dev, NULL);
@@ -2084,14 +2182,14 @@ static int omapfb_set_def_mode(struct omapfb2_device *fbdev,
         int r;
         u8 bpp;
         struct omap_video_timings timings, temp_timings;
+        struct omapfb_display_data *d;
 
         r = omapfb_mode_to_timings(mode_str, &timings, &bpp);
         if (r)
                 return r;
 
-        fbdev->bpp_overrides[fbdev->num_bpp_overrides].dssdev = display;
-        fbdev->bpp_overrides[fbdev->num_bpp_overrides].bpp = bpp;
-        ++fbdev->num_bpp_overrides;
+        d = get_display_data(fbdev, display);
+        d->bpp_override = bpp;
 
         if (display->driver->check_timings) {
                 r = display->driver->check_timings(display, &timings);
@@ -2117,14 +2215,14 @@ static int omapfb_set_def_mode(struct omapfb2_device *fbdev,
 static int omapfb_get_recommended_bpp(struct omapfb2_device *fbdev,
                 struct omap_dss_device *dssdev)
 {
-        int i;
+        struct omapfb_display_data *d;
 
         BUG_ON(dssdev->driver->get_recommended_bpp == NULL);
 
-        for (i = 0; i < fbdev->num_bpp_overrides; ++i) {
-                if (dssdev == fbdev->bpp_overrides[i].dssdev)
-                        return fbdev->bpp_overrides[i].bpp;
-        }
+        d = get_display_data(fbdev, dssdev);
+
+        if (d->bpp_override != 0)
+                return d->bpp_override;
 
         return dssdev->driver->get_recommended_bpp(dssdev);
 }
@@ -2156,9 +2254,9 @@ static int omapfb_parse_def_modes(struct omapfb2_device *fbdev)
 
                 display = NULL;
                 for (i = 0; i < fbdev->num_displays; ++i) {
-                        if (strcmp(fbdev->displays[i]->name,
+                        if (strcmp(fbdev->displays[i].dssdev->name,
                                                 display_str) == 0) {
-                                display = fbdev->displays[i];
+                                display = fbdev->displays[i].dssdev;
                                 break;
                         }
                 }
@@ -2182,6 +2280,7 @@ static int omapfb_init_display(struct omapfb2_device *fbdev,
                 struct omap_dss_device *dssdev)
 {
         struct omap_dss_driver *dssdrv = dssdev->driver;
+        struct omapfb_display_data *d;
         int r;
 
         r = dssdrv->enable(dssdev);
@@ -2191,8 +2290,20 @@ static int omapfb_init_display(struct omapfb2_device *fbdev,
                 return r;
         }
 
+        d = get_display_data(fbdev, dssdev);
+
+        d->fbdev = fbdev;
+
         if (dssdev->caps & OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE) {
                 u16 w, h;
+
+                if (auto_update) {
+                        omapfb_start_auto_update(fbdev, dssdev);
+                        d->update_mode = OMAPFB_AUTO_UPDATE;
+                } else {
+                        d->update_mode = OMAPFB_MANUAL_UPDATE;
+                }
+
                 if (dssdrv->enable_te) {
                         r = dssdrv->enable_te(dssdev, 1);
                         if (r) {
@@ -2201,16 +2312,6 @@ static int omapfb_init_display(struct omapfb2_device *fbdev,
                         }
                 }
 
-                if (dssdrv->set_update_mode) {
-                        r = dssdrv->set_update_mode(dssdev,
-                                        OMAP_DSS_UPDATE_MANUAL);
-                        if (r) {
-                                dev_err(fbdev->dev,
-                                                "Failed to set update mode\n");
-                                return r;
-                        }
-                }
-
                 dssdrv->get_resolution(dssdev, &w, &h);
                 r = dssdrv->update(dssdev, 0, 0, w, h);
                 if (r) {
@@ -2219,15 +2320,7 @@ static int omapfb_init_display(struct omapfb2_device *fbdev,
                         return r;
                 }
         } else {
-                if (dssdrv->set_update_mode) {
-                        r = dssdrv->set_update_mode(dssdev,
-                                        OMAP_DSS_UPDATE_AUTO);
-                        if (r) {
-                                dev_err(fbdev->dev,
-                                                "Failed to set update mode\n");
-                                return r;
-                        }
-                }
+                d->update_mode = OMAPFB_AUTO_UPDATE;
         }
 
         return 0;
@@ -2275,6 +2368,8 @@ static int omapfb_probe(struct platform_device *pdev)
         fbdev->num_displays = 0;
         dssdev = NULL;
         for_each_dss_dev(dssdev) {
+                struct omapfb_display_data *d;
+
                 omap_dss_get_device(dssdev);
 
                 if (!dssdev->driver) {
@@ -2282,7 +2377,12 @@ static int omapfb_probe(struct platform_device *pdev)
                         r = -ENODEV;
                 }
 
-                fbdev->displays[fbdev->num_displays++] = dssdev;
+                d = &fbdev->displays[fbdev->num_displays++];
+                d->dssdev = dssdev;
+                if (dssdev->caps & OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE)
+                        d->update_mode = OMAPFB_MANUAL_UPDATE;
+                else
+                        d->update_mode = OMAPFB_AUTO_UPDATE;
         }
 
         if (r)
diff --git a/drivers/video/omap2/omapfb/omapfb-sysfs.c b/drivers/video/omap2/omapfb/omapfb-sysfs.c
index 2f5e817b2a9a..153bf1aceebc 100644
--- a/drivers/video/omap2/omapfb/omapfb-sysfs.c
+++ b/drivers/video/omap2/omapfb/omapfb-sysfs.c
@@ -518,6 +518,39 @@ static ssize_t show_virt(struct device *dev,
         return snprintf(buf, PAGE_SIZE, "%p\n", ofbi->region->vaddr);
 }
 
+static ssize_t show_upd_mode(struct device *dev,
+                struct device_attribute *attr, char *buf)
+{
+        struct fb_info *fbi = dev_get_drvdata(dev);
+        enum omapfb_update_mode mode;
+        int r;
+
+        r = omapfb_get_update_mode(fbi, &mode);
+
+        if (r)
+                return r;
+
+        return snprintf(buf, PAGE_SIZE, "%u\n", (unsigned)mode);
+}
+
+static ssize_t store_upd_mode(struct device *dev, struct device_attribute *attr,
+                const char *buf, size_t count)
+{
+        struct fb_info *fbi = dev_get_drvdata(dev);
+        unsigned mode;
+        int r;
+
+        r = kstrtouint(buf, 0, &mode);
+        if (r)
+                return r;
+
+        r = omapfb_set_update_mode(fbi, mode);
+        if (r)
+                return r;
+
+        return count;
+}
+
 static struct device_attribute omapfb_attrs[] = {
         __ATTR(rotate_type, S_IRUGO | S_IWUSR, show_rotate_type,
                         store_rotate_type),
@@ -528,6 +561,7 @@ static struct device_attribute omapfb_attrs[] = {
                         store_overlays_rotate),
         __ATTR(phys_addr, S_IRUGO, show_phys, NULL),
         __ATTR(virt_addr, S_IRUGO, show_virt, NULL),
+        __ATTR(update_mode, S_IRUGO | S_IWUSR, show_upd_mode, store_upd_mode),
 };
 
 int omapfb_create_sysfs(struct omapfb2_device *fbdev)
diff --git a/drivers/video/omap2/omapfb/omapfb.h b/drivers/video/omap2/omapfb/omapfb.h
index aa1b1d974276..fdf0edeccf4e 100644
--- a/drivers/video/omap2/omapfb/omapfb.h
+++ b/drivers/video/omap2/omapfb/omapfb.h
@@ -73,6 +73,15 @@ struct omapfb_info {
         bool mirror;
 };
 
+struct omapfb_display_data {
+        struct omapfb2_device *fbdev;
+        struct omap_dss_device *dssdev;
+        u8 bpp_override;
+        enum omapfb_update_mode update_mode;
+        bool auto_update_work_enabled;
+        struct delayed_work auto_update_work;
+};
+
 struct omapfb2_device {
         struct device *dev;
         struct mutex  mtx;
@@ -86,17 +95,13 @@ struct omapfb2_device {
         struct omapfb2_mem_region regions[10];
 
         unsigned num_displays;
-        struct omap_dss_device *displays[10];
+        struct omapfb_display_data displays[10];
         unsigned num_overlays;
         struct omap_overlay *overlays[10];
         unsigned num_managers;
         struct omap_overlay_manager *managers[10];
 
-        unsigned num_bpp_overrides;
-        struct {
-                struct omap_dss_device *dssdev;
-                u8 bpp;
-        } bpp_overrides[10];
+        struct workqueue_struct *auto_update_wq;
 };
 
 struct omapfb_colormode {
@@ -128,6 +133,13 @@ int dss_mode_to_fb_mode(enum omap_color_mode dssmode,
 int omapfb_setup_overlay(struct fb_info *fbi, struct omap_overlay *ovl,
                 u16 posx, u16 posy, u16 outw, u16 outh);
 
+void omapfb_start_auto_update(struct omapfb2_device *fbdev,
+                struct omap_dss_device *display);
+void omapfb_stop_auto_update(struct omapfb2_device *fbdev,
+                struct omap_dss_device *display);
+int omapfb_get_update_mode(struct fb_info *fbi, enum omapfb_update_mode *mode);
+int omapfb_set_update_mode(struct fb_info *fbi, enum omapfb_update_mode mode);
+
 /* find the display connected to this fb, if any */
 static inline struct omap_dss_device *fb2display(struct fb_info *fbi)
 {
@@ -143,6 +155,19 @@ static inline struct omap_dss_device *fb2display(struct fb_info *fbi)
         return NULL;
 }
 
+static inline struct omapfb_display_data *get_display_data(
+                struct omapfb2_device *fbdev, struct omap_dss_device *dssdev)
+{
+        int i;
+
+        for (i = 0; i < fbdev->num_displays; ++i)
+                if (fbdev->displays[i].dssdev == dssdev)
+                        return &fbdev->displays[i];
+
+        /* This should never happen */
+        BUG();
+}
+
 static inline void omapfb_lock(struct omapfb2_device *fbdev)
 {
         mutex_lock(&fbdev->mtx);
diff --git a/drivers/video/savage/savagefb.h b/drivers/video/savage/savagefb.h
index 32549d177b19..dcaab9012ca2 100644
--- a/drivers/video/savage/savagefb.h
+++ b/drivers/video/savage/savagefb.h
@@ -55,7 +55,7 @@
 
 #define S3_SAVAGE3D_SERIES(chip)  ((chip>=S3_SAVAGE3D) && (chip<=S3_SAVAGE_MX))
 
-#define S3_SAVAGE4_SERIES(chip)   ((chip>=S3_SAVAGE4) || (chip<=S3_PROSAVAGEDDR))
+#define S3_SAVAGE4_SERIES(chip)   ((chip>=S3_SAVAGE4) && (chip<=S3_PROSAVAGEDDR))
 
 #define S3_SAVAGE_MOBILE_SERIES(chip)  ((chip==S3_SAVAGE_MX) || (chip==S3_SUPERSAVAGE))
 
diff --git a/drivers/w1/masters/ds2490.c b/drivers/w1/masters/ds2490.c
index 02bf7bf7160b..b5abaae38e97 100644
--- a/drivers/w1/masters/ds2490.c
+++ b/drivers/w1/masters/ds2490.c
@@ -1,7 +1,7 @@
 /*
  *      dscore.c
  *
- * Copyright (c) 2004 Evgeniy Polyakov <johnpol@2ka.mipt.ru>
+ * Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net>
  *
  *
  * This program is free software; you can redistribute it and/or modify
@@ -1024,5 +1024,5 @@ module_init(ds_init);
 module_exit(ds_fini);
 
 MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Evgeniy Polyakov <johnpol@2ka.mipt.ru>");
+MODULE_AUTHOR("Evgeniy Polyakov <zbr@ioremap.net>");
 MODULE_DESCRIPTION("DS2490 USB <-> W1 bus master driver (DS9490*)");
diff --git a/drivers/w1/masters/matrox_w1.c b/drivers/w1/masters/matrox_w1.c
index 334d1ccf9c92..f667c26b2195 100644
--- a/drivers/w1/masters/matrox_w1.c
+++ b/drivers/w1/masters/matrox_w1.c
@@ -1,7 +1,7 @@
 /*
  *      matrox_w1.c
  *
- * Copyright (c) 2004 Evgeniy Polyakov <johnpol@2ka.mipt.ru>
+ * Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net>
  *
  *
  * This program is free software; you can redistribute it and/or modify
@@ -39,7 +39,7 @@
 #include "../w1_log.h"
 
 MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Evgeniy Polyakov <johnpol@2ka.mipt.ru>");
+MODULE_AUTHOR("Evgeniy Polyakov <zbr@ioremap.net>");
 MODULE_DESCRIPTION("Driver for transport(Dallas 1-wire prtocol) over VGA DDC(matrox gpio).");
 
 static struct pci_device_id matrox_w1_tbl[] = {
diff --git a/drivers/w1/slaves/w1_ds2408.c b/drivers/w1/slaves/w1_ds2408.c
index c37781899d90..7c8cdb8aed26 100644
--- a/drivers/w1/slaves/w1_ds2408.c
+++ b/drivers/w1/slaves/w1_ds2408.c
@@ -373,7 +373,7 @@ static int w1_f29_add_slave(struct w1_slave *sl)
 static void w1_f29_remove_slave(struct w1_slave *sl)
 {
         int i;
-        for (i = NB_SYSFS_BIN_FILES; i <= 0; --i)
+        for (i = NB_SYSFS_BIN_FILES - 1; i >= 0; --i)
                 sysfs_remove_bin_file(&sl->dev.kobj,
                         &(w1_f29_sysfs_bin_files[i]));
 }
diff --git a/drivers/w1/slaves/w1_smem.c b/drivers/w1/slaves/w1_smem.c
index cc8c02e92593..84655625c870 100644
--- a/drivers/w1/slaves/w1_smem.c
+++ b/drivers/w1/slaves/w1_smem.c
@@ -1,7 +1,7 @@
 /*
  *      w1_smem.c
  *
- * Copyright (c) 2004 Evgeniy Polyakov <johnpol@2ka.mipt.ru>
+ * Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net>
  *
  *
  * This program is free software; you can redistribute it and/or modify
@@ -32,7 +32,7 @@
 #include "../w1_family.h"
 
 MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Evgeniy Polyakov <johnpol@2ka.mipt.ru>");
+MODULE_AUTHOR("Evgeniy Polyakov <zbr@ioremap.net>");
 MODULE_DESCRIPTION("Driver for 1-wire Dallas network protocol, 64bit memory family.");
 
 static struct w1_family w1_smem_family_01 = {
diff --git a/drivers/w1/slaves/w1_therm.c b/drivers/w1/slaves/w1_therm.c
index 402928b135d1..a1ef9b5b38cf 100644
--- a/drivers/w1/slaves/w1_therm.c
+++ b/drivers/w1/slaves/w1_therm.c
@@ -1,7 +1,7 @@
 /*
  *      w1_therm.c
  *
- * Copyright (c) 2004 Evgeniy Polyakov <johnpol@2ka.mipt.ru>
+ * Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net>
  *
  *
  * This program is free software; you can redistribute it and/or modify
@@ -34,7 +34,7 @@
 #include "../w1_family.h"
 
 MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Evgeniy Polyakov <johnpol@2ka.mipt.ru>");
+MODULE_AUTHOR("Evgeniy Polyakov <zbr@ioremap.net>");
 MODULE_DESCRIPTION("Driver for 1-wire Dallas network protocol, temperature family.");
 
 /* Allow the strong pullup to be disabled, but default to enabled.
diff --git a/drivers/w1/w1.c b/drivers/w1/w1.c
index 6c136c19e982..c37497823851 100644
--- a/drivers/w1/w1.c
+++ b/drivers/w1/w1.c
@@ -1,7 +1,7 @@
 /*
  *      w1.c
  *
- * Copyright (c) 2004 Evgeniy Polyakov <johnpol@2ka.mipt.ru>
+ * Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net>
  *
  *
  * This program is free software; you can redistribute it and/or modify
@@ -42,7 +42,7 @@
 #include "w1_netlink.h"
 
 MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Evgeniy Polyakov <johnpol@2ka.mipt.ru>");
+MODULE_AUTHOR("Evgeniy Polyakov <zbr@ioremap.net>");
 MODULE_DESCRIPTION("Driver for 1-wire Dallas network protocol.");
 
 static int w1_timeout = 10;
diff --git a/drivers/w1/w1.h b/drivers/w1/w1.h
index 1ce23fc6186c..4d012ca3f32c 100644
--- a/drivers/w1/w1.h
+++ b/drivers/w1/w1.h
@@ -1,7 +1,7 @@
 /*
  *      w1.h
  *
- * Copyright (c) 2004 Evgeniy Polyakov <johnpol@2ka.mipt.ru>
+ * Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net>
  *
  *
  * This program is free software; you can redistribute it and/or modify
diff --git a/drivers/w1/w1_family.c b/drivers/w1/w1_family.c
index 4a099041f28a..63359797c8b1 100644
--- a/drivers/w1/w1_family.c
+++ b/drivers/w1/w1_family.c
@@ -1,7 +1,7 @@
 /*
  *      w1_family.c
  *
- * Copyright (c) 2004 Evgeniy Polyakov <johnpol@2ka.mipt.ru>
+ * Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net>
  *
  *
  * This program is free software; you can redistribute it and/or modify
diff --git a/drivers/w1/w1_family.h b/drivers/w1/w1_family.h
index 98a1ac0f4693..490cda2281bc 100644
--- a/drivers/w1/w1_family.h
+++ b/drivers/w1/w1_family.h
@@ -1,7 +1,7 @@
 /*
  *      w1_family.h
  *
- * Copyright (c) 2004 Evgeniy Polyakov <johnpol@2ka.mipt.ru>
+ * Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net>
  *
  *
  * This program is free software; you can redistribute it and/or modify
diff --git a/drivers/w1/w1_int.c b/drivers/w1/w1_int.c
index b50be3f1073d..d220bce2cee4 100644
--- a/drivers/w1/w1_int.c
+++ b/drivers/w1/w1_int.c
@@ -1,7 +1,7 @@
 /*
  *      w1_int.c
  *
- * Copyright (c) 2004 Evgeniy Polyakov <johnpol@2ka.mipt.ru>
+ * Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net>
  *
  *
  * This program is free software; you can redistribute it and/or modify
diff --git a/drivers/w1/w1_int.h b/drivers/w1/w1_int.h
index 4274082d2262..2ad7d4414bed 100644
--- a/drivers/w1/w1_int.h
+++ b/drivers/w1/w1_int.h
@@ -1,7 +1,7 @@
 /*
  *      w1_int.h
  *
- * Copyright (c) 2004 Evgeniy Polyakov <johnpol@2ka.mipt.ru>
+ * Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net>
  *
  *
  * This program is free software; you can redistribute it and/or modify
diff --git a/drivers/w1/w1_io.c b/drivers/w1/w1_io.c
index 8e8b64cfafb6..765b37b62a4f 100644
--- a/drivers/w1/w1_io.c
+++ b/drivers/w1/w1_io.c
@@ -1,7 +1,7 @@
 /*
  *      w1_io.c
  *
- * Copyright (c) 2004 Evgeniy Polyakov <johnpol@2ka.mipt.ru>
+ * Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net>
  *
  *
  * This program is free software; you can redistribute it and/or modify
diff --git a/drivers/w1/w1_log.h b/drivers/w1/w1_log.h
index e6ab7cf08f88..9c7bd62e6bdc 100644
--- a/drivers/w1/w1_log.h
+++ b/drivers/w1/w1_log.h
@@ -1,7 +1,7 @@
 /*
  *      w1_log.h
  *
- * Copyright (c) 2004 Evgeniy Polyakov <johnpol@2ka.mipt.ru>
+ * Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net>
  *
  *
  * This program is free software; you can redistribute it and/or modify
diff --git a/drivers/w1/w1_netlink.c b/drivers/w1/w1_netlink.c
index 55aabd927c60..40788c925d1c 100644
--- a/drivers/w1/w1_netlink.c
+++ b/drivers/w1/w1_netlink.c
@@ -1,7 +1,7 @@
 /*
  * w1_netlink.c
  *
- * Copyright (c) 2003 Evgeniy Polyakov <johnpol@2ka.mipt.ru>
+ * Copyright (c) 2003 Evgeniy Polyakov <zbr@ioremap.net>
  *
  *
  * This program is free software; you can redistribute it and/or modify
diff --git a/drivers/w1/w1_netlink.h b/drivers/w1/w1_netlink.h
index 27e950f935b1..b0922dc29658 100644
--- a/drivers/w1/w1_netlink.h
+++ b/drivers/w1/w1_netlink.h
@@ -1,7 +1,7 @@
 /*
  * w1_netlink.h
  *
- * Copyright (c) 2003 Evgeniy Polyakov <johnpol@2ka.mipt.ru>
+ * Copyright (c) 2003 Evgeniy Polyakov <zbr@ioremap.net>
  *
  *
  * This program is free software; you can redistribute it and/or modify
diff --git a/drivers/watchdog/Kconfig b/drivers/watchdog/Kconfig
index f441726ddf2b..86b0735e6aa0 100644
--- a/drivers/watchdog/Kconfig
+++ b/drivers/watchdog/Kconfig
@@ -36,9 +36,6 @@ config WATCHDOG_CORE
           and gives them the /dev/watchdog interface (and later also the
           sysfs interface).
 
-          To compile this driver as a module, choose M here: the module will
-          be called watchdog.
-
 config WATCHDOG_NOWAYOUT
         bool "Disable watchdog shutdown on close"
         help
diff --git a/drivers/watchdog/nv_tco.c b/drivers/watchdog/nv_tco.c
index afa78a54711e..809f41c30c44 100644
--- a/drivers/watchdog/nv_tco.c
+++ b/drivers/watchdog/nv_tco.c
@@ -458,7 +458,15 @@ static int __devexit nv_tco_remove(struct platform_device *dev)
 
 static void nv_tco_shutdown(struct platform_device *dev)
 {
+        u32 val;
+
         tco_timer_stop();
+
+        /* Some BIOSes fail the POST (once) if the NO_REBOOT flag is not
+         * unset during shutdown. */
+        pci_read_config_dword(tco_pci, MCP51_SMBUS_SETUP_B, &val);
+        val &= ~MCP51_SMBUS_SETUP_B_TCO_REBOOT;
+        pci_write_config_dword(tco_pci, MCP51_SMBUS_SETUP_B, val);
 }
 
 static struct platform_driver nv_tco_driver = {
diff --git a/drivers/watchdog/shwdt.c b/drivers/watchdog/shwdt.c
index db84f2322d1a..a267dc078daf 100644
--- a/drivers/watchdog/shwdt.c
+++ b/drivers/watchdog/shwdt.c
@@ -64,7 +64,7 @@
  * misses its deadline, the kernel timer will allow the WDT to overflow.
  */
 static int clock_division_ratio = WTCSR_CKS_4096;
-#define next_ping_period(cks)   msecs_to_jiffies(cks - 4)
+#define next_ping_period(cks)   (jiffies + msecs_to_jiffies(cks - 4))
 
 static const struct watchdog_info sh_wdt_info;
 static struct platform_device *sh_wdt_dev;
diff --git a/drivers/xen/Kconfig b/drivers/xen/Kconfig
index f815283667af..5f7ff8e2fc14 100644
--- a/drivers/xen/Kconfig
+++ b/drivers/xen/Kconfig
@@ -11,7 +11,7 @@ config XEN_BALLOON
 
 config XEN_SELFBALLOONING
         bool "Dynamically self-balloon kernel memory to target"
-        depends on XEN && XEN_BALLOON && CLEANCACHE && SWAP
+        depends on XEN && XEN_BALLOON && CLEANCACHE && SWAP && XEN_TMEM
         default n
         help
           Self-ballooning dynamically balloons available kernel memory driven
diff --git a/drivers/xen/xen-selfballoon.c b/drivers/xen/xen-selfballoon.c
index 1b4afd81f872..6ea852e25162 100644
--- a/drivers/xen/xen-selfballoon.c
+++ b/drivers/xen/xen-selfballoon.c
@@ -70,6 +70,7 @@
 #include <linux/kernel.h>
 #include <linux/mm.h>
 #include <linux/mman.h>
+#include <linux/module.h>
 #include <linux/workqueue.h>
 #include <xen/balloon.h>
 #include <xen/tmem.h>