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