aslrestype2.c revision 167802
1 2/****************************************************************************** 3 * 4 * Module Name: aslrestype2 - Long (type2) resource templates and descriptors 5 * $Revision: 1.51 $ 6 * 7 *****************************************************************************/ 8 9/****************************************************************************** 10 * 11 * 1. Copyright Notice 12 * 13 * Some or all of this work - Copyright (c) 1999 - 2007, 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 122#define _COMPONENT ACPI_COMPILER 123 ACPI_MODULE_NAME ("aslrestype2") 124 125/* Local prototypes */ 126 127static UINT16 128RsGetStringDataLength ( 129 ACPI_PARSE_OBJECT *InitializerOp); 130 131 132/******************************************************************************* 133 * 134 * FUNCTION: RsGetStringDataLength 135 * 136 * PARAMETERS: InitializerOp - Start of a subtree of init nodes 137 * 138 * RETURN: Valid string length if a string node is found (otherwise 0) 139 * 140 * DESCRIPTION: In a list of peer nodes, find the first one that contains a 141 * string and return the length of the string. 142 * 143 ******************************************************************************/ 144 145static UINT16 146RsGetStringDataLength ( 147 ACPI_PARSE_OBJECT *InitializerOp) 148{ 149 150 while (InitializerOp) 151 { 152 if (InitializerOp->Asl.ParseOpcode == PARSEOP_STRING_LITERAL) 153 { 154 return ((UINT16) (strlen (InitializerOp->Asl.Value.String) + 1)); 155 } 156 InitializerOp = ASL_GET_PEER_NODE (InitializerOp); 157 } 158 159 return 0; 160} 161 162 163/******************************************************************************* 164 * 165 * FUNCTION: RsDoDwordIoDescriptor 166 * 167 * PARAMETERS: Op - Parent resource descriptor parse node 168 * CurrentByteOffset - Offset into the resource template AML 169 * buffer (to track references to the desc) 170 * 171 * RETURN: Completed resource node 172 * 173 * DESCRIPTION: Construct a long "DwordIO" descriptor 174 * 175 ******************************************************************************/ 176 177ASL_RESOURCE_NODE * 178RsDoDwordIoDescriptor ( 179 ACPI_PARSE_OBJECT *Op, 180 UINT32 CurrentByteOffset) 181{ 182 AML_RESOURCE *Descriptor; 183 ACPI_PARSE_OBJECT *InitializerOp; 184 ASL_RESOURCE_NODE *Rnode; 185 UINT16 StringLength = 0; 186 UINT32 OptionIndex = 0; 187 UINT8 *OptionalFields; 188 UINT32 i; 189 BOOLEAN ResSourceIndex = FALSE; 190 191 192 InitializerOp = Op->Asl.Child; 193 StringLength = RsGetStringDataLength (InitializerOp); 194 195 Rnode = RsAllocateResourceNode ( 196 sizeof (AML_RESOURCE_ADDRESS32) + 1 + StringLength); 197 198 Descriptor = Rnode->Buffer; 199 Descriptor->Address32.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS32; 200 Descriptor->Address32.ResourceType = ACPI_ADDRESS_TYPE_IO_RANGE; 201 202 /* 203 * Initial descriptor length -- may be enlarged if there are 204 * optional fields present 205 */ 206 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS32); 207 Descriptor->Address32.ResourceLength = (UINT16) 208 (sizeof (AML_RESOURCE_ADDRESS32) - 209 sizeof (AML_RESOURCE_LARGE_HEADER)); 210 211 /* Process all child initialization nodes */ 212 213 for (i = 0; InitializerOp; i++) 214 { 215 switch (i) 216 { 217 case 0: /* Resource Usage */ 218 219 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 0, 1); 220 break; 221 222 case 1: /* MinType */ 223 224 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 2, 0); 225 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE, 226 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 2); 227 break; 228 229 case 2: /* MaxType */ 230 231 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 3, 0); 232 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE, 233 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 3); 234 break; 235 236 case 3: /* DecodeType */ 237 238 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 1, 0); 239 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE, 240 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 1); 241 break; 242 243 case 4: /* Range Type */ 244 245 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 0, 3); 246 RsCreateBitField (InitializerOp, ACPI_RESTAG_RANGETYPE, 247 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 0); 248 break; 249 250 case 5: /* Address Granularity */ 251 252 Descriptor->Address32.Granularity = 253 (UINT32) InitializerOp->Asl.Value.Integer; 254 RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY, 255 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Granularity)); 256 break; 257 258 case 6: /* Address Min */ 259 260 Descriptor->Address32.Minimum = 261 (UINT32) InitializerOp->Asl.Value.Integer; 262 RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR, 263 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Minimum)); 264 break; 265 266 case 7: /* Address Max */ 267 268 Descriptor->Address32.Maximum = 269 (UINT32) InitializerOp->Asl.Value.Integer; 270 RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR, 271 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Maximum)); 272 break; 273 274 case 8: /* Translation Offset */ 275 276 Descriptor->Address32.TranslationOffset = 277 (UINT32) InitializerOp->Asl.Value.Integer; 278 RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION, 279 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.TranslationOffset)); 280 break; 281 282 case 9: /* Address Length */ 283 284 Descriptor->Address32.AddressLength = 285 (UINT32) InitializerOp->Asl.Value.Integer; 286 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH, 287 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.AddressLength)); 288 break; 289 290 case 10: /* ResSourceIndex [Optional Field - BYTE] */ 291 292 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 293 { 294 /* Found a valid ResourceSourceIndex */ 295 296 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer; 297 OptionIndex++; 298 Descriptor->Address32.ResourceLength++; 299 ResSourceIndex = TRUE; 300 } 301 break; 302 303 case 11: /* ResSource [Optional Field - STRING] */ 304 305 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) && 306 (InitializerOp->Asl.Value.String)) 307 { 308 if (StringLength) 309 { 310 /* Found a valid ResourceSource */ 311 312 Descriptor->Address32.ResourceLength = (UINT16) 313 (Descriptor->Address32.ResourceLength + StringLength); 314 315 strcpy ((char *) 316 &OptionalFields[OptionIndex], 317 InitializerOp->Asl.Value.String); 318 319 /* ResourceSourceIndex must also be valid */ 320 321 if (!ResSourceIndex) 322 { 323 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX, 324 InitializerOp, NULL); 325 } 326 } 327 } 328 329#if 0 330 /* 331 * Not a valid ResourceSource, ResourceSourceIndex must also 332 * be invalid 333 */ 334 else if (ResSourceIndex) 335 { 336 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE, 337 InitializerOp, NULL); 338 } 339#endif 340 break; 341 342 case 12: /* ResourceTag */ 343 344 UtAttachNamepathToOwner (Op, InitializerOp); 345 break; 346 347 case 13: /* Type */ 348 349 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 4, 0); 350 RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE, 351 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 4); 352 break; 353 354 case 14: /* Translation Type */ 355 356 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 5, 0); 357 RsCreateBitField (InitializerOp, ACPI_RESTAG_TRANSTYPE, 358 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 5); 359 break; 360 361 default: 362 363 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL); 364 break; 365 } 366 367 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 368 } 369 370 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS32) + 371 OptionIndex + StringLength; 372 return (Rnode); 373} 374 375 376/******************************************************************************* 377 * 378 * FUNCTION: RsDoDwordMemoryDescriptor 379 * 380 * PARAMETERS: Op - Parent resource descriptor parse node 381 * CurrentByteOffset - Offset into the resource template AML 382 * buffer (to track references to the desc) 383 * 384 * RETURN: Completed resource node 385 * 386 * DESCRIPTION: Construct a long "DwordMemory" descriptor 387 * 388 ******************************************************************************/ 389 390ASL_RESOURCE_NODE * 391RsDoDwordMemoryDescriptor ( 392 ACPI_PARSE_OBJECT *Op, 393 UINT32 CurrentByteOffset) 394{ 395 AML_RESOURCE *Descriptor; 396 ACPI_PARSE_OBJECT *InitializerOp; 397 ASL_RESOURCE_NODE *Rnode; 398 UINT8 *OptionalFields; 399 UINT16 StringLength = 0; 400 UINT32 OptionIndex = 0; 401 UINT32 i; 402 BOOLEAN ResSourceIndex = FALSE; 403 404 405 InitializerOp = Op->Asl.Child; 406 StringLength = RsGetStringDataLength (InitializerOp); 407 408 Rnode = RsAllocateResourceNode ( 409 sizeof (AML_RESOURCE_ADDRESS32) + 1 + StringLength); 410 411 Descriptor = Rnode->Buffer; 412 Descriptor->Address32.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS32; 413 Descriptor->Address32.ResourceType = ACPI_ADDRESS_TYPE_MEMORY_RANGE; 414 415 /* 416 * Initial descriptor length -- may be enlarged if there are 417 * optional fields present 418 */ 419 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS32); 420 Descriptor->Address32.ResourceLength = (UINT16) 421 (sizeof (AML_RESOURCE_ADDRESS32) - 422 sizeof (AML_RESOURCE_LARGE_HEADER)); 423 424 425 /* Process all child initialization nodes */ 426 427 for (i = 0; InitializerOp; i++) 428 { 429 switch (i) 430 { 431 case 0: /* Resource Usage */ 432 433 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 0, 1); 434 break; 435 436 case 1: /* DecodeType */ 437 438 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 1, 0); 439 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE, 440 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 1); 441 break; 442 443 case 2: /* MinType */ 444 445 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 2, 0); 446 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE, 447 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 2); 448 break; 449 450 case 3: /* MaxType */ 451 452 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 3, 0); 453 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE, 454 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 3); 455 break; 456 457 case 4: /* Memory Type */ 458 459 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 1, 0); 460 RsCreateBitField (InitializerOp, ACPI_RESTAG_MEMTYPE, 461 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 1); 462 break; 463 464 case 5: /* Read/Write Type */ 465 466 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 0, 1); 467 RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE, 468 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 0); 469 break; 470 471 case 6: /* Address Granularity */ 472 473 Descriptor->Address32.Granularity = 474 (UINT32) InitializerOp->Asl.Value.Integer; 475 RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY, 476 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Granularity)); 477 break; 478 479 case 7: /* Min Address */ 480 481 Descriptor->Address32.Minimum = 482 (UINT32) InitializerOp->Asl.Value.Integer; 483 RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR, 484 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Minimum)); 485 break; 486 487 case 8: /* Max Address */ 488 489 Descriptor->Address32.Maximum = 490 (UINT32) InitializerOp->Asl.Value.Integer; 491 RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR, 492 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Maximum)); 493 break; 494 495 case 9: /* Translation Offset */ 496 497 Descriptor->Address32.TranslationOffset = 498 (UINT32) InitializerOp->Asl.Value.Integer; 499 RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION, 500 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.TranslationOffset)); 501 break; 502 503 case 10: /* Address Length */ 504 505 Descriptor->Address32.AddressLength = 506 (UINT32) InitializerOp->Asl.Value.Integer; 507 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH, 508 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.AddressLength)); 509 break; 510 511 case 11: /* ResSourceIndex [Optional Field - BYTE] */ 512 513 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 514 { 515 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer; 516 OptionIndex++; 517 Descriptor->Address32.ResourceLength++; 518 ResSourceIndex = TRUE; 519 } 520 break; 521 522 case 12: /* ResSource [Optional Field - STRING] */ 523 524 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) && 525 (InitializerOp->Asl.Value.String)) 526 { 527 if (StringLength) 528 { 529 Descriptor->Address32.ResourceLength = (UINT16) 530 (Descriptor->Address32.ResourceLength + StringLength); 531 532 strcpy ((char *) 533 &OptionalFields[OptionIndex], 534 InitializerOp->Asl.Value.String); 535 536 /* ResourceSourceIndex must also be valid */ 537 538 if (!ResSourceIndex) 539 { 540 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX, 541 InitializerOp, NULL); 542 } 543 } 544 } 545 546#if 0 547 /* 548 * Not a valid ResourceSource, ResourceSourceIndex must also 549 * be invalid 550 */ 551 else if (ResSourceIndex) 552 { 553 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE, 554 InitializerOp, NULL); 555 } 556#endif 557 break; 558 559 case 13: /* ResourceTag */ 560 561 UtAttachNamepathToOwner (Op, InitializerOp); 562 break; 563 564 565 case 14: /* Address Range */ 566 567 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 3, 0); 568 RsCreateBitField (InitializerOp, ACPI_RESTAG_MEMATTRIBUTES, 569 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 3); 570 break; 571 572 case 15: /* Type */ 573 574 RsSetFlagBits (&Descriptor->Address32.SpecificFlags, InitializerOp, 5, 0); 575 RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE, 576 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.SpecificFlags), 5); 577 break; 578 579 default: 580 581 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL); 582 break; 583 } 584 585 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 586 } 587 588 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS32) + 589 OptionIndex + StringLength; 590 return (Rnode); 591} 592 593 594/******************************************************************************* 595 * 596 * FUNCTION: RsDoDwordSpaceDescriptor 597 * 598 * PARAMETERS: Op - Parent resource descriptor parse node 599 * CurrentByteOffset - Offset into the resource template AML 600 * buffer (to track references to the desc) 601 * 602 * RETURN: Completed resource node 603 * 604 * DESCRIPTION: Construct a long "DwordSpace" descriptor 605 * 606 ******************************************************************************/ 607 608ASL_RESOURCE_NODE * 609RsDoDwordSpaceDescriptor ( 610 ACPI_PARSE_OBJECT *Op, 611 UINT32 CurrentByteOffset) 612{ 613 AML_RESOURCE *Descriptor; 614 ACPI_PARSE_OBJECT *InitializerOp; 615 ASL_RESOURCE_NODE *Rnode; 616 UINT8 *OptionalFields; 617 UINT16 StringLength = 0; 618 UINT32 OptionIndex = 0; 619 UINT32 i; 620 BOOLEAN ResSourceIndex = FALSE; 621 622 623 InitializerOp = Op->Asl.Child; 624 StringLength = RsGetStringDataLength (InitializerOp); 625 626 Rnode = RsAllocateResourceNode ( 627 sizeof (AML_RESOURCE_ADDRESS32) + 1 + StringLength); 628 629 Descriptor = Rnode->Buffer; 630 Descriptor->Address32.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS32; 631 632 /* 633 * Initial descriptor length -- may be enlarged if there are 634 * optional fields present 635 */ 636 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS32); 637 Descriptor->Address32.ResourceLength = (UINT16) 638 (sizeof (AML_RESOURCE_ADDRESS32) - 639 sizeof (AML_RESOURCE_LARGE_HEADER)); 640 641 /* Process all child initialization nodes */ 642 643 for (i = 0; InitializerOp; i++) 644 { 645 switch (i) 646 { 647 case 0: /* Resource Type */ 648 649 Descriptor->Address32.ResourceType = 650 (UINT8) InitializerOp->Asl.Value.Integer; 651 break; 652 653 case 1: /* Resource Usage */ 654 655 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 0, 1); 656 break; 657 658 case 2: /* DecodeType */ 659 660 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 1, 0); 661 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE, 662 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 1); 663 break; 664 665 case 3: /* MinType */ 666 667 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 2, 0); 668 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE, 669 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 2); 670 break; 671 672 case 4: /* MaxType */ 673 674 RsSetFlagBits (&Descriptor->Address32.Flags, InitializerOp, 3, 0); 675 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE, 676 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Flags), 3); 677 break; 678 679 case 5: /* Type-Specific flags */ 680 681 Descriptor->Address32.SpecificFlags = 682 (UINT8) InitializerOp->Asl.Value.Integer; 683 break; 684 685 case 6: /* Address Granularity */ 686 687 Descriptor->Address32.Granularity = 688 (UINT32) InitializerOp->Asl.Value.Integer; 689 RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY, 690 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Granularity)); 691 break; 692 693 case 7: /* Min Address */ 694 695 Descriptor->Address32.Minimum = 696 (UINT32) InitializerOp->Asl.Value.Integer; 697 RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR, 698 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Minimum)); 699 break; 700 701 case 8: /* Max Address */ 702 703 Descriptor->Address32.Maximum = 704 (UINT32) InitializerOp->Asl.Value.Integer; 705 RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR, 706 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.Maximum)); 707 break; 708 709 case 9: /* Translation Offset */ 710 711 Descriptor->Address32.TranslationOffset = 712 (UINT32) InitializerOp->Asl.Value.Integer; 713 RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION, 714 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.TranslationOffset)); 715 break; 716 717 case 10: /* Address Length */ 718 719 Descriptor->Address32.AddressLength = 720 (UINT32) InitializerOp->Asl.Value.Integer; 721 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH, 722 CurrentByteOffset + ASL_RESDESC_OFFSET (Address32.AddressLength)); 723 break; 724 725 case 11: /* ResSourceIndex [Optional Field - BYTE] */ 726 727 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 728 { 729 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer; 730 OptionIndex++; 731 Descriptor->Address32.ResourceLength++; 732 ResSourceIndex = TRUE; 733 } 734 break; 735 736 case 12: /* ResSource [Optional Field - STRING] */ 737 738 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) && 739 (InitializerOp->Asl.Value.String)) 740 { 741 if (StringLength) 742 { 743 Descriptor->Address32.ResourceLength = (UINT16) 744 (Descriptor->Address32.ResourceLength + StringLength); 745 746 strcpy ((char *) 747 &OptionalFields[OptionIndex], 748 InitializerOp->Asl.Value.String); 749 750 /* ResourceSourceIndex must also be valid */ 751 752 if (!ResSourceIndex) 753 { 754 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX, 755 InitializerOp, NULL); 756 } 757 } 758 } 759 760#if 0 761 /* 762 * Not a valid ResourceSource, ResourceSourceIndex must also 763 * be invalid 764 */ 765 else if (ResSourceIndex) 766 { 767 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE, 768 InitializerOp, NULL); 769 } 770#endif 771 break; 772 773 case 13: /* ResourceTag */ 774 775 UtAttachNamepathToOwner (Op, InitializerOp); 776 break; 777 778 default: 779 780 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, 781 InitializerOp, NULL); 782 break; 783 } 784 785 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 786 } 787 788 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS32) + 789 OptionIndex + StringLength; 790 return (Rnode); 791} 792 793 794/******************************************************************************* 795 * 796 * FUNCTION: RsDoExtendedIoDescriptor 797 * 798 * PARAMETERS: Op - Parent resource descriptor parse node 799 * CurrentByteOffset - Offset into the resource template AML 800 * buffer (to track references to the desc) 801 * 802 * RETURN: Completed resource node 803 * 804 * DESCRIPTION: Construct a long "ExtendedIO" descriptor 805 * 806 ******************************************************************************/ 807 808ASL_RESOURCE_NODE * 809RsDoExtendedIoDescriptor ( 810 ACPI_PARSE_OBJECT *Op, 811 UINT32 CurrentByteOffset) 812{ 813 AML_RESOURCE *Descriptor; 814 ACPI_PARSE_OBJECT *InitializerOp; 815 ASL_RESOURCE_NODE *Rnode; 816 UINT16 StringLength = 0; 817 UINT32 i; 818 819 820 InitializerOp = Op->Asl.Child; 821 StringLength = RsGetStringDataLength (InitializerOp); 822 823 Rnode = RsAllocateResourceNode ( 824 sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength); 825 826 Descriptor = Rnode->Buffer; 827 Descriptor->ExtAddress64.DescriptorType = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64; 828 Descriptor->ExtAddress64.ResourceType = ACPI_ADDRESS_TYPE_IO_RANGE; 829 Descriptor->ExtAddress64.RevisionID = AML_RESOURCE_EXTENDED_ADDRESS_REVISION; 830 831 Descriptor->ExtAddress64.ResourceLength = (UINT16) 832 (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) - 833 sizeof (AML_RESOURCE_LARGE_HEADER)); 834 835 /* Process all child initialization nodes */ 836 837 for (i = 0; InitializerOp; i++) 838 { 839 switch (i) 840 { 841 case 0: /* Resource Usage */ 842 843 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1); 844 break; 845 846 case 1: /* MinType */ 847 848 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0); 849 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE, 850 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2); 851 break; 852 853 case 2: /* MaxType */ 854 855 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0); 856 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE, 857 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3); 858 break; 859 860 case 3: /* DecodeType */ 861 862 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0); 863 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE, 864 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1); 865 break; 866 867 case 4: /* Range Type */ 868 869 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 0, 3); 870 RsCreateBitField (InitializerOp, ACPI_RESTAG_RANGETYPE, 871 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 0); 872 break; 873 874 case 5: /* Address Granularity */ 875 876 Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer; 877 RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY, 878 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity)); 879 break; 880 881 case 6: /* Address Min */ 882 883 Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer; 884 RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR, 885 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum)); 886 break; 887 888 case 7: /* Address Max */ 889 890 Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer; 891 RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR, 892 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum)); 893 break; 894 895 case 8: /* Translation Offset */ 896 897 Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer; 898 RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION, 899 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset)); 900 break; 901 902 case 9: /* Address Length */ 903 904 Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer; 905 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH, 906 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength)); 907 break; 908 909 case 10: /* Type-Specific Attributes */ 910 911 Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer; 912 RsCreateByteField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES, 913 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific)); 914 break; 915 916 case 11: /* ResourceTag */ 917 918 UtAttachNamepathToOwner (Op, InitializerOp); 919 break; 920 921 case 12: /* Type */ 922 923 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 4, 0); 924 RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE, 925 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 4); 926 break; 927 928 case 13: /* Translation Type */ 929 930 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 5, 0); 931 RsCreateBitField (InitializerOp, ACPI_RESTAG_TRANSTYPE, 932 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 5); 933 break; 934 935 default: 936 937 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL); 938 break; 939 } 940 941 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 942 } 943 944 Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + StringLength; 945 return (Rnode); 946} 947 948 949/******************************************************************************* 950 * 951 * FUNCTION: RsDoExtendedMemoryDescriptor 952 * 953 * PARAMETERS: Op - Parent resource descriptor parse node 954 * CurrentByteOffset - Offset into the resource template AML 955 * buffer (to track references to the desc) 956 * 957 * RETURN: Completed resource node 958 * 959 * DESCRIPTION: Construct a long "ExtendedMemory" descriptor 960 * 961 ******************************************************************************/ 962 963ASL_RESOURCE_NODE * 964RsDoExtendedMemoryDescriptor ( 965 ACPI_PARSE_OBJECT *Op, 966 UINT32 CurrentByteOffset) 967{ 968 AML_RESOURCE *Descriptor; 969 ACPI_PARSE_OBJECT *InitializerOp; 970 ASL_RESOURCE_NODE *Rnode; 971 UINT16 StringLength = 0; 972 UINT32 i; 973 974 975 InitializerOp = Op->Asl.Child; 976 StringLength = RsGetStringDataLength (InitializerOp); 977 978 Rnode = RsAllocateResourceNode ( 979 sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength); 980 981 Descriptor = Rnode->Buffer; 982 Descriptor->ExtAddress64.DescriptorType = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64; 983 Descriptor->ExtAddress64.ResourceType = ACPI_ADDRESS_TYPE_MEMORY_RANGE; 984 Descriptor->ExtAddress64.RevisionID = AML_RESOURCE_EXTENDED_ADDRESS_REVISION; 985 986 Descriptor->ExtAddress64.ResourceLength = (UINT16) 987 (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) - 988 sizeof (AML_RESOURCE_LARGE_HEADER)); 989 990 /* Process all child initialization nodes */ 991 992 for (i = 0; InitializerOp; i++) 993 { 994 switch (i) 995 { 996 case 0: /* Resource Usage */ 997 998 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1); 999 break; 1000 1001 case 1: /* DecodeType */ 1002 1003 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0); 1004 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE, 1005 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1); 1006 break; 1007 1008 case 2: /* MinType */ 1009 1010 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0); 1011 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE, 1012 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2); 1013 break; 1014 1015 case 3: /* MaxType */ 1016 1017 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0); 1018 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE, 1019 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3); 1020 break; 1021 1022 case 4: /* Memory Type */ 1023 1024 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 1, 0); 1025 RsCreateBitField (InitializerOp, ACPI_RESTAG_MEMTYPE, 1026 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 1); 1027 break; 1028 1029 case 5: /* Read/Write Type */ 1030 1031 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 0, 1); 1032 RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE, 1033 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 0); 1034 break; 1035 1036 case 6: /* Address Granularity */ 1037 1038 Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer; 1039 RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY, 1040 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity)); 1041 break; 1042 1043 case 7: /* Min Address */ 1044 1045 Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer; 1046 RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR, 1047 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum)); 1048 break; 1049 1050 case 8: /* Max Address */ 1051 1052 Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer; 1053 RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR, 1054 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum)); 1055 break; 1056 1057 case 9: /* Translation Offset */ 1058 1059 Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer; 1060 RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION, 1061 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset)); 1062 break; 1063 1064 case 10: /* Address Length */ 1065 1066 Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer; 1067 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH, 1068 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength)); 1069 break; 1070 1071 case 11: /* Type-Specific Attributes */ 1072 1073 Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer; 1074 RsCreateByteField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES, 1075 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific)); 1076 break; 1077 1078 case 12: /* ResourceTag */ 1079 1080 UtAttachNamepathToOwner (Op, InitializerOp); 1081 break; 1082 1083 1084 case 13: /* Address Range */ 1085 1086 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 3, 0); 1087 RsCreateBitField (InitializerOp, ACPI_RESTAG_MEMATTRIBUTES, 1088 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 3); 1089 break; 1090 1091 case 14: /* Type */ 1092 1093 RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 5, 0); 1094 RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE, 1095 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 5); 1096 break; 1097 1098 default: 1099 1100 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL); 1101 break; 1102 } 1103 1104 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 1105 } 1106 1107 Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + StringLength; 1108 return (Rnode); 1109} 1110 1111 1112/******************************************************************************* 1113 * 1114 * FUNCTION: RsDoExtendedSpaceDescriptor 1115 * 1116 * PARAMETERS: Op - Parent resource descriptor parse node 1117 * CurrentByteOffset - Offset into the resource template AML 1118 * buffer (to track references to the desc) 1119 * 1120 * RETURN: Completed resource node 1121 * 1122 * DESCRIPTION: Construct a long "ExtendedSpace" descriptor 1123 * 1124 ******************************************************************************/ 1125 1126ASL_RESOURCE_NODE * 1127RsDoExtendedSpaceDescriptor ( 1128 ACPI_PARSE_OBJECT *Op, 1129 UINT32 CurrentByteOffset) 1130{ 1131 AML_RESOURCE *Descriptor; 1132 ACPI_PARSE_OBJECT *InitializerOp; 1133 ASL_RESOURCE_NODE *Rnode; 1134 UINT16 StringLength = 0; 1135 UINT32 i; 1136 1137 1138 InitializerOp = Op->Asl.Child; 1139 StringLength = RsGetStringDataLength (InitializerOp); 1140 1141 Rnode = RsAllocateResourceNode ( 1142 sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength); 1143 1144 Descriptor = Rnode->Buffer; 1145 Descriptor->ExtAddress64.DescriptorType = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64; 1146 Descriptor->ExtAddress64.RevisionID = AML_RESOURCE_EXTENDED_ADDRESS_REVISION; 1147 1148 Descriptor->ExtAddress64.ResourceLength = (UINT16) 1149 (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) - 1150 sizeof (AML_RESOURCE_LARGE_HEADER)); 1151 1152 /* Process all child initialization nodes */ 1153 1154 for (i = 0; InitializerOp; i++) 1155 { 1156 switch (i) 1157 { 1158 case 0: /* Resource Type */ 1159 1160 Descriptor->ExtAddress64.ResourceType = 1161 (UINT8) InitializerOp->Asl.Value.Integer; 1162 break; 1163 1164 case 1: /* Resource Usage */ 1165 1166 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1); 1167 break; 1168 1169 case 2: /* DecodeType */ 1170 1171 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0); 1172 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE, 1173 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1); 1174 break; 1175 1176 case 3: /* MinType */ 1177 1178 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0); 1179 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE, 1180 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2); 1181 break; 1182 1183 case 4: /* MaxType */ 1184 1185 RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0); 1186 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE, 1187 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3); 1188 break; 1189 1190 case 5: /* Type-Specific flags */ 1191 1192 Descriptor->ExtAddress64.SpecificFlags = 1193 (UINT8) InitializerOp->Asl.Value.Integer; 1194 break; 1195 1196 case 6: /* Address Granularity */ 1197 1198 Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer; 1199 RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY, 1200 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity)); 1201 break; 1202 1203 case 7: /* Min Address */ 1204 1205 Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer; 1206 RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR, 1207 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum)); 1208 break; 1209 1210 case 8: /* Max Address */ 1211 1212 Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer; 1213 RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR, 1214 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum)); 1215 break; 1216 1217 case 9: /* Translation Offset */ 1218 1219 Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer; 1220 RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION, 1221 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset)); 1222 break; 1223 1224 case 10: /* Address Length */ 1225 1226 Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer; 1227 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH, 1228 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength)); 1229 break; 1230 1231 case 11: /* Type-Specific Attributes */ 1232 1233 Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer; 1234 RsCreateByteField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES, 1235 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific)); 1236 break; 1237 1238 case 12: /* ResourceTag */ 1239 1240 UtAttachNamepathToOwner (Op, InitializerOp); 1241 break; 1242 1243 default: 1244 1245 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL); 1246 break; 1247 } 1248 1249 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 1250 } 1251 1252 Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + StringLength; 1253 return (Rnode); 1254} 1255 1256 1257/******************************************************************************* 1258 * 1259 * FUNCTION: RsDoQwordIoDescriptor 1260 * 1261 * PARAMETERS: Op - Parent resource descriptor parse node 1262 * CurrentByteOffset - Offset into the resource template AML 1263 * buffer (to track references to the desc) 1264 * 1265 * RETURN: Completed resource node 1266 * 1267 * DESCRIPTION: Construct a long "QwordIO" descriptor 1268 * 1269 ******************************************************************************/ 1270 1271ASL_RESOURCE_NODE * 1272RsDoQwordIoDescriptor ( 1273 ACPI_PARSE_OBJECT *Op, 1274 UINT32 CurrentByteOffset) 1275{ 1276 AML_RESOURCE *Descriptor; 1277 ACPI_PARSE_OBJECT *InitializerOp; 1278 ASL_RESOURCE_NODE *Rnode; 1279 UINT8 *OptionalFields; 1280 UINT16 StringLength = 0; 1281 UINT32 OptionIndex = 0; 1282 UINT32 i; 1283 BOOLEAN ResSourceIndex = FALSE; 1284 1285 1286 InitializerOp = Op->Asl.Child; 1287 StringLength = RsGetStringDataLength (InitializerOp); 1288 1289 Rnode = RsAllocateResourceNode ( 1290 sizeof (AML_RESOURCE_ADDRESS64) + 1 + StringLength); 1291 1292 Descriptor = Rnode->Buffer; 1293 Descriptor->Address64.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS64; 1294 Descriptor->Address64.ResourceType = ACPI_ADDRESS_TYPE_IO_RANGE; 1295 1296 /* 1297 * Initial descriptor length -- may be enlarged if there are 1298 * optional fields present 1299 */ 1300 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS64); 1301 Descriptor->Address64.ResourceLength = (UINT16) 1302 (sizeof (AML_RESOURCE_ADDRESS64) - 1303 sizeof (AML_RESOURCE_LARGE_HEADER)); 1304 1305 /* Process all child initialization nodes */ 1306 1307 for (i = 0; InitializerOp; i++) 1308 { 1309 switch (i) 1310 { 1311 case 0: /* Resource Usage */ 1312 1313 RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 0, 1); 1314 break; 1315 1316 case 1: /* MinType */ 1317 1318 RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 2, 0); 1319 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE, 1320 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 2); 1321 break; 1322 1323 case 2: /* MaxType */ 1324 1325 RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 3, 0); 1326 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE, 1327 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 3); 1328 break; 1329 1330 case 3: /* DecodeType */ 1331 1332 RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 1, 0); 1333 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE, 1334 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 1); 1335 break; 1336 1337 case 4: /* Range Type */ 1338 1339 RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 0, 3); 1340 RsCreateBitField (InitializerOp, ACPI_RESTAG_RANGETYPE, 1341 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 0); 1342 break; 1343 1344 case 5: /* Address Granularity */ 1345 1346 Descriptor->Address64.Granularity = InitializerOp->Asl.Value.Integer; 1347 RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY, 1348 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Granularity)); 1349 break; 1350 1351 case 6: /* Address Min */ 1352 1353 Descriptor->Address64.Minimum = InitializerOp->Asl.Value.Integer; 1354 RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR, 1355 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Minimum)); 1356 break; 1357 1358 case 7: /* Address Max */ 1359 1360 Descriptor->Address64.Maximum = InitializerOp->Asl.Value.Integer; 1361 RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR, 1362 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Maximum)); 1363 break; 1364 1365 case 8: /* Translation Offset */ 1366 1367 Descriptor->Address64.TranslationOffset = InitializerOp->Asl.Value.Integer; 1368 RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION, 1369 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.TranslationOffset)); 1370 break; 1371 1372 case 9: /* Address Length */ 1373 1374 Descriptor->Address64.AddressLength = InitializerOp->Asl.Value.Integer; 1375 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH, 1376 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.AddressLength)); 1377 break; 1378 1379 case 10: /* ResSourceIndex [Optional Field - BYTE] */ 1380 1381 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 1382 { 1383 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer; 1384 OptionIndex++; 1385 Descriptor->Address64.ResourceLength++; 1386 ResSourceIndex = TRUE; 1387 } 1388 break; 1389 1390 case 11: /* ResSource [Optional Field - STRING] */ 1391 1392 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) && 1393 (InitializerOp->Asl.Value.String)) 1394 { 1395 if (StringLength) 1396 { 1397 Descriptor->Address64.ResourceLength = (UINT16) 1398 (Descriptor->Address64.ResourceLength + StringLength); 1399 1400 strcpy ((char *) 1401 &OptionalFields[OptionIndex], 1402 InitializerOp->Asl.Value.String); 1403 1404 /* ResourceSourceIndex must also be valid */ 1405 1406 if (!ResSourceIndex) 1407 { 1408 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX, 1409 InitializerOp, NULL); 1410 } 1411 } 1412 } 1413 1414#if 0 1415 /* 1416 * Not a valid ResourceSource, ResourceSourceIndex must also 1417 * be invalid 1418 */ 1419 else if (ResSourceIndex) 1420 { 1421 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE, 1422 InitializerOp, NULL); 1423 } 1424#endif 1425 break; 1426 1427 case 12: /* ResourceTag */ 1428 1429 UtAttachNamepathToOwner (Op, InitializerOp); 1430 break; 1431 1432 case 13: /* Type */ 1433 1434 RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 4, 0); 1435 RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE, 1436 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 4); 1437 break; 1438 1439 case 14: /* Translation Type */ 1440 1441 RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 5, 0); 1442 RsCreateBitField (InitializerOp, ACPI_RESTAG_TRANSTYPE, 1443 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 5); 1444 break; 1445 1446 default: 1447 1448 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL); 1449 break; 1450 } 1451 1452 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 1453 } 1454 1455 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS64) + 1456 OptionIndex + StringLength; 1457 return (Rnode); 1458} 1459 1460 1461/******************************************************************************* 1462 * 1463 * FUNCTION: RsDoQwordMemoryDescriptor 1464 * 1465 * PARAMETERS: Op - Parent resource descriptor parse node 1466 * CurrentByteOffset - Offset into the resource template AML 1467 * buffer (to track references to the desc) 1468 * 1469 * RETURN: Completed resource node 1470 * 1471 * DESCRIPTION: Construct a long "QwordMemory" descriptor 1472 * 1473 ******************************************************************************/ 1474 1475ASL_RESOURCE_NODE * 1476RsDoQwordMemoryDescriptor ( 1477 ACPI_PARSE_OBJECT *Op, 1478 UINT32 CurrentByteOffset) 1479{ 1480 AML_RESOURCE *Descriptor; 1481 ACPI_PARSE_OBJECT *InitializerOp; 1482 ASL_RESOURCE_NODE *Rnode; 1483 UINT8 *OptionalFields; 1484 UINT16 StringLength = 0; 1485 UINT32 OptionIndex = 0; 1486 UINT32 i; 1487 BOOLEAN ResSourceIndex = FALSE; 1488 1489 1490 InitializerOp = Op->Asl.Child; 1491 StringLength = RsGetStringDataLength (InitializerOp); 1492 1493 Rnode = RsAllocateResourceNode ( 1494 sizeof (AML_RESOURCE_ADDRESS64) + 1 + StringLength); 1495 1496 Descriptor = Rnode->Buffer; 1497 Descriptor->Address64.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS64; 1498 Descriptor->Address64.ResourceType = ACPI_ADDRESS_TYPE_MEMORY_RANGE; 1499 1500 /* 1501 * Initial descriptor length -- may be enlarged if there are 1502 * optional fields present 1503 */ 1504 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS64); 1505 Descriptor->Address64.ResourceLength = (UINT16) 1506 (sizeof (AML_RESOURCE_ADDRESS64) - 1507 sizeof (AML_RESOURCE_LARGE_HEADER)); 1508 1509 /* Process all child initialization nodes */ 1510 1511 for (i = 0; InitializerOp; i++) 1512 { 1513 switch (i) 1514 { 1515 case 0: /* Resource Usage */ 1516 1517 RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 0, 1); 1518 break; 1519 1520 case 1: /* DecodeType */ 1521 1522 RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 1, 0); 1523 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE, 1524 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 1); 1525 break; 1526 1527 case 2: /* MinType */ 1528 1529 RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 2, 0); 1530 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE, 1531 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 2); 1532 break; 1533 1534 case 3: /* MaxType */ 1535 1536 RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 3, 0); 1537 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE, 1538 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 3); 1539 break; 1540 1541 case 4: /* Memory Type */ 1542 1543 RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 1, 0); 1544 RsCreateBitField (InitializerOp, ACPI_RESTAG_MEMTYPE, 1545 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 1); 1546 break; 1547 1548 case 5: /* Read/Write Type */ 1549 1550 RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 0, 1); 1551 RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE, 1552 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 0); 1553 break; 1554 1555 case 6: /* Address Granularity */ 1556 1557 Descriptor->Address64.Granularity = InitializerOp->Asl.Value.Integer; 1558 RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY, 1559 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Granularity)); 1560 break; 1561 1562 case 7: /* Min Address */ 1563 1564 Descriptor->Address64.Minimum = InitializerOp->Asl.Value.Integer; 1565 RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR, 1566 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Minimum)); 1567 break; 1568 1569 case 8: /* Max Address */ 1570 1571 Descriptor->Address64.Maximum = InitializerOp->Asl.Value.Integer; 1572 RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR, 1573 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Maximum)); 1574 break; 1575 1576 case 9: /* Translation Offset */ 1577 1578 Descriptor->Address64.TranslationOffset = InitializerOp->Asl.Value.Integer; 1579 RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION, 1580 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.TranslationOffset)); 1581 break; 1582 1583 case 10: /* Address Length */ 1584 1585 Descriptor->Address64.AddressLength = InitializerOp->Asl.Value.Integer; 1586 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH, 1587 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.AddressLength)); 1588 break; 1589 1590 case 11: /* ResSourceIndex [Optional Field - BYTE] */ 1591 1592 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 1593 { 1594 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer; 1595 OptionIndex++; 1596 Descriptor->Address64.ResourceLength++; 1597 ResSourceIndex = TRUE; 1598 } 1599 break; 1600 1601 case 12: /* ResSource [Optional Field - STRING] */ 1602 1603 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) && 1604 (InitializerOp->Asl.Value.String)) 1605 { 1606 if (StringLength) 1607 { 1608 Descriptor->Address64.ResourceLength = (UINT16) 1609 (Descriptor->Address64.ResourceLength + StringLength); 1610 1611 strcpy ((char *) 1612 &OptionalFields[OptionIndex], 1613 InitializerOp->Asl.Value.String); 1614 1615 /* ResourceSourceIndex must also be valid */ 1616 1617 if (!ResSourceIndex) 1618 { 1619 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX, 1620 InitializerOp, NULL); 1621 } 1622 } 1623 } 1624 1625#if 0 1626 /* 1627 * Not a valid ResourceSource, ResourceSourceIndex must also 1628 * be invalid 1629 */ 1630 else if (ResSourceIndex) 1631 { 1632 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE, 1633 InitializerOp, NULL); 1634 } 1635#endif 1636 break; 1637 1638 case 13: /* ResourceTag */ 1639 1640 UtAttachNamepathToOwner (Op, InitializerOp); 1641 break; 1642 1643 1644 case 14: /* Address Range */ 1645 1646 RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 3, 0); 1647 RsCreateBitField (InitializerOp, ACPI_RESTAG_MEMATTRIBUTES, 1648 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 3); 1649 break; 1650 1651 case 15: /* Type */ 1652 1653 RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 5, 0); 1654 RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE, 1655 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 5); 1656 break; 1657 1658 default: 1659 1660 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL); 1661 break; 1662 } 1663 1664 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 1665 } 1666 1667 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS64) + 1668 OptionIndex + StringLength; 1669 return (Rnode); 1670} 1671 1672 1673/******************************************************************************* 1674 * 1675 * FUNCTION: RsDoQwordSpaceDescriptor 1676 * 1677 * PARAMETERS: Op - Parent resource descriptor parse node 1678 * CurrentByteOffset - Offset into the resource template AML 1679 * buffer (to track references to the desc) 1680 * 1681 * RETURN: Completed resource node 1682 * 1683 * DESCRIPTION: Construct a long "QwordSpace" descriptor 1684 * 1685 ******************************************************************************/ 1686 1687ASL_RESOURCE_NODE * 1688RsDoQwordSpaceDescriptor ( 1689 ACPI_PARSE_OBJECT *Op, 1690 UINT32 CurrentByteOffset) 1691{ 1692 AML_RESOURCE *Descriptor; 1693 ACPI_PARSE_OBJECT *InitializerOp; 1694 ASL_RESOURCE_NODE *Rnode; 1695 UINT8 *OptionalFields; 1696 UINT16 StringLength = 0; 1697 UINT32 OptionIndex = 0; 1698 UINT32 i; 1699 BOOLEAN ResSourceIndex = FALSE; 1700 1701 1702 InitializerOp = Op->Asl.Child; 1703 StringLength = RsGetStringDataLength (InitializerOp); 1704 1705 Rnode = RsAllocateResourceNode ( 1706 sizeof (AML_RESOURCE_ADDRESS64) + 1 + StringLength); 1707 1708 Descriptor = Rnode->Buffer; 1709 Descriptor->Address64.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS64; 1710 1711 /* 1712 * Initial descriptor length -- may be enlarged if there are 1713 * optional fields present 1714 */ 1715 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS64); 1716 Descriptor->Address64.ResourceLength = (UINT16) 1717 (sizeof (AML_RESOURCE_ADDRESS64) - 1718 sizeof (AML_RESOURCE_LARGE_HEADER)); 1719 1720 /* Process all child initialization nodes */ 1721 1722 for (i = 0; InitializerOp; i++) 1723 { 1724 switch (i) 1725 { 1726 case 0: /* Resource Type */ 1727 1728 Descriptor->Address64.ResourceType = 1729 (UINT8) InitializerOp->Asl.Value.Integer; 1730 break; 1731 1732 case 1: /* Resource Usage */ 1733 1734 RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 0, 1); 1735 break; 1736 1737 case 2: /* DecodeType */ 1738 1739 RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 1, 0); 1740 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE, 1741 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 1); 1742 break; 1743 1744 case 3: /* MinType */ 1745 1746 RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 2, 0); 1747 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE, 1748 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 2); 1749 break; 1750 1751 case 4: /* MaxType */ 1752 1753 RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 3, 0); 1754 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE, 1755 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 3); 1756 break; 1757 1758 case 5: /* Type-Specific flags */ 1759 1760 Descriptor->Address64.SpecificFlags = 1761 (UINT8) InitializerOp->Asl.Value.Integer; 1762 break; 1763 1764 case 6: /* Address Granularity */ 1765 1766 Descriptor->Address64.Granularity = InitializerOp->Asl.Value.Integer; 1767 RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY, 1768 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Granularity)); 1769 break; 1770 1771 case 7: /* Min Address */ 1772 1773 Descriptor->Address64.Minimum = InitializerOp->Asl.Value.Integer; 1774 RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR, 1775 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Minimum)); 1776 break; 1777 1778 case 8: /* Max Address */ 1779 1780 Descriptor->Address64.Maximum = InitializerOp->Asl.Value.Integer; 1781 RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR, 1782 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Maximum)); 1783 break; 1784 1785 case 9: /* Translation Offset */ 1786 1787 Descriptor->Address64.TranslationOffset = InitializerOp->Asl.Value.Integer; 1788 RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION, 1789 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.TranslationOffset)); 1790 break; 1791 1792 case 10: /* Address Length */ 1793 1794 Descriptor->Address64.AddressLength = InitializerOp->Asl.Value.Integer; 1795 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH, 1796 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.AddressLength)); 1797 break; 1798 1799 case 11: /* ResSourceIndex [Optional Field - BYTE] */ 1800 1801 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 1802 { 1803 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer; 1804 OptionIndex++; 1805 Descriptor->Address64.ResourceLength++; 1806 ResSourceIndex = TRUE; 1807 } 1808 break; 1809 1810 case 12: /* ResSource [Optional Field - STRING] */ 1811 1812 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) && 1813 (InitializerOp->Asl.Value.String)) 1814 { 1815 if (StringLength) 1816 { 1817 Descriptor->Address64.ResourceLength = (UINT16) 1818 (Descriptor->Address64.ResourceLength + StringLength); 1819 1820 strcpy ((char *) 1821 &OptionalFields[OptionIndex], 1822 InitializerOp->Asl.Value.String); 1823 1824 /* ResourceSourceIndex must also be valid */ 1825 1826 if (!ResSourceIndex) 1827 { 1828 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX, 1829 InitializerOp, NULL); 1830 } 1831 } 1832 } 1833 1834#if 0 1835 /* 1836 * Not a valid ResourceSource, ResourceSourceIndex must also 1837 * be invalid 1838 */ 1839 else if (ResSourceIndex) 1840 { 1841 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE, 1842 InitializerOp, NULL); 1843 } 1844#endif 1845 break; 1846 1847 case 13: /* ResourceTag */ 1848 1849 UtAttachNamepathToOwner (Op, InitializerOp); 1850 break; 1851 1852 default: 1853 1854 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL); 1855 break; 1856 } 1857 1858 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 1859 } 1860 1861 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS64) + 1862 OptionIndex + StringLength; 1863 return (Rnode); 1864} 1865 1866 1867/******************************************************************************* 1868 * 1869 * FUNCTION: RsDoWordIoDescriptor 1870 * 1871 * PARAMETERS: Op - Parent resource descriptor parse node 1872 * CurrentByteOffset - Offset into the resource template AML 1873 * buffer (to track references to the desc) 1874 * 1875 * RETURN: Completed resource node 1876 * 1877 * DESCRIPTION: Construct a long "WordIO" descriptor 1878 * 1879 ******************************************************************************/ 1880 1881ASL_RESOURCE_NODE * 1882RsDoWordIoDescriptor ( 1883 ACPI_PARSE_OBJECT *Op, 1884 UINT32 CurrentByteOffset) 1885{ 1886 AML_RESOURCE *Descriptor; 1887 ACPI_PARSE_OBJECT *InitializerOp; 1888 ASL_RESOURCE_NODE *Rnode; 1889 UINT8 *OptionalFields; 1890 UINT16 StringLength = 0; 1891 UINT32 OptionIndex = 0; 1892 UINT32 i; 1893 BOOLEAN ResSourceIndex = FALSE; 1894 1895 1896 InitializerOp = Op->Asl.Child; 1897 StringLength = RsGetStringDataLength (InitializerOp); 1898 1899 Rnode = RsAllocateResourceNode ( 1900 sizeof (AML_RESOURCE_ADDRESS16) + 1 + StringLength); 1901 1902 Descriptor = Rnode->Buffer; 1903 Descriptor->Address16.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS16; 1904 Descriptor->Address16.ResourceType = ACPI_ADDRESS_TYPE_IO_RANGE; 1905 1906 /* 1907 * Initial descriptor length -- may be enlarged if there are 1908 * optional fields present 1909 */ 1910 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS16); 1911 Descriptor->Address16.ResourceLength = (UINT16) 1912 (sizeof (AML_RESOURCE_ADDRESS16) - 1913 sizeof (AML_RESOURCE_LARGE_HEADER)); 1914 1915 /* Process all child initialization nodes */ 1916 1917 for (i = 0; InitializerOp; i++) 1918 { 1919 switch (i) 1920 { 1921 case 0: /* Resource Usage */ 1922 1923 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 0, 1); 1924 break; 1925 1926 case 1: /* MinType */ 1927 1928 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 2, 0); 1929 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE, 1930 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 2); 1931 break; 1932 1933 case 2: /* MaxType */ 1934 1935 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 3, 0); 1936 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE, 1937 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 3); 1938 break; 1939 1940 case 3: /* DecodeType */ 1941 1942 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 1, 0); 1943 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE, 1944 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 1); 1945 break; 1946 1947 case 4: /* Range Type */ 1948 1949 RsSetFlagBits (&Descriptor->Address16.SpecificFlags, InitializerOp, 0, 3); 1950 RsCreateBitField (InitializerOp, ACPI_RESTAG_RANGETYPE, 1951 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.SpecificFlags), 0); 1952 break; 1953 1954 case 5: /* Address Granularity */ 1955 1956 Descriptor->Address16.Granularity = (UINT16) InitializerOp->Asl.Value.Integer; 1957 RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY, 1958 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Granularity)); 1959 break; 1960 1961 case 6: /* Address Min */ 1962 1963 Descriptor->Address16.Minimum = (UINT16) InitializerOp->Asl.Value.Integer; 1964 RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR, 1965 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Minimum)); 1966 break; 1967 1968 case 7: /* Address Max */ 1969 1970 Descriptor->Address16.Maximum = (UINT16) InitializerOp->Asl.Value.Integer; 1971 RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR, 1972 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Maximum)); 1973 break; 1974 1975 case 8: /* Translation Offset */ 1976 1977 Descriptor->Address16.TranslationOffset = (UINT16) InitializerOp->Asl.Value.Integer; 1978 RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION, 1979 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.TranslationOffset)); 1980 break; 1981 1982 case 9: /* Address Length */ 1983 1984 Descriptor->Address16.AddressLength = (UINT16) InitializerOp->Asl.Value.Integer; 1985 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH, 1986 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.AddressLength)); 1987 break; 1988 1989 case 10: /* ResSourceIndex [Optional Field - BYTE] */ 1990 1991 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 1992 { 1993 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer; 1994 OptionIndex++; 1995 Descriptor->Address16.ResourceLength++; 1996 ResSourceIndex = TRUE; 1997 } 1998 break; 1999 2000 case 11: /* ResSource [Optional Field - STRING] */ 2001 2002 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) && 2003 (InitializerOp->Asl.Value.String)) 2004 { 2005 if (StringLength) 2006 { 2007 Descriptor->Address16.ResourceLength = (UINT16) 2008 (Descriptor->Address16.ResourceLength + StringLength); 2009 2010 strcpy ((char *) 2011 &OptionalFields[OptionIndex], 2012 InitializerOp->Asl.Value.String); 2013 2014 /* ResourceSourceIndex must also be valid */ 2015 2016 if (!ResSourceIndex) 2017 { 2018 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX, 2019 InitializerOp, NULL); 2020 } 2021 } 2022 } 2023 2024#if 0 2025 /* 2026 * Not a valid ResourceSource, ResourceSourceIndex must also 2027 * be invalid 2028 */ 2029 else if (ResSourceIndex) 2030 { 2031 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE, 2032 InitializerOp, NULL); 2033 } 2034#endif 2035 break; 2036 2037 case 12: /* ResourceTag */ 2038 2039 UtAttachNamepathToOwner (Op, InitializerOp); 2040 break; 2041 2042 case 13: /* Type */ 2043 2044 RsSetFlagBits (&Descriptor->Address16.SpecificFlags, InitializerOp, 4, 0); 2045 RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE, 2046 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.SpecificFlags), 4); 2047 break; 2048 2049 case 14: /* Translation Type */ 2050 2051 RsSetFlagBits (&Descriptor->Address16.SpecificFlags, InitializerOp, 5, 0); 2052 RsCreateBitField (InitializerOp, ACPI_RESTAG_TRANSTYPE, 2053 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.SpecificFlags), 5); 2054 break; 2055 2056 default: 2057 2058 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL); 2059 break; 2060 } 2061 2062 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 2063 } 2064 2065 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS16) + 2066 OptionIndex + StringLength; 2067 return (Rnode); 2068} 2069 2070 2071/******************************************************************************* 2072 * 2073 * FUNCTION: RsDoWordBusNumberDescriptor 2074 * 2075 * PARAMETERS: Op - Parent resource descriptor parse node 2076 * CurrentByteOffset - Offset into the resource template AML 2077 * buffer (to track references to the desc) 2078 * 2079 * RETURN: Completed resource node 2080 * 2081 * DESCRIPTION: Construct a long "WordBusNumber" descriptor 2082 * 2083 ******************************************************************************/ 2084 2085ASL_RESOURCE_NODE * 2086RsDoWordBusNumberDescriptor ( 2087 ACPI_PARSE_OBJECT *Op, 2088 UINT32 CurrentByteOffset) 2089{ 2090 AML_RESOURCE *Descriptor; 2091 ACPI_PARSE_OBJECT *InitializerOp; 2092 ASL_RESOURCE_NODE *Rnode; 2093 UINT8 *OptionalFields; 2094 UINT16 StringLength = 0; 2095 UINT32 OptionIndex = 0; 2096 UINT32 i; 2097 BOOLEAN ResSourceIndex = FALSE; 2098 2099 2100 InitializerOp = Op->Asl.Child; 2101 StringLength = RsGetStringDataLength (InitializerOp); 2102 2103 Rnode = RsAllocateResourceNode ( 2104 sizeof (AML_RESOURCE_ADDRESS16) + 1 + StringLength); 2105 2106 Descriptor = Rnode->Buffer; 2107 Descriptor->Address16.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS16; 2108 Descriptor->Address16.ResourceType = ACPI_ADDRESS_TYPE_BUS_NUMBER_RANGE; 2109 2110 /* 2111 * Initial descriptor length -- may be enlarged if there are 2112 * optional fields present 2113 */ 2114 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS16); 2115 Descriptor->Address16.ResourceLength = (UINT16) 2116 (sizeof (AML_RESOURCE_ADDRESS16) - 2117 sizeof (AML_RESOURCE_LARGE_HEADER)); 2118 2119 /* Process all child initialization nodes */ 2120 2121 for (i = 0; InitializerOp; i++) 2122 { 2123 switch (i) 2124 { 2125 case 0: /* Resource Usage */ 2126 2127 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 0, 1); 2128 break; 2129 2130 case 1: /* MinType */ 2131 2132 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 2, 0); 2133 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE, 2134 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 2); 2135 break; 2136 2137 case 2: /* MaxType */ 2138 2139 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 3, 0); 2140 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE, 2141 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 3); 2142 break; 2143 2144 case 3: /* DecodeType */ 2145 2146 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 1, 0); 2147 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE, 2148 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 1); 2149 break; 2150 2151 case 4: /* Address Granularity */ 2152 2153 Descriptor->Address16.Granularity = 2154 (UINT16) InitializerOp->Asl.Value.Integer; 2155 RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY, 2156 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Granularity)); 2157 break; 2158 2159 case 5: /* Min Address */ 2160 2161 Descriptor->Address16.Minimum = 2162 (UINT16) InitializerOp->Asl.Value.Integer; 2163 RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR, 2164 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Minimum)); 2165 break; 2166 2167 case 6: /* Max Address */ 2168 2169 Descriptor->Address16.Maximum = 2170 (UINT16) InitializerOp->Asl.Value.Integer; 2171 RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR, 2172 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Maximum)); 2173 break; 2174 2175 case 7: /* Translation Offset */ 2176 2177 Descriptor->Address16.TranslationOffset = 2178 (UINT16) InitializerOp->Asl.Value.Integer; 2179 RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION, 2180 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.TranslationOffset)); 2181 break; 2182 2183 case 8: /* Address Length */ 2184 2185 Descriptor->Address16.AddressLength = 2186 (UINT16) InitializerOp->Asl.Value.Integer; 2187 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH, 2188 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.AddressLength)); 2189 break; 2190 2191 case 9: /* ResSourceIndex [Optional Field - BYTE] */ 2192 2193 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 2194 { 2195 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer; 2196 OptionIndex++; 2197 Descriptor->Address16.ResourceLength++; 2198 ResSourceIndex = TRUE; 2199 } 2200 break; 2201 2202 case 10: /* ResSource [Optional Field - STRING] */ 2203 2204 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) && 2205 (InitializerOp->Asl.Value.String)) 2206 { 2207 if (StringLength) 2208 { 2209 Descriptor->Address16.ResourceLength = (UINT16) 2210 (Descriptor->Address16.ResourceLength + StringLength); 2211 2212 strcpy ((char *) 2213 &OptionalFields[OptionIndex], 2214 InitializerOp->Asl.Value.String); 2215 2216 /* ResourceSourceIndex must also be valid */ 2217 2218 if (!ResSourceIndex) 2219 { 2220 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX, 2221 InitializerOp, NULL); 2222 } 2223 } 2224 } 2225 2226#if 0 2227 /* 2228 * Not a valid ResourceSource, ResourceSourceIndex must also 2229 * be invalid 2230 */ 2231 else if (ResSourceIndex) 2232 { 2233 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE, 2234 InitializerOp, NULL); 2235 } 2236#endif 2237 break; 2238 2239 case 11: /* ResourceTag */ 2240 2241 UtAttachNamepathToOwner (Op, InitializerOp); 2242 break; 2243 2244 default: 2245 2246 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL); 2247 break; 2248 } 2249 2250 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 2251 } 2252 2253 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS16) + 2254 OptionIndex + StringLength; 2255 return (Rnode); 2256} 2257 2258 2259/******************************************************************************* 2260 * 2261 * FUNCTION: RsDoWordSpaceDescriptor 2262 * 2263 * PARAMETERS: Op - Parent resource descriptor parse node 2264 * CurrentByteOffset - Offset into the resource template AML 2265 * buffer (to track references to the desc) 2266 * 2267 * RETURN: Completed resource node 2268 * 2269 * DESCRIPTION: Construct a long "WordSpace" descriptor 2270 * 2271 ******************************************************************************/ 2272 2273ASL_RESOURCE_NODE * 2274RsDoWordSpaceDescriptor ( 2275 ACPI_PARSE_OBJECT *Op, 2276 UINT32 CurrentByteOffset) 2277{ 2278 AML_RESOURCE *Descriptor; 2279 ACPI_PARSE_OBJECT *InitializerOp; 2280 ASL_RESOURCE_NODE *Rnode; 2281 UINT8 *OptionalFields; 2282 UINT16 StringLength = 0; 2283 UINT32 OptionIndex = 0; 2284 UINT32 i; 2285 BOOLEAN ResSourceIndex = FALSE; 2286 2287 2288 InitializerOp = Op->Asl.Child; 2289 StringLength = RsGetStringDataLength (InitializerOp); 2290 2291 Rnode = RsAllocateResourceNode ( 2292 sizeof (AML_RESOURCE_ADDRESS16) + 1 + StringLength); 2293 2294 Descriptor = Rnode->Buffer; 2295 Descriptor->Address16.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS16; 2296 2297 /* 2298 * Initial descriptor length -- may be enlarged if there are 2299 * optional fields present 2300 */ 2301 OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS16); 2302 Descriptor->Address16.ResourceLength = (UINT16) 2303 (sizeof (AML_RESOURCE_ADDRESS16) - 2304 sizeof (AML_RESOURCE_LARGE_HEADER)); 2305 2306 /* Process all child initialization nodes */ 2307 2308 for (i = 0; InitializerOp; i++) 2309 { 2310 switch (i) 2311 { 2312 case 0: /* Resource Type */ 2313 2314 Descriptor->Address16.ResourceType = 2315 (UINT8) InitializerOp->Asl.Value.Integer; 2316 break; 2317 2318 case 1: /* Resource Usage */ 2319 2320 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 0, 1); 2321 break; 2322 2323 case 2: /* DecodeType */ 2324 2325 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 1, 0); 2326 RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE, 2327 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 1); 2328 break; 2329 2330 case 3: /* MinType */ 2331 2332 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 2, 0); 2333 RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE, 2334 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 2); 2335 break; 2336 2337 case 4: /* MaxType */ 2338 2339 RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 3, 0); 2340 RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE, 2341 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 3); 2342 break; 2343 2344 case 5: /* Type-Specific flags */ 2345 2346 Descriptor->Address16.SpecificFlags = 2347 (UINT8) InitializerOp->Asl.Value.Integer; 2348 break; 2349 2350 case 6: /* Address Granularity */ 2351 2352 Descriptor->Address16.Granularity = 2353 (UINT16) InitializerOp->Asl.Value.Integer; 2354 RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY, 2355 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Granularity)); 2356 break; 2357 2358 case 7: /* Min Address */ 2359 2360 Descriptor->Address16.Minimum = 2361 (UINT16) InitializerOp->Asl.Value.Integer; 2362 RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR, 2363 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Minimum)); 2364 break; 2365 2366 case 8: /* Max Address */ 2367 2368 Descriptor->Address16.Maximum = 2369 (UINT16) InitializerOp->Asl.Value.Integer; 2370 RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR, 2371 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Maximum)); 2372 break; 2373 2374 case 9: /* Translation Offset */ 2375 2376 Descriptor->Address16.TranslationOffset = 2377 (UINT16) InitializerOp->Asl.Value.Integer; 2378 RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION, 2379 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.TranslationOffset)); 2380 break; 2381 2382 case 10: /* Address Length */ 2383 2384 Descriptor->Address16.AddressLength = 2385 (UINT16) InitializerOp->Asl.Value.Integer; 2386 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH, 2387 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.AddressLength)); 2388 break; 2389 2390 case 11: /* ResSourceIndex [Optional Field - BYTE] */ 2391 2392 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 2393 { 2394 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer; 2395 OptionIndex++; 2396 Descriptor->Address16.ResourceLength++; 2397 ResSourceIndex = TRUE; 2398 } 2399 break; 2400 2401 case 12: /* ResSource [Optional Field - STRING] */ 2402 2403 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) && 2404 (InitializerOp->Asl.Value.String)) 2405 { 2406 if (StringLength) 2407 { 2408 Descriptor->Address16.ResourceLength = (UINT16) 2409 (Descriptor->Address16.ResourceLength + StringLength); 2410 2411 strcpy ((char *) 2412 &OptionalFields[OptionIndex], 2413 InitializerOp->Asl.Value.String); 2414 2415 /* ResourceSourceIndex must also be valid */ 2416 2417 if (!ResSourceIndex) 2418 { 2419 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX, 2420 InitializerOp, NULL); 2421 } 2422 } 2423 } 2424 2425#if 0 2426 /* 2427 * Not a valid ResourceSource, ResourceSourceIndex must also 2428 * be invalid 2429 */ 2430 else if (ResSourceIndex) 2431 { 2432 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE, 2433 InitializerOp, NULL); 2434 } 2435#endif 2436 break; 2437 2438 case 13: /* ResourceTag */ 2439 2440 UtAttachNamepathToOwner (Op, InitializerOp); 2441 break; 2442 2443 default: 2444 2445 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL); 2446 break; 2447 } 2448 2449 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 2450 } 2451 2452 Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS16) + 2453 OptionIndex + StringLength; 2454 return (Rnode); 2455} 2456 2457 2458/******************************************************************************* 2459 * 2460 * FUNCTION: RsDoInterruptDescriptor 2461 * 2462 * PARAMETERS: Op - Parent resource descriptor parse node 2463 * CurrentByteOffset - Offset into the resource template AML 2464 * buffer (to track references to the desc) 2465 * 2466 * RETURN: Completed resource node 2467 * 2468 * DESCRIPTION: Construct a long "Interrupt" descriptor 2469 * 2470 ******************************************************************************/ 2471 2472ASL_RESOURCE_NODE * 2473RsDoInterruptDescriptor ( 2474 ACPI_PARSE_OBJECT *Op, 2475 UINT32 CurrentByteOffset) 2476{ 2477 AML_RESOURCE *Descriptor; 2478 AML_RESOURCE *Rover = NULL; 2479 ACPI_PARSE_OBJECT *InitializerOp; 2480 ASL_RESOURCE_NODE *Rnode; 2481 UINT16 StringLength = 0; 2482 UINT32 OptionIndex = 0; 2483 UINT32 i; 2484 BOOLEAN HasResSourceIndex = FALSE; 2485 UINT8 ResSourceIndex = 0; 2486 UINT8 *ResSourceString = NULL; 2487 2488 2489 InitializerOp = Op->Asl.Child; 2490 StringLength = RsGetStringDataLength (InitializerOp); 2491 if (StringLength) 2492 { 2493 /* Make room for the ResourceSourceIndex */ 2494 2495 OptionIndex++; 2496 } 2497 2498 /* Count the interrupt numbers */ 2499 2500 for (i = 0; InitializerOp; i++) 2501 { 2502 InitializerOp = ASL_GET_PEER_NODE (InitializerOp); 2503 if (i <= 6) 2504 { 2505 continue; 2506 } 2507 2508 OptionIndex += 4; 2509 } 2510 2511 InitializerOp = Op->Asl.Child; 2512 Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_EXTENDED_IRQ) + 2513 1 + OptionIndex + StringLength); 2514 2515 Descriptor = Rnode->Buffer; 2516 Descriptor->ExtendedIrq.DescriptorType = ACPI_RESOURCE_NAME_EXTENDED_IRQ; 2517 2518 /* 2519 * Initial descriptor length -- may be enlarged if there are 2520 * optional fields present 2521 */ 2522 Descriptor->ExtendedIrq.ResourceLength = 2; /* Flags and table length byte */ 2523 Descriptor->ExtendedIrq.InterruptCount = 0; 2524 2525 Rover = ACPI_CAST_PTR (AML_RESOURCE, 2526 (&(Descriptor->ExtendedIrq.Interrupts[0]))); 2527 2528 /* Process all child initialization nodes */ 2529 2530 for (i = 0; InitializerOp; i++) 2531 { 2532 switch (i) 2533 { 2534 case 0: /* Resource Usage (Default: consumer (1) */ 2535 2536 RsSetFlagBits (&Descriptor->ExtendedIrq.Flags, InitializerOp, 0, 1); 2537 break; 2538 2539 case 1: /* Interrupt Type (or Mode - edge/level) */ 2540 2541 RsSetFlagBits (&Descriptor->ExtendedIrq.Flags, InitializerOp, 1, 0); 2542 RsCreateBitField (InitializerOp, ACPI_RESTAG_INTERRUPTTYPE, 2543 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtendedIrq.Flags), 1); 2544 break; 2545 2546 case 2: /* Interrupt Level (or Polarity - Active high/low) */ 2547 2548 RsSetFlagBits (&Descriptor->ExtendedIrq.Flags, InitializerOp, 2, 0); 2549 RsCreateBitField (InitializerOp, ACPI_RESTAG_INTERRUPTLEVEL, 2550 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtendedIrq.Flags), 2); 2551 break; 2552 2553 case 3: /* Share Type - Default: exclusive (0) */ 2554 2555 RsSetFlagBits (&Descriptor->ExtendedIrq.Flags, InitializerOp, 3, 0); 2556 RsCreateBitField (InitializerOp, ACPI_RESTAG_INTERRUPTSHARE, 2557 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtendedIrq.Flags), 3); 2558 break; 2559 2560 case 4: /* ResSourceIndex [Optional Field - BYTE] */ 2561 2562 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) 2563 { 2564 HasResSourceIndex = TRUE; 2565 ResSourceIndex = (UINT8) InitializerOp->Asl.Value.Integer; 2566 } 2567 break; 2568 2569 case 5: /* ResSource [Optional Field - STRING] */ 2570 2571 if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) && 2572 (InitializerOp->Asl.Value.String)) 2573 { 2574 if (StringLength) 2575 { 2576 ResSourceString = (UINT8 *) InitializerOp->Asl.Value.String; 2577 } 2578 2579 /* ResourceSourceIndex must also be valid */ 2580 2581 if (!HasResSourceIndex) 2582 { 2583 AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX, 2584 InitializerOp, NULL); 2585 } 2586 } 2587 2588#if 0 2589 /* 2590 * Not a valid ResourceSource, ResourceSourceIndex must also 2591 * be invalid 2592 */ 2593 else if (HasResSourceIndex) 2594 { 2595 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE, 2596 InitializerOp, NULL); 2597 } 2598#endif 2599 break; 2600 2601 case 6: /* ResourceTag */ 2602 2603 UtAttachNamepathToOwner (Op, InitializerOp); 2604 break; 2605 2606 default: 2607 /* 2608 * Interrupt Numbers come through here, repeatedly 2609 */ 2610 2611 /* Maximum 255 interrupts allowed for this descriptor */ 2612 2613 if (Descriptor->ExtendedIrq.InterruptCount == 255) 2614 { 2615 AslError (ASL_ERROR, ASL_MSG_EX_INTERRUPT_LIST, 2616 InitializerOp, NULL); 2617 return (Rnode); 2618 } 2619 2620 /* Each interrupt number must be a 32-bit value */ 2621 2622 if (InitializerOp->Asl.Value.Integer > ACPI_UINT32_MAX) 2623 { 2624 AslError (ASL_ERROR, ASL_MSG_EX_INTERRUPT_NUMBER, 2625 InitializerOp, NULL); 2626 } 2627 2628 /* Save the integer and move pointer to the next one */ 2629 2630 Rover->DwordItem = (UINT32) InitializerOp->Asl.Value.Integer; 2631 Rover = ACPI_ADD_PTR (AML_RESOURCE, &(Rover->DwordItem), 4); 2632 Descriptor->ExtendedIrq.InterruptCount++; 2633 Descriptor->ExtendedIrq.ResourceLength += 4; 2634 2635 /* Case 7: First interrupt number in list */ 2636 2637 if (i == 7) 2638 { 2639 /* Check now for duplicates in list */ 2640 2641 RsCheckListForDuplicates (InitializerOp); 2642 2643 /* Create a named field at the start of the list */ 2644 2645 RsCreateByteField (InitializerOp, ACPI_RESTAG_INTERRUPT, 2646 CurrentByteOffset + 2647 ASL_RESDESC_OFFSET (ExtendedIrq.Interrupts[0])); 2648 } 2649 } 2650 2651 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 2652 } 2653 2654 2655 /* Add optional ResSourceIndex if present */ 2656 2657 if (HasResSourceIndex) 2658 { 2659 Rover->ByteItem = ResSourceIndex; 2660 Rover = ACPI_ADD_PTR (AML_RESOURCE, &(Rover->ByteItem), 1); 2661 Descriptor->ExtendedIrq.ResourceLength += 1; 2662 } 2663 2664 /* Add optional ResSource string if present */ 2665 2666 if (StringLength && ResSourceString) 2667 { 2668 2669 strcpy ((char *) Rover, (char *) ResSourceString); 2670 Rover = ACPI_ADD_PTR ( 2671 AML_RESOURCE, &(Rover->ByteItem), StringLength); 2672 2673 Descriptor->ExtendedIrq.ResourceLength = (UINT16) 2674 (Descriptor->ExtendedIrq.ResourceLength + StringLength); 2675 } 2676 2677 Rnode->BufferLength = (ASL_RESDESC_OFFSET (ExtendedIrq.Interrupts[0]) - 2678 ASL_RESDESC_OFFSET (ExtendedIrq.DescriptorType)) 2679 + OptionIndex + StringLength; 2680 return (Rnode); 2681} 2682 2683 2684/******************************************************************************* 2685 * 2686 * FUNCTION: RsDoVendorLargeDescriptor 2687 * 2688 * PARAMETERS: Op - Parent resource descriptor parse node 2689 * CurrentByteOffset - Offset into the resource template AML 2690 * buffer (to track references to the desc) 2691 * 2692 * RETURN: Completed resource node 2693 * 2694 * DESCRIPTION: Construct a long "VendorLong" descriptor 2695 * 2696 ******************************************************************************/ 2697 2698ASL_RESOURCE_NODE * 2699RsDoVendorLargeDescriptor ( 2700 ACPI_PARSE_OBJECT *Op, 2701 UINT32 CurrentByteOffset) 2702{ 2703 AML_RESOURCE *Descriptor; 2704 ACPI_PARSE_OBJECT *InitializerOp; 2705 ASL_RESOURCE_NODE *Rnode; 2706 UINT8 *VendorData; 2707 UINT32 i; 2708 2709 2710 /* Count the number of data bytes */ 2711 2712 InitializerOp = Op->Asl.Child; 2713 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 2714 2715 for (i = 0; InitializerOp; i++) 2716 { 2717 if (InitializerOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG) 2718 { 2719 break; 2720 } 2721 InitializerOp = InitializerOp->Asl.Next; 2722 } 2723 2724 InitializerOp = Op->Asl.Child; 2725 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 2726 Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_VENDOR_LARGE) + i); 2727 2728 Descriptor = Rnode->Buffer; 2729 Descriptor->VendorLarge.DescriptorType = ACPI_RESOURCE_NAME_VENDOR_LARGE; 2730 Descriptor->VendorLarge.ResourceLength = (UINT16) i; 2731 2732 /* Point to end-of-descriptor for vendor data */ 2733 2734 VendorData = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_LARGE_HEADER); 2735 2736 /* Process all child initialization nodes */ 2737 2738 for (i = 0; InitializerOp; i++) 2739 { 2740 if (InitializerOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG) 2741 { 2742 break; 2743 } 2744 2745 VendorData[i] = (UINT8) InitializerOp->Asl.Value.Integer; 2746 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 2747 } 2748 2749 return (Rnode); 2750} 2751 2752 2753/******************************************************************************* 2754 * 2755 * FUNCTION: RsDoGeneralRegisterDescriptor 2756 * 2757 * PARAMETERS: Op - Parent resource descriptor parse node 2758 * CurrentByteOffset - Offset into the resource template AML 2759 * buffer (to track references to the desc) 2760 * 2761 * RETURN: Completed resource node 2762 * 2763 * DESCRIPTION: Construct a long "Register" descriptor 2764 * 2765 ******************************************************************************/ 2766 2767ASL_RESOURCE_NODE * 2768RsDoGeneralRegisterDescriptor ( 2769 ACPI_PARSE_OBJECT *Op, 2770 UINT32 CurrentByteOffset) 2771{ 2772 AML_RESOURCE *Descriptor; 2773 ACPI_PARSE_OBJECT *InitializerOp; 2774 ASL_RESOURCE_NODE *Rnode; 2775 UINT32 i; 2776 2777 2778 InitializerOp = Op->Asl.Child; 2779 Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_GENERIC_REGISTER)); 2780 2781 Descriptor = Rnode->Buffer; 2782 Descriptor->GenericReg.DescriptorType = ACPI_RESOURCE_NAME_GENERIC_REGISTER; 2783 Descriptor->GenericReg.ResourceLength = 12; 2784 2785 /* Process all child initialization nodes */ 2786 2787 for (i = 0; InitializerOp; i++) 2788 { 2789 switch (i) 2790 { 2791 case 0: /* Address space */ 2792 2793 Descriptor->GenericReg.AddressSpaceId = (UINT8) InitializerOp->Asl.Value.Integer; 2794 RsCreateByteField (InitializerOp, ACPI_RESTAG_ADDRESSSPACE, 2795 CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.AddressSpaceId)); 2796 break; 2797 2798 case 1: /* Register Bit Width */ 2799 2800 Descriptor->GenericReg.BitWidth = (UINT8) InitializerOp->Asl.Value.Integer; 2801 RsCreateByteField (InitializerOp, ACPI_RESTAG_REGISTERBITWIDTH, 2802 CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.BitWidth)); 2803 break; 2804 2805 case 2: /* Register Bit Offset */ 2806 2807 Descriptor->GenericReg.BitOffset = (UINT8) InitializerOp->Asl.Value.Integer; 2808 RsCreateByteField (InitializerOp, ACPI_RESTAG_REGISTERBITOFFSET, 2809 CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.BitOffset)); 2810 break; 2811 2812 case 3: /* Register Address */ 2813 2814 Descriptor->GenericReg.Address = InitializerOp->Asl.Value.Integer; 2815 RsCreateByteField (InitializerOp, ACPI_RESTAG_ADDRESS, 2816 CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.Address)); 2817 break; 2818 2819 case 4: /* Access Size (ACPI 3.0) */ 2820 2821 Descriptor->GenericReg.AccessSize = (UINT8) InitializerOp->Asl.Value.Integer; 2822 RsCreateByteField (InitializerOp, ACPI_RESTAG_ACCESSSIZE, 2823 CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.AccessSize)); 2824 break; 2825 2826 case 5: /* ResourceTag (ACPI 3.0b) */ 2827 2828 UtAttachNamepathToOwner (Op, InitializerOp); 2829 break; 2830 2831 default: 2832 2833 AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL); 2834 break; 2835 } 2836 2837 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp); 2838 } 2839 return (Rnode); 2840} 2841 2842 2843