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 - 2011, 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 "acpi.h" 49 #include "accommon.h" 50 #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) 285 286