1 2 /****************************************************************************** 3 * 4 * Module Name: aslresource - Resource templates and descriptors 5 * $Revision: 1.38 $ 6 * 7 *****************************************************************************/ 8 9 /****************************************************************************** 10 * 11 * 1. Copyright Notice 12 * 13 * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp. 14 * All rights reserved. 15 * 16 * 2. License 17 * 18 * 2.1. This is your license from Intel Corp. under its intellectual property 19 * rights. You may have additional license terms from the party that provided 20 * you this software, covering your right to use that party's intellectual 21 * property rights. 22 * 23 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a 24 * copy of the source code appearing in this file ("Covered Code") an 25 * irrevocable, perpetual, worldwide license under Intel's copyrights in the 26 * base code distributed originally by Intel ("Original Intel Code") to copy, 27 * make derivatives, distribute, use and display any portion of the Covered 28 * Code in any form, with the right to sublicense such rights; and 29 * 30 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent 31 * license (with the right to sublicense), under only those claims of Intel 32 * patents that are infringed by the Original Intel Code, to make, use, sell, 33 * offer to sell, and import the Covered Code and derivative works thereof 34 * solely to the minimum extent necessary to exercise the above copyright 35 * license, and in no event shall the patent license extend to any additions 36 * to or modifications of the Original Intel Code. No other license or right 37 * is granted directly or by implication, estoppel or otherwise; 38 * 39 * The above copyright and patent license is granted only if the following 40 * conditions are met: 41 * 42 * 3. Conditions 43 * 44 * 3.1. Redistribution of Source with Rights to Further Distribute Source. 45 * Redistribution of source code of any substantial portion of the Covered 46 * Code or modification with rights to further distribute source must include 47 * the above Copyright Notice, the above License, this list of Conditions, 48 * and the following Disclaimer and Export Compliance provision. In addition, 49 * Licensee must cause all Covered Code to which Licensee contributes to 50 * contain a file documenting the changes Licensee made to create that Covered 51 * Code and the date of any change. Licensee must include in that file the 52 * documentation of any changes made by any predecessor Licensee. Licensee 53 * must include a prominent statement that the modification is derived, 54 * directly or indirectly, from Original Intel Code. 55 * 56 * 3.2. Redistribution of Source with no Rights to Further Distribute Source. 57 * Redistribution of source code of any substantial portion of the Covered 58 * Code or modification without rights to further distribute source must 59 * include the following Disclaimer and Export Compliance provision in the 60 * documentation and/or other materials provided with distribution. In 61 * addition, Licensee may not authorize further sublicense of source of any 62 * portion of the Covered Code, and must include terms to the effect that the 63 * license from Licensee to its licensee is limited to the intellectual 64 * property embodied in the software Licensee provides to its licensee, and 65 * not to intellectual property embodied in modifications its licensee may 66 * make. 67 * 68 * 3.3. Redistribution of Executable. Redistribution in executable form of any 69 * substantial portion of the Covered Code or modification must reproduce the 70 * above Copyright Notice, and the following Disclaimer and Export Compliance 71 * provision in the documentation and/or other materials provided with the 72 * distribution. 73 * 74 * 3.4. Intel retains all right, title, and interest in and to the Original 75 * Intel Code. 76 * 77 * 3.5. Neither the name Intel nor any other trademark owned or controlled by 78 * Intel shall be used in advertising or otherwise to promote the sale, use or 79 * other dealings in products derived from or relating to the Covered Code 80 * without prior written authorization from Intel. 81 * 82 * 4. Disclaimer and Export Compliance 83 * 84 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED 85 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE 86 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, 87 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY 88 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY 89 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A 90 * PARTICULAR PURPOSE. 91 * 92 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES 93 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR 94 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, 95 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY 96 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL 97 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS 98 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY 99 * LIMITED REMEDY. 100 * 101 * 4.3. Licensee shall not export, either directly or indirectly, any of this 102 * software or system incorporating such software without first obtaining any 103 * required license or other approval from the U. S. Department of Commerce or 104 * any other agency or department of the United States Government. In the 105 * event Licensee exports any such software from the United States or 106 * re-exports any such software from a foreign destination, Licensee shall 107 * ensure that the distribution and export/re-export of the software is in 108 * compliance with all laws, regulations, orders, or other restrictions of the 109 * U.S. Export Administration Regulations. Licensee agrees that neither it nor 110 * any of its subsidiaries will export/re-export any technical data, process, 111 * software, or service, directly or indirectly, to any country for which the 112 * United States government or any agency thereof requires an export license, 113 * other governmental approval, or letter of assurance, without first obtaining 114 * such license, approval or letter. 115 * 116 *****************************************************************************/ 117 118 119 #include <contrib/dev/acpica/compiler/aslcompiler.h> 120 #include "aslcompiler.y.h" 121 #include <contrib/dev/acpica/amlcode.h> 122 123 124 #define _COMPONENT ACPI_COMPILER 125 ACPI_MODULE_NAME ("aslresource") 126 127 128 /******************************************************************************* 129 * 130 * FUNCTION: RsAllocateResourceNode 131 * 132 * PARAMETERS: Size - Size of node in bytes 133 * 134 * RETURN: The allocated node - aborts on allocation failure 135 * 136 * DESCRIPTION: Allocate a resource description node and the resource 137 * descriptor itself (the nodes are used to link descriptors). 138 * 139 ******************************************************************************/ 140 141 ASL_RESOURCE_NODE * 142 RsAllocateResourceNode ( 143 UINT32 Size) 144 { 145 ASL_RESOURCE_NODE *Rnode; 146 147 148 /* Allocate the node */ 149 150 Rnode = UtLocalCalloc (sizeof (ASL_RESOURCE_NODE)); 151 152 /* Allocate the resource descriptor itself */ 153 154 Rnode->Buffer = UtLocalCalloc (Size); 155 Rnode->BufferLength = Size; 156 157 return (Rnode); 158 } 159 160 161 /******************************************************************************* 162 * 163 * FUNCTION: RsCreateBitField 164 * 165 * PARAMETERS: Op - Resource field node 166 * Name - Name of the field (Used only to reference 167 * the field in the ASL, not in the AML) 168 * ByteOffset - Offset from the field start 169 * BitOffset - Additional bit offset 170 * 171 * RETURN: None, sets fields within the input node 172 * 173 * DESCRIPTION: Utility function to generate a named bit field within a 174 * resource descriptor. Mark a node as 1) a field in a resource 175 * descriptor, and 2) set the value to be a BIT offset 176 * 177 ******************************************************************************/ 178 179 void 180 RsCreateBitField ( 181 ACPI_PARSE_OBJECT *Op, 182 char *Name, 183 UINT32 ByteOffset, 184 UINT32 BitOffset) 185 { 186 187 Op->Asl.ExternalName = Name; 188 Op->Asl.Value.Integer = ((ACPI_INTEGER) ByteOffset * 8) + BitOffset; 189 Op->Asl.CompileFlags |= (NODE_IS_RESOURCE_FIELD | NODE_IS_BIT_OFFSET); 190 } 191 192 193 /******************************************************************************* 194 * 195 * FUNCTION: RsCreateByteField 196 * 197 * PARAMETERS: Op - Resource field node 198 * Name - Name of the field (Used only to reference 199 * the field in the ASL, not in the AML) 200 * ByteOffset - Offset from the field start 201 * 202 * RETURN: None, sets fields within the input node 203 * 204 * DESCRIPTION: Utility function to generate a named byte field within a 205 * resource descriptor. Mark a node as 1) a field in a resource 206 * descriptor, and 2) set the value to be a BYTE offset 207 * 208 ******************************************************************************/ 209 210 void 211 RsCreateByteField ( 212 ACPI_PARSE_OBJECT *Op, 213 char *Name, 214 UINT32 ByteOffset) 215 { 216 217 Op->Asl.ExternalName = Name; 218 Op->Asl.Value.Integer = ByteOffset; 219 Op->Asl.CompileFlags |= NODE_IS_RESOURCE_FIELD; 220 } 221 222 223 /******************************************************************************* 224 * 225 * FUNCTION: RsSetFlagBits 226 * 227 * PARAMETERS: *Flags - Pointer to the flag byte 228 * Op - Flag initialization node 229 * Position - Bit position within the flag byte 230 * Default - Used if the node is DEFAULT. 231 * 232 * RETURN: Sets bits within the *Flags output byte. 233 * 234 * DESCRIPTION: Set a bit in a cumulative flags word from an initialization 235 * node. Will use a default value if the node is DEFAULT, meaning 236 * that no value was specified in the ASL. Used to merge multiple 237 * keywords into a single flags byte. 238 * 239 ******************************************************************************/ 240 241 void 242 RsSetFlagBits ( 243 UINT8 *Flags, 244 ACPI_PARSE_OBJECT *Op, 245 UINT8 Position, 246 UINT8 DefaultBit) 247 { 248 249 if (Op->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG) 250 { 251 /* Use the default bit */ 252 253 *Flags |= (DefaultBit << Position); 254 } 255 else 256 { 257 /* Use the bit specified in the initialization node */ 258 259 *Flags |= (((UINT8) Op->Asl.Value.Integer) << Position); 260 } 261 } 262 263 264 /******************************************************************************* 265 * 266 * FUNCTION: RsCompleteNodeAndGetNext 267 * 268 * PARAMETERS: Op - Resource node to be completed 269 * 270 * RETURN: The next peer to the input node. 271 * 272 * DESCRIPTION: Mark the current node completed and return the next peer. 273 * The node ParseOpcode is set to DEFAULT_ARG, meaning that 274 * this node is to be ignored from now on. 275 * 276 ******************************************************************************/ 277 278 ACPI_PARSE_OBJECT * 279 RsCompleteNodeAndGetNext ( 280 ACPI_PARSE_OBJECT *Op) 281 { 282 283 /* Mark this node unused */ 284 285 Op->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG; 286 287 /* Move on to the next peer node in the initializer list */ 288 289 return (ASL_GET_PEER_NODE (Op)); 290 } 291 292 293 /******************************************************************************* 294 * 295 * FUNCTION: RsCheckListForDuplicates 296 * 297 * PARAMETERS: Op - First op in the initializer list 298 * 299 * RETURN: None 300 * 301 * DESCRIPTION: Check an initializer list for duplicate values. Emits an error 302 * if any duplicates are found. 303 * 304 ******************************************************************************/ 305 306 void 307 RsCheckListForDuplicates ( 308 ACPI_PARSE_OBJECT *Op) 309 { 310 ACPI_PARSE_OBJECT *NextValueOp = Op; 311 ACPI_PARSE_OBJECT *NextOp; 312 UINT32 Value; 313 314 315 if (!Op) 316 { 317 return; 318 } 319 320 /* Search list once for each value in the list */ 321 322 while (NextValueOp) 323 { 324 Value = (UINT32) NextValueOp->Asl.Value.Integer; 325 326 /* Compare this value to all remaining values in the list */ 327 328 NextOp = ASL_GET_PEER_NODE (NextValueOp); 329 while (NextOp) 330 { 331 if (NextOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 332 { 333 /* Compare values */ 334 335 if (Value == (UINT32) NextOp->Asl.Value.Integer) 336 { 337 /* Emit error only once per duplicate node */ 338 339 if (!(NextOp->Asl.CompileFlags & NODE_IS_DUPLICATE)) 340 { 341 NextOp->Asl.CompileFlags |= NODE_IS_DUPLICATE; 342 AslError (ASL_ERROR, ASL_MSG_DUPLICATE_ITEM, 343 NextOp, NULL); 344 } 345 } 346 } 347 348 NextOp = ASL_GET_PEER_NODE (NextOp); 349 } 350 351 NextValueOp = ASL_GET_PEER_NODE (NextValueOp); 352 } 353 } 354 355 356 /******************************************************************************* 357 * 358 * FUNCTION: RsDoOneResourceDescriptor 359 * 360 * PARAMETERS: DescriptorTypeOp - Parent parse node of the descriptor 361 * CurrentByteOffset - Offset in the resource descriptor 362 * buffer. 363 * 364 * RETURN: A valid resource node for the descriptor 365 * 366 * DESCRIPTION: Dispatches the processing of one resource descriptor 367 * 368 ******************************************************************************/ 369 370 ASL_RESOURCE_NODE * 371 RsDoOneResourceDescriptor ( 372 ACPI_PARSE_OBJECT *DescriptorTypeOp, 373 UINT32 CurrentByteOffset, 374 UINT8 *State) 375 { 376 ASL_RESOURCE_NODE *Rnode = NULL; 377 378 379 /* Determine type of resource */ 380 381 switch (DescriptorTypeOp->Asl.ParseOpcode) 382 { 383 case PARSEOP_DMA: 384 Rnode = RsDoDmaDescriptor (DescriptorTypeOp, 385 CurrentByteOffset); 386 break; 387 388 case PARSEOP_DWORDIO: 389 Rnode = RsDoDwordIoDescriptor (DescriptorTypeOp, 390 CurrentByteOffset); 391 break; 392 393 case PARSEOP_DWORDMEMORY: 394 Rnode = RsDoDwordMemoryDescriptor (DescriptorTypeOp, 395 CurrentByteOffset); 396 break; 397 398 case PARSEOP_DWORDSPACE: 399 Rnode = RsDoDwordSpaceDescriptor (DescriptorTypeOp, 400 CurrentByteOffset); 401 break; 402 403 case PARSEOP_ENDDEPENDENTFN: 404 switch (*State) 405 { 406 case ACPI_RSTATE_NORMAL: 407 AslError (ASL_ERROR, ASL_MSG_MISSING_STARTDEPENDENT, 408 DescriptorTypeOp, NULL); 409 break; 410 411 case ACPI_RSTATE_START_DEPENDENT: 412 AslError (ASL_ERROR, ASL_MSG_DEPENDENT_NESTING, 413 DescriptorTypeOp, NULL); 414 break; 415 416 case ACPI_RSTATE_DEPENDENT_LIST: 417 default: 418 break; 419 } 420 421 *State = ACPI_RSTATE_NORMAL; 422 Rnode = RsDoEndDependentDescriptor (DescriptorTypeOp, 423 CurrentByteOffset); 424 break; 425 426 case PARSEOP_EXTENDEDIO: 427 Rnode = RsDoExtendedIoDescriptor (DescriptorTypeOp, 428 CurrentByteOffset); 429 break; 430 431 case PARSEOP_EXTENDEDMEMORY: 432 Rnode = RsDoExtendedMemoryDescriptor (DescriptorTypeOp, 433 CurrentByteOffset); 434 break; 435 436 case PARSEOP_EXTENDEDSPACE: 437 Rnode = RsDoExtendedSpaceDescriptor (DescriptorTypeOp, 438 CurrentByteOffset); 439 break; 440 441 case PARSEOP_FIXEDIO: 442 Rnode = RsDoFixedIoDescriptor (DescriptorTypeOp, 443 CurrentByteOffset); 444 break; 445 446 case PARSEOP_INTERRUPT: 447 Rnode = RsDoInterruptDescriptor (DescriptorTypeOp, 448 CurrentByteOffset); 449 break; 450 451 case PARSEOP_IO: 452 Rnode = RsDoIoDescriptor (DescriptorTypeOp, 453 CurrentByteOffset); 454 break; 455 456 case PARSEOP_IRQ: 457 Rnode = RsDoIrqDescriptor (DescriptorTypeOp, 458 CurrentByteOffset); 459 break; 460 461 case PARSEOP_IRQNOFLAGS: 462 Rnode = RsDoIrqNoFlagsDescriptor (DescriptorTypeOp, 463 CurrentByteOffset); 464 break; 465 466 case PARSEOP_MEMORY24: 467 Rnode = RsDoMemory24Descriptor (DescriptorTypeOp, 468 CurrentByteOffset); 469 break; 470 471 case PARSEOP_MEMORY32: 472 Rnode = RsDoMemory32Descriptor (DescriptorTypeOp, 473 CurrentByteOffset); 474 break; 475 476 case PARSEOP_MEMORY32FIXED: 477 Rnode = RsDoMemory32FixedDescriptor (DescriptorTypeOp, 478 CurrentByteOffset); 479 break; 480 481 case PARSEOP_QWORDIO: 482 Rnode = RsDoQwordIoDescriptor (DescriptorTypeOp, 483 CurrentByteOffset); 484 break; 485 486 case PARSEOP_QWORDMEMORY: 487 Rnode = RsDoQwordMemoryDescriptor (DescriptorTypeOp, 488 CurrentByteOffset); 489 break; 490 491 case PARSEOP_QWORDSPACE: 492 Rnode = RsDoQwordSpaceDescriptor (DescriptorTypeOp, 493 CurrentByteOffset); 494 break; 495 496 case PARSEOP_REGISTER: 497 Rnode = RsDoGeneralRegisterDescriptor (DescriptorTypeOp, 498 CurrentByteOffset); 499 break; 500 501 case PARSEOP_STARTDEPENDENTFN: 502 switch (*State) 503 { 504 case ACPI_RSTATE_START_DEPENDENT: 505 AslError (ASL_ERROR, ASL_MSG_DEPENDENT_NESTING, 506 DescriptorTypeOp, NULL); 507 break; 508 509 case ACPI_RSTATE_NORMAL: 510 case ACPI_RSTATE_DEPENDENT_LIST: 511 default: 512 break; 513 } 514 515 *State = ACPI_RSTATE_START_DEPENDENT; 516 Rnode = RsDoStartDependentDescriptor (DescriptorTypeOp, 517 CurrentByteOffset); 518 *State = ACPI_RSTATE_DEPENDENT_LIST; 519 break; 520 521 case PARSEOP_STARTDEPENDENTFN_NOPRI: 522 switch (*State) 523 { 524 case ACPI_RSTATE_START_DEPENDENT: 525 AslError (ASL_ERROR, ASL_MSG_DEPENDENT_NESTING, 526 DescriptorTypeOp, NULL); 527 break; 528 529 case ACPI_RSTATE_NORMAL: 530 case ACPI_RSTATE_DEPENDENT_LIST: 531 default: 532 break; 533 } 534 535 *State = ACPI_RSTATE_START_DEPENDENT; 536 Rnode = RsDoStartDependentNoPriDescriptor (DescriptorTypeOp, 537 CurrentByteOffset); 538 *State = ACPI_RSTATE_DEPENDENT_LIST; 539 break; 540 541 case PARSEOP_VENDORLONG: 542 Rnode = RsDoVendorLargeDescriptor (DescriptorTypeOp, 543 CurrentByteOffset); 544 break; 545 546 case PARSEOP_VENDORSHORT: 547 Rnode = RsDoVendorSmallDescriptor (DescriptorTypeOp, 548 CurrentByteOffset); 549 break; 550 551 case PARSEOP_WORDBUSNUMBER: 552 Rnode = RsDoWordBusNumberDescriptor (DescriptorTypeOp, 553 CurrentByteOffset); 554 break; 555 556 case PARSEOP_WORDIO: 557 Rnode = RsDoWordIoDescriptor (DescriptorTypeOp, 558 CurrentByteOffset); 559 break; 560 561 case PARSEOP_WORDSPACE: 562 Rnode = RsDoWordSpaceDescriptor (DescriptorTypeOp, 563 CurrentByteOffset); 564 break; 565 566 case PARSEOP_DEFAULT_ARG: 567 /* Just ignore any of these, they are used as fillers/placeholders */ 568 break; 569 570 default: 571 printf ("Unknown resource descriptor type [%s]\n", 572 DescriptorTypeOp->Asl.ParseOpName); 573 break; 574 } 575 576 /* 577 * Mark original node as unused, but head of a resource descriptor. 578 * This allows the resource to be installed in the namespace so that 579 * references to the descriptor can be resolved. 580 */ 581 DescriptorTypeOp->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG; 582 DescriptorTypeOp->Asl.CompileFlags = NODE_IS_RESOURCE_DESC; 583 584 return (Rnode); 585 } 586 587 588 /******************************************************************************* 589 * 590 * FUNCTION: RsLinkDescriptorChain 591 * 592 * PARAMETERS: PreviousRnode - Pointer to the node that will be previous 593 * to the linked node, At exit, set to the 594 * last node in the new chain. 595 * Rnode - Resource node to link into the list 596 * 597 * RETURN: Cumulative buffer byte offset of the new segment of chain 598 * 599 * DESCRIPTION: Link a descriptor chain at the end of an existing chain. 600 * 601 ******************************************************************************/ 602 603 UINT32 604 RsLinkDescriptorChain ( 605 ASL_RESOURCE_NODE **PreviousRnode, 606 ASL_RESOURCE_NODE *Rnode) 607 { 608 ASL_RESOURCE_NODE *LastRnode; 609 UINT32 CurrentByteOffset; 610 611 612 /* Anything to do? */ 613 614 if (!Rnode) 615 { 616 return 0; 617 } 618 619 /* Point the previous node to the new node */ 620 621 (*PreviousRnode)->Next = Rnode; 622 CurrentByteOffset = Rnode->BufferLength; 623 624 /* Walk to the end of the chain headed by Rnode */ 625 626 LastRnode = Rnode; 627 while (LastRnode->Next) 628 { 629 LastRnode = LastRnode->Next; 630 CurrentByteOffset += LastRnode->BufferLength; 631 } 632 633 /* Previous node becomes the last node in the chain */ 634 635 *PreviousRnode = LastRnode; 636 return CurrentByteOffset; 637 } 638 639 640 /******************************************************************************* 641 * 642 * FUNCTION: RsDoResourceTemplate 643 * 644 * PARAMETERS: Op - Parent of a resource template list 645 * 646 * RETURN: None. Sets input node to point to a list of AML code 647 * 648 * DESCRIPTION: Merge a list of resource descriptors into a single AML buffer, 649 * in preparation for output to the AML output file. 650 * 651 ******************************************************************************/ 652 653 void 654 RsDoResourceTemplate ( 655 ACPI_PARSE_OBJECT *Op) 656 { 657 ACPI_PARSE_OBJECT *BufferLengthOp; 658 ACPI_PARSE_OBJECT *BufferOp; 659 ACPI_PARSE_OBJECT *DescriptorTypeOp; 660 ACPI_PARSE_OBJECT *LastOp = NULL; 661 AML_RESOURCE *Descriptor; 662 UINT32 CurrentByteOffset = 0; 663 ASL_RESOURCE_NODE HeadRnode; 664 ASL_RESOURCE_NODE *PreviousRnode; 665 ASL_RESOURCE_NODE *Rnode; 666 UINT8 State; 667 668 669 /* ResourceTemplate Opcode is first (Op) */ 670 /* Buffer Length node is first child */ 671 672 BufferLengthOp = ASL_GET_CHILD_NODE (Op); 673 674 /* Buffer Op is first peer */ 675 676 BufferOp = ASL_GET_PEER_NODE (BufferLengthOp); 677 678 /* First Descriptor type is next */ 679 680 DescriptorTypeOp = ASL_GET_PEER_NODE (BufferOp); 681 682 /* Process all resource descriptors in the list */ 683 684 State = ACPI_RSTATE_NORMAL; 685 PreviousRnode = &HeadRnode; 686 while (DescriptorTypeOp) 687 { 688 Rnode = RsDoOneResourceDescriptor (DescriptorTypeOp, CurrentByteOffset, 689 &State); 690 691 /* 692 * Update current byte offset to indicate the number of bytes from the 693 * start of the buffer. Buffer can include multiple descriptors, we 694 * must keep track of the offset of not only each descriptor, but each 695 * element (field) within each descriptor as well. 696 */ 697 CurrentByteOffset += RsLinkDescriptorChain (&PreviousRnode, Rnode); 698 699 /* Get the next descriptor in the list */ 700 701 LastOp = DescriptorTypeOp; 702 DescriptorTypeOp = ASL_GET_PEER_NODE (DescriptorTypeOp); 703 } 704 705 if (State == ACPI_RSTATE_DEPENDENT_LIST) 706 { 707 if (LastOp) 708 { 709 LastOp = LastOp->Asl.Parent; 710 } 711 AslError (ASL_ERROR, ASL_MSG_MISSING_ENDDEPENDENT, LastOp, NULL); 712 } 713 714 /* 715 * Insert the EndTag descriptor after all other descriptors have 716 * been processed 717 */ 718 Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_END_TAG)); 719 720 Descriptor = Rnode->Buffer; 721 Descriptor->EndTag.DescriptorType = ACPI_RESOURCE_NAME_END_TAG | 722 ASL_RDESC_END_TAG_SIZE; 723 Descriptor->EndTag.Checksum = 0; 724 725 CurrentByteOffset += RsLinkDescriptorChain (&PreviousRnode, Rnode); 726 727 /* 728 * Transform the nodes into the following 729 * 730 * Op -> AML_BUFFER_OP 731 * First Child -> BufferLength 732 * Second Child -> Descriptor Buffer (raw byte data) 733 */ 734 Op->Asl.ParseOpcode = PARSEOP_BUFFER; 735 Op->Asl.AmlOpcode = AML_BUFFER_OP; 736 Op->Asl.CompileFlags = NODE_AML_PACKAGE; 737 738 BufferLengthOp->Asl.ParseOpcode = PARSEOP_INTEGER; 739 BufferLengthOp->Asl.Value.Integer = CurrentByteOffset; 740 741 (void) OpcSetOptimalIntegerSize (BufferLengthOp); 742 743 BufferOp->Asl.ParseOpcode = PARSEOP_RAW_DATA; 744 BufferOp->Asl.AmlOpcode = AML_RAW_DATA_CHAIN; 745 BufferOp->Asl.AmlOpcodeLength = 0; 746 BufferOp->Asl.AmlLength = CurrentByteOffset; 747 BufferOp->Asl.Value.Buffer = (UINT8 *) HeadRnode.Next; 748 749 return; 750 } 751 752 753