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

   1 /******************************************************************************
   2  *
   3  * Module Name: aslrestype2e - Large Extended address resource descriptors
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2013, Intel Corp.
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions, and the following disclaimer,
  16  *    without modification.
  17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  18  *    substantially similar to the "NO WARRANTY" disclaimer below
  19  *    ("Disclaimer") and any redistribution must be conditioned upon
  20  *    including a substantially similar Disclaimer requirement for further
  21  *    binary redistribution.
  22  * 3. Neither the names of the above-listed copyright holders nor the names
  23  *    of any contributors may be used to endorse or promote products derived
  24  *    from this software without specific prior written permission.
  25  *
  26  * Alternatively, this software may be distributed under the terms of the
  27  * GNU General Public License ("GPL") version 2 as published by the Free
  28  * Software Foundation.
  29  *
  30  * NO WARRANTY
  31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  41  * POSSIBILITY OF SUCH DAMAGES.
  42  */
  43
  44
  45 #include <contrib/dev/acpica/compiler/aslcompiler.h>
  46
  47 #define _COMPONENT          ACPI_COMPILER
  48         ACPI_MODULE_NAME    ("aslrestype2e")
  49
  50 /*
  51  * This module contains the Extended (64-bit) address space descriptors:
  52  *
  53  * ExtendedIO
  54  * ExtendedMemory
  55  * ExtendedSpace
  56  */
  57
  58 /*******************************************************************************
  59  *
  60  * FUNCTION:    RsDoExtendedIoDescriptor
  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 "ExtendedIO" descriptor
  69  *
  70  ******************************************************************************/
  71
  72 ASL_RESOURCE_NODE *
  73 RsDoExtendedIoDescriptor (
  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                  i;
  86
  87
  88     InitializerOp = Op->Asl.Child;
  89     StringLength = RsGetStringDataLength (InitializerOp);
  90
  91     Rnode = RsAllocateResourceNode (
  92                 sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength);
  93
  94     Descriptor = Rnode->Buffer;
  95     Descriptor->ExtAddress64.DescriptorType  = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64;
  96     Descriptor->ExtAddress64.ResourceType    = ACPI_ADDRESS_TYPE_IO_RANGE;
  97     Descriptor->ExtAddress64.RevisionID      = AML_RESOURCE_EXTENDED_ADDRESS_REVISION;
  98
  99     Descriptor->ExtAddress64.ResourceLength  = (UINT16)
 100         (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) -
 101          sizeof (AML_RESOURCE_LARGE_HEADER));
 102
 103     /* Process all child initialization nodes */
 104
 105     for (i = 0; InitializerOp; i++)
 106     {
 107         switch (i)
 108         {
 109         case 0: /* Resource Usage */
 110
 111             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1);
 112             break;
 113
 114         case 1: /* MinType */
 115
 116             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0);
 117             RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
 118                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2);
 119             break;
 120
 121         case 2: /* MaxType */
 122
 123             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0);
 124             RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
 125                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3);
 126             break;
 127
 128         case 3: /* DecodeType */
 129
 130             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0);
 131             RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
 132                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1);
 133             break;
 134
 135         case 4: /* Range Type */
 136
 137             RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 0, 3);
 138             RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_RANGETYPE,
 139                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 0, 2);
 140             break;
 141
 142         case 5: /* Address Granularity */
 143
 144             Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
 145             RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
 146                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
 147             GranOp = InitializerOp;
 148            break;
 149
 150         case 6: /* Address Min */
 151
 152             Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
 153             RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR,
 154                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
 155             MinOp = InitializerOp;
 156             break;
 157
 158         case 7: /* Address Max */
 159
 160             Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
 161             RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
 162                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
 163             MaxOp = InitializerOp;
 164             break;
 165
 166         case 8: /* Translation Offset */
 167
 168             Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
 169             RsCreateQwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
 170                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
 171             break;
 172
 173         case 9: /* Address Length */
 174
 175             Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
 176             RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH,
 177                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
 178             LengthOp = InitializerOp;
 179             break;
 180
 181         case 10: /* Type-Specific Attributes */
 182
 183             Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
 184             RsCreateQwordField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
 185                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
 186             break;
 187
 188         case 11: /* ResourceTag */
 189
 190             UtAttachNamepathToOwner (Op, InitializerOp);
 191             break;
 192
 193         case 12: /* Type */
 194
 195             RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 4, 0);
 196             RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
 197                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 4);
 198             break;
 199
 200         case 13: /* Translation Type */
 201
 202             RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 5, 0);
 203             RsCreateBitField (InitializerOp, ACPI_RESTAG_TRANSTYPE,
 204                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 5);
 205             break;
 206
 207         default:
 208
 209             AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
 210             break;
 211         }
 212
 213         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
 214     }
 215
 216     /* Validate the Min/Max/Len/Gran values */
 217
 218     RsLargeAddressCheck (
 219         Descriptor->ExtAddress64.Minimum,
 220         Descriptor->ExtAddress64.Maximum,
 221         Descriptor->ExtAddress64.AddressLength,
 222         Descriptor->ExtAddress64.Granularity,
 223         Descriptor->ExtAddress64.Flags,
 224         MinOp, MaxOp, LengthOp, GranOp, Op);
 225
 226     Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + StringLength;
 227     return (Rnode);
 228 }
 229
 230
 231 /*******************************************************************************
 232  *
 233  * FUNCTION:    RsDoExtendedMemoryDescriptor
 234  *
 235  * PARAMETERS:  Op                  - Parent resource descriptor parse node
 236  *              CurrentByteOffset   - Offset into the resource template AML
 237  *                                    buffer (to track references to the desc)
 238  *
 239  * RETURN:      Completed resource node
 240  *
 241  * DESCRIPTION: Construct a long "ExtendedMemory" descriptor
 242  *
 243  ******************************************************************************/
 244
 245 ASL_RESOURCE_NODE *
 246 RsDoExtendedMemoryDescriptor (
 247     ACPI_PARSE_OBJECT       *Op,
 248     UINT32                  CurrentByteOffset)
 249 {
 250     AML_RESOURCE            *Descriptor;
 251     ACPI_PARSE_OBJECT       *InitializerOp;
 252     ACPI_PARSE_OBJECT       *MinOp = NULL;
 253     ACPI_PARSE_OBJECT       *MaxOp = NULL;
 254     ACPI_PARSE_OBJECT       *LengthOp = NULL;
 255     ACPI_PARSE_OBJECT       *GranOp = NULL;
 256     ASL_RESOURCE_NODE       *Rnode;
 257     UINT16                  StringLength = 0;
 258     UINT32                  i;
 259
 260
 261     InitializerOp = Op->Asl.Child;
 262     StringLength = RsGetStringDataLength (InitializerOp);
 263
 264     Rnode = RsAllocateResourceNode (
 265                 sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength);
 266
 267     Descriptor = Rnode->Buffer;
 268     Descriptor->ExtAddress64.DescriptorType  = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64;
 269     Descriptor->ExtAddress64.ResourceType    = ACPI_ADDRESS_TYPE_MEMORY_RANGE;
 270     Descriptor->ExtAddress64.RevisionID      = AML_RESOURCE_EXTENDED_ADDRESS_REVISION;
 271
 272     Descriptor->ExtAddress64.ResourceLength  = (UINT16)
 273         (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) -
 274          sizeof (AML_RESOURCE_LARGE_HEADER));
 275
 276     /* Process all child initialization nodes */
 277
 278     for (i = 0; InitializerOp; i++)
 279     {
 280         switch (i)
 281         {
 282         case 0: /* Resource Usage */
 283
 284             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1);
 285             break;
 286
 287         case 1: /* DecodeType */
 288
 289             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0);
 290             RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
 291                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1);
 292             break;
 293
 294         case 2: /* MinType */
 295
 296             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0);
 297             RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
 298                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2);
 299             break;
 300
 301         case 3: /* MaxType */
 302
 303             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0);
 304             RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
 305                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3);
 306             break;
 307
 308         case 4: /* Memory Type */
 309
 310             RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 1, 0);
 311             RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_MEMTYPE,
 312                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 1, 2);
 313             break;
 314
 315         case 5: /* Read/Write Type */
 316
 317             RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 0, 1);
 318             RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE,
 319                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 0);
 320             break;
 321
 322         case 6: /* Address Granularity */
 323
 324             Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
 325             RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
 326                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
 327             GranOp = InitializerOp;
 328             break;
 329
 330         case 7: /* Min Address */
 331
 332             Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
 333             RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR,
 334                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
 335             MinOp = InitializerOp;
 336             break;
 337
 338         case 8: /* Max Address */
 339
 340             Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
 341             RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
 342                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
 343             MaxOp = InitializerOp;
 344             break;
 345
 346         case 9: /* Translation Offset */
 347
 348             Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
 349             RsCreateQwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
 350                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
 351             break;
 352
 353         case 10: /* Address Length */
 354
 355             Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
 356             RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH,
 357                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
 358             LengthOp = InitializerOp;
 359             break;
 360
 361         case 11: /* Type-Specific Attributes */
 362
 363             Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
 364             RsCreateQwordField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
 365                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
 366             break;
 367
 368         case 12: /* ResourceTag */
 369
 370             UtAttachNamepathToOwner (Op, InitializerOp);
 371             break;
 372
 373
 374         case 13: /* Address Range */
 375
 376             RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 3, 0);
 377             RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_MEMATTRIBUTES,
 378                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 3, 2);
 379             break;
 380
 381         case 14: /* Type */
 382
 383             RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 5, 0);
 384             RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
 385                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 5);
 386             break;
 387
 388         default:
 389
 390             AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
 391             break;
 392         }
 393
 394         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
 395     }
 396
 397     /* Validate the Min/Max/Len/Gran values */
 398
 399     RsLargeAddressCheck (
 400         Descriptor->ExtAddress64.Minimum,
 401         Descriptor->ExtAddress64.Maximum,
 402         Descriptor->ExtAddress64.AddressLength,
 403         Descriptor->ExtAddress64.Granularity,
 404         Descriptor->ExtAddress64.Flags,
 405         MinOp, MaxOp, LengthOp, GranOp, Op);
 406
 407     Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + StringLength;
 408     return (Rnode);
 409 }
 410
 411
 412 /*******************************************************************************
 413  *
 414  * FUNCTION:    RsDoExtendedSpaceDescriptor
 415  *
 416  * PARAMETERS:  Op                  - Parent resource descriptor parse node
 417  *              CurrentByteOffset   - Offset into the resource template AML
 418  *                                    buffer (to track references to the desc)
 419  *
 420  * RETURN:      Completed resource node
 421  *
 422  * DESCRIPTION: Construct a long "ExtendedSpace" descriptor
 423  *
 424  ******************************************************************************/
 425
 426 ASL_RESOURCE_NODE *
 427 RsDoExtendedSpaceDescriptor (
 428     ACPI_PARSE_OBJECT       *Op,
 429     UINT32                  CurrentByteOffset)
 430 {
 431     AML_RESOURCE            *Descriptor;
 432     ACPI_PARSE_OBJECT       *InitializerOp;
 433     ACPI_PARSE_OBJECT       *MinOp = NULL;
 434     ACPI_PARSE_OBJECT       *MaxOp = NULL;
 435     ACPI_PARSE_OBJECT       *LengthOp = NULL;
 436     ACPI_PARSE_OBJECT       *GranOp = NULL;
 437     ASL_RESOURCE_NODE       *Rnode;
 438     UINT16                  StringLength = 0;
 439     UINT32                  i;
 440
 441
 442     InitializerOp = Op->Asl.Child;
 443     StringLength = RsGetStringDataLength (InitializerOp);
 444
 445     Rnode = RsAllocateResourceNode (
 446                 sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength);
 447
 448     Descriptor = Rnode->Buffer;
 449     Descriptor->ExtAddress64.DescriptorType  = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64;
 450     Descriptor->ExtAddress64.RevisionID      = AML_RESOURCE_EXTENDED_ADDRESS_REVISION;
 451
 452     Descriptor->ExtAddress64.ResourceLength  = (UINT16)
 453         (sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) -
 454          sizeof (AML_RESOURCE_LARGE_HEADER));
 455
 456     /* Process all child initialization nodes */
 457
 458     for (i = 0; InitializerOp; i++)
 459     {
 460         switch (i)
 461         {
 462         case 0: /* Resource Type */
 463
 464             Descriptor->ExtAddress64.ResourceType =
 465                 (UINT8) InitializerOp->Asl.Value.Integer;
 466             break;
 467
 468         case 1: /* Resource Usage */
 469
 470             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1);
 471             break;
 472
 473         case 2: /* DecodeType */
 474
 475             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0);
 476             RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
 477                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1);
 478             break;
 479
 480         case 3: /* MinType */
 481
 482             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0);
 483             RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
 484                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2);
 485             break;
 486
 487         case 4: /* MaxType */
 488
 489             RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0);
 490             RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
 491                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3);
 492             break;
 493
 494         case 5: /* Type-Specific flags */
 495
 496             Descriptor->ExtAddress64.SpecificFlags =
 497                 (UINT8) InitializerOp->Asl.Value.Integer;
 498             break;
 499
 500         case 6: /* Address Granularity */
 501
 502             Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
 503             RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
 504                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
 505             GranOp = InitializerOp;
 506             break;
 507
 508         case 7: /* Min Address */
 509
 510             Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
 511             RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR,
 512                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
 513             MinOp = InitializerOp;
 514             break;
 515
 516         case 8: /* Max Address */
 517
 518             Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
 519             RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
 520                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
 521             MaxOp = InitializerOp;
 522             break;
 523
 524         case 9: /* Translation Offset */
 525
 526             Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
 527             RsCreateQwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
 528                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
 529             break;
 530
 531         case 10: /* Address Length */
 532
 533             Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
 534             RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH,
 535                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
 536             LengthOp = InitializerOp;
 537             break;
 538
 539         case 11: /* Type-Specific Attributes */
 540
 541             Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
 542             RsCreateQwordField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
 543                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
 544             break;
 545
 546         case 12: /* ResourceTag */
 547
 548             UtAttachNamepathToOwner (Op, InitializerOp);
 549             break;
 550
 551         default:
 552
 553             AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
 554             break;
 555         }
 556
 557         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
 558     }
 559
 560     /* Validate the Min/Max/Len/Gran values */
 561
 562     RsLargeAddressCheck (
 563         Descriptor->ExtAddress64.Minimum,
 564         Descriptor->ExtAddress64.Maximum,
 565         Descriptor->ExtAddress64.AddressLength,
 566         Descriptor->ExtAddress64.Granularity,
 567         Descriptor->ExtAddress64.Flags,
 568         MinOp, MaxOp, LengthOp, GranOp, Op);
 569
 570     Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + StringLength;
 571     return (Rnode);
 572 }