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