ACPI: ACPICA 20060526

Restructured, flattened, and simplified the internal
interfaces for namespace object evaluation - resulting
in smaller code, less CPU stack use, and fewer
interfaces. (With assistance from Mikhail Kouzmich)

Fixed a problem with the CopyObject operator where the
first parameter was not typed correctly for the parser,
interpreter, compiler, and disassembler. Caused various
errors and unexpected behavior.

Fixed a problem where a ShiftLeft or ShiftRight of
more than 64 bits produced incorrect results with some
C compilers. Since the behavior of C compilers when
the shift value is larger than the datatype width is
apparently not well defined, the interpreter now detects
this condition and simply returns zero as expected in all
such cases. (BZ 395)

Fixed problem reports (Valery Podrezov) integrated: -
Update String-to-Integer conversion to match ACPI 3.0A spec
http://bugzilla.kernel.org/show_bug.cgi?id=5329
Allow interpreter to handle nested method declarations
http://bugzilla.kernel.org/show_bug.cgi?id=5361

Fixed problem reports (Fiodor Suietov) integrated: -
acpi_terminate() doesn't free debug memory allocation
list objects (BZ 355) - After Core Subsystem
shutdown, acpi_subsystem_status() returns AE_OK (BZ 356) -
acpi_os_unmap_memory() for RSDP can be invoked inconsistently
(BZ 357) - Resource Manager should return AE_TYPE for
non-device objects (BZ 358) - Incomplete cleanup branch
in AcpiNsEvaluateRelative (BZ 359) - Use acpi_os_free()
instead of ACPI_FREE in acpi_rs_set_srs_method_data (BZ 360)
- Incomplete cleanup branch in acpi_ps_parse_aml (BZ 361) -
Incomplete cleanup branch in acpi_ds_delete_walk_state (BZ 362)
- acpi_get_table_header returns AE_NO_ACPI_TABLES until DSDT
is loaded (BZ 365) - Status of the Global Initialization
Handler call not used (BZ 366) - Incorrect object parameter
to Global Initialization Handler (BZ 367)

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

2 files changed, 261 insertions, 202 deletions

diff --git a/drivers/acpi/resources/rsutils.c b/drivers/acpi/resources/rsutils.c
index 0e493f2fec4d..a9cbee8e8b44 100644
--- a/drivers/acpi/resources/rsutils.c
+++ b/drivers/acpi/resources/rsutils.c
@@ -442,7 +442,7 @@ acpi_rs_set_resource_source(union aml_resource * aml,
  *
  * FUNCTION:    acpi_rs_get_prt_method_data
  *
- * PARAMETERS:  Handle          - Handle to the containing object
+ * PARAMETERS:  Node            - Device node
  *              ret_buffer      - Pointer to a buffer structure for the
  *                                results
  *
@@ -457,7 +457,8 @@ acpi_rs_set_resource_source(union aml_resource * aml,
  ******************************************************************************/
 
 acpi_status
-acpi_rs_get_prt_method_data(acpi_handle handle, struct acpi_buffer * ret_buffer)
+acpi_rs_get_prt_method_data(struct acpi_namespace_node * node,
+                            struct acpi_buffer * ret_buffer)
 {
         union acpi_operand_object *obj_desc;
         acpi_status status;
@@ -468,7 +469,7 @@ acpi_rs_get_prt_method_data(acpi_handle handle, struct acpi_buffer * ret_buffer)
 
         /* Execute the method, no parameters */
 
-        status = acpi_ut_evaluate_object(handle, METHOD_NAME__PRT,
+        status = acpi_ut_evaluate_object(node, METHOD_NAME__PRT,
                                          ACPI_BTYPE_PACKAGE, &obj_desc);
         if (ACPI_FAILURE(status)) {
                 return_ACPI_STATUS(status);
@@ -490,7 +491,7 @@ acpi_rs_get_prt_method_data(acpi_handle handle, struct acpi_buffer * ret_buffer)
  *
  * FUNCTION:    acpi_rs_get_crs_method_data
  *
- * PARAMETERS:  Handle          - Handle to the containing object
+ * PARAMETERS:  Node            - Device node
  *              ret_buffer      - Pointer to a buffer structure for the
  *                                results
  *
@@ -505,7 +506,8 @@ acpi_rs_get_prt_method_data(acpi_handle handle, struct acpi_buffer * ret_buffer)
  ******************************************************************************/
 
 acpi_status
-acpi_rs_get_crs_method_data(acpi_handle handle, struct acpi_buffer *ret_buffer)
+acpi_rs_get_crs_method_data(struct acpi_namespace_node *node,
+                            struct acpi_buffer *ret_buffer)
 {
         union acpi_operand_object *obj_desc;
         acpi_status status;
@@ -516,7 +518,7 @@ acpi_rs_get_crs_method_data(acpi_handle handle, struct acpi_buffer *ret_buffer)
 
         /* Execute the method, no parameters */
 
-        status = acpi_ut_evaluate_object(handle, METHOD_NAME__CRS,
+        status = acpi_ut_evaluate_object(node, METHOD_NAME__CRS,
                                          ACPI_BTYPE_BUFFER, &obj_desc);
         if (ACPI_FAILURE(status)) {
                 return_ACPI_STATUS(status);
@@ -539,7 +541,7 @@ acpi_rs_get_crs_method_data(acpi_handle handle, struct acpi_buffer *ret_buffer)
  *
  * FUNCTION:    acpi_rs_get_prs_method_data
  *
- * PARAMETERS:  Handle          - Handle to the containing object
+ * PARAMETERS:  Node            - Device node
  *              ret_buffer      - Pointer to a buffer structure for the
  *                                results
  *
@@ -555,7 +557,8 @@ acpi_rs_get_crs_method_data(acpi_handle handle, struct acpi_buffer *ret_buffer)
 
 #ifdef ACPI_FUTURE_USAGE
 acpi_status
-acpi_rs_get_prs_method_data(acpi_handle handle, struct acpi_buffer *ret_buffer)
+acpi_rs_get_prs_method_data(struct acpi_namespace_node *node,
+                            struct acpi_buffer *ret_buffer)
 {
         union acpi_operand_object *obj_desc;
         acpi_status status;
@@ -566,7 +569,7 @@ acpi_rs_get_prs_method_data(acpi_handle handle, struct acpi_buffer *ret_buffer)
 
         /* Execute the method, no parameters */
 
-        status = acpi_ut_evaluate_object(handle, METHOD_NAME__PRS,
+        status = acpi_ut_evaluate_object(node, METHOD_NAME__PRS,
                                          ACPI_BTYPE_BUFFER, &obj_desc);
         if (ACPI_FAILURE(status)) {
                 return_ACPI_STATUS(status);
@@ -641,7 +644,7 @@ acpi_rs_get_method_data(acpi_handle handle,
  *
  * FUNCTION:    acpi_rs_set_srs_method_data
  *
- * PARAMETERS:  Handle          - Handle to the containing object
+ * PARAMETERS:  Node            - Device node
  *              in_buffer       - Pointer to a buffer structure of the
  *                                parameter
  *
@@ -653,23 +656,37 @@ acpi_rs_get_method_data(acpi_handle handle,
  *              If the function fails an appropriate status will be returned
  *              and the contents of the callers buffer is undefined.
  *
+ * Note: Parameters guaranteed valid by caller
+ *
  ******************************************************************************/
 
 acpi_status
-acpi_rs_set_srs_method_data(acpi_handle handle, struct acpi_buffer *in_buffer)
+acpi_rs_set_srs_method_data(struct acpi_namespace_node *node,
+                            struct acpi_buffer *in_buffer)
 {
-        struct acpi_parameter_info info;
-        union acpi_operand_object *params[2];
+        struct acpi_evaluate_info *info;
+        union acpi_operand_object *args[2];
         acpi_status status;
         struct acpi_buffer buffer;
 
         ACPI_FUNCTION_TRACE(rs_set_srs_method_data);
 
-        /* Parameters guaranteed valid by caller */
+        /* Allocate and initialize the evaluation information block */
+
+        info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info));
+        if (!info) {
+                return_ACPI_STATUS(AE_NO_MEMORY);
+        }
+
+        info->prefix_node = node;
+        info->pathname = METHOD_NAME__SRS;
+        info->parameters = args;
+        info->parameter_type = ACPI_PARAM_ARGS;
+        info->flags = ACPI_IGNORE_RETURN_VALUE;
 
         /*
          * The in_buffer parameter will point to a linked list of
-         * resource parameters.  It needs to be formatted into a
+         * resource parameters. It needs to be formatted into a
          * byte stream to be sent in as an input parameter to _SRS
          *
          * Convert the linked list into a byte stream
@@ -677,42 +694,36 @@ acpi_rs_set_srs_method_data(acpi_handle handle, struct acpi_buffer *in_buffer)
         buffer.length = ACPI_ALLOCATE_LOCAL_BUFFER;
         status = acpi_rs_create_aml_resources(in_buffer->pointer, &buffer);
         if (ACPI_FAILURE(status)) {
-                return_ACPI_STATUS(status);
+                goto cleanup;
         }
 
-        /* Init the param object */
+        /* Create and initialize the method parameter object */
 
-        params[0] = acpi_ut_create_internal_object(ACPI_TYPE_BUFFER);
-        if (!params[0]) {
-                acpi_os_free(buffer.pointer);
-                return_ACPI_STATUS(AE_NO_MEMORY);
+        args[0] = acpi_ut_create_internal_object(ACPI_TYPE_BUFFER);
+        if (!args[0]) {
+                /*
+                 * Must free the buffer allocated above (otherwise it is freed
+                 * later)
+                 */
+                ACPI_FREE(buffer.pointer);
+                status = AE_NO_MEMORY;
+                goto cleanup;
         }
 
-        /* Set up the parameter object */
-
-        params[0]->buffer.length = (u32) buffer.length;
-        params[0]->buffer.pointer = buffer.pointer;
-        params[0]->common.flags = AOPOBJ_DATA_VALID;
-        params[1] = NULL;
+        args[0]->buffer.length = (u32) buffer.length;
+        args[0]->buffer.pointer = buffer.pointer;
+        args[0]->common.flags = AOPOBJ_DATA_VALID;
+        args[1] = NULL;
 
-        info.node = handle;
-        info.parameters = params;
-        info.parameter_type = ACPI_PARAM_ARGS;
+        /* Execute the method, no return value is expected */
 
-        /* Execute the method, no return value */
+        status = acpi_ns_evaluate(info);
 
-        status = acpi_ns_evaluate_relative(METHOD_NAME__SRS, &info);
-        if (ACPI_SUCCESS(status)) {
-
-                /* Delete any return object (especially if implicit_return is enabled) */
-
-                if (info.return_object) {
-                        acpi_ut_remove_reference(info.return_object);
-                }
-        }
+        /* Clean up and return the status from acpi_ns_evaluate */
 
-        /* Clean up and return the status from acpi_ns_evaluate_relative */
+        acpi_ut_remove_reference(args[0]);
 
-        acpi_ut_remove_reference(params[0]);
+      cleanup:
+        ACPI_FREE(info);
         return_ACPI_STATUS(status);
 }
diff --git a/drivers/acpi/resources/rsxface.c b/drivers/acpi/resources/rsxface.c
index 8c1628c12cc8..1999e2ab7daa 100644
--- a/drivers/acpi/resources/rsxface.c
+++ b/drivers/acpi/resources/rsxface.c
@@ -43,6 +43,7 @@
 
 #include <acpi/acpi.h>
 #include <acpi/acresrc.h>
+#include <acpi/acnamesp.h>
 
 #define _COMPONENT          ACPI_RESOURCES
 ACPI_MODULE_NAME("rsxface")
@@ -66,19 +67,80 @@ ACPI_MODULE_NAME("rsxface")
 static acpi_status
 acpi_rs_match_vendor_resource(struct acpi_resource *resource, void *context);
 
+static acpi_status
+acpi_rs_validate_parameters(acpi_handle device_handle,
+                            struct acpi_buffer *buffer,
+                            struct acpi_namespace_node **return_node);
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_rs_validate_parameters
+ *
+ * PARAMETERS:  device_handle   - Handle to a device
+ *              Buffer          - Pointer to a data buffer
+ *              return_node     - Pointer to where the device node is returned
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Common parameter validation for resource interfaces
+ *
+ ******************************************************************************/
+
+static acpi_status
+acpi_rs_validate_parameters(acpi_handle device_handle,
+                            struct acpi_buffer *buffer,
+                            struct acpi_namespace_node **return_node)
+{
+        acpi_status status;
+        struct acpi_namespace_node *node;
+
+        ACPI_FUNCTION_TRACE(rs_validate_parameters);
+
+        /*
+         * Must have a valid handle to an ACPI device
+         */
+        if (!device_handle) {
+                return_ACPI_STATUS(AE_BAD_PARAMETER);
+        }
+
+        node = acpi_ns_map_handle_to_node(device_handle);
+        if (!node) {
+                return_ACPI_STATUS(AE_BAD_PARAMETER);
+        }
+
+        if (node->type != ACPI_TYPE_DEVICE) {
+                return_ACPI_STATUS(AE_TYPE);
+        }
+
+        /*
+         * Validate the user buffer object
+         *
+         * if there is a non-zero buffer length we also need a valid pointer in
+         * the buffer. If it's a zero buffer length, we'll be returning the
+         * needed buffer size (later), so keep going.
+         */
+        status = acpi_ut_validate_buffer(buffer);
+        if (ACPI_FAILURE(status)) {
+                return_ACPI_STATUS(status);
+        }
+
+        *return_node = node;
+        return_ACPI_STATUS(AE_OK);
+}
+
 /*******************************************************************************
  *
  * FUNCTION:    acpi_get_irq_routing_table
  *
- * PARAMETERS:  device_handle   - a handle to the Bus device we are querying
- *              ret_buffer      - a pointer to a buffer to receive the
+ * PARAMETERS:  device_handle   - Handle to the Bus device we are querying
+ *              ret_buffer      - Pointer to a buffer to receive the
  *                                current resources for the device
  *
  * RETURN:      Status
  *
  * DESCRIPTION: This function is called to get the IRQ routing table for a
- *              specific bus.  The caller must first acquire a handle for the
- *              desired bus.  The routine table is placed in the buffer pointed
+ *              specific bus. The caller must first acquire a handle for the
+ *              desired bus. The routine table is placed in the buffer pointed
  *              to by the ret_buffer variable parameter.
  *
  *              If the function fails an appropriate status will be returned
@@ -94,25 +156,18 @@ acpi_get_irq_routing_table(acpi_handle device_handle,
                            struct acpi_buffer *ret_buffer)
 {
         acpi_status status;
+        struct acpi_namespace_node *node;
 
         ACPI_FUNCTION_TRACE(acpi_get_irq_routing_table);
 
-        /*
-         * Must have a valid handle and buffer, So we have to have a handle
-         * and a return buffer structure, and if there is a non-zero buffer length
-         * we also need a valid pointer in the buffer. If it's a zero buffer length,
-         * we'll be returning the needed buffer size, so keep going.
-         */
-        if (!device_handle) {
-                return_ACPI_STATUS(AE_BAD_PARAMETER);
-        }
+        /* Validate parameters then dispatch to internal routine */
 
-        status = acpi_ut_validate_buffer(ret_buffer);
+        status = acpi_rs_validate_parameters(device_handle, ret_buffer, &node);
         if (ACPI_FAILURE(status)) {
                 return_ACPI_STATUS(status);
         }
 
-        status = acpi_rs_get_prt_method_data(device_handle, ret_buffer);
+        status = acpi_rs_get_prt_method_data(node, ret_buffer);
         return_ACPI_STATUS(status);
 }
 
@@ -122,16 +177,16 @@ ACPI_EXPORT_SYMBOL(acpi_get_irq_routing_table)
  *
  * FUNCTION:    acpi_get_current_resources
  *
- * PARAMETERS:  device_handle   - a handle to the device object for the
+ * PARAMETERS:  device_handle   - Handle to the device object for the
  *                                device we are querying
- *              ret_buffer      - a pointer to a buffer to receive the
+ *              ret_buffer      - Pointer to a buffer to receive the
  *                                current resources for the device
  *
  * RETURN:      Status
  *
  * DESCRIPTION: This function is called to get the current resources for a
- *              specific device.  The caller must first acquire a handle for
- *              the desired device.  The resource data is placed in the buffer
+ *              specific device. The caller must first acquire a handle for
+ *              the desired device. The resource data is placed in the buffer
  *              pointed to by the ret_buffer variable parameter.
  *
  *              If the function fails an appropriate status will be returned
@@ -146,25 +201,18 @@ acpi_get_current_resources(acpi_handle device_handle,
                            struct acpi_buffer *ret_buffer)
 {
         acpi_status status;
+        struct acpi_namespace_node *node;
 
         ACPI_FUNCTION_TRACE(acpi_get_current_resources);
 
-        /*
-         * Must have a valid handle and buffer, So we have to have a handle
-         * and a return buffer structure, and if there is a non-zero buffer length
-         * we also need a valid pointer in the buffer. If it's a zero buffer length,
-         * we'll be returning the needed buffer size, so keep going.
-         */
-        if (!device_handle) {
-                return_ACPI_STATUS(AE_BAD_PARAMETER);
-        }
+        /* Validate parameters then dispatch to internal routine */
 
-        status = acpi_ut_validate_buffer(ret_buffer);
+        status = acpi_rs_validate_parameters(device_handle, ret_buffer, &node);
         if (ACPI_FAILURE(status)) {
                 return_ACPI_STATUS(status);
         }
 
-        status = acpi_rs_get_crs_method_data(device_handle, ret_buffer);
+        status = acpi_rs_get_crs_method_data(node, ret_buffer);
         return_ACPI_STATUS(status);
 }
 
@@ -175,16 +223,16 @@ ACPI_EXPORT_SYMBOL(acpi_get_current_resources)
  *
  * FUNCTION:    acpi_get_possible_resources
  *
- * PARAMETERS:  device_handle   - a handle to the device object for the
+ * PARAMETERS:  device_handle   - Handle to the device object for the
  *                                device we are querying
- *              ret_buffer      - a pointer to a buffer to receive the
+ *              ret_buffer      - Pointer to a buffer to receive the
  *                                resources for the device
  *
  * RETURN:      Status
  *
  * DESCRIPTION: This function is called to get a list of the possible resources
- *              for a specific device.  The caller must first acquire a handle
- *              for the desired device.  The resource data is placed in the
+ *              for a specific device. The caller must first acquire a handle
+ *              for the desired device. The resource data is placed in the
  *              buffer pointed to by the ret_buffer variable.
  *
  *              If the function fails an appropriate status will be returned
@@ -196,25 +244,18 @@ acpi_get_possible_resources(acpi_handle device_handle,
                             struct acpi_buffer *ret_buffer)
 {
         acpi_status status;
+        struct acpi_namespace_node *node;
 
         ACPI_FUNCTION_TRACE(acpi_get_possible_resources);
 
-        /*
-         * Must have a valid handle and buffer, So we have to have a handle
-         * and a return buffer structure, and if there is a non-zero buffer length
-         * we also need a valid pointer in the buffer. If it's a zero buffer length,
-         * we'll be returning the needed buffer size, so keep going.
-         */
-        if (!device_handle) {
-                return_ACPI_STATUS(AE_BAD_PARAMETER);
-        }
+        /* Validate parameters then dispatch to internal routine */
 
-        status = acpi_ut_validate_buffer(ret_buffer);
+        status = acpi_rs_validate_parameters(device_handle, ret_buffer, &node);
         if (ACPI_FAILURE(status)) {
                 return_ACPI_STATUS(status);
         }
 
-        status = acpi_rs_get_prs_method_data(device_handle, ret_buffer);
+        status = acpi_rs_get_prs_method_data(node, ret_buffer);
         return_ACPI_STATUS(status);
 }
 
@@ -223,113 +264,18 @@ ACPI_EXPORT_SYMBOL(acpi_get_possible_resources)
 
 /*******************************************************************************
  *
- * FUNCTION:    acpi_walk_resources
- *
- * PARAMETERS:  device_handle   - Handle to the device object for the
- *                                device we are querying
- *              Name            - Method name of the resources we want
- *                                (METHOD_NAME__CRS or METHOD_NAME__PRS)
- *              user_function   - Called for each resource
- *              Context         - Passed to user_function
- *
- * RETURN:      Status
- *
- * DESCRIPTION: Retrieves the current or possible resource list for the
- *              specified device.  The user_function is called once for
- *              each resource in the list.
- *
- ******************************************************************************/
-acpi_status
-acpi_walk_resources(acpi_handle device_handle,
-                    char *name,
-                    acpi_walk_resource_callback user_function, void *context)
-{
-        acpi_status status;
-        struct acpi_buffer buffer;
-        struct acpi_resource *resource;
-        struct acpi_resource *resource_end;
-
-        ACPI_FUNCTION_TRACE(acpi_walk_resources);
-
-        /* Parameter validation */
-
-        if (!device_handle || !user_function || !name ||
-            (!ACPI_COMPARE_NAME(name, METHOD_NAME__CRS) &&
-             !ACPI_COMPARE_NAME(name, METHOD_NAME__PRS))) {
-                return_ACPI_STATUS(AE_BAD_PARAMETER);
-        }
-
-        /* Get the _CRS or _PRS resource list */
-
-        buffer.length = ACPI_ALLOCATE_LOCAL_BUFFER;
-        status = acpi_rs_get_method_data(device_handle, name, &buffer);
-        if (ACPI_FAILURE(status)) {
-                return_ACPI_STATUS(status);
-        }
-
-        /* Buffer now contains the resource list */
-
-        resource = ACPI_CAST_PTR(struct acpi_resource, buffer.pointer);
-        resource_end =
-            ACPI_ADD_PTR(struct acpi_resource, buffer.pointer, buffer.length);
-
-        /* Walk the resource list until the end_tag is found (or buffer end) */
-
-        while (resource < resource_end) {
-
-                /* Sanity check the resource */
-
-                if (resource->type > ACPI_RESOURCE_TYPE_MAX) {
-                        status = AE_AML_INVALID_RESOURCE_TYPE;
-                        break;
-                }
-
-                /* Invoke the user function, abort on any error returned */
-
-                status = user_function(resource, context);
-                if (ACPI_FAILURE(status)) {
-                        if (status == AE_CTRL_TERMINATE) {
-
-                                /* This is an OK termination by the user function */
-
-                                status = AE_OK;
-                        }
-                        break;
-                }
-
-                /* end_tag indicates end-of-list */
-
-                if (resource->type == ACPI_RESOURCE_TYPE_END_TAG) {
-                        break;
-                }
-
-                /* Get the next resource descriptor */
-
-                resource =
-                    ACPI_ADD_PTR(struct acpi_resource, resource,
-                                 resource->length);
-        }
-
-        ACPI_FREE(buffer.pointer);
-        return_ACPI_STATUS(status);
-}
-
-ACPI_EXPORT_SYMBOL(acpi_walk_resources)
-
-/*******************************************************************************
- *
  * FUNCTION:    acpi_set_current_resources
  *
- * PARAMETERS:  device_handle   - a handle to the device object for the
- *                                device we are changing the resources of
- *              in_buffer       - a pointer to a buffer containing the
+ * PARAMETERS:  device_handle   - Handle to the device object for the
+ *                                device we are setting resources
+ *              in_buffer       - Pointer to a buffer containing the
  *                                resources to be set for the device
  *
  * RETURN:      Status
  *
  * DESCRIPTION: This function is called to set the current resources for a
- *              specific device.  The caller must first acquire a handle for
- *              the desired device.  The resource data is passed to the routine
+ *              specific device. The caller must first acquire a handle for
+ *              the desired device. The resource data is passed to the routine
  *              the buffer pointed to by the in_buffer variable.
  *
  ******************************************************************************/
@@ -338,17 +284,24 @@ acpi_set_current_resources(acpi_handle device_handle,
                            struct acpi_buffer *in_buffer)
 {
         acpi_status status;
+        struct acpi_namespace_node *node;
 
         ACPI_FUNCTION_TRACE(acpi_set_current_resources);
 
-        /* Must have a valid handle and buffer */
+        /* Validate the buffer, don't allow zero length */
 
-        if ((!device_handle) ||
-            (!in_buffer) || (!in_buffer->pointer) || (!in_buffer->length)) {
+        if ((!in_buffer) || (!in_buffer->pointer) || (!in_buffer->length)) {
                 return_ACPI_STATUS(AE_BAD_PARAMETER);
         }
 
-        status = acpi_rs_set_srs_method_data(device_handle, in_buffer);
+        /* Validate parameters then dispatch to internal routine */
+
+        status = acpi_rs_validate_parameters(device_handle, in_buffer, &node);
+        if (ACPI_FAILURE(status)) {
+                return_ACPI_STATUS(status);
+        }
+
+        status = acpi_rs_set_srs_method_data(node, in_buffer);
         return_ACPI_STATUS(status);
 }
 
@@ -358,15 +311,14 @@ ACPI_EXPORT_SYMBOL(acpi_set_current_resources)
  *
  * FUNCTION:    acpi_resource_to_address64
  *
- * PARAMETERS:  Resource                - Pointer to a resource
- *              Out                     - Pointer to the users's return
- *                                        buffer (a struct
- *                                        struct acpi_resource_address64)
+ * PARAMETERS:  Resource        - Pointer to a resource
+ *              Out             - Pointer to the users's return buffer
+ *                                (a struct acpi_resource_address64)
  *
  * RETURN:      Status
  *
  * DESCRIPTION: If the resource is an address16, address32, or address64,
- *              copy it to the address64 return buffer.  This saves the
+ *              copy it to the address64 return buffer. This saves the
  *              caller from having to duplicate code for different-sized
  *              addresses.
  *
@@ -418,12 +370,12 @@ ACPI_EXPORT_SYMBOL(acpi_resource_to_address64)
  *
  * FUNCTION:    acpi_get_vendor_resource
  *
- * PARAMETERS:  device_handle       - Handle for the parent device object
- *              Name                - Method name for the parent resource
- *                                    (METHOD_NAME__CRS or METHOD_NAME__PRS)
- *              Uuid                - Pointer to the UUID to be matched.
- *                                    includes both subtype and 16-byte UUID
- *              ret_buffer          - Where the vendor resource is returned
+ * PARAMETERS:  device_handle   - Handle for the parent device object
+ *              Name            - Method name for the parent resource
+ *                                (METHOD_NAME__CRS or METHOD_NAME__PRS)
+ *              Uuid            - Pointer to the UUID to be matched.
+ *                                includes both subtype and 16-byte UUID
+ *              ret_buffer      - Where the vendor resource is returned
  *
  * RETURN:      Status
  *
@@ -525,3 +477,99 @@ acpi_rs_match_vendor_resource(struct acpi_resource *resource, void *context)
 }
 
 ACPI_EXPORT_SYMBOL(acpi_rs_match_vendor_resource)
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_walk_resources
+ *
+ * PARAMETERS:  device_handle   - Handle to the device object for the
+ *                                device we are querying
+ *              Name            - Method name of the resources we want
+ *                                (METHOD_NAME__CRS or METHOD_NAME__PRS)
+ *              user_function   - Called for each resource
+ *              Context         - Passed to user_function
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Retrieves the current or possible resource list for the
+ *              specified device. The user_function is called once for
+ *              each resource in the list.
+ *
+ ******************************************************************************/
+
+acpi_status
+acpi_walk_resources(acpi_handle device_handle,
+                    char *name,
+                    acpi_walk_resource_callback user_function, void *context)
+{
+        acpi_status status;
+        struct acpi_buffer buffer;
+        struct acpi_resource *resource;
+        struct acpi_resource *resource_end;
+
+        ACPI_FUNCTION_TRACE(acpi_walk_resources);
+
+        /* Parameter validation */
+
+        if (!device_handle || !user_function || !name ||
+            (!ACPI_COMPARE_NAME(name, METHOD_NAME__CRS) &&
+             !ACPI_COMPARE_NAME(name, METHOD_NAME__PRS))) {
+                return_ACPI_STATUS(AE_BAD_PARAMETER);
+        }
+
+        /* Get the _CRS or _PRS resource list */
+
+        buffer.length = ACPI_ALLOCATE_LOCAL_BUFFER;
+        status = acpi_rs_get_method_data(device_handle, name, &buffer);
+        if (ACPI_FAILURE(status)) {
+                return_ACPI_STATUS(status);
+        }
+
+        /* Buffer now contains the resource list */
+
+        resource = ACPI_CAST_PTR(struct acpi_resource, buffer.pointer);
+        resource_end =
+            ACPI_ADD_PTR(struct acpi_resource, buffer.pointer, buffer.length);
+
+        /* Walk the resource list until the end_tag is found (or buffer end) */
+
+        while (resource < resource_end) {
+
+                /* Sanity check the resource */
+
+                if (resource->type > ACPI_RESOURCE_TYPE_MAX) {
+                        status = AE_AML_INVALID_RESOURCE_TYPE;
+                        break;
+                }
+
+                /* Invoke the user function, abort on any error returned */
+
+                status = user_function(resource, context);
+                if (ACPI_FAILURE(status)) {
+                        if (status == AE_CTRL_TERMINATE) {
+
+                                /* This is an OK termination by the user function */
+
+                                status = AE_OK;
+                        }
+                        break;
+                }
+
+                /* end_tag indicates end-of-list */
+
+                if (resource->type == ACPI_RESOURCE_TYPE_END_TAG) {
+                        break;
+                }
+
+                /* Get the next resource descriptor */
+
+                resource =
+                    ACPI_ADD_PTR(struct acpi_resource, resource,
+                                 resource->length);
+        }
+
+        ACPI_FREE(buffer.pointer);
+        return_ACPI_STATUS(status);
+}
+
+ACPI_EXPORT_SYMBOL(acpi_walk_resources)