Merge branch 'acpica'

* acpica: (21 commits)
  ACPICA: Update version to 20131218.
  ACPICA: Utilities: Cleanup declarations of the acpi_gbl_debug_file global.
  ACPICA: Linuxize: Cleanup spaces after special macro invocations.
  ACPICA: Interpreter: Add additional debug info for an error case.
  ACPICA: Update ACPI example code to make it an actual working program.
  ACPICA: Add an error message if the Debugger fails initialization.
  ACPICA: Conditionally define a local variable that is used for debug only.
  ACPICA: Parser: Updates/fixes for debug output.
  ACPICA: Enhance ACPI warning for memory/IO address conflicts.
  ACPICA: Update several debug statements - no functional change.
  ACPICA: Improve exception handling for GPE block installation.
  ACPICA: Add helper macros to extract bus/segment numbers from HEST table.
  ACPICA: Tables: Add full support for the PCCT table, update table definition.
  ACPICA: Tables: Add full support for the DBG2 table.
  ACPICA: Add option to favor 32-bit FADT addresses.
  ACPICA: Cleanup the option of forcing the use of the RSDT.
  ACPICA: Back port and refine validation of the XSDT root table.
  ACPICA: Linux Header: Remove unused OSL prototypes.
  ACPICA: Remove unused ACPI_FREE_BUFFER macro. No functional change.
  ACPICA: Disassembler: Improve pathname support for emitted External() statements.
  ...

20 files changed, 478 insertions, 315 deletions

diff --git a/drivers/acpi/acpica/acdebug.h b/drivers/acpi/acpica/acdebug.h
index a9fd0b872062..2bf3ca2b8a7a 100644
--- a/drivers/acpi/acpica/acdebug.h
+++ b/drivers/acpi/acpica/acdebug.h
@@ -113,7 +113,6 @@ void acpi_db_display_handlers(void);
 ACPI_HW_DEPENDENT_RETURN_VOID(void
                               acpi_db_generate_gpe(char *gpe_arg,
                                                    char *block_arg))
-
 ACPI_HW_DEPENDENT_RETURN_VOID(void acpi_db_generate_sci(void))
 
 /*
diff --git a/drivers/acpi/acpica/acevents.h b/drivers/acpi/acpica/acevents.h
index 41abe552c7a3..0fb0adf435d6 100644
--- a/drivers/acpi/acpica/acevents.h
+++ b/drivers/acpi/acpica/acevents.h
@@ -71,9 +71,8 @@ acpi_status acpi_ev_init_global_lock_handler(void);
 
 ACPI_HW_DEPENDENT_RETURN_OK(acpi_status
                             acpi_ev_acquire_global_lock(u16 timeout))
-
 ACPI_HW_DEPENDENT_RETURN_OK(acpi_status acpi_ev_release_global_lock(void))
- acpi_status acpi_ev_remove_global_lock_handler(void);
+acpi_status acpi_ev_remove_global_lock_handler(void);
 
 /*
  * evgpe - Low-level GPE support
@@ -133,7 +132,7 @@ acpi_status acpi_ev_gpe_initialize(void);
 ACPI_HW_DEPENDENT_RETURN_VOID(void
                               acpi_ev_update_gpes(acpi_owner_id table_owner_id))
 
- acpi_status
+acpi_status
 acpi_ev_match_gpe_method(acpi_handle obj_handle,
                          u32 level, void *context, void **return_value);
 
@@ -149,7 +148,9 @@ acpi_status
 acpi_ev_get_gpe_device(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
                        struct acpi_gpe_block_info *gpe_block, void *context);
 
-struct acpi_gpe_xrupt_info *acpi_ev_get_gpe_xrupt_block(u32 interrupt_number);
+acpi_status
+acpi_ev_get_gpe_xrupt_block(u32 interrupt_number,
+                            struct acpi_gpe_xrupt_info **gpe_xrupt_block);
 
 acpi_status acpi_ev_delete_gpe_xrupt(struct acpi_gpe_xrupt_info *gpe_xrupt);
 
diff --git a/drivers/acpi/acpica/acglobal.h b/drivers/acpi/acpica/acglobal.h
index e9f1fc7f99c7..24db8e153bf0 100644
--- a/drivers/acpi/acpica/acglobal.h
+++ b/drivers/acpi/acpica/acglobal.h
@@ -119,6 +119,24 @@ bool ACPI_INIT_GLOBAL(acpi_gbl_enable_aml_debug_object, FALSE);
 u8 ACPI_INIT_GLOBAL(acpi_gbl_copy_dsdt_locally, FALSE);
 
 /*
+ * Optionally ignore an XSDT if present and use the RSDT instead.
+ * Although the ACPI specification requires that an XSDT be used instead
+ * of the RSDT, the XSDT has been found to be corrupt or ill-formed on
+ * some machines. Default behavior is to use the XSDT if present.
+ */
+u8 ACPI_INIT_GLOBAL(acpi_gbl_do_not_use_xsdt, FALSE);
+
+/*
+ * Optionally use 32-bit FADT addresses if and when there is a conflict
+ * (address mismatch) between the 32-bit and 64-bit versions of the
+ * address. Although ACPICA adheres to the ACPI specification which
+ * requires the use of the corresponding 64-bit address if it is non-zero,
+ * some machines have been found to have a corrupted non-zero 64-bit
+ * address. Default is FALSE, do not favor the 32-bit addresses.
+ */
+u8 ACPI_INIT_GLOBAL(acpi_gbl_use32_bit_fadt_addresses, FALSE);
+
+/*
  * Optionally truncate I/O addresses to 16 bits. Provides compatibility
  * with other ACPI implementations. NOTE: During ACPICA initialization,
  * this value is set to TRUE if any Windows OSI strings have been
@@ -484,6 +502,18 @@ ACPI_EXTERN u32 acpi_gbl_size_of_acpi_objects;
 
 /*****************************************************************************
  *
+ * Application globals
+ *
+ ****************************************************************************/
+
+#ifdef ACPI_APPLICATION
+
+ACPI_FILE ACPI_INIT_GLOBAL(acpi_gbl_debug_file, NULL);
+
+#endif                          /* ACPI_APPLICATION */
+
+/*****************************************************************************
+ *
  * Info/help support
  *
  ****************************************************************************/
diff --git a/drivers/acpi/acpica/aclocal.h b/drivers/acpi/acpica/aclocal.h
index 53ed1a8ba4f0..d95ca5449ace 100644
--- a/drivers/acpi/acpica/aclocal.h
+++ b/drivers/acpi/acpica/aclocal.h
@@ -1038,15 +1038,16 @@ struct acpi_external_list {
         struct acpi_external_list *next;
         u32 value;
         u16 length;
+        u16 flags;
         u8 type;
-        u8 flags;
-        u8 resolved;
-        u8 emitted;
 };
 
 /* Values for Flags field above */
 
-#define ACPI_IPATH_ALLOCATED    0x01
+#define ACPI_EXT_RESOLVED_REFERENCE         0x01        /* Object was resolved during cross ref */
+#define ACPI_EXT_ORIGIN_FROM_FILE           0x02        /* External came from a file */
+#define ACPI_EXT_INTERNAL_PATH_ALLOCATED    0x04        /* Deallocate internal path on completion */
+#define ACPI_EXT_EXTERNAL_EMITTED           0x08        /* External() statement has been emitted */
 
 struct acpi_external_file {
         char *path;
diff --git a/drivers/acpi/acpica/dsfield.c b/drivers/acpi/acpica/dsfield.c
index 2d4c07322576..e7a57c554e84 100644
--- a/drivers/acpi/acpica/dsfield.c
+++ b/drivers/acpi/acpica/dsfield.c
@@ -105,7 +105,7 @@ acpi_ds_create_external_region(acpi_status lookup_status,
          * operation_region not found. Generate an External for it, and
          * insert the name into the namespace.
          */
-        acpi_dm_add_to_external_list(op, path, ACPI_TYPE_REGION, 0);
+        acpi_dm_add_op_to_external_list(op, path, ACPI_TYPE_REGION, 0, 0);
         status = acpi_ns_lookup(walk_state->scope_info, path, ACPI_TYPE_REGION,
                                 ACPI_IMODE_LOAD_PASS1, ACPI_NS_SEARCH_PARENT,
                                 walk_state, node);
diff --git a/drivers/acpi/acpica/dsutils.c b/drivers/acpi/acpica/dsutils.c
index ade44e49deb4..d7f53fb2979a 100644
--- a/drivers/acpi/acpica/dsutils.c
+++ b/drivers/acpi/acpica/dsutils.c
@@ -727,27 +727,26 @@ acpi_ds_create_operands(struct acpi_walk_state *walk_state,
                 index++;
         }
 
-        index--;
+        ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
+                          "NumOperands %d, ArgCount %d, Index %d\n",
+                          walk_state->num_operands, arg_count, index));
 
-        /* It is the appropriate order to get objects from the Result stack */
+        /* Create the interpreter arguments, in reverse order */
 
+        index--;
         for (i = 0; i < arg_count; i++) {
                 arg = arguments[index];
-
-                /* Force the filling of the operand stack in inverse order */
-
-                walk_state->operand_index = (u8) index;
+                walk_state->operand_index = (u8)index;
 
                 status = acpi_ds_create_operand(walk_state, arg, index);
                 if (ACPI_FAILURE(status)) {
                         goto cleanup;
                 }
 
-                index--;
-
                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
-                                  "Arg #%u (%p) done, Arg1=%p\n", index, arg,
-                                  first_arg));
+                                  "Created Arg #%u (%p) %u args total\n",
+                                  index, arg, arg_count));
+                index--;
         }
 
         return_ACPI_STATUS(status);
diff --git a/drivers/acpi/acpica/dswload.c b/drivers/acpi/acpica/dswload.c
index 95e681a36f9c..2dbe109727c8 100644
--- a/drivers/acpi/acpica/dswload.c
+++ b/drivers/acpi/acpica/dswload.c
@@ -181,8 +181,8 @@ acpi_ds_load1_begin_op(struct acpi_walk_state * walk_state,
                          * Target of Scope() not found. Generate an External for it, and
                          * insert the name into the namespace.
                          */
-                        acpi_dm_add_to_external_list(op, path, ACPI_TYPE_DEVICE,
-                                                     0);
+                        acpi_dm_add_op_to_external_list(op, path,
+                                                        ACPI_TYPE_DEVICE, 0, 0);
                         status =
                             acpi_ns_lookup(walk_state->scope_info, path,
                                            object_type, ACPI_IMODE_LOAD_PASS1,
diff --git a/drivers/acpi/acpica/evgpeblk.c b/drivers/acpi/acpica/evgpeblk.c
index a9e76bc4ad97..a31e549e64cc 100644
--- a/drivers/acpi/acpica/evgpeblk.c
+++ b/drivers/acpi/acpica/evgpeblk.c
@@ -87,9 +87,9 @@ acpi_ev_install_gpe_block(struct acpi_gpe_block_info *gpe_block,
                 return_ACPI_STATUS(status);
         }
 
-        gpe_xrupt_block = acpi_ev_get_gpe_xrupt_block(interrupt_number);
-        if (!gpe_xrupt_block) {
-                status = AE_NO_MEMORY;
+        status =
+            acpi_ev_get_gpe_xrupt_block(interrupt_number, &gpe_xrupt_block);
+        if (ACPI_FAILURE(status)) {
                 goto unlock_and_exit;
         }
 
@@ -112,7 +112,7 @@ acpi_ev_install_gpe_block(struct acpi_gpe_block_info *gpe_block,
         acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
 
 unlock_and_exit:
-        status = acpi_ut_release_mutex(ACPI_MTX_EVENTS);
+        (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
         return_ACPI_STATUS(status);
 }
 
diff --git a/drivers/acpi/acpica/evgpeutil.c b/drivers/acpi/acpica/evgpeutil.c
index d3f5e1e2a2b1..4d764e847a08 100644
--- a/drivers/acpi/acpica/evgpeutil.c
+++ b/drivers/acpi/acpica/evgpeutil.c
@@ -197,8 +197,9 @@ acpi_ev_get_gpe_device(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
  * FUNCTION:    acpi_ev_get_gpe_xrupt_block
  *
  * PARAMETERS:  interrupt_number            - Interrupt for a GPE block
+ *              gpe_xrupt_block             - Where the block is returned
  *
- * RETURN:      A GPE interrupt block
+ * RETURN:      Status
  *
  * DESCRIPTION: Get or Create a GPE interrupt block. There is one interrupt
  *              block per unique interrupt level used for GPEs. Should be
@@ -207,7 +208,9 @@ acpi_ev_get_gpe_device(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
  *
  ******************************************************************************/
 
-struct acpi_gpe_xrupt_info *acpi_ev_get_gpe_xrupt_block(u32 interrupt_number)
+acpi_status
+acpi_ev_get_gpe_xrupt_block(u32 interrupt_number,
+                            struct acpi_gpe_xrupt_info ** gpe_xrupt_block)
 {
         struct acpi_gpe_xrupt_info *next_gpe_xrupt;
         struct acpi_gpe_xrupt_info *gpe_xrupt;
@@ -221,7 +224,8 @@ struct acpi_gpe_xrupt_info *acpi_ev_get_gpe_xrupt_block(u32 interrupt_number)
         next_gpe_xrupt = acpi_gbl_gpe_xrupt_list_head;
         while (next_gpe_xrupt) {
                 if (next_gpe_xrupt->interrupt_number == interrupt_number) {
-                        return_PTR(next_gpe_xrupt);
+                        *gpe_xrupt_block = next_gpe_xrupt;
+                        return_ACPI_STATUS(AE_OK);
                 }
 
                 next_gpe_xrupt = next_gpe_xrupt->next;
@@ -231,7 +235,7 @@ struct acpi_gpe_xrupt_info *acpi_ev_get_gpe_xrupt_block(u32 interrupt_number)
 
         gpe_xrupt = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_gpe_xrupt_info));
         if (!gpe_xrupt) {
-                return_PTR(NULL);
+                return_ACPI_STATUS(AE_NO_MEMORY);
         }
 
         gpe_xrupt->interrupt_number = interrupt_number;
@@ -250,6 +254,7 @@ struct acpi_gpe_xrupt_info *acpi_ev_get_gpe_xrupt_block(u32 interrupt_number)
         } else {
                 acpi_gbl_gpe_xrupt_list_head = gpe_xrupt;
         }
+
         acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
 
         /* Install new interrupt handler if not SCI_INT */
@@ -259,14 +264,15 @@ struct acpi_gpe_xrupt_info *acpi_ev_get_gpe_xrupt_block(u32 interrupt_number)
                                                            acpi_ev_gpe_xrupt_handler,
                                                            gpe_xrupt);
                 if (ACPI_FAILURE(status)) {
-                        ACPI_ERROR((AE_INFO,
-                                    "Could not install GPE interrupt handler at level 0x%X",
-                                    interrupt_number));
-                        return_PTR(NULL);
+                        ACPI_EXCEPTION((AE_INFO, status,
+                                        "Could not install GPE interrupt handler at level 0x%X",
+                                        interrupt_number));
+                        return_ACPI_STATUS(status);
                 }
         }
 
-        return_PTR(gpe_xrupt);
+        *gpe_xrupt_block = gpe_xrupt;
+        return_ACPI_STATUS(AE_OK);
 }
 
 /*******************************************************************************
diff --git a/drivers/acpi/acpica/exresnte.c b/drivers/acpi/acpica/exresnte.c
index acd34f599313..7ca6925a87ca 100644
--- a/drivers/acpi/acpica/exresnte.c
+++ b/drivers/acpi/acpica/exresnte.c
@@ -124,7 +124,8 @@ acpi_ex_resolve_node_to_value(struct acpi_namespace_node **object_ptr,
         }
 
         if (!source_desc) {
-                ACPI_ERROR((AE_INFO, "No object attached to node %p", node));
+                ACPI_ERROR((AE_INFO, "No object attached to node [%4.4s] %p",
+                            node->name.ascii, node));
                 return_ACPI_STATUS(AE_AML_NO_OPERAND);
         }
 
diff --git a/drivers/acpi/acpica/nsxfeval.c b/drivers/acpi/acpica/nsxfeval.c
index e973e311f856..1f0c28ba50df 100644
--- a/drivers/acpi/acpica/nsxfeval.c
+++ b/drivers/acpi/acpica/nsxfeval.c
@@ -84,7 +84,7 @@ acpi_evaluate_object_typed(acpi_handle handle,
                            acpi_object_type return_type)
 {
         acpi_status status;
-        u8 must_free = FALSE;
+        u8 free_buffer_on_error = FALSE;
 
         ACPI_FUNCTION_TRACE(acpi_evaluate_object_typed);
 
@@ -95,14 +95,13 @@ acpi_evaluate_object_typed(acpi_handle handle,
         }
 
         if (return_buffer->length == ACPI_ALLOCATE_BUFFER) {
-                must_free = TRUE;
+                free_buffer_on_error = TRUE;
         }
 
         /* Evaluate the object */
 
-        status =
-            acpi_evaluate_object(handle, pathname, external_params,
-                                 return_buffer);
+        status = acpi_evaluate_object(handle, pathname,
+                                      external_params, return_buffer);
         if (ACPI_FAILURE(status)) {
                 return_ACPI_STATUS(status);
         }
@@ -135,11 +134,15 @@ acpi_evaluate_object_typed(acpi_handle handle,
                                            pointer)->type),
                     acpi_ut_get_type_name(return_type)));
 
-        if (must_free) {
-
-                /* Caller used ACPI_ALLOCATE_BUFFER, free the return buffer */
-
-                ACPI_FREE_BUFFER(*return_buffer);
+        if (free_buffer_on_error) {
+                /*
+                 * Free a buffer created via ACPI_ALLOCATE_BUFFER.
+                 * Note: We use acpi_os_free here because acpi_os_allocate was used
+                 * to allocate the buffer. This purposefully bypasses the
+                 * (optionally enabled) allocation tracking mechanism since we
+                 * only want to track internal allocations.
+                 */
+                acpi_os_free(return_buffer->pointer);
                 return_buffer->pointer = NULL;
         }
 
diff --git a/drivers/acpi/acpica/psopinfo.c b/drivers/acpi/acpica/psopinfo.c
index 9ba5301e5751..b0c9787dbe61 100644
--- a/drivers/acpi/acpica/psopinfo.c
+++ b/drivers/acpi/acpica/psopinfo.c
@@ -71,6 +71,10 @@ static const u8 acpi_gbl_argument_count[] =
 
 const struct acpi_opcode_info *acpi_ps_get_opcode_info(u16 opcode)
 {
+#ifdef ACPI_DEBUG_OUTPUT
+        const char *opcode_name = "Unknown AML opcode";
+#endif
+
         ACPI_FUNCTION_NAME(ps_get_opcode_info);
 
         /*
@@ -92,11 +96,54 @@ const struct acpi_opcode_info *acpi_ps_get_opcode_info(u16 opcode)
                 return (&acpi_gbl_aml_op_info
                         [acpi_gbl_long_op_index[(u8)opcode]]);
         }
+#if defined ACPI_ASL_COMPILER && defined ACPI_DEBUG_OUTPUT
+#include "asldefine.h"
+
+        switch (opcode) {
+        case AML_RAW_DATA_BYTE:
+                opcode_name = "-Raw Data Byte-";
+                break;
+
+        case AML_RAW_DATA_WORD:
+                opcode_name = "-Raw Data Word-";
+                break;
+
+        case AML_RAW_DATA_DWORD:
+                opcode_name = "-Raw Data Dword-";
+                break;
+
+        case AML_RAW_DATA_QWORD:
+                opcode_name = "-Raw Data Qword-";
+                break;
+
+        case AML_RAW_DATA_BUFFER:
+                opcode_name = "-Raw Data Buffer-";
+                break;
+
+        case AML_RAW_DATA_CHAIN:
+                opcode_name = "-Raw Data Buffer Chain-";
+                break;
+
+        case AML_PACKAGE_LENGTH:
+                opcode_name = "-Package Length-";
+                break;
+
+        case AML_UNASSIGNED_OPCODE:
+                opcode_name = "-Unassigned Opcode-";
+                break;
+
+        case AML_DEFAULT_ARG_OP:
+                opcode_name = "-Default Arg-";
+                break;
+
+        default:
+                break;
+        }
+#endif
 
         /* Unknown AML opcode */
 
-        ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
-                          "Unknown AML opcode [%4.4X]\n", opcode));
+        ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "%s [%4.4X]\n", opcode_name, opcode));
 
         return (&acpi_gbl_aml_op_info[_UNK]);
 }
diff --git a/drivers/acpi/acpica/tbfadt.c b/drivers/acpi/acpica/tbfadt.c
index 9d99f2189693..8f89263ac47e 100644
--- a/drivers/acpi/acpica/tbfadt.c
+++ b/drivers/acpi/acpica/tbfadt.c
@@ -56,10 +56,11 @@ acpi_tb_init_generic_address(struct acpi_generic_address *generic_address,
 
 static void acpi_tb_convert_fadt(void);
 
-static void acpi_tb_validate_fadt(void);
-
 static void acpi_tb_setup_fadt_registers(void);
 
+static u64
+acpi_tb_select_address(char *register_name, u32 address32, u64 address64);
+
 /* Table for conversion of FADT to common internal format and FADT validation */
 
 typedef struct acpi_fadt_info {
@@ -175,6 +176,7 @@ static struct acpi_fadt_pm_info fadt_pm_info_table[] = {
  *              space_id            - ACPI Space ID for this register
  *              byte_width          - Width of this register
  *              address             - Address of the register
+ *              register_name       - ASCII name of the ACPI register
  *
  * RETURN:      None
  *
@@ -220,6 +222,68 @@ acpi_tb_init_generic_address(struct acpi_generic_address *generic_address,
 
 /*******************************************************************************
  *
+ * FUNCTION:    acpi_tb_select_address
+ *
+ * PARAMETERS:  register_name       - ASCII name of the ACPI register
+ *              address32           - 32-bit address of the register
+ *              address64           - 64-bit address of the register
+ *
+ * RETURN:      The resolved 64-bit address
+ *
+ * DESCRIPTION: Select between 32-bit and 64-bit versions of addresses within
+ *              the FADT. Used for the FACS and DSDT addresses.
+ *
+ * NOTES:
+ *
+ * Check for FACS and DSDT address mismatches. An address mismatch between
+ * the 32-bit and 64-bit address fields (FIRMWARE_CTRL/X_FIRMWARE_CTRL and
+ * DSDT/X_DSDT) could be a corrupted address field or it might indicate
+ * the presence of two FACS or two DSDT tables.
+ *
+ * November 2013:
+ * By default, as per the ACPICA specification, a valid 64-bit address is
+ * used regardless of the value of the 32-bit address. However, this
+ * behavior can be overridden via the acpi_gbl_use32_bit_fadt_addresses flag.
+ *
+ ******************************************************************************/
+
+static u64
+acpi_tb_select_address(char *register_name, u32 address32, u64 address64)
+{
+
+        if (!address64) {
+
+                /* 64-bit address is zero, use 32-bit address */
+
+                return ((u64)address32);
+        }
+
+        if (address32 && (address64 != (u64)address32)) {
+
+                /* Address mismatch between 32-bit and 64-bit versions */
+
+                ACPI_BIOS_WARNING((AE_INFO,
+                                   "32/64X %s address mismatch in FADT: "
+                                   "0x%8.8X/0x%8.8X%8.8X, using %u-bit address",
+                                   register_name, address32,
+                                   ACPI_FORMAT_UINT64(address64),
+                                   acpi_gbl_use32_bit_fadt_addresses ? 32 :
+                                   64));
+
+                /* 32-bit address override */
+
+                if (acpi_gbl_use32_bit_fadt_addresses) {
+                        return ((u64)address32);
+                }
+        }
+
+        /* Default is to use the 64-bit address */
+
+        return (address64);
+}
+
+/*******************************************************************************
+ *
  * FUNCTION:    acpi_tb_parse_fadt
  *
  * PARAMETERS:  table_index         - Index for the FADT
@@ -331,10 +395,6 @@ void acpi_tb_create_local_fadt(struct acpi_table_header *table, u32 length)
 
         acpi_tb_convert_fadt();
 
-        /* Validate FADT values now, before we make any changes */
-
-        acpi_tb_validate_fadt();
-
         /* Initialize the global ACPI register structures */
 
         acpi_tb_setup_fadt_registers();
@@ -344,66 +404,55 @@ void acpi_tb_create_local_fadt(struct acpi_table_header *table, u32 length)
  *
  * FUNCTION:    acpi_tb_convert_fadt
  *
- * PARAMETERS:  None, uses acpi_gbl_FADT
+ * PARAMETERS:  none - acpi_gbl_FADT is used.
  *
  * RETURN:      None
  *
  * DESCRIPTION: Converts all versions of the FADT to a common internal format.
- *              Expand 32-bit addresses to 64-bit as necessary.
+ *              Expand 32-bit addresses to 64-bit as necessary. Also validate
+ *              important fields within the FADT.
  *
- * NOTE:        acpi_gbl_FADT must be of size (struct acpi_table_fadt),
- *              and must contain a copy of the actual FADT.
+ * NOTE:        acpi_gbl_FADT must be of size (struct acpi_table_fadt), and must
+ *              contain a copy of the actual BIOS-provided FADT.
  *
  * Notes on 64-bit register addresses:
  *
  * After this FADT conversion, later ACPICA code will only use the 64-bit "X"
  * fields of the FADT for all ACPI register addresses.
  *
- * The 64-bit "X" fields are optional extensions to the original 32-bit FADT
+ * The 64-bit X fields are optional extensions to the original 32-bit FADT
  * V1.0 fields. Even if they are present in the FADT, they are optional and
  * are unused if the BIOS sets them to zero. Therefore, we must copy/expand
- * 32-bit V1.0 fields if the corresponding X field is zero.
+ * 32-bit V1.0 fields to the 64-bit X fields if the the 64-bit X field is
+ * originally zero.
  *
- * For ACPI 1.0 FADTs, all 32-bit address fields are expanded to the
- * corresponding "X" fields in the internal FADT.
+ * For ACPI 1.0 FADTs (that contain no 64-bit addresses), all 32-bit address
+ * fields are expanded to the corresponding 64-bit X fields in the internal
+ * common FADT.
  *
  * For ACPI 2.0+ FADTs, all valid (non-zero) 32-bit address fields are expanded
- * to the corresponding 64-bit X fields. For compatibility with other ACPI
- * implementations, we ignore the 64-bit field if the 32-bit field is valid,
- * regardless of whether the host OS is 32-bit or 64-bit.
+ * to the corresponding 64-bit X fields, if the 64-bit field is originally
+ * zero. Adhering to the ACPI specification, we completely ignore the 32-bit
+ * field if the 64-bit field is valid, regardless of whether the host OS is
+ * 32-bit or 64-bit.
+ *
+ * Possible additional checks:
+ *  (acpi_gbl_FADT.pm1_event_length >= 4)
+ *  (acpi_gbl_FADT.pm1_control_length >= 2)
+ *  (acpi_gbl_FADT.pm_timer_length >= 4)
+ *  Gpe block lengths must be multiple of 2
  *
  ******************************************************************************/
 
 static void acpi_tb_convert_fadt(void)
 {
+        char *name;
         struct acpi_generic_address *address64;
         u32 address32;
+        u8 length;
         u32 i;
 
         /*
-         * Expand the 32-bit FACS and DSDT addresses to 64-bit as necessary.
-         * Later code will always use the X 64-bit field. Also, check for an
-         * address mismatch between the 32-bit and 64-bit address fields
-         * (FIRMWARE_CTRL/X_FIRMWARE_CTRL, DSDT/X_DSDT) which would indicate
-         * the presence of two FACS or two DSDT tables.
-         */
-        if (!acpi_gbl_FADT.Xfacs) {
-                acpi_gbl_FADT.Xfacs = (u64) acpi_gbl_FADT.facs;
-        } else if (acpi_gbl_FADT.facs &&
-                   (acpi_gbl_FADT.Xfacs != (u64) acpi_gbl_FADT.facs)) {
-                ACPI_WARNING((AE_INFO,
-                    "32/64 FACS address mismatch in FADT - two FACS tables!"));
-        }
-
-        if (!acpi_gbl_FADT.Xdsdt) {
-                acpi_gbl_FADT.Xdsdt = (u64) acpi_gbl_FADT.dsdt;
-        } else if (acpi_gbl_FADT.dsdt &&
-                   (acpi_gbl_FADT.Xdsdt != (u64) acpi_gbl_FADT.dsdt)) {
-                ACPI_WARNING((AE_INFO,
-                    "32/64 DSDT address mismatch in FADT - two DSDT tables!"));
-        }
-
-        /*
          * For ACPI 1.0 FADTs (revision 1 or 2), ensure that reserved fields which
          * should be zero are indeed zero. This will workaround BIOSs that
          * inadvertently place values in these fields.
@@ -421,119 +470,24 @@ static void acpi_tb_convert_fadt(void)
                 acpi_gbl_FADT.boot_flags = 0;
         }
 
-        /* Update the local FADT table header length */
-
-        acpi_gbl_FADT.header.length = sizeof(struct acpi_table_fadt);
-
         /*
-         * Expand the ACPI 1.0 32-bit addresses to the ACPI 2.0 64-bit "X"
-         * generic address structures as necessary. Later code will always use
-         * the 64-bit address structures.
-         *
-         * March 2009:
-         * We now always use the 32-bit address if it is valid (non-null). This
-         * is not in accordance with the ACPI specification which states that
-         * the 64-bit address supersedes the 32-bit version, but we do this for
-         * compatibility with other ACPI implementations. Most notably, in the
-         * case where both the 32 and 64 versions are non-null, we use the 32-bit
-         * version. This is the only address that is guaranteed to have been
-         * tested by the BIOS manufacturer.
+         * Now we can update the local FADT length to the length of the
+         * current FADT version as defined by the ACPI specification.
+         * Thus, we will have a common FADT internally.
          */
-        for (i = 0; i < ACPI_FADT_INFO_ENTRIES; i++) {
-                address32 = *ACPI_ADD_PTR(u32,
-                                          &acpi_gbl_FADT,
-                                          fadt_info_table[i].address32);
-
-                address64 = ACPI_ADD_PTR(struct acpi_generic_address,
-                                         &acpi_gbl_FADT,
-                                         fadt_info_table[i].address64);
-
-                /*
-                 * If both 32- and 64-bit addresses are valid (non-zero),
-                 * they must match.
-                 */
-                if (address64->address && address32 &&
-                    (address64->address != (u64)address32)) {
-                        ACPI_BIOS_ERROR((AE_INFO,
-                                         "32/64X address mismatch in FADT/%s: "
-                                         "0x%8.8X/0x%8.8X%8.8X, using 32",
-                                         fadt_info_table[i].name, address32,
-                                         ACPI_FORMAT_UINT64(address64->
-                                                            address)));
-                }
-
-                /* Always use 32-bit address if it is valid (non-null) */
-
-                if (address32) {
-                        /*
-                         * Copy the 32-bit address to the 64-bit GAS structure. The
-                         * Space ID is always I/O for 32-bit legacy address fields
-                        */
-                        acpi_tb_init_generic_address(address64,
-                                                     ACPI_ADR_SPACE_SYSTEM_IO,
-                                                     *ACPI_ADD_PTR(u8,
-                                                                   &acpi_gbl_FADT,
-                                                                   fadt_info_table
-                                                                   [i].length),
-                                                     (u64) address32,
-                                                     fadt_info_table[i].name);
-                }
-        }
-}
-
-/*******************************************************************************
- *
- * FUNCTION:    acpi_tb_validate_fadt
- *
- * PARAMETERS:  table           - Pointer to the FADT to be validated
- *
- * RETURN:      None
- *
- * DESCRIPTION: Validate various important fields within the FADT. If a problem
- *              is found, issue a message, but no status is returned.
- *              Used by both the table manager and the disassembler.
- *
- * Possible additional checks:
- * (acpi_gbl_FADT.pm1_event_length >= 4)
- * (acpi_gbl_FADT.pm1_control_length >= 2)
- * (acpi_gbl_FADT.pm_timer_length >= 4)
- * Gpe block lengths must be multiple of 2
- *
- ******************************************************************************/
-
-static void acpi_tb_validate_fadt(void)
-{
-        char *name;
-        struct acpi_generic_address *address64;
-        u8 length;
-        u32 i;
+        acpi_gbl_FADT.header.length = sizeof(struct acpi_table_fadt);
 
         /*
-         * Check for FACS and DSDT address mismatches. An address mismatch between
-         * the 32-bit and 64-bit address fields (FIRMWARE_CTRL/X_FIRMWARE_CTRL and
-         * DSDT/X_DSDT) would indicate the presence of two FACS or two DSDT tables.
+         * Expand the 32-bit FACS and DSDT addresses to 64-bit as necessary.
+         * Later ACPICA code will always use the X 64-bit field.
          */
-        if (acpi_gbl_FADT.facs &&
-            (acpi_gbl_FADT.Xfacs != (u64)acpi_gbl_FADT.facs)) {
-                ACPI_BIOS_WARNING((AE_INFO,
-                                   "32/64X FACS address mismatch in FADT - "
-                                   "0x%8.8X/0x%8.8X%8.8X, using 32",
-                                   acpi_gbl_FADT.facs,
-                                   ACPI_FORMAT_UINT64(acpi_gbl_FADT.Xfacs)));
-
-                acpi_gbl_FADT.Xfacs = (u64)acpi_gbl_FADT.facs;
-        }
-
-        if (acpi_gbl_FADT.dsdt &&
-            (acpi_gbl_FADT.Xdsdt != (u64)acpi_gbl_FADT.dsdt)) {
-                ACPI_BIOS_WARNING((AE_INFO,
-                                   "32/64X DSDT address mismatch in FADT - "
-                                   "0x%8.8X/0x%8.8X%8.8X, using 32",
-                                   acpi_gbl_FADT.dsdt,
-                                   ACPI_FORMAT_UINT64(acpi_gbl_FADT.Xdsdt)));
+        acpi_gbl_FADT.Xfacs = acpi_tb_select_address("FACS",
+                                                     acpi_gbl_FADT.facs,
+                                                     acpi_gbl_FADT.Xfacs);
 
-                acpi_gbl_FADT.Xdsdt = (u64)acpi_gbl_FADT.dsdt;
-        }
+        acpi_gbl_FADT.Xdsdt = acpi_tb_select_address("DSDT",
+                                                     acpi_gbl_FADT.dsdt,
+                                                     acpi_gbl_FADT.Xdsdt);
 
         /* If Hardware Reduced flag is set, we are all done */
 
@@ -545,18 +499,95 @@ static void acpi_tb_validate_fadt(void)
 
         for (i = 0; i < ACPI_FADT_INFO_ENTRIES; i++) {
                 /*
-                 * Generate pointer to the 64-bit address, get the register
-                 * length (width) and the register name
+                 * Get the 32-bit and 64-bit addresses, as well as the register
+                 * length and register name.
                  */
+                address32 = *ACPI_ADD_PTR(u32,
+                                          &acpi_gbl_FADT,
+                                          fadt_info_table[i].address32);
+
                 address64 = ACPI_ADD_PTR(struct acpi_generic_address,
                                          &acpi_gbl_FADT,
                                          fadt_info_table[i].address64);
-                length =
-                    *ACPI_ADD_PTR(u8, &acpi_gbl_FADT,
-                                  fadt_info_table[i].length);
+
+                length = *ACPI_ADD_PTR(u8,
+                                       &acpi_gbl_FADT,
+                                       fadt_info_table[i].length);
+
                 name = fadt_info_table[i].name;
 
                 /*
+                 * Expand the ACPI 1.0 32-bit addresses to the ACPI 2.0 64-bit "X"
+                 * generic address structures as necessary. Later code will always use
+                 * the 64-bit address structures.
+                 *
+                 * November 2013:
+                 * Now always use the 64-bit address if it is valid (non-zero), in
+                 * accordance with the ACPI specification which states that a 64-bit
+                 * address supersedes the 32-bit version. This behavior can be
+                 * overridden by the acpi_gbl_use32_bit_fadt_addresses flag.
+                 *
+                 * During 64-bit address construction and verification,
+                 * these cases are handled:
+                 *
+                 * Address32 zero, Address64 [don't care]   - Use Address64
+                 *
+                 * Address32 non-zero, Address64 zero       - Copy/use Address32
+                 * Address32 non-zero == Address64 non-zero - Use Address64
+                 * Address32 non-zero != Address64 non-zero - Warning, use Address64
+                 *
+                 * Override: if acpi_gbl_use32_bit_fadt_addresses is TRUE, and:
+                 * Address32 non-zero != Address64 non-zero - Warning, copy/use Address32
+                 *
+                 * Note: space_id is always I/O for 32-bit legacy address fields
+                 */
+                if (address32) {
+                        if (!address64->address) {
+
+                                /* 64-bit address is zero, use 32-bit address */
+
+                                acpi_tb_init_generic_address(address64,
+                                                             ACPI_ADR_SPACE_SYSTEM_IO,
+                                                             *ACPI_ADD_PTR(u8,
+                                                                           &acpi_gbl_FADT,
+                                                                           fadt_info_table
+                                                                           [i].
+                                                                           length),
+                                                             (u64)address32,
+                                                             name);
+                        } else if (address64->address != (u64)address32) {
+
+                                /* Address mismatch */
+
+                                ACPI_BIOS_WARNING((AE_INFO,
+                                                   "32/64X address mismatch in FADT/%s: "
+                                                   "0x%8.8X/0x%8.8X%8.8X, using %u-bit address",
+                                                   name, address32,
+                                                   ACPI_FORMAT_UINT64
+                                                   (address64->address),
+                                                   acpi_gbl_use32_bit_fadt_addresses
+                                                   ? 32 : 64));
+
+                                if (acpi_gbl_use32_bit_fadt_addresses) {
+
+                                        /* 32-bit address override */
+
+                                        acpi_tb_init_generic_address(address64,
+                                                                     ACPI_ADR_SPACE_SYSTEM_IO,
+                                                                     *ACPI_ADD_PTR
+                                                                     (u8,
+                                                                      &acpi_gbl_FADT,
+                                                                      fadt_info_table
+                                                                      [i].
+                                                                      length),
+                                                                     (u64)
+                                                                     address32,
+                                                                     name);
+                                }
+                        }
+                }
+
+                /*
                  * For each extended field, check for length mismatch between the
                  * legacy length field and the corresponding 64-bit X length field.
                  * Note: If the legacy length field is > 0xFF bits, ignore this
diff --git a/drivers/acpi/acpica/tbutils.c b/drivers/acpi/acpica/tbutils.c
index 3d6bb83aa7e7..6412d3c301cb 100644
--- a/drivers/acpi/acpica/tbutils.c
+++ b/drivers/acpi/acpica/tbutils.c
@@ -49,69 +49,11 @@
 ACPI_MODULE_NAME("tbutils")
 
 /* Local prototypes */
+static acpi_status acpi_tb_validate_xsdt(acpi_physical_address address);
+
 static acpi_physical_address
 acpi_tb_get_root_table_entry(u8 *table_entry, u32 table_entry_size);
 
-/*******************************************************************************
- *
- * FUNCTION:    acpi_tb_check_xsdt
- *
- * PARAMETERS:  address                    - Pointer to the XSDT
- *
- * RETURN:      status
- *              AE_OK - XSDT is okay
- *              AE_NO_MEMORY - can't map XSDT
- *              AE_INVALID_TABLE_LENGTH - invalid table length
- *              AE_NULL_ENTRY - XSDT has NULL entry
- *
- * DESCRIPTION: validate XSDT
-******************************************************************************/
-
-static acpi_status
-acpi_tb_check_xsdt(acpi_physical_address address)
-{
-        struct acpi_table_header *table;
-        u32 length;
-        u64 xsdt_entry_address;
-        u8 *table_entry;
-        u32 table_count;
-        int i;
-
-        table = acpi_os_map_memory(address, sizeof(struct acpi_table_header));
-        if (!table)
-                return AE_NO_MEMORY;
-
-        length = table->length;
-        acpi_os_unmap_memory(table, sizeof(struct acpi_table_header));
-        if (length < sizeof(struct acpi_table_header))
-                return AE_INVALID_TABLE_LENGTH;
-
-        table = acpi_os_map_memory(address, length);
-        if (!table)
-                return AE_NO_MEMORY;
-
-        /* Calculate the number of tables described in XSDT */
-        table_count =
-                (u32) ((table->length -
-                sizeof(struct acpi_table_header)) / sizeof(u64));
-        table_entry =
-                ACPI_CAST_PTR(u8, table) + sizeof(struct acpi_table_header);
-        for (i = 0; i < table_count; i++) {
-                ACPI_MOVE_64_TO_64(&xsdt_entry_address, table_entry);
-                if (!xsdt_entry_address) {
-                        /* XSDT has NULL entry */
-                        break;
-                }
-                table_entry += sizeof(u64);
-        }
-        acpi_os_unmap_memory(table, length);
-
-        if (i < table_count)
-                return AE_NULL_ENTRY;
-        else
-                return AE_OK;
-}
-
 #if (!ACPI_REDUCED_HARDWARE)
 /*******************************************************************************
  *
@@ -383,7 +325,7 @@ acpi_tb_get_root_table_entry(u8 *table_entry, u32 table_entry_size)
          * Get the table physical address (32-bit for RSDT, 64-bit for XSDT):
          * Note: Addresses are 32-bit aligned (not 64) in both RSDT and XSDT
          */
-        if (table_entry_size == sizeof(u32)) {
+        if (table_entry_size == ACPI_RSDT_ENTRY_SIZE) {
                 /*
                  * 32-bit platform, RSDT: Return 32-bit table entry
                  * 64-bit platform, RSDT: Expand 32-bit to 64-bit and return
@@ -415,6 +357,87 @@ acpi_tb_get_root_table_entry(u8 *table_entry, u32 table_entry_size)
 
 /*******************************************************************************
  *
+ * FUNCTION:    acpi_tb_validate_xsdt
+ *
+ * PARAMETERS:  address             - Physical address of the XSDT (from RSDP)
+ *
+ * RETURN:      Status. AE_OK if the table appears to be valid.
+ *
+ * DESCRIPTION: Validate an XSDT to ensure that it is of minimum size and does
+ *              not contain any NULL entries. A problem that is seen in the
+ *              field is that the XSDT exists, but is actually useless because
+ *              of one or more (or all) NULL entries.
+ *
+ ******************************************************************************/
+
+static acpi_status acpi_tb_validate_xsdt(acpi_physical_address xsdt_address)
+{
+        struct acpi_table_header *table;
+        u8 *next_entry;
+        acpi_physical_address address;
+        u32 length;
+        u32 entry_count;
+        acpi_status status;
+        u32 i;
+
+        /* Get the XSDT length */
+
+        table =
+            acpi_os_map_memory(xsdt_address, sizeof(struct acpi_table_header));
+        if (!table) {
+                return (AE_NO_MEMORY);
+        }
+
+        length = table->length;
+        acpi_os_unmap_memory(table, sizeof(struct acpi_table_header));
+
+        /*
+         * Minimum XSDT length is the size of the standard ACPI header
+         * plus one physical address entry
+         */
+        if (length < (sizeof(struct acpi_table_header) + ACPI_XSDT_ENTRY_SIZE)) {
+                return (AE_INVALID_TABLE_LENGTH);
+        }
+
+        /* Map the entire XSDT */
+
+        table = acpi_os_map_memory(xsdt_address, length);
+        if (!table) {
+                return (AE_NO_MEMORY);
+        }
+
+        /* Get the number of entries and pointer to first entry */
+
+        status = AE_OK;
+        next_entry = ACPI_ADD_PTR(u8, table, sizeof(struct acpi_table_header));
+        entry_count = (u32)((table->length - sizeof(struct acpi_table_header)) /
+                            ACPI_XSDT_ENTRY_SIZE);
+
+        /* Validate each entry (physical address) within the XSDT */
+
+        for (i = 0; i < entry_count; i++) {
+                address =
+                    acpi_tb_get_root_table_entry(next_entry,
+                                                 ACPI_XSDT_ENTRY_SIZE);
+                if (!address) {
+
+                        /* Detected a NULL entry, XSDT is invalid */
+
+                        status = AE_NULL_ENTRY;
+                        break;
+                }
+
+                next_entry += ACPI_XSDT_ENTRY_SIZE;
+        }
+
+        /* Unmap table */
+
+        acpi_os_unmap_memory(table, length);
+        return (status);
+}
+
+/*******************************************************************************
+ *
  * FUNCTION:    acpi_tb_parse_root_table
  *
  * PARAMETERS:  rsdp                    - Pointer to the RSDP
@@ -438,16 +461,14 @@ acpi_status __init acpi_tb_parse_root_table(acpi_physical_address rsdp_address)
         u32 table_count;
         struct acpi_table_header *table;
         acpi_physical_address address;
-        acpi_physical_address uninitialized_var(rsdt_address);
         u32 length;
         u8 *table_entry;
         acpi_status status;
 
         ACPI_FUNCTION_TRACE(tb_parse_root_table);
 
-        /*
-         * Map the entire RSDP and extract the address of the RSDT or XSDT
-         */
+        /* Map the entire RSDP and extract the address of the RSDT or XSDT */
+
         rsdp = acpi_os_map_memory(rsdp_address, sizeof(struct acpi_table_rsdp));
         if (!rsdp) {
                 return_ACPI_STATUS(AE_NO_MEMORY);
@@ -457,24 +478,22 @@ acpi_status __init acpi_tb_parse_root_table(acpi_physical_address rsdp_address)
                                    ACPI_CAST_PTR(struct acpi_table_header,
                                                  rsdp));
 
-        /* Differentiate between RSDT and XSDT root tables */
+        /* Use XSDT if present and not overridden. Otherwise, use RSDT */
 
-        if (rsdp->revision > 1 && rsdp->xsdt_physical_address
-                        && !acpi_rsdt_forced) {
+        if ((rsdp->revision > 1) &&
+            rsdp->xsdt_physical_address && !acpi_gbl_do_not_use_xsdt) {
                 /*
-                 * Root table is an XSDT (64-bit physical addresses). We must use the
-                 * XSDT if the revision is > 1 and the XSDT pointer is present, as per
-                 * the ACPI specification.
+                 * RSDP contains an XSDT (64-bit physical addresses). We must use
+                 * the XSDT if the revision is > 1 and the XSDT pointer is present,
+                 * as per the ACPI specification.
                  */
                 address = (acpi_physical_address) rsdp->xsdt_physical_address;
-                table_entry_size = sizeof(u64);
-                rsdt_address = (acpi_physical_address)
-                                        rsdp->rsdt_physical_address;
+                table_entry_size = ACPI_XSDT_ENTRY_SIZE;
         } else {
                 /* Root table is an RSDT (32-bit physical addresses) */
 
                 address = (acpi_physical_address) rsdp->rsdt_physical_address;
-                table_entry_size = sizeof(u32);
+                table_entry_size = ACPI_RSDT_ENTRY_SIZE;
         }
 
         /*
@@ -483,15 +502,25 @@ acpi_status __init acpi_tb_parse_root_table(acpi_physical_address rsdp_address)
          */
         acpi_os_unmap_memory(rsdp, sizeof(struct acpi_table_rsdp));
 
-        if (table_entry_size == sizeof(u64)) {
-                if (acpi_tb_check_xsdt(address) == AE_NULL_ENTRY) {
-                        /* XSDT has NULL entry, RSDT is used */
-                        address = rsdt_address;
-                        table_entry_size = sizeof(u32);
-                        ACPI_WARNING((AE_INFO, "BIOS XSDT has NULL entry, "
-                                        "using RSDT"));
+        /*
+         * If it is present and used, validate the XSDT for access/size
+         * and ensure that all table entries are at least non-NULL
+         */
+        if (table_entry_size == ACPI_XSDT_ENTRY_SIZE) {
+                status = acpi_tb_validate_xsdt(address);
+                if (ACPI_FAILURE(status)) {
+                        ACPI_BIOS_WARNING((AE_INFO,
+                                           "XSDT is invalid (%s), using RSDT",
+                                           acpi_format_exception(status)));
+
+                        /* Fall back to the RSDT */
+
+                        address =
+                            (acpi_physical_address) rsdp->rsdt_physical_address;
+                        table_entry_size = ACPI_RSDT_ENTRY_SIZE;
                 }
         }
+
         /* Map the RSDT/XSDT table header to get the full table length */
 
         table = acpi_os_map_memory(address, sizeof(struct acpi_table_header));
@@ -501,12 +530,14 @@ acpi_status __init acpi_tb_parse_root_table(acpi_physical_address rsdp_address)
 
         acpi_tb_print_table_header(address, table);
 
-        /* Get the length of the full table, verify length and map entire table */
-
+        /*
+         * Validate length of the table, and map entire table.
+         * Minimum length table must contain at least one entry.
+         */
         length = table->length;
         acpi_os_unmap_memory(table, sizeof(struct acpi_table_header));
 
-        if (length < sizeof(struct acpi_table_header)) {
+        if (length < (sizeof(struct acpi_table_header) + table_entry_size)) {
                 ACPI_BIOS_ERROR((AE_INFO,
                                  "Invalid table length 0x%X in RSDT/XSDT",
                                  length));
@@ -526,22 +557,21 @@ acpi_status __init acpi_tb_parse_root_table(acpi_physical_address rsdp_address)
                 return_ACPI_STATUS(status);
         }
 
-        /* Calculate the number of tables described in the root table */
+        /* Get the number of entries and pointer to first entry */
 
         table_count = (u32)((table->length - sizeof(struct acpi_table_header)) /
                             table_entry_size);
+        table_entry = ACPI_ADD_PTR(u8, table, sizeof(struct acpi_table_header));
+
         /*
          * First two entries in the table array are reserved for the DSDT
          * and FACS, which are not actually present in the RSDT/XSDT - they
          * come from the FADT
          */
-        table_entry =
-            ACPI_CAST_PTR(u8, table) + sizeof(struct acpi_table_header);
         acpi_gbl_root_table_list.current_table_count = 2;
 
-        /*
-         * Initialize the root table array from the RSDT/XSDT
-         */
+        /* Initialize the root table array from the RSDT/XSDT */
+
         for (i = 0; i < table_count; i++) {
                 if (acpi_gbl_root_table_list.current_table_count >=
                     acpi_gbl_root_table_list.max_table_count) {
@@ -584,7 +614,7 @@ acpi_status __init acpi_tb_parse_root_table(acpi_physical_address rsdp_address)
                 acpi_tb_install_table(acpi_gbl_root_table_list.tables[i].
                                       address, NULL, i);
 
-                /* Special case for FADT - get the DSDT and FACS */
+                /* Special case for FADT - validate it then get the DSDT and FACS */
 
                 if (ACPI_COMPARE_NAME
                     (&acpi_gbl_root_table_list.tables[i].signature,
diff --git a/drivers/acpi/acpica/utaddress.c b/drivers/acpi/acpica/utaddress.c
index e0a2e2779c2e..2c2b6ae5dfc4 100644
--- a/drivers/acpi/acpica/utaddress.c
+++ b/drivers/acpi/acpica/utaddress.c
@@ -224,10 +224,11 @@ acpi_ut_check_address_range(acpi_adr_space_type space_id,
 
         while (range_info) {
                 /*
-                 * Check if the requested Address/Length overlaps this address_range.
-                 * Four cases to consider:
+                 * Check if the requested address/length overlaps this
+                 * address range. There are four cases to consider:
                  *
-                 * 1) Input address/length is contained completely in the address range
+                 * 1) Input address/length is contained completely in the
+                 *    address range
                  * 2) Input address/length overlaps range at the range start
                  * 3) Input address/length overlaps range at the range end
                  * 4) Input address/length completely encompasses the range
@@ -244,11 +245,17 @@ acpi_ut_check_address_range(acpi_adr_space_type space_id,
                                                                   region_node);
 
                                 ACPI_WARNING((AE_INFO,
-                                              "0x%p-0x%p %s conflicts with Region %s %d",
+                                              "%s range 0x%p-0x%p conflicts with OpRegion 0x%p-0x%p (%s)",
+                                              acpi_ut_get_region_name(space_id),
                                               ACPI_CAST_PTR(void, address),
                                               ACPI_CAST_PTR(void, end_address),
-                                              acpi_ut_get_region_name(space_id),
-                                              pathname, overlap_count));
+                                              ACPI_CAST_PTR(void,
+                                                            range_info->
+                                                            start_address),
+                                              ACPI_CAST_PTR(void,
+                                                            range_info->
+                                                            end_address),
+                                              pathname));
                                 ACPI_FREE(pathname);
                         }
                 }
diff --git a/drivers/acpi/acpica/utalloc.c b/drivers/acpi/acpica/utalloc.c
index 814267f52715..1851762fc5b5 100644
--- a/drivers/acpi/acpica/utalloc.c
+++ b/drivers/acpi/acpica/utalloc.c
@@ -302,9 +302,13 @@ acpi_ut_initialize_buffer(struct acpi_buffer * buffer,
                 return (AE_BUFFER_OVERFLOW);
 
         case ACPI_ALLOCATE_BUFFER:
-
-                /* Allocate a new buffer */
-
+                /*
+                 * Allocate a new buffer. We directectly call acpi_os_allocate here to
+                 * purposefully bypass the (optionally enabled) internal allocation
+                 * tracking mechanism since we only want to track internal
+                 * allocations. Note: The caller should use acpi_os_free to free this
+                 * buffer created via ACPI_ALLOCATE_BUFFER.
+                 */
                 buffer->pointer = acpi_os_allocate(required_length);
                 break;
 
diff --git a/drivers/acpi/acpica/utcache.c b/drivers/acpi/acpica/utcache.c
index 366bfec4b770..cacd2fd9e665 100644
--- a/drivers/acpi/acpica/utcache.c
+++ b/drivers/acpi/acpica/utcache.c
@@ -248,12 +248,12 @@ void *acpi_os_acquire_object(struct acpi_memory_list *cache)
         ACPI_FUNCTION_NAME(os_acquire_object);
 
         if (!cache) {
-                return (NULL);
+                return_PTR(NULL);
         }
 
         status = acpi_ut_acquire_mutex(ACPI_MTX_CACHES);
         if (ACPI_FAILURE(status)) {
-                return (NULL);
+                return_PTR(NULL);
         }
 
         ACPI_MEM_TRACKING(cache->requests++);
@@ -276,7 +276,7 @@ void *acpi_os_acquire_object(struct acpi_memory_list *cache)
 
                 status = acpi_ut_release_mutex(ACPI_MTX_CACHES);
                 if (ACPI_FAILURE(status)) {
-                        return (NULL);
+                        return_PTR(NULL);
                 }
 
                 /* Clear (zero) the previously used Object */
@@ -299,15 +299,15 @@ void *acpi_os_acquire_object(struct acpi_memory_list *cache)
 
                 status = acpi_ut_release_mutex(ACPI_MTX_CACHES);
                 if (ACPI_FAILURE(status)) {
-                        return (NULL);
+                        return_PTR(NULL);
                 }
 
                 object = ACPI_ALLOCATE_ZEROED(cache->object_size);
                 if (!object) {
-                        return (NULL);
+                        return_PTR(NULL);
                 }
         }
 
-        return (object);
+        return_PTR(object);
 }
 #endif                          /* ACPI_USE_LOCAL_CACHE */
diff --git a/drivers/acpi/acpica/utdebug.c b/drivers/acpi/acpica/utdebug.c
index 03ae8affe48f..d971c8631263 100644
--- a/drivers/acpi/acpica/utdebug.c
+++ b/drivers/acpi/acpica/utdebug.c
@@ -194,9 +194,9 @@ acpi_debug_print(u32 requested_debug_level,
          */
         acpi_os_printf("%9s-%04ld ", module_name, line_number);
 
-#ifdef ACPI_EXEC_APP
+#ifdef ACPI_APPLICATION
         /*
-         * For acpi_exec only, emit the thread ID and nesting level.
+         * For acpi_exec/iASL only, emit the thread ID and nesting level.
          * Note: nesting level is really only useful during a single-thread
          * execution. Otherwise, multiple threads will keep resetting the
          * level.
diff --git a/drivers/acpi/acpica/utglobal.c b/drivers/acpi/acpica/utglobal.c
index 81f9a9584451..030cb0dc673c 100644
--- a/drivers/acpi/acpica/utglobal.c
+++ b/drivers/acpi/acpica/utglobal.c
@@ -388,11 +388,7 @@ acpi_status acpi_ut_init_globals(void)
 /* Public globals */
 
 ACPI_EXPORT_SYMBOL(acpi_gbl_FADT)
-
 ACPI_EXPORT_SYMBOL(acpi_dbg_level)
-
 ACPI_EXPORT_SYMBOL(acpi_dbg_layer)
-
 ACPI_EXPORT_SYMBOL(acpi_gpe_count)
-
 ACPI_EXPORT_SYMBOL(acpi_current_gpe_count)
diff --git a/drivers/acpi/acpica/utxfinit.c b/drivers/acpi/acpica/utxfinit.c
index 75efea0539c1..246ef68681f4 100644
--- a/drivers/acpi/acpica/utxfinit.c
+++ b/drivers/acpi/acpica/utxfinit.c
@@ -122,8 +122,16 @@ acpi_status __init acpi_initialize_subsystem(void)
 
         /* If configured, initialize the AML debugger */
 
-        ACPI_DEBUGGER_EXEC(status = acpi_db_initialize());
-        return_ACPI_STATUS(status);
+#ifdef ACPI_DEBUGGER
+        status = acpi_db_initialize();
+        if (ACPI_FAILURE(status)) {
+                ACPI_EXCEPTION((AE_INFO, status,
+                                "During Debugger initialization"));
+                return_ACPI_STATUS(status);
+        }
+#endif
+
+        return_ACPI_STATUS(AE_OK);
 }
 
 ACPI_EXPORT_SYMBOL_INIT(acpi_initialize_subsystem)