1/*******************************************************************************
2 *
3 * Module Name: nsxfobj - Public interfaces to the ACPI subsystem
4 *                         ACPI Object oriented interfaces
5 *
6 ******************************************************************************/
7
8/*
9 * Copyright (C) 2000 - 2013, Intel Corp.
10 * All rights reserved.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
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.
26 *
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.
30 *
31 * NO WARRANTY
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.
43 */
44
45
46#define __NSXFOBJ_C__
47
48#include <contrib/dev/acpica/include/acpi.h>
49#include <contrib/dev/acpica/include/accommon.h>
50#include <contrib/dev/acpica/include/acnamesp.h>
51
52
53#define _COMPONENT          ACPI_NAMESPACE
54        ACPI_MODULE_NAME    ("nsxfobj")
55
56/*******************************************************************************
57 *
58 * FUNCTION:    AcpiGetType
59 *
60 * PARAMETERS:  Handle          - Handle of object whose type is desired
61 *              RetType         - Where the type will be placed
62 *
63 * RETURN:      Status
64 *
65 * DESCRIPTION: This routine returns the type associatd with a particular handle
66 *
67 ******************************************************************************/
68
69ACPI_STATUS
70AcpiGetType (
71    ACPI_HANDLE             Handle,
72    ACPI_OBJECT_TYPE        *RetType)
73{
74    ACPI_NAMESPACE_NODE     *Node;
75    ACPI_STATUS             Status;
76
77
78    /* Parameter Validation */
79
80    if (!RetType)
81    {
82        return (AE_BAD_PARAMETER);
83    }
84
85    /*
86     * Special case for the predefined Root Node
87     * (return type ANY)
88     */
89    if (Handle == ACPI_ROOT_OBJECT)
90    {
91        *RetType = ACPI_TYPE_ANY;
92        return (AE_OK);
93    }
94
95    Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
96    if (ACPI_FAILURE (Status))
97    {
98        return (Status);
99    }
100
101    /* Convert and validate the handle */
102
103    Node = AcpiNsValidateHandle (Handle);
104    if (!Node)
105    {
106        (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
107        return (AE_BAD_PARAMETER);
108    }
109
110    *RetType = Node->Type;
111
112
113    Status = AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
114    return (Status);
115}
116
117ACPI_EXPORT_SYMBOL (AcpiGetType)
118
119
120/*******************************************************************************
121 *
122 * FUNCTION:    AcpiGetParent
123 *
124 * PARAMETERS:  Handle          - Handle of object whose parent is desired
125 *              RetHandle       - Where the parent handle will be placed
126 *
127 * RETURN:      Status
128 *
129 * DESCRIPTION: Returns a handle to the parent of the object represented by
130 *              Handle.
131 *
132 ******************************************************************************/
133
134ACPI_STATUS
135AcpiGetParent (
136    ACPI_HANDLE             Handle,
137    ACPI_HANDLE             *RetHandle)
138{
139    ACPI_NAMESPACE_NODE     *Node;
140    ACPI_NAMESPACE_NODE     *ParentNode;
141    ACPI_STATUS             Status;
142
143
144    if (!RetHandle)
145    {
146        return (AE_BAD_PARAMETER);
147    }
148
149    /* Special case for the predefined Root Node (no parent) */
150
151    if (Handle == ACPI_ROOT_OBJECT)
152    {
153        return (AE_NULL_ENTRY);
154    }
155
156    Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
157    if (ACPI_FAILURE (Status))
158    {
159        return (Status);
160    }
161
162    /* Convert and validate the handle */
163
164    Node = AcpiNsValidateHandle (Handle);
165    if (!Node)
166    {
167        Status = AE_BAD_PARAMETER;
168        goto UnlockAndExit;
169    }
170
171    /* Get the parent entry */
172
173    ParentNode = Node->Parent;
174    *RetHandle = ACPI_CAST_PTR (ACPI_HANDLE, ParentNode);
175
176    /* Return exception if parent is null */
177
178    if (!ParentNode)
179    {
180        Status = AE_NULL_ENTRY;
181    }
182
183
184UnlockAndExit:
185
186    (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
187    return (Status);
188}
189
190ACPI_EXPORT_SYMBOL (AcpiGetParent)
191
192
193/*******************************************************************************
194 *
195 * FUNCTION:    AcpiGetNextObject
196 *
197 * PARAMETERS:  Type            - Type of object to be searched for
198 *              Parent          - Parent object whose children we are getting
199 *              LastChild       - Previous child that was found.
200 *                                The NEXT child will be returned
201 *              RetHandle       - Where handle to the next object is placed
202 *
203 * RETURN:      Status
204 *
205 * DESCRIPTION: Return the next peer object within the namespace. If Handle is
206 *              valid, Scope is ignored. Otherwise, the first object within
207 *              Scope is returned.
208 *
209 ******************************************************************************/
210
211ACPI_STATUS
212AcpiGetNextObject (
213    ACPI_OBJECT_TYPE        Type,
214    ACPI_HANDLE             Parent,
215    ACPI_HANDLE             Child,
216    ACPI_HANDLE             *RetHandle)
217{
218    ACPI_STATUS             Status;
219    ACPI_NAMESPACE_NODE     *Node;
220    ACPI_NAMESPACE_NODE     *ParentNode = NULL;
221    ACPI_NAMESPACE_NODE     *ChildNode = NULL;
222
223
224    /* Parameter validation */
225
226    if (Type > ACPI_TYPE_EXTERNAL_MAX)
227    {
228        return (AE_BAD_PARAMETER);
229    }
230
231    Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
232    if (ACPI_FAILURE (Status))
233    {
234        return (Status);
235    }
236
237    /* If null handle, use the parent */
238
239    if (!Child)
240    {
241        /* Start search at the beginning of the specified scope */
242
243        ParentNode = AcpiNsValidateHandle (Parent);
244        if (!ParentNode)
245        {
246            Status = AE_BAD_PARAMETER;
247            goto UnlockAndExit;
248        }
249    }
250    else
251    {
252        /* Non-null handle, ignore the parent */
253        /* Convert and validate the handle */
254
255        ChildNode = AcpiNsValidateHandle (Child);
256        if (!ChildNode)
257        {
258            Status = AE_BAD_PARAMETER;
259            goto UnlockAndExit;
260        }
261    }
262
263    /* Internal function does the real work */
264
265    Node = AcpiNsGetNextNodeTyped (Type, ParentNode, ChildNode);
266    if (!Node)
267    {
268        Status = AE_NOT_FOUND;
269        goto UnlockAndExit;
270    }
271
272    if (RetHandle)
273    {
274        *RetHandle = ACPI_CAST_PTR (ACPI_HANDLE, Node);
275    }
276
277
278UnlockAndExit:
279
280    (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
281    return (Status);
282}
283
284ACPI_EXPORT_SYMBOL (AcpiGetNextObject)
285