sys/contrib/dev/acpica/compiler/aslrestype2.c

   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 - 2010, 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
 126 static UINT16
 127 RsGetStringDataLength (
 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
 144 static UINT16
 145 RsGetStringDataLength (
 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
 176 ASL_RESOURCE_NODE *
 177 RsDoDwordIoDescriptor (
 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
 389 ASL_RESOURCE_NODE *
 390 RsDoDwordMemoryDescriptor (
 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
 607 ASL_RESOURCE_NODE *
 608 RsDoDwordSpaceDescriptor (
 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
 807 ASL_RESOURCE_NODE *
 808 RsDoExtendedIoDescriptor (
 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
 962 ASL_RESOURCE_NODE *
 963 RsDoExtendedMemoryDescriptor (
 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
1125 ASL_RESOURCE_NODE *
1126 RsDoExtendedSpaceDescriptor (
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
1270 ASL_RESOURCE_NODE *
1271 RsDoQwordIoDescriptor (
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
1474 ASL_RESOURCE_NODE *
1475 RsDoQwordMemoryDescriptor (
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
1686 ASL_RESOURCE_NODE *
1687 RsDoQwordSpaceDescriptor (
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
1880 ASL_RESOURCE_NODE *
1881 RsDoWordIoDescriptor (
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
2084 ASL_RESOURCE_NODE *
2085 RsDoWordBusNumberDescriptor (
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
2272 ASL_RESOURCE_NODE *
2273 RsDoWordSpaceDescriptor (
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
2471 ASL_RESOURCE_NODE *
2472 RsDoInterruptDescriptor (
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
2710 ASL_RESOURCE_NODE *
2711 RsDoVendorLargeDescriptor (
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
2779 ASL_RESOURCE_NODE *
2780 RsDoGeneralRegisterDescriptor (
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