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 - 2007, R. Byron Moore 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#include <acpi/acpi.h> 46#include <acpi/acnamesp.h> 47 48#define _COMPONENT ACPI_NAMESPACE 49ACPI_MODULE_NAME("nsxfobj") 50 51/******************************************************************************* 52 * 53 * FUNCTION: acpi_get_id 54 * 55 * PARAMETERS: Handle - Handle of object whose id is desired 56 * ret_id - Where the id will be placed 57 * 58 * RETURN: Status 59 * 60 * DESCRIPTION: This routine returns the owner id associated with a handle 61 * 62 ******************************************************************************/ 63acpi_status acpi_get_id(acpi_handle handle, acpi_owner_id * ret_id) 64{ 65 struct acpi_namespace_node *node; 66 acpi_status status; 67 68 /* Parameter Validation */ 69 70 if (!ret_id) { 71 return (AE_BAD_PARAMETER); 72 } 73 74 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE); 75 if (ACPI_FAILURE(status)) { 76 return (status); 77 } 78 79 /* Convert and validate the handle */ 80 81 node = acpi_ns_map_handle_to_node(handle); 82 if (!node) { 83 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE); 84 return (AE_BAD_PARAMETER); 85 } 86 87 *ret_id = node->owner_id; 88 89 status = acpi_ut_release_mutex(ACPI_MTX_NAMESPACE); 90 return (status); 91} 92 93ACPI_EXPORT_SYMBOL(acpi_get_id) 94 95/******************************************************************************* 96 * 97 * FUNCTION: acpi_get_type 98 * 99 * PARAMETERS: Handle - Handle of object whose type is desired 100 * ret_type - Where the type will be placed 101 * 102 * RETURN: Status 103 * 104 * DESCRIPTION: This routine returns the type associatd with a particular handle 105 * 106 ******************************************************************************/ 107acpi_status acpi_get_type(acpi_handle handle, acpi_object_type * ret_type) 108{ 109 struct acpi_namespace_node *node; 110 acpi_status status; 111 112 /* Parameter Validation */ 113 114 if (!ret_type) { 115 return (AE_BAD_PARAMETER); 116 } 117 118 /* 119 * Special case for the predefined Root Node 120 * (return type ANY) 121 */ 122 if (handle == ACPI_ROOT_OBJECT) { 123 *ret_type = ACPI_TYPE_ANY; 124 return (AE_OK); 125 } 126 127 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE); 128 if (ACPI_FAILURE(status)) { 129 return (status); 130 } 131 132 /* Convert and validate the handle */ 133 134 node = acpi_ns_map_handle_to_node(handle); 135 if (!node) { 136 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE); 137 return (AE_BAD_PARAMETER); 138 } 139 140 *ret_type = node->type; 141 142 status = acpi_ut_release_mutex(ACPI_MTX_NAMESPACE); 143 return (status); 144} 145 146ACPI_EXPORT_SYMBOL(acpi_get_type) 147 148/******************************************************************************* 149 * 150 * FUNCTION: acpi_get_parent 151 * 152 * PARAMETERS: Handle - Handle of object whose parent is desired 153 * ret_handle - Where the parent handle will be placed 154 * 155 * RETURN: Status 156 * 157 * DESCRIPTION: Returns a handle to the parent of the object represented by 158 * Handle. 159 * 160 ******************************************************************************/ 161acpi_status acpi_get_parent(acpi_handle handle, acpi_handle * ret_handle) 162{ 163 struct acpi_namespace_node *node; 164 acpi_status status; 165 166 if (!ret_handle) { 167 return (AE_BAD_PARAMETER); 168 } 169 170 /* Special case for the predefined Root Node (no parent) */ 171 172 if (handle == ACPI_ROOT_OBJECT) { 173 return (AE_NULL_ENTRY); 174 } 175 176 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE); 177 if (ACPI_FAILURE(status)) { 178 return (status); 179 } 180 181 /* Convert and validate the handle */ 182 183 node = acpi_ns_map_handle_to_node(handle); 184 if (!node) { 185 status = AE_BAD_PARAMETER; 186 goto unlock_and_exit; 187 } 188 189 /* Get the parent entry */ 190 191 *ret_handle = 192 acpi_ns_convert_entry_to_handle(acpi_ns_get_parent_node(node)); 193 194 /* Return exception if parent is null */ 195 196 if (!acpi_ns_get_parent_node(node)) { 197 status = AE_NULL_ENTRY; 198 } 199 200 unlock_and_exit: 201 202 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE); 203 return (status); 204} 205 206ACPI_EXPORT_SYMBOL(acpi_get_parent) 207 208/******************************************************************************* 209 * 210 * FUNCTION: acpi_get_next_object 211 * 212 * PARAMETERS: Type - Type of object to be searched for 213 * Parent - Parent object whose children we are getting 214 * last_child - Previous child that was found. 215 * The NEXT child will be returned 216 * ret_handle - Where handle to the next object is placed 217 * 218 * RETURN: Status 219 * 220 * DESCRIPTION: Return the next peer object within the namespace. If Handle is 221 * valid, Scope is ignored. Otherwise, the first object within 222 * Scope is returned. 223 * 224 ******************************************************************************/ 225acpi_status 226acpi_get_next_object(acpi_object_type type, 227 acpi_handle parent, 228 acpi_handle child, acpi_handle * ret_handle) 229{ 230 acpi_status status; 231 struct acpi_namespace_node *node; 232 struct acpi_namespace_node *parent_node = NULL; 233 struct acpi_namespace_node *child_node = NULL; 234 235 /* Parameter validation */ 236 237 if (type > ACPI_TYPE_EXTERNAL_MAX) { 238 return (AE_BAD_PARAMETER); 239 } 240 241 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE); 242 if (ACPI_FAILURE(status)) { 243 return (status); 244 } 245 246 /* If null handle, use the parent */ 247 248 if (!child) { 249 250 /* Start search at the beginning of the specified scope */ 251 252 parent_node = acpi_ns_map_handle_to_node(parent); 253 if (!parent_node) { 254 status = AE_BAD_PARAMETER; 255 goto unlock_and_exit; 256 } 257 } else { 258 /* Non-null handle, ignore the parent */ 259 /* Convert and validate the handle */ 260 261 child_node = acpi_ns_map_handle_to_node(child); 262 if (!child_node) { 263 status = AE_BAD_PARAMETER; 264 goto unlock_and_exit; 265 } 266 } 267 268 /* Internal function does the real work */ 269 270 node = acpi_ns_get_next_node(type, parent_node, child_node); 271 if (!node) { 272 status = AE_NOT_FOUND; 273 goto unlock_and_exit; 274 } 275 276 if (ret_handle) { 277 *ret_handle = acpi_ns_convert_entry_to_handle(node); 278 } 279 280 unlock_and_exit: 281 282 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE); 283 return (status); 284} 285 286ACPI_EXPORT_SYMBOL(acpi_get_next_object) 287