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