1 /****************************************************************************** 2 * 3 * Module Name: dsobject - Dispatcher object management routines 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2016, 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 "acpi.h" 45 #include "accommon.h" 46 #include "acparser.h" 47 #include "amlcode.h" 48 #include "acdispat.h" 49 #include "acnamesp.h" 50 #include "acinterp.h" 51 52 #define _COMPONENT ACPI_DISPATCHER 53 ACPI_MODULE_NAME ("dsobject") 54 55 /* Local prototypes */ 56 57 static ACPI_STATUS 58 AcpiDsBuildInternalObject ( 59 ACPI_WALK_STATE *WalkState, 60 ACPI_PARSE_OBJECT *Op, 61 ACPI_OPERAND_OBJECT **ObjDescPtr); 62 63 64 #ifndef ACPI_NO_METHOD_EXECUTION 65 /******************************************************************************* 66 * 67 * FUNCTION: AcpiDsBuildInternalObject 68 * 69 * PARAMETERS: WalkState - Current walk state 70 * Op - Parser object to be translated 71 * ObjDescPtr - Where the ACPI internal object is returned 72 * 73 * RETURN: Status 74 * 75 * DESCRIPTION: Translate a parser Op object to the equivalent namespace object 76 * Simple objects are any objects other than a package object! 77 * 78 ******************************************************************************/ 79 80 static ACPI_STATUS 81 AcpiDsBuildInternalObject ( 82 ACPI_WALK_STATE *WalkState, 83 ACPI_PARSE_OBJECT *Op, 84 ACPI_OPERAND_OBJECT **ObjDescPtr) 85 { 86 ACPI_OPERAND_OBJECT *ObjDesc; 87 ACPI_STATUS Status; 88 ACPI_OBJECT_TYPE Type; 89 90 91 ACPI_FUNCTION_TRACE (DsBuildInternalObject); 92 93 94 *ObjDescPtr = NULL; 95 if (Op->Common.AmlOpcode == AML_INT_NAMEPATH_OP) 96 { 97 /* 98 * This is a named object reference. If this name was 99 * previously looked up in the namespace, it was stored in this op. 100 * Otherwise, go ahead and look it up now 101 */ 102 if (!Op->Common.Node) 103 { 104 Status = AcpiNsLookup (WalkState->ScopeInfo, 105 Op->Common.Value.String, 106 ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE, 107 ACPI_NS_SEARCH_PARENT | ACPI_NS_DONT_OPEN_SCOPE, NULL, 108 ACPI_CAST_INDIRECT_PTR (ACPI_NAMESPACE_NODE, &(Op->Common.Node))); 109 if (ACPI_FAILURE (Status)) 110 { 111 /* Check if we are resolving a named reference within a package */ 112 113 if ((Status == AE_NOT_FOUND) && (AcpiGbl_EnableInterpreterSlack) && 114 115 ((Op->Common.Parent->Common.AmlOpcode == AML_PACKAGE_OP) || 116 (Op->Common.Parent->Common.AmlOpcode == AML_VAR_PACKAGE_OP))) 117 { 118 /* 119 * We didn't find the target and we are populating elements 120 * of a package - ignore if slack enabled. Some ASL code 121 * contains dangling invalid references in packages and 122 * expects that no exception will be issued. Leave the 123 * element as a null element. It cannot be used, but it 124 * can be overwritten by subsequent ASL code - this is 125 * typically the case. 126 */ 127 ACPI_DEBUG_PRINT ((ACPI_DB_INFO, 128 "Ignoring unresolved reference in package [%4.4s]\n", 129 WalkState->ScopeInfo->Scope.Node->Name.Ascii)); 130 131 return_ACPI_STATUS (AE_OK); 132 } 133 else 134 { 135 ACPI_ERROR_NAMESPACE (Op->Common.Value.String, Status); 136 } 137 138 return_ACPI_STATUS (Status); 139 } 140 } 141 142 /* Special object resolution for elements of a package */ 143 144 if ((Op->Common.Parent->Common.AmlOpcode == AML_PACKAGE_OP) || 145 (Op->Common.Parent->Common.AmlOpcode == AML_VAR_PACKAGE_OP)) 146 { 147 /* 148 * Attempt to resolve the node to a value before we insert it into 149 * the package. If this is a reference to a common data type, 150 * resolve it immediately. According to the ACPI spec, package 151 * elements can only be "data objects" or method references. 152 * Attempt to resolve to an Integer, Buffer, String or Package. 153 * If cannot, return the named reference (for things like Devices, 154 * Methods, etc.) Buffer Fields and Fields will resolve to simple 155 * objects (int/buf/str/pkg). 156 * 157 * NOTE: References to things like Devices, Methods, Mutexes, etc. 158 * will remain as named references. This behavior is not described 159 * in the ACPI spec, but it appears to be an oversight. 160 */ 161 ObjDesc = ACPI_CAST_PTR (ACPI_OPERAND_OBJECT, Op->Common.Node); 162 163 Status = AcpiExResolveNodeToValue ( 164 ACPI_CAST_INDIRECT_PTR (ACPI_NAMESPACE_NODE, &ObjDesc), 165 WalkState); 166 if (ACPI_FAILURE (Status)) 167 { 168 return_ACPI_STATUS (Status); 169 } 170 171 /* 172 * Special handling for Alias objects. We need to setup the type 173 * and the Op->Common.Node to point to the Alias target. Note, 174 * Alias has at most one level of indirection internally. 175 */ 176 Type = Op->Common.Node->Type; 177 if (Type == ACPI_TYPE_LOCAL_ALIAS) 178 { 179 Type = ObjDesc->Common.Type; 180 Op->Common.Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, 181 Op->Common.Node->Object); 182 } 183 184 switch (Type) 185 { 186 /* 187 * For these types, we need the actual node, not the subobject. 188 * However, the subobject did not get an extra reference count above. 189 * 190 * TBD: should ExResolveNodeToValue be changed to fix this? 191 */ 192 case ACPI_TYPE_DEVICE: 193 case ACPI_TYPE_THERMAL: 194 195 AcpiUtAddReference (Op->Common.Node->Object); 196 197 /*lint -fallthrough */ 198 /* 199 * For these types, we need the actual node, not the subobject. 200 * The subobject got an extra reference count in ExResolveNodeToValue. 201 */ 202 case ACPI_TYPE_MUTEX: 203 case ACPI_TYPE_METHOD: 204 case ACPI_TYPE_POWER: 205 case ACPI_TYPE_PROCESSOR: 206 case ACPI_TYPE_EVENT: 207 case ACPI_TYPE_REGION: 208 209 /* We will create a reference object for these types below */ 210 break; 211 212 default: 213 /* 214 * All other types - the node was resolved to an actual 215 * object, we are done. 216 */ 217 goto Exit; 218 } 219 } 220 } 221 222 /* Create and init a new internal ACPI object */ 223 224 ObjDesc = AcpiUtCreateInternalObject ( 225 (AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode))->ObjectType); 226 if (!ObjDesc) 227 { 228 return_ACPI_STATUS (AE_NO_MEMORY); 229 } 230 231 Status = AcpiDsInitObjectFromOp ( 232 WalkState, Op, Op->Common.AmlOpcode, &ObjDesc); 233 if (ACPI_FAILURE (Status)) 234 { 235 AcpiUtRemoveReference (ObjDesc); 236 return_ACPI_STATUS (Status); 237 } 238 239 Exit: 240 *ObjDescPtr = ObjDesc; 241 return_ACPI_STATUS (Status); 242 } 243 244 245 /******************************************************************************* 246 * 247 * FUNCTION: AcpiDsBuildInternalBufferObj 248 * 249 * PARAMETERS: WalkState - Current walk state 250 * Op - Parser object to be translated 251 * BufferLength - Length of the buffer 252 * ObjDescPtr - Where the ACPI internal object is returned 253 * 254 * RETURN: Status 255 * 256 * DESCRIPTION: Translate a parser Op package object to the equivalent 257 * namespace object 258 * 259 ******************************************************************************/ 260 261 ACPI_STATUS 262 AcpiDsBuildInternalBufferObj ( 263 ACPI_WALK_STATE *WalkState, 264 ACPI_PARSE_OBJECT *Op, 265 UINT32 BufferLength, 266 ACPI_OPERAND_OBJECT **ObjDescPtr) 267 { 268 ACPI_PARSE_OBJECT *Arg; 269 ACPI_OPERAND_OBJECT *ObjDesc; 270 ACPI_PARSE_OBJECT *ByteList; 271 UINT32 ByteListLength = 0; 272 273 274 ACPI_FUNCTION_TRACE (DsBuildInternalBufferObj); 275 276 277 /* 278 * If we are evaluating a Named buffer object "Name (xxxx, Buffer)". 279 * The buffer object already exists (from the NS node), otherwise it must 280 * be created. 281 */ 282 ObjDesc = *ObjDescPtr; 283 if (!ObjDesc) 284 { 285 /* Create a new buffer object */ 286 287 ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_BUFFER); 288 *ObjDescPtr = ObjDesc; 289 if (!ObjDesc) 290 { 291 return_ACPI_STATUS (AE_NO_MEMORY); 292 } 293 } 294 295 /* 296 * Second arg is the buffer data (optional) ByteList can be either 297 * individual bytes or a string initializer. In either case, a 298 * ByteList appears in the AML. 299 */ 300 Arg = Op->Common.Value.Arg; /* skip first arg */ 301 302 ByteList = Arg->Named.Next; 303 if (ByteList) 304 { 305 if (ByteList->Common.AmlOpcode != AML_INT_BYTELIST_OP) 306 { 307 ACPI_ERROR ((AE_INFO, 308 "Expecting bytelist, found AML opcode 0x%X in op %p", 309 ByteList->Common.AmlOpcode, ByteList)); 310 311 AcpiUtRemoveReference (ObjDesc); 312 return (AE_TYPE); 313 } 314 315 ByteListLength = (UINT32) ByteList->Common.Value.Integer; 316 } 317 318 /* 319 * The buffer length (number of bytes) will be the larger of: 320 * 1) The specified buffer length and 321 * 2) The length of the initializer byte list 322 */ 323 ObjDesc->Buffer.Length = BufferLength; 324 if (ByteListLength > BufferLength) 325 { 326 ObjDesc->Buffer.Length = ByteListLength; 327 } 328 329 /* Allocate the buffer */ 330 331 if (ObjDesc->Buffer.Length == 0) 332 { 333 ObjDesc->Buffer.Pointer = NULL; 334 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, 335 "Buffer defined with zero length in AML, creating\n")); 336 } 337 else 338 { 339 ObjDesc->Buffer.Pointer = 340 ACPI_ALLOCATE_ZEROED (ObjDesc->Buffer.Length); 341 if (!ObjDesc->Buffer.Pointer) 342 { 343 AcpiUtDeleteObjectDesc (ObjDesc); 344 return_ACPI_STATUS (AE_NO_MEMORY); 345 } 346 347 /* Initialize buffer from the ByteList (if present) */ 348 349 if (ByteList) 350 { 351 memcpy (ObjDesc->Buffer.Pointer, ByteList->Named.Data, 352 ByteListLength); 353 } 354 } 355 356 ObjDesc->Buffer.Flags |= AOPOBJ_DATA_VALID; 357 Op->Common.Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, ObjDesc); 358 return_ACPI_STATUS (AE_OK); 359 } 360 361 362 /******************************************************************************* 363 * 364 * FUNCTION: AcpiDsBuildInternalPackageObj 365 * 366 * PARAMETERS: WalkState - Current walk state 367 * Op - Parser object to be translated 368 * ElementCount - Number of elements in the package - this is 369 * the NumElements argument to Package() 370 * ObjDescPtr - Where the ACPI internal object is returned 371 * 372 * RETURN: Status 373 * 374 * DESCRIPTION: Translate a parser Op package object to the equivalent 375 * namespace object 376 * 377 * NOTE: The number of elements in the package will be always be the NumElements 378 * count, regardless of the number of elements in the package list. If 379 * NumElements is smaller, only that many package list elements are used. 380 * if NumElements is larger, the Package object is padded out with 381 * objects of type Uninitialized (as per ACPI spec.) 382 * 383 * Even though the ASL compilers do not allow NumElements to be smaller 384 * than the Package list length (for the fixed length package opcode), some 385 * BIOS code modifies the AML on the fly to adjust the NumElements, and 386 * this code compensates for that. This also provides compatibility with 387 * other AML interpreters. 388 * 389 ******************************************************************************/ 390 391 ACPI_STATUS 392 AcpiDsBuildInternalPackageObj ( 393 ACPI_WALK_STATE *WalkState, 394 ACPI_PARSE_OBJECT *Op, 395 UINT32 ElementCount, 396 ACPI_OPERAND_OBJECT **ObjDescPtr) 397 { 398 ACPI_PARSE_OBJECT *Arg; 399 ACPI_PARSE_OBJECT *Parent; 400 ACPI_OPERAND_OBJECT *ObjDesc = NULL; 401 ACPI_STATUS Status = AE_OK; 402 UINT32 i; 403 UINT16 Index; 404 UINT16 ReferenceCount; 405 406 407 ACPI_FUNCTION_TRACE (DsBuildInternalPackageObj); 408 409 410 /* Find the parent of a possibly nested package */ 411 412 Parent = Op->Common.Parent; 413 while ((Parent->Common.AmlOpcode == AML_PACKAGE_OP) || 414 (Parent->Common.AmlOpcode == AML_VAR_PACKAGE_OP)) 415 { 416 Parent = Parent->Common.Parent; 417 } 418 419 /* 420 * If we are evaluating a Named package object "Name (xxxx, Package)", 421 * the package object already exists, otherwise it must be created. 422 */ 423 ObjDesc = *ObjDescPtr; 424 if (!ObjDesc) 425 { 426 ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_PACKAGE); 427 *ObjDescPtr = ObjDesc; 428 if (!ObjDesc) 429 { 430 return_ACPI_STATUS (AE_NO_MEMORY); 431 } 432 433 ObjDesc->Package.Node = Parent->Common.Node; 434 } 435 436 /* 437 * Allocate the element array (array of pointers to the individual 438 * objects) based on the NumElements parameter. Add an extra pointer slot 439 * so that the list is always null terminated. 440 */ 441 ObjDesc->Package.Elements = ACPI_ALLOCATE_ZEROED ( 442 ((ACPI_SIZE) ElementCount + 1) * sizeof (void *)); 443 444 if (!ObjDesc->Package.Elements) 445 { 446 AcpiUtDeleteObjectDesc (ObjDesc); 447 return_ACPI_STATUS (AE_NO_MEMORY); 448 } 449 450 ObjDesc->Package.Count = ElementCount; 451 452 /* 453 * Initialize the elements of the package, up to the NumElements count. 454 * Package is automatically padded with uninitialized (NULL) elements 455 * if NumElements is greater than the package list length. Likewise, 456 * Package is truncated if NumElements is less than the list length. 457 */ 458 Arg = Op->Common.Value.Arg; 459 Arg = Arg->Common.Next; 460 for (i = 0; Arg && (i < ElementCount); i++) 461 { 462 if (Arg->Common.AmlOpcode == AML_INT_RETURN_VALUE_OP) 463 { 464 if (Arg->Common.Node->Type == ACPI_TYPE_METHOD) 465 { 466 /* 467 * A method reference "looks" to the parser to be a method 468 * invocation, so we special case it here 469 */ 470 Arg->Common.AmlOpcode = AML_INT_NAMEPATH_OP; 471 Status = AcpiDsBuildInternalObject ( 472 WalkState, Arg, &ObjDesc->Package.Elements[i]); 473 } 474 else 475 { 476 /* This package element is already built, just get it */ 477 478 ObjDesc->Package.Elements[i] = 479 ACPI_CAST_PTR (ACPI_OPERAND_OBJECT, Arg->Common.Node); 480 } 481 } 482 else 483 { 484 Status = AcpiDsBuildInternalObject ( 485 WalkState, Arg, &ObjDesc->Package.Elements[i]); 486 } 487 488 if (*ObjDescPtr) 489 { 490 /* Existing package, get existing reference count */ 491 492 ReferenceCount = (*ObjDescPtr)->Common.ReferenceCount; 493 if (ReferenceCount > 1) 494 { 495 /* Make new element ref count match original ref count */ 496 497 for (Index = 0; Index < (ReferenceCount - 1); Index++) 498 { 499 AcpiUtAddReference ((ObjDesc->Package.Elements[i])); 500 } 501 } 502 } 503 504 Arg = Arg->Common.Next; 505 } 506 507 /* Check for match between NumElements and actual length of PackageList */ 508 509 if (Arg) 510 { 511 /* 512 * NumElements was exhausted, but there are remaining elements in the 513 * PackageList. Truncate the package to NumElements. 514 * 515 * Note: technically, this is an error, from ACPI spec: "It is an error 516 * for NumElements to be less than the number of elements in the 517 * PackageList". However, we just print a message and 518 * no exception is returned. This provides Windows compatibility. Some 519 * BIOSs will alter the NumElements on the fly, creating this type 520 * of ill-formed package object. 521 */ 522 while (Arg) 523 { 524 /* 525 * We must delete any package elements that were created earlier 526 * and are not going to be used because of the package truncation. 527 */ 528 if (Arg->Common.Node) 529 { 530 AcpiUtRemoveReference ( 531 ACPI_CAST_PTR (ACPI_OPERAND_OBJECT, Arg->Common.Node)); 532 Arg->Common.Node = NULL; 533 } 534 535 /* Find out how many elements there really are */ 536 537 i++; 538 Arg = Arg->Common.Next; 539 } 540 541 ACPI_INFO (( 542 "Actual Package length (%u) is larger than " 543 "NumElements field (%u), truncated", 544 i, ElementCount)); 545 } 546 else if (i < ElementCount) 547 { 548 /* 549 * Arg list (elements) was exhausted, but we did not reach NumElements count. 550 * Note: this is not an error, the package is padded out with NULLs. 551 */ 552 ACPI_DEBUG_PRINT ((ACPI_DB_INFO, 553 "Package List length (%u) smaller than NumElements " 554 "count (%u), padded with null elements\n", 555 i, ElementCount)); 556 } 557 558 ObjDesc->Package.Flags |= AOPOBJ_DATA_VALID; 559 Op->Common.Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, ObjDesc); 560 return_ACPI_STATUS (Status); 561 } 562 563 564 /******************************************************************************* 565 * 566 * FUNCTION: AcpiDsCreateNode 567 * 568 * PARAMETERS: WalkState - Current walk state 569 * Node - NS Node to be initialized 570 * Op - Parser object to be translated 571 * 572 * RETURN: Status 573 * 574 * DESCRIPTION: Create the object to be associated with a namespace node 575 * 576 ******************************************************************************/ 577 578 ACPI_STATUS 579 AcpiDsCreateNode ( 580 ACPI_WALK_STATE *WalkState, 581 ACPI_NAMESPACE_NODE *Node, 582 ACPI_PARSE_OBJECT *Op) 583 { 584 ACPI_STATUS Status; 585 ACPI_OPERAND_OBJECT *ObjDesc; 586 587 588 ACPI_FUNCTION_TRACE_PTR (DsCreateNode, Op); 589 590 591 /* 592 * Because of the execution pass through the non-control-method 593 * parts of the table, we can arrive here twice. Only init 594 * the named object node the first time through 595 */ 596 if (AcpiNsGetAttachedObject (Node)) 597 { 598 return_ACPI_STATUS (AE_OK); 599 } 600 601 if (!Op->Common.Value.Arg) 602 { 603 /* No arguments, there is nothing to do */ 604 605 return_ACPI_STATUS (AE_OK); 606 } 607 608 /* Build an internal object for the argument(s) */ 609 610 Status = AcpiDsBuildInternalObject ( 611 WalkState, Op->Common.Value.Arg, &ObjDesc); 612 if (ACPI_FAILURE (Status)) 613 { 614 return_ACPI_STATUS (Status); 615 } 616 617 /* Re-type the object according to its argument */ 618 619 Node->Type = ObjDesc->Common.Type; 620 621 /* Attach obj to node */ 622 623 Status = AcpiNsAttachObject (Node, ObjDesc, Node->Type); 624 625 /* Remove local reference to the object */ 626 627 AcpiUtRemoveReference (ObjDesc); 628 return_ACPI_STATUS (Status); 629 } 630 631 #endif /* ACPI_NO_METHOD_EXECUTION */ 632 633 634 /******************************************************************************* 635 * 636 * FUNCTION: AcpiDsInitObjectFromOp 637 * 638 * PARAMETERS: WalkState - Current walk state 639 * Op - Parser op used to init the internal object 640 * Opcode - AML opcode associated with the object 641 * RetObjDesc - Namespace object to be initialized 642 * 643 * RETURN: Status 644 * 645 * DESCRIPTION: Initialize a namespace object from a parser Op and its 646 * associated arguments. The namespace object is a more compact 647 * representation of the Op and its arguments. 648 * 649 ******************************************************************************/ 650 651 ACPI_STATUS 652 AcpiDsInitObjectFromOp ( 653 ACPI_WALK_STATE *WalkState, 654 ACPI_PARSE_OBJECT *Op, 655 UINT16 Opcode, 656 ACPI_OPERAND_OBJECT **RetObjDesc) 657 { 658 const ACPI_OPCODE_INFO *OpInfo; 659 ACPI_OPERAND_OBJECT *ObjDesc; 660 ACPI_STATUS Status = AE_OK; 661 662 663 ACPI_FUNCTION_TRACE (DsInitObjectFromOp); 664 665 666 ObjDesc = *RetObjDesc; 667 OpInfo = AcpiPsGetOpcodeInfo (Opcode); 668 if (OpInfo->Class == AML_CLASS_UNKNOWN) 669 { 670 /* Unknown opcode */ 671 672 return_ACPI_STATUS (AE_TYPE); 673 } 674 675 /* Perform per-object initialization */ 676 677 switch (ObjDesc->Common.Type) 678 { 679 case ACPI_TYPE_BUFFER: 680 /* 681 * Defer evaluation of Buffer TermArg operand 682 */ 683 ObjDesc->Buffer.Node = ACPI_CAST_PTR ( 684 ACPI_NAMESPACE_NODE, WalkState->Operands[0]); 685 ObjDesc->Buffer.AmlStart = Op->Named.Data; 686 ObjDesc->Buffer.AmlLength = Op->Named.Length; 687 break; 688 689 case ACPI_TYPE_PACKAGE: 690 /* 691 * Defer evaluation of Package TermArg operand 692 */ 693 ObjDesc->Package.Node = ACPI_CAST_PTR ( 694 ACPI_NAMESPACE_NODE, WalkState->Operands[0]); 695 ObjDesc->Package.AmlStart = Op->Named.Data; 696 ObjDesc->Package.AmlLength = Op->Named.Length; 697 break; 698 699 case ACPI_TYPE_INTEGER: 700 701 switch (OpInfo->Type) 702 { 703 case AML_TYPE_CONSTANT: 704 /* 705 * Resolve AML Constants here - AND ONLY HERE! 706 * All constants are integers. 707 * We mark the integer with a flag that indicates that it started 708 * life as a constant -- so that stores to constants will perform 709 * as expected (noop). ZeroOp is used as a placeholder for optional 710 * target operands. 711 */ 712 ObjDesc->Common.Flags = AOPOBJ_AML_CONSTANT; 713 714 switch (Opcode) 715 { 716 case AML_ZERO_OP: 717 718 ObjDesc->Integer.Value = 0; 719 break; 720 721 case AML_ONE_OP: 722 723 ObjDesc->Integer.Value = 1; 724 break; 725 726 case AML_ONES_OP: 727 728 ObjDesc->Integer.Value = ACPI_UINT64_MAX; 729 730 /* Truncate value if we are executing from a 32-bit ACPI table */ 731 732 #ifndef ACPI_NO_METHOD_EXECUTION 733 (void) AcpiExTruncateFor32bitTable (ObjDesc); 734 #endif 735 break; 736 737 case AML_REVISION_OP: 738 739 ObjDesc->Integer.Value = ACPI_CA_VERSION; 740 break; 741 742 default: 743 744 ACPI_ERROR ((AE_INFO, 745 "Unknown constant opcode 0x%X", Opcode)); 746 Status = AE_AML_OPERAND_TYPE; 747 break; 748 } 749 break; 750 751 case AML_TYPE_LITERAL: 752 753 ObjDesc->Integer.Value = Op->Common.Value.Integer; 754 755 #ifndef ACPI_NO_METHOD_EXECUTION 756 if (AcpiExTruncateFor32bitTable (ObjDesc)) 757 { 758 /* Warn if we found a 64-bit constant in a 32-bit table */ 759 760 ACPI_WARNING ((AE_INFO, 761 "Truncated 64-bit constant found in 32-bit table: %8.8X%8.8X => %8.8X", 762 ACPI_FORMAT_UINT64 (Op->Common.Value.Integer), 763 (UINT32) ObjDesc->Integer.Value)); 764 } 765 #endif 766 break; 767 768 default: 769 770 ACPI_ERROR ((AE_INFO, "Unknown Integer type 0x%X", 771 OpInfo->Type)); 772 Status = AE_AML_OPERAND_TYPE; 773 break; 774 } 775 break; 776 777 case ACPI_TYPE_STRING: 778 779 ObjDesc->String.Pointer = Op->Common.Value.String; 780 ObjDesc->String.Length = (UINT32) strlen (Op->Common.Value.String); 781 782 /* 783 * The string is contained in the ACPI table, don't ever try 784 * to delete it 785 */ 786 ObjDesc->Common.Flags |= AOPOBJ_STATIC_POINTER; 787 break; 788 789 case ACPI_TYPE_METHOD: 790 break; 791 792 case ACPI_TYPE_LOCAL_REFERENCE: 793 794 switch (OpInfo->Type) 795 { 796 case AML_TYPE_LOCAL_VARIABLE: 797 798 /* Local ID (0-7) is (AML opcode - base AML_LOCAL_OP) */ 799 800 ObjDesc->Reference.Value = ((UINT32) Opcode) - AML_LOCAL_OP; 801 ObjDesc->Reference.Class = ACPI_REFCLASS_LOCAL; 802 803 #ifndef ACPI_NO_METHOD_EXECUTION 804 Status = AcpiDsMethodDataGetNode (ACPI_REFCLASS_LOCAL, 805 ObjDesc->Reference.Value, WalkState, 806 ACPI_CAST_INDIRECT_PTR (ACPI_NAMESPACE_NODE, 807 &ObjDesc->Reference.Object)); 808 #endif 809 break; 810 811 case AML_TYPE_METHOD_ARGUMENT: 812 813 /* Arg ID (0-6) is (AML opcode - base AML_ARG_OP) */ 814 815 ObjDesc->Reference.Value = ((UINT32) Opcode) - AML_ARG_OP; 816 ObjDesc->Reference.Class = ACPI_REFCLASS_ARG; 817 818 #ifndef ACPI_NO_METHOD_EXECUTION 819 Status = AcpiDsMethodDataGetNode (ACPI_REFCLASS_ARG, 820 ObjDesc->Reference.Value, WalkState, 821 ACPI_CAST_INDIRECT_PTR (ACPI_NAMESPACE_NODE, 822 &ObjDesc->Reference.Object)); 823 #endif 824 break; 825 826 default: /* Object name or Debug object */ 827 828 switch (Op->Common.AmlOpcode) 829 { 830 case AML_INT_NAMEPATH_OP: 831 832 /* Node was saved in Op */ 833 834 ObjDesc->Reference.Node = Op->Common.Node; 835 ObjDesc->Reference.Object = Op->Common.Node->Object; 836 ObjDesc->Reference.Class = ACPI_REFCLASS_NAME; 837 break; 838 839 case AML_DEBUG_OP: 840 841 ObjDesc->Reference.Class = ACPI_REFCLASS_DEBUG; 842 break; 843 844 default: 845 846 ACPI_ERROR ((AE_INFO, 847 "Unimplemented reference type for AML opcode: 0x%4.4X", Opcode)); 848 return_ACPI_STATUS (AE_AML_OPERAND_TYPE); 849 } 850 break; 851 } 852 break; 853 854 default: 855 856 ACPI_ERROR ((AE_INFO, "Unimplemented data type: 0x%X", 857 ObjDesc->Common.Type)); 858 859 Status = AE_AML_OPERAND_TYPE; 860 break; 861 } 862 863 return_ACPI_STATUS (Status); 864 } 865