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

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