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