Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1. /*******************************************************************************
  2.  *
  3.  * Module Name: rsxface - Public interfaces to the resource manager
  4.  *
  5.  ******************************************************************************/
  6.  
  7. /*
  8.  * Copyright (C) 2000 - 2015, Intel Corp.
  9.  * All rights reserved.
  10.  *
  11.  * Redistribution and use in source and binary forms, with or without
  12.  * modification, are permitted provided that the following conditions
  13.  * are met:
  14.  * 1. Redistributions of source code must retain the above copyright
  15.  *    notice, this list of conditions, and the following disclaimer,
  16.  *    without modification.
  17.  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  18.  *    substantially similar to the "NO WARRANTY" disclaimer below
  19.  *    ("Disclaimer") and any redistribution must be conditioned upon
  20.  *    including a substantially similar Disclaimer requirement for further
  21.  *    binary redistribution.
  22.  * 3. Neither the names of the above-listed copyright holders nor the names
  23.  *    of any contributors may be used to endorse or promote products derived
  24.  *    from this software without specific prior written permission.
  25.  *
  26.  * Alternatively, this software may be distributed under the terms of the
  27.  * GNU General Public License ("GPL") version 2 as published by the Free
  28.  * Software Foundation.
  29.  *
  30.  * NO WARRANTY
  31.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  32.  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  33.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  34.  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  35.  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  37.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  39.  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  40.  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  41.  * POSSIBILITY OF SUCH DAMAGES.
  42.  */
  43.  
  44. #define EXPORT_ACPI_INTERFACES
  45.  
  46. #include <acpi/acpi.h>
  47. #include "accommon.h"
  48. #include "acresrc.h"
  49. #include "acnamesp.h"
  50.  
  51. #define _COMPONENT          ACPI_RESOURCES
  52. ACPI_MODULE_NAME("rsxface")
  53.  
  54. /* Local macros for 16,32-bit to 64-bit conversion */
  55. #define ACPI_COPY_FIELD(out, in, field)  ((out)->field = (in)->field)
  56. #define ACPI_COPY_ADDRESS(out, in)                      \
  57.         ACPI_COPY_FIELD(out, in, resource_type);             \
  58.         ACPI_COPY_FIELD(out, in, producer_consumer);         \
  59.         ACPI_COPY_FIELD(out, in, decode);                    \
  60.         ACPI_COPY_FIELD(out, in, min_address_fixed);         \
  61.         ACPI_COPY_FIELD(out, in, max_address_fixed);         \
  62.         ACPI_COPY_FIELD(out, in, info);                      \
  63.         ACPI_COPY_FIELD(out, in, address.granularity);       \
  64.         ACPI_COPY_FIELD(out, in, address.minimum);           \
  65.         ACPI_COPY_FIELD(out, in, address.maximum);           \
  66.         ACPI_COPY_FIELD(out, in, address.translation_offset); \
  67.         ACPI_COPY_FIELD(out, in, address.address_length);    \
  68.         ACPI_COPY_FIELD(out, in, resource_source);
  69. /* Local prototypes */
  70. static acpi_status
  71. acpi_rs_match_vendor_resource(struct acpi_resource *resource, void *context);
  72.  
  73. static acpi_status
  74. acpi_rs_validate_parameters(acpi_handle device_handle,
  75.                             struct acpi_buffer *buffer,
  76.                             struct acpi_namespace_node **return_node);
  77.  
  78. /*******************************************************************************
  79.  *
  80.  * FUNCTION:    acpi_rs_validate_parameters
  81.  *
  82.  * PARAMETERS:  device_handle   - Handle to a device
  83.  *              buffer          - Pointer to a data buffer
  84.  *              return_node     - Pointer to where the device node is returned
  85.  *
  86.  * RETURN:      Status
  87.  *
  88.  * DESCRIPTION: Common parameter validation for resource interfaces
  89.  *
  90.  ******************************************************************************/
  91.  
  92. static acpi_status
  93. acpi_rs_validate_parameters(acpi_handle device_handle,
  94.                             struct acpi_buffer *buffer,
  95.                             struct acpi_namespace_node **return_node)
  96. {
  97.         acpi_status status;
  98.         struct acpi_namespace_node *node;
  99.  
  100.         ACPI_FUNCTION_TRACE(rs_validate_parameters);
  101.  
  102.         /*
  103.          * Must have a valid handle to an ACPI device
  104.          */
  105.         if (!device_handle) {
  106.                 return_ACPI_STATUS(AE_BAD_PARAMETER);
  107.         }
  108.  
  109.         node = acpi_ns_validate_handle(device_handle);
  110.         if (!node) {
  111.                 return_ACPI_STATUS(AE_BAD_PARAMETER);
  112.         }
  113.  
  114.         if (node->type != ACPI_TYPE_DEVICE) {
  115.                 return_ACPI_STATUS(AE_TYPE);
  116.         }
  117.  
  118.         /*
  119.          * Validate the user buffer object
  120.          *
  121.          * if there is a non-zero buffer length we also need a valid pointer in
  122.          * the buffer. If it's a zero buffer length, we'll be returning the
  123.          * needed buffer size (later), so keep going.
  124.          */
  125.         status = acpi_ut_validate_buffer(buffer);
  126.         if (ACPI_FAILURE(status)) {
  127.                 return_ACPI_STATUS(status);
  128.         }
  129.  
  130.         *return_node = node;
  131.         return_ACPI_STATUS(AE_OK);
  132. }
  133.  
  134. /*******************************************************************************
  135.  *
  136.  * FUNCTION:    acpi_get_irq_routing_table
  137.  *
  138.  * PARAMETERS:  device_handle   - Handle to the Bus device we are querying
  139.  *              ret_buffer      - Pointer to a buffer to receive the
  140.  *                                current resources for the device
  141.  *
  142.  * RETURN:      Status
  143.  *
  144.  * DESCRIPTION: This function is called to get the IRQ routing table for a
  145.  *              specific bus. The caller must first acquire a handle for the
  146.  *              desired bus. The routine table is placed in the buffer pointed
  147.  *              to by the ret_buffer variable parameter.
  148.  *
  149.  *              If the function fails an appropriate status will be returned
  150.  *              and the value of ret_buffer is undefined.
  151.  *
  152.  *              This function attempts to execute the _PRT method contained in
  153.  *              the object indicated by the passed device_handle.
  154.  *
  155.  ******************************************************************************/
  156.  
  157. acpi_status
  158. acpi_get_irq_routing_table(acpi_handle device_handle,
  159.                            struct acpi_buffer *ret_buffer)
  160. {
  161.         acpi_status status;
  162.         struct acpi_namespace_node *node;
  163.  
  164.         ACPI_FUNCTION_TRACE(acpi_get_irq_routing_table);
  165.  
  166.         /* Validate parameters then dispatch to internal routine */
  167.  
  168.         status = acpi_rs_validate_parameters(device_handle, ret_buffer, &node);
  169.         if (ACPI_FAILURE(status)) {
  170.                 return_ACPI_STATUS(status);
  171.         }
  172.  
  173.         status = acpi_rs_get_prt_method_data(node, ret_buffer);
  174.         return_ACPI_STATUS(status);
  175. }
  176.  
  177. ACPI_EXPORT_SYMBOL(acpi_get_irq_routing_table)
  178.  
  179. /*******************************************************************************
  180.  *
  181.  * FUNCTION:    acpi_get_current_resources
  182.  *
  183.  * PARAMETERS:  device_handle   - Handle to the device object for the
  184.  *                                device we are querying
  185.  *              ret_buffer      - Pointer to a buffer to receive the
  186.  *                                current resources for the device
  187.  *
  188.  * RETURN:      Status
  189.  *
  190.  * DESCRIPTION: This function is called to get the current resources for a
  191.  *              specific device. The caller must first acquire a handle for
  192.  *              the desired device. The resource data is placed in the buffer
  193.  *              pointed to by the ret_buffer variable parameter.
  194.  *
  195.  *              If the function fails an appropriate status will be returned
  196.  *              and the value of ret_buffer is undefined.
  197.  *
  198.  *              This function attempts to execute the _CRS method contained in
  199.  *              the object indicated by the passed device_handle.
  200.  *
  201.  ******************************************************************************/
  202. acpi_status
  203. acpi_get_current_resources(acpi_handle device_handle,
  204.                            struct acpi_buffer *ret_buffer)
  205. {
  206.         acpi_status status;
  207.         struct acpi_namespace_node *node;
  208.  
  209.         ACPI_FUNCTION_TRACE(acpi_get_current_resources);
  210.  
  211.         /* Validate parameters then dispatch to internal routine */
  212.  
  213.         status = acpi_rs_validate_parameters(device_handle, ret_buffer, &node);
  214.         if (ACPI_FAILURE(status)) {
  215.                 return_ACPI_STATUS(status);
  216.         }
  217.  
  218.         status = acpi_rs_get_crs_method_data(node, ret_buffer);
  219.         return_ACPI_STATUS(status);
  220. }
  221.  
  222. ACPI_EXPORT_SYMBOL(acpi_get_current_resources)
  223.  
  224. /*******************************************************************************
  225.  *
  226.  * FUNCTION:    acpi_get_possible_resources
  227.  *
  228.  * PARAMETERS:  device_handle   - Handle to the device object for the
  229.  *                                device we are querying
  230.  *              ret_buffer      - Pointer to a buffer to receive the
  231.  *                                resources for the device
  232.  *
  233.  * RETURN:      Status
  234.  *
  235.  * DESCRIPTION: This function is called to get a list of the possible resources
  236.  *              for a specific device. The caller must first acquire a handle
  237.  *              for the desired device. The resource data is placed in the
  238.  *              buffer pointed to by the ret_buffer variable.
  239.  *
  240.  *              If the function fails an appropriate status will be returned
  241.  *              and the value of ret_buffer is undefined.
  242.  *
  243.  ******************************************************************************/
  244. acpi_status
  245. acpi_get_possible_resources(acpi_handle device_handle,
  246.                             struct acpi_buffer *ret_buffer)
  247. {
  248.         acpi_status status;
  249.         struct acpi_namespace_node *node;
  250.  
  251.         ACPI_FUNCTION_TRACE(acpi_get_possible_resources);
  252.  
  253.         /* Validate parameters then dispatch to internal routine */
  254.  
  255.         status = acpi_rs_validate_parameters(device_handle, ret_buffer, &node);
  256.         if (ACPI_FAILURE(status)) {
  257.                 return_ACPI_STATUS(status);
  258.         }
  259.  
  260.         status = acpi_rs_get_prs_method_data(node, ret_buffer);
  261.         return_ACPI_STATUS(status);
  262. }
  263.  
  264. ACPI_EXPORT_SYMBOL(acpi_get_possible_resources)
  265.  
  266. /*******************************************************************************
  267.  *
  268.  * FUNCTION:    acpi_set_current_resources
  269.  *
  270.  * PARAMETERS:  device_handle   - Handle to the device object for the
  271.  *                                device we are setting resources
  272.  *              in_buffer       - Pointer to a buffer containing the
  273.  *                                resources to be set for the device
  274.  *
  275.  * RETURN:      Status
  276.  *
  277.  * DESCRIPTION: This function is called to set the current resources for a
  278.  *              specific device. The caller must first acquire a handle for
  279.  *              the desired device. The resource data is passed to the routine
  280.  *              the buffer pointed to by the in_buffer variable.
  281.  *
  282.  ******************************************************************************/
  283. acpi_status
  284. acpi_set_current_resources(acpi_handle device_handle,
  285.                            struct acpi_buffer *in_buffer)
  286. {
  287.         acpi_status status;
  288.         struct acpi_namespace_node *node;
  289.  
  290.         ACPI_FUNCTION_TRACE(acpi_set_current_resources);
  291.  
  292.         /* Validate the buffer, don't allow zero length */
  293.  
  294.         if ((!in_buffer) || (!in_buffer->pointer) || (!in_buffer->length)) {
  295.                 return_ACPI_STATUS(AE_BAD_PARAMETER);
  296.         }
  297.  
  298.         /* Validate parameters then dispatch to internal routine */
  299.  
  300.         status = acpi_rs_validate_parameters(device_handle, in_buffer, &node);
  301.         if (ACPI_FAILURE(status)) {
  302.                 return_ACPI_STATUS(status);
  303.         }
  304.  
  305.         status = acpi_rs_set_srs_method_data(node, in_buffer);
  306.         return_ACPI_STATUS(status);
  307. }
  308.  
  309. ACPI_EXPORT_SYMBOL(acpi_set_current_resources)
  310.  
  311. /*******************************************************************************
  312.  *
  313.  * FUNCTION:    acpi_get_event_resources
  314.  *
  315.  * PARAMETERS:  device_handle   - Handle to the device object for the
  316.  *                                device we are getting resources
  317.  *              in_buffer       - Pointer to a buffer containing the
  318.  *                                resources to be set for the device
  319.  *
  320.  * RETURN:      Status
  321.  *
  322.  * DESCRIPTION: This function is called to get the event resources for a
  323.  *              specific device. The caller must first acquire a handle for
  324.  *              the desired device. The resource data is passed to the routine
  325.  *              the buffer pointed to by the in_buffer variable. Uses the
  326.  *              _AEI method.
  327.  *
  328.  ******************************************************************************/
  329. acpi_status
  330. acpi_get_event_resources(acpi_handle device_handle,
  331.                          struct acpi_buffer *ret_buffer)
  332. {
  333.         acpi_status status;
  334.         struct acpi_namespace_node *node;
  335.  
  336.         ACPI_FUNCTION_TRACE(acpi_get_event_resources);
  337.  
  338.         /* Validate parameters then dispatch to internal routine */
  339.  
  340.         status = acpi_rs_validate_parameters(device_handle, ret_buffer, &node);
  341.         if (ACPI_FAILURE(status)) {
  342.                 return_ACPI_STATUS(status);
  343.         }
  344.  
  345.         status = acpi_rs_get_aei_method_data(node, ret_buffer);
  346.         return_ACPI_STATUS(status);
  347. }
  348.  
  349. ACPI_EXPORT_SYMBOL(acpi_get_event_resources)
  350.  
  351. /******************************************************************************
  352.  *
  353.  * FUNCTION:    acpi_resource_to_address64
  354.  *
  355.  * PARAMETERS:  resource        - Pointer to a resource
  356.  *              out             - Pointer to the users's return buffer
  357.  *                                (a struct acpi_resource_address64)
  358.  *
  359.  * RETURN:      Status
  360.  *
  361.  * DESCRIPTION: If the resource is an address16, address32, or address64,
  362.  *              copy it to the address64 return buffer. This saves the
  363.  *              caller from having to duplicate code for different-sized
  364.  *              addresses.
  365.  *
  366.  ******************************************************************************/
  367. acpi_status
  368. acpi_resource_to_address64(struct acpi_resource *resource,
  369.                            struct acpi_resource_address64 *out)
  370. {
  371.         struct acpi_resource_address16 *address16;
  372.         struct acpi_resource_address32 *address32;
  373.  
  374.         if (!resource || !out) {
  375.                 return (AE_BAD_PARAMETER);
  376.         }
  377.  
  378.         /* Convert 16 or 32 address descriptor to 64 */
  379.  
  380.         switch (resource->type) {
  381.         case ACPI_RESOURCE_TYPE_ADDRESS16:
  382.  
  383.                 address16 =
  384.                     ACPI_CAST_PTR(struct acpi_resource_address16,
  385.                                   &resource->data);
  386.                 ACPI_COPY_ADDRESS(out, address16);
  387.                 break;
  388.  
  389.         case ACPI_RESOURCE_TYPE_ADDRESS32:
  390.  
  391.                 address32 =
  392.                     ACPI_CAST_PTR(struct acpi_resource_address32,
  393.                                   &resource->data);
  394.                 ACPI_COPY_ADDRESS(out, address32);
  395.                 break;
  396.  
  397.         case ACPI_RESOURCE_TYPE_ADDRESS64:
  398.  
  399.                 /* Simple copy for 64 bit source */
  400.  
  401.                 memcpy(out, &resource->data,
  402.                        sizeof(struct acpi_resource_address64));
  403.                 break;
  404.  
  405.         default:
  406.  
  407.                 return (AE_BAD_PARAMETER);
  408.         }
  409.  
  410.         return (AE_OK);
  411. }
  412.  
  413. ACPI_EXPORT_SYMBOL(acpi_resource_to_address64)
  414.  
  415. /*******************************************************************************
  416.  *
  417.  * FUNCTION:    acpi_get_vendor_resource
  418.  *
  419.  * PARAMETERS:  device_handle   - Handle for the parent device object
  420.  *              name            - Method name for the parent resource
  421.  *                                (METHOD_NAME__CRS or METHOD_NAME__PRS)
  422.  *              uuid            - Pointer to the UUID to be matched.
  423.  *                                includes both subtype and 16-byte UUID
  424.  *              ret_buffer      - Where the vendor resource is returned
  425.  *
  426.  * RETURN:      Status
  427.  *
  428.  * DESCRIPTION: Walk a resource template for the specified device to find a
  429.  *              vendor-defined resource that matches the supplied UUID and
  430.  *              UUID subtype. Returns a struct acpi_resource of type Vendor.
  431.  *
  432.  ******************************************************************************/
  433. acpi_status
  434. acpi_get_vendor_resource(acpi_handle device_handle,
  435.                          char *name,
  436.                          struct acpi_vendor_uuid * uuid,
  437.                          struct acpi_buffer * ret_buffer)
  438. {
  439.         struct acpi_vendor_walk_info info;
  440.         acpi_status status;
  441.  
  442.         /* Other parameters are validated by acpi_walk_resources */
  443.  
  444.         if (!uuid || !ret_buffer) {
  445.                 return (AE_BAD_PARAMETER);
  446.         }
  447.  
  448.         info.uuid = uuid;
  449.         info.buffer = ret_buffer;
  450.         info.status = AE_NOT_EXIST;
  451.  
  452.         /* Walk the _CRS or _PRS resource list for this device */
  453.  
  454.         status =
  455.             acpi_walk_resources(device_handle, name,
  456.                                 acpi_rs_match_vendor_resource, &info);
  457.         if (ACPI_FAILURE(status)) {
  458.                 return (status);
  459.         }
  460.  
  461.         return (info.status);
  462. }
  463.  
  464. ACPI_EXPORT_SYMBOL(acpi_get_vendor_resource)
  465.  
  466. /*******************************************************************************
  467.  *
  468.  * FUNCTION:    acpi_rs_match_vendor_resource
  469.  *
  470.  * PARAMETERS:  acpi_walk_resource_callback
  471.  *
  472.  * RETURN:      Status
  473.  *
  474.  * DESCRIPTION: Match a vendor resource via the ACPI 3.0 UUID
  475.  *
  476.  ******************************************************************************/
  477. static acpi_status
  478. acpi_rs_match_vendor_resource(struct acpi_resource *resource, void *context)
  479. {
  480.         struct acpi_vendor_walk_info *info = context;
  481.         struct acpi_resource_vendor_typed *vendor;
  482.         struct acpi_buffer *buffer;
  483.         acpi_status status;
  484.  
  485.         /* Ignore all descriptors except Vendor */
  486.  
  487.         if (resource->type != ACPI_RESOURCE_TYPE_VENDOR) {
  488.                 return (AE_OK);
  489.         }
  490.  
  491.         vendor = &resource->data.vendor_typed;
  492.  
  493.         /*
  494.          * For a valid match, these conditions must hold:
  495.          *
  496.          * 1) Length of descriptor data must be at least as long as a UUID struct
  497.          * 2) The UUID subtypes must match
  498.          * 3) The UUID data must match
  499.          */
  500.         if ((vendor->byte_length < (ACPI_UUID_LENGTH + 1)) ||
  501.             (vendor->uuid_subtype != info->uuid->subtype) ||
  502.             (memcmp(vendor->uuid, info->uuid->data, ACPI_UUID_LENGTH))) {
  503.                 return (AE_OK);
  504.         }
  505.  
  506.         /* Validate/Allocate/Clear caller buffer */
  507.  
  508.         buffer = info->buffer;
  509.         status = acpi_ut_initialize_buffer(buffer, resource->length);
  510.         if (ACPI_FAILURE(status)) {
  511.                 return (status);
  512.         }
  513.  
  514.         /* Found the correct resource, copy and return it */
  515.  
  516.         memcpy(buffer->pointer, resource, resource->length);
  517.         buffer->length = resource->length;
  518.  
  519.         /* Found the desired descriptor, terminate resource walk */
  520.  
  521.         info->status = AE_OK;
  522.         return (AE_CTRL_TERMINATE);
  523. }
  524.  
  525. /*******************************************************************************
  526.  *
  527.  * FUNCTION:    acpi_walk_resource_buffer
  528.  *
  529.  * PARAMETERS:  buffer          - Formatted buffer returned by one of the
  530.  *                                various Get*Resource functions
  531.  *              user_function   - Called for each resource
  532.  *              context         - Passed to user_function
  533.  *
  534.  * RETURN:      Status
  535.  *
  536.  * DESCRIPTION: Walks the input resource template. The user_function is called
  537.  *              once for each resource in the list.
  538.  *
  539.  ******************************************************************************/
  540.  
  541. acpi_status
  542. acpi_walk_resource_buffer(struct acpi_buffer * buffer,
  543.                           acpi_walk_resource_callback user_function,
  544.                           void *context)
  545. {
  546.         acpi_status status = AE_OK;
  547.         struct acpi_resource *resource;
  548.         struct acpi_resource *resource_end;
  549.  
  550.         ACPI_FUNCTION_TRACE(acpi_walk_resource_buffer);
  551.  
  552.         /* Parameter validation */
  553.  
  554.         if (!buffer || !buffer->pointer || !user_function) {
  555.                 return_ACPI_STATUS(AE_BAD_PARAMETER);
  556.         }
  557.  
  558.         /* Buffer contains the resource list and length */
  559.  
  560.         resource = ACPI_CAST_PTR(struct acpi_resource, buffer->pointer);
  561.         resource_end =
  562.             ACPI_ADD_PTR(struct acpi_resource, buffer->pointer, buffer->length);
  563.  
  564.         /* Walk the resource list until the end_tag is found (or buffer end) */
  565.  
  566.         while (resource < resource_end) {
  567.  
  568.                 /* Sanity check the resource type */
  569.  
  570.                 if (resource->type > ACPI_RESOURCE_TYPE_MAX) {
  571.                         status = AE_AML_INVALID_RESOURCE_TYPE;
  572.                         break;
  573.                 }
  574.  
  575.                 /* Sanity check the length. It must not be zero, or we loop forever */
  576.  
  577.                 if (!resource->length) {
  578.                         return_ACPI_STATUS(AE_AML_BAD_RESOURCE_LENGTH);
  579.                 }
  580.  
  581.                 /* Invoke the user function, abort on any error returned */
  582.  
  583.                 status = user_function(resource, context);
  584.                 if (ACPI_FAILURE(status)) {
  585.                         if (status == AE_CTRL_TERMINATE) {
  586.  
  587.                                 /* This is an OK termination by the user function */
  588.  
  589.                                 status = AE_OK;
  590.                         }
  591.                         break;
  592.                 }
  593.  
  594.                 /* end_tag indicates end-of-list */
  595.  
  596.                 if (resource->type == ACPI_RESOURCE_TYPE_END_TAG) {
  597.                         break;
  598.                 }
  599.  
  600.                 /* Get the next resource descriptor */
  601.  
  602.                 resource = ACPI_NEXT_RESOURCE(resource);
  603.         }
  604.  
  605.         return_ACPI_STATUS(status);
  606. }
  607.  
  608. ACPI_EXPORT_SYMBOL(acpi_walk_resource_buffer)
  609.  
  610. /*******************************************************************************
  611.  *
  612.  * FUNCTION:    acpi_walk_resources
  613.  *
  614.  * PARAMETERS:  device_handle   - Handle to the device object for the
  615.  *                                device we are querying
  616.  *              name            - Method name of the resources we want.
  617.  *                                (METHOD_NAME__CRS, METHOD_NAME__PRS, or
  618.  *                                METHOD_NAME__AEI)
  619.  *              user_function   - Called for each resource
  620.  *              context         - Passed to user_function
  621.  *
  622.  * RETURN:      Status
  623.  *
  624.  * DESCRIPTION: Retrieves the current or possible resource list for the
  625.  *              specified device. The user_function is called once for
  626.  *              each resource in the list.
  627.  *
  628.  ******************************************************************************/
  629. acpi_status
  630. acpi_walk_resources(acpi_handle device_handle,
  631.                     char *name,
  632.                     acpi_walk_resource_callback user_function, void *context)
  633. {
  634.         acpi_status status;
  635.         struct acpi_buffer buffer;
  636.  
  637.         ACPI_FUNCTION_TRACE(acpi_walk_resources);
  638.  
  639.         /* Parameter validation */
  640.  
  641.         if (!device_handle || !user_function || !name ||
  642.             (!ACPI_COMPARE_NAME(name, METHOD_NAME__CRS) &&
  643.              !ACPI_COMPARE_NAME(name, METHOD_NAME__PRS) &&
  644.              !ACPI_COMPARE_NAME(name, METHOD_NAME__AEI))) {
  645.                 return_ACPI_STATUS(AE_BAD_PARAMETER);
  646.         }
  647.  
  648.         /* Get the _CRS/_PRS/_AEI resource list */
  649.  
  650.         buffer.length = ACPI_ALLOCATE_LOCAL_BUFFER;
  651.         status = acpi_rs_get_method_data(device_handle, name, &buffer);
  652.         if (ACPI_FAILURE(status)) {
  653.                 return_ACPI_STATUS(status);
  654.         }
  655.  
  656.         /* Walk the resource list and cleanup */
  657.  
  658.         status = acpi_walk_resource_buffer(&buffer, user_function, context);
  659.         ACPI_FREE(buffer.pointer);
  660.         return_ACPI_STATUS(status);
  661. }
  662.  
  663. ACPI_EXPORT_SYMBOL(acpi_walk_resources)
  664.