sys/contrib/dev/acpica/source/compiler/aslrestype2q.c

   1 /******************************************************************************
   2  *
   3  * Module Name: aslrestype2q - Large QWord address resource descriptors
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2014, Intel Corp.
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions, and the following disclaimer,
  16  *    without modification.
  17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  18  *    substantially similar to the "NO WARRANTY" disclaimer below
  19  *    ("Disclaimer") and any redistribution must be conditioned upon
  20  *    including a substantially similar Disclaimer requirement for further
  21  *    binary redistribution.
  22  * 3. Neither the names of the above-listed copyright holders nor the names
  23  *    of any contributors may be used to endorse or promote products derived
  24  *    from this software without specific prior written permission.
  25  *
  26  * Alternatively, this software may be distributed under the terms of the
  27  * GNU General Public License ("GPL") version 2 as published by the Free
  28  * Software Foundation.
  29  *
  30  * NO WARRANTY
  31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  41  * POSSIBILITY OF SUCH DAMAGES.
  42  */
  43
  44
  45 #include "aslcompiler.h"
  46 #include "aslcompiler.y.h"
  47
  48 #define _COMPONENT          ACPI_COMPILER
  49         ACPI_MODULE_NAME    ("aslrestype2q")
  50
  51 /*
  52  * This module contains the QWord (64-bit) address space descriptors:
  53  *
  54  * QWordIO
  55  * QWordMemory
  56  * QWordSpace
  57  */
  58
  59 /*******************************************************************************
  60  *
  61  * FUNCTION:    RsDoQwordIoDescriptor
  62  *
  63  * PARAMETERS:  Op                  - Parent resource descriptor parse node
  64  *              CurrentByteOffset   - Offset into the resource template AML
  65  *                                    buffer (to track references to the desc)
  66  *
  67  * RETURN:      Completed resource node
  68  *
  69  * DESCRIPTION: Construct a long "QwordIO" descriptor
  70  *
  71  ******************************************************************************/
  72
  73 ASL_RESOURCE_NODE *
  74 RsDoQwordIoDescriptor (
  75     ACPI_PARSE_OBJECT       *Op,
  76     UINT32                  CurrentByteOffset)
  77 {
  78     AML_RESOURCE            *Descriptor;
  79     ACPI_PARSE_OBJECT       *InitializerOp;
  80     ACPI_PARSE_OBJECT       *MinOp = NULL;
  81     ACPI_PARSE_OBJECT       *MaxOp = NULL;
  82     ACPI_PARSE_OBJECT       *LengthOp = NULL;
  83     ACPI_PARSE_OBJECT       *GranOp = NULL;
  84     ASL_RESOURCE_NODE       *Rnode;
  85     UINT8                   *OptionalFields;
  86     UINT16                  StringLength = 0;
  87     UINT32                  OptionIndex = 0;
  88     UINT32                  i;
  89     BOOLEAN                 ResSourceIndex = FALSE;
  90
  91
  92     InitializerOp = Op->Asl.Child;
  93     StringLength = RsGetStringDataLength (InitializerOp);
  94
  95     Rnode = RsAllocateResourceNode (
  96                 sizeof (AML_RESOURCE_ADDRESS64) + 1 + StringLength);
  97
  98     Descriptor = Rnode->Buffer;
  99     Descriptor->Address64.DescriptorType  = ACPI_RESOURCE_NAME_ADDRESS64;
 100     Descriptor->Address64.ResourceType    = ACPI_ADDRESS_TYPE_IO_RANGE;
 101
 102     /*
 103      * Initial descriptor length -- may be enlarged if there are
 104      * optional fields present
 105      */
 106     OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS64);
 107     Descriptor->Address64.ResourceLength = (UINT16)
 108         (sizeof (AML_RESOURCE_ADDRESS64) -
 109          sizeof (AML_RESOURCE_LARGE_HEADER));
 110
 111     /* Process all child initialization nodes */
 112
 113     for (i = 0; InitializerOp; i++)
 114     {
 115         switch (i)
 116         {
 117         case 0: /* Resource Usage */
 118
 119             RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 0, 1);
 120             break;
 121
 122         case 1: /* MinType */
 123
 124             RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 2, 0);
 125             RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
 126                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 2);
 127             break;
 128
 129         case 2: /* MaxType */
 130
 131             RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 3, 0);
 132             RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
 133                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 3);
 134             break;
 135
 136         case 3: /* DecodeType */
 137
 138             RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 1, 0);
 139             RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
 140                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 1);
 141             break;
 142
 143         case 4: /* Range Type */
 144
 145             RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 0, 3);
 146             RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_RANGETYPE,
 147                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 0, 2);
 148             break;
 149
 150         case 5: /* Address Granularity */
 151
 152             Descriptor->Address64.Granularity = InitializerOp->Asl.Value.Integer;
 153             RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
 154                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Granularity));
 155             GranOp = InitializerOp;
 156             break;
 157
 158         case 6: /* Address Min */
 159
 160             Descriptor->Address64.Minimum = InitializerOp->Asl.Value.Integer;
 161             RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR,
 162                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Minimum));
 163             MinOp = InitializerOp;
 164             break;
 165
 166         case 7: /* Address Max */
 167
 168             Descriptor->Address64.Maximum = InitializerOp->Asl.Value.Integer;
 169             RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
 170                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Maximum));
 171             MaxOp = InitializerOp;
 172             break;
 173
 174         case 8: /* Translation Offset */
 175
 176             Descriptor->Address64.TranslationOffset = InitializerOp->Asl.Value.Integer;
 177             RsCreateByteField (InitializerOp, ACPI_RESTAG_TRANSLATION,
 178                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.TranslationOffset));
 179             break;
 180
 181         case 9: /* Address Length */
 182
 183             Descriptor->Address64.AddressLength = InitializerOp->Asl.Value.Integer;
 184             RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH,
 185                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.AddressLength));
 186             LengthOp = InitializerOp;
 187             break;
 188
 189         case 10: /* ResSourceIndex [Optional Field - BYTE] */
 190
 191             if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
 192             {
 193                 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
 194                 OptionIndex++;
 195                 Descriptor->Address64.ResourceLength++;
 196                 ResSourceIndex = TRUE;
 197             }
 198             break;
 199
 200         case 11: /* ResSource [Optional Field - STRING] */
 201
 202             if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
 203                 (InitializerOp->Asl.Value.String))
 204             {
 205                 if (StringLength)
 206                 {
 207                     Descriptor->Address64.ResourceLength = (UINT16)
 208                         (Descriptor->Address64.ResourceLength + StringLength);
 209
 210                     strcpy ((char *)
 211                         &OptionalFields[OptionIndex],
 212                         InitializerOp->Asl.Value.String);
 213
 214                     /* ResourceSourceIndex must also be valid */
 215
 216                     if (!ResSourceIndex)
 217                     {
 218                         AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
 219                             InitializerOp, NULL);
 220                     }
 221                 }
 222             }
 223
 224 #if 0
 225             /*
 226              * Not a valid ResourceSource, ResourceSourceIndex must also
 227              * be invalid
 228              */
 229             else if (ResSourceIndex)
 230             {
 231                 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
 232                     InitializerOp, NULL);
 233             }
 234 #endif
 235             break;
 236
 237         case 12: /* ResourceTag */
 238
 239             UtAttachNamepathToOwner (Op, InitializerOp);
 240             break;
 241
 242         case 13: /* Type */
 243
 244             RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 4, 0);
 245             RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
 246                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 4);
 247             break;
 248
 249         case 14: /* Translation Type */
 250
 251             RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 5, 0);
 252             RsCreateBitField (InitializerOp, ACPI_RESTAG_TRANSTYPE,
 253                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 5);
 254             break;
 255
 256         default:
 257
 258             AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
 259             break;
 260         }
 261
 262         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
 263     }
 264
 265     /* Validate the Min/Max/Len/Gran values */
 266
 267     RsLargeAddressCheck (
 268         Descriptor->Address64.Minimum,
 269         Descriptor->Address64.Maximum,
 270         Descriptor->Address64.AddressLength,
 271         Descriptor->Address64.Granularity,
 272         Descriptor->Address64.Flags,
 273         MinOp, MaxOp, LengthOp, GranOp, Op);
 274
 275     Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS64) +
 276                             OptionIndex + StringLength;
 277     return (Rnode);
 278 }
 279
 280
 281 /*******************************************************************************
 282  *
 283  * FUNCTION:    RsDoQwordMemoryDescriptor
 284  *
 285  * PARAMETERS:  Op                  - Parent resource descriptor parse node
 286  *              CurrentByteOffset   - Offset into the resource template AML
 287  *                                    buffer (to track references to the desc)
 288  *
 289  * RETURN:      Completed resource node
 290  *
 291  * DESCRIPTION: Construct a long "QwordMemory" descriptor
 292  *
 293  ******************************************************************************/
 294
 295 ASL_RESOURCE_NODE *
 296 RsDoQwordMemoryDescriptor (
 297     ACPI_PARSE_OBJECT       *Op,
 298     UINT32                  CurrentByteOffset)
 299 {
 300     AML_RESOURCE            *Descriptor;
 301     ACPI_PARSE_OBJECT       *InitializerOp;
 302     ACPI_PARSE_OBJECT       *MinOp = NULL;
 303     ACPI_PARSE_OBJECT       *MaxOp = NULL;
 304     ACPI_PARSE_OBJECT       *LengthOp = NULL;
 305     ACPI_PARSE_OBJECT       *GranOp = NULL;
 306     ASL_RESOURCE_NODE       *Rnode;
 307     UINT8                   *OptionalFields;
 308     UINT16                  StringLength = 0;
 309     UINT32                  OptionIndex = 0;
 310     UINT32                  i;
 311     BOOLEAN                 ResSourceIndex = FALSE;
 312
 313
 314     InitializerOp = Op->Asl.Child;
 315     StringLength = RsGetStringDataLength (InitializerOp);
 316
 317     Rnode = RsAllocateResourceNode (
 318                 sizeof (AML_RESOURCE_ADDRESS64) + 1 + StringLength);
 319
 320     Descriptor = Rnode->Buffer;
 321     Descriptor->Address64.DescriptorType  = ACPI_RESOURCE_NAME_ADDRESS64;
 322     Descriptor->Address64.ResourceType    = ACPI_ADDRESS_TYPE_MEMORY_RANGE;
 323
 324     /*
 325      * Initial descriptor length -- may be enlarged if there are
 326      * optional fields present
 327      */
 328     OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS64);
 329     Descriptor->Address64.ResourceLength = (UINT16)
 330         (sizeof (AML_RESOURCE_ADDRESS64) -
 331          sizeof (AML_RESOURCE_LARGE_HEADER));
 332
 333     /* Process all child initialization nodes */
 334
 335     for (i = 0; InitializerOp; i++)
 336     {
 337         switch (i)
 338         {
 339         case 0: /* Resource Usage */
 340
 341             RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 0, 1);
 342             break;
 343
 344         case 1: /* DecodeType */
 345
 346             RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 1, 0);
 347             RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
 348                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 1);
 349             break;
 350
 351         case 2: /* MinType */
 352
 353             RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 2, 0);
 354             RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
 355                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 2);
 356             break;
 357
 358         case 3: /* MaxType */
 359
 360             RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 3, 0);
 361             RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
 362                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 3);
 363             break;
 364
 365         case 4: /* Memory Type */
 366
 367             RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 1, 0);
 368             RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_MEMTYPE,
 369                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 1, 2);
 370             break;
 371
 372         case 5: /* Read/Write Type */
 373
 374             RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 0, 1);
 375             RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE,
 376                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 0);
 377             break;
 378
 379         case 6: /* Address Granularity */
 380
 381             Descriptor->Address64.Granularity = InitializerOp->Asl.Value.Integer;
 382             RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
 383                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Granularity));
 384             GranOp = InitializerOp;
 385             break;
 386
 387         case 7: /* Min Address */
 388
 389             Descriptor->Address64.Minimum = InitializerOp->Asl.Value.Integer;
 390             RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR,
 391                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Minimum));
 392             MinOp = InitializerOp;
 393             break;
 394
 395         case 8: /* Max Address */
 396
 397             Descriptor->Address64.Maximum = InitializerOp->Asl.Value.Integer;
 398             RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
 399                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Maximum));
 400             MaxOp = InitializerOp;
 401             break;
 402
 403         case 9: /* Translation Offset */
 404
 405             Descriptor->Address64.TranslationOffset = InitializerOp->Asl.Value.Integer;
 406             RsCreateQwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
 407                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.TranslationOffset));
 408             break;
 409
 410         case 10: /* Address Length */
 411
 412             Descriptor->Address64.AddressLength = InitializerOp->Asl.Value.Integer;
 413             RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH,
 414                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.AddressLength));
 415             LengthOp = InitializerOp;
 416             break;
 417
 418         case 11: /* ResSourceIndex [Optional Field - BYTE] */
 419
 420             if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
 421             {
 422                 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
 423                 OptionIndex++;
 424                 Descriptor->Address64.ResourceLength++;
 425                 ResSourceIndex = TRUE;
 426             }
 427             break;
 428
 429         case 12: /* ResSource [Optional Field - STRING] */
 430
 431             if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
 432                 (InitializerOp->Asl.Value.String))
 433             {
 434                 if (StringLength)
 435                 {
 436                     Descriptor->Address64.ResourceLength = (UINT16)
 437                         (Descriptor->Address64.ResourceLength + StringLength);
 438
 439                     strcpy ((char *)
 440                         &OptionalFields[OptionIndex],
 441                         InitializerOp->Asl.Value.String);
 442
 443                     /* ResourceSourceIndex must also be valid */
 444
 445                     if (!ResSourceIndex)
 446                     {
 447                         AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
 448                             InitializerOp, NULL);
 449                     }
 450                 }
 451             }
 452
 453 #if 0
 454             /*
 455              * Not a valid ResourceSource, ResourceSourceIndex must also
 456              * be invalid
 457              */
 458             else if (ResSourceIndex)
 459             {
 460                 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
 461                     InitializerOp, NULL);
 462             }
 463 #endif
 464             break;
 465
 466         case 13: /* ResourceTag */
 467
 468             UtAttachNamepathToOwner (Op, InitializerOp);
 469             break;
 470
 471
 472         case 14: /* Address Range */
 473
 474             RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 3, 0);
 475             RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_MEMATTRIBUTES,
 476                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 3, 2);
 477             break;
 478
 479         case 15: /* Type */
 480
 481             RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 5, 0);
 482             RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
 483                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 5);
 484             break;
 485
 486         default:
 487
 488             AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
 489             break;
 490         }
 491
 492         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
 493     }
 494
 495     /* Validate the Min/Max/Len/Gran values */
 496
 497     RsLargeAddressCheck (
 498         Descriptor->Address64.Minimum,
 499         Descriptor->Address64.Maximum,
 500         Descriptor->Address64.AddressLength,
 501         Descriptor->Address64.Granularity,
 502         Descriptor->Address64.Flags,
 503         MinOp, MaxOp, LengthOp, GranOp, Op);
 504
 505     Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS64) +
 506                             OptionIndex + StringLength;
 507     return (Rnode);
 508 }
 509
 510
 511 /*******************************************************************************
 512  *
 513  * FUNCTION:    RsDoQwordSpaceDescriptor
 514  *
 515  * PARAMETERS:  Op                  - Parent resource descriptor parse node
 516  *              CurrentByteOffset   - Offset into the resource template AML
 517  *                                    buffer (to track references to the desc)
 518  *
 519  * RETURN:      Completed resource node
 520  *
 521  * DESCRIPTION: Construct a long "QwordSpace" descriptor
 522  *
 523  ******************************************************************************/
 524
 525 ASL_RESOURCE_NODE *
 526 RsDoQwordSpaceDescriptor (
 527     ACPI_PARSE_OBJECT       *Op,
 528     UINT32                  CurrentByteOffset)
 529 {
 530     AML_RESOURCE            *Descriptor;
 531     ACPI_PARSE_OBJECT       *InitializerOp;
 532     ACPI_PARSE_OBJECT       *MinOp = NULL;
 533     ACPI_PARSE_OBJECT       *MaxOp = NULL;
 534     ACPI_PARSE_OBJECT       *LengthOp = NULL;
 535     ACPI_PARSE_OBJECT       *GranOp = NULL;
 536     ASL_RESOURCE_NODE       *Rnode;
 537     UINT8                   *OptionalFields;
 538     UINT16                  StringLength = 0;
 539     UINT32                  OptionIndex = 0;
 540     UINT32                  i;
 541     BOOLEAN                 ResSourceIndex = FALSE;
 542
 543
 544     InitializerOp = Op->Asl.Child;
 545     StringLength = RsGetStringDataLength (InitializerOp);
 546
 547     Rnode = RsAllocateResourceNode (
 548                 sizeof (AML_RESOURCE_ADDRESS64) + 1 + StringLength);
 549
 550     Descriptor = Rnode->Buffer;
 551     Descriptor->Address64.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS64;
 552
 553     /*
 554      * Initial descriptor length -- may be enlarged if there are
 555      * optional fields present
 556      */
 557     OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS64);
 558     Descriptor->Address64.ResourceLength = (UINT16)
 559         (sizeof (AML_RESOURCE_ADDRESS64) -
 560          sizeof (AML_RESOURCE_LARGE_HEADER));
 561
 562     /* Process all child initialization nodes */
 563
 564     for (i = 0; InitializerOp; i++)
 565     {
 566         switch (i)
 567         {
 568         case 0: /* Resource Type */
 569
 570             Descriptor->Address64.ResourceType =
 571                 (UINT8) InitializerOp->Asl.Value.Integer;
 572             break;
 573
 574         case 1: /* Resource Usage */
 575
 576             RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 0, 1);
 577             break;
 578
 579         case 2: /* DecodeType */
 580
 581             RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 1, 0);
 582             RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
 583                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 1);
 584             break;
 585
 586         case 3: /* MinType */
 587
 588             RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 2, 0);
 589             RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
 590                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 2);
 591             break;
 592
 593         case 4: /* MaxType */
 594
 595             RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 3, 0);
 596             RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
 597                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 3);
 598             break;
 599
 600         case 5: /* Type-Specific flags */
 601
 602             Descriptor->Address64.SpecificFlags =
 603                 (UINT8) InitializerOp->Asl.Value.Integer;
 604             break;
 605
 606         case 6: /* Address Granularity */
 607
 608             Descriptor->Address64.Granularity = InitializerOp->Asl.Value.Integer;
 609             RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
 610                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Granularity));
 611             GranOp = InitializerOp;
 612             break;
 613
 614         case 7: /* Min Address */
 615
 616             Descriptor->Address64.Minimum = InitializerOp->Asl.Value.Integer;
 617             RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR,
 618                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Minimum));
 619             MinOp = InitializerOp;
 620             break;
 621
 622         case 8: /* Max Address */
 623
 624             Descriptor->Address64.Maximum = InitializerOp->Asl.Value.Integer;
 625             RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
 626                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Maximum));
 627             MaxOp = InitializerOp;
 628             break;
 629
 630         case 9: /* Translation Offset */
 631
 632             Descriptor->Address64.TranslationOffset = InitializerOp->Asl.Value.Integer;
 633             RsCreateQwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
 634                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.TranslationOffset));
 635             break;
 636
 637         case 10: /* Address Length */
 638
 639             Descriptor->Address64.AddressLength = InitializerOp->Asl.Value.Integer;
 640             RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH,
 641                 CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.AddressLength));
 642             LengthOp = InitializerOp;
 643             break;
 644
 645         case 11: /* ResSourceIndex [Optional Field - BYTE] */
 646
 647             if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
 648             {
 649                 OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
 650                 OptionIndex++;
 651                 Descriptor->Address64.ResourceLength++;
 652                 ResSourceIndex = TRUE;
 653             }
 654             break;
 655
 656         case 12: /* ResSource [Optional Field - STRING] */
 657
 658             if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
 659                 (InitializerOp->Asl.Value.String))
 660             {
 661                 if (StringLength)
 662                 {
 663                     Descriptor->Address64.ResourceLength = (UINT16)
 664                         (Descriptor->Address64.ResourceLength + StringLength);
 665
 666                     strcpy ((char *)
 667                         &OptionalFields[OptionIndex],
 668                         InitializerOp->Asl.Value.String);
 669
 670                     /* ResourceSourceIndex must also be valid */
 671
 672                     if (!ResSourceIndex)
 673                     {
 674                         AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
 675                             InitializerOp, NULL);
 676                     }
 677                 }
 678             }
 679
 680 #if 0
 681             /*
 682              * Not a valid ResourceSource, ResourceSourceIndex must also
 683              * be invalid
 684              */
 685             else if (ResSourceIndex)
 686             {
 687                 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
 688                     InitializerOp, NULL);
 689             }
 690 #endif
 691             break;
 692
 693         case 13: /* ResourceTag */
 694
 695             UtAttachNamepathToOwner (Op, InitializerOp);
 696             break;
 697
 698         default:
 699
 700             AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
 701             break;
 702         }
 703
 704         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
 705     }
 706
 707     /* Validate the Min/Max/Len/Gran values */
 708
 709     RsLargeAddressCheck (
 710         Descriptor->Address64.Minimum,
 711         Descriptor->Address64.Maximum,
 712         Descriptor->Address64.AddressLength,
 713         Descriptor->Address64.Granularity,
 714         Descriptor->Address64.Flags,
 715         MinOp, MaxOp, LengthOp, GranOp, Op);
 716
 717     Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS64) +
 718                             OptionIndex + StringLength;
 719     return (Rnode);
 720 }