1 /******************************************************************************
2 *
3 * Module Name: uteval - Object evaluation
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2008, Intel Corp.
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
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.
25 *
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.
29 *
30 * NO WARRANTY
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.
42 */
43
44 #include <acpi/acpi.h>
45 #include "accommon.h"
46 #include "acnamesp.h"
47 #include "acinterp.h"
48
49 #define _COMPONENT ACPI_UTILITIES
50 ACPI_MODULE_NAME("uteval")
51
52 /* Local prototypes */
53 static void
54 acpi_ut_copy_id_string(char *destination, char *source, acpi_size max_length);
55
56 static acpi_status
57 acpi_ut_translate_one_cid(union acpi_operand_object *obj_desc,
58 struct acpi_compatible_id *one_cid);
59
60 /*
61 * Strings supported by the _OSI predefined (internal) method.
62 *
63 * March 2009: Removed "Linux" as this host no longer wants to respond true
64 * for this string. Basically, the only safe OS strings are windows-related
65 * and in many or most cases represent the only test path within the
66 * BIOS-provided ASL code.
67 *
68 * The second element of each entry is used to track the newest version of
69 * Windows that the BIOS has requested.
70 */
71 static struct acpi_interface_info acpi_interfaces_supported[] = {
72 /* Operating System Vendor Strings */
73
74 {"Windows 2000", ACPI_OSI_WIN_2000}, /* Windows 2000 */
75 {"Windows 2001", ACPI_OSI_WIN_XP}, /* Windows XP */
76 {"Windows 2001 SP1", ACPI_OSI_WIN_XP_SP1}, /* Windows XP SP1 */
77 {"Windows 2001.1", ACPI_OSI_WINSRV_2003}, /* Windows Server 2003 */
78 {"Windows 2001 SP2", ACPI_OSI_WIN_XP_SP2}, /* Windows XP SP2 */
79 {"Windows 2001.1 SP1", ACPI_OSI_WINSRV_2003_SP1}, /* Windows Server 2003 SP1 - Added 03/2006 */
80 {"Windows 2006", ACPI_OSI_WIN_VISTA}, /* Windows Vista - Added 03/2006 */
81
82 /* Feature Group Strings */
83
84 {"Extended Address Space Descriptor", 0}
85
86 /*
87 * All "optional" feature group strings (features that are implemented
88 * by the host) should be implemented in the host version of
89 * acpi_os_validate_interface and should not be added here.
90 */
91 };
92
93 /*******************************************************************************
94 *
95 * FUNCTION: acpi_ut_osi_implementation
96 *
97 * PARAMETERS: walk_state - Current walk state
98 *
99 * RETURN: Status
100 *
101 * DESCRIPTION: Implementation of the _OSI predefined control method
102 *
103 ******************************************************************************/
104
105 acpi_status acpi_ut_osi_implementation(struct acpi_walk_state *walk_state)
106 {
107 acpi_status status;
108 union acpi_operand_object *string_desc;
109 union acpi_operand_object *return_desc;
110 u32 return_value;
111 u32 i;
112
113 ACPI_FUNCTION_TRACE(ut_osi_implementation);
114
115 /* Validate the string input argument */
116
117 string_desc = walk_state->arguments[0].object;
118 if (!string_desc || (string_desc->common.type != ACPI_TYPE_STRING)) {
119 return_ACPI_STATUS(AE_TYPE);
120 }
121
122 /* Create a return object */
123
124 return_desc = acpi_ut_create_internal_object(ACPI_TYPE_INTEGER);
125 if (!return_desc) {
126 return_ACPI_STATUS(AE_NO_MEMORY);
127 }
128
129 /* Default return value is 0, NOT SUPPORTED */
130
131 return_value = 0;
132
133 /* Compare input string to static table of supported interfaces */
134
135 for (i = 0; i < ACPI_ARRAY_LENGTH(acpi_interfaces_supported); i++) {
136 if (!ACPI_STRCMP(string_desc->string.pointer,
137 acpi_interfaces_supported[i].name)) {
138 /*
139 * The interface is supported.
140 * Update the osi_data if necessary. We keep track of the latest
141 * version of Windows that has been requested by the BIOS.
142 */
143 if (acpi_interfaces_supported[i].value >
144 acpi_gbl_osi_data) {
145 acpi_gbl_osi_data =
146 acpi_interfaces_supported[i].value;
147 }
148
149 return_value = ACPI_UINT32_MAX;
150 goto exit;
151 }
152 }
153
154 /*
155 * Did not match the string in the static table, call the host OSL to
156 * check for a match with one of the optional strings (such as
157 * "Module Device", "3.0 Thermal Model", etc.)
158 */
159 status = acpi_os_validate_interface(string_desc->string.pointer);
160 if (ACPI_SUCCESS(status)) {
161
162 /* The interface is supported */
163
164 return_value = ACPI_UINT32_MAX;
165 }
166
167 exit:
168 ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO,
169 "ACPI: BIOS _OSI(%s) is %ssupported\n",
170 string_desc->string.pointer, return_value == 0 ? "not " : ""));
171
172 /* Complete the return value */
173
174 return_desc->integer.value = return_value;
175 walk_state->return_desc = return_desc;
176 return_ACPI_STATUS (AE_OK);
177 }
178
179 /*******************************************************************************
180 *
181 * FUNCTION: acpi_osi_invalidate
182 *
183 * PARAMETERS: interface_string
184 *
185 * RETURN: Status
186 *
187 * DESCRIPTION: invalidate string in pre-defiend _OSI string list
188 *
189 ******************************************************************************/
190
191 acpi_status acpi_osi_invalidate(char *interface)
192 {
193 int i;
194
195 for (i = 0; i < ACPI_ARRAY_LENGTH(acpi_interfaces_supported); i++) {
196 if (!ACPI_STRCMP(interface, acpi_interfaces_supported[i].name)) {
197 *acpi_interfaces_supported[i].name = '\0';
198 return AE_OK;
199 }
200 }
201 return AE_NOT_FOUND;
202 }
203
204 /*******************************************************************************
205 *
206 * FUNCTION: acpi_ut_evaluate_object
207 *
208 * PARAMETERS: prefix_node - Starting node
209 * Path - Path to object from starting node
210 * expected_return_types - Bitmap of allowed return types
211 * return_desc - Where a return value is stored
212 *
213 * RETURN: Status
214 *
215 * DESCRIPTION: Evaluates a namespace object and verifies the type of the
216 * return object. Common code that simplifies accessing objects
217 * that have required return objects of fixed types.
218 *
219 * NOTE: Internal function, no parameter validation
220 *
221 ******************************************************************************/
222
223 acpi_status
224 acpi_ut_evaluate_object(struct acpi_namespace_node *prefix_node,
225 char *path,
226 u32 expected_return_btypes,
227 union acpi_operand_object **return_desc)
228 {
229 struct acpi_evaluate_info *info;
230 acpi_status status;
231 u32 return_btype;
232
233 ACPI_FUNCTION_TRACE(ut_evaluate_object);
234
235 /* Allocate the evaluation information block */
236
237 info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info));
238 if (!info) {
239 return_ACPI_STATUS(AE_NO_MEMORY);
240 }
241
242 info->prefix_node = prefix_node;
243 info->pathname = path;
244
245 /* Evaluate the object/method */
246
247 status = acpi_ns_evaluate(info);
248 if (ACPI_FAILURE(status)) {
249 if (status == AE_NOT_FOUND) {
250 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
251 "[%4.4s.%s] was not found\n",
252 acpi_ut_get_node_name(prefix_node),
253 path));
254 } else {
255 ACPI_ERROR_METHOD("Method execution failed",
256 prefix_node, path, status);
257 }
258
259 goto cleanup;
260 }
261
262 /* Did we get a return object? */
263
264 if (!info->return_object) {
265 if (expected_return_btypes) {
266 ACPI_ERROR_METHOD("No object was returned from",
267 prefix_node, path, AE_NOT_EXIST);
268
269 status = AE_NOT_EXIST;
270 }
271
272 goto cleanup;
273 }
274
275 /* Map the return object type to the bitmapped type */
276
277 switch ((info->return_object)->common.type) {
278 case ACPI_TYPE_INTEGER:
279 return_btype = ACPI_BTYPE_INTEGER;
280 break;
281
282 case ACPI_TYPE_BUFFER:
283 return_btype = ACPI_BTYPE_BUFFER;
284 break;
285
286 case ACPI_TYPE_STRING:
287 return_btype = ACPI_BTYPE_STRING;
288 break;
289
290 case ACPI_TYPE_PACKAGE:
291 return_btype = ACPI_BTYPE_PACKAGE;
292 break;
293
294 default:
295 return_btype = 0;
296 break;
297 }
298
299 if ((acpi_gbl_enable_interpreter_slack) && (!expected_return_btypes)) {
300 /*
301 * We received a return object, but one was not expected. This can
302 * happen frequently if the "implicit return" feature is enabled.
303 * Just delete the return object and return AE_OK.
304 */
305 acpi_ut_remove_reference(info->return_object);
306 goto cleanup;
307 }
308
309 /* Is the return object one of the expected types? */
310
311 if (!(expected_return_btypes & return_btype)) {
312 ACPI_ERROR_METHOD("Return object type is incorrect",
313 prefix_node, path, AE_TYPE);
314
315 ACPI_ERROR((AE_INFO,
316 "Type returned from %s was incorrect: %s, expected Btypes: %X",
317 path,
318 acpi_ut_get_object_type_name(info->return_object),
319 expected_return_btypes));
320
321 /* On error exit, we must delete the return object */
322
323 acpi_ut_remove_reference(info->return_object);
324 status = AE_TYPE;
325 goto cleanup;
326 }
327
328 /* Object type is OK, return it */
329
330 *return_desc = info->return_object;
331
332 cleanup:
333 ACPI_FREE(info);
334 return_ACPI_STATUS(status);
335 }
336
337 /*******************************************************************************
338 *
339 * FUNCTION: acpi_ut_evaluate_numeric_object
340 *
341 * PARAMETERS: object_name - Object name to be evaluated
342 * device_node - Node for the device
343 * Address - Where the value is returned
344 *
345 * RETURN: Status
346 *
347 * DESCRIPTION: Evaluates a numeric namespace object for a selected device
348 * and stores result in *Address.
349 *
350 * NOTE: Internal function, no parameter validation
351 *
352 ******************************************************************************/
353
354 acpi_status
355 acpi_ut_evaluate_numeric_object(char *object_name,
356 struct acpi_namespace_node *device_node,
357 acpi_integer * address)
358 {
359 union acpi_operand_object *obj_desc;
360 acpi_status status;
361
362 ACPI_FUNCTION_TRACE(ut_evaluate_numeric_object);
363
364 status = acpi_ut_evaluate_object(device_node, object_name,
365 ACPI_BTYPE_INTEGER, &obj_desc);
366 if (ACPI_FAILURE(status)) {
367 return_ACPI_STATUS(status);
368 }
369
370 /* Get the returned Integer */
371
372 *address = obj_desc->integer.value;
373
374 /* On exit, we must delete the return object */
375
376 acpi_ut_remove_reference(obj_desc);
377 return_ACPI_STATUS(status);
378 }
379
380 /*******************************************************************************
381 *
382 * FUNCTION: acpi_ut_copy_id_string
383 *
384 * PARAMETERS: Destination - Where to copy the string
385 * Source - Source string
386 * max_length - Length of the destination buffer
387 *
388 * RETURN: None
389 *
390 * DESCRIPTION: Copies an ID string for the _HID, _CID, and _UID methods.
391 * Performs removal of a leading asterisk if present -- workaround
392 * for a known issue on a bunch of machines.
393 *
394 ******************************************************************************/
395
396 static void
397 acpi_ut_copy_id_string(char *destination, char *source, acpi_size max_length)
398 {
399
400 /*
401 * Workaround for ID strings that have a leading asterisk. This construct
402 * is not allowed by the ACPI specification (ID strings must be
403 * alphanumeric), but enough existing machines have this embedded in their
404 * ID strings that the following code is useful.
405 */
406 if (*source == '*') {
407 source++;
408 }
409
410 /* Do the actual copy */
411
412 ACPI_STRNCPY(destination, source, max_length);
413 }
414
415 /*******************************************************************************
416 *
417 * FUNCTION: acpi_ut_execute_HID
418 *
419 * PARAMETERS: device_node - Node for the device
420 * Hid - Where the HID is returned
421 *
422 * RETURN: Status
423 *
424 * DESCRIPTION: Executes the _HID control method that returns the hardware
425 * ID of the device.
426 *
427 * NOTE: Internal function, no parameter validation
428 *
429 ******************************************************************************/
430
431 acpi_status
432 acpi_ut_execute_HID(struct acpi_namespace_node *device_node,
433 struct acpica_device_id *hid)
434 {
435 union acpi_operand_object *obj_desc;
436 acpi_status status;
437
438 ACPI_FUNCTION_TRACE(ut_execute_HID);
439
440 status = acpi_ut_evaluate_object(device_node, METHOD_NAME__HID,
441 ACPI_BTYPE_INTEGER | ACPI_BTYPE_STRING,
442 &obj_desc);
443 if (ACPI_FAILURE(status)) {
444 return_ACPI_STATUS(status);
445 }
446
447 if (obj_desc->common.type == ACPI_TYPE_INTEGER) {
448
449 /* Convert the Numeric HID to string */
450
451 acpi_ex_eisa_id_to_string((u32) obj_desc->integer.value,
452 hid->value);
453 } else {
454 /* Copy the String HID from the returned object */
455
456 acpi_ut_copy_id_string(hid->value, obj_desc->string.pointer,
457 sizeof(hid->value));
458 }
459
460 /* On exit, we must delete the return object */
461
462 acpi_ut_remove_reference(obj_desc);
463 return_ACPI_STATUS(status);
464 }
465
466 /*******************************************************************************
467 *
468 * FUNCTION: acpi_ut_translate_one_cid
469 *
470 * PARAMETERS: obj_desc - _CID object, must be integer or string
471 * one_cid - Where the CID string is returned
472 *
473 * RETURN: Status
474 *
475 * DESCRIPTION: Return a numeric or string _CID value as a string.
476 * (Compatible ID)
477 *
478 * NOTE: Assumes a maximum _CID string length of
479 * ACPI_MAX_CID_LENGTH.
480 *
481 ******************************************************************************/
482
483 static acpi_status
484 acpi_ut_translate_one_cid(union acpi_operand_object *obj_desc,
485 struct acpi_compatible_id *one_cid)
486 {
487
488 switch (obj_desc->common.type) {
489 case ACPI_TYPE_INTEGER:
490
491 /* Convert the Numeric CID to string */
492
493 acpi_ex_eisa_id_to_string((u32) obj_desc->integer.value,
494 one_cid->value);
495 return (AE_OK);
496
497 case ACPI_TYPE_STRING:
498
499 if (obj_desc->string.length > ACPI_MAX_CID_LENGTH) {
500 return (AE_AML_STRING_LIMIT);
501 }
502
503 /* Copy the String CID from the returned object */
504
505 acpi_ut_copy_id_string(one_cid->value, obj_desc->string.pointer,
506 ACPI_MAX_CID_LENGTH);
507 return (AE_OK);
508
509 default:
510
511 return (AE_TYPE);
512 }
513 }
514
515 /*******************************************************************************
516 *
517 * FUNCTION: acpi_ut_execute_CID
518 *
519 * PARAMETERS: device_node - Node for the device
520 * return_cid_list - Where the CID list is returned
521 *
522 * RETURN: Status
523 *
524 * DESCRIPTION: Executes the _CID control method that returns one or more
525 * compatible hardware IDs for the device.
526 *
527 * NOTE: Internal function, no parameter validation
528 *
529 ******************************************************************************/
530
531 acpi_status
532 acpi_ut_execute_CID(struct acpi_namespace_node * device_node,
533 struct acpi_compatible_id_list ** return_cid_list)
534 {
535 union acpi_operand_object *obj_desc;
536 acpi_status status;
537 u32 count;
538 u32 size;
539 struct acpi_compatible_id_list *cid_list;
540 u32 i;
541
542 ACPI_FUNCTION_TRACE(ut_execute_CID);
543
544 /* Evaluate the _CID method for this device */
545
546 status = acpi_ut_evaluate_object(device_node, METHOD_NAME__CID,
547 ACPI_BTYPE_INTEGER | ACPI_BTYPE_STRING
548 | ACPI_BTYPE_PACKAGE, &obj_desc);
549 if (ACPI_FAILURE(status)) {
550 return_ACPI_STATUS(status);
551 }
552
553 /* Get the number of _CIDs returned */
554
555 count = 1;
556 if (obj_desc->common.type == ACPI_TYPE_PACKAGE) {
557 count = obj_desc->package.count;
558 }
559
560 /* Allocate a worst-case buffer for the _CIDs */
561
562 size = (((count - 1) * sizeof(struct acpi_compatible_id)) +
563 sizeof(struct acpi_compatible_id_list));
564
565 cid_list = ACPI_ALLOCATE_ZEROED((acpi_size) size);
566 if (!cid_list) {
567 return_ACPI_STATUS(AE_NO_MEMORY);
568 }
569
570 /* Init CID list */
571
572 cid_list->count = count;
573 cid_list->size = size;
574
575 /*
576 * A _CID can return either a single compatible ID or a package of
577 * compatible IDs. Each compatible ID can be one of the following:
578 * 1) Integer (32 bit compressed EISA ID) or
579 * 2) String (PCI ID format, e.g. "PCI\VEN_vvvv&DEV_dddd&SUBSYS_ssssssss")
580 */
581
582 /* The _CID object can be either a single CID or a package (list) of CIDs */
583
584 if (obj_desc->common.type == ACPI_TYPE_PACKAGE) {
585
586 /* Translate each package element */
587
588 for (i = 0; i < count; i++) {
589 status =
590 acpi_ut_translate_one_cid(obj_desc->package.
591 elements[i],
592 &cid_list->id[i]);
593 if (ACPI_FAILURE(status)) {
594 break;
595 }
596 }
597 } else {
598 /* Only one CID, translate to a string */
599
600 status = acpi_ut_translate_one_cid(obj_desc, cid_list->id);
601 }
602
603 /* Cleanup on error */
604
605 if (ACPI_FAILURE(status)) {
606 ACPI_FREE(cid_list);
607 } else {
608 *return_cid_list = cid_list;
609 }
610
611 /* On exit, we must delete the _CID return object */
612
613 acpi_ut_remove_reference(obj_desc);
614 return_ACPI_STATUS(status);
615 }
616
617 /*******************************************************************************
618 *
619 * FUNCTION: acpi_ut_execute_UID
620 *
621 * PARAMETERS: device_node - Node for the device
622 * Uid - Where the UID is returned
623 *
624 * RETURN: Status
625 *
626 * DESCRIPTION: Executes the _UID control method that returns the hardware
627 * ID of the device.
628 *
629 * NOTE: Internal function, no parameter validation
630 *
631 ******************************************************************************/
632
633 acpi_status
634 acpi_ut_execute_UID(struct acpi_namespace_node *device_node,
635 struct acpica_device_id *uid)
636 {
637 union acpi_operand_object *obj_desc;
638 acpi_status status;
639
640 ACPI_FUNCTION_TRACE(ut_execute_UID);
641
642 status = acpi_ut_evaluate_object(device_node, METHOD_NAME__UID,
643 ACPI_BTYPE_INTEGER | ACPI_BTYPE_STRING,
644 &obj_desc);
645 if (ACPI_FAILURE(status)) {
646 return_ACPI_STATUS(status);
647 }
648
649 if (obj_desc->common.type == ACPI_TYPE_INTEGER) {
650
651 /* Convert the Numeric UID to string */
652
653 acpi_ex_unsigned_integer_to_string(obj_desc->integer.value,
654 uid->value);
655 } else {
656 /* Copy the String UID from the returned object */
657
658 acpi_ut_copy_id_string(uid->value, obj_desc->string.pointer,
659 sizeof(uid->value));
660 }
661
662 /* On exit, we must delete the return object */
663
664 acpi_ut_remove_reference(obj_desc);
665 return_ACPI_STATUS(status);
666 }
667
668 /*******************************************************************************
669 *
670 * FUNCTION: acpi_ut_execute_STA
671 *
672 * PARAMETERS: device_node - Node for the device
673 * Flags - Where the status flags are returned
674 *
675 * RETURN: Status
676 *
677 * DESCRIPTION: Executes _STA for selected device and stores results in
678 * *Flags.
679 *
680 * NOTE: Internal function, no parameter validation
681 *
682 ******************************************************************************/
683
684 acpi_status
685 acpi_ut_execute_STA(struct acpi_namespace_node *device_node, u32 * flags)
686 {
687 union acpi_operand_object *obj_desc;
688 acpi_status status;
689
690 ACPI_FUNCTION_TRACE(ut_execute_STA);
691
692 status = acpi_ut_evaluate_object(device_node, METHOD_NAME__STA,
693 ACPI_BTYPE_INTEGER, &obj_desc);
694 if (ACPI_FAILURE(status)) {
695 if (AE_NOT_FOUND == status) {
696 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
697 "_STA on %4.4s was not found, assuming device is present\n",
698 acpi_ut_get_node_name(device_node)));
699
700 *flags = ACPI_UINT32_MAX;
701 status = AE_OK;
702 }
703
704 return_ACPI_STATUS(status);
705 }
706
707 /* Extract the status flags */
708
709 *flags = (u32) obj_desc->integer.value;
710
711 /* On exit, we must delete the return object */
712
713 acpi_ut_remove_reference(obj_desc);
714 return_ACPI_STATUS(status);
715 }
716
717 /*******************************************************************************
718 *
719 * FUNCTION: acpi_ut_execute_Sxds
720 *
721 * PARAMETERS: device_node - Node for the device
722 * Flags - Where the status flags are returned
723 *
724 * RETURN: Status
725 *
726 * DESCRIPTION: Executes _STA for selected device and stores results in
727 * *Flags.
728 *
729 * NOTE: Internal function, no parameter validation
730 *
731 ******************************************************************************/
732
733 acpi_status
734 acpi_ut_execute_sxds(struct acpi_namespace_node *device_node, u8 * highest)
735 {
736 union acpi_operand_object *obj_desc;
737 acpi_status status;
738 u32 i;
739
740 ACPI_FUNCTION_TRACE(ut_execute_sxds);
741
742 for (i = 0; i < 4; i++) {
743 highest[i] = 0xFF;
744 status = acpi_ut_evaluate_object(device_node,
745 ACPI_CAST_PTR(char,
746 acpi_gbl_highest_dstate_names
747 [i]),
748 ACPI_BTYPE_INTEGER, &obj_desc);
749 if (ACPI_FAILURE(status)) {
750 if (status != AE_NOT_FOUND) {
751 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
752 "%s on Device %4.4s, %s\n",
753 ACPI_CAST_PTR(char,
754 acpi_gbl_highest_dstate_names
755 [i]),
756 acpi_ut_get_node_name
757 (device_node),
758 acpi_format_exception
759 (status)));
760
761 return_ACPI_STATUS(status);
762 }
763 } else {
764 /* Extract the Dstate value */
765
766 highest[i] = (u8) obj_desc->integer.value;
767
768 /* Delete the return object */
769
770 acpi_ut_remove_reference(obj_desc);
771 }
772 }
773
774 return_ACPI_STATUS(AE_OK);
775 }
776
|
This page was automatically generated by the
LXR engine.
|