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

   1 /******************************************************************************
   2  *
   3  * Module Name: aslrestype1 - Miscellaneous small 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 #include "aslcompiler.y.h"
  47
  48 #define _COMPONENT          ACPI_COMPILER
  49         ACPI_MODULE_NAME    ("aslrestype1")
  50
  51 /*
  52  * This module contains miscellaneous small resource descriptors:
  53  *
  54  * EndTag
  55  * EndDependentFn
  56  * Memory24
  57  * Memory32
  58  * Memory32Fixed
  59  * StartDependentFn
  60  * StartDependentFnNoPri
  61  * VendorShort
  62  */
  63
  64 /*******************************************************************************
  65  *
  66  * FUNCTION:    RsDoEndTagDescriptor
  67  *
  68  * PARAMETERS:  Op                  - Parent resource descriptor parse node
  69  *              CurrentByteOffset   - Offset into the resource template AML
  70  *                                    buffer (to track references to the desc)
  71  *
  72  * RETURN:      Completed resource node
  73  *
  74  * DESCRIPTION: Construct a short "EndDependentFn" descriptor
  75  *
  76  ******************************************************************************/
  77
  78 ASL_RESOURCE_NODE *
  79 RsDoEndTagDescriptor (
  80     ACPI_PARSE_OBJECT       *Op,
  81     UINT32                  CurrentByteOffset)
  82 {
  83     AML_RESOURCE            *Descriptor;
  84     ASL_RESOURCE_NODE       *Rnode;
  85
  86
  87     Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_END_TAG));
  88
  89     Descriptor = Rnode->Buffer;
  90     Descriptor->EndTag.DescriptorType = ACPI_RESOURCE_NAME_END_TAG |
  91                                         ASL_RDESC_END_TAG_SIZE;
  92     Descriptor->EndTag.Checksum = 0;
  93
  94     return (Rnode);
  95 }
  96
  97
  98 /*******************************************************************************
  99  *
 100  * FUNCTION:    RsDoEndDependentDescriptor
 101  *
 102  * PARAMETERS:  Op                  - Parent resource descriptor parse node
 103  *              CurrentByteOffset   - Offset into the resource template AML
 104  *                                    buffer (to track references to the desc)
 105  *
 106  * RETURN:      Completed resource node
 107  *
 108  * DESCRIPTION: Construct a short "EndDependentFn" descriptor
 109  *
 110  ******************************************************************************/
 111
 112 ASL_RESOURCE_NODE *
 113 RsDoEndDependentDescriptor (
 114     ACPI_PARSE_OBJECT       *Op,
 115     UINT32                  CurrentByteOffset)
 116 {
 117     AML_RESOURCE            *Descriptor;
 118     ASL_RESOURCE_NODE       *Rnode;
 119
 120
 121     Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_END_DEPENDENT));
 122
 123     Descriptor = Rnode->Buffer;
 124     Descriptor->EndDpf.DescriptorType  = ACPI_RESOURCE_NAME_END_DEPENDENT |
 125                                       ASL_RDESC_END_DEPEND_SIZE;
 126     return (Rnode);
 127 }
 128
 129
 130 /*******************************************************************************
 131  *
 132  * FUNCTION:    RsDoMemory24Descriptor
 133  *
 134  * PARAMETERS:  Op                  - Parent resource descriptor parse node
 135  *              CurrentByteOffset   - Offset into the resource template AML
 136  *                                    buffer (to track references to the desc)
 137  *
 138  * RETURN:      Completed resource node
 139  *
 140  * DESCRIPTION: Construct a short "Memory24" descriptor
 141  *
 142  ******************************************************************************/
 143
 144 ASL_RESOURCE_NODE *
 145 RsDoMemory24Descriptor (
 146     ACPI_PARSE_OBJECT       *Op,
 147     UINT32                  CurrentByteOffset)
 148 {
 149     AML_RESOURCE            *Descriptor;
 150     ACPI_PARSE_OBJECT       *InitializerOp;
 151     ACPI_PARSE_OBJECT       *MinOp = NULL;
 152     ACPI_PARSE_OBJECT       *MaxOp = NULL;
 153     ACPI_PARSE_OBJECT       *LengthOp = NULL;
 154     ASL_RESOURCE_NODE       *Rnode;
 155     UINT32                  i;
 156
 157
 158     InitializerOp = Op->Asl.Child;
 159     Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_MEMORY24));
 160
 161     Descriptor = Rnode->Buffer;
 162     Descriptor->Memory24.DescriptorType  = ACPI_RESOURCE_NAME_MEMORY24;
 163     Descriptor->Memory24.ResourceLength = 9;
 164
 165     /* Process all child initialization nodes */
 166
 167     for (i = 0; InitializerOp; i++)
 168     {
 169         switch (i)
 170         {
 171         case 0: /* Read/Write type */
 172
 173             RsSetFlagBits (&Descriptor->Memory24.Flags, InitializerOp, 0, 1);
 174             RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE,
 175                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory24.Flags), 0);
 176             break;
 177
 178         case 1: /* Min Address */
 179
 180             Descriptor->Memory24.Minimum = (UINT16) InitializerOp->Asl.Value.Integer;
 181             RsCreateWordField (InitializerOp, ACPI_RESTAG_MINADDR,
 182                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory24.Minimum));
 183             MinOp = InitializerOp;
 184             break;
 185
 186         case 2: /* Max Address */
 187
 188             Descriptor->Memory24.Maximum = (UINT16) InitializerOp->Asl.Value.Integer;
 189             RsCreateWordField (InitializerOp, ACPI_RESTAG_MAXADDR,
 190                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory24.Maximum));
 191             MaxOp = InitializerOp;
 192             break;
 193
 194         case 3: /* Alignment */
 195
 196             Descriptor->Memory24.Alignment = (UINT16) InitializerOp->Asl.Value.Integer;
 197             RsCreateWordField (InitializerOp, ACPI_RESTAG_ALIGNMENT,
 198                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory24.Alignment));
 199             break;
 200
 201         case 4: /* Length */
 202
 203             Descriptor->Memory24.AddressLength = (UINT16) InitializerOp->Asl.Value.Integer;
 204             RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH,
 205                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory24.AddressLength));
 206             LengthOp = InitializerOp;
 207             break;
 208
 209         case 5: /* Name */
 210
 211             UtAttachNamepathToOwner (Op, InitializerOp);
 212             break;
 213
 214         default:
 215
 216             AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
 217             break;
 218         }
 219
 220         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
 221     }
 222
 223     /* Validate the Min/Max/Len/Align values (Alignment==0 means 64K) */
 224
 225     RsSmallAddressCheck (ACPI_RESOURCE_NAME_MEMORY24,
 226         Descriptor->Memory24.Minimum,
 227         Descriptor->Memory24.Maximum,
 228         Descriptor->Memory24.AddressLength,
 229         Descriptor->Memory24.Alignment,
 230         MinOp, MaxOp, LengthOp, NULL, Op);
 231
 232     return (Rnode);
 233 }
 234
 235
 236 /*******************************************************************************
 237  *
 238  * FUNCTION:    RsDoMemory32Descriptor
 239  *
 240  * PARAMETERS:  Op                  - Parent resource descriptor parse node
 241  *              CurrentByteOffset   - Offset into the resource template AML
 242  *                                    buffer (to track references to the desc)
 243  *
 244  * RETURN:      Completed resource node
 245  *
 246  * DESCRIPTION: Construct a short "Memory32" descriptor
 247  *
 248  ******************************************************************************/
 249
 250 ASL_RESOURCE_NODE *
 251 RsDoMemory32Descriptor (
 252     ACPI_PARSE_OBJECT       *Op,
 253     UINT32                  CurrentByteOffset)
 254 {
 255     AML_RESOURCE            *Descriptor;
 256     ACPI_PARSE_OBJECT       *InitializerOp;
 257     ACPI_PARSE_OBJECT       *MinOp = NULL;
 258     ACPI_PARSE_OBJECT       *MaxOp = NULL;
 259     ACPI_PARSE_OBJECT       *LengthOp = NULL;
 260     ACPI_PARSE_OBJECT       *AlignOp = NULL;
 261     ASL_RESOURCE_NODE       *Rnode;
 262     UINT32                  i;
 263
 264
 265     InitializerOp = Op->Asl.Child;
 266     Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_MEMORY32));
 267
 268     Descriptor = Rnode->Buffer;
 269     Descriptor->Memory32.DescriptorType  = ACPI_RESOURCE_NAME_MEMORY32;
 270     Descriptor->Memory32.ResourceLength = 17;
 271
 272     /* Process all child initialization nodes */
 273
 274     for (i = 0; InitializerOp; i++)
 275     {
 276         switch (i)
 277         {
 278         case 0: /* Read/Write type */
 279
 280             RsSetFlagBits (&Descriptor->Memory32.Flags, InitializerOp, 0, 1);
 281             RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE,
 282                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory32.Flags), 0);
 283             break;
 284
 285         case 1:  /* Min Address */
 286
 287             Descriptor->Memory32.Minimum = (UINT32) InitializerOp->Asl.Value.Integer;
 288             RsCreateDwordField (InitializerOp, ACPI_RESTAG_MINADDR,
 289                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory32.Minimum));
 290             MinOp = InitializerOp;
 291             break;
 292
 293         case 2: /* Max Address */
 294
 295             Descriptor->Memory32.Maximum = (UINT32) InitializerOp->Asl.Value.Integer;
 296             RsCreateDwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
 297                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory32.Maximum));
 298             MaxOp = InitializerOp;
 299             break;
 300
 301         case 3: /* Alignment */
 302
 303             Descriptor->Memory32.Alignment = (UINT32) InitializerOp->Asl.Value.Integer;
 304             RsCreateDwordField (InitializerOp, ACPI_RESTAG_ALIGNMENT,
 305                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory32.Alignment));
 306             AlignOp = InitializerOp;
 307             break;
 308
 309         case 4: /* Length */
 310
 311             Descriptor->Memory32.AddressLength = (UINT32) InitializerOp->Asl.Value.Integer;
 312             RsCreateDwordField (InitializerOp, ACPI_RESTAG_LENGTH,
 313                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory32.AddressLength));
 314             LengthOp = InitializerOp;
 315             break;
 316
 317         case 5: /* Name */
 318
 319             UtAttachNamepathToOwner (Op, InitializerOp);
 320             break;
 321
 322         default:
 323
 324             AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
 325             break;
 326         }
 327
 328         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
 329     }
 330
 331     /* Validate the Min/Max/Len/Align values */
 332
 333     RsSmallAddressCheck (ACPI_RESOURCE_NAME_MEMORY32,
 334         Descriptor->Memory32.Minimum,
 335         Descriptor->Memory32.Maximum,
 336         Descriptor->Memory32.AddressLength,
 337         Descriptor->Memory32.Alignment,
 338         MinOp, MaxOp, LengthOp, AlignOp, Op);
 339
 340     return (Rnode);
 341 }
 342
 343
 344 /*******************************************************************************
 345  *
 346  * FUNCTION:    RsDoMemory32FixedDescriptor
 347  *
 348  * PARAMETERS:  Op                  - Parent resource descriptor parse node
 349  *              CurrentByteOffset   - Offset into the resource template AML
 350  *                                    buffer (to track references to the desc)
 351  *
 352  * RETURN:      Completed resource node
 353  *
 354  * DESCRIPTION: Construct a short "Memory32Fixed" descriptor
 355  *
 356  ******************************************************************************/
 357
 358 ASL_RESOURCE_NODE *
 359 RsDoMemory32FixedDescriptor (
 360     ACPI_PARSE_OBJECT       *Op,
 361     UINT32                  CurrentByteOffset)
 362 {
 363     AML_RESOURCE            *Descriptor;
 364     ACPI_PARSE_OBJECT       *InitializerOp;
 365     ASL_RESOURCE_NODE       *Rnode;
 366     UINT32                  i;
 367
 368
 369     InitializerOp = Op->Asl.Child;
 370     Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_FIXED_MEMORY32));
 371
 372     Descriptor = Rnode->Buffer;
 373     Descriptor->FixedMemory32.DescriptorType  = ACPI_RESOURCE_NAME_FIXED_MEMORY32;
 374     Descriptor->FixedMemory32.ResourceLength = 9;
 375
 376     /* Process all child initialization nodes */
 377
 378     for (i = 0; InitializerOp; i++)
 379     {
 380         switch (i)
 381         {
 382         case 0: /* Read/Write type */
 383
 384             RsSetFlagBits (&Descriptor->FixedMemory32.Flags, InitializerOp, 0, 1);
 385             RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE,
 386                 CurrentByteOffset + ASL_RESDESC_OFFSET (FixedMemory32.Flags), 0);
 387             break;
 388
 389         case 1: /* Address */
 390
 391             Descriptor->FixedMemory32.Address = (UINT32) InitializerOp->Asl.Value.Integer;
 392             RsCreateDwordField (InitializerOp, ACPI_RESTAG_BASEADDRESS,
 393                 CurrentByteOffset + ASL_RESDESC_OFFSET (FixedMemory32.Address));
 394             break;
 395
 396         case 2: /* Length */
 397
 398             Descriptor->FixedMemory32.AddressLength = (UINT32) InitializerOp->Asl.Value.Integer;
 399             RsCreateDwordField (InitializerOp, ACPI_RESTAG_LENGTH,
 400                 CurrentByteOffset + ASL_RESDESC_OFFSET (FixedMemory32.AddressLength));
 401             break;
 402
 403         case 3: /* Name */
 404
 405             UtAttachNamepathToOwner (Op, InitializerOp);
 406             break;
 407
 408         default:
 409
 410             AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
 411             break;
 412         }
 413
 414         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
 415     }
 416
 417     return (Rnode);
 418 }
 419
 420
 421 /*******************************************************************************
 422  *
 423  * FUNCTION:    RsDoStartDependentDescriptor
 424  *
 425  * PARAMETERS:  Op                  - Parent resource descriptor parse node
 426  *              CurrentByteOffset   - Offset into the resource template AML
 427  *                                    buffer (to track references to the desc)
 428  *
 429  * RETURN:      Completed resource node
 430  *
 431  * DESCRIPTION: Construct a short "StartDependentFn" descriptor
 432  *
 433  ******************************************************************************/
 434
 435 ASL_RESOURCE_NODE *
 436 RsDoStartDependentDescriptor (
 437     ACPI_PARSE_OBJECT       *Op,
 438     UINT32                  CurrentByteOffset)
 439 {
 440     AML_RESOURCE            *Descriptor;
 441     ACPI_PARSE_OBJECT       *InitializerOp;
 442     ASL_RESOURCE_NODE       *Rnode;
 443     ASL_RESOURCE_NODE       *PreviousRnode;
 444     ASL_RESOURCE_NODE       *NextRnode;
 445     UINT32                  i;
 446     UINT8                   State;
 447
 448
 449     InitializerOp = Op->Asl.Child;
 450     Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_START_DEPENDENT));
 451
 452     PreviousRnode = Rnode;
 453     Descriptor = Rnode->Buffer;
 454
 455     /* Increment offset past StartDependent descriptor */
 456
 457     CurrentByteOffset += sizeof (AML_RESOURCE_START_DEPENDENT);
 458
 459     /* Descriptor has priority byte */
 460
 461     Descriptor->StartDpf.DescriptorType  = ACPI_RESOURCE_NAME_START_DEPENDENT |
 462                                       (ASL_RDESC_ST_DEPEND_SIZE + 0x01);
 463
 464     /* Process all child initialization nodes */
 465
 466     State = ACPI_RSTATE_START_DEPENDENT;
 467     for (i = 0; InitializerOp; i++)
 468     {
 469         switch (i)
 470         {
 471         case 0: /* Compatibility Priority */
 472
 473             if ((UINT8) InitializerOp->Asl.Value.Integer > 2)
 474             {
 475                 AslError (ASL_ERROR, ASL_MSG_INVALID_PRIORITY,
 476                     InitializerOp, NULL);
 477             }
 478
 479             RsSetFlagBits (&Descriptor->StartDpf.Flags, InitializerOp, 0, 0);
 480             break;
 481
 482         case 1: /* Performance/Robustness Priority */
 483
 484             if ((UINT8) InitializerOp->Asl.Value.Integer > 2)
 485             {
 486                 AslError (ASL_ERROR, ASL_MSG_INVALID_PERFORMANCE,
 487                     InitializerOp, NULL);
 488             }
 489
 490             RsSetFlagBits (&Descriptor->StartDpf.Flags, InitializerOp, 2, 0);
 491             break;
 492
 493         default:
 494
 495             NextRnode = RsDoOneResourceDescriptor  (InitializerOp,
 496                         CurrentByteOffset, &State);
 497
 498             /*
 499              * Update current byte offset to indicate the number of bytes from the
 500              * start of the buffer. Buffer can include multiple descriptors, we
 501              * must keep track of the offset of not only each descriptor, but each
 502              * element (field) within each descriptor as well.
 503              */
 504             CurrentByteOffset += RsLinkDescriptorChain (&PreviousRnode,
 505                                     NextRnode);
 506             break;
 507         }
 508
 509         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
 510     }
 511
 512     return (Rnode);
 513 }
 514
 515
 516 /*******************************************************************************
 517  *
 518  * FUNCTION:    RsDoStartDependentNoPriDescriptor
 519  *
 520  * PARAMETERS:  Op                  - Parent resource descriptor parse node
 521  *              CurrentByteOffset   - Offset into the resource template AML
 522  *                                    buffer (to track references to the desc)
 523  *
 524  * RETURN:      Completed resource node
 525  *
 526  * DESCRIPTION: Construct a short "StartDependentNoPri" descriptor
 527  *
 528  ******************************************************************************/
 529
 530 ASL_RESOURCE_NODE *
 531 RsDoStartDependentNoPriDescriptor (
 532     ACPI_PARSE_OBJECT       *Op,
 533     UINT32                  CurrentByteOffset)
 534 {
 535     AML_RESOURCE            *Descriptor;
 536     ACPI_PARSE_OBJECT       *InitializerOp;
 537     ASL_RESOURCE_NODE       *Rnode;
 538     ASL_RESOURCE_NODE       *PreviousRnode;
 539     ASL_RESOURCE_NODE       *NextRnode;
 540     UINT8                   State;
 541
 542
 543     InitializerOp = Op->Asl.Child;
 544     Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_START_DEPENDENT_NOPRIO));
 545
 546     Descriptor = Rnode->Buffer;
 547     Descriptor->StartDpf.DescriptorType  = ACPI_RESOURCE_NAME_START_DEPENDENT |
 548                                       ASL_RDESC_ST_DEPEND_SIZE;
 549     PreviousRnode = Rnode;
 550
 551     /* Increment offset past StartDependentNoPri descriptor */
 552
 553     CurrentByteOffset += sizeof (AML_RESOURCE_START_DEPENDENT_NOPRIO);
 554
 555     /* Process all child initialization nodes */
 556
 557     State = ACPI_RSTATE_START_DEPENDENT;
 558     while (InitializerOp)
 559     {
 560         NextRnode = RsDoOneResourceDescriptor  (InitializerOp,
 561                         CurrentByteOffset, &State);
 562
 563         /*
 564          * Update current byte offset to indicate the number of bytes from the
 565          * start of the buffer. Buffer can include multiple descriptors, we
 566          * must keep track of the offset of not only each descriptor, but each
 567          * element (field) within each descriptor as well.
 568          */
 569         CurrentByteOffset += RsLinkDescriptorChain (&PreviousRnode, NextRnode);
 570
 571         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
 572     }
 573
 574     return (Rnode);
 575 }
 576
 577
 578 /*******************************************************************************
 579  *
 580  * FUNCTION:    RsDoVendorSmallDescriptor
 581  *
 582  * PARAMETERS:  Op                  - Parent resource descriptor parse node
 583  *              CurrentByteOffset   - Offset into the resource template AML
 584  *                                    buffer (to track references to the desc)
 585  *
 586  * RETURN:      Completed resource node
 587  *
 588  * DESCRIPTION: Construct a short "VendorShort" descriptor
 589  *
 590  ******************************************************************************/
 591
 592 ASL_RESOURCE_NODE *
 593 RsDoVendorSmallDescriptor (
 594     ACPI_PARSE_OBJECT       *Op,
 595     UINT32                  CurrentByteOffset)
 596 {
 597     AML_RESOURCE            *Descriptor;
 598     ACPI_PARSE_OBJECT       *InitializerOp;
 599     ASL_RESOURCE_NODE       *Rnode;
 600     UINT8                   *VendorData;
 601     UINT32                  i;
 602
 603
 604     InitializerOp = Op->Asl.Child;
 605
 606     /* Allocate worst case - 7 vendor bytes */
 607
 608     Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_VENDOR_SMALL) + 7);
 609
 610     Descriptor = Rnode->Buffer;
 611     Descriptor->VendorSmall.DescriptorType  = ACPI_RESOURCE_NAME_VENDOR_SMALL;
 612     VendorData = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_SMALL_HEADER);
 613
 614     /* Process all child initialization nodes */
 615
 616     InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
 617     for (i = 0; InitializerOp; i++)
 618     {
 619         if (InitializerOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
 620         {
 621             break;
 622         }
 623
 624         /* Maximum 7 vendor data bytes allowed (0-6) */
 625
 626         if (i >= 7)
 627         {
 628             AslError (ASL_ERROR, ASL_MSG_VENDOR_LIST, InitializerOp, NULL);
 629
 630             /* Eat the excess initializers */
 631
 632             while (InitializerOp)
 633             {
 634                 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
 635             }
 636             break;
 637         }
 638
 639         VendorData[i] = (UINT8) InitializerOp->Asl.Value.Integer;
 640         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
 641     }
 642
 643     /* Adjust the Rnode buffer size, so correct number of bytes are emitted */
 644
 645     Rnode->BufferLength -= (7 - i);
 646
 647     /* Set the length in the Type Tag */
 648
 649     Descriptor->VendorSmall.DescriptorType |= (UINT8) i;
 650     return (Rnode);
 651 }