10d02842fSSascha Wildner /*******************************************************************************
20d02842fSSascha Wildner *
30d02842fSSascha Wildner * Module Name: nsxfeval - Public interfaces to the ACPI subsystem
40d02842fSSascha Wildner * ACPI Object evaluation interfaces
50d02842fSSascha Wildner *
60d02842fSSascha Wildner ******************************************************************************/
70d02842fSSascha Wildner
8b4315fc7SSascha Wildner /******************************************************************************
9b4315fc7SSascha Wildner *
10b4315fc7SSascha Wildner * 1. Copyright Notice
11b4315fc7SSascha Wildner *
12*383048acSSascha Wildner * Some or all of this work - Copyright (c) 1999 - 2021, Intel Corp.
130d02842fSSascha Wildner * All rights reserved.
140d02842fSSascha Wildner *
15b4315fc7SSascha Wildner * 2. License
16b4315fc7SSascha Wildner *
17b4315fc7SSascha Wildner * 2.1. This is your license from Intel Corp. under its intellectual property
18b4315fc7SSascha Wildner * rights. You may have additional license terms from the party that provided
19b4315fc7SSascha Wildner * you this software, covering your right to use that party's intellectual
20b4315fc7SSascha Wildner * property rights.
21b4315fc7SSascha Wildner *
22b4315fc7SSascha Wildner * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
23b4315fc7SSascha Wildner * copy of the source code appearing in this file ("Covered Code") an
24b4315fc7SSascha Wildner * irrevocable, perpetual, worldwide license under Intel's copyrights in the
25b4315fc7SSascha Wildner * base code distributed originally by Intel ("Original Intel Code") to copy,
26b4315fc7SSascha Wildner * make derivatives, distribute, use and display any portion of the Covered
27b4315fc7SSascha Wildner * Code in any form, with the right to sublicense such rights; and
28b4315fc7SSascha Wildner *
29b4315fc7SSascha Wildner * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
30b4315fc7SSascha Wildner * license (with the right to sublicense), under only those claims of Intel
31b4315fc7SSascha Wildner * patents that are infringed by the Original Intel Code, to make, use, sell,
32b4315fc7SSascha Wildner * offer to sell, and import the Covered Code and derivative works thereof
33b4315fc7SSascha Wildner * solely to the minimum extent necessary to exercise the above copyright
34b4315fc7SSascha Wildner * license, and in no event shall the patent license extend to any additions
35b4315fc7SSascha Wildner * to or modifications of the Original Intel Code. No other license or right
36b4315fc7SSascha Wildner * is granted directly or by implication, estoppel or otherwise;
37b4315fc7SSascha Wildner *
38b4315fc7SSascha Wildner * The above copyright and patent license is granted only if the following
39b4315fc7SSascha Wildner * conditions are met:
40b4315fc7SSascha Wildner *
41b4315fc7SSascha Wildner * 3. Conditions
42b4315fc7SSascha Wildner *
43b4315fc7SSascha Wildner * 3.1. Redistribution of Source with Rights to Further Distribute Source.
44b4315fc7SSascha Wildner * Redistribution of source code of any substantial portion of the Covered
45b4315fc7SSascha Wildner * Code or modification with rights to further distribute source must include
46b4315fc7SSascha Wildner * the above Copyright Notice, the above License, this list of Conditions,
47b4315fc7SSascha Wildner * and the following Disclaimer and Export Compliance provision. In addition,
48b4315fc7SSascha Wildner * Licensee must cause all Covered Code to which Licensee contributes to
49b4315fc7SSascha Wildner * contain a file documenting the changes Licensee made to create that Covered
50b4315fc7SSascha Wildner * Code and the date of any change. Licensee must include in that file the
51b4315fc7SSascha Wildner * documentation of any changes made by any predecessor Licensee. Licensee
52b4315fc7SSascha Wildner * must include a prominent statement that the modification is derived,
53b4315fc7SSascha Wildner * directly or indirectly, from Original Intel Code.
54b4315fc7SSascha Wildner *
55b4315fc7SSascha Wildner * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
56b4315fc7SSascha Wildner * Redistribution of source code of any substantial portion of the Covered
57b4315fc7SSascha Wildner * Code or modification without rights to further distribute source must
58b4315fc7SSascha Wildner * include the following Disclaimer and Export Compliance provision in the
59b4315fc7SSascha Wildner * documentation and/or other materials provided with distribution. In
60b4315fc7SSascha Wildner * addition, Licensee may not authorize further sublicense of source of any
61b4315fc7SSascha Wildner * portion of the Covered Code, and must include terms to the effect that the
62b4315fc7SSascha Wildner * license from Licensee to its licensee is limited to the intellectual
63b4315fc7SSascha Wildner * property embodied in the software Licensee provides to its licensee, and
64b4315fc7SSascha Wildner * not to intellectual property embodied in modifications its licensee may
65b4315fc7SSascha Wildner * make.
66b4315fc7SSascha Wildner *
67b4315fc7SSascha Wildner * 3.3. Redistribution of Executable. Redistribution in executable form of any
68b4315fc7SSascha Wildner * substantial portion of the Covered Code or modification must reproduce the
69b4315fc7SSascha Wildner * above Copyright Notice, and the following Disclaimer and Export Compliance
70b4315fc7SSascha Wildner * provision in the documentation and/or other materials provided with the
71b4315fc7SSascha Wildner * distribution.
72b4315fc7SSascha Wildner *
73b4315fc7SSascha Wildner * 3.4. Intel retains all right, title, and interest in and to the Original
74b4315fc7SSascha Wildner * Intel Code.
75b4315fc7SSascha Wildner *
76b4315fc7SSascha Wildner * 3.5. Neither the name Intel nor any other trademark owned or controlled by
77b4315fc7SSascha Wildner * Intel shall be used in advertising or otherwise to promote the sale, use or
78b4315fc7SSascha Wildner * other dealings in products derived from or relating to the Covered Code
79b4315fc7SSascha Wildner * without prior written authorization from Intel.
80b4315fc7SSascha Wildner *
81b4315fc7SSascha Wildner * 4. Disclaimer and Export Compliance
82b4315fc7SSascha Wildner *
83b4315fc7SSascha Wildner * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
84b4315fc7SSascha Wildner * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
85b4315fc7SSascha Wildner * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
86b4315fc7SSascha Wildner * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
87b4315fc7SSascha Wildner * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
88b4315fc7SSascha Wildner * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
89b4315fc7SSascha Wildner * PARTICULAR PURPOSE.
90b4315fc7SSascha Wildner *
91b4315fc7SSascha Wildner * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
92b4315fc7SSascha Wildner * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
93b4315fc7SSascha Wildner * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
94b4315fc7SSascha Wildner * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
95b4315fc7SSascha Wildner * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
96b4315fc7SSascha Wildner * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
97b4315fc7SSascha Wildner * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
98b4315fc7SSascha Wildner * LIMITED REMEDY.
99b4315fc7SSascha Wildner *
100b4315fc7SSascha Wildner * 4.3. Licensee shall not export, either directly or indirectly, any of this
101b4315fc7SSascha Wildner * software or system incorporating such software without first obtaining any
102b4315fc7SSascha Wildner * required license or other approval from the U. S. Department of Commerce or
103b4315fc7SSascha Wildner * any other agency or department of the United States Government. In the
104b4315fc7SSascha Wildner * event Licensee exports any such software from the United States or
105b4315fc7SSascha Wildner * re-exports any such software from a foreign destination, Licensee shall
106b4315fc7SSascha Wildner * ensure that the distribution and export/re-export of the software is in
107b4315fc7SSascha Wildner * compliance with all laws, regulations, orders, or other restrictions of the
108b4315fc7SSascha Wildner * U.S. Export Administration Regulations. Licensee agrees that neither it nor
109b4315fc7SSascha Wildner * any of its subsidiaries will export/re-export any technical data, process,
110b4315fc7SSascha Wildner * software, or service, directly or indirectly, to any country for which the
111b4315fc7SSascha Wildner * United States government or any agency thereof requires an export license,
112b4315fc7SSascha Wildner * other governmental approval, or letter of assurance, without first obtaining
113b4315fc7SSascha Wildner * such license, approval or letter.
114b4315fc7SSascha Wildner *
115b4315fc7SSascha Wildner *****************************************************************************
116b4315fc7SSascha Wildner *
117b4315fc7SSascha Wildner * Alternatively, you may choose to be licensed under the terms of the
118b4315fc7SSascha Wildner * following license:
119b4315fc7SSascha Wildner *
1200d02842fSSascha Wildner * Redistribution and use in source and binary forms, with or without
1210d02842fSSascha Wildner * modification, are permitted provided that the following conditions
1220d02842fSSascha Wildner * are met:
1230d02842fSSascha Wildner * 1. Redistributions of source code must retain the above copyright
1240d02842fSSascha Wildner * notice, this list of conditions, and the following disclaimer,
1250d02842fSSascha Wildner * without modification.
1260d02842fSSascha Wildner * 2. Redistributions in binary form must reproduce at minimum a disclaimer
1270d02842fSSascha Wildner * substantially similar to the "NO WARRANTY" disclaimer below
1280d02842fSSascha Wildner * ("Disclaimer") and any redistribution must be conditioned upon
1290d02842fSSascha Wildner * including a substantially similar Disclaimer requirement for further
1300d02842fSSascha Wildner * binary redistribution.
1310d02842fSSascha Wildner * 3. Neither the names of the above-listed copyright holders nor the names
1320d02842fSSascha Wildner * of any contributors may be used to endorse or promote products derived
1330d02842fSSascha Wildner * from this software without specific prior written permission.
1340d02842fSSascha Wildner *
135b4315fc7SSascha Wildner * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
136b4315fc7SSascha Wildner * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
137b4315fc7SSascha Wildner * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
138b4315fc7SSascha Wildner * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
139b4315fc7SSascha Wildner * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
140b4315fc7SSascha Wildner * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
141b4315fc7SSascha Wildner * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
142b4315fc7SSascha Wildner * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
143b4315fc7SSascha Wildner * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
144b4315fc7SSascha Wildner * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
145b4315fc7SSascha Wildner * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
146b4315fc7SSascha Wildner *
147b4315fc7SSascha Wildner * Alternatively, you may choose to be licensed under the terms of the
1480d02842fSSascha Wildner * GNU General Public License ("GPL") version 2 as published by the Free
1490d02842fSSascha Wildner * Software Foundation.
1500d02842fSSascha Wildner *
151b4315fc7SSascha Wildner *****************************************************************************/
1520d02842fSSascha Wildner
1530d02842fSSascha Wildner #define EXPORT_ACPI_INTERFACES
1540d02842fSSascha Wildner
1550d02842fSSascha Wildner #include "acpi.h"
1560d02842fSSascha Wildner #include "accommon.h"
1570d02842fSSascha Wildner #include "acnamesp.h"
1580d02842fSSascha Wildner #include "acinterp.h"
1590d02842fSSascha Wildner
1600d02842fSSascha Wildner
1610d02842fSSascha Wildner #define _COMPONENT ACPI_NAMESPACE
1620d02842fSSascha Wildner ACPI_MODULE_NAME ("nsxfeval")
1630d02842fSSascha Wildner
1640d02842fSSascha Wildner /* Local prototypes */
1650d02842fSSascha Wildner
1660d02842fSSascha Wildner static void
1670d02842fSSascha Wildner AcpiNsResolveReferences (
1680d02842fSSascha Wildner ACPI_EVALUATE_INFO *Info);
1690d02842fSSascha Wildner
1700d02842fSSascha Wildner
1710d02842fSSascha Wildner /*******************************************************************************
1720d02842fSSascha Wildner *
1730d02842fSSascha Wildner * FUNCTION: AcpiEvaluateObjectTyped
1740d02842fSSascha Wildner *
1750d02842fSSascha Wildner * PARAMETERS: Handle - Object handle (optional)
1760d02842fSSascha Wildner * Pathname - Object pathname (optional)
1777bcb6cafSSascha Wildner * ExternalParams - List of parameters to pass to a method,
1780d02842fSSascha Wildner * terminated by NULL. May be NULL
1790d02842fSSascha Wildner * if no parameters are being passed.
1807bcb6cafSSascha Wildner * ReturnBuffer - Where to put the object return value (if
1817bcb6cafSSascha Wildner * any). Required.
1820d02842fSSascha Wildner * ReturnType - Expected type of return object
1830d02842fSSascha Wildner *
1840d02842fSSascha Wildner * RETURN: Status
1850d02842fSSascha Wildner *
1860d02842fSSascha Wildner * DESCRIPTION: Find and evaluate the given object, passing the given
1870d02842fSSascha Wildner * parameters if necessary. One of "Handle" or "Pathname" must
1880d02842fSSascha Wildner * be valid (non-null)
1890d02842fSSascha Wildner *
1900d02842fSSascha Wildner ******************************************************************************/
1910d02842fSSascha Wildner
1920d02842fSSascha Wildner ACPI_STATUS
AcpiEvaluateObjectTyped(ACPI_HANDLE Handle,ACPI_STRING Pathname,ACPI_OBJECT_LIST * ExternalParams,ACPI_BUFFER * ReturnBuffer,ACPI_OBJECT_TYPE ReturnType)1930d02842fSSascha Wildner AcpiEvaluateObjectTyped (
1940d02842fSSascha Wildner ACPI_HANDLE Handle,
1950d02842fSSascha Wildner ACPI_STRING Pathname,
1960d02842fSSascha Wildner ACPI_OBJECT_LIST *ExternalParams,
1970d02842fSSascha Wildner ACPI_BUFFER *ReturnBuffer,
1980d02842fSSascha Wildner ACPI_OBJECT_TYPE ReturnType)
1990d02842fSSascha Wildner {
2000d02842fSSascha Wildner ACPI_STATUS Status;
2010d02842fSSascha Wildner BOOLEAN FreeBufferOnError = FALSE;
2021093ca81SSascha Wildner ACPI_HANDLE TargetHandle;
2031093ca81SSascha Wildner char *FullPathname;
2040d02842fSSascha Wildner
2050d02842fSSascha Wildner
2060d02842fSSascha Wildner ACPI_FUNCTION_TRACE (AcpiEvaluateObjectTyped);
2070d02842fSSascha Wildner
2080d02842fSSascha Wildner
2090d02842fSSascha Wildner /* Return buffer must be valid */
2100d02842fSSascha Wildner
2110d02842fSSascha Wildner if (!ReturnBuffer)
2120d02842fSSascha Wildner {
2130d02842fSSascha Wildner return_ACPI_STATUS (AE_BAD_PARAMETER);
2140d02842fSSascha Wildner }
2150d02842fSSascha Wildner
2160d02842fSSascha Wildner if (ReturnBuffer->Length == ACPI_ALLOCATE_BUFFER)
2170d02842fSSascha Wildner {
2180d02842fSSascha Wildner FreeBufferOnError = TRUE;
2190d02842fSSascha Wildner }
2200d02842fSSascha Wildner
2217bcb6cafSSascha Wildner /* Get a handle here, in order to build an error message if needed */
2227bcb6cafSSascha Wildner
2237bcb6cafSSascha Wildner TargetHandle = Handle;
2247bcb6cafSSascha Wildner if (Pathname)
2257bcb6cafSSascha Wildner {
2261093ca81SSascha Wildner Status = AcpiGetHandle (Handle, Pathname, &TargetHandle);
2270d02842fSSascha Wildner if (ACPI_FAILURE (Status))
2280d02842fSSascha Wildner {
2290d02842fSSascha Wildner return_ACPI_STATUS (Status);
2300d02842fSSascha Wildner }
2317bcb6cafSSascha Wildner }
2320d02842fSSascha Wildner
2331093ca81SSascha Wildner FullPathname = AcpiNsGetExternalPathname (TargetHandle);
2341093ca81SSascha Wildner if (!FullPathname)
2351093ca81SSascha Wildner {
2361093ca81SSascha Wildner return_ACPI_STATUS (AE_NO_MEMORY);
2371093ca81SSascha Wildner }
2381093ca81SSascha Wildner
2391093ca81SSascha Wildner /* Evaluate the object */
2401093ca81SSascha Wildner
2411093ca81SSascha Wildner Status = AcpiEvaluateObject (TargetHandle, NULL, ExternalParams,
2421093ca81SSascha Wildner ReturnBuffer);
2431093ca81SSascha Wildner if (ACPI_FAILURE (Status))
2441093ca81SSascha Wildner {
2451093ca81SSascha Wildner goto Exit;
2461093ca81SSascha Wildner }
2471093ca81SSascha Wildner
2481093ca81SSascha Wildner /* Type ANY means "don't care about return value type" */
2490d02842fSSascha Wildner
2500d02842fSSascha Wildner if (ReturnType == ACPI_TYPE_ANY)
2510d02842fSSascha Wildner {
2521093ca81SSascha Wildner goto Exit;
2530d02842fSSascha Wildner }
2540d02842fSSascha Wildner
2550d02842fSSascha Wildner if (ReturnBuffer->Length == 0)
2560d02842fSSascha Wildner {
2570d02842fSSascha Wildner /* Error because caller specifically asked for a return value */
2580d02842fSSascha Wildner
2591093ca81SSascha Wildner ACPI_ERROR ((AE_INFO, "%s did not return any object",
2601093ca81SSascha Wildner FullPathname));
2611093ca81SSascha Wildner Status = AE_NULL_OBJECT;
2621093ca81SSascha Wildner goto Exit;
2630d02842fSSascha Wildner }
2640d02842fSSascha Wildner
2650d02842fSSascha Wildner /* Examine the object type returned from EvaluateObject */
2660d02842fSSascha Wildner
2670d02842fSSascha Wildner if (((ACPI_OBJECT *) ReturnBuffer->Pointer)->Type == ReturnType)
2680d02842fSSascha Wildner {
2691093ca81SSascha Wildner goto Exit;
2700d02842fSSascha Wildner }
2710d02842fSSascha Wildner
2720d02842fSSascha Wildner /* Return object type does not match requested type */
2730d02842fSSascha Wildner
2740d02842fSSascha Wildner ACPI_ERROR ((AE_INFO,
2751093ca81SSascha Wildner "Incorrect return type from %s - received [%s], requested [%s]",
2761093ca81SSascha Wildner FullPathname,
2770d02842fSSascha Wildner AcpiUtGetTypeName (((ACPI_OBJECT *) ReturnBuffer->Pointer)->Type),
2780d02842fSSascha Wildner AcpiUtGetTypeName (ReturnType)));
2790d02842fSSascha Wildner
2800d02842fSSascha Wildner if (FreeBufferOnError)
2810d02842fSSascha Wildner {
2820d02842fSSascha Wildner /*
2830d02842fSSascha Wildner * Free a buffer created via ACPI_ALLOCATE_BUFFER.
2840d02842fSSascha Wildner * Note: We use AcpiOsFree here because AcpiOsAllocate was used
2850d02842fSSascha Wildner * to allocate the buffer. This purposefully bypasses the
2860d02842fSSascha Wildner * (optionally enabled) allocation tracking mechanism since we
2870d02842fSSascha Wildner * only want to track internal allocations.
2880d02842fSSascha Wildner */
2890d02842fSSascha Wildner AcpiOsFree (ReturnBuffer->Pointer);
2900d02842fSSascha Wildner ReturnBuffer->Pointer = NULL;
2910d02842fSSascha Wildner }
2920d02842fSSascha Wildner
2930d02842fSSascha Wildner ReturnBuffer->Length = 0;
2941093ca81SSascha Wildner Status = AE_TYPE;
2951093ca81SSascha Wildner
2961093ca81SSascha Wildner Exit:
2971093ca81SSascha Wildner ACPI_FREE (FullPathname);
2981093ca81SSascha Wildner return_ACPI_STATUS (Status);
2990d02842fSSascha Wildner }
3000d02842fSSascha Wildner
ACPI_EXPORT_SYMBOL(AcpiEvaluateObjectTyped)3010d02842fSSascha Wildner ACPI_EXPORT_SYMBOL (AcpiEvaluateObjectTyped)
3020d02842fSSascha Wildner
3030d02842fSSascha Wildner
3040d02842fSSascha Wildner /*******************************************************************************
3050d02842fSSascha Wildner *
3060d02842fSSascha Wildner * FUNCTION: AcpiEvaluateObject
3070d02842fSSascha Wildner *
3080d02842fSSascha Wildner * PARAMETERS: Handle - Object handle (optional)
3090d02842fSSascha Wildner * Pathname - Object pathname (optional)
3100d02842fSSascha Wildner * ExternalParams - List of parameters to pass to method,
3110d02842fSSascha Wildner * terminated by NULL. May be NULL
3120d02842fSSascha Wildner * if no parameters are being passed.
3130d02842fSSascha Wildner * ReturnBuffer - Where to put method's return value (if
3140d02842fSSascha Wildner * any). If NULL, no value is returned.
3150d02842fSSascha Wildner *
3160d02842fSSascha Wildner * RETURN: Status
3170d02842fSSascha Wildner *
3180d02842fSSascha Wildner * DESCRIPTION: Find and evaluate the given object, passing the given
3190d02842fSSascha Wildner * parameters if necessary. One of "Handle" or "Pathname" must
3200d02842fSSascha Wildner * be valid (non-null)
3210d02842fSSascha Wildner *
3220d02842fSSascha Wildner ******************************************************************************/
3230d02842fSSascha Wildner
3240d02842fSSascha Wildner ACPI_STATUS
3250d02842fSSascha Wildner AcpiEvaluateObject (
3260d02842fSSascha Wildner ACPI_HANDLE Handle,
3270d02842fSSascha Wildner ACPI_STRING Pathname,
3280d02842fSSascha Wildner ACPI_OBJECT_LIST *ExternalParams,
3290d02842fSSascha Wildner ACPI_BUFFER *ReturnBuffer)
3300d02842fSSascha Wildner {
3310d02842fSSascha Wildner ACPI_STATUS Status;
3320d02842fSSascha Wildner ACPI_EVALUATE_INFO *Info;
3330d02842fSSascha Wildner ACPI_SIZE BufferSpaceNeeded;
3340d02842fSSascha Wildner UINT32 i;
3350d02842fSSascha Wildner
3360d02842fSSascha Wildner
3370d02842fSSascha Wildner ACPI_FUNCTION_TRACE (AcpiEvaluateObject);
3380d02842fSSascha Wildner
3390d02842fSSascha Wildner
3400d02842fSSascha Wildner /* Allocate and initialize the evaluation information block */
3410d02842fSSascha Wildner
3420d02842fSSascha Wildner Info = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_EVALUATE_INFO));
3430d02842fSSascha Wildner if (!Info)
3440d02842fSSascha Wildner {
3450d02842fSSascha Wildner return_ACPI_STATUS (AE_NO_MEMORY);
3460d02842fSSascha Wildner }
3470d02842fSSascha Wildner
3480d02842fSSascha Wildner /* Convert and validate the device handle */
3490d02842fSSascha Wildner
3500d02842fSSascha Wildner Info->PrefixNode = AcpiNsValidateHandle (Handle);
3510d02842fSSascha Wildner if (!Info->PrefixNode)
3520d02842fSSascha Wildner {
3530d02842fSSascha Wildner Status = AE_BAD_PARAMETER;
3540d02842fSSascha Wildner goto Cleanup;
3550d02842fSSascha Wildner }
3560d02842fSSascha Wildner
3570d02842fSSascha Wildner /*
3580d02842fSSascha Wildner * Get the actual namespace node for the target object.
3590d02842fSSascha Wildner * Handles these cases:
3600d02842fSSascha Wildner *
3610d02842fSSascha Wildner * 1) Null node, valid pathname from root (absolute path)
3620d02842fSSascha Wildner * 2) Node and valid pathname (path relative to Node)
3630d02842fSSascha Wildner * 3) Node, Null pathname
3640d02842fSSascha Wildner */
3650d02842fSSascha Wildner if ((Pathname) &&
3660d02842fSSascha Wildner (ACPI_IS_ROOT_PREFIX (Pathname[0])))
3670d02842fSSascha Wildner {
3680d02842fSSascha Wildner /* The path is fully qualified, just evaluate by name */
3690d02842fSSascha Wildner
3700d02842fSSascha Wildner Info->PrefixNode = NULL;
3710d02842fSSascha Wildner }
3720d02842fSSascha Wildner else if (!Handle)
3730d02842fSSascha Wildner {
3740d02842fSSascha Wildner /*
3750d02842fSSascha Wildner * A handle is optional iff a fully qualified pathname is specified.
3760d02842fSSascha Wildner * Since we've already handled fully qualified names above, this is
3770d02842fSSascha Wildner * an error.
3780d02842fSSascha Wildner */
3790d02842fSSascha Wildner if (!Pathname)
3800d02842fSSascha Wildner {
3810d02842fSSascha Wildner ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
3820d02842fSSascha Wildner "Both Handle and Pathname are NULL"));
3830d02842fSSascha Wildner }
3840d02842fSSascha Wildner else
3850d02842fSSascha Wildner {
3860d02842fSSascha Wildner ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
3870d02842fSSascha Wildner "Null Handle with relative pathname [%s]", Pathname));
3880d02842fSSascha Wildner }
3890d02842fSSascha Wildner
3900d02842fSSascha Wildner Status = AE_BAD_PARAMETER;
3910d02842fSSascha Wildner goto Cleanup;
3920d02842fSSascha Wildner }
3930d02842fSSascha Wildner
3940d02842fSSascha Wildner Info->RelativePathname = Pathname;
3950d02842fSSascha Wildner
3960d02842fSSascha Wildner /*
3970d02842fSSascha Wildner * Convert all external objects passed as arguments to the
3980d02842fSSascha Wildner * internal version(s).
3990d02842fSSascha Wildner */
4000d02842fSSascha Wildner if (ExternalParams && ExternalParams->Count)
4010d02842fSSascha Wildner {
4020d02842fSSascha Wildner Info->ParamCount = (UINT16) ExternalParams->Count;
4030d02842fSSascha Wildner
4040d02842fSSascha Wildner /* Warn on impossible argument count */
4050d02842fSSascha Wildner
4060d02842fSSascha Wildner if (Info->ParamCount > ACPI_METHOD_NUM_ARGS)
4070d02842fSSascha Wildner {
4080d02842fSSascha Wildner ACPI_WARN_PREDEFINED ((AE_INFO, Pathname, ACPI_WARN_ALWAYS,
4090d02842fSSascha Wildner "Excess arguments (%u) - using only %u",
4100d02842fSSascha Wildner Info->ParamCount, ACPI_METHOD_NUM_ARGS));
4110d02842fSSascha Wildner
4120d02842fSSascha Wildner Info->ParamCount = ACPI_METHOD_NUM_ARGS;
4130d02842fSSascha Wildner }
4140d02842fSSascha Wildner
4150d02842fSSascha Wildner /*
4160d02842fSSascha Wildner * Allocate a new parameter block for the internal objects
4170d02842fSSascha Wildner * Add 1 to count to allow for null terminated internal list
4180d02842fSSascha Wildner */
4190d02842fSSascha Wildner Info->Parameters = ACPI_ALLOCATE_ZEROED (
4200d02842fSSascha Wildner ((ACPI_SIZE) Info->ParamCount + 1) * sizeof (void *));
4210d02842fSSascha Wildner if (!Info->Parameters)
4220d02842fSSascha Wildner {
4230d02842fSSascha Wildner Status = AE_NO_MEMORY;
4240d02842fSSascha Wildner goto Cleanup;
4250d02842fSSascha Wildner }
4260d02842fSSascha Wildner
4270d02842fSSascha Wildner /* Convert each external object in the list to an internal object */
4280d02842fSSascha Wildner
4290d02842fSSascha Wildner for (i = 0; i < Info->ParamCount; i++)
4300d02842fSSascha Wildner {
4310d02842fSSascha Wildner Status = AcpiUtCopyEobjectToIobject (
4320d02842fSSascha Wildner &ExternalParams->Pointer[i], &Info->Parameters[i]);
4330d02842fSSascha Wildner if (ACPI_FAILURE (Status))
4340d02842fSSascha Wildner {
4350d02842fSSascha Wildner goto Cleanup;
4360d02842fSSascha Wildner }
4370d02842fSSascha Wildner }
4380d02842fSSascha Wildner
4390d02842fSSascha Wildner Info->Parameters[Info->ParamCount] = NULL;
4400d02842fSSascha Wildner }
4410d02842fSSascha Wildner
4420d02842fSSascha Wildner
4430d27ae55SSascha Wildner #ifdef _FUTURE_FEATURE
4440d02842fSSascha Wildner
4450d02842fSSascha Wildner /*
4460d02842fSSascha Wildner * Begin incoming argument count analysis. Check for too few args
4470d02842fSSascha Wildner * and too many args.
4480d02842fSSascha Wildner */
4490d02842fSSascha Wildner switch (AcpiNsGetType (Info->Node))
4500d02842fSSascha Wildner {
4510d02842fSSascha Wildner case ACPI_TYPE_METHOD:
4520d02842fSSascha Wildner
4530d02842fSSascha Wildner /* Check incoming argument count against the method definition */
4540d02842fSSascha Wildner
4550d02842fSSascha Wildner if (Info->ObjDesc->Method.ParamCount > Info->ParamCount)
4560d02842fSSascha Wildner {
4570d02842fSSascha Wildner ACPI_ERROR ((AE_INFO,
4580d02842fSSascha Wildner "Insufficient arguments (%u) - %u are required",
4590d02842fSSascha Wildner Info->ParamCount,
4600d02842fSSascha Wildner Info->ObjDesc->Method.ParamCount));
4610d02842fSSascha Wildner
4620d02842fSSascha Wildner Status = AE_MISSING_ARGUMENTS;
4630d02842fSSascha Wildner goto Cleanup;
4640d02842fSSascha Wildner }
4650d02842fSSascha Wildner
4660d02842fSSascha Wildner else if (Info->ObjDesc->Method.ParamCount < Info->ParamCount)
4670d02842fSSascha Wildner {
4680d02842fSSascha Wildner ACPI_WARNING ((AE_INFO,
4690d02842fSSascha Wildner "Excess arguments (%u) - only %u are required",
4700d02842fSSascha Wildner Info->ParamCount,
4710d02842fSSascha Wildner Info->ObjDesc->Method.ParamCount));
4720d02842fSSascha Wildner
4730d02842fSSascha Wildner /* Just pass the required number of arguments */
4740d02842fSSascha Wildner
4750d02842fSSascha Wildner Info->ParamCount = Info->ObjDesc->Method.ParamCount;
4760d02842fSSascha Wildner }
4770d02842fSSascha Wildner
4780d02842fSSascha Wildner /*
4790d02842fSSascha Wildner * Any incoming external objects to be passed as arguments to the
4800d02842fSSascha Wildner * method must be converted to internal objects
4810d02842fSSascha Wildner */
4820d02842fSSascha Wildner if (Info->ParamCount)
4830d02842fSSascha Wildner {
4840d02842fSSascha Wildner /*
4850d02842fSSascha Wildner * Allocate a new parameter block for the internal objects
4860d02842fSSascha Wildner * Add 1 to count to allow for null terminated internal list
4870d02842fSSascha Wildner */
4880d02842fSSascha Wildner Info->Parameters = ACPI_ALLOCATE_ZEROED (
4890d02842fSSascha Wildner ((ACPI_SIZE) Info->ParamCount + 1) * sizeof (void *));
4900d02842fSSascha Wildner if (!Info->Parameters)
4910d02842fSSascha Wildner {
4920d02842fSSascha Wildner Status = AE_NO_MEMORY;
4930d02842fSSascha Wildner goto Cleanup;
4940d02842fSSascha Wildner }
4950d02842fSSascha Wildner
4960d02842fSSascha Wildner /* Convert each external object in the list to an internal object */
4970d02842fSSascha Wildner
4980d02842fSSascha Wildner for (i = 0; i < Info->ParamCount; i++)
4990d02842fSSascha Wildner {
5000d02842fSSascha Wildner Status = AcpiUtCopyEobjectToIobject (
5010d02842fSSascha Wildner &ExternalParams->Pointer[i], &Info->Parameters[i]);
5020d02842fSSascha Wildner if (ACPI_FAILURE (Status))
5030d02842fSSascha Wildner {
5040d02842fSSascha Wildner goto Cleanup;
5050d02842fSSascha Wildner }
5060d02842fSSascha Wildner }
5070d02842fSSascha Wildner
5080d02842fSSascha Wildner Info->Parameters[Info->ParamCount] = NULL;
5090d02842fSSascha Wildner }
5100d02842fSSascha Wildner break;
5110d02842fSSascha Wildner
5120d02842fSSascha Wildner default:
5130d02842fSSascha Wildner
5140d02842fSSascha Wildner /* Warn if arguments passed to an object that is not a method */
5150d02842fSSascha Wildner
5160d02842fSSascha Wildner if (Info->ParamCount)
5170d02842fSSascha Wildner {
5180d02842fSSascha Wildner ACPI_WARNING ((AE_INFO,
5190d02842fSSascha Wildner "%u arguments were passed to a non-method ACPI object",
5200d02842fSSascha Wildner Info->ParamCount));
5210d02842fSSascha Wildner }
5220d02842fSSascha Wildner break;
5230d02842fSSascha Wildner }
5240d02842fSSascha Wildner
5250d02842fSSascha Wildner #endif
5260d02842fSSascha Wildner
5270d02842fSSascha Wildner
5280d02842fSSascha Wildner /* Now we can evaluate the object */
5290d02842fSSascha Wildner
5300d02842fSSascha Wildner Status = AcpiNsEvaluate (Info);
5310d02842fSSascha Wildner
5320d02842fSSascha Wildner /*
5330d02842fSSascha Wildner * If we are expecting a return value, and all went well above,
5340d02842fSSascha Wildner * copy the return value to an external object.
5350d02842fSSascha Wildner */
5360d27ae55SSascha Wildner if (!ReturnBuffer)
5370d02842fSSascha Wildner {
5380d27ae55SSascha Wildner goto CleanupReturnObject;
5390d27ae55SSascha Wildner }
5400d27ae55SSascha Wildner
5410d02842fSSascha Wildner if (!Info->ReturnObject)
5420d02842fSSascha Wildner {
5430d02842fSSascha Wildner ReturnBuffer->Length = 0;
5440d27ae55SSascha Wildner goto Cleanup;
5450d02842fSSascha Wildner }
5460d27ae55SSascha Wildner
5470d02842fSSascha Wildner if (ACPI_GET_DESCRIPTOR_TYPE (Info->ReturnObject) ==
5480d02842fSSascha Wildner ACPI_DESC_TYPE_NAMED)
5490d02842fSSascha Wildner {
5500d02842fSSascha Wildner /*
5510d02842fSSascha Wildner * If we received a NS Node as a return object, this means that
5520d02842fSSascha Wildner * the object we are evaluating has nothing interesting to
5530d02842fSSascha Wildner * return (such as a mutex, etc.) We return an error because
5540d02842fSSascha Wildner * these types are essentially unsupported by this interface.
5550d02842fSSascha Wildner * We don't check up front because this makes it easier to add
5560d02842fSSascha Wildner * support for various types at a later date if necessary.
5570d02842fSSascha Wildner */
5580d02842fSSascha Wildner Status = AE_TYPE;
5590d02842fSSascha Wildner Info->ReturnObject = NULL; /* No need to delete a NS Node */
5600d02842fSSascha Wildner ReturnBuffer->Length = 0;
5610d02842fSSascha Wildner }
5620d02842fSSascha Wildner
5630d27ae55SSascha Wildner if (ACPI_FAILURE (Status))
5640d02842fSSascha Wildner {
5650d27ae55SSascha Wildner goto CleanupReturnObject;
5660d27ae55SSascha Wildner }
5670d27ae55SSascha Wildner
5680d02842fSSascha Wildner /* Dereference Index and RefOf references */
5690d02842fSSascha Wildner
5700d02842fSSascha Wildner AcpiNsResolveReferences (Info);
5710d02842fSSascha Wildner
5720d02842fSSascha Wildner /* Get the size of the returned object */
5730d02842fSSascha Wildner
5740d02842fSSascha Wildner Status = AcpiUtGetObjectSize (Info->ReturnObject,
5750d02842fSSascha Wildner &BufferSpaceNeeded);
5760d02842fSSascha Wildner if (ACPI_SUCCESS (Status))
5770d02842fSSascha Wildner {
5780d02842fSSascha Wildner /* Validate/Allocate/Clear caller buffer */
5790d02842fSSascha Wildner
5800d02842fSSascha Wildner Status = AcpiUtInitializeBuffer (ReturnBuffer,
5810d02842fSSascha Wildner BufferSpaceNeeded);
5820d02842fSSascha Wildner if (ACPI_FAILURE (Status))
5830d02842fSSascha Wildner {
5840d02842fSSascha Wildner /*
5850d02842fSSascha Wildner * Caller's buffer is too small or a new one can't
5860d02842fSSascha Wildner * be allocated
5870d02842fSSascha Wildner */
5880d02842fSSascha Wildner ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
5890d02842fSSascha Wildner "Needed buffer size %X, %s\n",
5900d02842fSSascha Wildner (UINT32) BufferSpaceNeeded,
5910d02842fSSascha Wildner AcpiFormatException (Status)));
5920d02842fSSascha Wildner }
5930d02842fSSascha Wildner else
5940d02842fSSascha Wildner {
5950d02842fSSascha Wildner /* We have enough space for the object, build it */
5960d02842fSSascha Wildner
597820c5b08SSascha Wildner Status = AcpiUtCopyIobjectToEobject (
598820c5b08SSascha Wildner Info->ReturnObject, ReturnBuffer);
5990d02842fSSascha Wildner }
6000d02842fSSascha Wildner }
6010d27ae55SSascha Wildner
6020d27ae55SSascha Wildner CleanupReturnObject:
6030d02842fSSascha Wildner
6040d02842fSSascha Wildner if (Info->ReturnObject)
6050d02842fSSascha Wildner {
6060d02842fSSascha Wildner /*
6070d02842fSSascha Wildner * Delete the internal return object. NOTE: Interpreter must be
6080d02842fSSascha Wildner * locked to avoid race condition.
6090d02842fSSascha Wildner */
6100d02842fSSascha Wildner AcpiExEnterInterpreter ();
6110d02842fSSascha Wildner
6120d02842fSSascha Wildner /* Remove one reference on the return object (should delete it) */
6130d02842fSSascha Wildner
6140d02842fSSascha Wildner AcpiUtRemoveReference (Info->ReturnObject);
6150d02842fSSascha Wildner AcpiExExitInterpreter ();
6160d02842fSSascha Wildner }
6170d02842fSSascha Wildner
6180d02842fSSascha Wildner
6190d02842fSSascha Wildner Cleanup:
6200d02842fSSascha Wildner
6210d02842fSSascha Wildner /* Free the input parameter list (if we created one) */
6220d02842fSSascha Wildner
6230d02842fSSascha Wildner if (Info->Parameters)
6240d02842fSSascha Wildner {
6250d02842fSSascha Wildner /* Free the allocated parameter block */
6260d02842fSSascha Wildner
6270d02842fSSascha Wildner AcpiUtDeleteInternalObjectList (Info->Parameters);
6280d02842fSSascha Wildner }
6290d02842fSSascha Wildner
6300d02842fSSascha Wildner ACPI_FREE (Info);
6310d02842fSSascha Wildner return_ACPI_STATUS (Status);
6320d02842fSSascha Wildner }
6330d02842fSSascha Wildner
ACPI_EXPORT_SYMBOL(AcpiEvaluateObject)6340d02842fSSascha Wildner ACPI_EXPORT_SYMBOL (AcpiEvaluateObject)
6350d02842fSSascha Wildner
6360d02842fSSascha Wildner
6370d02842fSSascha Wildner /*******************************************************************************
6380d02842fSSascha Wildner *
6390d02842fSSascha Wildner * FUNCTION: AcpiNsResolveReferences
6400d02842fSSascha Wildner *
6410d02842fSSascha Wildner * PARAMETERS: Info - Evaluation info block
6420d02842fSSascha Wildner *
6430d02842fSSascha Wildner * RETURN: Info->ReturnObject is replaced with the dereferenced object
6440d02842fSSascha Wildner *
6450d02842fSSascha Wildner * DESCRIPTION: Dereference certain reference objects. Called before an
6460d02842fSSascha Wildner * internal return object is converted to an external ACPI_OBJECT.
6470d02842fSSascha Wildner *
6480d02842fSSascha Wildner * Performs an automatic dereference of Index and RefOf reference objects.
6490d02842fSSascha Wildner * These reference objects are not supported by the ACPI_OBJECT, so this is a
6500d02842fSSascha Wildner * last resort effort to return something useful. Also, provides compatibility
6510d02842fSSascha Wildner * with other ACPI implementations.
6520d02842fSSascha Wildner *
6530d02842fSSascha Wildner * NOTE: does not handle references within returned package objects or nested
6540d02842fSSascha Wildner * references, but this support could be added later if found to be necessary.
6550d02842fSSascha Wildner *
6560d02842fSSascha Wildner ******************************************************************************/
6570d02842fSSascha Wildner
6580d02842fSSascha Wildner static void
6590d02842fSSascha Wildner AcpiNsResolveReferences (
6600d02842fSSascha Wildner ACPI_EVALUATE_INFO *Info)
6610d02842fSSascha Wildner {
6620d02842fSSascha Wildner ACPI_OPERAND_OBJECT *ObjDesc = NULL;
6630d02842fSSascha Wildner ACPI_NAMESPACE_NODE *Node;
6640d02842fSSascha Wildner
6650d02842fSSascha Wildner
6660d02842fSSascha Wildner /* We are interested in reference objects only */
6670d02842fSSascha Wildner
6680d02842fSSascha Wildner if ((Info->ReturnObject)->Common.Type != ACPI_TYPE_LOCAL_REFERENCE)
6690d02842fSSascha Wildner {
6700d02842fSSascha Wildner return;
6710d02842fSSascha Wildner }
6720d02842fSSascha Wildner
6730d02842fSSascha Wildner /*
6740d02842fSSascha Wildner * Two types of references are supported - those created by Index and
6750d02842fSSascha Wildner * RefOf operators. A name reference (AML_NAMEPATH_OP) can be converted
6760d02842fSSascha Wildner * to an ACPI_OBJECT, so it is not dereferenced here. A DdbHandle
6770d02842fSSascha Wildner * (AML_LOAD_OP) cannot be dereferenced, nor can it be converted to
6780d02842fSSascha Wildner * an ACPI_OBJECT.
6790d02842fSSascha Wildner */
6800d02842fSSascha Wildner switch (Info->ReturnObject->Reference.Class)
6810d02842fSSascha Wildner {
6820d02842fSSascha Wildner case ACPI_REFCLASS_INDEX:
6830d02842fSSascha Wildner
6840d02842fSSascha Wildner ObjDesc = *(Info->ReturnObject->Reference.Where);
6850d02842fSSascha Wildner break;
6860d02842fSSascha Wildner
6870d02842fSSascha Wildner case ACPI_REFCLASS_REFOF:
6880d02842fSSascha Wildner
6890d02842fSSascha Wildner Node = Info->ReturnObject->Reference.Object;
6900d02842fSSascha Wildner if (Node)
6910d02842fSSascha Wildner {
6920d02842fSSascha Wildner ObjDesc = Node->Object;
6930d02842fSSascha Wildner }
6940d02842fSSascha Wildner break;
6950d02842fSSascha Wildner
6960d02842fSSascha Wildner default:
6970d02842fSSascha Wildner
6980d02842fSSascha Wildner return;
6990d02842fSSascha Wildner }
7000d02842fSSascha Wildner
7010d02842fSSascha Wildner /* Replace the existing reference object */
7020d02842fSSascha Wildner
7030d02842fSSascha Wildner if (ObjDesc)
7040d02842fSSascha Wildner {
7050d02842fSSascha Wildner AcpiUtAddReference (ObjDesc);
7060d02842fSSascha Wildner AcpiUtRemoveReference (Info->ReturnObject);
7070d02842fSSascha Wildner Info->ReturnObject = ObjDesc;
7080d02842fSSascha Wildner }
7090d02842fSSascha Wildner
7100d02842fSSascha Wildner return;
7110d02842fSSascha Wildner }
7120d02842fSSascha Wildner
7130d02842fSSascha Wildner
7140d02842fSSascha Wildner /*******************************************************************************
7150d02842fSSascha Wildner *
7160d02842fSSascha Wildner * FUNCTION: AcpiWalkNamespace
7170d02842fSSascha Wildner *
7180d02842fSSascha Wildner * PARAMETERS: Type - ACPI_OBJECT_TYPE to search for
7190d02842fSSascha Wildner * StartObject - Handle in namespace where search begins
7200d02842fSSascha Wildner * MaxDepth - Depth to which search is to reach
7210d02842fSSascha Wildner * DescendingCallback - Called during tree descent
7220d02842fSSascha Wildner * when an object of "Type" is found
7230d02842fSSascha Wildner * AscendingCallback - Called during tree ascent
7240d02842fSSascha Wildner * when an object of "Type" is found
7250d02842fSSascha Wildner * Context - Passed to user function(s) above
7260d02842fSSascha Wildner * ReturnValue - Location where return value of
7270d02842fSSascha Wildner * UserFunction is put if terminated early
7280d02842fSSascha Wildner *
7290d02842fSSascha Wildner * RETURNS Return value from the UserFunction if terminated early.
7300d02842fSSascha Wildner * Otherwise, returns NULL.
7310d02842fSSascha Wildner *
7320d02842fSSascha Wildner * DESCRIPTION: Performs a modified depth-first walk of the namespace tree,
7330d02842fSSascha Wildner * starting (and ending) at the object specified by StartHandle.
7340d02842fSSascha Wildner * The callback function is called whenever an object that matches
7350d02842fSSascha Wildner * the type parameter is found. If the callback function returns
7360d02842fSSascha Wildner * a non-zero value, the search is terminated immediately and this
7370d02842fSSascha Wildner * value is returned to the caller.
7380d02842fSSascha Wildner *
7390d02842fSSascha Wildner * The point of this procedure is to provide a generic namespace
7400d02842fSSascha Wildner * walk routine that can be called from multiple places to
7410d02842fSSascha Wildner * provide multiple services; the callback function(s) can be
7420d02842fSSascha Wildner * tailored to each task, whether it is a print function,
7430d02842fSSascha Wildner * a compare function, etc.
7440d02842fSSascha Wildner *
7450d02842fSSascha Wildner ******************************************************************************/
7460d02842fSSascha Wildner
7470d02842fSSascha Wildner ACPI_STATUS
AcpiWalkNamespace(ACPI_OBJECT_TYPE Type,ACPI_HANDLE StartObject,UINT32 MaxDepth,ACPI_WALK_CALLBACK DescendingCallback,ACPI_WALK_CALLBACK AscendingCallback,void * Context,void ** ReturnValue)7480d02842fSSascha Wildner AcpiWalkNamespace (
7490d02842fSSascha Wildner ACPI_OBJECT_TYPE Type,
7500d02842fSSascha Wildner ACPI_HANDLE StartObject,
7510d02842fSSascha Wildner UINT32 MaxDepth,
7520d02842fSSascha Wildner ACPI_WALK_CALLBACK DescendingCallback,
7530d02842fSSascha Wildner ACPI_WALK_CALLBACK AscendingCallback,
7540d02842fSSascha Wildner void *Context,
7550d02842fSSascha Wildner void **ReturnValue)
7560d02842fSSascha Wildner {
7570d02842fSSascha Wildner ACPI_STATUS Status;
7580d02842fSSascha Wildner
7590d02842fSSascha Wildner
7600d02842fSSascha Wildner ACPI_FUNCTION_TRACE (AcpiWalkNamespace);
7610d02842fSSascha Wildner
7620d02842fSSascha Wildner
7630d02842fSSascha Wildner /* Parameter validation */
7640d02842fSSascha Wildner
7650d02842fSSascha Wildner if ((Type > ACPI_TYPE_LOCAL_MAX) ||
7660d02842fSSascha Wildner (!MaxDepth) ||
7670d02842fSSascha Wildner (!DescendingCallback && !AscendingCallback))
7680d02842fSSascha Wildner {
7690d02842fSSascha Wildner return_ACPI_STATUS (AE_BAD_PARAMETER);
7700d02842fSSascha Wildner }
7710d02842fSSascha Wildner
7720d02842fSSascha Wildner /*
7730d02842fSSascha Wildner * Need to acquire the namespace reader lock to prevent interference
7740d02842fSSascha Wildner * with any concurrent table unloads (which causes the deletion of
7750d02842fSSascha Wildner * namespace objects). We cannot allow the deletion of a namespace node
7760d02842fSSascha Wildner * while the user function is using it. The exception to this are the
7770d02842fSSascha Wildner * nodes created and deleted during control method execution -- these
7780d02842fSSascha Wildner * nodes are marked as temporary nodes and are ignored by the namespace
7790d02842fSSascha Wildner * walk. Thus, control methods can be executed while holding the
7800d02842fSSascha Wildner * namespace deletion lock (and the user function can execute control
7810d02842fSSascha Wildner * methods.)
7820d02842fSSascha Wildner */
7830d02842fSSascha Wildner Status = AcpiUtAcquireReadLock (&AcpiGbl_NamespaceRwLock);
7840d02842fSSascha Wildner if (ACPI_FAILURE (Status))
7850d02842fSSascha Wildner {
7860d02842fSSascha Wildner return_ACPI_STATUS (Status);
7870d02842fSSascha Wildner }
7880d02842fSSascha Wildner
7890d02842fSSascha Wildner /*
7900d02842fSSascha Wildner * Lock the namespace around the walk. The namespace will be
7910d02842fSSascha Wildner * unlocked/locked around each call to the user function - since the user
7920d02842fSSascha Wildner * function must be allowed to make ACPICA calls itself (for example, it
7930d02842fSSascha Wildner * will typically execute control methods during device enumeration.)
7940d02842fSSascha Wildner */
7950d02842fSSascha Wildner Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
7960d02842fSSascha Wildner if (ACPI_FAILURE (Status))
7970d02842fSSascha Wildner {
7980d02842fSSascha Wildner goto UnlockAndExit;
7990d02842fSSascha Wildner }
8000d02842fSSascha Wildner
8010d02842fSSascha Wildner /* Now we can validate the starting node */
8020d02842fSSascha Wildner
8030d02842fSSascha Wildner if (!AcpiNsValidateHandle (StartObject))
8040d02842fSSascha Wildner {
8050d02842fSSascha Wildner Status = AE_BAD_PARAMETER;
8060d02842fSSascha Wildner goto UnlockAndExit2;
8070d02842fSSascha Wildner }
8080d02842fSSascha Wildner
8090d02842fSSascha Wildner Status = AcpiNsWalkNamespace (Type, StartObject, MaxDepth,
8100d02842fSSascha Wildner ACPI_NS_WALK_UNLOCK, DescendingCallback,
8110d02842fSSascha Wildner AscendingCallback, Context, ReturnValue);
8120d02842fSSascha Wildner
8130d02842fSSascha Wildner UnlockAndExit2:
8140d02842fSSascha Wildner (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
8150d02842fSSascha Wildner
8160d02842fSSascha Wildner UnlockAndExit:
8170d02842fSSascha Wildner (void) AcpiUtReleaseReadLock (&AcpiGbl_NamespaceRwLock);
8180d02842fSSascha Wildner return_ACPI_STATUS (Status);
8190d02842fSSascha Wildner }
8200d02842fSSascha Wildner
ACPI_EXPORT_SYMBOL(AcpiWalkNamespace)8210d02842fSSascha Wildner ACPI_EXPORT_SYMBOL (AcpiWalkNamespace)
8220d02842fSSascha Wildner
8230d02842fSSascha Wildner
8240d02842fSSascha Wildner /*******************************************************************************
8250d02842fSSascha Wildner *
8260d02842fSSascha Wildner * FUNCTION: AcpiNsGetDeviceCallback
8270d02842fSSascha Wildner *
8280d02842fSSascha Wildner * PARAMETERS: Callback from AcpiGetDevice
8290d02842fSSascha Wildner *
8300d02842fSSascha Wildner * RETURN: Status
8310d02842fSSascha Wildner *
8320d02842fSSascha Wildner * DESCRIPTION: Takes callbacks from WalkNamespace and filters out all non-
8330d02842fSSascha Wildner * present devices, or if they specified a HID, it filters based
8340d02842fSSascha Wildner * on that.
8350d02842fSSascha Wildner *
8360d02842fSSascha Wildner ******************************************************************************/
8370d02842fSSascha Wildner
8380d02842fSSascha Wildner static ACPI_STATUS
8390d02842fSSascha Wildner AcpiNsGetDeviceCallback (
8400d02842fSSascha Wildner ACPI_HANDLE ObjHandle,
8410d02842fSSascha Wildner UINT32 NestingLevel,
8420d02842fSSascha Wildner void *Context,
8430d02842fSSascha Wildner void **ReturnValue)
8440d02842fSSascha Wildner {
8450d02842fSSascha Wildner ACPI_GET_DEVICES_INFO *Info = Context;
8460d02842fSSascha Wildner ACPI_STATUS Status;
8470d02842fSSascha Wildner ACPI_NAMESPACE_NODE *Node;
8480d02842fSSascha Wildner UINT32 Flags;
8490d02842fSSascha Wildner ACPI_PNP_DEVICE_ID *Hid;
8500d02842fSSascha Wildner ACPI_PNP_DEVICE_ID_LIST *Cid;
8510d02842fSSascha Wildner UINT32 i;
8520d02842fSSascha Wildner BOOLEAN Found;
8530d02842fSSascha Wildner int NoMatch;
8540d02842fSSascha Wildner
8550d02842fSSascha Wildner
8560d02842fSSascha Wildner Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
8570d02842fSSascha Wildner if (ACPI_FAILURE (Status))
8580d02842fSSascha Wildner {
8590d02842fSSascha Wildner return (Status);
8600d02842fSSascha Wildner }
8610d02842fSSascha Wildner
8620d02842fSSascha Wildner Node = AcpiNsValidateHandle (ObjHandle);
8630d02842fSSascha Wildner Status = AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
8640d02842fSSascha Wildner if (ACPI_FAILURE (Status))
8650d02842fSSascha Wildner {
8660d02842fSSascha Wildner return (Status);
8670d02842fSSascha Wildner }
8680d02842fSSascha Wildner
8690d02842fSSascha Wildner if (!Node)
8700d02842fSSascha Wildner {
8710d02842fSSascha Wildner return (AE_BAD_PARAMETER);
8720d02842fSSascha Wildner }
8730d02842fSSascha Wildner
8740d02842fSSascha Wildner /*
8750d02842fSSascha Wildner * First, filter based on the device HID and CID.
8760d02842fSSascha Wildner *
8770d02842fSSascha Wildner * 01/2010: For this case where a specific HID is requested, we don't
8780d02842fSSascha Wildner * want to run _STA until we have an actual HID match. Thus, we will
8790d02842fSSascha Wildner * not unnecessarily execute _STA on devices for which the caller
8800d02842fSSascha Wildner * doesn't care about. Previously, _STA was executed unconditionally
8810d02842fSSascha Wildner * on all devices found here.
8820d02842fSSascha Wildner *
8830d02842fSSascha Wildner * A side-effect of this change is that now we will continue to search
8840d02842fSSascha Wildner * for a matching HID even under device trees where the parent device
8850d02842fSSascha Wildner * would have returned a _STA that indicates it is not present or
8860d02842fSSascha Wildner * not functioning (thus aborting the search on that branch).
8870d02842fSSascha Wildner */
8880d02842fSSascha Wildner if (Info->Hid != NULL)
8890d02842fSSascha Wildner {
8900d02842fSSascha Wildner Status = AcpiUtExecute_HID (Node, &Hid);
8910d02842fSSascha Wildner if (Status == AE_NOT_FOUND)
8920d02842fSSascha Wildner {
8930d02842fSSascha Wildner return (AE_OK);
8940d02842fSSascha Wildner }
8950d02842fSSascha Wildner else if (ACPI_FAILURE (Status))
8960d02842fSSascha Wildner {
8970d02842fSSascha Wildner return (AE_CTRL_DEPTH);
8980d02842fSSascha Wildner }
8990d02842fSSascha Wildner
90025ca8c79SSascha Wildner NoMatch = strcmp (Hid->String, Info->Hid);
9010d02842fSSascha Wildner ACPI_FREE (Hid);
9020d02842fSSascha Wildner
9030d02842fSSascha Wildner if (NoMatch)
9040d02842fSSascha Wildner {
9050d02842fSSascha Wildner /*
9060d02842fSSascha Wildner * HID does not match, attempt match within the
9070d02842fSSascha Wildner * list of Compatible IDs (CIDs)
9080d02842fSSascha Wildner */
9090d02842fSSascha Wildner Status = AcpiUtExecute_CID (Node, &Cid);
9100d02842fSSascha Wildner if (Status == AE_NOT_FOUND)
9110d02842fSSascha Wildner {
9120d02842fSSascha Wildner return (AE_OK);
9130d02842fSSascha Wildner }
9140d02842fSSascha Wildner else if (ACPI_FAILURE (Status))
9150d02842fSSascha Wildner {
9160d02842fSSascha Wildner return (AE_CTRL_DEPTH);
9170d02842fSSascha Wildner }
9180d02842fSSascha Wildner
9190d02842fSSascha Wildner /* Walk the CID list */
9200d02842fSSascha Wildner
9210d02842fSSascha Wildner Found = FALSE;
9220d02842fSSascha Wildner for (i = 0; i < Cid->Count; i++)
9230d02842fSSascha Wildner {
92425ca8c79SSascha Wildner if (strcmp (Cid->Ids[i].String, Info->Hid) == 0)
9250d02842fSSascha Wildner {
9260d02842fSSascha Wildner /* Found a matching CID */
9270d02842fSSascha Wildner
9280d02842fSSascha Wildner Found = TRUE;
9290d02842fSSascha Wildner break;
9300d02842fSSascha Wildner }
9310d02842fSSascha Wildner }
9320d02842fSSascha Wildner
9330d02842fSSascha Wildner ACPI_FREE (Cid);
9340d02842fSSascha Wildner if (!Found)
9350d02842fSSascha Wildner {
9360d02842fSSascha Wildner return (AE_OK);
9370d02842fSSascha Wildner }
9380d02842fSSascha Wildner }
9390d02842fSSascha Wildner }
9400d02842fSSascha Wildner
9410d02842fSSascha Wildner /* Run _STA to determine if device is present */
9420d02842fSSascha Wildner
9430d02842fSSascha Wildner Status = AcpiUtExecute_STA (Node, &Flags);
9440d02842fSSascha Wildner if (ACPI_FAILURE (Status))
9450d02842fSSascha Wildner {
9460d02842fSSascha Wildner return (AE_CTRL_DEPTH);
9470d02842fSSascha Wildner }
9480d02842fSSascha Wildner
9490d02842fSSascha Wildner if (!(Flags & ACPI_STA_DEVICE_PRESENT) &&
9500d02842fSSascha Wildner !(Flags & ACPI_STA_DEVICE_FUNCTIONING))
9510d02842fSSascha Wildner {
9520d02842fSSascha Wildner /*
9530d02842fSSascha Wildner * Don't examine the children of the device only when the
9540d02842fSSascha Wildner * device is neither present nor functional. See ACPI spec,
9550d02842fSSascha Wildner * description of _STA for more information.
9560d02842fSSascha Wildner */
9570d02842fSSascha Wildner return (AE_CTRL_DEPTH);
9580d02842fSSascha Wildner }
9590d02842fSSascha Wildner
9600d02842fSSascha Wildner /* We have a valid device, invoke the user function */
9610d02842fSSascha Wildner
962820c5b08SSascha Wildner Status = Info->UserFunction (ObjHandle, NestingLevel,
963820c5b08SSascha Wildner Info->Context, ReturnValue);
9640d02842fSSascha Wildner return (Status);
9650d02842fSSascha Wildner }
9660d02842fSSascha Wildner
9670d02842fSSascha Wildner
9680d02842fSSascha Wildner /*******************************************************************************
9690d02842fSSascha Wildner *
9700d02842fSSascha Wildner * FUNCTION: AcpiGetDevices
9710d02842fSSascha Wildner *
9720d02842fSSascha Wildner * PARAMETERS: HID - HID to search for. Can be NULL.
9730d02842fSSascha Wildner * UserFunction - Called when a matching object is found
9740d02842fSSascha Wildner * Context - Passed to user function
9750d02842fSSascha Wildner * ReturnValue - Location where return value of
9760d02842fSSascha Wildner * UserFunction is put if terminated early
9770d02842fSSascha Wildner *
9780d02842fSSascha Wildner * RETURNS Return value from the UserFunction if terminated early.
9790d02842fSSascha Wildner * Otherwise, returns NULL.
9800d02842fSSascha Wildner *
9810d02842fSSascha Wildner * DESCRIPTION: Performs a modified depth-first walk of the namespace tree,
9820d02842fSSascha Wildner * starting (and ending) at the object specified by StartHandle.
9830d02842fSSascha Wildner * The UserFunction is called whenever an object of type
9840d02842fSSascha Wildner * Device is found. If the user function returns
9850d02842fSSascha Wildner * a non-zero value, the search is terminated immediately and this
9860d02842fSSascha Wildner * value is returned to the caller.
9870d02842fSSascha Wildner *
9880d02842fSSascha Wildner * This is a wrapper for WalkNamespace, but the callback performs
9890d02842fSSascha Wildner * additional filtering. Please see AcpiNsGetDeviceCallback.
9900d02842fSSascha Wildner *
9910d02842fSSascha Wildner ******************************************************************************/
9920d02842fSSascha Wildner
9930d02842fSSascha Wildner ACPI_STATUS
AcpiGetDevices(char * HID,ACPI_WALK_CALLBACK UserFunction,void * Context,void ** ReturnValue)9940d02842fSSascha Wildner AcpiGetDevices (
9950d02842fSSascha Wildner char *HID,
9960d02842fSSascha Wildner ACPI_WALK_CALLBACK UserFunction,
9970d02842fSSascha Wildner void *Context,
9980d02842fSSascha Wildner void **ReturnValue)
9990d02842fSSascha Wildner {
10000d02842fSSascha Wildner ACPI_STATUS Status;
10010d02842fSSascha Wildner ACPI_GET_DEVICES_INFO Info;
10020d02842fSSascha Wildner
10030d02842fSSascha Wildner
10040d02842fSSascha Wildner ACPI_FUNCTION_TRACE (AcpiGetDevices);
10050d02842fSSascha Wildner
10060d02842fSSascha Wildner
10070d02842fSSascha Wildner /* Parameter validation */
10080d02842fSSascha Wildner
10090d02842fSSascha Wildner if (!UserFunction)
10100d02842fSSascha Wildner {
10110d02842fSSascha Wildner return_ACPI_STATUS (AE_BAD_PARAMETER);
10120d02842fSSascha Wildner }
10130d02842fSSascha Wildner
10140d02842fSSascha Wildner /*
10150d02842fSSascha Wildner * We're going to call their callback from OUR callback, so we need
10160d02842fSSascha Wildner * to know what it is, and their context parameter.
10170d02842fSSascha Wildner */
10180d02842fSSascha Wildner Info.Hid = HID;
10190d02842fSSascha Wildner Info.Context = Context;
10200d02842fSSascha Wildner Info.UserFunction = UserFunction;
10210d02842fSSascha Wildner
10220d02842fSSascha Wildner /*
10230d02842fSSascha Wildner * Lock the namespace around the walk.
10240d02842fSSascha Wildner * The namespace will be unlocked/locked around each call
10250d02842fSSascha Wildner * to the user function - since this function
10260d02842fSSascha Wildner * must be allowed to make Acpi calls itself.
10270d02842fSSascha Wildner */
10280d02842fSSascha Wildner Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
10290d02842fSSascha Wildner if (ACPI_FAILURE (Status))
10300d02842fSSascha Wildner {
10310d02842fSSascha Wildner return_ACPI_STATUS (Status);
10320d02842fSSascha Wildner }
10330d02842fSSascha Wildner
10340d02842fSSascha Wildner Status = AcpiNsWalkNamespace (ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
10350d02842fSSascha Wildner ACPI_UINT32_MAX, ACPI_NS_WALK_UNLOCK,
10360d02842fSSascha Wildner AcpiNsGetDeviceCallback, NULL, &Info, ReturnValue);
10370d02842fSSascha Wildner
10380d02842fSSascha Wildner (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
10390d02842fSSascha Wildner return_ACPI_STATUS (Status);
10400d02842fSSascha Wildner }
10410d02842fSSascha Wildner
ACPI_EXPORT_SYMBOL(AcpiGetDevices)10420d02842fSSascha Wildner ACPI_EXPORT_SYMBOL (AcpiGetDevices)
10430d02842fSSascha Wildner
10440d02842fSSascha Wildner
10450d02842fSSascha Wildner /*******************************************************************************
10460d02842fSSascha Wildner *
10470d02842fSSascha Wildner * FUNCTION: AcpiAttachData
10480d02842fSSascha Wildner *
10490d02842fSSascha Wildner * PARAMETERS: ObjHandle - Namespace node
10500d02842fSSascha Wildner * Handler - Handler for this attachment
10510d02842fSSascha Wildner * Data - Pointer to data to be attached
10520d02842fSSascha Wildner *
10530d02842fSSascha Wildner * RETURN: Status
10540d02842fSSascha Wildner *
10550d02842fSSascha Wildner * DESCRIPTION: Attach arbitrary data and handler to a namespace node.
10560d02842fSSascha Wildner *
10570d02842fSSascha Wildner ******************************************************************************/
10580d02842fSSascha Wildner
10590d02842fSSascha Wildner ACPI_STATUS
10600d02842fSSascha Wildner AcpiAttachData (
10610d02842fSSascha Wildner ACPI_HANDLE ObjHandle,
10620d02842fSSascha Wildner ACPI_OBJECT_HANDLER Handler,
10630d02842fSSascha Wildner void *Data)
10640d02842fSSascha Wildner {
10650d02842fSSascha Wildner ACPI_NAMESPACE_NODE *Node;
10660d02842fSSascha Wildner ACPI_STATUS Status;
10670d02842fSSascha Wildner
10680d02842fSSascha Wildner
10690d02842fSSascha Wildner /* Parameter validation */
10700d02842fSSascha Wildner
10710d02842fSSascha Wildner if (!ObjHandle ||
10720d02842fSSascha Wildner !Handler ||
10730d02842fSSascha Wildner !Data)
10740d02842fSSascha Wildner {
10750d02842fSSascha Wildner return (AE_BAD_PARAMETER);
10760d02842fSSascha Wildner }
10770d02842fSSascha Wildner
10780d02842fSSascha Wildner Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
10790d02842fSSascha Wildner if (ACPI_FAILURE (Status))
10800d02842fSSascha Wildner {
10810d02842fSSascha Wildner return (Status);
10820d02842fSSascha Wildner }
10830d02842fSSascha Wildner
10840d02842fSSascha Wildner /* Convert and validate the handle */
10850d02842fSSascha Wildner
10860d02842fSSascha Wildner Node = AcpiNsValidateHandle (ObjHandle);
10870d02842fSSascha Wildner if (!Node)
10880d02842fSSascha Wildner {
10890d02842fSSascha Wildner Status = AE_BAD_PARAMETER;
10900d02842fSSascha Wildner goto UnlockAndExit;
10910d02842fSSascha Wildner }
10920d02842fSSascha Wildner
10930d02842fSSascha Wildner Status = AcpiNsAttachData (Node, Handler, Data);
10940d02842fSSascha Wildner
10950d02842fSSascha Wildner UnlockAndExit:
10960d02842fSSascha Wildner (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
10970d02842fSSascha Wildner return (Status);
10980d02842fSSascha Wildner }
10990d02842fSSascha Wildner
ACPI_EXPORT_SYMBOL(AcpiAttachData)11000d02842fSSascha Wildner ACPI_EXPORT_SYMBOL (AcpiAttachData)
11010d02842fSSascha Wildner
11020d02842fSSascha Wildner
11030d02842fSSascha Wildner /*******************************************************************************
11040d02842fSSascha Wildner *
11050d02842fSSascha Wildner * FUNCTION: AcpiDetachData
11060d02842fSSascha Wildner *
11070d02842fSSascha Wildner * PARAMETERS: ObjHandle - Namespace node handle
11080d02842fSSascha Wildner * Handler - Handler used in call to AcpiAttachData
11090d02842fSSascha Wildner *
11100d02842fSSascha Wildner * RETURN: Status
11110d02842fSSascha Wildner *
11120d02842fSSascha Wildner * DESCRIPTION: Remove data that was previously attached to a node.
11130d02842fSSascha Wildner *
11140d02842fSSascha Wildner ******************************************************************************/
11150d02842fSSascha Wildner
11160d02842fSSascha Wildner ACPI_STATUS
11170d02842fSSascha Wildner AcpiDetachData (
11180d02842fSSascha Wildner ACPI_HANDLE ObjHandle,
11190d02842fSSascha Wildner ACPI_OBJECT_HANDLER Handler)
11200d02842fSSascha Wildner {
11210d02842fSSascha Wildner ACPI_NAMESPACE_NODE *Node;
11220d02842fSSascha Wildner ACPI_STATUS Status;
11230d02842fSSascha Wildner
11240d02842fSSascha Wildner
11250d02842fSSascha Wildner /* Parameter validation */
11260d02842fSSascha Wildner
11270d02842fSSascha Wildner if (!ObjHandle ||
11280d02842fSSascha Wildner !Handler)
11290d02842fSSascha Wildner {
11300d02842fSSascha Wildner return (AE_BAD_PARAMETER);
11310d02842fSSascha Wildner }
11320d02842fSSascha Wildner
11330d02842fSSascha Wildner Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
11340d02842fSSascha Wildner if (ACPI_FAILURE (Status))
11350d02842fSSascha Wildner {
11360d02842fSSascha Wildner return (Status);
11370d02842fSSascha Wildner }
11380d02842fSSascha Wildner
11390d02842fSSascha Wildner /* Convert and validate the handle */
11400d02842fSSascha Wildner
11410d02842fSSascha Wildner Node = AcpiNsValidateHandle (ObjHandle);
11420d02842fSSascha Wildner if (!Node)
11430d02842fSSascha Wildner {
11440d02842fSSascha Wildner Status = AE_BAD_PARAMETER;
11450d02842fSSascha Wildner goto UnlockAndExit;
11460d02842fSSascha Wildner }
11470d02842fSSascha Wildner
11480d02842fSSascha Wildner Status = AcpiNsDetachData (Node, Handler);
11490d02842fSSascha Wildner
11500d02842fSSascha Wildner UnlockAndExit:
11510d02842fSSascha Wildner (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
11520d02842fSSascha Wildner return (Status);
11530d02842fSSascha Wildner }
11540d02842fSSascha Wildner
ACPI_EXPORT_SYMBOL(AcpiDetachData)11550d02842fSSascha Wildner ACPI_EXPORT_SYMBOL (AcpiDetachData)
11560d02842fSSascha Wildner
11570d02842fSSascha Wildner
11580d02842fSSascha Wildner /*******************************************************************************
11590d02842fSSascha Wildner *
11600d02842fSSascha Wildner * FUNCTION: AcpiGetData
11610d02842fSSascha Wildner *
11620d02842fSSascha Wildner * PARAMETERS: ObjHandle - Namespace node
11630d02842fSSascha Wildner * Handler - Handler used in call to AttachData
11640d02842fSSascha Wildner * Data - Where the data is returned
11650d02842fSSascha Wildner *
11660d02842fSSascha Wildner * RETURN: Status
11670d02842fSSascha Wildner *
11680d02842fSSascha Wildner * DESCRIPTION: Retrieve data that was previously attached to a namespace node.
11690d02842fSSascha Wildner *
11700d02842fSSascha Wildner ******************************************************************************/
11710d02842fSSascha Wildner
11720d02842fSSascha Wildner ACPI_STATUS
11730d02842fSSascha Wildner AcpiGetData (
11740d02842fSSascha Wildner ACPI_HANDLE ObjHandle,
11750d02842fSSascha Wildner ACPI_OBJECT_HANDLER Handler,
11760d02842fSSascha Wildner void **Data)
11770d02842fSSascha Wildner {
11780d02842fSSascha Wildner ACPI_NAMESPACE_NODE *Node;
11790d02842fSSascha Wildner ACPI_STATUS Status;
11800d02842fSSascha Wildner
11810d02842fSSascha Wildner
11820d02842fSSascha Wildner /* Parameter validation */
11830d02842fSSascha Wildner
11840d02842fSSascha Wildner if (!ObjHandle ||
11850d02842fSSascha Wildner !Handler ||
11860d02842fSSascha Wildner !Data)
11870d02842fSSascha Wildner {
11880d02842fSSascha Wildner return (AE_BAD_PARAMETER);
11890d02842fSSascha Wildner }
11900d02842fSSascha Wildner
11910d02842fSSascha Wildner Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
11920d02842fSSascha Wildner if (ACPI_FAILURE (Status))
11930d02842fSSascha Wildner {
11940d02842fSSascha Wildner return (Status);
11950d02842fSSascha Wildner }
11960d02842fSSascha Wildner
11970d02842fSSascha Wildner /* Convert and validate the handle */
11980d02842fSSascha Wildner
11990d02842fSSascha Wildner Node = AcpiNsValidateHandle (ObjHandle);
12000d02842fSSascha Wildner if (!Node)
12010d02842fSSascha Wildner {
12020d02842fSSascha Wildner Status = AE_BAD_PARAMETER;
12030d02842fSSascha Wildner goto UnlockAndExit;
12040d02842fSSascha Wildner }
12050d02842fSSascha Wildner
12060d02842fSSascha Wildner Status = AcpiNsGetAttachedData (Node, Handler, Data);
12070d02842fSSascha Wildner
12080d02842fSSascha Wildner UnlockAndExit:
12090d02842fSSascha Wildner (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
12100d02842fSSascha Wildner return (Status);
12110d02842fSSascha Wildner }
12120d02842fSSascha Wildner
12130d02842fSSascha Wildner ACPI_EXPORT_SYMBOL (AcpiGetData)
1214