1/******************************************************************************* 2 * 3 * Module Name: nseval - Object evaluation interfaces -- includes control 4 * method lookup and execution.
| 1/******************************************************************************* 2 * 3 * Module Name: nseval - Object evaluation interfaces -- includes control 4 * method lookup and execution.
|
5 * $Revision: 123 $
| 5 * $Revision: 124 $
|
6 * 7 ******************************************************************************/ 8 9/****************************************************************************** 10 * 11 * 1. Copyright Notice 12 * 13 * Some or all of this work - Copyright (c) 1999 - 2004, Intel Corp. 14 * All rights reserved. 15 * 16 * 2. License 17 * 18 * 2.1. This is your license from Intel Corp. under its intellectual property 19 * rights. You may have additional license terms from the party that provided 20 * you this software, covering your right to use that party's intellectual 21 * property rights. 22 * 23 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a 24 * copy of the source code appearing in this file ("Covered Code") an 25 * irrevocable, perpetual, worldwide license under Intel's copyrights in the 26 * base code distributed originally by Intel ("Original Intel Code") to copy, 27 * make derivatives, distribute, use and display any portion of the Covered 28 * Code in any form, with the right to sublicense such rights; and 29 * 30 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent 31 * license (with the right to sublicense), under only those claims of Intel 32 * patents that are infringed by the Original Intel Code, to make, use, sell, 33 * offer to sell, and import the Covered Code and derivative works thereof 34 * solely to the minimum extent necessary to exercise the above copyright 35 * license, and in no event shall the patent license extend to any additions 36 * to or modifications of the Original Intel Code. No other license or right 37 * is granted directly or by implication, estoppel or otherwise; 38 * 39 * The above copyright and patent license is granted only if the following 40 * conditions are met: 41 * 42 * 3. Conditions 43 * 44 * 3.1. Redistribution of Source with Rights to Further Distribute Source. 45 * Redistribution of source code of any substantial portion of the Covered 46 * Code or modification with rights to further distribute source must include 47 * the above Copyright Notice, the above License, this list of Conditions, 48 * and the following Disclaimer and Export Compliance provision. In addition, 49 * Licensee must cause all Covered Code to which Licensee contributes to 50 * contain a file documenting the changes Licensee made to create that Covered 51 * Code and the date of any change. Licensee must include in that file the 52 * documentation of any changes made by any predecessor Licensee. Licensee 53 * must include a prominent statement that the modification is derived, 54 * directly or indirectly, from Original Intel Code. 55 * 56 * 3.2. Redistribution of Source with no Rights to Further Distribute Source. 57 * Redistribution of source code of any substantial portion of the Covered 58 * Code or modification without rights to further distribute source must 59 * include the following Disclaimer and Export Compliance provision in the 60 * documentation and/or other materials provided with distribution. In 61 * addition, Licensee may not authorize further sublicense of source of any 62 * portion of the Covered Code, and must include terms to the effect that the 63 * license from Licensee to its licensee is limited to the intellectual 64 * property embodied in the software Licensee provides to its licensee, and 65 * not to intellectual property embodied in modifications its licensee may 66 * make. 67 68 * 69 * 3.3. Redistribution of Executable. Redistribution in executable form of any 70 * substantial portion of the Covered Code or modification must reproduce the 71 * above Copyright Notice, and the following Disclaimer and Export Compliance 72 * provision in the documentation and/or other materials provided with the 73 * distribution. 74 * 75 * 3.4. Intel retains all right, title, and interest in and to the Original 76 * Intel Code. 77 * 78 * 3.5. Neither the name Intel nor any other trademark owned or controlled by 79 * Intel shall be used in advertising or otherwise to promote the sale, use or 80 * other dealings in products derived from or relating to the Covered Code 81 * without prior written authorization from Intel. 82 * 83 * 4. Disclaimer and Export Compliance 84 * 85 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED 86 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE 87 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, 88 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY 89 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY 90 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A 91 * PARTICULAR PURPOSE. 92 * 93 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES 94 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR 95 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, 96 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY 97 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL 98 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS 99 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY 100 * LIMITED REMEDY. 101 * 102 * 4.3. Licensee shall not export, either directly or indirectly, any of this 103 * software or system incorporating such software without first obtaining any 104 * required license or other approval from the U. S. Department of Commerce or 105 * any other agency or department of the United States Government. In the 106 * event Licensee exports any such software from the United States or 107 * re-exports any such software from a foreign destination, Licensee shall 108 * ensure that the distribution and export/re-export of the software is in 109 * compliance with all laws, regulations, orders, or other restrictions of the 110 * U.S. Export Administration Regulations. Licensee agrees that neither it nor 111 * any of its subsidiaries will export/re-export any technical data, process, 112 * software, or service, directly or indirectly, to any country for which the 113 * United States government or any agency thereof requires an export license, 114 * other governmental approval, or letter of assurance, without first obtaining 115 * such license, approval or letter. 116 * 117 *****************************************************************************/ 118 119#define __NSEVAL_C__ 120 121#include "acpi.h" 122#include "acparser.h" 123#include "acinterp.h" 124#include "acnamesp.h" 125 126 127#define _COMPONENT ACPI_NAMESPACE 128 ACPI_MODULE_NAME ("nseval") 129 130 131/******************************************************************************* 132 * 133 * FUNCTION: AcpiNsEvaluateRelative 134 * 135 * PARAMETERS: Handle - The relative containing object 136 * Pathname - Name of method to execute, If NULL, the 137 * handle is the object to execute 138 * Params - List of parameters to pass to the method, 139 * terminated by NULL. Params itself may be 140 * NULL if no parameters are being passed. 141 * ReturnObject - Where to put method's return value (if 142 * any). If NULL, no value is returned. 143 * 144 * RETURN: Status 145 * 146 * DESCRIPTION: Find and execute the requested method using the handle as a 147 * scope 148 * 149 * MUTEX: Locks Namespace 150 * 151 ******************************************************************************/ 152 153ACPI_STATUS 154AcpiNsEvaluateRelative ( 155 ACPI_NAMESPACE_NODE *Handle, 156 char *Pathname, 157 ACPI_OPERAND_OBJECT **Params, 158 ACPI_OPERAND_OBJECT **ReturnObject) 159{
| 6 * 7 ******************************************************************************/ 8 9/****************************************************************************** 10 * 11 * 1. Copyright Notice 12 * 13 * Some or all of this work - Copyright (c) 1999 - 2004, Intel Corp. 14 * All rights reserved. 15 * 16 * 2. License 17 * 18 * 2.1. This is your license from Intel Corp. under its intellectual property 19 * rights. You may have additional license terms from the party that provided 20 * you this software, covering your right to use that party's intellectual 21 * property rights. 22 * 23 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a 24 * copy of the source code appearing in this file ("Covered Code") an 25 * irrevocable, perpetual, worldwide license under Intel's copyrights in the 26 * base code distributed originally by Intel ("Original Intel Code") to copy, 27 * make derivatives, distribute, use and display any portion of the Covered 28 * Code in any form, with the right to sublicense such rights; and 29 * 30 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent 31 * license (with the right to sublicense), under only those claims of Intel 32 * patents that are infringed by the Original Intel Code, to make, use, sell, 33 * offer to sell, and import the Covered Code and derivative works thereof 34 * solely to the minimum extent necessary to exercise the above copyright 35 * license, and in no event shall the patent license extend to any additions 36 * to or modifications of the Original Intel Code. No other license or right 37 * is granted directly or by implication, estoppel or otherwise; 38 * 39 * The above copyright and patent license is granted only if the following 40 * conditions are met: 41 * 42 * 3. Conditions 43 * 44 * 3.1. Redistribution of Source with Rights to Further Distribute Source. 45 * Redistribution of source code of any substantial portion of the Covered 46 * Code or modification with rights to further distribute source must include 47 * the above Copyright Notice, the above License, this list of Conditions, 48 * and the following Disclaimer and Export Compliance provision. In addition, 49 * Licensee must cause all Covered Code to which Licensee contributes to 50 * contain a file documenting the changes Licensee made to create that Covered 51 * Code and the date of any change. Licensee must include in that file the 52 * documentation of any changes made by any predecessor Licensee. Licensee 53 * must include a prominent statement that the modification is derived, 54 * directly or indirectly, from Original Intel Code. 55 * 56 * 3.2. Redistribution of Source with no Rights to Further Distribute Source. 57 * Redistribution of source code of any substantial portion of the Covered 58 * Code or modification without rights to further distribute source must 59 * include the following Disclaimer and Export Compliance provision in the 60 * documentation and/or other materials provided with distribution. In 61 * addition, Licensee may not authorize further sublicense of source of any 62 * portion of the Covered Code, and must include terms to the effect that the 63 * license from Licensee to its licensee is limited to the intellectual 64 * property embodied in the software Licensee provides to its licensee, and 65 * not to intellectual property embodied in modifications its licensee may 66 * make. 67 68 * 69 * 3.3. Redistribution of Executable. Redistribution in executable form of any 70 * substantial portion of the Covered Code or modification must reproduce the 71 * above Copyright Notice, and the following Disclaimer and Export Compliance 72 * provision in the documentation and/or other materials provided with the 73 * distribution. 74 * 75 * 3.4. Intel retains all right, title, and interest in and to the Original 76 * Intel Code. 77 * 78 * 3.5. Neither the name Intel nor any other trademark owned or controlled by 79 * Intel shall be used in advertising or otherwise to promote the sale, use or 80 * other dealings in products derived from or relating to the Covered Code 81 * without prior written authorization from Intel. 82 * 83 * 4. Disclaimer and Export Compliance 84 * 85 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED 86 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE 87 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, 88 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY 89 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY 90 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A 91 * PARTICULAR PURPOSE. 92 * 93 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES 94 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR 95 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, 96 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY 97 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL 98 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS 99 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY 100 * LIMITED REMEDY. 101 * 102 * 4.3. Licensee shall not export, either directly or indirectly, any of this 103 * software or system incorporating such software without first obtaining any 104 * required license or other approval from the U. S. Department of Commerce or 105 * any other agency or department of the United States Government. In the 106 * event Licensee exports any such software from the United States or 107 * re-exports any such software from a foreign destination, Licensee shall 108 * ensure that the distribution and export/re-export of the software is in 109 * compliance with all laws, regulations, orders, or other restrictions of the 110 * U.S. Export Administration Regulations. Licensee agrees that neither it nor 111 * any of its subsidiaries will export/re-export any technical data, process, 112 * software, or service, directly or indirectly, to any country for which the 113 * United States government or any agency thereof requires an export license, 114 * other governmental approval, or letter of assurance, without first obtaining 115 * such license, approval or letter. 116 * 117 *****************************************************************************/ 118 119#define __NSEVAL_C__ 120 121#include "acpi.h" 122#include "acparser.h" 123#include "acinterp.h" 124#include "acnamesp.h" 125 126 127#define _COMPONENT ACPI_NAMESPACE 128 ACPI_MODULE_NAME ("nseval") 129 130 131/******************************************************************************* 132 * 133 * FUNCTION: AcpiNsEvaluateRelative 134 * 135 * PARAMETERS: Handle - The relative containing object 136 * Pathname - Name of method to execute, If NULL, the 137 * handle is the object to execute 138 * Params - List of parameters to pass to the method, 139 * terminated by NULL. Params itself may be 140 * NULL if no parameters are being passed. 141 * ReturnObject - Where to put method's return value (if 142 * any). If NULL, no value is returned. 143 * 144 * RETURN: Status 145 * 146 * DESCRIPTION: Find and execute the requested method using the handle as a 147 * scope 148 * 149 * MUTEX: Locks Namespace 150 * 151 ******************************************************************************/ 152 153ACPI_STATUS 154AcpiNsEvaluateRelative ( 155 ACPI_NAMESPACE_NODE *Handle, 156 char *Pathname, 157 ACPI_OPERAND_OBJECT **Params, 158 ACPI_OPERAND_OBJECT **ReturnObject) 159{
|
160 ACPI_NAMESPACE_NODE *PrefixNode;
| |
161 ACPI_STATUS Status;
| 160 ACPI_STATUS Status;
|
| 161 ACPI_NAMESPACE_NODE *PrefixNode;
|
162 ACPI_NAMESPACE_NODE *Node = NULL;
| 162 ACPI_NAMESPACE_NODE *Node = NULL;
|
| 163 ACPI_GENERIC_STATE *ScopeInfo;
|
163 char *InternalPath = NULL;
| 164 char *InternalPath = NULL;
|
164 ACPI_GENERIC_STATE ScopeInfo;
| |
165 166 167 ACPI_FUNCTION_TRACE ("NsEvaluateRelative"); 168 169 170 /* 171 * Must have a valid object handle 172 */ 173 if (!Handle) 174 { 175 return_ACPI_STATUS (AE_BAD_PARAMETER); 176 } 177 178 /* Build an internal name string for the method */ 179 180 Status = AcpiNsInternalizeName (Pathname, &InternalPath); 181 if (ACPI_FAILURE (Status)) 182 { 183 return_ACPI_STATUS (Status); 184 } 185
| 165 166 167 ACPI_FUNCTION_TRACE ("NsEvaluateRelative"); 168 169 170 /* 171 * Must have a valid object handle 172 */ 173 if (!Handle) 174 { 175 return_ACPI_STATUS (AE_BAD_PARAMETER); 176 } 177 178 /* Build an internal name string for the method */ 179 180 Status = AcpiNsInternalizeName (Pathname, &InternalPath); 181 if (ACPI_FAILURE (Status)) 182 { 183 return_ACPI_STATUS (Status); 184 } 185
|
| 186 ScopeInfo = AcpiUtCreateGenericState (); 187 if (!ScopeInfo) 188 { 189 goto Cleanup1; 190 } 191
|
186 /* Get the prefix handle and Node */ 187 188 Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); 189 if (ACPI_FAILURE (Status)) 190 { 191 goto Cleanup; 192 } 193 194 PrefixNode = AcpiNsMapHandleToNode (Handle); 195 if (!PrefixNode) 196 { 197 (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); 198 Status = AE_BAD_PARAMETER; 199 goto Cleanup; 200 } 201 202 /* Lookup the name in the namespace */ 203
| 192 /* Get the prefix handle and Node */ 193 194 Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); 195 if (ACPI_FAILURE (Status)) 196 { 197 goto Cleanup; 198 } 199 200 PrefixNode = AcpiNsMapHandleToNode (Handle); 201 if (!PrefixNode) 202 { 203 (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); 204 Status = AE_BAD_PARAMETER; 205 goto Cleanup; 206 } 207 208 /* Lookup the name in the namespace */ 209
|
204 ScopeInfo.Scope.Node = PrefixNode; 205 Status = AcpiNsLookup (&ScopeInfo, InternalPath, ACPI_TYPE_ANY,
| 210 ScopeInfo->Scope.Node = PrefixNode; 211 Status = AcpiNsLookup (ScopeInfo, InternalPath, ACPI_TYPE_ANY,
|
206 ACPI_IMODE_EXECUTE, ACPI_NS_NO_UPSEARCH, NULL, 207 &Node); 208 209 (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); 210 211 if (ACPI_FAILURE (Status)) 212 { 213 ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "Object [%s] not found [%s]\n", 214 Pathname, AcpiFormatException (Status))); 215 goto Cleanup; 216 } 217 218 /* 219 * Now that we have a handle to the object, we can attempt 220 * to evaluate it. 221 */ 222 ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "%s [%p] Value %p\n", 223 Pathname, Node, AcpiNsGetAttachedObject (Node))); 224 225 Status = AcpiNsEvaluateByHandle (Node, Params, ReturnObject); 226 227 ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "*** Completed eval of object %s ***\n", 228 Pathname)); 229 230Cleanup:
| 212 ACPI_IMODE_EXECUTE, ACPI_NS_NO_UPSEARCH, NULL, 213 &Node); 214 215 (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); 216 217 if (ACPI_FAILURE (Status)) 218 { 219 ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "Object [%s] not found [%s]\n", 220 Pathname, AcpiFormatException (Status))); 221 goto Cleanup; 222 } 223 224 /* 225 * Now that we have a handle to the object, we can attempt 226 * to evaluate it. 227 */ 228 ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "%s [%p] Value %p\n", 229 Pathname, Node, AcpiNsGetAttachedObject (Node))); 230 231 Status = AcpiNsEvaluateByHandle (Node, Params, ReturnObject); 232 233 ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "*** Completed eval of object %s ***\n", 234 Pathname)); 235 236Cleanup:
|
| 237 AcpiUtDeleteGenericState (ScopeInfo);
|
231
| 238
|
| 239Cleanup1:
|
232 ACPI_MEM_FREE (InternalPath); 233 return_ACPI_STATUS (Status); 234} 235 236 237/******************************************************************************* 238 * 239 * FUNCTION: AcpiNsEvaluateByName 240 * 241 * PARAMETERS: Pathname - Fully qualified pathname to the object 242 * ReturnObject - Where to put method's return value (if 243 * any). If NULL, no value is returned. 244 * Params - List of parameters to pass to the method, 245 * terminated by NULL. Params itself may be 246 * NULL if no parameters are being passed. 247 * 248 * RETURN: Status 249 * 250 * DESCRIPTION: Find and execute the requested method passing the given 251 * parameters 252 * 253 * MUTEX: Locks Namespace 254 * 255 ******************************************************************************/ 256 257ACPI_STATUS 258AcpiNsEvaluateByName ( 259 char *Pathname, 260 ACPI_OPERAND_OBJECT **Params, 261 ACPI_OPERAND_OBJECT **ReturnObject) 262{ 263 ACPI_STATUS Status; 264 ACPI_NAMESPACE_NODE *Node = NULL; 265 char *InternalPath = NULL; 266 267 268 ACPI_FUNCTION_TRACE ("NsEvaluateByName"); 269 270 271 /* Build an internal name string for the method */ 272 273 Status = AcpiNsInternalizeName (Pathname, &InternalPath); 274 if (ACPI_FAILURE (Status)) 275 { 276 return_ACPI_STATUS (Status); 277 } 278 279 Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); 280 if (ACPI_FAILURE (Status)) 281 { 282 goto Cleanup; 283 } 284 285 /* Lookup the name in the namespace */ 286 287 Status = AcpiNsLookup (NULL, InternalPath, ACPI_TYPE_ANY, 288 ACPI_IMODE_EXECUTE, ACPI_NS_NO_UPSEARCH, NULL, 289 &Node); 290 291 (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); 292 293 if (ACPI_FAILURE (Status)) 294 { 295 ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "Object at [%s] was not found, status=%.4X\n", 296 Pathname, Status)); 297 goto Cleanup; 298 } 299 300 /* 301 * Now that we have a handle to the object, we can attempt 302 * to evaluate it. 303 */ 304 ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "%s [%p] Value %p\n", 305 Pathname, Node, AcpiNsGetAttachedObject (Node))); 306 307 Status = AcpiNsEvaluateByHandle (Node, Params, ReturnObject); 308 309 ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "*** Completed eval of object %s ***\n", 310 Pathname)); 311 312 313Cleanup: 314 315 /* Cleanup */ 316 317 if (InternalPath) 318 { 319 ACPI_MEM_FREE (InternalPath); 320 } 321 322 return_ACPI_STATUS (Status); 323} 324 325 326/******************************************************************************* 327 * 328 * FUNCTION: AcpiNsEvaluateByHandle 329 * 330 * PARAMETERS: Handle - Method Node to execute 331 * Params - List of parameters to pass to the method, 332 * terminated by NULL. Params itself may be 333 * NULL if no parameters are being passed. 334 * ReturnObject - Where to put method's return value (if 335 * any). If NULL, no value is returned. 336 * 337 * RETURN: Status 338 * 339 * DESCRIPTION: Execute the requested method passing the given parameters 340 * 341 * MUTEX: Locks Namespace 342 * 343 ******************************************************************************/ 344 345ACPI_STATUS 346AcpiNsEvaluateByHandle ( 347 ACPI_NAMESPACE_NODE *Handle, 348 ACPI_OPERAND_OBJECT **Params, 349 ACPI_OPERAND_OBJECT **ReturnObject) 350{ 351 ACPI_NAMESPACE_NODE *Node; 352 ACPI_STATUS Status; 353 ACPI_OPERAND_OBJECT *LocalReturnObject; 354 355 356 ACPI_FUNCTION_TRACE ("NsEvaluateByHandle"); 357 358 359 /* Check if namespace has been initialized */ 360 361 if (!AcpiGbl_RootNode) 362 { 363 return_ACPI_STATUS (AE_NO_NAMESPACE); 364 } 365 366 /* Parameter Validation */ 367 368 if (!Handle) 369 { 370 return_ACPI_STATUS (AE_BAD_PARAMETER); 371 } 372 373 if (ReturnObject) 374 { 375 /* Initialize the return value to an invalid object */ 376 377 *ReturnObject = NULL; 378 } 379 380 /* Get the prefix handle and Node */ 381 382 Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); 383 if (ACPI_FAILURE (Status)) 384 { 385 return_ACPI_STATUS (Status); 386 } 387 388 Node = AcpiNsMapHandleToNode (Handle); 389 if (!Node) 390 { 391 (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); 392 return_ACPI_STATUS (AE_BAD_PARAMETER); 393 } 394 395 /* 396 * Two major cases here: 397 * 1) The object is an actual control method -- execute it. 398 * 2) The object is not a method -- just return it's current 399 * value 400 * 401 * In both cases, the namespace is unlocked by the 402 * AcpiNs* procedure 403 */ 404 if (AcpiNsGetType (Node) == ACPI_TYPE_METHOD) 405 { 406 /* 407 * Case 1) We have an actual control method to execute 408 */ 409 Status = AcpiNsExecuteControlMethod (Node, Params, 410 &LocalReturnObject); 411 } 412 else 413 { 414 /* 415 * Case 2) Object is NOT a method, just return its 416 * current value 417 */ 418 Status = AcpiNsGetObjectValue (Node, &LocalReturnObject); 419 } 420 421 /* 422 * Check if there is a return value on the stack that must 423 * be dealt with 424 */ 425 if (Status == AE_CTRL_RETURN_VALUE) 426 { 427 /* 428 * If the Method returned a value and the caller 429 * provided a place to store a returned value, Copy 430 * the returned value to the object descriptor provided 431 * by the caller. 432 */ 433 if (ReturnObject) 434 { 435 /* 436 * Valid return object, copy the pointer to 437 * the returned object 438 */ 439 *ReturnObject = LocalReturnObject; 440 } 441 442 /* Map AE_CTRL_RETURN_VALUE to AE_OK, we are done with it */ 443 444 Status = AE_OK; 445 } 446 447 /* 448 * Namespace was unlocked by the handling AcpiNs* function, 449 * so we just return 450 */ 451 return_ACPI_STATUS (Status); 452} 453 454 455/******************************************************************************* 456 * 457 * FUNCTION: AcpiNsExecuteControlMethod 458 * 459 * PARAMETERS: MethodNode - The method to execute 460 * Params - List of parameters to pass to the method, 461 * terminated by NULL. Params itself may be 462 * NULL if no parameters are being passed. 463 * ReturnObjDesc - List of result objects to be returned 464 * from the method. 465 * 466 * RETURN: Status 467 * 468 * DESCRIPTION: Execute the requested method passing the given parameters 469 * 470 * MUTEX: Assumes namespace is locked 471 * 472 ******************************************************************************/ 473 474ACPI_STATUS 475AcpiNsExecuteControlMethod ( 476 ACPI_NAMESPACE_NODE *MethodNode, 477 ACPI_OPERAND_OBJECT **Params, 478 ACPI_OPERAND_OBJECT **ReturnObjDesc) 479{ 480 ACPI_STATUS Status; 481 ACPI_OPERAND_OBJECT *ObjDesc; 482 483 484 ACPI_FUNCTION_TRACE ("NsExecuteControlMethod"); 485 486 487 /* Verify that there is a method associated with this object */ 488 489 ObjDesc = AcpiNsGetAttachedObject (MethodNode); 490 if (!ObjDesc) 491 { 492 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "No attached method object\n")); 493 494 (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); 495 return_ACPI_STATUS (AE_NULL_OBJECT); 496 } 497 498 ACPI_DUMP_PATHNAME (MethodNode, "Execute Method:", 499 ACPI_LV_INFO, _COMPONENT); 500 501 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Method at AML address %p Length %X\n", 502 ObjDesc->Method.AmlStart + 1, ObjDesc->Method.AmlLength - 1)); 503 504 /* 505 * Unlock the namespace before execution. This allows namespace access 506 * via the external Acpi* interfaces while a method is being executed. 507 * However, any namespace deletion must acquire both the namespace and 508 * interpreter locks to ensure that no thread is using the portion of the 509 * namespace that is being deleted. 510 */ 511 Status = AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); 512 if (ACPI_FAILURE (Status)) 513 { 514 return_ACPI_STATUS (Status); 515 } 516 517 /* 518 * Execute the method via the interpreter. The interpreter is locked 519 * here before calling into the AML parser 520 */ 521 Status = AcpiExEnterInterpreter (); 522 if (ACPI_FAILURE (Status)) 523 { 524 return_ACPI_STATUS (Status); 525 } 526 527 Status = AcpiPsxExecute (MethodNode, Params, ReturnObjDesc); 528 AcpiExExitInterpreter (); 529 530 return_ACPI_STATUS (Status); 531} 532 533 534/******************************************************************************* 535 * 536 * FUNCTION: AcpiNsGetObjectValue 537 * 538 * PARAMETERS: Node - The object 539 * ReturnObjDesc - Where the objects value is returned 540 * 541 * RETURN: Status 542 * 543 * DESCRIPTION: Return the current value of the object 544 * 545 * MUTEX: Assumes namespace is locked, leaves namespace unlocked 546 * 547 ******************************************************************************/ 548 549ACPI_STATUS 550AcpiNsGetObjectValue ( 551 ACPI_NAMESPACE_NODE *Node, 552 ACPI_OPERAND_OBJECT **ReturnObjDesc) 553{ 554 ACPI_STATUS Status = AE_OK; 555 ACPI_NAMESPACE_NODE *ResolvedNode = Node; 556 557 558 ACPI_FUNCTION_TRACE ("NsGetObjectValue"); 559 560 561 /* 562 * Objects require additional resolution steps (e.g., the 563 * Node may be a field that must be read, etc.) -- we can't just grab 564 * the object out of the node. 565 */ 566 567 /* 568 * Use ResolveNodeToValue() to get the associated value. This call 569 * always deletes ObjDesc (allocated above). 570 * 571 * NOTE: we can get away with passing in NULL for a walk state 572 * because ObjDesc is guaranteed to not be a reference to either 573 * a method local or a method argument (because this interface can only be 574 * called from the AcpiEvaluate external interface, never called from 575 * a running control method.) 576 * 577 * Even though we do not directly invoke the interpreter 578 * for this, we must enter it because we could access an opregion. 579 * The opregion access code assumes that the interpreter 580 * is locked. 581 * 582 * We must release the namespace lock before entering the 583 * intepreter. 584 */ 585 Status = AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); 586 if (ACPI_FAILURE (Status)) 587 { 588 return_ACPI_STATUS (Status); 589 } 590 591 Status = AcpiExEnterInterpreter (); 592 if (ACPI_SUCCESS (Status)) 593 { 594 Status = AcpiExResolveNodeToValue (&ResolvedNode, NULL); 595 /* 596 * If AcpiExResolveNodeToValue() succeeded, the return value was 597 * placed in ResolvedNode. 598 */ 599 AcpiExExitInterpreter (); 600 601 if (ACPI_SUCCESS (Status)) 602 { 603 Status = AE_CTRL_RETURN_VALUE; 604 *ReturnObjDesc = ACPI_CAST_PTR (ACPI_OPERAND_OBJECT, ResolvedNode); 605 ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "Returning object %p [%s]\n", 606 *ReturnObjDesc, AcpiUtGetObjectTypeName (*ReturnObjDesc))); 607 } 608 } 609 610 /* Namespace is unlocked */ 611 612 return_ACPI_STATUS (Status); 613} 614
| 240 ACPI_MEM_FREE (InternalPath); 241 return_ACPI_STATUS (Status); 242} 243 244 245/******************************************************************************* 246 * 247 * FUNCTION: AcpiNsEvaluateByName 248 * 249 * PARAMETERS: Pathname - Fully qualified pathname to the object 250 * ReturnObject - Where to put method's return value (if 251 * any). If NULL, no value is returned. 252 * Params - List of parameters to pass to the method, 253 * terminated by NULL. Params itself may be 254 * NULL if no parameters are being passed. 255 * 256 * RETURN: Status 257 * 258 * DESCRIPTION: Find and execute the requested method passing the given 259 * parameters 260 * 261 * MUTEX: Locks Namespace 262 * 263 ******************************************************************************/ 264 265ACPI_STATUS 266AcpiNsEvaluateByName ( 267 char *Pathname, 268 ACPI_OPERAND_OBJECT **Params, 269 ACPI_OPERAND_OBJECT **ReturnObject) 270{ 271 ACPI_STATUS Status; 272 ACPI_NAMESPACE_NODE *Node = NULL; 273 char *InternalPath = NULL; 274 275 276 ACPI_FUNCTION_TRACE ("NsEvaluateByName"); 277 278 279 /* Build an internal name string for the method */ 280 281 Status = AcpiNsInternalizeName (Pathname, &InternalPath); 282 if (ACPI_FAILURE (Status)) 283 { 284 return_ACPI_STATUS (Status); 285 } 286 287 Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); 288 if (ACPI_FAILURE (Status)) 289 { 290 goto Cleanup; 291 } 292 293 /* Lookup the name in the namespace */ 294 295 Status = AcpiNsLookup (NULL, InternalPath, ACPI_TYPE_ANY, 296 ACPI_IMODE_EXECUTE, ACPI_NS_NO_UPSEARCH, NULL, 297 &Node); 298 299 (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); 300 301 if (ACPI_FAILURE (Status)) 302 { 303 ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "Object at [%s] was not found, status=%.4X\n", 304 Pathname, Status)); 305 goto Cleanup; 306 } 307 308 /* 309 * Now that we have a handle to the object, we can attempt 310 * to evaluate it. 311 */ 312 ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "%s [%p] Value %p\n", 313 Pathname, Node, AcpiNsGetAttachedObject (Node))); 314 315 Status = AcpiNsEvaluateByHandle (Node, Params, ReturnObject); 316 317 ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "*** Completed eval of object %s ***\n", 318 Pathname)); 319 320 321Cleanup: 322 323 /* Cleanup */ 324 325 if (InternalPath) 326 { 327 ACPI_MEM_FREE (InternalPath); 328 } 329 330 return_ACPI_STATUS (Status); 331} 332 333 334/******************************************************************************* 335 * 336 * FUNCTION: AcpiNsEvaluateByHandle 337 * 338 * PARAMETERS: Handle - Method Node to execute 339 * Params - List of parameters to pass to the method, 340 * terminated by NULL. Params itself may be 341 * NULL if no parameters are being passed. 342 * ReturnObject - Where to put method's return value (if 343 * any). If NULL, no value is returned. 344 * 345 * RETURN: Status 346 * 347 * DESCRIPTION: Execute the requested method passing the given parameters 348 * 349 * MUTEX: Locks Namespace 350 * 351 ******************************************************************************/ 352 353ACPI_STATUS 354AcpiNsEvaluateByHandle ( 355 ACPI_NAMESPACE_NODE *Handle, 356 ACPI_OPERAND_OBJECT **Params, 357 ACPI_OPERAND_OBJECT **ReturnObject) 358{ 359 ACPI_NAMESPACE_NODE *Node; 360 ACPI_STATUS Status; 361 ACPI_OPERAND_OBJECT *LocalReturnObject; 362 363 364 ACPI_FUNCTION_TRACE ("NsEvaluateByHandle"); 365 366 367 /* Check if namespace has been initialized */ 368 369 if (!AcpiGbl_RootNode) 370 { 371 return_ACPI_STATUS (AE_NO_NAMESPACE); 372 } 373 374 /* Parameter Validation */ 375 376 if (!Handle) 377 { 378 return_ACPI_STATUS (AE_BAD_PARAMETER); 379 } 380 381 if (ReturnObject) 382 { 383 /* Initialize the return value to an invalid object */ 384 385 *ReturnObject = NULL; 386 } 387 388 /* Get the prefix handle and Node */ 389 390 Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); 391 if (ACPI_FAILURE (Status)) 392 { 393 return_ACPI_STATUS (Status); 394 } 395 396 Node = AcpiNsMapHandleToNode (Handle); 397 if (!Node) 398 { 399 (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); 400 return_ACPI_STATUS (AE_BAD_PARAMETER); 401 } 402 403 /* 404 * Two major cases here: 405 * 1) The object is an actual control method -- execute it. 406 * 2) The object is not a method -- just return it's current 407 * value 408 * 409 * In both cases, the namespace is unlocked by the 410 * AcpiNs* procedure 411 */ 412 if (AcpiNsGetType (Node) == ACPI_TYPE_METHOD) 413 { 414 /* 415 * Case 1) We have an actual control method to execute 416 */ 417 Status = AcpiNsExecuteControlMethod (Node, Params, 418 &LocalReturnObject); 419 } 420 else 421 { 422 /* 423 * Case 2) Object is NOT a method, just return its 424 * current value 425 */ 426 Status = AcpiNsGetObjectValue (Node, &LocalReturnObject); 427 } 428 429 /* 430 * Check if there is a return value on the stack that must 431 * be dealt with 432 */ 433 if (Status == AE_CTRL_RETURN_VALUE) 434 { 435 /* 436 * If the Method returned a value and the caller 437 * provided a place to store a returned value, Copy 438 * the returned value to the object descriptor provided 439 * by the caller. 440 */ 441 if (ReturnObject) 442 { 443 /* 444 * Valid return object, copy the pointer to 445 * the returned object 446 */ 447 *ReturnObject = LocalReturnObject; 448 } 449 450 /* Map AE_CTRL_RETURN_VALUE to AE_OK, we are done with it */ 451 452 Status = AE_OK; 453 } 454 455 /* 456 * Namespace was unlocked by the handling AcpiNs* function, 457 * so we just return 458 */ 459 return_ACPI_STATUS (Status); 460} 461 462 463/******************************************************************************* 464 * 465 * FUNCTION: AcpiNsExecuteControlMethod 466 * 467 * PARAMETERS: MethodNode - The method to execute 468 * Params - List of parameters to pass to the method, 469 * terminated by NULL. Params itself may be 470 * NULL if no parameters are being passed. 471 * ReturnObjDesc - List of result objects to be returned 472 * from the method. 473 * 474 * RETURN: Status 475 * 476 * DESCRIPTION: Execute the requested method passing the given parameters 477 * 478 * MUTEX: Assumes namespace is locked 479 * 480 ******************************************************************************/ 481 482ACPI_STATUS 483AcpiNsExecuteControlMethod ( 484 ACPI_NAMESPACE_NODE *MethodNode, 485 ACPI_OPERAND_OBJECT **Params, 486 ACPI_OPERAND_OBJECT **ReturnObjDesc) 487{ 488 ACPI_STATUS Status; 489 ACPI_OPERAND_OBJECT *ObjDesc; 490 491 492 ACPI_FUNCTION_TRACE ("NsExecuteControlMethod"); 493 494 495 /* Verify that there is a method associated with this object */ 496 497 ObjDesc = AcpiNsGetAttachedObject (MethodNode); 498 if (!ObjDesc) 499 { 500 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "No attached method object\n")); 501 502 (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); 503 return_ACPI_STATUS (AE_NULL_OBJECT); 504 } 505 506 ACPI_DUMP_PATHNAME (MethodNode, "Execute Method:", 507 ACPI_LV_INFO, _COMPONENT); 508 509 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Method at AML address %p Length %X\n", 510 ObjDesc->Method.AmlStart + 1, ObjDesc->Method.AmlLength - 1)); 511 512 /* 513 * Unlock the namespace before execution. This allows namespace access 514 * via the external Acpi* interfaces while a method is being executed. 515 * However, any namespace deletion must acquire both the namespace and 516 * interpreter locks to ensure that no thread is using the portion of the 517 * namespace that is being deleted. 518 */ 519 Status = AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); 520 if (ACPI_FAILURE (Status)) 521 { 522 return_ACPI_STATUS (Status); 523 } 524 525 /* 526 * Execute the method via the interpreter. The interpreter is locked 527 * here before calling into the AML parser 528 */ 529 Status = AcpiExEnterInterpreter (); 530 if (ACPI_FAILURE (Status)) 531 { 532 return_ACPI_STATUS (Status); 533 } 534 535 Status = AcpiPsxExecute (MethodNode, Params, ReturnObjDesc); 536 AcpiExExitInterpreter (); 537 538 return_ACPI_STATUS (Status); 539} 540 541 542/******************************************************************************* 543 * 544 * FUNCTION: AcpiNsGetObjectValue 545 * 546 * PARAMETERS: Node - The object 547 * ReturnObjDesc - Where the objects value is returned 548 * 549 * RETURN: Status 550 * 551 * DESCRIPTION: Return the current value of the object 552 * 553 * MUTEX: Assumes namespace is locked, leaves namespace unlocked 554 * 555 ******************************************************************************/ 556 557ACPI_STATUS 558AcpiNsGetObjectValue ( 559 ACPI_NAMESPACE_NODE *Node, 560 ACPI_OPERAND_OBJECT **ReturnObjDesc) 561{ 562 ACPI_STATUS Status = AE_OK; 563 ACPI_NAMESPACE_NODE *ResolvedNode = Node; 564 565 566 ACPI_FUNCTION_TRACE ("NsGetObjectValue"); 567 568 569 /* 570 * Objects require additional resolution steps (e.g., the 571 * Node may be a field that must be read, etc.) -- we can't just grab 572 * the object out of the node. 573 */ 574 575 /* 576 * Use ResolveNodeToValue() to get the associated value. This call 577 * always deletes ObjDesc (allocated above). 578 * 579 * NOTE: we can get away with passing in NULL for a walk state 580 * because ObjDesc is guaranteed to not be a reference to either 581 * a method local or a method argument (because this interface can only be 582 * called from the AcpiEvaluate external interface, never called from 583 * a running control method.) 584 * 585 * Even though we do not directly invoke the interpreter 586 * for this, we must enter it because we could access an opregion. 587 * The opregion access code assumes that the interpreter 588 * is locked. 589 * 590 * We must release the namespace lock before entering the 591 * intepreter. 592 */ 593 Status = AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); 594 if (ACPI_FAILURE (Status)) 595 { 596 return_ACPI_STATUS (Status); 597 } 598 599 Status = AcpiExEnterInterpreter (); 600 if (ACPI_SUCCESS (Status)) 601 { 602 Status = AcpiExResolveNodeToValue (&ResolvedNode, NULL); 603 /* 604 * If AcpiExResolveNodeToValue() succeeded, the return value was 605 * placed in ResolvedNode. 606 */ 607 AcpiExExitInterpreter (); 608 609 if (ACPI_SUCCESS (Status)) 610 { 611 Status = AE_CTRL_RETURN_VALUE; 612 *ReturnObjDesc = ACPI_CAST_PTR (ACPI_OPERAND_OBJECT, ResolvedNode); 613 ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "Returning object %p [%s]\n", 614 *ReturnObjDesc, AcpiUtGetObjectTypeName (*ReturnObjDesc))); 615 } 616 } 617 618 /* Namespace is unlocked */ 619 620 return_ACPI_STATUS (Status); 621} 622
|