Merge tag 'acpi-4.16-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm

Pull ACPI updates from Rafael Wysocki:
 "The majority of this is an update of the ACPICA kernel code to
  upstream revision 20171215 with a cosmetic change and a maintainers
  information update on top of it.

  The rest is mostly some minor fixes and cleanups in the ACPI drivers
  and cleanups to initialization on x86.

  Specifics:

   - Update the ACPICA kernel code to upstream revision 20171215 including:
      * Support for ACPI 6.0A changes in the NFIT table (Bob Moore)
      * Local 64-bit divide in string conversions (Bob Moore)
      * Fix for a regression in acpi_evaluate_object_type() (Bob Moore)
      * Fixes for memory leaks during package object resolution (Bob
        Moore)
      * Deployment of safe version of strncpy() (Bob Moore)
      * Debug and messaging updates (Bob Moore)
      * Support for PDTT, SDEV, TPM2 tables in iASL and tools (Bob
        Moore)
      * Null pointer dereference avoidance in Op and cleanups (Colin Ian
        King)
      * Fix for memory leak from building prefixed pathname (Erik
        Schmauss)
      * Coding style fixes, disassembler and compiler updates (Hanjun
        Guo, Erik Schmauss)
      * Additional PPTT flags from ACPI 6.2 (Jeremy Linton)
      * Fix for an off-by-one error in acpi_get_timer_duration()
        (Jung-uk Kim)
      * Infinite loop detection timeout and utilities cleanups (Lv
        Zheng)
      * Windows 10 version 1607 and 1703 OSI strings (Mario
        Limonciello)

   - Update ACPICA information in MAINTAINERS to reflect the current
     status of ACPICA maintenance and rename a local variable in one
     function to match the corresponding upstream code (Rafael Wysocki)

   - Clean up ACPI-related initialization on x86 (Andy Shevchenko)

   - Add support for Intel Merrifield to the ACPI GPIO code (Andy
     Shevchenko)

   - Clean up ACPI PMIC drivers (Andy Shevchenko, Arvind Yadav)

   - Fix the ACPI Generic Event Device (GED) driver to free IRQs on
     shutdown and clean up the PCI IRQ Link driver (Sinan Kaya)

   - Make the GHES code call into the AER driver on all errors and clean
     up the ACPI APEI code (Colin Ian King, Tyler Baicar)

   - Make the IA64 ACPI NUMA code parse all SRAT entries (Ganapatrao
     Kulkarni)

   - Add a lid switch blacklist to the ACPI button driver and make it
     print extra debug messages on lid events (Hans de Goede)

   - Add quirks for Asus GL502VSK and UX305LA to the ACPI battery driver
     and clean it up somewhat (Bjørn Mork, Kai-Heng Feng)

   - Add device link for CHT SD card dependency on I2C to the ACPI LPSS
     (Intel SoCs) driver and make it avoid creating platform device
     objects for devices without MMIO resources (Adrian Hunter, Hans de
     Goede)

   - Fix the ACPI GPE mask kernel command line parameter handling
     (Prarit Bhargava)

   - Fix the handling of (incorrectly exposed) backlight interfaces
     without LCD (Hans de Goede)

   - Fix the usage of debugfs_create_*() in the ACPI EC driver (Geert
     Uytterhoeven)"

* tag 'acpi-4.16-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm: (62 commits)
  ACPI/PCI: pci_link: reduce verbosity when IRQ is enabled
  ACPI / LPSS: Do not instiate platform_dev for devs without MMIO resources
  ACPI / PMIC: Convert to use builtin_platform_driver() macro
  ACPI / x86: boot: Propagate error code in acpi_gsi_to_irq()
  ACPICA: Update version to 20171215
  ACPICA: trivial style fix, no functional change
  ACPICA: Fix a couple memory leaks during package object resolution
  ACPICA: Recognize the Windows 10 version 1607 and 1703 OSI strings
  ACPICA: DT compiler: prevent error if optional field at the end of table is not present
  ACPICA: Rename a global variable, no functional change
  ACPICA: Create and deploy safe version of strncpy
  ACPICA: Cleanup the global variables and update comments
  ACPICA: Debugger: fix slight indentation issue
  ACPICA: Fix a regression in the acpi_evaluate_object_type() interface
  ACPICA: Update for a few debug output statements
  ACPICA: Debug output, no functional change
  ACPI: EC: Fix debugfs_create_*() usage
  ACPI / video: Default lcd_only to true on Win8-ready and newer machines
  ACPI / x86: boot: Don't setup SCI on HW-reduced platforms
  ACPI / x86: boot: Use INVALID_ACPI_IRQ instead of 0 for acpi_sci_override_gsi
  ...

69 files changed, 1210 insertions, 408 deletions

diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentation/admin-guide/kernel-parameters.txt
index 281c85839c17..1bdcf572c2ac 100644
--- a/Documentation/admin-guide/kernel-parameters.txt
+++ b/Documentation/admin-guide/kernel-parameters.txt
@@ -114,7 +114,6 @@
                         This facility can be used to prevent such uncontrolled
                         GPE floodings.
                         Format: <int>
-                        Support masking of GPEs numbered from 0x00 to 0x7f.
 
         acpi_no_auto_serialize  [HW,ACPI]
                         Disable auto-serialization of AML methods
diff --git a/MAINTAINERS b/MAINTAINERS
index cf729942f33d..2f0e8d927185 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -329,7 +329,7 @@ F:	drivers/acpi/apei/
 
 ACPI COMPONENT ARCHITECTURE (ACPICA)
 M:      Robert Moore <robert.moore@intel.com>
-M:      Lv Zheng <lv.zheng@intel.com>
+M:      Erik Schmauss <erik.schmauss@intel.com>
 M:      "Rafael J. Wysocki" <rafael.j.wysocki@intel.com>
 L:      linux-acpi@vger.kernel.org
 L:      devel@acpica.org
diff --git a/arch/ia64/kernel/acpi.c b/arch/ia64/kernel/acpi.c
index 1d29b2f8726b..1dacbf5e9e09 100644
--- a/arch/ia64/kernel/acpi.c
+++ b/arch/ia64/kernel/acpi.c
@@ -504,6 +504,11 @@ acpi_numa_memory_affinity_init(struct acpi_srat_mem_affinity *ma)
         if (!(ma->flags & ACPI_SRAT_MEM_ENABLED))
                 return -1;
 
+        if (num_node_memblks >= NR_NODE_MEMBLKS) {
+                pr_err("NUMA: too many memblk ranges\n");
+                return -EINVAL;
+        }
+
         /* record this node in proximity bitmap */
         pxm_bit_set(pxm);
 
diff --git a/arch/x86/include/asm/acpi.h b/arch/x86/include/asm/acpi.h
index 8d0ec9df1cbe..44f5d79d5105 100644
--- a/arch/x86/include/asm/acpi.h
+++ b/arch/x86/include/asm/acpi.h
@@ -49,7 +49,7 @@ extern int acpi_fix_pin2_polarity;
 extern int acpi_disable_cmcff;
 
 extern u8 acpi_sci_flags;
-extern int acpi_sci_override_gsi;
+extern u32 acpi_sci_override_gsi;
 void acpi_pic_sci_set_trigger(unsigned int, u16);
 
 struct device;
diff --git a/arch/x86/kernel/acpi/boot.c b/arch/x86/kernel/acpi/boot.c
index f4c463df8b08..ec3a286163c3 100644
--- a/arch/x86/kernel/acpi/boot.c
+++ b/arch/x86/kernel/acpi/boot.c
@@ -68,8 +68,9 @@ int acpi_ioapic;
 int acpi_strict;
 int acpi_disable_cmcff;
 
+/* ACPI SCI override configuration */
 u8 acpi_sci_flags __initdata;
-int acpi_sci_override_gsi __initdata;
+u32 acpi_sci_override_gsi __initdata = INVALID_ACPI_IRQ;
 int acpi_skip_timer_override __initdata;
 int acpi_use_timer_override __initdata;
 int acpi_fix_pin2_polarity __initdata;
@@ -112,8 +113,6 @@ static u32 isa_irq_to_gsi[NR_IRQS_LEGACY] __read_mostly = {
         0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
 };
 
-#define ACPI_INVALID_GSI                INT_MIN
-
 /*
  * This is just a simple wrapper around early_memremap(),
  * with sanity checks for phys == 0 and size == 0.
@@ -372,7 +371,7 @@ static void __init mp_override_legacy_irq(u8 bus_irq, u8 polarity, u8 trigger,
          * and acpi_isa_irq_to_gsi() may give wrong result.
          */
         if (gsi < nr_legacy_irqs() && isa_irq_to_gsi[gsi] == gsi)
-                isa_irq_to_gsi[gsi] = ACPI_INVALID_GSI;
+                isa_irq_to_gsi[gsi] = INVALID_ACPI_IRQ;
         isa_irq_to_gsi[bus_irq] = gsi;
 }
 
@@ -620,24 +619,24 @@ int acpi_gsi_to_irq(u32 gsi, unsigned int *irqp)
         }
 
         rc = acpi_get_override_irq(gsi, &trigger, &polarity);
-        if (rc == 0) {
-                trigger = trigger ? ACPI_LEVEL_SENSITIVE : ACPI_EDGE_SENSITIVE;
-                polarity = polarity ? ACPI_ACTIVE_LOW : ACPI_ACTIVE_HIGH;
-                irq = acpi_register_gsi(NULL, gsi, trigger, polarity);
-                if (irq >= 0) {
-                        *irqp = irq;
-                        return 0;
-                }
-        }
+        if (rc)
+                return rc;
 
-        return -1;
+        trigger = trigger ? ACPI_LEVEL_SENSITIVE : ACPI_EDGE_SENSITIVE;
+        polarity = polarity ? ACPI_ACTIVE_LOW : ACPI_ACTIVE_HIGH;
+        irq = acpi_register_gsi(NULL, gsi, trigger, polarity);
+        if (irq < 0)
+                return irq;
+
+        *irqp = irq;
+        return 0;
 }
 EXPORT_SYMBOL_GPL(acpi_gsi_to_irq);
 
 int acpi_isa_irq_to_gsi(unsigned isa_irq, u32 *gsi)
 {
         if (isa_irq < nr_legacy_irqs() &&
-            isa_irq_to_gsi[isa_irq] != ACPI_INVALID_GSI) {
+            isa_irq_to_gsi[isa_irq] != INVALID_ACPI_IRQ) {
                 *gsi = isa_irq_to_gsi[isa_irq];
                 return 0;
         }
@@ -676,8 +675,7 @@ static int acpi_register_gsi_ioapic(struct device *dev, u32 gsi,
         mutex_lock(&acpi_ioapic_lock);
         irq = mp_map_gsi_to_irq(gsi, IOAPIC_MAP_ALLOC, &info);
         /* Don't set up the ACPI SCI because it's already set up */
-        if (irq >= 0 && enable_update_mptable &&
-            acpi_gbl_FADT.sci_interrupt != gsi)
+        if (irq >= 0 && enable_update_mptable && gsi != acpi_gbl_FADT.sci_interrupt)
                 mp_config_acpi_gsi(dev, gsi, trigger, polarity);
         mutex_unlock(&acpi_ioapic_lock);
 #endif
@@ -1211,8 +1209,9 @@ static int __init acpi_parse_madt_ioapic_entries(void)
         /*
          * If BIOS did not supply an INT_SRC_OVR for the SCI
          * pretend we got one so we can set the SCI flags.
+         * But ignore setting up SCI on hardware reduced platforms.
          */
-        if (!acpi_sci_override_gsi)
+        if (acpi_sci_override_gsi == INVALID_ACPI_IRQ && !acpi_gbl_reduced_hardware)
                 acpi_sci_ioapic_setup(acpi_gbl_FADT.sci_interrupt, 0, 0,
                                       acpi_gbl_FADT.sci_interrupt);
 
diff --git a/drivers/acpi/acpi_lpss.c b/drivers/acpi/acpi_lpss.c
index 7f2b02cc8ea1..2bcffec8dbf0 100644
--- a/drivers/acpi/acpi_lpss.c
+++ b/drivers/acpi/acpi_lpss.c
@@ -427,6 +427,142 @@ out:
         return 0;
 }
 
+struct lpss_device_links {
+        const char *supplier_hid;
+        const char *supplier_uid;
+        const char *consumer_hid;
+        const char *consumer_uid;
+        u32 flags;
+};
+
+/*
+ * The _DEP method is used to identify dependencies but instead of creating
+ * device links for every handle in _DEP, only links in the following list are
+ * created. That is necessary because, in the general case, _DEP can refer to
+ * devices that might not have drivers, or that are on different buses, or where
+ * the supplier is not enumerated until after the consumer is probed.
+ */
+static const struct lpss_device_links lpss_device_links[] = {
+        {"808622C1", "7", "80860F14", "3", DL_FLAG_PM_RUNTIME},
+};
+
+static bool hid_uid_match(const char *hid1, const char *uid1,
+                          const char *hid2, const char *uid2)
+{
+        return !strcmp(hid1, hid2) && uid1 && uid2 && !strcmp(uid1, uid2);
+}
+
+static bool acpi_lpss_is_supplier(struct acpi_device *adev,
+                                  const struct lpss_device_links *link)
+{
+        return hid_uid_match(acpi_device_hid(adev), acpi_device_uid(adev),
+                             link->supplier_hid, link->supplier_uid);
+}
+
+static bool acpi_lpss_is_consumer(struct acpi_device *adev,
+                                  const struct lpss_device_links *link)
+{
+        return hid_uid_match(acpi_device_hid(adev), acpi_device_uid(adev),
+                             link->consumer_hid, link->consumer_uid);
+}
+
+struct hid_uid {
+        const char *hid;
+        const char *uid;
+};
+
+static int match_hid_uid(struct device *dev, void *data)
+{
+        struct acpi_device *adev = ACPI_COMPANION(dev);
+        struct hid_uid *id = data;
+
+        if (!adev)
+                return 0;
+
+        return hid_uid_match(acpi_device_hid(adev), acpi_device_uid(adev),
+                             id->hid, id->uid);
+}
+
+static struct device *acpi_lpss_find_device(const char *hid, const char *uid)
+{
+        struct hid_uid data = {
+                .hid = hid,
+                .uid = uid,
+        };
+
+        return bus_find_device(&platform_bus_type, NULL, &data, match_hid_uid);
+}
+
+static bool acpi_lpss_dep(struct acpi_device *adev, acpi_handle handle)
+{
+        struct acpi_handle_list dep_devices;
+        acpi_status status;
+        int i;
+
+        if (!acpi_has_method(adev->handle, "_DEP"))
+                return false;
+
+        status = acpi_evaluate_reference(adev->handle, "_DEP", NULL,
+                                         &dep_devices);
+        if (ACPI_FAILURE(status)) {
+                dev_dbg(&adev->dev, "Failed to evaluate _DEP.\n");
+                return false;
+        }
+
+        for (i = 0; i < dep_devices.count; i++) {
+                if (dep_devices.handles[i] == handle)
+                        return true;
+        }
+
+        return false;
+}
+
+static void acpi_lpss_link_consumer(struct device *dev1,
+                                    const struct lpss_device_links *link)
+{
+        struct device *dev2;
+
+        dev2 = acpi_lpss_find_device(link->consumer_hid, link->consumer_uid);
+        if (!dev2)
+                return;
+
+        if (acpi_lpss_dep(ACPI_COMPANION(dev2), ACPI_HANDLE(dev1)))
+                device_link_add(dev2, dev1, link->flags);
+
+        put_device(dev2);
+}
+
+static void acpi_lpss_link_supplier(struct device *dev1,
+                                    const struct lpss_device_links *link)
+{
+        struct device *dev2;
+
+        dev2 = acpi_lpss_find_device(link->supplier_hid, link->supplier_uid);
+        if (!dev2)
+                return;
+
+        if (acpi_lpss_dep(ACPI_COMPANION(dev1), ACPI_HANDLE(dev2)))
+                device_link_add(dev1, dev2, link->flags);
+
+        put_device(dev2);
+}
+
+static void acpi_lpss_create_device_links(struct acpi_device *adev,
+                                          struct platform_device *pdev)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(lpss_device_links); i++) {
+                const struct lpss_device_links *link = &lpss_device_links[i];
+
+                if (acpi_lpss_is_supplier(adev, link))
+                        acpi_lpss_link_consumer(&pdev->dev, link);
+
+                if (acpi_lpss_is_consumer(adev, link))
+                        acpi_lpss_link_supplier(&pdev->dev, link);
+        }
+}
+
 static int acpi_lpss_create_device(struct acpi_device *adev,
                                    const struct acpi_device_id *id)
 {
@@ -465,6 +601,8 @@ static int acpi_lpss_create_device(struct acpi_device *adev,
         acpi_dev_free_resource_list(&resource_list);
 
         if (!pdata->mmio_base) {
+                /* Avoid acpi_bus_attach() instantiating a pdev for this dev. */
+                adev->pnp.type.platform_id = 0;
                 /* Skip the device, but continue the namespace scan. */
                 ret = 0;
                 goto err_out;
@@ -500,6 +638,7 @@ static int acpi_lpss_create_device(struct acpi_device *adev,
         adev->driver_data = pdata;
         pdev = acpi_create_platform_device(adev, dev_desc->properties);
         if (!IS_ERR_OR_NULL(pdev)) {
+                acpi_lpss_create_device_links(adev, pdev);
                 return 1;
         }
 
diff --git a/drivers/acpi/acpi_video.c b/drivers/acpi/acpi_video.c
index 0972ec0e2eb8..f53ccc680238 100644
--- a/drivers/acpi/acpi_video.c
+++ b/drivers/acpi/acpi_video.c
@@ -80,8 +80,8 @@ MODULE_PARM_DESC(report_key_events,
 static bool device_id_scheme = false;
 module_param(device_id_scheme, bool, 0444);
 
-static bool only_lcd = false;
-module_param(only_lcd, bool, 0444);
+static int only_lcd = -1;
+module_param(only_lcd, int, 0444);
 
 static int register_count;
 static DEFINE_MUTEX(register_count_mutex);
@@ -2136,6 +2136,16 @@ int acpi_video_register(void)
                 goto leave;
         }
 
+        /*
+         * We're seeing a lot of bogus backlight interfaces on newer machines
+         * without a LCD such as desktops, servers and HDMI sticks. Checking
+         * the lcd flag fixes this, so enable this on any machines which are
+         * win8 ready (where we also prefer the native backlight driver, so
+         * normally the acpi_video code should not register there anyways).
+         */
+        if (only_lcd == -1)
+                only_lcd = acpi_osi_is_win8();
+
         dmi_check_system(video_dmi_table);
 
         ret = acpi_bus_register_driver(&acpi_video_bus);
diff --git a/drivers/acpi/acpica/acapps.h b/drivers/acpi/acpica/acapps.h
index 7a1a68b5ac5c..2243c8164b34 100644
--- a/drivers/acpi/acpica/acapps.h
+++ b/drivers/acpi/acpica/acapps.h
@@ -80,6 +80,9 @@
         prefix, ACPICA_COPYRIGHT, \
         prefix
 
+#define ACPI_COMMON_BUILD_TIME \
+        "Build date/time: %s %s\n", __DATE__, __TIME__
+
 /* Macros for usage messages */
 
 #define ACPI_USAGE_HEADER(usage) \
diff --git a/drivers/acpi/acpica/acdebug.h b/drivers/acpi/acpica/acdebug.h
index 71743e5252f5..54b8d9df9423 100644
--- a/drivers/acpi/acpica/acdebug.h
+++ b/drivers/acpi/acpica/acdebug.h
@@ -223,6 +223,10 @@ void
 acpi_db_execute(char *name, char **args, acpi_object_type *types, u32 flags);
 
 void
+acpi_db_create_execution_thread(char *method_name_arg,
+                                char **arguments, acpi_object_type *types);
+
+void
 acpi_db_create_execution_threads(char *num_threads_arg,
                                  char *num_loops_arg, char *method_name_arg);
 
diff --git a/drivers/acpi/acpica/acglobal.h b/drivers/acpi/acpica/acglobal.h
index 95eed442703f..45ef3f5dc9ad 100644
--- a/drivers/acpi/acpica/acglobal.h
+++ b/drivers/acpi/acpica/acglobal.h
@@ -46,7 +46,7 @@
 
 /*****************************************************************************
  *
- * Globals related to the ACPI tables
+ * Globals related to the incoming ACPI tables
  *
  ****************************************************************************/
 
@@ -87,7 +87,7 @@ ACPI_GLOBAL(u8, acpi_gbl_integer_nybble_width);
 
 /*****************************************************************************
  *
- * Mutual exclusion within ACPICA subsystem
+ * Mutual exclusion within the ACPICA subsystem
  *
  ****************************************************************************/
 
@@ -167,7 +167,7 @@ ACPI_GLOBAL(u8, acpi_gbl_next_owner_id_offset);
 
 ACPI_INIT_GLOBAL(u8, acpi_gbl_namespace_initialized, FALSE);
 
-/* Misc */
+/* Miscellaneous */
 
 ACPI_GLOBAL(u32, acpi_gbl_original_mode);
 ACPI_GLOBAL(u32, acpi_gbl_ns_lookup_count);
@@ -191,10 +191,9 @@ extern const char acpi_gbl_lower_hex_digits[];
 extern const char acpi_gbl_upper_hex_digits[];
 extern const struct acpi_opcode_info acpi_gbl_aml_op_info[AML_NUM_OPCODES];
 
-#ifdef ACPI_DBG_TRACK_ALLOCATIONS
-
 /* Lists for tracking memory allocations (debug only) */
 
+#ifdef ACPI_DBG_TRACK_ALLOCATIONS
 ACPI_GLOBAL(struct acpi_memory_list *, acpi_gbl_global_list);
 ACPI_GLOBAL(struct acpi_memory_list *, acpi_gbl_ns_node_list);
 ACPI_GLOBAL(u8, acpi_gbl_display_final_mem_stats);
@@ -203,7 +202,7 @@ ACPI_GLOBAL(u8, acpi_gbl_disable_mem_tracking);
 
 /*****************************************************************************
  *
- * Namespace globals
+ * ACPI Namespace
  *
  ****************************************************************************/
 
@@ -234,15 +233,20 @@ ACPI_INIT_GLOBAL(u32, acpi_gbl_nesting_level, 0);
 
 /*****************************************************************************
  *
- * Interpreter globals
+ * Interpreter/Parser globals
  *
  ****************************************************************************/
 
-ACPI_GLOBAL(struct acpi_thread_state *, acpi_gbl_current_walk_list);
-
 /* Control method single step flag */
 
 ACPI_GLOBAL(u8, acpi_gbl_cm_single_step);
+ACPI_GLOBAL(struct acpi_thread_state *, acpi_gbl_current_walk_list);
+ACPI_INIT_GLOBAL(union acpi_parse_object, *acpi_gbl_current_scope, NULL);
+
+/* ASL/ASL+ converter */
+
+ACPI_INIT_GLOBAL(u8, acpi_gbl_capture_comments, FALSE);
+ACPI_INIT_GLOBAL(struct acpi_comment_node, *acpi_gbl_last_list_head, NULL);
 
 /*****************************************************************************
  *
@@ -252,7 +256,6 @@ ACPI_GLOBAL(u8, acpi_gbl_cm_single_step);
 
 extern struct acpi_bit_register_info
     acpi_gbl_bit_register_info[ACPI_NUM_BITREG];
-
 ACPI_GLOBAL(u8, acpi_gbl_sleep_type_a);
 ACPI_GLOBAL(u8, acpi_gbl_sleep_type_b);
 
@@ -263,7 +266,6 @@ ACPI_GLOBAL(u8, acpi_gbl_sleep_type_b);
  ****************************************************************************/
 
 #if (!ACPI_REDUCED_HARDWARE)
-
 ACPI_GLOBAL(u8, acpi_gbl_all_gpes_initialized);
 ACPI_GLOBAL(struct acpi_gpe_xrupt_info *, acpi_gbl_gpe_xrupt_list_head);
 ACPI_GLOBAL(struct acpi_gpe_block_info *,
@@ -272,10 +274,8 @@ ACPI_GLOBAL(acpi_gbl_event_handler, acpi_gbl_global_event_handler);
 ACPI_GLOBAL(void *, acpi_gbl_global_event_handler_context);
 ACPI_GLOBAL(struct acpi_fixed_event_handler,
             acpi_gbl_fixed_event_handlers[ACPI_NUM_FIXED_EVENTS]);
-
 extern struct acpi_fixed_event_info
     acpi_gbl_fixed_event_info[ACPI_NUM_FIXED_EVENTS];
-
 #endif                          /* !ACPI_REDUCED_HARDWARE */
 
 /*****************************************************************************
@@ -291,14 +291,14 @@ ACPI_GLOBAL(u32, acpi_gpe_count);
 ACPI_GLOBAL(u32, acpi_sci_count);
 ACPI_GLOBAL(u32, acpi_fixed_event_count[ACPI_NUM_FIXED_EVENTS]);
 
-/* Support for dynamic control method tracing mechanism */
+/* Dynamic control method tracing mechanism */
 
 ACPI_GLOBAL(u32, acpi_gbl_original_dbg_level);
 ACPI_GLOBAL(u32, acpi_gbl_original_dbg_layer);
 
 /*****************************************************************************
  *
- * Debugger and Disassembler globals
+ * Debugger and Disassembler
  *
  ****************************************************************************/
 
@@ -326,7 +326,6 @@ ACPI_GLOBAL(struct acpi_external_file *, acpi_gbl_external_file_list);
 #endif
 
 #ifdef ACPI_DEBUGGER
-
 ACPI_INIT_GLOBAL(u8, acpi_gbl_abort_method, FALSE);
 ACPI_INIT_GLOBAL(acpi_thread_id, acpi_gbl_db_thread_id, ACPI_INVALID_THREAD_ID);
 
@@ -340,7 +339,6 @@ ACPI_GLOBAL(u32, acpi_gbl_db_console_debug_level);
 ACPI_GLOBAL(struct acpi_namespace_node *, acpi_gbl_db_scope_node);
 ACPI_GLOBAL(u8, acpi_gbl_db_terminate_loop);
 ACPI_GLOBAL(u8, acpi_gbl_db_threads_terminated);
-
 ACPI_GLOBAL(char *, acpi_gbl_db_args[ACPI_DEBUGGER_MAX_ARGS]);
 ACPI_GLOBAL(acpi_object_type, acpi_gbl_db_arg_types[ACPI_DEBUGGER_MAX_ARGS]);
 
@@ -350,32 +348,33 @@ ACPI_GLOBAL(char, acpi_gbl_db_parsed_buf[ACPI_DB_LINE_BUFFER_SIZE]);
 ACPI_GLOBAL(char, acpi_gbl_db_scope_buf[ACPI_DB_LINE_BUFFER_SIZE]);
 ACPI_GLOBAL(char, acpi_gbl_db_debug_filename[ACPI_DB_LINE_BUFFER_SIZE]);
 
-/*
- * Statistic globals
- */
+/* Statistics globals */
+
 ACPI_GLOBAL(u16, acpi_gbl_obj_type_count[ACPI_TOTAL_TYPES]);
 ACPI_GLOBAL(u16, acpi_gbl_node_type_count[ACPI_TOTAL_TYPES]);
 ACPI_GLOBAL(u16, acpi_gbl_obj_type_count_misc);
 ACPI_GLOBAL(u16, acpi_gbl_node_type_count_misc);
 ACPI_GLOBAL(u32, acpi_gbl_num_nodes);
 ACPI_GLOBAL(u32, acpi_gbl_num_objects);
-
 #endif                          /* ACPI_DEBUGGER */
 
 #if defined (ACPI_DISASSEMBLER) || defined (ACPI_ASL_COMPILER)
-
 ACPI_GLOBAL(const char, *acpi_gbl_pld_panel_list[]);
 ACPI_GLOBAL(const char, *acpi_gbl_pld_vertical_position_list[]);
 ACPI_GLOBAL(const char, *acpi_gbl_pld_horizontal_position_list[]);
 ACPI_GLOBAL(const char, *acpi_gbl_pld_shape_list[]);
-
 ACPI_INIT_GLOBAL(u8, acpi_gbl_disasm_flag, FALSE);
-
 #endif
 
-/*
- * Meant for the -ca option.
- */
+/*****************************************************************************
+ *
+ * ACPICA application-specific globals
+ *
+ ****************************************************************************/
+
+/* ASL-to-ASL+ conversion utility (implemented within the iASL compiler) */
+
+#ifdef ACPI_ASL_COMPILER
 ACPI_INIT_GLOBAL(char *, acpi_gbl_current_inline_comment, NULL);
 ACPI_INIT_GLOBAL(char *, acpi_gbl_current_end_node_comment, NULL);
 ACPI_INIT_GLOBAL(char *, acpi_gbl_current_open_brace_comment, NULL);
@@ -386,23 +385,18 @@ ACPI_INIT_GLOBAL(char *, acpi_gbl_current_filename, NULL);
 ACPI_INIT_GLOBAL(char *, acpi_gbl_current_parent_filename, NULL);
 ACPI_INIT_GLOBAL(char *, acpi_gbl_current_include_filename, NULL);
 
-ACPI_INIT_GLOBAL(struct acpi_comment_node, *acpi_gbl_last_list_head, NULL);
-
 ACPI_INIT_GLOBAL(struct acpi_comment_node, *acpi_gbl_def_blk_comment_list_head,
                  NULL);
 ACPI_INIT_GLOBAL(struct acpi_comment_node, *acpi_gbl_def_blk_comment_list_tail,
                  NULL);
-
 ACPI_INIT_GLOBAL(struct acpi_comment_node, *acpi_gbl_reg_comment_list_head,
                  NULL);
 ACPI_INIT_GLOBAL(struct acpi_comment_node, *acpi_gbl_reg_comment_list_tail,
                  NULL);
-
 ACPI_INIT_GLOBAL(struct acpi_comment_node, *acpi_gbl_inc_comment_list_head,
                  NULL);
 ACPI_INIT_GLOBAL(struct acpi_comment_node, *acpi_gbl_inc_comment_list_tail,
                  NULL);
-
 ACPI_INIT_GLOBAL(struct acpi_comment_node, *acpi_gbl_end_blk_comment_list_head,
                  NULL);
 ACPI_INIT_GLOBAL(struct acpi_comment_node, *acpi_gbl_end_blk_comment_list_tail,
@@ -410,30 +404,18 @@ ACPI_INIT_GLOBAL(struct acpi_comment_node, *acpi_gbl_end_blk_comment_list_tail,
 
 ACPI_INIT_GLOBAL(struct acpi_comment_addr_node,
                  *acpi_gbl_comment_addr_list_head, NULL);
-
-ACPI_INIT_GLOBAL(union acpi_parse_object, *acpi_gbl_current_scope, NULL);
-
 ACPI_INIT_GLOBAL(struct acpi_file_node, *acpi_gbl_file_tree_root, NULL);
 
 ACPI_GLOBAL(acpi_cache_t *, acpi_gbl_reg_comment_cache);
 ACPI_GLOBAL(acpi_cache_t *, acpi_gbl_comment_addr_cache);
 ACPI_GLOBAL(acpi_cache_t *, acpi_gbl_file_cache);
 
-ACPI_INIT_GLOBAL(u8, gbl_capture_comments, FALSE);
-
 ACPI_INIT_GLOBAL(u8, acpi_gbl_debug_asl_conversion, FALSE);
 ACPI_INIT_GLOBAL(ACPI_FILE, acpi_gbl_conv_debug_file, NULL);
-
 ACPI_GLOBAL(char, acpi_gbl_table_sig[4]);
-
-/*****************************************************************************
- *
- * Application globals
- *
- ****************************************************************************/
+#endif
 
 #ifdef ACPI_APPLICATION
-
 ACPI_INIT_GLOBAL(ACPI_FILE, acpi_gbl_debug_file, NULL);
 ACPI_INIT_GLOBAL(ACPI_FILE, acpi_gbl_output_file, NULL);
 ACPI_INIT_GLOBAL(u8, acpi_gbl_debug_timeout, FALSE);
@@ -442,16 +424,6 @@ ACPI_INIT_GLOBAL(u8, acpi_gbl_debug_timeout, FALSE);
 
 ACPI_GLOBAL(acpi_spinlock, acpi_gbl_print_lock);        /* For print buffer */
 ACPI_GLOBAL(char, acpi_gbl_print_buffer[1024]);
-
 #endif                          /* ACPI_APPLICATION */
 
-/*****************************************************************************
- *
- * Info/help support
- *
- ****************************************************************************/
-
-extern const struct ah_predefined_name asl_predefined_info[];
-extern const struct ah_device_id asl_device_ids[];
-
 #endif                          /* __ACGLOBAL_H__ */
diff --git a/drivers/acpi/acpica/aclocal.h b/drivers/acpi/acpica/aclocal.h
index 0d45b8bb1678..a56675f0661e 100644
--- a/drivers/acpi/acpica/aclocal.h
+++ b/drivers/acpi/acpica/aclocal.h
@@ -622,7 +622,7 @@ struct acpi_control_state {
         union acpi_parse_object *predicate_op;
         u8 *aml_predicate_start;        /* Start of if/while predicate */
         u8 *package_end;        /* End of if/while block */
-        u32 loop_count;         /* While() loop counter */
+        u64 loop_timeout;       /* While() loop timeout */
 };
 
 /*
@@ -1218,16 +1218,17 @@ struct acpi_db_method_info {
         acpi_object_type *types;
 
         /*
-         * Arguments to be passed to method for the command
-         * Threads -
-         *   the Number of threads, ID of current thread and
-         *   Index of current thread inside all them created.
+         * Arguments to be passed to method for the commands Threads and
+         * Background. Note, ACPI specifies a maximum of 7 arguments (0 - 6).
+         *
+         * For the Threads command, the Number of threads, ID of current
+         * thread and Index of current thread inside all them created.
          */
         char init_args;
 #ifdef ACPI_DEBUGGER
-        acpi_object_type arg_types[4];
+        acpi_object_type arg_types[ACPI_METHOD_NUM_ARGS];
 #endif
-        char *arguments[4];
+        char *arguments[ACPI_METHOD_NUM_ARGS];
         char num_threads_str[11];
         char id_of_thread_str[11];
         char index_of_thread_str[11];
diff --git a/drivers/acpi/acpica/acmacros.h b/drivers/acpi/acpica/acmacros.h
index c7f0c96cc00f..128a3d71b598 100644
--- a/drivers/acpi/acpica/acmacros.h
+++ b/drivers/acpi/acpica/acmacros.h
@@ -455,7 +455,7 @@
  * the plist contains a set of parens to allow variable-length lists.
  * These macros are used for both the debug and non-debug versions of the code.
  */
-#define ACPI_ERROR_NAMESPACE(s, e)          acpi_ut_namespace_error (AE_INFO, s, e);
+#define ACPI_ERROR_NAMESPACE(s, p, e)       acpi_ut_prefixed_namespace_error (AE_INFO, s, p, e);
 #define ACPI_ERROR_METHOD(s, n, p, e)       acpi_ut_method_error (AE_INFO, s, n, p, e);
 #define ACPI_WARN_PREDEFINED(plist)         acpi_ut_predefined_warning plist
 #define ACPI_INFO_PREDEFINED(plist)         acpi_ut_predefined_info plist
diff --git a/drivers/acpi/acpica/acnamesp.h b/drivers/acpi/acpica/acnamesp.h
index 54a0c51b3e37..2fb1bb78d85c 100644
--- a/drivers/acpi/acpica/acnamesp.h
+++ b/drivers/acpi/acpica/acnamesp.h
@@ -289,6 +289,9 @@ acpi_ns_build_normalized_path(struct acpi_namespace_node *node,
 char *acpi_ns_get_normalized_pathname(struct acpi_namespace_node *node,
                                       u8 no_trailing);
 
+char *acpi_ns_build_prefixed_pathname(union acpi_generic_state *prefix_scope,
+                                      const char *internal_path);
+
 char *acpi_ns_name_of_current_scope(struct acpi_walk_state *walk_state);
 
 acpi_status
diff --git a/drivers/acpi/acpica/acutils.h b/drivers/acpi/acpica/acutils.h
index 83b75e9db7ef..b6b29d717824 100644
--- a/drivers/acpi/acpica/acutils.h
+++ b/drivers/acpi/acpica/acutils.h
@@ -118,9 +118,6 @@ extern const char *acpi_gbl_ptyp_decode[];
 #ifndef ACPI_MSG_ERROR
 #define ACPI_MSG_ERROR          "ACPI Error: "
 #endif
-#ifndef ACPI_MSG_EXCEPTION
-#define ACPI_MSG_EXCEPTION      "ACPI Exception: "
-#endif
 #ifndef ACPI_MSG_WARNING
 #define ACPI_MSG_WARNING        "ACPI Warning: "
 #endif
@@ -129,10 +126,10 @@ extern const char *acpi_gbl_ptyp_decode[];
 #endif
 
 #ifndef ACPI_MSG_BIOS_ERROR
-#define ACPI_MSG_BIOS_ERROR     "ACPI BIOS Error (bug): "
+#define ACPI_MSG_BIOS_ERROR     "Firmware Error (ACPI): "
 #endif
 #ifndef ACPI_MSG_BIOS_WARNING
-#define ACPI_MSG_BIOS_WARNING   "ACPI BIOS Warning (bug): "
+#define ACPI_MSG_BIOS_WARNING   "Firmware Warning (ACPI): "
 #endif
 
 /*
@@ -233,10 +230,10 @@ u64 acpi_ut_implicit_strtoul64(char *string);
  */
 acpi_status acpi_ut_init_globals(void);
 
-#if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
-
 const char *acpi_ut_get_mutex_name(u32 mutex_id);
 
+#if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
+
 const char *acpi_ut_get_notify_name(u32 notify_value, acpi_object_type type);
 #endif
 
@@ -641,9 +638,11 @@ void ut_convert_backslashes(char *pathname);
 
 void acpi_ut_repair_name(char *name);
 
-#if defined (ACPI_DEBUGGER) || defined (ACPI_APPLICATION)
+#if defined (ACPI_DEBUGGER) || defined (ACPI_APPLICATION) || defined (ACPI_DEBUG_OUTPUT)
 u8 acpi_ut_safe_strcpy(char *dest, acpi_size dest_size, char *source);
 
+void acpi_ut_safe_strncpy(char *dest, char *source, acpi_size dest_size);
+
 u8 acpi_ut_safe_strcat(char *dest, acpi_size dest_size, char *source);
 
 u8
@@ -737,9 +736,11 @@ acpi_ut_predefined_bios_error(const char *module_name,
                               u8 node_flags, const char *format, ...);
 
 void
-acpi_ut_namespace_error(const char *module_name,
-                        u32 line_number,
-                        const char *internal_name, acpi_status lookup_status);
+acpi_ut_prefixed_namespace_error(const char *module_name,
+                                 u32 line_number,
+                                 union acpi_generic_state *prefix_scope,
+                                 const char *internal_name,
+                                 acpi_status lookup_status);
 
 void
 acpi_ut_method_error(const char *module_name,
diff --git a/drivers/acpi/acpica/dbexec.c b/drivers/acpi/acpica/dbexec.c
index 3b30319752f0..ed088fceb18d 100644
--- a/drivers/acpi/acpica/dbexec.c
+++ b/drivers/acpi/acpica/dbexec.c
@@ -67,6 +67,8 @@ static acpi_status
 acpi_db_execution_walk(acpi_handle obj_handle,
                        u32 nesting_level, void *context, void **return_value);
 
+static void ACPI_SYSTEM_XFACE acpi_db_single_execution_thread(void *context);
+
 /*******************************************************************************
  *
  * FUNCTION:    acpi_db_delete_objects
@@ -229,7 +231,7 @@ static acpi_status acpi_db_execute_setup(struct acpi_db_method_info *info)
 
         ACPI_FUNCTION_NAME(db_execute_setup);
 
-        /* Catenate the current scope to the supplied name */
+        /* Concatenate the current scope to the supplied name */
 
         info->pathname[0] = 0;
         if ((info->name[0] != '\\') && (info->name[0] != '/')) {
@@ -611,6 +613,112 @@ static void ACPI_SYSTEM_XFACE acpi_db_method_thread(void *context)
 
 /*******************************************************************************
  *
+ * FUNCTION:    acpi_db_single_execution_thread
+ *
+ * PARAMETERS:  context                 - Method info struct
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Create one thread and execute a method
+ *
+ ******************************************************************************/
+
+static void ACPI_SYSTEM_XFACE acpi_db_single_execution_thread(void *context)
+{
+        struct acpi_db_method_info *info = context;
+        acpi_status status;
+        struct acpi_buffer return_obj;
+
+        acpi_os_printf("\n");
+
+        status = acpi_db_execute_method(info, &return_obj);
+        if (ACPI_FAILURE(status)) {
+                acpi_os_printf("%s During evaluation of %s\n",
+                               acpi_format_exception(status), info->pathname);
+                return;
+        }
+
+        /* Display a return object, if any */
+
+        if (return_obj.length) {
+                acpi_os_printf("Evaluation of %s returned object %p, "
+                               "external buffer length %X\n",
+                               acpi_gbl_db_method_info.pathname,
+                               return_obj.pointer, (u32)return_obj.length);
+
+                acpi_db_dump_external_object(return_obj.pointer, 1);
+        }
+
+        acpi_os_printf("\nBackground thread completed\n%c ",
+                       ACPI_DEBUGGER_COMMAND_PROMPT);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_db_create_execution_thread
+ *
+ * PARAMETERS:  method_name_arg         - Control method to execute
+ *              arguments               - Array of arguments to the method
+ *              types                   - Corresponding array of object types
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Create a single thread to evaluate a namespace object. Handles
+ *              arguments passed on command line for control methods.
+ *
+ ******************************************************************************/
+
+void
+acpi_db_create_execution_thread(char *method_name_arg,
+                                char **arguments, acpi_object_type *types)
+{
+        acpi_status status;
+        u32 i;
+
+        memset(&acpi_gbl_db_method_info, 0, sizeof(struct acpi_db_method_info));
+        acpi_gbl_db_method_info.name = method_name_arg;
+        acpi_gbl_db_method_info.init_args = 1;
+        acpi_gbl_db_method_info.args = acpi_gbl_db_method_info.arguments;
+        acpi_gbl_db_method_info.types = acpi_gbl_db_method_info.arg_types;
+
+        /* Setup method arguments, up to 7 (0-6) */
+
+        for (i = 0; (i < ACPI_METHOD_NUM_ARGS) && *arguments; i++) {
+                acpi_gbl_db_method_info.arguments[i] = *arguments;
+                arguments++;
+
+                acpi_gbl_db_method_info.arg_types[i] = *types;
+                types++;
+        }
+
+        status = acpi_db_execute_setup(&acpi_gbl_db_method_info);
+        if (ACPI_FAILURE(status)) {
+                return;
+        }
+
+        /* Get the NS node, determines existence also */
+
+        status = acpi_get_handle(NULL, acpi_gbl_db_method_info.pathname,
+                                 &acpi_gbl_db_method_info.method);
+        if (ACPI_FAILURE(status)) {
+                acpi_os_printf("%s Could not get handle for %s\n",
+                               acpi_format_exception(status),
+                               acpi_gbl_db_method_info.pathname);
+                return;
+        }
+
+        status = acpi_os_execute(OSL_DEBUGGER_EXEC_THREAD,
+                                 acpi_db_single_execution_thread,
+                                 &acpi_gbl_db_method_info);
+        if (ACPI_FAILURE(status)) {
+                return;
+        }
+
+        acpi_os_printf("\nBackground thread started\n");
+}
+
+/*******************************************************************************
+ *
  * FUNCTION:    acpi_db_create_execution_threads
  *
  * PARAMETERS:  num_threads_arg         - Number of threads to create
diff --git a/drivers/acpi/acpica/dbfileio.c b/drivers/acpi/acpica/dbfileio.c
index 4d81ea291d93..cf9607945704 100644
--- a/drivers/acpi/acpica/dbfileio.c
+++ b/drivers/acpi/acpica/dbfileio.c
@@ -99,8 +99,8 @@ void acpi_db_open_debug_file(char *name)
         }
 
         acpi_os_printf("Debug output file %s opened\n", name);
-        strncpy(acpi_gbl_db_debug_filename, name,
-                sizeof(acpi_gbl_db_debug_filename));
+        acpi_ut_safe_strncpy(acpi_gbl_db_debug_filename, name,
+                             sizeof(acpi_gbl_db_debug_filename));
         acpi_gbl_db_output_to_file = TRUE;
 }
 #endif
diff --git a/drivers/acpi/acpica/dbinput.c b/drivers/acpi/acpica/dbinput.c
index 2626d79db064..954ca3b981a7 100644
--- a/drivers/acpi/acpica/dbinput.c
+++ b/drivers/acpi/acpica/dbinput.c
@@ -136,6 +136,7 @@ enum acpi_ex_debugger_commands {
         CMD_UNLOAD,
 
         CMD_TERMINATE,
+        CMD_BACKGROUND,
         CMD_THREADS,
 
         CMD_TEST,
@@ -212,6 +213,7 @@ static const struct acpi_db_command_info acpi_gbl_db_commands[] = {
         {"UNLOAD", 1},
 
         {"TERMINATE", 0},
+        {"BACKGROUND", 1},
         {"THREADS", 3},
 
         {"TEST", 1},
@@ -222,9 +224,56 @@ static const struct acpi_db_command_info acpi_gbl_db_commands[] = {
 /*
  * Help for all debugger commands. First argument is the number of lines
  * of help to output for the command.
+ *
+ * Note: Some commands are not supported by the kernel-level version of
+ * the debugger.
  */
 static const struct acpi_db_command_help acpi_gbl_db_command_help[] = {
-        {0, "\nGeneral-Purpose Commands:", "\n"},
+        {0, "\nNamespace Access:", "\n"},
+        {1, "  Businfo", "Display system bus info\n"},
+        {1, "  Disassemble <Method>", "Disassemble a control method\n"},
+        {1, "  Find <AcpiName> (? is wildcard)",
+         "Find ACPI name(s) with wildcards\n"},
+        {1, "  Integrity", "Validate namespace integrity\n"},
+        {1, "  Methods", "Display list of loaded control methods\n"},
+        {1, "  Namespace [Object] [Depth]",
+         "Display loaded namespace tree/subtree\n"},
+        {1, "  Notify <Object> <Value>", "Send a notification on Object\n"},
+        {1, "  Objects [ObjectType]",
+         "Display summary of all objects or just given type\n"},
+        {1, "  Owner <OwnerId> [Depth]",
+         "Display loaded namespace by object owner\n"},
+        {1, "  Paths", "Display full pathnames of namespace objects\n"},
+        {1, "  Predefined", "Check all predefined names\n"},
+        {1, "  Prefix [<Namepath>]", "Set or Get current execution prefix\n"},
+        {1, "  References <Addr>", "Find all references to object at addr\n"},
+        {1, "  Resources [DeviceName]",
+         "Display Device resources (no arg = all devices)\n"},
+        {1, "  Set N <NamedObject> <Value>", "Set value for named integer\n"},
+        {1, "  Template <Object>", "Format/dump a Buffer/ResourceTemplate\n"},
+        {1, "  Type <Object>", "Display object type\n"},
+
+        {0, "\nControl Method Execution:", "\n"},
+        {1, "  Evaluate <Namepath> [Arguments]",
+         "Evaluate object or control method\n"},
+        {1, "  Execute <Namepath> [Arguments]", "Synonym for Evaluate\n"},
+#ifdef ACPI_APPLICATION
+        {1, "  Background <Namepath> [Arguments]",
+         "Evaluate object/method in a separate thread\n"},
+        {1, "  Thread <Threads><Loops><NamePath>",
+         "Spawn threads to execute method(s)\n"},
+#endif
+        {1, "  Debug <Namepath> [Arguments]", "Single-Step a control method\n"},
+        {7, "  [Arguments] formats:", "Control method argument formats\n"},
+        {1, "     Hex Integer", "Integer\n"},
+        {1, "     \"Ascii String\"", "String\n"},
+        {1, "     (Hex Byte List)", "Buffer\n"},
+        {1, "         (01 42 7A BF)", "Buffer example (4 bytes)\n"},
+        {1, "     [Package Element List]", "Package\n"},
+        {1, "         [0x01 0x1234 \"string\"]",
+         "Package example (3 elements)\n"},
+
+        {0, "\nMiscellaneous:", "\n"},
         {1, "  Allocations", "Display list of current memory allocations\n"},
         {2, "  Dump <Address>|<Namepath>", "\n"},
         {0, "       [Byte|Word|Dword|Qword]",
@@ -248,46 +297,30 @@ static const struct acpi_db_command_help acpi_gbl_db_command_help[] = {
         {1, "     Stack", "Display CPU stack usage\n"},
         {1, "     Tables", "Info about current ACPI table(s)\n"},
         {1, "  Tables", "Display info about loaded ACPI tables\n"},
+#ifdef ACPI_APPLICATION
+        {1, "  Terminate", "Delete namespace and all internal objects\n"},
+#endif
         {1, "  ! <CommandNumber>", "Execute command from history buffer\n"},
         {1, "  !!", "Execute last command again\n"},
 
-        {0, "\nNamespace Access Commands:", "\n"},
-        {1, "  Businfo", "Display system bus info\n"},
-        {1, "  Disassemble <Method>", "Disassemble a control method\n"},
-        {1, "  Find <AcpiName> (? is wildcard)",
-         "Find ACPI name(s) with wildcards\n"},
-        {1, "  Integrity", "Validate namespace integrity\n"},
-        {1, "  Methods", "Display list of loaded control methods\n"},
-        {1, "  Namespace [Object] [Depth]",
-         "Display loaded namespace tree/subtree\n"},
-        {1, "  Notify <Object> <Value>", "Send a notification on Object\n"},
-        {1, "  Objects [ObjectType]",
-         "Display summary of all objects or just given type\n"},
-        {1, "  Owner <OwnerId> [Depth]",
-         "Display loaded namespace by object owner\n"},
-        {1, "  Paths", "Display full pathnames of namespace objects\n"},
-        {1, "  Predefined", "Check all predefined names\n"},
-        {1, "  Prefix [<Namepath>]", "Set or Get current execution prefix\n"},
-        {1, "  References <Addr>", "Find all references to object at addr\n"},
-        {1, "  Resources [DeviceName]",
-         "Display Device resources (no arg = all devices)\n"},
-        {1, "  Set N <NamedObject> <Value>", "Set value for named integer\n"},
-        {1, "  Template <Object>", "Format/dump a Buffer/ResourceTemplate\n"},
-        {1, "  Type <Object>", "Display object type\n"},
+        {0, "\nMethod and Namespace Debugging:", "\n"},
+        {5, "  Trace <State> [<Namepath>] [Once]",
+         "Trace control method execution\n"},
+        {1, "     Enable", "Enable all messages\n"},
+        {1, "     Disable", "Disable tracing\n"},
+        {1, "     Method", "Enable method execution messages\n"},
+        {1, "     Opcode", "Enable opcode execution messages\n"},
+        {3, "  Test <TestName>", "Invoke a debug test\n"},
+        {1, "     Objects", "Read/write/compare all namespace data objects\n"},
+        {1, "     Predefined",
+         "Validate all ACPI predefined names (_STA, etc.)\n"},
+        {1, "  Execute predefined",
+         "Execute all predefined (public) methods\n"},
 
-        {0, "\nControl Method Execution Commands:", "\n"},
+        {0, "\nControl Method Single-Step Execution:", "\n"},
         {1, "  Arguments (or Args)", "Display method arguments\n"},
         {1, "  Breakpoint <AmlOffset>", "Set an AML execution breakpoint\n"},
         {1, "  Call", "Run to next control method invocation\n"},
-        {1, "  Debug <Namepath> [Arguments]", "Single Step a control method\n"},
-        {6, "  Evaluate", "Synonym for Execute\n"},
-        {5, "  Execute <Namepath> [Arguments]", "Execute control method\n"},
-        {1, "     Hex Integer", "Integer method argument\n"},
-        {1, "     \"Ascii String\"", "String method argument\n"},
-        {1, "     (Hex Byte List)", "Buffer method argument\n"},
-        {1, "     [Package Element List]", "Package method argument\n"},
-        {5, "  Execute predefined",
-         "Execute all predefined (public) methods\n"},
         {1, "  Go", "Allow method to run to completion\n"},
         {1, "  Information", "Display info about the current method\n"},
         {1, "  Into", "Step into (not over) a method call\n"},
@@ -296,41 +329,24 @@ static const struct acpi_db_command_help acpi_gbl_db_command_help[] = {
         {1, "  Results", "Display method result stack\n"},
         {1, "  Set <A|L> <#> <Value>", "Set method data (Arguments/Locals)\n"},
         {1, "  Stop", "Terminate control method\n"},
-        {5, "  Trace <State> [<Namepath>] [Once]",
-         "Trace control method execution\n"},
-        {1, "     Enable", "Enable all messages\n"},
-        {1, "     Disable", "Disable tracing\n"},
-        {1, "     Method", "Enable method execution messages\n"},
-        {1, "     Opcode", "Enable opcode execution messages\n"},
         {1, "  Tree", "Display control method calling tree\n"},
         {1, "  <Enter>", "Single step next AML opcode (over calls)\n"},
 
 #ifdef ACPI_APPLICATION
-        {0, "\nHardware Simulation Commands:", "\n"},
-        {1, "  EnableAcpi", "Enable ACPI (hardware) mode\n"},
-        {1, "  Event <F|G> <Value>", "Generate AcpiEvent (Fixed/GPE)\n"},
-        {1, "  Gpe <GpeNum> [GpeBlockDevice]", "Simulate a GPE\n"},
-        {1, "  Gpes", "Display info on all GPE devices\n"},
-        {1, "  Sci", "Generate an SCI\n"},
-        {1, "  Sleep [SleepState]", "Simulate sleep/wake sequence(s) (0-5)\n"},
-
-        {0, "\nFile I/O Commands:", "\n"},
+        {0, "\nFile Operations:", "\n"},
         {1, "  Close", "Close debug output file\n"},
         {1, "  Load <Input Filename>", "Load ACPI table from a file\n"},
         {1, "  Open <Output Filename>", "Open a file for debug output\n"},
         {1, "  Unload <Namepath>",
          "Unload an ACPI table via namespace object\n"},
 
-        {0, "\nUser Space Commands:", "\n"},
-        {1, "  Terminate", "Delete namespace and all internal objects\n"},
-        {1, "  Thread <Threads><Loops><NamePath>",
-         "Spawn threads to execute method(s)\n"},
-
-        {0, "\nDebug Test Commands:", "\n"},
-        {3, "  Test <TestName>", "Invoke a debug test\n"},
-        {1, "     Objects", "Read/write/compare all namespace data objects\n"},
-        {1, "     Predefined",
-         "Execute all ACPI predefined names (_STA, etc.)\n"},
+        {0, "\nHardware Simulation:", "\n"},
+        {1, "  EnableAcpi", "Enable ACPI (hardware) mode\n"},
+        {1, "  Event <F|G> <Value>", "Generate AcpiEvent (Fixed/GPE)\n"},
+        {1, "  Gpe <GpeNum> [GpeBlockDevice]", "Simulate a GPE\n"},
+        {1, "  Gpes", "Display info on all GPE devices\n"},
+        {1, "  Sci", "Generate an SCI\n"},
+        {1, "  Sleep [SleepState]", "Simulate sleep/wake sequence(s) (0-5)\n"},
 #endif
         {0, NULL, NULL}
 };
@@ -442,11 +458,15 @@ static void acpi_db_display_help(char *command)
 
                 /* No argument to help, display help for all commands */
 
+                acpi_os_printf("\nSummary of AML Debugger Commands\n\n");
+
                 while (next->invocation) {
                         acpi_os_printf("%-38s%s", next->invocation,
                                        next->description);
                         next++;
                 }
+                acpi_os_printf("\n");
+
         } else {
                 /* Display help for all commands that match the subtring */
 
@@ -1087,6 +1107,13 @@ acpi_db_command_dispatch(char *input_buffer,
                 /*  acpi_initialize (NULL); */
                 break;
 
+        case CMD_BACKGROUND:
+
+                acpi_db_create_execution_thread(acpi_gbl_db_args[1],
+                                                &acpi_gbl_db_args[2],
+                                                &acpi_gbl_db_arg_types[2]);
+                break;
+
         case CMD_THREADS:
 
                 acpi_db_create_execution_threads(acpi_gbl_db_args[1],
diff --git a/drivers/acpi/acpica/dscontrol.c b/drivers/acpi/acpica/dscontrol.c
index f470e81b0499..4b6ebc2a2851 100644
--- a/drivers/acpi/acpica/dscontrol.c
+++ b/drivers/acpi/acpica/dscontrol.c
@@ -118,6 +118,8 @@ acpi_ds_exec_begin_control_op(struct acpi_walk_state *walk_state,
                 control_state->control.package_end =
                     walk_state->parser_state.pkg_end;
                 control_state->control.opcode = op->common.aml_opcode;
+                control_state->control.loop_timeout = acpi_os_get_timer() +
+                    (u64)(acpi_gbl_max_loop_iterations * ACPI_100NSEC_PER_SEC);
 
                 /* Push the control state on this walk's control stack */
 
@@ -206,15 +208,15 @@ acpi_ds_exec_end_control_op(struct acpi_walk_state *walk_state,
                         /* Predicate was true, the body of the loop was just executed */
 
                         /*
-                         * This loop counter mechanism allows the interpreter to escape
-                         * possibly infinite loops. This can occur in poorly written AML
-                         * when the hardware does not respond within a while loop and the
-                         * loop does not implement a timeout.
+                         * This infinite loop detection mechanism allows the interpreter
+                         * to escape possibly infinite loops. This can occur in poorly
+                         * written AML when the hardware does not respond within a while
+                         * loop and the loop does not implement a timeout.
                          */
-                        control_state->control.loop_count++;
-                        if (control_state->control.loop_count >
-                            acpi_gbl_max_loop_iterations) {
-                                status = AE_AML_INFINITE_LOOP;
+                        if (ACPI_TIME_AFTER(acpi_os_get_timer(),
+                                            control_state->control.
+                                            loop_timeout)) {
+                                status = AE_AML_LOOP_TIMEOUT;
                                 break;
                         }
 
diff --git a/drivers/acpi/acpica/dsfield.c b/drivers/acpi/acpica/dsfield.c
index 7bcf5f5ea029..0cab34a593d5 100644
--- a/drivers/acpi/acpica/dsfield.c
+++ b/drivers/acpi/acpica/dsfield.c
@@ -209,7 +209,8 @@ acpi_ds_create_buffer_field(union acpi_parse_object *op,
                                         ACPI_IMODE_LOAD_PASS1, flags,
                                         walk_state, &node);
                 if (ACPI_FAILURE(status)) {
-                        ACPI_ERROR_NAMESPACE(arg->common.value.string, status);
+                        ACPI_ERROR_NAMESPACE(walk_state->scope_info,
+                                             arg->common.value.string, status);
                         return_ACPI_STATUS(status);
                 }
         }
@@ -383,7 +384,9 @@ acpi_ds_get_field_names(struct acpi_create_field_info *info,
                                                         walk_state,
                                                         &info->connection_node);
                                 if (ACPI_FAILURE(status)) {
-                                        ACPI_ERROR_NAMESPACE(child->common.
+                                        ACPI_ERROR_NAMESPACE(walk_state->
+                                                             scope_info,
+                                                             child->common.
                                                              value.name,
                                                              status);
                                         return_ACPI_STATUS(status);
@@ -402,7 +405,8 @@ acpi_ds_get_field_names(struct acpi_create_field_info *info,
                                                 ACPI_NS_DONT_OPEN_SCOPE,
                                                 walk_state, &info->field_node);
                         if (ACPI_FAILURE(status)) {
-                                ACPI_ERROR_NAMESPACE((char *)&arg->named.name,
+                                ACPI_ERROR_NAMESPACE(walk_state->scope_info,
+                                                     (char *)&arg->named.name,
                                                      status);
                                 return_ACPI_STATUS(status);
                         } else {
@@ -498,7 +502,8 @@ acpi_ds_create_field(union acpi_parse_object *op,
                                                         &region_node);
 #endif
                 if (ACPI_FAILURE(status)) {
-                        ACPI_ERROR_NAMESPACE(arg->common.value.name, status);
+                        ACPI_ERROR_NAMESPACE(walk_state->scope_info,
+                                             arg->common.value.name, status);
                         return_ACPI_STATUS(status);
                 }
         }
@@ -618,7 +623,8 @@ acpi_ds_init_field_objects(union acpi_parse_object *op,
                                                 ACPI_IMODE_LOAD_PASS1, flags,
                                                 walk_state, &node);
                         if (ACPI_FAILURE(status)) {
-                                ACPI_ERROR_NAMESPACE((char *)&arg->named.name,
+                                ACPI_ERROR_NAMESPACE(walk_state->scope_info,
+                                                     (char *)&arg->named.name,
                                                      status);
                                 if (status != AE_ALREADY_EXISTS) {
                                         return_ACPI_STATUS(status);
@@ -681,7 +687,8 @@ acpi_ds_create_bank_field(union acpi_parse_object *op,
                                                         &region_node);
 #endif
                 if (ACPI_FAILURE(status)) {
-                        ACPI_ERROR_NAMESPACE(arg->common.value.name, status);
+                        ACPI_ERROR_NAMESPACE(walk_state->scope_info,
+                                             arg->common.value.name, status);
                         return_ACPI_STATUS(status);
                 }
         }
@@ -695,7 +702,8 @@ acpi_ds_create_bank_field(union acpi_parse_object *op,
                            ACPI_NS_SEARCH_PARENT, walk_state,
                            &info.register_node);
         if (ACPI_FAILURE(status)) {
-                ACPI_ERROR_NAMESPACE(arg->common.value.string, status);
+                ACPI_ERROR_NAMESPACE(walk_state->scope_info,
+                                     arg->common.value.string, status);
                 return_ACPI_STATUS(status);
         }
 
@@ -765,7 +773,8 @@ acpi_ds_create_index_field(union acpi_parse_object *op,
                            ACPI_NS_SEARCH_PARENT, walk_state,
                            &info.register_node);
         if (ACPI_FAILURE(status)) {
-                ACPI_ERROR_NAMESPACE(arg->common.value.string, status);
+                ACPI_ERROR_NAMESPACE(walk_state->scope_info,
+                                     arg->common.value.string, status);
                 return_ACPI_STATUS(status);
         }
 
@@ -778,7 +787,8 @@ acpi_ds_create_index_field(union acpi_parse_object *op,
                            ACPI_NS_SEARCH_PARENT, walk_state,
                            &info.data_register_node);
         if (ACPI_FAILURE(status)) {
-                ACPI_ERROR_NAMESPACE(arg->common.value.string, status);
+                ACPI_ERROR_NAMESPACE(walk_state->scope_info,
+                                     arg->common.value.string, status);
                 return_ACPI_STATUS(status);
         }
 
diff --git a/drivers/acpi/acpica/dsobject.c b/drivers/acpi/acpica/dsobject.c
index 82448551781b..b21fe084ffc8 100644
--- a/drivers/acpi/acpica/dsobject.c
+++ b/drivers/acpi/acpica/dsobject.c
@@ -112,7 +112,9 @@ acpi_ds_build_internal_object(struct acpi_walk_state *walk_state,
                                                          acpi_namespace_node,
                                                          &(op->common.node)));
                                 if (ACPI_FAILURE(status)) {
-                                        ACPI_ERROR_NAMESPACE(op->common.value.
+                                        ACPI_ERROR_NAMESPACE(walk_state->
+                                                             scope_info,
+                                                             op->common.value.
                                                              string, status);
                                         return_ACPI_STATUS(status);
                                 }
diff --git a/drivers/acpi/acpica/dspkginit.c b/drivers/acpi/acpica/dspkginit.c
index 6d487edfe2de..5a602b75084e 100644
--- a/drivers/acpi/acpica/dspkginit.c
+++ b/drivers/acpi/acpica/dspkginit.c
@@ -297,8 +297,10 @@ acpi_ds_init_package_element(u8 object_type,
 {
         union acpi_operand_object **element_ptr;
 
+        ACPI_FUNCTION_TRACE(ds_init_package_element);
+
         if (!source_object) {
-                return (AE_OK);
+                return_ACPI_STATUS(AE_OK);
         }
 
         /*
@@ -329,7 +331,7 @@ acpi_ds_init_package_element(u8 object_type,
                 source_object->package.flags |= AOPOBJ_DATA_VALID;
         }
 
-        return (AE_OK);
+        return_ACPI_STATUS(AE_OK);
 }
 
 /*******************************************************************************
@@ -352,6 +354,7 @@ acpi_ds_resolve_package_element(union acpi_operand_object **element_ptr)
         union acpi_generic_state scope_info;
         union acpi_operand_object *element = *element_ptr;
         struct acpi_namespace_node *resolved_node;
+        struct acpi_namespace_node *original_node;
         char *external_path = NULL;
         acpi_object_type type;
 
@@ -441,6 +444,7 @@ acpi_ds_resolve_package_element(union acpi_operand_object **element_ptr)
          * will remain as named references. This behavior is not described
          * in the ACPI spec, but it appears to be an oversight.
          */
+        original_node = resolved_node;
         status = acpi_ex_resolve_node_to_value(&resolved_node, NULL);
         if (ACPI_FAILURE(status)) {
                 return_VOID;
@@ -468,26 +472,27 @@ acpi_ds_resolve_package_element(union acpi_operand_object **element_ptr)
                  */
         case ACPI_TYPE_DEVICE:
         case ACPI_TYPE_THERMAL:
-
-                /* TBD: This may not be necesssary */
-
-                acpi_ut_add_reference(resolved_node->object);
+        case ACPI_TYPE_METHOD:
                 break;
 
         case ACPI_TYPE_MUTEX:
-        case ACPI_TYPE_METHOD:
         case ACPI_TYPE_POWER:
         case ACPI_TYPE_PROCESSOR:
         case ACPI_TYPE_EVENT:
         case ACPI_TYPE_REGION:
 
+                /* acpi_ex_resolve_node_to_value gave these an extra reference */
+
+                acpi_ut_remove_reference(original_node->object);
                 break;
 
         default:
                 /*
                  * For all other types - the node was resolved to an actual
-                 * operand object with a value, return the object
+                 * operand object with a value, return the object. Remove
+                 * a reference on the existing object.
                  */
+                acpi_ut_remove_reference(element);
                 *element_ptr = (union acpi_operand_object *)resolved_node;
                 break;
         }
diff --git a/drivers/acpi/acpica/dsutils.c b/drivers/acpi/acpica/dsutils.c
index 0dabd9b95684..4c5faf629a83 100644
--- a/drivers/acpi/acpica/dsutils.c
+++ b/drivers/acpi/acpica/dsutils.c
@@ -583,7 +583,8 @@ acpi_ds_create_operand(struct acpi_walk_state *walk_state,
                         }
 
                         if (ACPI_FAILURE(status)) {
-                                ACPI_ERROR_NAMESPACE(name_string, status);
+                                ACPI_ERROR_NAMESPACE(walk_state->scope_info,
+                                                     name_string, status);
                         }
                 }
 
diff --git a/drivers/acpi/acpica/dswload.c b/drivers/acpi/acpica/dswload.c
index eaa859a89702..5771e4e4a99a 100644
--- a/drivers/acpi/acpica/dswload.c
+++ b/drivers/acpi/acpica/dswload.c
@@ -207,7 +207,8 @@ acpi_ds_load1_begin_op(struct acpi_walk_state *walk_state,
                 }
 #endif
                 if (ACPI_FAILURE(status)) {
-                        ACPI_ERROR_NAMESPACE(path, status);
+                        ACPI_ERROR_NAMESPACE(walk_state->scope_info, path,
+                                             status);
                         return_ACPI_STATUS(status);
                 }
 
@@ -375,7 +376,8 @@ acpi_ds_load1_begin_op(struct acpi_walk_state *walk_state,
                         }
 
                         if (ACPI_FAILURE(status)) {
-                                ACPI_ERROR_NAMESPACE(path, status);
+                                ACPI_ERROR_NAMESPACE(walk_state->scope_info,
+                                                     path, status);
                                 return_ACPI_STATUS(status);
                         }
                 }
diff --git a/drivers/acpi/acpica/dswload2.c b/drivers/acpi/acpica/dswload2.c
index aad83ef5a4ec..b3d0aaec8203 100644
--- a/drivers/acpi/acpica/dswload2.c
+++ b/drivers/acpi/acpica/dswload2.c
@@ -184,11 +184,14 @@ acpi_ds_load2_begin_op(struct acpi_walk_state *walk_state,
                                 if (status == AE_NOT_FOUND) {
                                         status = AE_OK;
                                 } else {
-                                        ACPI_ERROR_NAMESPACE(buffer_ptr,
+                                        ACPI_ERROR_NAMESPACE(walk_state->
+                                                             scope_info,
+                                                             buffer_ptr,
                                                              status);
                                 }
 #else
-                                ACPI_ERROR_NAMESPACE(buffer_ptr, status);
+                                ACPI_ERROR_NAMESPACE(walk_state->scope_info,
+                                                     buffer_ptr, status);
 #endif
                                 return_ACPI_STATUS(status);
                         }
@@ -343,7 +346,8 @@ acpi_ds_load2_begin_op(struct acpi_walk_state *walk_state,
         }
 
         if (ACPI_FAILURE(status)) {
-                ACPI_ERROR_NAMESPACE(buffer_ptr, status);
+                ACPI_ERROR_NAMESPACE(walk_state->scope_info,
+                                     buffer_ptr, status);
                 return_ACPI_STATUS(status);
         }
 
@@ -719,7 +723,8 @@ acpi_status acpi_ds_load2_end_op(struct acpi_walk_state *walk_state)
                          */
                         op->common.node = new_node;
                 } else {
-                        ACPI_ERROR_NAMESPACE(arg->common.value.string, status);
+                        ACPI_ERROR_NAMESPACE(walk_state->scope_info,
+                                             arg->common.value.string, status);
                 }
                 break;
 
diff --git a/drivers/acpi/acpica/evregion.c b/drivers/acpi/acpica/evregion.c
index 28b447ff92df..bb58419f0d61 100644
--- a/drivers/acpi/acpica/evregion.c
+++ b/drivers/acpi/acpica/evregion.c
@@ -298,6 +298,16 @@ acpi_ev_address_space_dispatch(union acpi_operand_object *region_obj,
                 ACPI_EXCEPTION((AE_INFO, status, "Returned by Handler for [%s]",
                                 acpi_ut_get_region_name(region_obj->region.
                                                         space_id)));
+
+                /*
+                 * Special case for an EC timeout. These are seen so frequently
+                 * that an additional error message is helpful
+                 */
+                if ((region_obj->region.space_id == ACPI_ADR_SPACE_EC) &&
+                    (status == AE_TIME)) {
+                        ACPI_ERROR((AE_INFO,
+                                    "Timeout from EC hardware or EC device driver"));
+                }
         }
 
         if (!(handler_desc->address_space.handler_flags &
diff --git a/drivers/acpi/acpica/exdump.c b/drivers/acpi/acpica/exdump.c
index 83398dc4b7c2..b2ff61bdb9a8 100644
--- a/drivers/acpi/acpica/exdump.c
+++ b/drivers/acpi/acpica/exdump.c
@@ -617,10 +617,11 @@ void acpi_ex_dump_operand(union acpi_operand_object *obj_desc, u32 depth)
         u32 length;
         u32 index;
 
-        ACPI_FUNCTION_NAME(ex_dump_operand)
+        ACPI_FUNCTION_NAME(ex_dump_operand);
 
-            /* Check if debug output enabled */
-            if (!ACPI_IS_DEBUG_ENABLED(ACPI_LV_EXEC, _COMPONENT)) {
+        /* Check if debug output enabled */
+
+        if (!ACPI_IS_DEBUG_ENABLED(ACPI_LV_EXEC, _COMPONENT)) {
                 return;
         }
 
@@ -904,7 +905,7 @@ void
 acpi_ex_dump_operands(union acpi_operand_object **operands,
                       const char *opcode_name, u32 num_operands)
 {
-        ACPI_FUNCTION_NAME(ex_dump_operands);
+        ACPI_FUNCTION_TRACE(ex_dump_operands);
 
         if (!opcode_name) {
                 opcode_name = "UNKNOWN";
@@ -928,7 +929,7 @@ acpi_ex_dump_operands(union acpi_operand_object **operands,
 
         ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
                           "**** End operand dump for [%s]\n", opcode_name));
-        return;
+        return_VOID;
 }
 
 /*******************************************************************************
diff --git a/drivers/acpi/acpica/hwtimer.c b/drivers/acpi/acpica/hwtimer.c
index a2f4e25d45b1..5b4282902a83 100644
--- a/drivers/acpi/acpica/hwtimer.c
+++ b/drivers/acpi/acpica/hwtimer.c
@@ -150,10 +150,10 @@ ACPI_EXPORT_SYMBOL(acpi_get_timer)
  *
  ******************************************************************************/
 acpi_status
-acpi_get_timer_duration(u32 start_ticks, u32 end_ticks, u32 * time_elapsed)
+acpi_get_timer_duration(u32 start_ticks, u32 end_ticks, u32 *time_elapsed)
 {
         acpi_status status;
-        u32 delta_ticks;
+        u64 delta_ticks;
         u64 quotient;
 
         ACPI_FUNCTION_TRACE(acpi_get_timer_duration);
@@ -168,30 +168,29 @@ acpi_get_timer_duration(u32 start_ticks, u32 end_ticks, u32 * time_elapsed)
                 return_ACPI_STATUS(AE_SUPPORT);
         }
 
+        if (start_ticks == end_ticks) {
+                *time_elapsed = 0;
+                return_ACPI_STATUS(AE_OK);
+        }
+
         /*
          * Compute Tick Delta:
          * Handle (max one) timer rollovers on 24-bit versus 32-bit timers.
          */
-        if (start_ticks < end_ticks) {
-                delta_ticks = end_ticks - start_ticks;
-        } else if (start_ticks > end_ticks) {
+        delta_ticks = end_ticks;
+        if (start_ticks > end_ticks) {
                 if ((acpi_gbl_FADT.flags & ACPI_FADT_32BIT_TIMER) == 0) {
 
                         /* 24-bit Timer */
 
-                        delta_ticks =
-                            (((0x00FFFFFF - start_ticks) +
-                              end_ticks) & 0x00FFFFFF);
+                        delta_ticks |= (u64)1 << 24;
                 } else {
                         /* 32-bit Timer */
 
-                        delta_ticks = (0xFFFFFFFF - start_ticks) + end_ticks;
+                        delta_ticks |= (u64)1 << 32;
                 }
-        } else {                /* start_ticks == end_ticks */
-
-                *time_elapsed = 0;
-                return_ACPI_STATUS(AE_OK);
         }
+        delta_ticks -= start_ticks;
 
         /*
          * Compute Duration (Requires a 64-bit multiply and divide):
@@ -199,10 +198,10 @@ acpi_get_timer_duration(u32 start_ticks, u32 end_ticks, u32 * time_elapsed)
          * time_elapsed (microseconds) =
          *  (delta_ticks * ACPI_USEC_PER_SEC) / ACPI_PM_TIMER_FREQUENCY;
          */
-        status = acpi_ut_short_divide(((u64)delta_ticks) * ACPI_USEC_PER_SEC,
+        status = acpi_ut_short_divide(delta_ticks * ACPI_USEC_PER_SEC,
                                       ACPI_PM_TIMER_FREQUENCY, &quotient, NULL);
 
-        *time_elapsed = (u32) quotient;
+        *time_elapsed = (u32)quotient;
         return_ACPI_STATUS(status);
 }
 
diff --git a/drivers/acpi/acpica/hwvalid.c b/drivers/acpi/acpica/hwvalid.c
index 3094cec4eab4..d1679035d5f3 100644
--- a/drivers/acpi/acpica/hwvalid.c
+++ b/drivers/acpi/acpica/hwvalid.c
@@ -128,14 +128,14 @@ acpi_hw_validate_io_request(acpi_io_address address, u32 bit_width)
         acpi_io_address last_address;
         const struct acpi_port_info *port_info;
 
-        ACPI_FUNCTION_NAME(hw_validate_io_request);
+        ACPI_FUNCTION_TRACE(hw_validate_io_request);
 
         /* Supported widths are 8/16/32 */
 
         if ((bit_width != 8) && (bit_width != 16) && (bit_width != 32)) {
                 ACPI_ERROR((AE_INFO,
                             "Bad BitWidth parameter: %8.8X", bit_width));
-                return (AE_BAD_PARAMETER);
+                return_ACPI_STATUS(AE_BAD_PARAMETER);
         }
 
         port_info = acpi_protected_ports;
@@ -153,13 +153,13 @@ acpi_hw_validate_io_request(acpi_io_address address, u32 bit_width)
                 ACPI_ERROR((AE_INFO,
                             "Illegal I/O port address/length above 64K: %8.8X%8.8X/0x%X",
                             ACPI_FORMAT_UINT64(address), byte_width));
-                return (AE_LIMIT);
+                return_ACPI_STATUS(AE_LIMIT);
         }
 
         /* Exit if requested address is not within the protected port table */
 
         if (address > acpi_protected_ports[ACPI_PORT_INFO_ENTRIES - 1].end) {
-                return (AE_OK);
+                return_ACPI_STATUS(AE_OK);
         }
 
         /* Check request against the list of protected I/O ports */
@@ -180,8 +180,8 @@ acpi_hw_validate_io_request(acpi_io_address address, u32 bit_width)
                         /* Port illegality may depend on the _OSI calls made by the BIOS */
 
                         if (acpi_gbl_osi_data >= port_info->osi_dependency) {
-                                ACPI_DEBUG_PRINT((ACPI_DB_IO,
-                                                  "Denied AML access to port 0x%8.8X%8.8X/%X (%s 0x%.4X-0x%.4X)",
+                                ACPI_DEBUG_PRINT((ACPI_DB_VALUES,
+                                                  "Denied AML access to port 0x%8.8X%8.8X/%X (%s 0x%.4X-0x%.4X)\n",
                                                   ACPI_FORMAT_UINT64(address),
                                                   byte_width, port_info->name,
                                                   port_info->start,
@@ -198,7 +198,7 @@ acpi_hw_validate_io_request(acpi_io_address address, u32 bit_width)
                 }
         }
 
-        return (AE_OK);
+        return_ACPI_STATUS(AE_OK);
 }
 
 /******************************************************************************
diff --git a/drivers/acpi/acpica/nsaccess.c b/drivers/acpi/acpica/nsaccess.c
index f2733f51ca8d..33e652a12fca 100644
--- a/drivers/acpi/acpica/nsaccess.c
+++ b/drivers/acpi/acpica/nsaccess.c
@@ -644,17 +644,18 @@ acpi_ns_lookup(union acpi_generic_state *scope_info,
                                             this_node->object;
                                 }
                         }
-#ifdef ACPI_ASL_COMPILER
-                        if (!acpi_gbl_disasm_flag &&
-                            (this_node->flags & ANOBJ_IS_EXTERNAL)) {
-                                this_node->flags |= IMPLICIT_EXTERNAL;
-                        }
-#endif
                 }
 
                 /* Special handling for the last segment (num_segments == 0) */
 
                 else {
+#ifdef ACPI_ASL_COMPILER
+                        if (!acpi_gbl_disasm_flag
+                            && (this_node->flags & ANOBJ_IS_EXTERNAL)) {
+                                this_node->flags &= ~IMPLICIT_EXTERNAL;
+                        }
+#endif
+
                         /*
                          * Sanity typecheck of the target object:
                          *
diff --git a/drivers/acpi/acpica/nsconvert.c b/drivers/acpi/acpica/nsconvert.c
index 539d775bbc92..d55dcc82f434 100644
--- a/drivers/acpi/acpica/nsconvert.c
+++ b/drivers/acpi/acpica/nsconvert.c
@@ -495,7 +495,8 @@ acpi_ns_convert_to_reference(struct acpi_namespace_node *scope,
 
                 /* Check if we are resolving a named reference within a package */
 
-                ACPI_ERROR_NAMESPACE(original_object->string.pointer, status);
+                ACPI_ERROR_NAMESPACE(&scope_info,
+                                     original_object->string.pointer, status);
                 goto error_exit;
         }
 
diff --git a/drivers/acpi/acpica/nsnames.c b/drivers/acpi/acpica/nsnames.c
index a410760a0308..22c92d1a24d8 100644
--- a/drivers/acpi/acpica/nsnames.c
+++ b/drivers/acpi/acpica/nsnames.c
@@ -49,6 +49,9 @@
 #define _COMPONENT          ACPI_NAMESPACE
 ACPI_MODULE_NAME("nsnames")
 
+/* Local Prototypes */
+static void acpi_ns_normalize_pathname(char *original_path);
+
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ns_get_external_pathname
@@ -63,6 +66,7 @@ ACPI_MODULE_NAME("nsnames")
  *              for error and debug statements.
  *
  ******************************************************************************/
+
 char *acpi_ns_get_external_pathname(struct acpi_namespace_node *node)
 {
         char *name_buffer;
@@ -352,3 +356,148 @@ char *acpi_ns_get_normalized_pathname(struct acpi_namespace_node *node,
 
         return_PTR(name_buffer);
 }
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_ns_build_prefixed_pathname
+ *
+ * PARAMETERS:  prefix_scope        - Scope/Path that prefixes the internal path
+ *              internal_path       - Name or path of the namespace node
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Construct a fully qualified pathname from a concatenation of:
+ *              1) Path associated with the prefix_scope namespace node
+ *              2) External path representation of the Internal path
+ *
+ ******************************************************************************/
+
+char *acpi_ns_build_prefixed_pathname(union acpi_generic_state *prefix_scope,
+                                      const char *internal_path)
+{
+        acpi_status status;
+        char *full_path = NULL;
+        char *external_path = NULL;
+        char *prefix_path = NULL;
+        u32 prefix_path_length = 0;
+
+        /* If there is a prefix, get the pathname to it */
+
+        if (prefix_scope && prefix_scope->scope.node) {
+                prefix_path =
+                    acpi_ns_get_normalized_pathname(prefix_scope->scope.node,
+                                                    TRUE);
+                if (prefix_path) {
+                        prefix_path_length = strlen(prefix_path);
+                }
+        }
+
+        status = acpi_ns_externalize_name(ACPI_UINT32_MAX, internal_path,
+                                          NULL, &external_path);
+        if (ACPI_FAILURE(status)) {
+                goto cleanup;
+        }
+
+        /* Merge the prefix path and the path. 2 is for one dot and trailing null */
+
+        full_path =
+            ACPI_ALLOCATE_ZEROED(prefix_path_length + strlen(external_path) +
+                                 2);
+        if (!full_path) {
+                goto cleanup;
+        }
+
+        /* Don't merge if the External path is already fully qualified */
+
+        if (prefix_path && (*external_path != '\\') && (*external_path != '^')) {
+                strcat(full_path, prefix_path);
+                if (prefix_path[1]) {
+                        strcat(full_path, ".");
+                }
+        }
+
+        acpi_ns_normalize_pathname(external_path);
+        strcat(full_path, external_path);
+
+cleanup:
+        if (prefix_path) {
+                ACPI_FREE(prefix_path);
+        }
+        if (external_path) {
+                ACPI_FREE(external_path);
+        }
+
+        return (full_path);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_ns_normalize_pathname
+ *
+ * PARAMETERS:  original_path       - Path to be normalized, in External format
+ *
+ * RETURN:      The original path is processed in-place
+ *
+ * DESCRIPTION: Remove trailing underscores from each element of a path.
+ *
+ *              For example:  \A___.B___.C___ becomes \A.B.C
+ *
+ ******************************************************************************/
+
+static void acpi_ns_normalize_pathname(char *original_path)
+{
+        char *input_path = original_path;
+        char *new_path_buffer;
+        char *new_path;
+        u32 i;
+
+        /* Allocate a temp buffer in which to construct the new path */
+
+        new_path_buffer = ACPI_ALLOCATE_ZEROED(strlen(input_path) + 1);
+        new_path = new_path_buffer;
+        if (!new_path_buffer) {
+                return;
+        }
+
+        /* Special characters may appear at the beginning of the path */
+
+        if (*input_path == '\\') {
+                *new_path = *input_path;
+                new_path++;
+                input_path++;
+        }
+
+        while (*input_path == '^') {
+                *new_path = *input_path;
+                new_path++;
+                input_path++;
+        }
+
+        /* Remainder of the path */
+
+        while (*input_path) {
+
+                /* Do one nameseg at a time */
+
+                for (i = 0; (i < ACPI_NAME_SIZE) && *input_path; i++) {
+                        if ((i == 0) || (*input_path != '_')) { /* First char is allowed to be underscore */
+                                *new_path = *input_path;
+                                new_path++;
+                        }
+
+                        input_path++;
+                }
+
+                /* Dot means that there are more namesegs to come */
+
+                if (*input_path == '.') {
+                        *new_path = *input_path;
+                        new_path++;
+                        input_path++;
+                }
+        }
+
+        *new_path = 0;
+        strcpy(original_path, new_path_buffer);
+        ACPI_FREE(new_path_buffer);
+}
diff --git a/drivers/acpi/acpica/nssearch.c b/drivers/acpi/acpica/nssearch.c
index 5de8957f5ef0..e91dbee9235f 100644
--- a/drivers/acpi/acpica/nssearch.c
+++ b/drivers/acpi/acpica/nssearch.c
@@ -417,6 +417,7 @@ acpi_ns_search_and_enter(u32 target_name,
         if (flags & ACPI_NS_EXTERNAL ||
             (walk_state && walk_state->opcode == AML_SCOPE_OP)) {
                 new_node->flags |= ANOBJ_IS_EXTERNAL;
+                new_node->flags |= IMPLICIT_EXTERNAL;
         }
 #endif
 
diff --git a/drivers/acpi/acpica/nsxfeval.c b/drivers/acpi/acpica/nsxfeval.c
index 783f4c838aee..9b51f65823b2 100644
--- a/drivers/acpi/acpica/nsxfeval.c
+++ b/drivers/acpi/acpica/nsxfeval.c
@@ -61,10 +61,10 @@ static void acpi_ns_resolve_references(struct acpi_evaluate_info *info);
  *
  * PARAMETERS:  handle              - Object handle (optional)
  *              pathname            - Object pathname (optional)
- *              external_params     - List of parameters to pass to method,
+ *              external_params     - List of parameters to pass to a method,
  *                                    terminated by NULL. May be NULL
  *                                    if no parameters are being passed.
- *              return_buffer       - Where to put method's return value (if
+ *              return_buffer       - Where to put the object's return value (if
  *                                    any). If NULL, no value is returned.
  *              return_type         - Expected type of return object
  *
@@ -100,13 +100,14 @@ acpi_evaluate_object_typed(acpi_handle handle,
                 free_buffer_on_error = TRUE;
         }
 
+        /* Get a handle here, in order to build an error message if needed */
+
+        target_handle = handle;
         if (pathname) {
                 status = acpi_get_handle(handle, pathname, &target_handle);
                 if (ACPI_FAILURE(status)) {
                         return_ACPI_STATUS(status);
                 }
-        } else {
-                target_handle = handle;
         }
 
         full_pathname = acpi_ns_get_external_pathname(target_handle);
diff --git a/drivers/acpi/acpica/psargs.c b/drivers/acpi/acpica/psargs.c
index eb9dfaca555f..171e2faa7c50 100644
--- a/drivers/acpi/acpica/psargs.c
+++ b/drivers/acpi/acpica/psargs.c
@@ -361,7 +361,7 @@ acpi_ps_get_next_namepath(struct acpi_walk_state *walk_state,
         /* Final exception check (may have been changed from code above) */
 
         if (ACPI_FAILURE(status)) {
-                ACPI_ERROR_NAMESPACE(path, status);
+                ACPI_ERROR_NAMESPACE(walk_state->scope_info, path, status);
 
                 if ((walk_state->parse_flags & ACPI_PARSE_MODE_MASK) ==
                     ACPI_PARSE_EXECUTE) {
diff --git a/drivers/acpi/acpica/psobject.c b/drivers/acpi/acpica/psobject.c
index 0bef6df71bba..c0b179883ff2 100644
--- a/drivers/acpi/acpica/psobject.c
+++ b/drivers/acpi/acpica/psobject.c
@@ -372,16 +372,10 @@ acpi_ps_create_op(struct acpi_walk_state *walk_state,
                          * external declaration opcode. Setting walk_state->Aml to
                          * walk_state->parser_state.Aml + 2 moves increments the
                          * walk_state->Aml past the object type and the paramcount of the
-                         * external opcode. For the error message, only print the AML
-                         * offset. We could attempt to print the name but this may cause
-                         * a segmentation fault when printing the namepath because the
-                         * AML may be incorrect.
+                         * external opcode.
                          */
-                        acpi_os_printf
-                            ("// Invalid external declaration at AML offset 0x%x.\n",
-                             walk_state->aml -
-                             walk_state->parser_state.aml_start);
                         walk_state->aml = walk_state->parser_state.aml + 2;
+                        walk_state->parser_state.aml = walk_state->aml;
                         return_ACPI_STATUS(AE_CTRL_PARSE_CONTINUE);
                 }
 #endif
diff --git a/drivers/acpi/acpica/psutils.c b/drivers/acpi/acpica/psutils.c
index 02642760cb93..cd59dfe6a47d 100644
--- a/drivers/acpi/acpica/psutils.c
+++ b/drivers/acpi/acpica/psutils.c
@@ -94,9 +94,11 @@ void acpi_ps_init_op(union acpi_parse_object *op, u16 opcode)
         op->common.descriptor_type = ACPI_DESC_TYPE_PARSER;
         op->common.aml_opcode = opcode;
 
-        ACPI_DISASM_ONLY_MEMBERS(strncpy(op->common.aml_op_name,
-                                         (acpi_ps_get_opcode_info(opcode))->
-                                         name, sizeof(op->common.aml_op_name)));
+        ACPI_DISASM_ONLY_MEMBERS(acpi_ut_safe_strncpy(op->common.aml_op_name,
+                                                      (acpi_ps_get_opcode_info
+                                                       (opcode))->name,
+                                                      sizeof(op->common.
+                                                             aml_op_name)));
 }
 
 /*******************************************************************************
@@ -158,10 +160,10 @@ union acpi_parse_object *acpi_ps_alloc_op(u16 opcode, u8 *aml)
                 if (opcode == AML_SCOPE_OP) {
                         acpi_gbl_current_scope = op;
                 }
-        }
 
-        if (gbl_capture_comments) {
-                ASL_CV_TRANSFER_COMMENTS(op);
+                if (acpi_gbl_capture_comments) {
+                        ASL_CV_TRANSFER_COMMENTS(op);
+                }
         }
 
         return (op);
diff --git a/drivers/acpi/acpica/utdebug.c b/drivers/acpi/acpica/utdebug.c
index 615a885e2ca3..cff7154b7fee 100644
--- a/drivers/acpi/acpica/utdebug.c
+++ b/drivers/acpi/acpica/utdebug.c
@@ -163,6 +163,9 @@ acpi_debug_print(u32 requested_debug_level,
 {
         acpi_thread_id thread_id;
         va_list args;
+#ifdef ACPI_APPLICATION
+        int fill_count;
+#endif
 
         /* Check if debug output enabled */
 
@@ -202,10 +205,21 @@ acpi_debug_print(u32 requested_debug_level,
                 acpi_os_printf("[%u] ", (u32)thread_id);
         }
 
-        acpi_os_printf("[%02ld] ", acpi_gbl_nesting_level);
-#endif
+        fill_count = 48 - acpi_gbl_nesting_level -
+            strlen(acpi_ut_trim_function_name(function_name));
+        if (fill_count < 0) {
+                fill_count = 0;
+        }
+
+        acpi_os_printf("[%02ld] %*s",
+                       acpi_gbl_nesting_level, acpi_gbl_nesting_level + 1, " ");
+        acpi_os_printf("%s%*s: ",
+                       acpi_ut_trim_function_name(function_name), fill_count,
+                       " ");
 
+#else
         acpi_os_printf("%-22.22s: ", acpi_ut_trim_function_name(function_name));
+#endif
 
         va_start(args, format);
         acpi_os_vprintf(format, args);
diff --git a/drivers/acpi/acpica/utdecode.c b/drivers/acpi/acpica/utdecode.c
index 02cd2c2d961a..55debbad487d 100644
--- a/drivers/acpi/acpica/utdecode.c
+++ b/drivers/acpi/acpica/utdecode.c
@@ -395,11 +395,6 @@ const char *acpi_ut_get_reference_name(union acpi_operand_object *object)
         return (acpi_gbl_ref_class_names[object->reference.class]);
 }
 
-#if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
-/*
- * Strings and procedures used for debug only
- */
-
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ut_get_mutex_name
@@ -433,6 +428,12 @@ const char *acpi_ut_get_mutex_name(u32 mutex_id)
         return (acpi_gbl_mutex_names[mutex_id]);
 }
 
+#if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
+
+/*
+ * Strings and procedures used for debug only
+ */
+
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ut_get_notify_name
diff --git a/drivers/acpi/acpica/uterror.c b/drivers/acpi/acpica/uterror.c
index e3368186e1c1..42388dcb5ccc 100644
--- a/drivers/acpi/acpica/uterror.c
+++ b/drivers/acpi/acpica/uterror.c
@@ -182,6 +182,78 @@ acpi_ut_predefined_bios_error(const char *module_name,
 
 /*******************************************************************************
  *
+ * FUNCTION:    acpi_ut_prefixed_namespace_error
+ *
+ * PARAMETERS:  module_name         - Caller's module name (for error output)
+ *              line_number         - Caller's line number (for error output)
+ *              prefix_scope        - Scope/Path that prefixes the internal path
+ *              internal_path       - Name or path of the namespace node
+ *              lookup_status       - Exception code from NS lookup
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Print error message with the full pathname constructed this way:
+ *
+ *                  prefix_scope_node_full_path.externalized_internal_path
+ *
+ * NOTE:        10/2017: Treat the major ns_lookup errors as firmware errors
+ *
+ ******************************************************************************/
+
+void
+acpi_ut_prefixed_namespace_error(const char *module_name,
+                                 u32 line_number,
+                                 union acpi_generic_state *prefix_scope,
+                                 const char *internal_path,
+                                 acpi_status lookup_status)
+{
+        char *full_path;
+        const char *message;
+
+        /*
+         * Main cases:
+         * 1) Object creation, object must not already exist
+         * 2) Object lookup, object must exist
+         */
+        switch (lookup_status) {
+        case AE_ALREADY_EXISTS:
+
+                acpi_os_printf(ACPI_MSG_BIOS_ERROR);
+                message = "Failure creating";
+                break;
+
+        case AE_NOT_FOUND:
+
+                acpi_os_printf(ACPI_MSG_BIOS_ERROR);
+                message = "Failure looking up";
+                break;
+
+        default:
+
+                acpi_os_printf(ACPI_MSG_ERROR);
+                message = "Failure looking up";
+                break;
+        }
+
+        /* Concatenate the prefix path and the internal path */
+
+        full_path =
+            acpi_ns_build_prefixed_pathname(prefix_scope, internal_path);
+
+        acpi_os_printf("%s [%s], %s", message,
+                       full_path ? full_path : "Could not get pathname",
+                       acpi_format_exception(lookup_status));
+
+        if (full_path) {
+                ACPI_FREE(full_path);
+        }
+
+        ACPI_MSG_SUFFIX;
+}
+
+#ifdef __OBSOLETE_FUNCTION
+/*******************************************************************************
+ *
  * FUNCTION:    acpi_ut_namespace_error
  *
  * PARAMETERS:  module_name         - Caller's module name (for error output)
@@ -240,6 +312,7 @@ acpi_ut_namespace_error(const char *module_name,
         ACPI_MSG_SUFFIX;
         ACPI_MSG_REDIRECT_END;
 }
+#endif
 
 /*******************************************************************************
  *
diff --git a/drivers/acpi/acpica/utinit.c b/drivers/acpi/acpica/utinit.c
index 23e766d1691d..45eeb0dcf283 100644
--- a/drivers/acpi/acpica/utinit.c
+++ b/drivers/acpi/acpica/utinit.c
@@ -206,7 +206,6 @@ acpi_status acpi_ut_init_globals(void)
         acpi_gbl_next_owner_id_offset = 0;
         acpi_gbl_debugger_configuration = DEBUGGER_THREADING;
         acpi_gbl_osi_mutex = NULL;
-        acpi_gbl_max_loop_iterations = ACPI_MAX_LOOP_COUNT;
 
         /* Hardware oriented */
 
diff --git a/drivers/acpi/acpica/utmath.c b/drivers/acpi/acpica/utmath.c
index 5f9c680076c4..2055a858e5f5 100644
--- a/drivers/acpi/acpica/utmath.c
+++ b/drivers/acpi/acpica/utmath.c
@@ -134,7 +134,7 @@ acpi_status acpi_ut_short_shift_left(u64 operand, u32 count, u64 *out_result)
 
         if ((count & 63) >= 32) {
                 operand_ovl.part.hi = operand_ovl.part.lo;
-                operand_ovl.part.lo ^= operand_ovl.part.lo;
+                operand_ovl.part.lo = 0;
                 count = (count & 63) - 32;
         }
         ACPI_SHIFT_LEFT_64_BY_32(operand_ovl.part.hi,
@@ -171,7 +171,7 @@ acpi_status acpi_ut_short_shift_right(u64 operand, u32 count, u64 *out_result)
 
         if ((count & 63) >= 32) {
                 operand_ovl.part.lo = operand_ovl.part.hi;
-                operand_ovl.part.hi ^= operand_ovl.part.hi;
+                operand_ovl.part.hi = 0;
                 count = (count & 63) - 32;
         }
         ACPI_SHIFT_RIGHT_64_BY_32(operand_ovl.part.hi,
diff --git a/drivers/acpi/acpica/utmutex.c b/drivers/acpi/acpica/utmutex.c
index 586354788018..524ba931d5e8 100644
--- a/drivers/acpi/acpica/utmutex.c
+++ b/drivers/acpi/acpica/utmutex.c
@@ -286,8 +286,9 @@ acpi_status acpi_ut_acquire_mutex(acpi_mutex_handle mutex_id)
                 acpi_gbl_mutex_info[mutex_id].thread_id = this_thread_id;
         } else {
                 ACPI_EXCEPTION((AE_INFO, status,
-                                "Thread %u could not acquire Mutex [0x%X]",
-                                (u32)this_thread_id, mutex_id));
+                                "Thread %u could not acquire Mutex [%s] (0x%X)",
+                                (u32)this_thread_id,
+                                acpi_ut_get_mutex_name(mutex_id), mutex_id));
         }
 
         return (status);
@@ -322,8 +323,8 @@ acpi_status acpi_ut_release_mutex(acpi_mutex_handle mutex_id)
          */
         if (acpi_gbl_mutex_info[mutex_id].thread_id == ACPI_MUTEX_NOT_ACQUIRED) {
                 ACPI_ERROR((AE_INFO,
-                            "Mutex [0x%X] is not acquired, cannot release",
-                            mutex_id));
+                            "Mutex [%s] (0x%X) is not acquired, cannot release",
+                            acpi_ut_get_mutex_name(mutex_id), mutex_id));
 
                 return (AE_NOT_ACQUIRED);
         }
diff --git a/drivers/acpi/acpica/utnonansi.c b/drivers/acpi/acpica/utnonansi.c
index 792664982ea3..33a0970646df 100644
--- a/drivers/acpi/acpica/utnonansi.c
+++ b/drivers/acpi/acpica/utnonansi.c
@@ -140,7 +140,7 @@ int acpi_ut_stricmp(char *string1, char *string2)
         return (c1 - c2);
 }
 
-#if defined (ACPI_DEBUGGER) || defined (ACPI_APPLICATION)
+#if defined (ACPI_DEBUGGER) || defined (ACPI_APPLICATION) || defined (ACPI_DEBUG_OUTPUT)
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ut_safe_strcpy, acpi_ut_safe_strcat, acpi_ut_safe_strncat
@@ -199,4 +199,13 @@ acpi_ut_safe_strncat(char *dest,
         strncat(dest, source, max_transfer_length);
         return (FALSE);
 }
+
+void acpi_ut_safe_strncpy(char *dest, char *source, acpi_size dest_size)
+{
+        /* Always terminate destination string */
+
+        strncpy(dest, source, dest_size);
+        dest[dest_size - 1] = 0;
+}
+
 #endif
diff --git a/drivers/acpi/acpica/utosi.c b/drivers/acpi/acpica/utosi.c
index 3175b133c0e4..f6b8dd24b006 100644
--- a/drivers/acpi/acpica/utosi.c
+++ b/drivers/acpi/acpica/utosi.c
@@ -101,6 +101,8 @@ static struct acpi_interface_info acpi_default_supported_interfaces[] = {
         {"Windows 2012", NULL, 0, ACPI_OSI_WIN_8},      /* Windows 8 and Server 2012 - Added 08/2012 */
         {"Windows 2013", NULL, 0, ACPI_OSI_WIN_8},      /* Windows 8.1 and Server 2012 R2 - Added 01/2014 */
         {"Windows 2015", NULL, 0, ACPI_OSI_WIN_10},     /* Windows 10 - Added 03/2015 */
+        {"Windows 2016", NULL, 0, ACPI_OSI_WIN_10_RS1}, /* Windows 10 version 1607 - Added 12/2017 */
+        {"Windows 2017", NULL, 0, ACPI_OSI_WIN_10_RS2}, /* Windows 10 version 1703 - Added 12/2017 */
 
         /* Feature Group Strings */
 
diff --git a/drivers/acpi/acpica/utstrsuppt.c b/drivers/acpi/acpica/utstrsuppt.c
index 965fb5cec94f..97f48d71f9e6 100644
--- a/drivers/acpi/acpica/utstrsuppt.c
+++ b/drivers/acpi/acpica/utstrsuppt.c
@@ -52,10 +52,9 @@ static acpi_status
 acpi_ut_insert_digit(u64 *accumulated_value, u32 base, int ascii_digit);
 
 static acpi_status
-acpi_ut_strtoul_multiply64(u64 multiplicand, u64 multiplier, u64 *out_product);
+acpi_ut_strtoul_multiply64(u64 multiplicand, u32 base, u64 *out_product);
 
-static acpi_status
-acpi_ut_strtoul_add64(u64 addend1, u64 addend2, u64 *out_sum);
+static acpi_status acpi_ut_strtoul_add64(u64 addend1, u32 digit, u64 *out_sum);
 
 /*******************************************************************************
  *
@@ -357,7 +356,7 @@ acpi_ut_insert_digit(u64 *accumulated_value, u32 base, int ascii_digit)
  * FUNCTION:    acpi_ut_strtoul_multiply64
  *
  * PARAMETERS:  multiplicand            - Current accumulated converted integer
- *              multiplier              - Base/Radix
+ *              base                    - Base/Radix
  *              out_product             - Where the product is returned
  *
  * RETURN:      Status and 64-bit product
@@ -369,33 +368,40 @@ acpi_ut_insert_digit(u64 *accumulated_value, u32 base, int ascii_digit)
  ******************************************************************************/
 
 static acpi_status
-acpi_ut_strtoul_multiply64(u64 multiplicand, u64 multiplier, u64 *out_product)
+acpi_ut_strtoul_multiply64(u64 multiplicand, u32 base, u64 *out_product)
 {
-        u64 val;
+        u64 product;
+        u64 quotient;
 
         /* Exit if either operand is zero */
 
         *out_product = 0;
-        if (!multiplicand || !multiplier) {
+        if (!multiplicand || !base) {
                 return (AE_OK);
         }
 
-        /* Check for 64-bit overflow before the actual multiplication */
-
-        acpi_ut_short_divide(ACPI_UINT64_MAX, (u32)multiplier, &val, NULL);
-        if (multiplicand > val) {
+        /*
+         * Check for 64-bit overflow before the actual multiplication.
+         *
+         * Notes: 64-bit division is often not supported on 32-bit platforms
+         * (it requires a library function), Therefore ACPICA has a local
+         * 64-bit divide function. Also, Multiplier is currently only used
+         * as the radix (8/10/16), to the 64/32 divide will always work.
+         */
+        acpi_ut_short_divide(ACPI_UINT64_MAX, base, &quotient, NULL);
+        if (multiplicand > quotient) {
                 return (AE_NUMERIC_OVERFLOW);
         }
 
-        val = multiplicand * multiplier;
+        product = multiplicand * base;
 
         /* Check for 32-bit overflow if necessary */
 
-        if ((acpi_gbl_integer_bit_width == 32) && (val > ACPI_UINT32_MAX)) {
+        if ((acpi_gbl_integer_bit_width == 32) && (product > ACPI_UINT32_MAX)) {
                 return (AE_NUMERIC_OVERFLOW);
         }
 
-        *out_product = val;
+        *out_product = product;
         return (AE_OK);
 }
 
@@ -404,7 +410,7 @@ acpi_ut_strtoul_multiply64(u64 multiplicand, u64 multiplier, u64 *out_product)
  * FUNCTION:    acpi_ut_strtoul_add64
  *
  * PARAMETERS:  addend1                 - Current accumulated converted integer
- *              addend2                 - New hex value/char
+ *              digit                   - New hex value/char
  *              out_sum                 - Where sum is returned (Accumulator)
  *
  * RETURN:      Status and 64-bit sum
@@ -415,17 +421,17 @@ acpi_ut_strtoul_multiply64(u64 multiplicand, u64 multiplier, u64 *out_product)
  *
  ******************************************************************************/
 
-static acpi_status acpi_ut_strtoul_add64(u64 addend1, u64 addend2, u64 *out_sum)
+static acpi_status acpi_ut_strtoul_add64(u64 addend1, u32 digit, u64 *out_sum)
 {
         u64 sum;
 
         /* Check for 64-bit overflow before the actual addition */
 
-        if ((addend1 > 0) && (addend2 > (ACPI_UINT64_MAX - addend1))) {
+        if ((addend1 > 0) && (digit > (ACPI_UINT64_MAX - addend1))) {
                 return (AE_NUMERIC_OVERFLOW);
         }
 
-        sum = addend1 + addend2;
+        sum = addend1 + digit;
 
         /* Check for 32-bit overflow if necessary */
 
diff --git a/drivers/acpi/acpica/uttrack.c b/drivers/acpi/acpica/uttrack.c
index 3c8de88ecbd5..633b4e2c669f 100644
--- a/drivers/acpi/acpica/uttrack.c
+++ b/drivers/acpi/acpica/uttrack.c
@@ -402,8 +402,8 @@ acpi_ut_track_allocation(struct acpi_debug_mem_block *allocation,
         allocation->component = component;
         allocation->line = line;
 
-        strncpy(allocation->module, module, ACPI_MAX_MODULE_NAME);
-        allocation->module[ACPI_MAX_MODULE_NAME - 1] = 0;
+        acpi_ut_safe_strncpy(allocation->module, (char *)module,
+                             ACPI_MAX_MODULE_NAME);
 
         if (!element) {
 
@@ -717,7 +717,7 @@ exit:
         if (!num_outstanding) {
                 ACPI_INFO(("No outstanding allocations"));
         } else {
-                ACPI_ERROR((AE_INFO, "%u(0x%X) Outstanding allocations",
+                ACPI_ERROR((AE_INFO, "%u (0x%X) Outstanding cache allocations",
                             num_outstanding, num_outstanding));
         }
 
diff --git a/drivers/acpi/acpica/utxferror.c b/drivers/acpi/acpica/utxferror.c
index 950a1e500bfa..9da4f8ef2e77 100644
--- a/drivers/acpi/acpica/utxferror.c
+++ b/drivers/acpi/acpica/utxferror.c
@@ -96,8 +96,8 @@ ACPI_EXPORT_SYMBOL(acpi_error)
  *
  * RETURN:      None
  *
- * DESCRIPTION: Print "ACPI Exception" message with module/line/version info
- *              and decoded acpi_status.
+ * DESCRIPTION: Print an "ACPI Error" message with module/line/version
+ *              info as well as decoded acpi_status.
  *
  ******************************************************************************/
 void ACPI_INTERNAL_VAR_XFACE
@@ -111,10 +111,10 @@ acpi_exception(const char *module_name,
         /* For AE_OK, just print the message */
 
         if (ACPI_SUCCESS(status)) {
-                acpi_os_printf(ACPI_MSG_EXCEPTION);
+                acpi_os_printf(ACPI_MSG_ERROR);
 
         } else {
-                acpi_os_printf(ACPI_MSG_EXCEPTION "%s, ",
+                acpi_os_printf(ACPI_MSG_ERROR "%s, ",
                                acpi_format_exception(status));
         }
 
diff --git a/drivers/acpi/apei/ghes.c b/drivers/acpi/apei/ghes.c
index 6402f7fad3bb..16c4a10b7506 100644
--- a/drivers/acpi/apei/ghes.c
+++ b/drivers/acpi/apei/ghes.c
@@ -414,6 +414,51 @@ static void ghes_handle_memory_failure(struct acpi_hest_generic_data *gdata, int
 #endif
 }
 
+/*
+ * PCIe AER errors need to be sent to the AER driver for reporting and
+ * recovery. The GHES severities map to the following AER severities and
+ * require the following handling:
+ *
+ * GHES_SEV_CORRECTABLE -> AER_CORRECTABLE
+ *     These need to be reported by the AER driver but no recovery is
+ *     necessary.
+ * GHES_SEV_RECOVERABLE -> AER_NONFATAL
+ * GHES_SEV_RECOVERABLE && CPER_SEC_RESET -> AER_FATAL
+ *     These both need to be reported and recovered from by the AER driver.
+ * GHES_SEV_PANIC does not make it to this handling since the kernel must
+ *     panic.
+ */
+static void ghes_handle_aer(struct acpi_hest_generic_data *gdata)
+{
+#ifdef CONFIG_ACPI_APEI_PCIEAER
+        struct cper_sec_pcie *pcie_err = acpi_hest_get_payload(gdata);
+
+        if (pcie_err->validation_bits & CPER_PCIE_VALID_DEVICE_ID &&
+            pcie_err->validation_bits & CPER_PCIE_VALID_AER_INFO) {
+                unsigned int devfn;
+                int aer_severity;
+
+                devfn = PCI_DEVFN(pcie_err->device_id.device,
+                                  pcie_err->device_id.function);
+                aer_severity = cper_severity_to_aer(gdata->error_severity);
+
+                /*
+                 * If firmware reset the component to contain
+                 * the error, we must reinitialize it before
+                 * use, so treat it as a fatal AER error.
+                 */
+                if (gdata->flags & CPER_SEC_RESET)
+                        aer_severity = AER_FATAL;
+
+                aer_recover_queue(pcie_err->device_id.segment,
+                                  pcie_err->device_id.bus,
+                                  devfn, aer_severity,
+                                  (struct aer_capability_regs *)
+                                  pcie_err->aer_info);
+        }
+#endif
+}
+
 static void ghes_do_proc(struct ghes *ghes,
                          const struct acpi_hest_generic_status *estatus)
 {
@@ -441,38 +486,9 @@ static void ghes_do_proc(struct ghes *ghes,
                         arch_apei_report_mem_error(sev, mem_err);
                         ghes_handle_memory_failure(gdata, sev);
                 }
-#ifdef CONFIG_ACPI_APEI_PCIEAER
                 else if (guid_equal(sec_type, &CPER_SEC_PCIE)) {
-                        struct cper_sec_pcie *pcie_err = acpi_hest_get_payload(gdata);
-
-                        if (sev == GHES_SEV_RECOVERABLE &&
-                            sec_sev == GHES_SEV_RECOVERABLE &&
-                            pcie_err->validation_bits & CPER_PCIE_VALID_DEVICE_ID &&
-                            pcie_err->validation_bits & CPER_PCIE_VALID_AER_INFO) {
-                                unsigned int devfn;
-                                int aer_severity;
-
-                                devfn = PCI_DEVFN(pcie_err->device_id.device,
-                                                  pcie_err->device_id.function);
-                                aer_severity = cper_severity_to_aer(gdata->error_severity);
-
-                                /*
-                                 * If firmware reset the component to contain
-                                 * the error, we must reinitialize it before
-                                 * use, so treat it as a fatal AER error.
-                                 */
-                                if (gdata->flags & CPER_SEC_RESET)
-                                        aer_severity = AER_FATAL;
-
-                                aer_recover_queue(pcie_err->device_id.segment,
-                                                  pcie_err->device_id.bus,
-                                                  devfn, aer_severity,
-                                                  (struct aer_capability_regs *)
-                                                  pcie_err->aer_info);
-                        }
-
+                        ghes_handle_aer(gdata);
                 }
-#endif
                 else if (guid_equal(sec_type, &CPER_SEC_PROC_ARM)) {
                         struct cper_sec_proc_arm *err = acpi_hest_get_payload(gdata);
 
@@ -870,7 +886,6 @@ static void ghes_print_queued_estatus(void)
         struct ghes_estatus_node *estatus_node;
         struct acpi_hest_generic *generic;
         struct acpi_hest_generic_status *estatus;
-        u32 len, node_len;
 
         llnode = llist_del_all(&ghes_estatus_llist);
         /*
@@ -882,8 +897,6 @@ static void ghes_print_queued_estatus(void)
                 estatus_node = llist_entry(llnode, struct ghes_estatus_node,
                                            llnode);
                 estatus = GHES_ESTATUS_FROM_NODE(estatus_node);
-                len = cper_estatus_len(estatus);
-                node_len = GHES_ESTATUS_NODE_LEN(len);
                 generic = estatus_node->generic;
                 ghes_print_estatus(NULL, generic, estatus);
                 llnode = llnode->next;
diff --git a/drivers/acpi/battery.c b/drivers/acpi/battery.c
index 13e7b56e33ae..19bc440820e6 100644
--- a/drivers/acpi/battery.c
+++ b/drivers/acpi/battery.c
@@ -70,6 +70,7 @@ static async_cookie_t async_cookie;
 static bool battery_driver_registered;
 static int battery_bix_broken_package;
 static int battery_notification_delay_ms;
+static int battery_full_discharging;
 static unsigned int cache_time = 1000;
 module_param(cache_time, uint, 0644);
 MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
@@ -214,9 +215,12 @@ static int acpi_battery_get_property(struct power_supply *psy,
                 return -ENODEV;
         switch (psp) {
         case POWER_SUPPLY_PROP_STATUS:
-                if (battery->state & ACPI_BATTERY_STATE_DISCHARGING)
-                        val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
-                else if (battery->state & ACPI_BATTERY_STATE_CHARGING)
+                if (battery->state & ACPI_BATTERY_STATE_DISCHARGING) {
+                        if (battery_full_discharging && battery->rate_now == 0)
+                                val->intval = POWER_SUPPLY_STATUS_FULL;
+                        else
+                                val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
+                } else if (battery->state & ACPI_BATTERY_STATE_CHARGING)
                         val->intval = POWER_SUPPLY_STATUS_CHARGING;
                 else if (acpi_battery_is_charged(battery))
                         val->intval = POWER_SUPPLY_STATUS_FULL;
@@ -1166,6 +1170,12 @@ battery_notification_delay_quirk(const struct dmi_system_id *d)
         return 0;
 }
 
+static int __init battery_full_discharging_quirk(const struct dmi_system_id *d)
+{
+        battery_full_discharging = 1;
+        return 0;
+}
+
 static const struct dmi_system_id bat_dmi_table[] __initconst = {
         {
                 .callback = battery_bix_broken_package_quirk,
@@ -1183,6 +1193,22 @@ static const struct dmi_system_id bat_dmi_table[] __initconst = {
                         DMI_MATCH(DMI_PRODUCT_NAME, "Aspire V5-573G"),
                 },
         },
+        {
+                .callback = battery_full_discharging_quirk,
+                .ident = "ASUS GL502VSK",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "GL502VSK"),
+                },
+        },
+        {
+                .callback = battery_full_discharging_quirk,
+                .ident = "ASUS UX305LA",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "UX305LA"),
+                },
+        },
         {},
 };
 
@@ -1237,13 +1263,11 @@ static int acpi_battery_add(struct acpi_device *device)
 
 #ifdef CONFIG_ACPI_PROCFS_POWER
         result = acpi_battery_add_fs(device);
-#endif
         if (result) {
-#ifdef CONFIG_ACPI_PROCFS_POWER
                 acpi_battery_remove_fs(device);
-#endif
                 goto fail;
         }
+#endif
 
         printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n",
                 ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
diff --git a/drivers/acpi/button.c b/drivers/acpi/button.c
index bf8e4d371fa7..e1eee7a60fad 100644
--- a/drivers/acpi/button.c
+++ b/drivers/acpi/button.c
@@ -30,6 +30,7 @@
 #include <linux/input.h>
 #include <linux/slab.h>
 #include <linux/acpi.h>
+#include <linux/dmi.h>
 #include <acpi/button.h>
 
 #define PREFIX "ACPI: "
@@ -76,6 +77,22 @@ static const struct acpi_device_id button_device_ids[] = {
 };
 MODULE_DEVICE_TABLE(acpi, button_device_ids);
 
+/*
+ * Some devices which don't even have a lid in anyway have a broken _LID
+ * method (e.g. pointing to a floating gpio pin) causing spurious LID events.
+ */
+static const struct dmi_system_id lid_blacklst[] = {
+        {
+                /* GP-electronic T701 */
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Insyde"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "T701"),
+                        DMI_MATCH(DMI_BIOS_VERSION, "BYT70A.YNCHENG.WIN.007"),
+                },
+        },
+        {}
+};
+
 static int acpi_button_add(struct acpi_device *device);
 static int acpi_button_remove(struct acpi_device *device);
 static void acpi_button_notify(struct acpi_device *device, u32 event);
@@ -210,6 +227,8 @@ static int acpi_lid_notify_state(struct acpi_device *device, int state)
         }
         /* Send the platform triggered reliable event */
         if (do_update) {
+                acpi_handle_debug(device->handle, "ACPI LID %s\n",
+                                  state ? "open" : "closed");
                 input_report_switch(button->input, SW_LID, !state);
                 input_sync(button->input);
                 button->last_state = !!state;
@@ -473,6 +492,9 @@ static int acpi_button_add(struct acpi_device *device)
         char *name, *class;
         int error;
 
+        if (!strcmp(hid, ACPI_BUTTON_HID_LID) && dmi_check_system(lid_blacklst))
+                return -ENODEV;
+
         button = kzalloc(sizeof(struct acpi_button), GFP_KERNEL);
         if (!button)
                 return -ENOMEM;
diff --git a/drivers/acpi/ec.c b/drivers/acpi/ec.c
index 0252c9b9af3d..d9f38c645e4a 100644
--- a/drivers/acpi/ec.c
+++ b/drivers/acpi/ec.c
@@ -1516,7 +1516,7 @@ static int acpi_ec_setup(struct acpi_ec *ec, bool handle_events)
         }
 
         acpi_handle_info(ec->handle,
-                         "GPE=0x%lx, EC_CMD/EC_SC=0x%lx, EC_DATA=0x%lx\n",
+                         "GPE=0x%x, EC_CMD/EC_SC=0x%lx, EC_DATA=0x%lx\n",
                          ec->gpe, ec->command_addr, ec->data_addr);
         return ret;
 }
diff --git a/drivers/acpi/ec_sys.c b/drivers/acpi/ec_sys.c
index 6c7dd7af789e..dd70d6c2bca0 100644
--- a/drivers/acpi/ec_sys.c
+++ b/drivers/acpi/ec_sys.c
@@ -128,7 +128,7 @@ static int acpi_ec_add_debugfs(struct acpi_ec *ec, unsigned int ec_device_count)
                 return -ENOMEM;
         }
 
-        if (!debugfs_create_x32("gpe", 0444, dev_dir, (u32 *)&first_ec->gpe))
+        if (!debugfs_create_x32("gpe", 0444, dev_dir, &first_ec->gpe))
                 goto error;
         if (!debugfs_create_bool("use_global_lock", 0444, dev_dir,
                                  &first_ec->global_lock))
diff --git a/drivers/acpi/evged.c b/drivers/acpi/evged.c
index 46f060356a22..f13ba2c07667 100644
--- a/drivers/acpi/evged.c
+++ b/drivers/acpi/evged.c
@@ -49,6 +49,11 @@
 
 #define MODULE_NAME     "acpi-ged"
 
+struct acpi_ged_device {
+        struct device *dev;
+        struct list_head event_list;
+};
+
 struct acpi_ged_event {
         struct list_head node;
         struct device *dev;
@@ -76,7 +81,8 @@ static acpi_status acpi_ged_request_interrupt(struct acpi_resource *ares,
         unsigned int irq;
         unsigned int gsi;
         unsigned int irqflags = IRQF_ONESHOT;
-        struct device *dev = context;
+        struct acpi_ged_device *geddev = context;
+        struct device *dev = geddev->dev;
         acpi_handle handle = ACPI_HANDLE(dev);
         acpi_handle evt_handle;
         struct resource r;
@@ -102,8 +108,6 @@ static acpi_status acpi_ged_request_interrupt(struct acpi_resource *ares,
                 return AE_ERROR;
         }
 
-        dev_info(dev, "GED listening GSI %u @ IRQ %u\n", gsi, irq);
-
         event = devm_kzalloc(dev, sizeof(*event), GFP_KERNEL);
         if (!event)
                 return AE_ERROR;
@@ -116,29 +120,58 @@ static acpi_status acpi_ged_request_interrupt(struct acpi_resource *ares,
         if (r.flags & IORESOURCE_IRQ_SHAREABLE)
                 irqflags |= IRQF_SHARED;
 
-        if (devm_request_threaded_irq(dev, irq, NULL, acpi_ged_irq_handler,
-                                      irqflags, "ACPI:Ged", event)) {
+        if (request_threaded_irq(irq, NULL, acpi_ged_irq_handler,
+                                 irqflags, "ACPI:Ged", event)) {
                 dev_err(dev, "failed to setup event handler for irq %u\n", irq);
                 return AE_ERROR;
         }
 
+        dev_dbg(dev, "GED listening GSI %u @ IRQ %u\n", gsi, irq);
+        list_add_tail(&event->node, &geddev->event_list);
         return AE_OK;
 }
 
 static int ged_probe(struct platform_device *pdev)
 {
+        struct acpi_ged_device *geddev;
         acpi_status acpi_ret;
 
+        geddev = devm_kzalloc(&pdev->dev, sizeof(*geddev), GFP_KERNEL);
+        if (!geddev)
+                return -ENOMEM;
+
+        geddev->dev = &pdev->dev;
+        INIT_LIST_HEAD(&geddev->event_list);
         acpi_ret = acpi_walk_resources(ACPI_HANDLE(&pdev->dev), "_CRS",
-                                       acpi_ged_request_interrupt, &pdev->dev);
+                                       acpi_ged_request_interrupt, geddev);
         if (ACPI_FAILURE(acpi_ret)) {
                 dev_err(&pdev->dev, "unable to parse the _CRS record\n");
                 return -EINVAL;
         }
+        platform_set_drvdata(pdev, geddev);
 
         return 0;
 }
 
+static void ged_shutdown(struct platform_device *pdev)
+{
+        struct acpi_ged_device *geddev = platform_get_drvdata(pdev);
+        struct acpi_ged_event *event, *next;
+
+        list_for_each_entry_safe(event, next, &geddev->event_list, node) {
+                free_irq(event->irq, event);
+                list_del(&event->node);
+                dev_dbg(geddev->dev, "GED releasing GSI %u @ IRQ %u\n",
+                         event->gsi, event->irq);
+        }
+}
+
+static int ged_remove(struct platform_device *pdev)
+{
+        ged_shutdown(pdev);
+        return 0;
+}
+
 static const struct acpi_device_id ged_acpi_ids[] = {
         {"ACPI0013"},
         {},
@@ -146,6 +179,8 @@ static const struct acpi_device_id ged_acpi_ids[] = {
 
 static struct platform_driver ged_driver = {
         .probe = ged_probe,
+        .remove = ged_remove,
+        .shutdown = ged_shutdown,
         .driver = {
                 .name = MODULE_NAME,
                 .acpi_match_table = ACPI_PTR(ged_acpi_ids),
diff --git a/drivers/acpi/internal.h b/drivers/acpi/internal.h
index 7f43423de43c..1d0a501bc7f0 100644
--- a/drivers/acpi/internal.h
+++ b/drivers/acpi/internal.h
@@ -159,7 +159,7 @@ static inline void acpi_early_processor_osc(void) {}
    -------------------------------------------------------------------------- */
 struct acpi_ec {
         acpi_handle handle;
-        unsigned long gpe;
+        u32 gpe;
         unsigned long command_addr;
         unsigned long data_addr;
         bool global_lock;
diff --git a/drivers/acpi/numa.c b/drivers/acpi/numa.c
index 917f1cc0fda4..8ccaae3550d2 100644
--- a/drivers/acpi/numa.c
+++ b/drivers/acpi/numa.c
@@ -460,8 +460,7 @@ int __init acpi_numa_init(void)
                                         srat_proc, ARRAY_SIZE(srat_proc), 0);
 
                 cnt = acpi_table_parse_srat(ACPI_SRAT_TYPE_MEMORY_AFFINITY,
-                                            acpi_parse_memory_affinity,
-                                            NR_NODE_MEMBLKS);
+                                            acpi_parse_memory_affinity, 0);
         }
 
         /* SLIT: System Locality Information Table */
diff --git a/drivers/acpi/pci_link.c b/drivers/acpi/pci_link.c
index bc3d914dfc3e..85ad679390e3 100644
--- a/drivers/acpi/pci_link.c
+++ b/drivers/acpi/pci_link.c
@@ -612,7 +612,7 @@ static int acpi_pci_link_allocate(struct acpi_pci_link *link)
                         acpi_isa_irq_penalty[link->irq.active] +=
                                 PIRQ_PENALTY_PCI_USING;
 
-                printk(KERN_WARNING PREFIX "%s [%s] enabled at IRQ %d\n",
+                pr_info("%s [%s] enabled at IRQ %d\n",
                        acpi_device_name(link->device),
                        acpi_device_bid(link->device), link->irq.active);
         }
diff --git a/drivers/acpi/pmic/intel_pmic_bxtwc.c b/drivers/acpi/pmic/intel_pmic_bxtwc.c
index 90011aad4d20..886ac8b93cd0 100644
--- a/drivers/acpi/pmic/intel_pmic_bxtwc.c
+++ b/drivers/acpi/pmic/intel_pmic_bxtwc.c
@@ -400,7 +400,7 @@ static int intel_bxtwc_pmic_opregion_probe(struct platform_device *pdev)
                         &intel_bxtwc_pmic_opregion_data);
 }
 
-static struct platform_device_id bxt_wc_opregion_id_table[] = {
+static const struct platform_device_id bxt_wc_opregion_id_table[] = {
         { .name = "bxt_wcove_region" },
         {},
 };
@@ -412,9 +412,4 @@ static struct platform_driver intel_bxtwc_pmic_opregion_driver = {
         },
         .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);
+builtin_platform_driver(intel_bxtwc_pmic_opregion_driver);
diff --git a/drivers/acpi/pmic/intel_pmic_chtdc_ti.c b/drivers/acpi/pmic/intel_pmic_chtdc_ti.c
index 109c1e9c9c7a..f6d73a243d80 100644
--- a/drivers/acpi/pmic/intel_pmic_chtdc_ti.c
+++ b/drivers/acpi/pmic/intel_pmic_chtdc_ti.c
@@ -131,7 +131,4 @@ static struct platform_driver chtdc_ti_pmic_opregion_driver = {
         },
         .id_table = chtdc_ti_pmic_opregion_id_table,
 };
-module_platform_driver(chtdc_ti_pmic_opregion_driver);
-
-MODULE_DESCRIPTION("Dollar Cove TI PMIC opregion driver");
-MODULE_LICENSE("GPL v2");
+builtin_platform_driver(chtdc_ti_pmic_opregion_driver);
diff --git a/drivers/acpi/pmic/intel_pmic_chtwc.c b/drivers/acpi/pmic/intel_pmic_chtwc.c
index 85636d7a9d39..9912422c8185 100644
--- a/drivers/acpi/pmic/intel_pmic_chtwc.c
+++ b/drivers/acpi/pmic/intel_pmic_chtwc.c
@@ -260,11 +260,10 @@ static int intel_cht_wc_pmic_opregion_probe(struct platform_device *pdev)
                         &intel_cht_wc_pmic_opregion_data);
 }
 
-static struct platform_device_id cht_wc_opregion_id_table[] = {
+static const struct platform_device_id cht_wc_opregion_id_table[] = {
         { .name = "cht_wcove_region" },
         {},
 };
-MODULE_DEVICE_TABLE(platform, cht_wc_opregion_id_table);
 
 static struct platform_driver intel_cht_wc_pmic_opregion_driver = {
         .probe = intel_cht_wc_pmic_opregion_probe,
@@ -273,8 +272,4 @@ static struct platform_driver intel_cht_wc_pmic_opregion_driver = {
         },
         .id_table = cht_wc_opregion_id_table,
 };
-module_platform_driver(intel_cht_wc_pmic_opregion_driver);
-
-MODULE_DESCRIPTION("Intel CHT Whiskey Cove PMIC operation region driver");
-MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
-MODULE_LICENSE("GPL");
+builtin_platform_driver(intel_cht_wc_pmic_opregion_driver);
diff --git a/drivers/acpi/pmic/intel_pmic_crc.c b/drivers/acpi/pmic/intel_pmic_crc.c
index d7f1761ab1bc..7ffa74048107 100644
--- a/drivers/acpi/pmic/intel_pmic_crc.c
+++ b/drivers/acpi/pmic/intel_pmic_crc.c
@@ -201,9 +201,4 @@ static struct platform_driver intel_crc_pmic_opregion_driver = {
                 .name = "crystal_cove_pmic",
         },
 };
-
-static int __init intel_crc_pmic_opregion_driver_init(void)
-{
-        return platform_driver_register(&intel_crc_pmic_opregion_driver);
-}
-device_initcall(intel_crc_pmic_opregion_driver_init);
+builtin_platform_driver(intel_crc_pmic_opregion_driver);
diff --git a/drivers/acpi/pmic/intel_pmic_xpower.c b/drivers/acpi/pmic/intel_pmic_xpower.c
index 6c99d3f81095..316e55174aa9 100644
--- a/drivers/acpi/pmic/intel_pmic_xpower.c
+++ b/drivers/acpi/pmic/intel_pmic_xpower.c
@@ -278,9 +278,4 @@ static struct platform_driver intel_xpower_pmic_opregion_driver = {
                 .name = "axp288_pmic_acpi",
         },
 };
-
-static int __init intel_xpower_pmic_opregion_driver_init(void)
-{
-        return platform_driver_register(&intel_xpower_pmic_opregion_driver);
-}
-device_initcall(intel_xpower_pmic_opregion_driver_init);
+builtin_platform_driver(intel_xpower_pmic_opregion_driver);
diff --git a/drivers/acpi/sysfs.c b/drivers/acpi/sysfs.c
index 06a150bb35bf..4fc59c3bc673 100644
--- a/drivers/acpi/sysfs.c
+++ b/drivers/acpi/sysfs.c
@@ -816,14 +816,8 @@ end:
  * interface:
  *   echo unmask > /sys/firmware/acpi/interrupts/gpe00
  */
-
-/*
- * Currently, the GPE flooding prevention only supports to mask the GPEs
- * numbered from 00 to 7f.
- */
-#define ACPI_MASKABLE_GPE_MAX   0x80
-
-static u64 __initdata acpi_masked_gpes;
+#define ACPI_MASKABLE_GPE_MAX   0xFF
+static DECLARE_BITMAP(acpi_masked_gpes_map, ACPI_MASKABLE_GPE_MAX) __initdata;
 
 static int __init acpi_gpe_set_masked_gpes(char *val)
 {
@@ -831,7 +825,7 @@ static int __init acpi_gpe_set_masked_gpes(char *val)
 
         if (kstrtou8(val, 0, &gpe) || gpe > ACPI_MASKABLE_GPE_MAX)
                 return -EINVAL;
-        acpi_masked_gpes |= ((u64)1<<gpe);
+        set_bit(gpe, acpi_masked_gpes_map);
 
         return 1;
 }
@@ -843,15 +837,11 @@ void __init acpi_gpe_apply_masked_gpes(void)
         acpi_status status;
         u8 gpe;
 
-        for (gpe = 0;
-             gpe < min_t(u8, ACPI_MASKABLE_GPE_MAX, acpi_current_gpe_count);
-             gpe++) {
-                if (acpi_masked_gpes & ((u64)1<<gpe)) {
-                        status = acpi_get_gpe_device(gpe, &handle);
-                        if (ACPI_SUCCESS(status)) {
-                                pr_info("Masking GPE 0x%x.\n", gpe);
-                                (void)acpi_mask_gpe(handle, gpe, TRUE);
-                        }
+        for_each_set_bit(gpe, acpi_masked_gpes_map, ACPI_MASKABLE_GPE_MAX) {
+                status = acpi_get_gpe_device(gpe, &handle);
+                if (ACPI_SUCCESS(status)) {
+                        pr_info("Masking GPE 0x%x.\n", gpe);
+                        (void)acpi_mask_gpe(handle, gpe, TRUE);
                 }
         }
 }
diff --git a/include/acpi/acconfig.h b/include/acpi/acconfig.h
index 6db3b4668b1a..ffe364fa4040 100644
--- a/include/acpi/acconfig.h
+++ b/include/acpi/acconfig.h
@@ -145,9 +145,9 @@
 
 #define ACPI_ADDRESS_RANGE_MAX          2
 
-/* Maximum number of While() loops before abort */
+/* Maximum time (default 30s) of While() loops before abort */
 
-#define ACPI_MAX_LOOP_COUNT             0x000FFFFF
+#define ACPI_MAX_LOOP_TIMEOUT           30
 
 /******************************************************************************
  *
diff --git a/include/acpi/acexcep.h b/include/acpi/acexcep.h
index 17d61b1f2511..3c46f0ef5f7a 100644
--- a/include/acpi/acexcep.h
+++ b/include/acpi/acexcep.h
@@ -130,8 +130,9 @@ struct acpi_exception_info {
 #define AE_HEX_OVERFLOW                 EXCEP_ENV (0x0020)
 #define AE_DECIMAL_OVERFLOW             EXCEP_ENV (0x0021)
 #define AE_OCTAL_OVERFLOW               EXCEP_ENV (0x0022)
+#define AE_END_OF_TABLE                 EXCEP_ENV (0x0023)
 
-#define AE_CODE_ENV_MAX                 0x0022
+#define AE_CODE_ENV_MAX                 0x0023
 
 /*
  * Programmer exceptions
@@ -195,7 +196,7 @@ struct acpi_exception_info {
 #define AE_AML_CIRCULAR_REFERENCE       EXCEP_AML (0x001E)
 #define AE_AML_BAD_RESOURCE_LENGTH      EXCEP_AML (0x001F)
 #define AE_AML_ILLEGAL_ADDRESS          EXCEP_AML (0x0020)
-#define AE_AML_INFINITE_LOOP            EXCEP_AML (0x0021)
+#define AE_AML_LOOP_TIMEOUT             EXCEP_AML (0x0021)
 #define AE_AML_UNINITIALIZED_NODE       EXCEP_AML (0x0022)
 #define AE_AML_TARGET_TYPE              EXCEP_AML (0x0023)
 
@@ -275,7 +276,8 @@ static const struct acpi_exception_info acpi_gbl_exception_names_env[] = {
         EXCEP_TXT("AE_DECIMAL_OVERFLOW",
                   "Overflow during ASCII decimal-to-binary conversion"),
         EXCEP_TXT("AE_OCTAL_OVERFLOW",
-                  "Overflow during ASCII octal-to-binary conversion")
+                  "Overflow during ASCII octal-to-binary conversion"),
+        EXCEP_TXT("AE_END_OF_TABLE", "Reached the end of table")
 };
 
 static const struct acpi_exception_info acpi_gbl_exception_names_pgm[] = {
@@ -368,8 +370,8 @@ static const struct acpi_exception_info acpi_gbl_exception_names_aml[] = {
                   "The length of a Resource Descriptor in the AML is incorrect"),
         EXCEP_TXT("AE_AML_ILLEGAL_ADDRESS",
                   "A memory, I/O, or PCI configuration address is invalid"),
-        EXCEP_TXT("AE_AML_INFINITE_LOOP",
-                  "An apparent infinite AML While loop, method was aborted"),
+        EXCEP_TXT("AE_AML_LOOP_TIMEOUT",
+                  "An AML While loop exceeded the maximum execution time"),
         EXCEP_TXT("AE_AML_UNINITIALIZED_NODE",
                   "A namespace node is uninitialized or unresolved"),
         EXCEP_TXT("AE_AML_TARGET_TYPE",
diff --git a/include/acpi/acpixf.h b/include/acpi/acpixf.h
index e1dd1a8d42b6..c589c3e12d90 100644
--- a/include/acpi/acpixf.h
+++ b/include/acpi/acpixf.h
@@ -46,7 +46,7 @@
 
 /* Current ACPICA subsystem version in YYYYMMDD format */
 
-#define ACPI_CA_VERSION                 0x20170831
+#define ACPI_CA_VERSION                 0x20171215
 
 #include <acpi/acconfig.h>
 #include <acpi/actypes.h>
@@ -260,11 +260,11 @@ ACPI_INIT_GLOBAL(u8, acpi_gbl_osi_data, 0);
 ACPI_INIT_GLOBAL(u8, acpi_gbl_reduced_hardware, FALSE);
 
 /*
- * Maximum number of While() loop iterations before forced method abort.
+ * Maximum timeout for While() loop iterations before forced method abort.
  * This mechanism is intended to prevent infinite loops during interpreter
  * execution within a host kernel.
  */
-ACPI_INIT_GLOBAL(u32, acpi_gbl_max_loop_iterations, ACPI_MAX_LOOP_COUNT);
+ACPI_INIT_GLOBAL(u32, acpi_gbl_max_loop_iterations, ACPI_MAX_LOOP_TIMEOUT);
 
 /*
  * This mechanism is used to trace a specified AML method. The method is
diff --git a/include/acpi/actbl1.h b/include/acpi/actbl1.h
index 7a89e6de94da..4c304bf4d591 100644
--- a/include/acpi/actbl1.h
+++ b/include/acpi/actbl1.h
@@ -69,9 +69,10 @@
 #define ACPI_SIG_HEST           "HEST"  /* Hardware Error Source Table */
 #define ACPI_SIG_MADT           "APIC"  /* Multiple APIC Description Table */
 #define ACPI_SIG_MSCT           "MSCT"  /* Maximum System Characteristics Table */
-#define ACPI_SIG_PDTT           "PDTT"  /* Processor Debug Trigger Table */
+#define ACPI_SIG_PDTT           "PDTT"  /* Platform Debug Trigger Table */
 #define ACPI_SIG_PPTT           "PPTT"  /* Processor Properties Topology Table */
 #define ACPI_SIG_SBST           "SBST"  /* Smart Battery Specification Table */
+#define ACPI_SIG_SDEV           "SDEV"  /* Secure Devices table */
 #define ACPI_SIG_SLIT           "SLIT"  /* System Locality Distance Information Table */
 #define ACPI_SIG_SRAT           "SRAT"  /* System Resource Affinity Table */
 #define ACPI_SIG_NFIT           "NFIT"  /* NVDIMM Firmware Interface Table */
@@ -1149,7 +1150,8 @@ enum acpi_nfit_type {
         ACPI_NFIT_TYPE_CONTROL_REGION = 4,
         ACPI_NFIT_TYPE_DATA_REGION = 5,
         ACPI_NFIT_TYPE_FLUSH_ADDRESS = 6,
-        ACPI_NFIT_TYPE_RESERVED = 7     /* 7 and greater are reserved */
+        ACPI_NFIT_TYPE_CAPABILITIES = 7,
+        ACPI_NFIT_TYPE_RESERVED = 8     /* 8 and greater are reserved */
 };
 
 /*
@@ -1162,7 +1164,7 @@ struct acpi_nfit_system_address {
         struct acpi_nfit_header header;
         u16 range_index;
         u16 flags;
-        u32 reserved;           /* Reseved, must be zero */
+        u32 reserved;           /* Reserved, must be zero */
         u32 proximity_domain;
         u8 range_guid[16];
         u64 address;
@@ -1281,9 +1283,72 @@ struct acpi_nfit_flush_address {
         u64 hint_address[1];    /* Variable length */
 };
 
+/* 7: Platform Capabilities Structure */
+
+struct acpi_nfit_capabilities {
+        struct acpi_nfit_header header;
+        u8 highest_capability;
+        u8 reserved[3];         /* Reserved, must be zero */
+        u32 capabilities;
+        u32 reserved2;
+};
+
+/* Capabilities Flags */
+
+#define ACPI_NFIT_CAPABILITY_CACHE_FLUSH       (1)      /* 00: Cache Flush to NVDIMM capable */
+#define ACPI_NFIT_CAPABILITY_MEM_FLUSH         (1<<1)   /* 01: Memory Flush to NVDIMM capable */
+#define ACPI_NFIT_CAPABILITY_MEM_MIRRORING     (1<<2)   /* 02: Memory Mirroring capable */
+
+/*
+ * NFIT/DVDIMM device handle support - used as the _ADR for each NVDIMM
+ */
+struct nfit_device_handle {
+        u32 handle;
+};
+
+/* Device handle construction and extraction macros */
+
+#define ACPI_NFIT_DIMM_NUMBER_MASK              0x0000000F
+#define ACPI_NFIT_CHANNEL_NUMBER_MASK           0x000000F0
+#define ACPI_NFIT_MEMORY_ID_MASK                0x00000F00
+#define ACPI_NFIT_SOCKET_ID_MASK                0x0000F000
+#define ACPI_NFIT_NODE_ID_MASK                  0x0FFF0000
+
+#define ACPI_NFIT_DIMM_NUMBER_OFFSET            0
+#define ACPI_NFIT_CHANNEL_NUMBER_OFFSET         4
+#define ACPI_NFIT_MEMORY_ID_OFFSET              8
+#define ACPI_NFIT_SOCKET_ID_OFFSET              12
+#define ACPI_NFIT_NODE_ID_OFFSET                16
+
+/* Macro to construct a NFIT/NVDIMM device handle */
+
+#define ACPI_NFIT_BUILD_DEVICE_HANDLE(dimm, channel, memory, socket, node) \
+        ((dimm)                                         | \
+        ((channel) << ACPI_NFIT_CHANNEL_NUMBER_OFFSET)  | \
+        ((memory)  << ACPI_NFIT_MEMORY_ID_OFFSET)       | \
+        ((socket)  << ACPI_NFIT_SOCKET_ID_OFFSET)       | \
+        ((node)    << ACPI_NFIT_NODE_ID_OFFSET))
+
+/* Macros to extract individual fields from a NFIT/NVDIMM device handle */
+
+#define ACPI_NFIT_GET_DIMM_NUMBER(handle) \
+        ((handle) & ACPI_NFIT_DIMM_NUMBER_MASK)
+
+#define ACPI_NFIT_GET_CHANNEL_NUMBER(handle) \
+        (((handle) & ACPI_NFIT_CHANNEL_NUMBER_MASK) >> ACPI_NFIT_CHANNEL_NUMBER_OFFSET)
+
+#define ACPI_NFIT_GET_MEMORY_ID(handle) \
+        (((handle) & ACPI_NFIT_MEMORY_ID_MASK)      >> ACPI_NFIT_MEMORY_ID_OFFSET)
+
+#define ACPI_NFIT_GET_SOCKET_ID(handle) \
+        (((handle) & ACPI_NFIT_SOCKET_ID_MASK)      >> ACPI_NFIT_SOCKET_ID_OFFSET)
+
+#define ACPI_NFIT_GET_NODE_ID(handle) \
+        (((handle) & ACPI_NFIT_NODE_ID_MASK)        >> ACPI_NFIT_NODE_ID_OFFSET)
+
 /*******************************************************************************
  *
- * PDTT - Processor Debug Trigger Table (ACPI 6.2)
+ * PDTT - Platform Debug Trigger Table (ACPI 6.2)
  *        Version 0
  *
  ******************************************************************************/
@@ -1301,14 +1366,14 @@ struct acpi_table_pdtt {
  * starting at array_offset.
  */
 struct acpi_pdtt_channel {
-        u16 sub_channel_id;
+        u8 subchannel_id;
+        u8 flags;
 };
 
-/* Mask and Flags for above */
+/* Flags for above */
 
-#define ACPI_PDTT_SUBCHANNEL_ID_MASK        0x00FF
-#define ACPI_PDTT_RUNTIME_TRIGGER           (1<<8)
-#define ACPI_PPTT_WAIT_COMPLETION           (1<<9)
+#define ACPI_PDTT_RUNTIME_TRIGGER           (1)
+#define ACPI_PDTT_WAIT_COMPLETION           (1<<1)
 
 /*******************************************************************************
  *
@@ -1376,6 +1441,20 @@ struct acpi_pptt_cache {
 #define ACPI_PPTT_MASK_CACHE_TYPE           (0x0C)      /* Cache type */
 #define ACPI_PPTT_MASK_WRITE_POLICY         (0x10)      /* Write policy */
 
+/* Attributes describing cache */
+#define ACPI_PPTT_CACHE_READ_ALLOCATE       (0x0)       /* Cache line is allocated on read */
+#define ACPI_PPTT_CACHE_WRITE_ALLOCATE      (0x01)      /* Cache line is allocated on write */
+#define ACPI_PPTT_CACHE_RW_ALLOCATE         (0x02)      /* Cache line is allocated on read and write */
+#define ACPI_PPTT_CACHE_RW_ALLOCATE_ALT     (0x03)      /* Alternate representation of above */
+
+#define ACPI_PPTT_CACHE_TYPE_DATA           (0x0)       /* Data cache */
+#define ACPI_PPTT_CACHE_TYPE_INSTR          (1<<2)      /* Instruction cache */
+#define ACPI_PPTT_CACHE_TYPE_UNIFIED        (2<<2)      /* Unified I & D cache */
+#define ACPI_PPTT_CACHE_TYPE_UNIFIED_ALT    (3<<2)      /* Alternate representation of above */
+
+#define ACPI_PPTT_CACHE_POLICY_WB           (0x0)       /* Cache is write back */
+#define ACPI_PPTT_CACHE_POLICY_WT           (1<<4)      /* Cache is write through */
+
 /* 2: ID Structure */
 
 struct acpi_pptt_id {
@@ -1405,6 +1484,68 @@ struct acpi_table_sbst {
 
 /*******************************************************************************
  *
+ * SDEV - Secure Devices Table (ACPI 6.2)
+ *        Version 1
+ *
+ ******************************************************************************/
+
+struct acpi_table_sdev {
+        struct acpi_table_header header;        /* Common ACPI table header */
+};
+
+struct acpi_sdev_header {
+        u8 type;
+        u8 flags;
+        u16 length;
+};
+
+/* Values for subtable type above */
+
+enum acpi_sdev_type {
+        ACPI_SDEV_TYPE_NAMESPACE_DEVICE = 0,
+        ACPI_SDEV_TYPE_PCIE_ENDPOINT_DEVICE = 1,
+        ACPI_SDEV_TYPE_RESERVED = 2     /* 2 and greater are reserved */
+};
+
+/* Values for flags above */
+
+#define ACPI_SDEV_HANDOFF_TO_UNSECURE_OS    (1)
+
+/*
+ * SDEV subtables
+ */
+
+/* 0: Namespace Device Based Secure Device Structure */
+
+struct acpi_sdev_namespace {
+        struct acpi_sdev_header header;
+        u16 device_id_offset;
+        u16 device_id_length;
+        u16 vendor_data_offset;
+        u16 vendor_data_length;
+};
+
+/* 1: PCIe Endpoint Device Based Device Structure */
+
+struct acpi_sdev_pcie {
+        struct acpi_sdev_header header;
+        u16 segment;
+        u16 start_bus;
+        u16 path_offset;
+        u16 path_length;
+        u16 vendor_data_offset;
+        u16 vendor_data_length;
+};
+
+/* 1a: PCIe Endpoint path entry */
+
+struct acpi_sdev_pcie_path {
+        u8 device;
+        u8 function;
+};
+
+/*******************************************************************************
+ *
  * SLIT - System Locality Distance Information Table
  *        Version 1
  *
diff --git a/include/acpi/actbl2.h b/include/acpi/actbl2.h
index 686b6f8c09dc..0d60d5df14f8 100644
--- a/include/acpi/actbl2.h
+++ b/include/acpi/actbl2.h
@@ -810,6 +810,7 @@ struct acpi_iort_smmu_v3 {
         u8 pxm;
         u8 reserved1;
         u16 reserved2;
+        u32 id_mapping_index;
 };
 
 /* Values for Model field above */
@@ -1246,6 +1247,8 @@ enum acpi_spmi_interface_types {
  * TCPA - Trusted Computing Platform Alliance table
  *        Version 2
  *
+ * TCG Hardware Interface Table for TPM 1.2 Clients and Servers
+ *
  * Conforms to "TCG ACPI Specification, Family 1.2 and 2.0",
  * Version 1.2, Revision 8
  * February 27, 2017
@@ -1310,6 +1313,8 @@ struct acpi_table_tcpa_server {
  * TPM2 - Trusted Platform Module (TPM) 2.0 Hardware Interface Table
  *        Version 4
  *
+ * TCG Hardware Interface Table for TPM 2.0 Clients and Servers
+ *
  * Conforms to "TCG ACPI Specification, Family 1.2 and 2.0",
  * Version 1.2, Revision 8
  * February 27, 2017
@@ -1329,15 +1334,23 @@ struct acpi_table_tpm2 {
 /* Values for start_method above */
 
 #define ACPI_TPM2_NOT_ALLOWED                       0
+#define ACPI_TPM2_RESERVED1                         1
 #define ACPI_TPM2_START_METHOD                      2
+#define ACPI_TPM2_RESERVED3                         3
+#define ACPI_TPM2_RESERVED4                         4
+#define ACPI_TPM2_RESERVED5                         5
 #define ACPI_TPM2_MEMORY_MAPPED                     6
 #define ACPI_TPM2_COMMAND_BUFFER                    7
 #define ACPI_TPM2_COMMAND_BUFFER_WITH_START_METHOD  8
+#define ACPI_TPM2_RESERVED9                         9
+#define ACPI_TPM2_RESERVED10                        10
 #define ACPI_TPM2_COMMAND_BUFFER_WITH_ARM_SMC       11  /* V1.2 Rev 8 */
+#define ACPI_TPM2_RESERVED                          12
 
-/* Trailer appears after any start_method subtables */
+/* Optional trailer appears after any start_method subtables */
 
 struct acpi_tpm2_trailer {
+        u8 method_parameters[12];
         u32 minimum_log_length; /* Minimum length for the event log area */
         u64 log_address;        /* Address of the event log area */
 };
diff --git a/include/acpi/actypes.h b/include/acpi/actypes.h
index 4f077edb9b81..31f1be74dd16 100644
--- a/include/acpi/actypes.h
+++ b/include/acpi/actypes.h
@@ -468,6 +468,8 @@ typedef void *acpi_handle;	/* Actually a ptr to a NS Node */
 #define ACPI_NSEC_PER_MSEC              1000000L
 #define ACPI_NSEC_PER_SEC               1000000000L
 
+#define ACPI_TIME_AFTER(a, b)           ((s64)((b) - (a)) < 0)
+
 /* Owner IDs are used to track namespace nodes for selective deletion */
 
 typedef u8 acpi_owner_id;
@@ -1299,6 +1301,8 @@ typedef enum {
 #define ACPI_OSI_WIN_7                  0x0B
 #define ACPI_OSI_WIN_8                  0x0C
 #define ACPI_OSI_WIN_10                 0x0D
+#define ACPI_OSI_WIN_10_RS1             0x0E
+#define ACPI_OSI_WIN_10_RS2             0x0F
 
 /* Definitions of getopt */
 
diff --git a/tools/power/acpi/tools/acpidump/apmain.c b/tools/power/acpi/tools/acpidump/apmain.c
index 22c3b4ee1617..be418fba9441 100644
--- a/tools/power/acpi/tools/acpidump/apmain.c
+++ b/tools/power/acpi/tools/acpidump/apmain.c
@@ -79,7 +79,7 @@ struct ap_dump_action action_table[AP_MAX_ACTIONS];
 u32 current_action = 0;
 
 #define AP_UTILITY_NAME             "ACPI Binary Table Dump Utility"
-#define AP_SUPPORTED_OPTIONS        "?a:bc:f:hn:o:r:svxz"
+#define AP_SUPPORTED_OPTIONS        "?a:bc:f:hn:o:r:sv^xz"
 
 /******************************************************************************
  *
@@ -100,6 +100,7 @@ static void ap_display_usage(void)
         ACPI_OPTION("-r <Address>", "Dump tables from specified RSDP");
         ACPI_OPTION("-s", "Print table summaries only");
         ACPI_OPTION("-v", "Display version information");
+        ACPI_OPTION("-vd", "Display build date and time");
         ACPI_OPTION("-z", "Verbose mode");
 
         ACPI_USAGE_TEXT("\nTable Options:\n");
@@ -231,10 +232,29 @@ static int ap_do_options(int argc, char **argv)
                         }
                         continue;
 
-                case 'v':       /* Revision/version */
+                case 'v':       /* -v: (Version): signon already emitted, just exit */
 
-                        acpi_os_printf(ACPI_COMMON_SIGNON(AP_UTILITY_NAME));
-                        return (1);
+                        switch (acpi_gbl_optarg[0]) {
+                        case '^':       /* -v: (Version) */
+
+                                fprintf(stderr,
+                                        ACPI_COMMON_SIGNON(AP_UTILITY_NAME));
+                                return (1);
+
+                        case 'd':
+
+                                fprintf(stderr,
+                                        ACPI_COMMON_SIGNON(AP_UTILITY_NAME));
+                                printf(ACPI_COMMON_BUILD_TIME);
+                                return (1);
+
+                        default:
+
+                                printf("Unknown option: -v%s\n",
+                                       acpi_gbl_optarg);
+                                return (-1);
+                        }
+                        break;
 
                 case 'z':       /* Verbose mode */