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

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