1 2 /****************************************************************************** 3 * 4 * Module Name: asloperands - AML operand processing 5 * 6 *****************************************************************************/ 7 8 /****************************************************************************** 9 * 10 * 1. Copyright Notice 11 * 12 * Some or all of this work - Copyright (c) 1999 - 2009, Intel Corp. 13 * All rights reserved. 14 * 15 * 2. License 16 * 17 * 2.1. This is your license from Intel Corp. under its intellectual property 18 * rights. You may have additional license terms from the party that provided 19 * you this software, covering your right to use that party's intellectual 20 * property rights. 21 * 22 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a 23 * copy of the source code appearing in this file ("Covered Code") an 24 * irrevocable, perpetual, worldwide license under Intel's copyrights in the 25 * base code distributed originally by Intel ("Original Intel Code") to copy, 26 * make derivatives, distribute, use and display any portion of the Covered 27 * Code in any form, with the right to sublicense such rights; and 28 * 29 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent 30 * license (with the right to sublicense), under only those claims of Intel 31 * patents that are infringed by the Original Intel Code, to make, use, sell, 32 * offer to sell, and import the Covered Code and derivative works thereof 33 * solely to the minimum extent necessary to exercise the above copyright 34 * license, and in no event shall the patent license extend to any additions 35 * to or modifications of the Original Intel Code. No other license or right 36 * is granted directly or by implication, estoppel or otherwise; 37 * 38 * The above copyright and patent license is granted only if the following 39 * conditions are met: 40 * 41 * 3. Conditions 42 * 43 * 3.1. Redistribution of Source with Rights to Further Distribute Source. 44 * Redistribution of source code of any substantial portion of the Covered 45 * Code or modification with rights to further distribute source must include 46 * the above Copyright Notice, the above License, this list of Conditions, 47 * and the following Disclaimer and Export Compliance provision. In addition, 48 * Licensee must cause all Covered Code to which Licensee contributes to 49 * contain a file documenting the changes Licensee made to create that Covered 50 * Code and the date of any change. Licensee must include in that file the 51 * documentation of any changes made by any predecessor Licensee. Licensee 52 * must include a prominent statement that the modification is derived, 53 * directly or indirectly, from Original Intel Code. 54 * 55 * 3.2. Redistribution of Source with no Rights to Further Distribute Source. 56 * Redistribution of source code of any substantial portion of the Covered 57 * Code or modification without rights to further distribute source must 58 * include the following Disclaimer and Export Compliance provision in the 59 * documentation and/or other materials provided with distribution. In 60 * addition, Licensee may not authorize further sublicense of source of any 61 * portion of the Covered Code, and must include terms to the effect that the 62 * license from Licensee to its licensee is limited to the intellectual 63 * property embodied in the software Licensee provides to its licensee, and 64 * not to intellectual property embodied in modifications its licensee may 65 * make. 66 * 67 * 3.3. Redistribution of Executable. Redistribution in executable form of any 68 * substantial portion of the Covered Code or modification must reproduce the 69 * above Copyright Notice, and the following Disclaimer and Export Compliance 70 * provision in the documentation and/or other materials provided with the 71 * distribution. 72 * 73 * 3.4. Intel retains all right, title, and interest in and to the Original 74 * Intel Code. 75 * 76 * 3.5. Neither the name Intel nor any other trademark owned or controlled by 77 * Intel shall be used in advertising or otherwise to promote the sale, use or 78 * other dealings in products derived from or relating to the Covered Code 79 * without prior written authorization from Intel. 80 * 81 * 4. Disclaimer and Export Compliance 82 * 83 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED 84 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE 85 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, 86 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY 87 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY 88 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A 89 * PARTICULAR PURPOSE. 90 * 91 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES 92 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR 93 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, 94 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY 95 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL 96 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS 97 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY 98 * LIMITED REMEDY. 99 * 100 * 4.3. Licensee shall not export, either directly or indirectly, any of this 101 * software or system incorporating such software without first obtaining any 102 * required license or other approval from the U. S. Department of Commerce or 103 * any other agency or department of the United States Government. In the 104 * event Licensee exports any such software from the United States or 105 * re-exports any such software from a foreign destination, Licensee shall 106 * ensure that the distribution and export/re-export of the software is in 107 * compliance with all laws, regulations, orders, or other restrictions of the 108 * U.S. Export Administration Regulations. Licensee agrees that neither it nor 109 * any of its subsidiaries will export/re-export any technical data, process, 110 * software, or service, directly or indirectly, to any country for which the 111 * United States government or any agency thereof requires an export license, 112 * other governmental approval, or letter of assurance, without first obtaining 113 * such license, approval or letter. 114 * 115 *****************************************************************************/ 116 117 118 #include <contrib/dev/acpica/compiler/aslcompiler.h> 119 #include "aslcompiler.y.h" 120 #include <contrib/dev/acpica/include/amlcode.h> 121 122 #define _COMPONENT ACPI_COMPILER 123 ACPI_MODULE_NAME ("asloperands") 124 125 /* Local prototypes */ 126 127 static void 128 OpnDoField ( 129 ACPI_PARSE_OBJECT *Op); 130 131 static void 132 OpnDoBankField ( 133 ACPI_PARSE_OBJECT *Op); 134 135 static void 136 OpnDoBuffer ( 137 ACPI_PARSE_OBJECT *Op); 138 139 static void 140 OpnDoDefinitionBlock ( 141 ACPI_PARSE_OBJECT *Op); 142 143 static void 144 OpnDoFieldCommon ( 145 ACPI_PARSE_OBJECT *FieldOp, 146 ACPI_PARSE_OBJECT *Op); 147 148 static void 149 OpnDoIndexField ( 150 ACPI_PARSE_OBJECT *Op); 151 152 static void 153 OpnDoLoadTable ( 154 ACPI_PARSE_OBJECT *Op); 155 156 static void 157 OpnDoMethod ( 158 ACPI_PARSE_OBJECT *Op); 159 160 static void 161 OpnDoMutex ( 162 ACPI_PARSE_OBJECT *Op); 163 164 static void 165 OpnDoRegion ( 166 ACPI_PARSE_OBJECT *Op); 167 168 static void 169 OpnAttachNameToNode ( 170 ACPI_PARSE_OBJECT *Op); 171 172 173 /******************************************************************************* 174 * 175 * FUNCTION: OpnDoMutex 176 * 177 * PARAMETERS: Op - The parent parse node 178 * 179 * RETURN: None 180 * 181 * DESCRIPTION: Construct the operands for the MUTEX ASL keyword. 182 * 183 ******************************************************************************/ 184 185 static void 186 OpnDoMutex ( 187 ACPI_PARSE_OBJECT *Op) 188 { 189 ACPI_PARSE_OBJECT *Next; 190 191 192 Next = Op->Asl.Child; 193 Next = Next->Asl.Next; 194 195 if (Next->Asl.Value.Integer > 15) 196 { 197 AslError (ASL_ERROR, ASL_MSG_SYNC_LEVEL, Next, NULL); 198 } 199 return; 200 } 201 202 203 /******************************************************************************* 204 * 205 * FUNCTION: OpnDoMethod 206 * 207 * PARAMETERS: Op - The parent parse node 208 * 209 * RETURN: None 210 * 211 * DESCRIPTION: Construct the operands for the METHOD ASL keyword. 212 * 213 ******************************************************************************/ 214 215 static void 216 OpnDoMethod ( 217 ACPI_PARSE_OBJECT *Op) 218 { 219 ACPI_PARSE_OBJECT *Next; 220 221 /* Optional arguments for this opcode with defaults */ 222 223 UINT8 NumArgs = 0; 224 UINT8 Serialized = 0; 225 UINT8 Concurrency = 0; 226 UINT8 MethodFlags; 227 228 229 /* Opcode and package length first */ 230 /* Method name */ 231 232 Next = Op->Asl.Child; 233 234 /* Num args */ 235 236 Next = Next->Asl.Next; 237 if (Next->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 238 { 239 NumArgs = (UINT8) Next->Asl.Value.Integer; 240 Next->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG; 241 } 242 243 /* Serialized Flag */ 244 245 Next = Next->Asl.Next; 246 if (Next->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 247 { 248 Serialized = (UINT8) Next->Asl.Value.Integer; 249 Next->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG; 250 } 251 252 /* Concurrency value (valid values are 0-15) */ 253 254 Next = Next->Asl.Next; 255 if (Next->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 256 { 257 if (Next->Asl.Value.Integer > 15) 258 { 259 AslError (ASL_ERROR, ASL_MSG_SYNC_LEVEL, Next, NULL); 260 } 261 Concurrency = (UINT8) Next->Asl.Value.Integer; 262 } 263 264 /* Put the bits in their proper places */ 265 266 MethodFlags = (UINT8) ((NumArgs & 0x7) | 267 ((Serialized & 0x1) << 3) | 268 ((Concurrency & 0xF) << 4)); 269 270 /* Use the last node for the combined flags byte */ 271 272 Next->Asl.Value.Integer = MethodFlags; 273 Next->Asl.AmlOpcode = AML_RAW_DATA_BYTE; 274 Next->Asl.AmlLength = 1; 275 Next->Asl.ParseOpcode = PARSEOP_RAW_DATA; 276 277 /* Save the arg count in the first node */ 278 279 Op->Asl.Extra = NumArgs; 280 } 281 282 283 /******************************************************************************* 284 * 285 * FUNCTION: OpnDoFieldCommon 286 * 287 * PARAMETERS: FieldOp - Node for an ASL field 288 * Op - The parent parse node 289 * 290 * RETURN: None 291 * 292 * DESCRIPTION: Construct the AML operands for the various field keywords, 293 * FIELD, BANKFIELD, INDEXFIELD 294 * 295 ******************************************************************************/ 296 297 static void 298 OpnDoFieldCommon ( 299 ACPI_PARSE_OBJECT *FieldOp, 300 ACPI_PARSE_OBJECT *Op) 301 { 302 ACPI_PARSE_OBJECT *Next; 303 ACPI_PARSE_OBJECT *PkgLengthNode; 304 UINT32 CurrentBitOffset; 305 UINT32 NewBitOffset; 306 UINT8 AccessType; 307 UINT8 LockRule; 308 UINT8 UpdateRule; 309 UINT8 FieldFlags; 310 UINT32 MinimumLength; 311 312 313 /* AccessType -- not optional, so no need to check for DEFAULT_ARG */ 314 315 AccessType = (UINT8) Op->Asl.Value.Integer; 316 Op->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG; 317 318 /* Set the access type in the parent (field) node for use later */ 319 320 FieldOp->Asl.Value.Integer = AccessType; 321 322 /* LockRule -- not optional, so no need to check for DEFAULT_ARG */ 323 324 Next = Op->Asl.Next; 325 LockRule = (UINT8) Next->Asl.Value.Integer; 326 Next->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG; 327 328 /* UpdateRule -- not optional, so no need to check for DEFAULT_ARG */ 329 330 Next = Next->Asl.Next; 331 UpdateRule = (UINT8) Next->Asl.Value.Integer; 332 333 /* 334 * Generate the flags byte. The various fields are already 335 * in the right bit position via translation from the 336 * keywords by the parser. 337 */ 338 FieldFlags = (UINT8) (AccessType | LockRule | UpdateRule); 339 340 /* Use the previous node to be the FieldFlags node */ 341 342 /* Set the node to RAW_DATA */ 343 344 Next->Asl.Value.Integer = FieldFlags; 345 Next->Asl.AmlOpcode = AML_RAW_DATA_BYTE; 346 Next->Asl.AmlLength = 1; 347 Next->Asl.ParseOpcode = PARSEOP_RAW_DATA; 348 349 /* Process the FieldUnitList */ 350 351 Next = Next->Asl.Next; 352 CurrentBitOffset = 0; 353 354 while (Next) 355 { 356 /* Save the offset of this field unit */ 357 358 Next->Asl.ExtraValue = CurrentBitOffset; 359 360 switch (Next->Asl.ParseOpcode) 361 { 362 case PARSEOP_ACCESSAS: 363 364 PkgLengthNode = Next->Asl.Child; 365 AccessType = (UINT8) PkgLengthNode->Asl.Value.Integer; 366 367 /* Nothing additional to do */ 368 break; 369 370 371 case PARSEOP_OFFSET: 372 373 /* New offset into the field */ 374 375 PkgLengthNode = Next->Asl.Child; 376 NewBitOffset = ((UINT32) PkgLengthNode->Asl.Value.Integer) * 8; 377 378 /* 379 * Examine the specified offset in relation to the 380 * current offset counter. 381 */ 382 if (NewBitOffset < CurrentBitOffset) 383 { 384 /* 385 * Not allowed to specify a backwards offset! 386 * Issue error and ignore this node. 387 */ 388 AslError (ASL_ERROR, ASL_MSG_BACKWARDS_OFFSET, PkgLengthNode, 389 NULL); 390 Next->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG; 391 PkgLengthNode->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG; 392 } 393 else if (NewBitOffset == CurrentBitOffset) 394 { 395 /* 396 * Offset is redundant; we don't need to output an 397 * offset opcode. Just set these nodes to default 398 */ 399 Next->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG; 400 PkgLengthNode->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG; 401 } 402 else 403 { 404 /* 405 * Valid new offset - set the value to be inserted into the AML 406 * and update the offset counter. 407 */ 408 PkgLengthNode->Asl.Value.Integer = 409 NewBitOffset - CurrentBitOffset; 410 CurrentBitOffset = NewBitOffset; 411 } 412 break; 413 414 415 case PARSEOP_NAMESEG: 416 case PARSEOP_RESERVED_BYTES: 417 418 /* Named or reserved field entry */ 419 420 PkgLengthNode = Next->Asl.Child; 421 NewBitOffset = (UINT32) PkgLengthNode->Asl.Value.Integer; 422 CurrentBitOffset += NewBitOffset; 423 424 /* Save the current AccessAs value for error checking later */ 425 426 switch (AccessType) 427 { 428 case AML_FIELD_ACCESS_ANY: 429 case AML_FIELD_ACCESS_BYTE: 430 case AML_FIELD_ACCESS_BUFFER: 431 default: 432 MinimumLength = 8; 433 break; 434 435 case AML_FIELD_ACCESS_WORD: 436 MinimumLength = 16; 437 break; 438 439 case AML_FIELD_ACCESS_DWORD: 440 MinimumLength = 32; 441 break; 442 443 case AML_FIELD_ACCESS_QWORD: 444 MinimumLength = 64; 445 break; 446 } 447 448 PkgLengthNode->Asl.ExtraValue = MinimumLength; 449 break; 450 451 default: 452 /* All supported field opcodes must appear above */ 453 break; 454 } 455 456 /* Move on to next entry in the field list */ 457 458 Next = Next->Asl.Next; 459 } 460 } 461 462 463 /******************************************************************************* 464 * 465 * FUNCTION: OpnDoField 466 * 467 * PARAMETERS: Op - The parent parse node 468 * 469 * RETURN: None 470 * 471 * DESCRIPTION: Construct the AML operands for the FIELD ASL keyword 472 * 473 ******************************************************************************/ 474 475 static void 476 OpnDoField ( 477 ACPI_PARSE_OBJECT *Op) 478 { 479 ACPI_PARSE_OBJECT *Next; 480 481 482 /* Opcode is parent node */ 483 /* First child is field name */ 484 485 Next = Op->Asl.Child; 486 487 /* Second child is the AccessType */ 488 489 OpnDoFieldCommon (Op, Next->Asl.Next); 490 } 491 492 493 /******************************************************************************* 494 * 495 * FUNCTION: OpnDoIndexField 496 * 497 * PARAMETERS: Op - The parent parse node 498 * 499 * RETURN: None 500 * 501 * DESCRIPTION: Construct the AML operands for the INDEXFIELD ASL keyword 502 * 503 ******************************************************************************/ 504 505 static void 506 OpnDoIndexField ( 507 ACPI_PARSE_OBJECT *Op) 508 { 509 ACPI_PARSE_OBJECT *Next; 510 511 512 /* Opcode is parent node */ 513 /* First child is the index name */ 514 515 Next = Op->Asl.Child; 516 517 /* Second child is the data name */ 518 519 Next = Next->Asl.Next; 520 521 /* Third child is the AccessType */ 522 523 OpnDoFieldCommon (Op, Next->Asl.Next); 524 } 525 526 527 /******************************************************************************* 528 * 529 * FUNCTION: OpnDoBankField 530 * 531 * PARAMETERS: Op - The parent parse node 532 * 533 * RETURN: None 534 * 535 * DESCRIPTION: Construct the AML operands for the BANKFIELD ASL keyword 536 * 537 ******************************************************************************/ 538 539 static void 540 OpnDoBankField ( 541 ACPI_PARSE_OBJECT *Op) 542 { 543 ACPI_PARSE_OBJECT *Next; 544 545 546 /* Opcode is parent node */ 547 /* First child is the region name */ 548 549 Next = Op->Asl.Child; 550 551 /* Second child is the bank name */ 552 553 Next = Next->Asl.Next; 554 555 /* Third child is the bank value */ 556 557 Next = Next->Asl.Next; 558 559 /* Fourth child is the AccessType */ 560 561 OpnDoFieldCommon (Op, Next->Asl.Next); 562 } 563 564 565 /******************************************************************************* 566 * 567 * FUNCTION: OpnDoRegion 568 * 569 * PARAMETERS: Op - The parent parse node 570 * 571 * RETURN: None 572 * 573 * DESCRIPTION: Tries to get the length of the region. Can only do this at 574 * compile time if the length is a constant. 575 * 576 ******************************************************************************/ 577 578 static void 579 OpnDoRegion ( 580 ACPI_PARSE_OBJECT *Op) 581 { 582 ACPI_PARSE_OBJECT *Next; 583 584 585 /* Opcode is parent node */ 586 /* First child is the region name */ 587 588 Next = Op->Asl.Child; 589 590 /* Second child is the space ID*/ 591 592 Next = Next->Asl.Next; 593 594 /* Third child is the region offset */ 595 596 Next = Next->Asl.Next; 597 598 /* Fourth child is the region length */ 599 600 Next = Next->Asl.Next; 601 if (Next->Asl.ParseOpcode == PARSEOP_INTEGER) 602 { 603 Op->Asl.Value.Integer = Next->Asl.Value.Integer; 604 } 605 else 606 { 607 Op->Asl.Value.Integer = ACPI_INTEGER_MAX; 608 } 609 } 610 611 612 /******************************************************************************* 613 * 614 * FUNCTION: OpnDoBuffer 615 * 616 * PARAMETERS: Op - The parent parse node 617 * 618 * RETURN: None 619 * 620 * DESCRIPTION: Construct the AML operands for the BUFFER ASL keyword. We 621 * build a single raw byte buffer from the initialization nodes, 622 * each parse node contains a buffer byte. 623 * 624 ******************************************************************************/ 625 626 static void 627 OpnDoBuffer ( 628 ACPI_PARSE_OBJECT *Op) 629 { 630 ACPI_PARSE_OBJECT *InitializerOp; 631 ACPI_PARSE_OBJECT *BufferLengthOp; 632 633 /* Optional arguments for this opcode with defaults */ 634 635 UINT32 BufferLength = 0; 636 637 638 /* Opcode and package length first */ 639 /* Buffer Length is next, followed by the initializer list */ 640 641 BufferLengthOp = Op->Asl.Child; 642 InitializerOp = BufferLengthOp->Asl.Next; 643 644 /* 645 * If the BufferLength is not an INTEGER or was not specified in the ASL 646 * (DEFAULT_ARG), it is a TermArg that is 647 * evaluated at run-time, and we are therefore finished. 648 */ 649 if ((BufferLengthOp->Asl.ParseOpcode != PARSEOP_INTEGER) && 650 (BufferLengthOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)) 651 { 652 return; 653 } 654 655 /* 656 * We want to count the number of items in the initializer list, because if 657 * it is larger than the buffer length, we will define the buffer size 658 * to be the size of the initializer list (as per the ACPI Specification) 659 */ 660 switch (InitializerOp->Asl.ParseOpcode) 661 { 662 case PARSEOP_INTEGER: 663 case PARSEOP_BYTECONST: 664 case PARSEOP_WORDCONST: 665 case PARSEOP_DWORDCONST: 666 667 /* The peer list contains the byte list (if any...) */ 668 669 while (InitializerOp) 670 { 671 /* For buffers, this is a list of raw bytes */ 672 673 InitializerOp->Asl.AmlOpcode = AML_RAW_DATA_BYTE; 674 InitializerOp->Asl.AmlLength = 1; 675 InitializerOp->Asl.ParseOpcode = PARSEOP_RAW_DATA; 676 677 BufferLength++; 678 InitializerOp = ASL_GET_PEER_NODE (InitializerOp); 679 } 680 break; 681 682 683 case PARSEOP_STRING_LITERAL: 684 685 /* 686 * Only one initializer, the string. Buffer must be big enough to hold 687 * the string plus the null termination byte 688 */ 689 BufferLength = strlen (InitializerOp->Asl.Value.String) + 1; 690 691 InitializerOp->Asl.AmlOpcode = AML_RAW_DATA_BUFFER; 692 InitializerOp->Asl.AmlLength = BufferLength; 693 InitializerOp->Asl.ParseOpcode = PARSEOP_RAW_DATA; 694 break; 695 696 697 case PARSEOP_RAW_DATA: 698 699 /* Buffer nodes are already initialized (e.g. Unicode operator) */ 700 return; 701 702 703 case PARSEOP_DEFAULT_ARG: 704 break; 705 706 707 default: 708 AslError (ASL_ERROR, ASL_MSG_INVALID_OPERAND, InitializerOp, 709 "Unknown buffer initializer opcode"); 710 printf ("Unknown buffer initializer opcode [%s]\n", 711 UtGetOpName (InitializerOp->Asl.ParseOpcode)); 712 return; 713 } 714 715 /* Check if initializer list is longer than the buffer length */ 716 717 if (BufferLengthOp->Asl.Value.Integer > BufferLength) 718 { 719 BufferLength = (UINT32) BufferLengthOp->Asl.Value.Integer; 720 } 721 722 if (!BufferLength) 723 { 724 /* No length AND no items -- issue notice */ 725 726 AslError (ASL_REMARK, ASL_MSG_BUFFER_LENGTH, BufferLengthOp, NULL); 727 728 /* But go ahead and put the buffer length of zero into the AML */ 729 } 730 731 /* 732 * Just set the buffer size node to be the buffer length, regardless 733 * of whether it was previously an integer or a default_arg placeholder 734 */ 735 BufferLengthOp->Asl.ParseOpcode = PARSEOP_INTEGER; 736 BufferLengthOp->Asl.AmlOpcode = AML_DWORD_OP; 737 BufferLengthOp->Asl.Value.Integer = BufferLength; 738 739 (void) OpcSetOptimalIntegerSize (BufferLengthOp); 740 741 /* Remaining nodes are handled via the tree walk */ 742 } 743 744 745 /******************************************************************************* 746 * 747 * FUNCTION: OpnDoPackage 748 * 749 * PARAMETERS: Op - The parent parse node 750 * 751 * RETURN: None 752 * 753 * DESCRIPTION: Construct the AML operands for the PACKAGE ASL keyword. NOTE: 754 * can only be called after constants have been folded, to ensure 755 * that the PackageLength operand has been fully reduced. 756 * 757 ******************************************************************************/ 758 759 void 760 OpnDoPackage ( 761 ACPI_PARSE_OBJECT *Op) 762 { 763 ACPI_PARSE_OBJECT *InitializerOp; 764 ACPI_PARSE_OBJECT *PackageLengthOp; 765 UINT32 PackageLength = 0; 766 767 768 /* Opcode and package length first, followed by the initializer list */ 769 770 PackageLengthOp = Op->Asl.Child; 771 InitializerOp = PackageLengthOp->Asl.Next; 772 773 /* Count the number of items in the initializer list */ 774 775 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 776 { 777 /* The peer list contains the byte list (if any...) */ 778 779 while (InitializerOp) 780 { 781 PackageLength++; 782 InitializerOp = InitializerOp->Asl.Next; 783 } 784 } 785 786 /* If package length is a constant, compare to the initializer list */ 787 788 if ((PackageLengthOp->Asl.ParseOpcode == PARSEOP_INTEGER) || 789 (PackageLengthOp->Asl.ParseOpcode == PARSEOP_QWORDCONST)) 790 { 791 if (PackageLengthOp->Asl.Value.Integer >= PackageLength) 792 { 793 /* Allow package to be longer than the initializer list */ 794 795 PackageLength = (UINT32) PackageLengthOp->Asl.Value.Integer; 796 } 797 else 798 { 799 /* 800 * Initializer list is longer than the package length. This 801 * is an error as per the ACPI spec. 802 */ 803 AslError (ASL_ERROR, ASL_MSG_LIST_LENGTH, 804 PackageLengthOp->Asl.Next, NULL); 805 } 806 } 807 808 if (PackageLengthOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG) 809 { 810 /* 811 * This is the case if the PackageLength was left empty - Package() 812 * The package length becomes the length of the initializer list 813 */ 814 Op->Asl.Child->Asl.ParseOpcode = PARSEOP_INTEGER; 815 Op->Asl.Child->Asl.Value.Integer = PackageLength; 816 817 /* Set the AML opcode */ 818 819 (void) OpcSetOptimalIntegerSize (Op->Asl.Child); 820 } 821 822 /* If not a variable-length package, check for a zero package length */ 823 824 if ((PackageLengthOp->Asl.ParseOpcode == PARSEOP_INTEGER) || 825 (PackageLengthOp->Asl.ParseOpcode == PARSEOP_QWORDCONST) || 826 (PackageLengthOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)) 827 { 828 if (!PackageLength) 829 { 830 /* No length AND no initializer list -- issue a remark */ 831 832 AslError (ASL_REMARK, ASL_MSG_PACKAGE_LENGTH, 833 PackageLengthOp, NULL); 834 835 /* But go ahead and put the buffer length of zero into the AML */ 836 } 837 } 838 839 /* 840 * If the PackageLength is a constant <= 255, we can change the 841 * AML opcode from VarPackage to a simple (ACPI 1.0) Package opcode. 842 */ 843 if ((Op->Asl.Child->Asl.ParseOpcode == PARSEOP_INTEGER) && 844 (Op->Asl.Child->Asl.Value.Integer <= 255)) 845 { 846 Op->Asl.AmlOpcode = AML_PACKAGE_OP; 847 Op->Asl.ParseOpcode = PARSEOP_PACKAGE; 848 849 /* 850 * Just set the package size node to be the package length, regardless 851 * of whether it was previously an integer or a default_arg placeholder 852 */ 853 PackageLengthOp->Asl.AmlOpcode = AML_RAW_DATA_BYTE; 854 PackageLengthOp->Asl.AmlLength = 1; 855 PackageLengthOp->Asl.ParseOpcode = PARSEOP_RAW_DATA; 856 PackageLengthOp->Asl.Value.Integer = PackageLength; 857 } 858 859 /* Remaining nodes are handled via the tree walk */ 860 } 861 862 863 /******************************************************************************* 864 * 865 * FUNCTION: OpnDoLoadTable 866 * 867 * PARAMETERS: Op - The parent parse node 868 * 869 * RETURN: None 870 * 871 * DESCRIPTION: Construct the AML operands for the LOADTABLE ASL keyword. 872 * 873 ******************************************************************************/ 874 875 static void 876 OpnDoLoadTable ( 877 ACPI_PARSE_OBJECT *Op) 878 { 879 ACPI_PARSE_OBJECT *Next; 880 881 882 /* Opcode is parent node */ 883 /* First child is the table signature */ 884 885 Next = Op->Asl.Child; 886 887 /* Second child is the OEM ID*/ 888 889 Next = Next->Asl.Next; 890 891 /* Third child is the OEM table ID */ 892 893 Next = Next->Asl.Next; 894 895 /* Fourth child is the RootPath string */ 896 897 Next = Next->Asl.Next; 898 if (Next->Asl.ParseOpcode == PARSEOP_ZERO) 899 { 900 Next->Asl.ParseOpcode = PARSEOP_STRING_LITERAL; 901 Next->Asl.Value.String = "\\"; 902 Next->Asl.AmlLength = 2; 903 OpcGenerateAmlOpcode (Next); 904 } 905 906 #ifdef ASL_FUTURE_IMPLEMENTATION 907 908 /* TBD: NOT IMPLEMENTED */ 909 /* Fifth child is the [optional] ParameterPathString */ 910 /* Sixth child is the [optional] ParameterData */ 911 912 Next = Next->Asl.Next; 913 if (Next->Asl.ParseOpcode == DEFAULT_ARG) 914 { 915 Next->Asl.AmlLength = 1; 916 Next->Asl.ParseOpcode = ZERO; 917 OpcGenerateAmlOpcode (Next); 918 } 919 920 921 Next = Next->Asl.Next; 922 if (Next->Asl.ParseOpcode == DEFAULT_ARG) 923 { 924 Next->Asl.AmlLength = 1; 925 Next->Asl.ParseOpcode = ZERO; 926 OpcGenerateAmlOpcode (Next); 927 } 928 #endif 929 } 930 931 932 /******************************************************************************* 933 * 934 * FUNCTION: OpnDoDefinitionBlock 935 * 936 * PARAMETERS: Op - The parent parse node 937 * 938 * RETURN: None 939 * 940 * DESCRIPTION: Construct the AML operands for the DEFINITIONBLOCK ASL keyword 941 * 942 ******************************************************************************/ 943 944 static void 945 OpnDoDefinitionBlock ( 946 ACPI_PARSE_OBJECT *Op) 947 { 948 ACPI_PARSE_OBJECT *Child; 949 ACPI_SIZE Length; 950 UINT32 i; 951 char *Filename; 952 953 954 /* 955 * These nodes get stuffed into the table header. They are special 956 * cased when the table is written to the output file. 957 * 958 * Mark all of these nodes as non-usable so they won't get output 959 * as AML opcodes! 960 */ 961 962 /* Get AML filename. Use it if non-null */ 963 964 Child = Op->Asl.Child; 965 if (Child->Asl.Value.Buffer && 966 *Child->Asl.Value.Buffer && 967 (Gbl_UseDefaultAmlFilename)) 968 { 969 /* 970 * We will use the AML filename that is embedded in the source file 971 * for the output filename. 972 */ 973 Filename = ACPI_ALLOCATE (strlen (Gbl_DirectoryPath) + 974 strlen ((char *) Child->Asl.Value.Buffer) + 1); 975 976 /* Prepend the current directory path */ 977 978 strcpy (Filename, Gbl_DirectoryPath); 979 strcat (Filename, (char *) Child->Asl.Value.Buffer); 980 981 Gbl_OutputFilenamePrefix = Filename; 982 } 983 Child->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG; 984 985 /* Signature */ 986 987 Child = Child->Asl.Next; 988 Child->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG; 989 if (Child->Asl.Value.String) 990 { 991 Gbl_TableSignature = Child->Asl.Value.String; 992 if (ACPI_STRLEN (Gbl_TableSignature) != 4) 993 { 994 AslError (ASL_ERROR, ASL_MSG_TABLE_SIGNATURE, Child, 995 "Length not exactly 4"); 996 } 997 998 for (i = 0; i < 4; i++) 999 { 1000 if (!isalnum (Gbl_TableSignature[i])) 1001 { 1002 AslError (ASL_ERROR, ASL_MSG_TABLE_SIGNATURE, Child, 1003 "Contains non-alphanumeric characters"); 1004 } 1005 } 1006 } 1007 1008 /* Revision */ 1009 1010 Child = Child->Asl.Next; 1011 Child->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG; 1012 /* 1013 * We used the revision to set the integer width earlier 1014 */ 1015 1016 /* OEMID */ 1017 1018 Child = Child->Asl.Next; 1019 Child->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG; 1020 1021 /* OEM TableID */ 1022 1023 Child = Child->Asl.Next; 1024 Child->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG; 1025 if (Child->Asl.Value.String) 1026 { 1027 Length = ACPI_STRLEN (Child->Asl.Value.String); 1028 Gbl_TableId = AcpiOsAllocate (Length + 1); 1029 ACPI_STRCPY (Gbl_TableId, Child->Asl.Value.String); 1030 1031 for (i = 0; i < Length; i++) 1032 { 1033 if (Gbl_TableId[i] == ' ') 1034 { 1035 Gbl_TableId[i] = 0; 1036 break; 1037 } 1038 } 1039 } 1040 1041 /* OEM Revision */ 1042 1043 Child = Child->Asl.Next; 1044 Child->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG; 1045 } 1046 1047 1048 /******************************************************************************* 1049 * 1050 * FUNCTION: UtGetArg 1051 * 1052 * PARAMETERS: Op - Get an argument for this op 1053 * Argn - Nth argument to get 1054 * 1055 * RETURN: The argument (as an Op object). NULL if argument does not exist 1056 * 1057 * DESCRIPTION: Get the specified op's argument (peer) 1058 * 1059 ******************************************************************************/ 1060 1061 ACPI_PARSE_OBJECT * 1062 UtGetArg ( 1063 ACPI_PARSE_OBJECT *Op, 1064 UINT32 Argn) 1065 { 1066 ACPI_PARSE_OBJECT *Arg = NULL; 1067 1068 1069 /* Get the requested argument object */ 1070 1071 Arg = Op->Asl.Child; 1072 while (Arg && Argn) 1073 { 1074 Argn--; 1075 Arg = Arg->Asl.Next; 1076 } 1077 1078 return (Arg); 1079 } 1080 1081 1082 /******************************************************************************* 1083 * 1084 * FUNCTION: OpnAttachNameToNode 1085 * 1086 * PARAMETERS: Op - The parent parse node 1087 * 1088 * RETURN: None 1089 * 1090 * DESCRIPTION: For the named ASL/AML operators, get the actual name from the 1091 * argument list and attach it to the parent node so that we 1092 * can get to it quickly later. 1093 * 1094 ******************************************************************************/ 1095 1096 static void 1097 OpnAttachNameToNode ( 1098 ACPI_PARSE_OBJECT *Op) 1099 { 1100 ACPI_PARSE_OBJECT *Child = NULL; 1101 1102 1103 if (Op->Asl.ParseOpcode == PARSEOP_EXTERNAL) 1104 { 1105 Child = UtGetArg (Op, 0); 1106 } 1107 else switch (Op->Asl.AmlOpcode) 1108 { 1109 case AML_DATA_REGION_OP: 1110 case AML_DEVICE_OP: 1111 case AML_EVENT_OP: 1112 case AML_METHOD_OP: 1113 case AML_MUTEX_OP: 1114 case AML_REGION_OP: 1115 case AML_POWER_RES_OP: 1116 case AML_PROCESSOR_OP: 1117 case AML_THERMAL_ZONE_OP: 1118 case AML_NAME_OP: 1119 case AML_SCOPE_OP: 1120 1121 Child = UtGetArg (Op, 0); 1122 break; 1123 1124 case AML_ALIAS_OP: 1125 1126 Child = UtGetArg (Op, 1); 1127 break; 1128 1129 case AML_CREATE_BIT_FIELD_OP: 1130 case AML_CREATE_BYTE_FIELD_OP: 1131 case AML_CREATE_WORD_FIELD_OP: 1132 case AML_CREATE_DWORD_FIELD_OP: 1133 case AML_CREATE_QWORD_FIELD_OP: 1134 1135 Child = UtGetArg (Op, 2); 1136 break; 1137 1138 case AML_CREATE_FIELD_OP: 1139 1140 Child = UtGetArg (Op, 3); 1141 break; 1142 1143 case AML_BANK_FIELD_OP: 1144 case AML_INDEX_FIELD_OP: 1145 case AML_FIELD_OP: 1146 1147 return; 1148 1149 default: 1150 return; 1151 } 1152 1153 if (Child) 1154 { 1155 UtAttachNamepathToOwner (Op, Child); 1156 } 1157 } 1158 1159 1160 /******************************************************************************* 1161 * 1162 * FUNCTION: OpnGenerateAmlOperands 1163 * 1164 * PARAMETERS: Op - The parent parse node 1165 * 1166 * RETURN: None 1167 * 1168 * DESCRIPTION: Prepare nodes to be output as AML data and operands. The more 1169 * complex AML opcodes require processing of the child nodes 1170 * (arguments/operands). 1171 * 1172 ******************************************************************************/ 1173 1174 void 1175 OpnGenerateAmlOperands ( 1176 ACPI_PARSE_OBJECT *Op) 1177 { 1178 1179 1180 if (Op->Asl.AmlOpcode == AML_RAW_DATA_BYTE) 1181 { 1182 return; 1183 } 1184 1185 switch (Op->Asl.ParseOpcode) 1186 { 1187 case PARSEOP_DEFINITIONBLOCK: 1188 OpnDoDefinitionBlock (Op); 1189 break; 1190 1191 case PARSEOP_METHOD: 1192 OpnDoMethod (Op); 1193 break; 1194 1195 case PARSEOP_MUTEX: 1196 OpnDoMutex (Op); 1197 break; 1198 1199 case PARSEOP_FIELD: 1200 OpnDoField (Op); 1201 break; 1202 1203 case PARSEOP_INDEXFIELD: 1204 OpnDoIndexField (Op); 1205 break; 1206 1207 case PARSEOP_BANKFIELD: 1208 OpnDoBankField (Op); 1209 break; 1210 1211 case PARSEOP_BUFFER: 1212 OpnDoBuffer (Op); 1213 break; 1214 1215 case PARSEOP_LOADTABLE: 1216 OpnDoLoadTable (Op); 1217 break; 1218 1219 case PARSEOP_OPERATIONREGION: 1220 OpnDoRegion (Op); 1221 break; 1222 1223 case PARSEOP_RESOURCETEMPLATE: 1224 RsDoResourceTemplate (Op); 1225 break; 1226 1227 case PARSEOP_NAMESEG: 1228 case PARSEOP_NAMESTRING: 1229 case PARSEOP_METHODCALL: 1230 case PARSEOP_STRING_LITERAL: 1231 break; 1232 1233 default: 1234 break; 1235 } 1236 1237 /* TBD: move */ 1238 1239 OpnAttachNameToNode (Op); 1240 } 1241 1242 1243