1 /*******************************************************************************
3 * Module Name: rsxface - Public interfaces to the resource manager
5 ******************************************************************************/
8 * Copyright (C) 2000 - 2013, Intel Corp.
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
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.
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.
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.
44 #define EXPORT_ACPI_INTERFACES
46 #include <acpi/acpi.h>
51 #define _COMPONENT ACPI_RESOURCES
52 ACPI_MODULE_NAME("rsxface")
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, granularity); \
64 ACPI_COPY_FIELD(out, in, minimum); \
65 ACPI_COPY_FIELD(out, in, maximum); \
66 ACPI_COPY_FIELD(out, in, translation_offset); \
67 ACPI_COPY_FIELD(out, in, address_length); \
68 ACPI_COPY_FIELD(out, in, resource_source);
69 /* Local prototypes */
71 acpi_rs_match_vendor_resource(struct acpi_resource
*resource
, void *context
);
74 acpi_rs_validate_parameters(acpi_handle device_handle
,
75 struct acpi_buffer
*buffer
,
76 struct acpi_namespace_node
**return_node
);
78 /*******************************************************************************
80 * FUNCTION: acpi_rs_validate_parameters
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
88 * DESCRIPTION: Common parameter validation for resource interfaces
90 ******************************************************************************/
93 acpi_rs_validate_parameters(acpi_handle device_handle
,
94 struct acpi_buffer
*buffer
,
95 struct acpi_namespace_node
**return_node
)
98 struct acpi_namespace_node
*node
;
100 ACPI_FUNCTION_TRACE(rs_validate_parameters
);
103 * Must have a valid handle to an ACPI device
105 if (!device_handle
) {
106 return_ACPI_STATUS(AE_BAD_PARAMETER
);
109 node
= acpi_ns_validate_handle(device_handle
);
111 return_ACPI_STATUS(AE_BAD_PARAMETER
);
114 if (node
->type
!= ACPI_TYPE_DEVICE
) {
115 return_ACPI_STATUS(AE_TYPE
);
119 * Validate the user buffer object
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.
125 status
= acpi_ut_validate_buffer(buffer
);
126 if (ACPI_FAILURE(status
)) {
127 return_ACPI_STATUS(status
);
131 return_ACPI_STATUS(AE_OK
);
134 /*******************************************************************************
136 * FUNCTION: acpi_get_irq_routing_table
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
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.
149 * If the function fails an appropriate status will be returned
150 * and the value of ret_buffer is undefined.
152 * This function attempts to execute the _PRT method contained in
153 * the object indicated by the passed device_handle.
155 ******************************************************************************/
158 acpi_get_irq_routing_table(acpi_handle device_handle
,
159 struct acpi_buffer
*ret_buffer
)
162 struct acpi_namespace_node
*node
;
164 ACPI_FUNCTION_TRACE(acpi_get_irq_routing_table
);
166 /* Validate parameters then dispatch to internal routine */
168 status
= acpi_rs_validate_parameters(device_handle
, ret_buffer
, &node
);
169 if (ACPI_FAILURE(status
)) {
170 return_ACPI_STATUS(status
);
173 status
= acpi_rs_get_prt_method_data(node
, ret_buffer
);
174 return_ACPI_STATUS(status
);
177 ACPI_EXPORT_SYMBOL(acpi_get_irq_routing_table
)
179 /*******************************************************************************
181 * FUNCTION: acpi_get_current_resources
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
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.
195 * If the function fails an appropriate status will be returned
196 * and the value of ret_buffer is undefined.
198 * This function attempts to execute the _CRS method contained in
199 * the object indicated by the passed device_handle.
201 ******************************************************************************/
203 acpi_get_current_resources(acpi_handle device_handle
,
204 struct acpi_buffer
*ret_buffer
)
207 struct acpi_namespace_node
*node
;
209 ACPI_FUNCTION_TRACE(acpi_get_current_resources
);
211 /* Validate parameters then dispatch to internal routine */
213 status
= acpi_rs_validate_parameters(device_handle
, ret_buffer
, &node
);
214 if (ACPI_FAILURE(status
)) {
215 return_ACPI_STATUS(status
);
218 status
= acpi_rs_get_crs_method_data(node
, ret_buffer
);
219 return_ACPI_STATUS(status
);
222 ACPI_EXPORT_SYMBOL(acpi_get_current_resources
)
223 #ifdef ACPI_FUTURE_USAGE
224 /*******************************************************************************
226 * FUNCTION: acpi_get_possible_resources
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
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.
240 * If the function fails an appropriate status will be returned
241 * and the value of ret_buffer is undefined.
243 ******************************************************************************/
245 acpi_get_possible_resources(acpi_handle device_handle
,
246 struct acpi_buffer
*ret_buffer
)
249 struct acpi_namespace_node
*node
;
251 ACPI_FUNCTION_TRACE(acpi_get_possible_resources
);
253 /* Validate parameters then dispatch to internal routine */
255 status
= acpi_rs_validate_parameters(device_handle
, ret_buffer
, &node
);
256 if (ACPI_FAILURE(status
)) {
257 return_ACPI_STATUS(status
);
260 status
= acpi_rs_get_prs_method_data(node
, ret_buffer
);
261 return_ACPI_STATUS(status
);
264 ACPI_EXPORT_SYMBOL(acpi_get_possible_resources
)
265 #endif /* ACPI_FUTURE_USAGE */
266 /*******************************************************************************
268 * FUNCTION: acpi_set_current_resources
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
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.
282 ******************************************************************************/
284 acpi_set_current_resources(acpi_handle device_handle
,
285 struct acpi_buffer
*in_buffer
)
288 struct acpi_namespace_node
*node
;
290 ACPI_FUNCTION_TRACE(acpi_set_current_resources
);
292 /* Validate the buffer, don't allow zero length */
294 if ((!in_buffer
) || (!in_buffer
->pointer
) || (!in_buffer
->length
)) {
295 return_ACPI_STATUS(AE_BAD_PARAMETER
);
298 /* Validate parameters then dispatch to internal routine */
300 status
= acpi_rs_validate_parameters(device_handle
, in_buffer
, &node
);
301 if (ACPI_FAILURE(status
)) {
302 return_ACPI_STATUS(status
);
305 status
= acpi_rs_set_srs_method_data(node
, in_buffer
);
306 return_ACPI_STATUS(status
);
309 ACPI_EXPORT_SYMBOL(acpi_set_current_resources
)
311 /*******************************************************************************
313 * FUNCTION: acpi_get_event_resources
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
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
328 ******************************************************************************/
330 acpi_get_event_resources(acpi_handle device_handle
,
331 struct acpi_buffer
*ret_buffer
)
334 struct acpi_namespace_node
*node
;
336 ACPI_FUNCTION_TRACE(acpi_get_event_resources
);
338 /* Validate parameters then dispatch to internal routine */
340 status
= acpi_rs_validate_parameters(device_handle
, ret_buffer
, &node
);
341 if (ACPI_FAILURE(status
)) {
342 return_ACPI_STATUS(status
);
345 status
= acpi_rs_get_aei_method_data(node
, ret_buffer
);
346 return_ACPI_STATUS(status
);
349 ACPI_EXPORT_SYMBOL(acpi_get_event_resources
)
351 /******************************************************************************
353 * FUNCTION: acpi_resource_to_address64
355 * PARAMETERS: resource - Pointer to a resource
356 * out - Pointer to the users's return buffer
357 * (a struct acpi_resource_address64)
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
366 ******************************************************************************/
368 acpi_resource_to_address64(struct acpi_resource
*resource
,
369 struct acpi_resource_address64
*out
)
371 struct acpi_resource_address16
*address16
;
372 struct acpi_resource_address32
*address32
;
374 if (!resource
|| !out
) {
375 return (AE_BAD_PARAMETER
);
378 /* Convert 16 or 32 address descriptor to 64 */
380 switch (resource
->type
) {
381 case ACPI_RESOURCE_TYPE_ADDRESS16
:
384 ACPI_CAST_PTR(struct acpi_resource_address16
,
386 ACPI_COPY_ADDRESS(out
, address16
);
389 case ACPI_RESOURCE_TYPE_ADDRESS32
:
392 ACPI_CAST_PTR(struct acpi_resource_address32
,
394 ACPI_COPY_ADDRESS(out
, address32
);
397 case ACPI_RESOURCE_TYPE_ADDRESS64
:
399 /* Simple copy for 64 bit source */
401 ACPI_MEMCPY(out
, &resource
->data
,
402 sizeof(struct acpi_resource_address64
));
407 return (AE_BAD_PARAMETER
);
413 ACPI_EXPORT_SYMBOL(acpi_resource_to_address64
)
415 /*******************************************************************************
417 * FUNCTION: acpi_get_vendor_resource
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
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.
432 ******************************************************************************/
434 acpi_get_vendor_resource(acpi_handle device_handle
,
436 struct acpi_vendor_uuid
* uuid
,
437 struct acpi_buffer
* ret_buffer
)
439 struct acpi_vendor_walk_info info
;
442 /* Other parameters are validated by acpi_walk_resources */
444 if (!uuid
|| !ret_buffer
) {
445 return (AE_BAD_PARAMETER
);
449 info
.buffer
= ret_buffer
;
450 info
.status
= AE_NOT_EXIST
;
452 /* Walk the _CRS or _PRS resource list for this device */
455 acpi_walk_resources(device_handle
, name
,
456 acpi_rs_match_vendor_resource
, &info
);
457 if (ACPI_FAILURE(status
)) {
461 return (info
.status
);
464 ACPI_EXPORT_SYMBOL(acpi_get_vendor_resource
)
466 /*******************************************************************************
468 * FUNCTION: acpi_rs_match_vendor_resource
470 * PARAMETERS: acpi_walk_resource_callback
474 * DESCRIPTION: Match a vendor resource via the ACPI 3.0 UUID
476 ******************************************************************************/
478 acpi_rs_match_vendor_resource(struct acpi_resource
*resource
, void *context
)
480 struct acpi_vendor_walk_info
*info
= context
;
481 struct acpi_resource_vendor_typed
*vendor
;
482 struct acpi_buffer
*buffer
;
485 /* Ignore all descriptors except Vendor */
487 if (resource
->type
!= ACPI_RESOURCE_TYPE_VENDOR
) {
491 vendor
= &resource
->data
.vendor_typed
;
494 * For a valid match, these conditions must hold:
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
500 if ((vendor
->byte_length
< (ACPI_UUID_LENGTH
+ 1)) ||
501 (vendor
->uuid_subtype
!= info
->uuid
->subtype
) ||
502 (ACPI_MEMCMP(vendor
->uuid
, info
->uuid
->data
, ACPI_UUID_LENGTH
))) {
506 /* Validate/Allocate/Clear caller buffer */
508 buffer
= info
->buffer
;
509 status
= acpi_ut_initialize_buffer(buffer
, resource
->length
);
510 if (ACPI_FAILURE(status
)) {
514 /* Found the correct resource, copy and return it */
516 ACPI_MEMCPY(buffer
->pointer
, resource
, resource
->length
);
517 buffer
->length
= resource
->length
;
519 /* Found the desired descriptor, terminate resource walk */
521 info
->status
= AE_OK
;
522 return (AE_CTRL_TERMINATE
);
525 /*******************************************************************************
527 * FUNCTION: acpi_walk_resource_buffer
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
536 * DESCRIPTION: Walks the input resource template. The user_function is called
537 * once for each resource in the list.
539 ******************************************************************************/
542 acpi_walk_resource_buffer(struct acpi_buffer
* buffer
,
543 acpi_walk_resource_callback user_function
,
546 acpi_status status
= AE_OK
;
547 struct acpi_resource
*resource
;
548 struct acpi_resource
*resource_end
;
550 ACPI_FUNCTION_TRACE(acpi_walk_resource_buffer
);
552 /* Parameter validation */
554 if (!buffer
|| !buffer
->pointer
|| !user_function
) {
555 return_ACPI_STATUS(AE_BAD_PARAMETER
);
558 /* Buffer contains the resource list and length */
560 resource
= ACPI_CAST_PTR(struct acpi_resource
, buffer
->pointer
);
562 ACPI_ADD_PTR(struct acpi_resource
, buffer
->pointer
, buffer
->length
);
564 /* Walk the resource list until the end_tag is found (or buffer end) */
566 while (resource
< resource_end
) {
568 /* Sanity check the resource type */
570 if (resource
->type
> ACPI_RESOURCE_TYPE_MAX
) {
571 status
= AE_AML_INVALID_RESOURCE_TYPE
;
575 /* Sanity check the length. It must not be zero, or we loop forever */
577 if (!resource
->length
) {
578 return_ACPI_STATUS(AE_AML_BAD_RESOURCE_LENGTH
);
581 /* Invoke the user function, abort on any error returned */
583 status
= user_function(resource
, context
);
584 if (ACPI_FAILURE(status
)) {
585 if (status
== AE_CTRL_TERMINATE
) {
587 /* This is an OK termination by the user function */
594 /* end_tag indicates end-of-list */
596 if (resource
->type
== ACPI_RESOURCE_TYPE_END_TAG
) {
600 /* Get the next resource descriptor */
602 resource
= ACPI_NEXT_RESOURCE(resource
);
605 return_ACPI_STATUS(status
);
608 ACPI_EXPORT_SYMBOL(acpi_walk_resource_buffer
)
610 /*******************************************************************************
612 * FUNCTION: acpi_walk_resources
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
619 * user_function - Called for each resource
620 * context - Passed to user_function
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.
628 ******************************************************************************/
630 acpi_walk_resources(acpi_handle device_handle
,
632 acpi_walk_resource_callback user_function
, void *context
)
635 struct acpi_buffer buffer
;
637 ACPI_FUNCTION_TRACE(acpi_walk_resources
);
639 /* Parameter validation */
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
);
648 /* Get the _CRS/_PRS/_AEI resource list */
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
);
656 /* Walk the resource list and cleanup */
658 status
= acpi_walk_resource_buffer(&buffer
, user_function
, context
);
659 ACPI_FREE(buffer
.pointer
);
660 return_ACPI_STATUS(status
);
663 ACPI_EXPORT_SYMBOL(acpi_walk_resources
)