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

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