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

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