117 files changed, 6059 insertions, 2557 deletions

diff --git a/drivers/acpi/Kconfig b/drivers/acpi/Kconfig
index 08e0140920e1..b811f2173f6f 100644
--- a/drivers/acpi/Kconfig
+++ b/drivers/acpi/Kconfig
@@ -54,17 +54,10 @@ config ACPI_PROCFS
           they have been replaced by functions in /sys.
           The deprecated files (and their replacements) include:
 
-          /proc/acpi/sleep (/sys/power/state)
-          /proc/acpi/info (/sys/module/acpi/parameters/acpica_version)
-          /proc/acpi/dsdt (/sys/firmware/acpi/tables/DSDT)
-          /proc/acpi/fadt (/sys/firmware/acpi/tables/FACP)
-          /proc/acpi/debug_layer (/sys/module/acpi/parameters/debug_layer)
-          /proc/acpi/debug_level (/sys/module/acpi/parameters/debug_level)
-          /proc/acpi/processor/*/power (/sys/devices/system/cpu/*/cpuidle/*)
-          /proc/acpi/processor/*/performance (/sys/devices/system/cpu/*/
-                cpufreq/*)
           /proc/acpi/processor/*/throttling (/sys/class/thermal/
                 cooling_device*/*)
+          /proc/acpi/video/*/brightness (/sys/class/backlight/)
+          /proc/acpi/thermal_zone/*/* (/sys/class/thermal/)
           This option has no effect on /proc/acpi/ files
           and functions which do not yet exist in /sys.
 
diff --git a/drivers/acpi/Makefile b/drivers/acpi/Makefile
index 833b582d1762..3d031d02e54b 100644
--- a/drivers/acpi/Makefile
+++ b/drivers/acpi/Makefile
@@ -37,8 +37,9 @@ acpi-y				+= ec.o
 acpi-$(CONFIG_ACPI_DOCK)        += dock.o
 acpi-y                          += pci_root.o pci_link.o pci_irq.o pci_bind.o
 acpi-y                          += power.o
-acpi-y                          += system.o event.o
-acpi-$(CONFIG_ACPI_DEBUG)       += debug.o
+acpi-y                          += event.o
+acpi-y                          += sysfs.o
+acpi-$(CONFIG_DEBUG_FS)         += debugfs.o
 acpi-$(CONFIG_ACPI_NUMA)        += numa.o
 acpi-$(CONFIG_ACPI_PROCFS_POWER) += cm_sbs.o
 ifdef CONFIG_ACPI_VIDEO
diff --git a/drivers/acpi/acpica/acevents.h b/drivers/acpi/acpica/acevents.h
index e0e6affb0d80..36867cd70eac 100644
--- a/drivers/acpi/acpica/acevents.h
+++ b/drivers/acpi/acpica/acevents.h
@@ -82,6 +82,10 @@ acpi_ev_update_gpe_enable_mask(struct acpi_gpe_event_info *gpe_event_info);
 
 acpi_status acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info);
 
+acpi_status acpi_raw_enable_gpe(struct acpi_gpe_event_info *gpe_event_info);
+
+acpi_status acpi_raw_disable_gpe(struct acpi_gpe_event_info *gpe_event_info);
+
 struct acpi_gpe_event_info *acpi_ev_get_gpe_event_info(acpi_handle gpe_device,
                                                        u32 gpe_number);
 
diff --git a/drivers/acpi/acpica/acglobal.h b/drivers/acpi/acpica/acglobal.h
index 18e796fe4295..1d192142c691 100644
--- a/drivers/acpi/acpica/acglobal.h
+++ b/drivers/acpi/acpica/acglobal.h
@@ -108,7 +108,7 @@ u8 ACPI_INIT_GLOBAL(acpi_gbl_use_default_register_widths, TRUE);
 /*
  * Optionally enable output from the AML Debug Object.
  */
-u8 ACPI_INIT_GLOBAL(acpi_gbl_enable_aml_debug_object, FALSE);
+u32 ACPI_INIT_GLOBAL(acpi_gbl_enable_aml_debug_object, FALSE);
 
 /*
  * Optionally copy the entire DSDT to local memory (instead of simply
diff --git a/drivers/acpi/acpica/aclocal.h b/drivers/acpi/acpica/aclocal.h
index 1ee0bcf399aa..df85b53a674f 100644
--- a/drivers/acpi/acpica/aclocal.h
+++ b/drivers/acpi/acpica/aclocal.h
@@ -412,6 +412,7 @@ struct acpi_handler_info {
         acpi_event_handler address;     /* Address of handler, if any */
         void *context;          /* Context to be passed to handler */
         struct acpi_namespace_node *method_node;        /* Method node for this GPE level (saved) */
+        u8 orig_flags;          /* Original misc info about this GPE */
 };
 
 union acpi_gpe_dispatch_info {
diff --git a/drivers/acpi/acpica/evgpe.c b/drivers/acpi/acpica/evgpe.c
index 7a6a3e6f4be0..f226eac314db 100644
--- a/drivers/acpi/acpica/evgpe.c
+++ b/drivers/acpi/acpica/evgpe.c
@@ -137,6 +137,79 @@ acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info)
 
 /*******************************************************************************
  *
+ * FUNCTION:    acpi_raw_enable_gpe
+ *
+ * PARAMETERS:  gpe_event_info  - GPE to enable
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Add a reference to a GPE. On the first reference, the GPE is
+ *              hardware-enabled.
+ *
+ ******************************************************************************/
+
+acpi_status acpi_raw_enable_gpe(struct acpi_gpe_event_info *gpe_event_info)
+{
+        acpi_status status = AE_OK;
+
+        if (gpe_event_info->runtime_count == ACPI_UINT8_MAX) {
+                return_ACPI_STATUS(AE_LIMIT);
+        }
+
+        gpe_event_info->runtime_count++;
+        if (gpe_event_info->runtime_count == 1) {
+                status = acpi_ev_update_gpe_enable_mask(gpe_event_info);
+                if (ACPI_SUCCESS(status)) {
+                        status = acpi_ev_enable_gpe(gpe_event_info);
+                }
+
+                if (ACPI_FAILURE(status)) {
+                        gpe_event_info->runtime_count--;
+                }
+        }
+
+        return_ACPI_STATUS(status);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_raw_disable_gpe
+ *
+ * PARAMETERS:  gpe_event_info  - GPE to disable
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Remove a reference to a GPE. When the last reference is
+ *              removed, the GPE is hardware-disabled.
+ *
+ ******************************************************************************/
+
+acpi_status acpi_raw_disable_gpe(struct acpi_gpe_event_info *gpe_event_info)
+{
+        acpi_status status = AE_OK;
+
+        if (!gpe_event_info->runtime_count) {
+                return_ACPI_STATUS(AE_LIMIT);
+        }
+
+        gpe_event_info->runtime_count--;
+        if (!gpe_event_info->runtime_count) {
+                status = acpi_ev_update_gpe_enable_mask(gpe_event_info);
+                if (ACPI_SUCCESS(status)) {
+                        status = acpi_hw_low_set_gpe(gpe_event_info,
+                                                     ACPI_GPE_DISABLE);
+                }
+
+                if (ACPI_FAILURE(status)) {
+                        gpe_event_info->runtime_count++;
+                }
+        }
+
+        return_ACPI_STATUS(status);
+}
+
+/*******************************************************************************
+ *
  * FUNCTION:    acpi_ev_low_get_gpe_info
  *
  * PARAMETERS:  gpe_number          - Raw GPE number
diff --git a/drivers/acpi/acpica/evxface.c b/drivers/acpi/acpica/evxface.c
index 4a531cdf7942..14e48add32fa 100644
--- a/drivers/acpi/acpica/evxface.c
+++ b/drivers/acpi/acpica/evxface.c
@@ -691,12 +691,22 @@ acpi_install_gpe_handler(acpi_handle gpe_device,
                 return_ACPI_STATUS(status);
         }
 
+        /* Allocate memory for the handler object */
+
+        handler = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_handler_info));
+        if (!handler) {
+                status = AE_NO_MEMORY;
+                goto unlock_and_exit;
+        }
+
+        flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
+
         /* Ensure that we have a valid GPE number */
 
         gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
         if (!gpe_event_info) {
                 status = AE_BAD_PARAMETER;
-                goto unlock_and_exit;
+                goto free_and_exit;
         }
 
         /* Make sure that there isn't a handler there already */
@@ -704,24 +714,30 @@ acpi_install_gpe_handler(acpi_handle gpe_device,
         if ((gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) ==
             ACPI_GPE_DISPATCH_HANDLER) {
                 status = AE_ALREADY_EXISTS;
-                goto unlock_and_exit;
+                goto free_and_exit;
         }
 
         /* Allocate and init handler object */
 
-        handler = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_handler_info));
-        if (!handler) {
-                status = AE_NO_MEMORY;
-                goto unlock_and_exit;
-        }
-
         handler->address = address;
         handler->context = context;
         handler->method_node = gpe_event_info->dispatch.method_node;
+        handler->orig_flags = gpe_event_info->flags &
+                        (ACPI_GPE_XRUPT_TYPE_MASK | ACPI_GPE_DISPATCH_MASK);
+
+        /*
+         * If the GPE is associated with a method and it cannot wake up the
+         * system from sleep states, it was enabled automatically during
+         * initialization, so it has to be disabled now to avoid spurious
+         * execution of the handler.
+         */
+
+        if ((handler->orig_flags & ACPI_GPE_DISPATCH_METHOD)
+            && !(gpe_event_info->flags & ACPI_GPE_CAN_WAKE))
+                (void)acpi_raw_disable_gpe(gpe_event_info);
 
         /* Install the handler */
 
-        flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
         gpe_event_info->dispatch.handler = handler;
 
         /* Setup up dispatch flags to indicate handler (vs. method) */
@@ -735,6 +751,11 @@ acpi_install_gpe_handler(acpi_handle gpe_device,
 unlock_and_exit:
         (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
         return_ACPI_STATUS(status);
+
+free_and_exit:
+        acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
+        ACPI_FREE(handler);
+        goto unlock_and_exit;
 }
 
 ACPI_EXPORT_SYMBOL(acpi_install_gpe_handler)
@@ -770,11 +791,17 @@ acpi_remove_gpe_handler(acpi_handle gpe_device,
                 return_ACPI_STATUS(AE_BAD_PARAMETER);
         }
 
+        /* Make sure all deferred tasks are completed */
+
+        acpi_os_wait_events_complete(NULL);
+
         status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
         if (ACPI_FAILURE(status)) {
                 return_ACPI_STATUS(status);
         }
 
+        flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
+
         /* Ensure that we have a valid GPE number */
 
         gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
@@ -798,34 +825,34 @@ acpi_remove_gpe_handler(acpi_handle gpe_device,
                 goto unlock_and_exit;
         }
 
-        /* Make sure all deferred tasks are completed */
-
-        (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
-        acpi_os_wait_events_complete(NULL);
-        status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
-        if (ACPI_FAILURE(status)) {
-                return_ACPI_STATUS(status);
-        }
-
         /* Remove the handler */
 
-        flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
         handler = gpe_event_info->dispatch.handler;
 
         /* Restore Method node (if any), set dispatch flags */
 
         gpe_event_info->dispatch.method_node = handler->method_node;
-        gpe_event_info->flags &= ~ACPI_GPE_DISPATCH_MASK;       /* Clear bits */
-        if (handler->method_node) {
-                gpe_event_info->flags |= ACPI_GPE_DISPATCH_METHOD;
-        }
-        acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
+        gpe_event_info->flags &=
+                ~(ACPI_GPE_XRUPT_TYPE_MASK | ACPI_GPE_DISPATCH_MASK);
+        gpe_event_info->flags |= handler->orig_flags;
+
+        /*
+         * If the GPE was previously associated with a method and it cannot wake
+         * up the system from sleep states, it should be enabled at this point
+         * to restore the post-initialization configuration.
+         */
+
+        if ((handler->orig_flags & ACPI_GPE_DISPATCH_METHOD)
+            && !(gpe_event_info->flags & ACPI_GPE_CAN_WAKE))
+                (void)acpi_raw_enable_gpe(gpe_event_info);
 
         /* Now we can free the handler object */
 
         ACPI_FREE(handler);
 
-      unlock_and_exit:
+unlock_and_exit:
+        acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
+
         (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
         return_ACPI_STATUS(status);
 }
diff --git a/drivers/acpi/acpica/evxfevnt.c b/drivers/acpi/acpica/evxfevnt.c
index 0ec900da5794..304825528d48 100644
--- a/drivers/acpi/acpica/evxfevnt.c
+++ b/drivers/acpi/acpica/evxfevnt.c
@@ -294,7 +294,7 @@ ACPI_EXPORT_SYMBOL(acpi_gpe_wakeup)
  ******************************************************************************/
 acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number)
 {
-        acpi_status status = AE_OK;
+        acpi_status status = AE_BAD_PARAMETER;
         struct acpi_gpe_event_info *gpe_event_info;
         acpi_cpu_flags flags;
 
@@ -305,28 +305,10 @@ acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number)
         /* Ensure that we have a valid GPE number */
 
         gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
-        if (!gpe_event_info) {
-                status = AE_BAD_PARAMETER;
-                goto unlock_and_exit;
+        if (gpe_event_info) {
+                status = acpi_raw_enable_gpe(gpe_event_info);
         }
 
-        if (gpe_event_info->runtime_count == ACPI_UINT8_MAX) {
-                status = AE_LIMIT;      /* Too many references */
-                goto unlock_and_exit;
-        }
-
-        gpe_event_info->runtime_count++;
-        if (gpe_event_info->runtime_count == 1) {
-                status = acpi_ev_update_gpe_enable_mask(gpe_event_info);
-                if (ACPI_SUCCESS(status)) {
-                        status = acpi_ev_enable_gpe(gpe_event_info);
-                }
-                if (ACPI_FAILURE(status)) {
-                        gpe_event_info->runtime_count--;
-                }
-        }
-
-unlock_and_exit:
         acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
         return_ACPI_STATUS(status);
 }
@@ -348,7 +330,7 @@ ACPI_EXPORT_SYMBOL(acpi_enable_gpe)
  ******************************************************************************/
 acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number)
 {
-        acpi_status status = AE_OK;
+        acpi_status status = AE_BAD_PARAMETER;
         struct acpi_gpe_event_info *gpe_event_info;
         acpi_cpu_flags flags;
 
@@ -359,32 +341,10 @@ acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number)
         /* Ensure that we have a valid GPE number */
 
         gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
-        if (!gpe_event_info) {
-                status = AE_BAD_PARAMETER;
-                goto unlock_and_exit;
-        }
-
-        /* Hardware-disable a runtime GPE on removal of the last reference */
-
-        if (!gpe_event_info->runtime_count) {
-                status = AE_LIMIT;      /* There are no references to remove */
-                goto unlock_and_exit;
+        if (gpe_event_info) {
+                status = acpi_raw_disable_gpe(gpe_event_info) ;
         }
 
-        gpe_event_info->runtime_count--;
-        if (!gpe_event_info->runtime_count) {
-                status = acpi_ev_update_gpe_enable_mask(gpe_event_info);
-                if (ACPI_SUCCESS(status)) {
-                        status =
-                            acpi_hw_low_set_gpe(gpe_event_info,
-                                                ACPI_GPE_DISABLE);
-                }
-                if (ACPI_FAILURE(status)) {
-                        gpe_event_info->runtime_count++;
-                }
-        }
-
-unlock_and_exit:
         acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
         return_ACPI_STATUS(status);
 }
@@ -411,7 +371,6 @@ acpi_status acpi_gpe_can_wake(acpi_handle gpe_device, u32 gpe_number)
         acpi_status status = AE_OK;
         struct acpi_gpe_event_info *gpe_event_info;
         acpi_cpu_flags flags;
-        u8 disable = 0;
 
         ACPI_FUNCTION_TRACE(acpi_gpe_can_wake);
 
@@ -430,15 +389,12 @@ acpi_status acpi_gpe_can_wake(acpi_handle gpe_device, u32 gpe_number)
         }
 
         gpe_event_info->flags |= ACPI_GPE_CAN_WAKE;
-        disable = (gpe_event_info->flags & ACPI_GPE_DISPATCH_METHOD)
-                && gpe_event_info->runtime_count;
+        if (gpe_event_info->flags & ACPI_GPE_DISPATCH_METHOD) {
+                (void)acpi_raw_disable_gpe(gpe_event_info);
+        }
 
 unlock_and_exit:
         acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
-
-        if (disable)
-                status = acpi_disable_gpe(gpe_device, gpe_number);
-
         return_ACPI_STATUS(status);
 }
 ACPI_EXPORT_SYMBOL(acpi_gpe_can_wake)
diff --git a/drivers/acpi/acpica/utmutex.c b/drivers/acpi/acpica/utmutex.c
index 058b3df48271..f5cca3a1300c 100644
--- a/drivers/acpi/acpica/utmutex.c
+++ b/drivers/acpi/acpica/utmutex.c
@@ -279,13 +279,10 @@ acpi_status acpi_ut_acquire_mutex(acpi_mutex_handle mutex_id)
 
 acpi_status acpi_ut_release_mutex(acpi_mutex_handle mutex_id)
 {
-        acpi_thread_id this_thread_id;
-
         ACPI_FUNCTION_NAME(ut_release_mutex);
 
-        this_thread_id = acpi_os_get_thread_id();
         ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Thread %p releasing Mutex [%s]\n",
-                          ACPI_CAST_PTR(void, this_thread_id),
+                          ACPI_CAST_PTR(void, acpi_os_get_thread_id()),
                           acpi_ut_get_mutex_name(mutex_id)));
 
         if (mutex_id > ACPI_MAX_MUTEX) {
diff --git a/drivers/acpi/apei/Kconfig b/drivers/acpi/apei/Kconfig
index f8c668f27b5a..907e350f1c7d 100644
--- a/drivers/acpi/apei/Kconfig
+++ b/drivers/acpi/apei/Kconfig
@@ -28,3 +28,12 @@ config ACPI_APEI_EINJ
           EINJ provides a hardware error injection mechanism, it is
           mainly used for debugging and testing the other parts of
           APEI and some other RAS features.
+
+config ACPI_APEI_ERST_DEBUG
+        tristate "APEI Error Record Serialization Table (ERST) Debug Support"
+        depends on ACPI_APEI
+        help
+          ERST is a way provided by APEI to save and retrieve hardware
+          error infomation to and from a persistent store. Enable this
+          if you want to debugging and testing the ERST kernel support
+          and firmware implementation.
diff --git a/drivers/acpi/apei/Makefile b/drivers/acpi/apei/Makefile
index b13b03a17789..d1d1bc0a4ee1 100644
--- a/drivers/acpi/apei/Makefile
+++ b/drivers/acpi/apei/Makefile
@@ -1,5 +1,6 @@
 obj-$(CONFIG_ACPI_APEI)         += apei.o
 obj-$(CONFIG_ACPI_APEI_GHES)    += ghes.o
 obj-$(CONFIG_ACPI_APEI_EINJ)    += einj.o
+obj-$(CONFIG_ACPI_APEI_ERST_DEBUG) += erst-dbg.o
 
 apei-y := apei-base.o hest.o cper.o erst.o
diff --git a/drivers/acpi/apei/apei-base.c b/drivers/acpi/apei/apei-base.c
index 216e1e948ff6..73fd0c7487c1 100644
--- a/drivers/acpi/apei/apei-base.c
+++ b/drivers/acpi/apei/apei-base.c
@@ -482,14 +482,14 @@ err_unmap_ioport:
         list_for_each_entry(res, &resources->ioport, list) {
                 if (res == res_bak)
                         break;
-                release_mem_region(res->start, res->end - res->start);
+                release_region(res->start, res->end - res->start);
         }
         res_bak = NULL;
 err_unmap_iomem:
         list_for_each_entry(res, &resources->iomem, list) {
                 if (res == res_bak)
                         break;
-                release_region(res->start, res->end - res->start);
+                release_mem_region(res->start, res->end - res->start);
         }
         return -EINVAL;
 }
diff --git a/drivers/acpi/apei/erst-dbg.c b/drivers/acpi/apei/erst-dbg.c
new file mode 100644
index 000000000000..5281ddda2777
--- /dev/null
+++ b/drivers/acpi/apei/erst-dbg.c
@@ -0,0 +1,207 @@
+/*
+ * APEI Error Record Serialization Table debug support
+ *
+ * ERST is a way provided by APEI to save and retrieve hardware error
+ * infomation to and from a persistent store. This file provide the
+ * debugging/testing support for ERST kernel support and firmware
+ * implementation.
+ *
+ * Copyright 2010 Intel Corp.
+ *   Author: Huang Ying <ying.huang@intel.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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/uaccess.h>
+#include <acpi/apei.h>
+#include <linux/miscdevice.h>
+
+#include "apei-internal.h"
+
+#define ERST_DBG_PFX                    "ERST DBG: "
+
+#define ERST_DBG_RECORD_LEN_MAX         4096
+
+static void *erst_dbg_buf;
+static unsigned int erst_dbg_buf_len;
+
+/* Prevent erst_dbg_read/write from being invoked concurrently */
+static DEFINE_MUTEX(erst_dbg_mutex);
+
+static int erst_dbg_open(struct inode *inode, struct file *file)
+{
+        if (erst_disable)
+                return -ENODEV;
+
+        return nonseekable_open(inode, file);
+}
+
+static long erst_dbg_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
+{
+        int rc;
+        u64 record_id;
+        u32 record_count;
+
+        switch (cmd) {
+        case APEI_ERST_CLEAR_RECORD:
+                rc = copy_from_user(&record_id, (void __user *)arg,
+                                    sizeof(record_id));
+                if (rc)
+                        return -EFAULT;
+                return erst_clear(record_id);
+        case APEI_ERST_GET_RECORD_COUNT:
+                rc = erst_get_record_count();
+                if (rc < 0)
+                        return rc;
+                record_count = rc;
+                rc = put_user(record_count, (u32 __user *)arg);
+                if (rc)
+                        return rc;
+                return 0;
+        default:
+                return -ENOTTY;
+        }
+}
+
+static ssize_t erst_dbg_read(struct file *filp, char __user *ubuf,
+                             size_t usize, loff_t *off)
+{
+        int rc;
+        ssize_t len = 0;
+        u64 id;
+
+        if (*off != 0)
+                return -EINVAL;
+
+        if (mutex_lock_interruptible(&erst_dbg_mutex) != 0)
+                return -EINTR;
+
+retry_next:
+        rc = erst_get_next_record_id(&id);
+        if (rc)
+                goto out;
+        /* no more record */
+        if (id == APEI_ERST_INVALID_RECORD_ID)
+                goto out;
+retry:
+        rc = len = erst_read(id, erst_dbg_buf, erst_dbg_buf_len);
+        /* The record may be cleared by others, try read next record */
+        if (rc == -ENOENT)
+                goto retry_next;
+        if (rc < 0)
+                goto out;
+        if (len > ERST_DBG_RECORD_LEN_MAX) {
+                pr_warning(ERST_DBG_PFX
+                           "Record (ID: 0x%llx) length is too long: %zd\n",
+                           id, len);
+                rc = -EIO;
+                goto out;
+        }
+        if (len > erst_dbg_buf_len) {
+                kfree(erst_dbg_buf);
+                rc = -ENOMEM;
+                erst_dbg_buf = kmalloc(len, GFP_KERNEL);
+                if (!erst_dbg_buf)
+                        goto out;
+                erst_dbg_buf_len = len;
+                goto retry;
+        }
+
+        rc = -EINVAL;
+        if (len > usize)
+                goto out;
+
+        rc = -EFAULT;
+        if (copy_to_user(ubuf, erst_dbg_buf, len))
+                goto out;
+        rc = 0;
+out:
+        mutex_unlock(&erst_dbg_mutex);
+        return rc ? rc : len;
+}
+
+static ssize_t erst_dbg_write(struct file *filp, const char __user *ubuf,
+                              size_t usize, loff_t *off)
+{
+        int rc;
+        struct cper_record_header *rcd;
+
+        if (!capable(CAP_SYS_ADMIN))
+                return -EPERM;
+
+        if (usize > ERST_DBG_RECORD_LEN_MAX) {
+                pr_err(ERST_DBG_PFX "Too long record to be written\n");
+                return -EINVAL;
+        }
+
+        if (mutex_lock_interruptible(&erst_dbg_mutex))
+                return -EINTR;
+        if (usize > erst_dbg_buf_len) {
+                kfree(erst_dbg_buf);
+                rc = -ENOMEM;
+                erst_dbg_buf = kmalloc(usize, GFP_KERNEL);
+                if (!erst_dbg_buf)
+                        goto out;
+                erst_dbg_buf_len = usize;
+        }
+        rc = copy_from_user(erst_dbg_buf, ubuf, usize);
+        if (rc) {
+                rc = -EFAULT;
+                goto out;
+        }
+        rcd = erst_dbg_buf;
+        rc = -EINVAL;
+        if (rcd->record_length != usize)
+                goto out;
+
+        rc = erst_write(erst_dbg_buf);
+
+out:
+        mutex_unlock(&erst_dbg_mutex);
+        return rc < 0 ? rc : usize;
+}
+
+static const struct file_operations erst_dbg_ops = {
+        .owner          = THIS_MODULE,
+        .open           = erst_dbg_open,
+        .read           = erst_dbg_read,
+        .write          = erst_dbg_write,
+        .unlocked_ioctl = erst_dbg_ioctl,
+};
+
+static struct miscdevice erst_dbg_dev = {
+        .minor  = MISC_DYNAMIC_MINOR,
+        .name   = "erst_dbg",
+        .fops   = &erst_dbg_ops,
+};
+
+static __init int erst_dbg_init(void)
+{
+        return misc_register(&erst_dbg_dev);
+}
+
+static __exit void erst_dbg_exit(void)
+{
+        misc_deregister(&erst_dbg_dev);
+        kfree(erst_dbg_buf);
+}
+
+module_init(erst_dbg_init);
+module_exit(erst_dbg_exit);
+
+MODULE_AUTHOR("Huang Ying");
+MODULE_DESCRIPTION("APEI Error Record Serialization Table debug support");
+MODULE_LICENSE("GPL");
diff --git a/drivers/acpi/apei/ghes.c b/drivers/acpi/apei/ghes.c
index fd0cc016a099..385a6059714a 100644
--- a/drivers/acpi/apei/ghes.c
+++ b/drivers/acpi/apei/ghes.c
@@ -41,6 +41,8 @@
 #include <linux/interrupt.h>
 #include <linux/cper.h>
 #include <linux/kdebug.h>
+#include <linux/platform_device.h>
+#include <linux/mutex.h>
 #include <acpi/apei.h>
 #include <acpi/atomicio.h>
 #include <acpi/hed.h>
@@ -87,6 +89,7 @@ struct ghes {
  * used for that.
  */
 static LIST_HEAD(ghes_sci);
+static DEFINE_MUTEX(ghes_list_mutex);
 
 static struct ghes *ghes_new(struct acpi_hest_generic *generic)
 {
@@ -132,26 +135,26 @@ static void ghes_fini(struct ghes *ghes)
 }
 
 enum {
-        GHES_SER_NO = 0x0,
-        GHES_SER_CORRECTED = 0x1,
-        GHES_SER_RECOVERABLE = 0x2,
-        GHES_SER_PANIC = 0x3,
+        GHES_SEV_NO = 0x0,
+        GHES_SEV_CORRECTED = 0x1,
+        GHES_SEV_RECOVERABLE = 0x2,
+        GHES_SEV_PANIC = 0x3,
 };
 
 static inline int ghes_severity(int severity)
 {
         switch (severity) {
-        case CPER_SER_INFORMATIONAL:
-                return GHES_SER_NO;
-        case CPER_SER_CORRECTED:
-                return GHES_SER_CORRECTED;
-        case CPER_SER_RECOVERABLE:
-                return GHES_SER_RECOVERABLE;
-        case CPER_SER_FATAL:
-                return GHES_SER_PANIC;
+        case CPER_SEV_INFORMATIONAL:
+                return GHES_SEV_NO;
+        case CPER_SEV_CORRECTED:
+                return GHES_SEV_CORRECTED;
+        case CPER_SEV_RECOVERABLE:
+                return GHES_SEV_RECOVERABLE;
+        case CPER_SEV_FATAL:
+                return GHES_SEV_PANIC;
         default:
                 /* Unkown, go panic */
-                return GHES_SER_PANIC;
+                return GHES_SEV_PANIC;
         }
 }
 
@@ -237,16 +240,16 @@ static void ghes_clear_estatus(struct ghes *ghes)
 
 static void ghes_do_proc(struct ghes *ghes)
 {
-        int ser, processed = 0;
+        int sev, processed = 0;
         struct acpi_hest_generic_data *gdata;
 
-        ser = ghes_severity(ghes->estatus->error_severity);
+        sev = ghes_severity(ghes->estatus->error_severity);
         apei_estatus_for_each_section(ghes->estatus, gdata) {
 #ifdef CONFIG_X86_MCE
                 if (!uuid_le_cmp(*(uuid_le *)gdata->section_type,
                                  CPER_SEC_PLATFORM_MEM)) {
                         apei_mce_report_mem_error(
-                                ser == GHES_SER_CORRECTED,
+                                sev == GHES_SEV_CORRECTED,
                                 (struct cper_sec_mem_err *)(gdata+1));
                         processed = 1;
                 }
@@ -293,18 +296,15 @@ static struct notifier_block ghes_notifier_sci = {
         .notifier_call = ghes_notify_sci,
 };
 
-static int hest_ghes_parse(struct acpi_hest_header *hest_hdr, void *data)
+static int __devinit ghes_probe(struct platform_device *ghes_dev)
 {
         struct acpi_hest_generic *generic;
         struct ghes *ghes = NULL;
-        int rc = 0;
+        int rc = -EINVAL;
 
-        if (hest_hdr->type != ACPI_HEST_TYPE_GENERIC_ERROR)
-                return 0;
-
-        generic = (struct acpi_hest_generic *)hest_hdr;
+        generic = ghes_dev->dev.platform_data;
         if (!generic->enabled)
-                return 0;
+                return -ENODEV;
 
         if (generic->error_block_length <
             sizeof(struct acpi_hest_generic_status)) {
@@ -327,62 +327,91 @@ static int hest_ghes_parse(struct acpi_hest_header *hest_hdr, void *data)
                 ghes = NULL;
                 goto err;
         }
-        switch (generic->notify.type) {
-        case ACPI_HEST_NOTIFY_POLLED:
-                pr_warning(GHES_PFX
-"Generic hardware error source: %d notified via POLL is not supported!\n",
-                           generic->header.source_id);
-                break;
-        case ACPI_HEST_NOTIFY_EXTERNAL:
-        case ACPI_HEST_NOTIFY_LOCAL:
-                pr_warning(GHES_PFX
-"Generic hardware error source: %d notified via IRQ is not supported!\n",
-                           generic->header.source_id);
-                break;
-        case ACPI_HEST_NOTIFY_SCI:
+        if (generic->notify.type == ACPI_HEST_NOTIFY_SCI) {
+                mutex_lock(&ghes_list_mutex);
                 if (list_empty(&ghes_sci))
                         register_acpi_hed_notifier(&ghes_notifier_sci);
                 list_add_rcu(&ghes->list, &ghes_sci);
-                break;
-        case ACPI_HEST_NOTIFY_NMI:
-                pr_warning(GHES_PFX
-"Generic hardware error source: %d notified via NMI is not supported!\n",
-                           generic->header.source_id);
-                break;
-        default:
-                pr_warning(FW_WARN GHES_PFX
-        "Unknown notification type: %u for generic hardware error source: %d\n",
-                           generic->notify.type, generic->header.source_id);
-                break;
+                mutex_unlock(&ghes_list_mutex);
+        } else {
+                unsigned char *notify = NULL;
+
+                switch (generic->notify.type) {
+                case ACPI_HEST_NOTIFY_POLLED:
+                        notify = "POLL";
+                        break;
+                case ACPI_HEST_NOTIFY_EXTERNAL:
+                case ACPI_HEST_NOTIFY_LOCAL:
+                        notify = "IRQ";
+                        break;
+                case ACPI_HEST_NOTIFY_NMI:
+                        notify = "NMI";
+                        break;
+                }
+                if (notify) {
+                        pr_warning(GHES_PFX
+"Generic hardware error source: %d notified via %s is not supported!\n",
+                                   generic->header.source_id, notify);
+                } else {
+                        pr_warning(FW_WARN GHES_PFX
+"Unknown notification type: %u for generic hardware error source: %d\n",
+                        generic->notify.type, generic->header.source_id);
+                }
+                rc = -ENODEV;
+                goto err;
         }
+        platform_set_drvdata(ghes_dev, ghes);
 
         return 0;
 err:
-        if (ghes)
+        if (ghes) {
                 ghes_fini(ghes);
+                kfree(ghes);
+        }
         return rc;
 }
 
-static void ghes_cleanup(void)
+static int __devexit ghes_remove(struct platform_device *ghes_dev)
 {
-        struct ghes *ghes, *nghes;
+        struct ghes *ghes;
+        struct acpi_hest_generic *generic;
 
-        if (!list_empty(&ghes_sci))
-                unregister_acpi_hed_notifier(&ghes_notifier_sci);
+        ghes = platform_get_drvdata(ghes_dev);
+        generic = ghes->generic;
+
+        switch (generic->notify.type) {
+        case ACPI_HEST_NOTIFY_SCI:
+                mutex_lock(&ghes_list_mutex);
+                list_del_rcu(&ghes->list);
+                if (list_empty(&ghes_sci))
+                        unregister_acpi_hed_notifier(&ghes_notifier_sci);
+                mutex_unlock(&ghes_list_mutex);
+                break;
+        default:
+                BUG();
+                break;
+        }
 
         synchronize_rcu();
+        ghes_fini(ghes);
+        kfree(ghes);
 
-        list_for_each_entry_safe(ghes, nghes, &ghes_sci, list) {
-                list_del(&ghes->list);
-                ghes_fini(ghes);
-                kfree(ghes);
-        }
+        platform_set_drvdata(ghes_dev, NULL);
+
+        return 0;
 }
 
+static struct platform_driver ghes_platform_driver = {
+        .driver         = {
+                .name   = "GHES",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = ghes_probe,
+        .remove         = ghes_remove,
+};
+
 static int __init ghes_init(void)
 {
-        int rc;
-
         if (acpi_disabled)
                 return -ENODEV;
 
@@ -391,32 +420,12 @@ static int __init ghes_init(void)
                 return -EINVAL;
         }
 
-        rc = apei_hest_parse(hest_ghes_parse, NULL);
-        if (rc) {
-                pr_err(GHES_PFX
-                "Error during parsing HEST generic hardware error sources.\n");
-                goto err_cleanup;
-        }
-
-        if (list_empty(&ghes_sci)) {
-                pr_info(GHES_PFX
-                        "No functional generic hardware error sources.\n");
-                rc = -ENODEV;
-                goto err_cleanup;
-        }
-
-        pr_info(GHES_PFX
-                "Generic Hardware Error Source support is initialized.\n");
-
-        return 0;
-err_cleanup:
-        ghes_cleanup();
-        return rc;
+        return platform_driver_register(&ghes_platform_driver);
 }
 
 static void __exit ghes_exit(void)
 {
-        ghes_cleanup();
+        platform_driver_unregister(&ghes_platform_driver);
 }
 
 module_init(ghes_init);
@@ -425,3 +434,4 @@ module_exit(ghes_exit);
 MODULE_AUTHOR("Huang Ying");
 MODULE_DESCRIPTION("APEI Generic Hardware Error Source support");
 MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:GHES");
diff --git a/drivers/acpi/apei/hest.c b/drivers/acpi/apei/hest.c
index e7f40d362cb3..343168d18266 100644
--- a/drivers/acpi/apei/hest.c
+++ b/drivers/acpi/apei/hest.c
@@ -34,6 +34,7 @@
 #include <linux/kdebug.h>
 #include <linux/highmem.h>
 #include <linux/io.h>
+#include <linux/platform_device.h>
 #include <acpi/apei.h>
 
 #include "apei-internal.h"
@@ -47,11 +48,6 @@ EXPORT_SYMBOL_GPL(hest_disable);
 
 static struct acpi_table_hest *hest_tab;
 
-static int hest_void_parse(struct acpi_hest_header *hest_hdr, void *data)
-{
-        return 0;
-}
-
 static int hest_esrc_len_tab[ACPI_HEST_TYPE_RESERVED] = {
         [ACPI_HEST_TYPE_IA32_CHECK] = -1,       /* need further calculation */
         [ACPI_HEST_TYPE_IA32_CORRECTED_CHECK] = -1,
@@ -125,6 +121,69 @@ int apei_hest_parse(apei_hest_func_t func, void *data)
 }
 EXPORT_SYMBOL_GPL(apei_hest_parse);
 
+struct ghes_arr {
+        struct platform_device **ghes_devs;
+        unsigned int count;
+};
+
+static int hest_parse_ghes_count(struct acpi_hest_header *hest_hdr, void *data)
+{
+        int *count = data;
+
+        if (hest_hdr->type == ACPI_HEST_TYPE_GENERIC_ERROR)
+                (*count)++;
+        return 0;
+}
+
+static int hest_parse_ghes(struct acpi_hest_header *hest_hdr, void *data)
+{
+        struct acpi_hest_generic *generic;
+        struct platform_device *ghes_dev;
+        struct ghes_arr *ghes_arr = data;
+        int rc;
+
+        if (hest_hdr->type != ACPI_HEST_TYPE_GENERIC_ERROR)
+                return 0;
+        generic = (struct acpi_hest_generic *)hest_hdr;
+        if (!generic->enabled)
+                return 0;
+        ghes_dev = platform_device_alloc("GHES", hest_hdr->source_id);
+        if (!ghes_dev)
+                return -ENOMEM;
+        ghes_dev->dev.platform_data = generic;
+        rc = platform_device_add(ghes_dev);
+        if (rc)
+                goto err;
+        ghes_arr->ghes_devs[ghes_arr->count++] = ghes_dev;
+
+        return 0;
+err:
+        platform_device_put(ghes_dev);
+        return rc;
+}
+
+static int hest_ghes_dev_register(unsigned int ghes_count)
+{
+        int rc, i;
+        struct ghes_arr ghes_arr;
+
+        ghes_arr.count = 0;
+        ghes_arr.ghes_devs = kmalloc(sizeof(void *) * ghes_count, GFP_KERNEL);
+        if (!ghes_arr.ghes_devs)
+                return -ENOMEM;
+
+        rc = apei_hest_parse(hest_parse_ghes, &ghes_arr);
+        if (rc)
+                goto err;
+out:
+        kfree(ghes_arr.ghes_devs);
+        return rc;
+err:
+        for (i = 0; i < ghes_arr.count; i++)
+                platform_device_unregister(ghes_arr.ghes_devs[i]);
+        goto out;
+}
+
 static int __init setup_hest_disable(char *str)
 {
         hest_disable = 1;
@@ -137,6 +196,7 @@ static int __init hest_init(void)
 {
         acpi_status status;
         int rc = -ENODEV;
+        unsigned int ghes_count = 0;
 
         if (acpi_disabled)
                 goto err;
@@ -158,7 +218,11 @@ static int __init hest_init(void)
                 goto err;
         }
 
-        rc = apei_hest_parse(hest_void_parse, NULL);
+        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;
 
diff --git a/drivers/acpi/bus.c b/drivers/acpi/bus.c
index c1d23cd71652..5c221ab535d5 100644
--- a/drivers/acpi/bus.c
+++ b/drivers/acpi/bus.c
@@ -1034,8 +1034,8 @@ static int __init acpi_init(void)
         acpi_scan_init();
         acpi_ec_init();
         acpi_power_init();
-        acpi_system_init();
-        acpi_debug_init();
+        acpi_sysfs_init();
+        acpi_debugfs_init();
         acpi_sleep_proc_init();
         acpi_wakeup_device_init();
         return result;
diff --git a/drivers/acpi/debug.c b/drivers/acpi/debug.c
deleted file mode 100644
index 295dbfa2db9c..000000000000
--- a/drivers/acpi/debug.c
+++ /dev/null
@@ -1,422 +0,0 @@
-/*
- * debug.c - ACPI debug interface to userspace.
- */
-
-#include <linux/proc_fs.h>
-#include <linux/seq_file.h>
-#include <linux/init.h>
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/moduleparam.h>
-#include <linux/debugfs.h>
-#include <linux/slab.h>
-#include <asm/uaccess.h>
-#include <acpi/acpi_drivers.h>
-
-#define _COMPONENT              ACPI_SYSTEM_COMPONENT
-ACPI_MODULE_NAME("debug");
-
-struct acpi_dlayer {
-        const char *name;
-        unsigned long value;
-};
-struct acpi_dlevel {
-        const char *name;
-        unsigned long value;
-};
-#define ACPI_DEBUG_INIT(v)      { .name = #v, .value = v }
-
-static const struct acpi_dlayer acpi_debug_layers[] = {
-        ACPI_DEBUG_INIT(ACPI_UTILITIES),
-        ACPI_DEBUG_INIT(ACPI_HARDWARE),
-        ACPI_DEBUG_INIT(ACPI_EVENTS),
-        ACPI_DEBUG_INIT(ACPI_TABLES),
-        ACPI_DEBUG_INIT(ACPI_NAMESPACE),
-        ACPI_DEBUG_INIT(ACPI_PARSER),
-        ACPI_DEBUG_INIT(ACPI_DISPATCHER),
-        ACPI_DEBUG_INIT(ACPI_EXECUTER),
-        ACPI_DEBUG_INIT(ACPI_RESOURCES),
-        ACPI_DEBUG_INIT(ACPI_CA_DEBUGGER),
-        ACPI_DEBUG_INIT(ACPI_OS_SERVICES),
-        ACPI_DEBUG_INIT(ACPI_CA_DISASSEMBLER),
-        ACPI_DEBUG_INIT(ACPI_COMPILER),
-        ACPI_DEBUG_INIT(ACPI_TOOLS),
-
-        ACPI_DEBUG_INIT(ACPI_BUS_COMPONENT),
-        ACPI_DEBUG_INIT(ACPI_AC_COMPONENT),
-        ACPI_DEBUG_INIT(ACPI_BATTERY_COMPONENT),
-        ACPI_DEBUG_INIT(ACPI_BUTTON_COMPONENT),
-        ACPI_DEBUG_INIT(ACPI_SBS_COMPONENT),
-        ACPI_DEBUG_INIT(ACPI_FAN_COMPONENT),
-        ACPI_DEBUG_INIT(ACPI_PCI_COMPONENT),
-        ACPI_DEBUG_INIT(ACPI_POWER_COMPONENT),
-        ACPI_DEBUG_INIT(ACPI_CONTAINER_COMPONENT),
-        ACPI_DEBUG_INIT(ACPI_SYSTEM_COMPONENT),
-        ACPI_DEBUG_INIT(ACPI_THERMAL_COMPONENT),
-        ACPI_DEBUG_INIT(ACPI_MEMORY_DEVICE_COMPONENT),
-        ACPI_DEBUG_INIT(ACPI_VIDEO_COMPONENT),
-        ACPI_DEBUG_INIT(ACPI_PROCESSOR_COMPONENT),
-};
-
-static const struct acpi_dlevel acpi_debug_levels[] = {
-        ACPI_DEBUG_INIT(ACPI_LV_INIT),
-        ACPI_DEBUG_INIT(ACPI_LV_DEBUG_OBJECT),
-        ACPI_DEBUG_INIT(ACPI_LV_INFO),
-
-        ACPI_DEBUG_INIT(ACPI_LV_INIT_NAMES),
-        ACPI_DEBUG_INIT(ACPI_LV_PARSE),
-        ACPI_DEBUG_INIT(ACPI_LV_LOAD),
-        ACPI_DEBUG_INIT(ACPI_LV_DISPATCH),
-        ACPI_DEBUG_INIT(ACPI_LV_EXEC),
-        ACPI_DEBUG_INIT(ACPI_LV_NAMES),
-        ACPI_DEBUG_INIT(ACPI_LV_OPREGION),
-        ACPI_DEBUG_INIT(ACPI_LV_BFIELD),
-        ACPI_DEBUG_INIT(ACPI_LV_TABLES),
-        ACPI_DEBUG_INIT(ACPI_LV_VALUES),
-        ACPI_DEBUG_INIT(ACPI_LV_OBJECTS),
-        ACPI_DEBUG_INIT(ACPI_LV_RESOURCES),
-        ACPI_DEBUG_INIT(ACPI_LV_USER_REQUESTS),
-        ACPI_DEBUG_INIT(ACPI_LV_PACKAGE),
-
-        ACPI_DEBUG_INIT(ACPI_LV_ALLOCATIONS),
-        ACPI_DEBUG_INIT(ACPI_LV_FUNCTIONS),
-        ACPI_DEBUG_INIT(ACPI_LV_OPTIMIZATIONS),
-
-        ACPI_DEBUG_INIT(ACPI_LV_MUTEX),
-        ACPI_DEBUG_INIT(ACPI_LV_THREADS),
-        ACPI_DEBUG_INIT(ACPI_LV_IO),
-        ACPI_DEBUG_INIT(ACPI_LV_INTERRUPTS),
-
-        ACPI_DEBUG_INIT(ACPI_LV_AML_DISASSEMBLE),
-        ACPI_DEBUG_INIT(ACPI_LV_VERBOSE_INFO),
-        ACPI_DEBUG_INIT(ACPI_LV_FULL_TABLES),
-        ACPI_DEBUG_INIT(ACPI_LV_EVENTS),
-};
-
-/* --------------------------------------------------------------------------
-                              FS Interface (/sys)
-   -------------------------------------------------------------------------- */
-static int param_get_debug_layer(char *buffer, const struct kernel_param *kp)
-{
-        int result = 0;
-        int i;
-
-        result = sprintf(buffer, "%-25s\tHex        SET\n", "Description");
-
-        for(i = 0; i <ARRAY_SIZE(acpi_debug_layers); i++) {
-                result += sprintf(buffer+result, "%-25s\t0x%08lX [%c]\n",
-                                        acpi_debug_layers[i].name,
-                                        acpi_debug_layers[i].value,
-                                        (acpi_dbg_layer & acpi_debug_layers[i].value) ? '*' : ' ');
-        }
-        result += sprintf(buffer+result, "%-25s\t0x%08X [%c]\n", "ACPI_ALL_DRIVERS",
-                                        ACPI_ALL_DRIVERS,
-                                        (acpi_dbg_layer & ACPI_ALL_DRIVERS) ==
-                                        ACPI_ALL_DRIVERS ? '*' : (acpi_dbg_layer &
-                                        ACPI_ALL_DRIVERS) == 0 ? ' ' : '-');
-        result += sprintf(buffer+result, "--\ndebug_layer = 0x%08X ( * = enabled)\n", acpi_dbg_layer);
-
-        return result;
-}
-
-static int param_get_debug_level(char *buffer, const struct kernel_param *kp)
-{
-        int result = 0;
-        int i;
-
-        result = sprintf(buffer, "%-25s\tHex        SET\n", "Description");
-
-        for (i = 0; i < ARRAY_SIZE(acpi_debug_levels); i++) {
-                result += sprintf(buffer+result, "%-25s\t0x%08lX [%c]\n",
-                                     acpi_debug_levels[i].name,
-                                     acpi_debug_levels[i].value,
-                                     (acpi_dbg_level & acpi_debug_levels[i].
-                                      value) ? '*' : ' ');
-        }
-        result += sprintf(buffer+result, "--\ndebug_level = 0x%08X (* = enabled)\n",
-                             acpi_dbg_level);
-
-        return result;
-}
-
-static struct kernel_param_ops acpi_debug_layer_ops = {
-        .set = param_set_uint,
-        .get = param_get_debug_layer,
-};
-
-static struct kernel_param_ops acpi_debug_level_ops = {
-        .set = param_set_uint,
-        .get = param_get_debug_level,
-};
-
-module_param_cb(debug_layer, &acpi_debug_layer_ops, &acpi_dbg_layer, 0644);
-module_param_cb(debug_level, &acpi_debug_level_ops, &acpi_dbg_level, 0644);
-
-static char trace_method_name[6];
-module_param_string(trace_method_name, trace_method_name, 6, 0644);
-static unsigned int trace_debug_layer;
-module_param(trace_debug_layer, uint, 0644);
-static unsigned int trace_debug_level;
-module_param(trace_debug_level, uint, 0644);
-
-static int param_set_trace_state(const char *val, const struct kernel_param *kp)
-{
-        int result = 0;
-
-        if (!strncmp(val, "enable", strlen("enable") - 1)) {
-                result = acpi_debug_trace(trace_method_name, trace_debug_level,
-                                          trace_debug_layer, 0);
-                if (result)
-                        result = -EBUSY;
-                goto exit;
-        }
-
-        if (!strncmp(val, "disable", strlen("disable") - 1)) {
-                int name = 0;
-                result = acpi_debug_trace((char *)&name, trace_debug_level,
-                                          trace_debug_layer, 0);
-                if (result)
-                        result = -EBUSY;
-                goto exit;
-        }
-
-        if (!strncmp(val, "1", 1)) {
-                result = acpi_debug_trace(trace_method_name, trace_debug_level,
-                                          trace_debug_layer, 1);
-                if (result)
-                        result = -EBUSY;
-                goto exit;
-        }
-
-        result = -EINVAL;
-exit:
-        return result;
-}
-
-static int param_get_trace_state(char *buffer, const struct kernel_param *kp)
-{
-        if (!acpi_gbl_trace_method_name)
-                return sprintf(buffer, "disable");
-        else {
-                if (acpi_gbl_trace_flags & 1)
-                        return sprintf(buffer, "1");
-                else
-                        return sprintf(buffer, "enable");
-        }
-        return 0;
-}
-
-static struct kernel_param_ops param_ops_trace_state = {
-        .set = param_set_trace_state,
-        .get = param_get_trace_state,
-};
-
-module_param_cb(trace_state, &param_ops_trace_state, NULL, 0644);
-
-/* --------------------------------------------------------------------------
-                                DebugFS Interface
-   -------------------------------------------------------------------------- */
-
-static ssize_t cm_write(struct file *file, const char __user *user_buf,
-                        size_t count, loff_t *ppos)
-{
-        static char *buf;
-        static int uncopied_bytes;
-        struct acpi_table_header table;
-        acpi_status status;
-
-        if (!(*ppos)) {
-                /* parse the table header to get the table length */
-                if (count <= sizeof(struct acpi_table_header))
-                        return -EINVAL;
-                if (copy_from_user(&table, user_buf,
-                        sizeof(struct acpi_table_header)))
-                        return -EFAULT;
-                uncopied_bytes = table.length;
-                buf = kzalloc(uncopied_bytes, GFP_KERNEL);
-                if (!buf)
-                        return -ENOMEM;
-        }
-
-        if (uncopied_bytes < count) {
-                kfree(buf);
-                return -EINVAL;
-        }
-
-        if (copy_from_user(buf + (*ppos), user_buf, count)) {
-                kfree(buf);
-                return -EFAULT;
-        }
-
-        uncopied_bytes -= count;
-        *ppos += count;
-
-        if (!uncopied_bytes) {
-                status = acpi_install_method(buf);
-                kfree(buf);
-                if (ACPI_FAILURE(status))
-                        return -EINVAL;
-                add_taint(TAINT_OVERRIDDEN_ACPI_TABLE);
-        }
-
-        return count;
-}
-
-static const struct file_operations cm_fops = {
-        .write = cm_write,
-};
-
-static int acpi_debugfs_init(void)
-{
-        struct dentry *acpi_dir, *cm_dentry;
-
-        acpi_dir = debugfs_create_dir("acpi", NULL);
-        if (!acpi_dir)
-                goto err;
-
-        cm_dentry = debugfs_create_file("custom_method", S_IWUGO,
-                                        acpi_dir, NULL, &cm_fops);
-        if (!cm_dentry)
-                goto err;
-
-        return 0;
-
-err:
-        if (acpi_dir)
-                debugfs_remove(acpi_dir);
-        return -EINVAL;
-}
-
-/* --------------------------------------------------------------------------
-                              FS Interface (/proc)
-   -------------------------------------------------------------------------- */
-#ifdef CONFIG_ACPI_PROCFS
-#define ACPI_SYSTEM_FILE_DEBUG_LAYER    "debug_layer"
-#define ACPI_SYSTEM_FILE_DEBUG_LEVEL            "debug_level"
-
-static int acpi_system_debug_proc_show(struct seq_file *m, void *v)
-{
-        unsigned int i;
-
-        seq_printf(m, "%-25s\tHex        SET\n", "Description");
-
-        switch ((unsigned long)m->private) {
-        case 0:
-                for (i = 0; i < ARRAY_SIZE(acpi_debug_layers); i++) {
-                        seq_printf(m, "%-25s\t0x%08lX [%c]\n",
-                                     acpi_debug_layers[i].name,
-                                     acpi_debug_layers[i].value,
-                                     (acpi_dbg_layer & acpi_debug_layers[i].
-                                      value) ? '*' : ' ');
-                }
-                seq_printf(m, "%-25s\t0x%08X [%c]\n", "ACPI_ALL_DRIVERS",
-                             ACPI_ALL_DRIVERS,
-                             (acpi_dbg_layer & ACPI_ALL_DRIVERS) ==
-                             ACPI_ALL_DRIVERS ? '*' : (acpi_dbg_layer &
-                                                       ACPI_ALL_DRIVERS) ==
-                             0 ? ' ' : '-');
-                seq_printf(m,
-                             "--\ndebug_layer = 0x%08X (* = enabled, - = partial)\n",
-                             acpi_dbg_layer);
-                break;
-        case 1:
-                for (i = 0; i < ARRAY_SIZE(acpi_debug_levels); i++) {
-                        seq_printf(m, "%-25s\t0x%08lX [%c]\n",
-                                     acpi_debug_levels[i].name,
-                                     acpi_debug_levels[i].value,
-                                     (acpi_dbg_level & acpi_debug_levels[i].
-                                      value) ? '*' : ' ');
-                }
-                seq_printf(m, "--\ndebug_level = 0x%08X (* = enabled)\n",
-                             acpi_dbg_level);
-                break;
-        }
-        return 0;
-}
-
-static int acpi_system_debug_proc_open(struct inode *inode, struct file *file)
-{
-        return single_open(file, acpi_system_debug_proc_show, PDE(inode)->data);
-}
-
-static ssize_t acpi_system_debug_proc_write(struct file *file,
-                        const char __user * buffer,
-                        size_t count, loff_t *pos)
-{
-        char debug_string[12] = { '\0' };
-
-
-        if (count > sizeof(debug_string) - 1)
-                return -EINVAL;
-
-        if (copy_from_user(debug_string, buffer, count))
-                return -EFAULT;
-
-        debug_string[count] = '\0';
-
-        switch ((unsigned long)PDE(file->f_path.dentry->d_inode)->data) {
-        case 0:
-                acpi_dbg_layer = simple_strtoul(debug_string, NULL, 0);
-                break;
-        case 1:
-                acpi_dbg_level = simple_strtoul(debug_string, NULL, 0);
-                break;
-        default:
-                return -EINVAL;
-        }
-
-        return count;
-}
-
-static const struct file_operations acpi_system_debug_proc_fops = {
-        .owner          = THIS_MODULE,
-        .open           = acpi_system_debug_proc_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = single_release,
-        .write          = acpi_system_debug_proc_write,
-};
-#endif
-
-int __init acpi_procfs_init(void)
-{
-#ifdef CONFIG_ACPI_PROCFS
-        struct proc_dir_entry *entry;
-        int error = 0;
-        char *name;
-
-        /* 'debug_layer' [R/W] */
-        name = ACPI_SYSTEM_FILE_DEBUG_LAYER;
-        entry = proc_create_data(name, S_IFREG | S_IRUGO | S_IWUSR,
-                                 acpi_root_dir, &acpi_system_debug_proc_fops,
-                                 (void *)0);
-        if (!entry)
-                goto Error;
-
-        /* 'debug_level' [R/W] */
-        name = ACPI_SYSTEM_FILE_DEBUG_LEVEL;
-        entry = proc_create_data(name, S_IFREG | S_IRUGO | S_IWUSR,
-                                 acpi_root_dir, &acpi_system_debug_proc_fops,
-                                 (void *)1);
-        if (!entry)
-                goto Error;
-
-      Done:
-        return error;
-
-      Error:
-        remove_proc_entry(ACPI_SYSTEM_FILE_DEBUG_LEVEL, acpi_root_dir);
-        remove_proc_entry(ACPI_SYSTEM_FILE_DEBUG_LAYER, acpi_root_dir);
-        error = -ENODEV;
-        goto Done;
-#else
-        return 0;
-#endif
-}
-
-int __init acpi_debug_init(void)
-{
-        acpi_debugfs_init();
-        acpi_procfs_init();
-        return 0;
-}
diff --git a/drivers/acpi/debugfs.c b/drivers/acpi/debugfs.c
new file mode 100644
index 000000000000..7de27d49c4b9
--- /dev/null
+++ b/drivers/acpi/debugfs.c
@@ -0,0 +1,93 @@
+/*
+ * debugfs.c - ACPI debugfs interface to userspace.
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/uaccess.h>
+#include <linux/debugfs.h>
+#include <acpi/acpi_drivers.h>
+
+#define _COMPONENT              ACPI_SYSTEM_COMPONENT
+ACPI_MODULE_NAME("debugfs");
+
+
+/* /sys/modules/acpi/parameters/aml_debug_output */
+
+module_param_named(aml_debug_output, acpi_gbl_enable_aml_debug_object,
+                   bool, 0644);
+MODULE_PARM_DESC(aml_debug_output,
+                 "To enable/disable the ACPI Debug Object output.");
+
+/* /sys/kernel/debug/acpi/custom_method */
+
+static ssize_t cm_write(struct file *file, const char __user * user_buf,
+                        size_t count, loff_t *ppos)
+{
+        static char *buf;
+        static int uncopied_bytes;
+        struct acpi_table_header table;
+        acpi_status status;
+
+        if (!(*ppos)) {
+                /* parse the table header to get the table length */
+                if (count <= sizeof(struct acpi_table_header))
+                        return -EINVAL;
+                if (copy_from_user(&table, user_buf,
+                                   sizeof(struct acpi_table_header)))
+                        return -EFAULT;
+                uncopied_bytes = table.length;
+                buf = kzalloc(uncopied_bytes, GFP_KERNEL);
+                if (!buf)
+                        return -ENOMEM;
+        }
+
+        if (uncopied_bytes < count) {
+                kfree(buf);
+                return -EINVAL;
+        }
+
+        if (copy_from_user(buf + (*ppos), user_buf, count)) {
+                kfree(buf);
+                return -EFAULT;
+        }
+
+        uncopied_bytes -= count;
+        *ppos += count;
+
+        if (!uncopied_bytes) {
+                status = acpi_install_method(buf);
+                kfree(buf);
+                if (ACPI_FAILURE(status))
+                        return -EINVAL;
+                add_taint(TAINT_OVERRIDDEN_ACPI_TABLE);
+        }
+
+        return count;
+}
+
+static const struct file_operations cm_fops = {
+        .write = cm_write,
+};
+
+int __init acpi_debugfs_init(void)
+{
+        struct dentry *acpi_dir, *cm_dentry;
+
+        acpi_dir = debugfs_create_dir("acpi", NULL);
+        if (!acpi_dir)
+                goto err;
+
+        cm_dentry = debugfs_create_file("custom_method", S_IWUGO,
+                                        acpi_dir, NULL, &cm_fops);
+        if (!cm_dentry)
+                goto err;
+
+        return 0;
+
+err:
+        if (acpi_dir)
+                debugfs_remove(acpi_dir);
+        return -EINVAL;
+}
diff --git a/drivers/acpi/glue.c b/drivers/acpi/glue.c
index 4af6301601e7..78b0164c35b2 100644
--- a/drivers/acpi/glue.c
+++ b/drivers/acpi/glue.c
@@ -100,7 +100,8 @@ do_acpi_find_child(acpi_handle handle, u32 lvl, void *context, void **rv)
 
         status = acpi_get_object_info(handle, &info);
         if (ACPI_SUCCESS(status)) {
-                if (info->address == find->address)
+                if ((info->address == find->address)
+                        && (info->valid & ACPI_VALID_ADR))
                         find->handle = handle;
                 kfree(info);
         }
diff --git a/drivers/acpi/internal.h b/drivers/acpi/internal.h
index 8ae27264a00e..a212bfeddf8c 100644
--- a/drivers/acpi/internal.h
+++ b/drivers/acpi/internal.h
@@ -27,12 +27,12 @@
 
 int init_acpi_device_notify(void);
 int acpi_scan_init(void);
-int acpi_system_init(void);
+int acpi_sysfs_init(void);
 
-#ifdef CONFIG_ACPI_DEBUG
-int acpi_debug_init(void);
+#ifdef CONFIG_DEBUG_FS
+int acpi_debugfs_init(void);
 #else
-static inline int acpi_debug_init(void) { return 0; }
+static inline int acpi_debugfs_init(void) { return 0; }
 #endif
 
 /* --------------------------------------------------------------------------
diff --git a/drivers/acpi/numa.c b/drivers/acpi/numa.c
index b0337d314604..5718566e00f9 100644
--- a/drivers/acpi/numa.c
+++ b/drivers/acpi/numa.c
@@ -255,12 +255,10 @@ acpi_parse_memory_affinity(struct acpi_subtable_header * header,
 
 static int __init acpi_parse_srat(struct acpi_table_header *table)
 {
-        struct acpi_table_srat *srat;
-
         if (!table)
                 return -EINVAL;
 
-        srat = (struct acpi_table_srat *)table;
+        /* Real work done in acpi_table_parse_srat below. */
 
         return 0;
 }
diff --git a/drivers/acpi/osl.c b/drivers/acpi/osl.c
index f14d3f251d26..65b25a303b86 100644
--- a/drivers/acpi/osl.c
+++ b/drivers/acpi/osl.c
@@ -141,15 +141,14 @@ static struct osi_linux {
 static void __init acpi_request_region (struct acpi_generic_address *addr,
         unsigned int length, char *desc)
 {
-        struct resource *res;
-
         if (!addr->address || !length)
                 return;
 
+        /* Resources are never freed */
         if (addr->space_id == ACPI_ADR_SPACE_SYSTEM_IO)
-                res = request_region(addr->address, length, desc);
+                request_region(addr->address, length, desc);
         else if (addr->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY)
-                res = request_mem_region(addr->address, length, desc);
+                request_mem_region(addr->address, length, desc);
 }
 
 static int __init acpi_reserve_resources(void)
diff --git a/drivers/acpi/power.c b/drivers/acpi/power.c
index f74d3b31e5c9..844c155aeb0f 100644
--- a/drivers/acpi/power.c
+++ b/drivers/acpi/power.c
@@ -40,8 +40,6 @@
 #include <linux/init.h>
 #include <linux/types.h>
 #include <linux/slab.h>
-#include <linux/proc_fs.h>
-#include <linux/seq_file.h>
 #include <acpi/acpi_bus.h>
 #include <acpi/acpi_drivers.h>
 #include "sleep.h"
@@ -64,7 +62,6 @@ module_param_named(power_nocheck, acpi_power_nocheck, bool, 000);
 static int acpi_power_add(struct acpi_device *device);
 static int acpi_power_remove(struct acpi_device *device, int type);
 static int acpi_power_resume(struct acpi_device *device);
-static int acpi_power_open_fs(struct inode *inode, struct file *file);
 
 static const struct acpi_device_id power_device_ids[] = {
         {ACPI_POWER_HID, 0},
@@ -99,14 +96,6 @@ struct acpi_power_resource {
 
 static struct list_head acpi_power_resource_list;
 
-static const struct file_operations acpi_power_fops = {
-        .owner = THIS_MODULE,
-        .open = acpi_power_open_fs,
-        .read = seq_read,
-        .llseek = seq_lseek,
-        .release = single_release,
-};
-
 /* --------------------------------------------------------------------------
                              Power Resource Management
    -------------------------------------------------------------------------- */
@@ -255,7 +244,6 @@ static int acpi_power_off_device(acpi_handle handle, struct acpi_device *dev)
         struct list_head *node, *next;
         struct acpi_power_reference *ref;
 
-
         result = acpi_power_get_context(handle, &resource);
         if (result)
                 return result;
@@ -542,102 +530,6 @@ int acpi_power_transition(struct acpi_device *device, int state)
 }
 
 /* --------------------------------------------------------------------------
-                              FS Interface (/proc)
-   -------------------------------------------------------------------------- */
-
-static struct proc_dir_entry *acpi_power_dir;
-
-static int acpi_power_seq_show(struct seq_file *seq, void *offset)
-{
-        int count = 0;
-        int result = 0, state;
-        struct acpi_power_resource *resource = NULL;
-        struct list_head *node, *next;
-        struct acpi_power_reference *ref;
-
-
-        resource = seq->private;
-
-        if (!resource)
-                goto end;
-
-        result = acpi_power_get_state(resource->device->handle, &state);
-        if (result)
-                goto end;
-
-        seq_puts(seq, "state:                   ");
-        switch (state) {
-        case ACPI_POWER_RESOURCE_STATE_ON:
-                seq_puts(seq, "on\n");
-                break;
-        case ACPI_POWER_RESOURCE_STATE_OFF:
-                seq_puts(seq, "off\n");
-                break;
-        default:
-                seq_puts(seq, "unknown\n");
-                break;
-        }
-
-        mutex_lock(&resource->resource_lock);
-        list_for_each_safe(node, next, &resource->reference) {
-                ref = container_of(node, struct acpi_power_reference, node);
-                count++;
-        }
-        mutex_unlock(&resource->resource_lock);
-
-        seq_printf(seq, "system level:            S%d\n"
-                   "order:                   %d\n"
-                   "reference count:         %d\n",
-                   resource->system_level,
-                   resource->order, count);
-
-      end:
-        return 0;
-}
-
-static int acpi_power_open_fs(struct inode *inode, struct file *file)
-{
-        return single_open(file, acpi_power_seq_show, PDE(inode)->data);
-}
-
-static int acpi_power_add_fs(struct acpi_device *device)
-{
-        struct proc_dir_entry *entry = NULL;
-
-
-        if (!device)
-                return -EINVAL;
-
-        if (!acpi_device_dir(device)) {
-                acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
-                                                     acpi_power_dir);
-                if (!acpi_device_dir(device))
-                        return -ENODEV;
-        }
-
-        /* 'status' [R] */
-        entry = proc_create_data(ACPI_POWER_FILE_STATUS,
-                                 S_IRUGO, acpi_device_dir(device),
-                                 &acpi_power_fops, acpi_driver_data(device));
-        if (!entry)
-                return -EIO;
-        return 0;
-}
-
-static int acpi_power_remove_fs(struct acpi_device *device)
-{
-
-        if (acpi_device_dir(device)) {
-                remove_proc_entry(ACPI_POWER_FILE_STATUS,
-                                  acpi_device_dir(device));
-                remove_proc_entry(acpi_device_bid(device), acpi_power_dir);
-                acpi_device_dir(device) = NULL;
-        }
-
-        return 0;
-}
-
-/* --------------------------------------------------------------------------
                                 Driver Interface
    -------------------------------------------------------------------------- */
 
@@ -690,10 +582,6 @@ static int acpi_power_add(struct acpi_device *device)
                 break;
         }
 
-        result = acpi_power_add_fs(device);
-        if (result)
-                goto end;
-
         printk(KERN_INFO PREFIX "%s [%s] (%s)\n", acpi_device_name(device),
                acpi_device_bid(device), state ? "on" : "off");
 
@@ -715,8 +603,6 @@ static int acpi_power_remove(struct acpi_device *device, int type)
 
         resource = acpi_driver_data(device);
 
-        acpi_power_remove_fs(device);
-
         mutex_lock(&resource->resource_lock);
         list_for_each_safe(node, next, &resource->reference) {
                 struct acpi_power_reference *ref = container_of(node, struct acpi_power_reference, node);
@@ -760,19 +646,6 @@ static int acpi_power_resume(struct acpi_device *device)
 
 int __init acpi_power_init(void)
 {
-        int result = 0;
-
         INIT_LIST_HEAD(&acpi_power_resource_list);
-
-        acpi_power_dir = proc_mkdir(ACPI_POWER_CLASS, acpi_root_dir);
-        if (!acpi_power_dir)
-                return -ENODEV;
-
-        result = acpi_bus_register_driver(&acpi_power_driver);
-        if (result < 0) {
-                remove_proc_entry(ACPI_POWER_CLASS, acpi_root_dir);
-                return -ENODEV;
-        }
-
-        return 0;
+        return acpi_bus_register_driver(&acpi_power_driver);
 }
diff --git a/drivers/acpi/proc.c b/drivers/acpi/proc.c
index 1ac678d2c51c..afad67769db6 100644
--- a/drivers/acpi/proc.c
+++ b/drivers/acpi/proc.c
@@ -17,64 +17,11 @@
 
 /*
  * this file provides support for:
- * /proc/acpi/sleep
  * /proc/acpi/alarm
  * /proc/acpi/wakeup
  */
 
 ACPI_MODULE_NAME("sleep")
-#ifdef  CONFIG_ACPI_PROCFS
-static int acpi_system_sleep_seq_show(struct seq_file *seq, void *offset)
-{
-        int i;
-
-        for (i = 0; i <= ACPI_STATE_S5; i++) {
-                if (sleep_states[i]) {
-                        seq_printf(seq, "S%d ", i);
-                }
-        }
-
-        seq_puts(seq, "\n");
-
-        return 0;
-}
-
-static int acpi_system_sleep_open_fs(struct inode *inode, struct file *file)
-{
-        return single_open(file, acpi_system_sleep_seq_show, PDE(inode)->data);
-}
-
-static ssize_t
-acpi_system_write_sleep(struct file *file,
-                        const char __user * buffer, size_t count, loff_t * ppos)
-{
-        char str[12];
-        u32 state = 0;
-        int error = 0;
-
-        if (count > sizeof(str) - 1)
-                goto Done;
-        memset(str, 0, sizeof(str));
-        if (copy_from_user(str, buffer, count))
-                return -EFAULT;
-
-        /* Check for S4 bios request */
-        if (!strcmp(str, "4b")) {
-                error = acpi_suspend(4);
-                goto Done;
-        }
-        state = simple_strtoul(str, NULL, 0);
-#ifdef CONFIG_HIBERNATION
-        if (state == 4) {
-                error = hibernate();
-                goto Done;
-        }
-#endif
-        error = acpi_suspend(state);
-      Done:
-        return error ? error : count;
-}
-#endif                          /* CONFIG_ACPI_PROCFS */
 
 #if defined(CONFIG_RTC_DRV_CMOS) || defined(CONFIG_RTC_DRV_CMOS_MODULE) || !defined(CONFIG_X86)
 /* use /sys/class/rtc/rtcX/wakealarm instead; it's not ACPI-specific */
@@ -463,17 +410,6 @@ static const struct file_operations acpi_system_wakeup_device_fops = {
         .release = single_release,
 };
 
-#ifdef  CONFIG_ACPI_PROCFS
-static const struct file_operations acpi_system_sleep_fops = {
-        .owner = THIS_MODULE,
-        .open = acpi_system_sleep_open_fs,
-        .read = seq_read,
-        .write = acpi_system_write_sleep,
-        .llseek = seq_lseek,
-        .release = single_release,
-};
-#endif                          /* CONFIG_ACPI_PROCFS */
-
 #ifdef  HAVE_ACPI_LEGACY_ALARM
 static const struct file_operations acpi_system_alarm_fops = {
         .owner = THIS_MODULE,
@@ -495,12 +431,6 @@ static u32 rtc_handler(void *context)
 
 int __init acpi_sleep_proc_init(void)
 {
-#ifdef  CONFIG_ACPI_PROCFS
-        /* 'sleep' [R/W] */
-        proc_create("sleep", S_IFREG | S_IRUGO | S_IWUSR,
-                    acpi_root_dir, &acpi_system_sleep_fops);
-#endif                          /* CONFIG_ACPI_PROCFS */
-
 #ifdef  HAVE_ACPI_LEGACY_ALARM
         /* 'alarm' [R/W] */
         proc_create("alarm", S_IFREG | S_IRUGO | S_IWUSR,
diff --git a/drivers/acpi/processor_driver.c b/drivers/acpi/processor_driver.c
index 38ea0cc6dc49..156021892389 100644
--- a/drivers/acpi/processor_driver.c
+++ b/drivers/acpi/processor_driver.c
@@ -83,9 +83,6 @@ MODULE_LICENSE("GPL");
 
 static int acpi_processor_add(struct acpi_device *device);
 static int acpi_processor_remove(struct acpi_device *device, int type);
-#ifdef CONFIG_ACPI_PROCFS
-static int acpi_processor_info_open_fs(struct inode *inode, struct file *file);
-#endif
 static void acpi_processor_notify(struct acpi_device *device, u32 event);
 static acpi_status acpi_processor_hotadd_init(acpi_handle handle, int *p_cpu);
 static int acpi_processor_handle_eject(struct acpi_processor *pr);
@@ -113,15 +110,6 @@ static struct acpi_driver acpi_processor_driver = {
 
 #define INSTALL_NOTIFY_HANDLER          1
 #define UNINSTALL_NOTIFY_HANDLER        2
-#ifdef CONFIG_ACPI_PROCFS
-static const struct file_operations acpi_processor_info_fops = {
-        .owner = THIS_MODULE,
-        .open = acpi_processor_info_open_fs,
-        .read = seq_read,
-        .llseek = seq_lseek,
-        .release = single_release,
-};
-#endif
 
 DEFINE_PER_CPU(struct acpi_processor *, processors);
 EXPORT_PER_CPU_SYMBOL(processors);
@@ -256,44 +244,8 @@ static int acpi_processor_errata(struct acpi_processor *pr)
         return result;
 }
 
-/* --------------------------------------------------------------------------
-                              FS Interface (/proc)
-   -------------------------------------------------------------------------- */
-
-#ifdef CONFIG_ACPI_PROCFS
 static struct proc_dir_entry *acpi_processor_dir = NULL;
 
-static int acpi_processor_info_seq_show(struct seq_file *seq, void *offset)
-{
-        struct acpi_processor *pr = seq->private;
-
-
-        if (!pr)
-                goto end;
-
-        seq_printf(seq, "processor id:            %d\n"
-                   "acpi id:                 %d\n"
-                   "bus mastering control:   %s\n"
-                   "power management:        %s\n"
-                   "throttling control:      %s\n"
-                   "limit interface:         %s\n",
-                   pr->id,
-                   pr->acpi_id,
-                   pr->flags.bm_control ? "yes" : "no",
-                   pr->flags.power ? "yes" : "no",
-                   pr->flags.throttling ? "yes" : "no",
-                   pr->flags.limit ? "yes" : "no");
-
-      end:
-        return 0;
-}
-
-static int acpi_processor_info_open_fs(struct inode *inode, struct file *file)
-{
-        return single_open(file, acpi_processor_info_seq_show,
-                           PDE(inode)->data);
-}
-
 static int __cpuinit acpi_processor_add_fs(struct acpi_device *device)
 {
         struct proc_dir_entry *entry = NULL;
@@ -306,14 +258,6 @@ static int __cpuinit acpi_processor_add_fs(struct acpi_device *device)
                         return -ENODEV;
         }
 
-        /* 'info' [R] */
-        entry = proc_create_data(ACPI_PROCESSOR_FILE_INFO,
-                                 S_IRUGO, acpi_device_dir(device),
-                                 &acpi_processor_info_fops,
-                                 acpi_driver_data(device));
-        if (!entry)
-                return -EIO;
-
         /* 'throttling' [R/W] */
         entry = proc_create_data(ACPI_PROCESSOR_FILE_THROTTLING,
                                  S_IFREG | S_IRUGO | S_IWUSR,
@@ -322,43 +266,20 @@ static int __cpuinit acpi_processor_add_fs(struct acpi_device *device)
                                  acpi_driver_data(device));
         if (!entry)
                 return -EIO;
-
-        /* 'limit' [R/W] */
-        entry = proc_create_data(ACPI_PROCESSOR_FILE_LIMIT,
-                                 S_IFREG | S_IRUGO | S_IWUSR,
-                                 acpi_device_dir(device),
-                                 &acpi_processor_limit_fops,
-                                 acpi_driver_data(device));
-        if (!entry)
-                return -EIO;
         return 0;
 }
 static int acpi_processor_remove_fs(struct acpi_device *device)
 {
 
         if (acpi_device_dir(device)) {
-                remove_proc_entry(ACPI_PROCESSOR_FILE_INFO,
-                                  acpi_device_dir(device));
                 remove_proc_entry(ACPI_PROCESSOR_FILE_THROTTLING,
                                   acpi_device_dir(device));
-                remove_proc_entry(ACPI_PROCESSOR_FILE_LIMIT,
-                                  acpi_device_dir(device));
                 remove_proc_entry(acpi_device_bid(device), acpi_processor_dir);
                 acpi_device_dir(device) = NULL;
         }
 
         return 0;
 }
-#else
-static inline int acpi_processor_add_fs(struct acpi_device *device)
-{
-        return 0;
-}
-static inline int acpi_processor_remove_fs(struct acpi_device *device)
-{
-        return 0;
-}
-#endif
 
 /* --------------------------------------------------------------------------
                                  Driver Interface
@@ -921,11 +842,9 @@ static int __init acpi_processor_init(void)
 
         memset(&errata, 0, sizeof(errata));
 
-#ifdef CONFIG_ACPI_PROCFS
         acpi_processor_dir = proc_mkdir(ACPI_PROCESSOR_CLASS, acpi_root_dir);
         if (!acpi_processor_dir)
                 return -ENOMEM;
-#endif
 
         if (!cpuidle_register_driver(&acpi_idle_driver)) {
                 printk(KERN_DEBUG "ACPI: %s registered with cpuidle\n",
@@ -952,9 +871,7 @@ static int __init acpi_processor_init(void)
 out_cpuidle:
         cpuidle_unregister_driver(&acpi_idle_driver);
 
-#ifdef CONFIG_ACPI_PROCFS
         remove_proc_entry(ACPI_PROCESSOR_CLASS, acpi_root_dir);
-#endif
 
         return result;
 }
@@ -974,9 +891,7 @@ static void __exit acpi_processor_exit(void)
 
         cpuidle_unregister_driver(&acpi_idle_driver);
 
-#ifdef CONFIG_ACPI_PROCFS
         remove_proc_entry(ACPI_PROCESSOR_CLASS, acpi_root_dir);
-#endif
 
         return;
 }
diff --git a/drivers/acpi/processor_idle.c b/drivers/acpi/processor_idle.c
index b4c2f3bdadeb..f4428e82b352 100644
--- a/drivers/acpi/processor_idle.c
+++ b/drivers/acpi/processor_idle.c
@@ -33,8 +33,6 @@
 #include <linux/init.h>
 #include <linux/cpufreq.h>
 #include <linux/slab.h>
-#include <linux/proc_fs.h>
-#include <linux/seq_file.h>
 #include <linux/acpi.h>
 #include <linux/dmi.h>
 #include <linux/moduleparam.h>
@@ -82,13 +80,6 @@ module_param(bm_check_disable, uint, 0000);
 static unsigned int latency_factor __read_mostly = 2;
 module_param(latency_factor, uint, 0644);
 
-#ifdef CONFIG_ACPI_PROCFS
-static u64 us_to_pm_timer_ticks(s64 t)
-{
-        return div64_u64(t * PM_TIMER_FREQUENCY, 1000000);
-}
-#endif
-
 /*
  * IBM ThinkPad R40e crashes mysteriously when going into C2 or C3.
  * For now disable this. Probably a bug somewhere else.
@@ -689,78 +680,6 @@ static int acpi_processor_get_power_info(struct acpi_processor *pr)
         return 0;
 }
 
-#ifdef CONFIG_ACPI_PROCFS
-static int acpi_processor_power_seq_show(struct seq_file *seq, void *offset)
-{
-        struct acpi_processor *pr = seq->private;
-        unsigned int i;
-
-
-        if (!pr)
-                goto end;
-
-        seq_printf(seq, "active state:            C%zd\n"
-                   "max_cstate:              C%d\n"
-                   "maximum allowed latency: %d usec\n",
-                   pr->power.state ? pr->power.state - pr->power.states : 0,
-                   max_cstate, pm_qos_request(PM_QOS_CPU_DMA_LATENCY));
-
-        seq_puts(seq, "states:\n");
-
-        for (i = 1; i <= pr->power.count; i++) {
-                seq_printf(seq, "   %cC%d:                  ",
-                           (&pr->power.states[i] ==
-                            pr->power.state ? '*' : ' '), i);
-
-                if (!pr->power.states[i].valid) {
-                        seq_puts(seq, "<not supported>\n");
-                        continue;
-                }
-
-                switch (pr->power.states[i].type) {
-                case ACPI_STATE_C1:
-                        seq_printf(seq, "type[C1] ");
-                        break;
-                case ACPI_STATE_C2:
-                        seq_printf(seq, "type[C2] ");
-                        break;
-                case ACPI_STATE_C3:
-                        seq_printf(seq, "type[C3] ");
-                        break;
-                default:
-                        seq_printf(seq, "type[--] ");
-                        break;
-                }
-
-                seq_puts(seq, "promotion[--] ");
-
-                seq_puts(seq, "demotion[--] ");
-
-                seq_printf(seq, "latency[%03d] usage[%08d] duration[%020Lu]\n",
-                           pr->power.states[i].latency,
-                           pr->power.states[i].usage,
-                           us_to_pm_timer_ticks(pr->power.states[i].time));
-        }
-
-      end:
-        return 0;
-}
-
-static int acpi_processor_power_open_fs(struct inode *inode, struct file *file)
-{
-        return single_open(file, acpi_processor_power_seq_show,
-                           PDE(inode)->data);
-}
-
-static const struct file_operations acpi_processor_power_fops = {
-        .owner = THIS_MODULE,
-        .open = acpi_processor_power_open_fs,
-        .read = seq_read,
-        .llseek = seq_lseek,
-        .release = single_release,
-};
-#endif
-
 /**
  * acpi_idle_bm_check - checks if bus master activity was detected
  */
@@ -803,13 +722,12 @@ static inline void acpi_idle_do_entry(struct acpi_processor_cx *cx)
         } else if (cx->entry_method == ACPI_CSTATE_HALT) {
                 acpi_safe_halt();
         } else {
-                int unused;
                 /* IO port based C-state */
                 inb(cx->address);
                 /* Dummy wait op - must do something useless after P_LVL2 read
                    because chipsets cannot guarantee that STPCLK# signal
                    gets asserted in time to freeze execution properly. */
-                unused = inl(acpi_gbl_FADT.xpm_timer_block.address);
+                inl(acpi_gbl_FADT.xpm_timer_block.address);
         }
         start_critical_timings();
 }
@@ -1172,9 +1090,6 @@ int __cpuinit acpi_processor_power_init(struct acpi_processor *pr,
 {
         acpi_status status = 0;
         static int first_run;
-#ifdef CONFIG_ACPI_PROCFS
-        struct proc_dir_entry *entry = NULL;
-#endif
 
         if (boot_option_idle_override)
                 return 0;
@@ -1223,15 +1138,6 @@ int __cpuinit acpi_processor_power_init(struct acpi_processor *pr,
                 if (cpuidle_register_device(&pr->power.dev))
                         return -EIO;
         }
-#ifdef CONFIG_ACPI_PROCFS
-        /* 'power' [R] */
-        entry = proc_create_data(ACPI_PROCESSOR_FILE_POWER,
-                                 S_IRUGO, acpi_device_dir(device),
-                                 &acpi_processor_power_fops,
-                                 acpi_driver_data(device));
-        if (!entry)
-                return -EIO;
-#endif
         return 0;
 }
 
@@ -1244,11 +1150,5 @@ int acpi_processor_power_exit(struct acpi_processor *pr,
         cpuidle_unregister_device(&pr->power.dev);
         pr->flags.power_setup_done = 0;
 
-#ifdef CONFIG_ACPI_PROCFS
-        if (acpi_device_dir(device))
-                remove_proc_entry(ACPI_PROCESSOR_FILE_POWER,
-                                  acpi_device_dir(device));
-#endif
-
         return 0;
 }
diff --git a/drivers/acpi/processor_thermal.c b/drivers/acpi/processor_thermal.c
index 6deafb4aa0da..953b25fb9869 100644
--- a/drivers/acpi/processor_thermal.c
+++ b/drivers/acpi/processor_thermal.c
@@ -30,8 +30,6 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/cpufreq.h>
-#include <linux/proc_fs.h>
-#include <linux/seq_file.h>
 #include <linux/sysdev.h>
 
 #include <asm/uaccess.h>
@@ -438,84 +436,3 @@ struct thermal_cooling_device_ops processor_cooling_ops = {
         .get_cur_state = processor_get_cur_state,
         .set_cur_state = processor_set_cur_state,
 };
-
-/* /proc interface */
-#ifdef CONFIG_ACPI_PROCFS
-static int acpi_processor_limit_seq_show(struct seq_file *seq, void *offset)
-{
-        struct acpi_processor *pr = seq->private;
-
-        if (!pr)
-                goto end;
-
-        if (!pr->flags.limit) {
-                seq_puts(seq, "<not supported>\n");
-                goto end;
-        }
-
-        seq_printf(seq, "active limit:            P%d:T%d\n"
-                   "user limit:              P%d:T%d\n"
-                   "thermal limit:           P%d:T%d\n",
-                   pr->limit.state.px, pr->limit.state.tx,
-                   pr->limit.user.px, pr->limit.user.tx,
-                   pr->limit.thermal.px, pr->limit.thermal.tx);
-
-      end:
-        return 0;
-}
-
-static int acpi_processor_limit_open_fs(struct inode *inode, struct file *file)
-{
-        return single_open(file, acpi_processor_limit_seq_show,
-                           PDE(inode)->data);
-}
-
-static ssize_t acpi_processor_write_limit(struct file * file,
-                                          const char __user * buffer,
-                                          size_t count, loff_t * data)
-{
-        int result = 0;
-        struct seq_file *m = file->private_data;
-        struct acpi_processor *pr = m->private;
-        char limit_string[25] = { '\0' };
-        int px = 0;
-        int tx = 0;
-
-
-        if (!pr || (count > sizeof(limit_string) - 1)) {
-                return -EINVAL;
-        }
-
-        if (copy_from_user(limit_string, buffer, count)) {
-                return -EFAULT;
-        }
-
-        limit_string[count] = '\0';
-
-        if (sscanf(limit_string, "%d:%d", &px, &tx) != 2) {
-                printk(KERN_ERR PREFIX "Invalid data format\n");
-                return -EINVAL;
-        }
-
-        if (pr->flags.throttling) {
-                if ((tx < 0) || (tx > (pr->throttling.state_count - 1))) {
-                        printk(KERN_ERR PREFIX "Invalid tx\n");
-                        return -EINVAL;
-                }
-                pr->limit.user.tx = tx;
-        }
-
-        result = acpi_processor_apply_limit(pr);
-
-        return count;
-}
-
-const struct file_operations acpi_processor_limit_fops = {
-        .owner = THIS_MODULE,
-        .open = acpi_processor_limit_open_fs,
-        .read = seq_read,
-        .write = acpi_processor_write_limit,
-        .llseek = seq_lseek,
-        .release = single_release,
-};
-#endif
diff --git a/drivers/acpi/processor_throttling.c b/drivers/acpi/processor_throttling.c
index 9ade1a5b32ed..730863855ed5 100644
--- a/drivers/acpi/processor_throttling.c
+++ b/drivers/acpi/processor_throttling.c
@@ -1215,7 +1215,6 @@ int acpi_processor_get_throttling_info(struct acpi_processor *pr)
 }
 
 /* proc interface */
-#ifdef CONFIG_ACPI_PROCFS
 static int acpi_processor_throttling_seq_show(struct seq_file *seq,
                                               void *offset)
 {
@@ -1323,4 +1322,3 @@ const struct file_operations acpi_processor_throttling_fops = {
         .llseek = seq_lseek,
         .release = single_release,
 };
-#endif
diff --git a/drivers/acpi/sleep.c b/drivers/acpi/sleep.c
index e143203254a4..cf82989ae756 100644
--- a/drivers/acpi/sleep.c
+++ b/drivers/acpi/sleep.c
@@ -70,10 +70,10 @@ static int acpi_sleep_prepare(u32 acpi_state)
 
         }
         ACPI_FLUSH_CPU_CACHE();
-        acpi_enable_wakeup_device_prep(acpi_state);
 #endif
         printk(KERN_INFO PREFIX "Preparing to enter system sleep state S%d\n",
                 acpi_state);
+        acpi_enable_wakeup_devices(acpi_state);
         acpi_enter_sleep_state_prep(acpi_state);
         return 0;
 }
@@ -119,6 +119,16 @@ static int acpi_pm_freeze(void)
 }
 
 /**
+ * acpi_pre_suspend - Enable wakeup devices, "freeze" EC and save NVS.
+ */
+static int acpi_pm_pre_suspend(void)
+{
+        acpi_pm_freeze();
+        suspend_nvs_save();
+        return 0;
+}
+
+/**
  *      __acpi_pm_prepare - Prepare the platform to enter the target state.
  *
  *      If necessary, set the firmware waking vector and do arch-specific
@@ -127,11 +137,9 @@ static int acpi_pm_freeze(void)
 static int __acpi_pm_prepare(void)
 {
         int error = acpi_sleep_prepare(acpi_target_sleep_state);
-
-        suspend_nvs_save();
-
         if (error)
                 acpi_target_sleep_state = ACPI_STATE_S0;
+
         return error;
 }
 
@@ -142,9 +150,8 @@ static int __acpi_pm_prepare(void)
 static int acpi_pm_prepare(void)
 {
         int error = __acpi_pm_prepare();
-
         if (!error)
-                acpi_pm_freeze();
+                acpi_pm_pre_suspend();
 
         return error;
 }
@@ -159,7 +166,6 @@ static void acpi_pm_finish(void)
 {
         u32 acpi_state = acpi_target_sleep_state;
 
-        suspend_nvs_free();
         acpi_ec_unblock_transactions();
 
         if (acpi_state == ACPI_STATE_S0)
@@ -167,7 +173,7 @@ static void acpi_pm_finish(void)
 
         printk(KERN_INFO PREFIX "Waking up from system sleep state S%d\n",
                 acpi_state);
-        acpi_disable_wakeup_device(acpi_state);
+        acpi_disable_wakeup_devices(acpi_state);
         acpi_leave_sleep_state(acpi_state);
 
         /* reset firmware waking vector */
@@ -181,6 +187,7 @@ static void acpi_pm_finish(void)
  */
 static void acpi_pm_end(void)
 {
+        suspend_nvs_free();
         /*
          * This is necessary in case acpi_pm_finish() is not called during a
          * failing transition to a sleep state.
@@ -251,7 +258,6 @@ static int acpi_suspend_enter(suspend_state_t pm_state)
         }
 
         local_irq_save(flags);
-        acpi_enable_wakeup_device(acpi_state);
         switch (acpi_state) {
         case ACPI_STATE_S1:
                 barrier();
@@ -297,11 +303,6 @@ static int acpi_suspend_enter(suspend_state_t pm_state)
         return ACPI_SUCCESS(status) ? 0 : -EFAULT;
 }
 
-static void acpi_suspend_finish(void)
-{
-        acpi_pm_finish();
-}
-
 static int acpi_suspend_state_valid(suspend_state_t pm_state)
 {
         u32 acpi_state;
@@ -323,7 +324,7 @@ static struct platform_suspend_ops acpi_suspend_ops = {
         .begin = acpi_suspend_begin,
         .prepare_late = acpi_pm_prepare,
         .enter = acpi_suspend_enter,
-        .wake = acpi_suspend_finish,
+        .wake = acpi_pm_finish,
         .end = acpi_pm_end,
 };
 
@@ -336,9 +337,9 @@ static struct platform_suspend_ops acpi_suspend_ops = {
 static int acpi_suspend_begin_old(suspend_state_t pm_state)
 {
         int error = acpi_suspend_begin(pm_state);
-
         if (!error)
                 error = __acpi_pm_prepare();
+
         return error;
 }
 
@@ -349,9 +350,9 @@ static int acpi_suspend_begin_old(suspend_state_t pm_state)
 static struct platform_suspend_ops acpi_suspend_ops_old = {
         .valid = acpi_suspend_state_valid,
         .begin = acpi_suspend_begin_old,
-        .prepare_late = acpi_pm_freeze,
+        .prepare_late = acpi_pm_pre_suspend,
         .enter = acpi_suspend_enter,
-        .wake = acpi_suspend_finish,
+        .wake = acpi_pm_finish,
         .end = acpi_pm_end,
         .recover = acpi_pm_finish,
 };
@@ -423,16 +424,6 @@ static int acpi_hibernation_begin(void)
         return error;
 }
 
-static int acpi_hibernation_pre_snapshot(void)
-{
-        int error = acpi_pm_prepare();
-
-        if (!error)
-                suspend_nvs_save();
-
-        return error;
-}
-
 static int acpi_hibernation_enter(void)
 {
         acpi_status status = AE_OK;
@@ -441,7 +432,6 @@ static int acpi_hibernation_enter(void)
         ACPI_FLUSH_CPU_CACHE();
 
         local_irq_save(flags);
-        acpi_enable_wakeup_device(ACPI_STATE_S4);
         /* This shouldn't return.  If it returns, we have a problem */
         status = acpi_enter_sleep_state(ACPI_STATE_S4);
         /* Reprogram control registers and execute _BFS */
@@ -481,7 +471,7 @@ static void acpi_pm_thaw(void)
 static struct platform_hibernation_ops acpi_hibernation_ops = {
         .begin = acpi_hibernation_begin,
         .end = acpi_pm_end,
-        .pre_snapshot = acpi_hibernation_pre_snapshot,
+        .pre_snapshot = acpi_pm_prepare,
         .finish = acpi_pm_finish,
         .prepare = acpi_pm_prepare,
         .enter = acpi_hibernation_enter,
@@ -517,13 +507,6 @@ static int acpi_hibernation_begin_old(void)
         return error;
 }
 
-static int acpi_hibernation_pre_snapshot_old(void)
-{
-        acpi_pm_freeze();
-        suspend_nvs_save();
-        return 0;
-}
-
 /*
  * The following callbacks are used if the pre-ACPI 2.0 suspend ordering has
  * been requested.
@@ -531,7 +514,7 @@ static int acpi_hibernation_pre_snapshot_old(void)
 static struct platform_hibernation_ops acpi_hibernation_ops_old = {
         .begin = acpi_hibernation_begin_old,
         .end = acpi_pm_end,
-        .pre_snapshot = acpi_hibernation_pre_snapshot_old,
+        .pre_snapshot = acpi_pm_pre_suspend,
         .prepare = acpi_pm_freeze,
         .finish = acpi_pm_finish,
         .enter = acpi_hibernation_enter,
@@ -686,7 +669,6 @@ static void acpi_power_off(void)
         /* acpi_sleep_prepare(ACPI_STATE_S5) should have already been called */
         printk(KERN_DEBUG "%s called\n", __func__);
         local_irq_disable();
-        acpi_enable_wakeup_device(ACPI_STATE_S5);
         acpi_enter_sleep_state(ACPI_STATE_S5);
 }
 
diff --git a/drivers/acpi/sleep.h b/drivers/acpi/sleep.h
index 25b8bd149284..d8821805c3bc 100644
--- a/drivers/acpi/sleep.h
+++ b/drivers/acpi/sleep.h
@@ -2,9 +2,8 @@
 extern u8 sleep_states[];
 extern int acpi_suspend(u32 state);
 
-extern void acpi_enable_wakeup_device_prep(u8 sleep_state);
-extern void acpi_enable_wakeup_device(u8 sleep_state);
-extern void acpi_disable_wakeup_device(u8 sleep_state);
+extern void acpi_enable_wakeup_devices(u8 sleep_state);
+extern void acpi_disable_wakeup_devices(u8 sleep_state);
 
 extern struct list_head acpi_wakeup_device_list;
 extern struct mutex acpi_device_lock;
diff --git a/drivers/acpi/system.c b/drivers/acpi/sysfs.c
index 5981bd07e20e..68e2e4582fa2 100644
--- a/drivers/acpi/system.c
+++ b/drivers/acpi/sysfs.c
@@ -1,51 +1,218 @@
 /*
- *  acpi_system.c - ACPI System Driver ($Revision: 63 $)
- *
- *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
- *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.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.
- *
- * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ * sysfs.c - ACPI sysfs interface to userspace.
  */
 
-#include <linux/proc_fs.h>
-#include <linux/seq_file.h>
-#include <linux/slab.h>
 #include <linux/init.h>
-#include <linux/string.h>
-#include <asm/uaccess.h>
-
+#include <linux/kernel.h>
+#include <linux/moduleparam.h>
 #include <acpi/acpi_drivers.h>
 
-#define PREFIX "ACPI: "
-
 #define _COMPONENT              ACPI_SYSTEM_COMPONENT
-ACPI_MODULE_NAME("system");
-
-#define ACPI_SYSTEM_CLASS               "system"
-#define ACPI_SYSTEM_DEVICE_NAME         "System"
+ACPI_MODULE_NAME("sysfs");
 
-u32 acpi_irq_handled;
-u32 acpi_irq_not_handled;
+#define PREFIX "ACPI: "
 
+#ifdef CONFIG_ACPI_DEBUG
 /*
- * Make ACPICA version work as module param
+ * ACPI debug sysfs I/F, including:
+ * /sys/modules/acpi/parameters/debug_layer
+ * /sys/modules/acpi/parameters/debug_level
+ * /sys/modules/acpi/parameters/trace_method_name
+ * /sys/modules/acpi/parameters/trace_state
+ * /sys/modules/acpi/parameters/trace_debug_layer
+ * /sys/modules/acpi/parameters/trace_debug_level
  */
+
+struct acpi_dlayer {
+        const char *name;
+        unsigned long value;
+};
+struct acpi_dlevel {
+        const char *name;
+        unsigned long value;
+};
+#define ACPI_DEBUG_INIT(v)      { .name = #v, .value = v }
+
+static const struct acpi_dlayer acpi_debug_layers[] = {
+        ACPI_DEBUG_INIT(ACPI_UTILITIES),
+        ACPI_DEBUG_INIT(ACPI_HARDWARE),
+        ACPI_DEBUG_INIT(ACPI_EVENTS),
+        ACPI_DEBUG_INIT(ACPI_TABLES),
+        ACPI_DEBUG_INIT(ACPI_NAMESPACE),
+        ACPI_DEBUG_INIT(ACPI_PARSER),
+        ACPI_DEBUG_INIT(ACPI_DISPATCHER),
+        ACPI_DEBUG_INIT(ACPI_EXECUTER),
+        ACPI_DEBUG_INIT(ACPI_RESOURCES),
+        ACPI_DEBUG_INIT(ACPI_CA_DEBUGGER),
+        ACPI_DEBUG_INIT(ACPI_OS_SERVICES),
+        ACPI_DEBUG_INIT(ACPI_CA_DISASSEMBLER),
+        ACPI_DEBUG_INIT(ACPI_COMPILER),
+        ACPI_DEBUG_INIT(ACPI_TOOLS),
+
+        ACPI_DEBUG_INIT(ACPI_BUS_COMPONENT),
+        ACPI_DEBUG_INIT(ACPI_AC_COMPONENT),
+        ACPI_DEBUG_INIT(ACPI_BATTERY_COMPONENT),
+        ACPI_DEBUG_INIT(ACPI_BUTTON_COMPONENT),
+        ACPI_DEBUG_INIT(ACPI_SBS_COMPONENT),
+        ACPI_DEBUG_INIT(ACPI_FAN_COMPONENT),
+        ACPI_DEBUG_INIT(ACPI_PCI_COMPONENT),
+        ACPI_DEBUG_INIT(ACPI_POWER_COMPONENT),
+        ACPI_DEBUG_INIT(ACPI_CONTAINER_COMPONENT),
+        ACPI_DEBUG_INIT(ACPI_SYSTEM_COMPONENT),
+        ACPI_DEBUG_INIT(ACPI_THERMAL_COMPONENT),
+        ACPI_DEBUG_INIT(ACPI_MEMORY_DEVICE_COMPONENT),
+        ACPI_DEBUG_INIT(ACPI_VIDEO_COMPONENT),
+        ACPI_DEBUG_INIT(ACPI_PROCESSOR_COMPONENT),
+};
+
+static const struct acpi_dlevel acpi_debug_levels[] = {
+        ACPI_DEBUG_INIT(ACPI_LV_INIT),
+        ACPI_DEBUG_INIT(ACPI_LV_DEBUG_OBJECT),
+        ACPI_DEBUG_INIT(ACPI_LV_INFO),
+
+        ACPI_DEBUG_INIT(ACPI_LV_INIT_NAMES),
+        ACPI_DEBUG_INIT(ACPI_LV_PARSE),
+        ACPI_DEBUG_INIT(ACPI_LV_LOAD),
+        ACPI_DEBUG_INIT(ACPI_LV_DISPATCH),
+        ACPI_DEBUG_INIT(ACPI_LV_EXEC),
+        ACPI_DEBUG_INIT(ACPI_LV_NAMES),
+        ACPI_DEBUG_INIT(ACPI_LV_OPREGION),
+        ACPI_DEBUG_INIT(ACPI_LV_BFIELD),
+        ACPI_DEBUG_INIT(ACPI_LV_TABLES),
+        ACPI_DEBUG_INIT(ACPI_LV_VALUES),
+        ACPI_DEBUG_INIT(ACPI_LV_OBJECTS),
+        ACPI_DEBUG_INIT(ACPI_LV_RESOURCES),
+        ACPI_DEBUG_INIT(ACPI_LV_USER_REQUESTS),
+        ACPI_DEBUG_INIT(ACPI_LV_PACKAGE),
+
+        ACPI_DEBUG_INIT(ACPI_LV_ALLOCATIONS),
+        ACPI_DEBUG_INIT(ACPI_LV_FUNCTIONS),
+        ACPI_DEBUG_INIT(ACPI_LV_OPTIMIZATIONS),
+
+        ACPI_DEBUG_INIT(ACPI_LV_MUTEX),
+        ACPI_DEBUG_INIT(ACPI_LV_THREADS),
+        ACPI_DEBUG_INIT(ACPI_LV_IO),
+        ACPI_DEBUG_INIT(ACPI_LV_INTERRUPTS),
+
+        ACPI_DEBUG_INIT(ACPI_LV_AML_DISASSEMBLE),
+        ACPI_DEBUG_INIT(ACPI_LV_VERBOSE_INFO),
+        ACPI_DEBUG_INIT(ACPI_LV_FULL_TABLES),
+        ACPI_DEBUG_INIT(ACPI_LV_EVENTS),
+};
+
+static int param_get_debug_layer(char *buffer, struct kernel_param *kp)
+{
+        int result = 0;
+        int i;
+
+        result = sprintf(buffer, "%-25s\tHex        SET\n", "Description");
+
+        for (i = 0; i < ARRAY_SIZE(acpi_debug_layers); i++) {
+                result += sprintf(buffer + result, "%-25s\t0x%08lX [%c]\n",
+                                  acpi_debug_layers[i].name,
+                                  acpi_debug_layers[i].value,
+                                  (acpi_dbg_layer & acpi_debug_layers[i].value)
+                                  ? '*' : ' ');
+        }
+        result +=
+            sprintf(buffer + result, "%-25s\t0x%08X [%c]\n", "ACPI_ALL_DRIVERS",
+                    ACPI_ALL_DRIVERS,
+                    (acpi_dbg_layer & ACPI_ALL_DRIVERS) ==
+                    ACPI_ALL_DRIVERS ? '*' : (acpi_dbg_layer & ACPI_ALL_DRIVERS)
+                    == 0 ? ' ' : '-');
+        result +=
+            sprintf(buffer + result,
+                    "--\ndebug_layer = 0x%08X ( * = enabled)\n",
+                    acpi_dbg_layer);
+
+        return result;
+}
+
+static int param_get_debug_level(char *buffer, struct kernel_param *kp)
+{
+        int result = 0;
+        int i;
+
+        result = sprintf(buffer, "%-25s\tHex        SET\n", "Description");
+
+        for (i = 0; i < ARRAY_SIZE(acpi_debug_levels); i++) {
+                result += sprintf(buffer + result, "%-25s\t0x%08lX [%c]\n",
+                                  acpi_debug_levels[i].name,
+                                  acpi_debug_levels[i].value,
+                                  (acpi_dbg_level & acpi_debug_levels[i].value)
+                                  ? '*' : ' ');
+        }
+        result +=
+            sprintf(buffer + result, "--\ndebug_level = 0x%08X (* = enabled)\n",
+                    acpi_dbg_level);
+
+        return result;
+}
+
+module_param_call(debug_layer, param_set_uint, param_get_debug_layer,
+                  &acpi_dbg_layer, 0644);
+module_param_call(debug_level, param_set_uint, param_get_debug_level,
+                  &acpi_dbg_level, 0644);
+
+static char trace_method_name[6];
+module_param_string(trace_method_name, trace_method_name, 6, 0644);
+static unsigned int trace_debug_layer;
+module_param(trace_debug_layer, uint, 0644);
+static unsigned int trace_debug_level;
+module_param(trace_debug_level, uint, 0644);
+
+static int param_set_trace_state(const char *val, struct kernel_param *kp)
+{
+        int result = 0;
+
+        if (!strncmp(val, "enable", strlen("enable") - 1)) {
+                result = acpi_debug_trace(trace_method_name, trace_debug_level,
+                                          trace_debug_layer, 0);
+                if (result)
+                        result = -EBUSY;
+                goto exit;
+        }
+
+        if (!strncmp(val, "disable", strlen("disable") - 1)) {
+                int name = 0;
+                result = acpi_debug_trace((char *)&name, trace_debug_level,
+                                          trace_debug_layer, 0);
+                if (result)
+                        result = -EBUSY;
+                goto exit;
+        }
+
+        if (!strncmp(val, "1", 1)) {
+                result = acpi_debug_trace(trace_method_name, trace_debug_level,
+                                          trace_debug_layer, 1);
+                if (result)
+                        result = -EBUSY;
+                goto exit;
+        }
+
+        result = -EINVAL;
+exit:
+        return result;
+}
+
+static int param_get_trace_state(char *buffer, struct kernel_param *kp)
+{
+        if (!acpi_gbl_trace_method_name)
+                return sprintf(buffer, "disable");
+        else {
+                if (acpi_gbl_trace_flags & 1)
+                        return sprintf(buffer, "1");
+                else
+                        return sprintf(buffer, "enable");
+        }
+        return 0;
+}
+
+module_param_call(trace_state, param_set_trace_state, param_get_trace_state,
+                  NULL, 0644);
+#endif /* CONFIG_ACPI_DEBUG */
+
+/* /sys/module/acpi/parameters/acpica_version */
 static int param_get_acpica_version(char *buffer, struct kernel_param *kp)
 {
         int result;
@@ -57,9 +224,12 @@ static int param_get_acpica_version(char *buffer, struct kernel_param *kp)
 
 module_param_call(acpica_version, NULL, param_get_acpica_version, NULL, 0444);
 
-/* --------------------------------------------------------------------------
-                              FS Interface (/sys)
-   -------------------------------------------------------------------------- */
+/*
+ * ACPI table sysfs I/F:
+ * /sys/firmware/acpi/tables/
+ * /sys/firmware/acpi/tables/dynamic/
+ */
+
 static LIST_HEAD(acpi_table_attr_list);
 static struct kobject *tables_kobj;
 static struct kobject *dynamic_tables_kobj;
@@ -86,14 +256,12 @@ static ssize_t acpi_table_show(struct file *filp, struct kobject *kobj,
         else
                 memcpy(name, "\0\0\0\0", 4);
 
-        status =
-            acpi_get_table(name, table_attr->instance,
-                           &table_header);
+        status = acpi_get_table(name, table_attr->instance, &table_header);
         if (ACPI_FAILURE(status))
                 return -ENODEV;
 
         return memory_read_from_buffer(buf, count, &offset,
-                                        table_header, table_header->length);
+                                       table_header, table_header->length);
 }
 
 static void acpi_table_attr_init(struct acpi_table_attr *table_attr,
@@ -105,7 +273,7 @@ static void acpi_table_attr_init(struct acpi_table_attr *table_attr,
         sysfs_attr_init(&table_attr->attr.attr);
         if (table_header->signature[0] != '\0')
                 memcpy(table_attr->name, table_header->signature,
-                        ACPI_NAME_SIZE);
+                       ACPI_NAME_SIZE);
         else
                 memcpy(table_attr->name, "NULL", 4);
 
@@ -117,8 +285,8 @@ static void acpi_table_attr_init(struct acpi_table_attr *table_attr,
         table_attr->instance++;
 
         if (table_attr->instance > 1 || (table_attr->instance == 1 &&
-                                        !acpi_get_table
-                                        (table_header->signature, 2, &header)))
+                                         !acpi_get_table
+                                         (table_header->signature, 2, &header)))
                 sprintf(table_attr->name + ACPI_NAME_SIZE, "%d",
                         table_attr->instance);
 
@@ -138,18 +306,17 @@ acpi_sysfs_table_handler(u32 event, void *table, void *context)
         switch (event) {
         case ACPI_TABLE_EVENT_LOAD:
                 table_attr =
-                        kzalloc(sizeof(struct acpi_table_attr), GFP_KERNEL);
+                    kzalloc(sizeof(struct acpi_table_attr), GFP_KERNEL);
                 if (!table_attr)
                         return AE_NO_MEMORY;
 
                 acpi_table_attr_init(table_attr, table);
                 if (sysfs_create_bin_file(dynamic_tables_kobj,
-                                        &table_attr->attr)) {
+                                          &table_attr->attr)) {
                         kfree(table_attr);
                         return AE_ERROR;
                 } else
-                        list_add_tail(&table_attr->node,
-                                        &acpi_table_attr_list);
+                        list_add_tail(&table_attr->node, &acpi_table_attr_list);
                 break;
         case ACPI_TABLE_EVENT_UNLOAD:
                 /*
@@ -164,7 +331,7 @@ acpi_sysfs_table_handler(u32 event, void *table, void *context)
         return AE_OK;
 }
 
-static int acpi_system_sysfs_init(void)
+static int acpi_tables_sysfs_init(void)
 {
         struct acpi_table_attr *table_attr;
         struct acpi_table_header *table_header = NULL;
@@ -213,14 +380,17 @@ err:
 }
 
 /*
- * Detailed ACPI IRQ counters in /sys/firmware/acpi/interrupts/
- * See Documentation/ABI/testing/sysfs-firmware-acpi
+ * Detailed ACPI IRQ counters:
+ * /sys/firmware/acpi/interrupts/
  */
 
+u32 acpi_irq_handled;
+u32 acpi_irq_not_handled;
+
 #define COUNT_GPE 0
-#define COUNT_SCI 1     /* acpi_irq_handled */
-#define COUNT_SCI_NOT 2 /* acpi_irq_not_handled */
-#define COUNT_ERROR 3   /* other */
+#define COUNT_SCI 1             /* acpi_irq_handled */
+#define COUNT_SCI_NOT 2         /* acpi_irq_not_handled */
+#define COUNT_ERROR 3           /* other */
 #define NUM_COUNTERS_EXTRA 4
 
 struct event_counter {
@@ -237,6 +407,7 @@ static u32 acpi_gpe_count;
 static struct attribute_group interrupt_stats_attr_group = {
         .name = "interrupts",
 };
+
 static struct kobj_attribute *counter_attrs;
 
 static void delete_gpe_attr_array(void)
@@ -269,8 +440,8 @@ void acpi_os_gpe_count(u32 gpe_number)
         if (gpe_number < num_gpes)
                 all_counters[gpe_number].count++;
         else
-                all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_ERROR].
-                                        count++;
+                all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS +
+                             COUNT_ERROR].count++;
 
         return;
 }
@@ -283,13 +454,14 @@ void acpi_os_fixed_event_count(u32 event_number)
         if (event_number < ACPI_NUM_FIXED_EVENTS)
                 all_counters[num_gpes + event_number].count++;
         else
-                all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_ERROR].
-                                count++;
+                all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS +
+                             COUNT_ERROR].count++;
 
         return;
 }
 
-static int get_status(u32 index, acpi_event_status *status, acpi_handle *handle)
+static int get_status(u32 index, acpi_event_status *status,
+                      acpi_handle *handle)
 {
         int result = 0;
 
@@ -300,7 +472,7 @@ static int get_status(u32 index, acpi_event_status *status, acpi_handle *handle)
                 result = acpi_get_gpe_device(index, handle);
                 if (result) {
                         ACPI_EXCEPTION((AE_INFO, AE_NOT_FOUND,
-                                "Invalid GPE 0x%x\n", index));
+                                        "Invalid GPE 0x%x\n", index));
                         goto end;
                 }
                 result = acpi_get_gpe_status(*handle, index, status);
@@ -312,7 +484,7 @@ end:
 }
 
 static ssize_t counter_show(struct kobject *kobj,
-        struct kobj_attribute *attr, char *buf)
+                            struct kobj_attribute *attr, char *buf)
 {
         int index = attr - counter_attrs;
         int size;
@@ -321,12 +493,11 @@ static ssize_t counter_show(struct kobject *kobj,
         int result = 0;
 
         all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI].count =
-                acpi_irq_handled;
+            acpi_irq_handled;
         all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_SCI_NOT].count =
-                acpi_irq_not_handled;
+            acpi_irq_not_handled;
         all_counters[num_gpes + ACPI_NUM_FIXED_EVENTS + COUNT_GPE].count =
-                acpi_gpe_count;
-
+            acpi_gpe_count;
         size = sprintf(buf, "%8d", all_counters[index].count);
 
         /* "gpe_all" or "sci" */
@@ -338,13 +509,13 @@ static ssize_t counter_show(struct kobject *kobj,
                 goto end;
 
         if (!(status & ACPI_EVENT_FLAG_HANDLE))
-                size += sprintf(buf + size, "   invalid");
+                size += sprintf(buf + size, "   invalid");
         else if (status & ACPI_EVENT_FLAG_ENABLED)
-                size += sprintf(buf + size, "   enabled");
+                size += sprintf(buf + size, "   enabled");
         else if (status & ACPI_EVENT_FLAG_WAKE_ENABLED)
-                size += sprintf(buf + size, "   wake_enabled");
+                size += sprintf(buf + size, "   wake_enabled");
         else
-                size += sprintf(buf + size, "   disabled");
+                size += sprintf(buf + size, "   disabled");
 
 end:
         size += sprintf(buf + size, "\n");
@@ -357,7 +528,8 @@ end:
  * enable/disable/clear a gpe/fixed event in user space.
  */
 static ssize_t counter_set(struct kobject *kobj,
-        struct kobj_attribute *attr, const char *buf, size_t size)
+                           struct kobj_attribute *attr, const char *buf,
+                           size_t size)
 {
         int index = attr - counter_attrs;
         acpi_event_status status;
@@ -381,32 +553,32 @@ static ssize_t counter_set(struct kobject *kobj,
 
         if (!(status & ACPI_EVENT_FLAG_HANDLE)) {
                 printk(KERN_WARNING PREFIX
-                        "Can not change Invalid GPE/Fixed Event status\n");
+                       "Can not change Invalid GPE/Fixed Event status\n");
                 return -EINVAL;
         }
 
         if (index < num_gpes) {
                 if (!strcmp(buf, "disable\n") &&
-                                (status & ACPI_EVENT_FLAG_ENABLED))
+                    (status & ACPI_EVENT_FLAG_ENABLED))
                         result = acpi_disable_gpe(handle, index);
                 else if (!strcmp(buf, "enable\n") &&
-                                !(status & ACPI_EVENT_FLAG_ENABLED))
+                         !(status & ACPI_EVENT_FLAG_ENABLED))
                         result = acpi_enable_gpe(handle, index);
                 else if (!strcmp(buf, "clear\n") &&
-                                (status & ACPI_EVENT_FLAG_SET))
+                         (status & ACPI_EVENT_FLAG_SET))
                         result = acpi_clear_gpe(handle, index);
                 else
                         all_counters[index].count = strtoul(buf, NULL, 0);
         } else if (index < num_gpes + ACPI_NUM_FIXED_EVENTS) {
                 int event = index - num_gpes;
                 if (!strcmp(buf, "disable\n") &&
-                                (status & ACPI_EVENT_FLAG_ENABLED))
+                    (status & ACPI_EVENT_FLAG_ENABLED))
                         result = acpi_disable_event(event, ACPI_NOT_ISR);
                 else if (!strcmp(buf, "enable\n") &&
-                                !(status & ACPI_EVENT_FLAG_ENABLED))
+                         !(status & ACPI_EVENT_FLAG_ENABLED))
                         result = acpi_enable_event(event, ACPI_NOT_ISR);
                 else if (!strcmp(buf, "clear\n") &&
-                                (status & ACPI_EVENT_FLAG_SET))
+                         (status & ACPI_EVENT_FLAG_SET))
                         result = acpi_clear_event(event);
                 else
                         all_counters[index].count = strtoul(buf, NULL, 0);
@@ -430,17 +602,17 @@ void acpi_irq_stats_init(void)
         num_counters = num_gpes + ACPI_NUM_FIXED_EVENTS + NUM_COUNTERS_EXTRA;
 
         all_attrs = kzalloc(sizeof(struct attribute *) * (num_counters + 1),
-                        GFP_KERNEL);
+                            GFP_KERNEL);
         if (all_attrs == NULL)
                 return;
 
         all_counters = kzalloc(sizeof(struct event_counter) * (num_counters),
-                                GFP_KERNEL);
+                               GFP_KERNEL);
         if (all_counters == NULL)
                 goto fail;
 
         counter_attrs = kzalloc(sizeof(struct kobj_attribute) * (num_counters),
-                        GFP_KERNEL);
+                                GFP_KERNEL);
         if (counter_attrs == NULL)
                 goto fail;
 
@@ -503,135 +675,11 @@ static void __exit interrupt_stats_exit(void)
         return;
 }
 
-/* --------------------------------------------------------------------------
-                              FS Interface (/proc)
-   -------------------------------------------------------------------------- */
-#ifdef CONFIG_ACPI_PROCFS
-#define ACPI_SYSTEM_FILE_INFO           "info"
-#define ACPI_SYSTEM_FILE_EVENT          "event"
-#define ACPI_SYSTEM_FILE_DSDT           "dsdt"
-#define ACPI_SYSTEM_FILE_FADT           "fadt"
-
-static int acpi_system_read_info(struct seq_file *seq, void *offset)
-{
-
-        seq_printf(seq, "version:                 %x\n", ACPI_CA_VERSION);
-        return 0;
-}
-
-static int acpi_system_info_open_fs(struct inode *inode, struct file *file)
-{
-        return single_open(file, acpi_system_read_info, PDE(inode)->data);
-}
-
-static const struct file_operations acpi_system_info_ops = {
-        .owner = THIS_MODULE,
-        .open = acpi_system_info_open_fs,
-        .read = seq_read,
-        .llseek = seq_lseek,
-        .release = single_release,
-};
-
-static ssize_t acpi_system_read_dsdt(struct file *, char __user *, size_t,
-                                     loff_t *);
-
-static const struct file_operations acpi_system_dsdt_ops = {
-        .owner = THIS_MODULE,
-        .read = acpi_system_read_dsdt,
-};
-
-static ssize_t
-acpi_system_read_dsdt(struct file *file,
-                      char __user * buffer, size_t count, loff_t * ppos)
-{
-        acpi_status status = AE_OK;
-        struct acpi_table_header *dsdt = NULL;
-        ssize_t res;
-
-        status = acpi_get_table(ACPI_SIG_DSDT, 1, &dsdt);
-        if (ACPI_FAILURE(status))
-                return -ENODEV;
-
-        res = simple_read_from_buffer(buffer, count, ppos, dsdt, dsdt->length);
-
-        return res;
-}
-
-static ssize_t acpi_system_read_fadt(struct file *, char __user *, size_t,
-                                     loff_t *);
-
-static const struct file_operations acpi_system_fadt_ops = {
-        .owner = THIS_MODULE,
-        .read = acpi_system_read_fadt,
-};
-
-static ssize_t
-acpi_system_read_fadt(struct file *file,
-                      char __user * buffer, size_t count, loff_t * ppos)
-{
-        acpi_status status = AE_OK;
-        struct acpi_table_header *fadt = NULL;
-        ssize_t res;
-
-        status = acpi_get_table(ACPI_SIG_FADT, 1, &fadt);
-        if (ACPI_FAILURE(status))
-                return -ENODEV;
-
-        res = simple_read_from_buffer(buffer, count, ppos, fadt, fadt->length);
-
-        return res;
-}
-
-static int acpi_system_procfs_init(void)
-{
-        struct proc_dir_entry *entry;
-        int error = 0;
-
-        /* 'info' [R] */
-        entry = proc_create(ACPI_SYSTEM_FILE_INFO, S_IRUGO, acpi_root_dir,
-                            &acpi_system_info_ops);
-        if (!entry)
-                goto Error;
-
-        /* 'dsdt' [R] */
-        entry = proc_create(ACPI_SYSTEM_FILE_DSDT, S_IRUSR, acpi_root_dir,
-                            &acpi_system_dsdt_ops);
-        if (!entry)
-                goto Error;
-
-        /* 'fadt' [R] */
-        entry = proc_create(ACPI_SYSTEM_FILE_FADT, S_IRUSR, acpi_root_dir,
-                            &acpi_system_fadt_ops);
-        if (!entry)
-                goto Error;
-
-      Done:
-        return error;
-
-      Error:
-        remove_proc_entry(ACPI_SYSTEM_FILE_FADT, acpi_root_dir);
-        remove_proc_entry(ACPI_SYSTEM_FILE_DSDT, acpi_root_dir);
-        remove_proc_entry(ACPI_SYSTEM_FILE_INFO, acpi_root_dir);
-
-        error = -EFAULT;
-        goto Done;
-}
-#else
-static int acpi_system_procfs_init(void)
-{
-        return 0;
-}
-#endif
-
-int __init acpi_system_init(void)
+int __init acpi_sysfs_init(void)
 {
         int result;
 
-        result = acpi_system_procfs_init();
-        if (result)
-                return result;
-
-        result = acpi_system_sysfs_init();
+        result = acpi_tables_sysfs_init();
 
         return result;
 }
diff --git a/drivers/acpi/thermal.c b/drivers/acpi/thermal.c
index efad1f33aeb5..2f8f17131d9f 100644
--- a/drivers/acpi/thermal.c
+++ b/drivers/acpi/thermal.c
@@ -37,10 +37,14 @@
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/types.h>
+
+#ifdef CONFIG_ACPI_PROCFS
 #include <linux/proc_fs.h>
+#include <linux/seq_file.h>
+#endif
+
 #include <linux/jiffies.h>
 #include <linux/kmod.h>
-#include <linux/seq_file.h>
 #include <linux/reboot.h>
 #include <linux/device.h>
 #include <asm/uaccess.h>
@@ -102,16 +106,6 @@ static int acpi_thermal_add(struct acpi_device *device);
 static int acpi_thermal_remove(struct acpi_device *device, int type);
 static int acpi_thermal_resume(struct acpi_device *device);
 static void acpi_thermal_notify(struct acpi_device *device, u32 event);
-static int acpi_thermal_state_open_fs(struct inode *inode, struct file *file);
-static int acpi_thermal_temp_open_fs(struct inode *inode, struct file *file);
-static int acpi_thermal_trip_open_fs(struct inode *inode, struct file *file);
-static int acpi_thermal_cooling_open_fs(struct inode *inode, struct file *file);
-static ssize_t acpi_thermal_write_cooling_mode(struct file *,
-                                               const char __user *, size_t,
-                                               loff_t *);
-static int acpi_thermal_polling_open_fs(struct inode *inode, struct file *file);
-static ssize_t acpi_thermal_write_polling(struct file *, const char __user *,
-                                          size_t, loff_t *);
 
 static const struct acpi_device_id  thermal_device_ids[] = {
         {ACPI_THERMAL_HID, 0},
@@ -201,6 +195,18 @@ struct acpi_thermal {
         struct mutex lock;
 };
 
+#ifdef CONFIG_ACPI_PROCFS
+static int acpi_thermal_state_open_fs(struct inode *inode, struct file *file);
+static int acpi_thermal_temp_open_fs(struct inode *inode, struct file *file);
+static int acpi_thermal_trip_open_fs(struct inode *inode, struct file *file);
+static int acpi_thermal_cooling_open_fs(struct inode *inode, struct file *file);
+static ssize_t acpi_thermal_write_cooling_mode(struct file *,
+                                               const char __user *, size_t,
+                                               loff_t *);
+static int acpi_thermal_polling_open_fs(struct inode *inode, struct file *file);
+static ssize_t acpi_thermal_write_polling(struct file *, const char __user *,
+                                          size_t, loff_t *);
+
 static const struct file_operations acpi_thermal_state_fops = {
         .owner = THIS_MODULE,
         .open = acpi_thermal_state_open_fs,
@@ -242,6 +248,7 @@ static const struct file_operations acpi_thermal_polling_fops = {
         .llseek = seq_lseek,
         .release = single_release,
 };
+#endif /* CONFIG_ACPI_PROCFS*/
 
 /* --------------------------------------------------------------------------
                              Thermal Zone Management
@@ -287,26 +294,6 @@ static int acpi_thermal_get_polling_frequency(struct acpi_thermal *tz)
         return 0;
 }
 
-static int acpi_thermal_set_polling(struct acpi_thermal *tz, int seconds)
-{
-
-        if (!tz)
-                return -EINVAL;
-
-        tz->polling_frequency = seconds * 10;   /* Convert value to deci-seconds */
-
-        tz->thermal_zone->polling_delay = seconds * 1000;
-
-        if (tz->tz_enabled)
-                thermal_zone_device_update(tz->thermal_zone);
-
-        ACPI_DEBUG_PRINT((ACPI_DB_INFO,
-                          "Polling frequency set to %lu seconds\n",
-                          tz->polling_frequency/10));
-
-        return 0;
-}
-
 static int acpi_thermal_set_cooling_mode(struct acpi_thermal *tz, int mode)
 {
         acpi_status status = AE_OK;
@@ -973,7 +960,7 @@ static void acpi_thermal_unregister_thermal_zone(struct acpi_thermal *tz)
 /* --------------------------------------------------------------------------
                               FS Interface (/proc)
    -------------------------------------------------------------------------- */
-
+#ifdef CONFIG_ACPI_PROCFS
 static struct proc_dir_entry *acpi_thermal_dir;
 
 static int acpi_thermal_state_seq_show(struct seq_file *seq, void *offset)
@@ -1187,6 +1174,26 @@ static int acpi_thermal_polling_open_fs(struct inode *inode, struct file *file)
                            PDE(inode)->data);
 }
 
+static int acpi_thermal_set_polling(struct acpi_thermal *tz, int seconds)
+{
+        if (!tz)
+                return -EINVAL;
+
+        /* Convert value to deci-seconds */
+        tz->polling_frequency = seconds * 10;
+
+        tz->thermal_zone->polling_delay = seconds * 1000;
+
+        if (tz->tz_enabled)
+                thermal_zone_device_update(tz->thermal_zone);
+
+        ACPI_DEBUG_PRINT((ACPI_DB_INFO,
+                          "Polling frequency set to %lu seconds\n",
+                          tz->polling_frequency/10));
+
+        return 0;
+}
+
 static ssize_t
 acpi_thermal_write_polling(struct file *file,
                            const char __user * buffer,
@@ -1295,7 +1302,13 @@ static int acpi_thermal_remove_fs(struct acpi_device *device)
 
         return 0;
 }
-
+#else
+static inline int acpi_thermal_add_fs(struct acpi_device *device) { return 0; }
+static inline int acpi_thermal_remove_fs(struct acpi_device *device)
+{
+        return 0;
+}
+#endif /* CONFIG_ACPI_PROCFS */
 /* --------------------------------------------------------------------------
                                  Driver Interface
    -------------------------------------------------------------------------- */
@@ -1566,13 +1579,18 @@ static int __init acpi_thermal_init(void)
                 printk(KERN_NOTICE "ACPI: thermal control disabled\n");
                 return -ENODEV;
         }
+
+#ifdef CONFIG_ACPI_PROCFS
         acpi_thermal_dir = proc_mkdir(ACPI_THERMAL_CLASS, acpi_root_dir);
         if (!acpi_thermal_dir)
                 return -ENODEV;
+#endif
 
         result = acpi_bus_register_driver(&acpi_thermal_driver);
         if (result < 0) {
+#ifdef CONFIG_ACPI_PROCFS
                 remove_proc_entry(ACPI_THERMAL_CLASS, acpi_root_dir);
+#endif
                 return -ENODEV;
         }
 
@@ -1584,7 +1602,9 @@ static void __exit acpi_thermal_exit(void)
 
         acpi_bus_unregister_driver(&acpi_thermal_driver);
 
+#ifdef CONFIG_ACPI_PROCFS
         remove_proc_entry(ACPI_THERMAL_CLASS, acpi_root_dir);
+#endif
 
         return;
 }
diff --git a/drivers/acpi/video.c b/drivers/acpi/video.c
index 9865d46f49a8..67dec0c675aa 100644
--- a/drivers/acpi/video.c
+++ b/drivers/acpi/video.c
@@ -152,7 +152,9 @@ struct acpi_video_bus {
         struct acpi_video_bus_flags flags;
         struct list_head video_device_list;
         struct mutex device_list_lock;  /* protects video_device_list */
+#ifdef CONFIG_ACPI_PROCFS
         struct proc_dir_entry *dir;
+#endif
         struct input_dev *input;
         char phys[32];  /* for input device */
         struct notifier_block pm_nb;
@@ -208,6 +210,7 @@ struct acpi_video_device {
         struct output_device *output_dev;
 };
 
+#ifdef CONFIG_ACPI_PROCFS
 /* bus */
 static int acpi_video_bus_info_open_fs(struct inode *inode, struct file *file);
 static const struct file_operations acpi_video_bus_info_fops = {
@@ -307,6 +310,7 @@ static const struct file_operations acpi_video_device_EDID_fops = {
         .llseek = seq_lseek,
         .release = single_release,
 };
+#endif /* CONFIG_ACPI_PROCFS */
 
 static const char device_decode[][30] = {
         "motherboard VGA device",
@@ -450,16 +454,6 @@ static struct thermal_cooling_device_ops video_cooling_ops = {
 /* device */
 
 static int
-acpi_video_device_query(struct acpi_video_device *device, unsigned long long *state)
-{
-        int status;
-
-        status = acpi_evaluate_integer(device->dev->handle, "_DGS", NULL, state);
-
-        return status;
-}
-
-static int
 acpi_video_device_get_state(struct acpi_video_device *device,
                             unsigned long long *state)
 {
@@ -698,46 +692,6 @@ acpi_video_device_EDID(struct acpi_video_device *device,
 
 /* bus */
 
-static int
-acpi_video_bus_set_POST(struct acpi_video_bus *video, unsigned long option)
-{
-        int status;
-        unsigned long long tmp;
-        union acpi_object arg0 = { ACPI_TYPE_INTEGER };
-        struct acpi_object_list args = { 1, &arg0 };
-
-
-        arg0.integer.value = option;
-
-        status = acpi_evaluate_integer(video->device->handle, "_SPD", &args, &tmp);
-        if (ACPI_SUCCESS(status))
-                status = tmp ? (-EINVAL) : (AE_OK);
-
-        return status;
-}
-
-static int
-acpi_video_bus_get_POST(struct acpi_video_bus *video, unsigned long long *id)
-{
-        int status;
-
-        status = acpi_evaluate_integer(video->device->handle, "_GPD", NULL, id);
-
-        return status;
-}
-
-static int
-acpi_video_bus_POST_options(struct acpi_video_bus *video,
-                            unsigned long long *options)
-{
-        int status;
-
-        status = acpi_evaluate_integer(video->device->handle, "_VPO", NULL, options);
-        *options &= 3;
-
-        return status;
-}
-
 /*
  *  Arg:
  *      video           : video bus device pointer
@@ -1159,6 +1113,7 @@ static int acpi_video_bus_check(struct acpi_video_bus *video)
 /* --------------------------------------------------------------------------
                               FS Interface (/proc)
    -------------------------------------------------------------------------- */
+#ifdef CONFIG_ACPI_PROCFS
 
 static struct proc_dir_entry *acpi_video_dir;
 
@@ -1198,6 +1153,18 @@ acpi_video_device_info_open_fs(struct inode *inode, struct file *file)
                            PDE(inode)->data);
 }
 
+static int
+acpi_video_device_query(struct acpi_video_device *device,
+                        unsigned long long *state)
+{
+        int status;
+
+        status = acpi_evaluate_integer(device->dev->handle, "_DGS",
+                                       NULL, state);
+
+        return status;
+}
+
 static int acpi_video_device_state_seq_show(struct seq_file *seq, void *offset)
 {
         int status;
@@ -1492,6 +1459,19 @@ static int acpi_video_bus_ROM_open_fs(struct inode *inode, struct file *file)
         return single_open(file, acpi_video_bus_ROM_seq_show, PDE(inode)->data);
 }
 
+static int
+acpi_video_bus_POST_options(struct acpi_video_bus *video,
+                            unsigned long long *options)
+{
+        int status;
+
+        status = acpi_evaluate_integer(video->device->handle, "_VPO",
+                                       NULL, options);
+        *options &= 3;
+
+        return status;
+}
+
 static int acpi_video_bus_POST_info_seq_show(struct seq_file *seq, void *offset)
 {
         struct acpi_video_bus *video = seq->private;
@@ -1530,6 +1510,16 @@ acpi_video_bus_POST_info_open_fs(struct inode *inode, struct file *file)
                            PDE(inode)->data);
 }
 
+static int
+acpi_video_bus_get_POST(struct acpi_video_bus *video, unsigned long long *id)
+{
+        int status;
+
+        status = acpi_evaluate_integer(video->device->handle, "_GPD", NULL, id);
+
+        return status;
+}
+
 static int acpi_video_bus_POST_seq_show(struct seq_file *seq, void *offset)
 {
         struct acpi_video_bus *video = seq->private;
@@ -1572,6 +1562,25 @@ static int acpi_video_bus_DOS_open_fs(struct inode *inode, struct file *file)
         return single_open(file, acpi_video_bus_DOS_seq_show, PDE(inode)->data);
 }
 
+static int
+acpi_video_bus_set_POST(struct acpi_video_bus *video, unsigned long option)
+{
+        int status;
+        unsigned long long tmp;
+        union acpi_object arg0 = { ACPI_TYPE_INTEGER };
+        struct acpi_object_list args = { 1, &arg0 };
+
+
+        arg0.integer.value = option;
+
+        status = acpi_evaluate_integer(video->device->handle, "_SPD",
+                                       &args, &tmp);
+        if (ACPI_SUCCESS(status))
+                status = tmp ? (-EINVAL) : (AE_OK);
+
+        return status;
+}
+
 static ssize_t
 acpi_video_bus_write_POST(struct file *file,
                           const char __user * buffer,
@@ -1722,6 +1731,24 @@ static int acpi_video_bus_remove_fs(struct acpi_device *device)
 
         return 0;
 }
+#else
+static inline int acpi_video_device_add_fs(struct acpi_device *device)
+{
+        return 0;
+}
+static inline int acpi_video_device_remove_fs(struct acpi_device *device)
+{
+        return 0;
+}
+static inline int acpi_video_bus_add_fs(struct acpi_device *device)
+{
+        return 0;
+}
+static inline int acpi_video_bus_remove_fs(struct acpi_device *device)
+{
+        return 0;
+}
+#endif /* CONFIG_ACPI_PROCFS */
 
 /* --------------------------------------------------------------------------
                                  Driver Interface
@@ -2140,7 +2167,7 @@ acpi_video_bus_get_devices(struct acpi_video_bus *video,
                 status = acpi_video_bus_get_one_device(dev, video);
                 if (ACPI_FAILURE(status)) {
                         printk(KERN_WARNING PREFIX
-                                        "Cant attach device");
+                                        "Cant attach device\n");
                         continue;
                 }
         }
@@ -2150,19 +2177,19 @@ acpi_video_bus_get_devices(struct acpi_video_bus *video,
 static int acpi_video_bus_put_one_device(struct acpi_video_device *device)
 {
         acpi_status status;
-        struct acpi_video_bus *video;
-
 
         if (!device || !device->video)
                 return -ENOENT;
 
-        video = device->video;
-
         acpi_video_device_remove_fs(device->dev);
 
         status = acpi_remove_notify_handler(device->dev->handle,
                                             ACPI_DEVICE_NOTIFY,
                                             acpi_video_device_notify);
+        if (ACPI_FAILURE(status)) {
+                printk(KERN_WARNING PREFIX
+                       "Cant remove video notify handler\n");
+        }
         if (device->backlight) {
                 sysfs_remove_link(&device->backlight->dev.kobj, "device");
                 backlight_device_unregister(device->backlight);
@@ -2557,9 +2584,11 @@ int acpi_video_register(void)
                 return 0;
         }
 
+#ifdef CONFIG_ACPI_PROCFS
         acpi_video_dir = proc_mkdir(ACPI_VIDEO_CLASS, acpi_root_dir);
         if (!acpi_video_dir)
                 return -ENODEV;
+#endif
 
         result = acpi_bus_register_driver(&acpi_video_bus);
         if (result < 0) {
@@ -2588,7 +2617,9 @@ void acpi_video_unregister(void)
         }
         acpi_bus_unregister_driver(&acpi_video_bus);
 
+#ifdef CONFIG_ACPI_PROCFS
         remove_proc_entry(ACPI_VIDEO_CLASS, acpi_root_dir);
+#endif
 
         register_count = 0;
 
diff --git a/drivers/acpi/wakeup.c b/drivers/acpi/wakeup.c
index c80537bc3234..f62a50c3ed34 100644
--- a/drivers/acpi/wakeup.c
+++ b/drivers/acpi/wakeup.c
@@ -21,46 +21,18 @@
 ACPI_MODULE_NAME("wakeup_devices")
 
 /**
- * acpi_enable_wakeup_device_prep - Prepare wake-up devices.
+ * acpi_enable_wakeup_devices - Enable wake-up device GPEs.
  * @sleep_state: ACPI system sleep state.
  *
- * Enable all wake-up devices' power, unless the requested system sleep state is
- * too deep.
+ * Enable wakeup device power of devices with the state.enable flag set and set
+ * the wakeup enable mask bits in the GPE registers that correspond to wakeup
+ * devices.
  */
-void acpi_enable_wakeup_device_prep(u8 sleep_state)
+void acpi_enable_wakeup_devices(u8 sleep_state)
 {
         struct list_head *node, *next;
 
         list_for_each_safe(node, next, &acpi_wakeup_device_list) {
-                struct acpi_device *dev = container_of(node,
-                                                       struct acpi_device,
-                                                       wakeup_list);
-
-                if (!dev->wakeup.flags.valid || !dev->wakeup.state.enabled
-                    || (sleep_state > (u32) dev->wakeup.sleep_state))
-                        continue;
-
-                acpi_enable_wakeup_device_power(dev, sleep_state);
-        }
-}
-
-/**
- * acpi_enable_wakeup_device - Enable wake-up device GPEs.
- * @sleep_state: ACPI system sleep state.
- *
- * Enable all wake-up devices' GPEs, with the assumption that
- * acpi_disable_all_gpes() was executed before, so we don't need to disable any
- * GPEs here.
- */
-void acpi_enable_wakeup_device(u8 sleep_state)
-{
-        struct list_head *node, *next;
-
-        /* 
-         * Caution: this routine must be invoked when interrupt is disabled 
-         * Refer ACPI2.0: P212
-         */
-        list_for_each_safe(node, next, &acpi_wakeup_device_list) {
                 struct acpi_device *dev =
                         container_of(node, struct acpi_device, wakeup_list);
 
@@ -69,6 +41,9 @@ void acpi_enable_wakeup_device(u8 sleep_state)
                     || sleep_state > (u32) dev->wakeup.sleep_state)
                         continue;
 
+                if (dev->wakeup.state.enabled)
+                        acpi_enable_wakeup_device_power(dev, sleep_state);
+
                 /* The wake-up power should have been enabled already. */
                 acpi_gpe_wakeup(dev->wakeup.gpe_device, dev->wakeup.gpe_number,
                                 ACPI_GPE_ENABLE);
@@ -76,13 +51,10 @@ void acpi_enable_wakeup_device(u8 sleep_state)
 }
 
 /**
- * acpi_disable_wakeup_device - Disable devices' wakeup capability.
+ * acpi_disable_wakeup_devices - Disable devices' wakeup capability.
  * @sleep_state: ACPI system sleep state.
- *
- * This function only affects devices with wakeup.state.enabled set, which means
- * that it reverses the changes made by acpi_enable_wakeup_device_prep().
  */
-void acpi_disable_wakeup_device(u8 sleep_state)
+void acpi_disable_wakeup_devices(u8 sleep_state)
 {
         struct list_head *node, *next;
 
diff --git a/drivers/ata/libata-acpi.c b/drivers/ata/libata-acpi.c
index 7b5eea7e01dc..8b5ea399a4f4 100644
--- a/drivers/ata/libata-acpi.c
+++ b/drivers/ata/libata-acpi.c
@@ -145,12 +145,6 @@ static void ata_acpi_handle_hotplug(struct ata_port *ap, struct ata_device *dev,
         struct ata_eh_info *ehi = &ap->link.eh_info;
         int wait = 0;
         unsigned long flags;
-        acpi_handle handle;
-
-        if (dev)
-                handle = dev->acpi_handle;
-        else
-                handle = ap->acpi_handle;
 
         spin_lock_irqsave(ap->lock, flags);
         /*
diff --git a/drivers/firmware/Kconfig b/drivers/firmware/Kconfig
index d4ed8e98edf7..280c9b5ad9e3 100644
--- a/drivers/firmware/Kconfig
+++ b/drivers/firmware/Kconfig
@@ -122,14 +122,6 @@ config ISCSI_IBFT_FIND
           is necessary for iSCSI Boot Firmware Table Attributes module to work
           properly.
 
-config ISCSI_BOOT_SYSFS
-        tristate "iSCSI Boot Sysfs Interface"
-        default n
-        help
-          This option enables support for exposing iSCSI boot information
-          via sysfs to userspace. If you wish to export this information,
-          say Y. Otherwise, say N.
-
 config ISCSI_IBFT
         tristate "iSCSI Boot Firmware Table Attributes module"
         select ISCSI_BOOT_SYSFS
diff --git a/drivers/firmware/Makefile b/drivers/firmware/Makefile
index 5fe7e1662922..1c3c17343dbe 100644
--- a/drivers/firmware/Makefile
+++ b/drivers/firmware/Makefile
@@ -10,5 +10,4 @@ obj-$(CONFIG_DCDBAS)		+= dcdbas.o
 obj-$(CONFIG_DMIID)             += dmi-id.o
 obj-$(CONFIG_ISCSI_IBFT_FIND)   += iscsi_ibft_find.o
 obj-$(CONFIG_ISCSI_IBFT)        += iscsi_ibft.o
-obj-$(CONFIG_ISCSI_BOOT_SYSFS)  += iscsi_boot_sysfs.o
 obj-$(CONFIG_FIRMWARE_MEMMAP)   += memmap.o
diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
index f3adf18bfa05..0fba82943125 100644
--- a/drivers/hwmon/Kconfig
+++ b/drivers/hwmon/Kconfig
@@ -465,6 +465,7 @@ config SENSORS_JZ4740
 
 config SENSORS_JC42
         tristate "JEDEC JC42.4 compliant temperature sensors"
+        depends on I2C
         help
           If you say yes here you get support for Jedec JC42.4 compliant
           temperature sensors. Support will include, but not be limited to,
@@ -711,7 +712,8 @@ config SENSORS_PC87427
           functions of the National Semiconductor PC87427 Super-I/O chip.
           The chip has two distinct logical devices, one for fan speed
           monitoring and control, and one for voltage and temperature
-          monitoring. Only fan speed monitoring is supported right now.
+          monitoring. Fan speed monitoring and control are supported, as
+          well as temperature monitoring. Voltages aren't supported yet.
 
           This driver can also be built as a module.  If so, the module
           will be called pc87427.
@@ -804,6 +806,16 @@ config SENSORS_EMC1403
           Threshold values can be configured using sysfs.
           Data from the different diodes are accessible via sysfs.
 
+config SENSORS_EMC2103
+        tristate "SMSC EMC2103"
+        depends on I2C
+        help
+          If you say yes here you get support for the temperature
+          and fan sensors of the SMSC EMC2103 chips.
+
+          This driver can also be built as a module.  If so, the module
+          will be called emc2103.
+
 config SENSORS_SMSC47M1
         tristate "SMSC LPC47M10x and compatibles"
         help
diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
index 13d913e34dbf..e3c2484f6c5f 100644
--- a/drivers/hwmon/Makefile
+++ b/drivers/hwmon/Makefile
@@ -43,6 +43,7 @@ obj-$(CONFIG_SENSORS_PKGTEMP)	+= pkgtemp.o
 obj-$(CONFIG_SENSORS_DME1737)   += dme1737.o
 obj-$(CONFIG_SENSORS_DS1621)    += ds1621.o
 obj-$(CONFIG_SENSORS_EMC1403)   += emc1403.o
+obj-$(CONFIG_SENSORS_EMC2103)   += emc2103.o
 obj-$(CONFIG_SENSORS_F71805F)   += f71805f.o
 obj-$(CONFIG_SENSORS_F71882FG)  += f71882fg.o
 obj-$(CONFIG_SENSORS_F75375S)   += f75375s.o
diff --git a/drivers/hwmon/asc7621.c b/drivers/hwmon/asc7621.c
index 3b973f30b1f6..89b4f3babe87 100644
--- a/drivers/hwmon/asc7621.c
+++ b/drivers/hwmon/asc7621.c
@@ -1150,9 +1150,6 @@ static int asc7621_detect(struct i2c_client *client,
 {
         struct i2c_adapter *adapter = client->adapter;
         int company, verstep, chip_index;
-        struct device *dev;
-
-        dev = &client->dev;
 
         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                 return -ENODEV;
@@ -1169,13 +1166,11 @@ static int asc7621_detect(struct i2c_client *client,
 
                 if (company == asc7621_chips[chip_index].company_id &&
                     verstep == asc7621_chips[chip_index].verstep_id) {
-                        strlcpy(client->name, asc7621_chips[chip_index].name,
-                                I2C_NAME_SIZE);
                         strlcpy(info->type, asc7621_chips[chip_index].name,
                                 I2C_NAME_SIZE);
 
-                        dev_info(&adapter->dev, "Matched %s\n",
-                                 asc7621_chips[chip_index].name);
+                        dev_info(&adapter->dev, "Matched %s at 0x%02x\n",
+                                 asc7621_chips[chip_index].name, client->addr);
                         return 0;
                 }
         }
diff --git a/drivers/hwmon/emc1403.c b/drivers/hwmon/emc1403.c
index 0e4b5642638d..5b58b20dead1 100644
--- a/drivers/hwmon/emc1403.c
+++ b/drivers/hwmon/emc1403.c
@@ -89,6 +89,35 @@ static ssize_t store_temp(struct device *dev,
         return count;
 }
 
+static ssize_t store_bit(struct device *dev,
+                struct device_attribute *attr, const char *buf, size_t count)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct thermal_data *data = i2c_get_clientdata(client);
+        struct sensor_device_attribute_2 *sda = to_sensor_dev_attr_2(attr);
+        unsigned long val;
+        int retval;
+
+        if (strict_strtoul(buf, 10, &val))
+                return -EINVAL;
+
+        mutex_lock(&data->mutex);
+        retval = i2c_smbus_read_byte_data(client, sda->nr);
+        if (retval < 0)
+                goto fail;
+
+        retval &= ~sda->index;
+        if (val)
+                retval |= sda->index;
+
+        retval = i2c_smbus_write_byte_data(client, sda->index, retval);
+        if (retval == 0)
+                retval = count;
+fail:
+        mutex_unlock(&data->mutex);
+        return retval;
+}
+
 static ssize_t show_hyst(struct device *dev,
                         struct device_attribute *attr, char *buf)
 {
@@ -200,6 +229,9 @@ static SENSOR_DEVICE_ATTR_2(temp3_crit_alarm, S_IRUGO,
 static SENSOR_DEVICE_ATTR(temp3_crit_hyst, S_IRUGO | S_IWUSR,
         show_hyst, store_hyst, 0x1A);
 
+static SENSOR_DEVICE_ATTR_2(power_state, S_IRUGO | S_IWUSR,
+        show_bit, store_bit, 0x03, 0x40);
+
 static struct attribute *mid_att_thermal[] = {
         &sensor_dev_attr_temp1_min.dev_attr.attr,
         &sensor_dev_attr_temp1_max.dev_attr.attr,
@@ -225,6 +257,7 @@ static struct attribute *mid_att_thermal[] = {
         &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
         &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr,
         &sensor_dev_attr_temp3_crit_hyst.dev_attr.attr,
+        &sensor_dev_attr_power_state.dev_attr.attr,
         NULL
 };
 
diff --git a/drivers/hwmon/emc2103.c b/drivers/hwmon/emc2103.c
new file mode 100644
index 000000000000..af914ad93ece
--- /dev/null
+++ b/drivers/hwmon/emc2103.c
@@ -0,0 +1,740 @@
+/*
+    emc2103.c - Support for SMSC EMC2103
+    Copyright (c) 2010 SMSC
+
+    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 scanned */
+static const unsigned short normal_i2c[] = { 0x2E, I2C_CLIENT_END };
+
+static const u8 REG_TEMP[4] = { 0x00, 0x02, 0x04, 0x06 };
+static const u8 REG_TEMP_MIN[4] = { 0x3c, 0x38, 0x39, 0x3a };
+static const u8 REG_TEMP_MAX[4] = { 0x34, 0x30, 0x31, 0x32 };
+
+#define REG_CONF1               0x20
+#define REG_TEMP_MAX_ALARM      0x24
+#define REG_TEMP_MIN_ALARM      0x25
+#define REG_FAN_CONF1           0x42
+#define REG_FAN_TARGET_LO       0x4c
+#define REG_FAN_TARGET_HI       0x4d
+#define REG_FAN_TACH_HI         0x4e
+#define REG_FAN_TACH_LO         0x4f
+#define REG_PRODUCT_ID          0xfd
+#define REG_MFG_ID              0xfe
+
+/* equation 4 from datasheet: rpm = (3932160 * multipler) / count */
+#define FAN_RPM_FACTOR          3932160
+
+/* 2103-2 and 2103-4's 3rd temperature sensor can be connected to two diodes
+ * in anti-parallel mode, and in this configuration both can be read
+ * independently (so we have 4 temperature inputs).  The device can't
+ * detect if it's connected in this mode, so we have to manually enable
+ * it.  Default is to leave the device in the state it's already in (-1).
+ * This parameter allows APD mode to be optionally forced on or off */
+static int apd = -1;
+module_param(apd, bool, 0);
+MODULE_PARM_DESC(init, "Set to zero to disable anti-parallel diode mode");
+
+struct temperature {
+        s8      degrees;
+        u8      fraction;       /* 0-7 multiples of 0.125 */
+};
+
+struct emc2103_data {
+        struct device           *hwmon_dev;
+        struct mutex            update_lock;
+        bool                    valid;          /* registers are valid */
+        bool                    fan_rpm_control;
+        int                     temp_count;     /* num of temp sensors */
+        unsigned long           last_updated;   /* in jiffies */
+        struct temperature      temp[4];        /* internal + 3 external */
+        s8                      temp_min[4];    /* no fractional part */
+        s8                      temp_max[4];    /* no fractional part */
+        u8                      temp_min_alarm;
+        u8                      temp_max_alarm;
+        u8                      fan_multiplier;
+        u16                     fan_tach;
+        u16                     fan_target;
+};
+
+static int read_u8_from_i2c(struct i2c_client *client, u8 i2c_reg, u8 *output)
+{
+        int status = i2c_smbus_read_byte_data(client, i2c_reg);
+        if (status < 0) {
+                dev_warn(&client->dev, "reg 0x%02x, err %d\n",
+                        i2c_reg, status);
+        } else {
+                *output = status;
+        }
+        return status;
+}
+
+static void read_temp_from_i2c(struct i2c_client *client, u8 i2c_reg,
+                               struct temperature *temp)
+{
+        u8 degrees, fractional;
+
+        if (read_u8_from_i2c(client, i2c_reg, &degrees) < 0)
+                return;
+
+        if (read_u8_from_i2c(client, i2c_reg + 1, &fractional) < 0)
+                return;
+
+        temp->degrees = degrees;
+        temp->fraction = (fractional & 0xe0) >> 5;
+}
+
+static void read_fan_from_i2c(struct i2c_client *client, u16 *output,
+                              u8 hi_addr, u8 lo_addr)
+{
+        u8 high_byte, lo_byte;
+
+        if (read_u8_from_i2c(client, hi_addr, &high_byte) < 0)
+                return;
+
+        if (read_u8_from_i2c(client, lo_addr, &lo_byte) < 0)
+                return;
+
+        *output = ((u16)high_byte << 5) | (lo_byte >> 3);
+}
+
+static void write_fan_target_to_i2c(struct i2c_client *client, u16 new_target)
+{
+        u8 high_byte = (new_target & 0x1fe0) >> 5;
+        u8 low_byte = (new_target & 0x001f) << 3;
+        i2c_smbus_write_byte_data(client, REG_FAN_TARGET_LO, low_byte);
+        i2c_smbus_write_byte_data(client, REG_FAN_TARGET_HI, high_byte);
+}
+
+static void read_fan_config_from_i2c(struct i2c_client *client)
+
+{
+        struct emc2103_data *data = i2c_get_clientdata(client);
+        u8 conf1;
+
+        if (read_u8_from_i2c(client, REG_FAN_CONF1, &conf1) < 0)
+                return;
+
+        data->fan_multiplier = 1 << ((conf1 & 0x60) >> 5);
+        data->fan_rpm_control = (conf1 & 0x80) != 0;
+}
+
+static struct emc2103_data *emc2103_update_device(struct device *dev)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct emc2103_data *data = i2c_get_clientdata(client);
+
+        mutex_lock(&data->update_lock);
+
+        if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
+            || !data->valid) {
+                int i;
+
+                for (i = 0; i < data->temp_count; i++) {
+                        read_temp_from_i2c(client, REG_TEMP[i], &data->temp[i]);
+                        read_u8_from_i2c(client, REG_TEMP_MIN[i],
+                                &data->temp_min[i]);
+                        read_u8_from_i2c(client, REG_TEMP_MAX[i],
+                                &data->temp_max[i]);
+                }
+
+                read_u8_from_i2c(client, REG_TEMP_MIN_ALARM,
+                        &data->temp_min_alarm);
+                read_u8_from_i2c(client, REG_TEMP_MAX_ALARM,
+                        &data->temp_max_alarm);
+
+                read_fan_from_i2c(client, &data->fan_tach,
+                        REG_FAN_TACH_HI, REG_FAN_TACH_LO);
+                read_fan_from_i2c(client, &data->fan_target,
+                        REG_FAN_TARGET_HI, REG_FAN_TARGET_LO);
+                read_fan_config_from_i2c(client);
+
+                data->last_updated = jiffies;
+                data->valid = true;
+        }
+
+        mutex_unlock(&data->update_lock);
+
+        return data;
+}
+
+static ssize_t
+show_temp(struct device *dev, struct device_attribute *da, char *buf)
+{
+        int nr = to_sensor_dev_attr(da)->index;
+        struct emc2103_data *data = emc2103_update_device(dev);
+        int millidegrees = data->temp[nr].degrees * 1000
+                + data->temp[nr].fraction * 125;
+        return sprintf(buf, "%d\n", millidegrees);
+}
+
+static ssize_t
+show_temp_min(struct device *dev, struct device_attribute *da, char *buf)
+{
+        int nr = to_sensor_dev_attr(da)->index;
+        struct emc2103_data *data = emc2103_update_device(dev);
+        int millidegrees = data->temp_min[nr] * 1000;
+        return sprintf(buf, "%d\n", millidegrees);
+}
+
+static ssize_t
+show_temp_max(struct device *dev, struct device_attribute *da, char *buf)
+{
+        int nr = to_sensor_dev_attr(da)->index;
+        struct emc2103_data *data = emc2103_update_device(dev);
+        int millidegrees = data->temp_max[nr] * 1000;
+        return sprintf(buf, "%d\n", millidegrees);
+}
+
+static ssize_t
+show_temp_fault(struct device *dev, struct device_attribute *da, char *buf)
+{
+        int nr = to_sensor_dev_attr(da)->index;
+        struct emc2103_data *data = emc2103_update_device(dev);
+        bool fault = (data->temp[nr].degrees == -128);
+        return sprintf(buf, "%d\n", fault ? 1 : 0);
+}
+
+static ssize_t
+show_temp_min_alarm(struct device *dev, struct device_attribute *da, char *buf)
+{
+        int nr = to_sensor_dev_attr(da)->index;
+        struct emc2103_data *data = emc2103_update_device(dev);
+        bool alarm = data->temp_min_alarm & (1 << nr);
+        return sprintf(buf, "%d\n", alarm ? 1 : 0);
+}
+
+static ssize_t
+show_temp_max_alarm(struct device *dev, struct device_attribute *da, char *buf)
+{
+        int nr = to_sensor_dev_attr(da)->index;
+        struct emc2103_data *data = emc2103_update_device(dev);
+        bool alarm = data->temp_max_alarm & (1 << nr);
+        return sprintf(buf, "%d\n", alarm ? 1 : 0);
+}
+
+static ssize_t set_temp_min(struct device *dev, struct device_attribute *da,
+                            const char *buf, size_t count)
+{
+        int nr = to_sensor_dev_attr(da)->index;
+        struct i2c_client *client = to_i2c_client(dev);
+        struct emc2103_data *data = i2c_get_clientdata(client);
+        long val;
+
+        int result = strict_strtol(buf, 10, &val);
+        if (result < 0)
+                return -EINVAL;
+
+        val = DIV_ROUND_CLOSEST(val, 1000);
+        if ((val < -63) || (val > 127))
+                return -EINVAL;
+
+        mutex_lock(&data->update_lock);
+        data->temp_min[nr] = val;
+        i2c_smbus_write_byte_data(client, REG_TEMP_MIN[nr], val);
+        mutex_unlock(&data->update_lock);
+
+        return count;
+}
+
+static ssize_t set_temp_max(struct device *dev, struct device_attribute *da,
+                            const char *buf, size_t count)
+{
+        int nr = to_sensor_dev_attr(da)->index;
+        struct i2c_client *client = to_i2c_client(dev);
+        struct emc2103_data *data = i2c_get_clientdata(client);
+        long val;
+
+        int result = strict_strtol(buf, 10, &val);
+        if (result < 0)
+                return -EINVAL;
+
+        val = DIV_ROUND_CLOSEST(val, 1000);
+        if ((val < -63) || (val > 127))
+                return -EINVAL;
+
+        mutex_lock(&data->update_lock);
+        data->temp_max[nr] = val;
+        i2c_smbus_write_byte_data(client, REG_TEMP_MAX[nr], val);
+        mutex_unlock(&data->update_lock);
+
+        return count;
+}
+
+static ssize_t
+show_fan(struct device *dev, struct device_attribute *da, char *buf)
+{
+        struct emc2103_data *data = emc2103_update_device(dev);
+        int rpm = 0;
+        if (data->fan_tach != 0)
+                rpm = (FAN_RPM_FACTOR * data->fan_multiplier) / data->fan_tach;
+        return sprintf(buf, "%d\n", rpm);
+}
+
+static ssize_t
+show_fan_div(struct device *dev, struct device_attribute *da, char *buf)
+{
+        struct emc2103_data *data = emc2103_update_device(dev);
+        int fan_div = 8 / data->fan_multiplier;
+        return sprintf(buf, "%d\n", fan_div);
+}
+
+/* Note: we also update the fan target here, because its value is
+   determined in part by the fan clock divider.  This follows the principle
+   of least surprise; the user doesn't expect the fan target to change just
+   because the divider changed. */
+static ssize_t set_fan_div(struct device *dev, struct device_attribute *da,
+                           const char *buf, size_t count)
+{
+        struct emc2103_data *data = emc2103_update_device(dev);
+        struct i2c_client *client = to_i2c_client(dev);
+        int new_range_bits, old_div = 8 / data->fan_multiplier;
+        long new_div;
+
+        int status = strict_strtol(buf, 10, &new_div);
+        if (status < 0)
+                return -EINVAL;
+
+        if (new_div == old_div) /* No change */
+                return count;
+
+        switch (new_div) {
+        case 1:
+                new_range_bits = 3;
+                break;
+        case 2:
+                new_range_bits = 2;
+                break;
+        case 4:
+                new_range_bits = 1;
+                break;
+        case 8:
+                new_range_bits = 0;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        mutex_lock(&data->update_lock);
+
+        status = i2c_smbus_read_byte_data(client, REG_FAN_CONF1);
+        if (status < 0) {
+                dev_dbg(&client->dev, "reg 0x%02x, err %d\n",
+                        REG_FAN_CONF1, status);
+                mutex_unlock(&data->update_lock);
+                return -EIO;
+        }
+        status &= 0x9F;
+        status |= (new_range_bits << 5);
+        i2c_smbus_write_byte_data(client, REG_FAN_CONF1, status);
+
+        data->fan_multiplier = 8 / new_div;
+
+        /* update fan target if high byte is not disabled */
+        if ((data->fan_target & 0x1fe0) != 0x1fe0) {
+                u16 new_target = (data->fan_target * old_div) / new_div;
+                data->fan_target = min(new_target, (u16)0x1fff);
+                write_fan_target_to_i2c(client, data->fan_target);
+        }
+
+        /* invalidate data to force re-read from hardware */
+        data->valid = false;
+
+        mutex_unlock(&data->update_lock);
+        return count;
+}
+
+static ssize_t
+show_fan_target(struct device *dev, struct device_attribute *da, char *buf)
+{
+        struct emc2103_data *data = emc2103_update_device(dev);
+        int rpm = 0;
+
+        /* high byte of 0xff indicates disabled so return 0 */
+        if ((data->fan_target != 0) && ((data->fan_target & 0x1fe0) != 0x1fe0))
+                rpm = (FAN_RPM_FACTOR * data->fan_multiplier)
+                        / data->fan_target;
+
+        return sprintf(buf, "%d\n", rpm);
+}
+
+static ssize_t set_fan_target(struct device *dev, struct device_attribute *da,
+                              const char *buf, size_t count)
+{
+        struct emc2103_data *data = emc2103_update_device(dev);
+        struct i2c_client *client = to_i2c_client(dev);
+        long rpm_target;
+
+        int result = strict_strtol(buf, 10, &rpm_target);
+        if (result < 0)
+                return -EINVAL;
+
+        /* Datasheet states 16384 as maximum RPM target (table 3.2) */
+        if ((rpm_target < 0) || (rpm_target > 16384))
+                return -EINVAL;
+
+        mutex_lock(&data->update_lock);
+
+        if (rpm_target == 0)
+                data->fan_target = 0x1fff;
+        else
+                data->fan_target = SENSORS_LIMIT(
+                        (FAN_RPM_FACTOR * data->fan_multiplier) / rpm_target,
+                        0, 0x1fff);
+
+        write_fan_target_to_i2c(client, data->fan_target);
+
+        mutex_unlock(&data->update_lock);
+        return count;
+}
+
+static ssize_t
+show_fan_fault(struct device *dev, struct device_attribute *da, char *buf)
+{
+        struct emc2103_data *data = emc2103_update_device(dev);
+        bool fault = ((data->fan_tach & 0x1fe0) == 0x1fe0);
+        return sprintf(buf, "%d\n", fault ? 1 : 0);
+}
+
+static ssize_t
+show_pwm_enable(struct device *dev, struct device_attribute *da, char *buf)
+{
+        struct emc2103_data *data = emc2103_update_device(dev);
+        return sprintf(buf, "%d\n", data->fan_rpm_control ? 3 : 0);
+}
+
+static ssize_t set_pwm_enable(struct device *dev, struct device_attribute *da,
+                              const char *buf, size_t count)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct emc2103_data *data = i2c_get_clientdata(client);
+        long new_value;
+        u8 conf_reg;
+
+        int result = strict_strtol(buf, 10, &new_value);
+        if (result < 0)
+                return -EINVAL;
+
+        mutex_lock(&data->update_lock);
+        switch (new_value) {
+        case 0:
+                data->fan_rpm_control = false;
+                break;
+        case 3:
+                data->fan_rpm_control = true;
+                break;
+        default:
+                mutex_unlock(&data->update_lock);
+                return -EINVAL;
+        }
+
+        read_u8_from_i2c(client, REG_FAN_CONF1, &conf_reg);
+
+        if (data->fan_rpm_control)
+                conf_reg |= 0x80;
+        else
+                conf_reg &= ~0x80;
+
+        i2c_smbus_write_byte_data(client, REG_FAN_CONF1, conf_reg);
+
+        mutex_unlock(&data->update_lock);
+        return count;
+}
+
+static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
+static SENSOR_DEVICE_ATTR(temp1_min, S_IRUGO | S_IWUSR, show_temp_min,
+        set_temp_min, 0);
+static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR, show_temp_max,
+        set_temp_max, 0);
+static SENSOR_DEVICE_ATTR(temp1_fault, S_IRUGO, show_temp_fault, NULL, 0);
+static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_temp_min_alarm,
+        NULL, 0);
+static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_temp_max_alarm,
+        NULL, 0);
+
+static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1);
+static SENSOR_DEVICE_ATTR(temp2_min, S_IRUGO | S_IWUSR, show_temp_min,
+        set_temp_min, 1);
+static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO | S_IWUSR, show_temp_max,
+        set_temp_max, 1);
+static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_temp_fault, NULL, 1);
+static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_temp_min_alarm,
+        NULL, 1);
+static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_temp_max_alarm,
+        NULL, 1);
+
+static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2);
+static SENSOR_DEVICE_ATTR(temp3_min, S_IRUGO | S_IWUSR, show_temp_min,
+        set_temp_min, 2);
+static SENSOR_DEVICE_ATTR(temp3_max, S_IRUGO | S_IWUSR, show_temp_max,
+        set_temp_max, 2);
+static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_temp_fault, NULL, 2);
+static SENSOR_DEVICE_ATTR(temp3_min_alarm, S_IRUGO, show_temp_min_alarm,
+        NULL, 2);
+static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO, show_temp_max_alarm,
+        NULL, 2);
+
+static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, show_temp, NULL, 3);
+static SENSOR_DEVICE_ATTR(temp4_min, S_IRUGO | S_IWUSR, show_temp_min,
+        set_temp_min, 3);
+static SENSOR_DEVICE_ATTR(temp4_max, S_IRUGO | S_IWUSR, show_temp_max,
+        set_temp_max, 3);
+static SENSOR_DEVICE_ATTR(temp4_fault, S_IRUGO, show_temp_fault, NULL, 3);
+static SENSOR_DEVICE_ATTR(temp4_min_alarm, S_IRUGO, show_temp_min_alarm,
+        NULL, 3);
+static SENSOR_DEVICE_ATTR(temp4_max_alarm, S_IRUGO, show_temp_max_alarm,
+        NULL, 3);
+
+static DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL);
+static DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR, show_fan_div, set_fan_div);
+static DEVICE_ATTR(fan1_target, S_IRUGO | S_IWUSR, show_fan_target,
+        set_fan_target);
+static DEVICE_ATTR(fan1_fault, S_IRUGO, show_fan_fault, NULL);
+
+static DEVICE_ATTR(pwm1_enable, S_IRUGO | S_IWUSR, show_pwm_enable,
+        set_pwm_enable);
+
+/* sensors present on all models */
+static struct attribute *emc2103_attributes[] = {
+        &sensor_dev_attr_temp1_input.dev_attr.attr,
+        &sensor_dev_attr_temp1_min.dev_attr.attr,
+        &sensor_dev_attr_temp1_max.dev_attr.attr,
+        &sensor_dev_attr_temp1_fault.dev_attr.attr,
+        &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp2_input.dev_attr.attr,
+        &sensor_dev_attr_temp2_min.dev_attr.attr,
+        &sensor_dev_attr_temp2_max.dev_attr.attr,
+        &sensor_dev_attr_temp2_fault.dev_attr.attr,
+        &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
+        &dev_attr_fan1_input.attr,
+        &dev_attr_fan1_div.attr,
+        &dev_attr_fan1_target.attr,
+        &dev_attr_fan1_fault.attr,
+        &dev_attr_pwm1_enable.attr,
+        NULL
+};
+
+/* extra temperature sensors only present on 2103-2 and 2103-4 */
+static struct attribute *emc2103_attributes_temp3[] = {
+        &sensor_dev_attr_temp3_input.dev_attr.attr,
+        &sensor_dev_attr_temp3_min.dev_attr.attr,
+        &sensor_dev_attr_temp3_max.dev_attr.attr,
+        &sensor_dev_attr_temp3_fault.dev_attr.attr,
+        &sensor_dev_attr_temp3_min_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
+        NULL
+};
+
+/* extra temperature sensors only present on 2103-2 and 2103-4 in APD mode */
+static struct attribute *emc2103_attributes_temp4[] = {
+        &sensor_dev_attr_temp4_input.dev_attr.attr,
+        &sensor_dev_attr_temp4_min.dev_attr.attr,
+        &sensor_dev_attr_temp4_max.dev_attr.attr,
+        &sensor_dev_attr_temp4_fault.dev_attr.attr,
+        &sensor_dev_attr_temp4_min_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp4_max_alarm.dev_attr.attr,
+        NULL
+};
+
+static const struct attribute_group emc2103_group = {
+        .attrs = emc2103_attributes,
+};
+
+static const struct attribute_group emc2103_temp3_group = {
+        .attrs = emc2103_attributes_temp3,
+};
+
+static const struct attribute_group emc2103_temp4_group = {
+        .attrs = emc2103_attributes_temp4,
+};
+
+static int
+emc2103_probe(struct i2c_client *client, const struct i2c_device_id *id)
+{
+        struct emc2103_data *data;
+        int status;
+
+        if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
+                return -EIO;
+
+        data = kzalloc(sizeof(struct emc2103_data), GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+
+        i2c_set_clientdata(client, data);
+        mutex_init(&data->update_lock);
+
+        /* 2103-2 and 2103-4 have 3 external diodes, 2103-1 has 1 */
+        status = i2c_smbus_read_byte_data(client, REG_PRODUCT_ID);
+        if (status == 0x24) {
+                /* 2103-1 only has 1 external diode */
+                data->temp_count = 2;
+        } else {
+                /* 2103-2 and 2103-4 have 3 or 4 external diodes */
+                status = i2c_smbus_read_byte_data(client, REG_CONF1);
+                if (status < 0) {
+                        dev_dbg(&client->dev, "reg 0x%02x, err %d\n", REG_CONF1,
+                                status);
+                        goto exit_free;
+                }
+
+                /* detect current state of hardware */
+                data->temp_count = (status & 0x01) ? 4 : 3;
+
+                /* force APD state if module parameter is set */
+                if (apd == 0) {
+                        /* force APD mode off */
+                        data->temp_count = 3;
+                        status &= ~(0x01);
+                        i2c_smbus_write_byte_data(client, REG_CONF1, status);
+                } else if (apd == 1) {
+                        /* force APD mode on */
+                        data->temp_count = 4;
+                        status |= 0x01;
+                        i2c_smbus_write_byte_data(client, REG_CONF1, status);
+                }
+        }
+
+        /* Register sysfs hooks */
+        status = sysfs_create_group(&client->dev.kobj, &emc2103_group);
+        if (status)
+                goto exit_free;
+
+        if (data->temp_count >= 3) {
+                status = sysfs_create_group(&client->dev.kobj,
+                        &emc2103_temp3_group);
+                if (status)
+                        goto exit_remove;
+        }
+
+        if (data->temp_count == 4) {
+                status = sysfs_create_group(&client->dev.kobj,
+                        &emc2103_temp4_group);
+                if (status)
+                        goto exit_remove_temp3;
+        }
+
+        data->hwmon_dev = hwmon_device_register(&client->dev);
+        if (IS_ERR(data->hwmon_dev)) {
+                status = PTR_ERR(data->hwmon_dev);
+                goto exit_remove_temp4;
+        }
+
+        dev_info(&client->dev, "%s: sensor '%s'\n",
+                 dev_name(data->hwmon_dev), client->name);
+
+        return 0;
+
+exit_remove_temp4:
+        if (data->temp_count == 4)
+                sysfs_remove_group(&client->dev.kobj, &emc2103_temp4_group);
+exit_remove_temp3:
+        if (data->temp_count >= 3)
+                sysfs_remove_group(&client->dev.kobj, &emc2103_temp3_group);
+exit_remove:
+        sysfs_remove_group(&client->dev.kobj, &emc2103_group);
+exit_free:
+        kfree(data);
+        return status;
+}
+
+static int emc2103_remove(struct i2c_client *client)
+{
+        struct emc2103_data *data = i2c_get_clientdata(client);
+
+        hwmon_device_unregister(data->hwmon_dev);
+
+        if (data->temp_count == 4)
+                sysfs_remove_group(&client->dev.kobj, &emc2103_temp4_group);
+
+        if (data->temp_count >= 3)
+                sysfs_remove_group(&client->dev.kobj, &emc2103_temp3_group);
+
+        sysfs_remove_group(&client->dev.kobj, &emc2103_group);
+
+        kfree(data);
+        return 0;
+}
+
+static const struct i2c_device_id emc2103_ids[] = {
+        { "emc2103", 0, },
+        { /* LIST END */ }
+};
+MODULE_DEVICE_TABLE(i2c, emc2103_ids);
+
+/* Return 0 if detection is successful, -ENODEV otherwise */
+static int
+emc2103_detect(struct i2c_client *new_client, struct i2c_board_info *info)
+{
+        struct i2c_adapter *adapter = new_client->adapter;
+        int manufacturer, product;
+
+        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
+                return -ENODEV;
+
+        manufacturer = i2c_smbus_read_byte_data(new_client, REG_MFG_ID);
+        if (manufacturer != 0x5D)
+                return -ENODEV;
+
+        product = i2c_smbus_read_byte_data(new_client, REG_PRODUCT_ID);
+        if ((product != 0x24) && (product != 0x26))
+                return -ENODEV;
+
+        strlcpy(info->type, "emc2103", I2C_NAME_SIZE);
+
+        return 0;
+}
+
+static struct i2c_driver emc2103_driver = {
+        .class          = I2C_CLASS_HWMON,
+        .driver = {
+                .name   = "emc2103",
+        },
+        .probe          = emc2103_probe,
+        .remove         = emc2103_remove,
+        .id_table       = emc2103_ids,
+        .detect         = emc2103_detect,
+        .address_list   = normal_i2c,
+};
+
+static int __init sensors_emc2103_init(void)
+{
+        return i2c_add_driver(&emc2103_driver);
+}
+
+static void __exit sensors_emc2103_exit(void)
+{
+        i2c_del_driver(&emc2103_driver);
+}
+
+MODULE_AUTHOR("Steve Glendinning <steve.glendinning@smsc.com>");
+MODULE_DESCRIPTION("SMSC EMC2103 hwmon driver");
+MODULE_LICENSE("GPL");
+
+module_init(sensors_emc2103_init);
+module_exit(sensors_emc2103_exit);
diff --git a/drivers/hwmon/it87.c b/drivers/hwmon/it87.c
index 25763d2223b6..f7701295937d 100644
--- a/drivers/hwmon/it87.c
+++ b/drivers/hwmon/it87.c
@@ -259,6 +259,7 @@ struct it87_sio_data {
         u8 revision;
         u8 vid_value;
         u8 beep_pin;
+        u8 internal;    /* Internal sensors can be labeled */
         /* Features skipped based on config or DMI */
         u8 skip_vid;
         u8 skip_fan;
@@ -1194,6 +1195,22 @@ static ssize_t show_vid_reg(struct device *dev, struct device_attribute *attr,
 }
 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
 
+static ssize_t show_label(struct device *dev, struct device_attribute *attr,
+                char *buf)
+{
+        static const char *labels[] = {
+                "+5V",
+                "5VSB",
+                "Vbat",
+        };
+        int nr = to_sensor_dev_attr(attr)->index;
+
+        return sprintf(buf, "%s\n", labels[nr]);
+}
+static SENSOR_DEVICE_ATTR(in3_label, S_IRUGO, show_label, NULL, 0);
+static SENSOR_DEVICE_ATTR(in7_label, S_IRUGO, show_label, NULL, 1);
+static SENSOR_DEVICE_ATTR(in8_label, S_IRUGO, show_label, NULL, 2);
+
 static ssize_t show_name(struct device *dev, struct device_attribute
                          *devattr, char *buf)
 {
@@ -1434,6 +1451,17 @@ static const struct attribute_group it87_group_vid = {
         .attrs = it87_attributes_vid,
 };
 
+static struct attribute *it87_attributes_label[] = {
+        &sensor_dev_attr_in3_label.dev_attr.attr,
+        &sensor_dev_attr_in7_label.dev_attr.attr,
+        &sensor_dev_attr_in8_label.dev_attr.attr,
+        NULL
+};
+
+static const struct attribute_group it87_group_label = {
+        .attrs = it87_attributes_vid,
+};
+
 /* SuperIO detection - will change isa_address if a chip is found */
 static int __init it87_find(unsigned short *address,
         struct it87_sio_data *sio_data)
@@ -1487,6 +1515,9 @@ static int __init it87_find(unsigned short *address,
         pr_info("it87: Found IT%04xF chip at 0x%x, revision %d\n",
                 chip_type, *address, sio_data->revision);
 
+        /* in8 (Vbat) is always internal */
+        sio_data->internal = (1 << 2);
+
         /* Read GPIO config and VID value from LDN 7 (GPIO) */
         if (sio_data->type == it87) {
                 /* The IT8705F doesn't have VID pins at all */
@@ -1540,9 +1571,9 @@ static int __init it87_find(unsigned short *address,
                         pr_notice("it87: Routing internal VCCH to in7\n");
                 }
                 if (reg & (1 << 0))
-                        pr_info("it87: in3 is VCC (+5V)\n");
+                        sio_data->internal |= (1 << 0);
                 if (reg & (1 << 1))
-                        pr_info("it87: in7 is VCCH (+5V Stand-By)\n");
+                        sio_data->internal |= (1 << 1);
 
                 sio_data->beep_pin = superio_inb(IT87_SIO_BEEP_PIN_REG) & 0x3f;
         }
@@ -1600,6 +1631,7 @@ static void it87_remove_files(struct device *dev)
         }
         if (!sio_data->skip_vid)
                 sysfs_remove_group(&dev->kobj, &it87_group_vid);
+        sysfs_remove_group(&dev->kobj, &it87_group_label);
 }
 
 static int __devinit it87_probe(struct platform_device *pdev)
@@ -1725,6 +1757,16 @@ static int __devinit it87_probe(struct platform_device *pdev)
                         goto ERROR4;
         }
 
+        /* Export labels for internal sensors */
+        for (i = 0; i < 3; i++) {
+                if (!(sio_data->internal & (1 << i)))
+                        continue;
+                err = sysfs_create_file(&dev->kobj,
+                                        it87_attributes_label[i]);
+                if (err)
+                        goto ERROR4;
+        }
+
         data->hwmon_dev = hwmon_device_register(dev);
         if (IS_ERR(data->hwmon_dev)) {
                 err = PTR_ERR(data->hwmon_dev);
diff --git a/drivers/hwmon/k8temp.c b/drivers/hwmon/k8temp.c
index 8bdf80d91598..b9bb3e0ca530 100644
--- a/drivers/hwmon/k8temp.c
+++ b/drivers/hwmon/k8temp.c
@@ -252,12 +252,13 @@ static int __devinit k8temp_probe(struct pci_dev *pdev,
                                    &sensor_dev_attr_temp3_input.dev_attr);
                 if (err)
                         goto exit_remove;
-                if (data->sensorsp & SEL_PLACE)
+                if (data->sensorsp & SEL_PLACE) {
                         err = device_create_file(&pdev->dev,
                                            &sensor_dev_attr_temp4_input.
                                            dev_attr);
                         if (err)
                                 goto exit_remove;
+                }
         }
 
         err = device_create_file(&pdev->dev, &dev_attr_name);
diff --git a/drivers/hwmon/lm75.c b/drivers/hwmon/lm75.c
index 393f354f92a4..ab5b87a81677 100644
--- a/drivers/hwmon/lm75.c
+++ b/drivers/hwmon/lm75.c
@@ -280,10 +280,49 @@ static int lm75_detect(struct i2c_client *new_client,
         return 0;
 }
 
+#ifdef CONFIG_PM
+static int lm75_suspend(struct device *dev)
+{
+        int status;
+        struct i2c_client *client = to_i2c_client(dev);
+        status = lm75_read_value(client, LM75_REG_CONF);
+        if (status < 0) {
+                dev_dbg(&client->dev, "Can't read config? %d\n", status);
+                return status;
+        }
+        status = status | LM75_SHUTDOWN;
+        lm75_write_value(client, LM75_REG_CONF, status);
+        return 0;
+}
+
+static int lm75_resume(struct device *dev)
+{
+        int status;
+        struct i2c_client *client = to_i2c_client(dev);
+        status = lm75_read_value(client, LM75_REG_CONF);
+        if (status < 0) {
+                dev_dbg(&client->dev, "Can't read config? %d\n", status);
+                return status;
+        }
+        status = status & ~LM75_SHUTDOWN;
+        lm75_write_value(client, LM75_REG_CONF, status);
+        return 0;
+}
+
+static const struct dev_pm_ops lm75_dev_pm_ops = {
+        .suspend        = lm75_suspend,
+        .resume         = lm75_resume,
+};
+#define LM75_DEV_PM_OPS (&lm75_dev_pm_ops)
+#else
+#define LM75_DEV_PM_OPS NULL
+#endif /* CONFIG_PM */
+
 static struct i2c_driver lm75_driver = {
         .class          = I2C_CLASS_HWMON,
         .driver = {
                 .name   = "lm75",
+                .pm     = LM75_DEV_PM_OPS,
         },
         .probe          = lm75_probe,
         .remove         = lm75_remove,
diff --git a/drivers/hwmon/lm75.h b/drivers/hwmon/lm75.h
index 7c93454bb4e3..e547a3eb4de3 100644
--- a/drivers/hwmon/lm75.h
+++ b/drivers/hwmon/lm75.h
@@ -30,6 +30,7 @@
 /* straight from the datasheet */
 #define LM75_TEMP_MIN (-55000)
 #define LM75_TEMP_MAX 125000
+#define LM75_SHUTDOWN 0x01
 
 /* TEMP: 0.001C/bit (-55C to +125C)
    REG: (0.5C/bit, two's complement) << 7 */
diff --git a/drivers/hwmon/ltc4245.c b/drivers/hwmon/ltc4245.c
index 21d201befc2c..659308329308 100644
--- a/drivers/hwmon/ltc4245.c
+++ b/drivers/hwmon/ltc4245.c
@@ -21,6 +21,7 @@
 #include <linux/i2c.h>
 #include <linux/hwmon.h>
 #include <linux/hwmon-sysfs.h>
+#include <linux/i2c/ltc4245.h>
 
 /* Here are names of the chip's registers (a.k.a. commands) */
 enum ltc4245_cmd {
@@ -60,8 +61,72 @@ struct ltc4245_data {
 
         /* Voltage registers */
         u8 vregs[0x0d];
+
+        /* GPIO ADC registers */
+        bool use_extra_gpios;
+        int gpios[3];
 };
 
+/*
+ * Update the readings from the GPIO pins. If the driver has been configured to
+ * sample all GPIO's as analog voltages, a round-robin sampling method is used.
+ * Otherwise, only the configured GPIO pin is sampled.
+ *
+ * LOCKING: must hold data->update_lock
+ */
+static void ltc4245_update_gpios(struct device *dev)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct ltc4245_data *data = i2c_get_clientdata(client);
+        u8 gpio_curr, gpio_next, gpio_reg;
+        int i;
+
+        /* no extra gpio support, we're basically done */
+        if (!data->use_extra_gpios) {
+                data->gpios[0] = data->vregs[LTC4245_GPIOADC - 0x10];
+                return;
+        }
+
+        /*
+         * If the last reading was too long ago, then we mark all old GPIO
+         * readings as stale by setting them to -EAGAIN
+         */
+        if (time_after(jiffies, data->last_updated + 5 * HZ)) {
+                dev_dbg(&client->dev, "Marking GPIOs invalid\n");
+                for (i = 0; i < ARRAY_SIZE(data->gpios); i++)
+                        data->gpios[i] = -EAGAIN;
+        }
+
+        /*
+         * Get the current GPIO pin
+         *
+         * The datasheet calls these GPIO[1-3], but we'll calculate the zero
+         * based array index instead, and call them GPIO[0-2]. This is much
+         * easier to think about.
+         */
+        gpio_curr = (data->cregs[LTC4245_GPIO] & 0xc0) >> 6;
+        if (gpio_curr > 0)
+                gpio_curr -= 1;
+
+        /* Read the GPIO voltage from the GPIOADC register */
+        data->gpios[gpio_curr] = data->vregs[LTC4245_GPIOADC - 0x10];
+
+        /* Find the next GPIO pin to read */
+        gpio_next = (gpio_curr + 1) % ARRAY_SIZE(data->gpios);
+
+        /*
+         * Calculate the correct setting for the GPIO register so it will
+         * sample the next GPIO pin
+         */
+        gpio_reg = (data->cregs[LTC4245_GPIO] & 0x3f) | ((gpio_next + 1) << 6);
+
+        /* Update the GPIO register */
+        i2c_smbus_write_byte_data(client, LTC4245_GPIO, gpio_reg);
+
+        /* Update saved data */
+        data->cregs[LTC4245_GPIO] = gpio_reg;
+}
+
 static struct ltc4245_data *ltc4245_update_device(struct device *dev)
 {
         struct i2c_client *client = to_i2c_client(dev);
@@ -93,6 +158,9 @@ static struct ltc4245_data *ltc4245_update_device(struct device *dev)
                                 data->vregs[i] = val;
                 }
 
+                /* Update GPIO readings */
+                ltc4245_update_gpios(dev);
+
                 data->last_updated = jiffies;
                 data->valid = 1;
         }
@@ -233,6 +301,22 @@ static ssize_t ltc4245_show_alarm(struct device *dev,
         return snprintf(buf, PAGE_SIZE, "%u\n", (reg & mask) ? 1 : 0);
 }
 
+static ssize_t ltc4245_show_gpio(struct device *dev,
+                                 struct device_attribute *da,
+                                 char *buf)
+{
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+        struct ltc4245_data *data = ltc4245_update_device(dev);
+        int val = data->gpios[attr->index];
+
+        /* handle stale GPIO's */
+        if (val < 0)
+                return val;
+
+        /* Convert to millivolts and print */
+        return snprintf(buf, PAGE_SIZE, "%u\n", val * 10);
+}
+
 /* These macros are used below in constructing device attribute objects
  * for use with sysfs_create_group() to make a sysfs device file
  * for each register.
@@ -254,6 +338,10 @@ static ssize_t ltc4245_show_alarm(struct device *dev,
         static SENSOR_DEVICE_ATTR_2(name, S_IRUGO, \
         ltc4245_show_alarm, NULL, (mask), reg)
 
+#define LTC4245_GPIO_VOLTAGE(name, gpio_num) \
+        static SENSOR_DEVICE_ATTR(name, S_IRUGO, \
+        ltc4245_show_gpio, NULL, gpio_num)
+
 /* Construct a sensor_device_attribute structure for each register */
 
 /* Input voltages */
@@ -293,7 +381,9 @@ LTC4245_ALARM(in7_min_alarm,	(1 << 2),	LTC4245_FAULT2);
 LTC4245_ALARM(in8_min_alarm,    (1 << 3),       LTC4245_FAULT2);
 
 /* GPIO voltages */
-LTC4245_VOLTAGE(in9_input,                      LTC4245_GPIOADC);
+LTC4245_GPIO_VOLTAGE(in9_input,                 0);
+LTC4245_GPIO_VOLTAGE(in10_input,                1);
+LTC4245_GPIO_VOLTAGE(in11_input,                2);
 
 /* Power Consumption (virtual) */
 LTC4245_POWER(power1_input,                     LTC4245_12VSENSE);
@@ -304,7 +394,7 @@ LTC4245_POWER(power4_input,			LTC4245_VEESENSE);
 /* Finally, construct an array of pointers to members of the above objects,
  * as required for sysfs_create_group()
  */
-static struct attribute *ltc4245_attributes[] = {
+static struct attribute *ltc4245_std_attributes[] = {
         &sensor_dev_attr_in1_input.dev_attr.attr,
         &sensor_dev_attr_in2_input.dev_attr.attr,
         &sensor_dev_attr_in3_input.dev_attr.attr,
@@ -345,10 +435,77 @@ static struct attribute *ltc4245_attributes[] = {
         NULL,
 };
 
-static const struct attribute_group ltc4245_group = {
-        .attrs = ltc4245_attributes,
+static struct attribute *ltc4245_gpio_attributes[] = {
+        &sensor_dev_attr_in10_input.dev_attr.attr,
+        &sensor_dev_attr_in11_input.dev_attr.attr,
+        NULL,
+};
+
+static const struct attribute_group ltc4245_std_group = {
+        .attrs = ltc4245_std_attributes,
+};
+
+static const struct attribute_group ltc4245_gpio_group = {
+        .attrs = ltc4245_gpio_attributes,
 };
 
+static int ltc4245_sysfs_create_groups(struct i2c_client *client)
+{
+        struct ltc4245_data *data = i2c_get_clientdata(client);
+        struct device *dev = &client->dev;
+        int ret;
+
+        /* register the standard sysfs attributes */
+        ret = sysfs_create_group(&dev->kobj, &ltc4245_std_group);
+        if (ret) {
+                dev_err(dev, "unable to register standard attributes\n");
+                return ret;
+        }
+
+        /* if we're using the extra gpio support, register it's attributes */
+        if (data->use_extra_gpios) {
+                ret = sysfs_create_group(&dev->kobj, &ltc4245_gpio_group);
+                if (ret) {
+                        dev_err(dev, "unable to register gpio attributes\n");
+                        sysfs_remove_group(&dev->kobj, &ltc4245_std_group);
+                        return ret;
+                }
+        }
+
+        return 0;
+}
+
+static void ltc4245_sysfs_remove_groups(struct i2c_client *client)
+{
+        struct ltc4245_data *data = i2c_get_clientdata(client);
+        struct device *dev = &client->dev;
+
+        if (data->use_extra_gpios)
+                sysfs_remove_group(&dev->kobj, &ltc4245_gpio_group);
+
+        sysfs_remove_group(&dev->kobj, &ltc4245_std_group);
+}
+
+static bool ltc4245_use_extra_gpios(struct i2c_client *client)
+{
+        struct ltc4245_platform_data *pdata = dev_get_platdata(&client->dev);
+#ifdef CONFIG_OF
+        struct device_node *np = client->dev.of_node;
+#endif
+
+        /* prefer platform data */
+        if (pdata)
+                return pdata->use_extra_gpios;
+
+#ifdef CONFIG_OF
+        /* fallback on OF */
+        if (of_find_property(np, "ltc4245,use-extra-gpios", NULL))
+                return true;
+#endif
+
+        return false;
+}
+
 static int ltc4245_probe(struct i2c_client *client,
                          const struct i2c_device_id *id)
 {
@@ -367,15 +524,16 @@ static int ltc4245_probe(struct i2c_client *client,
 
         i2c_set_clientdata(client, data);
         mutex_init(&data->update_lock);
+        data->use_extra_gpios = ltc4245_use_extra_gpios(client);
 
         /* Initialize the LTC4245 chip */
         i2c_smbus_write_byte_data(client, LTC4245_FAULT1, 0x00);
         i2c_smbus_write_byte_data(client, LTC4245_FAULT2, 0x00);
 
         /* Register sysfs hooks */
-        ret = sysfs_create_group(&client->dev.kobj, &ltc4245_group);
+        ret = ltc4245_sysfs_create_groups(client);
         if (ret)
-                goto out_sysfs_create_group;
+                goto out_sysfs_create_groups;
 
         data->hwmon_dev = hwmon_device_register(&client->dev);
         if (IS_ERR(data->hwmon_dev)) {
@@ -386,8 +544,8 @@ static int ltc4245_probe(struct i2c_client *client,
         return 0;
 
 out_hwmon_device_register:
-        sysfs_remove_group(&client->dev.kobj, &ltc4245_group);
-out_sysfs_create_group:
+        ltc4245_sysfs_remove_groups(client);
+out_sysfs_create_groups:
         kfree(data);
 out_kzalloc:
         return ret;
@@ -398,8 +556,7 @@ static int ltc4245_remove(struct i2c_client *client)
         struct ltc4245_data *data = i2c_get_clientdata(client);
 
         hwmon_device_unregister(data->hwmon_dev);
-        sysfs_remove_group(&client->dev.kobj, &ltc4245_group);
-
+        ltc4245_sysfs_remove_groups(client);
         kfree(data);
 
         return 0;
diff --git a/drivers/hwmon/pc87360.c b/drivers/hwmon/pc87360.c
index 4a64b85d4ec9..68e69a49633c 100644
--- a/drivers/hwmon/pc87360.c
+++ b/drivers/hwmon/pc87360.c
@@ -1610,11 +1610,8 @@ static struct pc87360_data *pc87360_update_device(struct device *dev)
 
 static int __init pc87360_device_add(unsigned short address)
 {
-        struct resource res = {
-                .name   = "pc87360",
-                .flags  = IORESOURCE_IO,
-        };
-        int err, i;
+        struct resource res[3];
+        int err, i, res_count;
 
         pdev = platform_device_alloc("pc87360", address);
         if (!pdev) {
@@ -1623,22 +1620,28 @@ static int __init pc87360_device_add(unsigned short address)
                 goto exit;
         }
 
+        memset(res, 0, 3 * sizeof(struct resource));
+        res_count = 0;
         for (i = 0; i < 3; i++) {
                 if (!extra_isa[i])
                         continue;
-                res.start = extra_isa[i];
-                res.end = extra_isa[i] + PC87360_EXTENT - 1;
+                res[res_count].start = extra_isa[i];
+                res[res_count].end = extra_isa[i] + PC87360_EXTENT - 1;
+                res[res_count].name = "pc87360",
+                res[res_count].flags = IORESOURCE_IO,
 
-                err = acpi_check_resource_conflict(&res);
+                err = acpi_check_resource_conflict(&res[res_count]);
                 if (err)
                         goto exit_device_put;
 
-                err = platform_device_add_resources(pdev, &res, 1);
-                if (err) {
-                        printk(KERN_ERR "pc87360: Device resource[%d] "
-                               "addition failed (%d)\n", i, err);
-                        goto exit_device_put;
-                }
+                res_count++;
+        }
+
+        err = platform_device_add_resources(pdev, res, res_count);
+        if (err) {
+                printk(KERN_ERR "pc87360: Device resources addition failed "
+                       "(%d)\n", err);
+                goto exit_device_put;
         }
 
         err = platform_device_add(pdev);
diff --git a/drivers/hwmon/pc87427.c b/drivers/hwmon/pc87427.c
index 3170b26d2443..9ec4daaf6ca6 100644
--- a/drivers/hwmon/pc87427.c
+++ b/drivers/hwmon/pc87427.c
@@ -1,7 +1,7 @@
 /*
  *  pc87427.c - hardware monitoring driver for the
  *              National Semiconductor PC87427 Super-I/O chip
- *  Copyright (C) 2006 Jean Delvare <khali@linux-fr.org>
+ *  Copyright (C) 2006, 2008, 2010  Jean Delvare <khali@linux-fr.org>
  *
  *  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
@@ -15,10 +15,11 @@
  *  Supports the following chips:
  *
  *  Chip        #vin    #fan    #pwm    #temp   devid
- *  PC87427     -       8       -       -       0xF2
+ *  PC87427     -       8       4       6       0xF2
  *
  *  This driver assumes that no more than one chip is present.
- *  Only fan inputs are supported so far, although the chip can do much more.
+ *  Only fans are fully supported so far. Temperatures are in read-only
+ *  mode, and voltages aren't supported at all.
  */
 
 #include <linux/module.h>
@@ -57,6 +58,25 @@ struct pc87427_data {
         u16 fan[8];                     /* register values */
         u16 fan_min[8];                 /* register values */
         u8 fan_status[8];               /* register values */
+
+        u8 pwm_enabled;                 /* bit vector */
+        u8 pwm_auto_ok;                 /* bit vector */
+        u8 pwm_enable[4];               /* register values */
+        u8 pwm[4];                      /* register values */
+
+        u8 temp_enabled;                /* bit vector */
+        s16 temp[6];                    /* register values */
+        s8 temp_min[6];                 /* register values */
+        s8 temp_max[6];                 /* register values */
+        s8 temp_crit[6];                /* register values */
+        u8 temp_status[6];              /* register values */
+        u8 temp_type[6];                /* register values */
+};
+
+struct pc87427_sio_data {
+        unsigned short address[2];
+        u8 has_fanin;
+        u8 has_fanout;
 };
 
 /*
@@ -65,6 +85,13 @@ struct pc87427_data {
 
 #define SIOREG_LDSEL    0x07    /* Logical device select */
 #define SIOREG_DEVID    0x20    /* Device ID */
+#define SIOREG_CF2      0x22    /* Configuration 2 */
+#define SIOREG_CF3      0x23    /* Configuration 3 */
+#define SIOREG_CF4      0x24    /* Configuration 4 */
+#define SIOREG_CF5      0x25    /* Configuration 5 */
+#define SIOREG_CFB      0x2B    /* Configuration B */
+#define SIOREG_CFC      0x2C    /* Configuration C */
+#define SIOREG_CFD      0x2D    /* Configuration D */
 #define SIOREG_ACT      0x30    /* Device activation */
 #define SIOREG_MAP      0x50    /* I/O or memory mapping */
 #define SIOREG_IOBASE   0x60    /* I/O base address */
@@ -102,6 +129,8 @@ static inline void superio_exit(int sioaddr)
 #define BANK_FM(nr)             (nr)
 #define BANK_FT(nr)             (0x08 + (nr))
 #define BANK_FC(nr)             (0x10 + (nr) * 2)
+#define BANK_TM(nr)             (nr)
+#define BANK_VM(nr)             (0x08 + (nr))
 
 /*
  * I/O access functions
@@ -179,6 +208,127 @@ static inline u16 fan_to_reg(unsigned long val)
 }
 
 /*
+ * PWM registers and conversions
+ */
+
+#define PC87427_REG_PWM_ENABLE          0x10
+#define PC87427_REG_PWM_DUTY            0x12
+
+#define PWM_ENABLE_MODE_MASK            (7 << 4)
+#define PWM_ENABLE_CTLEN                (1 << 0)
+
+#define PWM_MODE_MANUAL                 (0 << 4)
+#define PWM_MODE_AUTO                   (1 << 4)
+#define PWM_MODE_OFF                    (2 << 4)
+#define PWM_MODE_ON                     (7 << 4)
+
+/* Dedicated function to read all registers related to a given PWM output.
+   This saves us quite a few locks and bank selections.
+   Must be called with data->lock held.
+   nr is from 0 to 3 */
+static void pc87427_readall_pwm(struct pc87427_data *data, u8 nr)
+{
+        int iobase = data->address[LD_FAN];
+
+        outb(BANK_FC(nr), iobase + PC87427_REG_BANK);
+        data->pwm_enable[nr] = inb(iobase + PC87427_REG_PWM_ENABLE);
+        data->pwm[nr] = inb(iobase + PC87427_REG_PWM_DUTY);
+}
+
+static inline int pwm_enable_from_reg(u8 reg)
+{
+        switch (reg & PWM_ENABLE_MODE_MASK) {
+        case PWM_MODE_ON:
+                return 0;
+        case PWM_MODE_MANUAL:
+        case PWM_MODE_OFF:
+                return 1;
+        case PWM_MODE_AUTO:
+                return 2;
+        default:
+                return -EPROTO;
+        }
+}
+
+static inline u8 pwm_enable_to_reg(unsigned long val, u8 pwmval)
+{
+        switch (val) {
+        default:
+                return PWM_MODE_ON;
+        case 1:
+                return pwmval ? PWM_MODE_MANUAL : PWM_MODE_OFF;
+        case 2:
+                return PWM_MODE_AUTO;
+        }
+}
+
+/*
+ * Temperature registers and conversions
+ */
+
+#define PC87427_REG_TEMP_STATUS         0x10
+#define PC87427_REG_TEMP                0x14
+#define PC87427_REG_TEMP_MAX            0x18
+#define PC87427_REG_TEMP_MIN            0x19
+#define PC87427_REG_TEMP_CRIT           0x1a
+#define PC87427_REG_TEMP_TYPE           0x1d
+
+#define TEMP_STATUS_CHANEN              (1 << 0)
+#define TEMP_STATUS_LOWFLG              (1 << 1)
+#define TEMP_STATUS_HIGHFLG             (1 << 2)
+#define TEMP_STATUS_CRITFLG             (1 << 3)
+#define TEMP_STATUS_SENSERR             (1 << 5)
+#define TEMP_TYPE_MASK                  (3 << 5)
+
+#define TEMP_TYPE_THERMISTOR            (1 << 5)
+#define TEMP_TYPE_REMOTE_DIODE          (2 << 5)
+#define TEMP_TYPE_LOCAL_DIODE           (3 << 5)
+
+/* Dedicated function to read all registers related to a given temperature
+   input. This saves us quite a few locks and bank selections.
+   Must be called with data->lock held.
+   nr is from 0 to 5 */
+static void pc87427_readall_temp(struct pc87427_data *data, u8 nr)
+{
+        int iobase = data->address[LD_TEMP];
+
+        outb(BANK_TM(nr), iobase + PC87427_REG_BANK);
+        data->temp[nr] = le16_to_cpu(inw(iobase + PC87427_REG_TEMP));
+        data->temp_max[nr] = inb(iobase + PC87427_REG_TEMP_MAX);
+        data->temp_min[nr] = inb(iobase + PC87427_REG_TEMP_MIN);
+        data->temp_crit[nr] = inb(iobase + PC87427_REG_TEMP_CRIT);
+        data->temp_type[nr] = inb(iobase + PC87427_REG_TEMP_TYPE);
+        data->temp_status[nr] = inb(iobase + PC87427_REG_TEMP_STATUS);
+        /* Clear fan alarm bits */
+        outb(data->temp_status[nr], iobase + PC87427_REG_TEMP_STATUS);
+}
+
+static inline unsigned int temp_type_from_reg(u8 reg)
+{
+        switch (reg & TEMP_TYPE_MASK) {
+        case TEMP_TYPE_THERMISTOR:
+                return 4;
+        case TEMP_TYPE_REMOTE_DIODE:
+        case TEMP_TYPE_LOCAL_DIODE:
+                return 3;
+        default:
+                return 0;
+        }
+}
+
+/* We assume 8-bit thermal sensors; 9-bit thermal sensors are possible
+   too, but I have no idea how to figure out when they are used. */
+static inline long temp_from_reg(s16 reg)
+{
+        return reg * 1000 / 256;
+}
+
+static inline long temp_from_reg8(s8 reg)
+{
+        return reg * 1000;
+}
+
+/*
  * Data interface
  */
 
@@ -198,6 +348,21 @@ static struct pc87427_data *pc87427_update_device(struct device *dev)
                         continue;
                 pc87427_readall_fan(data, i);
         }
+
+        /* PWM outputs */
+        for (i = 0; i < 4; i++) {
+                if (!(data->pwm_enabled & (1 << i)))
+                        continue;
+                pc87427_readall_pwm(data, i);
+        }
+
+        /* Temperature channels */
+        for (i = 0; i < 6; i++) {
+                if (!(data->temp_enabled & (1 << i)))
+                        continue;
+                pc87427_readall_temp(data, i);
+        }
+
         data->last_updated = jiffies;
 
 done:
@@ -208,9 +373,8 @@ done:
 static ssize_t show_fan_input(struct device *dev, struct device_attribute
                               *devattr, char *buf)
 {
-        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
         struct pc87427_data *data = pc87427_update_device(dev);
-        int nr = attr->index;
+        int nr = to_sensor_dev_attr(devattr)->index;
 
         return sprintf(buf, "%lu\n", fan_from_reg(data->fan[nr]));
 }
@@ -218,9 +382,8 @@ static ssize_t show_fan_input(struct device *dev, struct device_attribute
 static ssize_t show_fan_min(struct device *dev, struct device_attribute
                             *devattr, char *buf)
 {
-        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
         struct pc87427_data *data = pc87427_update_device(dev);
-        int nr = attr->index;
+        int nr = to_sensor_dev_attr(devattr)->index;
 
         return sprintf(buf, "%lu\n", fan_from_reg(data->fan_min[nr]));
 }
@@ -228,9 +391,8 @@ static ssize_t show_fan_min(struct device *dev, struct device_attribute
 static ssize_t show_fan_alarm(struct device *dev, struct device_attribute
                               *devattr, char *buf)
 {
-        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
         struct pc87427_data *data = pc87427_update_device(dev);
-        int nr = attr->index;
+        int nr = to_sensor_dev_attr(devattr)->index;
 
         return sprintf(buf, "%d\n", !!(data->fan_status[nr]
                                        & FAN_STATUS_LOSPD));
@@ -239,9 +401,8 @@ static ssize_t show_fan_alarm(struct device *dev, struct device_attribute
 static ssize_t show_fan_fault(struct device *dev, struct device_attribute
                               *devattr, char *buf)
 {
-        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
         struct pc87427_data *data = pc87427_update_device(dev);
-        int nr = attr->index;
+        int nr = to_sensor_dev_attr(devattr)->index;
 
         return sprintf(buf, "%d\n", !!(data->fan_status[nr]
                                        & FAN_STATUS_STALL));
@@ -251,11 +412,13 @@ static ssize_t set_fan_min(struct device *dev, struct device_attribute
                            *devattr, const char *buf, size_t count)
 {
         struct pc87427_data *data = dev_get_drvdata(dev);
-        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
-        int nr = attr->index;
-        unsigned long val = simple_strtoul(buf, NULL, 10);
+        int nr = to_sensor_dev_attr(devattr)->index;
+        unsigned long val;
         int iobase = data->address[LD_FAN];
 
+        if (strict_strtoul(buf, 10, &val) < 0)
+                return -EINVAL;
+
         mutex_lock(&data->lock);
         outb(BANK_FM(nr), iobase + PC87427_REG_BANK);
         /* The low speed limit registers are read-only while monitoring
@@ -377,6 +540,390 @@ static const struct attribute_group pc87427_group_fan[8] = {
         { .attrs = pc87427_attributes_fan[7] },
 };
 
+/* Must be called with data->lock held and pc87427_readall_pwm() freshly
+   called */
+static void update_pwm_enable(struct pc87427_data *data, int nr, u8 mode)
+{
+        int iobase = data->address[LD_FAN];
+        data->pwm_enable[nr] &= ~PWM_ENABLE_MODE_MASK;
+        data->pwm_enable[nr] |= mode;
+        outb(data->pwm_enable[nr], iobase + PC87427_REG_PWM_ENABLE);
+}
+
+static ssize_t show_pwm_enable(struct device *dev, struct device_attribute
+                               *devattr, char *buf)
+{
+        struct pc87427_data *data = pc87427_update_device(dev);
+        int nr = to_sensor_dev_attr(devattr)->index;
+        int pwm_enable;
+
+        pwm_enable = pwm_enable_from_reg(data->pwm_enable[nr]);
+        if (pwm_enable < 0)
+                return pwm_enable;
+        return sprintf(buf, "%d\n", pwm_enable);
+}
+
+static ssize_t set_pwm_enable(struct device *dev, struct device_attribute
+                              *devattr, const char *buf, size_t count)
+{
+        struct pc87427_data *data = dev_get_drvdata(dev);
+        int nr = to_sensor_dev_attr(devattr)->index;
+        unsigned long val;
+
+        if (strict_strtoul(buf, 10, &val) < 0 || val > 2)
+                return -EINVAL;
+        /* Can't go to automatic mode if it isn't configured */
+        if (val == 2 && !(data->pwm_auto_ok & (1 << nr)))
+                return -EINVAL;
+
+        mutex_lock(&data->lock);
+        pc87427_readall_pwm(data, nr);
+        update_pwm_enable(data, nr, pwm_enable_to_reg(val, data->pwm[nr]));
+        mutex_unlock(&data->lock);
+
+        return count;
+}
+
+static ssize_t show_pwm(struct device *dev, struct device_attribute
+                        *devattr, char *buf)
+{
+        struct pc87427_data *data = pc87427_update_device(dev);
+        int nr = to_sensor_dev_attr(devattr)->index;
+
+        return sprintf(buf, "%d\n", (int)data->pwm[nr]);
+}
+
+static ssize_t set_pwm(struct device *dev, struct device_attribute
+                       *devattr, const char *buf, size_t count)
+{
+        struct pc87427_data *data = dev_get_drvdata(dev);
+        int nr = to_sensor_dev_attr(devattr)->index;
+        unsigned long val;
+        int iobase = data->address[LD_FAN];
+        u8 mode;
+
+        if (strict_strtoul(buf, 10, &val) < 0 || val > 0xff)
+                return -EINVAL;
+
+        mutex_lock(&data->lock);
+        pc87427_readall_pwm(data, nr);
+        mode = data->pwm_enable[nr] & PWM_ENABLE_MODE_MASK;
+        if (mode != PWM_MODE_MANUAL && mode != PWM_MODE_OFF) {
+                dev_notice(dev, "Can't set PWM%d duty cycle while not in "
+                           "manual mode\n", nr + 1);
+                mutex_unlock(&data->lock);
+                return -EPERM;
+        }
+
+        /* We may have to change the mode */
+        if (mode == PWM_MODE_MANUAL && val == 0) {
+                /* Transition from Manual to Off */
+                update_pwm_enable(data, nr, PWM_MODE_OFF);
+                mode = PWM_MODE_OFF;
+                dev_dbg(dev, "Switching PWM%d from %s to %s\n", nr + 1,
+                        "manual", "off");
+        } else if (mode == PWM_MODE_OFF && val != 0) {
+                /* Transition from Off to Manual */
+                update_pwm_enable(data, nr, PWM_MODE_MANUAL);
+                mode = PWM_MODE_MANUAL;
+                dev_dbg(dev, "Switching PWM%d from %s to %s\n", nr + 1,
+                        "off", "manual");
+        }
+
+        data->pwm[nr] = val;
+        if (mode == PWM_MODE_MANUAL)
+                outb(val, iobase + PC87427_REG_PWM_DUTY);
+        mutex_unlock(&data->lock);
+
+        return count;
+}
+
+static SENSOR_DEVICE_ATTR(pwm1_enable, S_IWUSR | S_IRUGO,
+                          show_pwm_enable, set_pwm_enable, 0);
+static SENSOR_DEVICE_ATTR(pwm2_enable, S_IWUSR | S_IRUGO,
+                          show_pwm_enable, set_pwm_enable, 1);
+static SENSOR_DEVICE_ATTR(pwm3_enable, S_IWUSR | S_IRUGO,
+                          show_pwm_enable, set_pwm_enable, 2);
+static SENSOR_DEVICE_ATTR(pwm4_enable, S_IWUSR | S_IRUGO,
+                          show_pwm_enable, set_pwm_enable, 3);
+
+static SENSOR_DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 0);
+static SENSOR_DEVICE_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 1);
+static SENSOR_DEVICE_ATTR(pwm3, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 2);
+static SENSOR_DEVICE_ATTR(pwm4, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 3);
+
+static struct attribute *pc87427_attributes_pwm[4][3] = {
+        {
+                &sensor_dev_attr_pwm1_enable.dev_attr.attr,
+                &sensor_dev_attr_pwm1.dev_attr.attr,
+                NULL
+        }, {
+                &sensor_dev_attr_pwm2_enable.dev_attr.attr,
+                &sensor_dev_attr_pwm2.dev_attr.attr,
+                NULL
+        }, {
+                &sensor_dev_attr_pwm3_enable.dev_attr.attr,
+                &sensor_dev_attr_pwm3.dev_attr.attr,
+                NULL
+        }, {
+                &sensor_dev_attr_pwm4_enable.dev_attr.attr,
+                &sensor_dev_attr_pwm4.dev_attr.attr,
+                NULL
+        }
+};
+
+static const struct attribute_group pc87427_group_pwm[4] = {
+        { .attrs = pc87427_attributes_pwm[0] },
+        { .attrs = pc87427_attributes_pwm[1] },
+        { .attrs = pc87427_attributes_pwm[2] },
+        { .attrs = pc87427_attributes_pwm[3] },
+};
+
+static ssize_t show_temp_input(struct device *dev, struct device_attribute
+                               *devattr, char *buf)
+{
+        struct pc87427_data *data = pc87427_update_device(dev);
+        int nr = to_sensor_dev_attr(devattr)->index;
+
+        return sprintf(buf, "%ld\n", temp_from_reg(data->temp[nr]));
+}
+
+static ssize_t show_temp_min(struct device *dev, struct device_attribute
+                             *devattr, char *buf)
+{
+        struct pc87427_data *data = pc87427_update_device(dev);
+        int nr = to_sensor_dev_attr(devattr)->index;
+
+        return sprintf(buf, "%ld\n", temp_from_reg8(data->temp_min[nr]));
+}
+
+static ssize_t show_temp_max(struct device *dev, struct device_attribute
+                             *devattr, char *buf)
+{
+        struct pc87427_data *data = pc87427_update_device(dev);
+        int nr = to_sensor_dev_attr(devattr)->index;
+
+        return sprintf(buf, "%ld\n", temp_from_reg8(data->temp_max[nr]));
+}
+
+static ssize_t show_temp_crit(struct device *dev, struct device_attribute
+                              *devattr, char *buf)
+{
+        struct pc87427_data *data = pc87427_update_device(dev);
+        int nr = to_sensor_dev_attr(devattr)->index;
+
+        return sprintf(buf, "%ld\n", temp_from_reg8(data->temp_crit[nr]));
+}
+
+static ssize_t show_temp_type(struct device *dev, struct device_attribute
+                              *devattr, char *buf)
+{
+        struct pc87427_data *data = pc87427_update_device(dev);
+        int nr = to_sensor_dev_attr(devattr)->index;
+
+        return sprintf(buf, "%u\n", temp_type_from_reg(data->temp_type[nr]));
+}
+
+static ssize_t show_temp_min_alarm(struct device *dev, struct device_attribute
+                                   *devattr, char *buf)
+{
+        struct pc87427_data *data = pc87427_update_device(dev);
+        int nr = to_sensor_dev_attr(devattr)->index;
+
+        return sprintf(buf, "%d\n", !!(data->temp_status[nr]
+                                       & TEMP_STATUS_LOWFLG));
+}
+
+static ssize_t show_temp_max_alarm(struct device *dev, struct device_attribute
+                                   *devattr, char *buf)
+{
+        struct pc87427_data *data = pc87427_update_device(dev);
+        int nr = to_sensor_dev_attr(devattr)->index;
+
+        return sprintf(buf, "%d\n", !!(data->temp_status[nr]
+                                       & TEMP_STATUS_HIGHFLG));
+}
+
+static ssize_t show_temp_crit_alarm(struct device *dev, struct device_attribute
+                                   *devattr, char *buf)
+{
+        struct pc87427_data *data = pc87427_update_device(dev);
+        int nr = to_sensor_dev_attr(devattr)->index;
+
+        return sprintf(buf, "%d\n", !!(data->temp_status[nr]
+                                       & TEMP_STATUS_CRITFLG));
+}
+
+static ssize_t show_temp_fault(struct device *dev, struct device_attribute
+                               *devattr, char *buf)
+{
+        struct pc87427_data *data = pc87427_update_device(dev);
+        int nr = to_sensor_dev_attr(devattr)->index;
+
+        return sprintf(buf, "%d\n", !!(data->temp_status[nr]
+                                       & TEMP_STATUS_SENSERR));
+}
+
+static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp_input, NULL, 0);
+static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp_input, NULL, 1);
+static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp_input, NULL, 2);
+static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, show_temp_input, NULL, 3);
+static SENSOR_DEVICE_ATTR(temp5_input, S_IRUGO, show_temp_input, NULL, 4);
+static SENSOR_DEVICE_ATTR(temp6_input, S_IRUGO, show_temp_input, NULL, 5);
+
+static SENSOR_DEVICE_ATTR(temp1_min, S_IRUGO, show_temp_min, NULL, 0);
+static SENSOR_DEVICE_ATTR(temp2_min, S_IRUGO, show_temp_min, NULL, 1);
+static SENSOR_DEVICE_ATTR(temp3_min, S_IRUGO, show_temp_min, NULL, 2);
+static SENSOR_DEVICE_ATTR(temp4_min, S_IRUGO, show_temp_min, NULL, 3);
+static SENSOR_DEVICE_ATTR(temp5_min, S_IRUGO, show_temp_min, NULL, 4);
+static SENSOR_DEVICE_ATTR(temp6_min, S_IRUGO, show_temp_min, NULL, 5);
+
+static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO, show_temp_max, NULL, 0);
+static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO, show_temp_max, NULL, 1);
+static SENSOR_DEVICE_ATTR(temp3_max, S_IRUGO, show_temp_max, NULL, 2);
+static SENSOR_DEVICE_ATTR(temp4_max, S_IRUGO, show_temp_max, NULL, 3);
+static SENSOR_DEVICE_ATTR(temp5_max, S_IRUGO, show_temp_max, NULL, 4);
+static SENSOR_DEVICE_ATTR(temp6_max, S_IRUGO, show_temp_max, NULL, 5);
+
+static SENSOR_DEVICE_ATTR(temp1_crit, S_IRUGO, show_temp_crit, NULL, 0);
+static SENSOR_DEVICE_ATTR(temp2_crit, S_IRUGO, show_temp_crit, NULL, 1);
+static SENSOR_DEVICE_ATTR(temp3_crit, S_IRUGO, show_temp_crit, NULL, 2);
+static SENSOR_DEVICE_ATTR(temp4_crit, S_IRUGO, show_temp_crit, NULL, 3);
+static SENSOR_DEVICE_ATTR(temp5_crit, S_IRUGO, show_temp_crit, NULL, 4);
+static SENSOR_DEVICE_ATTR(temp6_crit, S_IRUGO, show_temp_crit, NULL, 5);
+
+static SENSOR_DEVICE_ATTR(temp1_type, S_IRUGO, show_temp_type, NULL, 0);
+static SENSOR_DEVICE_ATTR(temp2_type, S_IRUGO, show_temp_type, NULL, 1);
+static SENSOR_DEVICE_ATTR(temp3_type, S_IRUGO, show_temp_type, NULL, 2);
+static SENSOR_DEVICE_ATTR(temp4_type, S_IRUGO, show_temp_type, NULL, 3);
+static SENSOR_DEVICE_ATTR(temp5_type, S_IRUGO, show_temp_type, NULL, 4);
+static SENSOR_DEVICE_ATTR(temp6_type, S_IRUGO, show_temp_type, NULL, 5);
+
+static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO,
+                          show_temp_min_alarm, NULL, 0);
+static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO,
+                          show_temp_min_alarm, NULL, 1);
+static SENSOR_DEVICE_ATTR(temp3_min_alarm, S_IRUGO,
+                          show_temp_min_alarm, NULL, 2);
+static SENSOR_DEVICE_ATTR(temp4_min_alarm, S_IRUGO,
+                          show_temp_min_alarm, NULL, 3);
+static SENSOR_DEVICE_ATTR(temp5_min_alarm, S_IRUGO,
+                          show_temp_min_alarm, NULL, 4);
+static SENSOR_DEVICE_ATTR(temp6_min_alarm, S_IRUGO,
+                          show_temp_min_alarm, NULL, 5);
+
+static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO,
+                          show_temp_max_alarm, NULL, 0);
+static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO,
+                          show_temp_max_alarm, NULL, 1);
+static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO,
+                          show_temp_max_alarm, NULL, 2);
+static SENSOR_DEVICE_ATTR(temp4_max_alarm, S_IRUGO,
+                          show_temp_max_alarm, NULL, 3);
+static SENSOR_DEVICE_ATTR(temp5_max_alarm, S_IRUGO,
+                          show_temp_max_alarm, NULL, 4);
+static SENSOR_DEVICE_ATTR(temp6_max_alarm, S_IRUGO,
+                          show_temp_max_alarm, NULL, 5);
+
+static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO,
+                          show_temp_crit_alarm, NULL, 0);
+static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO,
+                          show_temp_crit_alarm, NULL, 1);
+static SENSOR_DEVICE_ATTR(temp3_crit_alarm, S_IRUGO,
+                          show_temp_crit_alarm, NULL, 2);
+static SENSOR_DEVICE_ATTR(temp4_crit_alarm, S_IRUGO,
+                          show_temp_crit_alarm, NULL, 3);
+static SENSOR_DEVICE_ATTR(temp5_crit_alarm, S_IRUGO,
+                          show_temp_crit_alarm, NULL, 4);
+static SENSOR_DEVICE_ATTR(temp6_crit_alarm, S_IRUGO,
+                          show_temp_crit_alarm, NULL, 5);
+
+static SENSOR_DEVICE_ATTR(temp1_fault, S_IRUGO, show_temp_fault, NULL, 0);
+static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_temp_fault, NULL, 1);
+static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_temp_fault, NULL, 2);
+static SENSOR_DEVICE_ATTR(temp4_fault, S_IRUGO, show_temp_fault, NULL, 3);
+static SENSOR_DEVICE_ATTR(temp5_fault, S_IRUGO, show_temp_fault, NULL, 4);
+static SENSOR_DEVICE_ATTR(temp6_fault, S_IRUGO, show_temp_fault, NULL, 5);
+
+static struct attribute *pc87427_attributes_temp[6][10] = {
+        {
+                &sensor_dev_attr_temp1_input.dev_attr.attr,
+                &sensor_dev_attr_temp1_min.dev_attr.attr,
+                &sensor_dev_attr_temp1_max.dev_attr.attr,
+                &sensor_dev_attr_temp1_crit.dev_attr.attr,
+                &sensor_dev_attr_temp1_type.dev_attr.attr,
+                &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
+                &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
+                &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
+                &sensor_dev_attr_temp1_fault.dev_attr.attr,
+                NULL
+        }, {
+                &sensor_dev_attr_temp2_input.dev_attr.attr,
+                &sensor_dev_attr_temp2_min.dev_attr.attr,
+                &sensor_dev_attr_temp2_max.dev_attr.attr,
+                &sensor_dev_attr_temp2_crit.dev_attr.attr,
+                &sensor_dev_attr_temp2_type.dev_attr.attr,
+                &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
+                &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
+                &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
+                &sensor_dev_attr_temp2_fault.dev_attr.attr,
+                NULL
+        }, {
+                &sensor_dev_attr_temp3_input.dev_attr.attr,
+                &sensor_dev_attr_temp3_min.dev_attr.attr,
+                &sensor_dev_attr_temp3_max.dev_attr.attr,
+                &sensor_dev_attr_temp3_crit.dev_attr.attr,
+                &sensor_dev_attr_temp3_type.dev_attr.attr,
+                &sensor_dev_attr_temp3_min_alarm.dev_attr.attr,
+                &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
+                &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr,
+                &sensor_dev_attr_temp3_fault.dev_attr.attr,
+                NULL
+        }, {
+                &sensor_dev_attr_temp4_input.dev_attr.attr,
+                &sensor_dev_attr_temp4_min.dev_attr.attr,
+                &sensor_dev_attr_temp4_max.dev_attr.attr,
+                &sensor_dev_attr_temp4_crit.dev_attr.attr,
+                &sensor_dev_attr_temp4_type.dev_attr.attr,
+                &sensor_dev_attr_temp4_min_alarm.dev_attr.attr,
+                &sensor_dev_attr_temp4_max_alarm.dev_attr.attr,
+                &sensor_dev_attr_temp4_crit_alarm.dev_attr.attr,
+                &sensor_dev_attr_temp4_fault.dev_attr.attr,
+                NULL
+        }, {
+                &sensor_dev_attr_temp5_input.dev_attr.attr,
+                &sensor_dev_attr_temp5_min.dev_attr.attr,
+                &sensor_dev_attr_temp5_max.dev_attr.attr,
+                &sensor_dev_attr_temp5_crit.dev_attr.attr,
+                &sensor_dev_attr_temp5_type.dev_attr.attr,
+                &sensor_dev_attr_temp5_min_alarm.dev_attr.attr,
+                &sensor_dev_attr_temp5_max_alarm.dev_attr.attr,
+                &sensor_dev_attr_temp5_crit_alarm.dev_attr.attr,
+                &sensor_dev_attr_temp5_fault.dev_attr.attr,
+                NULL
+        }, {
+                &sensor_dev_attr_temp6_input.dev_attr.attr,
+                &sensor_dev_attr_temp6_min.dev_attr.attr,
+                &sensor_dev_attr_temp6_max.dev_attr.attr,
+                &sensor_dev_attr_temp6_crit.dev_attr.attr,
+                &sensor_dev_attr_temp6_type.dev_attr.attr,
+                &sensor_dev_attr_temp6_min_alarm.dev_attr.attr,
+                &sensor_dev_attr_temp6_max_alarm.dev_attr.attr,
+                &sensor_dev_attr_temp6_crit_alarm.dev_attr.attr,
+                &sensor_dev_attr_temp6_fault.dev_attr.attr,
+                NULL
+        }
+};
+
+static const struct attribute_group pc87427_group_temp[6] = {
+        { .attrs = pc87427_attributes_temp[0] },
+        { .attrs = pc87427_attributes_temp[1] },
+        { .attrs = pc87427_attributes_temp[2] },
+        { .attrs = pc87427_attributes_temp[3] },
+        { .attrs = pc87427_attributes_temp[4] },
+        { .attrs = pc87427_attributes_temp[5] },
+};
+
 static ssize_t show_name(struct device *dev, struct device_attribute
                          *devattr, char *buf)
 {
@@ -391,8 +938,49 @@ static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
  * Device detection, attach and detach
  */
 
+static void pc87427_release_regions(struct platform_device *pdev, int count)
+{
+        struct resource *res;
+        int i;
+
+        for (i = 0; i < count; i++) {
+                res = platform_get_resource(pdev, IORESOURCE_IO, i);
+                release_region(res->start, resource_size(res));
+        }
+}
+
+static int __devinit pc87427_request_regions(struct platform_device *pdev,
+                                             int count)
+{
+        struct resource *res;
+        int i, err = 0;
+
+        for (i = 0; i < count; i++) {
+                res = platform_get_resource(pdev, IORESOURCE_IO, i);
+                if (!res) {
+                        err = -ENOENT;
+                        dev_err(&pdev->dev, "Missing resource #%d\n", i);
+                        break;
+                }
+                if (!request_region(res->start, resource_size(res), DRVNAME)) {
+                        err = -EBUSY;
+                        dev_err(&pdev->dev,
+                                "Failed to request region 0x%lx-0x%lx\n",
+                                (unsigned long)res->start,
+                                (unsigned long)res->end);
+                        break;
+                }
+        }
+
+        if (err && i)
+                pc87427_release_regions(pdev, i);
+
+        return err;
+}
+
 static void __devinit pc87427_init_device(struct device *dev)
 {
+        struct pc87427_sio_data *sio_data = dev->platform_data;
         struct pc87427_data *data = dev_get_drvdata(dev);
         int i;
         u8 reg;
@@ -400,10 +988,12 @@ static void __devinit pc87427_init_device(struct device *dev)
         /* The FMC module should be ready */
         reg = pc87427_read8(data, LD_FAN, PC87427_REG_BANK);
         if (!(reg & 0x80))
-                dev_warn(dev, "FMC module not ready!\n");
+                dev_warn(dev, "%s module not ready!\n", "FMC");
 
         /* Check which fans are enabled */
         for (i = 0; i < 8; i++) {
+                if (!(sio_data->has_fanin & (1 << i)))  /* Not wired */
+                        continue;
                 reg = pc87427_read8_bank(data, LD_FAN, BANK_FM(i),
                                          PC87427_REG_FAN_STATUS);
                 if (reg & FAN_STATUS_MONEN)
@@ -411,37 +1001,93 @@ static void __devinit pc87427_init_device(struct device *dev)
         }
 
         if (!data->fan_enabled) {
-                dev_dbg(dev, "Enabling all fan inputs\n");
-                for (i = 0; i < 8; i++)
+                dev_dbg(dev, "Enabling monitoring of all fans\n");
+                for (i = 0; i < 8; i++) {
+                        if (!(sio_data->has_fanin & (1 << i)))  /* Not wired */
+                                continue;
                         pc87427_write8_bank(data, LD_FAN, BANK_FM(i),
                                             PC87427_REG_FAN_STATUS,
                                             FAN_STATUS_MONEN);
-                data->fan_enabled = 0xff;
+                }
+                data->fan_enabled = sio_data->has_fanin;
+        }
+
+        /* Check which PWM outputs are enabled */
+        for (i = 0; i < 4; i++) {
+                if (!(sio_data->has_fanout & (1 << i))) /* Not wired */
+                        continue;
+                reg = pc87427_read8_bank(data, LD_FAN, BANK_FC(i),
+                                         PC87427_REG_PWM_ENABLE);
+                if (reg & PWM_ENABLE_CTLEN)
+                        data->pwm_enabled |= (1 << i);
+
+                /* We don't expose an interface to reconfigure the automatic
+                   fan control mode, so only allow to return to this mode if
+                   it was originally set. */
+                if ((reg & PWM_ENABLE_MODE_MASK) == PWM_MODE_AUTO) {
+                        dev_dbg(dev, "PWM%d is in automatic control mode\n",
+                                i + 1);
+                        data->pwm_auto_ok |= (1 << i);
+                }
+        }
+
+        /* The HMC module should be ready */
+        reg = pc87427_read8(data, LD_TEMP, PC87427_REG_BANK);
+        if (!(reg & 0x80))
+                dev_warn(dev, "%s module not ready!\n", "HMC");
+
+        /* Check which temperature channels are enabled */
+        for (i = 0; i < 6; i++) {
+                reg = pc87427_read8_bank(data, LD_TEMP, BANK_TM(i),
+                                         PC87427_REG_TEMP_STATUS);
+                if (reg & TEMP_STATUS_CHANEN)
+                        data->temp_enabled |= (1 << i);
+        }
+}
+
+static void pc87427_remove_files(struct device *dev)
+{
+        struct pc87427_data *data = dev_get_drvdata(dev);
+        int i;
+
+        device_remove_file(dev, &dev_attr_name);
+        for (i = 0; i < 8; i++) {
+                if (!(data->fan_enabled & (1 << i)))
+                        continue;
+                sysfs_remove_group(&dev->kobj, &pc87427_group_fan[i]);
+        }
+        for (i = 0; i < 4; i++) {
+                if (!(data->pwm_enabled & (1 << i)))
+                        continue;
+                sysfs_remove_group(&dev->kobj, &pc87427_group_pwm[i]);
+        }
+        for (i = 0; i < 6; i++) {
+                if (!(data->temp_enabled & (1 << i)))
+                        continue;
+                sysfs_remove_group(&dev->kobj, &pc87427_group_temp[i]);
         }
 }
 
 static int __devinit pc87427_probe(struct platform_device *pdev)
 {
+        struct pc87427_sio_data *sio_data = pdev->dev.platform_data;
         struct pc87427_data *data;
-        struct resource *res;
-        int i, err;
+        int i, err, res_count;
 
-        if (!(data = kzalloc(sizeof(struct pc87427_data), GFP_KERNEL))) {
+        data = kzalloc(sizeof(struct pc87427_data), GFP_KERNEL);
+        if (!data) {
                 err = -ENOMEM;
                 printk(KERN_ERR DRVNAME ": Out of memory\n");
                 goto exit;
         }
 
-        /* This will need to be revisited when we add support for
-           temperature and voltage monitoring. */
-        res = platform_get_resource(pdev, IORESOURCE_IO, 0);
-        if (!request_region(res->start, resource_size(res), DRVNAME)) {
-                err = -EBUSY;
-                dev_err(&pdev->dev, "Failed to request region 0x%lx-0x%lx\n",
-                        (unsigned long)res->start, (unsigned long)res->end);
+        data->address[0] = sio_data->address[0];
+        data->address[1] = sio_data->address[1];
+        res_count = (data->address[0] != 0) + (data->address[1] != 0);
+
+        err = pc87427_request_regions(pdev, res_count);
+        if (err)
                 goto exit_kfree;
-        }
-        data->address[0] = res->start;
 
         mutex_init(&data->lock);
         data->name = "pc87427";
@@ -449,13 +1095,31 @@ static int __devinit pc87427_probe(struct platform_device *pdev)
         pc87427_init_device(&pdev->dev);
 
         /* Register sysfs hooks */
-        if ((err = device_create_file(&pdev->dev, &dev_attr_name)))
+        err = device_create_file(&pdev->dev, &dev_attr_name);
+        if (err)
                 goto exit_release_region;
         for (i = 0; i < 8; i++) {
                 if (!(data->fan_enabled & (1 << i)))
                         continue;
-                if ((err = sysfs_create_group(&pdev->dev.kobj,
-                                              &pc87427_group_fan[i])))
+                err = sysfs_create_group(&pdev->dev.kobj,
+                                         &pc87427_group_fan[i]);
+                if (err)
+                        goto exit_remove_files;
+        }
+        for (i = 0; i < 4; i++) {
+                if (!(data->pwm_enabled & (1 << i)))
+                        continue;
+                err = sysfs_create_group(&pdev->dev.kobj,
+                                         &pc87427_group_pwm[i]);
+                if (err)
+                        goto exit_remove_files;
+        }
+        for (i = 0; i < 6; i++) {
+                if (!(data->temp_enabled & (1 << i)))
+                        continue;
+                err = sysfs_create_group(&pdev->dev.kobj,
+                                         &pc87427_group_temp[i]);
+                if (err)
                         goto exit_remove_files;
         }
 
@@ -469,13 +1133,9 @@ static int __devinit pc87427_probe(struct platform_device *pdev)
         return 0;
 
 exit_remove_files:
-        for (i = 0; i < 8; i++) {
-                if (!(data->fan_enabled & (1 << i)))
-                        continue;
-                sysfs_remove_group(&pdev->dev.kobj, &pc87427_group_fan[i]);
-        }
+        pc87427_remove_files(&pdev->dev);
 exit_release_region:
-        release_region(res->start, resource_size(res));
+        pc87427_release_regions(pdev, res_count);
 exit_kfree:
         platform_set_drvdata(pdev, NULL);
         kfree(data);
@@ -486,21 +1146,16 @@ exit:
 static int __devexit pc87427_remove(struct platform_device *pdev)
 {
         struct pc87427_data *data = platform_get_drvdata(pdev);
-        struct resource *res;
-        int i;
+        int res_count;
+
+        res_count = (data->address[0] != 0) + (data->address[1] != 0);
 
         hwmon_device_unregister(data->hwmon_dev);
-        device_remove_file(&pdev->dev, &dev_attr_name);
-        for (i = 0; i < 8; i++) {
-                if (!(data->fan_enabled & (1 << i)))
-                        continue;
-                sysfs_remove_group(&pdev->dev.kobj, &pc87427_group_fan[i]);
-        }
+        pc87427_remove_files(&pdev->dev);
         platform_set_drvdata(pdev, NULL);
         kfree(data);
 
-        res = platform_get_resource(pdev, IORESOURCE_IO, 0);
-        release_region(res->start, resource_size(res));
+        pc87427_release_regions(pdev, res_count);
 
         return 0;
 }
@@ -515,34 +1170,50 @@ static struct platform_driver pc87427_driver = {
         .remove         = __devexit_p(pc87427_remove),
 };
 
-static int __init pc87427_device_add(unsigned short address)
+static int __init pc87427_device_add(const struct pc87427_sio_data *sio_data)
 {
-        struct resource res = {
-                .start  = address,
-                .end    = address + REGION_LENGTH - 1,
-                .name   = logdev_str[0],
-                .flags  = IORESOURCE_IO,
+        struct resource res[2] = {
+                { .flags        = IORESOURCE_IO },
+                { .flags        = IORESOURCE_IO },
         };
-        int err;
+        int err, i, res_count;
 
-        err = acpi_check_resource_conflict(&res);
-        if (err)
-                goto exit;
+        res_count = 0;
+        for (i = 0; i < 2; i++) {
+                if (!sio_data->address[i])
+                        continue;
+                res[res_count].start = sio_data->address[i];
+                res[res_count].end = sio_data->address[i] + REGION_LENGTH - 1;
+                res[res_count].name = logdev_str[i];
 
-        pdev = platform_device_alloc(DRVNAME, address);
+                err = acpi_check_resource_conflict(&res[res_count]);
+                if (err)
+                        goto exit;
+
+                res_count++;
+        }
+
+        pdev = platform_device_alloc(DRVNAME, res[0].start);
         if (!pdev) {
                 err = -ENOMEM;
                 printk(KERN_ERR DRVNAME ": Device allocation failed\n");
                 goto exit;
         }
 
-        err = platform_device_add_resources(pdev, &res, 1);
+        err = platform_device_add_resources(pdev, res, res_count);
         if (err) {
                 printk(KERN_ERR DRVNAME ": Device resource addition failed "
                        "(%d)\n", err);
                 goto exit_device_put;
         }
 
+        err = platform_device_add_data(pdev, sio_data,
+                                       sizeof(struct pc87427_sio_data));
+        if (err) {
+                printk(KERN_ERR DRVNAME ": Platform data allocation failed\n");
+                goto exit_device_put;
+        }
+
         err = platform_device_add(pdev);
         if (err) {
                 printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n",
@@ -558,9 +1229,10 @@ exit:
         return err;
 }
 
-static int __init pc87427_find(int sioaddr, unsigned short *address)
+static int __init pc87427_find(int sioaddr, struct pc87427_sio_data *sio_data)
 {
         u16 val;
+        u8 cfg, cfg_b;
         int i, err = 0;
 
         /* Identify device */
@@ -571,7 +1243,7 @@ static int __init pc87427_find(int sioaddr, unsigned short *address)
         }
 
         for (i = 0; i < 2; i++) {
-                address[i] = 0;
+                sio_data->address[i] = 0;
                 /* Select logical device */
                 superio_outb(sioaddr, SIOREG_LDSEL, logdev[i]);
 
@@ -596,9 +1268,58 @@ static int __init pc87427_find(int sioaddr, unsigned short *address)
                                "for logical device 0x%02x\n", logdev[i]);
                         continue;
                 }
-                address[i] = val;
+                sio_data->address[i] = val;
         }
 
+        /* No point in loading the driver if everything is disabled */
+        if (!sio_data->address[0] && !sio_data->address[1]) {
+                err = -ENODEV;
+                goto exit;
+        }
+
+        /* Check which fan inputs are wired */
+        sio_data->has_fanin = (1 << 2) | (1 << 3);      /* FANIN2, FANIN3 */
+
+        cfg = superio_inb(sioaddr, SIOREG_CF2);
+        if (!(cfg & (1 << 3)))
+                sio_data->has_fanin |= (1 << 0);        /* FANIN0 */
+        if (!(cfg & (1 << 2)))
+                sio_data->has_fanin |= (1 << 4);        /* FANIN4 */
+
+        cfg = superio_inb(sioaddr, SIOREG_CFD);
+        if (!(cfg & (1 << 0)))
+                sio_data->has_fanin |= (1 << 1);        /* FANIN1 */
+
+        cfg = superio_inb(sioaddr, SIOREG_CF4);
+        if (!(cfg & (1 << 0)))
+                sio_data->has_fanin |= (1 << 7);        /* FANIN7 */
+        cfg_b = superio_inb(sioaddr, SIOREG_CFB);
+        if (!(cfg & (1 << 1)) && (cfg_b & (1 << 3)))
+                sio_data->has_fanin |= (1 << 5);        /* FANIN5 */
+        cfg = superio_inb(sioaddr, SIOREG_CF3);
+        if ((cfg & (1 << 3)) && !(cfg_b & (1 << 5)))
+                sio_data->has_fanin |= (1 << 6);        /* FANIN6 */
+
+        /* Check which fan outputs are wired */
+        sio_data->has_fanout = (1 << 0);                /* FANOUT0 */
+        if (cfg_b & (1 << 0))
+                sio_data->has_fanout |= (1 << 3);       /* FANOUT3 */
+
+        cfg = superio_inb(sioaddr, SIOREG_CFC);
+        if (!(cfg & (1 << 4))) {
+                if (cfg_b & (1 << 1))
+                        sio_data->has_fanout |= (1 << 1); /* FANOUT1 */
+                if (cfg_b & (1 << 2))
+                        sio_data->has_fanout |= (1 << 2); /* FANOUT2 */
+        }
+
+        /* FANOUT1 and FANOUT2 can each be routed to 2 different pins */
+        cfg = superio_inb(sioaddr, SIOREG_CF5);
+        if (cfg & (1 << 6))
+                sio_data->has_fanout |= (1 << 1);       /* FANOUT1 */
+        if (cfg & (1 << 5))
+                sio_data->has_fanout |= (1 << 2);       /* FANOUT2 */
+
 exit:
         superio_exit(sioaddr);
         return err;
@@ -607,15 +1328,10 @@ exit:
 static int __init pc87427_init(void)
 {
         int err;
-        unsigned short address[2];
-
-        if (pc87427_find(0x2e, address)
-         && pc87427_find(0x4e, address))
-                return -ENODEV;
+        struct pc87427_sio_data sio_data;
 
-        /* For now the driver only handles fans so we only care about the
-           first address. */
-        if (!address[0])
+        if (pc87427_find(0x2e, &sio_data)
+         && pc87427_find(0x4e, &sio_data))
                 return -ENODEV;
 
         err = platform_driver_register(&pc87427_driver);
@@ -623,7 +1339,7 @@ static int __init pc87427_init(void)
                 goto exit;
 
         /* Sets global pdev as a side effect */
-        err = pc87427_device_add(address[0]);
+        err = pc87427_device_add(&sio_data);
         if (err)
                 goto exit_driver;
 
diff --git a/drivers/hwmon/via-cputemp.c b/drivers/hwmon/via-cputemp.c
index 7442cf754856..ffb793af680b 100644
--- a/drivers/hwmon/via-cputemp.c
+++ b/drivers/hwmon/via-cputemp.c
@@ -39,7 +39,7 @@
 
 #define DRVNAME "via_cputemp"
 
-enum { SHOW_TEMP, SHOW_LABEL, SHOW_NAME } SHOW;
+enum { SHOW_TEMP, SHOW_LABEL, SHOW_NAME };
 
 /*
  * Functions declaration
diff --git a/drivers/hwmon/w83627ehf.c b/drivers/hwmon/w83627ehf.c
index 0dcaba9b7189..e96e69dd36fb 100644
--- a/drivers/hwmon/w83627ehf.c
+++ b/drivers/hwmon/w83627ehf.c
@@ -39,6 +39,7 @@
     w83627dhg    9      5       4       3      0xa020 0xc1    0x5ca3
     w83627dhg-p  9      5       4       3      0xb070 0xc1    0x5ca3
     w83667hg     9      5       3       3      0xa510 0xc1    0x5ca3
+    w83667hg-b   9      5       3       3      0xb350 0xc1    0x5ca3
 */
 
 #include <linux/module.h>
@@ -55,7 +56,7 @@
 #include <linux/io.h>
 #include "lm75.h"
 
-enum kinds { w83627ehf, w83627dhg, w83627dhg_p, w83667hg };
+enum kinds { w83627ehf, w83627dhg, w83627dhg_p, w83667hg, w83667hg_b };
 
 /* used to set data->name = w83627ehf_device_names[data->sio_kind] */
 static const char * w83627ehf_device_names[] = {
@@ -63,6 +64,7 @@ static const char * w83627ehf_device_names[] = {
         "w83627dhg",
         "w83627dhg",
         "w83667hg",
+        "w83667hg",
 };
 
 static unsigned short force_id;
@@ -91,6 +93,7 @@ MODULE_PARM_DESC(force_id, "Override the detected device ID");
 #define SIO_W83627DHG_ID        0xa020
 #define SIO_W83627DHG_P_ID      0xb070
 #define SIO_W83667HG_ID         0xa510
+#define SIO_W83667HG_B_ID       0xb350
 #define SIO_ID_MASK             0xFFF0
 
 static inline void
@@ -201,8 +204,14 @@ static const u8 W83627EHF_REG_TOLERANCE[] = { 0x07, 0x07, 0x14, 0x62 };
 static const u8 W83627EHF_REG_FAN_START_OUTPUT[] = { 0x0a, 0x0b, 0x16, 0x65 };
 static const u8 W83627EHF_REG_FAN_STOP_OUTPUT[] = { 0x08, 0x09, 0x15, 0x64 };
 static const u8 W83627EHF_REG_FAN_STOP_TIME[] = { 0x0c, 0x0d, 0x17, 0x66 };
-static const u8 W83627EHF_REG_FAN_MAX_OUTPUT[] = { 0xff, 0x67, 0xff, 0x69 };
-static const u8 W83627EHF_REG_FAN_STEP_OUTPUT[] = { 0xff, 0x68, 0xff, 0x6a };
+
+static const u8 W83627EHF_REG_FAN_MAX_OUTPUT_COMMON[]
+                                                = { 0xff, 0x67, 0xff, 0x69 };
+static const u8 W83627EHF_REG_FAN_STEP_OUTPUT_COMMON[]
+                                                = { 0xff, 0x68, 0xff, 0x6a };
+
+static const u8 W83627EHF_REG_FAN_MAX_OUTPUT_W83667_B[] = { 0x67, 0x69, 0x6b };
+static const u8 W83627EHF_REG_FAN_STEP_OUTPUT_W83667_B[] = { 0x68, 0x6a, 0x6c };
 
 /*
  * Conversions
@@ -277,6 +286,11 @@ struct w83627ehf_data {
         struct device *hwmon_dev;
         struct mutex lock;
 
+        const u8 *REG_FAN_START_OUTPUT;
+        const u8 *REG_FAN_STOP_OUTPUT;
+        const u8 *REG_FAN_MAX_OUTPUT;
+        const u8 *REG_FAN_STEP_OUTPUT;
+
         struct mutex update_lock;
         char valid;             /* !=0 if following fields are valid */
         unsigned long last_updated;     /* In jiffies */
@@ -524,7 +538,10 @@ static struct w83627ehf_data *w83627ehf_update_device(struct device *dev)
                         }
                 }
 
-                for (i = 0; i < 4; i++) {
+                for (i = 0; i < data->pwm_num; i++) {
+                        if (!(data->has_fan & (1 << i)))
+                                continue;
+
                         /* pwmcfg, tolerance mapped for i=0, i=1 to same reg */
                         if (i != 1) {
                                 pwmcfg = w83627ehf_read_value(data,
@@ -546,6 +563,17 @@ static struct w83627ehf_data *w83627ehf_update_device(struct device *dev)
                                                 W83627EHF_REG_FAN_STOP_OUTPUT[i]);
                         data->fan_stop_time[i] = w83627ehf_read_value(data,
                                                 W83627EHF_REG_FAN_STOP_TIME[i]);
+
+                        if (data->REG_FAN_MAX_OUTPUT[i] != 0xff)
+                                data->fan_max_output[i] =
+                                  w83627ehf_read_value(data,
+                                               data->REG_FAN_MAX_OUTPUT[i]);
+
+                        if (data->REG_FAN_STEP_OUTPUT[i] != 0xff)
+                                data->fan_step_output[i] =
+                                  w83627ehf_read_value(data,
+                                               data->REG_FAN_STEP_OUTPUT[i]);
+
                         data->target_temp[i] =
                                 w83627ehf_read_value(data,
                                         W83627EHF_REG_TARGET[i]) &
@@ -1126,7 +1154,7 @@ store_##reg(struct device *dev, struct device_attribute *attr, \
         u32 val = SENSORS_LIMIT(simple_strtoul(buf, NULL, 10), 1, 255); \
         mutex_lock(&data->update_lock); \
         data->reg[nr] = val; \
-        w83627ehf_write_value(data, W83627EHF_REG_##REG[nr], val); \
+        w83627ehf_write_value(data, data->REG_##REG[nr], val); \
         mutex_unlock(&data->update_lock); \
         return count; \
 }
@@ -1206,12 +1234,26 @@ static struct sensor_device_attribute sda_sf3_arrays[] = {
                     store_fan_stop_output, 1),
         SENSOR_ATTR(pwm3_stop_output, S_IWUSR | S_IRUGO, show_fan_stop_output,
                     store_fan_stop_output, 2),
+};
 
-        /* pwm1 and pwm3 don't support max and step settings */
+
+/*
+ * pwm1 and pwm3 don't support max and step settings on all chips.
+ * Need to check support while generating/removing attribute files.
+ */
+static struct sensor_device_attribute sda_sf3_max_step_arrays[] = {
+        SENSOR_ATTR(pwm1_max_output, S_IWUSR | S_IRUGO, show_fan_max_output,
+                    store_fan_max_output, 0),
+        SENSOR_ATTR(pwm1_step_output, S_IWUSR | S_IRUGO, show_fan_step_output,
+                    store_fan_step_output, 0),
         SENSOR_ATTR(pwm2_max_output, S_IWUSR | S_IRUGO, show_fan_max_output,
                     store_fan_max_output, 1),
         SENSOR_ATTR(pwm2_step_output, S_IWUSR | S_IRUGO, show_fan_step_output,
                     store_fan_step_output, 1),
+        SENSOR_ATTR(pwm3_max_output, S_IWUSR | S_IRUGO, show_fan_max_output,
+                    store_fan_max_output, 2),
+        SENSOR_ATTR(pwm3_step_output, S_IWUSR | S_IRUGO, show_fan_step_output,
+                    store_fan_step_output, 2),
 };
 
 static ssize_t
@@ -1235,6 +1277,12 @@ static void w83627ehf_device_remove_files(struct device *dev)
 
         for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays); i++)
                 device_remove_file(dev, &sda_sf3_arrays[i].dev_attr);
+        for (i = 0; i < ARRAY_SIZE(sda_sf3_max_step_arrays); i++) {
+                struct sensor_device_attribute *attr =
+                  &sda_sf3_max_step_arrays[i];
+                if (data->REG_FAN_STEP_OUTPUT[attr->index] != 0xff)
+                        device_remove_file(dev, &attr->dev_attr);
+        }
         for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays_fan4); i++)
                 device_remove_file(dev, &sda_sf3_arrays_fan4[i].dev_attr);
         for (i = 0; i < data->in_num; i++) {
@@ -1343,22 +1391,37 @@ static int __devinit w83627ehf_probe(struct platform_device *pdev)
         /* 627EHG and 627EHF have 10 voltage inputs; 627DHG and 667HG have 9 */
         data->in_num = (sio_data->kind == w83627ehf) ? 10 : 9;
         /* 667HG has 3 pwms */
-        data->pwm_num = (sio_data->kind == w83667hg) ? 3 : 4;
+        data->pwm_num = (sio_data->kind == w83667hg
+                         || sio_data->kind == w83667hg_b) ? 3 : 4;
 
         /* Check temp3 configuration bit for 667HG */
-        if (sio_data->kind == w83667hg) {
+        if (sio_data->kind == w83667hg || sio_data->kind == w83667hg_b) {
                 data->temp3_disable = w83627ehf_read_value(data,
                                         W83627EHF_REG_TEMP_CONFIG[1]) & 0x01;
                 data->in6_skip = !data->temp3_disable;
         }
 
+        data->REG_FAN_START_OUTPUT = W83627EHF_REG_FAN_START_OUTPUT;
+        data->REG_FAN_STOP_OUTPUT = W83627EHF_REG_FAN_STOP_OUTPUT;
+        if (sio_data->kind == w83667hg_b) {
+                data->REG_FAN_MAX_OUTPUT =
+                  W83627EHF_REG_FAN_MAX_OUTPUT_W83667_B;
+                data->REG_FAN_STEP_OUTPUT =
+                  W83627EHF_REG_FAN_STEP_OUTPUT_W83667_B;
+        } else {
+                data->REG_FAN_MAX_OUTPUT =
+                  W83627EHF_REG_FAN_MAX_OUTPUT_COMMON;
+                data->REG_FAN_STEP_OUTPUT =
+                  W83627EHF_REG_FAN_STEP_OUTPUT_COMMON;
+        }
+
         /* Initialize the chip */
         w83627ehf_init_device(data);
 
         data->vrm = vid_which_vrm();
         superio_enter(sio_data->sioreg);
         /* Read VID value */
-        if (sio_data->kind == w83667hg) {
+        if (sio_data->kind == w83667hg || sio_data->kind == w83667hg_b) {
                 /* W83667HG has different pins for VID input and output, so
                 we can get the VID input values directly at logical device D
                 0xe3. */
@@ -1409,7 +1472,7 @@ static int __devinit w83627ehf_probe(struct platform_device *pdev)
         }
 
         /* fan4 and fan5 share some pins with the GPIO and serial flash */
-        if (sio_data->kind == w83667hg) {
+        if (sio_data->kind == w83667hg || sio_data->kind == w83667hg_b) {
                 fan5pin = superio_inb(sio_data->sioreg, 0x27) & 0x20;
                 fan4pin = superio_inb(sio_data->sioreg, 0x27) & 0x40;
         } else {
@@ -1440,6 +1503,15 @@ static int __devinit w83627ehf_probe(struct platform_device *pdev)
                         &sda_sf3_arrays[i].dev_attr)))
                         goto exit_remove;
 
+        for (i = 0; i < ARRAY_SIZE(sda_sf3_max_step_arrays); i++) {
+                struct sensor_device_attribute *attr =
+                  &sda_sf3_max_step_arrays[i];
+                if (data->REG_FAN_STEP_OUTPUT[attr->index] != 0xff) {
+                        err = device_create_file(dev, &attr->dev_attr);
+                        if (err)
+                                goto exit_remove;
+                }
+        }
         /* if fan4 is enabled create the sf3 files for it */
         if ((data->has_fan & (1 << 3)) && data->pwm_num >= 4)
                 for (i = 0; i < ARRAY_SIZE(sda_sf3_arrays_fan4); i++) {
@@ -1556,6 +1628,7 @@ static int __init w83627ehf_find(int sioaddr, unsigned short *addr,
         static const char __initdata sio_name_W83627DHG[] = "W83627DHG";
         static const char __initdata sio_name_W83627DHG_P[] = "W83627DHG-P";
         static const char __initdata sio_name_W83667HG[] = "W83667HG";
+        static const char __initdata sio_name_W83667HG_B[] = "W83667HG-B";
 
         u16 val;
         const char *sio_name;
@@ -1588,6 +1661,10 @@ static int __init w83627ehf_find(int sioaddr, unsigned short *addr,
                 sio_data->kind = w83667hg;
                 sio_name = sio_name_W83667HG;
                 break;
+        case SIO_W83667HG_B_ID:
+                sio_data->kind = w83667hg_b;
+                sio_name = sio_name_W83667HG_B;
+                break;
         default:
                 if (val != 0xffff)
                         pr_debug(DRVNAME ": unsupported chip ID: 0x%04x\n",
diff --git a/drivers/i2c/busses/Kconfig b/drivers/i2c/busses/Kconfig
index 15a9702e2941..6539ac2907e9 100644
--- a/drivers/i2c/busses/Kconfig
+++ b/drivers/i2c/busses/Kconfig
@@ -448,6 +448,13 @@ config I2C_NOMADIK
           If you say yes to this option, support will be included for the
           I2C interface from ST-Ericsson's Nomadik and Ux500 architectures.
 
+config I2C_NUC900
+        tristate "NUC900 I2C Driver"
+        depends on ARCH_W90X900
+        help
+          Say Y here to include support for I2C controller in the
+          Winbond/Nuvoton NUC900 based System-on-Chip devices.
+
 config I2C_OCORES
         tristate "OpenCores I2C Controller"
         depends on EXPERIMENTAL
@@ -496,8 +503,8 @@ config I2C_PMCMSP
           will be called i2c-pmcmsp.
 
 config I2C_PNX
-        tristate "I2C bus support for Philips PNX targets"
-        depends on ARCH_PNX4008
+        tristate "I2C bus support for Philips PNX and NXP LPC targets"
+        depends on ARCH_PNX4008 || ARCH_LPC32XX
         help
           This driver supports the Philips IP3204 I2C IP block master and/or
           slave controller
diff --git a/drivers/i2c/busses/Makefile b/drivers/i2c/busses/Makefile
index 936880bd1dc5..c3ef49230cba 100644
--- a/drivers/i2c/busses/Makefile
+++ b/drivers/i2c/busses/Makefile
@@ -43,6 +43,7 @@ obj-$(CONFIG_I2C_IXP2000)	+= i2c-ixp2000.o
 obj-$(CONFIG_I2C_MPC)           += i2c-mpc.o
 obj-$(CONFIG_I2C_MV64XXX)       += i2c-mv64xxx.o
 obj-$(CONFIG_I2C_NOMADIK)       += i2c-nomadik.o
+obj-$(CONFIG_I2C_NUC900)        += i2c-nuc900.o
 obj-$(CONFIG_I2C_OCORES)        += i2c-ocores.o
 obj-$(CONFIG_I2C_OMAP)          += i2c-omap.o
 obj-$(CONFIG_I2C_PASEMI)        += i2c-pasemi.o
diff --git a/drivers/i2c/busses/i2c-davinci.c b/drivers/i2c/busses/i2c-davinci.c
index 4523364e6722..2222c87876b9 100644
--- a/drivers/i2c/busses/i2c-davinci.c
+++ b/drivers/i2c/busses/i2c-davinci.c
@@ -36,14 +36,16 @@
 #include <linux/platform_device.h>
 #include <linux/io.h>
 #include <linux/slab.h>
+#include <linux/cpufreq.h>
+#include <linux/gpio.h>
 
 #include <mach/hardware.h>
-
 #include <mach/i2c.h>
 
 /* ----- global defines ----------------------------------------------- */
 
 #define DAVINCI_I2C_TIMEOUT     (1*HZ)
+#define DAVINCI_I2C_MAX_TRIES   2
 #define I2C_DAVINCI_INTR_ALL    (DAVINCI_I2C_IMR_AAS | \
                                  DAVINCI_I2C_IMR_SCD | \
                                  DAVINCI_I2C_IMR_ARDY | \
@@ -72,37 +74,29 @@
 #define DAVINCI_I2C_IVR_NACK    0x02
 #define DAVINCI_I2C_IVR_AL      0x01
 
-#define DAVINCI_I2C_STR_BB      (1 << 12)
-#define DAVINCI_I2C_STR_RSFULL  (1 << 11)
-#define DAVINCI_I2C_STR_SCD     (1 << 5)
-#define DAVINCI_I2C_STR_ARDY    (1 << 2)
-#define DAVINCI_I2C_STR_NACK    (1 << 1)
-#define DAVINCI_I2C_STR_AL      (1 << 0)
-
-#define DAVINCI_I2C_MDR_NACK    (1 << 15)
-#define DAVINCI_I2C_MDR_STT     (1 << 13)
-#define DAVINCI_I2C_MDR_STP     (1 << 11)
-#define DAVINCI_I2C_MDR_MST     (1 << 10)
-#define DAVINCI_I2C_MDR_TRX     (1 << 9)
-#define DAVINCI_I2C_MDR_XA      (1 << 8)
-#define DAVINCI_I2C_MDR_RM      (1 << 7)
-#define DAVINCI_I2C_MDR_IRS     (1 << 5)
-
-#define DAVINCI_I2C_IMR_AAS     (1 << 6)
-#define DAVINCI_I2C_IMR_SCD     (1 << 5)
-#define DAVINCI_I2C_IMR_XRDY    (1 << 4)
-#define DAVINCI_I2C_IMR_RRDY    (1 << 3)
-#define DAVINCI_I2C_IMR_ARDY    (1 << 2)
-#define DAVINCI_I2C_IMR_NACK    (1 << 1)
-#define DAVINCI_I2C_IMR_AL      (1 << 0)
-
-#define MOD_REG_BIT(val, mask, set) do { \
-        if (set) { \
-                val |= mask; \
-        } else { \
-                val &= ~mask; \
-        } \
-} while (0)
+#define DAVINCI_I2C_STR_BB      BIT(12)
+#define DAVINCI_I2C_STR_RSFULL  BIT(11)
+#define DAVINCI_I2C_STR_SCD     BIT(5)
+#define DAVINCI_I2C_STR_ARDY    BIT(2)
+#define DAVINCI_I2C_STR_NACK    BIT(1)
+#define DAVINCI_I2C_STR_AL      BIT(0)
+
+#define DAVINCI_I2C_MDR_NACK    BIT(15)
+#define DAVINCI_I2C_MDR_STT     BIT(13)
+#define DAVINCI_I2C_MDR_STP     BIT(11)
+#define DAVINCI_I2C_MDR_MST     BIT(10)
+#define DAVINCI_I2C_MDR_TRX     BIT(9)
+#define DAVINCI_I2C_MDR_XA      BIT(8)
+#define DAVINCI_I2C_MDR_RM      BIT(7)
+#define DAVINCI_I2C_MDR_IRS     BIT(5)
+
+#define DAVINCI_I2C_IMR_AAS     BIT(6)
+#define DAVINCI_I2C_IMR_SCD     BIT(5)
+#define DAVINCI_I2C_IMR_XRDY    BIT(4)
+#define DAVINCI_I2C_IMR_RRDY    BIT(3)
+#define DAVINCI_I2C_IMR_ARDY    BIT(2)
+#define DAVINCI_I2C_IMR_NACK    BIT(1)
+#define DAVINCI_I2C_IMR_AL      BIT(0)
 
 struct davinci_i2c_dev {
         struct device           *dev;
@@ -113,8 +107,13 @@ struct davinci_i2c_dev {
         u8                      *buf;
         size_t                  buf_len;
         int                     irq;
+        int                     stop;
         u8                      terminate;
         struct i2c_adapter      adapter;
+#ifdef CONFIG_CPU_FREQ
+        struct completion       xfr_complete;
+        struct notifier_block   freq_transition;
+#endif
 };
 
 /* default platform data to use if not supplied in the platform_device */
@@ -134,12 +133,59 @@ static inline u16 davinci_i2c_read_reg(struct davinci_i2c_dev *i2c_dev, int reg)
         return __raw_readw(i2c_dev->base + reg);
 }
 
-/*
- * This functions configures I2C and brings I2C out of reset.
- * This function is called during I2C init function. This function
- * also gets called if I2C encounters any errors.
+/* Generate a pulse on the i2c clock pin. */
+static void generic_i2c_clock_pulse(unsigned int scl_pin)
+{
+        u16 i;
+
+        if (scl_pin) {
+                /* Send high and low on the SCL line */
+                for (i = 0; i < 9; i++) {
+                        gpio_set_value(scl_pin, 0);
+                        udelay(20);
+                        gpio_set_value(scl_pin, 1);
+                        udelay(20);
+                }
+        }
+}
+
+/* This routine does i2c bus recovery as specified in the
+ * i2c protocol Rev. 03 section 3.16 titled "Bus clear"
  */
-static int i2c_davinci_init(struct davinci_i2c_dev *dev)
+static void i2c_recover_bus(struct davinci_i2c_dev *dev)
+{
+        u32 flag = 0;
+        struct davinci_i2c_platform_data *pdata = dev->dev->platform_data;
+
+        dev_err(dev->dev, "initiating i2c bus recovery\n");
+        /* Send NACK to the slave */
+        flag = davinci_i2c_read_reg(dev, DAVINCI_I2C_MDR_REG);
+        flag |=  DAVINCI_I2C_MDR_NACK;
+        /* write the data into mode register */
+        davinci_i2c_write_reg(dev, DAVINCI_I2C_MDR_REG, flag);
+        if (pdata)
+                generic_i2c_clock_pulse(pdata->scl_pin);
+        /* Send STOP */
+        flag = davinci_i2c_read_reg(dev, DAVINCI_I2C_MDR_REG);
+        flag |= DAVINCI_I2C_MDR_STP;
+        davinci_i2c_write_reg(dev, DAVINCI_I2C_MDR_REG, flag);
+}
+
+static inline void davinci_i2c_reset_ctrl(struct davinci_i2c_dev *i2c_dev,
+                                                                int val)
+{
+        u16 w;
+
+        w = davinci_i2c_read_reg(i2c_dev, DAVINCI_I2C_MDR_REG);
+        if (!val)       /* put I2C into reset */
+                w &= ~DAVINCI_I2C_MDR_IRS;
+        else            /* take I2C out of reset */
+                w |= DAVINCI_I2C_MDR_IRS;
+
+        davinci_i2c_write_reg(i2c_dev, DAVINCI_I2C_MDR_REG, w);
+}
+
+static void i2c_davinci_calc_clk_dividers(struct davinci_i2c_dev *dev)
 {
         struct davinci_i2c_platform_data *pdata = dev->dev->platform_data;
         u16 psc;
@@ -148,15 +194,6 @@ static int i2c_davinci_init(struct davinci_i2c_dev *dev)
         u32 clkh;
         u32 clkl;
         u32 input_clock = clk_get_rate(dev->clk);
-        u16 w;
-
-        if (!pdata)
-                pdata = &davinci_i2c_platform_data_default;
-
-        /* put I2C into reset */
-        w = davinci_i2c_read_reg(dev, DAVINCI_I2C_MDR_REG);
-        MOD_REG_BIT(w, DAVINCI_I2C_MDR_IRS, 0);
-        davinci_i2c_write_reg(dev, DAVINCI_I2C_MDR_REG, w);
 
         /* NOTE: I2C Clock divider programming info
          * As per I2C specs the following formulas provide prescaler
@@ -188,12 +225,32 @@ static int i2c_davinci_init(struct davinci_i2c_dev *dev)
         davinci_i2c_write_reg(dev, DAVINCI_I2C_CLKH_REG, clkh);
         davinci_i2c_write_reg(dev, DAVINCI_I2C_CLKL_REG, clkl);
 
+        dev_dbg(dev->dev, "input_clock = %d, CLK = %d\n", input_clock, clk);
+}
+
+/*
+ * This function configures I2C and brings I2C out of reset.
+ * This function is called during I2C init function. This function
+ * also gets called if I2C encounters any errors.
+ */
+static int i2c_davinci_init(struct davinci_i2c_dev *dev)
+{
+        struct davinci_i2c_platform_data *pdata = dev->dev->platform_data;
+
+        if (!pdata)
+                pdata = &davinci_i2c_platform_data_default;
+
+        /* put I2C into reset */
+        davinci_i2c_reset_ctrl(dev, 0);
+
+        /* compute clock dividers */
+        i2c_davinci_calc_clk_dividers(dev);
+
         /* Respond at reserved "SMBus Host" slave address" (and zero);
          * we seem to have no option to not respond...
          */
         davinci_i2c_write_reg(dev, DAVINCI_I2C_OAR_REG, 0x08);
 
-        dev_dbg(dev->dev, "input_clock = %d, CLK = %d\n", input_clock, clk);
         dev_dbg(dev->dev, "PSC  = %d\n",
                 davinci_i2c_read_reg(dev, DAVINCI_I2C_PSC_REG));
         dev_dbg(dev->dev, "CLKL = %d\n",
@@ -204,9 +261,7 @@ static int i2c_davinci_init(struct davinci_i2c_dev *dev)
                 pdata->bus_freq, pdata->bus_delay);
 
         /* Take the I2C module out of reset: */
-        w = davinci_i2c_read_reg(dev, DAVINCI_I2C_MDR_REG);
-        MOD_REG_BIT(w, DAVINCI_I2C_MDR_IRS, 1);
-        davinci_i2c_write_reg(dev, DAVINCI_I2C_MDR_REG, w);
+        davinci_i2c_reset_ctrl(dev, 1);
 
         /* Enable interrupts */
         davinci_i2c_write_reg(dev, DAVINCI_I2C_IMR_REG, I2C_DAVINCI_INTR_ALL);
@@ -221,14 +276,22 @@ static int i2c_davinci_wait_bus_not_busy(struct davinci_i2c_dev *dev,
                                          char allow_sleep)
 {
         unsigned long timeout;
+        static u16 to_cnt;
 
         timeout = jiffies + dev->adapter.timeout;
         while (davinci_i2c_read_reg(dev, DAVINCI_I2C_STR_REG)
                & DAVINCI_I2C_STR_BB) {
-                if (time_after(jiffies, timeout)) {
-                        dev_warn(dev->dev,
-                                 "timeout waiting for bus ready\n");
-                        return -ETIMEDOUT;
+                if (to_cnt <= DAVINCI_I2C_MAX_TRIES) {
+                        if (time_after(jiffies, timeout)) {
+                                dev_warn(dev->dev,
+                                "timeout waiting for bus ready\n");
+                                to_cnt++;
+                                return -ETIMEDOUT;
+                        } else {
+                                to_cnt = 0;
+                                i2c_recover_bus(dev);
+                                i2c_davinci_init(dev);
+                        }
                 }
                 if (allow_sleep)
                         schedule_timeout(1);
@@ -250,9 +313,6 @@ i2c_davinci_xfer_msg(struct i2c_adapter *adap, struct i2c_msg *msg, int stop)
         u16 w;
         int r;
 
-        if (msg->len == 0)
-                return -EINVAL;
-
         if (!pdata)
                 pdata = &davinci_i2c_platform_data_default;
         /* Introduce a delay, required for some boards (e.g Davinci EVM) */
@@ -264,6 +324,7 @@ i2c_davinci_xfer_msg(struct i2c_adapter *adap, struct i2c_msg *msg, int stop)
 
         dev->buf = msg->buf;
         dev->buf_len = msg->len;
+        dev->stop = stop;
 
         davinci_i2c_write_reg(dev, DAVINCI_I2C_CNT_REG, dev->buf_len);
 
@@ -281,23 +342,40 @@ i2c_davinci_xfer_msg(struct i2c_adapter *adap, struct i2c_msg *msg, int stop)
                 flag |= DAVINCI_I2C_MDR_TRX;
         if (stop)
                 flag |= DAVINCI_I2C_MDR_STP;
+        if (msg->len == 0) {
+                flag |= DAVINCI_I2C_MDR_RM;
+                flag &= ~DAVINCI_I2C_MDR_STP;
+        }
 
         /* Enable receive or transmit interrupts */
         w = davinci_i2c_read_reg(dev, DAVINCI_I2C_IMR_REG);
         if (msg->flags & I2C_M_RD)
-                MOD_REG_BIT(w, DAVINCI_I2C_IMR_RRDY, 1);
+                w |= DAVINCI_I2C_IMR_RRDY;
         else
-                MOD_REG_BIT(w, DAVINCI_I2C_IMR_XRDY, 1);
+                w |= DAVINCI_I2C_IMR_XRDY;
         davinci_i2c_write_reg(dev, DAVINCI_I2C_IMR_REG, w);
 
         dev->terminate = 0;
+
         /* write the data into mode register */
         davinci_i2c_write_reg(dev, DAVINCI_I2C_MDR_REG, flag);
 
+        /*
+         * First byte should be set here, not after interrupt,
+         * because transmit-data-ready interrupt can come before
+         * NACK-interrupt during sending of previous message and
+         * ICDXR may have wrong data
+         */
+        if ((!(msg->flags & I2C_M_RD)) && dev->buf_len) {
+                davinci_i2c_write_reg(dev, DAVINCI_I2C_DXR_REG, *dev->buf++);
+                dev->buf_len--;
+        }
+
         r = wait_for_completion_interruptible_timeout(&dev->cmd_complete,
                                                       dev->adapter.timeout);
         if (r == 0) {
                 dev_err(dev->dev, "controller timed out\n");
+                i2c_recover_bus(dev);
                 i2c_davinci_init(dev);
                 dev->buf_len = 0;
                 return -ETIMEDOUT;
@@ -334,7 +412,7 @@ i2c_davinci_xfer_msg(struct i2c_adapter *adap, struct i2c_msg *msg, int stop)
                         return msg->len;
                 if (stop) {
                         w = davinci_i2c_read_reg(dev, DAVINCI_I2C_MDR_REG);
-                        MOD_REG_BIT(w, DAVINCI_I2C_MDR_STP, 1);
+                        w |= DAVINCI_I2C_MDR_STP;
                         davinci_i2c_write_reg(dev, DAVINCI_I2C_MDR_REG, w);
                 }
                 return -EREMOTEIO;
@@ -367,12 +445,17 @@ i2c_davinci_xfer(struct i2c_adapter *adap, struct i2c_msg msgs[], int num)
                 if (ret < 0)
                         return ret;
         }
+
+#ifdef CONFIG_CPU_FREQ
+        complete(&dev->xfr_complete);
+#endif
+
         return num;
 }
 
 static u32 i2c_davinci_func(struct i2c_adapter *adap)
 {
-        return I2C_FUNC_I2C | (I2C_FUNC_SMBUS_EMUL & ~I2C_FUNC_SMBUS_QUICK);
+        return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
 }
 
 static void terminate_read(struct davinci_i2c_dev *dev)
@@ -431,6 +514,14 @@ static irqreturn_t i2c_davinci_isr(int this_irq, void *dev_id)
                 case DAVINCI_I2C_IVR_ARDY:
                         davinci_i2c_write_reg(dev,
                                 DAVINCI_I2C_STR_REG, DAVINCI_I2C_STR_ARDY);
+                        if (((dev->buf_len == 0) && (dev->stop != 0)) ||
+                            (dev->cmd_err & DAVINCI_I2C_STR_NACK)) {
+                                w = davinci_i2c_read_reg(dev,
+                                                         DAVINCI_I2C_MDR_REG);
+                                w |= DAVINCI_I2C_MDR_STP;
+                                davinci_i2c_write_reg(dev,
+                                                      DAVINCI_I2C_MDR_REG, w);
+                        }
                         complete(&dev->cmd_complete);
                         break;
 
@@ -462,7 +553,7 @@ static irqreturn_t i2c_davinci_isr(int this_irq, void *dev_id)
 
                                 w = davinci_i2c_read_reg(dev,
                                                          DAVINCI_I2C_IMR_REG);
-                                MOD_REG_BIT(w, DAVINCI_I2C_IMR_XRDY, 0);
+                                w &= ~DAVINCI_I2C_IMR_XRDY;
                                 davinci_i2c_write_reg(dev,
                                                       DAVINCI_I2C_IMR_REG,
                                                       w);
@@ -491,6 +582,48 @@ static irqreturn_t i2c_davinci_isr(int this_irq, void *dev_id)
         return count ? IRQ_HANDLED : IRQ_NONE;
 }
 
+#ifdef CONFIG_CPU_FREQ
+static int i2c_davinci_cpufreq_transition(struct notifier_block *nb,
+                                     unsigned long val, void *data)
+{
+        struct davinci_i2c_dev *dev;
+
+        dev = container_of(nb, struct davinci_i2c_dev, freq_transition);
+        if (val == CPUFREQ_PRECHANGE) {
+                wait_for_completion(&dev->xfr_complete);
+                davinci_i2c_reset_ctrl(dev, 0);
+        } else if (val == CPUFREQ_POSTCHANGE) {
+                i2c_davinci_calc_clk_dividers(dev);
+                davinci_i2c_reset_ctrl(dev, 1);
+        }
+
+        return 0;
+}
+
+static inline int i2c_davinci_cpufreq_register(struct davinci_i2c_dev *dev)
+{
+        dev->freq_transition.notifier_call = i2c_davinci_cpufreq_transition;
+
+        return cpufreq_register_notifier(&dev->freq_transition,
+                                         CPUFREQ_TRANSITION_NOTIFIER);
+}
+
+static inline void i2c_davinci_cpufreq_deregister(struct davinci_i2c_dev *dev)
+{
+        cpufreq_unregister_notifier(&dev->freq_transition,
+                                    CPUFREQ_TRANSITION_NOTIFIER);
+}
+#else
+static inline int i2c_davinci_cpufreq_register(struct davinci_i2c_dev *dev)
+{
+        return 0;
+}
+
+static inline void i2c_davinci_cpufreq_deregister(struct davinci_i2c_dev *dev)
+{
+}
+#endif
+
 static struct i2c_algorithm i2c_davinci_algo = {
         .master_xfer    = i2c_davinci_xfer,
         .functionality  = i2c_davinci_func,
@@ -530,6 +663,9 @@ static int davinci_i2c_probe(struct platform_device *pdev)
         }
 
         init_completion(&dev->cmd_complete);
+#ifdef CONFIG_CPU_FREQ
+        init_completion(&dev->xfr_complete);
+#endif
         dev->dev = get_device(&pdev->dev);
         dev->irq = irq->start;
         platform_set_drvdata(pdev, dev);
@@ -541,7 +677,12 @@ static int davinci_i2c_probe(struct platform_device *pdev)
         }
         clk_enable(dev->clk);
 
-        dev->base = (void __iomem *)IO_ADDRESS(mem->start);
+        dev->base = ioremap(mem->start, resource_size(mem));
+        if (!dev->base) {
+                r = -EBUSY;
+                goto err_mem_ioremap;
+        }
+
         i2c_davinci_init(dev);
 
         r = request_irq(dev->irq, i2c_davinci_isr, 0, pdev->name, dev);
@@ -550,6 +691,12 @@ static int davinci_i2c_probe(struct platform_device *pdev)
                 goto err_unuse_clocks;
         }
 
+        r = i2c_davinci_cpufreq_register(dev);
+        if (r) {
+                dev_err(&pdev->dev, "failed to register cpufreq\n");
+                goto err_free_irq;
+        }
+
         adap = &dev->adapter;
         i2c_set_adapdata(adap, dev);
         adap->owner = THIS_MODULE;
@@ -571,6 +718,8 @@ static int davinci_i2c_probe(struct platform_device *pdev)
 err_free_irq:
         free_irq(dev->irq, dev);
 err_unuse_clocks:
+        iounmap(dev->base);
+err_mem_ioremap:
         clk_disable(dev->clk);
         clk_put(dev->clk);
         dev->clk = NULL;
@@ -589,6 +738,8 @@ static int davinci_i2c_remove(struct platform_device *pdev)
         struct davinci_i2c_dev *dev = platform_get_drvdata(pdev);
         struct resource *mem;
 
+        i2c_davinci_cpufreq_deregister(dev);
+
         platform_set_drvdata(pdev, NULL);
         i2c_del_adapter(&dev->adapter);
         put_device(&pdev->dev);
@@ -599,6 +750,7 @@ static int davinci_i2c_remove(struct platform_device *pdev)
 
         davinci_i2c_write_reg(dev, DAVINCI_I2C_MDR_REG, 0);
         free_irq(IRQ_I2C, dev);
+        iounmap(dev->base);
         kfree(dev);
 
         mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
@@ -606,6 +758,41 @@ static int davinci_i2c_remove(struct platform_device *pdev)
         return 0;
 }
 
+#ifdef CONFIG_PM
+static int davinci_i2c_suspend(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct davinci_i2c_dev *i2c_dev = platform_get_drvdata(pdev);
+
+        /* put I2C into reset */
+        davinci_i2c_reset_ctrl(i2c_dev, 0);
+        clk_disable(i2c_dev->clk);
+
+        return 0;
+}
+
+static int davinci_i2c_resume(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct davinci_i2c_dev *i2c_dev = platform_get_drvdata(pdev);
+
+        clk_enable(i2c_dev->clk);
+        /* take I2C out of reset */
+        davinci_i2c_reset_ctrl(i2c_dev, 1);
+
+        return 0;
+}
+
+static const struct dev_pm_ops davinci_i2c_pm = {
+        .suspend        = davinci_i2c_suspend,
+        .resume         = davinci_i2c_resume,
+};
+
+#define davinci_i2c_pm_ops (&davinci_i2c_pm)
+#else
+#define davinci_i2c_pm_ops NULL
+#endif
+
 /* work with hotplug and coldplug */
 MODULE_ALIAS("platform:i2c_davinci");
 
@@ -615,6 +802,7 @@ static struct platform_driver davinci_i2c_driver = {
         .driver         = {
                 .name   = "i2c_davinci",
                 .owner  = THIS_MODULE,
+                .pm     = davinci_i2c_pm_ops,
         },
 };
 
diff --git a/drivers/i2c/busses/i2c-nuc900.c b/drivers/i2c/busses/i2c-nuc900.c
new file mode 100644
index 000000000000..92d770d7bbc2
--- /dev/null
+++ b/drivers/i2c/busses/i2c-nuc900.c
@@ -0,0 +1,709 @@
+/*
+ * linux/drivers/i2c/busses/i2c-nuc900.c
+ *
+ * Copyright (c) 2010 Nuvoton technology corporation.
+ *
+ * This driver based on S3C2410 I2C driver of Ben Dooks <ben-Y5A6D6n0/KfQXOPxS62xeg@public.gmane.org>.
+ * Written by Wan ZongShun <mcuos.com-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation;version 2 of the License.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+
+#include <linux/i2c.h>
+#include <linux/i2c-id.h>
+#include <linux/init.h>
+#include <linux/time.h>
+#include <linux/interrupt.h>
+#include <linux/delay.h>
+#include <linux/errno.h>
+#include <linux/err.h>
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+#include <linux/cpufreq.h>
+#include <linux/slab.h>
+#include <linux/io.h>
+
+#include <mach/mfp.h>
+#include <mach/i2c.h>
+
+/* nuc900 i2c registers offset */
+
+#define CSR             0x00
+#define DIVIDER         0x04
+#define CMDR            0x08
+#define SWR             0x0C
+#define RXR             0x10
+#define TXR             0x14
+
+/* nuc900 i2c CSR register bits */
+
+#define IRQEN           0x003
+#define I2CBUSY         0x400
+#define I2CSTART        0x018
+#define IRQFLAG         0x004
+#define ARBIT_LOST      0x200
+#define SLAVE_ACK       0x800
+
+/* nuc900 i2c CMDR register bits */
+
+#define I2C_CMD_START   0x10
+#define I2C_CMD_STOP    0x08
+#define I2C_CMD_READ    0x04
+#define I2C_CMD_WRITE   0x02
+#define I2C_CMD_NACK    0x01
+
+/* i2c controller state */
+
+enum nuc900_i2c_state {
+        STATE_IDLE,
+        STATE_START,
+        STATE_READ,
+        STATE_WRITE,
+        STATE_STOP
+};
+
+/* i2c controller private data */
+
+struct nuc900_i2c {
+        spinlock_t              lock;
+        wait_queue_head_t       wait;
+
+        struct i2c_msg          *msg;
+        unsigned int            msg_num;
+        unsigned int            msg_idx;
+        unsigned int            msg_ptr;
+        unsigned int            irq;
+
+        enum nuc900_i2c_state   state;
+
+        void __iomem            *regs;
+        struct clk              *clk;
+        struct device           *dev;
+        struct resource         *ioarea;
+        struct i2c_adapter      adap;
+};
+
+/* nuc900_i2c_master_complete
+ *
+ * complete the message and wake up the caller, using the given return code,
+ * or zero to mean ok.
+*/
+
+static inline void nuc900_i2c_master_complete(struct nuc900_i2c *i2c, int ret)
+{
+        dev_dbg(i2c->dev, "master_complete %d\n", ret);
+
+        i2c->msg_ptr = 0;
+        i2c->msg = NULL;
+        i2c->msg_idx++;
+        i2c->msg_num = 0;
+        if (ret)
+                i2c->msg_idx = ret;
+
+        wake_up(&i2c->wait);
+}
+
+/* irq enable/disable functions */
+
+static inline void nuc900_i2c_disable_irq(struct nuc900_i2c *i2c)
+{
+        unsigned long tmp;
+
+        tmp = readl(i2c->regs + CSR);
+        writel(tmp & ~IRQEN, i2c->regs + CSR);
+}
+
+static inline void nuc900_i2c_enable_irq(struct nuc900_i2c *i2c)
+{
+        unsigned long tmp;
+
+        tmp = readl(i2c->regs + CSR);
+        writel(tmp | IRQEN, i2c->regs + CSR);
+}
+
+
+/* nuc900_i2c_message_start
+ *
+ * put the start of a message onto the bus
+*/
+
+static void nuc900_i2c_message_start(struct nuc900_i2c *i2c,
+                                      struct i2c_msg *msg)
+{
+        unsigned int addr = (msg->addr & 0x7f) << 1;
+
+        if (msg->flags & I2C_M_RD)
+                addr |= 0x1;
+        writel(addr & 0xff, i2c->regs + TXR);
+        writel(I2C_CMD_START | I2C_CMD_WRITE, i2c->regs + CMDR);
+}
+
+static inline void nuc900_i2c_stop(struct nuc900_i2c *i2c, int ret)
+{
+
+        dev_dbg(i2c->dev, "STOP\n");
+
+        /* stop the transfer */
+        i2c->state = STATE_STOP;
+        writel(I2C_CMD_STOP, i2c->regs + CMDR);
+
+        nuc900_i2c_master_complete(i2c, ret);
+        nuc900_i2c_disable_irq(i2c);
+}
+
+/* helper functions to determine the current state in the set of
+ * messages we are sending
+*/
+
+/* is_lastmsg()
+ *
+ * returns TRUE if the current message is the last in the set
+*/
+
+static inline int is_lastmsg(struct nuc900_i2c *i2c)
+{
+        return i2c->msg_idx >= (i2c->msg_num - 1);
+}
+
+/* is_msglast
+ *
+ * returns TRUE if we this is the last byte in the current message
+*/
+
+static inline int is_msglast(struct nuc900_i2c *i2c)
+{
+        return i2c->msg_ptr == i2c->msg->len-1;
+}
+
+/* is_msgend
+ *
+ * returns TRUE if we reached the end of the current message
+*/
+
+static inline int is_msgend(struct nuc900_i2c *i2c)
+{
+        return i2c->msg_ptr >= i2c->msg->len;
+}
+
+/* i2c_nuc900_irq_nextbyte
+ *
+ * process an interrupt and work out what to do
+ */
+
+static void i2c_nuc900_irq_nextbyte(struct nuc900_i2c *i2c,
+                                                        unsigned long iicstat)
+{
+        unsigned char byte;
+
+        switch (i2c->state) {
+
+        case STATE_IDLE:
+                dev_err(i2c->dev, "%s: called in STATE_IDLE\n", __func__);
+                break;
+
+        case STATE_STOP:
+                dev_err(i2c->dev, "%s: called in STATE_STOP\n", __func__);
+                nuc900_i2c_disable_irq(i2c);
+                break;
+
+        case STATE_START:
+                /* last thing we did was send a start condition on the
+                 * bus, or started a new i2c message
+                 */
+
+                if (iicstat & SLAVE_ACK &&
+                    !(i2c->msg->flags & I2C_M_IGNORE_NAK)) {
+                        /* ack was not received... */
+
+                        dev_dbg(i2c->dev, "ack was not received\n");
+                        nuc900_i2c_stop(i2c, -ENXIO);
+                        break;
+                }
+
+                if (i2c->msg->flags & I2C_M_RD)
+                        i2c->state = STATE_READ;
+                else
+                        i2c->state = STATE_WRITE;
+
+                /* terminate the transfer if there is nothing to do
+                 * as this is used by the i2c probe to find devices.
+                */
+
+                if (is_lastmsg(i2c) && i2c->msg->len == 0) {
+                        nuc900_i2c_stop(i2c, 0);
+                        break;
+                }
+
+                if (i2c->state == STATE_READ)
+                        goto prepare_read;
+
+                /* fall through to the write state, as we will need to
+                 * send a byte as well
+                */
+
+        case STATE_WRITE:
+                /* we are writing data to the device... check for the
+                 * end of the message, and if so, work out what to do
+                 */
+
+                if (!(i2c->msg->flags & I2C_M_IGNORE_NAK)) {
+                        if (iicstat & SLAVE_ACK) {
+                                dev_dbg(i2c->dev, "WRITE: No Ack\n");
+
+                                nuc900_i2c_stop(i2c, -ECONNREFUSED);
+                                break;
+                        }
+                }
+
+retry_write:
+
+                if (!is_msgend(i2c)) {
+                        byte = i2c->msg->buf[i2c->msg_ptr++];
+                        writeb(byte, i2c->regs + TXR);
+                        writel(I2C_CMD_WRITE, i2c->regs + CMDR);
+
+                } else if (!is_lastmsg(i2c)) {
+                        /* we need to go to the next i2c message */
+
+                        dev_dbg(i2c->dev, "WRITE: Next Message\n");
+
+                        i2c->msg_ptr = 0;
+                        i2c->msg_idx++;
+                        i2c->msg++;
+
+                        /* check to see if we need to do another message */
+                        if (i2c->msg->flags & I2C_M_NOSTART) {
+
+                                if (i2c->msg->flags & I2C_M_RD) {
+                                        /* cannot do this, the controller
+                                         * forces us to send a new START
+                                         * when we change direction
+                                        */
+
+                                        nuc900_i2c_stop(i2c, -EINVAL);
+                                }
+
+                                goto retry_write;
+                        } else {
+                                /* send the new start */
+                                nuc900_i2c_message_start(i2c, i2c->msg);
+                                i2c->state = STATE_START;
+                        }
+
+                } else {
+                        /* send stop */
+
+                        nuc900_i2c_stop(i2c, 0);
+                }
+                break;
+
+        case STATE_READ:
+                /* we have a byte of data in the data register, do
+                 * something with it, and then work out wether we are
+                 * going to do any more read/write
+                 */
+
+                byte = readb(i2c->regs + RXR);
+                i2c->msg->buf[i2c->msg_ptr++] = byte;
+
+prepare_read:
+                if (is_msglast(i2c)) {
+                        /* last byte of buffer */
+
+                        if (is_lastmsg(i2c))
+                                writel(I2C_CMD_READ | I2C_CMD_NACK,
+                                                        i2c->regs + CMDR);
+
+                } else if (is_msgend(i2c)) {
+                        /* ok, we've read the entire buffer, see if there
+                         * is anything else we need to do
+                        */
+
+                        if (is_lastmsg(i2c)) {
+                                /* last message, send stop and complete */
+                                dev_dbg(i2c->dev, "READ: Send Stop\n");
+
+                                nuc900_i2c_stop(i2c, 0);
+                        } else {
+                                /* go to the next transfer */
+                                dev_dbg(i2c->dev, "READ: Next Transfer\n");
+
+                                i2c->msg_ptr = 0;
+                                i2c->msg_idx++;
+                                i2c->msg++;
+
+                                writel(I2C_CMD_READ, i2c->regs + CMDR);
+                        }
+
+                } else {
+                        writel(I2C_CMD_READ, i2c->regs + CMDR);
+                }
+
+                break;
+        }
+}
+
+/* nuc900_i2c_irq
+ *
+ * top level IRQ servicing routine
+*/
+
+static irqreturn_t nuc900_i2c_irq(int irqno, void *dev_id)
+{
+        struct nuc900_i2c *i2c = dev_id;
+        unsigned long status;
+
+        status = readl(i2c->regs + CSR);
+        writel(status | IRQFLAG, i2c->regs + CSR);
+
+        if (status & ARBIT_LOST) {
+                /* deal with arbitration loss */
+                dev_err(i2c->dev, "deal with arbitration loss\n");
+                goto out;
+        }
+
+        if (i2c->state == STATE_IDLE) {
+                dev_dbg(i2c->dev, "IRQ: error i2c->state == IDLE\n");
+                goto out;
+        }
+
+        /* pretty much this leaves us with the fact that we've
+         * transmitted or received whatever byte we last sent
+        */
+
+        i2c_nuc900_irq_nextbyte(i2c, status);
+
+ out:
+        return IRQ_HANDLED;
+}
+
+
+/* nuc900_i2c_set_master
+ *
+ * get the i2c bus for a master transaction
+*/
+
+static int nuc900_i2c_set_master(struct nuc900_i2c *i2c)
+{
+        int timeout = 400;
+
+        while (timeout-- > 0) {
+                if (((readl(i2c->regs + SWR) & I2CSTART) == I2CSTART) &&
+                                ((readl(i2c->regs + CSR) & I2CBUSY) == 0)) {
+                        return 0;
+                }
+
+                msleep(1);
+        }
+
+        return -ETIMEDOUT;
+}
+
+/* nuc900_i2c_doxfer
+ *
+ * this starts an i2c transfer
+*/
+
+static int nuc900_i2c_doxfer(struct nuc900_i2c *i2c,
+                              struct i2c_msg *msgs, int num)
+{
+        unsigned long iicstat, timeout;
+        int spins = 20;
+        int ret;
+
+        ret = nuc900_i2c_set_master(i2c);
+        if (ret != 0) {
+                dev_err(i2c->dev, "cannot get bus (error %d)\n", ret);
+                ret = -EAGAIN;
+                goto out;
+        }
+
+        spin_lock_irq(&i2c->lock);
+
+        i2c->msg     = msgs;
+        i2c->msg_num = num;
+        i2c->msg_ptr = 0;
+        i2c->msg_idx = 0;
+        i2c->state   = STATE_START;
+
+        nuc900_i2c_message_start(i2c, msgs);
+        spin_unlock_irq(&i2c->lock);
+
+        timeout = wait_event_timeout(i2c->wait, i2c->msg_num == 0, HZ * 5);
+
+        ret = i2c->msg_idx;
+
+        /* having these next two as dev_err() makes life very
+         * noisy when doing an i2cdetect
+        */
+
+        if (timeout == 0)
+                dev_dbg(i2c->dev, "timeout\n");
+        else if (ret != num)
+                dev_dbg(i2c->dev, "incomplete xfer (%d)\n", ret);
+
+        /* ensure the stop has been through the bus */
+
+        dev_dbg(i2c->dev, "waiting for bus idle\n");
+
+        /* first, try busy waiting briefly */
+        do {
+                iicstat = readl(i2c->regs + CSR);
+        } while ((iicstat & I2CBUSY) && --spins);
+
+        /* if that timed out sleep */
+        if (!spins) {
+                msleep(1);
+                iicstat = readl(i2c->regs + CSR);
+        }
+
+        if (iicstat & I2CBUSY)
+                dev_warn(i2c->dev, "timeout waiting for bus idle\n");
+
+ out:
+        return ret;
+}
+
+/* nuc900_i2c_xfer
+ *
+ * first port of call from the i2c bus code when an message needs
+ * transferring across the i2c bus.
+*/
+
+static int nuc900_i2c_xfer(struct i2c_adapter *adap,
+                        struct i2c_msg *msgs, int num)
+{
+        struct nuc900_i2c *i2c = (struct nuc900_i2c *)adap->algo_data;
+        int retry;
+        int ret;
+
+        nuc900_i2c_enable_irq(i2c);
+
+        for (retry = 0; retry < adap->retries; retry++) {
+
+                ret = nuc900_i2c_doxfer(i2c, msgs, num);
+
+                if (ret != -EAGAIN)
+                        return ret;
+
+                dev_dbg(i2c->dev, "Retrying transmission (%d)\n", retry);
+
+                udelay(100);
+        }
+
+        return -EREMOTEIO;
+}
+
+/* declare our i2c functionality */
+static u32 nuc900_i2c_func(struct i2c_adapter *adap)
+{
+        return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL | I2C_FUNC_PROTOCOL_MANGLING;
+}
+
+/* i2c bus registration info */
+
+static const struct i2c_algorithm nuc900_i2c_algorithm = {
+        .master_xfer            = nuc900_i2c_xfer,
+        .functionality          = nuc900_i2c_func,
+};
+
+/* nuc900_i2c_probe
+ *
+ * called by the bus driver when a suitable device is found
+*/
+
+static int __devinit nuc900_i2c_probe(struct platform_device *pdev)
+{
+        struct nuc900_i2c *i2c;
+        struct nuc900_platform_i2c *pdata;
+        struct resource *res;
+        int ret;
+
+        pdata = pdev->dev.platform_data;
+        if (!pdata) {
+                dev_err(&pdev->dev, "no platform data\n");
+                return -EINVAL;
+        }
+
+        i2c = kzalloc(sizeof(struct nuc900_i2c), GFP_KERNEL);
+        if (!i2c) {
+                dev_err(&pdev->dev, "no memory for state\n");
+                return -ENOMEM;
+        }
+
+        strlcpy(i2c->adap.name, "nuc900-i2c0", sizeof(i2c->adap.name));
+        i2c->adap.owner   = THIS_MODULE;
+        i2c->adap.algo    = &nuc900_i2c_algorithm;
+        i2c->adap.retries = 2;
+        i2c->adap.class   = I2C_CLASS_HWMON | I2C_CLASS_SPD;
+
+        spin_lock_init(&i2c->lock);
+        init_waitqueue_head(&i2c->wait);
+
+        /* find the clock and enable it */
+
+        i2c->dev = &pdev->dev;
+        i2c->clk = clk_get(&pdev->dev, NULL);
+        if (IS_ERR(i2c->clk)) {
+                dev_err(&pdev->dev, "cannot get clock\n");
+                ret = -ENOENT;
+                goto err_noclk;
+        }
+
+        dev_dbg(&pdev->dev, "clock source %p\n", i2c->clk);
+
+        clk_enable(i2c->clk);
+
+        /* map the registers */
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (res == NULL) {
+                dev_err(&pdev->dev, "cannot find IO resource\n");
+                ret = -ENOENT;
+                goto err_clk;
+        }
+
+        i2c->ioarea = request_mem_region(res->start, resource_size(res),
+                                         pdev->name);
+
+        if (i2c->ioarea == NULL) {
+                dev_err(&pdev->dev, "cannot request IO\n");
+                ret = -ENXIO;
+                goto err_clk;
+        }
+
+        i2c->regs = ioremap(res->start, resource_size(res));
+
+        if (i2c->regs == NULL) {
+                dev_err(&pdev->dev, "cannot map IO\n");
+                ret = -ENXIO;
+                goto err_ioarea;
+        }
+
+        dev_dbg(&pdev->dev, "registers %p (%p, %p)\n",
+                i2c->regs, i2c->ioarea, res);
+
+        /* setup info block for the i2c core */
+
+        i2c->adap.algo_data = i2c;
+        i2c->adap.dev.parent = &pdev->dev;
+
+        mfp_set_groupg(&pdev->dev);
+
+        clk_get_rate(i2c->clk);
+
+        ret = (i2c->clk.apbfreq)/(pdata->bus_freq * 5) - 1;
+        writel(ret & 0xffff, i2c->regs + DIVIDER);
+
+        /* find the IRQ for this unit (note, this relies on the init call to
+         * ensure no current IRQs pending
+         */
+
+        i2c->irq = ret = platform_get_irq(pdev, 0);
+        if (ret <= 0) {
+                dev_err(&pdev->dev, "cannot find IRQ\n");
+                goto err_iomap;
+        }
+
+        ret = request_irq(i2c->irq, nuc900_i2c_irq, IRQF_DISABLED | IRQF_SHARED,
+                          dev_name(&pdev->dev), i2c);
+
+        if (ret != 0) {
+                dev_err(&pdev->dev, "cannot claim IRQ %d\n", i2c->irq);
+                goto err_iomap;
+        }
+
+        /* Note, previous versions of the driver used i2c_add_adapter()
+         * to add the bus at any number. We now pass the bus number via
+         * the platform data, so if unset it will now default to always
+         * being bus 0.
+         */
+
+        i2c->adap.nr = pdata->bus_num;
+
+        ret = i2c_add_numbered_adapter(&i2c->adap);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "failed to add bus to i2c core\n");
+                goto err_irq;
+        }
+
+        platform_set_drvdata(pdev, i2c);
+
+        dev_info(&pdev->dev, "%s: NUC900 I2C adapter\n",
+                                                dev_name(&i2c->adap.dev));
+        return 0;
+
+ err_irq:
+        free_irq(i2c->irq, i2c);
+
+ err_iomap:
+        iounmap(i2c->regs);
+
+ err_ioarea:
+        release_resource(i2c->ioarea);
+        kfree(i2c->ioarea);
+
+ err_clk:
+        clk_disable(i2c->clk);
+        clk_put(i2c->clk);
+
+ err_noclk:
+        kfree(i2c);
+        return ret;
+}
+
+/* nuc900_i2c_remove
+ *
+ * called when device is removed from the bus
+*/
+
+static int __devexit nuc900_i2c_remove(struct platform_device *pdev)
+{
+        struct nuc900_i2c *i2c = platform_get_drvdata(pdev);
+
+        i2c_del_adapter(&i2c->adap);
+        free_irq(i2c->irq, i2c);
+
+        clk_disable(i2c->clk);
+        clk_put(i2c->clk);
+
+        iounmap(i2c->regs);
+
+        release_resource(i2c->ioarea);
+        kfree(i2c->ioarea);
+        kfree(i2c);
+
+        return 0;
+}
+
+static struct platform_driver nuc900_i2c_driver = {
+        .probe          = nuc900_i2c_probe,
+        .remove         = __devexit_p(nuc900_i2c_remove),
+        .driver         = {
+                .owner  = THIS_MODULE,
+                .name   = "nuc900-i2c0",
+        },
+};
+
+static int __init i2c_adap_nuc900_init(void)
+{
+        return platform_driver_register(&nuc900_i2c_driver);
+}
+
+static void __exit i2c_adap_nuc900_exit(void)
+{
+        platform_driver_unregister(&nuc900_i2c_driver);
+}
+subsys_initcall(i2c_adap_nuc900_init);
+module_exit(i2c_adap_nuc900_exit);
+
+MODULE_DESCRIPTION("NUC900 I2C Bus driver");
+MODULE_AUTHOR("Wan ZongShun, <mcuos.com-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org>");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:nuc900-i2c0");
diff --git a/drivers/i2c/busses/i2c-pxa.c b/drivers/i2c/busses/i2c-pxa.c
index 020ff23d762f..c94e51b2651e 100644
--- a/drivers/i2c/busses/i2c-pxa.c
+++ b/drivers/i2c/busses/i2c-pxa.c
@@ -1001,7 +1001,7 @@ static int i2c_pxa_probe(struct platform_device *dev)
         struct pxa_i2c *i2c;
         struct resource *res;
         struct i2c_pxa_platform_data *plat = dev->dev.platform_data;
-        struct platform_device_id *id = platform_get_device_id(dev);
+        const struct platform_device_id *id = platform_get_device_id(dev);
         int ret;
         int irq;
 
diff --git a/drivers/idle/Kconfig b/drivers/idle/Kconfig
index fb5c5186d4aa..8489eb58a52c 100644
--- a/drivers/idle/Kconfig
+++ b/drivers/idle/Kconfig
@@ -1,9 +1,8 @@
 config INTEL_IDLE
-        tristate "Cpuidle Driver for Intel Processors"
+        bool "Cpuidle Driver for Intel Processors"
         depends on CPU_IDLE
         depends on X86
         depends on CPU_SUP_INTEL
-        depends on EXPERIMENTAL
         help
           Enable intel_idle, a cpuidle driver that includes knowledge of
           native Intel hardware idle features.  The acpi_idle driver
diff --git a/drivers/idle/intel_idle.c b/drivers/idle/intel_idle.c
index 03d202b1ff27..a10152bb1427 100755
--- a/drivers/idle/intel_idle.c
+++ b/drivers/idle/intel_idle.c
@@ -77,10 +77,8 @@ static struct cpuidle_driver intel_idle_driver = {
 };
 /* intel_idle.max_cstate=0 disables driver */
 static int max_cstate = MWAIT_MAX_NUM_CSTATES - 1;
-static int power_policy = 7; /* 0 = max perf; 15 = max powersave */
 
-static unsigned int substates;
-static int (*choose_substate)(int);
+static unsigned int mwait_substates;
 
 /* Reliable LAPIC Timer States, bit 1 for C1 etc.  */
 static unsigned int lapic_timer_reliable_states;
@@ -168,41 +166,6 @@ static struct cpuidle_state atom_cstates[MWAIT_MAX_NUM_CSTATES] = {
                 .enter = NULL },        /* disabled */
 };
 
-/*
- * choose_tunable_substate()
- *
- * Run-time decision on which C-state substate to invoke
- * If power_policy = 0, choose shallowest substate (0)
- * If power_policy = 15, choose deepest substate
- * If power_policy = middle, choose middle substate etc.
- */
-static int choose_tunable_substate(int cstate)
-{
-        unsigned int num_substates;
-        unsigned int substate_choice;
-
-        power_policy &= 0xF;    /* valid range: 0-15 */
-        cstate &= 7;    /* valid range: 0-7 */
-
-        num_substates = (substates >> ((cstate) * 4)) & MWAIT_SUBSTATE_MASK;
-
-        if (num_substates <= 1)
-                return 0;
-
-        substate_choice = ((power_policy + (power_policy + 1) *
-                                (num_substates - 1)) / 16);
-
-        return substate_choice;
-}
-
-/*
- * choose_zero_substate()
- */
-static int choose_zero_substate(int cstate)
-{
-        return 0;
-}
-
 /**
  * intel_idle
  * @dev: cpuidle_device
@@ -220,8 +183,6 @@ static int intel_idle(struct cpuidle_device *dev, struct cpuidle_state *state)
 
         cstate = (((eax) >> MWAIT_SUBSTATE_SIZE) & MWAIT_CSTATE_MASK) + 1;
 
-        eax = eax + (choose_substate)(cstate);
-
         local_irq_disable();
 
         if (!(lapic_timer_reliable_states & (1 << (cstate))))
@@ -259,7 +220,7 @@ static int intel_idle(struct cpuidle_device *dev, struct cpuidle_state *state)
  */
 static int intel_idle_probe(void)
 {
-        unsigned int eax, ebx, ecx, edx;
+        unsigned int eax, ebx, ecx;
 
         if (max_cstate == 0) {
                 pr_debug(PREFIX "disabled\n");
@@ -275,17 +236,13 @@ static int intel_idle_probe(void)
         if (boot_cpu_data.cpuid_level < CPUID_MWAIT_LEAF)
                 return -ENODEV;
 
-        cpuid(CPUID_MWAIT_LEAF, &eax, &ebx, &ecx, &edx);
+        cpuid(CPUID_MWAIT_LEAF, &eax, &ebx, &ecx, &mwait_substates);
 
         if (!(ecx & CPUID5_ECX_EXTENSIONS_SUPPORTED) ||
                 !(ecx & CPUID5_ECX_INTERRUPT_BREAK))
                         return -ENODEV;
-#ifdef DEBUG
-        if (substates == 0)     /* can over-ride via modparam */
-#endif
-                substates = edx;
 
-        pr_debug(PREFIX "MWAIT substates: 0x%x\n", substates);
+        pr_debug(PREFIX "MWAIT substates: 0x%x\n", mwait_substates);
 
         if (boot_cpu_has(X86_FEATURE_ARAT))     /* Always Reliable APIC Timer */
                 lapic_timer_reliable_states = 0xFFFFFFFF;
@@ -299,18 +256,18 @@ static int intel_idle_probe(void)
         case 0x1E:      /* Core i7 and i5 Processor - Lynnfield Jasper Forest */
         case 0x1F:      /* Core i7 and i5 Processor - Nehalem */
         case 0x2E:      /* Nehalem-EX Xeon */
+        case 0x2F:      /* Westmere-EX Xeon */
                 lapic_timer_reliable_states = (1 << 1);  /* C1 */
 
         case 0x25:      /* Westmere */
         case 0x2C:      /* Westmere */
                 cpuidle_state_table = nehalem_cstates;
-                choose_substate = choose_tunable_substate;
                 break;
 
         case 0x1C:      /* 28 - Atom Processor */
+        case 0x26:      /* 38 - Lincroft Atom Processor */
                 lapic_timer_reliable_states = (1 << 2) | (1 << 1); /* C2, C1 */
                 cpuidle_state_table = atom_cstates;
-                choose_substate = choose_zero_substate;
                 break;
 #ifdef FUTURE_USE
         case 0x17:      /* 23 - Core 2 Duo */
@@ -376,7 +333,7 @@ static int intel_idle_cpuidle_devices_init(void)
                         }
 
                         /* does the state exist in CPUID.MWAIT? */
-                        num_substates = (substates >> ((cstate) * 4))
+                        num_substates = (mwait_substates >> ((cstate) * 4))
                                                 & MWAIT_SUBSTATE_MASK;
                         if (num_substates == 0)
                                 continue;
@@ -450,11 +407,7 @@ static void __exit intel_idle_exit(void)
 module_init(intel_idle_init);
 module_exit(intel_idle_exit);
 
-module_param(power_policy, int, 0644);
 module_param(max_cstate, int, 0444);
-#ifdef DEBUG
-module_param(substates, int, 0444);
-#endif
 
 MODULE_AUTHOR("Len Brown <len.brown@intel.com>");
 MODULE_DESCRIPTION("Cpuidle driver for Intel Hardware v" INTEL_IDLE_VERSION);
diff --git a/drivers/message/fusion/mptbase.c b/drivers/message/fusion/mptbase.c
index b8f1719d7c02..6837a8ef9371 100644
--- a/drivers/message/fusion/mptbase.c
+++ b/drivers/message/fusion/mptbase.c
@@ -626,6 +626,7 @@ mptbase_reply(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req, MPT_FRAME_HDR *reply)
  *      mpt_register - Register protocol-specific main callback handler.
  *      @cbfunc: callback function pointer
  *      @dclass: Protocol driver's class (%MPT_DRIVER_CLASS enum value)
+ *      @func_name: call function's name
  *
  *      This routine is called by a protocol-specific driver (SCSI host,
  *      LAN, SCSI target) to register its reply callback routine.  Each
@@ -6559,7 +6560,7 @@ procmpt_destroy(void)
 }
 
 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
-/**
+/*
  *      Handles read request from /proc/mpt/summary or /proc/mpt/iocN/summary.
  */
 static void seq_mpt_print_ioc_summary(MPT_ADAPTER *ioc, struct seq_file *m, int showlan);
@@ -8003,6 +8004,7 @@ mpt_spi_log_info(MPT_ADAPTER *ioc, u32 log_info)
  *      mpt_sas_log_info - Log information returned from SAS IOC.
  *      @ioc: Pointer to MPT_ADAPTER structure
  *      @log_info: U32 LogInfo reply word from the IOC
+ *      @cb_idx: callback function's handle
  *
  *      Refer to lsi/mpi_log_sas.h.
  **/
@@ -8049,7 +8051,7 @@ union loginfo_type {
                         code_desc = ir_code_str[sas_loginfo.dw.code];
                         if (sas_loginfo.dw.subcode >=
                             ARRAY_SIZE(raid_sub_code_str))
-                        break;
+                                break;
                         if (sas_loginfo.dw.code == 0)
                                 sub_code_desc =
                                     raid_sub_code_str[sas_loginfo.dw.subcode];
diff --git a/drivers/mmc/host/mmc_spi.c b/drivers/mmc/host/mmc_spi.c
index 1145ea0792e6..62a35822003e 100644
--- a/drivers/mmc/host/mmc_spi.c
+++ b/drivers/mmc/host/mmc_spi.c
@@ -182,7 +182,7 @@ mmc_spi_readbytes(struct mmc_spi_host *host, unsigned len)
                                 host->data_dma, sizeof(*host->data),
                                 DMA_FROM_DEVICE);
 
-        status = spi_sync(host->spi, &host->readback);
+        status = spi_sync_locked(host->spi, &host->readback);
 
         if (host->dma_dev)
                 dma_sync_single_for_cpu(host->dma_dev,
@@ -541,7 +541,7 @@ mmc_spi_command_send(struct mmc_spi_host *host,
                                 host->data_dma, sizeof(*host->data),
                                 DMA_BIDIRECTIONAL);
         }
-        status = spi_sync(host->spi, &host->m);
+        status = spi_sync_locked(host->spi, &host->m);
 
         if (host->dma_dev)
                 dma_sync_single_for_cpu(host->dma_dev,
@@ -685,7 +685,7 @@ mmc_spi_writeblock(struct mmc_spi_host *host, struct spi_transfer *t,
                                 host->data_dma, sizeof(*scratch),
                                 DMA_BIDIRECTIONAL);
 
-        status = spi_sync(spi, &host->m);
+        status = spi_sync_locked(spi, &host->m);
 
         if (status != 0) {
                 dev_dbg(&spi->dev, "write error (%d)\n", status);
@@ -822,7 +822,7 @@ mmc_spi_readblock(struct mmc_spi_host *host, struct spi_transfer *t,
                                 DMA_FROM_DEVICE);
         }
 
-        status = spi_sync(spi, &host->m);
+        status = spi_sync_locked(spi, &host->m);
 
         if (host->dma_dev) {
                 dma_sync_single_for_cpu(host->dma_dev,
@@ -1018,7 +1018,7 @@ mmc_spi_data_do(struct mmc_spi_host *host, struct mmc_command *cmd,
                                         host->data_dma, sizeof(*scratch),
                                         DMA_BIDIRECTIONAL);
 
-                tmp = spi_sync(spi, &host->m);
+                tmp = spi_sync_locked(spi, &host->m);
 
                 if (host->dma_dev)
                         dma_sync_single_for_cpu(host->dma_dev,
@@ -1084,6 +1084,9 @@ static void mmc_spi_request(struct mmc_host *mmc, struct mmc_request *mrq)
         }
 #endif
 
+        /* request exclusive bus access */
+        spi_bus_lock(host->spi->master);
+
         /* issue command; then optionally data and stop */
         status = mmc_spi_command_send(host, mrq, mrq->cmd, mrq->data != NULL);
         if (status == 0 && mrq->data) {
@@ -1094,6 +1097,9 @@ static void mmc_spi_request(struct mmc_host *mmc, struct mmc_request *mrq)
                         mmc_cs_off(host);
         }
 
+        /* release the bus */
+        spi_bus_unlock(host->spi->master);
+
         mmc_request_done(host->mmc, mrq);
 }
 
@@ -1290,23 +1296,6 @@ mmc_spi_detect_irq(int irq, void *mmc)
         return IRQ_HANDLED;
 }
 
-struct count_children {
-        unsigned        n;
-        struct bus_type *bus;
-};
-
-static int maybe_count_child(struct device *dev, void *c)
-{
-        struct count_children *ccp = c;
-
-        if (dev->bus == ccp->bus) {
-                if (ccp->n)
-                        return -EBUSY;
-                ccp->n++;
-        }
-        return 0;
-}
-
 static int mmc_spi_probe(struct spi_device *spi)
 {
         void                    *ones;
@@ -1338,32 +1327,6 @@ static int mmc_spi_probe(struct spi_device *spi)
                 return status;
         }
 
-        /* We can use the bus safely iff nobody else will interfere with us.
-         * Most commands consist of one SPI message to issue a command, then
-         * several more to collect its response, then possibly more for data
-         * transfer.  Clocking access to other devices during that period will
-         * corrupt the command execution.
-         *
-         * Until we have software primitives which guarantee non-interference,
-         * we'll aim for a hardware-level guarantee.
-         *
-         * REVISIT we can't guarantee another device won't be added later...
-         */
-        if (spi->master->num_chipselect > 1) {
-                struct count_children cc;
-
-                cc.n = 0;
-                cc.bus = spi->dev.bus;
-                status = device_for_each_child(spi->dev.parent, &cc,
-                                maybe_count_child);
-                if (status < 0) {
-                        dev_err(&spi->dev, "can't share SPI bus\n");
-                        return status;
-                }
-
-                dev_warn(&spi->dev, "ASSUMING SPI bus stays unshared!\n");
-        }
-
         /* We need a supply of ones to transmit.  This is the only time
          * the CPU touches these, so cache coherency isn't a concern.
          *
diff --git a/drivers/mtd/devices/m25p80.c b/drivers/mtd/devices/m25p80.c
index f90941a785e4..6f512b5c117b 100644
--- a/drivers/mtd/devices/m25p80.c
+++ b/drivers/mtd/devices/m25p80.c
@@ -347,8 +347,7 @@ static int m25p80_read(struct mtd_info *mtd, loff_t from, size_t len,
         spi_message_add_tail(&t[1], &m);
 
         /* Byte count starts at zero. */
-        if (retlen)
-                *retlen = 0;
+        *retlen = 0;
 
         mutex_lock(&flash->lock);
 
@@ -394,8 +393,7 @@ static int m25p80_write(struct mtd_info *mtd, loff_t to, size_t len,
                         dev_name(&flash->spi->dev), __func__, "to",
                         (u32)to, len);
 
-        if (retlen)
-                *retlen = 0;
+        *retlen = 0;
 
         /* sanity checks */
         if (!len)
@@ -466,8 +464,7 @@ static int m25p80_write(struct mtd_info *mtd, loff_t to, size_t len,
 
                         spi_sync(flash->spi, &m);
 
-                        if (retlen)
-                                *retlen += m.actual_length - m25p_cmdsz(flash);
+                        *retlen += m.actual_length - m25p_cmdsz(flash);
                 }
         }
 
@@ -485,8 +482,7 @@ static int sst_write(struct mtd_info *mtd, loff_t to, size_t len,
         size_t actual;
         int cmd_sz, ret;
 
-        if (retlen)
-                *retlen = 0;
+        *retlen = 0;
 
         /* sanity checks */
         if (!len)
@@ -797,7 +793,7 @@ static int __devinit m25p_probe(struct spi_device *spi)
                         break;
                 }
 
-                if (plat_id)
+                if (i < ARRAY_SIZE(m25p_ids) - 1)
                         id = plat_id;
                 else
                         dev_warn(&spi->dev, "unrecognized id %s\n", data->type);
diff --git a/drivers/mtd/nand/denali.c b/drivers/mtd/nand/denali.c
index 618fb42b86b0..532fe07cf886 100644
--- a/drivers/mtd/nand/denali.c
+++ b/drivers/mtd/nand/denali.c
@@ -56,7 +56,7 @@ MODULE_PARM_DESC(onfi_timing_mode, "Overrides default ONFI setting."
                         INTR_STATUS0__ERASE_COMP)
 
 /* indicates whether or not the internal value for the flash bank is
-   valid or not */
+ * valid or not */
 #define CHIP_SELECT_INVALID     -1
 
 #define SUPPORT_8BITECC         1
@@ -71,7 +71,7 @@ MODULE_PARM_DESC(onfi_timing_mode, "Overrides default ONFI setting."
 #define mtd_to_denali(m) container_of(m, struct denali_nand_info, mtd)
 
 /* These constants are defined by the driver to enable common driver
-   configuration options. */
+ * configuration options. */
 #define SPARE_ACCESS            0x41
 #define MAIN_ACCESS             0x42
 #define MAIN_SPARE_ACCESS       0x43
@@ -97,7 +97,7 @@ static const struct pci_device_id denali_pci_ids[] = {
 
 
 /* these are static lookup tables that give us easy access to
-   registers in the NAND controller.
+ * registers in the NAND controller.
  */
 static const uint32_t intr_status_addresses[4] = {INTR_STATUS0,
                                                   INTR_STATUS1,
@@ -119,9 +119,6 @@ static const uint32_t reset_complete[4] = {INTR_STATUS0__RST_COMP,
                                                         INTR_STATUS2__RST_COMP,
                                                         INTR_STATUS3__RST_COMP};
 
-/* specifies the debug level of the driver */
-static int nand_debug_level;
-
 /* forward declarations */
 static void clear_interrupts(struct denali_nand_info *denali);
 static uint32_t wait_for_irq(struct denali_nand_info *denali,
@@ -130,22 +127,6 @@ static void denali_irq_enable(struct denali_nand_info *denali,
                                                         uint32_t int_mask);
 static uint32_t read_interrupt_status(struct denali_nand_info *denali);
 
-#define DEBUG_DENALI 0
-
-/* This is a wrapper for writing to the denali registers.
- * this allows us to create debug information so we can
- * observe how the driver is programming the device.
- * it uses standard linux convention for (val, addr) */
-static void denali_write32(uint32_t value, void *addr)
-{
-        iowrite32(value, addr);
-
-#if DEBUG_DENALI
-        printk(KERN_INFO "wrote: 0x%x -> 0x%x\n", value,
-                        (uint32_t)((uint32_t)addr & 0x1fff));
-#endif
-}
-
 /* Certain operations for the denali NAND controller use
  * an indexed mode to read/write data. The operation is
  * performed by writing the address value of the command
@@ -155,15 +136,15 @@ static void denali_write32(uint32_t value, void *addr)
 static void index_addr(struct denali_nand_info *denali,
                                 uint32_t address, uint32_t data)
 {
-        denali_write32(address, denali->flash_mem);
-        denali_write32(data, denali->flash_mem + 0x10);
+        iowrite32(address, denali->flash_mem);
+        iowrite32(data, denali->flash_mem + 0x10);
 }
 
 /* Perform an indexed read of the device */
 static void index_addr_read_data(struct denali_nand_info *denali,
                                  uint32_t address, uint32_t *pdata)
 {
-        denali_write32(address, denali->flash_mem);
+        iowrite32(address, denali->flash_mem);
         *pdata = ioread32(denali->flash_mem + 0x10);
 }
 
@@ -188,18 +169,11 @@ static void read_status(struct denali_nand_info *denali)
         /* initialize the data buffer to store status */
         reset_buf(denali);
 
-        /* initiate a device status read */
-        cmd = MODE_11 | BANK(denali->flash_bank);
-        index_addr(denali, cmd | COMMAND_CYCLE, 0x70);
-        denali_write32(cmd | STATUS_CYCLE, denali->flash_mem);
-
-        /* update buffer with status value */
-        write_byte_to_buf(denali, ioread32(denali->flash_mem + 0x10));
-
-#if DEBUG_DENALI
-        printk(KERN_INFO "device reporting status value of 0x%2x\n",
-                        denali->buf.buf[0]);
-#endif
+        cmd = ioread32(denali->flash_reg + WRITE_PROTECT);
+        if (cmd)
+                write_byte_to_buf(denali, NAND_STATUS_WP);
+        else
+                write_byte_to_buf(denali, 0);
 }
 
 /* resets a specific device connected to the core */
@@ -213,12 +187,12 @@ static void reset_bank(struct denali_nand_info *denali)
         clear_interrupts(denali);
 
         bank = device_reset_banks[denali->flash_bank];
-        denali_write32(bank, denali->flash_reg + DEVICE_RESET);
+        iowrite32(bank, denali->flash_reg + DEVICE_RESET);
 
         irq_status = wait_for_irq(denali, irq_mask);
 
         if (irq_status & operation_timeout[denali->flash_bank])
-                printk(KERN_ERR "reset bank failed.\n");
+                dev_err(&denali->dev->dev, "reset bank failed.\n");
 }
 
 /* Reset the flash controller */
@@ -226,28 +200,28 @@ static uint16_t denali_nand_reset(struct denali_nand_info *denali)
 {
         uint32_t i;
 
-        nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
+        dev_dbg(&denali->dev->dev, "%s, Line %d, Function: %s\n",
                        __FILE__, __LINE__, __func__);
 
         for (i = 0 ; i < LLD_MAX_FLASH_BANKS; i++)
-                denali_write32(reset_complete[i] | operation_timeout[i],
+                iowrite32(reset_complete[i] | operation_timeout[i],
                 denali->flash_reg + intr_status_addresses[i]);
 
         for (i = 0 ; i < LLD_MAX_FLASH_BANKS; i++) {
-                denali_write32(device_reset_banks[i],
+                iowrite32(device_reset_banks[i],
                                 denali->flash_reg + DEVICE_RESET);
                 while (!(ioread32(denali->flash_reg +
-                                                intr_status_addresses[i]) &
+                                intr_status_addresses[i]) &
                         (reset_complete[i] | operation_timeout[i])))
-                        ;
+                        cpu_relax();
                 if (ioread32(denali->flash_reg + intr_status_addresses[i]) &
                         operation_timeout[i])
-                        nand_dbg_print(NAND_DBG_WARN,
+                        dev_dbg(&denali->dev->dev,
                         "NAND Reset operation timed out on bank %d\n", i);
         }
 
         for (i = 0; i < LLD_MAX_FLASH_BANKS; i++)
-                denali_write32(reset_complete[i] | operation_timeout[i],
+                iowrite32(reset_complete[i] | operation_timeout[i],
                         denali->flash_reg + intr_status_addresses[i]);
 
         return PASS;
@@ -280,7 +254,7 @@ static void nand_onfi_timing_set(struct denali_nand_info *denali,
         uint16_t acc_clks;
         uint16_t addr_2_data, re_2_we, re_2_re, we_2_re, cs_cnt;
 
-        nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
+        dev_dbg(&denali->dev->dev, "%s, Line %d, Function: %s\n",
                        __FILE__, __LINE__, __func__);
 
         en_lo = CEIL_DIV(Trp[mode], CLK_X);
@@ -317,7 +291,7 @@ static void nand_onfi_timing_set(struct denali_nand_info *denali,
                 acc_clks++;
 
         if ((data_invalid - acc_clks * CLK_X) < 2)
-                nand_dbg_print(NAND_DBG_WARN, "%s, Line %d: Warning!\n",
+                dev_warn(&denali->dev->dev, "%s, Line %d: Warning!\n",
                         __FILE__, __LINE__);
 
         addr_2_data = CEIL_DIV(Tadl[mode], CLK_X);
@@ -345,14 +319,14 @@ static void nand_onfi_timing_set(struct denali_nand_info *denali,
                 (ioread32(denali->flash_reg + DEVICE_ID) == 0x88))
                 acc_clks = 6;
 
-        denali_write32(acc_clks, denali->flash_reg + ACC_CLKS);
-        denali_write32(re_2_we, denali->flash_reg + RE_2_WE);
-        denali_write32(re_2_re, denali->flash_reg + RE_2_RE);
-        denali_write32(we_2_re, denali->flash_reg + WE_2_RE);
-        denali_write32(addr_2_data, denali->flash_reg + ADDR_2_DATA);
-        denali_write32(en_lo, denali->flash_reg + RDWR_EN_LO_CNT);
-        denali_write32(en_hi, denali->flash_reg + RDWR_EN_HI_CNT);
-        denali_write32(cs_cnt, denali->flash_reg + CS_SETUP_CNT);
+        iowrite32(acc_clks, denali->flash_reg + ACC_CLKS);
+        iowrite32(re_2_we, denali->flash_reg + RE_2_WE);
+        iowrite32(re_2_re, denali->flash_reg + RE_2_RE);
+        iowrite32(we_2_re, denali->flash_reg + WE_2_RE);
+        iowrite32(addr_2_data, denali->flash_reg + ADDR_2_DATA);
+        iowrite32(en_lo, denali->flash_reg + RDWR_EN_LO_CNT);
+        iowrite32(en_hi, denali->flash_reg + RDWR_EN_HI_CNT);
+        iowrite32(cs_cnt, denali->flash_reg + CS_SETUP_CNT);
 }
 
 /* queries the NAND device to see what ONFI modes it supports. */
@@ -387,13 +361,13 @@ static void get_samsung_nand_para(struct denali_nand_info *denali,
 {
         if (device_id == 0xd3) { /* Samsung K9WAG08U1A */
                 /* Set timing register values according to datasheet */
-                denali_write32(5, denali->flash_reg + ACC_CLKS);
-                denali_write32(20, denali->flash_reg + RE_2_WE);
-                denali_write32(12, denali->flash_reg + WE_2_RE);
-                denali_write32(14, denali->flash_reg + ADDR_2_DATA);
-                denali_write32(3, denali->flash_reg + RDWR_EN_LO_CNT);
-                denali_write32(2, denali->flash_reg + RDWR_EN_HI_CNT);
-                denali_write32(2, denali->flash_reg + CS_SETUP_CNT);
+                iowrite32(5, denali->flash_reg + ACC_CLKS);
+                iowrite32(20, denali->flash_reg + RE_2_WE);
+                iowrite32(12, denali->flash_reg + WE_2_RE);
+                iowrite32(14, denali->flash_reg + ADDR_2_DATA);
+                iowrite32(3, denali->flash_reg + RDWR_EN_LO_CNT);
+                iowrite32(2, denali->flash_reg + RDWR_EN_HI_CNT);
+                iowrite32(2, denali->flash_reg + CS_SETUP_CNT);
         }
 }
 
@@ -405,15 +379,15 @@ static void get_toshiba_nand_para(struct denali_nand_info *denali)
         /* spare area size for some kind of Toshiba NAND device */
         if ((ioread32(denali->flash_reg + DEVICE_MAIN_AREA_SIZE) == 4096) &&
                 (ioread32(denali->flash_reg + DEVICE_SPARE_AREA_SIZE) == 64)) {
-                denali_write32(216, denali->flash_reg + DEVICE_SPARE_AREA_SIZE);
+                iowrite32(216, denali->flash_reg + DEVICE_SPARE_AREA_SIZE);
                 tmp = ioread32(denali->flash_reg + DEVICES_CONNECTED) *
                         ioread32(denali->flash_reg + DEVICE_SPARE_AREA_SIZE);
-                denali_write32(tmp,
+                iowrite32(tmp,
                                 denali->flash_reg + LOGICAL_PAGE_SPARE_SIZE);
 #if SUPPORT_15BITECC
-                denali_write32(15, denali->flash_reg + ECC_CORRECTION);
+                iowrite32(15, denali->flash_reg + ECC_CORRECTION);
 #elif SUPPORT_8BITECC
-                denali_write32(8, denali->flash_reg + ECC_CORRECTION);
+                iowrite32(8, denali->flash_reg + ECC_CORRECTION);
 #endif
         }
 }
@@ -426,26 +400,26 @@ static void get_hynix_nand_para(struct denali_nand_info *denali,
         switch (device_id) {
         case 0xD5: /* Hynix H27UAG8T2A, H27UBG8U5A or H27UCG8VFA */
         case 0xD7: /* Hynix H27UDG8VEM, H27UCG8UDM or H27UCG8V5A */
-                denali_write32(128, denali->flash_reg + PAGES_PER_BLOCK);
-                denali_write32(4096, denali->flash_reg + DEVICE_MAIN_AREA_SIZE);
-                denali_write32(224, denali->flash_reg + DEVICE_SPARE_AREA_SIZE);
+                iowrite32(128, denali->flash_reg + PAGES_PER_BLOCK);
+                iowrite32(4096, denali->flash_reg + DEVICE_MAIN_AREA_SIZE);
+                iowrite32(224, denali->flash_reg + DEVICE_SPARE_AREA_SIZE);
                 main_size = 4096 *
                         ioread32(denali->flash_reg + DEVICES_CONNECTED);
                 spare_size = 224 *
                         ioread32(denali->flash_reg + DEVICES_CONNECTED);
-                denali_write32(main_size,
+                iowrite32(main_size,
                                 denali->flash_reg + LOGICAL_PAGE_DATA_SIZE);
-                denali_write32(spare_size,
+                iowrite32(spare_size,
                                 denali->flash_reg + LOGICAL_PAGE_SPARE_SIZE);
-                denali_write32(0, denali->flash_reg + DEVICE_WIDTH);
+                iowrite32(0, denali->flash_reg + DEVICE_WIDTH);
 #if SUPPORT_15BITECC
-                denali_write32(15, denali->flash_reg + ECC_CORRECTION);
+                iowrite32(15, denali->flash_reg + ECC_CORRECTION);
 #elif SUPPORT_8BITECC
-                denali_write32(8, denali->flash_reg + ECC_CORRECTION);
+                iowrite32(8, denali->flash_reg + ECC_CORRECTION);
 #endif
                 break;
         default:
-                nand_dbg_print(NAND_DBG_WARN,
+                dev_warn(&denali->dev->dev,
                         "Spectra: Unknown Hynix NAND (Device ID: 0x%x)."
                         "Will use default parameter values instead.\n",
                         device_id);
@@ -453,7 +427,7 @@ static void get_hynix_nand_para(struct denali_nand_info *denali,
 }
 
 /* determines how many NAND chips are connected to the controller. Note for
-   Intel CE4100 devices we don't support more than one device.
+ * Intel CE4100 devices we don't support more than one device.
  */
 static void find_valid_banks(struct denali_nand_info *denali)
 {
@@ -467,7 +441,7 @@ static void find_valid_banks(struct denali_nand_info *denali)
                 index_addr_read_data(denali,
                                 (uint32_t)(MODE_11 | (i << 24) | 2), &id[i]);
 
-                nand_dbg_print(NAND_DBG_DEBUG,
+                dev_dbg(&denali->dev->dev,
                         "Return 1st ID for bank[%d]: %x\n", i, id[i]);
 
                 if (i == 0) {
@@ -487,12 +461,13 @@ static void find_valid_banks(struct denali_nand_info *denali)
                  * Multichip support is not enabled.
                  */
                 if (denali->total_used_banks != 1) {
-                        printk(KERN_ERR "Sorry, Intel CE4100 only supports "
+                        dev_err(&denali->dev->dev,
+                                        "Sorry, Intel CE4100 only supports "
                                         "a single NAND device.\n");
                         BUG();
                 }
         }
-        nand_dbg_print(NAND_DBG_DEBUG,
+        dev_dbg(&denali->dev->dev,
                 "denali->total_used_banks: %d\n", denali->total_used_banks);
 }
 
@@ -526,8 +501,9 @@ static uint16_t denali_nand_timing_set(struct denali_nand_info *denali)
         uint32_t id_bytes[5], addr;
         uint8_t i, maf_id, device_id;
 
-        nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
-                       __FILE__, __LINE__, __func__);
+        dev_dbg(&denali->dev->dev,
+                        "%s, Line %d, Function: %s\n",
+                        __FILE__, __LINE__, __func__);
 
         /* Use read id method to get device ID and other
          * params. For some NAND chips, controller can't
@@ -554,12 +530,14 @@ static uint16_t denali_nand_timing_set(struct denali_nand_info *denali)
                 get_hynix_nand_para(denali, device_id);
         }
 
-        nand_dbg_print(NAND_DBG_DEBUG, "Dump timing register values:"
-                        "acc_clks: %d, re_2_we: %d, we_2_re: %d,"
-                        "addr_2_data: %d, rdwr_en_lo_cnt: %d, "
+        dev_info(&denali->dev->dev,
+                        "Dump timing register values:"
+                        "acc_clks: %d, re_2_we: %d, re_2_re: %d\n"
+                        "we_2_re: %d, addr_2_data: %d, rdwr_en_lo_cnt: %d\n"
                         "rdwr_en_hi_cnt: %d, cs_setup_cnt: %d\n",
                         ioread32(denali->flash_reg + ACC_CLKS),
                         ioread32(denali->flash_reg + RE_2_WE),
+                        ioread32(denali->flash_reg + RE_2_RE),
                         ioread32(denali->flash_reg + WE_2_RE),
                         ioread32(denali->flash_reg + ADDR_2_DATA),
                         ioread32(denali->flash_reg + RDWR_EN_LO_CNT),
@@ -582,17 +560,17 @@ static uint16_t denali_nand_timing_set(struct denali_nand_info *denali)
 static void denali_set_intr_modes(struct denali_nand_info *denali,
                                         uint16_t INT_ENABLE)
 {
-        nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
+        dev_dbg(&denali->dev->dev, "%s, Line %d, Function: %s\n",
                        __FILE__, __LINE__, __func__);
 
         if (INT_ENABLE)
-                denali_write32(1, denali->flash_reg + GLOBAL_INT_ENABLE);
+                iowrite32(1, denali->flash_reg + GLOBAL_INT_ENABLE);
         else
-                denali_write32(0, denali->flash_reg + GLOBAL_INT_ENABLE);
+                iowrite32(0, denali->flash_reg + GLOBAL_INT_ENABLE);
 }
 
 /* validation function to verify that the controlling software is making
-   a valid request
+ * a valid request
  */
 static inline bool is_flash_bank_valid(int flash_bank)
 {
@@ -609,10 +587,10 @@ static void denali_irq_init(struct denali_nand_info *denali)
         int_mask = DENALI_IRQ_ALL;
 
         /* Clear all status bits */
-        denali_write32(0xFFFF, denali->flash_reg + INTR_STATUS0);
-        denali_write32(0xFFFF, denali->flash_reg + INTR_STATUS1);
-        denali_write32(0xFFFF, denali->flash_reg + INTR_STATUS2);
-        denali_write32(0xFFFF, denali->flash_reg + INTR_STATUS3);
+        iowrite32(0xFFFF, denali->flash_reg + INTR_STATUS0);
+        iowrite32(0xFFFF, denali->flash_reg + INTR_STATUS1);
+        iowrite32(0xFFFF, denali->flash_reg + INTR_STATUS2);
+        iowrite32(0xFFFF, denali->flash_reg + INTR_STATUS3);
 
         denali_irq_enable(denali, int_mask);
 }
@@ -626,10 +604,10 @@ static void denali_irq_cleanup(int irqnum, struct denali_nand_info *denali)
 static void denali_irq_enable(struct denali_nand_info *denali,
                                                         uint32_t int_mask)
 {
-        denali_write32(int_mask, denali->flash_reg + INTR_EN0);
-        denali_write32(int_mask, denali->flash_reg + INTR_EN1);
-        denali_write32(int_mask, denali->flash_reg + INTR_EN2);
-        denali_write32(int_mask, denali->flash_reg + INTR_EN3);
+        iowrite32(int_mask, denali->flash_reg + INTR_EN0);
+        iowrite32(int_mask, denali->flash_reg + INTR_EN1);
+        iowrite32(int_mask, denali->flash_reg + INTR_EN2);
+        iowrite32(int_mask, denali->flash_reg + INTR_EN3);
 }
 
 /* This function only returns when an interrupt that this driver cares about
@@ -648,7 +626,7 @@ static inline void clear_interrupt(struct denali_nand_info *denali,
 
         intr_status_reg = intr_status_addresses[denali->flash_bank];
 
-        denali_write32(irq_mask, denali->flash_reg + intr_status_reg);
+        iowrite32(irq_mask, denali->flash_reg + intr_status_reg);
 }
 
 static void clear_interrupts(struct denali_nand_info *denali)
@@ -657,11 +635,7 @@ static void clear_interrupts(struct denali_nand_info *denali)
         spin_lock_irq(&denali->irq_lock);
 
         status = read_interrupt_status(denali);
-
-#if DEBUG_DENALI
-        denali->irq_debug_array[denali->idx++] = 0x30000000 | status;
-        denali->idx %= 32;
-#endif
+        clear_interrupt(denali, status);
 
         denali->irq_status = 0x0;
         spin_unlock_irq(&denali->irq_lock);
@@ -676,17 +650,6 @@ static uint32_t read_interrupt_status(struct denali_nand_info *denali)
         return ioread32(denali->flash_reg + intr_status_reg);
 }
 
-#if DEBUG_DENALI
-static void print_irq_log(struct denali_nand_info *denali)
-{
-        int i = 0;
-
-        printk(KERN_INFO "ISR debug log index = %X\n", denali->idx);
-        for (i = 0; i < 32; i++)
-                printk(KERN_INFO "%08X: %08X\n", i, denali->irq_debug_array[i]);
-}
-#endif
-
 /* This is the interrupt service routine. It handles all interrupts
  * sent to this device. Note that on CE4100, this is a shared
  * interrupt.
@@ -707,13 +670,6 @@ static irqreturn_t denali_isr(int irq, void *dev_id)
                  * the interrupt, since this is a shared interrupt */
                 irq_status = denali_irq_detected(denali);
                 if (irq_status != 0) {
-#if DEBUG_DENALI
-                        denali->irq_debug_array[denali->idx++] =
-                                0x10000000 | irq_status;
-                        denali->idx %= 32;
-
-                        printk(KERN_INFO "IRQ status = 0x%04x\n", irq_status);
-#endif
                         /* handle interrupt */
                         /* first acknowledge it */
                         clear_interrupt(denali, irq_status);
@@ -739,41 +695,20 @@ static uint32_t wait_for_irq(struct denali_nand_info *denali, uint32_t irq_mask)
         unsigned long timeout = msecs_to_jiffies(1000);
 
         do {
-#if DEBUG_DENALI
-                printk(KERN_INFO "waiting for 0x%x\n", irq_mask);
-#endif
                 comp_res =
                         wait_for_completion_timeout(&denali->complete, timeout);
                 spin_lock_irq(&denali->irq_lock);
                 intr_status = denali->irq_status;
 
-#if DEBUG_DENALI
-                denali->irq_debug_array[denali->idx++] =
-                        0x20000000 | (irq_mask << 16) | intr_status;
-                denali->idx %= 32;
-#endif
-
                 if (intr_status & irq_mask) {
                         denali->irq_status &= ~irq_mask;
                         spin_unlock_irq(&denali->irq_lock);
-#if DEBUG_DENALI
-                        if (retry)
-                                printk(KERN_INFO "status on retry = 0x%x\n",
-                                                intr_status);
-#endif
                         /* our interrupt was detected */
                         break;
                 } else {
                         /* these are not the interrupts you are looking for -
                          * need to wait again */
                         spin_unlock_irq(&denali->irq_lock);
-#if DEBUG_DENALI
-                        print_irq_log(denali);
-                        printk(KERN_INFO "received irq nobody cared:"
-                                        " irq_status = 0x%x, irq_mask = 0x%x,"
-                                        " timeout = %ld\n", intr_status,
-                                        irq_mask, comp_res);
-#endif
                         retry = true;
                 }
         } while (comp_res != 0);
@@ -789,7 +724,7 @@ static uint32_t wait_for_irq(struct denali_nand_info *denali, uint32_t irq_mask)
 }
 
 /* This helper function setups the registers for ECC and whether or not
-   the spare area will be transfered. */
+ * the spare area will be transfered. */
 static void setup_ecc_for_xfer(struct denali_nand_info *denali, bool ecc_en,
                                 bool transfer_spare)
 {
@@ -800,13 +735,13 @@ static void setup_ecc_for_xfer(struct denali_nand_info *denali, bool ecc_en,
         transfer_spare_flag = transfer_spare ? TRANSFER_SPARE_REG__FLAG : 0;
 
         /* Enable spare area/ECC per user's request. */
-        denali_write32(ecc_en_flag, denali->flash_reg + ECC_ENABLE);
-        denali_write32(transfer_spare_flag,
+        iowrite32(ecc_en_flag, denali->flash_reg + ECC_ENABLE);
+        iowrite32(transfer_spare_flag,
                         denali->flash_reg + TRANSFER_SPARE_REG);
 }
 
 /* sends a pipeline command operation to the controller. See the Denali NAND
-   controller's user guide for more information (section 4.2.3.6).
+ * controller's user guide for more information (section 4.2.3.6).
  */
 static int denali_send_pipeline_cmd(struct denali_nand_info *denali,
                                                         bool ecc_en,
@@ -827,16 +762,6 @@ static int denali_send_pipeline_cmd(struct denali_nand_info *denali,
 
         setup_ecc_for_xfer(denali, ecc_en, transfer_spare);
 
-#if DEBUG_DENALI
-        spin_lock_irq(&denali->irq_lock);
-        denali->irq_debug_array[denali->idx++] =
-                0x40000000 | ioread32(denali->flash_reg + ECC_ENABLE) |
-                (access_type << 4);
-        denali->idx %= 32;
-        spin_unlock_irq(&denali->irq_lock);
-#endif
-
-
         /* clear interrupts */
         clear_interrupts(denali);
 
@@ -844,14 +769,14 @@ static int denali_send_pipeline_cmd(struct denali_nand_info *denali,
 
         if (op == DENALI_WRITE && access_type != SPARE_ACCESS) {
                 cmd = MODE_01 | addr;
-                denali_write32(cmd, denali->flash_mem);
+                iowrite32(cmd, denali->flash_mem);
         } else if (op == DENALI_WRITE && access_type == SPARE_ACCESS) {
                 /* read spare area */
                 cmd = MODE_10 | addr;
                 index_addr(denali, (uint32_t)cmd, access_type);
 
                 cmd = MODE_01 | addr;
-                denali_write32(cmd, denali->flash_mem);
+                iowrite32(cmd, denali->flash_mem);
         } else if (op == DENALI_READ) {
                 /* setup page read request for access type */
                 cmd = MODE_10 | addr;
@@ -863,7 +788,7 @@ static int denali_send_pipeline_cmd(struct denali_nand_info *denali,
                  */
                 if (access_type == SPARE_ACCESS) {
                         cmd = MODE_01 | addr;
-                        denali_write32(cmd, denali->flash_mem);
+                        iowrite32(cmd, denali->flash_mem);
                 } else {
                         index_addr(denali, (uint32_t)cmd,
                                         0x2000 | op | page_count);
@@ -875,13 +800,14 @@ static int denali_send_pipeline_cmd(struct denali_nand_info *denali,
                         irq_status = wait_for_irq(denali, irq_mask);
 
                         if (irq_status == 0) {
-                                printk(KERN_ERR "cmd, page, addr on timeout "
-                                        "(0x%x, 0x%x, 0x%x)\n", cmd,
-                                        denali->page, addr);
+                                dev_err(&denali->dev->dev,
+                                                "cmd, page, addr on timeout "
+                                                "(0x%x, 0x%x, 0x%x)\n",
+                                                cmd, denali->page, addr);
                                 status = FAIL;
                         } else {
                                 cmd = MODE_01 | addr;
-                                denali_write32(cmd, denali->flash_mem);
+                                iowrite32(cmd, denali->flash_mem);
                         }
                 }
         }
@@ -902,7 +828,7 @@ static int write_data_to_flash_mem(struct denali_nand_info *denali,
         /* write the data to the flash memory */
         buf32 = (uint32_t *)buf;
         for (i = 0; i < len / 4; i++)
-                denali_write32(*buf32++, denali->flash_mem + 0x10);
+                iowrite32(*buf32++, denali->flash_mem + 0x10);
         return i*4; /* intent is to return the number of bytes read */
 }
 
@@ -945,24 +871,15 @@ static int write_oob_data(struct mtd_info *mtd, uint8_t *buf, int page)
                                                         DENALI_WRITE) == PASS) {
                 write_data_to_flash_mem(denali, buf, mtd->oobsize);
 
-#if DEBUG_DENALI
-                spin_lock_irq(&denali->irq_lock);
-                denali->irq_debug_array[denali->idx++] =
-                        0x80000000 | mtd->oobsize;
-                denali->idx %= 32;
-                spin_unlock_irq(&denali->irq_lock);
-#endif
-
-
                 /* wait for operation to complete */
                 irq_status = wait_for_irq(denali, irq_mask);
 
                 if (irq_status == 0) {
-                        printk(KERN_ERR "OOB write failed\n");
+                        dev_err(&denali->dev->dev, "OOB write failed\n");
                         status = -EIO;
                 }
         } else {
-                printk(KERN_ERR "unable to send pipeline command\n");
+                dev_err(&denali->dev->dev, "unable to send pipeline command\n");
                 status = -EIO;
         }
         return status;
@@ -977,9 +894,6 @@ static void read_oob_data(struct mtd_info *mtd, uint8_t *buf, int page)
 
         denali->page = page;
 
-#if DEBUG_DENALI
-        printk(KERN_INFO "read_oob %d\n", page);
-#endif
         if (denali_send_pipeline_cmd(denali, false, true, SPARE_ACCESS,
                                                         DENALI_READ) == PASS) {
                 read_data_from_flash_mem(denali, buf, mtd->oobsize);
@@ -990,7 +904,7 @@ static void read_oob_data(struct mtd_info *mtd, uint8_t *buf, int page)
                 irq_status = wait_for_irq(denali, irq_mask);
 
                 if (irq_status == 0)
-                        printk(KERN_ERR "page on OOB timeout %d\n",
+                        dev_err(&denali->dev->dev, "page on OOB timeout %d\n",
                                         denali->page);
 
                 /* We set the device back to MAIN_ACCESS here as I observed
@@ -1002,14 +916,6 @@ static void read_oob_data(struct mtd_info *mtd, uint8_t *buf, int page)
                 addr = BANK(denali->flash_bank) | denali->page;
                 cmd = MODE_10 | addr;
                 index_addr(denali, (uint32_t)cmd, MAIN_ACCESS);
-
-#if DEBUG_DENALI
-                spin_lock_irq(&denali->irq_lock);
-                denali->irq_debug_array[denali->idx++] =
-                        0x60000000 | mtd->oobsize;
-                denali->idx %= 32;
-                spin_unlock_irq(&denali->irq_lock);
-#endif
         }
 }
 
@@ -1029,12 +935,12 @@ bool is_erased(uint8_t *buf, int len)
 #define ECC_SECTOR(x)   (((x) & ECC_ERROR_ADDRESS__SECTOR_NR) >> 12)
 #define ECC_BYTE(x)     (((x) & ECC_ERROR_ADDRESS__OFFSET))
 #define ECC_CORRECTION_VALUE(x) ((x) & ERR_CORRECTION_INFO__BYTEMASK)
-#define ECC_ERROR_CORRECTABLE(x) (!((x) & ERR_CORRECTION_INFO))
-#define ECC_ERR_DEVICE(x)       ((x) & ERR_CORRECTION_INFO__DEVICE_NR >> 8)
+#define ECC_ERROR_CORRECTABLE(x) (!((x) & ERR_CORRECTION_INFO__ERROR_TYPE))
+#define ECC_ERR_DEVICE(x)       (((x) & ERR_CORRECTION_INFO__DEVICE_NR) >> 8)
 #define ECC_LAST_ERR(x)         ((x) & ERR_CORRECTION_INFO__LAST_ERR_INFO)
 
 static bool handle_ecc(struct denali_nand_info *denali, uint8_t *buf,
-                        uint8_t *oobbuf, uint32_t irq_status)
+                                        uint32_t irq_status)
 {
         bool check_erased_page = false;
 
@@ -1043,6 +949,7 @@ static bool handle_ecc(struct denali_nand_info *denali, uint8_t *buf,
                 uint32_t err_address = 0, err_correction_info = 0;
                 uint32_t err_byte = 0, err_sector = 0, err_device = 0;
                 uint32_t err_correction_value = 0;
+                denali_set_intr_modes(denali, false);
 
                 do {
                         err_address = ioread32(denali->flash_reg +
@@ -1050,7 +957,6 @@ static bool handle_ecc(struct denali_nand_info *denali, uint8_t *buf,
                         err_sector = ECC_SECTOR(err_address);
                         err_byte = ECC_BYTE(err_address);
 
-
                         err_correction_info = ioread32(denali->flash_reg +
                                                 ERR_CORRECTION_INFO);
                         err_correction_value =
@@ -1058,20 +964,23 @@ static bool handle_ecc(struct denali_nand_info *denali, uint8_t *buf,
                         err_device = ECC_ERR_DEVICE(err_correction_info);
 
                         if (ECC_ERROR_CORRECTABLE(err_correction_info)) {
-                                /* offset in our buffer is computed as:
-                                   sector number * sector size + offset in
-                                   sector
-                                 */
-                                int offset = err_sector * ECC_SECTOR_SIZE +
-                                                                err_byte;
-                                if (offset < denali->mtd.writesize) {
+                                /* If err_byte is larger than ECC_SECTOR_SIZE,
+                                 * means error happend in OOB, so we ignore
+                                 * it. It's no need for us to correct it
+                                 * err_device is represented the NAND error
+                                 * bits are happened in if there are more
+                                 * than one NAND connected.
+                                 * */
+                                if (err_byte < ECC_SECTOR_SIZE) {
+                                        int offset;
+                                        offset = (err_sector *
+                                                        ECC_SECTOR_SIZE +
+                                                        err_byte) *
+                                                        denali->devnum +
+                                                        err_device;
                                         /* correct the ECC error */
                                         buf[offset] ^= err_correction_value;
                                         denali->mtd.ecc_stats.corrected++;
-                                } else {
-                                        /* bummer, couldn't correct the error */
-                                        printk(KERN_ERR "ECC offset invalid\n");
-                                        denali->mtd.ecc_stats.failed++;
                                 }
                         } else {
                                 /* if the error is not correctable, need to
@@ -1080,14 +989,16 @@ static bool handle_ecc(struct denali_nand_info *denali, uint8_t *buf,
                                  * */
                                 check_erased_page = true;
                         }
-
-#if DEBUG_DENALI
-                        printk(KERN_INFO "Detected ECC error in page %d:"
-                                        " err_addr = 0x%08x, info to fix is"
-                                        " 0x%08x\n", denali->page, err_address,
-                                        err_correction_info);
-#endif
                 } while (!ECC_LAST_ERR(err_correction_info));
+                /* Once handle all ecc errors, controller will triger
+                 * a ECC_TRANSACTION_DONE interrupt, so here just wait
+                 * for a while for this interrupt
+                 * */
+                while (!(read_interrupt_status(denali) &
+                                INTR_STATUS0__ECC_TRANSACTION_DONE))
+                        cpu_relax();
+                clear_interrupts(denali);
+                denali_set_intr_modes(denali, true);
         }
         return check_erased_page;
 }
@@ -1100,7 +1011,7 @@ static void denali_enable_dma(struct denali_nand_info *denali, bool en)
         if (en)
                 reg_val = DMA_ENABLE__FLAG;
 
-        denali_write32(reg_val, denali->flash_reg + DMA_ENABLE);
+        iowrite32(reg_val, denali->flash_reg + DMA_ENABLE);
         ioread32(denali->flash_reg + DMA_ENABLE);
 }
 
@@ -1129,7 +1040,7 @@ static void denali_setup_dma(struct denali_nand_info *denali, int op)
 }
 
 /* writes a page. user specifies type, and this function handles the
-   configuration details. */
+ * configuration details. */
 static void write_page(struct mtd_info *mtd, struct nand_chip *chip,
                         const uint8_t *buf, bool raw_xfer)
 {
@@ -1171,8 +1082,9 @@ static void write_page(struct mtd_info *mtd, struct nand_chip *chip,
         irq_status = wait_for_irq(denali, irq_mask);
 
         if (irq_status == 0) {
-                printk(KERN_ERR "timeout on write_page"
-                                " (type = %d)\n", raw_xfer);
+                dev_err(&denali->dev->dev,
+                                "timeout on write_page (type = %d)\n",
+                                raw_xfer);
                 denali->status =
                         (irq_status & INTR_STATUS0__PROGRAM_FAIL) ?
                         NAND_STATUS_FAIL : PASS;
@@ -1185,8 +1097,9 @@ static void write_page(struct mtd_info *mtd, struct nand_chip *chip,
 /* NAND core entry points */
 
 /* this is the callback that the NAND core calls to write a page. Since
-   writing a page with ECC or without is similar, all the work is done
-   by write_page above.   */
+ * writing a page with ECC or without is similar, all the work is done
+ * by write_page above.
+ * */
 static void denali_write_page(struct mtd_info *mtd, struct nand_chip *chip,
                                 const uint8_t *buf)
 {
@@ -1196,8 +1109,8 @@ static void denali_write_page(struct mtd_info *mtd, struct nand_chip *chip,
 }
 
 /* This is the callback that the NAND core calls to write a page without ECC.
-   raw access is similiar to ECC page writes, so all the work is done in the
-   write_page() function above.
+ * raw access is similiar to ECC page writes, so all the work is done in the
+ * write_page() function above.
  */
 static void denali_write_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
                                         const uint8_t *buf)
@@ -1236,6 +1149,13 @@ static int denali_read_page(struct mtd_info *mtd, struct nand_chip *chip,
                             INTR_STATUS0__ECC_ERR;
         bool check_erased_page = false;
 
+        if (page != denali->page) {
+                dev_err(&denali->dev->dev, "IN %s: page %d is not"
+                                " equal to denali->page %d, investigate!!",
+                                __func__, page, denali->page);
+                BUG();
+        }
+
         setup_ecc_for_xfer(denali, true, false);
 
         denali_enable_dma(denali, true);
@@ -1251,7 +1171,7 @@ static int denali_read_page(struct mtd_info *mtd, struct nand_chip *chip,
 
         memcpy(buf, denali->buf.buf, mtd->writesize);
 
-        check_erased_page = handle_ecc(denali, buf, chip->oob_poi, irq_status);
+        check_erased_page = handle_ecc(denali, buf, irq_status);
         denali_enable_dma(denali, false);
 
         if (check_erased_page) {
@@ -1280,6 +1200,13 @@ static int denali_read_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
         uint32_t irq_status = 0;
         uint32_t irq_mask = INTR_STATUS0__DMA_CMD_COMP;
 
+        if (page != denali->page) {
+                dev_err(&denali->dev->dev, "IN %s: page %d is not"
+                                " equal to denali->page %d, investigate!!",
+                                __func__, page, denali->page);
+                BUG();
+        }
+
         setup_ecc_for_xfer(denali, false, true);
         denali_enable_dma(denali, true);
 
@@ -1309,18 +1236,13 @@ static uint8_t denali_read_byte(struct mtd_info *mtd)
         if (denali->buf.head < denali->buf.tail)
                 result = denali->buf.buf[denali->buf.head++];
 
-#if DEBUG_DENALI
-        printk(KERN_INFO "read byte -> 0x%02x\n", result);
-#endif
         return result;
 }
 
 static void denali_select_chip(struct mtd_info *mtd, int chip)
 {
         struct denali_nand_info *denali = mtd_to_denali(mtd);
-#if DEBUG_DENALI
-        printk(KERN_INFO "denali select chip %d\n", chip);
-#endif
+
         spin_lock_irq(&denali->irq_lock);
         denali->flash_bank = chip;
         spin_unlock_irq(&denali->irq_lock);
@@ -1332,9 +1254,6 @@ static int denali_waitfunc(struct mtd_info *mtd, struct nand_chip *chip)
         int status = denali->status;
         denali->status = 0;
 
-#if DEBUG_DENALI
-        printk(KERN_INFO "waitfunc %d\n", status);
-#endif
         return status;
 }
 
@@ -1344,9 +1263,6 @@ static void denali_erase(struct mtd_info *mtd, int page)
 
         uint32_t cmd = 0x0, irq_status = 0;
 
-#if DEBUG_DENALI
-        printk(KERN_INFO "erase page: %d\n", page);
-#endif
         /* clear interrupts */
         clear_interrupts(denali);
 
@@ -1369,9 +1285,6 @@ static void denali_cmdfunc(struct mtd_info *mtd, unsigned int cmd, int col,
         uint32_t addr, id;
         int i;
 
-#if DEBUG_DENALI
-        printk(KERN_INFO "cmdfunc: 0x%x %d %d\n", cmd, col, page);
-#endif
         switch (cmd) {
         case NAND_CMD_PAGEPROG:
                 break;
@@ -1415,7 +1328,9 @@ static void denali_cmdfunc(struct mtd_info *mtd, unsigned int cmd, int col,
 static int denali_ecc_calculate(struct mtd_info *mtd, const uint8_t *data,
                                 uint8_t *ecc_code)
 {
-        printk(KERN_ERR "denali_ecc_calculate called unexpectedly\n");
+        struct denali_nand_info *denali = mtd_to_denali(mtd);
+        dev_err(&denali->dev->dev,
+                        "denali_ecc_calculate called unexpectedly\n");
         BUG();
         return -EIO;
 }
@@ -1423,14 +1338,18 @@ static int denali_ecc_calculate(struct mtd_info *mtd, const uint8_t *data,
 static int denali_ecc_correct(struct mtd_info *mtd, uint8_t *data,
                                 uint8_t *read_ecc, uint8_t *calc_ecc)
 {
-        printk(KERN_ERR "denali_ecc_correct called unexpectedly\n");
+        struct denali_nand_info *denali = mtd_to_denali(mtd);
+        dev_err(&denali->dev->dev,
+                        "denali_ecc_correct called unexpectedly\n");
         BUG();
         return -EIO;
 }
 
 static void denali_ecc_hwctl(struct mtd_info *mtd, int mode)
 {
-        printk(KERN_ERR "denali_ecc_hwctl called unexpectedly\n");
+        struct denali_nand_info *denali = mtd_to_denali(mtd);
+        dev_err(&denali->dev->dev,
+                        "denali_ecc_hwctl called unexpectedly\n");
         BUG();
 }
 /* end NAND core entry points */
@@ -1445,18 +1364,18 @@ static void denali_hw_init(struct denali_nand_info *denali)
          * */
         denali->bbtskipbytes = ioread32(denali->flash_reg +
                                                 SPARE_AREA_SKIP_BYTES);
-        denali_irq_init(denali);
         denali_nand_reset(denali);
-        denali_write32(0x0F, denali->flash_reg + RB_PIN_ENABLED);
-        denali_write32(CHIP_EN_DONT_CARE__FLAG,
+        iowrite32(0x0F, denali->flash_reg + RB_PIN_ENABLED);
+        iowrite32(CHIP_EN_DONT_CARE__FLAG,
                         denali->flash_reg + CHIP_ENABLE_DONT_CARE);
 
-        denali_write32(0x0, denali->flash_reg + SPARE_AREA_SKIP_BYTES);
-        denali_write32(0xffff, denali->flash_reg + SPARE_AREA_MARKER);
+        iowrite32(0xffff, denali->flash_reg + SPARE_AREA_MARKER);
 
         /* Should set value for these registers when init */
-        denali_write32(0, denali->flash_reg + TWO_ROW_ADDR_CYCLES);
-        denali_write32(1, denali->flash_reg + ECC_ENABLE);
+        iowrite32(0, denali->flash_reg + TWO_ROW_ADDR_CYCLES);
+        iowrite32(1, denali->flash_reg + ECC_ENABLE);
+        denali_nand_timing_set(denali);
+        denali_irq_init(denali);
 }
 
 /* Althogh controller spec said SLC ECC is forceb to be 4bit,
@@ -1526,9 +1445,6 @@ static int denali_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
         unsigned long csr_len, mem_len;
         struct denali_nand_info *denali;
 
-        nand_dbg_print(NAND_DBG_TRACE, "%s, Line %d, Function: %s\n",
-                       __FILE__, __LINE__, __func__);
-
         denali = kzalloc(sizeof(*denali), GFP_KERNEL);
         if (!denali)
                 return -ENOMEM;
@@ -1536,7 +1452,7 @@ static int denali_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
         ret = pci_enable_device(dev);
         if (ret) {
                 printk(KERN_ERR "Spectra: pci_enable_device failed.\n");
-                goto failed_enable;
+                goto failed_alloc_memery;
         }
 
         if (id->driver_data == INTEL_CE4100) {
@@ -1547,7 +1463,7 @@ static int denali_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
                         printk(KERN_ERR "Intel CE4100 only supports"
                                         " ONFI timing mode 1 or below\n");
                         ret = -EINVAL;
-                        goto failed_enable;
+                        goto failed_enable_dev;
                 }
                 denali->platform = INTEL_CE4100;
                 mem_base = pci_resource_start(dev, 0);
@@ -1557,17 +1473,12 @@ static int denali_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
         } else {
                 denali->platform = INTEL_MRST;
                 csr_base = pci_resource_start(dev, 0);
-                csr_len = pci_resource_start(dev, 0);
+                csr_len = pci_resource_len(dev, 0);
                 mem_base = pci_resource_start(dev, 1);
                 mem_len = pci_resource_len(dev, 1);
                 if (!mem_len) {
                         mem_base = csr_base + csr_len;
                         mem_len = csr_len;
-                        nand_dbg_print(NAND_DBG_WARN,
-                                       "Spectra: No second"
-                                           " BAR for PCI device;"
-                                           " assuming %08Lx\n",
-                                       (uint64_t)csr_base);
                 }
         }
 
@@ -1576,7 +1487,7 @@ static int denali_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
 
         if (ret) {
                 printk(KERN_ERR "Spectra: no usable DMA configuration\n");
-                goto failed_enable;
+                goto failed_enable_dev;
         }
         denali->buf.dma_buf =
                 pci_map_single(dev, denali->buf.buf,
@@ -1584,50 +1495,44 @@ static int denali_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
                                                 PCI_DMA_BIDIRECTIONAL);
 
         if (pci_dma_mapping_error(dev, denali->buf.dma_buf)) {
-                printk(KERN_ERR "Spectra: failed to map DMA buffer\n");
-                goto failed_enable;
+                dev_err(&dev->dev, "Spectra: failed to map DMA buffer\n");
+                goto failed_enable_dev;
         }
 
         pci_set_master(dev);
         denali->dev = dev;
+        denali->mtd.dev.parent = &dev->dev;
 
         ret = pci_request_regions(dev, DENALI_NAND_NAME);
         if (ret) {
                 printk(KERN_ERR "Spectra: Unable to request memory regions\n");
-                goto failed_req_csr;
+                goto failed_dma_map;
         }
 
         denali->flash_reg = ioremap_nocache(csr_base, csr_len);
         if (!denali->flash_reg) {
                 printk(KERN_ERR "Spectra: Unable to remap memory region\n");
                 ret = -ENOMEM;
-                goto failed_remap_csr;
+                goto failed_req_regions;
         }
-        nand_dbg_print(NAND_DBG_DEBUG, "Spectra: CSR 0x%08Lx -> 0x%p (0x%lx)\n",
-                       (uint64_t)csr_base, denali->flash_reg, csr_len);
 
         denali->flash_mem = ioremap_nocache(mem_base, mem_len);
         if (!denali->flash_mem) {
                 printk(KERN_ERR "Spectra: ioremap_nocache failed!");
-                iounmap(denali->flash_reg);
                 ret = -ENOMEM;
-                goto failed_remap_csr;
+                goto failed_remap_reg;
         }
 
-        nand_dbg_print(NAND_DBG_WARN,
-                "Spectra: Remapped flash base address: "
-                "0x%p, len: %ld\n",
-                denali->flash_mem, csr_len);
-
         denali_hw_init(denali);
         denali_drv_init(denali);
 
-        nand_dbg_print(NAND_DBG_DEBUG, "Spectra: IRQ %d\n", dev->irq);
+        /* denali_isr register is done after all the hardware
+         * initilization is finished*/
         if (request_irq(dev->irq, denali_isr, IRQF_SHARED,
                         DENALI_NAND_NAME, denali)) {
                 printk(KERN_ERR "Spectra: Unable to allocate IRQ\n");
                 ret = -ENODEV;
-                goto failed_request_irq;
+                goto failed_remap_mem;
         }
 
         /* now that our ISR is registered, we can enable interrupts */
@@ -1635,21 +1540,7 @@ static int denali_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
 
         pci_set_drvdata(dev, denali);
 
-        denali_nand_timing_set(denali);
-
-        nand_dbg_print(NAND_DBG_DEBUG, "Dump timing register values:"
-                        "acc_clks: %d, re_2_we: %d, we_2_re: %d,"
-                        "addr_2_data: %d, rdwr_en_lo_cnt: %d, "
-                        "rdwr_en_hi_cnt: %d, cs_setup_cnt: %d\n",
-                        ioread32(denali->flash_reg + ACC_CLKS),
-                        ioread32(denali->flash_reg + RE_2_WE),
-                        ioread32(denali->flash_reg + WE_2_RE),
-                        ioread32(denali->flash_reg + ADDR_2_DATA),
-                        ioread32(denali->flash_reg + RDWR_EN_LO_CNT),
-                        ioread32(denali->flash_reg + RDWR_EN_HI_CNT),
-                        ioread32(denali->flash_reg + CS_SETUP_CNT));
-
-        denali->mtd.name = "Denali NAND";
+        denali->mtd.name = "denali-nand";
         denali->mtd.owner = THIS_MODULE;
         denali->mtd.priv = &denali->nand;
 
@@ -1664,7 +1555,7 @@ static int denali_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
          * with the nand subsystem */
         if (nand_scan_ident(&denali->mtd, LLD_MAX_FLASH_BANKS, NULL)) {
                 ret = -ENXIO;
-                goto failed_nand;
+                goto failed_req_irq;
         }
 
         /* MTD supported page sizes vary by kernel. We validate our
@@ -1674,7 +1565,7 @@ static int denali_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
                 ret = -ENODEV;
                 printk(KERN_ERR "Spectra: device size not supported by this "
                         "version of MTD.");
-                goto failed_nand;
+                goto failed_req_irq;
         }
 
         /* support for multi nand
@@ -1719,17 +1610,17 @@ static int denali_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
                 /* if MLC OOB size is large enough, use 15bit ECC*/
                 denali->nand.ecc.layout = &nand_15bit_oob;
                 denali->nand.ecc.bytes = ECC_15BITS;
-                denali_write32(15, denali->flash_reg + ECC_CORRECTION);
+                iowrite32(15, denali->flash_reg + ECC_CORRECTION);
         } else if (denali->mtd.oobsize < (denali->bbtskipbytes +
                         ECC_8BITS * (denali->mtd.writesize /
                         ECC_SECTOR_SIZE))) {
                 printk(KERN_ERR "Your NAND chip OOB is not large enough to"
                                 " contain 8bit ECC correction codes");
-                goto failed_nand;
+                goto failed_req_irq;
         } else {
                 denali->nand.ecc.layout = &nand_8bit_oob;
                 denali->nand.ecc.bytes = ECC_8BITS;
-                denali_write32(8, denali->flash_reg + ECC_CORRECTION);
+                iowrite32(8, denali->flash_reg + ECC_CORRECTION);
         }
 
         denali->nand.ecc.bytes *= denali->devnum;
@@ -1769,28 +1660,31 @@ static int denali_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
 
         if (nand_scan_tail(&denali->mtd)) {
                 ret = -ENXIO;
-                goto failed_nand;
+                goto failed_req_irq;
         }
 
         ret = add_mtd_device(&denali->mtd);
         if (ret) {
-                printk(KERN_ERR "Spectra: Failed to register"
-                                " MTD device: %d\n", ret);
-                goto failed_nand;
+                dev_err(&dev->dev, "Spectra: Failed to register MTD: %d\n",
+                                ret);
+                goto failed_req_irq;
         }
         return 0;
 
- failed_nand:
+failed_req_irq:
         denali_irq_cleanup(dev->irq, denali);
- failed_request_irq:
-        iounmap(denali->flash_reg);
+failed_remap_mem:
         iounmap(denali->flash_mem);
- failed_remap_csr:
+failed_remap_reg:
+        iounmap(denali->flash_reg);
+failed_req_regions:
         pci_release_regions(dev);
- failed_req_csr:
+failed_dma_map:
         pci_unmap_single(dev, denali->buf.dma_buf, DENALI_BUF_SIZE,
                                                         PCI_DMA_BIDIRECTIONAL);
- failed_enable:
+failed_enable_dev:
+        pci_disable_device(dev);
+failed_alloc_memery:
         kfree(denali);
         return ret;
 }
@@ -1800,9 +1694,6 @@ static void denali_pci_remove(struct pci_dev *dev)
 {
         struct denali_nand_info *denali = pci_get_drvdata(dev);
 
-        nand_dbg_print(NAND_DBG_WARN, "%s, Line %d, Function: %s\n",
-                       __FILE__, __LINE__, __func__);
-
         nand_release(&denali->mtd);
         del_mtd_device(&denali->mtd);
 
diff --git a/drivers/mtd/nand/denali.h b/drivers/mtd/nand/denali.h
index b680474e6333..3918bcb1561e 100644
--- a/drivers/mtd/nand/denali.h
+++ b/drivers/mtd/nand/denali.h
@@ -635,24 +635,6 @@
 #define CLK_X  5
 #define CLK_MULTI 4
 
-/* ffsport.h */
-#define VERBOSE    1
-
-#define NAND_DBG_WARN  1
-#define NAND_DBG_DEBUG 2
-#define NAND_DBG_TRACE 3
-
-#ifdef VERBOSE
-#define nand_dbg_print(level, args...)                          \
-        do {                                                    \
-                        if (level <= nand_debug_level)          \
-                                printk(KERN_ALERT args);        \
-        } while (0)
-#else
-#define nand_dbg_print(level, args...)
-#endif
-
-
 /* spectraswconfig.h */
 #define CMD_DMA 0
 
diff --git a/drivers/mtd/nand/nand_ids.c b/drivers/mtd/nand/nand_ids.c
index a04b89105b65..c65f19074bc8 100644
--- a/drivers/mtd/nand/nand_ids.c
+++ b/drivers/mtd/nand/nand_ids.c
@@ -112,7 +112,7 @@ struct nand_flash_dev nand_flash_ids[] = {
         {"NAND 2GiB 3,3V 16-bit",       0xC5, 0, 2048, 0, LP_OPTIONS16},
 
         /* 32 Gigabit */
-        {"NAND 4GiB 3,3V 8-bit",        0xD7, 0, 4096, 0, LP_OPTIONS16},
+        {"NAND 4GiB 3,3V 8-bit",        0xD7, 0, 4096, 0, LP_OPTIONS},
 
         /*
          * Renesas AND 1 Gigabit. Those chips do not support extended id and
diff --git a/drivers/mtd/nand/plat_nand.c b/drivers/mtd/nand/plat_nand.c
index 90e143e5ad3e..317aff428e42 100644
--- a/drivers/mtd/nand/plat_nand.c
+++ b/drivers/mtd/nand/plat_nand.c
@@ -37,6 +37,11 @@ static int __devinit plat_nand_probe(struct platform_device *pdev)
         struct resource *res;
         int err = 0;
 
+        if (pdata->chip.nr_chips < 1) {
+                dev_err(&pdev->dev, "invalid number of chips specified\n");
+                return -EINVAL;
+        }
+
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!res)
                 return -ENXIO;
diff --git a/drivers/pci/intel-iommu.c b/drivers/pci/intel-iommu.c
index b0de57947189..c3ceebb5be84 100644
--- a/drivers/pci/intel-iommu.c
+++ b/drivers/pci/intel-iommu.c
@@ -236,7 +236,7 @@ static inline u64 dma_pte_addr(struct dma_pte *pte)
         return pte->val & VTD_PAGE_MASK;
 #else
         /* Must have a full atomic 64-bit read */
-        return  __cmpxchg64(pte, 0ULL, 0ULL) & VTD_PAGE_MASK;
+        return  __cmpxchg64(&pte->val, 0ULL, 0ULL) & VTD_PAGE_MASK;
 #endif
 }
 
diff --git a/drivers/pci/intr_remapping.c b/drivers/pci/intr_remapping.c
index 1694a0e2845b..fd1d2867cdcc 100644
--- a/drivers/pci/intr_remapping.c
+++ b/drivers/pci/intr_remapping.c
@@ -21,6 +21,8 @@ static int ir_ioapic_num, ir_hpet_num;
 int intr_remapping_enabled;
 
 static int disable_intremap;
+static int disable_sourceid_checking;
+
 static __init int setup_nointremap(char *str)
 {
         disable_intremap = 1;
@@ -28,6 +30,22 @@ static __init int setup_nointremap(char *str)
 }
 early_param("nointremap", setup_nointremap);
 
+static __init int setup_intremap(char *str)
+{
+        if (!str)
+                return -EINVAL;
+
+        if (!strncmp(str, "on", 2))
+                disable_intremap = 0;
+        else if (!strncmp(str, "off", 3))
+                disable_intremap = 1;
+        else if (!strncmp(str, "nosid", 5))
+                disable_sourceid_checking = 1;
+
+        return 0;
+}
+early_param("intremap", setup_intremap);
+
 struct irq_2_iommu {
         struct intel_iommu *iommu;
         u16 irte_index;
@@ -453,6 +471,8 @@ int free_irte(int irq)
 static void set_irte_sid(struct irte *irte, unsigned int svt,
                          unsigned int sq, unsigned int sid)
 {
+        if (disable_sourceid_checking)
+                svt = SVT_NO_VERIFY;
         irte->svt = svt;
         irte->sq = sq;
         irte->sid = sid;
diff --git a/drivers/scsi/Kconfig b/drivers/scsi/Kconfig
index 6466231f338b..bbf91aec64f5 100644
--- a/drivers/scsi/Kconfig
+++ b/drivers/scsi/Kconfig
@@ -370,6 +370,14 @@ config ISCSI_TCP
 
          http://open-iscsi.org
 
+config ISCSI_BOOT_SYSFS
+        tristate "iSCSI Boot Sysfs Interface"
+        default n
+        help
+          This option enables support for exposing iSCSI boot information
+          via sysfs to userspace. If you wish to export this information,
+          say Y. Otherwise, say N.
+
 source "drivers/scsi/cxgb3i/Kconfig"
 source "drivers/scsi/bnx2i/Kconfig"
 source "drivers/scsi/be2iscsi/Kconfig"
diff --git a/drivers/scsi/Makefile b/drivers/scsi/Makefile
index 2a3fca2eca6a..2703c6ec5e36 100644
--- a/drivers/scsi/Makefile
+++ b/drivers/scsi/Makefile
@@ -42,6 +42,7 @@ obj-$(CONFIG_FCOE)		+= fcoe/
 obj-$(CONFIG_FCOE_FNIC)         += fnic/
 obj-$(CONFIG_ISCSI_TCP)         += libiscsi.o   libiscsi_tcp.o iscsi_tcp.o
 obj-$(CONFIG_INFINIBAND_ISER)   += libiscsi.o
+obj-$(CONFIG_ISCSI_BOOT_SYSFS)  += iscsi_boot_sysfs.o
 obj-$(CONFIG_SCSI_A4000T)       += 53c700.o     a4000t.o
 obj-$(CONFIG_SCSI_ZORRO7XX)     += 53c700.o     zorro7xx.o
 obj-$(CONFIG_A3000_SCSI)        += a3000.o      wd33c93.o
diff --git a/drivers/scsi/arcmsr/arcmsr_hba.c b/drivers/scsi/arcmsr/arcmsr_hba.c
index 95a895dd4f13..c8dc392edd57 100644
--- a/drivers/scsi/arcmsr/arcmsr_hba.c
+++ b/drivers/scsi/arcmsr/arcmsr_hba.c
@@ -56,6 +56,7 @@
 #include <linux/delay.h>
 #include <linux/dma-mapping.h>
 #include <linux/timer.h>
+#include <linux/slab.h>
 #include <linux/pci.h>
 #include <linux/aer.h>
 #include <asm/dma.h>
diff --git a/drivers/scsi/be2iscsi/Kconfig b/drivers/scsi/be2iscsi/Kconfig
index 84c275fb9f6b..ceaca32e788d 100644
--- a/drivers/scsi/be2iscsi/Kconfig
+++ b/drivers/scsi/be2iscsi/Kconfig
@@ -2,6 +2,7 @@ config BE2ISCSI
         tristate "ServerEngines' 10Gbps iSCSI - BladeEngine 2"
         depends on PCI && SCSI && NET
         select SCSI_ISCSI_ATTRS
+        select ISCSI_BOOT_SYSFS
 
         help
         This driver implements the iSCSI functionality for ServerEngines'
diff --git a/drivers/scsi/be2iscsi/be_cmds.h b/drivers/scsi/be2iscsi/be_cmds.h
index 40641d0845f4..5218de4ab35a 100644
--- a/drivers/scsi/be2iscsi/be_cmds.h
+++ b/drivers/scsi/be2iscsi/be_cmds.h
@@ -162,6 +162,13 @@ struct be_mcc_mailbox {
 #define OPCODE_COMMON_ISCSI_CFG_POST_SGL_PAGES          2
 #define OPCODE_COMMON_ISCSI_CFG_REMOVE_SGL_PAGES        3
 #define OPCODE_COMMON_ISCSI_NTWK_GET_NIC_CONFIG         7
+#define OPCODE_COMMON_ISCSI_NTWK_SET_VLAN               14
+#define OPCODE_COMMON_ISCSI_NTWK_CONFIGURE_STATELESS_IP_ADDR    17
+#define OPCODE_COMMON_ISCSI_NTWK_MODIFY_IP_ADDR         21
+#define OPCODE_COMMON_ISCSI_NTWK_GET_DEFAULT_GATEWAY    22
+#define OPCODE_COMMON_ISCSI_NTWK_MODIFY_DEFAULT_GATEWAY 23
+#define OPCODE_COMMON_ISCSI_NTWK_GET_ALL_IF_ID          24
+#define OPCODE_COMMON_ISCSI_NTWK_GET_IF_INFO            25
 #define OPCODE_COMMON_ISCSI_SET_FRAGNUM_BITS_FOR_SGL_CRA 61
 #define OPCODE_COMMON_ISCSI_DEFQ_CREATE                 64
 #define OPCODE_COMMON_ISCSI_DEFQ_DESTROY                65
@@ -237,11 +244,109 @@ struct be_cmd_resp_eq_create {
         u16 rsvd0;              /* sword */
 } __packed;
 
+struct mgmt_chap_format {
+        u32 flags;
+        u8  intr_chap_name[256];
+        u8  intr_secret[16];
+        u8  target_chap_name[256];
+        u8  target_secret[16];
+        u16 intr_chap_name_length;
+        u16 intr_secret_length;
+        u16 target_chap_name_length;
+        u16 target_secret_length;
+} __packed;
+
+struct mgmt_auth_method_format {
+        u8      auth_method_type;
+        u8      padding[3];
+        struct  mgmt_chap_format chap;
+} __packed;
+
+struct mgmt_conn_login_options {
+        u8 flags;
+        u8 header_digest;
+        u8 data_digest;
+        u8 rsvd0;
+        u32 max_recv_datasegment_len_ini;
+        u32 max_recv_datasegment_len_tgt;
+        u32 tcp_mss;
+        u32 tcp_window_size;
+        struct  mgmt_auth_method_format auth_data;
+} __packed;
+
+struct ip_address_format {
+        u16 size_of_structure;
+        u8 reserved;
+        u8 ip_type;
+        u8 ip_address[16];
+        u32 rsvd0;
+} __packed;
+
+struct  mgmt_conn_info {
+        u32     connection_handle;
+        u32     connection_status;
+        u16     src_port;
+        u16     dest_port;
+        u16     dest_port_redirected;
+        u16     cid;
+        u32     estimated_throughput;
+        struct  ip_address_format       src_ipaddr;
+        struct  ip_address_format       dest_ipaddr;
+        struct  ip_address_format       dest_ipaddr_redirected;
+        struct  mgmt_conn_login_options negotiated_login_options;
+} __packed;
+
+struct mgmt_session_login_options {
+        u8      flags;
+        u8      error_recovery_level;
+        u16     rsvd0;
+        u32     first_burst_length;
+        u32     max_burst_length;
+        u16     max_connections;
+        u16     max_outstanding_r2t;
+        u16     default_time2wait;
+        u16     default_time2retain;
+} __packed;
+
+struct mgmt_session_info {
+        u32     session_handle;
+        u32     status;
+        u8      isid[6];
+        u16     tsih;
+        u32     session_flags;
+        u16     conn_count;
+        u16     pad;
+        u8      target_name[224];
+        u8      initiator_iscsiname[224];
+        struct  mgmt_session_login_options negotiated_login_options;
+        struct  mgmt_conn_info  conn_list[1];
+} __packed;
+
+struct  be_cmd_req_get_session {
+        struct be_cmd_req_hdr hdr;
+        u32 session_handle;
+} __packed;
+
+struct  be_cmd_resp_get_session {
+        struct be_cmd_resp_hdr hdr;
+        struct mgmt_session_info session_info;
+} __packed;
+
 struct mac_addr {
         u16 size_of_struct;
         u8 addr[ETH_ALEN];
 } __packed;
 
+struct be_cmd_req_get_boot_target {
+        struct be_cmd_req_hdr hdr;
+} __packed;
+
+struct be_cmd_resp_get_boot_target {
+        struct be_cmd_resp_hdr hdr;
+        u32  boot_session_count;
+        int  boot_session_handle;
+};
+
 struct be_cmd_req_mac_query {
         struct be_cmd_req_hdr hdr;
         u8 type;
@@ -426,6 +531,11 @@ int be_poll_mcc(struct be_ctrl_info *ctrl);
 int mgmt_check_supported_fw(struct be_ctrl_info *ctrl,
                                       struct beiscsi_hba *phba);
 unsigned int be_cmd_get_mac_addr(struct beiscsi_hba *phba);
+unsigned int beiscsi_get_boot_target(struct beiscsi_hba *phba);
+unsigned int beiscsi_get_session_info(struct beiscsi_hba *phba,
+                                  u32 boot_session_handle,
+                                  struct be_dma_mem *nonemb_cmd);
+
 void free_mcc_tag(struct be_ctrl_info *ctrl, unsigned int tag);
 /*ISCSI Functuions */
 int be_cmd_fw_initialize(struct be_ctrl_info *ctrl);
@@ -601,14 +711,6 @@ struct be_eq_delay_params_in {
         struct eq_delay delay[8];
 } __packed;
 
-struct ip_address_format {
-        u16 size_of_structure;
-        u8 reserved;
-        u8 ip_type;
-        u8 ip_address[16];
-        u32 rsvd0;
-} __packed;
-
 struct tcp_connect_and_offload_in {
         struct be_cmd_req_hdr hdr;
         struct ip_address_format ip_address;
@@ -688,18 +790,29 @@ struct be_fw_cfg {
         u32 function_caps;
 } __packed;
 
-#define CMD_ISCSI_COMMAND_INVALIDATE  1
-#define ISCSI_OPCODE_SCSI_DATA_OUT      5
+struct be_all_if_id {
+        struct be_cmd_req_hdr hdr;
+        u32 if_count;
+        u32 if_hndl_list[1];
+} __packed;
+
+#define ISCSI_OPCODE_SCSI_DATA_OUT              5
+#define OPCODE_COMMON_MODIFY_EQ_DELAY           41
+#define OPCODE_COMMON_ISCSI_CLEANUP             59
+#define OPCODE_COMMON_TCP_UPLOAD                56
 #define OPCODE_COMMON_ISCSI_TCP_CONNECT_AND_OFFLOAD 70
-#define OPCODE_ISCSI_INI_DRIVER_OFFLOAD_SESSION 41
-#define OPCODE_COMMON_MODIFY_EQ_DELAY   41
-#define OPCODE_COMMON_ISCSI_CLEANUP     59
-#define OPCODE_COMMON_TCP_UPLOAD        56
 #define OPCODE_COMMON_ISCSI_ERROR_RECOVERY_INVALIDATE_COMMANDS 1
-/* --- CMD_ISCSI_INVALIDATE_CONNECTION_TYPE --- */
-#define CMD_ISCSI_CONNECTION_INVALIDATE 0x8001
-#define CMD_ISCSI_CONNECTION_ISSUE_TCP_RST 0x8002
+#define OPCODE_ISCSI_INI_CFG_GET_HBA_NAME       6
+#define OPCODE_ISCSI_INI_CFG_SET_HBA_NAME       7
+#define OPCODE_ISCSI_INI_SESSION_GET_A_SESSION  14
+#define OPCODE_ISCSI_INI_DRIVER_OFFLOAD_SESSION 41
 #define OPCODE_ISCSI_INI_DRIVER_INVALIDATE_CONNECTION 42
+#define OPCODE_ISCSI_INI_BOOT_GET_BOOT_TARGET   52
+
+/* --- CMD_ISCSI_INVALIDATE_CONNECTION_TYPE --- */
+#define CMD_ISCSI_COMMAND_INVALIDATE            1
+#define CMD_ISCSI_CONNECTION_INVALIDATE         0x8001
+#define CMD_ISCSI_CONNECTION_ISSUE_TCP_RST      0x8002
 
 #define INI_WR_CMD                      1       /* Initiator write command */
 #define INI_TMF_CMD                     2       /* Initiator TMF command */
diff --git a/drivers/scsi/be2iscsi/be_iscsi.c b/drivers/scsi/be2iscsi/be_iscsi.c
index 6d63e7b312cf..7d4d2275573c 100644
--- a/drivers/scsi/be2iscsi/be_iscsi.c
+++ b/drivers/scsi/be2iscsi/be_iscsi.c
@@ -300,40 +300,16 @@ int beiscsi_get_host_param(struct Scsi_Host *shost,
                            enum iscsi_host_param param, char *buf)
 {
         struct beiscsi_hba *phba = (struct beiscsi_hba *)iscsi_host_priv(shost);
-        struct be_cmd_resp_get_mac_addr *resp;
-        struct be_mcc_wrb *wrb;
-        unsigned int tag, wrb_num;
         int len = 0;
-        unsigned short status, extd_status;
-        struct be_queue_info *mccq = &phba->ctrl.mcc_obj.q;
+        int status;
 
         SE_DEBUG(DBG_LVL_8, "In beiscsi_get_host_param, param= %d\n", param);
         switch (param) {
         case ISCSI_HOST_PARAM_HWADDRESS:
-                tag = be_cmd_get_mac_addr(phba);
-                if (!tag) {
-                        SE_DEBUG(DBG_LVL_1, "be_cmd_get_mac_addr Failed\n");
-                        return -EAGAIN;
-                } else
-                        wait_event_interruptible(phba->ctrl.mcc_wait[tag],
-                                                 phba->ctrl.mcc_numtag[tag]);
-
-                wrb_num = (phba->ctrl.mcc_numtag[tag] & 0x00FF0000) >> 16;
-                extd_status = (phba->ctrl.mcc_numtag[tag] & 0x0000FF00) >> 8;
-                status = phba->ctrl.mcc_numtag[tag] & 0x000000FF;
-                if (status || extd_status) {
-                        SE_DEBUG(DBG_LVL_1, "be_cmd_get_mac_addr Failed"
-                                            " status = %d extd_status = %d\n",
-                                            status, extd_status);
-                        free_mcc_tag(&phba->ctrl, tag);
-                        return -EAGAIN;
-                } else {
-                        wrb = queue_get_wrb(mccq, wrb_num);
-                        free_mcc_tag(&phba->ctrl, tag);
-                        resp = embedded_payload(wrb);
-                        memcpy(phba->mac_address, resp->mac_address, ETH_ALEN);
-                        len = sysfs_format_mac(buf, phba->mac_address,
-                                               ETH_ALEN);
+                status = beiscsi_get_macaddr(buf, phba);
+                if (status < 0) {
+                        SE_DEBUG(DBG_LVL_1, "beiscsi_get_macaddr Failed\n");
+                        return status;
                 }
                 break;
         default:
@@ -342,6 +318,48 @@ int beiscsi_get_host_param(struct Scsi_Host *shost,
         return len;
 }
 
+int beiscsi_get_macaddr(char *buf, struct beiscsi_hba *phba)
+{
+        struct be_cmd_resp_get_mac_addr *resp;
+        struct be_mcc_wrb *wrb;
+        unsigned int tag, wrb_num;
+        unsigned short status, extd_status;
+        struct be_queue_info *mccq = &phba->ctrl.mcc_obj.q;
+        int rc;
+
+        if (phba->read_mac_address)
+                return sysfs_format_mac(buf, phba->mac_address,
+                                        ETH_ALEN);
+
+        tag = be_cmd_get_mac_addr(phba);
+        if (!tag) {
+                SE_DEBUG(DBG_LVL_1, "be_cmd_get_mac_addr Failed\n");
+                return -EBUSY;
+        } else
+                wait_event_interruptible(phba->ctrl.mcc_wait[tag],
+                                         phba->ctrl.mcc_numtag[tag]);
+
+        wrb_num = (phba->ctrl.mcc_numtag[tag] & 0x00FF0000) >> 16;
+        extd_status = (phba->ctrl.mcc_numtag[tag] & 0x0000FF00) >> 8;
+        status = phba->ctrl.mcc_numtag[tag] & 0x000000FF;
+        if (status || extd_status) {
+                SE_DEBUG(DBG_LVL_1, "Failed to get be_cmd_get_mac_addr"
+                                    " status = %d extd_status = %d\n",
+                                    status, extd_status);
+                free_mcc_tag(&phba->ctrl, tag);
+                return -EAGAIN;
+        }
+        wrb = queue_get_wrb(mccq, wrb_num);
+        free_mcc_tag(&phba->ctrl, tag);
+        resp = embedded_payload(wrb);
+        memcpy(phba->mac_address, resp->mac_address, ETH_ALEN);
+        rc = sysfs_format_mac(buf, phba->mac_address,
+                               ETH_ALEN);
+        phba->read_mac_address = 1;
+        return rc;
+}
+
+
 /**
  * beiscsi_conn_get_stats - get the iscsi stats
  * @cls_conn: pointer to iscsi cls conn
diff --git a/drivers/scsi/be2iscsi/be_iscsi.h b/drivers/scsi/be2iscsi/be_iscsi.h
index 870cdb2a73e4..8950a702b9f4 100644
--- a/drivers/scsi/be2iscsi/be_iscsi.h
+++ b/drivers/scsi/be2iscsi/be_iscsi.h
@@ -54,6 +54,8 @@ int beiscsi_conn_get_param(struct iscsi_cls_conn *cls_conn,
 int beiscsi_get_host_param(struct Scsi_Host *shost,
                            enum iscsi_host_param param, char *buf);
 
+int beiscsi_get_macaddr(char *buf, struct beiscsi_hba *phba);
+
 int beiscsi_set_param(struct iscsi_cls_conn *cls_conn,
                       enum iscsi_param param, char *buf, int buflen);
 
diff --git a/drivers/scsi/be2iscsi/be_main.c b/drivers/scsi/be2iscsi/be_main.c
index 7436c5ad5697..8220bde6c04c 100644
--- a/drivers/scsi/be2iscsi/be_main.c
+++ b/drivers/scsi/be2iscsi/be_main.c
@@ -26,6 +26,7 @@
 #include <linux/string.h>
 #include <linux/kernel.h>
 #include <linux/semaphore.h>
+#include <linux/iscsi_boot_sysfs.h>
 
 #include <scsi/libiscsi.h>
 #include <scsi/scsi_transport_iscsi.h>
@@ -211,6 +212,218 @@ unlock:
         return rc;
 }
 
+static ssize_t beiscsi_show_boot_tgt_info(void *data, int type, char *buf)
+{
+        struct beiscsi_hba *phba = data;
+        char *str = buf;
+        int rc;
+
+        switch (type) {
+        case ISCSI_BOOT_TGT_NAME:
+                rc = sprintf(buf, "%.*s\n",
+                                (int)strlen(phba->boot_sess.target_name),
+                                (char *)&phba->boot_sess.target_name);
+                break;
+        case ISCSI_BOOT_TGT_IP_ADDR:
+                if (phba->boot_sess.conn_list[0].dest_ipaddr.ip_type == 0x1)
+                        rc = sprintf(buf, "%pI4\n",
+                                (char *)&phba->boot_sess.conn_list[0].
+                                dest_ipaddr.ip_address);
+                else
+                        rc = sprintf(str, "%pI6\n",
+                                (char *)&phba->boot_sess.conn_list[0].
+                                dest_ipaddr.ip_address);
+                break;
+        case ISCSI_BOOT_TGT_PORT:
+                rc = sprintf(str, "%d\n", phba->boot_sess.conn_list[0].
+                                  dest_port);
+                break;
+
+        case ISCSI_BOOT_TGT_CHAP_NAME:
+                rc = sprintf(str,  "%.*s\n",
+                                      phba->boot_sess.conn_list[0].
+                                      negotiated_login_options.auth_data.chap.
+                                      target_chap_name_length,
+                                      (char *)&phba->boot_sess.conn_list[0].
+                                      negotiated_login_options.auth_data.chap.
+                                      target_chap_name);
+                break;
+        case ISCSI_BOOT_TGT_CHAP_SECRET:
+                rc = sprintf(str,  "%.*s\n",
+                                      phba->boot_sess.conn_list[0].
+                                      negotiated_login_options.auth_data.chap.
+                                      target_secret_length,
+                                      (char *)&phba->boot_sess.conn_list[0].
+                                      negotiated_login_options.auth_data.chap.
+                                      target_secret);
+
+                break;
+        case ISCSI_BOOT_TGT_REV_CHAP_NAME:
+                rc = sprintf(str,  "%.*s\n",
+                                      phba->boot_sess.conn_list[0].
+                                      negotiated_login_options.auth_data.chap.
+                                      intr_chap_name_length,
+                                      (char *)&phba->boot_sess.conn_list[0].
+                                      negotiated_login_options.auth_data.chap.
+                                      intr_chap_name);
+
+                break;
+        case ISCSI_BOOT_TGT_REV_CHAP_SECRET:
+                        rc = sprintf(str,  "%.*s\n",
+                                      phba->boot_sess.conn_list[0].
+                                      negotiated_login_options.auth_data.chap.
+                                      intr_secret_length,
+                                      (char *)&phba->boot_sess.conn_list[0].
+                                      negotiated_login_options.auth_data.chap.
+                                      intr_secret);
+                break;
+        case ISCSI_BOOT_TGT_FLAGS:
+                        rc = sprintf(str, "2\n");
+                break;
+        case ISCSI_BOOT_TGT_NIC_ASSOC:
+                        rc = sprintf(str, "0\n");
+                break;
+        default:
+                rc = -ENOSYS;
+                break;
+        }
+        return rc;
+}
+
+static ssize_t beiscsi_show_boot_ini_info(void *data, int type, char *buf)
+{
+        struct beiscsi_hba *phba = data;
+        char *str = buf;
+        int rc;
+
+        switch (type) {
+        case ISCSI_BOOT_INI_INITIATOR_NAME:
+                rc = sprintf(str, "%s\n", phba->boot_sess.initiator_iscsiname);
+                break;
+        default:
+                rc = -ENOSYS;
+                break;
+        }
+        return rc;
+}
+
+static ssize_t beiscsi_show_boot_eth_info(void *data, int type, char *buf)
+{
+        struct beiscsi_hba *phba = data;
+        char *str = buf;
+        int rc;
+
+        switch (type) {
+        case ISCSI_BOOT_ETH_FLAGS:
+                        rc = sprintf(str, "2\n");
+                break;
+        case ISCSI_BOOT_ETH_INDEX:
+                        rc = sprintf(str, "0\n");
+                break;
+        case ISCSI_BOOT_ETH_MAC:
+                rc  = beiscsi_get_macaddr(buf, phba);
+                if (rc < 0) {
+                        SE_DEBUG(DBG_LVL_1, "beiscsi_get_macaddr Failed\n");
+                        return rc;
+                }
+        break;
+        default:
+                rc = -ENOSYS;
+                break;
+        }
+        return rc;
+}
+
+
+static mode_t beiscsi_tgt_get_attr_visibility(void *data, int type)
+{
+        int rc;
+
+        switch (type) {
+        case ISCSI_BOOT_TGT_NAME:
+        case ISCSI_BOOT_TGT_IP_ADDR:
+        case ISCSI_BOOT_TGT_PORT:
+        case ISCSI_BOOT_TGT_CHAP_NAME:
+        case ISCSI_BOOT_TGT_CHAP_SECRET:
+        case ISCSI_BOOT_TGT_REV_CHAP_NAME:
+        case ISCSI_BOOT_TGT_REV_CHAP_SECRET:
+        case ISCSI_BOOT_TGT_NIC_ASSOC:
+        case ISCSI_BOOT_TGT_FLAGS:
+                rc = S_IRUGO;
+                break;
+        default:
+                rc = 0;
+                break;
+        }
+        return rc;
+}
+
+static mode_t beiscsi_ini_get_attr_visibility(void *data, int type)
+{
+        int rc;
+
+        switch (type) {
+        case ISCSI_BOOT_INI_INITIATOR_NAME:
+                rc = S_IRUGO;
+                break;
+        default:
+                rc = 0;
+                break;
+        }
+        return rc;
+}
+
+
+static mode_t beiscsi_eth_get_attr_visibility(void *data, int type)
+{
+        int rc;
+
+        switch (type) {
+        case ISCSI_BOOT_ETH_FLAGS:
+        case ISCSI_BOOT_ETH_MAC:
+        case ISCSI_BOOT_ETH_INDEX:
+                rc = S_IRUGO;
+                break;
+        default:
+                rc = 0;
+                break;
+        }
+        return rc;
+}
+
+static int beiscsi_setup_boot_info(struct beiscsi_hba *phba)
+{
+        struct iscsi_boot_kobj *boot_kobj;
+
+        phba->boot_kset = iscsi_boot_create_host_kset(phba->shost->host_no);
+        if (!phba->boot_kset)
+                return -ENOMEM;
+
+        /* get boot info using mgmt cmd */
+        boot_kobj = iscsi_boot_create_target(phba->boot_kset, 0, phba,
+                                             beiscsi_show_boot_tgt_info,
+                                             beiscsi_tgt_get_attr_visibility);
+        if (!boot_kobj)
+                goto free_kset;
+
+        boot_kobj = iscsi_boot_create_initiator(phba->boot_kset, 0, phba,
+                                             beiscsi_show_boot_ini_info,
+                                             beiscsi_ini_get_attr_visibility);
+        if (!boot_kobj)
+                goto free_kset;
+
+        boot_kobj = iscsi_boot_create_ethernet(phba->boot_kset, 0, phba,
+                                             beiscsi_show_boot_eth_info,
+                                             beiscsi_eth_get_attr_visibility);
+        if (!boot_kobj)
+                goto free_kset;
+        return 0;
+
+free_kset:
+        iscsi_boot_destroy_kset(phba->boot_kset);
+        return -ENOMEM;
+}
+
 /*------------------- PCI Driver operations and data ----------------- */
 static DEFINE_PCI_DEVICE_TABLE(beiscsi_pci_id_table) = {
         { PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID1) },
@@ -268,6 +481,15 @@ static struct beiscsi_hba *beiscsi_hba_alloc(struct pci_dev *pcidev)
 
         if (iscsi_host_add(shost, &phba->pcidev->dev))
                 goto free_devices;
+
+        if (beiscsi_setup_boot_info(phba))
+                /*
+                 * log error but continue, because we may not be using
+                 * iscsi boot.
+                 */
+                shost_printk(KERN_ERR, phba->shost, "Could not set up "
+                "iSCSI boot info.");
+
         return phba;
 
 free_devices:
@@ -3279,6 +3501,89 @@ static void hwi_disable_intr(struct beiscsi_hba *phba)
                              "In hwi_disable_intr, Already Disabled\n");
 }
 
+static int beiscsi_get_boot_info(struct beiscsi_hba *phba)
+{
+        struct be_cmd_resp_get_boot_target *boot_resp;
+        struct be_cmd_resp_get_session *session_resp;
+        struct be_mcc_wrb *wrb;
+        struct be_dma_mem nonemb_cmd;
+        unsigned int tag, wrb_num;
+        unsigned short status, extd_status;
+        struct be_queue_info *mccq = &phba->ctrl.mcc_obj.q;
+
+        tag = beiscsi_get_boot_target(phba);
+        if (!tag) {
+                SE_DEBUG(DBG_LVL_1, "be_cmd_get_mac_addr Failed\n");
+                return -EAGAIN;
+        } else
+                wait_event_interruptible(phba->ctrl.mcc_wait[tag],
+                                         phba->ctrl.mcc_numtag[tag]);
+
+        wrb_num = (phba->ctrl.mcc_numtag[tag] & 0x00FF0000) >> 16;
+        extd_status = (phba->ctrl.mcc_numtag[tag] & 0x0000FF00) >> 8;
+        status = phba->ctrl.mcc_numtag[tag] & 0x000000FF;
+        if (status || extd_status) {
+                SE_DEBUG(DBG_LVL_1, "be_cmd_get_mac_addr Failed"
+                                    " status = %d extd_status = %d\n",
+                                    status, extd_status);
+                free_mcc_tag(&phba->ctrl, tag);
+                return -EBUSY;
+        }
+        wrb = queue_get_wrb(mccq, wrb_num);
+        free_mcc_tag(&phba->ctrl, tag);
+        boot_resp = embedded_payload(wrb);
+
+        if (boot_resp->boot_session_handle < 0) {
+                printk(KERN_ERR "No Boot Session for this pci_func,"
+                        "session Hndl = %d\n", boot_resp->boot_session_handle);
+                return -ENXIO;
+        }
+
+        nonemb_cmd.va = pci_alloc_consistent(phba->ctrl.pdev,
+                                sizeof(*session_resp),
+                                &nonemb_cmd.dma);
+        if (nonemb_cmd.va == NULL) {
+                SE_DEBUG(DBG_LVL_1,
+                         "Failed to allocate memory for"
+                         "beiscsi_get_session_info\n");
+                return -ENOMEM;
+        }
+
+        memset(nonemb_cmd.va, 0, sizeof(*session_resp));
+        tag = beiscsi_get_session_info(phba,
+                boot_resp->boot_session_handle, &nonemb_cmd);
+        if (!tag) {
+                SE_DEBUG(DBG_LVL_1, "beiscsi_get_session_info"
+                        " Failed\n");
+                goto boot_freemem;
+        } else
+                wait_event_interruptible(phba->ctrl.mcc_wait[tag],
+                                         phba->ctrl.mcc_numtag[tag]);
+
+        wrb_num = (phba->ctrl.mcc_numtag[tag] & 0x00FF0000) >> 16;
+        extd_status = (phba->ctrl.mcc_numtag[tag] & 0x0000FF00) >> 8;
+        status = phba->ctrl.mcc_numtag[tag] & 0x000000FF;
+        if (status || extd_status) {
+                SE_DEBUG(DBG_LVL_1, "beiscsi_get_session_info Failed"
+                                    " status = %d extd_status = %d\n",
+                                    status, extd_status);
+                free_mcc_tag(&phba->ctrl, tag);
+                goto boot_freemem;
+        }
+        wrb = queue_get_wrb(mccq, wrb_num);
+        free_mcc_tag(&phba->ctrl, tag);
+        session_resp = nonemb_cmd.va ;
+        memcpy(&phba->boot_sess, &session_resp->session_info,
+               sizeof(struct mgmt_session_info));
+        pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
+                    nonemb_cmd.va, nonemb_cmd.dma);
+        return 0;
+boot_freemem:
+        pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
+                    nonemb_cmd.va, nonemb_cmd.dma);
+        return -ENOMEM;
+}
+
 static int beiscsi_init_port(struct beiscsi_hba *phba)
 {
         int ret;
@@ -3841,6 +4146,7 @@ static void beiscsi_remove(struct pci_dev *pcidev)
         iscsi_host_remove(phba->shost);
         pci_dev_put(phba->pcidev);
         iscsi_host_free(phba->shost);
+        iscsi_boot_destroy_kset(phba->boot_kset);
 }
 
 static void beiscsi_msix_enable(struct beiscsi_hba *phba)
@@ -3996,6 +4302,11 @@ static int __devinit beiscsi_dev_probe(struct pci_dev *pcidev,
                 goto free_blkenbld;
         }
         hwi_enable_intr(phba);
+        ret = beiscsi_get_boot_info(phba);
+        if (ret < 0) {
+                shost_printk(KERN_ERR, phba->shost, "beiscsi_dev_probe-"
+                             "No Boot Devices !!!!!\n");
+        }
         SE_DEBUG(DBG_LVL_8, "\n\n\n SUCCESS - DRIVER LOADED\n\n\n");
         return 0;
 
diff --git a/drivers/scsi/be2iscsi/be_main.h b/drivers/scsi/be2iscsi/be_main.h
index c643bb3736fc..90eb74f6bcab 100644
--- a/drivers/scsi/be2iscsi/be_main.h
+++ b/drivers/scsi/be2iscsi/be_main.h
@@ -35,7 +35,7 @@
 
 #include "be.h"
 #define DRV_NAME                "be2iscsi"
-#define BUILD_STR               "2.0.527.0"
+#define BUILD_STR               "2.0.549.0"
 #define BE_NAME                 "ServerEngines BladeEngine2" \
                                 "Linux iSCSI Driver version" BUILD_STR
 #define DRV_DESC                BE_NAME " " "Driver"
@@ -63,7 +63,7 @@
 #define BEISCSI_SGLIST_ELEMENTS 30
 
 #define BEISCSI_CMD_PER_LUN     128     /* scsi_host->cmd_per_lun */
-#define BEISCSI_MAX_SECTORS     256     /* scsi_host->max_sectors */
+#define BEISCSI_MAX_SECTORS     2048    /* scsi_host->max_sectors */
 
 #define BEISCSI_MAX_CMD_LEN     16      /* scsi_host->max_cmd_len */
 #define BEISCSI_NUM_MAX_LUN     256     /* scsi_host->max_lun */
@@ -312,6 +312,7 @@ struct beiscsi_hba {
         struct list_head hba_queue;
         unsigned short *cid_array;
         struct iscsi_endpoint **ep_array;
+        struct iscsi_boot_kset *boot_kset;
         struct Scsi_Host *shost;
         struct {
                 /**
@@ -342,6 +343,8 @@ struct beiscsi_hba {
         struct work_struct work_cqs;    /* The work being queued */
         struct be_ctrl_info ctrl;
         unsigned int generation;
+        unsigned int read_mac_address;
+        struct mgmt_session_info boot_sess;
         struct invalidate_command_table inv_tbl[128];
 
 };
diff --git a/drivers/scsi/be2iscsi/be_mgmt.c b/drivers/scsi/be2iscsi/be_mgmt.c
index 3f3fab91a7d1..26350e470bcc 100644
--- a/drivers/scsi/be2iscsi/be_mgmt.c
+++ b/drivers/scsi/be2iscsi/be_mgmt.c
@@ -20,6 +20,77 @@
 
 #include "be_mgmt.h"
 #include "be_iscsi.h"
+#include <scsi/scsi_transport_iscsi.h>
+
+unsigned int beiscsi_get_boot_target(struct beiscsi_hba *phba)
+{
+        struct be_ctrl_info *ctrl = &phba->ctrl;
+        struct be_mcc_wrb *wrb;
+        struct be_cmd_req_get_mac_addr *req;
+        unsigned int tag = 0;
+
+        SE_DEBUG(DBG_LVL_8, "In bescsi_get_boot_target\n");
+        spin_lock(&ctrl->mbox_lock);
+        tag = alloc_mcc_tag(phba);
+        if (!tag) {
+                spin_unlock(&ctrl->mbox_lock);
+                return tag;
+        }
+
+        wrb = wrb_from_mccq(phba);
+        req = embedded_payload(wrb);
+        wrb->tag0 |= tag;
+        be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
+        be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI_INI,
+                           OPCODE_ISCSI_INI_BOOT_GET_BOOT_TARGET,
+                           sizeof(*req));
+
+        be_mcc_notify(phba);
+        spin_unlock(&ctrl->mbox_lock);
+        return tag;
+}
+
+unsigned int beiscsi_get_session_info(struct beiscsi_hba *phba,
+                                  u32 boot_session_handle,
+                                  struct be_dma_mem *nonemb_cmd)
+{
+        struct be_ctrl_info *ctrl = &phba->ctrl;
+        struct be_mcc_wrb *wrb;
+        unsigned int tag = 0;
+        struct  be_cmd_req_get_session *req;
+        struct be_cmd_resp_get_session *resp;
+        struct be_sge *sge;
+
+        SE_DEBUG(DBG_LVL_8, "In beiscsi_get_session_info\n");
+        spin_lock(&ctrl->mbox_lock);
+        tag = alloc_mcc_tag(phba);
+        if (!tag) {
+                spin_unlock(&ctrl->mbox_lock);
+                return tag;
+        }
+
+        nonemb_cmd->size = sizeof(*resp);
+        req = nonemb_cmd->va;
+        memset(req, 0, sizeof(*req));
+        wrb = wrb_from_mccq(phba);
+        sge = nonembedded_sgl(wrb);
+        wrb->tag0 |= tag;
+
+
+        wrb->tag0 |= tag;
+        be_wrb_hdr_prepare(wrb, sizeof(*req), false, 1);
+        be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI_INI,
+                           OPCODE_ISCSI_INI_SESSION_GET_A_SESSION,
+                           sizeof(*resp));
+        req->session_handle = boot_session_handle;
+        sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd->dma));
+        sge->pa_lo = cpu_to_le32(nonemb_cmd->dma & 0xFFFFFFFF);
+        sge->len = cpu_to_le32(nonemb_cmd->size);
+
+        be_mcc_notify(phba);
+        spin_unlock(&ctrl->mbox_lock);
+        return tag;
+}
 
 int mgmt_get_fw_config(struct be_ctrl_info *ctrl,
                                 struct beiscsi_hba *phba)
diff --git a/drivers/scsi/ibmvscsi/ibmvfc.c b/drivers/scsi/ibmvscsi/ibmvfc.c
index bd96cecaa619..9f75a6d519a2 100644
--- a/drivers/scsi/ibmvscsi/ibmvfc.c
+++ b/drivers/scsi/ibmvscsi/ibmvfc.c
@@ -433,6 +433,9 @@ static void ibmvfc_set_tgt_action(struct ibmvfc_target *tgt,
 {
         switch (tgt->action) {
         case IBMVFC_TGT_ACTION_DEL_RPORT:
+                if (action == IBMVFC_TGT_ACTION_DELETED_RPORT)
+                        tgt->action = action;
+        case IBMVFC_TGT_ACTION_DELETED_RPORT:
                 break;
         default:
                 if (action == IBMVFC_TGT_ACTION_DEL_RPORT)
@@ -2036,95 +2039,108 @@ static int ibmvfc_reset_device(struct scsi_device *sdev, int type, char *desc)
 }
 
 /**
- * ibmvfc_abort_task_set - Abort outstanding commands to the device
- * @sdev:       scsi device to abort commands
- *
- * This sends an Abort Task Set to the VIOS for the specified device. This does
- * NOT send any cancel to the VIOS. That must be done separately.
+ * ibmvfc_match_rport - Match function for specified remote port
+ * @evt:        ibmvfc event struct
+ * @device:     device to match (rport)
  *
  * Returns:
- *      0 on success / other on failure
+ *      1 if event matches rport / 0 if event does not match rport
  **/
-static int ibmvfc_abort_task_set(struct scsi_device *sdev)
+static int ibmvfc_match_rport(struct ibmvfc_event *evt, void *rport)
 {
-        struct ibmvfc_host *vhost = shost_priv(sdev->host);
-        struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
-        struct ibmvfc_cmd *tmf;
-        struct ibmvfc_event *evt, *found_evt;
-        union ibmvfc_iu rsp_iu;
-        struct ibmvfc_fcp_rsp *fc_rsp = &rsp_iu.cmd.rsp;
-        int rsp_rc = -EBUSY;
-        unsigned long flags;
-        int rsp_code = 0;
+        struct fc_rport *cmd_rport;
 
-        spin_lock_irqsave(vhost->host->host_lock, flags);
-        found_evt = NULL;
-        list_for_each_entry(evt, &vhost->sent, queue) {
-                if (evt->cmnd && evt->cmnd->device == sdev) {
-                        found_evt = evt;
-                        break;
-                }
-        }
-
-        if (!found_evt) {
-                if (vhost->log_level > IBMVFC_DEFAULT_LOG_LEVEL)
-                        sdev_printk(KERN_INFO, sdev, "No events found to abort\n");
-                spin_unlock_irqrestore(vhost->host->host_lock, flags);
-                return 0;
-        }
-
-        if (vhost->state == IBMVFC_ACTIVE) {
-                evt = ibmvfc_get_event(vhost);
-                ibmvfc_init_event(evt, ibmvfc_sync_completion, IBMVFC_CMD_FORMAT);
-
-                tmf = &evt->iu.cmd;
-                memset(tmf, 0, sizeof(*tmf));
-                tmf->resp.va = (u64)evt->crq.ioba + offsetof(struct ibmvfc_cmd, rsp);
-                tmf->resp.len = sizeof(tmf->rsp);
-                tmf->frame_type = IBMVFC_SCSI_FCP_TYPE;
-                tmf->payload_len = sizeof(tmf->iu);
-                tmf->resp_len = sizeof(tmf->rsp);
-                tmf->cancel_key = (unsigned long)sdev->hostdata;
-                tmf->tgt_scsi_id = rport->port_id;
-                int_to_scsilun(sdev->lun, &tmf->iu.lun);
-                tmf->flags = (IBMVFC_NO_MEM_DESC | IBMVFC_TMF);
-                tmf->iu.tmf_flags = IBMVFC_ABORT_TASK_SET;
-                evt->sync_iu = &rsp_iu;
-
-                init_completion(&evt->comp);
-                rsp_rc = ibmvfc_send_event(evt, vhost, default_timeout);
+        if (evt->cmnd) {
+                cmd_rport = starget_to_rport(scsi_target(evt->cmnd->device));
+                if (cmd_rport == rport)
+                        return 1;
         }
+        return 0;
+}
 
-        spin_unlock_irqrestore(vhost->host->host_lock, flags);
+/**
+ * ibmvfc_match_target - Match function for specified target
+ * @evt:        ibmvfc event struct
+ * @device:     device to match (starget)
+ *
+ * Returns:
+ *      1 if event matches starget / 0 if event does not match starget
+ **/
+static int ibmvfc_match_target(struct ibmvfc_event *evt, void *device)
+{
+        if (evt->cmnd && scsi_target(evt->cmnd->device) == device)
+                return 1;
+        return 0;
+}
 
-        if (rsp_rc != 0) {
-                sdev_printk(KERN_ERR, sdev, "Failed to send abort. rc=%d\n", rsp_rc);
-                return -EIO;
-        }
+/**
+ * ibmvfc_match_lun - Match function for specified LUN
+ * @evt:        ibmvfc event struct
+ * @device:     device to match (sdev)
+ *
+ * Returns:
+ *      1 if event matches sdev / 0 if event does not match sdev
+ **/
+static int ibmvfc_match_lun(struct ibmvfc_event *evt, void *device)
+{
+        if (evt->cmnd && evt->cmnd->device == device)
+                return 1;
+        return 0;
+}
 
-        sdev_printk(KERN_INFO, sdev, "Aborting outstanding commands\n");
-        wait_for_completion(&evt->comp);
+/**
+ * ibmvfc_wait_for_ops - Wait for ops to complete
+ * @vhost:      ibmvfc host struct
+ * @device:     device to match (starget or sdev)
+ * @match:      match function
+ *
+ * Returns:
+ *      SUCCESS / FAILED
+ **/
+static int ibmvfc_wait_for_ops(struct ibmvfc_host *vhost, void *device,
+                               int (*match) (struct ibmvfc_event *, void *))
+{
+        struct ibmvfc_event *evt;
+        DECLARE_COMPLETION_ONSTACK(comp);
+        int wait;
+        unsigned long flags;
+        signed long timeout = IBMVFC_ABORT_WAIT_TIMEOUT * HZ;
 
-        if (rsp_iu.cmd.status)
-                rsp_code = ibmvfc_get_err_result(&rsp_iu.cmd);
+        ENTER;
+        do {
+                wait = 0;
+                spin_lock_irqsave(vhost->host->host_lock, flags);
+                list_for_each_entry(evt, &vhost->sent, queue) {
+                        if (match(evt, device)) {
+                                evt->eh_comp = &comp;
+                                wait++;
+                        }
+                }
+                spin_unlock_irqrestore(vhost->host->host_lock, flags);
 
-        if (rsp_code) {
-                if (fc_rsp->flags & FCP_RSP_LEN_VALID)
-                        rsp_code = fc_rsp->data.info.rsp_code;
+                if (wait) {
+                        timeout = wait_for_completion_timeout(&comp, timeout);
 
-                sdev_printk(KERN_ERR, sdev, "Abort failed: %s (%x:%x) "
-                            "flags: %x fcp_rsp: %x, scsi_status: %x\n",
-                            ibmvfc_get_cmd_error(rsp_iu.cmd.status, rsp_iu.cmd.error),
-                            rsp_iu.cmd.status, rsp_iu.cmd.error, fc_rsp->flags, rsp_code,
-                            fc_rsp->scsi_status);
-                rsp_rc = -EIO;
-        } else
-                sdev_printk(KERN_INFO, sdev, "Abort successful\n");
+                        if (!timeout) {
+                                wait = 0;
+                                spin_lock_irqsave(vhost->host->host_lock, flags);
+                                list_for_each_entry(evt, &vhost->sent, queue) {
+                                        if (match(evt, device)) {
+                                                evt->eh_comp = NULL;
+                                                wait++;
+                                        }
+                                }
+                                spin_unlock_irqrestore(vhost->host->host_lock, flags);
+                                if (wait)
+                                        dev_err(vhost->dev, "Timed out waiting for aborted commands\n");
+                                LEAVE;
+                                return wait ? FAILED : SUCCESS;
+                        }
+                }
+        } while (wait);
 
-        spin_lock_irqsave(vhost->host->host_lock, flags);
-        ibmvfc_free_event(evt);
-        spin_unlock_irqrestore(vhost->host->host_lock, flags);
-        return rsp_rc;
+        LEAVE;
+        return SUCCESS;
 }
 
 /**
@@ -2212,88 +2228,130 @@ static int ibmvfc_cancel_all(struct scsi_device *sdev, int type)
 }
 
 /**
- * ibmvfc_match_target - Match function for specified target
+ * ibmvfc_match_key - Match function for specified cancel key
  * @evt:        ibmvfc event struct
- * @device:     device to match (starget)
+ * @key:        cancel key to match
  *
  * Returns:
- *      1 if event matches starget / 0 if event does not match starget
+ *      1 if event matches key / 0 if event does not match key
  **/
-static int ibmvfc_match_target(struct ibmvfc_event *evt, void *device)
+static int ibmvfc_match_key(struct ibmvfc_event *evt, void *key)
 {
-        if (evt->cmnd && scsi_target(evt->cmnd->device) == device)
-                return 1;
-        return 0;
-}
+        unsigned long cancel_key = (unsigned long)key;
 
-/**
- * ibmvfc_match_lun - Match function for specified LUN
- * @evt:        ibmvfc event struct
- * @device:     device to match (sdev)
- *
- * Returns:
- *      1 if event matches sdev / 0 if event does not match sdev
- **/
-static int ibmvfc_match_lun(struct ibmvfc_event *evt, void *device)
-{
-        if (evt->cmnd && evt->cmnd->device == device)
+        if (evt->crq.format == IBMVFC_CMD_FORMAT &&
+            evt->iu.cmd.cancel_key == cancel_key)
                 return 1;
         return 0;
 }
 
 /**
- * ibmvfc_wait_for_ops - Wait for ops to complete
- * @vhost:      ibmvfc host struct
- * @device:     device to match (starget or sdev)
- * @match:      match function
+ * ibmvfc_abort_task_set - Abort outstanding commands to the device
+ * @sdev:       scsi device to abort commands
+ *
+ * This sends an Abort Task Set to the VIOS for the specified device. This does
+ * NOT send any cancel to the VIOS. That must be done separately.
  *
  * Returns:
- *      SUCCESS / FAILED
+ *      0 on success / other on failure
  **/
-static int ibmvfc_wait_for_ops(struct ibmvfc_host *vhost, void *device,
-                               int (*match) (struct ibmvfc_event *, void *))
+static int ibmvfc_abort_task_set(struct scsi_device *sdev)
 {
-        struct ibmvfc_event *evt;
-        DECLARE_COMPLETION_ONSTACK(comp);
-        int wait;
-        unsigned long flags;
-        signed long timeout = IBMVFC_ABORT_WAIT_TIMEOUT * HZ;
+        struct ibmvfc_host *vhost = shost_priv(sdev->host);
+        struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
+        struct ibmvfc_cmd *tmf;
+        struct ibmvfc_event *evt, *found_evt;
+        union ibmvfc_iu rsp_iu;
+        struct ibmvfc_fcp_rsp *fc_rsp = &rsp_iu.cmd.rsp;
+        int rc, rsp_rc = -EBUSY;
+        unsigned long flags, timeout = IBMVFC_ABORT_TIMEOUT;
+        int rsp_code = 0;
 
-        ENTER;
-        do {
-                wait = 0;
-                spin_lock_irqsave(vhost->host->host_lock, flags);
-                list_for_each_entry(evt, &vhost->sent, queue) {
-                        if (match(evt, device)) {
-                                evt->eh_comp = &comp;
-                                wait++;
-                        }
+        spin_lock_irqsave(vhost->host->host_lock, flags);
+        found_evt = NULL;
+        list_for_each_entry(evt, &vhost->sent, queue) {
+                if (evt->cmnd && evt->cmnd->device == sdev) {
+                        found_evt = evt;
+                        break;
                 }
+        }
+
+        if (!found_evt) {
+                if (vhost->log_level > IBMVFC_DEFAULT_LOG_LEVEL)
+                        sdev_printk(KERN_INFO, sdev, "No events found to abort\n");
                 spin_unlock_irqrestore(vhost->host->host_lock, flags);
+                return 0;
+        }
 
-                if (wait) {
-                        timeout = wait_for_completion_timeout(&comp, timeout);
+        if (vhost->state == IBMVFC_ACTIVE) {
+                evt = ibmvfc_get_event(vhost);
+                ibmvfc_init_event(evt, ibmvfc_sync_completion, IBMVFC_CMD_FORMAT);
 
-                        if (!timeout) {
-                                wait = 0;
-                                spin_lock_irqsave(vhost->host->host_lock, flags);
-                                list_for_each_entry(evt, &vhost->sent, queue) {
-                                        if (match(evt, device)) {
-                                                evt->eh_comp = NULL;
-                                                wait++;
-                                        }
-                                }
-                                spin_unlock_irqrestore(vhost->host->host_lock, flags);
-                                if (wait)
-                                        dev_err(vhost->dev, "Timed out waiting for aborted commands\n");
-                                LEAVE;
-                                return wait ? FAILED : SUCCESS;
-                        }
+                tmf = &evt->iu.cmd;
+                memset(tmf, 0, sizeof(*tmf));
+                tmf->resp.va = (u64)evt->crq.ioba + offsetof(struct ibmvfc_cmd, rsp);
+                tmf->resp.len = sizeof(tmf->rsp);
+                tmf->frame_type = IBMVFC_SCSI_FCP_TYPE;
+                tmf->payload_len = sizeof(tmf->iu);
+                tmf->resp_len = sizeof(tmf->rsp);
+                tmf->cancel_key = (unsigned long)sdev->hostdata;
+                tmf->tgt_scsi_id = rport->port_id;
+                int_to_scsilun(sdev->lun, &tmf->iu.lun);
+                tmf->flags = (IBMVFC_NO_MEM_DESC | IBMVFC_TMF);
+                tmf->iu.tmf_flags = IBMVFC_ABORT_TASK_SET;
+                evt->sync_iu = &rsp_iu;
+
+                init_completion(&evt->comp);
+                rsp_rc = ibmvfc_send_event(evt, vhost, default_timeout);
+        }
+
+        spin_unlock_irqrestore(vhost->host->host_lock, flags);
+
+        if (rsp_rc != 0) {
+                sdev_printk(KERN_ERR, sdev, "Failed to send abort. rc=%d\n", rsp_rc);
+                return -EIO;
+        }
+
+        sdev_printk(KERN_INFO, sdev, "Aborting outstanding commands\n");
+        timeout = wait_for_completion_timeout(&evt->comp, timeout);
+
+        if (!timeout) {
+                rc = ibmvfc_cancel_all(sdev, IBMVFC_TMF_ABORT_TASK_SET);
+                if (!rc) {
+                        rc = ibmvfc_wait_for_ops(vhost, sdev->hostdata, ibmvfc_match_key);
+                        if (rc == SUCCESS)
+                                rc = 0;
                 }
-        } while (wait);
 
-        LEAVE;
-        return SUCCESS;
+                if (rc) {
+                        sdev_printk(KERN_INFO, sdev, "Cancel failed, resetting host\n");
+                        ibmvfc_reset_host(vhost);
+                        rsp_rc = 0;
+                        goto out;
+                }
+        }
+
+        if (rsp_iu.cmd.status)
+                rsp_code = ibmvfc_get_err_result(&rsp_iu.cmd);
+
+        if (rsp_code) {
+                if (fc_rsp->flags & FCP_RSP_LEN_VALID)
+                        rsp_code = fc_rsp->data.info.rsp_code;
+
+                sdev_printk(KERN_ERR, sdev, "Abort failed: %s (%x:%x) "
+                            "flags: %x fcp_rsp: %x, scsi_status: %x\n",
+                            ibmvfc_get_cmd_error(rsp_iu.cmd.status, rsp_iu.cmd.error),
+                            rsp_iu.cmd.status, rsp_iu.cmd.error, fc_rsp->flags, rsp_code,
+                            fc_rsp->scsi_status);
+                rsp_rc = -EIO;
+        } else
+                sdev_printk(KERN_INFO, sdev, "Abort successful\n");
+
+out:
+        spin_lock_irqsave(vhost->host->host_lock, flags);
+        ibmvfc_free_event(evt);
+        spin_unlock_irqrestore(vhost->host->host_lock, flags);
+        return rsp_rc;
 }
 
 /**
@@ -2351,18 +2409,6 @@ static int ibmvfc_eh_device_reset_handler(struct scsi_cmnd *cmd)
 }
 
 /**
- * ibmvfc_dev_cancel_all_abts - Device iterated cancel all function
- * @sdev:       scsi device struct
- * @data:       return code
- *
- **/
-static void ibmvfc_dev_cancel_all_abts(struct scsi_device *sdev, void *data)
-{
-        unsigned long *rc = data;
-        *rc |= ibmvfc_cancel_all(sdev, IBMVFC_TMF_ABORT_TASK_SET);
-}
-
-/**
  * ibmvfc_dev_cancel_all_reset - Device iterated cancel all function
  * @sdev:       scsi device struct
  * @data:       return code
@@ -2375,18 +2421,6 @@ static void ibmvfc_dev_cancel_all_reset(struct scsi_device *sdev, void *data)
 }
 
 /**
- * ibmvfc_dev_abort_all - Device iterated abort task set function
- * @sdev:       scsi device struct
- * @data:       return code
- *
- **/
-static void ibmvfc_dev_abort_all(struct scsi_device *sdev, void *data)
-{
-        unsigned long *rc = data;
-        *rc |= ibmvfc_abort_task_set(sdev);
-}
-
-/**
  * ibmvfc_eh_target_reset_handler - Reset the target
  * @cmd:        scsi command struct
  *
@@ -2440,19 +2474,22 @@ static int ibmvfc_eh_host_reset_handler(struct scsi_cmnd *cmd)
  **/
 static void ibmvfc_terminate_rport_io(struct fc_rport *rport)
 {
-        struct scsi_target *starget = to_scsi_target(&rport->dev);
-        struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
+        struct Scsi_Host *shost = rport_to_shost(rport);
         struct ibmvfc_host *vhost = shost_priv(shost);
-        unsigned long cancel_rc = 0;
-        unsigned long abort_rc = 0;
-        int rc = FAILED;
+        struct fc_rport *dev_rport;
+        struct scsi_device *sdev;
+        unsigned long rc;
 
         ENTER;
-        starget_for_each_device(starget, &cancel_rc, ibmvfc_dev_cancel_all_abts);
-        starget_for_each_device(starget, &abort_rc, ibmvfc_dev_abort_all);
+        shost_for_each_device(sdev, shost) {
+                dev_rport = starget_to_rport(scsi_target(sdev));
+                if (dev_rport != rport)
+                        continue;
+                ibmvfc_cancel_all(sdev, IBMVFC_TMF_ABORT_TASK_SET);
+                ibmvfc_abort_task_set(sdev);
+        }
 
-        if (!cancel_rc && !abort_rc)
-                rc = ibmvfc_wait_for_ops(vhost, starget, ibmvfc_match_target);
+        rc = ibmvfc_wait_for_ops(vhost, rport, ibmvfc_match_rport);
 
         if (rc == FAILED)
                 ibmvfc_issue_fc_host_lip(shost);
@@ -4193,11 +4230,15 @@ static void ibmvfc_tgt_add_rport(struct ibmvfc_target *tgt)
         if (rport && tgt->action == IBMVFC_TGT_ACTION_DEL_RPORT) {
                 tgt_dbg(tgt, "Deleting rport\n");
                 list_del(&tgt->queue);
+                ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DELETED_RPORT);
                 spin_unlock_irqrestore(vhost->host->host_lock, flags);
                 fc_remote_port_delete(rport);
                 del_timer_sync(&tgt->timer);
                 kref_put(&tgt->kref, ibmvfc_release_tgt);
                 return;
+        } else if (rport && tgt->action == IBMVFC_TGT_ACTION_DELETED_RPORT) {
+                spin_unlock_irqrestore(vhost->host->host_lock, flags);
+                return;
         }
 
         if (rport) {
@@ -4297,6 +4338,7 @@ static void ibmvfc_do_work(struct ibmvfc_host *vhost)
                                 rport = tgt->rport;
                                 tgt->rport = NULL;
                                 list_del(&tgt->queue);
+                                ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DELETED_RPORT);
                                 spin_unlock_irqrestore(vhost->host->host_lock, flags);
                                 if (rport)
                                         fc_remote_port_delete(rport);
diff --git a/drivers/scsi/ibmvscsi/ibmvfc.h b/drivers/scsi/ibmvscsi/ibmvfc.h
index d7e8dcd90650..608af394c8cf 100644
--- a/drivers/scsi/ibmvscsi/ibmvfc.h
+++ b/drivers/scsi/ibmvscsi/ibmvfc.h
@@ -29,8 +29,8 @@
 #include "viosrp.h"
 
 #define IBMVFC_NAME     "ibmvfc"
-#define IBMVFC_DRIVER_VERSION           "1.0.8"
-#define IBMVFC_DRIVER_DATE              "(June 17, 2010)"
+#define IBMVFC_DRIVER_VERSION           "1.0.9"
+#define IBMVFC_DRIVER_DATE              "(August 5, 2010)"
 
 #define IBMVFC_DEFAULT_TIMEOUT  60
 #define IBMVFC_ADISC_CANCEL_TIMEOUT     45
@@ -38,6 +38,7 @@
 #define IBMVFC_ADISC_PLUS_CANCEL_TIMEOUT        \
                 (IBMVFC_ADISC_TIMEOUT + IBMVFC_ADISC_CANCEL_TIMEOUT)
 #define IBMVFC_INIT_TIMEOUT             120
+#define IBMVFC_ABORT_TIMEOUT            8
 #define IBMVFC_ABORT_WAIT_TIMEOUT       40
 #define IBMVFC_MAX_REQUESTS_DEFAULT     100
 
@@ -597,6 +598,7 @@ enum ibmvfc_target_action {
         IBMVFC_TGT_ACTION_INIT,
         IBMVFC_TGT_ACTION_INIT_WAIT,
         IBMVFC_TGT_ACTION_DEL_RPORT,
+        IBMVFC_TGT_ACTION_DELETED_RPORT,
 };
 
 struct ibmvfc_target {
diff --git a/drivers/firmware/iscsi_boot_sysfs.c b/drivers/scsi/iscsi_boot_sysfs.c
index df6bff7366cf..df6bff7366cf 100644
--- a/drivers/firmware/iscsi_boot_sysfs.c
+++ b/drivers/scsi/iscsi_boot_sysfs.c
diff --git a/drivers/scsi/libfc/fc_fcp.c b/drivers/scsi/libfc/fc_fcp.c
index eac4d09314eb..c797f6b48f05 100644
--- a/drivers/scsi/libfc/fc_fcp.c
+++ b/drivers/scsi/libfc/fc_fcp.c
@@ -1765,14 +1765,14 @@ int fc_queuecommand(struct scsi_cmnd *sc_cmd, void (*done)(struct scsi_cmnd *))
         struct fcoe_dev_stats *stats;
 
         lport = shost_priv(sc_cmd->device->host);
-        spin_unlock_irq(lport->host->host_lock);
 
         rval = fc_remote_port_chkready(rport);
         if (rval) {
                 sc_cmd->result = rval;
                 done(sc_cmd);
-                goto out;
+                return 0;
         }
+        spin_unlock_irq(lport->host->host_lock);
 
         if (!*(struct fc_remote_port **)rport->dd_data) {
                 /*
diff --git a/drivers/scsi/lpfc/lpfc.h b/drivers/scsi/lpfc/lpfc.h
index 3482d5a5aed2..a50aa03b8ac1 100644
--- a/drivers/scsi/lpfc/lpfc.h
+++ b/drivers/scsi/lpfc/lpfc.h
@@ -775,6 +775,7 @@ struct lpfc_hba {
         uint8_t temp_sensor_support;
         /* Fields used for heart beat. */
         unsigned long last_completion_time;
+        unsigned long skipped_hb;
         struct timer_list hb_tmofunc;
         uint8_t hb_outstanding;
         enum hba_temp_state over_temp_state;
@@ -817,6 +818,8 @@ struct lpfc_hba {
         uint32_t iocb_cnt;
         uint32_t iocb_max;
         atomic_t sdev_cnt;
+        uint8_t fips_spec_rev;
+        uint8_t fips_level;
 };
 
 static inline struct Scsi_Host *
diff --git a/drivers/scsi/lpfc/lpfc_attr.c b/drivers/scsi/lpfc/lpfc_attr.c
index ad05b266e950..23ce45708335 100644
--- a/drivers/scsi/lpfc/lpfc_attr.c
+++ b/drivers/scsi/lpfc/lpfc_attr.c
@@ -1240,6 +1240,44 @@ lpfc_poll_store(struct device *dev, struct device_attribute *attr,
 }
 
 /**
+ * lpfc_fips_level_show - Return the current FIPS level for the HBA
+ * @dev: class unused variable.
+ * @attr: device attribute, not used.
+ * @buf: on return contains the module description text.
+ *
+ * Returns: size of formatted string.
+ **/
+static ssize_t
+lpfc_fips_level_show(struct device *dev,  struct device_attribute *attr,
+                     char *buf)
+{
+        struct Scsi_Host  *shost = class_to_shost(dev);
+        struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
+        struct lpfc_hba   *phba = vport->phba;
+
+        return snprintf(buf, PAGE_SIZE, "%d\n", phba->fips_level);
+}
+
+/**
+ * lpfc_fips_rev_show - Return the FIPS Spec revision for the HBA
+ * @dev: class unused variable.
+ * @attr: device attribute, not used.
+ * @buf: on return contains the module description text.
+ *
+ * Returns: size of formatted string.
+ **/
+static ssize_t
+lpfc_fips_rev_show(struct device *dev,  struct device_attribute *attr,
+                   char *buf)
+{
+        struct Scsi_Host  *shost = class_to_shost(dev);
+        struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
+        struct lpfc_hba   *phba = vport->phba;
+
+        return snprintf(buf, PAGE_SIZE, "%d\n", phba->fips_spec_rev);
+}
+
+/**
  * lpfc_param_show - Return a cfg attribute value in decimal
  *
  * Description:
@@ -1677,6 +1715,8 @@ static DEVICE_ATTR(max_xri, S_IRUGO, lpfc_max_xri_show, NULL);
 static DEVICE_ATTR(used_xri, S_IRUGO, lpfc_used_xri_show, NULL);
 static DEVICE_ATTR(npiv_info, S_IRUGO, lpfc_npiv_info_show, NULL);
 static DEVICE_ATTR(lpfc_temp_sensor, S_IRUGO, lpfc_temp_sensor_show, NULL);
+static DEVICE_ATTR(lpfc_fips_level, S_IRUGO, lpfc_fips_level_show, NULL);
+static DEVICE_ATTR(lpfc_fips_rev, S_IRUGO, lpfc_fips_rev_show, NULL);
 
 
 static char *lpfc_soft_wwn_key = "C99G71SL8032A";
@@ -3278,7 +3318,7 @@ 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_DIX_TYPE0_PROTECTION;
+unsigned int lpfc_prot_mask = SHOST_DIF_TYPE1_PROTECTION;
 
 module_param(lpfc_prot_mask, uint, 0);
 MODULE_PARM_DESC(lpfc_prot_mask, "host protection mask");
@@ -3383,6 +3423,8 @@ struct device_attribute *lpfc_hba_attrs[] = {
         &dev_attr_iocb_hw,
         &dev_attr_txq_hw,
         &dev_attr_txcmplq_hw,
+        &dev_attr_lpfc_fips_level,
+        &dev_attr_lpfc_fips_rev,
         NULL,
 };
 
@@ -3409,6 +3451,8 @@ struct device_attribute *lpfc_vport_attrs[] = {
         &dev_attr_lpfc_max_scsicmpl_time,
         &dev_attr_lpfc_stat_data_ctrl,
         &dev_attr_lpfc_static_vport,
+        &dev_attr_lpfc_fips_level,
+        &dev_attr_lpfc_fips_rev,
         NULL,
 };
 
diff --git a/drivers/scsi/lpfc/lpfc_bsg.c b/drivers/scsi/lpfc/lpfc_bsg.c
index d521569e6620..49d0cf99c24c 100644
--- a/drivers/scsi/lpfc/lpfc_bsg.c
+++ b/drivers/scsi/lpfc/lpfc_bsg.c
@@ -2724,15 +2724,6 @@ lpfc_bsg_issue_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
 
                 pmboxq->context2 = ext;
                 pmboxq->in_ext_byte_len =
-                        mbox_req->inExtWLen *
-                        sizeof(uint32_t);
-                pmboxq->out_ext_byte_len =
-                        mbox_req->outExtWLen *
-                        sizeof(uint32_t);
-                pmboxq->mbox_offset_word =
-                        mbox_req->mbOffset;
-                pmboxq->context2 = ext;
-                pmboxq->in_ext_byte_len =
                         mbox_req->inExtWLen * sizeof(uint32_t);
                 pmboxq->out_ext_byte_len =
                         mbox_req->outExtWLen * sizeof(uint32_t);
diff --git a/drivers/scsi/lpfc/lpfc_compat.h b/drivers/scsi/lpfc/lpfc_compat.h
index a11f1ae7b98e..75e2e569dede 100644
--- a/drivers/scsi/lpfc/lpfc_compat.h
+++ b/drivers/scsi/lpfc/lpfc_compat.h
@@ -82,8 +82,7 @@ lpfc_memcpy_from_slim( void *dest, void __iomem *src, unsigned int bytes)
 static inline void
 lpfc_memcpy_to_slim( void __iomem *dest, void *src, unsigned int bytes)
 {
-        /* actually returns 1 byte past dest */
-        memcpy_toio( dest, src, bytes);
+        __iowrite32_copy(dest, src, bytes);
 }
 
 static inline void
diff --git a/drivers/scsi/lpfc/lpfc_els.c b/drivers/scsi/lpfc/lpfc_els.c
index afbed6bc31f0..8d09191c327e 100644
--- a/drivers/scsi/lpfc/lpfc_els.c
+++ b/drivers/scsi/lpfc/lpfc_els.c
@@ -600,6 +600,14 @@ lpfc_cmpl_els_flogi_fabric(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
                         vport->fc_flag |= FC_VPORT_NEEDS_INIT_VPI;
                         spin_unlock_irq(shost->host_lock);
                 }
+        } else if ((phba->sli_rev == LPFC_SLI_REV4) &&
+                !(vport->fc_flag & FC_VPORT_NEEDS_REG_VPI)) {
+                        /*
+                         * Driver needs to re-reg VPI in order for f/w
+                         * to update the MAC address.
+                         */
+                        lpfc_register_new_vport(phba, vport, ndlp);
+                        return 0;
         }
 
         if (phba->sli_rev < LPFC_SLI_REV4) {
@@ -801,9 +809,12 @@ lpfc_cmpl_els_flogi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
                     (irsp->un.ulpWord[4] != IOERR_SLI_ABORTED)) {
                         lpfc_printf_log(phba, KERN_WARNING, LOG_FIP | LOG_ELS,
                                         "2611 FLOGI failed on registered "
-                                        "FCF record fcf_index:%d, trying "
-                                        "to perform round robin failover\n",
-                                        phba->fcf.current_rec.fcf_indx);
+                                        "FCF record fcf_index(%d), status: "
+                                        "x%x/x%x, tmo:x%x, trying to perform "
+                                        "round robin failover\n",
+                                        phba->fcf.current_rec.fcf_indx,
+                                        irsp->ulpStatus, irsp->un.ulpWord[4],
+                                        irsp->ulpTimeout);
                         fcf_index = lpfc_sli4_fcf_rr_next_index_get(phba);
                         if (fcf_index == LPFC_FCOE_FCF_NEXT_NONE) {
                                 /*
@@ -841,6 +852,12 @@ lpfc_cmpl_els_flogi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
                         }
                 }
 
+                /* FLOGI failure */
+                lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+                                "2858 FLOGI failure Status:x%x/x%x TMO:x%x\n",
+                                irsp->ulpStatus, irsp->un.ulpWord[4],
+                                irsp->ulpTimeout);
+
                 /* Check for retry */
                 if (lpfc_els_retry(phba, cmdiocb, rspiocb))
                         goto out;
@@ -1291,6 +1308,8 @@ lpfc_plogi_confirm_nport(struct lpfc_hba *phba, uint32_t *prsp,
         struct serv_parm *sp;
         uint8_t  name[sizeof(struct lpfc_name)];
         uint32_t rc, keepDID = 0;
+        int  put_node;
+        int  put_rport;
 
         /* Fabric nodes can have the same WWPN so we don't bother searching
          * by WWPN.  Just return the ndlp that was given to us.
@@ -1379,6 +1398,28 @@ lpfc_plogi_confirm_nport(struct lpfc_hba *phba, uint32_t *prsp,
                 /* Two ndlps cannot have the same did */
                 ndlp->nlp_DID = keepDID;
                 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
+                /* Since we are swapping the ndlp passed in with the new one
+                 * and the did has already been swapped, copy over the
+                 * state and names.
+                 */
+                memcpy(&new_ndlp->nlp_portname, &ndlp->nlp_portname,
+                        sizeof(struct lpfc_name));
+                memcpy(&new_ndlp->nlp_nodename, &ndlp->nlp_nodename,
+                        sizeof(struct lpfc_name));
+                new_ndlp->nlp_state = ndlp->nlp_state;
+                /* Fix up the rport accordingly */
+                rport = ndlp->rport;
+                if (rport) {
+                        rdata = rport->dd_data;
+                        put_node = rdata->pnode != NULL;
+                        put_rport = ndlp->rport != NULL;
+                        rdata->pnode = NULL;
+                        ndlp->rport = NULL;
+                        if (put_node)
+                                lpfc_nlp_put(ndlp);
+                        if (put_rport)
+                                put_device(&rport->dev);
+                }
         }
         return new_ndlp;
 }
@@ -2880,6 +2921,17 @@ lpfc_els_retry(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
                 retry = 0;
 
         if (retry) {
+                if ((cmd == ELS_CMD_PLOGI) || (cmd == ELS_CMD_FDISC)) {
+                        /* Stop retrying PLOGI and FDISC if in FCF discovery */
+                        if (phba->fcf.fcf_flag & FCF_DISCOVERY) {
+                                lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
+                                                 "2849 Stop retry ELS command "
+                                                 "x%x to remote NPORT x%x, "
+                                                 "Data: x%x x%x\n", cmd, did,
+                                                 cmdiocb->retry, delay);
+                                return 0;
+                        }
+                }
 
                 /* Retry ELS command <elsCmd> to remote NPORT <did> */
                 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
@@ -6076,8 +6128,12 @@ lpfc_cmpl_reg_new_vport(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
 
         if (mb->mbxStatus) {
                 lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX,
-                                 "0915 Register VPI failed: 0x%x\n",
-                                 mb->mbxStatus);
+                                "0915 Register VPI failed : Status: x%x"
+                                " upd bit: x%x \n", mb->mbxStatus,
+                                 mb->un.varRegVpi.upd);
+                if (phba->sli_rev == LPFC_SLI_REV4 &&
+                        mb->un.varRegVpi.upd)
+                        goto mbox_err_exit ;
 
                 switch (mb->mbxStatus) {
                 case 0x11:      /* unsupported feature */
@@ -6142,7 +6198,7 @@ lpfc_cmpl_reg_new_vport(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
                 } else
                         lpfc_do_scr_ns_plogi(phba, vport);
         }
-
+mbox_err_exit:
         /* Now, we decrement the ndlp reference count held for this
          * callback function
          */
@@ -6387,6 +6443,14 @@ lpfc_cmpl_els_fdisc(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
                 else
                         vport->fc_flag |= FC_LOGO_RCVD_DID_CHNG;
                 spin_unlock_irq(shost->host_lock);
+        } else if ((phba->sli_rev == LPFC_SLI_REV4) &&
+                !(vport->fc_flag & FC_VPORT_NEEDS_REG_VPI)) {
+                /*
+                 * Driver needs to re-reg VPI in order for f/w
+                 * to update the MAC address.
+                 */
+                lpfc_register_new_vport(phba, vport, ndlp);
+                return ;
         }
 
         if (vport->fc_flag & FC_VPORT_NEEDS_INIT_VPI)
diff --git a/drivers/scsi/lpfc/lpfc_hbadisc.c b/drivers/scsi/lpfc/lpfc_hbadisc.c
index 0639c994349c..1f62ea8c165d 100644
--- a/drivers/scsi/lpfc/lpfc_hbadisc.c
+++ b/drivers/scsi/lpfc/lpfc_hbadisc.c
@@ -588,7 +588,7 @@ lpfc_work_done(struct lpfc_hba *phba)
                                                         (status &
                                                          HA_RXMASK));
                 }
-                if (pring->txq_cnt)
+                if ((phba->sli_rev == LPFC_SLI_REV4) && pring->txq_cnt)
                         lpfc_drain_txq(phba);
                 /*
                  * Turn on Ring interrupts
@@ -1852,8 +1852,7 @@ lpfc_mbx_cmpl_fcf_scan_read_fcf_rec(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
                                 __lpfc_sli4_stop_fcf_redisc_wait_timer(phba);
                         else if (phba->fcf.fcf_flag & FCF_REDISC_FOV)
                                 /* If in fast failover, mark it's completed */
-                                phba->fcf.fcf_flag &= ~(FCF_REDISC_FOV |
-                                                        FCF_DISCOVERY);
+                                phba->fcf.fcf_flag &= ~FCF_REDISC_FOV;
                         spin_unlock_irq(&phba->hbalock);
                         lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
                                         "2836 The new FCF record (x%x) "
@@ -2651,7 +2650,6 @@ lpfc_mbx_process_link_up(struct lpfc_hba *phba, READ_LA_VAR *la)
                 spin_unlock_irq(&phba->hbalock);
                 lpfc_printf_log(phba, KERN_INFO, LOG_FIP | LOG_DISCOVERY,
                                 "2778 Start FCF table scan at linkup\n");
-
                 rc = lpfc_sli4_fcf_scan_read_fcf_rec(phba,
                                                      LPFC_FCOE_FCF_GET_FIRST);
                 if (rc) {
@@ -2660,6 +2658,9 @@ lpfc_mbx_process_link_up(struct lpfc_hba *phba, READ_LA_VAR *la)
                         spin_unlock_irq(&phba->hbalock);
                         goto out;
                 }
+                /* Reset FCF roundrobin bmask for new discovery */
+                memset(phba->fcf.fcf_rr_bmask, 0,
+                       sizeof(*phba->fcf.fcf_rr_bmask));
         }
 
         return;
@@ -5097,6 +5098,7 @@ static void
 lpfc_unregister_vfi_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
 {
         struct lpfc_vport *vport = mboxq->vport;
+        struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
 
         if (mboxq->u.mb.mbxStatus) {
                 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY|LOG_MBOX,
@@ -5104,6 +5106,9 @@ lpfc_unregister_vfi_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
                         "HBA state x%x\n",
                         mboxq->u.mb.mbxStatus, vport->port_state);
         }
+        spin_lock_irq(shost->host_lock);
+        phba->pport->fc_flag &= ~FC_VFI_REGISTERED;
+        spin_unlock_irq(shost->host_lock);
         mempool_free(mboxq, phba->mbox_mem_pool);
         return;
 }
@@ -5285,6 +5290,10 @@ lpfc_unregister_fcf_rescan(struct lpfc_hba *phba)
         spin_lock_irq(&phba->hbalock);
         phba->fcf.fcf_flag |= FCF_INIT_DISC;
         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));
+
         rc = lpfc_sli4_fcf_scan_read_fcf_rec(phba, LPFC_FCOE_FCF_GET_FIRST);
 
         if (rc) {
diff --git a/drivers/scsi/lpfc/lpfc_hw.h b/drivers/scsi/lpfc/lpfc_hw.h
index f5dbf2be3eab..1676f61291e7 100644
--- a/drivers/scsi/lpfc/lpfc_hw.h
+++ b/drivers/scsi/lpfc/lpfc_hw.h
@@ -2291,7 +2291,8 @@ typedef struct {
 typedef struct {
 #ifdef __BIG_ENDIAN_BITFIELD
         uint32_t rsvd1;
-        uint32_t rsvd2:8;
+        uint32_t rsvd2:7;
+        uint32_t upd:1;
         uint32_t sid:24;
         uint32_t wwn[2];
         uint32_t rsvd5;
@@ -2300,7 +2301,8 @@ typedef struct {
 #else   /*  __LITTLE_ENDIAN */
         uint32_t rsvd1;
         uint32_t sid:24;
-        uint32_t rsvd2:8;
+        uint32_t upd:1;
+        uint32_t rsvd2:7;
         uint32_t wwn[2];
         uint32_t rsvd5;
         uint16_t vpi;
@@ -2806,11 +2808,15 @@ typedef struct {
         uint32_t rsvd6;           /* Reserved                             */
 
 #ifdef __BIG_ENDIAN_BITFIELD
-        uint32_t rsvd7      : 16;  /* Reserved                             */
+        uint32_t fips_rev   : 3;   /* FIPS Spec Revision                   */
+        uint32_t fips_level : 4;   /* FIPS Level                           */
+        uint32_t sec_err    : 9;   /* security crypto error                */
         uint32_t max_vpi    : 16;  /* Max number of virt N-Ports           */
 #else   /*  __LITTLE_ENDIAN */
         uint32_t max_vpi    : 16;  /* Max number of virt N-Ports           */
-        uint32_t rsvd7      : 16;  /* Reserved                             */
+        uint32_t sec_err    : 9;   /* security crypto error                */
+        uint32_t fips_level : 4;   /* FIPS Level                           */
+        uint32_t fips_rev   : 3;   /* FIPS Spec Revision                   */
 #endif
 
 } CONFIG_PORT_VAR;
@@ -3441,63 +3447,63 @@ struct sli3_bg_fields {
 static inline uint32_t
 lpfc_bgs_get_bidir_bg_prof(uint32_t bgstat)
 {
-        return (le32_to_cpu(bgstat) & BGS_BIDIR_BG_PROF_MASK) >>
+        return (bgstat & BGS_BIDIR_BG_PROF_MASK) >>
                                 BGS_BIDIR_BG_PROF_SHIFT;
 }
 
 static inline uint32_t
 lpfc_bgs_get_bidir_err_cond(uint32_t bgstat)
 {
-        return (le32_to_cpu(bgstat) & BGS_BIDIR_ERR_COND_FLAGS_MASK) >>
+        return (bgstat & BGS_BIDIR_ERR_COND_FLAGS_MASK) >>
                                 BGS_BIDIR_ERR_COND_SHIFT;
 }
 
 static inline uint32_t
 lpfc_bgs_get_bg_prof(uint32_t bgstat)
 {
-        return (le32_to_cpu(bgstat) & BGS_BG_PROFILE_MASK) >>
+        return (bgstat & BGS_BG_PROFILE_MASK) >>
                                 BGS_BG_PROFILE_SHIFT;
 }
 
 static inline uint32_t
 lpfc_bgs_get_invalid_prof(uint32_t bgstat)
 {
-        return (le32_to_cpu(bgstat) & BGS_INVALID_PROF_MASK) >>
+        return (bgstat & BGS_INVALID_PROF_MASK) >>
                                 BGS_INVALID_PROF_SHIFT;
 }
 
 static inline uint32_t
 lpfc_bgs_get_uninit_dif_block(uint32_t bgstat)
 {
-        return (le32_to_cpu(bgstat) & BGS_UNINIT_DIF_BLOCK_MASK) >>
+        return (bgstat & BGS_UNINIT_DIF_BLOCK_MASK) >>
                                 BGS_UNINIT_DIF_BLOCK_SHIFT;
 }
 
 static inline uint32_t
 lpfc_bgs_get_hi_water_mark_present(uint32_t bgstat)
 {
-        return (le32_to_cpu(bgstat) & BGS_HI_WATER_MARK_PRESENT_MASK) >>
+        return (bgstat & BGS_HI_WATER_MARK_PRESENT_MASK) >>
                                 BGS_HI_WATER_MARK_PRESENT_SHIFT;
 }
 
 static inline uint32_t
 lpfc_bgs_get_reftag_err(uint32_t bgstat)
 {
-        return (le32_to_cpu(bgstat) & BGS_REFTAG_ERR_MASK) >>
+        return (bgstat & BGS_REFTAG_ERR_MASK) >>
                                 BGS_REFTAG_ERR_SHIFT;
 }
 
 static inline uint32_t
 lpfc_bgs_get_apptag_err(uint32_t bgstat)
 {
-        return (le32_to_cpu(bgstat) & BGS_APPTAG_ERR_MASK) >>
+        return (bgstat & BGS_APPTAG_ERR_MASK) >>
                                 BGS_APPTAG_ERR_SHIFT;
 }
 
 static inline uint32_t
 lpfc_bgs_get_guard_err(uint32_t bgstat)
 {
-        return (le32_to_cpu(bgstat) & BGS_GUARD_ERR_MASK) >>
+        return (bgstat & BGS_GUARD_ERR_MASK) >>
                                 BGS_GUARD_ERR_SHIFT;
 }
 
diff --git a/drivers/scsi/lpfc/lpfc_init.c b/drivers/scsi/lpfc/lpfc_init.c
index 2786ee3b605d..da9ba06ad583 100644
--- a/drivers/scsi/lpfc/lpfc_init.c
+++ b/drivers/scsi/lpfc/lpfc_init.c
@@ -1032,27 +1032,46 @@ lpfc_hb_timeout_handler(struct lpfc_hba *phba)
         /* If there is no heart beat outstanding, issue a heartbeat command */
         if (phba->cfg_enable_hba_heartbeat) {
                 if (!phba->hb_outstanding) {
-                        pmboxq = mempool_alloc(phba->mbox_mem_pool,GFP_KERNEL);
-                        if (!pmboxq) {
-                                mod_timer(&phba->hb_tmofunc,
-                                          jiffies + HZ * LPFC_HB_MBOX_INTERVAL);
-                                return;
-                        }
+                        if ((!(psli->sli_flag & LPFC_SLI_MBOX_ACTIVE)) &&
+                                (list_empty(&psli->mboxq))) {
+                                pmboxq = mempool_alloc(phba->mbox_mem_pool,
+                                                        GFP_KERNEL);
+                                if (!pmboxq) {
+                                        mod_timer(&phba->hb_tmofunc,
+                                                 jiffies +
+                                                 HZ * LPFC_HB_MBOX_INTERVAL);
+                                        return;
+                                }
 
-                        lpfc_heart_beat(phba, pmboxq);
-                        pmboxq->mbox_cmpl = lpfc_hb_mbox_cmpl;
-                        pmboxq->vport = phba->pport;
-                        retval = lpfc_sli_issue_mbox(phba, pmboxq, MBX_NOWAIT);
+                                lpfc_heart_beat(phba, pmboxq);
+                                pmboxq->mbox_cmpl = lpfc_hb_mbox_cmpl;
+                                pmboxq->vport = phba->pport;
+                                retval = lpfc_sli_issue_mbox(phba, pmboxq,
+                                                MBX_NOWAIT);
+
+                                if (retval != MBX_BUSY &&
+                                        retval != MBX_SUCCESS) {
+                                        mempool_free(pmboxq,
+                                                        phba->mbox_mem_pool);
+                                        mod_timer(&phba->hb_tmofunc,
+                                                jiffies +
+                                                HZ * LPFC_HB_MBOX_INTERVAL);
+                                        return;
+                                }
+                                phba->skipped_hb = 0;
+                                phba->hb_outstanding = 1;
+                        } else if (time_before_eq(phba->last_completion_time,
+                                        phba->skipped_hb)) {
+                                lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
+                                        "2857 Last completion time not "
+                                        " updated in %d ms\n",
+                                        jiffies_to_msecs(jiffies
+                                                 - phba->last_completion_time));
+                        } else
+                                phba->skipped_hb = jiffies;
 
-                        if (retval != MBX_BUSY && retval != MBX_SUCCESS) {
-                                mempool_free(pmboxq, phba->mbox_mem_pool);
-                                mod_timer(&phba->hb_tmofunc,
-                                          jiffies + HZ * LPFC_HB_MBOX_INTERVAL);
-                                return;
-                        }
                         mod_timer(&phba->hb_tmofunc,
                                   jiffies + HZ * LPFC_HB_MBOX_TIMEOUT);
-                        phba->hb_outstanding = 1;
                         return;
                 } else {
                         /*
@@ -3281,10 +3300,10 @@ lpfc_sli4_perform_vport_cvl(struct lpfc_vport *vport)
                 if (!ndlp)
                         return 0;
         }
-        if (phba->pport->port_state <= LPFC_FLOGI)
+        if (phba->pport->port_state < LPFC_FLOGI)
                 return NULL;
         /* If virtual link is not yet instantiated ignore CVL */
-        if (vport->port_state <= LPFC_FDISC)
+        if ((vport != phba->pport) && (vport->port_state < LPFC_FDISC))
                 return NULL;
         shost = lpfc_shost_from_vport(vport);
         if (!shost)
@@ -3357,21 +3376,7 @@ lpfc_sli4_async_fcoe_evt(struct lpfc_hba *phba,
                                         "evt_tag:x%x, fcf_index:x%x\n",
                                         acqe_fcoe->event_tag,
                                         acqe_fcoe->index);
-                /* If the FCF discovery is in progress, do nothing. */
-                spin_lock_irq(&phba->hbalock);
-                if (phba->hba_flag & FCF_DISC_INPROGRESS) {
-                        spin_unlock_irq(&phba->hbalock);
-                        break;
-                }
-                /* If fast FCF failover rescan event is pending, do nothing */
-                if (phba->fcf.fcf_flag & FCF_REDISC_EVT) {
-                        spin_unlock_irq(&phba->hbalock);
-                        break;
-                }
-                spin_unlock_irq(&phba->hbalock);
-
-                if ((phba->fcf.fcf_flag & FCF_DISCOVERY) &&
-                    !(phba->fcf.fcf_flag & FCF_REDISC_FOV)) {
+                if (phba->fcf.fcf_flag & FCF_DISCOVERY) {
                         /*
                          * During period of FCF discovery, read the FCF
                          * table record indexed by the event to update
@@ -3385,13 +3390,26 @@ lpfc_sli4_async_fcoe_evt(struct lpfc_hba *phba,
                                         acqe_fcoe->index);
                         rc = lpfc_sli4_read_fcf_rec(phba, acqe_fcoe->index);
                 }
-                /* If the FCF has been in discovered state, do nothing. */
+
+                /* If the FCF discovery is in progress, do nothing. */
                 spin_lock_irq(&phba->hbalock);
+                if (phba->hba_flag & FCF_DISC_INPROGRESS) {
+                        spin_unlock_irq(&phba->hbalock);
+                        break;
+                }
+                /* If fast FCF failover rescan event is pending, do nothing */
+                if (phba->fcf.fcf_flag & FCF_REDISC_EVT) {
+                        spin_unlock_irq(&phba->hbalock);
+                        break;
+                }
+
+                /* If the FCF has been in discovered state, do nothing. */
                 if (phba->fcf.fcf_flag & FCF_SCAN_DONE) {
                         spin_unlock_irq(&phba->hbalock);
                         break;
                 }
                 spin_unlock_irq(&phba->hbalock);
+
                 /* Otherwise, scan the entire FCF table and re-discover SAN */
                 lpfc_printf_log(phba, KERN_INFO, LOG_FIP | LOG_DISCOVERY,
                                 "2770 Start FCF table scan due to new FCF "
@@ -3417,13 +3435,9 @@ lpfc_sli4_async_fcoe_evt(struct lpfc_hba *phba,
                         "2549 FCF disconnected from network index 0x%x"
                         " tag 0x%x\n", acqe_fcoe->index,
                         acqe_fcoe->event_tag);
-                /* If the event is not for currently used fcf do nothing */
-                if (phba->fcf.current_rec.fcf_indx != acqe_fcoe->index)
-                        break;
-                /* We request port to rediscover the entire FCF table for
-                 * a fast recovery from case that the current FCF record
-                 * is no longer valid if we are not in the middle of FCF
-                 * failover process already.
+                /*
+                 * If we are in the middle of FCF failover process, clear
+                 * the corresponding FCF bit in the roundrobin bitmap.
                  */
                 spin_lock_irq(&phba->hbalock);
                 if (phba->fcf.fcf_flag & FCF_DISCOVERY) {
@@ -3432,9 +3446,23 @@ lpfc_sli4_async_fcoe_evt(struct lpfc_hba *phba,
                         lpfc_sli4_fcf_rr_index_clear(phba, acqe_fcoe->index);
                         break;
                 }
+                spin_unlock_irq(&phba->hbalock);
+
+                /* If the event is not for currently used fcf do nothing */
+                if (phba->fcf.current_rec.fcf_indx != acqe_fcoe->index)
+                        break;
+
+                /*
+                 * Otherwise, request the port to rediscover the entire FCF
+                 * table for a fast recovery from case that the current FCF
+                 * is no longer valid as we are not in the middle of FCF
+                 * failover process already.
+                 */
+                spin_lock_irq(&phba->hbalock);
                 /* Mark the fast failover process in progress */
                 phba->fcf.fcf_flag |= FCF_DEAD_DISC;
                 spin_unlock_irq(&phba->hbalock);
+
                 lpfc_printf_log(phba, KERN_INFO, LOG_FIP | LOG_DISCOVERY,
                                 "2771 Start FCF fast failover process due to "
                                 "FCF DEAD event: evt_tag:x%x, fcf_index:x%x "
@@ -3454,12 +3482,16 @@ lpfc_sli4_async_fcoe_evt(struct lpfc_hba *phba,
                          * as a link down to FCF registration.
                          */
                         lpfc_sli4_fcf_dead_failthrough(phba);
-                } else
-                        /* Handling fast FCF failover to a DEAD FCF event
-                         * is considered equalivant to receiving CVL to all
-                         * vports.
+                } else {
+                        /* Reset FCF roundrobin bmask for new discovery */
+                        memset(phba->fcf.fcf_rr_bmask, 0,
+                               sizeof(*phba->fcf.fcf_rr_bmask));
+                        /*
+                         * Handling fast FCF failover to a DEAD FCF event is
+                         * considered equalivant to receiving CVL to all vports.
                          */
                         lpfc_sli4_perform_all_vport_cvl(phba);
+                }
                 break;
         case LPFC_FCOE_EVENT_TYPE_CVL:
                 lpfc_printf_log(phba, KERN_ERR, LOG_FIP | LOG_DISCOVERY,
@@ -3534,7 +3566,13 @@ lpfc_sli4_async_fcoe_evt(struct lpfc_hba *phba,
                                  * the current registered FCF entry.
                                  */
                                 lpfc_retry_pport_discovery(phba);
-                        }
+                        } else
+                                /*
+                                 * Reset FCF roundrobin bmask for new
+                                 * discovery.
+                                 */
+                                memset(phba->fcf.fcf_rr_bmask, 0,
+                                       sizeof(*phba->fcf.fcf_rr_bmask));
                 }
                 break;
         default:
diff --git a/drivers/scsi/lpfc/lpfc_mbox.c b/drivers/scsi/lpfc/lpfc_mbox.c
index 9c2c7c7140c7..0dfa310cd609 100644
--- a/drivers/scsi/lpfc/lpfc_mbox.c
+++ b/drivers/scsi/lpfc/lpfc_mbox.c
@@ -815,9 +815,15 @@ void
 lpfc_reg_vpi(struct lpfc_vport *vport, LPFC_MBOXQ_t *pmb)
 {
         MAILBOX_t *mb = &pmb->u.mb;
+        struct lpfc_hba *phba = vport->phba;
 
         memset(pmb, 0, sizeof (LPFC_MBOXQ_t));
-
+        /*
+         * Set the re-reg VPI bit for f/w to update the MAC address.
+         */
+        if ((phba->sli_rev == LPFC_SLI_REV4) &&
+                !(vport->fc_flag & FC_VPORT_NEEDS_REG_VPI))
+                mb->un.varRegVpi.upd = 1;
         mb->un.varRegVpi.vpi = vport->vpi + vport->phba->vpi_base;
         mb->un.varRegVpi.sid = vport->fc_myDID;
         mb->un.varRegVpi.vfi = vport->vfi + vport->phba->vfi_base;
diff --git a/drivers/scsi/lpfc/lpfc_scsi.c b/drivers/scsi/lpfc/lpfc_scsi.c
index c818a7255962..2e51aa6b45b3 100644
--- a/drivers/scsi/lpfc/lpfc_scsi.c
+++ b/drivers/scsi/lpfc/lpfc_scsi.c
@@ -1325,7 +1325,7 @@ lpfc_bg_setup_bpl(struct lpfc_hba *phba, struct scsi_cmnd *sc,
         bf_set(pde5_type, pde5, LPFC_PDE5_DESCRIPTOR);
         pde5->reftag = reftag;
 
-        /* Endian convertion if necessary for PDE5 */
+        /* Endianness conversion if necessary for PDE5 */
         pde5->word0 = cpu_to_le32(pde5->word0);
         pde5->reftag = cpu_to_le32(pde5->reftag);
 
@@ -1347,7 +1347,7 @@ lpfc_bg_setup_bpl(struct lpfc_hba *phba, struct scsi_cmnd *sc,
         bf_set(pde6_ai, pde6, 1);
         bf_set(pde6_apptagval, pde6, apptagval);
 
-        /* Endian convertion if necessary for PDE6 */
+        /* Endianness conversion if necessary for PDE6 */
         pde6->word0 = cpu_to_le32(pde6->word0);
         pde6->word1 = cpu_to_le32(pde6->word1);
         pde6->word2 = cpu_to_le32(pde6->word2);
@@ -1459,7 +1459,7 @@ lpfc_bg_setup_bpl_prot(struct lpfc_hba *phba, struct scsi_cmnd *sc,
                 bf_set(pde5_type, pde5, LPFC_PDE5_DESCRIPTOR);
                 pde5->reftag = reftag;
 
-                /* Endian convertion if necessary for PDE5 */
+                /* Endianness conversion if necessary for PDE5 */
                 pde5->word0 = cpu_to_le32(pde5->word0);
                 pde5->reftag = cpu_to_le32(pde5->reftag);
 
@@ -1479,7 +1479,7 @@ lpfc_bg_setup_bpl_prot(struct lpfc_hba *phba, struct scsi_cmnd *sc,
                 bf_set(pde6_ai, pde6, 1);
                 bf_set(pde6_apptagval, pde6, apptagval);
 
-                /* Endian convertion if necessary for PDE6 */
+                /* Endianness conversion if necessary for PDE6 */
                 pde6->word0 = cpu_to_le32(pde6->word0);
                 pde6->word1 = cpu_to_le32(pde6->word1);
                 pde6->word2 = cpu_to_le32(pde6->word2);
diff --git a/drivers/scsi/lpfc/lpfc_sli.c b/drivers/scsi/lpfc/lpfc_sli.c
index e758eae0d0fd..fb8905f893f5 100644
--- a/drivers/scsi/lpfc/lpfc_sli.c
+++ b/drivers/scsi/lpfc/lpfc_sli.c
@@ -1046,7 +1046,7 @@ lpfc_sli_next_iotag(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq)
         } else
                 spin_unlock_irq(&phba->hbalock);
 
-        lpfc_printf_log(phba, KERN_ERR,LOG_SLI,
+        lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
                         "0318 Failed to allocate IOTAG.last IOTAG is %d\n",
                         psli->last_iotag);
 
@@ -3914,7 +3914,8 @@ lpfc_sli_config_port(struct lpfc_hba *phba, int sli_mode)
                 phba->sli3_options &= ~(LPFC_SLI3_NPIV_ENABLED |
                                         LPFC_SLI3_HBQ_ENABLED |
                                         LPFC_SLI3_CRP_ENABLED |
-                                        LPFC_SLI3_BG_ENABLED);
+                                        LPFC_SLI3_BG_ENABLED |
+                                        LPFC_SLI3_DSS_ENABLED);
                 if (rc != MBX_SUCCESS) {
                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
                                 "0442 Adapter failed to init, mbxCmd x%x "
@@ -3949,8 +3950,23 @@ lpfc_sli_config_port(struct lpfc_hba *phba, int sli_mode)
 
                 } else
                         phba->max_vpi = 0;
-                if (pmb->u.mb.un.varCfgPort.gdss)
+                phba->fips_level = 0;
+                phba->fips_spec_rev = 0;
+                if (pmb->u.mb.un.varCfgPort.gdss) {
                         phba->sli3_options |= LPFC_SLI3_DSS_ENABLED;
+                        phba->fips_level = pmb->u.mb.un.varCfgPort.fips_level;
+                        phba->fips_spec_rev = pmb->u.mb.un.varCfgPort.fips_rev;
+                        lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
+                                        "2850 Security Crypto Active. FIPS x%d "
+                                        "(Spec Rev: x%d)",
+                                        phba->fips_level, phba->fips_spec_rev);
+                }
+                if (pmb->u.mb.un.varCfgPort.sec_err) {
+                        lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                        "2856 Config Port Security Crypto "
+                                        "Error: x%x ",
+                                        pmb->u.mb.un.varCfgPort.sec_err);
+                }
                 if (pmb->u.mb.un.varCfgPort.gerbm)
                         phba->sli3_options |= LPFC_SLI3_HBQ_ENABLED;
                 if (pmb->u.mb.un.varCfgPort.gcrp)
@@ -9040,6 +9056,7 @@ lpfc_sli4_sp_handle_cqe(struct lpfc_hba *phba, struct lpfc_queue *cq,
         switch (bf_get(lpfc_cqe_code, &cqevt)) {
         case CQE_CODE_COMPL_WQE:
                 /* Process the WQ/RQ complete event */
+                phba->last_completion_time = jiffies;
                 workposted = lpfc_sli4_sp_handle_els_wcqe(phba,
                                 (struct lpfc_wcqe_complete *)&cqevt);
                 break;
@@ -9050,11 +9067,13 @@ lpfc_sli4_sp_handle_cqe(struct lpfc_hba *phba, struct lpfc_queue *cq,
                 break;
         case CQE_CODE_XRI_ABORTED:
                 /* Process the WQ XRI abort event */
+                phba->last_completion_time = jiffies;
                 workposted = lpfc_sli4_sp_handle_abort_xri_wcqe(phba, cq,
                                 (struct sli4_wcqe_xri_aborted *)&cqevt);
                 break;
         case CQE_CODE_RECEIVE:
                 /* Process the RQ event */
+                phba->last_completion_time = jiffies;
                 workposted = lpfc_sli4_sp_handle_rcqe(phba,
                                 (struct lpfc_rcqe *)&cqevt);
                 break;
@@ -9276,7 +9295,6 @@ lpfc_sli4_fp_handle_wcqe(struct lpfc_hba *phba, struct lpfc_queue *cq,
 {
         struct lpfc_wcqe_release wcqe;
         bool workposted = false;
-        unsigned long iflag;
 
         /* Copy the work queue CQE and convert endian order if needed */
         lpfc_sli_pcimem_bcopy(cqe, &wcqe, sizeof(struct lpfc_cqe));
@@ -9285,9 +9303,7 @@ lpfc_sli4_fp_handle_wcqe(struct lpfc_hba *phba, struct lpfc_queue *cq,
         switch (bf_get(lpfc_wcqe_c_code, &wcqe)) {
         case CQE_CODE_COMPL_WQE:
                 /* Process the WQ complete event */
-                spin_lock_irqsave(&phba->hbalock, iflag);
                 phba->last_completion_time = jiffies;
-                spin_unlock_irqrestore(&phba->hbalock, iflag);
                 lpfc_sli4_fp_handle_fcp_wcqe(phba,
                                 (struct lpfc_wcqe_complete *)&wcqe);
                 break;
@@ -9298,6 +9314,7 @@ lpfc_sli4_fp_handle_wcqe(struct lpfc_hba *phba, struct lpfc_queue *cq,
                 break;
         case CQE_CODE_XRI_ABORTED:
                 /* Process the WQ XRI abort event */
+                phba->last_completion_time = jiffies;
                 workposted = lpfc_sli4_sp_handle_abort_xri_wcqe(phba, cq,
                                 (struct sli4_wcqe_xri_aborted *)&wcqe);
                 break;
@@ -12278,12 +12295,9 @@ lpfc_sli4_fcf_scan_read_fcf_rec(struct lpfc_hba *phba, uint16_t fcf_index)
                 spin_lock_irq(&phba->hbalock);
                 phba->hba_flag |= FCF_DISC_INPROGRESS;
                 spin_unlock_irq(&phba->hbalock);
-                /* Reset FCF round robin index bmask for new scan */
-                if (fcf_index == LPFC_FCOE_FCF_GET_FIRST) {
-                        memset(phba->fcf.fcf_rr_bmask, 0,
-                               sizeof(*phba->fcf.fcf_rr_bmask));
+                /* Reset eligible FCF count for new scan */
+                if (fcf_index == LPFC_FCOE_FCF_GET_FIRST)
                         phba->fcf.eligible_fcf_cnt = 0;
-                }
                 error = 0;
         }
 fail_fcf_scan:
diff --git a/drivers/scsi/lpfc/lpfc_version.h b/drivers/scsi/lpfc/lpfc_version.h
index d28830af71d8..61afb3420a96 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.15"
+#define LPFC_DRIVER_VERSION "8.3.16"
 #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/pm8001/pm8001_hwi.c b/drivers/scsi/pm8001/pm8001_hwi.c
index 58d1134935ef..9793aa6afb10 100644
--- a/drivers/scsi/pm8001/pm8001_hwi.c
+++ b/drivers/scsi/pm8001/pm8001_hwi.c
@@ -4199,8 +4199,10 @@ static int pm8001_chip_get_nvmd_req(struct pm8001_hba_info *pm8001_ha,
         circularQ = &pm8001_ha->inbnd_q_tbl[0];
         memset(&nvmd_req, 0, sizeof(nvmd_req));
         rc = pm8001_tag_alloc(pm8001_ha, &tag);
-        if (rc)
+        if (rc) {
+                kfree(fw_control_context);
                 return rc;
+        }
         ccb = &pm8001_ha->ccb_info[tag];
         ccb->ccb_tag = tag;
         ccb->fw_control_context = fw_control_context;
@@ -4276,8 +4278,10 @@ static int pm8001_chip_set_nvmd_req(struct pm8001_hba_info *pm8001_ha,
                 ioctl_payload->length);
         memset(&nvmd_req, 0, sizeof(nvmd_req));
         rc = pm8001_tag_alloc(pm8001_ha, &tag);
-        if (rc)
+        if (rc) {
+                kfree(fw_control_context);
                 return rc;
+        }
         ccb = &pm8001_ha->ccb_info[tag];
         ccb->fw_control_context = fw_control_context;
         ccb->ccb_tag = tag;
@@ -4387,6 +4391,7 @@ pm8001_chip_fw_flash_update_req(struct pm8001_hba_info *pm8001_ha,
                         fw_control->len, 0) != 0) {
                                 PM8001_FAIL_DBG(pm8001_ha,
                                         pm8001_printk("Mem alloc failure\n"));
+                                kfree(fw_control_context);
                                 return -ENOMEM;
                 }
         }
@@ -4401,8 +4406,10 @@ pm8001_chip_fw_flash_update_req(struct pm8001_hba_info *pm8001_ha,
         fw_control_context->virtAddr = buffer;
         fw_control_context->len = fw_control->len;
         rc = pm8001_tag_alloc(pm8001_ha, &tag);
-        if (rc)
+        if (rc) {
+                kfree(fw_control_context);
                 return rc;
+        }
         ccb = &pm8001_ha->ccb_info[tag];
         ccb->fw_control_context = fw_control_context;
         ccb->ccb_tag = tag;
diff --git a/drivers/scsi/qla4xxx/ql4_def.h b/drivers/scsi/qla4xxx/ql4_def.h
index a79da8dd2064..9dc0a6616edd 100644
--- a/drivers/scsi/qla4xxx/ql4_def.h
+++ b/drivers/scsi/qla4xxx/ql4_def.h
@@ -36,6 +36,24 @@
 #include "ql4_dbg.h"
 #include "ql4_nx.h"
 
+#if defined(CONFIG_PCIEAER)
+#include <linux/aer.h>
+#else
+/* AER releated */
+static inline int pci_enable_pcie_error_reporting(struct pci_dev *dev)
+{
+        return -EINVAL;
+}
+static inline int pci_disable_pcie_error_reporting(struct pci_dev *dev)
+{
+        return -EINVAL;
+}
+static inline int pci_cleanup_aer_uncorrect_error_status(struct pci_dev *dev)
+{
+        return -EINVAL;
+}
+#endif
+
 #ifndef PCI_DEVICE_ID_QLOGIC_ISP4010
 #define PCI_DEVICE_ID_QLOGIC_ISP4010    0x4010
 #endif
@@ -137,6 +155,9 @@
 #define ISCSI_ALIAS_SIZE                32      /* ISCSI Alias name size */
 #define ISCSI_NAME_SIZE                 0xE0    /* ISCSI Name size */
 
+#define QL4_SESS_RECOVERY_TMO           30      /* iSCSI session */
+                                                /* recovery timeout */
+
 #define LSDW(x) ((u32)((u64)(x)))
 #define MSDW(x) ((u32)((((u64)(x)) >> 16) >> 16))
 
@@ -249,7 +270,6 @@ struct ddb_entry {
         uint32_t default_time2wait; /* Default Min time between
                                      * relogins (+aens) */
 
-        atomic_t port_down_timer; /* Device connection timer */
         atomic_t retry_relogin_timer; /* Min Time between relogins
                                        * (4000 only) */
         atomic_t relogin_timer; /* Max Time to wait for relogin to complete */
@@ -378,7 +398,9 @@ struct scsi_qla_host {
 #define AF_MSI_ENABLED                  16 /* 0x00010000 */
 #define AF_MSIX_ENABLED                 17 /* 0x00020000 */
 #define AF_MBOX_COMMAND_NOPOLL          18 /* 0x00040000 */
-
+#define AF_FW_RECOVERY                  19 /* 0x00080000 */
+#define AF_EEH_BUSY                     20 /* 0x00100000 */
+#define AF_PCI_CHANNEL_IO_PERM_FAILURE  21 /* 0x00200000 */
 
         unsigned long dpc_flags;
 
@@ -474,7 +496,6 @@ struct scsi_qla_host {
         uint32_t timer_active;
 
         /* Recovery Timers */
-        uint32_t port_down_retry_count;
         uint32_t discovery_wait;
         atomic_t check_relogin_timeouts;
         uint32_t retry_reset_ha_cnt;
@@ -615,6 +636,15 @@ static inline int is_qla8022(struct scsi_qla_host *ha)
         return ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP8022;
 }
 
+/* Note: Currently AER/EEH is now supported only for 8022 cards
+ * This function needs to be updated when AER/EEH is enabled
+ * for other cards.
+ */
+static inline int is_aer_supported(struct scsi_qla_host *ha)
+{
+        return ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP8022;
+}
+
 static inline int adapter_up(struct scsi_qla_host *ha)
 {
         return (test_bit(AF_ONLINE, &ha->flags) != 0) &&
diff --git a/drivers/scsi/qla4xxx/ql4_fw.h b/drivers/scsi/qla4xxx/ql4_fw.h
index c94c9ddfb3a6..0336c6db8cb3 100644
--- a/drivers/scsi/qla4xxx/ql4_fw.h
+++ b/drivers/scsi/qla4xxx/ql4_fw.h
@@ -673,17 +673,17 @@ struct flash_sys_info {
 };      /* 200 */
 
 struct mbx_sys_info {
-        uint8_t board_id_str[16];       /* Keep board ID string first */
-                                        /* in this structure for GUI. */
-        uint16_t board_id;      /* board ID code */
-        uint16_t phys_port_cnt; /* number of physical network ports */
-        uint16_t port_num;      /* network port for this PCI function */
+        uint8_t board_id_str[16];   /*  0-f  Keep board ID string first */
+                                /* in this structure for GUI. */
+        uint16_t board_id;      /* 10-11 board ID code */
+        uint16_t phys_port_cnt; /* 12-13 number of physical network ports */
+        uint16_t port_num;      /* 14-15 network port for this PCI function */
                                 /* (port 0 is first port) */
-        uint8_t mac_addr[6];    /* MAC address for this PCI function */
-        uint32_t iscsi_pci_func_cnt;    /* number of iSCSI PCI functions */
-        uint32_t pci_func;              /* this PCI function */
-        unsigned char serial_number[16];        /* serial number string */
-        uint8_t reserved[16];
+        uint8_t mac_addr[6];    /* 16-1b MAC address for this PCI function */
+        uint32_t iscsi_pci_func_cnt;  /* 1c-1f number of iSCSI PCI functions */
+        uint32_t pci_func;            /* 20-23 this PCI function */
+        unsigned char serial_number[16];  /* 24-33 serial number string */
+        uint8_t reserved[12];             /* 34-3f */
 };
 
 struct crash_record {
diff --git a/drivers/scsi/qla4xxx/ql4_glbl.h b/drivers/scsi/qla4xxx/ql4_glbl.h
index c9cd5d6db982..f065204e401b 100644
--- a/drivers/scsi/qla4xxx/ql4_glbl.h
+++ b/drivers/scsi/qla4xxx/ql4_glbl.h
@@ -93,6 +93,7 @@ void qla4xxx_free_irqs(struct scsi_qla_host *ha);
 void qla4xxx_process_response_queue(struct scsi_qla_host *ha);
 void qla4xxx_wake_dpc(struct scsi_qla_host *ha);
 void qla4xxx_get_conn_event_log(struct scsi_qla_host *ha);
+void qla4xxx_mailbox_premature_completion(struct scsi_qla_host *ha);
 
 void qla4_8xxx_pci_config(struct scsi_qla_host *);
 int qla4_8xxx_iospace_config(struct scsi_qla_host *ha);
@@ -131,6 +132,7 @@ void qla4_8xxx_idc_unlock(struct scsi_qla_host *ha);
 int qla4_8xxx_device_state_handler(struct scsi_qla_host *ha);
 void qla4_8xxx_need_qsnt_handler(struct scsi_qla_host *ha);
 void qla4_8xxx_clear_drv_active(struct scsi_qla_host *ha);
+inline void qla4_8xxx_set_drv_active(struct scsi_qla_host *ha);
 
 extern int ql4xextended_error_logging;
 extern int ql4xdiscoverywait;
diff --git a/drivers/scsi/qla4xxx/ql4_init.c b/drivers/scsi/qla4xxx/ql4_init.c
index 30073577c3a4..4c9be77ee70b 100644
--- a/drivers/scsi/qla4xxx/ql4_init.c
+++ b/drivers/scsi/qla4xxx/ql4_init.c
@@ -308,7 +308,6 @@ static int qla4xxx_fw_ready(struct scsi_qla_host *ha)
                         DEBUG2(printk("scsi%ld: %s: unable to get firmware "
                                       "state\n", ha->host_no, __func__));
                         break;
-
                 }
 
                 if (ha->firmware_state & FW_STATE_ERROR) {
@@ -445,6 +444,16 @@ static int qla4xxx_init_firmware(struct scsi_qla_host *ha)
 {
         int status = QLA_ERROR;
 
+        if (is_aer_supported(ha) &&
+            test_bit(AF_PCI_CHANNEL_IO_PERM_FAILURE, &ha->flags))
+                return status;
+
+        /* For 82xx, stop firmware before initializing because if BIOS
+         * has previously initialized firmware, then driver's initialize
+         * firmware will fail. */
+        if (is_qla8022(ha))
+                qla4_8xxx_stop_firmware(ha);
+
         ql4_printk(KERN_INFO, ha, "Initializing firmware..\n");
         if (qla4xxx_initialize_fw_cb(ha) == QLA_ERROR) {
                 DEBUG2(printk("scsi%ld: %s: Failed to initialize firmware "
@@ -669,7 +678,6 @@ static struct ddb_entry * qla4xxx_alloc_ddb(struct scsi_qla_host *ha,
         }
 
         ddb_entry->fw_ddb_index = fw_ddb_index;
-        atomic_set(&ddb_entry->port_down_timer, ha->port_down_retry_count);
         atomic_set(&ddb_entry->retry_relogin_timer, INVALID_ENTRY);
         atomic_set(&ddb_entry->relogin_timer, 0);
         atomic_set(&ddb_entry->relogin_retry_count, 0);
@@ -1556,8 +1564,6 @@ int qla4xxx_process_ddb_changed(struct scsi_qla_host *ha, uint32_t fw_ddb_index,
         /* Device is back online. */
         if (ddb_entry->fw_ddb_device_state == DDB_DS_SESSION_ACTIVE) {
                 atomic_set(&ddb_entry->state, DDB_STATE_ONLINE);
-                atomic_set(&ddb_entry->port_down_timer,
-                           ha->port_down_retry_count);
                 atomic_set(&ddb_entry->relogin_retry_count, 0);
                 atomic_set(&ddb_entry->relogin_timer, 0);
                 clear_bit(DF_RELOGIN, &ddb_entry->flags);
diff --git a/drivers/scsi/qla4xxx/ql4_iocb.c b/drivers/scsi/qla4xxx/ql4_iocb.c
index f89973deac5b..4ef9ba112ee8 100644
--- a/drivers/scsi/qla4xxx/ql4_iocb.c
+++ b/drivers/scsi/qla4xxx/ql4_iocb.c
@@ -19,7 +19,7 @@ qla4xxx_space_in_req_ring(struct scsi_qla_host *ha, uint16_t req_cnt)
 
         /* Calculate number of free request entries. */
         if ((req_cnt + 2) >= ha->req_q_count) {
-                cnt = (uint16_t) le32_to_cpu(ha->shadow_regs->req_q_out);
+                cnt = (uint16_t) ha->isp_ops->rd_shdw_req_q_out(ha);
                 if (ha->request_in < cnt)
                         ha->req_q_count = cnt - ha->request_in;
                 else
diff --git a/drivers/scsi/qla4xxx/ql4_isr.c b/drivers/scsi/qla4xxx/ql4_isr.c
index aa65697a86b4..2a1ab63f3eb0 100644
--- a/drivers/scsi/qla4xxx/ql4_isr.c
+++ b/drivers/scsi/qla4xxx/ql4_isr.c
@@ -816,6 +816,9 @@ irqreturn_t qla4_8xxx_intr_handler(int irq, void *dev_id)
         unsigned long flags = 0;
         uint8_t reqs_count = 0;
 
+        if (unlikely(pci_channel_offline(ha->pdev)))
+                return IRQ_HANDLED;
+
         ha->isr_count++;
         status = qla4_8xxx_rd_32(ha, ISR_INT_VECTOR);
         if (!(status & ha->nx_legacy_intr.int_vec_bit))
diff --git a/drivers/scsi/qla4xxx/ql4_mbx.c b/drivers/scsi/qla4xxx/ql4_mbx.c
index 940ee561ee0a..90021704d8ca 100644
--- a/drivers/scsi/qla4xxx/ql4_mbx.c
+++ b/drivers/scsi/qla4xxx/ql4_mbx.c
@@ -39,6 +39,22 @@ int qla4xxx_mailbox_command(struct scsi_qla_host *ha, uint8_t inCount,
                               "pointer\n", ha->host_no, __func__));
                 return status;
         }
+
+        if (is_qla8022(ha) &&
+            test_bit(AF_FW_RECOVERY, &ha->flags)) {
+                DEBUG2(ql4_printk(KERN_WARNING, ha, "scsi%ld: %s: prematurely "
+                    "completing mbx cmd as firmware recovery detected\n",
+                    ha->host_no, __func__));
+                return status;
+        }
+
+        if ((is_aer_supported(ha)) &&
+            (test_bit(AF_PCI_CHANNEL_IO_PERM_FAILURE, &ha->flags))) {
+                DEBUG2(printk(KERN_WARNING "scsi%ld: %s: Perm failure on EEH, "
+                    "timeout MBX Exiting.\n", ha->host_no, __func__));
+                return status;
+        }
+
         /* Mailbox code active */
         wait_count = MBOX_TOV * 100;
 
@@ -150,6 +166,7 @@ int qla4xxx_mailbox_command(struct scsi_qla_host *ha, uint8_t inCount,
                 while (test_bit(AF_MBOX_COMMAND_DONE, &ha->flags) == 0) {
                         if (time_after_eq(jiffies, wait_count))
                                 break;
+
                         /*
                          * Service the interrupt.
                          * The ISR will save the mailbox status registers
@@ -196,6 +213,14 @@ int qla4xxx_mailbox_command(struct scsi_qla_host *ha, uint8_t inCount,
 
         /* Check for mailbox timeout. */
         if (!test_bit(AF_MBOX_COMMAND_DONE, &ha->flags)) {
+                if (is_qla8022(ha) &&
+                    test_bit(AF_FW_RECOVERY, &ha->flags)) {
+                        DEBUG2(ql4_printk(KERN_INFO, ha,
+                            "scsi%ld: %s: prematurely completing mbx cmd as "
+                            "firmware recovery detected\n",
+                            ha->host_no, __func__));
+                        goto mbox_exit;
+                }
                 DEBUG2(printk("scsi%ld: Mailbox Cmd 0x%08X timed out ...,"
                               " Scheduling Adapter Reset\n", ha->host_no,
                               mbx_cmd[0]));
@@ -246,6 +271,28 @@ mbox_exit:
         return status;
 }
 
+void qla4xxx_mailbox_premature_completion(struct scsi_qla_host *ha)
+{
+        set_bit(AF_FW_RECOVERY, &ha->flags);
+        ql4_printk(KERN_INFO, ha, "scsi%ld: %s: set FW RECOVERY!\n",
+            ha->host_no, __func__);
+
+        if (test_bit(AF_MBOX_COMMAND, &ha->flags)) {
+                if (test_bit(AF_MBOX_COMMAND_NOPOLL, &ha->flags)) {
+                        complete(&ha->mbx_intr_comp);
+                        ql4_printk(KERN_INFO, ha, "scsi%ld: %s: Due to fw "
+                            "recovery, doing premature completion of "
+                            "mbx cmd\n", ha->host_no, __func__);
+
+                } else {
+                        set_bit(AF_MBOX_COMMAND_DONE, &ha->flags);
+                        ql4_printk(KERN_INFO, ha, "scsi%ld: %s: Due to fw "
+                            "recovery, doing premature completion of "
+                            "polling mbx cmd\n", ha->host_no, __func__);
+                }
+        }
+}
+
 static uint8_t
 qla4xxx_set_ifcb(struct scsi_qla_host *ha, uint32_t *mbox_cmd,
                  uint32_t *mbox_sts, dma_addr_t init_fw_cb_dma)
@@ -361,7 +408,6 @@ qla4xxx_update_local_ifcb(struct scsi_qla_host *ha,
                min(sizeof(ha->alias), sizeof(init_fw_cb->Alias)));*/
 
         /* Save Command Line Paramater info */
-        ha->port_down_retry_count = le16_to_cpu(init_fw_cb->conn_ka_timeout);
         ha->discovery_wait = ql4xdiscoverywait;
 
         if (ha->acb_version == ACB_SUPPORTED) {
diff --git a/drivers/scsi/qla4xxx/ql4_nx.c b/drivers/scsi/qla4xxx/ql4_nx.c
index 3e119ae78397..e031a734836e 100644
--- a/drivers/scsi/qla4xxx/ql4_nx.c
+++ b/drivers/scsi/qla4xxx/ql4_nx.c
@@ -1418,7 +1418,7 @@ static int qla4_8xxx_rcvpeg_ready(struct scsi_qla_host *ha)
         return QLA_SUCCESS;
 }
 
-static inline void
+inline void
 qla4_8xxx_set_drv_active(struct scsi_qla_host *ha)
 {
         uint32_t drv_active;
@@ -1441,11 +1441,15 @@ qla4_8xxx_clear_drv_active(struct scsi_qla_host *ha)
 static inline int
 qla4_8xxx_need_reset(struct scsi_qla_host *ha)
 {
-        uint32_t drv_state;
+        uint32_t drv_state, drv_active;
         int rval;
 
+        drv_active = qla4_8xxx_rd_32(ha, QLA82XX_CRB_DRV_ACTIVE);
         drv_state = qla4_8xxx_rd_32(ha, QLA82XX_CRB_DRV_STATE);
         rval = drv_state & (1 << (ha->func_num * 4));
+        if ((test_bit(AF_EEH_BUSY, &ha->flags)) && drv_active)
+                rval = 1;
+
         return rval;
 }
 
@@ -1949,7 +1953,8 @@ qla4_8xxx_get_fdt_info(struct scsi_qla_host *ha)
         uint16_t cnt, chksum;
         uint16_t *wptr;
         struct qla_fdt_layout *fdt;
-        uint16_t mid, fid;
+        uint16_t mid = 0;
+        uint16_t fid = 0;
         struct ql82xx_hw_data *hw = &ha->hw;
 
         hw->flash_conf_off = FARX_ACCESS_FLASH_CONF;
@@ -2105,6 +2110,9 @@ qla4_8xxx_isp_reset(struct scsi_qla_host *ha)
         qla4_8xxx_clear_rst_ready(ha);
         qla4_8xxx_idc_unlock(ha);
 
+        if (rval == QLA_SUCCESS)
+                clear_bit(AF_FW_RECOVERY, &ha->flags);
+
         return rval;
 }
 
@@ -2145,7 +2153,8 @@ int qla4_8xxx_get_sys_info(struct scsi_qla_host *ha)
                 goto exit_validate_mac82;
         }
 
-        if (mbox_sts[4] < sizeof(*sys_info)) {
+        /* Make sure we receive the minimum required data to cache internally */
+        if (mbox_sts[4] < offsetof(struct mbx_sys_info, reserved)) {
                 DEBUG2(printk("scsi%ld: %s: GET_SYS_INFO data receive"
                     " error (%x)\n", ha->host_no, __func__, mbox_sts[4]));
                 goto exit_validate_mac82;
diff --git a/drivers/scsi/qla4xxx/ql4_os.c b/drivers/scsi/qla4xxx/ql4_os.c
index 5529b2a39741..370d40ff1529 100644
--- a/drivers/scsi/qla4xxx/ql4_os.c
+++ b/drivers/scsi/qla4xxx/ql4_os.c
@@ -163,10 +163,10 @@ static void qla4xxx_recovery_timedout(struct iscsi_cls_session *session)
         if (atomic_read(&ddb_entry->state) != DDB_STATE_ONLINE) {
                 atomic_set(&ddb_entry->state, DDB_STATE_DEAD);
 
-                DEBUG2(printk("scsi%ld: %s: ddb [%d] port down retry count "
+                DEBUG2(printk("scsi%ld: %s: ddb [%d] session recovery timeout "
                               "of (%d) secs exhausted, marking device DEAD.\n",
                               ha->host_no, __func__, ddb_entry->fw_ddb_index,
-                              ha->port_down_retry_count));
+                              QL4_SESS_RECOVERY_TMO));
 
                 qla4xxx_wake_dpc(ha);
         }
@@ -298,7 +298,8 @@ int qla4xxx_add_sess(struct ddb_entry *ddb_entry)
 {
         int err;
 
-        ddb_entry->sess->recovery_tmo = ddb_entry->ha->port_down_retry_count;
+        ddb_entry->sess->recovery_tmo = QL4_SESS_RECOVERY_TMO;
+
         err = iscsi_add_session(ddb_entry->sess, ddb_entry->fw_ddb_index);
         if (err) {
                 DEBUG2(printk(KERN_ERR "Could not add session.\n"));
@@ -474,6 +475,14 @@ static int qla4xxx_queuecommand(struct scsi_cmnd *cmd,
         struct srb *srb;
         int rval;
 
+        if (test_bit(AF_EEH_BUSY, &ha->flags)) {
+                if (test_bit(AF_PCI_CHANNEL_IO_PERM_FAILURE, &ha->flags))
+                        cmd->result = DID_NO_CONNECT << 16;
+                else
+                        cmd->result = DID_REQUEUE << 16;
+                goto qc_fail_command;
+        }
+
         if (!sess) {
                 cmd->result = DID_IMM_RETRY << 16;
                 goto qc_fail_command;
@@ -654,6 +663,13 @@ static void qla4_8xxx_check_fw_alive(struct scsi_qla_host *ha)
         uint32_t fw_heartbeat_counter, halt_status;
 
         fw_heartbeat_counter = qla4_8xxx_rd_32(ha, QLA82XX_PEG_ALIVE_COUNTER);
+        /* If PEG_ALIVE_COUNTER is 0xffffffff, AER/EEH is in progress, ignore */
+        if (fw_heartbeat_counter == 0xffffffff) {
+                DEBUG2(printk(KERN_WARNING "scsi%ld: %s: Device in frozen "
+                    "state, QLA82XX_PEG_ALIVE_COUNTER is 0xffffffff\n",
+                    ha->host_no, __func__));
+                return;
+        }
 
         if (ha->fw_heartbeat_counter == fw_heartbeat_counter) {
                 ha->seconds_since_last_heartbeat++;
@@ -662,6 +678,7 @@ static void qla4_8xxx_check_fw_alive(struct scsi_qla_host *ha)
                         ha->seconds_since_last_heartbeat = 0;
                         halt_status = qla4_8xxx_rd_32(ha,
                             QLA82XX_PEG_HALT_STATUS1);
+
                         /* Since we cannot change dev_state in interrupt
                          * context, set appropriate DPC flag then wakeup
                          * DPC */
@@ -673,6 +690,7 @@ static void qla4_8xxx_check_fw_alive(struct scsi_qla_host *ha)
                                 set_bit(DPC_RESET_HA, &ha->dpc_flags);
                         }
                         qla4xxx_wake_dpc(ha);
+                        qla4xxx_mailbox_premature_completion(ha);
                 }
         }
         ha->fw_heartbeat_counter = fw_heartbeat_counter;
@@ -698,6 +716,7 @@ void qla4_8xxx_watchdog(struct scsi_qla_host *ha)
                             ha->host_no, __func__);
                         set_bit(DPC_RESET_HA, &ha->dpc_flags);
                         qla4xxx_wake_dpc(ha);
+                        qla4xxx_mailbox_premature_completion(ha);
                 } else if (dev_state == QLA82XX_DEV_NEED_QUIESCENT &&
                     !test_bit(DPC_HA_NEED_QUIESCENT, &ha->dpc_flags)) {
                         printk("scsi%ld: %s: HW State: NEED QUIES!\n",
@@ -719,6 +738,19 @@ static void qla4xxx_timer(struct scsi_qla_host *ha)
 {
         struct ddb_entry *ddb_entry, *dtemp;
         int start_dpc = 0;
+        uint16_t w;
+
+        /* If we are in the middle of AER/EEH processing
+         * skip any processing and reschedule the timer
+         */
+        if (test_bit(AF_EEH_BUSY, &ha->flags)) {
+                mod_timer(&ha->timer, jiffies + HZ);
+                return;
+        }
+
+        /* Hardware read to trigger an EEH error during mailbox waits. */
+        if (!pci_channel_offline(ha->pdev))
+                pci_read_config_word(ha->pdev, PCI_VENDOR_ID, &w);
 
         if (test_bit(AF_HBA_GOING_AWAY, &ha->flags)) {
                 DEBUG2(ql4_printk(KERN_INFO, ha, "%s exited. HBA GOING AWAY\n",
@@ -1207,7 +1239,13 @@ static void qla4xxx_do_dpc(struct work_struct *work)
 
         /* Initialization not yet finished. Don't do anything yet. */
         if (!test_bit(AF_INIT_DONE, &ha->flags))
-                return;
+                goto do_dpc_exit;
+
+        if (test_bit(AF_EEH_BUSY, &ha->flags)) {
+                DEBUG2(printk(KERN_INFO "scsi%ld: %s: flags = %lx\n",
+                    ha->host_no, __func__, ha->flags));
+                goto do_dpc_exit;
+        }
 
         /* HBA is in the process of being permanently disabled.
          * Don't process anything */
@@ -1346,6 +1384,8 @@ dpc_post_reset_ha:
                         }
                 }
         }
+
+do_dpc_exit:
         clear_bit(AF_DPC_SCHEDULED, &ha->flags);
 }
 
@@ -1612,6 +1652,8 @@ static int __devinit qla4xxx_probe_adapter(struct pci_dev *pdev,
         ha->host = host;
         ha->host_no = host->host_no;
 
+        pci_enable_pcie_error_reporting(pdev);
+
         /* Setup Runtime configurable options */
         if (is_qla8022(ha)) {
                 ha->isp_ops = &qla4_8xxx_isp_ops;
@@ -1630,6 +1672,10 @@ static int __devinit qla4xxx_probe_adapter(struct pci_dev *pdev,
                 ha->isp_ops = &qla4xxx_isp_ops;
         }
 
+        /* Set EEH reset type to fundamental if required by hba */
+        if (is_qla8022(ha))
+                pdev->needs_freset = 1;
+
         /* Configure PCI I/O space. */
         ret = ha->isp_ops->iospace_config(ha);
         if (ret)
@@ -1726,6 +1772,7 @@ static int __devinit qla4xxx_probe_adapter(struct pci_dev *pdev,
                 }
         }
 
+        pci_save_state(ha->pdev);
         ha->isp_ops->enable_intrs(ha);
 
         /* Start timer thread. */
@@ -1752,6 +1799,7 @@ probe_failed:
         qla4xxx_free_adapter(ha);
 
 probe_failed_ioconfig:
+        pci_disable_pcie_error_reporting(pdev);
         scsi_host_put(ha->host);
 
 probe_disable_device:
@@ -1781,6 +1829,7 @@ static void __devexit qla4xxx_remove_adapter(struct pci_dev *pdev)
 
         scsi_host_put(ha->host);
 
+        pci_disable_pcie_error_reporting(pdev);
         pci_disable_device(pdev);
         pci_set_drvdata(pdev, NULL);
 }
@@ -1877,6 +1926,17 @@ static int qla4xxx_eh_wait_on_command(struct scsi_qla_host *ha,
         int done = 0;
         struct srb *rp;
         uint32_t max_wait_time = EH_WAIT_CMD_TOV;
+        int ret = SUCCESS;
+
+        /* Dont wait on command if PCI error is being handled
+         * by PCI AER driver
+         */
+        if (unlikely(pci_channel_offline(ha->pdev)) ||
+            (test_bit(AF_EEH_BUSY, &ha->flags))) {
+                ql4_printk(KERN_WARNING, ha, "scsi%ld: Return from %s\n",
+                    ha->host_no, __func__);
+                return ret;
+        }
 
         do {
                 /* Checking to see if its returned to OS */
@@ -2172,6 +2232,252 @@ static int qla4xxx_eh_host_reset(struct scsi_cmnd *cmd)
         return return_status;
 }
 
+/* PCI AER driver recovers from all correctable errors w/o
+ * driver intervention. For uncorrectable errors PCI AER
+ * driver calls the following device driver's callbacks
+ *
+ * - Fatal Errors - link_reset
+ * - Non-Fatal Errors - driver's pci_error_detected() which
+ * returns CAN_RECOVER, NEED_RESET or DISCONNECT.
+ *
+ * PCI AER driver calls
+ * CAN_RECOVER - driver's pci_mmio_enabled(), mmio_enabled
+ *               returns RECOVERED or NEED_RESET if fw_hung
+ * NEED_RESET - driver's slot_reset()
+ * DISCONNECT - device is dead & cannot recover
+ * RECOVERED - driver's pci_resume()
+ */
+static pci_ers_result_t
+qla4xxx_pci_error_detected(struct pci_dev *pdev, pci_channel_state_t state)
+{
+        struct scsi_qla_host *ha = pci_get_drvdata(pdev);
+
+        ql4_printk(KERN_WARNING, ha, "scsi%ld: %s: error detected:state %x\n",
+            ha->host_no, __func__, state);
+
+        if (!is_aer_supported(ha))
+                return PCI_ERS_RESULT_NONE;
+
+        switch (state) {
+        case pci_channel_io_normal:
+                clear_bit(AF_EEH_BUSY, &ha->flags);
+                return PCI_ERS_RESULT_CAN_RECOVER;
+        case pci_channel_io_frozen:
+                set_bit(AF_EEH_BUSY, &ha->flags);
+                qla4xxx_mailbox_premature_completion(ha);
+                qla4xxx_free_irqs(ha);
+                pci_disable_device(pdev);
+                return PCI_ERS_RESULT_NEED_RESET;
+        case pci_channel_io_perm_failure:
+                set_bit(AF_EEH_BUSY, &ha->flags);
+                set_bit(AF_PCI_CHANNEL_IO_PERM_FAILURE, &ha->flags);
+                qla4xxx_abort_active_cmds(ha, DID_NO_CONNECT << 16);
+                return PCI_ERS_RESULT_DISCONNECT;
+        }
+        return PCI_ERS_RESULT_NEED_RESET;
+}
+
+/**
+ * qla4xxx_pci_mmio_enabled() gets called if
+ * qla4xxx_pci_error_detected() returns PCI_ERS_RESULT_CAN_RECOVER
+ * and read/write to the device still works.
+ **/
+static pci_ers_result_t
+qla4xxx_pci_mmio_enabled(struct pci_dev *pdev)
+{
+        struct scsi_qla_host *ha = pci_get_drvdata(pdev);
+
+        if (!is_aer_supported(ha))
+                return PCI_ERS_RESULT_NONE;
+
+        if (test_bit(AF_FW_RECOVERY, &ha->flags)) {
+                ql4_printk(KERN_WARNING, ha, "scsi%ld: %s: firmware hang  -- "
+                    "mmio_enabled\n", ha->host_no, __func__);
+                return PCI_ERS_RESULT_NEED_RESET;
+        } else
+                return PCI_ERS_RESULT_RECOVERED;
+}
+
+uint32_t qla4_8xxx_error_recovery(struct scsi_qla_host *ha)
+{
+        uint32_t rval = QLA_ERROR;
+        int fn;
+        struct pci_dev *other_pdev = NULL;
+
+        ql4_printk(KERN_WARNING, ha, "scsi%ld: In %s\n", ha->host_no, __func__);
+
+        set_bit(DPC_RESET_ACTIVE, &ha->dpc_flags);
+
+        if (test_bit(AF_ONLINE, &ha->flags)) {
+                clear_bit(AF_ONLINE, &ha->flags);
+                qla4xxx_mark_all_devices_missing(ha);
+                qla4xxx_process_aen(ha, FLUSH_DDB_CHANGED_AENS);
+                qla4xxx_abort_active_cmds(ha, DID_RESET << 16);
+        }
+
+        fn = PCI_FUNC(ha->pdev->devfn);
+        while (fn > 0) {
+                fn--;
+                ql4_printk(KERN_INFO, ha, "scsi%ld: %s: Finding PCI device at "
+                    "func %x\n", ha->host_no, __func__, fn);
+                /* Get the pci device given the domain, bus,
+                 * slot/function number */
+                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),
+                    fn));
+
+                if (!other_pdev)
+                        continue;
+
+                if (atomic_read(&other_pdev->enable_cnt)) {
+                        ql4_printk(KERN_INFO, ha, "scsi%ld: %s: Found PCI "
+                            "func in enabled state%x\n", ha->host_no,
+                            __func__, fn);
+                        pci_dev_put(other_pdev);
+                        break;
+                }
+                pci_dev_put(other_pdev);
+        }
+
+        /* The first function on the card, the reset owner will
+         * start & initialize the firmware. The other functions
+         * on the card will reset the firmware context
+         */
+        if (!fn) {
+                ql4_printk(KERN_INFO, ha, "scsi%ld: %s: devfn being reset "
+                    "0x%x is the owner\n", ha->host_no, __func__,
+                    ha->pdev->devfn);
+
+                qla4_8xxx_idc_lock(ha);
+                qla4_8xxx_wr_32(ha, QLA82XX_CRB_DEV_STATE,
+                    QLA82XX_DEV_COLD);
+
+                qla4_8xxx_wr_32(ha, QLA82XX_CRB_DRV_IDC_VERSION,
+                    QLA82XX_IDC_VERSION);
+
+                qla4_8xxx_idc_unlock(ha);
+                clear_bit(AF_FW_RECOVERY, &ha->flags);
+                rval = qla4xxx_initialize_adapter(ha, PRESERVE_DDB_LIST);
+                qla4_8xxx_idc_lock(ha);
+
+                if (rval != QLA_SUCCESS) {
+                        ql4_printk(KERN_INFO, ha, "scsi%ld: %s: HW State: "
+                            "FAILED\n", ha->host_no, __func__);
+                        qla4_8xxx_clear_drv_active(ha);
+                        qla4_8xxx_wr_32(ha, QLA82XX_CRB_DEV_STATE,
+                            QLA82XX_DEV_FAILED);
+                } else {
+                        ql4_printk(KERN_INFO, ha, "scsi%ld: %s: HW State: "
+                            "READY\n", ha->host_no, __func__);
+                        qla4_8xxx_wr_32(ha, QLA82XX_CRB_DEV_STATE,
+                            QLA82XX_DEV_READY);
+                        /* Clear driver state register */
+                        qla4_8xxx_wr_32(ha, QLA82XX_CRB_DRV_STATE, 0);
+                        qla4_8xxx_set_drv_active(ha);
+                        ha->isp_ops->enable_intrs(ha);
+                }
+                qla4_8xxx_idc_unlock(ha);
+        } else {
+                ql4_printk(KERN_INFO, ha, "scsi%ld: %s: devfn 0x%x is not "
+                    "the reset owner\n", ha->host_no, __func__,
+                    ha->pdev->devfn);
+                if ((qla4_8xxx_rd_32(ha, QLA82XX_CRB_DEV_STATE) ==
+                    QLA82XX_DEV_READY)) {
+                        clear_bit(AF_FW_RECOVERY, &ha->flags);
+                        rval = qla4xxx_initialize_adapter(ha,
+                            PRESERVE_DDB_LIST);
+                        if (rval == QLA_SUCCESS)
+                                ha->isp_ops->enable_intrs(ha);
+                        qla4_8xxx_idc_lock(ha);
+                        qla4_8xxx_set_drv_active(ha);
+                        qla4_8xxx_idc_unlock(ha);
+                }
+        }
+        clear_bit(DPC_RESET_ACTIVE, &ha->dpc_flags);
+        return rval;
+}
+
+static pci_ers_result_t
+qla4xxx_pci_slot_reset(struct pci_dev *pdev)
+{
+        pci_ers_result_t ret = PCI_ERS_RESULT_DISCONNECT;
+        struct scsi_qla_host *ha = pci_get_drvdata(pdev);
+        int rc;
+
+        ql4_printk(KERN_WARNING, ha, "scsi%ld: %s: slot_reset\n",
+            ha->host_no, __func__);
+
+        if (!is_aer_supported(ha))
+                return PCI_ERS_RESULT_NONE;
+
+        /* Restore the saved state of PCIe device -
+         * BAR registers, PCI Config space, PCIX, MSI,
+         * IOV states
+         */
+        pci_restore_state(pdev);
+
+        /* pci_restore_state() clears the saved_state flag of the device
+         * save restored state which resets saved_state flag
+         */
+        pci_save_state(pdev);
+
+        /* Initialize device or resume if in suspended state */
+        rc = pci_enable_device(pdev);
+        if (rc) {
+                ql4_printk(KERN_WARNING, ha, "scsi%ld: %s: Cant re-enable "
+                    "device after reset\n", ha->host_no, __func__);
+                goto exit_slot_reset;
+        }
+
+        ret = qla4xxx_request_irqs(ha);
+        if (ret) {
+                ql4_printk(KERN_WARNING, ha, "Failed to reserve interrupt %d"
+                    " already in use.\n", pdev->irq);
+                goto exit_slot_reset;
+        }
+
+        if (is_qla8022(ha)) {
+                if (qla4_8xxx_error_recovery(ha) == QLA_SUCCESS) {
+                        ret = PCI_ERS_RESULT_RECOVERED;
+                        goto exit_slot_reset;
+                } else
+                        goto exit_slot_reset;
+        }
+
+exit_slot_reset:
+        ql4_printk(KERN_WARNING, ha, "scsi%ld: %s: Return=%x\n"
+            "device after reset\n", ha->host_no, __func__, ret);
+        return ret;
+}
+
+static void
+qla4xxx_pci_resume(struct pci_dev *pdev)
+{
+        struct scsi_qla_host *ha = pci_get_drvdata(pdev);
+        int ret;
+
+        ql4_printk(KERN_WARNING, ha, "scsi%ld: %s: pci_resume\n",
+            ha->host_no, __func__);
+
+        ret = qla4xxx_wait_for_hba_online(ha);
+        if (ret != QLA_SUCCESS) {
+                ql4_printk(KERN_ERR, ha, "scsi%ld: %s: the device failed to "
+                    "resume I/O from slot/link_reset\n", ha->host_no,
+                     __func__);
+        }
+
+        pci_cleanup_aer_uncorrect_error_status(pdev);
+        clear_bit(AF_EEH_BUSY, &ha->flags);
+}
+
+static struct pci_error_handlers qla4xxx_err_handler = {
+        .error_detected = qla4xxx_pci_error_detected,
+        .mmio_enabled = qla4xxx_pci_mmio_enabled,
+        .slot_reset = qla4xxx_pci_slot_reset,
+        .resume = qla4xxx_pci_resume,
+};
+
 static struct pci_device_id qla4xxx_pci_tbl[] = {
         {
                 .vendor         = PCI_VENDOR_ID_QLOGIC,
@@ -2206,6 +2512,7 @@ static struct pci_driver qla4xxx_pci_driver = {
         .id_table       = qla4xxx_pci_tbl,
         .probe          = qla4xxx_probe_adapter,
         .remove         = qla4xxx_remove_adapter,
+        .err_handler = &qla4xxx_err_handler,
 };
 
 static int __init qla4xxx_module_init(void)
diff --git a/drivers/scsi/qla4xxx/ql4_version.h b/drivers/scsi/qla4xxx/ql4_version.h
index c905dbd75331..a77b973f2cbc 100644
--- a/drivers/scsi/qla4xxx/ql4_version.h
+++ b/drivers/scsi/qla4xxx/ql4_version.h
@@ -5,4 +5,4 @@
  * See LICENSE.qla4xxx for copyright and licensing details.
  */
 
-#define QLA4XXX_DRIVER_VERSION  "5.02.00-k2"
+#define QLA4XXX_DRIVER_VERSION  "5.02.00-k3"
diff --git a/drivers/scsi/scsi_error.c b/drivers/scsi/scsi_error.c
index bbbc186dbc1a..1de30eb83bb0 100644
--- a/drivers/scsi/scsi_error.c
+++ b/drivers/scsi/scsi_error.c
@@ -473,14 +473,17 @@ static int scsi_eh_completed_normally(struct scsi_cmnd *scmd)
                  */
                 return SUCCESS;
         case RESERVATION_CONFLICT:
-                /*
-                 * let issuer deal with this, it could be just fine
-                 */
-                return SUCCESS;
+                if (scmd->cmnd[0] == TEST_UNIT_READY)
+                        /* it is a success, we probed the device and
+                         * found it */
+                        return SUCCESS;
+                /* otherwise, we failed to send the command */
+                return FAILED;
         case QUEUE_FULL:
                 scsi_handle_queue_full(scmd->device);
                 /* fall through */
         case BUSY:
+                return NEEDS_RETRY;
         default:
                 return FAILED;
         }
diff --git a/drivers/scsi/scsi_tgt_lib.c b/drivers/scsi/scsi_tgt_lib.c
index 66241dd525ae..c399be979921 100644
--- a/drivers/scsi/scsi_tgt_lib.c
+++ b/drivers/scsi/scsi_tgt_lib.c
@@ -185,6 +185,7 @@ static void scsi_tgt_cmd_destroy(struct work_struct *work)
         dprintk("cmd %p %d %u\n", cmd, cmd->sc_data_direction,
                 rq_data_dir(cmd->request));
         scsi_unmap_user_pages(tcmd);
+        tcmd->rq->bio = NULL;
         scsi_host_put_command(scsi_tgt_cmd_to_host(cmd), cmd);
 }
 
diff --git a/drivers/spi/amba-pl022.c b/drivers/spi/amba-pl022.c
index f0a1418ce660..acd35d1ebd12 100644
--- a/drivers/spi/amba-pl022.c
+++ b/drivers/spi/amba-pl022.c
@@ -1723,7 +1723,7 @@ static void pl022_cleanup(struct spi_device *spi)
 }
 
 
-static int __init
+static int __devinit
 pl022_probe(struct amba_device *adev, struct amba_id *id)
 {
         struct device *dev = &adev->dev;
@@ -1838,7 +1838,7 @@ pl022_probe(struct amba_device *adev, struct amba_id *id)
         return status;
 }
 
-static int __exit
+static int __devexit
 pl022_remove(struct amba_device *adev)
 {
         struct pl022 *pl022 = amba_get_drvdata(adev);
@@ -1970,7 +1970,7 @@ static struct amba_driver pl022_driver = {
         },
         .id_table       = pl022_ids,
         .probe          = pl022_probe,
-        .remove         = __exit_p(pl022_remove),
+        .remove         = __devexit_p(pl022_remove),
         .suspend        = pl022_suspend,
         .resume         = pl022_resume,
 };
diff --git a/drivers/spi/mpc512x_psc_spi.c b/drivers/spi/mpc512x_psc_spi.c
index cddbfceb324f..77d9e7ee8b27 100644
--- a/drivers/spi/mpc512x_psc_spi.c
+++ b/drivers/spi/mpc512x_psc_spi.c
@@ -406,9 +406,9 @@ static irqreturn_t mpc512x_psc_spi_isr(int irq, void *dev_id)
 }
 
 /* bus_num is used only for the case dev->platform_data == NULL */
-static int __init mpc512x_psc_spi_do_probe(struct device *dev, u32 regaddr,
-                                           u32 size, unsigned int irq,
-                                           s16 bus_num)
+static int __devinit mpc512x_psc_spi_do_probe(struct device *dev, u32 regaddr,
+                                              u32 size, unsigned int irq,
+                                              s16 bus_num)
 {
         struct fsl_spi_platform_data *pdata = dev->platform_data;
         struct mpc512x_psc_spi *mps;
@@ -492,7 +492,7 @@ free_master:
         return ret;
 }
 
-static int __exit mpc512x_psc_spi_do_remove(struct device *dev)
+static int __devexit mpc512x_psc_spi_do_remove(struct device *dev)
 {
         struct spi_master *master = dev_get_drvdata(dev);
         struct mpc512x_psc_spi *mps = spi_master_get_devdata(master);
@@ -507,8 +507,8 @@ static int __exit mpc512x_psc_spi_do_remove(struct device *dev)
         return 0;
 }
 
-static int __init mpc512x_psc_spi_of_probe(struct platform_device *op,
-                                           const struct of_device_id *match)
+static int __devinit mpc512x_psc_spi_of_probe(struct platform_device *op,
+                                              const struct of_device_id *match)
 {
         const u32 *regaddr_p;
         u64 regaddr64, size64;
@@ -539,7 +539,7 @@ static int __init mpc512x_psc_spi_of_probe(struct platform_device *op,
                                 irq_of_parse_and_map(op->dev.of_node, 0), id);
 }
 
-static int __exit mpc512x_psc_spi_of_remove(struct platform_device *op)
+static int __devexit mpc512x_psc_spi_of_remove(struct platform_device *op)
 {
         return mpc512x_psc_spi_do_remove(&op->dev);
 }
@@ -553,7 +553,7 @@ MODULE_DEVICE_TABLE(of, mpc512x_psc_spi_of_match);
 
 static struct of_platform_driver mpc512x_psc_spi_of_driver = {
         .probe = mpc512x_psc_spi_of_probe,
-        .remove = __exit_p(mpc512x_psc_spi_of_remove),
+        .remove = __devexit_p(mpc512x_psc_spi_of_remove),
         .driver = {
                 .name = "mpc512x-psc-spi",
                 .owner = THIS_MODULE,
diff --git a/drivers/spi/omap_spi_100k.c b/drivers/spi/omap_spi_100k.c
index 24668b30a52d..9bd1c92ad96e 100644
--- a/drivers/spi/omap_spi_100k.c
+++ b/drivers/spi/omap_spi_100k.c
@@ -141,7 +141,12 @@ static void spi100k_write_data(struct spi_master *master, int len, int data)
 {
         struct omap1_spi100k *spi100k = spi_master_get_devdata(master);
 
-        /* write 16-bit word */
+        /* write 16-bit word, shifting 8-bit data if necessary */
+        if (len <= 8) {
+                data <<= 8;
+                len = 16;
+        }
+
         spi100k_enable_clock(master);
         writew( data , spi100k->base + SPI_TX_MSB);
 
@@ -162,6 +167,10 @@ static int spi100k_read_data(struct spi_master *master, int len)
         int dataH,dataL;
         struct omap1_spi100k *spi100k = spi_master_get_devdata(master);
 
+        /* Always do at least 16 bits */
+        if (len <= 8)
+                len = 16;
+
         spi100k_enable_clock(master);
         writew(SPI_CTRL_SEN(0) |
                SPI_CTRL_WORD_SIZE(len) |
@@ -214,10 +223,6 @@ omap1_spi100k_txrx_pio(struct spi_device *spi, struct spi_transfer *xfer)
         c = count;
         word_len = cs->word_len;
 
-        /* RX_ONLY mode needs dummy data in TX reg */
-        if (xfer->tx_buf == NULL)
-                spi100k_write_data(spi->master,word_len, 0);
-
         if (word_len <= 8) {
                 u8              *rx;
                 const u8        *tx;
@@ -227,9 +232,9 @@ omap1_spi100k_txrx_pio(struct spi_device *spi, struct spi_transfer *xfer)
                 do {
                         c-=1;
                         if (xfer->tx_buf != NULL)
-                                spi100k_write_data(spi->master,word_len, *tx);
+                                spi100k_write_data(spi->master, word_len, *tx++);
                         if (xfer->rx_buf != NULL)
-                                *rx = spi100k_read_data(spi->master,word_len);
+                                *rx++ = spi100k_read_data(spi->master, word_len);
                 } while(c);
         } else if (word_len <= 16) {
                 u16             *rx;
@@ -380,10 +385,6 @@ static void omap1_spi100k_work(struct work_struct *work)
                         if (t->len) {
                                 unsigned count;
 
-                                /* RX_ONLY mode needs dummy data in TX reg */
-                                if (t->tx_buf == NULL)
-                                        spi100k_write_data(spi->master, 8, 0);
-
                                 count = omap1_spi100k_txrx_pio(spi, t);
                                 m->actual_length += count;
 
diff --git a/drivers/spi/spi.c b/drivers/spi/spi.c
index 1bb1b88780ce..a9e5c79ae52a 100644
--- a/drivers/spi/spi.c
+++ b/drivers/spi/spi.c
@@ -528,6 +528,10 @@ int spi_register_master(struct spi_master *master)
                 dynamic = 1;
         }
 
+        spin_lock_init(&master->bus_lock_spinlock);
+        mutex_init(&master->bus_lock_mutex);
+        master->bus_lock_flag = 0;
+
         /* register the device, then userspace will see it.
          * registration fails if the bus ID is in use.
          */
@@ -670,6 +674,35 @@ int spi_setup(struct spi_device *spi)
 }
 EXPORT_SYMBOL_GPL(spi_setup);
 
+static int __spi_async(struct spi_device *spi, struct spi_message *message)
+{
+        struct spi_master *master = spi->master;
+
+        /* Half-duplex links include original MicroWire, and ones with
+         * only one data pin like SPI_3WIRE (switches direction) or where
+         * either MOSI or MISO is missing.  They can also be caused by
+         * software limitations.
+         */
+        if ((master->flags & SPI_MASTER_HALF_DUPLEX)
+                        || (spi->mode & SPI_3WIRE)) {
+                struct spi_transfer *xfer;
+                unsigned flags = master->flags;
+
+                list_for_each_entry(xfer, &message->transfers, transfer_list) {
+                        if (xfer->rx_buf && xfer->tx_buf)
+                                return -EINVAL;
+                        if ((flags & SPI_MASTER_NO_TX) && xfer->tx_buf)
+                                return -EINVAL;
+                        if ((flags & SPI_MASTER_NO_RX) && xfer->rx_buf)
+                                return -EINVAL;
+                }
+        }
+
+        message->spi = spi;
+        message->status = -EINPROGRESS;
+        return master->transfer(spi, message);
+}
+
 /**
  * spi_async - asynchronous SPI transfer
  * @spi: device with which data will be exchanged
@@ -702,33 +735,68 @@ EXPORT_SYMBOL_GPL(spi_setup);
 int spi_async(struct spi_device *spi, struct spi_message *message)
 {
         struct spi_master *master = spi->master;
+        int ret;
+        unsigned long flags;
 
-        /* Half-duplex links include original MicroWire, and ones with
-         * only one data pin like SPI_3WIRE (switches direction) or where
-         * either MOSI or MISO is missing.  They can also be caused by
-         * software limitations.
-         */
-        if ((master->flags & SPI_MASTER_HALF_DUPLEX)
-                        || (spi->mode & SPI_3WIRE)) {
-                struct spi_transfer *xfer;
-                unsigned flags = master->flags;
+        spin_lock_irqsave(&master->bus_lock_spinlock, flags);
 
-                list_for_each_entry(xfer, &message->transfers, transfer_list) {
-                        if (xfer->rx_buf && xfer->tx_buf)
-                                return -EINVAL;
-                        if ((flags & SPI_MASTER_NO_TX) && xfer->tx_buf)
-                                return -EINVAL;
-                        if ((flags & SPI_MASTER_NO_RX) && xfer->rx_buf)
-                                return -EINVAL;
-                }
-        }
+        if (master->bus_lock_flag)
+                ret = -EBUSY;
+        else
+                ret = __spi_async(spi, message);
 
-        message->spi = spi;
-        message->status = -EINPROGRESS;
-        return master->transfer(spi, message);
+        spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
+
+        return ret;
 }
 EXPORT_SYMBOL_GPL(spi_async);
 
+/**
+ * spi_async_locked - version of spi_async with exclusive bus usage
+ * @spi: device with which data will be exchanged
+ * @message: describes the data transfers, including completion callback
+ * Context: any (irqs may be blocked, etc)
+ *
+ * This call may be used in_irq and other contexts which can't sleep,
+ * as well as from task contexts which can sleep.
+ *
+ * The completion callback is invoked in a context which can't sleep.
+ * Before that invocation, the value of message->status is undefined.
+ * When the callback is issued, message->status holds either zero (to
+ * indicate complete success) or a negative error code.  After that
+ * callback returns, the driver which issued the transfer request may
+ * deallocate the associated memory; it's no longer in use by any SPI
+ * core or controller driver code.
+ *
+ * Note that although all messages to a spi_device are handled in
+ * FIFO order, messages may go to different devices in other orders.
+ * Some device might be higher priority, or have various "hard" access
+ * time requirements, for example.
+ *
+ * On detection of any fault during the transfer, processing of
+ * the entire message is aborted, and the device is deselected.
+ * Until returning from the associated message completion callback,
+ * no other spi_message queued to that device will be processed.
+ * (This rule applies equally to all the synchronous transfer calls,
+ * which are wrappers around this core asynchronous primitive.)
+ */
+int spi_async_locked(struct spi_device *spi, struct spi_message *message)
+{
+        struct spi_master *master = spi->master;
+        int ret;
+        unsigned long flags;
+
+        spin_lock_irqsave(&master->bus_lock_spinlock, flags);
+
+        ret = __spi_async(spi, message);
+
+        spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
+
+        return ret;
+
+}
+EXPORT_SYMBOL_GPL(spi_async_locked);
+
 
 /*-------------------------------------------------------------------------*/
 
@@ -742,6 +810,32 @@ static void spi_complete(void *arg)
         complete(arg);
 }
 
+static int __spi_sync(struct spi_device *spi, struct spi_message *message,
+                      int bus_locked)
+{
+        DECLARE_COMPLETION_ONSTACK(done);
+        int status;
+        struct spi_master *master = spi->master;
+
+        message->complete = spi_complete;
+        message->context = &done;
+
+        if (!bus_locked)
+                mutex_lock(&master->bus_lock_mutex);
+
+        status = spi_async_locked(spi, message);
+
+        if (!bus_locked)
+                mutex_unlock(&master->bus_lock_mutex);
+
+        if (status == 0) {
+                wait_for_completion(&done);
+                status = message->status;
+        }
+        message->context = NULL;
+        return status;
+}
+
 /**
  * spi_sync - blocking/synchronous SPI data transfers
  * @spi: device with which data will be exchanged
@@ -765,21 +859,86 @@ static void spi_complete(void *arg)
  */
 int spi_sync(struct spi_device *spi, struct spi_message *message)
 {
-        DECLARE_COMPLETION_ONSTACK(done);
-        int status;
-
-        message->complete = spi_complete;
-        message->context = &done;
-        status = spi_async(spi, message);
-        if (status == 0) {
-                wait_for_completion(&done);
-                status = message->status;
-        }
-        message->context = NULL;
-        return status;
+        return __spi_sync(spi, message, 0);
 }
 EXPORT_SYMBOL_GPL(spi_sync);
 
+/**
+ * spi_sync_locked - version of spi_sync with exclusive bus usage
+ * @spi: device with which data will be exchanged
+ * @message: describes the data transfers
+ * Context: can sleep
+ *
+ * This call may only be used from a context that may sleep.  The sleep
+ * is non-interruptible, and has no timeout.  Low-overhead controller
+ * drivers may DMA directly into and out of the message buffers.
+ *
+ * This call should be used by drivers that require exclusive access to the
+ * SPI bus. It has to be preceeded by a spi_bus_lock call. The SPI bus must
+ * be released by a spi_bus_unlock call when the exclusive access is over.
+ *
+ * It returns zero on success, else a negative error code.
+ */
+int spi_sync_locked(struct spi_device *spi, struct spi_message *message)
+{
+        return __spi_sync(spi, message, 1);
+}
+EXPORT_SYMBOL_GPL(spi_sync_locked);
+
+/**
+ * spi_bus_lock - obtain a lock for exclusive SPI bus usage
+ * @master: SPI bus master that should be locked for exclusive bus access
+ * Context: can sleep
+ *
+ * This call may only be used from a context that may sleep.  The sleep
+ * is non-interruptible, and has no timeout.
+ *
+ * This call should be used by drivers that require exclusive access to the
+ * SPI bus. The SPI bus must be released by a spi_bus_unlock call when the
+ * exclusive access is over. Data transfer must be done by spi_sync_locked
+ * and spi_async_locked calls when the SPI bus lock is held.
+ *
+ * It returns zero on success, else a negative error code.
+ */
+int spi_bus_lock(struct spi_master *master)
+{
+        unsigned long flags;
+
+        mutex_lock(&master->bus_lock_mutex);
+
+        spin_lock_irqsave(&master->bus_lock_spinlock, flags);
+        master->bus_lock_flag = 1;
+        spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
+
+        /* mutex remains locked until spi_bus_unlock is called */
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(spi_bus_lock);
+
+/**
+ * spi_bus_unlock - release the lock for exclusive SPI bus usage
+ * @master: SPI bus master that was locked for exclusive bus access
+ * Context: can sleep
+ *
+ * This call may only be used from a context that may sleep.  The sleep
+ * is non-interruptible, and has no timeout.
+ *
+ * This call releases an SPI bus lock previously obtained by an spi_bus_lock
+ * call.
+ *
+ * It returns zero on success, else a negative error code.
+ */
+int spi_bus_unlock(struct spi_master *master)
+{
+        master->bus_lock_flag = 0;
+
+        mutex_unlock(&master->bus_lock_mutex);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(spi_bus_unlock);
+
 /* portable code must never pass more than 32 bytes */
 #define SPI_BUFSIZ      max(32,SMP_CACHE_BYTES)
 
diff --git a/drivers/spi/spi_bitbang.c b/drivers/spi/spi_bitbang.c
index 5265330a528f..8b55724d5f39 100644
--- a/drivers/spi/spi_bitbang.c
+++ b/drivers/spi/spi_bitbang.c
@@ -259,7 +259,6 @@ static void bitbang_work(struct work_struct *work)
         struct spi_bitbang      *bitbang =
                 container_of(work, struct spi_bitbang, work);
         unsigned long           flags;
-        int                     do_setup = -1;
         int                     (*setup_transfer)(struct spi_device *,
                                         struct spi_transfer *);
 
@@ -275,6 +274,7 @@ static void bitbang_work(struct work_struct *work)
                 unsigned                tmp;
                 unsigned                cs_change;
                 int                     status;
+                int                     do_setup = -1;
 
                 m = container_of(bitbang->queue.next, struct spi_message,
                                 queue);
@@ -307,6 +307,8 @@ static void bitbang_work(struct work_struct *work)
                                 status = setup_transfer(spi, t);
                                 if (status < 0)
                                         break;
+                                if (do_setup == -1)
+                                        do_setup = 0;
                         }
 
                         /* set up default clock polarity, and activate chip;
@@ -367,11 +369,6 @@ static void bitbang_work(struct work_struct *work)
                 m->status = status;
                 m->complete(m->context);
 
-                /* restore speed and wordsize if it was overridden */
-                if (do_setup == 1)
-                        setup_transfer(spi, NULL);
-                do_setup = 0;
-
                 /* normally deactivate chipselect ... unless no error and
                  * cs_change has hinted that the next message will probably
                  * be for this chip too.
diff --git a/drivers/spi/spi_bitbang_txrx.h b/drivers/spi/spi_bitbang_txrx.h
index fc033bbf9180..c16bf853c3eb 100644
--- a/drivers/spi/spi_bitbang_txrx.h
+++ b/drivers/spi/spi_bitbang_txrx.h
@@ -44,7 +44,7 @@
 
 static inline u32
 bitbang_txrx_be_cpha0(struct spi_device *spi,
-                unsigned nsecs, unsigned cpol,
+                unsigned nsecs, unsigned cpol, unsigned flags,
                 u32 word, u8 bits)
 {
         /* if (cpol == 0) this is SPI_MODE_0; else this is SPI_MODE_2 */
@@ -53,7 +53,8 @@ bitbang_txrx_be_cpha0(struct spi_device *spi,
         for (word <<= (32 - bits); likely(bits); bits--) {
 
                 /* setup MSB (to slave) on trailing edge */
-                setmosi(spi, word & (1 << 31));
+                if ((flags & SPI_MASTER_NO_TX) == 0)
+                        setmosi(spi, word & (1 << 31));
                 spidelay(nsecs);        /* T(setup) */
 
                 setsck(spi, !cpol);
@@ -61,7 +62,8 @@ bitbang_txrx_be_cpha0(struct spi_device *spi,
 
                 /* sample MSB (from slave) on leading edge */
                 word <<= 1;
-                word |= getmiso(spi);
+                if ((flags & SPI_MASTER_NO_RX) == 0)
+                        word |= getmiso(spi);
                 setsck(spi, cpol);
         }
         return word;
@@ -69,7 +71,7 @@ bitbang_txrx_be_cpha0(struct spi_device *spi,
 
 static inline u32
 bitbang_txrx_be_cpha1(struct spi_device *spi,
-                unsigned nsecs, unsigned cpol,
+                unsigned nsecs, unsigned cpol, unsigned flags,
                 u32 word, u8 bits)
 {
         /* if (cpol == 0) this is SPI_MODE_1; else this is SPI_MODE_3 */
@@ -79,7 +81,8 @@ bitbang_txrx_be_cpha1(struct spi_device *spi,
 
                 /* setup MSB (to slave) on leading edge */
                 setsck(spi, !cpol);
-                setmosi(spi, word & (1 << 31));
+                if ((flags & SPI_MASTER_NO_TX) == 0)
+                        setmosi(spi, word & (1 << 31));
                 spidelay(nsecs); /* T(setup) */
 
                 setsck(spi, cpol);
@@ -87,7 +90,8 @@ bitbang_txrx_be_cpha1(struct spi_device *spi,
 
                 /* sample MSB (from slave) on trailing edge */
                 word <<= 1;
-                word |= getmiso(spi);
+                if ((flags & SPI_MASTER_NO_RX) == 0)
+                        word |= getmiso(spi);
         }
         return word;
 }
diff --git a/drivers/spi/spi_butterfly.c b/drivers/spi/spi_butterfly.c
index 8b5281281111..0d4ceba3b590 100644
--- a/drivers/spi/spi_butterfly.c
+++ b/drivers/spi/spi_butterfly.c
@@ -156,7 +156,7 @@ butterfly_txrx_word_mode0(struct spi_device *spi,
                 unsigned nsecs,
                 u32 word, u8 bits)
 {
-        return bitbang_txrx_be_cpha0(spi, nsecs, 0, word, bits);
+        return bitbang_txrx_be_cpha0(spi, nsecs, 0, 0, word, bits);
 }
 
 /*----------------------------------------------------------------------*/
diff --git a/drivers/spi/spi_gpio.c b/drivers/spi/spi_gpio.c
index 7edbd5807e0e..e24a63498acb 100644
--- a/drivers/spi/spi_gpio.c
+++ b/drivers/spi/spi_gpio.c
@@ -146,25 +146,63 @@ static inline int getmiso(const struct spi_device *spi)
 static u32 spi_gpio_txrx_word_mode0(struct spi_device *spi,
                 unsigned nsecs, u32 word, u8 bits)
 {
-        return bitbang_txrx_be_cpha0(spi, nsecs, 0, word, bits);
+        return bitbang_txrx_be_cpha0(spi, nsecs, 0, 0, word, bits);
 }
 
 static u32 spi_gpio_txrx_word_mode1(struct spi_device *spi,
                 unsigned nsecs, u32 word, u8 bits)
 {
-        return bitbang_txrx_be_cpha1(spi, nsecs, 0, word, bits);
+        return bitbang_txrx_be_cpha1(spi, nsecs, 0, 0, word, bits);
 }
 
 static u32 spi_gpio_txrx_word_mode2(struct spi_device *spi,
                 unsigned nsecs, u32 word, u8 bits)
 {
-        return bitbang_txrx_be_cpha0(spi, nsecs, 1, word, bits);
+        return bitbang_txrx_be_cpha0(spi, nsecs, 1, 0, word, bits);
 }
 
 static u32 spi_gpio_txrx_word_mode3(struct spi_device *spi,
                 unsigned nsecs, u32 word, u8 bits)
 {
-        return bitbang_txrx_be_cpha1(spi, nsecs, 1, word, bits);
+        return bitbang_txrx_be_cpha1(spi, nsecs, 1, 0, word, bits);
+}
+
+/*
+ * These functions do not call setmosi or getmiso if respective flag
+ * (SPI_MASTER_NO_RX or SPI_MASTER_NO_TX) is set, so they are safe to
+ * call when such pin is not present or defined in the controller.
+ * A separate set of callbacks is defined to get highest possible
+ * speed in the generic case (when both MISO and MOSI lines are
+ * available), as optimiser will remove the checks when argument is
+ * constant.
+ */
+
+static u32 spi_gpio_spec_txrx_word_mode0(struct spi_device *spi,
+                unsigned nsecs, u32 word, u8 bits)
+{
+        unsigned flags = spi->master->flags;
+        return bitbang_txrx_be_cpha0(spi, nsecs, 0, flags, word, bits);
+}
+
+static u32 spi_gpio_spec_txrx_word_mode1(struct spi_device *spi,
+                unsigned nsecs, u32 word, u8 bits)
+{
+        unsigned flags = spi->master->flags;
+        return bitbang_txrx_be_cpha1(spi, nsecs, 0, flags, word, bits);
+}
+
+static u32 spi_gpio_spec_txrx_word_mode2(struct spi_device *spi,
+                unsigned nsecs, u32 word, u8 bits)
+{
+        unsigned flags = spi->master->flags;
+        return bitbang_txrx_be_cpha0(spi, nsecs, 1, flags, word, bits);
+}
+
+static u32 spi_gpio_spec_txrx_word_mode3(struct spi_device *spi,
+                unsigned nsecs, u32 word, u8 bits)
+{
+        unsigned flags = spi->master->flags;
+        return bitbang_txrx_be_cpha1(spi, nsecs, 1, flags, word, bits);
 }
 
 /*----------------------------------------------------------------------*/
@@ -232,19 +270,30 @@ static int __init spi_gpio_alloc(unsigned pin, const char *label, bool is_in)
 }
 
 static int __init
-spi_gpio_request(struct spi_gpio_platform_data *pdata, const char *label)
+spi_gpio_request(struct spi_gpio_platform_data *pdata, const char *label,
+        u16 *res_flags)
 {
         int value;
 
         /* NOTE:  SPI_*_GPIO symbols may reference "pdata" */
 
-        value = spi_gpio_alloc(SPI_MOSI_GPIO, label, false);
-        if (value)
-                goto done;
+        if (SPI_MOSI_GPIO != SPI_GPIO_NO_MOSI) {
+                value = spi_gpio_alloc(SPI_MOSI_GPIO, label, false);
+                if (value)
+                        goto done;
+        } else {
+                /* HW configuration without MOSI pin */
+                *res_flags |= SPI_MASTER_NO_TX;
+        }
 
-        value = spi_gpio_alloc(SPI_MISO_GPIO, label, true);
-        if (value)
-                goto free_mosi;
+        if (SPI_MISO_GPIO != SPI_GPIO_NO_MISO) {
+                value = spi_gpio_alloc(SPI_MISO_GPIO, label, true);
+                if (value)
+                        goto free_mosi;
+        } else {
+                /* HW configuration without MISO pin */
+                *res_flags |= SPI_MASTER_NO_RX;
+        }
 
         value = spi_gpio_alloc(SPI_SCK_GPIO, label, false);
         if (value)
@@ -253,9 +302,11 @@ spi_gpio_request(struct spi_gpio_platform_data *pdata, const char *label)
         goto done;
 
 free_miso:
-        gpio_free(SPI_MISO_GPIO);
+        if (SPI_MISO_GPIO != SPI_GPIO_NO_MISO)
+                gpio_free(SPI_MISO_GPIO);
 free_mosi:
-        gpio_free(SPI_MOSI_GPIO);
+        if (SPI_MOSI_GPIO != SPI_GPIO_NO_MOSI)
+                gpio_free(SPI_MOSI_GPIO);
 done:
         return value;
 }
@@ -266,6 +317,7 @@ static int __init spi_gpio_probe(struct platform_device *pdev)
         struct spi_master               *master;
         struct spi_gpio                 *spi_gpio;
         struct spi_gpio_platform_data   *pdata;
+        u16 master_flags = 0;
 
         pdata = pdev->dev.platform_data;
 #ifdef GENERIC_BITBANG
@@ -273,7 +325,7 @@ static int __init spi_gpio_probe(struct platform_device *pdev)
                 return -ENODEV;
 #endif
 
-        status = spi_gpio_request(pdata, dev_name(&pdev->dev));
+        status = spi_gpio_request(pdata, dev_name(&pdev->dev), &master_flags);
         if (status < 0)
                 return status;
 
@@ -289,6 +341,7 @@ static int __init spi_gpio_probe(struct platform_device *pdev)
         if (pdata)
                 spi_gpio->pdata = *pdata;
 
+        master->flags = master_flags;
         master->bus_num = pdev->id;
         master->num_chipselect = SPI_N_CHIPSEL;
         master->setup = spi_gpio_setup;
@@ -296,10 +349,18 @@ static int __init spi_gpio_probe(struct platform_device *pdev)
 
         spi_gpio->bitbang.master = spi_master_get(master);
         spi_gpio->bitbang.chipselect = spi_gpio_chipselect;
-        spi_gpio->bitbang.txrx_word[SPI_MODE_0] = spi_gpio_txrx_word_mode0;
-        spi_gpio->bitbang.txrx_word[SPI_MODE_1] = spi_gpio_txrx_word_mode1;
-        spi_gpio->bitbang.txrx_word[SPI_MODE_2] = spi_gpio_txrx_word_mode2;
-        spi_gpio->bitbang.txrx_word[SPI_MODE_3] = spi_gpio_txrx_word_mode3;
+
+        if ((master_flags & (SPI_MASTER_NO_RX | SPI_MASTER_NO_RX)) == 0) {
+                spi_gpio->bitbang.txrx_word[SPI_MODE_0] = spi_gpio_txrx_word_mode0;
+                spi_gpio->bitbang.txrx_word[SPI_MODE_1] = spi_gpio_txrx_word_mode1;
+                spi_gpio->bitbang.txrx_word[SPI_MODE_2] = spi_gpio_txrx_word_mode2;
+                spi_gpio->bitbang.txrx_word[SPI_MODE_3] = spi_gpio_txrx_word_mode3;
+        } else {
+                spi_gpio->bitbang.txrx_word[SPI_MODE_0] = spi_gpio_spec_txrx_word_mode0;
+                spi_gpio->bitbang.txrx_word[SPI_MODE_1] = spi_gpio_spec_txrx_word_mode1;
+                spi_gpio->bitbang.txrx_word[SPI_MODE_2] = spi_gpio_spec_txrx_word_mode2;
+                spi_gpio->bitbang.txrx_word[SPI_MODE_3] = spi_gpio_spec_txrx_word_mode3;
+        }
         spi_gpio->bitbang.setup_transfer = spi_bitbang_setup_transfer;
         spi_gpio->bitbang.flags = SPI_CS_HIGH;
 
@@ -307,8 +368,10 @@ static int __init spi_gpio_probe(struct platform_device *pdev)
         if (status < 0) {
                 spi_master_put(spi_gpio->bitbang.master);
 gpio_free:
-                gpio_free(SPI_MISO_GPIO);
-                gpio_free(SPI_MOSI_GPIO);
+                if (SPI_MISO_GPIO != SPI_GPIO_NO_MISO)
+                        gpio_free(SPI_MISO_GPIO);
+                if (SPI_MOSI_GPIO != SPI_GPIO_NO_MOSI)
+                        gpio_free(SPI_MOSI_GPIO);
                 gpio_free(SPI_SCK_GPIO);
                 spi_master_put(master);
         }
@@ -331,8 +394,10 @@ static int __exit spi_gpio_remove(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, NULL);
 
-        gpio_free(SPI_MISO_GPIO);
-        gpio_free(SPI_MOSI_GPIO);
+        if (SPI_MISO_GPIO != SPI_GPIO_NO_MISO)
+                gpio_free(SPI_MISO_GPIO);
+        if (SPI_MOSI_GPIO != SPI_GPIO_NO_MOSI)
+                gpio_free(SPI_MOSI_GPIO);
         gpio_free(SPI_SCK_GPIO);
 
         return status;
diff --git a/drivers/spi/spi_lm70llp.c b/drivers/spi/spi_lm70llp.c
index 86fb7b5993db..7746a41ab6d6 100644
--- a/drivers/spi/spi_lm70llp.c
+++ b/drivers/spi/spi_lm70llp.c
@@ -191,7 +191,7 @@ static void lm70_chipselect(struct spi_device *spi, int value)
  */
 static u32 lm70_txrx(struct spi_device *spi, unsigned nsecs, u32 word, u8 bits)
 {
-        return bitbang_txrx_be_cpha0(spi, nsecs, 0, word, bits);
+        return bitbang_txrx_be_cpha0(spi, nsecs, 0, 0, word, bits);
 }
 
 static void spi_lm70llp_attach(struct parport *p)
diff --git a/drivers/spi/spi_s3c24xx_gpio.c b/drivers/spi/spi_s3c24xx_gpio.c
index 8979a75dbd7b..be991359bf92 100644
--- a/drivers/spi/spi_s3c24xx_gpio.c
+++ b/drivers/spi/spi_s3c24xx_gpio.c
@@ -64,25 +64,25 @@ static inline u32 getmiso(struct spi_device *dev)
 static u32 s3c2410_spigpio_txrx_mode0(struct spi_device *spi,
                                       unsigned nsecs, u32 word, u8 bits)
 {
-        return bitbang_txrx_be_cpha0(spi, nsecs, 0, word, bits);
+        return bitbang_txrx_be_cpha0(spi, nsecs, 0, 0, word, bits);
 }
 
 static u32 s3c2410_spigpio_txrx_mode1(struct spi_device *spi,
                                       unsigned nsecs, u32 word, u8 bits)
 {
-        return bitbang_txrx_be_cpha1(spi, nsecs, 0, word, bits);
+        return bitbang_txrx_be_cpha1(spi, nsecs, 0, 0, word, bits);
 }
 
 static u32 s3c2410_spigpio_txrx_mode2(struct spi_device *spi,
                                       unsigned nsecs, u32 word, u8 bits)
 {
-        return bitbang_txrx_be_cpha0(spi, nsecs, 1, word, bits);
+        return bitbang_txrx_be_cpha0(spi, nsecs, 1, 0, word, bits);
 }
 
 static u32 s3c2410_spigpio_txrx_mode3(struct spi_device *spi,
                                       unsigned nsecs, u32 word, u8 bits)
 {
-        return bitbang_txrx_be_cpha1(spi, nsecs, 1, word, bits);
+        return bitbang_txrx_be_cpha1(spi, nsecs, 1, 0, word, bits);
 }
 
 
diff --git a/drivers/spi/spi_sh_sci.c b/drivers/spi/spi_sh_sci.c
index a511be7961a0..5c6439161199 100644
--- a/drivers/spi/spi_sh_sci.c
+++ b/drivers/spi/spi_sh_sci.c
@@ -83,25 +83,25 @@ static inline u32 getmiso(struct spi_device *dev)
 static u32 sh_sci_spi_txrx_mode0(struct spi_device *spi,
                                       unsigned nsecs, u32 word, u8 bits)
 {
-        return bitbang_txrx_be_cpha0(spi, nsecs, 0, word, bits);
+        return bitbang_txrx_be_cpha0(spi, nsecs, 0, 0, word, bits);
 }
 
 static u32 sh_sci_spi_txrx_mode1(struct spi_device *spi,
                                       unsigned nsecs, u32 word, u8 bits)
 {
-        return bitbang_txrx_be_cpha1(spi, nsecs, 0, word, bits);
+        return bitbang_txrx_be_cpha1(spi, nsecs, 0, 0, word, bits);
 }
 
 static u32 sh_sci_spi_txrx_mode2(struct spi_device *spi,
                                       unsigned nsecs, u32 word, u8 bits)
 {
-        return bitbang_txrx_be_cpha0(spi, nsecs, 1, word, bits);
+        return bitbang_txrx_be_cpha0(spi, nsecs, 1, 0, word, bits);
 }
 
 static u32 sh_sci_spi_txrx_mode3(struct spi_device *spi,
                                       unsigned nsecs, u32 word, u8 bits)
 {
-        return bitbang_txrx_be_cpha1(spi, nsecs, 1, word, bits);
+        return bitbang_txrx_be_cpha1(spi, nsecs, 1, 0, word, bits);
 }
 
 static void sh_sci_spi_chipselect(struct spi_device *dev, int value)