1 /******************************************************************************
3 * Module Name: uteval - Object evaluation
5 *****************************************************************************/
8 * Copyright (C) 2000 - 2006, 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
])))
102 /* This string is supported */
104 return_desc
->integer
.value
= 0xFFFFFFFF;
109 walk_state
->return_desc
= return_desc
;
110 return_ACPI_STATUS(AE_CTRL_TERMINATE
);
113 /*******************************************************************************
115 * FUNCTION: acpi_ut_evaluate_object
117 * PARAMETERS: prefix_node - Starting node
118 * Path - Path to object from starting node
119 * expected_return_types - Bitmap of allowed return types
120 * return_desc - Where a return value is stored
124 * DESCRIPTION: Evaluates a namespace object and verifies the type of the
125 * return object. Common code that simplifies accessing objects
126 * that have required return objects of fixed types.
128 * NOTE: Internal function, no parameter validation
130 ******************************************************************************/
133 acpi_ut_evaluate_object(struct acpi_namespace_node
*prefix_node
,
135 u32 expected_return_btypes
,
136 union acpi_operand_object
**return_desc
)
138 struct acpi_parameter_info info
;
142 ACPI_FUNCTION_TRACE("ut_evaluate_object");
144 info
.node
= prefix_node
;
145 info
.parameters
= NULL
;
146 info
.parameter_type
= ACPI_PARAM_ARGS
;
148 /* Evaluate the object/method */
150 status
= acpi_ns_evaluate_relative(path
, &info
);
151 if (ACPI_FAILURE(status
)) {
152 if (status
== AE_NOT_FOUND
) {
153 ACPI_DEBUG_PRINT((ACPI_DB_EXEC
,
154 "[%4.4s.%s] was not found\n",
155 acpi_ut_get_node_name(prefix_node
),
158 ACPI_ERROR_METHOD("Method execution failed",
159 prefix_node
, path
, status
);
162 return_ACPI_STATUS(status
);
165 /* Did we get a return object? */
167 if (!info
.return_object
) {
168 if (expected_return_btypes
) {
169 ACPI_ERROR_METHOD("No object was returned from",
170 prefix_node
, path
, AE_NOT_EXIST
);
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_ERROR_METHOD("Return object type is incorrect",
216 prefix_node
, path
, AE_TYPE
);
219 "Type returned from %s was incorrect: %s, expected Btypes: %X",
221 acpi_ut_get_object_type_name(info
.return_object
),
222 expected_return_btypes
));
224 /* On error exit, we must delete the return object */
226 acpi_ut_remove_reference(info
.return_object
);
227 return_ACPI_STATUS(AE_TYPE
);
230 /* Object type is OK, return it */
232 *return_desc
= info
.return_object
;
233 return_ACPI_STATUS(AE_OK
);
236 /*******************************************************************************
238 * FUNCTION: acpi_ut_evaluate_numeric_object
240 * PARAMETERS: object_name - Object name to be evaluated
241 * device_node - Node for the device
242 * Address - Where the value is returned
246 * DESCRIPTION: Evaluates a numeric namespace object for a selected device
247 * and stores result in *Address.
249 * NOTE: Internal function, no parameter validation
251 ******************************************************************************/
254 acpi_ut_evaluate_numeric_object(char *object_name
,
255 struct acpi_namespace_node
*device_node
,
256 acpi_integer
* address
)
258 union acpi_operand_object
*obj_desc
;
261 ACPI_FUNCTION_TRACE("ut_evaluate_numeric_object");
263 status
= acpi_ut_evaluate_object(device_node
, object_name
,
264 ACPI_BTYPE_INTEGER
, &obj_desc
);
265 if (ACPI_FAILURE(status
)) {
266 return_ACPI_STATUS(status
);
269 /* Get the returned Integer */
271 *address
= obj_desc
->integer
.value
;
273 /* On exit, we must delete the return object */
275 acpi_ut_remove_reference(obj_desc
);
276 return_ACPI_STATUS(status
);
279 /*******************************************************************************
281 * FUNCTION: acpi_ut_copy_id_string
283 * PARAMETERS: Destination - Where to copy the string
284 * Source - Source string
285 * max_length - Length of the destination buffer
289 * DESCRIPTION: Copies an ID string for the _HID, _CID, and _UID methods.
290 * Performs removal of a leading asterisk if present -- workaround
291 * for a known issue on a bunch of machines.
293 ******************************************************************************/
296 acpi_ut_copy_id_string(char *destination
, char *source
, acpi_size max_length
)
300 * Workaround for ID strings that have a leading asterisk. This construct
301 * is not allowed by the ACPI specification (ID strings must be
302 * alphanumeric), but enough existing machines have this embedded in their
303 * ID strings that the following code is useful.
305 if (*source
== '*') {
309 /* Do the actual copy */
311 ACPI_STRNCPY(destination
, source
, max_length
);
314 /*******************************************************************************
316 * FUNCTION: acpi_ut_execute_HID
318 * PARAMETERS: device_node - Node for the device
319 * Hid - Where the HID is returned
323 * DESCRIPTION: Executes the _HID control method that returns the hardware
326 * NOTE: Internal function, no parameter validation
328 ******************************************************************************/
331 acpi_ut_execute_HID(struct acpi_namespace_node
*device_node
,
332 struct acpi_device_id
*hid
)
334 union acpi_operand_object
*obj_desc
;
337 ACPI_FUNCTION_TRACE("ut_execute_HID");
339 status
= acpi_ut_evaluate_object(device_node
, METHOD_NAME__HID
,
340 ACPI_BTYPE_INTEGER
| ACPI_BTYPE_STRING
,
342 if (ACPI_FAILURE(status
)) {
343 return_ACPI_STATUS(status
);
346 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
) {
485 /* Translate each package element */
487 for (i
= 0; i
< count
; i
++) {
489 acpi_ut_translate_one_cid(obj_desc
->package
.
492 if (ACPI_FAILURE(status
)) {
497 /* Only one CID, translate to a string */
499 status
= acpi_ut_translate_one_cid(obj_desc
, cid_list
->id
);
502 /* Cleanup on error */
504 if (ACPI_FAILURE(status
)) {
505 ACPI_MEM_FREE(cid_list
);
507 *return_cid_list
= cid_list
;
510 /* On exit, we must delete the _CID return object */
512 acpi_ut_remove_reference(obj_desc
);
513 return_ACPI_STATUS(status
);
516 /*******************************************************************************
518 * FUNCTION: acpi_ut_execute_UID
520 * PARAMETERS: device_node - Node for the device
521 * Uid - Where the UID is returned
525 * DESCRIPTION: Executes the _UID control method that returns the hardware
528 * NOTE: Internal function, no parameter validation
530 ******************************************************************************/
533 acpi_ut_execute_UID(struct acpi_namespace_node
*device_node
,
534 struct acpi_device_id
*uid
)
536 union acpi_operand_object
*obj_desc
;
539 ACPI_FUNCTION_TRACE("ut_execute_UID");
541 status
= acpi_ut_evaluate_object(device_node
, METHOD_NAME__UID
,
542 ACPI_BTYPE_INTEGER
| ACPI_BTYPE_STRING
,
544 if (ACPI_FAILURE(status
)) {
545 return_ACPI_STATUS(status
);
548 if (ACPI_GET_OBJECT_TYPE(obj_desc
) == ACPI_TYPE_INTEGER
) {
550 /* Convert the Numeric UID to string */
552 acpi_ex_unsigned_integer_to_string(obj_desc
->integer
.value
,
555 /* Copy the String UID from the returned object */
557 acpi_ut_copy_id_string(uid
->value
, obj_desc
->string
.pointer
,
561 /* On exit, we must delete the return object */
563 acpi_ut_remove_reference(obj_desc
);
564 return_ACPI_STATUS(status
);
567 /*******************************************************************************
569 * FUNCTION: acpi_ut_execute_STA
571 * PARAMETERS: device_node - Node for the device
572 * Flags - Where the status flags are returned
576 * DESCRIPTION: Executes _STA for selected device and stores results in
579 * NOTE: Internal function, no parameter validation
581 ******************************************************************************/
584 acpi_ut_execute_STA(struct acpi_namespace_node
*device_node
, u32
* flags
)
586 union acpi_operand_object
*obj_desc
;
589 ACPI_FUNCTION_TRACE("ut_execute_STA");
591 status
= acpi_ut_evaluate_object(device_node
, METHOD_NAME__STA
,
592 ACPI_BTYPE_INTEGER
, &obj_desc
);
593 if (ACPI_FAILURE(status
)) {
594 if (AE_NOT_FOUND
== status
) {
595 ACPI_DEBUG_PRINT((ACPI_DB_EXEC
,
596 "_STA on %4.4s was not found, assuming device is present\n",
597 acpi_ut_get_node_name(device_node
)));
599 *flags
= ACPI_UINT32_MAX
;
603 return_ACPI_STATUS(status
);
606 /* Extract the status flags */
608 *flags
= (u32
) obj_desc
->integer
.value
;
610 /* On exit, we must delete the return object */
612 acpi_ut_remove_reference(obj_desc
);
613 return_ACPI_STATUS(status
);
616 /*******************************************************************************
618 * FUNCTION: acpi_ut_execute_Sxds
620 * PARAMETERS: device_node - Node for the device
621 * Flags - Where the status flags are returned
625 * DESCRIPTION: Executes _STA for selected device and stores results in
628 * NOTE: Internal function, no parameter validation
630 ******************************************************************************/
633 acpi_ut_execute_sxds(struct acpi_namespace_node
*device_node
, u8
* highest
)
635 union acpi_operand_object
*obj_desc
;
639 ACPI_FUNCTION_TRACE("ut_execute_Sxds");
641 for (i
= 0; i
< 4; i
++) {
643 status
= acpi_ut_evaluate_object(device_node
,
645 acpi_gbl_highest_dstate_names
647 ACPI_BTYPE_INTEGER
, &obj_desc
);
648 if (ACPI_FAILURE(status
)) {
649 if (status
!= AE_NOT_FOUND
) {
650 ACPI_DEBUG_PRINT((ACPI_DB_EXEC
,
651 "%s on Device %4.4s, %s\n",
653 acpi_gbl_highest_dstate_names
655 acpi_ut_get_node_name
657 acpi_format_exception
660 return_ACPI_STATUS(status
);
663 /* Extract the Dstate value */
665 highest
[i
] = (u8
) obj_desc
->integer
.value
;
667 /* Delete the return object */
669 acpi_ut_remove_reference(obj_desc
);
673 return_ACPI_STATUS(AE_OK
);