ACPI: ACPICA 20060421

Removed a device initialization optimization introduced in
20051216 where the _STA method was not run unless an _INI
was also present for the same device. This optimization
could cause problems because it could allow _INI methods
to be run within a not-present device subtree (If a
not-present device had no _INI, _STA would not be run,
the not-present status would not be discovered, and the
children of the device would be incorrectly traversed.)

Implemented a new _STA optimization where namespace
subtrees that do not contain _INI are identified and
ignored during device initialization. Selectively running
_STA can significantly improve boot time on large machines
(with assistance from Len Brown.)

Implemented support for the device initialization case
where the returned _STA flags indicate a device not-present
but functioning. In this case, _INI is not run, but the
device children are examined for presence, as per the
ACPI specification.

Implemented an additional change to the IndexField support
in order to conform to MS behavior. The value written to
the Index Register is not simply a byte offset, it is a
byte offset in units of the access width of the parent
Index Field. (Fiodor Suietov)

Defined and deployed a new OSL interface,
acpi_os_validate_address().  This interface is called during
the creation of all AML operation regions, and allows
the host OS to exert control over what addresses it will
allow the AML code to access. Operation Regions whose
addresses are disallowed will cause a runtime exception
when they are actually accessed (will not affect or abort
table loading.)

Defined and deployed a new OSL interface,
acpi_os_validate_interface().  This interface allows the host OS
to match the various "optional" interface/behavior strings
for the _OSI predefined control method as appropriate
(with assistance from Bjorn Helgaas.)

Restructured and corrected various problems in the
exception handling code paths within DsCallControlMethod
and DsTerminateControlMethod in dsmethod (with assistance
from Takayoshi Kochi.)

Modified the Linux source converter to ignore quoted string
literals while converting identifiers from mixed to lower
case. This will correct problems with the disassembler
and other areas where such strings must not be modified.

The ACPI_FUNCTION_* macros no longer require quotes around
the function name. This allows the Linux source converter
to convert the names, now that the converter ignores
quoted strings.

Signed-off-by: Bob Moore <robert.moore@intel.com>
Signed-off-by: Len Brown <len.brown@intel.com>

14 files changed, 247 insertions, 138 deletions

diff --git a/drivers/acpi/namespace/nsaccess.c b/drivers/acpi/namespace/nsaccess.c
index d4914fda6a37..5e3f63a90fb4 100644
--- a/drivers/acpi/namespace/nsaccess.c
+++ b/drivers/acpi/namespace/nsaccess.c
@@ -70,7 +70,7 @@ acpi_status acpi_ns_root_initialize(void)
         union acpi_operand_object *obj_desc;
         acpi_string val = NULL;
 
-        ACPI_FUNCTION_TRACE("ns_root_initialize");
+        ACPI_FUNCTION_TRACE(ns_root_initialize);
 
         status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
         if (ACPI_FAILURE(status)) {
@@ -314,7 +314,7 @@ acpi_ns_lookup(union acpi_generic_state *scope_info,
         u32 local_flags = flags & ~(ACPI_NS_ERROR_IF_FOUND |
                                     ACPI_NS_SEARCH_PARENT);
 
-        ACPI_FUNCTION_TRACE("ns_lookup");
+        ACPI_FUNCTION_TRACE(ns_lookup);
 
         if (!return_node) {
                 return_ACPI_STATUS(AE_BAD_PARAMETER);
@@ -615,7 +615,7 @@ acpi_ns_lookup(union acpi_generic_state *scope_info,
                         /* Complain about a type mismatch */
 
                         ACPI_WARNING((AE_INFO,
-                                      "ns_lookup: Type mismatch on %4.4s (%s), searching for (%s)",
+                                      "NsLookup: Type mismatch on %4.4s (%s), searching for (%s)",
                                       ACPI_CAST_PTR(char, &simple_name),
                                       acpi_ut_get_type_name(this_node->type),
                                       acpi_ut_get_type_name
diff --git a/drivers/acpi/namespace/nsalloc.c b/drivers/acpi/namespace/nsalloc.c
index c92c03693a16..dc3f0739a46b 100644
--- a/drivers/acpi/namespace/nsalloc.c
+++ b/drivers/acpi/namespace/nsalloc.c
@@ -62,7 +62,7 @@ struct acpi_namespace_node *acpi_ns_create_node(u32 name)
 {
         struct acpi_namespace_node *node;
 
-        ACPI_FUNCTION_TRACE("ns_create_node");
+        ACPI_FUNCTION_TRACE(ns_create_node);
 
         node = acpi_os_acquire_object(acpi_gbl_namespace_cache);
         if (!node) {
@@ -94,7 +94,7 @@ void acpi_ns_delete_node(struct acpi_namespace_node *node)
         struct acpi_namespace_node *prev_node;
         struct acpi_namespace_node *next_node;
 
-        ACPI_FUNCTION_TRACE_PTR("ns_delete_node", node);
+        ACPI_FUNCTION_TRACE_PTR(ns_delete_node, node);
 
         parent_node = acpi_ns_get_parent_node(node);
 
@@ -167,7 +167,7 @@ void acpi_ns_install_node(struct acpi_walk_state *walk_state, struct acpi_namesp
         acpi_owner_id owner_id = 0;
         struct acpi_namespace_node *child_node;
 
-        ACPI_FUNCTION_TRACE("ns_install_node");
+        ACPI_FUNCTION_TRACE(ns_install_node);
 
         /*
          * Get the owner ID from the Walk state
@@ -234,7 +234,7 @@ void acpi_ns_delete_children(struct acpi_namespace_node *parent_node)
         struct acpi_namespace_node *next_node;
         u8 flags;
 
-        ACPI_FUNCTION_TRACE_PTR("ns_delete_children", parent_node);
+        ACPI_FUNCTION_TRACE_PTR(ns_delete_children, parent_node);
 
         if (!parent_node) {
                 return_VOID;
@@ -313,7 +313,7 @@ void acpi_ns_delete_namespace_subtree(struct acpi_namespace_node *parent_node)
         struct acpi_namespace_node *child_node = NULL;
         u32 level = 1;
 
-        ACPI_FUNCTION_TRACE("ns_delete_namespace_subtree");
+        ACPI_FUNCTION_TRACE(ns_delete_namespace_subtree);
 
         if (!parent_node) {
                 return_VOID;
@@ -395,7 +395,7 @@ void acpi_ns_delete_namespace_by_owner(acpi_owner_id owner_id)
         u32 level;
         struct acpi_namespace_node *parent_node;
 
-        ACPI_FUNCTION_TRACE_U32("ns_delete_namespace_by_owner", owner_id);
+        ACPI_FUNCTION_TRACE_U32(ns_delete_namespace_by_owner, owner_id);
 
         if (owner_id == 0) {
                 return_VOID;
diff --git a/drivers/acpi/namespace/nsdump.c b/drivers/acpi/namespace/nsdump.c
index 5662d2def62f..d72df66aa965 100644
--- a/drivers/acpi/namespace/nsdump.c
+++ b/drivers/acpi/namespace/nsdump.c
@@ -75,7 +75,7 @@ void acpi_ns_print_pathname(u32 num_segments, char *pathname)
 {
         acpi_native_uint i;
 
-        ACPI_FUNCTION_NAME("ns_print_pathname");
+        ACPI_FUNCTION_NAME(ns_print_pathname);
 
         if (!(acpi_dbg_level & ACPI_LV_NAMES)
             || !(acpi_dbg_layer & ACPI_NAMESPACE)) {
@@ -123,7 +123,7 @@ void
 acpi_ns_dump_pathname(acpi_handle handle, char *msg, u32 level, u32 component)
 {
 
-        ACPI_FUNCTION_TRACE("ns_dump_pathname");
+        ACPI_FUNCTION_TRACE(ns_dump_pathname);
 
         /* Do this only if the requested debug level and component are enabled */
 
@@ -167,7 +167,7 @@ acpi_ns_dump_one_object(acpi_handle obj_handle,
         u32 dbg_level;
         u32 i;
 
-        ACPI_FUNCTION_NAME("ns_dump_one_object");
+        ACPI_FUNCTION_NAME(ns_dump_one_object);
 
         /* Is output enabled? */
 
@@ -675,7 +675,7 @@ void acpi_ns_dump_tables(acpi_handle search_base, u32 max_depth)
 {
         acpi_handle search_handle = search_base;
 
-        ACPI_FUNCTION_TRACE("ns_dump_tables");
+        ACPI_FUNCTION_TRACE(ns_dump_tables);
 
         if (!acpi_gbl_root_node) {
                 /*
diff --git a/drivers/acpi/namespace/nsdumpdv.c b/drivers/acpi/namespace/nsdumpdv.c
index 2b311da01ef5..c6bf5d30fca3 100644
--- a/drivers/acpi/namespace/nsdumpdv.c
+++ b/drivers/acpi/namespace/nsdumpdv.c
@@ -74,7 +74,7 @@ acpi_ns_dump_one_device(acpi_handle obj_handle,
         acpi_status status;
         u32 i;
 
-        ACPI_FUNCTION_NAME("ns_dump_one_device");
+        ACPI_FUNCTION_NAME(ns_dump_one_device);
 
         status =
             acpi_ns_dump_one_object(obj_handle, level, context, return_value);
@@ -115,7 +115,7 @@ void acpi_ns_dump_root_devices(void)
         acpi_handle sys_bus_handle;
         acpi_status status;
 
-        ACPI_FUNCTION_NAME("ns_dump_root_devices");
+        ACPI_FUNCTION_NAME(ns_dump_root_devices);
 
         /* Only dump the table if tracing is enabled */
 
diff --git a/drivers/acpi/namespace/nseval.c b/drivers/acpi/namespace/nseval.c
index f5d8e71b82cc..4b054062b46a 100644
--- a/drivers/acpi/namespace/nseval.c
+++ b/drivers/acpi/namespace/nseval.c
@@ -85,7 +85,7 @@ acpi_ns_evaluate_relative(char *pathname, struct acpi_parameter_info *info)
         union acpi_generic_state *scope_info;
         char *internal_path = NULL;
 
-        ACPI_FUNCTION_TRACE("ns_evaluate_relative");
+        ACPI_FUNCTION_TRACE(ns_evaluate_relative);
 
         /*
          * Must have a valid object handle
@@ -182,7 +182,7 @@ acpi_ns_evaluate_by_name(char *pathname, struct acpi_parameter_info *info)
         acpi_status status;
         char *internal_path = NULL;
 
-        ACPI_FUNCTION_TRACE("ns_evaluate_by_name");
+        ACPI_FUNCTION_TRACE(ns_evaluate_by_name);
 
         /* Build an internal name string for the method */
 
@@ -262,7 +262,7 @@ acpi_status acpi_ns_evaluate_by_handle(struct acpi_parameter_info *info)
 {
         acpi_status status;
 
-        ACPI_FUNCTION_TRACE("ns_evaluate_by_handle");
+        ACPI_FUNCTION_TRACE(ns_evaluate_by_handle);
 
         /* Check if namespace has been initialized */
 
@@ -368,7 +368,7 @@ acpi_ns_execute_control_method(struct acpi_parameter_info *info)
 {
         acpi_status status;
 
-        ACPI_FUNCTION_TRACE("ns_execute_control_method");
+        ACPI_FUNCTION_TRACE(ns_execute_control_method);
 
         /* Verify that there is a method associated with this object */
 
@@ -436,7 +436,7 @@ static acpi_status acpi_ns_get_object_value(struct acpi_parameter_info *info)
         acpi_status status = AE_OK;
         struct acpi_namespace_node *resolved_node = info->node;
 
-        ACPI_FUNCTION_TRACE("ns_get_object_value");
+        ACPI_FUNCTION_TRACE(ns_get_object_value);
 
         /*
          * Objects require additional resolution steps (e.g., the Node may be a
diff --git a/drivers/acpi/namespace/nsinit.c b/drivers/acpi/namespace/nsinit.c
index 57b2537643c7..bf1d8dbc0b86 100644
--- a/drivers/acpi/namespace/nsinit.c
+++ b/drivers/acpi/namespace/nsinit.c
@@ -58,6 +58,10 @@ static acpi_status
 acpi_ns_init_one_device(acpi_handle obj_handle,
                         u32 nesting_level, void *context, void **return_value);
 
+static acpi_status
+acpi_ns_find_ini_methods(acpi_handle obj_handle,
+                         u32 nesting_level, void *context, void **return_value);
+
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ns_initialize_objects
@@ -76,7 +80,7 @@ acpi_status acpi_ns_initialize_objects(void)
         acpi_status status;
         struct acpi_init_walk_info info;
 
-        ACPI_FUNCTION_TRACE("ns_initialize_objects");
+        ACPI_FUNCTION_TRACE(ns_initialize_objects);
 
         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
                           "**** Starting initialization of namespace objects ****\n"));
@@ -93,7 +97,7 @@ acpi_status acpi_ns_initialize_objects(void)
                                      ACPI_UINT32_MAX, acpi_ns_init_one_object,
                                      &info, NULL);
         if (ACPI_FAILURE(status)) {
-                ACPI_EXCEPTION((AE_INFO, status, "During walk_namespace"));
+                ACPI_EXCEPTION((AE_INFO, status, "During WalkNamespace"));
         }
 
         ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT,
@@ -133,7 +137,7 @@ acpi_status acpi_ns_initialize_devices(void)
         acpi_status status;
         struct acpi_device_walk_info info;
 
-        ACPI_FUNCTION_TRACE("ns_initialize_devices");
+        ACPI_FUNCTION_TRACE(ns_initialize_devices);
 
         /* Init counters */
 
@@ -142,28 +146,29 @@ acpi_status acpi_ns_initialize_devices(void)
         info.num_INI = 0;
 
         ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT,
-                              "Executing all Device _STA and_INI methods:"));
+                              "Initializing Device/Processor/Thermal objects by executing _INI methods:"));
+
+        /* Tree analysis: find all subtrees that contain _INI methods */
 
-        status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
+        status = acpi_ns_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
+                                        ACPI_UINT32_MAX, FALSE,
+                                        acpi_ns_find_ini_methods, &info, NULL);
         if (ACPI_FAILURE(status)) {
-                return_ACPI_STATUS(status);
+                ACPI_EXCEPTION((AE_INFO, status, "During WalkNamespace"));
         }
 
-        /* Walk namespace for all objects */
+        /* Walk namespace to execute all _INIs on present devices */
 
         status = acpi_ns_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
-                                        ACPI_UINT32_MAX, TRUE,
+                                        ACPI_UINT32_MAX, FALSE,
                                         acpi_ns_init_one_device, &info, NULL);
-
-        (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
-
         if (ACPI_FAILURE(status)) {
-                ACPI_EXCEPTION((AE_INFO, status, "During walk_namespace"));
+                ACPI_EXCEPTION((AE_INFO, status, "During WalkNamespace"));
         }
 
         ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT,
-                              "\n%hd Devices found - executed %hd _STA, %hd _INI methods\n",
-                              info.device_count, info.num_STA, info.num_INI));
+                              "\nExecuted %hd _INI methods requiring %hd _STA executions (examined %hd objects)\n",
+                              info.num_INI, info.num_STA, info.device_count));
 
         return_ACPI_STATUS(status);
 }
@@ -200,7 +205,7 @@ acpi_ns_init_one_object(acpi_handle obj_handle,
             (struct acpi_namespace_node *)obj_handle;
         union acpi_operand_object *obj_desc;
 
-        ACPI_FUNCTION_NAME("ns_init_one_object");
+        ACPI_FUNCTION_NAME(ns_init_one_object);
 
         info->object_count++;
 
@@ -311,6 +316,72 @@ acpi_ns_init_one_object(acpi_handle obj_handle,
 
 /*******************************************************************************
  *
+ * FUNCTION:    acpi_ns_find_ini_methods
+ *
+ * PARAMETERS:  acpi_walk_callback
+ *
+ * RETURN:      acpi_status
+ *
+ * DESCRIPTION: Called during namespace walk. Finds objects named _INI under
+ *              device/processor/thermal objects, and marks the entire subtree
+ *              with a SUBTREE_HAS_INI flag. This flag is used during the
+ *              subsequent device initialization walk to avoid entire subtrees
+ *              that do not contain an _INI.
+ *
+ ******************************************************************************/
+
+static acpi_status
+acpi_ns_find_ini_methods(acpi_handle obj_handle,
+                         u32 nesting_level, void *context, void **return_value)
+{
+        struct acpi_device_walk_info *info =
+            ACPI_CAST_PTR(struct acpi_device_walk_info, context);
+        struct acpi_namespace_node *node;
+        struct acpi_namespace_node *parent_node;
+
+        /* Keep count of device/processor/thermal objects */
+
+        node = ACPI_CAST_PTR(struct acpi_namespace_node, obj_handle);
+        if ((node->type == ACPI_TYPE_DEVICE) ||
+            (node->type == ACPI_TYPE_PROCESSOR) ||
+            (node->type == ACPI_TYPE_THERMAL)) {
+                info->device_count++;
+                return (AE_OK);
+        }
+
+        /* We are only looking for methods named _INI */
+
+        if (!ACPI_COMPARE_NAME(node->name.ascii, METHOD_NAME__INI)) {
+                return (AE_OK);
+        }
+
+        /*
+         * The only _INI methods that we care about are those that are
+         * present under Device, Processor, and Thermal objects.
+         */
+        parent_node = acpi_ns_get_parent_node(node);
+        switch (parent_node->type) {
+        case ACPI_TYPE_DEVICE:
+        case ACPI_TYPE_PROCESSOR:
+        case ACPI_TYPE_THERMAL:
+
+                /* Mark parent and bubble up the INI present flag to the root */
+
+                while (parent_node) {
+                        parent_node->flags |= ANOBJ_SUBTREE_HAS_INI;
+                        parent_node = acpi_ns_get_parent_node(parent_node);
+                }
+                break;
+
+        default:
+                break;
+        }
+
+        return (AE_OK);
+}
+
+/*******************************************************************************
+ *
  * FUNCTION:    acpi_ns_init_one_device
  *
  * PARAMETERS:  acpi_walk_callback
@@ -328,64 +399,49 @@ acpi_ns_init_one_device(acpi_handle obj_handle,
                         u32 nesting_level, void *context, void **return_value)
 {
         struct acpi_device_walk_info *info =
-            (struct acpi_device_walk_info *)context;
+            ACPI_CAST_PTR(struct acpi_device_walk_info, context);
         struct acpi_parameter_info pinfo;
         u32 flags;
         acpi_status status;
-        struct acpi_namespace_node *ini_node;
         struct acpi_namespace_node *device_node;
 
-        ACPI_FUNCTION_TRACE("ns_init_one_device");
+        ACPI_FUNCTION_TRACE(ns_init_one_device);
 
-        device_node = acpi_ns_map_handle_to_node(obj_handle);
-        if (!device_node) {
-                return_ACPI_STATUS(AE_BAD_PARAMETER);
-        }
+        /* We are interested in Devices, Processors and thermal_zones only */
 
-        /*
-         * We will run _STA/_INI on Devices, Processors and thermal_zones only
-         */
+        device_node = ACPI_CAST_PTR(struct acpi_namespace_node, obj_handle);
         if ((device_node->type != ACPI_TYPE_DEVICE) &&
             (device_node->type != ACPI_TYPE_PROCESSOR) &&
             (device_node->type != ACPI_TYPE_THERMAL)) {
                 return_ACPI_STATUS(AE_OK);
         }
 
-        if ((acpi_dbg_level <= ACPI_LV_ALL_EXCEPTIONS) &&
-            (!(acpi_dbg_level & ACPI_LV_INFO))) {
-                ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT, "."));
-        }
-
-        info->device_count++;
-
         /*
-         * Check if the _INI method exists for this device -
-         * if _INI does not exist, there is no need to run _STA
-         * No _INI means device requires no initialization
+         * Because of an earlier namespace analysis, all subtrees that contain an
+         * _INI method are tagged.
+         *
+         * If this device subtree does not contain any _INI methods, we
+         * can exit now and stop traversing this entire subtree.
          */
-        status = acpi_ns_search_node(*ACPI_CAST_PTR(u32, METHOD_NAME__INI),
-                                     device_node, ACPI_TYPE_METHOD, &ini_node);
-        if (ACPI_FAILURE(status)) {
-
-                /* No _INI method found - move on to next device */
-
-                return_ACPI_STATUS(AE_OK);
+        if (!(device_node->flags & ANOBJ_SUBTREE_HAS_INI)) {
+                return_ACPI_STATUS(AE_CTRL_DEPTH);
         }
 
         /*
-         * Run _STA to determine if we can run _INI on the device -
-         * the device must be present before _INI can be run.
-         * However, _STA is not required - assume device present if no _STA
+         * Run _STA to determine if this device is present and functioning. We
+         * must know this information for two important reasons (from ACPI spec):
+         *
+         * 1) We can only run _INI if the device is present.
+         * 2) We must abort the device tree walk on this subtree if the device is
+         *    not present and is not functional (we will not examine the children)
+         *
+         * The _STA method is not required to be present under the device, we
+         * assume the device is present if _STA does not exist.
          */
-        ACPI_DEBUG_EXEC(acpi_ut_display_init_pathname(ACPI_TYPE_METHOD,
-                                                      device_node,
-                                                      METHOD_NAME__STA));
+        ACPI_DEBUG_EXEC(acpi_ut_display_init_pathname
+                        (ACPI_TYPE_METHOD, device_node, METHOD_NAME__STA));
 
-        pinfo.node = device_node;
-        pinfo.parameters = NULL;
-        pinfo.parameter_type = ACPI_PARAM_ARGS;
-
-        status = acpi_ut_execute_STA(pinfo.node, &flags);
+        status = acpi_ut_execute_STA(device_node, &flags);
         if (ACPI_FAILURE(status)) {
 
                 /* Ignore error and move on to next device */
@@ -393,55 +449,108 @@ acpi_ns_init_one_device(acpi_handle obj_handle,
                 return_ACPI_STATUS(AE_OK);
         }
 
+        /*
+         * Flags == -1 means that _STA was not found. In this case, we assume that
+         * the device is both present and functional.
+         *
+         * From the ACPI spec, description of _STA:
+         *
+         * "If a device object (including the processor object) does not have an
+         * _STA object, then OSPM assumes that all of the above bits are set (in
+         * other words, the device is present, ..., and functioning)"
+         */
         if (flags != ACPI_UINT32_MAX) {
                 info->num_STA++;
         }
 
+        /*
+         * Examine the PRESENT and FUNCTIONING status bits
+         *
+         * Note: ACPI spec does not seem to specify behavior for the present but
+         * not functioning case, so we assume functioning if present.
+         */
         if (!(flags & ACPI_STA_DEVICE_PRESENT)) {
 
-                /* Don't look at children of a not present device */
-
-                return_ACPI_STATUS(AE_CTRL_DEPTH);
+                /* Device is not present, we must examine the Functioning bit */
+
+                if (flags & ACPI_STA_DEVICE_FUNCTIONING) {
+                        /*
+                         * Device is not present but is "functioning". In this case,
+                         * we will not run _INI, but we continue to examine the children
+                         * of this device.
+                         *
+                         * From the ACPI spec, description of _STA: (Note - no mention
+                         * of whether to run _INI or not on the device in question)
+                         *
+                         * "_STA may return bit 0 clear (not present) with bit 3 set
+                         * (device is functional). This case is used to indicate a valid
+                         * device for which no device driver should be loaded (for example,
+                         * a bridge device.) Children of this device may be present and
+                         * valid. OSPM should continue enumeration below a device whose
+                         * _STA returns this bit combination"
+                         */
+                        return_ACPI_STATUS(AE_OK);
+                } else {
+                        /*
+                         * Device is not present and is not functioning. We must abort the
+                         * walk of this subtree immediately -- don't look at the children
+                         * of such a device.
+                         *
+                         * From the ACPI spec, description of _INI:
+                         *
+                         * "If the _STA method indicates that the device is not present,
+                         * OSPM will not run the _INI and will not examine the children
+                         * of the device for _INI methods"
+                         */
+                        return_ACPI_STATUS(AE_CTRL_DEPTH);
+                }
         }
 
         /*
-         * The device is present and _INI exists. Run the _INI method.
-         * (We already have the _INI node from above)
+         * The device is present or is assumed present if no _STA exists.
+         * Run the _INI if it exists (not required to exist)
+         *
+         * Note: We know there is an _INI within this subtree, but it may not be
+         * under this particular device, it may be lower in the branch.
          */
-        ACPI_DEBUG_EXEC(acpi_ut_display_init_pathname(ACPI_TYPE_METHOD,
-                                                      pinfo.node,
-                                                      METHOD_NAME__INI));
+        ACPI_DEBUG_EXEC(acpi_ut_display_init_pathname
+                        (ACPI_TYPE_METHOD, device_node, METHOD_NAME__INI));
 
-        pinfo.node = ini_node;
-        status = acpi_ns_evaluate_by_handle(&pinfo);
-        if (ACPI_FAILURE(status)) {
-
-                /* Ignore error and move on to next device */
-
-#ifdef ACPI_DEBUG_OUTPUT
-                char *scope_name = acpi_ns_get_external_pathname(ini_node);
+        pinfo.node = device_node;
+        pinfo.parameters = NULL;
+        pinfo.parameter_type = ACPI_PARAM_ARGS;
 
-                ACPI_WARNING((AE_INFO, "%s._INI failed: %s",
-                              scope_name, acpi_format_exception(status)));
+        status = acpi_ns_evaluate_relative(METHOD_NAME__INI, &pinfo);
+        if (ACPI_SUCCESS(status)) {
 
-                ACPI_FREE(scope_name);
-#endif
-        } else {
                 /* Delete any return object (especially if implicit_return is enabled) */
 
                 if (pinfo.return_object) {
                         acpi_ut_remove_reference(pinfo.return_object);
                 }
 
-                /* Count of successful INIs */
-
                 info->num_INI++;
+                if ((acpi_dbg_level <= ACPI_LV_ALL_EXCEPTIONS) &&
+                    (!(acpi_dbg_level & ACPI_LV_INFO))) {
+                        ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT, "."));
+                }
         }
+#ifdef ACPI_DEBUG_OUTPUT
+        else if (status != AE_NOT_FOUND) {
 
-        if (acpi_gbl_init_handler) {
+                /* Ignore error and move on to next device */
+
+                char *scope_name = acpi_ns_get_external_pathname(pinfo.node);
 
-                /* External initialization handler is present, call it */
+                ACPI_EXCEPTION((AE_INFO, status, "during %s._INI execution",
+                                scope_name));
+                ACPI_FREE(scope_name);
+        }
+#endif
 
+        /* If an external initialization handler is present, call it */
+
+        if (acpi_gbl_init_handler) {
                 status =
                     acpi_gbl_init_handler(pinfo.node, ACPI_INIT_DEVICE_INI);
         }
diff --git a/drivers/acpi/namespace/nsload.c b/drivers/acpi/namespace/nsload.c
index 80acfd35f3ec..fe75d888e183 100644
--- a/drivers/acpi/namespace/nsload.c
+++ b/drivers/acpi/namespace/nsload.c
@@ -77,7 +77,7 @@ acpi_ns_load_table(struct acpi_table_desc *table_desc,
 {
         acpi_status status;
 
-        ACPI_FUNCTION_TRACE("ns_load_table");
+        ACPI_FUNCTION_TRACE(ns_load_table);
 
         /* Check if table contains valid AML (must be DSDT, PSDT, SSDT, etc.) */
 
@@ -169,7 +169,7 @@ static acpi_status acpi_ns_load_table_by_type(acpi_table_type table_type)
         acpi_status status;
         struct acpi_table_desc *table_desc;
 
-        ACPI_FUNCTION_TRACE("ns_load_table_by_type");
+        ACPI_FUNCTION_TRACE(ns_load_table_by_type);
 
         status = acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
         if (ACPI_FAILURE(status)) {
@@ -181,11 +181,11 @@ static acpi_status acpi_ns_load_table_by_type(acpi_table_type table_type)
          * DSDT (one), SSDT/PSDT (multiple)
          */
         switch (table_type) {
-        case ACPI_TABLE_DSDT:
+        case ACPI_TABLE_ID_DSDT:
 
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Namespace load: DSDT\n"));
 
-                table_desc = acpi_gbl_table_lists[ACPI_TABLE_DSDT].next;
+                table_desc = acpi_gbl_table_lists[ACPI_TABLE_ID_DSDT].next;
 
                 /* If table already loaded into namespace, just return */
 
@@ -201,8 +201,8 @@ static acpi_status acpi_ns_load_table_by_type(acpi_table_type table_type)
                 }
                 break;
 
-        case ACPI_TABLE_SSDT:
-        case ACPI_TABLE_PSDT:
+        case ACPI_TABLE_ID_SSDT:
+        case ACPI_TABLE_ID_PSDT:
 
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                                   "Namespace load: %d SSDT or PSDTs\n",
@@ -259,7 +259,7 @@ acpi_status acpi_ns_load_namespace(void)
 {
         acpi_status status;
 
-        ACPI_FUNCTION_TRACE("acpi_load_name_space");
+        ACPI_FUNCTION_TRACE(acpi_load_name_space);
 
         /* There must be at least a DSDT installed */
 
@@ -272,15 +272,15 @@ acpi_status acpi_ns_load_namespace(void)
          * Load the namespace.  The DSDT is required,
          * but the SSDT and PSDT tables are optional.
          */
-        status = acpi_ns_load_table_by_type(ACPI_TABLE_DSDT);
+        status = acpi_ns_load_table_by_type(ACPI_TABLE_ID_DSDT);
         if (ACPI_FAILURE(status)) {
                 return_ACPI_STATUS(status);
         }
 
         /* Ignore exceptions from these */
 
-        (void)acpi_ns_load_table_by_type(ACPI_TABLE_SSDT);
-        (void)acpi_ns_load_table_by_type(ACPI_TABLE_PSDT);
+        (void)acpi_ns_load_table_by_type(ACPI_TABLE_ID_SSDT);
+        (void)acpi_ns_load_table_by_type(ACPI_TABLE_ID_PSDT);
 
         ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT,
                               "ACPI Namespace successfully loaded at root %p\n",
@@ -315,7 +315,7 @@ static acpi_status acpi_ns_delete_subtree(acpi_handle start_handle)
         acpi_handle dummy;
         u32 level;
 
-        ACPI_FUNCTION_TRACE("ns_delete_subtree");
+        ACPI_FUNCTION_TRACE(ns_delete_subtree);
 
         parent_handle = start_handle;
         child_handle = NULL;
@@ -395,7 +395,7 @@ acpi_status acpi_ns_unload_namespace(acpi_handle handle)
 {
         acpi_status status;
 
-        ACPI_FUNCTION_TRACE("ns_unload_name_space");
+        ACPI_FUNCTION_TRACE(ns_unload_name_space);
 
         /* Parameter validation */
 
diff --git a/drivers/acpi/namespace/nsnames.c b/drivers/acpi/namespace/nsnames.c
index ba812f43897f..97b8332c9746 100644
--- a/drivers/acpi/namespace/nsnames.c
+++ b/drivers/acpi/namespace/nsnames.c
@@ -132,7 +132,7 @@ char *acpi_ns_get_external_pathname(struct acpi_namespace_node *node)
         char *name_buffer;
         acpi_size size;
 
-        ACPI_FUNCTION_TRACE_PTR("ns_get_external_pathname", node);
+        ACPI_FUNCTION_TRACE_PTR(ns_get_external_pathname, node);
 
         /* Calculate required buffer size based on depth below root */
 
@@ -213,7 +213,7 @@ acpi_ns_handle_to_pathname(acpi_handle target_handle,
         struct acpi_namespace_node *node;
         acpi_size required_size;
 
-        ACPI_FUNCTION_TRACE_PTR("ns_handle_to_pathname", target_handle);
+        ACPI_FUNCTION_TRACE_PTR(ns_handle_to_pathname, target_handle);
 
         node = acpi_ns_map_handle_to_node(target_handle);
         if (!node) {
diff --git a/drivers/acpi/namespace/nsobject.c b/drivers/acpi/namespace/nsobject.c
index 39dc87b228fc..aabe8794b908 100644
--- a/drivers/acpi/namespace/nsobject.c
+++ b/drivers/acpi/namespace/nsobject.c
@@ -76,7 +76,7 @@ acpi_ns_attach_object(struct acpi_namespace_node *node,
         union acpi_operand_object *last_obj_desc;
         acpi_object_type object_type = ACPI_TYPE_ANY;
 
-        ACPI_FUNCTION_TRACE("ns_attach_object");
+        ACPI_FUNCTION_TRACE(ns_attach_object);
 
         /*
          * Parameter validation
@@ -85,7 +85,7 @@ acpi_ns_attach_object(struct acpi_namespace_node *node,
 
                 /* Invalid handle */
 
-                ACPI_ERROR((AE_INFO, "Null named_obj handle"));
+                ACPI_ERROR((AE_INFO, "Null NamedObj handle"));
                 return_ACPI_STATUS(AE_BAD_PARAMETER);
         }
 
@@ -111,7 +111,7 @@ acpi_ns_attach_object(struct acpi_namespace_node *node,
 
         if (node->object == object) {
                 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
-                                  "Obj %p already installed in name_obj %p\n",
+                                  "Obj %p already installed in NameObj %p\n",
                                   object, node));
 
                 return_ACPI_STATUS(AE_OK);
@@ -204,7 +204,7 @@ void acpi_ns_detach_object(struct acpi_namespace_node *node)
 {
         union acpi_operand_object *obj_desc;
 
-        ACPI_FUNCTION_TRACE("ns_detach_object");
+        ACPI_FUNCTION_TRACE(ns_detach_object);
 
         obj_desc = node->object;
 
@@ -255,7 +255,7 @@ union acpi_operand_object *acpi_ns_get_attached_object(struct
                                                        acpi_namespace_node
                                                        *node)
 {
-        ACPI_FUNCTION_TRACE_PTR("ns_get_attached_object", node);
+        ACPI_FUNCTION_TRACE_PTR(ns_get_attached_object, node);
 
         if (!node) {
                 ACPI_WARNING((AE_INFO, "Null Node ptr"));
@@ -290,7 +290,7 @@ union acpi_operand_object *acpi_ns_get_secondary_object(union
                                                         acpi_operand_object
                                                         *obj_desc)
 {
-        ACPI_FUNCTION_TRACE_PTR("ns_get_secondary_object", obj_desc);
+        ACPI_FUNCTION_TRACE_PTR(ns_get_secondary_object, obj_desc);
 
         if ((!obj_desc) ||
             (ACPI_GET_OBJECT_TYPE(obj_desc) == ACPI_TYPE_LOCAL_DATA) ||
diff --git a/drivers/acpi/namespace/nsparse.c b/drivers/acpi/namespace/nsparse.c
index 64daf3028dea..155505a4ef69 100644
--- a/drivers/acpi/namespace/nsparse.c
+++ b/drivers/acpi/namespace/nsparse.c
@@ -68,7 +68,7 @@ acpi_ns_one_complete_parse(u8 pass_number, struct acpi_table_desc *table_desc)
         acpi_status status;
         struct acpi_walk_state *walk_state;
 
-        ACPI_FUNCTION_TRACE("ns_one_complete_parse");
+        ACPI_FUNCTION_TRACE(ns_one_complete_parse);
 
         /* Create and init a Root Node */
 
@@ -124,7 +124,7 @@ acpi_ns_parse_table(struct acpi_table_desc *table_desc,
 {
         acpi_status status;
 
-        ACPI_FUNCTION_TRACE("ns_parse_table");
+        ACPI_FUNCTION_TRACE(ns_parse_table);
 
         /*
          * AML Parse, pass 1
diff --git a/drivers/acpi/namespace/nssearch.c b/drivers/acpi/namespace/nssearch.c
index 51adec5a23d6..34ac512a2d5e 100644
--- a/drivers/acpi/namespace/nssearch.c
+++ b/drivers/acpi/namespace/nssearch.c
@@ -89,7 +89,7 @@ acpi_ns_search_node(u32 target_name,
 {
         struct acpi_namespace_node *next_node;
 
-        ACPI_FUNCTION_TRACE("ns_search_node");
+        ACPI_FUNCTION_TRACE(ns_search_node);
 
 #ifdef ACPI_DEBUG_OUTPUT
         if (ACPI_LV_NAMES & acpi_dbg_level) {
@@ -203,7 +203,7 @@ acpi_ns_search_parent_tree(u32 target_name,
         acpi_status status;
         struct acpi_namespace_node *parent_node;
 
-        ACPI_FUNCTION_TRACE("ns_search_parent_tree");
+        ACPI_FUNCTION_TRACE(ns_search_parent_tree);
 
         parent_node = acpi_ns_get_parent_node(node);
 
@@ -293,13 +293,13 @@ acpi_ns_search_and_enter(u32 target_name,
         acpi_status status;
         struct acpi_namespace_node *new_node;
 
-        ACPI_FUNCTION_TRACE("ns_search_and_enter");
+        ACPI_FUNCTION_TRACE(ns_search_and_enter);
 
         /* Parameter validation */
 
         if (!node || !target_name || !return_node) {
                 ACPI_ERROR((AE_INFO,
-                            "Null param: Node %p Name %X return_node %p",
+                            "Null param: Node %p Name %X ReturnNode %p",
                             node, target_name, return_node));
                 return_ACPI_STATUS(AE_BAD_PARAMETER);
         }
diff --git a/drivers/acpi/namespace/nsutils.c b/drivers/acpi/namespace/nsutils.c
index 9fa38ffc2e6e..d1d55032b455 100644
--- a/drivers/acpi/namespace/nsutils.c
+++ b/drivers/acpi/namespace/nsutils.c
@@ -241,7 +241,7 @@ static u8 acpi_ns_valid_path_separator(char sep)
 
 acpi_object_type acpi_ns_get_type(struct acpi_namespace_node * node)
 {
-        ACPI_FUNCTION_TRACE("ns_get_type");
+        ACPI_FUNCTION_TRACE(ns_get_type);
 
         if (!node) {
                 ACPI_WARNING((AE_INFO, "Null Node parameter"));
@@ -266,7 +266,7 @@ acpi_object_type acpi_ns_get_type(struct acpi_namespace_node * node)
 
 u32 acpi_ns_local(acpi_object_type type)
 {
-        ACPI_FUNCTION_TRACE("ns_local");
+        ACPI_FUNCTION_TRACE(ns_local);
 
         if (!acpi_ut_valid_object_type(type)) {
 
@@ -366,7 +366,7 @@ acpi_status acpi_ns_build_internal_name(struct acpi_namestring_info *info)
         char *result = NULL;
         acpi_native_uint i;
 
-        ACPI_FUNCTION_TRACE("ns_build_internal_name");
+        ACPI_FUNCTION_TRACE(ns_build_internal_name);
 
         /* Setup the correct prefixes, counts, and pointers */
 
@@ -477,7 +477,7 @@ acpi_status acpi_ns_internalize_name(char *external_name, char **converted_name)
         struct acpi_namestring_info info;
         acpi_status status;
 
-        ACPI_FUNCTION_TRACE("ns_internalize_name");
+        ACPI_FUNCTION_TRACE(ns_internalize_name);
 
         if ((!external_name) || (*external_name == 0) || (!converted_name)) {
                 return_ACPI_STATUS(AE_BAD_PARAMETER);
@@ -537,7 +537,7 @@ acpi_ns_externalize_name(u32 internal_name_length,
         acpi_native_uint i = 0;
         acpi_native_uint j = 0;
 
-        ACPI_FUNCTION_TRACE("ns_externalize_name");
+        ACPI_FUNCTION_TRACE(ns_externalize_name);
 
         if (!internal_name_length || !internal_name || !converted_name) {
                 return_ACPI_STATUS(AE_BAD_PARAMETER);
@@ -756,7 +756,7 @@ void acpi_ns_terminate(void)
 {
         union acpi_operand_object *obj_desc;
 
-        ACPI_FUNCTION_TRACE("ns_terminate");
+        ACPI_FUNCTION_TRACE(ns_terminate);
 
         /*
          * 1) Free the entire namespace -- all nodes and objects
@@ -796,7 +796,7 @@ void acpi_ns_terminate(void)
 
 u32 acpi_ns_opens_scope(acpi_object_type type)
 {
-        ACPI_FUNCTION_TRACE_STR("ns_opens_scope", acpi_ut_get_type_name(type));
+        ACPI_FUNCTION_TRACE_STR(ns_opens_scope, acpi_ut_get_type_name(type));
 
         if (!acpi_ut_valid_object_type(type)) {
 
@@ -840,7 +840,7 @@ acpi_ns_get_node_by_path(char *pathname,
         acpi_status status;
         char *internal_path = NULL;
 
-        ACPI_FUNCTION_TRACE_PTR("ns_get_node_by_path", pathname);
+        ACPI_FUNCTION_TRACE_PTR(ns_get_node_by_path, pathname);
 
         if (pathname) {
 
@@ -966,7 +966,7 @@ acpi_name acpi_ns_find_parent_name(struct acpi_namespace_node * child_node)
 {
         struct acpi_namespace_node *parent_node;
 
-        ACPI_FUNCTION_TRACE("ns_find_parent_name");
+        ACPI_FUNCTION_TRACE(ns_find_parent_name);
 
         if (child_node) {
 
diff --git a/drivers/acpi/namespace/nswalk.c b/drivers/acpi/namespace/nswalk.c
index 6bbc734bfee2..c8f6bef16ed0 100644
--- a/drivers/acpi/namespace/nswalk.c
+++ b/drivers/acpi/namespace/nswalk.c
@@ -164,7 +164,7 @@ acpi_ns_walk_namespace(acpi_object_type type,
         acpi_object_type child_type;
         u32 level;
 
-        ACPI_FUNCTION_TRACE("ns_walk_namespace");
+        ACPI_FUNCTION_TRACE(ns_walk_namespace);
 
         /* Special case for the namespace Root Node */
 
diff --git a/drivers/acpi/namespace/nsxfeval.c b/drivers/acpi/namespace/nsxfeval.c
index 7cdedc96a40a..998b29611b19 100644
--- a/drivers/acpi/namespace/nsxfeval.c
+++ b/drivers/acpi/namespace/nsxfeval.c
@@ -80,7 +80,7 @@ acpi_evaluate_object_typed(acpi_handle handle,
         acpi_status status;
         u8 must_free = FALSE;
 
-        ACPI_FUNCTION_TRACE("acpi_evaluate_object_typed");
+        ACPI_FUNCTION_TRACE(acpi_evaluate_object_typed);
 
         /* Return buffer must be valid */
 
@@ -175,7 +175,7 @@ acpi_evaluate_object(acpi_handle handle,
         acpi_size buffer_space_needed;
         u32 i;
 
-        ACPI_FUNCTION_TRACE("acpi_evaluate_object");
+        ACPI_FUNCTION_TRACE(acpi_evaluate_object);
 
         info.node = handle;
         info.parameters = NULL;
@@ -395,7 +395,7 @@ acpi_walk_namespace(acpi_object_type type,
 {
         acpi_status status;
 
-        ACPI_FUNCTION_TRACE("acpi_walk_namespace");
+        ACPI_FUNCTION_TRACE(acpi_walk_namespace);
 
         /* Parameter validation */
 
@@ -553,7 +553,7 @@ acpi_get_devices(char *HID,
         acpi_status status;
         struct acpi_get_devices_info info;
 
-        ACPI_FUNCTION_TRACE("acpi_get_devices");
+        ACPI_FUNCTION_TRACE(acpi_get_devices);
 
         /* Parameter validation */