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

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