110 files changed, 4081 insertions, 2266 deletions

diff --git a/drivers/acpi/Makefile b/drivers/acpi/Makefile
index bce34afadcd0..ea55e0179f81 100644
--- a/drivers/acpi/Makefile
+++ b/drivers/acpi/Makefile
@@ -39,8 +39,9 @@ acpi-y				+= processor_core.o
 acpi-y                          += ec.o
 acpi-$(CONFIG_ACPI_DOCK)        += dock.o
 acpi-y                          += pci_root.o pci_link.o pci_irq.o
-acpi-$(CONFIG_X86_INTEL_LPSS)   += acpi_lpss.o
+acpi-y                          += acpi_lpss.o
 acpi-y                          += acpi_platform.o
+acpi-y                          += acpi_pnp.o
 acpi-y                          += power.o
 acpi-y                          += event.o
 acpi-y                          += sysfs.o
@@ -63,9 +64,9 @@ obj-$(CONFIG_ACPI_FAN)		+= fan.o
 obj-$(CONFIG_ACPI_VIDEO)        += video.o
 obj-$(CONFIG_ACPI_PCI_SLOT)     += pci_slot.o
 obj-$(CONFIG_ACPI_PROCESSOR)    += processor.o
-obj-$(CONFIG_ACPI_CONTAINER)    += container.o
+obj-y                           += container.o
 obj-$(CONFIG_ACPI_THERMAL)      += thermal.o
-obj-$(CONFIG_ACPI_HOTPLUG_MEMORY) += acpi_memhotplug.o
+obj-y                           += acpi_memhotplug.o
 obj-$(CONFIG_ACPI_BATTERY)      += battery.o
 obj-$(CONFIG_ACPI_SBS)          += sbshc.o
 obj-$(CONFIG_ACPI_SBS)          += sbs.o
diff --git a/drivers/acpi/acpi_cmos_rtc.c b/drivers/acpi/acpi_cmos_rtc.c
index 961b45d18a5d..2da8660262e5 100644
--- a/drivers/acpi/acpi_cmos_rtc.c
+++ b/drivers/acpi/acpi_cmos_rtc.c
@@ -68,7 +68,7 @@ static int acpi_install_cmos_rtc_space_handler(struct acpi_device *adev,
                 return -ENODEV;
         }
 
-        return 0;
+        return 1;
 }
 
 static void acpi_remove_cmos_rtc_space_handler(struct acpi_device *adev)
diff --git a/drivers/acpi/acpi_extlog.c b/drivers/acpi/acpi_extlog.c
index c4a5d87ede7e..185334114d71 100644
--- a/drivers/acpi/acpi_extlog.c
+++ b/drivers/acpi/acpi_extlog.c
@@ -220,13 +220,13 @@ static int __init extlog_init(void)
                 goto err;
         }
 
-        extlog_l1_hdr = acpi_os_map_memory(l1_dirbase, l1_hdr_size);
+        extlog_l1_hdr = acpi_os_map_iomem(l1_dirbase, l1_hdr_size);
         l1_head = (struct extlog_l1_head *)extlog_l1_hdr;
         l1_size = l1_head->total_len;
         l1_percpu_entry = l1_head->entries;
         elog_base = l1_head->elog_base;
         elog_size = l1_head->elog_len;
-        acpi_os_unmap_memory(extlog_l1_hdr, l1_hdr_size);
+        acpi_os_unmap_iomem(extlog_l1_hdr, l1_hdr_size);
         release_mem_region(l1_dirbase, l1_hdr_size);
 
         /* remap L1 header again based on completed information */
@@ -237,7 +237,7 @@ static int __init extlog_init(void)
                         (unsigned long long)l1_dirbase + l1_size);
                 goto err;
         }
-        extlog_l1_addr = acpi_os_map_memory(l1_dirbase, l1_size);
+        extlog_l1_addr = acpi_os_map_iomem(l1_dirbase, l1_size);
         l1_entry_base = (u64 *)((u8 *)extlog_l1_addr + l1_hdr_size);
 
         /* remap elog table */
@@ -248,7 +248,7 @@ static int __init extlog_init(void)
                         (unsigned long long)elog_base + elog_size);
                 goto err_release_l1_dir;
         }
-        elog_addr = acpi_os_map_memory(elog_base, elog_size);
+        elog_addr = acpi_os_map_iomem(elog_base, elog_size);
 
         rc = -ENOMEM;
         /* allocate buffer to save elog record */
@@ -270,11 +270,11 @@ static int __init extlog_init(void)
 
 err_release_elog:
         if (elog_addr)
-                acpi_os_unmap_memory(elog_addr, elog_size);
+                acpi_os_unmap_iomem(elog_addr, elog_size);
         release_mem_region(elog_base, elog_size);
 err_release_l1_dir:
         if (extlog_l1_addr)
-                acpi_os_unmap_memory(extlog_l1_addr, l1_size);
+                acpi_os_unmap_iomem(extlog_l1_addr, l1_size);
         release_mem_region(l1_dirbase, l1_size);
 err:
         pr_warn(FW_BUG "Extended error log disabled because of problems parsing f/w tables\n");
@@ -287,9 +287,9 @@ static void __exit extlog_exit(void)
         mce_unregister_decode_chain(&extlog_mce_dec);
         ((struct extlog_l1_head *)extlog_l1_addr)->flags &= ~FLAG_OS_OPTIN;
         if (extlog_l1_addr)
-                acpi_os_unmap_memory(extlog_l1_addr, l1_size);
+                acpi_os_unmap_iomem(extlog_l1_addr, l1_size);
         if (elog_addr)
-                acpi_os_unmap_memory(elog_addr, elog_size);
+                acpi_os_unmap_iomem(elog_addr, elog_size);
         release_mem_region(elog_base, elog_size);
         release_mem_region(l1_dirbase, l1_size);
         kfree(elog_buf);
diff --git a/drivers/acpi/acpi_lpss.c b/drivers/acpi/acpi_lpss.c
index d79c6d7f598e..63407d264885 100644
--- a/drivers/acpi/acpi_lpss.c
+++ b/drivers/acpi/acpi_lpss.c
@@ -19,15 +19,21 @@
 #include <linux/platform_device.h>
 #include <linux/platform_data/clk-lpss.h>
 #include <linux/pm_runtime.h>
+#include <linux/delay.h>
 
 #include "internal.h"
 
 ACPI_MODULE_NAME("acpi_lpss");
 
+#ifdef CONFIG_X86_INTEL_LPSS
+
+#define LPSS_ADDR(desc) ((unsigned long)&desc)
+
 #define LPSS_CLK_SIZE   0x04
 #define LPSS_LTR_SIZE   0x18
 
 /* Offsets relative to LPSS_PRIVATE_OFFSET */
+#define LPSS_CLK_DIVIDER_DEF_MASK       (BIT(1) | BIT(16))
 #define LPSS_GENERAL                    0x08
 #define LPSS_GENERAL_LTR_MODE_SW        BIT(2)
 #define LPSS_GENERAL_UART_RTS_OVRD      BIT(3)
@@ -43,6 +49,8 @@ ACPI_MODULE_NAME("acpi_lpss");
 #define LPSS_TX_INT                     0x20
 #define LPSS_TX_INT_MASK                BIT(1)
 
+#define LPSS_PRV_REG_COUNT              9
+
 struct lpss_shared_clock {
         const char *name;
         unsigned long rate;
@@ -57,7 +65,9 @@ struct lpss_device_desc {
         bool ltr_required;
         unsigned int prv_offset;
         size_t prv_size_override;
+        bool clk_divider;
         bool clk_gate;
+        bool save_ctx;
         struct lpss_shared_clock *shared_clock;
         void (*setup)(struct lpss_private_data *pdata);
 };
@@ -72,6 +82,7 @@ struct lpss_private_data {
         resource_size_t mmio_size;
         struct clk *clk;
         const struct lpss_device_desc *dev_desc;
+        u32 prv_reg_ctx[LPSS_PRV_REG_COUNT];
 };
 
 static void lpss_uart_setup(struct lpss_private_data *pdata)
@@ -92,6 +103,14 @@ static struct lpss_device_desc lpt_dev_desc = {
         .clk_required = true,
         .prv_offset = 0x800,
         .ltr_required = true,
+        .clk_divider = true,
+        .clk_gate = true,
+};
+
+static struct lpss_device_desc lpt_i2c_dev_desc = {
+        .clk_required = true,
+        .prv_offset = 0x800,
+        .ltr_required = true,
         .clk_gate = true,
 };
 
@@ -99,6 +118,7 @@ static struct lpss_device_desc lpt_uart_dev_desc = {
         .clk_required = true,
         .prv_offset = 0x800,
         .ltr_required = true,
+        .clk_divider = true,
         .clk_gate = true,
         .setup = lpss_uart_setup,
 };
@@ -116,32 +136,25 @@ static struct lpss_shared_clock pwm_clock = {
 
 static struct lpss_device_desc byt_pwm_dev_desc = {
         .clk_required = true,
+        .save_ctx = true,
         .shared_clock = &pwm_clock,
 };
 
-static struct lpss_shared_clock uart_clock = {
-        .name = "uart_clk",
-        .rate = 44236800,
-};
-
 static struct lpss_device_desc byt_uart_dev_desc = {
         .clk_required = true,
         .prv_offset = 0x800,
+        .clk_divider = true,
         .clk_gate = true,
-        .shared_clock = &uart_clock,
+        .save_ctx = true,
         .setup = lpss_uart_setup,
 };
 
-static struct lpss_shared_clock spi_clock = {
-        .name = "spi_clk",
-        .rate = 50000000,
-};
-
 static struct lpss_device_desc byt_spi_dev_desc = {
         .clk_required = true,
         .prv_offset = 0x400,
+        .clk_divider = true,
         .clk_gate = true,
-        .shared_clock = &spi_clock,
+        .save_ctx = true,
 };
 
 static struct lpss_device_desc byt_sdio_dev_desc = {
@@ -156,44 +169,53 @@ static struct lpss_shared_clock i2c_clock = {
 static struct lpss_device_desc byt_i2c_dev_desc = {
         .clk_required = true,
         .prv_offset = 0x800,
+        .save_ctx = true,
         .shared_clock = &i2c_clock,
 };
 
+#else
+
+#define LPSS_ADDR(desc) (0UL)
+
+#endif /* CONFIG_X86_INTEL_LPSS */
+
 static const struct acpi_device_id acpi_lpss_device_ids[] = {
         /* Generic LPSS devices */
-        { "INTL9C60", (unsigned long)&lpss_dma_desc },
+        { "INTL9C60", LPSS_ADDR(lpss_dma_desc) },
 
         /* Lynxpoint LPSS devices */
-        { "INT33C0", (unsigned long)&lpt_dev_desc },
-        { "INT33C1", (unsigned long)&lpt_dev_desc },
-        { "INT33C2", (unsigned long)&lpt_dev_desc },
-        { "INT33C3", (unsigned long)&lpt_dev_desc },
-        { "INT33C4", (unsigned long)&lpt_uart_dev_desc },
-        { "INT33C5", (unsigned long)&lpt_uart_dev_desc },
-        { "INT33C6", (unsigned long)&lpt_sdio_dev_desc },
+        { "INT33C0", LPSS_ADDR(lpt_dev_desc) },
+        { "INT33C1", LPSS_ADDR(lpt_dev_desc) },
+        { "INT33C2", LPSS_ADDR(lpt_i2c_dev_desc) },
+        { "INT33C3", LPSS_ADDR(lpt_i2c_dev_desc) },
+        { "INT33C4", LPSS_ADDR(lpt_uart_dev_desc) },
+        { "INT33C5", LPSS_ADDR(lpt_uart_dev_desc) },
+        { "INT33C6", LPSS_ADDR(lpt_sdio_dev_desc) },
         { "INT33C7", },
 
         /* BayTrail LPSS devices */
-        { "80860F09", (unsigned long)&byt_pwm_dev_desc },
-        { "80860F0A", (unsigned long)&byt_uart_dev_desc },
-        { "80860F0E", (unsigned long)&byt_spi_dev_desc },
-        { "80860F14", (unsigned long)&byt_sdio_dev_desc },
-        { "80860F41", (unsigned long)&byt_i2c_dev_desc },
+        { "80860F09", LPSS_ADDR(byt_pwm_dev_desc) },
+        { "80860F0A", LPSS_ADDR(byt_uart_dev_desc) },
+        { "80860F0E", LPSS_ADDR(byt_spi_dev_desc) },
+        { "80860F14", LPSS_ADDR(byt_sdio_dev_desc) },
+        { "80860F41", LPSS_ADDR(byt_i2c_dev_desc) },
         { "INT33B2", },
         { "INT33FC", },
 
-        { "INT3430", (unsigned long)&lpt_dev_desc },
-        { "INT3431", (unsigned long)&lpt_dev_desc },
-        { "INT3432", (unsigned long)&lpt_dev_desc },
-        { "INT3433", (unsigned long)&lpt_dev_desc },
-        { "INT3434", (unsigned long)&lpt_uart_dev_desc },
-        { "INT3435", (unsigned long)&lpt_uart_dev_desc },
-        { "INT3436", (unsigned long)&lpt_sdio_dev_desc },
+        { "INT3430", LPSS_ADDR(lpt_dev_desc) },
+        { "INT3431", LPSS_ADDR(lpt_dev_desc) },
+        { "INT3432", LPSS_ADDR(lpt_i2c_dev_desc) },
+        { "INT3433", LPSS_ADDR(lpt_i2c_dev_desc) },
+        { "INT3434", LPSS_ADDR(lpt_uart_dev_desc) },
+        { "INT3435", LPSS_ADDR(lpt_uart_dev_desc) },
+        { "INT3436", LPSS_ADDR(lpt_sdio_dev_desc) },
         { "INT3437", },
 
         { }
 };
 
+#ifdef CONFIG_X86_INTEL_LPSS
+
 static int is_memory(struct acpi_resource *res, void *not_used)
 {
         struct resource r;
@@ -213,9 +235,11 @@ static int register_device_clock(struct acpi_device *adev,
 {
         const struct lpss_device_desc *dev_desc = pdata->dev_desc;
         struct lpss_shared_clock *shared_clock = dev_desc->shared_clock;
+        const char *devname = dev_name(&adev->dev);
         struct clk *clk = ERR_PTR(-ENODEV);
         struct lpss_clk_data *clk_data;
-        const char *parent;
+        const char *parent, *clk_name;
+        void __iomem *prv_base;
 
         if (!lpss_clk_dev)
                 lpt_register_clock_device();
@@ -226,7 +250,7 @@ static int register_device_clock(struct acpi_device *adev,
 
         if (dev_desc->clkdev_name) {
                 clk_register_clkdev(clk_data->clk, dev_desc->clkdev_name,
-                                    dev_name(&adev->dev));
+                                    devname);
                 return 0;
         }
 
@@ -235,6 +259,7 @@ static int register_device_clock(struct acpi_device *adev,
                 return -ENODATA;
 
         parent = clk_data->name;
+        prv_base = pdata->mmio_base + dev_desc->prv_offset;
 
         if (shared_clock) {
                 clk = shared_clock->clk;
@@ -248,16 +273,41 @@ static int register_device_clock(struct acpi_device *adev,
         }
 
         if (dev_desc->clk_gate) {
-                clk = clk_register_gate(NULL, dev_name(&adev->dev), parent, 0,
-                                        pdata->mmio_base + dev_desc->prv_offset,
-                                        0, 0, NULL);
-                pdata->clk = clk;
+                clk = clk_register_gate(NULL, devname, parent, 0,
+                                        prv_base, 0, 0, NULL);
+                parent = devname;
+        }
+
+        if (dev_desc->clk_divider) {
+                /* Prevent division by zero */
+                if (!readl(prv_base))
+                        writel(LPSS_CLK_DIVIDER_DEF_MASK, prv_base);
+
+                clk_name = kasprintf(GFP_KERNEL, "%s-div", devname);
+                if (!clk_name)
+                        return -ENOMEM;
+                clk = clk_register_fractional_divider(NULL, clk_name, parent,
+                                                      0, prv_base,
+                                                      1, 15, 16, 15, 0, NULL);
+                parent = clk_name;
+
+                clk_name = kasprintf(GFP_KERNEL, "%s-update", devname);
+                if (!clk_name) {
+                        kfree(parent);
+                        return -ENOMEM;
+                }
+                clk = clk_register_gate(NULL, clk_name, parent,
+                                        CLK_SET_RATE_PARENT | CLK_SET_RATE_GATE,
+                                        prv_base, 31, 0, NULL);
+                kfree(parent);
+                kfree(clk_name);
         }
 
         if (IS_ERR(clk))
                 return PTR_ERR(clk);
 
-        clk_register_clkdev(clk, NULL, dev_name(&adev->dev));
+        pdata->clk = clk;
+        clk_register_clkdev(clk, NULL, devname);
         return 0;
 }
 
@@ -268,12 +318,14 @@ static int acpi_lpss_create_device(struct acpi_device *adev,
         struct lpss_private_data *pdata;
         struct resource_list_entry *rentry;
         struct list_head resource_list;
+        struct platform_device *pdev;
         int ret;
 
         dev_desc = (struct lpss_device_desc *)id->driver_data;
-        if (!dev_desc)
-                return acpi_create_platform_device(adev, id);
-
+        if (!dev_desc) {
+                pdev = acpi_create_platform_device(adev);
+                return IS_ERR_OR_NULL(pdev) ? PTR_ERR(pdev) : 1;
+        }
         pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
         if (!pdata)
                 return -ENOMEM;
@@ -323,10 +375,13 @@ static int acpi_lpss_create_device(struct acpi_device *adev,
                 dev_desc->setup(pdata);
 
         adev->driver_data = pdata;
-        ret = acpi_create_platform_device(adev, id);
-        if (ret > 0)
-                return ret;
+        pdev = acpi_create_platform_device(adev);
+        if (!IS_ERR_OR_NULL(pdev)) {
+                device_enable_async_suspend(&pdev->dev);
+                return 1;
+        }
 
+        ret = PTR_ERR(pdev);
         adev->driver_data = NULL;
 
  err_out:
@@ -450,6 +505,126 @@ static void acpi_lpss_set_ltr(struct device *dev, s32 val)
         }
 }
 
+#ifdef CONFIG_PM
+/**
+ * acpi_lpss_save_ctx() - Save the private registers of LPSS device
+ * @dev: LPSS device
+ *
+ * Most LPSS devices have private registers which may loose their context when
+ * the device is powered down. acpi_lpss_save_ctx() saves those registers into
+ * prv_reg_ctx array.
+ */
+static void acpi_lpss_save_ctx(struct device *dev)
+{
+        struct lpss_private_data *pdata = acpi_driver_data(ACPI_COMPANION(dev));
+        unsigned int i;
+
+        for (i = 0; i < LPSS_PRV_REG_COUNT; i++) {
+                unsigned long offset = i * sizeof(u32);
+
+                pdata->prv_reg_ctx[i] = __lpss_reg_read(pdata, offset);
+                dev_dbg(dev, "saving 0x%08x from LPSS reg at offset 0x%02lx\n",
+                        pdata->prv_reg_ctx[i], offset);
+        }
+}
+
+/**
+ * acpi_lpss_restore_ctx() - Restore the private registers of LPSS device
+ * @dev: LPSS device
+ *
+ * Restores the registers that were previously stored with acpi_lpss_save_ctx().
+ */
+static void acpi_lpss_restore_ctx(struct device *dev)
+{
+        struct lpss_private_data *pdata = acpi_driver_data(ACPI_COMPANION(dev));
+        unsigned int i;
+
+        /*
+         * The following delay is needed or the subsequent write operations may
+         * fail. The LPSS devices are actually PCI devices and the PCI spec
+         * expects 10ms delay before the device can be accessed after D3 to D0
+         * transition.
+         */
+        msleep(10);
+
+        for (i = 0; i < LPSS_PRV_REG_COUNT; i++) {
+                unsigned long offset = i * sizeof(u32);
+
+                __lpss_reg_write(pdata->prv_reg_ctx[i], pdata, offset);
+                dev_dbg(dev, "restoring 0x%08x to LPSS reg at offset 0x%02lx\n",
+                        pdata->prv_reg_ctx[i], offset);
+        }
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int acpi_lpss_suspend_late(struct device *dev)
+{
+        int ret = pm_generic_suspend_late(dev);
+
+        if (ret)
+                return ret;
+
+        acpi_lpss_save_ctx(dev);
+        return acpi_dev_suspend_late(dev);
+}
+
+static int acpi_lpss_restore_early(struct device *dev)
+{
+        int ret = acpi_dev_resume_early(dev);
+
+        if (ret)
+                return ret;
+
+        acpi_lpss_restore_ctx(dev);
+        return pm_generic_resume_early(dev);
+}
+#endif /* CONFIG_PM_SLEEP */
+
+#ifdef CONFIG_PM_RUNTIME
+static int acpi_lpss_runtime_suspend(struct device *dev)
+{
+        int ret = pm_generic_runtime_suspend(dev);
+
+        if (ret)
+                return ret;
+
+        acpi_lpss_save_ctx(dev);
+        return acpi_dev_runtime_suspend(dev);
+}
+
+static int acpi_lpss_runtime_resume(struct device *dev)
+{
+        int ret = acpi_dev_runtime_resume(dev);
+
+        if (ret)
+                return ret;
+
+        acpi_lpss_restore_ctx(dev);
+        return pm_generic_runtime_resume(dev);
+}
+#endif /* CONFIG_PM_RUNTIME */
+#endif /* CONFIG_PM */
+
+static struct dev_pm_domain acpi_lpss_pm_domain = {
+        .ops = {
+#ifdef CONFIG_PM_SLEEP
+                .suspend_late = acpi_lpss_suspend_late,
+                .restore_early = acpi_lpss_restore_early,
+                .prepare = acpi_subsys_prepare,
+                .complete = acpi_subsys_complete,
+                .suspend = acpi_subsys_suspend,
+                .resume_early = acpi_subsys_resume_early,
+                .freeze = acpi_subsys_freeze,
+                .poweroff = acpi_subsys_suspend,
+                .poweroff_late = acpi_subsys_suspend_late,
+#endif
+#ifdef CONFIG_PM_RUNTIME
+                .runtime_suspend = acpi_lpss_runtime_suspend,
+                .runtime_resume = acpi_lpss_runtime_resume,
+#endif
+        },
+};
+
 static int acpi_lpss_platform_notify(struct notifier_block *nb,
                                      unsigned long action, void *data)
 {
@@ -457,7 +632,6 @@ static int acpi_lpss_platform_notify(struct notifier_block *nb,
         struct lpss_private_data *pdata;
         struct acpi_device *adev;
         const struct acpi_device_id *id;
-        int ret = 0;
 
         id = acpi_match_device(acpi_lpss_device_ids, &pdev->dev);
         if (!id || !id->driver_data)
@@ -467,7 +641,7 @@ static int acpi_lpss_platform_notify(struct notifier_block *nb,
                 return 0;
 
         pdata = acpi_driver_data(adev);
-        if (!pdata || !pdata->mmio_base || !pdata->dev_desc->ltr_required)
+        if (!pdata || !pdata->mmio_base)
                 return 0;
 
         if (pdata->mmio_size < pdata->dev_desc->prv_offset + LPSS_LTR_SIZE) {
@@ -475,12 +649,27 @@ static int acpi_lpss_platform_notify(struct notifier_block *nb,
                 return 0;
         }
 
-        if (action == BUS_NOTIFY_ADD_DEVICE)
-                ret = sysfs_create_group(&pdev->dev.kobj, &lpss_attr_group);
-        else if (action == BUS_NOTIFY_DEL_DEVICE)
-                sysfs_remove_group(&pdev->dev.kobj, &lpss_attr_group);
+        switch (action) {
+        case BUS_NOTIFY_BOUND_DRIVER:
+                if (pdata->dev_desc->save_ctx)
+                        pdev->dev.pm_domain = &acpi_lpss_pm_domain;
+                break;
+        case BUS_NOTIFY_UNBOUND_DRIVER:
+                if (pdata->dev_desc->save_ctx)
+                        pdev->dev.pm_domain = NULL;
+                break;
+        case BUS_NOTIFY_ADD_DEVICE:
+                if (pdata->dev_desc->ltr_required)
+                        return sysfs_create_group(&pdev->dev.kobj,
+                                                  &lpss_attr_group);
+        case BUS_NOTIFY_DEL_DEVICE:
+                if (pdata->dev_desc->ltr_required)
+                        sysfs_remove_group(&pdev->dev.kobj, &lpss_attr_group);
+        default:
+                break;
+        }
 
-        return ret;
+        return 0;
 }
 
 static struct notifier_block acpi_lpss_nb = {
@@ -519,3 +708,16 @@ void __init acpi_lpss_init(void)
                 acpi_scan_add_handler(&lpss_handler);
         }
 }
+
+#else
+
+static struct acpi_scan_handler lpss_handler = {
+        .ids = acpi_lpss_device_ids,
+};
+
+void __init acpi_lpss_init(void)
+{
+        acpi_scan_add_handler(&lpss_handler);
+}
+
+#endif /* CONFIG_X86_INTEL_LPSS */
diff --git a/drivers/acpi/acpi_memhotplug.c b/drivers/acpi/acpi_memhotplug.c
index b67be85ff0fc..23e2319ead41 100644
--- a/drivers/acpi/acpi_memhotplug.c
+++ b/drivers/acpi/acpi_memhotplug.c
@@ -44,6 +44,13 @@
 
 ACPI_MODULE_NAME("acpi_memhotplug");
 
+static const struct acpi_device_id memory_device_ids[] = {
+        {ACPI_MEMORY_DEVICE_HID, 0},
+        {"", 0},
+};
+
+#ifdef CONFIG_ACPI_HOTPLUG_MEMORY
+
 /* Memory Device States */
 #define MEMORY_INVALID_STATE    0
 #define MEMORY_POWER_ON_STATE   1
@@ -53,11 +60,6 @@ static int acpi_memory_device_add(struct acpi_device *device,
                                   const struct acpi_device_id *not_used);
 static void acpi_memory_device_remove(struct acpi_device *device);
 
-static const struct acpi_device_id memory_device_ids[] = {
-        {ACPI_MEMORY_DEVICE_HID, 0},
-        {"", 0},
-};
-
 static struct acpi_scan_handler memory_device_handler = {
         .ids = memory_device_ids,
         .attach = acpi_memory_device_add,
@@ -364,9 +366,11 @@ static bool __initdata acpi_no_memhotplug;
 
 void __init acpi_memory_hotplug_init(void)
 {
-        if (acpi_no_memhotplug)
+        if (acpi_no_memhotplug) {
+                memory_device_handler.attach = NULL;
+                acpi_scan_add_handler(&memory_device_handler);
                 return;
-
+        }
         acpi_scan_add_handler_with_hotplug(&memory_device_handler, "memory");
 }
 
@@ -376,3 +380,16 @@ static int __init disable_acpi_memory_hotplug(char *str)
         return 1;
 }
 __setup("acpi_no_memhotplug", disable_acpi_memory_hotplug);
+
+#else
+
+static struct acpi_scan_handler memory_device_handler = {
+        .ids = memory_device_ids,
+};
+
+void __init acpi_memory_hotplug_init(void)
+{
+        acpi_scan_add_handler(&memory_device_handler);
+}
+
+#endif /* CONFIG_ACPI_HOTPLUG_MEMORY */
diff --git a/drivers/acpi/acpi_pad.c b/drivers/acpi/acpi_pad.c
index 37d73024b82e..f148a0580e04 100644
--- a/drivers/acpi/acpi_pad.c
+++ b/drivers/acpi/acpi_pad.c
@@ -156,12 +156,13 @@ static int power_saving_thread(void *data)
 
         while (!kthread_should_stop()) {
                 int cpu;
-                u64 expire_time;
+                unsigned long expire_time;
 
                 try_to_freeze();
 
                 /* round robin to cpus */
-                if (last_jiffies + round_robin_time * HZ < jiffies) {
+                expire_time = last_jiffies + round_robin_time * HZ;
+                if (time_before(expire_time, jiffies)) {
                         last_jiffies = jiffies;
                         round_robin_cpu(tsk_index);
                 }
@@ -200,7 +201,7 @@ static int power_saving_thread(void *data)
                                         CLOCK_EVT_NOTIFY_BROADCAST_EXIT, &cpu);
                         local_irq_enable();
 
-                        if (jiffies > expire_time) {
+                        if (time_before(expire_time, jiffies)) {
                                 do_sleep = 1;
                                 break;
                         }
@@ -215,8 +216,15 @@ static int power_saving_thread(void *data)
                  * borrow CPU time from this CPU and cause RT task use > 95%
                  * CPU time. To make 'avoid starvation' work, takes a nap here.
                  */
-                if (do_sleep)
+                if (unlikely(do_sleep))
                         schedule_timeout_killable(HZ * idle_pct / 100);
+
+                /* If an external event has set the need_resched flag, then
+                 * we need to deal with it, or this loop will continue to
+                 * spin without calling __mwait().
+                 */
+                if (unlikely(need_resched()))
+                        schedule();
         }
 
         exit_round_robin(tsk_index);
diff --git a/drivers/acpi/acpi_platform.c b/drivers/acpi/acpi_platform.c
index 1d4950388fa1..2bf9082f7523 100644
--- a/drivers/acpi/acpi_platform.c
+++ b/drivers/acpi/acpi_platform.c
@@ -22,27 +22,16 @@
 
 ACPI_MODULE_NAME("platform");
 
-/*
- * The following ACPI IDs are known to be suitable for representing as
- * platform devices.
- */
-static const struct acpi_device_id acpi_platform_device_ids[] = {
-
-        { "PNP0D40" },
-        { "VPC2004" },
-        { "BCM4752" },
-
-        /* Intel Smart Sound Technology */
-        { "INT33C8" },
-        { "80860F28" },
-
-        { }
+static const struct acpi_device_id forbidden_id_list[] = {
+        {"PNP0000", 0}, /* PIC */
+        {"PNP0100", 0}, /* Timer */
+        {"PNP0200", 0}, /* AT DMA Controller */
+        {"", 0},
 };
 
 /**
  * acpi_create_platform_device - Create platform device for ACPI device node
  * @adev: ACPI device node to create a platform device for.
- * @id: ACPI device ID used to match @adev.
  *
  * Check if the given @adev can be represented as a platform device and, if
  * that's the case, create and register a platform device, populate its common
@@ -50,8 +39,7 @@ static const struct acpi_device_id acpi_platform_device_ids[] = {
  *
  * Name of the platform device will be the same as @adev's.
  */
-int acpi_create_platform_device(struct acpi_device *adev,
-                                const struct acpi_device_id *id)
+struct platform_device *acpi_create_platform_device(struct acpi_device *adev)
 {
         struct platform_device *pdev = NULL;
         struct acpi_device *acpi_parent;
@@ -63,19 +51,22 @@ int acpi_create_platform_device(struct acpi_device *adev,
 
         /* If the ACPI node already has a physical device attached, skip it. */
         if (adev->physical_node_count)
-                return 0;
+                return NULL;
+
+        if (!acpi_match_device_ids(adev, forbidden_id_list))
+                return ERR_PTR(-EINVAL);
 
         INIT_LIST_HEAD(&resource_list);
         count = acpi_dev_get_resources(adev, &resource_list, NULL, NULL);
         if (count < 0) {
-                return 0;
+                return NULL;
         } else if (count > 0) {
                 resources = kmalloc(count * sizeof(struct resource),
                                     GFP_KERNEL);
                 if (!resources) {
                         dev_err(&adev->dev, "No memory for resources\n");
                         acpi_dev_free_resource_list(&resource_list);
-                        return -ENOMEM;
+                        return ERR_PTR(-ENOMEM);
                 }
                 count = 0;
                 list_for_each_entry(rentry, &resource_list, node)
@@ -112,25 +103,13 @@ int acpi_create_platform_device(struct acpi_device *adev,
         pdevinfo.num_res = count;
         pdevinfo.acpi_node.companion = adev;
         pdev = platform_device_register_full(&pdevinfo);
-        if (IS_ERR(pdev)) {
+        if (IS_ERR(pdev))
                 dev_err(&adev->dev, "platform device creation failed: %ld\n",
                         PTR_ERR(pdev));
-                pdev = NULL;
-        } else {
+        else
                 dev_dbg(&adev->dev, "created platform device %s\n",
                         dev_name(&pdev->dev));
-        }
 
         kfree(resources);
-        return 1;
-}
-
-static struct acpi_scan_handler platform_handler = {
-        .ids = acpi_platform_device_ids,
-        .attach = acpi_create_platform_device,
-};
-
-void __init acpi_platform_init(void)
-{
-        acpi_scan_add_handler(&platform_handler);
+        return pdev;
 }
diff --git a/drivers/acpi/acpi_pnp.c b/drivers/acpi/acpi_pnp.c
new file mode 100644
index 000000000000..6703c1fd993a
--- /dev/null
+++ b/drivers/acpi/acpi_pnp.c
@@ -0,0 +1,395 @@
+/*
+ * ACPI support for PNP bus type
+ *
+ * Copyright (C) 2014, Intel Corporation
+ * Authors: Zhang Rui <rui.zhang@intel.com>
+ *          Rafael J. Wysocki <rafael.j.wysocki@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.
+ */
+
+#include <linux/acpi.h>
+#include <linux/module.h>
+
+static const struct acpi_device_id acpi_pnp_device_ids[] = {
+        /* pata_isapnp */
+        {"PNP0600"},            /* Generic ESDI/IDE/ATA compatible hard disk controller */
+        /* floppy */
+        {"PNP0700"},
+        /* ipmi_si */
+        {"IPI0001"},
+        /* tpm_inf_pnp */
+        {"IFX0101"},            /* Infineon TPMs */
+        {"IFX0102"},            /* Infineon TPMs */
+        /*tpm_tis */
+        {"PNP0C31"},            /* TPM */
+        {"ATM1200"},            /* Atmel */
+        {"IFX0102"},            /* Infineon */
+        {"BCM0101"},            /* Broadcom */
+        {"BCM0102"},            /* Broadcom */
+        {"NSC1200"},            /* National */
+        {"ICO0102"},            /* Intel */
+        /* ide   */
+        {"PNP0600"},            /* Generic ESDI/IDE/ATA compatible hard disk controller */
+        /* ns558 */
+        {"ASB16fd"},            /* AdLib NSC16 */
+        {"AZT3001"},            /* AZT1008 */
+        {"CDC0001"},            /* Opl3-SAx */
+        {"CSC0001"},            /* CS4232 */
+        {"CSC000f"},            /* CS4236 */
+        {"CSC0101"},            /* CS4327 */
+        {"CTL7001"},            /* SB16 */
+        {"CTL7002"},            /* AWE64 */
+        {"CTL7005"},            /* Vibra16 */
+        {"ENS2020"},            /* SoundscapeVIVO */
+        {"ESS0001"},            /* ES1869 */
+        {"ESS0005"},            /* ES1878 */
+        {"ESS6880"},            /* ES688 */
+        {"IBM0012"},            /* CS4232 */
+        {"OPT0001"},            /* OPTi Audio16 */
+        {"YMH0006"},            /* Opl3-SA */
+        {"YMH0022"},            /* Opl3-SAx */
+        {"PNPb02f"},            /* Generic */
+        /* i8042 kbd */
+        {"PNP0300"},
+        {"PNP0301"},
+        {"PNP0302"},
+        {"PNP0303"},
+        {"PNP0304"},
+        {"PNP0305"},
+        {"PNP0306"},
+        {"PNP0309"},
+        {"PNP030a"},
+        {"PNP030b"},
+        {"PNP0320"},
+        {"PNP0343"},
+        {"PNP0344"},
+        {"PNP0345"},
+        {"CPQA0D7"},
+        /* i8042 aux */
+        {"AUI0200"},
+        {"FJC6000"},
+        {"FJC6001"},
+        {"PNP0f03"},
+        {"PNP0f0b"},
+        {"PNP0f0e"},
+        {"PNP0f12"},
+        {"PNP0f13"},
+        {"PNP0f19"},
+        {"PNP0f1c"},
+        {"SYN0801"},
+        /* fcpnp */
+        {"AVM0900"},
+        /* radio-cadet */
+        {"MSM0c24"},            /* ADS Cadet AM/FM Radio Card */
+        /* radio-gemtek */
+        {"ADS7183"},            /* AOpen FX-3D/Pro Radio */
+        /* radio-sf16fmr2 */
+        {"MFRad13"},            /* tuner subdevice of SF16-FMD2 */
+        /* ene_ir */
+        {"ENE0100"},
+        {"ENE0200"},
+        {"ENE0201"},
+        {"ENE0202"},
+        /* fintek-cir */
+        {"FIT0002"},            /* CIR */
+        /* ite-cir */
+        {"ITE8704"},            /* Default model */
+        {"ITE8713"},            /* CIR found in EEEBox 1501U */
+        {"ITE8708"},            /* Bridged IT8512 */
+        {"ITE8709"},            /* SRAM-Bridged IT8512 */
+        /* nuvoton-cir */
+        {"WEC0530"},            /* CIR */
+        {"NTN0530"},            /* CIR for new chip's pnp id */
+        /* Winbond CIR */
+        {"WEC1022"},
+        /* wbsd */
+        {"WEC0517"},
+        {"WEC0518"},
+        /* Winbond CIR */
+        {"TCM5090"},            /* 3Com Etherlink III (TP) */
+        {"TCM5091"},            /* 3Com Etherlink III */
+        {"TCM5094"},            /* 3Com Etherlink III (combo) */
+        {"TCM5095"},            /* 3Com Etherlink III (TPO) */
+        {"TCM5098"},            /* 3Com Etherlink III (TPC) */
+        {"PNP80f7"},            /* 3Com Etherlink III compatible */
+        {"PNP80f8"},            /* 3Com Etherlink III compatible */
+        /* nsc-ircc */
+        {"NSC6001"},
+        {"HWPC224"},
+        {"IBM0071"},
+        /* smsc-ircc2 */
+        {"SMCf010"},
+        /* sb1000 */
+        {"GIC1000"},
+        /* parport_pc */
+        {"PNP0400"},            /* Standard LPT Printer Port */
+        {"PNP0401"},            /* ECP Printer Port */
+        /* apple-gmux */
+        {"APP000B"},
+        /* fujitsu-laptop.c */
+        {"FUJ02bf"},
+        {"FUJ02B1"},
+        {"FUJ02E3"},
+        /* system */
+        {"PNP0c02"},            /* General ID for reserving resources */
+        {"PNP0c01"},            /* memory controller */
+        /* rtc_cmos */
+        {"PNP0b00"},
+        {"PNP0b01"},
+        {"PNP0b02"},
+        /* c6xdigio */
+        {"PNP0400"},            /* Standard LPT Printer Port */
+        {"PNP0401"},            /* ECP Printer Port */
+        /* ni_atmio.c */
+        {"NIC1900"},
+        {"NIC2400"},
+        {"NIC2500"},
+        {"NIC2600"},
+        {"NIC2700"},
+        /* serial */
+        {"AAC000F"},            /* Archtek America Corp. Archtek SmartLink Modem 3334BT Plug & Play */
+        {"ADC0001"},            /* Anchor Datacomm BV. SXPro 144 External Data Fax Modem Plug & Play */
+        {"ADC0002"},            /* SXPro 288 External Data Fax Modem Plug & Play */
+        {"AEI0250"},            /* PROLiNK 1456VH ISA PnP K56flex Fax Modem */
+        {"AEI1240"},            /* Actiontec ISA PNP 56K X2 Fax Modem */
+        {"AKY1021"},            /* Rockwell 56K ACF II Fax+Data+Voice Modem */
+        {"AZT4001"},            /* AZT3005 PnP SOUND DEVICE */
+        {"BDP3336"},            /* Best Data Products Inc. Smart One 336F PnP Modem */
+        {"BRI0A49"},            /* Boca Complete Ofc Communicator 14.4 Data-FAX */
+        {"BRI1400"},            /* Boca Research 33,600 ACF Modem */
+        {"BRI3400"},            /* Boca 33.6 Kbps Internal FD34FSVD */
+        {"BRI0A49"},            /* Boca 33.6 Kbps Internal FD34FSVD */
+        {"BDP3336"},            /* Best Data Products Inc. Smart One 336F PnP Modem */
+        {"CPI4050"},            /* Computer Peripherals Inc. EuroViVa CommCenter-33.6 SP PnP */
+        {"CTL3001"},            /* Creative Labs Phone Blaster 28.8 DSVD PnP Voice */
+        {"CTL3011"},            /* Creative Labs Modem Blaster 28.8 DSVD PnP Voice */
+        {"DAV0336"},            /* Davicom ISA 33.6K Modem */
+        {"DMB1032"},            /* Creative Modem Blaster Flash56 DI5601-1 */
+        {"DMB2001"},            /* Creative Modem Blaster V.90 DI5660 */
+        {"ETT0002"},            /* E-Tech CyberBULLET PC56RVP */
+        {"FUJ0202"},            /* Fujitsu 33600 PnP-I2 R Plug & Play */
+        {"FUJ0205"},            /* Fujitsu FMV-FX431 Plug & Play */
+        {"FUJ0206"},            /* Fujitsu 33600 PnP-I4 R Plug & Play */
+        {"FUJ0209"},            /* Fujitsu Fax Voice 33600 PNP-I5 R Plug & Play */
+        {"GVC000F"},            /* Archtek SmartLink Modem 3334BT Plug & Play */
+        {"GVC0303"},            /* Archtek SmartLink Modem 3334BRV 33.6K Data Fax Voice */
+        {"HAY0001"},            /* Hayes Optima 288 V.34-V.FC + FAX + Voice Plug & Play */
+        {"HAY000C"},            /* Hayes Optima 336 V.34 + FAX + Voice PnP */
+        {"HAY000D"},            /* Hayes Optima 336B V.34 + FAX + Voice PnP */
+        {"HAY5670"},            /* Hayes Accura 56K Ext Fax Modem PnP */
+        {"HAY5674"},            /* Hayes Accura 56K Ext Fax Modem PnP */
+        {"HAY5675"},            /* Hayes Accura 56K Fax Modem PnP */
+        {"HAYF000"},            /* Hayes 288, V.34 + FAX */
+        {"HAYF001"},            /* Hayes Optima 288 V.34 + FAX + Voice, Plug & Play */
+        {"IBM0033"},            /* IBM Thinkpad 701 Internal Modem Voice */
+        {"PNP4972"},            /* Intermec CV60 touchscreen port */
+        {"IXDC801"},            /* Intertex 28k8 33k6 Voice EXT PnP */
+        {"IXDC901"},            /* Intertex 33k6 56k Voice EXT PnP */
+        {"IXDD801"},            /* Intertex 28k8 33k6 Voice SP EXT PnP */
+        {"IXDD901"},            /* Intertex 33k6 56k Voice SP EXT PnP */
+        {"IXDF401"},            /* Intertex 28k8 33k6 Voice SP INT PnP */
+        {"IXDF801"},            /* Intertex 28k8 33k6 Voice SP EXT PnP */
+        {"IXDF901"},            /* Intertex 33k6 56k Voice SP EXT PnP */
+        {"KOR4522"},            /* KORTEX 28800 Externe PnP */
+        {"KORF661"},            /* KXPro 33.6 Vocal ASVD PnP */
+        {"LAS4040"},            /* LASAT Internet 33600 PnP */
+        {"LAS4540"},            /* Lasat Safire 560 PnP */
+        {"LAS5440"},            /* Lasat Safire 336  PnP */
+        {"MNP0281"},            /* Microcom TravelPorte FAST V.34 Plug & Play */
+        {"MNP0336"},            /* Microcom DeskPorte V.34 FAST or FAST+ Plug & Play */
+        {"MNP0339"},            /* Microcom DeskPorte FAST EP 28.8 Plug & Play */
+        {"MNP0342"},            /* Microcom DeskPorte 28.8P Plug & Play */
+        {"MNP0500"},            /* Microcom DeskPorte FAST ES 28.8 Plug & Play */
+        {"MNP0501"},            /* Microcom DeskPorte FAST ES 28.8 Plug & Play */
+        {"MNP0502"},            /* Microcom DeskPorte 28.8S Internal Plug & Play */
+        {"MOT1105"},            /* Motorola BitSURFR Plug & Play */
+        {"MOT1111"},            /* Motorola TA210 Plug & Play */
+        {"MOT1114"},            /* Motorola HMTA 200 (ISDN) Plug & Play */
+        {"MOT1115"},            /* Motorola BitSURFR Plug & Play */
+        {"MOT1190"},            /* Motorola Lifestyle 28.8 Internal */
+        {"MOT1501"},            /* Motorola V.3400 Plug & Play */
+        {"MOT1502"},            /* Motorola Lifestyle 28.8 V.34 Plug & Play */
+        {"MOT1505"},            /* Motorola Power 28.8 V.34 Plug & Play */
+        {"MOT1509"},            /* Motorola ModemSURFR External 28.8 Plug & Play */
+        {"MOT150A"},            /* Motorola Premier 33.6 Desktop Plug & Play */
+        {"MOT150F"},            /* Motorola VoiceSURFR 56K External PnP */
+        {"MOT1510"},            /* Motorola ModemSURFR 56K External PnP */
+        {"MOT1550"},            /* Motorola ModemSURFR 56K Internal PnP */
+        {"MOT1560"},            /* Motorola ModemSURFR Internal 28.8 Plug & Play */
+        {"MOT1580"},            /* Motorola Premier 33.6 Internal Plug & Play */
+        {"MOT15B0"},            /* Motorola OnlineSURFR 28.8 Internal Plug & Play */
+        {"MOT15F0"},            /* Motorola VoiceSURFR 56K Internal PnP */
+        {"MVX00A1"},            /*  Deskline K56 Phone System PnP */
+        {"MVX00F2"},            /* PC Rider K56 Phone System PnP */
+        {"nEC8241"},            /* NEC 98NOTE SPEAKER PHONE FAX MODEM(33600bps) */
+        {"PMC2430"},            /* Pace 56 Voice Internal Plug & Play Modem */
+        {"PNP0500"},            /* Generic standard PC COM port     */
+        {"PNP0501"},            /* Generic 16550A-compatible COM port */
+        {"PNPC000"},            /* Compaq 14400 Modem */
+        {"PNPC001"},            /* Compaq 2400/9600 Modem */
+        {"PNPC031"},            /* Dial-Up Networking Serial Cable between 2 PCs */
+        {"PNPC032"},            /* Dial-Up Networking Parallel Cable between 2 PCs */
+        {"PNPC100"},            /* Standard 9600 bps Modem */
+        {"PNPC101"},            /* Standard 14400 bps Modem */
+        {"PNPC102"},            /*  Standard 28800 bps Modem */
+        {"PNPC103"},            /*  Standard Modem */
+        {"PNPC104"},            /*  Standard 9600 bps Modem */
+        {"PNPC105"},            /*  Standard 14400 bps Modem */
+        {"PNPC106"},            /*  Standard 28800 bps Modem */
+        {"PNPC107"},            /*  Standard Modem */
+        {"PNPC108"},            /* Standard 9600 bps Modem */
+        {"PNPC109"},            /* Standard 14400 bps Modem */
+        {"PNPC10A"},            /* Standard 28800 bps Modem */
+        {"PNPC10B"},            /* Standard Modem */
+        {"PNPC10C"},            /* Standard 9600 bps Modem */
+        {"PNPC10D"},            /* Standard 14400 bps Modem */
+        {"PNPC10E"},            /* Standard 28800 bps Modem */
+        {"PNPC10F"},            /* Standard Modem */
+        {"PNP2000"},            /* Standard PCMCIA Card Modem */
+        {"ROK0030"},            /* Rockwell 33.6 DPF Internal PnP, Modular Technology 33.6 Internal PnP */
+        {"ROK0100"},            /* KORTEX 14400 Externe PnP */
+        {"ROK4120"},            /* Rockwell 28.8 */
+        {"ROK4920"},            /* Viking 28.8 INTERNAL Fax+Data+Voice PnP */
+        {"RSS00A0"},            /* Rockwell 33.6 DPF External PnP, BT Prologue 33.6 External PnP, Modular Technology 33.6 External PnP */
+        {"RSS0262"},            /* Viking 56K FAX INT */
+        {"RSS0250"},            /* K56 par,VV,Voice,Speakphone,AudioSpan,PnP */
+        {"SUP1310"},            /* SupraExpress 28.8 Data/Fax PnP modem */
+        {"SUP1381"},            /* SupraExpress 336i PnP Voice Modem */
+        {"SUP1421"},            /* SupraExpress 33.6 Data/Fax PnP modem */
+        {"SUP1590"},            /* SupraExpress 33.6 Data/Fax PnP modem */
+        {"SUP1620"},            /* SupraExpress 336i Sp ASVD */
+        {"SUP1760"},            /* SupraExpress 33.6 Data/Fax PnP modem */
+        {"SUP2171"},            /* SupraExpress 56i Sp Intl */
+        {"TEX0011"},            /* Phoebe Micro 33.6 Data Fax 1433VQH Plug & Play */
+        {"UAC000F"},            /* Archtek SmartLink Modem 3334BT Plug & Play */
+        {"USR0000"},            /* 3Com Corp. Gateway Telepath IIvi 33.6 */
+        {"USR0002"},            /* U.S. Robotics Sporster 33.6K Fax INT PnP */
+        {"USR0004"},            /*  Sportster Vi 14.4 PnP FAX Voicemail */
+        {"USR0006"},            /* U.S. Robotics 33.6K Voice INT PnP */
+        {"USR0007"},            /* U.S. Robotics 33.6K Voice EXT PnP */
+        {"USR0009"},            /* U.S. Robotics Courier V.Everything INT PnP */
+        {"USR2002"},            /* U.S. Robotics 33.6K Voice INT PnP */
+        {"USR2070"},            /* U.S. Robotics 56K Voice INT PnP */
+        {"USR2080"},            /* U.S. Robotics 56K Voice EXT PnP */
+        {"USR3031"},            /* U.S. Robotics 56K FAX INT */
+        {"USR3050"},            /* U.S. Robotics 56K FAX INT */
+        {"USR3070"},            /* U.S. Robotics 56K Voice INT PnP */
+        {"USR3080"},            /* U.S. Robotics 56K Voice EXT PnP */
+        {"USR3090"},            /* U.S. Robotics 56K Voice INT PnP */
+        {"USR9100"},            /* U.S. Robotics 56K Message  */
+        {"USR9160"},            /* U.S. Robotics 56K FAX EXT PnP */
+        {"USR9170"},            /* U.S. Robotics 56K FAX INT PnP */
+        {"USR9180"},            /* U.S. Robotics 56K Voice EXT PnP */
+        {"USR9190"},            /* U.S. Robotics 56K Voice INT PnP */
+        {"WACFXXX"},            /* Wacom tablets */
+        {"FPI2002"},            /* Compaq touchscreen */
+        {"FUJ02B2"},            /* Fujitsu Stylistic touchscreens */
+        {"FUJ02B3"},
+        {"FUJ02B4"},            /* Fujitsu Stylistic LT touchscreens */
+        {"FUJ02B6"},            /* Passive Fujitsu Stylistic touchscreens */
+        {"FUJ02B7"},
+        {"FUJ02B8"},
+        {"FUJ02B9"},
+        {"FUJ02BC"},
+        {"FUJ02E5"},            /* Fujitsu Wacom Tablet PC device */
+        {"FUJ02E6"},            /* Fujitsu P-series tablet PC device */
+        {"FUJ02E7"},            /* Fujitsu Wacom 2FGT Tablet PC device */
+        {"FUJ02E9"},            /* Fujitsu Wacom 1FGT Tablet PC device */
+        {"LTS0001"},            /* LG C1 EXPRESS DUAL (C1-PB11A3) touch screen (actually a FUJ02E6 in disguise) */
+        {"WCI0003"},            /* Rockwell's (PORALiNK) 33600 INT PNP */
+        {"WEC1022"},            /* Winbond CIR port, should not be probed. We should keep track of it to prevent the legacy serial driver from probing it */
+        /* scl200wdt */
+        {"NSC0800"},            /* National Semiconductor PC87307/PC97307 watchdog component */
+        /* mpu401 */
+        {"PNPb006"},
+        /* cs423x-pnpbios */
+        {"CSC0100"},
+        {"CSC0000"},
+        {"GIM0100"},            /* Guillemot Turtlebeach something appears to be cs4232 compatible */
+        /* es18xx-pnpbios */
+        {"ESS1869"},
+        {"ESS1879"},
+        /* snd-opl3sa2-pnpbios */
+        {"YMH0021"},
+        {"NMX2210"},            /* Gateway Solo 2500 */
+        {""},
+};
+
+static bool is_hex_digit(char c)
+{
+        return (c >= 0 && c <= '9') || (c >= 'A' && c <= 'F');
+}
+
+static bool matching_id(char *idstr, char *list_id)
+{
+        int i;
+
+        if (memcmp(idstr, list_id, 3))
+                return false;
+
+        for (i = 3; i < 7; i++) {
+                char c = toupper(idstr[i]);
+
+                if (!is_hex_digit(c)
+                    || (list_id[i] != 'X' && c != toupper(list_id[i])))
+                        return false;
+        }
+        return true;
+}
+
+static bool acpi_pnp_match(char *idstr, const struct acpi_device_id **matchid)
+{
+        const struct acpi_device_id *devid;
+
+        for (devid = acpi_pnp_device_ids; devid->id[0]; devid++)
+                if (matching_id(idstr, (char *)devid->id)) {
+                        if (matchid)
+                                *matchid = devid;
+
+                        return true;
+                }
+
+        return false;
+}
+
+static int acpi_pnp_attach(struct acpi_device *adev,
+                           const struct acpi_device_id *id)
+{
+        return 1;
+}
+
+static struct acpi_scan_handler acpi_pnp_handler = {
+        .ids = acpi_pnp_device_ids,
+        .match = acpi_pnp_match,
+        .attach = acpi_pnp_attach,
+};
+
+/*
+ * For CMOS RTC devices, the PNP ACPI scan handler does not work, because
+ * there is a CMOS RTC ACPI scan handler installed already, so we need to
+ * check those devices and enumerate them to the PNP bus directly.
+ */
+static int is_cmos_rtc_device(struct acpi_device *adev)
+{
+        struct acpi_device_id ids[] = {
+                { "PNP0B00" },
+                { "PNP0B01" },
+                { "PNP0B02" },
+                {""},
+        };
+        return !acpi_match_device_ids(adev, ids);
+}
+
+bool acpi_is_pnp_device(struct acpi_device *adev)
+{
+        return adev->handler == &acpi_pnp_handler || is_cmos_rtc_device(adev);
+}
+EXPORT_SYMBOL_GPL(acpi_is_pnp_device);
+
+void __init acpi_pnp_init(void)
+{
+        acpi_scan_add_handler(&acpi_pnp_handler);
+}
diff --git a/drivers/acpi/acpi_processor.c b/drivers/acpi/acpi_processor.c
index 52c81c49cc7d..1c085742644f 100644
--- a/drivers/acpi/acpi_processor.c
+++ b/drivers/acpi/acpi_processor.c
@@ -268,7 +268,7 @@ static int acpi_processor_get_info(struct acpi_device *device)
         pr->apic_id = apic_id;
 
         cpu_index = acpi_map_cpuid(pr->apic_id, pr->acpi_id);
-        if (!cpu0_initialized) {
+        if (!cpu0_initialized && !acpi_lapic) {
                 cpu0_initialized = 1;
                 /* Handle UP system running SMP kernel, with no LAPIC in MADT */
                 if ((cpu_index == -1) && (num_online_cpus() == 1))
diff --git a/drivers/acpi/acpica/Makefile b/drivers/acpi/acpica/Makefile
index b7ed86a20427..8bb43f06e11f 100644
--- a/drivers/acpi/acpica/Makefile
+++ b/drivers/acpi/acpica/Makefile
@@ -135,6 +135,7 @@ acpi-y +=		\
         rsxface.o
 
 acpi-y +=               \
+        tbdata.o        \
         tbfadt.o        \
         tbfind.o        \
         tbinstal.o      \
diff --git a/drivers/acpi/acpica/acapps.h b/drivers/acpi/acpica/acapps.h
new file mode 100644
index 000000000000..8698ffba6f39
--- /dev/null
+++ b/drivers/acpi/acpica/acapps.h
@@ -0,0 +1,170 @@
+/******************************************************************************
+ *
+ * Module Name: acapps - common include for ACPI applications/tools
+ *
+ *****************************************************************************/
+
+/*
+ * Copyright (C) 2000 - 2014, Intel Corp.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions, and the following disclaimer,
+ *    without modification.
+ * 2. Redistributions in binary form must reproduce at minimum a disclaimer
+ *    substantially similar to the "NO WARRANTY" disclaimer below
+ *    ("Disclaimer") and any redistribution must be conditioned upon
+ *    including a substantially similar Disclaimer requirement for further
+ *    binary redistribution.
+ * 3. Neither the names of the above-listed copyright holders nor the names
+ *    of any contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#ifndef _ACAPPS
+#define _ACAPPS
+
+/* Common info for tool signons */
+
+#define ACPICA_NAME                 "Intel ACPI Component Architecture"
+#define ACPICA_COPYRIGHT            "Copyright (c) 2000 - 2014 Intel Corporation"
+
+#if ACPI_MACHINE_WIDTH == 64
+#define ACPI_WIDTH          "-64"
+
+#elif ACPI_MACHINE_WIDTH == 32
+#define ACPI_WIDTH          "-32"
+
+#else
+#error unknown ACPI_MACHINE_WIDTH
+#define ACPI_WIDTH          "-??"
+
+#endif
+
+/* Macros for signons and file headers */
+
+#define ACPI_COMMON_SIGNON(utility_name) \
+        "\n%s\n%s version %8.8X%s [%s]\n%s\n\n", \
+        ACPICA_NAME, \
+        utility_name, ((u32) ACPI_CA_VERSION), ACPI_WIDTH, __DATE__, \
+        ACPICA_COPYRIGHT
+
+#define ACPI_COMMON_HEADER(utility_name, prefix) \
+        "%s%s\n%s%s version %8.8X%s [%s]\n%s%s\n%s\n", \
+        prefix, ACPICA_NAME, \
+        prefix, utility_name, ((u32) ACPI_CA_VERSION), ACPI_WIDTH, __DATE__, \
+        prefix, ACPICA_COPYRIGHT, \
+        prefix
+
+/* Macros for usage messages */
+
+#define ACPI_USAGE_HEADER(usage) \
+        printf ("Usage: %s\nOptions:\n", usage);
+
+#define ACPI_OPTION(name, description) \
+        printf ("  %-18s%s\n", name, description);
+
+#define FILE_SUFFIX_DISASSEMBLY     "dsl"
+#define ACPI_TABLE_FILE_SUFFIX      ".dat"
+
+/*
+ * getopt
+ */
+int acpi_getopt(int argc, char **argv, char *opts);
+
+int acpi_getopt_argument(int argc, char **argv);
+
+extern int acpi_gbl_optind;
+extern int acpi_gbl_opterr;
+extern int acpi_gbl_sub_opt_char;
+extern char *acpi_gbl_optarg;
+
+/*
+ * cmfsize - Common get file size function
+ */
+u32 cm_get_file_size(FILE * file);
+
+#ifndef ACPI_DUMP_APP
+/*
+ * adisasm
+ */
+acpi_status
+ad_aml_disassemble(u8 out_to_file,
+                   char *filename, char *prefix, char **out_filename);
+
+void ad_print_statistics(void);
+
+acpi_status ad_find_dsdt(u8 **dsdt_ptr, u32 *dsdt_length);
+
+void ad_dump_tables(void);
+
+acpi_status ad_get_local_tables(void);
+
+acpi_status
+ad_parse_table(struct acpi_table_header *table,
+               acpi_owner_id * owner_id, u8 load_table, u8 external);
+
+acpi_status ad_display_tables(char *filename, struct acpi_table_header *table);
+
+acpi_status ad_display_statistics(void);
+
+/*
+ * adwalk
+ */
+void
+acpi_dm_cross_reference_namespace(union acpi_parse_object *parse_tree_root,
+                                  struct acpi_namespace_node *namespace_root,
+                                  acpi_owner_id owner_id);
+
+void acpi_dm_dump_tree(union acpi_parse_object *origin);
+
+void acpi_dm_find_orphan_methods(union acpi_parse_object *origin);
+
+void
+acpi_dm_finish_namespace_load(union acpi_parse_object *parse_tree_root,
+                              struct acpi_namespace_node *namespace_root,
+                              acpi_owner_id owner_id);
+
+void
+acpi_dm_convert_resource_indexes(union acpi_parse_object *parse_tree_root,
+                                 struct acpi_namespace_node *namespace_root);
+
+/*
+ * adfile
+ */
+acpi_status ad_initialize(void);
+
+char *fl_generate_filename(char *input_filename, char *suffix);
+
+acpi_status
+fl_split_input_pathname(char *input_path,
+                        char **out_directory_path, char **out_filename);
+
+char *ad_generate_filename(char *prefix, char *table_id);
+
+void
+ad_write_table(struct acpi_table_header *table,
+               u32 length, char *table_name, char *oem_table_id);
+#endif
+
+#endif                          /* _ACAPPS */
diff --git a/drivers/acpi/acpica/acevents.h b/drivers/acpi/acpica/acevents.h
index 68ec61fff188..7a7811a9fc26 100644
--- a/drivers/acpi/acpica/acevents.h
+++ b/drivers/acpi/acpica/acevents.h
@@ -104,9 +104,10 @@ acpi_status acpi_ev_finish_gpe(struct acpi_gpe_event_info *gpe_event_info);
  */
 acpi_status
 acpi_ev_create_gpe_block(struct acpi_namespace_node *gpe_device,
-                         struct acpi_generic_address *gpe_block_address,
+                         u64 address,
+                         u8 space_id,
                          u32 register_count,
-                         u8 gpe_block_base_number,
+                         u16 gpe_block_base_number,
                          u32 interrupt_number,
                          struct acpi_gpe_block_info **return_gpe_block);
 
diff --git a/drivers/acpi/acpica/acglobal.h b/drivers/acpi/acpica/acglobal.h
index a08a448068dd..115eedcade1e 100644
--- a/drivers/acpi/acpica/acglobal.h
+++ b/drivers/acpi/acpica/acglobal.h
@@ -44,144 +44,14 @@
 #ifndef __ACGLOBAL_H__
 #define __ACGLOBAL_H__
 
-/*
- * Ensure that the globals are actually defined and initialized only once.
- *
- * The use of these macros allows a single list of globals (here) in order
- * to simplify maintenance of the code.
- */
-#ifdef DEFINE_ACPI_GLOBALS
-#define ACPI_GLOBAL(type,name) \
-        extern type name; \
-        type name
-
-#define ACPI_INIT_GLOBAL(type,name,value) \
-        type name=value
-
-#else
-#define ACPI_GLOBAL(type,name) \
-        extern type name
-
-#define ACPI_INIT_GLOBAL(type,name,value) \
-        extern type name
-#endif
-
-#ifdef DEFINE_ACPI_GLOBALS
-
-/* Public globals, available from outside ACPICA subsystem */
-
 /*****************************************************************************
  *
- * Runtime configuration (static defaults that can be overriden at runtime)
+ * Globals related to the ACPI tables
  *
  ****************************************************************************/
 
-/*
- * Enable "slack" in the AML interpreter?  Default is FALSE, and the
- * interpreter strictly follows the ACPI specification. Setting to TRUE
- * allows the interpreter to ignore certain errors and/or bad AML constructs.
- *
- * Currently, these features are enabled by this flag:
- *
- * 1) Allow "implicit return" of last value in a control method
- * 2) Allow access beyond the end of an operation region
- * 3) Allow access to uninitialized locals/args (auto-init to integer 0)
- * 4) Allow ANY object type to be a source operand for the Store() operator
- * 5) Allow unresolved references (invalid target name) in package objects
- * 6) Enable warning messages for behavior that is not ACPI spec compliant
- */
-ACPI_INIT_GLOBAL(u8, acpi_gbl_enable_interpreter_slack, FALSE);
+/* Master list of all ACPI tables that were found in the RSDT/XSDT */
 
-/*
- * Automatically serialize all methods that create named objects? Default
- * is TRUE, meaning that all non_serialized methods are scanned once at
- * table load time to determine those that create named objects. Methods
- * that create named objects are marked Serialized in order to prevent
- * possible run-time problems if they are entered by more than one thread.
- */
-ACPI_INIT_GLOBAL(u8, acpi_gbl_auto_serialize_methods, TRUE);
-
-/*
- * Create the predefined _OSI method in the namespace? Default is TRUE
- * because ACPI CA is fully compatible with other ACPI implementations.
- * Changing this will revert ACPI CA (and machine ASL) to pre-OSI behavior.
- */
-ACPI_INIT_GLOBAL(u8, acpi_gbl_create_osi_method, TRUE);
-
-/*
- * Optionally use default values for the ACPI register widths. Set this to
- * TRUE to use the defaults, if an FADT contains incorrect widths/lengths.
- */
-ACPI_INIT_GLOBAL(u8, acpi_gbl_use_default_register_widths, TRUE);
-
-/*
- * Optionally enable output from the AML Debug Object.
- */
-ACPI_INIT_GLOBAL(u8, acpi_gbl_enable_aml_debug_object, FALSE);
-
-/*
- * Optionally copy the entire DSDT to local memory (instead of simply
- * mapping it.) There are some BIOSs that corrupt or replace the original
- * DSDT, creating the need for this option. Default is FALSE, do not copy
- * the DSDT.
- */
-ACPI_INIT_GLOBAL(u8, acpi_gbl_copy_dsdt_locally, FALSE);
-
-/*
- * Optionally ignore an XSDT if present and use the RSDT instead.
- * Although the ACPI specification requires that an XSDT be used instead
- * of the RSDT, the XSDT has been found to be corrupt or ill-formed on
- * some machines. Default behavior is to use the XSDT if present.
- */
-ACPI_INIT_GLOBAL(u8, acpi_gbl_do_not_use_xsdt, FALSE);
-
-/*
- * Optionally use 32-bit FADT addresses if and when there is a conflict
- * (address mismatch) between the 32-bit and 64-bit versions of the
- * address. Although ACPICA adheres to the ACPI specification which
- * requires the use of the corresponding 64-bit address if it is non-zero,
- * some machines have been found to have a corrupted non-zero 64-bit
- * address. Default is TRUE, favor the 32-bit addresses.
- */
-ACPI_INIT_GLOBAL(u8, acpi_gbl_use32_bit_fadt_addresses, TRUE);
-
-/*
- * Optionally truncate I/O addresses to 16 bits. Provides compatibility
- * with other ACPI implementations. NOTE: During ACPICA initialization,
- * this value is set to TRUE if any Windows OSI strings have been
- * requested by the BIOS.
- */
-ACPI_INIT_GLOBAL(u8, acpi_gbl_truncate_io_addresses, FALSE);
-
-/*
- * Disable runtime checking and repair of values returned by control methods.
- * Use only if the repair is causing a problem on a particular machine.
- */
-ACPI_INIT_GLOBAL(u8, acpi_gbl_disable_auto_repair, FALSE);
-
-/*
- * Optionally do not load any SSDTs from the RSDT/XSDT during initialization.
- * This can be useful for debugging ACPI problems on some machines.
- */
-ACPI_INIT_GLOBAL(u8, acpi_gbl_disable_ssdt_table_load, FALSE);
-
-/*
- * We keep track of the latest version of Windows that has been requested by
- * the BIOS.
- */
-ACPI_INIT_GLOBAL(u8, acpi_gbl_osi_data, 0);
-
-#endif                          /* DEFINE_ACPI_GLOBALS */
-
-/*****************************************************************************
- *
- * ACPI Table globals
- *
- ****************************************************************************/
-
-/*
- * Master list of all ACPI tables that were found in the RSDT/XSDT.
- */
 ACPI_GLOBAL(struct acpi_table_list, acpi_gbl_root_table_list);
 
 /* DSDT information. Used to check for DSDT corruption */
@@ -279,7 +149,6 @@ ACPI_GLOBAL(acpi_exception_handler, acpi_gbl_exception_handler);
 ACPI_GLOBAL(acpi_init_handler, acpi_gbl_init_handler);
 ACPI_GLOBAL(acpi_table_handler, acpi_gbl_table_handler);
 ACPI_GLOBAL(void *, acpi_gbl_table_handler_context);
-ACPI_GLOBAL(struct acpi_walk_state *, acpi_gbl_breakpoint_walk);
 ACPI_GLOBAL(acpi_interface_handler, acpi_gbl_interface_handler);
 ACPI_GLOBAL(struct acpi_sci_handler_info *, acpi_gbl_sci_handler_list);
 
@@ -296,7 +165,6 @@ ACPI_GLOBAL(u8, acpi_gbl_reg_methods_executed);
 /* Misc */
 
 ACPI_GLOBAL(u32, acpi_gbl_original_mode);
-ACPI_GLOBAL(u32, acpi_gbl_rsdp_original_location);
 ACPI_GLOBAL(u32, acpi_gbl_ns_lookup_count);
 ACPI_GLOBAL(u32, acpi_gbl_ps_find_count);
 ACPI_GLOBAL(u16, acpi_gbl_pm1_enable_register_save);
@@ -483,11 +351,6 @@ ACPI_GLOBAL(u16, acpi_gbl_node_type_count_misc);
 ACPI_GLOBAL(u32, acpi_gbl_num_nodes);
 ACPI_GLOBAL(u32, acpi_gbl_num_objects);
 
-ACPI_GLOBAL(u32, acpi_gbl_size_of_parse_tree);
-ACPI_GLOBAL(u32, acpi_gbl_size_of_method_trees);
-ACPI_GLOBAL(u32, acpi_gbl_size_of_node_entries);
-ACPI_GLOBAL(u32, acpi_gbl_size_of_acpi_objects);
-
 #endif                          /* ACPI_DEBUGGER */
 
 /*****************************************************************************
@@ -509,5 +372,6 @@ ACPI_INIT_GLOBAL(ACPI_FILE, acpi_gbl_debug_file, NULL);
  ****************************************************************************/
 
 extern const struct ah_predefined_name asl_predefined_info[];
+extern const struct ah_device_id asl_device_ids[];
 
 #endif                          /* __ACGLOBAL_H__ */
diff --git a/drivers/acpi/acpica/aclocal.h b/drivers/acpi/acpica/aclocal.h
index 52a21dafb540..91f801a2e689 100644
--- a/drivers/acpi/acpica/aclocal.h
+++ b/drivers/acpi/acpica/aclocal.h
@@ -450,9 +450,9 @@ struct acpi_gpe_event_info {
 struct acpi_gpe_register_info {
         struct acpi_generic_address status_address;     /* Address of status reg */
         struct acpi_generic_address enable_address;     /* Address of enable reg */
+        u16 base_gpe_number;    /* Base GPE number for this register */
         u8 enable_for_wake;     /* GPEs to keep enabled when sleeping */
         u8 enable_for_run;      /* GPEs to keep enabled when running */
-        u8 base_gpe_number;     /* Base GPE number for this register */
 };
 
 /*
@@ -466,11 +466,12 @@ struct acpi_gpe_block_info {
         struct acpi_gpe_xrupt_info *xrupt_block;        /* Backpointer to interrupt block */
         struct acpi_gpe_register_info *register_info;   /* One per GPE register pair */
         struct acpi_gpe_event_info *event_info; /* One for each GPE */
-        struct acpi_generic_address block_address;      /* Base address of the block */
+        u64 address;            /* Base address of the block */
         u32 register_count;     /* Number of register pairs in block */
         u16 gpe_count;          /* Number of individual GPEs in block */
-        u8 block_base_number;   /* Base GPE number for this block */
-        u8 initialized;         /* TRUE if this block is initialized */
+        u16 block_base_number;  /* Base GPE number for this block */
+        u8 space_id;
+        u8 initialized;         /* TRUE if this block is initialized */
 };
 
 /* Information about GPE interrupt handlers, one per each interrupt level used for GPEs */
@@ -733,7 +734,8 @@ union acpi_parse_value {
 #define ACPI_DASM_MATCHOP               0x06    /* Parent opcode is a Match() operator */
 #define ACPI_DASM_LNOT_PREFIX           0x07    /* Start of a Lnot_equal (etc.) pair of opcodes */
 #define ACPI_DASM_LNOT_SUFFIX           0x08    /* End  of a Lnot_equal (etc.) pair of opcodes */
-#define ACPI_DASM_IGNORE                0x09    /* Not used at this time */
+#define ACPI_DASM_HID_STRING            0x09    /* String is a _HID or _CID */
+#define ACPI_DASM_IGNORE                0x0A    /* Not used at this time */
 
 /*
  * Generic operation (for example:  If, While, Store)
@@ -1147,4 +1149,9 @@ struct ah_predefined_name {
 #endif
 };
 
+struct ah_device_id {
+        char *name;
+        char *description;
+};
+
 #endif                          /* __ACLOCAL_H__ */
diff --git a/drivers/acpi/acpica/acpredef.h b/drivers/acpi/acpica/acpredef.h
index a48d713e9599..bd08817cafd8 100644
--- a/drivers/acpi/acpica/acpredef.h
+++ b/drivers/acpi/acpica/acpredef.h
@@ -586,6 +586,10 @@ const union acpi_predefined_info acpi_gbl_predefined_methods[] = {
         {{"_LID", METHOD_0ARGS,
           METHOD_RETURNS(ACPI_RTYPE_INTEGER)}},
 
+        {{"_LPD", METHOD_0ARGS,
+          METHOD_RETURNS(ACPI_RTYPE_PACKAGE)}}, /* Variable-length (1 Int(rev), n Pkg (2 Int) */
+        PACKAGE_INFO(ACPI_PTYPE2_REV_FIXED, ACPI_RTYPE_INTEGER, 2, 0, 0, 0),
+
         {{"_MAT", METHOD_0ARGS,
           METHOD_RETURNS(ACPI_RTYPE_BUFFER)}},
 
@@ -698,12 +702,6 @@ const union acpi_predefined_info acpi_gbl_predefined_methods[] = {
           METHOD_RETURNS(ACPI_RTYPE_PACKAGE)}}, /* Variable-length (Refs) */
         PACKAGE_INFO(ACPI_PTYPE1_VAR, ACPI_RTYPE_REFERENCE, 0, 0, 0, 0),
 
-        {{"_PRP", METHOD_0ARGS,
-          METHOD_RETURNS(ACPI_RTYPE_PACKAGE)}}, /* Variable-length (Pkgs) each: 1 Str, 1 Int/Str/Pkg */
-        PACKAGE_INFO(ACPI_PTYPE2, ACPI_RTYPE_STRING, 1,
-                     ACPI_RTYPE_INTEGER | ACPI_RTYPE_STRING |
-                     ACPI_RTYPE_PACKAGE | ACPI_RTYPE_REFERENCE, 1, 0),
-
         {{"_PRS", METHOD_0ARGS,
           METHOD_RETURNS(ACPI_RTYPE_BUFFER)}},
 
diff --git a/drivers/acpi/acpica/actables.h b/drivers/acpi/acpica/actables.h
index 5fa4b2027697..f14882788eee 100644
--- a/drivers/acpi/acpica/actables.h
+++ b/drivers/acpi/acpica/actables.h
@@ -54,6 +54,31 @@ acpi_status acpi_tb_validate_rsdp(struct acpi_table_rsdp *rsdp);
 u8 *acpi_tb_scan_memory_for_rsdp(u8 *start_address, u32 length);
 
 /*
+ * tbdata - table data structure management
+ */
+acpi_status acpi_tb_get_next_root_index(u32 *table_index);
+
+void
+acpi_tb_init_table_descriptor(struct acpi_table_desc *table_desc,
+                              acpi_physical_address address,
+                              u8 flags, struct acpi_table_header *table);
+
+acpi_status
+acpi_tb_acquire_temp_table(struct acpi_table_desc *table_desc,
+                           acpi_physical_address address, u8 flags);
+
+void acpi_tb_release_temp_table(struct acpi_table_desc *table_desc);
+
+acpi_status acpi_tb_validate_temp_table(struct acpi_table_desc *table_desc);
+
+acpi_status
+acpi_tb_verify_temp_table(struct acpi_table_desc *table_desc, char *signature);
+
+u8 acpi_tb_is_table_loaded(u32 table_index);
+
+void acpi_tb_set_table_loaded_flag(u32 table_index, u8 is_loaded);
+
+/*
  * tbfadt - FADT parse/convert/validate
  */
 void acpi_tb_parse_fadt(u32 table_index);
@@ -72,22 +97,32 @@ acpi_tb_find_table(char *signature,
  */
 acpi_status acpi_tb_resize_root_table_list(void);
 
-acpi_status acpi_tb_verify_table(struct acpi_table_desc *table_desc);
+acpi_status acpi_tb_validate_table(struct acpi_table_desc *table_desc);
+
+void acpi_tb_invalidate_table(struct acpi_table_desc *table_desc);
+
+void acpi_tb_override_table(struct acpi_table_desc *old_table_desc);
 
-struct acpi_table_header *acpi_tb_table_override(struct acpi_table_header
-                                                 *table_header,
-                                                 struct acpi_table_desc
-                                                 *table_desc);
+acpi_status
+acpi_tb_acquire_table(struct acpi_table_desc *table_desc,
+                      struct acpi_table_header **table_ptr,
+                      u32 *table_length, u8 *table_flags);
+
+void
+acpi_tb_release_table(struct acpi_table_header *table,
+                      u32 table_length, u8 table_flags);
 
 acpi_status
-acpi_tb_add_table(struct acpi_table_desc *table_desc, u32 *table_index);
+acpi_tb_install_standard_table(acpi_physical_address address,
+                               u8 flags,
+                               u8 reload, u8 override, u32 *table_index);
 
 acpi_status
 acpi_tb_store_table(acpi_physical_address address,
                     struct acpi_table_header *table,
                     u32 length, u8 flags, u32 *table_index);
 
-void acpi_tb_delete_table(struct acpi_table_desc *table_desc);
+void acpi_tb_uninstall_table(struct acpi_table_desc *table_desc);
 
 void acpi_tb_terminate(void);
 
@@ -99,10 +134,6 @@ acpi_status acpi_tb_release_owner_id(u32 table_index);
 
 acpi_status acpi_tb_get_owner_id(u32 table_index, acpi_owner_id *owner_id);
 
-u8 acpi_tb_is_table_loaded(u32 table_index);
-
-void acpi_tb_set_table_loaded_flag(u32 table_index, u8 is_loaded);
-
 /*
  * tbutils - table manager utilities
  */
@@ -124,8 +155,13 @@ void acpi_tb_check_dsdt_header(void);
 struct acpi_table_header *acpi_tb_copy_dsdt(u32 table_index);
 
 void
-acpi_tb_install_table(acpi_physical_address address,
-                      char *signature, u32 table_index);
+acpi_tb_install_table_with_override(u32 table_index,
+                                    struct acpi_table_desc *new_table_desc,
+                                    u8 override);
+
+acpi_status
+acpi_tb_install_fixed_table(acpi_physical_address address,
+                            char *signature, u32 table_index);
 
 acpi_status acpi_tb_parse_root_table(acpi_physical_address rsdp_address);
 
diff --git a/drivers/acpi/acpica/acutils.h b/drivers/acpi/acpica/acutils.h
index ceeec0b7ccb1..1e256c5bda20 100644
--- a/drivers/acpi/acpica/acutils.h
+++ b/drivers/acpi/acpica/acutils.h
@@ -176,8 +176,7 @@ acpi_status acpi_ut_init_globals(void);
 
 char *acpi_ut_get_mutex_name(u32 mutex_id);
 
-const char *acpi_ut_get_notify_name(u32 notify_value);
-
+const char *acpi_ut_get_notify_name(u32 notify_value, acpi_object_type type);
 #endif
 
 char *acpi_ut_get_type_name(acpi_object_type type);
@@ -737,4 +736,11 @@ acpi_ut_method_error(const char *module_name,
                      struct acpi_namespace_node *node,
                      const char *path, acpi_status lookup_status);
 
+/*
+ * Utility functions for ACPI names and IDs
+ */
+const struct ah_predefined_name *acpi_ah_match_predefined_name(char *nameseg);
+
+const struct ah_device_id *acpi_ah_match_hardware_id(char *hid);
+
 #endif                          /* _ACUTILS_H */
diff --git a/drivers/acpi/acpica/evgpe.c b/drivers/acpi/acpica/evgpe.c
index 955f83da68a5..48f70013b488 100644
--- a/drivers/acpi/acpica/evgpe.c
+++ b/drivers/acpi/acpica/evgpe.c
@@ -383,7 +383,7 @@ u32 acpi_ev_gpe_detect(struct acpi_gpe_xrupt_info * gpe_xrupt_list)
                         if (!(gpe_register_info->enable_for_run |
                               gpe_register_info->enable_for_wake)) {
                                 ACPI_DEBUG_PRINT((ACPI_DB_INTERRUPTS,
-                                                  "Ignore disabled registers for GPE%02X-GPE%02X: "
+                                                  "Ignore disabled registers for GPE %02X-%02X: "
                                                   "RunEnable=%02X, WakeEnable=%02X\n",
                                                   gpe_register_info->
                                                   base_gpe_number,
@@ -416,7 +416,7 @@ u32 acpi_ev_gpe_detect(struct acpi_gpe_xrupt_info * gpe_xrupt_list)
                         }
 
                         ACPI_DEBUG_PRINT((ACPI_DB_INTERRUPTS,
-                                          "Read registers for GPE%02X-GPE%02X: Status=%02X, Enable=%02X, "
+                                          "Read registers for GPE %02X-%02X: Status=%02X, Enable=%02X, "
                                           "RunEnable=%02X, WakeEnable=%02X\n",
                                           gpe_register_info->base_gpe_number,
                                           gpe_register_info->base_gpe_number +
@@ -706,7 +706,8 @@ acpi_ev_gpe_dispatch(struct acpi_namespace_node *gpe_device,
                 status = acpi_hw_clear_gpe(gpe_event_info);
                 if (ACPI_FAILURE(status)) {
                         ACPI_EXCEPTION((AE_INFO, status,
-                                        "Unable to clear GPE%02X", gpe_number));
+                                        "Unable to clear GPE %02X",
+                                        gpe_number));
                         return_UINT32(ACPI_INTERRUPT_NOT_HANDLED);
                 }
         }
@@ -723,7 +724,7 @@ acpi_ev_gpe_dispatch(struct acpi_namespace_node *gpe_device,
         status = acpi_hw_low_set_gpe(gpe_event_info, ACPI_GPE_DISABLE);
         if (ACPI_FAILURE(status)) {
                 ACPI_EXCEPTION((AE_INFO, status,
-                                "Unable to disable GPE%02X", gpe_number));
+                                "Unable to disable GPE %02X", gpe_number));
                 return_UINT32(ACPI_INTERRUPT_NOT_HANDLED);
         }
 
@@ -764,7 +765,7 @@ acpi_ev_gpe_dispatch(struct acpi_namespace_node *gpe_device,
                                          gpe_event_info);
                 if (ACPI_FAILURE(status)) {
                         ACPI_EXCEPTION((AE_INFO, status,
-                                        "Unable to queue handler for GPE%02X - event disabled",
+                                        "Unable to queue handler for GPE %02X - event disabled",
                                         gpe_number));
                 }
                 break;
@@ -776,7 +777,7 @@ acpi_ev_gpe_dispatch(struct acpi_namespace_node *gpe_device,
                  * a GPE to be enabled if it has no handler or method.
                  */
                 ACPI_ERROR((AE_INFO,
-                            "No handler or method for GPE%02X, disabling event",
+                            "No handler or method for GPE %02X, disabling event",
                             gpe_number));
 
                 break;
diff --git a/drivers/acpi/acpica/evgpeblk.c b/drivers/acpi/acpica/evgpeblk.c
index caaed3c673fd..d86699eea33c 100644
--- a/drivers/acpi/acpica/evgpeblk.c
+++ b/drivers/acpi/acpica/evgpeblk.c
@@ -252,21 +252,17 @@ acpi_ev_create_gpe_info_blocks(struct acpi_gpe_block_info *gpe_block)
 
                 /* Init the register_info for this GPE register (8 GPEs) */
 
-                this_register->base_gpe_number =
-                    (u8) (gpe_block->block_base_number +
-                          (i * ACPI_GPE_REGISTER_WIDTH));
+                this_register->base_gpe_number = (u16)
+                    (gpe_block->block_base_number +
+                     (i * ACPI_GPE_REGISTER_WIDTH));
 
-                this_register->status_address.address =
-                    gpe_block->block_address.address + i;
+                this_register->status_address.address = gpe_block->address + i;
 
                 this_register->enable_address.address =
-                    gpe_block->block_address.address + i +
-                    gpe_block->register_count;
+                    gpe_block->address + i + gpe_block->register_count;
 
-                this_register->status_address.space_id =
-                    gpe_block->block_address.space_id;
-                this_register->enable_address.space_id =
-                    gpe_block->block_address.space_id;
+                this_register->status_address.space_id = gpe_block->space_id;
+                this_register->enable_address.space_id = gpe_block->space_id;
                 this_register->status_address.bit_width =
                     ACPI_GPE_REGISTER_WIDTH;
                 this_register->enable_address.bit_width =
@@ -334,9 +330,10 @@ error_exit:
 
 acpi_status
 acpi_ev_create_gpe_block(struct acpi_namespace_node *gpe_device,
-                         struct acpi_generic_address *gpe_block_address,
+                         u64 address,
+                         u8 space_id,
                          u32 register_count,
-                         u8 gpe_block_base_number,
+                         u16 gpe_block_base_number,
                          u32 interrupt_number,
                          struct acpi_gpe_block_info **return_gpe_block)
 {
@@ -359,15 +356,14 @@ acpi_ev_create_gpe_block(struct acpi_namespace_node *gpe_device,
 
         /* Initialize the new GPE block */
 
+        gpe_block->address = address;
+        gpe_block->space_id = space_id;
         gpe_block->node = gpe_device;
         gpe_block->gpe_count = (u16)(register_count * ACPI_GPE_REGISTER_WIDTH);
         gpe_block->initialized = FALSE;
         gpe_block->register_count = register_count;
         gpe_block->block_base_number = gpe_block_base_number;
 
-        ACPI_MEMCPY(&gpe_block->block_address, gpe_block_address,
-                    sizeof(struct acpi_generic_address));
-
         /*
          * Create the register_info and event_info sub-structures
          * Note: disables and clears all GPEs in the block
@@ -408,12 +404,14 @@ acpi_ev_create_gpe_block(struct acpi_namespace_node *gpe_device,
         }
 
         ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT,
-                              "    Initialized GPE %02X to %02X [%4.4s] %u regs on interrupt 0x%X\n",
+                              "    Initialized GPE %02X to %02X [%4.4s] %u regs on interrupt 0x%X%s\n",
                               (u32)gpe_block->block_base_number,
                               (u32)(gpe_block->block_base_number +
                                     (gpe_block->gpe_count - 1)),
                               gpe_device->name.ascii, gpe_block->register_count,
-                              interrupt_number));
+                              interrupt_number,
+                              interrupt_number ==
+                              acpi_gbl_FADT.sci_interrupt ? " (SCI)" : ""));
 
         /* Update global count of currently available GPEs */
 
diff --git a/drivers/acpi/acpica/evgpeinit.c b/drivers/acpi/acpica/evgpeinit.c
index ae779c1e871d..49fc7effd961 100644
--- a/drivers/acpi/acpica/evgpeinit.c
+++ b/drivers/acpi/acpica/evgpeinit.c
@@ -131,8 +131,10 @@ acpi_status acpi_ev_gpe_initialize(void)
                 /* Install GPE Block 0 */
 
                 status = acpi_ev_create_gpe_block(acpi_gbl_fadt_gpe_device,
-                                                  &acpi_gbl_FADT.xgpe0_block,
-                                                  register_count0, 0,
+                                                  acpi_gbl_FADT.xgpe0_block.
+                                                  address,
+                                                  acpi_gbl_FADT.xgpe0_block.
+                                                  space_id, register_count0, 0,
                                                   acpi_gbl_FADT.sci_interrupt,
                                                   &acpi_gbl_gpe_fadt_blocks[0]);
 
@@ -169,8 +171,10 @@ acpi_status acpi_ev_gpe_initialize(void)
 
                         status =
                             acpi_ev_create_gpe_block(acpi_gbl_fadt_gpe_device,
-                                                     &acpi_gbl_FADT.xgpe1_block,
-                                                     register_count1,
+                                                     acpi_gbl_FADT.xgpe1_block.
+                                                     address,
+                                                     acpi_gbl_FADT.xgpe1_block.
+                                                     space_id, register_count1,
                                                      acpi_gbl_FADT.gpe1_base,
                                                      acpi_gbl_FADT.
                                                      sci_interrupt,
diff --git a/drivers/acpi/acpica/evmisc.c b/drivers/acpi/acpica/evmisc.c
index 5d594eb2e5ec..24ea3424981b 100644
--- a/drivers/acpi/acpica/evmisc.c
+++ b/drivers/acpi/acpica/evmisc.c
@@ -167,7 +167,8 @@ acpi_ev_queue_notify_request(struct acpi_namespace_node * node,
                           "Dispatching Notify on [%4.4s] (%s) Value 0x%2.2X (%s) Node %p\n",
                           acpi_ut_get_node_name(node),
                           acpi_ut_get_type_name(node->type), notify_value,
-                          acpi_ut_get_notify_name(notify_value), node));
+                          acpi_ut_get_notify_name(notify_value, ACPI_TYPE_ANY),
+                          node));
 
         status = acpi_os_execute(OSL_NOTIFY_HANDLER, acpi_ev_notify_dispatch,
                                  info);
diff --git a/drivers/acpi/acpica/evsci.c b/drivers/acpi/acpica/evsci.c
index 4d8a709c1fc4..29630e303829 100644
--- a/drivers/acpi/acpica/evsci.c
+++ b/drivers/acpi/acpica/evsci.c
@@ -117,7 +117,7 @@ static u32 ACPI_SYSTEM_XFACE acpi_ev_sci_xrupt_handler(void *context)
         ACPI_FUNCTION_TRACE(ev_sci_xrupt_handler);
 
         /*
-         * We are guaranteed by the ACPI CA initialization/shutdown code that
+         * We are guaranteed by the ACPICA initialization/shutdown code that
          * if this interrupt handler is installed, ACPI is enabled.
          */
 
diff --git a/drivers/acpi/acpica/evxface.c b/drivers/acpi/acpica/evxface.c
index a734b27da061..11e5803b8b41 100644
--- a/drivers/acpi/acpica/evxface.c
+++ b/drivers/acpi/acpica/evxface.c
@@ -239,7 +239,7 @@ acpi_remove_notify_handler(acpi_handle device,
         union acpi_operand_object *obj_desc;
         union acpi_operand_object *handler_obj;
         union acpi_operand_object *previous_handler_obj;
-        acpi_status status;
+        acpi_status status = AE_OK;
         u32 i;
 
         ACPI_FUNCTION_TRACE(acpi_remove_notify_handler);
@@ -251,20 +251,17 @@ acpi_remove_notify_handler(acpi_handle device,
                 return_ACPI_STATUS(AE_BAD_PARAMETER);
         }
 
-        /* Make sure all deferred notify tasks are completed */
-
-        acpi_os_wait_events_complete();
-
-        status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
-        if (ACPI_FAILURE(status)) {
-                return_ACPI_STATUS(status);
-        }
-
         /* Root Object. Global handlers are removed here */
 
         if (device == ACPI_ROOT_OBJECT) {
                 for (i = 0; i < ACPI_NUM_NOTIFY_TYPES; i++) {
                         if (handler_type & (i + 1)) {
+                                status =
+                                    acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
+                                if (ACPI_FAILURE(status)) {
+                                        return_ACPI_STATUS(status);
+                                }
+
                                 if (!acpi_gbl_global_notify[i].handler ||
                                     (acpi_gbl_global_notify[i].handler !=
                                      handler)) {
@@ -277,31 +274,40 @@ acpi_remove_notify_handler(acpi_handle device,
 
                                 acpi_gbl_global_notify[i].handler = NULL;
                                 acpi_gbl_global_notify[i].context = NULL;
+
+                                (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
+
+                                /* Make sure all deferred notify tasks are completed */
+
+                                acpi_os_wait_events_complete();
                         }
                 }
 
-                goto unlock_and_exit;
+                return_ACPI_STATUS(AE_OK);
         }
 
         /* All other objects: Are Notifies allowed on this object? */
 
         if (!acpi_ev_is_notify_object(node)) {
-                status = AE_TYPE;
-                goto unlock_and_exit;
+                return_ACPI_STATUS(AE_TYPE);
         }
 
         /* Must have an existing internal object */
 
         obj_desc = acpi_ns_get_attached_object(node);
         if (!obj_desc) {
-                status = AE_NOT_EXIST;
-                goto unlock_and_exit;
+                return_ACPI_STATUS(AE_NOT_EXIST);
         }
 
         /* Internal object exists. Find the handler and remove it */
 
         for (i = 0; i < ACPI_NUM_NOTIFY_TYPES; i++) {
                 if (handler_type & (i + 1)) {
+                        status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
+                        if (ACPI_FAILURE(status)) {
+                                return_ACPI_STATUS(status);
+                        }
+
                         handler_obj = obj_desc->common_notify.notify_list[i];
                         previous_handler_obj = NULL;
 
@@ -329,10 +335,17 @@ acpi_remove_notify_handler(acpi_handle device,
                                     handler_obj->notify.next[i];
                         }
 
+                        (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
+
+                        /* Make sure all deferred notify tasks are completed */
+
+                        acpi_os_wait_events_complete();
                         acpi_ut_remove_reference(handler_obj);
                 }
         }
 
+        return_ACPI_STATUS(status);
+
 unlock_and_exit:
         (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
         return_ACPI_STATUS(status);
@@ -457,6 +470,8 @@ exit:
         return_ACPI_STATUS(status);
 }
 
+ACPI_EXPORT_SYMBOL(acpi_install_sci_handler)
+
 /*******************************************************************************
  *
  * FUNCTION:    acpi_remove_sci_handler
@@ -468,7 +483,6 @@ exit:
  * DESCRIPTION: Remove a handler for a System Control Interrupt.
  *
  ******************************************************************************/
-
 acpi_status acpi_remove_sci_handler(acpi_sci_handler address)
 {
         struct acpi_sci_handler_info *prev_sci_handler;
@@ -522,6 +536,8 @@ unlock_and_exit:
         return_ACPI_STATUS(status);
 }
 
+ACPI_EXPORT_SYMBOL(acpi_remove_sci_handler)
+
 /*******************************************************************************
  *
  * FUNCTION:    acpi_install_global_event_handler
@@ -537,7 +553,6 @@ unlock_and_exit:
  *              Can be used to update event counters, etc.
  *
  ******************************************************************************/
-
 acpi_status
 acpi_install_global_event_handler(acpi_gbl_event_handler handler, void *context)
 {
@@ -840,10 +855,6 @@ acpi_remove_gpe_handler(acpi_handle gpe_device,
                 return_ACPI_STATUS(AE_BAD_PARAMETER);
         }
 
-        /* Make sure all deferred GPE tasks are completed */
-
-        acpi_os_wait_events_complete();
-
         status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
         if (ACPI_FAILURE(status)) {
                 return_ACPI_STATUS(status);
@@ -895,9 +906,17 @@ acpi_remove_gpe_handler(acpi_handle gpe_device,
                 (void)acpi_ev_add_gpe_reference(gpe_event_info);
         }
 
+        acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
+        (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
+
+        /* Make sure all deferred GPE tasks are completed */
+
+        acpi_os_wait_events_complete();
+
         /* Now we can free the handler object */
 
         ACPI_FREE(handler);
+        return_ACPI_STATUS(status);
 
 unlock_and_exit:
         acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
diff --git a/drivers/acpi/acpica/evxfgpe.c b/drivers/acpi/acpica/evxfgpe.c
index 20a1392ffe06..cb534faf5369 100644
--- a/drivers/acpi/acpica/evxfgpe.c
+++ b/drivers/acpi/acpica/evxfgpe.c
@@ -599,9 +599,10 @@ acpi_install_gpe_block(acpi_handle gpe_device,
          * For user-installed GPE Block Devices, the gpe_block_base_number
          * is always zero
          */
-        status =
-            acpi_ev_create_gpe_block(node, gpe_block_address, register_count, 0,
-                                     interrupt_number, &gpe_block);
+        status = acpi_ev_create_gpe_block(node, gpe_block_address->address,
+                                          gpe_block_address->space_id,
+                                          register_count, 0, interrupt_number,
+                                          &gpe_block);
         if (ACPI_FAILURE(status)) {
                 goto unlock_and_exit;
         }
diff --git a/drivers/acpi/acpica/exconfig.c b/drivers/acpi/acpica/exconfig.c
index 8ba1464efd11..7d2949420db7 100644
--- a/drivers/acpi/acpica/exconfig.c
+++ b/drivers/acpi/acpica/exconfig.c
@@ -343,16 +343,14 @@ acpi_ex_load_op(union acpi_operand_object *obj_desc,
                 struct acpi_walk_state *walk_state)
 {
         union acpi_operand_object *ddb_handle;
+        struct acpi_table_header *table_header;
         struct acpi_table_header *table;
-        struct acpi_table_desc table_desc;
         u32 table_index;
         acpi_status status;
         u32 length;
 
         ACPI_FUNCTION_TRACE(ex_load_op);
 
-        ACPI_MEMSET(&table_desc, 0, sizeof(struct acpi_table_desc));
-
         /* Source Object can be either an op_region or a Buffer/Field */
 
         switch (obj_desc->common.type) {
@@ -380,17 +378,17 @@ acpi_ex_load_op(union acpi_operand_object *obj_desc,
 
                 /* Get the table header first so we can get the table length */
 
-                table = ACPI_ALLOCATE(sizeof(struct acpi_table_header));
-                if (!table) {
+                table_header = ACPI_ALLOCATE(sizeof(struct acpi_table_header));
+                if (!table_header) {
                         return_ACPI_STATUS(AE_NO_MEMORY);
                 }
 
                 status =
                     acpi_ex_region_read(obj_desc,
                                         sizeof(struct acpi_table_header),
-                                        ACPI_CAST_PTR(u8, table));
-                length = table->length;
-                ACPI_FREE(table);
+                                        ACPI_CAST_PTR(u8, table_header));
+                length = table_header->length;
+                ACPI_FREE(table_header);
 
                 if (ACPI_FAILURE(status)) {
                         return_ACPI_STATUS(status);
@@ -420,22 +418,19 @@ acpi_ex_load_op(union acpi_operand_object *obj_desc,
 
                 /* Allocate a buffer for the table */
 
-                table_desc.pointer = ACPI_ALLOCATE(length);
-                if (!table_desc.pointer) {
+                table = ACPI_ALLOCATE(length);
+                if (!table) {
                         return_ACPI_STATUS(AE_NO_MEMORY);
                 }
 
                 /* Read the entire table */
 
                 status = acpi_ex_region_read(obj_desc, length,
-                                             ACPI_CAST_PTR(u8,
-                                                           table_desc.pointer));
+                                             ACPI_CAST_PTR(u8, table));
                 if (ACPI_FAILURE(status)) {
-                        ACPI_FREE(table_desc.pointer);
+                        ACPI_FREE(table);
                         return_ACPI_STATUS(status);
                 }
-
-                table_desc.address = obj_desc->region.address;
                 break;
 
         case ACPI_TYPE_BUFFER:  /* Buffer or resolved region_field */
@@ -452,10 +447,10 @@ acpi_ex_load_op(union acpi_operand_object *obj_desc,
 
                 /* Get the actual table length from the table header */
 
-                table =
+                table_header =
                     ACPI_CAST_PTR(struct acpi_table_header,
                                   obj_desc->buffer.pointer);
-                length = table->length;
+                length = table_header->length;
 
                 /* Table cannot extend beyond the buffer */
 
@@ -470,13 +465,12 @@ acpi_ex_load_op(union acpi_operand_object *obj_desc,
                  * Copy the table from the buffer because the buffer could be modified
                  * or even deleted in the future
                  */
-                table_desc.pointer = ACPI_ALLOCATE(length);
-                if (!table_desc.pointer) {
+                table = ACPI_ALLOCATE(length);
+                if (!table) {
                         return_ACPI_STATUS(AE_NO_MEMORY);
                 }
 
-                ACPI_MEMCPY(table_desc.pointer, table, length);
-                table_desc.address = ACPI_TO_INTEGER(table_desc.pointer);
+                ACPI_MEMCPY(table, table_header, length);
                 break;
 
         default:
@@ -484,27 +478,32 @@ acpi_ex_load_op(union acpi_operand_object *obj_desc,
                 return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
         }
 
-        /* Validate table checksum (will not get validated in tb_add_table) */
-
-        status = acpi_tb_verify_checksum(table_desc.pointer, length);
-        if (ACPI_FAILURE(status)) {
-                ACPI_FREE(table_desc.pointer);
-                return_ACPI_STATUS(status);
-        }
-
-        /* Complete the table descriptor */
+        /* Install the new table into the local data structures */
 
-        table_desc.length = length;
-        table_desc.flags = ACPI_TABLE_ORIGIN_ALLOCATED;
+        ACPI_INFO((AE_INFO, "Dynamic OEM Table Load:"));
+        (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
 
-        /* Install the new table into the local data structures */
+        status = acpi_tb_install_standard_table(ACPI_PTR_TO_PHYSADDR(table),
+                                                ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL,
+                                                TRUE, TRUE, &table_index);
 
-        status = acpi_tb_add_table(&table_desc, &table_index);
+        (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
         if (ACPI_FAILURE(status)) {
 
                 /* Delete allocated table buffer */
 
-                acpi_tb_delete_table(&table_desc);
+                ACPI_FREE(table);
+                return_ACPI_STATUS(status);
+        }
+
+        /*
+         * Note: Now table is "INSTALLED", it must be validated before
+         * loading.
+         */
+        status =
+            acpi_tb_validate_table(&acpi_gbl_root_table_list.
+                                   tables[table_index]);
+        if (ACPI_FAILURE(status)) {
                 return_ACPI_STATUS(status);
         }
 
@@ -536,9 +535,6 @@ acpi_ex_load_op(union acpi_operand_object *obj_desc,
                 return_ACPI_STATUS(status);
         }
 
-        ACPI_INFO((AE_INFO, "Dynamic OEM Table Load:"));
-        acpi_tb_print_table_header(0, table_desc.pointer);
-
         /* Remove the reference by added by acpi_ex_store above */
 
         acpi_ut_remove_reference(ddb_handle);
@@ -546,8 +542,7 @@ acpi_ex_load_op(union acpi_operand_object *obj_desc,
         /* Invoke table handler if present */
 
         if (acpi_gbl_table_handler) {
-                (void)acpi_gbl_table_handler(ACPI_TABLE_EVENT_LOAD,
-                                             table_desc.pointer,
+                (void)acpi_gbl_table_handler(ACPI_TABLE_EVENT_LOAD, table,
                                              acpi_gbl_table_handler_context);
         }
 
@@ -576,6 +571,13 @@ acpi_status acpi_ex_unload_table(union acpi_operand_object *ddb_handle)
         ACPI_FUNCTION_TRACE(ex_unload_table);
 
         /*
+         * Temporarily emit a warning so that the ASL for the machine can be
+         * hopefully obtained. This is to say that the Unload() operator is
+         * extremely rare if not completely unused.
+         */
+        ACPI_WARNING((AE_INFO, "Received request to unload an ACPI table"));
+
+        /*
          * Validate the handle
          * Although the handle is partially validated in acpi_ex_reconfiguration()
          * when it calls acpi_ex_resolve_operands(), the handle is more completely
diff --git a/drivers/acpi/acpica/exdump.c b/drivers/acpi/acpica/exdump.c
index 973fdae00f94..925202acc3e4 100644
--- a/drivers/acpi/acpica/exdump.c
+++ b/drivers/acpi/acpica/exdump.c
@@ -134,9 +134,11 @@ static struct acpi_exdump_info acpi_ex_dump_method[9] = {
         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(method.aml_start), "Aml Start"}
 };
 
-static struct acpi_exdump_info acpi_ex_dump_mutex[5] = {
+static struct acpi_exdump_info acpi_ex_dump_mutex[6] = {
         {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE(acpi_ex_dump_mutex), NULL},
         {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(mutex.sync_level), "Sync Level"},
+        {ACPI_EXD_UINT8, ACPI_EXD_OFFSET(mutex.original_sync_level),
+         "Original Sync Level"},
         {ACPI_EXD_POINTER, ACPI_EXD_OFFSET(mutex.owner_thread), "Owner Thread"},
         {ACPI_EXD_UINT16, ACPI_EXD_OFFSET(mutex.acquisition_depth),
          "Acquire Depth"},
diff --git a/drivers/acpi/acpica/hwpci.c b/drivers/acpi/acpica/hwpci.c
index e701d8c33dbf..6aade8e1d2a1 100644
--- a/drivers/acpi/acpica/hwpci.c
+++ b/drivers/acpi/acpica/hwpci.c
@@ -140,11 +140,12 @@ acpi_hw_derive_pci_id(struct acpi_pci_id *pci_id,
                 /* Walk the list, updating the PCI device/function/bus numbers */
 
                 status = acpi_hw_process_pci_list(pci_id, list_head);
-        }
 
-        /* Always delete the list */
+                /* Delete the list */
+
+                acpi_hw_delete_pci_list(list_head);
+        }
 
-        acpi_hw_delete_pci_list(list_head);
         return_ACPI_STATUS(status);
 }
 
@@ -187,6 +188,10 @@ acpi_hw_build_pci_list(acpi_handle root_pci_device,
         while (1) {
                 status = acpi_get_parent(current_device, &parent_device);
                 if (ACPI_FAILURE(status)) {
+
+                        /* Must delete the list before exit */
+
+                        acpi_hw_delete_pci_list(*return_list_head);
                         return (status);
                 }
 
@@ -199,6 +204,10 @@ acpi_hw_build_pci_list(acpi_handle root_pci_device,
 
                 list_element = ACPI_ALLOCATE(sizeof(struct acpi_pci_device));
                 if (!list_element) {
+
+                        /* Must delete the list before exit */
+
+                        acpi_hw_delete_pci_list(*return_list_head);
                         return (AE_NO_MEMORY);
                 }
 
diff --git a/drivers/acpi/acpica/rscreate.c b/drivers/acpi/acpica/rscreate.c
index 75d369050657..049d9c22a0f9 100644
--- a/drivers/acpi/acpica/rscreate.c
+++ b/drivers/acpi/acpica/rscreate.c
@@ -72,6 +72,8 @@ acpi_buffer_to_resource(u8 *aml_buffer,
         void *resource;
         void *current_resource_ptr;
 
+        ACPI_FUNCTION_TRACE(acpi_buffer_to_resource);
+
         /*
          * Note: we allow AE_AML_NO_RESOURCE_END_TAG, since an end tag
          * is not required here.
@@ -85,7 +87,7 @@ acpi_buffer_to_resource(u8 *aml_buffer,
                 status = AE_OK;
         }
         if (ACPI_FAILURE(status)) {
-                return (status);
+                return_ACPI_STATUS(status);
         }
 
         /* Allocate a buffer for the converted resource */
@@ -93,7 +95,7 @@ acpi_buffer_to_resource(u8 *aml_buffer,
         resource = ACPI_ALLOCATE_ZEROED(list_size_needed);
         current_resource_ptr = resource;
         if (!resource) {
-                return (AE_NO_MEMORY);
+                return_ACPI_STATUS(AE_NO_MEMORY);
         }
 
         /* Perform the AML-to-Resource conversion */
@@ -110,9 +112,11 @@ acpi_buffer_to_resource(u8 *aml_buffer,
                 *resource_ptr = resource;
         }
 
-        return (status);
+        return_ACPI_STATUS(status);
 }
 
+ACPI_EXPORT_SYMBOL(acpi_buffer_to_resource)
+
 /*******************************************************************************
  *
  * FUNCTION:    acpi_rs_create_resource_list
@@ -130,10 +134,9 @@ acpi_buffer_to_resource(u8 *aml_buffer,
  *              of device resources.
  *
  ******************************************************************************/
-
 acpi_status
 acpi_rs_create_resource_list(union acpi_operand_object *aml_buffer,
-                             struct acpi_buffer * output_buffer)
+                             struct acpi_buffer *output_buffer)
 {
 
         acpi_status status;
diff --git a/drivers/acpi/acpica/tbdata.c b/drivers/acpi/acpica/tbdata.c
new file mode 100644
index 000000000000..f499c10ceb4a
--- /dev/null
+++ b/drivers/acpi/acpica/tbdata.c
@@ -0,0 +1,760 @@
+/******************************************************************************
+ *
+ * Module Name: tbdata - Table manager data structure functions
+ *
+ *****************************************************************************/
+
+/*
+ * Copyright (C) 2000 - 2014, Intel Corp.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions, and the following disclaimer,
+ *    without modification.
+ * 2. Redistributions in binary form must reproduce at minimum a disclaimer
+ *    substantially similar to the "NO WARRANTY" disclaimer below
+ *    ("Disclaimer") and any redistribution must be conditioned upon
+ *    including a substantially similar Disclaimer requirement for further
+ *    binary redistribution.
+ * 3. Neither the names of the above-listed copyright holders nor the names
+ *    of any contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#include <acpi/acpi.h>
+#include "accommon.h"
+#include "acnamesp.h"
+#include "actables.h"
+
+#define _COMPONENT          ACPI_TABLES
+ACPI_MODULE_NAME("tbdata")
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_tb_init_table_descriptor
+ *
+ * PARAMETERS:  table_desc              - Table descriptor
+ *              address                 - Physical address of the table
+ *              flags                   - Allocation flags of the table
+ *              table                   - Pointer to the table
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Initialize a new table descriptor
+ *
+ ******************************************************************************/
+void
+acpi_tb_init_table_descriptor(struct acpi_table_desc *table_desc,
+                              acpi_physical_address address,
+                              u8 flags, struct acpi_table_header *table)
+{
+
+        /*
+         * Initialize the table descriptor. Set the pointer to NULL, since the
+         * table is not fully mapped at this time.
+         */
+        ACPI_MEMSET(table_desc, 0, sizeof(struct acpi_table_desc));
+        table_desc->address = address;
+        table_desc->length = table->length;
+        table_desc->flags = flags;
+        ACPI_MOVE_32_TO_32(table_desc->signature.ascii, table->signature);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_tb_acquire_table
+ *
+ * PARAMETERS:  table_desc          - Table descriptor
+ *              table_ptr           - Where table is returned
+ *              table_length        - Where table length is returned
+ *              table_flags         - Where table allocation flags are returned
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Acquire an ACPI table. It can be used for tables not
+ *              maintained in the acpi_gbl_root_table_list.
+ *
+ ******************************************************************************/
+
+acpi_status
+acpi_tb_acquire_table(struct acpi_table_desc *table_desc,
+                      struct acpi_table_header **table_ptr,
+                      u32 *table_length, u8 *table_flags)
+{
+        struct acpi_table_header *table = NULL;
+
+        switch (table_desc->flags & ACPI_TABLE_ORIGIN_MASK) {
+        case ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL:
+
+                table =
+                    acpi_os_map_memory(table_desc->address, table_desc->length);
+                break;
+
+        case ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL:
+        case ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL:
+
+                table =
+                    ACPI_CAST_PTR(struct acpi_table_header,
+                                  table_desc->address);
+                break;
+
+        default:
+
+                break;
+        }
+
+        /* Table is not valid yet */
+
+        if (!table) {
+                return (AE_NO_MEMORY);
+        }
+
+        /* Fill the return values */
+
+        *table_ptr = table;
+        *table_length = table_desc->length;
+        *table_flags = table_desc->flags;
+        return (AE_OK);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_tb_release_table
+ *
+ * PARAMETERS:  table               - Pointer for the table
+ *              table_length        - Length for the table
+ *              table_flags         - Allocation flags for the table
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Release a table. The inverse of acpi_tb_acquire_table().
+ *
+ ******************************************************************************/
+
+void
+acpi_tb_release_table(struct acpi_table_header *table,
+                      u32 table_length, u8 table_flags)
+{
+
+        switch (table_flags & ACPI_TABLE_ORIGIN_MASK) {
+        case ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL:
+
+                acpi_os_unmap_memory(table, table_length);
+                break;
+
+        case ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL:
+        case ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL:
+        default:
+
+                break;
+        }
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_tb_acquire_temp_table
+ *
+ * PARAMETERS:  table_desc          - Table descriptor to be acquired
+ *              address             - Address of the table
+ *              flags               - Allocation flags of the table
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: This function validates the table header to obtain the length
+ *              of a table and fills the table descriptor to make its state as
+ *              "INSTALLED". Such a table descriptor is only used for verified
+ *              installation.
+ *
+ ******************************************************************************/
+
+acpi_status
+acpi_tb_acquire_temp_table(struct acpi_table_desc *table_desc,
+                           acpi_physical_address address, u8 flags)
+{
+        struct acpi_table_header *table_header;
+
+        switch (flags & ACPI_TABLE_ORIGIN_MASK) {
+        case ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL:
+
+                /* Get the length of the full table from the header */
+
+                table_header =
+                    acpi_os_map_memory(address,
+                                       sizeof(struct acpi_table_header));
+                if (!table_header) {
+                        return (AE_NO_MEMORY);
+                }
+
+                acpi_tb_init_table_descriptor(table_desc, address, flags,
+                                              table_header);
+                acpi_os_unmap_memory(table_header,
+                                     sizeof(struct acpi_table_header));
+                return (AE_OK);
+
+        case ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL:
+        case ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL:
+
+                table_header = ACPI_CAST_PTR(struct acpi_table_header, address);
+                if (!table_header) {
+                        return (AE_NO_MEMORY);
+                }
+
+                acpi_tb_init_table_descriptor(table_desc, address, flags,
+                                              table_header);
+                return (AE_OK);
+
+        default:
+
+                break;
+        }
+
+        /* Table is not valid yet */
+
+        return (AE_NO_MEMORY);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_tb_release_temp_table
+ *
+ * PARAMETERS:  table_desc          - Table descriptor to be released
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: The inverse of acpi_tb_acquire_temp_table().
+ *
+ *****************************************************************************/
+
+void acpi_tb_release_temp_table(struct acpi_table_desc *table_desc)
+{
+
+        /*
+         * Note that the .Address is maintained by the callers of
+         * acpi_tb_acquire_temp_table(), thus do not invoke acpi_tb_uninstall_table()
+         * where .Address will be freed.
+         */
+        acpi_tb_invalidate_table(table_desc);
+}
+
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_tb_validate_table
+ *
+ * PARAMETERS:  table_desc          - Table descriptor
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: This function is called to validate the table, the returned
+ *              table descriptor is in "VALIDATED" state.
+ *
+ *****************************************************************************/
+
+acpi_status acpi_tb_validate_table(struct acpi_table_desc *table_desc)
+{
+        acpi_status status = AE_OK;
+
+        ACPI_FUNCTION_TRACE(tb_validate_table);
+
+        /* Validate the table if necessary */
+
+        if (!table_desc->pointer) {
+                status = acpi_tb_acquire_table(table_desc, &table_desc->pointer,
+                                               &table_desc->length,
+                                               &table_desc->flags);
+                if (!table_desc->pointer) {
+                        status = AE_NO_MEMORY;
+                }
+        }
+
+        return_ACPI_STATUS(status);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_tb_invalidate_table
+ *
+ * PARAMETERS:  table_desc          - Table descriptor
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Invalidate one internal ACPI table, this is the inverse of
+ *              acpi_tb_validate_table().
+ *
+ ******************************************************************************/
+
+void acpi_tb_invalidate_table(struct acpi_table_desc *table_desc)
+{
+
+        ACPI_FUNCTION_TRACE(tb_invalidate_table);
+
+        /* Table must be validated */
+
+        if (!table_desc->pointer) {
+                return_VOID;
+        }
+
+        acpi_tb_release_table(table_desc->pointer, table_desc->length,
+                              table_desc->flags);
+        table_desc->pointer = NULL;
+
+        return_VOID;
+}
+
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_tb_validate_temp_table
+ *
+ * PARAMETERS:  table_desc          - Table descriptor
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: This function is called to validate the table, the returned
+ *              table descriptor is in "VALIDATED" state.
+ *
+ *****************************************************************************/
+
+acpi_status acpi_tb_validate_temp_table(struct acpi_table_desc *table_desc)
+{
+
+        if (!table_desc->pointer && !acpi_gbl_verify_table_checksum) {
+                /*
+                 * Only validates the header of the table.
+                 * Note that Length contains the size of the mapping after invoking
+                 * this work around, this value is required by
+                 * acpi_tb_release_temp_table().
+                 * We can do this because in acpi_init_table_descriptor(), the Length
+                 * field of the installed descriptor is filled with the actual
+                 * table length obtaining from the table header.
+                 */
+                table_desc->length = sizeof(struct acpi_table_header);
+        }
+
+        return (acpi_tb_validate_table(table_desc));
+}
+
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_tb_verify_temp_table
+ *
+ * PARAMETERS:  table_desc          - Table descriptor
+ *              signature           - Table signature to verify
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: This function is called to validate and verify the table, the
+ *              returned table descriptor is in "VALIDATED" state.
+ *
+ *****************************************************************************/
+
+acpi_status
+acpi_tb_verify_temp_table(struct acpi_table_desc * table_desc, char *signature)
+{
+        acpi_status status = AE_OK;
+
+        ACPI_FUNCTION_TRACE(tb_verify_temp_table);
+
+        /* Validate the table */
+
+        status = acpi_tb_validate_temp_table(table_desc);
+        if (ACPI_FAILURE(status)) {
+                return_ACPI_STATUS(AE_NO_MEMORY);
+        }
+
+        /* If a particular signature is expected (DSDT/FACS), it must match */
+
+        if (signature && !ACPI_COMPARE_NAME(&table_desc->signature, signature)) {
+                ACPI_BIOS_ERROR((AE_INFO,
+                                 "Invalid signature 0x%X for ACPI table, expected [%s]",
+                                 table_desc->signature.integer, signature));
+                status = AE_BAD_SIGNATURE;
+                goto invalidate_and_exit;
+        }
+
+        /* Verify the checksum */
+
+        if (acpi_gbl_verify_table_checksum) {
+                status =
+                    acpi_tb_verify_checksum(table_desc->pointer,
+                                            table_desc->length);
+                if (ACPI_FAILURE(status)) {
+                        ACPI_EXCEPTION((AE_INFO, AE_NO_MEMORY,
+                                        "%4.4s " ACPI_PRINTF_UINT
+                                        " Attempted table install failed",
+                                        acpi_ut_valid_acpi_name(table_desc->
+                                                                signature.
+                                                                ascii) ?
+                                        table_desc->signature.ascii : "????",
+                                        ACPI_FORMAT_TO_UINT(table_desc->
+                                                            address)));
+                        goto invalidate_and_exit;
+                }
+        }
+
+        return_ACPI_STATUS(AE_OK);
+
+invalidate_and_exit:
+        acpi_tb_invalidate_table(table_desc);
+        return_ACPI_STATUS(status);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_tb_resize_root_table_list
+ *
+ * PARAMETERS:  None
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Expand the size of global table array
+ *
+ ******************************************************************************/
+
+acpi_status acpi_tb_resize_root_table_list(void)
+{
+        struct acpi_table_desc *tables;
+        u32 table_count;
+
+        ACPI_FUNCTION_TRACE(tb_resize_root_table_list);
+
+        /* allow_resize flag is a parameter to acpi_initialize_tables */
+
+        if (!(acpi_gbl_root_table_list.flags & ACPI_ROOT_ALLOW_RESIZE)) {
+                ACPI_ERROR((AE_INFO,
+                            "Resize of Root Table Array is not allowed"));
+                return_ACPI_STATUS(AE_SUPPORT);
+        }
+
+        /* Increase the Table Array size */
+
+        if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) {
+                table_count = acpi_gbl_root_table_list.max_table_count;
+        } else {
+                table_count = acpi_gbl_root_table_list.current_table_count;
+        }
+
+        tables = ACPI_ALLOCATE_ZEROED(((acpi_size) table_count +
+                                       ACPI_ROOT_TABLE_SIZE_INCREMENT) *
+                                      sizeof(struct acpi_table_desc));
+        if (!tables) {
+                ACPI_ERROR((AE_INFO,
+                            "Could not allocate new root table array"));
+                return_ACPI_STATUS(AE_NO_MEMORY);
+        }
+
+        /* Copy and free the previous table array */
+
+        if (acpi_gbl_root_table_list.tables) {
+                ACPI_MEMCPY(tables, acpi_gbl_root_table_list.tables,
+                            (acpi_size) table_count *
+                            sizeof(struct acpi_table_desc));
+
+                if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) {
+                        ACPI_FREE(acpi_gbl_root_table_list.tables);
+                }
+        }
+
+        acpi_gbl_root_table_list.tables = tables;
+        acpi_gbl_root_table_list.max_table_count =
+            table_count + ACPI_ROOT_TABLE_SIZE_INCREMENT;
+        acpi_gbl_root_table_list.flags |= ACPI_ROOT_ORIGIN_ALLOCATED;
+
+        return_ACPI_STATUS(AE_OK);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_tb_get_next_root_index
+ *
+ * PARAMETERS:  table_index         - Where table index is returned
+ *
+ * RETURN:      Status and table index.
+ *
+ * DESCRIPTION: Allocate a new ACPI table entry to the global table list
+ *
+ ******************************************************************************/
+
+acpi_status acpi_tb_get_next_root_index(u32 *table_index)
+{
+        acpi_status status;
+
+        /* Ensure that there is room for the table in the Root Table List */
+
+        if (acpi_gbl_root_table_list.current_table_count >=
+            acpi_gbl_root_table_list.max_table_count) {
+                status = acpi_tb_resize_root_table_list();
+                if (ACPI_FAILURE(status)) {
+                        return (status);
+                }
+        }
+
+        *table_index = acpi_gbl_root_table_list.current_table_count;
+        acpi_gbl_root_table_list.current_table_count++;
+        return (AE_OK);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_tb_terminate
+ *
+ * PARAMETERS:  None
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Delete all internal ACPI tables
+ *
+ ******************************************************************************/
+
+void acpi_tb_terminate(void)
+{
+        u32 i;
+
+        ACPI_FUNCTION_TRACE(tb_terminate);
+
+        (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
+
+        /* Delete the individual tables */
+
+        for (i = 0; i < acpi_gbl_root_table_list.current_table_count; i++) {
+                acpi_tb_uninstall_table(&acpi_gbl_root_table_list.tables[i]);
+        }
+
+        /*
+         * Delete the root table array if allocated locally. Array cannot be
+         * mapped, so we don't need to check for that flag.
+         */
+        if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) {
+                ACPI_FREE(acpi_gbl_root_table_list.tables);
+        }
+
+        acpi_gbl_root_table_list.tables = NULL;
+        acpi_gbl_root_table_list.flags = 0;
+        acpi_gbl_root_table_list.current_table_count = 0;
+
+        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "ACPI Tables freed\n"));
+
+        (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
+        return_VOID;
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_tb_delete_namespace_by_owner
+ *
+ * PARAMETERS:  table_index         - Table index
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Delete all namespace objects created when this table was loaded.
+ *
+ ******************************************************************************/
+
+acpi_status acpi_tb_delete_namespace_by_owner(u32 table_index)
+{
+        acpi_owner_id owner_id;
+        acpi_status status;
+
+        ACPI_FUNCTION_TRACE(tb_delete_namespace_by_owner);
+
+        status = acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
+        if (ACPI_FAILURE(status)) {
+                return_ACPI_STATUS(status);
+        }
+
+        if (table_index >= acpi_gbl_root_table_list.current_table_count) {
+
+                /* The table index does not exist */
+
+                (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
+                return_ACPI_STATUS(AE_NOT_EXIST);
+        }
+
+        /* Get the owner ID for this table, used to delete namespace nodes */
+
+        owner_id = acpi_gbl_root_table_list.tables[table_index].owner_id;
+        (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
+
+        /*
+         * Need to acquire the namespace writer lock to prevent interference
+         * with any concurrent namespace walks. The interpreter must be
+         * released during the deletion since the acquisition of the deletion
+         * lock may block, and also since the execution of a namespace walk
+         * must be allowed to use the interpreter.
+         */
+        (void)acpi_ut_release_mutex(ACPI_MTX_INTERPRETER);
+        status = acpi_ut_acquire_write_lock(&acpi_gbl_namespace_rw_lock);
+
+        acpi_ns_delete_namespace_by_owner(owner_id);
+        if (ACPI_FAILURE(status)) {
+                return_ACPI_STATUS(status);
+        }
+
+        acpi_ut_release_write_lock(&acpi_gbl_namespace_rw_lock);
+
+        status = acpi_ut_acquire_mutex(ACPI_MTX_INTERPRETER);
+        return_ACPI_STATUS(status);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_tb_allocate_owner_id
+ *
+ * PARAMETERS:  table_index         - Table index
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Allocates owner_id in table_desc
+ *
+ ******************************************************************************/
+
+acpi_status acpi_tb_allocate_owner_id(u32 table_index)
+{
+        acpi_status status = AE_BAD_PARAMETER;
+
+        ACPI_FUNCTION_TRACE(tb_allocate_owner_id);
+
+        (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
+        if (table_index < acpi_gbl_root_table_list.current_table_count) {
+                status =
+                    acpi_ut_allocate_owner_id(&
+                                              (acpi_gbl_root_table_list.
+                                               tables[table_index].owner_id));
+        }
+
+        (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
+        return_ACPI_STATUS(status);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_tb_release_owner_id
+ *
+ * PARAMETERS:  table_index         - Table index
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Releases owner_id in table_desc
+ *
+ ******************************************************************************/
+
+acpi_status acpi_tb_release_owner_id(u32 table_index)
+{
+        acpi_status status = AE_BAD_PARAMETER;
+
+        ACPI_FUNCTION_TRACE(tb_release_owner_id);
+
+        (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
+        if (table_index < acpi_gbl_root_table_list.current_table_count) {
+                acpi_ut_release_owner_id(&
+                                         (acpi_gbl_root_table_list.
+                                          tables[table_index].owner_id));
+                status = AE_OK;
+        }
+
+        (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
+        return_ACPI_STATUS(status);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_tb_get_owner_id
+ *
+ * PARAMETERS:  table_index         - Table index
+ *              owner_id            - Where the table owner_id is returned
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: returns owner_id for the ACPI table
+ *
+ ******************************************************************************/
+
+acpi_status acpi_tb_get_owner_id(u32 table_index, acpi_owner_id * owner_id)
+{
+        acpi_status status = AE_BAD_PARAMETER;
+
+        ACPI_FUNCTION_TRACE(tb_get_owner_id);
+
+        (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
+        if (table_index < acpi_gbl_root_table_list.current_table_count) {
+                *owner_id =
+                    acpi_gbl_root_table_list.tables[table_index].owner_id;
+                status = AE_OK;
+        }
+
+        (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
+        return_ACPI_STATUS(status);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_tb_is_table_loaded
+ *
+ * PARAMETERS:  table_index         - Index into the root table
+ *
+ * RETURN:      Table Loaded Flag
+ *
+ ******************************************************************************/
+
+u8 acpi_tb_is_table_loaded(u32 table_index)
+{
+        u8 is_loaded = FALSE;
+
+        (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
+        if (table_index < acpi_gbl_root_table_list.current_table_count) {
+                is_loaded = (u8)
+                    (acpi_gbl_root_table_list.tables[table_index].flags &
+                     ACPI_TABLE_IS_LOADED);
+        }
+
+        (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
+        return (is_loaded);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_tb_set_table_loaded_flag
+ *
+ * PARAMETERS:  table_index         - Table index
+ *              is_loaded           - TRUE if table is loaded, FALSE otherwise
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Sets the table loaded flag to either TRUE or FALSE.
+ *
+ ******************************************************************************/
+
+void acpi_tb_set_table_loaded_flag(u32 table_index, u8 is_loaded)
+{
+
+        (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
+        if (table_index < acpi_gbl_root_table_list.current_table_count) {
+                if (is_loaded) {
+                        acpi_gbl_root_table_list.tables[table_index].flags |=
+                            ACPI_TABLE_IS_LOADED;
+                } else {
+                        acpi_gbl_root_table_list.tables[table_index].flags &=
+                            ~ACPI_TABLE_IS_LOADED;
+                }
+        }
+
+        (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
+}
diff --git a/drivers/acpi/acpica/tbfadt.c b/drivers/acpi/acpica/tbfadt.c
index ec14588254d4..41519a958083 100644
--- a/drivers/acpi/acpica/tbfadt.c
+++ b/drivers/acpi/acpica/tbfadt.c
@@ -52,7 +52,8 @@ ACPI_MODULE_NAME("tbfadt")
 static void
 acpi_tb_init_generic_address(struct acpi_generic_address *generic_address,
                              u8 space_id,
-                             u8 byte_width, u64 address, char *register_name);
+                             u8 byte_width,
+                             u64 address, char *register_name, u8 flags);
 
 static void acpi_tb_convert_fadt(void);
 
@@ -69,13 +70,14 @@ typedef struct acpi_fadt_info {
         u16 address32;
         u16 length;
         u8 default_length;
-        u8 type;
+        u8 flags;
 
 } acpi_fadt_info;
 
 #define ACPI_FADT_OPTIONAL          0
 #define ACPI_FADT_REQUIRED          1
 #define ACPI_FADT_SEPARATE_LENGTH   2
+#define ACPI_FADT_GPE_REGISTER      4
 
 static struct acpi_fadt_info fadt_info_table[] = {
         {"Pm1aEventBlock",
@@ -125,14 +127,14 @@ static struct acpi_fadt_info fadt_info_table[] = {
          ACPI_FADT_OFFSET(gpe0_block),
          ACPI_FADT_OFFSET(gpe0_block_length),
          0,
-         ACPI_FADT_SEPARATE_LENGTH},
+         ACPI_FADT_SEPARATE_LENGTH | ACPI_FADT_GPE_REGISTER},
 
         {"Gpe1Block",
          ACPI_FADT_OFFSET(xgpe1_block),
          ACPI_FADT_OFFSET(gpe1_block),
          ACPI_FADT_OFFSET(gpe1_block_length),
          0,
-         ACPI_FADT_SEPARATE_LENGTH}
+         ACPI_FADT_SEPARATE_LENGTH | ACPI_FADT_GPE_REGISTER}
 };
 
 #define ACPI_FADT_INFO_ENTRIES \
@@ -189,19 +191,29 @@ static struct acpi_fadt_pm_info fadt_pm_info_table[] = {
 static void
 acpi_tb_init_generic_address(struct acpi_generic_address *generic_address,
                              u8 space_id,
-                             u8 byte_width, u64 address, char *register_name)
+                             u8 byte_width,
+                             u64 address, char *register_name, u8 flags)
 {
         u8 bit_width;
 
-        /* Bit width field in the GAS is only one byte long, 255 max */
-
+        /*
+         * Bit width field in the GAS is only one byte long, 255 max.
+         * Check for bit_width overflow in GAS.
+         */
         bit_width = (u8)(byte_width * 8);
-
-        if (byte_width > 31) {  /* (31*8)=248 */
-                ACPI_ERROR((AE_INFO,
-                            "%s - 32-bit FADT register is too long (%u bytes, %u bits) "
-                            "to convert to GAS struct - 255 bits max, truncating",
-                            register_name, byte_width, (byte_width * 8)));
+        if (byte_width > 31) {  /* (31*8)=248, (32*8)=256 */
+                /*
+                 * No error for GPE blocks, because we do not use the bit_width
+                 * for GPEs, the legacy length (byte_width) is used instead to
+                 * allow for a large number of GPEs.
+                 */
+                if (!(flags & ACPI_FADT_GPE_REGISTER)) {
+                        ACPI_ERROR((AE_INFO,
+                                    "%s - 32-bit FADT register is too long (%u bytes, %u bits) "
+                                    "to convert to GAS struct - 255 bits max, truncating",
+                                    register_name, byte_width,
+                                    (byte_width * 8)));
+                }
 
                 bit_width = 255;
         }
@@ -332,15 +344,15 @@ void acpi_tb_parse_fadt(u32 table_index)
 
         /* Obtain the DSDT and FACS tables via their addresses within the FADT */
 
-        acpi_tb_install_table((acpi_physical_address) acpi_gbl_FADT.Xdsdt,
-                              ACPI_SIG_DSDT, ACPI_TABLE_INDEX_DSDT);
+        acpi_tb_install_fixed_table((acpi_physical_address) acpi_gbl_FADT.Xdsdt,
+                                    ACPI_SIG_DSDT, ACPI_TABLE_INDEX_DSDT);
 
         /* If Hardware Reduced flag is set, there is no FACS */
 
         if (!acpi_gbl_reduced_hardware) {
-                acpi_tb_install_table((acpi_physical_address) acpi_gbl_FADT.
-                                      Xfacs, ACPI_SIG_FACS,
-                                      ACPI_TABLE_INDEX_FACS);
+                acpi_tb_install_fixed_table((acpi_physical_address)
+                                            acpi_gbl_FADT.Xfacs, ACPI_SIG_FACS,
+                                            ACPI_TABLE_INDEX_FACS);
         }
 }
 
@@ -450,6 +462,7 @@ static void acpi_tb_convert_fadt(void)
         struct acpi_generic_address *address64;
         u32 address32;
         u8 length;
+        u8 flags;
         u32 i;
 
         /*
@@ -515,6 +528,7 @@ static void acpi_tb_convert_fadt(void)
                                        fadt_info_table[i].length);
 
                 name = fadt_info_table[i].name;
+                flags = fadt_info_table[i].flags;
 
                 /*
                  * Expand the ACPI 1.0 32-bit addresses to the ACPI 2.0 64-bit "X"
@@ -554,7 +568,7 @@ static void acpi_tb_convert_fadt(void)
                                                                            [i].
                                                                            length),
                                                              (u64)address32,
-                                                             name);
+                                                             name, flags);
                         } else if (address64->address != (u64)address32) {
 
                                 /* Address mismatch */
@@ -582,7 +596,8 @@ static void acpi_tb_convert_fadt(void)
                                                                       length),
                                                                      (u64)
                                                                      address32,
-                                                                     name);
+                                                                     name,
+                                                                     flags);
                                 }
                         }
                 }
@@ -603,7 +618,7 @@ static void acpi_tb_convert_fadt(void)
                                            address64->bit_width));
                 }
 
-                if (fadt_info_table[i].type & ACPI_FADT_REQUIRED) {
+                if (fadt_info_table[i].flags & ACPI_FADT_REQUIRED) {
                         /*
                          * Field is required (Pm1a_event, Pm1a_control).
                          * Both the address and length must be non-zero.
@@ -617,7 +632,7 @@ static void acpi_tb_convert_fadt(void)
                                                                     address),
                                                  length));
                         }
-                } else if (fadt_info_table[i].type & ACPI_FADT_SEPARATE_LENGTH) {
+                } else if (fadt_info_table[i].flags & ACPI_FADT_SEPARATE_LENGTH) {
                         /*
                          * Field is optional (Pm2_control, GPE0, GPE1) AND has its own
                          * length field. If present, both the address and length must
@@ -726,7 +741,7 @@ static void acpi_tb_setup_fadt_registers(void)
                                                      (fadt_pm_info_table[i].
                                                       register_num *
                                                       pm1_register_byte_width),
-                                                     "PmRegisters");
+                                                     "PmRegisters", 0);
                 }
         }
 }
diff --git a/drivers/acpi/acpica/tbfind.c b/drivers/acpi/acpica/tbfind.c
index c12003947bd5..cb947700206c 100644
--- a/drivers/acpi/acpica/tbfind.c
+++ b/drivers/acpi/acpica/tbfind.c
@@ -99,8 +99,8 @@ acpi_tb_find_table(char *signature,
                         /* Table is not currently mapped, map it */
 
                         status =
-                            acpi_tb_verify_table(&acpi_gbl_root_table_list.
-                                                 tables[i]);
+                            acpi_tb_validate_table(&acpi_gbl_root_table_list.
+                                                   tables[i]);
                         if (ACPI_FAILURE(status)) {
                                 return_ACPI_STATUS(status);
                         }
diff --git a/drivers/acpi/acpica/tbinstal.c b/drivers/acpi/acpica/tbinstal.c
index e3040947e9a0..755b90c40ddf 100644
--- a/drivers/acpi/acpica/tbinstal.c
+++ b/drivers/acpi/acpica/tbinstal.c
@@ -43,688 +43,483 @@
 
 #include <acpi/acpi.h>
 #include "accommon.h"
-#include "acnamesp.h"
 #include "actables.h"
 
 #define _COMPONENT          ACPI_TABLES
 ACPI_MODULE_NAME("tbinstal")
 
-/******************************************************************************
+/* Local prototypes */
+static u8
+acpi_tb_compare_tables(struct acpi_table_desc *table_desc, u32 table_index);
+
+/*******************************************************************************
  *
- * FUNCTION:    acpi_tb_verify_table
+ * FUNCTION:    acpi_tb_compare_tables
  *
- * PARAMETERS:  table_desc          - table
+ * PARAMETERS:  table_desc          - Table 1 descriptor to be compared
+ *              table_index         - Index of table 2 to be compared
  *
- * RETURN:      Status
+ * RETURN:      TRUE if both tables are identical.
  *
- * DESCRIPTION: this function is called to verify and map table
+ * DESCRIPTION: This function compares a table with another table that has
+ *              already been installed in the root table list.
  *
- *****************************************************************************/
-acpi_status acpi_tb_verify_table(struct acpi_table_desc *table_desc)
+ ******************************************************************************/
+
+static u8
+acpi_tb_compare_tables(struct acpi_table_desc *table_desc, u32 table_index)
 {
         acpi_status status = AE_OK;
+        u8 is_identical;
+        struct acpi_table_header *table;
+        u32 table_length;
+        u8 table_flags;
 
-        ACPI_FUNCTION_TRACE(tb_verify_table);
-
-        /* Map the table if necessary */
-
-        if (!table_desc->pointer) {
-                if ((table_desc->flags & ACPI_TABLE_ORIGIN_MASK) ==
-                    ACPI_TABLE_ORIGIN_MAPPED) {
-                        table_desc->pointer =
-                            acpi_os_map_memory(table_desc->address,
-                                               table_desc->length);
-                }
-                if (!table_desc->pointer) {
-                        return_ACPI_STATUS(AE_NO_MEMORY);
-                }
+        status =
+            acpi_tb_acquire_table(&acpi_gbl_root_table_list.tables[table_index],
+                                  &table, &table_length, &table_flags);
+        if (ACPI_FAILURE(status)) {
+                return (FALSE);
         }
 
-        /* Always calculate checksum, ignore bad checksum if requested */
+        /*
+         * Check for a table match on the entire table length,
+         * not just the header.
+         */
+        is_identical = (u8)((table_desc->length != table_length ||
+                             ACPI_MEMCMP(table_desc->pointer, table,
+                                         table_length)) ? FALSE : TRUE);
 
-        status =
-            acpi_tb_verify_checksum(table_desc->pointer, table_desc->length);
+        /* Release the acquired table */
 
-        return_ACPI_STATUS(status);
+        acpi_tb_release_table(table, table_length, table_flags);
+        return (is_identical);
 }
 
 /*******************************************************************************
  *
- * FUNCTION:    acpi_tb_add_table
+ * FUNCTION:    acpi_tb_install_table_with_override
  *
- * PARAMETERS:  table_desc          - Table descriptor
- *              table_index         - Where the table index is returned
+ * PARAMETERS:  table_index             - Index into root table array
+ *              new_table_desc          - New table descriptor to install
+ *              override                - Whether override should be performed
  *
- * RETURN:      Status
+ * RETURN:      None
  *
- * DESCRIPTION: This function is called to add an ACPI table. It is used to
- *              dynamically load tables via the Load and load_table AML
- *              operators.
+ * DESCRIPTION: Install an ACPI table into the global data structure. The
+ *              table override mechanism is called to allow the host
+ *              OS to replace any table before it is installed in the root
+ *              table array.
  *
  ******************************************************************************/
 
-acpi_status
-acpi_tb_add_table(struct acpi_table_desc *table_desc, u32 *table_index)
+void
+acpi_tb_install_table_with_override(u32 table_index,
+                                    struct acpi_table_desc *new_table_desc,
+                                    u8 override)
 {
-        u32 i;
-        acpi_status status = AE_OK;
 
-        ACPI_FUNCTION_TRACE(tb_add_table);
-
-        if (!table_desc->pointer) {
-                status = acpi_tb_verify_table(table_desc);
-                if (ACPI_FAILURE(status) || !table_desc->pointer) {
-                        return_ACPI_STATUS(status);
-                }
+        if (table_index >= acpi_gbl_root_table_list.current_table_count) {
+                return;
         }
 
         /*
-         * Validate the incoming table signature.
+         * ACPI Table Override:
          *
-         * 1) Originally, we checked the table signature for "SSDT" or "PSDT".
-         * 2) We added support for OEMx tables, signature "OEM".
-         * 3) Valid tables were encountered with a null signature, so we just
-         *    gave up on validating the signature, (05/2008).
-         * 4) We encountered non-AML tables such as the MADT, which caused
-         *    interpreter errors and kernel faults. So now, we once again allow
-         *    only "SSDT", "OEMx", and now, also a null signature. (05/2011).
+         * Before we install the table, let the host OS override it with a new
+         * one if desired. Any table within the RSDT/XSDT can be replaced,
+         * including the DSDT which is pointed to by the FADT.
          */
-        if ((table_desc->pointer->signature[0] != 0x00) &&
-            (!ACPI_COMPARE_NAME(table_desc->pointer->signature, ACPI_SIG_SSDT))
-            && (ACPI_STRNCMP(table_desc->pointer->signature, "OEM", 3))) {
-                ACPI_BIOS_ERROR((AE_INFO,
-                                 "Table has invalid signature [%4.4s] (0x%8.8X), "
-                                 "must be SSDT or OEMx",
-                                 acpi_ut_valid_acpi_name(table_desc->pointer->
-                                                         signature) ?
-                                 table_desc->pointer->signature : "????",
-                                 *(u32 *)table_desc->pointer->signature));
-
-                return_ACPI_STATUS(AE_BAD_SIGNATURE);
+        if (override) {
+                acpi_tb_override_table(new_table_desc);
         }
 
-        (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
+        acpi_tb_init_table_descriptor(&acpi_gbl_root_table_list.
+                                      tables[table_index],
+                                      new_table_desc->address,
+                                      new_table_desc->flags,
+                                      new_table_desc->pointer);
 
-        /* Check if table is already registered */
+        acpi_tb_print_table_header(new_table_desc->address,
+                                   new_table_desc->pointer);
 
-        for (i = 0; i < acpi_gbl_root_table_list.current_table_count; ++i) {
-                if (!acpi_gbl_root_table_list.tables[i].pointer) {
-                        status =
-                            acpi_tb_verify_table(&acpi_gbl_root_table_list.
-                                                 tables[i]);
-                        if (ACPI_FAILURE(status)
-                            || !acpi_gbl_root_table_list.tables[i].pointer) {
-                                continue;
-                        }
-                }
+        /* Set the global integer width (based upon revision of the DSDT) */
 
-                /*
-                 * Check for a table match on the entire table length,
-                 * not just the header.
-                 */
-                if (table_desc->length !=
-                    acpi_gbl_root_table_list.tables[i].length) {
-                        continue;
-                }
-
-                if (ACPI_MEMCMP(table_desc->pointer,
-                                acpi_gbl_root_table_list.tables[i].pointer,
-                                acpi_gbl_root_table_list.tables[i].length)) {
-                        continue;
-                }
-
-                /*
-                 * Note: the current mechanism does not unregister a table if it is
-                 * dynamically unloaded. The related namespace entries are deleted,
-                 * but the table remains in the root table list.
-                 *
-                 * The assumption here is that the number of different tables that
-                 * will be loaded is actually small, and there is minimal overhead
-                 * in just keeping the table in case it is needed again.
-                 *
-                 * If this assumption changes in the future (perhaps on large
-                 * machines with many table load/unload operations), tables will
-                 * need to be unregistered when they are unloaded, and slots in the
-                 * root table list should be reused when empty.
-                 */
-
-                /*
-                 * Table is already registered.
-                 * We can delete the table that was passed as a parameter.
-                 */
-                acpi_tb_delete_table(table_desc);
-                *table_index = i;
-
-                if (acpi_gbl_root_table_list.tables[i].
-                    flags & ACPI_TABLE_IS_LOADED) {
-
-                        /* Table is still loaded, this is an error */
-
-                        status = AE_ALREADY_EXISTS;
-                        goto release;
-                } else {
-                        /* Table was unloaded, allow it to be reloaded */
-
-                        table_desc->pointer =
-                            acpi_gbl_root_table_list.tables[i].pointer;
-                        table_desc->address =
-                            acpi_gbl_root_table_list.tables[i].address;
-                        status = AE_OK;
-                        goto print_header;
-                }
+        if (table_index == ACPI_TABLE_INDEX_DSDT) {
+                acpi_ut_set_integer_width(new_table_desc->pointer->revision);
         }
-
-        /*
-         * ACPI Table Override:
-         * Allow the host to override dynamically loaded tables.
-         * NOTE: the table is fully mapped at this point, and the mapping will
-         * be deleted by tb_table_override if the table is actually overridden.
-         */
-        (void)acpi_tb_table_override(table_desc->pointer, table_desc);
-
-        /* Add the table to the global root table list */
-
-        status = acpi_tb_store_table(table_desc->address, table_desc->pointer,
-                                     table_desc->length, table_desc->flags,
-                                     table_index);
-        if (ACPI_FAILURE(status)) {
-                goto release;
-        }
-
-print_header:
-        acpi_tb_print_table_header(table_desc->address, table_desc->pointer);
-
-release:
-        (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
-        return_ACPI_STATUS(status);
 }
 
 /*******************************************************************************
  *
- * FUNCTION:    acpi_tb_table_override
+ * FUNCTION:    acpi_tb_install_fixed_table
  *
- * PARAMETERS:  table_header        - Header for the original table
- *              table_desc          - Table descriptor initialized for the
- *                                    original table. May or may not be mapped.
+ * PARAMETERS:  address                 - Physical address of DSDT or FACS
+ *              signature               - Table signature, NULL if no need to
+ *                                        match
+ *              table_index             - Index into root table array
  *
- * RETURN:      Pointer to the entire new table. NULL if table not overridden.
- *              If overridden, installs the new table within the input table
- *              descriptor.
+ * RETURN:      Status
  *
- * DESCRIPTION: Attempt table override by calling the OSL override functions.
- *              Note: If the table is overridden, then the entire new table
- *              is mapped and returned by this function.
+ * DESCRIPTION: Install a fixed ACPI table (DSDT/FACS) into the global data
+ *              structure.
  *
  ******************************************************************************/
 
-struct acpi_table_header *acpi_tb_table_override(struct acpi_table_header
-                                                 *table_header,
-                                                 struct acpi_table_desc
-                                                 *table_desc)
+acpi_status
+acpi_tb_install_fixed_table(acpi_physical_address address,
+                            char *signature, u32 table_index)
 {
+        struct acpi_table_desc new_table_desc;
         acpi_status status;
-        struct acpi_table_header *new_table = NULL;
-        acpi_physical_address new_address = 0;
-        u32 new_table_length = 0;
-        u8 new_flags;
-        char *override_type;
 
-        /* (1) Attempt logical override (returns a logical address) */
+        ACPI_FUNCTION_TRACE(tb_install_fixed_table);
 
-        status = acpi_os_table_override(table_header, &new_table);
-        if (ACPI_SUCCESS(status) && new_table) {
-                new_address = ACPI_PTR_TO_PHYSADDR(new_table);
-                new_table_length = new_table->length;
-                new_flags = ACPI_TABLE_ORIGIN_OVERRIDE;
-                override_type = "Logical";
-                goto finish_override;
+        if (!address) {
+                ACPI_ERROR((AE_INFO,
+                            "Null physical address for ACPI table [%s]",
+                            signature));
+                return (AE_NO_MEMORY);
         }
 
-        /* (2) Attempt physical override (returns a physical address) */
+        /* Fill a table descriptor for validation */
 
-        status = acpi_os_physical_table_override(table_header,
-                                                 &new_address,
-                                                 &new_table_length);
-        if (ACPI_SUCCESS(status) && new_address && new_table_length) {
-
-                /* Map the entire new table */
-
-                new_table = acpi_os_map_memory(new_address, new_table_length);
-                if (!new_table) {
-                        ACPI_EXCEPTION((AE_INFO, AE_NO_MEMORY,
-                                        "%4.4s " ACPI_PRINTF_UINT
-                                        " Attempted physical table override failed",
-                                        table_header->signature,
-                                        ACPI_FORMAT_TO_UINT(table_desc->
-                                                            address)));
-                        return (NULL);
-                }
-
-                override_type = "Physical";
-                new_flags = ACPI_TABLE_ORIGIN_MAPPED;
-                goto finish_override;
+        status = acpi_tb_acquire_temp_table(&new_table_desc, address,
+                                            ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL);
+        if (ACPI_FAILURE(status)) {
+                ACPI_ERROR((AE_INFO, "Could not acquire table length at %p",
+                            ACPI_CAST_PTR(void, address)));
+                return_ACPI_STATUS(status);
         }
 
-        return (NULL);          /* There was no override */
-
-finish_override:
-
-        ACPI_INFO((AE_INFO, "%4.4s " ACPI_PRINTF_UINT
-                   " %s table override, new table: " ACPI_PRINTF_UINT,
-                   table_header->signature,
-                   ACPI_FORMAT_TO_UINT(table_desc->address),
-                   override_type, ACPI_FORMAT_TO_UINT(new_table)));
+        /* Validate and verify a table before installation */
 
-        /* We can now unmap/delete the original table (if fully mapped) */
+        status = acpi_tb_verify_temp_table(&new_table_desc, signature);
+        if (ACPI_FAILURE(status)) {
+                goto release_and_exit;
+        }
 
-        acpi_tb_delete_table(table_desc);
+        acpi_tb_install_table_with_override(table_index, &new_table_desc, TRUE);
 
-        /* Setup descriptor for the new table */
+release_and_exit:
 
-        table_desc->address = new_address;
-        table_desc->pointer = new_table;
-        table_desc->length = new_table_length;
-        table_desc->flags = new_flags;
+        /* Release the temporary table descriptor */
 
-        return (new_table);
+        acpi_tb_release_temp_table(&new_table_desc);
+        return_ACPI_STATUS(status);
 }
 
 /*******************************************************************************
  *
- * FUNCTION:    acpi_tb_resize_root_table_list
+ * FUNCTION:    acpi_tb_install_standard_table
  *
- * PARAMETERS:  None
+ * PARAMETERS:  address             - Address of the table (might be a virtual
+ *                                    address depending on the table_flags)
+ *              flags               - Flags for the table
+ *              reload              - Whether reload should be performed
+ *              override            - Whether override should be performed
+ *              table_index         - Where the table index is returned
  *
  * RETURN:      Status
  *
- * DESCRIPTION: Expand the size of global table array
+ * DESCRIPTION: This function is called to install an ACPI table that is
+ *              neither DSDT nor FACS (a "standard" table.)
+ *              When this function is called by "Load" or "LoadTable" opcodes,
+ *              or by acpi_load_table() API, the "Reload" parameter is set.
+ *              After sucessfully returning from this function, table is
+ *              "INSTALLED" but not "VALIDATED".
  *
  ******************************************************************************/
 
-acpi_status acpi_tb_resize_root_table_list(void)
+acpi_status
+acpi_tb_install_standard_table(acpi_physical_address address,
+                               u8 flags,
+                               u8 reload, u8 override, u32 *table_index)
 {
-        struct acpi_table_desc *tables;
-        u32 table_count;
-
-        ACPI_FUNCTION_TRACE(tb_resize_root_table_list);
-
-        /* allow_resize flag is a parameter to acpi_initialize_tables */
+        u32 i;
+        acpi_status status = AE_OK;
+        struct acpi_table_desc new_table_desc;
 
-        if (!(acpi_gbl_root_table_list.flags & ACPI_ROOT_ALLOW_RESIZE)) {
-                ACPI_ERROR((AE_INFO,
-                            "Resize of Root Table Array is not allowed"));
-                return_ACPI_STATUS(AE_SUPPORT);
-        }
+        ACPI_FUNCTION_TRACE(tb_install_standard_table);
 
-        /* Increase the Table Array size */
+        /* Acquire a temporary table descriptor for validation */
 
-        if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) {
-                table_count = acpi_gbl_root_table_list.max_table_count;
-        } else {
-                table_count = acpi_gbl_root_table_list.current_table_count;
+        status = acpi_tb_acquire_temp_table(&new_table_desc, address, flags);
+        if (ACPI_FAILURE(status)) {
+                ACPI_ERROR((AE_INFO, "Could not acquire table length at %p",
+                            ACPI_CAST_PTR(void, address)));
+                return_ACPI_STATUS(status);
         }
 
-        tables = ACPI_ALLOCATE_ZEROED(((acpi_size) table_count +
-                                       ACPI_ROOT_TABLE_SIZE_INCREMENT) *
-                                      sizeof(struct acpi_table_desc));
-        if (!tables) {
-                ACPI_ERROR((AE_INFO,
-                            "Could not allocate new root table array"));
-                return_ACPI_STATUS(AE_NO_MEMORY);
+        /*
+         * Optionally do not load any SSDTs from the RSDT/XSDT. This can
+         * be useful for debugging ACPI problems on some machines.
+         */
+        if (!reload &&
+            acpi_gbl_disable_ssdt_table_install &&
+            ACPI_COMPARE_NAME(&new_table_desc.signature, ACPI_SIG_SSDT)) {
+                ACPI_INFO((AE_INFO, "Ignoring installation of %4.4s at %p",
+                           new_table_desc.signature.ascii, ACPI_CAST_PTR(void,
+                                                                         address)));
+                goto release_and_exit;
         }
 
-        /* Copy and free the previous table array */
-
-        if (acpi_gbl_root_table_list.tables) {
-                ACPI_MEMCPY(tables, acpi_gbl_root_table_list.tables,
-                            (acpi_size) table_count *
-                            sizeof(struct acpi_table_desc));
+        /* Validate and verify a table before installation */
 
-                if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) {
-                        ACPI_FREE(acpi_gbl_root_table_list.tables);
-                }
+        status = acpi_tb_verify_temp_table(&new_table_desc, NULL);
+        if (ACPI_FAILURE(status)) {
+                goto release_and_exit;
         }
 
-        acpi_gbl_root_table_list.tables = tables;
-        acpi_gbl_root_table_list.max_table_count =
-            table_count + ACPI_ROOT_TABLE_SIZE_INCREMENT;
-        acpi_gbl_root_table_list.flags |= ACPI_ROOT_ORIGIN_ALLOCATED;
-
-        return_ACPI_STATUS(AE_OK);
-}
-
-/*******************************************************************************
- *
- * FUNCTION:    acpi_tb_store_table
- *
- * PARAMETERS:  address             - Table address
- *              table               - Table header
- *              length              - Table length
- *              flags               - flags
- *
- * RETURN:      Status and table index.
- *
- * DESCRIPTION: Add an ACPI table to the global table list
- *
- ******************************************************************************/
+        if (reload) {
+                /*
+                 * Validate the incoming table signature.
+                 *
+                 * 1) Originally, we checked the table signature for "SSDT" or "PSDT".
+                 * 2) We added support for OEMx tables, signature "OEM".
+                 * 3) Valid tables were encountered with a null signature, so we just
+                 *    gave up on validating the signature, (05/2008).
+                 * 4) We encountered non-AML tables such as the MADT, which caused
+                 *    interpreter errors and kernel faults. So now, we once again allow
+                 *    only "SSDT", "OEMx", and now, also a null signature. (05/2011).
+                 */
+                if ((new_table_desc.signature.ascii[0] != 0x00) &&
+                    (!ACPI_COMPARE_NAME
+                     (&new_table_desc.signature, ACPI_SIG_SSDT))
+                    && (ACPI_STRNCMP(new_table_desc.signature.ascii, "OEM", 3)))
+                {
+                        ACPI_BIOS_ERROR((AE_INFO,
+                                         "Table has invalid signature [%4.4s] (0x%8.8X), "
+                                         "must be SSDT or OEMx",
+                                         acpi_ut_valid_acpi_name(new_table_desc.
+                                                                 signature.
+                                                                 ascii) ?
+                                         new_table_desc.signature.
+                                         ascii : "????",
+                                         new_table_desc.signature.integer));
+
+                        status = AE_BAD_SIGNATURE;
+                        goto release_and_exit;
+                }
 
-acpi_status
-acpi_tb_store_table(acpi_physical_address address,
-                    struct acpi_table_header *table,
-                    u32 length, u8 flags, u32 *table_index)
-{
-        acpi_status status;
-        struct acpi_table_desc *new_table;
+                /* Check if table is already registered */
 
-        /* Ensure that there is room for the table in the Root Table List */
+                for (i = 0; i < acpi_gbl_root_table_list.current_table_count;
+                     ++i) {
+                        /*
+                         * Check for a table match on the entire table length,
+                         * not just the header.
+                         */
+                        if (!acpi_tb_compare_tables(&new_table_desc, i)) {
+                                continue;
+                        }
 
-        if (acpi_gbl_root_table_list.current_table_count >=
-            acpi_gbl_root_table_list.max_table_count) {
-                status = acpi_tb_resize_root_table_list();
-                if (ACPI_FAILURE(status)) {
-                        return (status);
+                        /*
+                         * Note: the current mechanism does not unregister a table if it is
+                         * dynamically unloaded. The related namespace entries are deleted,
+                         * but the table remains in the root table list.
+                         *
+                         * The assumption here is that the number of different tables that
+                         * will be loaded is actually small, and there is minimal overhead
+                         * in just keeping the table in case it is needed again.
+                         *
+                         * If this assumption changes in the future (perhaps on large
+                         * machines with many table load/unload operations), tables will
+                         * need to be unregistered when they are unloaded, and slots in the
+                         * root table list should be reused when empty.
+                         */
+                        if (acpi_gbl_root_table_list.tables[i].
+                            flags & ACPI_TABLE_IS_LOADED) {
+
+                                /* Table is still loaded, this is an error */
+
+                                status = AE_ALREADY_EXISTS;
+                                goto release_and_exit;
+                        } else {
+                                /*
+                                 * Table was unloaded, allow it to be reloaded.
+                                 * As we are going to return AE_OK to the caller, we should
+                                 * take the responsibility of freeing the input descriptor.
+                                 * Refill the input descriptor to ensure
+                                 * acpi_tb_install_table_with_override() can be called again to
+                                 * indicate the re-installation.
+                                 */
+                                acpi_tb_uninstall_table(&new_table_desc);
+                                *table_index = i;
+                                (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
+                                return_ACPI_STATUS(AE_OK);
+                        }
                 }
         }
 
-        new_table =
-            &acpi_gbl_root_table_list.tables[acpi_gbl_root_table_list.
-                                             current_table_count];
-
-        /* Initialize added table */
-
-        new_table->address = address;
-        new_table->pointer = table;
-        new_table->length = length;
-        new_table->owner_id = 0;
-        new_table->flags = flags;
-
-        ACPI_MOVE_32_TO_32(&new_table->signature, table->signature);
-
-        *table_index = acpi_gbl_root_table_list.current_table_count;
-        acpi_gbl_root_table_list.current_table_count++;
-        return (AE_OK);
-}
-
-/*******************************************************************************
- *
- * FUNCTION:    acpi_tb_delete_table
- *
- * PARAMETERS:  table_index         - Table index
- *
- * RETURN:      None
- *
- * DESCRIPTION: Delete one internal ACPI table
- *
- ******************************************************************************/
+        /* Add the table to the global root table list */
 
-void acpi_tb_delete_table(struct acpi_table_desc *table_desc)
-{
-        /* Table must be mapped or allocated */
-        if (!table_desc->pointer) {
-                return;
+        status = acpi_tb_get_next_root_index(&i);
+        if (ACPI_FAILURE(status)) {
+                goto release_and_exit;
         }
-        switch (table_desc->flags & ACPI_TABLE_ORIGIN_MASK) {
-        case ACPI_TABLE_ORIGIN_MAPPED:
-
-                acpi_os_unmap_memory(table_desc->pointer, table_desc->length);
-                break;
-
-        case ACPI_TABLE_ORIGIN_ALLOCATED:
 
-                ACPI_FREE(table_desc->pointer);
-                break;
+        *table_index = i;
+        acpi_tb_install_table_with_override(i, &new_table_desc, override);
 
-                /* Not mapped or allocated, there is nothing we can do */
+release_and_exit:
 
-        default:
+        /* Release the temporary table descriptor */
 
-                return;
-        }
-
-        table_desc->pointer = NULL;
+        acpi_tb_release_temp_table(&new_table_desc);
+        return_ACPI_STATUS(status);
 }
 
 /*******************************************************************************
  *
- * FUNCTION:    acpi_tb_terminate
+ * FUNCTION:    acpi_tb_override_table
  *
- * PARAMETERS:  None
+ * PARAMETERS:  old_table_desc      - Validated table descriptor to be
+ *                                    overridden
  *
  * RETURN:      None
  *
- * DESCRIPTION: Delete all internal ACPI tables
+ * DESCRIPTION: Attempt table override by calling the OSL override functions.
+ *              Note: If the table is overridden, then the entire new table
+ *              is acquired and returned by this function.
+ *              Before/after invocation, the table descriptor is in a state
+ *              that is "VALIDATED".
  *
  ******************************************************************************/
 
-void acpi_tb_terminate(void)
+void acpi_tb_override_table(struct acpi_table_desc *old_table_desc)
 {
-        u32 i;
-
-        ACPI_FUNCTION_TRACE(tb_terminate);
-
-        (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
-
-        /* Delete the individual tables */
+        acpi_status status;
+        char *override_type;
+        struct acpi_table_desc new_table_desc;
+        struct acpi_table_header *table;
+        acpi_physical_address address;
+        u32 length;
 
-        for (i = 0; i < acpi_gbl_root_table_list.current_table_count; i++) {
-                acpi_tb_delete_table(&acpi_gbl_root_table_list.tables[i]);
-        }
+        /* (1) Attempt logical override (returns a logical address) */
 
-        /*
-         * Delete the root table array if allocated locally. Array cannot be
-         * mapped, so we don't need to check for that flag.
-         */
-        if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) {
-                ACPI_FREE(acpi_gbl_root_table_list.tables);
+        status = acpi_os_table_override(old_table_desc->pointer, &table);
+        if (ACPI_SUCCESS(status) && table) {
+                acpi_tb_acquire_temp_table(&new_table_desc,
+                                           ACPI_PTR_TO_PHYSADDR(table),
+                                           ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL);
+                override_type = "Logical";
+                goto finish_override;
         }
 
-        acpi_gbl_root_table_list.tables = NULL;
-        acpi_gbl_root_table_list.flags = 0;
-        acpi_gbl_root_table_list.current_table_count = 0;
+        /* (2) Attempt physical override (returns a physical address) */
 
-        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "ACPI Tables freed\n"));
-        (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
+        status = acpi_os_physical_table_override(old_table_desc->pointer,
+                                                 &address, &length);
+        if (ACPI_SUCCESS(status) && address && length) {
+                acpi_tb_acquire_temp_table(&new_table_desc, address,
+                                           ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL);
+                override_type = "Physical";
+                goto finish_override;
+        }
 
-        return_VOID;
-}
+        return;                 /* There was no override */
 
-/*******************************************************************************
- *
- * FUNCTION:    acpi_tb_delete_namespace_by_owner
- *
- * PARAMETERS:  table_index         - Table index
- *
- * RETURN:      Status
- *
- * DESCRIPTION: Delete all namespace objects created when this table was loaded.
- *
- ******************************************************************************/
-
-acpi_status acpi_tb_delete_namespace_by_owner(u32 table_index)
-{
-        acpi_owner_id owner_id;
-        acpi_status status;
+finish_override:
 
-        ACPI_FUNCTION_TRACE(tb_delete_namespace_by_owner);
+        /* Validate and verify a table before overriding */
 
-        status = acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
+        status = acpi_tb_verify_temp_table(&new_table_desc, NULL);
         if (ACPI_FAILURE(status)) {
-                return_ACPI_STATUS(status);
+                return;
         }
 
-        if (table_index >= acpi_gbl_root_table_list.current_table_count) {
-
-                /* The table index does not exist */
-
-                (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
-                return_ACPI_STATUS(AE_NOT_EXIST);
-        }
+        ACPI_INFO((AE_INFO, "%4.4s " ACPI_PRINTF_UINT
+                   " %s table override, new table: " ACPI_PRINTF_UINT,
+                   old_table_desc->signature.ascii,
+                   ACPI_FORMAT_TO_UINT(old_table_desc->address),
+                   override_type, ACPI_FORMAT_TO_UINT(new_table_desc.address)));
 
-        /* Get the owner ID for this table, used to delete namespace nodes */
+        /* We can now uninstall the original table */
 
-        owner_id = acpi_gbl_root_table_list.tables[table_index].owner_id;
-        (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
+        acpi_tb_uninstall_table(old_table_desc);
 
         /*
-         * Need to acquire the namespace writer lock to prevent interference
-         * with any concurrent namespace walks. The interpreter must be
-         * released during the deletion since the acquisition of the deletion
-         * lock may block, and also since the execution of a namespace walk
-         * must be allowed to use the interpreter.
+         * Replace the original table descriptor and keep its state as
+         * "VALIDATED".
          */
-        (void)acpi_ut_release_mutex(ACPI_MTX_INTERPRETER);
-        status = acpi_ut_acquire_write_lock(&acpi_gbl_namespace_rw_lock);
+        acpi_tb_init_table_descriptor(old_table_desc, new_table_desc.address,
+                                      new_table_desc.flags,
+                                      new_table_desc.pointer);
+        acpi_tb_validate_temp_table(old_table_desc);
 
-        acpi_ns_delete_namespace_by_owner(owner_id);
-        if (ACPI_FAILURE(status)) {
-                return_ACPI_STATUS(status);
-        }
+        /* Release the temporary table descriptor */
 
-        acpi_ut_release_write_lock(&acpi_gbl_namespace_rw_lock);
-
-        status = acpi_ut_acquire_mutex(ACPI_MTX_INTERPRETER);
-        return_ACPI_STATUS(status);
+        acpi_tb_release_temp_table(&new_table_desc);
 }
 
 /*******************************************************************************
  *
- * FUNCTION:    acpi_tb_allocate_owner_id
+ * FUNCTION:    acpi_tb_store_table
  *
- * PARAMETERS:  table_index         - Table index
+ * PARAMETERS:  address             - Table address
+ *              table               - Table header
+ *              length              - Table length
+ *              flags               - Install flags
+ *              table_index         - Where the table index is returned
  *
- * RETURN:      Status
+ * RETURN:      Status and table index.
  *
- * DESCRIPTION: Allocates owner_id in table_desc
+ * DESCRIPTION: Add an ACPI table to the global table list
  *
  ******************************************************************************/
 
-acpi_status acpi_tb_allocate_owner_id(u32 table_index)
+acpi_status
+acpi_tb_store_table(acpi_physical_address address,
+                    struct acpi_table_header * table,
+                    u32 length, u8 flags, u32 *table_index)
 {
-        acpi_status status = AE_BAD_PARAMETER;
-
-        ACPI_FUNCTION_TRACE(tb_allocate_owner_id);
+        acpi_status status;
+        struct acpi_table_desc *table_desc;
 
-        (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
-        if (table_index < acpi_gbl_root_table_list.current_table_count) {
-                status = acpi_ut_allocate_owner_id
-                    (&(acpi_gbl_root_table_list.tables[table_index].owner_id));
+        status = acpi_tb_get_next_root_index(table_index);
+        if (ACPI_FAILURE(status)) {
+                return (status);
         }
 
-        (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
-        return_ACPI_STATUS(status);
-}
-
-/*******************************************************************************
- *
- * FUNCTION:    acpi_tb_release_owner_id
- *
- * PARAMETERS:  table_index         - Table index
- *
- * RETURN:      Status
- *
- * DESCRIPTION: Releases owner_id in table_desc
- *
- ******************************************************************************/
-
-acpi_status acpi_tb_release_owner_id(u32 table_index)
-{
-        acpi_status status = AE_BAD_PARAMETER;
-
-        ACPI_FUNCTION_TRACE(tb_release_owner_id);
-
-        (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
-        if (table_index < acpi_gbl_root_table_list.current_table_count) {
-                acpi_ut_release_owner_id(&
-                                         (acpi_gbl_root_table_list.
-                                          tables[table_index].owner_id));
-                status = AE_OK;
-        }
+        /* Initialize added table */
 
-        (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
-        return_ACPI_STATUS(status);
+        table_desc = &acpi_gbl_root_table_list.tables[*table_index];
+        acpi_tb_init_table_descriptor(table_desc, address, flags, table);
+        table_desc->pointer = table;
+        return (AE_OK);
 }
 
 /*******************************************************************************
  *
- * FUNCTION:    acpi_tb_get_owner_id
+ * FUNCTION:    acpi_tb_uninstall_table
  *
- * PARAMETERS:  table_index         - Table index
- *              owner_id            - Where the table owner_id is returned
+ * PARAMETERS:  table_desc          - Table descriptor
  *
- * RETURN:      Status
+ * RETURN:      None
  *
- * DESCRIPTION: returns owner_id for the ACPI table
+ * DESCRIPTION: Delete one internal ACPI table
  *
  ******************************************************************************/
 
-acpi_status acpi_tb_get_owner_id(u32 table_index, acpi_owner_id *owner_id)
+void acpi_tb_uninstall_table(struct acpi_table_desc *table_desc)
 {
-        acpi_status status = AE_BAD_PARAMETER;
-
-        ACPI_FUNCTION_TRACE(tb_get_owner_id);
 
-        (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
-        if (table_index < acpi_gbl_root_table_list.current_table_count) {
-                *owner_id =
-                    acpi_gbl_root_table_list.tables[table_index].owner_id;
-                status = AE_OK;
-        }
+        ACPI_FUNCTION_TRACE(tb_uninstall_table);
 
-        (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
-        return_ACPI_STATUS(status);
-}
-
-/*******************************************************************************
- *
- * FUNCTION:    acpi_tb_is_table_loaded
- *
- * PARAMETERS:  table_index         - Table index
- *
- * RETURN:      Table Loaded Flag
- *
- ******************************************************************************/
+        /* Table must be installed */
 
-u8 acpi_tb_is_table_loaded(u32 table_index)
-{
-        u8 is_loaded = FALSE;
-
-        (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
-        if (table_index < acpi_gbl_root_table_list.current_table_count) {
-                is_loaded = (u8)
-                    (acpi_gbl_root_table_list.tables[table_index].flags &
-                     ACPI_TABLE_IS_LOADED);
+        if (!table_desc->address) {
+                return_VOID;
         }
 
-        (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
-        return (is_loaded);
-}
-
-/*******************************************************************************
- *
- * FUNCTION:    acpi_tb_set_table_loaded_flag
- *
- * PARAMETERS:  table_index         - Table index
- *              is_loaded           - TRUE if table is loaded, FALSE otherwise
- *
- * RETURN:      None
- *
- * DESCRIPTION: Sets the table loaded flag to either TRUE or FALSE.
- *
- ******************************************************************************/
-
-void acpi_tb_set_table_loaded_flag(u32 table_index, u8 is_loaded)
-{
+        acpi_tb_invalidate_table(table_desc);
 
-        (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
-        if (table_index < acpi_gbl_root_table_list.current_table_count) {
-                if (is_loaded) {
-                        acpi_gbl_root_table_list.tables[table_index].flags |=
-                            ACPI_TABLE_IS_LOADED;
-                } else {
-                        acpi_gbl_root_table_list.tables[table_index].flags &=
-                            ~ACPI_TABLE_IS_LOADED;
-                }
+        if ((table_desc->flags & ACPI_TABLE_ORIGIN_MASK) ==
+            ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL) {
+                ACPI_FREE(ACPI_CAST_PTR(void, table_desc->address));
         }
 
-        (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
+        table_desc->address = ACPI_PTR_TO_PHYSADDR(NULL);
+        return_VOID;
 }
diff --git a/drivers/acpi/acpica/tbutils.c b/drivers/acpi/acpica/tbutils.c
index 9fb85f38de90..6b1ca9991b90 100644
--- a/drivers/acpi/acpica/tbutils.c
+++ b/drivers/acpi/acpica/tbutils.c
@@ -49,8 +49,6 @@
 ACPI_MODULE_NAME("tbutils")
 
 /* Local prototypes */
-static acpi_status acpi_tb_validate_xsdt(acpi_physical_address address);
-
 static acpi_physical_address
 acpi_tb_get_root_table_entry(u8 *table_entry, u32 table_entry_size);
 
@@ -178,9 +176,13 @@ struct acpi_table_header *acpi_tb_copy_dsdt(u32 table_index)
         }
 
         ACPI_MEMCPY(new_table, table_desc->pointer, table_desc->length);
-        acpi_tb_delete_table(table_desc);
-        table_desc->pointer = new_table;
-        table_desc->flags = ACPI_TABLE_ORIGIN_ALLOCATED;
+        acpi_tb_uninstall_table(table_desc);
+
+        acpi_tb_init_table_descriptor(&acpi_gbl_root_table_list.
+                                      tables[ACPI_TABLE_INDEX_DSDT],
+                                      ACPI_PTR_TO_PHYSADDR(new_table),
+                                      ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL,
+                                      new_table);
 
         ACPI_INFO((AE_INFO,
                    "Forced DSDT copy: length 0x%05X copied locally, original unmapped",
@@ -191,116 +193,6 @@ struct acpi_table_header *acpi_tb_copy_dsdt(u32 table_index)
 
 /*******************************************************************************
  *
- * FUNCTION:    acpi_tb_install_table
- *
- * PARAMETERS:  address                 - Physical address of DSDT or FACS
- *              signature               - Table signature, NULL if no need to
- *                                        match
- *              table_index             - Index into root table array
- *
- * RETURN:      None
- *
- * DESCRIPTION: Install an ACPI table into the global data structure. The
- *              table override mechanism is called to allow the host
- *              OS to replace any table before it is installed in the root
- *              table array.
- *
- ******************************************************************************/
-
-void
-acpi_tb_install_table(acpi_physical_address address,
-                      char *signature, u32 table_index)
-{
-        struct acpi_table_header *table;
-        struct acpi_table_header *final_table;
-        struct acpi_table_desc *table_desc;
-
-        if (!address) {
-                ACPI_ERROR((AE_INFO,
-                            "Null physical address for ACPI table [%s]",
-                            signature));
-                return;
-        }
-
-        /* Map just the table header */
-
-        table = acpi_os_map_memory(address, sizeof(struct acpi_table_header));
-        if (!table) {
-                ACPI_ERROR((AE_INFO,
-                            "Could not map memory for table [%s] at %p",
-                            signature, ACPI_CAST_PTR(void, address)));
-                return;
-        }
-
-        /* If a particular signature is expected (DSDT/FACS), it must match */
-
-        if (signature && !ACPI_COMPARE_NAME(table->signature, signature)) {
-                ACPI_BIOS_ERROR((AE_INFO,
-                                 "Invalid signature 0x%X for ACPI table, expected [%s]",
-                                 *ACPI_CAST_PTR(u32, table->signature),
-                                 signature));
-                goto unmap_and_exit;
-        }
-
-        /*
-         * Initialize the table entry. Set the pointer to NULL, since the
-         * table is not fully mapped at this time.
-         */
-        table_desc = &acpi_gbl_root_table_list.tables[table_index];
-
-        table_desc->address = address;
-        table_desc->pointer = NULL;
-        table_desc->length = table->length;
-        table_desc->flags = ACPI_TABLE_ORIGIN_MAPPED;
-        ACPI_MOVE_32_TO_32(table_desc->signature.ascii, table->signature);
-
-        /*
-         * ACPI Table Override:
-         *
-         * Before we install the table, let the host OS override it with a new
-         * one if desired. Any table within the RSDT/XSDT can be replaced,
-         * including the DSDT which is pointed to by the FADT.
-         *
-         * NOTE: If the table is overridden, then final_table will contain a
-         * mapped pointer to the full new table. If the table is not overridden,
-         * or if there has been a physical override, then the table will be
-         * fully mapped later (in verify table). In any case, we must
-         * unmap the header that was mapped above.
-         */
-        final_table = acpi_tb_table_override(table, table_desc);
-        if (!final_table) {
-                final_table = table;    /* There was no override */
-        }
-
-        acpi_tb_print_table_header(table_desc->address, final_table);
-
-        /* Set the global integer width (based upon revision of the DSDT) */
-
-        if (table_index == ACPI_TABLE_INDEX_DSDT) {
-                acpi_ut_set_integer_width(final_table->revision);
-        }
-
-        /*
-         * If we have a physical override during this early loading of the ACPI
-         * tables, unmap the table for now. It will be mapped again later when
-         * it is actually used. This supports very early loading of ACPI tables,
-         * before virtual memory is fully initialized and running within the
-         * host OS. Note: A logical override has the ACPI_TABLE_ORIGIN_OVERRIDE
-         * flag set and will not be deleted below.
-         */
-        if (final_table != table) {
-                acpi_tb_delete_table(table_desc);
-        }
-
-unmap_and_exit:
-
-        /* Always unmap the table header that we mapped above */
-
-        acpi_os_unmap_memory(table, sizeof(struct acpi_table_header));
-}
-
-/*******************************************************************************
- *
  * FUNCTION:    acpi_tb_get_root_table_entry
  *
  * PARAMETERS:  table_entry         - Pointer to the RSDT/XSDT table entry
@@ -357,87 +249,6 @@ acpi_tb_get_root_table_entry(u8 *table_entry, u32 table_entry_size)
 
 /*******************************************************************************
  *
- * FUNCTION:    acpi_tb_validate_xsdt
- *
- * PARAMETERS:  address             - Physical address of the XSDT (from RSDP)
- *
- * RETURN:      Status. AE_OK if the table appears to be valid.
- *
- * DESCRIPTION: Validate an XSDT to ensure that it is of minimum size and does
- *              not contain any NULL entries. A problem that is seen in the
- *              field is that the XSDT exists, but is actually useless because
- *              of one or more (or all) NULL entries.
- *
- ******************************************************************************/
-
-static acpi_status acpi_tb_validate_xsdt(acpi_physical_address xsdt_address)
-{
-        struct acpi_table_header *table;
-        u8 *next_entry;
-        acpi_physical_address address;
-        u32 length;
-        u32 entry_count;
-        acpi_status status;
-        u32 i;
-
-        /* Get the XSDT length */
-
-        table =
-            acpi_os_map_memory(xsdt_address, sizeof(struct acpi_table_header));
-        if (!table) {
-                return (AE_NO_MEMORY);
-        }
-
-        length = table->length;
-        acpi_os_unmap_memory(table, sizeof(struct acpi_table_header));
-
-        /*
-         * Minimum XSDT length is the size of the standard ACPI header
-         * plus one physical address entry
-         */
-        if (length < (sizeof(struct acpi_table_header) + ACPI_XSDT_ENTRY_SIZE)) {
-                return (AE_INVALID_TABLE_LENGTH);
-        }
-
-        /* Map the entire XSDT */
-
-        table = acpi_os_map_memory(xsdt_address, length);
-        if (!table) {
-                return (AE_NO_MEMORY);
-        }
-
-        /* Get the number of entries and pointer to first entry */
-
-        status = AE_OK;
-        next_entry = ACPI_ADD_PTR(u8, table, sizeof(struct acpi_table_header));
-        entry_count = (u32)((table->length - sizeof(struct acpi_table_header)) /
-                            ACPI_XSDT_ENTRY_SIZE);
-
-        /* Validate each entry (physical address) within the XSDT */
-
-        for (i = 0; i < entry_count; i++) {
-                address =
-                    acpi_tb_get_root_table_entry(next_entry,
-                                                 ACPI_XSDT_ENTRY_SIZE);
-                if (!address) {
-
-                        /* Detected a NULL entry, XSDT is invalid */
-
-                        status = AE_NULL_ENTRY;
-                        break;
-                }
-
-                next_entry += ACPI_XSDT_ENTRY_SIZE;
-        }
-
-        /* Unmap table */
-
-        acpi_os_unmap_memory(table, length);
-        return (status);
-}
-
-/*******************************************************************************
- *
  * FUNCTION:    acpi_tb_parse_root_table
  *
  * PARAMETERS:  rsdp                    - Pointer to the RSDP
@@ -461,10 +272,10 @@ acpi_status __init acpi_tb_parse_root_table(acpi_physical_address rsdp_address)
         u32 table_count;
         struct acpi_table_header *table;
         acpi_physical_address address;
-        acpi_physical_address rsdt_address;
         u32 length;
         u8 *table_entry;
         acpi_status status;
+        u32 table_index;
 
         ACPI_FUNCTION_TRACE(tb_parse_root_table);
 
@@ -489,14 +300,11 @@ acpi_status __init acpi_tb_parse_root_table(acpi_physical_address rsdp_address)
                  * as per the ACPI specification.
                  */
                 address = (acpi_physical_address) rsdp->xsdt_physical_address;
-                rsdt_address =
-                    (acpi_physical_address) rsdp->rsdt_physical_address;
                 table_entry_size = ACPI_XSDT_ENTRY_SIZE;
         } else {
                 /* Root table is an RSDT (32-bit physical addresses) */
 
                 address = (acpi_physical_address) rsdp->rsdt_physical_address;
-                rsdt_address = address;
                 table_entry_size = ACPI_RSDT_ENTRY_SIZE;
         }
 
@@ -506,24 +314,6 @@ acpi_status __init acpi_tb_parse_root_table(acpi_physical_address rsdp_address)
          */
         acpi_os_unmap_memory(rsdp, sizeof(struct acpi_table_rsdp));
 
-        /*
-         * If it is present and used, validate the XSDT for access/size
-         * and ensure that all table entries are at least non-NULL
-         */
-        if (table_entry_size == ACPI_XSDT_ENTRY_SIZE) {
-                status = acpi_tb_validate_xsdt(address);
-                if (ACPI_FAILURE(status)) {
-                        ACPI_BIOS_WARNING((AE_INFO,
-                                           "XSDT is invalid (%s), using RSDT",
-                                           acpi_format_exception(status)));
-
-                        /* Fall back to the RSDT */
-
-                        address = rsdt_address;
-                        table_entry_size = ACPI_RSDT_ENTRY_SIZE;
-                }
-        }
-
         /* Map the RSDT/XSDT table header to get the full table length */
 
         table = acpi_os_map_memory(address, sizeof(struct acpi_table_header));
@@ -576,55 +366,36 @@ acpi_status __init acpi_tb_parse_root_table(acpi_physical_address rsdp_address)
         /* Initialize the root table array from the RSDT/XSDT */
 
         for (i = 0; i < table_count; i++) {
-                if (acpi_gbl_root_table_list.current_table_count >=
-                    acpi_gbl_root_table_list.max_table_count) {
-
-                        /* There is no more room in the root table array, attempt resize */
-
-                        status = acpi_tb_resize_root_table_list();
-                        if (ACPI_FAILURE(status)) {
-                                ACPI_WARNING((AE_INFO,
-                                              "Truncating %u table entries!",
-                                              (unsigned) (table_count -
-                                               (acpi_gbl_root_table_list.
-                                                          current_table_count -
-                                                          2))));
-                                break;
-                        }
-                }
 
                 /* Get the table physical address (32-bit for RSDT, 64-bit for XSDT) */
 
-                acpi_gbl_root_table_list.tables[acpi_gbl_root_table_list.
-                                                current_table_count].address =
+                address =
                     acpi_tb_get_root_table_entry(table_entry, table_entry_size);
 
-                table_entry += table_entry_size;
-                acpi_gbl_root_table_list.current_table_count++;
-        }
-
-        /*
-         * It is not possible to map more than one entry in some environments,
-         * so unmap the root table here before mapping other tables
-         */
-        acpi_os_unmap_memory(table, length);
+                /* Skip NULL entries in RSDT/XSDT */
 
-        /*
-         * Complete the initialization of the root table array by examining
-         * the header of each table
-         */
-        for (i = 2; i < acpi_gbl_root_table_list.current_table_count; i++) {
-                acpi_tb_install_table(acpi_gbl_root_table_list.tables[i].
-                                      address, NULL, i);
+                if (!address) {
+                        goto next_table;
+                }
 
-                /* Special case for FADT - validate it then get the DSDT and FACS */
+                status = acpi_tb_install_standard_table(address,
+                                                        ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL,
+                                                        FALSE, TRUE,
+                                                        &table_index);
 
-                if (ACPI_COMPARE_NAME
-                    (&acpi_gbl_root_table_list.tables[i].signature,
-                     ACPI_SIG_FADT)) {
-                        acpi_tb_parse_fadt(i);
+                if (ACPI_SUCCESS(status) &&
+                    ACPI_COMPARE_NAME(&acpi_gbl_root_table_list.
+                                      tables[table_index].signature,
+                                      ACPI_SIG_FADT)) {
+                        acpi_tb_parse_fadt(table_index);
                 }
+
+next_table:
+
+                table_entry += table_entry_size;
         }
 
+        acpi_os_unmap_memory(table, length);
+
         return_ACPI_STATUS(AE_OK);
 }
diff --git a/drivers/acpi/acpica/tbxface.c b/drivers/acpi/acpica/tbxface.c
index a1593159d9ea..6482b0ded652 100644
--- a/drivers/acpi/acpica/tbxface.c
+++ b/drivers/acpi/acpica/tbxface.c
@@ -206,8 +206,8 @@ acpi_status
 acpi_get_table_header(char *signature,
                       u32 instance, struct acpi_table_header *out_table_header)
 {
-       u32 i;
-       u32 j;
+        u32 i;
+        u32 j;
         struct acpi_table_header *header;
 
         /* Parameter validation */
@@ -233,7 +233,7 @@ acpi_get_table_header(char *signature,
                 if (!acpi_gbl_root_table_list.tables[i].pointer) {
                         if ((acpi_gbl_root_table_list.tables[i].flags &
                              ACPI_TABLE_ORIGIN_MASK) ==
-                            ACPI_TABLE_ORIGIN_MAPPED) {
+                            ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL) {
                                 header =
                                     acpi_os_map_memory(acpi_gbl_root_table_list.
                                                        tables[i].address,
@@ -321,8 +321,8 @@ acpi_get_table_with_size(char *signature,
                u32 instance, struct acpi_table_header **out_table,
                acpi_size *tbl_size)
 {
-       u32 i;
-       u32 j;
+        u32 i;
+        u32 j;
         acpi_status status;
 
         /* Parameter validation */
@@ -346,7 +346,7 @@ acpi_get_table_with_size(char *signature,
                 }
 
                 status =
-                    acpi_tb_verify_table(&acpi_gbl_root_table_list.tables[i]);
+                    acpi_tb_validate_table(&acpi_gbl_root_table_list.tables[i]);
                 if (ACPI_SUCCESS(status)) {
                         *out_table = acpi_gbl_root_table_list.tables[i].pointer;
                         *tbl_size = acpi_gbl_root_table_list.tables[i].length;
@@ -390,7 +390,7 @@ ACPI_EXPORT_SYMBOL(acpi_get_table)
  *
  ******************************************************************************/
 acpi_status
-acpi_get_table_by_index(u32 table_index, struct acpi_table_header **table)
+acpi_get_table_by_index(u32 table_index, struct acpi_table_header ** table)
 {
         acpi_status status;
 
@@ -416,8 +416,8 @@ acpi_get_table_by_index(u32 table_index, struct acpi_table_header **table)
                 /* Table is not mapped, map it */
 
                 status =
-                    acpi_tb_verify_table(&acpi_gbl_root_table_list.
-                                         tables[table_index]);
+                    acpi_tb_validate_table(&acpi_gbl_root_table_list.
+                                           tables[table_index]);
                 if (ACPI_FAILURE(status)) {
                         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
                         return_ACPI_STATUS(status);
diff --git a/drivers/acpi/acpica/tbxfload.c b/drivers/acpi/acpica/tbxfload.c
index 0909420fc776..ab5308b81aa8 100644
--- a/drivers/acpi/acpica/tbxfload.c
+++ b/drivers/acpi/acpica/tbxfload.c
@@ -117,7 +117,7 @@ static acpi_status acpi_tb_load_namespace(void)
                                 tables[ACPI_TABLE_INDEX_DSDT].signature),
                                ACPI_SIG_DSDT)
             ||
-            ACPI_FAILURE(acpi_tb_verify_table
+            ACPI_FAILURE(acpi_tb_validate_table
                          (&acpi_gbl_root_table_list.
                           tables[ACPI_TABLE_INDEX_DSDT]))) {
                 status = AE_NO_ACPI_TABLES;
@@ -128,7 +128,7 @@ static acpi_status acpi_tb_load_namespace(void)
          * Save the DSDT pointer for simple access. This is the mapped memory
          * address. We must take care here because the address of the .Tables
          * array can change dynamically as tables are loaded at run-time. Note:
-         * .Pointer field is not validated until after call to acpi_tb_verify_table.
+         * .Pointer field is not validated until after call to acpi_tb_validate_table.
          */
         acpi_gbl_DSDT =
             acpi_gbl_root_table_list.tables[ACPI_TABLE_INDEX_DSDT].pointer;
@@ -174,24 +174,11 @@ static acpi_status acpi_tb_load_namespace(void)
                                         (acpi_gbl_root_table_list.tables[i].
                                          signature), ACPI_SIG_PSDT))
                     ||
-                    ACPI_FAILURE(acpi_tb_verify_table
+                    ACPI_FAILURE(acpi_tb_validate_table
                                  (&acpi_gbl_root_table_list.tables[i]))) {
                         continue;
                 }
 
-                /*
-                 * Optionally do not load any SSDTs from the RSDT/XSDT. This can
-                 * be useful for debugging ACPI problems on some machines.
-                 */
-                if (acpi_gbl_disable_ssdt_table_load) {
-                        ACPI_INFO((AE_INFO, "Ignoring %4.4s at %p",
-                                   acpi_gbl_root_table_list.tables[i].signature.
-                                   ascii, ACPI_CAST_PTR(void,
-                                                        acpi_gbl_root_table_list.
-                                                        tables[i].address)));
-                        continue;
-                }
-
                 /* Ignore errors while loading tables, get as many as possible */
 
                 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
@@ -208,6 +195,45 @@ unlock_and_exit:
 
 /*******************************************************************************
  *
+ * FUNCTION:    acpi_install_table
+ *
+ * PARAMETERS:  address             - Address of the ACPI table to be installed.
+ *              physical            - Whether the address is a physical table
+ *                                    address or not
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Dynamically install an ACPI table.
+ *              Note: This function should only be invoked after
+ *                    acpi_initialize_tables() and before acpi_load_tables().
+ *
+ ******************************************************************************/
+
+acpi_status __init
+acpi_install_table(acpi_physical_address address, u8 physical)
+{
+        acpi_status status;
+        u8 flags;
+        u32 table_index;
+
+        ACPI_FUNCTION_TRACE(acpi_install_table);
+
+        if (physical) {
+                flags = ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL;
+        } else {
+                flags = ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL;
+        }
+
+        status = acpi_tb_install_standard_table(address, flags,
+                                                FALSE, FALSE, &table_index);
+
+        return_ACPI_STATUS(status);
+}
+
+ACPI_EXPORT_SYMBOL_INIT(acpi_install_table)
+
+/*******************************************************************************
+ *
  * FUNCTION:    acpi_load_table
  *
  * PARAMETERS:  table               - Pointer to a buffer containing the ACPI
@@ -222,11 +248,9 @@ unlock_and_exit:
  *              to ensure that the table is not deleted or unmapped.
  *
  ******************************************************************************/
-
 acpi_status acpi_load_table(struct acpi_table_header *table)
 {
         acpi_status status;
-        struct acpi_table_desc table_desc;
         u32 table_index;
 
         ACPI_FUNCTION_TRACE(acpi_load_table);
@@ -237,14 +261,6 @@ acpi_status acpi_load_table(struct acpi_table_header *table)
                 return_ACPI_STATUS(AE_BAD_PARAMETER);
         }
 
-        /* Init local table descriptor */
-
-        ACPI_MEMSET(&table_desc, 0, sizeof(struct acpi_table_desc));
-        table_desc.address = ACPI_PTR_TO_PHYSADDR(table);
-        table_desc.pointer = table;
-        table_desc.length = table->length;
-        table_desc.flags = ACPI_TABLE_ORIGIN_UNKNOWN;
-
         /* Must acquire the interpreter lock during this operation */
 
         status = acpi_ut_acquire_mutex(ACPI_MTX_INTERPRETER);
@@ -255,7 +271,24 @@ acpi_status acpi_load_table(struct acpi_table_header *table)
         /* Install the table and load it into the namespace */
 
         ACPI_INFO((AE_INFO, "Host-directed Dynamic ACPI Table Load:"));
-        status = acpi_tb_add_table(&table_desc, &table_index);
+        (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
+
+        status = acpi_tb_install_standard_table(ACPI_PTR_TO_PHYSADDR(table),
+                                                ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL,
+                                                TRUE, FALSE, &table_index);
+
+        (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
+        if (ACPI_FAILURE(status)) {
+                goto unlock_and_exit;
+        }
+
+        /*
+         * Note: Now table is "INSTALLED", it must be validated before
+         * using.
+         */
+        status =
+            acpi_tb_validate_table(&acpi_gbl_root_table_list.
+                                   tables[table_index]);
         if (ACPI_FAILURE(status)) {
                 goto unlock_and_exit;
         }
diff --git a/drivers/acpi/acpica/utdecode.c b/drivers/acpi/acpica/utdecode.c
index fbfa9eca011f..90ec37c473c6 100644
--- a/drivers/acpi/acpica/utdecode.c
+++ b/drivers/acpi/acpica/utdecode.c
@@ -462,7 +462,7 @@ char *acpi_ut_get_mutex_name(u32 mutex_id)
 
 /* Names for Notify() values, used for debug output */
 
-static const char *acpi_gbl_notify_value_names[ACPI_NOTIFY_MAX + 1] = {
+static const char *acpi_gbl_generic_notify[ACPI_NOTIFY_MAX + 1] = {
         /* 00 */ "Bus Check",
         /* 01 */ "Device Check",
         /* 02 */ "Device Wake",
@@ -473,23 +473,75 @@ static const char *acpi_gbl_notify_value_names[ACPI_NOTIFY_MAX + 1] = {
         /* 07 */ "Power Fault",
         /* 08 */ "Capabilities Check",
         /* 09 */ "Device PLD Check",
-        /* 10 */ "Reserved",
-        /* 11 */ "System Locality Update",
-        /* 12 */ "Shutdown Request"
+        /* 0A */ "Reserved",
+        /* 0B */ "System Locality Update",
+        /* 0C */ "Shutdown Request"
 };
 
-const char *acpi_ut_get_notify_name(u32 notify_value)
+static const char *acpi_gbl_device_notify[4] = {
+        /* 80 */ "Status Change",
+        /* 81 */ "Information Change",
+        /* 82 */ "Device-Specific Change",
+        /* 83 */ "Device-Specific Change"
+};
+
+static const char *acpi_gbl_processor_notify[4] = {
+        /* 80 */ "Performance Capability Change",
+        /* 81 */ "C-State Change",
+        /* 82 */ "Throttling Capability Change",
+        /* 83 */ "Device-Specific Change"
+};
+
+static const char *acpi_gbl_thermal_notify[4] = {
+        /* 80 */ "Thermal Status Change",
+        /* 81 */ "Thermal Trip Point Change",
+        /* 82 */ "Thermal Device List Change",
+        /* 83 */ "Thermal Relationship Change"
+};
+
+const char *acpi_ut_get_notify_name(u32 notify_value, acpi_object_type type)
 {
 
+        /* 00 - 0C are common to all object types */
+
         if (notify_value <= ACPI_NOTIFY_MAX) {
-                return (acpi_gbl_notify_value_names[notify_value]);
-        } else if (notify_value <= ACPI_MAX_SYS_NOTIFY) {
+                return (acpi_gbl_generic_notify[notify_value]);
+        }
+
+        /* 0D - 7F are reserved */
+
+        if (notify_value <= ACPI_MAX_SYS_NOTIFY) {
                 return ("Reserved");
-        } else if (notify_value <= ACPI_MAX_DEVICE_SPECIFIC_NOTIFY) {
-                return ("Device Specific");
-        } else {
-                return ("Hardware Specific");
         }
+
+        /* 80 - 83 are per-object-type */
+
+        if (notify_value <= 0x83) {
+                switch (type) {
+                case ACPI_TYPE_ANY:
+                case ACPI_TYPE_DEVICE:
+                        return (acpi_gbl_device_notify[notify_value - 0x80]);
+
+                case ACPI_TYPE_PROCESSOR:
+                        return (acpi_gbl_processor_notify[notify_value - 0x80]);
+
+                case ACPI_TYPE_THERMAL:
+                        return (acpi_gbl_thermal_notify[notify_value - 0x80]);
+
+                default:
+                        return ("Target object type does not support notifies");
+                }
+        }
+
+        /* 84 - BF are device-specific */
+
+        if (notify_value <= ACPI_MAX_DEVICE_SPECIFIC_NOTIFY) {
+                return ("Device-Specific");
+        }
+
+        /* C0 and above are hardware-specific */
+
+        return ("Hardware-Specific");
 }
 #endif
 
diff --git a/drivers/acpi/acpica/utglobal.c b/drivers/acpi/acpica/utglobal.c
index f3abeae9d2f8..d69be3cb3fae 100644
--- a/drivers/acpi/acpica/utglobal.c
+++ b/drivers/acpi/acpica/utglobal.c
@@ -55,28 +55,7 @@ ACPI_MODULE_NAME("utglobal")
  * Static global variable initialization.
  *
  ******************************************************************************/
-/* Debug output control masks */
-u32 acpi_dbg_level = ACPI_DEBUG_DEFAULT;
-
-u32 acpi_dbg_layer = 0;
-
-/* acpi_gbl_FADT is a local copy of the FADT, converted to a common format. */
-
-struct acpi_table_fadt acpi_gbl_FADT;
-u32 acpi_gbl_trace_flags;
-acpi_name acpi_gbl_trace_method_name;
-u8 acpi_gbl_system_awake_and_running;
-u32 acpi_current_gpe_count;
-
-/*
- * ACPI 5.0 introduces the concept of a "reduced hardware platform", meaning
- * that the ACPI hardware is no longer required. A flag in the FADT indicates
- * a reduced HW machine, and that flag is duplicated here for convenience.
- */
-u8 acpi_gbl_reduced_hardware;
-
 /* Various state name strings */
-
 const char *acpi_gbl_sleep_state_names[ACPI_S_STATE_COUNT] = {
         "\\_S0_",
         "\\_S1_",
@@ -337,7 +316,6 @@ acpi_status acpi_ut_init_globals(void)
         acpi_gbl_acpi_hardware_present = TRUE;
         acpi_gbl_last_owner_id_index = 0;
         acpi_gbl_next_owner_id_offset = 0;
-        acpi_gbl_trace_method_name = 0;
         acpi_gbl_trace_dbg_level = 0;
         acpi_gbl_trace_dbg_layer = 0;
         acpi_gbl_debugger_configuration = DEBUGGER_THREADING;
@@ -377,9 +355,7 @@ acpi_status acpi_ut_init_globals(void)
         acpi_gbl_disable_mem_tracking = FALSE;
 #endif
 
-#ifdef ACPI_DEBUGGER
-        acpi_gbl_db_terminate_threads = FALSE;
-#endif
+        ACPI_DEBUGGER_EXEC(acpi_gbl_db_terminate_threads = FALSE);
 
         return_ACPI_STATUS(AE_OK);
 }
diff --git a/drivers/acpi/acpica/utstring.c b/drivers/acpi/acpica/utstring.c
index 77219336c7e0..6dc54b3c28b0 100644
--- a/drivers/acpi/acpica/utstring.c
+++ b/drivers/acpi/acpica/utstring.c
@@ -353,7 +353,7 @@ void acpi_ut_print_string(char *string, u16 max_length)
         }
 
         acpi_os_printf("\"");
-        for (i = 0; string[i] && (i < max_length); i++) {
+        for (i = 0; (i < max_length) && string[i]; i++) {
 
                 /* Escape sequences */
 
diff --git a/drivers/acpi/acpica/utxferror.c b/drivers/acpi/acpica/utxferror.c
index edd861102f1b..88ef77f3cf88 100644
--- a/drivers/acpi/acpica/utxferror.c
+++ b/drivers/acpi/acpica/utxferror.c
@@ -53,6 +53,7 @@ ACPI_MODULE_NAME("utxferror")
  * This module is used for the in-kernel ACPICA as well as the ACPICA
  * tools/applications.
  */
+#ifndef ACPI_NO_ERROR_MESSAGES  /* Entire module */
 /*******************************************************************************
  *
  * FUNCTION:    acpi_error
@@ -249,3 +250,4 @@ acpi_bios_warning(const char *module_name,
 }
 
 ACPI_EXPORT_SYMBOL(acpi_bios_warning)
+#endif                          /* ACPI_NO_ERROR_MESSAGES */
diff --git a/drivers/acpi/apei/einj.c b/drivers/acpi/apei/einj.c
index 1be6f5564485..a095d4f858da 100644
--- a/drivers/acpi/apei/einj.c
+++ b/drivers/acpi/apei/einj.c
@@ -202,7 +202,7 @@ static void check_vendor_extension(u64 paddr,
 
         if (!offset)
                 return;
-        v = acpi_os_map_memory(paddr + offset, sizeof(*v));
+        v = acpi_os_map_iomem(paddr + offset, sizeof(*v));
         if (!v)
                 return;
         sbdf = v->pcie_sbdf;
@@ -210,7 +210,7 @@ static void check_vendor_extension(u64 paddr,
                 sbdf >> 24, (sbdf >> 16) & 0xff,
                 (sbdf >> 11) & 0x1f, (sbdf >> 8) & 0x7,
                  v->vendor_id, v->device_id, v->rev_id);
-        acpi_os_unmap_memory(v, sizeof(*v));
+        acpi_os_unmap_iomem(v, sizeof(*v));
 }
 
 static void *einj_get_parameter_address(void)
@@ -236,7 +236,7 @@ static void *einj_get_parameter_address(void)
         if (pa_v5) {
                 struct set_error_type_with_address *v5param;
 
-                v5param = acpi_os_map_memory(pa_v5, sizeof(*v5param));
+                v5param = acpi_os_map_iomem(pa_v5, sizeof(*v5param));
                 if (v5param) {
                         acpi5 = 1;
                         check_vendor_extension(pa_v5, v5param);
@@ -246,11 +246,11 @@ static void *einj_get_parameter_address(void)
         if (param_extension && pa_v4) {
                 struct einj_parameter *v4param;
 
-                v4param = acpi_os_map_memory(pa_v4, sizeof(*v4param));
+                v4param = acpi_os_map_iomem(pa_v4, sizeof(*v4param));
                 if (!v4param)
                         return NULL;
                 if (v4param->reserved1 || v4param->reserved2) {
-                        acpi_os_unmap_memory(v4param, sizeof(*v4param));
+                        acpi_os_unmap_iomem(v4param, sizeof(*v4param));
                         return NULL;
                 }
                 return v4param;
@@ -794,7 +794,7 @@ err_unmap:
                         sizeof(struct set_error_type_with_address) :
                         sizeof(struct einj_parameter);
 
-                acpi_os_unmap_memory(einj_param, size);
+                acpi_os_unmap_iomem(einj_param, size);
         }
         apei_exec_post_unmap_gars(&ctx);
 err_release:
@@ -816,7 +816,7 @@ static void __exit einj_exit(void)
                         sizeof(struct set_error_type_with_address) :
                         sizeof(struct einj_parameter);
 
-                acpi_os_unmap_memory(einj_param, size);
+                acpi_os_unmap_iomem(einj_param, size);
         }
         einj_exec_ctx_init(&ctx);
         apei_exec_post_unmap_gars(&ctx);
diff --git a/drivers/acpi/battery.c b/drivers/acpi/battery.c
index 6e7b2a12860d..e48fc98e71c4 100644
--- a/drivers/acpi/battery.c
+++ b/drivers/acpi/battery.c
@@ -56,6 +56,10 @@
 /* Battery power unit: 0 means mW, 1 means mA */
 #define ACPI_BATTERY_POWER_UNIT_MA      1
 
+#define ACPI_BATTERY_STATE_DISCHARGING  0x1
+#define ACPI_BATTERY_STATE_CHARGING     0x2
+#define ACPI_BATTERY_STATE_CRITICAL     0x4
+
 #define _COMPONENT              ACPI_BATTERY_COMPONENT
 
 ACPI_MODULE_NAME("battery");
@@ -169,7 +173,7 @@ static int acpi_battery_get_state(struct acpi_battery *battery);
 
 static int acpi_battery_is_charged(struct acpi_battery *battery)
 {
-        /* either charging or discharging */
+        /* charging, discharging or critical low */
         if (battery->state != 0)
                 return 0;
 
@@ -204,9 +208,9 @@ static int acpi_battery_get_property(struct power_supply *psy,
                 return -ENODEV;
         switch (psp) {
         case POWER_SUPPLY_PROP_STATUS:
-                if (battery->state & 0x01)
+                if (battery->state & ACPI_BATTERY_STATE_DISCHARGING)
                         val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
-                else if (battery->state & 0x02)
+                else if (battery->state & ACPI_BATTERY_STATE_CHARGING)
                         val->intval = POWER_SUPPLY_STATUS_CHARGING;
                 else if (acpi_battery_is_charged(battery))
                         val->intval = POWER_SUPPLY_STATUS_FULL;
@@ -269,6 +273,17 @@ static int acpi_battery_get_property(struct power_supply *psy,
                 else
                         val->intval = 0;
                 break;
+        case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
+                if (battery->state & ACPI_BATTERY_STATE_CRITICAL)
+                        val->intval = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
+                else if (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) &&
+                        (battery->capacity_now <= battery->alarm))
+                        val->intval = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
+                else if (acpi_battery_is_charged(battery))
+                        val->intval = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
+                else
+                        val->intval = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
+                break;
         case POWER_SUPPLY_PROP_MODEL_NAME:
                 val->strval = battery->model_number;
                 break;
@@ -296,6 +311,7 @@ static enum power_supply_property charge_battery_props[] = {
         POWER_SUPPLY_PROP_CHARGE_FULL,
         POWER_SUPPLY_PROP_CHARGE_NOW,
         POWER_SUPPLY_PROP_CAPACITY,
+        POWER_SUPPLY_PROP_CAPACITY_LEVEL,
         POWER_SUPPLY_PROP_MODEL_NAME,
         POWER_SUPPLY_PROP_MANUFACTURER,
         POWER_SUPPLY_PROP_SERIAL_NUMBER,
@@ -313,6 +329,7 @@ static enum power_supply_property energy_battery_props[] = {
         POWER_SUPPLY_PROP_ENERGY_FULL,
         POWER_SUPPLY_PROP_ENERGY_NOW,
         POWER_SUPPLY_PROP_CAPACITY,
+        POWER_SUPPLY_PROP_CAPACITY_LEVEL,
         POWER_SUPPLY_PROP_MODEL_NAME,
         POWER_SUPPLY_PROP_MANUFACTURER,
         POWER_SUPPLY_PROP_SERIAL_NUMBER,
@@ -605,7 +622,8 @@ static int sysfs_add_battery(struct acpi_battery *battery)
         battery->bat.type = POWER_SUPPLY_TYPE_BATTERY;
         battery->bat.get_property = acpi_battery_get_property;
 
-        result = power_supply_register(&battery->device->dev, &battery->bat);
+        result = power_supply_register_no_ws(&battery->device->dev, &battery->bat);
+
         if (result)
                 return result;
         return device_create_file(battery->bat.dev, &alarm_attr);
@@ -696,7 +714,7 @@ static void acpi_battery_quirks(struct acpi_battery *battery)
         }
 }
 
-static int acpi_battery_update(struct acpi_battery *battery)
+static int acpi_battery_update(struct acpi_battery *battery, bool resume)
 {
         int result, old_present = acpi_battery_present(battery);
         result = acpi_battery_get_status(battery);
@@ -707,6 +725,10 @@ static int acpi_battery_update(struct acpi_battery *battery)
                 battery->update_time = 0;
                 return 0;
         }
+
+        if (resume)
+                return 0;
+
         if (!battery->update_time ||
             old_present != acpi_battery_present(battery)) {
                 result = acpi_battery_get_info(battery);
@@ -720,7 +742,19 @@ static int acpi_battery_update(struct acpi_battery *battery)
                         return result;
         }
         result = acpi_battery_get_state(battery);
+        if (result)
+                return result;
         acpi_battery_quirks(battery);
+
+        /*
+         * Wakeup the system if battery is critical low
+         * or lower than the alarm level
+         */
+        if ((battery->state & ACPI_BATTERY_STATE_CRITICAL) ||
+            (test_bit(ACPI_BATTERY_ALARM_PRESENT, &battery->flags) &&
+            (battery->capacity_now <= battery->alarm)))
+                pm_wakeup_event(&battery->device->dev, 0);
+
         return result;
 }
 
@@ -915,7 +949,7 @@ static print_func acpi_print_funcs[ACPI_BATTERY_NUMFILES] = {
 static int acpi_battery_read(int fid, struct seq_file *seq)
 {
         struct acpi_battery *battery = seq->private;
-        int result = acpi_battery_update(battery);
+        int result = acpi_battery_update(battery, false);
         return acpi_print_funcs[fid](seq, result);
 }
 
@@ -1030,7 +1064,7 @@ static void acpi_battery_notify(struct acpi_device *device, u32 event)
         old = battery->bat.dev;
         if (event == ACPI_BATTERY_NOTIFY_INFO)
                 acpi_battery_refresh(battery);
-        acpi_battery_update(battery);
+        acpi_battery_update(battery, false);
         acpi_bus_generate_netlink_event(device->pnp.device_class,
                                         dev_name(&device->dev), event,
                                         acpi_battery_present(battery));
@@ -1045,13 +1079,27 @@ static int battery_notify(struct notifier_block *nb,
 {
         struct acpi_battery *battery = container_of(nb, struct acpi_battery,
                                                     pm_nb);
+        int result;
+
         switch (mode) {
         case PM_POST_HIBERNATION:
         case PM_POST_SUSPEND:
-                if (battery->bat.dev) {
-                        sysfs_remove_battery(battery);
-                        sysfs_add_battery(battery);
-                }
+                if (!acpi_battery_present(battery))
+                        return 0;
+
+                if (!battery->bat.dev) {
+                        result = acpi_battery_get_info(battery);
+                        if (result)
+                                return result;
+
+                        result = sysfs_add_battery(battery);
+                        if (result)
+                                return result;
+                } else
+                        acpi_battery_refresh(battery);
+
+                acpi_battery_init_alarm(battery);
+                acpi_battery_get_state(battery);
                 break;
         }
 
@@ -1087,7 +1135,7 @@ static int acpi_battery_add(struct acpi_device *device)
         mutex_init(&battery->sysfs_lock);
         if (acpi_has_method(battery->device->handle, "_BIX"))
                 set_bit(ACPI_BATTERY_XINFO_PRESENT, &battery->flags);
-        result = acpi_battery_update(battery);
+        result = acpi_battery_update(battery, false);
         if (result)
                 goto fail;
 #ifdef CONFIG_ACPI_PROCFS_POWER
@@ -1107,6 +1155,8 @@ static int acpi_battery_add(struct acpi_device *device)
         battery->pm_nb.notifier_call = battery_notify;
         register_pm_notifier(&battery->pm_nb);
 
+        device_init_wakeup(&device->dev, 1);
+
         return result;
 
 fail:
@@ -1123,6 +1173,7 @@ static int acpi_battery_remove(struct acpi_device *device)
 
         if (!device || !acpi_driver_data(device))
                 return -EINVAL;
+        device_init_wakeup(&device->dev, 0);
         battery = acpi_driver_data(device);
         unregister_pm_notifier(&battery->pm_nb);
 #ifdef CONFIG_ACPI_PROCFS_POWER
@@ -1149,7 +1200,7 @@ static int acpi_battery_resume(struct device *dev)
                 return -EINVAL;
 
         battery->update_time = 0;
-        acpi_battery_update(battery);
+        acpi_battery_update(battery, true);
         return 0;
 }
 #else
diff --git a/drivers/acpi/bus.c b/drivers/acpi/bus.c
index cf925c4f36b7..c5bc8cfe09fa 100644
--- a/drivers/acpi/bus.c
+++ b/drivers/acpi/bus.c
@@ -52,6 +52,12 @@ struct proc_dir_entry *acpi_root_dir;
 EXPORT_SYMBOL(acpi_root_dir);
 
 #ifdef CONFIG_X86
+#ifdef CONFIG_ACPI_CUSTOM_DSDT
+static inline int set_copy_dsdt(const struct dmi_system_id *id)
+{
+        return 0;
+}
+#else
 static int set_copy_dsdt(const struct dmi_system_id *id)
 {
         printk(KERN_NOTICE "%s detected - "
@@ -59,6 +65,7 @@ static int set_copy_dsdt(const struct dmi_system_id *id)
         acpi_gbl_copy_dsdt_locally = 1;
         return 0;
 }
+#endif
 
 static struct dmi_system_id dsdt_dmi_table[] __initdata = {
         /*
@@ -132,6 +139,21 @@ void acpi_bus_private_data_handler(acpi_handle handle,
 }
 EXPORT_SYMBOL(acpi_bus_private_data_handler);
 
+int acpi_bus_attach_private_data(acpi_handle handle, void *data)
+{
+        acpi_status status;
+
+        status = acpi_attach_data(handle,
+                        acpi_bus_private_data_handler, data);
+        if (ACPI_FAILURE(status)) {
+                acpi_handle_debug(handle, "Error attaching device data\n");
+                return -ENODEV;
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(acpi_bus_attach_private_data);
+
 int acpi_bus_get_private_data(acpi_handle handle, void **data)
 {
         acpi_status status;
@@ -140,15 +162,20 @@ int acpi_bus_get_private_data(acpi_handle handle, void **data)
                 return -EINVAL;
 
         status = acpi_get_data(handle, acpi_bus_private_data_handler, data);
-        if (ACPI_FAILURE(status) || !*data) {
-                ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No context for object [%p]\n",
-                                handle));
+        if (ACPI_FAILURE(status)) {
+                acpi_handle_debug(handle, "No context for object\n");
                 return -ENODEV;
         }
 
         return 0;
 }
-EXPORT_SYMBOL(acpi_bus_get_private_data);
+EXPORT_SYMBOL_GPL(acpi_bus_get_private_data);
+
+void acpi_bus_detach_private_data(acpi_handle handle)
+{
+        acpi_detach_data(handle, acpi_bus_private_data_handler);
+}
+EXPORT_SYMBOL_GPL(acpi_bus_detach_private_data);
 
 void acpi_bus_no_hotplug(acpi_handle handle)
 {
@@ -340,16 +367,18 @@ static void acpi_bus_notify(acpi_handle handle, u32 type, void *data)
 {
         struct acpi_device *adev;
         struct acpi_driver *driver;
-        acpi_status status;
         u32 ost_code = ACPI_OST_SC_NON_SPECIFIC_FAILURE;
+        bool hotplug_event = false;
 
         switch (type) {
         case ACPI_NOTIFY_BUS_CHECK:
                 acpi_handle_debug(handle, "ACPI_NOTIFY_BUS_CHECK event\n");
+                hotplug_event = true;
                 break;
 
         case ACPI_NOTIFY_DEVICE_CHECK:
                 acpi_handle_debug(handle, "ACPI_NOTIFY_DEVICE_CHECK event\n");
+                hotplug_event = true;
                 break;
 
         case ACPI_NOTIFY_DEVICE_WAKE:
@@ -358,6 +387,7 @@ static void acpi_bus_notify(acpi_handle handle, u32 type, void *data)
 
         case ACPI_NOTIFY_EJECT_REQUEST:
                 acpi_handle_debug(handle, "ACPI_NOTIFY_EJECT_REQUEST event\n");
+                hotplug_event = true;
                 break;
 
         case ACPI_NOTIFY_DEVICE_CHECK_LIGHT:
@@ -393,16 +423,9 @@ static void acpi_bus_notify(acpi_handle handle, u32 type, void *data)
             (driver->flags & ACPI_DRIVER_ALL_NOTIFY_EVENTS))
                 driver->ops.notify(adev, type);
 
-        switch (type) {
-        case ACPI_NOTIFY_BUS_CHECK:
-        case ACPI_NOTIFY_DEVICE_CHECK:
-        case ACPI_NOTIFY_EJECT_REQUEST:
-                status = acpi_hotplug_schedule(adev, type);
-                if (ACPI_SUCCESS(status))
-                        return;
-        default:
-                break;
-        }
+        if (hotplug_event && ACPI_SUCCESS(acpi_hotplug_schedule(adev, type)))
+                return;
+
         acpi_bus_put_acpi_device(adev);
         return;
 
@@ -466,6 +489,9 @@ void __init acpi_early_init(void)
 
         printk(KERN_INFO PREFIX "Core revision %08x\n", ACPI_CA_VERSION);
 
+        /* It's safe to verify table checksums during late stage */
+        acpi_gbl_verify_table_checksum = TRUE;
+
         /* enable workarounds, unless strict ACPI spec. compliance */
         if (!acpi_strict)
                 acpi_gbl_enable_interpreter_slack = TRUE;
diff --git a/drivers/acpi/container.c b/drivers/acpi/container.c
index 63119d09b354..76f7cff64594 100644
--- a/drivers/acpi/container.c
+++ b/drivers/acpi/container.c
@@ -41,6 +41,8 @@ static const struct acpi_device_id container_device_ids[] = {
         {"", 0},
 };
 
+#ifdef CONFIG_ACPI_CONTAINER
+
 static int acpi_container_offline(struct container_dev *cdev)
 {
         struct acpi_device *adev = ACPI_COMPANION(&cdev->dev);
@@ -109,5 +111,18 @@ static struct acpi_scan_handler container_handler = {
 
 void __init acpi_container_init(void)
 {
+        acpi_scan_add_handler(&container_handler);
+}
+
+#else
+
+static struct acpi_scan_handler container_handler = {
+        .ids = container_device_ids,
+};
+
+void __init acpi_container_init(void)
+{
         acpi_scan_add_handler_with_hotplug(&container_handler, "container");
 }
+
+#endif /* CONFIG_ACPI_CONTAINER */
diff --git a/drivers/acpi/device_pm.c b/drivers/acpi/device_pm.c
index d047739f3380..49a51277f81d 100644
--- a/drivers/acpi/device_pm.c
+++ b/drivers/acpi/device_pm.c
@@ -900,18 +900,47 @@ EXPORT_SYMBOL_GPL(acpi_dev_resume_early);
  */
 int acpi_subsys_prepare(struct device *dev)
 {
-        /*
-         * Devices having power.ignore_children set may still be necessary for
-         * suspending their children in the next phase of device suspend.
-         */
-        if (dev->power.ignore_children)
-                pm_runtime_resume(dev);
+        struct acpi_device *adev = ACPI_COMPANION(dev);
+        u32 sys_target;
+        int ret, state;
+
+        ret = pm_generic_prepare(dev);
+        if (ret < 0)
+                return ret;
+
+        if (!adev || !pm_runtime_suspended(dev)
+            || device_may_wakeup(dev) != !!adev->wakeup.prepare_count)
+                return 0;
+
+        sys_target = acpi_target_system_state();
+        if (sys_target == ACPI_STATE_S0)
+                return 1;
 
-        return pm_generic_prepare(dev);
+        if (adev->power.flags.dsw_present)
+                return 0;
+
+        ret = acpi_dev_pm_get_state(dev, adev, sys_target, NULL, &state);
+        return !ret && state == adev->power.state;
 }
 EXPORT_SYMBOL_GPL(acpi_subsys_prepare);
 
 /**
+ * acpi_subsys_complete - Finalize device's resume during system resume.
+ * @dev: Device to handle.
+ */
+void acpi_subsys_complete(struct device *dev)
+{
+        /*
+         * If the device had been runtime-suspended before the system went into
+         * the sleep state it is going out of and it has never been resumed till
+         * now, resume it in case the firmware powered it up.
+         */
+        if (dev->power.direct_complete)
+                pm_request_resume(dev);
+}
+EXPORT_SYMBOL_GPL(acpi_subsys_complete);
+
+/**
  * acpi_subsys_suspend - Run the device driver's suspend callback.
  * @dev: Device to handle.
  *
@@ -923,6 +952,7 @@ int acpi_subsys_suspend(struct device *dev)
         pm_runtime_resume(dev);
         return pm_generic_suspend(dev);
 }
+EXPORT_SYMBOL_GPL(acpi_subsys_suspend);
 
 /**
  * acpi_subsys_suspend_late - Suspend device using ACPI.
@@ -968,6 +998,7 @@ int acpi_subsys_freeze(struct device *dev)
         pm_runtime_resume(dev);
         return pm_generic_freeze(dev);
 }
+EXPORT_SYMBOL_GPL(acpi_subsys_freeze);
 
 #endif /* CONFIG_PM_SLEEP */
 
@@ -979,6 +1010,7 @@ static struct dev_pm_domain acpi_general_pm_domain = {
 #endif
 #ifdef CONFIG_PM_SLEEP
                 .prepare = acpi_subsys_prepare,
+                .complete = acpi_subsys_complete,
                 .suspend = acpi_subsys_suspend,
                 .suspend_late = acpi_subsys_suspend_late,
                 .resume_early = acpi_subsys_resume_early,
diff --git a/drivers/acpi/internal.h b/drivers/acpi/internal.h
index 957391306cbf..7de5b603f272 100644
--- a/drivers/acpi/internal.h
+++ b/drivers/acpi/internal.h
@@ -30,12 +30,10 @@ void acpi_pci_root_init(void);
 void acpi_pci_link_init(void);
 void acpi_processor_init(void);
 void acpi_platform_init(void);
+void acpi_pnp_init(void);
 int acpi_sysfs_init(void);
-#ifdef CONFIG_ACPI_CONTAINER
 void acpi_container_init(void);
-#else
-static inline void acpi_container_init(void) {}
-#endif
+void acpi_memory_hotplug_init(void);
 #ifdef CONFIG_ACPI_DOCK
 void register_dock_dependent_device(struct acpi_device *adev,
                                     acpi_handle dshandle);
@@ -47,11 +45,6 @@ static inline void register_dock_dependent_device(struct acpi_device *adev,
 static inline int dock_notify(struct acpi_device *adev, u32 event) { return -ENODEV; }
 static inline void acpi_dock_add(struct acpi_device *adev) {}
 #endif
-#ifdef CONFIG_ACPI_HOTPLUG_MEMORY
-void acpi_memory_hotplug_init(void);
-#else
-static inline void acpi_memory_hotplug_init(void) {}
-#endif
 #ifdef CONFIG_X86
 void acpi_cmos_rtc_init(void);
 #else
@@ -72,11 +65,7 @@ int acpi_debugfs_init(void);
 #else
 static inline void acpi_debugfs_init(void) { return; }
 #endif
-#ifdef CONFIG_X86_INTEL_LPSS
 void acpi_lpss_init(void);
-#else
-static inline void acpi_lpss_init(void) {}
-#endif
 
 acpi_status acpi_hotplug_schedule(struct acpi_device *adev, u32 src);
 bool acpi_queue_hotplug_work(struct work_struct *work);
@@ -180,8 +169,7 @@ static inline void suspend_nvs_restore(void) {}
   -------------------------------------------------------------------------- */
 struct platform_device;
 
-int acpi_create_platform_device(struct acpi_device *adev,
-                                const struct acpi_device_id *id);
+struct platform_device *acpi_create_platform_device(struct acpi_device *adev);
 
 /*--------------------------------------------------------------------------
                                         Video
diff --git a/drivers/acpi/nvs.c b/drivers/acpi/nvs.c
index de4fe03873c5..85287b8fe3aa 100644
--- a/drivers/acpi/nvs.c
+++ b/drivers/acpi/nvs.c
@@ -139,8 +139,8 @@ void suspend_nvs_free(void)
                                         iounmap(entry->kaddr);
                                         entry->unmap = false;
                                 } else {
-                                        acpi_os_unmap_memory(entry->kaddr,
-                                                             entry->size);
+                                        acpi_os_unmap_iomem(entry->kaddr,
+                                                            entry->size);
                                 }
                                 entry->kaddr = NULL;
                         }
diff --git a/drivers/acpi/osl.c b/drivers/acpi/osl.c
index 6776c599816f..147bc1b91b42 100644
--- a/drivers/acpi/osl.c
+++ b/drivers/acpi/osl.c
@@ -355,7 +355,7 @@ static void acpi_unmap(acpi_physical_address pg_off, void __iomem *vaddr)
 }
 
 void __iomem *__init_refok
-acpi_os_map_memory(acpi_physical_address phys, acpi_size size)
+acpi_os_map_iomem(acpi_physical_address phys, acpi_size size)
 {
         struct acpi_ioremap *map;
         void __iomem *virt;
@@ -401,10 +401,17 @@ acpi_os_map_memory(acpi_physical_address phys, acpi_size size)
 
         list_add_tail_rcu(&map->list, &acpi_ioremaps);
 
- out:
+out:
         mutex_unlock(&acpi_ioremap_lock);
         return map->virt + (phys - map->phys);
 }
+EXPORT_SYMBOL_GPL(acpi_os_map_iomem);
+
+void *__init_refok
+acpi_os_map_memory(acpi_physical_address phys, acpi_size size)
+{
+        return (void *)acpi_os_map_iomem(phys, size);
+}
 EXPORT_SYMBOL_GPL(acpi_os_map_memory);
 
 static void acpi_os_drop_map_ref(struct acpi_ioremap *map)
@@ -422,7 +429,7 @@ static void acpi_os_map_cleanup(struct acpi_ioremap *map)
         }
 }
 
-void __ref acpi_os_unmap_memory(void __iomem *virt, acpi_size size)
+void __ref acpi_os_unmap_iomem(void __iomem *virt, acpi_size size)
 {
         struct acpi_ioremap *map;
 
@@ -443,6 +450,12 @@ void __ref acpi_os_unmap_memory(void __iomem *virt, acpi_size size)
 
         acpi_os_map_cleanup(map);
 }
+EXPORT_SYMBOL_GPL(acpi_os_unmap_iomem);
+
+void __ref acpi_os_unmap_memory(void *virt, acpi_size size)
+{
+        return acpi_os_unmap_iomem((void __iomem *)virt, size);
+}
 EXPORT_SYMBOL_GPL(acpi_os_unmap_memory);
 
 void __init early_acpi_os_unmap_memory(void __iomem *virt, acpi_size size)
@@ -464,7 +477,7 @@ int acpi_os_map_generic_address(struct acpi_generic_address *gas)
         if (!addr || !gas->bit_width)
                 return -EINVAL;
 
-        virt = acpi_os_map_memory(addr, gas->bit_width / 8);
+        virt = acpi_os_map_iomem(addr, gas->bit_width / 8);
         if (!virt)
                 return -EIO;
 
@@ -1770,16 +1783,15 @@ acpi_status acpi_os_release_object(acpi_cache_t * cache, void *object)
 }
 #endif
 
-static int __init acpi_no_auto_ssdt_setup(char *s)
+static int __init acpi_no_static_ssdt_setup(char *s)
 {
-        printk(KERN_NOTICE PREFIX "SSDT auto-load disabled\n");
+        acpi_gbl_disable_ssdt_table_install = TRUE;
+        pr_info("ACPI: static SSDT installation disabled\n");
 
-        acpi_gbl_disable_ssdt_table_load = TRUE;
-
-        return 1;
+        return 0;
 }
 
-__setup("acpi_no_auto_ssdt", acpi_no_auto_ssdt_setup);
+early_param("acpi_no_static_ssdt", acpi_no_static_ssdt_setup);
 
 static int __init acpi_disable_return_repair(char *s)
 {
diff --git a/drivers/acpi/processor_driver.c b/drivers/acpi/processor_driver.c
index 7f70f3182d50..4fcbd670415c 100644
--- a/drivers/acpi/processor_driver.c
+++ b/drivers/acpi/processor_driver.c
@@ -121,6 +121,13 @@ static int acpi_cpu_soft_notify(struct notifier_block *nfb,
         struct acpi_processor *pr = per_cpu(processors, cpu);
         struct acpi_device *device;
 
+        /*
+         * CPU_STARTING and CPU_DYING must not sleep. Return here since
+         * acpi_bus_get_device() may sleep.
+         */
+        if (action == CPU_STARTING || action == CPU_DYING)
+                return NOTIFY_DONE;
+
         if (!pr || acpi_bus_get_device(pr->handle, &device))
                 return NOTIFY_DONE;
 
diff --git a/drivers/acpi/scan.c b/drivers/acpi/scan.c
index 7efe546a8c42..f775fa0d850f 100644
--- a/drivers/acpi/scan.c
+++ b/drivers/acpi/scan.c
@@ -84,7 +84,7 @@ EXPORT_SYMBOL_GPL(acpi_initialize_hp_context);
 
 int acpi_scan_add_handler(struct acpi_scan_handler *handler)
 {
-        if (!handler || !handler->attach)
+        if (!handler)
                 return -EINVAL;
 
         list_add_tail(&handler->list_node, &acpi_scan_handlers_list);
@@ -1551,9 +1551,13 @@ static void acpi_bus_get_power_flags(struct acpi_device *device)
          */
         if (acpi_has_method(device->handle, "_PSC"))
                 device->power.flags.explicit_get = 1;
+
         if (acpi_has_method(device->handle, "_IRC"))
                 device->power.flags.inrush_current = 1;
 
+        if (acpi_has_method(device->handle, "_DSW"))
+                device->power.flags.dsw_present = 1;
+
         /*
          * Enumerate supported power management states
          */
@@ -1793,8 +1797,10 @@ static void acpi_set_pnp_ids(acpi_handle handle, struct acpi_device_pnp *pnp,
                         return;
                 }
 
-                if (info->valid & ACPI_VALID_HID)
+                if (info->valid & ACPI_VALID_HID) {
                         acpi_add_id(pnp, info->hardware_id.string);
+                        pnp->type.platform_id = 1;
+                }
                 if (info->valid & ACPI_VALID_CID) {
                         cid_list = &info->compatible_id_list;
                         for (i = 0; i < cid_list->count; i++)
@@ -1973,6 +1979,9 @@ static bool acpi_scan_handler_matching(struct acpi_scan_handler *handler,
 {
         const struct acpi_device_id *devid;
 
+        if (handler->match)
+                return handler->match(idstr, matchid);
+
         for (devid = handler->ids; devid->id[0]; devid++)
                 if (!strcmp((char *)devid->id, idstr)) {
                         if (matchid)
@@ -2061,6 +2070,44 @@ static acpi_status acpi_bus_check_add(acpi_handle handle, u32 lvl_not_used,
         return AE_OK;
 }
 
+static int acpi_check_spi_i2c_slave(struct acpi_resource *ares, void *data)
+{
+        bool *is_spi_i2c_slave_p = data;
+
+        if (ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS)
+                return 1;
+
+        /*
+         * devices that are connected to UART still need to be enumerated to
+         * platform bus
+         */
+        if (ares->data.common_serial_bus.type != ACPI_RESOURCE_SERIAL_TYPE_UART)
+                *is_spi_i2c_slave_p = true;
+
+         /* no need to do more checking */
+        return -1;
+}
+
+static void acpi_default_enumeration(struct acpi_device *device)
+{
+        struct list_head resource_list;
+        bool is_spi_i2c_slave = false;
+
+        if (!device->pnp.type.platform_id || device->handler)
+                return;
+
+        /*
+         * Do not enemerate SPI/I2C slaves as they will be enuerated by their
+         * respective parents.
+         */
+        INIT_LIST_HEAD(&resource_list);
+        acpi_dev_get_resources(device, &resource_list, acpi_check_spi_i2c_slave,
+                               &is_spi_i2c_slave);
+        acpi_dev_free_resource_list(&resource_list);
+        if (!is_spi_i2c_slave)
+                acpi_create_platform_device(device);
+}
+
 static int acpi_scan_attach_handler(struct acpi_device *device)
 {
         struct acpi_hardware_id *hwid;
@@ -2072,6 +2119,10 @@ static int acpi_scan_attach_handler(struct acpi_device *device)
 
                 handler = acpi_scan_match_handler(hwid->id, &devid);
                 if (handler) {
+                        if (!handler->attach) {
+                                device->pnp.type.platform_id = 0;
+                                continue;
+                        }
                         device->handler = handler;
                         ret = handler->attach(device, devid);
                         if (ret > 0)
@@ -2082,6 +2133,9 @@ static int acpi_scan_attach_handler(struct acpi_device *device)
                                 break;
                 }
         }
+        if (!ret)
+                acpi_default_enumeration(device);
+
         return ret;
 }
 
@@ -2241,11 +2295,11 @@ int __init acpi_scan_init(void)
         acpi_pci_root_init();
         acpi_pci_link_init();
         acpi_processor_init();
-        acpi_platform_init();
         acpi_lpss_init();
         acpi_cmos_rtc_init();
         acpi_container_init();
         acpi_memory_hotplug_init();
+        acpi_pnp_init();
 
         mutex_lock(&acpi_scan_lock);
         /*
@@ -2259,12 +2313,16 @@ int __init acpi_scan_init(void)
         if (result)
                 goto out;
 
-        result = acpi_bus_scan_fixed();
-        if (result) {
-                acpi_detach_data(acpi_root->handle, acpi_scan_drop_device);
-                acpi_device_del(acpi_root);
-                put_device(&acpi_root->dev);
-                goto out;
+        /* Fixed feature devices do not exist on HW-reduced platform */
+        if (!acpi_gbl_reduced_hardware) {
+                result = acpi_bus_scan_fixed();
+                if (result) {
+                        acpi_detach_data(acpi_root->handle,
+                                         acpi_scan_drop_device);
+                        acpi_device_del(acpi_root);
+                        put_device(&acpi_root->dev);
+                        goto out;
+                }
         }
 
         acpi_update_all_gpes();
diff --git a/drivers/acpi/sleep.c b/drivers/acpi/sleep.c
index c40fb2e81bbc..c11e3795431b 100644
--- a/drivers/acpi/sleep.c
+++ b/drivers/acpi/sleep.c
@@ -89,6 +89,7 @@ u32 acpi_target_system_state(void)
 {
         return acpi_target_sleep_state;
 }
+EXPORT_SYMBOL_GPL(acpi_target_system_state);
 
 static bool pwr_btn_event_pending;
 
@@ -611,6 +612,22 @@ static const struct platform_suspend_ops acpi_suspend_ops_old = {
         .recover = acpi_pm_finish,
 };
 
+static int acpi_freeze_begin(void)
+{
+        acpi_scan_lock_acquire();
+        return 0;
+}
+
+static void acpi_freeze_end(void)
+{
+        acpi_scan_lock_release();
+}
+
+static const struct platform_freeze_ops acpi_freeze_ops = {
+        .begin = acpi_freeze_begin,
+        .end = acpi_freeze_end,
+};
+
 static void acpi_sleep_suspend_setup(void)
 {
         int i;
@@ -621,7 +638,9 @@ static void acpi_sleep_suspend_setup(void)
 
         suspend_set_ops(old_suspend_ordering ?
                 &acpi_suspend_ops_old : &acpi_suspend_ops);
+        freeze_set_ops(&acpi_freeze_ops);
 }
+
 #else /* !CONFIG_SUSPEND */
 static inline void acpi_sleep_suspend_setup(void) {}
 #endif /* !CONFIG_SUSPEND */
diff --git a/drivers/acpi/tables.c b/drivers/acpi/tables.c
index 21782290df41..05550ba44d32 100644
--- a/drivers/acpi/tables.c
+++ b/drivers/acpi/tables.c
@@ -44,6 +44,12 @@ static struct acpi_table_desc initial_tables[ACPI_MAX_TABLES] __initdata;
 
 static int acpi_apic_instance __initdata;
 
+/*
+ * Disable table checksum verification for the early stage due to the size
+ * limitation of the current x86 early mapping implementation.
+ */
+static bool acpi_verify_table_checksum __initdata = false;
+
 void acpi_table_print_madt_entry(struct acpi_subtable_header *header)
 {
         if (!header)
@@ -333,6 +339,14 @@ int __init acpi_table_init(void)
 {
         acpi_status status;
 
+        if (acpi_verify_table_checksum) {
+                pr_info("Early table checksum verification enabled\n");
+                acpi_gbl_verify_table_checksum = TRUE;
+        } else {
+                pr_info("Early table checksum verification disabled\n");
+                acpi_gbl_verify_table_checksum = FALSE;
+        }
+
         status = acpi_initialize_tables(initial_tables, ACPI_MAX_TABLES, 0);
         if (ACPI_FAILURE(status))
                 return -EINVAL;
@@ -354,3 +368,12 @@ static int __init acpi_parse_apic_instance(char *str)
 }
 
 early_param("acpi_apic_instance", acpi_parse_apic_instance);
+
+static int __init acpi_force_table_verification_setup(char *s)
+{
+        acpi_verify_table_checksum = true;
+
+        return 0;
+}
+
+early_param("acpi_force_table_verification", acpi_force_table_verification_setup);
diff --git a/drivers/acpi/thermal.c b/drivers/acpi/thermal.c
index 25bbc55dca89..112817e963e0 100644
--- a/drivers/acpi/thermal.c
+++ b/drivers/acpi/thermal.c
@@ -925,13 +925,10 @@ static int acpi_thermal_register_thermal_zone(struct acpi_thermal *tz)
         if (result)
                 return result;
 
-        status = acpi_attach_data(tz->device->handle,
-                                  acpi_bus_private_data_handler,
-                                  tz->thermal_zone);
-        if (ACPI_FAILURE(status)) {
-                pr_err(PREFIX "Error attaching device data\n");
+        status =  acpi_bus_attach_private_data(tz->device->handle,
+                                               tz->thermal_zone);
+        if (ACPI_FAILURE(status))
                 return -ENODEV;
-        }
 
         tz->tz_enabled = 1;
 
@@ -946,7 +943,7 @@ static void acpi_thermal_unregister_thermal_zone(struct acpi_thermal *tz)
         sysfs_remove_link(&tz->thermal_zone->device.kobj, "device");
         thermal_zone_device_unregister(tz->thermal_zone);
         tz->thermal_zone = NULL;
-        acpi_detach_data(tz->device->handle, acpi_bus_private_data_handler);
+        acpi_bus_detach_private_data(tz->device->handle);
 }
 
 
diff --git a/drivers/acpi/utils.c b/drivers/acpi/utils.c
index bba526148583..07c8c5a5ee95 100644
--- a/drivers/acpi/utils.c
+++ b/drivers/acpi/utils.c
@@ -30,6 +30,7 @@
 #include <linux/types.h>
 #include <linux/hardirq.h>
 #include <linux/acpi.h>
+#include <linux/dynamic_debug.h>
 
 #include "internal.h"
 
@@ -457,6 +458,24 @@ acpi_evaluate_ost(acpi_handle handle, u32 source_event, u32 status_code,
 EXPORT_SYMBOL(acpi_evaluate_ost);
 
 /**
+ * acpi_handle_path: Return the object path of handle
+ *
+ * Caller must free the returned buffer
+ */
+static char *acpi_handle_path(acpi_handle handle)
+{
+        struct acpi_buffer buffer = {
+                .length = ACPI_ALLOCATE_BUFFER,
+                .pointer = NULL
+        };
+
+        if (in_interrupt() ||
+            acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer) != AE_OK)
+                return NULL;
+        return buffer.pointer;
+}
+
+/**
  * acpi_handle_printk: Print message with ACPI prefix and object path
  *
  * This function is called through acpi_handle_<level> macros and prints
@@ -469,29 +488,50 @@ acpi_handle_printk(const char *level, acpi_handle handle, const char *fmt, ...)
 {
         struct va_format vaf;
         va_list args;
-        struct acpi_buffer buffer = {
-                .length = ACPI_ALLOCATE_BUFFER,
-                .pointer = NULL
-        };
         const char *path;
 
         va_start(args, fmt);
         vaf.fmt = fmt;
         vaf.va = &args;
 
-        if (in_interrupt() ||
-            acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer) != AE_OK)
-                path = "<n/a>";
-        else
-                path = buffer.pointer;
-
-        printk("%sACPI: %s: %pV", level, path, &vaf);
+        path = acpi_handle_path(handle);
+        printk("%sACPI: %s: %pV", level, path ? path : "<n/a>" , &vaf);
 
         va_end(args);
-        kfree(buffer.pointer);
+        kfree(path);
 }
 EXPORT_SYMBOL(acpi_handle_printk);
 
+#if defined(CONFIG_DYNAMIC_DEBUG)
+/**
+ * __acpi_handle_debug: pr_debug with ACPI prefix and object path
+ *
+ * This function is called through acpi_handle_debug macro and debug
+ * prints a message with ACPI prefix and object path. This function
+ * acquires the global namespace mutex to obtain an object path.  In
+ * interrupt context, it shows the object path as <n/a>.
+ */
+void
+__acpi_handle_debug(struct _ddebug *descriptor, acpi_handle handle,
+                    const char *fmt, ...)
+{
+        struct va_format vaf;
+        va_list args;
+        const char *path;
+
+        va_start(args, fmt);
+        vaf.fmt = fmt;
+        vaf.va = &args;
+
+        path = acpi_handle_path(handle);
+        __dynamic_pr_debug(descriptor, "ACPI: %s: %pV", path ? path : "<n/a>", &vaf);
+
+        va_end(args);
+        kfree(path);
+}
+EXPORT_SYMBOL(__acpi_handle_debug);
+#endif
+
 /**
  * acpi_has_method: Check whether @handle has a method named @name
  * @handle: ACPI device handle
diff --git a/drivers/acpi/video.c b/drivers/acpi/video.c
index f8bc5a755dda..101fb090dcb9 100644
--- a/drivers/acpi/video.c
+++ b/drivers/acpi/video.c
@@ -68,7 +68,7 @@ MODULE_AUTHOR("Bruno Ducrot");
 MODULE_DESCRIPTION("ACPI Video Driver");
 MODULE_LICENSE("GPL");
 
-static bool brightness_switch_enabled = 1;
+static bool brightness_switch_enabled;
 module_param(brightness_switch_enabled, bool, 0644);
 
 /*
@@ -150,6 +150,8 @@ struct acpi_video_enumerated_device {
 
 struct acpi_video_bus {
         struct acpi_device *device;
+        bool backlight_registered;
+        bool backlight_notifier_registered;
         u8 dos_setting;
         struct acpi_video_enumerated_device *attached_array;
         u8 attached_count;
@@ -161,6 +163,7 @@ struct acpi_video_bus {
         struct input_dev *input;
         char phys[32];  /* for input device */
         struct notifier_block pm_nb;
+        struct notifier_block backlight_nb;
 };
 
 struct acpi_video_device_flags {
@@ -473,6 +476,14 @@ static struct dmi_system_id video_dmi_table[] __initdata = {
         },
         {
          .callback = video_set_use_native_backlight,
+         .ident = "ThinkPad W530",
+         .matches = {
+                DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
+                DMI_MATCH(DMI_PRODUCT_VERSION, "ThinkPad W530"),
+                },
+        },
+        {
+         .callback = video_set_use_native_backlight,
         .ident = "ThinkPad X1 Carbon",
         .matches = {
                 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
@@ -488,6 +499,14 @@ static struct dmi_system_id video_dmi_table[] __initdata = {
                 },
         },
         {
+         .callback = video_set_use_native_backlight,
+         .ident = "Lenovo Yoga 2 11",
+         .matches = {
+                DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
+                DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo Yoga 2 11"),
+                },
+        },
+        {
         .callback = video_set_use_native_backlight,
         .ident = "Thinkpad Helix",
         .matches = {
@@ -521,6 +540,14 @@ static struct dmi_system_id video_dmi_table[] __initdata = {
         },
         {
          .callback = video_set_use_native_backlight,
+         .ident = "Acer Aspire V5-171",
+         .matches = {
+                DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
+                DMI_MATCH(DMI_PRODUCT_NAME, "V5-171"),
+                },
+        },
+        {
+         .callback = video_set_use_native_backlight,
          .ident = "Acer Aspire V5-431",
          .matches = {
                 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
@@ -528,6 +555,14 @@ static struct dmi_system_id video_dmi_table[] __initdata = {
                 },
         },
         {
+         .callback = video_set_use_native_backlight,
+         .ident = "Acer Aspire V5-471G",
+         .matches = {
+                DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
+                DMI_MATCH(DMI_PRODUCT_NAME, "Aspire V5-471G"),
+                },
+        },
+        {
         .callback = video_set_use_native_backlight,
         .ident = "HP ProBook 4340s",
         .matches = {
@@ -579,6 +614,14 @@ static struct dmi_system_id video_dmi_table[] __initdata = {
         },
         {
         .callback = video_set_use_native_backlight,
+        .ident = "HP EliteBook 8470p",
+        .matches = {
+                DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
+                DMI_MATCH(DMI_PRODUCT_NAME, "HP EliteBook 8470p"),
+                },
+        },
+        {
+        .callback = video_set_use_native_backlight,
         .ident = "HP EliteBook 8780w",
         .matches = {
                 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
@@ -1658,88 +1701,92 @@ acpi_video_bus_match(acpi_handle handle, u32 level, void *context,
 
 static void acpi_video_dev_register_backlight(struct acpi_video_device *device)
 {
-        if (acpi_video_verify_backlight_support()) {
-                struct backlight_properties props;
-                struct pci_dev *pdev;
-                acpi_handle acpi_parent;
-                struct device *parent = NULL;
-                int result;
-                static int count;
-                char *name;
-
-                result = acpi_video_init_brightness(device);
-                if (result)
-                        return;
-                name = kasprintf(GFP_KERNEL, "acpi_video%d", count);
-                if (!name)
-                        return;
-                count++;
+        struct backlight_properties props;
+        struct pci_dev *pdev;
+        acpi_handle acpi_parent;
+        struct device *parent = NULL;
+        int result;
+        static int count;
+        char *name;
 
-                acpi_get_parent(device->dev->handle, &acpi_parent);
+        result = acpi_video_init_brightness(device);
+        if (result)
+                return;
+        name = kasprintf(GFP_KERNEL, "acpi_video%d", count);
+        if (!name)
+                return;
+        count++;
 
-                pdev = acpi_get_pci_dev(acpi_parent);
-                if (pdev) {
-                        parent = &pdev->dev;
-                        pci_dev_put(pdev);
-                }
+        acpi_get_parent(device->dev->handle, &acpi_parent);
 
-                memset(&props, 0, sizeof(struct backlight_properties));
-                props.type = BACKLIGHT_FIRMWARE;
-                props.max_brightness = device->brightness->count - 3;
-                device->backlight = backlight_device_register(name,
-                                                              parent,
-                                                              device,
-                                                              &acpi_backlight_ops,
-                                                              &props);
-                kfree(name);
-                if (IS_ERR(device->backlight))
-                        return;
+        pdev = acpi_get_pci_dev(acpi_parent);
+        if (pdev) {
+                parent = &pdev->dev;
+                pci_dev_put(pdev);
+        }
 
-                /*
-                 * Save current brightness level in case we have to restore it
-                 * before acpi_video_device_lcd_set_level() is called next time.
-                 */
-                device->backlight->props.brightness =
-                                acpi_video_get_brightness(device->backlight);
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.type = BACKLIGHT_FIRMWARE;
+        props.max_brightness = device->brightness->count - 3;
+        device->backlight = backlight_device_register(name,
+                                                      parent,
+                                                      device,
+                                                      &acpi_backlight_ops,
+                                                      &props);
+        kfree(name);
+        if (IS_ERR(device->backlight))
+                return;
 
-                device->cooling_dev = thermal_cooling_device_register("LCD",
-                                        device->dev, &video_cooling_ops);
-                if (IS_ERR(device->cooling_dev)) {
-                        /*
-                         * Set cooling_dev to NULL so we don't crash trying to
-                         * free it.
-                         * Also, why the hell we are returning early and
-                         * not attempt to register video output if cooling
-                         * device registration failed?
-                         * -- dtor
-                         */
-                        device->cooling_dev = NULL;
-                        return;
-                }
+        /*
+         * Save current brightness level in case we have to restore it
+         * before acpi_video_device_lcd_set_level() is called next time.
+         */
+        device->backlight->props.brightness =
+                        acpi_video_get_brightness(device->backlight);
 
-                dev_info(&device->dev->dev, "registered as cooling_device%d\n",
-                         device->cooling_dev->id);
-                result = sysfs_create_link(&device->dev->dev.kobj,
-                                &device->cooling_dev->device.kobj,
-                                "thermal_cooling");
-                if (result)
-                        printk(KERN_ERR PREFIX "Create sysfs link\n");
-                result = sysfs_create_link(&device->cooling_dev->device.kobj,
-                                &device->dev->dev.kobj, "device");
-                if (result)
-                        printk(KERN_ERR PREFIX "Create sysfs link\n");
+        device->cooling_dev = thermal_cooling_device_register("LCD",
+                                device->dev, &video_cooling_ops);
+        if (IS_ERR(device->cooling_dev)) {
+                /*
+                 * Set cooling_dev to NULL so we don't crash trying to free it.
+                 * Also, why the hell we are returning early and not attempt to
+                 * register video output if cooling device registration failed?
+                 * -- dtor
+                 */
+                device->cooling_dev = NULL;
+                return;
         }
+
+        dev_info(&device->dev->dev, "registered as cooling_device%d\n",
+                 device->cooling_dev->id);
+        result = sysfs_create_link(&device->dev->dev.kobj,
+                        &device->cooling_dev->device.kobj,
+                        "thermal_cooling");
+        if (result)
+                printk(KERN_ERR PREFIX "Create sysfs link\n");
+        result = sysfs_create_link(&device->cooling_dev->device.kobj,
+                        &device->dev->dev.kobj, "device");
+        if (result)
+                printk(KERN_ERR PREFIX "Create sysfs link\n");
 }
 
 static int acpi_video_bus_register_backlight(struct acpi_video_bus *video)
 {
         struct acpi_video_device *dev;
 
+        if (video->backlight_registered)
+                return 0;
+
+        if (!acpi_video_verify_backlight_support())
+                return 0;
+
         mutex_lock(&video->device_list_lock);
         list_for_each_entry(dev, &video->video_device_list, entry)
                 acpi_video_dev_register_backlight(dev);
         mutex_unlock(&video->device_list_lock);
 
+        video->backlight_registered = true;
+
         video->pm_nb.notifier_call = acpi_video_resume;
         video->pm_nb.priority = 0;
         return register_pm_notifier(&video->pm_nb);
@@ -1767,13 +1814,20 @@ static void acpi_video_dev_unregister_backlight(struct acpi_video_device *device
 static int acpi_video_bus_unregister_backlight(struct acpi_video_bus *video)
 {
         struct acpi_video_device *dev;
-        int error = unregister_pm_notifier(&video->pm_nb);
+        int error;
+
+        if (!video->backlight_registered)
+                return 0;
+
+        error = unregister_pm_notifier(&video->pm_nb);
 
         mutex_lock(&video->device_list_lock);
         list_for_each_entry(dev, &video->video_device_list, entry)
                 acpi_video_dev_unregister_backlight(dev);
         mutex_unlock(&video->device_list_lock);
 
+        video->backlight_registered = false;
+
         return error;
 }
 
@@ -1867,6 +1921,56 @@ static void acpi_video_bus_remove_notify_handler(struct acpi_video_bus *video)
         video->input = NULL;
 }
 
+static int acpi_video_backlight_notify(struct notifier_block *nb,
+                                        unsigned long val, void *bd)
+{
+        struct backlight_device *backlight = bd;
+        struct acpi_video_bus *video;
+
+        /* acpi_video_verify_backlight_support only cares about raw devices */
+        if (backlight->props.type != BACKLIGHT_RAW)
+                return NOTIFY_DONE;
+
+        video = container_of(nb, struct acpi_video_bus, backlight_nb);
+
+        switch (val) {
+        case BACKLIGHT_REGISTERED:
+                if (!acpi_video_verify_backlight_support())
+                        acpi_video_bus_unregister_backlight(video);
+                break;
+        case BACKLIGHT_UNREGISTERED:
+                acpi_video_bus_register_backlight(video);
+                break;
+        }
+
+        return NOTIFY_OK;
+}
+
+static int acpi_video_bus_add_backlight_notify_handler(
+                                                struct acpi_video_bus *video)
+{
+        int error;
+
+        video->backlight_nb.notifier_call = acpi_video_backlight_notify;
+        video->backlight_nb.priority = 0;
+        error = backlight_register_notifier(&video->backlight_nb);
+        if (error == 0)
+                video->backlight_notifier_registered = true;
+
+        return error;
+}
+
+static int acpi_video_bus_remove_backlight_notify_handler(
+                                                struct acpi_video_bus *video)
+{
+        if (!video->backlight_notifier_registered)
+                return 0;
+
+        video->backlight_notifier_registered = false;
+
+        return backlight_unregister_notifier(&video->backlight_nb);
+}
+
 static int acpi_video_bus_put_devices(struct acpi_video_bus *video)
 {
         struct acpi_video_device *dev, *next;
@@ -1948,6 +2052,7 @@ static int acpi_video_bus_add(struct acpi_device *device)
 
         acpi_video_bus_register_backlight(video);
         acpi_video_bus_add_notify_handler(video);
+        acpi_video_bus_add_backlight_notify_handler(video);
 
         return 0;
 
@@ -1971,6 +2076,7 @@ static int acpi_video_bus_remove(struct acpi_device *device)
 
         video = acpi_driver_data(device);
 
+        acpi_video_bus_remove_backlight_notify_handler(video);
         acpi_video_bus_remove_notify_handler(video);
         acpi_video_bus_unregister_backlight(video);
         acpi_video_bus_put_devices(video);
@@ -2061,6 +2167,20 @@ void acpi_video_unregister(void)
 }
 EXPORT_SYMBOL(acpi_video_unregister);
 
+void acpi_video_unregister_backlight(void)
+{
+        struct acpi_video_bus *video;
+
+        if (!register_count)
+                return;
+
+        mutex_lock(&video_list_lock);
+        list_for_each_entry(video, &video_bus_head, entry)
+                acpi_video_bus_unregister_backlight(video);
+        mutex_unlock(&video_list_lock);
+}
+EXPORT_SYMBOL(acpi_video_unregister_backlight);
+
 /*
  * This is kind of nasty. Hardware using Intel chipsets may require
  * the video opregion code to be run first in order to initialise
diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index 86d5e4fb5b98..343ffad59377 100644
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -479,7 +479,7 @@ static int device_resume_noirq(struct device *dev, pm_message_t state, bool asyn
         TRACE_DEVICE(dev);
         TRACE_RESUME(0);
 
-        if (dev->power.syscore)
+        if (dev->power.syscore || dev->power.direct_complete)
                 goto Out;
 
         if (!dev->power.is_noirq_suspended)
@@ -605,7 +605,7 @@ static int device_resume_early(struct device *dev, pm_message_t state, bool asyn
         TRACE_DEVICE(dev);
         TRACE_RESUME(0);
 
-        if (dev->power.syscore)
+        if (dev->power.syscore || dev->power.direct_complete)
                 goto Out;
 
         if (!dev->power.is_late_suspended)
@@ -735,6 +735,12 @@ static int device_resume(struct device *dev, pm_message_t state, bool async)
         if (dev->power.syscore)
                 goto Complete;
 
+        if (dev->power.direct_complete) {
+                /* Match the pm_runtime_disable() in __device_suspend(). */
+                pm_runtime_enable(dev);
+                goto Complete;
+        }
+
         dpm_wait(dev->parent, async);
         dpm_watchdog_set(&wd, dev);
         device_lock(dev);
@@ -1007,7 +1013,7 @@ static int __device_suspend_noirq(struct device *dev, pm_message_t state, bool a
                 goto Complete;
         }
 
-        if (dev->power.syscore)
+        if (dev->power.syscore || dev->power.direct_complete)
                 goto Complete;
 
         dpm_wait_for_children(dev, async);
@@ -1146,7 +1152,7 @@ static int __device_suspend_late(struct device *dev, pm_message_t state, bool as
                 goto Complete;
         }
 
-        if (dev->power.syscore)
+        if (dev->power.syscore || dev->power.direct_complete)
                 goto Complete;
 
         dpm_wait_for_children(dev, async);
@@ -1332,6 +1338,17 @@ static int __device_suspend(struct device *dev, pm_message_t state, bool async)
         if (dev->power.syscore)
                 goto Complete;
 
+        if (dev->power.direct_complete) {
+                if (pm_runtime_status_suspended(dev)) {
+                        pm_runtime_disable(dev);
+                        if (pm_runtime_suspended_if_enabled(dev))
+                                goto Complete;
+
+                        pm_runtime_enable(dev);
+                }
+                dev->power.direct_complete = false;
+        }
+
         dpm_watchdog_set(&wd, dev);
         device_lock(dev);
 
@@ -1382,10 +1399,19 @@ static int __device_suspend(struct device *dev, pm_message_t state, bool async)
 
  End:
         if (!error) {
+                struct device *parent = dev->parent;
+
                 dev->power.is_suspended = true;
-                if (dev->power.wakeup_path
-                    && dev->parent && !dev->parent->power.ignore_children)
-                        dev->parent->power.wakeup_path = true;
+                if (parent) {
+                        spin_lock_irq(&parent->power.lock);
+
+                        dev->parent->power.direct_complete = false;
+                        if (dev->power.wakeup_path
+                            && !dev->parent->power.ignore_children)
+                                dev->parent->power.wakeup_path = true;
+
+                        spin_unlock_irq(&parent->power.lock);
+                }
         }
 
         device_unlock(dev);
@@ -1487,7 +1513,7 @@ static int device_prepare(struct device *dev, pm_message_t state)
 {
         int (*callback)(struct device *) = NULL;
         char *info = NULL;
-        int error = 0;
+        int ret = 0;
 
         if (dev->power.syscore)
                 return 0;
@@ -1523,17 +1549,27 @@ static int device_prepare(struct device *dev, pm_message_t state)
                 callback = dev->driver->pm->prepare;
         }
 
-        if (callback) {
-                error = callback(dev);
-                suspend_report_result(callback, error);
-        }
+        if (callback)
+                ret = callback(dev);
 
         device_unlock(dev);
 
-        if (error)
+        if (ret < 0) {
+                suspend_report_result(callback, ret);
                 pm_runtime_put(dev);
-
-        return error;
+                return ret;
+        }
+        /*
+         * A positive return value from ->prepare() means "this device appears
+         * to be runtime-suspended and its state is fine, so if it really is
+         * runtime-suspended, you can leave it in that state provided that you
+         * will do the same thing with all of its descendants".  This only
+         * applies to suspend transitions, however.
+         */
+        spin_lock_irq(&dev->power.lock);
+        dev->power.direct_complete = ret > 0 && state.event == PM_EVENT_SUSPEND;
+        spin_unlock_irq(&dev->power.lock);
+        return 0;
 }
 
 /**
diff --git a/drivers/base/power/opp.c b/drivers/base/power/opp.c
index 25538675d59e..89ced955fafa 100644
--- a/drivers/base/power/opp.c
+++ b/drivers/base/power/opp.c
@@ -15,7 +15,6 @@
 #include <linux/errno.h>
 #include <linux/err.h>
 #include <linux/slab.h>
-#include <linux/cpufreq.h>
 #include <linux/device.h>
 #include <linux/list.h>
 #include <linux/rculist.h>
@@ -394,6 +393,13 @@ EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_floor);
  * to keep the integrity of the internal data structures. Callers should ensure
  * that this function is *NOT* called under RCU protection or in contexts where
  * mutex cannot be locked.
+ *
+ * Return:
+ * 0:           On success OR
+ *              Duplicate OPPs (both freq and volt are same) and opp->available
+ * -EEXIST:     Freq are same and volt are different OR
+ *              Duplicate OPPs (both freq and volt are same) and !opp->available
+ * -ENOMEM:     Memory allocation failure
  */
 int dev_pm_opp_add(struct device *dev, unsigned long freq, unsigned long u_volt)
 {
@@ -443,15 +449,31 @@ int dev_pm_opp_add(struct device *dev, unsigned long freq, unsigned long u_volt)
         new_opp->u_volt = u_volt;
         new_opp->available = true;
 
-        /* Insert new OPP in order of increasing frequency */
+        /*
+         * Insert new OPP in order of increasing frequency
+         * and discard if already present
+         */
         head = &dev_opp->opp_list;
         list_for_each_entry_rcu(opp, &dev_opp->opp_list, node) {
-                if (new_opp->rate < opp->rate)
+                if (new_opp->rate <= opp->rate)
                         break;
                 else
                         head = &opp->node;
         }
 
+        /* Duplicate OPPs ? */
+        if (new_opp->rate == opp->rate) {
+                int ret = opp->available && new_opp->u_volt == opp->u_volt ?
+                        0 : -EEXIST;
+
+                dev_warn(dev, "%s: duplicate OPPs detected. Existing: freq: %lu, volt: %lu, enabled: %d. New: freq: %lu, volt: %lu, enabled: %d\n",
+                         __func__, opp->rate, opp->u_volt, opp->available,
+                         new_opp->rate, new_opp->u_volt, new_opp->available);
+                mutex_unlock(&dev_opp_list_lock);
+                kfree(new_opp);
+                return ret;
+        }
+
         list_add_rcu(&new_opp->node, head);
         mutex_unlock(&dev_opp_list_lock);
 
@@ -596,96 +618,6 @@ int dev_pm_opp_disable(struct device *dev, unsigned long freq)
 }
 EXPORT_SYMBOL_GPL(dev_pm_opp_disable);
 
-#ifdef CONFIG_CPU_FREQ
-/**
- * dev_pm_opp_init_cpufreq_table() - create a cpufreq table for a device
- * @dev:        device for which we do this operation
- * @table:      Cpufreq table returned back to caller
- *
- * Generate a cpufreq table for a provided device- this assumes that the
- * opp list is already initialized and ready for usage.
- *
- * This function allocates required memory for the cpufreq table. It is
- * expected that the caller does the required maintenance such as freeing
- * the table as required.
- *
- * Returns -EINVAL for bad pointers, -ENODEV if the device is not found, -ENOMEM
- * if no memory available for the operation (table is not populated), returns 0
- * if successful and table is populated.
- *
- * WARNING: It is  important for the callers to ensure refreshing their copy of
- * the table if any of the mentioned functions have been invoked in the interim.
- *
- * Locking: The internal device_opp and opp structures are RCU protected.
- * To simplify the logic, we pretend we are updater and hold relevant mutex here
- * Callers should ensure that this function is *NOT* called under RCU protection
- * or in contexts where mutex locking cannot be used.
- */
-int dev_pm_opp_init_cpufreq_table(struct device *dev,
-                            struct cpufreq_frequency_table **table)
-{
-        struct device_opp *dev_opp;
-        struct dev_pm_opp *opp;
-        struct cpufreq_frequency_table *freq_table;
-        int i = 0;
-
-        /* Pretend as if I am an updater */
-        mutex_lock(&dev_opp_list_lock);
-
-        dev_opp = find_device_opp(dev);
-        if (IS_ERR(dev_opp)) {
-                int r = PTR_ERR(dev_opp);
-                mutex_unlock(&dev_opp_list_lock);
-                dev_err(dev, "%s: Device OPP not found (%d)\n", __func__, r);
-                return r;
-        }
-
-        freq_table = kzalloc(sizeof(struct cpufreq_frequency_table) *
-                             (dev_pm_opp_get_opp_count(dev) + 1), GFP_KERNEL);
-        if (!freq_table) {
-                mutex_unlock(&dev_opp_list_lock);
-                dev_warn(dev, "%s: Unable to allocate frequency table\n",
-                        __func__);
-                return -ENOMEM;
-        }
-
-        list_for_each_entry(opp, &dev_opp->opp_list, node) {
-                if (opp->available) {
-                        freq_table[i].driver_data = i;
-                        freq_table[i].frequency = opp->rate / 1000;
-                        i++;
-                }
-        }
-        mutex_unlock(&dev_opp_list_lock);
-
-        freq_table[i].driver_data = i;
-        freq_table[i].frequency = CPUFREQ_TABLE_END;
-
-        *table = &freq_table[0];
-
-        return 0;
-}
-EXPORT_SYMBOL_GPL(dev_pm_opp_init_cpufreq_table);
-
-/**
- * dev_pm_opp_free_cpufreq_table() - free the cpufreq table
- * @dev:        device for which we do this operation
- * @table:      table to free
- *
- * Free up the table allocated by dev_pm_opp_init_cpufreq_table
- */
-void dev_pm_opp_free_cpufreq_table(struct device *dev,
-                                struct cpufreq_frequency_table **table)
-{
-        if (!table)
-                return;
-
-        kfree(*table);
-        *table = NULL;
-}
-EXPORT_SYMBOL_GPL(dev_pm_opp_free_cpufreq_table);
-#endif          /* CONFIG_CPU_FREQ */
-
 /**
  * dev_pm_opp_get_notifier() - find notifier_head of the device with opp
  * @dev:        device pointer used to lookup device OPPs.
@@ -734,11 +666,9 @@ int of_init_opp_table(struct device *dev)
                 unsigned long freq = be32_to_cpup(val++) * 1000;
                 unsigned long volt = be32_to_cpup(val++);
 
-                if (dev_pm_opp_add(dev, freq, volt)) {
+                if (dev_pm_opp_add(dev, freq, volt))
                         dev_warn(dev, "%s: Failed to add OPP %ld\n",
                                  __func__, freq);
-                        continue;
-                }
                 nr -= 2;
         }
 
diff --git a/drivers/base/power/wakeup.c b/drivers/base/power/wakeup.c
index 2d56f4113ae7..eb1bd2ecad8b 100644
--- a/drivers/base/power/wakeup.c
+++ b/drivers/base/power/wakeup.c
@@ -318,10 +318,16 @@ int device_init_wakeup(struct device *dev, bool enable)
 {
         int ret = 0;
 
+        if (!dev)
+                return -EINVAL;
+
         if (enable) {
                 device_set_wakeup_capable(dev, true);
                 ret = device_wakeup_enable(dev);
         } else {
+                if (dev->power.can_wakeup)
+                        device_wakeup_disable(dev);
+
                 device_set_wakeup_capable(dev, false);
         }
 
diff --git a/drivers/char/tpm/tpm_acpi.c b/drivers/char/tpm/tpm_acpi.c
index b9a57fa4b710..565a9478cb94 100644
--- a/drivers/char/tpm/tpm_acpi.c
+++ b/drivers/char/tpm/tpm_acpi.c
@@ -95,7 +95,7 @@ int read_log(struct tpm_bios_log *log)
 
         log->bios_event_log_end = log->bios_event_log + len;
 
-        virt = acpi_os_map_memory(start, len);
+        virt = acpi_os_map_iomem(start, len);
         if (!virt) {
                 kfree(log->bios_event_log);
                 printk("%s: ERROR - Unable to map memory\n", __func__);
@@ -104,6 +104,6 @@ int read_log(struct tpm_bios_log *log)
 
         memcpy_fromio(log->bios_event_log, virt, len);
 
-        acpi_os_unmap_memory(virt, len);
+        acpi_os_unmap_iomem(virt, len);
         return 0;
 }
diff --git a/drivers/clk/Makefile b/drivers/clk/Makefile
index 17d7f13d19a5..50b2a7ebd747 100644
--- a/drivers/clk/Makefile
+++ b/drivers/clk/Makefile
@@ -8,6 +8,7 @@ obj-$(CONFIG_COMMON_CLK)	+= clk-fixed-rate.o
 obj-$(CONFIG_COMMON_CLK)        += clk-gate.o
 obj-$(CONFIG_COMMON_CLK)        += clk-mux.o
 obj-$(CONFIG_COMMON_CLK)        += clk-composite.o
+obj-$(CONFIG_COMMON_CLK)        += clk-fractional-divider.o
 
 # hardware specific clock types
 # please keep this section sorted lexicographically by file/directory path name
diff --git a/drivers/clk/clk-fractional-divider.c b/drivers/clk/clk-fractional-divider.c
new file mode 100644
index 000000000000..ede685ca0d20
--- /dev/null
+++ b/drivers/clk/clk-fractional-divider.c
@@ -0,0 +1,135 @@
+/*
+ * Copyright (C) 2014 Intel Corporation
+ *
+ * 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.
+ *
+ * Adjustable fractional divider clock implementation.
+ * Output rate = (m / n) * parent_rate.
+ */
+
+#include <linux/clk-provider.h>
+#include <linux/module.h>
+#include <linux/device.h>
+#include <linux/slab.h>
+#include <linux/gcd.h>
+
+#define to_clk_fd(_hw) container_of(_hw, struct clk_fractional_divider, hw)
+
+static unsigned long clk_fd_recalc_rate(struct clk_hw *hw,
+                                        unsigned long parent_rate)
+{
+        struct clk_fractional_divider *fd = to_clk_fd(hw);
+        unsigned long flags = 0;
+        u32 val, m, n;
+        u64 ret;
+
+        if (fd->lock)
+                spin_lock_irqsave(fd->lock, flags);
+
+        val = clk_readl(fd->reg);
+
+        if (fd->lock)
+                spin_unlock_irqrestore(fd->lock, flags);
+
+        m = (val & fd->mmask) >> fd->mshift;
+        n = (val & fd->nmask) >> fd->nshift;
+
+        ret = parent_rate * m;
+        do_div(ret, n);
+
+        return ret;
+}
+
+static long clk_fd_round_rate(struct clk_hw *hw, unsigned long rate,
+                              unsigned long *prate)
+{
+        struct clk_fractional_divider *fd = to_clk_fd(hw);
+        unsigned maxn = (fd->nmask >> fd->nshift) + 1;
+        unsigned div;
+
+        if (!rate || rate >= *prate)
+                return *prate;
+
+        div = gcd(*prate, rate);
+
+        while ((*prate / div) > maxn) {
+                div <<= 1;
+                rate <<= 1;
+        }
+
+        return rate;
+}
+
+static int clk_fd_set_rate(struct clk_hw *hw, unsigned long rate,
+                           unsigned long parent_rate)
+{
+        struct clk_fractional_divider *fd = to_clk_fd(hw);
+        unsigned long flags = 0;
+        unsigned long div;
+        unsigned n, m;
+        u32 val;
+
+        div = gcd(parent_rate, rate);
+        m = rate / div;
+        n = parent_rate / div;
+
+        if (fd->lock)
+                spin_lock_irqsave(fd->lock, flags);
+
+        val = clk_readl(fd->reg);
+        val &= ~(fd->mmask | fd->nmask);
+        val |= (m << fd->mshift) | (n << fd->nshift);
+        clk_writel(val, fd->reg);
+
+        if (fd->lock)
+                spin_unlock_irqrestore(fd->lock, flags);
+
+        return 0;
+}
+
+const struct clk_ops clk_fractional_divider_ops = {
+        .recalc_rate = clk_fd_recalc_rate,
+        .round_rate = clk_fd_round_rate,
+        .set_rate = clk_fd_set_rate,
+};
+EXPORT_SYMBOL_GPL(clk_fractional_divider_ops);
+
+struct clk *clk_register_fractional_divider(struct device *dev,
+                const char *name, const char *parent_name, unsigned long flags,
+                void __iomem *reg, u8 mshift, u8 mwidth, u8 nshift, u8 nwidth,
+                u8 clk_divider_flags, spinlock_t *lock)
+{
+        struct clk_fractional_divider *fd;
+        struct clk_init_data init;
+        struct clk *clk;
+
+        fd = kzalloc(sizeof(*fd), GFP_KERNEL);
+        if (!fd) {
+                dev_err(dev, "could not allocate fractional divider clk\n");
+                return ERR_PTR(-ENOMEM);
+        }
+
+        init.name = name;
+        init.ops = &clk_fractional_divider_ops;
+        init.flags = flags | CLK_IS_BASIC;
+        init.parent_names = parent_name ? &parent_name : NULL;
+        init.num_parents = parent_name ? 1 : 0;
+
+        fd->reg = reg;
+        fd->mshift = mshift;
+        fd->mmask = (BIT(mwidth) - 1) << mshift;
+        fd->nshift = nshift;
+        fd->nmask = (BIT(nwidth) - 1) << nshift;
+        fd->flags = clk_divider_flags;
+        fd->lock = lock;
+        fd->hw.init = &init;
+
+        clk = clk_register(dev, &fd->hw);
+        if (IS_ERR(clk))
+                kfree(fd);
+
+        return clk;
+}
+EXPORT_SYMBOL_GPL(clk_register_fractional_divider);
diff --git a/drivers/cpufreq/Kconfig.arm b/drivers/cpufreq/Kconfig.arm
index d2c7b4b8ffd5..36d20d0fce27 100644
--- a/drivers/cpufreq/Kconfig.arm
+++ b/drivers/cpufreq/Kconfig.arm
@@ -5,7 +5,8 @@
 # big LITTLE core layer and glue drivers
 config ARM_BIG_LITTLE_CPUFREQ
         tristate "Generic ARM big LITTLE CPUfreq driver"
-        depends on ARM && BIG_LITTLE && ARM_CPU_TOPOLOGY && HAVE_CLK
+        depends on (BIG_LITTLE && ARM_CPU_TOPOLOGY) || (ARM64 && SMP)
+        depends on HAVE_CLK
         select PM_OPP
         help
           This enables the Generic CPUfreq driver for ARM big.LITTLE platforms.
@@ -85,7 +86,7 @@ config ARM_EXYNOS_CPU_FREQ_BOOST_SW
           It allows usage of special frequencies for Samsung Exynos
           processors if thermal conditions are appropriate.
 
-          It reguires, for safe operation, thermal framework with properly
+          It requires, for safe operation, thermal framework with properly
           defined trip points.
 
           If in doubt, say N.
@@ -186,7 +187,7 @@ config ARM_S3C2416_CPUFREQ
           S3C2450 SoC. The S3C2416 supports changing the rate of the
           armdiv clock source and also entering a so called dynamic
           voltage scaling mode in which it is possible to reduce the
-          core voltage of the cpu.
+          core voltage of the CPU.
 
           If in doubt, say N.
 
diff --git a/drivers/cpufreq/Kconfig.x86 b/drivers/cpufreq/Kconfig.x86
index d369349eeaab..89ae88f91895 100644
--- a/drivers/cpufreq/Kconfig.x86
+++ b/drivers/cpufreq/Kconfig.x86
@@ -10,7 +10,7 @@ config X86_INTEL_PSTATE
           The driver implements an internal governor and will become
           the scaling driver and governor for Sandy bridge processors.
 
-          When this driver is enabled it will become the perferred
+          When this driver is enabled it will become the preferred
           scaling driver for Sandy bridge processors.
 
           If in doubt, say N.
@@ -52,7 +52,7 @@ config X86_ACPI_CPUFREQ_CPB
         help
           The powernow-k8 driver used to provide a sysfs knob called "cpb"
           to disable the Core Performance Boosting feature of AMD CPUs. This
-          file has now been superseeded by the more generic "boost" entry.
+          file has now been superseded by the more generic "boost" entry.
 
           By enabling this option the acpi_cpufreq driver provides the old
           entry in addition to the new boost ones, for compatibility reasons.
diff --git a/drivers/cpufreq/Makefile b/drivers/cpufreq/Makefile
index 0dbb963c1aef..738c8b7b17dc 100644
--- a/drivers/cpufreq/Makefile
+++ b/drivers/cpufreq/Makefile
@@ -1,5 +1,7 @@
 # CPUfreq core
 obj-$(CONFIG_CPU_FREQ)                  += cpufreq.o freq_table.o
+obj-$(CONFIG_PM_OPP)                    += cpufreq_opp.o
+
 # CPUfreq stats
 obj-$(CONFIG_CPU_FREQ_STAT)             += cpufreq_stats.o
 
diff --git a/drivers/cpufreq/acpi-cpufreq.c b/drivers/cpufreq/acpi-cpufreq.c
index 000e4e0afd7e..b0c18ed8d83f 100644
--- a/drivers/cpufreq/acpi-cpufreq.c
+++ b/drivers/cpufreq/acpi-cpufreq.c
@@ -213,7 +213,7 @@ static unsigned extract_io(u32 value, struct acpi_cpufreq_data *data)
 
 static unsigned extract_msr(u32 msr, struct acpi_cpufreq_data *data)
 {
-        int i;
+        struct cpufreq_frequency_table *pos;
         struct acpi_processor_performance *perf;
 
         if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD)
@@ -223,10 +223,9 @@ static unsigned extract_msr(u32 msr, struct acpi_cpufreq_data *data)
 
         perf = data->acpi_data;
 
-        for (i = 0; data->freq_table[i].frequency != CPUFREQ_TABLE_END; i++) {
-                if (msr == perf->states[data->freq_table[i].driver_data].status)
-                        return data->freq_table[i].frequency;
-        }
+        cpufreq_for_each_entry(pos, data->freq_table)
+                if (msr == perf->states[pos->driver_data].status)
+                        return pos->frequency;
         return data->freq_table[0].frequency;
 }
 
diff --git a/drivers/cpufreq/arm_big_little.c b/drivers/cpufreq/arm_big_little.c
index bad2ed317ba2..1f4d4e315057 100644
--- a/drivers/cpufreq/arm_big_little.c
+++ b/drivers/cpufreq/arm_big_little.c
@@ -226,22 +226,22 @@ static inline u32 get_table_count(struct cpufreq_frequency_table *table)
 /* get the minimum frequency in the cpufreq_frequency_table */
 static inline u32 get_table_min(struct cpufreq_frequency_table *table)
 {
-        int i;
+        struct cpufreq_frequency_table *pos;
         uint32_t min_freq = ~0;
-        for (i = 0; (table[i].frequency != CPUFREQ_TABLE_END); i++)
-                if (table[i].frequency < min_freq)
-                        min_freq = table[i].frequency;
+        cpufreq_for_each_entry(pos, table)
+                if (pos->frequency < min_freq)
+                        min_freq = pos->frequency;
         return min_freq;
 }
 
 /* get the maximum frequency in the cpufreq_frequency_table */
 static inline u32 get_table_max(struct cpufreq_frequency_table *table)
 {
-        int i;
+        struct cpufreq_frequency_table *pos;
         uint32_t max_freq = 0;
-        for (i = 0; (table[i].frequency != CPUFREQ_TABLE_END); i++)
-                if (table[i].frequency > max_freq)
-                        max_freq = table[i].frequency;
+        cpufreq_for_each_entry(pos, table)
+                if (pos->frequency > max_freq)
+                        max_freq = pos->frequency;
         return max_freq;
 }
 
diff --git a/drivers/cpufreq/cpufreq-nforce2.c b/drivers/cpufreq/cpufreq-nforce2.c
index bc447b9003c3..a2258090b58b 100644
--- a/drivers/cpufreq/cpufreq-nforce2.c
+++ b/drivers/cpufreq/cpufreq-nforce2.c
@@ -379,7 +379,7 @@ static struct cpufreq_driver nforce2_driver = {
 };
 
 #ifdef MODULE
-static DEFINE_PCI_DEVICE_TABLE(nforce2_ids) = {
+static const struct pci_device_id nforce2_ids[] = {
         { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE2 },
         {}
 };
diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
index abda6609d3e7..ae11dd51f81d 100644
--- a/drivers/cpufreq/cpufreq.c
+++ b/drivers/cpufreq/cpufreq.c
@@ -354,6 +354,18 @@ static void cpufreq_notify_post_transition(struct cpufreq_policy *policy,
 void cpufreq_freq_transition_begin(struct cpufreq_policy *policy,
                 struct cpufreq_freqs *freqs)
 {
+
+        /*
+         * Catch double invocations of _begin() which lead to self-deadlock.
+         * ASYNC_NOTIFICATION drivers are left out because the cpufreq core
+         * doesn't invoke _begin() on their behalf, and hence the chances of
+         * double invocations are very low. Moreover, there are scenarios
+         * where these checks can emit false-positive warnings in these
+         * drivers; so we avoid that by skipping them altogether.
+         */
+        WARN_ON(!(cpufreq_driver->flags & CPUFREQ_ASYNC_NOTIFICATION)
+                                && current == policy->transition_task);
+
 wait:
         wait_event(policy->transition_wait, !policy->transition_ongoing);
 
@@ -365,6 +377,7 @@ wait:
         }
 
         policy->transition_ongoing = true;
+        policy->transition_task = current;
 
         spin_unlock(&policy->transition_lock);
 
@@ -381,6 +394,7 @@ void cpufreq_freq_transition_end(struct cpufreq_policy *policy,
         cpufreq_notify_post_transition(policy, freqs, transition_failed);
 
         policy->transition_ongoing = false;
+        policy->transition_task = NULL;
 
         wake_up(&policy->transition_wait);
 }
@@ -1802,12 +1816,43 @@ EXPORT_SYMBOL(cpufreq_unregister_notifier);
  *                              GOVERNORS                            *
  *********************************************************************/
 
+static int __target_index(struct cpufreq_policy *policy,
+                          struct cpufreq_frequency_table *freq_table, int index)
+{
+        struct cpufreq_freqs freqs;
+        int retval = -EINVAL;
+        bool notify;
+
+        notify = !(cpufreq_driver->flags & CPUFREQ_ASYNC_NOTIFICATION);
+
+        if (notify) {
+                freqs.old = policy->cur;
+                freqs.new = freq_table[index].frequency;
+                freqs.flags = 0;
+
+                pr_debug("%s: cpu: %d, oldfreq: %u, new freq: %u\n",
+                         __func__, policy->cpu, freqs.old, freqs.new);
+
+                cpufreq_freq_transition_begin(policy, &freqs);
+        }
+
+        retval = cpufreq_driver->target_index(policy, index);
+        if (retval)
+                pr_err("%s: Failed to change cpu frequency: %d\n", __func__,
+                       retval);
+
+        if (notify)
+                cpufreq_freq_transition_end(policy, &freqs, retval);
+
+        return retval;
+}
+
 int __cpufreq_driver_target(struct cpufreq_policy *policy,
                             unsigned int target_freq,
                             unsigned int relation)
 {
-        int retval = -EINVAL;
         unsigned int old_target_freq = target_freq;
+        int retval = -EINVAL;
 
         if (cpufreq_disabled())
                 return -ENODEV;
@@ -1834,8 +1879,6 @@ int __cpufreq_driver_target(struct cpufreq_policy *policy,
                 retval = cpufreq_driver->target(policy, target_freq, relation);
         else if (cpufreq_driver->target_index) {
                 struct cpufreq_frequency_table *freq_table;
-                struct cpufreq_freqs freqs;
-                bool notify;
                 int index;
 
                 freq_table = cpufreq_frequency_get_table(policy->cpu);
@@ -1856,26 +1899,7 @@ int __cpufreq_driver_target(struct cpufreq_policy *policy,
                         goto out;
                 }
 
-                notify = !(cpufreq_driver->flags & CPUFREQ_ASYNC_NOTIFICATION);
-
-                if (notify) {
-                        freqs.old = policy->cur;
-                        freqs.new = freq_table[index].frequency;
-                        freqs.flags = 0;
-
-                        pr_debug("%s: cpu: %d, oldfreq: %u, new freq: %u\n",
-                                 __func__, policy->cpu, freqs.old, freqs.new);
-
-                        cpufreq_freq_transition_begin(policy, &freqs);
-                }
-
-                retval = cpufreq_driver->target_index(policy, index);
-                if (retval)
-                        pr_err("%s: Failed to change cpu frequency: %d\n",
-                               __func__, retval);
-
-                if (notify)
-                        cpufreq_freq_transition_end(policy, &freqs, retval);
+                retval = __target_index(policy, freq_table, index);
         }
 
 out:
diff --git a/drivers/cpufreq/cpufreq_opp.c b/drivers/cpufreq/cpufreq_opp.c
new file mode 100644
index 000000000000..c0c6f4a4eccf
--- /dev/null
+++ b/drivers/cpufreq/cpufreq_opp.c
@@ -0,0 +1,110 @@
+/*
+ * Generic OPP helper interface for CPUFreq drivers
+ *
+ * Copyright (C) 2009-2014 Texas Instruments Incorporated.
+ *      Nishanth Menon
+ *      Romit Dasgupta
+ *      Kevin Hilman
+ *
+ * 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/cpufreq.h>
+#include <linux/device.h>
+#include <linux/err.h>
+#include <linux/errno.h>
+#include <linux/export.h>
+#include <linux/kernel.h>
+#include <linux/pm_opp.h>
+#include <linux/rcupdate.h>
+#include <linux/slab.h>
+
+/**
+ * dev_pm_opp_init_cpufreq_table() - create a cpufreq table for a device
+ * @dev:        device for which we do this operation
+ * @table:      Cpufreq table returned back to caller
+ *
+ * Generate a cpufreq table for a provided device- this assumes that the
+ * opp list is already initialized and ready for usage.
+ *
+ * This function allocates required memory for the cpufreq table. It is
+ * expected that the caller does the required maintenance such as freeing
+ * the table as required.
+ *
+ * Returns -EINVAL for bad pointers, -ENODEV if the device is not found, -ENOMEM
+ * if no memory available for the operation (table is not populated), returns 0
+ * if successful and table is populated.
+ *
+ * WARNING: It is  important for the callers to ensure refreshing their copy of
+ * the table if any of the mentioned functions have been invoked in the interim.
+ *
+ * Locking: The internal device_opp and opp structures are RCU protected.
+ * Since we just use the regular accessor functions to access the internal data
+ * structures, we use RCU read lock inside this function. As a result, users of
+ * this function DONOT need to use explicit locks for invoking.
+ */
+int dev_pm_opp_init_cpufreq_table(struct device *dev,
+                                  struct cpufreq_frequency_table **table)
+{
+        struct dev_pm_opp *opp;
+        struct cpufreq_frequency_table *freq_table = NULL;
+        int i, max_opps, ret = 0;
+        unsigned long rate;
+
+        rcu_read_lock();
+
+        max_opps = dev_pm_opp_get_opp_count(dev);
+        if (max_opps <= 0) {
+                ret = max_opps ? max_opps : -ENODATA;
+                goto out;
+        }
+
+        freq_table = kzalloc(sizeof(*freq_table) * (max_opps + 1), GFP_KERNEL);
+        if (!freq_table) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        for (i = 0, rate = 0; i < max_opps; i++, rate++) {
+                /* find next rate */
+                opp = dev_pm_opp_find_freq_ceil(dev, &rate);
+                if (IS_ERR(opp)) {
+                        ret = PTR_ERR(opp);
+                        goto out;
+                }
+                freq_table[i].driver_data = i;
+                freq_table[i].frequency = rate / 1000;
+        }
+
+        freq_table[i].driver_data = i;
+        freq_table[i].frequency = CPUFREQ_TABLE_END;
+
+        *table = &freq_table[0];
+
+out:
+        rcu_read_unlock();
+        if (ret)
+                kfree(freq_table);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(dev_pm_opp_init_cpufreq_table);
+
+/**
+ * dev_pm_opp_free_cpufreq_table() - free the cpufreq table
+ * @dev:        device for which we do this operation
+ * @table:      table to free
+ *
+ * Free up the table allocated by dev_pm_opp_init_cpufreq_table
+ */
+void dev_pm_opp_free_cpufreq_table(struct device *dev,
+                                   struct cpufreq_frequency_table **table)
+{
+        if (!table)
+                return;
+
+        kfree(*table);
+        *table = NULL;
+}
+EXPORT_SYMBOL_GPL(dev_pm_opp_free_cpufreq_table);
diff --git a/drivers/cpufreq/cpufreq_stats.c b/drivers/cpufreq/cpufreq_stats.c
index ecaaebf969fc..0cd9b4dcef99 100644
--- a/drivers/cpufreq/cpufreq_stats.c
+++ b/drivers/cpufreq/cpufreq_stats.c
@@ -182,11 +182,11 @@ static void cpufreq_stats_free_table(unsigned int cpu)
 
 static int __cpufreq_stats_create_table(struct cpufreq_policy *policy)
 {
-        unsigned int i, j, count = 0, ret = 0;
+        unsigned int i, count = 0, ret = 0;
         struct cpufreq_stats *stat;
         unsigned int alloc_size;
         unsigned int cpu = policy->cpu;
-        struct cpufreq_frequency_table *table;
+        struct cpufreq_frequency_table *pos, *table;
 
         table = cpufreq_frequency_get_table(cpu);
         if (unlikely(!table))
@@ -205,12 +205,8 @@ static int __cpufreq_stats_create_table(struct cpufreq_policy *policy)
         stat->cpu = cpu;
         per_cpu(cpufreq_stats_table, cpu) = stat;
 
-        for (i = 0; table[i].frequency != CPUFREQ_TABLE_END; i++) {
-                unsigned int freq = table[i].frequency;
-                if (freq == CPUFREQ_ENTRY_INVALID)
-                        continue;
+        cpufreq_for_each_valid_entry(pos, table)
                 count++;
-        }
 
         alloc_size = count * sizeof(int) + count * sizeof(u64);
 
@@ -228,15 +224,11 @@ static int __cpufreq_stats_create_table(struct cpufreq_policy *policy)
 #ifdef CONFIG_CPU_FREQ_STAT_DETAILS
         stat->trans_table = stat->freq_table + count;
 #endif
-        j = 0;
-        for (i = 0; table[i].frequency != CPUFREQ_TABLE_END; i++) {
-                unsigned int freq = table[i].frequency;
-                if (freq == CPUFREQ_ENTRY_INVALID)
-                        continue;
-                if (freq_table_get_index(stat, freq) == -1)
-                        stat->freq_table[j++] = freq;
-        }
-        stat->state_num = j;
+        i = 0;
+        cpufreq_for_each_valid_entry(pos, table)
+                if (freq_table_get_index(stat, pos->frequency) == -1)
+                        stat->freq_table[i++] = pos->frequency;
+        stat->state_num = i;
         spin_lock(&cpufreq_stats_lock);
         stat->last_time = get_jiffies_64();
         stat->last_index = freq_table_get_index(stat, policy->cur);
diff --git a/drivers/cpufreq/dbx500-cpufreq.c b/drivers/cpufreq/dbx500-cpufreq.c
index 412a78bb0c94..4bebc1b5db48 100644
--- a/drivers/cpufreq/dbx500-cpufreq.c
+++ b/drivers/cpufreq/dbx500-cpufreq.c
@@ -45,7 +45,7 @@ static struct cpufreq_driver dbx500_cpufreq_driver = {
 
 static int dbx500_cpufreq_probe(struct platform_device *pdev)
 {
-        int i = 0;
+        struct cpufreq_frequency_table *pos;
 
         freq_table = dev_get_platdata(&pdev->dev);
         if (!freq_table) {
@@ -60,10 +60,8 @@ static int dbx500_cpufreq_probe(struct platform_device *pdev)
         }
 
         pr_info("dbx500-cpufreq: Available frequencies:\n");
-        while (freq_table[i].frequency != CPUFREQ_TABLE_END) {
-                pr_info("  %d Mhz\n", freq_table[i].frequency/1000);
-                i++;
-        }
+        cpufreq_for_each_entry(pos, freq_table)
+                pr_info("  %d Mhz\n", pos->frequency / 1000);
 
         return cpufreq_register_driver(&dbx500_cpufreq_driver);
 }
diff --git a/drivers/cpufreq/elanfreq.c b/drivers/cpufreq/elanfreq.c
index 7f5d2a68c353..1c06e786c9ba 100644
--- a/drivers/cpufreq/elanfreq.c
+++ b/drivers/cpufreq/elanfreq.c
@@ -147,7 +147,7 @@ static int elanfreq_target(struct cpufreq_policy *policy,
 static int elanfreq_cpu_init(struct cpufreq_policy *policy)
 {
         struct cpuinfo_x86 *c = &cpu_data(0);
-        unsigned int i;
+        struct cpufreq_frequency_table *pos;
 
         /* capability check */
         if ((c->x86_vendor != X86_VENDOR_AMD) ||
@@ -159,10 +159,9 @@ static int elanfreq_cpu_init(struct cpufreq_policy *policy)
                 max_freq = elanfreq_get_cpu_frequency(0);
 
         /* table init */
-        for (i = 0; (elanfreq_table[i].frequency != CPUFREQ_TABLE_END); i++) {
-                if (elanfreq_table[i].frequency > max_freq)
-                        elanfreq_table[i].frequency = CPUFREQ_ENTRY_INVALID;
-        }
+        cpufreq_for_each_entry(pos, elanfreq_table)
+                if (pos->frequency > max_freq)
+                        pos->frequency = CPUFREQ_ENTRY_INVALID;
 
         /* cpuinfo and default policy values */
         policy->cpuinfo.transition_latency = CPUFREQ_ETERNAL;
diff --git a/drivers/cpufreq/exynos-cpufreq.c b/drivers/cpufreq/exynos-cpufreq.c
index 348c8bafe436..1e0ec57bf6e3 100644
--- a/drivers/cpufreq/exynos-cpufreq.c
+++ b/drivers/cpufreq/exynos-cpufreq.c
@@ -28,17 +28,16 @@ static unsigned int locking_frequency;
 static int exynos_cpufreq_get_index(unsigned int freq)
 {
         struct cpufreq_frequency_table *freq_table = exynos_info->freq_table;
-        int index;
+        struct cpufreq_frequency_table *pos;
 
-        for (index = 0;
-                freq_table[index].frequency != CPUFREQ_TABLE_END; index++)
-                if (freq_table[index].frequency == freq)
+        cpufreq_for_each_entry(pos, freq_table)
+                if (pos->frequency == freq)
                         break;
 
-        if (freq_table[index].frequency == CPUFREQ_TABLE_END)
+        if (pos->frequency == CPUFREQ_TABLE_END)
                 return -EINVAL;
 
-        return index;
+        return pos - freq_table;
 }
 
 static int exynos_cpufreq_scale(unsigned int target_freq)
@@ -48,6 +47,7 @@ static int exynos_cpufreq_scale(unsigned int target_freq)
         struct cpufreq_policy *policy = cpufreq_cpu_get(0);
         unsigned int arm_volt, safe_arm_volt = 0;
         unsigned int mpll_freq_khz = exynos_info->mpll_freq_khz;
+        struct device *dev = exynos_info->dev;
         unsigned int old_freq;
         int index, old_index;
         int ret = 0;
@@ -89,8 +89,8 @@ static int exynos_cpufreq_scale(unsigned int target_freq)
                 /* Firstly, voltage up to increase frequency */
                 ret = regulator_set_voltage(arm_regulator, arm_volt, arm_volt);
                 if (ret) {
-                        pr_err("%s: failed to set cpu voltage to %d\n",
-                                __func__, arm_volt);
+                        dev_err(dev, "failed to set cpu voltage to %d\n",
+                                arm_volt);
                         return ret;
                 }
         }
@@ -99,8 +99,8 @@ static int exynos_cpufreq_scale(unsigned int target_freq)
                 ret = regulator_set_voltage(arm_regulator, safe_arm_volt,
                                       safe_arm_volt);
                 if (ret) {
-                        pr_err("%s: failed to set cpu voltage to %d\n",
-                                __func__, safe_arm_volt);
+                        dev_err(dev, "failed to set cpu voltage to %d\n",
+                                safe_arm_volt);
                         return ret;
                 }
         }
@@ -114,8 +114,8 @@ static int exynos_cpufreq_scale(unsigned int target_freq)
                 ret = regulator_set_voltage(arm_regulator, arm_volt,
                                 arm_volt);
                 if (ret) {
-                        pr_err("%s: failed to set cpu voltage to %d\n",
-                                __func__, arm_volt);
+                        dev_err(dev, "failed to set cpu voltage to %d\n",
+                                arm_volt);
                         goto out;
                 }
         }
@@ -162,6 +162,8 @@ static int exynos_cpufreq_probe(struct platform_device *pdev)
         if (!exynos_info)
                 return -ENOMEM;
 
+        exynos_info->dev = &pdev->dev;
+
         if (of_machine_is_compatible("samsung,exynos4210")) {
                 exynos_info->type = EXYNOS_SOC_4210;
                 ret = exynos4210_cpufreq_init(exynos_info);
@@ -183,13 +185,13 @@ static int exynos_cpufreq_probe(struct platform_device *pdev)
                 goto err_vdd_arm;
 
         if (exynos_info->set_freq == NULL) {
-                pr_err("%s: No set_freq function (ERR)\n", __func__);
+                dev_err(&pdev->dev, "No set_freq function (ERR)\n");
                 goto err_vdd_arm;
         }
 
         arm_regulator = regulator_get(NULL, "vdd_arm");
         if (IS_ERR(arm_regulator)) {
-                pr_err("%s: failed to get resource vdd_arm\n", __func__);
+                dev_err(&pdev->dev, "failed to get resource vdd_arm\n");
                 goto err_vdd_arm;
         }
 
@@ -199,7 +201,7 @@ static int exynos_cpufreq_probe(struct platform_device *pdev)
         if (!cpufreq_register_driver(&exynos_driver))
                 return 0;
 
-        pr_err("%s: failed to register cpufreq driver\n", __func__);
+        dev_err(&pdev->dev, "failed to register cpufreq driver\n");
         regulator_put(arm_regulator);
 err_vdd_arm:
         kfree(exynos_info);
diff --git a/drivers/cpufreq/exynos-cpufreq.h b/drivers/cpufreq/exynos-cpufreq.h
index 51af42e1b7fe..9f2062a7cc02 100644
--- a/drivers/cpufreq/exynos-cpufreq.h
+++ b/drivers/cpufreq/exynos-cpufreq.h
@@ -42,6 +42,7 @@ struct apll_freq {
 
 struct exynos_dvfs_info {
         enum exynos_soc_type type;
+        struct device   *dev;
         unsigned long   mpll_freq_khz;
         unsigned int    pll_safe_idx;
         struct clk      *cpu_clk;
diff --git a/drivers/cpufreq/exynos5440-cpufreq.c b/drivers/cpufreq/exynos5440-cpufreq.c
index a6b8214d7b77..f33f25b483ca 100644
--- a/drivers/cpufreq/exynos5440-cpufreq.c
+++ b/drivers/cpufreq/exynos5440-cpufreq.c
@@ -114,25 +114,23 @@ static struct cpufreq_freqs freqs;
 
 static int init_div_table(void)
 {
-        struct cpufreq_frequency_table *freq_tbl = dvfs_info->freq_table;
+        struct cpufreq_frequency_table *pos, *freq_tbl = dvfs_info->freq_table;
         unsigned int tmp, clk_div, ema_div, freq, volt_id;
-        int i = 0;
         struct dev_pm_opp *opp;
 
         rcu_read_lock();
-        for (i = 0; freq_tbl[i].frequency != CPUFREQ_TABLE_END; i++) {
-
+        cpufreq_for_each_entry(pos, freq_tbl) {
                 opp = dev_pm_opp_find_freq_exact(dvfs_info->dev,
-                                        freq_tbl[i].frequency * 1000, true);
+                                        pos->frequency * 1000, true);
                 if (IS_ERR(opp)) {
                         rcu_read_unlock();
                         dev_err(dvfs_info->dev,
                                 "failed to find valid OPP for %u KHZ\n",
-                                freq_tbl[i].frequency);
+                                pos->frequency);
                         return PTR_ERR(opp);
                 }
 
-                freq = freq_tbl[i].frequency / 1000; /* In MHZ */
+                freq = pos->frequency / 1000; /* In MHZ */
                 clk_div = ((freq / CPU_DIV_FREQ_MAX) & P0_7_CPUCLKDEV_MASK)
                                         << P0_7_CPUCLKDEV_SHIFT;
                 clk_div |= ((freq / CPU_ATB_FREQ_MAX) & P0_7_ATBCLKDEV_MASK)
@@ -157,7 +155,8 @@ static int init_div_table(void)
                 tmp = (clk_div | ema_div | (volt_id << P0_7_VDD_SHIFT)
                         | ((freq / FREQ_UNIT) << P0_7_FREQ_SHIFT));
 
-                __raw_writel(tmp, dvfs_info->base + XMU_PMU_P0_7 + 4 * i);
+                __raw_writel(tmp, dvfs_info->base + XMU_PMU_P0_7 + 4 *
+                                                (pos - freq_tbl));
         }
 
         rcu_read_unlock();
@@ -166,8 +165,9 @@ static int init_div_table(void)
 
 static void exynos_enable_dvfs(unsigned int cur_frequency)
 {
-        unsigned int tmp, i, cpu;
+        unsigned int tmp, cpu;
         struct cpufreq_frequency_table *freq_table = dvfs_info->freq_table;
+        struct cpufreq_frequency_table *pos;
         /* Disable DVFS */
         __raw_writel(0, dvfs_info->base + XMU_DVFS_CTRL);
 
@@ -182,15 +182,15 @@ static void exynos_enable_dvfs(unsigned int cur_frequency)
          __raw_writel(tmp, dvfs_info->base + XMU_PMUIRQEN);
 
         /* Set initial performance index */
-        for (i = 0; freq_table[i].frequency != CPUFREQ_TABLE_END; i++)
-                if (freq_table[i].frequency == cur_frequency)
+        cpufreq_for_each_entry(pos, freq_table)
+                if (pos->frequency == cur_frequency)
                         break;
 
-        if (freq_table[i].frequency == CPUFREQ_TABLE_END) {
+        if (pos->frequency == CPUFREQ_TABLE_END) {
                 dev_crit(dvfs_info->dev, "Boot up frequency not supported\n");
                 /* Assign the highest frequency */
-                i = 0;
-                cur_frequency = freq_table[i].frequency;
+                pos = freq_table;
+                cur_frequency = pos->frequency;
         }
 
         dev_info(dvfs_info->dev, "Setting dvfs initial frequency = %uKHZ",
@@ -199,7 +199,7 @@ static void exynos_enable_dvfs(unsigned int cur_frequency)
         for (cpu = 0; cpu < CONFIG_NR_CPUS; cpu++) {
                 tmp = __raw_readl(dvfs_info->base + XMU_C0_3_PSTATE + cpu * 4);
                 tmp &= ~(P_VALUE_MASK << C0_3_PSTATE_NEW_SHIFT);
-                tmp |= (i << C0_3_PSTATE_NEW_SHIFT);
+                tmp |= ((pos - freq_table) << C0_3_PSTATE_NEW_SHIFT);
                 __raw_writel(tmp, dvfs_info->base + XMU_C0_3_PSTATE + cpu * 4);
         }
 
diff --git a/drivers/cpufreq/freq_table.c b/drivers/cpufreq/freq_table.c
index 08e7bbcf6d73..1632981c4b25 100644
--- a/drivers/cpufreq/freq_table.c
+++ b/drivers/cpufreq/freq_table.c
@@ -21,22 +21,19 @@
 int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy,
                                     struct cpufreq_frequency_table *table)
 {
+        struct cpufreq_frequency_table *pos;
         unsigned int min_freq = ~0;
         unsigned int max_freq = 0;
-        unsigned int i;
+        unsigned int freq;
 
-        for (i = 0; (table[i].frequency != CPUFREQ_TABLE_END); i++) {
-                unsigned int freq = table[i].frequency;
-                if (freq == CPUFREQ_ENTRY_INVALID) {
-                        pr_debug("table entry %u is invalid, skipping\n", i);
+        cpufreq_for_each_valid_entry(pos, table) {
+                freq = pos->frequency;
 
-                        continue;
-                }
                 if (!cpufreq_boost_enabled()
-                    && (table[i].flags & CPUFREQ_BOOST_FREQ))
+                    && (pos->flags & CPUFREQ_BOOST_FREQ))
                         continue;
 
-                pr_debug("table entry %u: %u kHz\n", i, freq);
+                pr_debug("table entry %u: %u kHz\n", (int)(pos - table), freq);
                 if (freq < min_freq)
                         min_freq = freq;
                 if (freq > max_freq)
@@ -57,7 +54,8 @@ EXPORT_SYMBOL_GPL(cpufreq_frequency_table_cpuinfo);
 int cpufreq_frequency_table_verify(struct cpufreq_policy *policy,
                                    struct cpufreq_frequency_table *table)
 {
-        unsigned int next_larger = ~0, freq, i = 0;
+        struct cpufreq_frequency_table *pos;
+        unsigned int freq, next_larger = ~0;
         bool found = false;
 
         pr_debug("request for verification of policy (%u - %u kHz) for cpu %u\n",
@@ -65,9 +63,9 @@ int cpufreq_frequency_table_verify(struct cpufreq_policy *policy,
 
         cpufreq_verify_within_cpu_limits(policy);
 
-        for (; freq = table[i].frequency, freq != CPUFREQ_TABLE_END; i++) {
-                if (freq == CPUFREQ_ENTRY_INVALID)
-                        continue;
+        cpufreq_for_each_valid_entry(pos, table) {
+                freq = pos->frequency;
+
                 if ((freq >= policy->min) && (freq <= policy->max)) {
                         found = true;
                         break;
@@ -118,7 +116,8 @@ int cpufreq_frequency_table_target(struct cpufreq_policy *policy,
                 .driver_data = ~0,
                 .frequency = 0,
         };
-        unsigned int i;
+        struct cpufreq_frequency_table *pos;
+        unsigned int freq, i = 0;
 
         pr_debug("request for target %u kHz (relation: %u) for cpu %u\n",
                                         target_freq, relation, policy->cpu);
@@ -132,15 +131,19 @@ int cpufreq_frequency_table_target(struct cpufreq_policy *policy,
                 break;
         }
 
-        for (i = 0; (table[i].frequency != CPUFREQ_TABLE_END); i++) {
-                unsigned int freq = table[i].frequency;
-                if (freq == CPUFREQ_ENTRY_INVALID)
-                        continue;
+        cpufreq_for_each_valid_entry(pos, table) {
+                freq = pos->frequency;
+
+                i = pos - table;
                 if ((freq < policy->min) || (freq > policy->max))
                         continue;
+                if (freq == target_freq) {
+                        optimal.driver_data = i;
+                        break;
+                }
                 switch (relation) {
                 case CPUFREQ_RELATION_H:
-                        if (freq <= target_freq) {
+                        if (freq < target_freq) {
                                 if (freq >= optimal.frequency) {
                                         optimal.frequency = freq;
                                         optimal.driver_data = i;
@@ -153,7 +156,7 @@ int cpufreq_frequency_table_target(struct cpufreq_policy *policy,
                         }
                         break;
                 case CPUFREQ_RELATION_L:
-                        if (freq >= target_freq) {
+                        if (freq > target_freq) {
                                 if (freq <= optimal.frequency) {
                                         optimal.frequency = freq;
                                         optimal.driver_data = i;
@@ -184,8 +187,7 @@ EXPORT_SYMBOL_GPL(cpufreq_frequency_table_target);
 int cpufreq_frequency_table_get_index(struct cpufreq_policy *policy,
                 unsigned int freq)
 {
-        struct cpufreq_frequency_table *table;
-        int i;
+        struct cpufreq_frequency_table *pos, *table;
 
         table = cpufreq_frequency_get_table(policy->cpu);
         if (unlikely(!table)) {
@@ -193,10 +195,9 @@ int cpufreq_frequency_table_get_index(struct cpufreq_policy *policy,
                 return -ENOENT;
         }
 
-        for (i = 0; table[i].frequency != CPUFREQ_TABLE_END; i++) {
-                if (table[i].frequency == freq)
-                        return i;
-        }
+        cpufreq_for_each_valid_entry(pos, table)
+                if (pos->frequency == freq)
+                        return pos - table;
 
         return -EINVAL;
 }
@@ -208,16 +209,13 @@ EXPORT_SYMBOL_GPL(cpufreq_frequency_table_get_index);
 static ssize_t show_available_freqs(struct cpufreq_policy *policy, char *buf,
                                     bool show_boost)
 {
-        unsigned int i = 0;
         ssize_t count = 0;
-        struct cpufreq_frequency_table *table = policy->freq_table;
+        struct cpufreq_frequency_table *pos, *table = policy->freq_table;
 
         if (!table)
                 return -ENODEV;
 
-        for (i = 0; (table[i].frequency != CPUFREQ_TABLE_END); i++) {
-                if (table[i].frequency == CPUFREQ_ENTRY_INVALID)
-                        continue;
+        cpufreq_for_each_valid_entry(pos, table) {
                 /*
                  * show_boost = true and driver_data = BOOST freq
                  * display BOOST freqs
@@ -229,10 +227,10 @@ static ssize_t show_available_freqs(struct cpufreq_policy *policy, char *buf,
                  * show_boost = false and driver_data != BOOST freq
                  * display NON BOOST freqs
                  */
-                if (show_boost ^ (table[i].flags & CPUFREQ_BOOST_FREQ))
+                if (show_boost ^ (pos->flags & CPUFREQ_BOOST_FREQ))
                         continue;
 
-                count += sprintf(&buf[count], "%d ", table[i].frequency);
+                count += sprintf(&buf[count], "%d ", pos->frequency);
         }
         count += sprintf(&buf[count], "\n");
 
diff --git a/drivers/cpufreq/imx6q-cpufreq.c b/drivers/cpufreq/imx6q-cpufreq.c
index e27fca86fe4f..af366c21d4b4 100644
--- a/drivers/cpufreq/imx6q-cpufreq.c
+++ b/drivers/cpufreq/imx6q-cpufreq.c
@@ -9,7 +9,6 @@
 #include <linux/clk.h>
 #include <linux/cpu.h>
 #include <linux/cpufreq.h>
-#include <linux/delay.h>
 #include <linux/err.h>
 #include <linux/module.h>
 #include <linux/of.h>
@@ -170,25 +169,25 @@ static int imx6q_cpufreq_probe(struct platform_device *pdev)
                 return -ENOENT;
         }
 
-        arm_clk = devm_clk_get(cpu_dev, "arm");
-        pll1_sys_clk = devm_clk_get(cpu_dev, "pll1_sys");
-        pll1_sw_clk = devm_clk_get(cpu_dev, "pll1_sw");
-        step_clk = devm_clk_get(cpu_dev, "step");
-        pll2_pfd2_396m_clk = devm_clk_get(cpu_dev, "pll2_pfd2_396m");
+        arm_clk = clk_get(cpu_dev, "arm");
+        pll1_sys_clk = clk_get(cpu_dev, "pll1_sys");
+        pll1_sw_clk = clk_get(cpu_dev, "pll1_sw");
+        step_clk = clk_get(cpu_dev, "step");
+        pll2_pfd2_396m_clk = clk_get(cpu_dev, "pll2_pfd2_396m");
         if (IS_ERR(arm_clk) || IS_ERR(pll1_sys_clk) || IS_ERR(pll1_sw_clk) ||
             IS_ERR(step_clk) || IS_ERR(pll2_pfd2_396m_clk)) {
                 dev_err(cpu_dev, "failed to get clocks\n");
                 ret = -ENOENT;
-                goto put_node;
+                goto put_clk;
         }
 
-        arm_reg = devm_regulator_get(cpu_dev, "arm");
-        pu_reg = devm_regulator_get(cpu_dev, "pu");
-        soc_reg = devm_regulator_get(cpu_dev, "soc");
+        arm_reg = regulator_get(cpu_dev, "arm");
+        pu_reg = regulator_get(cpu_dev, "pu");
+        soc_reg = regulator_get(cpu_dev, "soc");
         if (IS_ERR(arm_reg) || IS_ERR(pu_reg) || IS_ERR(soc_reg)) {
                 dev_err(cpu_dev, "failed to get regulators\n");
                 ret = -ENOENT;
-                goto put_node;
+                goto put_reg;
         }
 
         /*
@@ -201,21 +200,21 @@ static int imx6q_cpufreq_probe(struct platform_device *pdev)
                 ret = of_init_opp_table(cpu_dev);
                 if (ret < 0) {
                         dev_err(cpu_dev, "failed to init OPP table: %d\n", ret);
-                        goto put_node;
+                        goto put_reg;
                 }
 
                 num = dev_pm_opp_get_opp_count(cpu_dev);
                 if (num < 0) {
                         ret = num;
                         dev_err(cpu_dev, "no OPP table is found: %d\n", ret);
-                        goto put_node;
+                        goto put_reg;
                 }
         }
 
         ret = dev_pm_opp_init_cpufreq_table(cpu_dev, &freq_table);
         if (ret) {
                 dev_err(cpu_dev, "failed to init cpufreq table: %d\n", ret);
-                goto put_node;
+                goto put_reg;
         }
 
         /* Make imx6_soc_volt array's size same as arm opp number */
@@ -301,7 +300,24 @@ soc_opp_out:
 
 free_freq_table:
         dev_pm_opp_free_cpufreq_table(cpu_dev, &freq_table);
-put_node:
+put_reg:
+        if (!IS_ERR(arm_reg))
+                regulator_put(arm_reg);
+        if (!IS_ERR(pu_reg))
+                regulator_put(pu_reg);
+        if (!IS_ERR(soc_reg))
+                regulator_put(soc_reg);
+put_clk:
+        if (!IS_ERR(arm_clk))
+                clk_put(arm_clk);
+        if (!IS_ERR(pll1_sys_clk))
+                clk_put(pll1_sys_clk);
+        if (!IS_ERR(pll1_sw_clk))
+                clk_put(pll1_sw_clk);
+        if (!IS_ERR(step_clk))
+                clk_put(step_clk);
+        if (!IS_ERR(pll2_pfd2_396m_clk))
+                clk_put(pll2_pfd2_396m_clk);
         of_node_put(np);
         return ret;
 }
@@ -310,6 +326,14 @@ static int imx6q_cpufreq_remove(struct platform_device *pdev)
 {
         cpufreq_unregister_driver(&imx6q_cpufreq_driver);
         dev_pm_opp_free_cpufreq_table(cpu_dev, &freq_table);
+        regulator_put(arm_reg);
+        regulator_put(pu_reg);
+        regulator_put(soc_reg);
+        clk_put(arm_clk);
+        clk_put(pll1_sys_clk);
+        clk_put(pll1_sw_clk);
+        clk_put(step_clk);
+        clk_put(pll2_pfd2_396m_clk);
 
         return 0;
 }
diff --git a/drivers/cpufreq/intel_pstate.c b/drivers/cpufreq/intel_pstate.c
index eab8ccfe6beb..aebd4572eb6d 100644
--- a/drivers/cpufreq/intel_pstate.c
+++ b/drivers/cpufreq/intel_pstate.c
@@ -32,18 +32,16 @@
 #include <asm/msr.h>
 #include <asm/cpu_device_id.h>
 
-#define SAMPLE_COUNT            3
-
 #define BYT_RATIOS              0x66a
 #define BYT_VIDS                0x66b
 #define BYT_TURBO_RATIOS        0x66c
 #define BYT_TURBO_VIDS          0x66d
 
 
-#define FRAC_BITS 6
+#define FRAC_BITS 8
 #define int_tofp(X) ((int64_t)(X) << FRAC_BITS)
 #define fp_toint(X) ((X) >> FRAC_BITS)
-#define FP_ROUNDUP(X) ((X) += 1 << FRAC_BITS)
+
 
 static inline int32_t mul_fp(int32_t x, int32_t y)
 {
@@ -59,8 +57,8 @@ struct sample {
         int32_t core_pct_busy;
         u64 aperf;
         u64 mperf;
-        unsigned long long tsc;
         int freq;
+        ktime_t time;
 };
 
 struct pstate_data {
@@ -90,17 +88,15 @@ struct _pid {
 struct cpudata {
         int cpu;
 
-        char name[64];
-
         struct timer_list timer;
 
         struct pstate_data pstate;
         struct vid_data vid;
         struct _pid pid;
 
+        ktime_t last_sample_time;
         u64     prev_aperf;
         u64     prev_mperf;
-        unsigned long long prev_tsc;
         struct sample sample;
 };
 
@@ -200,7 +196,10 @@ static signed int pid_calc(struct _pid *pid, int32_t busy)
         pid->last_err = fp_error;
 
         result = pterm + mul_fp(pid->integral, pid->i_gain) + dterm;
-
+        if (result >= 0)
+                result = result + (1 << (FRAC_BITS-1));
+        else
+                result = result - (1 << (FRAC_BITS-1));
         return (signed int)fp_toint(result);
 }
 
@@ -546,8 +545,6 @@ static inline void intel_pstate_pstate_decrease(struct cpudata *cpu, int steps)
 
 static void intel_pstate_get_cpu_pstates(struct cpudata *cpu)
 {
-        sprintf(cpu->name, "Intel 2nd generation core");
-
         cpu->pstate.min_pstate = pstate_funcs.get_min();
         cpu->pstate.max_pstate = pstate_funcs.get_max();
         cpu->pstate.turbo_pstate = pstate_funcs.get_turbo();
@@ -557,50 +554,45 @@ static void intel_pstate_get_cpu_pstates(struct cpudata *cpu)
         intel_pstate_set_pstate(cpu, cpu->pstate.min_pstate);
 }
 
-static inline void intel_pstate_calc_busy(struct cpudata *cpu,
-                                        struct sample *sample)
+static inline void intel_pstate_calc_busy(struct cpudata *cpu)
 {
-        int32_t core_pct;
-        int32_t c0_pct;
+        struct sample *sample = &cpu->sample;
+        int64_t core_pct;
+        int32_t rem;
 
-        core_pct = div_fp(int_tofp((sample->aperf)),
-                        int_tofp((sample->mperf)));
-        core_pct = mul_fp(core_pct, int_tofp(100));
-        FP_ROUNDUP(core_pct);
+        core_pct = int_tofp(sample->aperf) * int_tofp(100);
+        core_pct = div_u64_rem(core_pct, int_tofp(sample->mperf), &rem);
 
-        c0_pct = div_fp(int_tofp(sample->mperf), int_tofp(sample->tsc));
+        if ((rem << 1) >= int_tofp(sample->mperf))
+                core_pct += 1;
 
         sample->freq = fp_toint(
                 mul_fp(int_tofp(cpu->pstate.max_pstate * 1000), core_pct));
 
-        sample->core_pct_busy = mul_fp(core_pct, c0_pct);
+        sample->core_pct_busy = (int32_t)core_pct;
 }
 
 static inline void intel_pstate_sample(struct cpudata *cpu)
 {
         u64 aperf, mperf;
-        unsigned long long tsc;
 
         rdmsrl(MSR_IA32_APERF, aperf);
         rdmsrl(MSR_IA32_MPERF, mperf);
-        tsc = native_read_tsc();
 
         aperf = aperf >> FRAC_BITS;
         mperf = mperf >> FRAC_BITS;
-        tsc = tsc >> FRAC_BITS;
 
+        cpu->last_sample_time = cpu->sample.time;
+        cpu->sample.time = ktime_get();
         cpu->sample.aperf = aperf;
         cpu->sample.mperf = mperf;
-        cpu->sample.tsc = tsc;
         cpu->sample.aperf -= cpu->prev_aperf;
         cpu->sample.mperf -= cpu->prev_mperf;
-        cpu->sample.tsc -= cpu->prev_tsc;
 
-        intel_pstate_calc_busy(cpu, &cpu->sample);
+        intel_pstate_calc_busy(cpu);
 
         cpu->prev_aperf = aperf;
         cpu->prev_mperf = mperf;
-        cpu->prev_tsc = tsc;
 }
 
 static inline void intel_pstate_set_sample_time(struct cpudata *cpu)
@@ -614,13 +606,25 @@ static inline void intel_pstate_set_sample_time(struct cpudata *cpu)
 
 static inline int32_t intel_pstate_get_scaled_busy(struct cpudata *cpu)
 {
-        int32_t core_busy, max_pstate, current_pstate;
+        int32_t core_busy, max_pstate, current_pstate, sample_ratio;
+        u32 duration_us;
+        u32 sample_time;
 
         core_busy = cpu->sample.core_pct_busy;
         max_pstate = int_tofp(cpu->pstate.max_pstate);
         current_pstate = int_tofp(cpu->pstate.current_pstate);
         core_busy = mul_fp(core_busy, div_fp(max_pstate, current_pstate));
-        return FP_ROUNDUP(core_busy);
+
+        sample_time = (pid_params.sample_rate_ms  * USEC_PER_MSEC);
+        duration_us = (u32) ktime_us_delta(cpu->sample.time,
+                                        cpu->last_sample_time);
+        if (duration_us > sample_time * 3) {
+                sample_ratio = div_fp(int_tofp(sample_time),
+                                int_tofp(duration_us));
+                core_busy = mul_fp(core_busy, sample_ratio);
+        }
+
+        return core_busy;
 }
 
 static inline void intel_pstate_adjust_busy_pstate(struct cpudata *cpu)
@@ -674,10 +678,13 @@ static const struct x86_cpu_id intel_pstate_cpu_ids[] = {
         ICPU(0x37, byt_params),
         ICPU(0x3a, core_params),
         ICPU(0x3c, core_params),
+        ICPU(0x3d, core_params),
         ICPU(0x3e, core_params),
         ICPU(0x3f, core_params),
         ICPU(0x45, core_params),
         ICPU(0x46, core_params),
+        ICPU(0x4f, core_params),
+        ICPU(0x56, core_params),
         {}
 };
 MODULE_DEVICE_TABLE(x86cpu, intel_pstate_cpu_ids);
diff --git a/drivers/cpufreq/longhaul.c b/drivers/cpufreq/longhaul.c
index 5c4369b5d834..c913906a719e 100644
--- a/drivers/cpufreq/longhaul.c
+++ b/drivers/cpufreq/longhaul.c
@@ -530,6 +530,7 @@ static int longhaul_get_ranges(void)
 
 static void longhaul_setup_voltagescaling(void)
 {
+        struct cpufreq_frequency_table *freq_pos;
         union msr_longhaul longhaul;
         struct mV_pos minvid, maxvid, vid;
         unsigned int j, speed, pos, kHz_step, numvscales;
@@ -608,18 +609,16 @@ static void longhaul_setup_voltagescaling(void)
         /* Calculate kHz for one voltage step */
         kHz_step = (highest_speed - min_vid_speed) / numvscales;
 
-        j = 0;
-        while (longhaul_table[j].frequency != CPUFREQ_TABLE_END) {
-                speed = longhaul_table[j].frequency;
+        cpufreq_for_each_entry(freq_pos, longhaul_table) {
+                speed = freq_pos->frequency;
                 if (speed > min_vid_speed)
                         pos = (speed - min_vid_speed) / kHz_step + minvid.pos;
                 else
                         pos = minvid.pos;
-                longhaul_table[j].driver_data |= mV_vrm_table[pos] << 8;
+                freq_pos->driver_data |= mV_vrm_table[pos] << 8;
                 vid = vrm_mV_table[mV_vrm_table[pos]];
                 printk(KERN_INFO PFX "f: %d kHz, index: %d, vid: %d mV\n",
-                                speed, j, vid.mV);
-                j++;
+                        speed, (int)(freq_pos - longhaul_table), vid.mV);
         }
 
         can_scale_voltage = 1;
diff --git a/drivers/cpufreq/pasemi-cpufreq.c b/drivers/cpufreq/pasemi-cpufreq.c
index 84c84b5f0f3a..35dd4d7ffee0 100644
--- a/drivers/cpufreq/pasemi-cpufreq.c
+++ b/drivers/cpufreq/pasemi-cpufreq.c
@@ -136,9 +136,10 @@ void restore_astate(int cpu)
 
 static int pas_cpufreq_cpu_init(struct cpufreq_policy *policy)
 {
+        struct cpufreq_frequency_table *pos;
         const u32 *max_freqp;
         u32 max_freq;
-        int i, cur_astate;
+        int cur_astate;
         struct resource res;
         struct device_node *cpu, *dn;
         int err = -ENODEV;
@@ -197,10 +198,9 @@ static int pas_cpufreq_cpu_init(struct cpufreq_policy *policy)
         pr_debug("initializing frequency table\n");
 
         /* initialize frequency table */
-        for (i=0; pas_freqs[i].frequency!=CPUFREQ_TABLE_END; i++) {
-                pas_freqs[i].frequency =
-                        get_astate_freq(pas_freqs[i].driver_data) * 100000;
-                pr_debug("%d: %d\n", i, pas_freqs[i].frequency);
+        cpufreq_for_each_entry(pos, pas_freqs) {
+                pos->frequency = get_astate_freq(pos->driver_data) * 100000;
+                pr_debug("%d: %d\n", (int)(pos - pas_freqs), pos->frequency);
         }
 
         cur_astate = get_cur_astate(policy->cpu);
diff --git a/drivers/cpufreq/powernow-k6.c b/drivers/cpufreq/powernow-k6.c
index 78904e6ca4a0..c8012bc86910 100644
--- a/drivers/cpufreq/powernow-k6.c
+++ b/drivers/cpufreq/powernow-k6.c
@@ -151,6 +151,7 @@ static int powernow_k6_target(struct cpufreq_policy *policy,
 
 static int powernow_k6_cpu_init(struct cpufreq_policy *policy)
 {
+        struct cpufreq_frequency_table *pos;
         unsigned int i, f;
         unsigned khz;
 
@@ -168,12 +169,11 @@ static int powernow_k6_cpu_init(struct cpufreq_policy *policy)
                 }
         }
         if (param_max_multiplier) {
-                for (i = 0; (clock_ratio[i].frequency != CPUFREQ_TABLE_END); i++) {
-                        if (clock_ratio[i].driver_data == param_max_multiplier) {
+                cpufreq_for_each_entry(pos, clock_ratio)
+                        if (pos->driver_data == param_max_multiplier) {
                                 max_multiplier = param_max_multiplier;
                                 goto have_max_multiplier;
                         }
-                }
                 printk(KERN_ERR "powernow-k6: invalid max_multiplier parameter, valid parameters 20, 30, 35, 40, 45, 50, 55, 60\n");
                 return -EINVAL;
         }
@@ -201,12 +201,12 @@ have_busfreq:
         param_busfreq = busfreq * 10;
 
         /* table init */
-        for (i = 0; (clock_ratio[i].frequency != CPUFREQ_TABLE_END); i++) {
-                f = clock_ratio[i].driver_data;
+        cpufreq_for_each_entry(pos, clock_ratio) {
+                f = pos->driver_data;
                 if (f > max_multiplier)
-                        clock_ratio[i].frequency = CPUFREQ_ENTRY_INVALID;
+                        pos->frequency = CPUFREQ_ENTRY_INVALID;
                 else
-                        clock_ratio[i].frequency = busfreq * f;
+                        pos->frequency = busfreq * f;
         }
 
         /* cpuinfo and default policy values */
diff --git a/drivers/cpufreq/powernow-k8.c b/drivers/cpufreq/powernow-k8.c
index 1b6ae6b57c11..f9ce7e4bf0fe 100644
--- a/drivers/cpufreq/powernow-k8.c
+++ b/drivers/cpufreq/powernow-k8.c
@@ -27,6 +27,8 @@
  *  power and thermal data sheets, (e.g. 30417.pdf, 30430.pdf, 43375.pdf)
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/smp.h>
 #include <linux/module.h>
@@ -45,7 +47,6 @@
 #include <linux/mutex.h>
 #include <acpi/processor.h>
 
-#define PFX "powernow-k8: "
 #define VERSION "version 2.20.00"
 #include "powernow-k8.h"
 
@@ -161,7 +162,7 @@ static int write_new_fid(struct powernow_k8_data *data, u32 fid)
         u32 i = 0;
 
         if ((fid & INVALID_FID_MASK) || (data->currvid & INVALID_VID_MASK)) {
-                printk(KERN_ERR PFX "internal error - overflow on fid write\n");
+                pr_err("internal error - overflow on fid write\n");
                 return 1;
         }
 
@@ -175,9 +176,7 @@ static int write_new_fid(struct powernow_k8_data *data, u32 fid)
         do {
                 wrmsr(MSR_FIDVID_CTL, lo, data->plllock * PLL_LOCK_CONVERSION);
                 if (i++ > 100) {
-                        printk(KERN_ERR PFX
-                                "Hardware error - pending bit very stuck - "
-                                "no further pstate changes possible\n");
+                        pr_err("Hardware error - pending bit very stuck - no further pstate changes possible\n");
                         return 1;
                 }
         } while (query_current_values_with_pending_wait(data));
@@ -185,15 +184,13 @@ static int write_new_fid(struct powernow_k8_data *data, u32 fid)
         count_off_irt(data);
 
         if (savevid != data->currvid) {
-                printk(KERN_ERR PFX
-                        "vid change on fid trans, old 0x%x, new 0x%x\n",
-                        savevid, data->currvid);
+                pr_err("vid change on fid trans, old 0x%x, new 0x%x\n",
+                       savevid, data->currvid);
                 return 1;
         }
 
         if (fid != data->currfid) {
-                printk(KERN_ERR PFX
-                        "fid trans failed, fid 0x%x, curr 0x%x\n", fid,
+                pr_err("fid trans failed, fid 0x%x, curr 0x%x\n", fid,
                         data->currfid);
                 return 1;
         }
@@ -209,7 +206,7 @@ static int write_new_vid(struct powernow_k8_data *data, u32 vid)
         int i = 0;
 
         if ((data->currfid & INVALID_FID_MASK) || (vid & INVALID_VID_MASK)) {
-                printk(KERN_ERR PFX "internal error - overflow on vid write\n");
+                pr_err("internal error - overflow on vid write\n");
                 return 1;
         }
 
@@ -223,23 +220,19 @@ static int write_new_vid(struct powernow_k8_data *data, u32 vid)
         do {
                 wrmsr(MSR_FIDVID_CTL, lo, STOP_GRANT_5NS);
                 if (i++ > 100) {
-                        printk(KERN_ERR PFX "internal error - pending bit "
-                                        "very stuck - no further pstate "
-                                        "changes possible\n");
+                        pr_err("internal error - pending bit very stuck - no further pstate changes possible\n");
                         return 1;
                 }
         } while (query_current_values_with_pending_wait(data));
 
         if (savefid != data->currfid) {
-                printk(KERN_ERR PFX "fid changed on vid trans, old "
-                        "0x%x new 0x%x\n",
-                       savefid, data->currfid);
+                pr_err("fid changed on vid trans, old 0x%x new 0x%x\n",
+                        savefid, data->currfid);
                 return 1;
         }
 
         if (vid != data->currvid) {
-                printk(KERN_ERR PFX "vid trans failed, vid 0x%x, "
-                                "curr 0x%x\n",
+                pr_err("vid trans failed, vid 0x%x, curr 0x%x\n",
                                 vid, data->currvid);
                 return 1;
         }
@@ -283,8 +276,7 @@ static int transition_fid_vid(struct powernow_k8_data *data,
                 return 1;
 
         if ((reqfid != data->currfid) || (reqvid != data->currvid)) {
-                printk(KERN_ERR PFX "failed (cpu%d): req 0x%x 0x%x, "
-                                "curr 0x%x 0x%x\n",
+                pr_err("failed (cpu%d): req 0x%x 0x%x, curr 0x%x 0x%x\n",
                                 smp_processor_id(),
                                 reqfid, reqvid, data->currfid, data->currvid);
                 return 1;
@@ -304,8 +296,7 @@ static int core_voltage_pre_transition(struct powernow_k8_data *data,
         u32 savefid = data->currfid;
         u32 maxvid, lo, rvomult = 1;
 
-        pr_debug("ph1 (cpu%d): start, currfid 0x%x, currvid 0x%x, "
-                "reqvid 0x%x, rvo 0x%x\n",
+        pr_debug("ph1 (cpu%d): start, currfid 0x%x, currvid 0x%x, reqvid 0x%x, rvo 0x%x\n",
                 smp_processor_id(),
                 data->currfid, data->currvid, reqvid, data->rvo);
 
@@ -342,8 +333,7 @@ static int core_voltage_pre_transition(struct powernow_k8_data *data,
                 return 1;
 
         if (savefid != data->currfid) {
-                printk(KERN_ERR PFX "ph1 err, currfid changed 0x%x\n",
-                                data->currfid);
+                pr_err("ph1 err, currfid changed 0x%x\n", data->currfid);
                 return 1;
         }
 
@@ -360,13 +350,11 @@ static int core_frequency_transition(struct powernow_k8_data *data, u32 reqfid)
         u32 fid_interval, savevid = data->currvid;
 
         if (data->currfid == reqfid) {
-                printk(KERN_ERR PFX "ph2 null fid transition 0x%x\n",
-                                data->currfid);
+                pr_err("ph2 null fid transition 0x%x\n", data->currfid);
                 return 0;
         }
 
-        pr_debug("ph2 (cpu%d): starting, currfid 0x%x, currvid 0x%x, "
-                "reqfid 0x%x\n",
+        pr_debug("ph2 (cpu%d): starting, currfid 0x%x, currvid 0x%x, reqfid 0x%x\n",
                 smp_processor_id(),
                 data->currfid, data->currvid, reqfid);
 
@@ -409,15 +397,13 @@ static int core_frequency_transition(struct powernow_k8_data *data, u32 reqfid)
                 return 1;
 
         if (data->currfid != reqfid) {
-                printk(KERN_ERR PFX
-                        "ph2: mismatch, failed fid transition, "
-                        "curr 0x%x, req 0x%x\n",
+                pr_err("ph2: mismatch, failed fid transition, curr 0x%x, req 0x%x\n",
                         data->currfid, reqfid);
                 return 1;
         }
 
         if (savevid != data->currvid) {
-                printk(KERN_ERR PFX "ph2: vid changed, save 0x%x, curr 0x%x\n",
+                pr_err("ph2: vid changed, save 0x%x, curr 0x%x\n",
                         savevid, data->currvid);
                 return 1;
         }
@@ -444,17 +430,14 @@ static int core_voltage_post_transition(struct powernow_k8_data *data,
                         return 1;
 
                 if (savefid != data->currfid) {
-                        printk(KERN_ERR PFX
-                               "ph3: bad fid change, save 0x%x, curr 0x%x\n",
-                               savefid, data->currfid);
+                        pr_err("ph3: bad fid change, save 0x%x, curr 0x%x\n",
+                                savefid, data->currfid);
                         return 1;
                 }
 
                 if (data->currvid != reqvid) {
-                        printk(KERN_ERR PFX
-                               "ph3: failed vid transition\n, "
-                               "req 0x%x, curr 0x%x",
-                               reqvid, data->currvid);
+                        pr_err("ph3: failed vid transition\n, req 0x%x, curr 0x%x",
+                                reqvid, data->currvid);
                         return 1;
                 }
         }
@@ -498,23 +481,20 @@ static void check_supported_cpu(void *_rc)
         if ((eax & CPUID_XFAM) == CPUID_XFAM_K8) {
                 if (((eax & CPUID_USE_XFAM_XMOD) != CPUID_USE_XFAM_XMOD) ||
                     ((eax & CPUID_XMOD) > CPUID_XMOD_REV_MASK)) {
-                        printk(KERN_INFO PFX
-                                "Processor cpuid %x not supported\n", eax);
+                        pr_info("Processor cpuid %x not supported\n", eax);
                         return;
                 }
 
                 eax = cpuid_eax(CPUID_GET_MAX_CAPABILITIES);
                 if (eax < CPUID_FREQ_VOLT_CAPABILITIES) {
-                        printk(KERN_INFO PFX
-                               "No frequency change capabilities detected\n");
+                        pr_info("No frequency change capabilities detected\n");
                         return;
                 }
 
                 cpuid(CPUID_FREQ_VOLT_CAPABILITIES, &eax, &ebx, &ecx, &edx);
                 if ((edx & P_STATE_TRANSITION_CAPABLE)
                         != P_STATE_TRANSITION_CAPABLE) {
-                        printk(KERN_INFO PFX
-                                "Power state transitions not supported\n");
+                        pr_info("Power state transitions not supported\n");
                         return;
                 }
                 *rc = 0;
@@ -529,43 +509,39 @@ static int check_pst_table(struct powernow_k8_data *data, struct pst_s *pst,
 
         for (j = 0; j < data->numps; j++) {
                 if (pst[j].vid > LEAST_VID) {
-                        printk(KERN_ERR FW_BUG PFX "vid %d invalid : 0x%x\n",
-                               j, pst[j].vid);
+                        pr_err(FW_BUG "vid %d invalid : 0x%x\n", j,
+                                pst[j].vid);
                         return -EINVAL;
                 }
                 if (pst[j].vid < data->rvo) {
                         /* vid + rvo >= 0 */
-                        printk(KERN_ERR FW_BUG PFX "0 vid exceeded with pstate"
-                               " %d\n", j);
+                        pr_err(FW_BUG "0 vid exceeded with pstate %d\n", j);
                         return -ENODEV;
                 }
                 if (pst[j].vid < maxvid + data->rvo) {
                         /* vid + rvo >= maxvid */
-                        printk(KERN_ERR FW_BUG PFX "maxvid exceeded with pstate"
-                               " %d\n", j);
+                        pr_err(FW_BUG "maxvid exceeded with pstate %d\n", j);
                         return -ENODEV;
                 }
                 if (pst[j].fid > MAX_FID) {
-                        printk(KERN_ERR FW_BUG PFX "maxfid exceeded with pstate"
-                               " %d\n", j);
+                        pr_err(FW_BUG "maxfid exceeded with pstate %d\n", j);
                         return -ENODEV;
                 }
                 if (j && (pst[j].fid < HI_FID_TABLE_BOTTOM)) {
                         /* Only first fid is allowed to be in "low" range */
-                        printk(KERN_ERR FW_BUG PFX "two low fids - %d : "
-                               "0x%x\n", j, pst[j].fid);
+                        pr_err(FW_BUG "two low fids - %d : 0x%x\n", j,
+                                pst[j].fid);
                         return -EINVAL;
                 }
                 if (pst[j].fid < lastfid)
                         lastfid = pst[j].fid;
         }
         if (lastfid & 1) {
-                printk(KERN_ERR FW_BUG PFX "lastfid invalid\n");
+                pr_err(FW_BUG "lastfid invalid\n");
                 return -EINVAL;
         }
         if (lastfid > LO_FID_TABLE_TOP)
-                printk(KERN_INFO FW_BUG PFX
-                        "first fid not from lo freq table\n");
+                pr_info(FW_BUG "first fid not from lo freq table\n");
 
         return 0;
 }
@@ -582,16 +558,14 @@ static void print_basics(struct powernow_k8_data *data)
         for (j = 0; j < data->numps; j++) {
                 if (data->powernow_table[j].frequency !=
                                 CPUFREQ_ENTRY_INVALID) {
-                                printk(KERN_INFO PFX
-                                        "fid 0x%x (%d MHz), vid 0x%x\n",
-                                        data->powernow_table[j].driver_data & 0xff,
-                                        data->powernow_table[j].frequency/1000,
-                                        data->powernow_table[j].driver_data >> 8);
+                        pr_info("fid 0x%x (%d MHz), vid 0x%x\n",
+                                data->powernow_table[j].driver_data & 0xff,
+                                data->powernow_table[j].frequency/1000,
+                                data->powernow_table[j].driver_data >> 8);
                 }
         }
         if (data->batps)
-                printk(KERN_INFO PFX "Only %d pstates on battery\n",
-                                data->batps);
+                pr_info("Only %d pstates on battery\n", data->batps);
 }
 
 static int fill_powernow_table(struct powernow_k8_data *data,
@@ -602,21 +576,20 @@ static int fill_powernow_table(struct powernow_k8_data *data,
 
         if (data->batps) {
                 /* use ACPI support to get full speed on mains power */
-                printk(KERN_WARNING PFX
-                        "Only %d pstates usable (use ACPI driver for full "
-                        "range\n", data->batps);
+                pr_warn("Only %d pstates usable (use ACPI driver for full range\n",
+                        data->batps);
                 data->numps = data->batps;
         }
 
         for (j = 1; j < data->numps; j++) {
                 if (pst[j-1].fid >= pst[j].fid) {
-                        printk(KERN_ERR PFX "PST out of sequence\n");
+                        pr_err("PST out of sequence\n");
                         return -EINVAL;
                 }
         }
 
         if (data->numps < 2) {
-                printk(KERN_ERR PFX "no p states to transition\n");
+                pr_err("no p states to transition\n");
                 return -ENODEV;
         }
 
@@ -626,7 +599,7 @@ static int fill_powernow_table(struct powernow_k8_data *data,
         powernow_table = kzalloc((sizeof(*powernow_table)
                 * (data->numps + 1)), GFP_KERNEL);
         if (!powernow_table) {
-                printk(KERN_ERR PFX "powernow_table memory alloc failure\n");
+                pr_err("powernow_table memory alloc failure\n");
                 return -ENOMEM;
         }
 
@@ -681,13 +654,13 @@ static int find_psb_table(struct powernow_k8_data *data)
 
                 pr_debug("table vers: 0x%x\n", psb->tableversion);
                 if (psb->tableversion != PSB_VERSION_1_4) {
-                        printk(KERN_ERR FW_BUG PFX "PSB table is not v1.4\n");
+                        pr_err(FW_BUG "PSB table is not v1.4\n");
                         return -ENODEV;
                 }
 
                 pr_debug("flags: 0x%x\n", psb->flags1);
                 if (psb->flags1) {
-                        printk(KERN_ERR FW_BUG PFX "unknown flags\n");
+                        pr_err(FW_BUG "unknown flags\n");
                         return -ENODEV;
                 }
 
@@ -716,7 +689,7 @@ static int find_psb_table(struct powernow_k8_data *data)
                                 cpst = 1;
                 }
                 if (cpst != 1) {
-                        printk(KERN_ERR FW_BUG PFX "numpst must be 1\n");
+                        pr_err(FW_BUG "numpst must be 1\n");
                         return -ENODEV;
                 }
 
@@ -742,9 +715,8 @@ static int find_psb_table(struct powernow_k8_data *data)
          * BIOS and Kernel Developer's Guide, which is available on
          * www.amd.com
          */
-        printk(KERN_ERR FW_BUG PFX "No PSB or ACPI _PSS objects\n");
-        printk(KERN_ERR PFX "Make sure that your BIOS is up to date"
-                " and Cool'N'Quiet support is enabled in BIOS setup\n");
+        pr_err(FW_BUG "No PSB or ACPI _PSS objects\n");
+        pr_err("Make sure that your BIOS is up to date and Cool'N'Quiet support is enabled in BIOS setup\n");
         return -ENODEV;
 }
 
@@ -819,8 +791,7 @@ static int powernow_k8_cpu_init_acpi(struct powernow_k8_data *data)
         acpi_processor_notify_smm(THIS_MODULE);
 
         if (!zalloc_cpumask_var(&data->acpi_data.shared_cpu_map, GFP_KERNEL)) {
-                printk(KERN_ERR PFX
-                                "unable to alloc powernow_k8_data cpumask\n");
+                pr_err("unable to alloc powernow_k8_data cpumask\n");
                 ret_val = -ENOMEM;
                 goto err_out_mem;
         }
@@ -885,9 +856,8 @@ static int fill_powernow_table_fidvid(struct powernow_k8_data *data,
                 }
 
                 if (freq != (data->acpi_data.states[i].core_frequency * 1000)) {
-                        printk(KERN_INFO PFX "invalid freq entries "
-                                "%u kHz vs. %u kHz\n", freq,
-                                (unsigned int)
+                        pr_info("invalid freq entries %u kHz vs. %u kHz\n",
+                                freq, (unsigned int)
                                 (data->acpi_data.states[i].core_frequency
                                  * 1000));
                         invalidate_entry(powernow_table, i);
@@ -916,7 +886,7 @@ static int get_transition_latency(struct powernow_k8_data *data)
                         max_latency = cur_latency;
         }
         if (max_latency == 0) {
-                pr_err(FW_WARN PFX "Invalid zero transition latency\n");
+                pr_err(FW_WARN "Invalid zero transition latency\n");
                 max_latency = 1;
         }
         /* value in usecs, needs to be in nanoseconds */
@@ -991,7 +961,7 @@ static long powernowk8_target_fn(void *arg)
         checkvid = data->currvid;
 
         if (pending_bit_stuck()) {
-                printk(KERN_ERR PFX "failing targ, change pending bit set\n");
+                pr_err("failing targ, change pending bit set\n");
                 return -EIO;
         }
 
@@ -1003,12 +973,11 @@ static long powernowk8_target_fn(void *arg)
                 return -EIO;
 
         pr_debug("targ: curr fid 0x%x, vid 0x%x\n",
-                 data->currfid, data->currvid);
+                data->currfid, data->currvid);
 
         if ((checkvid != data->currvid) ||
             (checkfid != data->currfid)) {
-                pr_info(PFX
-                       "error - out of sync, fix 0x%x 0x%x, vid 0x%x 0x%x\n",
+                pr_info("error - out of sync, fix 0x%x 0x%x, vid 0x%x 0x%x\n",
                        checkfid, data->currfid,
                        checkvid, data->currvid);
         }
@@ -1020,7 +989,7 @@ static long powernowk8_target_fn(void *arg)
         ret = transition_frequency_fidvid(data, newstate);
 
         if (ret) {
-                printk(KERN_ERR PFX "transition frequency failed\n");
+                pr_err("transition frequency failed\n");
                 mutex_unlock(&fidvid_mutex);
                 return 1;
         }
@@ -1049,7 +1018,7 @@ static void powernowk8_cpu_init_on_cpu(void *_init_on_cpu)
         struct init_on_cpu *init_on_cpu = _init_on_cpu;
 
         if (pending_bit_stuck()) {
-                printk(KERN_ERR PFX "failing init, change pending bit set\n");
+                pr_err("failing init, change pending bit set\n");
                 init_on_cpu->rc = -ENODEV;
                 return;
         }
@@ -1064,11 +1033,10 @@ static void powernowk8_cpu_init_on_cpu(void *_init_on_cpu)
         init_on_cpu->rc = 0;
 }
 
-static const char missing_pss_msg[] =
-        KERN_ERR
-        FW_BUG PFX "No compatible ACPI _PSS objects found.\n"
-        FW_BUG PFX "First, make sure Cool'N'Quiet is enabled in the BIOS.\n"
-        FW_BUG PFX "If that doesn't help, try upgrading your BIOS.\n";
+#define MISSING_PSS_MSG \
+        FW_BUG "No compatible ACPI _PSS objects found.\n" \
+        FW_BUG "First, make sure Cool'N'Quiet is enabled in the BIOS.\n" \
+        FW_BUG "If that doesn't help, try upgrading your BIOS.\n"
 
 /* per CPU init entry point to the driver */
 static int powernowk8_cpu_init(struct cpufreq_policy *pol)
@@ -1083,7 +1051,7 @@ static int powernowk8_cpu_init(struct cpufreq_policy *pol)
 
         data = kzalloc(sizeof(*data), GFP_KERNEL);
         if (!data) {
-                printk(KERN_ERR PFX "unable to alloc powernow_k8_data");
+                pr_err("unable to alloc powernow_k8_data");
                 return -ENOMEM;
         }
 
@@ -1095,13 +1063,11 @@ static int powernowk8_cpu_init(struct cpufreq_policy *pol)
                  * an UP version, and is deprecated by AMD.
                  */
                 if (num_online_cpus() != 1) {
-                        printk_once(missing_pss_msg);
+                        pr_err_once(MISSING_PSS_MSG);
                         goto err_out;
                 }
                 if (pol->cpu != 0) {
-                        printk(KERN_ERR FW_BUG PFX "No ACPI _PSS objects for "
-                               "CPU other than CPU0. Complain to your BIOS "
-                               "vendor.\n");
+                        pr_err(FW_BUG "No ACPI _PSS objects for CPU other than CPU0. Complain to your BIOS vendor.\n");
                         goto err_out;
                 }
                 rc = find_psb_table(data);
@@ -1129,7 +1095,7 @@ static int powernowk8_cpu_init(struct cpufreq_policy *pol)
 
         /* min/max the cpu is capable of */
         if (cpufreq_table_validate_and_show(pol, data->powernow_table)) {
-                printk(KERN_ERR FW_BUG PFX "invalid powernow_table\n");
+                pr_err(FW_BUG "invalid powernow_table\n");
                 powernow_k8_cpu_exit_acpi(data);
                 kfree(data->powernow_table);
                 kfree(data);
@@ -1137,7 +1103,7 @@ static int powernowk8_cpu_init(struct cpufreq_policy *pol)
         }
 
         pr_debug("cpu_init done, current fid 0x%x, vid 0x%x\n",
-                 data->currfid, data->currvid);
+                data->currfid, data->currvid);
 
         /* Point all the CPUs in this policy to the same data */
         for_each_cpu(cpu, pol->cpus)
@@ -1220,12 +1186,12 @@ static void __request_acpi_cpufreq(void)
                 goto request;
 
         if (strncmp(cur_drv, drv, min_t(size_t, strlen(cur_drv), strlen(drv))))
-                pr_warn(PFX "WTF driver: %s\n", cur_drv);
+                pr_warn("WTF driver: %s\n", cur_drv);
 
         return;
 
  request:
-        pr_warn(PFX "This CPU is not supported anymore, using acpi-cpufreq instead.\n");
+        pr_warn("This CPU is not supported anymore, using acpi-cpufreq instead.\n");
         request_module(drv);
 }
 
@@ -1260,7 +1226,7 @@ static int powernowk8_init(void)
         if (ret)
                 return ret;
 
-        pr_info(PFX "Found %d %s (%d cpu cores) (" VERSION ")\n",
+        pr_info("Found %d %s (%d cpu cores) (" VERSION ")\n",
                 num_online_nodes(), boot_cpu_data.x86_model_id, supported_cpus);
 
         return ret;
@@ -1274,8 +1240,8 @@ static void __exit powernowk8_exit(void)
         cpufreq_unregister_driver(&cpufreq_amd64_driver);
 }
 
-MODULE_AUTHOR("Paul Devriendt <paul.devriendt@amd.com> and "
-                "Mark Langsdorf <mark.langsdorf@amd.com>");
+MODULE_AUTHOR("Paul Devriendt <paul.devriendt@amd.com>");
+MODULE_AUTHOR("Mark Langsdorf <mark.langsdorf@amd.com>");
 MODULE_DESCRIPTION("AMD Athlon 64 and Opteron processor frequency driver.");
 MODULE_LICENSE("GPL");
 
diff --git a/drivers/cpufreq/powernow-k8.h b/drivers/cpufreq/powernow-k8.h
index 79329d4d5abe..45ce11e86626 100644
--- a/drivers/cpufreq/powernow-k8.h
+++ b/drivers/cpufreq/powernow-k8.h
@@ -19,7 +19,7 @@ struct powernow_k8_data {
         u32 vidmvs;  /* usable value calculated from mvs */
         u32 vstable; /* voltage stabilization time, units 20 us */
         u32 plllock; /* pll lock time, units 1 us */
-        u32 exttype; /* extended interface = 1 */
+        u32 exttype; /* extended interface = 1 */
 
         /* keep track of the current fid / vid or pstate */
         u32 currvid;
diff --git a/drivers/cpufreq/powernv-cpufreq.c b/drivers/cpufreq/powernv-cpufreq.c
index af4968813e76..bb1d08dc8cc8 100644
--- a/drivers/cpufreq/powernv-cpufreq.c
+++ b/drivers/cpufreq/powernv-cpufreq.c
@@ -235,7 +235,7 @@ static void powernv_read_cpu_freq(void *arg)
  * firmware for CPU 'cpu'. This value is reported through the sysfs
  * file cpuinfo_cur_freq.
  */
-unsigned int powernv_cpufreq_get(unsigned int cpu)
+static unsigned int powernv_cpufreq_get(unsigned int cpu)
 {
         struct powernv_smp_call_data freq_data;
 
diff --git a/drivers/cpufreq/ppc_cbe_cpufreq.c b/drivers/cpufreq/ppc_cbe_cpufreq.c
index 5be8a48dba74..5a4c5a639f61 100644
--- a/drivers/cpufreq/ppc_cbe_cpufreq.c
+++ b/drivers/cpufreq/ppc_cbe_cpufreq.c
@@ -67,9 +67,10 @@ static int set_pmode(unsigned int cpu, unsigned int slow_mode)
 
 static int cbe_cpufreq_cpu_init(struct cpufreq_policy *policy)
 {
+        struct cpufreq_frequency_table *pos;
         const u32 *max_freqp;
         u32 max_freq;
-        int i, cur_pmode;
+        int cur_pmode;
         struct device_node *cpu;
 
         cpu = of_get_cpu_node(policy->cpu, NULL);
@@ -102,9 +103,9 @@ static int cbe_cpufreq_cpu_init(struct cpufreq_policy *policy)
         pr_debug("initializing frequency table\n");
 
         /* initialize frequency table */
-        for (i=0; cbe_freqs[i].frequency!=CPUFREQ_TABLE_END; i++) {
-                cbe_freqs[i].frequency = max_freq / cbe_freqs[i].driver_data;
-                pr_debug("%d: %d\n", i, cbe_freqs[i].frequency);
+        cpufreq_for_each_entry(pos, cbe_freqs) {
+                pos->frequency = max_freq / pos->driver_data;
+                pr_debug("%d: %d\n", (int)(pos - cbe_freqs), pos->frequency);
         }
 
         /* if DEBUG is enabled set_pmode() measures the latency
diff --git a/drivers/cpufreq/s3c2416-cpufreq.c b/drivers/cpufreq/s3c2416-cpufreq.c
index 4626f90559b5..2fd53eaaec20 100644
--- a/drivers/cpufreq/s3c2416-cpufreq.c
+++ b/drivers/cpufreq/s3c2416-cpufreq.c
@@ -266,7 +266,7 @@ out:
 static void __init s3c2416_cpufreq_cfg_regulator(struct s3c2416_data *s3c_freq)
 {
         int count, v, i, found;
-        struct cpufreq_frequency_table *freq;
+        struct cpufreq_frequency_table *pos;
         struct s3c2416_dvfs *dvfs;
 
         count = regulator_count_voltages(s3c_freq->vddarm);
@@ -275,12 +275,11 @@ static void __init s3c2416_cpufreq_cfg_regulator(struct s3c2416_data *s3c_freq)
                 return;
         }
 
-        freq = s3c_freq->freq_table;
-        while (count > 0 && freq->frequency != CPUFREQ_TABLE_END) {
-                if (freq->frequency == CPUFREQ_ENTRY_INVALID)
-                        continue;
+        if (!count)
+                goto out;
 
-                dvfs = &s3c2416_dvfs_table[freq->driver_data];
+        cpufreq_for_each_valid_entry(pos, s3c_freq->freq_table) {
+                dvfs = &s3c2416_dvfs_table[pos->driver_data];
                 found = 0;
 
                 /* Check only the min-voltage, more is always ok on S3C2416 */
@@ -292,13 +291,12 @@ static void __init s3c2416_cpufreq_cfg_regulator(struct s3c2416_data *s3c_freq)
 
                 if (!found) {
                         pr_debug("cpufreq: %dkHz unsupported by regulator\n",
-                                 freq->frequency);
-                        freq->frequency = CPUFREQ_ENTRY_INVALID;
+                                 pos->frequency);
+                        pos->frequency = CPUFREQ_ENTRY_INVALID;
                 }
-
-                freq++;
         }
 
+out:
         /* Guessed */
         s3c_freq->regulator_latency = 1 * 1000 * 1000;
 }
@@ -338,7 +336,7 @@ static struct notifier_block s3c2416_cpufreq_reboot_notifier = {
 static int __init s3c2416_cpufreq_driver_init(struct cpufreq_policy *policy)
 {
         struct s3c2416_data *s3c_freq = &s3c2416_cpufreq;
-        struct cpufreq_frequency_table *freq;
+        struct cpufreq_frequency_table *pos;
         struct clk *msysclk;
         unsigned long rate;
         int ret;
@@ -427,31 +425,27 @@ static int __init s3c2416_cpufreq_driver_init(struct cpufreq_policy *policy)
         s3c_freq->regulator_latency = 0;
 #endif
 
-        freq = s3c_freq->freq_table;
-        while (freq->frequency != CPUFREQ_TABLE_END) {
+        cpufreq_for_each_entry(pos, s3c_freq->freq_table) {
                 /* special handling for dvs mode */
-                if (freq->driver_data == 0) {
+                if (pos->driver_data == 0) {
                         if (!s3c_freq->hclk) {
                                 pr_debug("cpufreq: %dkHz unsupported as it would need unavailable dvs mode\n",
-                                         freq->frequency);
-                                freq->frequency = CPUFREQ_ENTRY_INVALID;
+                                         pos->frequency);
+                                pos->frequency = CPUFREQ_ENTRY_INVALID;
                         } else {
-                                freq++;
                                 continue;
                         }
                 }
 
                 /* Check for frequencies we can generate */
                 rate = clk_round_rate(s3c_freq->armdiv,
-                                      freq->frequency * 1000);
+                                      pos->frequency * 1000);
                 rate /= 1000;
-                if (rate != freq->frequency) {
+                if (rate != pos->frequency) {
                         pr_debug("cpufreq: %dkHz unsupported by clock (clk_round_rate return %lu)\n",
-                                 freq->frequency, rate);
-                        freq->frequency = CPUFREQ_ENTRY_INVALID;
+                                pos->frequency, rate);
+                        pos->frequency = CPUFREQ_ENTRY_INVALID;
                 }
-
-                freq++;
         }
 
         /* Datasheet says PLL stabalisation time must be at least 300us,
diff --git a/drivers/cpufreq/s3c64xx-cpufreq.c b/drivers/cpufreq/s3c64xx-cpufreq.c
index ff7d3ecb85f0..176e84cc3991 100644
--- a/drivers/cpufreq/s3c64xx-cpufreq.c
+++ b/drivers/cpufreq/s3c64xx-cpufreq.c
@@ -118,11 +118,10 @@ static void __init s3c64xx_cpufreq_config_regulator(void)
                 pr_err("Unable to check supported voltages\n");
         }
 
-        freq = s3c64xx_freq_table;
-        while (count > 0 && freq->frequency != CPUFREQ_TABLE_END) {
-                if (freq->frequency == CPUFREQ_ENTRY_INVALID)
-                        continue;
+        if (!count)
+                goto out;
 
+        cpufreq_for_each_valid_entry(freq, s3c64xx_freq_table) {
                 dvfs = &s3c64xx_dvfs_table[freq->driver_data];
                 found = 0;
 
@@ -137,10 +136,9 @@ static void __init s3c64xx_cpufreq_config_regulator(void)
                                  freq->frequency);
                         freq->frequency = CPUFREQ_ENTRY_INVALID;
                 }
-
-                freq++;
         }
 
+out:
         /* Guess based on having to do an I2C/SPI write; in future we
          * will be able to query the regulator performance here. */
         regulator_latency = 1 * 1000 * 1000;
@@ -179,8 +177,7 @@ static int s3c64xx_cpufreq_driver_init(struct cpufreq_policy *policy)
         }
 #endif
 
-        freq = s3c64xx_freq_table;
-        while (freq->frequency != CPUFREQ_TABLE_END) {
+        cpufreq_for_each_entry(freq, s3c64xx_freq_table) {
                 unsigned long r;
 
                 /* Check for frequencies we can generate */
@@ -196,8 +193,6 @@ static int s3c64xx_cpufreq_driver_init(struct cpufreq_policy *policy)
                  * frequency is the maximum we can support. */
                 if (!vddarm && freq->frequency > clk_get_rate(policy->clk) / 1000)
                         freq->frequency = CPUFREQ_ENTRY_INVALID;
-
-                freq++;
         }
 
         /* Datasheet says PLL stabalisation time (if we were to use
diff --git a/drivers/cpufreq/s5pv210-cpufreq.c b/drivers/cpufreq/s5pv210-cpufreq.c
index ab2c1a40d437..19a10b89fef7 100644
--- a/drivers/cpufreq/s5pv210-cpufreq.c
+++ b/drivers/cpufreq/s5pv210-cpufreq.c
@@ -175,10 +175,8 @@ static int s5pv210_target(struct cpufreq_policy *policy, unsigned int index)
         mutex_lock(&set_freq_lock);
 
         if (no_cpufreq_access) {
-#ifdef CONFIG_PM_VERBOSE
-                pr_err("%s:%d denied access to %s as it is disabled"
-                                "temporarily\n", __FILE__, __LINE__, __func__);
-#endif
+                pr_err("Denied access to %s as it is disabled temporarily\n",
+                       __func__);
                 ret = -EINVAL;
                 goto exit;
         }
diff --git a/drivers/cpufreq/speedstep-centrino.c b/drivers/cpufreq/speedstep-centrino.c
index 6723f0390f20..7d4a31571608 100644
--- a/drivers/cpufreq/speedstep-centrino.c
+++ b/drivers/cpufreq/speedstep-centrino.c
@@ -28,7 +28,7 @@
 #include <asm/cpu_device_id.h>
 
 #define PFX             "speedstep-centrino: "
-#define MAINTAINER      "cpufreq@vger.kernel.org"
+#define MAINTAINER      "linux-pm@vger.kernel.org"
 
 #define INTEL_MSR_RANGE (0xffff)
 
diff --git a/drivers/cpufreq/tegra-cpufreq.c b/drivers/cpufreq/tegra-cpufreq.c
index 63f00598a251..6e774c6ac20b 100644
--- a/drivers/cpufreq/tegra-cpufreq.c
+++ b/drivers/cpufreq/tegra-cpufreq.c
@@ -82,9 +82,9 @@ out:
         return ret;
 }
 
-static int tegra_update_cpu_speed(struct cpufreq_policy *policy,
-                unsigned long rate)
+static int tegra_target(struct cpufreq_policy *policy, unsigned int index)
 {
+        unsigned long rate = freq_table[index].frequency;
         int ret = 0;
 
         /*
@@ -106,11 +106,6 @@ static int tegra_update_cpu_speed(struct cpufreq_policy *policy,
         return ret;
 }
 
-static int tegra_target(struct cpufreq_policy *policy, unsigned int index)
-{
-        return tegra_update_cpu_speed(policy, freq_table[index].frequency);
-}
-
 static int tegra_cpu_init(struct cpufreq_policy *policy)
 {
         int ret;
diff --git a/drivers/cpuidle/Kconfig.arm b/drivers/cpuidle/Kconfig.arm
index ae1d78ea7df7..b6d69e899f5d 100644
--- a/drivers/cpuidle/Kconfig.arm
+++ b/drivers/cpuidle/Kconfig.arm
@@ -18,6 +18,12 @@ config ARM_BIG_LITTLE_CPUIDLE
           define different C-states for little and big cores through the
           multiple CPU idle drivers infrastructure.
 
+config ARM_CLPS711X_CPUIDLE
+        bool "CPU Idle Driver for CLPS711X processors"
+        depends on ARCH_CLPS711X || COMPILE_TEST
+        help
+          Select this to enable cpuidle on Cirrus Logic CLPS711X SOCs.
+
 config ARM_HIGHBANK_CPUIDLE
         bool "CPU Idle Driver for Calxeda processors"
         depends on ARM_PSCI
diff --git a/drivers/cpuidle/Makefile b/drivers/cpuidle/Makefile
index cd3ab59f8461..9b5b2b560d70 100644
--- a/drivers/cpuidle/Makefile
+++ b/drivers/cpuidle/Makefile
@@ -9,6 +9,7 @@ obj-$(CONFIG_ARCH_NEEDS_CPU_IDLE_COUPLED) += coupled.o
 # ARM SoC drivers
 obj-$(CONFIG_ARM_ARMADA_370_XP_CPUIDLE) += cpuidle-armada-370-xp.o
 obj-$(CONFIG_ARM_BIG_LITTLE_CPUIDLE)    += cpuidle-big_little.o
+obj-$(CONFIG_ARM_CLPS711X_CPUIDLE)      += cpuidle-clps711x.o
 obj-$(CONFIG_ARM_HIGHBANK_CPUIDLE)      += cpuidle-calxeda.o
 obj-$(CONFIG_ARM_KIRKWOOD_CPUIDLE)      += cpuidle-kirkwood.o
 obj-$(CONFIG_ARM_ZYNQ_CPUIDLE)          += cpuidle-zynq.o
diff --git a/drivers/cpuidle/cpuidle-clps711x.c b/drivers/cpuidle/cpuidle-clps711x.c
new file mode 100644
index 000000000000..5243811daa6e
--- /dev/null
+++ b/drivers/cpuidle/cpuidle-clps711x.c
@@ -0,0 +1,64 @@
+/*
+ *  CLPS711X CPU idle driver
+ *
+ *  Copyright (C) 2014 Alexander Shiyan <shc_work@mail.ru>
+ *
+ * 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/cpuidle.h>
+#include <linux/err.h>
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+
+#define CLPS711X_CPUIDLE_NAME   "clps711x-cpuidle"
+
+static void __iomem *clps711x_halt;
+
+static int clps711x_cpuidle_halt(struct cpuidle_device *dev,
+                                 struct cpuidle_driver *drv, int index)
+{
+        writel(0xaa, clps711x_halt);
+
+        return index;
+}
+
+static struct cpuidle_driver clps711x_idle_driver = {
+        .name           = CLPS711X_CPUIDLE_NAME,
+        .owner          = THIS_MODULE,
+        .states[0]      = {
+                .name           = "HALT",
+                .desc           = "CLPS711X HALT",
+                .enter          = clps711x_cpuidle_halt,
+                .exit_latency   = 1,
+        },
+        .state_count    = 1,
+};
+
+static int __init clps711x_cpuidle_probe(struct platform_device *pdev)
+{
+        struct resource *res;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        clps711x_halt = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(clps711x_halt))
+                return PTR_ERR(clps711x_halt);
+
+        return cpuidle_register(&clps711x_idle_driver, NULL);
+}
+
+static struct platform_driver clps711x_cpuidle_driver = {
+        .driver = {
+                .name   = CLPS711X_CPUIDLE_NAME,
+                .owner  = THIS_MODULE,
+        },
+};
+module_platform_driver_probe(clps711x_cpuidle_driver, clps711x_cpuidle_probe);
+
+MODULE_AUTHOR("Alexander Shiyan <shc_work@mail.ru>");
+MODULE_DESCRIPTION("CLPS711X CPU idle driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/devfreq/Kconfig b/drivers/devfreq/Kconfig
index 7d2f43550700..49e74c1fc639 100644
--- a/drivers/devfreq/Kconfig
+++ b/drivers/devfreq/Kconfig
@@ -70,19 +70,20 @@ config ARM_EXYNOS4_BUS_DEVFREQ
         depends on (CPU_EXYNOS4210 || SOC_EXYNOS4212 || SOC_EXYNOS4412) && !ARCH_MULTIPLATFORM
         select ARCH_HAS_OPP
         select DEVFREQ_GOV_SIMPLE_ONDEMAND
+        select PM_OPP
         help
           This adds the DEVFREQ driver for Exynos4210 memory bus (vdd_int)
           and Exynos4212/4412 memory interface and bus (vdd_mif + vdd_int).
           It reads PPMU counters of memory controllers and adjusts
           the operating frequencies and voltages with OPP support.
-          To operate with optimal voltages, ASV support is required
-          (CONFIG_EXYNOS_ASV).
+          This does not yet operate with optimal voltages.
 
 config ARM_EXYNOS5_BUS_DEVFREQ
         bool "ARM Exynos5250 Bus DEVFREQ Driver"
         depends on SOC_EXYNOS5250
         select ARCH_HAS_OPP
         select DEVFREQ_GOV_SIMPLE_ONDEMAND
+        select PM_OPP
         help
           This adds the DEVFREQ driver for Exynos5250 bus interface (vdd_int).
           It reads PPMU counters of memory controllers and adjusts the
diff --git a/drivers/devfreq/devfreq.c b/drivers/devfreq/devfreq.c
index 2042ec3656ba..9f90369dd6bd 100644
--- a/drivers/devfreq/devfreq.c
+++ b/drivers/devfreq/devfreq.c
@@ -394,7 +394,7 @@ static int devfreq_notifier_call(struct notifier_block *nb, unsigned long type,
  * @devfreq:    the devfreq struct
  * @skip:       skip calling device_unregister().
  */
-static void _remove_devfreq(struct devfreq *devfreq, bool skip)
+static void _remove_devfreq(struct devfreq *devfreq)
 {
         mutex_lock(&devfreq_list_lock);
         if (IS_ERR(find_device_devfreq(devfreq->dev.parent))) {
@@ -412,11 +412,6 @@ static void _remove_devfreq(struct devfreq *devfreq, bool skip)
         if (devfreq->profile->exit)
                 devfreq->profile->exit(devfreq->dev.parent);
 
-        if (!skip && get_device(&devfreq->dev)) {
-                device_unregister(&devfreq->dev);
-                put_device(&devfreq->dev);
-        }
-
         mutex_destroy(&devfreq->lock);
         kfree(devfreq);
 }
@@ -426,14 +421,12 @@ static void _remove_devfreq(struct devfreq *devfreq, bool skip)
  * @dev:        the devfreq device
  *
  * This calls _remove_devfreq() if _remove_devfreq() is not called.
- * Note that devfreq_dev_release() could be called by _remove_devfreq() as
- * well as by others unregistering the device.
  */
 static void devfreq_dev_release(struct device *dev)
 {
         struct devfreq *devfreq = to_devfreq(dev);
 
-        _remove_devfreq(devfreq, true);
+        _remove_devfreq(devfreq);
 }
 
 /**
@@ -544,12 +537,76 @@ int devfreq_remove_device(struct devfreq *devfreq)
         if (!devfreq)
                 return -EINVAL;
 
-        _remove_devfreq(devfreq, false);
+        device_unregister(&devfreq->dev);
+        put_device(&devfreq->dev);
 
         return 0;
 }
 EXPORT_SYMBOL(devfreq_remove_device);
 
+static int devm_devfreq_dev_match(struct device *dev, void *res, void *data)
+{
+        struct devfreq **r = res;
+
+        if (WARN_ON(!r || !*r))
+                return 0;
+
+        return *r == data;
+}
+
+static void devm_devfreq_dev_release(struct device *dev, void *res)
+{
+        devfreq_remove_device(*(struct devfreq **)res);
+}
+
+/**
+ * devm_devfreq_add_device() - Resource-managed devfreq_add_device()
+ * @dev:        the device to add devfreq feature.
+ * @profile:    device-specific profile to run devfreq.
+ * @governor_name:      name of the policy to choose frequency.
+ * @data:       private data for the governor. The devfreq framework does not
+ *              touch this value.
+ *
+ * This function manages automatically the memory of devfreq device using device
+ * resource management and simplify the free operation for memory of devfreq
+ * device.
+ */
+struct devfreq *devm_devfreq_add_device(struct device *dev,
+                                        struct devfreq_dev_profile *profile,
+                                        const char *governor_name,
+                                        void *data)
+{
+        struct devfreq **ptr, *devfreq;
+
+        ptr = devres_alloc(devm_devfreq_dev_release, sizeof(*ptr), GFP_KERNEL);
+        if (!ptr)
+                return ERR_PTR(-ENOMEM);
+
+        devfreq = devfreq_add_device(dev, profile, governor_name, data);
+        if (IS_ERR(devfreq)) {
+                devres_free(ptr);
+                return ERR_PTR(-ENOMEM);
+        }
+
+        *ptr = devfreq;
+        devres_add(dev, ptr);
+
+        return devfreq;
+}
+EXPORT_SYMBOL(devm_devfreq_add_device);
+
+/**
+ * devm_devfreq_remove_device() - Resource-managed devfreq_remove_device()
+ * @dev:        the device to add devfreq feature.
+ * @devfreq:    the devfreq instance to be removed
+ */
+void devm_devfreq_remove_device(struct device *dev, struct devfreq *devfreq)
+{
+        WARN_ON(devres_release(dev, devm_devfreq_dev_release,
+                               devm_devfreq_dev_match, devfreq));
+}
+EXPORT_SYMBOL(devm_devfreq_remove_device);
+
 /**
  * devfreq_suspend_device() - Suspend devfreq of a device.
  * @devfreq: the devfreq instance to be suspended
@@ -1112,6 +1169,54 @@ int devfreq_unregister_opp_notifier(struct device *dev, struct devfreq *devfreq)
         return ret;
 }
 
+static void devm_devfreq_opp_release(struct device *dev, void *res)
+{
+        devfreq_unregister_opp_notifier(dev, *(struct devfreq **)res);
+}
+
+/**
+ * devm_ devfreq_register_opp_notifier()
+ *              - Resource-managed devfreq_register_opp_notifier()
+ * @dev:        The devfreq user device. (parent of devfreq)
+ * @devfreq:    The devfreq object.
+ */
+int devm_devfreq_register_opp_notifier(struct device *dev,
+                                       struct devfreq *devfreq)
+{
+        struct devfreq **ptr;
+        int ret;
+
+        ptr = devres_alloc(devm_devfreq_opp_release, sizeof(*ptr), GFP_KERNEL);
+        if (!ptr)
+                return -ENOMEM;
+
+        ret = devfreq_register_opp_notifier(dev, devfreq);
+        if (ret) {
+                devres_free(ptr);
+                return ret;
+        }
+
+        *ptr = devfreq;
+        devres_add(dev, ptr);
+
+        return 0;
+}
+EXPORT_SYMBOL(devm_devfreq_register_opp_notifier);
+
+/**
+ * devm_devfreq_unregister_opp_notifier()
+ *              - Resource-managed devfreq_unregister_opp_notifier()
+ * @dev:        The devfreq user device. (parent of devfreq)
+ * @devfreq:    The devfreq object.
+ */
+void devm_devfreq_unregister_opp_notifier(struct device *dev,
+                                         struct devfreq *devfreq)
+{
+        WARN_ON(devres_release(dev, devm_devfreq_opp_release,
+                               devm_devfreq_dev_match, devfreq));
+}
+EXPORT_SYMBOL(devm_devfreq_unregister_opp_notifier);
+
 MODULE_AUTHOR("MyungJoo Ham <myungjoo.ham@samsung.com>");
 MODULE_DESCRIPTION("devfreq class support");
 MODULE_LICENSE("GPL");
diff --git a/drivers/devfreq/exynos/Makefile b/drivers/devfreq/exynos/Makefile
index bfaaf5b0d61d..49bc9175f923 100644
--- a/drivers/devfreq/exynos/Makefile
+++ b/drivers/devfreq/exynos/Makefile
@@ -1,3 +1,3 @@
 # Exynos DEVFREQ Drivers
-obj-$(CONFIG_ARM_EXYNOS4_BUS_DEVFREQ)   += exynos4_bus.o
+obj-$(CONFIG_ARM_EXYNOS4_BUS_DEVFREQ)   += exynos_ppmu.o exynos4_bus.o
 obj-$(CONFIG_ARM_EXYNOS5_BUS_DEVFREQ)   += exynos_ppmu.o exynos5_bus.o
diff --git a/drivers/devfreq/exynos/exynos4_bus.c b/drivers/devfreq/exynos/exynos4_bus.c
index e07b0c68c715..d9b08d3b6830 100644
--- a/drivers/devfreq/exynos/exynos4_bus.c
+++ b/drivers/devfreq/exynos/exynos4_bus.c
@@ -25,13 +25,9 @@
 #include <linux/regulator/consumer.h>
 #include <linux/module.h>
 
-/* Exynos4 ASV has been in the mailing list, but not upstreamed, yet. */
-#ifdef CONFIG_EXYNOS_ASV
-extern unsigned int exynos_result_of_asv;
-#endif
-
 #include <mach/map.h>
 
+#include "exynos_ppmu.h"
 #include "exynos4_bus.h"
 
 #define MAX_SAFEVOLT    1200000 /* 1.2V */
@@ -44,22 +40,6 @@ enum exynos4_busf_type {
 /* Assume that the bus is saturated if the utilization is 40% */
 #define BUS_SATURATION_RATIO    40
 
-enum ppmu_counter {
-        PPMU_PMNCNT0 = 0,
-        PPMU_PMCCNT1,
-        PPMU_PMNCNT2,
-        PPMU_PMNCNT3,
-        PPMU_PMNCNT_MAX,
-};
-struct exynos4_ppmu {
-        void __iomem *hw_base;
-        unsigned int ccnt;
-        unsigned int event;
-        unsigned int count[PPMU_PMNCNT_MAX];
-        bool ccnt_overflow;
-        bool count_overflow[PPMU_PMNCNT_MAX];
-};
-
 enum busclk_level_idx {
         LV_0 = 0,
         LV_1,
@@ -68,6 +48,13 @@ enum busclk_level_idx {
         LV_4,
         _LV_END
 };
+
+enum exynos_ppmu_idx {
+        PPMU_DMC0,
+        PPMU_DMC1,
+        PPMU_END,
+};
+
 #define EX4210_LV_MAX   LV_2
 #define EX4x12_LV_MAX   LV_4
 #define EX4210_LV_NUM   (LV_2 + 1)
@@ -91,7 +78,7 @@ struct busfreq_data {
         struct regulator *vdd_int;
         struct regulator *vdd_mif; /* Exynos4412/4212 only */
         struct busfreq_opp_info curr_oppinfo;
-        struct exynos4_ppmu dmc[2];
+        struct busfreq_ppmu_data ppmu_data;
 
         struct notifier_block pm_notifier;
         struct mutex lock;
@@ -101,12 +88,6 @@ struct busfreq_data {
         unsigned int top_divtable[_LV_END];
 };
 
-struct bus_opp_table {
-        unsigned int idx;
-        unsigned long clk;
-        unsigned long volt;
-};
-
 /* 4210 controls clock of mif and voltage of int */
 static struct bus_opp_table exynos4210_busclk_table[] = {
         {LV_0, 400000, 1150000},
@@ -524,57 +505,6 @@ static int exynos4x12_set_busclk(struct busfreq_data *data,
         return 0;
 }
 
-
-static void busfreq_mon_reset(struct busfreq_data *data)
-{
-        unsigned int i;
-
-        for (i = 0; i < 2; i++) {
-                void __iomem *ppmu_base = data->dmc[i].hw_base;
-
-                /* Reset PPMU */
-                __raw_writel(0x8000000f, ppmu_base + 0xf010);
-                __raw_writel(0x8000000f, ppmu_base + 0xf050);
-                __raw_writel(0x6, ppmu_base + 0xf000);
-                __raw_writel(0x0, ppmu_base + 0xf100);
-
-                /* Set PPMU Event */
-                data->dmc[i].event = 0x6;
-                __raw_writel(((data->dmc[i].event << 12) | 0x1),
-                             ppmu_base + 0xfc);
-
-                /* Start PPMU */
-                __raw_writel(0x1, ppmu_base + 0xf000);
-        }
-}
-
-static void exynos4_read_ppmu(struct busfreq_data *data)
-{
-        int i, j;
-
-        for (i = 0; i < 2; i++) {
-                void __iomem *ppmu_base = data->dmc[i].hw_base;
-                u32 overflow;
-
-                /* Stop PPMU */
-                __raw_writel(0x0, ppmu_base + 0xf000);
-
-                /* Update local data from PPMU */
-                overflow = __raw_readl(ppmu_base + 0xf050);
-
-                data->dmc[i].ccnt = __raw_readl(ppmu_base + 0xf100);
-                data->dmc[i].ccnt_overflow = overflow & (1 << 31);
-
-                for (j = 0; j < PPMU_PMNCNT_MAX; j++) {
-                        data->dmc[i].count[j] = __raw_readl(
-                                        ppmu_base + (0xf110 + (0x10 * j)));
-                        data->dmc[i].count_overflow[j] = overflow & (1 << j);
-                }
-        }
-
-        busfreq_mon_reset(data);
-}
-
 static int exynos4x12_get_intspec(unsigned long mifclk)
 {
         int i = 0;
@@ -698,84 +628,35 @@ out:
         return err;
 }
 
-static int exynos4_get_busier_dmc(struct busfreq_data *data)
-{
-        u64 p0 = data->dmc[0].count[0];
-        u64 p1 = data->dmc[1].count[0];
-
-        p0 *= data->dmc[1].ccnt;
-        p1 *= data->dmc[0].ccnt;
-
-        if (data->dmc[1].ccnt == 0)
-                return 0;
-
-        if (p0 > p1)
-                return 0;
-        return 1;
-}
-
 static int exynos4_bus_get_dev_status(struct device *dev,
                                       struct devfreq_dev_status *stat)
 {
         struct busfreq_data *data = dev_get_drvdata(dev);
-        int busier_dmc;
-        int cycles_x2 = 2; /* 2 x cycles */
-        void __iomem *addr;
-        u32 timing;
-        u32 memctrl;
-
-        exynos4_read_ppmu(data);
-        busier_dmc = exynos4_get_busier_dmc(data);
-        stat->current_frequency = data->curr_oppinfo.rate;
+        struct busfreq_ppmu_data *ppmu_data = &data->ppmu_data;
+        int busier;
 
-        if (busier_dmc)
-                addr = S5P_VA_DMC1;
-        else
-                addr = S5P_VA_DMC0;
-
-        memctrl = __raw_readl(addr + 0x04); /* one of DDR2/3/LPDDR2 */
-        timing = __raw_readl(addr + 0x38); /* CL or WL/RL values */
-
-        switch ((memctrl >> 8) & 0xf) {
-        case 0x4: /* DDR2 */
-                cycles_x2 = ((timing >> 16) & 0xf) * 2;
-                break;
-        case 0x5: /* LPDDR2 */
-        case 0x6: /* DDR3 */
-                cycles_x2 = ((timing >> 8) & 0xf) + ((timing >> 0) & 0xf);
-                break;
-        default:
-                pr_err("%s: Unknown Memory Type(%d).\n", __func__,
-                       (memctrl >> 8) & 0xf);
-                return -EINVAL;
-        }
+        exynos_read_ppmu(ppmu_data);
+        busier = exynos_get_busier_ppmu(ppmu_data);
+        stat->current_frequency = data->curr_oppinfo.rate;
 
         /* Number of cycles spent on memory access */
-        stat->busy_time = data->dmc[busier_dmc].count[0] / 2 * (cycles_x2 + 2);
+        stat->busy_time = ppmu_data->ppmu[busier].count[PPMU_PMNCNT3];
         stat->busy_time *= 100 / BUS_SATURATION_RATIO;
-        stat->total_time = data->dmc[busier_dmc].ccnt;
+        stat->total_time = ppmu_data->ppmu[busier].ccnt;
 
         /* If the counters have overflown, retry */
-        if (data->dmc[busier_dmc].ccnt_overflow ||
-            data->dmc[busier_dmc].count_overflow[0])
+        if (ppmu_data->ppmu[busier].ccnt_overflow ||
+            ppmu_data->ppmu[busier].count_overflow[0])
                 return -EAGAIN;
 
         return 0;
 }
 
-static void exynos4_bus_exit(struct device *dev)
-{
-        struct busfreq_data *data = dev_get_drvdata(dev);
-
-        devfreq_unregister_opp_notifier(dev, data->devfreq);
-}
-
 static struct devfreq_dev_profile exynos4_devfreq_profile = {
         .initial_freq   = 400000,
         .polling_ms     = 50,
         .target         = exynos4_bus_target,
         .get_dev_status = exynos4_bus_get_dev_status,
-        .exit           = exynos4_bus_exit,
 };
 
 static int exynos4210_init_tables(struct busfreq_data *data)
@@ -837,11 +718,11 @@ static int exynos4210_init_tables(struct busfreq_data *data)
                 data->top_divtable[i] = tmp;
         }
 
-#ifdef CONFIG_EXYNOS_ASV
-        tmp = exynos4_result_of_asv;
-#else
+        /*
+         * TODO: init tmp based on busfreq_data
+         * (device-tree or platform-data)
+         */
         tmp = 0; /* Max voltages for the reliability of the unknown */
-#endif
 
         pr_debug("ASV Group of Exynos4 is %d\n", tmp);
         /* Use merged grouping for voltage */
@@ -922,11 +803,7 @@ static int exynos4x12_init_tables(struct busfreq_data *data)
                 data->dmc_divtable[i] = tmp;
         }
 
-#ifdef CONFIG_EXYNOS_ASV
-        tmp = exynos4_result_of_asv;
-#else
         tmp = 0; /* Max voltages for the reliability of the unknown */
-#endif
 
         if (tmp > 8)
                 tmp = 0;
@@ -1020,6 +897,7 @@ unlock:
 static int exynos4_busfreq_probe(struct platform_device *pdev)
 {
         struct busfreq_data *data;
+        struct busfreq_ppmu_data *ppmu_data;
         struct dev_pm_opp *opp;
         struct device *dev = &pdev->dev;
         int err = 0;
@@ -1030,9 +908,19 @@ static int exynos4_busfreq_probe(struct platform_device *pdev)
                 return -ENOMEM;
         }
 
+        ppmu_data = &data->ppmu_data;
+        ppmu_data->ppmu_end = PPMU_END;
+        ppmu_data->ppmu = devm_kzalloc(dev,
+                                       sizeof(struct exynos_ppmu) * PPMU_END,
+                                       GFP_KERNEL);
+        if (!ppmu_data->ppmu) {
+                dev_err(dev, "Failed to allocate memory for exynos_ppmu\n");
+                return -ENOMEM;
+        }
+
         data->type = pdev->id_entry->driver_data;
-        data->dmc[0].hw_base = S5P_VA_DMC0;
-        data->dmc[1].hw_base = S5P_VA_DMC1;
+        ppmu_data->ppmu[PPMU_DMC0].hw_base = S5P_VA_DMC0;
+        ppmu_data->ppmu[PPMU_DMC1].hw_base = S5P_VA_DMC1;
         data->pm_notifier.notifier_call = exynos4_busfreq_pm_notifier_event;
         data->dev = dev;
         mutex_init(&data->lock);
@@ -1048,8 +936,11 @@ static int exynos4_busfreq_probe(struct platform_device *pdev)
                 dev_err(dev, "Cannot determine the device id %d\n", data->type);
                 err = -EINVAL;
         }
-        if (err)
+        if (err) {
+                dev_err(dev, "Cannot initialize busfreq table %d\n",
+                             data->type);
                 return err;
+        }
 
         data->vdd_int = devm_regulator_get(dev, "vdd_int");
         if (IS_ERR(data->vdd_int)) {
@@ -1079,19 +970,28 @@ static int exynos4_busfreq_probe(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, data);
 
-        busfreq_mon_reset(data);
-
-        data->devfreq = devfreq_add_device(dev, &exynos4_devfreq_profile,
+        data->devfreq = devm_devfreq_add_device(dev, &exynos4_devfreq_profile,
                                            "simple_ondemand", NULL);
         if (IS_ERR(data->devfreq))
                 return PTR_ERR(data->devfreq);
 
-        devfreq_register_opp_notifier(dev, data->devfreq);
+        /*
+         * Start PPMU (Performance Profiling Monitoring Unit) to check
+         * utilization of each IP in the Exynos4 SoC.
+         */
+        busfreq_mon_reset(ppmu_data);
 
+        /* Register opp_notifier for Exynos4 busfreq */
+        err = devm_devfreq_register_opp_notifier(dev, data->devfreq);
+        if (err < 0) {
+                dev_err(dev, "Failed to register opp notifier\n");
+                return err;
+        }
+
+        /* Register pm_notifier for Exynos4 busfreq */
         err = register_pm_notifier(&data->pm_notifier);
         if (err) {
                 dev_err(dev, "Failed to setup pm notifier\n");
-                devfreq_remove_device(data->devfreq);
                 return err;
         }
 
@@ -1102,23 +1002,24 @@ static int exynos4_busfreq_remove(struct platform_device *pdev)
 {
         struct busfreq_data *data = platform_get_drvdata(pdev);
 
+        /* Unregister all of notifier chain */
         unregister_pm_notifier(&data->pm_notifier);
-        devfreq_remove_device(data->devfreq);
 
         return 0;
 }
 
+#ifdef CONFIG_PM_SLEEP
 static int exynos4_busfreq_resume(struct device *dev)
 {
         struct busfreq_data *data = dev_get_drvdata(dev);
+        struct busfreq_ppmu_data *ppmu_data = &data->ppmu_data;
 
-        busfreq_mon_reset(data);
+        busfreq_mon_reset(ppmu_data);
         return 0;
 }
+#endif
 
-static const struct dev_pm_ops exynos4_busfreq_pm = {
-        .resume = exynos4_busfreq_resume,
-};
+static SIMPLE_DEV_PM_OPS(exynos4_busfreq_pm_ops, NULL, exynos4_busfreq_resume);
 
 static const struct platform_device_id exynos4_busfreq_id[] = {
         { "exynos4210-busfreq", TYPE_BUSF_EXYNOS4210 },
@@ -1134,7 +1035,7 @@ static struct platform_driver exynos4_busfreq_driver = {
         .driver = {
                 .name   = "exynos4-busfreq",
                 .owner  = THIS_MODULE,
-                .pm     = &exynos4_busfreq_pm,
+                .pm     = &exynos4_busfreq_pm_ops,
         },
 };
 
diff --git a/drivers/devfreq/exynos/exynos5_bus.c b/drivers/devfreq/exynos/exynos5_bus.c
index 6eef1f7397c6..6cd0392e2798 100644
--- a/drivers/devfreq/exynos/exynos5_bus.c
+++ b/drivers/devfreq/exynos/exynos5_bus.c
@@ -50,7 +50,7 @@ struct busfreq_data_int {
         struct device *dev;
         struct devfreq *devfreq;
         struct regulator *vdd_int;
-        struct exynos_ppmu ppmu[PPMU_END];
+        struct busfreq_ppmu_data ppmu_data;
         unsigned long curr_freq;
         bool disabled;
 
@@ -75,49 +75,6 @@ static struct int_bus_opp_table exynos5_int_opp_table[] = {
         {0, 0, 0},
 };
 
-static void busfreq_mon_reset(struct busfreq_data_int *data)
-{
-        unsigned int i;
-
-        for (i = PPMU_RIGHT; i < PPMU_END; i++) {
-                void __iomem *ppmu_base = data->ppmu[i].hw_base;
-
-                /* Reset the performance and cycle counters */
-                exynos_ppmu_reset(ppmu_base);
-
-                /* Setup count registers to monitor read/write transactions */
-                data->ppmu[i].event[PPMU_PMNCNT3] = RDWR_DATA_COUNT;
-                exynos_ppmu_setevent(ppmu_base, PPMU_PMNCNT3,
-                                        data->ppmu[i].event[PPMU_PMNCNT3]);
-
-                exynos_ppmu_start(ppmu_base);
-        }
-}
-
-static void exynos5_read_ppmu(struct busfreq_data_int *data)
-{
-        int i, j;
-
-        for (i = PPMU_RIGHT; i < PPMU_END; i++) {
-                void __iomem *ppmu_base = data->ppmu[i].hw_base;
-
-                exynos_ppmu_stop(ppmu_base);
-
-                /* Update local data from PPMU */
-                data->ppmu[i].ccnt = __raw_readl(ppmu_base + PPMU_CCNT);
-
-                for (j = PPMU_PMNCNT0; j < PPMU_PMNCNT_MAX; j++) {
-                        if (data->ppmu[i].event[j] == 0)
-                                data->ppmu[i].count[j] = 0;
-                        else
-                                data->ppmu[i].count[j] =
-                                        exynos_ppmu_read(ppmu_base, j);
-                }
-        }
-
-        busfreq_mon_reset(data);
-}
-
 static int exynos5_int_setvolt(struct busfreq_data_int *data,
                                 unsigned long volt)
 {
@@ -185,59 +142,33 @@ out:
         return err;
 }
 
-static int exynos5_get_busier_dmc(struct busfreq_data_int *data)
-{
-        int i, j;
-        int busy = 0;
-        unsigned int temp = 0;
-
-        for (i = PPMU_RIGHT; i < PPMU_END; i++) {
-                for (j = PPMU_PMNCNT0; j < PPMU_PMNCNT_MAX; j++) {
-                        if (data->ppmu[i].count[j] > temp) {
-                                temp = data->ppmu[i].count[j];
-                                busy = i;
-                        }
-                }
-        }
-
-        return busy;
-}
-
 static int exynos5_int_get_dev_status(struct device *dev,
                                       struct devfreq_dev_status *stat)
 {
         struct platform_device *pdev = container_of(dev, struct platform_device,
                                                     dev);
         struct busfreq_data_int *data = platform_get_drvdata(pdev);
+        struct busfreq_ppmu_data *ppmu_data = &data->ppmu_data;
         int busier_dmc;
 
-        exynos5_read_ppmu(data);
-        busier_dmc = exynos5_get_busier_dmc(data);
+        exynos_read_ppmu(ppmu_data);
+        busier_dmc = exynos_get_busier_ppmu(ppmu_data);
 
         stat->current_frequency = data->curr_freq;
 
         /* Number of cycles spent on memory access */
-        stat->busy_time = data->ppmu[busier_dmc].count[PPMU_PMNCNT3];
+        stat->busy_time = ppmu_data->ppmu[busier_dmc].count[PPMU_PMNCNT3];
         stat->busy_time *= 100 / INT_BUS_SATURATION_RATIO;
-        stat->total_time = data->ppmu[busier_dmc].ccnt;
+        stat->total_time = ppmu_data->ppmu[busier_dmc].ccnt;
 
         return 0;
 }
-static void exynos5_int_exit(struct device *dev)
-{
-        struct platform_device *pdev = container_of(dev, struct platform_device,
-                                                    dev);
-        struct busfreq_data_int *data = platform_get_drvdata(pdev);
-
-        devfreq_unregister_opp_notifier(dev, data->devfreq);
-}
 
 static struct devfreq_dev_profile exynos5_devfreq_int_profile = {
         .initial_freq           = 160000,
         .polling_ms             = 100,
         .target                 = exynos5_busfreq_int_target,
         .get_dev_status         = exynos5_int_get_dev_status,
-        .exit                   = exynos5_int_exit,
 };
 
 static int exynos5250_init_int_tables(struct busfreq_data_int *data)
@@ -315,6 +246,7 @@ unlock:
 static int exynos5_busfreq_int_probe(struct platform_device *pdev)
 {
         struct busfreq_data_int *data;
+        struct busfreq_ppmu_data *ppmu_data;
         struct dev_pm_opp *opp;
         struct device *dev = &pdev->dev;
         struct device_node *np;
@@ -330,16 +262,26 @@ static int exynos5_busfreq_int_probe(struct platform_device *pdev)
                 return -ENOMEM;
         }
 
+        ppmu_data = &data->ppmu_data;
+        ppmu_data->ppmu_end = PPMU_END;
+        ppmu_data->ppmu = devm_kzalloc(dev,
+                                       sizeof(struct exynos_ppmu) * PPMU_END,
+                                       GFP_KERNEL);
+        if (!ppmu_data->ppmu) {
+                dev_err(dev, "Failed to allocate memory for exynos_ppmu\n");
+                return -ENOMEM;
+        }
+
         np = of_find_compatible_node(NULL, NULL, "samsung,exynos5250-ppmu");
         if (np == NULL) {
                 pr_err("Unable to find PPMU node\n");
                 return -ENOENT;
         }
 
-        for (i = PPMU_RIGHT; i < PPMU_END; i++) {
+        for (i = 0; i < ppmu_data->ppmu_end; i++) {
                 /* map PPMU memory region */
-                data->ppmu[i].hw_base = of_iomap(np, i);
-                if (data->ppmu[i].hw_base == NULL) {
+                ppmu_data->ppmu[i].hw_base = of_iomap(np, i);
+                if (ppmu_data->ppmu[i].hw_base == NULL) {
                         dev_err(&pdev->dev, "failed to map memory region\n");
                         return -ENOMEM;
                 }
@@ -390,32 +332,29 @@ static int exynos5_busfreq_int_probe(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, data);
 
-        busfreq_mon_reset(data);
+        busfreq_mon_reset(ppmu_data);
 
-        data->devfreq = devfreq_add_device(dev, &exynos5_devfreq_int_profile,
+        data->devfreq = devm_devfreq_add_device(dev, &exynos5_devfreq_int_profile,
                                            "simple_ondemand", NULL);
+        if (IS_ERR(data->devfreq))
+                return PTR_ERR(data->devfreq);
 
-        if (IS_ERR(data->devfreq)) {
-                err = PTR_ERR(data->devfreq);
-                goto err_devfreq_add;
+        err = devm_devfreq_register_opp_notifier(dev, data->devfreq);
+        if (err < 0) {
+                dev_err(dev, "Failed to register opp notifier\n");
+                return err;
         }
 
-        devfreq_register_opp_notifier(dev, data->devfreq);
-
         err = register_pm_notifier(&data->pm_notifier);
         if (err) {
                 dev_err(dev, "Failed to setup pm notifier\n");
-                goto err_devfreq_add;
+                return err;
         }
 
         /* TODO: Add a new QOS class for int/mif bus */
         pm_qos_add_request(&data->int_req, PM_QOS_NETWORK_THROUGHPUT, -1);
 
         return 0;
-
-err_devfreq_add:
-        devfreq_remove_device(data->devfreq);
-        return err;
 }
 
 static int exynos5_busfreq_int_remove(struct platform_device *pdev)
@@ -424,24 +363,27 @@ static int exynos5_busfreq_int_remove(struct platform_device *pdev)
 
         pm_qos_remove_request(&data->int_req);
         unregister_pm_notifier(&data->pm_notifier);
-        devfreq_remove_device(data->devfreq);
 
         return 0;
 }
 
+#ifdef CONFIG_PM_SLEEP
 static int exynos5_busfreq_int_resume(struct device *dev)
 {
         struct platform_device *pdev = container_of(dev, struct platform_device,
                                                     dev);
         struct busfreq_data_int *data = platform_get_drvdata(pdev);
+        struct busfreq_ppmu_data *ppmu_data = &data->ppmu_data;
 
-        busfreq_mon_reset(data);
+        busfreq_mon_reset(ppmu_data);
         return 0;
 }
-
 static const struct dev_pm_ops exynos5_busfreq_int_pm = {
         .resume = exynos5_busfreq_int_resume,
 };
+#endif
+static SIMPLE_DEV_PM_OPS(exynos5_busfreq_int_pm_ops, NULL,
+                         exynos5_busfreq_int_resume);
 
 /* platform device pointer for exynos5 devfreq device. */
 static struct platform_device *exynos5_devfreq_pdev;
@@ -452,7 +394,7 @@ static struct platform_driver exynos5_busfreq_int_driver = {
         .driver         = {
                 .name           = "exynos5-bus-int",
                 .owner          = THIS_MODULE,
-                .pm             = &exynos5_busfreq_int_pm,
+                .pm             = &exynos5_busfreq_int_pm_ops,
         },
 };
 
diff --git a/drivers/devfreq/exynos/exynos_ppmu.c b/drivers/devfreq/exynos/exynos_ppmu.c
index 85fc5ac1036a..75fcc5140ffb 100644
--- a/drivers/devfreq/exynos/exynos_ppmu.c
+++ b/drivers/devfreq/exynos/exynos_ppmu.c
@@ -54,3 +54,63 @@ unsigned int exynos_ppmu_read(void __iomem *ppmu_base, unsigned int ch)
 
         return total;
 }
+
+void busfreq_mon_reset(struct busfreq_ppmu_data *ppmu_data)
+{
+        unsigned int i;
+
+        for (i = 0; i < ppmu_data->ppmu_end; i++) {
+                void __iomem *ppmu_base = ppmu_data->ppmu[i].hw_base;
+
+                /* Reset the performance and cycle counters */
+                exynos_ppmu_reset(ppmu_base);
+
+                /* Setup count registers to monitor read/write transactions */
+                ppmu_data->ppmu[i].event[PPMU_PMNCNT3] = RDWR_DATA_COUNT;
+                exynos_ppmu_setevent(ppmu_base, PPMU_PMNCNT3,
+                                        ppmu_data->ppmu[i].event[PPMU_PMNCNT3]);
+
+                exynos_ppmu_start(ppmu_base);
+        }
+}
+
+void exynos_read_ppmu(struct busfreq_ppmu_data *ppmu_data)
+{
+        int i, j;
+
+        for (i = 0; i < ppmu_data->ppmu_end; i++) {
+                void __iomem *ppmu_base = ppmu_data->ppmu[i].hw_base;
+
+                exynos_ppmu_stop(ppmu_base);
+
+                /* Update local data from PPMU */
+                ppmu_data->ppmu[i].ccnt = __raw_readl(ppmu_base + PPMU_CCNT);
+
+                for (j = PPMU_PMNCNT0; j < PPMU_PMNCNT_MAX; j++) {
+                        if (ppmu_data->ppmu[i].event[j] == 0)
+                                ppmu_data->ppmu[i].count[j] = 0;
+                        else
+                                ppmu_data->ppmu[i].count[j] =
+                                        exynos_ppmu_read(ppmu_base, j);
+                }
+        }
+
+        busfreq_mon_reset(ppmu_data);
+}
+
+int exynos_get_busier_ppmu(struct busfreq_ppmu_data *ppmu_data)
+{
+        unsigned int count = 0;
+        int i, j, busy = 0;
+
+        for (i = 0; i < ppmu_data->ppmu_end; i++) {
+                for (j = PPMU_PMNCNT0; j < PPMU_PMNCNT_MAX; j++) {
+                        if (ppmu_data->ppmu[i].count[j] > count) {
+                                count = ppmu_data->ppmu[i].count[j];
+                                busy = i;
+                        }
+                }
+        }
+
+        return busy;
+}
diff --git a/drivers/devfreq/exynos/exynos_ppmu.h b/drivers/devfreq/exynos/exynos_ppmu.h
index 7dfb221eaccd..71f17ba3563c 100644
--- a/drivers/devfreq/exynos/exynos_ppmu.h
+++ b/drivers/devfreq/exynos/exynos_ppmu.h
@@ -69,10 +69,18 @@ struct exynos_ppmu {
         bool count_overflow[PPMU_PMNCNT_MAX];
 };
 
+struct busfreq_ppmu_data {
+        struct exynos_ppmu *ppmu;
+        int ppmu_end;
+};
+
 void exynos_ppmu_reset(void __iomem *ppmu_base);
 void exynos_ppmu_setevent(void __iomem *ppmu_base, unsigned int ch,
                         unsigned int evt);
 void exynos_ppmu_start(void __iomem *ppmu_base);
 void exynos_ppmu_stop(void __iomem *ppmu_base);
 unsigned int exynos_ppmu_read(void __iomem *ppmu_base, unsigned int ch);
+void busfreq_mon_reset(struct busfreq_ppmu_data *ppmu_data);
+void exynos_read_ppmu(struct busfreq_ppmu_data *ppmu_data);
+int exynos_get_busier_ppmu(struct busfreq_ppmu_data *ppmu_data);
 #endif /* __DEVFREQ_EXYNOS_PPMU_H */
diff --git a/drivers/gpu/drm/nouveau/nouveau_backlight.c b/drivers/gpu/drm/nouveau/nouveau_backlight.c
index 630f6e84fc01..2c1e4aad7da3 100644
--- a/drivers/gpu/drm/nouveau/nouveau_backlight.c
+++ b/drivers/gpu/drm/nouveau/nouveau_backlight.c
@@ -31,7 +31,6 @@
  */
 
 #include <linux/backlight.h>
-#include <linux/acpi.h>
 
 #include "nouveau_drm.h"
 #include "nouveau_reg.h"
@@ -222,14 +221,6 @@ nouveau_backlight_init(struct drm_device *dev)
         struct nouveau_device *device = nv_device(drm->device);
         struct drm_connector *connector;
 
-#ifdef CONFIG_ACPI
-        if (acpi_video_backlight_support()) {
-                NV_INFO(drm, "ACPI backlight interface available, "
-                             "not registering our own\n");
-                return 0;
-        }
-#endif
-
         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
                 if (connector->connector_type != DRM_MODE_CONNECTOR_LVDS &&
                     connector->connector_type != DRM_MODE_CONNECTOR_eDP)
diff --git a/drivers/mfd/db8500-prcmu.c b/drivers/mfd/db8500-prcmu.c
index 7694e0700d34..b11fdd63eecd 100644
--- a/drivers/mfd/db8500-prcmu.c
+++ b/drivers/mfd/db8500-prcmu.c
@@ -1734,18 +1734,17 @@ static struct cpufreq_frequency_table db8500_cpufreq_table[] = {
 
 static long round_armss_rate(unsigned long rate)
 {
+        struct cpufreq_frequency_table *pos;
         long freq = 0;
-        int i = 0;
 
         /* cpufreq table frequencies is in KHz. */
         rate = rate / 1000;
 
         /* Find the corresponding arm opp from the cpufreq table. */
-        while (db8500_cpufreq_table[i].frequency != CPUFREQ_TABLE_END) {
-                freq = db8500_cpufreq_table[i].frequency;
+        cpufreq_for_each_entry(pos, db8500_cpufreq_table) {
+                freq = pos->frequency;
                 if (freq == rate)
                         break;
-                i++;
         }
 
         /* Return the last valid value, even if a match was not found. */
@@ -1886,23 +1885,21 @@ static void set_clock_rate(u8 clock, unsigned long rate)
 
 static int set_armss_rate(unsigned long rate)
 {
-        int i = 0;
+        struct cpufreq_frequency_table *pos;
 
         /* cpufreq table frequencies is in KHz. */
         rate = rate / 1000;
 
         /* Find the corresponding arm opp from the cpufreq table. */
-        while (db8500_cpufreq_table[i].frequency != CPUFREQ_TABLE_END) {
-                if (db8500_cpufreq_table[i].frequency == rate)
+        cpufreq_for_each_entry(pos, db8500_cpufreq_table)
+                if (pos->frequency == rate)
                         break;
-                i++;
-        }
 
-        if (db8500_cpufreq_table[i].frequency != rate)
+        if (pos->frequency != rate)
                 return -EINVAL;
 
         /* Set the new arm opp. */
-        return db8500_prcmu_set_arm_opp(db8500_cpufreq_table[i].driver_data);
+        return db8500_prcmu_set_arm_opp(pos->driver_data);
 }
 
 static int set_plldsi_rate(unsigned long rate)
diff --git a/drivers/net/irda/sh_sir.c b/drivers/net/irda/sh_sir.c
index cadf52e22464..e3fe9a286136 100644
--- a/drivers/net/irda/sh_sir.c
+++ b/drivers/net/irda/sh_sir.c
@@ -217,21 +217,17 @@ crc_init_out:
 static u32 sh_sir_find_sclk(struct clk *irda_clk)
 {
         struct cpufreq_frequency_table *freq_table = irda_clk->freq_table;
+        struct cpufreq_frequency_table *pos;
         struct clk *pclk = clk_get(NULL, "peripheral_clk");
         u32 limit, min = 0xffffffff, tmp;
-        int i, index = 0;
+        int index = 0;
 
         limit = clk_get_rate(pclk);
         clk_put(pclk);
 
         /* IrDA can not set over peripheral_clk */
-        for (i = 0;
-             freq_table[i].frequency != CPUFREQ_TABLE_END;
-             i++) {
-                u32 freq = freq_table[i].frequency;
-
-                if (freq == CPUFREQ_ENTRY_INVALID)
-                        continue;
+        cpufreq_for_each_valid_entry(pos, freq_table) {
+                u32 freq = pos->frequency;
 
                 /* IrDA should not over peripheral_clk */
                 if (freq > limit)
@@ -240,7 +236,7 @@ static u32 sh_sir_find_sclk(struct clk *irda_clk)
                 tmp = freq % SCLK_BASE;
                 if (tmp < min) {
                         min = tmp;
-                        index = i;
+                        index = pos - freq_table;
                 }
         }
 
diff --git a/drivers/platform/x86/acer-wmi.c b/drivers/platform/x86/acer-wmi.c
index c91f69b39db4..bbf78b2d6d93 100644
--- a/drivers/platform/x86/acer-wmi.c
+++ b/drivers/platform/x86/acer-wmi.c
@@ -570,6 +570,14 @@ static const struct dmi_system_id video_vendor_dmi_table[] = {
                         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5750"),
                 },
         },
+        {
+                .callback = video_set_backlight_video_vendor,
+                .ident = "Acer Aspire 5741",
+                .matches = {
+                        DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5741"),
+                },
+        },
         {}
 };
 
@@ -2228,7 +2236,7 @@ static int __init acer_wmi_init(void)
                 pr_info("Brightness must be controlled by acpi video driver\n");
         } else {
                 pr_info("Disabling ACPI video driver\n");
-                acpi_video_unregister();
+                acpi_video_unregister_backlight();
         }
 
         if (wmi_has_guid(WMID_GUID3)) {
diff --git a/drivers/pnp/pnpacpi/core.c b/drivers/pnp/pnpacpi/core.c
index c31aa07b3ba5..b81448b2c75d 100644
--- a/drivers/pnp/pnpacpi/core.c
+++ b/drivers/pnp/pnpacpi/core.c
@@ -30,26 +30,6 @@
 
 static int num;
 
-/* We need only to blacklist devices that have already an acpi driver that
- * can't use pnp layer. We don't need to blacklist device that are directly
- * used by the kernel (PCI root, ...), as it is harmless and there were
- * already present in pnpbios. But there is an exception for devices that
- * have irqs (PIC, Timer) because we call acpi_register_gsi.
- * Finally, only devices that have a CRS method need to be in this list.
- */
-static struct acpi_device_id excluded_id_list[] __initdata = {
-        {"PNP0C09", 0},         /* EC */
-        {"PNP0C0F", 0},         /* Link device */
-        {"PNP0000", 0},         /* PIC */
-        {"PNP0100", 0},         /* Timer */
-        {"", 0},
-};
-
-static inline int __init is_exclusive_device(struct acpi_device *dev)
-{
-        return (!acpi_match_device_ids(dev, excluded_id_list));
-}
-
 /*
  * Compatible Device IDs
  */
@@ -266,7 +246,7 @@ static int __init pnpacpi_add_device(struct acpi_device *device)
         if (!pnpid)
                 return 0;
 
-        if (is_exclusive_device(device) || !device->status.present)
+        if (!device->status.present)
                 return 0;
 
         dev = pnp_alloc_dev(&pnpacpi_protocol, num, pnpid);
@@ -326,10 +306,10 @@ static acpi_status __init pnpacpi_add_device_handler(acpi_handle handle,
 {
         struct acpi_device *device;
 
-        if (!acpi_bus_get_device(handle, &device))
-                pnpacpi_add_device(device);
-        else
+        if (acpi_bus_get_device(handle, &device))
                 return AE_CTRL_DEPTH;
+        if (acpi_is_pnp_device(device))
+                pnpacpi_add_device(device);
         return AE_OK;
 }
 
diff --git a/drivers/pnp/resource.c b/drivers/pnp/resource.c
index 01712cbfd92e..782e82289571 100644
--- a/drivers/pnp/resource.c
+++ b/drivers/pnp/resource.c
@@ -360,7 +360,7 @@ int pnp_check_irq(struct pnp_dev *dev, struct resource *res)
                 return 1;
 
         /* check if the resource is valid */
-        if (*irq < 0 || *irq > 15)
+        if (*irq > 15)
                 return 0;
 
         /* check if the resource is reserved */
@@ -424,7 +424,7 @@ int pnp_check_dma(struct pnp_dev *dev, struct resource *res)
                 return 1;
 
         /* check if the resource is valid */
-        if (*dma < 0 || *dma == 4 || *dma > 7)
+        if (*dma == 4 || *dma > 7)
                 return 0;
 
         /* check if the resource is reserved */
diff --git a/drivers/power/power_supply_core.c b/drivers/power/power_supply_core.c
index 26606641fe44..5a5a24e7d43c 100644
--- a/drivers/power/power_supply_core.c
+++ b/drivers/power/power_supply_core.c
@@ -537,7 +537,7 @@ static void psy_unregister_cooler(struct power_supply *psy)
 }
 #endif
 
-int power_supply_register(struct device *parent, struct power_supply *psy)
+int __power_supply_register(struct device *parent, struct power_supply *psy, bool ws)
 {
         struct device *dev;
         int rc;
@@ -568,7 +568,7 @@ int power_supply_register(struct device *parent, struct power_supply *psy)
         }
 
         spin_lock_init(&psy->changed_lock);
-        rc = device_init_wakeup(dev, true);
+        rc = device_init_wakeup(dev, ws);
         if (rc)
                 goto wakeup_init_failed;
 
@@ -606,8 +606,19 @@ dev_set_name_failed:
 success:
         return rc;
 }
+
+int power_supply_register(struct device *parent, struct power_supply *psy)
+{
+        return __power_supply_register(parent, psy, true);
+}
 EXPORT_SYMBOL_GPL(power_supply_register);
 
+int power_supply_register_no_ws(struct device *parent, struct power_supply *psy)
+{
+        return __power_supply_register(parent, psy, false);
+}
+EXPORT_SYMBOL_GPL(power_supply_register_no_ws);
+
 void power_supply_unregister(struct power_supply *psy)
 {
         cancel_work_sync(&psy->changed_work);
diff --git a/drivers/powercap/intel_rapl.c b/drivers/powercap/intel_rapl.c
index d9a0770b6c73..b1cda6ffdbcc 100644
--- a/drivers/powercap/intel_rapl.c
+++ b/drivers/powercap/intel_rapl.c
@@ -951,7 +951,9 @@ static const struct x86_cpu_id rapl_ids[] = {
         { X86_VENDOR_INTEL, 6, 0x2d},/* Sandy Bridge EP */
         { X86_VENDOR_INTEL, 6, 0x37},/* Valleyview */
         { X86_VENDOR_INTEL, 6, 0x3a},/* Ivy Bridge */
-        { X86_VENDOR_INTEL, 6, 0x45},/* Haswell */
+        { X86_VENDOR_INTEL, 6, 0x3c},/* Haswell */
+        { X86_VENDOR_INTEL, 6, 0x3d},/* Broadwell */
+        { X86_VENDOR_INTEL, 6, 0x45},/* Haswell ULT */
         /* TODO: Add more CPU IDs after testing */
         {}
 };
@@ -1124,8 +1126,7 @@ err_cleanup_package:
 static int rapl_check_domain(int cpu, int domain)
 {
         unsigned msr;
-        u64 val1, val2 = 0;
-        int retry = 0;
+        u64 val = 0;
 
         switch (domain) {
         case RAPL_DOMAIN_PACKAGE:
@@ -1144,26 +1145,13 @@ static int rapl_check_domain(int cpu, int domain)
                 pr_err("invalid domain id %d\n", domain);
                 return -EINVAL;
         }
-        if (rdmsrl_safe_on_cpu(cpu, msr, &val1))
-                return -ENODEV;
-
-        /* PP1/uncore/graphics domain may not be active at the time of
-         * driver loading. So skip further checks.
+        /* make sure domain counters are available and contains non-zero
+         * values, otherwise skip it.
          */
-        if (domain == RAPL_DOMAIN_PP1)
-                return 0;
-        /* energy counters roll slowly on some domains */
-        while (++retry < 10) {
-                usleep_range(10000, 15000);
-                rdmsrl_safe_on_cpu(cpu, msr, &val2);
-                if ((val1 & ENERGY_STATUS_MASK) != (val2 & ENERGY_STATUS_MASK))
-                        return 0;
-        }
-        /* if energy counter does not change, report as bad domain */
-        pr_info("domain %s energy ctr %llu:%llu not working, skip\n",
-                rapl_domain_names[domain], val1, val2);
+        if (rdmsrl_safe_on_cpu(cpu, msr, &val) || !val)
+                return -ENODEV;
 
-        return -ENODEV;
+        return 0;
 }
 
 /* Detect active and valid domains for the given CPU, caller must
@@ -1180,6 +1168,9 @@ static int rapl_detect_domains(struct rapl_package *rp, int cpu)
                 /* use physical package id to read counters */
                 if (!rapl_check_domain(cpu, i))
                         rp->domain_map |= 1 << i;
+                else
+                        pr_warn("RAPL domain %s detection failed\n",
+                                rapl_domain_names[i]);
         }
         rp->nr_domains = bitmap_weight(&rp->domain_map, RAPL_DOMAIN_MAX);
         if (!rp->nr_domains) {
diff --git a/drivers/sh/clk/core.c b/drivers/sh/clk/core.c
index 74727851820d..be56b22ca941 100644
--- a/drivers/sh/clk/core.c
+++ b/drivers/sh/clk/core.c
@@ -196,17 +196,11 @@ int clk_rate_table_find(struct clk *clk,
                         struct cpufreq_frequency_table *freq_table,
                         unsigned long rate)
 {
-        int i;
-
-        for (i = 0; freq_table[i].frequency != CPUFREQ_TABLE_END; i++) {
-                unsigned long freq = freq_table[i].frequency;
+        struct cpufreq_frequency_table *pos;
 
-                if (freq == CPUFREQ_ENTRY_INVALID)
-                        continue;
-
-                if (freq == rate)
-                        return i;
-        }
+        cpufreq_for_each_valid_entry(pos, freq_table)
+                if (pos->frequency == rate)
+                        return pos - freq_table;
 
         return -ENOENT;
 }
@@ -575,11 +569,7 @@ long clk_round_parent(struct clk *clk, unsigned long target,
                 return abs(target - *best_freq);
         }
 
-        for (freq = parent->freq_table; freq->frequency != CPUFREQ_TABLE_END;
-             freq++) {
-                if (freq->frequency == CPUFREQ_ENTRY_INVALID)
-                        continue;
-
+        cpufreq_for_each_valid_entry(freq, parent->freq_table) {
                 if (unlikely(freq->frequency / target <= div_min - 1)) {
                         unsigned long freq_max;
 
diff --git a/drivers/thermal/cpu_cooling.c b/drivers/thermal/cpu_cooling.c
index 4246262c4bd2..84a75f89bf74 100644
--- a/drivers/thermal/cpu_cooling.c
+++ b/drivers/thermal/cpu_cooling.c
@@ -144,11 +144,11 @@ static int get_property(unsigned int cpu, unsigned long input,
                         unsigned int *output,
                         enum cpufreq_cooling_property property)
 {
-        int i, j;
+        int i;
         unsigned long max_level = 0, level = 0;
         unsigned int freq = CPUFREQ_ENTRY_INVALID;
         int descend = -1;
-        struct cpufreq_frequency_table *table =
+        struct cpufreq_frequency_table *pos, *table =
                                         cpufreq_frequency_get_table(cpu);
 
         if (!output)
@@ -157,20 +157,16 @@ static int get_property(unsigned int cpu, unsigned long input,
         if (!table)
                 return -EINVAL;
 
-        for (i = 0; table[i].frequency != CPUFREQ_TABLE_END; i++) {
-                /* ignore invalid entries */
-                if (table[i].frequency == CPUFREQ_ENTRY_INVALID)
-                        continue;
-
+        cpufreq_for_each_valid_entry(pos, table) {
                 /* ignore duplicate entry */
-                if (freq == table[i].frequency)
+                if (freq == pos->frequency)
                         continue;
 
                 /* get the frequency order */
                 if (freq != CPUFREQ_ENTRY_INVALID && descend == -1)
-                        descend = !!(freq > table[i].frequency);
+                        descend = freq > pos->frequency;
 
-                freq = table[i].frequency;
+                freq = pos->frequency;
                 max_level++;
         }
 
@@ -190,29 +186,26 @@ static int get_property(unsigned int cpu, unsigned long input,
         if (property == GET_FREQ)
                 level = descend ? input : (max_level - input);
 
-        for (i = 0, j = 0; table[i].frequency != CPUFREQ_TABLE_END; i++) {
-                /* ignore invalid entry */
-                if (table[i].frequency == CPUFREQ_ENTRY_INVALID)
-                        continue;
-
+        i = 0;
+        cpufreq_for_each_valid_entry(pos, table) {
                 /* ignore duplicate entry */
-                if (freq == table[i].frequency)
+                if (freq == pos->frequency)
                         continue;
 
                 /* now we have a valid frequency entry */
-                freq = table[i].frequency;
+                freq = pos->frequency;
 
                 if (property == GET_LEVEL && (unsigned int)input == freq) {
                         /* get level by frequency */
-                        *output = descend ? j : (max_level - j);
+                        *output = descend ? i : (max_level - i);
                         return 0;
                 }
-                if (property == GET_FREQ && level == j) {
+                if (property == GET_FREQ && level == i) {
                         /* get frequency by level */
                         *output = freq;
                         return 0;
                 }
-                j++;
+                i++;
         }
 
         return -EINVAL;
diff --git a/drivers/video/backlight/backlight.c b/drivers/video/backlight/backlight.c
index bd2172c2d650..428089009cd5 100644
--- a/drivers/video/backlight/backlight.c
+++ b/drivers/video/backlight/backlight.c
@@ -23,6 +23,7 @@
 
 static struct list_head backlight_dev_list;
 static struct mutex backlight_dev_list_mutex;
+static struct blocking_notifier_head backlight_notifier;
 
 static const char *const backlight_types[] = {
         [BACKLIGHT_RAW] = "raw",
@@ -370,6 +371,9 @@ struct backlight_device *backlight_device_register(const char *name,
         list_add(&new_bd->entry, &backlight_dev_list);
         mutex_unlock(&backlight_dev_list_mutex);
 
+        blocking_notifier_call_chain(&backlight_notifier,
+                                     BACKLIGHT_REGISTERED, new_bd);
+
         return new_bd;
 }
 EXPORT_SYMBOL(backlight_device_register);
@@ -413,6 +417,10 @@ void backlight_device_unregister(struct backlight_device *bd)
                 pmac_backlight = NULL;
         mutex_unlock(&pmac_backlight_mutex);
 #endif
+
+        blocking_notifier_call_chain(&backlight_notifier,
+                                     BACKLIGHT_UNREGISTERED, bd);
+
         mutex_lock(&bd->ops_lock);
         bd->ops = NULL;
         mutex_unlock(&bd->ops_lock);
@@ -438,6 +446,36 @@ static int devm_backlight_device_match(struct device *dev, void *res,
 }
 
 /**
+ * backlight_register_notifier - get notified of backlight (un)registration
+ * @nb: notifier block with the notifier to call on backlight (un)registration
+ *
+ * @return 0 on success, otherwise a negative error code
+ *
+ * Register a notifier to get notified when backlight devices get registered
+ * or unregistered.
+ */
+int backlight_register_notifier(struct notifier_block *nb)
+{
+        return blocking_notifier_chain_register(&backlight_notifier, nb);
+}
+EXPORT_SYMBOL(backlight_register_notifier);
+
+/**
+ * backlight_unregister_notifier - unregister a backlight notifier
+ * @nb: notifier block to unregister
+ *
+ * @return 0 on success, otherwise a negative error code
+ *
+ * Register a notifier to get notified when backlight devices get registered
+ * or unregistered.
+ */
+int backlight_unregister_notifier(struct notifier_block *nb)
+{
+        return blocking_notifier_chain_unregister(&backlight_notifier, nb);
+}
+EXPORT_SYMBOL(backlight_unregister_notifier);
+
+/**
  * devm_backlight_device_register - resource managed backlight_device_register()
  * @dev: the device to register
  * @name: the name of the device
@@ -544,6 +582,8 @@ static int __init backlight_class_init(void)
         backlight_class->pm = &backlight_class_dev_pm_ops;
         INIT_LIST_HEAD(&backlight_dev_list);
         mutex_init(&backlight_dev_list_mutex);
+        BLOCKING_INIT_NOTIFIER_HEAD(&backlight_notifier);
+
         return 0;
 }