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

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