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

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