Merge branch 'imx/for-2.6.36' of git://git.pengutronix.de/git/ukl/linux-2.6 into HEAD

There are some more conflicts than detected by git, namely support for
the newly added cpuimx machines needed to be converted to dynamic device
registration.

Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>

Conflicts:
	arch/arm/mach-imx/Makefile
	arch/arm/mach-imx/devices.c
	arch/arm/mach-imx/devices.h
	arch/arm/mach-imx/eukrea_mbimx27-baseboard.c
	arch/arm/mach-mx2/Kconfig
	arch/arm/mach-mx25/Makefile
	arch/arm/mach-mx25/devices.c
	arch/arm/plat-mxc/include/mach/mx25.h
	arch/arm/plat-mxc/include/mach/mxc_nand.h

359 files changed, 25345 insertions, 4965 deletions

diff --git a/drivers/Makefile b/drivers/Makefile
index f42a03029b7c..91874e048552 100644
--- a/drivers/Makefile
+++ b/drivers/Makefile
@@ -10,6 +10,7 @@ obj-$(CONFIG_PCI)		+= pci/
 obj-$(CONFIG_PARISC)            += parisc/
 obj-$(CONFIG_RAPIDIO)           += rapidio/
 obj-y                           += video/
+obj-y                           += idle/
 obj-$(CONFIG_ACPI)              += acpi/
 obj-$(CONFIG_SFI)               += sfi/
 # PnP must come after ACPI since it will eventually need to check if acpi
@@ -91,7 +92,6 @@ obj-$(CONFIG_EISA)		+= eisa/
 obj-y                           += lguest/
 obj-$(CONFIG_CPU_FREQ)          += cpufreq/
 obj-$(CONFIG_CPU_IDLE)          += cpuidle/
-obj-y                           += idle/
 obj-$(CONFIG_MMC)               += mmc/
 obj-$(CONFIG_MEMSTICK)          += memstick/
 obj-$(CONFIG_NEW_LEDS)          += leds/
diff --git a/drivers/acpi/Kconfig b/drivers/acpi/Kconfig
index 93d2c7971df6..746411518802 100644
--- a/drivers/acpi/Kconfig
+++ b/drivers/acpi/Kconfig
@@ -360,4 +360,13 @@ config ACPI_SBS
           To compile this driver as a module, choose M here:
           the modules will be called sbs and sbshc.
 
+config ACPI_HED
+        tristate "Hardware Error Device"
+        help
+          This driver supports the Hardware Error Device (PNP0C33),
+          which is used to report some hardware errors notified via
+          SCI, mainly the corrected errors.
+
+source "drivers/acpi/apei/Kconfig"
+
 endif   # ACPI
diff --git a/drivers/acpi/Makefile b/drivers/acpi/Makefile
index a8d8998dd5c5..6ee33169e1dc 100644
--- a/drivers/acpi/Makefile
+++ b/drivers/acpi/Makefile
@@ -19,7 +19,7 @@ obj-y				+= acpi.o \
 
 # All the builtin files are in the "acpi." module_param namespace.
 acpi-y                          += osl.o utils.o reboot.o
-acpi-y                          += hest.o
+acpi-y                          += atomicio.o
 
 # sleep related files
 acpi-y                          += wakeup.o
@@ -59,6 +59,7 @@ obj-$(CONFIG_ACPI_BATTERY)	+= battery.o
 obj-$(CONFIG_ACPI_SBS)          += sbshc.o
 obj-$(CONFIG_ACPI_SBS)          += sbs.o
 obj-$(CONFIG_ACPI_POWER_METER)  += power_meter.o
+obj-$(CONFIG_ACPI_HED)          += hed.o
 
 # processor has its own "processor." module_param namespace
 processor-y                     := processor_driver.o processor_throttling.o
@@ -66,3 +67,5 @@ processor-y			+= processor_idle.o processor_thermal.o
 processor-$(CONFIG_CPU_FREQ)    += processor_perflib.o
 
 obj-$(CONFIG_ACPI_PROCESSOR_AGGREGATOR) += acpi_pad.o
+
+obj-$(CONFIG_ACPI_APEI)         += apei/
diff --git a/drivers/acpi/acpi_pad.c b/drivers/acpi/acpi_pad.c
index 62122134693b..d269a8f3329c 100644
--- a/drivers/acpi/acpi_pad.c
+++ b/drivers/acpi/acpi_pad.c
@@ -43,6 +43,10 @@ static DEFINE_MUTEX(isolated_cpus_lock);
 #define CPUID5_ECX_EXTENSIONS_SUPPORTED (0x1)
 #define CPUID5_ECX_INTERRUPT_BREAK      (0x2)
 static unsigned long power_saving_mwait_eax;
+
+static unsigned char tsc_detected_unstable;
+static unsigned char tsc_marked_unstable;
+
 static void power_saving_mwait_init(void)
 {
         unsigned int eax, ebx, ecx, edx;
@@ -87,8 +91,8 @@ static void power_saving_mwait_init(void)
 
                 /*FALL THROUGH*/
         default:
-                /* TSC could halt in idle, so notify users */
-                mark_tsc_unstable("TSC halts in idle");
+                /* TSC could halt in idle */
+                tsc_detected_unstable = 1;
         }
 #endif
 }
@@ -168,16 +172,14 @@ static int power_saving_thread(void *data)
 
                 do_sleep = 0;
 
-                current_thread_info()->status &= ~TS_POLLING;
-                /*
-                 * TS_POLLING-cleared state must be visible before we test
-                 * NEED_RESCHED:
-                 */
-                smp_mb();
-
                 expire_time = jiffies + HZ * (100 - idle_pct) / 100;
 
                 while (!need_resched()) {
+                        if (tsc_detected_unstable && !tsc_marked_unstable) {
+                                /* TSC could halt in idle, so notify users */
+                                mark_tsc_unstable("TSC halts in idle");
+                                tsc_marked_unstable = 1;
+                        }
                         local_irq_disable();
                         cpu = smp_processor_id();
                         clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_ENTER,
@@ -200,8 +202,6 @@ static int power_saving_thread(void *data)
                         }
                 }
 
-                current_thread_info()->status |= TS_POLLING;
-
                 /*
                  * current sched_rt has threshold for rt task running time.
                  * When a rt task uses 95% CPU time, the rt thread will be
diff --git a/drivers/acpi/acpica/evxfevnt.c b/drivers/acpi/acpica/evxfevnt.c
index 7c7bbb4d402c..d5a5efc043bf 100644
--- a/drivers/acpi/acpica/evxfevnt.c
+++ b/drivers/acpi/acpica/evxfevnt.c
@@ -69,7 +69,7 @@ acpi_ev_get_gpe_device(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
 
 acpi_status acpi_enable(void)
 {
-        acpi_status status = AE_OK;
+        acpi_status status;
 
         ACPI_FUNCTION_TRACE(acpi_enable);
 
@@ -84,21 +84,30 @@ acpi_status acpi_enable(void)
         if (acpi_hw_get_mode() == ACPI_SYS_MODE_ACPI) {
                 ACPI_DEBUG_PRINT((ACPI_DB_INIT,
                                   "System is already in ACPI mode\n"));
-        } else {
-                /* Transition to ACPI mode */
+                return_ACPI_STATUS(AE_OK);
+        }
 
-                status = acpi_hw_set_mode(ACPI_SYS_MODE_ACPI);
-                if (ACPI_FAILURE(status)) {
-                        ACPI_ERROR((AE_INFO,
-                                    "Could not transition to ACPI mode"));
-                        return_ACPI_STATUS(status);
-                }
+        /* Transition to ACPI mode */
 
-                ACPI_DEBUG_PRINT((ACPI_DB_INIT,
-                                  "Transition to ACPI mode successful\n"));
+        status = acpi_hw_set_mode(ACPI_SYS_MODE_ACPI);
+        if (ACPI_FAILURE(status)) {
+                ACPI_ERROR((AE_INFO,
+                            "Could not transition to ACPI mode"));
+                return_ACPI_STATUS(status);
         }
 
-        return_ACPI_STATUS(status);
+        /* Sanity check that transition succeeded */
+
+        if (acpi_hw_get_mode() != ACPI_SYS_MODE_ACPI) {
+                ACPI_ERROR((AE_INFO,
+                            "Hardware did not enter ACPI mode"));
+                return_ACPI_STATUS(AE_NO_HARDWARE_RESPONSE);
+        }
+
+        ACPI_DEBUG_PRINT((ACPI_DB_INIT,
+                          "Transition to ACPI mode successful\n"));
+
+        return_ACPI_STATUS(AE_OK);
 }
 
 ACPI_EXPORT_SYMBOL(acpi_enable)
diff --git a/drivers/acpi/acpica/hwacpi.c b/drivers/acpi/acpica/hwacpi.c
index 679a112a7d26..b44274a0b62c 100644
--- a/drivers/acpi/acpica/hwacpi.c
+++ b/drivers/acpi/acpica/hwacpi.c
@@ -63,7 +63,6 @@ acpi_status acpi_hw_set_mode(u32 mode)
 {
 
         acpi_status status;
-        u32 retry;
 
         ACPI_FUNCTION_TRACE(hw_set_mode);
 
@@ -125,24 +124,7 @@ acpi_status acpi_hw_set_mode(u32 mode)
                 return_ACPI_STATUS(status);
         }
 
-        /*
-         * Some hardware takes a LONG time to switch modes. Give them 3 sec to
-         * do so, but allow faster systems to proceed more quickly.
-         */
-        retry = 3000;
-        while (retry) {
-                if (acpi_hw_get_mode() == mode) {
-                        ACPI_DEBUG_PRINT((ACPI_DB_INFO,
-                                          "Mode %X successfully enabled\n",
-                                          mode));
-                        return_ACPI_STATUS(AE_OK);
-                }
-                acpi_os_stall(1000);
-                retry--;
-        }
-
-        ACPI_ERROR((AE_INFO, "Hardware did not change modes"));
-        return_ACPI_STATUS(AE_NO_HARDWARE_RESPONSE);
+        return_ACPI_STATUS(AE_OK);
 }
 
 /*******************************************************************************
diff --git a/drivers/acpi/apei/Kconfig b/drivers/acpi/apei/Kconfig
new file mode 100644
index 000000000000..f8c668f27b5a
--- /dev/null
+++ b/drivers/acpi/apei/Kconfig
@@ -0,0 +1,30 @@
+config ACPI_APEI
+        bool "ACPI Platform Error Interface (APEI)"
+        depends on X86
+        help
+          APEI allows to report errors (for example from the chipset)
+          to the operating system. This improves NMI handling
+          especially. In addition it supports error serialization and
+          error injection.
+
+config ACPI_APEI_GHES
+        tristate "APEI Generic Hardware Error Source"
+        depends on ACPI_APEI && X86
+        select ACPI_HED
+        help
+          Generic Hardware Error Source provides a way to report
+          platform hardware errors (such as that from chipset). It
+          works in so called "Firmware First" mode, that is, hardware
+          errors are reported to firmware firstly, then reported to
+          Linux by firmware. This way, some non-standard hardware
+          error registers or non-standard hardware link can be checked
+          by firmware to produce more valuable hardware error
+          information for Linux.
+
+config ACPI_APEI_EINJ
+        tristate "APEI Error INJection (EINJ)"
+        depends on ACPI_APEI && DEBUG_FS
+        help
+          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.
diff --git a/drivers/acpi/apei/Makefile b/drivers/acpi/apei/Makefile
new file mode 100644
index 000000000000..b13b03a17789
--- /dev/null
+++ b/drivers/acpi/apei/Makefile
@@ -0,0 +1,5 @@
+obj-$(CONFIG_ACPI_APEI)         += apei.o
+obj-$(CONFIG_ACPI_APEI_GHES)    += ghes.o
+obj-$(CONFIG_ACPI_APEI_EINJ)    += einj.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
new file mode 100644
index 000000000000..db3946e9c66b
--- /dev/null
+++ b/drivers/acpi/apei/apei-base.c
@@ -0,0 +1,593 @@
+/*
+ * apei-base.c - ACPI Platform Error Interface (APEI) supporting
+ * infrastructure
+ *
+ * APEI allows to report errors (for example from the chipset) to the
+ * the operating system. This improves NMI handling especially. In
+ * addition it supports error serialization and error injection.
+ *
+ * For more information about APEI, please refer to ACPI Specification
+ * version 4.0, chapter 17.
+ *
+ * This file has Common functions used by more than one APEI table,
+ * including framework of interpreter for ERST and EINJ; resource
+ * management for APEI registers.
+ *
+ * Copyright (C) 2009, 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/init.h>
+#include <linux/acpi.h>
+#include <linux/io.h>
+#include <linux/kref.h>
+#include <linux/rculist.h>
+#include <linux/interrupt.h>
+#include <linux/debugfs.h>
+#include <acpi/atomicio.h>
+
+#include "apei-internal.h"
+
+#define APEI_PFX "APEI: "
+
+/*
+ * APEI ERST (Error Record Serialization Table) and EINJ (Error
+ * INJection) interpreter framework.
+ */
+
+#define APEI_EXEC_PRESERVE_REGISTER     0x1
+
+void apei_exec_ctx_init(struct apei_exec_context *ctx,
+                        struct apei_exec_ins_type *ins_table,
+                        u32 instructions,
+                        struct acpi_whea_header *action_table,
+                        u32 entries)
+{
+        ctx->ins_table = ins_table;
+        ctx->instructions = instructions;
+        ctx->action_table = action_table;
+        ctx->entries = entries;
+}
+EXPORT_SYMBOL_GPL(apei_exec_ctx_init);
+
+int __apei_exec_read_register(struct acpi_whea_header *entry, u64 *val)
+{
+        int rc;
+
+        rc = acpi_atomic_read(val, &entry->register_region);
+        if (rc)
+                return rc;
+        *val >>= entry->register_region.bit_offset;
+        *val &= entry->mask;
+
+        return 0;
+}
+
+int apei_exec_read_register(struct apei_exec_context *ctx,
+                            struct acpi_whea_header *entry)
+{
+        int rc;
+        u64 val = 0;
+
+        rc = __apei_exec_read_register(entry, &val);
+        if (rc)
+                return rc;
+        ctx->value = val;
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(apei_exec_read_register);
+
+int apei_exec_read_register_value(struct apei_exec_context *ctx,
+                                  struct acpi_whea_header *entry)
+{
+        int rc;
+
+        rc = apei_exec_read_register(ctx, entry);
+        if (rc)
+                return rc;
+        ctx->value = (ctx->value == entry->value);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(apei_exec_read_register_value);
+
+int __apei_exec_write_register(struct acpi_whea_header *entry, u64 val)
+{
+        int rc;
+
+        val &= entry->mask;
+        val <<= entry->register_region.bit_offset;
+        if (entry->flags & APEI_EXEC_PRESERVE_REGISTER) {
+                u64 valr = 0;
+                rc = acpi_atomic_read(&valr, &entry->register_region);
+                if (rc)
+                        return rc;
+                valr &= ~(entry->mask << entry->register_region.bit_offset);
+                val |= valr;
+        }
+        rc = acpi_atomic_write(val, &entry->register_region);
+
+        return rc;
+}
+
+int apei_exec_write_register(struct apei_exec_context *ctx,
+                             struct acpi_whea_header *entry)
+{
+        return __apei_exec_write_register(entry, ctx->value);
+}
+EXPORT_SYMBOL_GPL(apei_exec_write_register);
+
+int apei_exec_write_register_value(struct apei_exec_context *ctx,
+                                   struct acpi_whea_header *entry)
+{
+        int rc;
+
+        ctx->value = entry->value;
+        rc = apei_exec_write_register(ctx, entry);
+
+        return rc;
+}
+EXPORT_SYMBOL_GPL(apei_exec_write_register_value);
+
+int apei_exec_noop(struct apei_exec_context *ctx,
+                   struct acpi_whea_header *entry)
+{
+        return 0;
+}
+EXPORT_SYMBOL_GPL(apei_exec_noop);
+
+/*
+ * Interpret the specified action. Go through whole action table,
+ * execute all instructions belong to the action.
+ */
+int apei_exec_run(struct apei_exec_context *ctx, u8 action)
+{
+        int rc;
+        u32 i, ip;
+        struct acpi_whea_header *entry;
+        apei_exec_ins_func_t run;
+
+        ctx->ip = 0;
+
+        /*
+         * "ip" is the instruction pointer of current instruction,
+         * "ctx->ip" specifies the next instruction to executed,
+         * instruction "run" function may change the "ctx->ip" to
+         * implement "goto" semantics.
+         */
+rewind:
+        ip = 0;
+        for (i = 0; i < ctx->entries; i++) {
+                entry = &ctx->action_table[i];
+                if (entry->action != action)
+                        continue;
+                if (ip == ctx->ip) {
+                        if (entry->instruction >= ctx->instructions ||
+                            !ctx->ins_table[entry->instruction].run) {
+                                pr_warning(FW_WARN APEI_PFX
+                        "Invalid action table, unknown instruction type: %d\n",
+                                           entry->instruction);
+                                return -EINVAL;
+                        }
+                        run = ctx->ins_table[entry->instruction].run;
+                        rc = run(ctx, entry);
+                        if (rc < 0)
+                                return rc;
+                        else if (rc != APEI_EXEC_SET_IP)
+                                ctx->ip++;
+                }
+                ip++;
+                if (ctx->ip < ip)
+                        goto rewind;
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(apei_exec_run);
+
+typedef int (*apei_exec_entry_func_t)(struct apei_exec_context *ctx,
+                                      struct acpi_whea_header *entry,
+                                      void *data);
+
+static int apei_exec_for_each_entry(struct apei_exec_context *ctx,
+                                    apei_exec_entry_func_t func,
+                                    void *data,
+                                    int *end)
+{
+        u8 ins;
+        int i, rc;
+        struct acpi_whea_header *entry;
+        struct apei_exec_ins_type *ins_table = ctx->ins_table;
+
+        for (i = 0; i < ctx->entries; i++) {
+                entry = ctx->action_table + i;
+                ins = entry->instruction;
+                if (end)
+                        *end = i;
+                if (ins >= ctx->instructions || !ins_table[ins].run) {
+                        pr_warning(FW_WARN APEI_PFX
+                        "Invalid action table, unknown instruction type: %d\n",
+                                   ins);
+                        return -EINVAL;
+                }
+                rc = func(ctx, entry, data);
+                if (rc)
+                        return rc;
+        }
+
+        return 0;
+}
+
+static int pre_map_gar_callback(struct apei_exec_context *ctx,
+                                struct acpi_whea_header *entry,
+                                void *data)
+{
+        u8 ins = entry->instruction;
+
+        if (ctx->ins_table[ins].flags & APEI_EXEC_INS_ACCESS_REGISTER)
+                return acpi_pre_map_gar(&entry->register_region);
+
+        return 0;
+}
+
+/*
+ * Pre-map all GARs in action table to make it possible to access them
+ * in NMI handler.
+ */
+int apei_exec_pre_map_gars(struct apei_exec_context *ctx)
+{
+        int rc, end;
+
+        rc = apei_exec_for_each_entry(ctx, pre_map_gar_callback,
+                                      NULL, &end);
+        if (rc) {
+                struct apei_exec_context ctx_unmap;
+                memcpy(&ctx_unmap, ctx, sizeof(*ctx));
+                ctx_unmap.entries = end;
+                apei_exec_post_unmap_gars(&ctx_unmap);
+        }
+
+        return rc;
+}
+EXPORT_SYMBOL_GPL(apei_exec_pre_map_gars);
+
+static int post_unmap_gar_callback(struct apei_exec_context *ctx,
+                                   struct acpi_whea_header *entry,
+                                   void *data)
+{
+        u8 ins = entry->instruction;
+
+        if (ctx->ins_table[ins].flags & APEI_EXEC_INS_ACCESS_REGISTER)
+                acpi_post_unmap_gar(&entry->register_region);
+
+        return 0;
+}
+
+/* Post-unmap all GAR in action table. */
+int apei_exec_post_unmap_gars(struct apei_exec_context *ctx)
+{
+        return apei_exec_for_each_entry(ctx, post_unmap_gar_callback,
+                                        NULL, NULL);
+}
+EXPORT_SYMBOL_GPL(apei_exec_post_unmap_gars);
+
+/*
+ * Resource management for GARs in APEI
+ */
+struct apei_res {
+        struct list_head list;
+        unsigned long start;
+        unsigned long end;
+};
+
+/* Collect all resources requested, to avoid conflict */
+struct apei_resources apei_resources_all = {
+        .iomem = LIST_HEAD_INIT(apei_resources_all.iomem),
+        .ioport = LIST_HEAD_INIT(apei_resources_all.ioport),
+};
+
+static int apei_res_add(struct list_head *res_list,
+                        unsigned long start, unsigned long size)
+{
+        struct apei_res *res, *resn, *res_ins = NULL;
+        unsigned long end = start + size;
+
+        if (end <= start)
+                return 0;
+repeat:
+        list_for_each_entry_safe(res, resn, res_list, list) {
+                if (res->start > end || res->end < start)
+                        continue;
+                else if (end <= res->end && start >= res->start) {
+                        kfree(res_ins);
+                        return 0;
+                }
+                list_del(&res->list);
+                res->start = start = min(res->start, start);
+                res->end = end = max(res->end, end);
+                kfree(res_ins);
+                res_ins = res;
+                goto repeat;
+        }
+
+        if (res_ins)
+                list_add(&res_ins->list, res_list);
+        else {
+                res_ins = kmalloc(sizeof(*res), GFP_KERNEL);
+                if (!res_ins)
+                        return -ENOMEM;
+                res_ins->start = start;
+                res_ins->end = end;
+                list_add(&res_ins->list, res_list);
+        }
+
+        return 0;
+}
+
+static int apei_res_sub(struct list_head *res_list1,
+                        struct list_head *res_list2)
+{
+        struct apei_res *res1, *resn1, *res2, *res;
+        res1 = list_entry(res_list1->next, struct apei_res, list);
+        resn1 = list_entry(res1->list.next, struct apei_res, list);
+        while (&res1->list != res_list1) {
+                list_for_each_entry(res2, res_list2, list) {
+                        if (res1->start >= res2->end ||
+                            res1->end <= res2->start)
+                                continue;
+                        else if (res1->end <= res2->end &&
+                                 res1->start >= res2->start) {
+                                list_del(&res1->list);
+                                kfree(res1);
+                                break;
+                        } else if (res1->end > res2->end &&
+                                   res1->start < res2->start) {
+                                res = kmalloc(sizeof(*res), GFP_KERNEL);
+                                if (!res)
+                                        return -ENOMEM;
+                                res->start = res2->end;
+                                res->end = res1->end;
+                                res1->end = res2->start;
+                                list_add(&res->list, &res1->list);
+                                resn1 = res;
+                        } else {
+                                if (res1->start < res2->start)
+                                        res1->end = res2->start;
+                                else
+                                        res1->start = res2->end;
+                        }
+                }
+                res1 = resn1;
+                resn1 = list_entry(resn1->list.next, struct apei_res, list);
+        }
+
+        return 0;
+}
+
+static void apei_res_clean(struct list_head *res_list)
+{
+        struct apei_res *res, *resn;
+
+        list_for_each_entry_safe(res, resn, res_list, list) {
+                list_del(&res->list);
+                kfree(res);
+        }
+}
+
+void apei_resources_fini(struct apei_resources *resources)
+{
+        apei_res_clean(&resources->iomem);
+        apei_res_clean(&resources->ioport);
+}
+EXPORT_SYMBOL_GPL(apei_resources_fini);
+
+static int apei_resources_merge(struct apei_resources *resources1,
+                                struct apei_resources *resources2)
+{
+        int rc;
+        struct apei_res *res;
+
+        list_for_each_entry(res, &resources2->iomem, list) {
+                rc = apei_res_add(&resources1->iomem, res->start,
+                                  res->end - res->start);
+                if (rc)
+                        return rc;
+        }
+        list_for_each_entry(res, &resources2->ioport, list) {
+                rc = apei_res_add(&resources1->ioport, res->start,
+                                  res->end - res->start);
+                if (rc)
+                        return rc;
+        }
+
+        return 0;
+}
+
+/*
+ * EINJ has two groups of GARs (EINJ table entry and trigger table
+ * entry), so common resources are subtracted from the trigger table
+ * resources before the second requesting.
+ */
+int apei_resources_sub(struct apei_resources *resources1,
+                       struct apei_resources *resources2)
+{
+        int rc;
+
+        rc = apei_res_sub(&resources1->iomem, &resources2->iomem);
+        if (rc)
+                return rc;
+        return apei_res_sub(&resources1->ioport, &resources2->ioport);
+}
+EXPORT_SYMBOL_GPL(apei_resources_sub);
+
+/*
+ * IO memory/port rersource management mechanism is used to check
+ * whether memory/port area used by GARs conflicts with normal memory
+ * or IO memory/port of devices.
+ */
+int apei_resources_request(struct apei_resources *resources,
+                           const char *desc)
+{
+        struct apei_res *res, *res_bak;
+        struct resource *r;
+
+        apei_resources_sub(resources, &apei_resources_all);
+
+        list_for_each_entry(res, &resources->iomem, list) {
+                r = request_mem_region(res->start, res->end - res->start,
+                                       desc);
+                if (!r) {
+                        pr_err(APEI_PFX
+                "Can not request iomem region <%016llx-%016llx> for GARs.\n",
+                               (unsigned long long)res->start,
+                               (unsigned long long)res->end);
+                        res_bak = res;
+                        goto err_unmap_iomem;
+                }
+        }
+
+        list_for_each_entry(res, &resources->ioport, list) {
+                r = request_region(res->start, res->end - res->start, desc);
+                if (!r) {
+                        pr_err(APEI_PFX
+                "Can not request ioport region <%016llx-%016llx> for GARs.\n",
+                               (unsigned long long)res->start,
+                               (unsigned long long)res->end);
+                        res_bak = res;
+                        goto err_unmap_ioport;
+                }
+        }
+
+        apei_resources_merge(&apei_resources_all, resources);
+
+        return 0;
+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);
+        }
+        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);
+        }
+        return -EINVAL;
+}
+EXPORT_SYMBOL_GPL(apei_resources_request);
+
+void apei_resources_release(struct apei_resources *resources)
+{
+        struct apei_res *res;
+
+        list_for_each_entry(res, &resources->iomem, list)
+                release_mem_region(res->start, res->end - res->start);
+        list_for_each_entry(res, &resources->ioport, list)
+                release_region(res->start, res->end - res->start);
+
+        apei_resources_sub(&apei_resources_all, resources);
+}
+EXPORT_SYMBOL_GPL(apei_resources_release);
+
+static int apei_check_gar(struct acpi_generic_address *reg, u64 *paddr)
+{
+        u32 width, space_id;
+
+        width = reg->bit_width;
+        space_id = reg->space_id;
+        /* Handle possible alignment issues */
+        memcpy(paddr, &reg->address, sizeof(*paddr));
+        if (!*paddr) {
+                pr_warning(FW_BUG APEI_PFX
+                           "Invalid physical address in GAR [0x%llx/%u/%u]\n",
+                           *paddr, width, space_id);
+                return -EINVAL;
+        }
+
+        if ((width != 8) && (width != 16) && (width != 32) && (width != 64)) {
+                pr_warning(FW_BUG APEI_PFX
+                           "Invalid bit width in GAR [0x%llx/%u/%u]\n",
+                           *paddr, width, space_id);
+                return -EINVAL;
+        }
+
+        if (space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY &&
+            space_id != ACPI_ADR_SPACE_SYSTEM_IO) {
+                pr_warning(FW_BUG APEI_PFX
+                           "Invalid address space type in GAR [0x%llx/%u/%u]\n",
+                           *paddr, width, space_id);
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int collect_res_callback(struct apei_exec_context *ctx,
+                                struct acpi_whea_header *entry,
+                                void *data)
+{
+        struct apei_resources *resources = data;
+        struct acpi_generic_address *reg = &entry->register_region;
+        u8 ins = entry->instruction;
+        u64 paddr;
+        int rc;
+
+        if (!(ctx->ins_table[ins].flags & APEI_EXEC_INS_ACCESS_REGISTER))
+                return 0;
+
+        rc = apei_check_gar(reg, &paddr);
+        if (rc)
+                return rc;
+
+        switch (reg->space_id) {
+        case ACPI_ADR_SPACE_SYSTEM_MEMORY:
+                return apei_res_add(&resources->iomem, paddr,
+                                    reg->bit_width / 8);
+        case ACPI_ADR_SPACE_SYSTEM_IO:
+                return apei_res_add(&resources->ioport, paddr,
+                                    reg->bit_width / 8);
+        default:
+                return -EINVAL;
+        }
+}
+
+/*
+ * Same register may be used by multiple instructions in GARs, so
+ * resources are collected before requesting.
+ */
+int apei_exec_collect_resources(struct apei_exec_context *ctx,
+                                struct apei_resources *resources)
+{
+        return apei_exec_for_each_entry(ctx, collect_res_callback,
+                                        resources, NULL);
+}
+EXPORT_SYMBOL_GPL(apei_exec_collect_resources);
+
+struct dentry *apei_get_debugfs_dir(void)
+{
+        static struct dentry *dapei;
+
+        if (!dapei)
+                dapei = debugfs_create_dir("apei", NULL);
+
+        return dapei;
+}
+EXPORT_SYMBOL_GPL(apei_get_debugfs_dir);
diff --git a/drivers/acpi/apei/apei-internal.h b/drivers/acpi/apei/apei-internal.h
new file mode 100644
index 000000000000..18df1e940276
--- /dev/null
+++ b/drivers/acpi/apei/apei-internal.h
@@ -0,0 +1,114 @@
+/*
+ * apei-internal.h - ACPI Platform Error Interface internal
+ * definations.
+ */
+
+#ifndef APEI_INTERNAL_H
+#define APEI_INTERNAL_H
+
+#include <linux/cper.h>
+
+struct apei_exec_context;
+
+typedef int (*apei_exec_ins_func_t)(struct apei_exec_context *ctx,
+                                    struct acpi_whea_header *entry);
+
+#define APEI_EXEC_INS_ACCESS_REGISTER   0x0001
+
+struct apei_exec_ins_type {
+        u32 flags;
+        apei_exec_ins_func_t run;
+};
+
+struct apei_exec_context {
+        u32 ip;
+        u64 value;
+        u64 var1;
+        u64 var2;
+        u64 src_base;
+        u64 dst_base;
+        struct apei_exec_ins_type *ins_table;
+        u32 instructions;
+        struct acpi_whea_header *action_table;
+        u32 entries;
+};
+
+void apei_exec_ctx_init(struct apei_exec_context *ctx,
+                        struct apei_exec_ins_type *ins_table,
+                        u32 instructions,
+                        struct acpi_whea_header *action_table,
+                        u32 entries);
+
+static inline void apei_exec_ctx_set_input(struct apei_exec_context *ctx,
+                                           u64 input)
+{
+        ctx->value = input;
+}
+
+static inline u64 apei_exec_ctx_get_output(struct apei_exec_context *ctx)
+{
+        return ctx->value;
+}
+
+int apei_exec_run(struct apei_exec_context *ctx, u8 action);
+
+/* Common instruction implementation */
+
+/* IP has been set in instruction function */
+#define APEI_EXEC_SET_IP        1
+
+int __apei_exec_read_register(struct acpi_whea_header *entry, u64 *val);
+int __apei_exec_write_register(struct acpi_whea_header *entry, u64 val);
+int apei_exec_read_register(struct apei_exec_context *ctx,
+                            struct acpi_whea_header *entry);
+int apei_exec_read_register_value(struct apei_exec_context *ctx,
+                                  struct acpi_whea_header *entry);
+int apei_exec_write_register(struct apei_exec_context *ctx,
+                             struct acpi_whea_header *entry);
+int apei_exec_write_register_value(struct apei_exec_context *ctx,
+                                   struct acpi_whea_header *entry);
+int apei_exec_noop(struct apei_exec_context *ctx,
+                   struct acpi_whea_header *entry);
+int apei_exec_pre_map_gars(struct apei_exec_context *ctx);
+int apei_exec_post_unmap_gars(struct apei_exec_context *ctx);
+
+struct apei_resources {
+        struct list_head iomem;
+        struct list_head ioport;
+};
+
+static inline void apei_resources_init(struct apei_resources *resources)
+{
+        INIT_LIST_HEAD(&resources->iomem);
+        INIT_LIST_HEAD(&resources->ioport);
+}
+
+void apei_resources_fini(struct apei_resources *resources);
+int apei_resources_sub(struct apei_resources *resources1,
+                       struct apei_resources *resources2);
+int apei_resources_request(struct apei_resources *resources,
+                           const char *desc);
+void apei_resources_release(struct apei_resources *resources);
+int apei_exec_collect_resources(struct apei_exec_context *ctx,
+                                struct apei_resources *resources);
+
+struct dentry;
+struct dentry *apei_get_debugfs_dir(void);
+
+#define apei_estatus_for_each_section(estatus, section)                 \
+        for (section = (struct acpi_hest_generic_data *)(estatus + 1);  \
+             (void *)section - (void *)estatus < estatus->data_length;  \
+             section = (void *)(section+1) + section->error_data_length)
+
+static inline u32 apei_estatus_len(struct acpi_hest_generic_status *estatus)
+{
+        if (estatus->raw_data_length)
+                return estatus->raw_data_offset + \
+                        estatus->raw_data_length;
+        else
+                return sizeof(*estatus) + estatus->data_length;
+}
+
+int apei_estatus_check_header(const struct acpi_hest_generic_status *estatus);
+int apei_estatus_check(const struct acpi_hest_generic_status *estatus);
+#endif
diff --git a/drivers/acpi/apei/cper.c b/drivers/acpi/apei/cper.c
new file mode 100644
index 000000000000..f4cf2fc4c8c1
--- /dev/null
+++ b/drivers/acpi/apei/cper.c
@@ -0,0 +1,84 @@
+/*
+ * UEFI Common Platform Error Record (CPER) support
+ *
+ * Copyright (C) 2010, Intel Corp.
+ *      Author: Huang Ying <ying.huang@intel.com>
+ *
+ * CPER is the format used to describe platform hardware error by
+ * various APEI tables, such as ERST, BERT and HEST etc.
+ *
+ * For more information about CPER, please refer to Appendix N of UEFI
+ * Specification version 2.3.
+ *
+ * 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/time.h>
+#include <linux/cper.h>
+#include <linux/acpi.h>
+
+/*
+ * CPER record ID need to be unique even after reboot, because record
+ * ID is used as index for ERST storage, while CPER records from
+ * multiple boot may co-exist in ERST.
+ */
+u64 cper_next_record_id(void)
+{
+        static atomic64_t seq;
+
+        if (!atomic64_read(&seq))
+                atomic64_set(&seq, ((u64)get_seconds()) << 32);
+
+        return atomic64_inc_return(&seq);
+}
+EXPORT_SYMBOL_GPL(cper_next_record_id);
+
+int apei_estatus_check_header(const struct acpi_hest_generic_status *estatus)
+{
+        if (estatus->data_length &&
+            estatus->data_length < sizeof(struct acpi_hest_generic_data))
+                return -EINVAL;
+        if (estatus->raw_data_length &&
+            estatus->raw_data_offset < sizeof(*estatus) + estatus->data_length)
+                return -EINVAL;
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(apei_estatus_check_header);
+
+int apei_estatus_check(const struct acpi_hest_generic_status *estatus)
+{
+        struct acpi_hest_generic_data *gdata;
+        unsigned int data_len, gedata_len;
+        int rc;
+
+        rc = apei_estatus_check_header(estatus);
+        if (rc)
+                return rc;
+        data_len = estatus->data_length;
+        gdata = (struct acpi_hest_generic_data *)(estatus + 1);
+        while (data_len > sizeof(*gdata)) {
+                gedata_len = gdata->error_data_length;
+                if (gedata_len > data_len - sizeof(*gdata))
+                        return -EINVAL;
+                data_len -= gedata_len + sizeof(*gdata);
+        }
+        if (data_len)
+                return -EINVAL;
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(apei_estatus_check);
diff --git a/drivers/acpi/apei/einj.c b/drivers/acpi/apei/einj.c
new file mode 100644
index 000000000000..465c885938ee
--- /dev/null
+++ b/drivers/acpi/apei/einj.c
@@ -0,0 +1,548 @@
+/*
+ * APEI Error INJection support
+ *
+ * EINJ provides a hardware error injection mechanism, this is useful
+ * for debugging and testing of other APEI and RAS features.
+ *
+ * For more information about EINJ, please refer to ACPI Specification
+ * version 4.0, section 17.5.
+ *
+ * Copyright 2009-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/init.h>
+#include <linux/io.h>
+#include <linux/debugfs.h>
+#include <linux/seq_file.h>
+#include <linux/nmi.h>
+#include <linux/delay.h>
+#include <acpi/acpi.h>
+
+#include "apei-internal.h"
+
+#define EINJ_PFX "EINJ: "
+
+#define SPIN_UNIT               100                     /* 100ns */
+/* Firmware should respond within 1 miliseconds */
+#define FIRMWARE_TIMEOUT        (1 * NSEC_PER_MSEC)
+
+/*
+ * Some BIOSes allow parameters to the SET_ERROR_TYPE entries in the
+ * EINJ table through an unpublished extension. Use with caution as
+ * most will ignore the parameter and make their own choice of address
+ * for error injection.
+ */
+struct einj_parameter {
+        u64 type;
+        u64 reserved1;
+        u64 reserved2;
+        u64 param1;
+        u64 param2;
+};
+
+#define EINJ_OP_BUSY                    0x1
+#define EINJ_STATUS_SUCCESS             0x0
+#define EINJ_STATUS_FAIL                0x1
+#define EINJ_STATUS_INVAL               0x2
+
+#define EINJ_TAB_ENTRY(tab)                                             \
+        ((struct acpi_whea_header *)((char *)(tab) +                    \
+                                    sizeof(struct acpi_table_einj)))
+
+static struct acpi_table_einj *einj_tab;
+
+static struct apei_resources einj_resources;
+
+static struct apei_exec_ins_type einj_ins_type[] = {
+        [ACPI_EINJ_READ_REGISTER] = {
+                .flags = APEI_EXEC_INS_ACCESS_REGISTER,
+                .run   = apei_exec_read_register,
+        },
+        [ACPI_EINJ_READ_REGISTER_VALUE] = {
+                .flags = APEI_EXEC_INS_ACCESS_REGISTER,
+                .run   = apei_exec_read_register_value,
+        },
+        [ACPI_EINJ_WRITE_REGISTER] = {
+                .flags = APEI_EXEC_INS_ACCESS_REGISTER,
+                .run   = apei_exec_write_register,
+        },
+        [ACPI_EINJ_WRITE_REGISTER_VALUE] = {
+                .flags = APEI_EXEC_INS_ACCESS_REGISTER,
+                .run   = apei_exec_write_register_value,
+        },
+        [ACPI_EINJ_NOOP] = {
+                .flags = 0,
+                .run   = apei_exec_noop,
+        },
+};
+
+/*
+ * Prevent EINJ interpreter to run simultaneously, because the
+ * corresponding firmware implementation may not work properly when
+ * invoked simultaneously.
+ */
+static DEFINE_MUTEX(einj_mutex);
+
+static struct einj_parameter *einj_param;
+
+static void einj_exec_ctx_init(struct apei_exec_context *ctx)
+{
+        apei_exec_ctx_init(ctx, einj_ins_type, ARRAY_SIZE(einj_ins_type),
+                           EINJ_TAB_ENTRY(einj_tab), einj_tab->entries);
+}
+
+static int __einj_get_available_error_type(u32 *type)
+{
+        struct apei_exec_context ctx;
+        int rc;
+
+        einj_exec_ctx_init(&ctx);
+        rc = apei_exec_run(&ctx, ACPI_EINJ_GET_ERROR_TYPE);
+        if (rc)
+                return rc;
+        *type = apei_exec_ctx_get_output(&ctx);
+
+        return 0;
+}
+
+/* Get error injection capabilities of the platform */
+static int einj_get_available_error_type(u32 *type)
+{
+        int rc;
+
+        mutex_lock(&einj_mutex);
+        rc = __einj_get_available_error_type(type);
+        mutex_unlock(&einj_mutex);
+
+        return rc;
+}
+
+static int einj_timedout(u64 *t)
+{
+        if ((s64)*t < SPIN_UNIT) {
+                pr_warning(FW_WARN EINJ_PFX
+                           "Firmware does not respond in time\n");
+                return 1;
+        }
+        *t -= SPIN_UNIT;
+        ndelay(SPIN_UNIT);
+        touch_nmi_watchdog();
+        return 0;
+}
+
+static u64 einj_get_parameter_address(void)
+{
+        int i;
+        u64 paddr = 0;
+        struct acpi_whea_header *entry;
+
+        entry = EINJ_TAB_ENTRY(einj_tab);
+        for (i = 0; i < einj_tab->entries; i++) {
+                if (entry->action == ACPI_EINJ_SET_ERROR_TYPE &&
+                    entry->instruction == ACPI_EINJ_WRITE_REGISTER &&
+                    entry->register_region.space_id ==
+                    ACPI_ADR_SPACE_SYSTEM_MEMORY)
+                        memcpy(&paddr, &entry->register_region.address,
+                               sizeof(paddr));
+                entry++;
+        }
+
+        return paddr;
+}
+
+/* do sanity check to trigger table */
+static int einj_check_trigger_header(struct acpi_einj_trigger *trigger_tab)
+{
+        if (trigger_tab->header_size != sizeof(struct acpi_einj_trigger))
+                return -EINVAL;
+        if (trigger_tab->table_size > PAGE_SIZE ||
+            trigger_tab->table_size <= trigger_tab->header_size)
+                return -EINVAL;
+        if (trigger_tab->entry_count !=
+            (trigger_tab->table_size - trigger_tab->header_size) /
+            sizeof(struct acpi_einj_entry))
+                return -EINVAL;
+
+        return 0;
+}
+
+/* Execute instructions in trigger error action table */
+static int __einj_error_trigger(u64 trigger_paddr)
+{
+        struct acpi_einj_trigger *trigger_tab = NULL;
+        struct apei_exec_context trigger_ctx;
+        struct apei_resources trigger_resources;
+        struct acpi_whea_header *trigger_entry;
+        struct resource *r;
+        u32 table_size;
+        int rc = -EIO;
+
+        r = request_mem_region(trigger_paddr, sizeof(*trigger_tab),
+                               "APEI EINJ Trigger Table");
+        if (!r) {
+                pr_err(EINJ_PFX
+        "Can not request iomem region <%016llx-%016llx> for Trigger table.\n",
+                       (unsigned long long)trigger_paddr,
+                       (unsigned long long)trigger_paddr+sizeof(*trigger_tab));
+                goto out;
+        }
+        trigger_tab = ioremap_cache(trigger_paddr, sizeof(*trigger_tab));
+        if (!trigger_tab) {
+                pr_err(EINJ_PFX "Failed to map trigger table!\n");
+                goto out_rel_header;
+        }
+        rc = einj_check_trigger_header(trigger_tab);
+        if (rc) {
+                pr_warning(FW_BUG EINJ_PFX
+                           "The trigger error action table is invalid\n");
+                goto out_rel_header;
+        }
+        rc = -EIO;
+        table_size = trigger_tab->table_size;
+        r = request_mem_region(trigger_paddr + sizeof(*trigger_tab),
+                               table_size - sizeof(*trigger_tab),
+                               "APEI EINJ Trigger Table");
+        if (!r) {
+                pr_err(EINJ_PFX
+"Can not request iomem region <%016llx-%016llx> for Trigger Table Entry.\n",
+                       (unsigned long long)trigger_paddr+sizeof(*trigger_tab),
+                       (unsigned long long)trigger_paddr + table_size);
+                goto out_rel_header;
+        }
+        iounmap(trigger_tab);
+        trigger_tab = ioremap_cache(trigger_paddr, table_size);
+        if (!trigger_tab) {
+                pr_err(EINJ_PFX "Failed to map trigger table!\n");
+                goto out_rel_entry;
+        }
+        trigger_entry = (struct acpi_whea_header *)
+                ((char *)trigger_tab + sizeof(struct acpi_einj_trigger));
+        apei_resources_init(&trigger_resources);
+        apei_exec_ctx_init(&trigger_ctx, einj_ins_type,
+                           ARRAY_SIZE(einj_ins_type),
+                           trigger_entry, trigger_tab->entry_count);
+        rc = apei_exec_collect_resources(&trigger_ctx, &trigger_resources);
+        if (rc)
+                goto out_fini;
+        rc = apei_resources_sub(&trigger_resources, &einj_resources);
+        if (rc)
+                goto out_fini;
+        rc = apei_resources_request(&trigger_resources, "APEI EINJ Trigger");
+        if (rc)
+                goto out_fini;
+        rc = apei_exec_pre_map_gars(&trigger_ctx);
+        if (rc)
+                goto out_release;
+
+        rc = apei_exec_run(&trigger_ctx, ACPI_EINJ_TRIGGER_ERROR);
+
+        apei_exec_post_unmap_gars(&trigger_ctx);
+out_release:
+        apei_resources_release(&trigger_resources);
+out_fini:
+        apei_resources_fini(&trigger_resources);
+out_rel_entry:
+        release_mem_region(trigger_paddr + sizeof(*trigger_tab),
+                           table_size - sizeof(*trigger_tab));
+out_rel_header:
+        release_mem_region(trigger_paddr, sizeof(*trigger_tab));
+out:
+        if (trigger_tab)
+                iounmap(trigger_tab);
+
+        return rc;
+}
+
+static int __einj_error_inject(u32 type, u64 param1, u64 param2)
+{
+        struct apei_exec_context ctx;
+        u64 val, trigger_paddr, timeout = FIRMWARE_TIMEOUT;
+        int rc;
+
+        einj_exec_ctx_init(&ctx);
+
+        rc = apei_exec_run(&ctx, ACPI_EINJ_BEGIN_OPERATION);
+        if (rc)
+                return rc;
+        apei_exec_ctx_set_input(&ctx, type);
+        rc = apei_exec_run(&ctx, ACPI_EINJ_SET_ERROR_TYPE);
+        if (rc)
+                return rc;
+        if (einj_param) {
+                writeq(param1, &einj_param->param1);
+                writeq(param2, &einj_param->param2);
+        }
+        rc = apei_exec_run(&ctx, ACPI_EINJ_EXECUTE_OPERATION);
+        if (rc)
+                return rc;
+        for (;;) {
+                rc = apei_exec_run(&ctx, ACPI_EINJ_CHECK_BUSY_STATUS);
+                if (rc)
+                        return rc;
+                val = apei_exec_ctx_get_output(&ctx);
+                if (!(val & EINJ_OP_BUSY))
+                        break;
+                if (einj_timedout(&timeout))
+                        return -EIO;
+        }
+        rc = apei_exec_run(&ctx, ACPI_EINJ_GET_COMMAND_STATUS);
+        if (rc)
+                return rc;
+        val = apei_exec_ctx_get_output(&ctx);
+        if (val != EINJ_STATUS_SUCCESS)
+                return -EBUSY;
+
+        rc = apei_exec_run(&ctx, ACPI_EINJ_GET_TRIGGER_TABLE);
+        if (rc)
+                return rc;
+        trigger_paddr = apei_exec_ctx_get_output(&ctx);
+        rc = __einj_error_trigger(trigger_paddr);
+        if (rc)
+                return rc;
+        rc = apei_exec_run(&ctx, ACPI_EINJ_END_OPERATION);
+
+        return rc;
+}
+
+/* Inject the specified hardware error */
+static int einj_error_inject(u32 type, u64 param1, u64 param2)
+{
+        int rc;
+
+        mutex_lock(&einj_mutex);
+        rc = __einj_error_inject(type, param1, param2);
+        mutex_unlock(&einj_mutex);
+
+        return rc;
+}
+
+static u32 error_type;
+static u64 error_param1;
+static u64 error_param2;
+static struct dentry *einj_debug_dir;
+
+static int available_error_type_show(struct seq_file *m, void *v)
+{
+        int rc;
+        u32 available_error_type = 0;
+
+        rc = einj_get_available_error_type(&available_error_type);
+        if (rc)
+                return rc;
+        if (available_error_type & 0x0001)
+                seq_printf(m, "0x00000001\tProcessor Correctable\n");
+        if (available_error_type & 0x0002)
+                seq_printf(m, "0x00000002\tProcessor Uncorrectable non-fatal\n");
+        if (available_error_type & 0x0004)
+                seq_printf(m, "0x00000004\tProcessor Uncorrectable fatal\n");
+        if (available_error_type & 0x0008)
+                seq_printf(m, "0x00000008\tMemory Correctable\n");
+        if (available_error_type & 0x0010)
+                seq_printf(m, "0x00000010\tMemory Uncorrectable non-fatal\n");
+        if (available_error_type & 0x0020)
+                seq_printf(m, "0x00000020\tMemory Uncorrectable fatal\n");
+        if (available_error_type & 0x0040)
+                seq_printf(m, "0x00000040\tPCI Express Correctable\n");
+        if (available_error_type & 0x0080)
+                seq_printf(m, "0x00000080\tPCI Express Uncorrectable non-fatal\n");
+        if (available_error_type & 0x0100)
+                seq_printf(m, "0x00000100\tPCI Express Uncorrectable fatal\n");
+        if (available_error_type & 0x0200)
+                seq_printf(m, "0x00000200\tPlatform Correctable\n");
+        if (available_error_type & 0x0400)
+                seq_printf(m, "0x00000400\tPlatform Uncorrectable non-fatal\n");
+        if (available_error_type & 0x0800)
+                seq_printf(m, "0x00000800\tPlatform Uncorrectable fatal\n");
+
+        return 0;
+}
+
+static int available_error_type_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, available_error_type_show, NULL);
+}
+
+static const struct file_operations available_error_type_fops = {
+        .open           = available_error_type_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
+static int error_type_get(void *data, u64 *val)
+{
+        *val = error_type;
+
+        return 0;
+}
+
+static int error_type_set(void *data, u64 val)
+{
+        int rc;
+        u32 available_error_type = 0;
+
+        /* Only one error type can be specified */
+        if (val & (val - 1))
+                return -EINVAL;
+        rc = einj_get_available_error_type(&available_error_type);
+        if (rc)
+                return rc;
+        if (!(val & available_error_type))
+                return -EINVAL;
+        error_type = val;
+
+        return 0;
+}
+
+DEFINE_SIMPLE_ATTRIBUTE(error_type_fops, error_type_get,
+                        error_type_set, "0x%llx\n");
+
+static int error_inject_set(void *data, u64 val)
+{
+        if (!error_type)
+                return -EINVAL;
+
+        return einj_error_inject(error_type, error_param1, error_param2);
+}
+
+DEFINE_SIMPLE_ATTRIBUTE(error_inject_fops, NULL,
+                        error_inject_set, "%llu\n");
+
+static int einj_check_table(struct acpi_table_einj *einj_tab)
+{
+        if (einj_tab->header_length != sizeof(struct acpi_table_einj))
+                return -EINVAL;
+        if (einj_tab->header.length < sizeof(struct acpi_table_einj))
+                return -EINVAL;
+        if (einj_tab->entries !=
+            (einj_tab->header.length - sizeof(struct acpi_table_einj)) /
+            sizeof(struct acpi_einj_entry))
+                return -EINVAL;
+
+        return 0;
+}
+
+static int __init einj_init(void)
+{
+        int rc;
+        u64 param_paddr;
+        acpi_status status;
+        struct dentry *fentry;
+        struct apei_exec_context ctx;
+
+        if (acpi_disabled)
+                return -ENODEV;
+
+        status = acpi_get_table(ACPI_SIG_EINJ, 0,
+                                (struct acpi_table_header **)&einj_tab);
+        if (status == AE_NOT_FOUND) {
+                pr_info(EINJ_PFX "Table is not found!\n");
+                return -ENODEV;
+        } else if (ACPI_FAILURE(status)) {
+                const char *msg = acpi_format_exception(status);
+                pr_err(EINJ_PFX "Failed to get table, %s\n", msg);
+                return -EINVAL;
+        }
+
+        rc = einj_check_table(einj_tab);
+        if (rc) {
+                pr_warning(FW_BUG EINJ_PFX "EINJ table is invalid\n");
+                return -EINVAL;
+        }
+
+        rc = -ENOMEM;
+        einj_debug_dir = debugfs_create_dir("einj", apei_get_debugfs_dir());
+        if (!einj_debug_dir)
+                goto err_cleanup;
+        fentry = debugfs_create_file("available_error_type", S_IRUSR,
+                                     einj_debug_dir, NULL,
+                                     &available_error_type_fops);
+        if (!fentry)
+                goto err_cleanup;
+        fentry = debugfs_create_file("error_type", S_IRUSR | S_IWUSR,
+                                     einj_debug_dir, NULL, &error_type_fops);
+        if (!fentry)
+                goto err_cleanup;
+        fentry = debugfs_create_x64("param1", S_IRUSR | S_IWUSR,
+                                    einj_debug_dir, &error_param1);
+        if (!fentry)
+                goto err_cleanup;
+        fentry = debugfs_create_x64("param2", S_IRUSR | S_IWUSR,
+                                    einj_debug_dir, &error_param2);
+        if (!fentry)
+                goto err_cleanup;
+        fentry = debugfs_create_file("error_inject", S_IWUSR,
+                                     einj_debug_dir, NULL, &error_inject_fops);
+        if (!fentry)
+                goto err_cleanup;
+
+        apei_resources_init(&einj_resources);
+        einj_exec_ctx_init(&ctx);
+        rc = apei_exec_collect_resources(&ctx, &einj_resources);
+        if (rc)
+                goto err_fini;
+        rc = apei_resources_request(&einj_resources, "APEI EINJ");
+        if (rc)
+                goto err_fini;
+        rc = apei_exec_pre_map_gars(&ctx);
+        if (rc)
+                goto err_release;
+        param_paddr = einj_get_parameter_address();
+        if (param_paddr) {
+                einj_param = ioremap(param_paddr, sizeof(*einj_param));
+                rc = -ENOMEM;
+                if (!einj_param)
+                        goto err_unmap;
+        }
+
+        pr_info(EINJ_PFX "Error INJection is initialized.\n");
+
+        return 0;
+
+err_unmap:
+        apei_exec_post_unmap_gars(&ctx);
+err_release:
+        apei_resources_release(&einj_resources);
+err_fini:
+        apei_resources_fini(&einj_resources);
+err_cleanup:
+        debugfs_remove_recursive(einj_debug_dir);
+
+        return rc;
+}
+
+static void __exit einj_exit(void)
+{
+        struct apei_exec_context ctx;
+
+        if (einj_param)
+                iounmap(einj_param);
+        einj_exec_ctx_init(&ctx);
+        apei_exec_post_unmap_gars(&ctx);
+        apei_resources_release(&einj_resources);
+        apei_resources_fini(&einj_resources);
+        debugfs_remove_recursive(einj_debug_dir);
+}
+
+module_init(einj_init);
+module_exit(einj_exit);
+
+MODULE_AUTHOR("Huang Ying");
+MODULE_DESCRIPTION("APEI Error INJection support");
+MODULE_LICENSE("GPL");
diff --git a/drivers/acpi/apei/erst.c b/drivers/acpi/apei/erst.c
new file mode 100644
index 000000000000..2ebc39115507
--- /dev/null
+++ b/drivers/acpi/apei/erst.c
@@ -0,0 +1,855 @@
+/*
+ * APEI Error Record Serialization Table support
+ *
+ * ERST is a way provided by APEI to save and retrieve hardware error
+ * infomation to and from a persistent store.
+ *
+ * For more information about ERST, please refer to ACPI Specification
+ * version 4.0, section 17.4.
+ *
+ * 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/init.h>
+#include <linux/delay.h>
+#include <linux/io.h>
+#include <linux/acpi.h>
+#include <linux/uaccess.h>
+#include <linux/cper.h>
+#include <linux/nmi.h>
+#include <acpi/apei.h>
+
+#include "apei-internal.h"
+
+#define ERST_PFX "ERST: "
+
+/* ERST command status */
+#define ERST_STATUS_SUCCESS                     0x0
+#define ERST_STATUS_NOT_ENOUGH_SPACE            0x1
+#define ERST_STATUS_HARDWARE_NOT_AVAILABLE      0x2
+#define ERST_STATUS_FAILED                      0x3
+#define ERST_STATUS_RECORD_STORE_EMPTY          0x4
+#define ERST_STATUS_RECORD_NOT_FOUND            0x5
+
+#define ERST_TAB_ENTRY(tab)                                             \
+        ((struct acpi_whea_header *)((char *)(tab) +                    \
+                                     sizeof(struct acpi_table_erst)))
+
+#define SPIN_UNIT               100                     /* 100ns */
+/* Firmware should respond within 1 miliseconds */
+#define FIRMWARE_TIMEOUT        (1 * NSEC_PER_MSEC)
+#define FIRMWARE_MAX_STALL      50                      /* 50us */
+
+int erst_disable;
+EXPORT_SYMBOL_GPL(erst_disable);
+
+static struct acpi_table_erst *erst_tab;
+
+/* ERST Error Log Address Range atrributes */
+#define ERST_RANGE_RESERVED     0x0001
+#define ERST_RANGE_NVRAM        0x0002
+#define ERST_RANGE_SLOW         0x0004
+
+/*
+ * ERST Error Log Address Range, used as buffer for reading/writing
+ * error records.
+ */
+static struct erst_erange {
+        u64 base;
+        u64 size;
+        void __iomem *vaddr;
+        u32 attr;
+} erst_erange;
+
+/*
+ * Prevent ERST interpreter to run simultaneously, because the
+ * corresponding firmware implementation may not work properly when
+ * invoked simultaneously.
+ *
+ * It is used to provide exclusive accessing for ERST Error Log
+ * Address Range too.
+ */
+static DEFINE_SPINLOCK(erst_lock);
+
+static inline int erst_errno(int command_status)
+{
+        switch (command_status) {
+        case ERST_STATUS_SUCCESS:
+                return 0;
+        case ERST_STATUS_HARDWARE_NOT_AVAILABLE:
+                return -ENODEV;
+        case ERST_STATUS_NOT_ENOUGH_SPACE:
+                return -ENOSPC;
+        case ERST_STATUS_RECORD_STORE_EMPTY:
+        case ERST_STATUS_RECORD_NOT_FOUND:
+                return -ENOENT;
+        default:
+                return -EINVAL;
+        }
+}
+
+static int erst_timedout(u64 *t, u64 spin_unit)
+{
+        if ((s64)*t < spin_unit) {
+                pr_warning(FW_WARN ERST_PFX
+                           "Firmware does not respond in time\n");
+                return 1;
+        }
+        *t -= spin_unit;
+        ndelay(spin_unit);
+        touch_nmi_watchdog();
+        return 0;
+}
+
+static int erst_exec_load_var1(struct apei_exec_context *ctx,
+                               struct acpi_whea_header *entry)
+{
+        return __apei_exec_read_register(entry, &ctx->var1);
+}
+
+static int erst_exec_load_var2(struct apei_exec_context *ctx,
+                               struct acpi_whea_header *entry)
+{
+        return __apei_exec_read_register(entry, &ctx->var2);
+}
+
+static int erst_exec_store_var1(struct apei_exec_context *ctx,
+                                struct acpi_whea_header *entry)
+{
+        return __apei_exec_write_register(entry, ctx->var1);
+}
+
+static int erst_exec_add(struct apei_exec_context *ctx,
+                         struct acpi_whea_header *entry)
+{
+        ctx->var1 += ctx->var2;
+        return 0;
+}
+
+static int erst_exec_subtract(struct apei_exec_context *ctx,
+                              struct acpi_whea_header *entry)
+{
+        ctx->var1 -= ctx->var2;
+        return 0;
+}
+
+static int erst_exec_add_value(struct apei_exec_context *ctx,
+                               struct acpi_whea_header *entry)
+{
+        int rc;
+        u64 val;
+
+        rc = __apei_exec_read_register(entry, &val);
+        if (rc)
+                return rc;
+        val += ctx->value;
+        rc = __apei_exec_write_register(entry, val);
+        return rc;
+}
+
+static int erst_exec_subtract_value(struct apei_exec_context *ctx,
+                                    struct acpi_whea_header *entry)
+{
+        int rc;
+        u64 val;
+
+        rc = __apei_exec_read_register(entry, &val);
+        if (rc)
+                return rc;
+        val -= ctx->value;
+        rc = __apei_exec_write_register(entry, val);
+        return rc;
+}
+
+static int erst_exec_stall(struct apei_exec_context *ctx,
+                           struct acpi_whea_header *entry)
+{
+        u64 stall_time;
+
+        if (ctx->value > FIRMWARE_MAX_STALL) {
+                if (!in_nmi())
+                        pr_warning(FW_WARN ERST_PFX
+                        "Too long stall time for stall instruction: %llx.\n",
+                                   ctx->value);
+                stall_time = FIRMWARE_MAX_STALL;
+        } else
+                stall_time = ctx->value;
+        udelay(stall_time);
+        return 0;
+}
+
+static int erst_exec_stall_while_true(struct apei_exec_context *ctx,
+                                      struct acpi_whea_header *entry)
+{
+        int rc;
+        u64 val;
+        u64 timeout = FIRMWARE_TIMEOUT;
+        u64 stall_time;
+
+        if (ctx->var1 > FIRMWARE_MAX_STALL) {
+                if (!in_nmi())
+                        pr_warning(FW_WARN ERST_PFX
+                "Too long stall time for stall while true instruction: %llx.\n",
+                                   ctx->var1);
+                stall_time = FIRMWARE_MAX_STALL;
+        } else
+                stall_time = ctx->var1;
+
+        for (;;) {
+                rc = __apei_exec_read_register(entry, &val);
+                if (rc)
+                        return rc;
+                if (val != ctx->value)
+                        break;
+                if (erst_timedout(&timeout, stall_time * NSEC_PER_USEC))
+                        return -EIO;
+        }
+        return 0;
+}
+
+static int erst_exec_skip_next_instruction_if_true(
+        struct apei_exec_context *ctx,
+        struct acpi_whea_header *entry)
+{
+        int rc;
+        u64 val;
+
+        rc = __apei_exec_read_register(entry, &val);
+        if (rc)
+                return rc;
+        if (val == ctx->value) {
+                ctx->ip += 2;
+                return APEI_EXEC_SET_IP;
+        }
+
+        return 0;
+}
+
+static int erst_exec_goto(struct apei_exec_context *ctx,
+                          struct acpi_whea_header *entry)
+{
+        ctx->ip = ctx->value;
+        return APEI_EXEC_SET_IP;
+}
+
+static int erst_exec_set_src_address_base(struct apei_exec_context *ctx,
+                                          struct acpi_whea_header *entry)
+{
+        return __apei_exec_read_register(entry, &ctx->src_base);
+}
+
+static int erst_exec_set_dst_address_base(struct apei_exec_context *ctx,
+                                          struct acpi_whea_header *entry)
+{
+        return __apei_exec_read_register(entry, &ctx->dst_base);
+}
+
+static int erst_exec_move_data(struct apei_exec_context *ctx,
+                               struct acpi_whea_header *entry)
+{
+        int rc;
+        u64 offset;
+
+        rc = __apei_exec_read_register(entry, &offset);
+        if (rc)
+                return rc;
+        memmove((void *)ctx->dst_base + offset,
+                (void *)ctx->src_base + offset,
+                ctx->var2);
+
+        return 0;
+}
+
+static struct apei_exec_ins_type erst_ins_type[] = {
+        [ACPI_ERST_READ_REGISTER] = {
+                .flags = APEI_EXEC_INS_ACCESS_REGISTER,
+                .run = apei_exec_read_register,
+        },
+        [ACPI_ERST_READ_REGISTER_VALUE] = {
+                .flags = APEI_EXEC_INS_ACCESS_REGISTER,
+                .run = apei_exec_read_register_value,
+        },
+        [ACPI_ERST_WRITE_REGISTER] = {
+                .flags = APEI_EXEC_INS_ACCESS_REGISTER,
+                .run = apei_exec_write_register,
+        },
+        [ACPI_ERST_WRITE_REGISTER_VALUE] = {
+                .flags = APEI_EXEC_INS_ACCESS_REGISTER,
+                .run = apei_exec_write_register_value,
+        },
+        [ACPI_ERST_NOOP] = {
+                .flags = 0,
+                .run = apei_exec_noop,
+        },
+        [ACPI_ERST_LOAD_VAR1] = {
+                .flags = APEI_EXEC_INS_ACCESS_REGISTER,
+                .run = erst_exec_load_var1,
+        },
+        [ACPI_ERST_LOAD_VAR2] = {
+                .flags = APEI_EXEC_INS_ACCESS_REGISTER,
+                .run = erst_exec_load_var2,
+        },
+        [ACPI_ERST_STORE_VAR1] = {
+                .flags = APEI_EXEC_INS_ACCESS_REGISTER,
+                .run = erst_exec_store_var1,
+        },
+        [ACPI_ERST_ADD] = {
+                .flags = 0,
+                .run = erst_exec_add,
+        },
+        [ACPI_ERST_SUBTRACT] = {
+                .flags = 0,
+                .run = erst_exec_subtract,
+        },
+        [ACPI_ERST_ADD_VALUE] = {
+                .flags = APEI_EXEC_INS_ACCESS_REGISTER,
+                .run = erst_exec_add_value,
+        },
+        [ACPI_ERST_SUBTRACT_VALUE] = {
+                .flags = APEI_EXEC_INS_ACCESS_REGISTER,
+                .run = erst_exec_subtract_value,
+        },
+        [ACPI_ERST_STALL] = {
+                .flags = 0,
+                .run = erst_exec_stall,
+        },
+        [ACPI_ERST_STALL_WHILE_TRUE] = {
+                .flags = APEI_EXEC_INS_ACCESS_REGISTER,
+                .run = erst_exec_stall_while_true,
+        },
+        [ACPI_ERST_SKIP_NEXT_IF_TRUE] = {
+                .flags = APEI_EXEC_INS_ACCESS_REGISTER,
+                .run = erst_exec_skip_next_instruction_if_true,
+        },
+        [ACPI_ERST_GOTO] = {
+                .flags = 0,
+                .run = erst_exec_goto,
+        },
+        [ACPI_ERST_SET_SRC_ADDRESS_BASE] = {
+                .flags = APEI_EXEC_INS_ACCESS_REGISTER,
+                .run = erst_exec_set_src_address_base,
+        },
+        [ACPI_ERST_SET_DST_ADDRESS_BASE] = {
+                .flags = APEI_EXEC_INS_ACCESS_REGISTER,
+                .run = erst_exec_set_dst_address_base,
+        },
+        [ACPI_ERST_MOVE_DATA] = {
+                .flags = APEI_EXEC_INS_ACCESS_REGISTER,
+                .run = erst_exec_move_data,
+        },
+};
+
+static inline void erst_exec_ctx_init(struct apei_exec_context *ctx)
+{
+        apei_exec_ctx_init(ctx, erst_ins_type, ARRAY_SIZE(erst_ins_type),
+                           ERST_TAB_ENTRY(erst_tab), erst_tab->entries);
+}
+
+static int erst_get_erange(struct erst_erange *range)
+{
+        struct apei_exec_context ctx;
+        int rc;
+
+        erst_exec_ctx_init(&ctx);
+        rc = apei_exec_run(&ctx, ACPI_ERST_GET_ERROR_RANGE);
+        if (rc)
+                return rc;
+        range->base = apei_exec_ctx_get_output(&ctx);
+        rc = apei_exec_run(&ctx, ACPI_ERST_GET_ERROR_LENGTH);
+        if (rc)
+                return rc;
+        range->size = apei_exec_ctx_get_output(&ctx);
+        rc = apei_exec_run(&ctx, ACPI_ERST_GET_ERROR_ATTRIBUTES);
+        if (rc)
+                return rc;
+        range->attr = apei_exec_ctx_get_output(&ctx);
+
+        return 0;
+}
+
+static ssize_t __erst_get_record_count(void)
+{
+        struct apei_exec_context ctx;
+        int rc;
+
+        erst_exec_ctx_init(&ctx);
+        rc = apei_exec_run(&ctx, ACPI_ERST_GET_RECORD_COUNT);
+        if (rc)
+                return rc;
+        return apei_exec_ctx_get_output(&ctx);
+}
+
+ssize_t erst_get_record_count(void)
+{
+        ssize_t count;
+        unsigned long flags;
+
+        if (erst_disable)
+                return -ENODEV;
+
+        spin_lock_irqsave(&erst_lock, flags);
+        count = __erst_get_record_count();
+        spin_unlock_irqrestore(&erst_lock, flags);
+
+        return count;
+}
+EXPORT_SYMBOL_GPL(erst_get_record_count);
+
+static int __erst_get_next_record_id(u64 *record_id)
+{
+        struct apei_exec_context ctx;
+        int rc;
+
+        erst_exec_ctx_init(&ctx);
+        rc = apei_exec_run(&ctx, ACPI_ERST_GET_RECORD_ID);
+        if (rc)
+                return rc;
+        *record_id = apei_exec_ctx_get_output(&ctx);
+
+        return 0;
+}
+
+/*
+ * Get the record ID of an existing error record on the persistent
+ * storage. If there is no error record on the persistent storage, the
+ * returned record_id is APEI_ERST_INVALID_RECORD_ID.
+ */
+int erst_get_next_record_id(u64 *record_id)
+{
+        int rc;
+        unsigned long flags;
+
+        if (erst_disable)
+                return -ENODEV;
+
+        spin_lock_irqsave(&erst_lock, flags);
+        rc = __erst_get_next_record_id(record_id);
+        spin_unlock_irqrestore(&erst_lock, flags);
+
+        return rc;
+}
+EXPORT_SYMBOL_GPL(erst_get_next_record_id);
+
+static int __erst_write_to_storage(u64 offset)
+{
+        struct apei_exec_context ctx;
+        u64 timeout = FIRMWARE_TIMEOUT;
+        u64 val;
+        int rc;
+
+        erst_exec_ctx_init(&ctx);
+        rc = apei_exec_run(&ctx, ACPI_ERST_BEGIN_WRITE);
+        if (rc)
+                return rc;
+        apei_exec_ctx_set_input(&ctx, offset);
+        rc = apei_exec_run(&ctx, ACPI_ERST_SET_RECORD_OFFSET);
+        if (rc)
+                return rc;
+        rc = apei_exec_run(&ctx, ACPI_ERST_EXECUTE_OPERATION);
+        if (rc)
+                return rc;
+        for (;;) {
+                rc = apei_exec_run(&ctx, ACPI_ERST_CHECK_BUSY_STATUS);
+                if (rc)
+                        return rc;
+                val = apei_exec_ctx_get_output(&ctx);
+                if (!val)
+                        break;
+                if (erst_timedout(&timeout, SPIN_UNIT))
+                        return -EIO;
+        }
+        rc = apei_exec_run(&ctx, ACPI_ERST_GET_COMMAND_STATUS);
+        if (rc)
+                return rc;
+        val = apei_exec_ctx_get_output(&ctx);
+        rc = apei_exec_run(&ctx, ACPI_ERST_END);
+        if (rc)
+                return rc;
+
+        return erst_errno(val);
+}
+
+static int __erst_read_from_storage(u64 record_id, u64 offset)
+{
+        struct apei_exec_context ctx;
+        u64 timeout = FIRMWARE_TIMEOUT;
+        u64 val;
+        int rc;
+
+        erst_exec_ctx_init(&ctx);
+        rc = apei_exec_run(&ctx, ACPI_ERST_BEGIN_READ);
+        if (rc)
+                return rc;
+        apei_exec_ctx_set_input(&ctx, offset);
+        rc = apei_exec_run(&ctx, ACPI_ERST_SET_RECORD_OFFSET);
+        if (rc)
+                return rc;
+        apei_exec_ctx_set_input(&ctx, record_id);
+        rc = apei_exec_run(&ctx, ACPI_ERST_SET_RECORD_ID);
+        if (rc)
+                return rc;
+        rc = apei_exec_run(&ctx, ACPI_ERST_EXECUTE_OPERATION);
+        if (rc)
+                return rc;
+        for (;;) {
+                rc = apei_exec_run(&ctx, ACPI_ERST_CHECK_BUSY_STATUS);
+                if (rc)
+                        return rc;
+                val = apei_exec_ctx_get_output(&ctx);
+                if (!val)
+                        break;
+                if (erst_timedout(&timeout, SPIN_UNIT))
+                        return -EIO;
+        };
+        rc = apei_exec_run(&ctx, ACPI_ERST_GET_COMMAND_STATUS);
+        if (rc)
+                return rc;
+        val = apei_exec_ctx_get_output(&ctx);
+        rc = apei_exec_run(&ctx, ACPI_ERST_END);
+        if (rc)
+                return rc;
+
+        return erst_errno(val);
+}
+
+static int __erst_clear_from_storage(u64 record_id)
+{
+        struct apei_exec_context ctx;
+        u64 timeout = FIRMWARE_TIMEOUT;
+        u64 val;
+        int rc;
+
+        erst_exec_ctx_init(&ctx);
+        rc = apei_exec_run(&ctx, ACPI_ERST_BEGIN_CLEAR);
+        if (rc)
+                return rc;
+        apei_exec_ctx_set_input(&ctx, record_id);
+        rc = apei_exec_run(&ctx, ACPI_ERST_SET_RECORD_ID);
+        if (rc)
+                return rc;
+        rc = apei_exec_run(&ctx, ACPI_ERST_EXECUTE_OPERATION);
+        if (rc)
+                return rc;
+        for (;;) {
+                rc = apei_exec_run(&ctx, ACPI_ERST_CHECK_BUSY_STATUS);
+                if (rc)
+                        return rc;
+                val = apei_exec_ctx_get_output(&ctx);
+                if (!val)
+                        break;
+                if (erst_timedout(&timeout, SPIN_UNIT))
+                        return -EIO;
+        }
+        rc = apei_exec_run(&ctx, ACPI_ERST_GET_COMMAND_STATUS);
+        if (rc)
+                return rc;
+        val = apei_exec_ctx_get_output(&ctx);
+        rc = apei_exec_run(&ctx, ACPI_ERST_END);
+        if (rc)
+                return rc;
+
+        return erst_errno(val);
+}
+
+/* NVRAM ERST Error Log Address Range is not supported yet */
+static void pr_unimpl_nvram(void)
+{
+        if (printk_ratelimit())
+                pr_warning(ERST_PFX
+                "NVRAM ERST Log Address Range is not implemented yet\n");
+}
+
+static int __erst_write_to_nvram(const struct cper_record_header *record)
+{
+        /* do not print message, because printk is not safe for NMI */
+        return -ENOSYS;
+}
+
+static int __erst_read_to_erange_from_nvram(u64 record_id, u64 *offset)
+{
+        pr_unimpl_nvram();
+        return -ENOSYS;
+}
+
+static int __erst_clear_from_nvram(u64 record_id)
+{
+        pr_unimpl_nvram();
+        return -ENOSYS;
+}
+
+int erst_write(const struct cper_record_header *record)
+{
+        int rc;
+        unsigned long flags;
+        struct cper_record_header *rcd_erange;
+
+        if (erst_disable)
+                return -ENODEV;
+
+        if (memcmp(record->signature, CPER_SIG_RECORD, CPER_SIG_SIZE))
+                return -EINVAL;
+
+        if (erst_erange.attr & ERST_RANGE_NVRAM) {
+                if (!spin_trylock_irqsave(&erst_lock, flags))
+                        return -EBUSY;
+                rc = __erst_write_to_nvram(record);
+                spin_unlock_irqrestore(&erst_lock, flags);
+                return rc;
+        }
+
+        if (record->record_length > erst_erange.size)
+                return -EINVAL;
+
+        if (!spin_trylock_irqsave(&erst_lock, flags))
+                return -EBUSY;
+        memcpy(erst_erange.vaddr, record, record->record_length);
+        rcd_erange = erst_erange.vaddr;
+        /* signature for serialization system */
+        memcpy(&rcd_erange->persistence_information, "ER", 2);
+
+        rc = __erst_write_to_storage(0);
+        spin_unlock_irqrestore(&erst_lock, flags);
+
+        return rc;
+}
+EXPORT_SYMBOL_GPL(erst_write);
+
+static int __erst_read_to_erange(u64 record_id, u64 *offset)
+{
+        int rc;
+
+        if (erst_erange.attr & ERST_RANGE_NVRAM)
+                return __erst_read_to_erange_from_nvram(
+                        record_id, offset);
+
+        rc = __erst_read_from_storage(record_id, 0);
+        if (rc)
+                return rc;
+        *offset = 0;
+
+        return 0;
+}
+
+static ssize_t __erst_read(u64 record_id, struct cper_record_header *record,
+                           size_t buflen)
+{
+        int rc;
+        u64 offset, len = 0;
+        struct cper_record_header *rcd_tmp;
+
+        rc = __erst_read_to_erange(record_id, &offset);
+        if (rc)
+                return rc;
+        rcd_tmp = erst_erange.vaddr + offset;
+        len = rcd_tmp->record_length;
+        if (len <= buflen)
+                memcpy(record, rcd_tmp, len);
+
+        return len;
+}
+
+/*
+ * If return value > buflen, the buffer size is not big enough,
+ * else if return value < 0, something goes wrong,
+ * else everything is OK, and return value is record length
+ */
+ssize_t erst_read(u64 record_id, struct cper_record_header *record,
+                  size_t buflen)
+{
+        ssize_t len;
+        unsigned long flags;
+
+        if (erst_disable)
+                return -ENODEV;
+
+        spin_lock_irqsave(&erst_lock, flags);
+        len = __erst_read(record_id, record, buflen);
+        spin_unlock_irqrestore(&erst_lock, flags);
+        return len;
+}
+EXPORT_SYMBOL_GPL(erst_read);
+
+/*
+ * If return value > buflen, the buffer size is not big enough,
+ * else if return value = 0, there is no more record to read,
+ * else if return value < 0, something goes wrong,
+ * else everything is OK, and return value is record length
+ */
+ssize_t erst_read_next(struct cper_record_header *record, size_t buflen)
+{
+        int rc;
+        ssize_t len;
+        unsigned long flags;
+        u64 record_id;
+
+        if (erst_disable)
+                return -ENODEV;
+
+        spin_lock_irqsave(&erst_lock, flags);
+        rc = __erst_get_next_record_id(&record_id);
+        if (rc) {
+                spin_unlock_irqrestore(&erst_lock, flags);
+                return rc;
+        }
+        /* no more record */
+        if (record_id == APEI_ERST_INVALID_RECORD_ID) {
+                spin_unlock_irqrestore(&erst_lock, flags);
+                return 0;
+        }
+
+        len = __erst_read(record_id, record, buflen);
+        spin_unlock_irqrestore(&erst_lock, flags);
+
+        return len;
+}
+EXPORT_SYMBOL_GPL(erst_read_next);
+
+int erst_clear(u64 record_id)
+{
+        int rc;
+        unsigned long flags;
+
+        if (erst_disable)
+                return -ENODEV;
+
+        spin_lock_irqsave(&erst_lock, flags);
+        if (erst_erange.attr & ERST_RANGE_NVRAM)
+                rc = __erst_clear_from_nvram(record_id);
+        else
+                rc = __erst_clear_from_storage(record_id);
+        spin_unlock_irqrestore(&erst_lock, flags);
+
+        return rc;
+}
+EXPORT_SYMBOL_GPL(erst_clear);
+
+static int __init setup_erst_disable(char *str)
+{
+        erst_disable = 1;
+        return 0;
+}
+
+__setup("erst_disable", setup_erst_disable);
+
+static int erst_check_table(struct acpi_table_erst *erst_tab)
+{
+        if (erst_tab->header_length != sizeof(struct acpi_table_erst))
+                return -EINVAL;
+        if (erst_tab->header.length < sizeof(struct acpi_table_erst))
+                return -EINVAL;
+        if (erst_tab->entries !=
+            (erst_tab->header.length - sizeof(struct acpi_table_erst)) /
+            sizeof(struct acpi_erst_entry))
+                return -EINVAL;
+
+        return 0;
+}
+
+static int __init erst_init(void)
+{
+        int rc = 0;
+        acpi_status status;
+        struct apei_exec_context ctx;
+        struct apei_resources erst_resources;
+        struct resource *r;
+
+        if (acpi_disabled)
+                goto err;
+
+        if (erst_disable) {
+                pr_info(ERST_PFX
+        "Error Record Serialization Table (ERST) support is disabled.\n");
+                goto err;
+        }
+
+        status = acpi_get_table(ACPI_SIG_ERST, 0,
+                                (struct acpi_table_header **)&erst_tab);
+        if (status == AE_NOT_FOUND) {
+                pr_err(ERST_PFX "Table is not found!\n");
+                goto err;
+        } else if (ACPI_FAILURE(status)) {
+                const char *msg = acpi_format_exception(status);
+                pr_err(ERST_PFX "Failed to get table, %s\n", msg);
+                rc = -EINVAL;
+                goto err;
+        }
+
+        rc = erst_check_table(erst_tab);
+        if (rc) {
+                pr_err(FW_BUG ERST_PFX "ERST table is invalid\n");
+                goto err;
+        }
+
+        apei_resources_init(&erst_resources);
+        erst_exec_ctx_init(&ctx);
+        rc = apei_exec_collect_resources(&ctx, &erst_resources);
+        if (rc)
+                goto err_fini;
+        rc = apei_resources_request(&erst_resources, "APEI ERST");
+        if (rc)
+                goto err_fini;
+        rc = apei_exec_pre_map_gars(&ctx);
+        if (rc)
+                goto err_release;
+        rc = erst_get_erange(&erst_erange);
+        if (rc) {
+                if (rc == -ENODEV)
+                        pr_info(ERST_PFX
+        "The corresponding hardware device or firmware implementation "
+        "is not available.\n");
+                else
+                        pr_err(ERST_PFX
+                               "Failed to get Error Log Address Range.\n");
+                goto err_unmap_reg;
+        }
+
+        r = request_mem_region(erst_erange.base, erst_erange.size, "APEI ERST");
+        if (!r) {
+                pr_err(ERST_PFX
+                "Can not request iomem region <0x%16llx-0x%16llx> for ERST.\n",
+                (unsigned long long)erst_erange.base,
+                (unsigned long long)erst_erange.base + erst_erange.size);
+                rc = -EIO;
+                goto err_unmap_reg;
+        }
+        rc = -ENOMEM;
+        erst_erange.vaddr = ioremap_cache(erst_erange.base,
+                                          erst_erange.size);
+        if (!erst_erange.vaddr)
+                goto err_release_erange;
+
+        pr_info(ERST_PFX
+        "Error Record Serialization Table (ERST) support is initialized.\n");
+
+        return 0;
+
+err_release_erange:
+        release_mem_region(erst_erange.base, erst_erange.size);
+err_unmap_reg:
+        apei_exec_post_unmap_gars(&ctx);
+err_release:
+        apei_resources_release(&erst_resources);
+err_fini:
+        apei_resources_fini(&erst_resources);
+err:
+        erst_disable = 1;
+        return rc;
+}
+
+device_initcall(erst_init);
diff --git a/drivers/acpi/apei/ghes.c b/drivers/acpi/apei/ghes.c
new file mode 100644
index 000000000000..fd0cc016a099
--- /dev/null
+++ b/drivers/acpi/apei/ghes.c
@@ -0,0 +1,427 @@
+/*
+ * APEI Generic Hardware Error Source support
+ *
+ * Generic Hardware Error Source provides a way to report platform
+ * hardware errors (such as that from chipset). It works in so called
+ * "Firmware First" mode, that is, hardware errors are reported to
+ * firmware firstly, then reported to Linux by firmware. This way,
+ * some non-standard hardware error registers or non-standard hardware
+ * link can be checked by firmware to produce more hardware error
+ * information for Linux.
+ *
+ * For more information about Generic Hardware Error Source, please
+ * refer to ACPI Specification version 4.0, section 17.3.2.6
+ *
+ * Now, only SCI notification type and memory errors are
+ * supported. More notification type and hardware error type will be
+ * added later.
+ *
+ * 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/init.h>
+#include <linux/acpi.h>
+#include <linux/io.h>
+#include <linux/interrupt.h>
+#include <linux/cper.h>
+#include <linux/kdebug.h>
+#include <acpi/apei.h>
+#include <acpi/atomicio.h>
+#include <acpi/hed.h>
+#include <asm/mce.h>
+
+#include "apei-internal.h"
+
+#define GHES_PFX        "GHES: "
+
+#define GHES_ESTATUS_MAX_SIZE           65536
+
+/*
+ * One struct ghes is created for each generic hardware error
+ * source.
+ *
+ * It provides the context for APEI hardware error timer/IRQ/SCI/NMI
+ * handler. Handler for one generic hardware error source is only
+ * triggered after the previous one is done. So handler can uses
+ * struct ghes without locking.
+ *
+ * estatus: memory buffer for error status block, allocated during
+ * HEST parsing.
+ */
+#define GHES_TO_CLEAR           0x0001
+
+struct ghes {
+        struct acpi_hest_generic *generic;
+        struct acpi_hest_generic_status *estatus;
+        struct list_head list;
+        u64 buffer_paddr;
+        unsigned long flags;
+};
+
+/*
+ * Error source lists, one list for each notification method. The
+ * members in lists are struct ghes.
+ *
+ * The list members are only added in HEST parsing and deleted during
+ * module_exit, that is, single-threaded. So no lock is needed for
+ * that.
+ *
+ * But the mutual exclusion is needed between members adding/deleting
+ * and timer/IRQ/SCI/NMI handler, which may traverse the list. RCU is
+ * used for that.
+ */
+static LIST_HEAD(ghes_sci);
+
+static struct ghes *ghes_new(struct acpi_hest_generic *generic)
+{
+        struct ghes *ghes;
+        unsigned int error_block_length;
+        int rc;
+
+        ghes = kzalloc(sizeof(*ghes), GFP_KERNEL);
+        if (!ghes)
+                return ERR_PTR(-ENOMEM);
+        ghes->generic = generic;
+        INIT_LIST_HEAD(&ghes->list);
+        rc = acpi_pre_map_gar(&generic->error_status_address);
+        if (rc)
+                goto err_free;
+        error_block_length = generic->error_block_length;
+        if (error_block_length > GHES_ESTATUS_MAX_SIZE) {
+                pr_warning(FW_WARN GHES_PFX
+                           "Error status block length is too long: %u for "
+                           "generic hardware error source: %d.\n",
+                           error_block_length, generic->header.source_id);
+                error_block_length = GHES_ESTATUS_MAX_SIZE;
+        }
+        ghes->estatus = kmalloc(error_block_length, GFP_KERNEL);
+        if (!ghes->estatus) {
+                rc = -ENOMEM;
+                goto err_unmap;
+        }
+
+        return ghes;
+
+err_unmap:
+        acpi_post_unmap_gar(&generic->error_status_address);
+err_free:
+        kfree(ghes);
+        return ERR_PTR(rc);
+}
+
+static void ghes_fini(struct ghes *ghes)
+{
+        kfree(ghes->estatus);
+        acpi_post_unmap_gar(&ghes->generic->error_status_address);
+}
+
+enum {
+        GHES_SER_NO = 0x0,
+        GHES_SER_CORRECTED = 0x1,
+        GHES_SER_RECOVERABLE = 0x2,
+        GHES_SER_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;
+        default:
+                /* Unkown, go panic */
+                return GHES_SER_PANIC;
+        }
+}
+
+/* SCI handler run in work queue, so ioremap can be used here */
+static int ghes_copy_tofrom_phys(void *buffer, u64 paddr, u32 len,
+                                 int from_phys)
+{
+        void *vaddr;
+
+        vaddr = ioremap_cache(paddr, len);
+        if (!vaddr)
+                return -ENOMEM;
+        if (from_phys)
+                memcpy(buffer, vaddr, len);
+        else
+                memcpy(vaddr, buffer, len);
+        iounmap(vaddr);
+
+        return 0;
+}
+
+static int ghes_read_estatus(struct ghes *ghes, int silent)
+{
+        struct acpi_hest_generic *g = ghes->generic;
+        u64 buf_paddr;
+        u32 len;
+        int rc;
+
+        rc = acpi_atomic_read(&buf_paddr, &g->error_status_address);
+        if (rc) {
+                if (!silent && printk_ratelimit())
+                        pr_warning(FW_WARN GHES_PFX
+"Failed to read error status block address for hardware error source: %d.\n",
+                                   g->header.source_id);
+                return -EIO;
+        }
+        if (!buf_paddr)
+                return -ENOENT;
+
+        rc = ghes_copy_tofrom_phys(ghes->estatus, buf_paddr,
+                                   sizeof(*ghes->estatus), 1);
+        if (rc)
+                return rc;
+        if (!ghes->estatus->block_status)
+                return -ENOENT;
+
+        ghes->buffer_paddr = buf_paddr;
+        ghes->flags |= GHES_TO_CLEAR;
+
+        rc = -EIO;
+        len = apei_estatus_len(ghes->estatus);
+        if (len < sizeof(*ghes->estatus))
+                goto err_read_block;
+        if (len > ghes->generic->error_block_length)
+                goto err_read_block;
+        if (apei_estatus_check_header(ghes->estatus))
+                goto err_read_block;
+        rc = ghes_copy_tofrom_phys(ghes->estatus + 1,
+                                   buf_paddr + sizeof(*ghes->estatus),
+                                   len - sizeof(*ghes->estatus), 1);
+        if (rc)
+                return rc;
+        if (apei_estatus_check(ghes->estatus))
+                goto err_read_block;
+        rc = 0;
+
+err_read_block:
+        if (rc && !silent)
+                pr_warning(FW_WARN GHES_PFX
+                           "Failed to read error status block!\n");
+        return rc;
+}
+
+static void ghes_clear_estatus(struct ghes *ghes)
+{
+        ghes->estatus->block_status = 0;
+        if (!(ghes->flags & GHES_TO_CLEAR))
+                return;
+        ghes_copy_tofrom_phys(ghes->estatus, ghes->buffer_paddr,
+                              sizeof(ghes->estatus->block_status), 0);
+        ghes->flags &= ~GHES_TO_CLEAR;
+}
+
+static void ghes_do_proc(struct ghes *ghes)
+{
+        int ser, processed = 0;
+        struct acpi_hest_generic_data *gdata;
+
+        ser = 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,
+                                (struct cper_sec_mem_err *)(gdata+1));
+                        processed = 1;
+                }
+#endif
+        }
+
+        if (!processed && printk_ratelimit())
+                pr_warning(GHES_PFX
+                "Unknown error record from generic hardware error source: %d\n",
+                           ghes->generic->header.source_id);
+}
+
+static int ghes_proc(struct ghes *ghes)
+{
+        int rc;
+
+        rc = ghes_read_estatus(ghes, 0);
+        if (rc)
+                goto out;
+        ghes_do_proc(ghes);
+
+out:
+        ghes_clear_estatus(ghes);
+        return 0;
+}
+
+static int ghes_notify_sci(struct notifier_block *this,
+                                  unsigned long event, void *data)
+{
+        struct ghes *ghes;
+        int ret = NOTIFY_DONE;
+
+        rcu_read_lock();
+        list_for_each_entry_rcu(ghes, &ghes_sci, list) {
+                if (!ghes_proc(ghes))
+                        ret = NOTIFY_OK;
+        }
+        rcu_read_unlock();
+
+        return ret;
+}
+
+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)
+{
+        struct acpi_hest_generic *generic;
+        struct ghes *ghes = NULL;
+        int rc = 0;
+
+        if (hest_hdr->type != ACPI_HEST_TYPE_GENERIC_ERROR)
+                return 0;
+
+        generic = (struct acpi_hest_generic *)hest_hdr;
+        if (!generic->enabled)
+                return 0;
+
+        if (generic->error_block_length <
+            sizeof(struct acpi_hest_generic_status)) {
+                pr_warning(FW_BUG GHES_PFX
+"Invalid error block length: %u for generic hardware error source: %d\n",
+                           generic->error_block_length,
+                           generic->header.source_id);
+                goto err;
+        }
+        if (generic->records_to_preallocate == 0) {
+                pr_warning(FW_BUG GHES_PFX
+"Invalid records to preallocate: %u for generic hardware error source: %d\n",
+                           generic->records_to_preallocate,
+                           generic->header.source_id);
+                goto err;
+        }
+        ghes = ghes_new(generic);
+        if (IS_ERR(ghes)) {
+                rc = PTR_ERR(ghes);
+                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 (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;
+        }
+
+        return 0;
+err:
+        if (ghes)
+                ghes_fini(ghes);
+        return rc;
+}
+
+static void ghes_cleanup(void)
+{
+        struct ghes *ghes, *nghes;
+
+        if (!list_empty(&ghes_sci))
+                unregister_acpi_hed_notifier(&ghes_notifier_sci);
+
+        synchronize_rcu();
+
+        list_for_each_entry_safe(ghes, nghes, &ghes_sci, list) {
+                list_del(&ghes->list);
+                ghes_fini(ghes);
+                kfree(ghes);
+        }
+}
+
+static int __init ghes_init(void)
+{
+        int rc;
+
+        if (acpi_disabled)
+                return -ENODEV;
+
+        if (hest_disable) {
+                pr_info(GHES_PFX "HEST is not enabled!\n");
+                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;
+}
+
+static void __exit ghes_exit(void)
+{
+        ghes_cleanup();
+}
+
+module_init(ghes_init);
+module_exit(ghes_exit);
+
+MODULE_AUTHOR("Huang Ying");
+MODULE_DESCRIPTION("APEI Generic Hardware Error Source support");
+MODULE_LICENSE("GPL");
diff --git a/drivers/acpi/apei/hest.c b/drivers/acpi/apei/hest.c
new file mode 100644
index 000000000000..e7f40d362cb3
--- /dev/null
+++ b/drivers/acpi/apei/hest.c
@@ -0,0 +1,173 @@
+/*
+ * APEI Hardware Error Souce Table support
+ *
+ * HEST describes error sources in detail; communicates operational
+ * parameters (i.e. severity levels, masking bits, and threshold
+ * values) to Linux as necessary. It also allows the BIOS to report
+ * non-standard error sources to Linux (for example, chipset-specific
+ * error registers).
+ *
+ * For more information about HEST, please refer to ACPI Specification
+ * version 4.0, section 17.3.2.
+ *
+ * Copyright 2009 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/init.h>
+#include <linux/acpi.h>
+#include <linux/kdebug.h>
+#include <linux/highmem.h>
+#include <linux/io.h>
+#include <acpi/apei.h>
+
+#include "apei-internal.h"
+
+#define HEST_PFX "HEST: "
+
+int hest_disable;
+EXPORT_SYMBOL_GPL(hest_disable);
+
+/* HEST table parsing */
+
+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,
+        [ACPI_HEST_TYPE_IA32_NMI] = sizeof(struct acpi_hest_ia_nmi),
+        [ACPI_HEST_TYPE_AER_ROOT_PORT] = sizeof(struct acpi_hest_aer_root),
+        [ACPI_HEST_TYPE_AER_ENDPOINT] = sizeof(struct acpi_hest_aer),
+        [ACPI_HEST_TYPE_AER_BRIDGE] = sizeof(struct acpi_hest_aer_bridge),
+        [ACPI_HEST_TYPE_GENERIC_ERROR] = sizeof(struct acpi_hest_generic),
+};
+
+static int hest_esrc_len(struct acpi_hest_header *hest_hdr)
+{
+        u16 hest_type = hest_hdr->type;
+        int len;
+
+        if (hest_type >= ACPI_HEST_TYPE_RESERVED)
+                return 0;
+
+        len = hest_esrc_len_tab[hest_type];
+
+        if (hest_type == ACPI_HEST_TYPE_IA32_CORRECTED_CHECK) {
+                struct acpi_hest_ia_corrected *cmc;
+                cmc = (struct acpi_hest_ia_corrected *)hest_hdr;
+                len = sizeof(*cmc) + cmc->num_hardware_banks *
+                        sizeof(struct acpi_hest_ia_error_bank);
+        } else if (hest_type == ACPI_HEST_TYPE_IA32_CHECK) {
+                struct acpi_hest_ia_machine_check *mc;
+                mc = (struct acpi_hest_ia_machine_check *)hest_hdr;
+                len = sizeof(*mc) + mc->num_hardware_banks *
+                        sizeof(struct acpi_hest_ia_error_bank);
+        }
+        BUG_ON(len == -1);
+
+        return len;
+};
+
+int apei_hest_parse(apei_hest_func_t func, void *data)
+{
+        struct acpi_hest_header *hest_hdr;
+        int i, rc, len;
+
+        if (hest_disable)
+                return -EINVAL;
+
+        hest_hdr = (struct acpi_hest_header *)(hest_tab + 1);
+        for (i = 0; i < hest_tab->error_source_count; i++) {
+                len = hest_esrc_len(hest_hdr);
+                if (!len) {
+                        pr_warning(FW_WARN HEST_PFX
+                                   "Unknown or unused hardware error source "
+                                   "type: %d for hardware error source: %d.\n",
+                                   hest_hdr->type, hest_hdr->source_id);
+                        return -EINVAL;
+                }
+                if ((void *)hest_hdr + len >
+                    (void *)hest_tab + hest_tab->header.length) {
+                        pr_warning(FW_BUG HEST_PFX
+                "Table contents overflow for hardware error source: %d.\n",
+                                hest_hdr->source_id);
+                        return -EINVAL;
+                }
+
+                rc = func(hest_hdr, data);
+                if (rc)
+                        return rc;
+
+                hest_hdr = (void *)hest_hdr + len;
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(apei_hest_parse);
+
+static int __init setup_hest_disable(char *str)
+{
+        hest_disable = 1;
+        return 0;
+}
+
+__setup("hest_disable", setup_hest_disable);
+
+static int __init hest_init(void)
+{
+        acpi_status status;
+        int rc = -ENODEV;
+
+        if (acpi_disabled)
+                goto err;
+
+        if (hest_disable) {
+                pr_info(HEST_PFX "HEST tabling parsing is disabled.\n");
+                goto err;
+        }
+
+        status = acpi_get_table(ACPI_SIG_HEST, 0,
+                                (struct acpi_table_header **)&hest_tab);
+        if (status == AE_NOT_FOUND) {
+                pr_info(HEST_PFX "Table is not found!\n");
+                goto err;
+        } else if (ACPI_FAILURE(status)) {
+                const char *msg = acpi_format_exception(status);
+                pr_err(HEST_PFX "Failed to get table, %s\n", msg);
+                rc = -EINVAL;
+                goto err;
+        }
+
+        rc = apei_hest_parse(hest_void_parse, NULL);
+        if (rc)
+                goto err;
+
+        pr_info(HEST_PFX "HEST table parsing is initialized.\n");
+
+        return 0;
+err:
+        hest_disable = 1;
+        return rc;
+}
+
+subsys_initcall(hest_init);
diff --git a/drivers/acpi/atomicio.c b/drivers/acpi/atomicio.c
new file mode 100644
index 000000000000..814b19249616
--- /dev/null
+++ b/drivers/acpi/atomicio.c
@@ -0,0 +1,360 @@
+/*
+ * atomicio.c - ACPI IO memory pre-mapping/post-unmapping, then
+ * accessing in atomic context.
+ *
+ * This is used for NMI handler to access IO memory area, because
+ * ioremap/iounmap can not be used in NMI handler. The IO memory area
+ * is pre-mapped in process context and accessed in NMI handler.
+ *
+ * Copyright (C) 2009-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/init.h>
+#include <linux/acpi.h>
+#include <linux/io.h>
+#include <linux/kref.h>
+#include <linux/rculist.h>
+#include <linux/interrupt.h>
+#include <acpi/atomicio.h>
+
+#define ACPI_PFX "ACPI: "
+
+static LIST_HEAD(acpi_iomaps);
+/*
+ * Used for mutual exclusion between writers of acpi_iomaps list, for
+ * synchronization between readers and writer, RCU is used.
+ */
+static DEFINE_SPINLOCK(acpi_iomaps_lock);
+
+struct acpi_iomap {
+        struct list_head list;
+        void __iomem *vaddr;
+        unsigned long size;
+        phys_addr_t paddr;
+        struct kref ref;
+};
+
+/* acpi_iomaps_lock or RCU read lock must be held before calling */
+static struct acpi_iomap *__acpi_find_iomap(phys_addr_t paddr,
+                                            unsigned long size)
+{
+        struct acpi_iomap *map;
+
+        list_for_each_entry_rcu(map, &acpi_iomaps, list) {
+                if (map->paddr + map->size >= paddr + size &&
+                    map->paddr <= paddr)
+                        return map;
+        }
+        return NULL;
+}
+
+/*
+ * Atomic "ioremap" used by NMI handler, if the specified IO memory
+ * area is not pre-mapped, NULL will be returned.
+ *
+ * acpi_iomaps_lock or RCU read lock must be held before calling
+ */
+static void __iomem *__acpi_ioremap_fast(phys_addr_t paddr,
+                                         unsigned long size)
+{
+        struct acpi_iomap *map;
+
+        map = __acpi_find_iomap(paddr, size);
+        if (map)
+                return map->vaddr + (paddr - map->paddr);
+        else
+                return NULL;
+}
+
+/* acpi_iomaps_lock must be held before calling */
+static void __iomem *__acpi_try_ioremap(phys_addr_t paddr,
+                                        unsigned long size)
+{
+        struct acpi_iomap *map;
+
+        map = __acpi_find_iomap(paddr, size);
+        if (map) {
+                kref_get(&map->ref);
+                return map->vaddr + (paddr - map->paddr);
+        } else
+                return NULL;
+}
+
+/*
+ * Used to pre-map the specified IO memory area. First try to find
+ * whether the area is already pre-mapped, if it is, increase the
+ * reference count (in __acpi_try_ioremap) and return; otherwise, do
+ * the real ioremap, and add the mapping into acpi_iomaps list.
+ */
+static void __iomem *acpi_pre_map(phys_addr_t paddr,
+                                  unsigned long size)
+{
+        void __iomem *vaddr;
+        struct acpi_iomap *map;
+        unsigned long pg_sz, flags;
+        phys_addr_t pg_off;
+
+        spin_lock_irqsave(&acpi_iomaps_lock, flags);
+        vaddr = __acpi_try_ioremap(paddr, size);
+        spin_unlock_irqrestore(&acpi_iomaps_lock, flags);
+        if (vaddr)
+                return vaddr;
+
+        pg_off = paddr & PAGE_MASK;
+        pg_sz = ((paddr + size + PAGE_SIZE - 1) & PAGE_MASK) - pg_off;
+        vaddr = ioremap(pg_off, pg_sz);
+        if (!vaddr)
+                return NULL;
+        map = kmalloc(sizeof(*map), GFP_KERNEL);
+        if (!map)
+                goto err_unmap;
+        INIT_LIST_HEAD(&map->list);
+        map->paddr = pg_off;
+        map->size = pg_sz;
+        map->vaddr = vaddr;
+        kref_init(&map->ref);
+
+        spin_lock_irqsave(&acpi_iomaps_lock, flags);
+        vaddr = __acpi_try_ioremap(paddr, size);
+        if (vaddr) {
+                spin_unlock_irqrestore(&acpi_iomaps_lock, flags);
+                iounmap(map->vaddr);
+                kfree(map);
+                return vaddr;
+        }
+        list_add_tail_rcu(&map->list, &acpi_iomaps);
+        spin_unlock_irqrestore(&acpi_iomaps_lock, flags);
+
+        return vaddr + (paddr - pg_off);
+err_unmap:
+        iounmap(vaddr);
+        return NULL;
+}
+
+/* acpi_iomaps_lock must be held before calling */
+static void __acpi_kref_del_iomap(struct kref *ref)
+{
+        struct acpi_iomap *map;
+
+        map = container_of(ref, struct acpi_iomap, ref);
+        list_del_rcu(&map->list);
+}
+
+/*
+ * Used to post-unmap the specified IO memory area. The iounmap is
+ * done only if the reference count goes zero.
+ */
+static void acpi_post_unmap(phys_addr_t paddr, unsigned long size)
+{
+        struct acpi_iomap *map;
+        unsigned long flags;
+        int del;
+
+        spin_lock_irqsave(&acpi_iomaps_lock, flags);
+        map = __acpi_find_iomap(paddr, size);
+        BUG_ON(!map);
+        del = kref_put(&map->ref, __acpi_kref_del_iomap);
+        spin_unlock_irqrestore(&acpi_iomaps_lock, flags);
+
+        if (!del)
+                return;
+
+        synchronize_rcu();
+        iounmap(map->vaddr);
+        kfree(map);
+}
+
+/* In NMI handler, should set silent = 1 */
+static int acpi_check_gar(struct acpi_generic_address *reg,
+                          u64 *paddr, int silent)
+{
+        u32 width, space_id;
+
+        width = reg->bit_width;
+        space_id = reg->space_id;
+        /* Handle possible alignment issues */
+        memcpy(paddr, &reg->address, sizeof(*paddr));
+        if (!*paddr) {
+                if (!silent)
+                        pr_warning(FW_BUG ACPI_PFX
+                        "Invalid physical address in GAR [0x%llx/%u/%u]\n",
+                                   *paddr, width, space_id);
+                return -EINVAL;
+        }
+
+        if ((width != 8) && (width != 16) && (width != 32) && (width != 64)) {
+                if (!silent)
+                        pr_warning(FW_BUG ACPI_PFX
+                                   "Invalid bit width in GAR [0x%llx/%u/%u]\n",
+                                   *paddr, width, space_id);
+                return -EINVAL;
+        }
+
+        if (space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY &&
+            space_id != ACPI_ADR_SPACE_SYSTEM_IO) {
+                if (!silent)
+                        pr_warning(FW_BUG ACPI_PFX
+                        "Invalid address space type in GAR [0x%llx/%u/%u]\n",
+                                   *paddr, width, space_id);
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+/* Pre-map, working on GAR */
+int acpi_pre_map_gar(struct acpi_generic_address *reg)
+{
+        u64 paddr;
+        void __iomem *vaddr;
+        int rc;
+
+        if (reg->space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY)
+                return 0;
+
+        rc = acpi_check_gar(reg, &paddr, 0);
+        if (rc)
+                return rc;
+
+        vaddr = acpi_pre_map(paddr, reg->bit_width / 8);
+        if (!vaddr)
+                return -EIO;
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(acpi_pre_map_gar);
+
+/* Post-unmap, working on GAR */
+int acpi_post_unmap_gar(struct acpi_generic_address *reg)
+{
+        u64 paddr;
+        int rc;
+
+        if (reg->space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY)
+                return 0;
+
+        rc = acpi_check_gar(reg, &paddr, 0);
+        if (rc)
+                return rc;
+
+        acpi_post_unmap(paddr, reg->bit_width / 8);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(acpi_post_unmap_gar);
+
+/*
+ * Can be used in atomic (including NMI) or process context. RCU read
+ * lock can only be released after the IO memory area accessing.
+ */
+static int acpi_atomic_read_mem(u64 paddr, u64 *val, u32 width)
+{
+        void __iomem *addr;
+
+        rcu_read_lock();
+        addr = __acpi_ioremap_fast(paddr, width);
+        switch (width) {
+        case 8:
+                *val = readb(addr);
+                break;
+        case 16:
+                *val = readw(addr);
+                break;
+        case 32:
+                *val = readl(addr);
+                break;
+        case 64:
+                *val = readq(addr);
+                break;
+        default:
+                return -EINVAL;
+        }
+        rcu_read_unlock();
+
+        return 0;
+}
+
+static int acpi_atomic_write_mem(u64 paddr, u64 val, u32 width)
+{
+        void __iomem *addr;
+
+        rcu_read_lock();
+        addr = __acpi_ioremap_fast(paddr, width);
+        switch (width) {
+        case 8:
+                writeb(val, addr);
+                break;
+        case 16:
+                writew(val, addr);
+                break;
+        case 32:
+                writel(val, addr);
+                break;
+        case 64:
+                writeq(val, addr);
+                break;
+        default:
+                return -EINVAL;
+        }
+        rcu_read_unlock();
+
+        return 0;
+}
+
+/* GAR accessing in atomic (including NMI) or process context */
+int acpi_atomic_read(u64 *val, struct acpi_generic_address *reg)
+{
+        u64 paddr;
+        int rc;
+
+        rc = acpi_check_gar(reg, &paddr, 1);
+        if (rc)
+                return rc;
+
+        *val = 0;
+        switch (reg->space_id) {
+        case ACPI_ADR_SPACE_SYSTEM_MEMORY:
+                return acpi_atomic_read_mem(paddr, val, reg->bit_width);
+        case ACPI_ADR_SPACE_SYSTEM_IO:
+                return acpi_os_read_port(paddr, (u32 *)val, reg->bit_width);
+        default:
+                return -EINVAL;
+        }
+}
+EXPORT_SYMBOL_GPL(acpi_atomic_read);
+
+int acpi_atomic_write(u64 val, struct acpi_generic_address *reg)
+{
+        u64 paddr;
+        int rc;
+
+        rc = acpi_check_gar(reg, &paddr, 1);
+        if (rc)
+                return rc;
+
+        switch (reg->space_id) {
+        case ACPI_ADR_SPACE_SYSTEM_MEMORY:
+                return acpi_atomic_write_mem(paddr, val, reg->bit_width);
+        case ACPI_ADR_SPACE_SYSTEM_IO:
+                return acpi_os_write_port(paddr, val, reg->bit_width);
+        default:
+                return -EINVAL;
+        }
+}
+EXPORT_SYMBOL_GPL(acpi_atomic_write);
diff --git a/drivers/acpi/ec.c b/drivers/acpi/ec.c
index f2234db85da0..e61d4f8e62a5 100644
--- a/drivers/acpi/ec.c
+++ b/drivers/acpi/ec.c
@@ -1027,10 +1027,9 @@ int __init acpi_ec_ecdt_probe(void)
                 /* Don't trust ECDT, which comes from ASUSTek */
                 if (!EC_FLAGS_VALIDATE_ECDT)
                         goto install;
-                saved_ec = kmalloc(sizeof(struct acpi_ec), GFP_KERNEL);
+                saved_ec = kmemdup(boot_ec, sizeof(struct acpi_ec), GFP_KERNEL);
                 if (!saved_ec)
                         return -ENOMEM;
-                memcpy(saved_ec, boot_ec, sizeof(struct acpi_ec));
         /* fall through */
         }
 
diff --git a/drivers/acpi/hed.c b/drivers/acpi/hed.c
new file mode 100644
index 000000000000..d0c1967f7597
--- /dev/null
+++ b/drivers/acpi/hed.c
@@ -0,0 +1,112 @@
+/*
+ * ACPI Hardware Error Device (PNP0C33) Driver
+ *
+ * Copyright (C) 2010, Intel Corp.
+ *      Author: Huang Ying <ying.huang@intel.com>
+ *
+ * ACPI Hardware Error Device is used to report some hardware errors
+ * notified via SCI, mainly the corrected errors.
+ *
+ * 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/init.h>
+#include <linux/acpi.h>
+#include <acpi/acpi_bus.h>
+#include <acpi/acpi_drivers.h>
+#include <acpi/hed.h>
+
+static struct acpi_device_id acpi_hed_ids[] = {
+        {"PNP0C33", 0},
+        {"", 0},
+};
+MODULE_DEVICE_TABLE(acpi, acpi_hed_ids);
+
+static acpi_handle hed_handle;
+
+static BLOCKING_NOTIFIER_HEAD(acpi_hed_notify_list);
+
+int register_acpi_hed_notifier(struct notifier_block *nb)
+{
+        return blocking_notifier_chain_register(&acpi_hed_notify_list, nb);
+}
+EXPORT_SYMBOL_GPL(register_acpi_hed_notifier);
+
+void unregister_acpi_hed_notifier(struct notifier_block *nb)
+{
+        blocking_notifier_chain_unregister(&acpi_hed_notify_list, nb);
+}
+EXPORT_SYMBOL_GPL(unregister_acpi_hed_notifier);
+
+/*
+ * SCI to report hardware error is forwarded to the listeners of HED,
+ * it is used by HEST Generic Hardware Error Source with notify type
+ * SCI.
+ */
+static void acpi_hed_notify(struct acpi_device *device, u32 event)
+{
+        blocking_notifier_call_chain(&acpi_hed_notify_list, 0, NULL);
+}
+
+static int __devinit acpi_hed_add(struct acpi_device *device)
+{
+        /* Only one hardware error device */
+        if (hed_handle)
+                return -EINVAL;
+        hed_handle = device->handle;
+        return 0;
+}
+
+static int __devexit acpi_hed_remove(struct acpi_device *device, int type)
+{
+        hed_handle = NULL;
+        return 0;
+}
+
+static struct acpi_driver acpi_hed_driver = {
+        .name = "hardware_error_device",
+        .class = "hardware_error",
+        .ids = acpi_hed_ids,
+        .ops = {
+                .add = acpi_hed_add,
+                .remove = acpi_hed_remove,
+                .notify = acpi_hed_notify,
+        },
+};
+
+static int __init acpi_hed_init(void)
+{
+        if (acpi_disabled)
+                return -ENODEV;
+
+        if (acpi_bus_register_driver(&acpi_hed_driver) < 0)
+                return -ENODEV;
+
+        return 0;
+}
+
+static void __exit acpi_hed_exit(void)
+{
+        acpi_bus_unregister_driver(&acpi_hed_driver);
+}
+
+module_init(acpi_hed_init);
+module_exit(acpi_hed_exit);
+
+ACPI_MODULE_NAME("hed");
+MODULE_AUTHOR("Huang Ying");
+MODULE_DESCRIPTION("ACPI Hardware Error Device Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/acpi/hest.c b/drivers/acpi/hest.c
deleted file mode 100644
index 1c527a192872..000000000000
--- a/drivers/acpi/hest.c
+++ /dev/null
@@ -1,139 +0,0 @@
-#include <linux/acpi.h>
-#include <linux/pci.h>
-
-#define PREFIX "ACPI: "
-
-static inline unsigned long parse_acpi_hest_ia_machine_check(struct acpi_hest_ia_machine_check *p)
-{
-        return sizeof(*p) +
-                (sizeof(struct acpi_hest_ia_error_bank) * p->num_hardware_banks);
-}
-
-static inline unsigned long parse_acpi_hest_ia_corrected(struct acpi_hest_ia_corrected *p)
-{
-        return sizeof(*p) +
-                (sizeof(struct acpi_hest_ia_error_bank) * p->num_hardware_banks);
-}
-
-static inline unsigned long parse_acpi_hest_ia_nmi(struct acpi_hest_ia_nmi *p)
-{
-        return sizeof(*p);
-}
-
-static inline unsigned long parse_acpi_hest_generic(struct acpi_hest_generic *p)
-{
-        return sizeof(*p);
-}
-
-static inline unsigned int hest_match_pci(struct acpi_hest_aer_common *p, struct pci_dev *pci)
-{
-        return  (0           == pci_domain_nr(pci->bus) &&
-                 p->bus      == pci->bus->number &&
-                 p->device   == PCI_SLOT(pci->devfn) &&
-                 p->function == PCI_FUNC(pci->devfn));
-}
-
-static unsigned long parse_acpi_hest_aer(void *hdr, int type, struct pci_dev *pci, int *firmware_first)
-{
-        struct acpi_hest_aer_common *p = hdr + sizeof(struct acpi_hest_header);
-        unsigned long rc=0;
-        u8 pcie_type = 0;
-        u8 bridge = 0;
-        switch (type) {
-        case ACPI_HEST_TYPE_AER_ROOT_PORT:
-                rc = sizeof(struct acpi_hest_aer_root);
-                pcie_type = PCI_EXP_TYPE_ROOT_PORT;
-                break;
-        case ACPI_HEST_TYPE_AER_ENDPOINT:
-                rc = sizeof(struct acpi_hest_aer);
-                pcie_type = PCI_EXP_TYPE_ENDPOINT;
-                break;
-        case ACPI_HEST_TYPE_AER_BRIDGE:
-                rc = sizeof(struct acpi_hest_aer_bridge);
-                if ((pci->class >> 16) == PCI_BASE_CLASS_BRIDGE)
-                        bridge = 1;
-                break;
-        }
-
-        if (p->flags & ACPI_HEST_GLOBAL) {
-                if ((pci->is_pcie && (pci->pcie_type == pcie_type)) || bridge)
-                        *firmware_first = !!(p->flags & ACPI_HEST_FIRMWARE_FIRST);
-        }
-        else
-                if (hest_match_pci(p, pci))
-                        *firmware_first = !!(p->flags & ACPI_HEST_FIRMWARE_FIRST);
-        return rc;
-}
-
-static int acpi_hest_firmware_first(struct acpi_table_header *stdheader, struct pci_dev *pci)
-{
-        struct acpi_table_hest *hest = (struct acpi_table_hest *)stdheader;
-        void *p = (void *)hest + sizeof(*hest); /* defined by the ACPI 4.0 spec */
-        struct acpi_hest_header *hdr = p;
-
-        int i;
-        int firmware_first = 0;
-        static unsigned char printed_unused = 0;
-        static unsigned char printed_reserved = 0;
-
-        for (i=0, hdr=p; p < (((void *)hest) + hest->header.length) && i < hest->error_source_count; i++) {
-                switch (hdr->type) {
-                case ACPI_HEST_TYPE_IA32_CHECK:
-                        p += parse_acpi_hest_ia_machine_check(p);
-                        break;
-                case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK:
-                        p += parse_acpi_hest_ia_corrected(p);
-                        break;
-                case ACPI_HEST_TYPE_IA32_NMI:
-                        p += parse_acpi_hest_ia_nmi(p);
-                        break;
-                /* These three should never appear */
-                case ACPI_HEST_TYPE_NOT_USED3:
-                case ACPI_HEST_TYPE_NOT_USED4:
-                case ACPI_HEST_TYPE_NOT_USED5:
-                        if (!printed_unused) {
-                                printk(KERN_DEBUG PREFIX
-                                       "HEST Error Source list contains an obsolete type (%d).\n", hdr->type);
-                                printed_unused = 1;
-                        }
-                        break;
-                case ACPI_HEST_TYPE_AER_ROOT_PORT:
-                case ACPI_HEST_TYPE_AER_ENDPOINT:
-                case ACPI_HEST_TYPE_AER_BRIDGE:
-                        p += parse_acpi_hest_aer(p, hdr->type, pci, &firmware_first);
-                        break;
-                case ACPI_HEST_TYPE_GENERIC_ERROR:
-                        p += parse_acpi_hest_generic(p);
-                        break;
-                /* These should never appear either */
-                case ACPI_HEST_TYPE_RESERVED:
-                default:
-                        if (!printed_reserved) {
-                                printk(KERN_DEBUG PREFIX
-                                       "HEST Error Source list contains a reserved type (%d).\n", hdr->type);
-                                printed_reserved = 1;
-                        }
-                        break;
-                }
-        }
-        return firmware_first;
-}
-
-int acpi_hest_firmware_first_pci(struct pci_dev *pci)
-{
-        acpi_status status = AE_NOT_FOUND;
-        struct acpi_table_header *hest = NULL;
-
-        if (acpi_disabled)
-                return 0;
-
-        status = acpi_get_table(ACPI_SIG_HEST, 1, &hest);
-
-        if (ACPI_SUCCESS(status)) {
-                if (acpi_hest_firmware_first(hest, pci)) {
-                        return 1;
-                }
-        }
-        return 0;
-}
-EXPORT_SYMBOL_GPL(acpi_hest_firmware_first_pci);
diff --git a/drivers/acpi/osl.c b/drivers/acpi/osl.c
index 4bc1c4178f50..78418ce4fc78 100644
--- a/drivers/acpi/osl.c
+++ b/drivers/acpi/osl.c
@@ -1207,6 +1207,15 @@ int acpi_check_mem_region(resource_size_t start, resource_size_t n,
 EXPORT_SYMBOL(acpi_check_mem_region);
 
 /*
+ * Let drivers know whether the resource checks are effective
+ */
+int acpi_resources_are_enforced(void)
+{
+        return acpi_enforce_resources == ENFORCE_RESOURCES_STRICT;
+}
+EXPORT_SYMBOL(acpi_resources_are_enforced);
+
+/*
  * Acquire a spinlock.
  *
  * handle is a pointer to the spinlock_t.
diff --git a/drivers/acpi/pci_root.c b/drivers/acpi/pci_root.c
index aefce33f2a09..4eac59393edc 100644
--- a/drivers/acpi/pci_root.c
+++ b/drivers/acpi/pci_root.c
@@ -120,7 +120,8 @@ acpi_handle acpi_get_pci_rootbridge_handle(unsigned int seg, unsigned int bus)
         struct acpi_pci_root *root;
         
         list_for_each_entry(root, &acpi_pci_roots, node)
-                if ((root->segment == (u16) seg) && (root->bus_nr == (u16) bus))
+                if ((root->segment == (u16) seg) &&
+                    (root->secondary.start == (u16) bus))
                         return root->device->handle;
         return NULL;            
 }
@@ -154,7 +155,7 @@ EXPORT_SYMBOL_GPL(acpi_is_root_bridge);
 static acpi_status
 get_root_bridge_busnr_callback(struct acpi_resource *resource, void *data)
 {
-        int *busnr = data;
+        struct resource *res = data;
         struct acpi_resource_address64 address;
 
         if (resource->type != ACPI_RESOURCE_TYPE_ADDRESS16 &&
@@ -164,28 +165,27 @@ get_root_bridge_busnr_callback(struct acpi_resource *resource, void *data)
 
         acpi_resource_to_address64(resource, &address);
         if ((address.address_length > 0) &&
-            (address.resource_type == ACPI_BUS_NUMBER_RANGE))
-                *busnr = address.minimum;
+            (address.resource_type == ACPI_BUS_NUMBER_RANGE)) {
+                res->start = address.minimum;
+                res->end = address.minimum + address.address_length - 1;
+        }
 
         return AE_OK;
 }
 
 static acpi_status try_get_root_bridge_busnr(acpi_handle handle,
-                                             unsigned long long *bus)
+                                             struct resource *res)
 {
         acpi_status status;
-        int busnum;
 
-        busnum = -1;
+        res->start = -1;
         status =
             acpi_walk_resources(handle, METHOD_NAME__CRS,
-                                get_root_bridge_busnr_callback, &busnum);
+                                get_root_bridge_busnr_callback, res);
         if (ACPI_FAILURE(status))
                 return status;
-        /* Check if we really get a bus number from _CRS */
-        if (busnum == -1)
+        if (res->start == -1)
                 return AE_ERROR;
-        *bus = busnum;
         return AE_OK;
 }
 
@@ -429,34 +429,47 @@ static int __devinit acpi_pci_root_add(struct acpi_device *device)
         struct acpi_device *child;
         u32 flags, base_flags;
 
+        root = kzalloc(sizeof(struct acpi_pci_root), GFP_KERNEL);
+        if (!root)
+                return -ENOMEM;
+
         segment = 0;
         status = acpi_evaluate_integer(device->handle, METHOD_NAME__SEG, NULL,
                                        &segment);
         if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
                 printk(KERN_ERR PREFIX "can't evaluate _SEG\n");
-                return -ENODEV;
+                result = -ENODEV;
+                goto end;
         }
 
         /* Check _CRS first, then _BBN.  If no _BBN, default to zero. */
-        bus = 0;
-        status = try_get_root_bridge_busnr(device->handle, &bus);
+        root->secondary.flags = IORESOURCE_BUS;
+        status = try_get_root_bridge_busnr(device->handle, &root->secondary);
         if (ACPI_FAILURE(status)) {
+                /*
+                 * We need both the start and end of the downstream bus range
+                 * to interpret _CBA (MMCONFIG base address), so it really is
+                 * supposed to be in _CRS.  If we don't find it there, all we
+                 * can do is assume [_BBN-0xFF] or [0-0xFF].
+                 */
+                root->secondary.end = 0xFF;
+                printk(KERN_WARNING FW_BUG PREFIX
+                       "no secondary bus range in _CRS\n");
                 status = acpi_evaluate_integer(device->handle, METHOD_NAME__BBN,                                               NULL, &bus);
-                if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
-                        printk(KERN_ERR PREFIX
-                             "no bus number in _CRS and can't evaluate _BBN\n");
-                        return -ENODEV;
+                if (ACPI_SUCCESS(status))
+                        root->secondary.start = bus;
+                else if (status == AE_NOT_FOUND)
+                        root->secondary.start = 0;
+                else {
+                        printk(KERN_ERR PREFIX "can't evaluate _BBN\n");
+                        result = -ENODEV;
+                        goto end;
                 }
         }
 
-        root = kzalloc(sizeof(struct acpi_pci_root), GFP_KERNEL);
-        if (!root)
-                return -ENOMEM;
-
         INIT_LIST_HEAD(&root->node);
         root->device = device;
         root->segment = segment & 0xFFFF;
-        root->bus_nr = bus & 0xFF;
         strcpy(acpi_device_name(device), ACPI_PCI_ROOT_DEVICE_NAME);
         strcpy(acpi_device_class(device), ACPI_PCI_ROOT_CLASS);
         device->driver_data = root;
@@ -475,9 +488,9 @@ static int __devinit acpi_pci_root_add(struct acpi_device *device)
         /* TBD: Locking */
         list_add_tail(&root->node, &acpi_pci_roots);
 
-        printk(KERN_INFO PREFIX "%s [%s] (%04x:%02x)\n",
+        printk(KERN_INFO PREFIX "%s [%s] (domain %04x %pR)\n",
                acpi_device_name(device), acpi_device_bid(device),
-               root->segment, root->bus_nr);
+               root->segment, &root->secondary);
 
         /*
          * Scan the Root Bridge
@@ -486,11 +499,11 @@ static int __devinit acpi_pci_root_add(struct acpi_device *device)
          * PCI namespace does not get created until this call is made (and 
          * thus the root bridge's pci_dev does not exist).
          */
-        root->bus = pci_acpi_scan_root(device, segment, bus);
+        root->bus = pci_acpi_scan_root(root);
         if (!root->bus) {
                 printk(KERN_ERR PREFIX
                             "Bus %04x:%02x not present in PCI namespace\n",
-                            root->segment, root->bus_nr);
+                            root->segment, (unsigned int)root->secondary.start);
                 result = -ENODEV;
                 goto end;
         }
diff --git a/drivers/acpi/processor_driver.c b/drivers/acpi/processor_driver.c
index 5675d9747e87..b1034a9ada4e 100644
--- a/drivers/acpi/processor_driver.c
+++ b/drivers/acpi/processor_driver.c
@@ -616,7 +616,8 @@ static int __cpuinit acpi_processor_add(struct acpi_device *device)
         acpi_processor_get_limit_info(pr);
 
 
-        acpi_processor_power_init(pr, device);
+        if (cpuidle_get_driver() == &acpi_idle_driver)
+                acpi_processor_power_init(pr, device);
 
         pr->cdev = thermal_cooling_device_register("Processor", device,
                                                 &processor_cooling_ops);
@@ -920,9 +921,14 @@ static int __init acpi_processor_init(void)
         if (!acpi_processor_dir)
                 return -ENOMEM;
 #endif
-        result = cpuidle_register_driver(&acpi_idle_driver);
-        if (result < 0)
-                goto out_proc;
+
+        if (!cpuidle_register_driver(&acpi_idle_driver)) {
+                printk(KERN_DEBUG "ACPI: %s registered with cpuidle\n",
+                        acpi_idle_driver.name);
+        } else {
+                printk(KERN_DEBUG "ACPI: acpi_idle yielding to %s",
+                        cpuidle_get_driver()->name);
+        }
 
         result = acpi_bus_register_driver(&acpi_processor_driver);
         if (result < 0)
@@ -941,7 +947,6 @@ static int __init acpi_processor_init(void)
 out_cpuidle:
         cpuidle_unregister_driver(&acpi_idle_driver);
 
-out_proc:
 #ifdef CONFIG_ACPI_PROCFS
         remove_proc_entry(ACPI_PROCESSOR_CLASS, acpi_root_dir);
 #endif
diff --git a/drivers/acpi/processor_idle.c b/drivers/acpi/processor_idle.c
index c3817e1f32c7..2e8c27d48f2b 100644
--- a/drivers/acpi/processor_idle.c
+++ b/drivers/acpi/processor_idle.c
@@ -727,19 +727,9 @@ static int acpi_processor_power_seq_show(struct seq_file *seq, void *offset)
                         break;
                 }
 
-                if (pr->power.states[i].promotion.state)
-                        seq_printf(seq, "promotion[C%zd] ",
-                                   (pr->power.states[i].promotion.state -
-                                    pr->power.states));
-                else
-                        seq_puts(seq, "promotion[--] ");
-
-                if (pr->power.states[i].demotion.state)
-                        seq_printf(seq, "demotion[C%zd] ",
-                                   (pr->power.states[i].demotion.state -
-                                    pr->power.states));
-                else
-                        seq_puts(seq, "demotion[--] ");
+                seq_puts(seq, "promotion[--] ");
+
+                seq_puts(seq, "demotion[--] ");
 
                 seq_printf(seq, "latency[%03d] usage[%08d] duration[%020llu]\n",
                            pr->power.states[i].latency,
@@ -869,6 +859,7 @@ static int acpi_idle_enter_simple(struct cpuidle_device *dev,
         struct acpi_processor *pr;
         struct acpi_processor_cx *cx = cpuidle_get_statedata(state);
         ktime_t  kt1, kt2;
+        s64 idle_time_ns;
         s64 idle_time;
         s64 sleep_ticks = 0;
 
@@ -881,6 +872,7 @@ static int acpi_idle_enter_simple(struct cpuidle_device *dev,
                 return(acpi_idle_enter_c1(dev, state));
 
         local_irq_disable();
+
         if (cx->entry_method != ACPI_CSTATE_FFH) {
                 current_thread_info()->status &= ~TS_POLLING;
                 /*
@@ -888,12 +880,12 @@ static int acpi_idle_enter_simple(struct cpuidle_device *dev,
                  * NEED_RESCHED:
                  */
                 smp_mb();
-        }
 
-        if (unlikely(need_resched())) {
-                current_thread_info()->status |= TS_POLLING;
-                local_irq_enable();
-                return 0;
+                if (unlikely(need_resched())) {
+                        current_thread_info()->status |= TS_POLLING;
+                        local_irq_enable();
+                        return 0;
+                }
         }
 
         /*
@@ -910,15 +902,18 @@ static int acpi_idle_enter_simple(struct cpuidle_device *dev,
         sched_clock_idle_sleep_event();
         acpi_idle_do_entry(cx);
         kt2 = ktime_get_real();
-        idle_time =  ktime_to_us(ktime_sub(kt2, kt1));
+        idle_time_ns = ktime_to_ns(ktime_sub(kt2, kt1));
+        idle_time = idle_time_ns;
+        do_div(idle_time, NSEC_PER_USEC);
 
         sleep_ticks = us_to_pm_timer_ticks(idle_time);
 
         /* Tell the scheduler how much we idled: */
-        sched_clock_idle_wakeup_event(sleep_ticks*PM_TIMER_TICK_NS);
+        sched_clock_idle_wakeup_event(idle_time_ns);
 
         local_irq_enable();
-        current_thread_info()->status |= TS_POLLING;
+        if (cx->entry_method != ACPI_CSTATE_FFH)
+                current_thread_info()->status |= TS_POLLING;
 
         cx->usage++;
 
@@ -943,6 +938,7 @@ static int acpi_idle_enter_bm(struct cpuidle_device *dev,
         struct acpi_processor *pr;
         struct acpi_processor_cx *cx = cpuidle_get_statedata(state);
         ktime_t  kt1, kt2;
+        s64 idle_time_ns;
         s64 idle_time;
         s64 sleep_ticks = 0;
 
@@ -968,6 +964,7 @@ static int acpi_idle_enter_bm(struct cpuidle_device *dev,
         }
 
         local_irq_disable();
+
         if (cx->entry_method != ACPI_CSTATE_FFH) {
                 current_thread_info()->status &= ~TS_POLLING;
                 /*
@@ -975,12 +972,12 @@ static int acpi_idle_enter_bm(struct cpuidle_device *dev,
                  * NEED_RESCHED:
                  */
                 smp_mb();
-        }
 
-        if (unlikely(need_resched())) {
-                current_thread_info()->status |= TS_POLLING;
-                local_irq_enable();
-                return 0;
+                if (unlikely(need_resched())) {
+                        current_thread_info()->status |= TS_POLLING;
+                        local_irq_enable();
+                        return 0;
+                }
         }
 
         acpi_unlazy_tlb(smp_processor_id());
@@ -1025,14 +1022,17 @@ static int acpi_idle_enter_bm(struct cpuidle_device *dev,
                 spin_unlock(&c3_lock);
         }
         kt2 = ktime_get_real();
-        idle_time =  ktime_to_us(ktime_sub(kt2, kt1));
+        idle_time_ns = ktime_to_us(ktime_sub(kt2, kt1));
+        idle_time = idle_time_ns;
+        do_div(idle_time, NSEC_PER_USEC);
 
         sleep_ticks = us_to_pm_timer_ticks(idle_time);
         /* Tell the scheduler how much we idled: */
-        sched_clock_idle_wakeup_event(sleep_ticks*PM_TIMER_TICK_NS);
+        sched_clock_idle_wakeup_event(idle_time_ns);
 
         local_irq_enable();
-        current_thread_info()->status |= TS_POLLING;
+        if (cx->entry_method != ACPI_CSTATE_FFH)
+                current_thread_info()->status |= TS_POLLING;
 
         cx->usage++;
 
diff --git a/drivers/acpi/sleep.c b/drivers/acpi/sleep.c
index baa76bbf244a..4ab2275b4461 100644
--- a/drivers/acpi/sleep.c
+++ b/drivers/acpi/sleep.c
@@ -80,22 +80,6 @@ static int acpi_sleep_prepare(u32 acpi_state)
 
 #ifdef CONFIG_ACPI_SLEEP
 static u32 acpi_target_sleep_state = ACPI_STATE_S0;
-/*
- * According to the ACPI specification the BIOS should make sure that ACPI is
- * enabled and SCI_EN bit is set on wake-up from S1 - S3 sleep states.  Still,
- * some BIOSes don't do that and therefore we use acpi_enable() to enable ACPI
- * on such systems during resume.  Unfortunately that doesn't help in
- * particularly pathological cases in which SCI_EN has to be set directly on
- * resume, although the specification states very clearly that this flag is
- * owned by the hardware.  The set_sci_en_on_resume variable will be set in such
- * cases.
- */
-static bool set_sci_en_on_resume;
-
-void __init acpi_set_sci_en_on_resume(void)
-{
-        set_sci_en_on_resume = true;
-}
 
 /*
  * ACPI 1.0 wants us to execute _PTS before suspending devices, so we allow the
@@ -253,11 +237,8 @@ static int acpi_suspend_enter(suspend_state_t pm_state)
                 break;
         }
 
-        /* If ACPI is not enabled by the BIOS, we need to enable it here. */
-        if (set_sci_en_on_resume)
-                acpi_write_bit_register(ACPI_BITREG_SCI_ENABLE, 1);
-        else
-                acpi_enable();
+        /* This violates the spec but is required for bug compatibility. */
+        acpi_write_bit_register(ACPI_BITREG_SCI_ENABLE, 1);
 
         /* Reprogram control registers and execute _BFS */
         acpi_leave_sleep_state_prep(acpi_state);
@@ -346,12 +327,6 @@ static int __init init_old_suspend_ordering(const struct dmi_system_id *d)
         return 0;
 }
 
-static int __init init_set_sci_en_on_resume(const struct dmi_system_id *d)
-{
-        set_sci_en_on_resume = true;
-        return 0;
-}
-
 static struct dmi_system_id __initdata acpisleep_dmi_table[] = {
         {
         .callback = init_old_suspend_ordering,
@@ -370,22 +345,6 @@ static struct dmi_system_id __initdata acpisleep_dmi_table[] = {
                 },
         },
         {
-        .callback = init_set_sci_en_on_resume,
-        .ident = "Apple MacBook 1,1",
-        .matches = {
-                DMI_MATCH(DMI_SYS_VENDOR, "Apple Computer, Inc."),
-                DMI_MATCH(DMI_PRODUCT_NAME, "MacBook1,1"),
-                },
-        },
-        {
-        .callback = init_set_sci_en_on_resume,
-        .ident = "Apple MacMini 1,1",
-        .matches = {
-                DMI_MATCH(DMI_SYS_VENDOR, "Apple Computer, Inc."),
-                DMI_MATCH(DMI_PRODUCT_NAME, "Macmini1,1"),
-                },
-        },
-        {
         .callback = init_old_suspend_ordering,
         .ident = "Asus Pundit P1-AH2 (M2N8L motherboard)",
         .matches = {
@@ -394,94 +353,6 @@ static struct dmi_system_id __initdata acpisleep_dmi_table[] = {
                 },
         },
         {
-        .callback = init_set_sci_en_on_resume,
-        .ident = "Toshiba Satellite L300",
-        .matches = {
-                DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
-                DMI_MATCH(DMI_PRODUCT_NAME, "Satellite L300"),
-                },
-        },
-        {
-        .callback = init_set_sci_en_on_resume,
-        .ident = "Hewlett-Packard HP G7000 Notebook PC",
-        .matches = {
-                DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
-                DMI_MATCH(DMI_PRODUCT_NAME, "HP G7000 Notebook PC"),
-                },
-        },
-        {
-        .callback = init_set_sci_en_on_resume,
-        .ident = "Hewlett-Packard HP Pavilion dv3 Notebook PC",
-        .matches = {
-                DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
-                DMI_MATCH(DMI_PRODUCT_NAME, "HP Pavilion dv3 Notebook PC"),
-                },
-        },
-        {
-        .callback = init_set_sci_en_on_resume,
-        .ident = "Hewlett-Packard Pavilion dv4",
-        .matches = {
-                DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
-                DMI_MATCH(DMI_PRODUCT_NAME, "HP Pavilion dv4"),
-                },
-        },
-        {
-        .callback = init_set_sci_en_on_resume,
-        .ident = "Hewlett-Packard Pavilion dv7",
-        .matches = {
-                DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
-                DMI_MATCH(DMI_PRODUCT_NAME, "HP Pavilion dv7"),
-                },
-        },
-        {
-        .callback = init_set_sci_en_on_resume,
-        .ident = "Hewlett-Packard Compaq Presario C700 Notebook PC",
-        .matches = {
-                DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
-                DMI_MATCH(DMI_PRODUCT_NAME, "Compaq Presario C700 Notebook PC"),
-                },
-        },
-        {
-        .callback = init_set_sci_en_on_resume,
-        .ident = "Hewlett-Packard Compaq Presario CQ40 Notebook PC",
-        .matches = {
-                DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
-                DMI_MATCH(DMI_PRODUCT_NAME, "Compaq Presario CQ40 Notebook PC"),
-                },
-        },
-        {
-        .callback = init_set_sci_en_on_resume,
-        .ident = "Lenovo ThinkPad T410",
-        .matches = {
-                DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
-                DMI_MATCH(DMI_PRODUCT_VERSION, "ThinkPad T410"),
-                },
-        },
-        {
-        .callback = init_set_sci_en_on_resume,
-        .ident = "Lenovo ThinkPad T510",
-        .matches = {
-                DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
-                DMI_MATCH(DMI_PRODUCT_VERSION, "ThinkPad T510"),
-                },
-        },
-        {
-        .callback = init_set_sci_en_on_resume,
-        .ident = "Lenovo ThinkPad W510",
-        .matches = {
-                DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
-                DMI_MATCH(DMI_PRODUCT_VERSION, "ThinkPad W510"),
-                },
-        },
-        {
-        .callback = init_set_sci_en_on_resume,
-        .ident = "Lenovo ThinkPad X201[s]",
-        .matches = {
-                DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
-                DMI_MATCH(DMI_PRODUCT_VERSION, "ThinkPad X201"),
-                },
-        },
-        {
         .callback = init_old_suspend_ordering,
         .ident = "Panasonic CF51-2L",
         .matches = {
@@ -490,30 +361,6 @@ static struct dmi_system_id __initdata acpisleep_dmi_table[] = {
                 DMI_MATCH(DMI_BOARD_NAME, "CF51-2L"),
                 },
         },
-        {
-        .callback = init_set_sci_en_on_resume,
-        .ident = "Dell Studio 1558",
-        .matches = {
-                DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
-                DMI_MATCH(DMI_PRODUCT_NAME, "Studio 1558"),
-                },
-        },
-        {
-        .callback = init_set_sci_en_on_resume,
-        .ident = "Dell Studio 1557",
-        .matches = {
-                DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
-                DMI_MATCH(DMI_PRODUCT_NAME, "Studio 1557"),
-                },
-        },
-        {
-        .callback = init_set_sci_en_on_resume,
-        .ident = "Dell Studio 1555",
-        .matches = {
-                DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
-                DMI_MATCH(DMI_PRODUCT_NAME, "Studio 1555"),
-                },
-        },
         {},
 };
 #endif /* CONFIG_SUSPEND */
diff --git a/drivers/acpi/sleep.h b/drivers/acpi/sleep.h
index 8a8f3b3382a6..25b8bd149284 100644
--- a/drivers/acpi/sleep.h
+++ b/drivers/acpi/sleep.h
@@ -1,6 +1,6 @@
 
 extern u8 sleep_states[];
-extern int acpi_suspend (u32 state);
+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);
diff --git a/drivers/acpi/tables.c b/drivers/acpi/tables.c
index 8a0ed2800e63..f336bca7c450 100644
--- a/drivers/acpi/tables.c
+++ b/drivers/acpi/tables.c
@@ -213,7 +213,7 @@ acpi_table_parse_entries(char *id,
         unsigned long table_end;
         acpi_size tbl_size;
 
-        if (acpi_disabled && !acpi_ht)
+        if (acpi_disabled)
                 return -ENODEV;
 
         if (!handler)
@@ -280,7 +280,7 @@ int __init acpi_table_parse(char *id, acpi_table_handler handler)
         struct acpi_table_header *table = NULL;
         acpi_size tbl_size;
 
-        if (acpi_disabled && !acpi_ht)
+        if (acpi_disabled)
                 return -ENODEV;
 
         if (!handler)
diff --git a/drivers/acpi/video.c b/drivers/acpi/video.c
index a0c93b321482..9865d46f49a8 100644
--- a/drivers/acpi/video.c
+++ b/drivers/acpi/video.c
@@ -45,6 +45,7 @@
 #include <acpi/acpi_bus.h>
 #include <acpi/acpi_drivers.h>
 #include <linux/suspend.h>
+#include <acpi/video.h>
 
 #define PREFIX "ACPI: "
 
@@ -65,11 +66,6 @@
 
 #define MAX_NAME_LEN    20
 
-#define ACPI_VIDEO_DISPLAY_CRT  1
-#define ACPI_VIDEO_DISPLAY_TV   2
-#define ACPI_VIDEO_DISPLAY_DVI  3
-#define ACPI_VIDEO_DISPLAY_LCD  4
-
 #define _COMPONENT              ACPI_VIDEO_COMPONENT
 ACPI_MODULE_NAME("video");
 
@@ -1007,11 +1003,11 @@ static void acpi_video_device_find_cap(struct acpi_video_device *device)
                 result = acpi_video_init_brightness(device);
                 if (result)
                         return;
-                name = kzalloc(MAX_NAME_LEN, GFP_KERNEL);
+                name = kasprintf(GFP_KERNEL, "acpi_video%d", count);
                 if (!name)
                         return;
+                count++;
 
-                sprintf(name, "acpi_video%d", count++);
                 memset(&props, 0, sizeof(struct backlight_properties));
                 props.max_brightness = device->brightness->count - 3;
                 device->backlight = backlight_device_register(name, NULL, device,
@@ -1067,10 +1063,10 @@ static void acpi_video_device_find_cap(struct acpi_video_device *device)
                 if (device->cap._DCS && device->cap._DSS) {
                         static int count;
                         char *name;
-                        name = kzalloc(MAX_NAME_LEN, GFP_KERNEL);
+                        name = kasprintf(GFP_KERNEL, "acpi_video%d", count);
                         if (!name)
                                 return;
-                        sprintf(name, "acpi_video%d", count++);
+                        count++;
                         device->output_dev = video_output_register(name,
                                         NULL, device, &acpi_output_properties);
                         kfree(name);
@@ -1748,11 +1744,27 @@ acpi_video_get_device_attr(struct acpi_video_bus *video, unsigned long device_id
 }
 
 static int
+acpi_video_get_device_type(struct acpi_video_bus *video,
+                           unsigned long device_id)
+{
+        struct acpi_video_enumerated_device *ids;
+        int i;
+
+        for (i = 0; i < video->attached_count; i++) {
+                ids = &video->attached_array[i];
+                if ((ids->value.int_val & 0xffff) == device_id)
+                        return ids->value.int_val;
+        }
+
+        return 0;
+}
+
+static int
 acpi_video_bus_get_one_device(struct acpi_device *device,
                               struct acpi_video_bus *video)
 {
         unsigned long long device_id;
-        int status;
+        int status, device_type;
         struct acpi_video_device *data;
         struct acpi_video_device_attrib* attribute;
 
@@ -1797,8 +1809,25 @@ acpi_video_bus_get_one_device(struct acpi_device *device,
                         }
                         if(attribute->bios_can_detect)
                                 data->flags.bios = 1;
-                } else
-                        data->flags.unknown = 1;
+                } else {
+                        /* Check for legacy IDs */
+                        device_type = acpi_video_get_device_type(video,
+                                                                 device_id);
+                        /* Ignore bits 16 and 18-20 */
+                        switch (device_type & 0xffe2ffff) {
+                        case ACPI_VIDEO_DISPLAY_LEGACY_MONITOR:
+                                data->flags.crt = 1;
+                                break;
+                        case ACPI_VIDEO_DISPLAY_LEGACY_PANEL:
+                                data->flags.lcd = 1;
+                                break;
+                        case ACPI_VIDEO_DISPLAY_LEGACY_TV:
+                                data->flags.tvout = 1;
+                                break;
+                        default:
+                                data->flags.unknown = 1;
+                        }
+                }
 
                 acpi_video_device_bind(video, data);
                 acpi_video_device_find_cap(data);
@@ -2032,6 +2061,71 @@ out:
         return result;
 }
 
+int acpi_video_get_edid(struct acpi_device *device, int type, int device_id,
+                        void **edid)
+{
+        struct acpi_video_bus *video;
+        struct acpi_video_device *video_device;
+        union acpi_object *buffer = NULL;
+        acpi_status status;
+        int i, length;
+
+        if (!device || !acpi_driver_data(device))
+                return -EINVAL;
+
+        video = acpi_driver_data(device);
+
+        for (i = 0; i < video->attached_count; i++) {
+                video_device = video->attached_array[i].bind_info;
+                length = 256;
+
+                if (!video_device)
+                        continue;
+
+                if (type) {
+                        switch (type) {
+                        case ACPI_VIDEO_DISPLAY_CRT:
+                                if (!video_device->flags.crt)
+                                        continue;
+                                break;
+                        case ACPI_VIDEO_DISPLAY_TV:
+                                if (!video_device->flags.tvout)
+                                        continue;
+                                break;
+                        case ACPI_VIDEO_DISPLAY_DVI:
+                                if (!video_device->flags.dvi)
+                                        continue;
+                                break;
+                        case ACPI_VIDEO_DISPLAY_LCD:
+                                if (!video_device->flags.lcd)
+                                        continue;
+                                break;
+                        }
+                } else if (video_device->device_id != device_id) {
+                        continue;
+                }
+
+                status = acpi_video_device_EDID(video_device, &buffer, length);
+
+                if (ACPI_FAILURE(status) || !buffer ||
+                    buffer->type != ACPI_TYPE_BUFFER) {
+                        length = 128;
+                        status = acpi_video_device_EDID(video_device, &buffer,
+                                                        length);
+                        if (ACPI_FAILURE(status) || !buffer ||
+                            buffer->type != ACPI_TYPE_BUFFER) {
+                                continue;
+                        }
+                }
+
+                *edid = buffer->buffer.pointer;
+                return length;
+        }
+
+        return -ENODEV;
+}
+EXPORT_SYMBOL(acpi_video_get_edid);
+
 static int
 acpi_video_bus_get_devices(struct acpi_video_bus *video,
                            struct acpi_device *device)
diff --git a/drivers/acpi/video_detect.c b/drivers/acpi/video_detect.c
index fc2f26b9b407..c5fef01b3c95 100644
--- a/drivers/acpi/video_detect.c
+++ b/drivers/acpi/video_detect.c
@@ -250,7 +250,7 @@ static int __init acpi_backlight(char *str)
                                 ACPI_VIDEO_BACKLIGHT_FORCE_VENDOR;
                 if (!strcmp("video", str))
                         acpi_video_support |=
-                                ACPI_VIDEO_OUTPUT_SWITCHING_FORCE_VIDEO;
+                                ACPI_VIDEO_BACKLIGHT_FORCE_VIDEO;
         }
         return 1;
 }
diff --git a/drivers/ata/Kconfig b/drivers/ata/Kconfig
index e68541f662b9..73f883333a0d 100644
--- a/drivers/ata/Kconfig
+++ b/drivers/ata/Kconfig
@@ -57,6 +57,8 @@ config SATA_PMP
           This option adds support for SATA Port Multipliers
           (the SATA version of an ethernet hub, or SAS expander).
 
+comment "Controllers with non-SFF native interface"
+
 config SATA_AHCI
         tristate "AHCI SATA support"
         depends on PCI
@@ -73,11 +75,12 @@ config SATA_AHCI_PLATFORM
 
           If unsure, say N.
 
-config SATA_SIL24
-        tristate "Silicon Image 3124/3132 SATA support"
-        depends on PCI
+config SATA_FSL
+        tristate "Freescale 3.0Gbps SATA support"
+        depends on FSL_SOC
         help
-          This option enables support for Silicon Image 3124/3132 Serial ATA.
+          This option enables support for Freescale 3.0Gbps SATA controller.
+          It can be found on MPC837x and MPC8315.
 
           If unsure, say N.
 
@@ -87,12 +90,11 @@ config SATA_INIC162X
         help
           This option enables support for Initio 162x Serial ATA.
 
-config SATA_FSL
-        tristate "Freescale 3.0Gbps SATA support"
-        depends on FSL_SOC
+config SATA_SIL24
+        tristate "Silicon Image 3124/3132 SATA support"
+        depends on PCI
         help
-          This option enables support for Freescale 3.0Gbps SATA controller.
-          It can be found on MPC837x and MPC8315.
+          This option enables support for Silicon Image 3124/3132 Serial ATA.
 
           If unsure, say N.
 
@@ -116,15 +118,65 @@ config ATA_SFF
 
 if ATA_SFF
 
-config SATA_SVW
-        tristate "ServerWorks Frodo / Apple K2 SATA support"
+comment "SFF controllers with custom DMA interface"
+
+config PDC_ADMA
+        tristate "Pacific Digital ADMA support"
         depends on PCI
         help
-          This option enables support for Broadcom/Serverworks/Apple K2
-          SATA support.
+          This option enables support for Pacific Digital ADMA controllers
+
+          If unsure, say N.
+
+config PATA_MPC52xx
+        tristate "Freescale MPC52xx SoC internal IDE"
+        depends on PPC_MPC52xx && PPC_BESTCOMM
+        select PPC_BESTCOMM_ATA
+        help
+          This option enables support for integrated IDE controller
+          of the Freescale MPC52xx SoC.
+
+          If unsure, say N.
+
+config PATA_OCTEON_CF
+        tristate "OCTEON Boot Bus Compact Flash support"
+        depends on CPU_CAVIUM_OCTEON
+        help
+          This option enables a polled compact flash driver for use with
+          compact flash cards attached to the OCTEON boot bus.
+
+          If unsure, say N.
+
+config SATA_QSTOR
+        tristate "Pacific Digital SATA QStor support"
+        depends on PCI
+        help
+          This option enables support for Pacific Digital Serial ATA QStor.
+
+          If unsure, say N.
+
+config SATA_SX4
+        tristate "Promise SATA SX4 support (Experimental)"
+        depends on PCI && EXPERIMENTAL
+        help
+          This option enables support for Promise Serial ATA SX4.
 
           If unsure, say N.
 
+config ATA_BMDMA
+        bool "ATA BMDMA support"
+        default y
+        help
+          This option adds support for SFF ATA controllers with BMDMA
+          capability.  BMDMA stands for bus-master DMA and the
+          de-facto DMA interface for SFF controllers.
+
+          If unuser, say Y.
+
+if ATA_BMDMA
+
+comment "SATA SFF controllers with BMDMA"
+
 config ATA_PIIX
         tristate "Intel ESB, ICH, PIIX3, PIIX4 PATA/SATA support"
         depends on PCI
@@ -152,22 +204,6 @@ config SATA_NV
 
           If unsure, say N.
 
-config PDC_ADMA
-        tristate "Pacific Digital ADMA support"
-        depends on PCI
-        help
-          This option enables support for Pacific Digital ADMA controllers
-
-          If unsure, say N.
-
-config SATA_QSTOR
-        tristate "Pacific Digital SATA QStor support"
-        depends on PCI
-        help
-          This option enables support for Pacific Digital Serial ATA QStor.
-
-          If unsure, say N.
-
 config SATA_PROMISE
         tristate "Promise SATA TX2/TX4 support"
         depends on PCI
@@ -176,14 +212,6 @@ config SATA_PROMISE
 
           If unsure, say N.
 
-config SATA_SX4
-        tristate "Promise SATA SX4 support (Experimental)"
-        depends on PCI && EXPERIMENTAL
-        help
-          This option enables support for Promise Serial ATA SX4.
-
-          If unsure, say N.
-
 config SATA_SIL
         tristate "Silicon Image SATA support"
         depends on PCI
@@ -203,6 +231,15 @@ config SATA_SIS
           enable the PATA_SIS driver in the config.
           If unsure, say N.
 
+config SATA_SVW
+        tristate "ServerWorks Frodo / Apple K2 SATA support"
+        depends on PCI
+        help
+          This option enables support for Broadcom/Serverworks/Apple K2
+          SATA support.
+
+          If unsure, say N.
+
 config SATA_ULI
         tristate "ULi Electronics SATA support"
         depends on PCI
@@ -227,14 +264,7 @@ config SATA_VITESSE
 
           If unsure, say N.
 
-config PATA_ACPI
-        tristate "ACPI firmware driver for PATA"
-        depends on ATA_ACPI
-        help
-          This option enables an ACPI method driver which drives
-          motherboard PATA controller interfaces through the ACPI
-          firmware in the BIOS. This driver can sometimes handle
-          otherwise unsupported hardware.
+comment "PATA SFF controllers with BMDMA"
 
 config PATA_ALI
         tristate "ALi PATA support"
@@ -262,40 +292,30 @@ config PATA_ARTOP
 
           If unsure, say N.
 
-config PATA_ATP867X
-        tristate "ARTOP/Acard ATP867X PATA support"
+config PATA_ATIIXP
+        tristate "ATI PATA support"
         depends on PCI
         help
-          This option enables support for ARTOP/Acard ATP867X PATA
-          controllers.
-
-          If unsure, say N.
-
-config PATA_AT32
-        tristate "Atmel AVR32 PATA support (Experimental)"
-        depends on AVR32 && PLATFORM_AT32AP && EXPERIMENTAL
-        help
-          This option enables support for the IDE devices on the
-          Atmel AT32AP platform.
+          This option enables support for the ATI ATA interfaces
+          found on the many ATI chipsets.
 
           If unsure, say N.
 
-config PATA_ATIIXP
-        tristate "ATI PATA support"
+config PATA_ATP867X
+        tristate "ARTOP/Acard ATP867X PATA support"
         depends on PCI
         help
-          This option enables support for the ATI ATA interfaces
-          found on the many ATI chipsets.
+          This option enables support for ARTOP/Acard ATP867X PATA
+          controllers.
 
           If unsure, say N.
 
-config PATA_CMD640_PCI
-        tristate "CMD640 PCI PATA support (Experimental)"
-        depends on PCI && EXPERIMENTAL
+config PATA_BF54X
+        tristate "Blackfin 54x ATAPI support"
+        depends on BF542 || BF548 || BF549
         help
-          This option enables support for the CMD640 PCI IDE
-          interface chip. Only the primary channel is currently
-          supported.
+          This option enables support for the built-in ATAPI controller on
+          Blackfin 54x family chips.
 
           If unsure, say N.
 
@@ -362,15 +382,6 @@ config PATA_EFAR
 
           If unsure, say N.
 
-config ATA_GENERIC
-        tristate "Generic ATA support"
-        depends on PCI
-        help
-          This option enables support for generic BIOS configured
-          ATA controllers via the new ATA layer
-
-          If unsure, say N.
-
 config PATA_HPT366
         tristate "HPT 366/368 PATA support"
         depends on PCI
@@ -415,12 +426,20 @@ config PATA_HPT3X3_DMA
           controllers. Enable with care as there are still some
           problems with DMA on this chipset.
 
-config PATA_ISAPNP
-        tristate "ISA Plug and Play PATA support"
-        depends on ISAPNP
+config PATA_ICSIDE
+        tristate "Acorn ICS PATA support"
+        depends on ARM && ARCH_ACORN
         help
-          This option enables support for ISA plug & play ATA
-          controllers such as those found on old soundcards.
+          On Acorn systems, say Y here if you wish to use the ICS PATA
+          interface card.  This is not required for ICS partition support.
+          If you are unsure, say N to this.
+
+config PATA_IT8213
+        tristate "IT8213 PATA support (Experimental)"
+        depends on PCI && EXPERIMENTAL
+        help
+          This option enables support for the ITE 821 PATA
+          controllers via the new ATA layer.
 
           If unsure, say N.
 
@@ -434,15 +453,6 @@ config PATA_IT821X
 
           If unsure, say N.
 
-config PATA_IT8213
-        tristate "IT8213 PATA support (Experimental)"
-        depends on PCI && EXPERIMENTAL
-        help
-          This option enables support for the ITE 821 PATA
-          controllers via the new ATA layer.
-
-          If unsure, say N.
-
 config PATA_JMICRON
         tristate "JMicron PATA support"
         depends on PCI
@@ -452,23 +462,14 @@ config PATA_JMICRON
 
           If unsure, say N.
 
-config PATA_LEGACY
-        tristate "Legacy ISA PATA support (Experimental)"
-        depends on (ISA || PCI)  && EXPERIMENTAL
-        help
-          This option enables support for ISA/VLB/PCI bus legacy PATA
-          ports and allows them to be accessed via the new ATA layer.
-
-          If unsure, say N.
-
-config PATA_TRIFLEX
-        tristate "Compaq Triflex PATA support"
-        depends on PCI
+config PATA_MACIO
+        tristate "Apple PowerMac/PowerBook internal 'MacIO' IDE"
+        depends on PPC_PMAC
         help
-          Enable support for the Compaq 'Triflex' IDE controller as found
-          on many Compaq Pentium-Pro systems, via the new ATA layer.
-
-          If unsure, say N.
+          Most IDE capable PowerMacs have IDE busses driven by a variant
+          of this controller which is part of the Apple chipset used on
+          most PowerMac models. Some models have multiple busses using
+          different chipsets, though generally, MacIO is one of them.
 
 config PATA_MARVELL
         tristate "Marvell PATA support via legacy mode"
@@ -481,32 +482,6 @@ config PATA_MARVELL
 
           If unsure, say N.
 
-config PATA_MPC52xx
-        tristate "Freescale MPC52xx SoC internal IDE"
-        depends on PPC_MPC52xx && PPC_BESTCOMM
-        select PPC_BESTCOMM_ATA
-        help
-          This option enables support for integrated IDE controller
-          of the Freescale MPC52xx SoC.
-
-          If unsure, say N.
-
-config PATA_MPIIX
-        tristate "Intel PATA MPIIX support"
-        depends on PCI
-        help
-          This option enables support for MPIIX PATA support.
-
-          If unsure, say N.
-
-config PATA_OLDPIIX
-        tristate "Intel PATA old PIIX support"
-        depends on PCI
-        help
-          This option enables support for early PIIX PATA support.
-
-          If unsure, say N.
-
 config PATA_NETCELL
         tristate "NETCELL Revolution RAID support"
         depends on PCI
@@ -525,15 +500,6 @@ config PATA_NINJA32
 
           If unsure, say N.
 
-config PATA_NS87410
-        tristate "Nat Semi NS87410 PATA support"
-        depends on PCI
-        help
-          This option enables support for the National Semiconductor
-          NS87410 PCI-IDE controller.
-
-          If unsure, say N.
-
 config PATA_NS87415
         tristate "Nat Semi NS87415 PATA support"
         depends on PCI
@@ -543,12 +509,11 @@ config PATA_NS87415
 
           If unsure, say N.
 
-config PATA_OPTI
-        tristate "OPTI621/6215 PATA support (Very Experimental)"
-        depends on PCI && EXPERIMENTAL
+config PATA_OLDPIIX
+        tristate "Intel PATA old PIIX support"
+        depends on PCI
         help
-          This option enables full PIO support for the early Opti ATA
-          controllers found on some old motherboards.
+          This option enables support for early PIIX PATA support.
 
           If unsure, say N.
 
@@ -562,24 +527,6 @@ config PATA_OPTIDMA
 
           If unsure, say N.
 
-config PATA_PALMLD
-        tristate "Palm LifeDrive PATA support"
-        depends on MACH_PALMLD
-        help
-          This option enables support for Palm LifeDrive's internal ATA
-          port via the new ATA layer.
-
-          If unsure, say N.
-
-config PATA_PCMCIA
-        tristate "PCMCIA PATA support"
-        depends on PCMCIA
-        help
-          This option enables support for PCMCIA ATA interfaces, including
-          compact flash card adapters via the new ATA layer.
-
-          If unsure, say N.
-
 config PATA_PDC2027X
         tristate "Promise PATA 2027x support"
         depends on PCI
@@ -597,12 +544,6 @@ config PATA_PDC_OLD
 
           If unsure, say N.
 
-config PATA_QDI
-        tristate "QDI VLB PATA support"
-        depends on ISA
-        help
-          Support for QDI 6500 and 6580 PATA controllers on VESA local bus.
-
 config PATA_RADISYS
         tristate "RADISYS 82600 PATA support (Experimental)"
         depends on PCI && EXPERIMENTAL
@@ -612,15 +553,6 @@ config PATA_RADISYS
 
           If unsure, say N.
 
-config PATA_RB532
-        tristate "RouterBoard 532 PATA CompactFlash support"
-        depends on MIKROTIK_RB532
-        help
-          This option enables support for the RouterBoard 532
-          PATA CompactFlash controller.
-
-          If unsure, say N.
-
 config PATA_RDC
         tristate "RDC PATA support"
         depends on PCI
@@ -631,21 +563,30 @@ config PATA_RDC
 
           If unsure, say N.
 
-config PATA_RZ1000
-        tristate "PC Tech RZ1000 PATA support"
+config PATA_SC1200
+        tristate "SC1200 PATA support"
         depends on PCI
         help
-          This option enables basic support for the PC Tech RZ1000/1
-          PATA controllers via the new ATA layer
+          This option enables support for the NatSemi/AMD SC1200 SoC
+          companion chip used with the Geode processor family.
 
           If unsure, say N.
 
-config PATA_SC1200
-        tristate "SC1200 PATA support"
+config PATA_SCC
+        tristate "Toshiba's Cell Reference Set IDE support"
+        depends on PCI && PPC_CELLEB
+        help
+          This option enables support for the built-in IDE controller on
+          Toshiba Cell Reference Board.
+
+          If unsure, say N.
+
+config PATA_SCH
+        tristate "Intel SCH PATA support"
         depends on PCI
         help
-          This option enables support for the NatSemi/AMD SC1200 SoC
-          companion chip used with the Geode processor family.
+          This option enables support for Intel SCH PATA on the Intel
+          SCH (US15W, US15L, UL11L) series host controllers.
 
           If unsure, say N.
 
@@ -683,6 +624,15 @@ config PATA_TOSHIBA
 
           If unsure, say N.
 
+config PATA_TRIFLEX
+        tristate "Compaq Triflex PATA support"
+        depends on PCI
+        help
+          Enable support for the Compaq 'Triflex' IDE controller as found
+          on many Compaq Pentium-Pro systems, via the new ATA layer.
+
+          If unsure, say N.
+
 config PATA_VIA
         tristate "VIA PATA support"
         depends on PCI
@@ -701,12 +651,99 @@ config PATA_WINBOND
 
           If unsure, say N.
 
-config PATA_WINBOND_VLB
-        tristate "Winbond W83759A VLB PATA support (Experimental)"
-        depends on ISA && EXPERIMENTAL
+endif # ATA_BMDMA
+
+comment "PIO-only SFF controllers"
+
+config PATA_AT32
+        tristate "Atmel AVR32 PATA support (Experimental)"
+        depends on AVR32 && PLATFORM_AT32AP && EXPERIMENTAL
         help
-          Support for the Winbond W83759A controller on Vesa Local Bus
-          systems.
+          This option enables support for the IDE devices on the
+          Atmel AT32AP platform.
+
+          If unsure, say N.
+
+config PATA_AT91
+        tristate "PATA support for AT91SAM9260"
+        depends on ARM && ARCH_AT91
+        help
+          This option enables support for IDE devices on the Atmel AT91SAM9260 SoC.
+
+          If unsure, say N.
+
+config PATA_CMD640_PCI
+        tristate "CMD640 PCI PATA support (Experimental)"
+        depends on PCI && EXPERIMENTAL
+        help
+          This option enables support for the CMD640 PCI IDE
+          interface chip. Only the primary channel is currently
+          supported.
+
+          If unsure, say N.
+
+config PATA_ISAPNP
+        tristate "ISA Plug and Play PATA support"
+        depends on ISAPNP
+        help
+          This option enables support for ISA plug & play ATA
+          controllers such as those found on old soundcards.
+
+          If unsure, say N.
+
+config PATA_IXP4XX_CF
+        tristate "IXP4XX Compact Flash support"
+        depends on ARCH_IXP4XX
+        help
+          This option enables support for a Compact Flash connected on
+          the ixp4xx expansion bus. This driver had been written for
+          Loft/Avila boards in mind but can work with others.
+
+          If unsure, say N.
+
+config PATA_MPIIX
+        tristate "Intel PATA MPIIX support"
+        depends on PCI
+        help
+          This option enables support for MPIIX PATA support.
+
+          If unsure, say N.
+
+config PATA_NS87410
+        tristate "Nat Semi NS87410 PATA support"
+        depends on PCI
+        help
+          This option enables support for the National Semiconductor
+          NS87410 PCI-IDE controller.
+
+          If unsure, say N.
+
+config PATA_OPTI
+        tristate "OPTI621/6215 PATA support (Very Experimental)"
+        depends on PCI && EXPERIMENTAL
+        help
+          This option enables full PIO support for the early Opti ATA
+          controllers found on some old motherboards.
+
+          If unsure, say N.
+
+config PATA_PALMLD
+        tristate "Palm LifeDrive PATA support"
+        depends on MACH_PALMLD
+        help
+          This option enables support for Palm LifeDrive's internal ATA
+          port via the new ATA layer.
+
+          If unsure, say N.
+
+config PATA_PCMCIA
+        tristate "PCMCIA PATA support"
+        depends on PCMCIA
+        help
+          This option enables support for PCMCIA ATA interfaces, including
+          compact flash card adapters via the new ATA layer.
+
+          If unsure, say N.
 
 config HAVE_PATA_PLATFORM
         bool
@@ -725,14 +762,6 @@ config PATA_PLATFORM
 
           If unsure, say N.
 
-config PATA_AT91
-        tristate "PATA support for AT91SAM9260"
-        depends on ARM && ARCH_AT91
-        help
-          This option enables support for IDE devices on the Atmel AT91SAM9260 SoC.
-
-          If unsure, say N.
-
 config PATA_OF_PLATFORM
         tristate "OpenFirmware platform device PATA support"
         depends on PATA_PLATFORM && PPC_OF
@@ -743,69 +772,65 @@ config PATA_OF_PLATFORM
 
           If unsure, say N.
 
-config PATA_ICSIDE
-        tristate "Acorn ICS PATA support"
-        depends on ARM && ARCH_ACORN
+config PATA_QDI
+        tristate "QDI VLB PATA support"
+        depends on ISA
         help
-          On Acorn systems, say Y here if you wish to use the ICS PATA
-          interface card.  This is not required for ICS partition support.
-          If you are unsure, say N to this.
+          Support for QDI 6500 and 6580 PATA controllers on VESA local bus.
 
-config PATA_IXP4XX_CF
-        tristate "IXP4XX Compact Flash support"
-        depends on ARCH_IXP4XX
+config PATA_RB532
+        tristate "RouterBoard 532 PATA CompactFlash support"
+        depends on MIKROTIK_RB532
         help
-          This option enables support for a Compact Flash connected on
-          the ixp4xx expansion bus. This driver had been written for
-          Loft/Avila boards in mind but can work with others.
+          This option enables support for the RouterBoard 532
+          PATA CompactFlash controller.
 
           If unsure, say N.
 
-config PATA_OCTEON_CF
-        tristate "OCTEON Boot Bus Compact Flash support"
-        depends on CPU_CAVIUM_OCTEON
+config PATA_RZ1000
+        tristate "PC Tech RZ1000 PATA support"
+        depends on PCI
         help
-          This option enables a polled compact flash driver for use with
-          compact flash cards attached to the OCTEON boot bus.
+          This option enables basic support for the PC Tech RZ1000/1
+          PATA controllers via the new ATA layer
 
           If unsure, say N.
 
-config PATA_SCC
-        tristate "Toshiba's Cell Reference Set IDE support"
-        depends on PCI && PPC_CELLEB
+config PATA_WINBOND_VLB
+        tristate "Winbond W83759A VLB PATA support (Experimental)"
+        depends on ISA && EXPERIMENTAL
         help
-          This option enables support for the built-in IDE controller on
-          Toshiba Cell Reference Board.
+          Support for the Winbond W83759A controller on Vesa Local Bus
+          systems.
 
-          If unsure, say N.
+comment "Generic fallback / legacy drivers"
 
-config PATA_SCH
-        tristate "Intel SCH PATA support"
-        depends on PCI
+config PATA_ACPI
+        tristate "ACPI firmware driver for PATA"
+        depends on ATA_ACPI && ATA_BMDMA
         help
-          This option enables support for Intel SCH PATA on the Intel
-          SCH (US15W, US15L, UL11L) series host controllers.
-
-          If unsure, say N.
+          This option enables an ACPI method driver which drives
+          motherboard PATA controller interfaces through the ACPI
+          firmware in the BIOS. This driver can sometimes handle
+          otherwise unsupported hardware.
 
-config PATA_BF54X
-        tristate "Blackfin 54x ATAPI support"
-        depends on BF542 || BF548 || BF549
+config ATA_GENERIC
+        tristate "Generic ATA support"
+        depends on PCI && ATA_BMDMA
         help
-          This option enables support for the built-in ATAPI controller on
-          Blackfin 54x family chips.
+          This option enables support for generic BIOS configured
+          ATA controllers via the new ATA layer
 
           If unsure, say N.
 
-config PATA_MACIO
-        tristate "Apple PowerMac/PowerBook internal 'MacIO' IDE"
-        depends on PPC_PMAC
+config PATA_LEGACY
+        tristate "Legacy ISA PATA support (Experimental)"
+        depends on (ISA || PCI) && EXPERIMENTAL
         help
-          Most IDE capable PowerMacs have IDE busses driven by a variant
-          of this controller which is part of the Apple chipset used on
-          most PowerMac models. Some models have multiple busses using
-          different chipsets, though generally, MacIO is one of them.
+          This option enables support for ISA/VLB/PCI bus legacy PATA
+          ports and allows them to be accessed via the new ATA layer.
 
+          If unsure, say N.
 
 endif # ATA_SFF
 endif # ATA
diff --git a/drivers/ata/Makefile b/drivers/ata/Makefile
index d0a93c4ad3ec..7ef89d73df63 100644
--- a/drivers/ata/Makefile
+++ b/drivers/ata/Makefile
@@ -1,33 +1,39 @@
 
 obj-$(CONFIG_ATA)               += libata.o
 
+# non-SFF interface
 obj-$(CONFIG_SATA_AHCI)         += ahci.o libahci.o
 obj-$(CONFIG_SATA_AHCI_PLATFORM) += ahci_platform.o libahci.o
-obj-$(CONFIG_SATA_SVW)          += sata_svw.o
+obj-$(CONFIG_SATA_FSL)          += sata_fsl.o
+obj-$(CONFIG_SATA_INIC162X)     += sata_inic162x.o
+obj-$(CONFIG_SATA_SIL24)        += sata_sil24.o
+
+# SFF w/ custom DMA
+obj-$(CONFIG_PDC_ADMA)          += pdc_adma.o
+obj-$(CONFIG_PATA_MPC52xx)      += pata_mpc52xx.o
+obj-$(CONFIG_PATA_OCTEON_CF)    += pata_octeon_cf.o
+obj-$(CONFIG_SATA_QSTOR)        += sata_qstor.o
+obj-$(CONFIG_SATA_SX4)          += sata_sx4.o
+
+# SFF SATA w/ BMDMA
 obj-$(CONFIG_ATA_PIIX)          += ata_piix.o
+obj-$(CONFIG_SATA_MV)           += sata_mv.o
+obj-$(CONFIG_SATA_NV)           += sata_nv.o
 obj-$(CONFIG_SATA_PROMISE)      += sata_promise.o
-obj-$(CONFIG_SATA_QSTOR)        += sata_qstor.o
 obj-$(CONFIG_SATA_SIL)          += sata_sil.o
-obj-$(CONFIG_SATA_SIL24)        += sata_sil24.o
-obj-$(CONFIG_SATA_VIA)          += sata_via.o
-obj-$(CONFIG_SATA_VITESSE)      += sata_vsc.o
 obj-$(CONFIG_SATA_SIS)          += sata_sis.o
-obj-$(CONFIG_SATA_SX4)          += sata_sx4.o
-obj-$(CONFIG_SATA_NV)           += sata_nv.o
+obj-$(CONFIG_SATA_SVW)          += sata_svw.o
 obj-$(CONFIG_SATA_ULI)          += sata_uli.o
-obj-$(CONFIG_SATA_MV)           += sata_mv.o
-obj-$(CONFIG_SATA_INIC162X)     += sata_inic162x.o
-obj-$(CONFIG_PDC_ADMA)          += pdc_adma.o
-obj-$(CONFIG_SATA_FSL)          += sata_fsl.o
-obj-$(CONFIG_PATA_MACIO)        += pata_macio.o
+obj-$(CONFIG_SATA_VIA)          += sata_via.o
+obj-$(CONFIG_SATA_VITESSE)      += sata_vsc.o
 
+# SFF PATA w/ BMDMA
 obj-$(CONFIG_PATA_ALI)          += pata_ali.o
 obj-$(CONFIG_PATA_AMD)          += pata_amd.o
 obj-$(CONFIG_PATA_ARTOP)        += pata_artop.o
-obj-$(CONFIG_PATA_ATP867X)      += pata_atp867x.o
-obj-$(CONFIG_PATA_AT32)         += pata_at32.o
 obj-$(CONFIG_PATA_ATIIXP)       += pata_atiixp.o
-obj-$(CONFIG_PATA_CMD640_PCI)   += pata_cmd640.o
+obj-$(CONFIG_PATA_ATP867X)      += pata_atp867x.o
+obj-$(CONFIG_PATA_BF54X)        += pata_bf54x.o
 obj-$(CONFIG_PATA_CMD64X)       += pata_cmd64x.o
 obj-$(CONFIG_PATA_CS5520)       += pata_cs5520.o
 obj-$(CONFIG_PATA_CS5530)       += pata_cs5530.o
@@ -39,47 +45,50 @@ obj-$(CONFIG_PATA_HPT366)	+= pata_hpt366.o
 obj-$(CONFIG_PATA_HPT37X)       += pata_hpt37x.o
 obj-$(CONFIG_PATA_HPT3X2N)      += pata_hpt3x2n.o
 obj-$(CONFIG_PATA_HPT3X3)       += pata_hpt3x3.o
-obj-$(CONFIG_PATA_ISAPNP)       += pata_isapnp.o
-obj-$(CONFIG_PATA_IT821X)       += pata_it821x.o
+obj-$(CONFIG_PATA_ICSIDE)       += pata_icside.o
 obj-$(CONFIG_PATA_IT8213)       += pata_it8213.o
+obj-$(CONFIG_PATA_IT821X)       += pata_it821x.o
 obj-$(CONFIG_PATA_JMICRON)      += pata_jmicron.o
+obj-$(CONFIG_PATA_MACIO)        += pata_macio.o
+obj-$(CONFIG_PATA_MARVELL)      += pata_marvell.o
 obj-$(CONFIG_PATA_NETCELL)      += pata_netcell.o
 obj-$(CONFIG_PATA_NINJA32)      += pata_ninja32.o
-obj-$(CONFIG_PATA_NS87410)      += pata_ns87410.o
 obj-$(CONFIG_PATA_NS87415)      += pata_ns87415.o
-obj-$(CONFIG_PATA_OPTI)         += pata_opti.o
-obj-$(CONFIG_PATA_OPTIDMA)      += pata_optidma.o
-obj-$(CONFIG_PATA_MPC52xx)      += pata_mpc52xx.o
-obj-$(CONFIG_PATA_MARVELL)      += pata_marvell.o
-obj-$(CONFIG_PATA_MPIIX)        += pata_mpiix.o
 obj-$(CONFIG_PATA_OLDPIIX)      += pata_oldpiix.o
-obj-$(CONFIG_PATA_PALMLD)       += pata_palmld.o
-obj-$(CONFIG_PATA_PCMCIA)       += pata_pcmcia.o
+obj-$(CONFIG_PATA_OPTIDMA)      += pata_optidma.o
 obj-$(CONFIG_PATA_PDC2027X)     += pata_pdc2027x.o
 obj-$(CONFIG_PATA_PDC_OLD)      += pata_pdc202xx_old.o
-obj-$(CONFIG_PATA_QDI)          += pata_qdi.o
 obj-$(CONFIG_PATA_RADISYS)      += pata_radisys.o
-obj-$(CONFIG_PATA_RB532)        += pata_rb532_cf.o
 obj-$(CONFIG_PATA_RDC)          += pata_rdc.o
-obj-$(CONFIG_PATA_RZ1000)       += pata_rz1000.o
 obj-$(CONFIG_PATA_SC1200)       += pata_sc1200.o
+obj-$(CONFIG_PATA_SCC)          += pata_scc.o
+obj-$(CONFIG_PATA_SCH)          += pata_sch.o
 obj-$(CONFIG_PATA_SERVERWORKS)  += pata_serverworks.o
 obj-$(CONFIG_PATA_SIL680)       += pata_sil680.o
+obj-$(CONFIG_PATA_SIS)          += pata_sis.o
 obj-$(CONFIG_PATA_TOSHIBA)      += pata_piccolo.o
+obj-$(CONFIG_PATA_TRIFLEX)      += pata_triflex.o
 obj-$(CONFIG_PATA_VIA)          += pata_via.o
 obj-$(CONFIG_PATA_WINBOND)      += pata_sl82c105.o
-obj-$(CONFIG_PATA_WINBOND_VLB)  += pata_winbond.o
-obj-$(CONFIG_PATA_SIS)          += pata_sis.o
-obj-$(CONFIG_PATA_TRIFLEX)      += pata_triflex.o
+
+# SFF PIO only
+obj-$(CONFIG_PATA_AT32)         += pata_at32.o
+obj-$(CONFIG_PATA_AT91)         += pata_at91.o
+obj-$(CONFIG_PATA_CMD640_PCI)   += pata_cmd640.o
+obj-$(CONFIG_PATA_ISAPNP)       += pata_isapnp.o
 obj-$(CONFIG_PATA_IXP4XX_CF)    += pata_ixp4xx_cf.o
-obj-$(CONFIG_PATA_SCC)          += pata_scc.o
-obj-$(CONFIG_PATA_SCH)          += pata_sch.o
-obj-$(CONFIG_PATA_BF54X)        += pata_bf54x.o
-obj-$(CONFIG_PATA_OCTEON_CF)    += pata_octeon_cf.o
+obj-$(CONFIG_PATA_MPIIX)        += pata_mpiix.o
+obj-$(CONFIG_PATA_NS87410)      += pata_ns87410.o
+obj-$(CONFIG_PATA_OPTI)         += pata_opti.o
+obj-$(CONFIG_PATA_PCMCIA)       += pata_pcmcia.o
+obj-$(CONFIG_PATA_PALMLD)       += pata_palmld.o
 obj-$(CONFIG_PATA_PLATFORM)     += pata_platform.o
-obj-$(CONFIG_PATA_AT91) += pata_at91.o
 obj-$(CONFIG_PATA_OF_PLATFORM)  += pata_of_platform.o
-obj-$(CONFIG_PATA_ICSIDE)       += pata_icside.o
+obj-$(CONFIG_PATA_QDI)          += pata_qdi.o
+obj-$(CONFIG_PATA_RB532)        += pata_rb532_cf.o
+obj-$(CONFIG_PATA_RZ1000)       += pata_rz1000.o
+obj-$(CONFIG_PATA_WINBOND_VLB)  += pata_winbond.o
+
 # Should be last but two libata driver
 obj-$(CONFIG_PATA_ACPI)         += pata_acpi.o
 # Should be last but one libata driver
diff --git a/drivers/ata/ata_generic.c b/drivers/ata/ata_generic.c
index 33fb614f9784..573158a9668d 100644
--- a/drivers/ata/ata_generic.c
+++ b/drivers/ata/ata_generic.c
@@ -155,7 +155,7 @@ static int ata_generic_init_one(struct pci_dev *dev, const struct pci_device_id
                         return rc;
                 pcim_pin_device(dev);
         }
-        return ata_pci_sff_init_one(dev, ppi, &generic_sht, NULL, 0);
+        return ata_pci_bmdma_init_one(dev, ppi, &generic_sht, NULL, 0);
 }
 
 static struct pci_device_id ata_generic[] = {
diff --git a/drivers/ata/ata_piix.c b/drivers/ata/ata_piix.c
index ec52fc618763..7409f98d2ae6 100644
--- a/drivers/ata/ata_piix.c
+++ b/drivers/ata/ata_piix.c
@@ -1589,7 +1589,7 @@ static int __devinit piix_init_one(struct pci_dev *pdev,
                 hpriv->map = piix_init_sata_map(pdev, port_info,
                                         piix_map_db_table[ent->driver_data]);
 
-        rc = ata_pci_sff_prepare_host(pdev, ppi, &host);
+        rc = ata_pci_bmdma_prepare_host(pdev, ppi, &host);
         if (rc)
                 return rc;
         host->private_data = hpriv;
@@ -1626,7 +1626,7 @@ static int __devinit piix_init_one(struct pci_dev *pdev,
         host->flags |= ATA_HOST_PARALLEL_SCAN;
 
         pci_set_master(pdev);
-        return ata_pci_sff_activate_host(host, ata_sff_interrupt, &piix_sht);
+        return ata_pci_sff_activate_host(host, ata_bmdma_interrupt, &piix_sht);
 }
 
 static void piix_remove_one(struct pci_dev *pdev)
diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c
index c47373f01f89..06b7e49e039c 100644
--- a/drivers/ata/libata-core.c
+++ b/drivers/ata/libata-core.c
@@ -160,6 +160,10 @@ int libata_allow_tpm = 0;
 module_param_named(allow_tpm, libata_allow_tpm, int, 0444);
 MODULE_PARM_DESC(allow_tpm, "Permit the use of TPM commands (0=off [default], 1=on)");
 
+static int atapi_an;
+module_param(atapi_an, int, 0444);
+MODULE_PARM_DESC(atapi_an, "Enable ATAPI AN media presence notification (0=0ff [default], 1=on)");
+
 MODULE_AUTHOR("Jeff Garzik");
 MODULE_DESCRIPTION("Library module for ATA devices");
 MODULE_LICENSE("GPL");
@@ -2122,6 +2126,14 @@ retry:
                 goto err_out;
         }
 
+        if (dev->horkage & ATA_HORKAGE_DUMP_ID) {
+                ata_dev_printk(dev, KERN_DEBUG, "dumping IDENTIFY data, "
+                               "class=%d may_fallback=%d tried_spinup=%d\n",
+                               class, may_fallback, tried_spinup);
+                print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET,
+                               16, 2, id, ATA_ID_WORDS * sizeof(*id), true);
+        }
+
         /* Falling back doesn't make sense if ID data was read
          * successfully at least once.
          */
@@ -2510,7 +2522,8 @@ int ata_dev_configure(struct ata_device *dev)
                  * to enable ATAPI AN to discern between PHY status
                  * changed notifications and ATAPI ANs.
                  */
-                if ((ap->flags & ATA_FLAG_AN) && ata_id_has_atapi_AN(id) &&
+                if (atapi_an &&
+                    (ap->flags & ATA_FLAG_AN) && ata_id_has_atapi_AN(id) &&
                     (!sata_pmp_attached(ap) ||
                      sata_scr_read(&ap->link, SCR_NOTIFICATION, &sntf) == 0)) {
                         unsigned int err_mask;
@@ -6372,6 +6385,7 @@ static int __init ata_parse_force_one(char **cur,
                 { "3.0Gbps",    .spd_limit      = 2 },
                 { "noncq",      .horkage_on     = ATA_HORKAGE_NONCQ },
                 { "ncq",        .horkage_off    = ATA_HORKAGE_NONCQ },
+                { "dump_id",    .horkage_on     = ATA_HORKAGE_DUMP_ID },
                 { "pio0",       .xfer_mask      = 1 << (ATA_SHIFT_PIO + 0) },
                 { "pio1",       .xfer_mask      = 1 << (ATA_SHIFT_PIO + 1) },
                 { "pio2",       .xfer_mask      = 1 << (ATA_SHIFT_PIO + 2) },
diff --git a/drivers/ata/libata-sff.c b/drivers/ata/libata-sff.c
index 19ddf924944f..efa4a18cfb9d 100644
--- a/drivers/ata/libata-sff.c
+++ b/drivers/ata/libata-sff.c
@@ -63,7 +63,6 @@ const struct ata_port_operations ata_sff_port_ops = {
         .sff_tf_read            = ata_sff_tf_read,
         .sff_exec_command       = ata_sff_exec_command,
         .sff_data_xfer          = ata_sff_data_xfer,
-        .sff_irq_clear          = ata_sff_irq_clear,
         .sff_drain_fifo         = ata_sff_drain_fifo,
 
         .lost_interrupt         = ata_sff_lost_interrupt,
@@ -395,33 +394,12 @@ void ata_sff_irq_on(struct ata_port *ap)
                 ata_sff_set_devctl(ap, ap->ctl);
         ata_wait_idle(ap);
 
-        ap->ops->sff_irq_clear(ap);
+        if (ap->ops->sff_irq_clear)
+                ap->ops->sff_irq_clear(ap);
 }
 EXPORT_SYMBOL_GPL(ata_sff_irq_on);
 
 /**
- *      ata_sff_irq_clear - Clear PCI IDE BMDMA interrupt.
- *      @ap: Port associated with this ATA transaction.
- *
- *      Clear interrupt and error flags in DMA status register.
- *
- *      May be used as the irq_clear() entry in ata_port_operations.
- *
- *      LOCKING:
- *      spin_lock_irqsave(host lock)
- */
-void ata_sff_irq_clear(struct ata_port *ap)
-{
-        void __iomem *mmio = ap->ioaddr.bmdma_addr;
-
-        if (!mmio)
-                return;
-
-        iowrite8(ioread8(mmio + ATA_DMA_STATUS), mmio + ATA_DMA_STATUS);
-}
-EXPORT_SYMBOL_GPL(ata_sff_irq_clear);
-
-/**
  *      ata_sff_tf_load - send taskfile registers to host controller
  *      @ap: Port to which output is sent
  *      @tf: ATA taskfile register set
@@ -820,11 +798,15 @@ static void atapi_send_cdb(struct ata_port *ap, struct ata_queued_cmd *qc)
         case ATAPI_PROT_NODATA:
                 ap->hsm_task_state = HSM_ST_LAST;
                 break;
+#ifdef CONFIG_ATA_BMDMA
         case ATAPI_PROT_DMA:
                 ap->hsm_task_state = HSM_ST_LAST;
                 /* initiate bmdma */
                 ap->ops->bmdma_start(qc);
                 break;
+#endif /* CONFIG_ATA_BMDMA */
+        default:
+                BUG();
         }
 }
 
@@ -1491,27 +1473,27 @@ bool ata_sff_qc_fill_rtf(struct ata_queued_cmd *qc)
 }
 EXPORT_SYMBOL_GPL(ata_sff_qc_fill_rtf);
 
-/**
- *      ata_sff_host_intr - Handle host interrupt for given (port, task)
- *      @ap: Port on which interrupt arrived (possibly...)
- *      @qc: Taskfile currently active in engine
- *
- *      Handle host interrupt for given queued command.  Currently,
- *      only DMA interrupts are handled.  All other commands are
- *      handled via polling with interrupts disabled (nIEN bit).
- *
- *      LOCKING:
- *      spin_lock_irqsave(host lock)
- *
- *      RETURNS:
- *      One if interrupt was handled, zero if not (shared irq).
- */
-unsigned int ata_sff_host_intr(struct ata_port *ap,
-                                      struct ata_queued_cmd *qc)
+static unsigned int ata_sff_idle_irq(struct ata_port *ap)
 {
-        struct ata_eh_info *ehi = &ap->link.eh_info;
-        u8 status, host_stat = 0;
-        bool bmdma_stopped = false;
+        ap->stats.idle_irq++;
+
+#ifdef ATA_IRQ_TRAP
+        if ((ap->stats.idle_irq % 1000) == 0) {
+                ap->ops->sff_check_status(ap);
+                if (ap->ops->sff_irq_clear)
+                        ap->ops->sff_irq_clear(ap);
+                ata_port_printk(ap, KERN_WARNING, "irq trap\n");
+                return 1;
+        }
+#endif
+        return 0;       /* irq not handled */
+}
+
+static unsigned int __ata_sff_port_intr(struct ata_port *ap,
+                                        struct ata_queued_cmd *qc,
+                                        bool hsmv_on_idle)
+{
+        u8 status;
 
         VPRINTK("ata%u: protocol %d task_state %d\n",
                 ap->print_id, qc->tf.protocol, ap->hsm_task_state);
@@ -1528,90 +1510,56 @@ unsigned int ata_sff_host_intr(struct ata_port *ap,
                  * need to check ata_is_atapi(qc->tf.protocol) again.
                  */
                 if (!(qc->dev->flags & ATA_DFLAG_CDB_INTR))
-                        goto idle_irq;
-                break;
-        case HSM_ST_LAST:
-                if (qc->tf.protocol == ATA_PROT_DMA ||
-                    qc->tf.protocol == ATAPI_PROT_DMA) {
-                        /* check status of DMA engine */
-                        host_stat = ap->ops->bmdma_status(ap);
-                        VPRINTK("ata%u: host_stat 0x%X\n",
-                                ap->print_id, host_stat);
-
-                        /* if it's not our irq... */
-                        if (!(host_stat & ATA_DMA_INTR))
-                                goto idle_irq;
-
-                        /* before we do anything else, clear DMA-Start bit */
-                        ap->ops->bmdma_stop(qc);
-                        bmdma_stopped = true;
-
-                        if (unlikely(host_stat & ATA_DMA_ERR)) {
-                                /* error when transfering data to/from memory */
-                                qc->err_mask |= AC_ERR_HOST_BUS;
-                                ap->hsm_task_state = HSM_ST_ERR;
-                        }
-                }
+                        return ata_sff_idle_irq(ap);
                 break;
         case HSM_ST:
+        case HSM_ST_LAST:
                 break;
         default:
-                goto idle_irq;
+                return ata_sff_idle_irq(ap);
         }
 
-
         /* check main status, clearing INTRQ if needed */
         status = ata_sff_irq_status(ap);
         if (status & ATA_BUSY) {
-                if (bmdma_stopped) {
+                if (hsmv_on_idle) {
                         /* BMDMA engine is already stopped, we're screwed */
                         qc->err_mask |= AC_ERR_HSM;
                         ap->hsm_task_state = HSM_ST_ERR;
                 } else
-                        goto idle_irq;
+                        return ata_sff_idle_irq(ap);
         }
 
         /* clear irq events */
-        ap->ops->sff_irq_clear(ap);
+        if (ap->ops->sff_irq_clear)
+                ap->ops->sff_irq_clear(ap);
 
         ata_sff_hsm_move(ap, qc, status, 0);
 
-        if (unlikely(qc->err_mask) && (qc->tf.protocol == ATA_PROT_DMA ||
-                                       qc->tf.protocol == ATAPI_PROT_DMA))
-                ata_ehi_push_desc(ehi, "BMDMA stat 0x%x", host_stat);
-
         return 1;       /* irq handled */
-
-idle_irq:
-        ap->stats.idle_irq++;
-
-#ifdef ATA_IRQ_TRAP
-        if ((ap->stats.idle_irq % 1000) == 0) {
-                ap->ops->sff_check_status(ap);
-                ap->ops->sff_irq_clear(ap);
-                ata_port_printk(ap, KERN_WARNING, "irq trap\n");
-                return 1;
-        }
-#endif
-        return 0;       /* irq not handled */
 }
-EXPORT_SYMBOL_GPL(ata_sff_host_intr);
 
 /**
- *      ata_sff_interrupt - Default ATA host interrupt handler
- *      @irq: irq line (unused)
- *      @dev_instance: pointer to our ata_host information structure
+ *      ata_sff_port_intr - Handle SFF port interrupt
+ *      @ap: Port on which interrupt arrived (possibly...)
+ *      @qc: Taskfile currently active in engine
  *
- *      Default interrupt handler for PCI IDE devices.  Calls
- *      ata_sff_host_intr() for each port that is not disabled.
+ *      Handle port interrupt for given queued command.
  *
  *      LOCKING:
- *      Obtains host lock during operation.
+ *      spin_lock_irqsave(host lock)
  *
  *      RETURNS:
- *      IRQ_NONE or IRQ_HANDLED.
+ *      One if interrupt was handled, zero if not (shared irq).
  */
-irqreturn_t ata_sff_interrupt(int irq, void *dev_instance)
+unsigned int ata_sff_port_intr(struct ata_port *ap, struct ata_queued_cmd *qc)
+{
+        return __ata_sff_port_intr(ap, qc, false);
+}
+EXPORT_SYMBOL_GPL(ata_sff_port_intr);
+
+static inline irqreturn_t __ata_sff_interrupt(int irq, void *dev_instance,
+        unsigned int (*port_intr)(struct ata_port *, struct ata_queued_cmd *))
 {
         struct ata_host *host = dev_instance;
         bool retried = false;
@@ -1631,7 +1579,7 @@ retry:
                 qc = ata_qc_from_tag(ap, ap->link.active_tag);
                 if (qc) {
                         if (!(qc->tf.flags & ATA_TFLAG_POLLING))
-                                handled |= ata_sff_host_intr(ap, qc);
+                                handled |= port_intr(ap, qc);
                         else
                                 polling |= 1 << i;
                 } else
@@ -1658,7 +1606,8 @@ retry:
 
                         if (idle & (1 << i)) {
                                 ap->ops->sff_check_status(ap);
-                                ap->ops->sff_irq_clear(ap);
+                                if (ap->ops->sff_irq_clear)
+                                        ap->ops->sff_irq_clear(ap);
                         } else {
                                 /* clear INTRQ and check if BUSY cleared */
                                 if (!(ap->ops->sff_check_status(ap) & ATA_BUSY))
@@ -1680,6 +1629,25 @@ retry:
 
         return IRQ_RETVAL(handled);
 }
+
+/**
+ *      ata_sff_interrupt - Default SFF ATA host interrupt handler
+ *      @irq: irq line (unused)
+ *      @dev_instance: pointer to our ata_host information structure
+ *
+ *      Default interrupt handler for PCI IDE devices.  Calls
+ *      ata_sff_port_intr() for each port that is not disabled.
+ *
+ *      LOCKING:
+ *      Obtains host lock during operation.
+ *
+ *      RETURNS:
+ *      IRQ_NONE or IRQ_HANDLED.
+ */
+irqreturn_t ata_sff_interrupt(int irq, void *dev_instance)
+{
+        return __ata_sff_interrupt(irq, dev_instance, ata_sff_port_intr);
+}
 EXPORT_SYMBOL_GPL(ata_sff_interrupt);
 
 /**
@@ -1717,7 +1685,7 @@ void ata_sff_lost_interrupt(struct ata_port *ap)
                                                                 status);
         /* Run the host interrupt logic as if the interrupt had not been
            lost */
-        ata_sff_host_intr(ap, qc);
+        ata_sff_port_intr(ap, qc);
 }
 EXPORT_SYMBOL_GPL(ata_sff_lost_interrupt);
 
@@ -1744,7 +1712,8 @@ void ata_sff_freeze(struct ata_port *ap)
          */
         ap->ops->sff_check_status(ap);
 
-        ap->ops->sff_irq_clear(ap);
+        if (ap->ops->sff_irq_clear)
+                ap->ops->sff_irq_clear(ap);
 }
 EXPORT_SYMBOL_GPL(ata_sff_freeze);
 
@@ -1761,7 +1730,8 @@ void ata_sff_thaw(struct ata_port *ap)
 {
         /* clear & re-enable interrupts */
         ap->ops->sff_check_status(ap);
-        ap->ops->sff_irq_clear(ap);
+        if (ap->ops->sff_irq_clear)
+                ap->ops->sff_irq_clear(ap);
         ata_sff_irq_on(ap);
 }
 EXPORT_SYMBOL_GPL(ata_sff_thaw);
@@ -2349,13 +2319,13 @@ int ata_pci_sff_init_host(struct ata_host *host)
 EXPORT_SYMBOL_GPL(ata_pci_sff_init_host);
 
 /**
- *      ata_pci_sff_prepare_host - helper to prepare native PCI ATA host
+ *      ata_pci_sff_prepare_host - helper to prepare PCI PIO-only SFF ATA host
  *      @pdev: target PCI device
  *      @ppi: array of port_info, must be enough for two ports
  *      @r_host: out argument for the initialized ATA host
  *
- *      Helper to allocate ATA host for @pdev, acquire all native PCI
- *      resources and initialize it accordingly in one go.
+ *      Helper to allocate PIO-only SFF ATA host for @pdev, acquire
+ *      all PCI resources and initialize it accordingly in one go.
  *
  *      LOCKING:
  *      Inherited from calling layer (may sleep).
@@ -2385,9 +2355,6 @@ int ata_pci_sff_prepare_host(struct pci_dev *pdev,
         if (rc)
                 goto err_out;
 
-        /* init DMA related stuff */
-        ata_pci_bmdma_init(host);
-
         devres_remove_group(&pdev->dev, NULL);
         *r_host = host;
         return 0;
@@ -2492,8 +2459,21 @@ out:
 }
 EXPORT_SYMBOL_GPL(ata_pci_sff_activate_host);
 
+static const struct ata_port_info *ata_sff_find_valid_pi(
+                                        const struct ata_port_info * const *ppi)
+{
+        int i;
+
+        /* look up the first valid port_info */
+        for (i = 0; i < 2 && ppi[i]; i++)
+                if (ppi[i]->port_ops != &ata_dummy_port_ops)
+                        return ppi[i];
+
+        return NULL;
+}
+
 /**
- *      ata_pci_sff_init_one - Initialize/register PCI IDE host controller
+ *      ata_pci_sff_init_one - Initialize/register PIO-only PCI IDE controller
  *      @pdev: Controller to be initialized
  *      @ppi: array of port_info, must be enough for two ports
  *      @sht: scsi_host_template to use when registering the host
@@ -2502,11 +2482,7 @@ EXPORT_SYMBOL_GPL(ata_pci_sff_activate_host);
  *
  *      This is a helper function which can be called from a driver's
  *      xxx_init_one() probe function if the hardware uses traditional
- *      IDE taskfile registers.
- *
- *      This function calls pci_enable_device(), reserves its register
- *      regions, sets the dma mask, enables bus master mode, and calls
- *      ata_device_add()
+ *      IDE taskfile registers and is PIO only.
  *
  *      ASSUMPTION:
  *      Nobody makes a single channel controller that appears solely as
@@ -2523,20 +2499,13 @@ int ata_pci_sff_init_one(struct pci_dev *pdev,
                  struct scsi_host_template *sht, void *host_priv, int hflag)
 {
         struct device *dev = &pdev->dev;
-        const struct ata_port_info *pi = NULL;
+        const struct ata_port_info *pi;
         struct ata_host *host = NULL;
-        int i, rc;
+        int rc;
 
         DPRINTK("ENTER\n");
 
-        /* look up the first valid port_info */
-        for (i = 0; i < 2 && ppi[i]; i++) {
-                if (ppi[i]->port_ops != &ata_dummy_port_ops) {
-                        pi = ppi[i];
-                        break;
-                }
-        }
-
+        pi = ata_sff_find_valid_pi(ppi);
         if (!pi) {
                 dev_printk(KERN_ERR, &pdev->dev,
                            "no valid port_info specified\n");
@@ -2557,7 +2526,6 @@ int ata_pci_sff_init_one(struct pci_dev *pdev,
         host->private_data = host_priv;
         host->flags |= hflag;
 
-        pci_set_master(pdev);
         rc = ata_pci_sff_activate_host(host, ata_sff_interrupt, sht);
 out:
         if (rc == 0)
@@ -2571,6 +2539,12 @@ EXPORT_SYMBOL_GPL(ata_pci_sff_init_one);
 
 #endif /* CONFIG_PCI */
 
+/*
+ *      BMDMA support
+ */
+
+#ifdef CONFIG_ATA_BMDMA
+
 const struct ata_port_operations ata_bmdma_port_ops = {
         .inherits               = &ata_sff_port_ops,
 
@@ -2580,6 +2554,7 @@ const struct ata_port_operations ata_bmdma_port_ops = {
         .qc_prep                = ata_bmdma_qc_prep,
         .qc_issue               = ata_bmdma_qc_issue,
 
+        .sff_irq_clear          = ata_bmdma_irq_clear,
         .bmdma_setup            = ata_bmdma_setup,
         .bmdma_start            = ata_bmdma_start,
         .bmdma_stop             = ata_bmdma_stop,
@@ -2804,6 +2779,75 @@ unsigned int ata_bmdma_qc_issue(struct ata_queued_cmd *qc)
 EXPORT_SYMBOL_GPL(ata_bmdma_qc_issue);
 
 /**
+ *      ata_bmdma_port_intr - Handle BMDMA port interrupt
+ *      @ap: Port on which interrupt arrived (possibly...)
+ *      @qc: Taskfile currently active in engine
+ *
+ *      Handle port interrupt for given queued command.
+ *
+ *      LOCKING:
+ *      spin_lock_irqsave(host lock)
+ *
+ *      RETURNS:
+ *      One if interrupt was handled, zero if not (shared irq).
+ */
+unsigned int ata_bmdma_port_intr(struct ata_port *ap, struct ata_queued_cmd *qc)
+{
+        struct ata_eh_info *ehi = &ap->link.eh_info;
+        u8 host_stat = 0;
+        bool bmdma_stopped = false;
+        unsigned int handled;
+
+        if (ap->hsm_task_state == HSM_ST_LAST && ata_is_dma(qc->tf.protocol)) {
+                /* check status of DMA engine */
+                host_stat = ap->ops->bmdma_status(ap);
+                VPRINTK("ata%u: host_stat 0x%X\n", ap->print_id, host_stat);
+
+                /* if it's not our irq... */
+                if (!(host_stat & ATA_DMA_INTR))
+                        return ata_sff_idle_irq(ap);
+
+                /* before we do anything else, clear DMA-Start bit */
+                ap->ops->bmdma_stop(qc);
+                bmdma_stopped = true;
+
+                if (unlikely(host_stat & ATA_DMA_ERR)) {
+                        /* error when transfering data to/from memory */
+                        qc->err_mask |= AC_ERR_HOST_BUS;
+                        ap->hsm_task_state = HSM_ST_ERR;
+                }
+        }
+
+        handled = __ata_sff_port_intr(ap, qc, bmdma_stopped);
+
+        if (unlikely(qc->err_mask) && ata_is_dma(qc->tf.protocol))
+                ata_ehi_push_desc(ehi, "BMDMA stat 0x%x", host_stat);
+
+        return handled;
+}
+EXPORT_SYMBOL_GPL(ata_bmdma_port_intr);
+
+/**
+ *      ata_bmdma_interrupt - Default BMDMA ATA host interrupt handler
+ *      @irq: irq line (unused)
+ *      @dev_instance: pointer to our ata_host information structure
+ *
+ *      Default interrupt handler for PCI IDE devices.  Calls
+ *      ata_bmdma_port_intr() for each port that is not disabled.
+ *
+ *      LOCKING:
+ *      Obtains host lock during operation.
+ *
+ *      RETURNS:
+ *      IRQ_NONE or IRQ_HANDLED.
+ */
+irqreturn_t ata_bmdma_interrupt(int irq, void *dev_instance)
+{
+        return __ata_sff_interrupt(irq, dev_instance, ata_bmdma_port_intr);
+}
+EXPORT_SYMBOL_GPL(ata_bmdma_interrupt);
+
+/**
  *      ata_bmdma_error_handler - Stock error handler for BMDMA controller
  *      @ap: port to handle error for
  *
@@ -2848,7 +2892,8 @@ void ata_bmdma_error_handler(struct ata_port *ap)
                 /* if we're gonna thaw, make sure IRQ is clear */
                 if (thaw) {
                         ap->ops->sff_check_status(ap);
-                        ap->ops->sff_irq_clear(ap);
+                        if (ap->ops->sff_irq_clear)
+                                ap->ops->sff_irq_clear(ap);
                 }
         }
 
@@ -2882,6 +2927,28 @@ void ata_bmdma_post_internal_cmd(struct ata_queued_cmd *qc)
 EXPORT_SYMBOL_GPL(ata_bmdma_post_internal_cmd);
 
 /**
+ *      ata_bmdma_irq_clear - Clear PCI IDE BMDMA interrupt.
+ *      @ap: Port associated with this ATA transaction.
+ *
+ *      Clear interrupt and error flags in DMA status register.
+ *
+ *      May be used as the irq_clear() entry in ata_port_operations.
+ *
+ *      LOCKING:
+ *      spin_lock_irqsave(host lock)
+ */
+void ata_bmdma_irq_clear(struct ata_port *ap)
+{
+        void __iomem *mmio = ap->ioaddr.bmdma_addr;
+
+        if (!mmio)
+                return;
+
+        iowrite8(ioread8(mmio + ATA_DMA_STATUS), mmio + ATA_DMA_STATUS);
+}
+EXPORT_SYMBOL_GPL(ata_bmdma_irq_clear);
+
+/**
  *      ata_bmdma_setup - Set up PCI IDE BMDMA transaction
  *      @qc: Info associated with this ATA transaction.
  *
@@ -3137,7 +3204,100 @@ void ata_pci_bmdma_init(struct ata_host *host)
 }
 EXPORT_SYMBOL_GPL(ata_pci_bmdma_init);
 
+/**
+ *      ata_pci_bmdma_prepare_host - helper to prepare PCI BMDMA ATA host
+ *      @pdev: target PCI device
+ *      @ppi: array of port_info, must be enough for two ports
+ *      @r_host: out argument for the initialized ATA host
+ *
+ *      Helper to allocate BMDMA ATA host for @pdev, acquire all PCI
+ *      resources and initialize it accordingly in one go.
+ *
+ *      LOCKING:
+ *      Inherited from calling layer (may sleep).
+ *
+ *      RETURNS:
+ *      0 on success, -errno otherwise.
+ */
+int ata_pci_bmdma_prepare_host(struct pci_dev *pdev,
+                               const struct ata_port_info * const * ppi,
+                               struct ata_host **r_host)
+{
+        int rc;
+
+        rc = ata_pci_sff_prepare_host(pdev, ppi, r_host);
+        if (rc)
+                return rc;
+
+        ata_pci_bmdma_init(*r_host);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(ata_pci_bmdma_prepare_host);
+
+/**
+ *      ata_pci_bmdma_init_one - Initialize/register BMDMA PCI IDE controller
+ *      @pdev: Controller to be initialized
+ *      @ppi: array of port_info, must be enough for two ports
+ *      @sht: scsi_host_template to use when registering the host
+ *      @host_priv: host private_data
+ *      @hflags: host flags
+ *
+ *      This function is similar to ata_pci_sff_init_one() but also
+ *      takes care of BMDMA initialization.
+ *
+ *      LOCKING:
+ *      Inherited from PCI layer (may sleep).
+ *
+ *      RETURNS:
+ *      Zero on success, negative on errno-based value on error.
+ */
+int ata_pci_bmdma_init_one(struct pci_dev *pdev,
+                           const struct ata_port_info * const * ppi,
+                           struct scsi_host_template *sht, void *host_priv,
+                           int hflags)
+{
+        struct device *dev = &pdev->dev;
+        const struct ata_port_info *pi;
+        struct ata_host *host = NULL;
+        int rc;
+
+        DPRINTK("ENTER\n");
+
+        pi = ata_sff_find_valid_pi(ppi);
+        if (!pi) {
+                dev_printk(KERN_ERR, &pdev->dev,
+                           "no valid port_info specified\n");
+                return -EINVAL;
+        }
+
+        if (!devres_open_group(dev, NULL, GFP_KERNEL))
+                return -ENOMEM;
+
+        rc = pcim_enable_device(pdev);
+        if (rc)
+                goto out;
+
+        /* prepare and activate BMDMA host */
+        rc = ata_pci_bmdma_prepare_host(pdev, ppi, &host);
+        if (rc)
+                goto out;
+        host->private_data = host_priv;
+        host->flags |= hflags;
+
+        pci_set_master(pdev);
+        rc = ata_pci_sff_activate_host(host, ata_bmdma_interrupt, sht);
+ out:
+        if (rc == 0)
+                devres_remove_group(&pdev->dev, NULL);
+        else
+                devres_release_group(&pdev->dev, NULL);
+
+        return rc;
+}
+EXPORT_SYMBOL_GPL(ata_pci_bmdma_init_one);
+
 #endif /* CONFIG_PCI */
+#endif /* CONFIG_ATA_BMDMA */
 
 /**
  *      ata_sff_port_init - Initialize SFF/BMDMA ATA port
diff --git a/drivers/ata/pata_acpi.c b/drivers/ata/pata_acpi.c
index 066b9f301ed5..c8d47034d5e9 100644
--- a/drivers/ata/pata_acpi.c
+++ b/drivers/ata/pata_acpi.c
@@ -260,7 +260,7 @@ static int pacpi_init_one (struct pci_dev *pdev, const struct pci_device_id *id)
                         return rc;
                 pcim_pin_device(pdev);
         }
-        return ata_pci_sff_init_one(pdev, ppi, &pacpi_sht, NULL, 0);
+        return ata_pci_bmdma_init_one(pdev, ppi, &pacpi_sht, NULL, 0);
 }
 
 static const struct pci_device_id pacpi_pci_tbl[] = {
diff --git a/drivers/ata/pata_ali.c b/drivers/ata/pata_ali.c
index f306e10c748d..794ec6e3275d 100644
--- a/drivers/ata/pata_ali.c
+++ b/drivers/ata/pata_ali.c
@@ -583,7 +583,10 @@ static int ali_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
                         ppi[0] = &info_20_udma;
         }
 
-        return ata_pci_sff_init_one(pdev, ppi, &ali_sht, NULL, 0);
+        if (!ppi[0]->mwdma_mask && !ppi[0]->udma_mask)
+                return ata_pci_sff_init_one(pdev, ppi, &ali_sht, NULL, 0);
+        else
+                return ata_pci_bmdma_init_one(pdev, ppi, &ali_sht, NULL, 0);
 }
 
 #ifdef CONFIG_PM
diff --git a/drivers/ata/pata_amd.c b/drivers/ata/pata_amd.c
index d95eca9c547e..620a07cabe31 100644
--- a/drivers/ata/pata_amd.c
+++ b/drivers/ata/pata_amd.c
@@ -574,7 +574,7 @@ static int amd_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
         }
 
         /* And fire it up */
-        return ata_pci_sff_init_one(pdev, ppi, &amd_sht, hpriv, 0);
+        return ata_pci_bmdma_init_one(pdev, ppi, &amd_sht, hpriv, 0);
 }
 
 #ifdef CONFIG_PM
diff --git a/drivers/ata/pata_artop.c b/drivers/ata/pata_artop.c
index 4d066d6c30fa..ba43f0f8c880 100644
--- a/drivers/ata/pata_artop.c
+++ b/drivers/ata/pata_artop.c
@@ -421,7 +421,7 @@ static int artop_init_one (struct pci_dev *pdev, const struct pci_device_id *id)
 
         BUG_ON(ppi[0] == NULL);
 
-        return ata_pci_sff_init_one(pdev, ppi, &artop_sht, NULL, 0);
+        return ata_pci_bmdma_init_one(pdev, ppi, &artop_sht, NULL, 0);
 }
 
 static const struct pci_device_id artop_pci_tbl[] = {
diff --git a/drivers/ata/pata_atiixp.c b/drivers/ata/pata_atiixp.c
index 44d88b380ddd..43755616dc5a 100644
--- a/drivers/ata/pata_atiixp.c
+++ b/drivers/ata/pata_atiixp.c
@@ -246,8 +246,8 @@ static int atiixp_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
                 if (!pci_test_config_bits(pdev, &atiixp_enable_bits[i]))
                         ppi[i] = &ata_dummy_port_info;
 
-        return ata_pci_sff_init_one(pdev, ppi, &atiixp_sht, NULL,
-                                                ATA_HOST_PARALLEL_SCAN);
+        return ata_pci_bmdma_init_one(pdev, ppi, &atiixp_sht, NULL,
+                                      ATA_HOST_PARALLEL_SCAN);
 }
 
 static const struct pci_device_id atiixp[] = {
diff --git a/drivers/ata/pata_atp867x.c b/drivers/ata/pata_atp867x.c
index bb6e0746e07d..95295935dd95 100644
--- a/drivers/ata/pata_atp867x.c
+++ b/drivers/ata/pata_atp867x.c
@@ -525,7 +525,7 @@ static int atp867x_init_one(struct pci_dev *pdev,
 
         pci_set_master(pdev);
 
-        rc = ata_host_activate(host, pdev->irq, ata_sff_interrupt,
+        rc = ata_host_activate(host, pdev->irq, ata_bmdma_interrupt,
                                 IRQF_SHARED, &atp867x_sht);
         if (rc)
                 dev_printk(KERN_ERR, &pdev->dev, "failed to activate host\n");
diff --git a/drivers/ata/pata_bf54x.c b/drivers/ata/pata_bf54x.c
index 6422cfd13d0d..9cae65de750e 100644
--- a/drivers/ata/pata_bf54x.c
+++ b/drivers/ata/pata_bf54x.c
@@ -1214,7 +1214,7 @@ static unsigned int bfin_data_xfer(struct ata_device *dev, unsigned char *buf,
  *      bfin_irq_clear - Clear ATAPI interrupt.
  *      @ap: Port associated with this ATA transaction.
  *
- *      Note: Original code is ata_sff_irq_clear().
+ *      Note: Original code is ata_bmdma_irq_clear().
  */
 
 static void bfin_irq_clear(struct ata_port *ap)
diff --git a/drivers/ata/pata_cmd64x.c b/drivers/ata/pata_cmd64x.c
index 4c81a71b8877..9f5da1c7454b 100644
--- a/drivers/ata/pata_cmd64x.c
+++ b/drivers/ata/pata_cmd64x.c
@@ -367,7 +367,7 @@ static int cmd64x_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
         pci_write_config_byte(pdev, UDIDETCR0, 0xF0);
 #endif
 
-        return ata_pci_sff_init_one(pdev, ppi, &cmd64x_sht, NULL, 0);
+        return ata_pci_bmdma_init_one(pdev, ppi, &cmd64x_sht, NULL, 0);
 }
 
 #ifdef CONFIG_PM
diff --git a/drivers/ata/pata_cs5520.c b/drivers/ata/pata_cs5520.c
index 17c5f346ff01..030952f1f97c 100644
--- a/drivers/ata/pata_cs5520.c
+++ b/drivers/ata/pata_cs5520.c
@@ -221,7 +221,7 @@ static int __devinit cs5520_init_one(struct pci_dev *pdev, const struct pci_devi
                         continue;
 
                 rc = devm_request_irq(&pdev->dev, irq[ap->port_no],
-                                      ata_sff_interrupt, 0, DRV_NAME, host);
+                                      ata_bmdma_interrupt, 0, DRV_NAME, host);
                 if (rc)
                         return rc;
 
diff --git a/drivers/ata/pata_cs5530.c b/drivers/ata/pata_cs5530.c
index e809a4233a81..f792330f0d8e 100644
--- a/drivers/ata/pata_cs5530.c
+++ b/drivers/ata/pata_cs5530.c
@@ -324,7 +324,7 @@ static int cs5530_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
                 ppi[1] = &info_palmax_secondary;
 
         /* Now kick off ATA set up */
-        return ata_pci_sff_init_one(pdev, ppi, &cs5530_sht, NULL, 0);
+        return ata_pci_bmdma_init_one(pdev, ppi, &cs5530_sht, NULL, 0);
 }
 
 #ifdef CONFIG_PM
diff --git a/drivers/ata/pata_cs5535.c b/drivers/ata/pata_cs5535.c
index a02e6459fdcc..03a93186aa19 100644
--- a/drivers/ata/pata_cs5535.c
+++ b/drivers/ata/pata_cs5535.c
@@ -198,7 +198,7 @@ static int cs5535_init_one(struct pci_dev *dev, const struct pci_device_id *id)
         rdmsr(ATAC_CH0D1_PIO, timings, dummy);
         if (CS5535_BAD_PIO(timings))
                 wrmsr(ATAC_CH0D1_PIO, 0xF7F4F7F4UL, 0);
-        return ata_pci_sff_init_one(dev, ppi, &cs5535_sht, NULL, 0);
+        return ata_pci_bmdma_init_one(dev, ppi, &cs5535_sht, NULL, 0);
 }
 
 static const struct pci_device_id cs5535[] = {
diff --git a/drivers/ata/pata_cs5536.c b/drivers/ata/pata_cs5536.c
index 914ae3506ff5..21ee23f89e88 100644
--- a/drivers/ata/pata_cs5536.c
+++ b/drivers/ata/pata_cs5536.c
@@ -260,7 +260,7 @@ static int cs5536_init_one(struct pci_dev *dev, const struct pci_device_id *id)
                 return -ENODEV;
         }
 
-        return ata_pci_sff_init_one(dev, ppi, &cs5536_sht, NULL, 0);
+        return ata_pci_bmdma_init_one(dev, ppi, &cs5536_sht, NULL, 0);
 }
 
 static const struct pci_device_id cs5536[] = {
diff --git a/drivers/ata/pata_cypress.c b/drivers/ata/pata_cypress.c
index 0fcc096b8dac..6d915b063d93 100644
--- a/drivers/ata/pata_cypress.c
+++ b/drivers/ata/pata_cypress.c
@@ -138,7 +138,7 @@ static int cy82c693_init_one(struct pci_dev *pdev, const struct pci_device_id *i
         if (PCI_FUNC(pdev->devfn) != 1)
                 return -ENODEV;
 
-        return ata_pci_sff_init_one(pdev, ppi, &cy82c693_sht, NULL, 0);
+        return ata_pci_bmdma_init_one(pdev, ppi, &cy82c693_sht, NULL, 0);
 }
 
 static const struct pci_device_id cy82c693[] = {
diff --git a/drivers/ata/pata_efar.c b/drivers/ata/pata_efar.c
index 3bac0e079691..a08834758ea2 100644
--- a/drivers/ata/pata_efar.c
+++ b/drivers/ata/pata_efar.c
@@ -277,8 +277,8 @@ static int efar_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
                 dev_printk(KERN_DEBUG, &pdev->dev,
                            "version " DRV_VERSION "\n");
 
-        return ata_pci_sff_init_one(pdev, ppi, &efar_sht, NULL,
-                                        ATA_HOST_PARALLEL_SCAN);
+        return ata_pci_bmdma_init_one(pdev, ppi, &efar_sht, NULL,
+                                      ATA_HOST_PARALLEL_SCAN);
 }
 
 static const struct pci_device_id efar_pci_tbl[] = {
diff --git a/drivers/ata/pata_hpt366.c b/drivers/ata/pata_hpt366.c
index 8580eb3cd54d..7688868557b9 100644
--- a/drivers/ata/pata_hpt366.c
+++ b/drivers/ata/pata_hpt366.c
@@ -361,7 +361,7 @@ static int hpt36x_init_one(struct pci_dev *dev, const struct pci_device_id *id)
                         break;
         }
         /* Now kick off ATA set up */
-        return ata_pci_sff_init_one(dev, ppi, &hpt36x_sht, hpriv, 0);
+        return ata_pci_bmdma_init_one(dev, ppi, &hpt36x_sht, hpriv, 0);
 }
 
 #ifdef CONFIG_PM
diff --git a/drivers/ata/pata_hpt37x.c b/drivers/ata/pata_hpt37x.c
index 98b498b6907c..9ae4c0830577 100644
--- a/drivers/ata/pata_hpt37x.c
+++ b/drivers/ata/pata_hpt37x.c
@@ -987,7 +987,7 @@ static int hpt37x_init_one(struct pci_dev *dev, const struct pci_device_id *id)
         }
 
         /* Now kick off ATA set up */
-        return ata_pci_sff_init_one(dev, ppi, &hpt37x_sht, private_data, 0);
+        return ata_pci_bmdma_init_one(dev, ppi, &hpt37x_sht, private_data, 0);
 }
 
 static const struct pci_device_id hpt37x[] = {
diff --git a/drivers/ata/pata_hpt3x2n.c b/drivers/ata/pata_hpt3x2n.c
index 8b95aeba0e74..32f3463216b8 100644
--- a/drivers/ata/pata_hpt3x2n.c
+++ b/drivers/ata/pata_hpt3x2n.c
@@ -548,7 +548,7 @@ static int hpt3x2n_init_one(struct pci_dev *dev, const struct pci_device_id *id)
                 outb(inb(iobase + 0x9c) | 0x04, iobase + 0x9c);
 
         /* Now kick off ATA set up */
-        return ata_pci_sff_init_one(dev, ppi, &hpt3x2n_sht, hpriv, 0);
+        return ata_pci_bmdma_init_one(dev, ppi, &hpt3x2n_sht, hpriv, 0);
 }
 
 static const struct pci_device_id hpt3x2n[] = {
diff --git a/drivers/ata/pata_hpt3x3.c b/drivers/ata/pata_hpt3x3.c
index 727a81ce4c9f..b63d5e2d4628 100644
--- a/drivers/ata/pata_hpt3x3.c
+++ b/drivers/ata/pata_hpt3x3.c
@@ -248,7 +248,7 @@ static int hpt3x3_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
                 ata_port_pbar_desc(ap, 4, offset_cmd[i], "cmd");
         }
         pci_set_master(pdev);
-        return ata_host_activate(host, pdev->irq, ata_sff_interrupt,
+        return ata_host_activate(host, pdev->irq, ata_bmdma_interrupt,
                                  IRQF_SHARED, &hpt3x3_sht);
 }
 
diff --git a/drivers/ata/pata_icside.c b/drivers/ata/pata_icside.c
index b56e8f722d20..9f2889fe43b2 100644
--- a/drivers/ata/pata_icside.c
+++ b/drivers/ata/pata_icside.c
@@ -470,7 +470,7 @@ static int __devinit pata_icside_add_ports(struct pata_icside_info *info)
                 pata_icside_setup_ioaddr(ap, info->base, info, info->port[i]);
         }
 
-        return ata_host_activate(host, ec->irq, ata_sff_interrupt, 0,
+        return ata_host_activate(host, ec->irq, ata_bmdma_interrupt, 0,
                                  &pata_icside_sht);
 }
 
diff --git a/drivers/ata/pata_it8213.c b/drivers/ata/pata_it8213.c
index f971f0de88e6..4d142a2ab8fd 100644
--- a/drivers/ata/pata_it8213.c
+++ b/drivers/ata/pata_it8213.c
@@ -273,7 +273,7 @@ static int it8213_init_one (struct pci_dev *pdev, const struct pci_device_id *en
                 dev_printk(KERN_DEBUG, &pdev->dev,
                            "version " DRV_VERSION "\n");
 
-        return ata_pci_sff_init_one(pdev, ppi, &it8213_sht, NULL, 0);
+        return ata_pci_bmdma_init_one(pdev, ppi, &it8213_sht, NULL, 0);
 }
 
 static const struct pci_device_id it8213_pci_tbl[] = {
diff --git a/drivers/ata/pata_it821x.c b/drivers/ata/pata_it821x.c
index 2bd2b002d14a..bf88f71a21f4 100644
--- a/drivers/ata/pata_it821x.c
+++ b/drivers/ata/pata_it821x.c
@@ -933,7 +933,7 @@ static int it821x_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
                 else
                         ppi[0] = &info_smart;
         }
-        return ata_pci_sff_init_one(pdev, ppi, &it821x_sht, NULL, 0);
+        return ata_pci_bmdma_init_one(pdev, ppi, &it821x_sht, NULL, 0);
 }
 
 #ifdef CONFIG_PM
diff --git a/drivers/ata/pata_jmicron.c b/drivers/ata/pata_jmicron.c
index 565e01e6ac7c..cb3babbb7035 100644
--- a/drivers/ata/pata_jmicron.c
+++ b/drivers/ata/pata_jmicron.c
@@ -144,7 +144,7 @@ static int jmicron_init_one (struct pci_dev *pdev, const struct pci_device_id *i
         };
         const struct ata_port_info *ppi[] = { &info, NULL };
 
-        return ata_pci_sff_init_one(pdev, ppi, &jmicron_sht, NULL, 0);
+        return ata_pci_bmdma_init_one(pdev, ppi, &jmicron_sht, NULL, 0);
 }
 
 static const struct pci_device_id jmicron_pci_tbl[] = {
diff --git a/drivers/ata/pata_macio.c b/drivers/ata/pata_macio.c
index b5b48e703cb7..76640ac76888 100644
--- a/drivers/ata/pata_macio.c
+++ b/drivers/ata/pata_macio.c
@@ -1110,7 +1110,7 @@ static int __devinit pata_macio_common_init(struct pata_macio_priv	*priv,
 
         /* Start it up */
         priv->irq = irq;
-        return ata_host_activate(priv->host, irq, ata_sff_interrupt, 0,
+        return ata_host_activate(priv->host, irq, ata_bmdma_interrupt, 0,
                                  &pata_macio_sht);
 }
 
diff --git a/drivers/ata/pata_marvell.c b/drivers/ata/pata_marvell.c
index e8ca02e5a71d..dd38083dcbeb 100644
--- a/drivers/ata/pata_marvell.c
+++ b/drivers/ata/pata_marvell.c
@@ -153,7 +153,7 @@ static int marvell_init_one (struct pci_dev *pdev, const struct pci_device_id *i
                 return -ENODEV;
         }
 #endif
-        return ata_pci_sff_init_one(pdev, ppi, &marvell_sht, NULL, 0);
+        return ata_pci_bmdma_init_one(pdev, ppi, &marvell_sht, NULL, 0);
 }
 
 static const struct pci_device_id marvell_pci_tbl[] = {
diff --git a/drivers/ata/pata_mpc52xx.c b/drivers/ata/pata_mpc52xx.c
index 36afe2c1c747..f087ab55b1df 100644
--- a/drivers/ata/pata_mpc52xx.c
+++ b/drivers/ata/pata_mpc52xx.c
@@ -659,7 +659,7 @@ mpc52xx_ata_init_one(struct device *dev, struct mpc52xx_ata_priv *priv,
         ata_port_desc(ap, "ata_regs 0x%lx", raw_ata_regs);
 
         /* activate host */
-        return ata_host_activate(host, priv->ata_irq, ata_sff_interrupt, 0,
+        return ata_host_activate(host, priv->ata_irq, ata_bmdma_interrupt, 0,
                                  &mpc52xx_ata_sht);
 }
 
diff --git a/drivers/ata/pata_netcell.c b/drivers/ata/pata_netcell.c
index 94f979a7f4f7..3eb921c746a1 100644
--- a/drivers/ata/pata_netcell.c
+++ b/drivers/ata/pata_netcell.c
@@ -82,7 +82,7 @@ static int netcell_init_one (struct pci_dev *pdev, const struct pci_device_id *e
         ata_pci_bmdma_clear_simplex(pdev);
 
         /* And let the library code do the work */
-        return ata_pci_sff_init_one(pdev, port_info, &netcell_sht, NULL, 0);
+        return ata_pci_bmdma_init_one(pdev, port_info, &netcell_sht, NULL, 0);
 }
 
 static const struct pci_device_id netcell_pci_tbl[] = {
diff --git a/drivers/ata/pata_ninja32.c b/drivers/ata/pata_ninja32.c
index dd53a66b19e3..cc50bd09aa26 100644
--- a/drivers/ata/pata_ninja32.c
+++ b/drivers/ata/pata_ninja32.c
@@ -149,7 +149,7 @@ static int ninja32_init_one(struct pci_dev *dev, const struct pci_device_id *id)
 
         ninja32_program(base);
         /* FIXME: Should we disable them at remove ? */
-        return ata_host_activate(host, dev->irq, ata_sff_interrupt,
+        return ata_host_activate(host, dev->irq, ata_bmdma_interrupt,
                                  IRQF_SHARED, &ninja32_sht);
 }
 
diff --git a/drivers/ata/pata_ns87415.c b/drivers/ata/pata_ns87415.c
index fdbba2d76d3e..605f198f958c 100644
--- a/drivers/ata/pata_ns87415.c
+++ b/drivers/ata/pata_ns87415.c
@@ -380,7 +380,7 @@ static int ns87415_init_one (struct pci_dev *pdev, const struct pci_device_id *e
 
         ns87415_fixup(pdev);
 
-        return ata_pci_sff_init_one(pdev, ppi, &ns87415_sht, NULL, 0);
+        return ata_pci_bmdma_init_one(pdev, ppi, &ns87415_sht, NULL, 0);
 }
 
 static const struct pci_device_id ns87415_pci_tbl[] = {
diff --git a/drivers/ata/pata_octeon_cf.c b/drivers/ata/pata_octeon_cf.c
index 3001109352ea..06ddd91ffeda 100644
--- a/drivers/ata/pata_octeon_cf.c
+++ b/drivers/ata/pata_octeon_cf.c
@@ -750,20 +750,6 @@ static void octeon_cf_dev_config(struct ata_device *dev)
 }
 
 /*
- * Trap if driver tries to do standard bmdma commands.  They are not
- * supported.
- */
-static void unreachable_qc(struct ata_queued_cmd *qc)
-{
-        BUG();
-}
-
-static u8 unreachable_port(struct ata_port *ap)
-{
-        BUG();
-}
-
-/*
  * We don't do ATAPI DMA so return 0.
  */
 static int octeon_cf_check_atapi_dma(struct ata_queued_cmd *qc)
@@ -804,10 +790,6 @@ static struct ata_port_operations octeon_cf_ops = {
         .sff_dev_select         = octeon_cf_dev_select,
         .sff_irq_on             = octeon_cf_irq_on,
         .sff_irq_clear          = octeon_cf_irq_clear,
-        .bmdma_setup            = unreachable_qc,
-        .bmdma_start            = unreachable_qc,
-        .bmdma_stop             = unreachable_qc,
-        .bmdma_status           = unreachable_port,
         .cable_detect           = ata_cable_40wire,
         .set_piomode            = octeon_cf_set_piomode,
         .set_dmamode            = octeon_cf_set_dmamode,
diff --git a/drivers/ata/pata_oldpiix.c b/drivers/ata/pata_oldpiix.c
index 988ef2627be3..b811c1636204 100644
--- a/drivers/ata/pata_oldpiix.c
+++ b/drivers/ata/pata_oldpiix.c
@@ -248,7 +248,7 @@ static int oldpiix_init_one (struct pci_dev *pdev, const struct pci_device_id *e
                 dev_printk(KERN_DEBUG, &pdev->dev,
                            "version " DRV_VERSION "\n");
 
-        return ata_pci_sff_init_one(pdev, ppi, &oldpiix_sht, NULL, 0);
+        return ata_pci_bmdma_init_one(pdev, ppi, &oldpiix_sht, NULL, 0);
 }
 
 static const struct pci_device_id oldpiix_pci_tbl[] = {
diff --git a/drivers/ata/pata_optidma.c b/drivers/ata/pata_optidma.c
index 76b7d12b1e8d..0852cd07de08 100644
--- a/drivers/ata/pata_optidma.c
+++ b/drivers/ata/pata_optidma.c
@@ -429,7 +429,7 @@ static int optidma_init_one(struct pci_dev *dev, const struct pci_device_id *id)
         if (optiplus_with_udma(dev))
                 ppi[0] = &info_82c700_udma;
 
-        return ata_pci_sff_init_one(dev, ppi, &optidma_sht, NULL, 0);
+        return ata_pci_bmdma_init_one(dev, ppi, &optidma_sht, NULL, 0);
 }
 
 static const struct pci_device_id optidma[] = {
diff --git a/drivers/ata/pata_pdc2027x.c b/drivers/ata/pata_pdc2027x.c
index 09f1f22c0307..b18351122525 100644
--- a/drivers/ata/pata_pdc2027x.c
+++ b/drivers/ata/pata_pdc2027x.c
@@ -754,7 +754,7 @@ static int __devinit pdc2027x_init_one(struct pci_dev *pdev, const struct pci_de
                 return -EIO;
 
         pci_set_master(pdev);
-        return ata_host_activate(host, pdev->irq, ata_sff_interrupt,
+        return ata_host_activate(host, pdev->irq, ata_bmdma_interrupt,
                                  IRQF_SHARED, &pdc2027x_sht);
 }
 
diff --git a/drivers/ata/pata_pdc202xx_old.c b/drivers/ata/pata_pdc202xx_old.c
index fa1e2f3bc0fd..c39f213e1bbc 100644
--- a/drivers/ata/pata_pdc202xx_old.c
+++ b/drivers/ata/pata_pdc202xx_old.c
@@ -337,7 +337,7 @@ static int pdc202xx_init_one(struct pci_dev *dev, const struct pci_device_id *id
                                 return -ENODEV;
                 }
         }
-        return ata_pci_sff_init_one(dev, ppi, &pdc202xx_sht, NULL, 0);
+        return ata_pci_bmdma_init_one(dev, ppi, &pdc202xx_sht, NULL, 0);
 }
 
 static const struct pci_device_id pdc202xx[] = {
diff --git a/drivers/ata/pata_piccolo.c b/drivers/ata/pata_piccolo.c
index 981615414849..cb01bf9496fe 100644
--- a/drivers/ata/pata_piccolo.c
+++ b/drivers/ata/pata_piccolo.c
@@ -95,7 +95,7 @@ static int ata_tosh_init_one(struct pci_dev *dev, const struct pci_device_id *id
         };
         const struct ata_port_info *ppi[] = { &info, &ata_dummy_port_info };
         /* Just one port for the moment */
-        return ata_pci_sff_init_one(dev, ppi, &tosh_sht, NULL, 0);
+        return ata_pci_bmdma_init_one(dev, ppi, &tosh_sht, NULL, 0);
 }
 
 static struct pci_device_id ata_tosh[] = {
diff --git a/drivers/ata/pata_radisys.c b/drivers/ata/pata_radisys.c
index a5fa388e5398..8574b31f1773 100644
--- a/drivers/ata/pata_radisys.c
+++ b/drivers/ata/pata_radisys.c
@@ -227,7 +227,7 @@ static int radisys_init_one (struct pci_dev *pdev, const struct pci_device_id *e
                 dev_printk(KERN_DEBUG, &pdev->dev,
                            "version " DRV_VERSION "\n");
 
-        return ata_pci_sff_init_one(pdev, ppi, &radisys_sht, NULL, 0);
+        return ata_pci_bmdma_init_one(pdev, ppi, &radisys_sht, NULL, 0);
 }
 
 static const struct pci_device_id radisys_pci_tbl[] = {
diff --git a/drivers/ata/pata_rdc.c b/drivers/ata/pata_rdc.c
index 37092cfd7bc6..5fbe9b166c69 100644
--- a/drivers/ata/pata_rdc.c
+++ b/drivers/ata/pata_rdc.c
@@ -344,7 +344,7 @@ static int __devinit rdc_init_one(struct pci_dev *pdev,
          */
         pci_read_config_dword(pdev, 0x54, &hpriv->saved_iocfg);
 
-        rc = ata_pci_sff_prepare_host(pdev, ppi, &host);
+        rc = ata_pci_bmdma_prepare_host(pdev, ppi, &host);
         if (rc)
                 return rc;
         host->private_data = hpriv;
@@ -354,7 +354,7 @@ static int __devinit rdc_init_one(struct pci_dev *pdev,
         host->flags |= ATA_HOST_PARALLEL_SCAN;
 
         pci_set_master(pdev);
-        return ata_pci_sff_activate_host(host, ata_sff_interrupt, &rdc_sht);
+        return ata_pci_sff_activate_host(host, ata_bmdma_interrupt, &rdc_sht);
 }
 
 static void rdc_remove_one(struct pci_dev *pdev)
diff --git a/drivers/ata/pata_sc1200.c b/drivers/ata/pata_sc1200.c
index 6b5b63a2fd8e..e2c18257adff 100644
--- a/drivers/ata/pata_sc1200.c
+++ b/drivers/ata/pata_sc1200.c
@@ -237,7 +237,7 @@ static int sc1200_init_one(struct pci_dev *dev, const struct pci_device_id *id)
         };
         const struct ata_port_info *ppi[] = { &info, NULL };
 
-        return ata_pci_sff_init_one(dev, ppi, &sc1200_sht, NULL, 0);
+        return ata_pci_bmdma_init_one(dev, ppi, &sc1200_sht, NULL, 0);
 }
 
 static const struct pci_device_id sc1200[] = {
diff --git a/drivers/ata/pata_scc.c b/drivers/ata/pata_scc.c
index 6f6193b707cb..d9db3f8d60ef 100644
--- a/drivers/ata/pata_scc.c
+++ b/drivers/ata/pata_scc.c
@@ -875,7 +875,7 @@ static void scc_postreset(struct ata_link *link, unsigned int *classes)
  *      scc_irq_clear - Clear PCI IDE BMDMA interrupt.
  *      @ap: Port associated with this ATA transaction.
  *
- *      Note: Original code is ata_sff_irq_clear().
+ *      Note: Original code is ata_bmdma_irq_clear().
  */
 
 static void scc_irq_clear (struct ata_port *ap)
@@ -1105,7 +1105,7 @@ static int scc_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
         if (rc)
                 return rc;
 
-        return ata_host_activate(host, pdev->irq, ata_sff_interrupt,
+        return ata_host_activate(host, pdev->irq, ata_bmdma_interrupt,
                                  IRQF_SHARED, &scc_sht);
 }
 
diff --git a/drivers/ata/pata_sch.c b/drivers/ata/pata_sch.c
index 86b3d0133c7c..e97b32f03a6e 100644
--- a/drivers/ata/pata_sch.c
+++ b/drivers/ata/pata_sch.c
@@ -179,7 +179,7 @@ static int __devinit sch_init_one(struct pci_dev *pdev,
                 dev_printk(KERN_DEBUG, &pdev->dev,
                            "version " DRV_VERSION "\n");
 
-        return ata_pci_sff_init_one(pdev, ppi, &sch_sht, NULL, 0);
+        return ata_pci_bmdma_init_one(pdev, ppi, &sch_sht, NULL, 0);
 }
 
 static int __init sch_init(void)
diff --git a/drivers/ata/pata_serverworks.c b/drivers/ata/pata_serverworks.c
index 43ea389df2b3..86dd714e3e1d 100644
--- a/drivers/ata/pata_serverworks.c
+++ b/drivers/ata/pata_serverworks.c
@@ -460,7 +460,7 @@ static int serverworks_init_one(struct pci_dev *pdev, const struct pci_device_id
         if (pdev->device == PCI_DEVICE_ID_SERVERWORKS_CSB5IDE)
                 ata_pci_bmdma_clear_simplex(pdev);
 
-        return ata_pci_sff_init_one(pdev, ppi, &serverworks_sht, NULL, 0);
+        return ata_pci_bmdma_init_one(pdev, ppi, &serverworks_sht, NULL, 0);
 }
 
 #ifdef CONFIG_PM
diff --git a/drivers/ata/pata_sil680.c b/drivers/ata/pata_sil680.c
index 43faf106f647..d3190d7ec304 100644
--- a/drivers/ata/pata_sil680.c
+++ b/drivers/ata/pata_sil680.c
@@ -374,11 +374,11 @@ static int __devinit sil680_init_one(struct pci_dev *pdev,
         ata_sff_std_ports(&host->ports[1]->ioaddr);
 
         /* Register & activate */
-        return ata_host_activate(host, pdev->irq, ata_sff_interrupt,
+        return ata_host_activate(host, pdev->irq, ata_bmdma_interrupt,
                                  IRQF_SHARED, &sil680_sht);
 
 use_ioports:
-        return ata_pci_sff_init_one(pdev, ppi, &sil680_sht, NULL, 0);
+        return ata_pci_bmdma_init_one(pdev, ppi, &sil680_sht, NULL, 0);
 }
 
 #ifdef CONFIG_PM
diff --git a/drivers/ata/pata_sis.c b/drivers/ata/pata_sis.c
index b6708032f321..60cea13cccce 100644
--- a/drivers/ata/pata_sis.c
+++ b/drivers/ata/pata_sis.c
@@ -826,7 +826,7 @@ static int sis_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
 
         sis_fixup(pdev, chipset);
 
-        return ata_pci_sff_init_one(pdev, ppi, &sis_sht, chipset, 0);
+        return ata_pci_bmdma_init_one(pdev, ppi, &sis_sht, chipset, 0);
 }
 
 #ifdef CONFIG_PM
diff --git a/drivers/ata/pata_sl82c105.c b/drivers/ata/pata_sl82c105.c
index 733b042a7469..98548f640c8e 100644
--- a/drivers/ata/pata_sl82c105.c
+++ b/drivers/ata/pata_sl82c105.c
@@ -316,7 +316,7 @@ static int sl82c105_init_one(struct pci_dev *dev, const struct pci_device_id *id
         val |= CTRL_P0EN | CTRL_P0F16 | CTRL_P1F16;
         pci_write_config_dword(dev, 0x40, val);
 
-        return ata_pci_sff_init_one(dev, ppi, &sl82c105_sht, NULL, 0);
+        return ata_pci_bmdma_init_one(dev, ppi, &sl82c105_sht, NULL, 0);
 }
 
 static const struct pci_device_id sl82c105[] = {
diff --git a/drivers/ata/pata_triflex.c b/drivers/ata/pata_triflex.c
index 48f50600ed2a..0d1f89e571dd 100644
--- a/drivers/ata/pata_triflex.c
+++ b/drivers/ata/pata_triflex.c
@@ -201,7 +201,7 @@ static int triflex_init_one(struct pci_dev *dev, const struct pci_device_id *id)
         if (!printed_version++)
                 dev_printk(KERN_DEBUG, &dev->dev, "version " DRV_VERSION "\n");
 
-        return ata_pci_sff_init_one(dev, ppi, &triflex_sht, NULL, 0);
+        return ata_pci_bmdma_init_one(dev, ppi, &triflex_sht, NULL, 0);
 }
 
 static const struct pci_device_id triflex[] = {
diff --git a/drivers/ata/pata_via.c b/drivers/ata/pata_via.c
index 7e3e0a5598b7..5e659885de16 100644
--- a/drivers/ata/pata_via.c
+++ b/drivers/ata/pata_via.c
@@ -627,7 +627,7 @@ static int via_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
         }
 
         /* We have established the device type, now fire it up */
-        return ata_pci_sff_init_one(pdev, ppi, &via_sht, (void *)config, 0);
+        return ata_pci_bmdma_init_one(pdev, ppi, &via_sht, (void *)config, 0);
 }
 
 #ifdef CONFIG_PM
diff --git a/drivers/ata/sata_mv.c b/drivers/ata/sata_mv.c
index f3471bc949d3..a476cd99b95d 100644
--- a/drivers/ata/sata_mv.c
+++ b/drivers/ata/sata_mv.c
@@ -675,8 +675,6 @@ static struct ata_port_operations mv5_ops = {
         .freeze                 = mv_eh_freeze,
         .thaw                   = mv_eh_thaw,
         .hardreset              = mv_hardreset,
-        .error_handler          = ata_std_error_handler, /* avoid SFF EH */
-        .post_internal_cmd      = ATA_OP_NULL,
 
         .scr_read               = mv5_scr_read,
         .scr_write              = mv5_scr_write,
@@ -2813,7 +2811,7 @@ static void mv_port_intr(struct ata_port *ap, u32 port_cause)
         } else if (!edma_was_enabled) {
                 struct ata_queued_cmd *qc = mv_get_active_qc(ap);
                 if (qc)
-                        ata_sff_host_intr(ap, qc);
+                        ata_bmdma_port_intr(ap, qc);
                 else
                         mv_unexpected_intr(ap, edma_was_enabled);
         }
diff --git a/drivers/ata/sata_nv.c b/drivers/ata/sata_nv.c
index baa8f0d2c86f..6fd114784116 100644
--- a/drivers/ata/sata_nv.c
+++ b/drivers/ata/sata_nv.c
@@ -920,7 +920,7 @@ static int nv_host_intr(struct ata_port *ap, u8 irq_stat)
         }
 
         /* handle interrupt */
-        return ata_sff_host_intr(ap, qc);
+        return ata_bmdma_port_intr(ap, qc);
 }
 
 static irqreturn_t nv_adma_interrupt(int irq, void *dev_instance)
@@ -1100,7 +1100,7 @@ static void nv_adma_irq_clear(struct ata_port *ap)
         u32 notifier_clears[2];
 
         if (pp->flags & NV_ADMA_ATAPI_SETUP_COMPLETE) {
-                ata_sff_irq_clear(ap);
+                ata_bmdma_irq_clear(ap);
                 return;
         }
 
@@ -1505,7 +1505,7 @@ static irqreturn_t nv_generic_interrupt(int irq, void *dev_instance)
 
                 qc = ata_qc_from_tag(ap, ap->link.active_tag);
                 if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING))) {
-                        handled += ata_sff_host_intr(ap, qc);
+                        handled += ata_bmdma_port_intr(ap, qc);
                 } else {
                         /*
                          * No request pending?  Clear interrupt status
@@ -2430,7 +2430,7 @@ static int nv_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 
         ppi[0] = &nv_port_info[type];
         ipriv = ppi[0]->private_data;
-        rc = ata_pci_sff_prepare_host(pdev, ppi, &host);
+        rc = ata_pci_bmdma_prepare_host(pdev, ppi, &host);
         if (rc)
                 return rc;
 
diff --git a/drivers/ata/sata_qstor.c b/drivers/ata/sata_qstor.c
index d533b3d20ca1..daeebf19a6a9 100644
--- a/drivers/ata/sata_qstor.c
+++ b/drivers/ata/sata_qstor.c
@@ -120,8 +120,6 @@ static void qs_host_stop(struct ata_host *host);
 static void qs_qc_prep(struct ata_queued_cmd *qc);
 static unsigned int qs_qc_issue(struct ata_queued_cmd *qc);
 static int qs_check_atapi_dma(struct ata_queued_cmd *qc);
-static void qs_bmdma_stop(struct ata_queued_cmd *qc);
-static u8 qs_bmdma_status(struct ata_port *ap);
 static void qs_freeze(struct ata_port *ap);
 static void qs_thaw(struct ata_port *ap);
 static int qs_prereset(struct ata_link *link, unsigned long deadline);
@@ -137,8 +135,6 @@ static struct ata_port_operations qs_ata_ops = {
         .inherits               = &ata_sff_port_ops,
 
         .check_atapi_dma        = qs_check_atapi_dma,
-        .bmdma_stop             = qs_bmdma_stop,
-        .bmdma_status           = qs_bmdma_status,
         .qc_prep                = qs_qc_prep,
         .qc_issue               = qs_qc_issue,
 
@@ -190,16 +186,6 @@ static int qs_check_atapi_dma(struct ata_queued_cmd *qc)
         return 1;       /* ATAPI DMA not supported */
 }
 
-static void qs_bmdma_stop(struct ata_queued_cmd *qc)
-{
-        /* nothing */
-}
-
-static u8 qs_bmdma_status(struct ata_port *ap)
-{
-        return 0;
-}
-
 static inline void qs_enter_reg_mode(struct ata_port *ap)
 {
         u8 __iomem *chan = qs_mmio_base(ap->host) + (ap->port_no * 0x4000);
@@ -454,7 +440,7 @@ static inline unsigned int qs_intr_mmio(struct ata_host *host)
                 if (!pp || pp->state != qs_state_mmio)
                         continue;
                 if (!(qc->tf.flags & ATA_TFLAG_POLLING))
-                        handled |= ata_sff_host_intr(ap, qc);
+                        handled |= ata_sff_port_intr(ap, qc);
         }
         return handled;
 }
diff --git a/drivers/ata/sata_sil.c b/drivers/ata/sata_sil.c
index 2dda312b6b9a..3a4f84219719 100644
--- a/drivers/ata/sata_sil.c
+++ b/drivers/ata/sata_sil.c
@@ -503,7 +503,7 @@ static void sil_host_intr(struct ata_port *ap, u32 bmdma2)
                 goto err_hsm;
 
         /* ack bmdma irq events */
-        ata_sff_irq_clear(ap);
+        ata_bmdma_irq_clear(ap);
 
         /* kick HSM in the ass */
         ata_sff_hsm_move(ap, qc, status, 0);
@@ -584,7 +584,7 @@ static void sil_thaw(struct ata_port *ap)
 
         /* clear IRQ */
         ap->ops->sff_check_status(ap);
-        ata_sff_irq_clear(ap);
+        ata_bmdma_irq_clear(ap);
 
         /* turn on SATA IRQ if supported */
         if (!(ap->flags & SIL_FLAG_NO_SATA_IRQ))
diff --git a/drivers/ata/sata_sis.c b/drivers/ata/sata_sis.c
index f8a91bfd66a8..2bfe3ae03976 100644
--- a/drivers/ata/sata_sis.c
+++ b/drivers/ata/sata_sis.c
@@ -279,7 +279,7 @@ static int sis_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
                 break;
         }
 
-        rc = ata_pci_sff_prepare_host(pdev, ppi, &host);
+        rc = ata_pci_bmdma_prepare_host(pdev, ppi, &host);
         if (rc)
                 return rc;
 
@@ -308,7 +308,7 @@ static int sis_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 
         pci_set_master(pdev);
         pci_intx(pdev, 1);
-        return ata_host_activate(host, pdev->irq, ata_sff_interrupt,
+        return ata_host_activate(host, pdev->irq, ata_bmdma_interrupt,
                                  IRQF_SHARED, &sis_sht);
 }
 
diff --git a/drivers/ata/sata_svw.c b/drivers/ata/sata_svw.c
index 101fd6a19829..7d9db4aaf07e 100644
--- a/drivers/ata/sata_svw.c
+++ b/drivers/ata/sata_svw.c
@@ -502,7 +502,7 @@ static int k2_sata_init_one(struct pci_dev *pdev, const struct pci_device_id *en
         writel(0x0, mmio_base + K2_SATA_SIM_OFFSET);
 
         pci_set_master(pdev);
-        return ata_host_activate(host, pdev->irq, ata_sff_interrupt,
+        return ata_host_activate(host, pdev->irq, ata_bmdma_interrupt,
                                  IRQF_SHARED, &k2_sata_sht);
 }
 
diff --git a/drivers/ata/sata_uli.c b/drivers/ata/sata_uli.c
index d8dac17dc2c8..b8578c32d344 100644
--- a/drivers/ata/sata_uli.c
+++ b/drivers/ata/sata_uli.c
@@ -242,7 +242,7 @@ static int uli_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 
         pci_set_master(pdev);
         pci_intx(pdev, 1);
-        return ata_host_activate(host, pdev->irq, ata_sff_interrupt,
+        return ata_host_activate(host, pdev->irq, ata_bmdma_interrupt,
                                  IRQF_SHARED, &uli_sht);
 }
 
diff --git a/drivers/ata/sata_via.c b/drivers/ata/sata_via.c
index 08f65492cc81..101d8c219caf 100644
--- a/drivers/ata/sata_via.c
+++ b/drivers/ata/sata_via.c
@@ -308,7 +308,7 @@ static void svia_noop_freeze(struct ata_port *ap)
          * certain way.  Leave it alone and just clear pending IRQ.
          */
         ap->ops->sff_check_status(ap);
-        ata_sff_irq_clear(ap);
+        ata_bmdma_irq_clear(ap);
 }
 
 /**
@@ -463,7 +463,7 @@ static int vt6420_prepare_host(struct pci_dev *pdev, struct ata_host **r_host)
         struct ata_host *host;
         int rc;
 
-        rc = ata_pci_sff_prepare_host(pdev, ppi, &host);
+        rc = ata_pci_bmdma_prepare_host(pdev, ppi, &host);
         if (rc)
                 return rc;
         *r_host = host;
@@ -520,7 +520,7 @@ static int vt8251_prepare_host(struct pci_dev *pdev, struct ata_host **r_host)
         struct ata_host *host;
         int i, rc;
 
-        rc = ata_pci_sff_prepare_host(pdev, ppi, &host);
+        rc = ata_pci_bmdma_prepare_host(pdev, ppi, &host);
         if (rc)
                 return rc;
         *r_host = host;
@@ -628,7 +628,7 @@ static int svia_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         svia_configure(pdev);
 
         pci_set_master(pdev);
-        return ata_host_activate(host, pdev->irq, ata_sff_interrupt,
+        return ata_host_activate(host, pdev->irq, ata_bmdma_interrupt,
                                  IRQF_SHARED, &svia_sht);
 }
 
diff --git a/drivers/ata/sata_vsc.c b/drivers/ata/sata_vsc.c
index 2107952ebff1..b777176ff494 100644
--- a/drivers/ata/sata_vsc.c
+++ b/drivers/ata/sata_vsc.c
@@ -245,7 +245,7 @@ static void vsc_port_intr(u8 port_status, struct ata_port *ap)
 
         qc = ata_qc_from_tag(ap, ap->link.active_tag);
         if (qc && likely(!(qc->tf.flags & ATA_TFLAG_POLLING)))
-                handled = ata_sff_host_intr(ap, qc);
+                handled = ata_bmdma_port_intr(ap, qc);
 
         /* We received an interrupt during a polled command,
          * or some other spurious condition.  Interrupt reporting
diff --git a/drivers/base/topology.c b/drivers/base/topology.c
index bf6b13206d00..9fc630ce1ddb 100644
--- a/drivers/base/topology.c
+++ b/drivers/base/topology.c
@@ -162,7 +162,7 @@ static int __cpuinit topology_cpu_callback(struct notifier_block *nfb,
                 topology_remove_dev(cpu);
                 break;
         }
-        return rc ? NOTIFY_BAD : NOTIFY_OK;
+        return notifier_from_errno(rc);
 }
 
 static int __cpuinit topology_sysfs_init(void)
diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index e21175be25d0..f09fc0e2062d 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -1121,5 +1121,12 @@ config DEVPORT
 
 source "drivers/s390/char/Kconfig"
 
+config RAMOOPS
+        tristate "Log panic/oops to a RAM buffer"
+        default n
+        help
+          This enables panic and oops messages to be logged to a circular
+          buffer in RAM where it can be read back at some later point.
+
 endmenu
 
diff --git a/drivers/char/Makefile b/drivers/char/Makefile
index d39be4cf1f5d..88d6eac69754 100644
--- a/drivers/char/Makefile
+++ b/drivers/char/Makefile
@@ -108,6 +108,7 @@ obj-$(CONFIG_HANGCHECK_TIMER)	+= hangcheck-timer.o
 obj-$(CONFIG_TCG_TPM)           += tpm/
 
 obj-$(CONFIG_PS3_FLASH)         += ps3flash.o
+obj-$(CONFIG_RAMOOPS)           += ramoops.o
 
 obj-$(CONFIG_JS_RTC)            += js-rtc.o
 js-rtc-y = rtc.o
diff --git a/drivers/char/agp/amd64-agp.c b/drivers/char/agp/amd64-agp.c
index 67ea3a60de74..70312da4c968 100644
--- a/drivers/char/agp/amd64-agp.c
+++ b/drivers/char/agp/amd64-agp.c
@@ -384,7 +384,7 @@ static int __devinit uli_agp_init(struct pci_dev *pdev)
 {
         u32 httfea,baseaddr,enuscr;
         struct pci_dev *dev1;
-        int i;
+        int i, ret;
         unsigned size = amd64_fetch_size();
 
         dev_info(&pdev->dev, "setting up ULi AGP\n");
@@ -400,15 +400,18 @@ static int __devinit uli_agp_init(struct pci_dev *pdev)
 
         if (i == ARRAY_SIZE(uli_sizes)) {
                 dev_info(&pdev->dev, "no ULi size found for %d\n", size);
-                return -ENODEV;
+                ret = -ENODEV;
+                goto put;
         }
 
         /* shadow x86-64 registers into ULi registers */
         pci_read_config_dword (k8_northbridges[0], AMD64_GARTAPERTUREBASE, &httfea);
 
         /* if x86-64 aperture base is beyond 4G, exit here */
-        if ((httfea & 0x7fff) >> (32 - 25))
-                return -ENODEV;
+        if ((httfea & 0x7fff) >> (32 - 25)) {
+                ret = -ENODEV;
+                goto put;
+        }
 
         httfea = (httfea& 0x7fff) << 25;
 
@@ -420,9 +423,10 @@ static int __devinit uli_agp_init(struct pci_dev *pdev)
         enuscr= httfea+ (size * 1024 * 1024) - 1;
         pci_write_config_dword(dev1, ULI_X86_64_HTT_FEA_REG, httfea);
         pci_write_config_dword(dev1, ULI_X86_64_ENU_SCR_REG, enuscr);
-
+        ret = 0;
+put:
         pci_dev_put(dev1);
-        return 0;
+        return ret;
 }
 
 
@@ -441,7 +445,7 @@ static int nforce3_agp_init(struct pci_dev *pdev)
 {
         u32 tmp, apbase, apbar, aplimit;
         struct pci_dev *dev1;
-        int i;
+        int i, ret;
         unsigned size = amd64_fetch_size();
 
         dev_info(&pdev->dev, "setting up Nforce3 AGP\n");
@@ -458,7 +462,8 @@ static int nforce3_agp_init(struct pci_dev *pdev)
 
         if (i == ARRAY_SIZE(nforce3_sizes)) {
                 dev_info(&pdev->dev, "no NForce3 size found for %d\n", size);
-                return -ENODEV;
+                ret = -ENODEV;
+                goto put;
         }
 
         pci_read_config_dword(dev1, NVIDIA_X86_64_1_APSIZE, &tmp);
@@ -472,7 +477,8 @@ static int nforce3_agp_init(struct pci_dev *pdev)
         /* if x86-64 aperture base is beyond 4G, exit here */
         if ( (apbase & 0x7fff) >> (32 - 25) ) {
                 dev_info(&pdev->dev, "aperture base > 4G\n");
-                return -ENODEV;
+                ret = -ENODEV;
+                goto put;
         }
 
         apbase = (apbase & 0x7fff) << 25;
@@ -488,9 +494,11 @@ static int nforce3_agp_init(struct pci_dev *pdev)
         pci_write_config_dword(dev1, NVIDIA_X86_64_1_APBASE2, apbase);
         pci_write_config_dword(dev1, NVIDIA_X86_64_1_APLIMIT2, aplimit);
 
+        ret = 0;
+put:
         pci_dev_put(dev1);
 
-        return 0;
+        return ret;
 }
 
 static int __devinit agp_amd64_probe(struct pci_dev *pdev,
diff --git a/drivers/char/amiserial.c b/drivers/char/amiserial.c
index 56b27671adc4..4f8d60c25a98 100644
--- a/drivers/char/amiserial.c
+++ b/drivers/char/amiserial.c
@@ -84,6 +84,7 @@ static char *serial_version = "4.30";
 #include <linux/smp_lock.h>
 #include <linux/init.h>
 #include <linux/bitops.h>
+#include <linux/platform_device.h>
 
 #include <asm/setup.h>
 
@@ -1954,29 +1955,16 @@ static const struct tty_operations serial_ops = {
 /*
  * The serial driver boot-time initialization code!
  */
-static int __init rs_init(void)
+static int __init amiga_serial_probe(struct platform_device *pdev)
 {
         unsigned long flags;
         struct serial_state * state;
         int error;
 
-        if (!MACH_IS_AMIGA || !AMIGAHW_PRESENT(AMI_SERIAL))
-                return -ENODEV;
-
         serial_driver = alloc_tty_driver(1);
         if (!serial_driver)
                 return -ENOMEM;
 
-        /*
-         *  We request SERDAT and SERPER only, because the serial registers are
-         *  too spreaded over the custom register space
-         */
-        if (!request_mem_region(CUSTOM_PHYSADDR+0x30, 4,
-                                "amiserial [Paula]")) {
-                error = -EBUSY;
-                goto fail_put_tty_driver;
-        }
-
         IRQ_ports = NULL;
 
         show_serial_version();
@@ -1998,7 +1986,7 @@ static int __init rs_init(void)
 
         error = tty_register_driver(serial_driver);
         if (error)
-                goto fail_release_mem_region;
+                goto fail_put_tty_driver;
 
         state = rs_table;
         state->magic = SSTATE_MAGIC;
@@ -2050,23 +2038,24 @@ static int __init rs_init(void)
         ciab.ddra |= (SER_DTR | SER_RTS);   /* outputs */
         ciab.ddra &= ~(SER_DCD | SER_CTS | SER_DSR);  /* inputs */
 
+        platform_set_drvdata(pdev, state);
+
         return 0;
 
 fail_free_irq:
         free_irq(IRQ_AMIGA_TBE, state);
 fail_unregister:
         tty_unregister_driver(serial_driver);
-fail_release_mem_region:
-        release_mem_region(CUSTOM_PHYSADDR+0x30, 4);
 fail_put_tty_driver:
         put_tty_driver(serial_driver);
         return error;
 }
 
-static __exit void rs_exit(void) 
+static int __exit amiga_serial_remove(struct platform_device *pdev)
 {
         int error;
-        struct async_struct *info = rs_table[0].info;
+        struct serial_state *state = platform_get_drvdata(pdev);
+        struct async_struct *info = state->info;
 
         /* printk("Unloading %s: version %s\n", serial_name, serial_version); */
         tasklet_kill(&info->tlet);
@@ -2075,19 +2064,38 @@ static __exit void rs_exit(void)
                        error);
         put_tty_driver(serial_driver);
 
-        if (info) {
-          rs_table[0].info = NULL;
-          kfree(info);
-        }
+        rs_table[0].info = NULL;
+        kfree(info);
 
         free_irq(IRQ_AMIGA_TBE, rs_table);
         free_irq(IRQ_AMIGA_RBF, rs_table);
 
-        release_mem_region(CUSTOM_PHYSADDR+0x30, 4);
+        platform_set_drvdata(pdev, NULL);
+
+        return error;
+}
+
+static struct platform_driver amiga_serial_driver = {
+        .remove = __exit_p(amiga_serial_remove),
+        .driver   = {
+                .name   = "amiga-serial",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init amiga_serial_init(void)
+{
+        return platform_driver_probe(&amiga_serial_driver, amiga_serial_probe);
+}
+
+module_init(amiga_serial_init);
+
+static void __exit amiga_serial_exit(void)
+{
+        platform_driver_unregister(&amiga_serial_driver);
 }
 
-module_init(rs_init)
-module_exit(rs_exit)
+module_exit(amiga_serial_exit);
 
 
 #if defined(CONFIG_SERIAL_CONSOLE) && !defined(MODULE)
@@ -2154,3 +2162,4 @@ console_initcall(amiserial_console_init);
 #endif /* CONFIG_SERIAL_CONSOLE && !MODULE */
 
 MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:amiga-serial");
diff --git a/drivers/char/applicom.c b/drivers/char/applicom.c
index 63313a33ba5f..f4ae0e0fb631 100644
--- a/drivers/char/applicom.c
+++ b/drivers/char/applicom.c
@@ -703,14 +703,9 @@ static long ac_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
         /* In general, the device is only openable by root anyway, so we're not
            particularly concerned that bogus ioctls can flood the console. */
 
-        adgl = kmalloc(sizeof(struct st_ram_io), GFP_KERNEL);
-        if (!adgl)
-                return -ENOMEM;
-
-        if (copy_from_user(adgl, argp, sizeof(struct st_ram_io))) {
-                kfree(adgl);
-                return -EFAULT;
-        }
+        adgl = memdup_user(argp, sizeof(struct st_ram_io));
+        if (IS_ERR(adgl))
+                return PTR_ERR(adgl);
 
         lock_kernel();  
         IndexCard = adgl->num_card-1;
diff --git a/drivers/char/ipmi/ipmi_msghandler.c b/drivers/char/ipmi/ipmi_msghandler.c
index c6ad4234378d..4f3f8c9ec262 100644
--- a/drivers/char/ipmi/ipmi_msghandler.c
+++ b/drivers/char/ipmi/ipmi_msghandler.c
@@ -2505,12 +2505,11 @@ static int ipmi_bmc_register(ipmi_smi_t intf, int ifnum,
                         return rv;
                 }
 
-                printk(KERN_INFO
-                       "ipmi: Found new BMC (man_id: 0x%6.6x, "
-                       " prod_id: 0x%4.4x, dev_id: 0x%2.2x)\n",
-                       bmc->id.manufacturer_id,
-                       bmc->id.product_id,
-                       bmc->id.device_id);
+                dev_info(intf->si_dev, "Found new BMC (man_id: 0x%6.6x, "
+                         "prod_id: 0x%4.4x, dev_id: 0x%2.2x)\n",
+                         bmc->id.manufacturer_id,
+                         bmc->id.product_id,
+                         bmc->id.device_id);
         }
 
         /*
@@ -4037,8 +4036,8 @@ static void ipmi_request_event(void)
 
 static struct timer_list ipmi_timer;
 
-/* Call every ~100 ms. */
-#define IPMI_TIMEOUT_TIME       100
+/* Call every ~1000 ms. */
+#define IPMI_TIMEOUT_TIME       1000
 
 /* How many jiffies does it take to get to the timeout time. */
 #define IPMI_TIMEOUT_JIFFIES    ((IPMI_TIMEOUT_TIME * HZ) / 1000)
diff --git a/drivers/char/ipmi/ipmi_si_intf.c b/drivers/char/ipmi/ipmi_si_intf.c
index 47ffe4a90a95..35603dd4e6c5 100644
--- a/drivers/char/ipmi/ipmi_si_intf.c
+++ b/drivers/char/ipmi/ipmi_si_intf.c
@@ -107,6 +107,14 @@ enum si_type {
 };
 static char *si_to_str[] = { "kcs", "smic", "bt" };
 
+enum ipmi_addr_src {
+        SI_INVALID = 0, SI_HOTMOD, SI_HARDCODED, SI_SPMI, SI_ACPI, SI_SMBIOS,
+        SI_PCI, SI_DEVICETREE, SI_DEFAULT
+};
+static char *ipmi_addr_src_to_str[] = { NULL, "hotmod", "hardcoded", "SPMI",
+                                        "ACPI", "SMBIOS", "PCI",
+                                        "device-tree", "default" };
+
 #define DEVICE_NAME "ipmi_si"
 
 static struct platform_driver ipmi_driver = {
@@ -188,7 +196,7 @@ struct smi_info {
         int (*irq_setup)(struct smi_info *info);
         void (*irq_cleanup)(struct smi_info *info);
         unsigned int io_size;
-        char *addr_source; /* ACPI, PCI, SMBIOS, hardcode, default. */
+        enum ipmi_addr_src addr_source; /* ACPI, PCI, SMBIOS, hardcode, etc. */
         void (*addr_source_cleanup)(struct smi_info *info);
         void *addr_source_data;
 
@@ -300,6 +308,7 @@ static int num_max_busy_us;
 
 static int unload_when_empty = 1;
 
+static int add_smi(struct smi_info *smi);
 static int try_smi_init(struct smi_info *smi);
 static void cleanup_one_si(struct smi_info *to_clean);
 
@@ -314,9 +323,14 @@ static void deliver_recv_msg(struct smi_info *smi_info,
 {
         /* Deliver the message to the upper layer with the lock
            released. */
-        spin_unlock(&(smi_info->si_lock));
-        ipmi_smi_msg_received(smi_info->intf, msg);
-        spin_lock(&(smi_info->si_lock));
+
+        if (smi_info->run_to_completion) {
+                ipmi_smi_msg_received(smi_info->intf, msg);
+        } else {
+                spin_unlock(&(smi_info->si_lock));
+                ipmi_smi_msg_received(smi_info->intf, msg);
+                spin_lock(&(smi_info->si_lock));
+        }
 }
 
 static void return_hosed_msg(struct smi_info *smi_info, int cCode)
@@ -445,6 +459,9 @@ static inline void disable_si_irq(struct smi_info *smi_info)
         if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
                 start_disable_irq(smi_info);
                 smi_info->interrupt_disabled = 1;
+                if (!atomic_read(&smi_info->stop_operation))
+                        mod_timer(&smi_info->si_timer,
+                                  jiffies + SI_TIMEOUT_JIFFIES);
         }
 }
 
@@ -576,9 +593,8 @@ static void handle_transaction_done(struct smi_info *smi_info)
                 smi_info->handlers->get_result(smi_info->si_sm, msg, 3);
                 if (msg[2] != 0) {
                         /* Error clearing flags */
-                        printk(KERN_WARNING
-                               "ipmi_si: Error clearing flags: %2.2x\n",
-                               msg[2]);
+                        dev_warn(smi_info->dev,
+                                 "Error clearing flags: %2.2x\n", msg[2]);
                 }
                 if (smi_info->si_state == SI_CLEARING_FLAGS_THEN_SET_IRQ)
                         start_enable_irq(smi_info);
@@ -670,9 +686,8 @@ static void handle_transaction_done(struct smi_info *smi_info)
                 /* We got the flags from the SMI, now handle them. */
                 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
                 if (msg[2] != 0) {
-                        printk(KERN_WARNING
-                               "ipmi_si: Could not enable interrupts"
-                               ", failed get, using polled mode.\n");
+                        dev_warn(smi_info->dev, "Could not enable interrupts"
+                                 ", failed get, using polled mode.\n");
                         smi_info->si_state = SI_NORMAL;
                 } else {
                         msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
@@ -693,11 +708,11 @@ static void handle_transaction_done(struct smi_info *smi_info)
 
                 /* We got the flags from the SMI, now handle them. */
                 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
-                if (msg[2] != 0) {
-                        printk(KERN_WARNING
-                               "ipmi_si: Could not enable interrupts"
-                               ", failed set, using polled mode.\n");
-                }
+                if (msg[2] != 0)
+                        dev_warn(smi_info->dev, "Could not enable interrupts"
+                                 ", failed set, using polled mode.\n");
+                else
+                        smi_info->interrupt_disabled = 0;
                 smi_info->si_state = SI_NORMAL;
                 break;
         }
@@ -709,9 +724,8 @@ static void handle_transaction_done(struct smi_info *smi_info)
                 /* We got the flags from the SMI, now handle them. */
                 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
                 if (msg[2] != 0) {
-                        printk(KERN_WARNING
-                               "ipmi_si: Could not disable interrupts"
-                               ", failed get.\n");
+                        dev_warn(smi_info->dev, "Could not disable interrupts"
+                                 ", failed get.\n");
                         smi_info->si_state = SI_NORMAL;
                 } else {
                         msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
@@ -733,9 +747,8 @@ static void handle_transaction_done(struct smi_info *smi_info)
                 /* We got the flags from the SMI, now handle them. */
                 smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
                 if (msg[2] != 0) {
-                        printk(KERN_WARNING
-                               "ipmi_si: Could not disable interrupts"
-                               ", failed set.\n");
+                        dev_warn(smi_info->dev, "Could not disable interrupts"
+                                 ", failed set.\n");
                 }
                 smi_info->si_state = SI_NORMAL;
                 break;
@@ -877,6 +890,11 @@ static void sender(void                *send_info,
         printk("**Enqueue: %d.%9.9d\n", t.tv_sec, t.tv_usec);
 #endif
 
+        mod_timer(&smi_info->si_timer, jiffies + SI_TIMEOUT_JIFFIES);
+
+        if (smi_info->thread)
+                wake_up_process(smi_info->thread);
+
         if (smi_info->run_to_completion) {
                 /*
                  * If we are running to completion, then throw it in
@@ -997,6 +1015,8 @@ static int ipmi_thread(void *data)
                         ; /* do nothing */
                 else if (smi_result == SI_SM_CALL_WITH_DELAY && busy_wait)
                         schedule();
+                else if (smi_result == SI_SM_IDLE)
+                        schedule_timeout_interruptible(100);
                 else
                         schedule_timeout_interruptible(0);
         }
@@ -1039,6 +1059,7 @@ static void smi_timeout(unsigned long data)
         unsigned long     flags;
         unsigned long     jiffies_now;
         long              time_diff;
+        long              timeout;
 #ifdef DEBUG_TIMING
         struct timeval    t;
 #endif
@@ -1059,9 +1080,9 @@ static void smi_timeout(unsigned long data)
 
         if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
                 /* Running with interrupts, only do long timeouts. */
-                smi_info->si_timer.expires = jiffies + SI_TIMEOUT_JIFFIES;
+                timeout = jiffies + SI_TIMEOUT_JIFFIES;
                 smi_inc_stat(smi_info, long_timeouts);
-                goto do_add_timer;
+                goto do_mod_timer;
         }
 
         /*
@@ -1070,14 +1091,15 @@ static void smi_timeout(unsigned long data)
          */
         if (smi_result == SI_SM_CALL_WITH_DELAY) {
                 smi_inc_stat(smi_info, short_timeouts);
-                smi_info->si_timer.expires = jiffies + 1;
+                timeout = jiffies + 1;
         } else {
                 smi_inc_stat(smi_info, long_timeouts);
-                smi_info->si_timer.expires = jiffies + SI_TIMEOUT_JIFFIES;
+                timeout = jiffies + SI_TIMEOUT_JIFFIES;
         }
 
- do_add_timer:
-        add_timer(&(smi_info->si_timer));
+ do_mod_timer:
+        if (smi_result != SI_SM_IDLE)
+                mod_timer(&(smi_info->si_timer), timeout);
 }
 
 static irqreturn_t si_irq_handler(int irq, void *data)
@@ -1144,10 +1166,10 @@ static int smi_start_processing(void       *send_info,
                 new_smi->thread = kthread_run(ipmi_thread, new_smi,
                                               "kipmi%d", new_smi->intf_num);
                 if (IS_ERR(new_smi->thread)) {
-                        printk(KERN_NOTICE "ipmi_si_intf: Could not start"
-                               " kernel thread due to error %ld, only using"
-                               " timers to drive the interface\n",
-                               PTR_ERR(new_smi->thread));
+                        dev_notice(new_smi->dev, "Could not start"
+                                   " kernel thread due to error %ld, only using"
+                                   " timers to drive the interface\n",
+                                   PTR_ERR(new_smi->thread));
                         new_smi->thread = NULL;
                 }
         }
@@ -1308,14 +1330,13 @@ static int std_irq_setup(struct smi_info *info)
                                  DEVICE_NAME,
                                  info);
         if (rv) {
-                printk(KERN_WARNING
-                       "ipmi_si: %s unable to claim interrupt %d,"
-                       " running polled\n",
-                       DEVICE_NAME, info->irq);
+                dev_warn(info->dev, "%s unable to claim interrupt %d,"
+                         " running polled\n",
+                         DEVICE_NAME, info->irq);
                 info->irq = 0;
         } else {
                 info->irq_cleanup = std_irq_cleanup;
-                printk("  Using irq %d\n", info->irq);
+                dev_info(info->dev, "Using irq %d\n", info->irq);
         }
 
         return rv;
@@ -1406,8 +1427,8 @@ static int port_setup(struct smi_info *info)
                 info->io.outputb = port_outl;
                 break;
         default:
-                printk(KERN_WARNING "ipmi_si: Invalid register size: %d\n",
-                       info->io.regsize);
+                dev_warn(info->dev, "Invalid register size: %d\n",
+                         info->io.regsize);
                 return -EINVAL;
         }
 
@@ -1529,8 +1550,8 @@ static int mem_setup(struct smi_info *info)
                 break;
 #endif
         default:
-                printk(KERN_WARNING "ipmi_si: Invalid register size: %d\n",
-                       info->io.regsize);
+                dev_warn(info->dev, "Invalid register size: %d\n",
+                         info->io.regsize);
                 return -EINVAL;
         }
 
@@ -1755,7 +1776,7 @@ static int hotmod_handler(const char *val, struct kernel_param *kp)
                                 goto out;
                         }
 
-                        info->addr_source = "hotmod";
+                        info->addr_source = SI_HOTMOD;
                         info->si_type = si_type;
                         info->io.addr_data = addr;
                         info->io.addr_type = addr_space;
@@ -1777,7 +1798,9 @@ static int hotmod_handler(const char *val, struct kernel_param *kp)
                                 info->irq_setup = std_irq_setup;
                         info->slave_addr = ipmb;
 
-                        try_smi_init(info);
+                        if (!add_smi(info))
+                                if (try_smi_init(info))
+                                        cleanup_one_si(info);
                 } else {
                         /* remove */
                         struct smi_info *e, *tmp_e;
@@ -1813,7 +1836,8 @@ static __devinit void hardcode_find_bmc(void)
                 if (!info)
                         return;
 
-                info->addr_source = "hardcoded";
+                info->addr_source = SI_HARDCODED;
+                printk(KERN_INFO PFX "probing via hardcoded address\n");
 
                 if (!si_type[i] || strcmp(si_type[i], "kcs") == 0) {
                         info->si_type = SI_KCS;
@@ -1822,8 +1846,7 @@ static __devinit void hardcode_find_bmc(void)
                 } else if (strcmp(si_type[i], "bt") == 0) {
                         info->si_type = SI_BT;
                 } else {
-                        printk(KERN_WARNING
-                               "ipmi_si: Interface type specified "
+                        printk(KERN_WARNING PFX "Interface type specified "
                                "for interface %d, was invalid: %s\n",
                                i, si_type[i]);
                         kfree(info);
@@ -1841,11 +1864,9 @@ static __devinit void hardcode_find_bmc(void)
                         info->io.addr_data = addrs[i];
                         info->io.addr_type = IPMI_MEM_ADDR_SPACE;
                 } else {
-                        printk(KERN_WARNING
-                               "ipmi_si: Interface type specified "
-                               "for interface %d, "
-                               "but port and address were not set or "
-                               "set to zero.\n", i);
+                        printk(KERN_WARNING PFX "Interface type specified "
+                               "for interface %d, but port and address were "
+                               "not set or set to zero.\n", i);
                         kfree(info);
                         continue;
                 }
@@ -1863,7 +1884,9 @@ static __devinit void hardcode_find_bmc(void)
                         info->irq_setup = std_irq_setup;
                 info->slave_addr = slave_addrs[i];
 
-                try_smi_init(info);
+                if (!add_smi(info))
+                        if (try_smi_init(info))
+                                cleanup_one_si(info);
         }
 }
 
@@ -1923,15 +1946,13 @@ static int acpi_gpe_irq_setup(struct smi_info *info)
                                           &ipmi_acpi_gpe,
                                           info);
         if (status != AE_OK) {
-                printk(KERN_WARNING
-                       "ipmi_si: %s unable to claim ACPI GPE %d,"
-                       " running polled\n",
-                       DEVICE_NAME, info->irq);
+                dev_warn(info->dev, "%s unable to claim ACPI GPE %d,"
+                         " running polled\n", DEVICE_NAME, info->irq);
                 info->irq = 0;
                 return -EINVAL;
         } else {
                 info->irq_cleanup = acpi_gpe_irq_cleanup;
-                printk("  Using ACPI GPE %d\n", info->irq);
+                dev_info(info->dev, "Using ACPI GPE %d\n", info->irq);
                 return 0;
         }
 }
@@ -1989,8 +2010,8 @@ static __devinit int try_init_spmi(struct SPMITable *spmi)
         u8               addr_space;
 
         if (spmi->IPMIlegacy != 1) {
-            printk(KERN_INFO "IPMI: Bad SPMI legacy %d\n", spmi->IPMIlegacy);
-            return -ENODEV;
+                printk(KERN_INFO PFX "Bad SPMI legacy %d\n", spmi->IPMIlegacy);
+                return -ENODEV;
         }
 
         if (spmi->addr.space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY)
@@ -2000,11 +2021,12 @@ static __devinit int try_init_spmi(struct SPMITable *spmi)
 
         info = kzalloc(sizeof(*info), GFP_KERNEL);
         if (!info) {
-                printk(KERN_ERR "ipmi_si: Could not allocate SI data (3)\n");
+                printk(KERN_ERR PFX "Could not allocate SI data (3)\n");
                 return -ENOMEM;
         }
 
-        info->addr_source = "SPMI";
+        info->addr_source = SI_SPMI;
+        printk(KERN_INFO PFX "probing via SPMI\n");
 
         /* Figure out the interface type. */
         switch (spmi->InterfaceType) {
@@ -2018,8 +2040,8 @@ static __devinit int try_init_spmi(struct SPMITable *spmi)
                 info->si_type = SI_BT;
                 break;
         default:
-                printk(KERN_INFO "ipmi_si: Unknown ACPI/SPMI SI type %d\n",
-                        spmi->InterfaceType);
+                printk(KERN_INFO PFX "Unknown ACPI/SPMI SI type %d\n",
+                       spmi->InterfaceType);
                 kfree(info);
                 return -EIO;
         }
@@ -2055,13 +2077,12 @@ static __devinit int try_init_spmi(struct SPMITable *spmi)
                 info->io.addr_type = IPMI_IO_ADDR_SPACE;
         } else {
                 kfree(info);
-                printk(KERN_WARNING
-                       "ipmi_si: Unknown ACPI I/O Address type\n");
+                printk(KERN_WARNING PFX "Unknown ACPI I/O Address type\n");
                 return -EIO;
         }
         info->io.addr_data = spmi->addr.address;
 
-        try_smi_init(info);
+        add_smi(info);
 
         return 0;
 }
@@ -2093,6 +2114,7 @@ static int __devinit ipmi_pnp_probe(struct pnp_dev *dev,
 {
         struct acpi_device *acpi_dev;
         struct smi_info *info;
+        struct resource *res;
         acpi_handle handle;
         acpi_status status;
         unsigned long long tmp;
@@ -2105,7 +2127,8 @@ static int __devinit ipmi_pnp_probe(struct pnp_dev *dev,
         if (!info)
                 return -ENOMEM;
 
-        info->addr_source = "ACPI";
+        info->addr_source = SI_ACPI;
+        printk(KERN_INFO PFX "probing via ACPI\n");
 
         handle = acpi_dev->handle;
 
@@ -2125,22 +2148,26 @@ static int __devinit ipmi_pnp_probe(struct pnp_dev *dev,
                 info->si_type = SI_BT;
                 break;
         default:
-                dev_info(&dev->dev, "unknown interface type %lld\n", tmp);
+                dev_info(&dev->dev, "unknown IPMI type %lld\n", tmp);
                 goto err_free;
         }
 
-        if (pnp_port_valid(dev, 0)) {
+        res = pnp_get_resource(dev, IORESOURCE_IO, 0);
+        if (res) {
                 info->io_setup = port_setup;
                 info->io.addr_type = IPMI_IO_ADDR_SPACE;
-                info->io.addr_data = pnp_port_start(dev, 0);
-        } else if (pnp_mem_valid(dev, 0)) {
-                info->io_setup = mem_setup;
-                info->io.addr_type = IPMI_MEM_ADDR_SPACE;
-                info->io.addr_data = pnp_mem_start(dev, 0);
         } else {
+                res = pnp_get_resource(dev, IORESOURCE_MEM, 0);
+                if (res) {
+                        info->io_setup = mem_setup;
+                        info->io.addr_type = IPMI_MEM_ADDR_SPACE;
+                }
+        }
+        if (!res) {
                 dev_err(&dev->dev, "no I/O or memory address\n");
                 goto err_free;
         }
+        info->io.addr_data = res->start;
 
         info->io.regspacing = DEFAULT_REGSPACING;
         info->io.regsize = DEFAULT_REGSPACING;
@@ -2156,10 +2183,14 @@ static int __devinit ipmi_pnp_probe(struct pnp_dev *dev,
                 info->irq_setup = std_irq_setup;
         }
 
-        info->dev = &acpi_dev->dev;
+        info->dev = &dev->dev;
         pnp_set_drvdata(dev, info);
 
-        return try_smi_init(info);
+        dev_info(info->dev, "%pR regsize %d spacing %d irq %d\n",
+                 res, info->io.regsize, info->io.regspacing,
+                 info->irq);
+
+        return add_smi(info);
 
 err_free:
         kfree(info);
@@ -2264,12 +2295,12 @@ static __devinit void try_init_dmi(struct dmi_ipmi_data *ipmi_data)
 
         info = kzalloc(sizeof(*info), GFP_KERNEL);
         if (!info) {
-                printk(KERN_ERR
-                       "ipmi_si: Could not allocate SI data\n");
+                printk(KERN_ERR PFX "Could not allocate SI data\n");
                 return;
         }
 
-        info->addr_source = "SMBIOS";
+        info->addr_source = SI_SMBIOS;
+        printk(KERN_INFO PFX "probing via SMBIOS\n");
 
         switch (ipmi_data->type) {
         case 0x01: /* KCS */
@@ -2299,8 +2330,7 @@ static __devinit void try_init_dmi(struct dmi_ipmi_data *ipmi_data)
 
         default:
                 kfree(info);
-                printk(KERN_WARNING
-                       "ipmi_si: Unknown SMBIOS I/O Address type: %d.\n",
+                printk(KERN_WARNING PFX "Unknown SMBIOS I/O Address type: %d\n",
                        ipmi_data->addr_space);
                 return;
         }
@@ -2318,7 +2348,7 @@ static __devinit void try_init_dmi(struct dmi_ipmi_data *ipmi_data)
         if (info->irq)
                 info->irq_setup = std_irq_setup;
 
-        try_smi_init(info);
+        add_smi(info);
 }
 
 static void __devinit dmi_find_bmc(void)
@@ -2368,7 +2398,8 @@ static int __devinit ipmi_pci_probe(struct pci_dev *pdev,
         if (!info)
                 return -ENOMEM;
 
-        info->addr_source = "PCI";
+        info->addr_source = SI_PCI;
+        dev_info(&pdev->dev, "probing via PCI");
 
         switch (class_type) {
         case PCI_ERMC_CLASSCODE_TYPE_SMIC:
@@ -2385,15 +2416,13 @@ static int __devinit ipmi_pci_probe(struct pci_dev *pdev,
 
         default:
                 kfree(info);
-                printk(KERN_INFO "ipmi_si: %s: Unknown IPMI type: %d\n",
-                       pci_name(pdev), class_type);
+                dev_info(&pdev->dev, "Unknown IPMI type: %d\n", class_type);
                 return -ENOMEM;
         }
 
         rv = pci_enable_device(pdev);
         if (rv) {
-                printk(KERN_ERR "ipmi_si: %s: couldn't enable PCI device\n",
-                       pci_name(pdev));
+                dev_err(&pdev->dev, "couldn't enable PCI device\n");
                 kfree(info);
                 return rv;
         }
@@ -2421,7 +2450,11 @@ static int __devinit ipmi_pci_probe(struct pci_dev *pdev,
         info->dev = &pdev->dev;
         pci_set_drvdata(pdev, info);
 
-        return try_smi_init(info);
+        dev_info(&pdev->dev, "%pR regsize %d spacing %d irq %d\n",
+                &pdev->resource[0], info->io.regsize, info->io.regspacing,
+                info->irq);
+
+        return add_smi(info);
 }
 
 static void __devexit ipmi_pci_remove(struct pci_dev *pdev)
@@ -2473,7 +2506,7 @@ static int __devinit ipmi_of_probe(struct of_device *dev,
         int ret;
         int proplen;
 
-        dev_info(&dev->dev, PFX "probing via device tree\n");
+        dev_info(&dev->dev, "probing via device tree\n");
 
         ret = of_address_to_resource(np, 0, &resource);
         if (ret) {
@@ -2503,12 +2536,12 @@ static int __devinit ipmi_of_probe(struct of_device *dev,
 
         if (!info) {
                 dev_err(&dev->dev,
-                        PFX "could not allocate memory for OF probe\n");
+                        "could not allocate memory for OF probe\n");
                 return -ENOMEM;
         }
 
         info->si_type           = (enum si_type) match->data;
-        info->addr_source       = "device-tree";
+        info->addr_source       = SI_DEVICETREE;
         info->irq_setup         = std_irq_setup;
 
         if (resource.flags & IORESOURCE_IO) {
@@ -2528,13 +2561,13 @@ static int __devinit ipmi_of_probe(struct of_device *dev,
         info->irq               = irq_of_parse_and_map(dev->dev.of_node, 0);
         info->dev               = &dev->dev;
 
-        dev_dbg(&dev->dev, "addr 0x%lx regsize %d spacing %d irq %x\n",
+        dev_dbg(&dev->dev, "addr 0x%lx regsize %d spacing %d irq %d\n",
                 info->io.addr_data, info->io.regsize, info->io.regspacing,
                 info->irq);
 
         dev_set_drvdata(&dev->dev, info);
 
-        return try_smi_init(info);
+        return add_smi(info);
 }
 
 static int __devexit ipmi_of_remove(struct of_device *dev)
@@ -2643,9 +2676,8 @@ static int try_enable_event_buffer(struct smi_info *smi_info)
 
         rv = wait_for_msg_done(smi_info);
         if (rv) {
-                printk(KERN_WARNING
-                       "ipmi_si: Error getting response from get global,"
-                       " enables command, the event buffer is not"
+                printk(KERN_WARNING PFX "Error getting response from get"
+                       " global enables command, the event buffer is not"
                        " enabled.\n");
                 goto out;
         }
@@ -2657,10 +2689,8 @@ static int try_enable_event_buffer(struct smi_info *smi_info)
                         resp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 ||
                         resp[1] != IPMI_GET_BMC_GLOBAL_ENABLES_CMD   ||
                         resp[2] != 0) {
-                printk(KERN_WARNING
-                       "ipmi_si: Invalid return from get global"
-                       " enables command, cannot enable the event"
-                       " buffer.\n");
+                printk(KERN_WARNING PFX "Invalid return from get global"
+                       " enables command, cannot enable the event buffer.\n");
                 rv = -EINVAL;
                 goto out;
         }
@@ -2676,9 +2706,8 @@ static int try_enable_event_buffer(struct smi_info *smi_info)
 
         rv = wait_for_msg_done(smi_info);
         if (rv) {
-                printk(KERN_WARNING
-                       "ipmi_si: Error getting response from set global,"
-                       " enables command, the event buffer is not"
+                printk(KERN_WARNING PFX "Error getting response from set"
+                       " global, enables command, the event buffer is not"
                        " enabled.\n");
                 goto out;
         }
@@ -2689,10 +2718,8 @@ static int try_enable_event_buffer(struct smi_info *smi_info)
         if (resp_len < 3 ||
                         resp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2 ||
                         resp[1] != IPMI_SET_BMC_GLOBAL_ENABLES_CMD) {
-                printk(KERN_WARNING
-                       "ipmi_si: Invalid return from get global,"
-                       "enables command, not enable the event"
-                       " buffer.\n");
+                printk(KERN_WARNING PFX "Invalid return from get global,"
+                       "enables command, not enable the event buffer.\n");
                 rv = -EINVAL;
                 goto out;
         }
@@ -2951,7 +2978,7 @@ static __devinit void default_find_bmc(void)
                 if (!info)
                         return;
 
-                info->addr_source = NULL;
+                info->addr_source = SI_DEFAULT;
 
                 info->si_type = ipmi_defaults[i].type;
                 info->io_setup = port_setup;
@@ -2963,14 +2990,16 @@ static __devinit void default_find_bmc(void)
                 info->io.regsize = DEFAULT_REGSPACING;
                 info->io.regshift = 0;
 
-                if (try_smi_init(info) == 0) {
-                        /* Found one... */
-                        printk(KERN_INFO "ipmi_si: Found default %s state"
-                               " machine at %s address 0x%lx\n",
-                               si_to_str[info->si_type],
-                               addr_space_to_str[info->io.addr_type],
-                               info->io.addr_data);
-                        return;
+                if (add_smi(info) == 0) {
+                        if ((try_smi_init(info)) == 0) {
+                                /* Found one... */
+                                printk(KERN_INFO PFX "Found default %s"
+                                " state machine at %s address 0x%lx\n",
+                                si_to_str[info->si_type],
+                                addr_space_to_str[info->io.addr_type],
+                                info->io.addr_data);
+                        } else
+                                cleanup_one_si(info);
                 }
         }
 }
@@ -2989,34 +3018,48 @@ static int is_new_interface(struct smi_info *info)
         return 1;
 }
 
-static int try_smi_init(struct smi_info *new_smi)
+static int add_smi(struct smi_info *new_smi)
 {
-        int rv;
-        int i;
-
-        if (new_smi->addr_source) {
-                printk(KERN_INFO "ipmi_si: Trying %s-specified %s state"
-                       " machine at %s address 0x%lx, slave address 0x%x,"
-                       " irq %d\n",
-                       new_smi->addr_source,
-                       si_to_str[new_smi->si_type],
-                       addr_space_to_str[new_smi->io.addr_type],
-                       new_smi->io.addr_data,
-                       new_smi->slave_addr, new_smi->irq);
-        }
+        int rv = 0;
 
+        printk(KERN_INFO PFX "Adding %s-specified %s state machine",
+                        ipmi_addr_src_to_str[new_smi->addr_source],
+                        si_to_str[new_smi->si_type]);
         mutex_lock(&smi_infos_lock);
         if (!is_new_interface(new_smi)) {
-                printk(KERN_WARNING "ipmi_si: duplicate interface\n");
+                printk(KERN_CONT PFX "duplicate interface\n");
                 rv = -EBUSY;
                 goto out_err;
         }
 
+        printk(KERN_CONT "\n");
+
         /* So we know not to free it unless we have allocated one. */
         new_smi->intf = NULL;
         new_smi->si_sm = NULL;
         new_smi->handlers = NULL;
 
+        list_add_tail(&new_smi->link, &smi_infos);
+
+out_err:
+        mutex_unlock(&smi_infos_lock);
+        return rv;
+}
+
+static int try_smi_init(struct smi_info *new_smi)
+{
+        int rv = 0;
+        int i;
+
+        printk(KERN_INFO PFX "Trying %s-specified %s state"
+               " machine at %s address 0x%lx, slave address 0x%x,"
+               " irq %d\n",
+               ipmi_addr_src_to_str[new_smi->addr_source],
+               si_to_str[new_smi->si_type],
+               addr_space_to_str[new_smi->io.addr_type],
+               new_smi->io.addr_data,
+               new_smi->slave_addr, new_smi->irq);
+
         switch (new_smi->si_type) {
         case SI_KCS:
                 new_smi->handlers = &kcs_smi_handlers;
@@ -3039,7 +3082,8 @@ static int try_smi_init(struct smi_info *new_smi)
         /* Allocate the state machine's data and initialize it. */
         new_smi->si_sm = kmalloc(new_smi->handlers->size(), GFP_KERNEL);
         if (!new_smi->si_sm) {
-                printk(KERN_ERR "Could not allocate state machine memory\n");
+                printk(KERN_ERR PFX
+                       "Could not allocate state machine memory\n");
                 rv = -ENOMEM;
                 goto out_err;
         }
@@ -3049,7 +3093,7 @@ static int try_smi_init(struct smi_info *new_smi)
         /* Now that we know the I/O size, we can set up the I/O. */
         rv = new_smi->io_setup(new_smi);
         if (rv) {
-                printk(KERN_ERR "Could not set up I/O space\n");
+                printk(KERN_ERR PFX "Could not set up I/O space\n");
                 goto out_err;
         }
 
@@ -3059,8 +3103,7 @@ static int try_smi_init(struct smi_info *new_smi)
         /* Do low-level detection first. */
         if (new_smi->handlers->detect(new_smi->si_sm)) {
                 if (new_smi->addr_source)
-                        printk(KERN_INFO "ipmi_si: Interface detection"
-                               " failed\n");
+                        printk(KERN_INFO PFX "Interface detection failed\n");
                 rv = -ENODEV;
                 goto out_err;
         }
@@ -3072,7 +3115,7 @@ static int try_smi_init(struct smi_info *new_smi)
         rv = try_get_dev_id(new_smi);
         if (rv) {
                 if (new_smi->addr_source)
-                        printk(KERN_INFO "ipmi_si: There appears to be no BMC"
+                        printk(KERN_INFO PFX "There appears to be no BMC"
                                " at this location\n");
                 goto out_err;
         }
@@ -3088,7 +3131,7 @@ static int try_smi_init(struct smi_info *new_smi)
         for (i = 0; i < SI_NUM_STATS; i++)
                 atomic_set(&new_smi->stats[i], 0);
 
-        new_smi->interrupt_disabled = 0;
+        new_smi->interrupt_disabled = 1;
         atomic_set(&new_smi->stop_operation, 0);
         new_smi->intf_num = smi_num;
         smi_num++;
@@ -3114,9 +3157,8 @@ static int try_smi_init(struct smi_info *new_smi)
                 new_smi->pdev = platform_device_alloc("ipmi_si",
                                                       new_smi->intf_num);
                 if (!new_smi->pdev) {
-                        printk(KERN_ERR
-                               "ipmi_si_intf:"
-                               " Unable to allocate platform device\n");
+                        printk(KERN_ERR PFX
+                               "Unable to allocate platform device\n");
                         goto out_err;
                 }
                 new_smi->dev = &new_smi->pdev->dev;
@@ -3124,9 +3166,8 @@ static int try_smi_init(struct smi_info *new_smi)
 
                 rv = platform_device_add(new_smi->pdev);
                 if (rv) {
-                        printk(KERN_ERR
-                               "ipmi_si_intf:"
-                               " Unable to register system interface device:"
+                        printk(KERN_ERR PFX
+                               "Unable to register system interface device:"
                                " %d\n",
                                rv);
                         goto out_err;
@@ -3141,9 +3182,8 @@ static int try_smi_init(struct smi_info *new_smi)
                                "bmc",
                                new_smi->slave_addr);
         if (rv) {
-                printk(KERN_ERR
-                       "ipmi_si: Unable to register device: error %d\n",
-                       rv);
+                dev_err(new_smi->dev, "Unable to register device: error %d\n",
+                        rv);
                 goto out_err_stop_timer;
         }
 
@@ -3151,9 +3191,7 @@ static int try_smi_init(struct smi_info *new_smi)
                                      type_file_read_proc,
                                      new_smi);
         if (rv) {
-                printk(KERN_ERR
-                       "ipmi_si: Unable to create proc entry: %d\n",
-                       rv);
+                dev_err(new_smi->dev, "Unable to create proc entry: %d\n", rv);
                 goto out_err_stop_timer;
         }
 
@@ -3161,9 +3199,7 @@ static int try_smi_init(struct smi_info *new_smi)
                                      stat_file_read_proc,
                                      new_smi);
         if (rv) {
-                printk(KERN_ERR
-                       "ipmi_si: Unable to create proc entry: %d\n",
-                       rv);
+                dev_err(new_smi->dev, "Unable to create proc entry: %d\n", rv);
                 goto out_err_stop_timer;
         }
 
@@ -3171,18 +3207,12 @@ static int try_smi_init(struct smi_info *new_smi)
                                      param_read_proc,
                                      new_smi);
         if (rv) {
-                printk(KERN_ERR
-                       "ipmi_si: Unable to create proc entry: %d\n",
-                       rv);
+                dev_err(new_smi->dev, "Unable to create proc entry: %d\n", rv);
                 goto out_err_stop_timer;
         }
 
-        list_add_tail(&new_smi->link, &smi_infos);
-
-        mutex_unlock(&smi_infos_lock);
-
-        printk(KERN_INFO "IPMI %s interface initialized\n",
-               si_to_str[new_smi->si_type]);
+        dev_info(new_smi->dev, "IPMI %s interface initialized\n",
+                 si_to_str[new_smi->si_type]);
 
         return 0;
 
@@ -3191,11 +3221,17 @@ static int try_smi_init(struct smi_info *new_smi)
         wait_for_timer_and_thread(new_smi);
 
  out_err:
-        if (new_smi->intf)
+        new_smi->interrupt_disabled = 1;
+
+        if (new_smi->intf) {
                 ipmi_unregister_smi(new_smi->intf);
+                new_smi->intf = NULL;
+        }
 
-        if (new_smi->irq_cleanup)
+        if (new_smi->irq_cleanup) {
                 new_smi->irq_cleanup(new_smi);
+                new_smi->irq_cleanup = NULL;
+        }
 
         /*
          * Wait until we know that we are out of any interrupt
@@ -3208,18 +3244,21 @@ static int try_smi_init(struct smi_info *new_smi)
                 if (new_smi->handlers)
                         new_smi->handlers->cleanup(new_smi->si_sm);
                 kfree(new_smi->si_sm);
+                new_smi->si_sm = NULL;
         }
-        if (new_smi->addr_source_cleanup)
+        if (new_smi->addr_source_cleanup) {
                 new_smi->addr_source_cleanup(new_smi);
-        if (new_smi->io_cleanup)
+                new_smi->addr_source_cleanup = NULL;
+        }
+        if (new_smi->io_cleanup) {
                 new_smi->io_cleanup(new_smi);
+                new_smi->io_cleanup = NULL;
+        }
 
-        if (new_smi->dev_registered)
+        if (new_smi->dev_registered) {
                 platform_device_unregister(new_smi->pdev);
-
-        kfree(new_smi);
-
-        mutex_unlock(&smi_infos_lock);
+                new_smi->dev_registered = 0;
+        }
 
         return rv;
 }
@@ -3229,6 +3268,8 @@ static __devinit int init_ipmi_si(void)
         int  i;
         char *str;
         int  rv;
+        struct smi_info *e;
+        enum ipmi_addr_src type = SI_INVALID;
 
         if (initialized)
                 return 0;
@@ -3237,9 +3278,7 @@ static __devinit int init_ipmi_si(void)
         /* Register the device drivers. */
         rv = driver_register(&ipmi_driver.driver);
         if (rv) {
-                printk(KERN_ERR
-                       "init_ipmi_si: Unable to register driver: %d\n",
-                       rv);
+                printk(KERN_ERR PFX "Unable to register driver: %d\n", rv);
                 return rv;
         }
 
@@ -3263,38 +3302,81 @@ static __devinit int init_ipmi_si(void)
 
         hardcode_find_bmc();
 
-#ifdef CONFIG_DMI
-        dmi_find_bmc();
-#endif
+        /* If the user gave us a device, they presumably want us to use it */
+        mutex_lock(&smi_infos_lock);
+        if (!list_empty(&smi_infos)) {
+                mutex_unlock(&smi_infos_lock);
+                return 0;
+        }
+        mutex_unlock(&smi_infos_lock);
 
-#ifdef CONFIG_ACPI
-        spmi_find_bmc();
+#ifdef CONFIG_PCI
+        rv = pci_register_driver(&ipmi_pci_driver);
+        if (rv)
+                printk(KERN_ERR PFX "Unable to register PCI driver: %d\n", rv);
 #endif
+
 #ifdef CONFIG_ACPI
         pnp_register_driver(&ipmi_pnp_driver);
 #endif
 
-#ifdef CONFIG_PCI
-        rv = pci_register_driver(&ipmi_pci_driver);
-        if (rv)
-                printk(KERN_ERR
-                       "init_ipmi_si: Unable to register PCI driver: %d\n",
-                       rv);
+#ifdef CONFIG_DMI
+        dmi_find_bmc();
+#endif
+
+#ifdef CONFIG_ACPI
+        spmi_find_bmc();
 #endif
 
 #ifdef CONFIG_PPC_OF
         of_register_platform_driver(&ipmi_of_platform_driver);
 #endif
 
+        /* We prefer devices with interrupts, but in the case of a machine
+           with multiple BMCs we assume that there will be several instances
+           of a given type so if we succeed in registering a type then also
+           try to register everything else of the same type */
+
+        mutex_lock(&smi_infos_lock);
+        list_for_each_entry(e, &smi_infos, link) {
+                /* Try to register a device if it has an IRQ and we either
+                   haven't successfully registered a device yet or this
+                   device has the same type as one we successfully registered */
+                if (e->irq && (!type || e->addr_source == type)) {
+                        if (!try_smi_init(e)) {
+                                type = e->addr_source;
+                        }
+                }
+        }
+
+        /* type will only have been set if we successfully registered an si */
+        if (type) {
+                mutex_unlock(&smi_infos_lock);
+                return 0;
+        }
+
+        /* Fall back to the preferred device */
+
+        list_for_each_entry(e, &smi_infos, link) {
+                if (!e->irq && (!type || e->addr_source == type)) {
+                        if (!try_smi_init(e)) {
+                                type = e->addr_source;
+                        }
+                }
+        }
+        mutex_unlock(&smi_infos_lock);
+
+        if (type)
+                return 0;
+
         if (si_trydefaults) {
                 mutex_lock(&smi_infos_lock);
                 if (list_empty(&smi_infos)) {
                         /* No BMC was found, try defaults. */
                         mutex_unlock(&smi_infos_lock);
                         default_find_bmc();
-                } else {
+                } else
                         mutex_unlock(&smi_infos_lock);
-                }
         }
 
         mutex_lock(&smi_infos_lock);
@@ -3308,8 +3390,8 @@ static __devinit int init_ipmi_si(void)
                 of_unregister_platform_driver(&ipmi_of_platform_driver);
 #endif
                 driver_unregister(&ipmi_driver.driver);
-                printk(KERN_WARNING
-                       "ipmi_si: Unable to find any System Interface(s)\n");
+                printk(KERN_WARNING PFX
+                       "Unable to find any System Interface(s)\n");
                 return -ENODEV;
         } else {
                 mutex_unlock(&smi_infos_lock);
@@ -3320,7 +3402,7 @@ module_init(init_ipmi_si);
 
 static void cleanup_one_si(struct smi_info *to_clean)
 {
-        int           rv;
+        int           rv = 0;
         unsigned long flags;
 
         if (!to_clean)
@@ -3364,14 +3446,16 @@ static void cleanup_one_si(struct smi_info *to_clean)
                 schedule_timeout_uninterruptible(1);
         }
 
-        rv = ipmi_unregister_smi(to_clean->intf);
+        if (to_clean->intf)
+                rv = ipmi_unregister_smi(to_clean->intf);
+
         if (rv) {
-                printk(KERN_ERR
-                       "ipmi_si: Unable to unregister device: errno=%d\n",
+                printk(KERN_ERR PFX "Unable to unregister device: errno=%d\n",
                        rv);
         }
 
-        to_clean->handlers->cleanup(to_clean->si_sm);
+        if (to_clean->handlers)
+                to_clean->handlers->cleanup(to_clean->si_sm);
 
         kfree(to_clean->si_sm);
 
diff --git a/drivers/char/ppdev.c b/drivers/char/ppdev.c
index fdd37543aa79..02abfddce45a 100644
--- a/drivers/char/ppdev.c
+++ b/drivers/char/ppdev.c
@@ -287,12 +287,10 @@ static int register_device (int minor, struct pp_struct *pp)
         char *name;
         int fl;
 
-        name = kmalloc (strlen (CHRDEV) + 3, GFP_KERNEL);
+        name = kasprintf(GFP_KERNEL, CHRDEV "%x", minor);
         if (name == NULL)
                 return -ENOMEM;
 
-        sprintf (name, CHRDEV "%x", minor);
-
         port = parport_find_number (minor);
         if (!port) {
                 printk (KERN_WARNING "%s: no associated port!\n", name);
diff --git a/drivers/char/ps3flash.c b/drivers/char/ps3flash.c
index 606048b72bcf..85c004a518ee 100644
--- a/drivers/char/ps3flash.c
+++ b/drivers/char/ps3flash.c
@@ -305,8 +305,7 @@ static int ps3flash_flush(struct file *file, fl_owner_t id)
         return ps3flash_writeback(ps3flash_dev);
 }
 
-static int ps3flash_fsync(struct file *file, struct dentry *dentry,
-                          int datasync)
+static int ps3flash_fsync(struct file *file, int datasync)
 {
         return ps3flash_writeback(ps3flash_dev);
 }
diff --git a/drivers/char/ramoops.c b/drivers/char/ramoops.c
new file mode 100644
index 000000000000..74f00b5ffa36
--- /dev/null
+++ b/drivers/char/ramoops.c
@@ -0,0 +1,162 @@
+/*
+ * RAM Oops/Panic logger
+ *
+ * Copyright (C) 2010 Marco Stornelli <marco.stornelli@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/kmsg_dump.h>
+#include <linux/time.h>
+#include <linux/io.h>
+#include <linux/ioport.h>
+
+#define RAMOOPS_KERNMSG_HDR "===="
+#define RAMOOPS_HEADER_SIZE   (5 + sizeof(struct timeval))
+
+#define RECORD_SIZE 4096
+
+static ulong mem_address;
+module_param(mem_address, ulong, 0400);
+MODULE_PARM_DESC(mem_address,
+                "start of reserved RAM used to store oops/panic logs");
+
+static ulong mem_size;
+module_param(mem_size, ulong, 0400);
+MODULE_PARM_DESC(mem_size,
+                "size of reserved RAM used to store oops/panic logs");
+
+static int dump_oops = 1;
+module_param(dump_oops, int, 0600);
+MODULE_PARM_DESC(dump_oops,
+                "set to 1 to dump oopses, 0 to only dump panics (default 1)");
+
+static struct ramoops_context {
+        struct kmsg_dumper dump;
+        void *virt_addr;
+        phys_addr_t phys_addr;
+        unsigned long size;
+        int count;
+        int max_count;
+} oops_cxt;
+
+static void ramoops_do_dump(struct kmsg_dumper *dumper,
+                enum kmsg_dump_reason reason, const char *s1, unsigned long l1,
+                const char *s2, unsigned long l2)
+{
+        struct ramoops_context *cxt = container_of(dumper,
+                        struct ramoops_context, dump);
+        unsigned long s1_start, s2_start;
+        unsigned long l1_cpy, l2_cpy;
+        int res;
+        char *buf;
+        struct timeval timestamp;
+
+        /* Only dump oopses if dump_oops is set */
+        if (reason == KMSG_DUMP_OOPS && !dump_oops)
+                return;
+
+        buf = (char *)(cxt->virt_addr + (cxt->count * RECORD_SIZE));
+        memset(buf, '\0', RECORD_SIZE);
+        res = sprintf(buf, "%s", RAMOOPS_KERNMSG_HDR);
+        buf += res;
+        do_gettimeofday(&timestamp);
+        res = sprintf(buf, "%lu.%lu\n", (long)timestamp.tv_sec, (long)timestamp.tv_usec);
+        buf += res;
+
+        l2_cpy = min(l2, (unsigned long)(RECORD_SIZE - RAMOOPS_HEADER_SIZE));
+        l1_cpy = min(l1, (unsigned long)(RECORD_SIZE - RAMOOPS_HEADER_SIZE) - l2_cpy);
+
+        s2_start = l2 - l2_cpy;
+        s1_start = l1 - l1_cpy;
+
+        memcpy(buf, s1 + s1_start, l1_cpy);
+        memcpy(buf + l1_cpy, s2 + s2_start, l2_cpy);
+
+        cxt->count = (cxt->count + 1) % cxt->max_count;
+}
+
+static int __init ramoops_init(void)
+{
+        struct ramoops_context *cxt = &oops_cxt;
+        int err = -EINVAL;
+
+        if (!mem_size) {
+                printk(KERN_ERR "ramoops: invalid size specification");
+                goto fail3;
+        }
+
+        rounddown_pow_of_two(mem_size);
+
+        if (mem_size < RECORD_SIZE) {
+                printk(KERN_ERR "ramoops: size too small");
+                goto fail3;
+        }
+
+        cxt->max_count = mem_size / RECORD_SIZE;
+        cxt->count = 0;
+        cxt->size = mem_size;
+        cxt->phys_addr = mem_address;
+
+        if (!request_mem_region(cxt->phys_addr, cxt->size, "ramoops")) {
+                printk(KERN_ERR "ramoops: request mem region failed");
+                err = -EINVAL;
+                goto fail3;
+        }
+
+        cxt->virt_addr = ioremap(cxt->phys_addr,  cxt->size);
+        if (!cxt->virt_addr) {
+                printk(KERN_ERR "ramoops: ioremap failed");
+                goto fail2;
+        }
+
+        cxt->dump.dump = ramoops_do_dump;
+        err = kmsg_dump_register(&cxt->dump);
+        if (err) {
+                printk(KERN_ERR "ramoops: registering kmsg dumper failed");
+                goto fail1;
+        }
+
+        return 0;
+
+fail1:
+        iounmap(cxt->virt_addr);
+fail2:
+        release_mem_region(cxt->phys_addr, cxt->size);
+fail3:
+        return err;
+}
+
+static void __exit ramoops_exit(void)
+{
+        struct ramoops_context *cxt = &oops_cxt;
+
+        if (kmsg_dump_unregister(&cxt->dump) < 0)
+                printk(KERN_WARNING "ramoops: could not unregister kmsg_dumper");
+
+        iounmap(cxt->virt_addr);
+        release_mem_region(cxt->phys_addr, cxt->size);
+}
+
+
+module_init(ramoops_init);
+module_exit(ramoops_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Marco Stornelli <marco.stornelli@gmail.com>");
+MODULE_DESCRIPTION("RAM Oops/Panic logger/driver");
diff --git a/drivers/char/vt.c b/drivers/char/vt.c
index bd1d1164fec5..7cdb6ee569cd 100644
--- a/drivers/char/vt.c
+++ b/drivers/char/vt.c
@@ -3967,13 +3967,9 @@ static int con_font_set(struct vc_data *vc, struct console_font_op *op)
         font.charcount = op->charcount;
         font.height = op->height;
         font.width = op->width;
-        font.data = kmalloc(size, GFP_KERNEL);
-        if (!font.data)
-                return -ENOMEM;
-        if (copy_from_user(font.data, op->data, size)) {
-                kfree(font.data);
-                return -EFAULT;
-        }
+        font.data = memdup_user(op->data, size);
+        if (IS_ERR(font.data))
+                return PTR_ERR(font.data);
         acquire_console_sem();
         if (vc->vc_sw->con_font_set)
                 rc = vc->vc_sw->con_font_set(vc, &font, op->flags);
diff --git a/drivers/cpuidle/cpuidle.c b/drivers/cpuidle/cpuidle.c
index 12fdd3987a36..199488576a05 100644
--- a/drivers/cpuidle/cpuidle.c
+++ b/drivers/cpuidle/cpuidle.c
@@ -156,7 +156,7 @@ int cpuidle_enable_device(struct cpuidle_device *dev)
 
         if (dev->enabled)
                 return 0;
-        if (!cpuidle_curr_driver || !cpuidle_curr_governor)
+        if (!cpuidle_get_driver() || !cpuidle_curr_governor)
                 return -EIO;
         if (!dev->state_count)
                 return -EINVAL;
@@ -207,7 +207,7 @@ void cpuidle_disable_device(struct cpuidle_device *dev)
 {
         if (!dev->enabled)
                 return;
-        if (!cpuidle_curr_driver || !cpuidle_curr_governor)
+        if (!cpuidle_get_driver() || !cpuidle_curr_governor)
                 return;
 
         dev->enabled = 0;
@@ -271,10 +271,11 @@ static int __cpuidle_register_device(struct cpuidle_device *dev)
 {
         int ret;
         struct sys_device *sys_dev = get_cpu_sysdev((unsigned long)dev->cpu);
+        struct cpuidle_driver *cpuidle_driver = cpuidle_get_driver();
 
         if (!sys_dev)
                 return -EINVAL;
-        if (!try_module_get(cpuidle_curr_driver->owner))
+        if (!try_module_get(cpuidle_driver->owner))
                 return -EINVAL;
 
         init_completion(&dev->kobj_unregister);
@@ -284,7 +285,7 @@ static int __cpuidle_register_device(struct cpuidle_device *dev)
         per_cpu(cpuidle_devices, dev->cpu) = dev;
         list_add(&dev->device_list, &cpuidle_detected_devices);
         if ((ret = cpuidle_add_sysfs(sys_dev))) {
-                module_put(cpuidle_curr_driver->owner);
+                module_put(cpuidle_driver->owner);
                 return ret;
         }
 
@@ -325,6 +326,7 @@ EXPORT_SYMBOL_GPL(cpuidle_register_device);
 void cpuidle_unregister_device(struct cpuidle_device *dev)
 {
         struct sys_device *sys_dev = get_cpu_sysdev((unsigned long)dev->cpu);
+        struct cpuidle_driver *cpuidle_driver = cpuidle_get_driver();
 
         if (dev->registered == 0)
                 return;
@@ -340,7 +342,7 @@ void cpuidle_unregister_device(struct cpuidle_device *dev)
 
         cpuidle_resume_and_unlock();
 
-        module_put(cpuidle_curr_driver->owner);
+        module_put(cpuidle_driver->owner);
 }
 
 EXPORT_SYMBOL_GPL(cpuidle_unregister_device);
diff --git a/drivers/cpuidle/cpuidle.h b/drivers/cpuidle/cpuidle.h
index 9476ba33ee2c..33e50d556f17 100644
--- a/drivers/cpuidle/cpuidle.h
+++ b/drivers/cpuidle/cpuidle.h
@@ -9,7 +9,6 @@
 
 /* For internal use only */
 extern struct cpuidle_governor *cpuidle_curr_governor;
-extern struct cpuidle_driver *cpuidle_curr_driver;
 extern struct list_head cpuidle_governors;
 extern struct list_head cpuidle_detected_devices;
 extern struct mutex cpuidle_lock;
diff --git a/drivers/cpuidle/driver.c b/drivers/cpuidle/driver.c
index 2257004fe33d..fd1601e3d125 100644
--- a/drivers/cpuidle/driver.c
+++ b/drivers/cpuidle/driver.c
@@ -14,7 +14,7 @@
 
 #include "cpuidle.h"
 
-struct cpuidle_driver *cpuidle_curr_driver;
+static struct cpuidle_driver *cpuidle_curr_driver;
 DEFINE_SPINLOCK(cpuidle_driver_lock);
 
 /**
@@ -40,13 +40,25 @@ int cpuidle_register_driver(struct cpuidle_driver *drv)
 EXPORT_SYMBOL_GPL(cpuidle_register_driver);
 
 /**
+ * cpuidle_get_driver - return the current driver
+ */
+struct cpuidle_driver *cpuidle_get_driver(void)
+{
+        return cpuidle_curr_driver;
+}
+EXPORT_SYMBOL_GPL(cpuidle_get_driver);
+
+/**
  * cpuidle_unregister_driver - unregisters a driver
  * @drv: the driver
  */
 void cpuidle_unregister_driver(struct cpuidle_driver *drv)
 {
-        if (!drv)
+        if (drv != cpuidle_curr_driver) {
+                WARN(1, "invalid cpuidle_unregister_driver(%s)\n",
+                        drv->name);
                 return;
+        }
 
         spin_lock(&cpuidle_driver_lock);
         cpuidle_curr_driver = NULL;
diff --git a/drivers/cpuidle/sysfs.c b/drivers/cpuidle/sysfs.c
index 0ba9c8b8ee74..0310ffaec9df 100644
--- a/drivers/cpuidle/sysfs.c
+++ b/drivers/cpuidle/sysfs.c
@@ -47,10 +47,11 @@ static ssize_t show_current_driver(struct sysdev_class *class,
                                    char *buf)
 {
         ssize_t ret;
+        struct cpuidle_driver *cpuidle_driver = cpuidle_get_driver();
 
         spin_lock(&cpuidle_driver_lock);
-        if (cpuidle_curr_driver)
-                ret = sprintf(buf, "%s\n", cpuidle_curr_driver->name);
+        if (cpuidle_driver)
+                ret = sprintf(buf, "%s\n", cpuidle_driver->name);
         else
                 ret = sprintf(buf, "none\n");
         spin_unlock(&cpuidle_driver_lock);
diff --git a/drivers/dma/Kconfig b/drivers/dma/Kconfig
index 1b8877922fb0..9e01e96fee94 100644
--- a/drivers/dma/Kconfig
+++ b/drivers/dma/Kconfig
@@ -166,6 +166,15 @@ config TIMB_DMA
 config ARCH_HAS_ASYNC_TX_FIND_CHANNEL
         bool
 
+config PL330_DMA
+        tristate "DMA API Driver for PL330"
+        select DMA_ENGINE
+        depends on PL330
+        help
+          Select if your platform has one or more PL330 DMACs.
+          You need to provide platform specific settings via
+          platform_data for a dma-pl330 device.
+
 config DMA_ENGINE
         bool
 
diff --git a/drivers/dma/Makefile b/drivers/dma/Makefile
index 20881426c1ac..0fe5ebbfda5d 100644
--- a/drivers/dma/Makefile
+++ b/drivers/dma/Makefile
@@ -22,3 +22,4 @@ obj-$(CONFIG_COH901318) += coh901318.o coh901318_lli.o
 obj-$(CONFIG_AMCC_PPC440SPE_ADMA) += ppc4xx/
 obj-$(CONFIG_TIMB_DMA) += timb_dma.o
 obj-$(CONFIG_STE_DMA40) += ste_dma40.o ste_dma40_ll.o
+obj-$(CONFIG_PL330_DMA) += pl330.o
diff --git a/drivers/dma/pl330.c b/drivers/dma/pl330.c
new file mode 100644
index 000000000000..7c50f6dfd3f4
--- /dev/null
+++ b/drivers/dma/pl330.c
@@ -0,0 +1,866 @@
+/* linux/drivers/dma/pl330.c
+ *
+ * Copyright (C) 2010 Samsung Electronics Co. Ltd.
+ *      Jaswinder Singh <jassi.brar@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#include <linux/io.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/dmaengine.h>
+#include <linux/interrupt.h>
+#include <linux/amba/bus.h>
+#include <linux/amba/pl330.h>
+
+#define NR_DEFAULT_DESC 16
+
+enum desc_status {
+        /* In the DMAC pool */
+        FREE,
+        /*
+         * Allocted to some channel during prep_xxx
+         * Also may be sitting on the work_list.
+         */
+        PREP,
+        /*
+         * Sitting on the work_list and already submitted
+         * to the PL330 core. Not more than two descriptors
+         * of a channel can be BUSY at any time.
+         */
+        BUSY,
+        /*
+         * Sitting on the channel work_list but xfer done
+         * by PL330 core
+         */
+        DONE,
+};
+
+struct dma_pl330_chan {
+        /* Schedule desc completion */
+        struct tasklet_struct task;
+
+        /* DMA-Engine Channel */
+        struct dma_chan chan;
+
+        /* Last completed cookie */
+        dma_cookie_t completed;
+
+        /* List of to be xfered descriptors */
+        struct list_head work_list;
+
+        /* Pointer to the DMAC that manages this channel,
+         * NULL if the channel is available to be acquired.
+         * As the parent, this DMAC also provides descriptors
+         * to the channel.
+         */
+        struct dma_pl330_dmac *dmac;
+
+        /* To protect channel manipulation */
+        spinlock_t lock;
+
+        /* Token of a hardware channel thread of PL330 DMAC
+         * NULL if the channel is available to be acquired.
+         */
+        void *pl330_chid;
+};
+
+struct dma_pl330_dmac {
+        struct pl330_info pif;
+
+        /* DMA-Engine Device */
+        struct dma_device ddma;
+
+        /* Pool of descriptors available for the DMAC's channels */
+        struct list_head desc_pool;
+        /* To protect desc_pool manipulation */
+        spinlock_t pool_lock;
+
+        /* Peripheral channels connected to this DMAC */
+        struct dma_pl330_chan peripherals[0]; /* keep at end */
+};
+
+struct dma_pl330_desc {
+        /* To attach to a queue as child */
+        struct list_head node;
+
+        /* Descriptor for the DMA Engine API */
+        struct dma_async_tx_descriptor txd;
+
+        /* Xfer for PL330 core */
+        struct pl330_xfer px;
+
+        struct pl330_reqcfg rqcfg;
+        struct pl330_req req;
+
+        enum desc_status status;
+
+        /* The channel which currently holds this desc */
+        struct dma_pl330_chan *pchan;
+};
+
+static inline struct dma_pl330_chan *
+to_pchan(struct dma_chan *ch)
+{
+        if (!ch)
+                return NULL;
+
+        return container_of(ch, struct dma_pl330_chan, chan);
+}
+
+static inline struct dma_pl330_desc *
+to_desc(struct dma_async_tx_descriptor *tx)
+{
+        return container_of(tx, struct dma_pl330_desc, txd);
+}
+
+static inline void free_desc_list(struct list_head *list)
+{
+        struct dma_pl330_dmac *pdmac;
+        struct dma_pl330_desc *desc;
+        struct dma_pl330_chan *pch;
+        unsigned long flags;
+
+        if (list_empty(list))
+                return;
+
+        /* Finish off the work list */
+        list_for_each_entry(desc, list, node) {
+                dma_async_tx_callback callback;
+                void *param;
+
+                /* All desc in a list belong to same channel */
+                pch = desc->pchan;
+                callback = desc->txd.callback;
+                param = desc->txd.callback_param;
+
+                if (callback)
+                        callback(param);
+
+                desc->pchan = NULL;
+        }
+
+        pdmac = pch->dmac;
+
+        spin_lock_irqsave(&pdmac->pool_lock, flags);
+        list_splice_tail_init(list, &pdmac->desc_pool);
+        spin_unlock_irqrestore(&pdmac->pool_lock, flags);
+}
+
+static inline void fill_queue(struct dma_pl330_chan *pch)
+{
+        struct dma_pl330_desc *desc;
+        int ret;
+
+        list_for_each_entry(desc, &pch->work_list, node) {
+
+                /* If already submitted */
+                if (desc->status == BUSY)
+                        break;
+
+                ret = pl330_submit_req(pch->pl330_chid,
+                                                &desc->req);
+                if (!ret) {
+                        desc->status = BUSY;
+                        break;
+                } else if (ret == -EAGAIN) {
+                        /* QFull or DMAC Dying */
+                        break;
+                } else {
+                        /* Unacceptable request */
+                        desc->status = DONE;
+                        dev_err(pch->dmac->pif.dev, "%s:%d Bad Desc(%d)\n",
+                                        __func__, __LINE__, desc->txd.cookie);
+                        tasklet_schedule(&pch->task);
+                }
+        }
+}
+
+static void pl330_tasklet(unsigned long data)
+{
+        struct dma_pl330_chan *pch = (struct dma_pl330_chan *)data;
+        struct dma_pl330_desc *desc, *_dt;
+        unsigned long flags;
+        LIST_HEAD(list);
+
+        spin_lock_irqsave(&pch->lock, flags);
+
+        /* Pick up ripe tomatoes */
+        list_for_each_entry_safe(desc, _dt, &pch->work_list, node)
+                if (desc->status == DONE) {
+                        pch->completed = desc->txd.cookie;
+                        list_move_tail(&desc->node, &list);
+                }
+
+        /* Try to submit a req imm. next to the last completed cookie */
+        fill_queue(pch);
+
+        /* Make sure the PL330 Channel thread is active */
+        pl330_chan_ctrl(pch->pl330_chid, PL330_OP_START);
+
+        spin_unlock_irqrestore(&pch->lock, flags);
+
+        free_desc_list(&list);
+}
+
+static void dma_pl330_rqcb(void *token, enum pl330_op_err err)
+{
+        struct dma_pl330_desc *desc = token;
+        struct dma_pl330_chan *pch = desc->pchan;
+        unsigned long flags;
+
+        /* If desc aborted */
+        if (!pch)
+                return;
+
+        spin_lock_irqsave(&pch->lock, flags);
+
+        desc->status = DONE;
+
+        spin_unlock_irqrestore(&pch->lock, flags);
+
+        tasklet_schedule(&pch->task);
+}
+
+static int pl330_alloc_chan_resources(struct dma_chan *chan)
+{
+        struct dma_pl330_chan *pch = to_pchan(chan);
+        struct dma_pl330_dmac *pdmac = pch->dmac;
+        unsigned long flags;
+
+        spin_lock_irqsave(&pch->lock, flags);
+
+        pch->completed = chan->cookie = 1;
+
+        pch->pl330_chid = pl330_request_channel(&pdmac->pif);
+        if (!pch->pl330_chid) {
+                spin_unlock_irqrestore(&pch->lock, flags);
+                return 0;
+        }
+
+        tasklet_init(&pch->task, pl330_tasklet, (unsigned long) pch);
+
+        spin_unlock_irqrestore(&pch->lock, flags);
+
+        return 1;
+}
+
+static int pl330_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd, unsigned long arg)
+{
+        struct dma_pl330_chan *pch = to_pchan(chan);
+        struct dma_pl330_desc *desc;
+        unsigned long flags;
+
+        /* Only supports DMA_TERMINATE_ALL */
+        if (cmd != DMA_TERMINATE_ALL)
+                return -ENXIO;
+
+        spin_lock_irqsave(&pch->lock, flags);
+
+        /* FLUSH the PL330 Channel thread */
+        pl330_chan_ctrl(pch->pl330_chid, PL330_OP_FLUSH);
+
+        /* Mark all desc done */
+        list_for_each_entry(desc, &pch->work_list, node)
+                desc->status = DONE;
+
+        spin_unlock_irqrestore(&pch->lock, flags);
+
+        pl330_tasklet((unsigned long) pch);
+
+        return 0;
+}
+
+static void pl330_free_chan_resources(struct dma_chan *chan)
+{
+        struct dma_pl330_chan *pch = to_pchan(chan);
+        unsigned long flags;
+
+        spin_lock_irqsave(&pch->lock, flags);
+
+        tasklet_kill(&pch->task);
+
+        pl330_release_channel(pch->pl330_chid);
+        pch->pl330_chid = NULL;
+
+        spin_unlock_irqrestore(&pch->lock, flags);
+}
+
+static enum dma_status
+pl330_tx_status(struct dma_chan *chan, dma_cookie_t cookie,
+                 struct dma_tx_state *txstate)
+{
+        struct dma_pl330_chan *pch = to_pchan(chan);
+        dma_cookie_t last_done, last_used;
+        int ret;
+
+        last_done = pch->completed;
+        last_used = chan->cookie;
+
+        ret = dma_async_is_complete(cookie, last_done, last_used);
+
+        dma_set_tx_state(txstate, last_done, last_used, 0);
+
+        return ret;
+}
+
+static void pl330_issue_pending(struct dma_chan *chan)
+{
+        pl330_tasklet((unsigned long) to_pchan(chan));
+}
+
+/*
+ * We returned the last one of the circular list of descriptor(s)
+ * from prep_xxx, so the argument to submit corresponds to the last
+ * descriptor of the list.
+ */
+static dma_cookie_t pl330_tx_submit(struct dma_async_tx_descriptor *tx)
+{
+        struct dma_pl330_desc *desc, *last = to_desc(tx);
+        struct dma_pl330_chan *pch = to_pchan(tx->chan);
+        dma_cookie_t cookie;
+        unsigned long flags;
+
+        spin_lock_irqsave(&pch->lock, flags);
+
+        /* Assign cookies to all nodes */
+        cookie = tx->chan->cookie;
+
+        while (!list_empty(&last->node)) {
+                desc = list_entry(last->node.next, struct dma_pl330_desc, node);
+
+                if (++cookie < 0)
+                        cookie = 1;
+                desc->txd.cookie = cookie;
+
+                list_move_tail(&desc->node, &pch->work_list);
+        }
+
+        if (++cookie < 0)
+                cookie = 1;
+        last->txd.cookie = cookie;
+
+        list_add_tail(&last->node, &pch->work_list);
+
+        tx->chan->cookie = cookie;
+
+        spin_unlock_irqrestore(&pch->lock, flags);
+
+        return cookie;
+}
+
+static inline void _init_desc(struct dma_pl330_desc *desc)
+{
+        desc->pchan = NULL;
+        desc->req.x = &desc->px;
+        desc->req.token = desc;
+        desc->rqcfg.swap = SWAP_NO;
+        desc->rqcfg.privileged = 0;
+        desc->rqcfg.insnaccess = 0;
+        desc->rqcfg.scctl = SCCTRL0;
+        desc->rqcfg.dcctl = DCCTRL0;
+        desc->req.cfg = &desc->rqcfg;
+        desc->req.xfer_cb = dma_pl330_rqcb;
+        desc->txd.tx_submit = pl330_tx_submit;
+
+        INIT_LIST_HEAD(&desc->node);
+}
+
+/* Returns the number of descriptors added to the DMAC pool */
+int add_desc(struct dma_pl330_dmac *pdmac, gfp_t flg, int count)
+{
+        struct dma_pl330_desc *desc;
+        unsigned long flags;
+        int i;
+
+        if (!pdmac)
+                return 0;
+
+        desc = kmalloc(count * sizeof(*desc), flg);
+        if (!desc)
+                return 0;
+
+        spin_lock_irqsave(&pdmac->pool_lock, flags);
+
+        for (i = 0; i < count; i++) {
+                _init_desc(&desc[i]);
+                list_add_tail(&desc[i].node, &pdmac->desc_pool);
+        }
+
+        spin_unlock_irqrestore(&pdmac->pool_lock, flags);
+
+        return count;
+}
+
+static struct dma_pl330_desc *
+pluck_desc(struct dma_pl330_dmac *pdmac)
+{
+        struct dma_pl330_desc *desc = NULL;
+        unsigned long flags;
+
+        if (!pdmac)
+                return NULL;
+
+        spin_lock_irqsave(&pdmac->pool_lock, flags);
+
+        if (!list_empty(&pdmac->desc_pool)) {
+                desc = list_entry(pdmac->desc_pool.next,
+                                struct dma_pl330_desc, node);
+
+                list_del_init(&desc->node);
+
+                desc->status = PREP;
+                desc->txd.callback = NULL;
+        }
+
+        spin_unlock_irqrestore(&pdmac->pool_lock, flags);
+
+        return desc;
+}
+
+static struct dma_pl330_desc *pl330_get_desc(struct dma_pl330_chan *pch)
+{
+        struct dma_pl330_dmac *pdmac = pch->dmac;
+        struct dma_pl330_peri *peri = pch->chan.private;
+        struct dma_pl330_desc *desc;
+
+        /* Pluck one desc from the pool of DMAC */
+        desc = pluck_desc(pdmac);
+
+        /* If the DMAC pool is empty, alloc new */
+        if (!desc) {
+                if (!add_desc(pdmac, GFP_ATOMIC, 1))
+                        return NULL;
+
+                /* Try again */
+                desc = pluck_desc(pdmac);
+                if (!desc) {
+                        dev_err(pch->dmac->pif.dev,
+                                "%s:%d ALERT!\n", __func__, __LINE__);
+                        return NULL;
+                }
+        }
+
+        /* Initialize the descriptor */
+        desc->pchan = pch;
+        desc->txd.cookie = 0;
+        async_tx_ack(&desc->txd);
+
+        desc->req.rqtype = peri->rqtype;
+        desc->req.peri = peri->peri_id;
+
+        dma_async_tx_descriptor_init(&desc->txd, &pch->chan);
+
+        return desc;
+}
+
+static inline void fill_px(struct pl330_xfer *px,
+                dma_addr_t dst, dma_addr_t src, size_t len)
+{
+        px->next = NULL;
+        px->bytes = len;
+        px->dst_addr = dst;
+        px->src_addr = src;
+}
+
+static struct dma_pl330_desc *
+__pl330_prep_dma_memcpy(struct dma_pl330_chan *pch, dma_addr_t dst,
+                dma_addr_t src, size_t len)
+{
+        struct dma_pl330_desc *desc = pl330_get_desc(pch);
+
+        if (!desc) {
+                dev_err(pch->dmac->pif.dev, "%s:%d Unable to fetch desc\n",
+                        __func__, __LINE__);
+                return NULL;
+        }
+
+        /*
+         * Ideally we should lookout for reqs bigger than
+         * those that can be programmed with 256 bytes of
+         * MC buffer, but considering a req size is seldom
+         * going to be word-unaligned and more than 200MB,
+         * we take it easy.
+         * Also, should the limit is reached we'd rather
+         * have the platform increase MC buffer size than
+         * complicating this API driver.
+         */
+        fill_px(&desc->px, dst, src, len);
+
+        return desc;
+}
+
+/* Call after fixing burst size */
+static inline int get_burst_len(struct dma_pl330_desc *desc, size_t len)
+{
+        struct dma_pl330_chan *pch = desc->pchan;
+        struct pl330_info *pi = &pch->dmac->pif;
+        int burst_len;
+
+        burst_len = pi->pcfg.data_bus_width / 8;
+        burst_len *= pi->pcfg.data_buf_dep;
+        burst_len >>= desc->rqcfg.brst_size;
+
+        /* src/dst_burst_len can't be more than 16 */
+        if (burst_len > 16)
+                burst_len = 16;
+
+        while (burst_len > 1) {
+                if (!(len % (burst_len << desc->rqcfg.brst_size)))
+                        break;
+                burst_len--;
+        }
+
+        return burst_len;
+}
+
+static struct dma_async_tx_descriptor *
+pl330_prep_dma_memcpy(struct dma_chan *chan, dma_addr_t dst,
+                dma_addr_t src, size_t len, unsigned long flags)
+{
+        struct dma_pl330_desc *desc;
+        struct dma_pl330_chan *pch = to_pchan(chan);
+        struct dma_pl330_peri *peri = chan->private;
+        struct pl330_info *pi;
+        int burst;
+
+        if (unlikely(!pch || !len || !peri))
+                return NULL;
+
+        if (peri->rqtype != MEMTOMEM)
+                return NULL;
+
+        pi = &pch->dmac->pif;
+
+        desc = __pl330_prep_dma_memcpy(pch, dst, src, len);
+        if (!desc)
+                return NULL;
+
+        desc->rqcfg.src_inc = 1;
+        desc->rqcfg.dst_inc = 1;
+
+        /* Select max possible burst size */
+        burst = pi->pcfg.data_bus_width / 8;
+
+        while (burst > 1) {
+                if (!(len % burst))
+                        break;
+                burst /= 2;
+        }
+
+        desc->rqcfg.brst_size = 0;
+        while (burst != (1 << desc->rqcfg.brst_size))
+                desc->rqcfg.brst_size++;
+
+        desc->rqcfg.brst_len = get_burst_len(desc, len);
+
+        desc->txd.flags = flags;
+
+        return &desc->txd;
+}
+
+static struct dma_async_tx_descriptor *
+pl330_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
+                unsigned int sg_len, enum dma_data_direction direction,
+                unsigned long flg)
+{
+        struct dma_pl330_desc *first, *desc = NULL;
+        struct dma_pl330_chan *pch = to_pchan(chan);
+        struct dma_pl330_peri *peri = chan->private;
+        struct scatterlist *sg;
+        unsigned long flags;
+        int i, burst_size;
+        dma_addr_t addr;
+
+        if (unlikely(!pch || !sgl || !sg_len))
+                return NULL;
+
+        /* Make sure the direction is consistent */
+        if ((direction == DMA_TO_DEVICE &&
+                                peri->rqtype != MEMTODEV) ||
+                        (direction == DMA_FROM_DEVICE &&
+                                peri->rqtype != DEVTOMEM)) {
+                dev_err(pch->dmac->pif.dev, "%s:%d Invalid Direction\n",
+                                __func__, __LINE__);
+                return NULL;
+        }
+
+        addr = peri->fifo_addr;
+        burst_size = peri->burst_sz;
+
+        first = NULL;
+
+        for_each_sg(sgl, sg, sg_len, i) {
+
+                desc = pl330_get_desc(pch);
+                if (!desc) {
+                        struct dma_pl330_dmac *pdmac = pch->dmac;
+
+                        dev_err(pch->dmac->pif.dev,
+                                "%s:%d Unable to fetch desc\n",
+                                __func__, __LINE__);
+                        if (!first)
+                                return NULL;
+
+                        spin_lock_irqsave(&pdmac->pool_lock, flags);
+
+                        while (!list_empty(&first->node)) {
+                                desc = list_entry(first->node.next,
+                                                struct dma_pl330_desc, node);
+                                list_move_tail(&desc->node, &pdmac->desc_pool);
+                        }
+
+                        list_move_tail(&first->node, &pdmac->desc_pool);
+
+                        spin_unlock_irqrestore(&pdmac->pool_lock, flags);
+
+                        return NULL;
+                }
+
+                if (!first)
+                        first = desc;
+                else
+                        list_add_tail(&desc->node, &first->node);
+
+                if (direction == DMA_TO_DEVICE) {
+                        desc->rqcfg.src_inc = 1;
+                        desc->rqcfg.dst_inc = 0;
+                        fill_px(&desc->px,
+                                addr, sg_dma_address(sg), sg_dma_len(sg));
+                } else {
+                        desc->rqcfg.src_inc = 0;
+                        desc->rqcfg.dst_inc = 1;
+                        fill_px(&desc->px,
+                                sg_dma_address(sg), addr, sg_dma_len(sg));
+                }
+
+                desc->rqcfg.brst_size = burst_size;
+                desc->rqcfg.brst_len = 1;
+        }
+
+        /* Return the last desc in the chain */
+        desc->txd.flags = flg;
+        return &desc->txd;
+}
+
+static irqreturn_t pl330_irq_handler(int irq, void *data)
+{
+        if (pl330_update(data))
+                return IRQ_HANDLED;
+        else
+                return IRQ_NONE;
+}
+
+static int __devinit
+pl330_probe(struct amba_device *adev, struct amba_id *id)
+{
+        struct dma_pl330_platdata *pdat;
+        struct dma_pl330_dmac *pdmac;
+        struct dma_pl330_chan *pch;
+        struct pl330_info *pi;
+        struct dma_device *pd;
+        struct resource *res;
+        int i, ret, irq;
+
+        pdat = adev->dev.platform_data;
+
+        if (!pdat || !pdat->nr_valid_peri) {
+                dev_err(&adev->dev, "platform data missing\n");
+                return -ENODEV;
+        }
+
+        /* Allocate a new DMAC and its Channels */
+        pdmac = kzalloc(pdat->nr_valid_peri * sizeof(*pch)
+                                + sizeof(*pdmac), GFP_KERNEL);
+        if (!pdmac) {
+                dev_err(&adev->dev, "unable to allocate mem\n");
+                return -ENOMEM;
+        }
+
+        pi = &pdmac->pif;
+        pi->dev = &adev->dev;
+        pi->pl330_data = NULL;
+        pi->mcbufsz = pdat->mcbuf_sz;
+
+        res = &adev->res;
+        request_mem_region(res->start, resource_size(res), "dma-pl330");
+
+        pi->base = ioremap(res->start, resource_size(res));
+        if (!pi->base) {
+                ret = -ENXIO;
+                goto probe_err1;
+        }
+
+        irq = adev->irq[0];
+        ret = request_irq(irq, pl330_irq_handler, 0,
+                        dev_name(&adev->dev), pi);
+        if (ret)
+                goto probe_err2;
+
+        ret = pl330_add(pi);
+        if (ret)
+                goto probe_err3;
+
+        INIT_LIST_HEAD(&pdmac->desc_pool);
+        spin_lock_init(&pdmac->pool_lock);
+
+        /* Create a descriptor pool of default size */
+        if (!add_desc(pdmac, GFP_KERNEL, NR_DEFAULT_DESC))
+                dev_warn(&adev->dev, "unable to allocate desc\n");
+
+        pd = &pdmac->ddma;
+        INIT_LIST_HEAD(&pd->channels);
+
+        /* Initialize channel parameters */
+        for (i = 0; i < pdat->nr_valid_peri; i++) {
+                struct dma_pl330_peri *peri = &pdat->peri[i];
+                pch = &pdmac->peripherals[i];
+
+                switch (peri->rqtype) {
+                case MEMTOMEM:
+                        dma_cap_set(DMA_MEMCPY, pd->cap_mask);
+                        break;
+                case MEMTODEV:
+                case DEVTOMEM:
+                        dma_cap_set(DMA_SLAVE, pd->cap_mask);
+                        break;
+                default:
+                        dev_err(&adev->dev, "DEVTODEV Not Supported\n");
+                        continue;
+                }
+
+                INIT_LIST_HEAD(&pch->work_list);
+                spin_lock_init(&pch->lock);
+                pch->pl330_chid = NULL;
+                pch->chan.private = peri;
+                pch->chan.device = pd;
+                pch->chan.chan_id = i;
+                pch->dmac = pdmac;
+
+                /* Add the channel to the DMAC list */
+                pd->chancnt++;
+                list_add_tail(&pch->chan.device_node, &pd->channels);
+        }
+
+        pd->dev = &adev->dev;
+
+        pd->device_alloc_chan_resources = pl330_alloc_chan_resources;
+        pd->device_free_chan_resources = pl330_free_chan_resources;
+        pd->device_prep_dma_memcpy = pl330_prep_dma_memcpy;
+        pd->device_tx_status = pl330_tx_status;
+        pd->device_prep_slave_sg = pl330_prep_slave_sg;
+        pd->device_control = pl330_control;
+        pd->device_issue_pending = pl330_issue_pending;
+
+        ret = dma_async_device_register(pd);
+        if (ret) {
+                dev_err(&adev->dev, "unable to register DMAC\n");
+                goto probe_err4;
+        }
+
+        amba_set_drvdata(adev, pdmac);
+
+        dev_info(&adev->dev,
+                "Loaded driver for PL330 DMAC-%d\n", adev->periphid);
+        dev_info(&adev->dev,
+                "\tDBUFF-%ux%ubytes Num_Chans-%u Num_Peri-%u Num_Events-%u\n",
+                pi->pcfg.data_buf_dep,
+                pi->pcfg.data_bus_width / 8, pi->pcfg.num_chan,
+                pi->pcfg.num_peri, pi->pcfg.num_events);
+
+        return 0;
+
+probe_err4:
+        pl330_del(pi);
+probe_err3:
+        free_irq(irq, pi);
+probe_err2:
+        iounmap(pi->base);
+probe_err1:
+        release_mem_region(res->start, resource_size(res));
+        kfree(pdmac);
+
+        return ret;
+}
+
+static int __devexit pl330_remove(struct amba_device *adev)
+{
+        struct dma_pl330_dmac *pdmac = amba_get_drvdata(adev);
+        struct dma_pl330_chan *pch, *_p;
+        struct pl330_info *pi;
+        struct resource *res;
+        int irq;
+
+        if (!pdmac)
+                return 0;
+
+        amba_set_drvdata(adev, NULL);
+
+        /* Idle the DMAC */
+        list_for_each_entry_safe(pch, _p, &pdmac->ddma.channels,
+                        chan.device_node) {
+
+                /* Remove the channel */
+                list_del(&pch->chan.device_node);
+
+                /* Flush the channel */
+                pl330_control(&pch->chan, DMA_TERMINATE_ALL, 0);
+                pl330_free_chan_resources(&pch->chan);
+        }
+
+        pi = &pdmac->pif;
+
+        pl330_del(pi);
+
+        irq = adev->irq[0];
+        free_irq(irq, pi);
+
+        iounmap(pi->base);
+
+        res = &adev->res;
+        release_mem_region(res->start, resource_size(res));
+
+        kfree(pdmac);
+
+        return 0;
+}
+
+static struct amba_id pl330_ids[] = {
+        {
+                .id     = 0x00041330,
+                .mask   = 0x000fffff,
+        },
+        { 0, 0 },
+};
+
+static struct amba_driver pl330_driver = {
+        .drv = {
+                .owner = THIS_MODULE,
+                .name = "dma-pl330",
+        },
+        .id_table = pl330_ids,
+        .probe = pl330_probe,
+        .remove = pl330_remove,
+};
+
+static int __init pl330_init(void)
+{
+        return amba_driver_register(&pl330_driver);
+}
+module_init(pl330_init);
+
+static void __exit pl330_exit(void)
+{
+        amba_driver_unregister(&pl330_driver);
+        return;
+}
+module_exit(pl330_exit);
+
+MODULE_AUTHOR("Jaswinder Singh <jassi.brar@samsung.com>");
+MODULE_DESCRIPTION("API Driver for PL330 DMAC");
+MODULE_LICENSE("GPL");
diff --git a/drivers/edac/i5000_edac.c b/drivers/edac/i5000_edac.c
index adc10a2ac5f6..996c1bdb5a34 100644
--- a/drivers/edac/i5000_edac.c
+++ b/drivers/edac/i5000_edac.c
@@ -774,7 +774,7 @@ static void i5000_clear_error(struct mem_ctl_info *mci)
 static void i5000_check_error(struct mem_ctl_info *mci)
 {
         struct i5000_error_info info;
-        debugf4("MC%d: " __FILE__ ": %s()\n", mci->mc_idx, __func__);
+        debugf4("MC%d: %s: %s()\n", mci->mc_idx, __FILE__, __func__);
         i5000_get_error_info(mci, &info);
         i5000_process_error_info(mci, &info, 1);
 }
@@ -1353,8 +1353,8 @@ static int i5000_probe1(struct pci_dev *pdev, int dev_idx)
         int num_dimms_per_channel;
         int num_csrows;
 
-        debugf0("MC: " __FILE__ ": %s(), pdev bus %u dev=0x%x fn=0x%x\n",
-                __func__,
+        debugf0("MC: %s: %s(), pdev bus %u dev=0x%x fn=0x%x\n",
+                __FILE__, __func__,
                 pdev->bus->number,
                 PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn));
 
@@ -1389,7 +1389,7 @@ static int i5000_probe1(struct pci_dev *pdev, int dev_idx)
                 return -ENOMEM;
 
         kobject_get(&mci->edac_mci_kobj);
-        debugf0("MC: " __FILE__ ": %s(): mci = %p\n", __func__, mci);
+        debugf0("MC: %s: %s(): mci = %p\n", __FILE__, __func__, mci);
 
         mci->dev = &pdev->dev;  /* record ptr  to the generic device */
 
@@ -1432,8 +1432,8 @@ static int i5000_probe1(struct pci_dev *pdev, int dev_idx)
 
         /* add this new MC control structure to EDAC's list of MCs */
         if (edac_mc_add_mc(mci)) {
-                debugf0("MC: " __FILE__
-                        ": %s(): failed edac_mc_add_mc()\n", __func__);
+                debugf0("MC: %s: %s(): failed edac_mc_add_mc()\n",
+                        __FILE__, __func__);
                 /* FIXME: perhaps some code should go here that disables error
                  * reporting if we just enabled it
                  */
@@ -1478,7 +1478,7 @@ static int __devinit i5000_init_one(struct pci_dev *pdev,
 {
         int rc;
 
-        debugf0("MC: " __FILE__ ": %s()\n", __func__);
+        debugf0("MC: %s: %s()\n", __FILE__, __func__);
 
         /* wake up device */
         rc = pci_enable_device(pdev);
@@ -1497,7 +1497,7 @@ static void __devexit i5000_remove_one(struct pci_dev *pdev)
 {
         struct mem_ctl_info *mci;
 
-        debugf0(__FILE__ ": %s()\n", __func__);
+        debugf0("%s: %s()\n", __FILE__, __func__);
 
         if (i5000_pci)
                 edac_pci_release_generic_ctl(i5000_pci);
@@ -1544,7 +1544,7 @@ static int __init i5000_init(void)
 {
         int pci_rc;
 
-        debugf2("MC: " __FILE__ ": %s()\n", __func__);
+        debugf2("MC: %s: %s()\n", __FILE__, __func__);
 
        /* Ensure that the OPSTATE is set correctly for POLL or NMI */
        opstate_init();
@@ -1560,7 +1560,7 @@ static int __init i5000_init(void)
  */
 static void __exit i5000_exit(void)
 {
-        debugf2("MC: " __FILE__ ": %s()\n", __func__);
+        debugf2("MC: %s: %s()\n", __FILE__, __func__);
         pci_unregister_driver(&i5000_driver);
 }
 
diff --git a/drivers/edac/i5400_edac.c b/drivers/edac/i5400_edac.c
index f99d10655ed4..010c1d6526f5 100644
--- a/drivers/edac/i5400_edac.c
+++ b/drivers/edac/i5400_edac.c
@@ -694,7 +694,7 @@ static void i5400_clear_error(struct mem_ctl_info *mci)
 static void i5400_check_error(struct mem_ctl_info *mci)
 {
         struct i5400_error_info info;
-        debugf4("MC%d: " __FILE__ ": %s()\n", mci->mc_idx, __func__);
+        debugf4("MC%d: %s: %s()\n", mci->mc_idx, __FILE__, __func__);
         i5400_get_error_info(mci, &info);
         i5400_process_error_info(mci, &info);
 }
@@ -1227,8 +1227,8 @@ static int i5400_probe1(struct pci_dev *pdev, int dev_idx)
         if (dev_idx >= ARRAY_SIZE(i5400_devs))
                 return -EINVAL;
 
-        debugf0("MC: " __FILE__ ": %s(), pdev bus %u dev=0x%x fn=0x%x\n",
-                __func__,
+        debugf0("MC: %s: %s(), pdev bus %u dev=0x%x fn=0x%x\n",
+                __FILE__, __func__,
                 pdev->bus->number,
                 PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn));
 
@@ -1256,7 +1256,7 @@ static int i5400_probe1(struct pci_dev *pdev, int dev_idx)
         if (mci == NULL)
                 return -ENOMEM;
 
-        debugf0("MC: " __FILE__ ": %s(): mci = %p\n", __func__, mci);
+        debugf0("MC: %s: %s(): mci = %p\n", __FILE__, __func__, mci);
 
         mci->dev = &pdev->dev;  /* record ptr  to the generic device */
 
@@ -1299,8 +1299,8 @@ static int i5400_probe1(struct pci_dev *pdev, int dev_idx)
 
         /* add this new MC control structure to EDAC's list of MCs */
         if (edac_mc_add_mc(mci)) {
-                debugf0("MC: " __FILE__
-                        ": %s(): failed edac_mc_add_mc()\n", __func__);
+                debugf0("MC: %s: %s(): failed edac_mc_add_mc()\n",
+                        __FILE__, __func__);
                 /* FIXME: perhaps some code should go here that disables error
                  * reporting if we just enabled it
                  */
@@ -1344,7 +1344,7 @@ static int __devinit i5400_init_one(struct pci_dev *pdev,
 {
         int rc;
 
-        debugf0("MC: " __FILE__ ": %s()\n", __func__);
+        debugf0("MC: %s: %s()\n", __FILE__, __func__);
 
         /* wake up device */
         rc = pci_enable_device(pdev);
@@ -1363,7 +1363,7 @@ static void __devexit i5400_remove_one(struct pci_dev *pdev)
 {
         struct mem_ctl_info *mci;
 
-        debugf0(__FILE__ ": %s()\n", __func__);
+        debugf0("%s: %s()\n", __FILE__, __func__);
 
         if (i5400_pci)
                 edac_pci_release_generic_ctl(i5400_pci);
@@ -1409,7 +1409,7 @@ static int __init i5400_init(void)
 {
         int pci_rc;
 
-        debugf2("MC: " __FILE__ ": %s()\n", __func__);
+        debugf2("MC: %s: %s()\n", __FILE__, __func__);
 
         /* Ensure that the OPSTATE is set correctly for POLL or NMI */
         opstate_init();
@@ -1425,7 +1425,7 @@ static int __init i5400_init(void)
  */
 static void __exit i5400_exit(void)
 {
-        debugf2("MC: " __FILE__ ": %s()\n", __func__);
+        debugf2("MC: %s: %s()\n", __FILE__, __func__);
         pci_unregister_driver(&i5400_driver);
 }
 
diff --git a/drivers/edac/i82443bxgx_edac.c b/drivers/edac/i82443bxgx_edac.c
index 2bf2c5051bfe..a2fa1feed724 100644
--- a/drivers/edac/i82443bxgx_edac.c
+++ b/drivers/edac/i82443bxgx_edac.c
@@ -178,7 +178,7 @@ static void i82443bxgx_edacmc_check(struct mem_ctl_info *mci)
 {
         struct i82443bxgx_edacmc_error_info info;
 
-        debugf1("MC%d: " __FILE__ ": %s()\n", mci->mc_idx, __func__);
+        debugf1("MC%d: %s: %s()\n", mci->mc_idx, __FILE__, __func__);
         i82443bxgx_edacmc_get_error_info(mci, &info);
         i82443bxgx_edacmc_process_error_info(mci, &info, 1);
 }
@@ -198,13 +198,13 @@ static void i82443bxgx_init_csrows(struct mem_ctl_info *mci,
         for (index = 0; index < mci->nr_csrows; index++) {
                 csrow = &mci->csrows[index];
                 pci_read_config_byte(pdev, I82443BXGX_DRB + index, &drbar);
-                debugf1("MC%d: " __FILE__ ": %s() Row=%d DRB = %#0x\n",
-                        mci->mc_idx, __func__, index, drbar);
+                debugf1("MC%d: %s: %s() Row=%d DRB = %#0x\n",
+                        mci->mc_idx, __FILE__, __func__, index, drbar);
                 row_high_limit = ((u32) drbar << 23);
                 /* find the DRAM Chip Select Base address and mask */
-                debugf1("MC%d: " __FILE__ ": %s() Row=%d, "
-                        "Boundry Address=%#0x, Last = %#0x \n",
-                        mci->mc_idx, __func__, index, row_high_limit,
+                debugf1("MC%d: %s: %s() Row=%d, "
+                        "Boundry Address=%#0x, Last = %#0x\n",
+                        mci->mc_idx, __FILE__, __func__, index, row_high_limit,
                         row_high_limit_last);
 
                 /* 440GX goes to 2GB, represented with a DRB of 0. */
@@ -237,7 +237,7 @@ static int i82443bxgx_edacmc_probe1(struct pci_dev *pdev, int dev_idx)
         enum mem_type mtype;
         enum edac_type edac_mode;
 
-        debugf0("MC: " __FILE__ ": %s()\n", __func__);
+        debugf0("MC: %s: %s()\n", __FILE__, __func__);
 
         /* Something is really hosed if PCI config space reads from
          * the MC aren't working.
@@ -250,7 +250,7 @@ static int i82443bxgx_edacmc_probe1(struct pci_dev *pdev, int dev_idx)
         if (mci == NULL)
                 return -ENOMEM;
 
-        debugf0("MC: " __FILE__ ": %s(): mci = %p\n", __func__, mci);
+        debugf0("MC: %s: %s(): mci = %p\n", __FILE__, __func__, mci);
         mci->dev = &pdev->dev;
         mci->mtype_cap = MEM_FLAG_EDO | MEM_FLAG_SDR | MEM_FLAG_RDR;
         mci->edac_ctl_cap = EDAC_FLAG_NONE | EDAC_FLAG_EC | EDAC_FLAG_SECDED;
@@ -336,7 +336,7 @@ static int i82443bxgx_edacmc_probe1(struct pci_dev *pdev, int dev_idx)
                         __func__);
         }
 
-        debugf3("MC: " __FILE__ ": %s(): success\n", __func__);
+        debugf3("MC: %s: %s(): success\n", __FILE__, __func__);
         return 0;
 
 fail:
@@ -352,7 +352,7 @@ static int __devinit i82443bxgx_edacmc_init_one(struct pci_dev *pdev,
 {
         int rc;
 
-        debugf0("MC: " __FILE__ ": %s()\n", __func__);
+        debugf0("MC: %s: %s()\n", __FILE__, __func__);
 
         /* don't need to call pci_enable_device() */
         rc = i82443bxgx_edacmc_probe1(pdev, ent->driver_data);
@@ -367,7 +367,7 @@ static void __devexit i82443bxgx_edacmc_remove_one(struct pci_dev *pdev)
 {
         struct mem_ctl_info *mci;
 
-        debugf0(__FILE__ ": %s()\n", __func__);
+        debugf0("%s: %s()\n", __FILE__, __func__);
 
         if (i82443bxgx_pci)
                 edac_pci_release_generic_ctl(i82443bxgx_pci);
diff --git a/drivers/firewire/core-card.c b/drivers/firewire/core-card.c
index 5045156c5313..9dcb30466ec0 100644
--- a/drivers/firewire/core-card.c
+++ b/drivers/firewire/core-card.c
@@ -30,7 +30,6 @@
 #include <linux/module.h>
 #include <linux/mutex.h>
 #include <linux/spinlock.h>
-#include <linux/timer.h>
 #include <linux/workqueue.h>
 
 #include <asm/atomic.h>
@@ -63,7 +62,7 @@ static size_t config_rom_length = 1 + 4 + 1 + 1;
 #define BIB_CRC(v)              ((v) <<  0)
 #define BIB_CRC_LENGTH(v)       ((v) << 16)
 #define BIB_INFO_LENGTH(v)      ((v) << 24)
-
+#define BIB_BUS_NAME            0x31333934 /* "1394" */
 #define BIB_LINK_SPEED(v)       ((v) <<  0)
 #define BIB_GENERATION(v)       ((v) <<  4)
 #define BIB_MAX_ROM(v)          ((v) <<  8)
@@ -73,7 +72,8 @@ static size_t config_rom_length = 1 + 4 + 1 + 1;
 #define BIB_BMC                 ((1) << 28)
 #define BIB_ISC                 ((1) << 29)
 #define BIB_CMC                 ((1) << 30)
-#define BIB_IMC                 ((1) << 31)
+#define BIB_IRMC                ((1) << 31)
+#define NODE_CAPABILITIES       0x0c0083c0 /* per IEEE 1394 clause 8.3.2.6.5.2 */
 
 static void generate_config_rom(struct fw_card *card, __be32 *config_rom)
 {
@@ -91,18 +91,18 @@ static void generate_config_rom(struct fw_card *card, __be32 *config_rom)
 
         config_rom[0] = cpu_to_be32(
                 BIB_CRC_LENGTH(4) | BIB_INFO_LENGTH(4) | BIB_CRC(0));
-        config_rom[1] = cpu_to_be32(0x31333934);
+        config_rom[1] = cpu_to_be32(BIB_BUS_NAME);
         config_rom[2] = cpu_to_be32(
                 BIB_LINK_SPEED(card->link_speed) |
                 BIB_GENERATION(card->config_rom_generation++ % 14 + 2) |
                 BIB_MAX_ROM(2) |
                 BIB_MAX_RECEIVE(card->max_receive) |
-                BIB_BMC | BIB_ISC | BIB_CMC | BIB_IMC);
+                BIB_BMC | BIB_ISC | BIB_CMC | BIB_IRMC);
         config_rom[3] = cpu_to_be32(card->guid >> 32);
         config_rom[4] = cpu_to_be32(card->guid);
 
         /* Generate root directory. */
-        config_rom[6] = cpu_to_be32(0x0c0083c0); /* node capabilities */
+        config_rom[6] = cpu_to_be32(NODE_CAPABILITIES);
         i = 7;
         j = 7 + descriptor_count;
 
@@ -407,13 +407,6 @@ static void fw_card_bm_work(struct work_struct *work)
         fw_card_put(card);
 }
 
-static void flush_timer_callback(unsigned long data)
-{
-        struct fw_card *card = (struct fw_card *)data;
-
-        fw_flush_transactions(card);
-}
-
 void fw_card_initialize(struct fw_card *card,
                         const struct fw_card_driver *driver,
                         struct device *device)
@@ -432,8 +425,6 @@ void fw_card_initialize(struct fw_card *card,
         init_completion(&card->done);
         INIT_LIST_HEAD(&card->transaction_list);
         spin_lock_init(&card->lock);
-        setup_timer(&card->flush_timer,
-                    flush_timer_callback, (unsigned long)card);
 
         card->local_node = NULL;
 
@@ -558,7 +549,6 @@ void fw_core_remove_card(struct fw_card *card)
         wait_for_completion(&card->done);
 
         WARN_ON(!list_empty(&card->transaction_list));
-        del_timer_sync(&card->flush_timer);
 }
 EXPORT_SYMBOL(fw_core_remove_card);
 
diff --git a/drivers/firewire/core-cdev.c b/drivers/firewire/core-cdev.c
index 14a34d99eea2..5bf106b9d791 100644
--- a/drivers/firewire/core-cdev.c
+++ b/drivers/firewire/core-cdev.c
@@ -227,7 +227,7 @@ static int fw_device_op_open(struct inode *inode, struct file *file)
         list_add_tail(&client->link, &device->client_list);
         mutex_unlock(&device->client_list_mutex);
 
-        return 0;
+        return nonseekable_open(inode, file);
 }
 
 static void queue_event(struct client *client, struct event *event,
@@ -1496,13 +1496,13 @@ static unsigned int fw_device_op_poll(struct file *file, poll_table * pt)
 
 const struct file_operations fw_device_ops = {
         .owner          = THIS_MODULE,
+        .llseek         = no_llseek,
         .open           = fw_device_op_open,
         .read           = fw_device_op_read,
         .unlocked_ioctl = fw_device_op_ioctl,
-        .poll           = fw_device_op_poll,
-        .release        = fw_device_op_release,
         .mmap           = fw_device_op_mmap,
-
+        .release        = fw_device_op_release,
+        .poll           = fw_device_op_poll,
 #ifdef CONFIG_COMPAT
         .compat_ioctl   = fw_device_op_compat_ioctl,
 #endif
diff --git a/drivers/firewire/core-transaction.c b/drivers/firewire/core-transaction.c
index 673b03f8b4ec..fdc33ff06dc1 100644
--- a/drivers/firewire/core-transaction.c
+++ b/drivers/firewire/core-transaction.c
@@ -81,7 +81,7 @@ static int close_transaction(struct fw_transaction *transaction,
         spin_lock_irqsave(&card->lock, flags);
         list_for_each_entry(t, &card->transaction_list, link) {
                 if (t == transaction) {
-                        list_del(&t->link);
+                        list_del_init(&t->link);
                         card->tlabel_mask &= ~(1ULL << t->tlabel);
                         break;
                 }
@@ -89,6 +89,7 @@ static int close_transaction(struct fw_transaction *transaction,
         spin_unlock_irqrestore(&card->lock, flags);
 
         if (&t->link != &card->transaction_list) {
+                del_timer_sync(&t->split_timeout_timer);
                 t->callback(card, rcode, NULL, 0, t->callback_data);
                 return 0;
         }
@@ -121,6 +122,31 @@ int fw_cancel_transaction(struct fw_card *card,
 }
 EXPORT_SYMBOL(fw_cancel_transaction);
 
+static void split_transaction_timeout_callback(unsigned long data)
+{
+        struct fw_transaction *t = (struct fw_transaction *)data;
+        struct fw_card *card = t->card;
+        unsigned long flags;
+
+        spin_lock_irqsave(&card->lock, flags);
+        if (list_empty(&t->link)) {
+                spin_unlock_irqrestore(&card->lock, flags);
+                return;
+        }
+        list_del(&t->link);
+        card->tlabel_mask &= ~(1ULL << t->tlabel);
+        spin_unlock_irqrestore(&card->lock, flags);
+
+        card->driver->cancel_packet(card, &t->packet);
+
+        /*
+         * At this point cancel_packet will never call the transaction
+         * callback, since we just took the transaction out of the list.
+         * So do it here.
+         */
+        t->callback(card, RCODE_CANCELLED, NULL, 0, t->callback_data);
+}
+
 static void transmit_complete_callback(struct fw_packet *packet,
                                        struct fw_card *card, int status)
 {
@@ -229,6 +255,23 @@ static void fw_fill_request(struct fw_packet *packet, int tcode, int tlabel,
         packet->payload_mapped = false;
 }
 
+static int allocate_tlabel(struct fw_card *card)
+{
+        int tlabel;
+
+        tlabel = card->current_tlabel;
+        while (card->tlabel_mask & (1ULL << tlabel)) {
+                tlabel = (tlabel + 1) & 0x3f;
+                if (tlabel == card->current_tlabel)
+                        return -EBUSY;
+        }
+
+        card->current_tlabel = (tlabel + 1) & 0x3f;
+        card->tlabel_mask |= 1ULL << tlabel;
+
+        return tlabel;
+}
+
 /**
  * This function provides low-level access to the IEEE1394 transaction
  * logic.  Most C programs would use either fw_read(), fw_write() or
@@ -277,31 +320,26 @@ void fw_send_request(struct fw_card *card, struct fw_transaction *t, int tcode,
         int tlabel;
 
         /*
-         * Bump the flush timer up 100ms first of all so we
-         * don't race with a flush timer callback.
-         */
-
-        mod_timer(&card->flush_timer, jiffies + DIV_ROUND_UP(HZ, 10));
-
-        /*
          * Allocate tlabel from the bitmap and put the transaction on
          * the list while holding the card spinlock.
          */
 
         spin_lock_irqsave(&card->lock, flags);
 
-        tlabel = card->current_tlabel;
-        if (card->tlabel_mask & (1ULL << tlabel)) {
+        tlabel = allocate_tlabel(card);
+        if (tlabel < 0) {
                 spin_unlock_irqrestore(&card->lock, flags);
                 callback(card, RCODE_SEND_ERROR, NULL, 0, callback_data);
                 return;
         }
 
-        card->current_tlabel = (card->current_tlabel + 1) & 0x3f;
-        card->tlabel_mask |= (1ULL << tlabel);
-
         t->node_id = destination_id;
         t->tlabel = tlabel;
+        t->card = card;
+        setup_timer(&t->split_timeout_timer,
+                    split_transaction_timeout_callback, (unsigned long)t);
+        /* FIXME: start this timer later, relative to t->timestamp */
+        mod_timer(&t->split_timeout_timer, jiffies + DIV_ROUND_UP(HZ, 10));
         t->callback = callback;
         t->callback_data = callback_data;
 
@@ -347,11 +385,13 @@ int fw_run_transaction(struct fw_card *card, int tcode, int destination_id,
         struct transaction_callback_data d;
         struct fw_transaction t;
 
+        init_timer_on_stack(&t.split_timeout_timer);
         init_completion(&d.done);
         d.payload = payload;
         fw_send_request(card, &t, tcode, destination_id, generation, speed,
                         offset, payload, length, transaction_callback, &d);
         wait_for_completion(&d.done);
+        destroy_timer_on_stack(&t.split_timeout_timer);
 
         return d.rcode;
 }
@@ -394,30 +434,6 @@ void fw_send_phy_config(struct fw_card *card,
         mutex_unlock(&phy_config_mutex);
 }
 
-void fw_flush_transactions(struct fw_card *card)
-{
-        struct fw_transaction *t, *next;
-        struct list_head list;
-        unsigned long flags;
-
-        INIT_LIST_HEAD(&list);
-        spin_lock_irqsave(&card->lock, flags);
-        list_splice_init(&card->transaction_list, &list);
-        card->tlabel_mask = 0;
-        spin_unlock_irqrestore(&card->lock, flags);
-
-        list_for_each_entry_safe(t, next, &list, link) {
-                card->driver->cancel_packet(card, &t->packet);
-
-                /*
-                 * At this point cancel_packet will never call the
-                 * transaction callback, since we just took all the
-                 * transactions out of the list.  So do it here.
-                 */
-                t->callback(card, RCODE_CANCELLED, NULL, 0, t->callback_data);
-        }
-}
-
 static struct fw_address_handler *lookup_overlapping_address_handler(
         struct list_head *list, unsigned long long offset, size_t length)
 {
@@ -827,8 +843,8 @@ void fw_core_handle_response(struct fw_card *card, struct fw_packet *p)
         spin_lock_irqsave(&card->lock, flags);
         list_for_each_entry(t, &card->transaction_list, link) {
                 if (t->node_id == source && t->tlabel == tlabel) {
-                        list_del(&t->link);
-                        card->tlabel_mask &= ~(1 << t->tlabel);
+                        list_del_init(&t->link);
+                        card->tlabel_mask &= ~(1ULL << t->tlabel);
                         break;
                 }
         }
@@ -869,6 +885,8 @@ void fw_core_handle_response(struct fw_card *card, struct fw_packet *p)
                 break;
         }
 
+        del_timer_sync(&t->split_timeout_timer);
+
         /*
          * The response handler may be executed while the request handler
          * is still pending.  Cancel the request handler.
diff --git a/drivers/firewire/core.h b/drivers/firewire/core.h
index fb0321300cce..0ecfcd95f4c5 100644
--- a/drivers/firewire/core.h
+++ b/drivers/firewire/core.h
@@ -27,7 +27,12 @@ struct fw_packet;
 #define PHY_LINK_ACTIVE         0x80
 #define PHY_CONTENDER           0x40
 #define PHY_BUS_RESET           0x40
+#define PHY_EXTENDED_REGISTERS  0xe0
 #define PHY_BUS_SHORT_RESET     0x40
+#define PHY_INT_STATUS_BITS     0x3c
+#define PHY_ENABLE_ACCEL        0x02
+#define PHY_ENABLE_MULTI        0x01
+#define PHY_PAGE_SELECT         0xe0
 
 #define BANDWIDTH_AVAILABLE_INITIAL     4915
 #define BROADCAST_CHANNEL_INITIAL       (1 << 31 | 31)
@@ -215,7 +220,6 @@ void fw_core_handle_request(struct fw_card *card, struct fw_packet *request);
 void fw_core_handle_response(struct fw_card *card, struct fw_packet *packet);
 void fw_fill_response(struct fw_packet *response, u32 *request_header,
                       int rcode, void *payload, size_t length);
-void fw_flush_transactions(struct fw_card *card);
 void fw_send_phy_config(struct fw_card *card,
                         int node_id, int generation, int gap_count);
 
diff --git a/drivers/firewire/ohci.c b/drivers/firewire/ohci.c
index a3b083a7403a..9f627e758cfc 100644
--- a/drivers/firewire/ohci.c
+++ b/drivers/firewire/ohci.c
@@ -236,13 +236,15 @@ static char ohci_driver_name[] = KBUILD_MODNAME;
 #define QUIRK_CYCLE_TIMER               1
 #define QUIRK_RESET_PACKET              2
 #define QUIRK_BE_HEADERS                4
+#define QUIRK_NO_1394A                  8
 
 /* In case of multiple matches in ohci_quirks[], only the first one is used. */
 static const struct {
         unsigned short vendor, device, flags;
 } ohci_quirks[] = {
         {PCI_VENDOR_ID_TI,      PCI_DEVICE_ID_TI_TSB12LV22, QUIRK_CYCLE_TIMER |
-                                                            QUIRK_RESET_PACKET},
+                                                            QUIRK_RESET_PACKET |
+                                                            QUIRK_NO_1394A},
         {PCI_VENDOR_ID_TI,      PCI_ANY_ID,     QUIRK_RESET_PACKET},
         {PCI_VENDOR_ID_AL,      PCI_ANY_ID,     QUIRK_CYCLE_TIMER},
         {PCI_VENDOR_ID_NEC,     PCI_ANY_ID,     QUIRK_CYCLE_TIMER},
@@ -257,15 +259,16 @@ MODULE_PARM_DESC(quirks, "Chip quirks (default = 0"
         ", nonatomic cycle timer = "    __stringify(QUIRK_CYCLE_TIMER)
         ", reset packet generation = "  __stringify(QUIRK_RESET_PACKET)
         ", AR/selfID endianess = "      __stringify(QUIRK_BE_HEADERS)
+        ", no 1394a enhancements = "    __stringify(QUIRK_NO_1394A)
         ")");
 
-#ifdef CONFIG_FIREWIRE_OHCI_DEBUG
-
 #define OHCI_PARAM_DEBUG_AT_AR          1
 #define OHCI_PARAM_DEBUG_SELFIDS        2
 #define OHCI_PARAM_DEBUG_IRQS           4
 #define OHCI_PARAM_DEBUG_BUSRESETS      8 /* only effective before chip init */
 
+#ifdef CONFIG_FIREWIRE_OHCI_DEBUG
+
 static int param_debug;
 module_param_named(debug, param_debug, int, 0644);
 MODULE_PARM_DESC(debug, "Verbose logging (default = 0"
@@ -438,9 +441,10 @@ static void log_ar_at_event(char dir, int speed, u32 *header, int evt)
 
 #else
 
-#define log_irqs(evt)
-#define log_selfids(node_id, generation, self_id_count, sid)
-#define log_ar_at_event(dir, speed, header, evt)
+#define param_debug 0
+static inline void log_irqs(u32 evt) {}
+static inline void log_selfids(int node_id, int generation, int self_id_count, u32 *s) {}
+static inline void log_ar_at_event(char dir, int speed, u32 *header, int evt) {}
 
 #endif /* CONFIG_FIREWIRE_OHCI_DEBUG */
 
@@ -460,27 +464,71 @@ static inline void flush_writes(const struct fw_ohci *ohci)
         reg_read(ohci, OHCI1394_Version);
 }
 
-static int ohci_update_phy_reg(struct fw_card *card, int addr,
-                               int clear_bits, int set_bits)
+static int read_phy_reg(struct fw_ohci *ohci, int addr)
 {
-        struct fw_ohci *ohci = fw_ohci(card);
-        u32 val, old;
+        u32 val;
+        int i;
 
         reg_write(ohci, OHCI1394_PhyControl, OHCI1394_PhyControl_Read(addr));
-        flush_writes(ohci);
-        msleep(2);
-        val = reg_read(ohci, OHCI1394_PhyControl);
-        if ((val & OHCI1394_PhyControl_ReadDone) == 0) {
-                fw_error("failed to set phy reg bits.\n");
-                return -EBUSY;
+        for (i = 0; i < 10; i++) {
+                val = reg_read(ohci, OHCI1394_PhyControl);
+                if (val & OHCI1394_PhyControl_ReadDone)
+                        return OHCI1394_PhyControl_ReadData(val);
+
+                msleep(1);
         }
+        fw_error("failed to read phy reg\n");
+
+        return -EBUSY;
+}
+
+static int write_phy_reg(const struct fw_ohci *ohci, int addr, u32 val)
+{
+        int i;
 
-        old = OHCI1394_PhyControl_ReadData(val);
-        old = (old & ~clear_bits) | set_bits;
         reg_write(ohci, OHCI1394_PhyControl,
-                  OHCI1394_PhyControl_Write(addr, old));
+                  OHCI1394_PhyControl_Write(addr, val));
+        for (i = 0; i < 100; i++) {
+                val = reg_read(ohci, OHCI1394_PhyControl);
+                if (!(val & OHCI1394_PhyControl_WritePending))
+                        return 0;
 
-        return 0;
+                msleep(1);
+        }
+        fw_error("failed to write phy reg\n");
+
+        return -EBUSY;
+}
+
+static int ohci_update_phy_reg(struct fw_card *card, int addr,
+                               int clear_bits, int set_bits)
+{
+        struct fw_ohci *ohci = fw_ohci(card);
+        int ret;
+
+        ret = read_phy_reg(ohci, addr);
+        if (ret < 0)
+                return ret;
+
+        /*
+         * The interrupt status bits are cleared by writing a one bit.
+         * Avoid clearing them unless explicitly requested in set_bits.
+         */
+        if (addr == 5)
+                clear_bits |= PHY_INT_STATUS_BITS;
+
+        return write_phy_reg(ohci, addr, (ret & ~clear_bits) | set_bits);
+}
+
+static int read_paged_phy_reg(struct fw_ohci *ohci, int page, int addr)
+{
+        int ret;
+
+        ret = ohci_update_phy_reg(&ohci->card, 7, PHY_PAGE_SELECT, page << 5);
+        if (ret < 0)
+                return ret;
+
+        return read_phy_reg(ohci, addr);
 }
 
 static int ar_context_add_page(struct ar_context *ctx)
@@ -1495,13 +1543,64 @@ static void copy_config_rom(__be32 *dest, const __be32 *src, size_t length)
                 memset(&dest[length], 0, CONFIG_ROM_SIZE - size);
 }
 
+static int configure_1394a_enhancements(struct fw_ohci *ohci)
+{
+        bool enable_1394a;
+        int ret, clear, set, offset;
+
+        /* Check if the driver should configure link and PHY. */
+        if (!(reg_read(ohci, OHCI1394_HCControlSet) &
+              OHCI1394_HCControl_programPhyEnable))
+                return 0;
+
+        /* Paranoia: check whether the PHY supports 1394a, too. */
+        enable_1394a = false;
+        ret = read_phy_reg(ohci, 2);
+        if (ret < 0)
+                return ret;
+        if ((ret & PHY_EXTENDED_REGISTERS) == PHY_EXTENDED_REGISTERS) {
+                ret = read_paged_phy_reg(ohci, 1, 8);
+                if (ret < 0)
+                        return ret;
+                if (ret >= 1)
+                        enable_1394a = true;
+        }
+
+        if (ohci->quirks & QUIRK_NO_1394A)
+                enable_1394a = false;
+
+        /* Configure PHY and link consistently. */
+        if (enable_1394a) {
+                clear = 0;
+                set = PHY_ENABLE_ACCEL | PHY_ENABLE_MULTI;
+        } else {
+                clear = PHY_ENABLE_ACCEL | PHY_ENABLE_MULTI;
+                set = 0;
+        }
+        ret = ohci_update_phy_reg(&ohci->card, 5, clear, set);
+        if (ret < 0)
+                return ret;
+
+        if (enable_1394a)
+                offset = OHCI1394_HCControlSet;
+        else
+                offset = OHCI1394_HCControlClear;
+        reg_write(ohci, offset, OHCI1394_HCControl_aPhyEnhanceEnable);
+
+        /* Clean up: configuration has been taken care of. */
+        reg_write(ohci, OHCI1394_HCControlClear,
+                  OHCI1394_HCControl_programPhyEnable);
+
+        return 0;
+}
+
 static int ohci_enable(struct fw_card *card,
                        const __be32 *config_rom, size_t length)
 {
         struct fw_ohci *ohci = fw_ohci(card);
         struct pci_dev *dev = to_pci_dev(card->device);
         u32 lps;
-        int i;
+        int i, ret;
 
         if (software_reset(ohci)) {
                 fw_error("Failed to reset ohci card.\n");
@@ -1565,10 +1664,14 @@ static int ohci_enable(struct fw_card *card,
         if (param_debug & OHCI_PARAM_DEBUG_BUSRESETS)
                 reg_write(ohci, OHCI1394_IntMaskSet, OHCI1394_busReset);
 
+        ret = configure_1394a_enhancements(ohci);
+        if (ret < 0)
+                return ret;
+
         /* Activate link_on bit and contender bit in our self ID packets.*/
-        if (ohci_update_phy_reg(card, 4, 0,
-                                PHY_LINK_ACTIVE | PHY_CONTENDER) < 0)
-                return -EIO;
+        ret = ohci_update_phy_reg(card, 4, 0, PHY_LINK_ACTIVE | PHY_CONTENDER);
+        if (ret < 0)
+                return ret;
 
         /*
          * When the link is not yet enabled, the atomic config rom
@@ -2304,7 +2407,7 @@ static const struct fw_card_driver ohci_driver = {
 };
 
 #ifdef CONFIG_PPC_PMAC
-static void ohci_pmac_on(struct pci_dev *dev)
+static void pmac_ohci_on(struct pci_dev *dev)
 {
         if (machine_is(powermac)) {
                 struct device_node *ofn = pci_device_to_OF_node(dev);
@@ -2316,7 +2419,7 @@ static void ohci_pmac_on(struct pci_dev *dev)
         }
 }
 
-static void ohci_pmac_off(struct pci_dev *dev)
+static void pmac_ohci_off(struct pci_dev *dev)
 {
         if (machine_is(powermac)) {
                 struct device_node *ofn = pci_device_to_OF_node(dev);
@@ -2328,15 +2431,15 @@ static void ohci_pmac_off(struct pci_dev *dev)
         }
 }
 #else
-#define ohci_pmac_on(dev)
-#define ohci_pmac_off(dev)
+static inline void pmac_ohci_on(struct pci_dev *dev) {}
+static inline void pmac_ohci_off(struct pci_dev *dev) {}
 #endif /* CONFIG_PPC_PMAC */
 
 static int __devinit pci_probe(struct pci_dev *dev,
                                const struct pci_device_id *ent)
 {
         struct fw_ohci *ohci;
-        u32 bus_options, max_receive, link_speed, version;
+        u32 bus_options, max_receive, link_speed, version, link_enh;
         u64 guid;
         int i, err, n_ir, n_it;
         size_t size;
@@ -2349,7 +2452,7 @@ static int __devinit pci_probe(struct pci_dev *dev,
 
         fw_card_initialize(&ohci->card, &ohci_driver, &dev->dev);
 
-        ohci_pmac_on(dev);
+        pmac_ohci_on(dev);
 
         err = pci_enable_device(dev);
         if (err) {
@@ -2389,6 +2492,23 @@ static int __devinit pci_probe(struct pci_dev *dev,
         if (param_quirks)
                 ohci->quirks = param_quirks;
 
+        /* TI OHCI-Lynx and compatible: set recommended configuration bits. */
+        if (dev->vendor == PCI_VENDOR_ID_TI) {
+                pci_read_config_dword(dev, PCI_CFG_TI_LinkEnh, &link_enh);
+
+                /* adjust latency of ATx FIFO: use 1.7 KB threshold */
+                link_enh &= ~TI_LinkEnh_atx_thresh_mask;
+                link_enh |= TI_LinkEnh_atx_thresh_1_7K;
+
+                /* use priority arbitration for asynchronous responses */
+                link_enh |= TI_LinkEnh_enab_unfair;
+
+                /* required for aPhyEnhanceEnable to work */
+                link_enh |= TI_LinkEnh_enab_accel;
+
+                pci_write_config_dword(dev, PCI_CFG_TI_LinkEnh, link_enh);
+        }
+
         ar_context_init(&ohci->ar_request_ctx, ohci,
                         OHCI1394_AsReqRcvContextControlSet);
 
@@ -2466,7 +2586,7 @@ static int __devinit pci_probe(struct pci_dev *dev,
         pci_disable_device(dev);
  fail_free:
         kfree(&ohci->card);
-        ohci_pmac_off(dev);
+        pmac_ohci_off(dev);
  fail:
         if (err == -ENOMEM)
                 fw_error("Out of memory\n");
@@ -2509,7 +2629,7 @@ static void pci_remove(struct pci_dev *dev)
         pci_release_region(dev, 0);
         pci_disable_device(dev);
         kfree(&ohci->card);
-        ohci_pmac_off(dev);
+        pmac_ohci_off(dev);
 
         fw_notify("Removed fw-ohci device.\n");
 }
@@ -2530,7 +2650,7 @@ static int pci_suspend(struct pci_dev *dev, pm_message_t state)
         err = pci_set_power_state(dev, pci_choose_state(dev, state));
         if (err)
                 fw_error("pci_set_power_state failed with %d\n", err);
-        ohci_pmac_off(dev);
+        pmac_ohci_off(dev);
 
         return 0;
 }
@@ -2540,7 +2660,7 @@ static int pci_resume(struct pci_dev *dev)
         struct fw_ohci *ohci = pci_get_drvdata(dev);
         int err;
 
-        ohci_pmac_on(dev);
+        pmac_ohci_on(dev);
         pci_set_power_state(dev, PCI_D0);
         pci_restore_state(dev);
         err = pci_enable_device(dev);
diff --git a/drivers/firewire/ohci.h b/drivers/firewire/ohci.h
index ba492d85c516..3bc9a5d744eb 100644
--- a/drivers/firewire/ohci.h
+++ b/drivers/firewire/ohci.h
@@ -67,7 +67,7 @@
 #define   OHCI1394_PhyControl_ReadDone          0x80000000
 #define   OHCI1394_PhyControl_ReadData(r)       (((r) & 0x00ff0000) >> 16)
 #define   OHCI1394_PhyControl_Write(addr, data) (((addr) << 8) | (data) | 0x00004000)
-#define   OHCI1394_PhyControl_WriteDone         0x00004000
+#define   OHCI1394_PhyControl_WritePending      0x00004000
 #define OHCI1394_IsochronousCycleTimer        0x0F0
 #define OHCI1394_AsReqFilterHiSet             0x100
 #define OHCI1394_AsReqFilterHiClear           0x104
@@ -154,4 +154,12 @@
 
 #define OHCI1394_phy_tcode              0xe
 
+/* TI extensions */
+
+#define PCI_CFG_TI_LinkEnh              0xf4
+#define  TI_LinkEnh_enab_accel          0x00000002
+#define  TI_LinkEnh_enab_unfair         0x00000080
+#define  TI_LinkEnh_atx_thresh_mask     0x00003000
+#define  TI_LinkEnh_atx_thresh_1_7K     0x00001000
+
 #endif /* _FIREWIRE_OHCI_H */
diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig
index fee678f74a19..724038dab4ca 100644
--- a/drivers/gpio/Kconfig
+++ b/drivers/gpio/Kconfig
@@ -139,6 +139,13 @@ config GPIO_MAX732X
           Board setup code must specify the model to use, and the start
           number for these GPIOs.
 
+config GPIO_MAX732X_IRQ
+        bool "Interrupt controller support for MAX732x"
+        depends on GPIO_MAX732X=y && GENERIC_HARDIRQS
+        help
+          Say yes here to enable the max732x to be used as an interrupt
+          controller. It requires the driver to be built in the kernel.
+
 config GPIO_PCA953X
         tristate "PCA953x, PCA955x, TCA64xx, and MAX7310 I/O ports"
         depends on I2C
@@ -188,6 +195,13 @@ config GPIO_PCF857X
           This driver provides an in-kernel interface to those GPIOs using
           platform-neutral GPIO calls.
 
+config GPIO_TC35892
+        bool "TC35892 GPIOs"
+        depends on MFD_TC35892
+        help
+          This enables support for the GPIOs found on the TC35892
+          I/O Expander.
+
 config GPIO_TWL4030
         tristate "TWL4030, TWL5030, and TPS659x0 GPIOs"
         depends on TWL4030_CORE
@@ -264,10 +278,10 @@ config GPIO_BT8XX
           If unsure, say N.
 
 config GPIO_LANGWELL
-        bool "Intel Moorestown Platform Langwell GPIO support"
+        bool "Intel Langwell/Penwell GPIO support"
         depends on PCI
         help
-          Say Y here to support Intel Moorestown platform GPIO.
+          Say Y here to support Intel Langwell/Penwell GPIO.
 
 config GPIO_TIMBERDALE
         bool "Support for timberdale GPIO IP"
@@ -275,6 +289,15 @@ config GPIO_TIMBERDALE
         ---help---
         Add support for the GPIO IP in the timberdale FPGA.
 
+config GPIO_RDC321X
+        tristate "RDC R-321x GPIO support"
+        depends on PCI && GPIOLIB
+        select MFD_CORE
+        select MFD_RDC321X
+        help
+          Support for the RDC R321x SoC GPIOs over southbridge
+          PCI configuration space.
+
 comment "SPI GPIO expanders:"
 
 config GPIO_MAX7301
@@ -310,4 +333,14 @@ config GPIO_UCB1400
           To compile this driver as a module, choose M here: the
           module will be called ucb1400_gpio.
 
+comment "MODULbus GPIO expanders:"
+
+config GPIO_JANZ_TTL
+        tristate "Janz VMOD-TTL Digital IO Module"
+        depends on MFD_JANZ_CMODIO
+        help
+          This enables support for the Janz VMOD-TTL Digital IO module.
+          This driver provides support for driving the pins in output
+          mode only. Input mode is not supported.
+
 endif
diff --git a/drivers/gpio/Makefile b/drivers/gpio/Makefile
index 10f3f8d958b1..51c3cdd41b5a 100644
--- a/drivers/gpio/Makefile
+++ b/drivers/gpio/Makefile
@@ -16,6 +16,7 @@ obj-$(CONFIG_GPIO_MCP23S08)	+= mcp23s08.o
 obj-$(CONFIG_GPIO_PCA953X)      += pca953x.o
 obj-$(CONFIG_GPIO_PCF857X)      += pcf857x.o
 obj-$(CONFIG_GPIO_PL061)        += pl061.o
+obj-$(CONFIG_GPIO_TC35892)      += tc35892-gpio.o
 obj-$(CONFIG_GPIO_TIMBERDALE)   += timbgpio.o
 obj-$(CONFIG_GPIO_TWL4030)      += twl4030-gpio.o
 obj-$(CONFIG_GPIO_UCB1400)      += ucb1400_gpio.o
@@ -27,4 +28,6 @@ obj-$(CONFIG_GPIO_VR41XX)	+= vr41xx_giu.o
 obj-$(CONFIG_GPIO_WM831X)       += wm831x-gpio.o
 obj-$(CONFIG_GPIO_WM8350)       += wm8350-gpiolib.o
 obj-$(CONFIG_GPIO_WM8994)       += wm8994-gpio.o
-obj-$(CONFIG_GPIO_SCH)          += sch_gpio.o
\ No newline at end of file
+obj-$(CONFIG_GPIO_SCH)          += sch_gpio.o
+obj-$(CONFIG_GPIO_RDC321X)      += rdc321x-gpio.o
+obj-$(CONFIG_GPIO_JANZ_TTL)     += janz-ttl.o
diff --git a/drivers/gpio/cs5535-gpio.c b/drivers/gpio/cs5535-gpio.c
index 0c3c498f2260..f73a1555e49d 100644
--- a/drivers/gpio/cs5535-gpio.c
+++ b/drivers/gpio/cs5535-gpio.c
@@ -197,7 +197,7 @@ static int chip_direction_output(struct gpio_chip *c, unsigned offset, int val)
         return 0;
 }
 
-static char *cs5535_gpio_names[] = {
+static const char * const cs5535_gpio_names[] = {
         "GPIO0", "GPIO1", "GPIO2", "GPIO3",
         "GPIO4", "GPIO5", "GPIO6", "GPIO7",
         "GPIO8", "GPIO9", "GPIO10", "GPIO11",
diff --git a/drivers/gpio/gpiolib.c b/drivers/gpio/gpiolib.c
index cae1b8c5b08c..3ca36542e338 100644
--- a/drivers/gpio/gpiolib.c
+++ b/drivers/gpio/gpiolib.c
@@ -722,7 +722,7 @@ int gpio_export(unsigned gpio, bool direction_may_change)
         unsigned long           flags;
         struct gpio_desc        *desc;
         int                     status = -EINVAL;
-        char                    *ioname = NULL;
+        const char              *ioname = NULL;
 
         /* can't export until sysfs is available ... */
         if (!gpio_class.p) {
@@ -753,7 +753,7 @@ int gpio_export(unsigned gpio, bool direction_may_change)
                 struct device   *dev;
 
                 dev = device_create(&gpio_class, desc->chip->dev, MKDEV(0, 0),
-                                desc, ioname ? ioname : "gpio%d", gpio);
+                                desc, ioname ? ioname : "gpio%u", gpio);
                 if (!IS_ERR(dev)) {
                         status = sysfs_create_group(&dev->kobj,
                                                 &gpio_attr_group);
@@ -1106,7 +1106,7 @@ unlock:
 fail:
         /* failures here can mean systems won't boot... */
         if (status)
-                pr_err("gpiochip_add: gpios %d..%d (%s) not registered\n",
+                pr_err("gpiochip_add: gpios %d..%d (%s) failed to register\n",
                         chip->base, chip->base + chip->ngpio - 1,
                         chip->label ? : "generic");
         return status;
@@ -1447,6 +1447,49 @@ fail:
 }
 EXPORT_SYMBOL_GPL(gpio_direction_output);
 
+/**
+ * gpio_set_debounce - sets @debounce time for a @gpio
+ * @gpio: the gpio to set debounce time
+ * @debounce: debounce time is microseconds
+ */
+int gpio_set_debounce(unsigned gpio, unsigned debounce)
+{
+        unsigned long           flags;
+        struct gpio_chip        *chip;
+        struct gpio_desc        *desc = &gpio_desc[gpio];
+        int                     status = -EINVAL;
+
+        spin_lock_irqsave(&gpio_lock, flags);
+
+        if (!gpio_is_valid(gpio))
+                goto fail;
+        chip = desc->chip;
+        if (!chip || !chip->set || !chip->set_debounce)
+                goto fail;
+        gpio -= chip->base;
+        if (gpio >= chip->ngpio)
+                goto fail;
+        status = gpio_ensure_requested(desc, gpio);
+        if (status < 0)
+                goto fail;
+
+        /* now we know the gpio is valid and chip won't vanish */
+
+        spin_unlock_irqrestore(&gpio_lock, flags);
+
+        might_sleep_if(extra_checks && chip->can_sleep);
+
+        return chip->set_debounce(chip, gpio, debounce);
+
+fail:
+        spin_unlock_irqrestore(&gpio_lock, flags);
+        if (status)
+                pr_debug("%s: gpio-%d status %d\n",
+                        __func__, gpio, status);
+
+        return status;
+}
+EXPORT_SYMBOL_GPL(gpio_set_debounce);
 
 /* I/O calls are only valid after configuration completed; the relevant
  * "is this a valid GPIO" error checks should already have been done.
diff --git a/drivers/gpio/it8761e_gpio.c b/drivers/gpio/it8761e_gpio.c
index 41a9388f2fde..48fc43c4bdd1 100644
--- a/drivers/gpio/it8761e_gpio.c
+++ b/drivers/gpio/it8761e_gpio.c
@@ -217,7 +217,10 @@ gpiochip_add_err:
 static void __exit it8761e_gpio_exit(void)
 {
         if (gpio_ba) {
-                gpiochip_remove(&it8761e_gpio_chip);
+                int ret = gpiochip_remove(&it8761e_gpio_chip);
+
+                WARN(ret, "%s(): gpiochip_remove() failed, ret=%d\n",
+                                __func__, ret);
 
                 release_region(gpio_ba, GPIO_IOSIZE);
                 gpio_ba = 0;
diff --git a/drivers/gpio/janz-ttl.c b/drivers/gpio/janz-ttl.c
new file mode 100644
index 000000000000..813ac077e5d7
--- /dev/null
+++ b/drivers/gpio/janz-ttl.c
@@ -0,0 +1,258 @@
+/*
+ * Janz MODULbus VMOD-TTL GPIO Driver
+ *
+ * Copyright (c) 2010 Ira W. Snyder <iws@ovro.caltech.edu>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/delay.h>
+#include <linux/platform_device.h>
+#include <linux/io.h>
+#include <linux/gpio.h>
+#include <linux/slab.h>
+
+#include <linux/mfd/janz.h>
+
+#define DRV_NAME "janz-ttl"
+
+#define PORTA_DIRECTION         0x23
+#define PORTB_DIRECTION         0x2B
+#define PORTC_DIRECTION         0x06
+#define PORTA_IOCTL             0x24
+#define PORTB_IOCTL             0x2C
+#define PORTC_IOCTL             0x07
+
+#define MASTER_INT_CTL          0x00
+#define MASTER_CONF_CTL         0x01
+
+#define CONF_PAE                (1 << 2)
+#define CONF_PBE                (1 << 7)
+#define CONF_PCE                (1 << 4)
+
+struct ttl_control_regs {
+        __be16 portc;
+        __be16 portb;
+        __be16 porta;
+        __be16 control;
+};
+
+struct ttl_module {
+        struct gpio_chip gpio;
+
+        /* base address of registers */
+        struct ttl_control_regs __iomem *regs;
+
+        u8 portc_shadow;
+        u8 portb_shadow;
+        u8 porta_shadow;
+
+        spinlock_t lock;
+};
+
+static int ttl_get_value(struct gpio_chip *gpio, unsigned offset)
+{
+        struct ttl_module *mod = dev_get_drvdata(gpio->dev);
+        u8 *shadow;
+        int ret;
+
+        if (offset < 8) {
+                shadow = &mod->porta_shadow;
+        } else if (offset < 16) {
+                shadow = &mod->portb_shadow;
+                offset -= 8;
+        } else {
+                shadow = &mod->portc_shadow;
+                offset -= 16;
+        }
+
+        spin_lock(&mod->lock);
+        ret = *shadow & (1 << offset);
+        spin_unlock(&mod->lock);
+        return ret;
+}
+
+static void ttl_set_value(struct gpio_chip *gpio, unsigned offset, int value)
+{
+        struct ttl_module *mod = dev_get_drvdata(gpio->dev);
+        void __iomem *port;
+        u8 *shadow;
+
+        if (offset < 8) {
+                port = &mod->regs->porta;
+                shadow = &mod->porta_shadow;
+        } else if (offset < 16) {
+                port = &mod->regs->portb;
+                shadow = &mod->portb_shadow;
+                offset -= 8;
+        } else {
+                port = &mod->regs->portc;
+                shadow = &mod->portc_shadow;
+                offset -= 16;
+        }
+
+        spin_lock(&mod->lock);
+        if (value)
+                *shadow |= (1 << offset);
+        else
+                *shadow &= ~(1 << offset);
+
+        iowrite16be(*shadow, port);
+        spin_unlock(&mod->lock);
+}
+
+static void __devinit ttl_write_reg(struct ttl_module *mod, u8 reg, u16 val)
+{
+        iowrite16be(reg, &mod->regs->control);
+        iowrite16be(val, &mod->regs->control);
+}
+
+static void __devinit ttl_setup_device(struct ttl_module *mod)
+{
+        /* reset the device to a known state */
+        iowrite16be(0x0000, &mod->regs->control);
+        iowrite16be(0x0001, &mod->regs->control);
+        iowrite16be(0x0000, &mod->regs->control);
+
+        /* put all ports in open-drain mode */
+        ttl_write_reg(mod, PORTA_IOCTL, 0x00ff);
+        ttl_write_reg(mod, PORTB_IOCTL, 0x00ff);
+        ttl_write_reg(mod, PORTC_IOCTL, 0x000f);
+
+        /* set all ports as outputs */
+        ttl_write_reg(mod, PORTA_DIRECTION, 0x0000);
+        ttl_write_reg(mod, PORTB_DIRECTION, 0x0000);
+        ttl_write_reg(mod, PORTC_DIRECTION, 0x0000);
+
+        /* set all ports to drive zeroes */
+        iowrite16be(0x0000, &mod->regs->porta);
+        iowrite16be(0x0000, &mod->regs->portb);
+        iowrite16be(0x0000, &mod->regs->portc);
+
+        /* enable all ports */
+        ttl_write_reg(mod, MASTER_CONF_CTL, CONF_PAE | CONF_PBE | CONF_PCE);
+}
+
+static int __devinit ttl_probe(struct platform_device *pdev)
+{
+        struct janz_platform_data *pdata;
+        struct device *dev = &pdev->dev;
+        struct ttl_module *mod;
+        struct gpio_chip *gpio;
+        struct resource *res;
+        int ret;
+
+        pdata = pdev->dev.platform_data;
+        if (!pdata) {
+                dev_err(dev, "no platform data\n");
+                ret = -ENXIO;
+                goto out_return;
+        }
+
+        mod = kzalloc(sizeof(*mod), GFP_KERNEL);
+        if (!mod) {
+                dev_err(dev, "unable to allocate private data\n");
+                ret = -ENOMEM;
+                goto out_return;
+        }
+
+        platform_set_drvdata(pdev, mod);
+        spin_lock_init(&mod->lock);
+
+        /* get access to the MODULbus registers for this module */
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(dev, "MODULbus registers not found\n");
+                ret = -ENODEV;
+                goto out_free_mod;
+        }
+
+        mod->regs = ioremap(res->start, resource_size(res));
+        if (!mod->regs) {
+                dev_err(dev, "MODULbus registers not ioremap\n");
+                ret = -ENOMEM;
+                goto out_free_mod;
+        }
+
+        ttl_setup_device(mod);
+
+        /* Initialize the GPIO data structures */
+        gpio = &mod->gpio;
+        gpio->dev = &pdev->dev;
+        gpio->label = pdev->name;
+        gpio->get = ttl_get_value;
+        gpio->set = ttl_set_value;
+        gpio->owner = THIS_MODULE;
+
+        /* request dynamic allocation */
+        gpio->base = -1;
+        gpio->ngpio = 20;
+
+        ret = gpiochip_add(gpio);
+        if (ret) {
+                dev_err(dev, "unable to add GPIO chip\n");
+                goto out_iounmap_regs;
+        }
+
+        dev_info(&pdev->dev, "module %d: registered GPIO device\n",
+                             pdata->modno);
+        return 0;
+
+out_iounmap_regs:
+        iounmap(mod->regs);
+out_free_mod:
+        kfree(mod);
+out_return:
+        return ret;
+}
+
+static int __devexit ttl_remove(struct platform_device *pdev)
+{
+        struct ttl_module *mod = platform_get_drvdata(pdev);
+        struct device *dev = &pdev->dev;
+        int ret;
+
+        ret = gpiochip_remove(&mod->gpio);
+        if (ret) {
+                dev_err(dev, "unable to remove GPIO chip\n");
+                return ret;
+        }
+
+        iounmap(mod->regs);
+        kfree(mod);
+        return 0;
+}
+
+static struct platform_driver ttl_driver = {
+        .driver         = {
+                .name   = DRV_NAME,
+                .owner  = THIS_MODULE,
+        },
+        .probe          = ttl_probe,
+        .remove         = __devexit_p(ttl_remove),
+};
+
+static int __init ttl_init(void)
+{
+        return platform_driver_register(&ttl_driver);
+}
+
+static void __exit ttl_exit(void)
+{
+        platform_driver_unregister(&ttl_driver);
+}
+
+MODULE_AUTHOR("Ira W. Snyder <iws@ovro.caltech.edu>");
+MODULE_DESCRIPTION("Janz MODULbus VMOD-TTL Driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:janz-ttl");
+
+module_init(ttl_init);
+module_exit(ttl_exit);
diff --git a/drivers/gpio/langwell_gpio.c b/drivers/gpio/langwell_gpio.c
index 00c3a14127af..8383a8d7f994 100644
--- a/drivers/gpio/langwell_gpio.c
+++ b/drivers/gpio/langwell_gpio.c
@@ -17,6 +17,7 @@
 
 /* Supports:
  * Moorestown platform Langwell chip.
+ * Medfield platform Penwell chip.
  */
 
 #include <linux/module.h>
@@ -31,44 +32,65 @@
 #include <linux/gpio.h>
 #include <linux/slab.h>
 
-struct lnw_gpio_register {
-        u32     GPLR[2];
-        u32     GPDR[2];
-        u32     GPSR[2];
-        u32     GPCR[2];
-        u32     GRER[2];
-        u32     GFER[2];
-        u32     GEDR[2];
+/*
+ * Langwell chip has 64 pins and thus there are 2 32bit registers to control
+ * each feature, while Penwell chip has 96 pins for each block, and need 3 32bit
+ * registers to control them, so we only define the order here instead of a
+ * structure, to get a bit offset for a pin (use GPDR as an example):
+ *
+ * nreg = ngpio / 32;
+ * reg = offset / 32;
+ * bit = offset % 32;
+ * reg_addr = reg_base + GPDR * nreg * 4 + reg * 4;
+ *
+ * so the bit of reg_addr is to control pin offset's GPDR feature
+*/
+
+enum GPIO_REG {
+        GPLR = 0,       /* pin level read-only */
+        GPDR,           /* pin direction */
+        GPSR,           /* pin set */
+        GPCR,           /* pin clear */
+        GRER,           /* rising edge detect */
+        GFER,           /* falling edge detect */
+        GEDR,           /* edge detect result */
 };
 
 struct lnw_gpio {
         struct gpio_chip                chip;
-        struct lnw_gpio_register        *reg_base;
+        void                            *reg_base;
         spinlock_t                      lock;
         unsigned                        irq_base;
 };
 
-static int lnw_gpio_get(struct gpio_chip *chip, unsigned offset)
+static void __iomem *gpio_reg(struct gpio_chip *chip, unsigned offset,
+                        enum GPIO_REG reg_type)
 {
         struct lnw_gpio *lnw = container_of(chip, struct lnw_gpio, chip);
+        unsigned nreg = chip->ngpio / 32;
         u8 reg = offset / 32;
-        void __iomem *gplr;
+        void __iomem *ptr;
+
+        ptr = (void __iomem *)(lnw->reg_base + reg_type * nreg * 4 + reg * 4);
+        return ptr;
+}
+
+static int lnw_gpio_get(struct gpio_chip *chip, unsigned offset)
+{
+        void __iomem *gplr = gpio_reg(chip, offset, GPLR);
 
-        gplr = (void __iomem *)(&lnw->reg_base->GPLR[reg]);
         return readl(gplr) & BIT(offset % 32);
 }
 
 static void lnw_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct lnw_gpio *lnw = container_of(chip, struct lnw_gpio, chip);
-        u8 reg = offset / 32;
         void __iomem *gpsr, *gpcr;
 
         if (value) {
-                gpsr = (void __iomem *)(&lnw->reg_base->GPSR[reg]);
+                gpsr = gpio_reg(chip, offset, GPSR);
                 writel(BIT(offset % 32), gpsr);
         } else {
-                gpcr = (void __iomem *)(&lnw->reg_base->GPCR[reg]);
+                gpcr = gpio_reg(chip, offset, GPCR);
                 writel(BIT(offset % 32), gpcr);
         }
 }
@@ -76,12 +98,10 @@ static void lnw_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 static int lnw_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 {
         struct lnw_gpio *lnw = container_of(chip, struct lnw_gpio, chip);
-        u8 reg = offset / 32;
+        void __iomem *gpdr = gpio_reg(chip, offset, GPDR);
         u32 value;
         unsigned long flags;
-        void __iomem *gpdr;
 
-        gpdr = (void __iomem *)(&lnw->reg_base->GPDR[reg]);
         spin_lock_irqsave(&lnw->lock, flags);
         value = readl(gpdr);
         value &= ~BIT(offset % 32);
@@ -94,12 +114,10 @@ static int lnw_gpio_direction_output(struct gpio_chip *chip,
                         unsigned offset, int value)
 {
         struct lnw_gpio *lnw = container_of(chip, struct lnw_gpio, chip);
-        u8 reg = offset / 32;
+        void __iomem *gpdr = gpio_reg(chip, offset, GPDR);
         unsigned long flags;
-        void __iomem *gpdr;
 
         lnw_gpio_set(chip, offset, value);
-        gpdr = (void __iomem *)(&lnw->reg_base->GPDR[reg]);
         spin_lock_irqsave(&lnw->lock, flags);
         value = readl(gpdr);
         value |= BIT(offset % 32);;
@@ -118,11 +136,10 @@ static int lnw_irq_type(unsigned irq, unsigned type)
 {
         struct lnw_gpio *lnw = get_irq_chip_data(irq);
         u32 gpio = irq - lnw->irq_base;
-        u8 reg = gpio / 32;
         unsigned long flags;
         u32 value;
-        void __iomem *grer = (void __iomem *)(&lnw->reg_base->GRER[reg]);
-        void __iomem *gfer = (void __iomem *)(&lnw->reg_base->GFER[reg]);
+        void __iomem *grer = gpio_reg(&lnw->chip, gpio, GRER);
+        void __iomem *gfer = gpio_reg(&lnw->chip, gpio, GFER);
 
         if (gpio >= lnw->chip.ngpio)
                 return -EINVAL;
@@ -158,8 +175,10 @@ static struct irq_chip lnw_irqchip = {
         .set_type       = lnw_irq_type,
 };
 
-static struct pci_device_id lnw_gpio_ids[] = {
-        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x080f) },
+static DEFINE_PCI_DEVICE_TABLE(lnw_gpio_ids) = {   /* pin number */
+        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x080f), .driver_data = 64 },
+        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x081f), .driver_data = 96 },
+        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x081a), .driver_data = 96 },
         { 0, }
 };
 MODULE_DEVICE_TABLE(pci, lnw_gpio_ids);
@@ -167,17 +186,17 @@ MODULE_DEVICE_TABLE(pci, lnw_gpio_ids);
 static void lnw_irq_handler(unsigned irq, struct irq_desc *desc)
 {
         struct lnw_gpio *lnw = (struct lnw_gpio *)get_irq_data(irq);
-        u32 reg, gpio;
+        u32 base, gpio;
         void __iomem *gedr;
         u32 gedr_v;
 
         /* check GPIO controller to check which pin triggered the interrupt */
-        for (reg = 0; reg < lnw->chip.ngpio / 32; reg++) {
-                gedr = (void __iomem *)(&lnw->reg_base->GEDR[reg]);
+        for (base = 0; base < lnw->chip.ngpio; base += 32) {
+                gedr = gpio_reg(&lnw->chip, base, GEDR);
                 gedr_v = readl(gedr);
                 if (!gedr_v)
                         continue;
-                for (gpio = reg*32; gpio < reg*32+32; gpio++)
+                for (gpio = base; gpio < base + 32; gpio++)
                         if (gedr_v & BIT(gpio % 32)) {
                                 pr_debug("pin %d triggered\n", gpio);
                                 generic_handle_irq(lnw->irq_base + gpio);
@@ -245,7 +264,7 @@ static int __devinit lnw_gpio_probe(struct pci_dev *pdev,
         lnw->chip.set = lnw_gpio_set;
         lnw->chip.to_irq = lnw_gpio_to_irq;
         lnw->chip.base = gpio_base;
-        lnw->chip.ngpio = 64;
+        lnw->chip.ngpio = id->driver_data;
         lnw->chip.can_sleep = 0;
         pci_set_drvdata(pdev, lnw);
         retval = gpiochip_add(&lnw->chip);
diff --git a/drivers/gpio/max732x.c b/drivers/gpio/max732x.c
index f7868243af89..9cad60f9e962 100644
--- a/drivers/gpio/max732x.c
+++ b/drivers/gpio/max732x.c
@@ -17,7 +17,8 @@
 #include <linux/slab.h>
 #include <linux/string.h>
 #include <linux/gpio.h>
-
+#include <linux/interrupt.h>
+#include <linux/irq.h>
 #include <linux/i2c.h>
 #include <linux/i2c/max732x.h>
 
@@ -31,7 +32,8 @@
  *   - Open Drain I/O
  *
  * designated by 'O', 'I' and 'P' individually according to MAXIM's
- * datasheets.
+ * datasheets. 'I' and 'P' ports are interrupt capables, some with
+ * a dedicated interrupt mask.
  *
  * There are two groups of I/O ports, each group usually includes
  * up to 8 I/O ports, and is accessed by a specific I2C address:
@@ -44,7 +46,8 @@
  *
  * Within each group of ports, there are five known combinations of
  * I/O ports: 4I4O, 4P4O, 8I, 8P, 8O, see the definitions below for
- * the detailed organization of these ports.
+ * the detailed organization of these ports. Only Goup A is interrupt
+ * capable.
  *
  * GPIO numbers start from 'gpio_base + 0' to 'gpio_base + 8/16',
  * and GPIOs from GROUP_A are numbered before those from GROUP_B
@@ -68,16 +71,47 @@
 #define GROUP_A(x)      ((x) & 0xffff)  /* I2C Addr: 0b'110xxxx */
 #define GROUP_B(x)      ((x) << 16)     /* I2C Addr: 0b'101xxxx */
 
+#define INT_NONE        0x0     /* No interrupt capability */
+#define INT_NO_MASK     0x1     /* Has interrupts, no mask */
+#define INT_INDEP_MASK  0x2     /* Has interrupts, independent mask */
+#define INT_MERGED_MASK 0x3     /* Has interrupts, merged mask */
+
+#define INT_CAPS(x)     (((uint64_t)(x)) << 32)
+
+enum {
+        MAX7319,
+        MAX7320,
+        MAX7321,
+        MAX7322,
+        MAX7323,
+        MAX7324,
+        MAX7325,
+        MAX7326,
+        MAX7327,
+};
+
+static uint64_t max732x_features[] = {
+        [MAX7319] = GROUP_A(IO_8I) | INT_CAPS(INT_MERGED_MASK),
+        [MAX7320] = GROUP_B(IO_8O),
+        [MAX7321] = GROUP_A(IO_8P) | INT_CAPS(INT_NO_MASK),
+        [MAX7322] = GROUP_A(IO_4I4O) | INT_CAPS(INT_MERGED_MASK),
+        [MAX7323] = GROUP_A(IO_4P4O) | INT_CAPS(INT_INDEP_MASK),
+        [MAX7324] = GROUP_A(IO_8I) | GROUP_B(IO_8O) | INT_CAPS(INT_MERGED_MASK),
+        [MAX7325] = GROUP_A(IO_8P) | GROUP_B(IO_8O) | INT_CAPS(INT_NO_MASK),
+        [MAX7326] = GROUP_A(IO_4I4O) | GROUP_B(IO_8O) | INT_CAPS(INT_MERGED_MASK),
+        [MAX7327] = GROUP_A(IO_4P4O) | GROUP_B(IO_8O) | INT_CAPS(INT_NO_MASK),
+};
+
 static const struct i2c_device_id max732x_id[] = {
-        { "max7319", GROUP_A(IO_8I) },
-        { "max7320", GROUP_B(IO_8O) },
-        { "max7321", GROUP_A(IO_8P) },
-        { "max7322", GROUP_A(IO_4I4O) },
-        { "max7323", GROUP_A(IO_4P4O) },
-        { "max7324", GROUP_A(IO_8I) | GROUP_B(IO_8O) },
-        { "max7325", GROUP_A(IO_8P) | GROUP_B(IO_8O) },
-        { "max7326", GROUP_A(IO_4I4O) | GROUP_B(IO_8O) },
-        { "max7327", GROUP_A(IO_4P4O) | GROUP_B(IO_8O) },
+        { "max7319", MAX7319 },
+        { "max7320", MAX7320 },
+        { "max7321", MAX7321 },
+        { "max7322", MAX7322 },
+        { "max7323", MAX7323 },
+        { "max7324", MAX7324 },
+        { "max7325", MAX7325 },
+        { "max7326", MAX7326 },
+        { "max7327", MAX7327 },
         { },
 };
 MODULE_DEVICE_TABLE(i2c, max732x_id);
@@ -96,9 +130,19 @@ struct max732x_chip {
 
         struct mutex    lock;
         uint8_t         reg_out[2];
+
+#ifdef CONFIG_GPIO_MAX732X_IRQ
+        struct mutex    irq_lock;
+        int             irq_base;
+        uint8_t         irq_mask;
+        uint8_t         irq_mask_cur;
+        uint8_t         irq_trig_raise;
+        uint8_t         irq_trig_fall;
+        uint8_t         irq_features;
+#endif
 };
 
-static int max732x_write(struct max732x_chip *chip, int group_a, uint8_t val)
+static int max732x_writeb(struct max732x_chip *chip, int group_a, uint8_t val)
 {
         struct i2c_client *client;
         int ret;
@@ -113,7 +157,7 @@ static int max732x_write(struct max732x_chip *chip, int group_a, uint8_t val)
         return 0;
 }
 
-static int max732x_read(struct max732x_chip *chip, int group_a, uint8_t *val)
+static int max732x_readb(struct max732x_chip *chip, int group_a, uint8_t *val)
 {
         struct i2c_client *client;
         int ret;
@@ -142,7 +186,7 @@ static int max732x_gpio_get_value(struct gpio_chip *gc, unsigned off)
 
         chip = container_of(gc, struct max732x_chip, gpio_chip);
 
-        ret = max732x_read(chip, is_group_a(chip, off), &reg_val);
+        ret = max732x_readb(chip, is_group_a(chip, off), &reg_val);
         if (ret < 0)
                 return 0;
 
@@ -162,7 +206,7 @@ static void max732x_gpio_set_value(struct gpio_chip *gc, unsigned off, int val)
         reg_out = (off > 7) ? chip->reg_out[1] : chip->reg_out[0];
         reg_out = (val) ? reg_out | mask : reg_out & ~mask;
 
-        ret = max732x_write(chip, is_group_a(chip, off), reg_out);
+        ret = max732x_writeb(chip, is_group_a(chip, off), reg_out);
         if (ret < 0)
                 goto out;
 
@@ -188,6 +232,13 @@ static int max732x_gpio_direction_input(struct gpio_chip *gc, unsigned off)
                 return -EACCES;
         }
 
+        /*
+         * Open-drain pins must be set to high impedance (which is
+         * equivalent to output-high) to be turned into an input.
+         */
+        if ((mask & chip->dir_output))
+                max732x_gpio_set_value(gc, off, 1);
+
         return 0;
 }
 
@@ -209,12 +260,278 @@ static int max732x_gpio_direction_output(struct gpio_chip *gc,
         return 0;
 }
 
+#ifdef CONFIG_GPIO_MAX732X_IRQ
+static int max732x_writew(struct max732x_chip *chip, uint16_t val)
+{
+        int ret;
+
+        val = cpu_to_le16(val);
+
+        ret = i2c_master_send(chip->client_group_a, (char *)&val, 2);
+        if (ret < 0) {
+                dev_err(&chip->client_group_a->dev, "failed writing\n");
+                return ret;
+        }
+
+        return 0;
+}
+
+static int max732x_readw(struct max732x_chip *chip, uint16_t *val)
+{
+        int ret;
+
+        ret = i2c_master_recv(chip->client_group_a, (char *)val, 2);
+        if (ret < 0) {
+                dev_err(&chip->client_group_a->dev, "failed reading\n");
+                return ret;
+        }
+
+        *val = le16_to_cpu(*val);
+        return 0;
+}
+
+static void max732x_irq_update_mask(struct max732x_chip *chip)
+{
+        uint16_t msg;
+
+        if (chip->irq_mask == chip->irq_mask_cur)
+                return;
+
+        chip->irq_mask = chip->irq_mask_cur;
+
+        if (chip->irq_features == INT_NO_MASK)
+                return;
+
+        mutex_lock(&chip->lock);
+
+        switch (chip->irq_features) {
+        case INT_INDEP_MASK:
+                msg = (chip->irq_mask << 8) | chip->reg_out[0];
+                max732x_writew(chip, msg);
+                break;
+
+        case INT_MERGED_MASK:
+                msg = chip->irq_mask | chip->reg_out[0];
+                max732x_writeb(chip, 1, (uint8_t)msg);
+                break;
+        }
+
+        mutex_unlock(&chip->lock);
+}
+
+static int max732x_gpio_to_irq(struct gpio_chip *gc, unsigned off)
+{
+        struct max732x_chip *chip;
+
+        chip = container_of(gc, struct max732x_chip, gpio_chip);
+        return chip->irq_base + off;
+}
+
+static void max732x_irq_mask(unsigned int irq)
+{
+        struct max732x_chip *chip = get_irq_chip_data(irq);
+
+        chip->irq_mask_cur &= ~(1 << (irq - chip->irq_base));
+}
+
+static void max732x_irq_unmask(unsigned int irq)
+{
+        struct max732x_chip *chip = get_irq_chip_data(irq);
+
+        chip->irq_mask_cur |= 1 << (irq - chip->irq_base);
+}
+
+static void max732x_irq_bus_lock(unsigned int irq)
+{
+        struct max732x_chip *chip = get_irq_chip_data(irq);
+
+        mutex_lock(&chip->irq_lock);
+        chip->irq_mask_cur = chip->irq_mask;
+}
+
+static void max732x_irq_bus_sync_unlock(unsigned int irq)
+{
+        struct max732x_chip *chip = get_irq_chip_data(irq);
+
+        max732x_irq_update_mask(chip);
+        mutex_unlock(&chip->irq_lock);
+}
+
+static int max732x_irq_set_type(unsigned int irq, unsigned int type)
+{
+        struct max732x_chip *chip = get_irq_chip_data(irq);
+        uint16_t off = irq - chip->irq_base;
+        uint16_t mask = 1 << off;
+
+        if (!(mask & chip->dir_input)) {
+                dev_dbg(&chip->client->dev, "%s port %d is output only\n",
+                        chip->client->name, off);
+                return -EACCES;
+        }
+
+        if (!(type & IRQ_TYPE_EDGE_BOTH)) {
+                dev_err(&chip->client->dev, "irq %d: unsupported type %d\n",
+                        irq, type);
+                return -EINVAL;
+        }
+
+        if (type & IRQ_TYPE_EDGE_FALLING)
+                chip->irq_trig_fall |= mask;
+        else
+                chip->irq_trig_fall &= ~mask;
+
+        if (type & IRQ_TYPE_EDGE_RISING)
+                chip->irq_trig_raise |= mask;
+        else
+                chip->irq_trig_raise &= ~mask;
+
+        return max732x_gpio_direction_input(&chip->gpio_chip, off);
+}
+
+static struct irq_chip max732x_irq_chip = {
+        .name                   = "max732x",
+        .mask                   = max732x_irq_mask,
+        .unmask                 = max732x_irq_unmask,
+        .bus_lock               = max732x_irq_bus_lock,
+        .bus_sync_unlock        = max732x_irq_bus_sync_unlock,
+        .set_type               = max732x_irq_set_type,
+};
+
+static uint8_t max732x_irq_pending(struct max732x_chip *chip)
+{
+        uint8_t cur_stat;
+        uint8_t old_stat;
+        uint8_t trigger;
+        uint8_t pending;
+        uint16_t status;
+        int ret;
+
+        ret = max732x_readw(chip, &status);
+        if (ret)
+                return 0;
+
+        trigger = status >> 8;
+        trigger &= chip->irq_mask;
+
+        if (!trigger)
+                return 0;
+
+        cur_stat = status & 0xFF;
+        cur_stat &= chip->irq_mask;
+
+        old_stat = cur_stat ^ trigger;
+
+        pending = (old_stat & chip->irq_trig_fall) |
+                  (cur_stat & chip->irq_trig_raise);
+        pending &= trigger;
+
+        return pending;
+}
+
+static irqreturn_t max732x_irq_handler(int irq, void *devid)
+{
+        struct max732x_chip *chip = devid;
+        uint8_t pending;
+        uint8_t level;
+
+        pending = max732x_irq_pending(chip);
+
+        if (!pending)
+                return IRQ_HANDLED;
+
+        do {
+                level = __ffs(pending);
+                handle_nested_irq(level + chip->irq_base);
+
+                pending &= ~(1 << level);
+        } while (pending);
+
+        return IRQ_HANDLED;
+}
+
+static int max732x_irq_setup(struct max732x_chip *chip,
+                             const struct i2c_device_id *id)
+{
+        struct i2c_client *client = chip->client;
+        struct max732x_platform_data *pdata = client->dev.platform_data;
+        int has_irq = max732x_features[id->driver_data] >> 32;
+        int ret;
+
+        if (pdata->irq_base && has_irq != INT_NONE) {
+                int lvl;
+
+                chip->irq_base = pdata->irq_base;
+                chip->irq_features = has_irq;
+                mutex_init(&chip->irq_lock);
+
+                for (lvl = 0; lvl < chip->gpio_chip.ngpio; lvl++) {
+                        int irq = lvl + chip->irq_base;
+
+                        if (!(chip->dir_input & (1 << lvl)))
+                                continue;
+
+                        set_irq_chip_data(irq, chip);
+                        set_irq_chip_and_handler(irq, &max732x_irq_chip,
+                                                 handle_edge_irq);
+                        set_irq_nested_thread(irq, 1);
+#ifdef CONFIG_ARM
+                        set_irq_flags(irq, IRQF_VALID);
+#else
+                        set_irq_noprobe(irq);
+#endif
+                }
+
+                ret = request_threaded_irq(client->irq,
+                                           NULL,
+                                           max732x_irq_handler,
+                                           IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
+                                           dev_name(&client->dev), chip);
+                if (ret) {
+                        dev_err(&client->dev, "failed to request irq %d\n",
+                                client->irq);
+                        goto out_failed;
+                }
+
+                chip->gpio_chip.to_irq = max732x_gpio_to_irq;
+        }
+
+        return 0;
+
+out_failed:
+        chip->irq_base = 0;
+        return ret;
+}
+
+static void max732x_irq_teardown(struct max732x_chip *chip)
+{
+        if (chip->irq_base)
+                free_irq(chip->client->irq, chip);
+}
+#else /* CONFIG_GPIO_MAX732X_IRQ */
+static int max732x_irq_setup(struct max732x_chip *chip,
+                             const struct i2c_device_id *id)
+{
+        struct i2c_client *client = chip->client;
+        struct max732x_platform_data *pdata = client->dev.platform_data;
+        int has_irq = max732x_features[id->driver_data] >> 32;
+
+        if (pdata->irq_base && has_irq != INT_NONE)
+                dev_warn(&client->dev, "interrupt support not compiled in\n");
+
+        return 0;
+}
+
+static void max732x_irq_teardown(struct max732x_chip *chip)
+{
+}
+#endif
+
 static int __devinit max732x_setup_gpio(struct max732x_chip *chip,
                                         const struct i2c_device_id *id,
                                         unsigned gpio_start)
 {
         struct gpio_chip *gc = &chip->gpio_chip;
-        uint32_t id_data = id->driver_data;
+        uint32_t id_data = (uint32_t)max732x_features[id->driver_data];
         int i, port = 0;
 
         for (i = 0; i < 16; i++, id_data >>= 2) {
@@ -285,14 +602,14 @@ static int __devinit max732x_probe(struct i2c_client *client,
         switch (client->addr & 0x70) {
         case 0x60:
                 chip->client_group_a = client;
-                if (nr_port > 7) {
+                if (nr_port > 8) {
                         c = i2c_new_dummy(client->adapter, addr_b);
                         chip->client_group_b = chip->client_dummy = c;
                 }
                 break;
         case 0x50:
                 chip->client_group_b = client;
-                if (nr_port > 7) {
+                if (nr_port > 8) {
                         c = i2c_new_dummy(client->adapter, addr_a);
                         chip->client_group_a = chip->client_dummy = c;
                 }
@@ -306,9 +623,13 @@ static int __devinit max732x_probe(struct i2c_client *client,
 
         mutex_init(&chip->lock);
 
-        max732x_read(chip, is_group_a(chip, 0), &chip->reg_out[0]);
-        if (nr_port > 7)
-                max732x_read(chip, is_group_a(chip, 8), &chip->reg_out[1]);
+        max732x_readb(chip, is_group_a(chip, 0), &chip->reg_out[0]);
+        if (nr_port > 8)
+                max732x_readb(chip, is_group_a(chip, 8), &chip->reg_out[1]);
+
+        ret = max732x_irq_setup(chip, id);
+        if (ret)
+                goto out_failed;
 
         ret = gpiochip_add(&chip->gpio_chip);
         if (ret)
@@ -325,6 +646,7 @@ static int __devinit max732x_probe(struct i2c_client *client,
         return 0;
 
 out_failed:
+        max732x_irq_teardown(chip);
         kfree(chip);
         return ret;
 }
@@ -352,6 +674,8 @@ static int __devexit max732x_remove(struct i2c_client *client)
                 return ret;
         }
 
+        max732x_irq_teardown(chip);
+
         /* unregister any dummy i2c_client */
         if (chip->client_dummy)
                 i2c_unregister_device(chip->client_dummy);
diff --git a/drivers/gpio/pca953x.c b/drivers/gpio/pca953x.c
index f156ab3bb6ed..a2b12aa1f2b9 100644
--- a/drivers/gpio/pca953x.c
+++ b/drivers/gpio/pca953x.c
@@ -73,7 +73,7 @@ struct pca953x_chip {
         struct i2c_client *client;
         struct pca953x_platform_data *dyn_pdata;
         struct gpio_chip gpio_chip;
-        char **names;
+        const char *const *names;
 };
 
 static int pca953x_write_reg(struct pca953x_chip *chip, int reg, uint16_t val)
diff --git a/drivers/gpio/pl061.c b/drivers/gpio/pl061.c
index 105701a1f05b..ee568c8fcbd0 100644
--- a/drivers/gpio/pl061.c
+++ b/drivers/gpio/pl061.c
@@ -164,7 +164,7 @@ static int pl061_irq_type(unsigned irq, unsigned trigger)
         unsigned long flags;
         u8 gpiois, gpioibe, gpioiev;
 
-        if (offset < 0 || offset > PL061_GPIO_NR)
+        if (offset < 0 || offset >= PL061_GPIO_NR)
                 return -EINVAL;
 
         spin_lock_irqsave(&chip->irq_lock, flags);
diff --git a/drivers/gpio/rdc321x-gpio.c b/drivers/gpio/rdc321x-gpio.c
new file mode 100644
index 000000000000..2762698e0204
--- /dev/null
+++ b/drivers/gpio/rdc321x-gpio.c
@@ -0,0 +1,246 @@
+/*
+ * RDC321x GPIO driver
+ *
+ * Copyright (C) 2008, Volker Weiss <dev@tintuc.de>
+ * Copyright (C) 2007-2010 Florian Fainelli <florian@openwrt.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * 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/kernel.h>
+#include <linux/init.h>
+#include <linux/spinlock.h>
+#include <linux/platform_device.h>
+#include <linux/pci.h>
+#include <linux/gpio.h>
+#include <linux/mfd/rdc321x.h>
+#include <linux/slab.h>
+
+struct rdc321x_gpio {
+        spinlock_t              lock;
+        struct pci_dev          *sb_pdev;
+        u32                     data_reg[2];
+        int                     reg1_ctrl_base;
+        int                     reg1_data_base;
+        int                     reg2_ctrl_base;
+        int                     reg2_data_base;
+        struct gpio_chip        chip;
+};
+
+/* read GPIO pin */
+static int rdc_gpio_get_value(struct gpio_chip *chip, unsigned gpio)
+{
+        struct rdc321x_gpio *gpch;
+        u32 value = 0;
+        int reg;
+
+        gpch = container_of(chip, struct rdc321x_gpio, chip);
+        reg = gpio < 32 ? gpch->reg1_data_base : gpch->reg2_data_base;
+
+        spin_lock(&gpch->lock);
+        pci_write_config_dword(gpch->sb_pdev, reg,
+                                        gpch->data_reg[gpio < 32 ? 0 : 1]);
+        pci_read_config_dword(gpch->sb_pdev, reg, &value);
+        spin_unlock(&gpch->lock);
+
+        return (1 << (gpio & 0x1f)) & value ? 1 : 0;
+}
+
+static void rdc_gpio_set_value_impl(struct gpio_chip *chip,
+                                unsigned gpio, int value)
+{
+        struct rdc321x_gpio *gpch;
+        int reg = (gpio < 32) ? 0 : 1;
+
+        gpch = container_of(chip, struct rdc321x_gpio, chip);
+
+        if (value)
+                gpch->data_reg[reg] |= 1 << (gpio & 0x1f);
+        else
+                gpch->data_reg[reg] &= ~(1 << (gpio & 0x1f));
+
+        pci_write_config_dword(gpch->sb_pdev,
+                        reg ? gpch->reg2_data_base : gpch->reg1_data_base,
+                        gpch->data_reg[reg]);
+}
+
+/* set GPIO pin to value */
+static void rdc_gpio_set_value(struct gpio_chip *chip,
+                                unsigned gpio, int value)
+{
+        struct rdc321x_gpio *gpch;
+
+        gpch = container_of(chip, struct rdc321x_gpio, chip);
+        spin_lock(&gpch->lock);
+        rdc_gpio_set_value_impl(chip, gpio, value);
+        spin_unlock(&gpch->lock);
+}
+
+static int rdc_gpio_config(struct gpio_chip *chip,
+                                unsigned gpio, int value)
+{
+        struct rdc321x_gpio *gpch;
+        int err;
+        u32 reg;
+
+        gpch = container_of(chip, struct rdc321x_gpio, chip);
+
+        spin_lock(&gpch->lock);
+        err = pci_read_config_dword(gpch->sb_pdev, gpio < 32 ?
+                        gpch->reg1_ctrl_base : gpch->reg2_ctrl_base, &reg);
+        if (err)
+                goto unlock;
+
+        reg |= 1 << (gpio & 0x1f);
+
+        err = pci_write_config_dword(gpch->sb_pdev, gpio < 32 ?
+                        gpch->reg1_ctrl_base : gpch->reg2_ctrl_base, reg);
+        if (err)
+                goto unlock;
+
+        rdc_gpio_set_value_impl(chip, gpio, value);
+
+unlock:
+        spin_unlock(&gpch->lock);
+
+        return err;
+}
+
+/* configure GPIO pin as input */
+static int rdc_gpio_direction_input(struct gpio_chip *chip, unsigned gpio)
+{
+        return rdc_gpio_config(chip, gpio, 1);
+}
+
+/*
+ * Cache the initial value of both GPIO data registers
+ */
+static int __devinit rdc321x_gpio_probe(struct platform_device *pdev)
+{
+        int err;
+        struct resource *r;
+        struct rdc321x_gpio *rdc321x_gpio_dev;
+        struct rdc321x_gpio_pdata *pdata;
+
+        pdata = pdev->dev.platform_data;
+        if (!pdata) {
+                dev_err(&pdev->dev, "no platform data supplied\n");
+                return -ENODEV;
+        }
+
+        rdc321x_gpio_dev = kzalloc(sizeof(struct rdc321x_gpio), GFP_KERNEL);
+        if (!rdc321x_gpio_dev) {
+                dev_err(&pdev->dev, "failed to allocate private data\n");
+                return -ENOMEM;
+        }
+
+        r = platform_get_resource_byname(pdev, IORESOURCE_IO, "gpio-reg1");
+        if (!r) {
+                dev_err(&pdev->dev, "failed to get gpio-reg1 resource\n");
+                err = -ENODEV;
+                goto out_free;
+        }
+
+        spin_lock_init(&rdc321x_gpio_dev->lock);
+        rdc321x_gpio_dev->sb_pdev = pdata->sb_pdev;
+        rdc321x_gpio_dev->reg1_ctrl_base = r->start;
+        rdc321x_gpio_dev->reg1_data_base = r->start + 0x4;
+
+        r = platform_get_resource_byname(pdev, IORESOURCE_IO, "gpio-reg2");
+        if (!r) {
+                dev_err(&pdev->dev, "failed to get gpio-reg2 resource\n");
+                err = -ENODEV;
+                goto out_free;
+        }
+
+        rdc321x_gpio_dev->reg2_ctrl_base = r->start;
+        rdc321x_gpio_dev->reg2_data_base = r->start + 0x4;
+
+        rdc321x_gpio_dev->chip.label = "rdc321x-gpio";
+        rdc321x_gpio_dev->chip.direction_input = rdc_gpio_direction_input;
+        rdc321x_gpio_dev->chip.direction_output = rdc_gpio_config;
+        rdc321x_gpio_dev->chip.get = rdc_gpio_get_value;
+        rdc321x_gpio_dev->chip.set = rdc_gpio_set_value;
+        rdc321x_gpio_dev->chip.base = 0;
+        rdc321x_gpio_dev->chip.ngpio = pdata->max_gpios;
+
+        platform_set_drvdata(pdev, rdc321x_gpio_dev);
+
+        /* This might not be, what others (BIOS, bootloader, etc.)
+           wrote to these registers before, but it's a good guess. Still
+           better than just using 0xffffffff. */
+        err = pci_read_config_dword(rdc321x_gpio_dev->sb_pdev,
+                                        rdc321x_gpio_dev->reg1_data_base,
+                                        &rdc321x_gpio_dev->data_reg[0]);
+        if (err)
+                goto out_drvdata;
+
+        err = pci_read_config_dword(rdc321x_gpio_dev->sb_pdev,
+                                        rdc321x_gpio_dev->reg2_data_base,
+                                        &rdc321x_gpio_dev->data_reg[1]);
+        if (err)
+                goto out_drvdata;
+
+        dev_info(&pdev->dev, "registering %d GPIOs\n",
+                                        rdc321x_gpio_dev->chip.ngpio);
+        return gpiochip_add(&rdc321x_gpio_dev->chip);
+
+out_drvdata:
+        platform_set_drvdata(pdev, NULL);
+out_free:
+        kfree(rdc321x_gpio_dev);
+        return err;
+}
+
+static int __devexit rdc321x_gpio_remove(struct platform_device *pdev)
+{
+        int ret;
+        struct rdc321x_gpio *rdc321x_gpio_dev = platform_get_drvdata(pdev);
+
+        ret = gpiochip_remove(&rdc321x_gpio_dev->chip);
+        if (ret)
+                dev_err(&pdev->dev, "failed to unregister chip\n");
+
+        kfree(rdc321x_gpio_dev);
+        platform_set_drvdata(pdev, NULL);
+
+        return ret;
+}
+
+static struct platform_driver rdc321x_gpio_driver = {
+        .driver.name    = "rdc321x-gpio",
+        .driver.owner   = THIS_MODULE,
+        .probe          = rdc321x_gpio_probe,
+        .remove         = __devexit_p(rdc321x_gpio_remove),
+};
+
+static int __init rdc321x_gpio_init(void)
+{
+        return platform_driver_register(&rdc321x_gpio_driver);
+}
+
+static void __exit rdc321x_gpio_exit(void)
+{
+        platform_driver_unregister(&rdc321x_gpio_driver);
+}
+
+module_init(rdc321x_gpio_init);
+module_exit(rdc321x_gpio_exit);
+
+MODULE_AUTHOR("Florian Fainelli <florian@openwrt.org>");
+MODULE_DESCRIPTION("RDC321x GPIO driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:rdc321x-gpio");
diff --git a/drivers/gpio/tc35892-gpio.c b/drivers/gpio/tc35892-gpio.c
new file mode 100644
index 000000000000..1be6288780de
--- /dev/null
+++ b/drivers/gpio/tc35892-gpio.c
@@ -0,0 +1,381 @@
+/*
+ * Copyright (C) ST-Ericsson SA 2010
+ *
+ * License Terms: GNU General Public License, version 2
+ * Author: Hanumath Prasad <hanumath.prasad@stericsson.com> for ST-Ericsson
+ * Author: Rabin Vincent <rabin.vincent@stericsson.com> for ST-Ericsson
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/gpio.h>
+#include <linux/irq.h>
+#include <linux/interrupt.h>
+#include <linux/mfd/tc35892.h>
+
+/*
+ * These registers are modified under the irq bus lock and cached to avoid
+ * unnecessary writes in bus_sync_unlock.
+ */
+enum { REG_IBE, REG_IEV, REG_IS, REG_IE };
+
+#define CACHE_NR_REGS   4
+#define CACHE_NR_BANKS  3
+
+struct tc35892_gpio {
+        struct gpio_chip chip;
+        struct tc35892 *tc35892;
+        struct device *dev;
+        struct mutex irq_lock;
+
+        int irq_base;
+
+        /* Caches of interrupt control registers for bus_lock */
+        u8 regs[CACHE_NR_REGS][CACHE_NR_BANKS];
+        u8 oldregs[CACHE_NR_REGS][CACHE_NR_BANKS];
+};
+
+static inline struct tc35892_gpio *to_tc35892_gpio(struct gpio_chip *chip)
+{
+        return container_of(chip, struct tc35892_gpio, chip);
+}
+
+static int tc35892_gpio_get(struct gpio_chip *chip, unsigned offset)
+{
+        struct tc35892_gpio *tc35892_gpio = to_tc35892_gpio(chip);
+        struct tc35892 *tc35892 = tc35892_gpio->tc35892;
+        u8 reg = TC35892_GPIODATA0 + (offset / 8) * 2;
+        u8 mask = 1 << (offset % 8);
+        int ret;
+
+        ret = tc35892_reg_read(tc35892, reg);
+        if (ret < 0)
+                return ret;
+
+        return ret & mask;
+}
+
+static void tc35892_gpio_set(struct gpio_chip *chip, unsigned offset, int val)
+{
+        struct tc35892_gpio *tc35892_gpio = to_tc35892_gpio(chip);
+        struct tc35892 *tc35892 = tc35892_gpio->tc35892;
+        u8 reg = TC35892_GPIODATA0 + (offset / 8) * 2;
+        unsigned pos = offset % 8;
+        u8 data[] = {!!val << pos, 1 << pos};
+
+        tc35892_block_write(tc35892, reg, ARRAY_SIZE(data), data);
+}
+
+static int tc35892_gpio_direction_output(struct gpio_chip *chip,
+                                         unsigned offset, int val)
+{
+        struct tc35892_gpio *tc35892_gpio = to_tc35892_gpio(chip);
+        struct tc35892 *tc35892 = tc35892_gpio->tc35892;
+        u8 reg = TC35892_GPIODIR0 + offset / 8;
+        unsigned pos = offset % 8;
+
+        tc35892_gpio_set(chip, offset, val);
+
+        return tc35892_set_bits(tc35892, reg, 1 << pos, 1 << pos);
+}
+
+static int tc35892_gpio_direction_input(struct gpio_chip *chip,
+                                        unsigned offset)
+{
+        struct tc35892_gpio *tc35892_gpio = to_tc35892_gpio(chip);
+        struct tc35892 *tc35892 = tc35892_gpio->tc35892;
+        u8 reg = TC35892_GPIODIR0 + offset / 8;
+        unsigned pos = offset % 8;
+
+        return tc35892_set_bits(tc35892, reg, 1 << pos, 0);
+}
+
+static int tc35892_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
+{
+        struct tc35892_gpio *tc35892_gpio = to_tc35892_gpio(chip);
+
+        return tc35892_gpio->irq_base + offset;
+}
+
+static struct gpio_chip template_chip = {
+        .label                  = "tc35892",
+        .owner                  = THIS_MODULE,
+        .direction_input        = tc35892_gpio_direction_input,
+        .get                    = tc35892_gpio_get,
+        .direction_output       = tc35892_gpio_direction_output,
+        .set                    = tc35892_gpio_set,
+        .to_irq                 = tc35892_gpio_to_irq,
+        .can_sleep              = 1,
+};
+
+static int tc35892_gpio_irq_set_type(unsigned int irq, unsigned int type)
+{
+        struct tc35892_gpio *tc35892_gpio = get_irq_chip_data(irq);
+        int offset = irq - tc35892_gpio->irq_base;
+        int regoffset = offset / 8;
+        int mask = 1 << (offset % 8);
+
+        if (type == IRQ_TYPE_EDGE_BOTH) {
+                tc35892_gpio->regs[REG_IBE][regoffset] |= mask;
+                return 0;
+        }
+
+        tc35892_gpio->regs[REG_IBE][regoffset] &= ~mask;
+
+        if (type == IRQ_TYPE_LEVEL_LOW || type == IRQ_TYPE_LEVEL_HIGH)
+                tc35892_gpio->regs[REG_IS][regoffset] |= mask;
+        else
+                tc35892_gpio->regs[REG_IS][regoffset] &= ~mask;
+
+        if (type == IRQ_TYPE_EDGE_RISING || type == IRQ_TYPE_LEVEL_HIGH)
+                tc35892_gpio->regs[REG_IEV][regoffset] |= mask;
+        else
+                tc35892_gpio->regs[REG_IEV][regoffset] &= ~mask;
+
+        return 0;
+}
+
+static void tc35892_gpio_irq_lock(unsigned int irq)
+{
+        struct tc35892_gpio *tc35892_gpio = get_irq_chip_data(irq);
+
+        mutex_lock(&tc35892_gpio->irq_lock);
+}
+
+static void tc35892_gpio_irq_sync_unlock(unsigned int irq)
+{
+        struct tc35892_gpio *tc35892_gpio = get_irq_chip_data(irq);
+        struct tc35892 *tc35892 = tc35892_gpio->tc35892;
+        static const u8 regmap[] = {
+                [REG_IBE]       = TC35892_GPIOIBE0,
+                [REG_IEV]       = TC35892_GPIOIEV0,
+                [REG_IS]        = TC35892_GPIOIS0,
+                [REG_IE]        = TC35892_GPIOIE0,
+        };
+        int i, j;
+
+        for (i = 0; i < CACHE_NR_REGS; i++) {
+                for (j = 0; j < CACHE_NR_BANKS; j++) {
+                        u8 old = tc35892_gpio->oldregs[i][j];
+                        u8 new = tc35892_gpio->regs[i][j];
+
+                        if (new == old)
+                                continue;
+
+                        tc35892_gpio->oldregs[i][j] = new;
+                        tc35892_reg_write(tc35892, regmap[i] + j * 8, new);
+                }
+        }
+
+        mutex_unlock(&tc35892_gpio->irq_lock);
+}
+
+static void tc35892_gpio_irq_mask(unsigned int irq)
+{
+        struct tc35892_gpio *tc35892_gpio = get_irq_chip_data(irq);
+        int offset = irq - tc35892_gpio->irq_base;
+        int regoffset = offset / 8;
+        int mask = 1 << (offset % 8);
+
+        tc35892_gpio->regs[REG_IE][regoffset] &= ~mask;
+}
+
+static void tc35892_gpio_irq_unmask(unsigned int irq)
+{
+        struct tc35892_gpio *tc35892_gpio = get_irq_chip_data(irq);
+        int offset = irq - tc35892_gpio->irq_base;
+        int regoffset = offset / 8;
+        int mask = 1 << (offset % 8);
+
+        tc35892_gpio->regs[REG_IE][regoffset] |= mask;
+}
+
+static struct irq_chip tc35892_gpio_irq_chip = {
+        .name                   = "tc35892-gpio",
+        .bus_lock               = tc35892_gpio_irq_lock,
+        .bus_sync_unlock        = tc35892_gpio_irq_sync_unlock,
+        .mask                   = tc35892_gpio_irq_mask,
+        .unmask                 = tc35892_gpio_irq_unmask,
+        .set_type               = tc35892_gpio_irq_set_type,
+};
+
+static irqreturn_t tc35892_gpio_irq(int irq, void *dev)
+{
+        struct tc35892_gpio *tc35892_gpio = dev;
+        struct tc35892 *tc35892 = tc35892_gpio->tc35892;
+        u8 status[CACHE_NR_BANKS];
+        int ret;
+        int i;
+
+        ret = tc35892_block_read(tc35892, TC35892_GPIOMIS0,
+                                 ARRAY_SIZE(status), status);
+        if (ret < 0)
+                return IRQ_NONE;
+
+        for (i = 0; i < ARRAY_SIZE(status); i++) {
+                unsigned int stat = status[i];
+                if (!stat)
+                        continue;
+
+                while (stat) {
+                        int bit = __ffs(stat);
+                        int line = i * 8 + bit;
+
+                        handle_nested_irq(tc35892_gpio->irq_base + line);
+                        stat &= ~(1 << bit);
+                }
+
+                tc35892_reg_write(tc35892, TC35892_GPIOIC0 + i, status[i]);
+        }
+
+        return IRQ_HANDLED;
+}
+
+static int tc35892_gpio_irq_init(struct tc35892_gpio *tc35892_gpio)
+{
+        int base = tc35892_gpio->irq_base;
+        int irq;
+
+        for (irq = base; irq < base + tc35892_gpio->chip.ngpio; irq++) {
+                set_irq_chip_data(irq, tc35892_gpio);
+                set_irq_chip_and_handler(irq, &tc35892_gpio_irq_chip,
+                                         handle_simple_irq);
+                set_irq_nested_thread(irq, 1);
+#ifdef CONFIG_ARM
+                set_irq_flags(irq, IRQF_VALID);
+#else
+                set_irq_noprobe(irq);
+#endif
+        }
+
+        return 0;
+}
+
+static void tc35892_gpio_irq_remove(struct tc35892_gpio *tc35892_gpio)
+{
+        int base = tc35892_gpio->irq_base;
+        int irq;
+
+        for (irq = base; irq < base + tc35892_gpio->chip.ngpio; irq++) {
+#ifdef CONFIG_ARM
+                set_irq_flags(irq, 0);
+#endif
+                set_irq_chip_and_handler(irq, NULL, NULL);
+                set_irq_chip_data(irq, NULL);
+        }
+}
+
+static int __devinit tc35892_gpio_probe(struct platform_device *pdev)
+{
+        struct tc35892 *tc35892 = dev_get_drvdata(pdev->dev.parent);
+        struct tc35892_gpio_platform_data *pdata;
+        struct tc35892_gpio *tc35892_gpio;
+        int ret;
+        int irq;
+
+        pdata = tc35892->pdata->gpio;
+        if (!pdata)
+                return -ENODEV;
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0)
+                return irq;
+
+        tc35892_gpio = kzalloc(sizeof(struct tc35892_gpio), GFP_KERNEL);
+        if (!tc35892_gpio)
+                return -ENOMEM;
+
+        mutex_init(&tc35892_gpio->irq_lock);
+
+        tc35892_gpio->dev = &pdev->dev;
+        tc35892_gpio->tc35892 = tc35892;
+
+        tc35892_gpio->chip = template_chip;
+        tc35892_gpio->chip.ngpio = tc35892->num_gpio;
+        tc35892_gpio->chip.dev = &pdev->dev;
+        tc35892_gpio->chip.base = pdata->gpio_base;
+
+        tc35892_gpio->irq_base = tc35892->irq_base + TC35892_INT_GPIO(0);
+
+        /* Bring the GPIO module out of reset */
+        ret = tc35892_set_bits(tc35892, TC35892_RSTCTRL,
+                               TC35892_RSTCTRL_GPIRST, 0);
+        if (ret < 0)
+                goto out_free;
+
+        ret = tc35892_gpio_irq_init(tc35892_gpio);
+        if (ret)
+                goto out_free;
+
+        ret = request_threaded_irq(irq, NULL, tc35892_gpio_irq, IRQF_ONESHOT,
+                                   "tc35892-gpio", tc35892_gpio);
+        if (ret) {
+                dev_err(&pdev->dev, "unable to get irq: %d\n", ret);
+                goto out_removeirq;
+        }
+
+        ret = gpiochip_add(&tc35892_gpio->chip);
+        if (ret) {
+                dev_err(&pdev->dev, "unable to add gpiochip: %d\n", ret);
+                goto out_freeirq;
+        }
+
+        platform_set_drvdata(pdev, tc35892_gpio);
+
+        return 0;
+
+out_freeirq:
+        free_irq(irq, tc35892_gpio);
+out_removeirq:
+        tc35892_gpio_irq_remove(tc35892_gpio);
+out_free:
+        kfree(tc35892_gpio);
+        return ret;
+}
+
+static int __devexit tc35892_gpio_remove(struct platform_device *pdev)
+{
+        struct tc35892_gpio *tc35892_gpio = platform_get_drvdata(pdev);
+        int irq = platform_get_irq(pdev, 0);
+        int ret;
+
+        ret = gpiochip_remove(&tc35892_gpio->chip);
+        if (ret < 0) {
+                dev_err(tc35892_gpio->dev,
+                        "unable to remove gpiochip: %d\n", ret);
+                return ret;
+        }
+
+        free_irq(irq, tc35892_gpio);
+        tc35892_gpio_irq_remove(tc35892_gpio);
+
+        platform_set_drvdata(pdev, NULL);
+        kfree(tc35892_gpio);
+
+        return 0;
+}
+
+static struct platform_driver tc35892_gpio_driver = {
+        .driver.name    = "tc35892-gpio",
+        .driver.owner   = THIS_MODULE,
+        .probe          = tc35892_gpio_probe,
+        .remove         = __devexit_p(tc35892_gpio_remove),
+};
+
+static int __init tc35892_gpio_init(void)
+{
+        return platform_driver_register(&tc35892_gpio_driver);
+}
+subsys_initcall(tc35892_gpio_init);
+
+static void __exit tc35892_gpio_exit(void)
+{
+        platform_driver_unregister(&tc35892_gpio_driver);
+}
+module_exit(tc35892_gpio_exit);
+
+MODULE_LICENSE("GPL v2");
+MODULE_DESCRIPTION("TC35892 GPIO driver");
+MODULE_AUTHOR("Hanumath Prasad, Rabin Vincent");
diff --git a/drivers/gpu/drm/drm_edid.c b/drivers/gpu/drm/drm_edid.c
index f569ae88ab38..c1981861bbbd 100644
--- a/drivers/gpu/drm/drm_edid.c
+++ b/drivers/gpu/drm/drm_edid.c
@@ -147,7 +147,10 @@ drm_edid_block_valid(u8 *raw_edid)
                 csum += raw_edid[i];
         if (csum) {
                 DRM_ERROR("EDID checksum is invalid, remainder is %d\n", csum);
-                goto bad;
+
+                /* allow CEA to slide through, switches mangle this */
+                if (raw_edid[0] != 0x02)
+                        goto bad;
         }
 
         /* per-block-type checks */
diff --git a/drivers/gpu/drm/nouveau/nouveau_connector.c b/drivers/gpu/drm/nouveau/nouveau_connector.c
index 7e663a79829f..266b0ff441af 100644
--- a/drivers/gpu/drm/nouveau/nouveau_connector.c
+++ b/drivers/gpu/drm/nouveau/nouveau_connector.c
@@ -241,7 +241,8 @@ nouveau_connector_detect(struct drm_connector *connector)
         if (nv_encoder && nv_connector->native_mode) {
                 unsigned status = connector_status_connected;
 
-#ifdef CONFIG_ACPI
+#if defined(CONFIG_ACPI_BUTTON) || \
+        (defined(CONFIG_ACPI_BUTTON_MODULE) && defined(MODULE))
                 if (!nouveau_ignorelid && !acpi_lid_open())
                         status = connector_status_unknown;
 #endif
diff --git a/drivers/gpu/drm/nouveau/nv40_graph.c b/drivers/gpu/drm/nouveau/nv40_graph.c
index 0616c96e4b67..704a25d04ac9 100644
--- a/drivers/gpu/drm/nouveau/nv40_graph.c
+++ b/drivers/gpu/drm/nouveau/nv40_graph.c
@@ -253,7 +253,11 @@ nv40_graph_init(struct drm_device *dev)
 
         if (!dev_priv->engine.graph.ctxprog) {
                 struct nouveau_grctx ctx = {};
-                uint32_t cp[256];
+                uint32_t *cp;
+
+                cp = kmalloc(sizeof(*cp) * 256, GFP_KERNEL);
+                if (!cp)
+                        return -ENOMEM;
 
                 ctx.dev = dev;
                 ctx.mode = NOUVEAU_GRCTX_PROG;
@@ -265,6 +269,8 @@ nv40_graph_init(struct drm_device *dev)
                 nv_wr32(dev, NV40_PGRAPH_CTXCTL_UCODE_INDEX, 0);
                 for (i = 0; i < ctx.ctxprog_len; i++)
                         nv_wr32(dev, NV40_PGRAPH_CTXCTL_UCODE_DATA, cp[i]);
+
+                kfree(cp);
         }
 
         /* No context present currently */
diff --git a/drivers/gpu/drm/radeon/atombios_crtc.c b/drivers/gpu/drm/radeon/atombios_crtc.c
index 03dd6c41dc19..f3f2827017ef 100644
--- a/drivers/gpu/drm/radeon/atombios_crtc.c
+++ b/drivers/gpu/drm/radeon/atombios_crtc.c
@@ -707,6 +707,7 @@ static void atombios_crtc_set_pll(struct drm_crtc *crtc, struct drm_display_mode
                 break;
         case ATOM_DCPLL:
         case ATOM_PPLL_INVALID:
+        default:
                 pll = &rdev->clock.dcpll;
                 break;
         }
diff --git a/drivers/gpu/drm/radeon/radeon.h b/drivers/gpu/drm/radeon/radeon.h
index 66a37fb75839..669feb689bfc 100644
--- a/drivers/gpu/drm/radeon/radeon.h
+++ b/drivers/gpu/drm/radeon/radeon.h
@@ -576,6 +576,7 @@ typedef int (*radeon_packet3_check_t)(struct radeon_cs_parser *p,
  */
 int radeon_agp_init(struct radeon_device *rdev);
 void radeon_agp_resume(struct radeon_device *rdev);
+void radeon_agp_suspend(struct radeon_device *rdev);
 void radeon_agp_fini(struct radeon_device *rdev);
 
 
diff --git a/drivers/gpu/drm/radeon/radeon_agp.c b/drivers/gpu/drm/radeon/radeon_agp.c
index 28e473f1f56f..f40dfb77f9b1 100644
--- a/drivers/gpu/drm/radeon/radeon_agp.c
+++ b/drivers/gpu/drm/radeon/radeon_agp.c
@@ -270,3 +270,8 @@ void radeon_agp_fini(struct radeon_device *rdev)
         }
 #endif
 }
+
+void radeon_agp_suspend(struct radeon_device *rdev)
+{
+        radeon_agp_fini(rdev);
+}
diff --git a/drivers/gpu/drm/radeon/radeon_atombios.c b/drivers/gpu/drm/radeon/radeon_atombios.c
index 6e733fdc3349..24ea683f7cf5 100644
--- a/drivers/gpu/drm/radeon/radeon_atombios.c
+++ b/drivers/gpu/drm/radeon/radeon_atombios.c
@@ -680,10 +680,18 @@ bool radeon_get_atom_connector_info_from_supported_devices_table(struct
         uint8_t dac;
         union atom_supported_devices *supported_devices;
         int i, j, max_device;
-        struct bios_connector bios_connectors[ATOM_MAX_SUPPORTED_DEVICE];
+        struct bios_connector *bios_connectors;
+        size_t bc_size = sizeof(*bios_connectors) * ATOM_MAX_SUPPORTED_DEVICE;
 
-        if (!atom_parse_data_header(ctx, index, &size, &frev, &crev, &data_offset))
+        bios_connectors = kzalloc(bc_size, GFP_KERNEL);
+        if (!bios_connectors)
+                return false;
+
+        if (!atom_parse_data_header(ctx, index, &size, &frev, &crev,
+                                    &data_offset)) {
+                kfree(bios_connectors);
                 return false;
+        }
 
         supported_devices =
             (union atom_supported_devices *)(ctx->bios + data_offset);
@@ -851,6 +859,7 @@ bool radeon_get_atom_connector_info_from_supported_devices_table(struct
 
         radeon_link_encoder_connector(dev);
 
+        kfree(bios_connectors);
         return true;
 }
 
diff --git a/drivers/gpu/drm/radeon/radeon_device.c b/drivers/gpu/drm/radeon/radeon_device.c
index a20b612ffe75..fdc3fdf78acb 100644
--- a/drivers/gpu/drm/radeon/radeon_device.c
+++ b/drivers/gpu/drm/radeon/radeon_device.c
@@ -754,6 +754,8 @@ int radeon_suspend_kms(struct drm_device *dev, pm_message_t state)
         /* evict remaining vram memory */
         radeon_bo_evict_vram(rdev);
 
+        radeon_agp_suspend(rdev);
+
         pci_save_state(dev->pdev);
         if (state.event == PM_EVENT_SUSPEND) {
                 /* Shut down the device */
diff --git a/drivers/gpu/drm/radeon/radeon_state.c b/drivers/gpu/drm/radeon/radeon_state.c
index cc5316dcf580..b3ba44c0a818 100644
--- a/drivers/gpu/drm/radeon/radeon_state.c
+++ b/drivers/gpu/drm/radeon/radeon_state.c
@@ -900,9 +900,10 @@ static void radeon_cp_dispatch_clear(struct drm_device * dev,
                         flags |= RADEON_FRONT;
         }
         if (flags & (RADEON_DEPTH|RADEON_STENCIL)) {
-                if (!dev_priv->have_z_offset)
+                if (!dev_priv->have_z_offset) {
                         printk_once(KERN_ERR "radeon: illegal depth clear request. Buggy mesa detected - please update.\n");
-                flags &= ~(RADEON_DEPTH | RADEON_STENCIL);
+                        flags &= ~(RADEON_DEPTH | RADEON_STENCIL);
+                }
         }
 
         if (flags & (RADEON_FRONT | RADEON_BACK)) {
diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig
index 76ba59b9fea1..132278fa6240 100644
--- a/drivers/hid/Kconfig
+++ b/drivers/hid/Kconfig
@@ -347,6 +347,14 @@ config HID_QUANTA
         ---help---
         Support for Quanta Optical Touch dual-touch panels.
 
+config HID_ROCCAT
+        tristate "Roccat special event support"
+        depends on USB_HID
+        ---help---
+        Support for Roccat special events.
+        Say Y here if you have a Roccat mouse or keyboard and want OSD or
+        macro execution support.
+
 config HID_ROCCAT_KONE
         tristate "Roccat Kone Mouse support"
         depends on USB_HID
diff --git a/drivers/hid/Makefile b/drivers/hid/Makefile
index 22e47eaeea32..987fa0627367 100644
--- a/drivers/hid/Makefile
+++ b/drivers/hid/Makefile
@@ -48,6 +48,7 @@ obj-$(CONFIG_HID_QUANTA)	+= hid-quanta.o
 obj-$(CONFIG_HID_PANTHERLORD)   += hid-pl.o
 obj-$(CONFIG_HID_PETALYNX)      += hid-petalynx.o
 obj-$(CONFIG_HID_PICOLCD)       += hid-picolcd.o
+obj-$(CONFIG_HID_ROCCAT)        += hid-roccat.o
 obj-$(CONFIG_HID_ROCCAT_KONE)   += hid-roccat-kone.o
 obj-$(CONFIG_HID_SAMSUNG)       += hid-samsung.o
 obj-$(CONFIG_HID_SMARTJOYPLUS)  += hid-sjoy.o
diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
index e10e314d38cc..aa0f7dcabcd7 100644
--- a/drivers/hid/hid-core.c
+++ b/drivers/hid/hid-core.c
@@ -1301,6 +1301,7 @@ static const struct hid_device_id hid_blacklist[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_GREENASIA, 0x0012) },
         { HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE) },
         { HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE_2) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE_3) },
         { HID_USB_DEVICE(USB_VENDOR_ID_KENSINGTON, USB_DEVICE_ID_KS_SLIMBLADE) },
         { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_ERGO_525V) },
         { HID_USB_DEVICE(USB_VENDOR_ID_LABTEC, USB_DEVICE_ID_LABTEC_WIRELESS_KEYBOARD) },
diff --git a/drivers/hid/hid-debug.c b/drivers/hid/hid-debug.c
index 56f314fbd4f9..c94026768570 100644
--- a/drivers/hid/hid-debug.c
+++ b/drivers/hid/hid-debug.c
@@ -811,7 +811,7 @@ static const char *relatives[REL_MAX + 1] = {
         [REL_WHEEL] = "Wheel",          [REL_MISC] = "Misc",
 };
 
-static const char *absolutes[ABS_MAX + 1] = {
+static const char *absolutes[ABS_CNT] = {
         [ABS_X] = "X",                  [ABS_Y] = "Y",
         [ABS_Z] = "Z",                  [ABS_RX] = "Rx",
         [ABS_RY] = "Ry",                [ABS_RZ] = "Rz",
diff --git a/drivers/hid/hid-gyration.c b/drivers/hid/hid-gyration.c
index 62416e6baeca..3975e039c3dd 100644
--- a/drivers/hid/hid-gyration.c
+++ b/drivers/hid/hid-gyration.c
@@ -73,6 +73,7 @@ static int gyration_event(struct hid_device *hdev, struct hid_field *field,
 static const struct hid_device_id gyration_devices[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE) },
         { HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE_2) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE_3) },
         { }
 };
 MODULE_DEVICE_TABLE(hid, gyration_devices);
diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h
index 9776896cc4fc..6af77ed0b555 100644
--- a/drivers/hid/hid-ids.h
+++ b/drivers/hid/hid-ids.h
@@ -282,6 +282,7 @@
 #define USB_VENDOR_ID_GYRATION          0x0c16
 #define USB_DEVICE_ID_GYRATION_REMOTE   0x0002
 #define USB_DEVICE_ID_GYRATION_REMOTE_2 0x0003
+#define USB_DEVICE_ID_GYRATION_REMOTE_3 0x0008
 
 #define USB_VENDOR_ID_HAPP              0x078b
 #define USB_DEVICE_ID_UGCI_DRIVING      0x0010
diff --git a/drivers/hid/hid-roccat-kone.c b/drivers/hid/hid-roccat-kone.c
index 66e694054ba2..17f2dc04f883 100644
--- a/drivers/hid/hid-roccat-kone.c
+++ b/drivers/hid/hid-roccat-kone.c
@@ -37,6 +37,7 @@
 #include <linux/module.h>
 #include <linux/slab.h>
 #include "hid-ids.h"
+#include "hid-roccat.h"
 #include "hid-roccat-kone.h"
 
 static void kone_set_settings_checksum(struct kone_settings *settings)
@@ -263,7 +264,7 @@ static int kone_get_firmware_version(struct usb_device *usb_dev, int *result)
         return 0;
 }
 
-static ssize_t kone_sysfs_read_settings(struct kobject *kobj,
+static ssize_t kone_sysfs_read_settings(struct file *fp, struct kobject *kobj,
                 struct bin_attribute *attr, char *buf,
                 loff_t off, size_t count) {
         struct device *dev = container_of(kobj, struct device, kobj);
@@ -287,7 +288,7 @@ static ssize_t kone_sysfs_read_settings(struct kobject *kobj,
  * This function keeps values in kone_device up to date and assumes that in
  * case of error the old data is still valid
  */
-static ssize_t kone_sysfs_write_settings(struct kobject *kobj,
+static ssize_t kone_sysfs_write_settings(struct file *fp, struct kobject *kobj,
                 struct bin_attribute *attr, char *buf,
                 loff_t off, size_t count) {
         struct device *dev = container_of(kobj, struct device, kobj);
@@ -342,31 +343,31 @@ static ssize_t kone_sysfs_read_profilex(struct kobject *kobj,
         return count;
 }
 
-static ssize_t kone_sysfs_read_profile1(struct kobject *kobj,
+static ssize_t kone_sysfs_read_profile1(struct file *fp, struct kobject *kobj,
                 struct bin_attribute *attr, char *buf,
                 loff_t off, size_t count) {
         return kone_sysfs_read_profilex(kobj, attr, buf, off, count, 1);
 }
 
-static ssize_t kone_sysfs_read_profile2(struct kobject *kobj,
+static ssize_t kone_sysfs_read_profile2(struct file *fp, struct kobject *kobj,
                 struct bin_attribute *attr, char *buf,
                 loff_t off, size_t count) {
         return kone_sysfs_read_profilex(kobj, attr, buf, off, count, 2);
 }
 
-static ssize_t kone_sysfs_read_profile3(struct kobject *kobj,
+static ssize_t kone_sysfs_read_profile3(struct file *fp, struct kobject *kobj,
                 struct bin_attribute *attr, char *buf,
                 loff_t off, size_t count) {
         return kone_sysfs_read_profilex(kobj, attr, buf, off, count, 3);
 }
 
-static ssize_t kone_sysfs_read_profile4(struct kobject *kobj,
+static ssize_t kone_sysfs_read_profile4(struct file *fp, struct kobject *kobj,
                 struct bin_attribute *attr, char *buf,
                 loff_t off, size_t count) {
         return kone_sysfs_read_profilex(kobj, attr, buf, off, count, 4);
 }
 
-static ssize_t kone_sysfs_read_profile5(struct kobject *kobj,
+static ssize_t kone_sysfs_read_profile5(struct file *fp, struct kobject *kobj,
                 struct bin_attribute *attr, char *buf,
                 loff_t off, size_t count) {
         return kone_sysfs_read_profilex(kobj, attr, buf, off, count, 5);
@@ -404,31 +405,31 @@ static ssize_t kone_sysfs_write_profilex(struct kobject *kobj,
         return sizeof(struct kone_profile);
 }
 
-static ssize_t kone_sysfs_write_profile1(struct kobject *kobj,
+static ssize_t kone_sysfs_write_profile1(struct file *fp, struct kobject *kobj,
                 struct bin_attribute *attr, char *buf,
                 loff_t off, size_t count) {
         return kone_sysfs_write_profilex(kobj, attr, buf, off, count, 1);
 }
 
-static ssize_t kone_sysfs_write_profile2(struct kobject *kobj,
+static ssize_t kone_sysfs_write_profile2(struct file *fp, struct kobject *kobj,
                 struct bin_attribute *attr, char *buf,
                 loff_t off, size_t count) {
         return kone_sysfs_write_profilex(kobj, attr, buf, off, count, 2);
 }
 
-static ssize_t kone_sysfs_write_profile3(struct kobject *kobj,
+static ssize_t kone_sysfs_write_profile3(struct file *fp, struct kobject *kobj,
                 struct bin_attribute *attr, char *buf,
                 loff_t off, size_t count) {
         return kone_sysfs_write_profilex(kobj, attr, buf, off, count, 3);
 }
 
-static ssize_t kone_sysfs_write_profile4(struct kobject *kobj,
+static ssize_t kone_sysfs_write_profile4(struct file *fp, struct kobject *kobj,
                 struct bin_attribute *attr, char *buf,
                 loff_t off, size_t count) {
         return kone_sysfs_write_profilex(kobj, attr, buf, off, count, 4);
 }
 
-static ssize_t kone_sysfs_write_profile5(struct kobject *kobj,
+static ssize_t kone_sysfs_write_profile5(struct file *fp, struct kobject *kobj,
                 struct bin_attribute *attr, char *buf,
                 loff_t off, size_t count) {
         return kone_sysfs_write_profilex(kobj, attr, buf, off, count, 5);
@@ -849,6 +850,16 @@ static int kone_init_specials(struct hid_device *hdev)
                                         "couldn't init struct kone_device\n");
                         goto exit_free;
                 }
+
+                retval = roccat_connect(hdev);
+                if (retval < 0) {
+                        dev_err(&hdev->dev, "couldn't init char dev\n");
+                        /* be tolerant about not getting chrdev */
+                } else {
+                        kone->roccat_claimed = 1;
+                        kone->chrdev_minor = retval;
+                }
+
                 retval = kone_create_sysfs_attributes(intf);
                 if (retval) {
                         dev_err(&hdev->dev, "cannot create sysfs files\n");
@@ -868,10 +879,14 @@ exit_free:
 static void kone_remove_specials(struct hid_device *hdev)
 {
         struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
+        struct kone_device *kone;
 
         if (intf->cur_altsetting->desc.bInterfaceProtocol
                         == USB_INTERFACE_PROTOCOL_MOUSE) {
                 kone_remove_sysfs_attributes(intf);
+                kone = hid_get_drvdata(hdev);
+                if (kone->roccat_claimed)
+                        roccat_disconnect(kone->chrdev_minor);
                 kfree(hid_get_drvdata(hdev));
         }
 }
@@ -930,6 +945,37 @@ static void kone_keep_values_up_to_date(struct kone_device *kone,
         }
 }
 
+static void kone_report_to_chrdev(struct kone_device const *kone,
+                struct kone_mouse_event const *event)
+{
+        struct kone_roccat_report roccat_report;
+
+        switch (event->event) {
+        case kone_mouse_event_switch_profile:
+        case kone_mouse_event_switch_dpi:
+        case kone_mouse_event_osd_profile:
+        case kone_mouse_event_osd_dpi:
+                roccat_report.event = event->event;
+                roccat_report.value = event->value;
+                roccat_report.key = 0;
+                roccat_report_event(kone->chrdev_minor,
+                                (uint8_t *)&roccat_report,
+                                sizeof(struct kone_roccat_report));
+                break;
+        case kone_mouse_event_call_overlong_macro:
+                if (event->value == kone_keystroke_action_press) {
+                        roccat_report.event = kone_mouse_event_call_overlong_macro;
+                        roccat_report.value = kone->actual_profile;
+                        roccat_report.key = event->macro_key;
+                        roccat_report_event(kone->chrdev_minor,
+                                        (uint8_t *)&roccat_report,
+                                        sizeof(struct kone_roccat_report));
+                }
+                break;
+        }
+
+}
+
 /*
  * Is called for keyboard- and mousepart.
  * Only mousepart gets informations about special events in its extended event
@@ -958,6 +1004,9 @@ static int kone_raw_event(struct hid_device *hdev, struct hid_report *report,
 
         kone_keep_values_up_to_date(kone, event);
 
+        if (kone->roccat_claimed)
+                kone_report_to_chrdev(kone, event);
+
         return 0; /* always do further processing */
 }
 
diff --git a/drivers/hid/hid-roccat-kone.h b/drivers/hid/hid-roccat-kone.h
index b413b10a7f8a..003e6f81c195 100644
--- a/drivers/hid/hid-roccat-kone.h
+++ b/drivers/hid/hid-roccat-kone.h
@@ -189,6 +189,12 @@ enum kone_commands {
         kone_command_firmware = 0xe5a
 };
 
+struct kone_roccat_report {
+        uint8_t event;
+        uint8_t value; /* holds dpi or profile value */
+        uint8_t key; /* macro key on overlong macro execution */
+};
+
 #pragma pack(pop)
 
 struct kone_device {
@@ -219,6 +225,9 @@ struct kone_device {
          * so it's read only once
          */
         int firmware_version;
+
+        int roccat_claimed;
+        int chrdev_minor;
 };
 
 #endif
diff --git a/drivers/hid/hid-roccat.c b/drivers/hid/hid-roccat.c
new file mode 100644
index 000000000000..e05d48edb66f
--- /dev/null
+++ b/drivers/hid/hid-roccat.c
@@ -0,0 +1,428 @@
+/*
+ * Roccat driver for Linux
+ *
+ * Copyright (c) 2010 Stefan Achatz <erazor_de@users.sourceforge.net>
+ */
+
+/*
+ * 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.
+ */
+
+/*
+ * Module roccat is a char device used to report special events of roccat
+ * hardware to userland. These events include requests for on-screen-display of
+ * profile or dpi settings or requests for execution of macro sequences that are
+ * not stored in device. The information in these events depends on hid device
+ * implementation and contains data that is not available in a single hid event
+ * or else hidraw could have been used.
+ * It is inspired by hidraw, but uses only one circular buffer for all readers.
+ */
+
+#include <linux/cdev.h>
+#include <linux/poll.h>
+#include <linux/sched.h>
+
+#include "hid-roccat.h"
+
+#define ROCCAT_FIRST_MINOR 0
+#define ROCCAT_MAX_DEVICES 8
+
+/* should be a power of 2 for performance reason */
+#define ROCCAT_CBUF_SIZE 16
+
+struct roccat_report {
+        uint8_t *value;
+        int len;
+};
+
+struct roccat_device {
+        unsigned int minor;
+        int open;
+        int exist;
+        wait_queue_head_t wait;
+        struct device *dev;
+        struct hid_device *hid;
+        struct list_head readers;
+        /* protects modifications of readers list */
+        struct mutex readers_lock;
+
+        /*
+         * circular_buffer has one writer and multiple readers with their own
+         * read pointers
+         */
+        struct roccat_report cbuf[ROCCAT_CBUF_SIZE];
+        int cbuf_end;
+        struct mutex cbuf_lock;
+};
+
+struct roccat_reader {
+        struct list_head node;
+        struct roccat_device *device;
+        int cbuf_start;
+};
+
+static int roccat_major;
+static struct class *roccat_class;
+static struct cdev roccat_cdev;
+
+static struct roccat_device *devices[ROCCAT_MAX_DEVICES];
+/* protects modifications of devices array */
+static DEFINE_MUTEX(devices_lock);
+
+static ssize_t roccat_read(struct file *file, char __user *buffer,
+                size_t count, loff_t *ppos)
+{
+        struct roccat_reader *reader = file->private_data;
+        struct roccat_device *device = reader->device;
+        struct roccat_report *report;
+        ssize_t retval = 0, len;
+        DECLARE_WAITQUEUE(wait, current);
+
+        mutex_lock(&device->cbuf_lock);
+
+        /* no data? */
+        if (reader->cbuf_start == device->cbuf_end) {
+                add_wait_queue(&device->wait, &wait);
+                set_current_state(TASK_INTERRUPTIBLE);
+
+                /* wait for data */
+                while (reader->cbuf_start == device->cbuf_end) {
+                        if (file->f_flags & O_NONBLOCK) {
+                                retval = -EAGAIN;
+                                break;
+                        }
+                        if (signal_pending(current)) {
+                                retval = -ERESTARTSYS;
+                                break;
+                        }
+                        if (!device->exist) {
+                                retval = -EIO;
+                                break;
+                        }
+
+                        mutex_unlock(&device->cbuf_lock);
+                        schedule();
+                        mutex_lock(&device->cbuf_lock);
+                        set_current_state(TASK_INTERRUPTIBLE);
+                }
+
+                set_current_state(TASK_RUNNING);
+                remove_wait_queue(&device->wait, &wait);
+        }
+
+        /* here we either have data or a reason to return if retval is set */
+        if (retval)
+                goto exit_unlock;
+
+        report = &device->cbuf[reader->cbuf_start];
+        /*
+         * If report is larger than requested amount of data, rest of report
+         * is lost!
+         */
+        len = report->len > count ? count : report->len;
+
+        if (copy_to_user(buffer, report->value, len)) {
+                retval = -EFAULT;
+                goto exit_unlock;
+        }
+        retval += len;
+        reader->cbuf_start = (reader->cbuf_start + 1) % ROCCAT_CBUF_SIZE;
+
+exit_unlock:
+        mutex_unlock(&device->cbuf_lock);
+        return retval;
+}
+
+static unsigned int roccat_poll(struct file *file, poll_table *wait)
+{
+        struct roccat_reader *reader = file->private_data;
+        poll_wait(file, &reader->device->wait, wait);
+        if (reader->cbuf_start != reader->device->cbuf_end)
+                return POLLIN | POLLRDNORM;
+        if (!reader->device->exist)
+                return POLLERR | POLLHUP;
+        return 0;
+}
+
+static int roccat_open(struct inode *inode, struct file *file)
+{
+        unsigned int minor = iminor(inode);
+        struct roccat_reader *reader;
+        struct roccat_device *device;
+        int error = 0;
+
+        reader = kzalloc(sizeof(struct roccat_reader), GFP_KERNEL);
+        if (!reader)
+                return -ENOMEM;
+
+        mutex_lock(&devices_lock);
+
+        device = devices[minor];
+
+        mutex_lock(&device->readers_lock);
+
+        if (!device) {
+                printk(KERN_EMERG "roccat device with minor %d doesn't exist\n",
+                                minor);
+                error = -ENODEV;
+                goto exit_unlock;
+        }
+
+        if (!device->open++) {
+                /* power on device on adding first reader */
+                if (device->hid->ll_driver->power) {
+                        error = device->hid->ll_driver->power(device->hid,
+                                        PM_HINT_FULLON);
+                        if (error < 0) {
+                                --device->open;
+                                goto exit_unlock;
+                        }
+                }
+                error = device->hid->ll_driver->open(device->hid);
+                if (error < 0) {
+                        if (device->hid->ll_driver->power)
+                                device->hid->ll_driver->power(device->hid,
+                                                PM_HINT_NORMAL);
+                        --device->open;
+                        goto exit_unlock;
+                }
+        }
+
+        reader->device = device;
+        /* new reader doesn't get old events */
+        reader->cbuf_start = device->cbuf_end;
+
+        list_add_tail(&reader->node, &device->readers);
+        file->private_data = reader;
+
+exit_unlock:
+        mutex_unlock(&device->readers_lock);
+        mutex_unlock(&devices_lock);
+        return error;
+}
+
+static int roccat_release(struct inode *inode, struct file *file)
+{
+        unsigned int minor = iminor(inode);
+        struct roccat_reader *reader = file->private_data;
+        struct roccat_device *device;
+
+        mutex_lock(&devices_lock);
+
+        device = devices[minor];
+        if (!device) {
+                mutex_unlock(&devices_lock);
+                printk(KERN_EMERG "roccat device with minor %d doesn't exist\n",
+                                minor);
+                return -ENODEV;
+        }
+
+        mutex_lock(&device->readers_lock);
+        list_del(&reader->node);
+        mutex_unlock(&device->readers_lock);
+        kfree(reader);
+
+        if (!--device->open) {
+                /* removing last reader */
+                if (device->exist) {
+                        if (device->hid->ll_driver->power)
+                                device->hid->ll_driver->power(device->hid,
+                                                PM_HINT_NORMAL);
+                        device->hid->ll_driver->close(device->hid);
+                } else {
+                        kfree(device);
+                }
+        }
+
+        mutex_unlock(&devices_lock);
+
+        return 0;
+}
+
+/*
+ * roccat_report_event() - output data to readers
+ * @minor: minor device number returned by roccat_connect()
+ * @data: pointer to data
+ * @len: size of data
+ *
+ * Return value is zero on success, a negative error code on failure.
+ *
+ * This is called from interrupt handler.
+ */
+int roccat_report_event(int minor, u8 const *data, int len)
+{
+        struct roccat_device *device;
+        struct roccat_reader *reader;
+        struct roccat_report *report;
+        uint8_t *new_value;
+
+        new_value = kmemdup(data, len, GFP_ATOMIC);
+        if (!new_value)
+                return -ENOMEM;
+
+        device = devices[minor];
+
+        report = &device->cbuf[device->cbuf_end];
+
+        /* passing NULL is safe */
+        kfree(report->value);
+
+        report->value = new_value;
+        report->len = len;
+        device->cbuf_end = (device->cbuf_end + 1) % ROCCAT_CBUF_SIZE;
+
+        list_for_each_entry(reader, &device->readers, node) {
+                /*
+                 * As we already inserted one element, the buffer can't be
+                 * empty. If start and end are equal, buffer is full and we
+                 * increase start, so that slow reader misses one event, but
+                 * gets the newer ones in the right order.
+                 */
+                if (reader->cbuf_start == device->cbuf_end)
+                        reader->cbuf_start = (reader->cbuf_start + 1) % ROCCAT_CBUF_SIZE;
+        }
+
+        wake_up_interruptible(&device->wait);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(roccat_report_event);
+
+/*
+ * roccat_connect() - create a char device for special event output
+ * @hid: the hid device the char device should be connected to.
+ *
+ * Return value is minor device number in Range [0, ROCCAT_MAX_DEVICES] on
+ * success, a negative error code on failure.
+ */
+int roccat_connect(struct hid_device *hid)
+{
+        unsigned int minor;
+        struct roccat_device *device;
+        int temp;
+
+        device = kzalloc(sizeof(struct roccat_device), GFP_KERNEL);
+        if (!device)
+                return -ENOMEM;
+
+        mutex_lock(&devices_lock);
+
+        for (minor = 0; minor < ROCCAT_MAX_DEVICES; ++minor) {
+                if (devices[minor])
+                        continue;
+                break;
+        }
+
+        if (minor < ROCCAT_MAX_DEVICES) {
+                devices[minor] = device;
+        } else {
+                mutex_unlock(&devices_lock);
+                kfree(device);
+                return -EINVAL;
+        }
+
+        device->dev = device_create(roccat_class, &hid->dev,
+                        MKDEV(roccat_major, minor), NULL,
+                        "%s%s%d", "roccat", hid->driver->name, minor);
+
+        if (IS_ERR(device->dev)) {
+                devices[minor] = NULL;
+                mutex_unlock(&devices_lock);
+                temp = PTR_ERR(device->dev);
+                kfree(device);
+                return temp;
+        }
+
+        mutex_unlock(&devices_lock);
+
+        init_waitqueue_head(&device->wait);
+        INIT_LIST_HEAD(&device->readers);
+        mutex_init(&device->readers_lock);
+        mutex_init(&device->cbuf_lock);
+        device->minor = minor;
+        device->hid = hid;
+        device->exist = 1;
+        device->cbuf_end = 0;
+
+        return minor;
+}
+EXPORT_SYMBOL_GPL(roccat_connect);
+
+/* roccat_disconnect() - remove char device from hid device
+ * @minor: the minor device number returned by roccat_connect()
+ */
+void roccat_disconnect(int minor)
+{
+        struct roccat_device *device;
+
+        mutex_lock(&devices_lock);
+        device = devices[minor];
+        devices[minor] = NULL;
+        mutex_unlock(&devices_lock);
+
+        device->exist = 0; /* TODO exist maybe not needed */
+
+        device_destroy(roccat_class, MKDEV(roccat_major, minor));
+
+        if (device->open) {
+                device->hid->ll_driver->close(device->hid);
+                wake_up_interruptible(&device->wait);
+        } else {
+                kfree(device);
+        }
+}
+EXPORT_SYMBOL_GPL(roccat_disconnect);
+
+static const struct file_operations roccat_ops = {
+        .owner = THIS_MODULE,
+        .read = roccat_read,
+        .poll = roccat_poll,
+        .open = roccat_open,
+        .release = roccat_release,
+};
+
+static int __init roccat_init(void)
+{
+        int retval;
+        dev_t dev_id;
+
+        retval = alloc_chrdev_region(&dev_id, ROCCAT_FIRST_MINOR,
+                        ROCCAT_MAX_DEVICES, "roccat");
+
+        roccat_major = MAJOR(dev_id);
+
+        if (retval < 0) {
+                printk(KERN_WARNING "roccat: can't get major number\n");
+                return retval;
+        }
+
+        roccat_class = class_create(THIS_MODULE, "roccat");
+        if (IS_ERR(roccat_class)) {
+                retval = PTR_ERR(roccat_class);
+                unregister_chrdev_region(dev_id, ROCCAT_MAX_DEVICES);
+                return retval;
+        }
+
+        cdev_init(&roccat_cdev, &roccat_ops);
+        cdev_add(&roccat_cdev, dev_id, ROCCAT_MAX_DEVICES);
+
+        return 0;
+}
+
+static void __exit roccat_exit(void)
+{
+        dev_t dev_id = MKDEV(roccat_major, 0);
+
+        cdev_del(&roccat_cdev);
+        class_destroy(roccat_class);
+        unregister_chrdev_region(dev_id, ROCCAT_MAX_DEVICES);
+}
+
+module_init(roccat_init);
+module_exit(roccat_exit);
+
+MODULE_AUTHOR("Stefan Achatz");
+MODULE_DESCRIPTION("USB Roccat char device");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/hid/hid-roccat.h b/drivers/hid/hid-roccat.h
new file mode 100644
index 000000000000..d8aae0c1fa7e
--- /dev/null
+++ b/drivers/hid/hid-roccat.h
@@ -0,0 +1,31 @@
+#ifndef __HID_ROCCAT_H
+#define __HID_ROCCAT_H
+
+/*
+ * Copyright (c) 2010 Stefan Achatz <erazor_de@users.sourceforge.net>
+ */
+
+/*
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ */
+
+#include <linux/hid.h>
+#include <linux/types.h>
+
+#if defined(CONFIG_HID_ROCCAT) || defined (CONFIG_HID_ROCCAT_MODULE)
+int roccat_connect(struct hid_device *hid);
+void roccat_disconnect(int minor);
+int roccat_report_event(int minor, u8 const *data, int len);
+#else
+static inline int roccat_connect(struct hid_device *hid) { return -1; }
+static inline void roccat_disconnect(int minor) {}
+static inline int roccat_report_event(int minor, u8 const *data, int len)
+{
+        return 0;
+}
+#endif
+
+#endif
diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
index 6a9ac754ca5d..e19cf8eb6ccf 100644
--- a/drivers/hwmon/Kconfig
+++ b/drivers/hwmon/Kconfig
@@ -447,13 +447,14 @@ config SENSORS_IT87
           will be called it87.
 
 config SENSORS_LM63
-        tristate "National Semiconductor LM63"
+        tristate "National Semiconductor LM63 and LM64"
         depends on I2C
         help
-          If you say yes here you get support for the National Semiconductor
-          LM63 remote diode digital temperature sensor with integrated fan
-          control.  Such chips are found on the Tyan S4882 (Thunder K8QS Pro)
-          motherboard, among others.
+          If you say yes here you get support for the National
+          Semiconductor LM63 and LM64 remote diode digital temperature
+          sensors with integrated fan control.  Such chips are found
+          on the Tyan S4882 (Thunder K8QS Pro) motherboard, among
+          others.
 
           This driver can also be built as a module.  If so, the module
           will be called lm63.
@@ -492,7 +493,8 @@ config SENSORS_LM75
                 - NXP's LM75A
                 - ST Microelectronics STDS75
                 - TelCom (now Microchip) TCN75
-                - Texas Instruments TMP100, TMP101, TMP75, TMP175, TMP275
+                - Texas Instruments TMP100, TMP101, TMP105, TMP75, TMP175,
+                  TMP275
 
           This driver supports driver model based binding through board
           specific I2C device tables.
@@ -749,6 +751,16 @@ config SENSORS_DME1737
           This driver can also be built as a module.  If so, the module
           will be called dme1737.
 
+config SENSORS_EMC1403
+        tristate "SMSC EMC1403 thermal sensor"
+        depends on I2C
+        help
+          If you say yes here you get support for the SMSC EMC1403
+          temperature monitoring chip.
+
+          Threshold values can be configured using sysfs.
+          Data from the different diodes are accessible via sysfs.
+
 config SENSORS_SMSC47M1
         tristate "SMSC LPC47M10x and compatibles"
         help
@@ -831,6 +843,16 @@ config SENSORS_THMC50
           This driver can also be built as a module.  If so, the module
           will be called thmc50.
 
+config SENSORS_TMP102
+        tristate "Texas Instruments TMP102"
+        depends on I2C && EXPERIMENTAL
+        help
+          If you say yes here you get support for Texas Instruments TMP102
+          sensor chips.
+
+          This driver can also be built as a module.  If so, the module
+          will be called tmp102.
+
 config SENSORS_TMP401
         tristate "Texas Instruments TMP401 and compatibles"
         depends on I2C && EXPERIMENTAL
diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
index 86920fb34118..2138ceb1a713 100644
--- a/drivers/hwmon/Makefile
+++ b/drivers/hwmon/Makefile
@@ -41,6 +41,7 @@ obj-$(CONFIG_SENSORS_ATXP1)	+= atxp1.o
 obj-$(CONFIG_SENSORS_CORETEMP)  += coretemp.o
 obj-$(CONFIG_SENSORS_DME1737)   += dme1737.o
 obj-$(CONFIG_SENSORS_DS1621)    += ds1621.o
+obj-$(CONFIG_SENSORS_EMC1403)   += emc1403.o
 obj-$(CONFIG_SENSORS_F71805F)   += f71805f.o
 obj-$(CONFIG_SENSORS_F71882FG)  += f71882fg.o
 obj-$(CONFIG_SENSORS_F75375S)   += f75375s.o
@@ -90,6 +91,7 @@ obj-$(CONFIG_SENSORS_SMSC47M1)	+= smsc47m1.o
 obj-$(CONFIG_SENSORS_SMSC47M192)+= smsc47m192.o
 obj-$(CONFIG_SENSORS_AMC6821)   += amc6821.o
 obj-$(CONFIG_SENSORS_THMC50)    += thmc50.o
+obj-$(CONFIG_SENSORS_TMP102)    += tmp102.o
 obj-$(CONFIG_SENSORS_TMP401)    += tmp401.o
 obj-$(CONFIG_SENSORS_TMP421)    += tmp421.o
 obj-$(CONFIG_SENSORS_VIA_CPUTEMP)+= via-cputemp.o
diff --git a/drivers/hwmon/adm1031.c b/drivers/hwmon/adm1031.c
index 1644b92e7cc4..15c1a9616af3 100644
--- a/drivers/hwmon/adm1031.c
+++ b/drivers/hwmon/adm1031.c
@@ -36,6 +36,7 @@
 #define ADM1031_REG_FAN_DIV(nr)         (0x20 + (nr))
 #define ADM1031_REG_PWM                 (0x22)
 #define ADM1031_REG_FAN_MIN(nr)         (0x10 + (nr))
+#define ADM1031_REG_FAN_FILTER          (0x23)
 
 #define ADM1031_REG_TEMP_OFFSET(nr)     (0x0d + (nr))
 #define ADM1031_REG_TEMP_MAX(nr)        (0x14 + 4 * (nr))
@@ -61,6 +62,9 @@
 #define ADM1031_CONF2_TACH2_ENABLE      0x08
 #define ADM1031_CONF2_TEMP_ENABLE(chan) (0x10 << (chan))
 
+#define ADM1031_UPDATE_RATE_MASK        0x1c
+#define ADM1031_UPDATE_RATE_SHIFT       2
+
 /* Addresses to scan */
 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };
 
@@ -75,6 +79,7 @@ struct adm1031_data {
         int chip_type;
         char valid;             /* !=0 if following fields are valid */
         unsigned long last_updated;     /* In jiffies */
+        unsigned int update_rate;       /* In milliseconds */
         /* The chan_select_table contains the possible configurations for
          * auto fan control.
          */
@@ -738,6 +743,57 @@ static SENSOR_DEVICE_ATTR(temp3_crit_alarm, S_IRUGO, show_alarm, NULL, 12);
 static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_alarm, NULL, 13);
 static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 14);
 
+/* Update Rate */
+static const unsigned int update_rates[] = {
+        16000, 8000, 4000, 2000, 1000, 500, 250, 125,
+};
+
+static ssize_t show_update_rate(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct adm1031_data *data = i2c_get_clientdata(client);
+
+        return sprintf(buf, "%u\n", data->update_rate);
+}
+
+static ssize_t set_update_rate(struct device *dev,
+                               struct device_attribute *attr,
+                               const char *buf, size_t count)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct adm1031_data *data = i2c_get_clientdata(client);
+        unsigned long val;
+        int i, err;
+        u8 reg;
+
+        err = strict_strtoul(buf, 10, &val);
+        if (err)
+                return err;
+
+        /* find the nearest update rate from the table */
+        for (i = 0; i < ARRAY_SIZE(update_rates) - 1; i++) {
+                if (val >= update_rates[i])
+                        break;
+        }
+        /* if not found, we point to the last entry (lowest update rate) */
+
+        /* set the new update rate while preserving other settings */
+        reg = adm1031_read_value(client, ADM1031_REG_FAN_FILTER);
+        reg &= ~ADM1031_UPDATE_RATE_MASK;
+        reg |= i << ADM1031_UPDATE_RATE_SHIFT;
+        adm1031_write_value(client, ADM1031_REG_FAN_FILTER, reg);
+
+        mutex_lock(&data->update_lock);
+        data->update_rate = update_rates[i];
+        mutex_unlock(&data->update_lock);
+
+        return count;
+}
+
+static DEVICE_ATTR(update_rate, S_IRUGO | S_IWUSR, show_update_rate,
+                   set_update_rate);
+
 static struct attribute *adm1031_attributes[] = {
         &sensor_dev_attr_fan1_input.dev_attr.attr,
         &sensor_dev_attr_fan1_div.dev_attr.attr,
@@ -774,6 +830,7 @@ static struct attribute *adm1031_attributes[] = {
 
         &sensor_dev_attr_auto_fan1_min_pwm.dev_attr.attr,
 
+        &dev_attr_update_rate.attr,
         &dev_attr_alarms.attr,
 
         NULL
@@ -900,6 +957,7 @@ static void adm1031_init_client(struct i2c_client *client)
 {
         unsigned int read_val;
         unsigned int mask;
+        int i;
         struct adm1031_data *data = i2c_get_clientdata(client);
 
         mask = (ADM1031_CONF2_PWM1_ENABLE | ADM1031_CONF2_TACH1_ENABLE);
@@ -919,18 +977,24 @@ static void adm1031_init_client(struct i2c_client *client)
                                 ADM1031_CONF1_MONITOR_ENABLE);
         }
 
+        /* Read the chip's update rate */
+        mask = ADM1031_UPDATE_RATE_MASK;
+        read_val = adm1031_read_value(client, ADM1031_REG_FAN_FILTER);
+        i = (read_val & mask) >> ADM1031_UPDATE_RATE_SHIFT;
+        data->update_rate = update_rates[i];
 }
 
 static struct adm1031_data *adm1031_update_device(struct device *dev)
 {
         struct i2c_client *client = to_i2c_client(dev);
         struct adm1031_data *data = i2c_get_clientdata(client);
+        unsigned long next_update;
         int chan;
 
         mutex_lock(&data->update_lock);
 
-        if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
-            || !data->valid) {
+        next_update = data->last_updated + msecs_to_jiffies(data->update_rate);
+        if (time_after(jiffies, next_update) || !data->valid) {
 
                 dev_dbg(&client->dev, "Starting adm1031 update\n");
                 for (chan = 0;
diff --git a/drivers/hwmon/applesmc.c b/drivers/hwmon/applesmc.c
index f085c18d2905..b6598aa557a0 100644
--- a/drivers/hwmon/applesmc.c
+++ b/drivers/hwmon/applesmc.c
@@ -148,6 +148,20 @@ static const char *temperature_sensors_sets[][41] = {
 /* Set 18: MacBook Pro 2,2 */
         { "TB0T", "TC0D", "TC0P", "TG0H", "TG0P", "TG0T", "TM0P", "TTF0",
           "Th0H", "Th1H", "Tm0P", "Ts0P", NULL },
+/* Set 19: Macbook Pro 5,3 */
+        { "TB0T", "TB1T", "TB2T", "TB3T", "TC0D", "TC0F", "TC0P", "TG0D",
+          "TG0F", "TG0H", "TG0P", "TG0T", "TN0D", "TN0P", "TTF0", "Th2H",
+          "Tm0P", "Ts0P", "Ts0S", NULL },
+/* Set 20: MacBook Pro 5,4 */
+        { "TB0T", "TB1T", "TB2T", "TB3T", "TC0D", "TC0F", "TC0P", "TN0D",
+          "TN0P", "TTF0", "Th2H", "Ts0P", "Ts0S", NULL },
+/* Set 21: MacBook Pro 6,2 */
+        { "TB0T", "TB1T", "TB2T", "TC0C", "TC0D", "TC0P", "TC1C", "TG0D",
+          "TG0P", "TG0T", "TMCD", "TP0P", "TPCD", "Th1H", "Th2H", "Tm0P",
+          "Ts0P", "Ts0S", NULL },
+/* Set 22: MacBook Pro 7,1 */
+        { "TB0T", "TB1T", "TB2T", "TC0D", "TC0P", "TN0D", "TN0P", "TN0S",
+          "TN1D", "TN1F", "TN1G", "TN1S", "Th1H", "Ts0P", "Ts0S", NULL },
 };
 
 /* List of keys used to read/write fan speeds */
@@ -646,6 +660,17 @@ out:
                 return snprintf(sysfsbuf, PAGE_SIZE, "(%d,%d)\n", left, right);
 }
 
+/* Displays sensor key as label */
+static ssize_t applesmc_show_sensor_label(struct device *dev,
+                        struct device_attribute *devattr, char *sysfsbuf)
+{
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+        const char *key =
+                temperature_sensors_sets[applesmc_temperature_set][attr->index];
+
+        return snprintf(sysfsbuf, PAGE_SIZE, "%s\n", key);
+}
+
 /* Displays degree Celsius * 1000 */
 static ssize_t applesmc_show_temperature(struct device *dev,
                         struct device_attribute *devattr, char *sysfsbuf)
@@ -1113,6 +1138,86 @@ static const struct attribute_group fan_attribute_groups[] = {
 /*
  * Temperature sensors sysfs entries.
  */
+static SENSOR_DEVICE_ATTR(temp1_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 0);
+static SENSOR_DEVICE_ATTR(temp2_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 1);
+static SENSOR_DEVICE_ATTR(temp3_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 2);
+static SENSOR_DEVICE_ATTR(temp4_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 3);
+static SENSOR_DEVICE_ATTR(temp5_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 4);
+static SENSOR_DEVICE_ATTR(temp6_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 5);
+static SENSOR_DEVICE_ATTR(temp7_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 6);
+static SENSOR_DEVICE_ATTR(temp8_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 7);
+static SENSOR_DEVICE_ATTR(temp9_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 8);
+static SENSOR_DEVICE_ATTR(temp10_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 9);
+static SENSOR_DEVICE_ATTR(temp11_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 10);
+static SENSOR_DEVICE_ATTR(temp12_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 11);
+static SENSOR_DEVICE_ATTR(temp13_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 12);
+static SENSOR_DEVICE_ATTR(temp14_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 13);
+static SENSOR_DEVICE_ATTR(temp15_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 14);
+static SENSOR_DEVICE_ATTR(temp16_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 15);
+static SENSOR_DEVICE_ATTR(temp17_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 16);
+static SENSOR_DEVICE_ATTR(temp18_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 17);
+static SENSOR_DEVICE_ATTR(temp19_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 18);
+static SENSOR_DEVICE_ATTR(temp20_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 19);
+static SENSOR_DEVICE_ATTR(temp21_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 20);
+static SENSOR_DEVICE_ATTR(temp22_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 21);
+static SENSOR_DEVICE_ATTR(temp23_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 22);
+static SENSOR_DEVICE_ATTR(temp24_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 23);
+static SENSOR_DEVICE_ATTR(temp25_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 24);
+static SENSOR_DEVICE_ATTR(temp26_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 25);
+static SENSOR_DEVICE_ATTR(temp27_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 26);
+static SENSOR_DEVICE_ATTR(temp28_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 27);
+static SENSOR_DEVICE_ATTR(temp29_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 28);
+static SENSOR_DEVICE_ATTR(temp30_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 29);
+static SENSOR_DEVICE_ATTR(temp31_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 30);
+static SENSOR_DEVICE_ATTR(temp32_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 31);
+static SENSOR_DEVICE_ATTR(temp33_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 32);
+static SENSOR_DEVICE_ATTR(temp34_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 33);
+static SENSOR_DEVICE_ATTR(temp35_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 34);
+static SENSOR_DEVICE_ATTR(temp36_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 35);
+static SENSOR_DEVICE_ATTR(temp37_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 36);
+static SENSOR_DEVICE_ATTR(temp38_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 37);
+static SENSOR_DEVICE_ATTR(temp39_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 38);
+static SENSOR_DEVICE_ATTR(temp40_label, S_IRUGO,
+                                        applesmc_show_sensor_label, NULL, 39);
 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO,
                                         applesmc_show_temperature, NULL, 0);
 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO,
@@ -1194,6 +1299,50 @@ static SENSOR_DEVICE_ATTR(temp39_input, S_IRUGO,
 static SENSOR_DEVICE_ATTR(temp40_input, S_IRUGO,
                                         applesmc_show_temperature, NULL, 39);
 
+static struct attribute *label_attributes[] = {
+        &sensor_dev_attr_temp1_label.dev_attr.attr,
+        &sensor_dev_attr_temp2_label.dev_attr.attr,
+        &sensor_dev_attr_temp3_label.dev_attr.attr,
+        &sensor_dev_attr_temp4_label.dev_attr.attr,
+        &sensor_dev_attr_temp5_label.dev_attr.attr,
+        &sensor_dev_attr_temp6_label.dev_attr.attr,
+        &sensor_dev_attr_temp7_label.dev_attr.attr,
+        &sensor_dev_attr_temp8_label.dev_attr.attr,
+        &sensor_dev_attr_temp9_label.dev_attr.attr,
+        &sensor_dev_attr_temp10_label.dev_attr.attr,
+        &sensor_dev_attr_temp11_label.dev_attr.attr,
+        &sensor_dev_attr_temp12_label.dev_attr.attr,
+        &sensor_dev_attr_temp13_label.dev_attr.attr,
+        &sensor_dev_attr_temp14_label.dev_attr.attr,
+        &sensor_dev_attr_temp15_label.dev_attr.attr,
+        &sensor_dev_attr_temp16_label.dev_attr.attr,
+        &sensor_dev_attr_temp17_label.dev_attr.attr,
+        &sensor_dev_attr_temp18_label.dev_attr.attr,
+        &sensor_dev_attr_temp19_label.dev_attr.attr,
+        &sensor_dev_attr_temp20_label.dev_attr.attr,
+        &sensor_dev_attr_temp21_label.dev_attr.attr,
+        &sensor_dev_attr_temp22_label.dev_attr.attr,
+        &sensor_dev_attr_temp23_label.dev_attr.attr,
+        &sensor_dev_attr_temp24_label.dev_attr.attr,
+        &sensor_dev_attr_temp25_label.dev_attr.attr,
+        &sensor_dev_attr_temp26_label.dev_attr.attr,
+        &sensor_dev_attr_temp27_label.dev_attr.attr,
+        &sensor_dev_attr_temp28_label.dev_attr.attr,
+        &sensor_dev_attr_temp29_label.dev_attr.attr,
+        &sensor_dev_attr_temp30_label.dev_attr.attr,
+        &sensor_dev_attr_temp31_label.dev_attr.attr,
+        &sensor_dev_attr_temp32_label.dev_attr.attr,
+        &sensor_dev_attr_temp33_label.dev_attr.attr,
+        &sensor_dev_attr_temp34_label.dev_attr.attr,
+        &sensor_dev_attr_temp35_label.dev_attr.attr,
+        &sensor_dev_attr_temp36_label.dev_attr.attr,
+        &sensor_dev_attr_temp37_label.dev_attr.attr,
+        &sensor_dev_attr_temp38_label.dev_attr.attr,
+        &sensor_dev_attr_temp39_label.dev_attr.attr,
+        &sensor_dev_attr_temp40_label.dev_attr.attr,
+        NULL
+};
+
 static struct attribute *temperature_attributes[] = {
         &sensor_dev_attr_temp1_input.dev_attr.attr,
         &sensor_dev_attr_temp2_input.dev_attr.attr,
@@ -1241,6 +1390,10 @@ static struct attribute *temperature_attributes[] = {
 static const struct attribute_group temperature_attributes_group =
         { .attrs = temperature_attributes };
 
+static const struct attribute_group label_attributes_group = {
+        .attrs = label_attributes
+};
+
 /* Module stuff */
 
 /*
@@ -1363,6 +1516,14 @@ static __initdata struct dmi_match_data applesmc_dmi_data[] = {
         { .accelerometer = 0, .light = 0, .temperature_set = 17 },
 /* MacBook Pro 2,2: accelerometer, backlight and temperature set 18 */
         { .accelerometer = 1, .light = 1, .temperature_set = 18 },
+/* MacBook Pro 5,3: accelerometer, backlight and temperature set 19 */
+        { .accelerometer = 1, .light = 1, .temperature_set = 19 },
+/* MacBook Pro 5,4: accelerometer, backlight and temperature set 20 */
+        { .accelerometer = 1, .light = 1, .temperature_set = 20 },
+/* MacBook Pro 6,2: accelerometer, backlight and temperature set 21 */
+        { .accelerometer = 1, .light = 1, .temperature_set = 21 },
+/* MacBook Pro 7,1: accelerometer, backlight and temperature set 22 */
+        { .accelerometer = 1, .light = 1, .temperature_set = 22 },
 };
 
 /* Note that DMI_MATCH(...,"MacBook") will match "MacBookPro1,1".
@@ -1376,6 +1537,22 @@ static __initdata struct dmi_system_id applesmc_whitelist[] = {
           DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
           DMI_MATCH(DMI_PRODUCT_NAME, "MacBookAir") },
                 &applesmc_dmi_data[7]},
+        { applesmc_dmi_match, "Apple MacBook Pro 7", {
+          DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
+          DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro7") },
+                &applesmc_dmi_data[22]},
+        { applesmc_dmi_match, "Apple MacBook Pro 5,4", {
+          DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
+          DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro5,4") },
+                &applesmc_dmi_data[20]},
+        { applesmc_dmi_match, "Apple MacBook Pro 5,3", {
+          DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
+          DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro5,3") },
+                &applesmc_dmi_data[19]},
+        { applesmc_dmi_match, "Apple MacBook Pro 6", {
+          DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
+          DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro6") },
+                &applesmc_dmi_data[21]},
         { applesmc_dmi_match, "Apple MacBook Pro 5", {
           DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
           DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro5") },
@@ -1518,7 +1695,8 @@ static int __init applesmc_init(void)
         for (i = 0;
              temperature_sensors_sets[applesmc_temperature_set][i] != NULL;
              i++) {
-                if (temperature_attributes[i] == NULL) {
+                if (temperature_attributes[i] == NULL ||
+                    label_attributes[i] == NULL) {
                         printk(KERN_ERR "applesmc: More temperature sensors "
                                 "in temperature_sensors_sets (at least %i)"
                                 "than available sysfs files in "
@@ -1530,6 +1708,10 @@ static int __init applesmc_init(void)
                                                 temperature_attributes[i]);
                 if (ret)
                         goto out_temperature;
+                ret = sysfs_create_file(&pdev->dev.kobj,
+                                                label_attributes[i]);
+                if (ret)
+                        goto out_temperature;
         }
 
         if (applesmc_accelerometer) {
@@ -1580,6 +1762,7 @@ out_accelerometer:
         if (applesmc_accelerometer)
                 applesmc_release_accelerometer();
 out_temperature:
+        sysfs_remove_group(&pdev->dev.kobj, &label_attributes_group);
         sysfs_remove_group(&pdev->dev.kobj, &temperature_attributes_group);
 out_fans:
         while (fans_handled)
@@ -1609,6 +1792,7 @@ static void __exit applesmc_exit(void)
         }
         if (applesmc_accelerometer)
                 applesmc_release_accelerometer();
+        sysfs_remove_group(&pdev->dev.kobj, &label_attributes_group);
         sysfs_remove_group(&pdev->dev.kobj, &temperature_attributes_group);
         while (fans_handled)
                 sysfs_remove_group(&pdev->dev.kobj,
diff --git a/drivers/hwmon/asus_atk0110.c b/drivers/hwmon/asus_atk0110.c
index 16c420240724..653db1bda934 100644
--- a/drivers/hwmon/asus_atk0110.c
+++ b/drivers/hwmon/asus_atk0110.c
@@ -1411,6 +1411,13 @@ static int __init atk0110_init(void)
 {
         int ret;
 
+        /* Make sure it's safe to access the device through ACPI */
+        if (!acpi_resources_are_enforced()) {
+                pr_err("atk: Resources not safely usable due to "
+                       "acpi_enforce_resources kernel parameter\n");
+                return -EBUSY;
+        }
+
         ret = acpi_bus_register_driver(&atk_driver);
         if (ret)
                 pr_info("atk: acpi_bus_register_driver failed: %d\n", ret);
diff --git a/drivers/hwmon/dme1737.c b/drivers/hwmon/dme1737.c
index 823dd28a902c..980c17d5eeae 100644
--- a/drivers/hwmon/dme1737.c
+++ b/drivers/hwmon/dme1737.c
@@ -1,12 +1,14 @@
 /*
- * dme1737.c - Driver for the SMSC DME1737, Asus A8000, SMSC SCH311x and
- *             SCH5027 Super-I/O chips integrated hardware monitoring features.
- * Copyright (c) 2007, 2008 Juerg Haefliger <juergh@gmail.com>
+ * dme1737.c - Driver for the SMSC DME1737, Asus A8000, SMSC SCH311x, SCH5027,
+ *             and SCH5127 Super-I/O chips integrated hardware monitoring
+ *             features.
+ * Copyright (c) 2007, 2008, 2009, 2010 Juerg Haefliger <juergh@gmail.com>
  *
  * This driver is an I2C/ISA hybrid, meaning that it uses the I2C bus to access
  * the chip registers if a DME1737, A8000, or SCH5027 is found and the ISA bus
- * if a SCH311x chip is found. Both types of chips have very similar hardware
- * monitoring capabilities but differ in the way they can be accessed.
+ * if a SCH311x or SCH5127 chip is found. Both types of chips have very
+ * similar hardware monitoring capabilities but differ in the way they can be
+ * accessed.
  *
  * 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
@@ -57,7 +59,7 @@ MODULE_PARM_DESC(probe_all_addr, "Include probing of non-standard LPC "
 /* Addresses to scan */
 static const unsigned short normal_i2c[] = {0x2c, 0x2d, 0x2e, I2C_CLIENT_END};
 
-enum chips { dme1737, sch5027, sch311x };
+enum chips { dme1737, sch5027, sch311x, sch5127 };
 
 /* ---------------------------------------------------------------------
  * Registers
@@ -164,10 +166,29 @@ static const u8 DME1737_BIT_ALARM_FAN[] = {10, 11, 12, 13, 22, 23};
 #define DME1737_VERSTEP_MASK    0xf8
 #define SCH311X_DEVICE          0x8c
 #define SCH5027_VERSTEP         0x69
+#define SCH5127_DEVICE          0x8e
+
+/* Device ID values (global configuration register index 0x20) */
+#define DME1737_ID_1    0x77
+#define DME1737_ID_2    0x78
+#define SCH3112_ID      0x7c
+#define SCH3114_ID      0x7d
+#define SCH3116_ID      0x7f
+#define SCH5027_ID      0x89
+#define SCH5127_ID      0x86
 
 /* Length of ISA address segment */
 #define DME1737_EXTENT  2
 
+/* chip-dependent features */
+#define HAS_TEMP_OFFSET         (1 << 0)                /* bit 0 */
+#define HAS_VID                 (1 << 1)                /* bit 1 */
+#define HAS_ZONE3               (1 << 2)                /* bit 2 */
+#define HAS_ZONE_HYST           (1 << 3)                /* bit 3 */
+#define HAS_PWM_MIN             (1 << 4)                /* bit 4 */
+#define HAS_FAN(ix)             (1 << ((ix) + 5))       /* bits 5-10 */
+#define HAS_PWM(ix)             (1 << ((ix) + 11))      /* bits 11-16 */
+
 /* ---------------------------------------------------------------------
  * Data structures and manipulation thereof
  * --------------------------------------------------------------------- */
@@ -187,8 +208,7 @@ struct dme1737_data {
 
         u8 vid;
         u8 pwm_rr_en;
-        u8 has_pwm;
-        u8 has_fan;
+        u32 has_features;
 
         /* Register values */
         u16 in[7];
@@ -224,8 +244,11 @@ static const int IN_NOMINAL_SCH311x[] = {2500, 1500, 3300, 5000, 12000, 3300,
                                          3300};
 static const int IN_NOMINAL_SCH5027[] = {5000, 2250, 3300, 1125, 1125, 3300,
                                          3300};
+static const int IN_NOMINAL_SCH5127[] = {2500, 2250, 3300, 1125, 1125, 3300,
+                                         3300};
 #define IN_NOMINAL(type)        ((type) == sch311x ? IN_NOMINAL_SCH311x : \
                                  (type) == sch5027 ? IN_NOMINAL_SCH5027 : \
+                                 (type) == sch5127 ? IN_NOMINAL_SCH5127 : \
                                  IN_NOMINAL_DME1737)
 
 /* Voltage input
@@ -568,7 +591,7 @@ static struct dme1737_data *dme1737_update_device(struct device *dev)
 
         /* Sample register contents every 1 sec */
         if (time_after(jiffies, data->last_update + HZ) || !data->valid) {
-                if (data->type == dme1737) {
+                if (data->has_features & HAS_VID) {
                         data->vid = dme1737_read(data, DME1737_REG_VID) &
                                 0x3f;
                 }
@@ -599,7 +622,7 @@ static struct dme1737_data *dme1737_update_device(struct device *dev)
                                         DME1737_REG_TEMP_MIN(ix));
                         data->temp_max[ix] = dme1737_read(data,
                                         DME1737_REG_TEMP_MAX(ix));
-                        if (data->type != sch5027) {
+                        if (data->has_features & HAS_TEMP_OFFSET) {
                                 data->temp_offset[ix] = dme1737_read(data,
                                                 DME1737_REG_TEMP_OFFSET(ix));
                         }
@@ -626,7 +649,7 @@ static struct dme1737_data *dme1737_update_device(struct device *dev)
                 for (ix = 0; ix < ARRAY_SIZE(data->fan); ix++) {
                         /* Skip reading registers if optional fans are not
                          * present */
-                        if (!(data->has_fan & (1 << ix))) {
+                        if (!(data->has_features & HAS_FAN(ix))) {
                                 continue;
                         }
                         data->fan[ix] = dme1737_read(data,
@@ -650,7 +673,7 @@ static struct dme1737_data *dme1737_update_device(struct device *dev)
                 for (ix = 0; ix < ARRAY_SIZE(data->pwm); ix++) {
                         /* Skip reading registers if optional PWMs are not
                          * present */
-                        if (!(data->has_pwm & (1 << ix))) {
+                        if (!(data->has_features & HAS_PWM(ix))) {
                                 continue;
                         }
                         data->pwm[ix] = dme1737_read(data,
@@ -672,12 +695,24 @@ static struct dme1737_data *dme1737_update_device(struct device *dev)
 
                 /* Thermal zone registers */
                 for (ix = 0; ix < ARRAY_SIZE(data->zone_low); ix++) {
-                        data->zone_low[ix] = dme1737_read(data,
-                                        DME1737_REG_ZONE_LOW(ix));
-                        data->zone_abs[ix] = dme1737_read(data,
-                                        DME1737_REG_ZONE_ABS(ix));
+                        /* Skip reading registers if zone3 is not present */
+                        if ((ix == 2) && !(data->has_features & HAS_ZONE3)) {
+                                continue;
+                        }
+                        /* sch5127 zone2 registers are special */
+                        if ((ix == 1) && (data->type == sch5127)) {
+                                data->zone_low[1] = dme1737_read(data,
+                                                DME1737_REG_ZONE_LOW(2));
+                                data->zone_abs[1] = dme1737_read(data,
+                                                DME1737_REG_ZONE_ABS(2));
+                        } else {
+                                data->zone_low[ix] = dme1737_read(data,
+                                                DME1737_REG_ZONE_LOW(ix));
+                                data->zone_abs[ix] = dme1737_read(data,
+                                                DME1737_REG_ZONE_ABS(ix));
+                        }
                 }
-                if (data->type != sch5027) {
+                if (data->has_features & HAS_ZONE_HYST) {
                         for (ix = 0; ix < ARRAY_SIZE(data->zone_hyst); ix++) {
                                 data->zone_hyst[ix] = dme1737_read(data,
                                                 DME1737_REG_ZONE_HYST(ix));
@@ -1594,10 +1629,6 @@ static struct attribute *dme1737_attr[] ={
         &sensor_dev_attr_zone2_auto_point2_temp.dev_attr.attr,
         &sensor_dev_attr_zone2_auto_point3_temp.dev_attr.attr,
         &sensor_dev_attr_zone2_auto_channels_temp.dev_attr.attr,
-        &sensor_dev_attr_zone3_auto_point1_temp.dev_attr.attr,
-        &sensor_dev_attr_zone3_auto_point2_temp.dev_attr.attr,
-        &sensor_dev_attr_zone3_auto_point3_temp.dev_attr.attr,
-        &sensor_dev_attr_zone3_auto_channels_temp.dev_attr.attr,
         NULL
 };
 
@@ -1605,27 +1636,23 @@ static const struct attribute_group dme1737_group = {
         .attrs = dme1737_attr,
 };
 
-/* The following struct holds misc attributes, which are not available in all
- * chips. Their creation depends on the chip type which is determined during
- * module load. */
-static struct attribute *dme1737_misc_attr[] = {
-        /* Temperatures */
+/* The following struct holds temp offset attributes, which are not available
+ * in all chips. The following chips support them:
+ * DME1737, SCH311x */
+static struct attribute *dme1737_temp_offset_attr[] = {
         &sensor_dev_attr_temp1_offset.dev_attr.attr,
         &sensor_dev_attr_temp2_offset.dev_attr.attr,
         &sensor_dev_attr_temp3_offset.dev_attr.attr,
-        /* Zones */
-        &sensor_dev_attr_zone1_auto_point1_temp_hyst.dev_attr.attr,
-        &sensor_dev_attr_zone2_auto_point1_temp_hyst.dev_attr.attr,
-        &sensor_dev_attr_zone3_auto_point1_temp_hyst.dev_attr.attr,
         NULL
 };
 
-static const struct attribute_group dme1737_misc_group = {
-        .attrs = dme1737_misc_attr,
+static const struct attribute_group dme1737_temp_offset_group = {
+        .attrs = dme1737_temp_offset_attr,
 };
 
-/* The following struct holds VID-related attributes. Their creation
-   depends on the chip type which is determined during module load. */
+/* The following struct holds VID related attributes, which are not available
+ * in all chips. The following chips support them:
+ * DME1737 */
 static struct attribute *dme1737_vid_attr[] = {
         &dev_attr_vrm.attr,
         &dev_attr_cpu0_vid.attr,
@@ -1636,6 +1663,36 @@ static const struct attribute_group dme1737_vid_group = {
         .attrs = dme1737_vid_attr,
 };
 
+/* The following struct holds temp zone 3 related attributes, which are not
+ * available in all chips. The following chips support them:
+ * DME1737, SCH311x, SCH5027 */
+static struct attribute *dme1737_zone3_attr[] = {
+        &sensor_dev_attr_zone3_auto_point1_temp.dev_attr.attr,
+        &sensor_dev_attr_zone3_auto_point2_temp.dev_attr.attr,
+        &sensor_dev_attr_zone3_auto_point3_temp.dev_attr.attr,
+        &sensor_dev_attr_zone3_auto_channels_temp.dev_attr.attr,
+        NULL
+};
+
+static const struct attribute_group dme1737_zone3_group = {
+        .attrs = dme1737_zone3_attr,
+};
+
+
+/* The following struct holds temp zone hysteresis  related attributes, which
+ * are not available in all chips. The following chips support them:
+ * DME1737, SCH311x */
+static struct attribute *dme1737_zone_hyst_attr[] = {
+        &sensor_dev_attr_zone1_auto_point1_temp_hyst.dev_attr.attr,
+        &sensor_dev_attr_zone2_auto_point1_temp_hyst.dev_attr.attr,
+        &sensor_dev_attr_zone3_auto_point1_temp_hyst.dev_attr.attr,
+        NULL
+};
+
+static const struct attribute_group dme1737_zone_hyst_group = {
+        .attrs = dme1737_zone_hyst_attr,
+};
+
 /* The following structs hold the PWM attributes, some of which are optional.
  * Their creation depends on the chip configuration which is determined during
  * module load. */
@@ -1691,10 +1748,10 @@ static const struct attribute_group dme1737_pwm_group[] = {
         { .attrs = dme1737_pwm6_attr },
 };
 
-/* The following struct holds misc PWM attributes, which are not available in
- * all chips. Their creation depends on the chip type which is determined
+/* The following struct holds auto PWM min attributes, which are not available
+ * in all chips. Their creation depends on the chip type which is determined
  * during module load. */
-static struct attribute *dme1737_pwm_misc_attr[] = {
+static struct attribute *dme1737_auto_pwm_min_attr[] = {
         &sensor_dev_attr_pwm1_auto_pwm_min.dev_attr.attr,
         &sensor_dev_attr_pwm2_auto_pwm_min.dev_attr.attr,
         &sensor_dev_attr_pwm3_auto_pwm_min.dev_attr.attr,
@@ -1764,14 +1821,25 @@ static struct attribute *dme1737_zone_chmod_attr[] = {
         &sensor_dev_attr_zone2_auto_point1_temp.dev_attr.attr,
         &sensor_dev_attr_zone2_auto_point2_temp.dev_attr.attr,
         &sensor_dev_attr_zone2_auto_point3_temp.dev_attr.attr,
+        NULL
+};
+
+static const struct attribute_group dme1737_zone_chmod_group = {
+        .attrs = dme1737_zone_chmod_attr,
+};
+
+
+/* The permissions of the following zone 3 attributes are changed to read-
+ * writeable if the chip is *not* locked. Otherwise they stay read-only. */
+static struct attribute *dme1737_zone3_chmod_attr[] = {
         &sensor_dev_attr_zone3_auto_point1_temp.dev_attr.attr,
         &sensor_dev_attr_zone3_auto_point2_temp.dev_attr.attr,
         &sensor_dev_attr_zone3_auto_point3_temp.dev_attr.attr,
         NULL
 };
 
-static const struct attribute_group dme1737_zone_chmod_group = {
-        .attrs = dme1737_zone_chmod_attr,
+static const struct attribute_group dme1737_zone3_chmod_group = {
+        .attrs = dme1737_zone3_chmod_attr,
 };
 
 /* The permissions of the following PWM attributes are changed to read-
@@ -1887,30 +1955,35 @@ static void dme1737_remove_files(struct device *dev)
         int ix;
 
         for (ix = 0; ix < ARRAY_SIZE(dme1737_fan_group); ix++) {
-                if (data->has_fan & (1 << ix)) {
+                if (data->has_features & HAS_FAN(ix)) {
                         sysfs_remove_group(&dev->kobj,
                                            &dme1737_fan_group[ix]);
                 }
         }
 
         for (ix = 0; ix < ARRAY_SIZE(dme1737_pwm_group); ix++) {
-                if (data->has_pwm & (1 << ix)) {
+                if (data->has_features & HAS_PWM(ix)) {
                         sysfs_remove_group(&dev->kobj,
                                            &dme1737_pwm_group[ix]);
-                        if (data->type != sch5027 && ix < 3) {
+                        if ((data->has_features & HAS_PWM_MIN) && ix < 3) {
                                 sysfs_remove_file(&dev->kobj,
-                                                  dme1737_pwm_misc_attr[ix]);
+                                                dme1737_auto_pwm_min_attr[ix]);
                         }
                 }
         }
 
-        if (data->type != sch5027) {
-                sysfs_remove_group(&dev->kobj, &dme1737_misc_group);
+        if (data->has_features & HAS_TEMP_OFFSET) {
+                sysfs_remove_group(&dev->kobj, &dme1737_temp_offset_group);
         }
-        if (data->type == dme1737) {
+        if (data->has_features & HAS_VID) {
                 sysfs_remove_group(&dev->kobj, &dme1737_vid_group);
         }
-
+        if (data->has_features & HAS_ZONE3) {
+                sysfs_remove_group(&dev->kobj, &dme1737_zone3_group);
+        }
+        if (data->has_features & HAS_ZONE_HYST) {
+                sysfs_remove_group(&dev->kobj, &dme1737_zone_hyst_group);
+        }
         sysfs_remove_group(&dev->kobj, &dme1737_group);
 
         if (!data->client) {
@@ -1934,23 +2007,31 @@ static int dme1737_create_files(struct device *dev)
                 goto exit_remove;
         }
 
-        /* Create misc sysfs attributes */
-        if ((data->type != sch5027) &&
+        /* Create chip-dependent sysfs attributes */
+        if ((data->has_features & HAS_TEMP_OFFSET) &&
             (err = sysfs_create_group(&dev->kobj,
-                                      &dme1737_misc_group))) {
+                                      &dme1737_temp_offset_group))) {
                 goto exit_remove;
         }
-
-        /* Create VID-related sysfs attributes */
-        if ((data->type == dme1737) &&
+        if ((data->has_features & HAS_VID) &&
             (err = sysfs_create_group(&dev->kobj,
                                       &dme1737_vid_group))) {
                 goto exit_remove;
         }
+        if ((data->has_features & HAS_ZONE3) &&
+            (err = sysfs_create_group(&dev->kobj,
+                                      &dme1737_zone3_group))) {
+                goto exit_remove;
+        }
+        if ((data->has_features & HAS_ZONE_HYST) &&
+            (err = sysfs_create_group(&dev->kobj,
+                                      &dme1737_zone_hyst_group))) {
+                goto exit_remove;
+        }
 
         /* Create fan sysfs attributes */
         for (ix = 0; ix < ARRAY_SIZE(dme1737_fan_group); ix++) {
-                if (data->has_fan & (1 << ix)) {
+                if (data->has_features & HAS_FAN(ix)) {
                         if ((err = sysfs_create_group(&dev->kobj,
                                                 &dme1737_fan_group[ix]))) {
                                 goto exit_remove;
@@ -1960,14 +2041,14 @@ static int dme1737_create_files(struct device *dev)
 
         /* Create PWM sysfs attributes */
         for (ix = 0; ix < ARRAY_SIZE(dme1737_pwm_group); ix++) {
-                if (data->has_pwm & (1 << ix)) {
+                if (data->has_features & HAS_PWM(ix)) {
                         if ((err = sysfs_create_group(&dev->kobj,
                                                 &dme1737_pwm_group[ix]))) {
                                 goto exit_remove;
                         }
-                        if (data->type != sch5027 && ix < 3 &&
+                        if ((data->has_features & HAS_PWM_MIN) && ix < 3 &&
                             (err = sysfs_create_file(&dev->kobj,
-                                                dme1737_pwm_misc_attr[ix]))) {
+                                        dme1737_auto_pwm_min_attr[ix]))) {
                                 goto exit_remove;
                         }
                 }
@@ -1983,21 +2064,30 @@ static int dme1737_create_files(struct device *dev)
                 dme1737_chmod_group(dev, &dme1737_zone_chmod_group,
                                     S_IRUGO | S_IWUSR);
 
-                /* Change permissions of misc sysfs attributes */
-                if (data->type != sch5027) {
-                        dme1737_chmod_group(dev, &dme1737_misc_group,
+                /* Change permissions of chip-dependent sysfs attributes */
+                if (data->has_features & HAS_TEMP_OFFSET) {
+                        dme1737_chmod_group(dev, &dme1737_temp_offset_group,
+                                            S_IRUGO | S_IWUSR);
+                }
+                if (data->has_features & HAS_ZONE3) {
+                        dme1737_chmod_group(dev, &dme1737_zone3_chmod_group,
+                                            S_IRUGO | S_IWUSR);
+                }
+                if (data->has_features & HAS_ZONE_HYST) {
+                        dme1737_chmod_group(dev, &dme1737_zone_hyst_group,
                                             S_IRUGO | S_IWUSR);
                 }
 
                 /* Change permissions of PWM sysfs attributes */
                 for (ix = 0; ix < ARRAY_SIZE(dme1737_pwm_chmod_group); ix++) {
-                        if (data->has_pwm & (1 << ix)) {
+                        if (data->has_features & HAS_PWM(ix)) {
                                 dme1737_chmod_group(dev,
                                                 &dme1737_pwm_chmod_group[ix],
                                                 S_IRUGO | S_IWUSR);
-                                if (data->type != sch5027 && ix < 3) {
+                                if ((data->has_features & HAS_PWM_MIN) &&
+                                    ix < 3) {
                                         dme1737_chmod_file(dev,
-                                                dme1737_pwm_misc_attr[ix],
+                                                dme1737_auto_pwm_min_attr[ix],
                                                 S_IRUGO | S_IWUSR);
                                 }
                         }
@@ -2005,7 +2095,7 @@ static int dme1737_create_files(struct device *dev)
 
                 /* Change permissions of pwm[1-3] if in manual mode */
                 for (ix = 0; ix < 3; ix++) {
-                        if ((data->has_pwm & (1 << ix)) &&
+                        if ((data->has_features & HAS_PWM(ix)) &&
                             (PWM_EN_FROM_REG(data->pwm_config[ix]) == 1)) {
                                 dme1737_chmod_file(dev,
                                                 dme1737_pwm_chmod_attr[ix],
@@ -2052,20 +2142,20 @@ static int dme1737_init_device(struct device *dev)
                 return -EFAULT;
         }
 
-        /* Determine which optional fan and pwm features are enabled/present */
+        /* Determine which optional fan and pwm features are enabled (only
+         * valid for I2C devices) */
         if (client) {   /* I2C chip */
                 data->config2 = dme1737_read(data, DME1737_REG_CONFIG2);
                 /* Check if optional fan3 input is enabled */
                 if (data->config2 & 0x04) {
-                        data->has_fan |= (1 << 2);
+                        data->has_features |= HAS_FAN(2);
                 }
 
                 /* Fan4 and pwm3 are only available if the client's I2C address
                  * is the default 0x2e. Otherwise the I/Os associated with
                  * these functions are used for addr enable/select. */
                 if (client->addr == 0x2e) {
-                        data->has_fan |= (1 << 3);
-                        data->has_pwm |= (1 << 2);
+                        data->has_features |= HAS_FAN(3) | HAS_PWM(2);
                 }
 
                 /* Determine which of the optional fan[5-6] and pwm[5-6]
@@ -2077,26 +2167,40 @@ static int dme1737_init_device(struct device *dev)
                         dev_warn(dev, "Failed to query Super-IO for optional "
                                  "features.\n");
                 }
-        } else {   /* ISA chip */
-                /* Fan3 and pwm3 are always available. Fan[4-5] and pwm[5-6]
-                 * don't exist in the ISA chip. */
-                data->has_fan |= (1 << 2);
-                data->has_pwm |= (1 << 2);
         }
 
-        /* Fan1, fan2, pwm1, and pwm2 are always present */
-        data->has_fan |= 0x03;
-        data->has_pwm |= 0x03;
+        /* Fan[1-2] and pwm[1-2] are present in all chips */
+        data->has_features |= HAS_FAN(0) | HAS_FAN(1) | HAS_PWM(0) | HAS_PWM(1);
+
+        /* Chip-dependent features */
+        switch (data->type) {
+        case dme1737:
+                data->has_features |= HAS_TEMP_OFFSET | HAS_VID | HAS_ZONE3 |
+                        HAS_ZONE_HYST | HAS_PWM_MIN;
+                break;
+        case sch311x:
+                data->has_features |= HAS_TEMP_OFFSET | HAS_ZONE3 |
+                        HAS_ZONE_HYST | HAS_PWM_MIN | HAS_FAN(2) | HAS_PWM(2);
+                break;
+        case sch5027:
+                data->has_features |= HAS_ZONE3;
+                break;
+        case sch5127:
+                data->has_features |= HAS_FAN(2) | HAS_PWM(2);
+                break;
+        default:
+                break;
+        }
 
         dev_info(dev, "Optional features: pwm3=%s, pwm5=%s, pwm6=%s, "
                  "fan3=%s, fan4=%s, fan5=%s, fan6=%s.\n",
-                 (data->has_pwm & (1 << 2)) ? "yes" : "no",
-                 (data->has_pwm & (1 << 4)) ? "yes" : "no",
-                 (data->has_pwm & (1 << 5)) ? "yes" : "no",
-                 (data->has_fan & (1 << 2)) ? "yes" : "no",
-                 (data->has_fan & (1 << 3)) ? "yes" : "no",
-                 (data->has_fan & (1 << 4)) ? "yes" : "no",
-                 (data->has_fan & (1 << 5)) ? "yes" : "no");
+                 (data->has_features & HAS_PWM(2)) ? "yes" : "no",
+                 (data->has_features & HAS_PWM(4)) ? "yes" : "no",
+                 (data->has_features & HAS_PWM(5)) ? "yes" : "no",
+                 (data->has_features & HAS_FAN(2)) ? "yes" : "no",
+                 (data->has_features & HAS_FAN(3)) ? "yes" : "no",
+                 (data->has_features & HAS_FAN(4)) ? "yes" : "no",
+                 (data->has_features & HAS_FAN(5)) ? "yes" : "no");
 
         reg = dme1737_read(data, DME1737_REG_TACH_PWM);
         /* Inform if fan-to-pwm mapping differs from the default */
@@ -2122,7 +2226,7 @@ static int dme1737_init_device(struct device *dev)
                 for (ix = 0; ix < 3; ix++) {
                         data->pwm_config[ix] = dme1737_read(data,
                                                 DME1737_REG_PWM_CONFIG(ix));
-                        if ((data->has_pwm & (1 << ix)) &&
+                        if ((data->has_features & HAS_PWM(ix)) &&
                             (PWM_EN_FROM_REG(data->pwm_config[ix]) == -1)) {
                                 dev_info(dev, "Switching pwm%d to "
                                          "manual mode.\n", ix + 1);
@@ -2142,7 +2246,7 @@ static int dme1737_init_device(struct device *dev)
         data->pwm_acz[2] = 4;   /* pwm3 -> zone3 */
 
         /* Set VRM */
-        if (data->type == dme1737) {
+        if (data->has_features & HAS_VID) {
                 data->vrm = vid_which_vrm();
         }
 
@@ -2163,10 +2267,10 @@ static int dme1737_i2c_get_features(int sio_cip, struct dme1737_data *data)
         dme1737_sio_enter(sio_cip);
 
         /* Check device ID
-         * The DME1737 can return either 0x78 or 0x77 as its device ID.
-         * The SCH5027 returns 0x89 as its device ID. */
+         * We currently know about two kinds of DME1737 and SCH5027. */
         reg = force_id ? force_id : dme1737_sio_inb(sio_cip, 0x20);
-        if (!(reg == 0x77 || reg == 0x78 || reg == 0x89)) {
+        if (!(reg == DME1737_ID_1 || reg == DME1737_ID_2 ||
+              reg == SCH5027_ID)) {
                 err = -ENODEV;
                 goto exit;
         }
@@ -2185,16 +2289,16 @@ static int dme1737_i2c_get_features(int sio_cip, struct dme1737_data *data)
          * are enabled and available. Bits [3:2] of registers 0x43-0x46 are set
          * to '10' if the respective feature is enabled. */
         if ((inb(addr + 0x43) & 0x0c) == 0x08) { /* fan6 */
-                data->has_fan |= (1 << 5);
+                data->has_features |= HAS_FAN(5);
         }
         if ((inb(addr + 0x44) & 0x0c) == 0x08) { /* pwm6 */
-                data->has_pwm |= (1 << 5);
+                data->has_features |= HAS_PWM(5);
         }
         if ((inb(addr + 0x45) & 0x0c) == 0x08) { /* fan5 */
-                data->has_fan |= (1 << 4);
+                data->has_features |= HAS_FAN(4);
         }
         if ((inb(addr + 0x46) & 0x0c) == 0x08) { /* pwm5 */
-                data->has_pwm |= (1 << 4);
+                data->has_features |= HAS_PWM(4);
         }
 
 exit:
@@ -2222,7 +2326,6 @@ static int dme1737_i2c_detect(struct i2c_client *client,
         if (company == DME1737_COMPANY_SMSC &&
             verstep == SCH5027_VERSTEP) {
                 name = "sch5027";
-
         } else if (company == DME1737_COMPANY_SMSC &&
                    (verstep & DME1737_VERSTEP_MASK) == DME1737_VERSTEP) {
                 name = "dme1737";
@@ -2329,10 +2432,10 @@ static int __init dme1737_isa_detect(int sio_cip, unsigned short *addr)
         dme1737_sio_enter(sio_cip);
 
         /* Check device ID
-         * We currently know about SCH3112 (0x7c), SCH3114 (0x7d), and
-         * SCH3116 (0x7f). */
+         * We currently know about SCH3112, SCH3114, SCH3116, and SCH5127 */
         reg = force_id ? force_id : dme1737_sio_inb(sio_cip, 0x20);
-        if (!(reg == 0x7c || reg == 0x7d || reg == 0x7f)) {
+        if (!(reg == SCH3112_ID || reg == SCH3114_ID || reg == SCH3116_ID ||
+              reg == SCH5127_ID)) {
                 err = -ENODEV;
                 goto exit;
         }
@@ -2424,23 +2527,42 @@ static int __devinit dme1737_isa_probe(struct platform_device *pdev)
         platform_set_drvdata(pdev, data);
 
         /* Skip chip detection if module is loaded with force_id parameter */
-        if (!force_id) {
+        switch (force_id) {
+        case SCH3112_ID:
+        case SCH3114_ID:
+        case SCH3116_ID:
+                data->type = sch311x;
+                break;
+        case SCH5127_ID:
+                data->type = sch5127;
+                break;
+        default:
                 company = dme1737_read(data, DME1737_REG_COMPANY);
                 device = dme1737_read(data, DME1737_REG_DEVICE);
 
-                if (!((company == DME1737_COMPANY_SMSC) &&
-                      (device == SCH311X_DEVICE))) {
+                if ((company == DME1737_COMPANY_SMSC) &&
+                    (device == SCH311X_DEVICE)) {
+                        data->type = sch311x;
+                } else if ((company == DME1737_COMPANY_SMSC) &&
+                           (device == SCH5127_DEVICE)) {
+                        data->type = sch5127;
+                } else {
                         err = -ENODEV;
                         goto exit_kfree;
                 }
         }
-        data->type = sch311x;
 
-        /* Fill in the remaining client fields and initialize the mutex */
-        data->name = "sch311x";
+        if (data->type == sch5127) {
+                data->name = "sch5127";
+        } else {
+                data->name = "sch311x";
+        }
+
+        /* Initialize the mutex */
         mutex_init(&data->update_lock);
 
-        dev_info(dev, "Found a SCH311x chip at 0x%04x\n", data->addr);
+        dev_info(dev, "Found a %s chip at 0x%04x\n",
+                 data->type == sch5127 ? "SCH5127" : "SCH311x", data->addr);
 
         /* Initialize the chip */
         if ((err = dme1737_init_device(dev))) {
diff --git a/drivers/hwmon/emc1403.c b/drivers/hwmon/emc1403.c
new file mode 100644
index 000000000000..0e4b5642638d
--- /dev/null
+++ b/drivers/hwmon/emc1403.c
@@ -0,0 +1,344 @@
+/*
+ * emc1403.c - SMSC Thermal Driver
+ *
+ * Copyright (C) 2008 Intel Corp
+ *
+ *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * 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.
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ * TODO
+ *      -       cache alarm and critical limit registers
+ *      -       add emc1404 support
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
+#include <linux/err.h>
+#include <linux/sysfs.h>
+#include <linux/mutex.h>
+
+#define THERMAL_PID_REG         0xfd
+#define THERMAL_SMSC_ID_REG     0xfe
+#define THERMAL_REVISION_REG    0xff
+
+struct thermal_data {
+        struct device *hwmon_dev;
+        struct mutex mutex;
+        /* Cache the hyst value so we don't keep re-reading it. In theory
+           we could cache it forever as nobody else should be writing it. */
+        u8 cached_hyst;
+        unsigned long hyst_valid;
+};
+
+static ssize_t show_temp(struct device *dev,
+                        struct device_attribute *attr, char *buf)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct sensor_device_attribute *sda = to_sensor_dev_attr(attr);
+        int retval = i2c_smbus_read_byte_data(client, sda->index);
+
+        if (retval < 0)
+                return retval;
+        return sprintf(buf, "%d000\n", retval);
+}
+
+static ssize_t show_bit(struct device *dev,
+                        struct device_attribute *attr, char *buf)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct sensor_device_attribute_2 *sda = to_sensor_dev_attr_2(attr);
+        int retval = i2c_smbus_read_byte_data(client, sda->nr);
+
+        if (retval < 0)
+                return retval;
+        retval &= sda->index;
+        return sprintf(buf, "%d\n", retval ? 1 : 0);
+}
+
+static ssize_t store_temp(struct device *dev,
+                struct device_attribute *attr, const char *buf, size_t count)
+{
+        struct sensor_device_attribute *sda = to_sensor_dev_attr(attr);
+        struct i2c_client *client = to_i2c_client(dev);
+        unsigned long val;
+        int retval;
+
+        if (strict_strtoul(buf, 10, &val))
+                return -EINVAL;
+        retval = i2c_smbus_write_byte_data(client, sda->index,
+                                        DIV_ROUND_CLOSEST(val, 1000));
+        if (retval < 0)
+                return retval;
+        return count;
+}
+
+static ssize_t show_hyst(struct device *dev,
+                        struct device_attribute *attr, char *buf)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct thermal_data *data = i2c_get_clientdata(client);
+        struct sensor_device_attribute *sda = to_sensor_dev_attr(attr);
+        int retval;
+        int hyst;
+
+        retval = i2c_smbus_read_byte_data(client, sda->index);
+        if (retval < 0)
+                return retval;
+
+        if (time_after(jiffies, data->hyst_valid)) {
+                hyst = i2c_smbus_read_byte_data(client, 0x21);
+                if (hyst < 0)
+                        return retval;
+                data->cached_hyst = hyst;
+                data->hyst_valid = jiffies + HZ;
+        }
+        return sprintf(buf, "%d000\n", retval - data->cached_hyst);
+}
+
+static ssize_t store_hyst(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 *sda = to_sensor_dev_attr(attr);
+        int retval;
+        int hyst;
+        unsigned long val;
+
+        if (strict_strtoul(buf, 10, &val))
+                return -EINVAL;
+
+        mutex_lock(&data->mutex);
+        retval = i2c_smbus_read_byte_data(client, sda->index);
+        if (retval < 0)
+                goto fail;
+
+        hyst = val - retval * 1000;
+        hyst = DIV_ROUND_CLOSEST(hyst, 1000);
+        if (hyst < 0 || hyst > 255) {
+                retval = -ERANGE;
+                goto fail;
+        }
+
+        retval = i2c_smbus_write_byte_data(client, 0x21, hyst);
+        if (retval == 0) {
+                retval = count;
+                data->cached_hyst = hyst;
+                data->hyst_valid = jiffies + HZ;
+        }
+fail:
+        mutex_unlock(&data->mutex);
+        return retval;
+}
+
+/*
+ *      Sensors. We pass the actual i2c register to the methods.
+ */
+
+static SENSOR_DEVICE_ATTR(temp1_min, S_IRUGO | S_IWUSR,
+        show_temp, store_temp, 0x06);
+static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR,
+        show_temp, store_temp, 0x05);
+static SENSOR_DEVICE_ATTR(temp1_crit, S_IRUGO | S_IWUSR,
+        show_temp, store_temp, 0x20);
+static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0x00);
+static SENSOR_DEVICE_ATTR_2(temp1_min_alarm, S_IRUGO,
+        show_bit, NULL, 0x36, 0x01);
+static SENSOR_DEVICE_ATTR_2(temp1_max_alarm, S_IRUGO,
+        show_bit, NULL, 0x35, 0x01);
+static SENSOR_DEVICE_ATTR_2(temp1_crit_alarm, S_IRUGO,
+        show_bit, NULL, 0x37, 0x01);
+static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IRUGO | S_IWUSR,
+        show_hyst, store_hyst, 0x20);
+
+static SENSOR_DEVICE_ATTR(temp2_min, S_IRUGO | S_IWUSR,
+        show_temp, store_temp, 0x08);
+static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO | S_IWUSR,
+        show_temp, store_temp, 0x07);
+static SENSOR_DEVICE_ATTR(temp2_crit, S_IRUGO | S_IWUSR,
+        show_temp, store_temp, 0x19);
+static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 0x01);
+static SENSOR_DEVICE_ATTR_2(temp2_min_alarm, S_IRUGO,
+        show_bit, NULL, 0x36, 0x02);
+static SENSOR_DEVICE_ATTR_2(temp2_max_alarm, S_IRUGO,
+        show_bit, NULL, 0x35, 0x02);
+static SENSOR_DEVICE_ATTR_2(temp2_crit_alarm, S_IRUGO,
+        show_bit, NULL, 0x37, 0x02);
+static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IRUGO | S_IWUSR,
+        show_hyst, store_hyst, 0x19);
+
+static SENSOR_DEVICE_ATTR(temp3_min, S_IRUGO | S_IWUSR,
+        show_temp, store_temp, 0x16);
+static SENSOR_DEVICE_ATTR(temp3_max, S_IRUGO | S_IWUSR,
+        show_temp, store_temp, 0x15);
+static SENSOR_DEVICE_ATTR(temp3_crit, S_IRUGO | S_IWUSR,
+        show_temp, store_temp, 0x1A);
+static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 0x23);
+static SENSOR_DEVICE_ATTR_2(temp3_min_alarm, S_IRUGO,
+        show_bit, NULL, 0x36, 0x04);
+static SENSOR_DEVICE_ATTR_2(temp3_max_alarm, S_IRUGO,
+        show_bit, NULL, 0x35, 0x04);
+static SENSOR_DEVICE_ATTR_2(temp3_crit_alarm, S_IRUGO,
+        show_bit, NULL, 0x37, 0x04);
+static SENSOR_DEVICE_ATTR(temp3_crit_hyst, S_IRUGO | S_IWUSR,
+        show_hyst, store_hyst, 0x1A);
+
+static struct attribute *mid_att_thermal[] = {
+        &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_input.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_crit_hyst.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_input.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_crit_hyst.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_input.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_crit_hyst.dev_attr.attr,
+        NULL
+};
+
+static const struct attribute_group m_thermal_gr = {
+        .attrs = mid_att_thermal
+};
+
+static int emc1403_detect(struct i2c_client *client,
+                        struct i2c_board_info *info)
+{
+        int id;
+        /* Check if thermal chip is SMSC and EMC1403 */
+
+        id = i2c_smbus_read_byte_data(client, THERMAL_SMSC_ID_REG);
+        if (id != 0x5d)
+                return -ENODEV;
+
+        /* Note: 0x25 is the 1404 which is very similar and this
+           driver could be extended */
+        id = i2c_smbus_read_byte_data(client, THERMAL_PID_REG);
+        if (id != 0x21)
+                return -ENODEV;
+
+        id = i2c_smbus_read_byte_data(client, THERMAL_REVISION_REG);
+        if (id != 0x01)
+                return -ENODEV;
+
+        strlcpy(info->type, "emc1403", I2C_NAME_SIZE);
+        return 0;
+}
+
+static int emc1403_probe(struct i2c_client *client,
+                        const struct i2c_device_id *id)
+{
+        int res;
+        struct thermal_data *data;
+
+        data = kzalloc(sizeof(struct thermal_data), GFP_KERNEL);
+        if (data == NULL) {
+                dev_warn(&client->dev, "out of memory");
+                return -ENOMEM;
+        }
+
+        i2c_set_clientdata(client, data);
+        mutex_init(&data->mutex);
+        data->hyst_valid = jiffies - 1;         /* Expired */
+
+        res = sysfs_create_group(&client->dev.kobj, &m_thermal_gr);
+        if (res) {
+                dev_warn(&client->dev, "create group failed\n");
+                hwmon_device_unregister(data->hwmon_dev);
+                goto thermal_error1;
+        }
+        data->hwmon_dev = hwmon_device_register(&client->dev);
+        if (IS_ERR(data->hwmon_dev)) {
+                res = PTR_ERR(data->hwmon_dev);
+                dev_warn(&client->dev, "register hwmon dev failed\n");
+                goto thermal_error2;
+        }
+        dev_info(&client->dev, "EMC1403 Thermal chip found\n");
+        return res;
+
+thermal_error2:
+        sysfs_remove_group(&client->dev.kobj, &m_thermal_gr);
+thermal_error1:
+        kfree(data);
+        return res;
+}
+
+static int emc1403_remove(struct i2c_client *client)
+{
+        struct thermal_data *data = i2c_get_clientdata(client);
+
+        hwmon_device_unregister(data->hwmon_dev);
+        sysfs_remove_group(&client->dev.kobj, &m_thermal_gr);
+        kfree(data);
+        return 0;
+}
+
+static const unsigned short emc1403_address_list[] = {
+        0x18, 0x2a, 0x4c, 0x4d, I2C_CLIENT_END
+};
+
+static const struct i2c_device_id emc1403_idtable[] = {
+        { "emc1403", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, emc1403_idtable);
+
+static struct i2c_driver sensor_emc1403 = {
+        .class = I2C_CLASS_HWMON,
+        .driver = {
+                .name = "emc1403",
+        },
+        .detect = emc1403_detect,
+        .probe = emc1403_probe,
+        .remove = emc1403_remove,
+        .id_table = emc1403_idtable,
+        .address_list = emc1403_address_list,
+};
+
+static int __init sensor_emc1403_init(void)
+{
+        return i2c_add_driver(&sensor_emc1403);
+}
+
+static void  __exit sensor_emc1403_exit(void)
+{
+        i2c_del_driver(&sensor_emc1403);
+}
+
+module_init(sensor_emc1403_init);
+module_exit(sensor_emc1403_exit);
+
+MODULE_AUTHOR("Kalhan Trisal <kalhan.trisal@intel.com");
+MODULE_DESCRIPTION("emc1403 Thermal Driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/hwmon/f71882fg.c b/drivers/hwmon/f71882fg.c
index a95fa4256caa..537841ef44b9 100644
--- a/drivers/hwmon/f71882fg.c
+++ b/drivers/hwmon/f71882fg.c
@@ -856,21 +856,19 @@ static inline int superio_inb(int base, int reg)
 static int superio_inw(int base, int reg)
 {
         int val;
-        outb(reg++, base);
-        val = inb(base + 1) << 8;
-        outb(reg, base);
-        val |= inb(base + 1);
+        val  = superio_inb(base, reg) << 8;
+        val |= superio_inb(base, reg + 1);
         return val;
 }
 
 static inline void superio_enter(int base)
 {
         /* according to the datasheet the key must be send twice! */
-        outb( SIO_UNLOCK_KEY, base);
-        outb( SIO_UNLOCK_KEY, base);
+        outb(SIO_UNLOCK_KEY, base);
+        outb(SIO_UNLOCK_KEY, base);
 }
 
-static inline void superio_select( int base, int ld)
+static inline void superio_select(int base, int ld)
 {
         outb(SIO_REG_LDSEL, base);
         outb(ld, base + 1);
@@ -905,10 +903,8 @@ static u16 f71882fg_read16(struct f71882fg_data *data, u8 reg)
 {
         u16 val;
 
-        outb(reg++, data->addr + ADDR_REG_OFFSET);
-        val = inb(data->addr + DATA_REG_OFFSET) << 8;
-        outb(reg, data->addr + ADDR_REG_OFFSET);
-        val |= inb(data->addr + DATA_REG_OFFSET);
+        val  = f71882fg_read8(data, reg) << 8;
+        val |= f71882fg_read8(data, reg + 1);
 
         return val;
 }
@@ -921,10 +917,8 @@ static void f71882fg_write8(struct f71882fg_data *data, u8 reg, u8 val)
 
 static void f71882fg_write16(struct f71882fg_data *data, u8 reg, u16 val)
 {
-        outb(reg++, data->addr + ADDR_REG_OFFSET);
-        outb(val >> 8, data->addr + DATA_REG_OFFSET);
-        outb(reg, data->addr + ADDR_REG_OFFSET);
-        outb(val & 255, data->addr + DATA_REG_OFFSET);
+        f71882fg_write8(data, reg,     val >> 8);
+        f71882fg_write8(data, reg + 1, val & 0xff);
 }
 
 static u16 f71882fg_read_temp(struct f71882fg_data *data, int nr)
@@ -945,7 +939,7 @@ static struct f71882fg_data *f71882fg_update_device(struct device *dev)
         mutex_lock(&data->update_lock);
 
         /* Update once every 60 seconds */
-        if ( time_after(jiffies, data->last_limits + 60 * HZ ) ||
+        if (time_after(jiffies, data->last_limits + 60 * HZ) ||
                         !data->valid) {
                 if (data->type == f71882fg || data->type == f71889fg) {
                         data->in1_max =
@@ -1127,8 +1121,12 @@ static ssize_t store_fan_full_speed(struct device *dev,
                                     const char *buf, size_t count)
 {
         struct f71882fg_data *data = dev_get_drvdata(dev);
-        int nr = to_sensor_dev_attr_2(devattr)->index;
-        long val = simple_strtol(buf, NULL, 10);
+        int err, nr = to_sensor_dev_attr_2(devattr)->index;
+        long val;
+
+        err = strict_strtol(buf, 10, &val);
+        if (err)
+                return err;
 
         val = SENSORS_LIMIT(val, 23, 1500000);
         val = fan_to_reg(val);
@@ -1157,8 +1155,12 @@ static ssize_t store_fan_beep(struct device *dev, struct device_attribute
         *devattr, const char *buf, size_t count)
 {
         struct f71882fg_data *data = dev_get_drvdata(dev);
-        int nr = to_sensor_dev_attr_2(devattr)->index;
-        unsigned long val = simple_strtoul(buf, NULL, 10);
+        int err, nr = to_sensor_dev_attr_2(devattr)->index;
+        unsigned long val;
+
+        err = strict_strtoul(buf, 10, &val);
+        if (err)
+                return err;
 
         mutex_lock(&data->update_lock);
         data->fan_beep = f71882fg_read8(data, F71882FG_REG_FAN_BEEP);
@@ -1206,7 +1208,14 @@ static ssize_t store_in_max(struct device *dev, struct device_attribute
         *devattr, const char *buf, size_t count)
 {
         struct f71882fg_data *data = dev_get_drvdata(dev);
-        long val = simple_strtol(buf, NULL, 10) / 8;
+        int err;
+        long val;
+
+        err = strict_strtol(buf, 10, &val);
+        if (err)
+                return err;
+
+        val /= 8;
         val = SENSORS_LIMIT(val, 0, 255);
 
         mutex_lock(&data->update_lock);
@@ -1233,8 +1242,12 @@ static ssize_t store_in_beep(struct device *dev, struct device_attribute
         *devattr, const char *buf, size_t count)
 {
         struct f71882fg_data *data = dev_get_drvdata(dev);
-        int nr = to_sensor_dev_attr_2(devattr)->index;
-        unsigned long val = simple_strtoul(buf, NULL, 10);
+        int err, nr = to_sensor_dev_attr_2(devattr)->index;
+        unsigned long val;
+
+        err = strict_strtoul(buf, 10, &val);
+        if (err)
+                return err;
 
         mutex_lock(&data->update_lock);
         data->in_beep = f71882fg_read8(data, F71882FG_REG_IN_BEEP);
@@ -1299,8 +1312,14 @@ static ssize_t store_temp_max(struct device *dev, struct device_attribute
         *devattr, const char *buf, size_t count)
 {
         struct f71882fg_data *data = dev_get_drvdata(dev);
-        int nr = to_sensor_dev_attr_2(devattr)->index;
-        long val = simple_strtol(buf, NULL, 10) / 1000;
+        int err, nr = to_sensor_dev_attr_2(devattr)->index;
+        long val;
+
+        err = strict_strtol(buf, 10, &val);
+        if (err)
+                return err;
+
+        val /= 1000;
         val = SENSORS_LIMIT(val, 0, 255);
 
         mutex_lock(&data->update_lock);
@@ -1333,10 +1352,16 @@ static ssize_t store_temp_max_hyst(struct device *dev, struct device_attribute
         *devattr, const char *buf, size_t count)
 {
         struct f71882fg_data *data = dev_get_drvdata(dev);
-        int nr = to_sensor_dev_attr_2(devattr)->index;
-        long val = simple_strtol(buf, NULL, 10) / 1000;
+        int err, nr = to_sensor_dev_attr_2(devattr)->index;
         ssize_t ret = count;
         u8 reg;
+        long val;
+
+        err = strict_strtol(buf, 10, &val);
+        if (err)
+                return err;
+
+        val /= 1000;
 
         mutex_lock(&data->update_lock);
 
@@ -1372,8 +1397,14 @@ static ssize_t store_temp_crit(struct device *dev, struct device_attribute
         *devattr, const char *buf, size_t count)
 {
         struct f71882fg_data *data = dev_get_drvdata(dev);
-        int nr = to_sensor_dev_attr_2(devattr)->index;
-        long val = simple_strtol(buf, NULL, 10) / 1000;
+        int err, nr = to_sensor_dev_attr_2(devattr)->index;
+        long val;
+
+        err = strict_strtol(buf, 10, &val);
+        if (err)
+                return err;
+
+        val /= 1000;
         val = SENSORS_LIMIT(val, 0, 255);
 
         mutex_lock(&data->update_lock);
@@ -1427,8 +1458,12 @@ static ssize_t store_temp_beep(struct device *dev, struct device_attribute
         *devattr, const char *buf, size_t count)
 {
         struct f71882fg_data *data = dev_get_drvdata(dev);
-        int nr = to_sensor_dev_attr_2(devattr)->index;
-        unsigned long val = simple_strtoul(buf, NULL, 10);
+        int err, nr = to_sensor_dev_attr_2(devattr)->index;
+        unsigned long val;
+
+        err = strict_strtoul(buf, 10, &val);
+        if (err)
+                return err;
 
         mutex_lock(&data->update_lock);
         data->temp_beep = f71882fg_read8(data, F71882FG_REG_TEMP_BEEP);
@@ -1490,8 +1525,13 @@ static ssize_t store_pwm(struct device *dev,
                          size_t count)
 {
         struct f71882fg_data *data = dev_get_drvdata(dev);
-        int nr = to_sensor_dev_attr_2(devattr)->index;
-        long val = simple_strtol(buf, NULL, 10);
+        int err, nr = to_sensor_dev_attr_2(devattr)->index;
+        long val;
+
+        err = strict_strtol(buf, 10, &val);
+        if (err)
+                return err;
+
         val = SENSORS_LIMIT(val, 0, 255);
 
         mutex_lock(&data->update_lock);
@@ -1551,8 +1591,12 @@ static ssize_t store_pwm_enable(struct device *dev, struct device_attribute
                                 *devattr, const char *buf, size_t count)
 {
         struct f71882fg_data *data = dev_get_drvdata(dev);
-        int nr = to_sensor_dev_attr_2(devattr)->index;
-        long val = simple_strtol(buf, NULL, 10);
+        int err, nr = to_sensor_dev_attr_2(devattr)->index;
+        long val;
+
+        err = strict_strtol(buf, 10, &val);
+        if (err)
+                return err;
 
         /* Special case for F8000 pwm channel 3 which only does auto mode */
         if (data->type == f8000 && nr == 2 && val != 2)
@@ -1626,9 +1670,14 @@ static ssize_t store_pwm_auto_point_pwm(struct device *dev,
                                         const char *buf, size_t count)
 {
         struct f71882fg_data *data = dev_get_drvdata(dev);
-        int pwm = to_sensor_dev_attr_2(devattr)->index;
+        int err, pwm = to_sensor_dev_attr_2(devattr)->index;
         int point = to_sensor_dev_attr_2(devattr)->nr;
-        long val = simple_strtol(buf, NULL, 10);
+        long val;
+
+        err = strict_strtol(buf, 10, &val);
+        if (err)
+                return err;
+
         val = SENSORS_LIMIT(val, 0, 255);
 
         mutex_lock(&data->update_lock);
@@ -1674,10 +1723,16 @@ static ssize_t store_pwm_auto_point_temp_hyst(struct device *dev,
                                               const char *buf, size_t count)
 {
         struct f71882fg_data *data = dev_get_drvdata(dev);
-        int nr = to_sensor_dev_attr_2(devattr)->index;
+        int err, nr = to_sensor_dev_attr_2(devattr)->index;
         int point = to_sensor_dev_attr_2(devattr)->nr;
-        long val = simple_strtol(buf, NULL, 10) / 1000;
         u8 reg;
+        long val;
+
+        err = strict_strtol(buf, 10, &val);
+        if (err)
+                return err;
+
+        val /= 1000;
 
         mutex_lock(&data->update_lock);
         data->pwm_auto_point_temp[nr][point] =
@@ -1716,8 +1771,12 @@ static ssize_t store_pwm_interpolate(struct device *dev,
                                      const char *buf, size_t count)
 {
         struct f71882fg_data *data = dev_get_drvdata(dev);
-        int nr = to_sensor_dev_attr_2(devattr)->index;
-        unsigned long val = simple_strtoul(buf, NULL, 10);
+        int err, nr = to_sensor_dev_attr_2(devattr)->index;
+        unsigned long val;
+
+        err = strict_strtoul(buf, 10, &val);
+        if (err)
+                return err;
 
         mutex_lock(&data->update_lock);
         data->pwm_auto_point_mapping[nr] =
@@ -1752,8 +1811,12 @@ static ssize_t store_pwm_auto_point_channel(struct device *dev,
                                             const char *buf, size_t count)
 {
         struct f71882fg_data *data = dev_get_drvdata(dev);
-        int nr = to_sensor_dev_attr_2(devattr)->index;
-        long val = simple_strtol(buf, NULL, 10);
+        int err, nr = to_sensor_dev_attr_2(devattr)->index;
+        long val;
+
+        err = strict_strtol(buf, 10, &val);
+        if (err)
+                return err;
 
         switch (val) {
         case 1:
@@ -1798,9 +1861,15 @@ static ssize_t store_pwm_auto_point_temp(struct device *dev,
                                          const char *buf, size_t count)
 {
         struct f71882fg_data *data = dev_get_drvdata(dev);
-        int pwm = to_sensor_dev_attr_2(devattr)->index;
+        int err, pwm = to_sensor_dev_attr_2(devattr)->index;
         int point = to_sensor_dev_attr_2(devattr)->nr;
-        long val = simple_strtol(buf, NULL, 10) / 1000;
+        long val;
+
+        err = strict_strtol(buf, 10, &val);
+        if (err)
+                return err;
+
+        val /= 1000;
 
         if (data->type == f71889fg)
                 val = SENSORS_LIMIT(val, -128, 127);
@@ -2109,6 +2178,13 @@ static int __init f71882fg_find(int sioaddr, unsigned short *address,
         int err = -ENODEV;
         u16 devid;
 
+        /* Don't step on other drivers' I/O space by accident */
+        if (!request_region(sioaddr, 2, DRVNAME)) {
+                printk(KERN_ERR DRVNAME ": I/O address 0x%04x already in use\n",
+                                (int)sioaddr);
+                return -EBUSY;
+        }
+
         superio_enter(sioaddr);
 
         devid = superio_inw(sioaddr, SIO_REG_MANID);
@@ -2151,8 +2227,7 @@ static int __init f71882fg_find(int sioaddr, unsigned short *address,
         }
 
         *address = superio_inw(sioaddr, SIO_REG_ADDR);
-        if (*address == 0)
-        {
+        if (*address == 0) {
                 printk(KERN_WARNING DRVNAME ": Base address not set\n");
                 goto exit;
         }
@@ -2164,6 +2239,7 @@ static int __init f71882fg_find(int sioaddr, unsigned short *address,
                 (int)superio_inb(sioaddr, SIO_REG_DEVREV));
 exit:
         superio_exit(sioaddr);
+        release_region(sioaddr, 2);
         return err;
 }
 
diff --git a/drivers/hwmon/lm63.c b/drivers/hwmon/lm63.c
index bf81aff7051d..776aeb3019d2 100644
--- a/drivers/hwmon/lm63.c
+++ b/drivers/hwmon/lm63.c
@@ -53,7 +53,7 @@
  * Address is fully defined internally and cannot be changed.
  */
 
-static const unsigned short normal_i2c[] = { 0x4c, I2C_CLIENT_END };
+static const unsigned short normal_i2c[] = { 0x18, 0x4c, 0x4e, I2C_CLIENT_END };
 
 /*
  * The LM63 registers
@@ -131,12 +131,15 @@ static struct lm63_data *lm63_update_device(struct device *dev);
 static int lm63_detect(struct i2c_client *client, struct i2c_board_info *info);
 static void lm63_init_client(struct i2c_client *client);
 
+enum chips { lm63, lm64 };
+
 /*
  * Driver data (common to all clients)
  */
 
 static const struct i2c_device_id lm63_id[] = {
-        { "lm63", 0 },
+        { "lm63", lm63 },
+        { "lm64", lm64 },
         { }
 };
 MODULE_DEVICE_TABLE(i2c, lm63_id);
@@ -422,6 +425,7 @@ static int lm63_detect(struct i2c_client *new_client,
         struct i2c_adapter *adapter = new_client->adapter;
         u8 man_id, chip_id, reg_config1, reg_config2;
         u8 reg_alert_status, reg_alert_mask;
+        int address = new_client->addr;
 
         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                 return -ENODEV;
@@ -439,7 +443,6 @@ static int lm63_detect(struct i2c_client *new_client,
                          LM63_REG_ALERT_MASK);
 
         if (man_id != 0x01 /* National Semiconductor */
-         || chip_id != 0x41 /* LM63 */
          || (reg_config1 & 0x18) != 0x00
          || (reg_config2 & 0xF8) != 0x00
          || (reg_alert_status & 0x20) != 0x00
@@ -450,7 +453,12 @@ static int lm63_detect(struct i2c_client *new_client,
                 return -ENODEV;
         }
 
-        strlcpy(info->type, "lm63", I2C_NAME_SIZE);
+        if (chip_id == 0x41 && address == 0x4c)
+                strlcpy(info->type, "lm63", I2C_NAME_SIZE);
+        else if (chip_id == 0x51 && (address == 0x18 || address == 0x4e))
+                strlcpy(info->type, "lm64", I2C_NAME_SIZE);
+        else
+                return -ENODEV;
 
         return 0;
 }
diff --git a/drivers/hwmon/lm75.c b/drivers/hwmon/lm75.c
index 8ae2cfe2d827..56463428a419 100644
--- a/drivers/hwmon/lm75.c
+++ b/drivers/hwmon/lm75.c
@@ -46,6 +46,7 @@ enum lm75_type {		/* keep sorted in alphabetical order */
         tcn75,
         tmp100,
         tmp101,
+        tmp105,
         tmp175,
         tmp275,
         tmp75,
@@ -220,6 +221,7 @@ static const struct i2c_device_id lm75_ids[] = {
         { "tcn75", tcn75, },
         { "tmp100", tmp100, },
         { "tmp101", tmp101, },
+        { "tmp105", tmp105, },
         { "tmp175", tmp175, },
         { "tmp275", tmp275, },
         { "tmp75", tmp75, },
diff --git a/drivers/hwmon/lm90.c b/drivers/hwmon/lm90.c
index 7cc2708871ab..760ef72eea56 100644
--- a/drivers/hwmon/lm90.c
+++ b/drivers/hwmon/lm90.c
@@ -982,7 +982,8 @@ static struct lm90_data *lm90_update_device(struct device *dev)
 
         mutex_lock(&data->update_lock);
 
-        if (time_after(jiffies, data->last_updated + HZ * 2) || !data->valid) {
+        if (time_after(jiffies, data->last_updated + HZ / 2 + HZ / 10)
+         || !data->valid) {
                 u8 h, l;
 
                 dev_dbg(&client->dev, "Updating lm90 data.\n");
diff --git a/drivers/hwmon/ltc4245.c b/drivers/hwmon/ltc4245.c
index 65c232a9d0c5..21d201befc2c 100644
--- a/drivers/hwmon/ltc4245.c
+++ b/drivers/hwmon/ltc4245.c
@@ -45,9 +45,7 @@ enum ltc4245_cmd {
         LTC4245_VEEIN                   = 0x19,
         LTC4245_VEESENSE                = 0x1a,
         LTC4245_VEEOUT                  = 0x1b,
-        LTC4245_GPIOADC1                = 0x1c,
-        LTC4245_GPIOADC2                = 0x1d,
-        LTC4245_GPIOADC3                = 0x1e,
+        LTC4245_GPIOADC                 = 0x1c,
 };
 
 struct ltc4245_data {
@@ -61,7 +59,7 @@ struct ltc4245_data {
         u8 cregs[0x08];
 
         /* Voltage registers */
-        u8 vregs[0x0f];
+        u8 vregs[0x0d];
 };
 
 static struct ltc4245_data *ltc4245_update_device(struct device *dev)
@@ -86,7 +84,7 @@ static struct ltc4245_data *ltc4245_update_device(struct device *dev)
                                 data->cregs[i] = val;
                 }
 
-                /* Read voltage registers -- 0x10 to 0x1f */
+                /* Read voltage registers -- 0x10 to 0x1c */
                 for (i = 0; i < ARRAY_SIZE(data->vregs); i++) {
                         val = i2c_smbus_read_byte_data(client, i+0x10);
                         if (unlikely(val < 0))
@@ -128,9 +126,7 @@ static int ltc4245_get_voltage(struct device *dev, u8 reg)
         case LTC4245_VEEOUT:
                 voltage = regval * -55;
                 break;
-        case LTC4245_GPIOADC1:
-        case LTC4245_GPIOADC2:
-        case LTC4245_GPIOADC3:
+        case LTC4245_GPIOADC:
                 voltage = regval * 10;
                 break;
         default:
@@ -297,9 +293,7 @@ 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_GPIOADC1);
-LTC4245_VOLTAGE(in10_input,                     LTC4245_GPIOADC2);
-LTC4245_VOLTAGE(in11_input,                     LTC4245_GPIOADC3);
+LTC4245_VOLTAGE(in9_input,                      LTC4245_GPIOADC);
 
 /* Power Consumption (virtual) */
 LTC4245_POWER(power1_input,                     LTC4245_12VSENSE);
@@ -342,8 +336,6 @@ static struct attribute *ltc4245_attributes[] = {
         &sensor_dev_attr_in8_min_alarm.dev_attr.attr,
 
         &sensor_dev_attr_in9_input.dev_attr.attr,
-        &sensor_dev_attr_in10_input.dev_attr.attr,
-        &sensor_dev_attr_in11_input.dev_attr.attr,
 
         &sensor_dev_attr_power1_input.dev_attr.attr,
         &sensor_dev_attr_power2_input.dev_attr.attr,
diff --git a/drivers/hwmon/tmp102.c b/drivers/hwmon/tmp102.c
new file mode 100644
index 000000000000..8013895a1faf
--- /dev/null
+++ b/drivers/hwmon/tmp102.c
@@ -0,0 +1,321 @@
+/* Texas Instruments TMP102 SMBus temperature sensor driver
+ *
+ * Copyright (C) 2010 Steven King <sfking@fdwdc.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., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
+#include <linux/err.h>
+#include <linux/mutex.h>
+#include <linux/device.h>
+
+#define DRIVER_NAME "tmp102"
+
+#define TMP102_TEMP_REG                 0x00
+#define TMP102_CONF_REG                 0x01
+/* note: these bit definitions are byte swapped */
+#define         TMP102_CONF_SD          0x0100
+#define         TMP102_CONF_TM          0x0200
+#define         TMP102_CONF_POL         0x0400
+#define         TMP102_CONF_F0          0x0800
+#define         TMP102_CONF_F1          0x1000
+#define         TMP102_CONF_R0          0x2000
+#define         TMP102_CONF_R1          0x4000
+#define         TMP102_CONF_OS          0x8000
+#define         TMP102_CONF_EM          0x0010
+#define         TMP102_CONF_AL          0x0020
+#define         TMP102_CONF_CR0         0x0040
+#define         TMP102_CONF_CR1         0x0080
+#define TMP102_TLOW_REG                 0x02
+#define TMP102_THIGH_REG                0x03
+
+struct tmp102 {
+        struct device *hwmon_dev;
+        struct mutex lock;
+        u16 config_orig;
+        unsigned long last_update;
+        int temp[3];
+};
+
+/* SMBus specifies low byte first, but the TMP102 returns high byte first,
+ * so we have to swab16 the values */
+static inline int tmp102_read_reg(struct i2c_client *client, u8 reg)
+{
+        int result = i2c_smbus_read_word_data(client, reg);
+        return result < 0 ? result : swab16(result);
+}
+
+static inline int tmp102_write_reg(struct i2c_client *client, u8 reg, u16 val)
+{
+        return i2c_smbus_write_word_data(client, reg, swab16(val));
+}
+
+/* convert left adjusted 13-bit TMP102 register value to milliCelsius */
+static inline int tmp102_reg_to_mC(s16 val)
+{
+        return ((val & ~0x01) * 1000) / 128;
+}
+
+/* convert milliCelsius to left adjusted 13-bit TMP102 register value */
+static inline u16 tmp102_mC_to_reg(int val)
+{
+        return (val * 128) / 1000;
+}
+
+static const u8 tmp102_reg[] = {
+        TMP102_TEMP_REG,
+        TMP102_TLOW_REG,
+        TMP102_THIGH_REG,
+};
+
+static struct tmp102 *tmp102_update_device(struct i2c_client *client)
+{
+        struct tmp102 *tmp102 = i2c_get_clientdata(client);
+
+        mutex_lock(&tmp102->lock);
+        if (time_after(jiffies, tmp102->last_update + HZ / 3)) {
+                int i;
+                for (i = 0; i < ARRAY_SIZE(tmp102->temp); ++i) {
+                        int status = tmp102_read_reg(client, tmp102_reg[i]);
+                        if (status > -1)
+                                tmp102->temp[i] = tmp102_reg_to_mC(status);
+                }
+                tmp102->last_update = jiffies;
+        }
+        mutex_unlock(&tmp102->lock);
+        return tmp102;
+}
+
+static ssize_t tmp102_show_temp(struct device *dev,
+                                struct device_attribute *attr,
+                                char *buf)
+{
+        struct sensor_device_attribute *sda = to_sensor_dev_attr(attr);
+        struct tmp102 *tmp102 = tmp102_update_device(to_i2c_client(dev));
+
+        return sprintf(buf, "%d\n", tmp102->temp[sda->index]);
+}
+
+static ssize_t tmp102_set_temp(struct device *dev,
+                               struct device_attribute *attr,
+                               const char *buf, size_t count)
+{
+        struct sensor_device_attribute *sda = to_sensor_dev_attr(attr);
+        struct i2c_client *client = to_i2c_client(dev);
+        struct tmp102 *tmp102 = i2c_get_clientdata(client);
+        long val;
+        int status;
+
+        if (strict_strtol(buf, 10, &val) < 0)
+                return -EINVAL;
+        val = SENSORS_LIMIT(val, -256000, 255000);
+
+        mutex_lock(&tmp102->lock);
+        tmp102->temp[sda->index] = val;
+        status = tmp102_write_reg(client, tmp102_reg[sda->index],
+                                  tmp102_mC_to_reg(val));
+        mutex_unlock(&tmp102->lock);
+        return status ? : count;
+}
+
+static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, tmp102_show_temp, NULL , 0);
+
+static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO, tmp102_show_temp,
+                          tmp102_set_temp, 1);
+
+static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, tmp102_show_temp,
+                          tmp102_set_temp, 2);
+
+static struct attribute *tmp102_attributes[] = {
+        &sensor_dev_attr_temp1_input.dev_attr.attr,
+        &sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
+        &sensor_dev_attr_temp1_max.dev_attr.attr,
+        NULL
+};
+
+static const struct attribute_group tmp102_attr_group = {
+        .attrs = tmp102_attributes,
+};
+
+#define TMP102_CONFIG  (TMP102_CONF_TM | TMP102_CONF_EM | TMP102_CONF_CR1)
+#define TMP102_CONFIG_RD_ONLY (TMP102_CONF_R0 | TMP102_CONF_R1 | TMP102_CONF_AL)
+
+static int __devinit tmp102_probe(struct i2c_client *client,
+                                  const struct i2c_device_id *id)
+{
+        struct tmp102 *tmp102;
+        int status;
+
+        if (!i2c_check_functionality(client->adapter,
+                                     I2C_FUNC_SMBUS_WORD_DATA)) {
+                dev_err(&client->dev, "adapter doesnt support SMBus word "
+                        "transactions\n");
+                return -ENODEV;
+        }
+
+        tmp102 = kzalloc(sizeof(*tmp102), GFP_KERNEL);
+        if (!tmp102) {
+                dev_dbg(&client->dev, "kzalloc failed\n");
+                return -ENOMEM;
+        }
+        i2c_set_clientdata(client, tmp102);
+
+        status = tmp102_read_reg(client, TMP102_CONF_REG);
+        if (status < 0) {
+                dev_err(&client->dev, "error reading config register\n");
+                goto fail_free;
+        }
+        tmp102->config_orig = status;
+        status = tmp102_write_reg(client, TMP102_CONF_REG, TMP102_CONFIG);
+        if (status < 0) {
+                dev_err(&client->dev, "error writing config register\n");
+                goto fail_restore_config;
+        }
+        status = tmp102_read_reg(client, TMP102_CONF_REG);
+        if (status < 0) {
+                dev_err(&client->dev, "error reading config register\n");
+                goto fail_restore_config;
+        }
+        status &= ~TMP102_CONFIG_RD_ONLY;
+        if (status != TMP102_CONFIG) {
+                dev_err(&client->dev, "config settings did not stick\n");
+                status = -ENODEV;
+                goto fail_restore_config;
+        }
+        tmp102->last_update = jiffies - HZ;
+        mutex_init(&tmp102->lock);
+
+        status = sysfs_create_group(&client->dev.kobj, &tmp102_attr_group);
+        if (status) {
+                dev_dbg(&client->dev, "could not create sysfs files\n");
+                goto fail_restore_config;
+        }
+        tmp102->hwmon_dev = hwmon_device_register(&client->dev);
+        if (IS_ERR(tmp102->hwmon_dev)) {
+                dev_dbg(&client->dev, "unable to register hwmon device\n");
+                status = PTR_ERR(tmp102->hwmon_dev);
+                goto fail_remove_sysfs;
+        }
+
+        dev_info(&client->dev, "initialized\n");
+
+        return 0;
+
+fail_remove_sysfs:
+        sysfs_remove_group(&client->dev.kobj, &tmp102_attr_group);
+fail_restore_config:
+        tmp102_write_reg(client, TMP102_CONF_REG, tmp102->config_orig);
+fail_free:
+        i2c_set_clientdata(client, NULL);
+        kfree(tmp102);
+
+        return status;
+}
+
+static int __devexit tmp102_remove(struct i2c_client *client)
+{
+        struct tmp102 *tmp102 = i2c_get_clientdata(client);
+
+        hwmon_device_unregister(tmp102->hwmon_dev);
+        sysfs_remove_group(&client->dev.kobj, &tmp102_attr_group);
+
+        /* Stop monitoring if device was stopped originally */
+        if (tmp102->config_orig & TMP102_CONF_SD) {
+                int config;
+
+                config = tmp102_read_reg(client, TMP102_CONF_REG);
+                if (config >= 0)
+                        tmp102_write_reg(client, TMP102_CONF_REG,
+                                         config | TMP102_CONF_SD);
+        }
+
+        i2c_set_clientdata(client, NULL);
+        kfree(tmp102);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int tmp102_suspend(struct device *dev)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        int config;
+
+        config = tmp102_read_reg(client, TMP102_CONF_REG);
+        if (config < 0)
+                return config;
+
+        config |= TMP102_CONF_SD;
+        return tmp102_write_reg(client, TMP102_CONF_REG, config);
+}
+
+static int tmp102_resume(struct device *dev)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        int config;
+
+        config = tmp102_read_reg(client, TMP102_CONF_REG);
+        if (config < 0)
+                return config;
+
+        config &= ~TMP102_CONF_SD;
+        return tmp102_write_reg(client, TMP102_CONF_REG, config);
+}
+
+static const struct dev_pm_ops tmp102_dev_pm_ops = {
+        .suspend        = tmp102_suspend,
+        .resume         = tmp102_resume,
+};
+
+#define TMP102_DEV_PM_OPS (&tmp102_dev_pm_ops)
+#else
+#define TMP102_DEV_PM_OPS NULL
+#endif /* CONFIG_PM */
+
+static const struct i2c_device_id tmp102_id[] = {
+        { "tmp102", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, tmp102_id);
+
+static struct i2c_driver tmp102_driver = {
+        .driver.name    = DRIVER_NAME,
+        .driver.pm      = TMP102_DEV_PM_OPS,
+        .probe          = tmp102_probe,
+        .remove         = __devexit_p(tmp102_remove),
+        .id_table       = tmp102_id,
+};
+
+static int __init tmp102_init(void)
+{
+        return i2c_add_driver(&tmp102_driver);
+}
+module_init(tmp102_init);
+
+static void __exit tmp102_exit(void)
+{
+        i2c_del_driver(&tmp102_driver);
+}
+module_exit(tmp102_exit);
+
+MODULE_AUTHOR("Steven King <sfking@fdwdc.com>");
+MODULE_DESCRIPTION("Texas Instruments TMP102 temperature sensor driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/hwmon/tmp401.c b/drivers/hwmon/tmp401.c
index d14a1af9f550..ad8d535235c5 100644
--- a/drivers/hwmon/tmp401.c
+++ b/drivers/hwmon/tmp401.c
@@ -92,17 +92,6 @@ static const u8 TMP411_TEMP_HIGHEST_LSB[2]		= { 0x33, 0x37 };
 #define TMP411_DEVICE_ID                        0x12
 
 /*
- * Functions declarations
- */
-
-static int tmp401_probe(struct i2c_client *client,
-                        const struct i2c_device_id *id);
-static int tmp401_detect(struct i2c_client *client,
-                         struct i2c_board_info *info);
-static int tmp401_remove(struct i2c_client *client);
-static struct tmp401_data *tmp401_update_device(struct device *dev);
-
-/*
  * Driver data (common to all clients)
  */
 
@@ -113,18 +102,6 @@ static const struct i2c_device_id tmp401_id[] = {
 };
 MODULE_DEVICE_TABLE(i2c, tmp401_id);
 
-static struct i2c_driver tmp401_driver = {
-        .class          = I2C_CLASS_HWMON,
-        .driver = {
-                .name   = "tmp401",
-        },
-        .probe          = tmp401_probe,
-        .remove         = tmp401_remove,
-        .id_table       = tmp401_id,
-        .detect         = tmp401_detect,
-        .address_list   = normal_i2c,
-};
-
 /*
  * Client data (each client gets its own)
  */
@@ -194,6 +171,71 @@ static u8 tmp401_crit_temp_to_register(long temp, u8 config)
         return (temp + 500) / 1000;
 }
 
+static struct tmp401_data *tmp401_update_device_reg16(
+        struct i2c_client *client, struct tmp401_data *data)
+{
+        int i;
+
+        for (i = 0; i < 2; i++) {
+                /*
+                 * High byte must be read first immediately followed
+                 * by the low byte
+                 */
+                data->temp[i] = i2c_smbus_read_byte_data(client,
+                        TMP401_TEMP_MSB[i]) << 8;
+                data->temp[i] |= i2c_smbus_read_byte_data(client,
+                        TMP401_TEMP_LSB[i]);
+                data->temp_low[i] = i2c_smbus_read_byte_data(client,
+                        TMP401_TEMP_LOW_LIMIT_MSB_READ[i]) << 8;
+                data->temp_low[i] |= i2c_smbus_read_byte_data(client,
+                        TMP401_TEMP_LOW_LIMIT_LSB[i]);
+                data->temp_high[i] = i2c_smbus_read_byte_data(client,
+                        TMP401_TEMP_HIGH_LIMIT_MSB_READ[i]) << 8;
+                data->temp_high[i] |= i2c_smbus_read_byte_data(client,
+                        TMP401_TEMP_HIGH_LIMIT_LSB[i]);
+                data->temp_crit[i] = i2c_smbus_read_byte_data(client,
+                        TMP401_TEMP_CRIT_LIMIT[i]);
+
+                if (data->kind == tmp411) {
+                        data->temp_lowest[i] = i2c_smbus_read_byte_data(client,
+                                TMP411_TEMP_LOWEST_MSB[i]) << 8;
+                        data->temp_lowest[i] |= i2c_smbus_read_byte_data(
+                                client, TMP411_TEMP_LOWEST_LSB[i]);
+
+                        data->temp_highest[i] = i2c_smbus_read_byte_data(
+                                client, TMP411_TEMP_HIGHEST_MSB[i]) << 8;
+                        data->temp_highest[i] |= i2c_smbus_read_byte_data(
+                                client, TMP411_TEMP_HIGHEST_LSB[i]);
+                }
+        }
+        return data;
+}
+
+static struct tmp401_data *tmp401_update_device(struct device *dev)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct tmp401_data *data = i2c_get_clientdata(client);
+
+        mutex_lock(&data->update_lock);
+
+        if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
+                data->status = i2c_smbus_read_byte_data(client, TMP401_STATUS);
+                data->config = i2c_smbus_read_byte_data(client,
+                                                TMP401_CONFIG_READ);
+                tmp401_update_device_reg16(client, data);
+
+                data->temp_crit_hyst = i2c_smbus_read_byte_data(client,
+                                                TMP401_TEMP_CRIT_HYST);
+
+                data->last_updated = jiffies;
+                data->valid = 1;
+        }
+
+        mutex_unlock(&data->update_lock);
+
+        return data;
+}
+
 static ssize_t show_temp_value(struct device *dev,
         struct device_attribute *devattr, char *buf)
 {
@@ -420,30 +462,36 @@ static ssize_t reset_temp_history(struct device *dev,
 }
 
 static struct sensor_device_attribute tmp401_attr[] = {
-        SENSOR_ATTR(temp1_input, 0444, show_temp_value, NULL, 0),
-        SENSOR_ATTR(temp1_min, 0644, show_temp_min, store_temp_min, 0),
-        SENSOR_ATTR(temp1_max, 0644, show_temp_max, store_temp_max, 0),
-        SENSOR_ATTR(temp1_crit, 0644, show_temp_crit, store_temp_crit, 0),
-        SENSOR_ATTR(temp1_crit_hyst, 0644, show_temp_crit_hyst,
+        SENSOR_ATTR(temp1_input, S_IRUGO, show_temp_value, NULL, 0),
+        SENSOR_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp_min,
+                    store_temp_min, 0),
+        SENSOR_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp_max,
+                    store_temp_max, 0),
+        SENSOR_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_temp_crit,
+                    store_temp_crit, 0),
+        SENSOR_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO, show_temp_crit_hyst,
                     store_temp_crit_hyst, 0),
-        SENSOR_ATTR(temp1_min_alarm, 0444, show_status, NULL,
+        SENSOR_ATTR(temp1_min_alarm, S_IRUGO, show_status, NULL,
                     TMP401_STATUS_LOCAL_LOW),
-        SENSOR_ATTR(temp1_max_alarm, 0444, show_status, NULL,
+        SENSOR_ATTR(temp1_max_alarm, S_IRUGO, show_status, NULL,
                     TMP401_STATUS_LOCAL_HIGH),
-        SENSOR_ATTR(temp1_crit_alarm, 0444, show_status, NULL,
+        SENSOR_ATTR(temp1_crit_alarm, S_IRUGO, show_status, NULL,
                     TMP401_STATUS_LOCAL_CRIT),
-        SENSOR_ATTR(temp2_input, 0444, show_temp_value, NULL, 1),
-        SENSOR_ATTR(temp2_min, 0644, show_temp_min, store_temp_min, 1),
-        SENSOR_ATTR(temp2_max, 0644, show_temp_max, store_temp_max, 1),
-        SENSOR_ATTR(temp2_crit, 0644, show_temp_crit, store_temp_crit, 1),
-        SENSOR_ATTR(temp2_crit_hyst, 0444, show_temp_crit_hyst, NULL, 1),
-        SENSOR_ATTR(temp2_fault, 0444, show_status, NULL,
+        SENSOR_ATTR(temp2_input, S_IRUGO, show_temp_value, NULL, 1),
+        SENSOR_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_temp_min,
+                    store_temp_min, 1),
+        SENSOR_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp_max,
+                    store_temp_max, 1),
+        SENSOR_ATTR(temp2_crit, S_IWUSR | S_IRUGO, show_temp_crit,
+                    store_temp_crit, 1),
+        SENSOR_ATTR(temp2_crit_hyst, S_IRUGO, show_temp_crit_hyst, NULL, 1),
+        SENSOR_ATTR(temp2_fault, S_IRUGO, show_status, NULL,
                     TMP401_STATUS_REMOTE_OPEN),
-        SENSOR_ATTR(temp2_min_alarm, 0444, show_status, NULL,
+        SENSOR_ATTR(temp2_min_alarm, S_IRUGO, show_status, NULL,
                     TMP401_STATUS_REMOTE_LOW),
-        SENSOR_ATTR(temp2_max_alarm, 0444, show_status, NULL,
+        SENSOR_ATTR(temp2_max_alarm, S_IRUGO, show_status, NULL,
                     TMP401_STATUS_REMOTE_HIGH),
-        SENSOR_ATTR(temp2_crit_alarm, 0444, show_status, NULL,
+        SENSOR_ATTR(temp2_crit_alarm, S_IRUGO, show_status, NULL,
                     TMP401_STATUS_REMOTE_CRIT),
 };
 
@@ -455,11 +503,11 @@ static struct sensor_device_attribute tmp401_attr[] = {
  * and remote channels.
  */
 static struct sensor_device_attribute tmp411_attr[] = {
-        SENSOR_ATTR(temp1_highest, 0444, show_temp_highest, NULL, 0),
-        SENSOR_ATTR(temp1_lowest, 0444, show_temp_lowest, NULL, 0),
-        SENSOR_ATTR(temp2_highest, 0444, show_temp_highest, NULL, 1),
-        SENSOR_ATTR(temp2_lowest, 0444, show_temp_lowest, NULL, 1),
-        SENSOR_ATTR(temp_reset_history, 0200, NULL, reset_temp_history, 0),
+        SENSOR_ATTR(temp1_highest, S_IRUGO, show_temp_highest, NULL, 0),
+        SENSOR_ATTR(temp1_lowest, S_IRUGO, show_temp_lowest, NULL, 0),
+        SENSOR_ATTR(temp2_highest, S_IRUGO, show_temp_highest, NULL, 1),
+        SENSOR_ATTR(temp2_lowest, S_IRUGO, show_temp_lowest, NULL, 1),
+        SENSOR_ATTR(temp_reset_history, S_IWUSR, NULL, reset_temp_history, 0),
 };
 
 /*
@@ -529,6 +577,27 @@ static int tmp401_detect(struct i2c_client *client,
         return 0;
 }
 
+static int tmp401_remove(struct i2c_client *client)
+{
+        struct tmp401_data *data = i2c_get_clientdata(client);
+        int i;
+
+        if (data->hwmon_dev)
+                hwmon_device_unregister(data->hwmon_dev);
+
+        for (i = 0; i < ARRAY_SIZE(tmp401_attr); i++)
+                device_remove_file(&client->dev, &tmp401_attr[i].dev_attr);
+
+        if (data->kind == tmp411) {
+                for (i = 0; i < ARRAY_SIZE(tmp411_attr); i++)
+                        device_remove_file(&client->dev,
+                                           &tmp411_attr[i].dev_attr);
+        }
+
+        kfree(data);
+        return 0;
+}
+
 static int tmp401_probe(struct i2c_client *client,
                         const struct i2c_device_id *id)
 {
@@ -581,91 +650,17 @@ exit_remove:
         return err;
 }
 
-static int tmp401_remove(struct i2c_client *client)
-{
-        struct tmp401_data *data = i2c_get_clientdata(client);
-        int i;
-
-        if (data->hwmon_dev)
-                hwmon_device_unregister(data->hwmon_dev);
-
-        for (i = 0; i < ARRAY_SIZE(tmp401_attr); i++)
-                device_remove_file(&client->dev, &tmp401_attr[i].dev_attr);
-
-        if (data->kind == tmp411) {
-                for (i = 0; i < ARRAY_SIZE(tmp411_attr); i++)
-                        device_remove_file(&client->dev,
-                                           &tmp411_attr[i].dev_attr);
-        }
-
-        kfree(data);
-        return 0;
-}
-
-static struct tmp401_data *tmp401_update_device_reg16(
-        struct i2c_client *client, struct tmp401_data *data)
-{
-        int i;
-
-        for (i = 0; i < 2; i++) {
-                /*
-                 * High byte must be read first immediately followed
-                 * by the low byte
-                 */
-                data->temp[i] = i2c_smbus_read_byte_data(client,
-                        TMP401_TEMP_MSB[i]) << 8;
-                data->temp[i] |= i2c_smbus_read_byte_data(client,
-                        TMP401_TEMP_LSB[i]);
-                data->temp_low[i] = i2c_smbus_read_byte_data(client,
-                        TMP401_TEMP_LOW_LIMIT_MSB_READ[i]) << 8;
-                data->temp_low[i] |= i2c_smbus_read_byte_data(client,
-                        TMP401_TEMP_LOW_LIMIT_LSB[i]);
-                data->temp_high[i] = i2c_smbus_read_byte_data(client,
-                        TMP401_TEMP_HIGH_LIMIT_MSB_READ[i]) << 8;
-                data->temp_high[i] |= i2c_smbus_read_byte_data(client,
-                        TMP401_TEMP_HIGH_LIMIT_LSB[i]);
-                data->temp_crit[i] = i2c_smbus_read_byte_data(client,
-                        TMP401_TEMP_CRIT_LIMIT[i]);
-
-                if (data->kind == tmp411) {
-                        data->temp_lowest[i] = i2c_smbus_read_byte_data(client,
-                                TMP411_TEMP_LOWEST_MSB[i]) << 8;
-                        data->temp_lowest[i] |= i2c_smbus_read_byte_data(
-                                client, TMP411_TEMP_LOWEST_LSB[i]);
-
-                        data->temp_highest[i] = i2c_smbus_read_byte_data(
-                                client, TMP411_TEMP_HIGHEST_MSB[i]) << 8;
-                        data->temp_highest[i] |= i2c_smbus_read_byte_data(
-                                client, TMP411_TEMP_HIGHEST_LSB[i]);
-                }
-        }
-        return data;
-}
-
-static struct tmp401_data *tmp401_update_device(struct device *dev)
-{
-        struct i2c_client *client = to_i2c_client(dev);
-        struct tmp401_data *data = i2c_get_clientdata(client);
-
-        mutex_lock(&data->update_lock);
-
-        if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
-                data->status = i2c_smbus_read_byte_data(client, TMP401_STATUS);
-                data->config = i2c_smbus_read_byte_data(client,
-                                                TMP401_CONFIG_READ);
-                tmp401_update_device_reg16(client, data);
-
-                data->temp_crit_hyst = i2c_smbus_read_byte_data(client,
-                                                TMP401_TEMP_CRIT_HYST);
-
-                data->last_updated = jiffies;
-                data->valid = 1;
-        }
-
-        mutex_unlock(&data->update_lock);
-
-        return data;
-}
+static struct i2c_driver tmp401_driver = {
+        .class          = I2C_CLASS_HWMON,
+        .driver = {
+                .name   = "tmp401",
+        },
+        .probe          = tmp401_probe,
+        .remove         = tmp401_remove,
+        .id_table       = tmp401_id,
+        .detect         = tmp401_detect,
+        .address_list   = normal_i2c,
+};
 
 static int __init tmp401_init(void)
 {
diff --git a/drivers/ide/gayle.c b/drivers/ide/gayle.c
index b9e517de6a82..3feaa26410be 100644
--- a/drivers/ide/gayle.c
+++ b/drivers/ide/gayle.c
@@ -16,6 +16,7 @@
 #include <linux/init.h>
 #include <linux/zorro.h>
 #include <linux/module.h>
+#include <linux/platform_device.h>
 
 #include <asm/setup.h>
 #include <asm/amigahw.h>
@@ -24,15 +25,6 @@
 
 
     /*
-     *  Bases of the IDE interfaces
-     */
-
-#define GAYLE_BASE_4000 0xdd2020        /* A4000/A4000T */
-#define GAYLE_BASE_1200 0xda0000        /* A1200/A600 and E-Matrix 530 */
-
-#define GAYLE_IDEREG_SIZE       0x2000
-
-    /*
      *  Offsets from one of the above bases
      */
 
@@ -68,20 +60,20 @@ MODULE_PARM_DESC(doubler, "enable support for IDE doublers");
 
 static int gayle_test_irq(ide_hwif_t *hwif)
 {
-    unsigned char ch;
+        unsigned char ch;
 
-    ch = z_readb(hwif->io_ports.irq_addr);
-    if (!(ch & GAYLE_IRQ_IDE))
-        return 0;
-    return 1;
+        ch = z_readb(hwif->io_ports.irq_addr);
+        if (!(ch & GAYLE_IRQ_IDE))
+                return 0;
+        return 1;
 }
 
 static void gayle_a1200_clear_irq(ide_drive_t *drive)
 {
-    ide_hwif_t *hwif = drive->hwif;
+        ide_hwif_t *hwif = drive->hwif;
 
-    (void)z_readb(hwif->io_ports.status_addr);
-    z_writeb(0x7c, hwif->io_ports.irq_addr);
+        (void)z_readb(hwif->io_ports.status_addr);
+        z_writeb(0x7c, hwif->io_ports.irq_addr);
 }
 
 static void __init gayle_setup_ports(struct ide_hw *hw, unsigned long base,
@@ -122,64 +114,89 @@ static const struct ide_port_info gayle_port_info = {
      *  Probe for a Gayle IDE interface (and optionally for an IDE doubler)
      */
 
-static int __init gayle_init(void)
+static int __init amiga_gayle_ide_probe(struct platform_device *pdev)
 {
-    unsigned long phys_base, res_start, res_n;
-    unsigned long base, ctrlport, irqport;
-    int a4000, i, rc;
-    struct ide_hw hw[GAYLE_NUM_HWIFS], *hws[GAYLE_NUM_HWIFS];
-    struct ide_port_info d = gayle_port_info;
-
-    if (!MACH_IS_AMIGA)
-        return -ENODEV;
-
-    if ((a4000 = AMIGAHW_PRESENT(A4000_IDE)) || AMIGAHW_PRESENT(A1200_IDE))
-        goto found;
-
-#ifdef CONFIG_ZORRO
-    if (zorro_find_device(ZORRO_PROD_MTEC_VIPER_MK_V_E_MATRIX_530_SCSI_IDE,
-                          NULL))
-        goto found;
-#endif
-    return -ENODEV;
-
-found:
-        printk(KERN_INFO "ide: Gayle IDE controller (A%d style%s)\n",
-                         a4000 ? 4000 : 1200,
-                         ide_doubler ? ", IDE doubler" : "");
-
-        if (a4000) {
-            phys_base = GAYLE_BASE_4000;
-            irqport = (unsigned long)ZTWO_VADDR(GAYLE_IRQ_4000);
-            d.port_ops = &gayle_a4000_port_ops;
-        } else {
-            phys_base = GAYLE_BASE_1200;
-            irqport = (unsigned long)ZTWO_VADDR(GAYLE_IRQ_1200);
-            d.port_ops = &gayle_a1200_port_ops;
+        struct resource *res;
+        struct gayle_ide_platform_data *pdata;
+        unsigned long base, ctrlport, irqport;
+        unsigned int i;
+        int error;
+        struct ide_hw hw[GAYLE_NUM_HWIFS], *hws[GAYLE_NUM_HWIFS];
+        struct ide_port_info d = gayle_port_info;
+        struct ide_host *host;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res)
+                return -ENODEV;
+
+        if (!request_mem_region(res->start, resource_size(res), "IDE"))
+                return -EBUSY;
+
+        pdata = pdev->dev.platform_data;
+        pr_info("ide: Gayle IDE controller (A%u style%s)\n",
+                pdata->explicit_ack ? 1200 : 4000,
+                ide_doubler ? ", IDE doubler" : "");
+
+        base = (unsigned long)ZTWO_VADDR(pdata->base);
+        ctrlport = 0;
+        irqport = (unsigned long)ZTWO_VADDR(pdata->irqport);
+        if (pdata->explicit_ack)
+                d.port_ops = &gayle_a1200_port_ops;
+        else
+                d.port_ops = &gayle_a4000_port_ops;
+
+        for (i = 0; i < GAYLE_NUM_PROBE_HWIFS; i++, base += GAYLE_NEXT_PORT) {
+                if (GAYLE_HAS_CONTROL_REG)
+                        ctrlport = base + GAYLE_CONTROL;
+
+                gayle_setup_ports(&hw[i], base, ctrlport, irqport);
+                hws[i] = &hw[i];
         }
 
-        res_start = ((unsigned long)phys_base) & ~(GAYLE_NEXT_PORT-1);
-        res_n = GAYLE_IDEREG_SIZE;
+        error = ide_host_add(&d, hws, i, &host);
+        if (error)
+                goto out;
 
-        if (!request_mem_region(res_start, res_n, "IDE"))
-                return -EBUSY;
+        platform_set_drvdata(pdev, host);
+        return 0;
 
-    for (i = 0; i < GAYLE_NUM_PROBE_HWIFS; i++) {
-        base = (unsigned long)ZTWO_VADDR(phys_base + i * GAYLE_NEXT_PORT);
-        ctrlport = GAYLE_HAS_CONTROL_REG ? (base + GAYLE_CONTROL) : 0;
+out:
+        release_mem_region(res->start, resource_size(res));
+        return error;
+}
+
+static int __exit amiga_gayle_ide_remove(struct platform_device *pdev)
+{
+        struct ide_host *host = platform_get_drvdata(pdev);
+        struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+
+        ide_host_remove(host);
+        release_mem_region(res->start, resource_size(res));
+        return 0;
+}
 
-        gayle_setup_ports(&hw[i], base, ctrlport, irqport);
+static struct platform_driver amiga_gayle_ide_driver = {
+        .remove = __exit_p(amiga_gayle_ide_remove),
+        .driver   = {
+                .name   = "amiga-gayle-ide",
+                .owner  = THIS_MODULE,
+        },
+};
 
-        hws[i] = &hw[i];
-    }
+static int __init amiga_gayle_ide_init(void)
+{
+        return platform_driver_probe(&amiga_gayle_ide_driver,
+                                     amiga_gayle_ide_probe);
+}
 
-    rc = ide_host_add(&d, hws, i, NULL);
-    if (rc)
-        release_mem_region(res_start, res_n);
+module_init(amiga_gayle_ide_init);
 
-    return rc;
+static void __exit amiga_gayle_ide_exit(void)
+{
+        platform_driver_unregister(&amiga_gayle_ide_driver);
 }
 
-module_init(gayle_init);
+module_exit(amiga_gayle_ide_exit);
 
 MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:amiga-gayle-ide");
diff --git a/drivers/idle/Kconfig b/drivers/idle/Kconfig
index f15e90a453d1..fb5c5186d4aa 100644
--- a/drivers/idle/Kconfig
+++ b/drivers/idle/Kconfig
@@ -1,3 +1,14 @@
+config INTEL_IDLE
+        tristate "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
+          can be configured at the same time, in order to handle
+          processors intel_idle does not support.
 
 menu "Memory power savings"
 depends on X86_64
diff --git a/drivers/idle/Makefile b/drivers/idle/Makefile
index 5f68fc377e21..23d295cf10f2 100644
--- a/drivers/idle/Makefile
+++ b/drivers/idle/Makefile
@@ -1,2 +1,3 @@
 obj-$(CONFIG_I7300_IDLE)                        += i7300_idle.o
+obj-$(CONFIG_INTEL_IDLE)                        += intel_idle.o
 
diff --git a/drivers/idle/intel_idle.c b/drivers/idle/intel_idle.c
new file mode 100755
index 000000000000..54f0fb4cd5d2
--- /dev/null
+++ b/drivers/idle/intel_idle.c
@@ -0,0 +1,461 @@
+/*
+ * intel_idle.c - native hardware idle loop for modern Intel processors
+ *
+ * Copyright (c) 2010, Intel Corporation.
+ * Len Brown <len.brown@intel.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+/*
+ * intel_idle is a cpuidle driver that loads on specific Intel processors
+ * in lieu of the legacy ACPI processor_idle driver.  The intent is to
+ * make Linux more efficient on these processors, as intel_idle knows
+ * more than ACPI, as well as make Linux more immune to ACPI BIOS bugs.
+ */
+
+/*
+ * Design Assumptions
+ *
+ * All CPUs have same idle states as boot CPU
+ *
+ * Chipset BM_STS (bus master status) bit is a NOP
+ *      for preventing entry into deep C-stats
+ */
+
+/*
+ * Known limitations
+ *
+ * The driver currently initializes for_each_online_cpu() upon modprobe.
+ * It it unaware of subsequent processors hot-added to the system.
+ * This means that if you boot with maxcpus=n and later online
+ * processors above n, those processors will use C1 only.
+ *
+ * ACPI has a .suspend hack to turn off deep c-statees during suspend
+ * to avoid complications with the lapic timer workaround.
+ * Have not seen issues with suspend, but may need same workaround here.
+ *
+ * There is currently no kernel-based automatic probing/loading mechanism
+ * if the driver is built as a module.
+ */
+
+/* un-comment DEBUG to enable pr_debug() statements */
+#define DEBUG
+
+#include <linux/kernel.h>
+#include <linux/cpuidle.h>
+#include <linux/clockchips.h>
+#include <linux/hrtimer.h>      /* ktime_get_real() */
+#include <trace/events/power.h>
+#include <linux/sched.h>
+
+#define INTEL_IDLE_VERSION "0.4"
+#define PREFIX "intel_idle: "
+
+#define MWAIT_SUBSTATE_MASK     (0xf)
+#define MWAIT_CSTATE_MASK       (0xf)
+#define MWAIT_SUBSTATE_SIZE     (4)
+#define MWAIT_MAX_NUM_CSTATES   8
+#define CPUID_MWAIT_LEAF (5)
+#define CPUID5_ECX_EXTENSIONS_SUPPORTED (0x1)
+#define CPUID5_ECX_INTERRUPT_BREAK      (0x2)
+
+static struct cpuidle_driver intel_idle_driver = {
+        .name = "intel_idle",
+        .owner = THIS_MODULE,
+};
+/* 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);
+
+/* Reliable LAPIC Timer States, bit 1 for C1 etc.  */
+static unsigned int lapic_timer_reliable_states;
+
+static struct cpuidle_device *intel_idle_cpuidle_devices;
+static int intel_idle(struct cpuidle_device *dev, struct cpuidle_state *state);
+
+static struct cpuidle_state *cpuidle_state_table;
+
+/*
+ * States are indexed by the cstate number,
+ * which is also the index into the MWAIT hint array.
+ * Thus C0 is a dummy.
+ */
+static struct cpuidle_state nehalem_cstates[MWAIT_MAX_NUM_CSTATES] = {
+        { /* MWAIT C0 */ },
+        { /* MWAIT C1 */
+                .name = "NHM-C1",
+                .desc = "MWAIT 0x00",
+                .driver_data = (void *) 0x00,
+                .flags = CPUIDLE_FLAG_TIME_VALID,
+                .exit_latency = 3,
+                .power_usage = 1000,
+                .target_residency = 6,
+                .enter = &intel_idle },
+        { /* MWAIT C2 */
+                .name = "NHM-C3",
+                .desc = "MWAIT 0x10",
+                .driver_data = (void *) 0x10,
+                .flags = CPUIDLE_FLAG_TIME_VALID,
+                .exit_latency = 20,
+                .power_usage = 500,
+                .target_residency = 80,
+                .enter = &intel_idle },
+        { /* MWAIT C3 */
+                .name = "NHM-C6",
+                .desc = "MWAIT 0x20",
+                .driver_data = (void *) 0x20,
+                .flags = CPUIDLE_FLAG_TIME_VALID,
+                .exit_latency = 200,
+                .power_usage = 350,
+                .target_residency = 800,
+                .enter = &intel_idle },
+};
+
+static struct cpuidle_state atom_cstates[MWAIT_MAX_NUM_CSTATES] = {
+        { /* MWAIT C0 */ },
+        { /* MWAIT C1 */
+                .name = "ATM-C1",
+                .desc = "MWAIT 0x00",
+                .driver_data = (void *) 0x00,
+                .flags = CPUIDLE_FLAG_TIME_VALID,
+                .exit_latency = 1,
+                .power_usage = 1000,
+                .target_residency = 4,
+                .enter = &intel_idle },
+        { /* MWAIT C2 */
+                .name = "ATM-C2",
+                .desc = "MWAIT 0x10",
+                .driver_data = (void *) 0x10,
+                .flags = CPUIDLE_FLAG_TIME_VALID,
+                .exit_latency = 20,
+                .power_usage = 500,
+                .target_residency = 80,
+                .enter = &intel_idle },
+        { /* MWAIT C3 */ },
+        { /* MWAIT C4 */
+                .name = "ATM-C4",
+                .desc = "MWAIT 0x30",
+                .driver_data = (void *) 0x30,
+                .flags = CPUIDLE_FLAG_TIME_VALID,
+                .exit_latency = 100,
+                .power_usage = 250,
+                .target_residency = 400,
+                .enter = &intel_idle },
+        { /* MWAIT C5 */ },
+        { /* MWAIT C6 */
+                .name = "ATM-C6",
+                .desc = "MWAIT 0x40",
+                .driver_data = (void *) 0x40,
+                .flags = CPUIDLE_FLAG_TIME_VALID,
+                .exit_latency = 200,
+                .power_usage = 150,
+                .target_residency = 800,
+                .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
+ * @state: cpuidle state
+ *
+ */
+static int intel_idle(struct cpuidle_device *dev, struct cpuidle_state *state)
+{
+        unsigned long ecx = 1; /* break on interrupt flag */
+        unsigned long eax = (unsigned long)cpuidle_get_statedata(state);
+        unsigned int cstate;
+        ktime_t kt_before, kt_after;
+        s64 usec_delta;
+        int cpu = smp_processor_id();
+
+        cstate = (((eax) >> MWAIT_SUBSTATE_SIZE) & MWAIT_CSTATE_MASK) + 1;
+
+        eax = eax + (choose_substate)(cstate);
+
+        local_irq_disable();
+
+        if (!(lapic_timer_reliable_states & (1 << (cstate))))
+                clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_ENTER, &cpu);
+
+        kt_before = ktime_get_real();
+
+        stop_critical_timings();
+#ifndef MODULE
+        trace_power_start(POWER_CSTATE, (eax >> 4) + 1);
+#endif
+        if (!need_resched()) {
+
+                __monitor((void *)&current_thread_info()->flags, 0, 0);
+                smp_mb();
+                if (!need_resched())
+                        __mwait(eax, ecx);
+        }
+
+        start_critical_timings();
+
+        kt_after = ktime_get_real();
+        usec_delta = ktime_to_us(ktime_sub(kt_after, kt_before));
+
+        local_irq_enable();
+
+        if (!(lapic_timer_reliable_states & (1 << (cstate))))
+                clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_EXIT, &cpu);
+
+        return usec_delta;
+}
+
+/*
+ * intel_idle_probe()
+ */
+static int intel_idle_probe(void)
+{
+        unsigned int eax, ebx, ecx, edx;
+
+        if (max_cstate == 0) {
+                pr_debug(PREFIX "disabled\n");
+                return -EPERM;
+        }
+
+        if (boot_cpu_data.x86_vendor != X86_VENDOR_INTEL)
+                return -ENODEV;
+
+        if (!boot_cpu_has(X86_FEATURE_MWAIT))
+                return -ENODEV;
+
+        if (boot_cpu_data.cpuid_level < CPUID_MWAIT_LEAF)
+                return -ENODEV;
+
+        cpuid(CPUID_MWAIT_LEAF, &eax, &ebx, &ecx, &edx);
+
+        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);
+
+        if (boot_cpu_has(X86_FEATURE_ARAT))     /* Always Reliable APIC Timer */
+                lapic_timer_reliable_states = 0xFFFFFFFF;
+
+        if (boot_cpu_data.x86 != 6)     /* family 6 */
+                return -ENODEV;
+
+        switch (boot_cpu_data.x86_model) {
+
+        case 0x1A:      /* Core i7, Xeon 5500 series */
+        case 0x1E:      /* Core i7 and i5 Processor - Lynnfield Jasper Forest */
+        case 0x1F:      /* Core i7 and i5 Processor - Nehalem */
+        case 0x2E:      /* Nehalem-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 */
+                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 */
+                lapic_timer_reliable_states = (1 << 2) | (1 << 1); /* C2, C1 */
+#endif
+
+        default:
+                pr_debug(PREFIX "does not run on family %d model %d\n",
+                        boot_cpu_data.x86, boot_cpu_data.x86_model);
+                return -ENODEV;
+        }
+
+        pr_debug(PREFIX "v" INTEL_IDLE_VERSION
+                " model 0x%X\n", boot_cpu_data.x86_model);
+
+        pr_debug(PREFIX "lapic_timer_reliable_states 0x%x\n",
+                lapic_timer_reliable_states);
+        return 0;
+}
+
+/*
+ * intel_idle_cpuidle_devices_uninit()
+ * unregister, free cpuidle_devices
+ */
+static void intel_idle_cpuidle_devices_uninit(void)
+{
+        int i;
+        struct cpuidle_device *dev;
+
+        for_each_online_cpu(i) {
+                dev = per_cpu_ptr(intel_idle_cpuidle_devices, i);
+                cpuidle_unregister_device(dev);
+        }
+
+        free_percpu(intel_idle_cpuidle_devices);
+        return;
+}
+/*
+ * intel_idle_cpuidle_devices_init()
+ * allocate, initialize, register cpuidle_devices
+ */
+static int intel_idle_cpuidle_devices_init(void)
+{
+        int i, cstate;
+        struct cpuidle_device *dev;
+
+        intel_idle_cpuidle_devices = alloc_percpu(struct cpuidle_device);
+        if (intel_idle_cpuidle_devices == NULL)
+                return -ENOMEM;
+
+        for_each_online_cpu(i) {
+                dev = per_cpu_ptr(intel_idle_cpuidle_devices, i);
+
+                dev->state_count = 1;
+
+                for (cstate = 1; cstate < MWAIT_MAX_NUM_CSTATES; ++cstate) {
+                        int num_substates;
+
+                        if (cstate > max_cstate) {
+                                printk(PREFIX "max_cstate %d reached\n",
+                                        max_cstate);
+                                break;
+                        }
+
+                        /* does the state exist in CPUID.MWAIT? */
+                        num_substates = (substates >> ((cstate) * 4))
+                                                & MWAIT_SUBSTATE_MASK;
+                        if (num_substates == 0)
+                                continue;
+                        /* is the state not enabled? */
+                        if (cpuidle_state_table[cstate].enter == NULL) {
+                                /* does the driver not know about the state? */
+                                if (*cpuidle_state_table[cstate].name == '\0')
+                                        pr_debug(PREFIX "unaware of model 0x%x"
+                                                " MWAIT %d please"
+                                                " contact lenb@kernel.org",
+                                        boot_cpu_data.x86_model, cstate);
+                                continue;
+                        }
+
+                        if ((cstate > 2) &&
+                                !boot_cpu_has(X86_FEATURE_NONSTOP_TSC))
+                                mark_tsc_unstable("TSC halts in idle"
+                                        " states deeper than C2");
+
+                        dev->states[dev->state_count] = /* structure copy */
+                                cpuidle_state_table[cstate];
+
+                        dev->state_count += 1;
+                }
+
+                dev->cpu = i;
+                if (cpuidle_register_device(dev)) {
+                        pr_debug(PREFIX "cpuidle_register_device %d failed!\n",
+                                 i);
+                        intel_idle_cpuidle_devices_uninit();
+                        return -EIO;
+                }
+        }
+
+        return 0;
+}
+
+
+static int __init intel_idle_init(void)
+{
+        int retval;
+
+        retval = intel_idle_probe();
+        if (retval)
+                return retval;
+
+        retval = cpuidle_register_driver(&intel_idle_driver);
+        if (retval) {
+                printk(KERN_DEBUG PREFIX "intel_idle yielding to %s",
+                        cpuidle_get_driver()->name);
+                return retval;
+        }
+
+        retval = intel_idle_cpuidle_devices_init();
+        if (retval) {
+                cpuidle_unregister_driver(&intel_idle_driver);
+                return retval;
+        }
+
+        return 0;
+}
+
+static void __exit intel_idle_exit(void)
+{
+        intel_idle_cpuidle_devices_uninit();
+        cpuidle_unregister_driver(&intel_idle_driver);
+
+        return;
+}
+
+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);
+MODULE_LICENSE("GPL");
diff --git a/drivers/ieee1394/dv1394.c b/drivers/ieee1394/dv1394.c
index 9fd4a0d3206e..adaefabc40e9 100644
--- a/drivers/ieee1394/dv1394.c
+++ b/drivers/ieee1394/dv1394.c
@@ -1824,7 +1824,7 @@ static int dv1394_open(struct inode *inode, struct file *file)
                "and will not be available in the new firewire driver stack. "
                "Try libraw1394 based programs instead.\n", current->comm);
 
-        return 0;
+        return nonseekable_open(inode, file);
 }
 
 
@@ -2153,17 +2153,18 @@ static struct cdev dv1394_cdev;
 static const struct file_operations dv1394_fops=
 {
         .owner =        THIS_MODULE,
-        .poll =         dv1394_poll,
+        .poll =         dv1394_poll,
         .unlocked_ioctl = dv1394_ioctl,
 #ifdef CONFIG_COMPAT
         .compat_ioctl = dv1394_compat_ioctl,
 #endif
         .mmap =         dv1394_mmap,
         .open =         dv1394_open,
-        .write =        dv1394_write,
-        .read =         dv1394_read,
+        .write =        dv1394_write,
+        .read =         dv1394_read,
         .release =      dv1394_release,
-        .fasync =       dv1394_fasync,
+        .fasync =       dv1394_fasync,
+        .llseek =       no_llseek,
 };
 
 
diff --git a/drivers/ieee1394/raw1394.c b/drivers/ieee1394/raw1394.c
index 8aa56ac07e29..b563d5e9fa2e 100644
--- a/drivers/ieee1394/raw1394.c
+++ b/drivers/ieee1394/raw1394.c
@@ -2834,7 +2834,7 @@ static int raw1394_open(struct inode *inode, struct file *file)
 
         file->private_data = fi;
 
-        return 0;
+        return nonseekable_open(inode, file);
 }
 
 static int raw1394_release(struct inode *inode, struct file *file)
@@ -3035,6 +3035,7 @@ static const struct file_operations raw1394_fops = {
         .poll = raw1394_poll,
         .open = raw1394_open,
         .release = raw1394_release,
+        .llseek = no_llseek,
 };
 
 static int __init init_raw1394(void)
diff --git a/drivers/ieee1394/video1394.c b/drivers/ieee1394/video1394.c
index 949064a05675..a42bd6893bcf 100644
--- a/drivers/ieee1394/video1394.c
+++ b/drivers/ieee1394/video1394.c
@@ -1239,7 +1239,7 @@ static int video1394_open(struct inode *inode, struct file *file)
         ctx->current_ctx = NULL;
         file->private_data = ctx;
 
-        return 0;
+        return nonseekable_open(inode, file);
 }
 
 static int video1394_release(struct inode *inode, struct file *file)
@@ -1287,7 +1287,8 @@ static const struct file_operations video1394_fops=
         .poll =         video1394_poll,
         .mmap =         video1394_mmap,
         .open =         video1394_open,
-        .release =      video1394_release
+        .release =      video1394_release,
+        .llseek =       no_llseek,
 };
 
 /*** HOTPLUG STUFF **********************************************************/
diff --git a/drivers/infiniband/core/ucm.c b/drivers/infiniband/core/ucm.c
index 46474842cfe9..08f948df8fa9 100644
--- a/drivers/infiniband/core/ucm.c
+++ b/drivers/infiniband/core/ucm.c
@@ -706,14 +706,9 @@ static int ib_ucm_alloc_data(const void **dest, u64 src, u32 len)
         if (!len)
                 return 0;
 
-        data = kmalloc(len, GFP_KERNEL);
-        if (!data)
-                return -ENOMEM;
-
-        if (copy_from_user(data, (void __user *)(unsigned long)src, len)) {
-                kfree(data);
-                return -EFAULT;
-        }
+        data = memdup_user((void __user *)(unsigned long)src, len);
+        if (IS_ERR(data))
+                return PTR_ERR(data);
 
         *dest = data;
         return 0;
diff --git a/drivers/infiniband/hw/ehca/ehca_irq.c b/drivers/infiniband/hw/ehca/ehca_irq.c
index 07cae552cafb..e571e60ecb88 100644
--- a/drivers/infiniband/hw/ehca/ehca_irq.c
+++ b/drivers/infiniband/hw/ehca/ehca_irq.c
@@ -847,7 +847,7 @@ static int __cpuinit comp_pool_callback(struct notifier_block *nfb,
                 ehca_gen_dbg("CPU: %x (CPU_PREPARE)", cpu);
                 if (!create_comp_task(pool, cpu)) {
                         ehca_gen_err("Can't create comp_task for cpu: %x", cpu);
-                        return NOTIFY_BAD;
+                        return notifier_from_errno(-ENOMEM);
                 }
                 break;
         case CPU_UP_CANCELED:
diff --git a/drivers/infiniband/hw/qib/qib_fs.c b/drivers/infiniband/hw/qib/qib_fs.c
index 755470440ef1..edef8527eb34 100644
--- a/drivers/infiniband/hw/qib/qib_fs.c
+++ b/drivers/infiniband/hw/qib/qib_fs.c
@@ -144,10 +144,11 @@ static ssize_t dev_counters_read(struct file *file, char __user *buf,
                                  size_t count, loff_t *ppos)
 {
         u64 *counters;
+        size_t avail;
         struct qib_devdata *dd = private2dd(file);
 
-        return simple_read_from_buffer(buf, count, ppos, counters,
-                dd->f_read_cntrs(dd, *ppos, NULL, &counters));
+        avail = dd->f_read_cntrs(dd, *ppos, NULL, &counters);
+        return simple_read_from_buffer(buf, count, ppos, counters, avail);
 }
 
 /* read the per-device counters */
@@ -155,10 +156,11 @@ static ssize_t dev_names_read(struct file *file, char __user *buf,
                               size_t count, loff_t *ppos)
 {
         char *names;
+        size_t avail;
         struct qib_devdata *dd = private2dd(file);
 
-        return simple_read_from_buffer(buf, count, ppos, names,
-                dd->f_read_cntrs(dd, *ppos, &names, NULL));
+        avail = dd->f_read_cntrs(dd, *ppos, &names, NULL);
+        return simple_read_from_buffer(buf, count, ppos, names, avail);
 }
 
 static const struct file_operations cntr_ops[] = {
@@ -176,10 +178,11 @@ static ssize_t portnames_read(struct file *file, char __user *buf,
                               size_t count, loff_t *ppos)
 {
         char *names;
+        size_t avail;
         struct qib_devdata *dd = private2dd(file);
 
-        return simple_read_from_buffer(buf, count, ppos, names,
-                dd->f_read_portcntrs(dd, *ppos, 0, &names, NULL));
+        avail = dd->f_read_portcntrs(dd, *ppos, 0, &names, NULL);
+        return simple_read_from_buffer(buf, count, ppos, names, avail);
 }
 
 /* read the per-port counters for port 1 (pidx 0) */
@@ -187,10 +190,11 @@ static ssize_t portcntrs_1_read(struct file *file, char __user *buf,
                                 size_t count, loff_t *ppos)
 {
         u64 *counters;
+        size_t avail;
         struct qib_devdata *dd = private2dd(file);
 
-        return simple_read_from_buffer(buf, count, ppos, counters,
-                dd->f_read_portcntrs(dd, *ppos, 0, NULL, &counters));
+        avail = dd->f_read_portcntrs(dd, *ppos, 0, NULL, &counters);
+        return simple_read_from_buffer(buf, count, ppos, counters, avail);
 }
 
 /* read the per-port counters for port 2 (pidx 1) */
@@ -198,10 +202,11 @@ static ssize_t portcntrs_2_read(struct file *file, char __user *buf,
                                 size_t count, loff_t *ppos)
 {
         u64 *counters;
+        size_t avail;
         struct qib_devdata *dd = private2dd(file);
 
-        return simple_read_from_buffer(buf, count, ppos, counters,
-                dd->f_read_portcntrs(dd, *ppos, 1, NULL, &counters));
+        avail = dd->f_read_portcntrs(dd, *ppos, 1, NULL, &counters);
+        return simple_read_from_buffer(buf, count, ppos, counters, avail);
 }
 
 static const struct file_operations portcntr_ops[] = {
diff --git a/drivers/infiniband/hw/qib/qib_iba6120.c b/drivers/infiniband/hw/qib/qib_iba6120.c
index 7b6549fd429b..1eadadc13da8 100644
--- a/drivers/infiniband/hw/qib/qib_iba6120.c
+++ b/drivers/infiniband/hw/qib/qib_iba6120.c
@@ -3475,14 +3475,6 @@ struct qib_devdata *qib_init_iba6120_funcs(struct pci_dev *pdev,
         struct qib_devdata *dd;
         int ret;
 
-#ifndef CONFIG_PCI_MSI
-        qib_early_err(&pdev->dev, "QLogic PCIE device 0x%x cannot "
-              "work if CONFIG_PCI_MSI is not enabled\n",
-              ent->device);
-        dd = ERR_PTR(-ENODEV);
-        goto bail;
-#endif
-
         dd = qib_alloc_devdata(pdev, sizeof(struct qib_pportdata) +
                                sizeof(struct qib_chip_specific));
         if (IS_ERR(dd))
@@ -3554,10 +3546,6 @@ struct qib_devdata *qib_init_iba6120_funcs(struct pci_dev *pdev,
         if (qib_mini_init)
                 goto bail;
 
-#ifndef CONFIG_PCI_MSI
-        qib_dev_err(dd, "PCI_MSI not configured, NO interrupts\n");
-#endif
-
         if (qib_pcie_params(dd, 8, NULL, NULL))
                 qib_dev_err(dd, "Failed to setup PCIe or interrupts; "
                             "continuing anyway\n");
diff --git a/drivers/infiniband/hw/qib/qib_iba7322.c b/drivers/infiniband/hw/qib/qib_iba7322.c
index 2c24eab35b54..503992d9c5ce 100644
--- a/drivers/infiniband/hw/qib/qib_iba7322.c
+++ b/drivers/infiniband/hw/qib/qib_iba7322.c
@@ -42,9 +42,6 @@
 #include <linux/jiffies.h>
 #include <rdma/ib_verbs.h>
 #include <rdma/ib_smi.h>
-#if defined(CONFIG_DCA) || defined(CONFIG_DCA_MODULE)
-#include <linux/dca.h>
-#endif
 
 #include "qib.h"
 #include "qib_7322_regs.h"
@@ -114,40 +111,18 @@ static ushort qib_singleport;
 module_param_named(singleport, qib_singleport, ushort, S_IRUGO);
 MODULE_PARM_DESC(singleport, "Use only IB port 1; more per-port buffer space");
 
-
-/*
- * Setup QMH7342 receive and transmit parameters, necessary because
- * each bay, Mez connector, and IB port need different tuning, beyond
- * what the switch and HCA can do automatically.
- * It's expected to be done by cat'ing files to the modules file,
- * rather than setting up as a module parameter.
- * It's a "write-only" file, returns 0 when read back.
- * The unit, port, bay (if given), and values MUST be done as a single write.
- * The unit, port, and bay must precede the values to be effective.
- */
-static int setup_qmh_params(const char *, struct kernel_param *);
-static unsigned dummy_qmh_params;
-module_param_call(qmh_serdes_setup, setup_qmh_params, param_get_uint,
-                  &dummy_qmh_params, S_IWUSR | S_IRUGO);
-
-/* similarly for QME7342, but it's simpler */
-static int setup_qme_params(const char *, struct kernel_param *);
-static unsigned dummy_qme_params;
-module_param_call(qme_serdes_setup, setup_qme_params, param_get_uint,
-                  &dummy_qme_params, S_IWUSR | S_IRUGO);
-
 #define MAX_ATTEN_LEN 64 /* plenty for any real system */
 /* for read back, default index is ~5m copper cable */
-static char cable_atten_list[MAX_ATTEN_LEN] = "10";
-static struct kparam_string kp_cable_atten = {
-        .string = cable_atten_list,
+static char txselect_list[MAX_ATTEN_LEN] = "10";
+static struct kparam_string kp_txselect = {
+        .string = txselect_list,
         .maxlen = MAX_ATTEN_LEN
 };
-static int  setup_cable_atten(const char *, struct kernel_param *);
-module_param_call(cable_atten, setup_cable_atten, param_get_string,
-                  &kp_cable_atten, S_IWUSR | S_IRUGO);
-MODULE_PARM_DESC(cable_atten, \
-                 "cable attenuation indices for cables with invalid EEPROM");
+static int  setup_txselect(const char *, struct kernel_param *);
+module_param_call(txselect, setup_txselect, param_get_string,
+                  &kp_txselect, S_IWUSR | S_IRUGO);
+MODULE_PARM_DESC(txselect, \
+                 "Tx serdes indices (for no QSFP or invalid QSFP data)");
 
 #define BOARD_QME7342 5
 #define BOARD_QMH7342 6
@@ -540,12 +515,6 @@ struct qib_chip_specific {
         u32 lastbuf_for_pio;
         u32 stay_in_freeze;
         u32 recovery_ports_initted;
-#if defined(CONFIG_DCA) || defined(CONFIG_DCA_MODULE)
-        u32 dca_ctrl;
-        int rhdr_cpu[18];
-        int sdma_cpu[2];
-        u64 dca_rcvhdr_ctrl[5]; /* B, C, D, E, F */
-#endif
         struct msix_entry *msix_entries;
         void  **msix_arg;
         unsigned long *sendchkenable;
@@ -574,11 +543,12 @@ struct vendor_txdds_ent {
 static void write_tx_serdes_param(struct qib_pportdata *, struct txdds_ent *);
 
 #define TXDDS_TABLE_SZ 16 /* number of entries per speed in onchip table */
+#define TXDDS_EXTRA_SZ 11 /* number of extra tx settings entries */
 #define SERDES_CHANS 4 /* yes, it's obvious, but one less magic number */
 
 #define H1_FORCE_VAL 8
-#define H1_FORCE_QME 1 /*  may be overridden via setup_qme_params() */
-#define H1_FORCE_QMH 7 /*  may be overridden via setup_qmh_params() */
+#define H1_FORCE_QME 1 /*  may be overridden via setup_txselect() */
+#define H1_FORCE_QMH 7 /*  may be overridden via setup_txselect() */
 
 /* The static and dynamic registers are paired, and the pairs indexed by spd */
 #define krp_static_adapt_dis(spd) (KREG_IBPORT_IDX(ADAPT_DISABLE_STATIC_SDR) \
@@ -590,15 +560,6 @@ static void write_tx_serdes_param(struct qib_pportdata *, struct txdds_ent *);
 #define QDR_STATIC_ADAPT_INIT 0xffffffffffULL /* up, disable H0,H1-8, LE */
 #define QDR_STATIC_ADAPT_INIT_R1 0xf0ffffffffULL /* r1 up, disable H0,H1-8 */
 
-static const struct txdds_ent qmh_sdr_txdds =  { 11, 0,  5,  6 };
-static const struct txdds_ent qmh_ddr_txdds =  {  7, 0,  2,  8 };
-static const struct txdds_ent qmh_qdr_txdds =  {  0, 1,  3, 10 };
-
-/* this is used for unknown mez cards also */
-static const struct txdds_ent qme_sdr_txdds =  { 11, 0,  4,  4 };
-static const struct txdds_ent qme_ddr_txdds =  {  7, 0,  2,  7 };
-static const struct txdds_ent qme_qdr_txdds =  {  0, 1, 12, 11 };
-
 struct qib_chippport_specific {
         u64 __iomem *kpregbase;
         u64 __iomem *cpregbase;
@@ -637,12 +598,8 @@ struct qib_chippport_specific {
          * Per-bay per-channel rcv QMH H1 values and Tx values for QDR.
          * entry zero is unused, to simplify indexing
          */
-        u16 h1_val;
-        u8 amp[SERDES_CHANS];
-        u8 pre[SERDES_CHANS];
-        u8 mainv[SERDES_CHANS];
-        u8 post[SERDES_CHANS];
-        u8 no_eep;  /* attenuation index to use if no qsfp info */
+        u8 h1_val;
+        u8 no_eep;  /* txselect table index to use if no qsfp info */
         u8 ipg_tries;
         u8 ibmalfusesnap;
         struct qib_qsfp_data qsfp_data;
@@ -676,52 +633,6 @@ static struct {
                 SYM_LSB(IntStatus, SDmaCleanupDone_1), 2 },
 };
 
-#if defined(CONFIG_DCA) || defined(CONFIG_DCA_MODULE)
-static const struct dca_reg_map {
-        int     shadow_inx;
-        int     lsb;
-        u64     mask;
-        u16     regno;
-} dca_rcvhdr_reg_map[] = {
-        { 0, SYM_LSB(DCACtrlB, RcvHdrq0DCAOPH),
-           ~SYM_MASK(DCACtrlB, RcvHdrq0DCAOPH) , KREG_IDX(DCACtrlB) },
-        { 0, SYM_LSB(DCACtrlB, RcvHdrq1DCAOPH),
-           ~SYM_MASK(DCACtrlB, RcvHdrq1DCAOPH) , KREG_IDX(DCACtrlB) },
-        { 0, SYM_LSB(DCACtrlB, RcvHdrq2DCAOPH),
-           ~SYM_MASK(DCACtrlB, RcvHdrq2DCAOPH) , KREG_IDX(DCACtrlB) },
-        { 0, SYM_LSB(DCACtrlB, RcvHdrq3DCAOPH),
-           ~SYM_MASK(DCACtrlB, RcvHdrq3DCAOPH) , KREG_IDX(DCACtrlB) },
-        { 1, SYM_LSB(DCACtrlC, RcvHdrq4DCAOPH),
-           ~SYM_MASK(DCACtrlC, RcvHdrq4DCAOPH) , KREG_IDX(DCACtrlC) },
-        { 1, SYM_LSB(DCACtrlC, RcvHdrq5DCAOPH),
-           ~SYM_MASK(DCACtrlC, RcvHdrq5DCAOPH) , KREG_IDX(DCACtrlC) },
-        { 1, SYM_LSB(DCACtrlC, RcvHdrq6DCAOPH),
-           ~SYM_MASK(DCACtrlC, RcvHdrq6DCAOPH) , KREG_IDX(DCACtrlC) },
-        { 1, SYM_LSB(DCACtrlC, RcvHdrq7DCAOPH),
-           ~SYM_MASK(DCACtrlC, RcvHdrq7DCAOPH) , KREG_IDX(DCACtrlC) },
-        { 2, SYM_LSB(DCACtrlD, RcvHdrq8DCAOPH),
-           ~SYM_MASK(DCACtrlD, RcvHdrq8DCAOPH) , KREG_IDX(DCACtrlD) },
-        { 2, SYM_LSB(DCACtrlD, RcvHdrq9DCAOPH),
-           ~SYM_MASK(DCACtrlD, RcvHdrq9DCAOPH) , KREG_IDX(DCACtrlD) },
-        { 2, SYM_LSB(DCACtrlD, RcvHdrq10DCAOPH),
-           ~SYM_MASK(DCACtrlD, RcvHdrq10DCAOPH) , KREG_IDX(DCACtrlD) },
-        { 2, SYM_LSB(DCACtrlD, RcvHdrq11DCAOPH),
-           ~SYM_MASK(DCACtrlD, RcvHdrq11DCAOPH) , KREG_IDX(DCACtrlD) },
-        { 3, SYM_LSB(DCACtrlE, RcvHdrq12DCAOPH),
-           ~SYM_MASK(DCACtrlE, RcvHdrq12DCAOPH) , KREG_IDX(DCACtrlE) },
-        { 3, SYM_LSB(DCACtrlE, RcvHdrq13DCAOPH),
-           ~SYM_MASK(DCACtrlE, RcvHdrq13DCAOPH) , KREG_IDX(DCACtrlE) },
-        { 3, SYM_LSB(DCACtrlE, RcvHdrq14DCAOPH),
-           ~SYM_MASK(DCACtrlE, RcvHdrq14DCAOPH) , KREG_IDX(DCACtrlE) },
-        { 3, SYM_LSB(DCACtrlE, RcvHdrq15DCAOPH),
-           ~SYM_MASK(DCACtrlE, RcvHdrq15DCAOPH) , KREG_IDX(DCACtrlE) },
-        { 4, SYM_LSB(DCACtrlF, RcvHdrq16DCAOPH),
-           ~SYM_MASK(DCACtrlF, RcvHdrq16DCAOPH) , KREG_IDX(DCACtrlF) },
-        { 4, SYM_LSB(DCACtrlF, RcvHdrq17DCAOPH),
-           ~SYM_MASK(DCACtrlF, RcvHdrq17DCAOPH) , KREG_IDX(DCACtrlF) },
-};
-#endif
-
 /* ibcctrl bits */
 #define QLOGIC_IB_IBCC_LINKINITCMD_DISABLE 1
 /* cycle through TS1/TS2 till OK */
@@ -2572,95 +2483,6 @@ static void qib_setup_7322_setextled(struct qib_pportdata *ppd, u32 on)
                 qib_write_kreg_port(ppd, krp_rcvpktledcnt, ledblink);
 }
 
-#if defined(CONFIG_DCA) || defined(CONFIG_DCA_MODULE)
-static void qib_update_rhdrq_dca(struct qib_ctxtdata *rcd)
-{
-        struct qib_devdata *dd = rcd->dd;
-        struct qib_chip_specific *cspec = dd->cspec;
-        int cpu = get_cpu();
-
-        if (cspec->rhdr_cpu[rcd->ctxt] != cpu) {
-                const struct dca_reg_map *rmp;
-
-                cspec->rhdr_cpu[rcd->ctxt] = cpu;
-                rmp = &dca_rcvhdr_reg_map[rcd->ctxt];
-                cspec->dca_rcvhdr_ctrl[rmp->shadow_inx] &= rmp->mask;
-                cspec->dca_rcvhdr_ctrl[rmp->shadow_inx] |=
-                        (u64) dca3_get_tag(&dd->pcidev->dev, cpu) << rmp->lsb;
-                qib_write_kreg(dd, rmp->regno,
-                               cspec->dca_rcvhdr_ctrl[rmp->shadow_inx]);
-                cspec->dca_ctrl |= SYM_MASK(DCACtrlA, RcvHdrqDCAEnable);
-                qib_write_kreg(dd, KREG_IDX(DCACtrlA), cspec->dca_ctrl);
-        }
-        put_cpu();
-}
-
-static void qib_update_sdma_dca(struct qib_pportdata *ppd)
-{
-        struct qib_devdata *dd = ppd->dd;
-        struct qib_chip_specific *cspec = dd->cspec;
-        int cpu = get_cpu();
-        unsigned pidx = ppd->port - 1;
-
-        if (cspec->sdma_cpu[pidx] != cpu) {
-                cspec->sdma_cpu[pidx] = cpu;
-                cspec->dca_rcvhdr_ctrl[4] &= ~(ppd->hw_pidx ?
-                        SYM_MASK(DCACtrlF, SendDma1DCAOPH) :
-                        SYM_MASK(DCACtrlF, SendDma0DCAOPH));
-                cspec->dca_rcvhdr_ctrl[4] |=
-                        (u64) dca3_get_tag(&dd->pcidev->dev, cpu) <<
-                                (ppd->hw_pidx ?
-                                        SYM_LSB(DCACtrlF, SendDma1DCAOPH) :
-                                        SYM_LSB(DCACtrlF, SendDma0DCAOPH));
-                qib_write_kreg(dd, KREG_IDX(DCACtrlF),
-                               cspec->dca_rcvhdr_ctrl[4]);
-                cspec->dca_ctrl |= ppd->hw_pidx ?
-                        SYM_MASK(DCACtrlA, SendDMAHead1DCAEnable) :
-                        SYM_MASK(DCACtrlA, SendDMAHead0DCAEnable);
-                qib_write_kreg(dd, KREG_IDX(DCACtrlA), cspec->dca_ctrl);
-        }
-        put_cpu();
-}
-
-static void qib_setup_dca(struct qib_devdata *dd)
-{
-        struct qib_chip_specific *cspec = dd->cspec;
-        int i;
-
-        for (i = 0; i < ARRAY_SIZE(cspec->rhdr_cpu); i++)
-                cspec->rhdr_cpu[i] = -1;
-        for (i = 0; i < ARRAY_SIZE(cspec->sdma_cpu); i++)
-                cspec->sdma_cpu[i] = -1;
-        cspec->dca_rcvhdr_ctrl[0] =
-                (1ULL << SYM_LSB(DCACtrlB, RcvHdrq0DCAXfrCnt)) |
-                (1ULL << SYM_LSB(DCACtrlB, RcvHdrq1DCAXfrCnt)) |
-                (1ULL << SYM_LSB(DCACtrlB, RcvHdrq2DCAXfrCnt)) |
-                (1ULL << SYM_LSB(DCACtrlB, RcvHdrq3DCAXfrCnt));
-        cspec->dca_rcvhdr_ctrl[1] =
-                (1ULL << SYM_LSB(DCACtrlC, RcvHdrq4DCAXfrCnt)) |
-                (1ULL << SYM_LSB(DCACtrlC, RcvHdrq5DCAXfrCnt)) |
-                (1ULL << SYM_LSB(DCACtrlC, RcvHdrq6DCAXfrCnt)) |
-                (1ULL << SYM_LSB(DCACtrlC, RcvHdrq7DCAXfrCnt));
-        cspec->dca_rcvhdr_ctrl[2] =
-                (1ULL << SYM_LSB(DCACtrlD, RcvHdrq8DCAXfrCnt)) |
-                (1ULL << SYM_LSB(DCACtrlD, RcvHdrq9DCAXfrCnt)) |
-                (1ULL << SYM_LSB(DCACtrlD, RcvHdrq10DCAXfrCnt)) |
-                (1ULL << SYM_LSB(DCACtrlD, RcvHdrq11DCAXfrCnt));
-        cspec->dca_rcvhdr_ctrl[3] =
-                (1ULL << SYM_LSB(DCACtrlE, RcvHdrq12DCAXfrCnt)) |
-                (1ULL << SYM_LSB(DCACtrlE, RcvHdrq13DCAXfrCnt)) |
-                (1ULL << SYM_LSB(DCACtrlE, RcvHdrq14DCAXfrCnt)) |
-                (1ULL << SYM_LSB(DCACtrlE, RcvHdrq15DCAXfrCnt));
-        cspec->dca_rcvhdr_ctrl[4] =
-                (1ULL << SYM_LSB(DCACtrlF, RcvHdrq16DCAXfrCnt)) |
-                (1ULL << SYM_LSB(DCACtrlF, RcvHdrq17DCAXfrCnt));
-        for (i = 0; i < ARRAY_SIZE(cspec->sdma_cpu); i++)
-                qib_write_kreg(dd, KREG_IDX(DCACtrlB) + i,
-                               cspec->dca_rcvhdr_ctrl[i]);
-}
-
-#endif
-
 /*
  * Disable MSIx interrupt if enabled, call generic MSIx code
  * to cleanup, and clear pending MSIx interrupts.
@@ -2701,15 +2523,6 @@ static void qib_setup_7322_cleanup(struct qib_devdata *dd)
 {
         int i;
 
-#if defined(CONFIG_DCA) || defined(CONFIG_DCA_MODULE)
-        if (dd->flags & QIB_DCA_ENABLED) {
-                dca_remove_requester(&dd->pcidev->dev);
-                dd->flags &= ~QIB_DCA_ENABLED;
-                dd->cspec->dca_ctrl = 0;
-                qib_write_kreg(dd, KREG_IDX(DCACtrlA), dd->cspec->dca_ctrl);
-        }
-#endif
-
         qib_7322_free_irq(dd);
         kfree(dd->cspec->cntrs);
         kfree(dd->cspec->sendchkenable);
@@ -3017,11 +2830,6 @@ static irqreturn_t qib_7322pintr(int irq, void *data)
         if (dd->int_counter != (u32) -1)
                 dd->int_counter++;
 
-#if defined(CONFIG_DCA) || defined(CONFIG_DCA_MODULE)
-        if (dd->flags & QIB_DCA_ENABLED)
-                qib_update_rhdrq_dca(rcd);
-#endif
-
         /* Clear the interrupt bit we expect to be set. */
         qib_write_kreg(dd, kr_intclear, ((1ULL << QIB_I_RCVAVAIL_LSB) |
                        (1ULL << QIB_I_RCVURG_LSB)) << rcd->ctxt);
@@ -3085,11 +2893,6 @@ static irqreturn_t sdma_intr(int irq, void *data)
         if (dd->int_counter != (u32) -1)
                 dd->int_counter++;
 
-#if defined(CONFIG_DCA) || defined(CONFIG_DCA_MODULE)
-        if (dd->flags & QIB_DCA_ENABLED)
-                qib_update_sdma_dca(ppd);
-#endif
-
         /* Clear the interrupt bit we expect to be set. */
         qib_write_kreg(dd, kr_intclear, ppd->hw_pidx ?
                        INT_MASK_P(SDma, 1) : INT_MASK_P(SDma, 0));
@@ -3119,11 +2922,6 @@ static irqreturn_t sdma_idle_intr(int irq, void *data)
         if (dd->int_counter != (u32) -1)
                 dd->int_counter++;
 
-#if defined(CONFIG_DCA) || defined(CONFIG_DCA_MODULE)
-        if (dd->flags & QIB_DCA_ENABLED)
-                qib_update_sdma_dca(ppd);
-#endif
-
         /* Clear the interrupt bit we expect to be set. */
         qib_write_kreg(dd, kr_intclear, ppd->hw_pidx ?
                        INT_MASK_P(SDmaIdle, 1) : INT_MASK_P(SDmaIdle, 0));
@@ -3153,11 +2951,6 @@ static irqreturn_t sdma_progress_intr(int irq, void *data)
         if (dd->int_counter != (u32) -1)
                 dd->int_counter++;
 
-#if defined(CONFIG_DCA) || defined(CONFIG_DCA_MODULE)
-        if (dd->flags & QIB_DCA_ENABLED)
-                qib_update_sdma_dca(ppd);
-#endif
-
         /* Clear the interrupt bit we expect to be set. */
         qib_write_kreg(dd, kr_intclear, ppd->hw_pidx ?
                        INT_MASK_P(SDmaProgress, 1) :
@@ -3188,11 +2981,6 @@ static irqreturn_t sdma_cleanup_intr(int irq, void *data)
         if (dd->int_counter != (u32) -1)
                 dd->int_counter++;
 
-#if defined(CONFIG_DCA) || defined(CONFIG_DCA_MODULE)
-        if (dd->flags & QIB_DCA_ENABLED)
-                qib_update_sdma_dca(ppd);
-#endif
-
         /* Clear the interrupt bit we expect to be set. */
         qib_write_kreg(dd, kr_intclear, ppd->hw_pidx ?
                        INT_MASK_PM(SDmaCleanupDone, 1) :
@@ -4299,10 +4087,6 @@ static void rcvctrl_7322_mod(struct qib_pportdata *ppd, unsigned int op,
                 qib_write_kreg_ctxt(dd, krc_rcvhdraddr, ctxt,
                                     rcd->rcvhdrq_phys);
                 rcd->seq_cnt = 1;
-#if defined(CONFIG_DCA) || defined(CONFIG_DCA_MODULE)
-                if (dd->flags & QIB_DCA_ENABLED)
-                        qib_update_rhdrq_dca(rcd);
-#endif
         }
         if (op & QIB_RCVCTRL_CTXT_DIS)
                 ppd->p_rcvctrl &=
@@ -5360,7 +5144,13 @@ static int qib_7322_ib_updown(struct qib_pportdata *ppd, int ibup, u64 ibcs)
                                      QIBL_IB_AUTONEG_INPROG)))
                         set_7322_ibspeed_fast(ppd, ppd->link_speed_enabled);
                 if (!(ppd->lflags & QIBL_IB_AUTONEG_INPROG)) {
+                        /* unlock the Tx settings, speed may change */
+                        qib_write_kreg_port(ppd, krp_tx_deemph_override,
+                                SYM_MASK(IBSD_TX_DEEMPHASIS_OVERRIDE_0,
+                                reset_tx_deemphasis_override));
                         qib_cancel_sends(ppd);
+                        /* on link down, ensure sane pcs state */
+                        qib_7322_mini_pcs_reset(ppd);
                         spin_lock_irqsave(&ppd->sdma_lock, flags);
                         if (__qib_sdma_running(ppd))
                                 __qib_sdma_process_event(ppd,
@@ -5766,26 +5556,28 @@ static void qib_init_7322_qsfp(struct qib_pportdata *ppd)
 }
 
 /*
- * called at device initialization time, and also if the cable_atten
+ * called at device initialization time, and also if the txselect
  * module parameter is changed.  This is used for cables that don't
  * have valid QSFP EEPROMs (not present, or attenuation is zero).
  * We initialize to the default, then if there is a specific
- * unit,port match, we use that.
+ * unit,port match, we use that (and set it immediately, for the
+ * current speed, if the link is at INIT or better).
  * String format is "default# unit#,port#=# ... u,p=#", separators must
- * be a SPACE character.  A newline terminates.
+ * be a SPACE character.  A newline terminates.  The u,p=# tuples may
+ * optionally have "u,p=#,#", where the final # is the H1 value
  * The last specific match is used (actually, all are used, but last
  * one is the one that winds up set); if none at all, fall back on default.
  */
 static void set_no_qsfp_atten(struct qib_devdata *dd, int change)
 {
         char *nxt, *str;
-        int pidx, unit, port, deflt;
+        u32 pidx, unit, port, deflt, h1;
         unsigned long val;
-        int any = 0;
+        int any = 0, seth1;
 
-        str = cable_atten_list;
+        str = txselect_list;
 
-        /* default number is validated in setup_cable_atten() */
+        /* default number is validated in setup_txselect() */
         deflt = simple_strtoul(str, &nxt, 0);
         for (pidx = 0; pidx < dd->num_pports; ++pidx)
                 dd->pport[pidx].cpspec->no_eep = deflt;
@@ -5812,16 +5604,28 @@ static void set_no_qsfp_atten(struct qib_devdata *dd, int change)
                                 ;
                         continue;
                 }
-                if (val >= TXDDS_TABLE_SZ)
+                if (val >= TXDDS_TABLE_SZ + TXDDS_EXTRA_SZ)
                         continue;
+                seth1 = 0;
+                h1 = 0; /* gcc thinks it might be used uninitted */
+                if (*nxt == ',' && nxt[1]) {
+                        str = ++nxt;
+                        h1 = (u32)simple_strtoul(str, &nxt, 0);
+                        if (nxt == str)
+                                while (*nxt && *nxt++ != ' ') /* skip */
+                                        ;
+                        else
+                                seth1 = 1;
+                }
                 for (pidx = 0; dd->unit == unit && pidx < dd->num_pports;
                      ++pidx) {
-                        if (dd->pport[pidx].port != port ||
-                                !dd->pport[pidx].link_speed_supported)
+                        struct qib_pportdata *ppd = &dd->pport[pidx];
+
+                        if (ppd->port != port || !ppd->link_speed_supported)
                                 continue;
-                        dd->pport[pidx].cpspec->no_eep = val;
+                        ppd->cpspec->no_eep = val;
                         /* now change the IBC and serdes, overriding generic */
-                        init_txdds_table(&dd->pport[pidx], 1);
+                        init_txdds_table(ppd, 1);
                         any++;
                 }
                 if (*nxt == '\n')
@@ -5832,35 +5636,35 @@ static void set_no_qsfp_atten(struct qib_devdata *dd, int change)
                  * Change the IBC and serdes, but since it's
                  * general, don't override specific settings.
                  */
-                for (pidx = 0; pidx < dd->num_pports; ++pidx) {
-                        if (!dd->pport[pidx].link_speed_supported)
-                                continue;
-                        init_txdds_table(&dd->pport[pidx], 0);
-                }
+                for (pidx = 0; pidx < dd->num_pports; ++pidx)
+                        if (dd->pport[pidx].link_speed_supported)
+                                init_txdds_table(&dd->pport[pidx], 0);
         }
 }
 
-/* handle the cable_atten parameter changing */
-static int setup_cable_atten(const char *str, struct kernel_param *kp)
+/* handle the txselect parameter changing */
+static int setup_txselect(const char *str, struct kernel_param *kp)
 {
         struct qib_devdata *dd;
         unsigned long val;
         char *n;
         if (strlen(str) >= MAX_ATTEN_LEN) {
-                printk(KERN_INFO QIB_DRV_NAME " cable_atten_values string "
+                printk(KERN_INFO QIB_DRV_NAME " txselect_values string "
                        "too long\n");
                 return -ENOSPC;
         }
         val = simple_strtoul(str, &n, 0);
-        if (n == str || val >= TXDDS_TABLE_SZ) {
+        if (n == str || val >= (TXDDS_TABLE_SZ + TXDDS_EXTRA_SZ)) {
                 printk(KERN_INFO QIB_DRV_NAME
-                       "cable_atten_values must start with a number\n");
+                       "txselect_values must start with a number < %d\n",
+                        TXDDS_TABLE_SZ + TXDDS_EXTRA_SZ);
                 return -EINVAL;
         }
-        strcpy(cable_atten_list, str);
+        strcpy(txselect_list, str);
 
         list_for_each_entry(dd, &qib_dev_list, list)
-                set_no_qsfp_atten(dd, 1);
+                if (dd->deviceid == PCI_DEVICE_ID_QLOGIC_IB_7322)
+                        set_no_qsfp_atten(dd, 1);
         return 0;
 }
 
@@ -6261,28 +6065,17 @@ static int qib_init_7322_variables(struct qib_devdata *dd)
                  * in adapter-specific routines.
                  */
                 if (!(ppd->dd->flags & QIB_HAS_QSFP)) {
-                        int i;
-                        const struct txdds_ent *txdds;
-
                         if (!IS_QMH(ppd->dd) && !IS_QME(ppd->dd))
                                 qib_devinfo(ppd->dd->pcidev, "IB%u:%u: "
                                             "Unknown mezzanine card type\n",
-                                            ppd->dd->unit, ppd->port);
-                        txdds = IS_QMH(ppd->dd) ? &qmh_qdr_txdds :
-                                &qme_qdr_txdds;
-
+                                            dd->unit, ppd->port);
+                        cp->h1_val = IS_QMH(dd) ? H1_FORCE_QMH : H1_FORCE_QME;
                         /*
-                         * set values in case link comes up
-                         * before table is written to driver.
+                         * Choose center value as default tx serdes setting
+                         * until changed through module parameter.
                          */
-                        cp->h1_val = IS_QMH(ppd->dd) ? H1_FORCE_QMH :
-                                H1_FORCE_QME;
-                        for (i = 0; i < SERDES_CHANS; i++) {
-                                cp->amp[i] = txdds->amp;
-                                cp->pre[i] = txdds->pre;
-                                cp->mainv[i] = txdds->main;
-                                cp->post[i] = txdds->post;
-                        }
+                        ppd->cpspec->no_eep = IS_QMH(dd) ?
+                                TXDDS_TABLE_SZ + 2 : TXDDS_TABLE_SZ + 4;
                 } else
                         cp->h1_val = H1_FORCE_VAL;
 
@@ -6299,8 +6092,7 @@ static int qib_init_7322_variables(struct qib_devdata *dd)
 
         dd->rcvhdrentsize = QIB_RCVHDR_ENTSIZE;
         dd->rcvhdrsize = QIB_DFLT_RCVHDRSIZE;
-        dd->rhf_offset =
-                dd->rcvhdrentsize - sizeof(u64) / sizeof(u32);
+        dd->rhf_offset = dd->rcvhdrentsize - sizeof(u64) / sizeof(u32);
 
         /* we always allocate at least 2048 bytes for eager buffers */
         dd->rcvegrbufsize = max(mtu, 2048);
@@ -6919,13 +6711,6 @@ struct qib_devdata *qib_init_iba7322_funcs(struct pci_dev *pdev,
         /* clear diagctrl register, in case diags were running and crashed */
         qib_write_kreg(dd, kr_hwdiagctrl, 0);
 
-#if defined(CONFIG_DCA) || defined(CONFIG_DCA_MODULE)
-        ret = dca_add_requester(&pdev->dev);
-        if (!ret) {
-                dd->flags |= QIB_DCA_ENABLED;
-                qib_setup_dca(dd);
-        }
-#endif
         goto bail;
 
 bail_cleanup:
@@ -7111,8 +6896,8 @@ static const struct txdds_ent txdds_ddr[TXDDS_TABLE_SZ] = {
 static const struct txdds_ent txdds_qdr[TXDDS_TABLE_SZ] = {
         /* amp, pre, main, post */
         {  2, 2, 15,  6 },      /* Loopback */
-        {  0, 1,  0,  7 },      /*  2 dB */
-        {  0, 1,  0,  9 },      /*  3 dB */
+        {  0, 1,  0,  7 },      /*  2 dB (also QMH7342) */
+        {  0, 1,  0,  9 },      /*  3 dB (also QMH7342) */
         {  0, 1,  0, 11 },      /*  4 dB */
         {  0, 1,  0, 13 },      /*  5 dB */
         {  0, 1,  0, 15 },      /*  6 dB */
@@ -7128,6 +6913,57 @@ static const struct txdds_ent txdds_qdr[TXDDS_TABLE_SZ] = {
         {  0, 2,  9, 15 },      /* 16 dB */
 };
 
+/*
+ * extra entries for use with txselect, for indices >= TXDDS_TABLE_SZ.
+ * These are mostly used for mez cards going through connectors
+ * and backplane traces, but can be used to add other "unusual"
+ * table values as well.
+ */
+static const struct txdds_ent txdds_extra_sdr[TXDDS_EXTRA_SZ] = {
+        /* amp, pre, main, post */
+        {  0, 0, 0,  1 },       /* QMH7342 backplane settings */
+        {  0, 0, 0,  1 },       /* QMH7342 backplane settings */
+        {  0, 0, 0,  2 },       /* QMH7342 backplane settings */
+        {  0, 0, 0,  2 },       /* QMH7342 backplane settings */
+        {  0, 0, 0, 11 },       /* QME7342 backplane settings */
+        {  0, 0, 0, 11 },       /* QME7342 backplane settings */
+        {  0, 0, 0, 11 },       /* QME7342 backplane settings */
+        {  0, 0, 0, 11 },       /* QME7342 backplane settings */
+        {  0, 0, 0, 11 },       /* QME7342 backplane settings */
+        {  0, 0, 0, 11 },       /* QME7342 backplane settings */
+        {  0, 0, 0, 11 },       /* QME7342 backplane settings */
+};
+
+static const struct txdds_ent txdds_extra_ddr[TXDDS_EXTRA_SZ] = {
+        /* amp, pre, main, post */
+        {  0, 0, 0,  7 },       /* QMH7342 backplane settings */
+        {  0, 0, 0,  7 },       /* QMH7342 backplane settings */
+        {  0, 0, 0,  8 },       /* QMH7342 backplane settings */
+        {  0, 0, 0,  8 },       /* QMH7342 backplane settings */
+        {  0, 0, 0, 13 },       /* QME7342 backplane settings */
+        {  0, 0, 0, 13 },       /* QME7342 backplane settings */
+        {  0, 0, 0, 13 },       /* QME7342 backplane settings */
+        {  0, 0, 0, 13 },       /* QME7342 backplane settings */
+        {  0, 0, 0, 13 },       /* QME7342 backplane settings */
+        {  0, 0, 0, 13 },       /* QME7342 backplane settings */
+        {  0, 0, 0, 13 },       /* QME7342 backplane settings */
+};
+
+static const struct txdds_ent txdds_extra_qdr[TXDDS_EXTRA_SZ] = {
+        /* amp, pre, main, post */
+        {  0, 1,  0,  4 },      /* QMH7342 backplane settings */
+        {  0, 1,  0,  5 },      /* QMH7342 backplane settings */
+        {  0, 1,  0,  6 },      /* QMH7342 backplane settings */
+        {  0, 1,  0,  8 },      /* QMH7342 backplane settings */
+        {  0, 1, 12, 10 },      /* QME7342 backplane setting */
+        {  0, 1, 12, 11 },      /* QME7342 backplane setting */
+        {  0, 1, 12, 12 },      /* QME7342 backplane setting */
+        {  0, 1, 12, 14 },      /* QME7342 backplane setting */
+        {  0, 1, 12,  6 },      /* QME7342 backplane setting */
+        {  0, 1, 12,  7 },      /* QME7342 backplane setting */
+        {  0, 1, 12,  8 },      /* QME7342 backplane setting */
+};
+
 static const struct txdds_ent *get_atten_table(const struct txdds_ent *txdds,
                                                unsigned atten)
 {
@@ -7145,7 +6981,7 @@ static const struct txdds_ent *get_atten_table(const struct txdds_ent *txdds,
 }
 
 /*
- * if override is set, the module parameter cable_atten has a value
+ * if override is set, the module parameter txselect has a value
  * for this specific port, so use it, rather than our normal mechanism.
  */
 static void find_best_ent(struct qib_pportdata *ppd,
@@ -7184,15 +7020,28 @@ static void find_best_ent(struct qib_pportdata *ppd,
                 *ddr_dds = get_atten_table(txdds_ddr, qd->atten[0]);
                 *qdr_dds = get_atten_table(txdds_qdr, qd->atten[1]);
                 return;
-        } else {
+        } else if (ppd->cpspec->no_eep < TXDDS_TABLE_SZ) {
                 /*
                  * If we have no (or incomplete) data from the cable
-                 * EEPROM, or no QSFP, use the module parameter value
-                 * to index into the attentuation table.
+                 * EEPROM, or no QSFP, or override is set, use the
+                 * module parameter value to index into the attentuation
+                 * table.
                  */
-                *sdr_dds = &txdds_sdr[ppd->cpspec->no_eep];
-                *ddr_dds = &txdds_ddr[ppd->cpspec->no_eep];
-                *qdr_dds = &txdds_qdr[ppd->cpspec->no_eep];
+                idx = ppd->cpspec->no_eep;
+                *sdr_dds = &txdds_sdr[idx];
+                *ddr_dds = &txdds_ddr[idx];
+                *qdr_dds = &txdds_qdr[idx];
+        } else if (ppd->cpspec->no_eep < (TXDDS_TABLE_SZ + TXDDS_EXTRA_SZ)) {
+                /* similar to above, but index into the "extra" table. */
+                idx = ppd->cpspec->no_eep - TXDDS_TABLE_SZ;
+                *sdr_dds = &txdds_extra_sdr[idx];
+                *ddr_dds = &txdds_extra_ddr[idx];
+                *qdr_dds = &txdds_extra_qdr[idx];
+        } else {
+                /* this shouldn't happen, it's range checked */
+                *sdr_dds = txdds_sdr + qib_long_atten;
+                *ddr_dds = txdds_ddr + qib_long_atten;
+                *qdr_dds = txdds_qdr + qib_long_atten;
         }
 }
 
@@ -7203,33 +7052,24 @@ static void init_txdds_table(struct qib_pportdata *ppd, int override)
         int idx;
         int single_ent = 0;
 
-        if (IS_QMH(ppd->dd)) {
-                /* normally will be overridden, via setup_qmh() */
-                sdr_dds = &qmh_sdr_txdds;
-                ddr_dds = &qmh_ddr_txdds;
-                qdr_dds = &qmh_qdr_txdds;
-                single_ent = 1;
-        } else if (IS_QME(ppd->dd)) {
-                sdr_dds = &qme_sdr_txdds;
-                ddr_dds = &qme_ddr_txdds;
-                qdr_dds = &qme_qdr_txdds;
+        find_best_ent(ppd, &sdr_dds, &ddr_dds, &qdr_dds, override);
+
+        /* for mez cards or override, use the selected value for all entries */
+        if (!(ppd->dd->flags & QIB_HAS_QSFP) || override)
                 single_ent = 1;
-        } else
-                find_best_ent(ppd, &sdr_dds, &ddr_dds, &qdr_dds, override);
 
         /* Fill in the first entry with the best entry found. */
         set_txdds(ppd, 0, sdr_dds);
         set_txdds(ppd, TXDDS_TABLE_SZ, ddr_dds);
         set_txdds(ppd, 2 * TXDDS_TABLE_SZ, qdr_dds);
-
-        /*
-         * for our current speed, also write that value into the
-         * tx serdes registers.
-         */
-        dds = (struct txdds_ent *)(ppd->link_speed_active == QIB_IB_QDR ?
-                                   qdr_dds : (ppd->link_speed_active ==
-                                              QIB_IB_DDR ? ddr_dds : sdr_dds));
-        write_tx_serdes_param(ppd, dds);
+        if (ppd->lflags & (QIBL_LINKINIT | QIBL_LINKARMED |
+                QIBL_LINKACTIVE)) {
+                dds = (struct txdds_ent *)(ppd->link_speed_active ==
+                                           QIB_IB_QDR ?  qdr_dds :
+                                           (ppd->link_speed_active ==
+                                            QIB_IB_DDR ? ddr_dds : sdr_dds));
+                write_tx_serdes_param(ppd, dds);
+        }
 
         /* Fill in the remaining entries with the default table values. */
         for (idx = 1; idx < ARRAY_SIZE(txdds_sdr); ++idx) {
@@ -7352,6 +7192,11 @@ static int serdes_7322_init(struct qib_pportdata *ppd)
          */
         init_txdds_table(ppd, 0);
 
+        /* ensure no tx overrides from earlier driver loads */
+        qib_write_kreg_port(ppd, krp_tx_deemph_override,
+                SYM_MASK(IBSD_TX_DEEMPHASIS_OVERRIDE_0,
+                reset_tx_deemphasis_override));
+
         /* Patch some SerDes defaults to "Better for IB" */
         /* Timing Loop Bandwidth: cdr_timing[11:9] = 0 */
         ibsd_wr_allchans(ppd, 2, 0, BMASK(11, 9));
@@ -7421,7 +7266,7 @@ static int serdes_7322_init(struct qib_pportdata *ppd)
                             QDR_STATIC_ADAPT_DOWN_R1 : QDR_STATIC_ADAPT_DOWN);
         ppd->cpspec->qdr_dfe_on = 1;
 
-        /* (FLoop LOS gate: PPM filter  enabled */
+        /* FLoop LOS gate: PPM filter  enabled */
         ibsd_wr_allchans(ppd, 38, 0 << 10, 1 << 10);
 
         /* rx offset center enabled */
@@ -7486,68 +7331,39 @@ static void write_tx_serdes_param(struct qib_pportdata *ppd,
                     SYM_MASK(IBSD_TX_DEEMPHASIS_OVERRIDE_0, txc0_ena) |
                     SYM_MASK(IBSD_TX_DEEMPHASIS_OVERRIDE_0, txcp1_ena) |
                     SYM_MASK(IBSD_TX_DEEMPHASIS_OVERRIDE_0, txcn1_ena));
-        deemph |= 1ULL << SYM_LSB(IBSD_TX_DEEMPHASIS_OVERRIDE_0,
-                                  tx_override_deemphasis_select);
-        deemph |= txdds->amp << SYM_LSB(IBSD_TX_DEEMPHASIS_OVERRIDE_0,
-                                    txampcntl_d2a);
-        deemph |= txdds->main << SYM_LSB(IBSD_TX_DEEMPHASIS_OVERRIDE_0,
-                                      txc0_ena);
-        deemph |= txdds->post << SYM_LSB(IBSD_TX_DEEMPHASIS_OVERRIDE_0,
-                                     txcp1_ena);
-        deemph |= txdds->pre << SYM_LSB(IBSD_TX_DEEMPHASIS_OVERRIDE_0,
+
+        deemph |= SYM_MASK(IBSD_TX_DEEMPHASIS_OVERRIDE_0,
+                           tx_override_deemphasis_select);
+        deemph |= (txdds->amp & SYM_RMASK(IBSD_TX_DEEMPHASIS_OVERRIDE_0,
+                    txampcntl_d2a)) << SYM_LSB(IBSD_TX_DEEMPHASIS_OVERRIDE_0,
+                                       txampcntl_d2a);
+        deemph |= (txdds->main & SYM_RMASK(IBSD_TX_DEEMPHASIS_OVERRIDE_0,
+                     txc0_ena)) << SYM_LSB(IBSD_TX_DEEMPHASIS_OVERRIDE_0,
+                                   txc0_ena);
+        deemph |= (txdds->post & SYM_RMASK(IBSD_TX_DEEMPHASIS_OVERRIDE_0,
+                     txcp1_ena)) << SYM_LSB(IBSD_TX_DEEMPHASIS_OVERRIDE_0,
+                                    txcp1_ena);
+        deemph |= (txdds->pre & SYM_RMASK(IBSD_TX_DEEMPHASIS_OVERRIDE_0,
+                     txcn1_ena)) << SYM_LSB(IBSD_TX_DEEMPHASIS_OVERRIDE_0,
                                     txcn1_ena);
         qib_write_kreg_port(ppd, krp_tx_deemph_override, deemph);
 }
 
 /*
- * set per-bay, per channel parameters.  For now, we ignore
- * do_tx, and always set tx parameters, and set them with the same value
- * for all channels, using the channel 0 value.   We may switch to
- * per-channel settings in the future, and that method only needs
- * to be done once.
- * Because this also writes the IBC txdds table with a single set
- * of values, it should be called only for cases where we want to completely
- * force a specific setting, typically only for mez cards.
+ * Set the parameters for mez cards on link bounce, so they are
+ * always exactly what was requested.  Similar logic to init_txdds
+ * but does just the serdes.
  */
 static void adj_tx_serdes(struct qib_pportdata *ppd)
 {
-        struct txdds_ent txdds;
-        int i;
-        u8 *amp, *pre, *mainv, *post;
-
-        /*
-         * Because we use TX_DEEMPHASIS_OVERRIDE, we need to
-         * always do tx side, just like H1, since it is cleared
-         * by link down
-         */
-        amp = ppd->cpspec->amp;
-        pre = ppd->cpspec->pre;
-        mainv = ppd->cpspec->mainv;
-        post = ppd->cpspec->post;
-
-        amp[0] &= SYM_RMASK(IBSD_TX_DEEMPHASIS_OVERRIDE_0,
-                            txampcntl_d2a);
-        mainv[0] &= SYM_RMASK(IBSD_TX_DEEMPHASIS_OVERRIDE_0,
-                              txc0_ena);
-        post[0] &= SYM_RMASK(IBSD_TX_DEEMPHASIS_OVERRIDE_0,
-                             txcp1_ena);
-        pre[0] &= SYM_RMASK(IBSD_TX_DEEMPHASIS_OVERRIDE_0,
-                            txcn1_ena);
-
-        /*
-         * Use the channel zero values, only, for now, for
-         * all channels
-        */
-        txdds.amp = amp[0];
-        txdds.pre = pre[0];
-        txdds.main = mainv[0];
-        txdds.post = post[0];
-
-        /* write the QDR table for IBC use, as backup for link down */
-        for (i = 0; i < ARRAY_SIZE(txdds_qdr); ++i)
-                set_txdds(ppd, i + 32, &txdds);
+        const struct txdds_ent *sdr_dds, *ddr_dds, *qdr_dds;
+        struct txdds_ent *dds;
 
-        write_tx_serdes_param(ppd, &txdds);
+        find_best_ent(ppd, &sdr_dds, &ddr_dds, &qdr_dds, 1);
+        dds = (struct txdds_ent *)(ppd->link_speed_active == QIB_IB_QDR ?
+                qdr_dds : (ppd->link_speed_active == QIB_IB_DDR ?
+                                ddr_dds : sdr_dds));
+        write_tx_serdes_param(ppd, dds);
 }
 
 /* set QDR forced value for H1, if needed */
@@ -7567,235 +7383,6 @@ static void force_h1(struct qib_pportdata *ppd)
         }
 }
 
-/*
- * Parse the parameters for the QMH7342, to get rx and tx serdes
- * settings for that Bay, for both possible mez connectors (PCIe bus)
- * and IB link (one link on mez1, two possible on mez2).
- *
- * Data is comma or white space separated.
- *
- * A set of data has 7 groups, rx and tx groups have SERDES_CHANS values,
- * one per IB lane (serdes channel).
- * The groups are Bay, bus# H1 rcv, and amp, pre, post, main Tx values (QDR).
- * The Bay # is used only for debugging currently.
- * H1 values are set whenever the link goes down, or is at cfg_test or
- * cfg_wait_enh.  Tx values are programmed once, when this routine is called
- * (and with default values at chip initialization).  Values are any base, in
- * strtoul style, and values are seperated by comma, or any white space
- * (space, tab, newline).
- *
- * An example set might look like this (white space vs
- * comma used for human ease of reading)
- * The ordering is a set of Bay# Bus# H1, amp, pre, post, and main for mez1 IB1,
- * repeat for mez2 IB1, then mez2 IB2.
- *
- * B B H1:0       amp:0       pre:0        post: 0        main:0
- * a u H1:  1     amp:  1     pre:  1      post:   1      main:  1
- * y s H1:    2   amp:    2   pre:    2    post:      2   main:    2
- *     H1:      4 amp:      3 pre:      3  post:        3 main:      3
- * 1 3    8,6,5,6     0,0,0,0     1,1,1,1       10,10,10,10    3,3,3,3
- * 1 6    7,6,6,7     0,0,0,0     1,1,1,1       10,10,10,10    3,3,3,3
- * 1 6    9,7,7,8     0,0,0,0     1,1,1,1       10,10,10,10    3,3,3,3
- */
-#define N_QMH_FIELDS 22
-static int setup_qmh_params(const char *str, struct kernel_param *kp)
-{
-        char *abuf, *v, *nv, *nvp;
-        struct qib_devdata *dd;
-        struct qib_pportdata *ppd;
-        u32 mez, vlen, nf, port, bay;
-        int ret = 0, found = 0;
-
-        vlen = strlen(str) + 1;
-        abuf = kmalloc(vlen, GFP_KERNEL);
-        if (!abuf) {
-                printk(KERN_INFO QIB_DRV_NAME
-                       " Unable to allocate QMH param buffer; ignoring\n");
-                return 0;
-        }
-        memcpy(abuf, str, vlen);
-        v = abuf;
-
-        /* these 3 are because gcc can't know they are set before used */
-        port = 1;
-        mez = 1; /* used only for debugging */
-        bay = 0; /* used only for debugging */
-        ppd = NULL;
-        for (nf = 0; (nv = strsep(&v, ", \t\n\r")) &&
-             nf < (N_QMH_FIELDS * 3);) {
-                u32 val;
-
-                if (!*nv)
-                        /* allow for multiple separators */
-                        continue;
-
-                val = simple_strtoul(nv, &nvp, 0);
-                if (nv == nvp) {
-                        printk(KERN_INFO QIB_DRV_NAME
-                               " Bay%u, mez%u IB%u non-numeric value (%s) "
-                               "field #%u, ignoring rest\n", bay, mez,
-                               port, nv, nf % (N_QMH_FIELDS * 3));
-                        ret = -EINVAL;
-                        goto bail;
-                }
-                if (!(nf % N_QMH_FIELDS)) {
-                        ppd = NULL;
-                        bay = val;
-                        if (!bay || bay > 16) {
-                                printk(KERN_INFO QIB_DRV_NAME
-                                       " Invalid bay # %u, field %u, "
-                                       "ignoring rest\n", bay, nf);
-                                ret = -EINVAL;
-                                goto bail;
-                        }
-                } else if ((nf % N_QMH_FIELDS) == 1) {
-                        u32 bus = val;
-                        if (nf == 1) {
-                                mez = 1;
-                                port = 1;
-                        } else if (nf == (N_QMH_FIELDS + 1)) {
-                                mez = 2;
-                                port = 1;
-                        } else {
-                                mez = 2;
-                                port = 2;
-                        }
-                        list_for_each_entry(dd, &qib_dev_list, list) {
-                                if (dd->deviceid != PCI_DEVICE_ID_QLOGIC_IB_7322
-                                    || !IS_QMH(dd))
-                                        continue; /* only for QMH cards */
-                                if (dd->pcidev->bus->number == bus) {
-                                        found++;
-                                        ppd = &dd->pport[port - 1];
-                                }
-                        }
-                } else if (ppd) {
-                        u32 parm = (nf % N_QMH_FIELDS) - 2;
-                        if (parm < SERDES_CHANS && !(parm % SERDES_CHANS))
-                                ppd->cpspec->h1_val = val;
-                        else if (parm < (2 * SERDES_CHANS))
-                                ppd->cpspec->amp[parm % SERDES_CHANS] = val;
-                        else if (parm < (3 * SERDES_CHANS))
-                                ppd->cpspec->pre[parm % SERDES_CHANS] = val;
-                        else if (parm < (4 * SERDES_CHANS))
-                                ppd->cpspec->post[parm % SERDES_CHANS] = val;
-                        else {
-                                ppd->cpspec->mainv[parm % SERDES_CHANS] = val;
-                                /* At the end of a port, set params */
-                                if (parm == ((5 * SERDES_CHANS) - 1))
-                                        adj_tx_serdes(ppd);
-                        }
-                }
-                nf++;
-        }
-        if (!found) {
-                printk(KERN_ERR QIB_DRV_NAME
-                       ": No match found for qmh_serdes_setup parameter\n");
-                ret = -EINVAL;
-        }
-bail:
-        kfree(abuf);
-        return ret;
-}
-
-/*
- * Similarly for QME7342, but the format is simpler, values are the
- * same for all mez card positions in a blade (2 or 4 per blade), but
- * are different for some blades vs others, and we don't need to
- * specify different parameters for different serdes channels or different
- * IB ports.
- * Format is: h1 amp,pre,post,main
- * Alternate format (so ports can be different): Pport# h1 amp,pre,post,main
- */
-#define N_QME_FIELDS 5
-static int setup_qme_params(const char *str, struct kernel_param *kp)
-{
-        char *abuf, *v, *nv, *nvp;
-        struct qib_devdata *dd;
-        u32 vlen, nf, port = 0;
-        u8 h1, tx[4]; /* amp, pre, post, main */
-        int ret =  -EINVAL;
-        char *seplist;
-
-        vlen = strlen(str) + 1;
-        abuf = kmalloc(vlen, GFP_KERNEL);
-        if (!abuf) {
-                printk(KERN_INFO QIB_DRV_NAME
-                       " Unable to allocate QME param buffer; ignoring\n");
-                return 0;
-        }
-        strncpy(abuf, str, vlen);
-
-        v = abuf;
-        seplist = " \t";
-        h1 = H1_FORCE_QME; /* gcc can't figure out always set before used */
-
-        for (nf = 0; (nv = strsep(&v, seplist)); ) {
-                u32 val;
-
-                if (!*nv)
-                        /* allow for multiple separators */
-                        continue;
-
-                if (!nf && *nv == 'P') {
-                        /* alternate format with port */
-                        val = simple_strtoul(++nv, &nvp, 0);
-                        if (nv == nvp || port >= NUM_IB_PORTS) {
-                                printk(KERN_INFO QIB_DRV_NAME
-                                       " %s: non-numeric port value (%s) "
-                                       "ignoring rest\n", __func__, nv);
-                                goto done;
-                        }
-                        port = val;
-                        continue; /* without incrementing nf */
-                }
-                val = simple_strtoul(nv, &nvp, 0);
-                if (nv == nvp) {
-                        printk(KERN_INFO QIB_DRV_NAME
-                               " %s: non-numeric value (%s) "
-                               "field #%u, ignoring rest\n", __func__,
-                               nv, nf);
-                        goto done;
-                }
-                if (!nf) {
-                        h1 = val;
-                        seplist = ",";
-                } else
-                        tx[nf - 1] = val;
-                if (++nf == N_QME_FIELDS) {
-                        list_for_each_entry(dd, &qib_dev_list, list) {
-                                int pidx, i;
-                                if (dd->deviceid != PCI_DEVICE_ID_QLOGIC_IB_7322
-                                    || !IS_QME(dd))
-                                        continue; /* only for QME cards */
-                                for (pidx = 0; pidx < dd->num_pports; ++pidx) {
-                                        struct qib_pportdata *ppd;
-                                        ppd = &dd->pport[pidx];
-                                        if ((port && ppd->port != port) ||
-                                                !ppd->link_speed_supported)
-                                                continue;
-                                        ppd->cpspec->h1_val = h1;
-                                        for (i = 0; i < SERDES_CHANS; i++) {
-                                                ppd->cpspec->amp[i] = tx[0];
-                                                ppd->cpspec->pre[i] = tx[1];
-                                                ppd->cpspec->post[i] = tx[2];
-                                                ppd->cpspec->mainv[i] = tx[3];
-                                        }
-                                        adj_tx_serdes(ppd);
-                                }
-                        }
-                        ret = 0;
-                        goto done;
-                }
-        }
-        printk(KERN_INFO QIB_DRV_NAME
-               " %s: Only %u of %u fields provided, skipping\n",
-               __func__, nf, N_QME_FIELDS);
-done:
-        kfree(abuf);
-        return ret;
-}
-
 #define SJA_EN SYM_MASK(SPC_JTAG_ACCESS_REG, SPC_JTAG_ACCESS_EN)
 #define BISTEN_LSB SYM_LSB(SPC_JTAG_ACCESS_REG, bist_en)
 
diff --git a/drivers/infiniband/hw/qib/qib_init.c b/drivers/infiniband/hw/qib/qib_init.c
index c0139c07e97e..9b40f345ac3f 100644
--- a/drivers/infiniband/hw/qib/qib_init.c
+++ b/drivers/infiniband/hw/qib/qib_init.c
@@ -1237,7 +1237,13 @@ static int __devinit qib_init_one(struct pci_dev *pdev,
          */
         switch (ent->device) {
         case PCI_DEVICE_ID_QLOGIC_IB_6120:
+#ifdef CONFIG_PCI_MSI
                 dd = qib_init_iba6120_funcs(pdev, ent);
+#else
+                qib_early_err(&pdev->dev, "QLogic PCIE device 0x%x cannot "
+                      "work if CONFIG_PCI_MSI is not enabled\n",
+                      ent->device);
+#endif
                 break;
 
         case PCI_DEVICE_ID_QLOGIC_IB_7220:
diff --git a/drivers/input/joydev.c b/drivers/input/joydev.c
index 423e0e6031ab..34157bb97ed6 100644
--- a/drivers/input/joydev.c
+++ b/drivers/input/joydev.c
@@ -47,15 +47,15 @@ struct joydev {
         struct mutex mutex;
         struct device dev;
 
-        struct js_corr corr[ABS_MAX + 1];
+        struct js_corr corr[ABS_CNT];
         struct JS_DATA_SAVE_TYPE glue;
         int nabs;
         int nkey;
         __u16 keymap[KEY_MAX - BTN_MISC + 1];
         __u16 keypam[KEY_MAX - BTN_MISC + 1];
-        __u8 absmap[ABS_MAX + 1];
-        __u8 abspam[ABS_MAX + 1];
-        __s16 abs[ABS_MAX + 1];
+        __u8 absmap[ABS_CNT];
+        __u8 abspam[ABS_CNT];
+        __s16 abs[ABS_CNT];
 };
 
 struct joydev_client {
@@ -826,7 +826,7 @@ static int joydev_connect(struct input_handler *handler, struct input_dev *dev,
         joydev->handle.handler = handler;
         joydev->handle.private = joydev;
 
-        for (i = 0; i < ABS_MAX + 1; i++)
+        for (i = 0; i < ABS_CNT; i++)
                 if (test_bit(i, dev->absbit)) {
                         joydev->absmap[i] = joydev->nabs;
                         joydev->abspam[joydev->nabs] = i;
diff --git a/drivers/input/keyboard/amikbd.c b/drivers/input/keyboard/amikbd.c
index 35149ec455a9..79172af164f2 100644
--- a/drivers/input/keyboard/amikbd.c
+++ b/drivers/input/keyboard/amikbd.c
@@ -35,6 +35,7 @@
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/keyboard.h>
+#include <linux/platform_device.h>
 
 #include <asm/amigaints.h>
 #include <asm/amigahw.h>
@@ -154,10 +155,9 @@ static const char *amikbd_messages[8] = {
         [7] = KERN_WARNING "amikbd: keyboard interrupt\n"
 };
 
-static struct input_dev *amikbd_dev;
-
-static irqreturn_t amikbd_interrupt(int irq, void *dummy)
+static irqreturn_t amikbd_interrupt(int irq, void *data)
 {
+        struct input_dev *dev = data;
         unsigned char scancode, down;
 
         scancode = ~ciaa.sdr;           /* get and invert scancode (keyboard is active low) */
@@ -170,47 +170,42 @@ static irqreturn_t amikbd_interrupt(int irq, void *dummy)
 
         if (scancode < 0x78) {          /* scancodes < 0x78 are keys */
                 if (scancode == 98) {   /* CapsLock is a toggle switch key on Amiga */
-                        input_report_key(amikbd_dev, scancode, 1);
-                        input_report_key(amikbd_dev, scancode, 0);
+                        input_report_key(dev, scancode, 1);
+                        input_report_key(dev, scancode, 0);
                 } else {
-                        input_report_key(amikbd_dev, scancode, down);
+                        input_report_key(dev, scancode, down);
                 }
 
-                input_sync(amikbd_dev);
+                input_sync(dev);
         } else                          /* scancodes >= 0x78 are error codes */
                 printk(amikbd_messages[scancode - 0x78]);
 
         return IRQ_HANDLED;
 }
 
-static int __init amikbd_init(void)
+static int __init amikbd_probe(struct platform_device *pdev)
 {
+        struct input_dev *dev;
         int i, j, err;
 
-        if (!AMIGAHW_PRESENT(AMI_KEYBOARD))
-                return -ENODEV;
-
-        if (!request_mem_region(CIAA_PHYSADDR-1+0xb00, 0x100, "amikeyb"))
-                return -EBUSY;
-
-        amikbd_dev = input_allocate_device();
-        if (!amikbd_dev) {
-                printk(KERN_ERR "amikbd: not enough memory for input device\n");
-                err = -ENOMEM;
-                goto fail1;
+        dev = input_allocate_device();
+        if (!dev) {
+                dev_err(&pdev->dev, "Not enough memory for input device\n");
+                return -ENOMEM;
         }
 
-        amikbd_dev->name = "Amiga Keyboard";
-        amikbd_dev->phys = "amikbd/input0";
-        amikbd_dev->id.bustype = BUS_AMIGA;
-        amikbd_dev->id.vendor = 0x0001;
-        amikbd_dev->id.product = 0x0001;
-        amikbd_dev->id.version = 0x0100;
+        dev->name = pdev->name;
+        dev->phys = "amikbd/input0";
+        dev->id.bustype = BUS_AMIGA;
+        dev->id.vendor = 0x0001;
+        dev->id.product = 0x0001;
+        dev->id.version = 0x0100;
+        dev->dev.parent = &pdev->dev;
 
-        amikbd_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP);
+        dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP);
 
         for (i = 0; i < 0x78; i++)
-                set_bit(i, amikbd_dev->keybit);
+                set_bit(i, dev->keybit);
 
         for (i = 0; i < MAX_NR_KEYMAPS; i++) {
                 static u_short temp_map[NR_KEYS] __initdata;
@@ -229,30 +224,54 @@ static int __init amikbd_init(void)
                 memcpy(key_maps[i], temp_map, sizeof(temp_map));
         }
         ciaa.cra &= ~0x41;       /* serial data in, turn off TA */
-        if (request_irq(IRQ_AMIGA_CIAA_SP, amikbd_interrupt, 0, "amikbd",
-                        amikbd_interrupt)) {
-                err = -EBUSY;
+        err = request_irq(IRQ_AMIGA_CIAA_SP, amikbd_interrupt, 0, "amikbd",
+                          dev);
+        if (err)
                 goto fail2;
-        }
 
-        err = input_register_device(amikbd_dev);
+        err = input_register_device(dev);
         if (err)
                 goto fail3;
 
+        platform_set_drvdata(pdev, dev);
+
         return 0;
 
- fail3: free_irq(IRQ_AMIGA_CIAA_SP, amikbd_interrupt);
- fail2: input_free_device(amikbd_dev);
- fail1: release_mem_region(CIAA_PHYSADDR - 1 + 0xb00, 0x100);
+ fail3: free_irq(IRQ_AMIGA_CIAA_SP, dev);
+ fail2: input_free_device(dev);
         return err;
 }
 
-static void __exit amikbd_exit(void)
+static int __exit amikbd_remove(struct platform_device *pdev)
+{
+        struct input_dev *dev = platform_get_drvdata(pdev);
+
+        platform_set_drvdata(pdev, NULL);
+        free_irq(IRQ_AMIGA_CIAA_SP, dev);
+        input_unregister_device(dev);
+        return 0;
+}
+
+static struct platform_driver amikbd_driver = {
+        .remove = __exit_p(amikbd_remove),
+        .driver   = {
+                .name   = "amiga-keyboard",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init amikbd_init(void)
 {
-        free_irq(IRQ_AMIGA_CIAA_SP, amikbd_interrupt);
-        input_unregister_device(amikbd_dev);
-        release_mem_region(CIAA_PHYSADDR - 1 + 0xb00, 0x100);
+        return platform_driver_probe(&amikbd_driver, amikbd_probe);
 }
 
 module_init(amikbd_init);
+
+static void __exit amikbd_exit(void)
+{
+        platform_driver_unregister(&amikbd_driver);
+}
+
 module_exit(amikbd_exit);
+
+MODULE_ALIAS("platform:amiga-keyboard");
diff --git a/drivers/input/misc/Kconfig b/drivers/input/misc/Kconfig
index 48cdabec372a..c44b9eafc556 100644
--- a/drivers/input/misc/Kconfig
+++ b/drivers/input/misc/Kconfig
@@ -80,6 +80,16 @@ config INPUT_M68K_BEEP
         tristate "M68k Beeper support"
         depends on M68K
 
+config INPUT_MAX8925_ONKEY
+        tristate "MAX8925 ONKEY support"
+        depends on MFD_MAX8925
+        help
+          Support the ONKEY of MAX8925 PMICs as an input device
+          reporting power button status.
+
+          To compile this driver as a module, choose M here: the module
+          will be called max8925_onkey.
+
 config INPUT_APANEL
         tristate "Fujitsu Lifebook Application Panel buttons"
         depends on X86 && I2C && LEDS_CLASS
diff --git a/drivers/input/misc/Makefile b/drivers/input/misc/Makefile
index f9f577031e06..71fe57d8023f 100644
--- a/drivers/input/misc/Makefile
+++ b/drivers/input/misc/Makefile
@@ -20,6 +20,7 @@ obj-$(CONFIG_HP_SDC_RTC)		+= hp_sdc_rtc.o
 obj-$(CONFIG_INPUT_IXP4XX_BEEPER)       += ixp4xx-beeper.o
 obj-$(CONFIG_INPUT_KEYSPAN_REMOTE)      += keyspan_remote.o
 obj-$(CONFIG_INPUT_M68K_BEEP)           += m68kspkr.o
+obj-$(CONFIG_INPUT_MAX8925_ONKEY)       += max8925_onkey.o
 obj-$(CONFIG_INPUT_PCAP)                += pcap_keys.o
 obj-$(CONFIG_INPUT_PCF50633_PMU)        += pcf50633-input.o
 obj-$(CONFIG_INPUT_PCF8574)             += pcf8574_keypad.o
diff --git a/drivers/input/misc/max8925_onkey.c b/drivers/input/misc/max8925_onkey.c
new file mode 100644
index 000000000000..80af44608018
--- /dev/null
+++ b/drivers/input/misc/max8925_onkey.c
@@ -0,0 +1,148 @@
+/**
+ * max8925_onkey.c - MAX8925 ONKEY driver
+ *
+ * Copyright (C) 2009 Marvell International Ltd.
+ *      Haojian Zhuang <haojian.zhuang@marvell.com>
+ *
+ * This file is subject to the terms and conditions of the GNU General
+ * Public License. See the file "COPYING" in the main directory of this
+ * archive for more details.
+ *
+ * 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/platform_device.h>
+#include <linux/i2c.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/mfd/max8925.h>
+#include <linux/slab.h>
+
+#define HARDRESET_EN            (1 << 7)
+#define PWREN_EN                (1 << 7)
+
+struct max8925_onkey_info {
+        struct input_dev        *idev;
+        struct i2c_client       *i2c;
+        int                     irq;
+};
+
+/*
+ * MAX8925 gives us an interrupt when ONKEY is held for 3 seconds.
+ * max8925_set_bits() operates I2C bus and may sleep. So implement
+ * it in thread IRQ handler.
+ */
+static irqreturn_t max8925_onkey_handler(int irq, void *data)
+{
+        struct max8925_onkey_info *info = data;
+
+        input_report_key(info->idev, KEY_POWER, 1);
+        input_sync(info->idev);
+
+        /* Enable hardreset to halt if system isn't shutdown on time */
+        max8925_set_bits(info->i2c, MAX8925_SYSENSEL,
+                         HARDRESET_EN, HARDRESET_EN);
+
+        return IRQ_HANDLED;
+}
+
+static int __devinit max8925_onkey_probe(struct platform_device *pdev)
+{
+        struct max8925_chip *chip = dev_get_drvdata(pdev->dev.parent);
+        struct max8925_onkey_info *info;
+        int error;
+
+        info = kzalloc(sizeof(struct max8925_onkey_info), GFP_KERNEL);
+        if (!info)
+                return -ENOMEM;
+
+        info->i2c = chip->i2c;
+        info->irq = chip->irq_base + MAX8925_IRQ_GPM_SW_3SEC;
+
+        info->idev = input_allocate_device();
+        if (!info->idev) {
+                dev_err(chip->dev, "Failed to allocate input dev\n");
+                error = -ENOMEM;
+                goto out_input;
+        }
+
+        info->idev->name = "max8925_on";
+        info->idev->phys = "max8925_on/input0";
+        info->idev->id.bustype = BUS_I2C;
+        info->idev->dev.parent = &pdev->dev;
+        info->idev->evbit[0] = BIT_MASK(EV_KEY);
+        info->idev->keybit[BIT_WORD(KEY_POWER)] = BIT_MASK(KEY_POWER);
+
+        error = request_threaded_irq(info->irq, NULL, max8925_onkey_handler,
+                                     IRQF_ONESHOT, "onkey", info);
+        if (error < 0) {
+                dev_err(chip->dev, "Failed to request IRQ: #%d: %d\n",
+                        info->irq, error);
+                goto out_irq;
+        }
+
+        error = input_register_device(info->idev);
+        if (error) {
+                dev_err(chip->dev, "Can't register input device: %d\n", error);
+                goto out;
+        }
+
+        platform_set_drvdata(pdev, info);
+
+        return 0;
+
+out:
+        free_irq(info->irq, info);
+out_irq:
+        input_free_device(info->idev);
+out_input:
+        kfree(info);
+        return error;
+}
+
+static int __devexit max8925_onkey_remove(struct platform_device *pdev)
+{
+        struct max8925_onkey_info *info = platform_get_drvdata(pdev);
+
+        free_irq(info->irq, info);
+        input_unregister_device(info->idev);
+        kfree(info);
+
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
+}
+
+static struct platform_driver max8925_onkey_driver = {
+        .driver         = {
+                .name   = "max8925-onkey",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = max8925_onkey_probe,
+        .remove         = __devexit_p(max8925_onkey_remove),
+};
+
+static int __init max8925_onkey_init(void)
+{
+        return platform_driver_register(&max8925_onkey_driver);
+}
+module_init(max8925_onkey_init);
+
+static void __exit max8925_onkey_exit(void)
+{
+        platform_driver_unregister(&max8925_onkey_driver);
+}
+module_exit(max8925_onkey_exit);
+
+MODULE_DESCRIPTION("Maxim MAX8925 ONKEY driver");
+MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/twl4030-vibra.c b/drivers/input/misc/twl4030-vibra.c
index fee9eac8e04a..4f9b2afc24e8 100644
--- a/drivers/input/misc/twl4030-vibra.c
+++ b/drivers/input/misc/twl4030-vibra.c
@@ -90,8 +90,8 @@ static void vibra_disable(struct vibra_info *info)
         twl_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE,
                          (reg & ~TWL4030_VIBRA_EN), TWL4030_REG_VIBRA_CTL);
 
-        twl4030_codec_disable_resource(TWL4030_CODEC_RES_POWER);
         twl4030_codec_disable_resource(TWL4030_CODEC_RES_APLL);
+        twl4030_codec_disable_resource(TWL4030_CODEC_RES_POWER);
 
         info->enabled = false;
 }
diff --git a/drivers/input/misc/uinput.c b/drivers/input/misc/uinput.c
index 1477466076ad..b71eb55f2dbc 100644
--- a/drivers/input/misc/uinput.c
+++ b/drivers/input/misc/uinput.c
@@ -300,7 +300,7 @@ static int uinput_validate_absbits(struct input_dev *dev)
         unsigned int cnt;
         int retval = 0;
 
-        for (cnt = 0; cnt < ABS_MAX + 1; cnt++) {
+        for (cnt = 0; cnt < ABS_CNT; cnt++) {
                 if (!test_bit(cnt, dev->absbit))
                         continue;
 
@@ -387,7 +387,7 @@ static int uinput_setup_device(struct uinput_device *udev, const char __user *bu
         dev->id.product = user_dev->id.product;
         dev->id.version = user_dev->id.version;
 
-        size = sizeof(int) * (ABS_MAX + 1);
+        size = sizeof(int) * ABS_CNT;
         memcpy(dev->absmax, user_dev->absmax, size);
         memcpy(dev->absmin, user_dev->absmin, size);
         memcpy(dev->absfuzz, user_dev->absfuzz, size);
diff --git a/drivers/input/mouse/amimouse.c b/drivers/input/mouse/amimouse.c
index a185ac78a42c..ff5f61a0fd3a 100644
--- a/drivers/input/mouse/amimouse.c
+++ b/drivers/input/mouse/amimouse.c
@@ -21,6 +21,7 @@
 #include <linux/init.h>
 #include <linux/input.h>
 #include <linux/interrupt.h>
+#include <linux/platform_device.h>
 
 #include <asm/irq.h>
 #include <asm/setup.h>
@@ -34,10 +35,10 @@ MODULE_DESCRIPTION("Amiga mouse driver");
 MODULE_LICENSE("GPL");
 
 static int amimouse_lastx, amimouse_lasty;
-static struct input_dev *amimouse_dev;
 
-static irqreturn_t amimouse_interrupt(int irq, void *dummy)
+static irqreturn_t amimouse_interrupt(int irq, void *data)
 {
+        struct input_dev *dev = data;
         unsigned short joy0dat, potgor;
         int nx, ny, dx, dy;
 
@@ -59,14 +60,14 @@ static irqreturn_t amimouse_interrupt(int irq, void *dummy)
 
         potgor = amiga_custom.potgor;
 
-        input_report_rel(amimouse_dev, REL_X, dx);
-        input_report_rel(amimouse_dev, REL_Y, dy);
+        input_report_rel(dev, REL_X, dx);
+        input_report_rel(dev, REL_Y, dy);
 
-        input_report_key(amimouse_dev, BTN_LEFT,   ciaa.pra & 0x40);
-        input_report_key(amimouse_dev, BTN_MIDDLE, potgor & 0x0100);
-        input_report_key(amimouse_dev, BTN_RIGHT,  potgor & 0x0400);
+        input_report_key(dev, BTN_LEFT,   ciaa.pra & 0x40);
+        input_report_key(dev, BTN_MIDDLE, potgor & 0x0100);
+        input_report_key(dev, BTN_RIGHT,  potgor & 0x0400);
 
-        input_sync(amimouse_dev);
+        input_sync(dev);
 
         return IRQ_HANDLED;
 }
@@ -74,63 +75,90 @@ static irqreturn_t amimouse_interrupt(int irq, void *dummy)
 static int amimouse_open(struct input_dev *dev)
 {
         unsigned short joy0dat;
+        int error;
 
         joy0dat = amiga_custom.joy0dat;
 
         amimouse_lastx = joy0dat & 0xff;
         amimouse_lasty = joy0dat >> 8;
 
-        if (request_irq(IRQ_AMIGA_VERTB, amimouse_interrupt, 0, "amimouse", amimouse_interrupt)) {
-                printk(KERN_ERR "amimouse.c: Can't allocate irq %d\n", IRQ_AMIGA_VERTB);
-                return -EBUSY;
-        }
+        error = request_irq(IRQ_AMIGA_VERTB, amimouse_interrupt, 0, "amimouse",
+                            dev);
+        if (error)
+                dev_err(&dev->dev, "Can't allocate irq %d\n", IRQ_AMIGA_VERTB);
 
-        return 0;
+        return error;
 }
 
 static void amimouse_close(struct input_dev *dev)
 {
-        free_irq(IRQ_AMIGA_VERTB, amimouse_interrupt);
+        free_irq(IRQ_AMIGA_VERTB, dev);
 }
 
-static int __init amimouse_init(void)
+static int __init amimouse_probe(struct platform_device *pdev)
 {
         int err;
+        struct input_dev *dev;
 
-        if (!MACH_IS_AMIGA || !AMIGAHW_PRESENT(AMI_MOUSE))
-                return -ENODEV;
-
-        amimouse_dev = input_allocate_device();
-        if (!amimouse_dev)
+        dev = input_allocate_device();
+        if (!dev)
                 return -ENOMEM;
 
-        amimouse_dev->name = "Amiga mouse";
-        amimouse_dev->phys = "amimouse/input0";
-        amimouse_dev->id.bustype = BUS_AMIGA;
-        amimouse_dev->id.vendor = 0x0001;
-        amimouse_dev->id.product = 0x0002;
-        amimouse_dev->id.version = 0x0100;
+        dev->name = pdev->name;
+        dev->phys = "amimouse/input0";
+        dev->id.bustype = BUS_AMIGA;
+        dev->id.vendor = 0x0001;
+        dev->id.product = 0x0002;
+        dev->id.version = 0x0100;
 
-        amimouse_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);
-        amimouse_dev->relbit[0] = BIT_MASK(REL_X) | BIT_MASK(REL_Y);
-        amimouse_dev->keybit[BIT_WORD(BTN_LEFT)] = BIT_MASK(BTN_LEFT) |
+        dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);
+        dev->relbit[0] = BIT_MASK(REL_X) | BIT_MASK(REL_Y);
+        dev->keybit[BIT_WORD(BTN_LEFT)] = BIT_MASK(BTN_LEFT) |
                 BIT_MASK(BTN_MIDDLE) | BIT_MASK(BTN_RIGHT);
-        amimouse_dev->open = amimouse_open;
-        amimouse_dev->close = amimouse_close;
+        dev->open = amimouse_open;
+        dev->close = amimouse_close;
+        dev->dev.parent = &pdev->dev;
 
-        err = input_register_device(amimouse_dev);
+        err = input_register_device(dev);
         if (err) {
-                input_free_device(amimouse_dev);
+                input_free_device(dev);
                 return err;
         }
 
+        platform_set_drvdata(pdev, dev);
+
         return 0;
 }
 
-static void __exit amimouse_exit(void)
+static int __exit amimouse_remove(struct platform_device *pdev)
 {
-        input_unregister_device(amimouse_dev);
+        struct input_dev *dev = platform_get_drvdata(pdev);
+
+        platform_set_drvdata(pdev, NULL);
+        input_unregister_device(dev);
+        return 0;
+}
+
+static struct platform_driver amimouse_driver = {
+        .remove = __exit_p(amimouse_remove),
+        .driver   = {
+                .name   = "amiga-mouse",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init amimouse_init(void)
+{
+        return platform_driver_probe(&amimouse_driver, amimouse_probe);
 }
 
 module_init(amimouse_init);
+
+static void __exit amimouse_exit(void)
+{
+        platform_driver_unregister(&amimouse_driver);
+}
+
 module_exit(amimouse_exit);
+
+MODULE_ALIAS("platform:amiga-mouse");
diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
index b9f58ca82fd1..6703c6b9800a 100644
--- a/drivers/input/touchscreen/Kconfig
+++ b/drivers/input/touchscreen/Kconfig
@@ -590,4 +590,17 @@ config TOUCHSCREEN_PCAP
 
           To compile this driver as a module, choose M here: the
           module will be called pcap_ts.
+
+config TOUCHSCREEN_TPS6507X
+        tristate "TPS6507x based touchscreens"
+        depends on I2C
+        help
+          Say Y here if you have a TPS6507x based touchscreen
+          controller.
+
+          If unsure, say N.
+
+          To compile this driver as a module, choose M here: the
+          module will be called tps6507x_ts.
+
 endif
diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile
index 8ad36eef90a2..497964a7a214 100644
--- a/drivers/input/touchscreen/Makefile
+++ b/drivers/input/touchscreen/Makefile
@@ -46,3 +46,4 @@ obj-$(CONFIG_TOUCHSCREEN_WM97XX_ATMEL)	+= atmel-wm97xx.o
 obj-$(CONFIG_TOUCHSCREEN_WM97XX_MAINSTONE)      += mainstone-wm97xx.o
 obj-$(CONFIG_TOUCHSCREEN_WM97XX_ZYLONITE)       += zylonite-wm97xx.o
 obj-$(CONFIG_TOUCHSCREEN_W90X900)       += w90p910_ts.o
+obj-$(CONFIG_TOUCHSCREEN_TPS6507X)      += tps6507x-ts.o
diff --git a/drivers/input/touchscreen/ads7846.c b/drivers/input/touchscreen/ads7846.c
index 532279cda0e4..634f6f6b9b13 100644
--- a/drivers/input/touchscreen/ads7846.c
+++ b/drivers/input/touchscreen/ads7846.c
@@ -1163,8 +1163,8 @@ static int __devinit ads7846_probe(struct spi_device *spi)
 
         ts->reg = regulator_get(&spi->dev, "vcc");
         if (IS_ERR(ts->reg)) {
-                dev_err(&spi->dev, "unable to get regulator: %ld\n",
-                        PTR_ERR(ts->reg));
+                err = PTR_ERR(ts->reg);
+                dev_err(&spi->dev, "unable to get regulator: %ld\n", err);
                 goto err_free_gpio;
         }
 
diff --git a/drivers/input/touchscreen/s3c2410_ts.c b/drivers/input/touchscreen/s3c2410_ts.c
index e0b7c834111d..ac5d0f9b0cb1 100644
--- a/drivers/input/touchscreen/s3c2410_ts.c
+++ b/drivers/input/touchscreen/s3c2410_ts.c
@@ -413,6 +413,8 @@ static struct dev_pm_ops s3c_ts_pmops = {
 #endif
 
 static struct platform_device_id s3cts_driver_ids[] = {
+        { "s3c2410-ts", 0 },
+        { "s3c2440-ts", 0 },
         { "s3c64xx-ts", FEAT_PEN_IRQ },
         { }
 };
diff --git a/drivers/input/touchscreen/tps6507x-ts.c b/drivers/input/touchscreen/tps6507x-ts.c
new file mode 100644
index 000000000000..5de80a1a730b
--- /dev/null
+++ b/drivers/input/touchscreen/tps6507x-ts.c
@@ -0,0 +1,400 @@
+/*
+ * drivers/input/touchscreen/tps6507x_ts.c
+ *
+ * Touchscreen driver for the tps6507x chip.
+ *
+ * Copyright (c) 2009 RidgeRun (todd.fischer@ridgerun.com)
+ *
+ * Credits:
+ *
+ *    Using code from tsc2007, MtekVision Co., Ltd.
+ *
+ * For licencing details see kernel-base/COPYING
+ *
+ * TPS65070, TPS65073, TPS650731, and TPS650732 support
+ * 10 bit touch screen interface.
+ */
+
+#include <linux/module.h>
+#include <linux/workqueue.h>
+#include <linux/slab.h>
+#include <linux/input.h>
+#include <linux/platform_device.h>
+#include <linux/mfd/tps6507x.h>
+#include <linux/input/tps6507x-ts.h>
+#include <linux/delay.h>
+
+#define TSC_DEFAULT_POLL_PERIOD 30 /* ms */
+#define TPS_DEFAULT_MIN_PRESSURE 0x30
+#define MAX_10BIT ((1 << 10) - 1)
+
+#define TPS6507X_ADCONFIG_CONVERT_TS (TPS6507X_ADCONFIG_AD_ENABLE | \
+                                         TPS6507X_ADCONFIG_START_CONVERSION | \
+                                         TPS6507X_ADCONFIG_INPUT_REAL_TSC)
+#define TPS6507X_ADCONFIG_POWER_DOWN_TS (TPS6507X_ADCONFIG_INPUT_REAL_TSC)
+
+struct ts_event {
+        u16     x;
+        u16     y;
+        u16     pressure;
+};
+
+struct tps6507x_ts {
+        struct input_dev        *input_dev;
+        struct device           *dev;
+        char                    phys[32];
+        struct workqueue_struct *wq;
+        struct delayed_work     work;
+        unsigned                polling;        /* polling is active */
+        struct ts_event         tc;
+        struct tps6507x_dev     *mfd;
+        u16                     model;
+        unsigned                pendown;
+        int                     irq;
+        void                    (*clear_penirq)(void);
+        unsigned long           poll_period;    /* ms */
+        u16                     min_pressure;
+        int                     vref;           /* non-zero to leave vref on */
+};
+
+static int tps6507x_read_u8(struct tps6507x_ts *tsc, u8 reg, u8 *data)
+{
+        int err;
+
+        err = tsc->mfd->read_dev(tsc->mfd, reg, 1, data);
+
+        if (err)
+                return err;
+
+        return 0;
+}
+
+static int tps6507x_write_u8(struct tps6507x_ts *tsc, u8 reg, u8 data)
+{
+        return tsc->mfd->write_dev(tsc->mfd, reg, 1, &data);
+}
+
+static s32 tps6507x_adc_conversion(struct tps6507x_ts *tsc,
+                                   u8 tsc_mode, u16 *value)
+{
+        s32 ret;
+        u8 adc_status;
+        u8 result;
+
+        /* Route input signal to A/D converter */
+
+        ret = tps6507x_write_u8(tsc, TPS6507X_REG_TSCMODE, tsc_mode);
+        if (ret) {
+                dev_err(tsc->dev, "TSC mode read failed\n");
+                goto err;
+        }
+
+        /* Start A/D conversion */
+
+        ret = tps6507x_write_u8(tsc, TPS6507X_REG_ADCONFIG,
+                                TPS6507X_ADCONFIG_CONVERT_TS);
+        if (ret) {
+                dev_err(tsc->dev, "ADC config write failed\n");
+                return ret;
+        }
+
+        do {
+                ret = tps6507x_read_u8(tsc, TPS6507X_REG_ADCONFIG,
+                                       &adc_status);
+                if (ret) {
+                        dev_err(tsc->dev, "ADC config read failed\n");
+                        goto err;
+                }
+        } while (adc_status & TPS6507X_ADCONFIG_START_CONVERSION);
+
+        ret = tps6507x_read_u8(tsc, TPS6507X_REG_ADRESULT_2, &result);
+        if (ret) {
+                dev_err(tsc->dev, "ADC result 2 read failed\n");
+                goto err;
+        }
+
+        *value = (result & TPS6507X_REG_ADRESULT_2_MASK) << 8;
+
+        ret = tps6507x_read_u8(tsc, TPS6507X_REG_ADRESULT_1, &result);
+        if (ret) {
+                dev_err(tsc->dev, "ADC result 1 read failed\n");
+                goto err;
+        }
+
+        *value |= result;
+
+        dev_dbg(tsc->dev, "TSC channel %d = 0x%X\n", tsc_mode, *value);
+
+err:
+        return ret;
+}
+
+/* Need to call tps6507x_adc_standby() after using A/D converter for the
+ * touch screen interrupt to work properly.
+ */
+
+static s32 tps6507x_adc_standby(struct tps6507x_ts *tsc)
+{
+        s32 ret;
+        s32 loops = 0;
+        u8 val;
+
+        ret = tps6507x_write_u8(tsc,  TPS6507X_REG_ADCONFIG,
+                                TPS6507X_ADCONFIG_INPUT_TSC);
+        if (ret)
+                return ret;
+
+        ret = tps6507x_write_u8(tsc, TPS6507X_REG_TSCMODE,
+                                TPS6507X_TSCMODE_STANDBY);
+        if (ret)
+                return ret;
+
+        ret = tps6507x_read_u8(tsc, TPS6507X_REG_INT, &val);
+        if (ret)
+                return ret;
+
+        while (val & TPS6507X_REG_TSC_INT) {
+                mdelay(10);
+                ret = tps6507x_read_u8(tsc, TPS6507X_REG_INT, &val);
+                if (ret)
+                        return ret;
+                loops++;
+        }
+
+        return ret;
+}
+
+static void tps6507x_ts_handler(struct work_struct *work)
+{
+        struct tps6507x_ts *tsc =  container_of(work,
+                                struct tps6507x_ts, work.work);
+        struct input_dev *input_dev = tsc->input_dev;
+        int pendown;
+        int schd;
+        int poll = 0;
+        s32 ret;
+
+        ret =  tps6507x_adc_conversion(tsc, TPS6507X_TSCMODE_PRESSURE,
+                                       &tsc->tc.pressure);
+        if (ret)
+                goto done;
+
+        pendown = tsc->tc.pressure > tsc->min_pressure;
+
+        if (unlikely(!pendown && tsc->pendown)) {
+                dev_dbg(tsc->dev, "UP\n");
+                input_report_key(input_dev, BTN_TOUCH, 0);
+                input_report_abs(input_dev, ABS_PRESSURE, 0);
+                input_sync(input_dev);
+                tsc->pendown = 0;
+        }
+
+        if (pendown) {
+
+                if (!tsc->pendown) {
+                        dev_dbg(tsc->dev, "DOWN\n");
+                        input_report_key(input_dev, BTN_TOUCH, 1);
+                } else
+                        dev_dbg(tsc->dev, "still down\n");
+
+                ret =  tps6507x_adc_conversion(tsc, TPS6507X_TSCMODE_X_POSITION,
+                                               &tsc->tc.x);
+                if (ret)
+                        goto done;
+
+                ret =  tps6507x_adc_conversion(tsc, TPS6507X_TSCMODE_Y_POSITION,
+                                               &tsc->tc.y);
+                if (ret)
+                        goto done;
+
+                input_report_abs(input_dev, ABS_X, tsc->tc.x);
+                input_report_abs(input_dev, ABS_Y, tsc->tc.y);
+                input_report_abs(input_dev, ABS_PRESSURE, tsc->tc.pressure);
+                input_sync(input_dev);
+                tsc->pendown = 1;
+                poll = 1;
+        }
+
+done:
+        /* always poll if not using interrupts */
+        poll = 1;
+
+        if (poll) {
+                schd = queue_delayed_work(tsc->wq, &tsc->work,
+                                          tsc->poll_period * HZ / 1000);
+                if (schd)
+                        tsc->polling = 1;
+                else {
+                        tsc->polling = 0;
+                        dev_err(tsc->dev, "re-schedule failed");
+                }
+        } else
+                tsc->polling = 0;
+
+        ret = tps6507x_adc_standby(tsc);
+}
+
+static int tps6507x_ts_probe(struct platform_device *pdev)
+{
+        int error;
+        struct tps6507x_ts *tsc;
+        struct tps6507x_dev *tps6507x_dev = dev_get_drvdata(pdev->dev.parent);
+        struct touchscreen_init_data *init_data;
+        struct input_dev *input_dev;
+        struct tps6507x_board *tps_board;
+        int schd;
+
+        /**
+         * tps_board points to pmic related constants
+         * coming from the board-evm file.
+         */
+
+        tps_board = (struct tps6507x_board *)tps6507x_dev->dev->platform_data;
+
+        if (!tps_board) {
+                dev_err(tps6507x_dev->dev,
+                        "Could not find tps6507x platform data\n");
+                return -EIO;
+        }
+
+        /**
+         * init_data points to array of regulator_init structures
+         * coming from the board-evm file.
+         */
+
+        init_data = tps_board->tps6507x_ts_init_data;
+
+        tsc = kzalloc(sizeof(struct tps6507x_ts), GFP_KERNEL);
+        if (!tsc) {
+                dev_err(tps6507x_dev->dev, "failed to allocate driver data\n");
+                error = -ENOMEM;
+                goto err0;
+        }
+
+        tps6507x_dev->ts = tsc;
+        tsc->mfd = tps6507x_dev;
+        tsc->dev = tps6507x_dev->dev;
+        input_dev = input_allocate_device();
+        if (!input_dev) {
+                dev_err(tsc->dev, "Failed to allocate input device.\n");
+                error = -ENOMEM;
+                goto err1;
+        }
+
+        input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
+        input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
+
+        input_set_abs_params(input_dev, ABS_X, 0, MAX_10BIT, 0, 0);
+        input_set_abs_params(input_dev, ABS_Y, 0, MAX_10BIT, 0, 0);
+        input_set_abs_params(input_dev, ABS_PRESSURE, 0, MAX_10BIT, 0, 0);
+
+        input_dev->name = "TPS6507x Touchscreen";
+        input_dev->id.bustype = BUS_I2C;
+        input_dev->dev.parent = tsc->dev;
+
+        snprintf(tsc->phys, sizeof(tsc->phys),
+                 "%s/input0", dev_name(tsc->dev));
+        input_dev->phys = tsc->phys;
+
+        dev_dbg(tsc->dev, "device: %s\n", input_dev->phys);
+
+        input_set_drvdata(input_dev, tsc);
+
+        tsc->input_dev = input_dev;
+
+        INIT_DELAYED_WORK(&tsc->work, tps6507x_ts_handler);
+        tsc->wq = create_workqueue("TPS6507x Touchscreen");
+
+        if (init_data) {
+                tsc->poll_period = init_data->poll_period;
+                tsc->vref = init_data->vref;
+                tsc->min_pressure = init_data->min_pressure;
+                input_dev->id.vendor = init_data->vendor;
+                input_dev->id.product = init_data->product;
+                input_dev->id.version = init_data->version;
+        } else {
+                tsc->poll_period = TSC_DEFAULT_POLL_PERIOD;
+                tsc->min_pressure = TPS_DEFAULT_MIN_PRESSURE;
+        }
+
+        error = tps6507x_adc_standby(tsc);
+        if (error)
+                goto err2;
+
+        error = input_register_device(input_dev);
+        if (error)
+                goto err2;
+
+        schd = queue_delayed_work(tsc->wq, &tsc->work,
+                                  tsc->poll_period * HZ / 1000);
+
+        if (schd)
+                tsc->polling = 1;
+        else {
+                tsc->polling = 0;
+                dev_err(tsc->dev, "schedule failed");
+                goto err2;
+         }
+
+        return 0;
+
+err2:
+        cancel_delayed_work(&tsc->work);
+        flush_workqueue(tsc->wq);
+        destroy_workqueue(tsc->wq);
+        tsc->wq = 0;
+        input_free_device(input_dev);
+err1:
+        kfree(tsc);
+        tps6507x_dev->ts = NULL;
+err0:
+        return error;
+}
+
+static int __devexit tps6507x_ts_remove(struct platform_device *pdev)
+{
+        struct tps6507x_dev *tps6507x_dev = platform_get_drvdata(pdev);
+        struct tps6507x_ts *tsc = tps6507x_dev->ts;
+        struct input_dev *input_dev = tsc->input_dev;
+
+        if (!tsc)
+                return 0;
+
+        cancel_delayed_work(&tsc->work);
+        flush_workqueue(tsc->wq);
+        destroy_workqueue(tsc->wq);
+        tsc->wq = 0;
+
+        input_free_device(input_dev);
+
+        tps6507x_dev->ts = NULL;
+        kfree(tsc);
+
+        return 0;
+}
+
+static struct platform_driver tps6507x_ts_driver = {
+        .driver = {
+                .name = "tps6507x-ts",
+                .owner = THIS_MODULE,
+        },
+        .probe = tps6507x_ts_probe,
+        .remove = __devexit_p(tps6507x_ts_remove),
+};
+
+static int __init tps6507x_ts_init(void)
+{
+        return platform_driver_register(&tps6507x_ts_driver);
+}
+module_init(tps6507x_ts_init);
+
+static void __exit tps6507x_ts_exit(void)
+{
+        platform_driver_unregister(&tps6507x_ts_driver);
+}
+module_exit(tps6507x_ts_exit);
+
+MODULE_AUTHOR("Todd Fischer <todd.fischer@ridgerun.com>");
+MODULE_DESCRIPTION("TPS6507x - TouchScreen driver");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:tps6507x-tsc");
diff --git a/drivers/input/touchscreen/usbtouchscreen.c b/drivers/input/touchscreen/usbtouchscreen.c
index 29a8bbf3f086..567d57215c28 100644
--- a/drivers/input/touchscreen/usbtouchscreen.c
+++ b/drivers/input/touchscreen/usbtouchscreen.c
@@ -857,6 +857,11 @@ static int nexio_read_data(struct usbtouch_usb *usbtouch, unsigned char *pkt)
         if ((pkt[0] & 0xe0) != 0xe0)
                 return 0;
 
+        if (be16_to_cpu(packet->data_len) > 0xff)
+                packet->data_len = cpu_to_be16(be16_to_cpu(packet->data_len) - 0x100);
+        if (be16_to_cpu(packet->x_len) > 0xff)
+                packet->x_len = cpu_to_be16(be16_to_cpu(packet->x_len) - 0x80);
+
         /* send ACK */
         ret = usb_submit_urb(priv->ack, GFP_ATOMIC);
 
@@ -1112,7 +1117,7 @@ static struct usbtouch_device_info usbtouch_dev_info[] = {
 
 #ifdef CONFIG_TOUCHSCREEN_USB_NEXIO
         [DEVTYPE_NEXIO] = {
-                .rept_size      = 128,
+                .rept_size      = 1024,
                 .irq_always     = true,
                 .read_data      = nexio_read_data,
                 .init           = nexio_init,
diff --git a/drivers/isdn/mISDN/timerdev.c b/drivers/isdn/mISDN/timerdev.c
index c3243c913ec0..81048b8ed8ad 100644
--- a/drivers/isdn/mISDN/timerdev.c
+++ b/drivers/isdn/mISDN/timerdev.c
@@ -98,8 +98,6 @@ mISDN_read(struct file *filep, char __user *buf, size_t count, loff_t *off)
         if (*debug & DEBUG_TIMER)
                 printk(KERN_DEBUG "%s(%p, %p, %d, %p)\n", __func__,
                         filep, buf, (int)count, off);
-        if (*off != filep->f_pos)
-                return -ESPIPE;
 
         if (list_empty(&dev->expired) && (dev->work == 0)) {
                 if (filep->f_flags & O_NONBLOCK)
diff --git a/drivers/leds/Kconfig b/drivers/leds/Kconfig
index 505eb64c329c..81bf25e67ce1 100644
--- a/drivers/leds/Kconfig
+++ b/drivers/leds/Kconfig
@@ -21,7 +21,7 @@ comment "LED drivers"
 
 config LEDS_88PM860X
         tristate "LED Support for Marvell 88PM860x PMIC"
-        depends on LEDS_CLASS && MFD_88PM860X
+        depends on MFD_88PM860X
         help
           This option enables support for on-chip LED drivers found on Marvell
           Semiconductor 88PM8606 PMIC.
@@ -67,6 +67,16 @@ config LEDS_NET48XX
           This option enables support for the Soekris net4801 and net4826 error
           LED.
 
+config LEDS_NET5501
+        tristate "LED Support for Soekris net5501 series Error LED"
+        depends on LEDS_TRIGGERS
+        depends on X86 && LEDS_GPIO_PLATFORM && GPIO_CS5535
+        select LEDS_TRIGGER_DEFAULT_ON
+        default n
+        help
+          Add support for the Soekris net5501 board (detection, error led
+          and GPIO).
+
 config LEDS_FSG
         tristate "LED Support for the Freecom FSG-3"
         depends on MACH_FSG
@@ -285,6 +295,13 @@ config LEDS_DELL_NETBOOKS
           This adds support for the Latitude 2100 and similar
           notebooks that have an external LED.
 
+config LEDS_MC13783
+        tristate "LED Support for MC13783 PMIC"
+        depends on MFD_MC13783
+        help
+          This option enable support for on-chip LED drivers found
+          on Freescale Semiconductor MC13783 PMIC.
+
 config LEDS_TRIGGERS
         bool "LED Trigger support"
         help
diff --git a/drivers/leds/Makefile b/drivers/leds/Makefile
index 0cd8b9957380..2493de499374 100644
--- a/drivers/leds/Makefile
+++ b/drivers/leds/Makefile
@@ -13,6 +13,7 @@ obj-$(CONFIG_LEDS_MIKROTIK_RB532)	+= leds-rb532.o
 obj-$(CONFIG_LEDS_S3C24XX)              += leds-s3c24xx.o
 obj-$(CONFIG_LEDS_AMS_DELTA)            += leds-ams-delta.o
 obj-$(CONFIG_LEDS_NET48XX)              += leds-net48xx.o
+obj-$(CONFIG_LEDS_NET5501)              += leds-net5501.o
 obj-$(CONFIG_LEDS_WRAP)                 += leds-wrap.o
 obj-$(CONFIG_LEDS_ALIX2)                += leds-alix2.o
 obj-$(CONFIG_LEDS_H1940)                += leds-h1940.o
@@ -35,6 +36,7 @@ obj-$(CONFIG_LEDS_INTEL_SS4200)		+= leds-ss4200.o
 obj-$(CONFIG_LEDS_LT3593)               += leds-lt3593.o
 obj-$(CONFIG_LEDS_ADP5520)              += leds-adp5520.o
 obj-$(CONFIG_LEDS_DELL_NETBOOKS)        += dell-led.o
+obj-$(CONFIG_LEDS_MC13783)              += leds-mc13783.o
 
 # LED SPI Drivers
 obj-$(CONFIG_LEDS_DAC124S085)           += leds-dac124s085.o
diff --git a/drivers/leds/led-class.c b/drivers/leds/led-class.c
index 69e7d86a5143..260660076507 100644
--- a/drivers/leds/led-class.c
+++ b/drivers/leds/led-class.c
@@ -74,7 +74,7 @@ static ssize_t led_max_brightness_show(struct device *dev,
 
 static struct device_attribute led_class_attrs[] = {
         __ATTR(brightness, 0644, led_brightness_show, led_brightness_store),
-        __ATTR(max_brightness, 0644, led_max_brightness_show, NULL),
+        __ATTR(max_brightness, 0444, led_max_brightness_show, NULL),
 #ifdef CONFIG_LEDS_TRIGGERS
         __ATTR(trigger, 0644, led_trigger_show, led_trigger_store),
 #endif
diff --git a/drivers/leds/leds-88pm860x.c b/drivers/leds/leds-88pm860x.c
index 16a60c06c96c..b7677106cff8 100644
--- a/drivers/leds/leds-88pm860x.c
+++ b/drivers/leds/leds-88pm860x.c
@@ -256,8 +256,10 @@ static int pm860x_led_probe(struct platform_device *pdev)
         if (pdev->dev.parent->platform_data) {
                 pm860x_pdata = pdev->dev.parent->platform_data;
                 pdata = pm860x_pdata->led;
-        } else
-                pdata = NULL;
+        } else {
+                dev_err(&pdev->dev, "missing platform data\n");
+                return -EINVAL;
+        }
 
         data = kzalloc(sizeof(struct pm860x_led), GFP_KERNEL);
         if (data == NULL)
@@ -268,8 +270,11 @@ static int pm860x_led_probe(struct platform_device *pdev)
         data->i2c = (chip->id == CHIP_PM8606) ? chip->client : chip->companion;
         data->iset = pdata->iset;
         data->port = __check_device(pdata, data->name);
-        if (data->port < 0)
+        if (data->port < 0) {
+                dev_err(&pdev->dev, "check device failed\n");
+                kfree(data);
                 return -EINVAL;
+        }
 
         data->current_brightness = 0;
         data->cdev.name = data->name;
diff --git a/drivers/leds/leds-gpio.c b/drivers/leds/leds-gpio.c
index 6d94b0b9979c..cc22eeefa10b 100644
--- a/drivers/leds/leds-gpio.c
+++ b/drivers/leds/leds-gpio.c
@@ -26,7 +26,8 @@ struct gpio_led_data {
         u8 new_level;
         u8 can_sleep;
         u8 active_low;
-        int (*platform_gpio_blink_set)(unsigned gpio,
+        u8 blinking;
+        int (*platform_gpio_blink_set)(unsigned gpio, int state,
                         unsigned long *delay_on, unsigned long *delay_off);
 };
 
@@ -35,7 +36,13 @@ static void gpio_led_work(struct work_struct *work)
         struct gpio_led_data    *led_dat =
                 container_of(work, struct gpio_led_data, work);
 
-        gpio_set_value_cansleep(led_dat->gpio, led_dat->new_level);
+        if (led_dat->blinking) {
+                led_dat->platform_gpio_blink_set(led_dat->gpio,
+                                                 led_dat->new_level,
+                                                 NULL, NULL);
+                led_dat->blinking = 0;
+        } else
+                gpio_set_value_cansleep(led_dat->gpio, led_dat->new_level);
 }
 
 static void gpio_led_set(struct led_classdev *led_cdev,
@@ -60,8 +67,14 @@ static void gpio_led_set(struct led_classdev *led_cdev,
         if (led_dat->can_sleep) {
                 led_dat->new_level = level;
                 schedule_work(&led_dat->work);
-        } else
-                gpio_set_value(led_dat->gpio, level);
+        } else {
+                if (led_dat->blinking) {
+                        led_dat->platform_gpio_blink_set(led_dat->gpio, level,
+                                                         NULL, NULL);
+                        led_dat->blinking = 0;
+                } else
+                        gpio_set_value(led_dat->gpio, level);
+        }
 }
 
 static int gpio_blink_set(struct led_classdev *led_cdev,
@@ -70,12 +83,14 @@ static int gpio_blink_set(struct led_classdev *led_cdev,
         struct gpio_led_data *led_dat =
                 container_of(led_cdev, struct gpio_led_data, cdev);
 
-        return led_dat->platform_gpio_blink_set(led_dat->gpio, delay_on, delay_off);
+        led_dat->blinking = 1;
+        return led_dat->platform_gpio_blink_set(led_dat->gpio, GPIO_LED_BLINK,
+                                                delay_on, delay_off);
 }
 
 static int __devinit create_gpio_led(const struct gpio_led *template,
         struct gpio_led_data *led_dat, struct device *parent,
-        int (*blink_set)(unsigned, unsigned long *, unsigned long *))
+        int (*blink_set)(unsigned, int, unsigned long *, unsigned long *))
 {
         int ret, state;
 
@@ -97,6 +112,7 @@ static int __devinit create_gpio_led(const struct gpio_led *template,
         led_dat->gpio = template->gpio;
         led_dat->can_sleep = gpio_cansleep(template->gpio);
         led_dat->active_low = template->active_low;
+        led_dat->blinking = 0;
         if (blink_set) {
                 led_dat->platform_gpio_blink_set = blink_set;
                 led_dat->cdev.blink_set = gpio_blink_set;
@@ -113,7 +129,7 @@ static int __devinit create_gpio_led(const struct gpio_led *template,
         ret = gpio_direction_output(led_dat->gpio, led_dat->active_low ^ state);
         if (ret < 0)
                 goto err;
-
+                
         INIT_WORK(&led_dat->work, gpio_led_work);
 
         ret = led_classdev_register(parent, &led_dat->cdev);
diff --git a/drivers/leds/leds-lp3944.c b/drivers/leds/leds-lp3944.c
index 8d5ecceba181..932a58da76c4 100644
--- a/drivers/leds/leds-lp3944.c
+++ b/drivers/leds/leds-lp3944.c
@@ -379,6 +379,7 @@ static int __devinit lp3944_probe(struct i2c_client *client,
 {
         struct lp3944_platform_data *lp3944_pdata = client->dev.platform_data;
         struct lp3944_data *data;
+        int err;
 
         if (lp3944_pdata == NULL) {
                 dev_err(&client->dev, "no platform data\n");
@@ -401,9 +402,13 @@ static int __devinit lp3944_probe(struct i2c_client *client,
 
         mutex_init(&data->lock);
 
-        dev_info(&client->dev, "lp3944 enabled\n");
+        err = lp3944_configure(client, data, lp3944_pdata);
+        if (err < 0) {
+                kfree(data);
+                return err;
+        }
 
-        lp3944_configure(client, data, lp3944_pdata);
+        dev_info(&client->dev, "lp3944 enabled\n");
         return 0;
 }
 
diff --git a/drivers/leds/leds-mc13783.c b/drivers/leds/leds-mc13783.c
new file mode 100644
index 000000000000..f05bb08d0f09
--- /dev/null
+++ b/drivers/leds/leds-mc13783.c
@@ -0,0 +1,403 @@
+/*
+ * LEDs driver for Freescale MC13783
+ *
+ * Copyright (C) 2010 Philippe Rétornaz
+ *
+ * Based on leds-da903x:
+ * Copyright (C) 2008 Compulab, Ltd.
+ *      Mike Rapoport <mike@compulab.co.il>
+ *
+ * Copyright (C) 2006-2008 Marvell International Ltd.
+ *      Eric Miao <eric.miao@marvell.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/leds.h>
+#include <linux/workqueue.h>
+#include <linux/mfd/mc13783.h>
+#include <linux/slab.h>
+
+struct mc13783_led {
+        struct led_classdev     cdev;
+        struct work_struct      work;
+        struct mc13783          *master;
+        enum led_brightness     new_brightness;
+        int                     id;
+};
+
+#define MC13783_REG_LED_CONTROL_0       51
+#define MC13783_LED_C0_ENABLE_BIT       (1 << 0)
+#define MC13783_LED_C0_TRIODE_MD_BIT    (1 << 7)
+#define MC13783_LED_C0_TRIODE_AD_BIT    (1 << 8)
+#define MC13783_LED_C0_TRIODE_KP_BIT    (1 << 9)
+#define MC13783_LED_C0_BOOST_BIT        (1 << 10)
+#define MC13783_LED_C0_ABMODE_MASK      0x7
+#define MC13783_LED_C0_ABMODE           11
+#define MC13783_LED_C0_ABREF_MASK       0x3
+#define MC13783_LED_C0_ABREF            14
+
+#define MC13783_REG_LED_CONTROL_1       52
+#define MC13783_LED_C1_TC1HALF_BIT      (1 << 18)
+
+#define MC13783_REG_LED_CONTROL_2       53
+#define MC13783_LED_C2_BL_P_MASK        0xf
+#define MC13783_LED_C2_MD_P             9
+#define MC13783_LED_C2_AD_P             13
+#define MC13783_LED_C2_KP_P             17
+#define MC13783_LED_C2_BL_C_MASK        0x7
+#define MC13783_LED_C2_MD_C             0
+#define MC13783_LED_C2_AD_C             3
+#define MC13783_LED_C2_KP_C             6
+
+#define MC13783_REG_LED_CONTROL_3       54
+#define MC13783_LED_C3_TC_P             6
+#define MC13783_LED_C3_TC_P_MASK        0x1f
+
+#define MC13783_REG_LED_CONTROL_4       55
+#define MC13783_REG_LED_CONTROL_5       56
+
+#define MC13783_LED_Cx_PERIOD           21
+#define MC13783_LED_Cx_PERIOD_MASK      0x3
+#define MC13783_LED_Cx_SLEWLIM_BIT      (1 << 23)
+#define MC13783_LED_Cx_TRIODE_TC_BIT    (1 << 23)
+#define MC13783_LED_Cx_TC_C_MASK        0x3
+
+static void mc13783_led_work(struct work_struct *work)
+{
+        struct mc13783_led *led = container_of(work, struct mc13783_led, work);
+        int reg = 0;
+        int mask = 0;
+        int value = 0;
+        int bank, off, shift;
+
+        switch (led->id) {
+        case MC13783_LED_MD:
+                reg = MC13783_REG_LED_CONTROL_2;
+                mask = MC13783_LED_C2_BL_P_MASK << MC13783_LED_C2_MD_P;
+                value = (led->new_brightness >> 4) << MC13783_LED_C2_MD_P;
+                break;
+        case MC13783_LED_AD:
+                reg = MC13783_REG_LED_CONTROL_2;
+                mask = MC13783_LED_C2_BL_P_MASK << MC13783_LED_C2_AD_P;
+                value = (led->new_brightness >> 4) << MC13783_LED_C2_AD_P;
+                break;
+        case MC13783_LED_KP:
+                reg = MC13783_REG_LED_CONTROL_2;
+                mask = MC13783_LED_C2_BL_P_MASK << MC13783_LED_C2_KP_P;
+                value = (led->new_brightness >> 4) << MC13783_LED_C2_KP_P;
+                break;
+        case MC13783_LED_R1:
+        case MC13783_LED_G1:
+        case MC13783_LED_B1:
+        case MC13783_LED_R2:
+        case MC13783_LED_G2:
+        case MC13783_LED_B2:
+        case MC13783_LED_R3:
+        case MC13783_LED_G3:
+        case MC13783_LED_B3:
+                off = led->id - MC13783_LED_R1;
+                bank = off/3;
+                reg = MC13783_REG_LED_CONTROL_3 + off/3;
+                shift = (off - bank * 3) * 5 + MC13783_LED_C3_TC_P;
+                value = (led->new_brightness >> 3) << shift;
+                mask = MC13783_LED_C3_TC_P_MASK << shift;
+                break;
+        }
+
+        mc13783_lock(led->master);
+
+        mc13783_reg_rmw(led->master, reg, mask, value);
+
+        mc13783_unlock(led->master);
+}
+
+static void mc13783_led_set(struct led_classdev *led_cdev,
+                           enum led_brightness value)
+{
+        struct mc13783_led *led;
+
+        led = container_of(led_cdev, struct mc13783_led, cdev);
+        led->new_brightness = value;
+        schedule_work(&led->work);
+}
+
+static int __devinit mc13783_led_setup(struct mc13783_led *led, int max_current)
+{
+        int shift = 0;
+        int mask = 0;
+        int value = 0;
+        int reg = 0;
+        int ret, bank;
+
+        switch (led->id) {
+        case MC13783_LED_MD:
+                shift = MC13783_LED_C2_MD_C;
+                mask = MC13783_LED_C2_BL_C_MASK;
+                value = max_current & MC13783_LED_C2_BL_C_MASK;
+                reg = MC13783_REG_LED_CONTROL_2;
+                break;
+        case MC13783_LED_AD:
+                shift = MC13783_LED_C2_AD_C;
+                mask = MC13783_LED_C2_BL_C_MASK;
+                value = max_current & MC13783_LED_C2_BL_C_MASK;
+                reg = MC13783_REG_LED_CONTROL_2;
+                break;
+        case MC13783_LED_KP:
+                shift = MC13783_LED_C2_KP_C;
+                mask = MC13783_LED_C2_BL_C_MASK;
+                value = max_current & MC13783_LED_C2_BL_C_MASK;
+                reg = MC13783_REG_LED_CONTROL_2;
+                break;
+        case MC13783_LED_R1:
+        case MC13783_LED_G1:
+        case MC13783_LED_B1:
+        case MC13783_LED_R2:
+        case MC13783_LED_G2:
+        case MC13783_LED_B2:
+        case MC13783_LED_R3:
+        case MC13783_LED_G3:
+        case MC13783_LED_B3:
+                bank = (led->id - MC13783_LED_R1)/3;
+                reg = MC13783_REG_LED_CONTROL_3 + bank;
+                shift = ((led->id - MC13783_LED_R1) - bank * 3) * 2;
+                mask = MC13783_LED_Cx_TC_C_MASK;
+                value = max_current & MC13783_LED_Cx_TC_C_MASK;
+                break;
+        }
+
+        mc13783_lock(led->master);
+
+        ret = mc13783_reg_rmw(led->master, reg, mask << shift,
+                                                value << shift);
+
+        mc13783_unlock(led->master);
+        return ret;
+}
+
+static int __devinit mc13783_leds_prepare(struct platform_device *pdev)
+{
+        struct mc13783_leds_platform_data *pdata = dev_get_platdata(&pdev->dev);
+        struct mc13783 *dev = dev_get_drvdata(pdev->dev.parent);
+        int ret = 0;
+        int reg = 0;
+
+        mc13783_lock(dev);
+
+        if (pdata->flags & MC13783_LED_TC1HALF)
+                reg |= MC13783_LED_C1_TC1HALF_BIT;
+
+        if (pdata->flags & MC13783_LED_SLEWLIMTC)
+                reg |= MC13783_LED_Cx_SLEWLIM_BIT;
+
+        ret = mc13783_reg_write(dev, MC13783_REG_LED_CONTROL_1, reg);
+        if (ret)
+                goto out;
+
+        reg = (pdata->bl_period & MC13783_LED_Cx_PERIOD_MASK) <<
+                                                        MC13783_LED_Cx_PERIOD;
+
+        if (pdata->flags & MC13783_LED_SLEWLIMBL)
+                reg |= MC13783_LED_Cx_SLEWLIM_BIT;
+
+        ret = mc13783_reg_write(dev, MC13783_REG_LED_CONTROL_2, reg);
+        if (ret)
+                goto out;
+
+        reg = (pdata->tc1_period & MC13783_LED_Cx_PERIOD_MASK) <<
+                                                        MC13783_LED_Cx_PERIOD;
+
+        if (pdata->flags & MC13783_LED_TRIODE_TC1)
+                reg |= MC13783_LED_Cx_TRIODE_TC_BIT;
+
+        ret = mc13783_reg_write(dev, MC13783_REG_LED_CONTROL_3, reg);
+        if (ret)
+                goto out;
+
+        reg = (pdata->tc2_period & MC13783_LED_Cx_PERIOD_MASK) <<
+                                                        MC13783_LED_Cx_PERIOD;
+
+        if (pdata->flags & MC13783_LED_TRIODE_TC2)
+                reg |= MC13783_LED_Cx_TRIODE_TC_BIT;
+
+        ret = mc13783_reg_write(dev, MC13783_REG_LED_CONTROL_4, reg);
+        if (ret)
+                goto out;
+
+        reg = (pdata->tc3_period & MC13783_LED_Cx_PERIOD_MASK) <<
+                                                        MC13783_LED_Cx_PERIOD;
+
+        if (pdata->flags & MC13783_LED_TRIODE_TC3)
+                reg |= MC13783_LED_Cx_TRIODE_TC_BIT;;
+
+        ret = mc13783_reg_write(dev, MC13783_REG_LED_CONTROL_5, reg);
+        if (ret)
+                goto out;
+
+        reg = MC13783_LED_C0_ENABLE_BIT;
+        if (pdata->flags & MC13783_LED_TRIODE_MD)
+                reg |= MC13783_LED_C0_TRIODE_MD_BIT;
+        if (pdata->flags & MC13783_LED_TRIODE_AD)
+                reg |= MC13783_LED_C0_TRIODE_AD_BIT;
+        if (pdata->flags & MC13783_LED_TRIODE_KP)
+                reg |= MC13783_LED_C0_TRIODE_KP_BIT;
+        if (pdata->flags & MC13783_LED_BOOST_EN)
+                reg |= MC13783_LED_C0_BOOST_BIT;
+
+        reg |= (pdata->abmode & MC13783_LED_C0_ABMODE_MASK) <<
+                                                        MC13783_LED_C0_ABMODE;
+        reg |= (pdata->abref & MC13783_LED_C0_ABREF_MASK) <<
+                                                        MC13783_LED_C0_ABREF;
+
+        ret = mc13783_reg_write(dev, MC13783_REG_LED_CONTROL_0, reg);
+
+out:
+        mc13783_unlock(dev);
+        return ret;
+}
+
+static int __devinit mc13783_led_probe(struct platform_device *pdev)
+{
+        struct mc13783_leds_platform_data *pdata = dev_get_platdata(&pdev->dev);
+        struct mc13783_led_platform_data *led_cur;
+        struct mc13783_led *led, *led_dat;
+        int ret, i;
+        int init_led = 0;
+
+        if (pdata == NULL) {
+                dev_err(&pdev->dev, "missing platform data\n");
+                return -ENODEV;
+        }
+
+        if (pdata->num_leds < 1 || pdata->num_leds > MC13783_LED_MAX) {
+                dev_err(&pdev->dev, "Invalid led count %d\n", pdata->num_leds);
+                return -EINVAL;
+        }
+
+        led = kzalloc(sizeof(*led) * pdata->num_leds, GFP_KERNEL);
+        if (led == NULL) {
+                dev_err(&pdev->dev, "failed to alloc memory\n");
+                return -ENOMEM;
+        }
+
+        ret = mc13783_leds_prepare(pdev);
+        if (ret) {
+                dev_err(&pdev->dev, "unable to init led driver\n");
+                goto err_free;
+        }
+
+        for (i = 0; i < pdata->num_leds; i++) {
+                led_dat = &led[i];
+                led_cur = &pdata->led[i];
+
+                if (led_cur->id > MC13783_LED_MAX || led_cur->id < 0) {
+                        dev_err(&pdev->dev, "invalid id %d\n", led_cur->id);
+                        ret = -EINVAL;
+                        goto err_register;
+                }
+
+                if (init_led & (1 << led_cur->id)) {
+                        dev_err(&pdev->dev, "led %d already initialized\n",
+                                        led_cur->id);
+                        ret = -EINVAL;
+                        goto err_register;
+                }
+
+                init_led |= 1 << led_cur->id;
+                led_dat->cdev.name = led_cur->name;
+                led_dat->cdev.default_trigger = led_cur->default_trigger;
+                led_dat->cdev.brightness_set = mc13783_led_set;
+                led_dat->cdev.brightness = LED_OFF;
+                led_dat->id = led_cur->id;
+                led_dat->master = dev_get_drvdata(pdev->dev.parent);
+
+                INIT_WORK(&led_dat->work, mc13783_led_work);
+
+                ret = led_classdev_register(pdev->dev.parent, &led_dat->cdev);
+                if (ret) {
+                        dev_err(&pdev->dev, "failed to register led %d\n",
+                                        led_dat->id);
+                        goto err_register;
+                }
+
+                ret = mc13783_led_setup(led_dat, led_cur->max_current);
+                if (ret) {
+                        dev_err(&pdev->dev, "unable to init led %d\n",
+                                        led_dat->id);
+                        i++;
+                        goto err_register;
+                }
+        }
+
+        platform_set_drvdata(pdev, led);
+        return 0;
+
+err_register:
+        for (i = i - 1; i >= 0; i--) {
+                led_classdev_unregister(&led[i].cdev);
+                cancel_work_sync(&led[i].work);
+        }
+
+err_free:
+        kfree(led);
+        return ret;
+}
+
+static int __devexit mc13783_led_remove(struct platform_device *pdev)
+{
+        struct mc13783_leds_platform_data *pdata = dev_get_platdata(&pdev->dev);
+        struct mc13783_led *led = platform_get_drvdata(pdev);
+        struct mc13783 *dev = dev_get_drvdata(pdev->dev.parent);
+        int i;
+
+        for (i = 0; i < pdata->num_leds; i++) {
+                led_classdev_unregister(&led[i].cdev);
+                cancel_work_sync(&led[i].work);
+        }
+
+        mc13783_lock(dev);
+
+        mc13783_reg_write(dev, MC13783_REG_LED_CONTROL_0, 0);
+        mc13783_reg_write(dev, MC13783_REG_LED_CONTROL_1, 0);
+        mc13783_reg_write(dev, MC13783_REG_LED_CONTROL_2, 0);
+        mc13783_reg_write(dev, MC13783_REG_LED_CONTROL_3, 0);
+        mc13783_reg_write(dev, MC13783_REG_LED_CONTROL_4, 0);
+        mc13783_reg_write(dev, MC13783_REG_LED_CONTROL_5, 0);
+
+        mc13783_unlock(dev);
+
+        kfree(led);
+        return 0;
+}
+
+static struct platform_driver mc13783_led_driver = {
+        .driver = {
+                .name   = "mc13783-led",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = mc13783_led_probe,
+        .remove         = __devexit_p(mc13783_led_remove),
+};
+
+static int __init mc13783_led_init(void)
+{
+        return platform_driver_register(&mc13783_led_driver);
+}
+module_init(mc13783_led_init);
+
+static void __exit mc13783_led_exit(void)
+{
+        platform_driver_unregister(&mc13783_led_driver);
+}
+module_exit(mc13783_led_exit);
+
+MODULE_DESCRIPTION("LEDs driver for Freescale MC13783 PMIC");
+MODULE_AUTHOR("Philippe Retornaz <philippe.retornaz@epfl.ch>");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:mc13783-led");
diff --git a/drivers/leds/leds-net5501.c b/drivers/leds/leds-net5501.c
new file mode 100644
index 000000000000..3063f591f0dc
--- /dev/null
+++ b/drivers/leds/leds-net5501.c
@@ -0,0 +1,94 @@
+/*
+ * Soekris board support code
+ *
+ * Copyright (C) 2008-2009 Tower Technologies
+ * Written by Alessandro Zummo <a.zummo@towertech.it>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2
+ * as published by the Free Software Foundation.
+ */
+
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/io.h>
+#include <linux/string.h>
+#include <linux/leds.h>
+#include <linux/platform_device.h>
+#include <linux/gpio.h>
+
+#include <asm/geode.h>
+
+static struct gpio_led net5501_leds[] = {
+        {
+                .name = "error",
+                .gpio = 6,
+                .default_trigger = "default-on",
+        },
+};
+
+static struct gpio_led_platform_data net5501_leds_data = {
+        .num_leds = ARRAY_SIZE(net5501_leds),
+        .leds = net5501_leds,
+};
+
+static struct platform_device net5501_leds_dev = {
+        .name = "leds-gpio",
+        .id = -1,
+        .dev.platform_data = &net5501_leds_data,
+};
+
+static void __init init_net5501(void)
+{
+        platform_device_register(&net5501_leds_dev);
+}
+
+struct soekris_board {
+        u16     offset;
+        char    *sig;
+        u8      len;
+        void    (*init)(void);
+};
+
+static struct soekris_board __initdata boards[] = {
+        { 0xb7b, "net5501", 7, init_net5501 },  /* net5501 v1.33/1.33c */
+        { 0xb1f, "net5501", 7, init_net5501 },  /* net5501 v1.32i */
+};
+
+static int __init soekris_init(void)
+{
+        int i;
+        unsigned char *rombase, *bios;
+
+        if (!is_geode())
+                return 0;
+
+        rombase = ioremap(0xffff0000, 0xffff);
+        if (!rombase) {
+                printk(KERN_INFO "Soekris net5501 LED driver failed to get rombase");
+                return 0;
+        }
+
+        bios = rombase + 0x20;  /* null terminated */
+
+        if (strncmp(bios, "comBIOS", 7))
+                goto unmap;
+
+        for (i = 0; i < ARRAY_SIZE(boards); i++) {
+                unsigned char *model = rombase + boards[i].offset;
+
+                if (strncmp(model, boards[i].sig, boards[i].len) == 0) {
+                        printk(KERN_INFO "Soekris %s: %s\n", model, bios);
+
+                        if (boards[i].init)
+                                boards[i].init();
+                        break;
+                }
+        }
+
+unmap:
+        iounmap(rombase);
+        return 0;
+}
+
+arch_initcall(soekris_init);
diff --git a/drivers/leds/leds-ss4200.c b/drivers/leds/leds-ss4200.c
index 51477ec71391..a688293abd0b 100644
--- a/drivers/leds/leds-ss4200.c
+++ b/drivers/leds/leds-ss4200.c
@@ -534,7 +534,7 @@ static int __init nas_gpio_init(void)
         set_power_light_amber_noblink();
         return 0;
 out_err:
-        for (; i >= 0; i--)
+        for (i--; i >= 0; i--)
                 unregister_nasgpio_led(i);
         pci_unregister_driver(&nas_gpio_pci_driver);
         return ret;
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index 9ea17d6c799b..d2c0f94fa37d 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -4645,7 +4645,7 @@ static int raid456_cpu_notify(struct notifier_block *nfb, unsigned long action,
                         kfree(percpu->scribble);
                         pr_err("%s: failed memory allocation for cpu%ld\n",
                                __func__, cpu);
-                        return NOTIFY_BAD;
+                        return notifier_from_errno(-ENOMEM);
                 }
                 break;
         case CPU_DEAD:
diff --git a/drivers/message/i2o/i2o_config.c b/drivers/message/i2o/i2o_config.c
index d33693c13368..c4b117f5fb70 100644
--- a/drivers/message/i2o/i2o_config.c
+++ b/drivers/message/i2o/i2o_config.c
@@ -186,14 +186,9 @@ static int i2o_cfg_parms(unsigned long arg, unsigned int type)
         if (!dev)
                 return -ENXIO;
 
-        ops = kmalloc(kcmd.oplen, GFP_KERNEL);
-        if (!ops)
-                return -ENOMEM;
-
-        if (copy_from_user(ops, kcmd.opbuf, kcmd.oplen)) {
-                kfree(ops);
-                return -EFAULT;
-        }
+        ops = memdup_user(kcmd.opbuf, kcmd.oplen);
+        if (IS_ERR(ops))
+                return PTR_ERR(ops);
 
         /*
          * It's possible to have a _very_ large table
diff --git a/drivers/mfd/88pm860x-core.c b/drivers/mfd/88pm860x-core.c
index 405d2d5183cf..2c65a2c57294 100644
--- a/drivers/mfd/88pm860x-core.c
+++ b/drivers/mfd/88pm860x-core.c
@@ -566,7 +566,7 @@ out:
         return ret;
 }
 
-static void __devexit device_irq_exit(struct pm860x_chip *chip)
+static void device_irq_exit(struct pm860x_chip *chip)
 {
         if (chip->core_irq)
                 free_irq(chip->core_irq, chip);
@@ -703,7 +703,7 @@ out:
         return;
 }
 
-int pm860x_device_init(struct pm860x_chip *chip,
+int __devinit pm860x_device_init(struct pm860x_chip *chip,
                        struct pm860x_platform_data *pdata)
 {
         chip->core_irq = 0;
@@ -731,7 +731,7 @@ int pm860x_device_init(struct pm860x_chip *chip,
         return 0;
 }
 
-void pm860x_device_exit(struct pm860x_chip *chip)
+void __devexit pm860x_device_exit(struct pm860x_chip *chip)
 {
         device_irq_exit(chip);
         mfd_remove_devices(chip->dev);
diff --git a/drivers/mfd/88pm860x-i2c.c b/drivers/mfd/88pm860x-i2c.c
index 4a6e7186334e..c933b64d1283 100644
--- a/drivers/mfd/88pm860x-i2c.c
+++ b/drivers/mfd/88pm860x-i2c.c
@@ -200,8 +200,8 @@ static int __devexit pm860x_remove(struct i2c_client *client)
 
         pm860x_device_exit(chip);
         i2c_unregister_device(chip->companion);
-        i2c_set_clientdata(chip->companion, NULL);
         i2c_set_clientdata(chip->client, NULL);
+        i2c_set_clientdata(client, NULL);
         kfree(chip);
         return 0;
 }
diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig
index 3c6a9860dd9c..9da0e504bbe9 100644
--- a/drivers/mfd/Kconfig
+++ b/drivers/mfd/Kconfig
@@ -2,8 +2,14 @@
 # Multifunction miscellaneous devices
 #
 
-menu "Multifunction device drivers"
+menuconfig MFD_SUPPORT
+        bool "Multifunction device drivers"
         depends on HAS_IOMEM
+        default y
+        help
+          Configure MFD device drivers.
+
+if MFD_SUPPORT
 
 config MFD_CORE
         tristate
@@ -116,6 +122,18 @@ config TPS65010
           This driver can also be built as a module.  If so, the module
           will be called tps65010.
 
+config TPS6507X
+        tristate "TPS6507x Power Management / Touch Screen chips"
+        select MFD_CORE
+        depends on I2C
+        help
+          If you say yes here you get support for the TPS6507x series of
+          Power Management / Touch Screen chips.  These include voltage
+          regulators, lithium ion/polymer battery charging, touch screen
+          and other features that are often used in portable devices.
+          This driver can also be built as a module.  If so, the module
+          will be called tps6507x.
+
 config MENELAUS
         bool "Texas Instruments TWL92330/Menelaus PM chip"
         depends on I2C=y && ARCH_OMAP2
@@ -159,6 +177,17 @@ config TWL4030_CODEC
         select MFD_CORE
         default n
 
+config MFD_TC35892
+        bool "Support Toshiba TC35892"
+        depends on I2C=y && GENERIC_HARDIRQS
+        select MFD_CORE
+        help
+          Support for the Toshiba TC35892 I/O Expander.
+
+          This driver provides common support for accessing the device,
+          additional drivers must be enabled in order to use the
+          functionality of the device.
+
 config MFD_TMIO
         bool
         default n
@@ -351,9 +380,19 @@ config PCF50633_GPIO
          Say yes here if you want to include support GPIO for pins on
          the PCF50633 chip.
 
+config ABX500_CORE
+        bool "ST-Ericsson ABX500 Mixed Signal Circuit register functions"
+        default y if ARCH_U300
+        help
+          Say yes here if you have the ABX500 Mixed Signal IC family
+          chips. This core driver expose register access functions.
+          Functionality specific drivers using these functions can
+          remain unchanged when IC changes. Binding of the functions to
+          actual register access is done by the IC core driver.
+
 config AB3100_CORE
         bool "ST-Ericsson AB3100 Mixed Signal Circuit core functions"
-        depends on I2C=y
+        depends on I2C=y && ABX500_CORE
         default y if ARCH_U300
         help
           Select this to enable the AB3100 Mixed Signal IC core
@@ -381,15 +420,30 @@ config EZX_PCAP
           This enables the PCAP ASIC present on EZX Phones. This is
           needed for MMC, TouchScreen, Sound, USB, etc..
 
-config AB4500_CORE
-        tristate "ST-Ericsson's AB4500 Mixed Signal Power management chip"
-        depends on SPI
+config AB8500_CORE
+        bool "ST-Ericsson AB8500 Mixed Signal Power Management chip"
+        depends on SPI=y && GENERIC_HARDIRQS
+        select MFD_CORE
         help
-          Select this option to enable access to AB4500 power management
+          Select this option to enable access to AB8500 power management
           chip. This connects to U8500 on the SSP/SPI bus and exports
           read/write functions for the devices to get access to this chip.
           This chip embeds various other multimedia funtionalities as well.
 
+config AB3550_CORE
+        bool "ST-Ericsson AB3550 Mixed Signal Circuit core functions"
+        select MFD_CORE
+        depends on I2C=y && GENERIC_HARDIRQS && ABX500_CORE
+        help
+          Select this to enable the AB3550 Mixed Signal IC core
+          functionality. This connects to a AB3550 on the I2C bus
+          and expose a number of symbols needed for dependent devices
+          to read and write registers and subscribe to events from
+          this multi-functional IC. This is needed to use other features
+          of the AB3550 such as battery-backed RTC, charging control,
+          LEDs, vibrator, system power and temperature, power management
+          and ALSA sound.
+
 config MFD_TIMBERDALE
         tristate "Support for the Timberdale FPGA"
         select MFD_CORE
@@ -409,7 +463,26 @@ config LPC_SCH
           LPC bridge function of the Intel SCH provides support for
           System Management Bus and General Purpose I/O.
 
-endmenu
+config MFD_RDC321X
+        tristate "Support for RDC-R321x southbridge"
+        select MFD_CORE
+        depends on PCI
+        help
+          Say yes here if you want to have support for the RDC R-321x SoC
+          southbridge which provides access to GPIOs and Watchdog using the
+          southbridge PCI device configuration space.
+
+config MFD_JANZ_CMODIO
+        tristate "Support for Janz CMOD-IO PCI MODULbus Carrier Board"
+        select MFD_CORE
+        depends on PCI
+        help
+          This is the core driver for the Janz CMOD-IO PCI MODULbus
+          carrier board. This device is a PCI to MODULbus bridge which may
+          host many different types of MODULbus daughterboards, including
+          CAN and GPIO controllers.
+
+endif # MFD_SUPPORT
 
 menu "Multimedia Capabilities Port drivers"
         depends on ARCH_SA1100
diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile
index 87935f967aa0..fb503e77dc60 100644
--- a/drivers/mfd/Makefile
+++ b/drivers/mfd/Makefile
@@ -15,6 +15,7 @@ obj-$(CONFIG_HTC_I2CPLD)	+= htc-i2cpld.o
 obj-$(CONFIG_MFD_DAVINCI_VOICECODEC)    += davinci_voicecodec.o
 obj-$(CONFIG_MFD_DM355EVM_MSP)  += dm355evm_msp.o
 
+obj-$(CONFIG_MFD_TC35892)       += tc35892.o
 obj-$(CONFIG_MFD_T7L66XB)       += t7l66xb.o tmio_core.o
 obj-$(CONFIG_MFD_TC6387XB)      += tc6387xb.o tmio_core.o
 obj-$(CONFIG_MFD_TC6393XB)      += tc6393xb.o tmio_core.o
@@ -29,6 +30,7 @@ obj-$(CONFIG_MFD_WM8350_I2C)	+= wm8350-i2c.o
 obj-$(CONFIG_MFD_WM8994)        += wm8994-core.o wm8994-irq.o
 
 obj-$(CONFIG_TPS65010)          += tps65010.o
+obj-$(CONFIG_TPS6507X)          += tps6507x.o
 obj-$(CONFIG_MENELAUS)          += menelaus.o
 
 obj-$(CONFIG_TWL4030_CORE)      += twl-core.o twl4030-irq.o twl6030-irq.o
@@ -55,12 +57,17 @@ obj-$(CONFIG_PMIC_DA903X)	+= da903x.o
 max8925-objs                    := max8925-core.o max8925-i2c.o
 obj-$(CONFIG_MFD_MAX8925)       += max8925.o
 
-obj-$(CONFIG_MFD_PCF50633)      += pcf50633-core.o
+pcf50633-objs                   := pcf50633-core.o pcf50633-irq.o
+obj-$(CONFIG_MFD_PCF50633)      += pcf50633.o
 obj-$(CONFIG_PCF50633_ADC)      += pcf50633-adc.o
 obj-$(CONFIG_PCF50633_GPIO)     += pcf50633-gpio.o
+obj-$(CONFIG_ABX500_CORE)       += abx500-core.o
 obj-$(CONFIG_AB3100_CORE)       += ab3100-core.o
 obj-$(CONFIG_AB3100_OTP)        += ab3100-otp.o
-obj-$(CONFIG_AB4500_CORE)       += ab4500-core.o
+obj-$(CONFIG_AB3550_CORE)       += ab3550-core.o
+obj-$(CONFIG_AB8500_CORE)       += ab8500-core.o ab8500-spi.o
 obj-$(CONFIG_MFD_TIMBERDALE)    += timberdale.o
 obj-$(CONFIG_PMIC_ADP5520)      += adp5520.o
-obj-$(CONFIG_LPC_SCH)           += lpc_sch.o
\ No newline at end of file
+obj-$(CONFIG_LPC_SCH)           += lpc_sch.o
+obj-$(CONFIG_MFD_RDC321X)       += rdc321x-southbridge.o
+obj-$(CONFIG_MFD_JANZ_CMODIO)   += janz-cmodio.o
diff --git a/drivers/mfd/ab3100-core.c b/drivers/mfd/ab3100-core.c
index e4ca5909e424..53ebfee548fa 100644
--- a/drivers/mfd/ab3100-core.c
+++ b/drivers/mfd/ab3100-core.c
@@ -19,7 +19,7 @@
 #include <linux/debugfs.h>
 #include <linux/seq_file.h>
 #include <linux/uaccess.h>
-#include <linux/mfd/ab3100.h>
+#include <linux/mfd/abx500.h>
 
 /* These are the only registers inside AB3100 used in this main file */
 
@@ -59,24 +59,15 @@
  * The AB3100 is usually assigned address 0x48 (7-bit)
  * The chip is defined in the platform i2c_board_data section.
  */
-
-u8 ab3100_get_chip_type(struct ab3100 *ab3100)
+static int ab3100_get_chip_id(struct device *dev)
 {
-        u8 chip = ABUNKNOWN;
-
-        switch (ab3100->chip_id & 0xf0) {
-        case  0xa0:
-                chip = AB3000;
-                break;
-        case  0xc0:
-                chip = AB3100;
-                break;
-        }
-        return chip;
+        struct ab3100 *ab3100 = dev_get_drvdata(dev->parent);
+
+        return (int)ab3100->chip_id;
 }
-EXPORT_SYMBOL(ab3100_get_chip_type);
 
-int ab3100_set_register_interruptible(struct ab3100 *ab3100, u8 reg, u8 regval)
+static int ab3100_set_register_interruptible(struct ab3100 *ab3100,
+        u8 reg, u8 regval)
 {
         u8 regandval[2] = {reg, regval};
         int err;
@@ -108,8 +99,14 @@ int ab3100_set_register_interruptible(struct ab3100 *ab3100, u8 reg, u8 regval)
         mutex_unlock(&ab3100->access_mutex);
         return err;
 }
-EXPORT_SYMBOL(ab3100_set_register_interruptible);
 
+static int set_register_interruptible(struct device *dev,
+        u8 bank, u8 reg, u8 value)
+{
+        struct ab3100 *ab3100 = dev_get_drvdata(dev->parent);
+
+        return ab3100_set_register_interruptible(ab3100, reg, value);
+}
 
 /*
  * The test registers exist at an I2C bus address up one
@@ -148,8 +145,8 @@ static int ab3100_set_test_register_interruptible(struct ab3100 *ab3100,
         return err;
 }
 
-
-int ab3100_get_register_interruptible(struct ab3100 *ab3100, u8 reg, u8 *regval)
+static int ab3100_get_register_interruptible(struct ab3100 *ab3100,
+        u8 reg, u8 *regval)
 {
         int err;
 
@@ -203,10 +200,16 @@ int ab3100_get_register_interruptible(struct ab3100 *ab3100, u8 reg, u8 *regval)
         mutex_unlock(&ab3100->access_mutex);
         return err;
 }
-EXPORT_SYMBOL(ab3100_get_register_interruptible);
 
+static int get_register_interruptible(struct device *dev, u8 bank, u8 reg,
+        u8 *value)
+{
+        struct ab3100 *ab3100 = dev_get_drvdata(dev->parent);
+
+        return ab3100_get_register_interruptible(ab3100, reg, value);
+}
 
-int ab3100_get_register_page_interruptible(struct ab3100 *ab3100,
+static int ab3100_get_register_page_interruptible(struct ab3100 *ab3100,
                              u8 first_reg, u8 *regvals, u8 numregs)
 {
         int err;
@@ -260,10 +263,17 @@ int ab3100_get_register_page_interruptible(struct ab3100 *ab3100,
         mutex_unlock(&ab3100->access_mutex);
         return err;
 }
-EXPORT_SYMBOL(ab3100_get_register_page_interruptible);
 
+static int get_register_page_interruptible(struct device *dev, u8 bank,
+        u8 first_reg, u8 *regvals, u8 numregs)
+{
+        struct ab3100 *ab3100 = dev_get_drvdata(dev->parent);
+
+        return ab3100_get_register_page_interruptible(ab3100,
+                        first_reg, regvals, numregs);
+}
 
-int ab3100_mask_and_set_register_interruptible(struct ab3100 *ab3100,
+static int ab3100_mask_and_set_register_interruptible(struct ab3100 *ab3100,
                                  u8 reg, u8 andmask, u8 ormask)
 {
         u8 regandval[2] = {reg, 0};
@@ -331,8 +341,15 @@ int ab3100_mask_and_set_register_interruptible(struct ab3100 *ab3100,
         mutex_unlock(&ab3100->access_mutex);
         return err;
 }
-EXPORT_SYMBOL(ab3100_mask_and_set_register_interruptible);
 
+static int mask_and_set_register_interruptible(struct device *dev, u8 bank,
+        u8 reg, u8 bitmask, u8 bitvalues)
+{
+        struct ab3100 *ab3100 = dev_get_drvdata(dev->parent);
+
+        return ab3100_mask_and_set_register_interruptible(ab3100,
+                        reg, bitmask, (bitmask & bitvalues));
+}
 
 /*
  * Register a simple callback for handling any AB3100 events.
@@ -357,15 +374,27 @@ int ab3100_event_unregister(struct ab3100 *ab3100,
 EXPORT_SYMBOL(ab3100_event_unregister);
 
 
-int ab3100_event_registers_startup_state_get(struct ab3100 *ab3100,
-                                             u32 *fatevent)
+static int ab3100_event_registers_startup_state_get(struct device *dev,
+                                             u8 *event)
 {
+        struct ab3100 *ab3100 = dev_get_drvdata(dev->parent);
         if (!ab3100->startup_events_read)
                 return -EAGAIN; /* Try again later */
-        *fatevent = ab3100->startup_events;
+        memcpy(event, ab3100->startup_events, 3);
         return 0;
 }
-EXPORT_SYMBOL(ab3100_event_registers_startup_state_get);
+
+static struct abx500_ops ab3100_ops = {
+        .get_chip_id = ab3100_get_chip_id,
+        .set_register = set_register_interruptible,
+        .get_register = get_register_interruptible,
+        .get_register_page = get_register_page_interruptible,
+        .set_register_page = NULL,
+        .mask_and_set_register = mask_and_set_register_interruptible,
+        .event_registers_startup_state_get =
+                ab3100_event_registers_startup_state_get,
+        .startup_irq_enabled = NULL,
+};
 
 /*
  * This is a threaded interrupt handler so we can make some
@@ -390,7 +419,9 @@ static irqreturn_t ab3100_irq_handler(int irq, void *data)
                 event_regs[2];
 
         if (!ab3100->startup_events_read) {
-                ab3100->startup_events = fatevent;
+                ab3100->startup_events[0] = event_regs[0];
+                ab3100->startup_events[1] = event_regs[1];
+                ab3100->startup_events[2] = event_regs[2];
                 ab3100->startup_events_read = true;
         }
         /*
@@ -703,7 +734,8 @@ static int __init ab3100_setup(struct ab3100 *ab3100)
                 dev_warn(ab3100->dev,
                          "AB3100 P1E variant detected, "
                          "forcing chip to 32KHz\n");
-                err = ab3100_set_test_register_interruptible(ab3100, 0x02, 0x08);
+                err = ab3100_set_test_register_interruptible(ab3100,
+                        0x02, 0x08);
         }
 
  exit_no_setup:
@@ -898,6 +930,10 @@ static int __init ab3100_probe(struct i2c_client *client,
         if (err)
                 goto exit_no_irq;
 
+        err = abx500_register_ops(&client->dev, &ab3100_ops);
+        if (err)
+                goto exit_no_ops;
+
         /* Set parent and a pointer back to the container in device data */
         for (i = 0; i < ARRAY_SIZE(ab3100_platform_devs); i++) {
                 ab3100_platform_devs[i]->dev.parent =
@@ -915,11 +951,13 @@ static int __init ab3100_probe(struct i2c_client *client,
 
         return 0;
 
+ exit_no_ops:
  exit_no_irq:
  exit_no_setup:
         i2c_unregister_device(ab3100->testreg_client);
  exit_no_testreg_client:
  exit_no_detect:
+        i2c_set_clientdata(client, NULL);
         kfree(ab3100);
         return err;
 }
@@ -941,6 +979,7 @@ static int __exit ab3100_remove(struct i2c_client *client)
          * their notifiers so deactivate IRQ
          */
         free_irq(client->irq, ab3100);
+        i2c_set_clientdata(client, NULL);
         kfree(ab3100);
         return 0;
 }
diff --git a/drivers/mfd/ab3100-otp.c b/drivers/mfd/ab3100-otp.c
index 2d14655fdebd..63d2b727ddbb 100644
--- a/drivers/mfd/ab3100-otp.c
+++ b/drivers/mfd/ab3100-otp.c
@@ -12,7 +12,7 @@
 #include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/platform_device.h>
-#include <linux/mfd/ab3100.h>
+#include <linux/mfd/abx500.h>
 #include <linux/debugfs.h>
 #include <linux/seq_file.h>
 
@@ -30,7 +30,6 @@
 /**
  * struct ab3100_otp
  * @dev containing device
- * @ab3100 a pointer to the parent ab3100 device struct
  * @locked whether the OTP is locked, after locking, no more bits
  *       can be changed but before locking it is still possible
  *       to change bits from 1->0.
@@ -49,7 +48,6 @@
  */
 struct ab3100_otp {
         struct device *dev;
-        struct ab3100 *ab3100;
         bool locked;
         u32 freq;
         bool paf;
@@ -63,19 +61,19 @@ struct ab3100_otp {
 
 static int __init ab3100_otp_read(struct ab3100_otp *otp)
 {
-        struct ab3100 *ab = otp->ab3100;
         u8 otpval[8];
         u8 otpp;
         int err;
 
-        err = ab3100_get_register_interruptible(ab, AB3100_OTPP, &otpp);
+        err = abx500_get_register_interruptible(otp->dev, 0,
+                AB3100_OTPP, &otpp);
         if (err) {
                 dev_err(otp->dev, "unable to read OTPP register\n");
                 return err;
         }
 
-        err = ab3100_get_register_page_interruptible(ab, AB3100_OTP0,
-                                                     otpval, 8);
+        err = abx500_get_register_page_interruptible(otp->dev, 0,
+                AB3100_OTP0, otpval, 8);
         if (err) {
                 dev_err(otp->dev, "unable to read OTP register page\n");
                 return err;
@@ -197,7 +195,6 @@ static int __init ab3100_otp_probe(struct platform_device *pdev)
         otp->dev = &pdev->dev;
 
         /* Replace platform data coming in with a local struct */
-        otp->ab3100 = platform_get_drvdata(pdev);
         platform_set_drvdata(pdev, otp);
 
         err = ab3100_otp_read(otp);
diff --git a/drivers/mfd/ab3550-core.c b/drivers/mfd/ab3550-core.c
new file mode 100644
index 000000000000..1060f8e1c40a
--- /dev/null
+++ b/drivers/mfd/ab3550-core.c
@@ -0,0 +1,1401 @@
+/*
+ * Copyright (C) 2007-2010 ST-Ericsson
+ * License terms: GNU General Public License (GPL) version 2
+ * Low-level core for exclusive access to the AB3550 IC on the I2C bus
+ * and some basic chip-configuration.
+ * Author: Bengt Jonsson <bengt.g.jonsson@stericsson.com>
+ * Author: Mattias Nilsson <mattias.i.nilsson@stericsson.com>
+ * Author: Mattias Wallin <mattias.wallin@stericsson.com>
+ * Author: Rickard Andersson <rickard.andersson@stericsson.com>
+ */
+
+#include <linux/i2c.h>
+#include <linux/mutex.h>
+#include <linux/err.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/device.h>
+#include <linux/irq.h>
+#include <linux/interrupt.h>
+#include <linux/random.h>
+#include <linux/workqueue.h>
+#include <linux/debugfs.h>
+#include <linux/seq_file.h>
+#include <linux/uaccess.h>
+#include <linux/mfd/abx500.h>
+#include <linux/list.h>
+#include <linux/bitops.h>
+#include <linux/spinlock.h>
+#include <linux/mfd/core.h>
+
+#define AB3550_NAME_STRING "ab3550"
+#define AB3550_ID_FORMAT_STRING "AB3550 %s"
+#define AB3550_NUM_BANKS 2
+#define AB3550_NUM_EVENT_REG 5
+
+/* These are the only registers inside AB3550 used in this main file */
+
+/* Chip ID register */
+#define AB3550_CID_REG           0x20
+
+/* Interrupt event registers */
+#define AB3550_EVENT_BANK        0
+#define AB3550_EVENT_REG         0x22
+
+/* Read/write operation values. */
+#define AB3550_PERM_RD (0x01)
+#define AB3550_PERM_WR (0x02)
+
+/* Read/write permissions. */
+#define AB3550_PERM_RO (AB3550_PERM_RD)
+#define AB3550_PERM_RW (AB3550_PERM_RD | AB3550_PERM_WR)
+
+/**
+ * struct ab3550
+ * @access_mutex: lock out concurrent accesses to the AB registers
+ * @i2c_client: I2C client for this chip
+ * @chip_name: name of this chip variant
+ * @chip_id: 8 bit chip ID for this chip variant
+ * @mask_work: a worker for writing to mask registers
+ * @event_lock: a lock to protect the event_mask
+ * @event_mask: a local copy of the mask event registers
+ * @startup_events: a copy of the first reading of the event registers
+ * @startup_events_read: whether the first events have been read
+ */
+struct ab3550 {
+        struct mutex access_mutex;
+        struct i2c_client *i2c_client[AB3550_NUM_BANKS];
+        char chip_name[32];
+        u8 chip_id;
+        struct work_struct mask_work;
+        spinlock_t event_lock;
+        u8 event_mask[AB3550_NUM_EVENT_REG];
+        u8 startup_events[AB3550_NUM_EVENT_REG];
+        bool startup_events_read;
+#ifdef CONFIG_DEBUG_FS
+        unsigned int debug_bank;
+        unsigned int debug_address;
+#endif
+};
+
+/**
+ * struct ab3550_reg_range
+ * @first: the first address of the range
+ * @last: the last address of the range
+ * @perm: access permissions for the range
+ */
+struct ab3550_reg_range {
+        u8 first;
+        u8 last;
+        u8 perm;
+};
+
+/**
+ * struct ab3550_reg_ranges
+ * @count: the number of ranges in the list
+ * @range: the list of register ranges
+ */
+struct ab3550_reg_ranges {
+        u8 count;
+        const struct ab3550_reg_range *range;
+};
+
+/*
+ * Permissible register ranges for reading and writing per device and bank.
+ *
+ * The ranges must be listed in increasing address order, and no overlaps are
+ * allowed. It is assumed that write permission implies read permission
+ * (i.e. only RO and RW permissions should be used).  Ranges with write
+ * permission must not be split up.
+ */
+
+#define NO_RANGE {.count = 0, .range = NULL,}
+
+static struct
+ab3550_reg_ranges ab3550_reg_ranges[AB3550_NUM_DEVICES][AB3550_NUM_BANKS] = {
+        [AB3550_DEVID_DAC] = {
+                NO_RANGE,
+                {
+                        .count = 2,
+                        .range = (struct ab3550_reg_range[]) {
+                                {
+                                        .first = 0xb0,
+                                        .last = 0xba,
+                                        .perm = AB3550_PERM_RW,
+                                },
+                                {
+                                        .first = 0xbc,
+                                        .last = 0xc3,
+                                        .perm = AB3550_PERM_RW,
+                                },
+                        },
+                },
+        },
+        [AB3550_DEVID_LEDS] = {
+                NO_RANGE,
+                {
+                        .count = 2,
+                        .range = (struct ab3550_reg_range[]) {
+                                {
+                                        .first = 0x5a,
+                                        .last = 0x88,
+                                        .perm = AB3550_PERM_RW,
+                                },
+                                {
+                                        .first = 0x8a,
+                                        .last = 0xad,
+                                        .perm = AB3550_PERM_RW,
+                                },
+                        }
+                },
+        },
+        [AB3550_DEVID_POWER] = {
+                {
+                        .count = 1,
+                        .range = (struct ab3550_reg_range[]) {
+                                {
+                                        .first = 0x21,
+                                        .last = 0x21,
+                                        .perm = AB3550_PERM_RO,
+                                },
+                        }
+                },
+                NO_RANGE,
+        },
+        [AB3550_DEVID_REGULATORS] = {
+                {
+                        .count = 1,
+                        .range = (struct ab3550_reg_range[]) {
+                                {
+                                        .first = 0x69,
+                                        .last = 0xa3,
+                                        .perm = AB3550_PERM_RW,
+                                },
+                        }
+                },
+                {
+                        .count = 1,
+                        .range = (struct ab3550_reg_range[]) {
+                                {
+                                        .first = 0x14,
+                                        .last = 0x16,
+                                        .perm = AB3550_PERM_RW,
+                                },
+                        }
+                },
+        },
+        [AB3550_DEVID_SIM] = {
+                {
+                        .count = 1,
+                        .range = (struct ab3550_reg_range[]) {
+                                {
+                                        .first = 0x21,
+                                        .last = 0x21,
+                                        .perm = AB3550_PERM_RO,
+                                },
+                        }
+                },
+                {
+                        .count = 1,
+                        .range = (struct ab3550_reg_range[]) {
+                                {
+                                        .first = 0x14,
+                                        .last = 0x17,
+                                        .perm = AB3550_PERM_RW,
+                                },
+                        }
+
+                },
+        },
+        [AB3550_DEVID_UART] = {
+                NO_RANGE,
+                NO_RANGE,
+        },
+        [AB3550_DEVID_RTC] = {
+                {
+                        .count = 1,
+                        .range = (struct ab3550_reg_range[]) {
+                                {
+                                        .first = 0x00,
+                                        .last = 0x0c,
+                                        .perm = AB3550_PERM_RW,
+                                },
+                        }
+                },
+                NO_RANGE,
+        },
+        [AB3550_DEVID_CHARGER] = {
+                {
+                        .count = 2,
+                        .range = (struct ab3550_reg_range[]) {
+                                {
+                                        .first = 0x10,
+                                        .last = 0x1a,
+                                        .perm = AB3550_PERM_RW,
+                                },
+                                {
+                                        .first = 0x21,
+                                        .last = 0x21,
+                                        .perm = AB3550_PERM_RO,
+                                },
+                        }
+                },
+                NO_RANGE,
+        },
+        [AB3550_DEVID_ADC] = {
+                NO_RANGE,
+                {
+                        .count = 1,
+                        .range = (struct ab3550_reg_range[]) {
+                                {
+                                        .first = 0x20,
+                                        .last = 0x56,
+                                        .perm = AB3550_PERM_RW,
+                                },
+
+                        }
+                },
+        },
+        [AB3550_DEVID_FUELGAUGE] = {
+                {
+                        .count = 1,
+                        .range = (struct ab3550_reg_range[]) {
+                                {
+                                        .first = 0x21,
+                                        .last = 0x21,
+                                        .perm = AB3550_PERM_RO,
+                                },
+                        }
+                },
+                {
+                        .count = 1,
+                        .range = (struct ab3550_reg_range[]) {
+                                {
+                                        .first = 0x00,
+                                        .last = 0x0e,
+                                        .perm = AB3550_PERM_RW,
+                                },
+                        }
+                },
+        },
+        [AB3550_DEVID_VIBRATOR] = {
+                NO_RANGE,
+                {
+                        .count = 1,
+                        .range = (struct ab3550_reg_range[]) {
+                                {
+                                        .first = 0x10,
+                                        .last = 0x13,
+                                        .perm = AB3550_PERM_RW,
+                                },
+
+                        }
+                },
+        },
+        [AB3550_DEVID_CODEC] = {
+                {
+                        .count = 2,
+                        .range = (struct ab3550_reg_range[]) {
+                                {
+                                        .first = 0x31,
+                                        .last = 0x63,
+                                        .perm = AB3550_PERM_RW,
+                                },
+                                {
+                                        .first = 0x65,
+                                        .last = 0x68,
+                                        .perm = AB3550_PERM_RW,
+                                },
+                        }
+                },
+                NO_RANGE,
+        },
+};
+
+static struct mfd_cell ab3550_devs[AB3550_NUM_DEVICES] = {
+        [AB3550_DEVID_DAC] = {
+                .name = "ab3550-dac",
+                .id = AB3550_DEVID_DAC,
+                .num_resources = 0,
+        },
+        [AB3550_DEVID_LEDS] = {
+                .name = "ab3550-leds",
+                .id = AB3550_DEVID_LEDS,
+        },
+        [AB3550_DEVID_POWER] = {
+                .name = "ab3550-power",
+                .id = AB3550_DEVID_POWER,
+        },
+        [AB3550_DEVID_REGULATORS] = {
+                .name = "ab3550-regulators",
+                .id = AB3550_DEVID_REGULATORS,
+        },
+        [AB3550_DEVID_SIM] = {
+                .name = "ab3550-sim",
+                .id = AB3550_DEVID_SIM,
+        },
+        [AB3550_DEVID_UART] = {
+                .name = "ab3550-uart",
+                .id = AB3550_DEVID_UART,
+        },
+        [AB3550_DEVID_RTC] = {
+                .name = "ab3550-rtc",
+                .id = AB3550_DEVID_RTC,
+        },
+        [AB3550_DEVID_CHARGER] = {
+                .name = "ab3550-charger",
+                .id = AB3550_DEVID_CHARGER,
+        },
+        [AB3550_DEVID_ADC] = {
+                .name = "ab3550-adc",
+                .id = AB3550_DEVID_ADC,
+                .num_resources = 10,
+                .resources = (struct resource[]) {
+                        {
+                                .name = "TRIGGER-0",
+                                .flags = IORESOURCE_IRQ,
+                                .start = 16,
+                                .end = 16,
+                        },
+                        {
+                                .name = "TRIGGER-1",
+                                .flags = IORESOURCE_IRQ,
+                                .start = 17,
+                                .end = 17,
+                        },
+                        {
+                                .name = "TRIGGER-2",
+                                .flags = IORESOURCE_IRQ,
+                                .start = 18,
+                                .end = 18,
+                        },
+                        {
+                                .name = "TRIGGER-3",
+                                .flags = IORESOURCE_IRQ,
+                                .start = 19,
+                                .end = 19,
+                        },
+                        {
+                                .name = "TRIGGER-4",
+                                .flags = IORESOURCE_IRQ,
+                                .start = 20,
+                                .end = 20,
+                        },
+                        {
+                                .name = "TRIGGER-5",
+                                .flags = IORESOURCE_IRQ,
+                                .start = 21,
+                                .end = 21,
+                        },
+                        {
+                                .name = "TRIGGER-6",
+                                .flags = IORESOURCE_IRQ,
+                                .start = 22,
+                                .end = 22,
+                        },
+                        {
+                                .name = "TRIGGER-7",
+                                .flags = IORESOURCE_IRQ,
+                                .start = 23,
+                                .end = 23,
+                        },
+                        {
+                                .name = "TRIGGER-VBAT-TXON",
+                                .flags = IORESOURCE_IRQ,
+                                .start = 13,
+                                .end = 13,
+                        },
+                        {
+                                .name = "TRIGGER-VBAT",
+                                .flags = IORESOURCE_IRQ,
+                                .start = 12,
+                                .end = 12,
+                        },
+                },
+        },
+        [AB3550_DEVID_FUELGAUGE] = {
+                .name = "ab3550-fuelgauge",
+                .id = AB3550_DEVID_FUELGAUGE,
+        },
+        [AB3550_DEVID_VIBRATOR] = {
+                .name = "ab3550-vibrator",
+                .id = AB3550_DEVID_VIBRATOR,
+        },
+        [AB3550_DEVID_CODEC] = {
+                .name = "ab3550-codec",
+                .id = AB3550_DEVID_CODEC,
+        },
+};
+
+/*
+ * I2C transactions with error messages.
+ */
+static int ab3550_i2c_master_send(struct ab3550 *ab, u8 bank, u8 *data,
+        u8 count)
+{
+        int err;
+
+        err = i2c_master_send(ab->i2c_client[bank], data, count);
+        if (err < 0) {
+                dev_err(&ab->i2c_client[0]->dev, "send error: %d\n", err);
+                return err;
+        }
+        return 0;
+}
+
+static int ab3550_i2c_master_recv(struct ab3550 *ab, u8 bank, u8 *data,
+        u8 count)
+{
+        int err;
+
+        err = i2c_master_recv(ab->i2c_client[bank], data, count);
+        if (err < 0) {
+                dev_err(&ab->i2c_client[0]->dev, "receive error: %d\n", err);
+                return err;
+        }
+        return 0;
+}
+
+/*
+ * Functionality for getting/setting register values.
+ */
+static int get_register_interruptible(struct ab3550 *ab, u8 bank, u8 reg,
+        u8 *value)
+{
+        int err;
+
+        err = mutex_lock_interruptible(&ab->access_mutex);
+        if (err)
+                return err;
+
+        err = ab3550_i2c_master_send(ab, bank, &reg, 1);
+        if (!err)
+                err = ab3550_i2c_master_recv(ab, bank, value, 1);
+
+        mutex_unlock(&ab->access_mutex);
+        return err;
+}
+
+static int get_register_page_interruptible(struct ab3550 *ab, u8 bank,
+        u8 first_reg, u8 *regvals, u8 numregs)
+{
+        int err;
+
+        err = mutex_lock_interruptible(&ab->access_mutex);
+        if (err)
+                return err;
+
+        err = ab3550_i2c_master_send(ab, bank, &first_reg, 1);
+        if (!err)
+                err = ab3550_i2c_master_recv(ab, bank, regvals, numregs);
+
+        mutex_unlock(&ab->access_mutex);
+        return err;
+}
+
+static int mask_and_set_register_interruptible(struct ab3550 *ab, u8 bank,
+        u8 reg, u8 bitmask, u8 bitvalues)
+{
+        int err = 0;
+
+        if (likely(bitmask)) {
+                u8 reg_bits[2] = {reg, 0};
+
+                err = mutex_lock_interruptible(&ab->access_mutex);
+                if (err)
+                        return err;
+
+                if (bitmask == 0xFF) /* No need to read in this case. */
+                        reg_bits[1] = bitvalues;
+                else { /* Read and modify the register value. */
+                        u8 bits;
+
+                        err = ab3550_i2c_master_send(ab, bank, &reg, 1);
+                        if (err)
+                                goto unlock_and_return;
+                        err = ab3550_i2c_master_recv(ab, bank, &bits, 1);
+                        if (err)
+                                goto unlock_and_return;
+                        reg_bits[1] = ((~bitmask & bits) |
+                                (bitmask & bitvalues));
+                }
+                /* Write the new value. */
+                err = ab3550_i2c_master_send(ab, bank, reg_bits, 2);
+unlock_and_return:
+                mutex_unlock(&ab->access_mutex);
+        }
+        return err;
+}
+
+/*
+ * Read/write permission checking functions.
+ */
+static bool page_write_allowed(const struct ab3550_reg_ranges *ranges,
+        u8 first_reg, u8 last_reg)
+{
+        u8 i;
+
+        if (last_reg < first_reg)
+                return false;
+
+        for (i = 0; i < ranges->count; i++) {
+                if (first_reg < ranges->range[i].first)
+                        break;
+                if ((last_reg <= ranges->range[i].last) &&
+                        (ranges->range[i].perm & AB3550_PERM_WR))
+                        return true;
+        }
+        return false;
+}
+
+static bool reg_write_allowed(const struct ab3550_reg_ranges *ranges, u8 reg)
+{
+        return page_write_allowed(ranges, reg, reg);
+}
+
+static bool page_read_allowed(const struct ab3550_reg_ranges *ranges,
+        u8 first_reg, u8 last_reg)
+{
+        u8 i;
+
+        if (last_reg < first_reg)
+                return false;
+        /* Find the range (if it exists in the list) that includes first_reg. */
+        for (i = 0; i < ranges->count; i++) {
+                if (first_reg < ranges->range[i].first)
+                        return false;
+                if (first_reg <= ranges->range[i].last)
+                        break;
+        }
+        /* Make sure that the entire range up to and including last_reg is
+         * readable. This may span several of the ranges in the list.
+         */
+        while ((i < ranges->count) &&
+                (ranges->range[i].perm & AB3550_PERM_RD)) {
+                if (last_reg <= ranges->range[i].last)
+                        return true;
+                if ((++i >= ranges->count) ||
+                        (ranges->range[i].first !=
+                         (ranges->range[i - 1].last + 1))) {
+                        break;
+                }
+        }
+        return false;
+}
+
+static bool reg_read_allowed(const struct ab3550_reg_ranges *ranges, u8 reg)
+{
+        return page_read_allowed(ranges, reg, reg);
+}
+
+/*
+ * The exported register access functionality.
+ */
+int ab3550_get_chip_id(struct device *dev)
+{
+        struct ab3550 *ab = dev_get_drvdata(dev->parent);
+        return (int)ab->chip_id;
+}
+
+int ab3550_mask_and_set_register_interruptible(struct device *dev, u8 bank,
+        u8 reg, u8 bitmask, u8 bitvalues)
+{
+        struct ab3550 *ab;
+        struct platform_device *pdev = to_platform_device(dev);
+
+        if ((AB3550_NUM_BANKS <= bank) ||
+                !reg_write_allowed(&ab3550_reg_ranges[pdev->id][bank], reg))
+                return -EINVAL;
+
+        ab = dev_get_drvdata(dev->parent);
+        return mask_and_set_register_interruptible(ab, bank, reg,
+                bitmask, bitvalues);
+}
+
+int ab3550_set_register_interruptible(struct device *dev, u8 bank, u8 reg,
+        u8 value)
+{
+        return ab3550_mask_and_set_register_interruptible(dev, bank, reg, 0xFF,
+                value);
+}
+
+int ab3550_get_register_interruptible(struct device *dev, u8 bank, u8 reg,
+        u8 *value)
+{
+        struct ab3550 *ab;
+        struct platform_device *pdev = to_platform_device(dev);
+
+        if ((AB3550_NUM_BANKS <= bank) ||
+                !reg_read_allowed(&ab3550_reg_ranges[pdev->id][bank], reg))
+                return -EINVAL;
+
+        ab = dev_get_drvdata(dev->parent);
+        return get_register_interruptible(ab, bank, reg, value);
+}
+
+int ab3550_get_register_page_interruptible(struct device *dev, u8 bank,
+        u8 first_reg, u8 *regvals, u8 numregs)
+{
+        struct ab3550 *ab;
+        struct platform_device *pdev = to_platform_device(dev);
+
+        if ((AB3550_NUM_BANKS <= bank) ||
+                !page_read_allowed(&ab3550_reg_ranges[pdev->id][bank],
+                        first_reg, (first_reg + numregs - 1)))
+                return -EINVAL;
+
+        ab = dev_get_drvdata(dev->parent);
+        return get_register_page_interruptible(ab, bank, first_reg, regvals,
+                numregs);
+}
+
+int ab3550_event_registers_startup_state_get(struct device *dev, u8 *event)
+{
+        struct ab3550 *ab;
+
+        ab = dev_get_drvdata(dev->parent);
+        if (!ab->startup_events_read)
+                return -EAGAIN; /* Try again later */
+
+        memcpy(event, ab->startup_events, AB3550_NUM_EVENT_REG);
+        return 0;
+}
+
+int ab3550_startup_irq_enabled(struct device *dev, unsigned int irq)
+{
+        struct ab3550 *ab;
+        struct ab3550_platform_data *plf_data;
+        bool val;
+
+        ab = get_irq_chip_data(irq);
+        plf_data = ab->i2c_client[0]->dev.platform_data;
+        irq -= plf_data->irq.base;
+        val = ((ab->startup_events[irq / 8] & BIT(irq % 8)) != 0);
+
+        return val;
+}
+
+static struct abx500_ops ab3550_ops = {
+        .get_chip_id = ab3550_get_chip_id,
+        .get_register = ab3550_get_register_interruptible,
+        .set_register = ab3550_set_register_interruptible,
+        .get_register_page = ab3550_get_register_page_interruptible,
+        .set_register_page = NULL,
+        .mask_and_set_register = ab3550_mask_and_set_register_interruptible,
+        .event_registers_startup_state_get =
+                ab3550_event_registers_startup_state_get,
+        .startup_irq_enabled = ab3550_startup_irq_enabled,
+};
+
+static irqreturn_t ab3550_irq_handler(int irq, void *data)
+{
+        struct ab3550 *ab = data;
+        int err;
+        unsigned int i;
+        u8 e[AB3550_NUM_EVENT_REG];
+        u8 *events;
+        unsigned long flags;
+
+        events = (ab->startup_events_read ? e : ab->startup_events);
+
+        err = get_register_page_interruptible(ab, AB3550_EVENT_BANK,
+                AB3550_EVENT_REG, events, AB3550_NUM_EVENT_REG);
+        if (err)
+                goto err_event_rd;
+
+        if (!ab->startup_events_read) {
+                dev_info(&ab->i2c_client[0]->dev,
+                        "startup events 0x%x,0x%x,0x%x,0x%x,0x%x\n",
+                        ab->startup_events[0], ab->startup_events[1],
+                        ab->startup_events[2], ab->startup_events[3],
+                        ab->startup_events[4]);
+                ab->startup_events_read = true;
+                goto out;
+        }
+
+        /* The two highest bits in event[4] are not used. */
+        events[4] &= 0x3f;
+
+        spin_lock_irqsave(&ab->event_lock, flags);
+        for (i = 0; i < AB3550_NUM_EVENT_REG; i++)
+                events[i] &= ~ab->event_mask[i];
+        spin_unlock_irqrestore(&ab->event_lock, flags);
+
+        for (i = 0; i < AB3550_NUM_EVENT_REG; i++) {
+                u8 bit;
+                u8 event_reg;
+
+                dev_dbg(&ab->i2c_client[0]->dev, "IRQ Event[%d]: 0x%2x\n",
+                        i, events[i]);
+
+                event_reg = events[i];
+                for (bit = 0; event_reg; bit++, event_reg /= 2) {
+                        if (event_reg % 2) {
+                                unsigned int irq;
+                                struct ab3550_platform_data *plf_data;
+
+                                plf_data = ab->i2c_client[0]->dev.platform_data;
+                                irq = plf_data->irq.base + (i * 8) + bit;
+                                handle_nested_irq(irq);
+                        }
+                }
+        }
+out:
+        return IRQ_HANDLED;
+
+err_event_rd:
+        dev_dbg(&ab->i2c_client[0]->dev, "error reading event registers\n");
+        return IRQ_HANDLED;
+}
+
+#ifdef CONFIG_DEBUG_FS
+static struct ab3550_reg_ranges debug_ranges[AB3550_NUM_BANKS] = {
+        {
+                .count = 6,
+                .range = (struct ab3550_reg_range[]) {
+                        {
+                                .first = 0x00,
+                                .last = 0x0e,
+                        },
+                        {
+                                .first = 0x10,
+                                .last = 0x1a,
+                        },
+                        {
+                                .first = 0x1e,
+                                .last = 0x4f,
+                        },
+                        {
+                                .first = 0x51,
+                                .last = 0x63,
+                        },
+                        {
+                                .first = 0x65,
+                                .last = 0xa3,
+                        },
+                        {
+                                .first = 0xa5,
+                                .last = 0xa8,
+                        },
+                }
+        },
+        {
+                .count = 8,
+                .range = (struct ab3550_reg_range[]) {
+                        {
+                                .first = 0x00,
+                                .last = 0x0e,
+                        },
+                        {
+                                .first = 0x10,
+                                .last = 0x17,
+                        },
+                        {
+                                .first = 0x1a,
+                                .last = 0x1c,
+                        },
+                        {
+                                .first = 0x20,
+                                .last = 0x56,
+                        },
+                        {
+                                .first = 0x5a,
+                                .last = 0x88,
+                        },
+                        {
+                                .first = 0x8a,
+                                .last = 0xad,
+                        },
+                        {
+                                .first = 0xb0,
+                                .last = 0xba,
+                        },
+                        {
+                                .first = 0xbc,
+                                .last = 0xc3,
+                        },
+                }
+        },
+};
+
+static int ab3550_registers_print(struct seq_file *s, void *p)
+{
+        struct ab3550 *ab = s->private;
+        int bank;
+
+        seq_printf(s, AB3550_NAME_STRING " register values:\n");
+
+        for (bank = 0; bank < AB3550_NUM_BANKS; bank++) {
+                unsigned int i;
+
+                seq_printf(s, " bank %d:\n", bank);
+                for (i = 0; i < debug_ranges[bank].count; i++) {
+                        u8 reg;
+
+                        for (reg = debug_ranges[bank].range[i].first;
+                                reg <= debug_ranges[bank].range[i].last;
+                                reg++) {
+                                u8 value;
+
+                                get_register_interruptible(ab, bank, reg,
+                                        &value);
+                                seq_printf(s, "  [%d/0x%02X]: 0x%02X\n", bank,
+                                        reg, value);
+                        }
+                }
+        }
+        return 0;
+}
+
+static int ab3550_registers_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, ab3550_registers_print, inode->i_private);
+}
+
+static const struct file_operations ab3550_registers_fops = {
+        .open = ab3550_registers_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+        .owner = THIS_MODULE,
+};
+
+static int ab3550_bank_print(struct seq_file *s, void *p)
+{
+        struct ab3550 *ab = s->private;
+
+        seq_printf(s, "%d\n", ab->debug_bank);
+        return 0;
+}
+
+static int ab3550_bank_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, ab3550_bank_print, inode->i_private);
+}
+
+static ssize_t ab3550_bank_write(struct file *file,
+        const char __user *user_buf,
+        size_t count, loff_t *ppos)
+{
+        struct ab3550 *ab = ((struct seq_file *)(file->private_data))->private;
+        char buf[32];
+        int buf_size;
+        unsigned long user_bank;
+        int err;
+
+        /* Get userspace string and assure termination */
+        buf_size = min(count, (sizeof(buf) - 1));
+        if (copy_from_user(buf, user_buf, buf_size))
+                return -EFAULT;
+        buf[buf_size] = 0;
+
+        err = strict_strtoul(buf, 0, &user_bank);
+        if (err)
+                return -EINVAL;
+
+        if (user_bank >= AB3550_NUM_BANKS) {
+                dev_err(&ab->i2c_client[0]->dev,
+                        "debugfs error input > number of banks\n");
+                return -EINVAL;
+        }
+
+        ab->debug_bank = user_bank;
+
+        return buf_size;
+}
+
+static int ab3550_address_print(struct seq_file *s, void *p)
+{
+        struct ab3550 *ab = s->private;
+
+        seq_printf(s, "0x%02X\n", ab->debug_address);
+        return 0;
+}
+
+static int ab3550_address_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, ab3550_address_print, inode->i_private);
+}
+
+static ssize_t ab3550_address_write(struct file *file,
+        const char __user *user_buf,
+        size_t count, loff_t *ppos)
+{
+        struct ab3550 *ab = ((struct seq_file *)(file->private_data))->private;
+        char buf[32];
+        int buf_size;
+        unsigned long user_address;
+        int err;
+
+        /* Get userspace string and assure termination */
+        buf_size = min(count, (sizeof(buf) - 1));
+        if (copy_from_user(buf, user_buf, buf_size))
+                return -EFAULT;
+        buf[buf_size] = 0;
+
+        err = strict_strtoul(buf, 0, &user_address);
+        if (err)
+                return -EINVAL;
+        if (user_address > 0xff) {
+                dev_err(&ab->i2c_client[0]->dev,
+                        "debugfs error input > 0xff\n");
+                return -EINVAL;
+        }
+        ab->debug_address = user_address;
+        return buf_size;
+}
+
+static int ab3550_val_print(struct seq_file *s, void *p)
+{
+        struct ab3550 *ab = s->private;
+        int err;
+        u8 regvalue;
+
+        err = get_register_interruptible(ab, (u8)ab->debug_bank,
+                (u8)ab->debug_address, &regvalue);
+        if (err)
+                return -EINVAL;
+        seq_printf(s, "0x%02X\n", regvalue);
+
+        return 0;
+}
+
+static int ab3550_val_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, ab3550_val_print, inode->i_private);
+}
+
+static ssize_t ab3550_val_write(struct file *file,
+        const char __user *user_buf,
+        size_t count, loff_t *ppos)
+{
+        struct ab3550 *ab = ((struct seq_file *)(file->private_data))->private;
+        char buf[32];
+        int buf_size;
+        unsigned long user_val;
+        int err;
+        u8 regvalue;
+
+        /* Get userspace string and assure termination */
+        buf_size = min(count, (sizeof(buf)-1));
+        if (copy_from_user(buf, user_buf, buf_size))
+                return -EFAULT;
+        buf[buf_size] = 0;
+
+        err = strict_strtoul(buf, 0, &user_val);
+        if (err)
+                return -EINVAL;
+        if (user_val > 0xff) {
+                dev_err(&ab->i2c_client[0]->dev,
+                        "debugfs error input > 0xff\n");
+                return -EINVAL;
+        }
+        err = mask_and_set_register_interruptible(
+                ab, (u8)ab->debug_bank,
+                (u8)ab->debug_address, 0xFF, (u8)user_val);
+        if (err)
+                return -EINVAL;
+
+        get_register_interruptible(ab, (u8)ab->debug_bank,
+                (u8)ab->debug_address, &regvalue);
+        if (err)
+                return -EINVAL;
+
+        return buf_size;
+}
+
+static const struct file_operations ab3550_bank_fops = {
+        .open = ab3550_bank_open,
+        .write = ab3550_bank_write,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+        .owner = THIS_MODULE,
+};
+
+static const struct file_operations ab3550_address_fops = {
+        .open = ab3550_address_open,
+        .write = ab3550_address_write,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+        .owner = THIS_MODULE,
+};
+
+static const struct file_operations ab3550_val_fops = {
+        .open = ab3550_val_open,
+        .write = ab3550_val_write,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+        .owner = THIS_MODULE,
+};
+
+static struct dentry *ab3550_dir;
+static struct dentry *ab3550_reg_file;
+static struct dentry *ab3550_bank_file;
+static struct dentry *ab3550_address_file;
+static struct dentry *ab3550_val_file;
+
+static inline void ab3550_setup_debugfs(struct ab3550 *ab)
+{
+        ab->debug_bank = 0;
+        ab->debug_address = 0x00;
+
+        ab3550_dir = debugfs_create_dir(AB3550_NAME_STRING, NULL);
+        if (!ab3550_dir)
+                goto exit_no_debugfs;
+
+        ab3550_reg_file = debugfs_create_file("all-registers",
+                S_IRUGO, ab3550_dir, ab, &ab3550_registers_fops);
+        if (!ab3550_reg_file)
+                goto exit_destroy_dir;
+
+        ab3550_bank_file = debugfs_create_file("register-bank",
+                (S_IRUGO | S_IWUGO), ab3550_dir, ab, &ab3550_bank_fops);
+        if (!ab3550_bank_file)
+                goto exit_destroy_reg;
+
+        ab3550_address_file = debugfs_create_file("register-address",
+                (S_IRUGO | S_IWUGO), ab3550_dir, ab, &ab3550_address_fops);
+        if (!ab3550_address_file)
+                goto exit_destroy_bank;
+
+        ab3550_val_file = debugfs_create_file("register-value",
+                (S_IRUGO | S_IWUGO), ab3550_dir, ab, &ab3550_val_fops);
+        if (!ab3550_val_file)
+                goto exit_destroy_address;
+
+        return;
+
+exit_destroy_address:
+        debugfs_remove(ab3550_address_file);
+exit_destroy_bank:
+        debugfs_remove(ab3550_bank_file);
+exit_destroy_reg:
+        debugfs_remove(ab3550_reg_file);
+exit_destroy_dir:
+        debugfs_remove(ab3550_dir);
+exit_no_debugfs:
+        dev_err(&ab->i2c_client[0]->dev, "failed to create debugfs entries.\n");
+        return;
+}
+
+static inline void ab3550_remove_debugfs(void)
+{
+        debugfs_remove(ab3550_val_file);
+        debugfs_remove(ab3550_address_file);
+        debugfs_remove(ab3550_bank_file);
+        debugfs_remove(ab3550_reg_file);
+        debugfs_remove(ab3550_dir);
+}
+
+#else /* !CONFIG_DEBUG_FS */
+static inline void ab3550_setup_debugfs(struct ab3550 *ab)
+{
+}
+static inline void ab3550_remove_debugfs(void)
+{
+}
+#endif
+
+/*
+ * Basic set-up, datastructure creation/destruction and I2C interface.
+ * This sets up a default config in the AB3550 chip so that it
+ * will work as expected.
+ */
+static int __init ab3550_setup(struct ab3550 *ab)
+{
+        int err = 0;
+        int i;
+        struct ab3550_platform_data *plf_data;
+        struct abx500_init_settings *settings;
+
+        plf_data = ab->i2c_client[0]->dev.platform_data;
+        settings = plf_data->init_settings;
+
+        for (i = 0; i < plf_data->init_settings_sz; i++) {
+                err = mask_and_set_register_interruptible(ab,
+                        settings[i].bank,
+                        settings[i].reg,
+                        0xFF, settings[i].setting);
+                if (err)
+                        goto exit_no_setup;
+
+                /* If event mask register update the event mask in ab3550 */
+                if ((settings[i].bank == 0) &&
+                        (AB3550_IMR1 <= settings[i].reg) &&
+                        (settings[i].reg <= AB3550_IMR5)) {
+                        ab->event_mask[settings[i].reg - AB3550_IMR1] =
+                                settings[i].setting;
+                }
+        }
+exit_no_setup:
+        return err;
+}
+
+static void ab3550_mask_work(struct work_struct *work)
+{
+        struct ab3550 *ab = container_of(work, struct ab3550, mask_work);
+        int i;
+        unsigned long flags;
+        u8 mask[AB3550_NUM_EVENT_REG];
+
+        spin_lock_irqsave(&ab->event_lock, flags);
+        for (i = 0; i < AB3550_NUM_EVENT_REG; i++)
+                mask[i] = ab->event_mask[i];
+        spin_unlock_irqrestore(&ab->event_lock, flags);
+
+        for (i = 0; i < AB3550_NUM_EVENT_REG; i++) {
+                int err;
+
+                err = mask_and_set_register_interruptible(ab, 0,
+                        (AB3550_IMR1 + i), ~0, mask[i]);
+                if (err)
+                        dev_err(&ab->i2c_client[0]->dev,
+                                "ab3550_mask_work failed 0x%x,0x%x\n",
+                                (AB3550_IMR1 + i), mask[i]);
+        }
+}
+
+static void ab3550_mask(unsigned int irq)
+{
+        unsigned long flags;
+        struct ab3550 *ab;
+        struct ab3550_platform_data *plf_data;
+
+        ab = get_irq_chip_data(irq);
+        plf_data = ab->i2c_client[0]->dev.platform_data;
+        irq -= plf_data->irq.base;
+
+        spin_lock_irqsave(&ab->event_lock, flags);
+        ab->event_mask[irq / 8] |= BIT(irq % 8);
+        spin_unlock_irqrestore(&ab->event_lock, flags);
+
+        schedule_work(&ab->mask_work);
+}
+
+static void ab3550_unmask(unsigned int irq)
+{
+        unsigned long flags;
+        struct ab3550 *ab;
+        struct ab3550_platform_data *plf_data;
+
+        ab = get_irq_chip_data(irq);
+        plf_data = ab->i2c_client[0]->dev.platform_data;
+        irq -= plf_data->irq.base;
+
+        spin_lock_irqsave(&ab->event_lock, flags);
+        ab->event_mask[irq / 8] &= ~BIT(irq % 8);
+        spin_unlock_irqrestore(&ab->event_lock, flags);
+
+        schedule_work(&ab->mask_work);
+}
+
+static void noop(unsigned int irq)
+{
+}
+
+static struct irq_chip ab3550_irq_chip = {
+        .name           = "ab3550-core", /* Keep the same name as the request */
+        .startup        = NULL, /* defaults to enable */
+        .shutdown       = NULL, /* defaults to disable */
+        .enable         = NULL, /* defaults to unmask */
+        .disable        = ab3550_mask, /* No default to mask in chip.c */
+        .ack            = noop,
+        .mask           = ab3550_mask,
+        .unmask         = ab3550_unmask,
+        .end            = NULL,
+};
+
+struct ab_family_id {
+        u8      id;
+        char    *name;
+};
+
+static const struct ab_family_id ids[] __initdata = {
+        /* AB3550 */
+        {
+                .id = AB3550_P1A,
+                .name = "P1A"
+        },
+        /* Terminator */
+        {
+                .id = 0x00,
+        }
+};
+
+static int __init ab3550_probe(struct i2c_client *client,
+        const struct i2c_device_id *id)
+{
+        struct ab3550 *ab;
+        struct ab3550_platform_data *ab3550_plf_data =
+                client->dev.platform_data;
+        int err;
+        int i;
+        int num_i2c_clients = 0;
+
+        ab = kzalloc(sizeof(struct ab3550), GFP_KERNEL);
+        if (!ab) {
+                dev_err(&client->dev,
+                        "could not allocate " AB3550_NAME_STRING " device\n");
+                return -ENOMEM;
+        }
+
+        /* Initialize data structure */
+        mutex_init(&ab->access_mutex);
+        spin_lock_init(&ab->event_lock);
+        ab->i2c_client[0] = client;
+
+        i2c_set_clientdata(client, ab);
+
+        /* Read chip ID register */
+        err = get_register_interruptible(ab, 0, AB3550_CID_REG, &ab->chip_id);
+        if (err) {
+                dev_err(&client->dev, "could not communicate with the analog "
+                        "baseband chip\n");
+                goto exit_no_detect;
+        }
+
+        for (i = 0; ids[i].id != 0x0; i++) {
+                if (ids[i].id == ab->chip_id) {
+                        snprintf(&ab->chip_name[0], sizeof(ab->chip_name) - 1,
+                                AB3550_ID_FORMAT_STRING, ids[i].name);
+                        break;
+                }
+        }
+
+        if (ids[i].id == 0x0) {
+                dev_err(&client->dev, "unknown analog baseband chip id: 0x%x\n",
+                        ab->chip_id);
+                dev_err(&client->dev, "driver not started!\n");
+                goto exit_no_detect;
+        }
+
+        dev_info(&client->dev, "detected AB chip: %s\n", &ab->chip_name[0]);
+
+        /* Attach other dummy I2C clients. */
+        while (++num_i2c_clients < AB3550_NUM_BANKS) {
+                ab->i2c_client[num_i2c_clients] =
+                        i2c_new_dummy(client->adapter,
+                                (client->addr + num_i2c_clients));
+                if (!ab->i2c_client[num_i2c_clients]) {
+                        err = -ENOMEM;
+                        goto exit_no_dummy_client;
+                }
+                strlcpy(ab->i2c_client[num_i2c_clients]->name, id->name,
+                        sizeof(ab->i2c_client[num_i2c_clients]->name));
+        }
+
+        err = ab3550_setup(ab);
+        if (err)
+                goto exit_no_setup;
+
+        INIT_WORK(&ab->mask_work, ab3550_mask_work);
+
+        for (i = 0; i < ab3550_plf_data->irq.count; i++) {
+                unsigned int irq;
+
+                irq = ab3550_plf_data->irq.base + i;
+                set_irq_chip_data(irq, ab);
+                set_irq_chip_and_handler(irq, &ab3550_irq_chip,
+                        handle_simple_irq);
+                set_irq_nested_thread(irq, 1);
+#ifdef CONFIG_ARM
+                set_irq_flags(irq, IRQF_VALID);
+#else
+                set_irq_noprobe(irq);
+#endif
+        }
+
+        err = request_threaded_irq(client->irq, NULL, ab3550_irq_handler,
+                IRQF_ONESHOT, "ab3550-core", ab);
+        /* This real unpredictable IRQ is of course sampled for entropy */
+        rand_initialize_irq(client->irq);
+
+        if (err)
+                goto exit_no_irq;
+
+        err = abx500_register_ops(&client->dev, &ab3550_ops);
+        if (err)
+                goto exit_no_ops;
+
+        /* Set up and register the platform devices. */
+        for (i = 0; i < AB3550_NUM_DEVICES; i++) {
+                ab3550_devs[i].platform_data = ab3550_plf_data->dev_data[i];
+                ab3550_devs[i].data_size = ab3550_plf_data->dev_data_sz[i];
+        }
+
+        err = mfd_add_devices(&client->dev, 0, ab3550_devs,
+                ARRAY_SIZE(ab3550_devs), NULL,
+                ab3550_plf_data->irq.base);
+
+        ab3550_setup_debugfs(ab);
+
+        return 0;
+
+exit_no_ops:
+exit_no_irq:
+exit_no_setup:
+exit_no_dummy_client:
+        /* Unregister the dummy i2c clients. */
+        while (--num_i2c_clients)
+                i2c_unregister_device(ab->i2c_client[num_i2c_clients]);
+exit_no_detect:
+        kfree(ab);
+        return err;
+}
+
+static int __exit ab3550_remove(struct i2c_client *client)
+{
+        struct ab3550 *ab = i2c_get_clientdata(client);
+        int num_i2c_clients = AB3550_NUM_BANKS;
+
+        mfd_remove_devices(&client->dev);
+        ab3550_remove_debugfs();
+
+        while (--num_i2c_clients)
+                i2c_unregister_device(ab->i2c_client[num_i2c_clients]);
+
+        /*
+         * At this point, all subscribers should have unregistered
+         * their notifiers so deactivate IRQ
+         */
+        free_irq(client->irq, ab);
+        i2c_set_clientdata(client, NULL);
+        kfree(ab);
+        return 0;
+}
+
+static const struct i2c_device_id ab3550_id[] = {
+        {AB3550_NAME_STRING, 0},
+        {}
+};
+MODULE_DEVICE_TABLE(i2c, ab3550_id);
+
+static struct i2c_driver ab3550_driver = {
+        .driver = {
+                .name   = AB3550_NAME_STRING,
+                .owner  = THIS_MODULE,
+        },
+        .id_table       = ab3550_id,
+        .probe          = ab3550_probe,
+        .remove         = __exit_p(ab3550_remove),
+};
+
+static int __init ab3550_i2c_init(void)
+{
+        return i2c_add_driver(&ab3550_driver);
+}
+
+static void __exit ab3550_i2c_exit(void)
+{
+        i2c_del_driver(&ab3550_driver);
+}
+
+subsys_initcall(ab3550_i2c_init);
+module_exit(ab3550_i2c_exit);
+
+MODULE_AUTHOR("Mattias Wallin <mattias.wallin@stericsson.com>");
+MODULE_DESCRIPTION("AB3550 core driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/mfd/ab4500-core.c b/drivers/mfd/ab4500-core.c
deleted file mode 100644
index c275daa3ab1a..000000000000
--- a/drivers/mfd/ab4500-core.c
+++ /dev/null
@@ -1,209 +0,0 @@
-/*
- * Copyright (C) 2009 ST-Ericsson
- *
- * Author: Srinidhi KASAGAR <srinidhi.kasagar@stericsson.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.
- *
- * AB4500 is a companion power management chip used with U8500.
- * On this platform, this is interfaced with SSP0 controller
- * which is a ARM primecell pl022.
- *
- * At the moment the module just exports read/write features.
- * Interrupt management to be added - TODO.
- */
-#include <linux/kernel.h>
-#include <linux/slab.h>
-#include <linux/init.h>
-#include <linux/module.h>
-#include <linux/platform_device.h>
-#include <linux/spi/spi.h>
-#include <linux/mfd/ab4500.h>
-
-/* just required if probe fails, we need to
- * unregister the device
- */
-static struct spi_driver ab4500_driver;
-
-/*
- * This funtion writes to any AB4500 registers using
- * SPI protocol &  before it writes it packs the data
- * in the below 24 bit frame format
- *
- *       *|------------------------------------|
- *       *| 23|22...18|17.......10|9|8|7......0|
- *       *| r/w  bank       adr          data  |
- *       * ------------------------------------
- *
- * This function shouldn't be called from interrupt
- * context
- */
-int ab4500_write(struct ab4500 *ab4500, unsigned char block,
-                unsigned long addr, unsigned char data)
-{
-        struct spi_transfer xfer;
-        struct spi_message      msg;
-        int err;
-        unsigned long spi_data =
-                block << 18 | addr << 10 | data;
-
-        mutex_lock(&ab4500->lock);
-        ab4500->tx_buf[0] = spi_data;
-        ab4500->rx_buf[0] = 0;
-
-        xfer.tx_buf     = ab4500->tx_buf;
-        xfer.rx_buf     = NULL;
-        xfer.len        = sizeof(unsigned long);
-
-        spi_message_init(&msg);
-        spi_message_add_tail(&xfer, &msg);
-
-        err = spi_sync(ab4500->spi, &msg);
-        mutex_unlock(&ab4500->lock);
-
-        return err;
-}
-EXPORT_SYMBOL(ab4500_write);
-
-int ab4500_read(struct ab4500 *ab4500, unsigned char block,
-                unsigned long addr)
-{
-        struct spi_transfer xfer;
-        struct spi_message      msg;
-        unsigned long spi_data =
-                1 << 23 | block << 18 | addr << 10;
-
-        mutex_lock(&ab4500->lock);
-        ab4500->tx_buf[0] = spi_data;
-        ab4500->rx_buf[0] = 0;
-
-        xfer.tx_buf     = ab4500->tx_buf;
-        xfer.rx_buf     = ab4500->rx_buf;
-        xfer.len        = sizeof(unsigned long);
-
-        spi_message_init(&msg);
-        spi_message_add_tail(&xfer, &msg);
-
-        spi_sync(ab4500->spi, &msg);
-        mutex_unlock(&ab4500->lock);
-
-        return  ab4500->rx_buf[0];
-}
-EXPORT_SYMBOL(ab4500_read);
-
-/* ref: ab3100 core */
-#define AB4500_DEVICE(devname, devid)                           \
-static struct platform_device ab4500_##devname##_device = {     \
-        .name   = devid,                                        \
-        .id     = -1,                                           \
-}
-
-/* list of childern devices of ab4500 - all are
- * not populated here - TODO
- */
-AB4500_DEVICE(charger, "ab4500-charger");
-AB4500_DEVICE(audio, "ab4500-audio");
-AB4500_DEVICE(usb, "ab4500-usb");
-AB4500_DEVICE(tvout, "ab4500-tvout");
-AB4500_DEVICE(sim, "ab4500-sim");
-AB4500_DEVICE(gpadc, "ab4500-gpadc");
-AB4500_DEVICE(clkmgt, "ab4500-clkmgt");
-AB4500_DEVICE(misc, "ab4500-misc");
-
-static struct platform_device *ab4500_platform_devs[] = {
-        &ab4500_charger_device,
-        &ab4500_audio_device,
-        &ab4500_usb_device,
-        &ab4500_tvout_device,
-        &ab4500_sim_device,
-        &ab4500_gpadc_device,
-        &ab4500_clkmgt_device,
-        &ab4500_misc_device,
-};
-
-static int __init ab4500_probe(struct spi_device *spi)
-{
-        struct ab4500   *ab4500;
-        unsigned char revision;
-        int err = 0;
-        int i;
-
-        ab4500 = kzalloc(sizeof *ab4500, GFP_KERNEL);
-        if (!ab4500) {
-                dev_err(&spi->dev, "could not allocate AB4500\n");
-                err = -ENOMEM;
-                goto not_detect;
-        }
-
-        ab4500->spi = spi;
-        spi_set_drvdata(spi, ab4500);
-
-        mutex_init(&ab4500->lock);
-
-        /* read the revision register */
-        revision = ab4500_read(ab4500, AB4500_MISC, AB4500_REV_REG);
-
-        /* revision id 0x0 is for early drop, 0x10 is for cut1.0 */
-        if (revision == 0x0 || revision == 0x10)
-                dev_info(&spi->dev, "Detected chip: %s, revision = %x\n",
-                        ab4500_driver.driver.name, revision);
-        else    {
-                dev_err(&spi->dev, "unknown chip: 0x%x\n", revision);
-                goto not_detect;
-        }
-
-        for (i = 0; i < ARRAY_SIZE(ab4500_platform_devs); i++)  {
-                ab4500_platform_devs[i]->dev.parent =
-                        &spi->dev;
-                platform_set_drvdata(ab4500_platform_devs[i], ab4500);
-        }
-
-        /* register the ab4500 platform devices */
-        platform_add_devices(ab4500_platform_devs,
-                        ARRAY_SIZE(ab4500_platform_devs));
-
-        return err;
-
- not_detect:
-        spi_unregister_driver(&ab4500_driver);
-        kfree(ab4500);
-        return err;
-}
-
-static int __devexit ab4500_remove(struct spi_device *spi)
-{
-        struct ab4500 *ab4500 =
-                spi_get_drvdata(spi);
-
-        kfree(ab4500);
-
-        return 0;
-}
-
-static struct spi_driver ab4500_driver = {
-        .driver = {
-                .name = "ab4500",
-                .owner = THIS_MODULE,
-        },
-        .probe = ab4500_probe,
-        .remove = __devexit_p(ab4500_remove)
-};
-
-static int __devinit ab4500_init(void)
-{
-        return spi_register_driver(&ab4500_driver);
-}
-
-static void __exit ab4500_exit(void)
-{
-        spi_unregister_driver(&ab4500_driver);
-}
-
-subsys_initcall(ab4500_init);
-module_exit(ab4500_exit);
-
-MODULE_AUTHOR("Srinidhi KASAGAR <srinidhi.kasagar@stericsson.com");
-MODULE_DESCRIPTION("AB4500 core driver");
-MODULE_LICENSE("GPL");
diff --git a/drivers/mfd/ab8500-core.c b/drivers/mfd/ab8500-core.c
new file mode 100644
index 000000000000..f3d26fa9c34d
--- /dev/null
+++ b/drivers/mfd/ab8500-core.c
@@ -0,0 +1,444 @@
+/*
+ * Copyright (C) ST-Ericsson SA 2010
+ *
+ * License Terms: GNU General Public License v2
+ * Author: Srinidhi Kasagar <srinidhi.kasagar@stericsson.com>
+ * Author: Rabin Vincent <rabin.vincent@stericsson.com>
+ */
+
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/init.h>
+#include <linux/irq.h>
+#include <linux/delay.h>
+#include <linux/interrupt.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/mfd/core.h>
+#include <linux/mfd/ab8500.h>
+
+/*
+ * Interrupt register offsets
+ * Bank : 0x0E
+ */
+#define AB8500_IT_SOURCE1_REG           0x0E00
+#define AB8500_IT_SOURCE2_REG           0x0E01
+#define AB8500_IT_SOURCE3_REG           0x0E02
+#define AB8500_IT_SOURCE4_REG           0x0E03
+#define AB8500_IT_SOURCE5_REG           0x0E04
+#define AB8500_IT_SOURCE6_REG           0x0E05
+#define AB8500_IT_SOURCE7_REG           0x0E06
+#define AB8500_IT_SOURCE8_REG           0x0E07
+#define AB8500_IT_SOURCE19_REG          0x0E12
+#define AB8500_IT_SOURCE20_REG          0x0E13
+#define AB8500_IT_SOURCE21_REG          0x0E14
+#define AB8500_IT_SOURCE22_REG          0x0E15
+#define AB8500_IT_SOURCE23_REG          0x0E16
+#define AB8500_IT_SOURCE24_REG          0x0E17
+
+/*
+ * latch registers
+ */
+#define AB8500_IT_LATCH1_REG            0x0E20
+#define AB8500_IT_LATCH2_REG            0x0E21
+#define AB8500_IT_LATCH3_REG            0x0E22
+#define AB8500_IT_LATCH4_REG            0x0E23
+#define AB8500_IT_LATCH5_REG            0x0E24
+#define AB8500_IT_LATCH6_REG            0x0E25
+#define AB8500_IT_LATCH7_REG            0x0E26
+#define AB8500_IT_LATCH8_REG            0x0E27
+#define AB8500_IT_LATCH9_REG            0x0E28
+#define AB8500_IT_LATCH10_REG           0x0E29
+#define AB8500_IT_LATCH19_REG           0x0E32
+#define AB8500_IT_LATCH20_REG           0x0E33
+#define AB8500_IT_LATCH21_REG           0x0E34
+#define AB8500_IT_LATCH22_REG           0x0E35
+#define AB8500_IT_LATCH23_REG           0x0E36
+#define AB8500_IT_LATCH24_REG           0x0E37
+
+/*
+ * mask registers
+ */
+
+#define AB8500_IT_MASK1_REG             0x0E40
+#define AB8500_IT_MASK2_REG             0x0E41
+#define AB8500_IT_MASK3_REG             0x0E42
+#define AB8500_IT_MASK4_REG             0x0E43
+#define AB8500_IT_MASK5_REG             0x0E44
+#define AB8500_IT_MASK6_REG             0x0E45
+#define AB8500_IT_MASK7_REG             0x0E46
+#define AB8500_IT_MASK8_REG             0x0E47
+#define AB8500_IT_MASK9_REG             0x0E48
+#define AB8500_IT_MASK10_REG            0x0E49
+#define AB8500_IT_MASK11_REG            0x0E4A
+#define AB8500_IT_MASK12_REG            0x0E4B
+#define AB8500_IT_MASK13_REG            0x0E4C
+#define AB8500_IT_MASK14_REG            0x0E4D
+#define AB8500_IT_MASK15_REG            0x0E4E
+#define AB8500_IT_MASK16_REG            0x0E4F
+#define AB8500_IT_MASK17_REG            0x0E50
+#define AB8500_IT_MASK18_REG            0x0E51
+#define AB8500_IT_MASK19_REG            0x0E52
+#define AB8500_IT_MASK20_REG            0x0E53
+#define AB8500_IT_MASK21_REG            0x0E54
+#define AB8500_IT_MASK22_REG            0x0E55
+#define AB8500_IT_MASK23_REG            0x0E56
+#define AB8500_IT_MASK24_REG            0x0E57
+
+#define AB8500_REV_REG                  0x1080
+
+/*
+ * Map interrupt numbers to the LATCH and MASK register offsets, Interrupt
+ * numbers are indexed into this array with (num / 8).
+ *
+ * This is one off from the register names, i.e. AB8500_IT_MASK1_REG is at
+ * offset 0.
+ */
+static const int ab8500_irq_regoffset[AB8500_NUM_IRQ_REGS] = {
+        0, 1, 2, 3, 4, 6, 7, 8, 9, 18, 19, 20, 21,
+};
+
+static int __ab8500_write(struct ab8500 *ab8500, u16 addr, u8 data)
+{
+        int ret;
+
+        dev_vdbg(ab8500->dev, "wr: addr %#x <= %#x\n", addr, data);
+
+        ret = ab8500->write(ab8500, addr, data);
+        if (ret < 0)
+                dev_err(ab8500->dev, "failed to write reg %#x: %d\n",
+                        addr, ret);
+
+        return ret;
+}
+
+/**
+ * ab8500_write() - write an AB8500 register
+ * @ab8500: device to write to
+ * @addr: address of the register
+ * @data: value to write
+ */
+int ab8500_write(struct ab8500 *ab8500, u16 addr, u8 data)
+{
+        int ret;
+
+        mutex_lock(&ab8500->lock);
+        ret = __ab8500_write(ab8500, addr, data);
+        mutex_unlock(&ab8500->lock);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(ab8500_write);
+
+static int __ab8500_read(struct ab8500 *ab8500, u16 addr)
+{
+        int ret;
+
+        ret = ab8500->read(ab8500, addr);
+        if (ret < 0)
+                dev_err(ab8500->dev, "failed to read reg %#x: %d\n",
+                        addr, ret);
+
+        dev_vdbg(ab8500->dev, "rd: addr %#x => data %#x\n", addr, ret);
+
+        return ret;
+}
+
+/**
+ * ab8500_read() - read an AB8500 register
+ * @ab8500: device to read from
+ * @addr: address of the register
+ */
+int ab8500_read(struct ab8500 *ab8500, u16 addr)
+{
+        int ret;
+
+        mutex_lock(&ab8500->lock);
+        ret = __ab8500_read(ab8500, addr);
+        mutex_unlock(&ab8500->lock);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(ab8500_read);
+
+/**
+ * ab8500_set_bits() - set a bitfield in an AB8500 register
+ * @ab8500: device to read from
+ * @addr: address of the register
+ * @mask: mask of the bitfield to modify
+ * @data: value to set to the bitfield
+ */
+int ab8500_set_bits(struct ab8500 *ab8500, u16 addr, u8 mask, u8 data)
+{
+        int ret;
+
+        mutex_lock(&ab8500->lock);
+
+        ret = __ab8500_read(ab8500, addr);
+        if (ret < 0)
+                goto out;
+
+        ret &= ~mask;
+        ret |= data;
+
+        ret = __ab8500_write(ab8500, addr, ret);
+
+out:
+        mutex_unlock(&ab8500->lock);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(ab8500_set_bits);
+
+static void ab8500_irq_lock(unsigned int irq)
+{
+        struct ab8500 *ab8500 = get_irq_chip_data(irq);
+
+        mutex_lock(&ab8500->irq_lock);
+}
+
+static void ab8500_irq_sync_unlock(unsigned int irq)
+{
+        struct ab8500 *ab8500 = get_irq_chip_data(irq);
+        int i;
+
+        for (i = 0; i < AB8500_NUM_IRQ_REGS; i++) {
+                u8 old = ab8500->oldmask[i];
+                u8 new = ab8500->mask[i];
+                int reg;
+
+                if (new == old)
+                        continue;
+
+                ab8500->oldmask[i] = new;
+
+                reg = AB8500_IT_MASK1_REG + ab8500_irq_regoffset[i];
+                ab8500_write(ab8500, reg, new);
+        }
+
+        mutex_unlock(&ab8500->irq_lock);
+}
+
+static void ab8500_irq_mask(unsigned int irq)
+{
+        struct ab8500 *ab8500 = get_irq_chip_data(irq);
+        int offset = irq - ab8500->irq_base;
+        int index = offset / 8;
+        int mask = 1 << (offset % 8);
+
+        ab8500->mask[index] |= mask;
+}
+
+static void ab8500_irq_unmask(unsigned int irq)
+{
+        struct ab8500 *ab8500 = get_irq_chip_data(irq);
+        int offset = irq - ab8500->irq_base;
+        int index = offset / 8;
+        int mask = 1 << (offset % 8);
+
+        ab8500->mask[index] &= ~mask;
+}
+
+static struct irq_chip ab8500_irq_chip = {
+        .name                   = "ab8500",
+        .bus_lock               = ab8500_irq_lock,
+        .bus_sync_unlock        = ab8500_irq_sync_unlock,
+        .mask                   = ab8500_irq_mask,
+        .unmask                 = ab8500_irq_unmask,
+};
+
+static irqreturn_t ab8500_irq(int irq, void *dev)
+{
+        struct ab8500 *ab8500 = dev;
+        int i;
+
+        dev_vdbg(ab8500->dev, "interrupt\n");
+
+        for (i = 0; i < AB8500_NUM_IRQ_REGS; i++) {
+                int regoffset = ab8500_irq_regoffset[i];
+                int status;
+
+                status = ab8500_read(ab8500, AB8500_IT_LATCH1_REG + regoffset);
+                if (status <= 0)
+                        continue;
+
+                do {
+                        int bit = __ffs(status);
+                        int line = i * 8 + bit;
+
+                        handle_nested_irq(ab8500->irq_base + line);
+                        status &= ~(1 << bit);
+                } while (status);
+        }
+
+        return IRQ_HANDLED;
+}
+
+static int ab8500_irq_init(struct ab8500 *ab8500)
+{
+        int base = ab8500->irq_base;
+        int irq;
+
+        for (irq = base; irq < base + AB8500_NR_IRQS; irq++) {
+                set_irq_chip_data(irq, ab8500);
+                set_irq_chip_and_handler(irq, &ab8500_irq_chip,
+                                         handle_simple_irq);
+                set_irq_nested_thread(irq, 1);
+#ifdef CONFIG_ARM
+                set_irq_flags(irq, IRQF_VALID);
+#else
+                set_irq_noprobe(irq);
+#endif
+        }
+
+        return 0;
+}
+
+static void ab8500_irq_remove(struct ab8500 *ab8500)
+{
+        int base = ab8500->irq_base;
+        int irq;
+
+        for (irq = base; irq < base + AB8500_NR_IRQS; irq++) {
+#ifdef CONFIG_ARM
+                set_irq_flags(irq, 0);
+#endif
+                set_irq_chip_and_handler(irq, NULL, NULL);
+                set_irq_chip_data(irq, NULL);
+        }
+}
+
+static struct resource ab8500_gpadc_resources[] = {
+        {
+                .name   = "HW_CONV_END",
+                .start  = AB8500_INT_GP_HW_ADC_CONV_END,
+                .end    = AB8500_INT_GP_HW_ADC_CONV_END,
+                .flags  = IORESOURCE_IRQ,
+        },
+        {
+                .name   = "SW_CONV_END",
+                .start  = AB8500_INT_GP_SW_ADC_CONV_END,
+                .end    = AB8500_INT_GP_SW_ADC_CONV_END,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct resource ab8500_rtc_resources[] = {
+        {
+                .name   = "60S",
+                .start  = AB8500_INT_RTC_60S,
+                .end    = AB8500_INT_RTC_60S,
+                .flags  = IORESOURCE_IRQ,
+        },
+        {
+                .name   = "ALARM",
+                .start  = AB8500_INT_RTC_ALARM,
+                .end    = AB8500_INT_RTC_ALARM,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct mfd_cell ab8500_devs[] = {
+        {
+                .name = "ab8500-gpadc",
+                .num_resources = ARRAY_SIZE(ab8500_gpadc_resources),
+                .resources = ab8500_gpadc_resources,
+        },
+        {
+                .name = "ab8500-rtc",
+                .num_resources = ARRAY_SIZE(ab8500_rtc_resources),
+                .resources = ab8500_rtc_resources,
+        },
+        { .name = "ab8500-charger", },
+        { .name = "ab8500-audio", },
+        { .name = "ab8500-usb", },
+        { .name = "ab8500-pwm", },
+};
+
+int __devinit ab8500_init(struct ab8500 *ab8500)
+{
+        struct ab8500_platform_data *plat = dev_get_platdata(ab8500->dev);
+        int ret;
+        int i;
+
+        if (plat)
+                ab8500->irq_base = plat->irq_base;
+
+        mutex_init(&ab8500->lock);
+        mutex_init(&ab8500->irq_lock);
+
+        ret = ab8500_read(ab8500, AB8500_REV_REG);
+        if (ret < 0)
+                return ret;
+
+        /*
+         * 0x0 - Early Drop
+         * 0x10 - Cut 1.0
+         * 0x11 - Cut 1.1
+         */
+        if (ret == 0x0 || ret == 0x10 || ret == 0x11) {
+                ab8500->revision = ret;
+                dev_info(ab8500->dev, "detected chip, revision: %#x\n", ret);
+        } else {
+                dev_err(ab8500->dev, "unknown chip, revision: %#x\n", ret);
+                return -EINVAL;
+        }
+
+        if (plat && plat->init)
+                plat->init(ab8500);
+
+        /* Clear and mask all interrupts */
+        for (i = 0; i < 10; i++) {
+                ab8500_read(ab8500, AB8500_IT_LATCH1_REG + i);
+                ab8500_write(ab8500, AB8500_IT_MASK1_REG + i, 0xff);
+        }
+
+        for (i = 18; i < 24; i++) {
+                ab8500_read(ab8500, AB8500_IT_LATCH1_REG + i);
+                ab8500_write(ab8500, AB8500_IT_MASK1_REG + i, 0xff);
+        }
+
+        for (i = 0; i < AB8500_NUM_IRQ_REGS; i++)
+                ab8500->mask[i] = ab8500->oldmask[i] = 0xff;
+
+        if (ab8500->irq_base) {
+                ret = ab8500_irq_init(ab8500);
+                if (ret)
+                        return ret;
+
+                ret = request_threaded_irq(ab8500->irq, NULL, ab8500_irq,
+                                           IRQF_ONESHOT, "ab8500", ab8500);
+                if (ret)
+                        goto out_removeirq;
+        }
+
+        ret = mfd_add_devices(ab8500->dev, -1, ab8500_devs,
+                              ARRAY_SIZE(ab8500_devs), NULL,
+                              ab8500->irq_base);
+        if (ret)
+                goto out_freeirq;
+
+        return ret;
+
+out_freeirq:
+        if (ab8500->irq_base) {
+                free_irq(ab8500->irq, ab8500);
+out_removeirq:
+                ab8500_irq_remove(ab8500);
+        }
+        return ret;
+}
+
+int __devexit ab8500_exit(struct ab8500 *ab8500)
+{
+        mfd_remove_devices(ab8500->dev);
+        if (ab8500->irq_base) {
+                free_irq(ab8500->irq, ab8500);
+                ab8500_irq_remove(ab8500);
+        }
+
+        return 0;
+}
+
+MODULE_AUTHOR("Srinidhi Kasagar, Rabin Vincent");
+MODULE_DESCRIPTION("AB8500 MFD core");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/mfd/ab8500-spi.c b/drivers/mfd/ab8500-spi.c
new file mode 100644
index 000000000000..b81d4f768ef6
--- /dev/null
+++ b/drivers/mfd/ab8500-spi.c
@@ -0,0 +1,133 @@
+/*
+ * Copyright (C) ST-Ericsson SA 2010
+ *
+ * License Terms: GNU General Public License v2
+ * Author: Srinidhi Kasagar <srinidhi.kasagar@stericsson.com>
+ */
+
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/spi/spi.h>
+#include <linux/mfd/ab8500.h>
+
+/*
+ * This funtion writes to any AB8500 registers using
+ * SPI protocol &  before it writes it packs the data
+ * in the below 24 bit frame format
+ *
+ *       *|------------------------------------|
+ *       *| 23|22...18|17.......10|9|8|7......0|
+ *       *| r/w  bank       adr          data  |
+ *       * ------------------------------------
+ *
+ * This function shouldn't be called from interrupt
+ * context
+ */
+static int ab8500_spi_write(struct ab8500 *ab8500, u16 addr, u8 data)
+{
+        struct spi_device *spi = container_of(ab8500->dev, struct spi_device,
+                                              dev);
+        unsigned long spi_data = addr << 10 | data;
+        struct spi_transfer xfer;
+        struct spi_message msg;
+
+        ab8500->tx_buf[0] = spi_data;
+        ab8500->rx_buf[0] = 0;
+
+        xfer.tx_buf     = ab8500->tx_buf;
+        xfer.rx_buf     = NULL;
+        xfer.len        = sizeof(unsigned long);
+
+        spi_message_init(&msg);
+        spi_message_add_tail(&xfer, &msg);
+
+        return spi_sync(spi, &msg);
+}
+
+static int ab8500_spi_read(struct ab8500 *ab8500, u16 addr)
+{
+        struct spi_device *spi = container_of(ab8500->dev, struct spi_device,
+                                              dev);
+        unsigned long spi_data = 1 << 23 | addr << 10;
+        struct spi_transfer xfer;
+        struct spi_message msg;
+        int ret;
+
+        ab8500->tx_buf[0] = spi_data;
+        ab8500->rx_buf[0] = 0;
+
+        xfer.tx_buf     = ab8500->tx_buf;
+        xfer.rx_buf     = ab8500->rx_buf;
+        xfer.len        = sizeof(unsigned long);
+
+        spi_message_init(&msg);
+        spi_message_add_tail(&xfer, &msg);
+
+        ret = spi_sync(spi, &msg);
+        if (!ret)
+                ret = ab8500->rx_buf[0];
+
+        return ret;
+}
+
+static int __devinit ab8500_spi_probe(struct spi_device *spi)
+{
+        struct ab8500 *ab8500;
+        int ret;
+
+        ab8500 = kzalloc(sizeof *ab8500, GFP_KERNEL);
+        if (!ab8500)
+                return -ENOMEM;
+
+        ab8500->dev = &spi->dev;
+        ab8500->irq = spi->irq;
+
+        ab8500->read = ab8500_spi_read;
+        ab8500->write = ab8500_spi_write;
+
+        spi_set_drvdata(spi, ab8500);
+
+        ret = ab8500_init(ab8500);
+        if (ret)
+                kfree(ab8500);
+
+        return ret;
+}
+
+static int __devexit ab8500_spi_remove(struct spi_device *spi)
+{
+        struct ab8500 *ab8500 = spi_get_drvdata(spi);
+
+        ab8500_exit(ab8500);
+        kfree(ab8500);
+
+        return 0;
+}
+
+static struct spi_driver ab8500_spi_driver = {
+        .driver = {
+                .name = "ab8500",
+                .owner = THIS_MODULE,
+        },
+        .probe  = ab8500_spi_probe,
+        .remove = __devexit_p(ab8500_spi_remove)
+};
+
+static int __init ab8500_spi_init(void)
+{
+        return spi_register_driver(&ab8500_spi_driver);
+}
+subsys_initcall(ab8500_spi_init);
+
+static void __exit ab8500_spi_exit(void)
+{
+        spi_unregister_driver(&ab8500_spi_driver);
+}
+module_exit(ab8500_spi_exit);
+
+MODULE_AUTHOR("Srinidhi KASAGAR <srinidhi.kasagar@stericsson.com");
+MODULE_DESCRIPTION("AB8500 SPI");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/mfd/abx500-core.c b/drivers/mfd/abx500-core.c
new file mode 100644
index 000000000000..3b3b97ec32a7
--- /dev/null
+++ b/drivers/mfd/abx500-core.c
@@ -0,0 +1,157 @@
+/*
+ * Copyright (C) 2007-2010 ST-Ericsson
+ * License terms: GNU General Public License (GPL) version 2
+ * Register access functions for the ABX500 Mixed Signal IC family.
+ * Author: Mattias Wallin <mattias.wallin@stericsson.com>
+ */
+
+#include <linux/list.h>
+#include <linux/slab.h>
+#include <linux/err.h>
+#include <linux/mfd/abx500.h>
+
+static LIST_HEAD(abx500_list);
+
+struct abx500_device_entry {
+        struct list_head list;
+        struct abx500_ops ops;
+        struct device *dev;
+};
+
+static void lookup_ops(struct device *dev, struct abx500_ops **ops)
+{
+        struct abx500_device_entry *dev_entry;
+
+        *ops = NULL;
+        list_for_each_entry(dev_entry, &abx500_list, list) {
+                if (dev_entry->dev == dev) {
+                        *ops = &dev_entry->ops;
+                        return;
+                }
+        }
+}
+
+int abx500_register_ops(struct device *dev, struct abx500_ops *ops)
+{
+        struct abx500_device_entry *dev_entry;
+
+        dev_entry = kzalloc(sizeof(struct abx500_device_entry), GFP_KERNEL);
+        if (IS_ERR(dev_entry)) {
+                dev_err(dev, "register_ops kzalloc failed");
+                return -ENOMEM;
+        }
+        dev_entry->dev = dev;
+        memcpy(&dev_entry->ops, ops, sizeof(struct abx500_ops));
+
+        list_add_tail(&dev_entry->list, &abx500_list);
+        return 0;
+}
+EXPORT_SYMBOL(abx500_register_ops);
+
+void abx500_remove_ops(struct device *dev)
+{
+        struct abx500_device_entry *dev_entry, *tmp;
+
+        list_for_each_entry_safe(dev_entry, tmp, &abx500_list, list)
+        {
+                if (dev_entry->dev == dev) {
+                        list_del(&dev_entry->list);
+                        kfree(dev_entry);
+                }
+        }
+}
+EXPORT_SYMBOL(abx500_remove_ops);
+
+int abx500_set_register_interruptible(struct device *dev, u8 bank, u8 reg,
+        u8 value)
+{
+        struct abx500_ops *ops;
+
+        lookup_ops(dev->parent, &ops);
+        if ((ops != NULL) && (ops->set_register != NULL))
+                return ops->set_register(dev, bank, reg, value);
+        else
+                return -ENOTSUPP;
+}
+EXPORT_SYMBOL(abx500_set_register_interruptible);
+
+int abx500_get_register_interruptible(struct device *dev, u8 bank, u8 reg,
+        u8 *value)
+{
+        struct abx500_ops *ops;
+
+        lookup_ops(dev->parent, &ops);
+        if ((ops != NULL) && (ops->get_register != NULL))
+                return ops->get_register(dev, bank, reg, value);
+        else
+                return -ENOTSUPP;
+}
+EXPORT_SYMBOL(abx500_get_register_interruptible);
+
+int abx500_get_register_page_interruptible(struct device *dev, u8 bank,
+        u8 first_reg, u8 *regvals, u8 numregs)
+{
+        struct abx500_ops *ops;
+
+        lookup_ops(dev->parent, &ops);
+        if ((ops != NULL) && (ops->get_register_page != NULL))
+                return ops->get_register_page(dev, bank,
+                        first_reg, regvals, numregs);
+        else
+                return -ENOTSUPP;
+}
+EXPORT_SYMBOL(abx500_get_register_page_interruptible);
+
+int abx500_mask_and_set_register_interruptible(struct device *dev, u8 bank,
+        u8 reg, u8 bitmask, u8 bitvalues)
+{
+        struct abx500_ops *ops;
+
+        lookup_ops(dev->parent, &ops);
+        if ((ops != NULL) && (ops->mask_and_set_register != NULL))
+                return ops->mask_and_set_register(dev, bank,
+                        reg, bitmask, bitvalues);
+        else
+                return -ENOTSUPP;
+}
+EXPORT_SYMBOL(abx500_mask_and_set_register_interruptible);
+
+int abx500_get_chip_id(struct device *dev)
+{
+        struct abx500_ops *ops;
+
+        lookup_ops(dev->parent, &ops);
+        if ((ops != NULL) && (ops->get_chip_id != NULL))
+                return ops->get_chip_id(dev);
+        else
+                return -ENOTSUPP;
+}
+EXPORT_SYMBOL(abx500_get_chip_id);
+
+int abx500_event_registers_startup_state_get(struct device *dev, u8 *event)
+{
+        struct abx500_ops *ops;
+
+        lookup_ops(dev->parent, &ops);
+        if ((ops != NULL) && (ops->event_registers_startup_state_get != NULL))
+                return ops->event_registers_startup_state_get(dev, event);
+        else
+                return -ENOTSUPP;
+}
+EXPORT_SYMBOL(abx500_event_registers_startup_state_get);
+
+int abx500_startup_irq_enabled(struct device *dev, unsigned int irq)
+{
+        struct abx500_ops *ops;
+
+        lookup_ops(dev->parent, &ops);
+        if ((ops != NULL) && (ops->startup_irq_enabled != NULL))
+                return ops->startup_irq_enabled(dev, irq);
+        else
+                return -ENOTSUPP;
+}
+EXPORT_SYMBOL(abx500_startup_irq_enabled);
+
+MODULE_AUTHOR("Mattias Wallin <mattias.wallin@stericsson.com>");
+MODULE_DESCRIPTION("ABX500 core driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/mfd/da903x.c b/drivers/mfd/da903x.c
index 67181b147ab3..3ad915d0589c 100644
--- a/drivers/mfd/da903x.c
+++ b/drivers/mfd/da903x.c
@@ -544,6 +544,7 @@ static int __devexit da903x_remove(struct i2c_client *client)
         struct da903x_chip *chip = i2c_get_clientdata(client);
 
         da903x_remove_subdevs(chip);
+        i2c_set_clientdata(client, NULL);
         kfree(chip);
         return 0;
 }
diff --git a/drivers/mfd/janz-cmodio.c b/drivers/mfd/janz-cmodio.c
new file mode 100644
index 000000000000..9ed630799acc
--- /dev/null
+++ b/drivers/mfd/janz-cmodio.c
@@ -0,0 +1,304 @@
+/*
+ * Janz CMOD-IO MODULbus Carrier Board PCI Driver
+ *
+ * Copyright (c) 2010 Ira W. Snyder <iws@ovro.caltech.edu>
+ *
+ * Lots of inspiration and code was copied from drivers/mfd/sm501.c
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/pci.h>
+#include <linux/interrupt.h>
+#include <linux/delay.h>
+#include <linux/platform_device.h>
+#include <linux/mfd/core.h>
+
+#include <linux/mfd/janz.h>
+
+#define DRV_NAME "janz-cmodio"
+
+/* Size of each MODULbus module in PCI BAR4 */
+#define CMODIO_MODULBUS_SIZE    0x200
+
+/* Maximum number of MODULbus modules on a CMOD-IO carrier board */
+#define CMODIO_MAX_MODULES      4
+
+/* Module Parameters */
+static unsigned int num_modules = CMODIO_MAX_MODULES;
+static unsigned char *modules[CMODIO_MAX_MODULES] = {
+        "empty", "empty", "empty", "empty",
+};
+
+module_param_array(modules, charp, &num_modules, S_IRUGO);
+MODULE_PARM_DESC(modules, "MODULbus modules attached to the carrier board");
+
+/* Unique Device Id */
+static unsigned int cmodio_id;
+
+struct cmodio_device {
+        /* Parent PCI device */
+        struct pci_dev *pdev;
+
+        /* PLX control registers */
+        struct janz_cmodio_onboard_regs __iomem *ctrl;
+
+        /* hex switch position */
+        u8 hex;
+
+        /* mfd-core API */
+        struct mfd_cell cells[CMODIO_MAX_MODULES];
+        struct resource resources[3 * CMODIO_MAX_MODULES];
+        struct janz_platform_data pdata[CMODIO_MAX_MODULES];
+};
+
+/*
+ * Subdevices using the mfd-core API
+ */
+
+static int __devinit cmodio_setup_subdevice(struct cmodio_device *priv,
+                                            char *name, unsigned int devno,
+                                            unsigned int modno)
+{
+        struct janz_platform_data *pdata;
+        struct mfd_cell *cell;
+        struct resource *res;
+        struct pci_dev *pci;
+
+        pci = priv->pdev;
+        cell = &priv->cells[devno];
+        res = &priv->resources[devno * 3];
+        pdata = &priv->pdata[devno];
+
+        cell->name = name;
+        cell->resources = res;
+        cell->num_resources = 3;
+
+        /* Setup the subdevice ID -- must be unique */
+        cell->id = cmodio_id++;
+
+        /* Add platform data */
+        pdata->modno = modno;
+        cell->platform_data = pdata;
+        cell->data_size = sizeof(*pdata);
+
+        /* MODULbus registers -- PCI BAR3 is big-endian MODULbus access */
+        res->flags = IORESOURCE_MEM;
+        res->parent = &pci->resource[3];
+        res->start = pci->resource[3].start + (CMODIO_MODULBUS_SIZE * modno);
+        res->end = res->start + CMODIO_MODULBUS_SIZE - 1;
+        res++;
+
+        /* PLX Control Registers -- PCI BAR4 is interrupt and other registers */
+        res->flags = IORESOURCE_MEM;
+        res->parent = &pci->resource[4];
+        res->start = pci->resource[4].start;
+        res->end = pci->resource[4].end;
+        res++;
+
+        /*
+         * IRQ
+         *
+         * The start and end fields are used as an offset to the irq_base
+         * parameter passed into the mfd_add_devices() function call. All
+         * devices share the same IRQ.
+         */
+        res->flags = IORESOURCE_IRQ;
+        res->parent = NULL;
+        res->start = 0;
+        res->end = 0;
+        res++;
+
+        return 0;
+}
+
+/* Probe each submodule using kernel parameters */
+static int __devinit cmodio_probe_submodules(struct cmodio_device *priv)
+{
+        struct pci_dev *pdev = priv->pdev;
+        unsigned int num_probed = 0;
+        char *name;
+        int i;
+
+        for (i = 0; i < num_modules; i++) {
+                name = modules[i];
+                if (!strcmp(name, "") || !strcmp(name, "empty"))
+                        continue;
+
+                dev_dbg(&priv->pdev->dev, "MODULbus %d: name %s\n", i, name);
+                cmodio_setup_subdevice(priv, name, num_probed, i);
+                num_probed++;
+        }
+
+        /* print an error message if no modules were probed */
+        if (num_probed == 0) {
+                dev_err(&priv->pdev->dev, "no MODULbus modules specified, "
+                                          "please set the ``modules'' kernel "
+                                          "parameter according to your "
+                                          "hardware configuration\n");
+                return -ENODEV;
+        }
+
+        return mfd_add_devices(&pdev->dev, 0, priv->cells,
+                               num_probed, NULL, pdev->irq);
+}
+
+/*
+ * SYSFS Attributes
+ */
+
+static ssize_t mbus_show(struct device *dev, struct device_attribute *attr,
+                         char *buf)
+{
+        struct cmodio_device *priv = dev_get_drvdata(dev);
+
+        return snprintf(buf, PAGE_SIZE, "%x\n", priv->hex);
+}
+
+static DEVICE_ATTR(modulbus_number, S_IRUGO, mbus_show, NULL);
+
+static struct attribute *cmodio_sysfs_attrs[] = {
+        &dev_attr_modulbus_number.attr,
+        NULL,
+};
+
+static const struct attribute_group cmodio_sysfs_attr_group = {
+        .attrs = cmodio_sysfs_attrs,
+};
+
+/*
+ * PCI Driver
+ */
+
+static int __devinit cmodio_pci_probe(struct pci_dev *dev,
+                                      const struct pci_device_id *id)
+{
+        struct cmodio_device *priv;
+        int ret;
+
+        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+        if (!priv) {
+                dev_err(&dev->dev, "unable to allocate private data\n");
+                ret = -ENOMEM;
+                goto out_return;
+        }
+
+        pci_set_drvdata(dev, priv);
+        priv->pdev = dev;
+
+        /* Hardware Initialization */
+        ret = pci_enable_device(dev);
+        if (ret) {
+                dev_err(&dev->dev, "unable to enable device\n");
+                goto out_free_priv;
+        }
+
+        pci_set_master(dev);
+        ret = pci_request_regions(dev, DRV_NAME);
+        if (ret) {
+                dev_err(&dev->dev, "unable to request regions\n");
+                goto out_pci_disable_device;
+        }
+
+        /* Onboard configuration registers */
+        priv->ctrl = pci_ioremap_bar(dev, 4);
+        if (!priv->ctrl) {
+                dev_err(&dev->dev, "unable to remap onboard regs\n");
+                ret = -ENOMEM;
+                goto out_pci_release_regions;
+        }
+
+        /* Read the hex switch on the carrier board */
+        priv->hex = ioread8(&priv->ctrl->int_enable);
+
+        /* Add the MODULbus number (hex switch value) to the device's sysfs */
+        ret = sysfs_create_group(&dev->dev.kobj, &cmodio_sysfs_attr_group);
+        if (ret) {
+                dev_err(&dev->dev, "unable to create sysfs attributes\n");
+                goto out_unmap_ctrl;
+        }
+
+        /*
+         * Disable all interrupt lines, each submodule will enable its
+         * own interrupt line if needed
+         */
+        iowrite8(0xf, &priv->ctrl->int_disable);
+
+        /* Register drivers for all submodules */
+        ret = cmodio_probe_submodules(priv);
+        if (ret) {
+                dev_err(&dev->dev, "unable to probe submodules\n");
+                goto out_sysfs_remove_group;
+        }
+
+        return 0;
+
+out_sysfs_remove_group:
+        sysfs_remove_group(&dev->dev.kobj, &cmodio_sysfs_attr_group);
+out_unmap_ctrl:
+        iounmap(priv->ctrl);
+out_pci_release_regions:
+        pci_release_regions(dev);
+out_pci_disable_device:
+        pci_disable_device(dev);
+out_free_priv:
+        kfree(priv);
+out_return:
+        return ret;
+}
+
+static void __devexit cmodio_pci_remove(struct pci_dev *dev)
+{
+        struct cmodio_device *priv = pci_get_drvdata(dev);
+
+        mfd_remove_devices(&dev->dev);
+        sysfs_remove_group(&dev->dev.kobj, &cmodio_sysfs_attr_group);
+        iounmap(priv->ctrl);
+        pci_release_regions(dev);
+        pci_disable_device(dev);
+        kfree(priv);
+}
+
+#define PCI_VENDOR_ID_JANZ              0x13c3
+
+/* The list of devices that this module will support */
+static DEFINE_PCI_DEVICE_TABLE(cmodio_pci_ids) = {
+        { PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9030, PCI_VENDOR_ID_JANZ, 0x0101 },
+        { PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050, PCI_VENDOR_ID_JANZ, 0x0100 },
+        { 0, }
+};
+MODULE_DEVICE_TABLE(pci, cmodio_pci_ids);
+
+static struct pci_driver cmodio_pci_driver = {
+        .name     = DRV_NAME,
+        .id_table = cmodio_pci_ids,
+        .probe    = cmodio_pci_probe,
+        .remove   = __devexit_p(cmodio_pci_remove),
+};
+
+/*
+ * Module Init / Exit
+ */
+
+static int __init cmodio_init(void)
+{
+        return pci_register_driver(&cmodio_pci_driver);
+}
+
+static void __exit cmodio_exit(void)
+{
+        pci_unregister_driver(&cmodio_pci_driver);
+}
+
+MODULE_AUTHOR("Ira W. Snyder <iws@ovro.caltech.edu>");
+MODULE_DESCRIPTION("Janz CMOD-IO PCI MODULbus Carrier Board Driver");
+MODULE_LICENSE("GPL");
+
+module_init(cmodio_init);
+module_exit(cmodio_exit);
diff --git a/drivers/mfd/max8925-core.c b/drivers/mfd/max8925-core.c
index 85d63c04749b..f621bcea3d02 100644
--- a/drivers/mfd/max8925-core.c
+++ b/drivers/mfd/max8925-core.c
@@ -508,7 +508,7 @@ static int max8925_irq_init(struct max8925_chip *chip, int irq,
         max8925_reg_read(chip->i2c, MAX8925_ON_OFF_IRQ2);
         max8925_reg_read(chip->rtc, MAX8925_RTC_IRQ);
         max8925_reg_read(chip->adc, MAX8925_TSC_IRQ);
-        /* mask all interrupts */
+        /* mask all interrupts except for TSC */
         max8925_reg_write(chip->rtc, MAX8925_ALARM0_CNTL, 0);
         max8925_reg_write(chip->rtc, MAX8925_ALARM1_CNTL, 0);
         max8925_reg_write(chip->i2c, MAX8925_CHG_IRQ1_MASK, 0xff);
@@ -516,7 +516,6 @@ static int max8925_irq_init(struct max8925_chip *chip, int irq,
         max8925_reg_write(chip->i2c, MAX8925_ON_OFF_IRQ1_MASK, 0xff);
         max8925_reg_write(chip->i2c, MAX8925_ON_OFF_IRQ2_MASK, 0xff);
         max8925_reg_write(chip->rtc, MAX8925_RTC_IRQ_MASK, 0xff);
-        max8925_reg_write(chip->adc, MAX8925_TSC_IRQ_MASK, 0xff);
 
         mutex_init(&chip->irq_lock);
         chip->core_irq = irq;
@@ -547,7 +546,11 @@ static int max8925_irq_init(struct max8925_chip *chip, int irq,
                 dev_err(chip->dev, "Failed to request core IRQ: %d\n", ret);
                 chip->core_irq = 0;
         }
+
 tsc_irq:
+        /* mask TSC interrupt */
+        max8925_reg_write(chip->adc, MAX8925_TSC_IRQ_MASK, 0x0f);
+
         if (!pdata->tsc_irq) {
                 dev_warn(chip->dev, "No interrupt support on TSC IRQ\n");
                 return 0;
diff --git a/drivers/mfd/max8925-i2c.c b/drivers/mfd/max8925-i2c.c
index d9fd8785da4d..e73f3f5252a8 100644
--- a/drivers/mfd/max8925-i2c.c
+++ b/drivers/mfd/max8925-i2c.c
@@ -173,8 +173,6 @@ static int __devexit max8925_remove(struct i2c_client *client)
         max8925_device_exit(chip);
         i2c_unregister_device(chip->adc);
         i2c_unregister_device(chip->rtc);
-        i2c_set_clientdata(chip->adc, NULL);
-        i2c_set_clientdata(chip->rtc, NULL);
         i2c_set_clientdata(chip->i2c, NULL);
         kfree(chip);
         return 0;
diff --git a/drivers/mfd/mc13783-core.c b/drivers/mfd/mc13783-core.c
index 1f68ecadddc2..fecf38a4f025 100644
--- a/drivers/mfd/mc13783-core.c
+++ b/drivers/mfd/mc13783-core.c
@@ -679,6 +679,10 @@ err_revision:
         if (pdata->flags & MC13783_USE_TOUCHSCREEN)
                 mc13783_add_subdevice(mc13783, "mc13783-ts");
 
+        if (pdata->flags & MC13783_USE_LED)
+                mc13783_add_subdevice_pdata(mc13783, "mc13783-led",
+                                        pdata->leds, sizeof(*pdata->leds));
+
         return 0;
 }
 
diff --git a/drivers/mfd/menelaus.c b/drivers/mfd/menelaus.c
index a94b131a18ef..721948be12c7 100644
--- a/drivers/mfd/menelaus.c
+++ b/drivers/mfd/menelaus.c
@@ -1228,6 +1228,7 @@ fail2:
         free_irq(client->irq, menelaus);
         flush_scheduled_work();
 fail1:
+        i2c_set_clientdata(client, NULL);
         kfree(menelaus);
         return err;
 }
@@ -1237,8 +1238,8 @@ static int __exit menelaus_remove(struct i2c_client *client)
         struct menelaus_chip    *menelaus = i2c_get_clientdata(client);
 
         free_irq(client->irq, menelaus);
-        kfree(menelaus);
         i2c_set_clientdata(client, NULL);
+        kfree(menelaus);
         the_menelaus = NULL;
         return 0;
 }
diff --git a/drivers/mfd/mfd-core.c b/drivers/mfd/mfd-core.c
index 8ffbb7a85a7e..7dd76bceaae8 100644
--- a/drivers/mfd/mfd-core.c
+++ b/drivers/mfd/mfd-core.c
@@ -48,7 +48,7 @@ static int mfd_add_device(struct device *parent, int id,
                 res[r].flags = cell->resources[r].flags;
 
                 /* Find out base to use */
-                if (cell->resources[r].flags & IORESOURCE_MEM) {
+                if ((cell->resources[r].flags & IORESOURCE_MEM) && mem_base) {
                         res[r].parent = mem_base;
                         res[r].start = mem_base->start +
                                 cell->resources[r].start;
diff --git a/drivers/mfd/pcf50633-adc.c b/drivers/mfd/pcf50633-adc.c
index fe8f922f6654..aed0d2a9b032 100644
--- a/drivers/mfd/pcf50633-adc.c
+++ b/drivers/mfd/pcf50633-adc.c
@@ -30,13 +30,13 @@
 struct pcf50633_adc_request {
         int mux;
         int avg;
-        int result;
         void (*callback)(struct pcf50633 *, void *, int);
         void *callback_param;
+};
 
-        /* Used in case of sync requests */
+struct pcf50633_adc_sync_request {
+        int result;
         struct completion completion;
-
 };
 
 #define PCF50633_MAX_ADC_FIFO_DEPTH 8
@@ -109,10 +109,10 @@ adc_enqueue_request(struct pcf50633 *pcf, struct pcf50633_adc_request *req)
         return 0;
 }
 
-static void
-pcf50633_adc_sync_read_callback(struct pcf50633 *pcf, void *param, int result)
+static void pcf50633_adc_sync_read_callback(struct pcf50633 *pcf, void *param,
+        int result)
 {
-        struct pcf50633_adc_request *req = param;
+        struct pcf50633_adc_sync_request *req = param;
 
         req->result = result;
         complete(&req->completion);
@@ -120,28 +120,19 @@ pcf50633_adc_sync_read_callback(struct pcf50633 *pcf, void *param, int result)
 
 int pcf50633_adc_sync_read(struct pcf50633 *pcf, int mux, int avg)
 {
-        struct pcf50633_adc_request *req;
-        int err;
+        struct pcf50633_adc_sync_request req;
+        int ret;
 
-        /* req is freed when the result is ready, in interrupt handler */
-        req = kzalloc(sizeof(*req), GFP_KERNEL);
-        if (!req)
-                return -ENOMEM;
-
-        req->mux = mux;
-        req->avg = avg;
-        req->callback =  pcf50633_adc_sync_read_callback;
-        req->callback_param = req;
+        init_completion(&req.completion);
 
-        init_completion(&req->completion);
-        err = adc_enqueue_request(pcf, req);
-        if (err)
-                return err;
+        ret = pcf50633_adc_async_read(pcf, mux, avg,
+                pcf50633_adc_sync_read_callback, &req);
+        if (ret)
+                return ret;
 
-        wait_for_completion(&req->completion);
+        wait_for_completion(&req.completion);
 
-        /* FIXME by this time req might be already freed */
-        return req->result;
+        return req.result;
 }
 EXPORT_SYMBOL_GPL(pcf50633_adc_sync_read);
 
diff --git a/drivers/mfd/pcf50633-core.c b/drivers/mfd/pcf50633-core.c
index 63a614d696c1..704736e6e9b9 100644
--- a/drivers/mfd/pcf50633-core.c
+++ b/drivers/mfd/pcf50633-core.c
@@ -21,16 +21,16 @@
 #include <linux/workqueue.h>
 #include <linux/platform_device.h>
 #include <linux/i2c.h>
-#include <linux/irq.h>
 #include <linux/slab.h>
 
 #include <linux/mfd/pcf50633/core.h>
 
-/* Two MBCS registers used during cold start */
-#define PCF50633_REG_MBCS1              0x4b
-#define PCF50633_REG_MBCS2              0x4c
-#define PCF50633_MBCS1_USBPRES          0x01
-#define PCF50633_MBCS1_ADAPTPRES        0x01
+int pcf50633_irq_init(struct pcf50633 *pcf, int irq);
+void pcf50633_irq_free(struct pcf50633 *pcf);
+#ifdef CONFIG_PM
+int pcf50633_irq_suspend(struct pcf50633 *pcf);
+int pcf50633_irq_resume(struct pcf50633 *pcf);
+#endif
 
 static int __pcf50633_read(struct pcf50633 *pcf, u8 reg, int num, u8 *data)
 {
@@ -215,244 +215,6 @@ static struct attribute_group pcf_attr_group = {
         .attrs  = pcf_sysfs_entries,
 };
 
-int pcf50633_register_irq(struct pcf50633 *pcf, int irq,
-                        void (*handler) (int, void *), void *data)
-{
-        if (irq < 0 || irq > PCF50633_NUM_IRQ || !handler)
-                return -EINVAL;
-
-        if (WARN_ON(pcf->irq_handler[irq].handler))
-                return -EBUSY;
-
-        mutex_lock(&pcf->lock);
-        pcf->irq_handler[irq].handler = handler;
-        pcf->irq_handler[irq].data = data;
-        mutex_unlock(&pcf->lock);
-
-        return 0;
-}
-EXPORT_SYMBOL_GPL(pcf50633_register_irq);
-
-int pcf50633_free_irq(struct pcf50633 *pcf, int irq)
-{
-        if (irq < 0 || irq > PCF50633_NUM_IRQ)
-                return -EINVAL;
-
-        mutex_lock(&pcf->lock);
-        pcf->irq_handler[irq].handler = NULL;
-        mutex_unlock(&pcf->lock);
-
-        return 0;
-}
-EXPORT_SYMBOL_GPL(pcf50633_free_irq);
-
-static int __pcf50633_irq_mask_set(struct pcf50633 *pcf, int irq, u8 mask)
-{
-        u8 reg, bits, tmp;
-        int ret = 0, idx;
-
-        idx = irq >> 3;
-        reg =  PCF50633_REG_INT1M + idx;
-        bits = 1 << (irq & 0x07);
-
-        mutex_lock(&pcf->lock);
-
-        if (mask) {
-                ret = __pcf50633_read(pcf, reg, 1, &tmp);
-                if (ret < 0)
-                        goto out;
-
-                tmp |= bits;
-
-                ret = __pcf50633_write(pcf, reg, 1, &tmp);
-                if (ret < 0)
-                        goto out;
-
-                pcf->mask_regs[idx] &= ~bits;
-                pcf->mask_regs[idx] |= bits;
-        } else {
-                ret = __pcf50633_read(pcf, reg, 1, &tmp);
-                if (ret < 0)
-                        goto out;
-
-                tmp &= ~bits;
-
-                ret = __pcf50633_write(pcf, reg, 1, &tmp);
-                if (ret < 0)
-                        goto out;
-
-                pcf->mask_regs[idx] &= ~bits;
-        }
-out:
-        mutex_unlock(&pcf->lock);
-
-        return ret;
-}
-
-int pcf50633_irq_mask(struct pcf50633 *pcf, int irq)
-{
-        dev_dbg(pcf->dev, "Masking IRQ %d\n", irq);
-
-        return __pcf50633_irq_mask_set(pcf, irq, 1);
-}
-EXPORT_SYMBOL_GPL(pcf50633_irq_mask);
-
-int pcf50633_irq_unmask(struct pcf50633 *pcf, int irq)
-{
-        dev_dbg(pcf->dev, "Unmasking IRQ %d\n", irq);
-
-        return __pcf50633_irq_mask_set(pcf, irq, 0);
-}
-EXPORT_SYMBOL_GPL(pcf50633_irq_unmask);
-
-int pcf50633_irq_mask_get(struct pcf50633 *pcf, int irq)
-{
-        u8 reg, bits;
-
-        reg =  irq >> 3;
-        bits = 1 << (irq & 0x07);
-
-        return pcf->mask_regs[reg] & bits;
-}
-EXPORT_SYMBOL_GPL(pcf50633_irq_mask_get);
-
-static void pcf50633_irq_call_handler(struct pcf50633 *pcf, int irq)
-{
-        if (pcf->irq_handler[irq].handler)
-                pcf->irq_handler[irq].handler(irq, pcf->irq_handler[irq].data);
-}
-
-/* Maximum amount of time ONKEY is held before emergency action is taken */
-#define PCF50633_ONKEY1S_TIMEOUT 8
-
-static void pcf50633_irq_worker(struct work_struct *work)
-{
-        struct pcf50633 *pcf;
-        int ret, i, j;
-        u8 pcf_int[5], chgstat;
-
-        pcf = container_of(work, struct pcf50633, irq_work);
-
-        /* Read the 5 INT regs in one transaction */
-        ret = pcf50633_read_block(pcf, PCF50633_REG_INT1,
-                                                ARRAY_SIZE(pcf_int), pcf_int);
-        if (ret != ARRAY_SIZE(pcf_int)) {
-                dev_err(pcf->dev, "Error reading INT registers\n");
-
-                /*
-                 * If this doesn't ACK the interrupt to the chip, we'll be
-                 * called once again as we're level triggered.
-                 */
-                goto out;
-        }
-
-        /* defeat 8s death from lowsys on A5 */
-        pcf50633_reg_write(pcf, PCF50633_REG_OOCSHDWN,  0x04);
-
-        /* We immediately read the usb and adapter status. We thus make sure
-         * only of USBINS/USBREM IRQ handlers are called */
-        if (pcf_int[0] & (PCF50633_INT1_USBINS | PCF50633_INT1_USBREM)) {
-                chgstat = pcf50633_reg_read(pcf, PCF50633_REG_MBCS2);
-                if (chgstat & (0x3 << 4))
-                        pcf_int[0] &= ~(1 << PCF50633_INT1_USBREM);
-                else
-                        pcf_int[0] &= ~(1 << PCF50633_INT1_USBINS);
-        }
-
-        /* Make sure only one of ADPINS or ADPREM is set */
-        if (pcf_int[0] & (PCF50633_INT1_ADPINS | PCF50633_INT1_ADPREM)) {
-                chgstat = pcf50633_reg_read(pcf, PCF50633_REG_MBCS2);
-                if (chgstat & (0x3 << 4))
-                        pcf_int[0] &= ~(1 << PCF50633_INT1_ADPREM);
-                else
-                        pcf_int[0] &= ~(1 << PCF50633_INT1_ADPINS);
-        }
-
-        dev_dbg(pcf->dev, "INT1=0x%02x INT2=0x%02x INT3=0x%02x "
-                        "INT4=0x%02x INT5=0x%02x\n", pcf_int[0],
-                        pcf_int[1], pcf_int[2], pcf_int[3], pcf_int[4]);
-
-        /* Some revisions of the chip don't have a 8s standby mode on
-         * ONKEY1S press. We try to manually do it in such cases. */
-        if ((pcf_int[0] & PCF50633_INT1_SECOND) && pcf->onkey1s_held) {
-                dev_info(pcf->dev, "ONKEY1S held for %d secs\n",
-                                                        pcf->onkey1s_held);
-                if (pcf->onkey1s_held++ == PCF50633_ONKEY1S_TIMEOUT)
-                        if (pcf->pdata->force_shutdown)
-                                pcf->pdata->force_shutdown(pcf);
-        }
-
-        if (pcf_int[2] & PCF50633_INT3_ONKEY1S) {
-                dev_info(pcf->dev, "ONKEY1S held\n");
-                pcf->onkey1s_held = 1 ;
-
-                /* Unmask IRQ_SECOND */
-                pcf50633_reg_clear_bits(pcf, PCF50633_REG_INT1M,
-                                                PCF50633_INT1_SECOND);
-
-                /* Unmask IRQ_ONKEYR */
-                pcf50633_reg_clear_bits(pcf, PCF50633_REG_INT2M,
-                                                PCF50633_INT2_ONKEYR);
-        }
-
-        if ((pcf_int[1] & PCF50633_INT2_ONKEYR) && pcf->onkey1s_held) {
-                pcf->onkey1s_held = 0;
-
-                /* Mask SECOND and ONKEYR interrupts */
-                if (pcf->mask_regs[0] & PCF50633_INT1_SECOND)
-                        pcf50633_reg_set_bit_mask(pcf,
-                                        PCF50633_REG_INT1M,
-                                        PCF50633_INT1_SECOND,
-                                        PCF50633_INT1_SECOND);
-
-                if (pcf->mask_regs[1] & PCF50633_INT2_ONKEYR)
-                        pcf50633_reg_set_bit_mask(pcf,
-                                        PCF50633_REG_INT2M,
-                                        PCF50633_INT2_ONKEYR,
-                                        PCF50633_INT2_ONKEYR);
-        }
-
-        /* Have we just resumed ? */
-        if (pcf->is_suspended) {
-                pcf->is_suspended = 0;
-
-                /* Set the resume reason filtering out non resumers */
-                for (i = 0; i < ARRAY_SIZE(pcf_int); i++)
-                        pcf->resume_reason[i] = pcf_int[i] &
-                                                pcf->pdata->resumers[i];
-
-                /* Make sure we don't pass on any ONKEY events to
-                 * userspace now */
-                pcf_int[1] &= ~(PCF50633_INT2_ONKEYR | PCF50633_INT2_ONKEYF);
-        }
-
-        for (i = 0; i < ARRAY_SIZE(pcf_int); i++) {
-                /* Unset masked interrupts */
-                pcf_int[i] &= ~pcf->mask_regs[i];
-
-                for (j = 0; j < 8 ; j++)
-                        if (pcf_int[i] & (1 << j))
-                                pcf50633_irq_call_handler(pcf, (i * 8) + j);
-        }
-
-out:
-        put_device(pcf->dev);
-        enable_irq(pcf->irq);
-}
-
-static irqreturn_t pcf50633_irq(int irq, void *data)
-{
-        struct pcf50633 *pcf = data;
-
-        dev_dbg(pcf->dev, "pcf50633_irq\n");
-
-        get_device(pcf->dev);
-        disable_irq_nosync(pcf->irq);
-        queue_work(pcf->work_queue, &pcf->irq_work);
-
-        return IRQ_HANDLED;
-}
-
 static void
 pcf50633_client_dev_register(struct pcf50633 *pcf, const char *name,
                                                 struct platform_device **pdev)
@@ -479,70 +241,17 @@ pcf50633_client_dev_register(struct pcf50633 *pcf, const char *name,
 static int pcf50633_suspend(struct i2c_client *client, pm_message_t state)
 {
         struct pcf50633 *pcf;
-        int ret = 0, i;
-        u8 res[5];
-
         pcf = i2c_get_clientdata(client);
 
-        /* Make sure our interrupt handlers are not called
-         * henceforth */
-        disable_irq(pcf->irq);
-
-        /* Make sure that any running IRQ worker has quit */
-        cancel_work_sync(&pcf->irq_work);
-
-        /* Save the masks */
-        ret = pcf50633_read_block(pcf, PCF50633_REG_INT1M,
-                                ARRAY_SIZE(pcf->suspend_irq_masks),
-                                        pcf->suspend_irq_masks);
-        if (ret < 0) {
-                dev_err(pcf->dev, "error saving irq masks\n");
-                goto out;
-        }
-
-        /* Write wakeup irq masks */
-        for (i = 0; i < ARRAY_SIZE(res); i++)
-                res[i] = ~pcf->pdata->resumers[i];
-
-        ret = pcf50633_write_block(pcf, PCF50633_REG_INT1M,
-                                        ARRAY_SIZE(res), &res[0]);
-        if (ret < 0) {
-                dev_err(pcf->dev, "error writing wakeup irq masks\n");
-                goto out;
-        }
-
-        pcf->is_suspended = 1;
-
-out:
-        return ret;
+        return pcf50633_irq_suspend(pcf);
 }
 
 static int pcf50633_resume(struct i2c_client *client)
 {
         struct pcf50633 *pcf;
-        int ret;
-
         pcf = i2c_get_clientdata(client);
 
-        /* Write the saved mask registers */
-        ret = pcf50633_write_block(pcf, PCF50633_REG_INT1M,
-                                ARRAY_SIZE(pcf->suspend_irq_masks),
-                                        pcf->suspend_irq_masks);
-        if (ret < 0)
-                dev_err(pcf->dev, "Error restoring saved suspend masks\n");
-
-        /* Restore regulators' state */
-
-
-        get_device(pcf->dev);
-
-        /*
-         * Clear any pending interrupts and set resume reason if any.
-         * This will leave with enable_irq()
-         */
-        pcf50633_irq_worker(&pcf->irq_work);
-
-        return 0;
+        return pcf50633_irq_resume(pcf);
 }
 #else
 #define pcf50633_suspend NULL
@@ -573,43 +282,19 @@ static int __devinit pcf50633_probe(struct i2c_client *client,
         i2c_set_clientdata(client, pcf);
         pcf->dev = &client->dev;
         pcf->i2c_client = client;
-        pcf->irq = client->irq;
-        pcf->work_queue = create_singlethread_workqueue("pcf50633");
-
-        if (!pcf->work_queue) {
-                dev_err(&client->dev, "Failed to alloc workqueue\n");
-                ret = -ENOMEM;
-                goto err_free;
-        }
-
-        INIT_WORK(&pcf->irq_work, pcf50633_irq_worker);
 
         version = pcf50633_reg_read(pcf, 0);
         variant = pcf50633_reg_read(pcf, 1);
         if (version < 0 || variant < 0) {
                 dev_err(pcf->dev, "Unable to probe pcf50633\n");
                 ret = -ENODEV;
-                goto err_destroy_workqueue;
+                goto err_free;
         }
 
         dev_info(pcf->dev, "Probed device version %d variant %d\n",
                                                         version, variant);
 
-        /* Enable all interrupts except RTC SECOND */
-        pcf->mask_regs[0] = 0x80;
-        pcf50633_reg_write(pcf, PCF50633_REG_INT1M, pcf->mask_regs[0]);
-        pcf50633_reg_write(pcf, PCF50633_REG_INT2M, 0x00);
-        pcf50633_reg_write(pcf, PCF50633_REG_INT3M, 0x00);
-        pcf50633_reg_write(pcf, PCF50633_REG_INT4M, 0x00);
-        pcf50633_reg_write(pcf, PCF50633_REG_INT5M, 0x00);
-
-        ret = request_irq(client->irq, pcf50633_irq,
-                                        IRQF_TRIGGER_LOW, "pcf50633", pcf);
-
-        if (ret) {
-                dev_err(pcf->dev, "Failed to request IRQ %d\n", ret);
-                goto err_destroy_workqueue;
-        }
+        pcf50633_irq_init(pcf, client->irq);
 
         /* Create sub devices */
         pcf50633_client_dev_register(pcf, "pcf50633-input",
@@ -620,6 +305,9 @@ static int __devinit pcf50633_probe(struct i2c_client *client,
                                                 &pcf->mbc_pdev);
         pcf50633_client_dev_register(pcf, "pcf50633-adc",
                                                 &pcf->adc_pdev);
+        pcf50633_client_dev_register(pcf, "pcf50633-backlight",
+                                                &pcf->bl_pdev);
+
 
         for (i = 0; i < PCF50633_NUM_REGULATORS; i++) {
                 struct platform_device *pdev;
@@ -638,10 +326,6 @@ static int __devinit pcf50633_probe(struct i2c_client *client,
                 platform_device_add(pdev);
         }
 
-        if (enable_irq_wake(client->irq) < 0)
-                dev_err(pcf->dev, "IRQ %u cannot be enabled as wake-up source"
-                        "in this hardware revision", client->irq);
-
         ret = sysfs_create_group(&client->dev.kobj, &pcf_attr_group);
         if (ret)
                 dev_err(pcf->dev, "error creating sysfs entries\n");
@@ -651,8 +335,6 @@ static int __devinit pcf50633_probe(struct i2c_client *client,
 
         return 0;
 
-err_destroy_workqueue:
-        destroy_workqueue(pcf->work_queue);
 err_free:
         i2c_set_clientdata(client, NULL);
         kfree(pcf);
@@ -665,8 +347,7 @@ static int __devexit pcf50633_remove(struct i2c_client *client)
         struct pcf50633 *pcf = i2c_get_clientdata(client);
         int i;
 
-        free_irq(pcf->irq, pcf);
-        destroy_workqueue(pcf->work_queue);
+        pcf50633_irq_free(pcf);
 
         platform_device_unregister(pcf->input_pdev);
         platform_device_unregister(pcf->rtc_pdev);
@@ -676,6 +357,7 @@ static int __devexit pcf50633_remove(struct i2c_client *client)
         for (i = 0; i < PCF50633_NUM_REGULATORS; i++)
                 platform_device_unregister(pcf->regulator_pdev[i]);
 
+        i2c_set_clientdata(client, NULL);
         kfree(pcf);
 
         return 0;
diff --git a/drivers/mfd/pcf50633-irq.c b/drivers/mfd/pcf50633-irq.c
new file mode 100644
index 000000000000..1b0192f1efff
--- /dev/null
+++ b/drivers/mfd/pcf50633-irq.c
@@ -0,0 +1,318 @@
+/* NXP PCF50633 Power Management Unit (PMU) driver
+ *
+ * (C) 2006-2008 by Openmoko, Inc.
+ * Author: Harald Welte <laforge@openmoko.org>
+ *         Balaji Rao <balajirrao@openmoko.org>
+ * All rights reserved.
+ *
+ *  This program is free software; you can redistribute  it and/or modify it
+ *  under  the terms of  the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ *
+ */
+
+#include <linux/interrupt.h>
+#include <linux/kernel.h>
+#include <linux/mutex.h>
+#include <linux/slab.h>
+
+#include <linux/mfd/pcf50633/core.h>
+
+/* Two MBCS registers used during cold start */
+#define PCF50633_REG_MBCS1              0x4b
+#define PCF50633_REG_MBCS2              0x4c
+#define PCF50633_MBCS1_USBPRES          0x01
+#define PCF50633_MBCS1_ADAPTPRES        0x01
+
+int pcf50633_register_irq(struct pcf50633 *pcf, int irq,
+                        void (*handler) (int, void *), void *data)
+{
+        if (irq < 0 || irq >= PCF50633_NUM_IRQ || !handler)
+                return -EINVAL;
+
+        if (WARN_ON(pcf->irq_handler[irq].handler))
+                return -EBUSY;
+
+        mutex_lock(&pcf->lock);
+        pcf->irq_handler[irq].handler = handler;
+        pcf->irq_handler[irq].data = data;
+        mutex_unlock(&pcf->lock);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(pcf50633_register_irq);
+
+int pcf50633_free_irq(struct pcf50633 *pcf, int irq)
+{
+        if (irq < 0 || irq >= PCF50633_NUM_IRQ)
+                return -EINVAL;
+
+        mutex_lock(&pcf->lock);
+        pcf->irq_handler[irq].handler = NULL;
+        mutex_unlock(&pcf->lock);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(pcf50633_free_irq);
+
+static int __pcf50633_irq_mask_set(struct pcf50633 *pcf, int irq, u8 mask)
+{
+        u8 reg, bit;
+        int ret = 0, idx;
+
+        idx = irq >> 3;
+        reg = PCF50633_REG_INT1M + idx;
+        bit = 1 << (irq & 0x07);
+
+        pcf50633_reg_set_bit_mask(pcf, reg, bit, mask ? bit : 0);
+
+        mutex_lock(&pcf->lock);
+
+        if (mask)
+                pcf->mask_regs[idx] |= bit;
+        else
+                pcf->mask_regs[idx] &= ~bit;
+
+        mutex_unlock(&pcf->lock);
+
+        return ret;
+}
+
+int pcf50633_irq_mask(struct pcf50633 *pcf, int irq)
+{
+        dev_dbg(pcf->dev, "Masking IRQ %d\n", irq);
+
+        return __pcf50633_irq_mask_set(pcf, irq, 1);
+}
+EXPORT_SYMBOL_GPL(pcf50633_irq_mask);
+
+int pcf50633_irq_unmask(struct pcf50633 *pcf, int irq)
+{
+        dev_dbg(pcf->dev, "Unmasking IRQ %d\n", irq);
+
+        return __pcf50633_irq_mask_set(pcf, irq, 0);
+}
+EXPORT_SYMBOL_GPL(pcf50633_irq_unmask);
+
+int pcf50633_irq_mask_get(struct pcf50633 *pcf, int irq)
+{
+        u8 reg, bits;
+
+        reg =  irq >> 3;
+        bits = 1 << (irq & 0x07);
+
+        return pcf->mask_regs[reg] & bits;
+}
+EXPORT_SYMBOL_GPL(pcf50633_irq_mask_get);
+
+static void pcf50633_irq_call_handler(struct pcf50633 *pcf, int irq)
+{
+        if (pcf->irq_handler[irq].handler)
+                pcf->irq_handler[irq].handler(irq, pcf->irq_handler[irq].data);
+}
+
+/* Maximum amount of time ONKEY is held before emergency action is taken */
+#define PCF50633_ONKEY1S_TIMEOUT 8
+
+static irqreturn_t pcf50633_irq(int irq, void *data)
+{
+        struct pcf50633 *pcf = data;
+        int ret, i, j;
+        u8 pcf_int[5], chgstat;
+
+        /* Read the 5 INT regs in one transaction */
+        ret = pcf50633_read_block(pcf, PCF50633_REG_INT1,
+                                                ARRAY_SIZE(pcf_int), pcf_int);
+        if (ret != ARRAY_SIZE(pcf_int)) {
+                dev_err(pcf->dev, "Error reading INT registers\n");
+
+                /*
+                 * If this doesn't ACK the interrupt to the chip, we'll be
+                 * called once again as we're level triggered.
+                 */
+                goto out;
+        }
+
+        /* defeat 8s death from lowsys on A5 */
+        pcf50633_reg_write(pcf, PCF50633_REG_OOCSHDWN,  0x04);
+
+        /* We immediately read the usb and adapter status. We thus make sure
+         * only of USBINS/USBREM IRQ handlers are called */
+        if (pcf_int[0] & (PCF50633_INT1_USBINS | PCF50633_INT1_USBREM)) {
+                chgstat = pcf50633_reg_read(pcf, PCF50633_REG_MBCS2);
+                if (chgstat & (0x3 << 4))
+                        pcf_int[0] &= ~PCF50633_INT1_USBREM;
+                else
+                        pcf_int[0] &= ~PCF50633_INT1_USBINS;
+        }
+
+        /* Make sure only one of ADPINS or ADPREM is set */
+        if (pcf_int[0] & (PCF50633_INT1_ADPINS | PCF50633_INT1_ADPREM)) {
+                chgstat = pcf50633_reg_read(pcf, PCF50633_REG_MBCS2);
+                if (chgstat & (0x3 << 4))
+                        pcf_int[0] &= ~PCF50633_INT1_ADPREM;
+                else
+                        pcf_int[0] &= ~PCF50633_INT1_ADPINS;
+        }
+
+        dev_dbg(pcf->dev, "INT1=0x%02x INT2=0x%02x INT3=0x%02x "
+                        "INT4=0x%02x INT5=0x%02x\n", pcf_int[0],
+                        pcf_int[1], pcf_int[2], pcf_int[3], pcf_int[4]);
+
+        /* Some revisions of the chip don't have a 8s standby mode on
+         * ONKEY1S press. We try to manually do it in such cases. */
+        if ((pcf_int[0] & PCF50633_INT1_SECOND) && pcf->onkey1s_held) {
+                dev_info(pcf->dev, "ONKEY1S held for %d secs\n",
+                                                        pcf->onkey1s_held);
+                if (pcf->onkey1s_held++ == PCF50633_ONKEY1S_TIMEOUT)
+                        if (pcf->pdata->force_shutdown)
+                                pcf->pdata->force_shutdown(pcf);
+        }
+
+        if (pcf_int[2] & PCF50633_INT3_ONKEY1S) {
+                dev_info(pcf->dev, "ONKEY1S held\n");
+                pcf->onkey1s_held = 1 ;
+
+                /* Unmask IRQ_SECOND */
+                pcf50633_reg_clear_bits(pcf, PCF50633_REG_INT1M,
+                                                PCF50633_INT1_SECOND);
+
+                /* Unmask IRQ_ONKEYR */
+                pcf50633_reg_clear_bits(pcf, PCF50633_REG_INT2M,
+                                                PCF50633_INT2_ONKEYR);
+        }
+
+        if ((pcf_int[1] & PCF50633_INT2_ONKEYR) && pcf->onkey1s_held) {
+                pcf->onkey1s_held = 0;
+
+                /* Mask SECOND and ONKEYR interrupts */
+                if (pcf->mask_regs[0] & PCF50633_INT1_SECOND)
+                        pcf50633_reg_set_bit_mask(pcf,
+                                        PCF50633_REG_INT1M,
+                                        PCF50633_INT1_SECOND,
+                                        PCF50633_INT1_SECOND);
+
+                if (pcf->mask_regs[1] & PCF50633_INT2_ONKEYR)
+                        pcf50633_reg_set_bit_mask(pcf,
+                                        PCF50633_REG_INT2M,
+                                        PCF50633_INT2_ONKEYR,
+                                        PCF50633_INT2_ONKEYR);
+        }
+
+        /* Have we just resumed ? */
+        if (pcf->is_suspended) {
+                pcf->is_suspended = 0;
+
+                /* Set the resume reason filtering out non resumers */
+                for (i = 0; i < ARRAY_SIZE(pcf_int); i++)
+                        pcf->resume_reason[i] = pcf_int[i] &
+                                                pcf->pdata->resumers[i];
+
+                /* Make sure we don't pass on any ONKEY events to
+                 * userspace now */
+                pcf_int[1] &= ~(PCF50633_INT2_ONKEYR | PCF50633_INT2_ONKEYF);
+        }
+
+        for (i = 0; i < ARRAY_SIZE(pcf_int); i++) {
+                /* Unset masked interrupts */
+                pcf_int[i] &= ~pcf->mask_regs[i];
+
+                for (j = 0; j < 8 ; j++)
+                        if (pcf_int[i] & (1 << j))
+                                pcf50633_irq_call_handler(pcf, (i * 8) + j);
+        }
+
+out:
+        return IRQ_HANDLED;
+}
+
+#ifdef CONFIG_PM
+
+int pcf50633_irq_suspend(struct pcf50633 *pcf)
+{
+        int ret;
+        int i;
+        u8 res[5];
+
+
+        /* Make sure our interrupt handlers are not called
+         * henceforth */
+        disable_irq(pcf->irq);
+
+        /* Save the masks */
+        ret = pcf50633_read_block(pcf, PCF50633_REG_INT1M,
+                                ARRAY_SIZE(pcf->suspend_irq_masks),
+                                        pcf->suspend_irq_masks);
+        if (ret < 0) {
+                dev_err(pcf->dev, "error saving irq masks\n");
+                goto out;
+        }
+
+        /* Write wakeup irq masks */
+        for (i = 0; i < ARRAY_SIZE(res); i++)
+                res[i] = ~pcf->pdata->resumers[i];
+
+        ret = pcf50633_write_block(pcf, PCF50633_REG_INT1M,
+                                        ARRAY_SIZE(res), &res[0]);
+        if (ret < 0) {
+                dev_err(pcf->dev, "error writing wakeup irq masks\n");
+                goto out;
+        }
+
+        pcf->is_suspended = 1;
+
+out:
+        return ret;
+}
+
+int pcf50633_irq_resume(struct pcf50633 *pcf)
+{
+        int ret;
+
+        /* Write the saved mask registers */
+        ret = pcf50633_write_block(pcf, PCF50633_REG_INT1M,
+                                ARRAY_SIZE(pcf->suspend_irq_masks),
+                                        pcf->suspend_irq_masks);
+        if (ret < 0)
+                dev_err(pcf->dev, "Error restoring saved suspend masks\n");
+
+        enable_irq(pcf->irq);
+
+        return ret;
+}
+
+#endif
+
+int pcf50633_irq_init(struct pcf50633 *pcf, int irq)
+{
+        int ret;
+
+        pcf->irq = irq;
+
+        /* Enable all interrupts except RTC SECOND */
+        pcf->mask_regs[0] = 0x80;
+        pcf50633_reg_write(pcf, PCF50633_REG_INT1M, pcf->mask_regs[0]);
+        pcf50633_reg_write(pcf, PCF50633_REG_INT2M, 0x00);
+        pcf50633_reg_write(pcf, PCF50633_REG_INT3M, 0x00);
+        pcf50633_reg_write(pcf, PCF50633_REG_INT4M, 0x00);
+        pcf50633_reg_write(pcf, PCF50633_REG_INT5M, 0x00);
+
+        ret = request_threaded_irq(irq, NULL, pcf50633_irq,
+                                        IRQF_TRIGGER_LOW | IRQF_ONESHOT,
+                                        "pcf50633", pcf);
+
+        if (ret)
+                dev_err(pcf->dev, "Failed to request IRQ %d\n", ret);
+
+        if (enable_irq_wake(irq) < 0)
+                dev_err(pcf->dev, "IRQ %u cannot be enabled as wake-up source"
+                        "in this hardware revision", irq);
+
+        return ret;
+}
+
+void pcf50633_irq_free(struct pcf50633 *pcf)
+{
+        free_irq(pcf->irq, pcf);
+}
diff --git a/drivers/mfd/rdc321x-southbridge.c b/drivers/mfd/rdc321x-southbridge.c
new file mode 100644
index 000000000000..50922975bda3
--- /dev/null
+++ b/drivers/mfd/rdc321x-southbridge.c
@@ -0,0 +1,123 @@
+/*
+ * RDC321x MFD southbrige driver
+ *
+ * Copyright (C) 2007-2010 Florian Fainelli <florian@openwrt.org>
+ * Copyright (C) 2010 Bernhard Loos <bernhardloos@googlemail.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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/platform_device.h>
+#include <linux/pci.h>
+#include <linux/mfd/core.h>
+#include <linux/mfd/rdc321x.h>
+
+static struct rdc321x_wdt_pdata rdc321x_wdt_pdata;
+
+static struct resource rdc321x_wdt_resource[] = {
+        {
+                .name   = "wdt-reg",
+                .start  = RDC321X_WDT_CTRL,
+                .end    = RDC321X_WDT_CTRL + 0x3,
+                .flags  = IORESOURCE_IO,
+        }
+};
+
+static struct rdc321x_gpio_pdata rdc321x_gpio_pdata = {
+        .max_gpios      = RDC321X_MAX_GPIO,
+};
+
+static struct resource rdc321x_gpio_resources[] = {
+        {
+                .name   = "gpio-reg1",
+                .start  = RDC321X_GPIO_CTRL_REG1,
+                .end    = RDC321X_GPIO_CTRL_REG1 + 0x7,
+                .flags  = IORESOURCE_IO,
+        }, {
+                .name   = "gpio-reg2",
+                .start  = RDC321X_GPIO_CTRL_REG2,
+                .end    = RDC321X_GPIO_CTRL_REG2 + 0x7,
+                .flags  = IORESOURCE_IO,
+        }
+};
+
+static struct mfd_cell rdc321x_sb_cells[] = {
+        {
+                .name           = "rdc321x-wdt",
+                .resources      = rdc321x_wdt_resource,
+                .num_resources  = ARRAY_SIZE(rdc321x_wdt_resource),
+                .driver_data    = &rdc321x_wdt_pdata,
+        }, {
+                .name           = "rdc321x-gpio",
+                .resources      = rdc321x_gpio_resources,
+                .num_resources  = ARRAY_SIZE(rdc321x_gpio_resources),
+                .driver_data    = &rdc321x_gpio_pdata,
+        },
+};
+
+static int __devinit rdc321x_sb_probe(struct pci_dev *pdev,
+                                        const struct pci_device_id *ent)
+{
+        int err;
+
+        err = pci_enable_device(pdev);
+        if (err) {
+                dev_err(&pdev->dev, "failed to enable device\n");
+                return err;
+        }
+
+        rdc321x_gpio_pdata.sb_pdev = pdev;
+        rdc321x_wdt_pdata.sb_pdev = pdev;
+
+        return mfd_add_devices(&pdev->dev, -1,
+                rdc321x_sb_cells, ARRAY_SIZE(rdc321x_sb_cells), NULL, 0);
+}
+
+static void __devexit rdc321x_sb_remove(struct pci_dev *pdev)
+{
+        mfd_remove_devices(&pdev->dev);
+}
+
+static DEFINE_PCI_DEVICE_TABLE(rdc321x_sb_table) = {
+        { PCI_DEVICE(PCI_VENDOR_ID_RDC, PCI_DEVICE_ID_RDC_R6030) },
+        {}
+};
+
+static struct pci_driver rdc321x_sb_driver = {
+        .name           = "RDC321x Southbridge",
+        .id_table       = rdc321x_sb_table,
+        .probe          = rdc321x_sb_probe,
+        .remove         = __devexit_p(rdc321x_sb_remove),
+};
+
+static int __init rdc321x_sb_init(void)
+{
+        return pci_register_driver(&rdc321x_sb_driver);
+}
+
+static void __exit rdc321x_sb_exit(void)
+{
+        pci_unregister_driver(&rdc321x_sb_driver);
+}
+
+module_init(rdc321x_sb_init);
+module_exit(rdc321x_sb_exit);
+
+MODULE_AUTHOR("Florian Fainelli <florian@openwrt.org>");
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("RDC R-321x MFD southbridge driver");
diff --git a/drivers/mfd/t7l66xb.c b/drivers/mfd/t7l66xb.c
index da6383a934ac..5041d33adf0b 100644
--- a/drivers/mfd/t7l66xb.c
+++ b/drivers/mfd/t7l66xb.c
@@ -318,6 +318,9 @@ static int t7l66xb_probe(struct platform_device *dev)
         struct resource *iomem, *rscr;
         int ret;
 
+        if (pdata == NULL)
+                return -EINVAL;
+
         iomem = platform_get_resource(dev, IORESOURCE_MEM, 0);
         if (!iomem)
                 return -EINVAL;
diff --git a/drivers/mfd/tc35892.c b/drivers/mfd/tc35892.c
new file mode 100644
index 000000000000..715f095dd7a6
--- /dev/null
+++ b/drivers/mfd/tc35892.c
@@ -0,0 +1,347 @@
+/*
+ * Copyright (C) ST-Ericsson SA 2010
+ *
+ * License Terms: GNU General Public License, version 2
+ * Author: Hanumath Prasad <hanumath.prasad@stericsson.com> for ST-Ericsson
+ * Author: Rabin Vincent <rabin.vincent@stericsson.com> for ST-Ericsson
+ */
+
+#include <linux/module.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/mfd/core.h>
+#include <linux/mfd/tc35892.h>
+
+/**
+ * tc35892_reg_read() - read a single TC35892 register
+ * @tc35892:    Device to read from
+ * @reg:        Register to read
+ */
+int tc35892_reg_read(struct tc35892 *tc35892, u8 reg)
+{
+        int ret;
+
+        ret = i2c_smbus_read_byte_data(tc35892->i2c, reg);
+        if (ret < 0)
+                dev_err(tc35892->dev, "failed to read reg %#x: %d\n",
+                        reg, ret);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(tc35892_reg_read);
+
+/**
+ * tc35892_reg_read() - write a single TC35892 register
+ * @tc35892:    Device to write to
+ * @reg:        Register to read
+ * @data:       Value to write
+ */
+int tc35892_reg_write(struct tc35892 *tc35892, u8 reg, u8 data)
+{
+        int ret;
+
+        ret = i2c_smbus_write_byte_data(tc35892->i2c, reg, data);
+        if (ret < 0)
+                dev_err(tc35892->dev, "failed to write reg %#x: %d\n",
+                        reg, ret);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(tc35892_reg_write);
+
+/**
+ * tc35892_block_read() - read multiple TC35892 registers
+ * @tc35892:    Device to read from
+ * @reg:        First register
+ * @length:     Number of registers
+ * @values:     Buffer to write to
+ */
+int tc35892_block_read(struct tc35892 *tc35892, u8 reg, u8 length, u8 *values)
+{
+        int ret;
+
+        ret = i2c_smbus_read_i2c_block_data(tc35892->i2c, reg, length, values);
+        if (ret < 0)
+                dev_err(tc35892->dev, "failed to read regs %#x: %d\n",
+                        reg, ret);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(tc35892_block_read);
+
+/**
+ * tc35892_block_write() - write multiple TC35892 registers
+ * @tc35892:    Device to write to
+ * @reg:        First register
+ * @length:     Number of registers
+ * @values:     Values to write
+ */
+int tc35892_block_write(struct tc35892 *tc35892, u8 reg, u8 length,
+                        const u8 *values)
+{
+        int ret;
+
+        ret = i2c_smbus_write_i2c_block_data(tc35892->i2c, reg, length,
+                                             values);
+        if (ret < 0)
+                dev_err(tc35892->dev, "failed to write regs %#x: %d\n",
+                        reg, ret);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(tc35892_block_write);
+
+/**
+ * tc35892_set_bits() - set the value of a bitfield in a TC35892 register
+ * @tc35892:    Device to write to
+ * @reg:        Register to write
+ * @mask:       Mask of bits to set
+ * @values:     Value to set
+ */
+int tc35892_set_bits(struct tc35892 *tc35892, u8 reg, u8 mask, u8 val)
+{
+        int ret;
+
+        mutex_lock(&tc35892->lock);
+
+        ret = tc35892_reg_read(tc35892, reg);
+        if (ret < 0)
+                goto out;
+
+        ret &= ~mask;
+        ret |= val;
+
+        ret = tc35892_reg_write(tc35892, reg, ret);
+
+out:
+        mutex_unlock(&tc35892->lock);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(tc35892_set_bits);
+
+static struct resource gpio_resources[] = {
+        {
+                .start  = TC35892_INT_GPIIRQ,
+                .end    = TC35892_INT_GPIIRQ,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct mfd_cell tc35892_devs[] = {
+        {
+                .name           = "tc35892-gpio",
+                .num_resources  = ARRAY_SIZE(gpio_resources),
+                .resources      = &gpio_resources[0],
+        },
+};
+
+static irqreturn_t tc35892_irq(int irq, void *data)
+{
+        struct tc35892 *tc35892 = data;
+        int status;
+
+        status = tc35892_reg_read(tc35892, TC35892_IRQST);
+        if (status < 0)
+                return IRQ_NONE;
+
+        while (status) {
+                int bit = __ffs(status);
+
+                handle_nested_irq(tc35892->irq_base + bit);
+                status &= ~(1 << bit);
+        }
+
+        /*
+         * A dummy read or write (to any register) appears to be necessary to
+         * have the last interrupt clear (for example, GPIO IC write) take
+         * effect.
+         */
+        tc35892_reg_read(tc35892, TC35892_IRQST);
+
+        return IRQ_HANDLED;
+}
+
+static void tc35892_irq_dummy(unsigned int irq)
+{
+        /* No mask/unmask at this level */
+}
+
+static struct irq_chip tc35892_irq_chip = {
+        .name   = "tc35892",
+        .mask   = tc35892_irq_dummy,
+        .unmask = tc35892_irq_dummy,
+};
+
+static int tc35892_irq_init(struct tc35892 *tc35892)
+{
+        int base = tc35892->irq_base;
+        int irq;
+
+        for (irq = base; irq < base + TC35892_NR_INTERNAL_IRQS; irq++) {
+                set_irq_chip_data(irq, tc35892);
+                set_irq_chip_and_handler(irq, &tc35892_irq_chip,
+                                         handle_edge_irq);
+                set_irq_nested_thread(irq, 1);
+#ifdef CONFIG_ARM
+                set_irq_flags(irq, IRQF_VALID);
+#else
+                set_irq_noprobe(irq);
+#endif
+        }
+
+        return 0;
+}
+
+static void tc35892_irq_remove(struct tc35892 *tc35892)
+{
+        int base = tc35892->irq_base;
+        int irq;
+
+        for (irq = base; irq < base + TC35892_NR_INTERNAL_IRQS; irq++) {
+#ifdef CONFIG_ARM
+                set_irq_flags(irq, 0);
+#endif
+                set_irq_chip_and_handler(irq, NULL, NULL);
+                set_irq_chip_data(irq, NULL);
+        }
+}
+
+static int tc35892_chip_init(struct tc35892 *tc35892)
+{
+        int manf, ver, ret;
+
+        manf = tc35892_reg_read(tc35892, TC35892_MANFCODE);
+        if (manf < 0)
+                return manf;
+
+        ver = tc35892_reg_read(tc35892, TC35892_VERSION);
+        if (ver < 0)
+                return ver;
+
+        if (manf != TC35892_MANFCODE_MAGIC) {
+                dev_err(tc35892->dev, "unknown manufacturer: %#x\n", manf);
+                return -EINVAL;
+        }
+
+        dev_info(tc35892->dev, "manufacturer: %#x, version: %#x\n", manf, ver);
+
+        /* Put everything except the IRQ module into reset */
+        ret = tc35892_reg_write(tc35892, TC35892_RSTCTRL,
+                                TC35892_RSTCTRL_TIMRST
+                                | TC35892_RSTCTRL_ROTRST
+                                | TC35892_RSTCTRL_KBDRST
+                                | TC35892_RSTCTRL_GPIRST);
+        if (ret < 0)
+                return ret;
+
+        /* Clear the reset interrupt. */
+        return tc35892_reg_write(tc35892, TC35892_RSTINTCLR, 0x1);
+}
+
+static int __devinit tc35892_probe(struct i2c_client *i2c,
+                                   const struct i2c_device_id *id)
+{
+        struct tc35892_platform_data *pdata = i2c->dev.platform_data;
+        struct tc35892 *tc35892;
+        int ret;
+
+        if (!i2c_check_functionality(i2c->adapter, I2C_FUNC_SMBUS_BYTE_DATA
+                                     | I2C_FUNC_SMBUS_I2C_BLOCK))
+                return -EIO;
+
+        tc35892 = kzalloc(sizeof(struct tc35892), GFP_KERNEL);
+        if (!tc35892)
+                return -ENOMEM;
+
+        mutex_init(&tc35892->lock);
+
+        tc35892->dev = &i2c->dev;
+        tc35892->i2c = i2c;
+        tc35892->pdata = pdata;
+        tc35892->irq_base = pdata->irq_base;
+        tc35892->num_gpio = id->driver_data;
+
+        i2c_set_clientdata(i2c, tc35892);
+
+        ret = tc35892_chip_init(tc35892);
+        if (ret)
+                goto out_free;
+
+        ret = tc35892_irq_init(tc35892);
+        if (ret)
+                goto out_free;
+
+        ret = request_threaded_irq(tc35892->i2c->irq, NULL, tc35892_irq,
+                                   IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
+                                   "tc35892", tc35892);
+        if (ret) {
+                dev_err(tc35892->dev, "failed to request IRQ: %d\n", ret);
+                goto out_removeirq;
+        }
+
+        ret = mfd_add_devices(tc35892->dev, -1, tc35892_devs,
+                              ARRAY_SIZE(tc35892_devs), NULL,
+                              tc35892->irq_base);
+        if (ret) {
+                dev_err(tc35892->dev, "failed to add children\n");
+                goto out_freeirq;
+        }
+
+        return 0;
+
+out_freeirq:
+        free_irq(tc35892->i2c->irq, tc35892);
+out_removeirq:
+        tc35892_irq_remove(tc35892);
+out_free:
+        i2c_set_clientdata(i2c, NULL);
+        kfree(tc35892);
+        return ret;
+}
+
+static int __devexit tc35892_remove(struct i2c_client *client)
+{
+        struct tc35892 *tc35892 = i2c_get_clientdata(client);
+
+        mfd_remove_devices(tc35892->dev);
+
+        free_irq(tc35892->i2c->irq, tc35892);
+        tc35892_irq_remove(tc35892);
+
+        i2c_set_clientdata(client, NULL);
+        kfree(tc35892);
+
+        return 0;
+}
+
+static const struct i2c_device_id tc35892_id[] = {
+        { "tc35892", 24 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, tc35892_id);
+
+static struct i2c_driver tc35892_driver = {
+        .driver.name    = "tc35892",
+        .driver.owner   = THIS_MODULE,
+        .probe          = tc35892_probe,
+        .remove         = __devexit_p(tc35892_remove),
+        .id_table       = tc35892_id,
+};
+
+static int __init tc35892_init(void)
+{
+        return i2c_add_driver(&tc35892_driver);
+}
+subsys_initcall(tc35892_init);
+
+static void __exit tc35892_exit(void)
+{
+        i2c_del_driver(&tc35892_driver);
+}
+module_exit(tc35892_exit);
+
+MODULE_LICENSE("GPL v2");
+MODULE_DESCRIPTION("TC35892 MFD core driver");
+MODULE_AUTHOR("Hanumath Prasad, Rabin Vincent");
diff --git a/drivers/mfd/timberdale.c b/drivers/mfd/timberdale.c
index 7f478ec4184b..ac5995026c88 100644
--- a/drivers/mfd/timberdale.c
+++ b/drivers/mfd/timberdale.c
@@ -31,6 +31,7 @@
 
 #include <linux/i2c.h>
 #include <linux/i2c-ocores.h>
+#include <linux/i2c-xiic.h>
 #include <linux/i2c/tsc2007.h>
 
 #include <linux/spi/spi.h>
@@ -40,6 +41,8 @@
 
 #include <media/timb_radio.h>
 
+#include <linux/timb_dma.h>
+
 #include "timberdale.h"
 
 #define DRIVER_NAME "timberdale"
@@ -69,6 +72,12 @@ static struct i2c_board_info timberdale_i2c_board_info[] = {
         },
 };
 
+static __devinitdata struct xiic_i2c_platform_data
+timberdale_xiic_platform_data = {
+        .devices = timberdale_i2c_board_info,
+        .num_devices = ARRAY_SIZE(timberdale_i2c_board_info)
+};
+
 static __devinitdata struct ocores_i2c_platform_data
 timberdale_ocores_platform_data = {
         .regstep = 4,
@@ -77,7 +86,20 @@ timberdale_ocores_platform_data = {
         .num_devices = ARRAY_SIZE(timberdale_i2c_board_info)
 };
 
-const static __devinitconst struct resource timberdale_ocores_resources[] = {
+static const __devinitconst struct resource timberdale_xiic_resources[] = {
+        {
+                .start  = XIICOFFSET,
+                .end    = XIICEND,
+                .flags  = IORESOURCE_MEM,
+        },
+        {
+                .start  = IRQ_TIMBERDALE_I2C,
+                .end    = IRQ_TIMBERDALE_I2C,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static const __devinitconst struct resource timberdale_ocores_resources[] = {
         {
                 .start  = OCORESOFFSET,
                 .end    = OCORESEND,
@@ -126,7 +148,7 @@ static __devinitdata struct xspi_platform_data timberdale_xspi_platform_data = {
          */
 };
 
-const static __devinitconst struct resource timberdale_spi_resources[] = {
+static const __devinitconst struct resource timberdale_spi_resources[] = {
         {
                 .start  = SPIOFFSET,
                 .end    = SPIEND,
@@ -139,7 +161,7 @@ const static __devinitconst struct resource timberdale_spi_resources[] = {
         },
 };
 
-const static __devinitconst struct resource timberdale_eth_resources[] = {
+static const __devinitconst struct resource timberdale_eth_resources[] = {
         {
                 .start  = ETHOFFSET,
                 .end    = ETHEND,
@@ -159,7 +181,7 @@ static __devinitdata struct timbgpio_platform_data
         .irq_base = 200,
 };
 
-const static __devinitconst struct resource timberdale_gpio_resources[] = {
+static const __devinitconst struct resource timberdale_gpio_resources[] = {
         {
                 .start  = GPIOOFFSET,
                 .end    = GPIOEND,
@@ -172,7 +194,7 @@ const static __devinitconst struct resource timberdale_gpio_resources[] = {
         },
 };
 
-const static __devinitconst struct resource timberdale_mlogicore_resources[] = {
+static const __devinitconst struct resource timberdale_mlogicore_resources[] = {
         {
                 .start  = MLCOREOFFSET,
                 .end    = MLCOREEND,
@@ -190,7 +212,7 @@ const static __devinitconst struct resource timberdale_mlogicore_resources[] = {
         },
 };
 
-const static __devinitconst struct resource timberdale_uart_resources[] = {
+static const __devinitconst struct resource timberdale_uart_resources[] = {
         {
                 .start  = UARTOFFSET,
                 .end    = UARTEND,
@@ -203,7 +225,7 @@ const static __devinitconst struct resource timberdale_uart_resources[] = {
         },
 };
 
-const static __devinitconst struct resource timberdale_uartlite_resources[] = {
+static const __devinitconst struct resource timberdale_uartlite_resources[] = {
         {
                 .start  = UARTLITEOFFSET,
                 .end    = UARTLITEEND,
@@ -216,7 +238,7 @@ const static __devinitconst struct resource timberdale_uartlite_resources[] = {
         },
 };
 
-const static __devinitconst struct resource timberdale_radio_resources[] = {
+static const __devinitconst struct resource timberdale_radio_resources[] = {
         {
                 .start  = RDSOFFSET,
                 .end    = RDSEND,
@@ -250,7 +272,66 @@ static __devinitdata struct timb_radio_platform_data
         }
 };
 
-const static __devinitconst struct resource timberdale_dma_resources[] = {
+static __devinitdata struct timb_dma_platform_data timb_dma_platform_data = {
+        .nr_channels = 10,
+        .channels = {
+                {
+                        /* UART RX */
+                        .rx = true,
+                        .descriptors = 2,
+                        .descriptor_elements = 1
+                },
+                {
+                        /* UART TX */
+                        .rx = false,
+                        .descriptors = 2,
+                        .descriptor_elements = 1
+                },
+                {
+                        /* MLB RX */
+                        .rx = true,
+                        .descriptors = 2,
+                        .descriptor_elements = 1
+                },
+                {
+                        /* MLB TX */
+                        .rx = false,
+                        .descriptors = 2,
+                        .descriptor_elements = 1
+                },
+                {
+                        /* Video RX */
+                        .rx = true,
+                        .bytes_per_line = 1440,
+                        .descriptors = 2,
+                        .descriptor_elements = 16
+                },
+                {
+                        /* Video framedrop */
+                },
+                {
+                        /* SDHCI RX */
+                        .rx = true,
+                },
+                {
+                        /* SDHCI TX */
+                },
+                {
+                        /* ETH RX */
+                        .rx = true,
+                        .descriptors = 2,
+                        .descriptor_elements = 1
+                },
+                {
+                        /* ETH TX */
+                        .rx = false,
+                        .descriptors = 2,
+                        .descriptor_elements = 1
+                },
+        }
+};
+
+static const __devinitconst struct resource timberdale_dma_resources[] = {
         {
                 .start  = DMAOFFSET,
                 .end    = DMAEND,
@@ -265,11 +346,25 @@ const static __devinitconst struct resource timberdale_dma_resources[] = {
 
 static __devinitdata struct mfd_cell timberdale_cells_bar0_cfg0[] = {
         {
+                .name = "timb-dma",
+                .num_resources = ARRAY_SIZE(timberdale_dma_resources),
+                .resources = timberdale_dma_resources,
+                .platform_data = &timb_dma_platform_data,
+                .data_size = sizeof(timb_dma_platform_data),
+        },
+        {
                 .name = "timb-uart",
                 .num_resources = ARRAY_SIZE(timberdale_uart_resources),
                 .resources = timberdale_uart_resources,
         },
         {
+                .name = "xiic-i2c",
+                .num_resources = ARRAY_SIZE(timberdale_xiic_resources),
+                .resources = timberdale_xiic_resources,
+                .platform_data = &timberdale_xiic_platform_data,
+                .data_size = sizeof(timberdale_xiic_platform_data),
+        },
+        {
                 .name = "timb-gpio",
                 .num_resources = ARRAY_SIZE(timberdale_gpio_resources),
                 .resources = timberdale_gpio_resources,
@@ -295,14 +390,16 @@ static __devinitdata struct mfd_cell timberdale_cells_bar0_cfg0[] = {
                 .num_resources = ARRAY_SIZE(timberdale_eth_resources),
                 .resources = timberdale_eth_resources,
         },
+};
+
+static __devinitdata struct mfd_cell timberdale_cells_bar0_cfg1[] = {
         {
                 .name = "timb-dma",
                 .num_resources = ARRAY_SIZE(timberdale_dma_resources),
                 .resources = timberdale_dma_resources,
+                .platform_data = &timb_dma_platform_data,
+                .data_size = sizeof(timb_dma_platform_data),
         },
-};
-
-static __devinitdata struct mfd_cell timberdale_cells_bar0_cfg1[] = {
         {
                 .name = "timb-uart",
                 .num_resources = ARRAY_SIZE(timberdale_uart_resources),
@@ -314,6 +411,13 @@ static __devinitdata struct mfd_cell timberdale_cells_bar0_cfg1[] = {
                 .resources = timberdale_uartlite_resources,
         },
         {
+                .name = "xiic-i2c",
+                .num_resources = ARRAY_SIZE(timberdale_xiic_resources),
+                .resources = timberdale_xiic_resources,
+                .platform_data = &timberdale_xiic_platform_data,
+                .data_size = sizeof(timberdale_xiic_platform_data),
+        },
+        {
                 .name = "timb-gpio",
                 .num_resources = ARRAY_SIZE(timberdale_gpio_resources),
                 .resources = timberdale_gpio_resources,
@@ -344,20 +448,29 @@ static __devinitdata struct mfd_cell timberdale_cells_bar0_cfg1[] = {
                 .num_resources = ARRAY_SIZE(timberdale_eth_resources),
                 .resources = timberdale_eth_resources,
         },
+};
+
+static __devinitdata struct mfd_cell timberdale_cells_bar0_cfg2[] = {
         {
                 .name = "timb-dma",
                 .num_resources = ARRAY_SIZE(timberdale_dma_resources),
                 .resources = timberdale_dma_resources,
+                .platform_data = &timb_dma_platform_data,
+                .data_size = sizeof(timb_dma_platform_data),
         },
-};
-
-static __devinitdata struct mfd_cell timberdale_cells_bar0_cfg2[] = {
         {
                 .name = "timb-uart",
                 .num_resources = ARRAY_SIZE(timberdale_uart_resources),
                 .resources = timberdale_uart_resources,
         },
         {
+                .name = "xiic-i2c",
+                .num_resources = ARRAY_SIZE(timberdale_xiic_resources),
+                .resources = timberdale_xiic_resources,
+                .platform_data = &timberdale_xiic_platform_data,
+                .data_size = sizeof(timberdale_xiic_platform_data),
+        },
+        {
                 .name = "timb-gpio",
                 .num_resources = ARRAY_SIZE(timberdale_gpio_resources),
                 .resources = timberdale_gpio_resources,
@@ -378,14 +491,16 @@ static __devinitdata struct mfd_cell timberdale_cells_bar0_cfg2[] = {
                 .platform_data = &timberdale_xspi_platform_data,
                 .data_size = sizeof(timberdale_xspi_platform_data),
         },
+};
+
+static __devinitdata struct mfd_cell timberdale_cells_bar0_cfg3[] = {
         {
                 .name = "timb-dma",
                 .num_resources = ARRAY_SIZE(timberdale_dma_resources),
                 .resources = timberdale_dma_resources,
+                .platform_data = &timb_dma_platform_data,
+                .data_size = sizeof(timb_dma_platform_data),
         },
-};
-
-static __devinitdata struct mfd_cell timberdale_cells_bar0_cfg3[] = {
         {
                 .name = "timb-uart",
                 .num_resources = ARRAY_SIZE(timberdale_uart_resources),
@@ -424,11 +539,6 @@ static __devinitdata struct mfd_cell timberdale_cells_bar0_cfg3[] = {
                 .num_resources = ARRAY_SIZE(timberdale_eth_resources),
                 .resources = timberdale_eth_resources,
         },
-        {
-                .name = "timb-dma",
-                .num_resources = ARRAY_SIZE(timberdale_dma_resources),
-                .resources = timberdale_dma_resources,
-        },
 };
 
 static const __devinitconst struct resource timberdale_sdhc_resources[] = {
diff --git a/drivers/mfd/timberdale.h b/drivers/mfd/timberdale.h
index 8d27ffabc25d..c11bf6ebfe00 100644
--- a/drivers/mfd/timberdale.h
+++ b/drivers/mfd/timberdale.h
@@ -23,7 +23,7 @@
 #ifndef MFD_TIMBERDALE_H
 #define MFD_TIMBERDALE_H
 
-#define DRV_VERSION             "0.1"
+#define DRV_VERSION             "0.2"
 
 /* This driver only support versions >= 3.8 and < 4.0  */
 #define TIMB_SUPPORTED_MAJOR    3
@@ -66,7 +66,7 @@
 
 #define CHIPCTLOFFSET   0x800
 #define CHIPCTLEND      0x8ff
-#define CHIPCTLSIZE     (CHIPCTLEND - CHIPCTLOFFSET)
+#define CHIPCTLSIZE     (CHIPCTLEND - CHIPCTLOFFSET + 1)
 
 #define INTCOFFSET      0xc00
 #define INTCEND         0xfff
@@ -127,4 +127,16 @@
 #define GPIO_PIN_BT_RST         15
 #define GPIO_NR_PINS            16
 
+/* DMA Channels */
+#define DMA_UART_RX         0
+#define DMA_UART_TX         1
+#define DMA_MLB_RX          2
+#define DMA_MLB_TX          3
+#define DMA_VIDEO_RX        4
+#define DMA_VIDEO_DROP      5
+#define DMA_SDHCI_RX        6
+#define DMA_SDHCI_TX        7
+#define DMA_ETH_RX          8
+#define DMA_ETH_TX          9
+
 #endif
diff --git a/drivers/mfd/tps65010.c b/drivers/mfd/tps65010.c
index e5955306c2fa..9b22a77f70f5 100644
--- a/drivers/mfd/tps65010.c
+++ b/drivers/mfd/tps65010.c
@@ -530,8 +530,8 @@ static int __exit tps65010_remove(struct i2c_client *client)
         cancel_delayed_work(&tps->work);
         flush_scheduled_work();
         debugfs_remove(tps->file);
-        kfree(tps);
         i2c_set_clientdata(client, NULL);
+        kfree(tps);
         the_tps = NULL;
         return 0;
 }
diff --git a/drivers/mfd/tps6507x.c b/drivers/mfd/tps6507x.c
new file mode 100644
index 000000000000..d859dffed39f
--- /dev/null
+++ b/drivers/mfd/tps6507x.c
@@ -0,0 +1,159 @@
+/*
+ * tps6507x.c  --  TPS6507x chip family multi-function driver
+ *
+ *  Copyright (c) 2010 RidgeRun (todd.fischer@ridgerun.com)
+ *
+ * Author: Todd Fischer
+ *         todd.fischer@ridgerun.com
+ *
+ * Credits:
+ *
+ *    Using code from wm831x-*.c, wm8400-core, Wolfson Microelectronics PLC.
+ *
+ * For licencing details see kernel-base/COPYING
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/mfd/core.h>
+#include <linux/mfd/tps6507x.h>
+
+static struct mfd_cell tps6507x_devs[] = {
+        {
+                .name = "tps6507x-pmic",
+        },
+        {
+                .name = "tps6507x-ts",
+        },
+};
+
+
+static int tps6507x_i2c_read_device(struct tps6507x_dev *tps6507x, char reg,
+                                  int bytes, void *dest)
+{
+        struct i2c_client *i2c = tps6507x->i2c_client;
+        struct i2c_msg xfer[2];
+        int ret;
+
+        /* Write register */
+        xfer[0].addr = i2c->addr;
+        xfer[0].flags = 0;
+        xfer[0].len = 1;
+        xfer[0].buf = &reg;
+
+        /* Read data */
+        xfer[1].addr = i2c->addr;
+        xfer[1].flags = I2C_M_RD;
+        xfer[1].len = bytes;
+        xfer[1].buf = dest;
+
+        ret = i2c_transfer(i2c->adapter, xfer, 2);
+        if (ret == 2)
+                ret = 0;
+        else if (ret >= 0)
+                ret = -EIO;
+
+        return ret;
+}
+
+static int tps6507x_i2c_write_device(struct tps6507x_dev *tps6507x, char reg,
+                                   int bytes, void *src)
+{
+        struct i2c_client *i2c = tps6507x->i2c_client;
+        /* we add 1 byte for device register */
+        u8 msg[TPS6507X_MAX_REGISTER + 1];
+        int ret;
+
+        if (bytes > (TPS6507X_MAX_REGISTER + 1))
+                return -EINVAL;
+
+        msg[0] = reg;
+        memcpy(&msg[1], src, bytes);
+
+        ret = i2c_master_send(i2c, msg, bytes + 1);
+        if (ret < 0)
+                return ret;
+        if (ret != bytes + 1)
+                return -EIO;
+        return 0;
+}
+
+static int tps6507x_i2c_probe(struct i2c_client *i2c,
+                            const struct i2c_device_id *id)
+{
+        struct tps6507x_dev *tps6507x;
+        int ret = 0;
+
+        tps6507x = kzalloc(sizeof(struct tps6507x_dev), GFP_KERNEL);
+        if (tps6507x == NULL) {
+                kfree(i2c);
+                return -ENOMEM;
+        }
+
+        i2c_set_clientdata(i2c, tps6507x);
+        tps6507x->dev = &i2c->dev;
+        tps6507x->i2c_client = i2c;
+        tps6507x->read_dev = tps6507x_i2c_read_device;
+        tps6507x->write_dev = tps6507x_i2c_write_device;
+
+        ret = mfd_add_devices(tps6507x->dev, -1,
+                              tps6507x_devs, ARRAY_SIZE(tps6507x_devs),
+                              NULL, 0);
+
+        if (ret < 0)
+                goto err;
+
+        return ret;
+
+err:
+        mfd_remove_devices(tps6507x->dev);
+        kfree(tps6507x);
+        return ret;
+}
+
+static int tps6507x_i2c_remove(struct i2c_client *i2c)
+{
+        struct tps6507x_dev *tps6507x = i2c_get_clientdata(i2c);
+
+        mfd_remove_devices(tps6507x->dev);
+        kfree(tps6507x);
+
+        return 0;
+}
+
+static const struct i2c_device_id tps6507x_i2c_id[] = {
+       { "tps6507x", 0 },
+       { }
+};
+MODULE_DEVICE_TABLE(i2c, tps6507x_i2c_id);
+
+
+static struct i2c_driver tps6507x_i2c_driver = {
+        .driver = {
+                   .name = "tps6507x",
+                   .owner = THIS_MODULE,
+        },
+        .probe = tps6507x_i2c_probe,
+        .remove = tps6507x_i2c_remove,
+        .id_table = tps6507x_i2c_id,
+};
+
+static int __init tps6507x_i2c_init(void)
+{
+        return i2c_add_driver(&tps6507x_i2c_driver);
+}
+/* init early so consumer devices can complete system boot */
+subsys_initcall(tps6507x_i2c_init);
+
+static void __exit tps6507x_i2c_exit(void)
+{
+        i2c_del_driver(&tps6507x_i2c_driver);
+}
+module_exit(tps6507x_i2c_exit);
+
+MODULE_DESCRIPTION("TPS6507x chip family multi-function driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/mfd/twl4030-irq.c b/drivers/mfd/twl4030-irq.c
index 202bdd59632d..097f24d8bceb 100644
--- a/drivers/mfd/twl4030-irq.c
+++ b/drivers/mfd/twl4030-irq.c
@@ -232,10 +232,11 @@ static const struct sih sih_modules_twl5031[8] = {
         },
         [6] = {
                 /*
-                 * ACI doesn't use the same SIH organization.
-                 * For example, it supports only one interrupt line
+                 * ECI/DBI doesn't use the same SIH organization.
+                 * For example, it supports only one interrupt output line.
+                 * That is, the interrupts are seen on both INT1 and INT2 lines.
                  */
-                .name           = "aci",
+                .name           = "eci_dbi",
                 .module         = TWL5031_MODULE_ACCESSORY,
                 .bits           = 9,
                 .bytes_ixr      = 2,
@@ -247,8 +248,8 @@ static const struct sih sih_modules_twl5031[8] = {
 
         },
         [7] = {
-                /* Accessory */
-                .name           = "acc",
+                /* Audio accessory */
+                .name           = "audio",
                 .module         = TWL5031_MODULE_ACCESSORY,
                 .control_offset = TWL5031_ACCSIHCTRL,
                 .bits           = 2,
diff --git a/drivers/mfd/wm831x-core.c b/drivers/mfd/wm831x-core.c
index f2ab025ad97a..1a968f34d679 100644
--- a/drivers/mfd/wm831x-core.c
+++ b/drivers/mfd/wm831x-core.c
@@ -322,7 +322,11 @@ EXPORT_SYMBOL_GPL(wm831x_set_bits);
  */
 int wm831x_auxadc_read(struct wm831x *wm831x, enum wm831x_auxadc input)
 {
-        int ret, src;
+        int ret, src, irq_masked, timeout;
+
+        /* Are we using the interrupt? */
+        irq_masked = wm831x_reg_read(wm831x, WM831X_INTERRUPT_STATUS_1_MASK);
+        irq_masked &= WM831X_AUXADC_DATA_EINT;
 
         mutex_lock(&wm831x->auxadc_lock);
 
@@ -342,6 +346,9 @@ int wm831x_auxadc_read(struct wm831x *wm831x, enum wm831x_auxadc input)
                 goto out;
         }
 
+        /* Clear any notification from a very late arriving interrupt */
+        try_wait_for_completion(&wm831x->auxadc_done);
+
         ret = wm831x_set_bits(wm831x, WM831X_AUXADC_CONTROL,
                               WM831X_AUX_CVT_ENA, WM831X_AUX_CVT_ENA);
         if (ret < 0) {
@@ -349,22 +356,46 @@ int wm831x_auxadc_read(struct wm831x *wm831x, enum wm831x_auxadc input)
                 goto disable;
         }
 
-        /* If an interrupt arrived late clean up after it */
-        try_wait_for_completion(&wm831x->auxadc_done);
-
-        /* Ignore the result to allow us to soldier on without IRQ hookup */
-        wait_for_completion_timeout(&wm831x->auxadc_done, msecs_to_jiffies(5));
-
-        ret = wm831x_reg_read(wm831x, WM831X_AUXADC_CONTROL);
-        if (ret < 0) {
-                dev_err(wm831x->dev, "AUXADC status read failed: %d\n", ret);
-                goto disable;
-        }
-
-        if (ret & WM831X_AUX_CVT_ENA) {
-                dev_err(wm831x->dev, "Timed out reading AUXADC\n");
-                ret = -EBUSY;
-                goto disable;
+        if (irq_masked) {
+                /* If we're not using interrupts then poll the
+                 * interrupt status register */
+                timeout = 5;
+                while (timeout) {
+                        msleep(1);
+
+                        ret = wm831x_reg_read(wm831x,
+                                              WM831X_INTERRUPT_STATUS_1);
+                        if (ret < 0) {
+                                dev_err(wm831x->dev,
+                                        "ISR 1 read failed: %d\n", ret);
+                                goto disable;
+                        }
+
+                        /* Did it complete? */
+                        if (ret & WM831X_AUXADC_DATA_EINT) {
+                                wm831x_reg_write(wm831x,
+                                                 WM831X_INTERRUPT_STATUS_1,
+                                                 WM831X_AUXADC_DATA_EINT);
+                                break;
+                        } else {
+                                dev_err(wm831x->dev,
+                                        "AUXADC conversion timeout\n");
+                                ret = -EBUSY;
+                                goto disable;
+                        }
+                }
+        } else {
+                /* If we are using interrupts then wait for the
+                 * interrupt to complete.  Use an extremely long
+                 * timeout to handle situations with heavy load where
+                 * the notification of the interrupt may be delayed by
+                 * threaded IRQ handling. */
+                if (!wait_for_completion_timeout(&wm831x->auxadc_done,
+                                                 msecs_to_jiffies(500))) {
+                        dev_err(wm831x->dev, "Timed out waiting for AUXADC\n");
+                        ret = -EBUSY;
+                        goto disable;
+                }
         }
 
         ret = wm831x_reg_read(wm831x, WM831X_AUXADC_DATA);
@@ -1463,6 +1494,7 @@ static int wm831x_device_init(struct wm831x *wm831x, unsigned long id, int irq)
         case WM8310:
                 parent = WM8310;
                 wm831x->num_gpio = 16;
+                wm831x->charger_irq_wake = 1;
                 if (rev > 0) {
                         wm831x->has_gpio_ena = 1;
                         wm831x->has_cs_sts = 1;
@@ -1474,6 +1506,7 @@ static int wm831x_device_init(struct wm831x *wm831x, unsigned long id, int irq)
         case WM8311:
                 parent = WM8311;
                 wm831x->num_gpio = 16;
+                wm831x->charger_irq_wake = 1;
                 if (rev > 0) {
                         wm831x->has_gpio_ena = 1;
                         wm831x->has_cs_sts = 1;
@@ -1485,6 +1518,7 @@ static int wm831x_device_init(struct wm831x *wm831x, unsigned long id, int irq)
         case WM8312:
                 parent = WM8312;
                 wm831x->num_gpio = 16;
+                wm831x->charger_irq_wake = 1;
                 if (rev > 0) {
                         wm831x->has_gpio_ena = 1;
                         wm831x->has_cs_sts = 1;
@@ -1623,6 +1657,42 @@ static void wm831x_device_exit(struct wm831x *wm831x)
         kfree(wm831x);
 }
 
+static int wm831x_device_suspend(struct wm831x *wm831x)
+{
+        int reg, mask;
+
+        /* If the charger IRQs are a wake source then make sure we ack
+         * them even if they're not actively being used (eg, no power
+         * driver or no IRQ line wired up) then acknowledge the
+         * interrupts otherwise suspend won't last very long.
+         */
+        if (wm831x->charger_irq_wake) {
+                reg = wm831x_reg_read(wm831x, WM831X_INTERRUPT_STATUS_2_MASK);
+
+                mask = WM831X_CHG_BATT_HOT_EINT |
+                        WM831X_CHG_BATT_COLD_EINT |
+                        WM831X_CHG_BATT_FAIL_EINT |
+                        WM831X_CHG_OV_EINT | WM831X_CHG_END_EINT |
+                        WM831X_CHG_TO_EINT | WM831X_CHG_MODE_EINT |
+                        WM831X_CHG_START_EINT;
+
+                /* If any of the interrupts are masked read the statuses */
+                if (reg & mask)
+                        reg = wm831x_reg_read(wm831x,
+                                              WM831X_INTERRUPT_STATUS_2);
+
+                if (reg & mask) {
+                        dev_info(wm831x->dev,
+                                 "Acknowledging masked charger IRQs: %x\n",
+                                 reg & mask);
+                        wm831x_reg_write(wm831x, WM831X_INTERRUPT_STATUS_2,
+                                         reg & mask);
+                }
+        }
+
+        return 0;
+}
+
 static int wm831x_i2c_read_device(struct wm831x *wm831x, unsigned short reg,
                                   int bytes, void *dest)
 {
@@ -1697,6 +1767,13 @@ static int wm831x_i2c_remove(struct i2c_client *i2c)
         return 0;
 }
 
+static int wm831x_i2c_suspend(struct i2c_client *i2c, pm_message_t mesg)
+{
+        struct wm831x *wm831x = i2c_get_clientdata(i2c);
+
+        return wm831x_device_suspend(wm831x);
+}
+
 static const struct i2c_device_id wm831x_i2c_id[] = {
         { "wm8310", WM8310 },
         { "wm8311", WM8311 },
@@ -1714,6 +1791,7 @@ static struct i2c_driver wm831x_i2c_driver = {
         },
         .probe = wm831x_i2c_probe,
         .remove = wm831x_i2c_remove,
+        .suspend = wm831x_i2c_suspend,
         .id_table = wm831x_i2c_id,
 };
 
diff --git a/drivers/mfd/wm831x-irq.c b/drivers/mfd/wm831x-irq.c
index 4c1122ceb443..7dabe4dbd373 100644
--- a/drivers/mfd/wm831x-irq.c
+++ b/drivers/mfd/wm831x-irq.c
@@ -39,8 +39,6 @@ struct wm831x_irq_data {
         int primary;
         int reg;
         int mask;
-        irq_handler_t handler;
-        void *handler_data;
 };
 
 static struct wm831x_irq_data wm831x_irqs[] = {
@@ -492,6 +490,14 @@ int wm831x_irq_init(struct wm831x *wm831x, int irq)
 
         mutex_init(&wm831x->irq_lock);
 
+        /* Mask the individual interrupt sources */
+        for (i = 0; i < ARRAY_SIZE(wm831x->irq_masks_cur); i++) {
+                wm831x->irq_masks_cur[i] = 0xffff;
+                wm831x->irq_masks_cache[i] = 0xffff;
+                wm831x_reg_write(wm831x, WM831X_INTERRUPT_STATUS_1_MASK + i,
+                                 0xffff);
+        }
+
         if (!irq) {
                 dev_warn(wm831x->dev,
                          "No interrupt specified - functionality limited\n");
@@ -507,14 +513,6 @@ int wm831x_irq_init(struct wm831x *wm831x, int irq)
         wm831x->irq = irq;
         wm831x->irq_base = pdata->irq_base;
 
-        /* Mask the individual interrupt sources */
-        for (i = 0; i < ARRAY_SIZE(wm831x->irq_masks_cur); i++) {
-                wm831x->irq_masks_cur[i] = 0xffff;
-                wm831x->irq_masks_cache[i] = 0xffff;
-                wm831x_reg_write(wm831x, WM831X_INTERRUPT_STATUS_1_MASK + i,
-                                 0xffff);
-        }
-
         /* Register them with genirq */
         for (cur_irq = wm831x->irq_base;
              cur_irq < ARRAY_SIZE(wm831x_irqs) + wm831x->irq_base;
diff --git a/drivers/mfd/wm8350-i2c.c b/drivers/mfd/wm8350-i2c.c
index 65830f57c093..7795af4b1fe1 100644
--- a/drivers/mfd/wm8350-i2c.c
+++ b/drivers/mfd/wm8350-i2c.c
@@ -64,10 +64,8 @@ static int wm8350_i2c_probe(struct i2c_client *i2c,
         int ret = 0;
 
         wm8350 = kzalloc(sizeof(struct wm8350), GFP_KERNEL);
-        if (wm8350 == NULL) {
-                kfree(i2c);
+        if (wm8350 == NULL)
                 return -ENOMEM;
-        }
 
         i2c_set_clientdata(i2c, wm8350);
         wm8350->dev = &i2c->dev;
@@ -82,6 +80,7 @@ static int wm8350_i2c_probe(struct i2c_client *i2c,
         return ret;
 
 err:
+        i2c_set_clientdata(i2c, NULL);
         kfree(wm8350);
         return ret;
 }
@@ -91,6 +90,7 @@ static int wm8350_i2c_remove(struct i2c_client *i2c)
         struct wm8350 *wm8350 = i2c_get_clientdata(i2c);
 
         wm8350_device_exit(wm8350);
+        i2c_set_clientdata(i2c, NULL);
         kfree(wm8350);
 
         return 0;
diff --git a/drivers/mfd/wm8400-core.c b/drivers/mfd/wm8400-core.c
index 865ce013a821..e08aafa663dc 100644
--- a/drivers/mfd/wm8400-core.c
+++ b/drivers/mfd/wm8400-core.c
@@ -118,7 +118,7 @@ static int wm8400_read(struct wm8400 *wm8400, u8 reg, int num_regs, u16 *dest)
 {
         int i, ret = 0;
 
-        BUG_ON(reg + num_regs - 1 > ARRAY_SIZE(wm8400->reg_cache));
+        BUG_ON(reg + num_regs > ARRAY_SIZE(wm8400->reg_cache));
 
         /* If there are any volatile reads then read back the entire block */
         for (i = reg; i < reg + num_regs; i++)
@@ -144,7 +144,7 @@ static int wm8400_write(struct wm8400 *wm8400, u8 reg, int num_regs,
 {
         int ret, i;
 
-        BUG_ON(reg + num_regs - 1 > ARRAY_SIZE(wm8400->reg_cache));
+        BUG_ON(reg + num_regs > ARRAY_SIZE(wm8400->reg_cache));
 
         for (i = 0; i < num_regs; i++) {
                 BUG_ON(!reg_data[reg + i].writable);
diff --git a/drivers/misc/lkdtm.c b/drivers/misc/lkdtm.c
index 31a991161f0a..5bfb2a2041b8 100644
--- a/drivers/misc/lkdtm.c
+++ b/drivers/misc/lkdtm.c
@@ -75,6 +75,9 @@ enum ctype {
         UNALIGNED_LOAD_STORE_WRITE,
         OVERWRITE_ALLOCATION,
         WRITE_AFTER_FREE,
+        SOFTLOCKUP,
+        HARDLOCKUP,
+        HUNG_TASK,
 };
 
 static char* cp_name[] = {
@@ -99,6 +102,9 @@ static char* cp_type[] = {
         "UNALIGNED_LOAD_STORE_WRITE",
         "OVERWRITE_ALLOCATION",
         "WRITE_AFTER_FREE",
+        "SOFTLOCKUP",
+        "HARDLOCKUP",
+        "HUNG_TASK",
 };
 
 static struct jprobe lkdtm;
@@ -320,6 +326,20 @@ static void lkdtm_do_action(enum ctype which)
                 memset(data, 0x78, len);
                 break;
         }
+        case SOFTLOCKUP:
+                preempt_disable();
+                for (;;)
+                        cpu_relax();
+                break;
+        case HARDLOCKUP:
+                local_irq_disable();
+                for (;;)
+                        cpu_relax();
+                break;
+        case HUNG_TASK:
+                set_current_state(TASK_UNINTERRUPTIBLE);
+                schedule();
+                break;
         case NONE:
         default:
                 break;
diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
index 3168ebd616b2..569e94da844c 100644
--- a/drivers/mmc/core/core.c
+++ b/drivers/mmc/core/core.c
@@ -1252,9 +1252,8 @@ EXPORT_SYMBOL(mmc_card_can_sleep);
 /**
  *      mmc_suspend_host - suspend a host
  *      @host: mmc host
- *      @state: suspend mode (PM_SUSPEND_xxx)
  */
-int mmc_suspend_host(struct mmc_host *host, pm_message_t state)
+int mmc_suspend_host(struct mmc_host *host)
 {
         int err = 0;
 
diff --git a/drivers/mmc/core/sd_ops.c b/drivers/mmc/core/sd_ops.c
index 0d96080d44b0..63772e7e7608 100644
--- a/drivers/mmc/core/sd_ops.c
+++ b/drivers/mmc/core/sd_ops.c
@@ -79,8 +79,6 @@ int mmc_wait_for_app_cmd(struct mmc_host *host, struct mmc_card *card,
          * we cannot use the retries field in mmc_command.
          */
         for (i = 0;i <= retries;i++) {
-                memset(&mrq, 0, sizeof(struct mmc_request));
-
                 err = mmc_app_cmd(host, card);
                 if (err) {
                         /* no point in retrying; no APP commands allowed */
diff --git a/drivers/mmc/core/sdio_io.c b/drivers/mmc/core/sdio_io.c
index ff27c8c71355..0f687cdeb064 100644
--- a/drivers/mmc/core/sdio_io.c
+++ b/drivers/mmc/core/sdio_io.c
@@ -406,6 +406,36 @@ void sdio_writeb(struct sdio_func *func, u8 b, unsigned int addr, int *err_ret)
 EXPORT_SYMBOL_GPL(sdio_writeb);
 
 /**
+ *      sdio_writeb_readb - write and read a byte from SDIO function
+ *      @func: SDIO function to access
+ *      @write_byte: byte to write
+ *      @addr: address to write to
+ *      @err_ret: optional status value from transfer
+ *
+ *      Performs a RAW (Read after Write) operation as defined by SDIO spec -
+ *      single byte is written to address space of a given SDIO function and
+ *      response is read back from the same address, both using single request.
+ *      If there is a problem with the operation, 0xff is returned and
+ *      @err_ret will contain the error code.
+ */
+u8 sdio_writeb_readb(struct sdio_func *func, u8 write_byte,
+        unsigned int addr, int *err_ret)
+{
+        int ret;
+        u8 val;
+
+        ret = mmc_io_rw_direct(func->card, 1, func->num, addr,
+                        write_byte, &val);
+        if (err_ret)
+                *err_ret = ret;
+        if (ret)
+                val = 0xff;
+
+        return val;
+}
+EXPORT_SYMBOL_GPL(sdio_writeb_readb);
+
+/**
  *      sdio_memcpy_fromio - read a chunk of memory from a SDIO function
  *      @func: SDIO function to access
  *      @dst: buffer to store the data
diff --git a/drivers/mmc/host/Kconfig b/drivers/mmc/host/Kconfig
index 2e13b94769fd..e171e77f6129 100644
--- a/drivers/mmc/host/Kconfig
+++ b/drivers/mmc/host/Kconfig
@@ -136,6 +136,18 @@ config MMC_SDHCI_S3C
 
           If unsure, say N.
 
+config MMC_SDHCI_SPEAR
+        tristate "SDHCI support on ST SPEAr platform"
+        depends on MMC_SDHCI && PLAT_SPEAR
+        help
+          This selects the Secure Digital Host Controller Interface (SDHCI)
+          often referrered to as the HSMMC block in some of the ST SPEAR range
+          of SoC
+
+          If you have a controller with this interface, say Y or M here.
+
+          If unsure, say N.
+
 config MMC_SDHCI_S3C_DMA
         bool "DMA support on S3C SDHCI"
         depends on MMC_SDHCI_S3C && EXPERIMENTAL
@@ -412,3 +424,11 @@ config SDH_BFIN_MISSING_CMD_PULLUP_WORKAROUND
         depends on SDH_BFIN
         help
           If you say yes here SD-Cards may work on the EZkit.
+
+config MMC_SH_MMCIF
+        tristate "SuperH Internal MMCIF support"
+        depends on MMC_BLOCK && (SUPERH || ARCH_SHMOBILE)
+        help
+          This selects the MMC Host Interface controler (MMCIF).
+
+          This driver supports MMCIF in sh7724/sh7757/sh7372.
diff --git a/drivers/mmc/host/Makefile b/drivers/mmc/host/Makefile
index f4803977dfce..e30c2ee48894 100644
--- a/drivers/mmc/host/Makefile
+++ b/drivers/mmc/host/Makefile
@@ -14,6 +14,7 @@ obj-$(CONFIG_MMC_SDHCI)		+= sdhci.o
 obj-$(CONFIG_MMC_SDHCI_PCI)     += sdhci-pci.o
 obj-$(CONFIG_MMC_SDHCI_PLTFM)   += sdhci-pltfm.o
 obj-$(CONFIG_MMC_SDHCI_S3C)     += sdhci-s3c.o
+obj-$(CONFIG_MMC_SDHCI_SPEAR)   += sdhci-spear.o
 obj-$(CONFIG_MMC_WBSD)          += wbsd.o
 obj-$(CONFIG_MMC_AU1X)          += au1xmmc.o
 obj-$(CONFIG_MMC_OMAP)          += omap.o
@@ -34,6 +35,7 @@ obj-$(CONFIG_MMC_TMIO)		+= tmio_mmc.o
 obj-$(CONFIG_MMC_CB710) += cb710-mmc.o
 obj-$(CONFIG_MMC_VIA_SDMMC)     += via-sdmmc.o
 obj-$(CONFIG_SDH_BFIN)          += bfin_sdh.o
+obj-$(CONFIG_MMC_SH_MMCIF)      += sh_mmcif.o
 
 obj-$(CONFIG_MMC_SDHCI_OF)      += sdhci-of.o
 sdhci-of-y                              := sdhci-of-core.o
diff --git a/drivers/mmc/host/at91_mci.c b/drivers/mmc/host/at91_mci.c
index 336d9f553f3e..5f3a599ead07 100644
--- a/drivers/mmc/host/at91_mci.c
+++ b/drivers/mmc/host/at91_mci.c
@@ -1157,7 +1157,7 @@ static int at91_mci_suspend(struct platform_device *pdev, pm_message_t state)
                 enable_irq_wake(host->board->det_pin);
 
         if (mmc)
-                ret = mmc_suspend_host(mmc, state);
+                ret = mmc_suspend_host(mmc);
 
         return ret;
 }
diff --git a/drivers/mmc/host/atmel-mci.c b/drivers/mmc/host/atmel-mci.c
index df0e8a88d85f..95ef864ad8f9 100644
--- a/drivers/mmc/host/atmel-mci.c
+++ b/drivers/mmc/host/atmel-mci.c
@@ -173,6 +173,7 @@ struct atmel_mci {
  * @mmc: The mmc_host representing this slot.
  * @host: The MMC controller this slot is using.
  * @sdc_reg: Value of SDCR to be written before using this slot.
+ * @sdio_irq: SDIO irq mask for this slot.
  * @mrq: mmc_request currently being processed or waiting to be
  *      processed, or NULL when the slot is idle.
  * @queue_node: List node for placing this node in the @queue list of
@@ -191,6 +192,7 @@ struct atmel_mci_slot {
         struct atmel_mci        *host;
 
         u32                     sdc_reg;
+        u32                     sdio_irq;
 
         struct mmc_request      *mrq;
         struct list_head        queue_node;
@@ -792,7 +794,7 @@ static void atmci_start_request(struct atmel_mci *host,
         mci_writel(host, SDCR, slot->sdc_reg);
 
         iflags = mci_readl(host, IMR);
-        if (iflags)
+        if (iflags & ~(MCI_SDIOIRQA | MCI_SDIOIRQB))
                 dev_warn(&slot->mmc->class_dev, "WARNING: IMR=0x%08x\n",
                                 iflags);
 
@@ -952,10 +954,21 @@ static void atmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                 if (mci_has_rwproof())
                         host->mode_reg |= (MCI_MR_WRPROOF | MCI_MR_RDPROOF);
 
-                if (list_empty(&host->queue))
+                if (atmci_is_mci2()) {
+                        /* setup High Speed mode in relation with card capacity */
+                        if (ios->timing == MMC_TIMING_SD_HS)
+                                host->cfg_reg |= MCI_CFG_HSMODE;
+                        else
+                                host->cfg_reg &= ~MCI_CFG_HSMODE;
+                }
+
+                if (list_empty(&host->queue)) {
                         mci_writel(host, MR, host->mode_reg);
-                else
+                        if (atmci_is_mci2())
+                                mci_writel(host, CFG, host->cfg_reg);
+                } else {
                         host->need_clock_update = true;
+                }
 
                 spin_unlock_bh(&host->lock);
         } else {
@@ -1030,11 +1043,23 @@ static int atmci_get_cd(struct mmc_host *mmc)
         return present;
 }
 
+static void atmci_enable_sdio_irq(struct mmc_host *mmc, int enable)
+{
+        struct atmel_mci_slot   *slot = mmc_priv(mmc);
+        struct atmel_mci        *host = slot->host;
+
+        if (enable)
+                mci_writel(host, IER, slot->sdio_irq);
+        else
+                mci_writel(host, IDR, slot->sdio_irq);
+}
+
 static const struct mmc_host_ops atmci_ops = {
         .request        = atmci_request,
         .set_ios        = atmci_set_ios,
         .get_ro         = atmci_get_ro,
         .get_cd         = atmci_get_cd,
+        .enable_sdio_irq = atmci_enable_sdio_irq,
 };
 
 /* Called with host->lock held */
@@ -1052,8 +1077,11 @@ static void atmci_request_end(struct atmel_mci *host, struct mmc_request *mrq)
          * necessary if set_ios() is called when a different slot is
          * busy transfering data.
          */
-        if (host->need_clock_update)
+        if (host->need_clock_update) {
                 mci_writel(host, MR, host->mode_reg);
+                if (atmci_is_mci2())
+                        mci_writel(host, CFG, host->cfg_reg);
+        }
 
         host->cur_slot->mrq = NULL;
         host->mrq = NULL;
@@ -1483,6 +1511,19 @@ static void atmci_cmd_interrupt(struct atmel_mci *host, u32 status)
         tasklet_schedule(&host->tasklet);
 }
 
+static void atmci_sdio_interrupt(struct atmel_mci *host, u32 status)
+{
+        int     i;
+
+        for (i = 0; i < ATMEL_MCI_MAX_NR_SLOTS; i++) {
+                struct atmel_mci_slot *slot = host->slot[i];
+                if (slot && (status & slot->sdio_irq)) {
+                        mmc_signal_sdio_irq(slot->mmc);
+                }
+        }
+}
+
+
 static irqreturn_t atmci_interrupt(int irq, void *dev_id)
 {
         struct atmel_mci        *host = dev_id;
@@ -1522,6 +1563,10 @@ static irqreturn_t atmci_interrupt(int irq, void *dev_id)
 
                 if (pending & MCI_CMDRDY)
                         atmci_cmd_interrupt(host, status);
+
+                if (pending & (MCI_SDIOIRQA | MCI_SDIOIRQB))
+                        atmci_sdio_interrupt(host, status);
+
         } while (pass_count++ < 5);
 
         return pass_count ? IRQ_HANDLED : IRQ_NONE;
@@ -1544,7 +1589,7 @@ static irqreturn_t atmci_detect_interrupt(int irq, void *dev_id)
 
 static int __init atmci_init_slot(struct atmel_mci *host,
                 struct mci_slot_pdata *slot_data, unsigned int id,
-                u32 sdc_reg)
+                u32 sdc_reg, u32 sdio_irq)
 {
         struct mmc_host                 *mmc;
         struct atmel_mci_slot           *slot;
@@ -1560,11 +1605,16 @@ static int __init atmci_init_slot(struct atmel_mci *host,
         slot->wp_pin = slot_data->wp_pin;
         slot->detect_is_active_high = slot_data->detect_is_active_high;
         slot->sdc_reg = sdc_reg;
+        slot->sdio_irq = sdio_irq;
 
         mmc->ops = &atmci_ops;
         mmc->f_min = DIV_ROUND_UP(host->bus_hz, 512);
         mmc->f_max = host->bus_hz / 2;
         mmc->ocr_avail  = MMC_VDD_32_33 | MMC_VDD_33_34;
+        if (sdio_irq)
+                mmc->caps |= MMC_CAP_SDIO_IRQ;
+        if (atmci_is_mci2())
+                mmc->caps |= MMC_CAP_SD_HIGHSPEED;
         if (slot_data->bus_width >= 4)
                 mmc->caps |= MMC_CAP_4_BIT_DATA;
 
@@ -1753,13 +1803,13 @@ static int __init atmci_probe(struct platform_device *pdev)
         ret = -ENODEV;
         if (pdata->slot[0].bus_width) {
                 ret = atmci_init_slot(host, &pdata->slot[0],
-                                0, MCI_SDCSEL_SLOT_A);
+                                0, MCI_SDCSEL_SLOT_A, MCI_SDIOIRQA);
                 if (!ret)
                         nr_slots++;
         }
         if (pdata->slot[1].bus_width) {
                 ret = atmci_init_slot(host, &pdata->slot[1],
-                                1, MCI_SDCSEL_SLOT_B);
+                                1, MCI_SDCSEL_SLOT_B, MCI_SDIOIRQB);
                 if (!ret)
                         nr_slots++;
         }
diff --git a/drivers/mmc/host/au1xmmc.c b/drivers/mmc/host/au1xmmc.c
index f5834449400e..c8da5d30a861 100644
--- a/drivers/mmc/host/au1xmmc.c
+++ b/drivers/mmc/host/au1xmmc.c
@@ -1142,7 +1142,7 @@ static int au1xmmc_suspend(struct platform_device *pdev, pm_message_t state)
         struct au1xmmc_host *host = platform_get_drvdata(pdev);
         int ret;
 
-        ret = mmc_suspend_host(host->mmc, state);
+        ret = mmc_suspend_host(host->mmc);
         if (ret)
                 return ret;
 
diff --git a/drivers/mmc/host/bfin_sdh.c b/drivers/mmc/host/bfin_sdh.c
index 6919e844072c..4b0e677d7295 100644
--- a/drivers/mmc/host/bfin_sdh.c
+++ b/drivers/mmc/host/bfin_sdh.c
@@ -576,7 +576,7 @@ static int sdh_suspend(struct platform_device *dev, pm_message_t state)
         int ret = 0;
 
         if (mmc)
-                ret = mmc_suspend_host(mmc, state);
+                ret = mmc_suspend_host(mmc);
 
         bfin_write_SDH_PWR_CTL(bfin_read_SDH_PWR_CTL() & ~PWR_ON);
         peripheral_free_list(drv_data->pin_req);
diff --git a/drivers/mmc/host/cb710-mmc.c b/drivers/mmc/host/cb710-mmc.c
index 92a324f7417c..ca3bdc831900 100644
--- a/drivers/mmc/host/cb710-mmc.c
+++ b/drivers/mmc/host/cb710-mmc.c
@@ -675,7 +675,7 @@ static int cb710_mmc_suspend(struct platform_device *pdev, pm_message_t state)
         struct mmc_host *mmc = cb710_slot_to_mmc(slot);
         int err;
 
-        err = mmc_suspend_host(mmc, state);
+        err = mmc_suspend_host(mmc);
         if (err)
                 return err;
 
diff --git a/drivers/mmc/host/davinci_mmc.c b/drivers/mmc/host/davinci_mmc.c
index 3bd0ba294e9d..33d9f1b00862 100644
--- a/drivers/mmc/host/davinci_mmc.c
+++ b/drivers/mmc/host/davinci_mmc.c
@@ -137,15 +137,15 @@
 
 /*
  * One scatterlist dma "segment" is at most MAX_CCNT rw_threshold units,
- * and we handle up to NR_SG segments.  MMC_BLOCK_BOUNCE kicks in only
+ * and we handle up to MAX_NR_SG segments.  MMC_BLOCK_BOUNCE kicks in only
  * for drivers with max_hw_segs == 1, making the segments bigger (64KB)
- * than the page or two that's otherwise typical.  NR_SG == 16 gives at
- * least the same throughput boost, using EDMA transfer linkage instead
- * of spending CPU time copying pages.
+ * than the page or two that's otherwise typical. nr_sg (passed from
+ * platform data) == 16 gives at least the same throughput boost, using
+ * EDMA transfer linkage instead of spending CPU time copying pages.
  */
 #define MAX_CCNT        ((1 << 16) - 1)
 
-#define NR_SG           16
+#define MAX_NR_SG       16
 
 static unsigned rw_threshold = 32;
 module_param(rw_threshold, uint, S_IRUGO);
@@ -171,6 +171,7 @@ struct mmc_davinci_host {
 #define DAVINCI_MMC_DATADIR_READ        1
 #define DAVINCI_MMC_DATADIR_WRITE       2
         unsigned char data_dir;
+        unsigned char suspended;
 
         /* buffer is used during PIO of one scatterlist segment, and
          * is updated along with buffer_bytes_left.  bytes_left applies
@@ -192,7 +193,7 @@ struct mmc_davinci_host {
         struct edmacc_param     tx_template;
         struct edmacc_param     rx_template;
         unsigned                n_link;
-        u32                     links[NR_SG - 1];
+        u32                     links[MAX_NR_SG - 1];
 
         /* For PIO we walk scatterlists one segment at a time. */
         unsigned int            sg_len;
@@ -202,6 +203,8 @@ struct mmc_davinci_host {
         u8 version;
         /* for ns in one cycle calculation */
         unsigned ns_in_one_cycle;
+        /* Number of sg segments */
+        u8 nr_sg;
 #ifdef CONFIG_CPU_FREQ
         struct notifier_block   freq_transition;
 #endif
@@ -568,6 +571,7 @@ davinci_release_dma_channels(struct mmc_davinci_host *host)
 
 static int __init davinci_acquire_dma_channels(struct mmc_davinci_host *host)
 {
+        u32 link_size;
         int r, i;
 
         /* Acquire master DMA write channel */
@@ -593,7 +597,8 @@ static int __init davinci_acquire_dma_channels(struct mmc_davinci_host *host)
         /* Allocate parameter RAM slots, which will later be bound to a
          * channel as needed to handle a scatterlist.
          */
-        for (i = 0; i < ARRAY_SIZE(host->links); i++) {
+        link_size = min_t(unsigned, host->nr_sg, ARRAY_SIZE(host->links));
+        for (i = 0; i < link_size; i++) {
                 r = edma_alloc_slot(EDMA_CTLR(host->txdma), EDMA_SLOT_ANY);
                 if (r < 0) {
                         dev_dbg(mmc_dev(host->mmc), "dma PaRAM alloc --> %d\n",
@@ -905,19 +910,26 @@ static void mmc_davinci_cmd_done(struct mmc_davinci_host *host,
         }
 }
 
-static void
-davinci_abort_data(struct mmc_davinci_host *host, struct mmc_data *data)
+static inline void mmc_davinci_reset_ctrl(struct mmc_davinci_host *host,
+                                                                int val)
 {
         u32 temp;
 
-        /* reset command and data state machines */
         temp = readl(host->base + DAVINCI_MMCCTL);
-        writel(temp | MMCCTL_CMDRST | MMCCTL_DATRST,
-                host->base + DAVINCI_MMCCTL);
+        if (val)        /* reset */
+                temp |= MMCCTL_CMDRST | MMCCTL_DATRST;
+        else            /* enable */
+                temp &= ~(MMCCTL_CMDRST | MMCCTL_DATRST);
 
-        temp &= ~(MMCCTL_CMDRST | MMCCTL_DATRST);
-        udelay(10);
         writel(temp, host->base + DAVINCI_MMCCTL);
+        udelay(10);
+}
+
+static void
+davinci_abort_data(struct mmc_davinci_host *host, struct mmc_data *data)
+{
+        mmc_davinci_reset_ctrl(host, 1);
+        mmc_davinci_reset_ctrl(host, 0);
 }
 
 static irqreturn_t mmc_davinci_irq(int irq, void *dev_id)
@@ -1121,15 +1133,8 @@ static inline void mmc_davinci_cpufreq_deregister(struct mmc_davinci_host *host)
 #endif
 static void __init init_mmcsd_host(struct mmc_davinci_host *host)
 {
-        /* DAT line portion is diabled and in reset state */
-        writel(readl(host->base + DAVINCI_MMCCTL) | MMCCTL_DATRST,
-                host->base + DAVINCI_MMCCTL);
-
-        /* CMD line portion is diabled and in reset state */
-        writel(readl(host->base + DAVINCI_MMCCTL) | MMCCTL_CMDRST,
-                host->base + DAVINCI_MMCCTL);
 
-        udelay(10);
+        mmc_davinci_reset_ctrl(host, 1);
 
         writel(0, host->base + DAVINCI_MMCCLK);
         writel(MMCCLK_CLKEN, host->base + DAVINCI_MMCCLK);
@@ -1137,12 +1142,7 @@ static void __init init_mmcsd_host(struct mmc_davinci_host *host)
         writel(0x1FFF, host->base + DAVINCI_MMCTOR);
         writel(0xFFFF, host->base + DAVINCI_MMCTOD);
 
-        writel(readl(host->base + DAVINCI_MMCCTL) & ~MMCCTL_DATRST,
-                host->base + DAVINCI_MMCCTL);
-        writel(readl(host->base + DAVINCI_MMCCTL) & ~MMCCTL_CMDRST,
-                host->base + DAVINCI_MMCCTL);
-
-        udelay(10);
+        mmc_davinci_reset_ctrl(host, 0);
 }
 
 static int __init davinci_mmcsd_probe(struct platform_device *pdev)
@@ -1202,6 +1202,12 @@ static int __init davinci_mmcsd_probe(struct platform_device *pdev)
 
         init_mmcsd_host(host);
 
+        if (pdata->nr_sg)
+                host->nr_sg = pdata->nr_sg - 1;
+
+        if (host->nr_sg > MAX_NR_SG || !host->nr_sg)
+                host->nr_sg = MAX_NR_SG;
+
         host->use_dma = use_dma;
         host->irq = irq;
 
@@ -1327,32 +1333,65 @@ static int __exit davinci_mmcsd_remove(struct platform_device *pdev)
 }
 
 #ifdef CONFIG_PM
-static int davinci_mmcsd_suspend(struct platform_device *pdev, pm_message_t msg)
+static int davinci_mmcsd_suspend(struct device *dev)
 {
+        struct platform_device *pdev = to_platform_device(dev);
         struct mmc_davinci_host *host = platform_get_drvdata(pdev);
+        int ret;
 
-        return mmc_suspend_host(host->mmc, msg);
+        mmc_host_enable(host->mmc);
+        ret = mmc_suspend_host(host->mmc);
+        if (!ret) {
+                writel(0, host->base + DAVINCI_MMCIM);
+                mmc_davinci_reset_ctrl(host, 1);
+                mmc_host_disable(host->mmc);
+                clk_disable(host->clk);
+                host->suspended = 1;
+        } else {
+                host->suspended = 0;
+                mmc_host_disable(host->mmc);
+        }
+
+        return ret;
 }
 
-static int davinci_mmcsd_resume(struct platform_device *pdev)
+static int davinci_mmcsd_resume(struct device *dev)
 {
+        struct platform_device *pdev = to_platform_device(dev);
         struct mmc_davinci_host *host = platform_get_drvdata(pdev);
+        int ret;
+
+        if (!host->suspended)
+                return 0;
 
-        return mmc_resume_host(host->mmc);
+        clk_enable(host->clk);
+        mmc_host_enable(host->mmc);
+
+        mmc_davinci_reset_ctrl(host, 0);
+        ret = mmc_resume_host(host->mmc);
+        if (!ret)
+                host->suspended = 0;
+
+        return ret;
 }
+
+static const struct dev_pm_ops davinci_mmcsd_pm = {
+        .suspend        = davinci_mmcsd_suspend,
+        .resume         = davinci_mmcsd_resume,
+};
+
+#define davinci_mmcsd_pm_ops (&davinci_mmcsd_pm)
 #else
-#define davinci_mmcsd_suspend   NULL
-#define davinci_mmcsd_resume    NULL
+#define davinci_mmcsd_pm_ops NULL
 #endif
 
 static struct platform_driver davinci_mmcsd_driver = {
         .driver         = {
                 .name   = "davinci_mmc",
                 .owner  = THIS_MODULE,
+                .pm     = davinci_mmcsd_pm_ops,
         },
         .remove         = __exit_p(davinci_mmcsd_remove),
-        .suspend        = davinci_mmcsd_suspend,
-        .resume         = davinci_mmcsd_resume,
 };
 
 static int __init davinci_mmcsd_init(void)
diff --git a/drivers/mmc/host/imxmmc.c b/drivers/mmc/host/imxmmc.c
index bf98d7cc928a..9a68ff4353a2 100644
--- a/drivers/mmc/host/imxmmc.c
+++ b/drivers/mmc/host/imxmmc.c
@@ -1115,7 +1115,7 @@ static int imxmci_suspend(struct platform_device *dev, pm_message_t state)
         int ret = 0;
 
         if (mmc)
-                ret = mmc_suspend_host(mmc, state);
+                ret = mmc_suspend_host(mmc);
 
         return ret;
 }
diff --git a/drivers/mmc/host/mmci.c b/drivers/mmc/host/mmci.c
index ff115d920888..4917af96bae1 100644
--- a/drivers/mmc/host/mmci.c
+++ b/drivers/mmc/host/mmci.c
@@ -824,7 +824,7 @@ static int mmci_suspend(struct amba_device *dev, pm_message_t state)
         if (mmc) {
                 struct mmci_host *host = mmc_priv(mmc);
 
-                ret = mmc_suspend_host(mmc, state);
+                ret = mmc_suspend_host(mmc);
                 if (ret == 0)
                         writel(0, host->base + MMCIMASK0);
         }
diff --git a/drivers/mmc/host/msm_sdcc.c b/drivers/mmc/host/msm_sdcc.c
index 61f1d27fed3f..24e09454e522 100644
--- a/drivers/mmc/host/msm_sdcc.c
+++ b/drivers/mmc/host/msm_sdcc.c
@@ -1327,7 +1327,7 @@ msmsdcc_suspend(struct platform_device *dev, pm_message_t state)
                         disable_irq(host->stat_irq);
 
                 if (mmc->card && mmc->card->type != MMC_TYPE_SDIO)
-                        rc = mmc_suspend_host(mmc, state);
+                        rc = mmc_suspend_host(mmc);
                 if (!rc)
                         msmsdcc_writel(host, 0, MMCIMASK0);
                 if (host->clks_on)
diff --git a/drivers/mmc/host/mvsdio.c b/drivers/mmc/host/mvsdio.c
index 34e23489811a..366eefa77c5a 100644
--- a/drivers/mmc/host/mvsdio.c
+++ b/drivers/mmc/host/mvsdio.c
@@ -865,7 +865,7 @@ static int mvsd_suspend(struct platform_device *dev, pm_message_t state)
         int ret = 0;
 
         if (mmc)
-                ret = mmc_suspend_host(mmc, state);
+                ret = mmc_suspend_host(mmc);
 
         return ret;
 }
diff --git a/drivers/mmc/host/mxcmmc.c b/drivers/mmc/host/mxcmmc.c
index 74c87e023866..fdf33e837a73 100644
--- a/drivers/mmc/host/mxcmmc.c
+++ b/drivers/mmc/host/mxcmmc.c
@@ -942,7 +942,7 @@ static int mxcmci_suspend(struct platform_device *dev, pm_message_t state)
         int ret = 0;
 
         if (mmc)
-                ret = mmc_suspend_host(mmc, state);
+                ret = mmc_suspend_host(mmc);
 
         return ret;
 }
diff --git a/drivers/mmc/host/omap.c b/drivers/mmc/host/omap.c
index 84d280406341..2b281680e320 100644
--- a/drivers/mmc/host/omap.c
+++ b/drivers/mmc/host/omap.c
@@ -39,30 +39,30 @@
 #include <plat/fpga.h>
 
 #define OMAP_MMC_REG_CMD        0x00
-#define OMAP_MMC_REG_ARGL       0x04
-#define OMAP_MMC_REG_ARGH       0x08
-#define OMAP_MMC_REG_CON        0x0c
-#define OMAP_MMC_REG_STAT       0x10
-#define OMAP_MMC_REG_IE         0x14
-#define OMAP_MMC_REG_CTO        0x18
-#define OMAP_MMC_REG_DTO        0x1c
-#define OMAP_MMC_REG_DATA       0x20
-#define OMAP_MMC_REG_BLEN       0x24
-#define OMAP_MMC_REG_NBLK       0x28
-#define OMAP_MMC_REG_BUF        0x2c
-#define OMAP_MMC_REG_SDIO       0x34
-#define OMAP_MMC_REG_REV        0x3c
-#define OMAP_MMC_REG_RSP0       0x40
-#define OMAP_MMC_REG_RSP1       0x44
-#define OMAP_MMC_REG_RSP2       0x48
-#define OMAP_MMC_REG_RSP3       0x4c
-#define OMAP_MMC_REG_RSP4       0x50
-#define OMAP_MMC_REG_RSP5       0x54
-#define OMAP_MMC_REG_RSP6       0x58
-#define OMAP_MMC_REG_RSP7       0x5c
-#define OMAP_MMC_REG_IOSR       0x60
-#define OMAP_MMC_REG_SYSC       0x64
-#define OMAP_MMC_REG_SYSS       0x68
+#define OMAP_MMC_REG_ARGL       0x01
+#define OMAP_MMC_REG_ARGH       0x02
+#define OMAP_MMC_REG_CON        0x03
+#define OMAP_MMC_REG_STAT       0x04
+#define OMAP_MMC_REG_IE         0x05
+#define OMAP_MMC_REG_CTO        0x06
+#define OMAP_MMC_REG_DTO        0x07
+#define OMAP_MMC_REG_DATA       0x08
+#define OMAP_MMC_REG_BLEN       0x09
+#define OMAP_MMC_REG_NBLK       0x0a
+#define OMAP_MMC_REG_BUF        0x0b
+#define OMAP_MMC_REG_SDIO       0x0d
+#define OMAP_MMC_REG_REV        0x0f
+#define OMAP_MMC_REG_RSP0       0x10
+#define OMAP_MMC_REG_RSP1       0x11
+#define OMAP_MMC_REG_RSP2       0x12
+#define OMAP_MMC_REG_RSP3       0x13
+#define OMAP_MMC_REG_RSP4       0x14
+#define OMAP_MMC_REG_RSP5       0x15
+#define OMAP_MMC_REG_RSP6       0x16
+#define OMAP_MMC_REG_RSP7       0x17
+#define OMAP_MMC_REG_IOSR       0x18
+#define OMAP_MMC_REG_SYSC       0x19
+#define OMAP_MMC_REG_SYSS       0x1a
 
 #define OMAP_MMC_STAT_CARD_ERR          (1 << 14)
 #define OMAP_MMC_STAT_CARD_IRQ          (1 << 13)
@@ -78,8 +78,9 @@
 #define OMAP_MMC_STAT_CARD_BUSY         (1 <<  2)
 #define OMAP_MMC_STAT_END_OF_CMD        (1 <<  0)
 
-#define OMAP_MMC_READ(host, reg)        __raw_readw((host)->virt_base + OMAP_MMC_REG_##reg)
-#define OMAP_MMC_WRITE(host, reg, val)  __raw_writew((val), (host)->virt_base + OMAP_MMC_REG_##reg)
+#define OMAP_MMC_REG(host, reg)         (OMAP_MMC_REG_##reg << (host)->reg_shift)
+#define OMAP_MMC_READ(host, reg)        __raw_readw((host)->virt_base + OMAP_MMC_REG(host, reg))
+#define OMAP_MMC_WRITE(host, reg, val)  __raw_writew((val), (host)->virt_base + OMAP_MMC_REG(host, reg))
 
 /*
  * Command types
@@ -133,6 +134,7 @@ struct mmc_omap_host {
         int                     irq;
         unsigned char           bus_mode;
         unsigned char           hw_bus_mode;
+        unsigned int            reg_shift;
 
         struct work_struct      cmd_abort_work;
         unsigned                abort:1;
@@ -680,9 +682,9 @@ mmc_omap_xfer_data(struct mmc_omap_host *host, int write)
         host->data->bytes_xfered += n;
 
         if (write) {
-                __raw_writesw(host->virt_base + OMAP_MMC_REG_DATA, host->buffer, n);
+                __raw_writesw(host->virt_base + OMAP_MMC_REG(host, DATA), host->buffer, n);
         } else {
-                __raw_readsw(host->virt_base + OMAP_MMC_REG_DATA, host->buffer, n);
+                __raw_readsw(host->virt_base + OMAP_MMC_REG(host, DATA), host->buffer, n);
         }
 }
 
@@ -900,7 +902,7 @@ mmc_omap_prepare_dma(struct mmc_omap_host *host, struct mmc_data *data)
         int dst_port = 0;
         int sync_dev = 0;
 
-        data_addr = host->phys_base + OMAP_MMC_REG_DATA;
+        data_addr = host->phys_base + OMAP_MMC_REG(host, DATA);
         frame = data->blksz;
         count = sg_dma_len(sg);
 
@@ -1493,6 +1495,8 @@ static int __init mmc_omap_probe(struct platform_device *pdev)
                 }
         }
 
+        host->reg_shift = (cpu_is_omap7xx() ? 1 : 2);
+
         return 0;
 
 err_plat_cleanup:
@@ -1557,7 +1561,7 @@ static int mmc_omap_suspend(struct platform_device *pdev, pm_message_t mesg)
                 struct mmc_omap_slot *slot;
 
                 slot = host->slots[i];
-                ret = mmc_suspend_host(slot->mmc, mesg);
+                ret = mmc_suspend_host(slot->mmc);
                 if (ret < 0) {
                         while (--i >= 0) {
                                 slot = host->slots[i];
diff --git a/drivers/mmc/host/omap_hsmmc.c b/drivers/mmc/host/omap_hsmmc.c
index e9caf694c59e..b032828c6126 100644
--- a/drivers/mmc/host/omap_hsmmc.c
+++ b/drivers/mmc/host/omap_hsmmc.c
@@ -157,12 +157,10 @@ struct omap_hsmmc_host {
          */
         struct  regulator       *vcc;
         struct  regulator       *vcc_aux;
-        struct  semaphore       sem;
         struct  work_struct     mmc_carddetect_work;
         void    __iomem         *base;
         resource_size_t         mapbase;
         spinlock_t              irq_lock; /* Prevent races with irq handler */
-        unsigned long           flags;
         unsigned int            id;
         unsigned int            dma_len;
         unsigned int            dma_sg_idx;
@@ -183,6 +181,7 @@ struct omap_hsmmc_host {
         int                     protect_card;
         int                     reqs_blocked;
         int                     use_reg;
+        int                     req_in_progress;
 
         struct  omap_mmc_platform_data  *pdata;
 };
@@ -524,6 +523,27 @@ static void omap_hsmmc_stop_clock(struct omap_hsmmc_host *host)
                 dev_dbg(mmc_dev(host->mmc), "MMC Clock is not stoped\n");
 }
 
+static void omap_hsmmc_enable_irq(struct omap_hsmmc_host *host)
+{
+        unsigned int irq_mask;
+
+        if (host->use_dma)
+                irq_mask = INT_EN_MASK & ~(BRR_ENABLE | BWR_ENABLE);
+        else
+                irq_mask = INT_EN_MASK;
+
+        OMAP_HSMMC_WRITE(host->base, STAT, STAT_CLEAR);
+        OMAP_HSMMC_WRITE(host->base, ISE, irq_mask);
+        OMAP_HSMMC_WRITE(host->base, IE, irq_mask);
+}
+
+static void omap_hsmmc_disable_irq(struct omap_hsmmc_host *host)
+{
+        OMAP_HSMMC_WRITE(host->base, ISE, 0);
+        OMAP_HSMMC_WRITE(host->base, IE, 0);
+        OMAP_HSMMC_WRITE(host->base, STAT, STAT_CLEAR);
+}
+
 #ifdef CONFIG_PM
 
 /*
@@ -592,9 +612,7 @@ static int omap_hsmmc_context_restore(struct omap_hsmmc_host *host)
                 && time_before(jiffies, timeout))
                 ;
 
-        OMAP_HSMMC_WRITE(host->base, STAT, STAT_CLEAR);
-        OMAP_HSMMC_WRITE(host->base, ISE, INT_EN_MASK);
-        OMAP_HSMMC_WRITE(host->base, IE, INT_EN_MASK);
+        omap_hsmmc_disable_irq(host);
 
         /* Do not initialize card-specific things if the power is off */
         if (host->power_mode == MMC_POWER_OFF)
@@ -697,6 +715,8 @@ static void send_init_stream(struct omap_hsmmc_host *host)
                 return;
 
         disable_irq(host->irq);
+
+        OMAP_HSMMC_WRITE(host->base, IE, INT_EN_MASK);
         OMAP_HSMMC_WRITE(host->base, CON,
                 OMAP_HSMMC_READ(host->base, CON) | INIT_STREAM);
         OMAP_HSMMC_WRITE(host->base, CMD, INIT_STREAM_CMD);
@@ -762,17 +782,7 @@ omap_hsmmc_start_command(struct omap_hsmmc_host *host, struct mmc_command *cmd,
                 mmc_hostname(host->mmc), cmd->opcode, cmd->arg);
         host->cmd = cmd;
 
-        /*
-         * Clear status bits and enable interrupts
-         */
-        OMAP_HSMMC_WRITE(host->base, STAT, STAT_CLEAR);
-        OMAP_HSMMC_WRITE(host->base, ISE, INT_EN_MASK);
-
-        if (host->use_dma)
-                OMAP_HSMMC_WRITE(host->base, IE,
-                                 INT_EN_MASK & ~(BRR_ENABLE | BWR_ENABLE));
-        else
-                OMAP_HSMMC_WRITE(host->base, IE, INT_EN_MASK);
+        omap_hsmmc_enable_irq(host);
 
         host->response_busy = 0;
         if (cmd->flags & MMC_RSP_PRESENT) {
@@ -806,13 +816,7 @@ omap_hsmmc_start_command(struct omap_hsmmc_host *host, struct mmc_command *cmd,
         if (host->use_dma)
                 cmdreg |= DMA_EN;
 
-        /*
-         * In an interrupt context (i.e. STOP command), the spinlock is unlocked
-         * by the interrupt handler, otherwise (i.e. for a new request) it is
-         * unlocked here.
-         */
-        if (!in_interrupt())
-                spin_unlock_irqrestore(&host->irq_lock, host->flags);
+        host->req_in_progress = 1;
 
         OMAP_HSMMC_WRITE(host->base, ARG, cmd->arg);
         OMAP_HSMMC_WRITE(host->base, CMD, cmdreg);
@@ -827,6 +831,23 @@ omap_hsmmc_get_dma_dir(struct omap_hsmmc_host *host, struct mmc_data *data)
                 return DMA_FROM_DEVICE;
 }
 
+static void omap_hsmmc_request_done(struct omap_hsmmc_host *host, struct mmc_request *mrq)
+{
+        int dma_ch;
+
+        spin_lock(&host->irq_lock);
+        host->req_in_progress = 0;
+        dma_ch = host->dma_ch;
+        spin_unlock(&host->irq_lock);
+
+        omap_hsmmc_disable_irq(host);
+        /* Do not complete the request if DMA is still in progress */
+        if (mrq->data && host->use_dma && dma_ch != -1)
+                return;
+        host->mrq = NULL;
+        mmc_request_done(host->mmc, mrq);
+}
+
 /*
  * Notify the transfer complete to MMC core
  */
@@ -843,25 +864,19 @@ omap_hsmmc_xfer_done(struct omap_hsmmc_host *host, struct mmc_data *data)
                         return;
                 }
 
-                host->mrq = NULL;
-                mmc_request_done(host->mmc, mrq);
+                omap_hsmmc_request_done(host, mrq);
                 return;
         }
 
         host->data = NULL;
 
-        if (host->use_dma && host->dma_ch != -1)
-                dma_unmap_sg(mmc_dev(host->mmc), data->sg, host->dma_len,
-                        omap_hsmmc_get_dma_dir(host, data));
-
         if (!data->error)
                 data->bytes_xfered += data->blocks * (data->blksz);
         else
                 data->bytes_xfered = 0;
 
         if (!data->stop) {
-                host->mrq = NULL;
-                mmc_request_done(host->mmc, data->mrq);
+                omap_hsmmc_request_done(host, data->mrq);
                 return;
         }
         omap_hsmmc_start_command(host, data->stop, NULL);
@@ -887,10 +902,8 @@ omap_hsmmc_cmd_done(struct omap_hsmmc_host *host, struct mmc_command *cmd)
                         cmd->resp[0] = OMAP_HSMMC_READ(host->base, RSP10);
                 }
         }
-        if ((host->data == NULL && !host->response_busy) || cmd->error) {
-                host->mrq = NULL;
-                mmc_request_done(host->mmc, cmd->mrq);
-        }
+        if ((host->data == NULL && !host->response_busy) || cmd->error)
+                omap_hsmmc_request_done(host, cmd->mrq);
 }
 
 /*
@@ -898,14 +911,19 @@ omap_hsmmc_cmd_done(struct omap_hsmmc_host *host, struct mmc_command *cmd)
  */
 static void omap_hsmmc_dma_cleanup(struct omap_hsmmc_host *host, int errno)
 {
+        int dma_ch;
+
         host->data->error = errno;
 
-        if (host->use_dma && host->dma_ch != -1) {
+        spin_lock(&host->irq_lock);
+        dma_ch = host->dma_ch;
+        host->dma_ch = -1;
+        spin_unlock(&host->irq_lock);
+
+        if (host->use_dma && dma_ch != -1) {
                 dma_unmap_sg(mmc_dev(host->mmc), host->data->sg, host->dma_len,
                         omap_hsmmc_get_dma_dir(host, host->data));
-                omap_free_dma(host->dma_ch);
-                host->dma_ch = -1;
-                up(&host->sem);
+                omap_free_dma(dma_ch);
         }
         host->data = NULL;
 }
@@ -967,28 +985,21 @@ static inline void omap_hsmmc_reset_controller_fsm(struct omap_hsmmc_host *host,
                         __func__);
 }
 
-/*
- * MMC controller IRQ handler
- */
-static irqreturn_t omap_hsmmc_irq(int irq, void *dev_id)
+static void omap_hsmmc_do_irq(struct omap_hsmmc_host *host, int status)
 {
-        struct omap_hsmmc_host *host = dev_id;
         struct mmc_data *data;
-        int end_cmd = 0, end_trans = 0, status;
-
-        spin_lock(&host->irq_lock);
-
-        if (host->mrq == NULL) {
-                OMAP_HSMMC_WRITE(host->base, STAT,
-                        OMAP_HSMMC_READ(host->base, STAT));
-                /* Flush posted write */
-                OMAP_HSMMC_READ(host->base, STAT);
-                spin_unlock(&host->irq_lock);
-                return IRQ_HANDLED;
+        int end_cmd = 0, end_trans = 0;
+
+        if (!host->req_in_progress) {
+                do {
+                        OMAP_HSMMC_WRITE(host->base, STAT, status);
+                        /* Flush posted write */
+                        status = OMAP_HSMMC_READ(host->base, STAT);
+                } while (status & INT_EN_MASK);
+                return;
         }
 
         data = host->data;
-        status = OMAP_HSMMC_READ(host->base, STAT);
         dev_dbg(mmc_dev(host->mmc), "IRQ Status is %x\n", status);
 
         if (status & ERR) {
@@ -1041,15 +1052,27 @@ static irqreturn_t omap_hsmmc_irq(int irq, void *dev_id)
         }
 
         OMAP_HSMMC_WRITE(host->base, STAT, status);
-        /* Flush posted write */
-        OMAP_HSMMC_READ(host->base, STAT);
 
         if (end_cmd || ((status & CC) && host->cmd))
                 omap_hsmmc_cmd_done(host, host->cmd);
         if ((end_trans || (status & TC)) && host->mrq)
                 omap_hsmmc_xfer_done(host, data);
+}
 
-        spin_unlock(&host->irq_lock);
+/*
+ * MMC controller IRQ handler
+ */
+static irqreturn_t omap_hsmmc_irq(int irq, void *dev_id)
+{
+        struct omap_hsmmc_host *host = dev_id;
+        int status;
+
+        status = OMAP_HSMMC_READ(host->base, STAT);
+        do {
+                omap_hsmmc_do_irq(host, status);
+                /* Flush posted write */
+                status = OMAP_HSMMC_READ(host->base, STAT);
+        } while (status & INT_EN_MASK);
 
         return IRQ_HANDLED;
 }
@@ -1244,31 +1267,47 @@ static void omap_hsmmc_config_dma_params(struct omap_hsmmc_host *host,
 /*
  * DMA call back function
  */
-static void omap_hsmmc_dma_cb(int lch, u16 ch_status, void *data)
+static void omap_hsmmc_dma_cb(int lch, u16 ch_status, void *cb_data)
 {
-        struct omap_hsmmc_host *host = data;
+        struct omap_hsmmc_host *host = cb_data;
+        struct mmc_data *data = host->mrq->data;
+        int dma_ch, req_in_progress;
 
         if (ch_status & OMAP2_DMA_MISALIGNED_ERR_IRQ)
                 dev_dbg(mmc_dev(host->mmc), "MISALIGNED_ADRS_ERR\n");
 
-        if (host->dma_ch < 0)
+        spin_lock(&host->irq_lock);
+        if (host->dma_ch < 0) {
+                spin_unlock(&host->irq_lock);
                 return;
+        }
 
         host->dma_sg_idx++;
         if (host->dma_sg_idx < host->dma_len) {
                 /* Fire up the next transfer. */
-                omap_hsmmc_config_dma_params(host, host->data,
-                                           host->data->sg + host->dma_sg_idx);
+                omap_hsmmc_config_dma_params(host, data,
+                                           data->sg + host->dma_sg_idx);
+                spin_unlock(&host->irq_lock);
                 return;
         }
 
-        omap_free_dma(host->dma_ch);
+        dma_unmap_sg(mmc_dev(host->mmc), data->sg, host->dma_len,
+                omap_hsmmc_get_dma_dir(host, data));
+
+        req_in_progress = host->req_in_progress;
+        dma_ch = host->dma_ch;
         host->dma_ch = -1;
-        /*
-         * DMA Callback: run in interrupt context.
-         * mutex_unlock will throw a kernel warning if used.
-         */
-        up(&host->sem);
+        spin_unlock(&host->irq_lock);
+
+        omap_free_dma(dma_ch);
+
+        /* If DMA has finished after TC, complete the request */
+        if (!req_in_progress) {
+                struct mmc_request *mrq = host->mrq;
+
+                host->mrq = NULL;
+                mmc_request_done(host->mmc, mrq);
+        }
 }
 
 /*
@@ -1277,7 +1316,7 @@ static void omap_hsmmc_dma_cb(int lch, u16 ch_status, void *data)
 static int omap_hsmmc_start_dma_transfer(struct omap_hsmmc_host *host,
                                         struct mmc_request *req)
 {
-        int dma_ch = 0, ret = 0, err = 1, i;
+        int dma_ch = 0, ret = 0, i;
         struct mmc_data *data = req->data;
 
         /* Sanity check: all the SG entries must be aligned by block size. */
@@ -1294,23 +1333,7 @@ static int omap_hsmmc_start_dma_transfer(struct omap_hsmmc_host *host,
                  */
                 return -EINVAL;
 
-        /*
-         * If for some reason the DMA transfer is still active,
-         * we wait for timeout period and free the dma
-         */
-        if (host->dma_ch != -1) {
-                set_current_state(TASK_UNINTERRUPTIBLE);
-                schedule_timeout(100);
-                if (down_trylock(&host->sem)) {
-                        omap_free_dma(host->dma_ch);
-                        host->dma_ch = -1;
-                        up(&host->sem);
-                        return err;
-                }
-        } else {
-                if (down_trylock(&host->sem))
-                        return err;
-        }
+        BUG_ON(host->dma_ch != -1);
 
         ret = omap_request_dma(omap_hsmmc_get_dma_sync_dev(host, data),
                                "MMC/SD", omap_hsmmc_dma_cb, host, &dma_ch);
@@ -1410,37 +1433,27 @@ static void omap_hsmmc_request(struct mmc_host *mmc, struct mmc_request *req)
         struct omap_hsmmc_host *host = mmc_priv(mmc);
         int err;
 
-        /*
-         * Prevent races with the interrupt handler because of unexpected
-         * interrupts, but not if we are already in interrupt context i.e.
-         * retries.
-         */
-        if (!in_interrupt()) {
-                spin_lock_irqsave(&host->irq_lock, host->flags);
-                /*
-                 * Protect the card from I/O if there is a possibility
-                 * it can be removed.
-                 */
-                if (host->protect_card) {
-                        if (host->reqs_blocked < 3) {
-                                /*
-                                 * Ensure the controller is left in a consistent
-                                 * state by resetting the command and data state
-                                 * machines.
-                                 */
-                                omap_hsmmc_reset_controller_fsm(host, SRD);
-                                omap_hsmmc_reset_controller_fsm(host, SRC);
-                                host->reqs_blocked += 1;
-                        }
-                        req->cmd->error = -EBADF;
-                        if (req->data)
-                                req->data->error = -EBADF;
-                        spin_unlock_irqrestore(&host->irq_lock, host->flags);
-                        mmc_request_done(mmc, req);
-                        return;
-                } else if (host->reqs_blocked)
-                        host->reqs_blocked = 0;
-        }
+        BUG_ON(host->req_in_progress);
+        BUG_ON(host->dma_ch != -1);
+        if (host->protect_card) {
+                if (host->reqs_blocked < 3) {
+                        /*
+                         * Ensure the controller is left in a consistent
+                         * state by resetting the command and data state
+                         * machines.
+                         */
+                        omap_hsmmc_reset_controller_fsm(host, SRD);
+                        omap_hsmmc_reset_controller_fsm(host, SRC);
+                        host->reqs_blocked += 1;
+                }
+                req->cmd->error = -EBADF;
+                if (req->data)
+                        req->data->error = -EBADF;
+                req->cmd->retries = 0;
+                mmc_request_done(mmc, req);
+                return;
+        } else if (host->reqs_blocked)
+                host->reqs_blocked = 0;
         WARN_ON(host->mrq != NULL);
         host->mrq = req;
         err = omap_hsmmc_prepare_data(host, req);
@@ -1449,8 +1462,6 @@ static void omap_hsmmc_request(struct mmc_host *mmc, struct mmc_request *req)
                 if (req->data)
                         req->data->error = err;
                 host->mrq = NULL;
-                if (!in_interrupt())
-                        spin_unlock_irqrestore(&host->irq_lock, host->flags);
                 mmc_request_done(mmc, req);
                 return;
         }
@@ -2019,7 +2030,6 @@ static int __init omap_hsmmc_probe(struct platform_device *pdev)
         mmc->f_min      = 400000;
         mmc->f_max      = 52000000;
 
-        sema_init(&host->sem, 1);
         spin_lock_init(&host->irq_lock);
 
         host->iclk = clk_get(&pdev->dev, "ick");
@@ -2162,8 +2172,7 @@ static int __init omap_hsmmc_probe(struct platform_device *pdev)
                 }
         }
 
-        OMAP_HSMMC_WRITE(host->base, ISE, INT_EN_MASK);
-        OMAP_HSMMC_WRITE(host->base, IE, INT_EN_MASK);
+        omap_hsmmc_disable_irq(host);
 
         mmc_host_lazy_disable(host->mmc);
 
@@ -2258,10 +2267,12 @@ static int omap_hsmmc_remove(struct platform_device *pdev)
 }
 
 #ifdef CONFIG_PM
-static int omap_hsmmc_suspend(struct platform_device *pdev, pm_message_t state)
+static int omap_hsmmc_suspend(struct device *dev)
 {
         int ret = 0;
+        struct platform_device *pdev = to_platform_device(dev);
         struct omap_hsmmc_host *host = platform_get_drvdata(pdev);
+        pm_message_t state = PMSG_SUSPEND; /* unused by MMC core */
 
         if (host && host->suspended)
                 return 0;
@@ -2281,12 +2292,9 @@ static int omap_hsmmc_suspend(struct platform_device *pdev, pm_message_t state)
                 }
                 cancel_work_sync(&host->mmc_carddetect_work);
                 mmc_host_enable(host->mmc);
-                ret = mmc_suspend_host(host->mmc, state);
+                ret = mmc_suspend_host(host->mmc);
                 if (ret == 0) {
-                        OMAP_HSMMC_WRITE(host->base, ISE, 0);
-                        OMAP_HSMMC_WRITE(host->base, IE, 0);
-
-
+                        omap_hsmmc_disable_irq(host);
                         OMAP_HSMMC_WRITE(host->base, HCTL,
                                 OMAP_HSMMC_READ(host->base, HCTL) & ~SDBP);
                         mmc_host_disable(host->mmc);
@@ -2310,9 +2318,10 @@ static int omap_hsmmc_suspend(struct platform_device *pdev, pm_message_t state)
 }
 
 /* Routine to resume the MMC device */
-static int omap_hsmmc_resume(struct platform_device *pdev)
+static int omap_hsmmc_resume(struct device *dev)
 {
         int ret = 0;
+        struct platform_device *pdev = to_platform_device(dev);
         struct omap_hsmmc_host *host = platform_get_drvdata(pdev);
 
         if (host && !host->suspended)
@@ -2363,13 +2372,17 @@ clk_en_err:
 #define omap_hsmmc_resume               NULL
 #endif
 
-static struct platform_driver omap_hsmmc_driver = {
-        .remove         = omap_hsmmc_remove,
+static struct dev_pm_ops omap_hsmmc_dev_pm_ops = {
         .suspend        = omap_hsmmc_suspend,
         .resume         = omap_hsmmc_resume,
+};
+
+static struct platform_driver omap_hsmmc_driver = {
+        .remove         = omap_hsmmc_remove,
         .driver         = {
                 .name = DRIVER_NAME,
                 .owner = THIS_MODULE,
+                .pm = &omap_hsmmc_dev_pm_ops,
         },
 };
 
diff --git a/drivers/mmc/host/pxamci.c b/drivers/mmc/host/pxamci.c
index e4f00e70a749..0a4e43f37140 100644
--- a/drivers/mmc/host/pxamci.c
+++ b/drivers/mmc/host/pxamci.c
@@ -813,7 +813,7 @@ static int pxamci_suspend(struct device *dev)
         int ret = 0;
 
         if (mmc)
-                ret = mmc_suspend_host(mmc, PMSG_SUSPEND);
+                ret = mmc_suspend_host(mmc);
 
         return ret;
 }
diff --git a/drivers/mmc/host/s3cmci.c b/drivers/mmc/host/s3cmci.c
index 2fdf7689ae6c..2e16e0a90a5e 100644
--- a/drivers/mmc/host/s3cmci.c
+++ b/drivers/mmc/host/s3cmci.c
@@ -1881,9 +1881,8 @@ MODULE_DEVICE_TABLE(platform, s3cmci_driver_ids);
 static int s3cmci_suspend(struct device *dev)
 {
         struct mmc_host *mmc = platform_get_drvdata(to_platform_device(dev));
-        struct pm_message event = { PM_EVENT_SUSPEND };
 
-        return mmc_suspend_host(mmc, event);
+        return mmc_suspend_host(mmc);
 }
 
 static int s3cmci_resume(struct device *dev)
diff --git a/drivers/mmc/host/sdhci-of-core.c b/drivers/mmc/host/sdhci-of-core.c
index 7802a543d8fc..a2e9820cd42f 100644
--- a/drivers/mmc/host/sdhci-of-core.c
+++ b/drivers/mmc/host/sdhci-of-core.c
@@ -89,7 +89,7 @@ static int sdhci_of_suspend(struct of_device *ofdev, pm_message_t state)
 {
         struct sdhci_host *host = dev_get_drvdata(&ofdev->dev);
 
-        return mmc_suspend_host(host->mmc, state);
+        return mmc_suspend_host(host->mmc);
 }
 
 static int sdhci_of_resume(struct of_device *ofdev)
diff --git a/drivers/mmc/host/sdhci-of-esdhc.c b/drivers/mmc/host/sdhci-of-esdhc.c
index d5b11a17e648..c8623de13af3 100644
--- a/drivers/mmc/host/sdhci-of-esdhc.c
+++ b/drivers/mmc/host/sdhci-of-esdhc.c
@@ -129,12 +129,12 @@ struct sdhci_of_data sdhci_esdhc = {
                   SDHCI_QUIRK_RESTORE_IRQS_AFTER_RESET |
                   SDHCI_QUIRK_NO_CARD_NO_RESET,
         .ops = {
-                .readl = sdhci_be32bs_readl,
-                .readw = esdhc_readw,
-                .readb = sdhci_be32bs_readb,
-                .writel = sdhci_be32bs_writel,
-                .writew = esdhc_writew,
-                .writeb = esdhc_writeb,
+                .read_l = sdhci_be32bs_readl,
+                .read_w = esdhc_readw,
+                .read_b = sdhci_be32bs_readb,
+                .write_l = sdhci_be32bs_writel,
+                .write_w = esdhc_writew,
+                .write_b = esdhc_writeb,
                 .set_clock = esdhc_set_clock,
                 .enable_dma = esdhc_enable_dma,
                 .get_max_clock = esdhc_get_max_clock,
diff --git a/drivers/mmc/host/sdhci-of-hlwd.c b/drivers/mmc/host/sdhci-of-hlwd.c
index 35117f3ed757..68ddb7546ae2 100644
--- a/drivers/mmc/host/sdhci-of-hlwd.c
+++ b/drivers/mmc/host/sdhci-of-hlwd.c
@@ -55,11 +55,11 @@ struct sdhci_of_data sdhci_hlwd = {
         .quirks = SDHCI_QUIRK_32BIT_DMA_ADDR |
                   SDHCI_QUIRK_32BIT_DMA_SIZE,
         .ops = {
-                .readl = sdhci_be32bs_readl,
-                .readw = sdhci_be32bs_readw,
-                .readb = sdhci_be32bs_readb,
-                .writel = sdhci_hlwd_writel,
-                .writew = sdhci_hlwd_writew,
-                .writeb = sdhci_hlwd_writeb,
+                .read_l = sdhci_be32bs_readl,
+                .read_w = sdhci_be32bs_readw,
+                .read_b = sdhci_be32bs_readb,
+                .write_l = sdhci_hlwd_writel,
+                .write_w = sdhci_hlwd_writew,
+                .write_b = sdhci_hlwd_writeb,
         },
 };
diff --git a/drivers/mmc/host/sdhci-pci.c b/drivers/mmc/host/sdhci-pci.c
index 6701af629c30..65483fdea45b 100644
--- a/drivers/mmc/host/sdhci-pci.c
+++ b/drivers/mmc/host/sdhci-pci.c
@@ -628,7 +628,7 @@ static struct sdhci_pci_slot * __devinit sdhci_pci_probe_slot(
         host = sdhci_alloc_host(&pdev->dev, sizeof(struct sdhci_pci_slot));
         if (IS_ERR(host)) {
                 dev_err(&pdev->dev, "cannot allocate host\n");
-                return ERR_PTR(PTR_ERR(host));
+                return ERR_CAST(host);
         }
 
         slot = sdhci_priv(host);
diff --git a/drivers/mmc/host/sdhci-pltfm.c b/drivers/mmc/host/sdhci-pltfm.c
index 297f40ae6ad5..b6ee0d719698 100644
--- a/drivers/mmc/host/sdhci-pltfm.c
+++ b/drivers/mmc/host/sdhci-pltfm.c
@@ -29,6 +29,7 @@
 #include <linux/mmc/host.h>
 
 #include <linux/io.h>
+#include <linux/sdhci-pltfm.h>
 
 #include "sdhci.h"
 
@@ -49,19 +50,18 @@ static struct sdhci_ops sdhci_pltfm_ops = {
 
 static int __devinit sdhci_pltfm_probe(struct platform_device *pdev)
 {
+        struct sdhci_pltfm_data *pdata = pdev->dev.platform_data;
         struct sdhci_host *host;
         struct resource *iomem;
         int ret;
 
-        BUG_ON(pdev == NULL);
-
         iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!iomem) {
                 ret = -ENOMEM;
                 goto err;
         }
 
-        if (resource_size(iomem) != 0x100)
+        if (resource_size(iomem) < 0x100)
                 dev_err(&pdev->dev, "Invalid iomem size. You may "
                         "experience problems.\n");
 
@@ -76,7 +76,12 @@ static int __devinit sdhci_pltfm_probe(struct platform_device *pdev)
         }
 
         host->hw_name = "platform";
-        host->ops = &sdhci_pltfm_ops;
+        if (pdata && pdata->ops)
+                host->ops = pdata->ops;
+        else
+                host->ops = &sdhci_pltfm_ops;
+        if (pdata)
+                host->quirks = pdata->quirks;
         host->irq = platform_get_irq(pdev, 0);
 
         if (!request_mem_region(iomem->start, resource_size(iomem),
@@ -93,6 +98,12 @@ static int __devinit sdhci_pltfm_probe(struct platform_device *pdev)
                 goto err_remap;
         }
 
+        if (pdata && pdata->init) {
+                ret = pdata->init(host);
+                if (ret)
+                        goto err_plat_init;
+        }
+
         ret = sdhci_add_host(host);
         if (ret)
                 goto err_add_host;
@@ -102,6 +113,9 @@ static int __devinit sdhci_pltfm_probe(struct platform_device *pdev)
         return 0;
 
 err_add_host:
+        if (pdata && pdata->exit)
+                pdata->exit(host);
+err_plat_init:
         iounmap(host->ioaddr);
 err_remap:
         release_mem_region(iomem->start, resource_size(iomem));
@@ -114,6 +128,7 @@ err:
 
 static int __devexit sdhci_pltfm_remove(struct platform_device *pdev)
 {
+        struct sdhci_pltfm_data *pdata = pdev->dev.platform_data;
         struct sdhci_host *host = platform_get_drvdata(pdev);
         struct resource *iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         int dead;
@@ -125,6 +140,8 @@ static int __devexit sdhci_pltfm_remove(struct platform_device *pdev)
                 dead = 1;
 
         sdhci_remove_host(host, dead);
+        if (pdata && pdata->exit)
+                pdata->exit(host);
         iounmap(host->ioaddr);
         release_mem_region(iomem->start, resource_size(iomem));
         sdhci_free_host(host);
@@ -165,4 +182,3 @@ MODULE_DESCRIPTION("Secure Digital Host Controller Interface platform driver");
 MODULE_AUTHOR("Mocean Laboratories <info@mocean-labs.com>");
 MODULE_LICENSE("GPL v2");
 MODULE_ALIAS("platform:sdhci");
-
diff --git a/drivers/mmc/host/sdhci-s3c.c b/drivers/mmc/host/sdhci-s3c.c
index 2136794c0cfa..af217924a76e 100644
--- a/drivers/mmc/host/sdhci-s3c.c
+++ b/drivers/mmc/host/sdhci-s3c.c
@@ -317,12 +317,7 @@ static int __devinit sdhci_s3c_probe(struct platform_device *pdev)
         host->irq = irq;
 
         /* Setup quirks for the controller */
-
-        /* Currently with ADMA enabled we are getting some length
-         * interrupts that are not being dealt with, do disable
-         * ADMA until this is sorted out. */
-        host->quirks |= SDHCI_QUIRK_BROKEN_ADMA;
-        host->quirks |= SDHCI_QUIRK_32BIT_ADMA_SIZE;
+        host->quirks |= SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC;
 
 #ifndef CONFIG_MMC_SDHCI_S3C_DMA
 
@@ -330,9 +325,6 @@ static int __devinit sdhci_s3c_probe(struct platform_device *pdev)
          * support as well. */
         host->quirks |= SDHCI_QUIRK_BROKEN_DMA;
 
-        /* PIO currently has problems with multi-block IO */
-        host->quirks |= SDHCI_QUIRK_NO_MULTIBLOCK;
-
 #endif /* CONFIG_MMC_SDHCI_S3C_DMA */
 
         /* It seems we do not get an DATA transfer complete on non-busy
diff --git a/drivers/mmc/host/sdhci-spear.c b/drivers/mmc/host/sdhci-spear.c
new file mode 100644
index 000000000000..d70c54c7b70a
--- /dev/null
+++ b/drivers/mmc/host/sdhci-spear.c
@@ -0,0 +1,298 @@
+/*
+ * drivers/mmc/host/sdhci-spear.c
+ *
+ * Support of SDHCI platform devices for spear soc family
+ *
+ * Copyright (C) 2010 ST Microelectronics
+ * Viresh Kumar<viresh.kumar@st.com>
+ *
+ * Inspired by sdhci-pltfm.c
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed "as is" without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include <linux/clk.h>
+#include <linux/delay.h>
+#include <linux/gpio.h>
+#include <linux/highmem.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/mmc/host.h>
+#include <linux/mmc/sdhci-spear.h>
+#include <linux/io.h>
+#include "sdhci.h"
+
+struct spear_sdhci {
+        struct clk *clk;
+        struct sdhci_plat_data *data;
+};
+
+/* sdhci ops */
+static struct sdhci_ops sdhci_pltfm_ops = {
+        /* Nothing to do for now. */
+};
+
+/* gpio card detection interrupt handler */
+static irqreturn_t sdhci_gpio_irq(int irq, void *dev_id)
+{
+        struct platform_device *pdev = dev_id;
+        struct sdhci_host *host = platform_get_drvdata(pdev);
+        struct spear_sdhci *sdhci = dev_get_platdata(&pdev->dev);
+        unsigned long gpio_irq_type;
+        int val;
+
+        val = gpio_get_value(sdhci->data->card_int_gpio);
+
+        /* val == 1 -> card removed, val == 0 -> card inserted */
+        /* if card removed - set irq for low level, else vice versa */
+        gpio_irq_type = val ? IRQF_TRIGGER_LOW : IRQF_TRIGGER_HIGH;
+        set_irq_type(irq, gpio_irq_type);
+
+        if (sdhci->data->card_power_gpio >= 0) {
+                if (!sdhci->data->power_always_enb) {
+                        /* if card inserted, give power, otherwise remove it */
+                        val = sdhci->data->power_active_high ? !val : val ;
+                        gpio_set_value(sdhci->data->card_power_gpio, val);
+                }
+        }
+
+        /* inform sdhci driver about card insertion/removal */
+        tasklet_schedule(&host->card_tasklet);
+
+        return IRQ_HANDLED;
+}
+
+static int __devinit sdhci_probe(struct platform_device *pdev)
+{
+        struct sdhci_host *host;
+        struct resource *iomem;
+        struct spear_sdhci *sdhci;
+        int ret;
+
+        BUG_ON(pdev == NULL);
+
+        iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!iomem) {
+                ret = -ENOMEM;
+                dev_dbg(&pdev->dev, "memory resource not defined\n");
+                goto err;
+        }
+
+        if (!request_mem_region(iomem->start, resource_size(iomem),
+                                "spear-sdhci")) {
+                ret = -EBUSY;
+                dev_dbg(&pdev->dev, "cannot request region\n");
+                goto err;
+        }
+
+        sdhci = kzalloc(sizeof(*sdhci), GFP_KERNEL);
+        if (!sdhci) {
+                ret = -ENOMEM;
+                dev_dbg(&pdev->dev, "cannot allocate memory for sdhci\n");
+                goto err_kzalloc;
+        }
+
+        /* clk enable */
+        sdhci->clk = clk_get(&pdev->dev, NULL);
+        if (IS_ERR(sdhci->clk)) {
+                ret = PTR_ERR(sdhci->clk);
+                dev_dbg(&pdev->dev, "Error getting clock\n");
+                goto err_clk_get;
+        }
+
+        ret = clk_enable(sdhci->clk);
+        if (ret) {
+                dev_dbg(&pdev->dev, "Error enabling clock\n");
+                goto err_clk_enb;
+        }
+
+        /* overwrite platform_data */
+        sdhci->data = dev_get_platdata(&pdev->dev);
+        pdev->dev.platform_data = sdhci;
+
+        if (pdev->dev.parent)
+                host = sdhci_alloc_host(pdev->dev.parent, 0);
+        else
+                host = sdhci_alloc_host(&pdev->dev, 0);
+
+        if (IS_ERR(host)) {
+                ret = PTR_ERR(host);
+                dev_dbg(&pdev->dev, "error allocating host\n");
+                goto err_alloc_host;
+        }
+
+        host->hw_name = "sdhci";
+        host->ops = &sdhci_pltfm_ops;
+        host->irq = platform_get_irq(pdev, 0);
+        host->quirks = SDHCI_QUIRK_BROKEN_ADMA;
+
+        host->ioaddr = ioremap(iomem->start, resource_size(iomem));
+        if (!host->ioaddr) {
+                ret = -ENOMEM;
+                dev_dbg(&pdev->dev, "failed to remap registers\n");
+                goto err_ioremap;
+        }
+
+        ret = sdhci_add_host(host);
+        if (ret) {
+                dev_dbg(&pdev->dev, "error adding host\n");
+                goto err_add_host;
+        }
+
+        platform_set_drvdata(pdev, host);
+
+        /*
+         * It is optional to use GPIOs for sdhci Power control & sdhci card
+         * interrupt detection. If sdhci->data is NULL, then use original sdhci
+         * lines otherwise GPIO lines.
+         * If GPIO is selected for power control, then power should be disabled
+         * after card removal and should be enabled when card insertion
+         * interrupt occurs
+         */
+        if (!sdhci->data)
+                return 0;
+
+        if (sdhci->data->card_power_gpio >= 0) {
+                int val = 0;
+
+                ret = gpio_request(sdhci->data->card_power_gpio, "sdhci");
+                if (ret < 0) {
+                        dev_dbg(&pdev->dev, "gpio request fail: %d\n",
+                                        sdhci->data->card_power_gpio);
+                        goto err_pgpio_request;
+                }
+
+                if (sdhci->data->power_always_enb)
+                        val = sdhci->data->power_active_high;
+                else
+                        val = !sdhci->data->power_active_high;
+
+                ret = gpio_direction_output(sdhci->data->card_power_gpio, val);
+                if (ret) {
+                        dev_dbg(&pdev->dev, "gpio set direction fail: %d\n",
+                                        sdhci->data->card_power_gpio);
+                        goto err_pgpio_direction;
+                }
+
+                gpio_set_value(sdhci->data->card_power_gpio, 1);
+        }
+
+        if (sdhci->data->card_int_gpio >= 0) {
+                ret = gpio_request(sdhci->data->card_int_gpio, "sdhci");
+                if (ret < 0) {
+                        dev_dbg(&pdev->dev, "gpio request fail: %d\n",
+                                        sdhci->data->card_int_gpio);
+                        goto err_igpio_request;
+                }
+
+                ret = gpio_direction_input(sdhci->data->card_int_gpio);
+                if (ret) {
+                        dev_dbg(&pdev->dev, "gpio set direction fail: %d\n",
+                                        sdhci->data->card_int_gpio);
+                        goto err_igpio_direction;
+                }
+                ret = request_irq(gpio_to_irq(sdhci->data->card_int_gpio),
+                                sdhci_gpio_irq, IRQF_TRIGGER_LOW,
+                                mmc_hostname(host->mmc), pdev);
+                if (ret) {
+                        dev_dbg(&pdev->dev, "gpio request irq fail: %d\n",
+                                        sdhci->data->card_int_gpio);
+                        goto err_igpio_request_irq;
+                }
+
+        }
+
+        return 0;
+
+err_igpio_request_irq:
+err_igpio_direction:
+        if (sdhci->data->card_int_gpio >= 0)
+                gpio_free(sdhci->data->card_int_gpio);
+err_igpio_request:
+err_pgpio_direction:
+        if (sdhci->data->card_power_gpio >= 0)
+                gpio_free(sdhci->data->card_power_gpio);
+err_pgpio_request:
+        platform_set_drvdata(pdev, NULL);
+        sdhci_remove_host(host, 1);
+err_add_host:
+        iounmap(host->ioaddr);
+err_ioremap:
+        sdhci_free_host(host);
+err_alloc_host:
+        clk_disable(sdhci->clk);
+err_clk_enb:
+        clk_put(sdhci->clk);
+err_clk_get:
+        kfree(sdhci);
+err_kzalloc:
+        release_mem_region(iomem->start, resource_size(iomem));
+err:
+        dev_err(&pdev->dev, "spear-sdhci probe failed: %d\n", ret);
+        return ret;
+}
+
+static int __devexit sdhci_remove(struct platform_device *pdev)
+{
+        struct sdhci_host *host = platform_get_drvdata(pdev);
+        struct resource *iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        struct spear_sdhci *sdhci = dev_get_platdata(&pdev->dev);
+        int dead;
+        u32 scratch;
+
+        if (sdhci->data) {
+                if (sdhci->data->card_int_gpio >= 0) {
+                        free_irq(gpio_to_irq(sdhci->data->card_int_gpio), pdev);
+                        gpio_free(sdhci->data->card_int_gpio);
+                }
+
+                if (sdhci->data->card_power_gpio >= 0)
+                        gpio_free(sdhci->data->card_power_gpio);
+        }
+
+        platform_set_drvdata(pdev, NULL);
+        dead = 0;
+        scratch = readl(host->ioaddr + SDHCI_INT_STATUS);
+        if (scratch == (u32)-1)
+                dead = 1;
+
+        sdhci_remove_host(host, dead);
+        iounmap(host->ioaddr);
+        sdhci_free_host(host);
+        clk_disable(sdhci->clk);
+        clk_put(sdhci->clk);
+        kfree(sdhci);
+        if (iomem)
+                release_mem_region(iomem->start, resource_size(iomem));
+
+        return 0;
+}
+
+static struct platform_driver sdhci_driver = {
+        .driver = {
+                .name   = "sdhci",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = sdhci_probe,
+        .remove         = __devexit_p(sdhci_remove),
+};
+
+static int __init sdhci_init(void)
+{
+        return platform_driver_register(&sdhci_driver);
+}
+module_init(sdhci_init);
+
+static void __exit sdhci_exit(void)
+{
+        platform_driver_unregister(&sdhci_driver);
+}
+module_exit(sdhci_exit);
+
+MODULE_DESCRIPTION("SPEAr Secure Digital Host Controller Interface driver");
+MODULE_AUTHOR("Viresh Kumar <viresh.kumar@st.com>");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
index 9d4fdfa685e5..c6d1bd8d4ac4 100644
--- a/drivers/mmc/host/sdhci.c
+++ b/drivers/mmc/host/sdhci.c
@@ -496,12 +496,22 @@ static int sdhci_adma_table_pre(struct sdhci_host *host,
                 WARN_ON((desc - host->adma_desc) > (128 * 2 + 1) * 4);
         }
 
-        /*
-         * Add a terminating entry.
-         */
+        if (host->quirks & SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC) {
+                /*
+                * Mark the last descriptor as the terminating descriptor
+                */
+                if (desc != host->adma_desc) {
+                        desc -= 8;
+                        desc[0] |= 0x2; /* end */
+                }
+        } else {
+                /*
+                * Add a terminating entry.
+                */
 
-        /* nop, end, valid */
-        sdhci_set_adma_desc(desc, 0, 0, 0x3);
+                /* nop, end, valid */
+                sdhci_set_adma_desc(desc, 0, 0, 0x3);
+        }
 
         /*
          * Resync align buffer as we might have changed it.
@@ -1587,7 +1597,7 @@ int sdhci_suspend_host(struct sdhci_host *host, pm_message_t state)
 
         sdhci_disable_card_detection(host);
 
-        ret = mmc_suspend_host(host->mmc, state);
+        ret = mmc_suspend_host(host->mmc);
         if (ret)
                 return ret;
 
@@ -1744,7 +1754,8 @@ int sdhci_add_host(struct sdhci_host *host)
         host->max_clk =
                 (caps & SDHCI_CLOCK_BASE_MASK) >> SDHCI_CLOCK_BASE_SHIFT;
         host->max_clk *= 1000000;
-        if (host->max_clk == 0) {
+        if (host->max_clk == 0 || host->quirks &
+                        SDHCI_QUIRK_CAP_CLOCK_BASE_BROKEN) {
                 if (!host->ops->get_max_clock) {
                         printk(KERN_ERR
                                "%s: Hardware doesn't specify base clock "
diff --git a/drivers/mmc/host/sdhci.h b/drivers/mmc/host/sdhci.h
index 842f46f94284..c8468134adc9 100644
--- a/drivers/mmc/host/sdhci.h
+++ b/drivers/mmc/host/sdhci.h
@@ -127,7 +127,7 @@
 #define  SDHCI_INT_DATA_MASK    (SDHCI_INT_DATA_END | SDHCI_INT_DMA_END | \
                 SDHCI_INT_DATA_AVAIL | SDHCI_INT_SPACE_AVAIL | \
                 SDHCI_INT_DATA_TIMEOUT | SDHCI_INT_DATA_CRC | \
-                SDHCI_INT_DATA_END_BIT | SDHCI_ADMA_ERROR)
+                SDHCI_INT_DATA_END_BIT | SDHCI_INT_ADMA_ERROR)
 #define SDHCI_INT_ALL_MASK      ((unsigned int)-1)
 
 #define SDHCI_ACMD12_ERR        0x3C
@@ -236,6 +236,10 @@ struct sdhci_host {
 #define SDHCI_QUIRK_DELAY_AFTER_POWER                   (1<<23)
 /* Controller uses SDCLK instead of TMCLK for data timeouts */
 #define SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK             (1<<24)
+/* Controller reports wrong base clock capability */
+#define SDHCI_QUIRK_CAP_CLOCK_BASE_BROKEN               (1<<25)
+/* Controller cannot support End Attribute in NOP ADMA descriptor */
+#define SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC               (1<<26)
 
         int                     irq;            /* Device IRQ */
         void __iomem *          ioaddr;         /* Mapped address */
@@ -294,12 +298,12 @@ struct sdhci_host {
 
 struct sdhci_ops {
 #ifdef CONFIG_MMC_SDHCI_IO_ACCESSORS
-        u32             (*readl)(struct sdhci_host *host, int reg);
-        u16             (*readw)(struct sdhci_host *host, int reg);
-        u8              (*readb)(struct sdhci_host *host, int reg);
-        void            (*writel)(struct sdhci_host *host, u32 val, int reg);
-        void            (*writew)(struct sdhci_host *host, u16 val, int reg);
-        void            (*writeb)(struct sdhci_host *host, u8 val, int reg);
+        u32             (*read_l)(struct sdhci_host *host, int reg);
+        u16             (*read_w)(struct sdhci_host *host, int reg);
+        u8              (*read_b)(struct sdhci_host *host, int reg);
+        void            (*write_l)(struct sdhci_host *host, u32 val, int reg);
+        void            (*write_w)(struct sdhci_host *host, u16 val, int reg);
+        void            (*write_b)(struct sdhci_host *host, u8 val, int reg);
 #endif
 
         void    (*set_clock)(struct sdhci_host *host, unsigned int clock);
@@ -314,48 +318,48 @@ struct sdhci_ops {
 
 static inline void sdhci_writel(struct sdhci_host *host, u32 val, int reg)
 {
-        if (unlikely(host->ops->writel))
-                host->ops->writel(host, val, reg);
+        if (unlikely(host->ops->write_l))
+                host->ops->write_l(host, val, reg);
         else
                 writel(val, host->ioaddr + reg);
 }
 
 static inline void sdhci_writew(struct sdhci_host *host, u16 val, int reg)
 {
-        if (unlikely(host->ops->writew))
-                host->ops->writew(host, val, reg);
+        if (unlikely(host->ops->write_w))
+                host->ops->write_w(host, val, reg);
         else
                 writew(val, host->ioaddr + reg);
 }
 
 static inline void sdhci_writeb(struct sdhci_host *host, u8 val, int reg)
 {
-        if (unlikely(host->ops->writeb))
-                host->ops->writeb(host, val, reg);
+        if (unlikely(host->ops->write_b))
+                host->ops->write_b(host, val, reg);
         else
                 writeb(val, host->ioaddr + reg);
 }
 
 static inline u32 sdhci_readl(struct sdhci_host *host, int reg)
 {
-        if (unlikely(host->ops->readl))
-                return host->ops->readl(host, reg);
+        if (unlikely(host->ops->read_l))
+                return host->ops->read_l(host, reg);
         else
                 return readl(host->ioaddr + reg);
 }
 
 static inline u16 sdhci_readw(struct sdhci_host *host, int reg)
 {
-        if (unlikely(host->ops->readw))
-                return host->ops->readw(host, reg);
+        if (unlikely(host->ops->read_w))
+                return host->ops->read_w(host, reg);
         else
                 return readw(host->ioaddr + reg);
 }
 
 static inline u8 sdhci_readb(struct sdhci_host *host, int reg)
 {
-        if (unlikely(host->ops->readb))
-                return host->ops->readb(host, reg);
+        if (unlikely(host->ops->read_b))
+                return host->ops->read_b(host, reg);
         else
                 return readb(host->ioaddr + reg);
 }
diff --git a/drivers/mmc/host/sdricoh_cs.c b/drivers/mmc/host/sdricoh_cs.c
index cb41e9c3ac07..e7507af3856e 100644
--- a/drivers/mmc/host/sdricoh_cs.c
+++ b/drivers/mmc/host/sdricoh_cs.c
@@ -519,7 +519,7 @@ static int sdricoh_pcmcia_suspend(struct pcmcia_device *link)
 {
         struct mmc_host *mmc = link->priv;
         dev_dbg(&link->dev, "suspend\n");
-        mmc_suspend_host(mmc, PMSG_SUSPEND);
+        mmc_suspend_host(mmc);
         return 0;
 }
 
diff --git a/drivers/mmc/host/sh_mmcif.c b/drivers/mmc/host/sh_mmcif.c
new file mode 100644
index 000000000000..eb97830c0344
--- /dev/null
+++ b/drivers/mmc/host/sh_mmcif.c
@@ -0,0 +1,965 @@
+/*
+ * MMCIF eMMC driver.
+ *
+ * Copyright (C) 2010 Renesas Solutions Corp.
+ * Yusuke Goda <yusuke.goda.sx@renesas.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.
+ *
+ *
+ * TODO
+ *  1. DMA
+ *  2. Power management
+ *  3. Handle MMC errors better
+ *
+ */
+
+#include <linux/dma-mapping.h>
+#include <linux/mmc/host.h>
+#include <linux/mmc/card.h>
+#include <linux/mmc/core.h>
+#include <linux/mmc/mmc.h>
+#include <linux/mmc/sdio.h>
+#include <linux/delay.h>
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+#include <linux/mmc/sh_mmcif.h>
+
+#define DRIVER_NAME     "sh_mmcif"
+#define DRIVER_VERSION  "2010-04-28"
+
+#define MMCIF_CE_CMD_SET        0x00000000
+#define MMCIF_CE_ARG            0x00000008
+#define MMCIF_CE_ARG_CMD12      0x0000000C
+#define MMCIF_CE_CMD_CTRL       0x00000010
+#define MMCIF_CE_BLOCK_SET      0x00000014
+#define MMCIF_CE_CLK_CTRL       0x00000018
+#define MMCIF_CE_BUF_ACC        0x0000001C
+#define MMCIF_CE_RESP3          0x00000020
+#define MMCIF_CE_RESP2          0x00000024
+#define MMCIF_CE_RESP1          0x00000028
+#define MMCIF_CE_RESP0          0x0000002C
+#define MMCIF_CE_RESP_CMD12     0x00000030
+#define MMCIF_CE_DATA           0x00000034
+#define MMCIF_CE_INT            0x00000040
+#define MMCIF_CE_INT_MASK       0x00000044
+#define MMCIF_CE_HOST_STS1      0x00000048
+#define MMCIF_CE_HOST_STS2      0x0000004C
+#define MMCIF_CE_VERSION        0x0000007C
+
+/* CE_CMD_SET */
+#define CMD_MASK                0x3f000000
+#define CMD_SET_RTYP_NO         ((0 << 23) | (0 << 22))
+#define CMD_SET_RTYP_6B         ((0 << 23) | (1 << 22)) /* R1/R1b/R3/R4/R5 */
+#define CMD_SET_RTYP_17B        ((1 << 23) | (0 << 22)) /* R2 */
+#define CMD_SET_RBSY            (1 << 21) /* R1b */
+#define CMD_SET_CCSEN           (1 << 20)
+#define CMD_SET_WDAT            (1 << 19) /* 1: on data, 0: no data */
+#define CMD_SET_DWEN            (1 << 18) /* 1: write, 0: read */
+#define CMD_SET_CMLTE           (1 << 17) /* 1: multi block trans, 0: single */
+#define CMD_SET_CMD12EN         (1 << 16) /* 1: CMD12 auto issue */
+#define CMD_SET_RIDXC_INDEX     ((0 << 15) | (0 << 14)) /* index check */
+#define CMD_SET_RIDXC_BITS      ((0 << 15) | (1 << 14)) /* check bits check */
+#define CMD_SET_RIDXC_NO        ((1 << 15) | (0 << 14)) /* no check */
+#define CMD_SET_CRC7C           ((0 << 13) | (0 << 12)) /* CRC7 check*/
+#define CMD_SET_CRC7C_BITS      ((0 << 13) | (1 << 12)) /* check bits check*/
+#define CMD_SET_CRC7C_INTERNAL  ((1 << 13) | (0 << 12)) /* internal CRC7 check*/
+#define CMD_SET_CRC16C          (1 << 10) /* 0: CRC16 check*/
+#define CMD_SET_CRCSTE          (1 << 8) /* 1: not receive CRC status */
+#define CMD_SET_TBIT            (1 << 7) /* 1: tran mission bit "Low" */
+#define CMD_SET_OPDM            (1 << 6) /* 1: open/drain */
+#define CMD_SET_CCSH            (1 << 5)
+#define CMD_SET_DATW_1          ((0 << 1) | (0 << 0)) /* 1bit */
+#define CMD_SET_DATW_4          ((0 << 1) | (1 << 0)) /* 4bit */
+#define CMD_SET_DATW_8          ((1 << 1) | (0 << 0)) /* 8bit */
+
+/* CE_CMD_CTRL */
+#define CMD_CTRL_BREAK          (1 << 0)
+
+/* CE_BLOCK_SET */
+#define BLOCK_SIZE_MASK         0x0000ffff
+
+/* CE_CLK_CTRL */
+#define CLK_ENABLE              (1 << 24) /* 1: output mmc clock */
+#define CLK_CLEAR               ((1 << 19) | (1 << 18) | (1 << 17) | (1 << 16))
+#define CLK_SUP_PCLK            ((1 << 19) | (1 << 18) | (1 << 17) | (1 << 16))
+#define SRSPTO_256              ((1 << 13) | (0 << 12)) /* resp timeout */
+#define SRBSYTO_29              ((1 << 11) | (1 << 10) |        \
+                                 (1 << 9) | (1 << 8)) /* resp busy timeout */
+#define SRWDTO_29               ((1 << 7) | (1 << 6) |          \
+                                 (1 << 5) | (1 << 4)) /* read/write timeout */
+#define SCCSTO_29               ((1 << 3) | (1 << 2) |          \
+                                 (1 << 1) | (1 << 0)) /* ccs timeout */
+
+/* CE_BUF_ACC */
+#define BUF_ACC_DMAWEN          (1 << 25)
+#define BUF_ACC_DMAREN          (1 << 24)
+#define BUF_ACC_BUSW_32         (0 << 17)
+#define BUF_ACC_BUSW_16         (1 << 17)
+#define BUF_ACC_ATYP            (1 << 16)
+
+/* CE_INT */
+#define INT_CCSDE               (1 << 29)
+#define INT_CMD12DRE            (1 << 26)
+#define INT_CMD12RBE            (1 << 25)
+#define INT_CMD12CRE            (1 << 24)
+#define INT_DTRANE              (1 << 23)
+#define INT_BUFRE               (1 << 22)
+#define INT_BUFWEN              (1 << 21)
+#define INT_BUFREN              (1 << 20)
+#define INT_CCSRCV              (1 << 19)
+#define INT_RBSYE               (1 << 17)
+#define INT_CRSPE               (1 << 16)
+#define INT_CMDVIO              (1 << 15)
+#define INT_BUFVIO              (1 << 14)
+#define INT_WDATERR             (1 << 11)
+#define INT_RDATERR             (1 << 10)
+#define INT_RIDXERR             (1 << 9)
+#define INT_RSPERR              (1 << 8)
+#define INT_CCSTO               (1 << 5)
+#define INT_CRCSTO              (1 << 4)
+#define INT_WDATTO              (1 << 3)
+#define INT_RDATTO              (1 << 2)
+#define INT_RBSYTO              (1 << 1)
+#define INT_RSPTO               (1 << 0)
+#define INT_ERR_STS             (INT_CMDVIO | INT_BUFVIO | INT_WDATERR |  \
+                                 INT_RDATERR | INT_RIDXERR | INT_RSPERR | \
+                                 INT_CCSTO | INT_CRCSTO | INT_WDATTO |    \
+                                 INT_RDATTO | INT_RBSYTO | INT_RSPTO)
+
+/* CE_INT_MASK */
+#define MASK_ALL                0x00000000
+#define MASK_MCCSDE             (1 << 29)
+#define MASK_MCMD12DRE          (1 << 26)
+#define MASK_MCMD12RBE          (1 << 25)
+#define MASK_MCMD12CRE          (1 << 24)
+#define MASK_MDTRANE            (1 << 23)
+#define MASK_MBUFRE             (1 << 22)
+#define MASK_MBUFWEN            (1 << 21)
+#define MASK_MBUFREN            (1 << 20)
+#define MASK_MCCSRCV            (1 << 19)
+#define MASK_MRBSYE             (1 << 17)
+#define MASK_MCRSPE             (1 << 16)
+#define MASK_MCMDVIO            (1 << 15)
+#define MASK_MBUFVIO            (1 << 14)
+#define MASK_MWDATERR           (1 << 11)
+#define MASK_MRDATERR           (1 << 10)
+#define MASK_MRIDXERR           (1 << 9)
+#define MASK_MRSPERR            (1 << 8)
+#define MASK_MCCSTO             (1 << 5)
+#define MASK_MCRCSTO            (1 << 4)
+#define MASK_MWDATTO            (1 << 3)
+#define MASK_MRDATTO            (1 << 2)
+#define MASK_MRBSYTO            (1 << 1)
+#define MASK_MRSPTO             (1 << 0)
+
+/* CE_HOST_STS1 */
+#define STS1_CMDSEQ             (1 << 31)
+
+/* CE_HOST_STS2 */
+#define STS2_CRCSTE             (1 << 31)
+#define STS2_CRC16E             (1 << 30)
+#define STS2_AC12CRCE           (1 << 29)
+#define STS2_RSPCRC7E           (1 << 28)
+#define STS2_CRCSTEBE           (1 << 27)
+#define STS2_RDATEBE            (1 << 26)
+#define STS2_AC12REBE           (1 << 25)
+#define STS2_RSPEBE             (1 << 24)
+#define STS2_AC12IDXE           (1 << 23)
+#define STS2_RSPIDXE            (1 << 22)
+#define STS2_CCSTO              (1 << 15)
+#define STS2_RDATTO             (1 << 14)
+#define STS2_DATBSYTO           (1 << 13)
+#define STS2_CRCSTTO            (1 << 12)
+#define STS2_AC12BSYTO          (1 << 11)
+#define STS2_RSPBSYTO           (1 << 10)
+#define STS2_AC12RSPTO          (1 << 9)
+#define STS2_RSPTO              (1 << 8)
+#define STS2_CRC_ERR            (STS2_CRCSTE | STS2_CRC16E |            \
+                                 STS2_AC12CRCE | STS2_RSPCRC7E | STS2_CRCSTEBE)
+#define STS2_TIMEOUT_ERR        (STS2_CCSTO | STS2_RDATTO |             \
+                                 STS2_DATBSYTO | STS2_CRCSTTO |         \
+                                 STS2_AC12BSYTO | STS2_RSPBSYTO |       \
+                                 STS2_AC12RSPTO | STS2_RSPTO)
+
+/* CE_VERSION */
+#define SOFT_RST_ON             (1 << 31)
+#define SOFT_RST_OFF            (0 << 31)
+
+#define CLKDEV_EMMC_DATA        52000000 /* 52MHz */
+#define CLKDEV_MMC_DATA         20000000 /* 20MHz */
+#define CLKDEV_INIT             400000   /* 400 KHz */
+
+struct sh_mmcif_host {
+        struct mmc_host *mmc;
+        struct mmc_data *data;
+        struct mmc_command *cmd;
+        struct platform_device *pd;
+        struct clk *hclk;
+        unsigned int clk;
+        int bus_width;
+        u16 wait_int;
+        u16 sd_error;
+        long timeout;
+        void __iomem *addr;
+        wait_queue_head_t intr_wait;
+};
+
+static inline u32 sh_mmcif_readl(struct sh_mmcif_host *host, unsigned int reg)
+{
+        return readl(host->addr + reg);
+}
+
+static inline void sh_mmcif_writel(struct sh_mmcif_host *host,
+                                        unsigned int reg, u32 val)
+{
+        writel(val, host->addr + reg);
+}
+
+static inline void sh_mmcif_bitset(struct sh_mmcif_host *host,
+                                        unsigned int reg, u32 val)
+{
+        writel(val | sh_mmcif_readl(host, reg), host->addr + reg);
+}
+
+static inline void sh_mmcif_bitclr(struct sh_mmcif_host *host,
+                                        unsigned int reg, u32 val)
+{
+        writel(~val & sh_mmcif_readl(host, reg), host->addr + reg);
+}
+
+
+static void sh_mmcif_clock_control(struct sh_mmcif_host *host, unsigned int clk)
+{
+        struct sh_mmcif_plat_data *p = host->pd->dev.platform_data;
+
+        sh_mmcif_bitclr(host, MMCIF_CE_CLK_CTRL, CLK_ENABLE);
+        sh_mmcif_bitclr(host, MMCIF_CE_CLK_CTRL, CLK_CLEAR);
+
+        if (!clk)
+                return;
+        if (p->sup_pclk && clk == host->clk)
+                sh_mmcif_bitset(host, MMCIF_CE_CLK_CTRL, CLK_SUP_PCLK);
+        else
+                sh_mmcif_bitset(host, MMCIF_CE_CLK_CTRL, CLK_CLEAR &
+                        (ilog2(__rounddown_pow_of_two(host->clk / clk)) << 16));
+
+        sh_mmcif_bitset(host, MMCIF_CE_CLK_CTRL, CLK_ENABLE);
+}
+
+static void sh_mmcif_sync_reset(struct sh_mmcif_host *host)
+{
+        u32 tmp;
+
+        tmp = 0x010f0000 & sh_mmcif_readl(host, MMCIF_CE_CLK_CTRL);
+
+        sh_mmcif_writel(host, MMCIF_CE_VERSION, SOFT_RST_ON);
+        sh_mmcif_writel(host, MMCIF_CE_VERSION, SOFT_RST_OFF);
+        sh_mmcif_bitset(host, MMCIF_CE_CLK_CTRL, tmp |
+                SRSPTO_256 | SRBSYTO_29 | SRWDTO_29 | SCCSTO_29);
+        /* byte swap on */
+        sh_mmcif_bitset(host, MMCIF_CE_BUF_ACC, BUF_ACC_ATYP);
+}
+
+static int sh_mmcif_error_manage(struct sh_mmcif_host *host)
+{
+        u32 state1, state2;
+        int ret, timeout = 10000000;
+
+        host->sd_error = 0;
+        host->wait_int = 0;
+
+        state1 = sh_mmcif_readl(host, MMCIF_CE_HOST_STS1);
+        state2 = sh_mmcif_readl(host, MMCIF_CE_HOST_STS2);
+        pr_debug("%s: ERR HOST_STS1 = %08x\n", \
+                        DRIVER_NAME, sh_mmcif_readl(host, MMCIF_CE_HOST_STS1));
+        pr_debug("%s: ERR HOST_STS2 = %08x\n", \
+                        DRIVER_NAME, sh_mmcif_readl(host, MMCIF_CE_HOST_STS2));
+
+        if (state1 & STS1_CMDSEQ) {
+                sh_mmcif_bitset(host, MMCIF_CE_CMD_CTRL, CMD_CTRL_BREAK);
+                sh_mmcif_bitset(host, MMCIF_CE_CMD_CTRL, ~CMD_CTRL_BREAK);
+                while (1) {
+                        timeout--;
+                        if (timeout < 0) {
+                                pr_err(DRIVER_NAME": Forceed end of " \
+                                        "command sequence timeout err\n");
+                                return -EIO;
+                        }
+                        if (!(sh_mmcif_readl(host, MMCIF_CE_HOST_STS1)
+                                                                & STS1_CMDSEQ))
+                                break;
+                        mdelay(1);
+                }
+                sh_mmcif_sync_reset(host);
+                pr_debug(DRIVER_NAME": Forced end of command sequence\n");
+                return -EIO;
+        }
+
+        if (state2 & STS2_CRC_ERR) {
+                pr_debug(DRIVER_NAME": Happened CRC error\n");
+                ret = -EIO;
+        } else if (state2 & STS2_TIMEOUT_ERR) {
+                pr_debug(DRIVER_NAME": Happened Timeout error\n");
+                ret = -ETIMEDOUT;
+        } else {
+                pr_debug(DRIVER_NAME": Happened End/Index error\n");
+                ret = -EIO;
+        }
+        return ret;
+}
+
+static int sh_mmcif_single_read(struct sh_mmcif_host *host,
+                                        struct mmc_request *mrq)
+{
+        struct mmc_data *data = mrq->data;
+        long time;
+        u32 blocksize, i, *p = sg_virt(data->sg);
+
+        host->wait_int = 0;
+
+        /* buf read enable */
+        sh_mmcif_bitset(host, MMCIF_CE_INT_MASK, MASK_MBUFREN);
+        time = wait_event_interruptible_timeout(host->intr_wait,
+                        host->wait_int == 1 ||
+                        host->sd_error == 1, host->timeout);
+        if (host->wait_int != 1 && (time == 0 || host->sd_error != 0))
+                return sh_mmcif_error_manage(host);
+
+        host->wait_int = 0;
+        blocksize = (BLOCK_SIZE_MASK &
+                        sh_mmcif_readl(host, MMCIF_CE_BLOCK_SET)) + 3;
+        for (i = 0; i < blocksize / 4; i++)
+                *p++ = sh_mmcif_readl(host, MMCIF_CE_DATA);
+
+        /* buffer read end */
+        sh_mmcif_bitset(host, MMCIF_CE_INT_MASK, MASK_MBUFRE);
+        time = wait_event_interruptible_timeout(host->intr_wait,
+                        host->wait_int == 1 ||
+                        host->sd_error == 1, host->timeout);
+        if (host->wait_int != 1 && (time == 0 || host->sd_error != 0))
+                return sh_mmcif_error_manage(host);
+
+        host->wait_int = 0;
+        return 0;
+}
+
+static int sh_mmcif_multi_read(struct sh_mmcif_host *host,
+                                        struct mmc_request *mrq)
+{
+        struct mmc_data *data = mrq->data;
+        long time;
+        u32 blocksize, i, j, sec, *p;
+
+        blocksize = BLOCK_SIZE_MASK & sh_mmcif_readl(host, MMCIF_CE_BLOCK_SET);
+        for (j = 0; j < data->sg_len; j++) {
+                p = sg_virt(data->sg);
+                host->wait_int = 0;
+                for (sec = 0; sec < data->sg->length / blocksize; sec++) {
+                        sh_mmcif_bitset(host, MMCIF_CE_INT_MASK, MASK_MBUFREN);
+                        /* buf read enable */
+                        time = wait_event_interruptible_timeout(host->intr_wait,
+                                host->wait_int == 1 ||
+                                host->sd_error == 1, host->timeout);
+
+                        if (host->wait_int != 1 &&
+                            (time == 0 || host->sd_error != 0))
+                                return sh_mmcif_error_manage(host);
+
+                        host->wait_int = 0;
+                        for (i = 0; i < blocksize / 4; i++)
+                                *p++ = sh_mmcif_readl(host, MMCIF_CE_DATA);
+                }
+                if (j < data->sg_len - 1)
+                        data->sg++;
+        }
+        return 0;
+}
+
+static int sh_mmcif_single_write(struct sh_mmcif_host *host,
+                                        struct mmc_request *mrq)
+{
+        struct mmc_data *data = mrq->data;
+        long time;
+        u32 blocksize, i, *p = sg_virt(data->sg);
+
+        host->wait_int = 0;
+        sh_mmcif_bitset(host, MMCIF_CE_INT_MASK, MASK_MBUFWEN);
+
+        /* buf write enable */
+        time = wait_event_interruptible_timeout(host->intr_wait,
+                        host->wait_int == 1 ||
+                        host->sd_error == 1, host->timeout);
+        if (host->wait_int != 1 && (time == 0 || host->sd_error != 0))
+                return sh_mmcif_error_manage(host);
+
+        host->wait_int = 0;
+        blocksize = (BLOCK_SIZE_MASK &
+                        sh_mmcif_readl(host, MMCIF_CE_BLOCK_SET)) + 3;
+        for (i = 0; i < blocksize / 4; i++)
+                sh_mmcif_writel(host, MMCIF_CE_DATA, *p++);
+
+        /* buffer write end */
+        sh_mmcif_bitset(host, MMCIF_CE_INT_MASK, MASK_MDTRANE);
+
+        time = wait_event_interruptible_timeout(host->intr_wait,
+                        host->wait_int == 1 ||
+                        host->sd_error == 1, host->timeout);
+        if (host->wait_int != 1 && (time == 0 || host->sd_error != 0))
+                return sh_mmcif_error_manage(host);
+
+        host->wait_int = 0;
+        return 0;
+}
+
+static int sh_mmcif_multi_write(struct sh_mmcif_host *host,
+                                                struct mmc_request *mrq)
+{
+        struct mmc_data *data = mrq->data;
+        long time;
+        u32 i, sec, j, blocksize, *p;
+
+        blocksize = BLOCK_SIZE_MASK & sh_mmcif_readl(host, MMCIF_CE_BLOCK_SET);
+
+        for (j = 0; j < data->sg_len; j++) {
+                p = sg_virt(data->sg);
+                host->wait_int = 0;
+                for (sec = 0; sec < data->sg->length / blocksize; sec++) {
+                        sh_mmcif_bitset(host, MMCIF_CE_INT_MASK, MASK_MBUFWEN);
+                        /* buf write enable*/
+                        time = wait_event_interruptible_timeout(host->intr_wait,
+                                host->wait_int == 1 ||
+                                host->sd_error == 1, host->timeout);
+
+                        if (host->wait_int != 1 &&
+                            (time == 0 || host->sd_error != 0))
+                                return sh_mmcif_error_manage(host);
+
+                        host->wait_int = 0;
+                        for (i = 0; i < blocksize / 4; i++)
+                                sh_mmcif_writel(host, MMCIF_CE_DATA, *p++);
+                }
+                if (j < data->sg_len - 1)
+                        data->sg++;
+        }
+        return 0;
+}
+
+static void sh_mmcif_get_response(struct sh_mmcif_host *host,
+                                                struct mmc_command *cmd)
+{
+        if (cmd->flags & MMC_RSP_136) {
+                cmd->resp[0] = sh_mmcif_readl(host, MMCIF_CE_RESP3);
+                cmd->resp[1] = sh_mmcif_readl(host, MMCIF_CE_RESP2);
+                cmd->resp[2] = sh_mmcif_readl(host, MMCIF_CE_RESP1);
+                cmd->resp[3] = sh_mmcif_readl(host, MMCIF_CE_RESP0);
+        } else
+                cmd->resp[0] = sh_mmcif_readl(host, MMCIF_CE_RESP0);
+}
+
+static void sh_mmcif_get_cmd12response(struct sh_mmcif_host *host,
+                                                struct mmc_command *cmd)
+{
+        cmd->resp[0] = sh_mmcif_readl(host, MMCIF_CE_RESP_CMD12);
+}
+
+static u32 sh_mmcif_set_cmd(struct sh_mmcif_host *host,
+                struct mmc_request *mrq, struct mmc_command *cmd, u32 opc)
+{
+        u32 tmp = 0;
+
+        /* Response Type check */
+        switch (mmc_resp_type(cmd)) {
+        case MMC_RSP_NONE:
+                tmp |= CMD_SET_RTYP_NO;
+                break;
+        case MMC_RSP_R1:
+        case MMC_RSP_R1B:
+        case MMC_RSP_R3:
+                tmp |= CMD_SET_RTYP_6B;
+                break;
+        case MMC_RSP_R2:
+                tmp |= CMD_SET_RTYP_17B;
+                break;
+        default:
+                pr_err(DRIVER_NAME": Not support type response.\n");
+                break;
+        }
+        switch (opc) {
+        /* RBSY */
+        case MMC_SWITCH:
+        case MMC_STOP_TRANSMISSION:
+        case MMC_SET_WRITE_PROT:
+        case MMC_CLR_WRITE_PROT:
+        case MMC_ERASE:
+        case MMC_GEN_CMD:
+                tmp |= CMD_SET_RBSY;
+                break;
+        }
+        /* WDAT / DATW */
+        if (host->data) {
+                tmp |= CMD_SET_WDAT;
+                switch (host->bus_width) {
+                case MMC_BUS_WIDTH_1:
+                        tmp |= CMD_SET_DATW_1;
+                        break;
+                case MMC_BUS_WIDTH_4:
+                        tmp |= CMD_SET_DATW_4;
+                        break;
+                case MMC_BUS_WIDTH_8:
+                        tmp |= CMD_SET_DATW_8;
+                        break;
+                default:
+                        pr_err(DRIVER_NAME": Not support bus width.\n");
+                        break;
+                }
+        }
+        /* DWEN */
+        if (opc == MMC_WRITE_BLOCK || opc == MMC_WRITE_MULTIPLE_BLOCK)
+                tmp |= CMD_SET_DWEN;
+        /* CMLTE/CMD12EN */
+        if (opc == MMC_READ_MULTIPLE_BLOCK || opc == MMC_WRITE_MULTIPLE_BLOCK) {
+                tmp |= CMD_SET_CMLTE | CMD_SET_CMD12EN;
+                sh_mmcif_bitset(host, MMCIF_CE_BLOCK_SET,
+                                        mrq->data->blocks << 16);
+        }
+        /* RIDXC[1:0] check bits */
+        if (opc == MMC_SEND_OP_COND || opc == MMC_ALL_SEND_CID ||
+            opc == MMC_SEND_CSD || opc == MMC_SEND_CID)
+                tmp |= CMD_SET_RIDXC_BITS;
+        /* RCRC7C[1:0] check bits */
+        if (opc == MMC_SEND_OP_COND)
+                tmp |= CMD_SET_CRC7C_BITS;
+        /* RCRC7C[1:0] internal CRC7 */
+        if (opc == MMC_ALL_SEND_CID ||
+                opc == MMC_SEND_CSD || opc == MMC_SEND_CID)
+                tmp |= CMD_SET_CRC7C_INTERNAL;
+
+        return opc = ((opc << 24) | tmp);
+}
+
+static u32 sh_mmcif_data_trans(struct sh_mmcif_host *host,
+                                struct mmc_request *mrq, u32 opc)
+{
+        u32 ret;
+
+        switch (opc) {
+        case MMC_READ_MULTIPLE_BLOCK:
+                ret = sh_mmcif_multi_read(host, mrq);
+                break;
+        case MMC_WRITE_MULTIPLE_BLOCK:
+                ret = sh_mmcif_multi_write(host, mrq);
+                break;
+        case MMC_WRITE_BLOCK:
+                ret = sh_mmcif_single_write(host, mrq);
+                break;
+        case MMC_READ_SINGLE_BLOCK:
+        case MMC_SEND_EXT_CSD:
+                ret = sh_mmcif_single_read(host, mrq);
+                break;
+        default:
+                pr_err(DRIVER_NAME": NOT SUPPORT CMD = d'%08d\n", opc);
+                ret = -EINVAL;
+                break;
+        }
+        return ret;
+}
+
+static void sh_mmcif_start_cmd(struct sh_mmcif_host *host,
+                        struct mmc_request *mrq, struct mmc_command *cmd)
+{
+        long time;
+        int ret = 0, mask = 0;
+        u32 opc = cmd->opcode;
+
+        host->cmd = cmd;
+
+        switch (opc) {
+        /* respons busy check */
+        case MMC_SWITCH:
+        case MMC_STOP_TRANSMISSION:
+        case MMC_SET_WRITE_PROT:
+        case MMC_CLR_WRITE_PROT:
+        case MMC_ERASE:
+        case MMC_GEN_CMD:
+                mask = MASK_MRBSYE;
+                break;
+        default:
+                mask = MASK_MCRSPE;
+                break;
+        }
+        mask |= MASK_MCMDVIO | MASK_MBUFVIO | MASK_MWDATERR |
+                MASK_MRDATERR | MASK_MRIDXERR | MASK_MRSPERR |
+                MASK_MCCSTO | MASK_MCRCSTO | MASK_MWDATTO |
+                MASK_MRDATTO | MASK_MRBSYTO | MASK_MRSPTO;
+
+        if (host->data) {
+                sh_mmcif_writel(host, MMCIF_CE_BLOCK_SET, 0);
+                sh_mmcif_writel(host, MMCIF_CE_BLOCK_SET, mrq->data->blksz);
+        }
+        opc = sh_mmcif_set_cmd(host, mrq, cmd, opc);
+
+        sh_mmcif_writel(host, MMCIF_CE_INT, 0xD80430C0);
+        sh_mmcif_writel(host, MMCIF_CE_INT_MASK, mask);
+        /* set arg */
+        sh_mmcif_writel(host, MMCIF_CE_ARG, cmd->arg);
+        host->wait_int = 0;
+        /* set cmd */
+        sh_mmcif_writel(host, MMCIF_CE_CMD_SET, opc);
+
+        time = wait_event_interruptible_timeout(host->intr_wait,
+                host->wait_int == 1 || host->sd_error == 1, host->timeout);
+        if (host->wait_int != 1 && time == 0) {
+                cmd->error = sh_mmcif_error_manage(host);
+                return;
+        }
+        if (host->sd_error) {
+                switch (cmd->opcode) {
+                case MMC_ALL_SEND_CID:
+                case MMC_SELECT_CARD:
+                case MMC_APP_CMD:
+                        cmd->error = -ETIMEDOUT;
+                        break;
+                default:
+                        pr_debug("%s: Cmd(d'%d) err\n",
+                                        DRIVER_NAME, cmd->opcode);
+                        cmd->error = sh_mmcif_error_manage(host);
+                        break;
+                }
+                host->sd_error = 0;
+                host->wait_int = 0;
+                return;
+        }
+        if (!(cmd->flags & MMC_RSP_PRESENT)) {
+                cmd->error = ret;
+                host->wait_int = 0;
+                return;
+        }
+        if (host->wait_int == 1) {
+                sh_mmcif_get_response(host, cmd);
+                host->wait_int = 0;
+        }
+        if (host->data) {
+                ret = sh_mmcif_data_trans(host, mrq, cmd->opcode);
+                if (ret < 0)
+                        mrq->data->bytes_xfered = 0;
+                else
+                        mrq->data->bytes_xfered =
+                                mrq->data->blocks * mrq->data->blksz;
+        }
+        cmd->error = ret;
+}
+
+static void sh_mmcif_stop_cmd(struct sh_mmcif_host *host,
+                struct mmc_request *mrq, struct mmc_command *cmd)
+{
+        long time;
+
+        if (mrq->cmd->opcode == MMC_READ_MULTIPLE_BLOCK)
+                sh_mmcif_bitset(host, MMCIF_CE_INT_MASK, MASK_MCMD12DRE);
+        else if (mrq->cmd->opcode == MMC_WRITE_MULTIPLE_BLOCK)
+                sh_mmcif_bitset(host, MMCIF_CE_INT_MASK, MASK_MCMD12RBE);
+        else {
+                pr_err(DRIVER_NAME": not support stop cmd\n");
+                cmd->error = sh_mmcif_error_manage(host);
+                return;
+        }
+
+        time = wait_event_interruptible_timeout(host->intr_wait,
+                        host->wait_int == 1 ||
+                        host->sd_error == 1, host->timeout);
+        if (host->wait_int != 1 && (time == 0 || host->sd_error != 0)) {
+                cmd->error = sh_mmcif_error_manage(host);
+                return;
+        }
+        sh_mmcif_get_cmd12response(host, cmd);
+        host->wait_int = 0;
+        cmd->error = 0;
+}
+
+static void sh_mmcif_request(struct mmc_host *mmc, struct mmc_request *mrq)
+{
+        struct sh_mmcif_host *host = mmc_priv(mmc);
+
+        switch (mrq->cmd->opcode) {
+        /* MMCIF does not support SD/SDIO command */
+        case SD_IO_SEND_OP_COND:
+        case MMC_APP_CMD:
+                mrq->cmd->error = -ETIMEDOUT;
+                mmc_request_done(mmc, mrq);
+                return;
+        case MMC_SEND_EXT_CSD: /* = SD_SEND_IF_COND (8) */
+                if (!mrq->data) {
+                        /* send_if_cond cmd (not support) */
+                        mrq->cmd->error = -ETIMEDOUT;
+                        mmc_request_done(mmc, mrq);
+                        return;
+                }
+                break;
+        default:
+                break;
+        }
+        host->data = mrq->data;
+        sh_mmcif_start_cmd(host, mrq, mrq->cmd);
+        host->data = NULL;
+
+        if (mrq->cmd->error != 0) {
+                mmc_request_done(mmc, mrq);
+                return;
+        }
+        if (mrq->stop)
+                sh_mmcif_stop_cmd(host, mrq, mrq->stop);
+        mmc_request_done(mmc, mrq);
+}
+
+static void sh_mmcif_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
+{
+        struct sh_mmcif_host *host = mmc_priv(mmc);
+        struct sh_mmcif_plat_data *p = host->pd->dev.platform_data;
+
+        if (ios->power_mode == MMC_POWER_OFF) {
+                /* clock stop */
+                sh_mmcif_clock_control(host, 0);
+                if (p->down_pwr)
+                        p->down_pwr(host->pd);
+                return;
+        } else if (ios->power_mode == MMC_POWER_UP) {
+                if (p->set_pwr)
+                        p->set_pwr(host->pd, ios->power_mode);
+        }
+
+        if (ios->clock)
+                sh_mmcif_clock_control(host, ios->clock);
+
+        host->bus_width = ios->bus_width;
+}
+
+static struct mmc_host_ops sh_mmcif_ops = {
+        .request        = sh_mmcif_request,
+        .set_ios        = sh_mmcif_set_ios,
+};
+
+static void sh_mmcif_detect(struct mmc_host *mmc)
+{
+        mmc_detect_change(mmc, 0);
+}
+
+static irqreturn_t sh_mmcif_intr(int irq, void *dev_id)
+{
+        struct sh_mmcif_host *host = dev_id;
+        u32 state = 0;
+        int err = 0;
+
+        state = sh_mmcif_readl(host, MMCIF_CE_INT);
+
+        if (state & INT_RBSYE) {
+                sh_mmcif_writel(host, MMCIF_CE_INT, ~(INT_RBSYE | INT_CRSPE));
+                sh_mmcif_bitclr(host, MMCIF_CE_INT_MASK, MASK_MRBSYE);
+        } else if (state & INT_CRSPE) {
+                sh_mmcif_writel(host, MMCIF_CE_INT, ~INT_CRSPE);
+                sh_mmcif_bitclr(host, MMCIF_CE_INT_MASK, MASK_MCRSPE);
+        } else if (state & INT_BUFREN) {
+                sh_mmcif_writel(host, MMCIF_CE_INT, ~INT_BUFREN);
+                sh_mmcif_bitclr(host, MMCIF_CE_INT_MASK, MASK_MBUFREN);
+        } else if (state & INT_BUFWEN) {
+                sh_mmcif_writel(host, MMCIF_CE_INT, ~INT_BUFWEN);
+                sh_mmcif_bitclr(host, MMCIF_CE_INT_MASK, MASK_MBUFWEN);
+        } else if (state & INT_CMD12DRE) {
+                sh_mmcif_writel(host, MMCIF_CE_INT,
+                        ~(INT_CMD12DRE | INT_CMD12RBE |
+                          INT_CMD12CRE | INT_BUFRE));
+                sh_mmcif_bitclr(host, MMCIF_CE_INT_MASK, MASK_MCMD12DRE);
+        } else if (state & INT_BUFRE) {
+                sh_mmcif_writel(host, MMCIF_CE_INT, ~INT_BUFRE);
+                sh_mmcif_bitclr(host, MMCIF_CE_INT_MASK, MASK_MBUFRE);
+        } else if (state & INT_DTRANE) {
+                sh_mmcif_writel(host, MMCIF_CE_INT, ~INT_DTRANE);
+                sh_mmcif_bitclr(host, MMCIF_CE_INT_MASK, MASK_MDTRANE);
+        } else if (state & INT_CMD12RBE) {
+                sh_mmcif_writel(host, MMCIF_CE_INT,
+                                ~(INT_CMD12RBE | INT_CMD12CRE));
+                sh_mmcif_bitclr(host, MMCIF_CE_INT_MASK, MASK_MCMD12RBE);
+        } else if (state & INT_ERR_STS) {
+                /* err interrupts */
+                sh_mmcif_writel(host, MMCIF_CE_INT, ~state);
+                sh_mmcif_bitclr(host, MMCIF_CE_INT_MASK, state);
+                err = 1;
+        } else {
+                pr_debug("%s: Not support int\n", DRIVER_NAME);
+                sh_mmcif_writel(host, MMCIF_CE_INT, ~state);
+                sh_mmcif_bitclr(host, MMCIF_CE_INT_MASK, state);
+                err = 1;
+        }
+        if (err) {
+                host->sd_error = 1;
+                pr_debug("%s: int err state = %08x\n", DRIVER_NAME, state);
+        }
+        host->wait_int = 1;
+        wake_up(&host->intr_wait);
+
+        return IRQ_HANDLED;
+}
+
+static int __devinit sh_mmcif_probe(struct platform_device *pdev)
+{
+        int ret = 0, irq[2];
+        struct mmc_host *mmc;
+        struct sh_mmcif_host *host = NULL;
+        struct sh_mmcif_plat_data *pd = NULL;
+        struct resource *res;
+        void __iomem *reg;
+        char clk_name[8];
+
+        irq[0] = platform_get_irq(pdev, 0);
+        irq[1] = platform_get_irq(pdev, 1);
+        if (irq[0] < 0 || irq[1] < 0) {
+                pr_err(DRIVER_NAME": Get irq error\n");
+                return -ENXIO;
+        }
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&pdev->dev, "platform_get_resource error.\n");
+                return -ENXIO;
+        }
+        reg = ioremap(res->start, resource_size(res));
+        if (!reg) {
+                dev_err(&pdev->dev, "ioremap error.\n");
+                return -ENOMEM;
+        }
+        pd = (struct sh_mmcif_plat_data *)(pdev->dev.platform_data);
+        if (!pd) {
+                dev_err(&pdev->dev, "sh_mmcif plat data error.\n");
+                ret = -ENXIO;
+                goto clean_up;
+        }
+        mmc = mmc_alloc_host(sizeof(struct sh_mmcif_host), &pdev->dev);
+        if (!mmc) {
+                ret = -ENOMEM;
+                goto clean_up;
+        }
+        host            = mmc_priv(mmc);
+        host->mmc       = mmc;
+        host->addr      = reg;
+        host->timeout   = 1000;
+
+        snprintf(clk_name, sizeof(clk_name), "mmc%d", pdev->id);
+        host->hclk = clk_get(&pdev->dev, clk_name);
+        if (IS_ERR(host->hclk)) {
+                dev_err(&pdev->dev, "cannot get clock \"%s\"\n", clk_name);
+                ret = PTR_ERR(host->hclk);
+                goto clean_up1;
+        }
+        clk_enable(host->hclk);
+        host->clk = clk_get_rate(host->hclk);
+        host->pd = pdev;
+
+        init_waitqueue_head(&host->intr_wait);
+
+        mmc->ops = &sh_mmcif_ops;
+        mmc->f_max = host->clk;
+        /* close to 400KHz */
+        if (mmc->f_max < 51200000)
+                mmc->f_min = mmc->f_max / 128;
+        else if (mmc->f_max < 102400000)
+                mmc->f_min = mmc->f_max / 256;
+        else
+                mmc->f_min = mmc->f_max / 512;
+        if (pd->ocr)
+                mmc->ocr_avail = pd->ocr;
+        mmc->caps = MMC_CAP_MMC_HIGHSPEED;
+        if (pd->caps)
+                mmc->caps |= pd->caps;
+        mmc->max_phys_segs = 128;
+        mmc->max_hw_segs = 128;
+        mmc->max_blk_size = 512;
+        mmc->max_blk_count = 65535;
+        mmc->max_req_size = mmc->max_blk_size * mmc->max_blk_count;
+        mmc->max_seg_size = mmc->max_req_size;
+
+        sh_mmcif_sync_reset(host);
+        platform_set_drvdata(pdev, host);
+        mmc_add_host(mmc);
+
+        ret = request_irq(irq[0], sh_mmcif_intr, 0, "sh_mmc:error", host);
+        if (ret) {
+                pr_err(DRIVER_NAME": request_irq error (sh_mmc:error)\n");
+                goto clean_up2;
+        }
+        ret = request_irq(irq[1], sh_mmcif_intr, 0, "sh_mmc:int", host);
+        if (ret) {
+                free_irq(irq[0], host);
+                pr_err(DRIVER_NAME": request_irq error (sh_mmc:int)\n");
+                goto clean_up2;
+        }
+
+        sh_mmcif_writel(host, MMCIF_CE_INT_MASK, MASK_ALL);
+        sh_mmcif_detect(host->mmc);
+
+        pr_info("%s: driver version %s\n", DRIVER_NAME, DRIVER_VERSION);
+        pr_debug("%s: chip ver H'%04x\n", DRIVER_NAME,
+                        sh_mmcif_readl(host, MMCIF_CE_VERSION) & 0x0000ffff);
+        return ret;
+
+clean_up2:
+        clk_disable(host->hclk);
+clean_up1:
+        mmc_free_host(mmc);
+clean_up:
+        if (reg)
+                iounmap(reg);
+        return ret;
+}
+
+static int __devexit sh_mmcif_remove(struct platform_device *pdev)
+{
+        struct sh_mmcif_host *host = platform_get_drvdata(pdev);
+        int irq[2];
+
+        sh_mmcif_writel(host, MMCIF_CE_INT_MASK, MASK_ALL);
+
+        irq[0] = platform_get_irq(pdev, 0);
+        irq[1] = platform_get_irq(pdev, 1);
+
+        if (host->addr)
+                iounmap(host->addr);
+
+        platform_set_drvdata(pdev, NULL);
+        mmc_remove_host(host->mmc);
+
+        free_irq(irq[0], host);
+        free_irq(irq[1], host);
+
+        clk_disable(host->hclk);
+        mmc_free_host(host->mmc);
+
+        return 0;
+}
+
+static struct platform_driver sh_mmcif_driver = {
+        .probe          = sh_mmcif_probe,
+        .remove         = sh_mmcif_remove,
+        .driver         = {
+                .name   = DRIVER_NAME,
+        },
+};
+
+static int __init sh_mmcif_init(void)
+{
+        return platform_driver_register(&sh_mmcif_driver);
+}
+
+static void __exit sh_mmcif_exit(void)
+{
+        platform_driver_unregister(&sh_mmcif_driver);
+}
+
+module_init(sh_mmcif_init);
+module_exit(sh_mmcif_exit);
+
+
+MODULE_DESCRIPTION("SuperH on-chip MMC/eMMC interface driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS(DRIVER_NAME);
+MODULE_AUTHOR("Yusuke Goda <yusuke.goda.sx@renesas.com>");
diff --git a/drivers/mmc/host/tifm_sd.c b/drivers/mmc/host/tifm_sd.c
index 82554ddec6b3..cec99958b652 100644
--- a/drivers/mmc/host/tifm_sd.c
+++ b/drivers/mmc/host/tifm_sd.c
@@ -1032,7 +1032,7 @@ static void tifm_sd_remove(struct tifm_dev *sock)
 
 static int tifm_sd_suspend(struct tifm_dev *sock, pm_message_t state)
 {
-        return mmc_suspend_host(tifm_get_drvdata(sock), state);
+        return mmc_suspend_host(tifm_get_drvdata(sock));
 }
 
 static int tifm_sd_resume(struct tifm_dev *sock)
diff --git a/drivers/mmc/host/tmio_mmc.c b/drivers/mmc/host/tmio_mmc.c
index 883fcac21004..ee7d0a5a51c4 100644
--- a/drivers/mmc/host/tmio_mmc.c
+++ b/drivers/mmc/host/tmio_mmc.c
@@ -768,7 +768,7 @@ static int tmio_mmc_suspend(struct platform_device *dev, pm_message_t state)
         struct mmc_host *mmc = platform_get_drvdata(dev);
         int ret;
 
-        ret = mmc_suspend_host(mmc, state);
+        ret = mmc_suspend_host(mmc);
 
         /* Tell MFD core it can disable us now.*/
         if (!ret && cell->disable)
diff --git a/drivers/mmc/host/via-sdmmc.c b/drivers/mmc/host/via-sdmmc.c
index 632858a94376..19f2d72dbca5 100644
--- a/drivers/mmc/host/via-sdmmc.c
+++ b/drivers/mmc/host/via-sdmmc.c
@@ -1280,7 +1280,7 @@ static int via_sd_suspend(struct pci_dev *pcidev, pm_message_t state)
         via_save_pcictrlreg(host);
         via_save_sdcreg(host);
 
-        ret = mmc_suspend_host(host->mmc, state);
+        ret = mmc_suspend_host(host->mmc);
 
         pci_save_state(pcidev);
         pci_enable_wake(pcidev, pci_choose_state(pcidev, state), 0);
diff --git a/drivers/mmc/host/wbsd.c b/drivers/mmc/host/wbsd.c
index 69efe01eece8..0012f5d13d28 100644
--- a/drivers/mmc/host/wbsd.c
+++ b/drivers/mmc/host/wbsd.c
@@ -1819,7 +1819,7 @@ static int wbsd_suspend(struct wbsd_host *host, pm_message_t state)
 {
         BUG_ON(host == NULL);
 
-        return mmc_suspend_host(host->mmc, state);
+        return mmc_suspend_host(host->mmc);
 }
 
 static int wbsd_resume(struct wbsd_host *host)
diff --git a/drivers/mtd/ubi/cdev.c b/drivers/mtd/ubi/cdev.c
index 72ebb3f06b86..4dfa6b90c21c 100644
--- a/drivers/mtd/ubi/cdev.c
+++ b/drivers/mtd/ubi/cdev.c
@@ -189,8 +189,7 @@ static loff_t vol_cdev_llseek(struct file *file, loff_t offset, int origin)
         return new_offset;
 }
 
-static int vol_cdev_fsync(struct file *file, struct dentry *dentry,
-                          int datasync)
+static int vol_cdev_fsync(struct file *file, int datasync)
 {
         struct ubi_volume_desc *desc = file->private_data;
         struct ubi_device *ubi = desc->vol->ubi;
diff --git a/drivers/net/3c507.c b/drivers/net/3c507.c
index 82eaf65d2d85..ea9b7a098c9b 100644
--- a/drivers/net/3c507.c
+++ b/drivers/net/3c507.c
@@ -551,8 +551,7 @@ static irqreturn_t el16_interrupt(int irq, void *dev_id)
         void __iomem *shmem;
 
         if (dev == NULL) {
-                pr_err("%s: net_interrupt(): irq %d for unknown device.\n",
-                        dev->name, irq);
+                pr_err("net_interrupt(): irq %d for unknown device.\n", irq);
                 return IRQ_NONE;
         }
 
diff --git a/drivers/net/benet/be_cmds.c b/drivers/net/benet/be_cmds.c
index c911bfb55b19..9d11dbf5e4da 100644
--- a/drivers/net/benet/be_cmds.c
+++ b/drivers/net/benet/be_cmds.c
@@ -294,7 +294,7 @@ int be_cmd_POST(struct be_adapter *adapter)
                 } else {
                         return 0;
                 }
-        } while (timeout < 20);
+        } while (timeout < 40);
 
         dev_err(&adapter->pdev->dev, "POST timeout; stage=0x%x\n", stage);
         return -1;
diff --git a/drivers/net/benet/be_main.c b/drivers/net/benet/be_main.c
index aa065c71ddd8..54b14272f333 100644
--- a/drivers/net/benet/be_main.c
+++ b/drivers/net/benet/be_main.c
@@ -1861,7 +1861,7 @@ static int be_setup(struct be_adapter *adapter)
                                 goto if_destroy;
                         }
                         vf++;
-                } while (vf < num_vfs);
+                }
         } else if (!be_physfn(adapter)) {
                 status = be_cmd_mac_addr_query(adapter, mac,
                         MAC_ADDRESS_TYPE_NETWORK, false, adapter->if_handle);
diff --git a/drivers/net/can/Kconfig b/drivers/net/can/Kconfig
index 05b751719bd5..2c5227c02fa0 100644
--- a/drivers/net/can/Kconfig
+++ b/drivers/net/can/Kconfig
@@ -63,6 +63,16 @@ config CAN_BFIN
           To compile this driver as a module, choose M here: the
           module will be called bfin_can.
 
+config CAN_JANZ_ICAN3
+        tristate "Janz VMOD-ICAN3 Intelligent CAN controller"
+        depends on CAN_DEV && MFD_JANZ_CMODIO
+        ---help---
+          Driver for Janz VMOD-ICAN3 Intelligent CAN controller module, which
+          connects to a MODULbus carrier board.
+
+          This driver can also be built as a module. If so, the module will be
+          called janz-ican3.ko.
+
 source "drivers/net/can/mscan/Kconfig"
 
 source "drivers/net/can/sja1000/Kconfig"
diff --git a/drivers/net/can/Makefile b/drivers/net/can/Makefile
index 7a702f28d01c..9047cd066fea 100644
--- a/drivers/net/can/Makefile
+++ b/drivers/net/can/Makefile
@@ -15,5 +15,6 @@ obj-$(CONFIG_CAN_AT91)		+= at91_can.o
 obj-$(CONFIG_CAN_TI_HECC)       += ti_hecc.o
 obj-$(CONFIG_CAN_MCP251X)       += mcp251x.o
 obj-$(CONFIG_CAN_BFIN)          += bfin_can.o
+obj-$(CONFIG_CAN_JANZ_ICAN3)    += janz-ican3.o
 
 ccflags-$(CONFIG_CAN_DEBUG_DEVICES) := -DDEBUG
diff --git a/drivers/net/can/janz-ican3.c b/drivers/net/can/janz-ican3.c
new file mode 100644
index 000000000000..6e533dcc36c0
--- /dev/null
+++ b/drivers/net/can/janz-ican3.c
@@ -0,0 +1,1830 @@
+/*
+ * Janz MODULbus VMOD-ICAN3 CAN Interface Driver
+ *
+ * Copyright (c) 2010 Ira W. Snyder <iws@ovro.caltech.edu>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/delay.h>
+#include <linux/platform_device.h>
+
+#include <linux/netdevice.h>
+#include <linux/can.h>
+#include <linux/can/dev.h>
+#include <linux/can/error.h>
+
+#include <linux/mfd/janz.h>
+
+/* the DPM has 64k of memory, organized into 256x 256 byte pages */
+#define DPM_NUM_PAGES           256
+#define DPM_PAGE_SIZE           256
+#define DPM_PAGE_ADDR(p)        ((p) * DPM_PAGE_SIZE)
+
+/* JANZ ICAN3 "old-style" host interface queue page numbers */
+#define QUEUE_OLD_CONTROL       0
+#define QUEUE_OLD_RB0           1
+#define QUEUE_OLD_RB1           2
+#define QUEUE_OLD_WB0           3
+#define QUEUE_OLD_WB1           4
+
+/* Janz ICAN3 "old-style" host interface control registers */
+#define MSYNC_PEER              0x00            /* ICAN only */
+#define MSYNC_LOCL              0x01            /* host only */
+#define TARGET_RUNNING          0x02
+
+#define MSYNC_RB0               0x01
+#define MSYNC_RB1               0x02
+#define MSYNC_RBLW              0x04
+#define MSYNC_RB_MASK           (MSYNC_RB0 | MSYNC_RB1)
+
+#define MSYNC_WB0               0x10
+#define MSYNC_WB1               0x20
+#define MSYNC_WBLW              0x40
+#define MSYNC_WB_MASK           (MSYNC_WB0 | MSYNC_WB1)
+
+/* Janz ICAN3 "new-style" host interface queue page numbers */
+#define QUEUE_TOHOST            5
+#define QUEUE_FROMHOST_MID      6
+#define QUEUE_FROMHOST_HIGH     7
+#define QUEUE_FROMHOST_LOW      8
+
+/* The first free page in the DPM is #9 */
+#define DPM_FREE_START          9
+
+/* Janz ICAN3 "new-style" and "fast" host interface descriptor flags */
+#define DESC_VALID              0x80
+#define DESC_WRAP               0x40
+#define DESC_INTERRUPT          0x20
+#define DESC_IVALID             0x10
+#define DESC_LEN(len)           (len)
+
+/* Janz ICAN3 Firmware Messages */
+#define MSG_CONNECTI            0x02
+#define MSG_DISCONNECT          0x03
+#define MSG_IDVERS              0x04
+#define MSG_MSGLOST             0x05
+#define MSG_NEWHOSTIF           0x08
+#define MSG_INQUIRY             0x0a
+#define MSG_SETAFILMASK         0x10
+#define MSG_INITFDPMQUEUE       0x11
+#define MSG_HWCONF              0x12
+#define MSG_FMSGLOST            0x15
+#define MSG_CEVTIND             0x37
+#define MSG_CBTRREQ             0x41
+#define MSG_COFFREQ             0x42
+#define MSG_CONREQ              0x43
+#define MSG_CCONFREQ            0x47
+
+/*
+ * Janz ICAN3 CAN Inquiry Message Types
+ *
+ * NOTE: there appears to be a firmware bug here. You must send
+ * NOTE: INQUIRY_STATUS and expect to receive an INQUIRY_EXTENDED
+ * NOTE: response. The controller never responds to a message with
+ * NOTE: the INQUIRY_EXTENDED subspec :(
+ */
+#define INQUIRY_STATUS          0x00
+#define INQUIRY_TERMINATION     0x01
+#define INQUIRY_EXTENDED        0x04
+
+/* Janz ICAN3 CAN Set Acceptance Filter Mask Message Types */
+#define SETAFILMASK_REJECT      0x00
+#define SETAFILMASK_FASTIF      0x02
+
+/* Janz ICAN3 CAN Hardware Configuration Message Types */
+#define HWCONF_TERMINATE_ON     0x01
+#define HWCONF_TERMINATE_OFF    0x00
+
+/* Janz ICAN3 CAN Event Indication Message Types */
+#define CEVTIND_EI              0x01
+#define CEVTIND_DOI             0x02
+#define CEVTIND_LOST            0x04
+#define CEVTIND_FULL            0x08
+#define CEVTIND_BEI             0x10
+
+#define CEVTIND_CHIP_SJA1000    0x02
+
+#define ICAN3_BUSERR_QUOTA_MAX  255
+
+/* Janz ICAN3 CAN Frame Conversion */
+#define ICAN3_ECHO      0x10
+#define ICAN3_EFF_RTR   0x40
+#define ICAN3_SFF_RTR   0x10
+#define ICAN3_EFF       0x80
+
+#define ICAN3_CAN_TYPE_MASK     0x0f
+#define ICAN3_CAN_TYPE_SFF      0x00
+#define ICAN3_CAN_TYPE_EFF      0x01
+
+#define ICAN3_CAN_DLC_MASK      0x0f
+
+/*
+ * SJA1000 Status and Error Register Definitions
+ *
+ * Copied from drivers/net/can/sja1000/sja1000.h
+ */
+
+/* status register content */
+#define SR_BS           0x80
+#define SR_ES           0x40
+#define SR_TS           0x20
+#define SR_RS           0x10
+#define SR_TCS          0x08
+#define SR_TBS          0x04
+#define SR_DOS          0x02
+#define SR_RBS          0x01
+
+#define SR_CRIT (SR_BS|SR_ES)
+
+/* ECC register */
+#define ECC_SEG         0x1F
+#define ECC_DIR         0x20
+#define ECC_ERR         6
+#define ECC_BIT         0x00
+#define ECC_FORM        0x40
+#define ECC_STUFF       0x80
+#define ECC_MASK        0xc0
+
+/* Number of buffers for use in the "new-style" host interface */
+#define ICAN3_NEW_BUFFERS       16
+
+/* Number of buffers for use in the "fast" host interface */
+#define ICAN3_TX_BUFFERS        512
+#define ICAN3_RX_BUFFERS        1024
+
+/* SJA1000 Clock Input */
+#define ICAN3_CAN_CLOCK         8000000
+
+/* Driver Name */
+#define DRV_NAME "janz-ican3"
+
+/* DPM Control Registers -- starts at offset 0x100 in the MODULbus registers */
+struct ican3_dpm_control {
+        /* window address register */
+        u8 window_address;
+        u8 unused1;
+
+        /*
+         * Read access: clear interrupt from microcontroller
+         * Write access: send interrupt to microcontroller
+         */
+        u8 interrupt;
+        u8 unused2;
+
+        /* write-only: reset all hardware on the module */
+        u8 hwreset;
+        u8 unused3;
+
+        /* write-only: generate an interrupt to the TPU */
+        u8 tpuinterrupt;
+};
+
+struct ican3_dev {
+
+        /* must be the first member */
+        struct can_priv can;
+
+        /* CAN network device */
+        struct net_device *ndev;
+        struct napi_struct napi;
+
+        /* Device for printing */
+        struct device *dev;
+
+        /* module number */
+        unsigned int num;
+
+        /* base address of registers and IRQ */
+        struct janz_cmodio_onboard_regs __iomem *ctrl;
+        struct ican3_dpm_control __iomem *dpmctrl;
+        void __iomem *dpm;
+        int irq;
+
+        /* CAN bus termination status */
+        struct completion termination_comp;
+        bool termination_enabled;
+
+        /* CAN bus error status registers */
+        struct completion buserror_comp;
+        struct can_berr_counter bec;
+
+        /* old and new style host interface */
+        unsigned int iftype;
+
+        /*
+         * Any function which changes the current DPM page must hold this
+         * lock while it is performing data accesses. This ensures that the
+         * function will not be preempted and end up reading data from a
+         * different DPM page than it expects.
+         */
+        spinlock_t lock;
+
+        /* new host interface */
+        unsigned int rx_int;
+        unsigned int rx_num;
+        unsigned int tx_num;
+
+        /* fast host interface */
+        unsigned int fastrx_start;
+        unsigned int fastrx_int;
+        unsigned int fastrx_num;
+        unsigned int fasttx_start;
+        unsigned int fasttx_num;
+
+        /* first free DPM page */
+        unsigned int free_page;
+};
+
+struct ican3_msg {
+        u8 control;
+        u8 spec;
+        __le16 len;
+        u8 data[252];
+};
+
+struct ican3_new_desc {
+        u8 control;
+        u8 pointer;
+};
+
+struct ican3_fast_desc {
+        u8 control;
+        u8 command;
+        u8 data[14];
+};
+
+/* write to the window basic address register */
+static inline void ican3_set_page(struct ican3_dev *mod, unsigned int page)
+{
+        BUG_ON(page >= DPM_NUM_PAGES);
+        iowrite8(page, &mod->dpmctrl->window_address);
+}
+
+/*
+ * ICAN3 "old-style" host interface
+ */
+
+/*
+ * Recieve a message from the ICAN3 "old-style" firmware interface
+ *
+ * LOCKING: must hold mod->lock
+ *
+ * returns 0 on success, -ENOMEM when no message exists
+ */
+static int ican3_old_recv_msg(struct ican3_dev *mod, struct ican3_msg *msg)
+{
+        unsigned int mbox, mbox_page;
+        u8 locl, peer, xord;
+
+        /* get the MSYNC registers */
+        ican3_set_page(mod, QUEUE_OLD_CONTROL);
+        peer = ioread8(mod->dpm + MSYNC_PEER);
+        locl = ioread8(mod->dpm + MSYNC_LOCL);
+        xord = locl ^ peer;
+
+        if ((xord & MSYNC_RB_MASK) == 0x00) {
+                dev_dbg(mod->dev, "no mbox for reading\n");
+                return -ENOMEM;
+        }
+
+        /* find the first free mbox to read */
+        if ((xord & MSYNC_RB_MASK) == MSYNC_RB_MASK)
+                mbox = (xord & MSYNC_RBLW) ? MSYNC_RB0 : MSYNC_RB1;
+        else
+                mbox = (xord & MSYNC_RB0) ? MSYNC_RB0 : MSYNC_RB1;
+
+        /* copy the message */
+        mbox_page = (mbox == MSYNC_RB0) ? QUEUE_OLD_RB0 : QUEUE_OLD_RB1;
+        ican3_set_page(mod, mbox_page);
+        memcpy_fromio(msg, mod->dpm, sizeof(*msg));
+
+        /*
+         * notify the firmware that the read buffer is available
+         * for it to fill again
+         */
+        locl ^= mbox;
+
+        ican3_set_page(mod, QUEUE_OLD_CONTROL);
+        iowrite8(locl, mod->dpm + MSYNC_LOCL);
+        return 0;
+}
+
+/*
+ * Send a message through the "old-style" firmware interface
+ *
+ * LOCKING: must hold mod->lock
+ *
+ * returns 0 on success, -ENOMEM when no free space exists
+ */
+static int ican3_old_send_msg(struct ican3_dev *mod, struct ican3_msg *msg)
+{
+        unsigned int mbox, mbox_page;
+        u8 locl, peer, xord;
+
+        /* get the MSYNC registers */
+        ican3_set_page(mod, QUEUE_OLD_CONTROL);
+        peer = ioread8(mod->dpm + MSYNC_PEER);
+        locl = ioread8(mod->dpm + MSYNC_LOCL);
+        xord = locl ^ peer;
+
+        if ((xord & MSYNC_WB_MASK) == MSYNC_WB_MASK) {
+                dev_err(mod->dev, "no mbox for writing\n");
+                return -ENOMEM;
+        }
+
+        /* calculate a free mbox to use */
+        mbox = (xord & MSYNC_WB0) ? MSYNC_WB1 : MSYNC_WB0;
+
+        /* copy the message to the DPM */
+        mbox_page = (mbox == MSYNC_WB0) ? QUEUE_OLD_WB0 : QUEUE_OLD_WB1;
+        ican3_set_page(mod, mbox_page);
+        memcpy_toio(mod->dpm, msg, sizeof(*msg));
+
+        locl ^= mbox;
+        if (mbox == MSYNC_WB1)
+                locl |= MSYNC_WBLW;
+
+        ican3_set_page(mod, QUEUE_OLD_CONTROL);
+        iowrite8(locl, mod->dpm + MSYNC_LOCL);
+        return 0;
+}
+
+/*
+ * ICAN3 "new-style" Host Interface Setup
+ */
+
+static void __devinit ican3_init_new_host_interface(struct ican3_dev *mod)
+{
+        struct ican3_new_desc desc;
+        unsigned long flags;
+        void __iomem *dst;
+        int i;
+
+        spin_lock_irqsave(&mod->lock, flags);
+
+        /* setup the internal datastructures for RX */
+        mod->rx_num = 0;
+        mod->rx_int = 0;
+
+        /* tohost queue descriptors are in page 5 */
+        ican3_set_page(mod, QUEUE_TOHOST);
+        dst = mod->dpm;
+
+        /* initialize the tohost (rx) queue descriptors: pages 9-24 */
+        for (i = 0; i < ICAN3_NEW_BUFFERS; i++) {
+                desc.control = DESC_INTERRUPT | DESC_LEN(1); /* I L=1 */
+                desc.pointer = mod->free_page;
+
+                /* set wrap flag on last buffer */
+                if (i == ICAN3_NEW_BUFFERS - 1)
+                        desc.control |= DESC_WRAP;
+
+                memcpy_toio(dst, &desc, sizeof(desc));
+                dst += sizeof(desc);
+                mod->free_page++;
+        }
+
+        /* fromhost (tx) mid queue descriptors are in page 6 */
+        ican3_set_page(mod, QUEUE_FROMHOST_MID);
+        dst = mod->dpm;
+
+        /* setup the internal datastructures for TX */
+        mod->tx_num = 0;
+
+        /* initialize the fromhost mid queue descriptors: pages 25-40 */
+        for (i = 0; i < ICAN3_NEW_BUFFERS; i++) {
+                desc.control = DESC_VALID | DESC_LEN(1); /* V L=1 */
+                desc.pointer = mod->free_page;
+
+                /* set wrap flag on last buffer */
+                if (i == ICAN3_NEW_BUFFERS - 1)
+                        desc.control |= DESC_WRAP;
+
+                memcpy_toio(dst, &desc, sizeof(desc));
+                dst += sizeof(desc);
+                mod->free_page++;
+        }
+
+        /* fromhost hi queue descriptors are in page 7 */
+        ican3_set_page(mod, QUEUE_FROMHOST_HIGH);
+        dst = mod->dpm;
+
+        /* initialize only a single buffer in the fromhost hi queue (unused) */
+        desc.control = DESC_VALID | DESC_WRAP | DESC_LEN(1); /* VW L=1 */
+        desc.pointer = mod->free_page;
+        memcpy_toio(dst, &desc, sizeof(desc));
+        mod->free_page++;
+
+        /* fromhost low queue descriptors are in page 8 */
+        ican3_set_page(mod, QUEUE_FROMHOST_LOW);
+        dst = mod->dpm;
+
+        /* initialize only a single buffer in the fromhost low queue (unused) */
+        desc.control = DESC_VALID | DESC_WRAP | DESC_LEN(1); /* VW L=1 */
+        desc.pointer = mod->free_page;
+        memcpy_toio(dst, &desc, sizeof(desc));
+        mod->free_page++;
+
+        spin_unlock_irqrestore(&mod->lock, flags);
+}
+
+/*
+ * ICAN3 Fast Host Interface Setup
+ */
+
+static void __devinit ican3_init_fast_host_interface(struct ican3_dev *mod)
+{
+        struct ican3_fast_desc desc;
+        unsigned long flags;
+        unsigned int addr;
+        void __iomem *dst;
+        int i;
+
+        spin_lock_irqsave(&mod->lock, flags);
+
+        /* save the start recv page */
+        mod->fastrx_start = mod->free_page;
+        mod->fastrx_num = 0;
+        mod->fastrx_int = 0;
+
+        /* build a single fast tohost queue descriptor */
+        memset(&desc, 0, sizeof(desc));
+        desc.control = 0x00;
+        desc.command = 1;
+
+        /* build the tohost queue descriptor ring in memory */
+        addr = 0;
+        for (i = 0; i < ICAN3_RX_BUFFERS; i++) {
+
+                /* set the wrap bit on the last buffer */
+                if (i == ICAN3_RX_BUFFERS - 1)
+                        desc.control |= DESC_WRAP;
+
+                /* switch to the correct page */
+                ican3_set_page(mod, mod->free_page);
+
+                /* copy the descriptor to the DPM */
+                dst = mod->dpm + addr;
+                memcpy_toio(dst, &desc, sizeof(desc));
+                addr += sizeof(desc);
+
+                /* move to the next page if necessary */
+                if (addr >= DPM_PAGE_SIZE) {
+                        addr = 0;
+                        mod->free_page++;
+                }
+        }
+
+        /* make sure we page-align the next queue */
+        if (addr != 0)
+                mod->free_page++;
+
+        /* save the start xmit page */
+        mod->fasttx_start = mod->free_page;
+        mod->fasttx_num = 0;
+
+        /* build a single fast fromhost queue descriptor */
+        memset(&desc, 0, sizeof(desc));
+        desc.control = DESC_VALID;
+        desc.command = 1;
+
+        /* build the fromhost queue descriptor ring in memory */
+        addr = 0;
+        for (i = 0; i < ICAN3_TX_BUFFERS; i++) {
+
+                /* set the wrap bit on the last buffer */
+                if (i == ICAN3_TX_BUFFERS - 1)
+                        desc.control |= DESC_WRAP;
+
+                /* switch to the correct page */
+                ican3_set_page(mod, mod->free_page);
+
+                /* copy the descriptor to the DPM */
+                dst = mod->dpm + addr;
+                memcpy_toio(dst, &desc, sizeof(desc));
+                addr += sizeof(desc);
+
+                /* move to the next page if necessary */
+                if (addr >= DPM_PAGE_SIZE) {
+                        addr = 0;
+                        mod->free_page++;
+                }
+        }
+
+        spin_unlock_irqrestore(&mod->lock, flags);
+}
+
+/*
+ * ICAN3 "new-style" Host Interface Message Helpers
+ */
+
+/*
+ * LOCKING: must hold mod->lock
+ */
+static int ican3_new_send_msg(struct ican3_dev *mod, struct ican3_msg *msg)
+{
+        struct ican3_new_desc desc;
+        void __iomem *desc_addr = mod->dpm + (mod->tx_num * sizeof(desc));
+
+        /* switch to the fromhost mid queue, and read the buffer descriptor */
+        ican3_set_page(mod, QUEUE_FROMHOST_MID);
+        memcpy_fromio(&desc, desc_addr, sizeof(desc));
+
+        if (!(desc.control & DESC_VALID)) {
+                dev_dbg(mod->dev, "%s: no free buffers\n", __func__);
+                return -ENOMEM;
+        }
+
+        /* switch to the data page, copy the data */
+        ican3_set_page(mod, desc.pointer);
+        memcpy_toio(mod->dpm, msg, sizeof(*msg));
+
+        /* switch back to the descriptor, set the valid bit, write it back */
+        ican3_set_page(mod, QUEUE_FROMHOST_MID);
+        desc.control ^= DESC_VALID;
+        memcpy_toio(desc_addr, &desc, sizeof(desc));
+
+        /* update the tx number */
+        mod->tx_num = (desc.control & DESC_WRAP) ? 0 : (mod->tx_num + 1);
+        return 0;
+}
+
+/*
+ * LOCKING: must hold mod->lock
+ */
+static int ican3_new_recv_msg(struct ican3_dev *mod, struct ican3_msg *msg)
+{
+        struct ican3_new_desc desc;
+        void __iomem *desc_addr = mod->dpm + (mod->rx_num * sizeof(desc));
+
+        /* switch to the tohost queue, and read the buffer descriptor */
+        ican3_set_page(mod, QUEUE_TOHOST);
+        memcpy_fromio(&desc, desc_addr, sizeof(desc));
+
+        if (!(desc.control & DESC_VALID)) {
+                dev_dbg(mod->dev, "%s: no buffers to recv\n", __func__);
+                return -ENOMEM;
+        }
+
+        /* switch to the data page, copy the data */
+        ican3_set_page(mod, desc.pointer);
+        memcpy_fromio(msg, mod->dpm, sizeof(*msg));
+
+        /* switch back to the descriptor, toggle the valid bit, write it back */
+        ican3_set_page(mod, QUEUE_TOHOST);
+        desc.control ^= DESC_VALID;
+        memcpy_toio(desc_addr, &desc, sizeof(desc));
+
+        /* update the rx number */
+        mod->rx_num = (desc.control & DESC_WRAP) ? 0 : (mod->rx_num + 1);
+        return 0;
+}
+
+/*
+ * Message Send / Recv Helpers
+ */
+
+static int ican3_send_msg(struct ican3_dev *mod, struct ican3_msg *msg)
+{
+        unsigned long flags;
+        int ret;
+
+        spin_lock_irqsave(&mod->lock, flags);
+
+        if (mod->iftype == 0)
+                ret = ican3_old_send_msg(mod, msg);
+        else
+                ret = ican3_new_send_msg(mod, msg);
+
+        spin_unlock_irqrestore(&mod->lock, flags);
+        return ret;
+}
+
+static int ican3_recv_msg(struct ican3_dev *mod, struct ican3_msg *msg)
+{
+        unsigned long flags;
+        int ret;
+
+        spin_lock_irqsave(&mod->lock, flags);
+
+        if (mod->iftype == 0)
+                ret = ican3_old_recv_msg(mod, msg);
+        else
+                ret = ican3_new_recv_msg(mod, msg);
+
+        spin_unlock_irqrestore(&mod->lock, flags);
+        return ret;
+}
+
+/*
+ * Quick Pre-constructed Messages
+ */
+
+static int __devinit ican3_msg_connect(struct ican3_dev *mod)
+{
+        struct ican3_msg msg;
+
+        memset(&msg, 0, sizeof(msg));
+        msg.spec = MSG_CONNECTI;
+        msg.len = cpu_to_le16(0);
+
+        return ican3_send_msg(mod, &msg);
+}
+
+static int __devexit ican3_msg_disconnect(struct ican3_dev *mod)
+{
+        struct ican3_msg msg;
+
+        memset(&msg, 0, sizeof(msg));
+        msg.spec = MSG_DISCONNECT;
+        msg.len = cpu_to_le16(0);
+
+        return ican3_send_msg(mod, &msg);
+}
+
+static int __devinit ican3_msg_newhostif(struct ican3_dev *mod)
+{
+        struct ican3_msg msg;
+        int ret;
+
+        memset(&msg, 0, sizeof(msg));
+        msg.spec = MSG_NEWHOSTIF;
+        msg.len = cpu_to_le16(0);
+
+        /* If we're not using the old interface, switching seems bogus */
+        WARN_ON(mod->iftype != 0);
+
+        ret = ican3_send_msg(mod, &msg);
+        if (ret)
+                return ret;
+
+        /* mark the module as using the new host interface */
+        mod->iftype = 1;
+        return 0;
+}
+
+static int __devinit ican3_msg_fasthostif(struct ican3_dev *mod)
+{
+        struct ican3_msg msg;
+        unsigned int addr;
+
+        memset(&msg, 0, sizeof(msg));
+        msg.spec = MSG_INITFDPMQUEUE;
+        msg.len = cpu_to_le16(8);
+
+        /* write the tohost queue start address */
+        addr = DPM_PAGE_ADDR(mod->fastrx_start);
+        msg.data[0] = addr & 0xff;
+        msg.data[1] = (addr >> 8) & 0xff;
+        msg.data[2] = (addr >> 16) & 0xff;
+        msg.data[3] = (addr >> 24) & 0xff;
+
+        /* write the fromhost queue start address */
+        addr = DPM_PAGE_ADDR(mod->fasttx_start);
+        msg.data[4] = addr & 0xff;
+        msg.data[5] = (addr >> 8) & 0xff;
+        msg.data[6] = (addr >> 16) & 0xff;
+        msg.data[7] = (addr >> 24) & 0xff;
+
+        /* If we're not using the new interface yet, we cannot do this */
+        WARN_ON(mod->iftype != 1);
+
+        return ican3_send_msg(mod, &msg);
+}
+
+/*
+ * Setup the CAN filter to either accept or reject all
+ * messages from the CAN bus.
+ */
+static int __devinit ican3_set_id_filter(struct ican3_dev *mod, bool accept)
+{
+        struct ican3_msg msg;
+        int ret;
+
+        /* Standard Frame Format */
+        memset(&msg, 0, sizeof(msg));
+        msg.spec = MSG_SETAFILMASK;
+        msg.len = cpu_to_le16(5);
+        msg.data[0] = 0x00; /* IDLo LSB */
+        msg.data[1] = 0x00; /* IDLo MSB */
+        msg.data[2] = 0xff; /* IDHi LSB */
+        msg.data[3] = 0x07; /* IDHi MSB */
+
+        /* accept all frames for fast host if, or reject all frames */
+        msg.data[4] = accept ? SETAFILMASK_FASTIF : SETAFILMASK_REJECT;
+
+        ret = ican3_send_msg(mod, &msg);
+        if (ret)
+                return ret;
+
+        /* Extended Frame Format */
+        memset(&msg, 0, sizeof(msg));
+        msg.spec = MSG_SETAFILMASK;
+        msg.len = cpu_to_le16(13);
+        msg.data[0] = 0;    /* MUX = 0 */
+        msg.data[1] = 0x00; /* IDLo LSB */
+        msg.data[2] = 0x00;
+        msg.data[3] = 0x00;
+        msg.data[4] = 0x20; /* IDLo MSB */
+        msg.data[5] = 0xff; /* IDHi LSB */
+        msg.data[6] = 0xff;
+        msg.data[7] = 0xff;
+        msg.data[8] = 0x3f; /* IDHi MSB */
+
+        /* accept all frames for fast host if, or reject all frames */
+        msg.data[9] = accept ? SETAFILMASK_FASTIF : SETAFILMASK_REJECT;
+
+        return ican3_send_msg(mod, &msg);
+}
+
+/*
+ * Bring the CAN bus online or offline
+ */
+static int ican3_set_bus_state(struct ican3_dev *mod, bool on)
+{
+        struct ican3_msg msg;
+
+        memset(&msg, 0, sizeof(msg));
+        msg.spec = on ? MSG_CONREQ : MSG_COFFREQ;
+        msg.len = cpu_to_le16(0);
+
+        return ican3_send_msg(mod, &msg);
+}
+
+static int ican3_set_termination(struct ican3_dev *mod, bool on)
+{
+        struct ican3_msg msg;
+
+        memset(&msg, 0, sizeof(msg));
+        msg.spec = MSG_HWCONF;
+        msg.len = cpu_to_le16(2);
+        msg.data[0] = 0x00;
+        msg.data[1] = on ? HWCONF_TERMINATE_ON : HWCONF_TERMINATE_OFF;
+
+        return ican3_send_msg(mod, &msg);
+}
+
+static int ican3_send_inquiry(struct ican3_dev *mod, u8 subspec)
+{
+        struct ican3_msg msg;
+
+        memset(&msg, 0, sizeof(msg));
+        msg.spec = MSG_INQUIRY;
+        msg.len = cpu_to_le16(2);
+        msg.data[0] = subspec;
+        msg.data[1] = 0x00;
+
+        return ican3_send_msg(mod, &msg);
+}
+
+static int ican3_set_buserror(struct ican3_dev *mod, u8 quota)
+{
+        struct ican3_msg msg;
+
+        memset(&msg, 0, sizeof(msg));
+        msg.spec = MSG_CCONFREQ;
+        msg.len = cpu_to_le16(2);
+        msg.data[0] = 0x00;
+        msg.data[1] = quota;
+
+        return ican3_send_msg(mod, &msg);
+}
+
+/*
+ * ICAN3 to Linux CAN Frame Conversion
+ */
+
+static void ican3_to_can_frame(struct ican3_dev *mod,
+                               struct ican3_fast_desc *desc,
+                               struct can_frame *cf)
+{
+        if ((desc->command & ICAN3_CAN_TYPE_MASK) == ICAN3_CAN_TYPE_SFF) {
+                if (desc->data[1] & ICAN3_SFF_RTR)
+                        cf->can_id |= CAN_RTR_FLAG;
+
+                cf->can_id |= desc->data[0] << 3;
+                cf->can_id |= (desc->data[1] & 0xe0) >> 5;
+                cf->can_dlc = desc->data[1] & ICAN3_CAN_DLC_MASK;
+                memcpy(cf->data, &desc->data[2], sizeof(cf->data));
+        } else {
+                cf->can_dlc = desc->data[0] & ICAN3_CAN_DLC_MASK;
+                if (desc->data[0] & ICAN3_EFF_RTR)
+                        cf->can_id |= CAN_RTR_FLAG;
+
+                if (desc->data[0] & ICAN3_EFF) {
+                        cf->can_id |= CAN_EFF_FLAG;
+                        cf->can_id |= desc->data[2] << 21; /* 28-21 */
+                        cf->can_id |= desc->data[3] << 13; /* 20-13 */
+                        cf->can_id |= desc->data[4] << 5;  /* 12-5  */
+                        cf->can_id |= (desc->data[5] & 0xf8) >> 3;
+                } else {
+                        cf->can_id |= desc->data[2] << 3;  /* 10-3  */
+                        cf->can_id |= desc->data[3] >> 5;  /* 2-0   */
+                }
+
+                memcpy(cf->data, &desc->data[6], sizeof(cf->data));
+        }
+}
+
+static void can_frame_to_ican3(struct ican3_dev *mod,
+                               struct can_frame *cf,
+                               struct ican3_fast_desc *desc)
+{
+        /* clear out any stale data in the descriptor */
+        memset(desc->data, 0, sizeof(desc->data));
+
+        /* we always use the extended format, with the ECHO flag set */
+        desc->command = ICAN3_CAN_TYPE_EFF;
+        desc->data[0] |= cf->can_dlc;
+        desc->data[1] |= ICAN3_ECHO;
+
+        if (cf->can_id & CAN_RTR_FLAG)
+                desc->data[0] |= ICAN3_EFF_RTR;
+
+        /* pack the id into the correct places */
+        if (cf->can_id & CAN_EFF_FLAG) {
+                desc->data[0] |= ICAN3_EFF;
+                desc->data[2] = (cf->can_id & 0x1fe00000) >> 21; /* 28-21 */
+                desc->data[3] = (cf->can_id & 0x001fe000) >> 13; /* 20-13 */
+                desc->data[4] = (cf->can_id & 0x00001fe0) >> 5;  /* 12-5  */
+                desc->data[5] = (cf->can_id & 0x0000001f) << 3;  /* 4-0   */
+        } else {
+                desc->data[2] = (cf->can_id & 0x7F8) >> 3; /* bits 10-3 */
+                desc->data[3] = (cf->can_id & 0x007) << 5; /* bits 2-0  */
+        }
+
+        /* copy the data bits into the descriptor */
+        memcpy(&desc->data[6], cf->data, sizeof(cf->data));
+}
+
+/*
+ * Interrupt Handling
+ */
+
+/*
+ * Handle an ID + Version message response from the firmware. We never generate
+ * this message in production code, but it is very useful when debugging to be
+ * able to display this message.
+ */
+static void ican3_handle_idvers(struct ican3_dev *mod, struct ican3_msg *msg)
+{
+        dev_dbg(mod->dev, "IDVERS response: %s\n", msg->data);
+}
+
+static void ican3_handle_msglost(struct ican3_dev *mod, struct ican3_msg *msg)
+{
+        struct net_device *dev = mod->ndev;
+        struct net_device_stats *stats = &dev->stats;
+        struct can_frame *cf;
+        struct sk_buff *skb;
+
+        /*
+         * Report that communication messages with the microcontroller firmware
+         * are being lost. These are never CAN frames, so we do not generate an
+         * error frame for userspace
+         */
+        if (msg->spec == MSG_MSGLOST) {
+                dev_err(mod->dev, "lost %d control messages\n", msg->data[0]);
+                return;
+        }
+
+        /*
+         * Oops, this indicates that we have lost messages in the fast queue,
+         * which are exclusively CAN messages. Our driver isn't reading CAN
+         * frames fast enough.
+         *
+         * We'll pretend that the SJA1000 told us that it ran out of buffer
+         * space, because there is not a better message for this.
+         */
+        skb = alloc_can_err_skb(dev, &cf);
+        if (skb) {
+                cf->can_id |= CAN_ERR_CRTL;
+                cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
+                stats->rx_errors++;
+                stats->rx_bytes += cf->can_dlc;
+                netif_rx(skb);
+        }
+}
+
+/*
+ * Handle CAN Event Indication Messages from the firmware
+ *
+ * The ICAN3 firmware provides the values of some SJA1000 registers when it
+ * generates this message. The code below is largely copied from the
+ * drivers/net/can/sja1000/sja1000.c file, and adapted as necessary
+ */
+static int ican3_handle_cevtind(struct ican3_dev *mod, struct ican3_msg *msg)
+{
+        struct net_device *dev = mod->ndev;
+        struct net_device_stats *stats = &dev->stats;
+        enum can_state state = mod->can.state;
+        u8 status, isrc, rxerr, txerr;
+        struct can_frame *cf;
+        struct sk_buff *skb;
+
+        /* we can only handle the SJA1000 part */
+        if (msg->data[1] != CEVTIND_CHIP_SJA1000) {
+                dev_err(mod->dev, "unable to handle errors on non-SJA1000\n");
+                return -ENODEV;
+        }
+
+        /* check the message length for sanity */
+        if (le16_to_cpu(msg->len) < 6) {
+                dev_err(mod->dev, "error message too short\n");
+                return -EINVAL;
+        }
+
+        skb = alloc_can_err_skb(dev, &cf);
+        if (skb == NULL)
+                return -ENOMEM;
+
+        isrc = msg->data[0];
+        status = msg->data[3];
+        rxerr = msg->data[4];
+        txerr = msg->data[5];
+
+        /* data overrun interrupt */
+        if (isrc == CEVTIND_DOI || isrc == CEVTIND_LOST) {
+                dev_dbg(mod->dev, "data overrun interrupt\n");
+                cf->can_id |= CAN_ERR_CRTL;
+                cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
+                stats->rx_over_errors++;
+                stats->rx_errors++;
+        }
+
+        /* error warning + passive interrupt */
+        if (isrc == CEVTIND_EI) {
+                dev_dbg(mod->dev, "error warning + passive interrupt\n");
+                if (status & SR_BS) {
+                        state = CAN_STATE_BUS_OFF;
+                        cf->can_id |= CAN_ERR_BUSOFF;
+                        can_bus_off(dev);
+                } else if (status & SR_ES) {
+                        if (rxerr >= 128 || txerr >= 128)
+                                state = CAN_STATE_ERROR_PASSIVE;
+                        else
+                                state = CAN_STATE_ERROR_WARNING;
+                } else {
+                        state = CAN_STATE_ERROR_ACTIVE;
+                }
+        }
+
+        /* bus error interrupt */
+        if (isrc == CEVTIND_BEI) {
+                u8 ecc = msg->data[2];
+
+                dev_dbg(mod->dev, "bus error interrupt\n");
+                mod->can.can_stats.bus_error++;
+                stats->rx_errors++;
+                cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR;
+
+                switch (ecc & ECC_MASK) {
+                case ECC_BIT:
+                        cf->data[2] |= CAN_ERR_PROT_BIT;
+                        break;
+                case ECC_FORM:
+                        cf->data[2] |= CAN_ERR_PROT_FORM;
+                        break;
+                case ECC_STUFF:
+                        cf->data[2] |= CAN_ERR_PROT_STUFF;
+                        break;
+                default:
+                        cf->data[2] |= CAN_ERR_PROT_UNSPEC;
+                        cf->data[3] = ecc & ECC_SEG;
+                        break;
+                }
+
+                if ((ecc & ECC_DIR) == 0)
+                        cf->data[2] |= CAN_ERR_PROT_TX;
+
+                cf->data[6] = txerr;
+                cf->data[7] = rxerr;
+        }
+
+        if (state != mod->can.state && (state == CAN_STATE_ERROR_WARNING ||
+                                        state == CAN_STATE_ERROR_PASSIVE)) {
+                cf->can_id |= CAN_ERR_CRTL;
+                if (state == CAN_STATE_ERROR_WARNING) {
+                        mod->can.can_stats.error_warning++;
+                        cf->data[1] = (txerr > rxerr) ?
+                                CAN_ERR_CRTL_TX_WARNING :
+                                CAN_ERR_CRTL_RX_WARNING;
+                } else {
+                        mod->can.can_stats.error_passive++;
+                        cf->data[1] = (txerr > rxerr) ?
+                                CAN_ERR_CRTL_TX_PASSIVE :
+                                CAN_ERR_CRTL_RX_PASSIVE;
+                }
+
+                cf->data[6] = txerr;
+                cf->data[7] = rxerr;
+        }
+
+        mod->can.state = state;
+        stats->rx_errors++;
+        stats->rx_bytes += cf->can_dlc;
+        netif_rx(skb);
+        return 0;
+}
+
+static void ican3_handle_inquiry(struct ican3_dev *mod, struct ican3_msg *msg)
+{
+        switch (msg->data[0]) {
+        case INQUIRY_STATUS:
+        case INQUIRY_EXTENDED:
+                mod->bec.rxerr = msg->data[5];
+                mod->bec.txerr = msg->data[6];
+                complete(&mod->buserror_comp);
+                break;
+        case INQUIRY_TERMINATION:
+                mod->termination_enabled = msg->data[6] & HWCONF_TERMINATE_ON;
+                complete(&mod->termination_comp);
+                break;
+        default:
+                dev_err(mod->dev, "recieved an unknown inquiry response\n");
+                break;
+        }
+}
+
+static void ican3_handle_unknown_message(struct ican3_dev *mod,
+                                        struct ican3_msg *msg)
+{
+        dev_warn(mod->dev, "recieved unknown message: spec 0x%.2x length %d\n",
+                           msg->spec, le16_to_cpu(msg->len));
+}
+
+/*
+ * Handle a control message from the firmware
+ */
+static void ican3_handle_message(struct ican3_dev *mod, struct ican3_msg *msg)
+{
+        dev_dbg(mod->dev, "%s: modno %d spec 0x%.2x len %d bytes\n", __func__,
+                           mod->num, msg->spec, le16_to_cpu(msg->len));
+
+        switch (msg->spec) {
+        case MSG_IDVERS:
+                ican3_handle_idvers(mod, msg);
+                break;
+        case MSG_MSGLOST:
+        case MSG_FMSGLOST:
+                ican3_handle_msglost(mod, msg);
+                break;
+        case MSG_CEVTIND:
+                ican3_handle_cevtind(mod, msg);
+                break;
+        case MSG_INQUIRY:
+                ican3_handle_inquiry(mod, msg);
+                break;
+        default:
+                ican3_handle_unknown_message(mod, msg);
+                break;
+        }
+}
+
+/*
+ * Check that there is room in the TX ring to transmit another skb
+ *
+ * LOCKING: must hold mod->lock
+ */
+static bool ican3_txok(struct ican3_dev *mod)
+{
+        struct ican3_fast_desc __iomem *desc;
+        u8 control;
+
+        /* copy the control bits of the descriptor */
+        ican3_set_page(mod, mod->fasttx_start + (mod->fasttx_num / 16));
+        desc = mod->dpm + ((mod->fasttx_num % 16) * sizeof(*desc));
+        control = ioread8(&desc->control);
+
+        /* if the control bits are not valid, then we have no more space */
+        if (!(control & DESC_VALID))
+                return false;
+
+        return true;
+}
+
+/*
+ * Recieve one CAN frame from the hardware
+ *
+ * This works like the core of a NAPI function, but is intended to be called
+ * from workqueue context instead. This driver already needs a workqueue to
+ * process control messages, so we use the workqueue instead of using NAPI.
+ * This was done to simplify locking.
+ *
+ * CONTEXT: must be called from user context
+ */
+static int ican3_recv_skb(struct ican3_dev *mod)
+{
+        struct net_device *ndev = mod->ndev;
+        struct net_device_stats *stats = &ndev->stats;
+        struct ican3_fast_desc desc;
+        void __iomem *desc_addr;
+        struct can_frame *cf;
+        struct sk_buff *skb;
+        unsigned long flags;
+
+        spin_lock_irqsave(&mod->lock, flags);
+
+        /* copy the whole descriptor */
+        ican3_set_page(mod, mod->fastrx_start + (mod->fastrx_num / 16));
+        desc_addr = mod->dpm + ((mod->fastrx_num % 16) * sizeof(desc));
+        memcpy_fromio(&desc, desc_addr, sizeof(desc));
+
+        spin_unlock_irqrestore(&mod->lock, flags);
+
+        /* check that we actually have a CAN frame */
+        if (!(desc.control & DESC_VALID))
+                return -ENOBUFS;
+
+        /* allocate an skb */
+        skb = alloc_can_skb(ndev, &cf);
+        if (unlikely(skb == NULL)) {
+                stats->rx_dropped++;
+                goto err_noalloc;
+        }
+
+        /* convert the ICAN3 frame into Linux CAN format */
+        ican3_to_can_frame(mod, &desc, cf);
+
+        /* receive the skb, update statistics */
+        netif_receive_skb(skb);
+        stats->rx_packets++;
+        stats->rx_bytes += cf->can_dlc;
+
+err_noalloc:
+        /* toggle the valid bit and return the descriptor to the ring */
+        desc.control ^= DESC_VALID;
+
+        spin_lock_irqsave(&mod->lock, flags);
+
+        ican3_set_page(mod, mod->fastrx_start + (mod->fastrx_num / 16));
+        memcpy_toio(desc_addr, &desc, 1);
+
+        /* update the next buffer pointer */
+        mod->fastrx_num = (desc.control & DESC_WRAP) ? 0
+                                                     : (mod->fastrx_num + 1);
+
+        /* there are still more buffers to process */
+        spin_unlock_irqrestore(&mod->lock, flags);
+        return 0;
+}
+
+static int ican3_napi(struct napi_struct *napi, int budget)
+{
+        struct ican3_dev *mod = container_of(napi, struct ican3_dev, napi);
+        struct ican3_msg msg;
+        unsigned long flags;
+        int received = 0;
+        int ret;
+
+        /* process all communication messages */
+        while (true) {
+                ret = ican3_recv_msg(mod, &msg);
+                if (ret)
+                        break;
+
+                ican3_handle_message(mod, &msg);
+        }
+
+        /* process all CAN frames from the fast interface */
+        while (received < budget) {
+                ret = ican3_recv_skb(mod);
+                if (ret)
+                        break;
+
+                received++;
+        }
+
+        /* We have processed all packets that the adapter had, but it
+         * was less than our budget, stop polling */
+        if (received < budget)
+                napi_complete(napi);
+
+        spin_lock_irqsave(&mod->lock, flags);
+
+        /* Wake up the transmit queue if necessary */
+        if (netif_queue_stopped(mod->ndev) && ican3_txok(mod))
+                netif_wake_queue(mod->ndev);
+
+        spin_unlock_irqrestore(&mod->lock, flags);
+
+        /* re-enable interrupt generation */
+        iowrite8(1 << mod->num, &mod->ctrl->int_enable);
+        return received;
+}
+
+static irqreturn_t ican3_irq(int irq, void *dev_id)
+{
+        struct ican3_dev *mod = dev_id;
+        u8 stat;
+
+        /*
+         * The interrupt status register on this device reports interrupts
+         * as zeroes instead of using ones like most other devices
+         */
+        stat = ioread8(&mod->ctrl->int_disable) & (1 << mod->num);
+        if (stat == (1 << mod->num))
+                return IRQ_NONE;
+
+        /* clear the MODULbus interrupt from the microcontroller */
+        ioread8(&mod->dpmctrl->interrupt);
+
+        /* disable interrupt generation, schedule the NAPI poller */
+        iowrite8(1 << mod->num, &mod->ctrl->int_disable);
+        napi_schedule(&mod->napi);
+        return IRQ_HANDLED;
+}
+
+/*
+ * Firmware reset, startup, and shutdown
+ */
+
+/*
+ * Reset an ICAN module to its power-on state
+ *
+ * CONTEXT: no network device registered
+ * LOCKING: work function disabled
+ */
+static int ican3_reset_module(struct ican3_dev *mod)
+{
+        u8 val = 1 << mod->num;
+        unsigned long start;
+        u8 runold, runnew;
+
+        /* disable interrupts so no more work is scheduled */
+        iowrite8(1 << mod->num, &mod->ctrl->int_disable);
+
+        /* flush any pending work */
+        flush_scheduled_work();
+
+        /* the first unallocated page in the DPM is #9 */
+        mod->free_page = DPM_FREE_START;
+
+        ican3_set_page(mod, QUEUE_OLD_CONTROL);
+        runold = ioread8(mod->dpm + TARGET_RUNNING);
+
+        /* reset the module */
+        iowrite8(val, &mod->ctrl->reset_assert);
+        iowrite8(val, &mod->ctrl->reset_deassert);
+
+        /* wait until the module has finished resetting and is running */
+        start = jiffies;
+        do {
+                ican3_set_page(mod, QUEUE_OLD_CONTROL);
+                runnew = ioread8(mod->dpm + TARGET_RUNNING);
+                if (runnew == (runold ^ 0xff))
+                        return 0;
+
+                msleep(10);
+        } while (time_before(jiffies, start + HZ / 4));
+
+        dev_err(mod->dev, "failed to reset CAN module\n");
+        return -ETIMEDOUT;
+}
+
+static void __devexit ican3_shutdown_module(struct ican3_dev *mod)
+{
+        ican3_msg_disconnect(mod);
+        ican3_reset_module(mod);
+}
+
+/*
+ * Startup an ICAN module, bringing it into fast mode
+ */
+static int __devinit ican3_startup_module(struct ican3_dev *mod)
+{
+        int ret;
+
+        ret = ican3_reset_module(mod);
+        if (ret) {
+                dev_err(mod->dev, "unable to reset module\n");
+                return ret;
+        }
+
+        /* re-enable interrupts so we can send messages */
+        iowrite8(1 << mod->num, &mod->ctrl->int_enable);
+
+        ret = ican3_msg_connect(mod);
+        if (ret) {
+                dev_err(mod->dev, "unable to connect to module\n");
+                return ret;
+        }
+
+        ican3_init_new_host_interface(mod);
+        ret = ican3_msg_newhostif(mod);
+        if (ret) {
+                dev_err(mod->dev, "unable to switch to new-style interface\n");
+                return ret;
+        }
+
+        /* default to "termination on" */
+        ret = ican3_set_termination(mod, true);
+        if (ret) {
+                dev_err(mod->dev, "unable to enable termination\n");
+                return ret;
+        }
+
+        /* default to "bus errors enabled" */
+        ret = ican3_set_buserror(mod, ICAN3_BUSERR_QUOTA_MAX);
+        if (ret) {
+                dev_err(mod->dev, "unable to set bus-error\n");
+                return ret;
+        }
+
+        ican3_init_fast_host_interface(mod);
+        ret = ican3_msg_fasthostif(mod);
+        if (ret) {
+                dev_err(mod->dev, "unable to switch to fast host interface\n");
+                return ret;
+        }
+
+        ret = ican3_set_id_filter(mod, true);
+        if (ret) {
+                dev_err(mod->dev, "unable to set acceptance filter\n");
+                return ret;
+        }
+
+        return 0;
+}
+
+/*
+ * CAN Network Device
+ */
+
+static int ican3_open(struct net_device *ndev)
+{
+        struct ican3_dev *mod = netdev_priv(ndev);
+        u8 quota;
+        int ret;
+
+        /* open the CAN layer */
+        ret = open_candev(ndev);
+        if (ret) {
+                dev_err(mod->dev, "unable to start CAN layer\n");
+                return ret;
+        }
+
+        /* set the bus error generation state appropriately */
+        if (mod->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING)
+                quota = ICAN3_BUSERR_QUOTA_MAX;
+        else
+                quota = 0;
+
+        ret = ican3_set_buserror(mod, quota);
+        if (ret) {
+                dev_err(mod->dev, "unable to set bus-error\n");
+                close_candev(ndev);
+                return ret;
+        }
+
+        /* bring the bus online */
+        ret = ican3_set_bus_state(mod, true);
+        if (ret) {
+                dev_err(mod->dev, "unable to set bus-on\n");
+                close_candev(ndev);
+                return ret;
+        }
+
+        /* start up the network device */
+        mod->can.state = CAN_STATE_ERROR_ACTIVE;
+        netif_start_queue(ndev);
+
+        return 0;
+}
+
+static int ican3_stop(struct net_device *ndev)
+{
+        struct ican3_dev *mod = netdev_priv(ndev);
+        int ret;
+
+        /* stop the network device xmit routine */
+        netif_stop_queue(ndev);
+        mod->can.state = CAN_STATE_STOPPED;
+
+        /* bring the bus offline, stop receiving packets */
+        ret = ican3_set_bus_state(mod, false);
+        if (ret) {
+                dev_err(mod->dev, "unable to set bus-off\n");
+                return ret;
+        }
+
+        /* close the CAN layer */
+        close_candev(ndev);
+        return 0;
+}
+
+static int ican3_xmit(struct sk_buff *skb, struct net_device *ndev)
+{
+        struct ican3_dev *mod = netdev_priv(ndev);
+        struct net_device_stats *stats = &ndev->stats;
+        struct can_frame *cf = (struct can_frame *)skb->data;
+        struct ican3_fast_desc desc;
+        void __iomem *desc_addr;
+        unsigned long flags;
+
+        spin_lock_irqsave(&mod->lock, flags);
+
+        /* check that we can actually transmit */
+        if (!ican3_txok(mod)) {
+                dev_err(mod->dev, "no free descriptors, stopping queue\n");
+                netif_stop_queue(ndev);
+                spin_unlock_irqrestore(&mod->lock, flags);
+                return NETDEV_TX_BUSY;
+        }
+
+        /* copy the control bits of the descriptor */
+        ican3_set_page(mod, mod->fasttx_start + (mod->fasttx_num / 16));
+        desc_addr = mod->dpm + ((mod->fasttx_num % 16) * sizeof(desc));
+        memset(&desc, 0, sizeof(desc));
+        memcpy_fromio(&desc, desc_addr, 1);
+
+        /* convert the Linux CAN frame into ICAN3 format */
+        can_frame_to_ican3(mod, cf, &desc);
+
+        /*
+         * the programming manual says that you must set the IVALID bit, then
+         * interrupt, then set the valid bit. Quite weird, but it seems to be
+         * required for this to work
+         */
+        desc.control |= DESC_IVALID;
+        memcpy_toio(desc_addr, &desc, sizeof(desc));
+
+        /* generate a MODULbus interrupt to the microcontroller */
+        iowrite8(0x01, &mod->dpmctrl->interrupt);
+
+        desc.control ^= DESC_VALID;
+        memcpy_toio(desc_addr, &desc, sizeof(desc));
+
+        /* update the next buffer pointer */
+        mod->fasttx_num = (desc.control & DESC_WRAP) ? 0
+                                                     : (mod->fasttx_num + 1);
+
+        /* update statistics */
+        stats->tx_packets++;
+        stats->tx_bytes += cf->can_dlc;
+        kfree_skb(skb);
+
+        /*
+         * This hardware doesn't have TX-done notifications, so we'll try and
+         * emulate it the best we can using ECHO skbs. Get the next TX
+         * descriptor, and see if we have room to send. If not, stop the queue.
+         * It will be woken when the ECHO skb for the current packet is recv'd.
+         */
+
+        /* copy the control bits of the descriptor */
+        if (!ican3_txok(mod))
+                netif_stop_queue(ndev);
+
+        spin_unlock_irqrestore(&mod->lock, flags);
+        return NETDEV_TX_OK;
+}
+
+static const struct net_device_ops ican3_netdev_ops = {
+        .ndo_open       = ican3_open,
+        .ndo_stop       = ican3_stop,
+        .ndo_start_xmit = ican3_xmit,
+};
+
+/*
+ * Low-level CAN Device
+ */
+
+/* This structure was stolen from drivers/net/can/sja1000/sja1000.c */
+static struct can_bittiming_const ican3_bittiming_const = {
+        .name = DRV_NAME,
+        .tseg1_min = 1,
+        .tseg1_max = 16,
+        .tseg2_min = 1,
+        .tseg2_max = 8,
+        .sjw_max = 4,
+        .brp_min = 1,
+        .brp_max = 64,
+        .brp_inc = 1,
+};
+
+/*
+ * This routine was stolen from drivers/net/can/sja1000/sja1000.c
+ *
+ * The bittiming register command for the ICAN3 just sets the bit timing
+ * registers on the SJA1000 chip directly
+ */
+static int ican3_set_bittiming(struct net_device *ndev)
+{
+        struct ican3_dev *mod = netdev_priv(ndev);
+        struct can_bittiming *bt = &mod->can.bittiming;
+        struct ican3_msg msg;
+        u8 btr0, btr1;
+
+        btr0 = ((bt->brp - 1) & 0x3f) | (((bt->sjw - 1) & 0x3) << 6);
+        btr1 = ((bt->prop_seg + bt->phase_seg1 - 1) & 0xf) |
+                (((bt->phase_seg2 - 1) & 0x7) << 4);
+        if (mod->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES)
+                btr1 |= 0x80;
+
+        memset(&msg, 0, sizeof(msg));
+        msg.spec = MSG_CBTRREQ;
+        msg.len = cpu_to_le16(4);
+        msg.data[0] = 0x00;
+        msg.data[1] = 0x00;
+        msg.data[2] = btr0;
+        msg.data[3] = btr1;
+
+        return ican3_send_msg(mod, &msg);
+}
+
+static int ican3_set_mode(struct net_device *ndev, enum can_mode mode)
+{
+        struct ican3_dev *mod = netdev_priv(ndev);
+        int ret;
+
+        if (mode != CAN_MODE_START)
+                return -ENOTSUPP;
+
+        /* bring the bus online */
+        ret = ican3_set_bus_state(mod, true);
+        if (ret) {
+                dev_err(mod->dev, "unable to set bus-on\n");
+                return ret;
+        }
+
+        /* start up the network device */
+        mod->can.state = CAN_STATE_ERROR_ACTIVE;
+
+        if (netif_queue_stopped(ndev))
+                netif_wake_queue(ndev);
+
+        return 0;
+}
+
+static int ican3_get_berr_counter(const struct net_device *ndev,
+                                  struct can_berr_counter *bec)
+{
+        struct ican3_dev *mod = netdev_priv(ndev);
+        int ret;
+
+        ret = ican3_send_inquiry(mod, INQUIRY_STATUS);
+        if (ret)
+                return ret;
+
+        ret = wait_for_completion_timeout(&mod->buserror_comp, HZ);
+        if (ret <= 0) {
+                dev_info(mod->dev, "%s timed out\n", __func__);
+                return -ETIMEDOUT;
+        }
+
+        bec->rxerr = mod->bec.rxerr;
+        bec->txerr = mod->bec.txerr;
+        return 0;
+}
+
+/*
+ * Sysfs Attributes
+ */
+
+static ssize_t ican3_sysfs_show_term(struct device *dev,
+                                     struct device_attribute *attr,
+                                     char *buf)
+{
+        struct ican3_dev *mod = netdev_priv(to_net_dev(dev));
+        int ret;
+
+        ret = ican3_send_inquiry(mod, INQUIRY_TERMINATION);
+        if (ret)
+                return ret;
+
+        ret = wait_for_completion_timeout(&mod->termination_comp, HZ);
+        if (ret <= 0) {
+                dev_info(mod->dev, "%s timed out\n", __func__);
+                return -ETIMEDOUT;
+        }
+
+        return snprintf(buf, PAGE_SIZE, "%u\n", mod->termination_enabled);
+}
+
+static ssize_t ican3_sysfs_set_term(struct device *dev,
+                                    struct device_attribute *attr,
+                                    const char *buf, size_t count)
+{
+        struct ican3_dev *mod = netdev_priv(to_net_dev(dev));
+        unsigned long enable;
+        int ret;
+
+        if (strict_strtoul(buf, 0, &enable))
+                return -EINVAL;
+
+        ret = ican3_set_termination(mod, enable);
+        if (ret)
+                return ret;
+
+        return count;
+}
+
+static DEVICE_ATTR(termination, S_IWUGO | S_IRUGO, ican3_sysfs_show_term,
+                                                   ican3_sysfs_set_term);
+
+static struct attribute *ican3_sysfs_attrs[] = {
+        &dev_attr_termination.attr,
+        NULL,
+};
+
+static struct attribute_group ican3_sysfs_attr_group = {
+        .attrs = ican3_sysfs_attrs,
+};
+
+/*
+ * PCI Subsystem
+ */
+
+static int __devinit ican3_probe(struct platform_device *pdev)
+{
+        struct janz_platform_data *pdata;
+        struct net_device *ndev;
+        struct ican3_dev *mod;
+        struct resource *res;
+        struct device *dev;
+        int ret;
+
+        pdata = pdev->dev.platform_data;
+        if (!pdata)
+                return -ENXIO;
+
+        dev_dbg(&pdev->dev, "probe: module number %d\n", pdata->modno);
+
+        /* save the struct device for printing */
+        dev = &pdev->dev;
+
+        /* allocate the CAN device and private data */
+        ndev = alloc_candev(sizeof(*mod), 0);
+        if (!ndev) {
+                dev_err(dev, "unable to allocate CANdev\n");
+                ret = -ENOMEM;
+                goto out_return;
+        }
+
+        platform_set_drvdata(pdev, ndev);
+        mod = netdev_priv(ndev);
+        mod->ndev = ndev;
+        mod->dev = &pdev->dev;
+        mod->num = pdata->modno;
+        netif_napi_add(ndev, &mod->napi, ican3_napi, ICAN3_RX_BUFFERS);
+        spin_lock_init(&mod->lock);
+        init_completion(&mod->termination_comp);
+        init_completion(&mod->buserror_comp);
+
+        /* setup device-specific sysfs attributes */
+        ndev->sysfs_groups[0] = &ican3_sysfs_attr_group;
+
+        /* the first unallocated page in the DPM is 9 */
+        mod->free_page = DPM_FREE_START;
+
+        ndev->netdev_ops = &ican3_netdev_ops;
+        ndev->flags |= IFF_ECHO;
+        SET_NETDEV_DEV(ndev, &pdev->dev);
+
+        mod->can.clock.freq = ICAN3_CAN_CLOCK;
+        mod->can.bittiming_const = &ican3_bittiming_const;
+        mod->can.do_set_bittiming = ican3_set_bittiming;
+        mod->can.do_set_mode = ican3_set_mode;
+        mod->can.do_get_berr_counter = ican3_get_berr_counter;
+        mod->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES
+                                    | CAN_CTRLMODE_BERR_REPORTING;
+
+        /* find our IRQ number */
+        mod->irq = platform_get_irq(pdev, 0);
+        if (mod->irq < 0) {
+                dev_err(dev, "IRQ line not found\n");
+                ret = -ENODEV;
+                goto out_free_ndev;
+        }
+
+        ndev->irq = mod->irq;
+
+        /* get access to the MODULbus registers for this module */
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(dev, "MODULbus registers not found\n");
+                ret = -ENODEV;
+                goto out_free_ndev;
+        }
+
+        mod->dpm = ioremap(res->start, resource_size(res));
+        if (!mod->dpm) {
+                dev_err(dev, "MODULbus registers not ioremap\n");
+                ret = -ENOMEM;
+                goto out_free_ndev;
+        }
+
+        mod->dpmctrl = mod->dpm + DPM_PAGE_SIZE;
+
+        /* get access to the control registers for this module */
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+        if (!res) {
+                dev_err(dev, "CONTROL registers not found\n");
+                ret = -ENODEV;
+                goto out_iounmap_dpm;
+        }
+
+        mod->ctrl = ioremap(res->start, resource_size(res));
+        if (!mod->ctrl) {
+                dev_err(dev, "CONTROL registers not ioremap\n");
+                ret = -ENOMEM;
+                goto out_iounmap_dpm;
+        }
+
+        /* disable our IRQ, then hookup the IRQ handler */
+        iowrite8(1 << mod->num, &mod->ctrl->int_disable);
+        ret = request_irq(mod->irq, ican3_irq, IRQF_SHARED, DRV_NAME, mod);
+        if (ret) {
+                dev_err(dev, "unable to request IRQ\n");
+                goto out_iounmap_ctrl;
+        }
+
+        /* reset and initialize the CAN controller into fast mode */
+        napi_enable(&mod->napi);
+        ret = ican3_startup_module(mod);
+        if (ret) {
+                dev_err(dev, "%s: unable to start CANdev\n", __func__);
+                goto out_free_irq;
+        }
+
+        /* register with the Linux CAN layer */
+        ret = register_candev(ndev);
+        if (ret) {
+                dev_err(dev, "%s: unable to register CANdev\n", __func__);
+                goto out_free_irq;
+        }
+
+        dev_info(dev, "module %d: registered CAN device\n", pdata->modno);
+        return 0;
+
+out_free_irq:
+        napi_disable(&mod->napi);
+        iowrite8(1 << mod->num, &mod->ctrl->int_disable);
+        free_irq(mod->irq, mod);
+out_iounmap_ctrl:
+        iounmap(mod->ctrl);
+out_iounmap_dpm:
+        iounmap(mod->dpm);
+out_free_ndev:
+        free_candev(ndev);
+out_return:
+        return ret;
+}
+
+static int __devexit ican3_remove(struct platform_device *pdev)
+{
+        struct net_device *ndev = platform_get_drvdata(pdev);
+        struct ican3_dev *mod = netdev_priv(ndev);
+
+        /* unregister the netdevice, stop interrupts */
+        unregister_netdev(ndev);
+        napi_disable(&mod->napi);
+        iowrite8(1 << mod->num, &mod->ctrl->int_disable);
+        free_irq(mod->irq, mod);
+
+        /* put the module into reset */
+        ican3_shutdown_module(mod);
+
+        /* unmap all registers */
+        iounmap(mod->ctrl);
+        iounmap(mod->dpm);
+
+        free_candev(ndev);
+
+        return 0;
+}
+
+static struct platform_driver ican3_driver = {
+        .driver         = {
+                .name   = DRV_NAME,
+                .owner  = THIS_MODULE,
+        },
+        .probe          = ican3_probe,
+        .remove         = __devexit_p(ican3_remove),
+};
+
+static int __init ican3_init(void)
+{
+        return platform_driver_register(&ican3_driver);
+}
+
+static void __exit ican3_exit(void)
+{
+        platform_driver_unregister(&ican3_driver);
+}
+
+MODULE_AUTHOR("Ira W. Snyder <iws@ovro.caltech.edu>");
+MODULE_DESCRIPTION("Janz MODULbus VMOD-ICAN3 Driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:janz-ican3");
+
+module_init(ican3_init);
+module_exit(ican3_exit);
diff --git a/drivers/net/cnic.c b/drivers/net/cnic.c
index be90d3598bca..fe925663d39a 100644
--- a/drivers/net/cnic.c
+++ b/drivers/net/cnic.c
@@ -3367,13 +3367,9 @@ static int cnic_cm_shutdown(struct cnic_dev *dev)
 
 static void cnic_init_context(struct cnic_dev *dev, u32 cid)
 {
-        struct cnic_local *cp = dev->cnic_priv;
         u32 cid_addr;
         int i;
 
-        if (CHIP_NUM(cp) == CHIP_NUM_5709)
-                return;
-
         cid_addr = GET_CID_ADDR(cid);
 
         for (i = 0; i < CTX_SIZE; i += 4)
@@ -3530,14 +3526,11 @@ static void cnic_init_bnx2_tx_ring(struct cnic_dev *dev)
 
         sb_id = cp->status_blk_num;
         tx_cid = 20;
-        cnic_init_context(dev, tx_cid);
-        cnic_init_context(dev, tx_cid + 1);
         cp->tx_cons_ptr = &s_blk->status_tx_quick_consumer_index2;
         if (ethdev->drv_state & CNIC_DRV_STATE_USING_MSIX) {
                 struct status_block_msix *sblk = cp->status_blk.bnx2;
 
                 tx_cid = TX_TSS_CID + sb_id - 1;
-                cnic_init_context(dev, tx_cid);
                 CNIC_WR(dev, BNX2_TSCH_TSS_CFG, (sb_id << 24) |
                         (TX_TSS_CID << 7));
                 cp->tx_cons_ptr = &sblk->status_tx_quick_consumer_index;
@@ -3556,6 +3549,9 @@ static void cnic_init_bnx2_tx_ring(struct cnic_dev *dev)
                 offset2 = BNX2_L2CTX_TBDR_BHADDR_HI_XI;
                 offset3 = BNX2_L2CTX_TBDR_BHADDR_LO_XI;
         } else {
+                cnic_init_context(dev, tx_cid);
+                cnic_init_context(dev, tx_cid + 1);
+
                 offset0 = BNX2_L2CTX_TYPE;
                 offset1 = BNX2_L2CTX_CMD_TYPE;
                 offset2 = BNX2_L2CTX_TBDR_BHADDR_HI;
diff --git a/drivers/net/cnic_if.h b/drivers/net/cnic_if.h
index 110c62072e6f..0c55177db046 100644
--- a/drivers/net/cnic_if.h
+++ b/drivers/net/cnic_if.h
@@ -12,8 +12,8 @@
 #ifndef CNIC_IF_H
 #define CNIC_IF_H
 
-#define CNIC_MODULE_VERSION     "2.1.1"
-#define CNIC_MODULE_RELDATE     "Feb 22, 2010"
+#define CNIC_MODULE_VERSION     "2.1.2"
+#define CNIC_MODULE_RELDATE     "May 26, 2010"
 
 #define CNIC_ULP_RDMA           0
 #define CNIC_ULP_ISCSI          1
diff --git a/drivers/net/fec.c b/drivers/net/fec.c
index 326465ffbb23..ddf7a86cd466 100644
--- a/drivers/net/fec.c
+++ b/drivers/net/fec.c
@@ -681,6 +681,8 @@ static int fec_enet_mii_probe(struct net_device *dev)
         struct phy_device *phy_dev = NULL;
         int phy_addr;
 
+        fep->phy_dev = NULL;
+
         /* find the first phy */
         for (phy_addr = 0; phy_addr < PHY_MAX_ADDR; phy_addr++) {
                 if (fep->mii_bus->phy_map[phy_addr]) {
@@ -711,6 +713,11 @@ static int fec_enet_mii_probe(struct net_device *dev)
         fep->link = 0;
         fep->full_duplex = 0;
 
+        printk(KERN_INFO "%s: Freescale FEC PHY driver [%s] "
+                "(mii_bus:phy_addr=%s, irq=%d)\n", dev->name,
+                fep->phy_dev->drv->name, dev_name(&fep->phy_dev->dev),
+                fep->phy_dev->irq);
+
         return 0;
 }
 
@@ -756,13 +763,8 @@ static int fec_enet_mii_init(struct platform_device *pdev)
         if (mdiobus_register(fep->mii_bus))
                 goto err_out_free_mdio_irq;
 
-        if (fec_enet_mii_probe(dev) != 0)
-                goto err_out_unregister_bus;
-
         return 0;
 
-err_out_unregister_bus:
-        mdiobus_unregister(fep->mii_bus);
 err_out_free_mdio_irq:
         kfree(fep->mii_bus->irq);
 err_out_free_mdiobus:
@@ -915,7 +917,12 @@ fec_enet_open(struct net_device *dev)
         if (ret)
                 return ret;
 
-        /* schedule a link state check */
+        /* Probe and connect to PHY when open the interface */
+        ret = fec_enet_mii_probe(dev);
+        if (ret) {
+                fec_enet_free_buffers(dev);
+                return ret;
+        }
         phy_start(fep->phy_dev);
         netif_start_queue(dev);
         fep->opened = 1;
@@ -929,10 +936,12 @@ fec_enet_close(struct net_device *dev)
 
         /* Don't know what to do yet. */
         fep->opened = 0;
-        phy_stop(fep->phy_dev);
         netif_stop_queue(dev);
         fec_stop(dev);
 
+        if (fep->phy_dev)
+                phy_disconnect(fep->phy_dev);
+
         fec_enet_free_buffers(dev);
 
         return 0;
@@ -1316,11 +1325,6 @@ fec_probe(struct platform_device *pdev)
         if (ret)
                 goto failed_register;
 
-        printk(KERN_INFO "%s: Freescale FEC PHY driver [%s] "
-                "(mii_bus:phy_addr=%s, irq=%d)\n", ndev->name,
-                fep->phy_dev->drv->name, dev_name(&fep->phy_dev->dev),
-                fep->phy_dev->irq);
-
         return 0;
 
 failed_register:
diff --git a/drivers/net/hamradio/yam.c b/drivers/net/hamradio/yam.c
index 694132e04af6..4e7d1d0a2340 100644
--- a/drivers/net/hamradio/yam.c
+++ b/drivers/net/hamradio/yam.c
@@ -1151,8 +1151,7 @@ static int __init yam_init_driver(void)
                 dev = alloc_netdev(sizeof(struct yam_port), name,
                                    yam_setup);
                 if (!dev) {
-                        printk(KERN_ERR "yam: cannot allocate net device %s\n",
-                               dev->name);
+                        pr_err("yam: cannot allocate net device\n");
                         err = -ENOMEM;
                         goto error;
                 }
diff --git a/drivers/net/ll_temac.h b/drivers/net/ll_temac.h
index c03358434acb..522abe2ff25a 100644
--- a/drivers/net/ll_temac.h
+++ b/drivers/net/ll_temac.h
@@ -295,6 +295,10 @@ This option defaults to enabled (set) */
 
 #define MULTICAST_CAM_TABLE_NUM 4
 
+/* TEMAC Synthesis features */
+#define TEMAC_FEATURE_RX_CSUM  (1 << 0)
+#define TEMAC_FEATURE_TX_CSUM  (1 << 1)
+
 /* TX/RX CURDESC_PTR points to first descriptor */
 /* TX/RX TAILDESC_PTR points to last descriptor in linked list */
 
@@ -353,6 +357,7 @@ struct temac_local {
         struct mutex indirect_mutex;
         u32 options;                    /* Current options word */
         int last_link;
+        unsigned int temac_features;
 
         /* Buffer descriptors */
         struct cdmac_bd *tx_bd_v;
diff --git a/drivers/net/ll_temac_main.c b/drivers/net/ll_temac_main.c
index fa7620e28404..52dcc8495647 100644
--- a/drivers/net/ll_temac_main.c
+++ b/drivers/net/ll_temac_main.c
@@ -245,7 +245,7 @@ static int temac_dma_bd_init(struct net_device *ndev)
                                           CHNL_CTRL_IRQ_COAL_EN);
         /* 0x10220483 */
         /* 0x00100483 */
-        lp->dma_out(lp, RX_CHNL_CTRL, 0xff010000 |
+        lp->dma_out(lp, RX_CHNL_CTRL, 0xff070000 |
                                           CHNL_CTRL_IRQ_EN |
                                           CHNL_CTRL_IRQ_DLY_EN |
                                           CHNL_CTRL_IRQ_COAL_EN |
@@ -574,6 +574,10 @@ static void temac_start_xmit_done(struct net_device *ndev)
                 if (cur_p->app4)
                         dev_kfree_skb_irq((struct sk_buff *)cur_p->app4);
                 cur_p->app0 = 0;
+                cur_p->app1 = 0;
+                cur_p->app2 = 0;
+                cur_p->app3 = 0;
+                cur_p->app4 = 0;
 
                 ndev->stats.tx_packets++;
                 ndev->stats.tx_bytes += cur_p->len;
@@ -589,6 +593,29 @@ static void temac_start_xmit_done(struct net_device *ndev)
         netif_wake_queue(ndev);
 }
 
+static inline int temac_check_tx_bd_space(struct temac_local *lp, int num_frag)
+{
+        struct cdmac_bd *cur_p;
+        int tail;
+
+        tail = lp->tx_bd_tail;
+        cur_p = &lp->tx_bd_v[tail];
+
+        do {
+                if (cur_p->app0)
+                        return NETDEV_TX_BUSY;
+
+                tail++;
+                if (tail >= TX_BD_NUM)
+                        tail = 0;
+
+                cur_p = &lp->tx_bd_v[tail];
+                num_frag--;
+        } while (num_frag >= 0);
+
+        return 0;
+}
+
 static int temac_start_xmit(struct sk_buff *skb, struct net_device *ndev)
 {
         struct temac_local *lp = netdev_priv(ndev);
@@ -603,7 +630,7 @@ static int temac_start_xmit(struct sk_buff *skb, struct net_device *ndev)
         start_p = lp->tx_bd_p + sizeof(*lp->tx_bd_v) * lp->tx_bd_tail;
         cur_p = &lp->tx_bd_v[lp->tx_bd_tail];
 
-        if (cur_p->app0 & STS_CTRL_APP0_CMPLT) {
+        if (temac_check_tx_bd_space(lp, num_frag)) {
                 if (!netif_queue_stopped(ndev)) {
                         netif_stop_queue(ndev);
                         return NETDEV_TX_BUSY;
@@ -613,29 +640,14 @@ static int temac_start_xmit(struct sk_buff *skb, struct net_device *ndev)
 
         cur_p->app0 = 0;
         if (skb->ip_summed == CHECKSUM_PARTIAL) {
-                const struct iphdr *ip = ip_hdr(skb);
-                int length = 0, start = 0, insert = 0;
-
-                switch (ip->protocol) {
-                case IPPROTO_TCP:
-                        start = sizeof(struct iphdr) + ETH_HLEN;
-                        insert = sizeof(struct iphdr) + ETH_HLEN + 16;
-                        length = ip->tot_len - sizeof(struct iphdr);
-                        break;
-                case IPPROTO_UDP:
-                        start = sizeof(struct iphdr) + ETH_HLEN;
-                        insert = sizeof(struct iphdr) + ETH_HLEN + 6;
-                        length = ip->tot_len - sizeof(struct iphdr);
-                        break;
-                default:
-                        break;
-                }
-                cur_p->app1 = ((start << 16) | insert);
-                cur_p->app2 = csum_tcpudp_magic(ip->saddr, ip->daddr,
-                                                length, ip->protocol, 0);
-                skb->data[insert] = 0;
-                skb->data[insert + 1] = 0;
+                unsigned int csum_start_off = skb_transport_offset(skb);
+                unsigned int csum_index_off = csum_start_off + skb->csum_offset;
+
+                cur_p->app0 |= 1; /* TX Checksum Enabled */
+                cur_p->app1 = (csum_start_off << 16) | csum_index_off;
+                cur_p->app2 = 0;  /* initial checksum seed */
         }
+
         cur_p->app0 |= STS_CTRL_APP0_SOP;
         cur_p->len = skb_headlen(skb);
         cur_p->phys = dma_map_single(ndev->dev.parent, skb->data, skb->len,
@@ -699,6 +711,15 @@ static void ll_temac_recv(struct net_device *ndev)
                 skb->protocol = eth_type_trans(skb, ndev);
                 skb->ip_summed = CHECKSUM_NONE;
 
+                /* if we're doing rx csum offload, set it up */
+                if (((lp->temac_features & TEMAC_FEATURE_RX_CSUM) != 0) &&
+                        (skb->protocol == __constant_htons(ETH_P_IP)) &&
+                        (skb->len > 64)) {
+
+                        skb->csum = cur_p->app3 & 0xFFFF;
+                        skb->ip_summed = CHECKSUM_COMPLETE;
+                }
+
                 netif_rx(skb);
 
                 ndev->stats.rx_packets++;
@@ -883,6 +904,7 @@ temac_of_probe(struct of_device *op, const struct of_device_id *match)
         struct temac_local *lp;
         struct net_device *ndev;
         const void *addr;
+        __be32 *p;
         int size, rc = 0;
 
         /* Init network device structure */
@@ -926,6 +948,18 @@ temac_of_probe(struct of_device *op, const struct of_device_id *match)
                 goto nodev;
         }
 
+        /* Setup checksum offload, but default to off if not specified */
+        lp->temac_features = 0;
+        p = (__be32 *)of_get_property(op->dev.of_node, "xlnx,txcsum", NULL);
+        if (p && be32_to_cpu(*p)) {
+                lp->temac_features |= TEMAC_FEATURE_TX_CSUM;
+                /* Can checksum TCP/UDP over IPv4. */
+                ndev->features |= NETIF_F_IP_CSUM;
+        }
+        p = (__be32 *)of_get_property(op->dev.of_node, "xlnx,rxcsum", NULL);
+        if (p && be32_to_cpu(*p))
+                lp->temac_features |= TEMAC_FEATURE_RX_CSUM;
+
         /* Find the DMA node, map the DMA registers, and decode the DMA IRQs */
         np = of_parse_phandle(op->dev.of_node, "llink-connected", 0);
         if (!np) {
@@ -950,7 +984,7 @@ temac_of_probe(struct of_device *op, const struct of_device_id *match)
 
         lp->rx_irq = irq_of_parse_and_map(np, 0);
         lp->tx_irq = irq_of_parse_and_map(np, 1);
-        if (!lp->rx_irq || !lp->tx_irq) {
+        if ((lp->rx_irq == NO_IRQ) || (lp->tx_irq == NO_IRQ)) {
                 dev_err(&op->dev, "could not determine irqs\n");
                 rc = -ENOMEM;
                 goto nodev;
diff --git a/drivers/parport/parport_amiga.c b/drivers/parport/parport_amiga.c
index 1586e1caa2f5..8bef6d60f88b 100644
--- a/drivers/parport/parport_amiga.c
+++ b/drivers/parport/parport_amiga.c
@@ -18,6 +18,8 @@
 #include <linux/parport.h>
 #include <linux/ioport.h>
 #include <linux/interrupt.h>
+#include <linux/platform_device.h>
+
 #include <asm/setup.h>
 #include <asm/amigahw.h>
 #include <asm/irq.h>
@@ -31,7 +33,6 @@
 #define DPRINTK(x...)   do { } while (0)
 #endif
 
-static struct parport *this_port = NULL;
 
 static void amiga_write_data(struct parport *p, unsigned char data)
 {
@@ -227,18 +228,11 @@ static struct parport_operations pp_amiga_ops = {
 
 /* ----------- Initialisation code --------------------------------- */
 
-static int __init parport_amiga_init(void)
+static int __init amiga_parallel_probe(struct platform_device *pdev)
 {
         struct parport *p;
         int err;
 
-        if (!MACH_IS_AMIGA || !AMIGAHW_PRESENT(AMI_PARALLEL))
-                return -ENODEV;
-
-        err = -EBUSY;
-        if (!request_mem_region(CIAA_PHYSADDR-1+0x100, 0x100, "parallel"))
-                goto out_mem;
-
         ciaa.ddrb = 0xff;
         ciab.ddra &= 0xf8;
         mb();
@@ -246,41 +240,63 @@ static int __init parport_amiga_init(void)
         p = parport_register_port((unsigned long)&ciaa.prb, IRQ_AMIGA_CIAA_FLG,
                                    PARPORT_DMA_NONE, &pp_amiga_ops);
         if (!p)
-                goto out_port;
+                return -EBUSY;
 
-        err = request_irq(IRQ_AMIGA_CIAA_FLG, parport_irq_handler, 0, p->name, p);
+        err = request_irq(IRQ_AMIGA_CIAA_FLG, parport_irq_handler, 0, p->name,
+                          p);
         if (err)
                 goto out_irq;
 
-        this_port = p;
         printk(KERN_INFO "%s: Amiga built-in port using irq\n", p->name);
         /* XXX: set operating mode */
         parport_announce_port(p);
 
+        platform_set_drvdata(pdev, p);
+
         return 0;
 
 out_irq:
         parport_put_port(p);
-out_port:
-        release_mem_region(CIAA_PHYSADDR-1+0x100, 0x100);
-out_mem:
         return err;
 }
 
-static void __exit parport_amiga_exit(void)
+static int __exit amiga_parallel_remove(struct platform_device *pdev)
+{
+        struct parport *port = platform_get_drvdata(pdev);
+
+        parport_remove_port(port);
+        if (port->irq != PARPORT_IRQ_NONE)
+                free_irq(IRQ_AMIGA_CIAA_FLG, port);
+        parport_put_port(port);
+        platform_set_drvdata(pdev, NULL);
+        return 0;
+}
+
+static struct platform_driver amiga_parallel_driver = {
+        .remove = __exit_p(amiga_parallel_remove),
+        .driver   = {
+                .name   = "amiga-parallel",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init amiga_parallel_init(void)
+{
+        return platform_driver_probe(&amiga_parallel_driver,
+                                     amiga_parallel_probe);
+}
+
+module_init(amiga_parallel_init);
+
+static void __exit amiga_parallel_exit(void)
 {
-        parport_remove_port(this_port);
-        if (this_port->irq != PARPORT_IRQ_NONE)
-                free_irq(IRQ_AMIGA_CIAA_FLG, this_port);
-        parport_put_port(this_port);
-        release_mem_region(CIAA_PHYSADDR-1+0x100, 0x100);
+        platform_driver_unregister(&amiga_parallel_driver);
 }
 
+module_exit(amiga_parallel_exit);
 
 MODULE_AUTHOR("Joerg Dorchain <joerg@dorchain.net>");
 MODULE_DESCRIPTION("Parport Driver for Amiga builtin Port");
 MODULE_SUPPORTED_DEVICE("Amiga builtin Parallel Port");
 MODULE_LICENSE("GPL");
-
-module_init(parport_amiga_init)
-module_exit(parport_amiga_exit)
+MODULE_ALIAS("platform:amiga-parallel");
diff --git a/drivers/pci/pcie/aer/aerdrv.h b/drivers/pci/pcie/aer/aerdrv.h
index 7aaae2d2bd67..80c11d131499 100644
--- a/drivers/pci/pcie/aer/aerdrv.h
+++ b/drivers/pci/pcie/aer/aerdrv.h
@@ -130,4 +130,21 @@ static inline int aer_osc_setup(struct pcie_device *pciedev)
 }
 #endif
 
+#ifdef CONFIG_ACPI_APEI
+extern int pcie_aer_get_firmware_first(struct pci_dev *pci_dev);
+#else
+static inline int pcie_aer_get_firmware_first(struct pci_dev *pci_dev)
+{
+        if (pci_dev->__aer_firmware_first_valid)
+                return pci_dev->__aer_firmware_first;
+        return 0;
+}
+#endif
+
+static inline void pcie_aer_force_firmware_first(struct pci_dev *pci_dev,
+                                                 int enable)
+{
+        pci_dev->__aer_firmware_first = !!enable;
+        pci_dev->__aer_firmware_first_valid = 1;
+}
 #endif /* _AERDRV_H_ */
diff --git a/drivers/pci/pcie/aer/aerdrv_acpi.c b/drivers/pci/pcie/aer/aerdrv_acpi.c
index 04814087658d..f278d7b0d95d 100644
--- a/drivers/pci/pcie/aer/aerdrv_acpi.c
+++ b/drivers/pci/pcie/aer/aerdrv_acpi.c
@@ -16,6 +16,7 @@
 #include <linux/acpi.h>
 #include <linux/pci-acpi.h>
 #include <linux/delay.h>
+#include <acpi/apei.h>
 #include "aerdrv.h"
 
 /**
@@ -53,3 +54,79 @@ int aer_osc_setup(struct pcie_device *pciedev)
 
         return 0;
 }
+
+#ifdef CONFIG_ACPI_APEI
+static inline int hest_match_pci(struct acpi_hest_aer_common *p,
+                                 struct pci_dev *pci)
+{
+        return  (0           == pci_domain_nr(pci->bus) &&
+                 p->bus      == pci->bus->number &&
+                 p->device   == PCI_SLOT(pci->devfn) &&
+                 p->function == PCI_FUNC(pci->devfn));
+}
+
+struct aer_hest_parse_info {
+        struct pci_dev *pci_dev;
+        int firmware_first;
+};
+
+static int aer_hest_parse(struct acpi_hest_header *hest_hdr, void *data)
+{
+        struct aer_hest_parse_info *info = data;
+        struct acpi_hest_aer_common *p;
+        u8 pcie_type = 0;
+        u8 bridge = 0;
+        int ff = 0;
+
+        switch (hest_hdr->type) {
+        case ACPI_HEST_TYPE_AER_ROOT_PORT:
+                pcie_type = PCI_EXP_TYPE_ROOT_PORT;
+                break;
+        case ACPI_HEST_TYPE_AER_ENDPOINT:
+                pcie_type = PCI_EXP_TYPE_ENDPOINT;
+                break;
+        case ACPI_HEST_TYPE_AER_BRIDGE:
+                if ((info->pci_dev->class >> 16) == PCI_BASE_CLASS_BRIDGE)
+                        bridge = 1;
+                break;
+        default:
+                return 0;
+        }
+
+        p = (struct acpi_hest_aer_common *)(hest_hdr + 1);
+        if (p->flags & ACPI_HEST_GLOBAL) {
+                if ((info->pci_dev->is_pcie &&
+                     info->pci_dev->pcie_type == pcie_type) || bridge)
+                        ff = !!(p->flags & ACPI_HEST_FIRMWARE_FIRST);
+        } else
+                if (hest_match_pci(p, info->pci_dev))
+                        ff = !!(p->flags & ACPI_HEST_FIRMWARE_FIRST);
+        info->firmware_first = ff;
+
+        return 0;
+}
+
+static void aer_set_firmware_first(struct pci_dev *pci_dev)
+{
+        int rc;
+        struct aer_hest_parse_info info = {
+                .pci_dev        = pci_dev,
+                .firmware_first = 0,
+        };
+
+        rc = apei_hest_parse(aer_hest_parse, &info);
+
+        if (rc)
+                pci_dev->__aer_firmware_first = 0;
+        else
+                pci_dev->__aer_firmware_first = info.firmware_first;
+        pci_dev->__aer_firmware_first_valid = 1;
+}
+
+int pcie_aer_get_firmware_first(struct pci_dev *dev)
+{
+        if (!dev->__aer_firmware_first_valid)
+                aer_set_firmware_first(dev);
+        return dev->__aer_firmware_first;
+}
+#endif
diff --git a/drivers/pci/pcie/aer/aerdrv_core.c b/drivers/pci/pcie/aer/aerdrv_core.c
index df2d686fe3dd..8af4f619bba2 100644
--- a/drivers/pci/pcie/aer/aerdrv_core.c
+++ b/drivers/pci/pcie/aer/aerdrv_core.c
@@ -36,7 +36,7 @@ int pci_enable_pcie_error_reporting(struct pci_dev *dev)
         u16 reg16 = 0;
         int pos;
 
-        if (dev->aer_firmware_first)
+        if (pcie_aer_get_firmware_first(dev))
                 return -EIO;
 
         pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ERR);
@@ -63,7 +63,7 @@ int pci_disable_pcie_error_reporting(struct pci_dev *dev)
         u16 reg16 = 0;
         int pos;
 
-        if (dev->aer_firmware_first)
+        if (pcie_aer_get_firmware_first(dev))
                 return -EIO;
 
         pos = pci_pcie_cap(dev);
@@ -771,7 +771,7 @@ void aer_isr(struct work_struct *work)
  */
 int aer_init(struct pcie_device *dev)
 {
-        if (dev->port->aer_firmware_first) {
+        if (pcie_aer_get_firmware_first(dev->port)) {
                 dev_printk(KERN_DEBUG, &dev->device,
                            "PCIe errors handled by platform firmware.\n");
                 goto out;
@@ -785,7 +785,7 @@ out:
         if (forceload) {
                 dev_printk(KERN_DEBUG, &dev->device,
                            "aerdrv forceload requested.\n");
-                dev->port->aer_firmware_first = 0;
+                pcie_aer_force_firmware_first(dev->port, 0);
                 return 0;
         }
         return -ENXIO;
diff --git a/drivers/pci/probe.c b/drivers/pci/probe.c
index c82548afcd5c..f4adba2d1dd3 100644
--- a/drivers/pci/probe.c
+++ b/drivers/pci/probe.c
@@ -10,7 +10,6 @@
 #include <linux/module.h>
 #include <linux/cpumask.h>
 #include <linux/pci-aspm.h>
-#include <acpi/acpi_hest.h>
 #include "pci.h"
 
 #define CARDBUS_LATENCY_TIMER   176     /* secondary latency timer */
@@ -904,12 +903,6 @@ void set_pcie_hotplug_bridge(struct pci_dev *pdev)
                 pdev->is_hotplug_bridge = 1;
 }
 
-static void set_pci_aer_firmware_first(struct pci_dev *pdev)
-{
-        if (acpi_hest_firmware_first_pci(pdev))
-                pdev->aer_firmware_first = 1;
-}
-
 #define LEGACY_IO_RESOURCE      (IORESOURCE_IO | IORESOURCE_PCI_FIXED)
 
 /**
@@ -939,7 +932,6 @@ int pci_setup_device(struct pci_dev *dev)
         dev->multifunction = !!(hdr_type & 0x80);
         dev->error_state = pci_channel_io_normal;
         set_pcie_port_type(dev);
-        set_pci_aer_firmware_first(dev);
 
         list_for_each_entry(slot, &dev->bus->slots, list)
                 if (PCI_SLOT(dev->devfn) == slot->number)
diff --git a/drivers/rapidio/Kconfig b/drivers/rapidio/Kconfig
index c32822ad84a4..070211a5955c 100644
--- a/drivers/rapidio/Kconfig
+++ b/drivers/rapidio/Kconfig
@@ -8,3 +8,27 @@ config RAPIDIO_DISC_TIMEOUT
         ---help---
           Amount of time a discovery node waits for a host to complete
           enumeration before giving up.
+
+config RAPIDIO_ENABLE_RX_TX_PORTS
+        bool "Enable RapidIO Input/Output Ports"
+        depends on RAPIDIO
+        ---help---
+          The RapidIO specification describes a Output port transmit
+          enable and a Input port receive enable. The recommended state
+          for Input ports and Output ports should be disabled. When
+          this switch is set the RapidIO subsystem will enable all
+          ports for Input/Output direction to allow other traffic
+          than Maintenance transfers.
+
+source "drivers/rapidio/switches/Kconfig"
+
+config RAPIDIO_DEBUG
+        bool "RapidIO subsystem debug messages"
+        depends on RAPIDIO
+        help
+          Say Y here if you want the RapidIO subsystem to produce a bunch of
+          debug messages to the system log. Select this if you are having a
+          problem with the RapidIO subsystem and want to see more of what is
+          going on.
+
+          If you are unsure about this, say N here.
diff --git a/drivers/rapidio/Makefile b/drivers/rapidio/Makefile
index 7c0e1818de51..b6139fe187bf 100644
--- a/drivers/rapidio/Makefile
+++ b/drivers/rapidio/Makefile
@@ -4,3 +4,7 @@
 obj-y += rio.o rio-access.o rio-driver.o rio-scan.o rio-sysfs.o
 
 obj-$(CONFIG_RAPIDIO)           += switches/
+
+ifeq ($(CONFIG_RAPIDIO_DEBUG),y)
+EXTRA_CFLAGS += -DDEBUG
+endif
diff --git a/drivers/rapidio/rio-scan.c b/drivers/rapidio/rio-scan.c
index 45415096c294..8070e074c739 100644
--- a/drivers/rapidio/rio-scan.c
+++ b/drivers/rapidio/rio-scan.c
@@ -4,6 +4,14 @@
  * Copyright 2005 MontaVista Software, Inc.
  * Matt Porter <mporter@kernel.crashing.org>
  *
+ * Copyright 2009 Integrated Device Technology, Inc.
+ * Alex Bounine <alexandre.bounine@idt.com>
+ * - Added Port-Write/Error Management initialization and handling
+ *
+ * Copyright 2009 Sysgo AG
+ * Thomas Moll <thomas.moll@sysgo.com>
+ * - Added Input- Output- enable functionality, to allow full communication
+ *
  * 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
@@ -31,15 +39,16 @@
 LIST_HEAD(rio_devices);
 static LIST_HEAD(rio_switches);
 
-#define RIO_ENUM_CMPL_MAGIC     0xdeadbeef
-
 static void rio_enum_timeout(unsigned long);
 
+static void rio_init_em(struct rio_dev *rdev);
+
 DEFINE_SPINLOCK(rio_global_list_lock);
 
 static int next_destid = 0;
 static int next_switchid = 0;
 static int next_net = 0;
+static int next_comptag;
 
 static struct timer_list rio_enum_timer =
 TIMER_INITIALIZER(rio_enum_timeout, 0, 0);
@@ -52,12 +61,6 @@ static int rio_mport_phys_table[] = {
         -1,
 };
 
-static int rio_sport_phys_table[] = {
-        RIO_EFB_PAR_EP_FREE_ID,
-        RIO_EFB_SER_EP_FREE_ID,
-        -1,
-};
-
 /**
  * rio_get_device_id - Get the base/extended device id for a device
  * @port: RIO master port
@@ -118,12 +121,26 @@ static int rio_clear_locks(struct rio_mport *port)
         u32 result;
         int ret = 0;
 
-        /* Write component tag CSR magic complete value */
-        rio_local_write_config_32(port, RIO_COMPONENT_TAG_CSR,
-                                  RIO_ENUM_CMPL_MAGIC);
-        list_for_each_entry(rdev, &rio_devices, global_list)
-            rio_write_config_32(rdev, RIO_COMPONENT_TAG_CSR,
-                                RIO_ENUM_CMPL_MAGIC);
+        /* Assign component tag to all devices */
+        next_comptag = 1;
+        rio_local_write_config_32(port, RIO_COMPONENT_TAG_CSR, next_comptag++);
+
+        list_for_each_entry(rdev, &rio_devices, global_list) {
+                /* Mark device as discovered */
+                rio_read_config_32(rdev,
+                                   rdev->phys_efptr + RIO_PORT_GEN_CTL_CSR,
+                                   &result);
+                rio_write_config_32(rdev,
+                                    rdev->phys_efptr + RIO_PORT_GEN_CTL_CSR,
+                                    result | RIO_PORT_GEN_DISCOVERED);
+
+                rio_write_config_32(rdev, RIO_COMPONENT_TAG_CSR, next_comptag);
+                rdev->comp_tag = next_comptag++;
+                if (next_comptag >= 0x10000) {
+                        pr_err("RIO: Component Tag Counter Overflow\n");
+                        break;
+                }
+        }
 
         /* Release host device id locks */
         rio_local_write_config_32(port, RIO_HOST_DID_LOCK_CSR,
@@ -229,27 +246,37 @@ static int rio_is_switch(struct rio_dev *rdev)
 }
 
 /**
- * rio_route_set_ops- Sets routing operations for a particular vendor switch
+ * rio_switch_init - Sets switch operations for a particular vendor switch
  * @rdev: RIO device
+ * @do_enum: Enumeration/Discovery mode flag
  *
- * Searches the RIO route ops table for known switch types. If the vid
- * and did match a switch table entry, then set the add_entry() and
- * get_entry() ops to the table entry values.
+ * Searches the RIO switch ops table for known switch types. If the vid
+ * and did match a switch table entry, then call switch initialization
+ * routine to setup switch-specific routines.
  */
-static void rio_route_set_ops(struct rio_dev *rdev)
+static void rio_switch_init(struct rio_dev *rdev, int do_enum)
 {
-        struct rio_route_ops *cur = __start_rio_route_ops;
-        struct rio_route_ops *end = __end_rio_route_ops;
+        struct rio_switch_ops *cur = __start_rio_switch_ops;
+        struct rio_switch_ops *end = __end_rio_switch_ops;
 
         while (cur < end) {
                 if ((cur->vid == rdev->vid) && (cur->did == rdev->did)) {
-                        pr_debug("RIO: adding routing ops for %s\n", rio_name(rdev));
-                        rdev->rswitch->add_entry = cur->add_hook;
-                        rdev->rswitch->get_entry = cur->get_hook;
+                        pr_debug("RIO: calling init routine for %s\n",
+                                 rio_name(rdev));
+                        cur->init_hook(rdev, do_enum);
+                        break;
                 }
                 cur++;
         }
 
+        if ((cur >= end) && (rdev->pef & RIO_PEF_STD_RT)) {
+                pr_debug("RIO: adding STD routing ops for %s\n",
+                        rio_name(rdev));
+                rdev->rswitch->add_entry = rio_std_route_add_entry;
+                rdev->rswitch->get_entry = rio_std_route_get_entry;
+                rdev->rswitch->clr_table = rio_std_route_clr_table;
+        }
+
         if (!rdev->rswitch->add_entry || !rdev->rswitch->get_entry)
                 printk(KERN_ERR "RIO: missing routing ops for %s\n",
                        rio_name(rdev));
@@ -281,6 +308,65 @@ static int __devinit rio_add_device(struct rio_dev *rdev)
 }
 
 /**
+ * rio_enable_rx_tx_port - enable input reciever and output transmitter of
+ * given port
+ * @port: Master port associated with the RIO network
+ * @local: local=1 select local port otherwise a far device is reached
+ * @destid: Destination ID of the device to check host bit
+ * @hopcount: Number of hops to reach the target
+ * @port_num: Port (-number on switch) to enable on a far end device
+ *
+ * Returns 0 or 1 from on General Control Command and Status Register
+ * (EXT_PTR+0x3C)
+ */
+inline int rio_enable_rx_tx_port(struct rio_mport *port,
+                                 int local, u16 destid,
+                                 u8 hopcount, u8 port_num) {
+#ifdef CONFIG_RAPIDIO_ENABLE_RX_TX_PORTS
+        u32 regval;
+        u32 ext_ftr_ptr;
+
+        /*
+        * enable rx input tx output port
+        */
+        pr_debug("rio_enable_rx_tx_port(local = %d, destid = %d, hopcount = "
+                 "%d, port_num = %d)\n", local, destid, hopcount, port_num);
+
+        ext_ftr_ptr = rio_mport_get_physefb(port, local, destid, hopcount);
+
+        if (local) {
+                rio_local_read_config_32(port, ext_ftr_ptr +
+                                RIO_PORT_N_CTL_CSR(0),
+                                &regval);
+        } else {
+                if (rio_mport_read_config_32(port, destid, hopcount,
+                ext_ftr_ptr + RIO_PORT_N_CTL_CSR(port_num), &regval) < 0)
+                        return -EIO;
+        }
+
+        if (regval & RIO_PORT_N_CTL_P_TYP_SER) {
+                /* serial */
+                regval = regval | RIO_PORT_N_CTL_EN_RX_SER
+                                | RIO_PORT_N_CTL_EN_TX_SER;
+        } else {
+                /* parallel */
+                regval = regval | RIO_PORT_N_CTL_EN_RX_PAR
+                                | RIO_PORT_N_CTL_EN_TX_PAR;
+        }
+
+        if (local) {
+                rio_local_write_config_32(port, ext_ftr_ptr +
+                                          RIO_PORT_N_CTL_CSR(0), regval);
+        } else {
+                if (rio_mport_write_config_32(port, destid, hopcount,
+                    ext_ftr_ptr + RIO_PORT_N_CTL_CSR(port_num), regval) < 0)
+                        return -EIO;
+        }
+#endif
+        return 0;
+}
+
+/**
  * rio_setup_device- Allocates and sets up a RIO device
  * @net: RIO network
  * @port: Master port to send transactions
@@ -325,8 +411,14 @@ static struct rio_dev __devinit *rio_setup_device(struct rio_net *net,
         rdev->asm_rev = result >> 16;
         rio_mport_read_config_32(port, destid, hopcount, RIO_PEF_CAR,
                                  &rdev->pef);
-        if (rdev->pef & RIO_PEF_EXT_FEATURES)
+        if (rdev->pef & RIO_PEF_EXT_FEATURES) {
                 rdev->efptr = result & 0xffff;
+                rdev->phys_efptr = rio_mport_get_physefb(port, 0, destid,
+                                                         hopcount);
+
+                rdev->em_efptr = rio_mport_get_feature(port, 0, destid,
+                                                hopcount, RIO_EFB_ERR_MGMNT);
+        }
 
         rio_mport_read_config_32(port, destid, hopcount, RIO_SRC_OPS_CAR,
                                  &rdev->src_ops);
@@ -349,12 +441,13 @@ static struct rio_dev __devinit *rio_setup_device(struct rio_net *net,
         if (rio_is_switch(rdev)) {
                 rio_mport_read_config_32(port, destid, hopcount,
                                          RIO_SWP_INFO_CAR, &rdev->swpinfo);
-                rswitch = kmalloc(sizeof(struct rio_switch), GFP_KERNEL);
+                rswitch = kzalloc(sizeof(struct rio_switch), GFP_KERNEL);
                 if (!rswitch)
                         goto cleanup;
                 rswitch->switchid = next_switchid;
                 rswitch->hopcount = hopcount;
                 rswitch->destid = destid;
+                rswitch->port_ok = 0;
                 rswitch->route_table = kzalloc(sizeof(u8)*
                                         RIO_MAX_ROUTE_ENTRIES(port->sys_size),
                                         GFP_KERNEL);
@@ -367,13 +460,22 @@ static struct rio_dev __devinit *rio_setup_device(struct rio_net *net,
                 rdev->rswitch = rswitch;
                 dev_set_name(&rdev->dev, "%02x:s:%04x", rdev->net->id,
                              rdev->rswitch->switchid);
-                rio_route_set_ops(rdev);
+                rio_switch_init(rdev, do_enum);
+
+                if (do_enum && rdev->rswitch->clr_table)
+                        rdev->rswitch->clr_table(port, destid, hopcount,
+                                                 RIO_GLOBAL_TABLE);
 
                 list_add_tail(&rswitch->node, &rio_switches);
 
-        } else
+        } else {
+                if (do_enum)
+                        /*Enable Input Output Port (transmitter reviever)*/
+                        rio_enable_rx_tx_port(port, 0, destid, hopcount, 0);
+
                 dev_set_name(&rdev->dev, "%02x:e:%04x", rdev->net->id,
                              rdev->destid);
+        }
 
         rdev->dev.bus = &rio_bus_type;
 
@@ -414,23 +516,29 @@ cleanup:
  *
  * Reads the port error status CSR for a particular switch port to
  * determine if the port has an active link.  Returns
- * %PORT_N_ERR_STS_PORT_OK if the port is active or %0 if it is
+ * %RIO_PORT_N_ERR_STS_PORT_OK if the port is active or %0 if it is
  * inactive.
  */
 static int
 rio_sport_is_active(struct rio_mport *port, u16 destid, u8 hopcount, int sport)
 {
-        u32 result;
+        u32 result = 0;
         u32 ext_ftr_ptr;
 
-        int *entry = rio_sport_phys_table;
-
-        do {
-                if ((ext_ftr_ptr =
-                     rio_mport_get_feature(port, 0, destid, hopcount, *entry)))
+        ext_ftr_ptr = rio_mport_get_efb(port, 0, destid, hopcount, 0);
 
+        while (ext_ftr_ptr) {
+                rio_mport_read_config_32(port, destid, hopcount,
+                                         ext_ftr_ptr, &result);
+                result = RIO_GET_BLOCK_ID(result);
+                if ((result == RIO_EFB_SER_EP_FREE_ID) ||
+                    (result == RIO_EFB_SER_EP_FREE_ID_V13P) ||
+                    (result == RIO_EFB_SER_EP_FREC_ID))
                         break;
-        } while (*++entry >= 0);
+
+                ext_ftr_ptr = rio_mport_get_efb(port, 0, destid, hopcount,
+                                                ext_ftr_ptr);
+        }
 
         if (ext_ftr_ptr)
                 rio_mport_read_config_32(port, destid, hopcount,
@@ -438,7 +546,81 @@ rio_sport_is_active(struct rio_mport *port, u16 destid, u8 hopcount, int sport)
                                          RIO_PORT_N_ERR_STS_CSR(sport),
                                          &result);
 
-        return (result & PORT_N_ERR_STS_PORT_OK);
+        return result & RIO_PORT_N_ERR_STS_PORT_OK;
+}
+
+/**
+ * rio_lock_device - Acquires host device lock for specified device
+ * @port: Master port to send transaction
+ * @destid: Destination ID for device/switch
+ * @hopcount: Hopcount to reach switch
+ * @wait_ms: Max wait time in msec (0 = no timeout)
+ *
+ * Attepts to acquire host device lock for specified device
+ * Returns 0 if device lock acquired or EINVAL if timeout expires.
+ */
+static int
+rio_lock_device(struct rio_mport *port, u16 destid, u8 hopcount, int wait_ms)
+{
+        u32 result;
+        int tcnt = 0;
+
+        /* Attempt to acquire device lock */
+        rio_mport_write_config_32(port, destid, hopcount,
+                                  RIO_HOST_DID_LOCK_CSR, port->host_deviceid);
+        rio_mport_read_config_32(port, destid, hopcount,
+                                 RIO_HOST_DID_LOCK_CSR, &result);
+
+        while (result != port->host_deviceid) {
+                if (wait_ms != 0 && tcnt == wait_ms) {
+                        pr_debug("RIO: timeout when locking device %x:%x\n",
+                                destid, hopcount);
+                        return -EINVAL;
+                }
+
+                /* Delay a bit */
+                mdelay(1);
+                tcnt++;
+                /* Try to acquire device lock again */
+                rio_mport_write_config_32(port, destid,
+                        hopcount,
+                        RIO_HOST_DID_LOCK_CSR,
+                        port->host_deviceid);
+                rio_mport_read_config_32(port, destid,
+                        hopcount,
+                        RIO_HOST_DID_LOCK_CSR, &result);
+        }
+
+        return 0;
+}
+
+/**
+ * rio_unlock_device - Releases host device lock for specified device
+ * @port: Master port to send transaction
+ * @destid: Destination ID for device/switch
+ * @hopcount: Hopcount to reach switch
+ *
+ * Returns 0 if device lock released or EINVAL if fails.
+ */
+static int
+rio_unlock_device(struct rio_mport *port, u16 destid, u8 hopcount)
+{
+        u32 result;
+
+        /* Release device lock */
+        rio_mport_write_config_32(port, destid,
+                                  hopcount,
+                                  RIO_HOST_DID_LOCK_CSR,
+                                  port->host_deviceid);
+        rio_mport_read_config_32(port, destid, hopcount,
+                RIO_HOST_DID_LOCK_CSR, &result);
+        if ((result & 0xffff) != 0xffff) {
+                pr_debug("RIO: badness when releasing device lock %x:%x\n",
+                         destid, hopcount);
+                return -EINVAL;
+        }
+
+        return 0;
 }
 
 /**
@@ -448,6 +630,7 @@ rio_sport_is_active(struct rio_mport *port, u16 destid, u8 hopcount, int sport)
  * @table: Routing table ID
  * @route_destid: Destination ID to be routed
  * @route_port: Port number to be routed
+ * @lock: lock switch device flag
  *
  * Calls the switch specific add_entry() method to add a route entry
  * on a switch. The route table can be specified using the @table
@@ -456,12 +639,26 @@ rio_sport_is_active(struct rio_mport *port, u16 destid, u8 hopcount, int sport)
  * %RIO_GLOBAL_TABLE in @table. Returns %0 on success or %-EINVAL
  * on failure.
  */
-static int rio_route_add_entry(struct rio_mport *mport, struct rio_switch *rswitch,
-                               u16 table, u16 route_destid, u8 route_port)
+static int
+rio_route_add_entry(struct rio_mport *mport, struct rio_switch *rswitch,
+                    u16 table, u16 route_destid, u8 route_port, int lock)
 {
-        return rswitch->add_entry(mport, rswitch->destid,
+        int rc;
+
+        if (lock) {
+                rc = rio_lock_device(mport, rswitch->destid,
+                                     rswitch->hopcount, 1000);
+                if (rc)
+                        return rc;
+        }
+
+        rc = rswitch->add_entry(mport, rswitch->destid,
                                         rswitch->hopcount, table,
                                         route_destid, route_port);
+        if (lock)
+                rio_unlock_device(mport, rswitch->destid, rswitch->hopcount);
+
+        return rc;
 }
 
 /**
@@ -471,6 +668,7 @@ static int rio_route_add_entry(struct rio_mport *mport, struct rio_switch *rswit
  * @table: Routing table ID
  * @route_destid: Destination ID to be routed
  * @route_port: Pointer to read port number into
+ * @lock: lock switch device flag
  *
  * Calls the switch specific get_entry() method to read a route entry
  * in a switch. The route table can be specified using the @table
@@ -481,11 +679,24 @@ static int rio_route_add_entry(struct rio_mport *mport, struct rio_switch *rswit
  */
 static int
 rio_route_get_entry(struct rio_mport *mport, struct rio_switch *rswitch, u16 table,
-                    u16 route_destid, u8 * route_port)
+                    u16 route_destid, u8 *route_port, int lock)
 {
-        return rswitch->get_entry(mport, rswitch->destid,
+        int rc;
+
+        if (lock) {
+                rc = rio_lock_device(mport, rswitch->destid,
+                                     rswitch->hopcount, 1000);
+                if (rc)
+                        return rc;
+        }
+
+        rc = rswitch->get_entry(mport, rswitch->destid,
                                         rswitch->hopcount, table,
                                         route_destid, route_port);
+        if (lock)
+                rio_unlock_device(mport, rswitch->destid, rswitch->hopcount);
+
+        return rc;
 }
 
 /**
@@ -625,14 +836,14 @@ static int __devinit rio_enum_peer(struct rio_net *net, struct rio_mport *port,
                 sw_inport = rio_get_swpinfo_inport(port,
                                 RIO_ANY_DESTID(port->sys_size), hopcount);
                 rio_route_add_entry(port, rdev->rswitch, RIO_GLOBAL_TABLE,
-                                    port->host_deviceid, sw_inport);
+                                    port->host_deviceid, sw_inport, 0);
                 rdev->rswitch->route_table[port->host_deviceid] = sw_inport;
 
                 for (destid = 0; destid < next_destid; destid++) {
                         if (destid == port->host_deviceid)
                                 continue;
                         rio_route_add_entry(port, rdev->rswitch, RIO_GLOBAL_TABLE,
-                                            destid, sw_inport);
+                                            destid, sw_inport, 0);
                         rdev->rswitch->route_table[destid] = sw_inport;
                 }
 
@@ -644,8 +855,15 @@ static int __devinit rio_enum_peer(struct rio_net *net, struct rio_mport *port,
                     rio_name(rdev), rdev->vid, rdev->did, num_ports);
                 sw_destid = next_destid;
                 for (port_num = 0; port_num < num_ports; port_num++) {
-                        if (sw_inport == port_num)
+                        /*Enable Input Output Port (transmitter reviever)*/
+                        rio_enable_rx_tx_port(port, 0,
+                                              RIO_ANY_DESTID(port->sys_size),
+                                              hopcount, port_num);
+
+                        if (sw_inport == port_num) {
+                                rdev->rswitch->port_ok |= (1 << port_num);
                                 continue;
+                        }
 
                         cur_destid = next_destid;
 
@@ -655,10 +873,11 @@ static int __devinit rio_enum_peer(struct rio_net *net, struct rio_mport *port,
                                 pr_debug(
                                     "RIO: scanning device on port %d\n",
                                     port_num);
+                                rdev->rswitch->port_ok |= (1 << port_num);
                                 rio_route_add_entry(port, rdev->rswitch,
                                                 RIO_GLOBAL_TABLE,
                                                 RIO_ANY_DESTID(port->sys_size),
-                                                port_num);
+                                                port_num, 0);
 
                                 if (rio_enum_peer(net, port, hopcount + 1) < 0)
                                         return -1;
@@ -672,15 +891,35 @@ static int __devinit rio_enum_peer(struct rio_net *net, struct rio_mport *port,
                                                 rio_route_add_entry(port, rdev->rswitch,
                                                                     RIO_GLOBAL_TABLE,
                                                                     destid,
-                                                                    port_num);
+                                                                    port_num,
+                                                                    0);
                                                 rdev->rswitch->
                                                     route_table[destid] =
                                                     port_num;
                                         }
                                 }
+                        } else {
+                                /* If switch supports Error Management,
+                                 * set PORT_LOCKOUT bit for unused port
+                                 */
+                                if (rdev->em_efptr)
+                                        rio_set_port_lockout(rdev, port_num, 1);
+
+                                rdev->rswitch->port_ok &= ~(1 << port_num);
                         }
                 }
 
+                /* Direct Port-write messages to the enumeratiing host */
+                if ((rdev->src_ops & RIO_SRC_OPS_PORT_WRITE) &&
+                    (rdev->em_efptr)) {
+                        rio_write_config_32(rdev,
+                                        rdev->em_efptr + RIO_EM_PW_TGT_DEVID,
+                                        (port->host_deviceid << 16) |
+                                        (port->sys_size << 15));
+                }
+
+                rio_init_em(rdev);
+
                 /* Check for empty switch */
                 if (next_destid == sw_destid) {
                         next_destid++;
@@ -700,21 +939,16 @@ static int __devinit rio_enum_peer(struct rio_net *net, struct rio_mport *port,
  * rio_enum_complete- Tests if enumeration of a network is complete
  * @port: Master port to send transaction
  *
- * Tests the Component Tag CSR for presence of the magic enumeration
- * complete flag. Return %1 if enumeration is complete or %0 if
+ * Tests the Component Tag CSR for non-zero value (enumeration
+ * complete flag). Return %1 if enumeration is complete or %0 if
  * enumeration is incomplete.
  */
 static int rio_enum_complete(struct rio_mport *port)
 {
         u32 tag_csr;
-        int ret = 0;
 
         rio_local_read_config_32(port, RIO_COMPONENT_TAG_CSR, &tag_csr);
-
-        if (tag_csr == RIO_ENUM_CMPL_MAGIC)
-                ret = 1;
-
-        return ret;
+        return (tag_csr & 0xffff) ? 1 : 0;
 }
 
 /**
@@ -763,17 +997,21 @@ rio_disc_peer(struct rio_net *net, struct rio_mport *port, u16 destid,
                                 pr_debug(
                                     "RIO: scanning device on port %d\n",
                                     port_num);
+
+                                rio_lock_device(port, destid, hopcount, 1000);
+
                                 for (ndestid = 0;
                                      ndestid < RIO_ANY_DESTID(port->sys_size);
                                      ndestid++) {
                                         rio_route_get_entry(port, rdev->rswitch,
                                                             RIO_GLOBAL_TABLE,
                                                             ndestid,
-                                                            &route_port);
+                                                            &route_port, 0);
                                         if (route_port == port_num)
                                                 break;
                                 }
 
+                                rio_unlock_device(port, destid, hopcount);
                                 if (rio_disc_peer
                                     (net, port, ndestid, hopcount + 1) < 0)
                                         return -1;
@@ -792,7 +1030,7 @@ rio_disc_peer(struct rio_net *net, struct rio_mport *port, u16 destid,
  *
  * Reads the port error status CSR for the master port to
  * determine if the port has an active link.  Returns
- * %PORT_N_ERR_STS_PORT_OK if the  master port is active
+ * %RIO_PORT_N_ERR_STS_PORT_OK if the  master port is active
  * or %0 if it is inactive.
  */
 static int rio_mport_is_active(struct rio_mport *port)
@@ -813,7 +1051,7 @@ static int rio_mport_is_active(struct rio_mport *port)
                                          RIO_PORT_N_ERR_STS_CSR(port->index),
                                          &result);
 
-        return (result & PORT_N_ERR_STS_PORT_OK);
+        return result & RIO_PORT_N_ERR_STS_PORT_OK;
 }
 
 /**
@@ -866,12 +1104,17 @@ static void rio_update_route_tables(struct rio_mport *port)
                                 continue;
 
                         if (RIO_INVALID_ROUTE == rswitch->route_table[destid]) {
+                                /* Skip if destid ends in empty switch*/
+                                if (rswitch->destid == destid)
+                                        continue;
 
                                 sport = rio_get_swpinfo_inport(port,
                                                 rswitch->destid, rswitch->hopcount);
 
                                 if (rswitch->add_entry) {
-                                        rio_route_add_entry(port, rswitch, RIO_GLOBAL_TABLE, destid, sport);
+                                        rio_route_add_entry(port, rswitch,
+                                                RIO_GLOBAL_TABLE, destid,
+                                                sport, 0);
                                         rswitch->route_table[destid] = sport;
                                 }
                         }
@@ -880,6 +1123,32 @@ static void rio_update_route_tables(struct rio_mport *port)
 }
 
 /**
+ * rio_init_em - Initializes RIO Error Management (for switches)
+ * @rdev: RIO device
+ *
+ * For each enumerated switch, call device-specific error management
+ * initialization routine (if supplied by the switch driver).
+ */
+static void rio_init_em(struct rio_dev *rdev)
+{
+        if (rio_is_switch(rdev) && (rdev->em_efptr) &&
+            (rdev->rswitch->em_init)) {
+                rdev->rswitch->em_init(rdev);
+        }
+}
+
+/**
+ * rio_pw_enable - Enables/disables port-write handling by a master port
+ * @port: Master port associated with port-write handling
+ * @enable:  1=enable,  0=disable
+ */
+static void rio_pw_enable(struct rio_mport *port, int enable)
+{
+        if (port->ops->pwenable)
+                port->ops->pwenable(port, enable);
+}
+
+/**
  * rio_enum_mport- Start enumeration through a master port
  * @mport: Master port to send transactions
  *
@@ -911,6 +1180,10 @@ int __devinit rio_enum_mport(struct rio_mport *mport)
                         rc = -ENOMEM;
                         goto out;
                 }
+
+                /* Enable Input Output Port (transmitter reviever) */
+                rio_enable_rx_tx_port(mport, 1, 0, 0, 0);
+
                 if (rio_enum_peer(net, mport, 0) < 0) {
                         /* A higher priority host won enumeration, bail. */
                         printk(KERN_INFO
@@ -922,6 +1195,7 @@ int __devinit rio_enum_mport(struct rio_mport *mport)
                 }
                 rio_update_route_tables(mport);
                 rio_clear_locks(mport);
+                rio_pw_enable(mport, 1);
         } else {
                 printk(KERN_INFO "RIO: master port %d link inactive\n",
                        mport->id);
@@ -945,15 +1219,22 @@ static void rio_build_route_tables(void)
         u8 sport;
 
         list_for_each_entry(rdev, &rio_devices, global_list)
-            if (rio_is_switch(rdev))
-                for (i = 0;
-                     i < RIO_MAX_ROUTE_ENTRIES(rdev->net->hport->sys_size);
-                     i++) {
-                        if (rio_route_get_entry
-                            (rdev->net->hport, rdev->rswitch, RIO_GLOBAL_TABLE,
-                             i, &sport) < 0)
-                                continue;
-                        rdev->rswitch->route_table[i] = sport;
+                if (rio_is_switch(rdev)) {
+                        rio_lock_device(rdev->net->hport, rdev->rswitch->destid,
+                                        rdev->rswitch->hopcount, 1000);
+                        for (i = 0;
+                             i < RIO_MAX_ROUTE_ENTRIES(rdev->net->hport->sys_size);
+                             i++) {
+                                if (rio_route_get_entry
+                                    (rdev->net->hport, rdev->rswitch,
+                                     RIO_GLOBAL_TABLE, i, &sport, 0) < 0)
+                                        continue;
+                                rdev->rswitch->route_table[i] = sport;
+                        }
+
+                        rio_unlock_device(rdev->net->hport,
+                                          rdev->rswitch->destid,
+                                          rdev->rswitch->hopcount);
                 }
 }
 
@@ -1012,6 +1293,13 @@ int __devinit rio_disc_mport(struct rio_mport *mport)
                 del_timer_sync(&rio_enum_timer);
 
                 pr_debug("done\n");
+
+                /* Read DestID assigned by enumerator */
+                rio_local_read_config_32(mport, RIO_DID_CSR,
+                                         &mport->host_deviceid);
+                mport->host_deviceid = RIO_GET_DID(mport->sys_size,
+                                                   mport->host_deviceid);
+
                 if (rio_disc_peer(net, mport, RIO_ANY_DESTID(mport->sys_size),
                                         0) < 0) {
                         printk(KERN_INFO
diff --git a/drivers/rapidio/rio.c b/drivers/rapidio/rio.c
index 6395c780008b..08fa453af974 100644
--- a/drivers/rapidio/rio.c
+++ b/drivers/rapidio/rio.c
@@ -5,6 +5,10 @@
  * Copyright 2005 MontaVista Software, Inc.
  * Matt Porter <mporter@kernel.crashing.org>
  *
+ * Copyright 2009 Integrated Device Technology, Inc.
+ * Alex Bounine <alexandre.bounine@idt.com>
+ * - Added Port-Write/Error Management initialization and handling
+ *
  * 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
@@ -333,6 +337,331 @@ int rio_release_outb_dbell(struct rio_dev *rdev, struct resource *res)
 }
 
 /**
+ * rio_request_inb_pwrite - request inbound port-write message service
+ * @rdev: RIO device to which register inbound port-write callback routine
+ * @pwcback: Callback routine to execute when port-write is received
+ *
+ * Binds a port-write callback function to the RapidIO device.
+ * Returns 0 if the request has been satisfied.
+ */
+int rio_request_inb_pwrite(struct rio_dev *rdev,
+        int (*pwcback)(struct rio_dev *rdev, union rio_pw_msg *msg, int step))
+{
+        int rc = 0;
+
+        spin_lock(&rio_global_list_lock);
+        if (rdev->pwcback != NULL)
+                rc = -ENOMEM;
+        else
+                rdev->pwcback = pwcback;
+
+        spin_unlock(&rio_global_list_lock);
+        return rc;
+}
+EXPORT_SYMBOL_GPL(rio_request_inb_pwrite);
+
+/**
+ * rio_release_inb_pwrite - release inbound port-write message service
+ * @rdev: RIO device which registered for inbound port-write callback
+ *
+ * Removes callback from the rio_dev structure. Returns 0 if the request
+ * has been satisfied.
+ */
+int rio_release_inb_pwrite(struct rio_dev *rdev)
+{
+        int rc = -ENOMEM;
+
+        spin_lock(&rio_global_list_lock);
+        if (rdev->pwcback) {
+                rdev->pwcback = NULL;
+                rc = 0;
+        }
+
+        spin_unlock(&rio_global_list_lock);
+        return rc;
+}
+EXPORT_SYMBOL_GPL(rio_release_inb_pwrite);
+
+/**
+ * rio_mport_get_physefb - Helper function that returns register offset
+ *                      for Physical Layer Extended Features Block.
+ * @port: Master port to issue transaction
+ * @local: Indicate a local master port or remote device access
+ * @destid: Destination ID of the device
+ * @hopcount: Number of switch hops to the device
+ */
+u32
+rio_mport_get_physefb(struct rio_mport *port, int local,
+                      u16 destid, u8 hopcount)
+{
+        u32 ext_ftr_ptr;
+        u32 ftr_header;
+
+        ext_ftr_ptr = rio_mport_get_efb(port, local, destid, hopcount, 0);
+
+        while (ext_ftr_ptr)  {
+                if (local)
+                        rio_local_read_config_32(port, ext_ftr_ptr,
+                                                 &ftr_header);
+                else
+                        rio_mport_read_config_32(port, destid, hopcount,
+                                                 ext_ftr_ptr, &ftr_header);
+
+                ftr_header = RIO_GET_BLOCK_ID(ftr_header);
+                switch (ftr_header) {
+
+                case RIO_EFB_SER_EP_ID_V13P:
+                case RIO_EFB_SER_EP_REC_ID_V13P:
+                case RIO_EFB_SER_EP_FREE_ID_V13P:
+                case RIO_EFB_SER_EP_ID:
+                case RIO_EFB_SER_EP_REC_ID:
+                case RIO_EFB_SER_EP_FREE_ID:
+                case RIO_EFB_SER_EP_FREC_ID:
+
+                        return ext_ftr_ptr;
+
+                default:
+                        break;
+                }
+
+                ext_ftr_ptr = rio_mport_get_efb(port, local, destid,
+                                                hopcount, ext_ftr_ptr);
+        }
+
+        return ext_ftr_ptr;
+}
+
+/**
+ * rio_get_comptag - Begin or continue searching for a RIO device by component tag
+ * @comp_tag: RIO component tag to match
+ * @from: Previous RIO device found in search, or %NULL for new search
+ *
+ * Iterates through the list of known RIO devices. If a RIO device is
+ * found with a matching @comp_tag, a pointer to its device
+ * structure is returned. Otherwise, %NULL is returned. A new search
+ * is initiated by passing %NULL to the @from argument. Otherwise, if
+ * @from is not %NULL, searches continue from next device on the global
+ * list.
+ */
+static struct rio_dev *rio_get_comptag(u32 comp_tag, struct rio_dev *from)
+{
+        struct list_head *n;
+        struct rio_dev *rdev;
+
+        spin_lock(&rio_global_list_lock);
+        n = from ? from->global_list.next : rio_devices.next;
+
+        while (n && (n != &rio_devices)) {
+                rdev = rio_dev_g(n);
+                if (rdev->comp_tag == comp_tag)
+                        goto exit;
+                n = n->next;
+        }
+        rdev = NULL;
+exit:
+        spin_unlock(&rio_global_list_lock);
+        return rdev;
+}
+
+/**
+ * rio_set_port_lockout - Sets/clears LOCKOUT bit (RIO EM 1.3) for a switch port.
+ * @rdev: Pointer to RIO device control structure
+ * @pnum: Switch port number to set LOCKOUT bit
+ * @lock: Operation : set (=1) or clear (=0)
+ */
+int rio_set_port_lockout(struct rio_dev *rdev, u32 pnum, int lock)
+{
+        u8 hopcount = 0xff;
+        u16 destid = rdev->destid;
+        u32 regval;
+
+        if (rdev->rswitch) {
+                destid = rdev->rswitch->destid;
+                hopcount = rdev->rswitch->hopcount;
+        }
+
+        rio_mport_read_config_32(rdev->net->hport, destid, hopcount,
+                                 rdev->phys_efptr + RIO_PORT_N_CTL_CSR(pnum),
+                                 &regval);
+        if (lock)
+                regval |= RIO_PORT_N_CTL_LOCKOUT;
+        else
+                regval &= ~RIO_PORT_N_CTL_LOCKOUT;
+
+        rio_mport_write_config_32(rdev->net->hport, destid, hopcount,
+                                  rdev->phys_efptr + RIO_PORT_N_CTL_CSR(pnum),
+                                  regval);
+        return 0;
+}
+
+/**
+ * rio_inb_pwrite_handler - process inbound port-write message
+ * @pw_msg: pointer to inbound port-write message
+ *
+ * Processes an inbound port-write message. Returns 0 if the request
+ * has been satisfied.
+ */
+int rio_inb_pwrite_handler(union rio_pw_msg *pw_msg)
+{
+        struct rio_dev *rdev;
+        struct rio_mport *mport;
+        u8 hopcount;
+        u16 destid;
+        u32 err_status;
+        int rc, portnum;
+
+        rdev = rio_get_comptag(pw_msg->em.comptag, NULL);
+        if (rdev == NULL) {
+                /* Someting bad here (probably enumeration error) */
+                pr_err("RIO: %s No matching device for CTag 0x%08x\n",
+                        __func__, pw_msg->em.comptag);
+                return -EIO;
+        }
+
+        pr_debug("RIO: Port-Write message from %s\n", rio_name(rdev));
+
+#ifdef DEBUG_PW
+        {
+        u32 i;
+        for (i = 0; i < RIO_PW_MSG_SIZE/sizeof(u32);) {
+                        pr_debug("0x%02x: %08x %08x %08x %08x",
+                                 i*4, pw_msg->raw[i], pw_msg->raw[i + 1],
+                                 pw_msg->raw[i + 2], pw_msg->raw[i + 3]);
+                        i += 4;
+        }
+        pr_debug("\n");
+        }
+#endif
+
+        /* Call an external service function (if such is registered
+         * for this device). This may be the service for endpoints that send
+         * device-specific port-write messages. End-point messages expected
+         * to be handled completely by EP specific device driver.
+         * For switches rc==0 signals that no standard processing required.
+         */
+        if (rdev->pwcback != NULL) {
+                rc = rdev->pwcback(rdev, pw_msg, 0);
+                if (rc == 0)
+                        return 0;
+        }
+
+        /* For End-point devices processing stops here */
+        if (!(rdev->pef & RIO_PEF_SWITCH))
+                return 0;
+
+        if (rdev->phys_efptr == 0) {
+                pr_err("RIO_PW: Bad switch initialization for %s\n",
+                        rio_name(rdev));
+                return 0;
+        }
+
+        mport = rdev->net->hport;
+        destid = rdev->rswitch->destid;
+        hopcount = rdev->rswitch->hopcount;
+
+        /*
+         * Process the port-write notification from switch
+         */
+
+        portnum = pw_msg->em.is_port & 0xFF;
+
+        if (rdev->rswitch->em_handle)
+                rdev->rswitch->em_handle(rdev, portnum);
+
+        rio_mport_read_config_32(mport, destid, hopcount,
+                        rdev->phys_efptr + RIO_PORT_N_ERR_STS_CSR(portnum),
+                        &err_status);
+        pr_debug("RIO_PW: SP%d_ERR_STS_CSR=0x%08x\n", portnum, err_status);
+
+        if (pw_msg->em.errdetect) {
+                pr_debug("RIO_PW: RIO_EM_P%d_ERR_DETECT=0x%08x\n",
+                         portnum, pw_msg->em.errdetect);
+                /* Clear EM Port N Error Detect CSR */
+                rio_mport_write_config_32(mport, destid, hopcount,
+                        rdev->em_efptr + RIO_EM_PN_ERR_DETECT(portnum), 0);
+        }
+
+        if (pw_msg->em.ltlerrdet) {
+                pr_debug("RIO_PW: RIO_EM_LTL_ERR_DETECT=0x%08x\n",
+                         pw_msg->em.ltlerrdet);
+                /* Clear EM L/T Layer Error Detect CSR */
+                rio_mport_write_config_32(mport, destid, hopcount,
+                        rdev->em_efptr + RIO_EM_LTL_ERR_DETECT, 0);
+        }
+
+        /* Clear Port Errors */
+        rio_mport_write_config_32(mport, destid, hopcount,
+                        rdev->phys_efptr + RIO_PORT_N_ERR_STS_CSR(portnum),
+                        err_status & RIO_PORT_N_ERR_STS_CLR_MASK);
+
+        if (rdev->rswitch->port_ok & (1 << portnum)) {
+                if (err_status & RIO_PORT_N_ERR_STS_PORT_UNINIT) {
+                        rdev->rswitch->port_ok &= ~(1 << portnum);
+                        rio_set_port_lockout(rdev, portnum, 1);
+
+                        rio_mport_write_config_32(mport, destid, hopcount,
+                                rdev->phys_efptr +
+                                        RIO_PORT_N_ACK_STS_CSR(portnum),
+                                RIO_PORT_N_ACK_CLEAR);
+
+                        /* Schedule Extraction Service */
+                        pr_debug("RIO_PW: Device Extraction on [%s]-P%d\n",
+                               rio_name(rdev), portnum);
+                }
+        } else {
+                if (err_status & RIO_PORT_N_ERR_STS_PORT_OK) {
+                        rdev->rswitch->port_ok |= (1 << portnum);
+                        rio_set_port_lockout(rdev, portnum, 0);
+
+                        /* Schedule Insertion Service */
+                        pr_debug("RIO_PW: Device Insertion on [%s]-P%d\n",
+                               rio_name(rdev), portnum);
+                }
+        }
+
+        /* Clear Port-Write Pending bit */
+        rio_mport_write_config_32(mport, destid, hopcount,
+                        rdev->phys_efptr + RIO_PORT_N_ERR_STS_CSR(portnum),
+                        RIO_PORT_N_ERR_STS_PW_PEND);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(rio_inb_pwrite_handler);
+
+/**
+ * rio_mport_get_efb - get pointer to next extended features block
+ * @port: Master port to issue transaction
+ * @local: Indicate a local master port or remote device access
+ * @destid: Destination ID of the device
+ * @hopcount: Number of switch hops to the device
+ * @from: Offset of  current Extended Feature block header (if 0 starts
+ * from ExtFeaturePtr)
+ */
+u32
+rio_mport_get_efb(struct rio_mport *port, int local, u16 destid,
+                      u8 hopcount, u32 from)
+{
+        u32 reg_val;
+
+        if (from == 0) {
+                if (local)
+                        rio_local_read_config_32(port, RIO_ASM_INFO_CAR,
+                                                 &reg_val);
+                else
+                        rio_mport_read_config_32(port, destid, hopcount,
+                                                 RIO_ASM_INFO_CAR, &reg_val);
+                return reg_val & RIO_EXT_FTR_PTR_MASK;
+        } else {
+                if (local)
+                        rio_local_read_config_32(port, from, &reg_val);
+                else
+                        rio_mport_read_config_32(port, destid, hopcount,
+                                                 from, &reg_val);
+                return RIO_GET_BLOCK_ID(reg_val);
+        }
+}
+
+/**
  * rio_mport_get_feature - query for devices' extended features
  * @port: Master port to issue transaction
  * @local: Indicate a local master port or remote device access
@@ -451,6 +780,110 @@ struct rio_dev *rio_get_device(u16 vid, u16 did, struct rio_dev *from)
         return rio_get_asm(vid, did, RIO_ANY_ID, RIO_ANY_ID, from);
 }
 
+/**
+ * rio_std_route_add_entry - Add switch route table entry using standard
+ *   registers defined in RIO specification rev.1.3
+ * @mport: Master port to issue transaction
+ * @destid: Destination ID of the device
+ * @hopcount: Number of switch hops to the device
+ * @table: routing table ID (global or port-specific)
+ * @route_destid: destID entry in the RT
+ * @route_port: destination port for specified destID
+ */
+int rio_std_route_add_entry(struct rio_mport *mport, u16 destid, u8 hopcount,
+                       u16 table, u16 route_destid, u8 route_port)
+{
+        if (table == RIO_GLOBAL_TABLE) {
+                rio_mport_write_config_32(mport, destid, hopcount,
+                                RIO_STD_RTE_CONF_DESTID_SEL_CSR,
+                                (u32)route_destid);
+                rio_mport_write_config_32(mport, destid, hopcount,
+                                RIO_STD_RTE_CONF_PORT_SEL_CSR,
+                                (u32)route_port);
+        }
+
+        udelay(10);
+        return 0;
+}
+
+/**
+ * rio_std_route_get_entry - Read switch route table entry (port number)
+ *   assosiated with specified destID using standard registers defined in RIO
+ *   specification rev.1.3
+ * @mport: Master port to issue transaction
+ * @destid: Destination ID of the device
+ * @hopcount: Number of switch hops to the device
+ * @table: routing table ID (global or port-specific)
+ * @route_destid: destID entry in the RT
+ * @route_port: returned destination port for specified destID
+ */
+int rio_std_route_get_entry(struct rio_mport *mport, u16 destid, u8 hopcount,
+                       u16 table, u16 route_destid, u8 *route_port)
+{
+        u32 result;
+
+        if (table == RIO_GLOBAL_TABLE) {
+                rio_mport_write_config_32(mport, destid, hopcount,
+                                RIO_STD_RTE_CONF_DESTID_SEL_CSR, route_destid);
+                rio_mport_read_config_32(mport, destid, hopcount,
+                                RIO_STD_RTE_CONF_PORT_SEL_CSR, &result);
+
+                *route_port = (u8)result;
+        }
+
+        return 0;
+}
+
+/**
+ * rio_std_route_clr_table - Clear swotch route table using standard registers
+ *   defined in RIO specification rev.1.3.
+ * @mport: Master port to issue transaction
+ * @destid: Destination ID of the device
+ * @hopcount: Number of switch hops to the device
+ * @table: routing table ID (global or port-specific)
+ */
+int rio_std_route_clr_table(struct rio_mport *mport, u16 destid, u8 hopcount,
+                       u16 table)
+{
+        u32 max_destid = 0xff;
+        u32 i, pef, id_inc = 1, ext_cfg = 0;
+        u32 port_sel = RIO_INVALID_ROUTE;
+
+        if (table == RIO_GLOBAL_TABLE) {
+                rio_mport_read_config_32(mport, destid, hopcount,
+                                         RIO_PEF_CAR, &pef);
+
+                if (mport->sys_size) {
+                        rio_mport_read_config_32(mport, destid, hopcount,
+                                                 RIO_SWITCH_RT_LIMIT,
+                                                 &max_destid);
+                        max_destid &= RIO_RT_MAX_DESTID;
+                }
+
+                if (pef & RIO_PEF_EXT_RT) {
+                        ext_cfg = 0x80000000;
+                        id_inc = 4;
+                        port_sel = (RIO_INVALID_ROUTE << 24) |
+                                   (RIO_INVALID_ROUTE << 16) |
+                                   (RIO_INVALID_ROUTE << 8) |
+                                   RIO_INVALID_ROUTE;
+                }
+
+                for (i = 0; i <= max_destid;) {
+                        rio_mport_write_config_32(mport, destid, hopcount,
+                                        RIO_STD_RTE_CONF_DESTID_SEL_CSR,
+                                        ext_cfg | i);
+                        rio_mport_write_config_32(mport, destid, hopcount,
+                                        RIO_STD_RTE_CONF_PORT_SEL_CSR,
+                                        port_sel);
+                        i += id_inc;
+                }
+        }
+
+        udelay(10);
+        return 0;
+}
+
 static void rio_fixup_device(struct rio_dev *dev)
 {
 }
diff --git a/drivers/rapidio/rio.h b/drivers/rapidio/rio.h
index 7786d02581f2..f27b7a9c47d2 100644
--- a/drivers/rapidio/rio.h
+++ b/drivers/rapidio/rio.h
@@ -18,38 +18,50 @@
 
 extern u32 rio_mport_get_feature(struct rio_mport *mport, int local, u16 destid,
                                  u8 hopcount, int ftr);
+extern u32 rio_mport_get_physefb(struct rio_mport *port, int local,
+                                 u16 destid, u8 hopcount);
+extern u32 rio_mport_get_efb(struct rio_mport *port, int local, u16 destid,
+                             u8 hopcount, u32 from);
 extern int rio_create_sysfs_dev_files(struct rio_dev *rdev);
 extern int rio_enum_mport(struct rio_mport *mport);
 extern int rio_disc_mport(struct rio_mport *mport);
+extern int rio_std_route_add_entry(struct rio_mport *mport, u16 destid,
+                                   u8 hopcount, u16 table, u16 route_destid,
+                                   u8 route_port);
+extern int rio_std_route_get_entry(struct rio_mport *mport, u16 destid,
+                                   u8 hopcount, u16 table, u16 route_destid,
+                                   u8 *route_port);
+extern int rio_std_route_clr_table(struct rio_mport *mport, u16 destid,
+                                   u8 hopcount, u16 table);
+extern int rio_set_port_lockout(struct rio_dev *rdev, u32 pnum, int lock);
 
 /* Structures internal to the RIO core code */
 extern struct device_attribute rio_dev_attrs[];
 extern spinlock_t rio_global_list_lock;
 
-extern struct rio_route_ops __start_rio_route_ops[];
-extern struct rio_route_ops __end_rio_route_ops[];
+extern struct rio_switch_ops __start_rio_switch_ops[];
+extern struct rio_switch_ops __end_rio_switch_ops[];
 
 /* Helpers internal to the RIO core code */
-#define DECLARE_RIO_ROUTE_SECTION(section, vid, did, add_hook, get_hook)  \
-        static struct rio_route_ops __rio_route_ops __used   \
-        __section(section)= { vid, did, add_hook, get_hook };
+#define DECLARE_RIO_SWITCH_SECTION(section, name, vid, did, init_hook) \
+        static const struct rio_switch_ops __rio_switch_##name __used \
+        __section(section) = { vid, did, init_hook };
 
 /**
- * DECLARE_RIO_ROUTE_OPS - Registers switch routing operations
+ * DECLARE_RIO_SWITCH_INIT - Registers switch initialization routine
  * @vid: RIO vendor ID
  * @did: RIO device ID
- * @add_hook: Callback that adds a route entry
- * @get_hook: Callback that gets a route entry
+ * @init_hook: Callback that performs switch-specific initialization
  *
- * Manipulating switch route tables in RIO is switch specific. This
- * registers a switch by vendor and device ID with two callbacks for
- * modifying and retrieving route entries in a switch. A &struct
- * rio_route_ops is initialized with the ops and placed into a
- * RIO-specific kernel section.
+ * Manipulating switch route tables and error management in RIO
+ * is switch specific. This registers a switch by vendor and device ID with
+ * initialization callback for setting up switch operations and (if required)
+ * hardware initialization. A &struct rio_switch_ops is initialized with
+ * pointer to the init routine and placed into a RIO-specific kernel section.
  */
-#define DECLARE_RIO_ROUTE_OPS(vid, did, add_hook, get_hook)             \
-        DECLARE_RIO_ROUTE_SECTION(.rio_route_ops,                       \
-                        vid, did, add_hook, get_hook)
+#define DECLARE_RIO_SWITCH_INIT(vid, did, init_hook)            \
+        DECLARE_RIO_SWITCH_SECTION(.rio_switch_ops, vid##did, \
+                        vid, did, init_hook)
 
 #define RIO_GET_DID(size, x)    (size ? (x & 0xffff) : ((x & 0x00ff0000) >> 16))
 #define RIO_SET_DID(size, x)    (size ? (x & 0xffff) : ((x & 0x000000ff) << 16))
diff --git a/drivers/rapidio/switches/Kconfig b/drivers/rapidio/switches/Kconfig
new file mode 100644
index 000000000000..2b4e9b2b6631
--- /dev/null
+++ b/drivers/rapidio/switches/Kconfig
@@ -0,0 +1,28 @@
+#
+# RapidIO switches configuration
+#
+config RAPIDIO_TSI57X
+        bool "IDT Tsi57x SRIO switches support"
+        depends on RAPIDIO
+        ---help---
+          Includes support for IDT Tsi57x family of serial RapidIO switches.
+
+config RAPIDIO_CPS_XX
+        bool "IDT CPS-xx SRIO switches support"
+        depends on RAPIDIO
+        ---help---
+          Includes support for IDT CPS-16/12/10/8 serial RapidIO switches.
+
+config RAPIDIO_TSI568
+        bool "Tsi568 SRIO switch support"
+        depends on RAPIDIO
+        default n
+        ---help---
+          Includes support for IDT Tsi568 serial RapidIO switch.
+
+config RAPIDIO_TSI500
+        bool "Tsi500 Parallel RapidIO switch support"
+        depends on RAPIDIO
+        default n
+        ---help---
+          Includes support for IDT Tsi500 parallel RapidIO switch.
diff --git a/drivers/rapidio/switches/Makefile b/drivers/rapidio/switches/Makefile
index b924f8301761..fe4adc3e8d5f 100644
--- a/drivers/rapidio/switches/Makefile
+++ b/drivers/rapidio/switches/Makefile
@@ -2,4 +2,11 @@
 # Makefile for RIO switches
 #
 
-obj-$(CONFIG_RAPIDIO)   += tsi500.o
+obj-$(CONFIG_RAPIDIO_TSI57X)    += tsi57x.o
+obj-$(CONFIG_RAPIDIO_CPS_XX)    += idtcps.o
+obj-$(CONFIG_RAPIDIO_TSI568)    += tsi568.o
+obj-$(CONFIG_RAPIDIO_TSI500)    += tsi500.o
+
+ifeq ($(CONFIG_RAPIDIO_DEBUG),y)
+EXTRA_CFLAGS += -DDEBUG
+endif
diff --git a/drivers/rapidio/switches/idtcps.c b/drivers/rapidio/switches/idtcps.c
new file mode 100644
index 000000000000..2c790c144f89
--- /dev/null
+++ b/drivers/rapidio/switches/idtcps.c
@@ -0,0 +1,137 @@
+/*
+ * IDT CPS RapidIO switches support
+ *
+ * Copyright 2009-2010 Integrated Device Technology, Inc.
+ * Alexandre Bounine <alexandre.bounine@idt.com>
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ */
+
+#include <linux/rio.h>
+#include <linux/rio_drv.h>
+#include <linux/rio_ids.h>
+#include "../rio.h"
+
+#define CPS_DEFAULT_ROUTE       0xde
+#define CPS_NO_ROUTE            0xdf
+
+#define IDTCPS_RIO_DOMAIN 0xf20020
+
+static int
+idtcps_route_add_entry(struct rio_mport *mport, u16 destid, u8 hopcount,
+                       u16 table, u16 route_destid, u8 route_port)
+{
+        u32 result;
+
+        if (table == RIO_GLOBAL_TABLE) {
+                rio_mport_write_config_32(mport, destid, hopcount,
+                                RIO_STD_RTE_CONF_DESTID_SEL_CSR, route_destid);
+
+                rio_mport_read_config_32(mport, destid, hopcount,
+                                RIO_STD_RTE_CONF_PORT_SEL_CSR, &result);
+
+                result = (0xffffff00 & result) | (u32)route_port;
+                rio_mport_write_config_32(mport, destid, hopcount,
+                                RIO_STD_RTE_CONF_PORT_SEL_CSR, result);
+        }
+
+        return 0;
+}
+
+static int
+idtcps_route_get_entry(struct rio_mport *mport, u16 destid, u8 hopcount,
+                       u16 table, u16 route_destid, u8 *route_port)
+{
+        u32 result;
+
+        if (table == RIO_GLOBAL_TABLE) {
+                rio_mport_write_config_32(mport, destid, hopcount,
+                                RIO_STD_RTE_CONF_DESTID_SEL_CSR, route_destid);
+
+                rio_mport_read_config_32(mport, destid, hopcount,
+                                RIO_STD_RTE_CONF_PORT_SEL_CSR, &result);
+
+                if (CPS_DEFAULT_ROUTE == (u8)result ||
+                    CPS_NO_ROUTE == (u8)result)
+                        *route_port = RIO_INVALID_ROUTE;
+                else
+                        *route_port = (u8)result;
+        }
+
+        return 0;
+}
+
+static int
+idtcps_route_clr_table(struct rio_mport *mport, u16 destid, u8 hopcount,
+                       u16 table)
+{
+        u32 i;
+
+        if (table == RIO_GLOBAL_TABLE) {
+                for (i = 0x80000000; i <= 0x800000ff;) {
+                        rio_mport_write_config_32(mport, destid, hopcount,
+                                RIO_STD_RTE_CONF_DESTID_SEL_CSR, i);
+                        rio_mport_write_config_32(mport, destid, hopcount,
+                                RIO_STD_RTE_CONF_PORT_SEL_CSR,
+                                (CPS_DEFAULT_ROUTE << 24) |
+                                (CPS_DEFAULT_ROUTE << 16) |
+                                (CPS_DEFAULT_ROUTE << 8) | CPS_DEFAULT_ROUTE);
+                        i += 4;
+                }
+        }
+
+        return 0;
+}
+
+static int
+idtcps_set_domain(struct rio_mport *mport, u16 destid, u8 hopcount,
+                       u8 sw_domain)
+{
+        /*
+         * Switch domain configuration operates only at global level
+         */
+        rio_mport_write_config_32(mport, destid, hopcount,
+                                  IDTCPS_RIO_DOMAIN, (u32)sw_domain);
+        return 0;
+}
+
+static int
+idtcps_get_domain(struct rio_mport *mport, u16 destid, u8 hopcount,
+                       u8 *sw_domain)
+{
+        u32 regval;
+
+        /*
+         * Switch domain configuration operates only at global level
+         */
+        rio_mport_read_config_32(mport, destid, hopcount,
+                                IDTCPS_RIO_DOMAIN, &regval);
+
+        *sw_domain = (u8)(regval & 0xff);
+
+        return 0;
+}
+
+static int idtcps_switch_init(struct rio_dev *rdev, int do_enum)
+{
+        pr_debug("RIO: %s for %s\n", __func__, rio_name(rdev));
+        rdev->rswitch->add_entry = idtcps_route_add_entry;
+        rdev->rswitch->get_entry = idtcps_route_get_entry;
+        rdev->rswitch->clr_table = idtcps_route_clr_table;
+        rdev->rswitch->set_domain = idtcps_set_domain;
+        rdev->rswitch->get_domain = idtcps_get_domain;
+        rdev->rswitch->em_init = NULL;
+        rdev->rswitch->em_handle = NULL;
+
+        return 0;
+}
+
+DECLARE_RIO_SWITCH_INIT(RIO_VID_IDT, RIO_DID_IDTCPS6Q, idtcps_switch_init);
+DECLARE_RIO_SWITCH_INIT(RIO_VID_IDT, RIO_DID_IDTCPS8, idtcps_switch_init);
+DECLARE_RIO_SWITCH_INIT(RIO_VID_IDT, RIO_DID_IDTCPS10Q, idtcps_switch_init);
+DECLARE_RIO_SWITCH_INIT(RIO_VID_IDT, RIO_DID_IDTCPS12, idtcps_switch_init);
+DECLARE_RIO_SWITCH_INIT(RIO_VID_IDT, RIO_DID_IDTCPS16, idtcps_switch_init);
+DECLARE_RIO_SWITCH_INIT(RIO_VID_IDT, RIO_DID_IDT70K200, idtcps_switch_init);
diff --git a/drivers/rapidio/switches/tsi500.c b/drivers/rapidio/switches/tsi500.c
index c77c23bd9840..914eddd5aa42 100644
--- a/drivers/rapidio/switches/tsi500.c
+++ b/drivers/rapidio/switches/tsi500.c
@@ -1,6 +1,10 @@
 /*
  * RapidIO Tsi500 switch support
  *
+ * Copyright 2009-2010 Integrated Device Technology, Inc.
+ * Alexandre Bounine <alexandre.bounine@idt.com>
+ *  - Modified switch operations initialization.
+ *
  * Copyright 2005 MontaVista Software, Inc.
  * Matt Porter <mporter@kernel.crashing.org>
  *
@@ -57,4 +61,18 @@ tsi500_route_get_entry(struct rio_mport *mport, u16 destid, u8 hopcount, u16 tab
         return ret;
 }
 
-DECLARE_RIO_ROUTE_OPS(RIO_VID_TUNDRA, RIO_DID_TSI500, tsi500_route_add_entry, tsi500_route_get_entry);
+static int tsi500_switch_init(struct rio_dev *rdev, int do_enum)
+{
+        pr_debug("RIO: %s for %s\n", __func__, rio_name(rdev));
+        rdev->rswitch->add_entry = tsi500_route_add_entry;
+        rdev->rswitch->get_entry = tsi500_route_get_entry;
+        rdev->rswitch->clr_table = NULL;
+        rdev->rswitch->set_domain = NULL;
+        rdev->rswitch->get_domain = NULL;
+        rdev->rswitch->em_init = NULL;
+        rdev->rswitch->em_handle = NULL;
+
+        return 0;
+}
+
+DECLARE_RIO_SWITCH_INIT(RIO_VID_TUNDRA, RIO_DID_TSI500, tsi500_switch_init);
diff --git a/drivers/rapidio/switches/tsi568.c b/drivers/rapidio/switches/tsi568.c
new file mode 100644
index 000000000000..f7fd7898606e
--- /dev/null
+++ b/drivers/rapidio/switches/tsi568.c
@@ -0,0 +1,146 @@
+/*
+ * RapidIO Tsi568 switch support
+ *
+ * Copyright 2009-2010 Integrated Device Technology, Inc.
+ * Alexandre Bounine <alexandre.bounine@idt.com>
+ *  - Added EM support
+ *  - Modified switch operations initialization.
+ *
+ * Copyright 2005 MontaVista Software, Inc.
+ * Matt Porter <mporter@kernel.crashing.org>
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ */
+
+#include <linux/rio.h>
+#include <linux/rio_drv.h>
+#include <linux/rio_ids.h>
+#include <linux/delay.h>
+#include "../rio.h"
+
+/* Global (broadcast) route registers */
+#define SPBC_ROUTE_CFG_DESTID   0x10070
+#define SPBC_ROUTE_CFG_PORT     0x10074
+
+/* Per port route registers */
+#define SPP_ROUTE_CFG_DESTID(n) (0x11070 + 0x100*n)
+#define SPP_ROUTE_CFG_PORT(n)   (0x11074 + 0x100*n)
+
+#define TSI568_SP_MODE_BC       0x10004
+#define  TSI568_SP_MODE_PW_DIS  0x08000000
+
+static int
+tsi568_route_add_entry(struct rio_mport *mport, u16 destid, u8 hopcount,
+                       u16 table, u16 route_destid, u8 route_port)
+{
+        if (table == RIO_GLOBAL_TABLE) {
+                rio_mport_write_config_32(mport, destid, hopcount,
+                                        SPBC_ROUTE_CFG_DESTID, route_destid);
+                rio_mport_write_config_32(mport, destid, hopcount,
+                                        SPBC_ROUTE_CFG_PORT, route_port);
+        } else {
+                rio_mport_write_config_32(mport, destid, hopcount,
+                                        SPP_ROUTE_CFG_DESTID(table),
+                                        route_destid);
+                rio_mport_write_config_32(mport, destid, hopcount,
+                                        SPP_ROUTE_CFG_PORT(table), route_port);
+        }
+
+        udelay(10);
+
+        return 0;
+}
+
+static int
+tsi568_route_get_entry(struct rio_mport *mport, u16 destid, u8 hopcount,
+                       u16 table, u16 route_destid, u8 *route_port)
+{
+        int ret = 0;
+        u32 result;
+
+        if (table == RIO_GLOBAL_TABLE) {
+                rio_mport_write_config_32(mport, destid, hopcount,
+                                        SPBC_ROUTE_CFG_DESTID, route_destid);
+                rio_mport_read_config_32(mport, destid, hopcount,
+                                        SPBC_ROUTE_CFG_PORT, &result);
+        } else {
+                rio_mport_write_config_32(mport, destid, hopcount,
+                                        SPP_ROUTE_CFG_DESTID(table),
+                                        route_destid);
+                rio_mport_read_config_32(mport, destid, hopcount,
+                                        SPP_ROUTE_CFG_PORT(table), &result);
+        }
+
+        *route_port = result;
+        if (*route_port > 15)
+                ret = -1;
+
+        return ret;
+}
+
+static int
+tsi568_route_clr_table(struct rio_mport *mport, u16 destid, u8 hopcount,
+                       u16 table)
+{
+        u32 route_idx;
+        u32 lut_size;
+
+        lut_size = (mport->sys_size) ? 0x1ff : 0xff;
+
+        if (table == RIO_GLOBAL_TABLE) {
+                rio_mport_write_config_32(mport, destid, hopcount,
+                                        SPBC_ROUTE_CFG_DESTID, 0x80000000);
+                for (route_idx = 0; route_idx <= lut_size; route_idx++)
+                        rio_mport_write_config_32(mport, destid, hopcount,
+                                                SPBC_ROUTE_CFG_PORT,
+                                                RIO_INVALID_ROUTE);
+        } else {
+                rio_mport_write_config_32(mport, destid, hopcount,
+                                        SPP_ROUTE_CFG_DESTID(table),
+                                        0x80000000);
+                for (route_idx = 0; route_idx <= lut_size; route_idx++)
+                        rio_mport_write_config_32(mport, destid, hopcount,
+                                                SPP_ROUTE_CFG_PORT(table),
+                                                RIO_INVALID_ROUTE);
+        }
+
+        return 0;
+}
+
+static int
+tsi568_em_init(struct rio_dev *rdev)
+{
+        struct rio_mport *mport = rdev->net->hport;
+        u16 destid = rdev->rswitch->destid;
+        u8 hopcount = rdev->rswitch->hopcount;
+        u32 regval;
+
+        pr_debug("TSI568 %s [%d:%d]\n", __func__, destid, hopcount);
+
+        /* Make sure that Port-Writes are disabled (for all ports) */
+        rio_mport_read_config_32(mport, destid, hopcount,
+                        TSI568_SP_MODE_BC, &regval);
+        rio_mport_write_config_32(mport, destid, hopcount,
+                        TSI568_SP_MODE_BC, regval | TSI568_SP_MODE_PW_DIS);
+
+        return 0;
+}
+
+static int tsi568_switch_init(struct rio_dev *rdev, int do_enum)
+{
+        pr_debug("RIO: %s for %s\n", __func__, rio_name(rdev));
+        rdev->rswitch->add_entry = tsi568_route_add_entry;
+        rdev->rswitch->get_entry = tsi568_route_get_entry;
+        rdev->rswitch->clr_table = tsi568_route_clr_table;
+        rdev->rswitch->set_domain = NULL;
+        rdev->rswitch->get_domain = NULL;
+        rdev->rswitch->em_init = tsi568_em_init;
+        rdev->rswitch->em_handle = NULL;
+
+        return 0;
+}
+
+DECLARE_RIO_SWITCH_INIT(RIO_VID_TUNDRA, RIO_DID_TSI568, tsi568_switch_init);
diff --git a/drivers/rapidio/switches/tsi57x.c b/drivers/rapidio/switches/tsi57x.c
new file mode 100644
index 000000000000..d34df722d95f
--- /dev/null
+++ b/drivers/rapidio/switches/tsi57x.c
@@ -0,0 +1,315 @@
+/*
+ * RapidIO Tsi57x switch family support
+ *
+ * Copyright 2009-2010 Integrated Device Technology, Inc.
+ * Alexandre Bounine <alexandre.bounine@idt.com>
+ *  - Added EM support
+ *  - Modified switch operations initialization.
+ *
+ * Copyright 2005 MontaVista Software, Inc.
+ * Matt Porter <mporter@kernel.crashing.org>
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ */
+
+#include <linux/rio.h>
+#include <linux/rio_drv.h>
+#include <linux/rio_ids.h>
+#include <linux/delay.h>
+#include "../rio.h"
+
+/* Global (broadcast) route registers */
+#define SPBC_ROUTE_CFG_DESTID   0x10070
+#define SPBC_ROUTE_CFG_PORT     0x10074
+
+/* Per port route registers */
+#define SPP_ROUTE_CFG_DESTID(n) (0x11070 + 0x100*n)
+#define SPP_ROUTE_CFG_PORT(n)   (0x11074 + 0x100*n)
+
+#define TSI578_SP_MODE(n)       (0x11004 + n*0x100)
+#define TSI578_SP_MODE_GLBL     0x10004
+#define  TSI578_SP_MODE_PW_DIS  0x08000000
+#define  TSI578_SP_MODE_LUT_512 0x01000000
+
+#define TSI578_SP_CTL_INDEP(n)  (0x13004 + n*0x100)
+#define TSI578_SP_LUT_PEINF(n)  (0x13010 + n*0x100)
+#define TSI578_SP_CS_TX(n)      (0x13014 + n*0x100)
+#define TSI578_SP_INT_STATUS(n) (0x13018 + n*0x100)
+
+#define TSI578_GLBL_ROUTE_BASE  0x10078
+
+static int
+tsi57x_route_add_entry(struct rio_mport *mport, u16 destid, u8 hopcount,
+                       u16 table, u16 route_destid, u8 route_port)
+{
+        if (table == RIO_GLOBAL_TABLE) {
+                rio_mport_write_config_32(mport, destid, hopcount,
+                                          SPBC_ROUTE_CFG_DESTID, route_destid);
+                rio_mport_write_config_32(mport, destid, hopcount,
+                                          SPBC_ROUTE_CFG_PORT, route_port);
+        } else {
+                rio_mport_write_config_32(mport, destid, hopcount,
+                                SPP_ROUTE_CFG_DESTID(table), route_destid);
+                rio_mport_write_config_32(mport, destid, hopcount,
+                                SPP_ROUTE_CFG_PORT(table), route_port);
+        }
+
+        udelay(10);
+
+        return 0;
+}
+
+static int
+tsi57x_route_get_entry(struct rio_mport *mport, u16 destid, u8 hopcount,
+                       u16 table, u16 route_destid, u8 *route_port)
+{
+        int ret = 0;
+        u32 result;
+
+        if (table == RIO_GLOBAL_TABLE) {
+                /* Use local RT of the ingress port to avoid possible
+                   race condition */
+                rio_mport_read_config_32(mport, destid, hopcount,
+                        RIO_SWP_INFO_CAR, &result);
+                table = (result & RIO_SWP_INFO_PORT_NUM_MASK);
+        }
+
+        rio_mport_write_config_32(mport, destid, hopcount,
+                                SPP_ROUTE_CFG_DESTID(table), route_destid);
+        rio_mport_read_config_32(mport, destid, hopcount,
+                                SPP_ROUTE_CFG_PORT(table), &result);
+
+        *route_port = (u8)result;
+        if (*route_port > 15)
+                ret = -1;
+
+        return ret;
+}
+
+static int
+tsi57x_route_clr_table(struct rio_mport *mport, u16 destid, u8 hopcount,
+                       u16 table)
+{
+        u32 route_idx;
+        u32 lut_size;
+
+        lut_size = (mport->sys_size) ? 0x1ff : 0xff;
+
+        if (table == RIO_GLOBAL_TABLE) {
+                rio_mport_write_config_32(mport, destid, hopcount,
+                                          SPBC_ROUTE_CFG_DESTID, 0x80000000);
+                for (route_idx = 0; route_idx <= lut_size; route_idx++)
+                        rio_mport_write_config_32(mport, destid, hopcount,
+                                                  SPBC_ROUTE_CFG_PORT,
+                                                  RIO_INVALID_ROUTE);
+        } else {
+                rio_mport_write_config_32(mport, destid, hopcount,
+                                SPP_ROUTE_CFG_DESTID(table), 0x80000000);
+                for (route_idx = 0; route_idx <= lut_size; route_idx++)
+                        rio_mport_write_config_32(mport, destid, hopcount,
+                                SPP_ROUTE_CFG_PORT(table) , RIO_INVALID_ROUTE);
+        }
+
+        return 0;
+}
+
+static int
+tsi57x_set_domain(struct rio_mport *mport, u16 destid, u8 hopcount,
+                       u8 sw_domain)
+{
+        u32 regval;
+
+        /*
+         * Switch domain configuration operates only at global level
+         */
+
+        /* Turn off flat (LUT_512) mode */
+        rio_mport_read_config_32(mport, destid, hopcount,
+                                 TSI578_SP_MODE_GLBL, &regval);
+        rio_mport_write_config_32(mport, destid, hopcount, TSI578_SP_MODE_GLBL,
+                                  regval & ~TSI578_SP_MODE_LUT_512);
+        /* Set switch domain base */
+        rio_mport_write_config_32(mport, destid, hopcount,
+                                  TSI578_GLBL_ROUTE_BASE,
+                                  (u32)(sw_domain << 24));
+        return 0;
+}
+
+static int
+tsi57x_get_domain(struct rio_mport *mport, u16 destid, u8 hopcount,
+                       u8 *sw_domain)
+{
+        u32 regval;
+
+        /*
+         * Switch domain configuration operates only at global level
+         */
+        rio_mport_read_config_32(mport, destid, hopcount,
+                                TSI578_GLBL_ROUTE_BASE, &regval);
+
+        *sw_domain = (u8)(regval >> 24);
+
+        return 0;
+}
+
+static int
+tsi57x_em_init(struct rio_dev *rdev)
+{
+        struct rio_mport *mport = rdev->net->hport;
+        u16 destid = rdev->rswitch->destid;
+        u8 hopcount = rdev->rswitch->hopcount;
+        u32 regval;
+        int portnum;
+
+        pr_debug("TSI578 %s [%d:%d]\n", __func__, destid, hopcount);
+
+        for (portnum = 0; portnum < 16; portnum++) {
+                /* Make sure that Port-Writes are enabled (for all ports) */
+                rio_mport_read_config_32(mport, destid, hopcount,
+                                TSI578_SP_MODE(portnum), &regval);
+                rio_mport_write_config_32(mport, destid, hopcount,
+                                TSI578_SP_MODE(portnum),
+                                regval & ~TSI578_SP_MODE_PW_DIS);
+
+                /* Clear all pending interrupts */
+                rio_mport_read_config_32(mport, destid, hopcount,
+                                rdev->phys_efptr +
+                                        RIO_PORT_N_ERR_STS_CSR(portnum),
+                                &regval);
+                rio_mport_write_config_32(mport, destid, hopcount,
+                                rdev->phys_efptr +
+                                        RIO_PORT_N_ERR_STS_CSR(portnum),
+                                regval & 0x07120214);
+
+                rio_mport_read_config_32(mport, destid, hopcount,
+                                TSI578_SP_INT_STATUS(portnum), &regval);
+                rio_mport_write_config_32(mport, destid, hopcount,
+                                TSI578_SP_INT_STATUS(portnum),
+                                regval & 0x000700bd);
+
+                /* Enable all interrupts to allow ports to send a port-write */
+                rio_mport_read_config_32(mport, destid, hopcount,
+                                TSI578_SP_CTL_INDEP(portnum), &regval);
+                rio_mport_write_config_32(mport, destid, hopcount,
+                                TSI578_SP_CTL_INDEP(portnum),
+                                regval | 0x000b0000);
+
+                /* Skip next (odd) port if the current port is in x4 mode */
+                rio_mport_read_config_32(mport, destid, hopcount,
+                                rdev->phys_efptr + RIO_PORT_N_CTL_CSR(portnum),
+                                &regval);
+                if ((regval & RIO_PORT_N_CTL_PWIDTH) == RIO_PORT_N_CTL_PWIDTH_4)
+                        portnum++;
+        }
+
+        return 0;
+}
+
+static int
+tsi57x_em_handler(struct rio_dev *rdev, u8 portnum)
+{
+        struct rio_mport *mport = rdev->net->hport;
+        u16 destid = rdev->rswitch->destid;
+        u8 hopcount = rdev->rswitch->hopcount;
+        u32 intstat, err_status;
+        int sendcount, checkcount;
+        u8 route_port;
+        u32 regval;
+
+        rio_mport_read_config_32(mport, destid, hopcount,
+                        rdev->phys_efptr + RIO_PORT_N_ERR_STS_CSR(portnum),
+                        &err_status);
+
+        if ((err_status & RIO_PORT_N_ERR_STS_PORT_OK) &&
+            (err_status & (RIO_PORT_N_ERR_STS_PW_OUT_ES |
+                          RIO_PORT_N_ERR_STS_PW_INP_ES))) {
+                /* Remove any queued packets by locking/unlocking port */
+                rio_mport_read_config_32(mport, destid, hopcount,
+                        rdev->phys_efptr + RIO_PORT_N_CTL_CSR(portnum),
+                        &regval);
+                if (!(regval & RIO_PORT_N_CTL_LOCKOUT)) {
+                        rio_mport_write_config_32(mport, destid, hopcount,
+                                rdev->phys_efptr + RIO_PORT_N_CTL_CSR(portnum),
+                                regval | RIO_PORT_N_CTL_LOCKOUT);
+                        udelay(50);
+                        rio_mport_write_config_32(mport, destid, hopcount,
+                                rdev->phys_efptr + RIO_PORT_N_CTL_CSR(portnum),
+                                regval);
+                }
+
+                /* Read from link maintenance response register to clear
+                 * valid bit
+                 */
+                rio_mport_read_config_32(mport, destid, hopcount,
+                        rdev->phys_efptr + RIO_PORT_N_MNT_RSP_CSR(portnum),
+                        &regval);
+
+                /* Send a Packet-Not-Accepted/Link-Request-Input-Status control
+                 * symbol to recover from IES/OES
+                 */
+                sendcount = 3;
+                while (sendcount) {
+                        rio_mport_write_config_32(mport, destid, hopcount,
+                                          TSI578_SP_CS_TX(portnum), 0x40fc8000);
+                        checkcount = 3;
+                        while (checkcount--) {
+                                udelay(50);
+                                rio_mport_read_config_32(
+                                        mport, destid, hopcount,
+                                        rdev->phys_efptr +
+                                                RIO_PORT_N_MNT_RSP_CSR(portnum),
+                                        &regval);
+                                if (regval & RIO_PORT_N_MNT_RSP_RVAL)
+                                        goto exit_es;
+                        }
+
+                        sendcount--;
+                }
+        }
+
+exit_es:
+        /* Clear implementation specific error status bits */
+        rio_mport_read_config_32(mport, destid, hopcount,
+                                 TSI578_SP_INT_STATUS(portnum), &intstat);
+        pr_debug("TSI578[%x:%x] SP%d_INT_STATUS=0x%08x\n",
+                 destid, hopcount, portnum, intstat);
+
+        if (intstat & 0x10000) {
+                rio_mport_read_config_32(mport, destid, hopcount,
+                                TSI578_SP_LUT_PEINF(portnum), &regval);
+                regval = (mport->sys_size) ? (regval >> 16) : (regval >> 24);
+                route_port = rdev->rswitch->route_table[regval];
+                pr_debug("RIO: TSI578[%s] P%d LUT Parity Error (destID=%d)\n",
+                        rio_name(rdev), portnum, regval);
+                tsi57x_route_add_entry(mport, destid, hopcount,
+                                RIO_GLOBAL_TABLE, regval, route_port);
+        }
+
+        rio_mport_write_config_32(mport, destid, hopcount,
+                                  TSI578_SP_INT_STATUS(portnum),
+                                  intstat & 0x000700bd);
+
+        return 0;
+}
+
+static int tsi57x_switch_init(struct rio_dev *rdev, int do_enum)
+{
+        pr_debug("RIO: %s for %s\n", __func__, rio_name(rdev));
+        rdev->rswitch->add_entry = tsi57x_route_add_entry;
+        rdev->rswitch->get_entry = tsi57x_route_get_entry;
+        rdev->rswitch->clr_table = tsi57x_route_clr_table;
+        rdev->rswitch->set_domain = tsi57x_set_domain;
+        rdev->rswitch->get_domain = tsi57x_get_domain;
+        rdev->rswitch->em_init = tsi57x_em_init;
+        rdev->rswitch->em_handle = tsi57x_em_handler;
+
+        return 0;
+}
+
+DECLARE_RIO_SWITCH_INIT(RIO_VID_TUNDRA, RIO_DID_TSI572, tsi57x_switch_init);
+DECLARE_RIO_SWITCH_INIT(RIO_VID_TUNDRA, RIO_DID_TSI574, tsi57x_switch_init);
+DECLARE_RIO_SWITCH_INIT(RIO_VID_TUNDRA, RIO_DID_TSI577, tsi57x_switch_init);
+DECLARE_RIO_SWITCH_INIT(RIO_VID_TUNDRA, RIO_DID_TSI578, tsi57x_switch_init);
diff --git a/drivers/regulator/ab3100.c b/drivers/regulator/ab3100.c
index 1afd008ca957..7b14a67bdca2 100644
--- a/drivers/regulator/ab3100.c
+++ b/drivers/regulator/ab3100.c
@@ -16,7 +16,7 @@
 #include <linux/delay.h>
 #include <linux/platform_device.h>
 #include <linux/regulator/driver.h>
-#include <linux/mfd/ab3100.h>
+#include <linux/mfd/abx500.h>
 
 /* LDO registers and some handy masking definitions for AB3100 */
 #define AB3100_LDO_A            0x40
@@ -41,7 +41,7 @@
  * struct ab3100_regulator
  * A struct passed around the individual regulator functions
  * @platform_device: platform device holding this regulator
- * @ab3100: handle to the AB3100 parent chip
+ * @dev: handle to the device
  * @plfdata: AB3100 platform data passed in at probe time
  * @regreg: regulator register number in the AB3100
  * @fixed_voltage: a fixed voltage for this regulator, if this
@@ -52,7 +52,7 @@
  */
 struct ab3100_regulator {
         struct regulator_dev *rdev;
-        struct ab3100 *ab3100;
+        struct device *dev;
         struct ab3100_platform_data *plfdata;
         u8 regreg;
         int fixed_voltage;
@@ -183,7 +183,7 @@ static int ab3100_enable_regulator(struct regulator_dev *reg)
         int err;
         u8 regval;
 
-        err = ab3100_get_register_interruptible(abreg->ab3100, abreg->regreg,
+        err = abx500_get_register_interruptible(abreg->dev, 0, abreg->regreg,
                                                 &regval);
         if (err) {
                 dev_warn(&reg->dev, "failed to get regid %d value\n",
@@ -197,7 +197,7 @@ static int ab3100_enable_regulator(struct regulator_dev *reg)
 
         regval |= AB3100_REG_ON_MASK;
 
-        err = ab3100_set_register_interruptible(abreg->ab3100, abreg->regreg,
+        err = abx500_set_register_interruptible(abreg->dev, 0, abreg->regreg,
                                                 regval);
         if (err) {
                 dev_warn(&reg->dev, "failed to set regid %d value\n",
@@ -245,14 +245,14 @@ static int ab3100_disable_regulator(struct regulator_dev *reg)
         if (abreg->regreg == AB3100_LDO_D) {
                 dev_info(&reg->dev, "disabling LDO D - shut down system\n");
                 /* Setting LDO D to 0x00 cuts the power to the SoC */
-                return ab3100_set_register_interruptible(abreg->ab3100,
+                return abx500_set_register_interruptible(abreg->dev, 0,
                                                          AB3100_LDO_D, 0x00U);
         }
 
         /*
          * All other regulators are handled here
          */
-        err = ab3100_get_register_interruptible(abreg->ab3100, abreg->regreg,
+        err = abx500_get_register_interruptible(abreg->dev, 0, abreg->regreg,
                                                 &regval);
         if (err) {
                 dev_err(&reg->dev, "unable to get register 0x%x\n",
@@ -260,7 +260,7 @@ static int ab3100_disable_regulator(struct regulator_dev *reg)
                 return err;
         }
         regval &= ~AB3100_REG_ON_MASK;
-        return ab3100_set_register_interruptible(abreg->ab3100, abreg->regreg,
+        return abx500_set_register_interruptible(abreg->dev, 0, abreg->regreg,
                                                  regval);
 }
 
@@ -270,7 +270,7 @@ static int ab3100_is_enabled_regulator(struct regulator_dev *reg)
         u8 regval;
         int err;
 
-        err = ab3100_get_register_interruptible(abreg->ab3100, abreg->regreg,
+        err = abx500_get_register_interruptible(abreg->dev, 0, abreg->regreg,
                                                 &regval);
         if (err) {
                 dev_err(&reg->dev, "unable to get register 0x%x\n",
@@ -305,7 +305,7 @@ static int ab3100_get_voltage_regulator(struct regulator_dev *reg)
          * For variable types, read out setting and index into
          * supplied voltage list.
          */
-        err = ab3100_get_register_interruptible(abreg->ab3100,
+        err = abx500_get_register_interruptible(abreg->dev, 0,
                                                 abreg->regreg, &regval);
         if (err) {
                 dev_warn(&reg->dev,
@@ -373,7 +373,7 @@ static int ab3100_set_voltage_regulator(struct regulator_dev *reg,
         if (bestindex < 0)
                 return bestindex;
 
-        err = ab3100_get_register_interruptible(abreg->ab3100,
+        err = abx500_get_register_interruptible(abreg->dev, 0,
                                                 abreg->regreg, &regval);
         if (err) {
                 dev_warn(&reg->dev,
@@ -386,7 +386,7 @@ static int ab3100_set_voltage_regulator(struct regulator_dev *reg,
         regval &= ~0xE0;
         regval |= (bestindex << 5);
 
-        err = ab3100_set_register_interruptible(abreg->ab3100,
+        err = abx500_set_register_interruptible(abreg->dev, 0,
                                                 abreg->regreg, regval);
         if (err)
                 dev_warn(&reg->dev, "failed to set regulator register %02x\n",
@@ -414,7 +414,7 @@ static int ab3100_set_suspend_voltage_regulator(struct regulator_dev *reg,
         /* LDO E and BUCK have special suspend voltages you can set */
         bestindex = ab3100_get_best_voltage_index(reg, uV, uV);
 
-        err = ab3100_get_register_interruptible(abreg->ab3100,
+        err = abx500_get_register_interruptible(abreg->dev, 0,
                                                 targetreg, &regval);
         if (err) {
                 dev_warn(&reg->dev,
@@ -427,7 +427,7 @@ static int ab3100_set_suspend_voltage_regulator(struct regulator_dev *reg,
         regval &= ~0xE0;
         regval |= (bestindex << 5);
 
-        err = ab3100_set_register_interruptible(abreg->ab3100,
+        err = abx500_set_register_interruptible(abreg->dev, 0,
                                                 targetreg, regval);
         if (err)
                 dev_warn(&reg->dev, "failed to set regulator register %02x\n",
@@ -574,13 +574,12 @@ ab3100_regulator_desc[AB3100_NUM_REGULATORS] = {
 static int __devinit ab3100_regulators_probe(struct platform_device *pdev)
 {
         struct ab3100_platform_data *plfdata = pdev->dev.platform_data;
-        struct ab3100 *ab3100 = platform_get_drvdata(pdev);
         int err = 0;
         u8 data;
         int i;
 
         /* Check chip state */
-        err = ab3100_get_register_interruptible(ab3100,
+        err = abx500_get_register_interruptible(&pdev->dev, 0,
                                                 AB3100_LDO_D, &data);
         if (err) {
                 dev_err(&pdev->dev, "could not read initial status of LDO_D\n");
@@ -595,7 +594,7 @@ static int __devinit ab3100_regulators_probe(struct platform_device *pdev)
 
         /* Set up regulators */
         for (i = 0; i < ARRAY_SIZE(ab3100_reg_init_order); i++) {
-                err = ab3100_set_register_interruptible(ab3100,
+                err = abx500_set_register_interruptible(&pdev->dev, 0,
                                         ab3100_reg_init_order[i],
                                         plfdata->reg_initvals[i]);
                 if (err) {
@@ -617,7 +616,7 @@ static int __devinit ab3100_regulators_probe(struct platform_device *pdev)
                  * see what it looks like for a certain machine, go
                  * into the machine I2C setup.
                  */
-                reg->ab3100 = ab3100;
+                reg->dev = &pdev->dev;
                 reg->plfdata = plfdata;
 
                 /*
diff --git a/drivers/regulator/tps6507x-regulator.c b/drivers/regulator/tps6507x-regulator.c
index 74841abcc9cc..14b4576281c5 100644
--- a/drivers/regulator/tps6507x-regulator.c
+++ b/drivers/regulator/tps6507x-regulator.c
@@ -22,68 +22,9 @@
 #include <linux/platform_device.h>
 #include <linux/regulator/driver.h>
 #include <linux/regulator/machine.h>
-#include <linux/i2c.h>
 #include <linux/delay.h>
 #include <linux/slab.h>
-
-/* Register definitions */
-#define TPS6507X_REG_PPATH1                             0X01
-#define TPS6507X_REG_INT                                0X02
-#define TPS6507X_REG_CHGCONFIG0                         0X03
-#define TPS6507X_REG_CHGCONFIG1                         0X04
-#define TPS6507X_REG_CHGCONFIG2                         0X05
-#define TPS6507X_REG_CHGCONFIG3                         0X06
-#define TPS6507X_REG_REG_ADCONFIG                       0X07
-#define TPS6507X_REG_TSCMODE                            0X08
-#define TPS6507X_REG_ADRESULT_1                         0X09
-#define TPS6507X_REG_ADRESULT_2                         0X0A
-#define TPS6507X_REG_PGOOD                              0X0B
-#define TPS6507X_REG_PGOODMASK                          0X0C
-#define TPS6507X_REG_CON_CTRL1                          0X0D
-#define TPS6507X_REG_CON_CTRL2                          0X0E
-#define TPS6507X_REG_CON_CTRL3                          0X0F
-#define TPS6507X_REG_DEFDCDC1                           0X10
-#define TPS6507X_REG_DEFDCDC2_LOW                       0X11
-#define TPS6507X_REG_DEFDCDC2_HIGH                      0X12
-#define TPS6507X_REG_DEFDCDC3_LOW                       0X13
-#define TPS6507X_REG_DEFDCDC3_HIGH                      0X14
-#define TPS6507X_REG_DEFSLEW                            0X15
-#define TPS6507X_REG_LDO_CTRL1                          0X16
-#define TPS6507X_REG_DEFLDO2                            0X17
-#define TPS6507X_REG_WLED_CTRL1                         0X18
-#define TPS6507X_REG_WLED_CTRL2                         0X19
-
-/* CON_CTRL1 bitfields */
-#define TPS6507X_CON_CTRL1_DCDC1_ENABLE         BIT(4)
-#define TPS6507X_CON_CTRL1_DCDC2_ENABLE         BIT(3)
-#define TPS6507X_CON_CTRL1_DCDC3_ENABLE         BIT(2)
-#define TPS6507X_CON_CTRL1_LDO1_ENABLE          BIT(1)
-#define TPS6507X_CON_CTRL1_LDO2_ENABLE          BIT(0)
-
-/* DEFDCDC1 bitfields */
-#define TPS6507X_DEFDCDC1_DCDC1_EXT_ADJ_EN      BIT(7)
-#define TPS6507X_DEFDCDC1_DCDC1_MASK            0X3F
-
-/* DEFDCDC2_LOW bitfields */
-#define TPS6507X_DEFDCDC2_LOW_DCDC2_MASK        0X3F
-
-/* DEFDCDC2_HIGH bitfields */
-#define TPS6507X_DEFDCDC2_HIGH_DCDC2_MASK       0X3F
-
-/* DEFDCDC3_LOW bitfields */
-#define TPS6507X_DEFDCDC3_LOW_DCDC3_MASK        0X3F
-
-/* DEFDCDC3_HIGH bitfields */
-#define TPS6507X_DEFDCDC3_HIGH_DCDC3_MASK       0X3F
-
-/* TPS6507X_REG_LDO_CTRL1 bitfields */
-#define TPS6507X_REG_LDO_CTRL1_LDO1_MASK        0X0F
-
-/* TPS6507X_REG_DEFLDO2 bitfields */
-#define TPS6507X_REG_DEFLDO2_LDO2_MASK          0X3F
-
-/* VDCDC MASK */
-#define TPS6507X_DEFDCDCX_DCDC_MASK             0X3F
+#include <linux/mfd/tps6507x.h>
 
 /* DCDC's */
 #define TPS6507X_DCDC_1                         0
@@ -162,101 +103,146 @@ struct tps_info {
         const u16 *table;
 };
 
-struct tps_pmic {
+static const struct tps_info tps6507x_pmic_regs[] = {
+        {
+                .name = "VDCDC1",
+                .min_uV = 725000,
+                .max_uV = 3300000,
+                .table_len = ARRAY_SIZE(VDCDCx_VSEL_table),
+                .table = VDCDCx_VSEL_table,
+        },
+        {
+                .name = "VDCDC2",
+                .min_uV = 725000,
+                .max_uV = 3300000,
+                .table_len = ARRAY_SIZE(VDCDCx_VSEL_table),
+                .table = VDCDCx_VSEL_table,
+        },
+        {
+                .name = "VDCDC3",
+                .min_uV = 725000,
+                .max_uV = 3300000,
+                .table_len = ARRAY_SIZE(VDCDCx_VSEL_table),
+                .table = VDCDCx_VSEL_table,
+        },
+        {
+                .name = "LDO1",
+                .min_uV = 1000000,
+                .max_uV = 3300000,
+                .table_len = ARRAY_SIZE(LDO1_VSEL_table),
+                .table = LDO1_VSEL_table,
+        },
+        {
+                .name = "LDO2",
+                .min_uV = 725000,
+                .max_uV = 3300000,
+                .table_len = ARRAY_SIZE(LDO2_VSEL_table),
+                .table = LDO2_VSEL_table,
+        },
+};
+
+struct tps6507x_pmic {
         struct regulator_desc desc[TPS6507X_NUM_REGULATOR];
-        struct i2c_client *client;
+        struct tps6507x_dev *mfd;
         struct regulator_dev *rdev[TPS6507X_NUM_REGULATOR];
         const struct tps_info *info[TPS6507X_NUM_REGULATOR];
         struct mutex io_lock;
 };
-
-static inline int tps_6507x_read(struct tps_pmic *tps, u8 reg)
+static inline int tps6507x_pmic_read(struct tps6507x_pmic *tps, u8 reg)
 {
-        return i2c_smbus_read_byte_data(tps->client, reg);
+        u8 val;
+        int err;
+
+        err = tps->mfd->read_dev(tps->mfd, reg, 1, &val);
+
+        if (err)
+                return err;
+
+        return val;
 }
 
-static inline int tps_6507x_write(struct tps_pmic *tps, u8 reg, u8 val)
+static inline int tps6507x_pmic_write(struct tps6507x_pmic *tps, u8 reg, u8 val)
 {
-        return i2c_smbus_write_byte_data(tps->client, reg, val);
+        return tps->mfd->write_dev(tps->mfd, reg, 1, &val);
 }
 
-static int tps_6507x_set_bits(struct tps_pmic *tps, u8 reg, u8 mask)
+static int tps6507x_pmic_set_bits(struct tps6507x_pmic *tps, u8 reg, u8 mask)
 {
         int err, data;
 
         mutex_lock(&tps->io_lock);
 
-        data = tps_6507x_read(tps, reg);
+        data = tps6507x_pmic_read(tps, reg);
         if (data < 0) {
-                dev_err(&tps->client->dev, "Read from reg 0x%x failed\n", reg);
+                dev_err(tps->mfd->dev, "Read from reg 0x%x failed\n", reg);
                 err = data;
                 goto out;
         }
 
         data |= mask;
-        err = tps_6507x_write(tps, reg, data);
+        err = tps6507x_pmic_write(tps, reg, data);
         if (err)
-                dev_err(&tps->client->dev, "Write for reg 0x%x failed\n", reg);
+                dev_err(tps->mfd->dev, "Write for reg 0x%x failed\n", reg);
 
 out:
         mutex_unlock(&tps->io_lock);
         return err;
 }
 
-static int tps_6507x_clear_bits(struct tps_pmic *tps, u8 reg, u8 mask)
+static int tps6507x_pmic_clear_bits(struct tps6507x_pmic *tps, u8 reg, u8 mask)
 {
         int err, data;
 
         mutex_lock(&tps->io_lock);
 
-        data = tps_6507x_read(tps, reg);
+        data = tps6507x_pmic_read(tps, reg);
         if (data < 0) {
-                dev_err(&tps->client->dev, "Read from reg 0x%x failed\n", reg);
+                dev_err(tps->mfd->dev, "Read from reg 0x%x failed\n", reg);
                 err = data;
                 goto out;
         }
 
         data &= ~mask;
-        err = tps_6507x_write(tps, reg, data);
+        err = tps6507x_pmic_write(tps, reg, data);
         if (err)
-                dev_err(&tps->client->dev, "Write for reg 0x%x failed\n", reg);
+                dev_err(tps->mfd->dev, "Write for reg 0x%x failed\n", reg);
 
 out:
         mutex_unlock(&tps->io_lock);
         return err;
 }
 
-static int tps_6507x_reg_read(struct tps_pmic *tps, u8 reg)
+static int tps6507x_pmic_reg_read(struct tps6507x_pmic *tps, u8 reg)
 {
         int data;
 
         mutex_lock(&tps->io_lock);
 
-        data = tps_6507x_read(tps, reg);
+        data = tps6507x_pmic_read(tps, reg);
         if (data < 0)
-                dev_err(&tps->client->dev, "Read from reg 0x%x failed\n", reg);
+                dev_err(tps->mfd->dev, "Read from reg 0x%x failed\n", reg);
 
         mutex_unlock(&tps->io_lock);
         return data;
 }
 
-static int tps_6507x_reg_write(struct tps_pmic *tps, u8 reg, u8 val)
+static int tps6507x_pmic_reg_write(struct tps6507x_pmic *tps, u8 reg, u8 val)
 {
         int err;
 
         mutex_lock(&tps->io_lock);
 
-        err = tps_6507x_write(tps, reg, val);
+        err = tps6507x_pmic_write(tps, reg, val);
         if (err < 0)
-                dev_err(&tps->client->dev, "Write for reg 0x%x failed\n", reg);
+                dev_err(tps->mfd->dev, "Write for reg 0x%x failed\n", reg);
 
         mutex_unlock(&tps->io_lock);
         return err;
 }
 
-static int tps6507x_dcdc_is_enabled(struct regulator_dev *dev)
+static int tps6507x_pmic_dcdc_is_enabled(struct regulator_dev *dev)
 {
-        struct tps_pmic *tps = rdev_get_drvdata(dev);
+        struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
         int data, dcdc = rdev_get_id(dev);
         u8 shift;
 
@@ -264,7 +250,7 @@ static int tps6507x_dcdc_is_enabled(struct regulator_dev *dev)
                 return -EINVAL;
 
         shift = TPS6507X_MAX_REG_ID - dcdc;
-        data = tps_6507x_reg_read(tps, TPS6507X_REG_CON_CTRL1);
+        data = tps6507x_pmic_reg_read(tps, TPS6507X_REG_CON_CTRL1);
 
         if (data < 0)
                 return data;
@@ -272,9 +258,9 @@ static int tps6507x_dcdc_is_enabled(struct regulator_dev *dev)
                 return (data & 1<<shift) ? 1 : 0;
 }
 
-static int tps6507x_ldo_is_enabled(struct regulator_dev *dev)
+static int tps6507x_pmic_ldo_is_enabled(struct regulator_dev *dev)
 {
-        struct tps_pmic *tps = rdev_get_drvdata(dev);
+        struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
         int data, ldo = rdev_get_id(dev);
         u8 shift;
 
@@ -282,7 +268,7 @@ static int tps6507x_ldo_is_enabled(struct regulator_dev *dev)
                 return -EINVAL;
 
         shift = TPS6507X_MAX_REG_ID - ldo;
-        data = tps_6507x_reg_read(tps, TPS6507X_REG_CON_CTRL1);
+        data = tps6507x_pmic_reg_read(tps, TPS6507X_REG_CON_CTRL1);
 
         if (data < 0)
                 return data;
@@ -290,9 +276,9 @@ static int tps6507x_ldo_is_enabled(struct regulator_dev *dev)
                 return (data & 1<<shift) ? 1 : 0;
 }
 
-static int tps6507x_dcdc_enable(struct regulator_dev *dev)
+static int tps6507x_pmic_dcdc_enable(struct regulator_dev *dev)
 {
-        struct tps_pmic *tps = rdev_get_drvdata(dev);
+        struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
         int dcdc = rdev_get_id(dev);
         u8 shift;
 
@@ -300,12 +286,12 @@ static int tps6507x_dcdc_enable(struct regulator_dev *dev)
                 return -EINVAL;
 
         shift = TPS6507X_MAX_REG_ID - dcdc;
-        return tps_6507x_set_bits(tps, TPS6507X_REG_CON_CTRL1, 1 << shift);
+        return tps6507x_pmic_set_bits(tps, TPS6507X_REG_CON_CTRL1, 1 << shift);
 }
 
-static int tps6507x_dcdc_disable(struct regulator_dev *dev)
+static int tps6507x_pmic_dcdc_disable(struct regulator_dev *dev)
 {
-        struct tps_pmic *tps = rdev_get_drvdata(dev);
+        struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
         int dcdc = rdev_get_id(dev);
         u8 shift;
 
@@ -313,12 +299,13 @@ static int tps6507x_dcdc_disable(struct regulator_dev *dev)
                 return -EINVAL;
 
         shift = TPS6507X_MAX_REG_ID - dcdc;
-        return tps_6507x_clear_bits(tps, TPS6507X_REG_CON_CTRL1, 1 << shift);
+        return tps6507x_pmic_clear_bits(tps, TPS6507X_REG_CON_CTRL1,
+                                        1 << shift);
 }
 
-static int tps6507x_ldo_enable(struct regulator_dev *dev)
+static int tps6507x_pmic_ldo_enable(struct regulator_dev *dev)
 {
-        struct tps_pmic *tps = rdev_get_drvdata(dev);
+        struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
         int ldo = rdev_get_id(dev);
         u8 shift;
 
@@ -326,12 +313,12 @@ static int tps6507x_ldo_enable(struct regulator_dev *dev)
                 return -EINVAL;
 
         shift = TPS6507X_MAX_REG_ID - ldo;
-        return tps_6507x_set_bits(tps, TPS6507X_REG_CON_CTRL1, 1 << shift);
+        return tps6507x_pmic_set_bits(tps, TPS6507X_REG_CON_CTRL1, 1 << shift);
 }
 
-static int tps6507x_ldo_disable(struct regulator_dev *dev)
+static int tps6507x_pmic_ldo_disable(struct regulator_dev *dev)
 {
-        struct tps_pmic *tps = rdev_get_drvdata(dev);
+        struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
         int ldo = rdev_get_id(dev);
         u8 shift;
 
@@ -339,12 +326,13 @@ static int tps6507x_ldo_disable(struct regulator_dev *dev)
                 return -EINVAL;
 
         shift = TPS6507X_MAX_REG_ID - ldo;
-        return tps_6507x_clear_bits(tps, TPS6507X_REG_CON_CTRL1, 1 << shift);
+        return tps6507x_pmic_clear_bits(tps, TPS6507X_REG_CON_CTRL1,
+                                        1 << shift);
 }
 
-static int tps6507x_dcdc_get_voltage(struct regulator_dev *dev)
+static int tps6507x_pmic_dcdc_get_voltage(struct regulator_dev *dev)
 {
-        struct tps_pmic *tps = rdev_get_drvdata(dev);
+        struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
         int data, dcdc = rdev_get_id(dev);
         u8 reg;
 
@@ -362,7 +350,7 @@ static int tps6507x_dcdc_get_voltage(struct regulator_dev *dev)
                 return -EINVAL;
         }
 
-        data = tps_6507x_reg_read(tps, reg);
+        data = tps6507x_pmic_reg_read(tps, reg);
         if (data < 0)
                 return data;
 
@@ -370,10 +358,10 @@ static int tps6507x_dcdc_get_voltage(struct regulator_dev *dev)
         return tps->info[dcdc]->table[data] * 1000;
 }
 
-static int tps6507x_dcdc_set_voltage(struct regulator_dev *dev,
+static int tps6507x_pmic_dcdc_set_voltage(struct regulator_dev *dev,
                                 int min_uV, int max_uV)
 {
-        struct tps_pmic *tps = rdev_get_drvdata(dev);
+        struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
         int data, vsel, dcdc = rdev_get_id(dev);
         u8 reg;
 
@@ -411,19 +399,19 @@ static int tps6507x_dcdc_set_voltage(struct regulator_dev *dev,
         if (vsel == tps->info[dcdc]->table_len)
                 return -EINVAL;
 
-        data = tps_6507x_reg_read(tps, reg);
+        data = tps6507x_pmic_reg_read(tps, reg);
         if (data < 0)
                 return data;
 
         data &= ~TPS6507X_DEFDCDCX_DCDC_MASK;
         data |= vsel;
 
-        return tps_6507x_reg_write(tps, reg, data);
+        return tps6507x_pmic_reg_write(tps, reg, data);
 }
 
-static int tps6507x_ldo_get_voltage(struct regulator_dev *dev)
+static int tps6507x_pmic_ldo_get_voltage(struct regulator_dev *dev)
 {
-        struct tps_pmic *tps = rdev_get_drvdata(dev);
+        struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
         int data, ldo = rdev_get_id(dev);
         u8 reg, mask;
 
@@ -437,7 +425,7 @@ static int tps6507x_ldo_get_voltage(struct regulator_dev *dev)
                                 TPS6507X_REG_DEFLDO2_LDO2_MASK);
         }
 
-        data = tps_6507x_reg_read(tps, reg);
+        data = tps6507x_pmic_reg_read(tps, reg);
         if (data < 0)
                 return data;
 
@@ -445,10 +433,10 @@ static int tps6507x_ldo_get_voltage(struct regulator_dev *dev)
         return tps->info[ldo]->table[data] * 1000;
 }
 
-static int tps6507x_ldo_set_voltage(struct regulator_dev *dev,
+static int tps6507x_pmic_ldo_set_voltage(struct regulator_dev *dev,
                                 int min_uV, int max_uV)
 {
-        struct tps_pmic *tps = rdev_get_drvdata(dev);
+        struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
         int data, vsel, ldo = rdev_get_id(dev);
         u8 reg, mask;
 
@@ -479,20 +467,20 @@ static int tps6507x_ldo_set_voltage(struct regulator_dev *dev,
         if (vsel == tps->info[ldo]->table_len)
                 return -EINVAL;
 
-        data = tps_6507x_reg_read(tps, reg);
+        data = tps6507x_pmic_reg_read(tps, reg);
         if (data < 0)
                 return data;
 
         data &= ~mask;
         data |= vsel;
 
-        return tps_6507x_reg_write(tps, reg, data);
+        return tps6507x_pmic_reg_write(tps, reg, data);
 }
 
-static int tps6507x_dcdc_list_voltage(struct regulator_dev *dev,
+static int tps6507x_pmic_dcdc_list_voltage(struct regulator_dev *dev,
                                         unsigned selector)
 {
-        struct tps_pmic *tps = rdev_get_drvdata(dev);
+        struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
         int dcdc = rdev_get_id(dev);
 
         if (dcdc < TPS6507X_DCDC_1 || dcdc > TPS6507X_DCDC_3)
@@ -504,10 +492,10 @@ static int tps6507x_dcdc_list_voltage(struct regulator_dev *dev,
                 return tps->info[dcdc]->table[selector] * 1000;
 }
 
-static int tps6507x_ldo_list_voltage(struct regulator_dev *dev,
+static int tps6507x_pmic_ldo_list_voltage(struct regulator_dev *dev,
                                         unsigned selector)
 {
-        struct tps_pmic *tps = rdev_get_drvdata(dev);
+        struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
         int ldo = rdev_get_id(dev);
 
         if (ldo < TPS6507X_LDO_1 || ldo > TPS6507X_LDO_2)
@@ -520,47 +508,54 @@ static int tps6507x_ldo_list_voltage(struct regulator_dev *dev,
 }
 
 /* Operations permitted on VDCDCx */
-static struct regulator_ops tps6507x_dcdc_ops = {
-        .is_enabled = tps6507x_dcdc_is_enabled,
-        .enable = tps6507x_dcdc_enable,
-        .disable = tps6507x_dcdc_disable,
-        .get_voltage = tps6507x_dcdc_get_voltage,
-        .set_voltage = tps6507x_dcdc_set_voltage,
-        .list_voltage = tps6507x_dcdc_list_voltage,
+static struct regulator_ops tps6507x_pmic_dcdc_ops = {
+        .is_enabled = tps6507x_pmic_dcdc_is_enabled,
+        .enable = tps6507x_pmic_dcdc_enable,
+        .disable = tps6507x_pmic_dcdc_disable,
+        .get_voltage = tps6507x_pmic_dcdc_get_voltage,
+        .set_voltage = tps6507x_pmic_dcdc_set_voltage,
+        .list_voltage = tps6507x_pmic_dcdc_list_voltage,
 };
 
 /* Operations permitted on LDOx */
-static struct regulator_ops tps6507x_ldo_ops = {
-        .is_enabled = tps6507x_ldo_is_enabled,
-        .enable = tps6507x_ldo_enable,
-        .disable = tps6507x_ldo_disable,
-        .get_voltage = tps6507x_ldo_get_voltage,
-        .set_voltage = tps6507x_ldo_set_voltage,
-        .list_voltage = tps6507x_ldo_list_voltage,
+static struct regulator_ops tps6507x_pmic_ldo_ops = {
+        .is_enabled = tps6507x_pmic_ldo_is_enabled,
+        .enable = tps6507x_pmic_ldo_enable,
+        .disable = tps6507x_pmic_ldo_disable,
+        .get_voltage = tps6507x_pmic_ldo_get_voltage,
+        .set_voltage = tps6507x_pmic_ldo_set_voltage,
+        .list_voltage = tps6507x_pmic_ldo_list_voltage,
 };
 
-static int __devinit tps_6507x_probe(struct i2c_client *client,
-                                     const struct i2c_device_id *id)
+static __devinit
+int tps6507x_pmic_probe(struct platform_device *pdev)
 {
+        struct tps6507x_dev *tps6507x_dev = dev_get_drvdata(pdev->dev.parent);
         static int desc_id;
-        const struct tps_info *info = (void *)id->driver_data;
+        const struct tps_info *info = &tps6507x_pmic_regs[0];
         struct regulator_init_data *init_data;
         struct regulator_dev *rdev;
-        struct tps_pmic *tps;
+        struct tps6507x_pmic *tps;
+        struct tps6507x_board *tps_board;
         int i;
         int error;
 
-        if (!i2c_check_functionality(client->adapter,
-                                I2C_FUNC_SMBUS_BYTE_DATA))
-                return -EIO;
+        /**
+         * tps_board points to pmic related constants
+         * coming from the board-evm file.
+         */
+
+        tps_board = dev_get_platdata(tps6507x_dev->dev);
+        if (!tps_board)
+                return -EINVAL;
 
         /**
          * init_data points to array of regulator_init structures
          * coming from the board-evm file.
          */
-        init_data = client->dev.platform_data;
+        init_data = tps_board->tps6507x_pmic_init_data;
         if (!init_data)
-                return -EIO;
+                return -EINVAL;
 
         tps = kzalloc(sizeof(*tps), GFP_KERNEL);
         if (!tps)
@@ -569,7 +564,7 @@ static int __devinit tps_6507x_probe(struct i2c_client *client,
         mutex_init(&tps->io_lock);
 
         /* common for all regulators */
-        tps->client = client;
+        tps->mfd = tps6507x_dev;
 
         for (i = 0; i < TPS6507X_NUM_REGULATOR; i++, info++, init_data++) {
                 /* Register the regulators */
@@ -578,15 +573,16 @@ static int __devinit tps_6507x_probe(struct i2c_client *client,
                 tps->desc[i].id = desc_id++;
                 tps->desc[i].n_voltages = num_voltages[i];
                 tps->desc[i].ops = (i > TPS6507X_DCDC_3 ?
-                                &tps6507x_ldo_ops : &tps6507x_dcdc_ops);
+                &tps6507x_pmic_ldo_ops : &tps6507x_pmic_dcdc_ops);
                 tps->desc[i].type = REGULATOR_VOLTAGE;
                 tps->desc[i].owner = THIS_MODULE;
 
                 rdev = regulator_register(&tps->desc[i],
-                                        &client->dev, init_data, tps);
+                                        tps6507x_dev->dev, init_data, tps);
                 if (IS_ERR(rdev)) {
-                        dev_err(&client->dev, "failed to register %s\n",
-                                id->name);
+                        dev_err(tps6507x_dev->dev,
+                                "failed to register %s regulator\n",
+                                pdev->name);
                         error = PTR_ERR(rdev);
                         goto fail;
                 }
@@ -595,7 +591,7 @@ static int __devinit tps_6507x_probe(struct i2c_client *client,
                 tps->rdev[i] = rdev;
         }
 
-        i2c_set_clientdata(client, tps);
+        tps6507x_dev->pmic = tps;
 
         return 0;
 
@@ -608,19 +604,17 @@ fail:
 }
 
 /**
- * tps_6507x_remove - TPS6507x driver i2c remove handler
+ * tps6507x_remove - TPS6507x driver i2c remove handler
  * @client: i2c driver client device structure
  *
  * Unregister TPS driver as an i2c client device driver
  */
-static int __devexit tps_6507x_remove(struct i2c_client *client)
+static int __devexit tps6507x_pmic_remove(struct platform_device *pdev)
 {
-        struct tps_pmic *tps = i2c_get_clientdata(client);
+        struct tps6507x_dev *tps6507x_dev = platform_get_drvdata(pdev);
+        struct tps6507x_pmic *tps = tps6507x_dev->pmic;
         int i;
 
-        /* clear the client data in i2c */
-        i2c_set_clientdata(client, NULL);
-
         for (i = 0; i < TPS6507X_NUM_REGULATOR; i++)
                 regulator_unregister(tps->rdev[i]);
 
@@ -629,83 +623,38 @@ static int __devexit tps_6507x_remove(struct i2c_client *client)
         return 0;
 }
 
-static const struct tps_info tps6507x_regs[] = {
-        {
-                .name = "VDCDC1",
-                .min_uV = 725000,
-                .max_uV = 3300000,
-                .table_len = ARRAY_SIZE(VDCDCx_VSEL_table),
-                .table = VDCDCx_VSEL_table,
-        },
-        {
-                .name = "VDCDC2",
-                .min_uV = 725000,
-                .max_uV = 3300000,
-                .table_len = ARRAY_SIZE(VDCDCx_VSEL_table),
-                .table = VDCDCx_VSEL_table,
-        },
-        {
-                .name = "VDCDC3",
-                .min_uV = 725000,
-                .max_uV = 3300000,
-                .table_len = ARRAY_SIZE(VDCDCx_VSEL_table),
-                .table = VDCDCx_VSEL_table,
-        },
-        {
-                .name = "LDO1",
-                .min_uV = 1000000,
-                .max_uV = 3300000,
-                .table_len = ARRAY_SIZE(LDO1_VSEL_table),
-                .table = LDO1_VSEL_table,
-        },
-        {
-                .name = "LDO2",
-                .min_uV = 725000,
-                .max_uV = 3300000,
-                .table_len = ARRAY_SIZE(LDO2_VSEL_table),
-                .table = LDO2_VSEL_table,
-        },
-};
-
-static const struct i2c_device_id tps_6507x_id[] = {
-        {.name = "tps6507x",
-        .driver_data = (unsigned long) tps6507x_regs,},
-        { },
-};
-MODULE_DEVICE_TABLE(i2c, tps_6507x_id);
-
-static struct i2c_driver tps_6507x_i2c_driver = {
+static struct platform_driver tps6507x_pmic_driver = {
         .driver = {
-                .name = "tps6507x",
+                .name = "tps6507x-pmic",
                 .owner = THIS_MODULE,
         },
-        .probe = tps_6507x_probe,
-        .remove = __devexit_p(tps_6507x_remove),
-        .id_table = tps_6507x_id,
+        .probe = tps6507x_pmic_probe,
+        .remove = __devexit_p(tps6507x_pmic_remove),
 };
 
 /**
- * tps_6507x_init
+ * tps6507x_pmic_init
  *
  * Module init function
  */
-static int __init tps_6507x_init(void)
+static int __init tps6507x_pmic_init(void)
 {
-        return i2c_add_driver(&tps_6507x_i2c_driver);
+        return platform_driver_register(&tps6507x_pmic_driver);
 }
-subsys_initcall(tps_6507x_init);
+subsys_initcall(tps6507x_pmic_init);
 
 /**
- * tps_6507x_cleanup
+ * tps6507x_pmic_cleanup
  *
  * Module exit function
  */
-static void __exit tps_6507x_cleanup(void)
+static void __exit tps6507x_pmic_cleanup(void)
 {
-        i2c_del_driver(&tps_6507x_i2c_driver);
+        platform_driver_unregister(&tps6507x_pmic_driver);
 }
-module_exit(tps_6507x_cleanup);
+module_exit(tps6507x_pmic_cleanup);
 
 MODULE_AUTHOR("Texas Instruments");
 MODULE_DESCRIPTION("TPS6507x voltage regulator driver");
 MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:tps6507x-pmic");
diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index f1598324344c..10ba12c8c5e0 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -611,6 +611,13 @@ config RTC_DRV_AB3100
           Select this to enable the ST-Ericsson AB3100 Mixed Signal IC RTC
           support. This chip contains a battery- and capacitor-backed RTC.
 
+config RTC_DRV_AB8500
+        tristate "ST-Ericsson AB8500 RTC"
+        depends on AB8500_CORE
+        help
+          Select this to enable the ST-Ericsson AB8500 power management IC RTC
+          support. This chip contains a battery- and capacitor-backed RTC.
+
 config RTC_DRV_NUC900
         tristate "NUC910/NUC920 RTC driver"
         depends on RTC_CLASS && ARCH_W90X900
diff --git a/drivers/rtc/Makefile b/drivers/rtc/Makefile
index 245311a1348f..5adbba7cf89c 100644
--- a/drivers/rtc/Makefile
+++ b/drivers/rtc/Makefile
@@ -18,6 +18,7 @@ rtc-core-$(CONFIG_RTC_INTF_SYSFS) += rtc-sysfs.o
 # Keep the list ordered.
 
 obj-$(CONFIG_RTC_DRV_AB3100)    += rtc-ab3100.o
+obj-$(CONFIG_RTC_DRV_AB8500)    += rtc-ab8500.o
 obj-$(CONFIG_RTC_DRV_AT32AP700X)+= rtc-at32ap700x.o
 obj-$(CONFIG_RTC_DRV_AT91RM9200)+= rtc-at91rm9200.o
 obj-$(CONFIG_RTC_DRV_AT91SAM9)  += rtc-at91sam9.o
diff --git a/drivers/rtc/rtc-ab3100.c b/drivers/rtc/rtc-ab3100.c
index 4704aac2b5af..d26780ea254b 100644
--- a/drivers/rtc/rtc-ab3100.c
+++ b/drivers/rtc/rtc-ab3100.c
@@ -9,7 +9,7 @@
 #include <linux/init.h>
 #include <linux/platform_device.h>
 #include <linux/rtc.h>
-#include <linux/mfd/ab3100.h>
+#include <linux/mfd/abx500.h>
 
 /* Clock rate in Hz */
 #define AB3100_RTC_CLOCK_RATE   32768
@@ -45,7 +45,6 @@
  */
 static int ab3100_rtc_set_mmss(struct device *dev, unsigned long secs)
 {
-        struct ab3100 *ab3100_data = dev_get_drvdata(dev);
         u8 regs[] = {AB3100_TI0, AB3100_TI1, AB3100_TI2,
                      AB3100_TI3, AB3100_TI4, AB3100_TI5};
         unsigned char buf[6];
@@ -61,27 +60,26 @@ static int ab3100_rtc_set_mmss(struct device *dev, unsigned long secs)
         buf[5] = (fat_time >> 40) & 0xFF;
 
         for (i = 0; i < 6; i++) {
-                err = ab3100_set_register_interruptible(ab3100_data,
+                err = abx500_set_register_interruptible(dev, 0,
                                                         regs[i], buf[i]);
                 if (err)
                         return err;
         }
 
         /* Set the flag to mark that the clock is now set */
-        return ab3100_mask_and_set_register_interruptible(ab3100_data,
+        return abx500_mask_and_set_register_interruptible(dev, 0,
                                                           AB3100_RTC,
-                                                          0xFE, 0x01);
+                                                          0x01, 0x01);
 
 }
 
 static int ab3100_rtc_read_time(struct device *dev, struct rtc_time *tm)
 {
-        struct ab3100 *ab3100_data = dev_get_drvdata(dev);
         unsigned long time;
         u8 rtcval;
         int err;
 
-        err = ab3100_get_register_interruptible(ab3100_data,
+        err = abx500_get_register_interruptible(dev, 0,
                                                 AB3100_RTC, &rtcval);
         if (err)
                 return err;
@@ -94,7 +92,7 @@ static int ab3100_rtc_read_time(struct device *dev, struct rtc_time *tm)
                 u8 buf[6];
 
                 /* Read out time registers */
-                err = ab3100_get_register_page_interruptible(ab3100_data,
+                err = abx500_get_register_page_interruptible(dev, 0,
                                                              AB3100_TI0,
                                                              buf, 6);
                 if (err != 0)
@@ -114,7 +112,6 @@ static int ab3100_rtc_read_time(struct device *dev, struct rtc_time *tm)
 
 static int ab3100_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 {
-        struct ab3100 *ab3100_data = dev_get_drvdata(dev);
         unsigned long time;
         u64 fat_time;
         u8 buf[6];
@@ -122,7 +119,7 @@ static int ab3100_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
         int err;
 
         /* Figure out if alarm is enabled or not */
-        err = ab3100_get_register_interruptible(ab3100_data,
+        err = abx500_get_register_interruptible(dev, 0,
                                                 AB3100_RTC, &rtcval);
         if (err)
                 return err;
@@ -133,7 +130,7 @@ static int ab3100_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
         /* No idea how this could be represented */
         alarm->pending = 0;
         /* Read out alarm registers, only 4 bytes */
-        err = ab3100_get_register_page_interruptible(ab3100_data,
+        err = abx500_get_register_page_interruptible(dev, 0,
                                                      AB3100_AL0, buf, 4);
         if (err)
                 return err;
@@ -148,7 +145,6 @@ static int ab3100_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 
 static int ab3100_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 {
-        struct ab3100 *ab3100_data = dev_get_drvdata(dev);
         u8 regs[] = {AB3100_AL0, AB3100_AL1, AB3100_AL2, AB3100_AL3};
         unsigned char buf[4];
         unsigned long secs;
@@ -165,21 +161,19 @@ static int ab3100_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 
         /* Set the alarm */
         for (i = 0; i < 4; i++) {
-                err = ab3100_set_register_interruptible(ab3100_data,
+                err = abx500_set_register_interruptible(dev, 0,
                                                         regs[i], buf[i]);
                 if (err)
                         return err;
         }
         /* Then enable the alarm */
-        return ab3100_mask_and_set_register_interruptible(ab3100_data,
-                                                          AB3100_RTC, ~(1 << 2),
+        return abx500_mask_and_set_register_interruptible(dev, 0,
+                                                          AB3100_RTC, (1 << 2),
                                                           alarm->enabled << 2);
 }
 
 static int ab3100_rtc_irq_enable(struct device *dev, unsigned int enabled)
 {
-        struct ab3100 *ab3100_data = dev_get_drvdata(dev);
-
         /*
          * It's not possible to enable/disable the alarm IRQ for this RTC.
          * It does not actually trigger any IRQ: instead its only function is
@@ -188,12 +182,12 @@ static int ab3100_rtc_irq_enable(struct device *dev, unsigned int enabled)
          * and need to be handled there instead.
          */
         if (enabled)
-                return ab3100_mask_and_set_register_interruptible(ab3100_data,
-                                                    AB3100_RTC, ~(1 << 2),
+                return abx500_mask_and_set_register_interruptible(dev, 0,
+                                                    AB3100_RTC, (1 << 2),
                                                     1 << 2);
         else
-                return ab3100_mask_and_set_register_interruptible(ab3100_data,
-                                                    AB3100_RTC, ~(1 << 2),
+                return abx500_mask_and_set_register_interruptible(dev, 0,
+                                                    AB3100_RTC, (1 << 2),
                                                     0);
 }
 
@@ -210,10 +204,9 @@ static int __init ab3100_rtc_probe(struct platform_device *pdev)
         int err;
         u8 regval;
         struct rtc_device *rtc;
-        struct ab3100 *ab3100_data = platform_get_drvdata(pdev);
 
         /* The first RTC register needs special treatment */
-        err = ab3100_get_register_interruptible(ab3100_data,
+        err = abx500_get_register_interruptible(&pdev->dev, 0,
                                                 AB3100_RTC, &regval);
         if (err) {
                 dev_err(&pdev->dev, "unable to read RTC register\n");
@@ -231,7 +224,7 @@ static int __init ab3100_rtc_probe(struct platform_device *pdev)
                  * This bit remains until RTC power is lost.
                  */
                 regval = 1 | RTC_SETTING;
-                err = ab3100_set_register_interruptible(ab3100_data,
+                err = abx500_set_register_interruptible(&pdev->dev, 0,
                                                         AB3100_RTC, regval);
                 /* Ignore any error on this write */
         }
diff --git a/drivers/rtc/rtc-ab8500.c b/drivers/rtc/rtc-ab8500.c
new file mode 100644
index 000000000000..2fda03125e55
--- /dev/null
+++ b/drivers/rtc/rtc-ab8500.c
@@ -0,0 +1,363 @@
+/*
+ * Copyright (C) ST-Ericsson SA 2010
+ *
+ * License terms: GNU General Public License (GPL) version 2
+ * Author: Virupax Sadashivpetimath <virupax.sadashivpetimath@stericsson.com>
+ *
+ * RTC clock driver for the RTC part of the AB8500 Power management chip.
+ * Based on RTC clock driver for the AB3100 Analog Baseband Chip by
+ * Linus Walleij <linus.walleij@stericsson.com>
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/rtc.h>
+#include <linux/mfd/ab8500.h>
+#include <linux/delay.h>
+
+#define AB8500_RTC_SOFF_STAT_REG        0x0F00
+#define AB8500_RTC_CC_CONF_REG          0x0F01
+#define AB8500_RTC_READ_REQ_REG         0x0F02
+#define AB8500_RTC_WATCH_TSECMID_REG    0x0F03
+#define AB8500_RTC_WATCH_TSECHI_REG     0x0F04
+#define AB8500_RTC_WATCH_TMIN_LOW_REG   0x0F05
+#define AB8500_RTC_WATCH_TMIN_MID_REG   0x0F06
+#define AB8500_RTC_WATCH_TMIN_HI_REG    0x0F07
+#define AB8500_RTC_ALRM_MIN_LOW_REG     0x0F08
+#define AB8500_RTC_ALRM_MIN_MID_REG     0x0F09
+#define AB8500_RTC_ALRM_MIN_HI_REG      0x0F0A
+#define AB8500_RTC_STAT_REG             0x0F0B
+#define AB8500_RTC_BKUP_CHG_REG         0x0F0C
+#define AB8500_RTC_FORCE_BKUP_REG       0x0F0D
+#define AB8500_RTC_CALIB_REG            0x0F0E
+#define AB8500_RTC_SWITCH_STAT_REG      0x0F0F
+#define AB8500_REV_REG                  0x1080
+
+/* RtcReadRequest bits */
+#define RTC_READ_REQUEST                0x01
+#define RTC_WRITE_REQUEST               0x02
+
+/* RtcCtrl bits */
+#define RTC_ALARM_ENA                   0x04
+#define RTC_STATUS_DATA                 0x01
+
+#define COUNTS_PER_SEC                  (0xF000 / 60)
+#define AB8500_RTC_EPOCH                2000
+
+static const unsigned long ab8500_rtc_time_regs[] = {
+        AB8500_RTC_WATCH_TMIN_HI_REG, AB8500_RTC_WATCH_TMIN_MID_REG,
+        AB8500_RTC_WATCH_TMIN_LOW_REG, AB8500_RTC_WATCH_TSECHI_REG,
+        AB8500_RTC_WATCH_TSECMID_REG
+};
+
+static const unsigned long ab8500_rtc_alarm_regs[] = {
+        AB8500_RTC_ALRM_MIN_HI_REG, AB8500_RTC_ALRM_MIN_MID_REG,
+        AB8500_RTC_ALRM_MIN_LOW_REG
+};
+
+/* Calculate the seconds from 1970 to 01-01-2000 00:00:00 */
+static unsigned long get_elapsed_seconds(int year)
+{
+        unsigned long secs;
+        struct rtc_time tm = {
+                .tm_year = year - 1900,
+                .tm_mday = 1,
+        };
+
+        /*
+         * This function calculates secs from 1970 and not from
+         * 1900, even if we supply the offset from year 1900.
+         */
+        rtc_tm_to_time(&tm, &secs);
+        return secs;
+}
+
+static int ab8500_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct ab8500 *ab8500 = dev_get_drvdata(dev->parent);
+        unsigned long timeout = jiffies + HZ;
+        int retval, i;
+        unsigned long mins, secs;
+        unsigned char buf[ARRAY_SIZE(ab8500_rtc_time_regs)];
+
+        /* Request a data read */
+        retval = ab8500_write(ab8500, AB8500_RTC_READ_REQ_REG,
+                              RTC_READ_REQUEST);
+        if (retval < 0)
+                return retval;
+
+        /* Early AB8500 chips will not clear the rtc read request bit */
+        if (ab8500->revision == 0) {
+                msleep(1);
+        } else {
+                /* Wait for some cycles after enabling the rtc read in ab8500 */
+                while (time_before(jiffies, timeout)) {
+                        retval = ab8500_read(ab8500, AB8500_RTC_READ_REQ_REG);
+                        if (retval < 0)
+                                return retval;
+
+                        if (!(retval & RTC_READ_REQUEST))
+                                break;
+
+                        msleep(1);
+                }
+        }
+
+        /* Read the Watchtime registers */
+        for (i = 0; i < ARRAY_SIZE(ab8500_rtc_time_regs); i++) {
+                retval = ab8500_read(ab8500, ab8500_rtc_time_regs[i]);
+                if (retval < 0)
+                        return retval;
+                buf[i] = retval;
+        }
+
+        mins = (buf[0] << 16) | (buf[1] << 8) | buf[2];
+
+        secs =  (buf[3] << 8) | buf[4];
+        secs =  secs / COUNTS_PER_SEC;
+        secs =  secs + (mins * 60);
+
+        /* Add back the initially subtracted number of seconds */
+        secs += get_elapsed_seconds(AB8500_RTC_EPOCH);
+
+        rtc_time_to_tm(secs, tm);
+        return rtc_valid_tm(tm);
+}
+
+static int ab8500_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        struct ab8500 *ab8500 = dev_get_drvdata(dev->parent);
+        int retval, i;
+        unsigned char buf[ARRAY_SIZE(ab8500_rtc_time_regs)];
+        unsigned long no_secs, no_mins, secs = 0;
+
+        if (tm->tm_year < (AB8500_RTC_EPOCH - 1900)) {
+                dev_dbg(dev, "year should be equal to or greater than %d\n",
+                                AB8500_RTC_EPOCH);
+                return -EINVAL;
+        }
+
+        /* Get the number of seconds since 1970 */
+        rtc_tm_to_time(tm, &secs);
+
+        /*
+         * Convert it to the number of seconds since 01-01-2000 00:00:00, since
+         * we only have a small counter in the RTC.
+         */
+        secs -= get_elapsed_seconds(AB8500_RTC_EPOCH);
+
+        no_mins = secs / 60;
+
+        no_secs = secs % 60;
+        /* Make the seconds count as per the RTC resolution */
+        no_secs = no_secs * COUNTS_PER_SEC;
+
+        buf[4] = no_secs & 0xFF;
+        buf[3] = (no_secs >> 8) & 0xFF;
+
+        buf[2] = no_mins & 0xFF;
+        buf[1] = (no_mins >> 8) & 0xFF;
+        buf[0] = (no_mins >> 16) & 0xFF;
+
+        for (i = 0; i < ARRAY_SIZE(ab8500_rtc_time_regs); i++) {
+                retval = ab8500_write(ab8500, ab8500_rtc_time_regs[i], buf[i]);
+                if (retval < 0)
+                        return retval;
+        }
+
+        /* Request a data write */
+        return ab8500_write(ab8500, AB8500_RTC_READ_REQ_REG, RTC_WRITE_REQUEST);
+}
+
+static int ab8500_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
+{
+        struct ab8500 *ab8500 = dev_get_drvdata(dev->parent);
+        int retval, i;
+        int rtc_ctrl;
+        unsigned char buf[ARRAY_SIZE(ab8500_rtc_alarm_regs)];
+        unsigned long secs, mins;
+
+        /* Check if the alarm is enabled or not */
+        rtc_ctrl = ab8500_read(ab8500, AB8500_RTC_STAT_REG);
+        if (rtc_ctrl < 0)
+                return rtc_ctrl;
+
+        if (rtc_ctrl & RTC_ALARM_ENA)
+                alarm->enabled = 1;
+        else
+                alarm->enabled = 0;
+
+        alarm->pending = 0;
+
+        for (i = 0; i < ARRAY_SIZE(ab8500_rtc_alarm_regs); i++) {
+                retval = ab8500_read(ab8500, ab8500_rtc_alarm_regs[i]);
+                if (retval < 0)
+                        return retval;
+                buf[i] = retval;
+        }
+
+        mins = (buf[0] << 16) | (buf[1] << 8) | (buf[2]);
+        secs = mins * 60;
+
+        /* Add back the initially subtracted number of seconds */
+        secs += get_elapsed_seconds(AB8500_RTC_EPOCH);
+
+        rtc_time_to_tm(secs, &alarm->time);
+
+        return rtc_valid_tm(&alarm->time);
+}
+
+static int ab8500_rtc_irq_enable(struct device *dev, unsigned int enabled)
+{
+        struct ab8500 *ab8500 = dev_get_drvdata(dev->parent);
+
+        return ab8500_set_bits(ab8500, AB8500_RTC_STAT_REG, RTC_ALARM_ENA,
+                               enabled ? RTC_ALARM_ENA : 0);
+}
+
+static int ab8500_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
+{
+        struct ab8500 *ab8500 = dev_get_drvdata(dev->parent);
+        int retval, i;
+        unsigned char buf[ARRAY_SIZE(ab8500_rtc_alarm_regs)];
+        unsigned long mins, secs = 0;
+
+        if (alarm->time.tm_year < (AB8500_RTC_EPOCH - 1900)) {
+                dev_dbg(dev, "year should be equal to or greater than %d\n",
+                                AB8500_RTC_EPOCH);
+                return -EINVAL;
+        }
+
+        /* Get the number of seconds since 1970 */
+        rtc_tm_to_time(&alarm->time, &secs);
+
+        /*
+         * Convert it to the number of seconds since 01-01-2000 00:00:00, since
+         * we only have a small counter in the RTC.
+         */
+        secs -= get_elapsed_seconds(AB8500_RTC_EPOCH);
+
+        mins = secs / 60;
+
+        buf[2] = mins & 0xFF;
+        buf[1] = (mins >> 8) & 0xFF;
+        buf[0] = (mins >> 16) & 0xFF;
+
+        /* Set the alarm time */
+        for (i = 0; i < ARRAY_SIZE(ab8500_rtc_alarm_regs); i++) {
+                retval = ab8500_write(ab8500, ab8500_rtc_alarm_regs[i], buf[i]);
+                if (retval < 0)
+                        return retval;
+        }
+
+        return ab8500_rtc_irq_enable(dev, alarm->enabled);
+}
+
+static irqreturn_t rtc_alarm_handler(int irq, void *data)
+{
+        struct rtc_device *rtc = data;
+        unsigned long events = RTC_IRQF | RTC_AF;
+
+        dev_dbg(&rtc->dev, "%s\n", __func__);
+        rtc_update_irq(rtc, 1, events);
+
+        return IRQ_HANDLED;
+}
+
+static const struct rtc_class_ops ab8500_rtc_ops = {
+        .read_time              = ab8500_rtc_read_time,
+        .set_time               = ab8500_rtc_set_time,
+        .read_alarm             = ab8500_rtc_read_alarm,
+        .set_alarm              = ab8500_rtc_set_alarm,
+        .alarm_irq_enable       = ab8500_rtc_irq_enable,
+};
+
+static int __devinit ab8500_rtc_probe(struct platform_device *pdev)
+{
+        struct ab8500 *ab8500 = dev_get_drvdata(pdev->dev.parent);
+        int err;
+        struct rtc_device *rtc;
+        int rtc_ctrl;
+        int irq;
+
+        irq = platform_get_irq_byname(pdev, "ALARM");
+        if (irq < 0)
+                return irq;
+
+        /* For RTC supply test */
+        err = ab8500_set_bits(ab8500, AB8500_RTC_STAT_REG, RTC_STATUS_DATA,
+                        RTC_STATUS_DATA);
+        if (err < 0)
+                return err;
+
+        /* Wait for reset by the PorRtc */
+        msleep(1);
+
+        rtc_ctrl = ab8500_read(ab8500, AB8500_RTC_STAT_REG);
+        if (rtc_ctrl < 0)
+                return rtc_ctrl;
+
+        /* Check if the RTC Supply fails */
+        if (!(rtc_ctrl & RTC_STATUS_DATA)) {
+                dev_err(&pdev->dev, "RTC supply failure\n");
+                return -ENODEV;
+        }
+
+        rtc = rtc_device_register("ab8500-rtc", &pdev->dev, &ab8500_rtc_ops,
+                        THIS_MODULE);
+        if (IS_ERR(rtc)) {
+                dev_err(&pdev->dev, "Registration failed\n");
+                err = PTR_ERR(rtc);
+                return err;
+        }
+
+        err = request_threaded_irq(irq, NULL, rtc_alarm_handler, 0,
+                                   "ab8500-rtc", rtc);
+        if (err < 0) {
+                rtc_device_unregister(rtc);
+                return err;
+        }
+
+        platform_set_drvdata(pdev, rtc);
+
+        return 0;
+}
+
+static int __devexit ab8500_rtc_remove(struct platform_device *pdev)
+{
+        struct rtc_device *rtc = platform_get_drvdata(pdev);
+        int irq = platform_get_irq_byname(pdev, "ALARM");
+
+        free_irq(irq, rtc);
+        rtc_device_unregister(rtc);
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
+}
+
+static struct platform_driver ab8500_rtc_driver = {
+        .driver = {
+                .name = "ab8500-rtc",
+                .owner = THIS_MODULE,
+        },
+        .probe  = ab8500_rtc_probe,
+        .remove = __devexit_p(ab8500_rtc_remove),
+};
+
+static int __init ab8500_rtc_init(void)
+{
+        return platform_driver_register(&ab8500_rtc_driver);
+}
+
+static void __exit ab8500_rtc_exit(void)
+{
+        platform_driver_unregister(&ab8500_rtc_driver);
+}
+
+module_init(ab8500_rtc_init);
+module_exit(ab8500_rtc_exit);
+MODULE_AUTHOR("Virupax Sadashivpetimath <virupax.sadashivpetimath@stericsson.com>");
+MODULE_DESCRIPTION("AB8500 RTC Driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/rtc/rtc-m41t80.c b/drivers/rtc/rtc-m41t80.c
index 038095d99976..6dc4e6241418 100644
--- a/drivers/rtc/rtc-m41t80.c
+++ b/drivers/rtc/rtc-m41t80.c
@@ -595,10 +595,6 @@ static void wdt_disable(void)
 static ssize_t wdt_write(struct file *file, const char __user *buf,
                          size_t count, loff_t *ppos)
 {
-        /*  Can't seek (pwrite) on this device
-        if (ppos != &file->f_pos)
-        return -ESPIPE;
-        */
         if (count) {
                 wdt_ping();
                 return 1;
@@ -707,7 +703,7 @@ static int wdt_open(struct inode *inode, struct file *file)
                  */
                 wdt_is_open = 1;
                 unlock_kernel();
-                return 0;
+                return nonseekable_open(inode, file);
         }
         return -ENODEV;
 }
diff --git a/drivers/s390/block/dasd.c b/drivers/s390/block/dasd.c
index 0e86247d791e..33975e922d65 100644
--- a/drivers/s390/block/dasd.c
+++ b/drivers/s390/block/dasd.c
@@ -1186,6 +1186,29 @@ void dasd_int_handler(struct ccw_device *cdev, unsigned long intparm,
         dasd_schedule_device_bh(device);
 }
 
+enum uc_todo dasd_generic_uc_handler(struct ccw_device *cdev, struct irb *irb)
+{
+        struct dasd_device *device;
+
+        device = dasd_device_from_cdev_locked(cdev);
+
+        if (IS_ERR(device))
+                goto out;
+        if (test_bit(DASD_FLAG_OFFLINE, &device->flags) ||
+           device->state != device->target ||
+           !device->discipline->handle_unsolicited_interrupt){
+                dasd_put_device(device);
+                goto out;
+        }
+
+        dasd_device_clear_timer(device);
+        device->discipline->handle_unsolicited_interrupt(device, irb);
+        dasd_put_device(device);
+out:
+        return UC_TODO_RETRY;
+}
+EXPORT_SYMBOL_GPL(dasd_generic_uc_handler);
+
 /*
  * If we have an error on a dasd_block layer request then we cancel
  * and return all further requests from the same dasd_block as well.
diff --git a/drivers/s390/block/dasd_eckd.c b/drivers/s390/block/dasd_eckd.c
index 5b1cd8d6e971..ab84da5592e8 100644
--- a/drivers/s390/block/dasd_eckd.c
+++ b/drivers/s390/block/dasd_eckd.c
@@ -3436,6 +3436,7 @@ static struct ccw_driver dasd_eckd_driver = {
         .freeze      = dasd_generic_pm_freeze,
         .thaw        = dasd_generic_restore_device,
         .restore     = dasd_generic_restore_device,
+        .uc_handler  = dasd_generic_uc_handler,
 };
 
 /*
diff --git a/drivers/s390/block/dasd_int.h b/drivers/s390/block/dasd_int.h
index 32fac186ba3f..49b431d135e0 100644
--- a/drivers/s390/block/dasd_int.h
+++ b/drivers/s390/block/dasd_int.h
@@ -617,6 +617,7 @@ int dasd_generic_notify(struct ccw_device *, int);
 void dasd_generic_handle_state_change(struct dasd_device *);
 int dasd_generic_pm_freeze(struct ccw_device *);
 int dasd_generic_restore_device(struct ccw_device *);
+enum uc_todo dasd_generic_uc_handler(struct ccw_device *, struct irb *);
 
 int dasd_generic_read_dev_chars(struct dasd_device *, int, void *, int);
 char *dasd_get_sense(struct irb *);
diff --git a/drivers/s390/cio/ccwgroup.c b/drivers/s390/cio/ccwgroup.c
index 5f97ea2ee6b1..97b25d68e3e7 100644
--- a/drivers/s390/cio/ccwgroup.c
+++ b/drivers/s390/cio/ccwgroup.c
@@ -123,8 +123,10 @@ ccwgroup_release (struct device *dev)
 
         for (i = 0; i < gdev->count; i++) {
                 if (gdev->cdev[i]) {
+                        spin_lock_irq(gdev->cdev[i]->ccwlock);
                         if (dev_get_drvdata(&gdev->cdev[i]->dev) == gdev)
                                 dev_set_drvdata(&gdev->cdev[i]->dev, NULL);
+                        spin_unlock_irq(gdev->cdev[i]->ccwlock);
                         put_device(&gdev->cdev[i]->dev);
                 }
         }
@@ -262,11 +264,14 @@ int ccwgroup_create_from_string(struct device *root, unsigned int creator_id,
                         goto error;
                 }
                 /* Don't allow a device to belong to more than one group. */
+                spin_lock_irq(gdev->cdev[i]->ccwlock);
                 if (dev_get_drvdata(&gdev->cdev[i]->dev)) {
+                        spin_unlock_irq(gdev->cdev[i]->ccwlock);
                         rc = -EINVAL;
                         goto error;
                 }
                 dev_set_drvdata(&gdev->cdev[i]->dev, gdev);
+                spin_unlock_irq(gdev->cdev[i]->ccwlock);
         }
         /* Check for sufficient number of bus ids. */
         if (i < num_devices && !curr_buf) {
@@ -303,8 +308,10 @@ int ccwgroup_create_from_string(struct device *root, unsigned int creator_id,
 error:
         for (i = 0; i < num_devices; i++)
                 if (gdev->cdev[i]) {
+                        spin_lock_irq(gdev->cdev[i]->ccwlock);
                         if (dev_get_drvdata(&gdev->cdev[i]->dev) == gdev)
                                 dev_set_drvdata(&gdev->cdev[i]->dev, NULL);
+                        spin_unlock_irq(gdev->cdev[i]->ccwlock);
                         put_device(&gdev->cdev[i]->dev);
                         gdev->cdev[i] = NULL;
                 }
diff --git a/drivers/s390/cio/ccwreq.c b/drivers/s390/cio/ccwreq.c
index 37df42af05ec..7f206ed44fdf 100644
--- a/drivers/s390/cio/ccwreq.c
+++ b/drivers/s390/cio/ccwreq.c
@@ -159,6 +159,7 @@ static enum io_status ccwreq_status(struct ccw_device *cdev, struct irb *lcirb)
 {
         struct irb *irb = &cdev->private->irb;
         struct cmd_scsw *scsw = &irb->scsw.cmd;
+        enum uc_todo todo;
 
         /* Perform BASIC SENSE if needed. */
         if (ccw_device_accumulate_and_sense(cdev, lcirb))
@@ -178,6 +179,20 @@ static enum io_status ccwreq_status(struct ccw_device *cdev, struct irb *lcirb)
                 /* Check for command reject. */
                 if (irb->ecw[0] & SNS0_CMD_REJECT)
                         return IO_REJECTED;
+                /* Ask the driver what to do */
+                if (cdev->drv && cdev->drv->uc_handler) {
+                        todo = cdev->drv->uc_handler(cdev, lcirb);
+                        switch (todo) {
+                        case UC_TODO_RETRY:
+                                return IO_STATUS_ERROR;
+                        case UC_TODO_RETRY_ON_NEW_PATH:
+                                return IO_PATH_ERROR;
+                        case UC_TODO_STOP:
+                                return IO_REJECTED;
+                        default:
+                                return IO_STATUS_ERROR;
+                        }
+                }
                 /* Assume that unexpected SENSE data implies an error. */
                 return IO_STATUS_ERROR;
         }
diff --git a/drivers/s390/cio/ioasm.h b/drivers/s390/cio/ioasm.h
index 759262792633..fac06155773f 100644
--- a/drivers/s390/cio/ioasm.h
+++ b/drivers/s390/cio/ioasm.h
@@ -23,21 +23,6 @@ struct tpi_info {
  * Some S390 specific IO instructions as inline
  */
 
-static inline int stsch(struct subchannel_id schid, struct schib *addr)
-{
-        register struct subchannel_id reg1 asm ("1") = schid;
-        int ccode;
-
-        asm volatile(
-                "       stsch   0(%3)\n"
-                "       ipm     %0\n"
-                "       srl     %0,28"
-                : "=d" (ccode), "=m" (*addr)
-                : "d" (reg1), "a" (addr)
-                : "cc");
-        return ccode;
-}
-
 static inline int stsch_err(struct subchannel_id schid, struct schib *addr)
 {
         register struct subchannel_id reg1 asm ("1") = schid;
diff --git a/drivers/scsi/a2091.c b/drivers/scsi/a2091.c
index 308541ff85cf..1bb5d3f0e260 100644
--- a/drivers/scsi/a2091.c
+++ b/drivers/scsi/a2091.c
@@ -1,34 +1,31 @@
 #include <linux/types.h>
-#include <linux/mm.h>
-#include <linux/slab.h>
-#include <linux/blkdev.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
+#include <linux/mm.h>
+#include <linux/slab.h>
+#include <linux/spinlock.h>
+#include <linux/zorro.h>
 
-#include <asm/setup.h>
 #include <asm/page.h>
 #include <asm/pgtable.h>
 #include <asm/amigaints.h>
 #include <asm/amigahw.h>
-#include <linux/zorro.h>
-#include <asm/irq.h>
-#include <linux/spinlock.h>
 
 #include "scsi.h"
-#include <scsi/scsi_host.h>
 #include "wd33c93.h"
 #include "a2091.h"
 
-#include <linux/stat.h>
-
 
-static int a2091_release(struct Scsi_Host *instance);
+struct a2091_hostdata {
+        struct WD33C93_hostdata wh;
+        struct a2091_scsiregs *regs;
+};
 
 static irqreturn_t a2091_intr(int irq, void *data)
 {
         struct Scsi_Host *instance = data;
-        a2091_scsiregs *regs = (a2091_scsiregs *)(instance->base);
-        unsigned int status = regs->ISTR;
+        struct a2091_hostdata *hdata = shost_priv(instance);
+        unsigned int status = hdata->regs->ISTR;
         unsigned long flags;
 
         if (!(status & (ISTR_INT_F | ISTR_INT_P)) || !(status & ISTR_INTS))
@@ -43,38 +40,39 @@ static irqreturn_t a2091_intr(int irq, void *data)
 static int dma_setup(struct scsi_cmnd *cmd, int dir_in)
 {
         struct Scsi_Host *instance = cmd->device->host;
-        struct WD33C93_hostdata *hdata = shost_priv(instance);
-        a2091_scsiregs *regs = (a2091_scsiregs *)(instance->base);
+        struct a2091_hostdata *hdata = shost_priv(instance);
+        struct WD33C93_hostdata *wh = &hdata->wh;
+        struct a2091_scsiregs *regs = hdata->regs;
         unsigned short cntr = CNTR_PDMD | CNTR_INTEN;
         unsigned long addr = virt_to_bus(cmd->SCp.ptr);
 
         /* don't allow DMA if the physical address is bad */
         if (addr & A2091_XFER_MASK) {
-                hdata->dma_bounce_len = (cmd->SCp.this_residual + 511) & ~0x1ff;
-                hdata->dma_bounce_buffer = kmalloc(hdata->dma_bounce_len,
-                                                   GFP_KERNEL);
+                wh->dma_bounce_len = (cmd->SCp.this_residual + 511) & ~0x1ff;
+                wh->dma_bounce_buffer = kmalloc(wh->dma_bounce_len,
+                                                GFP_KERNEL);
 
                 /* can't allocate memory; use PIO */
-                if (!hdata->dma_bounce_buffer) {
-                        hdata->dma_bounce_len = 0;
+                if (!wh->dma_bounce_buffer) {
+                        wh->dma_bounce_len = 0;
                         return 1;
                 }
 
                 /* get the physical address of the bounce buffer */
-                addr = virt_to_bus(hdata->dma_bounce_buffer);
+                addr = virt_to_bus(wh->dma_bounce_buffer);
 
                 /* the bounce buffer may not be in the first 16M of physmem */
                 if (addr & A2091_XFER_MASK) {
                         /* we could use chipmem... maybe later */
-                        kfree(hdata->dma_bounce_buffer);
-                        hdata->dma_bounce_buffer = NULL;
-                        hdata->dma_bounce_len = 0;
+                        kfree(wh->dma_bounce_buffer);
+                        wh->dma_bounce_buffer = NULL;
+                        wh->dma_bounce_len = 0;
                         return 1;
                 }
 
                 if (!dir_in) {
                         /* copy to bounce buffer for a write */
-                        memcpy(hdata->dma_bounce_buffer, cmd->SCp.ptr,
+                        memcpy(wh->dma_bounce_buffer, cmd->SCp.ptr,
                                cmd->SCp.this_residual);
                 }
         }
@@ -84,7 +82,7 @@ static int dma_setup(struct scsi_cmnd *cmd, int dir_in)
                 cntr |= CNTR_DDIR;
 
         /* remember direction */
-        hdata->dma_dir = dir_in;
+        wh->dma_dir = dir_in;
 
         regs->CNTR = cntr;
 
@@ -108,20 +106,21 @@ static int dma_setup(struct scsi_cmnd *cmd, int dir_in)
 static void dma_stop(struct Scsi_Host *instance, struct scsi_cmnd *SCpnt,
                      int status)
 {
-        struct WD33C93_hostdata *hdata = shost_priv(instance);
-        a2091_scsiregs *regs = (a2091_scsiregs *)(instance->base);
+        struct a2091_hostdata *hdata = shost_priv(instance);
+        struct WD33C93_hostdata *wh = &hdata->wh;
+        struct a2091_scsiregs *regs = hdata->regs;
 
         /* disable SCSI interrupts */
         unsigned short cntr = CNTR_PDMD;
 
-        if (!hdata->dma_dir)
+        if (!wh->dma_dir)
                 cntr |= CNTR_DDIR;
 
         /* disable SCSI interrupts */
         regs->CNTR = cntr;
 
         /* flush if we were reading */
-        if (hdata->dma_dir) {
+        if (wh->dma_dir) {
                 regs->FLUSH = 1;
                 while (!(regs->ISTR & ISTR_FE_FLG))
                         ;
@@ -137,95 +136,37 @@ static void dma_stop(struct Scsi_Host *instance, struct scsi_cmnd *SCpnt,
         regs->CNTR = CNTR_PDMD | CNTR_INTEN;
 
         /* copy from a bounce buffer, if necessary */
-        if (status && hdata->dma_bounce_buffer) {
-                if (hdata->dma_dir)
-                        memcpy(SCpnt->SCp.ptr, hdata->dma_bounce_buffer,
+        if (status && wh->dma_bounce_buffer) {
+                if (wh->dma_dir)
+                        memcpy(SCpnt->SCp.ptr, wh->dma_bounce_buffer,
                                SCpnt->SCp.this_residual);
-                kfree(hdata->dma_bounce_buffer);
-                hdata->dma_bounce_buffer = NULL;
-                hdata->dma_bounce_len = 0;
-        }
-}
-
-static int __init a2091_detect(struct scsi_host_template *tpnt)
-{
-        static unsigned char called = 0;
-        struct Scsi_Host *instance;
-        unsigned long address;
-        struct zorro_dev *z = NULL;
-        wd33c93_regs wdregs;
-        a2091_scsiregs *regs;
-        struct WD33C93_hostdata *hdata;
-        int num_a2091 = 0;
-
-        if (!MACH_IS_AMIGA || called)
-                return 0;
-        called = 1;
-
-        tpnt->proc_name = "A2091";
-        tpnt->proc_info = &wd33c93_proc_info;
-
-        while ((z = zorro_find_device(ZORRO_WILDCARD, z))) {
-                if (z->id != ZORRO_PROD_CBM_A590_A2091_1 &&
-                    z->id != ZORRO_PROD_CBM_A590_A2091_2)
-                        continue;
-                address = z->resource.start;
-                if (!request_mem_region(address, 256, "wd33c93"))
-                        continue;
-
-                instance = scsi_register(tpnt, sizeof(struct WD33C93_hostdata));
-                if (instance == NULL)
-                        goto release;
-                instance->base = ZTWO_VADDR(address);
-                instance->irq = IRQ_AMIGA_PORTS;
-                instance->unique_id = z->slotaddr;
-                regs = (a2091_scsiregs *)(instance->base);
-                regs->DAWR = DAWR_A2091;
-                wdregs.SASR = &regs->SASR;
-                wdregs.SCMD = &regs->SCMD;
-                hdata = shost_priv(instance);
-                hdata->no_sync = 0xff;
-                hdata->fast = 0;
-                hdata->dma_mode = CTRL_DMA;
-                wd33c93_init(instance, wdregs, dma_setup, dma_stop,
-                             WD33C93_FS_8_10);
-                if (request_irq(IRQ_AMIGA_PORTS, a2091_intr, IRQF_SHARED,
-                                "A2091 SCSI", instance))
-                        goto unregister;
-                regs->CNTR = CNTR_PDMD | CNTR_INTEN;
-                num_a2091++;
-                continue;
-
-unregister:
-                scsi_unregister(instance);
-release:
-                release_mem_region(address, 256);
+                kfree(wh->dma_bounce_buffer);
+                wh->dma_bounce_buffer = NULL;
+                wh->dma_bounce_len = 0;
         }
-
-        return num_a2091;
 }
 
 static int a2091_bus_reset(struct scsi_cmnd *cmd)
 {
+        struct Scsi_Host *instance = cmd->device->host;
+
         /* FIXME perform bus-specific reset */
 
         /* FIXME 2: kill this function, and let midlayer fall back
            to the same action, calling wd33c93_host_reset() */
 
-        spin_lock_irq(cmd->device->host->host_lock);
+        spin_lock_irq(instance->host_lock);
         wd33c93_host_reset(cmd);
-        spin_unlock_irq(cmd->device->host->host_lock);
+        spin_unlock_irq(instance->host_lock);
 
         return SUCCESS;
 }
 
-#define HOSTS_C
-
-static struct scsi_host_template driver_template = {
-        .proc_name              = "A2901",
+static struct scsi_host_template a2091_scsi_template = {
+        .module                 = THIS_MODULE,
         .name                   = "Commodore A2091/A590 SCSI",
-        .detect                 = a2091_detect,
-        .release                = a2091_release,
+        .proc_info              = wd33c93_proc_info,
+        .proc_name              = "A2901",
         .queuecommand           = wd33c93_queuecommand,
         .eh_abort_handler       = wd33c93_abort,
         .eh_bus_reset_handler   = a2091_bus_reset,
@@ -237,19 +178,103 @@ static struct scsi_host_template driver_template = {
         .use_clustering         = DISABLE_CLUSTERING
 };
 
+static int __devinit a2091_probe(struct zorro_dev *z,
+                                 const struct zorro_device_id *ent)
+{
+        struct Scsi_Host *instance;
+        int error;
+        struct a2091_scsiregs *regs;
+        wd33c93_regs wdregs;
+        struct a2091_hostdata *hdata;
 
-#include "scsi_module.c"
+        if (!request_mem_region(z->resource.start, 256, "wd33c93"))
+                return -EBUSY;
 
-static int a2091_release(struct Scsi_Host *instance)
+        instance = scsi_host_alloc(&a2091_scsi_template,
+                                   sizeof(struct a2091_hostdata));
+        if (!instance) {
+                error = -ENOMEM;
+                goto fail_alloc;
+        }
+
+        instance->irq = IRQ_AMIGA_PORTS;
+        instance->unique_id = z->slotaddr;
+
+        regs = (struct a2091_scsiregs *)ZTWO_VADDR(z->resource.start);
+        regs->DAWR = DAWR_A2091;
+
+        wdregs.SASR = &regs->SASR;
+        wdregs.SCMD = &regs->SCMD;
+
+        hdata = shost_priv(instance);
+        hdata->wh.no_sync = 0xff;
+        hdata->wh.fast = 0;
+        hdata->wh.dma_mode = CTRL_DMA;
+        hdata->regs = regs;
+
+        wd33c93_init(instance, wdregs, dma_setup, dma_stop, WD33C93_FS_8_10);
+        error = request_irq(IRQ_AMIGA_PORTS, a2091_intr, IRQF_SHARED,
+                            "A2091 SCSI", instance);
+        if (error)
+                goto fail_irq;
+
+        regs->CNTR = CNTR_PDMD | CNTR_INTEN;
+
+        error = scsi_add_host(instance, NULL);
+        if (error)
+                goto fail_host;
+
+        zorro_set_drvdata(z, instance);
+
+        scsi_scan_host(instance);
+        return 0;
+
+fail_host:
+        free_irq(IRQ_AMIGA_PORTS, instance);
+fail_irq:
+        scsi_host_put(instance);
+fail_alloc:
+        release_mem_region(z->resource.start, 256);
+        return error;
+}
+
+static void __devexit a2091_remove(struct zorro_dev *z)
 {
-#ifdef MODULE
-        a2091_scsiregs *regs = (a2091_scsiregs *)(instance->base);
+        struct Scsi_Host *instance = zorro_get_drvdata(z);
+        struct a2091_hostdata *hdata = shost_priv(instance);
 
-        regs->CNTR = 0;
-        release_mem_region(ZTWO_PADDR(instance->base), 256);
+        hdata->regs->CNTR = 0;
+        scsi_remove_host(instance);
         free_irq(IRQ_AMIGA_PORTS, instance);
-#endif
-        return 1;
+        scsi_host_put(instance);
+        release_mem_region(z->resource.start, 256);
+}
+
+static struct zorro_device_id a2091_zorro_tbl[] __devinitdata = {
+        { ZORRO_PROD_CBM_A590_A2091_1 },
+        { ZORRO_PROD_CBM_A590_A2091_2 },
+        { 0 }
+};
+MODULE_DEVICE_TABLE(zorro, a2091_zorro_tbl);
+
+static struct zorro_driver a2091_driver = {
+        .name           = "a2091",
+        .id_table       = a2091_zorro_tbl,
+        .probe          = a2091_probe,
+        .remove         = __devexit_p(a2091_remove),
+};
+
+static int __init a2091_init(void)
+{
+        return zorro_register_driver(&a2091_driver);
+}
+module_init(a2091_init);
+
+static void __exit a2091_exit(void)
+{
+        zorro_unregister_driver(&a2091_driver);
 }
+module_exit(a2091_exit);
 
+MODULE_DESCRIPTION("Commodore A2091/A590 SCSI");
 MODULE_LICENSE("GPL");
diff --git a/drivers/scsi/a2091.h b/drivers/scsi/a2091.h
index 1c3daa1fd754..794b8e65c711 100644
--- a/drivers/scsi/a2091.h
+++ b/drivers/scsi/a2091.h
@@ -25,7 +25,7 @@
  */
 #define A2091_XFER_MASK         (0xff000001)
 
-typedef struct {
+struct a2091_scsiregs {
                  unsigned char  pad1[64];
         volatile unsigned short ISTR;
         volatile unsigned short CNTR;
@@ -44,7 +44,7 @@ typedef struct {
         volatile unsigned short CINT;
                  unsigned char  pad7[2];
         volatile unsigned short FLUSH;
-} a2091_scsiregs;
+};
 
 #define DAWR_A2091              (3)
 
diff --git a/drivers/scsi/a3000.c b/drivers/scsi/a3000.c
index bc6eb69f5fd0..d9468027fb61 100644
--- a/drivers/scsi/a3000.c
+++ b/drivers/scsi/a3000.c
@@ -1,53 +1,52 @@
 #include <linux/types.h>
 #include <linux/mm.h>
-#include <linux/slab.h>
-#include <linux/blkdev.h>
 #include <linux/ioport.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <linux/spinlock.h>
 #include <linux/interrupt.h>
+#include <linux/platform_device.h>
 
-#include <asm/setup.h>
 #include <asm/page.h>
 #include <asm/pgtable.h>
 #include <asm/amigaints.h>
 #include <asm/amigahw.h>
-#include <asm/irq.h>
 
 #include "scsi.h"
-#include <scsi/scsi_host.h>
 #include "wd33c93.h"
 #include "a3000.h"
 
-#include <linux/stat.h>
-
 
-#define DMA(ptr)        ((a3000_scsiregs *)((ptr)->base))
-
-static struct Scsi_Host *a3000_host = NULL;
-
-static int a3000_release(struct Scsi_Host *instance);
+struct a3000_hostdata {
+        struct WD33C93_hostdata wh;
+        struct a3000_scsiregs *regs;
+};
 
-static irqreturn_t a3000_intr(int irq, void *dummy)
+static irqreturn_t a3000_intr(int irq, void *data)
 {
+        struct Scsi_Host *instance = data;
+        struct a3000_hostdata *hdata = shost_priv(instance);
+        unsigned int status = hdata->regs->ISTR;
         unsigned long flags;
-        unsigned int status = DMA(a3000_host)->ISTR;
 
         if (!(status & ISTR_INT_P))
                 return IRQ_NONE;
         if (status & ISTR_INTS) {
-                spin_lock_irqsave(a3000_host->host_lock, flags);
-                wd33c93_intr(a3000_host);
-                spin_unlock_irqrestore(a3000_host->host_lock, flags);
+                spin_lock_irqsave(instance->host_lock, flags);
+                wd33c93_intr(instance);
+                spin_unlock_irqrestore(instance->host_lock, flags);
                 return IRQ_HANDLED;
         }
-        printk("Non-serviced A3000 SCSI-interrupt? ISTR = %02x\n", status);
+        pr_warning("Non-serviced A3000 SCSI-interrupt? ISTR = %02x\n", status);
         return IRQ_NONE;
 }
 
 static int dma_setup(struct scsi_cmnd *cmd, int dir_in)
 {
-        struct WD33C93_hostdata *hdata = shost_priv(a3000_host);
+        struct Scsi_Host *instance = cmd->device->host;
+        struct a3000_hostdata *hdata = shost_priv(instance);
+        struct WD33C93_hostdata *wh = &hdata->wh;
+        struct a3000_scsiregs *regs = hdata->regs;
         unsigned short cntr = CNTR_PDMD | CNTR_INTEN;
         unsigned long addr = virt_to_bus(cmd->SCp.ptr);
 
@@ -58,23 +57,23 @@ static int dma_setup(struct scsi_cmnd *cmd, int dir_in)
          * buffer
          */
         if (addr & A3000_XFER_MASK) {
-                hdata->dma_bounce_len = (cmd->SCp.this_residual + 511) & ~0x1ff;
-                hdata->dma_bounce_buffer = kmalloc(hdata->dma_bounce_len,
-                                                   GFP_KERNEL);
+                wh->dma_bounce_len = (cmd->SCp.this_residual + 511) & ~0x1ff;
+                wh->dma_bounce_buffer = kmalloc(wh->dma_bounce_len,
+                                                GFP_KERNEL);
 
                 /* can't allocate memory; use PIO */
-                if (!hdata->dma_bounce_buffer) {
-                        hdata->dma_bounce_len = 0;
+                if (!wh->dma_bounce_buffer) {
+                        wh->dma_bounce_len = 0;
                         return 1;
                 }
 
                 if (!dir_in) {
                         /* copy to bounce buffer for a write */
-                        memcpy(hdata->dma_bounce_buffer, cmd->SCp.ptr,
+                        memcpy(wh->dma_bounce_buffer, cmd->SCp.ptr,
                                cmd->SCp.this_residual);
                 }
 
-                addr = virt_to_bus(hdata->dma_bounce_buffer);
+                addr = virt_to_bus(wh->dma_bounce_buffer);
         }
 
         /* setup dma direction */
@@ -82,12 +81,12 @@ static int dma_setup(struct scsi_cmnd *cmd, int dir_in)
                 cntr |= CNTR_DDIR;
 
         /* remember direction */
-        hdata->dma_dir = dir_in;
+        wh->dma_dir = dir_in;
 
-        DMA(a3000_host)->CNTR = cntr;
+        regs->CNTR = cntr;
 
         /* setup DMA *physical* address */
-        DMA(a3000_host)->ACR = addr;
+        regs->ACR = addr;
 
         if (dir_in) {
                 /* invalidate any cache */
@@ -99,7 +98,7 @@ static int dma_setup(struct scsi_cmnd *cmd, int dir_in)
 
         /* start DMA */
         mb();                   /* make sure setup is completed */
-        DMA(a3000_host)->ST_DMA = 1;
+        regs->ST_DMA = 1;
         mb();                   /* make sure DMA has started before next IO */
 
         /* return success */
@@ -109,22 +108,24 @@ static int dma_setup(struct scsi_cmnd *cmd, int dir_in)
 static void dma_stop(struct Scsi_Host *instance, struct scsi_cmnd *SCpnt,
                      int status)
 {
-        struct WD33C93_hostdata *hdata = shost_priv(instance);
+        struct a3000_hostdata *hdata = shost_priv(instance);
+        struct WD33C93_hostdata *wh = &hdata->wh;
+        struct a3000_scsiregs *regs = hdata->regs;
 
         /* disable SCSI interrupts */
         unsigned short cntr = CNTR_PDMD;
 
-        if (!hdata->dma_dir)
+        if (!wh->dma_dir)
                 cntr |= CNTR_DDIR;
 
-        DMA(instance)->CNTR = cntr;
+        regs->CNTR = cntr;
         mb();                   /* make sure CNTR is updated before next IO */
 
         /* flush if we were reading */
-        if (hdata->dma_dir) {
-                DMA(instance)->FLUSH = 1;
+        if (wh->dma_dir) {
+                regs->FLUSH = 1;
                 mb();           /* don't allow prefetch */
-                while (!(DMA(instance)->ISTR & ISTR_FE_FLG))
+                while (!(regs->ISTR & ISTR_FE_FLG))
                         barrier();
                 mb();           /* no IO until FLUSH is done */
         }
@@ -133,96 +134,54 @@ static void dma_stop(struct Scsi_Host *instance, struct scsi_cmnd *SCpnt,
         /* I think that this CINT is only necessary if you are
          * using the terminal count features.   HM 7 Mar 1994
          */
-        DMA(instance)->CINT = 1;
+        regs->CINT = 1;
 
         /* stop DMA */
-        DMA(instance)->SP_DMA = 1;
+        regs->SP_DMA = 1;
         mb();                   /* make sure DMA is stopped before next IO */
 
         /* restore the CONTROL bits (minus the direction flag) */
-        DMA(instance)->CNTR = CNTR_PDMD | CNTR_INTEN;
+        regs->CNTR = CNTR_PDMD | CNTR_INTEN;
         mb();                   /* make sure CNTR is updated before next IO */
 
         /* copy from a bounce buffer, if necessary */
-        if (status && hdata->dma_bounce_buffer) {
+        if (status && wh->dma_bounce_buffer) {
                 if (SCpnt) {
-                        if (hdata->dma_dir && SCpnt)
-                                memcpy(SCpnt->SCp.ptr,
-                                       hdata->dma_bounce_buffer,
+                        if (wh->dma_dir && SCpnt)
+                                memcpy(SCpnt->SCp.ptr, wh->dma_bounce_buffer,
                                        SCpnt->SCp.this_residual);
-                        kfree(hdata->dma_bounce_buffer);
-                        hdata->dma_bounce_buffer = NULL;
-                        hdata->dma_bounce_len = 0;
+                        kfree(wh->dma_bounce_buffer);
+                        wh->dma_bounce_buffer = NULL;
+                        wh->dma_bounce_len = 0;
                 } else {
-                        kfree(hdata->dma_bounce_buffer);
-                        hdata->dma_bounce_buffer = NULL;
-                        hdata->dma_bounce_len = 0;
+                        kfree(wh->dma_bounce_buffer);
+                        wh->dma_bounce_buffer = NULL;
+                        wh->dma_bounce_len = 0;
                 }
         }
 }
 
-static int __init a3000_detect(struct scsi_host_template *tpnt)
-{
-        wd33c93_regs regs;
-        struct WD33C93_hostdata *hdata;
-
-        if (!MACH_IS_AMIGA || !AMIGAHW_PRESENT(A3000_SCSI))
-                return 0;
-        if (!request_mem_region(0xDD0000, 256, "wd33c93"))
-                return 0;
-
-        tpnt->proc_name = "A3000";
-        tpnt->proc_info = &wd33c93_proc_info;
-
-        a3000_host = scsi_register(tpnt, sizeof(struct WD33C93_hostdata));
-        if (a3000_host == NULL)
-                goto fail_register;
-
-        a3000_host->base = ZTWO_VADDR(0xDD0000);
-        a3000_host->irq = IRQ_AMIGA_PORTS;
-        DMA(a3000_host)->DAWR = DAWR_A3000;
-        regs.SASR = &(DMA(a3000_host)->SASR);
-        regs.SCMD = &(DMA(a3000_host)->SCMD);
-        hdata = shost_priv(a3000_host);
-        hdata->no_sync = 0xff;
-        hdata->fast = 0;
-        hdata->dma_mode = CTRL_DMA;
-        wd33c93_init(a3000_host, regs, dma_setup, dma_stop, WD33C93_FS_12_15);
-        if (request_irq(IRQ_AMIGA_PORTS, a3000_intr, IRQF_SHARED, "A3000 SCSI",
-                        a3000_intr))
-                goto fail_irq;
-        DMA(a3000_host)->CNTR = CNTR_PDMD | CNTR_INTEN;
-
-        return 1;
-
-fail_irq:
-        scsi_unregister(a3000_host);
-fail_register:
-        release_mem_region(0xDD0000, 256);
-        return 0;
-}
-
 static int a3000_bus_reset(struct scsi_cmnd *cmd)
 {
+        struct Scsi_Host *instance = cmd->device->host;
+
         /* FIXME perform bus-specific reset */
 
         /* FIXME 2: kill this entire function, which should
            cause mid-layer to call wd33c93_host_reset anyway? */
 
-        spin_lock_irq(cmd->device->host->host_lock);
+        spin_lock_irq(instance->host_lock);
         wd33c93_host_reset(cmd);
-        spin_unlock_irq(cmd->device->host->host_lock);
+        spin_unlock_irq(instance->host_lock);
 
         return SUCCESS;
 }
 
-#define HOSTS_C
-
-static struct scsi_host_template driver_template = {
-        .proc_name              = "A3000",
+static struct scsi_host_template amiga_a3000_scsi_template = {
+        .module                 = THIS_MODULE,
         .name                   = "Amiga 3000 built-in SCSI",
-        .detect                 = a3000_detect,
-        .release                = a3000_release,
+        .proc_info              = wd33c93_proc_info,
+        .proc_name              = "A3000",
         .queuecommand           = wd33c93_queuecommand,
         .eh_abort_handler       = wd33c93_abort,
         .eh_bus_reset_handler   = a3000_bus_reset,
@@ -234,15 +193,104 @@ static struct scsi_host_template driver_template = {
         .use_clustering         = ENABLE_CLUSTERING
 };
 
+static int __init amiga_a3000_scsi_probe(struct platform_device *pdev)
+{
+        struct resource *res;
+        struct Scsi_Host *instance;
+        int error;
+        struct a3000_scsiregs *regs;
+        wd33c93_regs wdregs;
+        struct a3000_hostdata *hdata;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res)
+                return -ENODEV;
+
+        if (!request_mem_region(res->start, resource_size(res), "wd33c93"))
+                return -EBUSY;
+
+        instance = scsi_host_alloc(&amiga_a3000_scsi_template,
+                                   sizeof(struct a3000_hostdata));
+        if (!instance) {
+                error = -ENOMEM;
+                goto fail_alloc;
+        }
+
+        instance->irq = IRQ_AMIGA_PORTS;
 
-#include "scsi_module.c"
+        regs = (struct a3000_scsiregs *)ZTWO_VADDR(res->start);
+        regs->DAWR = DAWR_A3000;
+
+        wdregs.SASR = &regs->SASR;
+        wdregs.SCMD = &regs->SCMD;
+
+        hdata = shost_priv(instance);
+        hdata->wh.no_sync = 0xff;
+        hdata->wh.fast = 0;
+        hdata->wh.dma_mode = CTRL_DMA;
+        hdata->regs = regs;
+
+        wd33c93_init(instance, wdregs, dma_setup, dma_stop, WD33C93_FS_12_15);
+        error = request_irq(IRQ_AMIGA_PORTS, a3000_intr, IRQF_SHARED,
+                            "A3000 SCSI", instance);
+        if (error)
+                goto fail_irq;
+
+        regs->CNTR = CNTR_PDMD | CNTR_INTEN;
+
+        error = scsi_add_host(instance, NULL);
+        if (error)
+                goto fail_host;
+
+        platform_set_drvdata(pdev, instance);
+
+        scsi_scan_host(instance);
+        return 0;
+
+fail_host:
+        free_irq(IRQ_AMIGA_PORTS, instance);
+fail_irq:
+        scsi_host_put(instance);
+fail_alloc:
+        release_mem_region(res->start, resource_size(res));
+        return error;
+}
+
+static int __exit amiga_a3000_scsi_remove(struct platform_device *pdev)
+{
+        struct Scsi_Host *instance = platform_get_drvdata(pdev);
+        struct a3000_hostdata *hdata = shost_priv(instance);
+        struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+
+        hdata->regs->CNTR = 0;
+        scsi_remove_host(instance);
+        free_irq(IRQ_AMIGA_PORTS, instance);
+        scsi_host_put(instance);
+        release_mem_region(res->start, resource_size(res));
+        return 0;
+}
+
+static struct platform_driver amiga_a3000_scsi_driver = {
+        .remove = __exit_p(amiga_a3000_scsi_remove),
+        .driver   = {
+                .name   = "amiga-a3000-scsi",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init amiga_a3000_scsi_init(void)
+{
+        return platform_driver_probe(&amiga_a3000_scsi_driver,
+                                     amiga_a3000_scsi_probe);
+}
+module_init(amiga_a3000_scsi_init);
 
-static int a3000_release(struct Scsi_Host *instance)
+static void __exit amiga_a3000_scsi_exit(void)
 {
-        DMA(instance)->CNTR = 0;
-        release_mem_region(0xDD0000, 256);
-        free_irq(IRQ_AMIGA_PORTS, a3000_intr);
-        return 1;
+        platform_driver_unregister(&amiga_a3000_scsi_driver);
 }
+module_exit(amiga_a3000_scsi_exit);
 
+MODULE_DESCRIPTION("Amiga 3000 built-in SCSI");
 MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:amiga-a3000-scsi");
diff --git a/drivers/scsi/a3000.h b/drivers/scsi/a3000.h
index 684813ee378c..49db4a335aab 100644
--- a/drivers/scsi/a3000.h
+++ b/drivers/scsi/a3000.h
@@ -25,7 +25,7 @@
  */
 #define A3000_XFER_MASK         (0x00000003)
 
-typedef struct {
+struct a3000_scsiregs {
                  unsigned char  pad1[2];
         volatile unsigned short DAWR;
         volatile unsigned int   WTC;
@@ -46,7 +46,7 @@ typedef struct {
         volatile unsigned char  SASR;
                  unsigned char  pad9;
         volatile unsigned char  SCMD;
-} a3000_scsiregs;
+};
 
 #define DAWR_A3000              (3)
 
diff --git a/drivers/scsi/a4000t.c b/drivers/scsi/a4000t.c
index 11ae6be8aeaf..23c76f41883c 100644
--- a/drivers/scsi/a4000t.c
+++ b/drivers/scsi/a4000t.c
@@ -20,10 +20,6 @@
 
 #include "53c700.h"
 
-MODULE_AUTHOR("Alan Hourihane <alanh@fairlite.demon.co.uk> / Kars de Jong <jongk@linux-m68k.org>");
-MODULE_DESCRIPTION("Amiga A4000T NCR53C710 driver");
-MODULE_LICENSE("GPL");
-
 
 static struct scsi_host_template a4000t_scsi_driver_template = {
         .name           = "A4000T builtin SCSI",
@@ -32,30 +28,35 @@ static struct scsi_host_template a4000t_scsi_driver_template = {
         .module         = THIS_MODULE,
 };
 
-static struct platform_device *a4000t_scsi_device;
 
-#define A4000T_SCSI_ADDR 0xdd0040
+#define A4000T_SCSI_OFFSET      0x40
 
-static int __devinit a4000t_probe(struct platform_device *dev)
+static int __init amiga_a4000t_scsi_probe(struct platform_device *pdev)
 {
-        struct Scsi_Host *host;
+        struct resource *res;
+        phys_addr_t scsi_addr;
         struct NCR_700_Host_Parameters *hostdata;
+        struct Scsi_Host *host;
 
-        if (!(MACH_IS_AMIGA && AMIGAHW_PRESENT(A4000_SCSI)))
-                goto out;
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res)
+                return -ENODEV;
 
-        if (!request_mem_region(A4000T_SCSI_ADDR, 0x1000,
+        if (!request_mem_region(res->start, resource_size(res),
                                 "A4000T builtin SCSI"))
-                goto out;
+                return -EBUSY;
 
-        hostdata = kzalloc(sizeof(struct NCR_700_Host_Parameters), GFP_KERNEL);
+        hostdata = kzalloc(sizeof(struct NCR_700_Host_Parameters),
+                           GFP_KERNEL);
         if (!hostdata) {
-                printk(KERN_ERR "a4000t-scsi: Failed to allocate host data\n");
+                dev_err(&pdev->dev, "Failed to allocate host data\n");
                 goto out_release;
         }
 
+        scsi_addr = res->start + A4000T_SCSI_OFFSET;
+
         /* Fill in the required pieces of hostdata */
-        hostdata->base = (void __iomem *)ZTWO_VADDR(A4000T_SCSI_ADDR);
+        hostdata->base = (void __iomem *)ZTWO_VADDR(scsi_addr);
         hostdata->clock = 50;
         hostdata->chip710 = 1;
         hostdata->dmode_extra = DMODE_FC2;
@@ -63,26 +64,25 @@ static int __devinit a4000t_probe(struct platform_device *dev)
 
         /* and register the chip */
         host = NCR_700_detect(&a4000t_scsi_driver_template, hostdata,
-                              &dev->dev);
+                              &pdev->dev);
         if (!host) {
-                printk(KERN_ERR "a4000t-scsi: No host detected; "
-                                "board configuration problem?\n");
+                dev_err(&pdev->dev,
+                        "No host detected; board configuration problem?\n");
                 goto out_free;
         }
 
         host->this_id = 7;
-        host->base = A4000T_SCSI_ADDR;
+        host->base = scsi_addr;
         host->irq = IRQ_AMIGA_PORTS;
 
         if (request_irq(host->irq, NCR_700_intr, IRQF_SHARED, "a4000t-scsi",
                         host)) {
-                printk(KERN_ERR "a4000t-scsi: request_irq failed\n");
+                dev_err(&pdev->dev, "request_irq failed\n");
                 goto out_put_host;
         }
 
-        platform_set_drvdata(dev, host);
+        platform_set_drvdata(pdev, host);
         scsi_scan_host(host);
-
         return 0;
 
  out_put_host:
@@ -90,58 +90,49 @@ static int __devinit a4000t_probe(struct platform_device *dev)
  out_free:
         kfree(hostdata);
  out_release:
-        release_mem_region(A4000T_SCSI_ADDR, 0x1000);
- out:
+        release_mem_region(res->start, resource_size(res));
         return -ENODEV;
 }
 
-static __devexit int a4000t_device_remove(struct platform_device *dev)
+static int __exit amiga_a4000t_scsi_remove(struct platform_device *pdev)
 {
-        struct Scsi_Host *host = platform_get_drvdata(dev);
+        struct Scsi_Host *host = platform_get_drvdata(pdev);
         struct NCR_700_Host_Parameters *hostdata = shost_priv(host);
+        struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 
         scsi_remove_host(host);
-
         NCR_700_release(host);
         kfree(hostdata);
         free_irq(host->irq, host);
-        release_mem_region(A4000T_SCSI_ADDR, 0x1000);
-
+        release_mem_region(res->start, resource_size(res));
         return 0;
 }
 
-static struct platform_driver a4000t_scsi_driver = {
-        .driver = {
-                .name           = "a4000t-scsi",
-                .owner          = THIS_MODULE,
+static struct platform_driver amiga_a4000t_scsi_driver = {
+        .remove = __exit_p(amiga_a4000t_scsi_remove),
+        .driver   = {
+                .name   = "amiga-a4000t-scsi",
+                .owner  = THIS_MODULE,
         },
-        .probe          = a4000t_probe,
-        .remove         = __devexit_p(a4000t_device_remove),
 };
 
-static int __init a4000t_scsi_init(void)
+static int __init amiga_a4000t_scsi_init(void)
 {
-        int err;
-
-        err = platform_driver_register(&a4000t_scsi_driver);
-        if (err)
-                return err;
-
-        a4000t_scsi_device = platform_device_register_simple("a4000t-scsi",
-                        -1, NULL, 0);
-        if (IS_ERR(a4000t_scsi_device)) {
-                platform_driver_unregister(&a4000t_scsi_driver);
-                return PTR_ERR(a4000t_scsi_device);
-        }
-
-        return err;
+        return platform_driver_probe(&amiga_a4000t_scsi_driver,
+                                     amiga_a4000t_scsi_probe);
 }
 
-static void __exit a4000t_scsi_exit(void)
+module_init(amiga_a4000t_scsi_init);
+
+static void __exit amiga_a4000t_scsi_exit(void)
 {
-        platform_device_unregister(a4000t_scsi_device);
-        platform_driver_unregister(&a4000t_scsi_driver);
+        platform_driver_unregister(&amiga_a4000t_scsi_driver);
 }
 
-module_init(a4000t_scsi_init);
-module_exit(a4000t_scsi_exit);
+module_exit(amiga_a4000t_scsi_exit);
+
+MODULE_AUTHOR("Alan Hourihane <alanh@fairlite.demon.co.uk> / "
+              "Kars de Jong <jongk@linux-m68k.org>");
+MODULE_DESCRIPTION("Amiga A4000T NCR53C710 driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:amiga-a4000t-scsi");
diff --git a/drivers/scsi/aacraid/commctrl.c b/drivers/scsi/aacraid/commctrl.c
index 9c0c91178538..1a5bf5724750 100644
--- a/drivers/scsi/aacraid/commctrl.c
+++ b/drivers/scsi/aacraid/commctrl.c
@@ -655,9 +655,9 @@ static int aac_send_raw_srb(struct aac_dev* dev, void __user * arg)
                                 /* Does this really need to be GFP_DMA? */
                                 p = kmalloc(usg->sg[i].count,GFP_KERNEL|__GFP_DMA);
                                 if(!p) {
-                                        kfree (usg);
-                                        dprintk((KERN_DEBUG"aacraid: Could not allocate SG buffer - size = %d buffer number %d of %d\n",
+                                        dprintk((KERN_DEBUG "aacraid: Could not allocate SG buffer - size = %d buffer number %d of %d\n",
                                           usg->sg[i].count,i,usg->count));
+                                        kfree(usg);
                                         rcode = -ENOMEM;
                                         goto cleanup;
                                 }
diff --git a/drivers/scsi/arcmsr/arcmsr.h b/drivers/scsi/arcmsr/arcmsr.h
index ab646e580d64..ce5371b3cdd5 100644
--- a/drivers/scsi/arcmsr/arcmsr.h
+++ b/drivers/scsi/arcmsr/arcmsr.h
@@ -48,7 +48,7 @@ struct device_attribute;
 /*The limit of outstanding scsi command that firmware can handle*/
 #define ARCMSR_MAX_OUTSTANDING_CMD                                              256
 #define ARCMSR_MAX_FREECCB_NUM                                                  320
-#define ARCMSR_DRIVER_VERSION                "Driver Version 1.20.00.15 2008/02/27"
+#define ARCMSR_DRIVER_VERSION                "Driver Version 1.20.00.15 2008/11/03"
 #define ARCMSR_SCSI_INITIATOR_ID                                                255
 #define ARCMSR_MAX_XFER_SECTORS                                                 512
 #define ARCMSR_MAX_XFER_SECTORS_B                                               4096
@@ -110,6 +110,8 @@ struct CMD_MESSAGE_FIELD
 #define FUNCTION_SAY_HELLO                      0x0807
 #define FUNCTION_SAY_GOODBYE                    0x0808
 #define FUNCTION_FLUSH_ADAPTER_CACHE            0x0809
+#define FUNCTION_GET_FIRMWARE_STATUS                    0x080A
+#define FUNCTION_HARDWARE_RESET                 0x080B
 /* ARECA IO CONTROL CODE*/
 #define ARCMSR_MESSAGE_READ_RQBUFFER       \
         ARECA_SATA_RAID | FUNCTION_READ_RQBUFFER
@@ -133,6 +135,7 @@ struct CMD_MESSAGE_FIELD
 #define ARCMSR_MESSAGE_RETURNCODE_OK              0x00000001
 #define ARCMSR_MESSAGE_RETURNCODE_ERROR           0x00000006
 #define ARCMSR_MESSAGE_RETURNCODE_3F              0x0000003F
+#define ARCMSR_MESSAGE_RETURNCODE_BUS_HANG_ON   0x00000088
 /*
 *************************************************************
 **   structure for holding DMA address data
@@ -341,13 +344,13 @@ struct MessageUnit_B
         uint32_t        done_qbuffer[ARCMSR_MAX_HBB_POSTQUEUE];
         uint32_t        postq_index;
         uint32_t        doneq_index;
-        void            __iomem *drv2iop_doorbell_reg;
-        void            __iomem *drv2iop_doorbell_mask_reg;
-        void            __iomem *iop2drv_doorbell_reg;
-        void            __iomem *iop2drv_doorbell_mask_reg;
-        void            __iomem *msgcode_rwbuffer_reg;
-        void            __iomem *ioctl_wbuffer_reg;
-        void            __iomem *ioctl_rbuffer_reg;
+        uint32_t                __iomem *drv2iop_doorbell_reg;
+        uint32_t                __iomem *drv2iop_doorbell_mask_reg;
+        uint32_t                __iomem *iop2drv_doorbell_reg;
+        uint32_t                __iomem *iop2drv_doorbell_mask_reg;
+        uint32_t                __iomem *msgcode_rwbuffer_reg;
+        uint32_t                __iomem *ioctl_wbuffer_reg;
+        uint32_t                __iomem *ioctl_rbuffer_reg;
 };
 
 /*
@@ -375,6 +378,7 @@ struct AdapterControlBlock
         /* message unit ATU inbound base address0 */
 
         uint32_t                        acb_flags;
+        uint8_t                                 adapter_index;
         #define ACB_F_SCSISTOPADAPTER           0x0001
         #define ACB_F_MSG_STOP_BGRB             0x0002
         /* stop RAID background rebuild */
@@ -390,7 +394,7 @@ struct AdapterControlBlock
         #define ACB_F_BUS_RESET                 0x0080
         #define ACB_F_IOP_INITED                0x0100
         /* iop init */
-
+        #define ACB_F_FIRMWARE_TRAP                     0x0400
         struct CommandControlBlock *                    pccb_pool[ARCMSR_MAX_FREECCB_NUM];
         /* used for memory free */
         struct list_head                ccb_free_list;
@@ -423,12 +427,19 @@ struct AdapterControlBlock
 #define ARECA_RAID_GOOD               0xaa
         uint32_t                        num_resets;
         uint32_t                        num_aborts;
+        uint32_t                        signature;
         uint32_t                        firm_request_len;
         uint32_t                        firm_numbers_queue;
         uint32_t                        firm_sdram_size;
         uint32_t                        firm_hd_channels;
         char                            firm_model[12];
         char                            firm_version[20];
+        char                    device_map[20];                 /*21,84-99*/
+        struct work_struct              arcmsr_do_message_isr_bh;
+        struct timer_list               eternal_timer;
+        unsigned short          fw_state;
+        atomic_t                        rq_map_token;
+        int                     ante_token_value;
 };/* HW_DEVICE_EXTENSION */
 /*
 *******************************************************************************
diff --git a/drivers/scsi/arcmsr/arcmsr_attr.c b/drivers/scsi/arcmsr/arcmsr_attr.c
index a4e04c50c436..07fdfe57e38e 100644
--- a/drivers/scsi/arcmsr/arcmsr_attr.c
+++ b/drivers/scsi/arcmsr/arcmsr_attr.c
@@ -192,6 +192,7 @@ static struct bin_attribute arcmsr_sysfs_message_read_attr = {
         .attr = {
                 .name = "mu_read",
                 .mode = S_IRUSR ,
+                .owner = THIS_MODULE,
         },
         .size = 1032,
         .read = arcmsr_sysfs_iop_message_read,
@@ -201,6 +202,7 @@ static struct bin_attribute arcmsr_sysfs_message_write_attr = {
         .attr = {
                 .name = "mu_write",
                 .mode = S_IWUSR,
+                .owner = THIS_MODULE,
         },
         .size = 1032,
         .write = arcmsr_sysfs_iop_message_write,
@@ -210,6 +212,7 @@ static struct bin_attribute arcmsr_sysfs_message_clear_attr = {
         .attr = {
                 .name = "mu_clear",
                 .mode = S_IWUSR,
+                .owner = THIS_MODULE,
         },
         .size = 1,
         .write = arcmsr_sysfs_iop_message_clear,
diff --git a/drivers/scsi/arcmsr/arcmsr_hba.c b/drivers/scsi/arcmsr/arcmsr_hba.c
index ffbe2192da3c..ffa54792bb33 100644
--- a/drivers/scsi/arcmsr/arcmsr_hba.c
+++ b/drivers/scsi/arcmsr/arcmsr_hba.c
@@ -72,8 +72,16 @@
 #include <scsi/scsicam.h>
 #include "arcmsr.h"
 
+#ifdef CONFIG_SCSI_ARCMSR_RESET
+        static int sleeptime = 20;
+        static int retrycount = 12;
+        module_param(sleeptime, int, S_IRUGO|S_IWUSR);
+        MODULE_PARM_DESC(sleeptime, "The waiting period for FW ready while bus reset");
+        module_param(retrycount, int, S_IRUGO|S_IWUSR);
+        MODULE_PARM_DESC(retrycount, "The retry count for FW ready while bus reset");
+#endif
 MODULE_AUTHOR("Erich Chen <support@areca.com.tw>");
-MODULE_DESCRIPTION("ARECA (ARC11xx/12xx/13xx/16xx) SATA/SAS RAID HOST Adapter");
+MODULE_DESCRIPTION("ARECA (ARC11xx/12xx/13xx/16xx) SATA/SAS RAID Host Bus Adapter");
 MODULE_LICENSE("Dual BSD/GPL");
 MODULE_VERSION(ARCMSR_DRIVER_VERSION);
 
@@ -96,6 +104,13 @@ static u32 arcmsr_disable_outbound_ints(struct AdapterControlBlock *acb);
 static void arcmsr_stop_adapter_bgrb(struct AdapterControlBlock *acb);
 static void arcmsr_flush_hba_cache(struct AdapterControlBlock *acb);
 static void arcmsr_flush_hbb_cache(struct AdapterControlBlock *acb);
+static void arcmsr_request_device_map(unsigned long pacb);
+static void arcmsr_request_hba_device_map(struct AdapterControlBlock *acb);
+static void arcmsr_request_hbb_device_map(struct AdapterControlBlock *acb);
+static void arcmsr_message_isr_bh_fn(struct work_struct *work);
+static void *arcmsr_get_firmware_spec(struct AdapterControlBlock *acb, int mode);
+static void arcmsr_start_adapter_bgrb(struct AdapterControlBlock *acb);
+
 static const char *arcmsr_info(struct Scsi_Host *);
 static irqreturn_t arcmsr_interrupt(struct AdapterControlBlock *acb);
 static int arcmsr_adjust_disk_queue_depth(struct scsi_device *sdev,
@@ -112,7 +127,7 @@ static int arcmsr_adjust_disk_queue_depth(struct scsi_device *sdev,
 
 static struct scsi_host_template arcmsr_scsi_host_template = {
         .module                 = THIS_MODULE,
-        .name                   = "ARCMSR ARECA SATA/SAS RAID HOST Adapter"
+        .name                   = "ARCMSR ARECA SATA/SAS RAID Host Bus Adapter"
                                                         ARCMSR_DRIVER_VERSION,
         .info                   = arcmsr_info,
         .queuecommand           = arcmsr_queue_command,
@@ -128,16 +143,6 @@ static struct scsi_host_template arcmsr_scsi_host_template = {
         .use_clustering         = ENABLE_CLUSTERING,
         .shost_attrs            = arcmsr_host_attrs,
 };
-#ifdef CONFIG_SCSI_ARCMSR_AER
-static pci_ers_result_t arcmsr_pci_slot_reset(struct pci_dev *pdev);
-static pci_ers_result_t arcmsr_pci_error_detected(struct pci_dev *pdev,
-                                                pci_channel_state_t state);
-
-static struct pci_error_handlers arcmsr_pci_error_handlers = {
-        .error_detected         = arcmsr_pci_error_detected,
-        .slot_reset             = arcmsr_pci_slot_reset,
-};
-#endif
 static struct pci_device_id arcmsr_device_id_table[] = {
         {PCI_DEVICE(PCI_VENDOR_ID_ARECA, PCI_DEVICE_ID_ARECA_1110)},
         {PCI_DEVICE(PCI_VENDOR_ID_ARECA, PCI_DEVICE_ID_ARECA_1120)},
@@ -166,9 +171,6 @@ static struct pci_driver arcmsr_pci_driver = {
         .probe                  = arcmsr_probe,
         .remove                 = arcmsr_remove,
         .shutdown               = arcmsr_shutdown,
-        #ifdef CONFIG_SCSI_ARCMSR_AER
-        .err_handler            = &arcmsr_pci_error_handlers,
-        #endif
 };
 
 static irqreturn_t arcmsr_do_interrupt(int irq, void *dev_id)
@@ -236,10 +238,9 @@ static int arcmsr_alloc_ccb_pool(struct AdapterControlBlock *acb)
                 void *dma_coherent;
                 dma_addr_t dma_coherent_handle, dma_addr;
                 struct CommandControlBlock *ccb_tmp;
-                uint32_t intmask_org;
                 int i, j;
 
-                acb->pmuA = pci_ioremap_bar(pdev, 0);
+                acb->pmuA = ioremap(pci_resource_start(pdev, 0), pci_resource_len(pdev, 0));
                 if (!acb->pmuA) {
                         printk(KERN_NOTICE "arcmsr%d: memory mapping region fail \n",
                                                         acb->host->host_no);
@@ -281,12 +282,6 @@ static int arcmsr_alloc_ccb_pool(struct AdapterControlBlock *acb)
                 for (i = 0; i < ARCMSR_MAX_TARGETID; i++)
                         for (j = 0; j < ARCMSR_MAX_TARGETLUN; j++)
                                 acb->devstate[i][j] = ARECA_RAID_GONE;
-
-                /*
-                ** here we need to tell iop 331 our ccb_tmp.HighPart
-                ** if ccb_tmp.HighPart is not zero
-                */
-                intmask_org = arcmsr_disable_outbound_ints(acb);
                 }
                 break;
 
@@ -297,7 +292,6 @@ static int arcmsr_alloc_ccb_pool(struct AdapterControlBlock *acb)
                 void __iomem *mem_base0, *mem_base1;
                 void *dma_coherent;
                 dma_addr_t dma_coherent_handle, dma_addr;
-                uint32_t intmask_org;
                 struct CommandControlBlock *ccb_tmp;
                 int i, j;
 
@@ -333,11 +327,13 @@ static int arcmsr_alloc_ccb_pool(struct AdapterControlBlock *acb)
                 reg = (struct MessageUnit_B *)(dma_coherent +
                 ARCMSR_MAX_FREECCB_NUM * sizeof(struct CommandControlBlock));
                 acb->pmuB = reg;
-                mem_base0 = pci_ioremap_bar(pdev, 0);
+                mem_base0 = ioremap(pci_resource_start(pdev, 0),
+                                        pci_resource_len(pdev, 0));
                 if (!mem_base0)
                         goto out;
 
-                mem_base1 = pci_ioremap_bar(pdev, 2);
+                mem_base1 = ioremap(pci_resource_start(pdev, 2),
+                                        pci_resource_len(pdev, 2));
                 if (!mem_base1) {
                         iounmap(mem_base0);
                         goto out;
@@ -357,12 +353,6 @@ static int arcmsr_alloc_ccb_pool(struct AdapterControlBlock *acb)
                 for (i = 0; i < ARCMSR_MAX_TARGETID; i++)
                         for (j = 0; j < ARCMSR_MAX_TARGETLUN; j++)
                                 acb->devstate[i][j] = ARECA_RAID_GOOD;
-
-                /*
-                ** here we need to tell iop 331 our ccb_tmp.HighPart
-                ** if ccb_tmp.HighPart is not zero
-                */
-                intmask_org = arcmsr_disable_outbound_ints(acb);
                 }
                 break;
         }
@@ -374,6 +364,88 @@ out:
                 sizeof(struct MessageUnit_B)), acb->dma_coherent, acb->dma_coherent_handle);
         return -ENOMEM;
 }
+static void arcmsr_message_isr_bh_fn(struct work_struct *work)
+{
+        struct AdapterControlBlock *acb = container_of(work, struct AdapterControlBlock, arcmsr_do_message_isr_bh);
+
+        switch (acb->adapter_type) {
+                case ACB_ADAPTER_TYPE_A: {
+
+                        struct MessageUnit_A __iomem *reg  = acb->pmuA;
+                        char *acb_dev_map = (char *)acb->device_map;
+                        uint32_t __iomem *signature = (uint32_t __iomem *) (&reg->message_rwbuffer[0]);
+                        char __iomem *devicemap = (char __iomem *) (&reg->message_rwbuffer[21]);
+                        int target, lun;
+                        struct scsi_device *psdev;
+                        char diff;
+
+                        atomic_inc(&acb->rq_map_token);
+                        if (readl(signature) == ARCMSR_SIGNATURE_GET_CONFIG) {
+                                for (target = 0; target < ARCMSR_MAX_TARGETID - 1; target++) {
+                                        diff = (*acb_dev_map)^readb(devicemap);
+                                        if (diff != 0) {
+                                                char temp;
+                                                *acb_dev_map = readb(devicemap);
+                                                temp = *acb_dev_map;
+                                                for (lun = 0; lun < ARCMSR_MAX_TARGETLUN; lun++) {
+                                                        if ((temp & 0x01) == 1 && (diff & 0x01) == 1) {
+                                                                scsi_add_device(acb->host, 0, target, lun);
+                                                        } else if ((temp & 0x01) == 0 && (diff & 0x01) == 1) {
+                                                                psdev = scsi_device_lookup(acb->host, 0, target, lun);
+                                                                if (psdev != NULL) {
+                                                                        scsi_remove_device(psdev);
+                                                                        scsi_device_put(psdev);
+                                                                }
+                                                        }
+                                                        temp >>= 1;
+                                                        diff >>= 1;
+                                                }
+                                        }
+                                        devicemap++;
+                                        acb_dev_map++;
+                                }
+                        }
+                        break;
+                }
+
+                case ACB_ADAPTER_TYPE_B: {
+                        struct MessageUnit_B *reg  = acb->pmuB;
+                        char *acb_dev_map = (char *)acb->device_map;
+                        uint32_t __iomem *signature = (uint32_t __iomem *)(&reg->msgcode_rwbuffer_reg[0]);
+                        char __iomem *devicemap = (char __iomem *)(&reg->msgcode_rwbuffer_reg[21]);
+                        int target, lun;
+                        struct scsi_device *psdev;
+                        char diff;
+
+                        atomic_inc(&acb->rq_map_token);
+                        if (readl(signature) == ARCMSR_SIGNATURE_GET_CONFIG) {
+                                for (target = 0; target < ARCMSR_MAX_TARGETID - 1; target++) {
+                                        diff = (*acb_dev_map)^readb(devicemap);
+                                        if (diff != 0) {
+                                                char temp;
+                                                *acb_dev_map = readb(devicemap);
+                                                temp = *acb_dev_map;
+                                                for (lun = 0; lun < ARCMSR_MAX_TARGETLUN; lun++) {
+                                                        if ((temp & 0x01) == 1 && (diff & 0x01) == 1) {
+                                                                scsi_add_device(acb->host, 0, target, lun);
+                                                        } else if ((temp & 0x01) == 0 && (diff & 0x01) == 1) {
+                                                                psdev = scsi_device_lookup(acb->host, 0, target, lun);
+                                                                if (psdev != NULL) {
+                                                                        scsi_remove_device(psdev);
+                                                                        scsi_device_put(psdev);
+                                                                }
+                                                        }
+                                                        temp >>= 1;
+                                                        diff >>= 1;
+                                                }
+                                        }
+                                        devicemap++;
+                                        acb_dev_map++;
+                                }
+                        }
+                }
+        }
+}
 
 static int arcmsr_probe(struct pci_dev *pdev,
         const struct pci_device_id *id)
@@ -432,17 +504,17 @@ static int arcmsr_probe(struct pci_dev *pdev,
                            ACB_F_MESSAGE_WQBUFFER_READED);
         acb->acb_flags &= ~ACB_F_SCSISTOPADAPTER;
         INIT_LIST_HEAD(&acb->ccb_free_list);
-
+        INIT_WORK(&acb->arcmsr_do_message_isr_bh, arcmsr_message_isr_bh_fn);
         error = arcmsr_alloc_ccb_pool(acb);
         if (error)
                 goto out_release_regions;
 
+        arcmsr_iop_init(acb);
         error = request_irq(pdev->irq, arcmsr_do_interrupt,
                             IRQF_SHARED, "arcmsr", acb);
         if (error)
                 goto out_free_ccb_pool;
 
-        arcmsr_iop_init(acb);
         pci_set_drvdata(pdev, host);
         if (strncmp(acb->firm_version, "V1.42", 5) >= 0)
                 host->max_sectors= ARCMSR_MAX_XFER_SECTORS_B;
@@ -459,6 +531,14 @@ static int arcmsr_probe(struct pci_dev *pdev,
         #ifdef CONFIG_SCSI_ARCMSR_AER
         pci_enable_pcie_error_reporting(pdev);
         #endif
+        atomic_set(&acb->rq_map_token, 16);
+        acb->fw_state = true;
+        init_timer(&acb->eternal_timer);
+        acb->eternal_timer.expires = jiffies + msecs_to_jiffies(10*HZ);
+        acb->eternal_timer.data = (unsigned long) acb;
+        acb->eternal_timer.function = &arcmsr_request_device_map;
+        add_timer(&acb->eternal_timer);
+
         return 0;
  out_free_sysfs:
  out_free_irq:
@@ -518,40 +598,48 @@ static uint8_t arcmsr_hbb_wait_msgint_ready(struct AdapterControlBlock *acb)
         return 0xff;
 }
 
-static void arcmsr_abort_hba_allcmd(struct AdapterControlBlock *acb)
+static uint8_t arcmsr_abort_hba_allcmd(struct AdapterControlBlock *acb)
 {
         struct MessageUnit_A __iomem *reg = acb->pmuA;
 
         writel(ARCMSR_INBOUND_MESG0_ABORT_CMD, &reg->inbound_msgaddr0);
-        if (arcmsr_hba_wait_msgint_ready(acb))
+        if (arcmsr_hba_wait_msgint_ready(acb)) {
                 printk(KERN_NOTICE
                         "arcmsr%d: wait 'abort all outstanding command' timeout \n"
                         , acb->host->host_no);
+                return 0xff;
+        }
+        return 0x00;
 }
 
-static void arcmsr_abort_hbb_allcmd(struct AdapterControlBlock *acb)
+static uint8_t arcmsr_abort_hbb_allcmd(struct AdapterControlBlock *acb)
 {
         struct MessageUnit_B *reg = acb->pmuB;
 
         writel(ARCMSR_MESSAGE_ABORT_CMD, reg->drv2iop_doorbell_reg);
-        if (arcmsr_hbb_wait_msgint_ready(acb))
+        if (arcmsr_hbb_wait_msgint_ready(acb)) {
                 printk(KERN_NOTICE
                         "arcmsr%d: wait 'abort all outstanding command' timeout \n"
                         , acb->host->host_no);
+                return 0xff;
+        }
+        return 0x00;
 }
 
-static void arcmsr_abort_allcmd(struct AdapterControlBlock *acb)
+static uint8_t arcmsr_abort_allcmd(struct AdapterControlBlock *acb)
 {
+        uint8_t rtnval = 0;
         switch (acb->adapter_type) {
         case ACB_ADAPTER_TYPE_A: {
-                arcmsr_abort_hba_allcmd(acb);
+                rtnval = arcmsr_abort_hba_allcmd(acb);
                 }
                 break;
 
         case ACB_ADAPTER_TYPE_B: {
-                arcmsr_abort_hbb_allcmd(acb);
+                rtnval = arcmsr_abort_hbb_allcmd(acb);
                 }
         }
+        return rtnval;
 }
 
 static void arcmsr_pci_unmap_dma(struct CommandControlBlock *ccb)
@@ -649,8 +737,7 @@ static u32 arcmsr_disable_outbound_ints(struct AdapterControlBlock *acb)
 
         case ACB_ADAPTER_TYPE_A : {
                 struct MessageUnit_A __iomem *reg = acb->pmuA;
-                orig_mask = readl(&reg->outbound_intmask)|\
-                                ARCMSR_MU_OUTBOUND_MESSAGE0_INTMASKENABLE;
+                orig_mask = readl(&reg->outbound_intmask);
                 writel(orig_mask|ARCMSR_MU_OUTBOUND_ALL_INTMASKENABLE, \
                                                 &reg->outbound_intmask);
                 }
@@ -658,8 +745,7 @@ static u32 arcmsr_disable_outbound_ints(struct AdapterControlBlock *acb)
 
         case ACB_ADAPTER_TYPE_B : {
                 struct MessageUnit_B *reg = acb->pmuB;
-                orig_mask = readl(reg->iop2drv_doorbell_mask_reg) & \
-                                        (~ARCMSR_IOP2DRV_MESSAGE_CMD_DONE);
+                orig_mask = readl(reg->iop2drv_doorbell_mask_reg);
                 writel(0, reg->iop2drv_doorbell_mask_reg);
                 }
                 break;
@@ -795,12 +881,13 @@ static void arcmsr_remove(struct pci_dev *pdev)
         struct AdapterControlBlock *acb =
                 (struct AdapterControlBlock *) host->hostdata;
         int poll_count = 0;
-
         arcmsr_free_sysfs_attr(acb);
         scsi_remove_host(host);
+        flush_scheduled_work();
+        del_timer_sync(&acb->eternal_timer);
+        arcmsr_disable_outbound_ints(acb);
         arcmsr_stop_adapter_bgrb(acb);
         arcmsr_flush_adapter_cache(acb);
-        arcmsr_disable_outbound_ints(acb);
         acb->acb_flags |= ACB_F_SCSISTOPADAPTER;
         acb->acb_flags &= ~ACB_F_IOP_INITED;
 
@@ -841,7 +928,9 @@ static void arcmsr_shutdown(struct pci_dev *pdev)
         struct Scsi_Host *host = pci_get_drvdata(pdev);
         struct AdapterControlBlock *acb =
                 (struct AdapterControlBlock *)host->hostdata;
-
+        del_timer_sync(&acb->eternal_timer);
+        arcmsr_disable_outbound_ints(acb);
+        flush_scheduled_work();
         arcmsr_stop_adapter_bgrb(acb);
         arcmsr_flush_adapter_cache(acb);
 }
@@ -861,7 +950,7 @@ static void arcmsr_module_exit(void)
 module_init(arcmsr_module_init);
 module_exit(arcmsr_module_exit);
 
-static void arcmsr_enable_outbound_ints(struct AdapterControlBlock *acb, \
+static void arcmsr_enable_outbound_ints(struct AdapterControlBlock *acb,
                                                 u32 intmask_org)
 {
         u32 mask;
@@ -871,7 +960,8 @@ static void arcmsr_enable_outbound_ints(struct AdapterControlBlock *acb, \
         case ACB_ADAPTER_TYPE_A : {
                 struct MessageUnit_A __iomem *reg = acb->pmuA;
                 mask = intmask_org & ~(ARCMSR_MU_OUTBOUND_POSTQUEUE_INTMASKENABLE |
-                             ARCMSR_MU_OUTBOUND_DOORBELL_INTMASKENABLE);
+                             ARCMSR_MU_OUTBOUND_DOORBELL_INTMASKENABLE|
+                             ARCMSR_MU_OUTBOUND_MESSAGE0_INTMASKENABLE);
                 writel(mask, &reg->outbound_intmask);
                 acb->outbound_int_enable = ~(intmask_org & mask) & 0x000000ff;
                 }
@@ -879,8 +969,10 @@ static void arcmsr_enable_outbound_ints(struct AdapterControlBlock *acb, \
 
         case ACB_ADAPTER_TYPE_B : {
                 struct MessageUnit_B *reg = acb->pmuB;
-                mask = intmask_org | (ARCMSR_IOP2DRV_DATA_WRITE_OK | \
-                        ARCMSR_IOP2DRV_DATA_READ_OK | ARCMSR_IOP2DRV_CDB_DONE);
+                mask = intmask_org | (ARCMSR_IOP2DRV_DATA_WRITE_OK |
+                        ARCMSR_IOP2DRV_DATA_READ_OK |
+                        ARCMSR_IOP2DRV_CDB_DONE |
+                        ARCMSR_IOP2DRV_MESSAGE_CMD_DONE);
                 writel(mask, reg->iop2drv_doorbell_mask_reg);
                 acb->outbound_int_enable = (intmask_org | mask) & 0x0000000f;
                 }
@@ -1048,8 +1140,8 @@ static void arcmsr_free_ccb_pool(struct AdapterControlBlock *acb)
         }
         case ACB_ADAPTER_TYPE_B: {
                 struct MessageUnit_B *reg = acb->pmuB;
-                iounmap(reg->drv2iop_doorbell_reg - ARCMSR_DRV2IOP_DOORBELL);
-                iounmap(reg->ioctl_wbuffer_reg - ARCMSR_IOCTL_WBUFFER);
+                iounmap((u8 *)reg->drv2iop_doorbell_reg - ARCMSR_DRV2IOP_DOORBELL);
+                iounmap((u8 *)reg->ioctl_wbuffer_reg - ARCMSR_IOCTL_WBUFFER);
                 dma_free_coherent(&acb->pdev->dev,
                 (ARCMSR_MAX_FREECCB_NUM * sizeof(struct CommandControlBlock) + 0x20 +
                 sizeof(struct MessageUnit_B)), acb->dma_coherent, acb->dma_coherent_handle);
@@ -1249,13 +1341,36 @@ static void arcmsr_hbb_postqueue_isr(struct AdapterControlBlock *acb)
                 reg->doneq_index = index;
         }
 }
+/*
+**********************************************************************************
+** Handle a message interrupt
+**
+** The only message interrupt we expect is in response to a query for the current adapter config.
+** We want this in order to compare the drivemap so that we can detect newly-attached drives.
+**********************************************************************************
+*/
+static void arcmsr_hba_message_isr(struct AdapterControlBlock *acb)
+{
+        struct MessageUnit_A *reg  = acb->pmuA;
+
+        /*clear interrupt and message state*/
+        writel(ARCMSR_MU_OUTBOUND_MESSAGE0_INT, &reg->outbound_intstatus);
+        schedule_work(&acb->arcmsr_do_message_isr_bh);
+}
+static void arcmsr_hbb_message_isr(struct AdapterControlBlock *acb)
+{
+        struct MessageUnit_B *reg  = acb->pmuB;
 
+        /*clear interrupt and message state*/
+        writel(ARCMSR_MESSAGE_INT_CLEAR_PATTERN, reg->iop2drv_doorbell_reg);
+        schedule_work(&acb->arcmsr_do_message_isr_bh);
+}
 static int arcmsr_handle_hba_isr(struct AdapterControlBlock *acb)
 {
         uint32_t outbound_intstatus;
         struct MessageUnit_A __iomem *reg = acb->pmuA;
 
-        outbound_intstatus = readl(&reg->outbound_intstatus) & \
+        outbound_intstatus = readl(&reg->outbound_intstatus) &
                                                         acb->outbound_int_enable;
         if (!(outbound_intstatus & ARCMSR_MU_OUTBOUND_HANDLE_INT))      {
                 return 1;
@@ -1267,6 +1382,10 @@ static int arcmsr_handle_hba_isr(struct AdapterControlBlock *acb)
         if (outbound_intstatus & ARCMSR_MU_OUTBOUND_POSTQUEUE_INT) {
                 arcmsr_hba_postqueue_isr(acb);
         }
+        if (outbound_intstatus & ARCMSR_MU_OUTBOUND_MESSAGE0_INT)       {
+                /* messenger of "driver to iop commands" */
+                arcmsr_hba_message_isr(acb);
+        }
         return 0;
 }
 
@@ -1275,13 +1394,14 @@ static int arcmsr_handle_hbb_isr(struct AdapterControlBlock *acb)
         uint32_t outbound_doorbell;
         struct MessageUnit_B *reg = acb->pmuB;
 
-        outbound_doorbell = readl(reg->iop2drv_doorbell_reg) & \
+        outbound_doorbell = readl(reg->iop2drv_doorbell_reg) &
                                                         acb->outbound_int_enable;
         if (!outbound_doorbell)
                 return 1;
 
         writel(~outbound_doorbell, reg->iop2drv_doorbell_reg);
-        /*in case the last action of doorbell interrupt clearance is cached, this action can push HW to write down the clear bit*/
+        /*in case the last action of doorbell interrupt clearance is cached,
+        this action can push HW to write down the clear bit*/
         readl(reg->iop2drv_doorbell_reg);
         writel(ARCMSR_DRV2IOP_END_OF_INTERRUPT, reg->drv2iop_doorbell_reg);
         if (outbound_doorbell & ARCMSR_IOP2DRV_DATA_WRITE_OK)   {
@@ -1293,6 +1413,10 @@ static int arcmsr_handle_hbb_isr(struct AdapterControlBlock *acb)
         if (outbound_doorbell & ARCMSR_IOP2DRV_CDB_DONE) {
                 arcmsr_hbb_postqueue_isr(acb);
         }
+        if (outbound_doorbell & ARCMSR_IOP2DRV_MESSAGE_CMD_DONE) {
+                /* messenger of "driver to iop commands" */
+                arcmsr_hbb_message_isr(acb);
+        }
 
         return 0;
 }
@@ -1360,7 +1484,7 @@ void arcmsr_post_ioctldata2iop(struct AdapterControlBlock *acb)
         }
 }
 
-static int arcmsr_iop_message_xfer(struct AdapterControlBlock *acb, \
+static int arcmsr_iop_message_xfer(struct AdapterControlBlock *acb,
                                         struct scsi_cmnd *cmd)
 {
         struct CMD_MESSAGE_FIELD *pcmdmessagefld;
@@ -1398,6 +1522,13 @@ static int arcmsr_iop_message_xfer(struct AdapterControlBlock *acb, \
                         retvalue = ARCMSR_MESSAGE_FAIL;
                         goto message_out;
                 }
+
+                if (!acb->fw_state) {
+                        pcmdmessagefld->cmdmessage.ReturnCode =
+                        ARCMSR_MESSAGE_RETURNCODE_BUS_HANG_ON;
+                        goto message_out;
+                }
+
                 ptmpQbuffer = ver_addr;
                 while ((acb->rqbuf_firstindex != acb->rqbuf_lastindex)
                         && (allxfer_len < 1031)) {
@@ -1444,6 +1575,12 @@ static int arcmsr_iop_message_xfer(struct AdapterControlBlock *acb, \
                         retvalue = ARCMSR_MESSAGE_FAIL;
                         goto message_out;
                 }
+                if (!acb->fw_state) {
+                        pcmdmessagefld->cmdmessage.ReturnCode =
+                        ARCMSR_MESSAGE_RETURNCODE_BUS_HANG_ON;
+                        goto message_out;
+                }
+
                 ptmpuserbuffer = ver_addr;
                 user_len = pcmdmessagefld->cmdmessage.Length;
                 memcpy(ptmpuserbuffer, pcmdmessagefld->messagedatabuffer, user_len);
@@ -1496,6 +1633,11 @@ static int arcmsr_iop_message_xfer(struct AdapterControlBlock *acb, \
 
         case ARCMSR_MESSAGE_CLEAR_RQBUFFER: {
                 uint8_t *pQbuffer = acb->rqbuffer;
+                if (!acb->fw_state) {
+                        pcmdmessagefld->cmdmessage.ReturnCode =
+                        ARCMSR_MESSAGE_RETURNCODE_BUS_HANG_ON;
+                        goto message_out;
+                }
 
                 if (acb->acb_flags & ACB_F_IOPDATA_OVERFLOW) {
                         acb->acb_flags &= ~ACB_F_IOPDATA_OVERFLOW;
@@ -1511,6 +1653,11 @@ static int arcmsr_iop_message_xfer(struct AdapterControlBlock *acb, \
 
         case ARCMSR_MESSAGE_CLEAR_WQBUFFER: {
                 uint8_t *pQbuffer = acb->wqbuffer;
+                if (!acb->fw_state) {
+                        pcmdmessagefld->cmdmessage.ReturnCode =
+                        ARCMSR_MESSAGE_RETURNCODE_BUS_HANG_ON;
+                        goto message_out;
+                }
 
                 if (acb->acb_flags & ACB_F_IOPDATA_OVERFLOW) {
                         acb->acb_flags &= ~ACB_F_IOPDATA_OVERFLOW;
@@ -1529,6 +1676,11 @@ static int arcmsr_iop_message_xfer(struct AdapterControlBlock *acb, \
 
         case ARCMSR_MESSAGE_CLEAR_ALLQBUFFER: {
                 uint8_t *pQbuffer;
+                if (!acb->fw_state) {
+                        pcmdmessagefld->cmdmessage.ReturnCode =
+                        ARCMSR_MESSAGE_RETURNCODE_BUS_HANG_ON;
+                        goto message_out;
+                }
 
                 if (acb->acb_flags & ACB_F_IOPDATA_OVERFLOW) {
                         acb->acb_flags &= ~ACB_F_IOPDATA_OVERFLOW;
@@ -1551,13 +1703,22 @@ static int arcmsr_iop_message_xfer(struct AdapterControlBlock *acb, \
                 break;
 
         case ARCMSR_MESSAGE_RETURN_CODE_3F: {
+                if (!acb->fw_state) {
+                        pcmdmessagefld->cmdmessage.ReturnCode =
+                        ARCMSR_MESSAGE_RETURNCODE_BUS_HANG_ON;
+                        goto message_out;
+                }
                 pcmdmessagefld->cmdmessage.ReturnCode = ARCMSR_MESSAGE_RETURNCODE_3F;
                 }
                 break;
 
         case ARCMSR_MESSAGE_SAY_HELLO: {
                 int8_t *hello_string = "Hello! I am ARCMSR";
-
+                if (!acb->fw_state) {
+                        pcmdmessagefld->cmdmessage.ReturnCode =
+                        ARCMSR_MESSAGE_RETURNCODE_BUS_HANG_ON;
+                        goto message_out;
+                }
                 memcpy(pcmdmessagefld->messagedatabuffer, hello_string
                         , (int16_t)strlen(hello_string));
                 pcmdmessagefld->cmdmessage.ReturnCode = ARCMSR_MESSAGE_RETURNCODE_OK;
@@ -1565,10 +1726,20 @@ static int arcmsr_iop_message_xfer(struct AdapterControlBlock *acb, \
                 break;
 
         case ARCMSR_MESSAGE_SAY_GOODBYE:
+                if (!acb->fw_state) {
+                        pcmdmessagefld->cmdmessage.ReturnCode =
+                        ARCMSR_MESSAGE_RETURNCODE_BUS_HANG_ON;
+                        goto message_out;
+                }
                 arcmsr_iop_parking(acb);
                 break;
 
         case ARCMSR_MESSAGE_FLUSH_ADAPTER_CACHE:
+                if (!acb->fw_state) {
+                        pcmdmessagefld->cmdmessage.ReturnCode =
+                        ARCMSR_MESSAGE_RETURNCODE_BUS_HANG_ON;
+                        goto message_out;
+                }
                 arcmsr_flush_adapter_cache(acb);
                 break;
 
@@ -1651,16 +1822,57 @@ static int arcmsr_queue_command(struct scsi_cmnd *cmd,
         struct CommandControlBlock *ccb;
         int target = cmd->device->id;
         int lun = cmd->device->lun;
-
+        uint8_t scsicmd = cmd->cmnd[0];
         cmd->scsi_done = done;
         cmd->host_scribble = NULL;
         cmd->result = 0;
+
+        if ((scsicmd == SYNCHRONIZE_CACHE) || (scsicmd == SEND_DIAGNOSTIC)) {
+                if (acb->devstate[target][lun] == ARECA_RAID_GONE) {
+                        cmd->result = (DID_NO_CONNECT << 16);
+                }
+                cmd->scsi_done(cmd);
+                return 0;
+        }
+
         if (acb->acb_flags & ACB_F_BUS_RESET) {
-                printk(KERN_NOTICE "arcmsr%d: bus reset"
-                        " and return busy \n"
-                        , acb->host->host_no);
+                switch (acb->adapter_type) {
+                        case ACB_ADAPTER_TYPE_A: {
+                                struct MessageUnit_A __iomem *reg = acb->pmuA;
+                                uint32_t intmask_org, outbound_doorbell;
+
+                                if ((readl(&reg->outbound_msgaddr1) &
+                                        ARCMSR_OUTBOUND_MESG1_FIRMWARE_OK) == 0) {
+                                        printk(KERN_NOTICE "arcmsr%d: bus reset and return busy\n",
+                                                acb->host->host_no);
                 return SCSI_MLQUEUE_HOST_BUSY;
         }
+
+                                acb->acb_flags &= ~ACB_F_FIRMWARE_TRAP;
+                                printk(KERN_NOTICE "arcmsr%d: hardware bus reset and reset ok\n",
+                                        acb->host->host_no);
+                                /* disable all outbound interrupt */
+                                intmask_org = arcmsr_disable_outbound_ints(acb);
+                                arcmsr_get_firmware_spec(acb, 1);
+                                /*start background rebuild*/
+                                arcmsr_start_adapter_bgrb(acb);
+                                /* clear Qbuffer if door bell ringed */
+                                outbound_doorbell = readl(&reg->outbound_doorbell);
+                                /*clear interrupt */
+                                writel(outbound_doorbell, &reg->outbound_doorbell);
+                                writel(ARCMSR_INBOUND_DRIVER_DATA_READ_OK,
+                                        &reg->inbound_doorbell);
+                                /* enable outbound Post Queue,outbound doorbell Interrupt */
+                                arcmsr_enable_outbound_ints(acb, intmask_org);
+                                acb->acb_flags |= ACB_F_IOP_INITED;
+                                acb->acb_flags &= ~ACB_F_BUS_RESET;
+                        }
+                        break;
+                        case ACB_ADAPTER_TYPE_B: {
+                        }
+                }
+        }
+
         if (target == 16) {
                 /* virtual device for iop message transfer */
                 arcmsr_handle_virtual_command(acb, cmd);
@@ -1699,21 +1911,25 @@ static int arcmsr_queue_command(struct scsi_cmnd *cmd,
         return 0;
 }
 
-static void arcmsr_get_hba_config(struct AdapterControlBlock *acb)
+static void *arcmsr_get_hba_config(struct AdapterControlBlock *acb, int mode)
 {
         struct MessageUnit_A __iomem *reg = acb->pmuA;
         char *acb_firm_model = acb->firm_model;
         char *acb_firm_version = acb->firm_version;
+        char *acb_device_map = acb->device_map;
         char __iomem *iop_firm_model = (char __iomem *)(&reg->message_rwbuffer[15]);
         char __iomem *iop_firm_version = (char __iomem *)(&reg->message_rwbuffer[17]);
+        char __iomem *iop_device_map = (char __iomem *) (&reg->message_rwbuffer[21]);
         int count;
 
         writel(ARCMSR_INBOUND_MESG0_GET_CONFIG, &reg->inbound_msgaddr0);
         if (arcmsr_hba_wait_msgint_ready(acb)) {
                 printk(KERN_NOTICE "arcmsr%d: wait 'get adapter firmware \
                         miscellaneous data' timeout \n", acb->host->host_no);
+                return NULL;
         }
 
+        if (mode == 1) {
         count = 8;
         while (count) {
                 *acb_firm_model = readb(iop_firm_model);
@@ -1730,34 +1946,48 @@ static void arcmsr_get_hba_config(struct AdapterControlBlock *acb)
                 count--;
         }
 
+                count = 16;
+                while (count) {
+                        *acb_device_map = readb(iop_device_map);
+                        acb_device_map++;
+                        iop_device_map++;
+                        count--;
+                }
+
         printk(KERN_INFO        "ARECA RAID ADAPTER%d: FIRMWARE VERSION %s \n"
                 , acb->host->host_no
                 , acb->firm_version);
-
+                acb->signature = readl(&reg->message_rwbuffer[0]);
         acb->firm_request_len = readl(&reg->message_rwbuffer[1]);
         acb->firm_numbers_queue = readl(&reg->message_rwbuffer[2]);
         acb->firm_sdram_size = readl(&reg->message_rwbuffer[3]);
         acb->firm_hd_channels = readl(&reg->message_rwbuffer[4]);
 }
-
-static void arcmsr_get_hbb_config(struct AdapterControlBlock *acb)
+        return reg->message_rwbuffer;
+}
+static void __iomem *arcmsr_get_hbb_config(struct AdapterControlBlock *acb, int mode)
 {
         struct MessageUnit_B *reg = acb->pmuB;
         uint32_t __iomem *lrwbuffer = reg->msgcode_rwbuffer_reg;
         char *acb_firm_model = acb->firm_model;
         char *acb_firm_version = acb->firm_version;
+        char *acb_device_map = acb->device_map;
         char __iomem *iop_firm_model = (char __iomem *)(&lrwbuffer[15]);
         /*firm_model,15,60-67*/
         char __iomem *iop_firm_version = (char __iomem *)(&lrwbuffer[17]);
         /*firm_version,17,68-83*/
+        char __iomem *iop_device_map = (char __iomem *) (&lrwbuffer[21]);
+        /*firm_version,21,84-99*/
         int count;
 
         writel(ARCMSR_MESSAGE_GET_CONFIG, reg->drv2iop_doorbell_reg);
         if (arcmsr_hbb_wait_msgint_ready(acb)) {
                 printk(KERN_NOTICE "arcmsr%d: wait 'get adapter firmware \
                         miscellaneous data' timeout \n", acb->host->host_no);
+                return NULL;
         }
 
+        if (mode == 1) {
         count = 8;
         while (count)
         {
@@ -1776,11 +2006,20 @@ static void arcmsr_get_hbb_config(struct AdapterControlBlock *acb)
                 count--;
         }
 
+                count = 16;
+                while (count) {
+                        *acb_device_map = readb(iop_device_map);
+                        acb_device_map++;
+                        iop_device_map++;
+                        count--;
+                }
+
         printk(KERN_INFO "ARECA RAID ADAPTER%d: FIRMWARE VERSION %s \n",
                         acb->host->host_no,
                         acb->firm_version);
 
-        lrwbuffer++;
+                acb->signature = readl(lrwbuffer++);
+                /*firm_signature,1,00-03*/
         acb->firm_request_len = readl(lrwbuffer++);
         /*firm_request_len,1,04-07*/
         acb->firm_numbers_queue = readl(lrwbuffer++);
@@ -1790,20 +2029,23 @@ static void arcmsr_get_hbb_config(struct AdapterControlBlock *acb)
         acb->firm_hd_channels = readl(lrwbuffer);
         /*firm_ide_channels,4,16-19*/
 }
-
-static void arcmsr_get_firmware_spec(struct AdapterControlBlock *acb)
+        return reg->msgcode_rwbuffer_reg;
+}
+static void *arcmsr_get_firmware_spec(struct AdapterControlBlock *acb, int mode)
 {
+        void *rtnval = 0;
         switch (acb->adapter_type) {
         case ACB_ADAPTER_TYPE_A: {
-                arcmsr_get_hba_config(acb);
+                rtnval = arcmsr_get_hba_config(acb, mode);
                 }
                 break;
 
         case ACB_ADAPTER_TYPE_B: {
-                arcmsr_get_hbb_config(acb);
+                rtnval = arcmsr_get_hbb_config(acb, mode);
                 }
                 break;
         }
+        return rtnval;
 }
 
 static void arcmsr_polling_hba_ccbdone(struct AdapterControlBlock *acb,
@@ -2043,6 +2285,66 @@ static void arcmsr_wait_firmware_ready(struct AdapterControlBlock *acb)
         }
 }
 
+static void arcmsr_request_hba_device_map(struct AdapterControlBlock *acb)
+{
+        struct MessageUnit_A __iomem *reg = acb->pmuA;
+
+        if (unlikely(atomic_read(&acb->rq_map_token) == 0)) {
+                acb->fw_state = false;
+        } else {
+        /*to prevent rq_map_token from changing by other interrupt, then
+        avoid the dead-lock*/
+                acb->fw_state = true;
+                atomic_dec(&acb->rq_map_token);
+                if (!(acb->fw_state) ||
+                        (acb->ante_token_value == atomic_read(&acb->rq_map_token))) {
+                        atomic_set(&acb->rq_map_token, 16);
+                }
+                acb->ante_token_value = atomic_read(&acb->rq_map_token);
+                writel(ARCMSR_INBOUND_MESG0_GET_CONFIG, &reg->inbound_msgaddr0);
+        }
+        mod_timer(&acb->eternal_timer, jiffies + msecs_to_jiffies(6000));
+        return;
+}
+
+static void arcmsr_request_hbb_device_map(struct AdapterControlBlock *acb)
+{
+        struct MessageUnit_B __iomem *reg = acb->pmuB;
+
+        if (unlikely(atomic_read(&acb->rq_map_token) == 0)) {
+                acb->fw_state = false;
+        } else {
+        /*to prevent rq_map_token from changing by other interrupt, then
+        avoid the dead-lock*/
+                acb->fw_state = true;
+                atomic_dec(&acb->rq_map_token);
+                if (!(acb->fw_state) ||
+                        (acb->ante_token_value == atomic_read(&acb->rq_map_token))) {
+                        atomic_set(&acb->rq_map_token, 16);
+                }
+                acb->ante_token_value = atomic_read(&acb->rq_map_token);
+                writel(ARCMSR_MESSAGE_GET_CONFIG, reg->drv2iop_doorbell_reg);
+        }
+        mod_timer(&acb->eternal_timer, jiffies + msecs_to_jiffies(6000));
+        return;
+}
+
+static void arcmsr_request_device_map(unsigned long pacb)
+{
+        struct AdapterControlBlock *acb = (struct AdapterControlBlock *)pacb;
+
+        switch (acb->adapter_type) {
+                case ACB_ADAPTER_TYPE_A: {
+                        arcmsr_request_hba_device_map(acb);
+                }
+                break;
+                case ACB_ADAPTER_TYPE_B: {
+                        arcmsr_request_hbb_device_map(acb);
+                }
+                break;
+        }
+}
+
 static void arcmsr_start_hba_bgrb(struct AdapterControlBlock *acb)
 {
         struct MessageUnit_A __iomem *reg = acb->pmuA;
@@ -2121,6 +2423,60 @@ static void arcmsr_enable_eoi_mode(struct AdapterControlBlock *acb)
         return;
 }
 
+static void arcmsr_hardware_reset(struct AdapterControlBlock *acb)
+{
+        uint8_t value[64];
+        int i;
+
+        /* backup pci config data */
+        for (i = 0; i < 64; i++) {
+                pci_read_config_byte(acb->pdev, i, &value[i]);
+        }
+        /* hardware reset signal */
+        pci_write_config_byte(acb->pdev, 0x84, 0x20);
+        msleep(1000);
+        /* write back pci config data */
+        for (i = 0; i < 64; i++) {
+                pci_write_config_byte(acb->pdev, i, value[i]);
+        }
+        msleep(1000);
+        return;
+}
+/*
+****************************************************************************
+****************************************************************************
+*/
+#ifdef CONFIG_SCSI_ARCMSR_RESET
+        int arcmsr_sleep_for_bus_reset(struct scsi_cmnd *cmd)
+        {
+                        struct Scsi_Host *shost = NULL;
+                        spinlock_t *host_lock = NULL;
+                        int i, isleep;
+
+                        shost = cmd->device->host;
+                        host_lock = shost->host_lock;
+
+                        printk(KERN_NOTICE "Host %d bus reset over, sleep %d seconds (busy %d, can queue %d) ...........\n",
+                                        shost->host_no, sleeptime, shost->host_busy, shost->can_queue);
+                        isleep = sleeptime / 10;
+                        spin_unlock_irq(host_lock);
+                        if (isleep > 0) {
+                                for (i = 0; i < isleep; i++) {
+                                        msleep(10000);
+                                        printk(KERN_NOTICE "^%d^\n", i);
+                                }
+                        }
+
+                        isleep = sleeptime % 10;
+                        if (isleep > 0) {
+                                msleep(isleep * 1000);
+                                printk(KERN_NOTICE "^v^\n");
+                        }
+                        spin_lock_irq(host_lock);
+                        printk(KERN_NOTICE "***** wake up *****\n");
+                        return 0;
+        }
+#endif
 static void arcmsr_iop_init(struct AdapterControlBlock *acb)
 {
         uint32_t intmask_org;
@@ -2129,7 +2485,7 @@ static void arcmsr_iop_init(struct AdapterControlBlock *acb)
        intmask_org = arcmsr_disable_outbound_ints(acb);
         arcmsr_wait_firmware_ready(acb);
         arcmsr_iop_confirm(acb);
-        arcmsr_get_firmware_spec(acb);
+        arcmsr_get_firmware_spec(acb, 1);
         /*start background rebuild*/
         arcmsr_start_adapter_bgrb(acb);
         /* empty doorbell Qbuffer if door bell ringed */
@@ -2140,51 +2496,110 @@ static void arcmsr_iop_init(struct AdapterControlBlock *acb)
         acb->acb_flags |= ACB_F_IOP_INITED;
 }
 
-static void arcmsr_iop_reset(struct AdapterControlBlock *acb)
+static uint8_t arcmsr_iop_reset(struct AdapterControlBlock *acb)
 {
         struct CommandControlBlock *ccb;
         uint32_t intmask_org;
+        uint8_t rtnval = 0x00;
         int i = 0;
 
         if (atomic_read(&acb->ccboutstandingcount) != 0) {
+                /* disable all outbound interrupt */
+                intmask_org = arcmsr_disable_outbound_ints(acb);
                 /* talk to iop 331 outstanding command aborted */
-                arcmsr_abort_allcmd(acb);
-
+                rtnval = arcmsr_abort_allcmd(acb);
                 /* wait for 3 sec for all command aborted*/
                 ssleep(3);
-
-                /* disable all outbound interrupt */
-                intmask_org = arcmsr_disable_outbound_ints(acb);
                 /* clear all outbound posted Q */
                 arcmsr_done4abort_postqueue(acb);
                 for (i = 0; i < ARCMSR_MAX_FREECCB_NUM; i++) {
                         ccb = acb->pccb_pool[i];
                         if (ccb->startdone == ARCMSR_CCB_START) {
-                                ccb->startdone = ARCMSR_CCB_ABORTED;
                                 arcmsr_ccb_complete(ccb, 1);
                         }
                 }
+                atomic_set(&acb->ccboutstandingcount, 0);
                 /* enable all outbound interrupt */
                 arcmsr_enable_outbound_ints(acb, intmask_org);
+                return rtnval;
         }
+        return rtnval;
 }
 
 static int arcmsr_bus_reset(struct scsi_cmnd *cmd)
 {
         struct AdapterControlBlock *acb =
                 (struct AdapterControlBlock *)cmd->device->host->hostdata;
-        int i;
+        int retry = 0;
 
-        acb->num_resets++;
+        if (acb->acb_flags & ACB_F_BUS_RESET)
+                return SUCCESS;
+
+        printk(KERN_NOTICE "arcmsr%d: bus reset ..... \n", acb->adapter_index);
         acb->acb_flags |= ACB_F_BUS_RESET;
-        for (i = 0; i < 400; i++) {
-                if (!atomic_read(&acb->ccboutstandingcount))
+        acb->num_resets++;
+        while (atomic_read(&acb->ccboutstandingcount) != 0 && retry < 4) {
+                arcmsr_interrupt(acb);
+                retry++;
+        }
+
+        if (arcmsr_iop_reset(acb)) {
+                switch (acb->adapter_type) {
+                case ACB_ADAPTER_TYPE_A: {
+                        printk(KERN_NOTICE "arcmsr%d: do hardware bus reset, num_resets = %d num_aborts = %d \n",
+                                acb->adapter_index, acb->num_resets, acb->num_aborts);
+                        arcmsr_hardware_reset(acb);
+                        acb->acb_flags |= ACB_F_FIRMWARE_TRAP;
+                        acb->acb_flags &= ~ACB_F_IOP_INITED;
+                        #ifdef CONFIG_SCSI_ARCMSR_RESET
+                        struct MessageUnit_A __iomem *reg = acb->pmuA;
+                        uint32_t intmask_org, outbound_doorbell;
+                        int retry_count = 0;
+sleep_again:
+                        arcmsr_sleep_for_bus_reset(cmd);
+                        if ((readl(&reg->outbound_msgaddr1) &
+                        ARCMSR_OUTBOUND_MESG1_FIRMWARE_OK) == 0) {
+                        printk(KERN_NOTICE "arcmsr%d: hardware bus reset and return busy, retry=%d \n",
+                        acb->host->host_no, retry_count);
+                        if (retry_count > retrycount) {
+                                printk(KERN_NOTICE "arcmsr%d: hardware bus reset and return busy, retry aborted \n",
+                                acb->host->host_no);
+                        return SUCCESS;
+                        }
+                        retry_count++;
+                        goto sleep_again;
+                        }
+                        acb->acb_flags &= ~ACB_F_FIRMWARE_TRAP;
+                        acb->acb_flags |= ACB_F_IOP_INITED;
+                        acb->acb_flags &= ~ACB_F_BUS_RESET;
+                        printk(KERN_NOTICE "arcmsr%d: hardware bus reset and reset ok \n",
+                                acb->host->host_no);
+                        /* disable all outbound interrupt */
+                        intmask_org = arcmsr_disable_outbound_ints(acb);
+                        arcmsr_get_firmware_spec(acb, 1);
+                        /*start background rebuild*/
+                        arcmsr_start_adapter_bgrb(acb);
+                        /* clear Qbuffer if door bell ringed */
+                        outbound_doorbell = readl(&reg->outbound_doorbell);
+                        writel(outbound_doorbell, &reg->outbound_doorbell); /*clear interrupt */
+                        writel(ARCMSR_INBOUND_DRIVER_DATA_READ_OK, &reg->inbound_doorbell);
+                        /* enable outbound Post Queue,outbound doorbell Interrupt */
+                        arcmsr_enable_outbound_ints(acb, intmask_org);
+                        atomic_set(&acb->rq_map_token, 16);
+                        init_timer(&acb->eternal_timer);
+                        acb->eternal_timer.expires = jiffies + msecs_to_jiffies(20*HZ);
+                        acb->eternal_timer.data = (unsigned long) acb;
+                        acb->eternal_timer.function = &arcmsr_request_device_map;
+                        add_timer(&acb->eternal_timer);
+                        #endif
+                }
                         break;
-                arcmsr_interrupt(acb);/* FIXME: need spinlock */
-                msleep(25);
+                case ACB_ADAPTER_TYPE_B: {
         }
-        arcmsr_iop_reset(acb);
+                }
+        } else {
         acb->acb_flags &= ~ACB_F_BUS_RESET;
+        }
         return SUCCESS;
 }
 
@@ -2277,98 +2692,3 @@ static const char *arcmsr_info(struct Scsi_Host *host)
                         ARCMSR_DRIVER_VERSION);
         return buf;
 }
-#ifdef CONFIG_SCSI_ARCMSR_AER
-static pci_ers_result_t arcmsr_pci_slot_reset(struct pci_dev *pdev)
-{
-        struct Scsi_Host *host = pci_get_drvdata(pdev);
-        struct AdapterControlBlock *acb =
-                (struct AdapterControlBlock *) host->hostdata;
-        uint32_t intmask_org;
-        int i, j;
-
-        if (pci_enable_device(pdev)) {
-                return PCI_ERS_RESULT_DISCONNECT;
-        }
-        pci_set_master(pdev);
-        intmask_org = arcmsr_disable_outbound_ints(acb);
-        acb->acb_flags |= (ACB_F_MESSAGE_WQBUFFER_CLEARED |
-                           ACB_F_MESSAGE_RQBUFFER_CLEARED |
-                           ACB_F_MESSAGE_WQBUFFER_READED);
-        acb->acb_flags &= ~ACB_F_SCSISTOPADAPTER;
-        for (i = 0; i < ARCMSR_MAX_TARGETID; i++)
-                for (j = 0; j < ARCMSR_MAX_TARGETLUN; j++)
-                        acb->devstate[i][j] = ARECA_RAID_GONE;
-
-        arcmsr_wait_firmware_ready(acb);
-        arcmsr_iop_confirm(acb);
-       /* disable all outbound interrupt */
-        arcmsr_get_firmware_spec(acb);
-        /*start background rebuild*/
-        arcmsr_start_adapter_bgrb(acb);
-        /* empty doorbell Qbuffer if door bell ringed */
-        arcmsr_clear_doorbell_queue_buffer(acb);
-        arcmsr_enable_eoi_mode(acb);
-        /* enable outbound Post Queue,outbound doorbell Interrupt */
-        arcmsr_enable_outbound_ints(acb, intmask_org);
-        acb->acb_flags |= ACB_F_IOP_INITED;
-
-        pci_enable_pcie_error_reporting(pdev);
-        return PCI_ERS_RESULT_RECOVERED;
-}
-
-static void arcmsr_pci_ers_need_reset_forepart(struct pci_dev *pdev)
-{
-        struct Scsi_Host *host = pci_get_drvdata(pdev);
-        struct AdapterControlBlock *acb = (struct AdapterControlBlock *)host->hostdata;
-        struct CommandControlBlock *ccb;
-        uint32_t intmask_org;
-        int i = 0;
-
-        if (atomic_read(&acb->ccboutstandingcount) != 0) {
-                /* talk to iop 331 outstanding command aborted */
-                arcmsr_abort_allcmd(acb);
-                /* wait for 3 sec for all command aborted*/
-                ssleep(3);
-                /* disable all outbound interrupt */
-                intmask_org = arcmsr_disable_outbound_ints(acb);
-                /* clear all outbound posted Q */
-                arcmsr_done4abort_postqueue(acb);
-                for (i = 0; i < ARCMSR_MAX_FREECCB_NUM; i++) {
-                        ccb = acb->pccb_pool[i];
-                        if (ccb->startdone == ARCMSR_CCB_START) {
-                                ccb->startdone = ARCMSR_CCB_ABORTED;
-                                arcmsr_ccb_complete(ccb, 1);
-                        }
-                }
-                /* enable all outbound interrupt */
-                arcmsr_enable_outbound_ints(acb, intmask_org);
-        }
-        pci_disable_device(pdev);
-}
-
-static void arcmsr_pci_ers_disconnect_forepart(struct pci_dev *pdev)
-{
-                        struct Scsi_Host *host = pci_get_drvdata(pdev);
-                        struct AdapterControlBlock *acb = \
-                                (struct AdapterControlBlock *)host->hostdata;
-
-                        arcmsr_stop_adapter_bgrb(acb);
-                        arcmsr_flush_adapter_cache(acb);
-}
-
-static pci_ers_result_t arcmsr_pci_error_detected(struct pci_dev *pdev,
-                                                pci_channel_state_t state)
-{
-        switch (state) {
-        case pci_channel_io_frozen:
-                        arcmsr_pci_ers_need_reset_forepart(pdev);
-                        return PCI_ERS_RESULT_NEED_RESET;
-        case pci_channel_io_perm_failure:
-                        arcmsr_pci_ers_disconnect_forepart(pdev);
-                        return PCI_ERS_RESULT_DISCONNECT;
-                        break;
-        default:
-                        return PCI_ERS_RESULT_NEED_RESET;
-          }
-}
-#endif
diff --git a/drivers/scsi/be2iscsi/be_mgmt.c b/drivers/scsi/be2iscsi/be_mgmt.c
index e641922f20bc..350cbeaae160 100644
--- a/drivers/scsi/be2iscsi/be_mgmt.c
+++ b/drivers/scsi/be2iscsi/be_mgmt.c
@@ -167,10 +167,9 @@ unsigned char mgmt_invalidate_icds(struct beiscsi_hba *phba,
                                 &nonemb_cmd.dma);
         if (nonemb_cmd.va == NULL) {
                 SE_DEBUG(DBG_LVL_1,
-                         "Failed to allocate memory for"
-                         "mgmt_invalidate_icds \n");
+                         "Failed to allocate memory for mgmt_invalidate_icds\n");
                 spin_unlock(&ctrl->mbox_lock);
-                return -1;
+                return 0;
         }
         nonemb_cmd.size = sizeof(struct invalidate_commands_params_in);
         req = nonemb_cmd.va;
diff --git a/drivers/scsi/bfa/bfa_core.c b/drivers/scsi/bfa/bfa_core.c
index 0c08e185a766..3a7b3f88932f 100644
--- a/drivers/scsi/bfa/bfa_core.c
+++ b/drivers/scsi/bfa/bfa_core.c
@@ -84,11 +84,32 @@ bfa_cfg_get_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *meminfo)
         for (i = 0; hal_mods[i]; i++)
                 hal_mods[i]->meminfo(cfg, &km_len, &dm_len);
 
+        dm_len += bfa_port_meminfo();
 
         meminfo->meminfo[BFA_MEM_TYPE_KVA - 1].mem_len = km_len;
         meminfo->meminfo[BFA_MEM_TYPE_DMA - 1].mem_len = dm_len;
 }
 
+static void
+bfa_com_port_attach(struct bfa_s *bfa, struct bfa_meminfo_s *mi)
+{
+        struct bfa_port_s       *port = &bfa->modules.port;
+        uint32_t                dm_len;
+        uint8_t                 *dm_kva;
+        uint64_t                dm_pa;
+
+        dm_len = bfa_port_meminfo();
+        dm_kva = bfa_meminfo_dma_virt(mi);
+        dm_pa  = bfa_meminfo_dma_phys(mi);
+
+        memset(port, 0, sizeof(struct bfa_port_s));
+        bfa_port_attach(port, &bfa->ioc, bfa, bfa->trcmod, bfa->logm);
+        bfa_port_mem_claim(port, dm_kva, dm_pa);
+
+        bfa_meminfo_dma_virt(mi) = dm_kva + dm_len;
+        bfa_meminfo_dma_phys(mi) = dm_pa + dm_len;
+}
+
 /**
  * Use this function to do attach the driver instance with the BFA
  * library. This function will not trigger any HW initialization
@@ -140,6 +161,7 @@ bfa_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
         for (i = 0; hal_mods[i]; i++)
                 hal_mods[i]->attach(bfa, bfad, cfg, meminfo, pcidev);
 
+        bfa_com_port_attach(bfa, meminfo);
 }
 
 /**
diff --git a/drivers/scsi/gvp11.c b/drivers/scsi/gvp11.c
index 18b7102bb80e..2ce26eb7a1ec 100644
--- a/drivers/scsi/gvp11.c
+++ b/drivers/scsi/gvp11.c
@@ -1,36 +1,35 @@
 #include <linux/types.h>
-#include <linux/mm.h>
-#include <linux/slab.h>
-#include <linux/blkdev.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
+#include <linux/mm.h>
+#include <linux/slab.h>
+#include <linux/spinlock.h>
+#include <linux/zorro.h>
 
-#include <asm/setup.h>
 #include <asm/page.h>
 #include <asm/pgtable.h>
 #include <asm/amigaints.h>
 #include <asm/amigahw.h>
-#include <linux/zorro.h>
-#include <asm/irq.h>
-#include <linux/spinlock.h>
 
 #include "scsi.h"
-#include <scsi/scsi_host.h>
 #include "wd33c93.h"
 #include "gvp11.h"
 
-#include <linux/stat.h>
 
+#define CHECK_WD33C93
 
-#define DMA(ptr)        ((gvp11_scsiregs *)((ptr)->base))
+struct gvp11_hostdata {
+        struct WD33C93_hostdata wh;
+        struct gvp11_scsiregs *regs;
+};
 
-static irqreturn_t gvp11_intr(int irq, void *_instance)
+static irqreturn_t gvp11_intr(int irq, void *data)
 {
+        struct Scsi_Host *instance = data;
+        struct gvp11_hostdata *hdata = shost_priv(instance);
+        unsigned int status = hdata->regs->CNTR;
         unsigned long flags;
-        unsigned int status;
-        struct Scsi_Host *instance = (struct Scsi_Host *)_instance;
 
-        status = DMA(instance)->CNTR;
         if (!(status & GVP11_DMAC_INT_PENDING))
                 return IRQ_NONE;
 
@@ -50,64 +49,66 @@ void gvp11_setup(char *str, int *ints)
 static int dma_setup(struct scsi_cmnd *cmd, int dir_in)
 {
         struct Scsi_Host *instance = cmd->device->host;
-        struct WD33C93_hostdata *hdata = shost_priv(instance);
+        struct gvp11_hostdata *hdata = shost_priv(instance);
+        struct WD33C93_hostdata *wh = &hdata->wh;
+        struct gvp11_scsiregs *regs = hdata->regs;
         unsigned short cntr = GVP11_DMAC_INT_ENABLE;
         unsigned long addr = virt_to_bus(cmd->SCp.ptr);
         int bank_mask;
         static int scsi_alloc_out_of_range = 0;
 
         /* use bounce buffer if the physical address is bad */
-        if (addr & hdata->dma_xfer_mask) {
-                hdata->dma_bounce_len = (cmd->SCp.this_residual + 511) & ~0x1ff;
+        if (addr & wh->dma_xfer_mask) {
+                wh->dma_bounce_len = (cmd->SCp.this_residual + 511) & ~0x1ff;
 
                 if (!scsi_alloc_out_of_range) {
-                        hdata->dma_bounce_buffer =
-                                kmalloc(hdata->dma_bounce_len, GFP_KERNEL);
-                        hdata->dma_buffer_pool = BUF_SCSI_ALLOCED;
+                        wh->dma_bounce_buffer =
+                                kmalloc(wh->dma_bounce_len, GFP_KERNEL);
+                        wh->dma_buffer_pool = BUF_SCSI_ALLOCED;
                 }
 
                 if (scsi_alloc_out_of_range ||
-                    !hdata->dma_bounce_buffer) {
-                        hdata->dma_bounce_buffer =
-                                amiga_chip_alloc(hdata->dma_bounce_len,
+                    !wh->dma_bounce_buffer) {
+                        wh->dma_bounce_buffer =
+                                amiga_chip_alloc(wh->dma_bounce_len,
                                                  "GVP II SCSI Bounce Buffer");
 
-                        if (!hdata->dma_bounce_buffer) {
-                                hdata->dma_bounce_len = 0;
+                        if (!wh->dma_bounce_buffer) {
+                                wh->dma_bounce_len = 0;
                                 return 1;
                         }
 
-                        hdata->dma_buffer_pool = BUF_CHIP_ALLOCED;
+                        wh->dma_buffer_pool = BUF_CHIP_ALLOCED;
                 }
 
                 /* check if the address of the bounce buffer is OK */
-                addr = virt_to_bus(hdata->dma_bounce_buffer);
+                addr = virt_to_bus(wh->dma_bounce_buffer);
 
-                if (addr & hdata->dma_xfer_mask) {
+                if (addr & wh->dma_xfer_mask) {
                         /* fall back to Chip RAM if address out of range */
-                        if (hdata->dma_buffer_pool == BUF_SCSI_ALLOCED) {
-                                kfree(hdata->dma_bounce_buffer);
+                        if (wh->dma_buffer_pool == BUF_SCSI_ALLOCED) {
+                                kfree(wh->dma_bounce_buffer);
                                 scsi_alloc_out_of_range = 1;
                         } else {
-                                amiga_chip_free(hdata->dma_bounce_buffer);
+                                amiga_chip_free(wh->dma_bounce_buffer);
                         }
 
-                        hdata->dma_bounce_buffer =
-                                amiga_chip_alloc(hdata->dma_bounce_len,
+                        wh->dma_bounce_buffer =
+                                amiga_chip_alloc(wh->dma_bounce_len,
                                                  "GVP II SCSI Bounce Buffer");
 
-                        if (!hdata->dma_bounce_buffer) {
-                                hdata->dma_bounce_len = 0;
+                        if (!wh->dma_bounce_buffer) {
+                                wh->dma_bounce_len = 0;
                                 return 1;
                         }
 
-                        addr = virt_to_bus(hdata->dma_bounce_buffer);
-                        hdata->dma_buffer_pool = BUF_CHIP_ALLOCED;
+                        addr = virt_to_bus(wh->dma_bounce_buffer);
+                        wh->dma_buffer_pool = BUF_CHIP_ALLOCED;
                 }
 
                 if (!dir_in) {
                         /* copy to bounce buffer for a write */
-                        memcpy(hdata->dma_bounce_buffer, cmd->SCp.ptr,
+                        memcpy(wh->dma_bounce_buffer, cmd->SCp.ptr,
                                cmd->SCp.this_residual);
                 }
         }
@@ -116,11 +117,11 @@ static int dma_setup(struct scsi_cmnd *cmd, int dir_in)
         if (!dir_in)
                 cntr |= GVP11_DMAC_DIR_WRITE;
 
-        hdata->dma_dir = dir_in;
-        DMA(cmd->device->host)->CNTR = cntr;
+        wh->dma_dir = dir_in;
+        regs->CNTR = cntr;
 
         /* setup DMA *physical* address */
-        DMA(cmd->device->host)->ACR = addr;
+        regs->ACR = addr;
 
         if (dir_in) {
                 /* invalidate any cache */
@@ -130,12 +131,12 @@ static int dma_setup(struct scsi_cmnd *cmd, int dir_in)
                 cache_push(addr, cmd->SCp.this_residual);
         }
 
-        bank_mask = (~hdata->dma_xfer_mask >> 18) & 0x01c0;
+        bank_mask = (~wh->dma_xfer_mask >> 18) & 0x01c0;
         if (bank_mask)
-                DMA(cmd->device->host)->BANK = bank_mask & (addr >> 18);
+                regs->BANK = bank_mask & (addr >> 18);
 
         /* start DMA */
-        DMA(cmd->device->host)->ST_DMA = 1;
+        regs->ST_DMA = 1;
 
         /* return success */
         return 0;
@@ -144,236 +145,53 @@ static int dma_setup(struct scsi_cmnd *cmd, int dir_in)
 static void dma_stop(struct Scsi_Host *instance, struct scsi_cmnd *SCpnt,
                      int status)
 {
-        struct WD33C93_hostdata *hdata = shost_priv(instance);
+        struct gvp11_hostdata *hdata = shost_priv(instance);
+        struct WD33C93_hostdata *wh = &hdata->wh;
+        struct gvp11_scsiregs *regs = hdata->regs;
 
         /* stop DMA */
-        DMA(instance)->SP_DMA = 1;
+        regs->SP_DMA = 1;
         /* remove write bit from CONTROL bits */
-        DMA(instance)->CNTR = GVP11_DMAC_INT_ENABLE;
+        regs->CNTR = GVP11_DMAC_INT_ENABLE;
 
         /* copy from a bounce buffer, if necessary */
-        if (status && hdata->dma_bounce_buffer) {
-                if (hdata->dma_dir && SCpnt)
-                        memcpy(SCpnt->SCp.ptr, hdata->dma_bounce_buffer,
+        if (status && wh->dma_bounce_buffer) {
+                if (wh->dma_dir && SCpnt)
+                        memcpy(SCpnt->SCp.ptr, wh->dma_bounce_buffer,
                                SCpnt->SCp.this_residual);
 
-                if (hdata->dma_buffer_pool == BUF_SCSI_ALLOCED)
-                        kfree(hdata->dma_bounce_buffer);
-                else
-                        amiga_chip_free(hdata->dma_bounce_buffer);
-
-                hdata->dma_bounce_buffer = NULL;
-                hdata->dma_bounce_len = 0;
-        }
-}
-
-#define CHECK_WD33C93
-
-int __init gvp11_detect(struct scsi_host_template *tpnt)
-{
-        static unsigned char called = 0;
-        struct Scsi_Host *instance;
-        unsigned long address;
-        unsigned int epc;
-        struct zorro_dev *z = NULL;
-        unsigned int default_dma_xfer_mask;
-        struct WD33C93_hostdata *hdata;
-        wd33c93_regs regs;
-        int num_gvp11 = 0;
-#ifdef CHECK_WD33C93
-        volatile unsigned char *sasr_3393, *scmd_3393;
-        unsigned char save_sasr;
-        unsigned char q, qq;
-#endif
-
-        if (!MACH_IS_AMIGA || called)
-                return 0;
-        called = 1;
-
-        tpnt->proc_name = "GVP11";
-        tpnt->proc_info = &wd33c93_proc_info;
-
-        while ((z = zorro_find_device(ZORRO_WILDCARD, z))) {
-                /*
-                 * This should (hopefully) be the correct way to identify
-                 * all the different GVP SCSI controllers (except for the
-                 * SERIES I though).
-                 */
-
-                if (z->id == ZORRO_PROD_GVP_COMBO_030_R3_SCSI ||
-                    z->id == ZORRO_PROD_GVP_SERIES_II)
-                        default_dma_xfer_mask = ~0x00ffffff;
-                else if (z->id == ZORRO_PROD_GVP_GFORCE_030_SCSI ||
-                         z->id == ZORRO_PROD_GVP_A530_SCSI ||
-                         z->id == ZORRO_PROD_GVP_COMBO_030_R4_SCSI)
-                        default_dma_xfer_mask = ~0x01ffffff;
-                else if (z->id == ZORRO_PROD_GVP_A1291 ||
-                         z->id == ZORRO_PROD_GVP_GFORCE_040_SCSI_1)
-                        default_dma_xfer_mask = ~0x07ffffff;
+                if (wh->dma_buffer_pool == BUF_SCSI_ALLOCED)
+                        kfree(wh->dma_bounce_buffer);
                 else
-                        continue;
-
-                /*
-                 * Rumors state that some GVP ram boards use the same product
-                 * code as the SCSI controllers. Therefore if the board-size
-                 * is not 64KB we asume it is a ram board and bail out.
-                 */
-                if (z->resource.end - z->resource.start != 0xffff)
-                        continue;
+                        amiga_chip_free(wh->dma_bounce_buffer);
 
-                address = z->resource.start;
-                if (!request_mem_region(address, 256, "wd33c93"))
-                        continue;
-
-#ifdef CHECK_WD33C93
-
-                /*
-                 * These darn GVP boards are a problem - it can be tough to tell
-                 * whether or not they include a SCSI controller. This is the
-                 * ultimate Yet-Another-GVP-Detection-Hack in that it actually
-                 * probes for a WD33c93 chip: If we find one, it's extremely
-                 * likely that this card supports SCSI, regardless of Product_
-                 * Code, Board_Size, etc.
-                 */
-
-                /* Get pointers to the presumed register locations and save contents */
-
-                sasr_3393 = &(((gvp11_scsiregs *)(ZTWO_VADDR(address)))->SASR);
-                scmd_3393 = &(((gvp11_scsiregs *)(ZTWO_VADDR(address)))->SCMD);
-                save_sasr = *sasr_3393;
-
-                /* First test the AuxStatus Reg */
-
-                q = *sasr_3393; /* read it */
-                if (q & 0x08)   /* bit 3 should always be clear */
-                        goto release;
-                *sasr_3393 = WD_AUXILIARY_STATUS;       /* setup indirect address */
-                if (*sasr_3393 == WD_AUXILIARY_STATUS) {        /* shouldn't retain the write */
-                        *sasr_3393 = save_sasr; /* Oops - restore this byte */
-                        goto release;
-                }
-                if (*sasr_3393 != q) {  /* should still read the same */
-                        *sasr_3393 = save_sasr; /* Oops - restore this byte */
-                        goto release;
-                }
-                if (*scmd_3393 != q)    /* and so should the image at 0x1f */
-                        goto release;
-
-                /*
-                 * Ok, we probably have a wd33c93, but let's check a few other places
-                 * for good measure. Make sure that this works for both 'A and 'B
-                 * chip versions.
-                 */
-
-                *sasr_3393 = WD_SCSI_STATUS;
-                q = *scmd_3393;
-                *sasr_3393 = WD_SCSI_STATUS;
-                *scmd_3393 = ~q;
-                *sasr_3393 = WD_SCSI_STATUS;
-                qq = *scmd_3393;
-                *sasr_3393 = WD_SCSI_STATUS;
-                *scmd_3393 = q;
-                if (qq != q)    /* should be read only */
-                        goto release;
-                *sasr_3393 = 0x1e;      /* this register is unimplemented */
-                q = *scmd_3393;
-                *sasr_3393 = 0x1e;
-                *scmd_3393 = ~q;
-                *sasr_3393 = 0x1e;
-                qq = *scmd_3393;
-                *sasr_3393 = 0x1e;
-                *scmd_3393 = q;
-                if (qq != q || qq != 0xff)      /* should be read only, all 1's */
-                        goto release;
-                *sasr_3393 = WD_TIMEOUT_PERIOD;
-                q = *scmd_3393;
-                *sasr_3393 = WD_TIMEOUT_PERIOD;
-                *scmd_3393 = ~q;
-                *sasr_3393 = WD_TIMEOUT_PERIOD;
-                qq = *scmd_3393;
-                *sasr_3393 = WD_TIMEOUT_PERIOD;
-                *scmd_3393 = q;
-                if (qq != (~q & 0xff))  /* should be read/write */
-                        goto release;
-#endif
-
-                instance = scsi_register(tpnt, sizeof(struct WD33C93_hostdata));
-                if (instance == NULL)
-                        goto release;
-                instance->base = ZTWO_VADDR(address);
-                instance->irq = IRQ_AMIGA_PORTS;
-                instance->unique_id = z->slotaddr;
-
-                hdata = shost_priv(instance);
-                if (gvp11_xfer_mask)
-                        hdata->dma_xfer_mask = gvp11_xfer_mask;
-                else
-                        hdata->dma_xfer_mask = default_dma_xfer_mask;
-
-                DMA(instance)->secret2 = 1;
-                DMA(instance)->secret1 = 0;
-                DMA(instance)->secret3 = 15;
-                while (DMA(instance)->CNTR & GVP11_DMAC_BUSY)
-                        ;
-                DMA(instance)->CNTR = 0;
-
-                DMA(instance)->BANK = 0;
-
-                epc = *(unsigned short *)(ZTWO_VADDR(address) + 0x8000);
-
-                /*
-                 * Check for 14MHz SCSI clock
-                 */
-                regs.SASR = &(DMA(instance)->SASR);
-                regs.SCMD = &(DMA(instance)->SCMD);
-                hdata->no_sync = 0xff;
-                hdata->fast = 0;
-                hdata->dma_mode = CTRL_DMA;
-                wd33c93_init(instance, regs, dma_setup, dma_stop,
-                             (epc & GVP_SCSICLKMASK) ? WD33C93_FS_8_10
-                                                     : WD33C93_FS_12_15);
-
-                if (request_irq(IRQ_AMIGA_PORTS, gvp11_intr, IRQF_SHARED,
-                                "GVP11 SCSI", instance))
-                        goto unregister;
-                DMA(instance)->CNTR = GVP11_DMAC_INT_ENABLE;
-                num_gvp11++;
-                continue;
-
-unregister:
-                scsi_unregister(instance);
-release:
-                release_mem_region(address, 256);
+                wh->dma_bounce_buffer = NULL;
+                wh->dma_bounce_len = 0;
         }
-
-        return num_gvp11;
 }
 
 static int gvp11_bus_reset(struct scsi_cmnd *cmd)
 {
+        struct Scsi_Host *instance = cmd->device->host;
+
         /* FIXME perform bus-specific reset */
 
         /* FIXME 2: shouldn't we no-op this function (return
            FAILED), and fall back to host reset function,
            wd33c93_host_reset ? */
 
-        spin_lock_irq(cmd->device->host->host_lock);
+        spin_lock_irq(instance->host_lock);
         wd33c93_host_reset(cmd);
-        spin_unlock_irq(cmd->device->host->host_lock);
+        spin_unlock_irq(instance->host_lock);
 
         return SUCCESS;
 }
 
-
-#define HOSTS_C
-
-#include "gvp11.h"
-
-static struct scsi_host_template driver_template = {
-        .proc_name              = "GVP11",
+static struct scsi_host_template gvp11_scsi_template = {
+        .module                 = THIS_MODULE,
         .name                   = "GVP Series II SCSI",
-        .detect                 = gvp11_detect,
-        .release                = gvp11_release,
+        .proc_info              = wd33c93_proc_info,
+        .proc_name              = "GVP11",
         .queuecommand           = wd33c93_queuecommand,
         .eh_abort_handler       = wd33c93_abort,
         .eh_bus_reset_handler   = gvp11_bus_reset,
@@ -385,17 +203,230 @@ static struct scsi_host_template driver_template = {
         .use_clustering         = DISABLE_CLUSTERING
 };
 
+static int __devinit check_wd33c93(struct gvp11_scsiregs *regs)
+{
+#ifdef CHECK_WD33C93
+        volatile unsigned char *sasr_3393, *scmd_3393;
+        unsigned char save_sasr;
+        unsigned char q, qq;
 
-#include "scsi_module.c"
+        /*
+         * These darn GVP boards are a problem - it can be tough to tell
+         * whether or not they include a SCSI controller. This is the
+         * ultimate Yet-Another-GVP-Detection-Hack in that it actually
+         * probes for a WD33c93 chip: If we find one, it's extremely
+         * likely that this card supports SCSI, regardless of Product_
+         * Code, Board_Size, etc.
+         */
+
+        /* Get pointers to the presumed register locations and save contents */
+
+        sasr_3393 = &regs->SASR;
+        scmd_3393 = &regs->SCMD;
+        save_sasr = *sasr_3393;
+
+        /* First test the AuxStatus Reg */
+
+        q = *sasr_3393; /* read it */
+        if (q & 0x08)   /* bit 3 should always be clear */
+                return -ENODEV;
+        *sasr_3393 = WD_AUXILIARY_STATUS;       /* setup indirect address */
+        if (*sasr_3393 == WD_AUXILIARY_STATUS) {        /* shouldn't retain the write */
+                *sasr_3393 = save_sasr; /* Oops - restore this byte */
+                return -ENODEV;
+        }
+        if (*sasr_3393 != q) {  /* should still read the same */
+                *sasr_3393 = save_sasr; /* Oops - restore this byte */
+                return -ENODEV;
+        }
+        if (*scmd_3393 != q)    /* and so should the image at 0x1f */
+                return -ENODEV;
+
+        /*
+         * Ok, we probably have a wd33c93, but let's check a few other places
+         * for good measure. Make sure that this works for both 'A and 'B
+         * chip versions.
+         */
+
+        *sasr_3393 = WD_SCSI_STATUS;
+        q = *scmd_3393;
+        *sasr_3393 = WD_SCSI_STATUS;
+        *scmd_3393 = ~q;
+        *sasr_3393 = WD_SCSI_STATUS;
+        qq = *scmd_3393;
+        *sasr_3393 = WD_SCSI_STATUS;
+        *scmd_3393 = q;
+        if (qq != q)    /* should be read only */
+                return -ENODEV;
+        *sasr_3393 = 0x1e;      /* this register is unimplemented */
+        q = *scmd_3393;
+        *sasr_3393 = 0x1e;
+        *scmd_3393 = ~q;
+        *sasr_3393 = 0x1e;
+        qq = *scmd_3393;
+        *sasr_3393 = 0x1e;
+        *scmd_3393 = q;
+        if (qq != q || qq != 0xff)      /* should be read only, all 1's */
+                return -ENODEV;
+        *sasr_3393 = WD_TIMEOUT_PERIOD;
+        q = *scmd_3393;
+        *sasr_3393 = WD_TIMEOUT_PERIOD;
+        *scmd_3393 = ~q;
+        *sasr_3393 = WD_TIMEOUT_PERIOD;
+        qq = *scmd_3393;
+        *sasr_3393 = WD_TIMEOUT_PERIOD;
+        *scmd_3393 = q;
+        if (qq != (~q & 0xff))  /* should be read/write */
+                return -ENODEV;
+#endif /* CHECK_WD33C93 */
 
-int gvp11_release(struct Scsi_Host *instance)
+        return 0;
+}
+
+static int __devinit gvp11_probe(struct zorro_dev *z,
+                                 const struct zorro_device_id *ent)
 {
-#ifdef MODULE
-        DMA(instance)->CNTR = 0;
-        release_mem_region(ZTWO_PADDR(instance->base), 256);
+        struct Scsi_Host *instance;
+        unsigned long address;
+        int error;
+        unsigned int epc;
+        unsigned int default_dma_xfer_mask;
+        struct gvp11_hostdata *hdata;
+        struct gvp11_scsiregs *regs;
+        wd33c93_regs wdregs;
+
+        default_dma_xfer_mask = ent->driver_data;
+
+        /*
+         * Rumors state that some GVP ram boards use the same product
+         * code as the SCSI controllers. Therefore if the board-size
+         * is not 64KB we asume it is a ram board and bail out.
+         */
+        if (zorro_resource_len(z) != 0x10000)
+                return -ENODEV;
+
+        address = z->resource.start;
+        if (!request_mem_region(address, 256, "wd33c93"))
+                return -EBUSY;
+
+        regs = (struct gvp11_scsiregs *)(ZTWO_VADDR(address));
+
+        error = check_wd33c93(regs);
+        if (error)
+                goto fail_check_or_alloc;
+
+        instance = scsi_host_alloc(&gvp11_scsi_template,
+                                   sizeof(struct gvp11_hostdata));
+        if (!instance) {
+                error = -ENOMEM;
+                goto fail_check_or_alloc;
+        }
+
+        instance->irq = IRQ_AMIGA_PORTS;
+        instance->unique_id = z->slotaddr;
+
+        regs->secret2 = 1;
+        regs->secret1 = 0;
+        regs->secret3 = 15;
+        while (regs->CNTR & GVP11_DMAC_BUSY)
+                ;
+        regs->CNTR = 0;
+        regs->BANK = 0;
+
+        wdregs.SASR = &regs->SASR;
+        wdregs.SCMD = &regs->SCMD;
+
+        hdata = shost_priv(instance);
+        if (gvp11_xfer_mask)
+                hdata->wh.dma_xfer_mask = gvp11_xfer_mask;
+        else
+                hdata->wh.dma_xfer_mask = default_dma_xfer_mask;
+
+        hdata->wh.no_sync = 0xff;
+        hdata->wh.fast = 0;
+        hdata->wh.dma_mode = CTRL_DMA;
+        hdata->regs = regs;
+
+        /*
+         * Check for 14MHz SCSI clock
+         */
+        epc = *(unsigned short *)(ZTWO_VADDR(address) + 0x8000);
+        wd33c93_init(instance, wdregs, dma_setup, dma_stop,
+                     (epc & GVP_SCSICLKMASK) ? WD33C93_FS_8_10
+                                             : WD33C93_FS_12_15);
+
+        error = request_irq(IRQ_AMIGA_PORTS, gvp11_intr, IRQF_SHARED,
+                            "GVP11 SCSI", instance);
+        if (error)
+                goto fail_irq;
+
+        regs->CNTR = GVP11_DMAC_INT_ENABLE;
+
+        error = scsi_add_host(instance, NULL);
+        if (error)
+                goto fail_host;
+
+        zorro_set_drvdata(z, instance);
+        scsi_scan_host(instance);
+        return 0;
+
+fail_host:
         free_irq(IRQ_AMIGA_PORTS, instance);
-#endif
-        return 1;
+fail_irq:
+        scsi_host_put(instance);
+fail_check_or_alloc:
+        release_mem_region(address, 256);
+        return error;
+}
+
+static void __devexit gvp11_remove(struct zorro_dev *z)
+{
+        struct Scsi_Host *instance = zorro_get_drvdata(z);
+        struct gvp11_hostdata *hdata = shost_priv(instance);
+
+        hdata->regs->CNTR = 0;
+        scsi_remove_host(instance);
+        free_irq(IRQ_AMIGA_PORTS, instance);
+        scsi_host_put(instance);
+        release_mem_region(z->resource.start, 256);
+}
+
+        /*
+         * This should (hopefully) be the correct way to identify
+         * all the different GVP SCSI controllers (except for the
+         * SERIES I though).
+         */
+
+static struct zorro_device_id gvp11_zorro_tbl[] __devinitdata = {
+        { ZORRO_PROD_GVP_COMBO_030_R3_SCSI,     ~0x00ffffff },
+        { ZORRO_PROD_GVP_SERIES_II,             ~0x00ffffff },
+        { ZORRO_PROD_GVP_GFORCE_030_SCSI,       ~0x01ffffff },
+        { ZORRO_PROD_GVP_A530_SCSI,             ~0x01ffffff },
+        { ZORRO_PROD_GVP_COMBO_030_R4_SCSI,     ~0x01ffffff },
+        { ZORRO_PROD_GVP_A1291,                 ~0x07ffffff },
+        { ZORRO_PROD_GVP_GFORCE_040_SCSI_1,     ~0x07ffffff },
+        { 0 }
+};
+MODULE_DEVICE_TABLE(zorro, gvp11_zorro_tbl);
+
+static struct zorro_driver gvp11_driver = {
+        .name           = "gvp11",
+        .id_table       = gvp11_zorro_tbl,
+        .probe          = gvp11_probe,
+        .remove         = __devexit_p(gvp11_remove),
+};
+
+static int __init gvp11_init(void)
+{
+        return zorro_register_driver(&gvp11_driver);
+}
+module_init(gvp11_init);
+
+static void __exit gvp11_exit(void)
+{
+        zorro_unregister_driver(&gvp11_driver);
 }
+module_exit(gvp11_exit);
 
+MODULE_DESCRIPTION("GVP Series II SCSI");
 MODULE_LICENSE("GPL");
diff --git a/drivers/scsi/gvp11.h b/drivers/scsi/gvp11.h
index e2efdf9601ef..852913cde5dd 100644
--- a/drivers/scsi/gvp11.h
+++ b/drivers/scsi/gvp11.h
@@ -11,9 +11,6 @@
 
 #include <linux/types.h>
 
-int gvp11_detect(struct scsi_host_template *);
-int gvp11_release(struct Scsi_Host *);
-
 #ifndef CMD_PER_LUN
 #define CMD_PER_LUN             2
 #endif
@@ -22,15 +19,13 @@ int gvp11_release(struct Scsi_Host *);
 #define CAN_QUEUE               16
 #endif
 
-#ifndef HOSTS_C
-
 /*
  * if the transfer address ANDed with this results in a non-zero
  * result, then we can't use DMA.
  */
 #define GVP11_XFER_MASK         (0xff000001)
 
-typedef struct {
+struct gvp11_scsiregs {
                  unsigned char  pad1[64];
         volatile unsigned short CNTR;
                  unsigned char  pad2[31];
@@ -46,7 +41,7 @@ typedef struct {
         volatile unsigned short SP_DMA;
         volatile unsigned short secret2; /* store 1 here */
         volatile unsigned short secret3; /* store 15 here */
-} gvp11_scsiregs;
+};
 
 /* bits in CNTR */
 #define GVP11_DMAC_BUSY         (1<<0)
@@ -54,6 +49,4 @@ typedef struct {
 #define GVP11_DMAC_INT_ENABLE   (1<<3)
 #define GVP11_DMAC_DIR_WRITE    (1<<4)
 
-#endif /* else def HOSTS_C */
-
 #endif /* GVP11_H */
diff --git a/drivers/scsi/ipr.c b/drivers/scsi/ipr.c
index 6a6661c35b2f..82ea4a8226b0 100644
--- a/drivers/scsi/ipr.c
+++ b/drivers/scsi/ipr.c
@@ -567,7 +567,8 @@ static void ipr_trc_hook(struct ipr_cmnd *ipr_cmd,
 static void ipr_reinit_ipr_cmnd(struct ipr_cmnd *ipr_cmd)
 {
         struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
-        struct ipr_ioasa *ioasa = &ipr_cmd->ioasa;
+        struct ipr_ioasa *ioasa = &ipr_cmd->s.ioasa;
+        struct ipr_ioasa64 *ioasa64 = &ipr_cmd->s.ioasa64;
         dma_addr_t dma_addr = ipr_cmd->dma_addr;
 
         memset(&ioarcb->cmd_pkt, 0, sizeof(struct ipr_cmd_pkt));
@@ -576,19 +577,19 @@ static void ipr_reinit_ipr_cmnd(struct ipr_cmnd *ipr_cmd)
         ioarcb->ioadl_len = 0;
         ioarcb->read_ioadl_len = 0;
 
-        if (ipr_cmd->ioa_cfg->sis64)
+        if (ipr_cmd->ioa_cfg->sis64) {
                 ioarcb->u.sis64_addr_data.data_ioadl_addr =
                         cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, i.ioadl64));
-        else {
+                ioasa64->u.gata.status = 0;
+        } else {
                 ioarcb->write_ioadl_addr =
                         cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, i.ioadl));
                 ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr;
+                ioasa->u.gata.status = 0;
         }
 
-        ioasa->ioasc = 0;
-        ioasa->residual_data_len = 0;
-        ioasa->u.gata.status = 0;
-
+        ioasa->hdr.ioasc = 0;
+        ioasa->hdr.residual_data_len = 0;
         ipr_cmd->scsi_cmd = NULL;
         ipr_cmd->qc = NULL;
         ipr_cmd->sense_buffer[0] = 0;
@@ -768,8 +769,8 @@ static void ipr_fail_all_ops(struct ipr_ioa_cfg *ioa_cfg)
         list_for_each_entry_safe(ipr_cmd, temp, &ioa_cfg->pending_q, queue) {
                 list_del(&ipr_cmd->queue);
 
-                ipr_cmd->ioasa.ioasc = cpu_to_be32(IPR_IOASC_IOA_WAS_RESET);
-                ipr_cmd->ioasa.ilid = cpu_to_be32(IPR_DRIVER_ILID);
+                ipr_cmd->s.ioasa.hdr.ioasc = cpu_to_be32(IPR_IOASC_IOA_WAS_RESET);
+                ipr_cmd->s.ioasa.hdr.ilid = cpu_to_be32(IPR_DRIVER_ILID);
 
                 if (ipr_cmd->scsi_cmd)
                         ipr_cmd->done = ipr_scsi_eh_done;
@@ -1040,7 +1041,7 @@ static void ipr_init_res_entry(struct ipr_resource_entry *res,
                 proto = cfgtew->u.cfgte64->proto;
                 res->res_flags = cfgtew->u.cfgte64->res_flags;
                 res->qmodel = IPR_QUEUEING_MODEL64(res);
-                res->type = cfgtew->u.cfgte64->res_type & 0x0f;
+                res->type = cfgtew->u.cfgte64->res_type;
 
                 memcpy(res->res_path, &cfgtew->u.cfgte64->res_path,
                         sizeof(res->res_path));
@@ -1319,7 +1320,7 @@ static void ipr_process_ccn(struct ipr_cmnd *ipr_cmd)
 {
         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
         struct ipr_hostrcb *hostrcb = ipr_cmd->u.hostrcb;
-        u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
+        u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
 
         list_del(&hostrcb->queue);
         list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
@@ -2354,7 +2355,7 @@ static void ipr_process_error(struct ipr_cmnd *ipr_cmd)
 {
         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
         struct ipr_hostrcb *hostrcb = ipr_cmd->u.hostrcb;
-        u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
+        u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
         u32 fd_ioasc;
 
         if (ioa_cfg->sis64)
@@ -4509,11 +4510,16 @@ static int ipr_device_reset(struct ipr_ioa_cfg *ioa_cfg,
         }
 
         ipr_send_blocking_cmd(ipr_cmd, ipr_timeout, IPR_DEVICE_RESET_TIMEOUT);
-        ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
+        ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
         list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
-        if (ipr_is_gata(res) && res->sata_port && ioasc != IPR_IOASC_IOA_WAS_RESET)
-                memcpy(&res->sata_port->ioasa, &ipr_cmd->ioasa.u.gata,
-                       sizeof(struct ipr_ioasa_gata));
+        if (ipr_is_gata(res) && res->sata_port && ioasc != IPR_IOASC_IOA_WAS_RESET) {
+                if (ipr_cmd->ioa_cfg->sis64)
+                        memcpy(&res->sata_port->ioasa, &ipr_cmd->s.ioasa64.u.gata,
+                               sizeof(struct ipr_ioasa_gata));
+                else
+                        memcpy(&res->sata_port->ioasa, &ipr_cmd->s.ioasa.u.gata,
+                               sizeof(struct ipr_ioasa_gata));
+        }
 
         LEAVE;
         return (IPR_IOASC_SENSE_KEY(ioasc) ? -EIO : 0);
@@ -4768,7 +4774,7 @@ static int ipr_cancel_op(struct scsi_cmnd * scsi_cmd)
         scmd_printk(KERN_ERR, scsi_cmd, "Aborting command: %02X\n",
                     scsi_cmd->cmnd[0]);
         ipr_send_blocking_cmd(ipr_cmd, ipr_abort_timeout, IPR_CANCEL_ALL_TIMEOUT);
-        ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
+        ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
 
         /*
          * If the abort task timed out and we sent a bus reset, we will get
@@ -4812,15 +4818,39 @@ static int ipr_eh_abort(struct scsi_cmnd * scsi_cmd)
 /**
  * ipr_handle_other_interrupt - Handle "other" interrupts
  * @ioa_cfg:    ioa config struct
- * @int_reg:    interrupt register
  *
  * Return value:
  *      IRQ_NONE / IRQ_HANDLED
  **/
-static irqreturn_t ipr_handle_other_interrupt(struct ipr_ioa_cfg *ioa_cfg,
-                                              volatile u32 int_reg)
+static irqreturn_t ipr_handle_other_interrupt(struct ipr_ioa_cfg *ioa_cfg)
 {
         irqreturn_t rc = IRQ_HANDLED;
+        volatile u32 int_reg, int_mask_reg;
+
+        int_mask_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg32);
+        int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32) & ~int_mask_reg;
+
+        /* If an interrupt on the adapter did not occur, ignore it.
+         * Or in the case of SIS 64, check for a stage change interrupt.
+         */
+        if ((int_reg & IPR_PCII_OPER_INTERRUPTS) == 0) {
+                if (ioa_cfg->sis64) {
+                        int_mask_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
+                        int_reg = readl(ioa_cfg->regs.sense_interrupt_reg) & ~int_mask_reg;
+                        if (int_reg & IPR_PCII_IPL_STAGE_CHANGE) {
+
+                                /* clear stage change */
+                                writel(IPR_PCII_IPL_STAGE_CHANGE, ioa_cfg->regs.clr_interrupt_reg);
+                                int_reg = readl(ioa_cfg->regs.sense_interrupt_reg) & ~int_mask_reg;
+                                list_del(&ioa_cfg->reset_cmd->queue);
+                                del_timer(&ioa_cfg->reset_cmd->timer);
+                                ipr_reset_ioa_job(ioa_cfg->reset_cmd);
+                                return IRQ_HANDLED;
+                        }
+                }
+
+                return IRQ_NONE;
+        }
 
         if (int_reg & IPR_PCII_IOA_TRANS_TO_OPER) {
                 /* Mask the interrupt */
@@ -4881,7 +4911,7 @@ static irqreturn_t ipr_isr(int irq, void *devp)
 {
         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)devp;
         unsigned long lock_flags = 0;
-        volatile u32 int_reg, int_mask_reg;
+        volatile u32 int_reg;
         u32 ioasc;
         u16 cmd_index;
         int num_hrrq = 0;
@@ -4896,33 +4926,6 @@ static irqreturn_t ipr_isr(int irq, void *devp)
                 return IRQ_NONE;
         }
 
-        int_mask_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg32);
-        int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32) & ~int_mask_reg;
-
-        /* If an interrupt on the adapter did not occur, ignore it.
-         * Or in the case of SIS 64, check for a stage change interrupt.
-         */
-        if (unlikely((int_reg & IPR_PCII_OPER_INTERRUPTS) == 0)) {
-                if (ioa_cfg->sis64) {
-                        int_mask_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
-                        int_reg = readl(ioa_cfg->regs.sense_interrupt_reg) & ~int_mask_reg;
-                        if (int_reg & IPR_PCII_IPL_STAGE_CHANGE) {
-
-                                /* clear stage change */
-                                writel(IPR_PCII_IPL_STAGE_CHANGE, ioa_cfg->regs.clr_interrupt_reg);
-                                int_reg = readl(ioa_cfg->regs.sense_interrupt_reg) & ~int_mask_reg;
-                                list_del(&ioa_cfg->reset_cmd->queue);
-                                del_timer(&ioa_cfg->reset_cmd->timer);
-                                ipr_reset_ioa_job(ioa_cfg->reset_cmd);
-                                spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
-                                return IRQ_HANDLED;
-                        }
-                }
-
-                spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
-                return IRQ_NONE;
-        }
-
         while (1) {
                 ipr_cmd = NULL;
 
@@ -4940,7 +4943,7 @@ static irqreturn_t ipr_isr(int irq, void *devp)
 
                         ipr_cmd = ioa_cfg->ipr_cmnd_list[cmd_index];
 
-                        ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
+                        ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
 
                         ipr_trc_hook(ipr_cmd, IPR_TRACE_FINISH, ioasc);
 
@@ -4962,7 +4965,7 @@ static irqreturn_t ipr_isr(int irq, void *devp)
                         /* Clear the PCI interrupt */
                         do {
                                 writel(IPR_PCII_HRRQ_UPDATED, ioa_cfg->regs.clr_interrupt_reg32);
-                                int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32) & ~int_mask_reg;
+                                int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32);
                         } while (int_reg & IPR_PCII_HRRQ_UPDATED &&
                                         num_hrrq++ < IPR_MAX_HRRQ_RETRIES);
 
@@ -4977,7 +4980,7 @@ static irqreturn_t ipr_isr(int irq, void *devp)
         }
 
         if (unlikely(rc == IRQ_NONE))
-                rc = ipr_handle_other_interrupt(ioa_cfg, int_reg);
+                rc = ipr_handle_other_interrupt(ioa_cfg);
 
         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
         return rc;
@@ -5014,6 +5017,10 @@ static int ipr_build_ioadl64(struct ipr_ioa_cfg *ioa_cfg,
 
         ipr_cmd->dma_use_sg = nseg;
 
+        ioarcb->data_transfer_length = cpu_to_be32(length);
+        ioarcb->ioadl_len =
+                cpu_to_be32(sizeof(struct ipr_ioadl64_desc) * ipr_cmd->dma_use_sg);
+
         if (scsi_cmd->sc_data_direction == DMA_TO_DEVICE) {
                 ioadl_flags = IPR_IOADL_FLAGS_WRITE;
                 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
@@ -5135,7 +5142,7 @@ static void ipr_erp_done(struct ipr_cmnd *ipr_cmd)
         struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
         struct ipr_resource_entry *res = scsi_cmd->device->hostdata;
         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
-        u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
+        u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
 
         if (IPR_IOASC_SENSE_KEY(ioasc) > 0) {
                 scsi_cmd->result |= (DID_ERROR << 16);
@@ -5166,7 +5173,7 @@ static void ipr_erp_done(struct ipr_cmnd *ipr_cmd)
 static void ipr_reinit_ipr_cmnd_for_erp(struct ipr_cmnd *ipr_cmd)
 {
         struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
-        struct ipr_ioasa *ioasa = &ipr_cmd->ioasa;
+        struct ipr_ioasa *ioasa = &ipr_cmd->s.ioasa;
         dma_addr_t dma_addr = ipr_cmd->dma_addr;
 
         memset(&ioarcb->cmd_pkt, 0, sizeof(struct ipr_cmd_pkt));
@@ -5174,8 +5181,8 @@ static void ipr_reinit_ipr_cmnd_for_erp(struct ipr_cmnd *ipr_cmd)
         ioarcb->read_data_transfer_length = 0;
         ioarcb->ioadl_len = 0;
         ioarcb->read_ioadl_len = 0;
-        ioasa->ioasc = 0;
-        ioasa->residual_data_len = 0;
+        ioasa->hdr.ioasc = 0;
+        ioasa->hdr.residual_data_len = 0;
 
         if (ipr_cmd->ioa_cfg->sis64)
                 ioarcb->u.sis64_addr_data.data_ioadl_addr =
@@ -5200,7 +5207,7 @@ static void ipr_reinit_ipr_cmnd_for_erp(struct ipr_cmnd *ipr_cmd)
 static void ipr_erp_request_sense(struct ipr_cmnd *ipr_cmd)
 {
         struct ipr_cmd_pkt *cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt;
-        u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
+        u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
 
         if (IPR_IOASC_SENSE_KEY(ioasc) > 0) {
                 ipr_erp_done(ipr_cmd);
@@ -5277,12 +5284,12 @@ static void ipr_dump_ioasa(struct ipr_ioa_cfg *ioa_cfg,
         int i;
         u16 data_len;
         u32 ioasc, fd_ioasc;
-        struct ipr_ioasa *ioasa = &ipr_cmd->ioasa;
+        struct ipr_ioasa *ioasa = &ipr_cmd->s.ioasa;
         __be32 *ioasa_data = (__be32 *)ioasa;
         int error_index;
 
-        ioasc = be32_to_cpu(ioasa->ioasc) & IPR_IOASC_IOASC_MASK;
-        fd_ioasc = be32_to_cpu(ioasa->fd_ioasc) & IPR_IOASC_IOASC_MASK;
+        ioasc = be32_to_cpu(ioasa->hdr.ioasc) & IPR_IOASC_IOASC_MASK;
+        fd_ioasc = be32_to_cpu(ioasa->hdr.fd_ioasc) & IPR_IOASC_IOASC_MASK;
 
         if (0 == ioasc)
                 return;
@@ -5297,7 +5304,7 @@ static void ipr_dump_ioasa(struct ipr_ioa_cfg *ioa_cfg,
 
         if (ioa_cfg->log_level < IPR_MAX_LOG_LEVEL) {
                 /* Don't log an error if the IOA already logged one */
-                if (ioasa->ilid != 0)
+                if (ioasa->hdr.ilid != 0)
                         return;
 
                 if (!ipr_is_gscsi(res))
@@ -5309,10 +5316,11 @@ static void ipr_dump_ioasa(struct ipr_ioa_cfg *ioa_cfg,
 
         ipr_res_err(ioa_cfg, res, "%s\n", ipr_error_table[error_index].error);
 
-        if (sizeof(struct ipr_ioasa) < be16_to_cpu(ioasa->ret_stat_len))
+        data_len = be16_to_cpu(ioasa->hdr.ret_stat_len);
+        if (ioa_cfg->sis64 && sizeof(struct ipr_ioasa64) < data_len)
+                data_len = sizeof(struct ipr_ioasa64);
+        else if (!ioa_cfg->sis64 && sizeof(struct ipr_ioasa) < data_len)
                 data_len = sizeof(struct ipr_ioasa);
-        else
-                data_len = be16_to_cpu(ioasa->ret_stat_len);
 
         ipr_err("IOASA Dump:\n");
 
@@ -5338,8 +5346,8 @@ static void ipr_gen_sense(struct ipr_cmnd *ipr_cmd)
         u32 failing_lba;
         u8 *sense_buf = ipr_cmd->scsi_cmd->sense_buffer;
         struct ipr_resource_entry *res = ipr_cmd->scsi_cmd->device->hostdata;
-        struct ipr_ioasa *ioasa = &ipr_cmd->ioasa;
-        u32 ioasc = be32_to_cpu(ioasa->ioasc);
+        struct ipr_ioasa *ioasa = &ipr_cmd->s.ioasa;
+        u32 ioasc = be32_to_cpu(ioasa->hdr.ioasc);
 
         memset(sense_buf, 0, SCSI_SENSE_BUFFERSIZE);
 
@@ -5382,7 +5390,7 @@ static void ipr_gen_sense(struct ipr_cmnd *ipr_cmd)
 
                 /* Illegal request */
                 if ((IPR_IOASC_SENSE_KEY(ioasc) == 0x05) &&
-                    (be32_to_cpu(ioasa->ioasc_specific) & IPR_FIELD_POINTER_VALID)) {
+                    (be32_to_cpu(ioasa->hdr.ioasc_specific) & IPR_FIELD_POINTER_VALID)) {
                         sense_buf[7] = 10;      /* additional length */
 
                         /* IOARCB was in error */
@@ -5393,10 +5401,10 @@ static void ipr_gen_sense(struct ipr_cmnd *ipr_cmd)
 
                         sense_buf[16] =
                             ((IPR_FIELD_POINTER_MASK &
-                              be32_to_cpu(ioasa->ioasc_specific)) >> 8) & 0xff;
+                              be32_to_cpu(ioasa->hdr.ioasc_specific)) >> 8) & 0xff;
                         sense_buf[17] =
                             (IPR_FIELD_POINTER_MASK &
-                             be32_to_cpu(ioasa->ioasc_specific)) & 0xff;
+                             be32_to_cpu(ioasa->hdr.ioasc_specific)) & 0xff;
                 } else {
                         if (ioasc == IPR_IOASC_MED_DO_NOT_REALLOC) {
                                 if (ipr_is_vset_device(res))
@@ -5428,14 +5436,20 @@ static void ipr_gen_sense(struct ipr_cmnd *ipr_cmd)
  **/
 static int ipr_get_autosense(struct ipr_cmnd *ipr_cmd)
 {
-        struct ipr_ioasa *ioasa = &ipr_cmd->ioasa;
+        struct ipr_ioasa *ioasa = &ipr_cmd->s.ioasa;
+        struct ipr_ioasa64 *ioasa64 = &ipr_cmd->s.ioasa64;
 
-        if ((be32_to_cpu(ioasa->ioasc_specific) & IPR_AUTOSENSE_VALID) == 0)
+        if ((be32_to_cpu(ioasa->hdr.ioasc_specific) & IPR_AUTOSENSE_VALID) == 0)
                 return 0;
 
-        memcpy(ipr_cmd->scsi_cmd->sense_buffer, ioasa->auto_sense.data,
-               min_t(u16, be16_to_cpu(ioasa->auto_sense.auto_sense_len),
-                   SCSI_SENSE_BUFFERSIZE));
+        if (ipr_cmd->ioa_cfg->sis64)
+                memcpy(ipr_cmd->scsi_cmd->sense_buffer, ioasa64->auto_sense.data,
+                       min_t(u16, be16_to_cpu(ioasa64->auto_sense.auto_sense_len),
+                           SCSI_SENSE_BUFFERSIZE));
+        else
+                memcpy(ipr_cmd->scsi_cmd->sense_buffer, ioasa->auto_sense.data,
+                       min_t(u16, be16_to_cpu(ioasa->auto_sense.auto_sense_len),
+                           SCSI_SENSE_BUFFERSIZE));
         return 1;
 }
 
@@ -5455,7 +5469,7 @@ static void ipr_erp_start(struct ipr_ioa_cfg *ioa_cfg,
 {
         struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
         struct ipr_resource_entry *res = scsi_cmd->device->hostdata;
-        u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
+        u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
         u32 masked_ioasc = ioasc & IPR_IOASC_IOASC_MASK;
 
         if (!res) {
@@ -5547,9 +5561,9 @@ static void ipr_scsi_done(struct ipr_cmnd *ipr_cmd)
 {
         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
         struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
-        u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
+        u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
 
-        scsi_set_resid(scsi_cmd, be32_to_cpu(ipr_cmd->ioasa.residual_data_len));
+        scsi_set_resid(scsi_cmd, be32_to_cpu(ipr_cmd->s.ioasa.hdr.residual_data_len));
 
         if (likely(IPR_IOASC_SENSE_KEY(ioasc) == 0)) {
                 scsi_dma_unmap(ipr_cmd->scsi_cmd);
@@ -5839,19 +5853,23 @@ static void ipr_sata_done(struct ipr_cmnd *ipr_cmd)
         struct ata_queued_cmd *qc = ipr_cmd->qc;
         struct ipr_sata_port *sata_port = qc->ap->private_data;
         struct ipr_resource_entry *res = sata_port->res;
-        u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
+        u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
 
-        memcpy(&sata_port->ioasa, &ipr_cmd->ioasa.u.gata,
-               sizeof(struct ipr_ioasa_gata));
+        if (ipr_cmd->ioa_cfg->sis64)
+                memcpy(&sata_port->ioasa, &ipr_cmd->s.ioasa64.u.gata,
+                       sizeof(struct ipr_ioasa_gata));
+        else
+                memcpy(&sata_port->ioasa, &ipr_cmd->s.ioasa.u.gata,
+                       sizeof(struct ipr_ioasa_gata));
         ipr_dump_ioasa(ioa_cfg, ipr_cmd, res);
 
-        if (be32_to_cpu(ipr_cmd->ioasa.ioasc_specific) & IPR_ATA_DEVICE_WAS_RESET)
+        if (be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc_specific) & IPR_ATA_DEVICE_WAS_RESET)
                 scsi_report_device_reset(ioa_cfg->host, res->bus, res->target);
 
         if (IPR_IOASC_SENSE_KEY(ioasc) > RECOVERED_ERROR)
-                qc->err_mask |= __ac_err_mask(ipr_cmd->ioasa.u.gata.status);
+                qc->err_mask |= __ac_err_mask(sata_port->ioasa.status);
         else
-                qc->err_mask |= ac_err_mask(ipr_cmd->ioasa.u.gata.status);
+                qc->err_mask |= ac_err_mask(sata_port->ioasa.status);
         list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
         ata_qc_complete(qc);
 }
@@ -6520,7 +6538,7 @@ static void ipr_build_mode_sense(struct ipr_cmnd *ipr_cmd,
 static int ipr_reset_cmd_failed(struct ipr_cmnd *ipr_cmd)
 {
         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
-        u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
+        u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
 
         dev_err(&ioa_cfg->pdev->dev,
                 "0x%02X failed with IOASC: 0x%08X\n",
@@ -6544,7 +6562,7 @@ static int ipr_reset_cmd_failed(struct ipr_cmnd *ipr_cmd)
 static int ipr_reset_mode_sense_failed(struct ipr_cmnd *ipr_cmd)
 {
         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
-        u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
+        u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
 
         if (ioasc == IPR_IOASC_IR_INVALID_REQ_TYPE_OR_PKT) {
                 ipr_cmd->job_step = ipr_set_supported_devs;
@@ -6634,7 +6652,7 @@ static int ipr_ioafp_mode_select_page24(struct ipr_cmnd *ipr_cmd)
  **/
 static int ipr_reset_mode_sense_page24_failed(struct ipr_cmnd *ipr_cmd)
 {
-        u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
+        u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
 
         if (ioasc == IPR_IOASC_IR_INVALID_REQ_TYPE_OR_PKT) {
                 ipr_cmd->job_step = ipr_ioafp_mode_sense_page28;
@@ -6706,7 +6724,7 @@ static int ipr_init_res_table(struct ipr_cmnd *ipr_cmd)
                 list_move_tail(&res->queue, &old_res);
 
         if (ioa_cfg->sis64)
-                entries = ioa_cfg->u.cfg_table64->hdr64.num_entries;
+                entries = be16_to_cpu(ioa_cfg->u.cfg_table64->hdr64.num_entries);
         else
                 entries = ioa_cfg->u.cfg_table->hdr.num_entries;
 
@@ -6792,6 +6810,7 @@ static int ipr_ioafp_query_ioa_cfg(struct ipr_cmnd *ipr_cmd)
         ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
 
         ioarcb->cmd_pkt.cdb[0] = IPR_QUERY_IOA_CONFIG;
+        ioarcb->cmd_pkt.cdb[6] = (ioa_cfg->cfg_table_size >> 16) & 0xff;
         ioarcb->cmd_pkt.cdb[7] = (ioa_cfg->cfg_table_size >> 8) & 0xff;
         ioarcb->cmd_pkt.cdb[8] = ioa_cfg->cfg_table_size & 0xff;
 
@@ -7122,7 +7141,9 @@ static int ipr_reset_next_stage(struct ipr_cmnd *ipr_cmd)
         ipr_dbg("IPL stage = 0x%lx, IPL stage time = %ld\n", stage, stage_time);
 
         /* sanity check the stage_time value */
-        if (stage_time < IPR_IPL_INIT_MIN_STAGE_TIME)
+        if (stage_time == 0)
+                stage_time = IPR_IPL_INIT_DEFAULT_STAGE_TIME;
+        else if (stage_time < IPR_IPL_INIT_MIN_STAGE_TIME)
                 stage_time = IPR_IPL_INIT_MIN_STAGE_TIME;
         else if (stage_time > IPR_LONG_OPERATIONAL_TIMEOUT)
                 stage_time = IPR_LONG_OPERATIONAL_TIMEOUT;
@@ -7165,13 +7186,14 @@ static int ipr_reset_enable_ioa(struct ipr_cmnd *ipr_cmd)
 {
         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
         volatile u32 int_reg;
+        volatile u64 maskval;
 
         ENTER;
         ipr_cmd->job_step = ipr_ioafp_identify_hrrq;
         ipr_init_ioa_mem(ioa_cfg);
 
         ioa_cfg->allow_interrupts = 1;
-        int_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
+        int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32);
 
         if (int_reg & IPR_PCII_IOA_TRANS_TO_OPER) {
                 writel((IPR_PCII_ERROR_INTERRUPTS | IPR_PCII_HRRQ_UPDATED),
@@ -7183,9 +7205,12 @@ static int ipr_reset_enable_ioa(struct ipr_cmnd *ipr_cmd)
         /* Enable destructive diagnostics on IOA */
         writel(ioa_cfg->doorbell, ioa_cfg->regs.set_uproc_interrupt_reg32);
 
-        writel(IPR_PCII_OPER_INTERRUPTS, ioa_cfg->regs.clr_interrupt_mask_reg32);
-        if (ioa_cfg->sis64)
-                writel(IPR_PCII_IPL_STAGE_CHANGE, ioa_cfg->regs.clr_interrupt_mask_reg);
+        if (ioa_cfg->sis64) {
+                maskval = IPR_PCII_IPL_STAGE_CHANGE;
+                maskval = (maskval << 32) | IPR_PCII_OPER_INTERRUPTS;
+                writeq(maskval, ioa_cfg->regs.clr_interrupt_mask_reg);
+        } else
+                writel(IPR_PCII_OPER_INTERRUPTS, ioa_cfg->regs.clr_interrupt_mask_reg32);
 
         int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
 
@@ -7332,12 +7357,12 @@ static int ipr_reset_restore_cfg_space(struct ipr_cmnd *ipr_cmd)
         rc = pci_restore_state(ioa_cfg->pdev);
 
         if (rc != PCIBIOS_SUCCESSFUL) {
-                ipr_cmd->ioasa.ioasc = cpu_to_be32(IPR_IOASC_PCI_ACCESS_ERROR);
+                ipr_cmd->s.ioasa.hdr.ioasc = cpu_to_be32(IPR_IOASC_PCI_ACCESS_ERROR);
                 return IPR_RC_JOB_CONTINUE;
         }
 
         if (ipr_set_pcix_cmd_reg(ioa_cfg)) {
-                ipr_cmd->ioasa.ioasc = cpu_to_be32(IPR_IOASC_PCI_ACCESS_ERROR);
+                ipr_cmd->s.ioasa.hdr.ioasc = cpu_to_be32(IPR_IOASC_PCI_ACCESS_ERROR);
                 return IPR_RC_JOB_CONTINUE;
         }
 
@@ -7364,7 +7389,7 @@ static int ipr_reset_restore_cfg_space(struct ipr_cmnd *ipr_cmd)
                 }
         }
 
-        ENTER;
+        LEAVE;
         return IPR_RC_JOB_CONTINUE;
 }
 
@@ -7406,7 +7431,7 @@ static int ipr_reset_start_bist(struct ipr_cmnd *ipr_cmd)
 
         if (rc != PCIBIOS_SUCCESSFUL) {
                 pci_unblock_user_cfg_access(ipr_cmd->ioa_cfg->pdev);
-                ipr_cmd->ioasa.ioasc = cpu_to_be32(IPR_IOASC_PCI_ACCESS_ERROR);
+                ipr_cmd->s.ioasa.hdr.ioasc = cpu_to_be32(IPR_IOASC_PCI_ACCESS_ERROR);
                 rc = IPR_RC_JOB_CONTINUE;
         } else {
                 ipr_cmd->job_step = ipr_reset_bist_done;
@@ -7665,7 +7690,7 @@ static void ipr_reset_ioa_job(struct ipr_cmnd *ipr_cmd)
         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
 
         do {
-                ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
+                ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
 
                 if (ioa_cfg->reset_cmd != ipr_cmd) {
                         /*
@@ -8048,13 +8073,13 @@ static int __devinit ipr_alloc_cmd_blks(struct ipr_ioa_cfg *ioa_cfg)
                         ioarcb->u.sis64_addr_data.data_ioadl_addr =
                                 cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, i.ioadl64));
                         ioarcb->u.sis64_addr_data.ioasa_host_pci_addr =
-                                cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, ioasa));
+                                cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, s.ioasa64));
                 } else {
                         ioarcb->write_ioadl_addr =
                                 cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, i.ioadl));
                         ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr;
                         ioarcb->ioasa_host_pci_addr =
-                                cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, ioasa));
+                                cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, s.ioasa));
                 }
                 ioarcb->ioasa_len = cpu_to_be16(sizeof(struct ipr_ioasa));
                 ipr_cmd->cmd_index = i;
diff --git a/drivers/scsi/ipr.h b/drivers/scsi/ipr.h
index 4c267b5e0b96..9ecd2259eb39 100644
--- a/drivers/scsi/ipr.h
+++ b/drivers/scsi/ipr.h
@@ -244,6 +244,7 @@
 #define IPR_RUNTIME_RESET                               0x40000000
 
 #define IPR_IPL_INIT_MIN_STAGE_TIME                     5
+#define IPR_IPL_INIT_DEFAULT_STAGE_TIME                 15
 #define IPR_IPL_INIT_STAGE_UNKNOWN                      0x0
 #define IPR_IPL_INIT_STAGE_TRANSOP                      0xB0000000
 #define IPR_IPL_INIT_STAGE_MASK                         0xff000000
@@ -613,7 +614,7 @@ struct ipr_auto_sense {
         __be32 data[SCSI_SENSE_BUFFERSIZE/sizeof(__be32)];
 };
 
-struct ipr_ioasa {
+struct ipr_ioasa_hdr {
         __be32 ioasc;
 #define IPR_IOASC_SENSE_KEY(ioasc) ((ioasc) >> 24)
 #define IPR_IOASC_SENSE_CODE(ioasc) (((ioasc) & 0x00ff0000) >> 16)
@@ -645,6 +646,25 @@ struct ipr_ioasa {
 #define IPR_FIELD_POINTER_VALID         (0x80000000 >> 8)
 #define IPR_FIELD_POINTER_MASK          0x0000ffff
 
+}__attribute__((packed, aligned (4)));
+
+struct ipr_ioasa {
+        struct ipr_ioasa_hdr hdr;
+
+        union {
+                struct ipr_ioasa_vset vset;
+                struct ipr_ioasa_af_dasd dasd;
+                struct ipr_ioasa_gpdd gpdd;
+                struct ipr_ioasa_gata gata;
+        } u;
+
+        struct ipr_auto_sense auto_sense;
+}__attribute__((packed, aligned (4)));
+
+struct ipr_ioasa64 {
+        struct ipr_ioasa_hdr hdr;
+        u8 fd_res_path[8];
+
         union {
                 struct ipr_ioasa_vset vset;
                 struct ipr_ioasa_af_dasd dasd;
@@ -804,7 +824,7 @@ struct ipr_hostrcb_array_data_entry_enhanced {
 }__attribute__((packed, aligned (4)));
 
 struct ipr_hostrcb_type_ff_error {
-        __be32 ioa_data[502];
+        __be32 ioa_data[758];
 }__attribute__((packed, aligned (4)));
 
 struct ipr_hostrcb_type_01_error {
@@ -1181,7 +1201,7 @@ struct ipr_resource_entry {
         u8 flags;
         __be16 res_flags;
 
-        __be32 type;
+        u8 type;
 
         u8 qmodel;
         struct ipr_std_inq_data std_inq_data;
@@ -1464,7 +1484,10 @@ struct ipr_cmnd {
                 struct ipr_ioadl64_desc ioadl64[IPR_NUM_IOADL_ENTRIES];
                 struct ipr_ata64_ioadl ata_ioadl;
         } i;
-        struct ipr_ioasa ioasa;
+        union {
+                struct ipr_ioasa ioasa;
+                struct ipr_ioasa64 ioasa64;
+        } s;
         struct list_head queue;
         struct scsi_cmnd *scsi_cmd;
         struct ata_queued_cmd *qc;
diff --git a/drivers/scsi/iscsi_tcp.c b/drivers/scsi/iscsi_tcp.c
index bf55d3057413..fec47de72535 100644
--- a/drivers/scsi/iscsi_tcp.c
+++ b/drivers/scsi/iscsi_tcp.c
@@ -601,10 +601,8 @@ static void iscsi_sw_tcp_conn_stop(struct iscsi_cls_conn *cls_conn, int flag)
         set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx);
         write_unlock_bh(&tcp_sw_conn->sock->sk->sk_callback_lock);
 
-        if (sk_sleep(sock->sk)) {
-                sock->sk->sk_err = EIO;
-                wake_up_interruptible(sk_sleep(sock->sk));
-        }
+        sock->sk->sk_err = EIO;
+        wake_up_interruptible(sk_sleep(sock->sk));
 
         iscsi_conn_stop(cls_conn, flag);
         iscsi_sw_tcp_release_conn(conn);
diff --git a/drivers/scsi/mvme147.c b/drivers/scsi/mvme147.c
index 716d1785cda7..c29d0dbb9660 100644
--- a/drivers/scsi/mvme147.c
+++ b/drivers/scsi/mvme147.c
@@ -16,12 +16,12 @@
 #include <linux/stat.h>
 
 
-static struct Scsi_Host *mvme147_host = NULL;
-
-static irqreturn_t mvme147_intr(int irq, void *dummy)
+static irqreturn_t mvme147_intr(int irq, void *data)
 {
+        struct Scsi_Host *instance = data;
+
         if (irq == MVME147_IRQ_SCSI_PORT)
-                wd33c93_intr(mvme147_host);
+                wd33c93_intr(instance);
         else
                 m147_pcc->dma_intr = 0x89;      /* Ack and enable ints */
         return IRQ_HANDLED;
@@ -29,7 +29,8 @@ static irqreturn_t mvme147_intr(int irq, void *dummy)
 
 static int dma_setup(struct scsi_cmnd *cmd, int dir_in)
 {
-        struct WD33C93_hostdata *hdata = shost_priv(mvme147_host);
+        struct Scsi_Host *instance = cmd->device->host;
+        struct WD33C93_hostdata *hdata = shost_priv(instance);
         unsigned char flags = 0x01;
         unsigned long addr = virt_to_bus(cmd->SCp.ptr);
 
@@ -66,6 +67,7 @@ static void dma_stop(struct Scsi_Host *instance, struct scsi_cmnd *SCpnt,
 int mvme147_detect(struct scsi_host_template *tpnt)
 {
         static unsigned char called = 0;
+        struct Scsi_Host *instance;
         wd33c93_regs regs;
         struct WD33C93_hostdata *hdata;
 
@@ -76,25 +78,25 @@ int mvme147_detect(struct scsi_host_template *tpnt)
         tpnt->proc_name = "MVME147";
         tpnt->proc_info = &wd33c93_proc_info;
 
-        mvme147_host = scsi_register(tpnt, sizeof(struct WD33C93_hostdata));
-        if (!mvme147_host)
+        instance = scsi_register(tpnt, sizeof(struct WD33C93_hostdata));
+        if (!instance)
                 goto err_out;
 
-        mvme147_host->base = 0xfffe4000;
-        mvme147_host->irq = MVME147_IRQ_SCSI_PORT;
+        instance->base = 0xfffe4000;
+        instance->irq = MVME147_IRQ_SCSI_PORT;
         regs.SASR = (volatile unsigned char *)0xfffe4000;
         regs.SCMD = (volatile unsigned char *)0xfffe4001;
-        hdata = shost_priv(mvme147_host);
+        hdata = shost_priv(instance);
         hdata->no_sync = 0xff;
         hdata->fast = 0;
         hdata->dma_mode = CTRL_DMA;
-        wd33c93_init(mvme147_host, regs, dma_setup, dma_stop, WD33C93_FS_8_10);
+        wd33c93_init(instance, regs, dma_setup, dma_stop, WD33C93_FS_8_10);
 
         if (request_irq(MVME147_IRQ_SCSI_PORT, mvme147_intr, 0,
-                        "MVME147 SCSI PORT", mvme147_intr))
+                        "MVME147 SCSI PORT", instance))
                 goto err_unregister;
         if (request_irq(MVME147_IRQ_SCSI_DMA, mvme147_intr, 0,
-                        "MVME147 SCSI DMA", mvme147_intr))
+                        "MVME147 SCSI DMA", instance))
                 goto err_free_irq;
 #if 0   /* Disabled; causes problems booting */
         m147_pcc->scsi_interrupt = 0x10;        /* Assert SCSI bus reset */
@@ -113,7 +115,7 @@ int mvme147_detect(struct scsi_host_template *tpnt)
 err_free_irq:
         free_irq(MVME147_IRQ_SCSI_PORT, mvme147_intr);
 err_unregister:
-        scsi_unregister(mvme147_host);
+        scsi_unregister(instance);
 err_out:
         return 0;
 }
@@ -132,9 +134,6 @@ static int mvme147_bus_reset(struct scsi_cmnd *cmd)
         return SUCCESS;
 }
 
-#define HOSTS_C
-
-#include "mvme147.h"
 
 static struct scsi_host_template driver_template = {
         .proc_name              = "MVME147",
diff --git a/drivers/scsi/osst.c b/drivers/scsi/osst.c
index 8dbf1c3afb7b..d64b7178fa08 100644
--- a/drivers/scsi/osst.c
+++ b/drivers/scsi/osst.c
@@ -3587,7 +3587,7 @@ if (SRpnt) printk(KERN_ERR "%s:A: Not supposed to have SRpnt at line %d\n", name
                 if (i == (-ENOSPC)) {
                         transfer = STp->buffer->writing;        /* FIXME -- check this logic */
                         if (transfer <= do_count) {
-                                filp->f_pos += do_count - transfer;
+                                *ppos += do_count - transfer;
                                 count -= do_count - transfer;
                                 if (STps->drv_block >= 0) {
                                         STps->drv_block += (do_count - transfer) / STp->block_size;
@@ -3625,7 +3625,7 @@ if (SRpnt) printk(KERN_ERR "%s:A: Not supposed to have SRpnt at line %d\n", name
                         goto out;
                 }
 
-                filp->f_pos += do_count;
+                *ppos += do_count;
                 b_point += do_count;
                 count -= do_count;
                 if (STps->drv_block >= 0) {
@@ -3647,7 +3647,7 @@ if (SRpnt) printk(KERN_ERR "%s:A: Not supposed to have SRpnt at line %d\n", name
                 if (STps->drv_block >= 0) {
                         STps->drv_block += blks;
                 }
-                filp->f_pos += count;
+                *ppos += count;
                 count = 0;
         }
 
@@ -3823,7 +3823,7 @@ static ssize_t osst_read(struct file * filp, char __user * buf, size_t count, lo
                         }
                         STp->logical_blk_num += transfer / STp->block_size;
                         STps->drv_block      += transfer / STp->block_size;
-                        filp->f_pos          += transfer;
+                        *ppos          += transfer;
                         buf                  += transfer;
                         total                += transfer;
                 }
@@ -5626,6 +5626,7 @@ static const struct file_operations osst_fops = {
         .open =         os_scsi_tape_open,
         .flush =        os_scsi_tape_flush,
         .release =      os_scsi_tape_close,
+        .llseek =       noop_llseek,
 };
 
 static int osst_supports(struct scsi_device * SDp)
diff --git a/drivers/scsi/scsi_scan.c b/drivers/scsi/scsi_scan.c
index 9798c2c06b93..1c027a97d8b9 100644
--- a/drivers/scsi/scsi_scan.c
+++ b/drivers/scsi/scsi_scan.c
@@ -492,19 +492,20 @@ void scsi_target_reap(struct scsi_target *starget)
         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
         unsigned long flags;
         enum scsi_target_state state;
-        int empty;
+        int empty = 0;
 
         spin_lock_irqsave(shost->host_lock, flags);
         state = starget->state;
-        empty = --starget->reap_ref == 0 &&
-                list_empty(&starget->devices) ? 1 : 0;
+        if (--starget->reap_ref == 0 && list_empty(&starget->devices)) {
+                empty = 1;
+                starget->state = STARGET_DEL;
+        }
         spin_unlock_irqrestore(shost->host_lock, flags);
 
         if (!empty)
                 return;
 
         BUG_ON(state == STARGET_DEL);
-        starget->state = STARGET_DEL;
         if (state == STARGET_CREATED)
                 scsi_target_destroy(starget);
         else
diff --git a/drivers/scsi/st.c b/drivers/scsi/st.c
index 3ea1a713ef25..24211d0efa6d 100644
--- a/drivers/scsi/st.c
+++ b/drivers/scsi/st.c
@@ -3962,6 +3962,7 @@ static const struct file_operations st_fops =
         .open =         st_open,
         .flush =        st_flush,
         .release =      st_release,
+        .llseek =       noop_llseek,
 };
 
 static int st_probe(struct device *dev)
diff --git a/drivers/serial/s5pv210.c b/drivers/serial/s5pv210.c
index 8dc03837617b..4a789e5361a4 100644
--- a/drivers/serial/s5pv210.c
+++ b/drivers/serial/s5pv210.c
@@ -119,7 +119,7 @@ static int s5p_serial_probe(struct platform_device *pdev)
         return s3c24xx_serial_probe(pdev, s5p_uart_inf[pdev->id]);
 }
 
-static struct platform_driver s5p_serial_drv = {
+static struct platform_driver s5p_serial_driver = {
         .probe          = s5p_serial_probe,
         .remove         = __devexit_p(s3c24xx_serial_remove),
         .driver         = {
@@ -130,19 +130,19 @@ static struct platform_driver s5p_serial_drv = {
 
 static int __init s5pv210_serial_console_init(void)
 {
-        return s3c24xx_serial_initconsole(&s5p_serial_drv, s5p_uart_inf);
+        return s3c24xx_serial_initconsole(&s5p_serial_driver, s5p_uart_inf);
 }
 
 console_initcall(s5pv210_serial_console_init);
 
 static int __init s5p_serial_init(void)
 {
-        return s3c24xx_serial_init(&s5p_serial_drv, *s5p_uart_inf);
+        return s3c24xx_serial_init(&s5p_serial_driver, *s5p_uart_inf);
 }
 
 static void __exit s5p_serial_exit(void)
 {
-        platform_driver_unregister(&s5p_serial_drv);
+        platform_driver_unregister(&s5p_serial_driver);
 }
 
 module_init(s5p_serial_init);
diff --git a/drivers/sfi/sfi_acpi.c b/drivers/sfi/sfi_acpi.c
index 34aba30eb84b..f5b4ca581541 100644
--- a/drivers/sfi/sfi_acpi.c
+++ b/drivers/sfi/sfi_acpi.c
@@ -173,3 +173,44 @@ int sfi_acpi_table_parse(char *signature, char *oem_id, char *oem_table_id,
         sfi_acpi_put_table(table);
         return ret;
 }
+
+static ssize_t sfi_acpi_table_show(struct file *filp, struct kobject *kobj,
+                               struct bin_attribute *bin_attr, char *buf,
+                               loff_t offset, size_t count)
+{
+        struct sfi_table_attr *tbl_attr =
+            container_of(bin_attr, struct sfi_table_attr, attr);
+        struct acpi_table_header *th = NULL;
+        struct sfi_table_key key;
+        ssize_t cnt;
+
+        key.sig = tbl_attr->name;
+        key.oem_id = NULL;
+        key.oem_table_id = NULL;
+
+        th = sfi_acpi_get_table(&key);
+        if (!th)
+                return 0;
+
+        cnt =  memory_read_from_buffer(buf, count, &offset,
+                                        th, th->length);
+        sfi_acpi_put_table(th);
+
+        return cnt;
+}
+
+
+void __init sfi_acpi_sysfs_init(void)
+{
+        u32 tbl_cnt, i;
+        struct sfi_table_attr *tbl_attr;
+
+        tbl_cnt = XSDT_GET_NUM_ENTRIES(xsdt_va, u64);
+        for (i = 0; i < tbl_cnt; i++) {
+                tbl_attr =
+                        sfi_sysfs_install_table(xsdt_va->table_offset_entry[i]);
+                tbl_attr->attr.read = sfi_acpi_table_show;
+        }
+
+        return;
+}
diff --git a/drivers/sfi/sfi_core.c b/drivers/sfi/sfi_core.c
index b204a0929139..005195958647 100644
--- a/drivers/sfi/sfi_core.c
+++ b/drivers/sfi/sfi_core.c
@@ -67,6 +67,7 @@
 #include <linux/acpi.h>
 #include <linux/init.h>
 #include <linux/sfi.h>
+#include <linux/slab.h>
 
 #include "sfi_core.h"
 
@@ -382,6 +383,102 @@ static __init int sfi_find_syst(void)
         return -1;
 }
 
+static struct kobject *sfi_kobj;
+static struct kobject *tables_kobj;
+
+static ssize_t sfi_table_show(struct file *filp, struct kobject *kobj,
+                               struct bin_attribute *bin_attr, char *buf,
+                               loff_t offset, size_t count)
+{
+        struct sfi_table_attr *tbl_attr =
+            container_of(bin_attr, struct sfi_table_attr, attr);
+        struct sfi_table_header *th = NULL;
+        struct sfi_table_key key;
+        ssize_t cnt;
+
+        key.sig = tbl_attr->name;
+        key.oem_id = NULL;
+        key.oem_table_id = NULL;
+
+        if (strncmp(SFI_SIG_SYST, tbl_attr->name, SFI_SIGNATURE_SIZE)) {
+                th = sfi_get_table(&key);
+                if (!th)
+                        return 0;
+
+                cnt =  memory_read_from_buffer(buf, count, &offset,
+                                                th, th->len);
+                sfi_put_table(th);
+        } else
+                cnt =  memory_read_from_buffer(buf, count, &offset,
+                                        syst_va, syst_va->header.len);
+
+        return cnt;
+}
+
+struct sfi_table_attr __init *sfi_sysfs_install_table(u64 pa)
+{
+        struct sfi_table_attr *tbl_attr;
+        struct sfi_table_header *th;
+        int ret;
+
+        tbl_attr = kzalloc(sizeof(struct sfi_table_attr), GFP_KERNEL);
+        if (!tbl_attr)
+                return NULL;
+
+        th = sfi_map_table(pa);
+        if (!th || !th->sig[0]) {
+                kfree(tbl_attr);
+                return NULL;
+        }
+
+        sysfs_attr_init(&tbl_attr->attr.attr);
+        memcpy(tbl_attr->name, th->sig, SFI_SIGNATURE_SIZE);
+
+        tbl_attr->attr.size = 0;
+        tbl_attr->attr.read = sfi_table_show;
+        tbl_attr->attr.attr.name = tbl_attr->name;
+        tbl_attr->attr.attr.mode = 0400;
+
+        ret = sysfs_create_bin_file(tables_kobj,
+                                  &tbl_attr->attr);
+        if (ret)
+                kfree(tbl_attr);
+
+        sfi_unmap_table(th);
+        return tbl_attr;
+}
+
+static int __init sfi_sysfs_init(void)
+{
+        int tbl_cnt, i;
+
+        if (sfi_disabled)
+                return 0;
+
+        sfi_kobj = kobject_create_and_add("sfi", firmware_kobj);
+        if (!sfi_kobj)
+                return 0;
+
+        tables_kobj = kobject_create_and_add("tables", sfi_kobj);
+        if (!tables_kobj) {
+                kobject_put(sfi_kobj);
+                return 0;
+        }
+
+        sfi_sysfs_install_table(syst_pa);
+
+        tbl_cnt = SFI_GET_NUM_ENTRIES(syst_va, u64);
+
+        for (i = 0; i < tbl_cnt; i++)
+                sfi_sysfs_install_table(syst_va->pentry[i]);
+
+        sfi_acpi_sysfs_init();
+        kobject_uevent(sfi_kobj, KOBJ_ADD);
+        kobject_uevent(tables_kobj, KOBJ_ADD);
+        pr_info("SFI sysfs interfaces init success\n");
+        return 0;
+}
+
 void __init sfi_init(void)
 {
         if (!acpi_disabled)
@@ -390,7 +487,7 @@ void __init sfi_init(void)
         if (sfi_disabled)
                 return;
 
-        pr_info("Simple Firmware Interface v0.7 http://simplefirmware.org\n");
+        pr_info("Simple Firmware Interface v0.81 http://simplefirmware.org\n");
 
         if (sfi_find_syst() || sfi_parse_syst() || sfi_platform_init())
                 disable_sfi();
@@ -414,3 +511,9 @@ void __init sfi_init_late(void)
 
         sfi_acpi_init();
 }
+
+/*
+ * The reason we put it here becasue we need wait till the /sys/firmware
+ * is setup, then our interface can be registered in /sys/firmware/sfi
+ */
+core_initcall(sfi_sysfs_init);
diff --git a/drivers/sfi/sfi_core.h b/drivers/sfi/sfi_core.h
index da82d39e104d..b7cf220d44ec 100644
--- a/drivers/sfi/sfi_core.h
+++ b/drivers/sfi/sfi_core.h
@@ -61,6 +61,12 @@ struct sfi_table_key{
         char    *oem_table_id;
 };
 
+/* sysfs interface */
+struct sfi_table_attr {
+        struct bin_attribute attr;
+        char name[8];
+};
+
 #define SFI_ANY_KEY { .sig = NULL, .oem_id = NULL, .oem_table_id = NULL }
 
 extern int __init sfi_acpi_init(void);
@@ -68,3 +74,5 @@ extern  struct sfi_table_header *sfi_check_table(u64 paddr,
                                         struct sfi_table_key *key);
 struct sfi_table_header *sfi_get_table(struct sfi_table_key *key);
 extern void sfi_put_table(struct sfi_table_header *table);
+extern struct sfi_table_attr __init *sfi_sysfs_install_table(u64 pa);
+extern void __init sfi_acpi_sysfs_init(void);
diff --git a/drivers/staging/go7007/saa7134-go7007.c b/drivers/staging/go7007/saa7134-go7007.c
index 49f0d31c118a..cf7c34a99459 100644
--- a/drivers/staging/go7007/saa7134-go7007.c
+++ b/drivers/staging/go7007/saa7134-go7007.c
@@ -242,13 +242,13 @@ static void saa7134_go7007_irq_ts_done(struct saa7134_dev *dev,
                 printk(KERN_DEBUG "saa7134-go7007: irq: lost %ld\n",
                                 (status >> 16) & 0x0f);
         if (status & 0x100000) {
-                dma_sync_single(&dev->pci->dev,
-                                saa->bottom_dma, PAGE_SIZE, DMA_FROM_DEVICE);
+                dma_sync_single_for_cpu(&dev->pci->dev,
+                                        saa->bottom_dma, PAGE_SIZE, DMA_FROM_DEVICE);
                 go7007_parse_video_stream(go, saa->bottom, PAGE_SIZE);
                 saa_writel(SAA7134_RS_BA2(5), cpu_to_le32(saa->bottom_dma));
         } else {
-                dma_sync_single(&dev->pci->dev,
-                                saa->top_dma, PAGE_SIZE, DMA_FROM_DEVICE);
+                dma_sync_single_for_cpu(&dev->pci->dev,
+                                        saa->top_dma, PAGE_SIZE, DMA_FROM_DEVICE);
                 go7007_parse_video_stream(go, saa->top, PAGE_SIZE);
                 saa_writel(SAA7134_RS_BA1(5), cpu_to_le32(saa->top_dma));
         }
diff --git a/drivers/staging/pohmelfs/inode.c b/drivers/staging/pohmelfs/inode.c
index 9286e863b0e7..643b413d9f0f 100644
--- a/drivers/staging/pohmelfs/inode.c
+++ b/drivers/staging/pohmelfs/inode.c
@@ -29,7 +29,6 @@
 #include <linux/slab.h>
 #include <linux/statfs.h>
 #include <linux/writeback.h>
-#include <linux/quotaops.h>
 
 #include "netfs.h"
 
@@ -880,7 +879,7 @@ static struct inode *pohmelfs_alloc_inode(struct super_block *sb)
 /*
  * We want fsync() to work on POHMELFS.
  */
-static int pohmelfs_fsync(struct file *file, struct dentry *dentry, int datasync)
+static int pohmelfs_fsync(struct file *file, int datasync)
 {
         struct inode *inode = file->f_mapping->host;
         struct writeback_control wbc = {
@@ -969,13 +968,6 @@ int pohmelfs_setattr_raw(struct inode *inode, struct iattr *attr)
                 goto err_out_exit;
         }
 
-        if ((attr->ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) ||
-            (attr->ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid)) {
-                err = dquot_transfer(inode, attr);
-                if (err)
-                        goto err_out_exit;
-        }
-
         err = inode_setattr(inode, attr);
         if (err) {
                 dprintk("%s: ino: %llu, failed to set the attributes.\n", __func__, POHMELFS_I(inode)->ino);
diff --git a/drivers/telephony/ixj.c b/drivers/telephony/ixj.c
index e89304c72568..b53deee25d74 100644
--- a/drivers/telephony/ixj.c
+++ b/drivers/telephony/ixj.c
@@ -5879,20 +5879,13 @@ out:
 static int ixj_build_filter_cadence(IXJ *j, IXJ_FILTER_CADENCE __user * cp)
 {
         IXJ_FILTER_CADENCE *lcp;
-        lcp = kmalloc(sizeof(IXJ_FILTER_CADENCE), GFP_KERNEL);
-        if (lcp == NULL) {
+        lcp = memdup_user(cp, sizeof(IXJ_FILTER_CADENCE));
+        if (IS_ERR(lcp)) {
                 if(ixjdebug & 0x0001) {
-                        printk(KERN_INFO "Could not allocate memory for cadence\n");
+                        printk(KERN_INFO "Could not allocate memory for cadence or could not copy cadence to kernel\n");
                 }
-                return -ENOMEM;
+                return PTR_ERR(lcp);
         }
-        if (copy_from_user(lcp, cp, sizeof(IXJ_FILTER_CADENCE))) {
-                if(ixjdebug & 0x0001) {
-                        printk(KERN_INFO "Could not copy cadence to kernel\n");
-                }
-                kfree(lcp);
-                return -EFAULT;
-        }
         if (lcp->filter > 5) {
                 if(ixjdebug & 0x0001) {
                         printk(KERN_INFO "Cadence out of range\n");
diff --git a/drivers/usb/gadget/printer.c b/drivers/usb/gadget/printer.c
index 6b8bf8c781c4..43abf55d8c60 100644
--- a/drivers/usb/gadget/printer.c
+++ b/drivers/usb/gadget/printer.c
@@ -794,7 +794,7 @@ printer_write(struct file *fd, const char __user *buf, size_t len, loff_t *ptr)
 }
 
 static int
-printer_fsync(struct file *fd, struct dentry *dentry, int datasync)
+printer_fsync(struct file *fd, int datasync)
 {
         struct printer_dev      *dev = fd->private_data;
         unsigned long           flags;
diff --git a/drivers/vhost/net.c b/drivers/vhost/net.c
index aa88911c9504..0f41c9195e9b 100644
--- a/drivers/vhost/net.c
+++ b/drivers/vhost/net.c
@@ -593,17 +593,17 @@ static long vhost_net_ioctl(struct file *f, unsigned int ioctl,
         int r;
         switch (ioctl) {
         case VHOST_NET_SET_BACKEND:
-                r = copy_from_user(&backend, argp, sizeof backend);
-                if (r < 0)
-                        return r;
+                if (copy_from_user(&backend, argp, sizeof backend))
+                        return -EFAULT;
                 return vhost_net_set_backend(n, backend.index, backend.fd);
         case VHOST_GET_FEATURES:
                 features = VHOST_FEATURES;
-                return copy_to_user(featurep, &features, sizeof features);
+                if (copy_to_user(featurep, &features, sizeof features))
+                        return -EFAULT;
+                return 0;
         case VHOST_SET_FEATURES:
-                r = copy_from_user(&features, featurep, sizeof features);
-                if (r < 0)
-                        return r;
+                if (copy_from_user(&features, featurep, sizeof features))
+                        return -EFAULT;
                 if (features & ~VHOST_FEATURES)
                         return -EOPNOTSUPP;
                 return vhost_net_set_features(n, features);
diff --git a/drivers/vhost/vhost.c b/drivers/vhost/vhost.c
index c6fb8e968f21..3b83382e06eb 100644
--- a/drivers/vhost/vhost.c
+++ b/drivers/vhost/vhost.c
@@ -320,10 +320,8 @@ static long vhost_set_memory(struct vhost_dev *d, struct vhost_memory __user *m)
 {
         struct vhost_memory mem, *newmem, *oldmem;
         unsigned long size = offsetof(struct vhost_memory, regions);
-        long r;
-        r = copy_from_user(&mem, m, size);
-        if (r)
-                return r;
+        if (copy_from_user(&mem, m, size))
+                return -EFAULT;
         if (mem.padding)
                 return -EOPNOTSUPP;
         if (mem.nregions > VHOST_MEMORY_MAX_NREGIONS)
@@ -333,15 +331,16 @@ static long vhost_set_memory(struct vhost_dev *d, struct vhost_memory __user *m)
                 return -ENOMEM;
 
         memcpy(newmem, &mem, size);
-        r = copy_from_user(newmem->regions, m->regions,
-                           mem.nregions * sizeof *m->regions);
-        if (r) {
+        if (copy_from_user(newmem->regions, m->regions,
+                           mem.nregions * sizeof *m->regions)) {
                 kfree(newmem);
-                return r;
+                return -EFAULT;
         }
 
-        if (!memory_access_ok(d, newmem, vhost_has_feature(d, VHOST_F_LOG_ALL)))
+        if (!memory_access_ok(d, newmem, vhost_has_feature(d, VHOST_F_LOG_ALL))) {
+                kfree(newmem);
                 return -EFAULT;
+        }
         oldmem = d->memory;
         rcu_assign_pointer(d->memory, newmem);
         synchronize_rcu();
@@ -374,7 +373,7 @@ static long vhost_set_vring(struct vhost_dev *d, int ioctl, void __user *argp)
         r = get_user(idx, idxp);
         if (r < 0)
                 return r;
-        if (idx > d->nvqs)
+        if (idx >= d->nvqs)
                 return -ENOBUFS;
 
         vq = d->vqs + idx;
@@ -389,9 +388,10 @@ static long vhost_set_vring(struct vhost_dev *d, int ioctl, void __user *argp)
                         r = -EBUSY;
                         break;
                 }
-                r = copy_from_user(&s, argp, sizeof s);
-                if (r < 0)
+                if (copy_from_user(&s, argp, sizeof s)) {
+                        r = -EFAULT;
                         break;
+                }
                 if (!s.num || s.num > 0xffff || (s.num & (s.num - 1))) {
                         r = -EINVAL;
                         break;
@@ -405,9 +405,10 @@ static long vhost_set_vring(struct vhost_dev *d, int ioctl, void __user *argp)
                         r = -EBUSY;
                         break;
                 }
-                r = copy_from_user(&s, argp, sizeof s);
-                if (r < 0)
+                if (copy_from_user(&s, argp, sizeof s)) {
+                        r = -EFAULT;
                         break;
+                }
                 if (s.num > 0xffff) {
                         r = -EINVAL;
                         break;
@@ -419,12 +420,14 @@ static long vhost_set_vring(struct vhost_dev *d, int ioctl, void __user *argp)
         case VHOST_GET_VRING_BASE:
                 s.index = idx;
                 s.num = vq->last_avail_idx;
-                r = copy_to_user(argp, &s, sizeof s);
+                if (copy_to_user(argp, &s, sizeof s))
+                        r = -EFAULT;
                 break;
         case VHOST_SET_VRING_ADDR:
-                r = copy_from_user(&a, argp, sizeof a);
-                if (r < 0)
+                if (copy_from_user(&a, argp, sizeof a)) {
+                        r = -EFAULT;
                         break;
+                }
                 if (a.flags & ~(0x1 << VHOST_VRING_F_LOG)) {
                         r = -EOPNOTSUPP;
                         break;
@@ -477,9 +480,10 @@ static long vhost_set_vring(struct vhost_dev *d, int ioctl, void __user *argp)
                 vq->used = (void __user *)(unsigned long)a.used_user_addr;
                 break;
         case VHOST_SET_VRING_KICK:
-                r = copy_from_user(&f, argp, sizeof f);
-                if (r < 0)
+                if (copy_from_user(&f, argp, sizeof f)) {
+                        r = -EFAULT;
                         break;
+                }
                 eventfp = f.fd == -1 ? NULL : eventfd_fget(f.fd);
                 if (IS_ERR(eventfp)) {
                         r = PTR_ERR(eventfp);
@@ -492,9 +496,10 @@ static long vhost_set_vring(struct vhost_dev *d, int ioctl, void __user *argp)
                         filep = eventfp;
                 break;
         case VHOST_SET_VRING_CALL:
-                r = copy_from_user(&f, argp, sizeof f);
-                if (r < 0)
+                if (copy_from_user(&f, argp, sizeof f)) {
+                        r = -EFAULT;
                         break;
+                }
                 eventfp = f.fd == -1 ? NULL : eventfd_fget(f.fd);
                 if (IS_ERR(eventfp)) {
                         r = PTR_ERR(eventfp);
@@ -510,9 +515,10 @@ static long vhost_set_vring(struct vhost_dev *d, int ioctl, void __user *argp)
                         filep = eventfp;
                 break;
         case VHOST_SET_VRING_ERR:
-                r = copy_from_user(&f, argp, sizeof f);
-                if (r < 0)
+                if (copy_from_user(&f, argp, sizeof f)) {
+                        r = -EFAULT;
                         break;
+                }
                 eventfp = f.fd == -1 ? NULL : eventfd_fget(f.fd);
                 if (IS_ERR(eventfp)) {
                         r = PTR_ERR(eventfp);
@@ -575,9 +581,10 @@ long vhost_dev_ioctl(struct vhost_dev *d, unsigned int ioctl, unsigned long arg)
                 r = vhost_set_memory(d, argp);
                 break;
         case VHOST_SET_LOG_BASE:
-                r = copy_from_user(&p, argp, sizeof p);
-                if (r < 0)
+                if (copy_from_user(&p, argp, sizeof p)) {
+                        r = -EFAULT;
                         break;
+                }
                 if ((u64)(unsigned long)p != p) {
                         r = -EFAULT;
                         break;
diff --git a/drivers/video/backlight/88pm860x_bl.c b/drivers/video/backlight/88pm860x_bl.c
index 68d2518fadaa..38ffc3fbcbe4 100644
--- a/drivers/video/backlight/88pm860x_bl.c
+++ b/drivers/video/backlight/88pm860x_bl.c
@@ -222,6 +222,7 @@ static int pm860x_backlight_probe(struct platform_device *pdev)
         data->port = __check_device(pdata, name);
         if (data->port < 0) {
                 dev_err(&pdev->dev, "wrong platform data is assigned");
+                kfree(data);
                 return -EINVAL;
         }
 
@@ -266,6 +267,7 @@ static int pm860x_backlight_probe(struct platform_device *pdev)
         backlight_update_status(bl);
         return 0;
 out:
+        backlight_device_unregister(bl);
         kfree(data);
         return ret;
 }
diff --git a/drivers/video/backlight/Kconfig b/drivers/video/backlight/Kconfig
index c025c84601b0..e54a337227ea 100644
--- a/drivers/video/backlight/Kconfig
+++ b/drivers/video/backlight/Kconfig
@@ -8,12 +8,13 @@ menuconfig BACKLIGHT_LCD_SUPPORT
           Enable this to be able to choose the drivers for controlling the
           backlight and the LCD panel on some platforms, for example on PDAs.
 
+if BACKLIGHT_LCD_SUPPORT
+
 #
 # LCD
 #
 config LCD_CLASS_DEVICE
         tristate "Lowlevel LCD controls"
-        depends on BACKLIGHT_LCD_SUPPORT
         default m
         help
           This framework adds support for low-level control of LCD.
@@ -24,31 +25,32 @@ config LCD_CLASS_DEVICE
           To have support for your specific LCD panel you will have to
           select the proper drivers which depend on this option.
 
+if LCD_CLASS_DEVICE
+
 config LCD_CORGI
         tristate "LCD Panel support for SHARP corgi/spitz model"
-        depends on LCD_CLASS_DEVICE && SPI_MASTER && PXA_SHARPSL
+        depends on SPI_MASTER && PXA_SHARPSL
         help
           Say y here to support the LCD panels usually found on SHARP
           corgi (C7x0) and spitz (Cxx00) models.
 
 config LCD_L4F00242T03
         tristate "Epson L4F00242T03 LCD"
-        depends on LCD_CLASS_DEVICE && SPI_MASTER && GENERIC_GPIO
+        depends on SPI_MASTER && GENERIC_GPIO
         help
           SPI driver for Epson L4F00242T03. This provides basic support
           for init and powering the LCD up/down through a sysfs interface.
 
 config LCD_LMS283GF05
         tristate "Samsung LMS283GF05 LCD"
-        depends on LCD_CLASS_DEVICE && SPI_MASTER && GENERIC_GPIO
+        depends on SPI_MASTER && GENERIC_GPIO
         help
           SPI driver for Samsung LMS283GF05. This provides basic support
           for powering the LCD up/down through a sysfs interface.
 
 config LCD_LTV350QV
         tristate "Samsung LTV350QV LCD Panel"
-        depends on LCD_CLASS_DEVICE && SPI_MASTER
-        default n
+        depends on SPI_MASTER
         help
           If you have a Samsung LTV350QV LCD panel, say y to include a
           power control driver for it.  The panel starts up in power
@@ -59,60 +61,61 @@ config LCD_LTV350QV
 
 config LCD_ILI9320
         tristate
-        depends on LCD_CLASS_DEVICE && BACKLIGHT_LCD_SUPPORT
-        default n
         help
           If you have a panel based on the ILI9320 controller chip
           then say y to include a power driver for it.
 
 config LCD_TDO24M
         tristate "Toppoly TDO24M  and TDO35S LCD Panels support"
-        depends on LCD_CLASS_DEVICE && SPI_MASTER
-        default n
+        depends on SPI_MASTER
         help
           If you have a Toppoly TDO24M/TDO35S series LCD panel, say y here to
           include the support for it.
 
 config LCD_VGG2432A4
         tristate "VGG2432A4 LCM device support"
-        depends on BACKLIGHT_LCD_SUPPORT && LCD_CLASS_DEVICE && SPI_MASTER
+        depends on SPI_MASTER
         select LCD_ILI9320
-        default n
         help
           If you have a VGG2432A4 panel based on the ILI9320 controller chip
           then say y to include a power driver for it.
 
 config LCD_PLATFORM
         tristate "Platform LCD controls"
-        depends on LCD_CLASS_DEVICE
         help
           This driver provides a platform-device registered LCD power
           control interface.
 
 config LCD_TOSA
         tristate "Sharp SL-6000 LCD Driver"
-        depends on LCD_CLASS_DEVICE && SPI
-        depends on MACH_TOSA
-        default n
+        depends on SPI && MACH_TOSA
         help
           If you have an Sharp SL-6000 Zaurus say Y to enable a driver
           for its LCD.
 
 config LCD_HP700
         tristate "HP Jornada 700 series LCD Driver"
-        depends on LCD_CLASS_DEVICE
         depends on SA1100_JORNADA720_SSP && !PREEMPT
         default y
         help
           If you have an HP Jornada 700 series handheld (710/720/728)
           say Y to enable LCD control driver.
 
+config LCD_S6E63M0
+        tristate "S6E63M0 AMOLED LCD Driver"
+        depends on SPI && BACKLIGHT_CLASS_DEVICE
+        default n
+        help
+          If you have an S6E63M0 LCD Panel, say Y to enable its
+          LCD control driver.
+
+endif # LCD_CLASS_DEVICE
+
 #
 # Backlight
 #
 config BACKLIGHT_CLASS_DEVICE
         tristate "Lowlevel Backlight controls"
-        depends on BACKLIGHT_LCD_SUPPORT
         default m
         help
           This framework adds support for low-level control of the LCD
@@ -121,9 +124,11 @@ config BACKLIGHT_CLASS_DEVICE
           To have support for your specific LCD panel you will have to
           select the proper drivers which depend on this option.
 
+if BACKLIGHT_CLASS_DEVICE
+
 config BACKLIGHT_ATMEL_LCDC
         bool "Atmel LCDC Contrast-as-Backlight control"
-        depends on BACKLIGHT_CLASS_DEVICE && FB_ATMEL
+        depends on FB_ATMEL
         default y if MACH_SAM9261EK || MACH_SAM9G10EK || MACH_SAM9263EK
         help
           This provides a backlight control internal to the Atmel LCDC
@@ -136,8 +141,7 @@ config BACKLIGHT_ATMEL_LCDC
 
 config BACKLIGHT_ATMEL_PWM
         tristate "Atmel PWM backlight control"
-        depends on BACKLIGHT_CLASS_DEVICE && ATMEL_PWM
-        default n
+        depends on ATMEL_PWM
         help
           Say Y here if you want to use the PWM peripheral in Atmel AT91 and
           AVR32 devices. This driver will need additional platform data to know
@@ -146,9 +150,18 @@ config BACKLIGHT_ATMEL_PWM
           To compile this driver as a module, choose M here: the module will be
           called atmel-pwm-bl.
 
+config BACKLIGHT_EP93XX
+        tristate "Cirrus EP93xx Backlight Driver"
+        depends on FB_EP93XX
+        help
+          If you have a LCD backlight connected to the BRIGHT output of
+          the EP93xx, say Y here to enable this driver.
+
+          To compile this driver as a module, choose M here: the module will
+          be called ep93xx_bl.
+
 config BACKLIGHT_GENERIC
         tristate "Generic (aka Sharp Corgi) Backlight Driver"
-        depends on BACKLIGHT_CLASS_DEVICE
         default y
         help
           Say y to enable the generic platform backlight driver previously
@@ -157,7 +170,7 @@ config BACKLIGHT_GENERIC
 
 config BACKLIGHT_LOCOMO
         tristate "Sharp LOCOMO LCD/Backlight Driver"
-        depends on BACKLIGHT_CLASS_DEVICE && SHARP_LOCOMO
+        depends on SHARP_LOCOMO
         default y
         help
           If you have a Sharp Zaurus SL-5500 (Collie) or SL-5600 (Poodle) say y to
@@ -165,7 +178,7 @@ config BACKLIGHT_LOCOMO
 
 config BACKLIGHT_OMAP1
         tristate "OMAP1 PWL-based LCD Backlight"
-        depends on BACKLIGHT_CLASS_DEVICE && ARCH_OMAP1
+        depends on ARCH_OMAP1
         default y
         help
           This driver controls the LCD backlight level and power for
@@ -174,7 +187,7 @@ config BACKLIGHT_OMAP1
 
 config BACKLIGHT_HP680
         tristate "HP Jornada 680 Backlight Driver"
-        depends on BACKLIGHT_CLASS_DEVICE && SH_HP6XX
+        depends on SH_HP6XX
         default y
         help
           If you have a HP Jornada 680, say y to enable the
@@ -182,7 +195,6 @@ config BACKLIGHT_HP680
 
 config BACKLIGHT_HP700
         tristate "HP Jornada 700 series Backlight Driver"
-        depends on BACKLIGHT_CLASS_DEVICE
         depends on SA1100_JORNADA720_SSP && !PREEMPT
         default y
         help
@@ -191,76 +203,70 @@ config BACKLIGHT_HP700
 
 config BACKLIGHT_PROGEAR
         tristate "Frontpath ProGear Backlight Driver"
-        depends on BACKLIGHT_CLASS_DEVICE && PCI && X86
-        default n
+        depends on PCI && X86
         help
           If you have a Frontpath ProGear say Y to enable the
           backlight driver.
 
 config BACKLIGHT_CARILLO_RANCH
         tristate "Intel Carillo Ranch Backlight Driver"
-        depends on BACKLIGHT_CLASS_DEVICE && LCD_CLASS_DEVICE && PCI && X86 && FB_LE80578
-        default n
+        depends on LCD_CLASS_DEVICE && PCI && X86 && FB_LE80578
         help
           If you have a Intel LE80578 (Carillo Ranch) say Y to enable the
           backlight driver.
 
 config BACKLIGHT_PWM
         tristate "Generic PWM based Backlight Driver"
-        depends on BACKLIGHT_CLASS_DEVICE && HAVE_PWM
+        depends on HAVE_PWM
         help
           If you have a LCD backlight adjustable by PWM, say Y to enable
           this driver.
 
 config BACKLIGHT_DA903X
         tristate "Backlight Driver for DA9030/DA9034 using WLED"
-        depends on BACKLIGHT_CLASS_DEVICE && PMIC_DA903X
+        depends on PMIC_DA903X
         help
           If you have a LCD backlight connected to the WLED output of DA9030
           or DA9034 WLED output, say Y here to enable this driver.
 
 config BACKLIGHT_MAX8925
         tristate "Backlight driver for MAX8925"
-        depends on BACKLIGHT_CLASS_DEVICE && MFD_MAX8925
+        depends on MFD_MAX8925
         help
           If you have a LCD backlight connected to the WLED output of MAX8925
           WLED output, say Y here to enable this driver.
 
 config BACKLIGHT_MBP_NVIDIA
        tristate "MacBook Pro Nvidia Backlight Driver"
-       depends on BACKLIGHT_CLASS_DEVICE && X86
-       default n
+       depends on X86
        help
          If you have an Apple Macbook Pro with Nvidia graphics hardware say Y
          to enable a driver for its backlight
 
 config BACKLIGHT_TOSA
         tristate "Sharp SL-6000 Backlight Driver"
-        depends on BACKLIGHT_CLASS_DEVICE && I2C
-        depends on MACH_TOSA && LCD_TOSA
-        default n
+        depends on I2C && MACH_TOSA && LCD_TOSA
         help
           If you have an Sharp SL-6000 Zaurus say Y to enable a driver
           for its backlight
 
 config BACKLIGHT_SAHARA
         tristate "Tabletkiosk Sahara Touch-iT Backlight Driver"
-        depends on BACKLIGHT_CLASS_DEVICE && X86
-        default n
+        depends on X86
         help
           If you have a Tabletkiosk Sahara Touch-iT, say y to enable the
           backlight driver.
 
 config BACKLIGHT_WM831X
         tristate "WM831x PMIC Backlight Driver"
-        depends on BACKLIGHT_CLASS_DEVICE && MFD_WM831X
+        depends on MFD_WM831X
         help
           If you have a backlight driven by the ISINK and DCDC of a
           WM831x PMIC say y to enable the backlight driver for it.
 
 config BACKLIGHT_ADX
         tristate "Avionic Design Xanthos Backlight Driver"
-        depends on BACKLIGHT_CLASS_DEVICE && ARCH_PXA_ADX
+        depends on ARCH_PXA_ADX
         default y
         help
           Say Y to enable the backlight driver on Avionic Design Xanthos-based
@@ -268,7 +274,7 @@ config BACKLIGHT_ADX
 
 config BACKLIGHT_ADP5520
         tristate "Backlight Driver for ADP5520/ADP5501 using WLED"
-        depends on BACKLIGHT_CLASS_DEVICE && PMIC_ADP5520
+        depends on PMIC_ADP5520
         help
           If you have a LCD backlight connected to the BST/BL_SNK output of
           ADP5520 or ADP5501, say Y here to enable this driver.
@@ -276,9 +282,31 @@ config BACKLIGHT_ADP5520
           To compile this driver as a module, choose M here: the module will
           be called adp5520_bl.
 
+config BACKLIGHT_ADP8860
+        tristate "Backlight Driver for ADP8860/ADP8861/ADP8863 using WLED"
+        depends on BACKLIGHT_CLASS_DEVICE && I2C
+        select NEW_LEDS
+        select LEDS_CLASS
+        help
+          If you have a LCD backlight connected to the ADP8860, ADP8861 or
+          ADP8863 say Y here to enable this driver.
+
+          To compile this driver as a module, choose M here: the module will
+          be called adp8860_bl.
+
 config BACKLIGHT_88PM860X
         tristate "Backlight Driver for 88PM8606 using WLED"
-        depends on BACKLIGHT_CLASS_DEVICE && MFD_88PM860X
+        depends on MFD_88PM860X
         help
           Say Y to enable the backlight driver for Marvell 88PM8606.
 
+config BACKLIGHT_PCF50633
+        tristate "Backlight driver for NXP PCF50633 MFD"
+        depends on BACKLIGHT_CLASS_DEVICE && MFD_PCF50633
+        help
+          If you have a backlight driven by a NXP PCF50633 MFD, say Y here to
+          enable its driver.
+
+endif # BACKLIGHT_CLASS_DEVICE
+
+endif # BACKLIGHT_LCD_SUPPORT
diff --git a/drivers/video/backlight/Makefile b/drivers/video/backlight/Makefile
index 09d1f14d6257..44c0f81ad85d 100644
--- a/drivers/video/backlight/Makefile
+++ b/drivers/video/backlight/Makefile
@@ -11,9 +11,11 @@ obj-$(CONFIG_LCD_PLATFORM)	   += platform_lcd.o
 obj-$(CONFIG_LCD_VGG2432A4)        += vgg2432a4.o
 obj-$(CONFIG_LCD_TDO24M)           += tdo24m.o
 obj-$(CONFIG_LCD_TOSA)             += tosa_lcd.o
+obj-$(CONFIG_LCD_S6E63M0)       += s6e63m0.o
 
 obj-$(CONFIG_BACKLIGHT_CLASS_DEVICE) += backlight.o
 obj-$(CONFIG_BACKLIGHT_ATMEL_PWM)    += atmel-pwm-bl.o
+obj-$(CONFIG_BACKLIGHT_EP93XX)  += ep93xx_bl.o
 obj-$(CONFIG_BACKLIGHT_GENERIC) += generic_bl.o
 obj-$(CONFIG_BACKLIGHT_HP700)   += jornada720_bl.o
 obj-$(CONFIG_BACKLIGHT_HP680)   += hp680_bl.o
@@ -30,5 +32,7 @@ obj-$(CONFIG_BACKLIGHT_SAHARA)	+= kb3886_bl.o
 obj-$(CONFIG_BACKLIGHT_WM831X)  += wm831x_bl.o
 obj-$(CONFIG_BACKLIGHT_ADX)    += adx_bl.o
 obj-$(CONFIG_BACKLIGHT_ADP5520) += adp5520_bl.o
+obj-$(CONFIG_BACKLIGHT_ADP8860) += adp8860_bl.o
 obj-$(CONFIG_BACKLIGHT_88PM860X) += 88pm860x_bl.o
+obj-$(CONFIG_BACKLIGHT_PCF50633)        += pcf50633-backlight.o
 
diff --git a/drivers/video/backlight/adp8860_bl.c b/drivers/video/backlight/adp8860_bl.c
new file mode 100644
index 000000000000..921ca37398f3
--- /dev/null
+++ b/drivers/video/backlight/adp8860_bl.c
@@ -0,0 +1,838 @@
+/*
+ * Backlight driver for Analog Devices ADP8860 Backlight Devices
+ *
+ * Copyright 2009-2010 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2 or later.
+ */
+
+#include <linux/module.h>
+#include <linux/version.h>
+#include <linux/init.h>
+#include <linux/errno.h>
+#include <linux/pm.h>
+#include <linux/platform_device.h>
+#include <linux/i2c.h>
+#include <linux/fb.h>
+#include <linux/backlight.h>
+#include <linux/leds.h>
+#include <linux/slab.h>
+#include <linux/workqueue.h>
+
+#include <linux/i2c/adp8860.h>
+#define ADP8860_EXT_FEATURES
+#define ADP8860_USE_LEDS
+
+#define ADP8860_MFDVID 0x00 /* Manufacturer and device ID */
+#define ADP8860_MDCR 0x01 /* Device mode and status */
+#define ADP8860_MDCR2 0x02 /* Device mode and Status Register 2 */
+#define ADP8860_INTR_EN 0x03 /* Interrupts enable */
+#define ADP8860_CFGR 0x04 /* Configuration register */
+#define ADP8860_BLSEN 0x05 /* Sink enable backlight or independent */
+#define ADP8860_BLOFF 0x06 /* Backlight off timeout */
+#define ADP8860_BLDIM 0x07 /* Backlight dim timeout */
+#define ADP8860_BLFR 0x08 /* Backlight fade in and out rates */
+#define ADP8860_BLMX1 0x09 /* Backlight (Brightness Level 1-daylight) maximum current */
+#define ADP8860_BLDM1 0x0A /* Backlight (Brightness Level 1-daylight) dim current */
+#define ADP8860_BLMX2 0x0B /* Backlight (Brightness Level 2-office) maximum current */
+#define ADP8860_BLDM2 0x0C /* Backlight (Brightness Level 2-office) dim current */
+#define ADP8860_BLMX3 0x0D /* Backlight (Brightness Level 3-dark) maximum current */
+#define ADP8860_BLDM3 0x0E /* Backlight (Brightness Level 3-dark) dim current */
+#define ADP8860_ISCFR 0x0F /* Independent sink current fade control register */
+#define ADP8860_ISCC 0x10 /* Independent sink current control register */
+#define ADP8860_ISCT1 0x11 /* Independent Sink Current Timer Register LED[7:5] */
+#define ADP8860_ISCT2 0x12 /* Independent Sink Current Timer Register LED[4:1] */
+#define ADP8860_ISCF 0x13 /* Independent sink current fade register */
+#define ADP8860_ISC7 0x14 /* Independent Sink Current LED7 */
+#define ADP8860_ISC6 0x15 /* Independent Sink Current LED6 */
+#define ADP8860_ISC5 0x16 /* Independent Sink Current LED5 */
+#define ADP8860_ISC4 0x17 /* Independent Sink Current LED4 */
+#define ADP8860_ISC3 0x18 /* Independent Sink Current LED3 */
+#define ADP8860_ISC2 0x19 /* Independent Sink Current LED2 */
+#define ADP8860_ISC1 0x1A /* Independent Sink Current LED1 */
+#define ADP8860_CCFG 0x1B /* Comparator configuration */
+#define ADP8860_CCFG2 0x1C /* Second comparator configuration */
+#define ADP8860_L2_TRP 0x1D /* L2 comparator reference */
+#define ADP8860_L2_HYS 0x1E /* L2 hysteresis */
+#define ADP8860_L3_TRP 0x1F /* L3 comparator reference */
+#define ADP8860_L3_HYS 0x20 /* L3 hysteresis */
+#define ADP8860_PH1LEVL 0x21 /* First phototransistor ambient light level-low byte register */
+#define ADP8860_PH1LEVH 0x22 /* First phototransistor ambient light level-high byte register */
+#define ADP8860_PH2LEVL 0x23 /* Second phototransistor ambient light level-low byte register */
+#define ADP8860_PH2LEVH 0x24 /* Second phototransistor ambient light level-high byte register */
+
+#define ADP8860_MANUFID         0x0  /* Analog Devices ADP8860 Manufacturer ID */
+#define ADP8861_MANUFID         0x4  /* Analog Devices ADP8861 Manufacturer ID */
+#define ADP8863_MANUFID         0x2  /* Analog Devices ADP8863 Manufacturer ID */
+
+#define ADP8860_DEVID(x)        ((x) & 0xF)
+#define ADP8860_MANID(x)        ((x) >> 4)
+
+/* MDCR Device mode and status */
+#define INT_CFG                 (1 << 6)
+#define NSTBY                   (1 << 5)
+#define DIM_EN                  (1 << 4)
+#define GDWN_DIS                (1 << 3)
+#define SIS_EN                  (1 << 2)
+#define CMP_AUTOEN              (1 << 1)
+#define BLEN                    (1 << 0)
+
+/* ADP8860_CCFG Main ALS comparator level enable */
+#define L3_EN                   (1 << 1)
+#define L2_EN                   (1 << 0)
+
+#define CFGR_BLV_SHIFT          3
+#define CFGR_BLV_MASK           0x3
+#define ADP8860_FLAG_LED_MASK   0xFF
+
+#define FADE_VAL(in, out)       ((0xF & (in)) | ((0xF & (out)) << 4))
+#define BL_CFGR_VAL(law, blv)   ((((blv) & CFGR_BLV_MASK) << CFGR_BLV_SHIFT) | ((0x3 & (law)) << 1))
+#define ALS_CCFG_VAL(filt)      ((0x7 & filt) << 5)
+
+enum {
+        adp8860,
+        adp8861,
+        adp8863
+};
+
+struct adp8860_led {
+        struct led_classdev     cdev;
+        struct work_struct      work;
+        struct i2c_client       *client;
+        enum led_brightness     new_brightness;
+        int                     id;
+        int                     flags;
+};
+
+struct adp8860_bl {
+        struct i2c_client *client;
+        struct backlight_device *bl;
+        struct adp8860_led *led;
+        struct adp8860_backlight_platform_data *pdata;
+        struct mutex lock;
+        unsigned long cached_daylight_max;
+        int id;
+        int revid;
+        int current_brightness;
+        unsigned en_ambl_sens:1;
+        unsigned gdwn_dis:1;
+};
+
+static int adp8860_read(struct i2c_client *client, int reg, uint8_t *val)
+{
+        int ret;
+
+        ret = i2c_smbus_read_byte_data(client, reg);
+        if (ret < 0) {
+                dev_err(&client->dev, "failed reading at 0x%02x\n", reg);
+                return ret;
+        }
+
+        *val = (uint8_t)ret;
+        return 0;
+}
+
+static int adp8860_write(struct i2c_client *client, u8 reg, u8 val)
+{
+        return i2c_smbus_write_byte_data(client, reg, val);
+}
+
+static int adp8860_set_bits(struct i2c_client *client, int reg, uint8_t bit_mask)
+{
+        struct adp8860_bl *data = i2c_get_clientdata(client);
+        uint8_t reg_val;
+        int ret;
+
+        mutex_lock(&data->lock);
+
+        ret = adp8860_read(client, reg, &reg_val);
+
+        if (!ret && ((reg_val & bit_mask) == 0)) {
+                reg_val |= bit_mask;
+                ret = adp8860_write(client, reg, reg_val);
+        }
+
+        mutex_unlock(&data->lock);
+        return ret;
+}
+
+static int adp8860_clr_bits(struct i2c_client *client, int reg, uint8_t bit_mask)
+{
+        struct adp8860_bl *data = i2c_get_clientdata(client);
+        uint8_t reg_val;
+        int ret;
+
+        mutex_lock(&data->lock);
+
+        ret = adp8860_read(client, reg, &reg_val);
+
+        if (!ret && (reg_val & bit_mask)) {
+                reg_val &= ~bit_mask;
+                ret = adp8860_write(client, reg, reg_val);
+        }
+
+        mutex_unlock(&data->lock);
+        return ret;
+}
+
+/*
+ * Independent sink / LED
+ */
+#if defined(ADP8860_USE_LEDS)
+static void adp8860_led_work(struct work_struct *work)
+{
+        struct adp8860_led *led = container_of(work, struct adp8860_led, work);
+        adp8860_write(led->client, ADP8860_ISC1 - led->id + 1,
+                         led->new_brightness >> 1);
+}
+
+static void adp8860_led_set(struct led_classdev *led_cdev,
+                           enum led_brightness value)
+{
+        struct adp8860_led *led;
+
+        led = container_of(led_cdev, struct adp8860_led, cdev);
+        led->new_brightness = value;
+        schedule_work(&led->work);
+}
+
+static int adp8860_led_setup(struct adp8860_led *led)
+{
+        struct i2c_client *client = led->client;
+        int ret = 0;
+
+        ret = adp8860_write(client, ADP8860_ISC1 - led->id + 1, 0);
+        ret |= adp8860_set_bits(client, ADP8860_ISCC, 1 << (led->id - 1));
+
+        if (led->id > 4)
+                ret |= adp8860_set_bits(client, ADP8860_ISCT1,
+                                (led->flags & 0x3) << ((led->id - 5) * 2));
+        else
+                ret |= adp8860_set_bits(client, ADP8860_ISCT2,
+                                (led->flags & 0x3) << ((led->id - 1) * 2));
+
+        return ret;
+}
+
+static int __devinit adp8860_led_probe(struct i2c_client *client)
+{
+        struct adp8860_backlight_platform_data *pdata =
+                client->dev.platform_data;
+        struct adp8860_bl *data = i2c_get_clientdata(client);
+        struct adp8860_led *led, *led_dat;
+        struct led_info *cur_led;
+        int ret, i;
+
+        led = kzalloc(sizeof(*led) * pdata->num_leds, GFP_KERNEL);
+        if (led == NULL) {
+                dev_err(&client->dev, "failed to alloc memory\n");
+                return -ENOMEM;
+        }
+
+        ret = adp8860_write(client, ADP8860_ISCFR, pdata->led_fade_law);
+        ret = adp8860_write(client, ADP8860_ISCT1,
+                        (pdata->led_on_time & 0x3) << 6);
+        ret |= adp8860_write(client, ADP8860_ISCF,
+                        FADE_VAL(pdata->led_fade_in, pdata->led_fade_out));
+
+        if (ret) {
+                dev_err(&client->dev, "failed to write\n");
+                goto err_free;
+        }
+
+        for (i = 0; i < pdata->num_leds; ++i) {
+                cur_led = &pdata->leds[i];
+                led_dat = &led[i];
+
+                led_dat->id = cur_led->flags & ADP8860_FLAG_LED_MASK;
+
+                if (led_dat->id > 7 || led_dat->id < 1) {
+                        dev_err(&client->dev, "Invalid LED ID %d\n",
+                                led_dat->id);
+                        goto err;
+                }
+
+                if (pdata->bl_led_assign & (1 << (led_dat->id - 1))) {
+                        dev_err(&client->dev, "LED %d used by Backlight\n",
+                                led_dat->id);
+                        goto err;
+                }
+
+                led_dat->cdev.name = cur_led->name;
+                led_dat->cdev.default_trigger = cur_led->default_trigger;
+                led_dat->cdev.brightness_set = adp8860_led_set;
+                led_dat->cdev.brightness = LED_OFF;
+                led_dat->flags = cur_led->flags >> FLAG_OFFT_SHIFT;
+                led_dat->client = client;
+                led_dat->new_brightness = LED_OFF;
+                INIT_WORK(&led_dat->work, adp8860_led_work);
+
+                ret = led_classdev_register(&client->dev, &led_dat->cdev);
+                if (ret) {
+                        dev_err(&client->dev, "failed to register LED %d\n",
+                                led_dat->id);
+                        goto err;
+                }
+
+                ret = adp8860_led_setup(led_dat);
+                if (ret) {
+                        dev_err(&client->dev, "failed to write\n");
+                        i++;
+                        goto err;
+                }
+        }
+
+        data->led = led;
+
+        return 0;
+
+ err:
+        for (i = i - 1; i >= 0; --i) {
+                led_classdev_unregister(&led[i].cdev);
+                cancel_work_sync(&led[i].work);
+        }
+
+ err_free:
+        kfree(led);
+
+        return ret;
+}
+
+static int __devexit adp8860_led_remove(struct i2c_client *client)
+{
+        struct adp8860_backlight_platform_data *pdata =
+                client->dev.platform_data;
+        struct adp8860_bl *data = i2c_get_clientdata(client);
+        int i;
+
+        for (i = 0; i < pdata->num_leds; i++) {
+                led_classdev_unregister(&data->led[i].cdev);
+                cancel_work_sync(&data->led[i].work);
+        }
+
+        kfree(data->led);
+        return 0;
+}
+#else
+static int __devinit adp8860_led_probe(struct i2c_client *client)
+{
+        return 0;
+}
+
+static int __devexit adp8860_led_remove(struct i2c_client *client)
+{
+        return 0;
+}
+#endif
+
+static int adp8860_bl_set(struct backlight_device *bl, int brightness)
+{
+        struct adp8860_bl *data = bl_get_data(bl);
+        struct i2c_client *client = data->client;
+        int ret = 0;
+
+        if (data->en_ambl_sens) {
+                if ((brightness > 0) && (brightness < ADP8860_MAX_BRIGHTNESS)) {
+                        /* Disable Ambient Light auto adjust */
+                        ret |= adp8860_clr_bits(client, ADP8860_MDCR,
+                                        CMP_AUTOEN);
+                        ret |= adp8860_write(client, ADP8860_BLMX1, brightness);
+                } else {
+                        /*
+                         * MAX_BRIGHTNESS -> Enable Ambient Light auto adjust
+                         * restore daylight l1 sysfs brightness
+                         */
+                        ret |= adp8860_write(client, ADP8860_BLMX1,
+                                         data->cached_daylight_max);
+                        ret |= adp8860_set_bits(client, ADP8860_MDCR,
+                                         CMP_AUTOEN);
+                }
+        } else
+                ret |= adp8860_write(client, ADP8860_BLMX1, brightness);
+
+        if (data->current_brightness && brightness == 0)
+                ret |= adp8860_set_bits(client,
+                                ADP8860_MDCR, DIM_EN);
+        else if (data->current_brightness == 0 && brightness)
+                ret |= adp8860_clr_bits(client,
+                                ADP8860_MDCR, DIM_EN);
+
+        if (!ret)
+                data->current_brightness = brightness;
+
+        return ret;
+}
+
+static int adp8860_bl_update_status(struct backlight_device *bl)
+{
+        int brightness = bl->props.brightness;
+        if (bl->props.power != FB_BLANK_UNBLANK)
+                brightness = 0;
+
+        if (bl->props.fb_blank != FB_BLANK_UNBLANK)
+                brightness = 0;
+
+        return adp8860_bl_set(bl, brightness);
+}
+
+static int adp8860_bl_get_brightness(struct backlight_device *bl)
+{
+        struct adp8860_bl *data = bl_get_data(bl);
+
+        return data->current_brightness;
+}
+
+static const struct backlight_ops adp8860_bl_ops = {
+        .update_status  = adp8860_bl_update_status,
+        .get_brightness = adp8860_bl_get_brightness,
+};
+
+static int adp8860_bl_setup(struct backlight_device *bl)
+{
+        struct adp8860_bl *data = bl_get_data(bl);
+        struct i2c_client *client = data->client;
+        struct adp8860_backlight_platform_data *pdata = data->pdata;
+        int ret = 0;
+
+        ret |= adp8860_write(client, ADP8860_BLSEN, ~pdata->bl_led_assign);
+        ret |= adp8860_write(client, ADP8860_BLMX1, pdata->l1_daylight_max);
+        ret |= adp8860_write(client, ADP8860_BLDM1, pdata->l1_daylight_dim);
+
+        if (data->en_ambl_sens) {
+                data->cached_daylight_max = pdata->l1_daylight_max;
+                ret |= adp8860_write(client, ADP8860_BLMX2,
+                                                pdata->l2_office_max);
+                ret |= adp8860_write(client, ADP8860_BLDM2,
+                                                pdata->l2_office_dim);
+                ret |= adp8860_write(client, ADP8860_BLMX3,
+                                                pdata->l3_dark_max);
+                ret |= adp8860_write(client, ADP8860_BLDM3,
+                                                pdata->l3_dark_dim);
+
+                ret |= adp8860_write(client, ADP8860_L2_TRP, pdata->l2_trip);
+                ret |= adp8860_write(client, ADP8860_L2_HYS, pdata->l2_hyst);
+                ret |= adp8860_write(client, ADP8860_L3_TRP, pdata->l3_trip);
+                ret |= adp8860_write(client, ADP8860_L3_HYS, pdata->l3_hyst);
+                ret |= adp8860_write(client, ADP8860_CCFG, L2_EN | L3_EN |
+                                                ALS_CCFG_VAL(pdata->abml_filt));
+        }
+
+        ret |= adp8860_write(client, ADP8860_CFGR,
+                        BL_CFGR_VAL(pdata->bl_fade_law, 0));
+
+        ret |= adp8860_write(client, ADP8860_BLFR, FADE_VAL(pdata->bl_fade_in,
+                        pdata->bl_fade_out));
+
+        ret |= adp8860_set_bits(client, ADP8860_MDCR, BLEN | DIM_EN | NSTBY |
+                        (data->gdwn_dis ? GDWN_DIS : 0));
+
+        return ret;
+}
+
+static ssize_t adp8860_show(struct device *dev, char *buf, int reg)
+{
+        struct adp8860_bl *data = dev_get_drvdata(dev);
+        int error;
+        uint8_t reg_val;
+
+        mutex_lock(&data->lock);
+        error = adp8860_read(data->client, reg, &reg_val);
+        mutex_unlock(&data->lock);
+
+        if (error < 0)
+                return error;
+
+        return sprintf(buf, "%u\n", reg_val);
+}
+
+static ssize_t adp8860_store(struct device *dev, const char *buf,
+                         size_t count, int reg)
+{
+        struct adp8860_bl *data = dev_get_drvdata(dev);
+        unsigned long val;
+        int ret;
+
+        ret = strict_strtoul(buf, 10, &val);
+        if (ret)
+                return ret;
+
+        mutex_lock(&data->lock);
+        adp8860_write(data->client, reg, val);
+        mutex_unlock(&data->lock);
+
+        return count;
+}
+
+static ssize_t adp8860_bl_l3_dark_max_show(struct device *dev,
+                                     struct device_attribute *attr, char *buf)
+{
+        return adp8860_show(dev, buf, ADP8860_BLMX3);
+}
+
+static ssize_t adp8860_bl_l3_dark_max_store(struct device *dev,
+                struct device_attribute *attr, const char *buf, size_t count)
+{
+        return adp8860_store(dev, buf, count, ADP8860_BLMX3);
+}
+
+static DEVICE_ATTR(l3_dark_max, 0664, adp8860_bl_l3_dark_max_show,
+                        adp8860_bl_l3_dark_max_store);
+
+static ssize_t adp8860_bl_l2_office_max_show(struct device *dev,
+                struct device_attribute *attr, char *buf)
+{
+        return adp8860_show(dev, buf, ADP8860_BLMX2);
+}
+
+static ssize_t adp8860_bl_l2_office_max_store(struct device *dev,
+                struct device_attribute *attr, const char *buf, size_t count)
+{
+        return adp8860_store(dev, buf, count, ADP8860_BLMX2);
+}
+static DEVICE_ATTR(l2_office_max, 0664, adp8860_bl_l2_office_max_show,
+                        adp8860_bl_l2_office_max_store);
+
+static ssize_t adp8860_bl_l1_daylight_max_show(struct device *dev,
+                        struct device_attribute *attr, char *buf)
+{
+        return adp8860_show(dev, buf, ADP8860_BLMX1);
+}
+
+static ssize_t adp8860_bl_l1_daylight_max_store(struct device *dev,
+                struct device_attribute *attr, const char *buf, size_t count)
+{
+        struct adp8860_bl *data = dev_get_drvdata(dev);
+
+        strict_strtoul(buf, 10, &data->cached_daylight_max);
+        return adp8860_store(dev, buf, count, ADP8860_BLMX1);
+}
+static DEVICE_ATTR(l1_daylight_max, 0664, adp8860_bl_l1_daylight_max_show,
+                        adp8860_bl_l1_daylight_max_store);
+
+static ssize_t adp8860_bl_l3_dark_dim_show(struct device *dev,
+                        struct device_attribute *attr, char *buf)
+{
+        return adp8860_show(dev, buf, ADP8860_BLDM3);
+}
+
+static ssize_t adp8860_bl_l3_dark_dim_store(struct device *dev,
+                                     struct device_attribute *attr,
+                                     const char *buf, size_t count)
+{
+        return adp8860_store(dev, buf, count, ADP8860_BLDM3);
+}
+static DEVICE_ATTR(l3_dark_dim, 0664, adp8860_bl_l3_dark_dim_show,
+                        adp8860_bl_l3_dark_dim_store);
+
+static ssize_t adp8860_bl_l2_office_dim_show(struct device *dev,
+                        struct device_attribute *attr, char *buf)
+{
+        return adp8860_show(dev, buf, ADP8860_BLDM2);
+}
+
+static ssize_t adp8860_bl_l2_office_dim_store(struct device *dev,
+                                     struct device_attribute *attr,
+                                     const char *buf, size_t count)
+{
+        return adp8860_store(dev, buf, count, ADP8860_BLDM2);
+}
+static DEVICE_ATTR(l2_office_dim, 0664, adp8860_bl_l2_office_dim_show,
+                        adp8860_bl_l2_office_dim_store);
+
+static ssize_t adp8860_bl_l1_daylight_dim_show(struct device *dev,
+                                     struct device_attribute *attr, char *buf)
+{
+        return adp8860_show(dev, buf, ADP8860_BLDM1);
+}
+
+static ssize_t adp8860_bl_l1_daylight_dim_store(struct device *dev,
+                                     struct device_attribute *attr,
+                                     const char *buf, size_t count)
+{
+        return adp8860_store(dev, buf, count, ADP8860_BLDM1);
+}
+static DEVICE_ATTR(l1_daylight_dim, 0664, adp8860_bl_l1_daylight_dim_show,
+                        adp8860_bl_l1_daylight_dim_store);
+
+#ifdef ADP8860_EXT_FEATURES
+static ssize_t adp8860_bl_ambient_light_level_show(struct device *dev,
+                                     struct device_attribute *attr, char *buf)
+{
+        struct adp8860_bl *data = dev_get_drvdata(dev);
+        int error;
+        uint8_t reg_val;
+        uint16_t ret_val;
+
+        mutex_lock(&data->lock);
+        error = adp8860_read(data->client, ADP8860_PH1LEVL, &reg_val);
+        ret_val = reg_val;
+        error |= adp8860_read(data->client, ADP8860_PH1LEVH, &reg_val);
+        mutex_unlock(&data->lock);
+
+        if (error < 0)
+                return error;
+
+        /* Return 13-bit conversion value for the first light sensor */
+        ret_val += (reg_val & 0x1F) << 8;
+
+        return sprintf(buf, "%u\n", ret_val);
+}
+static DEVICE_ATTR(ambient_light_level, 0444,
+                adp8860_bl_ambient_light_level_show, NULL);
+
+static ssize_t adp8860_bl_ambient_light_zone_show(struct device *dev,
+                                     struct device_attribute *attr, char *buf)
+{
+        struct adp8860_bl *data = dev_get_drvdata(dev);
+        int error;
+        uint8_t reg_val;
+
+        mutex_lock(&data->lock);
+        error = adp8860_read(data->client, ADP8860_CFGR, &reg_val);
+        mutex_unlock(&data->lock);
+
+        if (error < 0)
+                return error;
+
+        return sprintf(buf, "%u\n",
+                ((reg_val >> CFGR_BLV_SHIFT) & CFGR_BLV_MASK) + 1);
+}
+
+static ssize_t adp8860_bl_ambient_light_zone_store(struct device *dev,
+                                     struct device_attribute *attr,
+                                     const char *buf, size_t count)
+{
+        struct adp8860_bl *data = dev_get_drvdata(dev);
+        unsigned long val;
+        uint8_t reg_val;
+        int ret;
+
+        ret = strict_strtoul(buf, 10, &val);
+        if (ret)
+                return ret;
+
+        if (val == 0) {
+                /* Enable automatic ambient light sensing */
+                adp8860_set_bits(data->client, ADP8860_MDCR, CMP_AUTOEN);
+        } else if ((val > 0) && (val < 6)) {
+                /* Disable automatic ambient light sensing */
+                adp8860_clr_bits(data->client, ADP8860_MDCR, CMP_AUTOEN);
+
+                /* Set user supplied ambient light zone */
+                mutex_lock(&data->lock);
+                adp8860_read(data->client, ADP8860_CFGR, &reg_val);
+                reg_val &= ~(CFGR_BLV_MASK << CFGR_BLV_SHIFT);
+                reg_val |= val << CFGR_BLV_SHIFT;
+                adp8860_write(data->client, ADP8860_CFGR, reg_val);
+                mutex_unlock(&data->lock);
+        }
+
+        return count;
+}
+static DEVICE_ATTR(ambient_light_zone, 0664,
+                adp8860_bl_ambient_light_zone_show,
+                adp8860_bl_ambient_light_zone_store);
+#endif
+
+static struct attribute *adp8860_bl_attributes[] = {
+        &dev_attr_l3_dark_max.attr,
+        &dev_attr_l3_dark_dim.attr,
+        &dev_attr_l2_office_max.attr,
+        &dev_attr_l2_office_dim.attr,
+        &dev_attr_l1_daylight_max.attr,
+        &dev_attr_l1_daylight_dim.attr,
+#ifdef ADP8860_EXT_FEATURES
+        &dev_attr_ambient_light_level.attr,
+        &dev_attr_ambient_light_zone.attr,
+#endif
+        NULL
+};
+
+static const struct attribute_group adp8860_bl_attr_group = {
+        .attrs = adp8860_bl_attributes,
+};
+
+static int __devinit adp8860_probe(struct i2c_client *client,
+                                        const struct i2c_device_id *id)
+{
+        struct backlight_device *bl;
+        struct adp8860_bl *data;
+        struct adp8860_backlight_platform_data *pdata =
+                client->dev.platform_data;
+        struct backlight_properties props;
+        uint8_t reg_val;
+        int ret;
+
+        if (!i2c_check_functionality(client->adapter,
+                                        I2C_FUNC_SMBUS_BYTE_DATA)) {
+                dev_err(&client->dev, "SMBUS Byte Data not Supported\n");
+                return -EIO;
+        }
+
+        if (!pdata) {
+                dev_err(&client->dev, "no platform data?\n");
+                return -EINVAL;
+        }
+
+        data = kzalloc(sizeof(*data), GFP_KERNEL);
+        if (data == NULL)
+                return -ENOMEM;
+
+        ret = adp8860_read(client, ADP8860_MFDVID, &reg_val);
+        if (ret < 0)
+                goto out2;
+
+        switch (ADP8860_MANID(reg_val)) {
+        case ADP8863_MANUFID:
+                data->gdwn_dis = !!pdata->gdwn_dis;
+        case ADP8860_MANUFID:
+                data->en_ambl_sens = !!pdata->en_ambl_sens;
+                break;
+        case ADP8861_MANUFID:
+                data->gdwn_dis = !!pdata->gdwn_dis;
+                break;
+        default:
+                dev_err(&client->dev, "failed to probe\n");
+                ret = -ENODEV;
+                goto out2;
+        }
+
+        /* It's confirmed that the DEVID field is actually a REVID */
+
+        data->revid = ADP8860_DEVID(reg_val);
+        data->client = client;
+        data->pdata = pdata;
+        data->id = id->driver_data;
+        data->current_brightness = 0;
+        i2c_set_clientdata(client, data);
+
+        memset(&props, 0, sizeof(props));
+        props.max_brightness = ADP8860_MAX_BRIGHTNESS;
+
+        mutex_init(&data->lock);
+
+        bl = backlight_device_register(dev_driver_string(&client->dev),
+                        &client->dev, data, &adp8860_bl_ops, &props);
+        if (IS_ERR(bl)) {
+                dev_err(&client->dev, "failed to register backlight\n");
+                ret = PTR_ERR(bl);
+                goto out2;
+        }
+
+        bl->props.max_brightness =
+                bl->props.brightness = ADP8860_MAX_BRIGHTNESS;
+
+        data->bl = bl;
+
+        if (data->en_ambl_sens)
+                ret = sysfs_create_group(&bl->dev.kobj,
+                        &adp8860_bl_attr_group);
+
+        if (ret) {
+                dev_err(&client->dev, "failed to register sysfs\n");
+                goto out1;
+        }
+
+        ret = adp8860_bl_setup(bl);
+        if (ret) {
+                ret = -EIO;
+                goto out;
+        }
+
+        backlight_update_status(bl);
+
+        dev_info(&client->dev, "%s Rev.%d Backlight\n",
+                client->name, data->revid);
+
+        if (pdata->num_leds)
+                adp8860_led_probe(client);
+
+        return 0;
+
+out:
+        if (data->en_ambl_sens)
+                sysfs_remove_group(&data->bl->dev.kobj,
+                        &adp8860_bl_attr_group);
+out1:
+        backlight_device_unregister(bl);
+out2:
+        i2c_set_clientdata(client, NULL);
+        kfree(data);
+
+        return ret;
+}
+
+static int __devexit adp8860_remove(struct i2c_client *client)
+{
+        struct adp8860_bl *data = i2c_get_clientdata(client);
+
+        adp8860_clr_bits(client, ADP8860_MDCR, NSTBY);
+
+        if (data->led)
+                adp8860_led_remove(client);
+
+        if (data->en_ambl_sens)
+                sysfs_remove_group(&data->bl->dev.kobj,
+                        &adp8860_bl_attr_group);
+
+        backlight_device_unregister(data->bl);
+        i2c_set_clientdata(client, NULL);
+        kfree(data);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int adp8860_i2c_suspend(struct i2c_client *client, pm_message_t message)
+{
+        adp8860_clr_bits(client, ADP8860_MDCR, NSTBY);
+
+        return 0;
+}
+
+static int adp8860_i2c_resume(struct i2c_client *client)
+{
+        adp8860_set_bits(client, ADP8860_MDCR, NSTBY);
+
+        return 0;
+}
+#else
+#define adp8860_i2c_suspend NULL
+#define adp8860_i2c_resume NULL
+#endif
+
+static const struct i2c_device_id adp8860_id[] = {
+        { "adp8860", adp8860 },
+        { "adp8861", adp8861 },
+        { "adp8863", adp8863 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, adp8860_id);
+
+static struct i2c_driver adp8860_driver = {
+        .driver = {
+                .name = KBUILD_MODNAME,
+        },
+        .probe    = adp8860_probe,
+        .remove   = __devexit_p(adp8860_remove),
+        .suspend = adp8860_i2c_suspend,
+        .resume  = adp8860_i2c_resume,
+        .id_table = adp8860_id,
+};
+
+static int __init adp8860_init(void)
+{
+        return i2c_add_driver(&adp8860_driver);
+}
+module_init(adp8860_init);
+
+static void __exit adp8860_exit(void)
+{
+        i2c_del_driver(&adp8860_driver);
+}
+module_exit(adp8860_exit);
+
+MODULE_LICENSE("GPL v2");
+MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
+MODULE_DESCRIPTION("ADP8860 Backlight driver");
+MODULE_ALIAS("i2c:adp8860-backlight");
diff --git a/drivers/video/backlight/adx_bl.c b/drivers/video/backlight/adx_bl.c
index 7f4a7c30a98b..fe9af129c5dd 100644
--- a/drivers/video/backlight/adx_bl.c
+++ b/drivers/video/backlight/adx_bl.c
@@ -107,8 +107,8 @@ static int __devinit adx_backlight_probe(struct platform_device *pdev)
         props.max_brightness = 0xff;
         bldev = backlight_device_register(dev_name(&pdev->dev), &pdev->dev,
                                           bl, &adx_backlight_ops, &props);
-        if (!bldev) {
-                ret = -ENOMEM;
+        if (IS_ERR(bldev)) {
+                ret = PTR_ERR(bldev);
                 goto out;
         }
 
diff --git a/drivers/video/backlight/ep93xx_bl.c b/drivers/video/backlight/ep93xx_bl.c
new file mode 100644
index 000000000000..b0cc49184803
--- /dev/null
+++ b/drivers/video/backlight/ep93xx_bl.c
@@ -0,0 +1,160 @@
+/*
+ * Driver for the Cirrus EP93xx lcd backlight
+ *
+ * Copyright (c) 2010 H Hartley Sweeten <hsweeten@visionengravers.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 driver controls the pulse width modulated brightness control output,
+ * BRIGHT, on the Cirrus EP9307, EP9312, and EP9315 processors.
+ */
+
+
+#include <linux/platform_device.h>
+#include <linux/io.h>
+#include <linux/fb.h>
+#include <linux/backlight.h>
+
+#include <mach/hardware.h>
+
+#define EP93XX_RASTER_REG(x)            (EP93XX_RASTER_BASE + (x))
+#define EP93XX_RASTER_BRIGHTNESS        EP93XX_RASTER_REG(0x20)
+
+#define EP93XX_MAX_COUNT                255
+#define EP93XX_MAX_BRIGHT               255
+#define EP93XX_DEF_BRIGHT               128
+
+struct ep93xxbl {
+        void __iomem *mmio;
+        int brightness;
+};
+
+static int ep93xxbl_set(struct backlight_device *bl, int brightness)
+{
+        struct ep93xxbl *ep93xxbl = bl_get_data(bl);
+
+        __raw_writel((brightness << 8) | EP93XX_MAX_COUNT, ep93xxbl->mmio);
+
+        ep93xxbl->brightness = brightness;
+
+        return 0;
+}
+
+static int ep93xxbl_update_status(struct backlight_device *bl)
+{
+        int brightness = bl->props.brightness;
+
+        if (bl->props.power != FB_BLANK_UNBLANK ||
+            bl->props.fb_blank != FB_BLANK_UNBLANK)
+                brightness = 0;
+
+        return ep93xxbl_set(bl, brightness);
+}
+
+static int ep93xxbl_get_brightness(struct backlight_device *bl)
+{
+        struct ep93xxbl *ep93xxbl = bl_get_data(bl);
+
+        return ep93xxbl->brightness;
+}
+
+static const struct backlight_ops ep93xxbl_ops = {
+        .update_status  = ep93xxbl_update_status,
+        .get_brightness = ep93xxbl_get_brightness,
+};
+
+static int __init ep93xxbl_probe(struct platform_device *dev)
+{
+        struct ep93xxbl *ep93xxbl;
+        struct backlight_device *bl;
+        struct backlight_properties props;
+
+        ep93xxbl = devm_kzalloc(&dev->dev, sizeof(*ep93xxbl), GFP_KERNEL);
+        if (!ep93xxbl)
+                return -ENOMEM;
+
+        /*
+         * This register is located in the range already ioremap'ed by
+         * the framebuffer driver.  A MFD driver seems a bit of overkill
+         * to handle this so use the static I/O mapping; this address
+         * is already virtual.
+         *
+         * NOTE: No locking is required; the framebuffer does not touch
+         * this register.
+         */
+        ep93xxbl->mmio = EP93XX_RASTER_BRIGHTNESS;
+
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.max_brightness = EP93XX_MAX_BRIGHT;
+        bl = backlight_device_register(dev->name, &dev->dev, ep93xxbl,
+                                       &ep93xxbl_ops, &props);
+        if (IS_ERR(bl))
+                return PTR_ERR(bl);
+
+        bl->props.brightness = EP93XX_DEF_BRIGHT;
+
+        platform_set_drvdata(dev, bl);
+
+        ep93xxbl_update_status(bl);
+
+        return 0;
+}
+
+static int ep93xxbl_remove(struct platform_device *dev)
+{
+        struct backlight_device *bl = platform_get_drvdata(dev);
+
+        backlight_device_unregister(bl);
+        platform_set_drvdata(dev, NULL);
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int ep93xxbl_suspend(struct platform_device *dev, pm_message_t state)
+{
+        struct backlight_device *bl = platform_get_drvdata(dev);
+
+        return ep93xxbl_set(bl, 0);
+}
+
+static int ep93xxbl_resume(struct platform_device *dev)
+{
+        struct backlight_device *bl = platform_get_drvdata(dev);
+
+        backlight_update_status(bl);
+        return 0;
+}
+#else
+#define ep93xxbl_suspend        NULL
+#define ep93xxbl_resume         NULL
+#endif
+
+static struct platform_driver ep93xxbl_driver = {
+        .driver         = {
+                .name   = "ep93xx-bl",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = ep93xxbl_probe,
+        .remove         = __devexit_p(ep93xxbl_remove),
+        .suspend        = ep93xxbl_suspend,
+        .resume         = ep93xxbl_resume,
+};
+
+static int __init ep93xxbl_init(void)
+{
+        return platform_driver_register(&ep93xxbl_driver);
+}
+module_init(ep93xxbl_init);
+
+static void __exit ep93xxbl_exit(void)
+{
+        platform_driver_unregister(&ep93xxbl_driver);
+}
+module_exit(ep93xxbl_exit);
+
+MODULE_DESCRIPTION("EP93xx Backlight Driver");
+MODULE_AUTHOR("H Hartley Sweeten <hsweeten@visionengravers.com>");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:ep93xx-bl");
diff --git a/drivers/video/backlight/l4f00242t03.c b/drivers/video/backlight/l4f00242t03.c
index bcdb12c93efd..9093ef0fa869 100644
--- a/drivers/video/backlight/l4f00242t03.c
+++ b/drivers/video/backlight/l4f00242t03.c
@@ -125,8 +125,7 @@ static int __devinit l4f00242t03_probe(struct spi_device *spi)
 
         if (priv == NULL) {
                 dev_err(&spi->dev, "No memory for this device.\n");
-                ret = -ENOMEM;
-                goto err;
+                return -ENOMEM;
         }
 
         dev_set_drvdata(&spi->dev, priv);
@@ -139,7 +138,7 @@ static int __devinit l4f00242t03_probe(struct spi_device *spi)
         if (ret) {
                 dev_err(&spi->dev,
                         "Unable to get the lcd l4f00242t03 reset gpio.\n");
-                return ret;
+                goto err;
         }
 
         ret = gpio_direction_output(pdata->reset_gpio, 1);
@@ -151,7 +150,7 @@ static int __devinit l4f00242t03_probe(struct spi_device *spi)
         if (ret) {
                 dev_err(&spi->dev,
                         "Unable to get the lcd l4f00242t03 data en gpio.\n");
-                return ret;
+                goto err2;
         }
 
         ret = gpio_direction_output(pdata->data_enable_gpio, 0);
@@ -222,9 +221,9 @@ static int __devexit l4f00242t03_remove(struct spi_device *spi)
         gpio_free(pdata->reset_gpio);
 
         if (priv->io_reg)
-                regulator_put(priv->core_reg);
-        if (priv->core_reg)
                 regulator_put(priv->io_reg);
+        if (priv->core_reg)
+                regulator_put(priv->core_reg);
 
         kfree(priv);
 
diff --git a/drivers/video/backlight/max8925_bl.c b/drivers/video/backlight/max8925_bl.c
index b5accc957ad3..b2b2c7ba1f63 100644
--- a/drivers/video/backlight/max8925_bl.c
+++ b/drivers/video/backlight/max8925_bl.c
@@ -162,6 +162,7 @@ static int __devinit max8925_backlight_probe(struct platform_device *pdev)
         backlight_update_status(bl);
         return 0;
 out:
+        backlight_device_unregister(bl);
         kfree(data);
         return ret;
 }
diff --git a/drivers/video/backlight/mbp_nvidia_bl.c b/drivers/video/backlight/mbp_nvidia_bl.c
index 1b5d3fe6bbbc..9fb533f6373e 100644
--- a/drivers/video/backlight/mbp_nvidia_bl.c
+++ b/drivers/video/backlight/mbp_nvidia_bl.c
@@ -141,7 +141,7 @@ static const struct dmi_system_id __initdata mbp_device_table[] = {
                 .callback       = mbp_dmi_match,
                 .ident          = "MacBook 1,1",
                 .matches        = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
+                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Computer, Inc."),
                         DMI_MATCH(DMI_PRODUCT_NAME, "MacBook1,1"),
                 },
                 .driver_data    = (void *)&intel_chipset_data,
@@ -184,6 +184,42 @@ static const struct dmi_system_id __initdata mbp_device_table[] = {
         },
         {
                 .callback       = mbp_dmi_match,
+                .ident          = "MacBookPro 1,1",
+                .matches        = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro1,1"),
+                },
+                .driver_data    = (void *)&intel_chipset_data,
+        },
+        {
+                .callback       = mbp_dmi_match,
+                .ident          = "MacBookPro 1,2",
+                .matches        = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro1,2"),
+                },
+                .driver_data    = (void *)&intel_chipset_data,
+        },
+        {
+                .callback       = mbp_dmi_match,
+                .ident          = "MacBookPro 2,1",
+                .matches        = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro2,1"),
+                },
+                .driver_data    = (void *)&intel_chipset_data,
+        },
+        {
+                .callback       = mbp_dmi_match,
+                .ident          = "MacBookPro 2,2",
+                .matches        = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro2,2"),
+                },
+                .driver_data    = (void *)&intel_chipset_data,
+        },
+        {
+                .callback       = mbp_dmi_match,
                 .ident          = "MacBookPro 3,1",
                 .matches        = {
                         DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
@@ -238,6 +274,15 @@ static const struct dmi_system_id __initdata mbp_device_table[] = {
         },
         {
                 .callback       = mbp_dmi_match,
+                .ident          = "MacBook 6,1",
+                .matches        = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "MacBook6,1"),
+                },
+                .driver_data    = (void *)&nvidia_chipset_data,
+        },
+        {
+                .callback       = mbp_dmi_match,
                 .ident          = "MacBookAir 2,1",
                 .matches        = {
                         DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
diff --git a/drivers/video/backlight/pcf50633-backlight.c b/drivers/video/backlight/pcf50633-backlight.c
new file mode 100644
index 000000000000..3c424f7efdcc
--- /dev/null
+++ b/drivers/video/backlight/pcf50633-backlight.c
@@ -0,0 +1,190 @@
+/*
+ *  Copyright (C) 2009-2010, Lars-Peter Clausen <lars@metafoo.de>
+ *      PCF50633 backlight device driver
+ *
+ *  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.
+ *
+ *  You should have received a copy of the  GNU General Public License along
+ *  with this program; if not, write  to the Free Software Foundation, Inc.,
+ *  675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/platform_device.h>
+
+#include <linux/backlight.h>
+#include <linux/fb.h>
+
+#include <linux/mfd/pcf50633/core.h>
+#include <linux/mfd/pcf50633/backlight.h>
+
+struct pcf50633_bl {
+        struct pcf50633 *pcf;
+        struct backlight_device *bl;
+
+        unsigned int brightness;
+        unsigned int brightness_limit;
+};
+
+/*
+ * pcf50633_bl_set_brightness_limit
+ *
+ * Update the brightness limit for the pc50633 backlight. The actual brightness
+ * will not go above the limit. This is useful to limit power drain for example
+ * on low battery.
+ *
+ * @dev: Pointer to a pcf50633 device
+ * @limit: The brightness limit. Valid values are 0-63
+ */
+int pcf50633_bl_set_brightness_limit(struct pcf50633 *pcf, unsigned int limit)
+{
+        struct pcf50633_bl *pcf_bl = platform_get_drvdata(pcf->bl_pdev);
+
+        if (!pcf_bl)
+                return -ENODEV;
+
+        pcf_bl->brightness_limit = limit & 0x3f;
+        backlight_update_status(pcf_bl->bl);
+
+    return 0;
+}
+
+static int pcf50633_bl_update_status(struct backlight_device *bl)
+{
+        struct pcf50633_bl *pcf_bl = bl_get_data(bl);
+        unsigned int new_brightness;
+
+
+        if (bl->props.state & (BL_CORE_SUSPENDED | BL_CORE_FBBLANK) ||
+                bl->props.power != FB_BLANK_UNBLANK)
+                new_brightness = 0;
+        else if (bl->props.brightness < pcf_bl->brightness_limit)
+                new_brightness = bl->props.brightness;
+        else
+                new_brightness = pcf_bl->brightness_limit;
+
+
+        if (pcf_bl->brightness == new_brightness)
+                return 0;
+
+        if (new_brightness) {
+                pcf50633_reg_write(pcf_bl->pcf, PCF50633_REG_LEDOUT,
+                                        new_brightness);
+                if (!pcf_bl->brightness)
+                        pcf50633_reg_write(pcf_bl->pcf, PCF50633_REG_LEDENA, 1);
+        } else {
+                pcf50633_reg_write(pcf_bl->pcf, PCF50633_REG_LEDENA, 0);
+        }
+
+        pcf_bl->brightness = new_brightness;
+
+        return 0;
+}
+
+static int pcf50633_bl_get_brightness(struct backlight_device *bl)
+{
+        struct pcf50633_bl *pcf_bl = bl_get_data(bl);
+        return pcf_bl->brightness;
+}
+
+static const struct backlight_ops pcf50633_bl_ops = {
+        .get_brightness = pcf50633_bl_get_brightness,
+        .update_status  = pcf50633_bl_update_status,
+        .options        = BL_CORE_SUSPENDRESUME,
+};
+
+static int __devinit pcf50633_bl_probe(struct platform_device *pdev)
+{
+        int ret;
+        struct pcf50633_bl *pcf_bl;
+        struct device *parent = pdev->dev.parent;
+        struct pcf50633_platform_data *pcf50633_data = parent->platform_data;
+        struct pcf50633_bl_platform_data *pdata = pcf50633_data->backlight_data;
+        struct backlight_properties bl_props;
+
+        pcf_bl = kzalloc(sizeof(*pcf_bl), GFP_KERNEL);
+        if (!pcf_bl)
+                return -ENOMEM;
+
+        bl_props.max_brightness = 0x3f;
+        bl_props.power = FB_BLANK_UNBLANK;
+
+        if (pdata) {
+                bl_props.brightness = pdata->default_brightness;
+                pcf_bl->brightness_limit = pdata->default_brightness_limit;
+        } else {
+                bl_props.brightness = 0x3f;
+                pcf_bl->brightness_limit = 0x3f;
+        }
+
+        pcf_bl->pcf = dev_to_pcf50633(pdev->dev.parent);
+
+        pcf_bl->bl = backlight_device_register(pdev->name, &pdev->dev, pcf_bl,
+                                                &pcf50633_bl_ops, &bl_props);
+
+        if (IS_ERR(pcf_bl->bl)) {
+                ret = PTR_ERR(pcf_bl->bl);
+                goto err_free;
+        }
+
+        platform_set_drvdata(pdev, pcf_bl);
+
+        pcf50633_reg_write(pcf_bl->pcf, PCF50633_REG_LEDDIM, pdata->ramp_time);
+
+        /* Should be different from bl_props.brightness, so we do not exit
+         * update_status early the first time it's called */
+        pcf_bl->brightness = pcf_bl->bl->props.brightness + 1;
+
+        backlight_update_status(pcf_bl->bl);
+
+        return 0;
+
+err_free:
+        kfree(pcf_bl);
+
+        return ret;
+}
+
+static int __devexit pcf50633_bl_remove(struct platform_device *pdev)
+{
+        struct pcf50633_bl *pcf_bl = platform_get_drvdata(pdev);
+
+        backlight_device_unregister(pcf_bl->bl);
+
+        platform_set_drvdata(pdev, NULL);
+
+        kfree(pcf_bl);
+
+        return 0;
+}
+
+static struct platform_driver pcf50633_bl_driver = {
+        .probe =        pcf50633_bl_probe,
+        .remove =       __devexit_p(pcf50633_bl_remove),
+        .driver = {
+                .name = "pcf50633-backlight",
+        },
+};
+
+static int __init pcf50633_bl_init(void)
+{
+        return platform_driver_register(&pcf50633_bl_driver);
+}
+module_init(pcf50633_bl_init);
+
+static void __exit pcf50633_bl_exit(void)
+{
+        platform_driver_unregister(&pcf50633_bl_driver);
+}
+module_exit(pcf50633_bl_exit);
+
+MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
+MODULE_DESCRIPTION("PCF50633 backlight driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:pcf50633-backlight");
diff --git a/drivers/video/backlight/s6e63m0.c b/drivers/video/backlight/s6e63m0.c
new file mode 100644
index 000000000000..a3128c9cb7ad
--- /dev/null
+++ b/drivers/video/backlight/s6e63m0.c
@@ -0,0 +1,920 @@
+/*
+ * S6E63M0 AMOLED LCD panel driver.
+ *
+ * Author: InKi Dae  <inki.dae@samsung.com>
+ *
+ * Derived from drivers/video/omap/lcd-apollon.c
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ */
+
+#include <linux/wait.h>
+#include <linux/fb.h>
+#include <linux/delay.h>
+#include <linux/gpio.h>
+#include <linux/spi/spi.h>
+#include <linux/irq.h>
+#include <linux/interrupt.h>
+#include <linux/kernel.h>
+#include <linux/lcd.h>
+#include <linux/backlight.h>
+
+#include "s6e63m0_gamma.h"
+
+#define SLEEPMSEC               0x1000
+#define ENDDEF                  0x2000
+#define DEFMASK                 0xFF00
+#define COMMAND_ONLY            0xFE
+#define DATA_ONLY               0xFF
+
+#define MIN_BRIGHTNESS          0
+#define MAX_BRIGHTNESS          10
+
+#define POWER_IS_ON(pwr)        ((pwr) <= FB_BLANK_NORMAL)
+
+struct s6e63m0 {
+        struct device                   *dev;
+        struct spi_device               *spi;
+        unsigned int                    power;
+        unsigned int                    current_brightness;
+        unsigned int                    gamma_mode;
+        unsigned int                    gamma_table_count;
+        struct lcd_device               *ld;
+        struct backlight_device         *bd;
+        struct lcd_platform_data        *lcd_pd;
+};
+
+static const unsigned short SEQ_PANEL_CONDITION_SET[] = {
+        0xF8, 0x01,
+        DATA_ONLY, 0x27,
+        DATA_ONLY, 0x27,
+        DATA_ONLY, 0x07,
+        DATA_ONLY, 0x07,
+        DATA_ONLY, 0x54,
+        DATA_ONLY, 0x9f,
+        DATA_ONLY, 0x63,
+        DATA_ONLY, 0x86,
+        DATA_ONLY, 0x1a,
+        DATA_ONLY, 0x33,
+        DATA_ONLY, 0x0d,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x00,
+
+        ENDDEF, 0x0000
+};
+
+static const unsigned short SEQ_DISPLAY_CONDITION_SET[] = {
+        0xf2, 0x02,
+        DATA_ONLY, 0x03,
+        DATA_ONLY, 0x1c,
+        DATA_ONLY, 0x10,
+        DATA_ONLY, 0x10,
+
+        0xf7, 0x03,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x00,
+
+        ENDDEF, 0x0000
+};
+
+static const unsigned short SEQ_GAMMA_SETTING[] = {
+        0xfa, 0x00,
+        DATA_ONLY, 0x18,
+        DATA_ONLY, 0x08,
+        DATA_ONLY, 0x24,
+        DATA_ONLY, 0x64,
+        DATA_ONLY, 0x56,
+        DATA_ONLY, 0x33,
+        DATA_ONLY, 0xb6,
+        DATA_ONLY, 0xba,
+        DATA_ONLY, 0xa8,
+        DATA_ONLY, 0xac,
+        DATA_ONLY, 0xb1,
+        DATA_ONLY, 0x9d,
+        DATA_ONLY, 0xc1,
+        DATA_ONLY, 0xc1,
+        DATA_ONLY, 0xb7,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x9c,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x9f,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0xd6,
+
+        0xfa, 0x01,
+
+        ENDDEF, 0x0000
+};
+
+static const unsigned short SEQ_ETC_CONDITION_SET[] = {
+        0xf6, 0x00,
+        DATA_ONLY, 0x8c,
+        DATA_ONLY, 0x07,
+
+        0xb3, 0xc,
+
+        0xb5, 0x2c,
+        DATA_ONLY, 0x12,
+        DATA_ONLY, 0x0c,
+        DATA_ONLY, 0x0a,
+        DATA_ONLY, 0x10,
+        DATA_ONLY, 0x0e,
+        DATA_ONLY, 0x17,
+        DATA_ONLY, 0x13,
+        DATA_ONLY, 0x1f,
+        DATA_ONLY, 0x1a,
+        DATA_ONLY, 0x2a,
+        DATA_ONLY, 0x24,
+        DATA_ONLY, 0x1f,
+        DATA_ONLY, 0x1b,
+        DATA_ONLY, 0x1a,
+        DATA_ONLY, 0x17,
+
+        DATA_ONLY, 0x2b,
+        DATA_ONLY, 0x26,
+        DATA_ONLY, 0x22,
+        DATA_ONLY, 0x20,
+        DATA_ONLY, 0x3a,
+        DATA_ONLY, 0x34,
+        DATA_ONLY, 0x30,
+        DATA_ONLY, 0x2c,
+        DATA_ONLY, 0x29,
+        DATA_ONLY, 0x26,
+        DATA_ONLY, 0x25,
+        DATA_ONLY, 0x23,
+        DATA_ONLY, 0x21,
+        DATA_ONLY, 0x20,
+        DATA_ONLY, 0x1e,
+        DATA_ONLY, 0x1e,
+
+        0xb6, 0x00,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x11,
+        DATA_ONLY, 0x22,
+        DATA_ONLY, 0x33,
+        DATA_ONLY, 0x44,
+        DATA_ONLY, 0x44,
+        DATA_ONLY, 0x44,
+
+        DATA_ONLY, 0x55,
+        DATA_ONLY, 0x55,
+        DATA_ONLY, 0x66,
+        DATA_ONLY, 0x66,
+        DATA_ONLY, 0x66,
+        DATA_ONLY, 0x66,
+        DATA_ONLY, 0x66,
+        DATA_ONLY, 0x66,
+
+        0xb7, 0x2c,
+        DATA_ONLY, 0x12,
+        DATA_ONLY, 0x0c,
+        DATA_ONLY, 0x0a,
+        DATA_ONLY, 0x10,
+        DATA_ONLY, 0x0e,
+        DATA_ONLY, 0x17,
+        DATA_ONLY, 0x13,
+        DATA_ONLY, 0x1f,
+        DATA_ONLY, 0x1a,
+        DATA_ONLY, 0x2a,
+        DATA_ONLY, 0x24,
+        DATA_ONLY, 0x1f,
+        DATA_ONLY, 0x1b,
+        DATA_ONLY, 0x1a,
+        DATA_ONLY, 0x17,
+
+        DATA_ONLY, 0x2b,
+        DATA_ONLY, 0x26,
+        DATA_ONLY, 0x22,
+        DATA_ONLY, 0x20,
+        DATA_ONLY, 0x3a,
+        DATA_ONLY, 0x34,
+        DATA_ONLY, 0x30,
+        DATA_ONLY, 0x2c,
+        DATA_ONLY, 0x29,
+        DATA_ONLY, 0x26,
+        DATA_ONLY, 0x25,
+        DATA_ONLY, 0x23,
+        DATA_ONLY, 0x21,
+        DATA_ONLY, 0x20,
+        DATA_ONLY, 0x1e,
+        DATA_ONLY, 0x1e,
+
+        0xb8, 0x00,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x11,
+        DATA_ONLY, 0x22,
+        DATA_ONLY, 0x33,
+        DATA_ONLY, 0x44,
+        DATA_ONLY, 0x44,
+        DATA_ONLY, 0x44,
+
+        DATA_ONLY, 0x55,
+        DATA_ONLY, 0x55,
+        DATA_ONLY, 0x66,
+        DATA_ONLY, 0x66,
+        DATA_ONLY, 0x66,
+        DATA_ONLY, 0x66,
+        DATA_ONLY, 0x66,
+        DATA_ONLY, 0x66,
+
+        0xb9, 0x2c,
+        DATA_ONLY, 0x12,
+        DATA_ONLY, 0x0c,
+        DATA_ONLY, 0x0a,
+        DATA_ONLY, 0x10,
+        DATA_ONLY, 0x0e,
+        DATA_ONLY, 0x17,
+        DATA_ONLY, 0x13,
+        DATA_ONLY, 0x1f,
+        DATA_ONLY, 0x1a,
+        DATA_ONLY, 0x2a,
+        DATA_ONLY, 0x24,
+        DATA_ONLY, 0x1f,
+        DATA_ONLY, 0x1b,
+        DATA_ONLY, 0x1a,
+        DATA_ONLY, 0x17,
+
+        DATA_ONLY, 0x2b,
+        DATA_ONLY, 0x26,
+        DATA_ONLY, 0x22,
+        DATA_ONLY, 0x20,
+        DATA_ONLY, 0x3a,
+        DATA_ONLY, 0x34,
+        DATA_ONLY, 0x30,
+        DATA_ONLY, 0x2c,
+        DATA_ONLY, 0x29,
+        DATA_ONLY, 0x26,
+        DATA_ONLY, 0x25,
+        DATA_ONLY, 0x23,
+        DATA_ONLY, 0x21,
+        DATA_ONLY, 0x20,
+        DATA_ONLY, 0x1e,
+        DATA_ONLY, 0x1e,
+
+        0xba, 0x00,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x11,
+        DATA_ONLY, 0x22,
+        DATA_ONLY, 0x33,
+        DATA_ONLY, 0x44,
+        DATA_ONLY, 0x44,
+        DATA_ONLY, 0x44,
+
+        DATA_ONLY, 0x55,
+        DATA_ONLY, 0x55,
+        DATA_ONLY, 0x66,
+        DATA_ONLY, 0x66,
+        DATA_ONLY, 0x66,
+        DATA_ONLY, 0x66,
+        DATA_ONLY, 0x66,
+        DATA_ONLY, 0x66,
+
+        0xc1, 0x4d,
+        DATA_ONLY, 0x96,
+        DATA_ONLY, 0x1d,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x01,
+        DATA_ONLY, 0xdf,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x03,
+        DATA_ONLY, 0x1f,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x00,
+        DATA_ONLY, 0x03,
+        DATA_ONLY, 0x06,
+        DATA_ONLY, 0x09,
+        DATA_ONLY, 0x0d,
+        DATA_ONLY, 0x0f,
+        DATA_ONLY, 0x12,
+        DATA_ONLY, 0x15,
+        DATA_ONLY, 0x18,
+
+        0xb2, 0x10,
+        DATA_ONLY, 0x10,
+        DATA_ONLY, 0x0b,
+        DATA_ONLY, 0x05,
+
+        ENDDEF, 0x0000
+};
+
+static const unsigned short SEQ_ACL_ON[] = {
+        /* ACL on */
+        0xc0, 0x01,
+
+        ENDDEF, 0x0000
+};
+
+static const unsigned short SEQ_ACL_OFF[] = {
+        /* ACL off */
+        0xc0, 0x00,
+
+        ENDDEF, 0x0000
+};
+
+static const unsigned short SEQ_ELVSS_ON[] = {
+        /* ELVSS on */
+        0xb1, 0x0b,
+
+        ENDDEF, 0x0000
+};
+
+static const unsigned short SEQ_ELVSS_OFF[] = {
+        /* ELVSS off */
+        0xb1, 0x0a,
+
+        ENDDEF, 0x0000
+};
+
+static const unsigned short SEQ_STAND_BY_OFF[] = {
+        0x11, COMMAND_ONLY,
+
+        ENDDEF, 0x0000
+};
+
+static const unsigned short SEQ_STAND_BY_ON[] = {
+        0x10, COMMAND_ONLY,
+
+        ENDDEF, 0x0000
+};
+
+static const unsigned short SEQ_DISPLAY_ON[] = {
+        0x29, COMMAND_ONLY,
+
+        ENDDEF, 0x0000
+};
+
+
+static int s6e63m0_spi_write_byte(struct s6e63m0 *lcd, int addr, int data)
+{
+        u16 buf[1];
+        struct spi_message msg;
+
+        struct spi_transfer xfer = {
+                .len            = 2,
+                .tx_buf         = buf,
+        };
+
+        buf[0] = (addr << 8) | data;
+
+        spi_message_init(&msg);
+        spi_message_add_tail(&xfer, &msg);
+
+        return spi_sync(lcd->spi, &msg);
+}
+
+static int s6e63m0_spi_write(struct s6e63m0 *lcd, unsigned char address,
+        unsigned char command)
+{
+        int ret = 0;
+
+        if (address != DATA_ONLY)
+                ret = s6e63m0_spi_write_byte(lcd, 0x0, address);
+        if (command != COMMAND_ONLY)
+                ret = s6e63m0_spi_write_byte(lcd, 0x1, command);
+
+        return ret;
+}
+
+static int s6e63m0_panel_send_sequence(struct s6e63m0 *lcd,
+        const unsigned short *wbuf)
+{
+        int ret = 0, i = 0;
+
+        while ((wbuf[i] & DEFMASK) != ENDDEF) {
+                if ((wbuf[i] & DEFMASK) != SLEEPMSEC) {
+                        ret = s6e63m0_spi_write(lcd, wbuf[i], wbuf[i+1]);
+                        if (ret)
+                                break;
+                } else
+                        udelay(wbuf[i+1]*1000);
+                i += 2;
+        }
+
+        return ret;
+}
+
+static int _s6e63m0_gamma_ctl(struct s6e63m0 *lcd, const unsigned int *gamma)
+{
+        unsigned int i = 0;
+        int ret = 0;
+
+        /* disable gamma table updating. */
+        ret = s6e63m0_spi_write(lcd, 0xfa, 0x00);
+        if (ret) {
+                dev_err(lcd->dev, "failed to disable gamma table updating.\n");
+                goto gamma_err;
+        }
+
+        for (i = 0 ; i < GAMMA_TABLE_COUNT; i++) {
+                ret = s6e63m0_spi_write(lcd, DATA_ONLY, gamma[i]);
+                if (ret) {
+                        dev_err(lcd->dev, "failed to set gamma table.\n");
+                        goto gamma_err;
+                }
+        }
+
+        /* update gamma table. */
+        ret = s6e63m0_spi_write(lcd, 0xfa, 0x01);
+        if (ret)
+                dev_err(lcd->dev, "failed to update gamma table.\n");
+
+gamma_err:
+        return ret;
+}
+
+static int s6e63m0_gamma_ctl(struct s6e63m0 *lcd, int gamma)
+{
+        int ret = 0;
+
+        ret = _s6e63m0_gamma_ctl(lcd, gamma_table.gamma_22_table[gamma]);
+
+        return ret;
+}
+
+
+static int s6e63m0_ldi_init(struct s6e63m0 *lcd)
+{
+        int ret, i;
+        const unsigned short *init_seq[] = {
+                SEQ_PANEL_CONDITION_SET,
+                SEQ_DISPLAY_CONDITION_SET,
+                SEQ_GAMMA_SETTING,
+                SEQ_ETC_CONDITION_SET,
+                SEQ_ACL_ON,
+                SEQ_ELVSS_ON,
+        };
+
+        for (i = 0; i < ARRAY_SIZE(init_seq); i++) {
+                ret = s6e63m0_panel_send_sequence(lcd, init_seq[i]);
+                if (ret)
+                        break;
+        }
+
+        return ret;
+}
+
+static int s6e63m0_ldi_enable(struct s6e63m0 *lcd)
+{
+        int ret = 0, i;
+        const unsigned short *enable_seq[] = {
+                SEQ_STAND_BY_OFF,
+                SEQ_DISPLAY_ON,
+        };
+
+        for (i = 0; i < ARRAY_SIZE(enable_seq); i++) {
+                ret = s6e63m0_panel_send_sequence(lcd, enable_seq[i]);
+                if (ret)
+                        break;
+        }
+
+        return ret;
+}
+
+static int s6e63m0_ldi_disable(struct s6e63m0 *lcd)
+{
+        int ret;
+
+        ret = s6e63m0_panel_send_sequence(lcd, SEQ_STAND_BY_ON);
+
+        return ret;
+}
+
+static int s6e63m0_power_on(struct s6e63m0 *lcd)
+{
+        int ret = 0;
+        struct lcd_platform_data *pd = NULL;
+        struct backlight_device *bd = NULL;
+
+        pd = lcd->lcd_pd;
+        if (!pd) {
+                dev_err(lcd->dev, "platform data is NULL.\n");
+                return -EFAULT;
+        }
+
+        bd = lcd->bd;
+        if (!bd) {
+                dev_err(lcd->dev, "backlight device is NULL.\n");
+                return -EFAULT;
+        }
+
+        if (!pd->power_on) {
+                dev_err(lcd->dev, "power_on is NULL.\n");
+                return -EFAULT;
+        } else {
+                pd->power_on(lcd->ld, 1);
+                mdelay(pd->power_on_delay);
+        }
+
+        if (!pd->reset) {
+                dev_err(lcd->dev, "reset is NULL.\n");
+                return -EFAULT;
+        } else {
+                pd->reset(lcd->ld);
+                mdelay(pd->reset_delay);
+        }
+
+        ret = s6e63m0_ldi_init(lcd);
+        if (ret) {
+                dev_err(lcd->dev, "failed to initialize ldi.\n");
+                return ret;
+        }
+
+        ret = s6e63m0_ldi_enable(lcd);
+        if (ret) {
+                dev_err(lcd->dev, "failed to enable ldi.\n");
+                return ret;
+        }
+
+        /* set brightness to current value after power on or resume. */
+        ret = s6e63m0_gamma_ctl(lcd, bd->props.brightness);
+        if (ret) {
+                dev_err(lcd->dev, "lcd gamma setting failed.\n");
+                return ret;
+        }
+
+        return 0;
+}
+
+static int s6e63m0_power_off(struct s6e63m0 *lcd)
+{
+        int ret = 0;
+        struct lcd_platform_data *pd = NULL;
+
+        pd = lcd->lcd_pd;
+        if (!pd) {
+                dev_err(lcd->dev, "platform data is NULL.\n");
+                return -EFAULT;
+        }
+
+        ret = s6e63m0_ldi_disable(lcd);
+        if (ret) {
+                dev_err(lcd->dev, "lcd setting failed.\n");
+                return -EIO;
+        }
+
+        mdelay(pd->power_off_delay);
+
+        if (!pd->power_on) {
+                dev_err(lcd->dev, "power_on is NULL.\n");
+                return -EFAULT;
+        } else
+                pd->power_on(lcd->ld, 0);
+
+        return 0;
+}
+
+static int s6e63m0_power(struct s6e63m0 *lcd, int power)
+{
+        int ret = 0;
+
+        if (POWER_IS_ON(power) && !POWER_IS_ON(lcd->power))
+                ret = s6e63m0_power_on(lcd);
+        else if (!POWER_IS_ON(power) && POWER_IS_ON(lcd->power))
+                ret = s6e63m0_power_off(lcd);
+
+        if (!ret)
+                lcd->power = power;
+
+        return ret;
+}
+
+static int s6e63m0_set_power(struct lcd_device *ld, int power)
+{
+        struct s6e63m0 *lcd = lcd_get_data(ld);
+
+        if (power != FB_BLANK_UNBLANK && power != FB_BLANK_POWERDOWN &&
+                power != FB_BLANK_NORMAL) {
+                dev_err(lcd->dev, "power value should be 0, 1 or 4.\n");
+                return -EINVAL;
+        }
+
+        return s6e63m0_power(lcd, power);
+}
+
+static int s6e63m0_get_power(struct lcd_device *ld)
+{
+        struct s6e63m0 *lcd = lcd_get_data(ld);
+
+        return lcd->power;
+}
+
+static int s6e63m0_get_brightness(struct backlight_device *bd)
+{
+        return bd->props.brightness;
+}
+
+static int s6e63m0_set_brightness(struct backlight_device *bd)
+{
+        int ret = 0, brightness = bd->props.brightness;
+        struct s6e63m0 *lcd = bl_get_data(bd);
+
+        if (brightness < MIN_BRIGHTNESS ||
+                brightness > bd->props.max_brightness) {
+                dev_err(&bd->dev, "lcd brightness should be %d to %d.\n",
+                        MIN_BRIGHTNESS, MAX_BRIGHTNESS);
+                return -EINVAL;
+        }
+
+        ret = s6e63m0_gamma_ctl(lcd, bd->props.brightness);
+        if (ret) {
+                dev_err(&bd->dev, "lcd brightness setting failed.\n");
+                return -EIO;
+        }
+
+        return ret;
+}
+
+static struct lcd_ops s6e63m0_lcd_ops = {
+        .set_power = s6e63m0_set_power,
+        .get_power = s6e63m0_get_power,
+};
+
+static const struct backlight_ops s6e63m0_backlight_ops  = {
+        .get_brightness = s6e63m0_get_brightness,
+        .update_status = s6e63m0_set_brightness,
+};
+
+static ssize_t s6e63m0_sysfs_show_gamma_mode(struct device *dev,
+                                      struct device_attribute *attr, char *buf)
+{
+        struct s6e63m0 *lcd = dev_get_drvdata(dev);
+        char temp[10];
+
+        switch (lcd->gamma_mode) {
+        case 0:
+                sprintf(temp, "2.2 mode\n");
+                strcat(buf, temp);
+                break;
+        case 1:
+                sprintf(temp, "1.9 mode\n");
+                strcat(buf, temp);
+                break;
+        case 2:
+                sprintf(temp, "1.7 mode\n");
+                strcat(buf, temp);
+                break;
+        default:
+                dev_info(dev, "gamma mode could be 0:2.2, 1:1.9 or 2:1.7)n");
+                break;
+        }
+
+        return strlen(buf);
+}
+
+static ssize_t s6e63m0_sysfs_store_gamma_mode(struct device *dev,
+                                       struct device_attribute *attr,
+                                       const char *buf, size_t len)
+{
+        struct s6e63m0 *lcd = dev_get_drvdata(dev);
+        struct backlight_device *bd = NULL;
+        int brightness, rc;
+
+        rc = strict_strtoul(buf, 0, (unsigned long *)&lcd->gamma_mode);
+        if (rc < 0)
+                return rc;
+
+        bd = lcd->bd;
+
+        brightness = bd->props.brightness;
+
+        switch (lcd->gamma_mode) {
+        case 0:
+                _s6e63m0_gamma_ctl(lcd, gamma_table.gamma_22_table[brightness]);
+                break;
+        case 1:
+                _s6e63m0_gamma_ctl(lcd, gamma_table.gamma_19_table[brightness]);
+                break;
+        case 2:
+                _s6e63m0_gamma_ctl(lcd, gamma_table.gamma_17_table[brightness]);
+                break;
+        default:
+                dev_info(dev, "gamma mode could be 0:2.2, 1:1.9 or 2:1.7\n");
+                _s6e63m0_gamma_ctl(lcd, gamma_table.gamma_22_table[brightness]);
+                break;
+        }
+        return len;
+}
+
+static DEVICE_ATTR(gamma_mode, 0644,
+                s6e63m0_sysfs_show_gamma_mode, s6e63m0_sysfs_store_gamma_mode);
+
+static ssize_t s6e63m0_sysfs_show_gamma_table(struct device *dev,
+                                      struct device_attribute *attr, char *buf)
+{
+        struct s6e63m0 *lcd = dev_get_drvdata(dev);
+        char temp[3];
+
+        sprintf(temp, "%d\n", lcd->gamma_table_count);
+        strcpy(buf, temp);
+
+        return strlen(buf);
+}
+static DEVICE_ATTR(gamma_table, 0644,
+                s6e63m0_sysfs_show_gamma_table, NULL);
+
+static int __init s6e63m0_probe(struct spi_device *spi)
+{
+        int ret = 0;
+        struct s6e63m0 *lcd = NULL;
+        struct lcd_device *ld = NULL;
+        struct backlight_device *bd = NULL;
+
+        lcd = kzalloc(sizeof(struct s6e63m0), GFP_KERNEL);
+        if (!lcd)
+                return -ENOMEM;
+
+        /* s6e63m0 lcd panel uses 3-wire 9bits SPI Mode. */
+        spi->bits_per_word = 9;
+
+        ret = spi_setup(spi);
+        if (ret < 0) {
+                dev_err(&spi->dev, "spi setup failed.\n");
+                goto out_free_lcd;
+        }
+
+        lcd->spi = spi;
+        lcd->dev = &spi->dev;
+
+        lcd->lcd_pd = (struct lcd_platform_data *)spi->dev.platform_data;
+        if (!lcd->lcd_pd) {
+                dev_err(&spi->dev, "platform data is NULL.\n");
+                goto out_free_lcd;
+        }
+
+        ld = lcd_device_register("s6e63m0", &spi->dev, lcd, &s6e63m0_lcd_ops);
+        if (IS_ERR(ld)) {
+                ret = PTR_ERR(ld);
+                goto out_free_lcd;
+        }
+
+        lcd->ld = ld;
+
+        bd = backlight_device_register("s6e63m0bl-bl", &spi->dev, lcd,
+                &s6e63m0_backlight_ops, NULL);
+        if (IS_ERR(bd)) {
+                ret =  PTR_ERR(bd);
+                goto out_lcd_unregister;
+        }
+
+        bd->props.max_brightness = MAX_BRIGHTNESS;
+        bd->props.brightness = MAX_BRIGHTNESS;
+        lcd->bd = bd;
+
+        /*
+         * it gets gamma table count available so it gets user
+         * know that.
+         */
+        lcd->gamma_table_count =
+            sizeof(gamma_table) / (MAX_GAMMA_LEVEL * sizeof(int));
+
+        ret = device_create_file(&(spi->dev), &dev_attr_gamma_mode);
+        if (ret < 0)
+                dev_err(&(spi->dev), "failed to add sysfs entries\n");
+
+        ret = device_create_file(&(spi->dev), &dev_attr_gamma_table);
+        if (ret < 0)
+                dev_err(&(spi->dev), "failed to add sysfs entries\n");
+
+        /*
+         * if lcd panel was on from bootloader like u-boot then
+         * do not lcd on.
+         */
+        if (!lcd->lcd_pd->lcd_enabled) {
+                /*
+                 * if lcd panel was off from bootloader then
+                 * current lcd status is powerdown and then
+                 * it enables lcd panel.
+                 */
+                lcd->power = FB_BLANK_POWERDOWN;
+
+                s6e63m0_power(lcd, FB_BLANK_UNBLANK);
+        } else
+                lcd->power = FB_BLANK_UNBLANK;
+
+        dev_set_drvdata(&spi->dev, lcd);
+
+        dev_info(&spi->dev, "s6e63m0 panel driver has been probed.\n");
+
+        return 0;
+
+out_lcd_unregister:
+        lcd_device_unregister(ld);
+out_free_lcd:
+        kfree(lcd);
+        return ret;
+}
+
+static int __devexit s6e63m0_remove(struct spi_device *spi)
+{
+        struct s6e63m0 *lcd = dev_get_drvdata(&spi->dev);
+
+        s6e63m0_power(lcd, FB_BLANK_POWERDOWN);
+        lcd_device_unregister(lcd->ld);
+        kfree(lcd);
+
+        return 0;
+}
+
+#if defined(CONFIG_PM)
+unsigned int before_power;
+
+static int s6e63m0_suspend(struct spi_device *spi, pm_message_t mesg)
+{
+        int ret = 0;
+        struct s6e63m0 *lcd = dev_get_drvdata(&spi->dev);
+
+        dev_dbg(&spi->dev, "lcd->power = %d\n", lcd->power);
+
+        before_power = lcd->power;
+
+        /*
+         * when lcd panel is suspend, lcd panel becomes off
+         * regardless of status.
+         */
+        ret = s6e63m0_power(lcd, FB_BLANK_POWERDOWN);
+
+        return ret;
+}
+
+static int s6e63m0_resume(struct spi_device *spi)
+{
+        int ret = 0;
+        struct s6e63m0 *lcd = dev_get_drvdata(&spi->dev);
+
+        /*
+         * after suspended, if lcd panel status is FB_BLANK_UNBLANK
+         * (at that time, before_power is FB_BLANK_UNBLANK) then
+         * it changes that status to FB_BLANK_POWERDOWN to get lcd on.
+         */
+        if (before_power == FB_BLANK_UNBLANK)
+                lcd->power = FB_BLANK_POWERDOWN;
+
+        dev_dbg(&spi->dev, "before_power = %d\n", before_power);
+
+        ret = s6e63m0_power(lcd, before_power);
+
+        return ret;
+}
+#else
+#define s6e63m0_suspend         NULL
+#define s6e63m0_resume          NULL
+#endif
+
+/* Power down all displays on reboot, poweroff or halt. */
+static void s6e63m0_shutdown(struct spi_device *spi)
+{
+        struct s6e63m0 *lcd = dev_get_drvdata(&spi->dev);
+
+        s6e63m0_power(lcd, FB_BLANK_POWERDOWN);
+}
+
+static struct spi_driver s6e63m0_driver = {
+        .driver = {
+                .name   = "s6e63m0",
+                .bus    = &spi_bus_type,
+                .owner  = THIS_MODULE,
+        },
+        .probe          = s6e63m0_probe,
+        .remove         = __devexit_p(s6e63m0_remove),
+        .shutdown       = s6e63m0_shutdown,
+        .suspend        = s6e63m0_suspend,
+        .resume         = s6e63m0_resume,
+};
+
+static int __init s6e63m0_init(void)
+{
+        return spi_register_driver(&s6e63m0_driver);
+}
+
+static void __exit s6e63m0_exit(void)
+{
+        spi_unregister_driver(&s6e63m0_driver);
+}
+
+module_init(s6e63m0_init);
+module_exit(s6e63m0_exit);
+
+MODULE_AUTHOR("InKi Dae <inki.dae@samsung.com>");
+MODULE_DESCRIPTION("S6E63M0 LCD Driver");
+MODULE_LICENSE("GPL");
+
diff --git a/drivers/video/backlight/s6e63m0_gamma.h b/drivers/video/backlight/s6e63m0_gamma.h
new file mode 100644
index 000000000000..2c44bdb0696b
--- /dev/null
+++ b/drivers/video/backlight/s6e63m0_gamma.h
@@ -0,0 +1,266 @@
+/* linux/drivers/video/samsung/s6e63m0_brightness.h
+ *
+ * Gamma level definitions.
+ *
+ * Copyright (c) 2009 Samsung Electronics
+ * InKi Dae <inki.dae@samsung.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.
+*/
+
+#ifndef _S6E63M0_BRIGHTNESS_H
+#define _S6E63M0_BRIGHTNESS_H
+
+#define MAX_GAMMA_LEVEL         11
+#define GAMMA_TABLE_COUNT       21
+
+/* gamma value: 2.2 */
+static const unsigned int s6e63m0_22_300[] = {
+        0x18, 0x08, 0x24, 0x5f, 0x50, 0x2d, 0xB6,
+        0xB9, 0xA7, 0xAd, 0xB1, 0x9f, 0xbe, 0xC0,
+        0xB5, 0x00, 0xa0, 0x00, 0xa4, 0x00, 0xdb
+};
+
+static const unsigned int s6e63m0_22_280[] = {
+        0x18, 0x08, 0x24, 0x64, 0x56, 0x33, 0xB6,
+        0xBA, 0xA8, 0xAC, 0xB1, 0x9D, 0xC1, 0xC1,
+        0xB7, 0x00, 0x9C, 0x00, 0x9F, 0x00, 0xD6
+};
+
+static const unsigned int s6e63m0_22_260[] = {
+        0x18, 0x08, 0x24, 0x66, 0x58, 0x34, 0xB6,
+        0xBA, 0xA7, 0xAF, 0xB3, 0xA0, 0xC1, 0xC2,
+        0xB7, 0x00, 0x97, 0x00, 0x9A, 0x00, 0xD1
+
+};
+
+static const unsigned int s6e63m0_22_240[] = {
+        0x18, 0x08, 0x24, 0x62, 0x54, 0x30, 0xB9,
+        0xBB, 0xA9, 0xB0, 0xB3, 0xA1, 0xC1, 0xC3,
+        0xB7, 0x00, 0x91, 0x00, 0x95, 0x00, 0xDA
+
+};
+static const unsigned int s6e63m0_22_220[] = {
+        0x18, 0x08, 0x24, 0x63, 0x53, 0x31, 0xB8,
+        0xBC, 0xA9, 0xB0, 0xB5, 0xA2, 0xC4, 0xC4,
+        0xB8, 0x00, 0x8B, 0x00, 0x8E, 0x00, 0xC2
+};
+
+static const unsigned int s6e63m0_22_200[] = {
+        0x18, 0x08, 0x24, 0x66, 0x55, 0x34, 0xBA,
+        0xBD, 0xAB, 0xB1, 0xB5, 0xA3, 0xC5, 0xC6,
+        0xB9, 0x00, 0x85, 0x00, 0x88, 0x00, 0xBA
+};
+
+static const unsigned int s6e63m0_22_170[] = {
+        0x18, 0x08, 0x24, 0x69, 0x54, 0x37, 0xBB,
+        0xBE, 0xAC, 0xB4, 0xB7, 0xA6, 0xC7, 0xC8,
+        0xBC, 0x00, 0x7B, 0x00, 0x7E, 0x00, 0xAB
+};
+
+static const unsigned int s6e63m0_22_140[] = {
+        0x18, 0x08, 0x24, 0x6C, 0x54, 0x3A, 0xBC,
+        0xBF, 0xAC, 0xB7, 0xBB, 0xA9, 0xC9, 0xC9,
+        0xBE, 0x00, 0x71, 0x00, 0x73, 0x00, 0x9E
+};
+
+static const unsigned int s6e63m0_22_110[] = {
+        0x18, 0x08, 0x24, 0x70, 0x51, 0x3E, 0xBF,
+        0xC1, 0xAF, 0xB9, 0xBC, 0xAB, 0xCC, 0xCC,
+        0xC2, 0x00, 0x65, 0x00, 0x67, 0x00, 0x8D
+};
+
+static const unsigned int s6e63m0_22_90[] = {
+        0x18, 0x08, 0x24, 0x73, 0x4A, 0x3D, 0xC0,
+        0xC2, 0xB1, 0xBB, 0xBE, 0xAC, 0xCE, 0xCF,
+        0xC5, 0x00, 0x5D, 0x00, 0x5E, 0x00, 0x82
+};
+
+static const unsigned int s6e63m0_22_30[] = {
+        0x18, 0x08, 0x24, 0x78, 0xEC, 0x3D, 0xC8,
+        0xC2, 0xB6, 0xC4, 0xC7, 0xB6, 0xD5, 0xD7,
+        0xCC, 0x00, 0x39, 0x00, 0x36, 0x00, 0x51
+};
+
+/* gamma value: 1.9 */
+static const unsigned int s6e63m0_19_300[] = {
+        0x18, 0x08, 0x24, 0x61, 0x5F, 0x39, 0xBA,
+        0xBD, 0xAD, 0xB1, 0xB6, 0xA5, 0xC4, 0xC5,
+        0xBC, 0x00, 0xA0, 0x00, 0xA4, 0x00, 0xDB
+};
+
+static const unsigned int s6e63m0_19_280[] = {
+        0x18, 0x08, 0x24, 0x61, 0x60, 0x39, 0xBB,
+        0xBE, 0xAD, 0xB2, 0xB6, 0xA6, 0xC5, 0xC7,
+        0xBD, 0x00, 0x9B, 0x00, 0x9E, 0x00, 0xD5
+};
+
+static const unsigned int s6e63m0_19_260[] = {
+        0x18, 0x08, 0x24, 0x63, 0x61, 0x3B, 0xBA,
+        0xBE, 0xAC, 0xB3, 0xB8, 0xA7, 0xC6, 0xC8,
+        0xBD, 0x00, 0x96, 0x00, 0x98, 0x00, 0xCF
+};
+
+static const unsigned int s6e63m0_19_240[] = {
+        0x18, 0x08, 0x24, 0x67, 0x64, 0x3F, 0xBB,
+        0xBE, 0xAD, 0xB3, 0xB9, 0xA7, 0xC8, 0xC9,
+        0xBE, 0x00, 0x90, 0x00, 0x92, 0x00, 0xC8
+};
+
+static const unsigned int s6e63m0_19_220[] = {
+        0x18, 0x08, 0x24, 0x68, 0x64, 0x40, 0xBC,
+        0xBF, 0xAF, 0xB4, 0xBA, 0xA9, 0xC8, 0xCA,
+        0xBE, 0x00, 0x8B, 0x00, 0x8C, 0x00, 0xC0
+};
+
+static const unsigned int s6e63m0_19_200[] = {
+        0x18, 0x08, 0x24, 0x68, 0x64, 0x3F, 0xBE,
+        0xC0, 0xB0, 0xB6, 0xBB, 0xAB, 0xC8, 0xCB,
+        0xBF, 0x00, 0x85, 0x00, 0x86, 0x00, 0xB8
+};
+
+static const unsigned int s6e63m0_19_170[] = {
+        0x18, 0x08, 0x24, 0x69, 0x64, 0x40, 0xBF,
+        0xC1, 0xB0, 0xB9, 0xBE, 0xAD, 0xCB, 0xCD,
+        0xC2, 0x00, 0x7A, 0x00, 0x7B, 0x00, 0xAA
+};
+
+static const unsigned int s6e63m0_19_140[] = {
+        0x18, 0x08, 0x24, 0x6E, 0x65, 0x45, 0xC0,
+        0xC3, 0xB2, 0xBA, 0xBE, 0xAE, 0xCD, 0xD0,
+        0xC4, 0x00, 0x70, 0x00, 0x70, 0x00, 0x9C
+};
+
+static const unsigned int s6e63m0_19_110[] = {
+        0x18, 0x08, 0x24, 0x6F, 0x65, 0x46, 0xC2,
+        0xC4, 0xB3, 0xBF, 0xC2, 0xB2, 0xCF, 0xD1,
+        0xC6, 0x00, 0x64, 0x00, 0x64, 0x00, 0x8D
+};
+
+static const unsigned int s6e63m0_19_90[] = {
+        0x18, 0x08, 0x24, 0x74, 0x60, 0x4A, 0xC3,
+        0xC6, 0xB5, 0xBF, 0xC3, 0xB2, 0xD2, 0xD3,
+        0xC8, 0x00, 0x5B, 0x00, 0x5B, 0x00, 0x81
+};
+
+static const unsigned int s6e63m0_19_30[] = {
+        0x18, 0x08, 0x24, 0x84, 0x45, 0x4F, 0xCA,
+        0xCB, 0xBC, 0xC9, 0xCB, 0xBC, 0xDA, 0xDA,
+        0xD0, 0x00, 0x35, 0x00, 0x34, 0x00, 0x4E
+};
+
+/* gamma value: 1.7 */
+static const unsigned int s6e63m0_17_300[] = {
+        0x18, 0x08, 0x24, 0x70, 0x70, 0x4F, 0xBF,
+        0xC2, 0xB2, 0xB8, 0xBC, 0xAC, 0xCB, 0xCD,
+        0xC3, 0x00, 0xA0, 0x00, 0xA4, 0x00, 0xDB
+};
+
+static const unsigned int s6e63m0_17_280[] = {
+        0x18, 0x08, 0x24, 0x71, 0x71, 0x50, 0xBF,
+        0xC2, 0xB2, 0xBA, 0xBE, 0xAE, 0xCB, 0xCD,
+        0xC3, 0x00, 0x9C, 0x00, 0x9F, 0x00, 0xD6
+};
+
+static const unsigned int s6e63m0_17_260[] = {
+        0x18, 0x08, 0x24, 0x72, 0x72, 0x50, 0xC0,
+        0xC3, 0xB4, 0xB9, 0xBE, 0xAE, 0xCC, 0xCF,
+        0xC4, 0x00, 0x97, 0x00, 0x9A, 0x00, 0xD1
+};
+
+static const unsigned int s6e63m0_17_240[] = {
+        0x18, 0x08, 0x24, 0x71, 0x72, 0x4F, 0xC2,
+        0xC4, 0xB5, 0xBB, 0xBF, 0xB0, 0xCC, 0xCF,
+        0xC3, 0x00, 0x91, 0x00, 0x95, 0x00, 0xCA
+};
+
+static const unsigned int s6e63m0_17_220[] = {
+        0x18, 0x08, 0x24, 0x71, 0x73, 0x4F, 0xC2,
+        0xC5, 0xB5, 0xBD, 0xC0, 0xB2, 0xCD, 0xD1,
+        0xC5, 0x00, 0x8B, 0x00, 0x8E, 0x00, 0xC2
+};
+
+static const unsigned int s6e63m0_17_200[] = {
+        0x18, 0x08, 0x24, 0x72, 0x75, 0x51, 0xC2,
+        0xC6, 0xB5, 0xBF, 0xC1, 0xB3, 0xCE, 0xD1,
+        0xC6, 0x00, 0x85, 0x00, 0x88, 0x00, 0xBA
+};
+
+static const unsigned int s6e63m0_17_170[] = {
+        0x18, 0x08, 0x24, 0x75, 0x77, 0x54, 0xC3,
+        0xC7, 0xB7, 0xC0, 0xC3, 0xB4, 0xD1, 0xD3,
+        0xC9, 0x00, 0x7B, 0x00, 0x7E, 0x00, 0xAB
+};
+
+static const unsigned int s6e63m0_17_140[] = {
+        0x18, 0x08, 0x24, 0x7B, 0x77, 0x58, 0xC3,
+        0xC8, 0xB8, 0xC2, 0xC6, 0xB6, 0xD3, 0xD4,
+        0xCA, 0x00, 0x71, 0x00, 0x73, 0x00, 0x9E
+};
+
+static const unsigned int s6e63m0_17_110[] = {
+        0x18, 0x08, 0x24, 0x81, 0x7B, 0x5D, 0xC6,
+        0xCA, 0xBB, 0xC3, 0xC7, 0xB8, 0xD6, 0xD8,
+        0xCD, 0x00, 0x65, 0x00, 0x67, 0x00, 0x8D
+};
+
+static const unsigned int s6e63m0_17_90[] = {
+        0x18, 0x08, 0x24, 0x82, 0x7A, 0x5B, 0xC8,
+        0xCB, 0xBD, 0xC5, 0xCA, 0xBA, 0xD6, 0xD8,
+        0xCE, 0x00, 0x5D, 0x00, 0x5E, 0x00, 0x82
+};
+
+static const unsigned int s6e63m0_17_30[] = {
+        0x18, 0x08, 0x24, 0x8F, 0x73, 0x63, 0xD1,
+        0xD0, 0xC5, 0xCC, 0xD1, 0xC2, 0xDE, 0xE0,
+        0xD6, 0x00, 0x39, 0x00, 0x36, 0x00, 0x51
+};
+
+struct s6e63m0_gamma {
+        unsigned int *gamma_22_table[MAX_GAMMA_LEVEL];
+        unsigned int *gamma_19_table[MAX_GAMMA_LEVEL];
+        unsigned int *gamma_17_table[MAX_GAMMA_LEVEL];
+};
+
+static struct s6e63m0_gamma gamma_table = {
+        .gamma_22_table[0] = (unsigned int *)&s6e63m0_22_30,
+        .gamma_22_table[1] = (unsigned int *)&s6e63m0_22_90,
+        .gamma_22_table[2] = (unsigned int *)&s6e63m0_22_110,
+        .gamma_22_table[3] = (unsigned int *)&s6e63m0_22_140,
+        .gamma_22_table[4] = (unsigned int *)&s6e63m0_22_170,
+        .gamma_22_table[5] = (unsigned int *)&s6e63m0_22_200,
+        .gamma_22_table[6] = (unsigned int *)&s6e63m0_22_220,
+        .gamma_22_table[7] = (unsigned int *)&s6e63m0_22_240,
+        .gamma_22_table[8] = (unsigned int *)&s6e63m0_22_260,
+        .gamma_22_table[9] = (unsigned int *)&s6e63m0_22_280,
+        .gamma_22_table[10] = (unsigned int *)&s6e63m0_22_300,
+
+        .gamma_19_table[0] = (unsigned int *)&s6e63m0_19_30,
+        .gamma_19_table[1] = (unsigned int *)&s6e63m0_19_90,
+        .gamma_19_table[2] = (unsigned int *)&s6e63m0_19_110,
+        .gamma_19_table[3] = (unsigned int *)&s6e63m0_19_140,
+        .gamma_19_table[4] = (unsigned int *)&s6e63m0_19_170,
+        .gamma_19_table[5] = (unsigned int *)&s6e63m0_19_200,
+        .gamma_19_table[6] = (unsigned int *)&s6e63m0_19_220,
+        .gamma_19_table[7] = (unsigned int *)&s6e63m0_19_240,
+        .gamma_19_table[8] = (unsigned int *)&s6e63m0_19_260,
+        .gamma_19_table[9] = (unsigned int *)&s6e63m0_19_280,
+        .gamma_19_table[10] = (unsigned int *)&s6e63m0_19_300,
+
+        .gamma_17_table[0] = (unsigned int *)&s6e63m0_17_30,
+        .gamma_17_table[1] = (unsigned int *)&s6e63m0_17_90,
+        .gamma_17_table[2] = (unsigned int *)&s6e63m0_17_110,
+        .gamma_17_table[3] = (unsigned int *)&s6e63m0_17_140,
+        .gamma_17_table[4] = (unsigned int *)&s6e63m0_17_170,
+        .gamma_17_table[5] = (unsigned int *)&s6e63m0_17_200,
+        .gamma_17_table[6] = (unsigned int *)&s6e63m0_17_220,
+        .gamma_17_table[7] = (unsigned int *)&s6e63m0_17_240,
+        .gamma_17_table[8] = (unsigned int *)&s6e63m0_17_260,
+        .gamma_17_table[9] = (unsigned int *)&s6e63m0_17_280,
+        .gamma_17_table[10] = (unsigned int *)&s6e63m0_17_300,
+};
+
+#endif
+
diff --git a/drivers/video/bf54x-lq043fb.c b/drivers/video/bf54x-lq043fb.c
index 23b2a8c0dbfc..b020ba7f1cf2 100644
--- a/drivers/video/bf54x-lq043fb.c
+++ b/drivers/video/bf54x-lq043fb.c
@@ -501,7 +501,9 @@ static irqreturn_t bfin_bf54x_irq_error(int irq, void *dev_id)
 
 static int __devinit bfin_bf54x_probe(struct platform_device *pdev)
 {
+#ifndef NO_BL_SUPPORT
         struct backlight_properties props;
+#endif
         struct bfin_bf54xfb_info *info;
         struct fb_info *fbinfo;
         int ret;
@@ -654,7 +656,8 @@ static int __devinit bfin_bf54x_probe(struct platform_device *pdev)
                 printk(KERN_ERR DRIVER_NAME
                         ": unable to register backlight.\n");
                 ret = -EINVAL;
-                goto out9;
+                unregister_framebuffer(fbinfo);
+                goto out8;
         }
 
         lcd_dev = lcd_device_register(DRIVER_NAME, &pdev->dev, NULL, &bfin_lcd_ops);
@@ -663,8 +666,6 @@ static int __devinit bfin_bf54x_probe(struct platform_device *pdev)
 
         return 0;
 
-out9:
-        unregister_framebuffer(fbinfo);
 out8:
         free_irq(info->irq, info);
 out7:
diff --git a/drivers/video/bfin-t350mcqb-fb.c b/drivers/video/bfin-t350mcqb-fb.c
index c2ec3dcd4e91..7a50272eaab9 100644
--- a/drivers/video/bfin-t350mcqb-fb.c
+++ b/drivers/video/bfin-t350mcqb-fb.c
@@ -420,7 +420,9 @@ static irqreturn_t bfin_t350mcqb_irq_error(int irq, void *dev_id)
 
 static int __devinit bfin_t350mcqb_probe(struct platform_device *pdev)
 {
+#ifndef NO_BL_SUPPORT
         struct backlight_properties props;
+#endif
         struct bfin_t350mcqbfb_info *info;
         struct fb_info *fbinfo;
         int ret;
@@ -550,7 +552,8 @@ static int __devinit bfin_t350mcqb_probe(struct platform_device *pdev)
                 printk(KERN_ERR DRIVER_NAME
                         ": unable to register backlight.\n");
                 ret = -EINVAL;
-                goto out9;
+                unregister_framebuffer(fbinfo);
+                goto out8;
         }
 
         lcd_dev = lcd_device_register(DRIVER_NAME, NULL, &bfin_lcd_ops);
@@ -559,8 +562,6 @@ static int __devinit bfin_t350mcqb_probe(struct platform_device *pdev)
 
         return 0;
 
-out9:
-        unregister_framebuffer(fbinfo);
 out8:
         free_irq(info->irq, info);
 out7:
diff --git a/drivers/video/fb_defio.c b/drivers/video/fb_defio.c
index 1105a591dcc1..073c9b408cf7 100644
--- a/drivers/video/fb_defio.c
+++ b/drivers/video/fb_defio.c
@@ -66,7 +66,7 @@ static int fb_deferred_io_fault(struct vm_area_struct *vma,
         return 0;
 }
 
-int fb_deferred_io_fsync(struct file *file, struct dentry *dentry, int datasync)
+int fb_deferred_io_fsync(struct file *file, int datasync)
 {
         struct fb_info *info = file->private_data;
 
diff --git a/drivers/video/s3fb.c b/drivers/video/s3fb.c
index d4471b4c0374..dce8c97b4333 100644
--- a/drivers/video/s3fb.c
+++ b/drivers/video/s3fb.c
@@ -71,7 +71,8 @@ static const char * const s3_names[] = {"S3 Unknown", "S3 Trio32", "S3 Trio64",
                         "S3 Trio64UV+", "S3 Trio64V2/DX", "S3 Trio64V2/GX",
                         "S3 Plato/PX", "S3 Aurora64VP", "S3 Virge",
                         "S3 Virge/VX", "S3 Virge/DX", "S3 Virge/GX",
-                        "S3 Virge/GX2", "S3 Virge/GX2P", "S3 Virge/GX2P"};
+                        "S3 Virge/GX2", "S3 Virge/GX2P", "S3 Virge/GX2P",
+                        "S3 Trio3D/1X", "S3 Trio3D/2X", "S3 Trio3D/2X"};
 
 #define CHIP_UNKNOWN            0x00
 #define CHIP_732_TRIO32         0x01
@@ -89,10 +90,14 @@ static const char * const s3_names[] = {"S3 Unknown", "S3 Trio32", "S3 Trio64",
 #define CHIP_356_VIRGE_GX2      0x0D
 #define CHIP_357_VIRGE_GX2P     0x0E
 #define CHIP_359_VIRGE_GX2P     0x0F
+#define CHIP_360_TRIO3D_1X      0x10
+#define CHIP_362_TRIO3D_2X      0x11
+#define CHIP_368_TRIO3D_2X      0x12
 
 #define CHIP_XXX_TRIO           0x80
 #define CHIP_XXX_TRIO64V2_DXGX  0x81
 #define CHIP_XXX_VIRGE_DXGX     0x82
+#define CHIP_36X_TRIO3D_1X_2X   0x83
 
 #define CHIP_UNDECIDED_FLAG     0x80
 #define CHIP_MASK               0xFF
@@ -324,6 +329,7 @@ static void s3fb_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
 
 static void s3_set_pixclock(struct fb_info *info, u32 pixclock)
 {
+        struct s3fb_info *par = info->par;
         u16 m, n, r;
         u8 regval;
         int rv;
@@ -339,7 +345,13 @@ static void s3_set_pixclock(struct fb_info *info, u32 pixclock)
         vga_w(NULL, VGA_MIS_W, regval | VGA_MIS_ENB_PLL_LOAD);
 
         /* Set S3 clock registers */
-        vga_wseq(NULL, 0x12, ((n - 2) | (r << 5)));
+        if (par->chip == CHIP_360_TRIO3D_1X ||
+            par->chip == CHIP_362_TRIO3D_2X ||
+            par->chip == CHIP_368_TRIO3D_2X) {
+                vga_wseq(NULL, 0x12, (n - 2) | ((r & 3) << 6)); /* n and two bits of r */
+                vga_wseq(NULL, 0x29, r >> 2); /* remaining highest bit of r */
+        } else
+                vga_wseq(NULL, 0x12, (n - 2) | (r << 5));
         vga_wseq(NULL, 0x13, m - 2);
 
         udelay(1000);
@@ -456,7 +468,7 @@ static int s3fb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
 static int s3fb_set_par(struct fb_info *info)
 {
         struct s3fb_info *par = info->par;
-        u32 value, mode, hmul, offset_value, screen_size, multiplex;
+        u32 value, mode, hmul, offset_value, screen_size, multiplex, dbytes;
         u32 bpp = info->var.bits_per_pixel;
 
         if (bpp != 0) {
@@ -518,7 +530,7 @@ static int s3fb_set_par(struct fb_info *info)
         svga_wcrt_mask(0x33, 0x00, 0x08); /* no DDR ?   */
         svga_wcrt_mask(0x43, 0x00, 0x01); /* no DDR ?   */
 
-        svga_wcrt_mask(0x5D, 0x00, 0x28); // Clear strange HSlen bits
+        svga_wcrt_mask(0x5D, 0x00, 0x28); /* Clear strange HSlen bits */
 
 /*      svga_wcrt_mask(0x58, 0x03, 0x03); */
 
@@ -530,10 +542,14 @@ static int s3fb_set_par(struct fb_info *info)
         pr_debug("fb%d: offset register       : %d\n", info->node, offset_value);
         svga_wcrt_multi(s3_offset_regs, offset_value);
 
-        vga_wcrt(NULL, 0x54, 0x18); /* M parameter */
-        vga_wcrt(NULL, 0x60, 0xff); /* N parameter */
-        vga_wcrt(NULL, 0x61, 0xff); /* L parameter */
-        vga_wcrt(NULL, 0x62, 0xff); /* L parameter */
+        if (par->chip != CHIP_360_TRIO3D_1X &&
+            par->chip != CHIP_362_TRIO3D_2X &&
+            par->chip != CHIP_368_TRIO3D_2X) {
+                vga_wcrt(NULL, 0x54, 0x18); /* M parameter */
+                vga_wcrt(NULL, 0x60, 0xff); /* N parameter */
+                vga_wcrt(NULL, 0x61, 0xff); /* L parameter */
+                vga_wcrt(NULL, 0x62, 0xff); /* L parameter */
+        }
 
         vga_wcrt(NULL, 0x3A, 0x35);
         svga_wattr(0x33, 0x00);
@@ -570,6 +586,16 @@ static int s3fb_set_par(struct fb_info *info)
                 vga_wcrt(NULL, 0x66, 0x90);
         }
 
+        if (par->chip == CHIP_360_TRIO3D_1X ||
+            par->chip == CHIP_362_TRIO3D_2X ||
+            par->chip == CHIP_368_TRIO3D_2X) {
+                dbytes = info->var.xres * ((bpp+7)/8);
+                vga_wcrt(NULL, 0x91, (dbytes + 7) / 8);
+                vga_wcrt(NULL, 0x90, (((dbytes + 7) / 8) >> 8) | 0x80);
+
+                vga_wcrt(NULL, 0x66, 0x81);
+        }
+
         svga_wcrt_mask(0x31, 0x00, 0x40);
         multiplex = 0;
         hmul = 1;
@@ -615,11 +641,13 @@ static int s3fb_set_par(struct fb_info *info)
                 break;
         case 3:
                 pr_debug("fb%d: 8 bit pseudocolor\n", info->node);
-                if (info->var.pixclock > 20000) {
-                        svga_wcrt_mask(0x50, 0x00, 0x30);
+                svga_wcrt_mask(0x50, 0x00, 0x30);
+                if (info->var.pixclock > 20000 ||
+                    par->chip == CHIP_360_TRIO3D_1X ||
+                    par->chip == CHIP_362_TRIO3D_2X ||
+                    par->chip == CHIP_368_TRIO3D_2X)
                         svga_wcrt_mask(0x67, 0x00, 0xF0);
-                } else {
-                        svga_wcrt_mask(0x50, 0x00, 0x30);
+                else {
                         svga_wcrt_mask(0x67, 0x10, 0xF0);
                         multiplex = 1;
                 }
@@ -634,7 +662,10 @@ static int s3fb_set_par(struct fb_info *info)
                 } else {
                         svga_wcrt_mask(0x50, 0x10, 0x30);
                         svga_wcrt_mask(0x67, 0x30, 0xF0);
-                        hmul = 2;
+                        if (par->chip != CHIP_360_TRIO3D_1X &&
+                            par->chip != CHIP_362_TRIO3D_2X &&
+                            par->chip != CHIP_368_TRIO3D_2X)
+                                hmul = 2;
                 }
                 break;
         case 5:
@@ -647,7 +678,10 @@ static int s3fb_set_par(struct fb_info *info)
                 } else {
                         svga_wcrt_mask(0x50, 0x10, 0x30);
                         svga_wcrt_mask(0x67, 0x50, 0xF0);
-                        hmul = 2;
+                        if (par->chip != CHIP_360_TRIO3D_1X &&
+                            par->chip != CHIP_362_TRIO3D_2X &&
+                            par->chip != CHIP_368_TRIO3D_2X)
+                                hmul = 2;
                 }
                 break;
         case 6:
@@ -866,6 +900,17 @@ static int __devinit s3_identification(int chip)
                         return CHIP_385_VIRGE_GX;
         }
 
+        if (chip == CHIP_36X_TRIO3D_1X_2X) {
+                switch (vga_rcrt(NULL, 0x2f)) {
+                case 0x00:
+                        return CHIP_360_TRIO3D_1X;
+                case 0x01:
+                        return CHIP_362_TRIO3D_2X;
+                case 0x02:
+                        return CHIP_368_TRIO3D_2X;
+                }
+        }
+
         return CHIP_UNKNOWN;
 }
 
@@ -930,17 +975,32 @@ static int __devinit s3_pci_probe(struct pci_dev *dev, const struct pci_device_i
         vga_wcrt(NULL, 0x38, 0x48);
         vga_wcrt(NULL, 0x39, 0xA5);
 
-        /* Find how many physical memory there is on card */
-        /* 0x36 register is accessible even if other registers are locked */
-        regval = vga_rcrt(NULL, 0x36);
-        info->screen_size = s3_memsizes[regval >> 5] << 10;
-        info->fix.smem_len = info->screen_size;
-
+        /* Identify chip type */
         par->chip = id->driver_data & CHIP_MASK;
         par->rev = vga_rcrt(NULL, 0x2f);
         if (par->chip & CHIP_UNDECIDED_FLAG)
                 par->chip = s3_identification(par->chip);
 
+        /* Find how many physical memory there is on card */
+        /* 0x36 register is accessible even if other registers are locked */
+        regval = vga_rcrt(NULL, 0x36);
+        if (par->chip == CHIP_360_TRIO3D_1X ||
+            par->chip == CHIP_362_TRIO3D_2X ||
+            par->chip == CHIP_368_TRIO3D_2X) {
+                switch ((regval & 0xE0) >> 5) {
+                case 0: /* 8MB -- only 4MB usable for display */
+                case 1: /* 4MB with 32-bit bus */
+                case 2: /* 4MB */
+                        info->screen_size = 4 << 20;
+                        break;
+                case 6: /* 2MB */
+                        info->screen_size = 2 << 20;
+                        break;
+                }
+        } else
+                info->screen_size = s3_memsizes[regval >> 5] << 10;
+        info->fix.smem_len = info->screen_size;
+
         /* Find MCLK frequency */
         regval = vga_rseq(NULL, 0x10);
         par->mclk_freq = ((vga_rseq(NULL, 0x11) + 2) * 14318) / ((regval & 0x1F)  + 2);
@@ -1131,6 +1191,7 @@ static struct pci_device_id s3_devices[] __devinitdata = {
         {PCI_DEVICE(PCI_VENDOR_ID_S3, 0x8A10), .driver_data = CHIP_356_VIRGE_GX2},
         {PCI_DEVICE(PCI_VENDOR_ID_S3, 0x8A11), .driver_data = CHIP_357_VIRGE_GX2P},
         {PCI_DEVICE(PCI_VENDOR_ID_S3, 0x8A12), .driver_data = CHIP_359_VIRGE_GX2P},
+        {PCI_DEVICE(PCI_VENDOR_ID_S3, 0x8A13), .driver_data = CHIP_36X_TRIO3D_1X_2X},
 
         {0, 0, 0, 0, 0, 0, 0}
 };
diff --git a/drivers/video/via/viafbdev.c b/drivers/video/via/viafbdev.c
index 2bc40e682f95..1082541358f0 100644
--- a/drivers/video/via/viafbdev.c
+++ b/drivers/video/via/viafbdev.c
@@ -578,14 +578,9 @@ static int viafb_ioctl(struct fb_info *info, u_int cmd, u_long arg)
                 break;
 
         case VIAFB_SET_GAMMA_LUT:
-                viafb_gamma_table = kmalloc(256 * sizeof(u32), GFP_KERNEL);
-                if (!viafb_gamma_table)
-                        return -ENOMEM;
-                if (copy_from_user(viafb_gamma_table, argp,
-                                256 * sizeof(u32))) {
-                        kfree(viafb_gamma_table);
-                        return -EFAULT;
-                }
+                viafb_gamma_table = memdup_user(argp, 256 * sizeof(u32));
+                if (IS_ERR(viafb_gamma_table))
+                        return PTR_ERR(viafb_gamma_table);
                 viafb_set_gamma_table(viafb_bpp, viafb_gamma_table);
                 kfree(viafb_gamma_table);
                 break;
diff --git a/drivers/watchdog/rdc321x_wdt.c b/drivers/watchdog/rdc321x_wdt.c
index 69c6adbd8205..428f8a1583e8 100644
--- a/drivers/watchdog/rdc321x_wdt.c
+++ b/drivers/watchdog/rdc321x_wdt.c
@@ -1,7 +1,7 @@
 /*
  * RDC321x watchdog driver
  *
- * Copyright (C) 2007 Florian Fainelli <florian@openwrt.org>
+ * Copyright (C) 2007-2010 Florian Fainelli <florian@openwrt.org>
  *
  * This driver is highly inspired from the cpu5_wdt driver
  *
@@ -36,8 +36,7 @@
 #include <linux/watchdog.h>
 #include <linux/io.h>
 #include <linux/uaccess.h>
-
-#include <asm/rdc321x_defs.h>
+#include <linux/mfd/rdc321x.h>
 
 #define RDC_WDT_MASK    0x80000000 /* Mask */
 #define RDC_WDT_EN      0x00800000 /* Enable bit */
@@ -63,6 +62,8 @@ static struct {
         int default_ticks;
         unsigned long inuse;
         spinlock_t lock;
+        struct pci_dev *sb_pdev;
+        int base_reg;
 } rdc321x_wdt_device;
 
 /* generic helper functions */
@@ -70,14 +71,18 @@ static struct {
 static void rdc321x_wdt_trigger(unsigned long unused)
 {
         unsigned long flags;
+        u32 val;
 
         if (rdc321x_wdt_device.running)
                 ticks--;
 
         /* keep watchdog alive */
         spin_lock_irqsave(&rdc321x_wdt_device.lock, flags);
-        outl(RDC_WDT_EN | inl(RDC3210_CFGREG_DATA),
-                RDC3210_CFGREG_DATA);
+        pci_read_config_dword(rdc321x_wdt_device.sb_pdev,
+                                        rdc321x_wdt_device.base_reg, &val);
+        val |= RDC_WDT_EN;
+        pci_write_config_dword(rdc321x_wdt_device.sb_pdev,
+                                        rdc321x_wdt_device.base_reg, val);
         spin_unlock_irqrestore(&rdc321x_wdt_device.lock, flags);
 
         /* requeue?? */
@@ -105,10 +110,13 @@ static void rdc321x_wdt_start(void)
 
                 /* Clear the timer */
                 spin_lock_irqsave(&rdc321x_wdt_device.lock, flags);
-                outl(RDC_CLS_TMR, RDC3210_CFGREG_ADDR);
+                pci_write_config_dword(rdc321x_wdt_device.sb_pdev,
+                                rdc321x_wdt_device.base_reg, RDC_CLS_TMR);
 
                 /* Enable watchdog and set the timeout to 81.92 us */
-                outl(RDC_WDT_EN | RDC_WDT_CNT, RDC3210_CFGREG_DATA);
+                pci_write_config_dword(rdc321x_wdt_device.sb_pdev,
+                                        rdc321x_wdt_device.base_reg,
+                                        RDC_WDT_EN | RDC_WDT_CNT);
                 spin_unlock_irqrestore(&rdc321x_wdt_device.lock, flags);
 
                 mod_timer(&rdc321x_wdt_device.timer,
@@ -148,7 +156,7 @@ static long rdc321x_wdt_ioctl(struct file *file, unsigned int cmd,
                                 unsigned long arg)
 {
         void __user *argp = (void __user *)arg;
-        unsigned int value;
+        u32 value;
         static const struct watchdog_info ident = {
                 .options = WDIOF_CARDRESET,
                 .identity = "RDC321x WDT",
@@ -162,9 +170,10 @@ static long rdc321x_wdt_ioctl(struct file *file, unsigned int cmd,
         case WDIOC_GETSTATUS:
                 /* Read the value from the DATA register */
                 spin_lock_irqsave(&rdc321x_wdt_device.lock, flags);
-                value = inl(RDC3210_CFGREG_DATA);
+                pci_read_config_dword(rdc321x_wdt_device.sb_pdev,
+                                        rdc321x_wdt_device.base_reg, &value);
                 spin_unlock_irqrestore(&rdc321x_wdt_device.lock, flags);
-                if (copy_to_user(argp, &value, sizeof(int)))
+                if (copy_to_user(argp, &value, sizeof(u32)))
                         return -EFAULT;
                 break;
         case WDIOC_GETSUPPORT:
@@ -219,17 +228,35 @@ static struct miscdevice rdc321x_wdt_misc = {
 static int __devinit rdc321x_wdt_probe(struct platform_device *pdev)
 {
         int err;
+        struct resource *r;
+        struct rdc321x_wdt_pdata *pdata;
+
+        pdata = pdev->dev.platform_data;
+        if (!pdata) {
+                dev_err(&pdev->dev, "no platform data supplied\n");
+                return -ENODEV;
+        }
+
+        r = platform_get_resource_byname(pdev, IORESOURCE_IO, "wdt-reg");
+        if (!r) {
+                dev_err(&pdev->dev, "failed to get wdt-reg resource\n");
+                return -ENODEV;
+        }
+
+        rdc321x_wdt_device.sb_pdev = pdata->sb_pdev;
+        rdc321x_wdt_device.base_reg = r->start;
 
         err = misc_register(&rdc321x_wdt_misc);
         if (err < 0) {
-                printk(KERN_ERR PFX "watchdog misc_register failed\n");
+                dev_err(&pdev->dev, "misc_register failed\n");
                 return err;
         }
 
         spin_lock_init(&rdc321x_wdt_device.lock);
 
         /* Reset the watchdog */
-        outl(RDC_WDT_RST, RDC3210_CFGREG_DATA);
+        pci_write_config_dword(rdc321x_wdt_device.sb_pdev,
+                                rdc321x_wdt_device.base_reg, RDC_WDT_RST);
 
         init_completion(&rdc321x_wdt_device.stop);
         rdc321x_wdt_device.queue = 0;
@@ -240,7 +267,7 @@ static int __devinit rdc321x_wdt_probe(struct platform_device *pdev)
 
         rdc321x_wdt_device.default_ticks = ticks;
 
-        printk(KERN_INFO PFX "watchdog init success\n");
+        dev_info(&pdev->dev, "watchdog init success\n");
 
         return 0;
 }