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