1 /******************************************************************************* 2 * 3 * Module Name: nseval - Object evaluation, includes control method execution 4 * 5 ******************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2015, Intel Corp. 9 * All rights reserved. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions, and the following disclaimer, 16 * without modification. 17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 18 * substantially similar to the "NO WARRANTY" disclaimer below 19 * ("Disclaimer") and any redistribution must be conditioned upon 20 * including a substantially similar Disclaimer requirement for further 21 * binary redistribution. 22 * 3. Neither the names of the above-listed copyright holders nor the names 23 * of any contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * Alternatively, this software may be distributed under the terms of the 27 * GNU General Public License ("GPL") version 2 as published by the Free 28 * Software Foundation. 29 * 30 * NO WARRANTY 31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 41 * POSSIBILITY OF SUCH DAMAGES. 42 */ 43 44 #include <contrib/dev/acpica/include/acpi.h> 45 #include <contrib/dev/acpica/include/accommon.h> 46 #include <contrib/dev/acpica/include/acparser.h> 47 #include <contrib/dev/acpica/include/acinterp.h> 48 #include <contrib/dev/acpica/include/acnamesp.h> 49 50 51 #define _COMPONENT ACPI_NAMESPACE 52 ACPI_MODULE_NAME ("nseval") 53 54 /* Local prototypes */ 55 56 static void 57 AcpiNsExecModuleCode ( 58 ACPI_OPERAND_OBJECT *MethodObj, 59 ACPI_EVALUATE_INFO *Info); 60 61 62 /******************************************************************************* 63 * 64 * FUNCTION: AcpiNsEvaluate 65 * 66 * PARAMETERS: Info - Evaluation info block, contains these fields 67 * and more: 68 * PrefixNode - Prefix or Method/Object Node to execute 69 * RelativePath - Name of method to execute, If NULL, the 70 * Node is the object to execute 71 * Parameters - List of parameters to pass to the method, 72 * terminated by NULL. Params itself may be 73 * NULL if no parameters are being passed. 74 * ParameterType - Type of Parameter list 75 * ReturnObject - Where to put method's return value (if 76 * any). If NULL, no value is returned. 77 * Flags - ACPI_IGNORE_RETURN_VALUE to delete return 78 * 79 * RETURN: Status 80 * 81 * DESCRIPTION: Execute a control method or return the current value of an 82 * ACPI namespace object. 83 * 84 * MUTEX: Locks interpreter 85 * 86 ******************************************************************************/ 87 88 ACPI_STATUS 89 AcpiNsEvaluate ( 90 ACPI_EVALUATE_INFO *Info) 91 { 92 ACPI_STATUS Status; 93 94 95 ACPI_FUNCTION_TRACE (NsEvaluate); 96 97 98 if (!Info) 99 { 100 return_ACPI_STATUS (AE_BAD_PARAMETER); 101 } 102 103 if (!Info->Node) 104 { 105 /* 106 * Get the actual namespace node for the target object if we 107 * need to. Handles these cases: 108 * 109 * 1) Null node, valid pathname from root (absolute path) 110 * 2) Node and valid pathname (path relative to Node) 111 * 3) Node, Null pathname 112 */ 113 Status = AcpiNsGetNode (Info->PrefixNode, Info->RelativePathname, 114 ACPI_NS_NO_UPSEARCH, &Info->Node); 115 if (ACPI_FAILURE (Status)) 116 { 117 return_ACPI_STATUS (Status); 118 } 119 } 120 121 /* 122 * For a method alias, we must grab the actual method node so that 123 * proper scoping context will be established before execution. 124 */ 125 if (AcpiNsGetType (Info->Node) == ACPI_TYPE_LOCAL_METHOD_ALIAS) 126 { 127 Info->Node = ACPI_CAST_PTR ( 128 ACPI_NAMESPACE_NODE, Info->Node->Object); 129 } 130 131 /* Complete the info block initialization */ 132 133 Info->ReturnObject = NULL; 134 Info->NodeFlags = Info->Node->Flags; 135 Info->ObjDesc = AcpiNsGetAttachedObject (Info->Node); 136 137 ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "%s [%p] Value %p\n", 138 Info->RelativePathname, Info->Node, 139 AcpiNsGetAttachedObject (Info->Node))); 140 141 /* Get info if we have a predefined name (_HID, etc.) */ 142 143 Info->Predefined = AcpiUtMatchPredefinedMethod (Info->Node->Name.Ascii); 144 145 /* Get the full pathname to the object, for use in warning messages */ 146 147 Info->FullPathname = AcpiNsGetExternalPathname (Info->Node); 148 if (!Info->FullPathname) 149 { 150 return_ACPI_STATUS (AE_NO_MEMORY); 151 } 152 153 /* Count the number of arguments being passed in */ 154 155 Info->ParamCount = 0; 156 if (Info->Parameters) 157 { 158 while (Info->Parameters[Info->ParamCount]) 159 { 160 Info->ParamCount++; 161 } 162 163 /* Warn on impossible argument count */ 164 165 if (Info->ParamCount > ACPI_METHOD_NUM_ARGS) 166 { 167 ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname, ACPI_WARN_ALWAYS, 168 "Excess arguments (%u) - using only %u", 169 Info->ParamCount, ACPI_METHOD_NUM_ARGS)); 170 171 Info->ParamCount = ACPI_METHOD_NUM_ARGS; 172 } 173 } 174 175 /* 176 * For predefined names: Check that the declared argument count 177 * matches the ACPI spec -- otherwise this is a BIOS error. 178 */ 179 AcpiNsCheckAcpiCompliance (Info->FullPathname, Info->Node, 180 Info->Predefined); 181 182 /* 183 * For all names: Check that the incoming argument count for 184 * this method/object matches the actual ASL/AML definition. 185 */ 186 AcpiNsCheckArgumentCount (Info->FullPathname, Info->Node, 187 Info->ParamCount, Info->Predefined); 188 189 /* For predefined names: Typecheck all incoming arguments */ 190 191 AcpiNsCheckArgumentTypes (Info); 192 193 /* 194 * Three major evaluation cases: 195 * 196 * 1) Object types that cannot be evaluated by definition 197 * 2) The object is a control method -- execute it 198 * 3) The object is not a method -- just return it's current value 199 */ 200 switch (AcpiNsGetType (Info->Node)) 201 { 202 case ACPI_TYPE_DEVICE: 203 case ACPI_TYPE_EVENT: 204 case ACPI_TYPE_MUTEX: 205 case ACPI_TYPE_REGION: 206 case ACPI_TYPE_THERMAL: 207 case ACPI_TYPE_LOCAL_SCOPE: 208 /* 209 * 1) Disallow evaluation of certain object types. For these, 210 * object evaluation is undefined and not supported. 211 */ 212 ACPI_ERROR ((AE_INFO, 213 "%s: Evaluation of object type [%s] is not supported", 214 Info->FullPathname, 215 AcpiUtGetTypeName (Info->Node->Type))); 216 217 Status = AE_TYPE; 218 goto Cleanup; 219 220 case ACPI_TYPE_METHOD: 221 /* 222 * 2) Object is a control method - execute it 223 */ 224 225 /* Verify that there is a method object associated with this node */ 226 227 if (!Info->ObjDesc) 228 { 229 ACPI_ERROR ((AE_INFO, "%s: Method has no attached sub-object", 230 Info->FullPathname)); 231 Status = AE_NULL_OBJECT; 232 goto Cleanup; 233 } 234 235 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, 236 "**** Execute method [%s] at AML address %p length %X\n", 237 Info->FullPathname, 238 Info->ObjDesc->Method.AmlStart + 1, 239 Info->ObjDesc->Method.AmlLength - 1)); 240 241 /* 242 * Any namespace deletion must acquire both the namespace and 243 * interpreter locks to ensure that no thread is using the portion of 244 * the namespace that is being deleted. 245 * 246 * Execute the method via the interpreter. The interpreter is locked 247 * here before calling into the AML parser 248 */ 249 AcpiExEnterInterpreter (); 250 Status = AcpiPsExecuteMethod (Info); 251 AcpiExExitInterpreter (); 252 break; 253 254 default: 255 /* 256 * 3) All other non-method objects -- get the current object value 257 */ 258 259 /* 260 * Some objects require additional resolution steps (e.g., the Node 261 * may be a field that must be read, etc.) -- we can't just grab 262 * the object out of the node. 263 * 264 * Use ResolveNodeToValue() to get the associated value. 265 * 266 * NOTE: we can get away with passing in NULL for a walk state because 267 * the Node is guaranteed to not be a reference to either a method 268 * local or a method argument (because this interface is never called 269 * from a running method.) 270 * 271 * Even though we do not directly invoke the interpreter for object 272 * resolution, we must lock it because we could access an OpRegion. 273 * The OpRegion access code assumes that the interpreter is locked. 274 */ 275 AcpiExEnterInterpreter (); 276 277 /* TBD: ResolveNodeToValue has a strange interface, fix */ 278 279 Info->ReturnObject = ACPI_CAST_PTR (ACPI_OPERAND_OBJECT, Info->Node); 280 281 Status = AcpiExResolveNodeToValue (ACPI_CAST_INDIRECT_PTR ( 282 ACPI_NAMESPACE_NODE, &Info->ReturnObject), NULL); 283 AcpiExExitInterpreter (); 284 285 if (ACPI_FAILURE (Status)) 286 { 287 goto Cleanup; 288 } 289 290 ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "Returned object %p [%s]\n", 291 Info->ReturnObject, 292 AcpiUtGetObjectTypeName (Info->ReturnObject))); 293 294 Status = AE_CTRL_RETURN_VALUE; /* Always has a "return value" */ 295 break; 296 } 297 298 /* 299 * For predefined names, check the return value against the ACPI 300 * specification. Some incorrect return value types are repaired. 301 */ 302 (void) AcpiNsCheckReturnValue (Info->Node, Info, Info->ParamCount, 303 Status, &Info->ReturnObject); 304 305 /* Check if there is a return value that must be dealt with */ 306 307 if (Status == AE_CTRL_RETURN_VALUE) 308 { 309 /* If caller does not want the return value, delete it */ 310 311 if (Info->Flags & ACPI_IGNORE_RETURN_VALUE) 312 { 313 AcpiUtRemoveReference (Info->ReturnObject); 314 Info->ReturnObject = NULL; 315 } 316 317 /* Map AE_CTRL_RETURN_VALUE to AE_OK, we are done with it */ 318 319 Status = AE_OK; 320 } 321 322 ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, 323 "*** Completed evaluation of object %s ***\n", 324 Info->RelativePathname)); 325 326 Cleanup: 327 /* 328 * Namespace was unlocked by the handling AcpiNs* function, so we 329 * just free the pathname and return 330 */ 331 ACPI_FREE (Info->FullPathname); 332 Info->FullPathname = NULL; 333 return_ACPI_STATUS (Status); 334 } 335 336 337 /******************************************************************************* 338 * 339 * FUNCTION: AcpiNsExecModuleCodeList 340 * 341 * PARAMETERS: None 342 * 343 * RETURN: None. Exceptions during method execution are ignored, since 344 * we cannot abort a table load. 345 * 346 * DESCRIPTION: Execute all elements of the global module-level code list. 347 * Each element is executed as a single control method. 348 * 349 ******************************************************************************/ 350 351 void 352 AcpiNsExecModuleCodeList ( 353 void) 354 { 355 ACPI_OPERAND_OBJECT *Prev; 356 ACPI_OPERAND_OBJECT *Next; 357 ACPI_EVALUATE_INFO *Info; 358 UINT32 MethodCount = 0; 359 360 361 ACPI_FUNCTION_TRACE (NsExecModuleCodeList); 362 363 364 /* Exit now if the list is empty */ 365 366 Next = AcpiGbl_ModuleCodeList; 367 if (!Next) 368 { 369 return_VOID; 370 } 371 372 /* Allocate the evaluation information block */ 373 374 Info = ACPI_ALLOCATE (sizeof (ACPI_EVALUATE_INFO)); 375 if (!Info) 376 { 377 return_VOID; 378 } 379 380 /* Walk the list, executing each "method" */ 381 382 while (Next) 383 { 384 Prev = Next; 385 Next = Next->Method.Mutex; 386 387 /* Clear the link field and execute the method */ 388 389 Prev->Method.Mutex = NULL; 390 AcpiNsExecModuleCode (Prev, Info); 391 MethodCount++; 392 393 /* Delete the (temporary) method object */ 394 395 AcpiUtRemoveReference (Prev); 396 } 397 398 ACPI_INFO ((AE_INFO, 399 "Executed %u blocks of module-level executable AML code", 400 MethodCount)); 401 402 ACPI_FREE (Info); 403 AcpiGbl_ModuleCodeList = NULL; 404 return_VOID; 405 } 406 407 408 /******************************************************************************* 409 * 410 * FUNCTION: AcpiNsExecModuleCode 411 * 412 * PARAMETERS: MethodObj - Object container for the module-level code 413 * Info - Info block for method evaluation 414 * 415 * RETURN: None. Exceptions during method execution are ignored, since 416 * we cannot abort a table load. 417 * 418 * DESCRIPTION: Execute a control method containing a block of module-level 419 * executable AML code. The control method is temporarily 420 * installed to the root node, then evaluated. 421 * 422 ******************************************************************************/ 423 424 static void 425 AcpiNsExecModuleCode ( 426 ACPI_OPERAND_OBJECT *MethodObj, 427 ACPI_EVALUATE_INFO *Info) 428 { 429 ACPI_OPERAND_OBJECT *ParentObj; 430 ACPI_NAMESPACE_NODE *ParentNode; 431 ACPI_OBJECT_TYPE Type; 432 ACPI_STATUS Status; 433 434 435 ACPI_FUNCTION_TRACE (NsExecModuleCode); 436 437 438 /* 439 * Get the parent node. We cheat by using the NextObject field 440 * of the method object descriptor. 441 */ 442 ParentNode = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, 443 MethodObj->Method.NextObject); 444 Type = AcpiNsGetType (ParentNode); 445 446 /* 447 * Get the region handler and save it in the method object. We may need 448 * this if an operation region declaration causes a _REG method to be run. 449 * 450 * We can't do this in AcpiPsLinkModuleCode because 451 * AcpiGbl_RootNode->Object is NULL at PASS1. 452 */ 453 if ((Type == ACPI_TYPE_DEVICE) && ParentNode->Object) 454 { 455 MethodObj->Method.Dispatch.Handler = 456 ParentNode->Object->Device.Handler; 457 } 458 459 /* Must clear NextObject (AcpiNsAttachObject needs the field) */ 460 461 MethodObj->Method.NextObject = NULL; 462 463 /* Initialize the evaluation information block */ 464 465 memset (Info, 0, sizeof (ACPI_EVALUATE_INFO)); 466 Info->PrefixNode = ParentNode; 467 468 /* 469 * Get the currently attached parent object. Add a reference, because the 470 * ref count will be decreased when the method object is installed to 471 * the parent node. 472 */ 473 ParentObj = AcpiNsGetAttachedObject (ParentNode); 474 if (ParentObj) 475 { 476 AcpiUtAddReference (ParentObj); 477 } 478 479 /* Install the method (module-level code) in the parent node */ 480 481 Status = AcpiNsAttachObject (ParentNode, MethodObj, 482 ACPI_TYPE_METHOD); 483 if (ACPI_FAILURE (Status)) 484 { 485 goto Exit; 486 } 487 488 /* Execute the parent node as a control method */ 489 490 Status = AcpiNsEvaluate (Info); 491 492 ACPI_DEBUG_PRINT ((ACPI_DB_INIT, "Executed module-level code at %p\n", 493 MethodObj->Method.AmlStart)); 494 495 /* Delete a possible implicit return value (in slack mode) */ 496 497 if (Info->ReturnObject) 498 { 499 AcpiUtRemoveReference (Info->ReturnObject); 500 } 501 502 /* Detach the temporary method object */ 503 504 AcpiNsDetachObject (ParentNode); 505 506 /* Restore the original parent object */ 507 508 if (ParentObj) 509 { 510 Status = AcpiNsAttachObject (ParentNode, ParentObj, Type); 511 } 512 else 513 { 514 ParentNode->Type = (UINT8) Type; 515 } 516 517 Exit: 518 if (ParentObj) 519 { 520 AcpiUtRemoveReference (ParentObj); 521 } 522 return_VOID; 523 } 524