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

   1
   2 /******************************************************************************
   3  *
   4  * Module Name: aslrestype2 - Long (type2) resource templates and descriptors
   5  *              $Revision: 1.42 $
   6  *
   7  *****************************************************************************/
   8
   9 /******************************************************************************
  10  *
  11  * 1. Copyright Notice
  12  *
  13  * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp.
  14  * All rights reserved.
  15  *
  16  * 2. License
  17  *
  18  * 2.1. This is your license from Intel Corp. under its intellectual property
  19  * rights.  You may have additional license terms from the party that provided
  20  * you this software, covering your right to use that party's intellectual
  21  * property rights.
  22  *
  23  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  24  * copy of the source code appearing in this file ("Covered Code") an
  25  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  26  * base code distributed originally by Intel ("Original Intel Code") to copy,
  27  * make derivatives, distribute, use and display any portion of the Covered
  28  * Code in any form, with the right to sublicense such rights; and
  29  *
  30  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  31  * license (with the right to sublicense), under only those claims of Intel
  32  * patents that are infringed by the Original Intel Code, to make, use, sell,
  33  * offer to sell, and import the Covered Code and derivative works thereof
  34  * solely to the minimum extent necessary to exercise the above copyright
  35  * license, and in no event shall the patent license extend to any additions
  36  * to or modifications of the Original Intel Code.  No other license or right
  37  * is granted directly or by implication, estoppel or otherwise;
  38  *
  39  * The above copyright and patent license is granted only if the following
  40  * conditions are met:
  41  *
  42  * 3. Conditions
  43  *
  44  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  45  * Redistribution of source code of any substantial portion of the Covered
  46  * Code or modification with rights to further distribute source must include
  47  * the above Copyright Notice, the above License, this list of Conditions,
  48  * and the following Disclaimer and Export Compliance provision.  In addition,
  49  * Licensee must cause all Covered Code to which Licensee contributes to
  50  * contain a file documenting the changes Licensee made to create that Covered
  51  * Code and the date of any change.  Licensee must include in that file the
  52  * documentation of any changes made by any predecessor Licensee.  Licensee
  53  * must include a prominent statement that the modification is derived,
  54  * directly or indirectly, from Original Intel Code.
  55  *
  56  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  57  * Redistribution of source code of any substantial portion of the Covered
  58  * Code or modification without rights to further distribute source must
  59  * include the following Disclaimer and Export Compliance provision in the
  60  * documentation and/or other materials provided with distribution.  In
  61  * addition, Licensee may not authorize further sublicense of source of any
  62  * portion of the Covered Code, and must include terms to the effect that the
  63  * license from Licensee to its licensee is limited to the intellectual
  64  * property embodied in the software Licensee provides to its licensee, and
  65  * not to intellectual property embodied in modifications its licensee may
  66  * make.
  67  *
  68  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  69  * substantial portion of the Covered Code or modification must reproduce the
  70  * above Copyright Notice, and the following Disclaimer and Export Compliance
  71  * provision in the documentation and/or other materials provided with the
  72  * distribution.
  73  *
  74  * 3.4. Intel retains all right, title, and interest in and to the Original
  75  * Intel Code.
  76  *
  77  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  78  * Intel shall be used in advertising or otherwise to promote the sale, use or
  79  * other dealings in products derived from or relating to the Covered Code
  80  * without prior written authorization from Intel.
  81  *
  82  * 4. Disclaimer and Export Compliance
  83  *
  84  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  85  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  86  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  87  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  88  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  89  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  90  * PARTICULAR PURPOSE.
  91  *
  92  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  93  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  94  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  95  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  96  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  97  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  98  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  99  * LIMITED REMEDY.
 100  *
 101  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 102  * software or system incorporating such software without first obtaining any
 103  * required license or other approval from the U. S. Department of Commerce or
 104  * any other agency or department of the United States Government.  In the
 105  * event Licensee exports any such software from the United States or
 106  * re-exports any such software from a foreign destination, Licensee shall
 107  * ensure that the distribution and export/re-export of the software is in
 108  * compliance with all laws, regulations, orders, or other restrictions of the
 109  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 110  * any of its subsidiaries will export/re-export any technical data, process,
 111  * software, or service, directly or indirectly, to any country for which the
 112  * United States government or any agency thereof requires an export license,
 113  * other governmental approval, or letter of assurance, without first obtaining
 114  * such license, approval or letter.
 115  *
 116  *****************************************************************************/
 117
 118
 119 #include <contrib/dev/acpica/compiler/aslcompiler.h>
 120 #include "aslcompiler.y.h"
 121
 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, ASL_RESNAME_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, ASL_RESNAME_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, ASL_RESNAME_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, ASL_RESNAME_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, ASL_RESNAME_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, ASL_RESNAME_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, ASL_RESNAME_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, ASL_RESNAME_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, ASL_RESNAME_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, ASL_RESNAME_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, ASL_RESNAME_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, ASL_RESNAME_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, ASL_RESNAME_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, ASL_RESNAME_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, ASL_RESNAME_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, ASL_RESNAME_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, ASL_RESNAME_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, ASL_RESNAME_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, ASL_RESNAME_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, ASL_RESNAME_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, ASL_RESNAME_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, ASL_RESNAME_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, ASL_RESNAME_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, ASL_RESNAME_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, ASL_RESNAME_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, ASL_RESNAME_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, ASL_RESNAME_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, ASL_RESNAME_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, ASL_RESNAME_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, ASL_RESNAME_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, ASL_RESNAME_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                  OptionIndex = 0;
 818     UINT32                  i;
 819
 820
 821     InitializerOp = Op->Asl.Child;
 822     StringLength = RsGetStringDataLength (InitializerOp);
 823
 824     Rnode = RsAllocateResourceNode (
 825                 sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength);
 826
 827     Descriptor = Rnode->Buffer;
 828     Descriptor->ExtAddress64.DescriptorType  = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64;
 829     Descriptor->ExtAddress64.ResourceType    = ACPI_ADDRESS_TYPE_IO_RANGE;
 830     Descriptor->ExtAddress64.RevisionID      = AML_RESOURCE_EXTENDED_ADDRESS_REVISION;
 831
 832     Descriptor->ExtAddress64.ResourceLength  = (UINT16)
 833         (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) -
 834          sizeof (AML_RESOURCE_LARGE_HEADER));
 835
 836     /* Process all child initialization nodes */
 837
 838     for (i = 0; InitializerOp; i++)
 839     {
 840         switch (i)
 841         {
 842         case 0: /* Resource Usage */
 843
 844             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1);
 845             break;
 846
 847         case 1: /* MinType */
 848
 849             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0);
 850             RsCreateBitField (InitializerOp, ASL_RESNAME_MINTYPE,
 851                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2);
 852             break;
 853
 854         case 2: /* MaxType */
 855
 856             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0);
 857             RsCreateBitField (InitializerOp, ASL_RESNAME_MAXTYPE,
 858                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3);
 859             break;
 860
 861         case 3: /* DecodeType */
 862
 863             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0);
 864             RsCreateBitField (InitializerOp, ASL_RESNAME_DECODE,
 865                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1);
 866             break;
 867
 868         case 4: /* Range Type */
 869
 870             RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 0, 3);
 871             RsCreateBitField (InitializerOp, ASL_RESNAME_RANGETYPE,
 872                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 0);
 873             break;
 874
 875         case 5: /* Address Granularity */
 876
 877             Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
 878             RsCreateByteField (InitializerOp, ASL_RESNAME_GRANULARITY,
 879                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
 880            break;
 881
 882         case 6: /* Address Min */
 883
 884             Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
 885             RsCreateByteField (InitializerOp, ASL_RESNAME_MINADDR,
 886                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
 887             break;
 888
 889         case 7: /* Address Max */
 890
 891             Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
 892             RsCreateByteField (InitializerOp, ASL_RESNAME_MAXADDR,
 893                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
 894             break;
 895
 896         case 8: /* Translation Offset */
 897
 898             Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
 899             RsCreateByteField (InitializerOp, ASL_RESNAME_TRANSLATION,
 900                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
 901             break;
 902
 903         case 9: /* Address Length */
 904
 905             Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
 906             RsCreateByteField (InitializerOp, ASL_RESNAME_LENGTH,
 907                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
 908             break;
 909
 910         case 10: /* Type-Specific Attributes */
 911
 912             Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
 913             RsCreateByteField (InitializerOp, ASL_RESNAME_TYPESPECIFICATTRIBUTES,
 914                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
 915             break;
 916
 917         case 11: /* ResourceTag */
 918
 919             UtAttachNamepathToOwner (Op, InitializerOp);
 920             break;
 921
 922         case 12: /* Type */
 923
 924             RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 4, 0);
 925             RsCreateBitField (InitializerOp, ASL_RESNAME_TYPE,
 926                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 4);
 927             break;
 928
 929         case 13: /* Translation Type */
 930
 931             RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 5, 0);
 932             RsCreateBitField (InitializerOp, ASL_RESNAME_TRANSTYPE,
 933                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 5);
 934             break;
 935
 936         default:
 937
 938             AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
 939             break;
 940         }
 941
 942         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
 943     }
 944
 945     Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + StringLength;
 946     return (Rnode);
 947 }
 948
 949
 950 /*******************************************************************************
 951  *
 952  * FUNCTION:    RsDoExtendedMemoryDescriptor
 953  *
 954  * PARAMETERS:  Op                  - Parent resource descriptor parse node
 955  *              CurrentByteOffset   - Offset into the resource template AML
 956  *                                    buffer (to track references to the desc)
 957  *
 958  * RETURN:      Completed resource node
 959  *
 960  * DESCRIPTION: Construct a long "ExtendedMemory" descriptor
 961  *
 962  ******************************************************************************/
 963
 964 ASL_RESOURCE_NODE *
 965 RsDoExtendedMemoryDescriptor (
 966     ACPI_PARSE_OBJECT       *Op,
 967     UINT32                  CurrentByteOffset)
 968 {
 969     AML_RESOURCE            *Descriptor;
 970     ACPI_PARSE_OBJECT       *InitializerOp;
 971     ASL_RESOURCE_NODE       *Rnode;
 972     UINT16                  StringLength = 0;
 973     UINT32                  i;
 974
 975
 976     InitializerOp = Op->Asl.Child;
 977     StringLength = RsGetStringDataLength (InitializerOp);
 978
 979     Rnode = RsAllocateResourceNode (
 980                 sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength);
 981
 982     Descriptor = Rnode->Buffer;
 983     Descriptor->ExtAddress64.DescriptorType  = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64;
 984     Descriptor->ExtAddress64.ResourceType    = ACPI_ADDRESS_TYPE_MEMORY_RANGE;
 985     Descriptor->ExtAddress64.RevisionID      = AML_RESOURCE_EXTENDED_ADDRESS_REVISION;
 986
 987     Descriptor->ExtAddress64.ResourceLength  = (UINT16)
 988         (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) -
 989          sizeof (AML_RESOURCE_LARGE_HEADER));
 990
 991     /* Process all child initialization nodes */
 992
 993     for (i = 0; InitializerOp; i++)
 994     {
 995         switch (i)
 996         {
 997         case 0: /* Resource Usage */
 998
 999             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1);
1000             break;
1001
1002         case 1: /* DecodeType */
1003
1004             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0);
1005             RsCreateBitField (InitializerOp, ASL_RESNAME_DECODE,
1006                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1);
1007             break;
1008
1009         case 2: /* MinType */
1010
1011             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0);
1012             RsCreateBitField (InitializerOp, ASL_RESNAME_MINTYPE,
1013                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2);
1014             break;
1015
1016         case 3: /* MaxType */
1017
1018             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0);
1019             RsCreateBitField (InitializerOp, ASL_RESNAME_MAXTYPE,
1020                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3);
1021             break;
1022
1023         case 4: /* Memory Type */
1024
1025             RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 1, 0);
1026             RsCreateBitField (InitializerOp, ASL_RESNAME_MEMTYPE,
1027                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 1);
1028             break;
1029
1030         case 5: /* Read/Write Type */
1031
1032             RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 0, 1);
1033             RsCreateBitField (InitializerOp, ASL_RESNAME_READWRITETYPE,
1034                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 0);
1035             break;
1036
1037         case 6: /* Address Granularity */
1038
1039             Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
1040             RsCreateByteField (InitializerOp, ASL_RESNAME_GRANULARITY,
1041                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
1042             break;
1043
1044         case 7: /* Min Address */
1045
1046             Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
1047             RsCreateByteField (InitializerOp, ASL_RESNAME_MINADDR,
1048                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
1049             break;
1050
1051         case 8: /* Max Address */
1052
1053             Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
1054             RsCreateByteField (InitializerOp, ASL_RESNAME_MAXADDR,
1055                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
1056             break;
1057
1058         case 9: /* Translation Offset */
1059
1060             Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
1061             RsCreateByteField (InitializerOp, ASL_RESNAME_TRANSLATION,
1062                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
1063             break;
1064
1065         case 10: /* Address Length */
1066
1067             Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
1068             RsCreateByteField (InitializerOp, ASL_RESNAME_LENGTH,
1069                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
1070             break;
1071
1072         case 11: /* Type-Specific Attributes */
1073
1074             Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
1075             RsCreateByteField (InitializerOp, ASL_RESNAME_TYPESPECIFICATTRIBUTES,
1076                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
1077             break;
1078
1079         case 12: /* ResourceTag */
1080
1081             UtAttachNamepathToOwner (Op, InitializerOp);
1082             break;
1083
1084
1085         case 13: /* Address Range */
1086
1087             RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 3, 0);
1088             RsCreateBitField (InitializerOp, ASL_RESNAME_MEMATTRIBUTES,
1089                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 3);
1090             break;
1091
1092         case 14: /* Type */
1093
1094             RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 5, 0);
1095             RsCreateBitField (InitializerOp, ASL_RESNAME_TYPE,
1096                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 5);
1097             break;
1098
1099         default:
1100
1101             AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
1102             break;
1103         }
1104
1105         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
1106     }
1107
1108     Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + StringLength;
1109     return (Rnode);
1110 }
1111
1112
1113 /*******************************************************************************
1114  *
1115  * FUNCTION:    RsDoExtendedSpaceDescriptor
1116  *
1117  * PARAMETERS:  Op                  - Parent resource descriptor parse node
1118  *              CurrentByteOffset   - Offset into the resource template AML
1119  *                                    buffer (to track references to the desc)
1120  *
1121  * RETURN:      Completed resource node
1122  *
1123  * DESCRIPTION: Construct a long "ExtendedSpace" descriptor
1124  *
1125  ******************************************************************************/
1126
1127 ASL_RESOURCE_NODE *
1128 RsDoExtendedSpaceDescriptor (
1129     ACPI_PARSE_OBJECT       *Op,
1130     UINT32                  CurrentByteOffset)
1131 {
1132     AML_RESOURCE            *Descriptor;
1133     ACPI_PARSE_OBJECT       *InitializerOp;
1134     ASL_RESOURCE_NODE       *Rnode;
1135     UINT16                  StringLength = 0;
1136     UINT32                  i;
1137
1138
1139     InitializerOp = Op->Asl.Child;
1140     StringLength = RsGetStringDataLength (InitializerOp);
1141
1142     Rnode = RsAllocateResourceNode (
1143                 sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength);
1144
1145     Descriptor = Rnode->Buffer;
1146     Descriptor->ExtAddress64.DescriptorType  = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64;
1147     Descriptor->ExtAddress64.RevisionID      = AML_RESOURCE_EXTENDED_ADDRESS_REVISION;
1148
1149     Descriptor->ExtAddress64.ResourceLength  = (UINT16)
1150         (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) -
1151          sizeof (AML_RESOURCE_LARGE_HEADER));
1152
1153     /* Process all child initialization nodes */
1154
1155     for (i = 0; InitializerOp; i++)
1156     {
1157         switch (i)
1158         {
1159         case 0: /* Resource Type */
1160
1161             Descriptor->ExtAddress64.ResourceType =
1162                 (UINT8) InitializerOp->Asl.Value.Integer;
1163             break;
1164
1165         case 1: /* Resource Usage */
1166
1167             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1);
1168             break;
1169
1170         case 2: /* DecodeType */
1171
1172             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0);
1173             RsCreateBitField (InitializerOp, ASL_RESNAME_DECODE,
1174                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1);
1175             break;
1176
1177         case 3: /* MinType */
1178
1179             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0);
1180             RsCreateBitField (InitializerOp, ASL_RESNAME_MINTYPE,
1181                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2);
1182             break;
1183
1184         case 4: /* MaxType */
1185
1186             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0);
1187             RsCreateBitField (InitializerOp, ASL_RESNAME_MAXTYPE,
1188                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3);
1189             break;
1190
1191         case 5: /* Type-Specific flags */
1192
1193             Descriptor->ExtAddress64.SpecificFlags =
1194                 (UINT8) InitializerOp->Asl.Value.Integer;
1195             break;
1196
1197         case 6: /* Address Granularity */
1198
1199             Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
1200             RsCreateByteField (InitializerOp, ASL_RESNAME_GRANULARITY,
1201                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
1202             break;
1203
1204         case 7: /* Min Address */
1205
1206             Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
1207             RsCreateByteField (InitializerOp, ASL_RESNAME_MINADDR,
1208                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
1209             break;
1210
1211         case 8: /* Max Address */
1212
1213             Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
1214             RsCreateByteField (InitializerOp, ASL_RESNAME_MAXADDR,
1215                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
1216             break;
1217
1218         case 9: /* Translation Offset */
1219
1220             Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
1221             RsCreateByteField (InitializerOp, ASL_RESNAME_TRANSLATION,
1222                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
1223             break;
1224
1225         case 10: /* Address Length */
1226
1227             Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
1228             RsCreateByteField (InitializerOp, ASL_RESNAME_LENGTH,
1229                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
1230             break;
1231
1232         case 11: /* Type-Specific Attributes */
1233
1234             Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
1235             RsCreateByteField (InitializerOp, ASL_RESNAME_TYPESPECIFICATTRIBUTES,
1236                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
1237             break;
1238
1239         case 12: /* ResourceTag */
1240
1241             UtAttachNamepathToOwner (Op, InitializerOp);
1242             break;
1243
1244         default:
1245
1246             AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
1247             break;
1248         }
1249
1250         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
1251     }
1252
1253     Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + StringLength;
1254     return (Rnode);
1255 }
1256
1257
1258 /*******************************************************************************
1259  *
1260  * FUNCTION:    RsDoQwordIoDescriptor
1261  *
1262  * PARAMETERS:  Op                  - Parent resource descriptor parse node
1263  *              CurrentByteOffset   - Offset into the resource template AML
1264  *                                    buffer (to track references to the desc)
1265  *
1266  * RETURN:      Completed resource node
1267  *
1268  * DESCRIPTION: Construct a long "QwordIO" descriptor
1269  *
1270  ******************************************************************************/
1271
1272 ASL_RESOURCE_NODE *
1273 RsDoQwordIoDescriptor (
1274     ACPI_PARSE_OBJECT       *Op,
1275     UINT32                  CurrentByteOffset)
1276 {
1277     AML_RESOURCE            *Descriptor;
1278     ACPI_PARSE_OBJECT       *InitializerOp;
1279     ASL_RESOURCE_NODE       *Rnode;
1280     UINT8                   *OptionalFields;
1281     UINT16                  StringLength = 0;
1282     UINT32                  OptionIndex = 0;
1283     UINT32                  i;
1284     BOOLEAN                 ResSourceIndex = FALSE;
1285
1286
1287     InitializerOp = Op->Asl.Child;
1288     StringLength = RsGetStringDataLength (InitializerOp);
1289
1290     Rnode = RsAllocateResourceNode (
1291                 sizeof (AML_RESOURCE_ADDRESS64) + 1 + StringLength);
1292
1293     Descriptor = Rnode->Buffer;
1294     Descriptor->Address64.DescriptorType  = ACPI_RESOURCE_NAME_ADDRESS64;
1295     Descriptor->Address64.ResourceType    = ACPI_ADDRESS_TYPE_IO_RANGE;
1296
1297     /*
1298      * Initial descriptor length -- may be enlarged if there are
1299      * optional fields present
1300      */
1301     OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS64);
1302     Descriptor->Address64.ResourceLength = (UINT16)
1303         (sizeof (AML_RESOURCE_ADDRESS64) -
1304          sizeof (AML_RESOURCE_LARGE_HEADER));
1305
1306     /* Process all child initialization nodes */
1307
1308     for (i = 0; InitializerOp; i++)
1309     {
1310         switch (i)
1311         {
1312         case 0: /* Resource Usage */
1313
1314             RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 0, 1);
1315             break;
1316
1317         case 1: /* MinType */
1318
1319             RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 2, 0);
1320             RsCreateBitField (InitializerOp, ASL_RESNAME_MINTYPE,
1321                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 2);
1322             break;
1323
1324         case 2: /* MaxType */
1325
1326             RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 3, 0);
1327             RsCreateBitField (InitializerOp, ASL_RESNAME_MAXTYPE,
1328                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 3);
1329             break;
1330
1331         case 3: /* DecodeType */
1332
1333             RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 1, 0);
1334             RsCreateBitField (InitializerOp, ASL_RESNAME_DECODE,
1335                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 1);
1336             break;
1337
1338         case 4: /* Range Type */
1339
1340             RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 0, 3);
1341             RsCreateBitField (InitializerOp, ASL_RESNAME_RANGETYPE,
1342                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 0);
1343             break;
1344
1345         case 5: /* Address Granularity */
1346
1347             Descriptor->Address64.Granularity = InitializerOp->Asl.Value.Integer;
1348             RsCreateByteField (InitializerOp, ASL_RESNAME_GRANULARITY,
1349                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Granularity));
1350            break;
1351
1352         case 6: /* Address Min */
1353
1354             Descriptor->Address64.Minimum = InitializerOp->Asl.Value.Integer;
1355             RsCreateByteField (InitializerOp, ASL_RESNAME_MINADDR,
1356                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Minimum));
1357             break;
1358
1359         case 7: /* Address Max */
1360
1361             Descriptor->Address64.Maximum = InitializerOp->Asl.Value.Integer;
1362             RsCreateByteField (InitializerOp, ASL_RESNAME_MAXADDR,
1363                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Maximum));
1364             break;
1365
1366         case 8: /* Translation Offset */
1367
1368             Descriptor->Address64.TranslationOffset = InitializerOp->Asl.Value.Integer;
1369             RsCreateByteField (InitializerOp, ASL_RESNAME_TRANSLATION,
1370                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.TranslationOffset));
1371             break;
1372
1373         case 9: /* Address Length */
1374
1375             Descriptor->Address64.AddressLength = InitializerOp->Asl.Value.Integer;
1376             RsCreateByteField (InitializerOp, ASL_RESNAME_LENGTH,
1377                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.AddressLength));
1378             break;
1379
1380         case 10: /* ResSourceIndex [Optional Field - BYTE] */
1381
1382             if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
1383             {
1384                 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
1385                 OptionIndex++;
1386                 Descriptor->Address64.ResourceLength++;
1387                 ResSourceIndex = TRUE;
1388             }
1389             break;
1390
1391         case 11: /* ResSource [Optional Field - STRING] */
1392
1393             if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
1394                 (InitializerOp->Asl.Value.String))
1395             {
1396                 if (StringLength)
1397                 {
1398                     Descriptor->Address64.ResourceLength = (UINT16)
1399                         (Descriptor->Address64.ResourceLength + StringLength);
1400
1401                     strcpy ((char *)
1402                         &OptionalFields[OptionIndex],
1403                         InitializerOp->Asl.Value.String);
1404
1405                     /* ResourceSourceIndex must also be valid */
1406
1407                     if (!ResSourceIndex)
1408                     {
1409                         AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
1410                             InitializerOp, NULL);
1411                     }
1412                 }
1413             }
1414
1415 #if 0
1416             /*
1417              * Not a valid ResourceSource, ResourceSourceIndex must also
1418              * be invalid
1419              */
1420             else if (ResSourceIndex)
1421             {
1422                 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
1423                     InitializerOp, NULL);
1424             }
1425 #endif
1426             break;
1427
1428         case 12: /* ResourceTag */
1429
1430             UtAttachNamepathToOwner (Op, InitializerOp);
1431             break;
1432
1433         case 13: /* Type */
1434
1435             RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 4, 0);
1436             RsCreateBitField (InitializerOp, ASL_RESNAME_TYPE,
1437                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 4);
1438             break;
1439
1440         case 14: /* Translation Type */
1441
1442             RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 5, 0);
1443             RsCreateBitField (InitializerOp, ASL_RESNAME_TRANSTYPE,
1444                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 5);
1445             break;
1446
1447         default:
1448
1449             AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
1450             break;
1451         }
1452
1453         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
1454     }
1455
1456     Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS64) +
1457                             OptionIndex + StringLength;
1458     return (Rnode);
1459 }
1460
1461
1462 /*******************************************************************************
1463  *
1464  * FUNCTION:    RsDoQwordMemoryDescriptor
1465  *
1466  * PARAMETERS:  Op                  - Parent resource descriptor parse node
1467  *              CurrentByteOffset   - Offset into the resource template AML
1468  *                                    buffer (to track references to the desc)
1469  *
1470  * RETURN:      Completed resource node
1471  *
1472  * DESCRIPTION: Construct a long "QwordMemory" descriptor
1473  *
1474  ******************************************************************************/
1475
1476 ASL_RESOURCE_NODE *
1477 RsDoQwordMemoryDescriptor (
1478     ACPI_PARSE_OBJECT       *Op,
1479     UINT32                  CurrentByteOffset)
1480 {
1481     AML_RESOURCE            *Descriptor;
1482     ACPI_PARSE_OBJECT       *InitializerOp;
1483     ASL_RESOURCE_NODE       *Rnode;
1484     UINT8                   *OptionalFields;
1485     UINT16                  StringLength = 0;
1486     UINT32                  OptionIndex = 0;
1487     UINT32                  i;
1488     BOOLEAN                 ResSourceIndex = FALSE;
1489
1490
1491     InitializerOp = Op->Asl.Child;
1492     StringLength = RsGetStringDataLength (InitializerOp);
1493
1494     Rnode = RsAllocateResourceNode (
1495                 sizeof (AML_RESOURCE_ADDRESS64) + 1 + StringLength);
1496
1497     Descriptor = Rnode->Buffer;
1498     Descriptor->Address64.DescriptorType  = ACPI_RESOURCE_NAME_ADDRESS64;
1499     Descriptor->Address64.ResourceType    = ACPI_ADDRESS_TYPE_MEMORY_RANGE;
1500
1501     /*
1502      * Initial descriptor length -- may be enlarged if there are
1503      * optional fields present
1504      */
1505     OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS64);
1506     Descriptor->Address64.ResourceLength = (UINT16)
1507         (sizeof (AML_RESOURCE_ADDRESS64) -
1508          sizeof (AML_RESOURCE_LARGE_HEADER));
1509
1510     /* Process all child initialization nodes */
1511
1512     for (i = 0; InitializerOp; i++)
1513     {
1514         switch (i)
1515         {
1516         case 0: /* Resource Usage */
1517
1518             RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 0, 1);
1519             break;
1520
1521         case 1: /* DecodeType */
1522
1523             RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 1, 0);
1524             RsCreateBitField (InitializerOp, ASL_RESNAME_DECODE,
1525                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 1);
1526             break;
1527
1528         case 2: /* MinType */
1529
1530             RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 2, 0);
1531             RsCreateBitField (InitializerOp, ASL_RESNAME_MINTYPE,
1532                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 2);
1533             break;
1534
1535         case 3: /* MaxType */
1536
1537             RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 3, 0);
1538             RsCreateBitField (InitializerOp, ASL_RESNAME_MAXTYPE,
1539                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 3);
1540             break;
1541
1542         case 4: /* Memory Type */
1543
1544             RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 1, 0);
1545             RsCreateBitField (InitializerOp, ASL_RESNAME_MEMTYPE,
1546                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 1);
1547             break;
1548
1549         case 5: /* Read/Write Type */
1550
1551             RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 0, 1);
1552             RsCreateBitField (InitializerOp, ASL_RESNAME_READWRITETYPE,
1553                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 0);
1554             break;
1555
1556         case 6: /* Address Granularity */
1557
1558             Descriptor->Address64.Granularity = InitializerOp->Asl.Value.Integer;
1559             RsCreateByteField (InitializerOp, ASL_RESNAME_GRANULARITY,
1560                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Granularity));
1561             break;
1562
1563         case 7: /* Min Address */
1564
1565             Descriptor->Address64.Minimum = InitializerOp->Asl.Value.Integer;
1566             RsCreateByteField (InitializerOp, ASL_RESNAME_MINADDR,
1567                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Minimum));
1568             break;
1569
1570         case 8: /* Max Address */
1571
1572             Descriptor->Address64.Maximum = InitializerOp->Asl.Value.Integer;
1573             RsCreateByteField (InitializerOp, ASL_RESNAME_MAXADDR,
1574                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Maximum));
1575             break;
1576
1577         case 9: /* Translation Offset */
1578
1579             Descriptor->Address64.TranslationOffset = InitializerOp->Asl.Value.Integer;
1580             RsCreateByteField (InitializerOp, ASL_RESNAME_TRANSLATION,
1581                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.TranslationOffset));
1582             break;
1583
1584         case 10: /* Address Length */
1585
1586             Descriptor->Address64.AddressLength = InitializerOp->Asl.Value.Integer;
1587             RsCreateByteField (InitializerOp, ASL_RESNAME_LENGTH,
1588                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.AddressLength));
1589             break;
1590
1591         case 11: /* ResSourceIndex [Optional Field - BYTE] */
1592
1593             if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
1594             {
1595                 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
1596                 OptionIndex++;
1597                 Descriptor->Address64.ResourceLength++;
1598                 ResSourceIndex = TRUE;
1599             }
1600             break;
1601
1602         case 12: /* ResSource [Optional Field - STRING] */
1603
1604             if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
1605                 (InitializerOp->Asl.Value.String))
1606             {
1607                 if (StringLength)
1608                 {
1609                     Descriptor->Address64.ResourceLength = (UINT16)
1610                         (Descriptor->Address64.ResourceLength + StringLength);
1611
1612                     strcpy ((char *)
1613                         &OptionalFields[OptionIndex],
1614                         InitializerOp->Asl.Value.String);
1615
1616                     /* ResourceSourceIndex must also be valid */
1617
1618                     if (!ResSourceIndex)
1619                     {
1620                         AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
1621                             InitializerOp, NULL);
1622                     }
1623                 }
1624             }
1625
1626 #if 0
1627             /*
1628              * Not a valid ResourceSource, ResourceSourceIndex must also
1629              * be invalid
1630              */
1631             else if (ResSourceIndex)
1632             {
1633                 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
1634                     InitializerOp, NULL);
1635             }
1636 #endif
1637             break;
1638
1639         case 13: /* ResourceTag */
1640
1641             UtAttachNamepathToOwner (Op, InitializerOp);
1642             break;
1643
1644
1645         case 14: /* Address Range */
1646
1647             RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 3, 0);
1648             RsCreateBitField (InitializerOp, ASL_RESNAME_MEMATTRIBUTES,
1649                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 3);
1650             break;
1651
1652         case 15: /* Type */
1653
1654             RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 5, 0);
1655             RsCreateBitField (InitializerOp, ASL_RESNAME_TYPE,
1656                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 5);
1657             break;
1658
1659         default:
1660
1661             AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
1662             break;
1663         }
1664
1665         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
1666     }
1667
1668     Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS64) +
1669                             OptionIndex + StringLength;
1670     return (Rnode);
1671 }
1672
1673
1674 /*******************************************************************************
1675  *
1676  * FUNCTION:    RsDoQwordSpaceDescriptor
1677  *
1678  * PARAMETERS:  Op                  - Parent resource descriptor parse node
1679  *              CurrentByteOffset   - Offset into the resource template AML
1680  *                                    buffer (to track references to the desc)
1681  *
1682  * RETURN:      Completed resource node
1683  *
1684  * DESCRIPTION: Construct a long "QwordSpace" descriptor
1685  *
1686  ******************************************************************************/
1687
1688 ASL_RESOURCE_NODE *
1689 RsDoQwordSpaceDescriptor (
1690     ACPI_PARSE_OBJECT       *Op,
1691     UINT32                  CurrentByteOffset)
1692 {
1693     AML_RESOURCE            *Descriptor;
1694     ACPI_PARSE_OBJECT       *InitializerOp;
1695     ASL_RESOURCE_NODE       *Rnode;
1696     UINT8                   *OptionalFields;
1697     UINT16                  StringLength = 0;
1698     UINT32                  OptionIndex = 0;
1699     UINT32                  i;
1700     BOOLEAN                 ResSourceIndex = FALSE;
1701
1702
1703     InitializerOp = Op->Asl.Child;
1704     StringLength = RsGetStringDataLength (InitializerOp);
1705
1706     Rnode = RsAllocateResourceNode (
1707                 sizeof (AML_RESOURCE_ADDRESS64) + 1 + StringLength);
1708
1709     Descriptor = Rnode->Buffer;
1710     Descriptor->Address64.DescriptorType  = ACPI_RESOURCE_NAME_ADDRESS32;
1711
1712     /*
1713      * Initial descriptor length -- may be enlarged if there are
1714      * optional fields present
1715      */
1716     OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS64);
1717     Descriptor->Address64.ResourceLength = (UINT16)
1718         (sizeof (AML_RESOURCE_ADDRESS64) -
1719          sizeof (AML_RESOURCE_LARGE_HEADER));
1720
1721     /* Process all child initialization nodes */
1722
1723     for (i = 0; InitializerOp; i++)
1724     {
1725         switch (i)
1726         {
1727         case 0: /* Resource Type */
1728
1729             Descriptor->Address64.ResourceType =
1730                 (UINT8) InitializerOp->Asl.Value.Integer;
1731             break;
1732
1733         case 1: /* Resource Usage */
1734
1735             RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 0, 1);
1736             break;
1737
1738         case 2: /* DecodeType */
1739
1740             RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 1, 0);
1741             RsCreateBitField (InitializerOp, ASL_RESNAME_DECODE,
1742                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 1);
1743             break;
1744
1745         case 3: /* MinType */
1746
1747             RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 2, 0);
1748             RsCreateBitField (InitializerOp, ASL_RESNAME_MINTYPE,
1749                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 2);
1750             break;
1751
1752         case 4: /* MaxType */
1753
1754             RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 3, 0);
1755             RsCreateBitField (InitializerOp, ASL_RESNAME_MAXTYPE,
1756                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 3);
1757             break;
1758
1759         case 5: /* Type-Specific flags */
1760
1761             Descriptor->Address64.SpecificFlags =
1762                 (UINT8) InitializerOp->Asl.Value.Integer;
1763             break;
1764
1765         case 6: /* Address Granularity */
1766
1767             Descriptor->Address64.Granularity = InitializerOp->Asl.Value.Integer;
1768             RsCreateByteField (InitializerOp, ASL_RESNAME_GRANULARITY,
1769                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Granularity));
1770             break;
1771
1772         case 7: /* Min Address */
1773
1774             Descriptor->Address64.Minimum = InitializerOp->Asl.Value.Integer;
1775             RsCreateByteField (InitializerOp, ASL_RESNAME_MINADDR,
1776                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Minimum));
1777             break;
1778
1779         case 8: /* Max Address */
1780
1781             Descriptor->Address64.Maximum = InitializerOp->Asl.Value.Integer;
1782             RsCreateByteField (InitializerOp, ASL_RESNAME_MAXADDR,
1783                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Maximum));
1784             break;
1785
1786         case 9: /* Translation Offset */
1787
1788             Descriptor->Address64.TranslationOffset = InitializerOp->Asl.Value.Integer;
1789             RsCreateByteField (InitializerOp, ASL_RESNAME_TRANSLATION,
1790                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.TranslationOffset));
1791             break;
1792
1793         case 10: /* Address Length */
1794
1795             Descriptor->Address64.AddressLength = InitializerOp->Asl.Value.Integer;
1796             RsCreateByteField (InitializerOp, ASL_RESNAME_LENGTH,
1797                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.AddressLength));
1798             break;
1799
1800         case 11: /* ResSourceIndex [Optional Field - BYTE] */
1801
1802             if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
1803             {
1804                 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
1805                 OptionIndex++;
1806                 Descriptor->Address64.ResourceLength++;
1807                 ResSourceIndex = TRUE;
1808             }
1809             break;
1810
1811         case 12: /* ResSource [Optional Field - STRING] */
1812
1813             if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
1814                 (InitializerOp->Asl.Value.String))
1815             {
1816                 if (StringLength)
1817                 {
1818                     Descriptor->Address64.ResourceLength = (UINT16)
1819                         (Descriptor->Address64.ResourceLength + StringLength);
1820
1821                     strcpy ((char *)
1822                         &OptionalFields[OptionIndex],
1823                         InitializerOp->Asl.Value.String);
1824
1825                     /* ResourceSourceIndex must also be valid */
1826
1827                     if (!ResSourceIndex)
1828                     {
1829                         AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
1830                             InitializerOp, NULL);
1831                     }
1832                 }
1833             }
1834
1835 #if 0
1836             /*
1837              * Not a valid ResourceSource, ResourceSourceIndex must also
1838              * be invalid
1839              */
1840             else if (ResSourceIndex)
1841             {
1842                 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
1843                     InitializerOp, NULL);
1844             }
1845 #endif
1846             break;
1847
1848         case 13: /* ResourceTag */
1849
1850             UtAttachNamepathToOwner (Op, InitializerOp);
1851             break;
1852
1853         default:
1854
1855             AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
1856             break;
1857         }
1858
1859         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
1860     }
1861
1862     Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS64) +
1863                             OptionIndex + StringLength;
1864     return (Rnode);
1865 }
1866
1867
1868 /*******************************************************************************
1869  *
1870  * FUNCTION:    RsDoWordIoDescriptor
1871  *
1872  * PARAMETERS:  Op                  - Parent resource descriptor parse node
1873  *              CurrentByteOffset   - Offset into the resource template AML
1874  *                                    buffer (to track references to the desc)
1875  *
1876  * RETURN:      Completed resource node
1877  *
1878  * DESCRIPTION: Construct a long "WordIO" descriptor
1879  *
1880  ******************************************************************************/
1881
1882 ASL_RESOURCE_NODE *
1883 RsDoWordIoDescriptor (
1884     ACPI_PARSE_OBJECT       *Op,
1885     UINT32                  CurrentByteOffset)
1886 {
1887     AML_RESOURCE            *Descriptor;
1888     ACPI_PARSE_OBJECT       *InitializerOp;
1889     ASL_RESOURCE_NODE       *Rnode;
1890     UINT8                   *OptionalFields;
1891     UINT16                  StringLength = 0;
1892     UINT32                  OptionIndex = 0;
1893     UINT32                  i;
1894     BOOLEAN                 ResSourceIndex = FALSE;
1895
1896
1897     InitializerOp = Op->Asl.Child;
1898     StringLength = RsGetStringDataLength (InitializerOp);
1899
1900     Rnode = RsAllocateResourceNode (
1901                 sizeof (AML_RESOURCE_ADDRESS16) + 1 + StringLength);
1902
1903     Descriptor = Rnode->Buffer;
1904     Descriptor->Address16.DescriptorType  = ACPI_RESOURCE_NAME_ADDRESS16;
1905     Descriptor->Address16.ResourceType    = ACPI_ADDRESS_TYPE_IO_RANGE;
1906
1907     /*
1908      * Initial descriptor length -- may be enlarged if there are
1909      * optional fields present
1910      */
1911     OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS16);
1912     Descriptor->Address16.ResourceLength = (UINT16)
1913         (sizeof (AML_RESOURCE_ADDRESS16) -
1914          sizeof (AML_RESOURCE_LARGE_HEADER));
1915
1916     /* Process all child initialization nodes */
1917
1918     for (i = 0; InitializerOp; i++)
1919     {
1920         switch (i)
1921         {
1922         case 0: /* Resource Usage */
1923
1924             RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 0, 1);
1925             break;
1926
1927         case 1: /* MinType */
1928
1929             RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 2, 0);
1930             RsCreateBitField (InitializerOp, ASL_RESNAME_MINTYPE,
1931                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 2);
1932             break;
1933
1934         case 2: /* MaxType */
1935
1936             RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 3, 0);
1937             RsCreateBitField (InitializerOp, ASL_RESNAME_MAXTYPE,
1938                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 3);
1939             break;
1940
1941         case 3: /* DecodeType */
1942
1943             RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 1, 0);
1944             RsCreateBitField (InitializerOp, ASL_RESNAME_DECODE,
1945                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 1);
1946             break;
1947
1948         case 4: /* Range Type */
1949
1950             RsSetFlagBits (&Descriptor->Address16.SpecificFlags, InitializerOp, 0, 3);
1951             RsCreateBitField (InitializerOp, ASL_RESNAME_RANGETYPE,
1952                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.SpecificFlags), 0);
1953             break;
1954
1955         case 5: /* Address Granularity */
1956
1957             Descriptor->Address16.Granularity = (UINT16) InitializerOp->Asl.Value.Integer;
1958             RsCreateByteField (InitializerOp, ASL_RESNAME_GRANULARITY,
1959                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Granularity));
1960             break;
1961
1962         case 6: /* Address Min */
1963
1964             Descriptor->Address16.Minimum = (UINT16) InitializerOp->Asl.Value.Integer;
1965             RsCreateByteField (InitializerOp, ASL_RESNAME_MINADDR,
1966                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Minimum));
1967             break;
1968
1969         case 7: /* Address Max */
1970
1971             Descriptor->Address16.Maximum = (UINT16) InitializerOp->Asl.Value.Integer;
1972             RsCreateByteField (InitializerOp, ASL_RESNAME_MAXADDR,
1973                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Maximum));
1974             break;
1975
1976         case 8: /* Translation Offset */
1977
1978             Descriptor->Address16.TranslationOffset = (UINT16) InitializerOp->Asl.Value.Integer;
1979             RsCreateByteField (InitializerOp, ASL_RESNAME_TRANSLATION,
1980                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.TranslationOffset));
1981             break;
1982
1983         case 9: /* Address Length */
1984
1985             Descriptor->Address16.AddressLength = (UINT16) InitializerOp->Asl.Value.Integer;
1986             RsCreateByteField (InitializerOp, ASL_RESNAME_LENGTH,
1987                  CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.AddressLength));
1988             break;
1989
1990         case 10: /* ResSourceIndex [Optional Field - BYTE] */
1991
1992             if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
1993             {
1994                 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
1995                 OptionIndex++;
1996                 Descriptor->Address16.ResourceLength++;
1997                 ResSourceIndex = TRUE;
1998             }
1999             break;
2000
2001         case 11: /* ResSource [Optional Field - STRING] */
2002
2003             if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
2004                 (InitializerOp->Asl.Value.String))
2005             {
2006                 if (StringLength)
2007                 {
2008                     Descriptor->Address16.ResourceLength = (UINT16)
2009                         (Descriptor->Address16.ResourceLength + StringLength);
2010
2011                     strcpy ((char *)
2012                         &OptionalFields[OptionIndex],
2013                         InitializerOp->Asl.Value.String);
2014
2015                     /* ResourceSourceIndex must also be valid */
2016
2017                     if (!ResSourceIndex)
2018                     {
2019                         AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
2020                             InitializerOp, NULL);
2021                     }
2022                 }
2023             }
2024
2025 #if 0
2026             /*
2027              * Not a valid ResourceSource, ResourceSourceIndex must also
2028              * be invalid
2029              */
2030             else if (ResSourceIndex)
2031             {
2032                 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
2033                     InitializerOp, NULL);
2034             }
2035 #endif
2036             break;
2037
2038         case 12: /* ResourceTag */
2039
2040             UtAttachNamepathToOwner (Op, InitializerOp);
2041             break;
2042
2043         case 13: /* Type */
2044
2045             RsSetFlagBits (&Descriptor->Address16.SpecificFlags, InitializerOp, 4, 0);
2046             RsCreateBitField (InitializerOp, ASL_RESNAME_TYPE,
2047                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.SpecificFlags), 4);
2048             break;
2049
2050         case 14: /* Translation Type */
2051
2052             RsSetFlagBits (&Descriptor->Address16.SpecificFlags, InitializerOp, 5, 0);
2053             RsCreateBitField (InitializerOp, ASL_RESNAME_TRANSTYPE,
2054                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.SpecificFlags), 5);
2055             break;
2056
2057         default:
2058
2059             AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
2060             break;
2061         }
2062
2063         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
2064     }
2065
2066     Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS16) +
2067                             OptionIndex + StringLength;
2068     return (Rnode);
2069 }
2070
2071
2072 /*******************************************************************************
2073  *
2074  * FUNCTION:    RsDoWordBusNumberDescriptor
2075  *
2076  * PARAMETERS:  Op                  - Parent resource descriptor parse node
2077  *              CurrentByteOffset   - Offset into the resource template AML
2078  *                                    buffer (to track references to the desc)
2079  *
2080  * RETURN:      Completed resource node
2081  *
2082  * DESCRIPTION: Construct a long "WordBusNumber" descriptor
2083  *
2084  ******************************************************************************/
2085
2086 ASL_RESOURCE_NODE *
2087 RsDoWordBusNumberDescriptor (
2088     ACPI_PARSE_OBJECT       *Op,
2089     UINT32                  CurrentByteOffset)
2090 {
2091     AML_RESOURCE            *Descriptor;
2092     ACPI_PARSE_OBJECT       *InitializerOp;
2093     ASL_RESOURCE_NODE       *Rnode;
2094     UINT8                   *OptionalFields;
2095     UINT16                  StringLength = 0;
2096     UINT32                  OptionIndex = 0;
2097     UINT32                  i;
2098     BOOLEAN                 ResSourceIndex = FALSE;
2099
2100
2101     InitializerOp = Op->Asl.Child;
2102     StringLength = RsGetStringDataLength (InitializerOp);
2103
2104     Rnode = RsAllocateResourceNode (
2105                 sizeof (AML_RESOURCE_ADDRESS16) + 1 + StringLength);
2106
2107     Descriptor = Rnode->Buffer;
2108     Descriptor->Address16.DescriptorType  = ACPI_RESOURCE_NAME_ADDRESS16;
2109     Descriptor->Address16.ResourceType    = ACPI_ADDRESS_TYPE_BUS_NUMBER_RANGE;
2110
2111     /*
2112      * Initial descriptor length -- may be enlarged if there are
2113      * optional fields present
2114      */
2115     OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS16);
2116     Descriptor->Address16.ResourceLength = (UINT16)
2117         (sizeof (AML_RESOURCE_ADDRESS16) -
2118          sizeof (AML_RESOURCE_LARGE_HEADER));
2119
2120     /* Process all child initialization nodes */
2121
2122     for (i = 0; InitializerOp; i++)
2123     {
2124         switch (i)
2125         {
2126         case 0: /* Resource Usage */
2127
2128             RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 0, 1);
2129             break;
2130
2131         case 1: /* MinType */
2132
2133             RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 2, 0);
2134             RsCreateBitField (InitializerOp, ASL_RESNAME_MINTYPE,
2135                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 2);
2136             break;
2137
2138         case 2: /* MaxType */
2139
2140             RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 3, 0);
2141             RsCreateBitField (InitializerOp, ASL_RESNAME_MAXTYPE,
2142                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 3);
2143             break;
2144
2145         case 3: /* DecodeType */
2146
2147             RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 1, 0);
2148             RsCreateBitField (InitializerOp, ASL_RESNAME_DECODE,
2149                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 1);
2150             break;
2151
2152         case 4: /* Address Granularity */
2153
2154             Descriptor->Address16.Granularity =
2155                 (UINT16) InitializerOp->Asl.Value.Integer;
2156             RsCreateByteField (InitializerOp, ASL_RESNAME_GRANULARITY,
2157                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Granularity));
2158             break;
2159
2160         case 5: /* Min Address */
2161
2162             Descriptor->Address16.Minimum =
2163                 (UINT16) InitializerOp->Asl.Value.Integer;
2164             RsCreateByteField (InitializerOp, ASL_RESNAME_MINADDR,
2165                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Minimum));
2166             break;
2167
2168         case 6: /* Max Address */
2169
2170             Descriptor->Address16.Maximum =
2171                 (UINT16) InitializerOp->Asl.Value.Integer;
2172             RsCreateByteField (InitializerOp, ASL_RESNAME_MAXADDR,
2173                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Maximum));
2174             break;
2175
2176         case 7: /* Translation Offset */
2177
2178             Descriptor->Address16.TranslationOffset =
2179                 (UINT16) InitializerOp->Asl.Value.Integer;
2180             RsCreateByteField (InitializerOp, ASL_RESNAME_TRANSLATION,
2181                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.TranslationOffset));
2182             break;
2183
2184         case 8: /* Address Length */
2185
2186             Descriptor->Address16.AddressLength =
2187                 (UINT16) InitializerOp->Asl.Value.Integer;
2188             RsCreateByteField (InitializerOp, ASL_RESNAME_LENGTH,
2189                  CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.AddressLength));
2190             break;
2191
2192         case 9: /* ResSourceIndex [Optional Field - BYTE] */
2193
2194             if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
2195             {
2196                 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
2197                 OptionIndex++;
2198                 Descriptor->Address16.ResourceLength++;
2199                 ResSourceIndex = TRUE;
2200             }
2201             break;
2202
2203         case 10: /* ResSource [Optional Field - STRING] */
2204
2205             if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
2206                 (InitializerOp->Asl.Value.String))
2207             {
2208                 if (StringLength)
2209                 {
2210                     Descriptor->Address16.ResourceLength = (UINT16)
2211                         (Descriptor->Address16.ResourceLength + StringLength);
2212
2213                     strcpy ((char *)
2214                         &OptionalFields[OptionIndex],
2215                         InitializerOp->Asl.Value.String);
2216
2217                     /* ResourceSourceIndex must also be valid */
2218
2219                     if (!ResSourceIndex)
2220                     {
2221                         AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
2222                             InitializerOp, NULL);
2223                     }
2224                 }
2225             }
2226
2227 #if 0
2228             /*
2229              * Not a valid ResourceSource, ResourceSourceIndex must also
2230              * be invalid
2231              */
2232             else if (ResSourceIndex)
2233             {
2234                 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
2235                     InitializerOp, NULL);
2236             }
2237 #endif
2238             break;
2239
2240         case 11: /* ResourceTag */
2241
2242             UtAttachNamepathToOwner (Op, InitializerOp);
2243             break;
2244
2245         default:
2246
2247             AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
2248             break;
2249         }
2250
2251         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
2252     }
2253
2254     Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS16) +
2255                             OptionIndex + StringLength;
2256     return (Rnode);
2257 }
2258
2259
2260 /*******************************************************************************
2261  *
2262  * FUNCTION:    RsDoWordSpaceDescriptor
2263  *
2264  * PARAMETERS:  Op                  - Parent resource descriptor parse node
2265  *              CurrentByteOffset   - Offset into the resource template AML
2266  *                                    buffer (to track references to the desc)
2267  *
2268  * RETURN:      Completed resource node
2269  *
2270  * DESCRIPTION: Construct a long "WordSpace" descriptor
2271  *
2272  ******************************************************************************/
2273
2274 ASL_RESOURCE_NODE *
2275 RsDoWordSpaceDescriptor (
2276     ACPI_PARSE_OBJECT       *Op,
2277     UINT32                  CurrentByteOffset)
2278 {
2279     AML_RESOURCE            *Descriptor;
2280     ACPI_PARSE_OBJECT       *InitializerOp;
2281     ASL_RESOURCE_NODE       *Rnode;
2282     UINT8                   *OptionalFields;
2283     UINT16                  StringLength = 0;
2284     UINT32                  OptionIndex = 0;
2285     UINT32                  i;
2286     BOOLEAN                 ResSourceIndex = FALSE;
2287
2288
2289     InitializerOp = Op->Asl.Child;
2290     StringLength = RsGetStringDataLength (InitializerOp);
2291
2292     Rnode = RsAllocateResourceNode (
2293                 sizeof (AML_RESOURCE_ADDRESS16) + 1 + StringLength);
2294
2295     Descriptor = Rnode->Buffer;
2296     Descriptor->Address16.DescriptorType  = ACPI_RESOURCE_NAME_ADDRESS16;
2297
2298     /*
2299      * Initial descriptor length -- may be enlarged if there are
2300      * optional fields present
2301      */
2302     OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS16);
2303     Descriptor->Address16.ResourceLength = (UINT16)
2304         (sizeof (AML_RESOURCE_ADDRESS16) -
2305          sizeof (AML_RESOURCE_LARGE_HEADER));
2306
2307     /* Process all child initialization nodes */
2308
2309     for (i = 0; InitializerOp; i++)
2310     {
2311         switch (i)
2312         {
2313         case 0: /* Resource Type */
2314
2315             Descriptor->Address16.ResourceType =
2316                 (UINT8) InitializerOp->Asl.Value.Integer;
2317             break;
2318
2319         case 1: /* Resource Usage */
2320
2321             RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 0, 1);
2322             break;
2323
2324         case 2: /* DecodeType */
2325
2326             RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 1, 0);
2327             RsCreateBitField (InitializerOp, ASL_RESNAME_DECODE,
2328                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 1);
2329             break;
2330
2331         case 3: /* MinType */
2332
2333             RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 2, 0);
2334             RsCreateBitField (InitializerOp, ASL_RESNAME_MINTYPE,
2335                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 2);
2336             break;
2337
2338         case 4: /* MaxType */
2339
2340             RsSetFlagBits (&Descriptor->Address16.Flags, InitializerOp, 3, 0);
2341             RsCreateBitField (InitializerOp, ASL_RESNAME_MAXTYPE,
2342                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Flags), 3);
2343             break;
2344
2345         case 5: /* Type-Specific flags */
2346
2347             Descriptor->Address16.SpecificFlags =
2348                 (UINT8) InitializerOp->Asl.Value.Integer;
2349             break;
2350
2351         case 6: /* Address Granularity */
2352
2353             Descriptor->Address16.Granularity =
2354                 (UINT16) InitializerOp->Asl.Value.Integer;
2355             RsCreateByteField (InitializerOp, ASL_RESNAME_GRANULARITY,
2356                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Granularity));
2357             break;
2358
2359         case 7: /* Min Address */
2360
2361             Descriptor->Address16.Minimum =
2362                 (UINT16) InitializerOp->Asl.Value.Integer;
2363             RsCreateByteField (InitializerOp, ASL_RESNAME_MINADDR,
2364                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Minimum));
2365             break;
2366
2367         case 8: /* Max Address */
2368
2369             Descriptor->Address16.Maximum =
2370                 (UINT16) InitializerOp->Asl.Value.Integer;
2371             RsCreateByteField (InitializerOp, ASL_RESNAME_MAXADDR,
2372                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.Maximum));
2373             break;
2374
2375         case 9: /* Translation Offset */
2376
2377             Descriptor->Address16.TranslationOffset =
2378                 (UINT16) InitializerOp->Asl.Value.Integer;
2379             RsCreateByteField (InitializerOp, ASL_RESNAME_TRANSLATION,
2380                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.TranslationOffset));
2381             break;
2382
2383         case 10: /* Address Length */
2384
2385             Descriptor->Address16.AddressLength =
2386                 (UINT16) InitializerOp->Asl.Value.Integer;
2387             RsCreateByteField (InitializerOp, ASL_RESNAME_LENGTH,
2388                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address16.AddressLength));
2389             break;
2390
2391         case 11: /* ResSourceIndex [Optional Field - BYTE] */
2392
2393             if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
2394             {
2395                 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
2396                 OptionIndex++;
2397                 Descriptor->Address16.ResourceLength++;
2398                 ResSourceIndex = TRUE;
2399             }
2400             break;
2401
2402         case 12: /* ResSource [Optional Field - STRING] */
2403
2404             if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
2405                 (InitializerOp->Asl.Value.String))
2406             {
2407                 if (StringLength)
2408                 {
2409                     Descriptor->Address16.ResourceLength = (UINT16)
2410                         (Descriptor->Address16.ResourceLength + StringLength);
2411
2412                     strcpy ((char *)
2413                         &OptionalFields[OptionIndex],
2414                         InitializerOp->Asl.Value.String);
2415
2416                     /* ResourceSourceIndex must also be valid */
2417
2418                     if (!ResSourceIndex)
2419                     {
2420                         AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
2421                             InitializerOp, NULL);
2422                     }
2423                 }
2424             }
2425
2426 #if 0
2427             /*
2428              * Not a valid ResourceSource, ResourceSourceIndex must also
2429              * be invalid
2430              */
2431             else if (ResSourceIndex)
2432             {
2433                 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
2434                     InitializerOp, NULL);
2435             }
2436 #endif
2437             break;
2438
2439         case 13: /* ResourceTag */
2440
2441             UtAttachNamepathToOwner (Op, InitializerOp);
2442             break;
2443
2444         default:
2445
2446             AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
2447             break;
2448         }
2449
2450         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
2451     }
2452
2453     Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS16) +
2454                             OptionIndex + StringLength;
2455     return (Rnode);
2456 }
2457
2458
2459 /*******************************************************************************
2460  *
2461  * FUNCTION:    RsDoInterruptDescriptor
2462  *
2463  * PARAMETERS:  Op                  - Parent resource descriptor parse node
2464  *              CurrentByteOffset   - Offset into the resource template AML
2465  *                                    buffer (to track references to the desc)
2466  *
2467  * RETURN:      Completed resource node
2468  *
2469  * DESCRIPTION: Construct a long "Interrupt" descriptor
2470  *
2471  ******************************************************************************/
2472
2473 ASL_RESOURCE_NODE *
2474 RsDoInterruptDescriptor (
2475     ACPI_PARSE_OBJECT       *Op,
2476     UINT32                  CurrentByteOffset)
2477 {
2478     AML_RESOURCE            *Descriptor;
2479     AML_RESOURCE            *Rover = NULL;
2480     ACPI_PARSE_OBJECT       *InitializerOp;
2481     ASL_RESOURCE_NODE       *Rnode;
2482     UINT16                  StringLength = 0;
2483     UINT32                  OptionIndex = 0;
2484     UINT32                  i;
2485     BOOLEAN                 HasResSourceIndex = FALSE;
2486     UINT8                   ResSourceIndex = 0;
2487     UINT8                   *ResSourceString = NULL;
2488
2489
2490     InitializerOp = Op->Asl.Child;
2491     StringLength = RsGetStringDataLength (InitializerOp);
2492     if (StringLength)
2493     {
2494         /* Make room for the ResourceSourceIndex */
2495
2496         OptionIndex++;
2497     }
2498
2499     /* Count the interrupt numbers */
2500
2501     for (i = 0; InitializerOp; i++)
2502     {
2503         InitializerOp = ASL_GET_PEER_NODE (InitializerOp);
2504         if (i <= 6)
2505         {
2506             continue;
2507         }
2508
2509         OptionIndex += 4;
2510     }
2511
2512     InitializerOp = Op->Asl.Child;
2513     Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_EXTENDED_IRQ) +
2514                 1 + OptionIndex + StringLength);
2515
2516     Descriptor = Rnode->Buffer;
2517     Descriptor->ExtendedIrq.DescriptorType  = ACPI_RESOURCE_NAME_EXTENDED_IRQ;
2518
2519     /*
2520      * Initial descriptor length -- may be enlarged if there are
2521      * optional fields present
2522      */
2523     Descriptor->ExtendedIrq.ResourceLength  = 2;  /* Flags and table length byte */
2524     Descriptor->ExtendedIrq.InterruptCount  = 0;
2525
2526     Rover = ACPI_CAST_PTR (AML_RESOURCE,
2527                 (&(Descriptor->ExtendedIrq.Interrupts[0])));
2528
2529     /* Process all child initialization nodes */
2530
2531     for (i = 0; InitializerOp; i++)
2532     {
2533         switch (i)
2534         {
2535         case 0: /* Resource Usage (Default: consumer (1) */
2536
2537             RsSetFlagBits (&Descriptor->ExtendedIrq.Flags, InitializerOp, 0, 1);
2538             break;
2539
2540         case 1: /* Interrupt Type (or Mode - edge/level) */
2541
2542             RsSetFlagBits (&Descriptor->ExtendedIrq.Flags, InitializerOp, 1, 0);
2543             RsCreateBitField (InitializerOp, ASL_RESNAME_INTERRUPTTYPE,
2544                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtendedIrq.Flags), 1);
2545             break;
2546
2547         case 2: /* Interrupt Level (or Polarity - Active high/low) */
2548
2549             RsSetFlagBits (&Descriptor->ExtendedIrq.Flags, InitializerOp, 2, 0);
2550             RsCreateBitField (InitializerOp, ASL_RESNAME_INTERRUPTLEVEL,
2551                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtendedIrq.Flags), 2);
2552             break;
2553
2554         case 3: /* Share Type - Default: exclusive (0) */
2555
2556             RsSetFlagBits (&Descriptor->ExtendedIrq.Flags, InitializerOp, 3, 0);
2557             RsCreateBitField (InitializerOp, ASL_RESNAME_INTERRUPTSHARE,
2558                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtendedIrq.Flags), 3);
2559             break;
2560
2561         case 4: /* ResSourceIndex [Optional Field - BYTE] */
2562
2563             if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
2564             {
2565                 HasResSourceIndex = TRUE;
2566                 ResSourceIndex = (UINT8) InitializerOp->Asl.Value.Integer;
2567             }
2568             break;
2569
2570         case 5: /* ResSource [Optional Field - STRING] */
2571
2572             if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
2573                 (InitializerOp->Asl.Value.String))
2574             {
2575                 if (StringLength)
2576                 {
2577                     ResSourceString = (UINT8 *) InitializerOp->Asl.Value.String;
2578                 }
2579
2580                 /* ResourceSourceIndex must also be valid */
2581
2582                 if (!HasResSourceIndex)
2583                 {
2584                     AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
2585                         InitializerOp, NULL);
2586                 }
2587             }
2588
2589 #if 0
2590             /*
2591              * Not a valid ResourceSource, ResourceSourceIndex must also
2592              * be invalid
2593              */
2594             else if (HasResSourceIndex)
2595             {
2596                 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
2597                     InitializerOp, NULL);
2598             }
2599 #endif
2600             break;
2601
2602         case 6: /* ResourceTag */
2603
2604             UtAttachNamepathToOwner (Op, InitializerOp);
2605             break;
2606
2607         default:
2608             /*
2609              * Interrupt Numbers come through here, repeatedly
2610              */
2611
2612             /* Maximum 255 interrupts allowed for this descriptor */
2613
2614             if (Descriptor->ExtendedIrq.InterruptCount == 255)
2615             {
2616                 AslError (ASL_ERROR, ASL_MSG_EX_INTERRUPT_LIST,
2617                     InitializerOp, NULL);
2618                 return (Rnode);
2619             }
2620
2621             /* Each interrupt number must be a 32-bit value */
2622
2623             if (InitializerOp->Asl.Value.Integer > ACPI_UINT32_MAX)
2624             {
2625                 AslError (ASL_ERROR, ASL_MSG_EX_INTERRUPT_NUMBER,
2626                     InitializerOp, NULL);
2627             }
2628
2629             /* Save the integer and move pointer to the next one */
2630
2631             Rover->U32Item = (UINT32) InitializerOp->Asl.Value.Integer;
2632             Rover = ACPI_PTR_ADD (AML_RESOURCE, &(Rover->U32Item), 4);
2633             Descriptor->ExtendedIrq.InterruptCount++;
2634             Descriptor->ExtendedIrq.ResourceLength += 4;
2635
2636             /* Case 7: First interrupt number in list */
2637
2638             if (i == 7)
2639             {
2640                 /* Check now for duplicates in list */
2641
2642                 RsCheckListForDuplicates (InitializerOp);
2643
2644                 /* Create a named field at the start of the list */
2645
2646                 RsCreateByteField (InitializerOp, ASL_RESNAME_INTERRUPT,
2647                     CurrentByteOffset +
2648                     ASL_RESDESC_OFFSET (ExtendedIrq.Interrupts[0]));
2649             }
2650         }
2651
2652         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
2653     }
2654
2655
2656     /* Add optional ResSourceIndex if present */
2657
2658     if (HasResSourceIndex)
2659     {
2660         Rover->U8Item = ResSourceIndex;
2661         Rover = ACPI_PTR_ADD (AML_RESOURCE, &(Rover->U8Item), 1);
2662         Descriptor->ExtendedIrq.ResourceLength += 1;
2663     }
2664
2665     /* Add optional ResSource string if present */
2666
2667     if (StringLength && ResSourceString)
2668     {
2669
2670         strcpy ((char *) Rover, (char *) ResSourceString);
2671         Rover = ACPI_PTR_ADD (
2672                     AML_RESOURCE, &(Rover->U8Item), StringLength);
2673
2674         Descriptor->ExtendedIrq.ResourceLength = (UINT16)
2675             (Descriptor->ExtendedIrq.ResourceLength + StringLength);
2676     }
2677
2678     Rnode->BufferLength = (ASL_RESDESC_OFFSET (ExtendedIrq.Interrupts[0]) -
2679                            ASL_RESDESC_OFFSET (ExtendedIrq.DescriptorType))
2680                            + OptionIndex + StringLength;
2681     return (Rnode);
2682 }
2683
2684
2685 /*******************************************************************************
2686  *
2687  * FUNCTION:    RsDoVendorLargeDescriptor
2688  *
2689  * PARAMETERS:  Op                  - Parent resource descriptor parse node
2690  *              CurrentByteOffset   - Offset into the resource template AML
2691  *                                    buffer (to track references to the desc)
2692  *
2693  * RETURN:      Completed resource node
2694  *
2695  * DESCRIPTION: Construct a long "VendorLong" descriptor
2696  *
2697  ******************************************************************************/
2698
2699 ASL_RESOURCE_NODE *
2700 RsDoVendorLargeDescriptor (
2701     ACPI_PARSE_OBJECT       *Op,
2702     UINT32                  CurrentByteOffset)
2703 {
2704     AML_RESOURCE            *Descriptor;
2705     ACPI_PARSE_OBJECT       *InitializerOp;
2706     ASL_RESOURCE_NODE       *Rnode;
2707     UINT8                   *VendorData;
2708     UINT32                  i;
2709
2710
2711     /* Count the number of data bytes */
2712
2713     InitializerOp = Op->Asl.Child;
2714     InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
2715
2716     for (i = 0; InitializerOp; i++)
2717     {
2718         InitializerOp = InitializerOp->Asl.Next;
2719     }
2720
2721     InitializerOp = Op->Asl.Child;
2722     InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
2723     Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_VENDOR_LARGE) + i);
2724
2725     Descriptor = Rnode->Buffer;
2726     Descriptor->VendorLarge.DescriptorType  = ACPI_RESOURCE_NAME_VENDOR_LARGE;
2727     Descriptor->VendorLarge.ResourceLength = (UINT16) i;
2728
2729     /* Point to end-of-descriptor for vendor data */
2730
2731     VendorData = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_LARGE_HEADER);
2732
2733     /* Process all child initialization nodes */
2734
2735     for (i = 0; InitializerOp; i++)
2736     {
2737         VendorData[i] = (UINT8) InitializerOp->Asl.Value.Integer;
2738
2739         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
2740     }
2741
2742     return (Rnode);
2743 }
2744
2745
2746 /*******************************************************************************
2747  *
2748  * FUNCTION:    RsDoGeneralRegisterDescriptor
2749  *
2750  * PARAMETERS:  Op                  - Parent resource descriptor parse node
2751  *              CurrentByteOffset   - Offset into the resource template AML
2752  *                                    buffer (to track references to the desc)
2753  *
2754  * RETURN:      Completed resource node
2755  *
2756  * DESCRIPTION: Construct a long "Register" descriptor
2757  *
2758  ******************************************************************************/
2759
2760 ASL_RESOURCE_NODE *
2761 RsDoGeneralRegisterDescriptor (
2762     ACPI_PARSE_OBJECT       *Op,
2763     UINT32                  CurrentByteOffset)
2764 {
2765     AML_RESOURCE            *Descriptor;
2766     ACPI_PARSE_OBJECT       *InitializerOp;
2767     ASL_RESOURCE_NODE       *Rnode;
2768     UINT32                  i;
2769
2770
2771     InitializerOp = Op->Asl.Child;
2772     Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_GENERIC_REGISTER));
2773
2774     Descriptor = Rnode->Buffer;
2775     Descriptor->GenericReg.DescriptorType = ACPI_RESOURCE_NAME_GENERIC_REGISTER;
2776     Descriptor->GenericReg.ResourceLength = 12;
2777
2778     /* Process all child initialization nodes */
2779
2780     for (i = 0; InitializerOp; i++)
2781     {
2782         switch (i)
2783         {
2784         case 0: /* Address space */
2785
2786             Descriptor->GenericReg.AddressSpaceId = (UINT8) InitializerOp->Asl.Value.Integer;
2787             RsCreateByteField (InitializerOp, ASL_RESNAME_ADDRESSSPACE,
2788                 CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.AddressSpaceId));
2789            break;
2790
2791         case 1: /* Register Bit Width */
2792
2793             Descriptor->GenericReg.BitWidth = (UINT8) InitializerOp->Asl.Value.Integer;
2794             RsCreateByteField (InitializerOp, ASL_RESNAME_REGISTERBITWIDTH,
2795                 CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.BitWidth));
2796             break;
2797
2798         case 2: /* Register Bit Offset */
2799
2800             Descriptor->GenericReg.BitOffset = (UINT8) InitializerOp->Asl.Value.Integer;
2801             RsCreateByteField (InitializerOp, ASL_RESNAME_REGISTERBITOFFSET,
2802                 CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.BitOffset));
2803             break;
2804
2805         case 3: /* Register Address */
2806
2807             Descriptor->GenericReg.Address = InitializerOp->Asl.Value.Integer;
2808             RsCreateByteField (InitializerOp, ASL_RESNAME_ADDRESS,
2809                 CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.Address));
2810             break;
2811
2812         case 4: /* Access Size (ACPI 3.0) */
2813
2814             Descriptor->GenericReg.AccessSize = (UINT8) InitializerOp->Asl.Value.Integer;
2815             RsCreateByteField (InitializerOp, ASL_RESNAME_ACCESSSIZE,
2816                 CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.AccessSize));
2817             break;
2818
2819         default:
2820
2821             AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
2822             break;
2823         }
2824
2825         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
2826     }
2827     return (Rnode);
2828 }
2829
2830