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);