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

   1 /******************************************************************************
   2  *
   3  * Module Name: aslrestype2e - Large Extended 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
  46 #define _COMPONENT          ACPI_COMPILER
  47         ACPI_MODULE_NAME    ("aslrestype2e")
  48
  49 /*
  50  * This module contains the Extended (64-bit) address space descriptors:
  51  *
  52  * ExtendedIO
  53  * ExtendedMemory
  54  * ExtendedSpace
  55  */
  56
  57 /*******************************************************************************
  58  *
  59  * FUNCTION:    RsDoExtendedIoDescriptor
  60  *
  61  * PARAMETERS:  Info                - Parse Op and resource template offset
  62  *
  63  * RETURN:      Completed resource node
  64  *
  65  * DESCRIPTION: Construct a long "ExtendedIO" descriptor
  66  *
  67  ******************************************************************************/
  68
  69 ASL_RESOURCE_NODE *
  70 RsDoExtendedIoDescriptor (
  71     ASL_RESOURCE_INFO       *Info)
  72 {
  73     AML_RESOURCE            *Descriptor;
  74     ACPI_PARSE_OBJECT       *InitializerOp;
  75     ACPI_PARSE_OBJECT       *MinOp = NULL;
  76     ACPI_PARSE_OBJECT       *MaxOp = NULL;
  77     ACPI_PARSE_OBJECT       *LengthOp = NULL;
  78     ACPI_PARSE_OBJECT       *GranOp = NULL;
  79     ASL_RESOURCE_NODE       *Rnode;
  80     UINT16                  StringLength = 0;
  81     UINT32                  CurrentByteOffset;
  82     UINT32                  i;
  83
  84
  85     InitializerOp = Info->DescriptorTypeOp->Asl.Child;
  86     StringLength = RsGetStringDataLength (InitializerOp);
  87     CurrentByteOffset = Info->CurrentByteOffset;
  88
  89     Rnode = RsAllocateResourceNode (
  90                 sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength);
  91
  92     Descriptor = Rnode->Buffer;
  93     Descriptor->ExtAddress64.DescriptorType  = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64;
  94     Descriptor->ExtAddress64.ResourceType    = ACPI_ADDRESS_TYPE_IO_RANGE;
  95     Descriptor->ExtAddress64.RevisionID      = AML_RESOURCE_EXTENDED_ADDRESS_REVISION;
  96
  97     Descriptor->ExtAddress64.ResourceLength  = (UINT16)
  98         (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) -
  99          sizeof (AML_RESOURCE_LARGE_HEADER));
 100
 101     /* Process all child initialization nodes */
 102
 103     for (i = 0; InitializerOp; i++)
 104     {
 105         switch (i)
 106         {
 107         case 0: /* Resource Usage */
 108
 109             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1);
 110             break;
 111
 112         case 1: /* MinType */
 113
 114             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0);
 115             RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
 116                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2);
 117             break;
 118
 119         case 2: /* MaxType */
 120
 121             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0);
 122             RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
 123                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3);
 124             break;
 125
 126         case 3: /* DecodeType */
 127
 128             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0);
 129             RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
 130                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1);
 131             break;
 132
 133         case 4: /* Range Type */
 134
 135             RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 0, 3);
 136             RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_RANGETYPE,
 137                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 0, 2);
 138             break;
 139
 140         case 5: /* Address Granularity */
 141
 142             Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
 143             RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
 144                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
 145             GranOp = InitializerOp;
 146            break;
 147
 148         case 6: /* Address Min */
 149
 150             Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
 151             RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR,
 152                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
 153             MinOp = InitializerOp;
 154             break;
 155
 156         case 7: /* Address Max */
 157
 158             Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
 159             RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
 160                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
 161             MaxOp = InitializerOp;
 162             break;
 163
 164         case 8: /* Translation Offset */
 165
 166             Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
 167             RsCreateQwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
 168                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
 169             break;
 170
 171         case 9: /* Address Length */
 172
 173             Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
 174             RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH,
 175                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
 176             LengthOp = InitializerOp;
 177             break;
 178
 179         case 10: /* Type-Specific Attributes */
 180
 181             Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
 182             RsCreateQwordField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
 183                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
 184             break;
 185
 186         case 11: /* ResourceTag */
 187
 188             UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
 189             break;
 190
 191         case 12: /* Type */
 192
 193             RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 4, 0);
 194             RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
 195                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 4);
 196             break;
 197
 198         case 13: /* Translation Type */
 199
 200             RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 5, 0);
 201             RsCreateBitField (InitializerOp, ACPI_RESTAG_TRANSTYPE,
 202                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 5);
 203             break;
 204
 205         default:
 206
 207             AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
 208             break;
 209         }
 210
 211         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
 212     }
 213
 214     /* Validate the Min/Max/Len/Gran values */
 215
 216     RsLargeAddressCheck (
 217         Descriptor->ExtAddress64.Minimum,
 218         Descriptor->ExtAddress64.Maximum,
 219         Descriptor->ExtAddress64.AddressLength,
 220         Descriptor->ExtAddress64.Granularity,
 221         Descriptor->ExtAddress64.Flags,
 222         MinOp, MaxOp, LengthOp, GranOp, Info->DescriptorTypeOp);
 223
 224     Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) +
 225         StringLength;
 226     return (Rnode);
 227 }
 228
 229
 230 /*******************************************************************************
 231  *
 232  * FUNCTION:    RsDoExtendedMemoryDescriptor
 233  *
 234  * PARAMETERS:  Info                - Parse Op and resource template offset
 235  *
 236  * RETURN:      Completed resource node
 237  *
 238  * DESCRIPTION: Construct a long "ExtendedMemory" descriptor
 239  *
 240  ******************************************************************************/
 241
 242 ASL_RESOURCE_NODE *
 243 RsDoExtendedMemoryDescriptor (
 244     ASL_RESOURCE_INFO       *Info)
 245 {
 246     AML_RESOURCE            *Descriptor;
 247     ACPI_PARSE_OBJECT       *InitializerOp;
 248     ACPI_PARSE_OBJECT       *MinOp = NULL;
 249     ACPI_PARSE_OBJECT       *MaxOp = NULL;
 250     ACPI_PARSE_OBJECT       *LengthOp = NULL;
 251     ACPI_PARSE_OBJECT       *GranOp = NULL;
 252     ASL_RESOURCE_NODE       *Rnode;
 253     UINT16                  StringLength = 0;
 254     UINT32                  CurrentByteOffset;
 255     UINT32                  i;
 256
 257
 258     InitializerOp = Info->DescriptorTypeOp->Asl.Child;
 259     StringLength = RsGetStringDataLength (InitializerOp);
 260     CurrentByteOffset = Info->CurrentByteOffset;
 261
 262     Rnode = RsAllocateResourceNode (
 263                 sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength);
 264
 265     Descriptor = Rnode->Buffer;
 266     Descriptor->ExtAddress64.DescriptorType  = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64;
 267     Descriptor->ExtAddress64.ResourceType    = ACPI_ADDRESS_TYPE_MEMORY_RANGE;
 268     Descriptor->ExtAddress64.RevisionID      = AML_RESOURCE_EXTENDED_ADDRESS_REVISION;
 269
 270     Descriptor->ExtAddress64.ResourceLength  = (UINT16)
 271         (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) -
 272          sizeof (AML_RESOURCE_LARGE_HEADER));
 273
 274     /* Process all child initialization nodes */
 275
 276     for (i = 0; InitializerOp; i++)
 277     {
 278         switch (i)
 279         {
 280         case 0: /* Resource Usage */
 281
 282             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1);
 283             break;
 284
 285         case 1: /* DecodeType */
 286
 287             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0);
 288             RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
 289                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1);
 290             break;
 291
 292         case 2: /* MinType */
 293
 294             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0);
 295             RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
 296                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2);
 297             break;
 298
 299         case 3: /* MaxType */
 300
 301             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0);
 302             RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
 303                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3);
 304             break;
 305
 306         case 4: /* Memory Type */
 307
 308             RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 1, 0);
 309             RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_MEMTYPE,
 310                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 1, 2);
 311             break;
 312
 313         case 5: /* Read/Write Type */
 314
 315             RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 0, 1);
 316             RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE,
 317                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 0);
 318             break;
 319
 320         case 6: /* Address Granularity */
 321
 322             Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
 323             RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
 324                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
 325             GranOp = InitializerOp;
 326             break;
 327
 328         case 7: /* Min Address */
 329
 330             Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
 331             RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR,
 332                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
 333             MinOp = InitializerOp;
 334             break;
 335
 336         case 8: /* Max Address */
 337
 338             Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
 339             RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
 340                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
 341             MaxOp = InitializerOp;
 342             break;
 343
 344         case 9: /* Translation Offset */
 345
 346             Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
 347             RsCreateQwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
 348                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
 349             break;
 350
 351         case 10: /* Address Length */
 352
 353             Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
 354             RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH,
 355                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
 356             LengthOp = InitializerOp;
 357             break;
 358
 359         case 11: /* Type-Specific Attributes */
 360
 361             Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
 362             RsCreateQwordField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
 363                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
 364             break;
 365
 366         case 12: /* ResourceTag */
 367
 368             UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
 369             break;
 370
 371
 372         case 13: /* Address Range */
 373
 374             RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 3, 0);
 375             RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_MEMATTRIBUTES,
 376                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 3, 2);
 377             break;
 378
 379         case 14: /* Type */
 380
 381             RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 5, 0);
 382             RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
 383                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 5);
 384             break;
 385
 386         default:
 387
 388             AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
 389             break;
 390         }
 391
 392         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
 393     }
 394
 395     /* Validate the Min/Max/Len/Gran values */
 396
 397     RsLargeAddressCheck (
 398         Descriptor->ExtAddress64.Minimum,
 399         Descriptor->ExtAddress64.Maximum,
 400         Descriptor->ExtAddress64.AddressLength,
 401         Descriptor->ExtAddress64.Granularity,
 402         Descriptor->ExtAddress64.Flags,
 403         MinOp, MaxOp, LengthOp, GranOp, Info->DescriptorTypeOp);
 404
 405     Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) +
 406         StringLength;
 407     return (Rnode);
 408 }
 409
 410
 411 /*******************************************************************************
 412  *
 413  * FUNCTION:    RsDoExtendedSpaceDescriptor
 414  *
 415  * PARAMETERS:  Info                - Parse Op and resource template offset
 416  *
 417  * RETURN:      Completed resource node
 418  *
 419  * DESCRIPTION: Construct a long "ExtendedSpace" descriptor
 420  *
 421  ******************************************************************************/
 422
 423 ASL_RESOURCE_NODE *
 424 RsDoExtendedSpaceDescriptor (
 425     ASL_RESOURCE_INFO       *Info)
 426 {
 427     AML_RESOURCE            *Descriptor;
 428     ACPI_PARSE_OBJECT       *InitializerOp;
 429     ACPI_PARSE_OBJECT       *MinOp = NULL;
 430     ACPI_PARSE_OBJECT       *MaxOp = NULL;
 431     ACPI_PARSE_OBJECT       *LengthOp = NULL;
 432     ACPI_PARSE_OBJECT       *GranOp = NULL;
 433     ASL_RESOURCE_NODE       *Rnode;
 434     UINT16                  StringLength = 0;
 435     UINT32                  CurrentByteOffset;
 436     UINT32                  i;
 437
 438
 439     InitializerOp = Info->DescriptorTypeOp->Asl.Child;
 440     StringLength = RsGetStringDataLength (InitializerOp);
 441     CurrentByteOffset = Info->CurrentByteOffset;
 442
 443     Rnode = RsAllocateResourceNode (
 444                 sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength);
 445
 446     Descriptor = Rnode->Buffer;
 447     Descriptor->ExtAddress64.DescriptorType  = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64;
 448     Descriptor->ExtAddress64.RevisionID      = AML_RESOURCE_EXTENDED_ADDRESS_REVISION;
 449
 450     Descriptor->ExtAddress64.ResourceLength  = (UINT16)
 451         (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) -
 452          sizeof (AML_RESOURCE_LARGE_HEADER));
 453
 454     /* Process all child initialization nodes */
 455
 456     for (i = 0; InitializerOp; i++)
 457     {
 458         switch (i)
 459         {
 460         case 0: /* Resource Type */
 461
 462             Descriptor->ExtAddress64.ResourceType =
 463                 (UINT8) InitializerOp->Asl.Value.Integer;
 464             break;
 465
 466         case 1: /* Resource Usage */
 467
 468             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1);
 469             break;
 470
 471         case 2: /* DecodeType */
 472
 473             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0);
 474             RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
 475                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1);
 476             break;
 477
 478         case 3: /* MinType */
 479
 480             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0);
 481             RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
 482                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2);
 483             break;
 484
 485         case 4: /* MaxType */
 486
 487             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0);
 488             RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
 489                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3);
 490             break;
 491
 492         case 5: /* Type-Specific flags */
 493
 494             Descriptor->ExtAddress64.SpecificFlags =
 495                 (UINT8) InitializerOp->Asl.Value.Integer;
 496             break;
 497
 498         case 6: /* Address Granularity */
 499
 500             Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
 501             RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
 502                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
 503             GranOp = InitializerOp;
 504             break;
 505
 506         case 7: /* Min Address */
 507
 508             Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
 509             RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR,
 510                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
 511             MinOp = InitializerOp;
 512             break;
 513
 514         case 8: /* Max Address */
 515
 516             Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
 517             RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
 518                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
 519             MaxOp = InitializerOp;
 520             break;
 521
 522         case 9: /* Translation Offset */
 523
 524             Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
 525             RsCreateQwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
 526                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
 527             break;
 528
 529         case 10: /* Address Length */
 530
 531             Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
 532             RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH,
 533                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
 534             LengthOp = InitializerOp;
 535             break;
 536
 537         case 11: /* Type-Specific Attributes */
 538
 539             Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
 540             RsCreateQwordField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
 541                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
 542             break;
 543
 544         case 12: /* ResourceTag */
 545
 546             UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
 547             break;
 548
 549         default:
 550
 551             AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
 552             break;
 553         }
 554
 555         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
 556     }
 557
 558     /* Validate the Min/Max/Len/Gran values */
 559
 560     RsLargeAddressCheck (
 561         Descriptor->ExtAddress64.Minimum,
 562         Descriptor->ExtAddress64.Maximum,
 563         Descriptor->ExtAddress64.AddressLength,
 564         Descriptor->ExtAddress64.Granularity,
 565         Descriptor->ExtAddress64.Flags,
 566         MinOp, MaxOp, LengthOp, GranOp, Info->DescriptorTypeOp);
 567
 568     Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) +
 569         StringLength;
 570     return (Rnode);
 571 }