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