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