1 /******************************************************************************
3 * Module Name: uteval - Object evaluation
5 *****************************************************************************/
8 * Copyright (C) 2000 - 2007, R. Byron Moore
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 #include <acpi/acpi.h>
45 #include <acpi/acnamesp.h>
46 #include <acpi/acinterp.h>
48 #define _COMPONENT ACPI_UTILITIES
49 ACPI_MODULE_NAME("uteval")
51 /* Local prototypes */
53 acpi_ut_copy_id_string(char *destination
, char *source
, acpi_size max_length
);
56 acpi_ut_translate_one_cid(union acpi_operand_object
*obj_desc
,
57 struct acpi_compatible_id
*one_cid
);
60 * Strings supported by the _OSI predefined (internal) method.
62 static char *acpi_interfaces_supported
[] = {
63 /* Operating System Vendor Strings */
74 "Windows 2001.1 SP1", /* Added 03/2006 */
75 "Windows 2006", /* Added 03/2006 */
77 /* Feature Group Strings */
79 "Extended Address Space Descriptor"
81 * All "optional" feature group strings (features that are implemented
82 * by the host) should be implemented in the host version of
83 * acpi_os_validate_interface and should not be added here.
87 /*******************************************************************************
89 * FUNCTION: acpi_ut_osi_implementation
91 * PARAMETERS: walk_state - Current walk state
95 * DESCRIPTION: Implementation of the _OSI predefined control method
97 ******************************************************************************/
99 acpi_status
acpi_ut_osi_implementation(struct acpi_walk_state
*walk_state
)
102 union acpi_operand_object
*string_desc
;
103 union acpi_operand_object
*return_desc
;
106 ACPI_FUNCTION_TRACE(ut_osi_implementation
);
108 /* Validate the string input argument */
110 string_desc
= walk_state
->arguments
[0].object
;
111 if (!string_desc
|| (string_desc
->common
.type
!= ACPI_TYPE_STRING
)) {
112 return_ACPI_STATUS(AE_TYPE
);
115 /* Create a return object */
117 return_desc
= acpi_ut_create_internal_object(ACPI_TYPE_INTEGER
);
119 return_ACPI_STATUS(AE_NO_MEMORY
);
122 /* Default return value is SUPPORTED */
124 return_desc
->integer
.value
= ACPI_UINT32_MAX
;
125 walk_state
->return_desc
= return_desc
;
127 /* Compare input string to static table of supported interfaces */
129 for (i
= 0; i
< ACPI_ARRAY_LENGTH(acpi_interfaces_supported
); i
++) {
131 (string_desc
->string
.pointer
,
132 acpi_interfaces_supported
[i
])) {
134 /* The interface is supported */
136 return_ACPI_STATUS(AE_CTRL_TERMINATE
);
141 * Did not match the string in the static table, call the host OSL to
142 * check for a match with one of the optional strings (such as
143 * "Module Device", "3.0 Thermal Model", etc.)
145 status
= acpi_os_validate_interface(string_desc
->string
.pointer
);
146 if (ACPI_SUCCESS(status
)) {
148 /* The interface is supported */
150 return_ACPI_STATUS(AE_CTRL_TERMINATE
);
153 /* The interface is not supported */
155 return_desc
->integer
.value
= 0;
156 return_ACPI_STATUS(AE_CTRL_TERMINATE
);
159 /*******************************************************************************
161 * FUNCTION: acpi_osi_invalidate
163 * PARAMETERS: interface_string
167 * DESCRIPTION: invalidate string in pre-defiend _OSI string list
169 ******************************************************************************/
171 acpi_status
acpi_osi_invalidate(char *interface
)
175 for (i
= 0; i
< ACPI_ARRAY_LENGTH(acpi_interfaces_supported
); i
++) {
176 if (!ACPI_STRCMP(interface
, acpi_interfaces_supported
[i
])) {
177 *acpi_interfaces_supported
[i
] = '\0';
184 /*******************************************************************************
186 * FUNCTION: acpi_ut_evaluate_object
188 * PARAMETERS: prefix_node - Starting node
189 * Path - Path to object from starting node
190 * expected_return_types - Bitmap of allowed return types
191 * return_desc - Where a return value is stored
195 * DESCRIPTION: Evaluates a namespace object and verifies the type of the
196 * return object. Common code that simplifies accessing objects
197 * that have required return objects of fixed types.
199 * NOTE: Internal function, no parameter validation
201 ******************************************************************************/
204 acpi_ut_evaluate_object(struct acpi_namespace_node
*prefix_node
,
206 u32 expected_return_btypes
,
207 union acpi_operand_object
**return_desc
)
209 struct acpi_evaluate_info
*info
;
213 ACPI_FUNCTION_TRACE(ut_evaluate_object
);
215 /* Allocate the evaluation information block */
217 info
= ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info
));
219 return_ACPI_STATUS(AE_NO_MEMORY
);
222 info
->prefix_node
= prefix_node
;
223 info
->pathname
= path
;
224 info
->parameter_type
= ACPI_PARAM_ARGS
;
226 /* Evaluate the object/method */
228 status
= acpi_ns_evaluate(info
);
229 if (ACPI_FAILURE(status
)) {
230 if (status
== AE_NOT_FOUND
) {
231 ACPI_DEBUG_PRINT((ACPI_DB_EXEC
,
232 "[%4.4s.%s] was not found\n",
233 acpi_ut_get_node_name(prefix_node
),
236 ACPI_ERROR_METHOD("Method execution failed",
237 prefix_node
, path
, status
);
243 /* Did we get a return object? */
245 if (!info
->return_object
) {
246 if (expected_return_btypes
) {
247 ACPI_ERROR_METHOD("No object was returned from",
248 prefix_node
, path
, AE_NOT_EXIST
);
250 status
= AE_NOT_EXIST
;
256 /* Map the return object type to the bitmapped type */
258 switch (ACPI_GET_OBJECT_TYPE(info
->return_object
)) {
259 case ACPI_TYPE_INTEGER
:
260 return_btype
= ACPI_BTYPE_INTEGER
;
263 case ACPI_TYPE_BUFFER
:
264 return_btype
= ACPI_BTYPE_BUFFER
;
267 case ACPI_TYPE_STRING
:
268 return_btype
= ACPI_BTYPE_STRING
;
271 case ACPI_TYPE_PACKAGE
:
272 return_btype
= ACPI_BTYPE_PACKAGE
;
280 if ((acpi_gbl_enable_interpreter_slack
) && (!expected_return_btypes
)) {
282 * We received a return object, but one was not expected. This can
283 * happen frequently if the "implicit return" feature is enabled.
284 * Just delete the return object and return AE_OK.
286 acpi_ut_remove_reference(info
->return_object
);
290 /* Is the return object one of the expected types? */
292 if (!(expected_return_btypes
& return_btype
)) {
293 ACPI_ERROR_METHOD("Return object type is incorrect",
294 prefix_node
, path
, AE_TYPE
);
297 "Type returned from %s was incorrect: %s, expected Btypes: %X",
299 acpi_ut_get_object_type_name(info
->return_object
),
300 expected_return_btypes
));
302 /* On error exit, we must delete the return object */
304 acpi_ut_remove_reference(info
->return_object
);
309 /* Object type is OK, return it */
311 *return_desc
= info
->return_object
;
315 return_ACPI_STATUS(status
);
318 /*******************************************************************************
320 * FUNCTION: acpi_ut_evaluate_numeric_object
322 * PARAMETERS: object_name - Object name to be evaluated
323 * device_node - Node for the device
324 * Address - Where the value is returned
328 * DESCRIPTION: Evaluates a numeric namespace object for a selected device
329 * and stores result in *Address.
331 * NOTE: Internal function, no parameter validation
333 ******************************************************************************/
336 acpi_ut_evaluate_numeric_object(char *object_name
,
337 struct acpi_namespace_node
*device_node
,
338 acpi_integer
* address
)
340 union acpi_operand_object
*obj_desc
;
343 ACPI_FUNCTION_TRACE(ut_evaluate_numeric_object
);
345 status
= acpi_ut_evaluate_object(device_node
, object_name
,
346 ACPI_BTYPE_INTEGER
, &obj_desc
);
347 if (ACPI_FAILURE(status
)) {
348 return_ACPI_STATUS(status
);
351 /* Get the returned Integer */
353 *address
= obj_desc
->integer
.value
;
355 /* On exit, we must delete the return object */
357 acpi_ut_remove_reference(obj_desc
);
358 return_ACPI_STATUS(status
);
361 /*******************************************************************************
363 * FUNCTION: acpi_ut_copy_id_string
365 * PARAMETERS: Destination - Where to copy the string
366 * Source - Source string
367 * max_length - Length of the destination buffer
371 * DESCRIPTION: Copies an ID string for the _HID, _CID, and _UID methods.
372 * Performs removal of a leading asterisk if present -- workaround
373 * for a known issue on a bunch of machines.
375 ******************************************************************************/
378 acpi_ut_copy_id_string(char *destination
, char *source
, acpi_size max_length
)
382 * Workaround for ID strings that have a leading asterisk. This construct
383 * is not allowed by the ACPI specification (ID strings must be
384 * alphanumeric), but enough existing machines have this embedded in their
385 * ID strings that the following code is useful.
387 if (*source
== '*') {
391 /* Do the actual copy */
393 ACPI_STRNCPY(destination
, source
, max_length
);
396 /*******************************************************************************
398 * FUNCTION: acpi_ut_execute_HID
400 * PARAMETERS: device_node - Node for the device
401 * Hid - Where the HID is returned
405 * DESCRIPTION: Executes the _HID control method that returns the hardware
408 * NOTE: Internal function, no parameter validation
410 ******************************************************************************/
413 acpi_ut_execute_HID(struct acpi_namespace_node
*device_node
,
414 struct acpi_device_id
*hid
)
416 union acpi_operand_object
*obj_desc
;
419 ACPI_FUNCTION_TRACE(ut_execute_HID
);
421 status
= acpi_ut_evaluate_object(device_node
, METHOD_NAME__HID
,
422 ACPI_BTYPE_INTEGER
| ACPI_BTYPE_STRING
,
424 if (ACPI_FAILURE(status
)) {
425 return_ACPI_STATUS(status
);
428 if (ACPI_GET_OBJECT_TYPE(obj_desc
) == ACPI_TYPE_INTEGER
) {
430 /* Convert the Numeric HID to string */
432 acpi_ex_eisa_id_to_string((u32
) obj_desc
->integer
.value
,
435 /* Copy the String HID from the returned object */
437 acpi_ut_copy_id_string(hid
->value
, obj_desc
->string
.pointer
,
441 /* On exit, we must delete the return object */
443 acpi_ut_remove_reference(obj_desc
);
444 return_ACPI_STATUS(status
);
447 /*******************************************************************************
449 * FUNCTION: acpi_ut_translate_one_cid
451 * PARAMETERS: obj_desc - _CID object, must be integer or string
452 * one_cid - Where the CID string is returned
456 * DESCRIPTION: Return a numeric or string _CID value as a string.
459 * NOTE: Assumes a maximum _CID string length of
460 * ACPI_MAX_CID_LENGTH.
462 ******************************************************************************/
465 acpi_ut_translate_one_cid(union acpi_operand_object
*obj_desc
,
466 struct acpi_compatible_id
*one_cid
)
469 switch (ACPI_GET_OBJECT_TYPE(obj_desc
)) {
470 case ACPI_TYPE_INTEGER
:
472 /* Convert the Numeric CID to string */
474 acpi_ex_eisa_id_to_string((u32
) obj_desc
->integer
.value
,
478 case ACPI_TYPE_STRING
:
480 if (obj_desc
->string
.length
> ACPI_MAX_CID_LENGTH
) {
481 return (AE_AML_STRING_LIMIT
);
484 /* Copy the String CID from the returned object */
486 acpi_ut_copy_id_string(one_cid
->value
, obj_desc
->string
.pointer
,
487 ACPI_MAX_CID_LENGTH
);
496 /*******************************************************************************
498 * FUNCTION: acpi_ut_execute_CID
500 * PARAMETERS: device_node - Node for the device
501 * return_cid_list - Where the CID list is returned
505 * DESCRIPTION: Executes the _CID control method that returns one or more
506 * compatible hardware IDs for the device.
508 * NOTE: Internal function, no parameter validation
510 ******************************************************************************/
513 acpi_ut_execute_CID(struct acpi_namespace_node
* device_node
,
514 struct acpi_compatible_id_list
** return_cid_list
)
516 union acpi_operand_object
*obj_desc
;
520 struct acpi_compatible_id_list
*cid_list
;
523 ACPI_FUNCTION_TRACE(ut_execute_CID
);
525 /* Evaluate the _CID method for this device */
527 status
= acpi_ut_evaluate_object(device_node
, METHOD_NAME__CID
,
528 ACPI_BTYPE_INTEGER
| ACPI_BTYPE_STRING
529 | ACPI_BTYPE_PACKAGE
, &obj_desc
);
530 if (ACPI_FAILURE(status
)) {
531 return_ACPI_STATUS(status
);
534 /* Get the number of _CIDs returned */
537 if (ACPI_GET_OBJECT_TYPE(obj_desc
) == ACPI_TYPE_PACKAGE
) {
538 count
= obj_desc
->package
.count
;
541 /* Allocate a worst-case buffer for the _CIDs */
543 size
= (((count
- 1) * sizeof(struct acpi_compatible_id
)) +
544 sizeof(struct acpi_compatible_id_list
));
546 cid_list
= ACPI_ALLOCATE_ZEROED((acpi_size
) size
);
548 return_ACPI_STATUS(AE_NO_MEMORY
);
553 cid_list
->count
= count
;
554 cid_list
->size
= size
;
557 * A _CID can return either a single compatible ID or a package of
558 * compatible IDs. Each compatible ID can be one of the following:
559 * 1) Integer (32 bit compressed EISA ID) or
560 * 2) String (PCI ID format, e.g. "PCI\VEN_vvvv&DEV_dddd&SUBSYS_ssssssss")
563 /* The _CID object can be either a single CID or a package (list) of CIDs */
565 if (ACPI_GET_OBJECT_TYPE(obj_desc
) == ACPI_TYPE_PACKAGE
) {
567 /* Translate each package element */
569 for (i
= 0; i
< count
; i
++) {
571 acpi_ut_translate_one_cid(obj_desc
->package
.
574 if (ACPI_FAILURE(status
)) {
579 /* Only one CID, translate to a string */
581 status
= acpi_ut_translate_one_cid(obj_desc
, cid_list
->id
);
584 /* Cleanup on error */
586 if (ACPI_FAILURE(status
)) {
589 *return_cid_list
= cid_list
;
592 /* On exit, we must delete the _CID return object */
594 acpi_ut_remove_reference(obj_desc
);
595 return_ACPI_STATUS(status
);
598 /*******************************************************************************
600 * FUNCTION: acpi_ut_execute_UID
602 * PARAMETERS: device_node - Node for the device
603 * Uid - Where the UID is returned
607 * DESCRIPTION: Executes the _UID control method that returns the hardware
610 * NOTE: Internal function, no parameter validation
612 ******************************************************************************/
615 acpi_ut_execute_UID(struct acpi_namespace_node
*device_node
,
616 struct acpi_device_id
*uid
)
618 union acpi_operand_object
*obj_desc
;
621 ACPI_FUNCTION_TRACE(ut_execute_UID
);
623 status
= acpi_ut_evaluate_object(device_node
, METHOD_NAME__UID
,
624 ACPI_BTYPE_INTEGER
| ACPI_BTYPE_STRING
,
626 if (ACPI_FAILURE(status
)) {
627 return_ACPI_STATUS(status
);
630 if (ACPI_GET_OBJECT_TYPE(obj_desc
) == ACPI_TYPE_INTEGER
) {
632 /* Convert the Numeric UID to string */
634 acpi_ex_unsigned_integer_to_string(obj_desc
->integer
.value
,
637 /* Copy the String UID from the returned object */
639 acpi_ut_copy_id_string(uid
->value
, obj_desc
->string
.pointer
,
643 /* On exit, we must delete the return object */
645 acpi_ut_remove_reference(obj_desc
);
646 return_ACPI_STATUS(status
);
649 /*******************************************************************************
651 * FUNCTION: acpi_ut_execute_STA
653 * PARAMETERS: device_node - Node for the device
654 * Flags - Where the status flags are returned
658 * DESCRIPTION: Executes _STA for selected device and stores results in
661 * NOTE: Internal function, no parameter validation
663 ******************************************************************************/
666 acpi_ut_execute_STA(struct acpi_namespace_node
*device_node
, u32
* flags
)
668 union acpi_operand_object
*obj_desc
;
671 ACPI_FUNCTION_TRACE(ut_execute_STA
);
673 status
= acpi_ut_evaluate_object(device_node
, METHOD_NAME__STA
,
674 ACPI_BTYPE_INTEGER
, &obj_desc
);
675 if (ACPI_FAILURE(status
)) {
676 if (AE_NOT_FOUND
== status
) {
677 ACPI_DEBUG_PRINT((ACPI_DB_EXEC
,
678 "_STA on %4.4s was not found, assuming device is present\n",
679 acpi_ut_get_node_name(device_node
)));
681 *flags
= ACPI_UINT32_MAX
;
685 return_ACPI_STATUS(status
);
688 /* Extract the status flags */
690 *flags
= (u32
) obj_desc
->integer
.value
;
692 /* On exit, we must delete the return object */
694 acpi_ut_remove_reference(obj_desc
);
695 return_ACPI_STATUS(status
);
698 /*******************************************************************************
700 * FUNCTION: acpi_ut_execute_Sxds
702 * PARAMETERS: device_node - Node for the device
703 * Flags - Where the status flags are returned
707 * DESCRIPTION: Executes _STA for selected device and stores results in
710 * NOTE: Internal function, no parameter validation
712 ******************************************************************************/
715 acpi_ut_execute_sxds(struct acpi_namespace_node
*device_node
, u8
* highest
)
717 union acpi_operand_object
*obj_desc
;
721 ACPI_FUNCTION_TRACE(ut_execute_sxds
);
723 for (i
= 0; i
< 4; i
++) {
725 status
= acpi_ut_evaluate_object(device_node
,
727 acpi_gbl_highest_dstate_names
729 ACPI_BTYPE_INTEGER
, &obj_desc
);
730 if (ACPI_FAILURE(status
)) {
731 if (status
!= AE_NOT_FOUND
) {
732 ACPI_DEBUG_PRINT((ACPI_DB_EXEC
,
733 "%s on Device %4.4s, %s\n",
735 acpi_gbl_highest_dstate_names
737 acpi_ut_get_node_name
739 acpi_format_exception
742 return_ACPI_STATUS(status
);
745 /* Extract the Dstate value */
747 highest
[i
] = (u8
) obj_desc
->integer
.value
;
749 /* Delete the return object */
751 acpi_ut_remove_reference(obj_desc
);
755 return_ACPI_STATUS(AE_OK
);