1 /******************************************************************************
3 * Module Name: uteval - Object evaluation
5 *****************************************************************************/
8 * Copyright (C) 2000 - 2005, 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
);
59 /*******************************************************************************
61 * FUNCTION: acpi_ut_osi_implementation
63 * PARAMETERS: walk_state - Current walk state
67 * DESCRIPTION: Implementation of _OSI predefined control method
68 * Supported = _OSI (String)
70 ******************************************************************************/
72 acpi_status
acpi_ut_osi_implementation(struct acpi_walk_state
*walk_state
)
74 union acpi_operand_object
*string_desc
;
75 union acpi_operand_object
*return_desc
;
78 ACPI_FUNCTION_TRACE("ut_osi_implementation");
80 /* Validate the string input argument */
82 string_desc
= walk_state
->arguments
[0].object
;
83 if (!string_desc
|| (string_desc
->common
.type
!= ACPI_TYPE_STRING
)) {
84 return_ACPI_STATUS(AE_TYPE
);
87 /* Create a return object (Default value = 0) */
89 return_desc
= acpi_ut_create_internal_object(ACPI_TYPE_INTEGER
);
91 return_ACPI_STATUS(AE_NO_MEMORY
);
94 /* Compare input string to table of supported strings */
96 for (i
= 0; i
< ACPI_NUM_OSI_STRINGS
; i
++) {
97 if (!ACPI_STRCMP(string_desc
->string
.pointer
,
99 acpi_gbl_valid_osi_strings
[i
])))
101 /* This string is supported */
103 return_desc
->integer
.value
= 0xFFFFFFFF;
108 walk_state
->return_desc
= return_desc
;
109 return_ACPI_STATUS(AE_CTRL_TERMINATE
);
112 /*******************************************************************************
114 * FUNCTION: acpi_ut_evaluate_object
116 * PARAMETERS: prefix_node - Starting node
117 * Path - Path to object from starting node
118 * expected_return_types - Bitmap of allowed return types
119 * return_desc - Where a return value is stored
123 * DESCRIPTION: Evaluates a namespace object and verifies the type of the
124 * return object. Common code that simplifies accessing objects
125 * that have required return objects of fixed types.
127 * NOTE: Internal function, no parameter validation
129 ******************************************************************************/
132 acpi_ut_evaluate_object(struct acpi_namespace_node
*prefix_node
,
134 u32 expected_return_btypes
,
135 union acpi_operand_object
**return_desc
)
137 struct acpi_parameter_info info
;
141 ACPI_FUNCTION_TRACE("ut_evaluate_object");
143 info
.node
= prefix_node
;
144 info
.parameters
= NULL
;
145 info
.parameter_type
= ACPI_PARAM_ARGS
;
147 /* Evaluate the object/method */
149 status
= acpi_ns_evaluate_relative(path
, &info
);
150 if (ACPI_FAILURE(status
)) {
151 if (status
== AE_NOT_FOUND
) {
152 ACPI_DEBUG_PRINT((ACPI_DB_EXEC
,
153 "[%4.4s.%s] was not found\n",
154 acpi_ut_get_node_name(prefix_node
),
157 ACPI_REPORT_METHOD_ERROR("Method execution failed",
158 prefix_node
, path
, status
);
161 return_ACPI_STATUS(status
);
164 /* Did we get a return object? */
166 if (!info
.return_object
) {
167 if (expected_return_btypes
) {
168 ACPI_REPORT_METHOD_ERROR("No object was returned from",
172 return_ACPI_STATUS(AE_NOT_EXIST
);
175 return_ACPI_STATUS(AE_OK
);
178 /* Map the return object type to the bitmapped type */
180 switch (ACPI_GET_OBJECT_TYPE(info
.return_object
)) {
181 case ACPI_TYPE_INTEGER
:
182 return_btype
= ACPI_BTYPE_INTEGER
;
185 case ACPI_TYPE_BUFFER
:
186 return_btype
= ACPI_BTYPE_BUFFER
;
189 case ACPI_TYPE_STRING
:
190 return_btype
= ACPI_BTYPE_STRING
;
193 case ACPI_TYPE_PACKAGE
:
194 return_btype
= ACPI_BTYPE_PACKAGE
;
202 if ((acpi_gbl_enable_interpreter_slack
) && (!expected_return_btypes
)) {
204 * We received a return object, but one was not expected. This can
205 * happen frequently if the "implicit return" feature is enabled.
206 * Just delete the return object and return AE_OK.
208 acpi_ut_remove_reference(info
.return_object
);
209 return_ACPI_STATUS(AE_OK
);
212 /* Is the return object one of the expected types? */
214 if (!(expected_return_btypes
& return_btype
)) {
215 ACPI_REPORT_METHOD_ERROR("Return object type is incorrect",
216 prefix_node
, path
, AE_TYPE
);
218 ACPI_DEBUG_PRINT((ACPI_DB_ERROR
,
219 "Type returned from %s was incorrect: %s, expected Btypes: %X\n",
221 acpi_ut_get_object_type_name(info
.
223 expected_return_btypes
));
225 /* On error exit, we must delete the return object */
227 acpi_ut_remove_reference(info
.return_object
);
228 return_ACPI_STATUS(AE_TYPE
);
231 /* Object type is OK, return it */
233 *return_desc
= info
.return_object
;
234 return_ACPI_STATUS(AE_OK
);
237 /*******************************************************************************
239 * FUNCTION: acpi_ut_evaluate_numeric_object
241 * PARAMETERS: object_name - Object name to be evaluated
242 * device_node - Node for the device
243 * Address - Where the value is returned
247 * DESCRIPTION: Evaluates a numeric namespace object for a selected device
248 * and stores result in *Address.
250 * NOTE: Internal function, no parameter validation
252 ******************************************************************************/
255 acpi_ut_evaluate_numeric_object(char *object_name
,
256 struct acpi_namespace_node
*device_node
,
257 acpi_integer
* address
)
259 union acpi_operand_object
*obj_desc
;
262 ACPI_FUNCTION_TRACE("ut_evaluate_numeric_object");
264 status
= acpi_ut_evaluate_object(device_node
, object_name
,
265 ACPI_BTYPE_INTEGER
, &obj_desc
);
266 if (ACPI_FAILURE(status
)) {
267 return_ACPI_STATUS(status
);
270 /* Get the returned Integer */
272 *address
= obj_desc
->integer
.value
;
274 /* On exit, we must delete the return object */
276 acpi_ut_remove_reference(obj_desc
);
277 return_ACPI_STATUS(status
);
280 /*******************************************************************************
282 * FUNCTION: acpi_ut_copy_id_string
284 * PARAMETERS: Destination - Where to copy the string
285 * Source - Source string
286 * max_length - Length of the destination buffer
290 * DESCRIPTION: Copies an ID string for the _HID, _CID, and _UID methods.
291 * Performs removal of a leading asterisk if present -- workaround
292 * for a known issue on a bunch of machines.
294 ******************************************************************************/
297 acpi_ut_copy_id_string(char *destination
, char *source
, acpi_size max_length
)
301 * Workaround for ID strings that have a leading asterisk. This construct
302 * is not allowed by the ACPI specification (ID strings must be
303 * alphanumeric), but enough existing machines have this embedded in their
304 * ID strings that the following code is useful.
306 if (*source
== '*') {
310 /* Do the actual copy */
312 ACPI_STRNCPY(destination
, source
, max_length
);
315 /*******************************************************************************
317 * FUNCTION: acpi_ut_execute_HID
319 * PARAMETERS: device_node - Node for the device
320 * Hid - Where the HID is returned
324 * DESCRIPTION: Executes the _HID control method that returns the hardware
327 * NOTE: Internal function, no parameter validation
329 ******************************************************************************/
332 acpi_ut_execute_HID(struct acpi_namespace_node
*device_node
,
333 struct acpi_device_id
*hid
)
335 union acpi_operand_object
*obj_desc
;
338 ACPI_FUNCTION_TRACE("ut_execute_HID");
340 status
= acpi_ut_evaluate_object(device_node
, METHOD_NAME__HID
,
341 ACPI_BTYPE_INTEGER
| ACPI_BTYPE_STRING
,
343 if (ACPI_FAILURE(status
)) {
344 return_ACPI_STATUS(status
);
347 if (ACPI_GET_OBJECT_TYPE(obj_desc
) == ACPI_TYPE_INTEGER
) {
348 /* Convert the Numeric HID to string */
350 acpi_ex_eisa_id_to_string((u32
) obj_desc
->integer
.value
,
353 /* Copy the String HID from the returned object */
355 acpi_ut_copy_id_string(hid
->value
, obj_desc
->string
.pointer
,
359 /* On exit, we must delete the return object */
361 acpi_ut_remove_reference(obj_desc
);
362 return_ACPI_STATUS(status
);
365 /*******************************************************************************
367 * FUNCTION: acpi_ut_translate_one_cid
369 * PARAMETERS: obj_desc - _CID object, must be integer or string
370 * one_cid - Where the CID string is returned
374 * DESCRIPTION: Return a numeric or string _CID value as a string.
377 * NOTE: Assumes a maximum _CID string length of
378 * ACPI_MAX_CID_LENGTH.
380 ******************************************************************************/
383 acpi_ut_translate_one_cid(union acpi_operand_object
*obj_desc
,
384 struct acpi_compatible_id
*one_cid
)
387 switch (ACPI_GET_OBJECT_TYPE(obj_desc
)) {
388 case ACPI_TYPE_INTEGER
:
390 /* Convert the Numeric CID to string */
392 acpi_ex_eisa_id_to_string((u32
) obj_desc
->integer
.value
,
396 case ACPI_TYPE_STRING
:
398 if (obj_desc
->string
.length
> ACPI_MAX_CID_LENGTH
) {
399 return (AE_AML_STRING_LIMIT
);
402 /* Copy the String CID from the returned object */
404 acpi_ut_copy_id_string(one_cid
->value
, obj_desc
->string
.pointer
,
405 ACPI_MAX_CID_LENGTH
);
414 /*******************************************************************************
416 * FUNCTION: acpi_ut_execute_CID
418 * PARAMETERS: device_node - Node for the device
419 * return_cid_list - Where the CID list is returned
423 * DESCRIPTION: Executes the _CID control method that returns one or more
424 * compatible hardware IDs for the device.
426 * NOTE: Internal function, no parameter validation
428 ******************************************************************************/
431 acpi_ut_execute_CID(struct acpi_namespace_node
* device_node
,
432 struct acpi_compatible_id_list
** return_cid_list
)
434 union acpi_operand_object
*obj_desc
;
438 struct acpi_compatible_id_list
*cid_list
;
441 ACPI_FUNCTION_TRACE("ut_execute_CID");
443 /* Evaluate the _CID method for this device */
445 status
= acpi_ut_evaluate_object(device_node
, METHOD_NAME__CID
,
446 ACPI_BTYPE_INTEGER
| ACPI_BTYPE_STRING
447 | ACPI_BTYPE_PACKAGE
, &obj_desc
);
448 if (ACPI_FAILURE(status
)) {
449 return_ACPI_STATUS(status
);
452 /* Get the number of _CIDs returned */
455 if (ACPI_GET_OBJECT_TYPE(obj_desc
) == ACPI_TYPE_PACKAGE
) {
456 count
= obj_desc
->package
.count
;
459 /* Allocate a worst-case buffer for the _CIDs */
461 size
= (((count
- 1) * sizeof(struct acpi_compatible_id
)) +
462 sizeof(struct acpi_compatible_id_list
));
464 cid_list
= ACPI_MEM_CALLOCATE((acpi_size
) size
);
466 return_ACPI_STATUS(AE_NO_MEMORY
);
471 cid_list
->count
= count
;
472 cid_list
->size
= size
;
475 * A _CID can return either a single compatible ID or a package of
476 * compatible IDs. Each compatible ID can be one of the following:
477 * 1) Integer (32 bit compressed EISA ID) or
478 * 2) String (PCI ID format, e.g. "PCI\VEN_vvvv&DEV_dddd&SUBSYS_ssssssss")
481 /* The _CID object can be either a single CID or a package (list) of CIDs */
483 if (ACPI_GET_OBJECT_TYPE(obj_desc
) == ACPI_TYPE_PACKAGE
) {
484 /* Translate each package element */
486 for (i
= 0; i
< count
; i
++) {
488 acpi_ut_translate_one_cid(obj_desc
->package
.
491 if (ACPI_FAILURE(status
)) {
496 /* Only one CID, translate to a string */
498 status
= acpi_ut_translate_one_cid(obj_desc
, cid_list
->id
);
501 /* Cleanup on error */
503 if (ACPI_FAILURE(status
)) {
504 ACPI_MEM_FREE(cid_list
);
506 *return_cid_list
= cid_list
;
509 /* On exit, we must delete the _CID return object */
511 acpi_ut_remove_reference(obj_desc
);
512 return_ACPI_STATUS(status
);
515 /*******************************************************************************
517 * FUNCTION: acpi_ut_execute_UID
519 * PARAMETERS: device_node - Node for the device
520 * Uid - Where the UID is returned
524 * DESCRIPTION: Executes the _UID control method that returns the hardware
527 * NOTE: Internal function, no parameter validation
529 ******************************************************************************/
532 acpi_ut_execute_UID(struct acpi_namespace_node
*device_node
,
533 struct acpi_device_id
*uid
)
535 union acpi_operand_object
*obj_desc
;
538 ACPI_FUNCTION_TRACE("ut_execute_UID");
540 status
= acpi_ut_evaluate_object(device_node
, METHOD_NAME__UID
,
541 ACPI_BTYPE_INTEGER
| ACPI_BTYPE_STRING
,
543 if (ACPI_FAILURE(status
)) {
544 return_ACPI_STATUS(status
);
547 if (ACPI_GET_OBJECT_TYPE(obj_desc
) == ACPI_TYPE_INTEGER
) {
548 /* Convert the Numeric UID to string */
550 acpi_ex_unsigned_integer_to_string(obj_desc
->integer
.value
,
553 /* Copy the String UID from the returned object */
555 acpi_ut_copy_id_string(uid
->value
, obj_desc
->string
.pointer
,
559 /* On exit, we must delete the return object */
561 acpi_ut_remove_reference(obj_desc
);
562 return_ACPI_STATUS(status
);
565 /*******************************************************************************
567 * FUNCTION: acpi_ut_execute_STA
569 * PARAMETERS: device_node - Node for the device
570 * Flags - Where the status flags are returned
574 * DESCRIPTION: Executes _STA for selected device and stores results in
577 * NOTE: Internal function, no parameter validation
579 ******************************************************************************/
582 acpi_ut_execute_STA(struct acpi_namespace_node
*device_node
, u32
* flags
)
584 union acpi_operand_object
*obj_desc
;
587 ACPI_FUNCTION_TRACE("ut_execute_STA");
589 status
= acpi_ut_evaluate_object(device_node
, METHOD_NAME__STA
,
590 ACPI_BTYPE_INTEGER
, &obj_desc
);
591 if (ACPI_FAILURE(status
)) {
592 if (AE_NOT_FOUND
== status
) {
593 ACPI_DEBUG_PRINT((ACPI_DB_EXEC
,
594 "_STA on %4.4s was not found, assuming device is present\n",
595 acpi_ut_get_node_name(device_node
)));
597 *flags
= ACPI_UINT32_MAX
;
601 return_ACPI_STATUS(status
);
604 /* Extract the status flags */
606 *flags
= (u32
) obj_desc
->integer
.value
;
608 /* On exit, we must delete the return object */
610 acpi_ut_remove_reference(obj_desc
);
611 return_ACPI_STATUS(status
);
614 /*******************************************************************************
616 * FUNCTION: acpi_ut_execute_Sxds
618 * PARAMETERS: device_node - Node for the device
619 * Flags - Where the status flags are returned
623 * DESCRIPTION: Executes _STA for selected device and stores results in
626 * NOTE: Internal function, no parameter validation
628 ******************************************************************************/
631 acpi_ut_execute_sxds(struct acpi_namespace_node
*device_node
, u8
* highest
)
633 union acpi_operand_object
*obj_desc
;
637 ACPI_FUNCTION_TRACE("ut_execute_Sxds");
639 for (i
= 0; i
< 4; i
++) {
641 status
= acpi_ut_evaluate_object(device_node
,
643 acpi_gbl_highest_dstate_names
645 ACPI_BTYPE_INTEGER
, &obj_desc
);
646 if (ACPI_FAILURE(status
)) {
647 if (status
!= AE_NOT_FOUND
) {
648 ACPI_DEBUG_PRINT((ACPI_DB_EXEC
,
649 "%s on Device %4.4s, %s\n",
651 acpi_gbl_highest_dstate_names
653 acpi_ut_get_node_name
655 acpi_format_exception
658 return_ACPI_STATUS(status
);
661 /* Extract the Dstate value */
663 highest
[i
] = (u8
) obj_desc
->integer
.value
;
665 /* Delete the return object */
667 acpi_ut_remove_reference(obj_desc
);
671 return_ACPI_STATUS(AE_OK
);