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