1 /******************************************************************************
3 * Module Name: nspredef - Validation of ACPI predefined methods and objects
6 *****************************************************************************/
9 * Copyright (C) 2000 - 2008, Intel Corp.
10 * All rights reserved.
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions, and the following disclaimer,
17 * without modification.
18 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
19 * substantially similar to the "NO WARRANTY" disclaimer below
20 * ("Disclaimer") and any redistribution must be conditioned upon
21 * including a substantially similar Disclaimer requirement for further
22 * binary redistribution.
23 * 3. Neither the names of the above-listed copyright holders nor the names
24 * of any contributors may be used to endorse or promote products derived
25 * from this software without specific prior written permission.
27 * Alternatively, this software may be distributed under the terms of the
28 * GNU General Public License ("GPL") version 2 as published by the Free
29 * Software Foundation.
32 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
33 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
34 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
35 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
36 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
40 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
41 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
42 * POSSIBILITY OF SUCH DAMAGES.
45 #include <acpi/acpi.h>
46 #include <acpi/acnamesp.h>
47 #include <acpi/acpredef.h>
49 #define _COMPONENT ACPI_NAMESPACE
50 ACPI_MODULE_NAME("nspredef")
52 /*******************************************************************************
54 * This module validates predefined ACPI objects that appear in the namespace,
55 * at the time they are evaluated (via acpi_evaluate_object). The purpose of this
56 * validation is to detect problems with BIOS-exposed predefined ACPI objects
57 * before the results are returned to the ACPI-related drivers.
59 * There are several areas that are validated:
61 * 1) The number of input arguments as defined by the method/object in the
62 * ASL is validated against the ACPI specification.
63 * 2) The type of the return object (if any) is validated against the ACPI
65 * 3) For returned package objects, the count of package elements is
66 * validated, as well as the type of each package element. Nested
67 * packages are supported.
69 * For any problems found, a warning message is issued.
71 ******************************************************************************/
72 /* Local prototypes */
74 acpi_ns_check_package(char *pathname
,
75 union acpi_operand_object
**return_object_ptr
,
76 const union acpi_predefined_info
*predefined
);
79 acpi_ns_check_package_elements(char *pathname
,
80 union acpi_operand_object
**elements
,
81 u8 type1
, u32 count1
, u8 type2
, u32 count2
);
84 acpi_ns_check_object_type(char *pathname
,
85 union acpi_operand_object
**return_object_ptr
,
86 u32 expected_btypes
, u32 package_index
);
89 acpi_ns_check_reference(char *pathname
,
90 union acpi_operand_object
*return_object
);
93 acpi_ns_repair_object(u32 expected_btypes
,
95 union acpi_operand_object
**return_object_ptr
);
98 * Names for the types that can be returned by the predefined objects.
99 * Used for warning messages. Must be in the same order as the ACPI_RTYPEs
101 static const char *acpi_rtype_names
[] = {
109 #define ACPI_NOT_PACKAGE ACPI_UINT32_MAX
111 /*******************************************************************************
113 * FUNCTION: acpi_ns_check_predefined_names
115 * PARAMETERS: Node - Namespace node for the method/object
116 * return_object_ptr - Pointer to the object returned from the
117 * evaluation of a method or object
121 * DESCRIPTION: Check an ACPI name for a match in the predefined name list.
123 ******************************************************************************/
126 acpi_ns_check_predefined_names(struct acpi_namespace_node
*node
,
127 u32 user_param_count
,
128 acpi_status return_status
,
129 union acpi_operand_object
**return_object_ptr
)
131 union acpi_operand_object
*return_object
= *return_object_ptr
;
132 acpi_status status
= AE_OK
;
133 const union acpi_predefined_info
*predefined
;
136 /* Match the name for this method/object against the predefined list */
138 predefined
= acpi_ns_check_for_predefined_name(node
);
140 /* Get the full pathname to the object, for use in error messages */
142 pathname
= acpi_ns_get_external_pathname(node
);
144 pathname
= ACPI_CAST_PTR(char, predefined
->info
.name
);
148 * Check that the parameter count for this method matches the ASL
149 * definition. For predefined names, ensure that both the caller and
150 * the method itself are in accordance with the ACPI specification.
152 acpi_ns_check_parameter_count(pathname
, node
, user_param_count
,
155 /* If not a predefined name, we cannot validate the return object */
161 /* If the method failed, we cannot validate the return object */
163 if ((return_status
!= AE_OK
) && (return_status
!= AE_CTRL_RETURN_VALUE
)) {
168 * Only validate the return value on the first successful evaluation of
169 * the method. This ensures that any warnings will only be emitted during
170 * the very first evaluation of the method/object.
172 if (node
->flags
& ANOBJ_EVALUATED
) {
176 /* Mark the node as having been successfully evaluated */
178 node
->flags
|= ANOBJ_EVALUATED
;
181 * If there is no return value, check if we require a return value for
182 * this predefined name. Either one return value is expected, or none,
183 * for both methods and other objects.
185 * Exit now if there is no return object. Warning if one was expected.
187 if (!return_object
) {
188 if ((predefined
->info
.expected_btypes
) &&
189 (!(predefined
->info
.expected_btypes
& ACPI_RTYPE_NONE
))) {
191 "%s: Missing expected return value",
194 status
= AE_AML_NO_RETURN_VALUE
;
200 * We have a return value, but if one wasn't expected, just exit, this is
203 * For example, if the "Implicit Return" feature is enabled, methods will
204 * always return a value
206 if (!predefined
->info
.expected_btypes
) {
211 * Check that the type of the return object is what is expected for
212 * this predefined name
214 status
= acpi_ns_check_object_type(pathname
, return_object_ptr
,
215 predefined
->info
.expected_btypes
,
217 if (ACPI_FAILURE(status
)) {
221 /* For returned Package objects, check the type of all sub-objects */
223 if (ACPI_GET_OBJECT_TYPE(return_object
) == ACPI_TYPE_PACKAGE
) {
225 acpi_ns_check_package(pathname
, return_object_ptr
,
230 if (pathname
!= predefined
->info
.name
) {
237 /*******************************************************************************
239 * FUNCTION: acpi_ns_check_parameter_count
241 * PARAMETERS: Pathname - Full pathname to the node (for error msgs)
242 * Node - Namespace node for the method/object
243 * user_param_count - Number of args passed in by the caller
244 * Predefined - Pointer to entry in predefined name table
248 * DESCRIPTION: Check that the declared (in ASL/AML) parameter count for a
249 * predefined name is what is expected (i.e., what is defined in
250 * the ACPI specification for this predefined name.)
252 ******************************************************************************/
255 acpi_ns_check_parameter_count(char *pathname
,
256 struct acpi_namespace_node
*node
,
257 u32 user_param_count
,
258 const union acpi_predefined_info
*predefined
)
261 u32 required_params_current
;
262 u32 required_params_old
;
264 /* Methods have 0-7 parameters. All other types have zero. */
267 if (node
->type
== ACPI_TYPE_METHOD
) {
268 param_count
= node
->object
->method
.param_count
;
271 /* Argument count check for non-predefined methods/objects */
275 * Warning if too few or too many arguments have been passed by the
276 * caller. An incorrect number of arguments may not cause the method
277 * to fail. However, the method will fail if there are too few
278 * arguments and the method attempts to use one of the missing ones.
280 if (user_param_count
< param_count
) {
281 ACPI_WARNING((AE_INFO
,
282 "%s: Insufficient arguments - needs %d, found %d",
283 pathname
, param_count
, user_param_count
));
284 } else if (user_param_count
> param_count
) {
285 ACPI_WARNING((AE_INFO
,
286 "%s: Excess arguments - needs %d, found %d",
287 pathname
, param_count
, user_param_count
));
292 /* Allow two different legal argument counts (_SCP, etc.) */
294 required_params_current
= predefined
->info
.param_count
& 0x0F;
295 required_params_old
= predefined
->info
.param_count
>> 4;
297 if (user_param_count
!= ACPI_UINT32_MAX
) {
299 /* Validate the user-supplied parameter count */
301 if ((user_param_count
!= required_params_current
) &&
302 (user_param_count
!= required_params_old
)) {
303 ACPI_WARNING((AE_INFO
,
304 "%s: Parameter count mismatch - caller passed %d, ACPI requires %d",
305 pathname
, user_param_count
,
306 required_params_current
));
311 * Only validate the argument count on the first successful evaluation of
312 * the method. This ensures that any warnings will only be emitted during
313 * the very first evaluation of the method/object.
315 if (node
->flags
& ANOBJ_EVALUATED
) {
320 * Check that the ASL-defined parameter count is what is expected for
321 * this predefined name.
323 if ((param_count
!= required_params_current
) &&
324 (param_count
!= required_params_old
)) {
325 ACPI_WARNING((AE_INFO
,
326 "%s: Parameter count mismatch - ASL declared %d, ACPI requires %d",
327 pathname
, param_count
, required_params_current
));
331 /*******************************************************************************
333 * FUNCTION: acpi_ns_check_for_predefined_name
335 * PARAMETERS: Node - Namespace node for the method/object
337 * RETURN: Pointer to entry in predefined table. NULL indicates not found.
339 * DESCRIPTION: Check an object name against the predefined object list.
341 ******************************************************************************/
343 const union acpi_predefined_info
*acpi_ns_check_for_predefined_name(struct
347 const union acpi_predefined_info
*this_name
;
349 /* Quick check for a predefined name, first character must be underscore */
351 if (node
->name
.ascii
[0] != '_') {
355 /* Search info table for a predefined method/object name */
357 this_name
= predefined_names
;
358 while (this_name
->info
.name
[0]) {
359 if (ACPI_COMPARE_NAME(node
->name
.ascii
, this_name
->info
.name
)) {
361 /* Return pointer to this table entry */
367 * Skip next entry in the table if this name returns a Package
368 * (next entry contains the package info)
370 if (this_name
->info
.expected_btypes
& ACPI_RTYPE_PACKAGE
) {
380 /*******************************************************************************
382 * FUNCTION: acpi_ns_check_package
384 * PARAMETERS: Pathname - Full pathname to the node (for error msgs)
385 * return_object_ptr - Pointer to the object returned from the
386 * evaluation of a method or object
387 * Predefined - Pointer to entry in predefined name table
391 * DESCRIPTION: Check a returned package object for the correct count and
392 * correct type of all sub-objects.
394 ******************************************************************************/
397 acpi_ns_check_package(char *pathname
,
398 union acpi_operand_object
**return_object_ptr
,
399 const union acpi_predefined_info
*predefined
)
401 union acpi_operand_object
*return_object
= *return_object_ptr
;
402 const union acpi_predefined_info
*package
;
403 union acpi_operand_object
*sub_package
;
404 union acpi_operand_object
**elements
;
405 union acpi_operand_object
**sub_elements
;
412 ACPI_FUNCTION_NAME(ns_check_package
);
414 /* The package info for this name is in the next table entry */
416 package
= predefined
+ 1;
418 ACPI_DEBUG_PRINT((ACPI_DB_NAMES
,
419 "%s Validating return Package of Type %X, Count %X\n",
420 pathname
, package
->ret_info
.type
,
421 return_object
->package
.count
));
423 /* Extract package count and elements array */
425 elements
= return_object
->package
.elements
;
426 count
= return_object
->package
.count
;
428 /* The package must have at least one element, else invalid */
431 ACPI_WARNING((AE_INFO
,
432 "%s: Return Package has no elements (empty)",
435 return (AE_AML_OPERAND_VALUE
);
439 * Decode the type of the expected package contents
441 * PTYPE1 packages contain no subpackages
442 * PTYPE2 packages contain sub-packages
444 switch (package
->ret_info
.type
) {
445 case ACPI_PTYPE1_FIXED
:
448 * The package count is fixed and there are no sub-packages
450 * If package is too small, exit.
451 * If package is larger than expected, issue warning but continue
454 package
->ret_info
.count1
+ package
->ret_info
.count2
;
455 if (count
< expected_count
) {
456 goto package_too_small
;
457 } else if (count
> expected_count
) {
458 ACPI_WARNING((AE_INFO
,
459 "%s: Return Package is larger than needed - "
460 "found %u, expected %u", pathname
, count
,
464 /* Validate all elements of the returned package */
466 status
= acpi_ns_check_package_elements(pathname
, elements
,
475 if (ACPI_FAILURE(status
)) {
480 case ACPI_PTYPE1_VAR
:
483 * The package count is variable, there are no sub-packages, and all
484 * elements must be of the same type
486 for (i
= 0; i
< count
; i
++) {
487 status
= acpi_ns_check_object_type(pathname
, elements
,
490 if (ACPI_FAILURE(status
)) {
497 case ACPI_PTYPE1_OPTION
:
500 * The package count is variable, there are no sub-packages. There are
501 * a fixed number of required elements, and a variable number of
504 * Check if package is at least as large as the minimum required
506 expected_count
= package
->ret_info3
.count
;
507 if (count
< expected_count
) {
508 goto package_too_small
;
511 /* Variable number of sub-objects */
513 for (i
= 0; i
< count
; i
++) {
514 if (i
< package
->ret_info3
.count
) {
516 /* These are the required package elements (0, 1, or 2) */
519 acpi_ns_check_object_type(pathname
,
525 if (ACPI_FAILURE(status
)) {
529 /* These are the optional package elements */
532 acpi_ns_check_object_type(pathname
,
538 if (ACPI_FAILURE(status
)) {
546 case ACPI_PTYPE2_PKG_COUNT
:
548 /* First element is the (Integer) count of sub-packages to follow */
550 status
= acpi_ns_check_object_type(pathname
, elements
,
551 ACPI_RTYPE_INTEGER
, 0);
552 if (ACPI_FAILURE(status
)) {
557 * Count cannot be larger than the parent package length, but allow it
558 * to be smaller. The >= accounts for the Integer above.
560 expected_count
= (u32
) (*elements
)->integer
.value
;
561 if (expected_count
>= count
) {
562 goto package_too_small
;
565 count
= expected_count
;
568 /* Now we can walk the sub-packages */
570 /*lint -fallthrough */
573 case ACPI_PTYPE2_FIXED
:
574 case ACPI_PTYPE2_MIN
:
575 case ACPI_PTYPE2_COUNT
:
578 * These types all return a single package that consists of a variable
579 * number of sub-packages
581 for (i
= 0; i
< count
; i
++) {
582 sub_package
= *elements
;
583 sub_elements
= sub_package
->package
.elements
;
585 /* Each sub-object must be of type Package */
588 acpi_ns_check_object_type(pathname
, &sub_package
,
589 ACPI_RTYPE_PACKAGE
, i
);
590 if (ACPI_FAILURE(status
)) {
594 /* Examine the different types of sub-packages */
596 switch (package
->ret_info
.type
) {
598 case ACPI_PTYPE2_PKG_COUNT
:
600 /* Each subpackage has a fixed number of elements */
603 package
->ret_info
.count1
+
604 package
->ret_info
.count2
;
605 if (sub_package
->package
.count
!=
607 count
= sub_package
->package
.count
;
608 goto package_too_small
;
612 acpi_ns_check_package_elements(pathname
,
626 if (ACPI_FAILURE(status
)) {
631 case ACPI_PTYPE2_FIXED
:
633 /* Each sub-package has a fixed length */
635 expected_count
= package
->ret_info2
.count
;
636 if (sub_package
->package
.count
< expected_count
) {
637 count
= sub_package
->package
.count
;
638 goto package_too_small
;
641 /* Check the type of each sub-package element */
643 for (j
= 0; j
< expected_count
; j
++) {
645 acpi_ns_check_object_type(pathname
,
647 package
->ret_info2
.object_type
[j
], j
);
648 if (ACPI_FAILURE(status
)) {
654 case ACPI_PTYPE2_MIN
:
656 /* Each sub-package has a variable but minimum length */
658 expected_count
= package
->ret_info
.count1
;
659 if (sub_package
->package
.count
< expected_count
) {
660 count
= sub_package
->package
.count
;
661 goto package_too_small
;
664 /* Check the type of each sub-package element */
667 acpi_ns_check_package_elements(pathname
,
675 if (ACPI_FAILURE(status
)) {
680 case ACPI_PTYPE2_COUNT
:
682 /* First element is the (Integer) count of elements to follow */
685 acpi_ns_check_object_type(pathname
,
689 if (ACPI_FAILURE(status
)) {
693 /* Make sure package is large enough for the Count */
696 (u32
) (*sub_elements
)->integer
.value
;
697 if (sub_package
->package
.count
< expected_count
) {
698 count
= sub_package
->package
.count
;
699 goto package_too_small
;
702 /* Check the type of each sub-package element */
705 acpi_ns_check_package_elements(pathname
,
713 if (ACPI_FAILURE(status
)) {
728 /* Should not get here if predefined info table is correct */
730 ACPI_WARNING((AE_INFO
,
731 "%s: Invalid internal return type in table entry: %X",
732 pathname
, package
->ret_info
.type
));
734 return (AE_AML_INTERNAL
);
741 /* Error exit for the case with an incorrect package count */
743 ACPI_WARNING((AE_INFO
, "%s: Return Package is too small - "
744 "found %u, expected %u", pathname
, count
,
747 return (AE_AML_OPERAND_VALUE
);
750 /*******************************************************************************
752 * FUNCTION: acpi_ns_check_package_elements
754 * PARAMETERS: Pathname - Full pathname to the node (for error msgs)
755 * Elements - Pointer to the package elements array
756 * Type1 - Object type for first group
757 * Count1 - Count for first group
758 * Type2 - Object type for second group
759 * Count2 - Count for second group
763 * DESCRIPTION: Check that all elements of a package are of the correct object
764 * type. Supports up to two groups of different object types.
766 ******************************************************************************/
769 acpi_ns_check_package_elements(char *pathname
,
770 union acpi_operand_object
**elements
,
771 u8 type1
, u32 count1
, u8 type2
, u32 count2
)
773 union acpi_operand_object
**this_element
= elements
;
778 * Up to two groups of package elements are supported by the data
779 * structure. All elements in each group must be of the same type.
780 * The second group can have a count of zero.
782 for (i
= 0; i
< count1
; i
++) {
783 status
= acpi_ns_check_object_type(pathname
, this_element
,
785 if (ACPI_FAILURE(status
)) {
791 for (i
= 0; i
< count2
; i
++) {
792 status
= acpi_ns_check_object_type(pathname
, this_element
,
793 type2
, (i
+ count1
));
794 if (ACPI_FAILURE(status
)) {
803 /*******************************************************************************
805 * FUNCTION: acpi_ns_check_object_type
807 * PARAMETERS: Pathname - Full pathname to the node (for error msgs)
808 * return_object_ptr - Pointer to the object returned from the
809 * evaluation of a method or object
810 * expected_btypes - Bitmap of expected return type(s)
811 * package_index - Index of object within parent package (if
812 * applicable - ACPI_NOT_PACKAGE otherwise)
816 * DESCRIPTION: Check the type of the return object against the expected object
817 * type(s). Use of Btype allows multiple expected object types.
819 ******************************************************************************/
822 acpi_ns_check_object_type(char *pathname
,
823 union acpi_operand_object
**return_object_ptr
,
824 u32 expected_btypes
, u32 package_index
)
826 union acpi_operand_object
*return_object
= *return_object_ptr
;
827 acpi_status status
= AE_OK
;
829 char type_buffer
[48]; /* Room for 5 types */
835 * If we get a NULL return_object here, it is a NULL package element,
836 * and this is always an error.
838 if (!return_object
) {
839 goto type_error_exit
;
842 /* A Namespace node should not get here, but make sure */
844 if (ACPI_GET_DESCRIPTOR_TYPE(return_object
) == ACPI_DESC_TYPE_NAMED
) {
845 ACPI_WARNING((AE_INFO
,
846 "%s: Invalid return type - Found a Namespace node [%4.4s] type %s",
847 pathname
, return_object
->node
.name
.ascii
,
848 acpi_ut_get_type_name(return_object
->node
.type
)));
849 return (AE_AML_OPERAND_TYPE
);
853 * Convert the object type (ACPI_TYPE_xxx) to a bitmapped object type.
854 * The bitmapped type allows multiple possible return types.
856 * Note, the cases below must handle all of the possible types returned
857 * from all of the predefined names (including elements of returned
860 switch (ACPI_GET_OBJECT_TYPE(return_object
)) {
861 case ACPI_TYPE_INTEGER
:
862 return_btype
= ACPI_RTYPE_INTEGER
;
865 case ACPI_TYPE_BUFFER
:
866 return_btype
= ACPI_RTYPE_BUFFER
;
869 case ACPI_TYPE_STRING
:
870 return_btype
= ACPI_RTYPE_STRING
;
873 case ACPI_TYPE_PACKAGE
:
874 return_btype
= ACPI_RTYPE_PACKAGE
;
877 case ACPI_TYPE_LOCAL_REFERENCE
:
878 return_btype
= ACPI_RTYPE_REFERENCE
;
882 /* Not one of the supported objects, must be incorrect */
884 goto type_error_exit
;
887 /* Is the object one of the expected types? */
889 if (!(return_btype
& expected_btypes
)) {
891 /* Type mismatch -- attempt repair of the returned object */
893 status
= acpi_ns_repair_object(expected_btypes
, package_index
,
895 if (ACPI_SUCCESS(status
)) {
898 goto type_error_exit
;
901 /* For reference objects, check that the reference type is correct */
903 if (ACPI_GET_OBJECT_TYPE(return_object
) == ACPI_TYPE_LOCAL_REFERENCE
) {
904 status
= acpi_ns_check_reference(pathname
, return_object
);
911 /* Create a string with all expected types for this predefined object */
915 this_rtype
= ACPI_RTYPE_INTEGER
;
917 for (i
= 0; i
< ACPI_NUM_RTYPES
; i
++) {
919 /* If one of the expected types, concatenate the name of this type */
921 if (expected_btypes
& this_rtype
) {
922 ACPI_STRCAT(type_buffer
, &acpi_rtype_names
[i
][j
]);
923 j
= 0; /* Use name separator from now on */
925 this_rtype
<<= 1; /* Next Rtype */
928 if (package_index
== ACPI_NOT_PACKAGE
) {
929 ACPI_WARNING((AE_INFO
,
930 "%s: Return type mismatch - found %s, expected %s",
932 acpi_ut_get_object_type_name(return_object
),
935 ACPI_WARNING((AE_INFO
,
936 "%s: Return Package type mismatch at index %u - "
937 "found %s, expected %s", pathname
, package_index
,
938 acpi_ut_get_object_type_name(return_object
),
942 return (AE_AML_OPERAND_TYPE
);
945 /*******************************************************************************
947 * FUNCTION: acpi_ns_check_reference
949 * PARAMETERS: Pathname - Full pathname to the node (for error msgs)
950 * return_object - Object returned from the evaluation of a
955 * DESCRIPTION: Check a returned reference object for the correct reference
956 * type. The only reference type that can be returned from a
957 * predefined method is a named reference. All others are invalid.
959 ******************************************************************************/
962 acpi_ns_check_reference(char *pathname
,
963 union acpi_operand_object
*return_object
)
967 * Check the reference object for the correct reference type (opcode).
968 * The only type of reference that can be converted to an union acpi_object is
969 * a reference to a named object (reference class: NAME)
971 if (return_object
->reference
.class == ACPI_REFCLASS_NAME
) {
975 ACPI_WARNING((AE_INFO
,
976 "%s: Return type mismatch - unexpected reference object type [%s] %2.2X",
977 pathname
, acpi_ut_get_reference_name(return_object
),
978 return_object
->reference
.class));
980 return (AE_AML_OPERAND_TYPE
);
983 /*******************************************************************************
985 * FUNCTION: acpi_ns_repair_object
987 * PARAMETERS: Pathname - Full pathname to the node (for error msgs)
988 * package_index - Used to determine if target is in a package
989 * return_object_ptr - Pointer to the object returned from the
990 * evaluation of a method or object
992 * RETURN: Status. AE_OK if repair was successful.
994 * DESCRIPTION: Attempt to repair/convert a return object of a type that was
997 ******************************************************************************/
1000 acpi_ns_repair_object(u32 expected_btypes
,
1002 union acpi_operand_object
**return_object_ptr
)
1004 union acpi_operand_object
*return_object
= *return_object_ptr
;
1005 union acpi_operand_object
*new_object
;
1008 switch (ACPI_GET_OBJECT_TYPE(return_object
)) {
1009 case ACPI_TYPE_BUFFER
:
1011 if (!(expected_btypes
& ACPI_RTYPE_STRING
)) {
1012 return (AE_AML_OPERAND_TYPE
);
1016 * Have a Buffer, expected a String, convert. Use a to_string
1017 * conversion, no transform performed on the buffer data. The best
1018 * example of this is the _BIF method, where the string data from
1019 * the battery is often (incorrectly) returned as buffer object(s).
1022 while ((length
< return_object
->buffer
.length
) &&
1023 (return_object
->buffer
.pointer
[length
])) {
1027 /* Allocate a new string object */
1029 new_object
= acpi_ut_create_string_object(length
);
1031 return (AE_NO_MEMORY
);
1035 * Copy the raw buffer data with no transform. String is already NULL
1036 * terminated at Length+1.
1038 ACPI_MEMCPY(new_object
->string
.pointer
,
1039 return_object
->buffer
.pointer
, length
);
1041 /* Install the new return object */
1043 acpi_ut_remove_reference(return_object
);
1044 *return_object_ptr
= new_object
;
1047 * If the object is a package element, we need to:
1048 * 1. Decrement the reference count of the orignal object, it was
1049 * incremented when building the package
1050 * 2. Increment the reference count of the new object, it will be
1051 * decremented when releasing the package
1053 if (package_index
!= ACPI_NOT_PACKAGE
) {
1054 acpi_ut_remove_reference(return_object
);
1055 acpi_ut_add_reference(new_object
);
1063 return (AE_AML_OPERAND_TYPE
);