36 files changed, 2191 insertions, 378 deletions

diff --git a/drivers/acpi/Kconfig b/drivers/acpi/Kconfig
index b7e2e776397d..acad70a0bb0d 100644
--- a/drivers/acpi/Kconfig
+++ b/drivers/acpi/Kconfig
@@ -213,6 +213,10 @@ config ACPI_CPU_FREQ_PSS
         bool
         select THERMAL
 
+config ACPI_PROCESSOR_CSTATE
+        def_bool y
+        depends on IA64 || X86
+
 config ACPI_PROCESSOR_IDLE
         bool
         select CPU_IDLE
@@ -234,7 +238,7 @@ config ACPI_CPPC_LIB
 config ACPI_PROCESSOR
         tristate "Processor"
         depends on X86 || IA64 || ARM64
-        select ACPI_PROCESSOR_IDLE if X86 || IA64
+        select ACPI_PROCESSOR_IDLE
         select ACPI_CPU_FREQ_PSS if X86 || IA64
         default y
         help
@@ -291,8 +295,8 @@ config ACPI_THERMAL
 config ACPI_NUMA
         bool "NUMA support"
         depends on NUMA
-        depends on (X86 || IA64)
-        default y if IA64_GENERIC || IA64_SGI_SN2
+        depends on (X86 || IA64 || ARM64)
+        default y if IA64_GENERIC || IA64_SGI_SN2 || ARM64
 
 config ACPI_CUSTOM_DSDT_FILE
         string "Custom DSDT Table file to include"
@@ -311,9 +315,12 @@ config ACPI_CUSTOM_DSDT
         bool
         default ACPI_CUSTOM_DSDT_FILE != ""
 
+config ARCH_HAS_ACPI_TABLE_UPGRADE
+        def_bool n
+
 config ACPI_TABLE_UPGRADE
         bool "Allow upgrading ACPI tables via initrd"
-        depends on BLK_DEV_INITRD && X86
+        depends on BLK_DEV_INITRD && ARCH_HAS_ACPI_TABLE_UPGRADE
         default y
         help
           This option provides functionality to upgrade arbitrary ACPI tables
@@ -475,6 +482,7 @@ config ACPI_NFIT_DEBUG
           issue.
 
 source "drivers/acpi/apei/Kconfig"
+source "drivers/acpi/dptf/Kconfig"
 
 config ACPI_EXTLOG
         tristate "Extended Error Log support"
@@ -519,6 +527,20 @@ config XPOWER_PMIC_OPREGION
         help
           This config adds ACPI operation region support for XPower AXP288 PMIC.
 
+config BXT_WC_PMIC_OPREGION
+        bool "ACPI operation region support for BXT WhiskeyCove PMIC"
+        depends on INTEL_SOC_PMIC
+        help
+          This config adds ACPI operation region support for BXT WhiskeyCove PMIC.
+
 endif
 
+config ACPI_CONFIGFS
+        tristate "ACPI configfs support"
+        select CONFIGFS_FS
+        help
+          Select this option to enable support for ACPI configuration from
+          userspace. The configurable ACPI groups will be visible under
+          /config/acpi, assuming configfs is mounted under /config.
+
 endif   # ACPI
diff --git a/drivers/acpi/Makefile b/drivers/acpi/Makefile
index 251ce85a66fb..88f54f03e3d2 100644
--- a/drivers/acpi/Makefile
+++ b/drivers/acpi/Makefile
@@ -44,7 +44,6 @@ acpi-y				+= acpi_lpss.o acpi_apd.o
 acpi-y                          += acpi_platform.o
 acpi-y                          += acpi_pnp.o
 acpi-$(CONFIG_ARM_AMBA) += acpi_amba.o
-acpi-y                          += int340x_thermal.o
 acpi-y                          += power.o
 acpi-y                          += event.o
 acpi-$(CONFIG_ACPI_REDUCED_HARDWARE_ONLY) += evged.o
@@ -99,5 +98,9 @@ obj-$(CONFIG_ACPI_EXTLOG)	+= acpi_extlog.o
 obj-$(CONFIG_PMIC_OPREGION)     += pmic/intel_pmic.o
 obj-$(CONFIG_CRC_PMIC_OPREGION) += pmic/intel_pmic_crc.o
 obj-$(CONFIG_XPOWER_PMIC_OPREGION) += pmic/intel_pmic_xpower.o
+obj-$(CONFIG_BXT_WC_PMIC_OPREGION) += pmic/intel_pmic_bxtwc.o
+
+obj-$(CONFIG_ACPI_CONFIGFS)     += acpi_configfs.o
 
 video-objs                      += acpi_video.o video_detect.o
+obj-y                           += dptf/
diff --git a/drivers/acpi/acpi_configfs.c b/drivers/acpi/acpi_configfs.c
new file mode 100644
index 000000000000..146a77fb762d
--- /dev/null
+++ b/drivers/acpi/acpi_configfs.c
@@ -0,0 +1,267 @@
+/*
+ * ACPI configfs support
+ *
+ * Copyright (c) 2016 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.
+ */
+
+#define pr_fmt(fmt) "ACPI configfs: " fmt
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/configfs.h>
+#include <linux/acpi.h>
+
+static struct config_group *acpi_table_group;
+
+struct acpi_table {
+        struct config_item cfg;
+        struct acpi_table_header *header;
+};
+
+static ssize_t acpi_table_aml_write(struct config_item *cfg,
+                                    const void *data, size_t size)
+{
+        const struct acpi_table_header *header = data;
+        struct acpi_table *table;
+        int ret;
+
+        table = container_of(cfg, struct acpi_table, cfg);
+
+        if (table->header) {
+                pr_err("table already loaded\n");
+                return -EBUSY;
+        }
+
+        if (header->length != size) {
+                pr_err("invalid table length\n");
+                return -EINVAL;
+        }
+
+        if (memcmp(header->signature, ACPI_SIG_SSDT, 4)) {
+                pr_err("invalid table signature\n");
+                return -EINVAL;
+        }
+
+        table = container_of(cfg, struct acpi_table, cfg);
+
+        table->header = kmemdup(header, header->length, GFP_KERNEL);
+        if (!table->header)
+                return -ENOMEM;
+
+        ret = acpi_load_table(table->header);
+        if (ret) {
+                kfree(table->header);
+                table->header = NULL;
+        }
+
+        return ret;
+}
+
+static inline struct acpi_table_header *get_header(struct config_item *cfg)
+{
+        struct acpi_table *table = container_of(cfg, struct acpi_table, cfg);
+
+        if (!table->header)
+                pr_err("table not loaded\n");
+
+        return table->header;
+}
+
+static ssize_t acpi_table_aml_read(struct config_item *cfg,
+                                   void *data, size_t size)
+{
+        struct acpi_table_header *h = get_header(cfg);
+
+        if (!h)
+                return -EINVAL;
+
+        if (data)
+                memcpy(data, h, h->length);
+
+        return h->length;
+}
+
+#define MAX_ACPI_TABLE_SIZE (128 * 1024)
+
+CONFIGFS_BIN_ATTR(acpi_table_, aml, NULL, MAX_ACPI_TABLE_SIZE);
+
+struct configfs_bin_attribute *acpi_table_bin_attrs[] = {
+        &acpi_table_attr_aml,
+        NULL,
+};
+
+ssize_t acpi_table_signature_show(struct config_item *cfg, char *str)
+{
+        struct acpi_table_header *h = get_header(cfg);
+
+        if (!h)
+                return -EINVAL;
+
+        return sprintf(str, "%.*s\n", ACPI_NAME_SIZE, h->signature);
+}
+
+ssize_t acpi_table_length_show(struct config_item *cfg, char *str)
+{
+        struct acpi_table_header *h = get_header(cfg);
+
+        if (!h)
+                return -EINVAL;
+
+        return sprintf(str, "%d\n", h->length);
+}
+
+ssize_t acpi_table_revision_show(struct config_item *cfg, char *str)
+{
+        struct acpi_table_header *h = get_header(cfg);
+
+        if (!h)
+                return -EINVAL;
+
+        return sprintf(str, "%d\n", h->revision);
+}
+
+ssize_t acpi_table_oem_id_show(struct config_item *cfg, char *str)
+{
+        struct acpi_table_header *h = get_header(cfg);
+
+        if (!h)
+                return -EINVAL;
+
+        return sprintf(str, "%.*s\n", ACPI_OEM_ID_SIZE, h->oem_id);
+}
+
+ssize_t acpi_table_oem_table_id_show(struct config_item *cfg, char *str)
+{
+        struct acpi_table_header *h = get_header(cfg);
+
+        if (!h)
+                return -EINVAL;
+
+        return sprintf(str, "%.*s\n", ACPI_OEM_TABLE_ID_SIZE, h->oem_table_id);
+}
+
+ssize_t acpi_table_oem_revision_show(struct config_item *cfg, char *str)
+{
+        struct acpi_table_header *h = get_header(cfg);
+
+        if (!h)
+                return -EINVAL;
+
+        return sprintf(str, "%d\n", h->oem_revision);
+}
+
+ssize_t acpi_table_asl_compiler_id_show(struct config_item *cfg, char *str)
+{
+        struct acpi_table_header *h = get_header(cfg);
+
+        if (!h)
+                return -EINVAL;
+
+        return sprintf(str, "%.*s\n", ACPI_NAME_SIZE, h->asl_compiler_id);
+}
+
+ssize_t acpi_table_asl_compiler_revision_show(struct config_item *cfg,
+                                              char *str)
+{
+        struct acpi_table_header *h = get_header(cfg);
+
+        if (!h)
+                return -EINVAL;
+
+        return sprintf(str, "%d\n", h->asl_compiler_revision);
+}
+
+CONFIGFS_ATTR_RO(acpi_table_, signature);
+CONFIGFS_ATTR_RO(acpi_table_, length);
+CONFIGFS_ATTR_RO(acpi_table_, revision);
+CONFIGFS_ATTR_RO(acpi_table_, oem_id);
+CONFIGFS_ATTR_RO(acpi_table_, oem_table_id);
+CONFIGFS_ATTR_RO(acpi_table_, oem_revision);
+CONFIGFS_ATTR_RO(acpi_table_, asl_compiler_id);
+CONFIGFS_ATTR_RO(acpi_table_, asl_compiler_revision);
+
+struct configfs_attribute *acpi_table_attrs[] = {
+        &acpi_table_attr_signature,
+        &acpi_table_attr_length,
+        &acpi_table_attr_revision,
+        &acpi_table_attr_oem_id,
+        &acpi_table_attr_oem_table_id,
+        &acpi_table_attr_oem_revision,
+        &acpi_table_attr_asl_compiler_id,
+        &acpi_table_attr_asl_compiler_revision,
+        NULL,
+};
+
+static struct config_item_type acpi_table_type = {
+        .ct_owner = THIS_MODULE,
+        .ct_bin_attrs = acpi_table_bin_attrs,
+        .ct_attrs = acpi_table_attrs,
+};
+
+static struct config_item *acpi_table_make_item(struct config_group *group,
+                                                const char *name)
+{
+        struct acpi_table *table;
+
+        table = kzalloc(sizeof(*table), GFP_KERNEL);
+        if (!table)
+                return ERR_PTR(-ENOMEM);
+
+        config_item_init_type_name(&table->cfg, name, &acpi_table_type);
+        return &table->cfg;
+}
+
+struct configfs_group_operations acpi_table_group_ops = {
+        .make_item = acpi_table_make_item,
+};
+
+static struct config_item_type acpi_tables_type = {
+        .ct_owner = THIS_MODULE,
+        .ct_group_ops = &acpi_table_group_ops,
+};
+
+static struct config_item_type acpi_root_group_type = {
+        .ct_owner = THIS_MODULE,
+};
+
+static struct configfs_subsystem acpi_configfs = {
+        .su_group = {
+                .cg_item = {
+                        .ci_namebuf = "acpi",
+                        .ci_type = &acpi_root_group_type,
+                },
+        },
+        .su_mutex = __MUTEX_INITIALIZER(acpi_configfs.su_mutex),
+};
+
+static int __init acpi_configfs_init(void)
+{
+        int ret;
+        struct config_group *root = &acpi_configfs.su_group;
+
+        config_group_init(root);
+
+        ret = configfs_register_subsystem(&acpi_configfs);
+        if (ret)
+                return ret;
+
+        acpi_table_group = configfs_register_default_group(root, "table",
+                                                           &acpi_tables_type);
+        return PTR_ERR_OR_ZERO(acpi_table_group);
+}
+module_init(acpi_configfs_init);
+
+static void __exit acpi_configfs_exit(void)
+{
+        configfs_unregister_default_group(acpi_table_group);
+        configfs_unregister_subsystem(&acpi_configfs);
+}
+module_exit(acpi_configfs_exit);
+
+MODULE_AUTHOR("Octavian Purdila <octavian.purdila@intel.com>");
+MODULE_DESCRIPTION("ACPI configfs support");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/acpi/acpi_lpat.c b/drivers/acpi/acpi_lpat.c
index feb61c1630eb..c1c4877ca96c 100644
--- a/drivers/acpi/acpi_lpat.c
+++ b/drivers/acpi/acpi_lpat.c
@@ -13,7 +13,7 @@
  * GNU General Public License for more details.
  */
 
-#include <linux/module.h>
+#include <linux/export.h>
 #include <linux/acpi.h>
 #include <acpi/acpi_lpat.h>
 
@@ -157,5 +157,3 @@ void acpi_lpat_free_conversion_table(struct acpi_lpat_conversion_table
         }
 }
 EXPORT_SYMBOL_GPL(acpi_lpat_free_conversion_table);
-
-MODULE_LICENSE("GPL");
diff --git a/drivers/acpi/acpi_lpss.c b/drivers/acpi/acpi_lpss.c
index 0872d5fecb82..357a0b8f860b 100644
--- a/drivers/acpi/acpi_lpss.c
+++ b/drivers/acpi/acpi_lpss.c
@@ -29,6 +29,7 @@ ACPI_MODULE_NAME("acpi_lpss");
 #ifdef CONFIG_X86_INTEL_LPSS
 
 #include <asm/cpu_device_id.h>
+#include <asm/intel-family.h>
 #include <asm/iosf_mbi.h>
 #include <asm/pmc_atom.h>
 
@@ -229,8 +230,8 @@ static const struct lpss_device_desc bsw_spi_dev_desc = {
 #define ICPU(model)     { X86_VENDOR_INTEL, 6, model, X86_FEATURE_ANY, }
 
 static const struct x86_cpu_id lpss_cpu_ids[] = {
-        ICPU(0x37),     /* Valleyview, Bay Trail */
-        ICPU(0x4c),     /* Braswell, Cherry Trail */
+        ICPU(INTEL_FAM6_ATOM_SILVERMONT1),      /* Valleyview, Bay Trail */
+        ICPU(INTEL_FAM6_ATOM_AIRMONT),  /* Braswell, Cherry Trail */
         {}
 };
 
diff --git a/drivers/acpi/acpi_video.c b/drivers/acpi/acpi_video.c
index c1d138e128cb..c5557d070954 100644
--- a/drivers/acpi/acpi_video.c
+++ b/drivers/acpi/acpi_video.c
@@ -1246,6 +1246,9 @@ static int acpi_video_device_enumerate(struct acpi_video_bus *video)
         union acpi_object *dod = NULL;
         union acpi_object *obj;
 
+        if (!video->cap._DOD)
+                return AE_NOT_EXIST;
+
         status = acpi_evaluate_object(video->device->handle, "_DOD", NULL, &buffer);
         if (!ACPI_SUCCESS(status)) {
                 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _DOD"));
diff --git a/drivers/acpi/apei/Makefile b/drivers/acpi/apei/Makefile
index 5d575a955940..e50573de25f1 100644
--- a/drivers/acpi/apei/Makefile
+++ b/drivers/acpi/apei/Makefile
@@ -3,4 +3,4 @@ obj-$(CONFIG_ACPI_APEI_GHES)	+= ghes.o
 obj-$(CONFIG_ACPI_APEI_EINJ)    += einj.o
 obj-$(CONFIG_ACPI_APEI_ERST_DEBUG) += erst-dbg.o
 
-apei-y := apei-base.o hest.o erst.o
+apei-y := apei-base.o hest.o erst.o bert.o
diff --git a/drivers/acpi/apei/apei-internal.h b/drivers/acpi/apei/apei-internal.h
index 16129c78b489..6e9f14c0a71b 100644
--- a/drivers/acpi/apei/apei-internal.h
+++ b/drivers/acpi/apei/apei-internal.h
@@ -1,6 +1,6 @@
 /*
  * apei-internal.h - ACPI Platform Error Interface internal
- * definations.
+ * definitions.
  */
 
 #ifndef APEI_INTERNAL_H
diff --git a/drivers/acpi/apei/bert.c b/drivers/acpi/apei/bert.c
new file mode 100644
index 000000000000..a05b5c0cf181
--- /dev/null
+++ b/drivers/acpi/apei/bert.c
@@ -0,0 +1,150 @@
+/*
+ * APEI Boot Error Record Table (BERT) support
+ *
+ * Copyright 2011 Intel Corp.
+ *   Author: Huang Ying <ying.huang@intel.com>
+ *
+ * Under normal circumstances, when a hardware error occurs, the error
+ * handler receives control and processes the error. This gives OSPM a
+ * chance to process the error condition, report it, and optionally attempt
+ * recovery. In some cases, the system is unable to process an error.
+ * For example, system firmware or a management controller may choose to
+ * reset the system or the system might experience an uncontrolled crash
+ * or reset.The boot error source is used to report unhandled errors that
+ * occurred in a previous boot. This mechanism is described in the BERT
+ * table.
+ *
+ * For more information about BERT, please refer to ACPI Specification
+ * version 4.0, section 17.3.1
+ *
+ * This file is licensed under GPLv2.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/acpi.h>
+#include <linux/io.h>
+
+#include "apei-internal.h"
+
+#undef pr_fmt
+#define pr_fmt(fmt) "BERT: " fmt
+
+static int bert_disable;
+
+static void __init bert_print_all(struct acpi_bert_region *region,
+                                  unsigned int region_len)
+{
+        struct acpi_hest_generic_status *estatus =
+                (struct acpi_hest_generic_status *)region;
+        int remain = region_len;
+        u32 estatus_len;
+
+        if (!estatus->block_status)
+                return;
+
+        while (remain > sizeof(struct acpi_bert_region)) {
+                if (cper_estatus_check(estatus)) {
+                        pr_err(FW_BUG "Invalid error record.\n");
+                        return;
+                }
+
+                estatus_len = cper_estatus_len(estatus);
+                if (remain < estatus_len) {
+                        pr_err(FW_BUG "Truncated status block (length: %u).\n",
+                               estatus_len);
+                        return;
+                }
+
+                pr_info_once("Error records from previous boot:\n");
+
+                cper_estatus_print(KERN_INFO HW_ERR, estatus);
+
+                /*
+                 * Because the boot error source is "one-time polled" type,
+                 * clear Block Status of current Generic Error Status Block,
+                 * once it's printed.
+                 */
+                estatus->block_status = 0;
+
+                estatus = (void *)estatus + estatus_len;
+                /* No more error records. */
+                if (!estatus->block_status)
+                        return;
+
+                remain -= estatus_len;
+        }
+}
+
+static int __init setup_bert_disable(char *str)
+{
+        bert_disable = 1;
+
+        return 0;
+}
+__setup("bert_disable", setup_bert_disable);
+
+static int __init bert_check_table(struct acpi_table_bert *bert_tab)
+{
+        if (bert_tab->header.length < sizeof(struct acpi_table_bert) ||
+            bert_tab->region_length < sizeof(struct acpi_bert_region))
+                return -EINVAL;
+
+        return 0;
+}
+
+static int __init bert_init(void)
+{
+        struct acpi_bert_region *boot_error_region;
+        struct acpi_table_bert *bert_tab;
+        unsigned int region_len;
+        acpi_status status;
+        int rc = 0;
+
+        if (acpi_disabled)
+                return 0;
+
+        if (bert_disable) {
+                pr_info("Boot Error Record Table support is disabled.\n");
+                return 0;
+        }
+
+        status = acpi_get_table(ACPI_SIG_BERT, 0, (struct acpi_table_header **)&bert_tab);
+        if (status == AE_NOT_FOUND)
+                return 0;
+
+        if (ACPI_FAILURE(status)) {
+                pr_err("get table failed, %s.\n", acpi_format_exception(status));
+                return -EINVAL;
+        }
+
+        rc = bert_check_table(bert_tab);
+        if (rc) {
+                pr_err(FW_BUG "table invalid.\n");
+                return rc;
+        }
+
+        region_len = bert_tab->region_length;
+        if (!request_mem_region(bert_tab->address, region_len, "APEI BERT")) {
+                pr_err("Can't request iomem region <%016llx-%016llx>.\n",
+                       (unsigned long long)bert_tab->address,
+                       (unsigned long long)bert_tab->address + region_len - 1);
+                return -EIO;
+        }
+
+        boot_error_region = ioremap_cache(bert_tab->address, region_len);
+        if (boot_error_region) {
+                bert_print_all(boot_error_region, region_len);
+                iounmap(boot_error_region);
+        } else {
+                rc = -ENOMEM;
+        }
+
+        release_mem_region(bert_tab->address, region_len);
+
+        return rc;
+}
+
+late_initcall(bert_init);
diff --git a/drivers/acpi/apei/einj.c b/drivers/acpi/apei/einj.c
index 559c1173de1c..eebb7e39c49c 100644
--- a/drivers/acpi/apei/einj.c
+++ b/drivers/acpi/apei/einj.c
@@ -33,7 +33,8 @@
 
 #include "apei-internal.h"
 
-#define EINJ_PFX "EINJ: "
+#undef pr_fmt
+#define pr_fmt(fmt) "EINJ: " fmt
 
 #define SPIN_UNIT               100                     /* 100ns */
 /* Firmware should respond within 1 milliseconds */
@@ -179,8 +180,7 @@ static int einj_get_available_error_type(u32 *type)
 static int einj_timedout(u64 *t)
 {
         if ((s64)*t < SPIN_UNIT) {
-                pr_warning(FW_WARN EINJ_PFX
-                           "Firmware does not respond in time\n");
+                pr_warning(FW_WARN "Firmware does not respond in time\n");
                 return 1;
         }
         *t -= SPIN_UNIT;
@@ -307,8 +307,7 @@ static int __einj_error_trigger(u64 trigger_paddr, u32 type,
         r = request_mem_region(trigger_paddr, sizeof(*trigger_tab),
                                "APEI EINJ Trigger Table");
         if (!r) {
-                pr_err(EINJ_PFX
-        "Can not request [mem %#010llx-%#010llx] for Trigger table\n",
+                pr_err("Can not request [mem %#010llx-%#010llx] for Trigger table\n",
                        (unsigned long long)trigger_paddr,
                        (unsigned long long)trigger_paddr +
                             sizeof(*trigger_tab) - 1);
@@ -316,13 +315,12 @@ static int __einj_error_trigger(u64 trigger_paddr, u32 type,
         }
         trigger_tab = ioremap_cache(trigger_paddr, sizeof(*trigger_tab));
         if (!trigger_tab) {
-                pr_err(EINJ_PFX "Failed to map trigger table!\n");
+                pr_err("Failed to map trigger table!\n");
                 goto out_rel_header;
         }
         rc = einj_check_trigger_header(trigger_tab);
         if (rc) {
-                pr_warning(FW_BUG EINJ_PFX
-                           "The trigger error action table is invalid\n");
+                pr_warning(FW_BUG "Invalid trigger error action table.\n");
                 goto out_rel_header;
         }
 
@@ -336,8 +334,7 @@ static int __einj_error_trigger(u64 trigger_paddr, u32 type,
                                table_size - sizeof(*trigger_tab),
                                "APEI EINJ Trigger Table");
         if (!r) {
-                pr_err(EINJ_PFX
-"Can not request [mem %#010llx-%#010llx] for Trigger Table Entry\n",
+                pr_err("Can not request [mem %#010llx-%#010llx] for Trigger Table Entry\n",
                        (unsigned long long)trigger_paddr + sizeof(*trigger_tab),
                        (unsigned long long)trigger_paddr + table_size - 1);
                 goto out_rel_header;
@@ -345,7 +342,7 @@ static int __einj_error_trigger(u64 trigger_paddr, u32 type,
         iounmap(trigger_tab);
         trigger_tab = ioremap_cache(trigger_paddr, table_size);
         if (!trigger_tab) {
-                pr_err(EINJ_PFX "Failed to map trigger table!\n");
+                pr_err("Failed to map trigger table!\n");
                 goto out_rel_entry;
         }
         trigger_entry = (struct acpi_whea_header *)
@@ -695,34 +692,42 @@ static int __init einj_init(void)
         struct dentry *fentry;
         struct apei_exec_context ctx;
 
-        if (acpi_disabled)
+        if (acpi_disabled) {
+                pr_warn("ACPI disabled.\n");
                 return -ENODEV;
+        }
 
         status = acpi_get_table(ACPI_SIG_EINJ, 0,
                                 (struct acpi_table_header **)&einj_tab);
-        if (status == AE_NOT_FOUND)
+        if (status == AE_NOT_FOUND) {
+                pr_warn("EINJ table not found.\n");
                 return -ENODEV;
+        }
         else if (ACPI_FAILURE(status)) {
-                const char *msg = acpi_format_exception(status);
-                pr_err(EINJ_PFX "Failed to get table, %s\n", msg);
+                pr_err("Failed to get EINJ table: %s\n",
+                                acpi_format_exception(status));
                 return -EINVAL;
         }
 
         rc = einj_check_table(einj_tab);
         if (rc) {
-                pr_warning(FW_BUG EINJ_PFX "EINJ table is invalid\n");
+                pr_warn(FW_BUG "Invalid EINJ table.n");
                 return -EINVAL;
         }
 
         rc = -ENOMEM;
         einj_debug_dir = debugfs_create_dir("einj", apei_get_debugfs_dir());
-        if (!einj_debug_dir)
+        if (!einj_debug_dir) {
+                pr_err("Error creating debugfs node.\n");
                 goto err_cleanup;
+        }
+
         fentry = debugfs_create_file("available_error_type", S_IRUSR,
                                      einj_debug_dir, NULL,
                                      &available_error_type_fops);
         if (!fentry)
                 goto err_cleanup;
+
         fentry = debugfs_create_file("error_type", S_IRUSR | S_IWUSR,
                                      einj_debug_dir, NULL, &error_type_fops);
         if (!fentry)
@@ -735,14 +740,22 @@ static int __init einj_init(void)
         apei_resources_init(&einj_resources);
         einj_exec_ctx_init(&ctx);
         rc = apei_exec_collect_resources(&ctx, &einj_resources);
-        if (rc)
+        if (rc) {
+                pr_err("Error collecting EINJ resources.\n");
                 goto err_fini;
+        }
+
         rc = apei_resources_request(&einj_resources, "APEI EINJ");
-        if (rc)
+        if (rc) {
+                pr_err("Error requesting memory/port resources.\n");
                 goto err_fini;
+        }
+
         rc = apei_exec_pre_map_gars(&ctx);
-        if (rc)
+        if (rc) {
+                pr_err("Error pre-mapping GARs.\n");
                 goto err_release;
+        }
 
         rc = -ENOMEM;
         einj_param = einj_get_parameter_address();
@@ -787,7 +800,7 @@ static int __init einj_init(void)
                         goto err_unmap;
         }
 
-        pr_info(EINJ_PFX "Error INJection is initialized.\n");
+        pr_info("Error INJection is initialized.\n");
 
         return 0;
 
@@ -798,6 +811,7 @@ err_unmap:
                         sizeof(struct einj_parameter);
 
                 acpi_os_unmap_iomem(einj_param, size);
+                pr_err("Error creating param extension debugfs nodes.\n");
         }
         apei_exec_post_unmap_gars(&ctx);
 err_release:
@@ -805,6 +819,7 @@ err_release:
 err_fini:
         apei_resources_fini(&einj_resources);
 err_cleanup:
+        pr_err("Error creating primary debugfs nodes.\n");
         debugfs_remove_recursive(einj_debug_dir);
 
         return rc;
diff --git a/drivers/acpi/bus.c b/drivers/acpi/bus.c
index 262ca31b86d9..85b7d07fe5c8 100644
--- a/drivers/acpi/bus.c
+++ b/drivers/acpi/bus.c
@@ -30,6 +30,9 @@
 #include <linux/acpi.h>
 #include <linux/slab.h>
 #include <linux/regulator/machine.h>
+#include <linux/workqueue.h>
+#include <linux/reboot.h>
+#include <linux/delay.h>
 #ifdef CONFIG_X86
 #include <asm/mpspec.h>
 #endif
@@ -174,22 +177,17 @@ void acpi_bus_detach_private_data(acpi_handle handle)
 EXPORT_SYMBOL_GPL(acpi_bus_detach_private_data);
 
 static void acpi_print_osc_error(acpi_handle handle,
-        struct acpi_osc_context *context, char *error)
+                                 struct acpi_osc_context *context, char *error)
 {
-        struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER};
         int i;
 
-        if (ACPI_FAILURE(acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer)))
-                printk(KERN_DEBUG "%s: %s\n", context->uuid_str, error);
-        else {
-                printk(KERN_DEBUG "%s (%s): %s\n",
-                       (char *)buffer.pointer, context->uuid_str, error);
-                kfree(buffer.pointer);
-        }
-        printk(KERN_DEBUG "_OSC request data:");
+        acpi_handle_debug(handle, "(%s): %s\n", context->uuid_str, error);
+
+        pr_debug("_OSC request data:");
         for (i = 0; i < context->cap.length; i += sizeof(u32))
-                printk(" %x", *((u32 *)(context->cap.pointer + i)));
-        printk("\n");
+                pr_debug(" %x", *((u32 *)(context->cap.pointer + i)));
+
+        pr_debug("\n");
 }
 
 acpi_status acpi_str_to_uuid(char *str, u8 *uuid)
@@ -302,6 +300,14 @@ out_kfree:
 EXPORT_SYMBOL(acpi_run_osc);
 
 bool osc_sb_apei_support_acked;
+
+/*
+ * ACPI 6.0 Section 8.4.4.2 Idle State Coordination
+ * OSPM supports platform coordinated low power idle(LPI) states
+ */
+bool osc_pc_lpi_support_confirmed;
+EXPORT_SYMBOL_GPL(osc_pc_lpi_support_confirmed);
+
 static u8 sb_uuid_str[] = "0811B06E-4A27-44F9-8D60-3CBBC22E7B48";
 static void acpi_bus_osc_support(void)
 {
@@ -322,6 +328,7 @@ static void acpi_bus_osc_support(void)
                 capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_PPC_OST_SUPPORT;
 
         capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_HOTPLUG_OST_SUPPORT;
+        capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_PCLPI_SUPPORT;
 
         if (!ghes_disable)
                 capbuf[OSC_SUPPORT_DWORD] |= OSC_SB_APEI_SUPPORT;
@@ -329,9 +336,12 @@ static void acpi_bus_osc_support(void)
                 return;
         if (ACPI_SUCCESS(acpi_run_osc(handle, &context))) {
                 u32 *capbuf_ret = context.ret.pointer;
-                if (context.ret.length > OSC_SUPPORT_DWORD)
+                if (context.ret.length > OSC_SUPPORT_DWORD) {
                         osc_sb_apei_support_acked =
                                 capbuf_ret[OSC_SUPPORT_DWORD] & OSC_SB_APEI_SUPPORT;
+                        osc_pc_lpi_support_confirmed =
+                                capbuf_ret[OSC_SUPPORT_DWORD] & OSC_SB_PCLPI_SUPPORT;
+                }
                 kfree(context.ret.pointer);
         }
         /* do we need to check other returned cap? Sounds no */
@@ -475,6 +485,56 @@ static void acpi_device_remove_notify_handler(struct acpi_device *device)
                                            acpi_device_notify);
 }
 
+/* Handle events targeting \_SB device (at present only graceful shutdown) */
+
+#define ACPI_SB_NOTIFY_SHUTDOWN_REQUEST 0x81
+#define ACPI_SB_INDICATE_INTERVAL       10000
+
+static void sb_notify_work(struct work_struct *dummy)
+{
+        acpi_handle sb_handle;
+
+        orderly_poweroff(true);
+
+        /*
+         * After initiating graceful shutdown, the ACPI spec requires OSPM
+         * to evaluate _OST method once every 10seconds to indicate that
+         * the shutdown is in progress
+         */
+        acpi_get_handle(NULL, "\\_SB", &sb_handle);
+        while (1) {
+                pr_info("Graceful shutdown in progress.\n");
+                acpi_evaluate_ost(sb_handle, ACPI_OST_EC_OSPM_SHUTDOWN,
+                                ACPI_OST_SC_OS_SHUTDOWN_IN_PROGRESS, NULL);
+                msleep(ACPI_SB_INDICATE_INTERVAL);
+        }
+}
+
+static void acpi_sb_notify(acpi_handle handle, u32 event, void *data)
+{
+        static DECLARE_WORK(acpi_sb_work, sb_notify_work);
+
+        if (event == ACPI_SB_NOTIFY_SHUTDOWN_REQUEST) {
+                if (!work_busy(&acpi_sb_work))
+                        schedule_work(&acpi_sb_work);
+        } else
+                pr_warn("event %x is not supported by \\_SB device\n", event);
+}
+
+static int __init acpi_setup_sb_notify_handler(void)
+{
+        acpi_handle sb_handle;
+
+        if (ACPI_FAILURE(acpi_get_handle(NULL, "\\_SB", &sb_handle)))
+                return -ENXIO;
+
+        if (ACPI_FAILURE(acpi_install_notify_handler(sb_handle, ACPI_DEVICE_NOTIFY,
+                                                acpi_sb_notify, NULL)))
+                return -EINVAL;
+
+        return 0;
+}
+
 /* --------------------------------------------------------------------------
                              Device Matching
    -------------------------------------------------------------------------- */
@@ -961,8 +1021,7 @@ void __init acpi_early_init(void)
 /**
  * acpi_subsystem_init - Finalize the early initialization of ACPI.
  *
- * Switch over the platform to the ACPI mode (if possible), initialize the
- * handling of ACPI events, install the interrupt and global lock handlers.
+ * Switch over the platform to the ACPI mode (if possible).
  *
  * Doing this too early is generally unsafe, but at the same time it needs to be
  * done before all things that really depend on ACPI.  The right spot appears to
@@ -990,6 +1049,13 @@ void __init acpi_subsystem_init(void)
         }
 }
 
+static acpi_status acpi_bus_table_handler(u32 event, void *table, void *context)
+{
+        acpi_scan_table_handler(event, table, context);
+
+        return acpi_sysfs_table_handler(event, table, context);
+}
+
 static int __init acpi_bus_init(void)
 {
         int result;
@@ -1043,6 +1109,8 @@ static int __init acpi_bus_init(void)
          * _PDC control method may load dynamic SSDT tables,
          * and we need to install the table handler before that.
          */
+        status = acpi_install_table_handler(acpi_bus_table_handler, NULL);
+
         acpi_sysfs_init();
 
         acpi_early_processor_set_pdc();
@@ -1124,6 +1192,7 @@ static int __init acpi_init(void)
         acpi_sleep_proc_init();
         acpi_wakeup_device_init();
         acpi_debugger_init();
+        acpi_setup_sb_notify_handler();
         return 0;
 }
 
diff --git a/drivers/acpi/button.c b/drivers/acpi/button.c
index 5c3b0918d5fd..148f4e5ca104 100644
--- a/drivers/acpi/button.c
+++ b/drivers/acpi/button.c
@@ -53,6 +53,10 @@
 #define ACPI_BUTTON_DEVICE_NAME_LID     "Lid Switch"
 #define ACPI_BUTTON_TYPE_LID            0x05
 
+#define ACPI_BUTTON_LID_INIT_IGNORE     0x00
+#define ACPI_BUTTON_LID_INIT_OPEN       0x01
+#define ACPI_BUTTON_LID_INIT_METHOD     0x02
+
 #define _COMPONENT              ACPI_BUTTON_COMPONENT
 ACPI_MODULE_NAME("button");
 
@@ -105,6 +109,7 @@ struct acpi_button {
 
 static BLOCKING_NOTIFIER_HEAD(acpi_lid_notifier);
 static struct acpi_device *lid_device;
+static u8 lid_init_state = ACPI_BUTTON_LID_INIT_METHOD;
 
 /* --------------------------------------------------------------------------
                               FS Interface (/proc)
@@ -113,16 +118,52 @@ static struct acpi_device *lid_device;
 static struct proc_dir_entry *acpi_button_dir;
 static struct proc_dir_entry *acpi_lid_dir;
 
+static int acpi_lid_evaluate_state(struct acpi_device *device)
+{
+        unsigned long long lid_state;
+        acpi_status status;
+
+        status = acpi_evaluate_integer(device->handle, "_LID", NULL, &lid_state);
+        if (ACPI_FAILURE(status))
+                return -ENODEV;
+
+        return lid_state ? 1 : 0;
+}
+
+static int acpi_lid_notify_state(struct acpi_device *device, int state)
+{
+        struct acpi_button *button = acpi_driver_data(device);
+        int ret;
+
+        /* input layer checks if event is redundant */
+        input_report_switch(button->input, SW_LID, !state);
+        input_sync(button->input);
+
+        if (state)
+                pm_wakeup_event(&device->dev, 0);
+
+        ret = blocking_notifier_call_chain(&acpi_lid_notifier, state, device);
+        if (ret == NOTIFY_DONE)
+                ret = blocking_notifier_call_chain(&acpi_lid_notifier, state,
+                                                   device);
+        if (ret == NOTIFY_DONE || ret == NOTIFY_OK) {
+                /*
+                 * It is also regarded as success if the notifier_chain
+                 * returns NOTIFY_OK or NOTIFY_DONE.
+                 */
+                ret = 0;
+        }
+        return ret;
+}
+
 static int acpi_button_state_seq_show(struct seq_file *seq, void *offset)
 {
         struct acpi_device *device = seq->private;
-        acpi_status status;
-        unsigned long long state;
+        int state;
 
-        status = acpi_evaluate_integer(device->handle, "_LID", NULL, &state);
+        state = acpi_lid_evaluate_state(device);
         seq_printf(seq, "state:      %s\n",
-                   ACPI_FAILURE(status) ? "unsupported" :
-                        (state ? "open" : "closed"));
+                   state < 0 ? "unsupported" : (state ? "open" : "closed"));
         return 0;
 }
 
@@ -231,51 +272,37 @@ EXPORT_SYMBOL(acpi_lid_notifier_unregister);
 
 int acpi_lid_open(void)
 {
-        acpi_status status;
-        unsigned long long state;
-
         if (!lid_device)
                 return -ENODEV;
 
-        status = acpi_evaluate_integer(lid_device->handle, "_LID", NULL,
-                                       &state);
-        if (ACPI_FAILURE(status))
-                return -ENODEV;
-
-        return !!state;
+        return acpi_lid_evaluate_state(lid_device);
 }
 EXPORT_SYMBOL(acpi_lid_open);
 
-static int acpi_lid_send_state(struct acpi_device *device)
+static int acpi_lid_update_state(struct acpi_device *device)
 {
-        struct acpi_button *button = acpi_driver_data(device);
-        unsigned long long state;
-        acpi_status status;
-        int ret;
-
-        status = acpi_evaluate_integer(device->handle, "_LID", NULL, &state);
-        if (ACPI_FAILURE(status))
-                return -ENODEV;
+        int state;
 
-        /* input layer checks if event is redundant */
-        input_report_switch(button->input, SW_LID, !state);
-        input_sync(button->input);
+        state = acpi_lid_evaluate_state(device);
+        if (state < 0)
+                return state;
 
-        if (state)
-                pm_wakeup_event(&device->dev, 0);
+        return acpi_lid_notify_state(device, state);
+}
 
-        ret = blocking_notifier_call_chain(&acpi_lid_notifier, state, device);
-        if (ret == NOTIFY_DONE)
-                ret = blocking_notifier_call_chain(&acpi_lid_notifier, state,
-                                                   device);
-        if (ret == NOTIFY_DONE || ret == NOTIFY_OK) {
-                /*
-                 * It is also regarded as success if the notifier_chain
-                 * returns NOTIFY_OK or NOTIFY_DONE.
-                 */
-                ret = 0;
+static void acpi_lid_initialize_state(struct acpi_device *device)
+{
+        switch (lid_init_state) {
+        case ACPI_BUTTON_LID_INIT_OPEN:
+                (void)acpi_lid_notify_state(device, 1);
+                break;
+        case ACPI_BUTTON_LID_INIT_METHOD:
+                (void)acpi_lid_update_state(device);
+                break;
+        case ACPI_BUTTON_LID_INIT_IGNORE:
+        default:
+                break;
         }
-        return ret;
 }
 
 static void acpi_button_notify(struct acpi_device *device, u32 event)
@@ -290,7 +317,7 @@ static void acpi_button_notify(struct acpi_device *device, u32 event)
         case ACPI_BUTTON_NOTIFY_STATUS:
                 input = button->input;
                 if (button->type == ACPI_BUTTON_TYPE_LID) {
-                        acpi_lid_send_state(device);
+                        acpi_lid_update_state(device);
                 } else {
                         int keycode;
 
@@ -335,7 +362,7 @@ static int acpi_button_resume(struct device *dev)
 
         button->suspended = false;
         if (button->type == ACPI_BUTTON_TYPE_LID)
-                return acpi_lid_send_state(device);
+                acpi_lid_initialize_state(device);
         return 0;
 }
 #endif
@@ -416,7 +443,7 @@ static int acpi_button_add(struct acpi_device *device)
         if (error)
                 goto err_remove_fs;
         if (button->type == ACPI_BUTTON_TYPE_LID) {
-                acpi_lid_send_state(device);
+                acpi_lid_initialize_state(device);
                 /*
                  * This assumes there's only one lid device, or if there are
                  * more we only care about the last one...
@@ -446,4 +473,42 @@ static int acpi_button_remove(struct acpi_device *device)
         return 0;
 }
 
+static int param_set_lid_init_state(const char *val, struct kernel_param *kp)
+{
+        int result = 0;
+
+        if (!strncmp(val, "open", sizeof("open") - 1)) {
+                lid_init_state = ACPI_BUTTON_LID_INIT_OPEN;
+                pr_info("Notify initial lid state as open\n");
+        } else if (!strncmp(val, "method", sizeof("method") - 1)) {
+                lid_init_state = ACPI_BUTTON_LID_INIT_METHOD;
+                pr_info("Notify initial lid state with _LID return value\n");
+        } else if (!strncmp(val, "ignore", sizeof("ignore") - 1)) {
+                lid_init_state = ACPI_BUTTON_LID_INIT_IGNORE;
+                pr_info("Do not notify initial lid state\n");
+        } else
+                result = -EINVAL;
+        return result;
+}
+
+static int param_get_lid_init_state(char *buffer, struct kernel_param *kp)
+{
+        switch (lid_init_state) {
+        case ACPI_BUTTON_LID_INIT_OPEN:
+                return sprintf(buffer, "open");
+        case ACPI_BUTTON_LID_INIT_METHOD:
+                return sprintf(buffer, "method");
+        case ACPI_BUTTON_LID_INIT_IGNORE:
+                return sprintf(buffer, "ignore");
+        default:
+                return sprintf(buffer, "invalid");
+        }
+        return 0;
+}
+
+module_param_call(lid_init_state,
+                  param_set_lid_init_state, param_get_lid_init_state,
+                  NULL, 0644);
+MODULE_PARM_DESC(lid_init_state, "Behavior for reporting LID initial state");
+
 module_acpi_driver(acpi_button_driver);
diff --git a/drivers/acpi/cppc_acpi.c b/drivers/acpi/cppc_acpi.c
index 8adac69dba3d..2e981732805b 100644
--- a/drivers/acpi/cppc_acpi.c
+++ b/drivers/acpi/cppc_acpi.c
@@ -299,8 +299,10 @@ int acpi_get_psd_map(struct cpudata **all_cpu_data)
                         continue;
 
                 cpc_ptr = per_cpu(cpc_desc_ptr, i);
-                if (!cpc_ptr)
-                        continue;
+                if (!cpc_ptr) {
+                        retval = -EFAULT;
+                        goto err_ret;
+                }
 
                 pdomain = &(cpc_ptr->domain_info);
                 cpumask_set_cpu(i, pr->shared_cpu_map);
@@ -322,8 +324,10 @@ int acpi_get_psd_map(struct cpudata **all_cpu_data)
                                 continue;
 
                         match_cpc_ptr = per_cpu(cpc_desc_ptr, j);
-                        if (!match_cpc_ptr)
-                                continue;
+                        if (!match_cpc_ptr) {
+                                retval = -EFAULT;
+                                goto err_ret;
+                        }
 
                         match_pdomain = &(match_cpc_ptr->domain_info);
                         if (match_pdomain->domain != pdomain->domain)
@@ -353,8 +357,10 @@ int acpi_get_psd_map(struct cpudata **all_cpu_data)
                                 continue;
 
                         match_cpc_ptr = per_cpu(cpc_desc_ptr, j);
-                        if (!match_cpc_ptr)
-                                continue;
+                        if (!match_cpc_ptr) {
+                                retval = -EFAULT;
+                                goto err_ret;
+                        }
 
                         match_pdomain = &(match_cpc_ptr->domain_info);
                         if (match_pdomain->domain != pdomain->domain)
@@ -595,9 +601,6 @@ int acpi_cppc_processor_probe(struct acpi_processor *pr)
         /* Store CPU Logical ID */
         cpc_ptr->cpu_id = pr->id;
 
-        /* Plug it into this CPUs CPC descriptor. */
-        per_cpu(cpc_desc_ptr, pr->id) = cpc_ptr;
-
         /* Parse PSD data for this CPU */
         ret = acpi_get_psd(cpc_ptr, handle);
         if (ret)
@@ -610,6 +613,9 @@ int acpi_cppc_processor_probe(struct acpi_processor *pr)
                         goto out_free;
         }
 
+        /* Plug PSD data into this CPUs CPC descriptor. */
+        per_cpu(cpc_desc_ptr, pr->id) = cpc_ptr;
+
         /* Everything looks okay */
         pr_debug("Parsed CPC struct for CPU: %d\n", pr->id);
 
diff --git a/drivers/acpi/dock.c b/drivers/acpi/dock.c
index e8e128dede29..0c00208b423e 100644
--- a/drivers/acpi/dock.c
+++ b/drivers/acpi/dock.c
@@ -21,7 +21,7 @@
  */
 
 #include <linux/kernel.h>
-#include <linux/module.h>
+#include <linux/moduleparam.h>
 #include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/types.h>
@@ -33,12 +33,7 @@
 
 #include "internal.h"
 
-#define ACPI_DOCK_DRIVER_DESCRIPTION "ACPI Dock Station Driver"
-
 ACPI_MODULE_NAME("dock");
-MODULE_AUTHOR("Kristen Carlson Accardi");
-MODULE_DESCRIPTION(ACPI_DOCK_DRIVER_DESCRIPTION);
-MODULE_LICENSE("GPL");
 
 static bool immediate_undock = 1;
 module_param(immediate_undock, bool, 0644);
diff --git a/drivers/acpi/dptf/Kconfig b/drivers/acpi/dptf/Kconfig
new file mode 100644
index 000000000000..ac0a6ed0cf46
--- /dev/null
+++ b/drivers/acpi/dptf/Kconfig
@@ -0,0 +1,15 @@
+config DPTF_POWER
+        tristate "DPTF Platform Power Participant"
+        depends on X86
+        help
+          This driver adds support for Dynamic Platform and Thermal Framework
+          (DPTF) Platform Power Participant device (INT3407) support.
+          This participant is responsible for exposing platform telemetry:
+                max_platform_power
+                platform_power_source
+                adapter_rating
+                battery_steady_power
+                charger_type
+
+          To compile this driver as a module, choose M here:
+          the module will be called dptf_power.
diff --git a/drivers/acpi/dptf/Makefile b/drivers/acpi/dptf/Makefile
new file mode 100644
index 000000000000..06ea8809583d
--- /dev/null
+++ b/drivers/acpi/dptf/Makefile
@@ -0,0 +1,4 @@
+obj-$(CONFIG_ACPI)             += int340x_thermal.o
+obj-$(CONFIG_DPTF_POWER)        += dptf_power.o
+
+ccflags-y += -Idrivers/acpi
diff --git a/drivers/acpi/dptf/dptf_power.c b/drivers/acpi/dptf/dptf_power.c
new file mode 100644
index 000000000000..734642dc5008
--- /dev/null
+++ b/drivers/acpi/dptf/dptf_power.c
@@ -0,0 +1,128 @@
+/*
+ * dptf_power:  DPTF platform power driver
+ * Copyright (c) 2016, Intel Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/acpi.h>
+#include <linux/platform_device.h>
+
+/*
+ * Presentation of attributes which are defined for INT3407. They are:
+ * PMAX : Maximum platform powe
+ * PSRC : Platform power source
+ * ARTG : Adapter rating
+ * CTYP : Charger type
+ * PBSS : Battery steady power
+ */
+#define DPTF_POWER_SHOW(name, object) \
+static ssize_t name##_show(struct device *dev,\
+                           struct device_attribute *attr,\
+                           char *buf)\
+{\
+        struct platform_device *pdev = to_platform_device(dev);\
+        struct acpi_device *acpi_dev = platform_get_drvdata(pdev);\
+        unsigned long long val;\
+        acpi_status status;\
+\
+        status = acpi_evaluate_integer(acpi_dev->handle, #object,\
+                                       NULL, &val);\
+        if (ACPI_SUCCESS(status))\
+                return sprintf(buf, "%d\n", (int)val);\
+        else \
+                return -EINVAL;\
+}
+
+DPTF_POWER_SHOW(max_platform_power_mw, PMAX)
+DPTF_POWER_SHOW(platform_power_source, PSRC)
+DPTF_POWER_SHOW(adapter_rating_mw, ARTG)
+DPTF_POWER_SHOW(battery_steady_power_mw, PBSS)
+DPTF_POWER_SHOW(charger_type, CTYP)
+
+static DEVICE_ATTR_RO(max_platform_power_mw);
+static DEVICE_ATTR_RO(platform_power_source);
+static DEVICE_ATTR_RO(adapter_rating_mw);
+static DEVICE_ATTR_RO(battery_steady_power_mw);
+static DEVICE_ATTR_RO(charger_type);
+
+static struct attribute *dptf_power_attrs[] = {
+        &dev_attr_max_platform_power_mw.attr,
+        &dev_attr_platform_power_source.attr,
+        &dev_attr_adapter_rating_mw.attr,
+        &dev_attr_battery_steady_power_mw.attr,
+        &dev_attr_charger_type.attr,
+        NULL
+};
+
+static struct attribute_group dptf_power_attribute_group = {
+        .attrs = dptf_power_attrs,
+        .name = "dptf_power"
+};
+
+static int dptf_power_add(struct platform_device *pdev)
+{
+        struct acpi_device *acpi_dev;
+        acpi_status status;
+        unsigned long long ptype;
+        int result;
+
+        acpi_dev = ACPI_COMPANION(&(pdev->dev));
+        if (!acpi_dev)
+                return -ENODEV;
+
+        status = acpi_evaluate_integer(acpi_dev->handle, "PTYP", NULL, &ptype);
+        if (ACPI_FAILURE(status))
+                return -ENODEV;
+
+        if (ptype != 0x11)
+                return -ENODEV;
+
+        result = sysfs_create_group(&pdev->dev.kobj,
+                                    &dptf_power_attribute_group);
+        if (result)
+                return result;
+
+        platform_set_drvdata(pdev, acpi_dev);
+
+        return 0;
+}
+
+static int dptf_power_remove(struct platform_device *pdev)
+{
+
+        sysfs_remove_group(&pdev->dev.kobj, &dptf_power_attribute_group);
+
+        return 0;
+}
+
+static const struct acpi_device_id int3407_device_ids[] = {
+        {"INT3407", 0},
+        {"", 0},
+};
+MODULE_DEVICE_TABLE(acpi, int3407_device_ids);
+
+static struct platform_driver dptf_power_driver = {
+        .probe = dptf_power_add,
+        .remove = dptf_power_remove,
+        .driver = {
+                .name = "DPTF Platform Power",
+                .acpi_match_table = int3407_device_ids,
+        },
+};
+
+module_platform_driver(dptf_power_driver);
+
+MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
+MODULE_LICENSE("GPL v2");
+MODULE_DESCRIPTION("ACPI DPTF platform power driver");
diff --git a/drivers/acpi/int340x_thermal.c b/drivers/acpi/dptf/int340x_thermal.c
index 33505c651f62..33505c651f62 100644
--- a/drivers/acpi/int340x_thermal.c
+++ b/drivers/acpi/dptf/int340x_thermal.c
diff --git a/drivers/acpi/ec.c b/drivers/acpi/ec.c
index 290d6f5be44b..999a10914678 100644
--- a/drivers/acpi/ec.c
+++ b/drivers/acpi/ec.c
@@ -1359,13 +1359,9 @@ static void ec_remove_handlers(struct acpi_ec *ec)
         }
 }
 
-static int acpi_ec_add(struct acpi_device *device)
+static struct acpi_ec *acpi_ec_alloc(void)
 {
-        struct acpi_ec *ec = NULL;
-        int ret;
-
-        strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
-        strcpy(acpi_device_class(device), ACPI_EC_CLASS);
+        struct acpi_ec *ec;
 
         /* Check for boot EC */
         if (boot_ec) {
@@ -1376,9 +1372,21 @@ static int acpi_ec_add(struct acpi_device *device)
                         first_ec = NULL;
         } else {
                 ec = make_acpi_ec();
-                if (!ec)
-                        return -ENOMEM;
         }
+        return ec;
+}
+
+static int acpi_ec_add(struct acpi_device *device)
+{
+        struct acpi_ec *ec = NULL;
+        int ret;
+
+        strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
+        strcpy(acpi_device_class(device), ACPI_EC_CLASS);
+
+        ec = acpi_ec_alloc();
+        if (!ec)
+                return -ENOMEM;
         if (ec_parse_device(device->handle, 0, ec, NULL) !=
                 AE_CTRL_TERMINATE) {
                         kfree(ec);
@@ -1465,27 +1473,31 @@ static const struct acpi_device_id ec_device_ids[] = {
 int __init acpi_ec_dsdt_probe(void)
 {
         acpi_status status;
+        struct acpi_ec *ec;
+        int ret;
 
-        if (boot_ec)
-                return 0;
-
+        ec = acpi_ec_alloc();
+        if (!ec)
+                return -ENOMEM;
         /*
          * Finding EC from DSDT if there is no ECDT EC available. When this
          * function is invoked, ACPI tables have been fully loaded, we can
          * walk namespace now.
          */
-        boot_ec = make_acpi_ec();
-        if (!boot_ec)
-                return -ENOMEM;
         status = acpi_get_devices(ec_device_ids[0].id,
-                                  ec_parse_device, boot_ec, NULL);
-        if (ACPI_FAILURE(status) || !boot_ec->handle)
-                return -ENODEV;
-        if (!ec_install_handlers(boot_ec)) {
-                first_ec = boot_ec;
-                return 0;
+                                  ec_parse_device, ec, NULL);
+        if (ACPI_FAILURE(status) || !ec->handle) {
+                ret = -ENODEV;
+                goto error;
         }
-        return -EFAULT;
+        ret = ec_install_handlers(ec);
+
+error:
+        if (ret)
+                kfree(ec);
+        else
+                first_ec = boot_ec = ec;
+        return ret;
 }
 
 #if 0
@@ -1529,6 +1541,11 @@ static int ec_clear_on_resume(const struct dmi_system_id *id)
         return 0;
 }
 
+/*
+ * Some ECDTs contain wrong register addresses.
+ * MSI MS-171F
+ * https://bugzilla.kernel.org/show_bug.cgi?id=12461
+ */
 static int ec_correct_ecdt(const struct dmi_system_id *id)
 {
         pr_debug("Detected system needing ECDT address correction.\n");
@@ -1538,16 +1555,6 @@ static int ec_correct_ecdt(const struct dmi_system_id *id)
 
 static struct dmi_system_id ec_dmi_table[] __initdata = {
         {
-        ec_correct_ecdt, "Asus L4R", {
-        DMI_MATCH(DMI_BIOS_VERSION, "1008.006"),
-        DMI_MATCH(DMI_PRODUCT_NAME, "L4R"),
-        DMI_MATCH(DMI_BOARD_NAME, "L4R") }, NULL},
-        {
-        ec_correct_ecdt, "Asus M6R", {
-        DMI_MATCH(DMI_BIOS_VERSION, "0207"),
-        DMI_MATCH(DMI_PRODUCT_NAME, "M6R"),
-        DMI_MATCH(DMI_BOARD_NAME, "M6R") }, NULL},
-        {
         ec_correct_ecdt, "MSI MS-171F", {
         DMI_MATCH(DMI_SYS_VENDOR, "Micro-Star"),
         DMI_MATCH(DMI_PRODUCT_NAME, "MS-171F"),}, NULL},
@@ -1559,12 +1566,13 @@ static struct dmi_system_id ec_dmi_table[] __initdata = {
 
 int __init acpi_ec_ecdt_probe(void)
 {
-        int ret = 0;
+        int ret;
         acpi_status status;
         struct acpi_table_ecdt *ecdt_ptr;
+        struct acpi_ec *ec;
 
-        boot_ec = make_acpi_ec();
-        if (!boot_ec)
+        ec = acpi_ec_alloc();
+        if (!ec)
                 return -ENOMEM;
         /*
          * Generate a boot ec context
@@ -1588,28 +1596,20 @@ int __init acpi_ec_ecdt_probe(void)
 
         pr_info("EC description table is found, configuring boot EC\n");
         if (EC_FLAGS_CORRECT_ECDT) {
-                /*
-                 * Asus L4R, Asus M6R
-                 * https://bugzilla.kernel.org/show_bug.cgi?id=9399
-                 * MSI MS-171F
-                 * https://bugzilla.kernel.org/show_bug.cgi?id=12461
-                 */
-                boot_ec->command_addr = ecdt_ptr->data.address;
-                boot_ec->data_addr = ecdt_ptr->control.address;
+                ec->command_addr = ecdt_ptr->data.address;
+                ec->data_addr = ecdt_ptr->control.address;
         } else {
-                boot_ec->command_addr = ecdt_ptr->control.address;
-                boot_ec->data_addr = ecdt_ptr->data.address;
+                ec->command_addr = ecdt_ptr->control.address;
+                ec->data_addr = ecdt_ptr->data.address;
         }
-        boot_ec->gpe = ecdt_ptr->gpe;
-        boot_ec->handle = ACPI_ROOT_OBJECT;
-        ret = ec_install_handlers(boot_ec);
-        if (!ret)
-                first_ec = boot_ec;
+        ec->gpe = ecdt_ptr->gpe;
+        ec->handle = ACPI_ROOT_OBJECT;
+        ret = ec_install_handlers(ec);
 error:
-        if (ret) {
-                kfree(boot_ec);
-                boot_ec = NULL;
-        }
+        if (ret)
+                kfree(ec);
+        else
+                first_ec = boot_ec = ec;
         return ret;
 }
 
diff --git a/drivers/acpi/internal.h b/drivers/acpi/internal.h
index 27cc7feabfe4..940218ff0193 100644
--- a/drivers/acpi/internal.h
+++ b/drivers/acpi/internal.h
@@ -87,6 +87,9 @@ bool acpi_queue_hotplug_work(struct work_struct *work);
 void acpi_device_hotplug(struct acpi_device *adev, u32 src);
 bool acpi_scan_is_offline(struct acpi_device *adev, bool uevent);
 
+acpi_status acpi_sysfs_table_handler(u32 event, void *table, void *context);
+void acpi_scan_table_handler(u32 event, void *table, void *context);
+
 /* --------------------------------------------------------------------------
                      Device Node Initialization / Removal
    -------------------------------------------------------------------------- */
diff --git a/drivers/acpi/numa.c b/drivers/acpi/numa.c
index d176e0ece470..ce3a7a16f03f 100644
--- a/drivers/acpi/numa.c
+++ b/drivers/acpi/numa.c
@@ -18,22 +18,21 @@
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  *
  */
+
+#define pr_fmt(fmt) "ACPI: " fmt
+
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/types.h>
 #include <linux/errno.h>
 #include <linux/acpi.h>
+#include <linux/bootmem.h>
+#include <linux/memblock.h>
 #include <linux/numa.h>
 #include <linux/nodemask.h>
 #include <linux/topology.h>
 
-#define PREFIX "ACPI: "
-
-#define ACPI_NUMA       0x80000000
-#define _COMPONENT      ACPI_NUMA
-ACPI_MODULE_NAME("numa");
-
 static nodemask_t nodes_found_map = NODE_MASK_NONE;
 
 /* maps to convert between proximity domain and logical node ID */
@@ -43,6 +42,7 @@ static int node_to_pxm_map[MAX_NUMNODES]
                         = { [0 ... MAX_NUMNODES - 1] = PXM_INVAL };
 
 unsigned char acpi_srat_revision __initdata;
+int acpi_numa __initdata;
 
 int pxm_to_node(int pxm)
 {
@@ -128,68 +128,63 @@ EXPORT_SYMBOL(acpi_map_pxm_to_online_node);
 static void __init
 acpi_table_print_srat_entry(struct acpi_subtable_header *header)
 {
-
-        ACPI_FUNCTION_NAME("acpi_table_print_srat_entry");
-
-        if (!header)
-                return;
-
         switch (header->type) {
-
         case ACPI_SRAT_TYPE_CPU_AFFINITY:
-#ifdef ACPI_DEBUG_OUTPUT
                 {
                         struct acpi_srat_cpu_affinity *p =
                             (struct acpi_srat_cpu_affinity *)header;
-                        ACPI_DEBUG_PRINT((ACPI_DB_INFO,
-                                          "SRAT Processor (id[0x%02x] eid[0x%02x]) in proximity domain %d %s\n",
-                                          p->apic_id, p->local_sapic_eid,
-                                          p->proximity_domain_lo,
-                                          (p->flags & ACPI_SRAT_CPU_ENABLED)?
-                                          "enabled" : "disabled"));
+                        pr_debug("SRAT Processor (id[0x%02x] eid[0x%02x]) in proximity domain %d %s\n",
+                                 p->apic_id, p->local_sapic_eid,
+                                 p->proximity_domain_lo,
+                                 (p->flags & ACPI_SRAT_CPU_ENABLED) ?
+                                 "enabled" : "disabled");
                 }
-#endif                          /* ACPI_DEBUG_OUTPUT */
                 break;
 
         case ACPI_SRAT_TYPE_MEMORY_AFFINITY:
-#ifdef ACPI_DEBUG_OUTPUT
                 {
                         struct acpi_srat_mem_affinity *p =
                             (struct acpi_srat_mem_affinity *)header;
-                        ACPI_DEBUG_PRINT((ACPI_DB_INFO,
-                                          "SRAT Memory (0x%lx length 0x%lx) in proximity domain %d %s%s%s\n",
-                                          (unsigned long)p->base_address,
-                                          (unsigned long)p->length,
-                                          p->proximity_domain,
-                                          (p->flags & ACPI_SRAT_MEM_ENABLED)?
-                                          "enabled" : "disabled",
-                                          (p->flags & ACPI_SRAT_MEM_HOT_PLUGGABLE)?
-                                          " hot-pluggable" : "",
-                                          (p->flags & ACPI_SRAT_MEM_NON_VOLATILE)?
-                                          " non-volatile" : ""));
+                        pr_debug("SRAT Memory (0x%lx length 0x%lx) in proximity domain %d %s%s%s\n",
+                                 (unsigned long)p->base_address,
+                                 (unsigned long)p->length,
+                                 p->proximity_domain,
+                                 (p->flags & ACPI_SRAT_MEM_ENABLED) ?
+                                 "enabled" : "disabled",
+                                 (p->flags & ACPI_SRAT_MEM_HOT_PLUGGABLE) ?
+                                 " hot-pluggable" : "",
+                                 (p->flags & ACPI_SRAT_MEM_NON_VOLATILE) ?
+                                 " non-volatile" : "");
                 }
-#endif                          /* ACPI_DEBUG_OUTPUT */
                 break;
 
         case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY:
-#ifdef ACPI_DEBUG_OUTPUT
                 {
                         struct acpi_srat_x2apic_cpu_affinity *p =
                             (struct acpi_srat_x2apic_cpu_affinity *)header;
-                        ACPI_DEBUG_PRINT((ACPI_DB_INFO,
-                                          "SRAT Processor (x2apicid[0x%08x]) in"
-                                          " proximity domain %d %s\n",
-                                          p->apic_id,
-                                          p->proximity_domain,
-                                          (p->flags & ACPI_SRAT_CPU_ENABLED) ?
-                                          "enabled" : "disabled"));
+                        pr_debug("SRAT Processor (x2apicid[0x%08x]) in proximity domain %d %s\n",
+                                 p->apic_id,
+                                 p->proximity_domain,
+                                 (p->flags & ACPI_SRAT_CPU_ENABLED) ?
+                                 "enabled" : "disabled");
                 }
-#endif                          /* ACPI_DEBUG_OUTPUT */
                 break;
+
+        case ACPI_SRAT_TYPE_GICC_AFFINITY:
+                {
+                        struct acpi_srat_gicc_affinity *p =
+                            (struct acpi_srat_gicc_affinity *)header;
+                        pr_debug("SRAT Processor (acpi id[0x%04x]) in proximity domain %d %s\n",
+                                 p->acpi_processor_uid,
+                                 p->proximity_domain,
+                                 (p->flags & ACPI_SRAT_GICC_ENABLED) ?
+                                 "enabled" : "disabled");
+                }
+                break;
+
         default:
-                printk(KERN_WARNING PREFIX
-                       "Found unsupported SRAT entry (type = 0x%x)\n",
-                       header->type);
+                pr_warn("Found unsupported SRAT entry (type = 0x%x)\n",
+                        header->type);
                 break;
         }
 }
@@ -217,12 +212,117 @@ static int __init slit_valid(struct acpi_table_slit *slit)
         return 1;
 }
 
+void __init bad_srat(void)
+{
+        pr_err("SRAT: SRAT not used.\n");
+        acpi_numa = -1;
+}
+
+int __init srat_disabled(void)
+{
+        return acpi_numa < 0;
+}
+
+#if defined(CONFIG_X86) || defined(CONFIG_ARM64)
+/*
+ * Callback for SLIT parsing.  pxm_to_node() returns NUMA_NO_NODE for
+ * I/O localities since SRAT does not list them.  I/O localities are
+ * not supported at this point.
+ */
+void __init acpi_numa_slit_init(struct acpi_table_slit *slit)
+{
+        int i, j;
+
+        for (i = 0; i < slit->locality_count; i++) {
+                const int from_node = pxm_to_node(i);
+
+                if (from_node == NUMA_NO_NODE)
+                        continue;
+
+                for (j = 0; j < slit->locality_count; j++) {
+                        const int to_node = pxm_to_node(j);
+
+                        if (to_node == NUMA_NO_NODE)
+                                continue;
+
+                        numa_set_distance(from_node, to_node,
+                                slit->entry[slit->locality_count * i + j]);
+                }
+        }
+}
+
+/*
+ * Default callback for parsing of the Proximity Domain <-> Memory
+ * Area mappings
+ */
+int __init
+acpi_numa_memory_affinity_init(struct acpi_srat_mem_affinity *ma)
+{
+        u64 start, end;
+        u32 hotpluggable;
+        int node, pxm;
+
+        if (srat_disabled())
+                goto out_err;
+        if (ma->header.length < sizeof(struct acpi_srat_mem_affinity)) {
+                pr_err("SRAT: Unexpected header length: %d\n",
+                       ma->header.length);
+                goto out_err_bad_srat;
+        }
+        if ((ma->flags & ACPI_SRAT_MEM_ENABLED) == 0)
+                goto out_err;
+        hotpluggable = ma->flags & ACPI_SRAT_MEM_HOT_PLUGGABLE;
+        if (hotpluggable && !IS_ENABLED(CONFIG_MEMORY_HOTPLUG))
+                goto out_err;
+
+        start = ma->base_address;
+        end = start + ma->length;
+        pxm = ma->proximity_domain;
+        if (acpi_srat_revision <= 1)
+                pxm &= 0xff;
+
+        node = acpi_map_pxm_to_node(pxm);
+        if (node == NUMA_NO_NODE || node >= MAX_NUMNODES) {
+                pr_err("SRAT: Too many proximity domains.\n");
+                goto out_err_bad_srat;
+        }
+
+        if (numa_add_memblk(node, start, end) < 0) {
+                pr_err("SRAT: Failed to add memblk to node %u [mem %#010Lx-%#010Lx]\n",
+                       node, (unsigned long long) start,
+                       (unsigned long long) end - 1);
+                goto out_err_bad_srat;
+        }
+
+        node_set(node, numa_nodes_parsed);
+
+        pr_info("SRAT: Node %u PXM %u [mem %#010Lx-%#010Lx]%s%s\n",
+                node, pxm,
+                (unsigned long long) start, (unsigned long long) end - 1,
+                hotpluggable ? " hotplug" : "",
+                ma->flags & ACPI_SRAT_MEM_NON_VOLATILE ? " non-volatile" : "");
+
+        /* Mark hotplug range in memblock. */
+        if (hotpluggable && memblock_mark_hotplug(start, ma->length))
+                pr_warn("SRAT: Failed to mark hotplug range [mem %#010Lx-%#010Lx] in memblock\n",
+                        (unsigned long long)start, (unsigned long long)end - 1);
+
+        max_possible_pfn = max(max_possible_pfn, PFN_UP(end - 1));
+
+        return 0;
+out_err_bad_srat:
+        bad_srat();
+out_err:
+        return -EINVAL;
+}
+#endif /* defined(CONFIG_X86) || defined (CONFIG_ARM64) */
+
 static int __init acpi_parse_slit(struct acpi_table_header *table)
 {
         struct acpi_table_slit *slit = (struct acpi_table_slit *)table;
 
         if (!slit_valid(slit)) {
-                printk(KERN_INFO "ACPI: SLIT table looks invalid. Not used.\n");
+                pr_info("SLIT table looks invalid. Not used.\n");
                 return -EINVAL;
         }
         acpi_numa_slit_init(slit);
@@ -233,12 +333,9 @@ static int __init acpi_parse_slit(struct acpi_table_header *table)
 void __init __weak
 acpi_numa_x2apic_affinity_init(struct acpi_srat_x2apic_cpu_affinity *pa)
 {
-        printk(KERN_WARNING PREFIX
-               "Found unsupported x2apic [0x%08x] SRAT entry\n", pa->apic_id);
-        return;
+        pr_warn("Found unsupported x2apic [0x%08x] SRAT entry\n", pa->apic_id);
 }
 
-
 static int __init
 acpi_parse_x2apic_affinity(struct acpi_subtable_header *header,
                            const unsigned long end)
@@ -275,6 +372,24 @@ acpi_parse_processor_affinity(struct acpi_subtable_header *header,
         return 0;
 }
 
+static int __init
+acpi_parse_gicc_affinity(struct acpi_subtable_header *header,
+                         const unsigned long end)
+{
+        struct acpi_srat_gicc_affinity *processor_affinity;
+
+        processor_affinity = (struct acpi_srat_gicc_affinity *)header;
+        if (!processor_affinity)
+                return -EINVAL;
+
+        acpi_table_print_srat_entry(header);
+
+        /* let architecture-dependent part to do it */
+        acpi_numa_gicc_affinity_init(processor_affinity);
+
+        return 0;
+}
+
 static int __initdata parsed_numa_memblks;
 
 static int __init
@@ -319,6 +434,9 @@ int __init acpi_numa_init(void)
 {
         int cnt = 0;
 
+        if (acpi_disabled)
+                return -EINVAL;
+
         /*
          * Should not limit number with cpu num that is from NR_CPUS or nr_cpus=
          * SRAT cpu entries could have different order with that in MADT.
@@ -327,13 +445,15 @@ int __init acpi_numa_init(void)
 
         /* SRAT: Static Resource Affinity Table */
         if (!acpi_table_parse(ACPI_SIG_SRAT, acpi_parse_srat)) {
-                struct acpi_subtable_proc srat_proc[2];
+                struct acpi_subtable_proc srat_proc[3];
 
                 memset(srat_proc, 0, sizeof(srat_proc));
                 srat_proc[0].id = ACPI_SRAT_TYPE_CPU_AFFINITY;
                 srat_proc[0].handler = acpi_parse_processor_affinity;
                 srat_proc[1].id = ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY;
                 srat_proc[1].handler = acpi_parse_x2apic_affinity;
+                srat_proc[2].id = ACPI_SRAT_TYPE_GICC_AFFINITY;
+                srat_proc[2].handler = acpi_parse_gicc_affinity;
 
                 acpi_table_parse_entries_array(ACPI_SIG_SRAT,
                                         sizeof(struct acpi_table_srat),
@@ -347,8 +467,6 @@ int __init acpi_numa_init(void)
         /* SLIT: System Locality Information Table */
         acpi_table_parse(ACPI_SIG_SLIT, acpi_parse_slit);
 
-        acpi_numa_arch_fixup();
-
         if (cnt < 0)
                 return cnt;
         else if (!parsed_numa_memblks)
diff --git a/drivers/acpi/pci_slot.c b/drivers/acpi/pci_slot.c
index 7188e53b6b7c..f62c68e24317 100644
--- a/drivers/acpi/pci_slot.c
+++ b/drivers/acpi/pci_slot.c
@@ -22,8 +22,9 @@
  *  General Public License for more details.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
-#include <linux/module.h>
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/types.h>
@@ -33,30 +34,11 @@
 #include <linux/dmi.h>
 #include <linux/pci-acpi.h>
 
-static bool debug;
 static int check_sta_before_sun;
 
-#define DRIVER_VERSION  "0.1"
-#define DRIVER_AUTHOR   "Alex Chiang <achiang@hp.com>"
-#define DRIVER_DESC     "ACPI PCI Slot Detection Driver"
-MODULE_AUTHOR(DRIVER_AUTHOR);
-MODULE_DESCRIPTION(DRIVER_DESC);
-MODULE_LICENSE("GPL");
-MODULE_PARM_DESC(debug, "Debugging mode enabled or not");
-module_param(debug, bool, 0644);
-
 #define _COMPONENT              ACPI_PCI_COMPONENT
 ACPI_MODULE_NAME("pci_slot");
 
-#define MY_NAME "pci_slot"
-#define err(format, arg...) pr_err("%s: " format , MY_NAME , ## arg)
-#define info(format, arg...) pr_info("%s: " format , MY_NAME , ## arg)
-#define dbg(format, arg...)                                     \
-        do {                                                    \
-                if (debug)                                      \
-                        pr_debug("%s: " format, MY_NAME , ## arg); \
-        } while (0)
-
 #define SLOT_NAME_SIZE 21               /* Inspired by #define in acpiphp.h */
 
 struct acpi_pci_slot {
@@ -76,7 +58,7 @@ check_slot(acpi_handle handle, unsigned long long *sun)
         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 
         acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
-        dbg("Checking slot on path: %s\n", (char *)buffer.pointer);
+        pr_debug("Checking slot on path: %s\n", (char *)buffer.pointer);
 
         if (check_sta_before_sun) {
                 /* If SxFy doesn't have _STA, we just assume it's there */
@@ -87,14 +69,16 @@ check_slot(acpi_handle handle, unsigned long long *sun)
 
         status = acpi_evaluate_integer(handle, "_ADR", NULL, &adr);
         if (ACPI_FAILURE(status)) {
-                dbg("_ADR returned %d on %s\n", status, (char *)buffer.pointer);
+                pr_debug("_ADR returned %d on %s\n",
+                         status, (char *)buffer.pointer);
                 goto out;
         }
 
         /* No _SUN == not a slot == bail */
         status = acpi_evaluate_integer(handle, "_SUN", NULL, sun);
         if (ACPI_FAILURE(status)) {
-                dbg("_SUN returned %d on %s\n", status, (char *)buffer.pointer);
+                pr_debug("_SUN returned %d on %s\n",
+                         status, (char *)buffer.pointer);
                 goto out;
         }
 
@@ -132,15 +116,13 @@ register_slot(acpi_handle handle, u32 lvl, void *context, void **rv)
         }
 
         slot = kmalloc(sizeof(*slot), GFP_KERNEL);
-        if (!slot) {
-                err("%s: cannot allocate memory\n", __func__);
+        if (!slot)
                 return AE_OK;
-        }
 
         snprintf(name, sizeof(name), "%llu", sun);
         pci_slot = pci_create_slot(pci_bus, device, name, NULL);
         if (IS_ERR(pci_slot)) {
-                err("pci_create_slot returned %ld\n", PTR_ERR(pci_slot));
+                pr_err("pci_create_slot returned %ld\n", PTR_ERR(pci_slot));
                 kfree(slot);
                 return AE_OK;
         }
@@ -150,8 +132,8 @@ register_slot(acpi_handle handle, u32 lvl, void *context, void **rv)
 
         get_device(&pci_bus->dev);
 
-        dbg("pci_slot: %p, pci_bus: %x, device: %d, name: %s\n",
-                pci_slot, pci_bus->number, device, name);
+        pr_debug("%p, pci_bus: %x, device: %d, name: %s\n",
+                 pci_slot, pci_bus->number, device, name);
 
         return AE_OK;
 }
@@ -186,7 +168,8 @@ void acpi_pci_slot_remove(struct pci_bus *bus)
 
 static int do_sta_before_sun(const struct dmi_system_id *d)
 {
-        info("%s detected: will evaluate _STA before calling _SUN\n", d->ident);
+        pr_info("%s detected: will evaluate _STA before calling _SUN\n",
+                d->ident);
         check_sta_before_sun = 1;
         return 0;
 }
diff --git a/drivers/acpi/pmic/intel_pmic.c b/drivers/acpi/pmic/intel_pmic.c
index bd772cd56494..ca18e0d23df9 100644
--- a/drivers/acpi/pmic/intel_pmic.c
+++ b/drivers/acpi/pmic/intel_pmic.c
@@ -13,7 +13,7 @@
  * GNU General Public License for more details.
  */
 
-#include <linux/module.h>
+#include <linux/export.h>
 #include <linux/acpi.h>
 #include <linux/regmap.h>
 #include <acpi/acpi_lpat.h>
@@ -21,12 +21,19 @@
 
 #define PMIC_POWER_OPREGION_ID          0x8d
 #define PMIC_THERMAL_OPREGION_ID        0x8c
+#define PMIC_REGS_OPREGION_ID           0x8f
+
+struct intel_pmic_regs_handler_ctx {
+        unsigned int val;
+        u16 addr;
+};
 
 struct intel_pmic_opregion {
         struct mutex lock;
         struct acpi_lpat_conversion_table *lpat_table;
         struct regmap *regmap;
         struct intel_pmic_opregion_data *data;
+        struct intel_pmic_regs_handler_ctx ctx;
 };
 
 static int pmic_get_reg_bit(int address, struct pmic_table *table,
@@ -131,7 +138,7 @@ static int pmic_thermal_aux(struct intel_pmic_opregion *opregion, int reg,
 }
 
 static int pmic_thermal_pen(struct intel_pmic_opregion *opregion, int reg,
-                            u32 function, u64 *value)
+                            int bit, u32 function, u64 *value)
 {
         struct intel_pmic_opregion_data *d = opregion->data;
         struct regmap *regmap = opregion->regmap;
@@ -140,12 +147,12 @@ static int pmic_thermal_pen(struct intel_pmic_opregion *opregion, int reg,
                 return -ENXIO;
 
         if (function == ACPI_READ)
-                return d->get_policy(regmap, reg, value);
+                return d->get_policy(regmap, reg, bit, value);
 
         if (*value != 0 && *value != 1)
                 return -EINVAL;
 
-        return d->update_policy(regmap, reg, *value);
+        return d->update_policy(regmap, reg, bit, *value);
 }
 
 static bool pmic_thermal_is_temp(int address)
@@ -170,13 +177,13 @@ static acpi_status intel_pmic_thermal_handler(u32 function,
 {
         struct intel_pmic_opregion *opregion = region_context;
         struct intel_pmic_opregion_data *d = opregion->data;
-        int reg, result;
+        int reg, bit, result;
 
         if (bits != 32 || !value64)
                 return AE_BAD_PARAMETER;
 
         result = pmic_get_reg_bit(address, d->thermal_table,
-                                  d->thermal_table_count, &reg, NULL);
+                                  d->thermal_table_count, &reg, &bit);
         if (result == -ENOENT)
                 return AE_BAD_PARAMETER;
 
@@ -187,7 +194,8 @@ static acpi_status intel_pmic_thermal_handler(u32 function,
         else if (pmic_thermal_is_aux(address))
                 result = pmic_thermal_aux(opregion, reg, function, value64);
         else if (pmic_thermal_is_pen(address))
-                result = pmic_thermal_pen(opregion, reg, function, value64);
+                result = pmic_thermal_pen(opregion, reg, bit,
+                                                function, value64);
         else
                 result = -EINVAL;
 
@@ -203,6 +211,48 @@ static acpi_status intel_pmic_thermal_handler(u32 function,
         return AE_OK;
 }
 
+static acpi_status intel_pmic_regs_handler(u32 function,
+                acpi_physical_address address, u32 bits, u64 *value64,
+                void *handler_context, void *region_context)
+{
+        struct intel_pmic_opregion *opregion = region_context;
+        int result = 0;
+
+        switch (address) {
+        case 0:
+                return AE_OK;
+        case 1:
+                opregion->ctx.addr |= (*value64 & 0xff) << 8;
+                return AE_OK;
+        case 2:
+                opregion->ctx.addr |= *value64 & 0xff;
+                return AE_OK;
+        case 3:
+                opregion->ctx.val = *value64 & 0xff;
+                return AE_OK;
+        case 4:
+                if (*value64) {
+                        result = regmap_write(opregion->regmap, opregion->ctx.addr,
+                                              opregion->ctx.val);
+                } else {
+                        result = regmap_read(opregion->regmap, opregion->ctx.addr,
+                                             &opregion->ctx.val);
+                        if (result == 0)
+                                *value64 = opregion->ctx.val;
+                }
+                memset(&opregion->ctx, 0x00, sizeof(opregion->ctx));
+        }
+
+        if (result < 0) {
+                if (result == -EINVAL)
+                        return AE_BAD_PARAMETER;
+                else
+                        return AE_ERROR;
+        }
+
+        return AE_OK;
+}
+
 int intel_pmic_install_opregion_handler(struct device *dev, acpi_handle handle,
                                         struct regmap *regmap,
                                         struct intel_pmic_opregion_data *d)
@@ -242,16 +292,30 @@ int intel_pmic_install_opregion_handler(struct device *dev, acpi_handle handle,
                 acpi_remove_address_space_handler(handle, PMIC_POWER_OPREGION_ID,
                                                   intel_pmic_power_handler);
                 ret = -ENODEV;
-                goto out_error;
+                goto out_remove_power_handler;
+        }
+
+        status = acpi_install_address_space_handler(handle,
+                        PMIC_REGS_OPREGION_ID, intel_pmic_regs_handler, NULL,
+                        opregion);
+        if (ACPI_FAILURE(status)) {
+                ret = -ENODEV;
+                goto out_remove_thermal_handler;
         }
 
         opregion->data = d;
         return 0;
 
+out_remove_thermal_handler:
+        acpi_remove_address_space_handler(handle, PMIC_THERMAL_OPREGION_ID,
+                                          intel_pmic_thermal_handler);
+
+out_remove_power_handler:
+        acpi_remove_address_space_handler(handle, PMIC_POWER_OPREGION_ID,
+                                          intel_pmic_power_handler);
+
 out_error:
         acpi_lpat_free_conversion_table(opregion->lpat_table);
         return ret;
 }
 EXPORT_SYMBOL_GPL(intel_pmic_install_opregion_handler);
-
-MODULE_LICENSE("GPL");
diff --git a/drivers/acpi/pmic/intel_pmic.h b/drivers/acpi/pmic/intel_pmic.h
index d4e90af8f0dd..e8bfa7b865a5 100644
--- a/drivers/acpi/pmic/intel_pmic.h
+++ b/drivers/acpi/pmic/intel_pmic.h
@@ -12,8 +12,8 @@ struct intel_pmic_opregion_data {
         int (*update_power)(struct regmap *r, int reg, int bit, bool on);
         int (*get_raw_temp)(struct regmap *r, int reg);
         int (*update_aux)(struct regmap *r, int reg, int raw_temp);
-        int (*get_policy)(struct regmap *r, int reg, u64 *value);
-        int (*update_policy)(struct regmap *r, int reg, int enable);
+        int (*get_policy)(struct regmap *r, int reg, int bit, u64 *value);
+        int (*update_policy)(struct regmap *r, int reg, int bit, int enable);
         struct pmic_table *power_table;
         int power_table_count;
         struct pmic_table *thermal_table;
diff --git a/drivers/acpi/pmic/intel_pmic_bxtwc.c b/drivers/acpi/pmic/intel_pmic_bxtwc.c
new file mode 100644
index 000000000000..90011aad4d20
--- /dev/null
+++ b/drivers/acpi/pmic/intel_pmic_bxtwc.c
@@ -0,0 +1,420 @@
+/*
+ * intel_pmic_bxtwc.c - Intel BXT WhiskeyCove PMIC operation region driver
+ *
+ * Copyright (C) 2015 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License version
+ * 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/init.h>
+#include <linux/acpi.h>
+#include <linux/mfd/intel_soc_pmic.h>
+#include <linux/regmap.h>
+#include <linux/platform_device.h>
+#include "intel_pmic.h"
+
+#define WHISKEY_COVE_ALRT_HIGH_BIT_MASK 0x0F
+#define WHISKEY_COVE_ADC_HIGH_BIT(x)    (((x & 0x0F) << 8))
+#define WHISKEY_COVE_ADC_CURSRC(x)      (((x & 0xF0) >> 4))
+#define VR_MODE_DISABLED        0
+#define VR_MODE_AUTO            BIT(0)
+#define VR_MODE_NORMAL          BIT(1)
+#define VR_MODE_SWITCH          BIT(2)
+#define VR_MODE_ECO             (BIT(0)|BIT(1))
+#define VSWITCH2_OUTPUT         BIT(5)
+#define VSWITCH1_OUTPUT         BIT(4)
+#define VUSBPHY_CHARGE          BIT(1)
+
+static struct pmic_table power_table[] = {
+        {
+                .address = 0x0,
+                .reg = 0x63,
+                .bit = VR_MODE_AUTO,
+        }, /* VDD1 -> VDD1CNT */
+        {
+                .address = 0x04,
+                .reg = 0x65,
+                .bit = VR_MODE_AUTO,
+        }, /* VDD2 -> VDD2CNT */
+        {
+                .address = 0x08,
+                .reg = 0x67,
+                .bit = VR_MODE_AUTO,
+        }, /* VDD3 -> VDD3CNT */
+        {
+                .address = 0x0c,
+                .reg = 0x6d,
+                .bit = VR_MODE_AUTO,
+        }, /* VLFX -> VFLEXCNT */
+        {
+                .address = 0x10,
+                .reg = 0x6f,
+                .bit = VR_MODE_NORMAL,
+        }, /* VP1A -> VPROG1ACNT */
+        {
+                .address = 0x14,
+                .reg = 0x70,
+                .bit = VR_MODE_NORMAL,
+        }, /* VP1B -> VPROG1BCNT */
+        {
+                .address = 0x18,
+                .reg = 0x71,
+                .bit = VR_MODE_NORMAL,
+        }, /* VP1C -> VPROG1CCNT */
+        {
+                .address = 0x1c,
+                .reg = 0x72,
+                .bit = VR_MODE_NORMAL,
+        }, /* VP1D -> VPROG1DCNT */
+        {
+                .address = 0x20,
+                .reg = 0x73,
+                .bit = VR_MODE_NORMAL,
+        }, /* VP2A -> VPROG2ACNT */
+        {
+                .address = 0x24,
+                .reg = 0x74,
+                .bit = VR_MODE_NORMAL,
+        }, /* VP2B -> VPROG2BCNT */
+        {
+                .address = 0x28,
+                .reg = 0x75,
+                .bit = VR_MODE_NORMAL,
+        }, /* VP2C -> VPROG2CCNT */
+        {
+                .address = 0x2c,
+                .reg = 0x76,
+                .bit = VR_MODE_NORMAL,
+        }, /* VP3A -> VPROG3ACNT */
+        {
+                .address = 0x30,
+                .reg = 0x77,
+                .bit = VR_MODE_NORMAL,
+        }, /* VP3B -> VPROG3BCNT */
+        {
+                .address = 0x34,
+                .reg = 0x78,
+                .bit = VSWITCH2_OUTPUT,
+        }, /* VSW2 -> VLD0CNT Bit 5*/
+        {
+                .address = 0x38,
+                .reg = 0x78,
+                .bit = VSWITCH1_OUTPUT,
+        }, /* VSW1 -> VLD0CNT Bit 4 */
+        {
+                .address = 0x3c,
+                .reg = 0x78,
+                .bit = VUSBPHY_CHARGE,
+        }, /* VUPY -> VLDOCNT Bit 1 */
+        {
+                .address = 0x40,
+                .reg = 0x7b,
+                .bit = VR_MODE_NORMAL,
+        }, /* VRSO -> VREFSOCCNT*/
+        {
+                .address = 0x44,
+                .reg = 0xA0,
+                .bit = VR_MODE_NORMAL,
+        }, /* VP1E -> VPROG1ECNT */
+        {
+                .address = 0x48,
+                .reg = 0xA1,
+                .bit = VR_MODE_NORMAL,
+        }, /* VP1F -> VPROG1FCNT */
+        {
+                .address = 0x4c,
+                .reg = 0xA2,
+                .bit = VR_MODE_NORMAL,
+        }, /* VP2D -> VPROG2DCNT */
+        {
+                .address = 0x50,
+                .reg = 0xA3,
+                .bit = VR_MODE_NORMAL,
+        }, /* VP4A -> VPROG4ACNT */
+        {
+                .address = 0x54,
+                .reg = 0xA4,
+                .bit = VR_MODE_NORMAL,
+        }, /* VP4B -> VPROG4BCNT */
+        {
+                .address = 0x58,
+                .reg = 0xA5,
+                .bit = VR_MODE_NORMAL,
+        }, /* VP4C -> VPROG4CCNT */
+        {
+                .address = 0x5c,
+                .reg = 0xA6,
+                .bit = VR_MODE_NORMAL,
+        }, /* VP4D -> VPROG4DCNT */
+        {
+                .address = 0x60,
+                .reg = 0xA7,
+                .bit = VR_MODE_NORMAL,
+        }, /* VP5A -> VPROG5ACNT */
+        {
+                .address = 0x64,
+                .reg = 0xA8,
+                .bit = VR_MODE_NORMAL,
+        }, /* VP5B -> VPROG5BCNT */
+        {
+                .address = 0x68,
+                .reg = 0xA9,
+                .bit = VR_MODE_NORMAL,
+        }, /* VP6A -> VPROG6ACNT */
+        {
+                .address = 0x6c,
+                .reg = 0xAA,
+                .bit = VR_MODE_NORMAL,
+        }, /* VP6B -> VPROG6BCNT */
+        {
+                .address = 0x70,
+                .reg = 0x36,
+                .bit = BIT(2),
+        }, /* SDWN_N -> MODEMCTRL Bit 2 */
+        {
+                .address = 0x74,
+                .reg = 0x36,
+                .bit = BIT(0),
+        } /* MOFF -> MODEMCTRL Bit 0 */
+};
+
+static struct pmic_table thermal_table[] = {
+        {
+                .address = 0x00,
+                .reg = 0x4F39
+        },
+        {
+                .address = 0x04,
+                .reg = 0x4F24
+        },
+        {
+                .address = 0x08,
+                .reg = 0x4F26
+        },
+        {
+                .address = 0x0c,
+                .reg = 0x4F3B
+        },
+        {
+                .address = 0x10,
+                .reg = 0x4F28
+        },
+        {
+                .address = 0x14,
+                .reg = 0x4F2A
+        },
+        {
+                .address = 0x18,
+                .reg = 0x4F3D
+        },
+        {
+                .address = 0x1c,
+                .reg = 0x4F2C
+        },
+        {
+                .address = 0x20,
+                .reg = 0x4F2E
+        },
+        {
+                .address = 0x24,
+                .reg = 0x4F3F
+        },
+        {
+                .address = 0x28,
+                .reg = 0x4F30
+        },
+        {
+                .address = 0x30,
+                .reg = 0x4F41
+        },
+        {
+                .address = 0x34,
+                .reg = 0x4F32
+        },
+        {
+                .address = 0x3c,
+                .reg = 0x4F43
+        },
+        {
+                .address = 0x40,
+                .reg = 0x4F34
+        },
+        {
+                .address = 0x48,
+                .reg = 0x4F6A,
+                .bit = 0,
+        },
+        {
+                .address = 0x4C,
+                .reg = 0x4F6A,
+                .bit = 1
+        },
+        {
+                .address = 0x50,
+                .reg = 0x4F6A,
+                .bit = 2
+        },
+        {
+                .address = 0x54,
+                .reg = 0x4F6A,
+                .bit = 4
+        },
+        {
+                .address = 0x58,
+                .reg = 0x4F6A,
+                .bit = 5
+        },
+        {
+                .address = 0x5C,
+                .reg = 0x4F6A,
+                .bit = 3
+        },
+};
+
+static int intel_bxtwc_pmic_get_power(struct regmap *regmap, int reg,
+                int bit, u64 *value)
+{
+        int data;
+
+        if (regmap_read(regmap, reg, &data))
+                return -EIO;
+
+        *value = (data & bit) ? 1 : 0;
+        return 0;
+}
+
+static int intel_bxtwc_pmic_update_power(struct regmap *regmap, int reg,
+                int bit, bool on)
+{
+        u8 val, mask = bit;
+
+        if (on)
+                val = 0xFF;
+        else
+                val = 0x0;
+
+        return regmap_update_bits(regmap, reg, mask, val);
+}
+
+static int intel_bxtwc_pmic_get_raw_temp(struct regmap *regmap, int reg)
+{
+        unsigned int val, adc_val, reg_val;
+        u8 temp_l, temp_h, cursrc;
+        unsigned long rlsb;
+        static const unsigned long rlsb_array[] = {
+                0, 260420, 130210, 65100, 32550, 16280,
+                8140, 4070, 2030, 0, 260420, 130210 };
+
+        if (regmap_read(regmap, reg, &val))
+                return -EIO;
+        temp_l = (u8) val;
+
+        if (regmap_read(regmap, (reg - 1), &val))
+                return -EIO;
+        temp_h = (u8) val;
+
+        reg_val = temp_l | WHISKEY_COVE_ADC_HIGH_BIT(temp_h);
+        cursrc = WHISKEY_COVE_ADC_CURSRC(temp_h);
+        rlsb = rlsb_array[cursrc];
+        adc_val = reg_val * rlsb / 1000;
+
+        return adc_val;
+}
+
+static int
+intel_bxtwc_pmic_update_aux(struct regmap *regmap, int reg, int raw)
+{
+        u32 bsr_num;
+        u16 resi_val, count = 0, thrsh = 0;
+        u8 alrt_h, alrt_l, cursel = 0;
+
+        bsr_num = raw;
+        bsr_num /= (1 << 5);
+
+        count = fls(bsr_num) - 1;
+
+        cursel = clamp_t(s8, (count - 7), 0, 7);
+        thrsh = raw / (1 << (4 + cursel));
+
+        resi_val = (cursel << 9) | thrsh;
+        alrt_h = (resi_val >> 8) & WHISKEY_COVE_ALRT_HIGH_BIT_MASK;
+        if (regmap_update_bits(regmap,
+                                reg - 1,
+                                WHISKEY_COVE_ALRT_HIGH_BIT_MASK,
+                                alrt_h))
+                return -EIO;
+
+        alrt_l = (u8)resi_val;
+        return regmap_write(regmap, reg, alrt_l);
+}
+
+static int
+intel_bxtwc_pmic_get_policy(struct regmap *regmap, int reg, int bit, u64 *value)
+{
+        u8 mask = BIT(bit);
+        unsigned int val;
+
+        if (regmap_read(regmap, reg, &val))
+                return -EIO;
+
+        *value = (val & mask) >> bit;
+        return 0;
+}
+
+static int
+intel_bxtwc_pmic_update_policy(struct regmap *regmap,
+                                int reg, int bit, int enable)
+{
+        u8 mask = BIT(bit), val = enable << bit;
+
+        return regmap_update_bits(regmap, reg, mask, val);
+}
+
+static struct intel_pmic_opregion_data intel_bxtwc_pmic_opregion_data = {
+        .get_power      = intel_bxtwc_pmic_get_power,
+        .update_power   = intel_bxtwc_pmic_update_power,
+        .get_raw_temp   = intel_bxtwc_pmic_get_raw_temp,
+        .update_aux     = intel_bxtwc_pmic_update_aux,
+        .get_policy     = intel_bxtwc_pmic_get_policy,
+        .update_policy  = intel_bxtwc_pmic_update_policy,
+        .power_table      = power_table,
+        .power_table_count = ARRAY_SIZE(power_table),
+        .thermal_table     = thermal_table,
+        .thermal_table_count = ARRAY_SIZE(thermal_table),
+};
+
+static int intel_bxtwc_pmic_opregion_probe(struct platform_device *pdev)
+{
+        struct intel_soc_pmic *pmic = dev_get_drvdata(pdev->dev.parent);
+
+        return intel_pmic_install_opregion_handler(&pdev->dev,
+                        ACPI_HANDLE(pdev->dev.parent),
+                        pmic->regmap,
+                        &intel_bxtwc_pmic_opregion_data);
+}
+
+static struct platform_device_id bxt_wc_opregion_id_table[] = {
+        { .name = "bxt_wcove_region" },
+        {},
+};
+
+static struct platform_driver intel_bxtwc_pmic_opregion_driver = {
+        .probe = intel_bxtwc_pmic_opregion_probe,
+        .driver = {
+                .name = "bxt_whiskey_cove_pmic",
+        },
+        .id_table = bxt_wc_opregion_id_table,
+};
+
+static int __init intel_bxtwc_pmic_opregion_driver_init(void)
+{
+        return platform_driver_register(&intel_bxtwc_pmic_opregion_driver);
+}
+device_initcall(intel_bxtwc_pmic_opregion_driver_init);
diff --git a/drivers/acpi/pmic/intel_pmic_crc.c b/drivers/acpi/pmic/intel_pmic_crc.c
index fcd1852dcdee..d7f1761ab1bc 100644
--- a/drivers/acpi/pmic/intel_pmic_crc.c
+++ b/drivers/acpi/pmic/intel_pmic_crc.c
@@ -141,7 +141,8 @@ static int intel_crc_pmic_update_aux(struct regmap *regmap, int reg, int raw)
                 regmap_update_bits(regmap, reg - 1, 0x3, raw >> 8) ? -EIO : 0;
 }
 
-static int intel_crc_pmic_get_policy(struct regmap *regmap, int reg, u64 *value)
+static int intel_crc_pmic_get_policy(struct regmap *regmap,
+                                        int reg, int bit, u64 *value)
 {
         int pen;
 
@@ -152,7 +153,7 @@ static int intel_crc_pmic_get_policy(struct regmap *regmap, int reg, u64 *value)
 }
 
 static int intel_crc_pmic_update_policy(struct regmap *regmap,
-                                        int reg, int enable)
+                                        int reg, int bit, int enable)
 {
         int alert0;
 
diff --git a/drivers/acpi/pmic/intel_pmic_xpower.c b/drivers/acpi/pmic/intel_pmic_xpower.c
index 6a082d4de12c..e6e991ac20f3 100644
--- a/drivers/acpi/pmic/intel_pmic_xpower.c
+++ b/drivers/acpi/pmic/intel_pmic_xpower.c
@@ -13,7 +13,7 @@
  * GNU General Public License for more details.
  */
 
-#include <linux/module.h>
+#include <linux/init.h>
 #include <linux/acpi.h>
 #include <linux/mfd/axp20x.h>
 #include <linux/regmap.h>
@@ -262,7 +262,4 @@ static int __init intel_xpower_pmic_opregion_driver_init(void)
 {
         return platform_driver_register(&intel_xpower_pmic_opregion_driver);
 }
-module_init(intel_xpower_pmic_opregion_driver_init);
-
-MODULE_DESCRIPTION("XPower AXP288 ACPI operation region driver");
-MODULE_LICENSE("GPL");
+device_initcall(intel_xpower_pmic_opregion_driver_init);
diff --git a/drivers/acpi/processor_core.c b/drivers/acpi/processor_core.c
index 33a38d604630..9125d7d96372 100644
--- a/drivers/acpi/processor_core.c
+++ b/drivers/acpi/processor_core.c
@@ -108,13 +108,12 @@ static int map_gicc_mpidr(struct acpi_subtable_header *entry,
         return -EINVAL;
 }
 
-static phys_cpuid_t map_madt_entry(int type, u32 acpi_id)
+static phys_cpuid_t map_madt_entry(struct acpi_table_madt *madt,
+                                   int type, u32 acpi_id)
 {
         unsigned long madt_end, entry;
         phys_cpuid_t phys_id = PHYS_CPUID_INVALID;      /* CPU hardware ID */
-        struct acpi_table_madt *madt;
 
-        madt = get_madt_table();
         if (!madt)
                 return phys_id;
 
@@ -145,6 +144,25 @@ static phys_cpuid_t map_madt_entry(int type, u32 acpi_id)
         return phys_id;
 }
 
+phys_cpuid_t __init acpi_map_madt_entry(u32 acpi_id)
+{
+        struct acpi_table_madt *madt = NULL;
+        acpi_size tbl_size;
+        phys_cpuid_t rv;
+
+        acpi_get_table_with_size(ACPI_SIG_MADT, 0,
+                                 (struct acpi_table_header **)&madt,
+                                 &tbl_size);
+        if (!madt)
+                return PHYS_CPUID_INVALID;
+
+        rv = map_madt_entry(madt, 1, acpi_id);
+
+        early_acpi_os_unmap_memory(madt, tbl_size);
+
+        return rv;
+}
+
 static phys_cpuid_t map_mat_entry(acpi_handle handle, int type, u32 acpi_id)
 {
         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
@@ -185,7 +203,7 @@ phys_cpuid_t acpi_get_phys_id(acpi_handle handle, int type, u32 acpi_id)
 
         phys_id = map_mat_entry(handle, type, acpi_id);
         if (invalid_phys_cpuid(phys_id))
-                phys_id = map_madt_entry(type, acpi_id);
+                phys_id = map_madt_entry(get_madt_table(), type, acpi_id);
 
         return phys_id;
 }
diff --git a/drivers/acpi/processor_driver.c b/drivers/acpi/processor_driver.c
index d2fa8cb82d2b..0ca14ac7bb28 100644
--- a/drivers/acpi/processor_driver.c
+++ b/drivers/acpi/processor_driver.c
@@ -90,7 +90,7 @@ static void acpi_processor_notify(acpi_handle handle, u32 event, void *data)
                                                   pr->performance_platform_limit);
                 break;
         case ACPI_PROCESSOR_NOTIFY_POWER:
-                acpi_processor_cst_has_changed(pr);
+                acpi_processor_power_state_has_changed(pr);
                 acpi_bus_generate_netlink_event(device->pnp.device_class,
                                                   dev_name(&device->dev), event, 0);
                 break;
diff --git a/drivers/acpi/processor_idle.c b/drivers/acpi/processor_idle.c
index 444e3745c8b3..cea52528aa18 100644
--- a/drivers/acpi/processor_idle.c
+++ b/drivers/acpi/processor_idle.c
@@ -59,6 +59,12 @@ module_param(latency_factor, uint, 0644);
 
 static DEFINE_PER_CPU(struct cpuidle_device *, acpi_cpuidle_device);
 
+struct cpuidle_driver acpi_idle_driver = {
+        .name =         "acpi_idle",
+        .owner =        THIS_MODULE,
+};
+
+#ifdef CONFIG_ACPI_PROCESSOR_CSTATE
 static
 DEFINE_PER_CPU(struct acpi_processor_cx * [CPUIDLE_STATE_MAX], acpi_cstate);
 
@@ -297,7 +303,6 @@ static int acpi_processor_get_power_info_cst(struct acpi_processor *pr)
         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
         union acpi_object *cst;
 
-
         if (nocst)
                 return -ENODEV;
 
@@ -570,7 +575,7 @@ static int acpi_processor_power_verify(struct acpi_processor *pr)
         return (working);
 }
 
-static int acpi_processor_get_power_info(struct acpi_processor *pr)
+static int acpi_processor_get_cstate_info(struct acpi_processor *pr)
 {
         unsigned int i;
         int result;
@@ -804,36 +809,12 @@ static void acpi_idle_enter_freeze(struct cpuidle_device *dev,
         acpi_idle_do_entry(cx);
 }
 
-struct cpuidle_driver acpi_idle_driver = {
-        .name =         "acpi_idle",
-        .owner =        THIS_MODULE,
-};
-
-/**
- * acpi_processor_setup_cpuidle_cx - prepares and configures CPUIDLE
- * device i.e. per-cpu data
- *
- * @pr: the ACPI processor
- * @dev : the cpuidle device
- */
 static int acpi_processor_setup_cpuidle_cx(struct acpi_processor *pr,
                                            struct cpuidle_device *dev)
 {
         int i, count = CPUIDLE_DRIVER_STATE_START;
         struct acpi_processor_cx *cx;
 
-        if (!pr->flags.power_setup_done)
-                return -EINVAL;
-
-        if (pr->flags.power == 0) {
-                return -EINVAL;
-        }
-
-        if (!dev)
-                return -EINVAL;
-
-        dev->cpu = pr->id;
-
         if (max_cstate == 0)
                 max_cstate = 1;
 
@@ -856,31 +837,13 @@ static int acpi_processor_setup_cpuidle_cx(struct acpi_processor *pr,
         return 0;
 }
 
-/**
- * acpi_processor_setup_cpuidle states- prepares and configures cpuidle
- * global state data i.e. idle routines
- *
- * @pr: the ACPI processor
- */
-static int acpi_processor_setup_cpuidle_states(struct acpi_processor *pr)
+static int acpi_processor_setup_cstates(struct acpi_processor *pr)
 {
         int i, count = CPUIDLE_DRIVER_STATE_START;
         struct acpi_processor_cx *cx;
         struct cpuidle_state *state;
         struct cpuidle_driver *drv = &acpi_idle_driver;
 
-        if (!pr->flags.power_setup_done)
-                return -EINVAL;
-
-        if (pr->flags.power == 0)
-                return -EINVAL;
-
-        drv->safe_state_index = -1;
-        for (i = CPUIDLE_DRIVER_STATE_START; i < CPUIDLE_STATE_MAX; i++) {
-                drv->states[i].name[0] = '\0';
-                drv->states[i].desc[0] = '\0';
-        }
-
         if (max_cstate == 0)
                 max_cstate = 1;
 
@@ -892,7 +855,7 @@ static int acpi_processor_setup_cpuidle_states(struct acpi_processor *pr)
 
                 state = &drv->states[count];
                 snprintf(state->name, CPUIDLE_NAME_LEN, "C%d", i);
-                strncpy(state->desc, cx->desc, CPUIDLE_DESC_LEN);
+                strlcpy(state->desc, cx->desc, CPUIDLE_DESC_LEN);
                 state->exit_latency = cx->latency;
                 state->target_residency = cx->latency * latency_factor;
                 state->enter = acpi_idle_enter;
@@ -925,6 +888,450 @@ static int acpi_processor_setup_cpuidle_states(struct acpi_processor *pr)
         return 0;
 }
 
+static inline void acpi_processor_cstate_first_run_checks(void)
+{
+        acpi_status status;
+        static int first_run;
+
+        if (first_run)
+                return;
+        dmi_check_system(processor_power_dmi_table);
+        max_cstate = acpi_processor_cstate_check(max_cstate);
+        if (max_cstate < ACPI_C_STATES_MAX)
+                pr_notice("ACPI: processor limited to max C-state %d\n",
+                          max_cstate);
+        first_run++;
+
+        if (acpi_gbl_FADT.cst_control && !nocst) {
+                status = acpi_os_write_port(acpi_gbl_FADT.smi_command,
+                                            acpi_gbl_FADT.cst_control, 8);
+                if (ACPI_FAILURE(status))
+                        ACPI_EXCEPTION((AE_INFO, status,
+                                        "Notifying BIOS of _CST ability failed"));
+        }
+}
+#else
+
+static inline int disabled_by_idle_boot_param(void) { return 0; }
+static inline void acpi_processor_cstate_first_run_checks(void) { }
+static int acpi_processor_get_cstate_info(struct acpi_processor *pr)
+{
+        return -ENODEV;
+}
+
+static int acpi_processor_setup_cpuidle_cx(struct acpi_processor *pr,
+                                           struct cpuidle_device *dev)
+{
+        return -EINVAL;
+}
+
+static int acpi_processor_setup_cstates(struct acpi_processor *pr)
+{
+        return -EINVAL;
+}
+
+#endif /* CONFIG_ACPI_PROCESSOR_CSTATE */
+
+struct acpi_lpi_states_array {
+        unsigned int size;
+        unsigned int composite_states_size;
+        struct acpi_lpi_state *entries;
+        struct acpi_lpi_state *composite_states[ACPI_PROCESSOR_MAX_POWER];
+};
+
+static int obj_get_integer(union acpi_object *obj, u32 *value)
+{
+        if (obj->type != ACPI_TYPE_INTEGER)
+                return -EINVAL;
+
+        *value = obj->integer.value;
+        return 0;
+}
+
+static int acpi_processor_evaluate_lpi(acpi_handle handle,
+                                       struct acpi_lpi_states_array *info)
+{
+        acpi_status status;
+        int ret = 0;
+        int pkg_count, state_idx = 1, loop;
+        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
+        union acpi_object *lpi_data;
+        struct acpi_lpi_state *lpi_state;
+
+        status = acpi_evaluate_object(handle, "_LPI", NULL, &buffer);
+        if (ACPI_FAILURE(status)) {
+                ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No _LPI, giving up\n"));
+                return -ENODEV;
+        }
+
+        lpi_data = buffer.pointer;
+
+        /* There must be at least 4 elements = 3 elements + 1 package */
+        if (!lpi_data || lpi_data->type != ACPI_TYPE_PACKAGE ||
+            lpi_data->package.count < 4) {
+                pr_debug("not enough elements in _LPI\n");
+                ret = -ENODATA;
+                goto end;
+        }
+
+        pkg_count = lpi_data->package.elements[2].integer.value;
+
+        /* Validate number of power states. */
+        if (pkg_count < 1 || pkg_count != lpi_data->package.count - 3) {
+                pr_debug("count given by _LPI is not valid\n");
+                ret = -ENODATA;
+                goto end;
+        }
+
+        lpi_state = kcalloc(pkg_count, sizeof(*lpi_state), GFP_KERNEL);
+        if (!lpi_state) {
+                ret = -ENOMEM;
+                goto end;
+        }
+
+        info->size = pkg_count;
+        info->entries = lpi_state;
+
+        /* LPI States start at index 3 */
+        for (loop = 3; state_idx <= pkg_count; loop++, state_idx++, lpi_state++) {
+                union acpi_object *element, *pkg_elem, *obj;
+
+                element = &lpi_data->package.elements[loop];
+                if (element->type != ACPI_TYPE_PACKAGE || element->package.count < 7)
+                        continue;
+
+                pkg_elem = element->package.elements;
+
+                obj = pkg_elem + 6;
+                if (obj->type == ACPI_TYPE_BUFFER) {
+                        struct acpi_power_register *reg;
+
+                        reg = (struct acpi_power_register *)obj->buffer.pointer;
+                        if (reg->space_id != ACPI_ADR_SPACE_SYSTEM_IO &&
+                            reg->space_id != ACPI_ADR_SPACE_FIXED_HARDWARE)
+                                continue;
+
+                        lpi_state->address = reg->address;
+                        lpi_state->entry_method =
+                                reg->space_id == ACPI_ADR_SPACE_FIXED_HARDWARE ?
+                                ACPI_CSTATE_FFH : ACPI_CSTATE_SYSTEMIO;
+                } else if (obj->type == ACPI_TYPE_INTEGER) {
+                        lpi_state->entry_method = ACPI_CSTATE_INTEGER;
+                        lpi_state->address = obj->integer.value;
+                } else {
+                        continue;
+                }
+
+                /* elements[7,8] skipped for now i.e. Residency/Usage counter*/
+
+                obj = pkg_elem + 9;
+                if (obj->type == ACPI_TYPE_STRING)
+                        strlcpy(lpi_state->desc, obj->string.pointer,
+                                ACPI_CX_DESC_LEN);
+
+                lpi_state->index = state_idx;
+                if (obj_get_integer(pkg_elem + 0, &lpi_state->min_residency)) {
+                        pr_debug("No min. residency found, assuming 10 us\n");
+                        lpi_state->min_residency = 10;
+                }
+
+                if (obj_get_integer(pkg_elem + 1, &lpi_state->wake_latency)) {
+                        pr_debug("No wakeup residency found, assuming 10 us\n");
+                        lpi_state->wake_latency = 10;
+                }
+
+                if (obj_get_integer(pkg_elem + 2, &lpi_state->flags))
+                        lpi_state->flags = 0;
+
+                if (obj_get_integer(pkg_elem + 3, &lpi_state->arch_flags))
+                        lpi_state->arch_flags = 0;
+
+                if (obj_get_integer(pkg_elem + 4, &lpi_state->res_cnt_freq))
+                        lpi_state->res_cnt_freq = 1;
+
+                if (obj_get_integer(pkg_elem + 5, &lpi_state->enable_parent_state))
+                        lpi_state->enable_parent_state = 0;
+        }
+
+        acpi_handle_debug(handle, "Found %d power states\n", state_idx);
+end:
+        kfree(buffer.pointer);
+        return ret;
+}
+
+/*
+ * flat_state_cnt - the number of composite LPI states after the process of flattening
+ */
+static int flat_state_cnt;
+
+/**
+ * combine_lpi_states - combine local and parent LPI states to form a composite LPI state
+ *
+ * @local: local LPI state
+ * @parent: parent LPI state
+ * @result: composite LPI state
+ */
+static bool combine_lpi_states(struct acpi_lpi_state *local,
+                               struct acpi_lpi_state *parent,
+                               struct acpi_lpi_state *result)
+{
+        if (parent->entry_method == ACPI_CSTATE_INTEGER) {
+                if (!parent->address) /* 0 means autopromotable */
+                        return false;
+                result->address = local->address + parent->address;
+        } else {
+                result->address = parent->address;
+        }
+
+        result->min_residency = max(local->min_residency, parent->min_residency);
+        result->wake_latency = local->wake_latency + parent->wake_latency;
+        result->enable_parent_state = parent->enable_parent_state;
+        result->entry_method = local->entry_method;
+
+        result->flags = parent->flags;
+        result->arch_flags = parent->arch_flags;
+        result->index = parent->index;
+
+        strlcpy(result->desc, local->desc, ACPI_CX_DESC_LEN);
+        strlcat(result->desc, "+", ACPI_CX_DESC_LEN);
+        strlcat(result->desc, parent->desc, ACPI_CX_DESC_LEN);
+        return true;
+}
+
+#define ACPI_LPI_STATE_FLAGS_ENABLED                    BIT(0)
+
+static void stash_composite_state(struct acpi_lpi_states_array *curr_level,
+                                  struct acpi_lpi_state *t)
+{
+        curr_level->composite_states[curr_level->composite_states_size++] = t;
+}
+
+static int flatten_lpi_states(struct acpi_processor *pr,
+                              struct acpi_lpi_states_array *curr_level,
+                              struct acpi_lpi_states_array *prev_level)
+{
+        int i, j, state_count = curr_level->size;
+        struct acpi_lpi_state *p, *t = curr_level->entries;
+
+        curr_level->composite_states_size = 0;
+        for (j = 0; j < state_count; j++, t++) {
+                struct acpi_lpi_state *flpi;
+
+                if (!(t->flags & ACPI_LPI_STATE_FLAGS_ENABLED))
+                        continue;
+
+                if (flat_state_cnt >= ACPI_PROCESSOR_MAX_POWER) {
+                        pr_warn("Limiting number of LPI states to max (%d)\n",
+                                ACPI_PROCESSOR_MAX_POWER);
+                        pr_warn("Please increase ACPI_PROCESSOR_MAX_POWER if needed.\n");
+                        break;
+                }
+
+                flpi = &pr->power.lpi_states[flat_state_cnt];
+
+                if (!prev_level) { /* leaf/processor node */
+                        memcpy(flpi, t, sizeof(*t));
+                        stash_composite_state(curr_level, flpi);
+                        flat_state_cnt++;
+                        continue;
+                }
+
+                for (i = 0; i < prev_level->composite_states_size; i++) {
+                        p = prev_level->composite_states[i];
+                        if (t->index <= p->enable_parent_state &&
+                            combine_lpi_states(p, t, flpi)) {
+                                stash_composite_state(curr_level, flpi);
+                                flat_state_cnt++;
+                                flpi++;
+                        }
+                }
+        }
+
+        kfree(curr_level->entries);
+        return 0;
+}
+
+static int acpi_processor_get_lpi_info(struct acpi_processor *pr)
+{
+        int ret, i;
+        acpi_status status;
+        acpi_handle handle = pr->handle, pr_ahandle;
+        struct acpi_device *d = NULL;
+        struct acpi_lpi_states_array info[2], *tmp, *prev, *curr;
+
+        if (!osc_pc_lpi_support_confirmed)
+                return -EOPNOTSUPP;
+
+        if (!acpi_has_method(handle, "_LPI"))
+                return -EINVAL;
+
+        flat_state_cnt = 0;
+        prev = &info[0];
+        curr = &info[1];
+        handle = pr->handle;
+        ret = acpi_processor_evaluate_lpi(handle, prev);
+        if (ret)
+                return ret;
+        flatten_lpi_states(pr, prev, NULL);
+
+        status = acpi_get_parent(handle, &pr_ahandle);
+        while (ACPI_SUCCESS(status)) {
+                acpi_bus_get_device(pr_ahandle, &d);
+                handle = pr_ahandle;
+
+                if (strcmp(acpi_device_hid(d), ACPI_PROCESSOR_CONTAINER_HID))
+                        break;
+
+                /* can be optional ? */
+                if (!acpi_has_method(handle, "_LPI"))
+                        break;
+
+                ret = acpi_processor_evaluate_lpi(handle, curr);
+                if (ret)
+                        break;
+
+                /* flatten all the LPI states in this level of hierarchy */
+                flatten_lpi_states(pr, curr, prev);
+
+                tmp = prev, prev = curr, curr = tmp;
+
+                status = acpi_get_parent(handle, &pr_ahandle);
+        }
+
+        pr->power.count = flat_state_cnt;
+        /* reset the index after flattening */
+        for (i = 0; i < pr->power.count; i++)
+                pr->power.lpi_states[i].index = i;
+
+        /* Tell driver that _LPI is supported. */
+        pr->flags.has_lpi = 1;
+        pr->flags.power = 1;
+
+        return 0;
+}
+
+int __weak acpi_processor_ffh_lpi_probe(unsigned int cpu)
+{
+        return -ENODEV;
+}
+
+int __weak acpi_processor_ffh_lpi_enter(struct acpi_lpi_state *lpi)
+{
+        return -ENODEV;
+}
+
+/**
+ * acpi_idle_lpi_enter - enters an ACPI any LPI state
+ * @dev: the target CPU
+ * @drv: cpuidle driver containing cpuidle state info
+ * @index: index of target state
+ *
+ * Return: 0 for success or negative value for error
+ */
+static int acpi_idle_lpi_enter(struct cpuidle_device *dev,
+                               struct cpuidle_driver *drv, int index)
+{
+        struct acpi_processor *pr;
+        struct acpi_lpi_state *lpi;
+
+        pr = __this_cpu_read(processors);
+
+        if (unlikely(!pr))
+                return -EINVAL;
+
+        lpi = &pr->power.lpi_states[index];
+        if (lpi->entry_method == ACPI_CSTATE_FFH)
+                return acpi_processor_ffh_lpi_enter(lpi);
+
+        return -EINVAL;
+}
+
+static int acpi_processor_setup_lpi_states(struct acpi_processor *pr)
+{
+        int i;
+        struct acpi_lpi_state *lpi;
+        struct cpuidle_state *state;
+        struct cpuidle_driver *drv = &acpi_idle_driver;
+
+        if (!pr->flags.has_lpi)
+                return -EOPNOTSUPP;
+
+        for (i = 0; i < pr->power.count && i < CPUIDLE_STATE_MAX; i++) {
+                lpi = &pr->power.lpi_states[i];
+
+                state = &drv->states[i];
+                snprintf(state->name, CPUIDLE_NAME_LEN, "LPI-%d", i);
+                strlcpy(state->desc, lpi->desc, CPUIDLE_DESC_LEN);
+                state->exit_latency = lpi->wake_latency;
+                state->target_residency = lpi->min_residency;
+                if (lpi->arch_flags)
+                        state->flags |= CPUIDLE_FLAG_TIMER_STOP;
+                state->enter = acpi_idle_lpi_enter;
+                drv->safe_state_index = i;
+        }
+
+        drv->state_count = i;
+
+        return 0;
+}
+
+/**
+ * acpi_processor_setup_cpuidle_states- prepares and configures cpuidle
+ * global state data i.e. idle routines
+ *
+ * @pr: the ACPI processor
+ */
+static int acpi_processor_setup_cpuidle_states(struct acpi_processor *pr)
+{
+        int i;
+        struct cpuidle_driver *drv = &acpi_idle_driver;
+
+        if (!pr->flags.power_setup_done || !pr->flags.power)
+                return -EINVAL;
+
+        drv->safe_state_index = -1;
+        for (i = CPUIDLE_DRIVER_STATE_START; i < CPUIDLE_STATE_MAX; i++) {
+                drv->states[i].name[0] = '\0';
+                drv->states[i].desc[0] = '\0';
+        }
+
+        if (pr->flags.has_lpi)
+                return acpi_processor_setup_lpi_states(pr);
+
+        return acpi_processor_setup_cstates(pr);
+}
+
+/**
+ * acpi_processor_setup_cpuidle_dev - prepares and configures CPUIDLE
+ * device i.e. per-cpu data
+ *
+ * @pr: the ACPI processor
+ * @dev : the cpuidle device
+ */
+static int acpi_processor_setup_cpuidle_dev(struct acpi_processor *pr,
+                                            struct cpuidle_device *dev)
+{
+        if (!pr->flags.power_setup_done || !pr->flags.power || !dev)
+                return -EINVAL;
+
+        dev->cpu = pr->id;
+        if (pr->flags.has_lpi)
+                return acpi_processor_ffh_lpi_probe(pr->id);
+
+        return acpi_processor_setup_cpuidle_cx(pr, dev);
+}
+
+static int acpi_processor_get_power_info(struct acpi_processor *pr)
+{
+        int ret;
+
+        ret = acpi_processor_get_lpi_info(pr);
+        if (ret)
+                ret = acpi_processor_get_cstate_info(pr);
+
+        return ret;
+}
+
 int acpi_processor_hotplug(struct acpi_processor *pr)
 {
         int ret = 0;
@@ -933,18 +1340,15 @@ int acpi_processor_hotplug(struct acpi_processor *pr)
         if (disabled_by_idle_boot_param())
                 return 0;
 
-        if (nocst)
-                return -ENODEV;
-
         if (!pr->flags.power_setup_done)
                 return -ENODEV;
 
         dev = per_cpu(acpi_cpuidle_device, pr->id);
         cpuidle_pause_and_lock();
         cpuidle_disable_device(dev);
-        acpi_processor_get_power_info(pr);
-        if (pr->flags.power) {
-                acpi_processor_setup_cpuidle_cx(pr, dev);
+        ret = acpi_processor_get_power_info(pr);
+        if (!ret && pr->flags.power) {
+                acpi_processor_setup_cpuidle_dev(pr, dev);
                 ret = cpuidle_enable_device(dev);
         }
         cpuidle_resume_and_unlock();
@@ -952,7 +1356,7 @@ int acpi_processor_hotplug(struct acpi_processor *pr)
         return ret;
 }
 
-int acpi_processor_cst_has_changed(struct acpi_processor *pr)
+int acpi_processor_power_state_has_changed(struct acpi_processor *pr)
 {
         int cpu;
         struct acpi_processor *_pr;
@@ -961,9 +1365,6 @@ int acpi_processor_cst_has_changed(struct acpi_processor *pr)
         if (disabled_by_idle_boot_param())
                 return 0;
 
-        if (nocst)
-                return -ENODEV;
-
         if (!pr->flags.power_setup_done)
                 return -ENODEV;
 
@@ -1000,7 +1401,7 @@ int acpi_processor_cst_has_changed(struct acpi_processor *pr)
                         acpi_processor_get_power_info(_pr);
                         if (_pr->flags.power) {
                                 dev = per_cpu(acpi_cpuidle_device, cpu);
-                                acpi_processor_setup_cpuidle_cx(_pr, dev);
+                                acpi_processor_setup_cpuidle_dev(_pr, dev);
                                 cpuidle_enable_device(dev);
                         }
                 }
@@ -1015,35 +1416,16 @@ static int acpi_processor_registered;
 
 int acpi_processor_power_init(struct acpi_processor *pr)
 {
-        acpi_status status;
         int retval;
         struct cpuidle_device *dev;
-        static int first_run;
 
         if (disabled_by_idle_boot_param())
                 return 0;
 
-        if (!first_run) {
-                dmi_check_system(processor_power_dmi_table);
-                max_cstate = acpi_processor_cstate_check(max_cstate);
-                if (max_cstate < ACPI_C_STATES_MAX)
-                        printk(KERN_NOTICE
-                               "ACPI: processor limited to max C-state %d\n",
-                               max_cstate);
-                first_run++;
-        }
-
-        if (acpi_gbl_FADT.cst_control && !nocst) {
-                status =
-                    acpi_os_write_port(acpi_gbl_FADT.smi_command, acpi_gbl_FADT.cst_control, 8);
-                if (ACPI_FAILURE(status)) {
-                        ACPI_EXCEPTION((AE_INFO, status,
-                                        "Notifying BIOS of _CST ability failed"));
-                }
-        }
+        acpi_processor_cstate_first_run_checks();
 
-        acpi_processor_get_power_info(pr);
-        pr->flags.power_setup_done = 1;
+        if (!acpi_processor_get_power_info(pr))
+                pr->flags.power_setup_done = 1;
 
         /*
          * Install the idle handler if processor power management is supported.
@@ -1066,7 +1448,7 @@ int acpi_processor_power_init(struct acpi_processor *pr)
                         return -ENOMEM;
                 per_cpu(acpi_cpuidle_device, pr->id) = dev;
 
-                acpi_processor_setup_cpuidle_cx(pr, dev);
+                acpi_processor_setup_cpuidle_dev(pr, dev);
 
                 /* Register per-cpu cpuidle_device. Cpuidle driver
                  * must already be registered before registering device
diff --git a/drivers/acpi/scan.c b/drivers/acpi/scan.c
index 5f28cf778349..405056b95b05 100644
--- a/drivers/acpi/scan.c
+++ b/drivers/acpi/scan.c
@@ -494,6 +494,8 @@ static void acpi_device_del(struct acpi_device *device)
         device_del(&device->dev);
 }
 
+static BLOCKING_NOTIFIER_HEAD(acpi_reconfig_chain);
+
 static LIST_HEAD(acpi_device_del_list);
 static DEFINE_MUTEX(acpi_device_del_lock);
 
@@ -514,6 +516,9 @@ static void acpi_device_del_work_fn(struct work_struct *work_not_used)
 
                 mutex_unlock(&acpi_device_del_lock);
 
+                blocking_notifier_call_chain(&acpi_reconfig_chain,
+                                             ACPI_RECONFIG_DEVICE_REMOVE, adev);
+
                 acpi_device_del(adev);
                 /*
                  * Drop references to all power resources that might have been
@@ -1406,7 +1411,7 @@ void acpi_init_device_object(struct acpi_device *device, acpi_handle handle,
         acpi_bus_get_flags(device);
         device->flags.match_driver = false;
         device->flags.initialized = true;
-        device->flags.visited = false;
+        acpi_device_clear_enumerated(device);
         device_initialize(&device->dev);
         dev_set_uevent_suppress(&device->dev, true);
         acpi_init_coherency(device);
@@ -1676,15 +1681,20 @@ static void acpi_default_enumeration(struct acpi_device *device)
         bool is_spi_i2c_slave = false;
 
         /*
-         * Do not enemerate SPI/I2C slaves as they will be enuerated by their
+         * Do not enumerate SPI/I2C slaves as they will be enumerated 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)
+        if (!is_spi_i2c_slave) {
                 acpi_create_platform_device(device);
+                acpi_device_set_enumerated(device);
+        } else {
+                blocking_notifier_call_chain(&acpi_reconfig_chain,
+                                             ACPI_RECONFIG_DEVICE_ADD, device);
+        }
 }
 
 static const struct acpi_device_id generic_device_ids[] = {
@@ -1751,7 +1761,7 @@ static void acpi_bus_attach(struct acpi_device *device)
         acpi_bus_get_status(device);
         /* Skip devices that are not present. */
         if (!acpi_device_is_present(device)) {
-                device->flags.visited = false;
+                acpi_device_clear_enumerated(device);
                 device->flags.power_manageable = 0;
                 return;
         }
@@ -1766,7 +1776,7 @@ static void acpi_bus_attach(struct acpi_device *device)
 
                 device->flags.initialized = true;
         }
-        device->flags.visited = false;
+
         ret = acpi_scan_attach_handler(device);
         if (ret < 0)
                 return;
@@ -1780,7 +1790,6 @@ static void acpi_bus_attach(struct acpi_device *device)
                 if (!ret && device->pnp.type.platform_id)
                         acpi_default_enumeration(device);
         }
-        device->flags.visited = true;
 
  ok:
         list_for_each_entry(child, &device->children, node)
@@ -1872,7 +1881,7 @@ void acpi_bus_trim(struct acpi_device *adev)
          */
         acpi_device_set_power(adev, ACPI_STATE_D3_COLD);
         adev->flags.initialized = false;
-        adev->flags.visited = false;
+        acpi_device_clear_enumerated(adev);
 }
 EXPORT_SYMBOL_GPL(acpi_bus_trim);
 
@@ -1916,6 +1925,8 @@ static int acpi_bus_scan_fixed(void)
         return result < 0 ? result : 0;
 }
 
+static bool acpi_scan_initialized;
+
 int __init acpi_scan_init(void)
 {
         int result;
@@ -1960,6 +1971,8 @@ int __init acpi_scan_init(void)
 
         acpi_update_all_gpes();
 
+        acpi_scan_initialized = true;
+
  out:
         mutex_unlock(&acpi_scan_lock);
         return result;
@@ -2003,3 +2016,57 @@ int __init __acpi_probe_device_table(struct acpi_probe_entry *ap_head, int nr)
 
         return count;
 }
+
+struct acpi_table_events_work {
+        struct work_struct work;
+        void *table;
+        u32 event;
+};
+
+static void acpi_table_events_fn(struct work_struct *work)
+{
+        struct acpi_table_events_work *tew;
+
+        tew = container_of(work, struct acpi_table_events_work, work);
+
+        if (tew->event == ACPI_TABLE_EVENT_LOAD) {
+                acpi_scan_lock_acquire();
+                acpi_bus_scan(ACPI_ROOT_OBJECT);
+                acpi_scan_lock_release();
+        }
+
+        kfree(tew);
+}
+
+void acpi_scan_table_handler(u32 event, void *table, void *context)
+{
+        struct acpi_table_events_work *tew;
+
+        if (!acpi_scan_initialized)
+                return;
+
+        if (event != ACPI_TABLE_EVENT_LOAD)
+                return;
+
+        tew = kmalloc(sizeof(*tew), GFP_KERNEL);
+        if (!tew)
+                return;
+
+        INIT_WORK(&tew->work, acpi_table_events_fn);
+        tew->table = table;
+        tew->event = event;
+
+        schedule_work(&tew->work);
+}
+
+int acpi_reconfig_notifier_register(struct notifier_block *nb)
+{
+        return blocking_notifier_chain_register(&acpi_reconfig_chain, nb);
+}
+EXPORT_SYMBOL(acpi_reconfig_notifier_register);
+
+int acpi_reconfig_notifier_unregister(struct notifier_block *nb)
+{
+        return blocking_notifier_chain_unregister(&acpi_reconfig_chain, nb);
+}
+EXPORT_SYMBOL(acpi_reconfig_notifier_unregister);
diff --git a/drivers/acpi/sleep.c b/drivers/acpi/sleep.c
index 7a2e4d45b266..2b38c1bb0446 100644
--- a/drivers/acpi/sleep.c
+++ b/drivers/acpi/sleep.c
@@ -47,15 +47,32 @@ static void acpi_sleep_tts_switch(u32 acpi_state)
         }
 }
 
-static int tts_notify_reboot(struct notifier_block *this,
+static void acpi_sleep_pts_switch(u32 acpi_state)
+{
+        acpi_status status;
+
+        status = acpi_execute_simple_method(NULL, "\\_PTS", acpi_state);
+        if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
+                /*
+                 * OS can't evaluate the _PTS object correctly. Some warning
+                 * message will be printed. But it won't break anything.
+                 */
+                printk(KERN_NOTICE "Failure in evaluating _PTS object\n");
+        }
+}
+
+static int sleep_notify_reboot(struct notifier_block *this,
                         unsigned long code, void *x)
 {
         acpi_sleep_tts_switch(ACPI_STATE_S5);
+
+        acpi_sleep_pts_switch(ACPI_STATE_S5);
+
         return NOTIFY_DONE;
 }
 
-static struct notifier_block tts_notifier = {
-        .notifier_call  = tts_notify_reboot,
+static struct notifier_block sleep_notifier = {
+        .notifier_call  = sleep_notify_reboot,
         .next           = NULL,
         .priority       = 0,
 };
@@ -899,9 +916,9 @@ int __init acpi_sleep_init(void)
         pr_info(PREFIX "(supports%s)\n", supported);
 
         /*
-         * Register the tts_notifier to reboot notifier list so that the _TTS
-         * object can also be evaluated when the system enters S5.
+         * Register the sleep_notifier to reboot notifier list so that the _TTS
+         * and _PTS object can also be evaluated when the system enters S5.
          */
-        register_reboot_notifier(&tts_notifier);
+        register_reboot_notifier(&sleep_notifier);
         return 0;
 }
diff --git a/drivers/acpi/sysfs.c b/drivers/acpi/sysfs.c
index 4b3a9e27f1b6..358165e9f5b8 100644
--- a/drivers/acpi/sysfs.c
+++ b/drivers/acpi/sysfs.c
@@ -378,8 +378,7 @@ static void acpi_table_attr_init(struct acpi_table_attr *table_attr,
         return;
 }
 
-static acpi_status
-acpi_sysfs_table_handler(u32 event, void *table, void *context)
+acpi_status acpi_sysfs_table_handler(u32 event, void *table, void *context)
 {
         struct acpi_table_attr *table_attr;
 
@@ -452,9 +451,8 @@ static int acpi_tables_sysfs_init(void)
 
         kobject_uevent(tables_kobj, KOBJ_ADD);
         kobject_uevent(dynamic_tables_kobj, KOBJ_ADD);
-        status = acpi_install_table_handler(acpi_sysfs_table_handler, NULL);
 
-        return ACPI_FAILURE(status) ? -EINVAL : 0;
+        return 0;
 err_dynamic_tables:
         kobject_put(tables_kobj);
 err:
diff --git a/drivers/acpi/tables.c b/drivers/acpi/tables.c
index a372f9eaa15d..9f0ad6ebb368 100644
--- a/drivers/acpi/tables.c
+++ b/drivers/acpi/tables.c
@@ -34,6 +34,8 @@
 #include <linux/bootmem.h>
 #include <linux/earlycpio.h>
 #include <linux/memblock.h>
+#include <linux/initrd.h>
+#include <linux/acpi.h>
 #include "internal.h"
 
 #ifdef CONFIG_ACPI_CUSTOM_DSDT
@@ -481,8 +483,10 @@ static DECLARE_BITMAP(acpi_initrd_installed, NR_ACPI_INITRD_TABLES);
 
 #define MAP_CHUNK_SIZE   (NR_FIX_BTMAPS << PAGE_SHIFT)
 
-static void __init acpi_table_initrd_init(void *data, size_t size)
+void __init acpi_table_upgrade(void)
 {
+        void *data = (void *)initrd_start;
+        size_t size = initrd_end - initrd_start;
         int sig, no, table_nr = 0, total_offset = 0;
         long offset = 0;
         struct acpi_table_header *table;
@@ -540,7 +544,7 @@ static void __init acpi_table_initrd_init(void *data, size_t size)
                 return;
 
         acpi_tables_addr =
-                memblock_find_in_range(0, max_low_pfn_mapped << PAGE_SHIFT,
+                memblock_find_in_range(0, ACPI_TABLE_UPGRADE_MAX_PHYS,
                                        all_tables_size, PAGE_SIZE);
         if (!acpi_tables_addr) {
                 WARN_ON(1);
@@ -578,10 +582,10 @@ static void __init acpi_table_initrd_init(void *data, size_t size)
                         clen = size;
                         if (clen > MAP_CHUNK_SIZE - slop)
                                 clen = MAP_CHUNK_SIZE - slop;
-                        dest_p = early_ioremap(dest_addr & PAGE_MASK,
-                                                 clen + slop);
+                        dest_p = early_memremap(dest_addr & PAGE_MASK,
+                                                clen + slop);
                         memcpy(dest_p + slop, src_p, clen);
-                        early_iounmap(dest_p, clen + slop);
+                        early_memunmap(dest_p, clen + slop);
                         src_p += clen;
                         dest_addr += clen;
                         size -= clen;
@@ -696,10 +700,6 @@ next_table:
         }
 }
 #else
-static void __init acpi_table_initrd_init(void *data, size_t size)
-{
-}
-
 static acpi_status
 acpi_table_initrd_override(struct acpi_table_header *existing_table,
                            acpi_physical_address *address,
@@ -742,11 +742,6 @@ acpi_os_table_override(struct acpi_table_header *existing_table,
         return AE_OK;
 }
 
-void __init early_acpi_table_init(void *data, size_t size)
-{
-        acpi_table_initrd_init(data, size);
-}
-
 /*
  * acpi_table_init()
  *
diff --git a/drivers/acpi/thermal.c b/drivers/acpi/thermal.c
index 82707f9824ca..f4ebe39539af 100644
--- a/drivers/acpi/thermal.c
+++ b/drivers/acpi/thermal.c
@@ -1259,7 +1259,8 @@ static int __init acpi_thermal_init(void)
                 return -ENODEV;
         }
 
-        acpi_thermal_pm_queue = create_workqueue("acpi_thermal_pm");
+        acpi_thermal_pm_queue = alloc_workqueue("acpi_thermal_pm",
+                                                WQ_HIGHPRI | WQ_MEM_RECLAIM, 0);
         if (!acpi_thermal_pm_queue)
                 return -ENODEV;
 
diff --git a/drivers/acpi/video_detect.c b/drivers/acpi/video_detect.c
index 3d1327615f72..a6b36fc53aec 100644
--- a/drivers/acpi/video_detect.c
+++ b/drivers/acpi/video_detect.c
@@ -167,6 +167,14 @@ static const struct dmi_system_id video_detect_dmi_table[] = {
                 DMI_MATCH(DMI_PRODUCT_VERSION, "ThinkPad X201s"),
                 },
         },
+        {
+         .callback = video_detect_force_video,
+         .ident = "ThinkPad X201T",
+         .matches = {
+                DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
+                DMI_MATCH(DMI_PRODUCT_VERSION, "ThinkPad X201T"),
+                },
+        },
 
         /* The native backlight controls do not work on some older machines */
         {