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

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