sys/contrib/dev/acpica-unix/compiler/aslrestype2e.c

   1
   2 /******************************************************************************
   3  *
   4  * Module Name: aslrestype2e - Large Extended address resource descriptors
   5  *
   6  *****************************************************************************/
   7
   8 /******************************************************************************
   9  *
  10  * 1. Copyright Notice
  11  *
  12  * Some or all of this work - Copyright (c) 1999 - 2011, Intel Corp.
  13  * All rights reserved.
  14  *
  15  * 2. License
  16  *
  17  * 2.1. This is your license from Intel Corp. under its intellectual property
  18  * rights.  You may have additional license terms from the party that provided
  19  * you this software, covering your right to use that party's intellectual
  20  * property rights.
  21  *
  22  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  23  * copy of the source code appearing in this file ("Covered Code") an
  24  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  25  * base code distributed originally by Intel ("Original Intel Code") to copy,
  26  * make derivatives, distribute, use and display any portion of the Covered
  27  * Code in any form, with the right to sublicense such rights; and
  28  *
  29  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  30  * license (with the right to sublicense), under only those claims of Intel
  31  * patents that are infringed by the Original Intel Code, to make, use, sell,
  32  * offer to sell, and import the Covered Code and derivative works thereof
  33  * solely to the minimum extent necessary to exercise the above copyright
  34  * license, and in no event shall the patent license extend to any additions
  35  * to or modifications of the Original Intel Code.  No other license or right
  36  * is granted directly or by implication, estoppel or otherwise;
  37  *
  38  * The above copyright and patent license is granted only if the following
  39  * conditions are met:
  40  *
  41  * 3. Conditions
  42  *
  43  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  44  * Redistribution of source code of any substantial portion of the Covered
  45  * Code or modification with rights to further distribute source must include
  46  * the above Copyright Notice, the above License, this list of Conditions,
  47  * and the following Disclaimer and Export Compliance provision.  In addition,
  48  * Licensee must cause all Covered Code to which Licensee contributes to
  49  * contain a file documenting the changes Licensee made to create that Covered
  50  * Code and the date of any change.  Licensee must include in that file the
  51  * documentation of any changes made by any predecessor Licensee.  Licensee
  52  * must include a prominent statement that the modification is derived,
  53  * directly or indirectly, from Original Intel Code.
  54  *
  55  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  56  * Redistribution of source code of any substantial portion of the Covered
  57  * Code or modification without rights to further distribute source must
  58  * include the following Disclaimer and Export Compliance provision in the
  59  * documentation and/or other materials provided with distribution.  In
  60  * addition, Licensee may not authorize further sublicense of source of any
  61  * portion of the Covered Code, and must include terms to the effect that the
  62  * license from Licensee to its licensee is limited to the intellectual
  63  * property embodied in the software Licensee provides to its licensee, and
  64  * not to intellectual property embodied in modifications its licensee may
  65  * make.
  66  *
  67  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  68  * substantial portion of the Covered Code or modification must reproduce the
  69  * above Copyright Notice, and the following Disclaimer and Export Compliance
  70  * provision in the documentation and/or other materials provided with the
  71  * distribution.
  72  *
  73  * 3.4. Intel retains all right, title, and interest in and to the Original
  74  * Intel Code.
  75  *
  76  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  77  * Intel shall be used in advertising or otherwise to promote the sale, use or
  78  * other dealings in products derived from or relating to the Covered Code
  79  * without prior written authorization from Intel.
  80  *
  81  * 4. Disclaimer and Export Compliance
  82  *
  83  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  84  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  85  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  86  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  87  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  88  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  89  * PARTICULAR PURPOSE.
  90  *
  91  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  92  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  93  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  94  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  95  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  96  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  97  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  98  * LIMITED REMEDY.
  99  *
 100  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 101  * software or system incorporating such software without first obtaining any
 102  * required license or other approval from the U. S. Department of Commerce or
 103  * any other agency or department of the United States Government.  In the
 104  * event Licensee exports any such software from the United States or
 105  * re-exports any such software from a foreign destination, Licensee shall
 106  * ensure that the distribution and export/re-export of the software is in
 107  * compliance with all laws, regulations, orders, or other restrictions of the
 108  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 109  * any of its subsidiaries will export/re-export any technical data, process,
 110  * software, or service, directly or indirectly, to any country for which the
 111  * United States government or any agency thereof requires an export license,
 112  * other governmental approval, or letter of assurance, without first obtaining
 113  * such license, approval or letter.
 114  *
 115  *****************************************************************************/
 116
 117
 118 #include "aslcompiler.h"
 119
 120 #define _COMPONENT          ACPI_COMPILER
 121         ACPI_MODULE_NAME    ("aslrestype2e")
 122
 123 /*
 124  * This module contains the Extended (64-bit) address space descriptors:
 125  *
 126  * ExtendedIO
 127  * ExtendedMemory
 128  * ExtendedSpace
 129  */
 130
 131 /*******************************************************************************
 132  *
 133  * FUNCTION:    RsDoExtendedIoDescriptor
 134  *
 135  * PARAMETERS:  Op                  - Parent resource descriptor parse node
 136  *              CurrentByteOffset   - Offset into the resource template AML
 137  *                                    buffer (to track references to the desc)
 138  *
 139  * RETURN:      Completed resource node
 140  *
 141  * DESCRIPTION: Construct a long "ExtendedIO" descriptor
 142  *
 143  ******************************************************************************/
 144
 145 ASL_RESOURCE_NODE *
 146 RsDoExtendedIoDescriptor (
 147     ACPI_PARSE_OBJECT       *Op,
 148     UINT32                  CurrentByteOffset)
 149 {
 150     AML_RESOURCE            *Descriptor;
 151     ACPI_PARSE_OBJECT       *InitializerOp;
 152     ACPI_PARSE_OBJECT       *MinOp = NULL;
 153     ACPI_PARSE_OBJECT       *MaxOp = NULL;
 154     ACPI_PARSE_OBJECT       *LengthOp = NULL;
 155     ACPI_PARSE_OBJECT       *GranOp = NULL;
 156     ASL_RESOURCE_NODE       *Rnode;
 157     UINT16                  StringLength = 0;
 158     UINT32                  i;
 159
 160
 161     InitializerOp = Op->Asl.Child;
 162     StringLength = RsGetStringDataLength (InitializerOp);
 163
 164     Rnode = RsAllocateResourceNode (
 165                 sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength);
 166
 167     Descriptor = Rnode->Buffer;
 168     Descriptor->ExtAddress64.DescriptorType  = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64;
 169     Descriptor->ExtAddress64.ResourceType    = ACPI_ADDRESS_TYPE_IO_RANGE;
 170     Descriptor->ExtAddress64.RevisionID      = AML_RESOURCE_EXTENDED_ADDRESS_REVISION;
 171
 172     Descriptor->ExtAddress64.ResourceLength  = (UINT16)
 173         (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) -
 174          sizeof (AML_RESOURCE_LARGE_HEADER));
 175
 176     /* Process all child initialization nodes */
 177
 178     for (i = 0; InitializerOp; i++)
 179     {
 180         switch (i)
 181         {
 182         case 0: /* Resource Usage */
 183
 184             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1);
 185             break;
 186
 187         case 1: /* MinType */
 188
 189             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0);
 190             RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
 191                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2);
 192             break;
 193
 194         case 2: /* MaxType */
 195
 196             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0);
 197             RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
 198                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3);
 199             break;
 200
 201         case 3: /* DecodeType */
 202
 203             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0);
 204             RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
 205                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1);
 206             break;
 207
 208         case 4: /* Range Type */
 209
 210             RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 0, 3);
 211             RsCreateBitField (InitializerOp, ACPI_RESTAG_RANGETYPE,
 212                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 0);
 213             break;
 214
 215         case 5: /* Address Granularity */
 216
 217             Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
 218             RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
 219                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
 220             GranOp = InitializerOp;
 221            break;
 222
 223         case 6: /* Address Min */
 224
 225             Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
 226             RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
 227                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
 228             MinOp = InitializerOp;
 229             break;
 230
 231         case 7: /* Address Max */
 232
 233             Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
 234             RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
 235                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
 236             MaxOp = InitializerOp;
 237             break;
 238
 239         case 8: /* Translation Offset */
 240
 241             Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
 242             RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
 243                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
 244             break;
 245
 246         case 9: /* Address Length */
 247
 248             Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
 249             RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
 250                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
 251             LengthOp = InitializerOp;
 252             break;
 253
 254         case 10: /* Type-Specific Attributes */
 255
 256             Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
 257             RsCreateByteField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
 258                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
 259             break;
 260
 261         case 11: /* ResourceTag */
 262
 263             UtAttachNamepathToOwner (Op, InitializerOp);
 264             break;
 265
 266         case 12: /* Type */
 267
 268             RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 4, 0);
 269             RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
 270                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 4);
 271             break;
 272
 273         case 13: /* Translation Type */
 274
 275             RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 5, 0);
 276             RsCreateBitField (InitializerOp, ACPI_RESTAG_TRANSTYPE,
 277                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 5);
 278             break;
 279
 280         default:
 281
 282             AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
 283             break;
 284         }
 285
 286         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
 287     }
 288
 289     /* Validate the Min/Max/Len/Gran values */
 290
 291     RsLargeAddressCheck (
 292         Descriptor->ExtAddress64.Minimum,
 293         Descriptor->ExtAddress64.Maximum,
 294         Descriptor->ExtAddress64.AddressLength,
 295         Descriptor->ExtAddress64.Granularity,
 296         Descriptor->ExtAddress64.Flags,
 297         MinOp, MaxOp, LengthOp, GranOp, Op);
 298
 299     Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + StringLength;
 300     return (Rnode);
 301 }
 302
 303
 304 /*******************************************************************************
 305  *
 306  * FUNCTION:    RsDoExtendedMemoryDescriptor
 307  *
 308  * PARAMETERS:  Op                  - Parent resource descriptor parse node
 309  *              CurrentByteOffset   - Offset into the resource template AML
 310  *                                    buffer (to track references to the desc)
 311  *
 312  * RETURN:      Completed resource node
 313  *
 314  * DESCRIPTION: Construct a long "ExtendedMemory" descriptor
 315  *
 316  ******************************************************************************/
 317
 318 ASL_RESOURCE_NODE *
 319 RsDoExtendedMemoryDescriptor (
 320     ACPI_PARSE_OBJECT       *Op,
 321     UINT32                  CurrentByteOffset)
 322 {
 323     AML_RESOURCE            *Descriptor;
 324     ACPI_PARSE_OBJECT       *InitializerOp;
 325     ACPI_PARSE_OBJECT       *MinOp = NULL;
 326     ACPI_PARSE_OBJECT       *MaxOp = NULL;
 327     ACPI_PARSE_OBJECT       *LengthOp = NULL;
 328     ACPI_PARSE_OBJECT       *GranOp = NULL;
 329     ASL_RESOURCE_NODE       *Rnode;
 330     UINT16                  StringLength = 0;
 331     UINT32                  i;
 332
 333
 334     InitializerOp = Op->Asl.Child;
 335     StringLength = RsGetStringDataLength (InitializerOp);
 336
 337     Rnode = RsAllocateResourceNode (
 338                 sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength);
 339
 340     Descriptor = Rnode->Buffer;
 341     Descriptor->ExtAddress64.DescriptorType  = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64;
 342     Descriptor->ExtAddress64.ResourceType    = ACPI_ADDRESS_TYPE_MEMORY_RANGE;
 343     Descriptor->ExtAddress64.RevisionID      = AML_RESOURCE_EXTENDED_ADDRESS_REVISION;
 344
 345     Descriptor->ExtAddress64.ResourceLength  = (UINT16)
 346         (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) -
 347          sizeof (AML_RESOURCE_LARGE_HEADER));
 348
 349     /* Process all child initialization nodes */
 350
 351     for (i = 0; InitializerOp; i++)
 352     {
 353         switch (i)
 354         {
 355         case 0: /* Resource Usage */
 356
 357             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1);
 358             break;
 359
 360         case 1: /* DecodeType */
 361
 362             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0);
 363             RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
 364                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1);
 365             break;
 366
 367         case 2: /* MinType */
 368
 369             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0);
 370             RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
 371                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2);
 372             break;
 373
 374         case 3: /* MaxType */
 375
 376             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0);
 377             RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
 378                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3);
 379             break;
 380
 381         case 4: /* Memory Type */
 382
 383             RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 1, 0);
 384             RsCreateBitField (InitializerOp, ACPI_RESTAG_MEMTYPE,
 385                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 1);
 386             break;
 387
 388         case 5: /* Read/Write Type */
 389
 390             RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 0, 1);
 391             RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE,
 392                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 0);
 393             break;
 394
 395         case 6: /* Address Granularity */
 396
 397             Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
 398             RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
 399                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
 400             GranOp = InitializerOp;
 401             break;
 402
 403         case 7: /* Min Address */
 404
 405             Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
 406             RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
 407                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
 408             MinOp = InitializerOp;
 409             break;
 410
 411         case 8: /* Max Address */
 412
 413             Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
 414             RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
 415                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
 416             MaxOp = InitializerOp;
 417             break;
 418
 419         case 9: /* Translation Offset */
 420
 421             Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
 422             RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
 423                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
 424             break;
 425
 426         case 10: /* Address Length */
 427
 428             Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
 429             RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
 430                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
 431             LengthOp = InitializerOp;
 432             break;
 433
 434         case 11: /* Type-Specific Attributes */
 435
 436             Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
 437             RsCreateByteField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
 438                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
 439             break;
 440
 441         case 12: /* ResourceTag */
 442
 443             UtAttachNamepathToOwner (Op, InitializerOp);
 444             break;
 445
 446
 447         case 13: /* Address Range */
 448
 449             RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 3, 0);
 450             RsCreateBitField (InitializerOp, ACPI_RESTAG_MEMATTRIBUTES,
 451                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 3);
 452             break;
 453
 454         case 14: /* Type */
 455
 456             RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 5, 0);
 457             RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
 458                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 5);
 459             break;
 460
 461         default:
 462
 463             AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
 464             break;
 465         }
 466
 467         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
 468     }
 469
 470     /* Validate the Min/Max/Len/Gran values */
 471
 472     RsLargeAddressCheck (
 473         Descriptor->ExtAddress64.Minimum,
 474         Descriptor->ExtAddress64.Maximum,
 475         Descriptor->ExtAddress64.AddressLength,
 476         Descriptor->ExtAddress64.Granularity,
 477         Descriptor->ExtAddress64.Flags,
 478         MinOp, MaxOp, LengthOp, GranOp, Op);
 479
 480     Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + StringLength;
 481     return (Rnode);
 482 }
 483
 484
 485 /*******************************************************************************
 486  *
 487  * FUNCTION:    RsDoExtendedSpaceDescriptor
 488  *
 489  * PARAMETERS:  Op                  - Parent resource descriptor parse node
 490  *              CurrentByteOffset   - Offset into the resource template AML
 491  *                                    buffer (to track references to the desc)
 492  *
 493  * RETURN:      Completed resource node
 494  *
 495  * DESCRIPTION: Construct a long "ExtendedSpace" descriptor
 496  *
 497  ******************************************************************************/
 498
 499 ASL_RESOURCE_NODE *
 500 RsDoExtendedSpaceDescriptor (
 501     ACPI_PARSE_OBJECT       *Op,
 502     UINT32                  CurrentByteOffset)
 503 {
 504     AML_RESOURCE            *Descriptor;
 505     ACPI_PARSE_OBJECT       *InitializerOp;
 506     ACPI_PARSE_OBJECT       *MinOp = NULL;
 507     ACPI_PARSE_OBJECT       *MaxOp = NULL;
 508     ACPI_PARSE_OBJECT       *LengthOp = NULL;
 509     ACPI_PARSE_OBJECT       *GranOp = NULL;
 510     ASL_RESOURCE_NODE       *Rnode;
 511     UINT16                  StringLength = 0;
 512     UINT32                  i;
 513
 514
 515     InitializerOp = Op->Asl.Child;
 516     StringLength = RsGetStringDataLength (InitializerOp);
 517
 518     Rnode = RsAllocateResourceNode (
 519                 sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength);
 520
 521     Descriptor = Rnode->Buffer;
 522     Descriptor->ExtAddress64.DescriptorType  = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64;
 523     Descriptor->ExtAddress64.RevisionID      = AML_RESOURCE_EXTENDED_ADDRESS_REVISION;
 524
 525     Descriptor->ExtAddress64.ResourceLength  = (UINT16)
 526         (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) -
 527          sizeof (AML_RESOURCE_LARGE_HEADER));
 528
 529     /* Process all child initialization nodes */
 530
 531     for (i = 0; InitializerOp; i++)
 532     {
 533         switch (i)
 534         {
 535         case 0: /* Resource Type */
 536
 537             Descriptor->ExtAddress64.ResourceType =
 538                 (UINT8) InitializerOp->Asl.Value.Integer;
 539             break;
 540
 541         case 1: /* Resource Usage */
 542
 543             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1);
 544             break;
 545
 546         case 2: /* DecodeType */
 547
 548             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0);
 549             RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
 550                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1);
 551             break;
 552
 553         case 3: /* MinType */
 554
 555             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0);
 556             RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
 557                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2);
 558             break;
 559
 560         case 4: /* MaxType */
 561
 562             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0);
 563             RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
 564                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3);
 565             break;
 566
 567         case 5: /* Type-Specific flags */
 568
 569             Descriptor->ExtAddress64.SpecificFlags =
 570                 (UINT8) InitializerOp->Asl.Value.Integer;
 571             break;
 572
 573         case 6: /* Address Granularity */
 574
 575             Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
 576             RsCreateByteField (InitializerOp, ACPI_RESTAG_GRANULARITY,
 577                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
 578             GranOp = InitializerOp;
 579             break;
 580
 581         case 7: /* Min Address */
 582
 583             Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
 584             RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
 585                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
 586             MinOp = InitializerOp;
 587             break;
 588
 589         case 8: /* Max Address */
 590
 591             Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
 592             RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
 593                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
 594             MaxOp = InitializerOp;
 595             break;
 596
 597         case 9: /* Translation Offset */
 598
 599             Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
 600             RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
 601                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
 602             break;
 603
 604         case 10: /* Address Length */
 605
 606             Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
 607             RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
 608                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
 609             LengthOp = InitializerOp;
 610             break;
 611
 612         case 11: /* Type-Specific Attributes */
 613
 614             Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
 615             RsCreateByteField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
 616                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
 617             break;
 618
 619         case 12: /* ResourceTag */
 620
 621             UtAttachNamepathToOwner (Op, InitializerOp);
 622             break;
 623
 624         default:
 625
 626             AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
 627             break;
 628         }
 629
 630         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
 631     }
 632
 633     /* Validate the Min/Max/Len/Gran values */
 634
 635     RsLargeAddressCheck (
 636         Descriptor->ExtAddress64.Minimum,
 637         Descriptor->ExtAddress64.Maximum,
 638         Descriptor->ExtAddress64.AddressLength,
 639         Descriptor->ExtAddress64.Granularity,
 640         Descriptor->ExtAddress64.Flags,
 641         MinOp, MaxOp, LengthOp, GranOp, Op);
 642
 643     Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + StringLength;
 644     return (Rnode);
 645 }