sys/contrib/dev/acpica/components/namespace/nsxfobj.c

   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
  69 ACPI_STATUS
  70 AcpiGetType (
  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
 117 ACPI_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
 134 ACPI_STATUS
 135 AcpiGetParent (
 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
 184 UnlockAndExit:
 185
 186     (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
 187     return (Status);
 188 }
 189
 190 ACPI_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
 211 ACPI_STATUS
 212 AcpiGetNextObject (
 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
 278 UnlockAndExit:
 279
 280     (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
 281     return (Status);
 282 }
 283
 284 ACPI_EXPORT_SYMBOL (AcpiGetNextObject)