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

   1
   2 /******************************************************************************
   3  *
   4  * Module Name: aslrestype1 - Short (type1) resource templates and descriptors
   5  *
   6  *****************************************************************************/
   7
   8 /******************************************************************************
   9  *
  10  * 1. Copyright Notice
  11  *
  12  * Some or all of this work - Copyright (c) 1999 - 2009, Intel Corp.
  13  * All rights reserved.
  14  *
  15  * 2. License
  16  *
  17  * 2.1. This is your license from Intel Corp. under its intellectual property
  18  * rights.  You may have additional license terms from the party that provided
  19  * you this software, covering your right to use that party's intellectual
  20  * property rights.
  21  *
  22  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  23  * copy of the source code appearing in this file ("Covered Code") an
  24  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  25  * base code distributed originally by Intel ("Original Intel Code") to copy,
  26  * make derivatives, distribute, use and display any portion of the Covered
  27  * Code in any form, with the right to sublicense such rights; and
  28  *
  29  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  30  * license (with the right to sublicense), under only those claims of Intel
  31  * patents that are infringed by the Original Intel Code, to make, use, sell,
  32  * offer to sell, and import the Covered Code and derivative works thereof
  33  * solely to the minimum extent necessary to exercise the above copyright
  34  * license, and in no event shall the patent license extend to any additions
  35  * to or modifications of the Original Intel Code.  No other license or right
  36  * is granted directly or by implication, estoppel or otherwise;
  37  *
  38  * The above copyright and patent license is granted only if the following
  39  * conditions are met:
  40  *
  41  * 3. Conditions
  42  *
  43  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  44  * Redistribution of source code of any substantial portion of the Covered
  45  * Code or modification with rights to further distribute source must include
  46  * the above Copyright Notice, the above License, this list of Conditions,
  47  * and the following Disclaimer and Export Compliance provision.  In addition,
  48  * Licensee must cause all Covered Code to which Licensee contributes to
  49  * contain a file documenting the changes Licensee made to create that Covered
  50  * Code and the date of any change.  Licensee must include in that file the
  51  * documentation of any changes made by any predecessor Licensee.  Licensee
  52  * must include a prominent statement that the modification is derived,
  53  * directly or indirectly, from Original Intel Code.
  54  *
  55  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  56  * Redistribution of source code of any substantial portion of the Covered
  57  * Code or modification without rights to further distribute source must
  58  * include the following Disclaimer and Export Compliance provision in the
  59  * documentation and/or other materials provided with distribution.  In
  60  * addition, Licensee may not authorize further sublicense of source of any
  61  * portion of the Covered Code, and must include terms to the effect that the
  62  * license from Licensee to its licensee is limited to the intellectual
  63  * property embodied in the software Licensee provides to its licensee, and
  64  * not to intellectual property embodied in modifications its licensee may
  65  * make.
  66  *
  67  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  68  * substantial portion of the Covered Code or modification must reproduce the
  69  * above Copyright Notice, and the following Disclaimer and Export Compliance
  70  * provision in the documentation and/or other materials provided with the
  71  * distribution.
  72  *
  73  * 3.4. Intel retains all right, title, and interest in and to the Original
  74  * Intel Code.
  75  *
  76  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  77  * Intel shall be used in advertising or otherwise to promote the sale, use or
  78  * other dealings in products derived from or relating to the Covered Code
  79  * without prior written authorization from Intel.
  80  *
  81  * 4. Disclaimer and Export Compliance
  82  *
  83  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  84  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  85  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  86  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  87  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  88  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  89  * PARTICULAR PURPOSE.
  90  *
  91  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  92  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  93  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  94  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  95  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  96  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  97  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  98  * LIMITED REMEDY.
  99  *
 100  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 101  * software or system incorporating such software without first obtaining any
 102  * required license or other approval from the U. S. Department of Commerce or
 103  * any other agency or department of the United States Government.  In the
 104  * event Licensee exports any such software from the United States or
 105  * re-exports any such software from a foreign destination, Licensee shall
 106  * ensure that the distribution and export/re-export of the software is in
 107  * compliance with all laws, regulations, orders, or other restrictions of the
 108  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 109  * any of its subsidiaries will export/re-export any technical data, process,
 110  * software, or service, directly or indirectly, to any country for which the
 111  * United States government or any agency thereof requires an export license,
 112  * other governmental approval, or letter of assurance, without first obtaining
 113  * such license, approval or letter.
 114  *
 115  *****************************************************************************/
 116
 117
 118 #include "aslcompiler.h"
 119 #include "aslcompiler.y.h"
 120
 121 #define _COMPONENT          ACPI_COMPILER
 122         ACPI_MODULE_NAME    ("aslrestype1")
 123
 124
 125 /*******************************************************************************
 126  *
 127  * FUNCTION:    RsDoEndTagDescriptor
 128  *
 129  * PARAMETERS:  Op                  - Parent resource descriptor parse node
 130  *              CurrentByteOffset   - Offset into the resource template AML
 131  *                                    buffer (to track references to the desc)
 132  *
 133  * RETURN:      Completed resource node
 134  *
 135  * DESCRIPTION: Construct a short "EndDependentFn" descriptor
 136  *
 137  ******************************************************************************/
 138
 139 ASL_RESOURCE_NODE *
 140 RsDoEndTagDescriptor (
 141     ACPI_PARSE_OBJECT       *Op,
 142     UINT32                  CurrentByteOffset)
 143 {
 144     AML_RESOURCE            *Descriptor;
 145     ASL_RESOURCE_NODE       *Rnode;
 146
 147
 148     Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_END_TAG));
 149
 150     Descriptor = Rnode->Buffer;
 151     Descriptor->EndTag.DescriptorType = ACPI_RESOURCE_NAME_END_TAG |
 152                                         ASL_RDESC_END_TAG_SIZE;
 153     Descriptor->EndTag.Checksum = 0;
 154
 155     return (Rnode);
 156 }
 157
 158
 159 /*******************************************************************************
 160  *
 161  * FUNCTION:    RsDoDmaDescriptor
 162  *
 163  * PARAMETERS:  Op                  - Parent resource descriptor parse node
 164  *              CurrentByteOffset   - Offset into the resource template AML
 165  *                                    buffer (to track references to the desc)
 166  *
 167  * RETURN:      Completed resource node
 168  *
 169  * DESCRIPTION: Construct a short "DMA" descriptor
 170  *
 171  ******************************************************************************/
 172
 173 ASL_RESOURCE_NODE *
 174 RsDoDmaDescriptor (
 175     ACPI_PARSE_OBJECT       *Op,
 176     UINT32                  CurrentByteOffset)
 177 {
 178     AML_RESOURCE            *Descriptor;
 179     ACPI_PARSE_OBJECT       *InitializerOp;
 180     ASL_RESOURCE_NODE       *Rnode;
 181     UINT32                  i;
 182     UINT8                   DmaChannelMask = 0;
 183     UINT8                   DmaChannels = 0;
 184
 185
 186     InitializerOp = Op->Asl.Child;
 187     Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_DMA));
 188
 189     Descriptor = Rnode->Buffer;
 190     Descriptor->Dma.DescriptorType  = ACPI_RESOURCE_NAME_DMA |
 191                                         ASL_RDESC_DMA_SIZE;
 192
 193     /* Process all child initialization nodes */
 194
 195     for (i = 0; InitializerOp; i++)
 196     {
 197         switch (i)
 198         {
 199         case 0: /* DMA type */
 200
 201             RsSetFlagBits (&Descriptor->Dma.Flags, InitializerOp, 5, 0);
 202             RsCreateBitField (InitializerOp, ACPI_RESTAG_DMATYPE,
 203                 CurrentByteOffset + ASL_RESDESC_OFFSET (Dma.Flags), 5);
 204             break;
 205
 206         case 1: /* Bus Master */
 207
 208             RsSetFlagBits (&Descriptor->Dma.Flags, InitializerOp, 2, 0);
 209             RsCreateBitField (InitializerOp, ACPI_RESTAG_BUSMASTER,
 210                 CurrentByteOffset + ASL_RESDESC_OFFSET (Dma.Flags), 2);
 211             break;
 212
 213         case 2: /* Xfer Type (transfer width) */
 214
 215             RsSetFlagBits (&Descriptor->Dma.Flags, InitializerOp, 0, 0);
 216             RsCreateBitField (InitializerOp, ACPI_RESTAG_XFERTYPE,
 217                 CurrentByteOffset + ASL_RESDESC_OFFSET (Dma.Flags), 0);
 218             break;
 219
 220         case 3: /* Name */
 221
 222             UtAttachNamepathToOwner (Op, InitializerOp);
 223             break;
 224
 225         default:
 226
 227             /* All DMA channel bytes are handled here, after flags and name */
 228
 229             if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
 230             {
 231                 /* Up to 8 channels can be specified in the list */
 232
 233                 DmaChannels++;
 234                 if (DmaChannels > 8)
 235                 {
 236                     AslError (ASL_ERROR, ASL_MSG_DMA_LIST,
 237                         InitializerOp, NULL);
 238                     return (Rnode);
 239                 }
 240
 241                 /* Only DMA channels 0-7 are allowed (mask is 8 bits) */
 242
 243                 if (InitializerOp->Asl.Value.Integer > 7)
 244                 {
 245                     AslError (ASL_ERROR, ASL_MSG_DMA_CHANNEL,
 246                         InitializerOp, NULL);
 247                 }
 248
 249                 /* Build the mask */
 250
 251                 DmaChannelMask |=
 252                     (1 << ((UINT8) InitializerOp->Asl.Value.Integer));
 253             }
 254
 255             if (i == 4) /* case 4: First DMA byte */
 256             {
 257                 /* Check now for duplicates in list */
 258
 259                 RsCheckListForDuplicates (InitializerOp);
 260
 261                 /* Create a named field at the start of the list */
 262
 263                 RsCreateByteField (InitializerOp, ACPI_RESTAG_DMA,
 264                     CurrentByteOffset +
 265                     ASL_RESDESC_OFFSET (Dma.DmaChannelMask));
 266             }
 267             break;
 268         }
 269
 270         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
 271     }
 272
 273     /* Now we can set the channel mask */
 274
 275     Descriptor->Dma.DmaChannelMask = DmaChannelMask;
 276     return (Rnode);
 277 }
 278
 279
 280 /*******************************************************************************
 281  *
 282  * FUNCTION:    RsDoEndDependentDescriptor
 283  *
 284  * PARAMETERS:  Op                  - Parent resource descriptor parse node
 285  *              CurrentByteOffset   - Offset into the resource template AML
 286  *                                    buffer (to track references to the desc)
 287  *
 288  * RETURN:      Completed resource node
 289  *
 290  * DESCRIPTION: Construct a short "EndDependentFn" descriptor
 291  *
 292  ******************************************************************************/
 293
 294 ASL_RESOURCE_NODE *
 295 RsDoEndDependentDescriptor (
 296     ACPI_PARSE_OBJECT       *Op,
 297     UINT32                  CurrentByteOffset)
 298 {
 299     AML_RESOURCE            *Descriptor;
 300     ASL_RESOURCE_NODE       *Rnode;
 301
 302
 303     Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_END_DEPENDENT));
 304
 305     Descriptor = Rnode->Buffer;
 306     Descriptor->EndDpf.DescriptorType  = ACPI_RESOURCE_NAME_END_DEPENDENT |
 307                                       ASL_RDESC_END_DEPEND_SIZE;
 308     return (Rnode);
 309 }
 310
 311
 312 /*******************************************************************************
 313  *
 314  * FUNCTION:    RsDoFixedIoDescriptor
 315  *
 316  * PARAMETERS:  Op                  - Parent resource descriptor parse node
 317  *              CurrentByteOffset   - Offset into the resource template AML
 318  *                                    buffer (to track references to the desc)
 319  *
 320  * RETURN:      Completed resource node
 321  *
 322  * DESCRIPTION: Construct a short "FixedIO" descriptor
 323  *
 324  ******************************************************************************/
 325
 326 ASL_RESOURCE_NODE *
 327 RsDoFixedIoDescriptor (
 328     ACPI_PARSE_OBJECT       *Op,
 329     UINT32                  CurrentByteOffset)
 330 {
 331     AML_RESOURCE            *Descriptor;
 332     ACPI_PARSE_OBJECT       *InitializerOp;
 333     ASL_RESOURCE_NODE       *Rnode;
 334     UINT32                  i;
 335
 336
 337     InitializerOp = Op->Asl.Child;
 338     Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_FIXED_IO));
 339
 340     Descriptor = Rnode->Buffer;
 341     Descriptor->Io.DescriptorType  = ACPI_RESOURCE_NAME_FIXED_IO |
 342                                       ASL_RDESC_FIXED_IO_SIZE;
 343
 344     /* Process all child initialization nodes */
 345
 346     for (i = 0; InitializerOp; i++)
 347     {
 348         switch (i)
 349         {
 350         case 0: /* Base Address */
 351
 352             Descriptor->FixedIo.Address =
 353                 (UINT16) InitializerOp->Asl.Value.Integer;
 354             RsCreateByteField (InitializerOp, ACPI_RESTAG_BASEADDRESS,
 355                 CurrentByteOffset + ASL_RESDESC_OFFSET (FixedIo.Address));
 356             break;
 357
 358         case 1: /* Length */
 359
 360             Descriptor->FixedIo.AddressLength =
 361                 (UINT8) InitializerOp->Asl.Value.Integer;
 362             RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
 363                 CurrentByteOffset + ASL_RESDESC_OFFSET (FixedIo.AddressLength));
 364             break;
 365
 366         case 2: /* Name */
 367
 368             UtAttachNamepathToOwner (Op, InitializerOp);
 369             break;
 370
 371         default:
 372
 373             AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
 374             break;
 375         }
 376
 377         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
 378     }
 379
 380     return (Rnode);
 381 }
 382
 383
 384 /*******************************************************************************
 385  *
 386  * FUNCTION:    RsDoIoDescriptor
 387  *
 388  * PARAMETERS:  Op                  - Parent resource descriptor parse node
 389  *              CurrentByteOffset   - Offset into the resource template AML
 390  *                                    buffer (to track references to the desc)
 391  *
 392  * RETURN:      Completed resource node
 393  *
 394  * DESCRIPTION: Construct a short "IO" descriptor
 395  *
 396  ******************************************************************************/
 397
 398 ASL_RESOURCE_NODE *
 399 RsDoIoDescriptor (
 400     ACPI_PARSE_OBJECT       *Op,
 401     UINT32                  CurrentByteOffset)
 402 {
 403     AML_RESOURCE            *Descriptor;
 404     ACPI_PARSE_OBJECT       *InitializerOp;
 405     ASL_RESOURCE_NODE       *Rnode;
 406     UINT32                  i;
 407
 408
 409     InitializerOp = Op->Asl.Child;
 410     Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_IO));
 411
 412     Descriptor = Rnode->Buffer;
 413     Descriptor->Io.DescriptorType  = ACPI_RESOURCE_NAME_IO |
 414                                       ASL_RDESC_IO_SIZE;
 415
 416     /* Process all child initialization nodes */
 417
 418     for (i = 0; InitializerOp; i++)
 419     {
 420         switch (i)
 421         {
 422         case 0: /* Decode size */
 423
 424             RsSetFlagBits (&Descriptor->Io.Flags, InitializerOp, 0, 1);
 425             RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
 426                 CurrentByteOffset + ASL_RESDESC_OFFSET (Io.Flags), 0);
 427             break;
 428
 429         case 1:  /* Min Address */
 430
 431             Descriptor->Io.Minimum =
 432                 (UINT16) InitializerOp->Asl.Value.Integer;
 433             RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
 434                 CurrentByteOffset + ASL_RESDESC_OFFSET (Io.Minimum));
 435             break;
 436
 437         case 2: /* Max Address */
 438
 439             Descriptor->Io.Maximum =
 440                 (UINT16) InitializerOp->Asl.Value.Integer;
 441             RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
 442                 CurrentByteOffset + ASL_RESDESC_OFFSET (Io.Maximum));
 443             break;
 444
 445         case 3: /* Alignment */
 446
 447             Descriptor->Io.Alignment =
 448                 (UINT8) InitializerOp->Asl.Value.Integer;
 449             RsCreateByteField (InitializerOp, ACPI_RESTAG_ALIGNMENT,
 450                 CurrentByteOffset + ASL_RESDESC_OFFSET (Io.Alignment));
 451             break;
 452
 453         case 4: /* Length */
 454
 455             Descriptor->Io.AddressLength =
 456                 (UINT8) InitializerOp->Asl.Value.Integer;
 457             RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
 458                 CurrentByteOffset + ASL_RESDESC_OFFSET (Io.AddressLength));
 459             break;
 460
 461         case 5: /* Name */
 462
 463             UtAttachNamepathToOwner (Op, InitializerOp);
 464             break;
 465
 466         default:
 467
 468             AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
 469             break;
 470         }
 471
 472         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
 473     }
 474
 475     return (Rnode);
 476 }
 477
 478
 479 /*******************************************************************************
 480  *
 481  * FUNCTION:    RsDoIrqDescriptor
 482  *
 483  * PARAMETERS:  Op                  - Parent resource descriptor parse node
 484  *              CurrentByteOffset   - Offset into the resource template AML
 485  *                                    buffer (to track references to the desc)
 486  *
 487  * RETURN:      Completed resource node
 488  *
 489  * DESCRIPTION: Construct a short "IRQ" descriptor
 490  *
 491  ******************************************************************************/
 492
 493 ASL_RESOURCE_NODE *
 494 RsDoIrqDescriptor (
 495     ACPI_PARSE_OBJECT       *Op,
 496     UINT32                  CurrentByteOffset)
 497 {
 498     AML_RESOURCE            *Descriptor;
 499     ACPI_PARSE_OBJECT       *InitializerOp;
 500     ASL_RESOURCE_NODE       *Rnode;
 501     UINT32                  Interrupts = 0;
 502     UINT16                  IrqMask = 0;
 503     UINT32                  i;
 504
 505
 506     InitializerOp = Op->Asl.Child;
 507     Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_IRQ));
 508
 509     /* Length = 3 (with flag byte) */
 510
 511     Descriptor = Rnode->Buffer;
 512     Descriptor->Irq.DescriptorType  = ACPI_RESOURCE_NAME_IRQ |
 513                                       (ASL_RDESC_IRQ_SIZE + 0x01);
 514
 515     /* Process all child initialization nodes */
 516
 517     for (i = 0; InitializerOp; i++)
 518     {
 519         switch (i)
 520         {
 521         case 0: /* Interrupt Type (or Mode - edge/level) */
 522
 523             RsSetFlagBits (&Descriptor->Irq.Flags, InitializerOp, 0, 1);
 524             RsCreateBitField (InitializerOp, ACPI_RESTAG_INTERRUPTTYPE,
 525                 CurrentByteOffset + ASL_RESDESC_OFFSET (Irq.Flags), 0);
 526             break;
 527
 528         case 1: /* Interrupt Level (or Polarity - Active high/low) */
 529
 530             RsSetFlagBits (&Descriptor->Irq.Flags, InitializerOp, 3, 0);
 531             RsCreateBitField (InitializerOp, ACPI_RESTAG_INTERRUPTLEVEL,
 532                 CurrentByteOffset + ASL_RESDESC_OFFSET (Irq.Flags), 3);
 533             break;
 534
 535         case 2: /* Share Type - Default: exclusive (0) */
 536
 537             RsSetFlagBits (&Descriptor->Irq.Flags, InitializerOp, 4, 0);
 538             RsCreateBitField (InitializerOp, ACPI_RESTAG_INTERRUPTSHARE,
 539                 CurrentByteOffset + ASL_RESDESC_OFFSET (Irq.Flags), 4);
 540             break;
 541
 542         case 3: /* Name */
 543
 544             UtAttachNamepathToOwner (Op, InitializerOp);
 545             break;
 546
 547         default:
 548
 549             /* All IRQ bytes are handled here, after the flags and name */
 550
 551             if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
 552             {
 553                 /* Up to 16 interrupts can be specified in the list */
 554
 555                 Interrupts++;
 556                 if (Interrupts > 16)
 557                 {
 558                     AslError (ASL_ERROR, ASL_MSG_INTERRUPT_LIST,
 559                         InitializerOp, NULL);
 560                     return (Rnode);
 561                 }
 562
 563                 /* Only interrupts 0-15 are allowed (mask is 16 bits) */
 564
 565                 if (InitializerOp->Asl.Value.Integer > 15)
 566                 {
 567                     AslError (ASL_ERROR, ASL_MSG_INTERRUPT_NUMBER,
 568                         InitializerOp, NULL);
 569                 }
 570                 else
 571                 {
 572                     IrqMask |= (1 << (UINT8) InitializerOp->Asl.Value.Integer);
 573                 }
 574             }
 575
 576             /* Case 4: First IRQ value in list */
 577
 578             if (i == 4)
 579             {
 580                 /* Check now for duplicates in list */
 581
 582                 RsCheckListForDuplicates (InitializerOp);
 583
 584                 /* Create a named field at the start of the list */
 585
 586                 RsCreateByteField (InitializerOp, ACPI_RESTAG_INTERRUPT,
 587                     CurrentByteOffset + ASL_RESDESC_OFFSET (Irq.IrqMask));
 588             }
 589             break;
 590         }
 591
 592         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
 593     }
 594
 595     /* Now we can set the channel mask */
 596
 597     Descriptor->Irq.IrqMask = IrqMask;
 598     return (Rnode);
 599 }
 600
 601
 602 /*******************************************************************************
 603  *
 604  * FUNCTION:    RsDoIrqNoFlagsDescriptor
 605  *
 606  * PARAMETERS:  Op                  - Parent resource descriptor parse node
 607  *              CurrentByteOffset   - Offset into the resource template AML
 608  *                                    buffer (to track references to the desc)
 609  *
 610  * RETURN:      Completed resource node
 611  *
 612  * DESCRIPTION: Construct a short "IRQNoFlags" descriptor
 613  *
 614  ******************************************************************************/
 615
 616 ASL_RESOURCE_NODE *
 617 RsDoIrqNoFlagsDescriptor (
 618     ACPI_PARSE_OBJECT       *Op,
 619     UINT32                  CurrentByteOffset)
 620 {
 621     AML_RESOURCE            *Descriptor;
 622     ACPI_PARSE_OBJECT       *InitializerOp;
 623     ASL_RESOURCE_NODE       *Rnode;
 624     UINT16                  IrqMask = 0;
 625     UINT32                  Interrupts = 0;
 626     UINT32                  i;
 627
 628
 629     InitializerOp = Op->Asl.Child;
 630     Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_IRQ_NOFLAGS));
 631
 632     Descriptor = Rnode->Buffer;
 633     Descriptor->Irq.DescriptorType  = ACPI_RESOURCE_NAME_IRQ |
 634                                       ASL_RDESC_IRQ_SIZE;
 635
 636     /* Process all child initialization nodes */
 637
 638     for (i = 0; InitializerOp; i++)
 639     {
 640         switch (i)
 641         {
 642         case 0: /* Name */
 643
 644             UtAttachNamepathToOwner (Op, InitializerOp);
 645             break;
 646
 647         default:
 648
 649             /* IRQ bytes are handled here, after the flags and name */
 650
 651             if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
 652             {
 653                 /* Up to 16 interrupts can be specified in the list */
 654
 655                 Interrupts++;
 656                 if (Interrupts > 16)
 657                 {
 658                     AslError (ASL_ERROR, ASL_MSG_INTERRUPT_LIST,
 659                         InitializerOp, NULL);
 660                     return (Rnode);
 661                 }
 662
 663                 /* Only interrupts 0-15 are allowed (mask is 16 bits) */
 664
 665                 if (InitializerOp->Asl.Value.Integer > 15)
 666                 {
 667                     AslError (ASL_ERROR, ASL_MSG_INTERRUPT_NUMBER,
 668                         InitializerOp, NULL);
 669                 }
 670                 else
 671                 {
 672                     IrqMask |= (1 << ((UINT8) InitializerOp->Asl.Value.Integer));
 673                 }
 674             }
 675
 676             /* Case 1: First IRQ value in list */
 677
 678             if (i == 1)
 679             {
 680                 /* Check now for duplicates in list */
 681
 682                 RsCheckListForDuplicates (InitializerOp);
 683
 684                 /* Create a named field at the start of the list */
 685
 686                 RsCreateByteField (InitializerOp, ACPI_RESTAG_INTERRUPT,
 687                     CurrentByteOffset + ASL_RESDESC_OFFSET (Irq.IrqMask));
 688             }
 689             break;
 690         }
 691
 692         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
 693     }
 694
 695     /* Now we can set the interrupt mask */
 696
 697     Descriptor->Irq.IrqMask = IrqMask;
 698     return (Rnode);
 699 }
 700
 701
 702 /*******************************************************************************
 703  *
 704  * FUNCTION:    RsDoMemory24Descriptor
 705  *
 706  * PARAMETERS:  Op                  - Parent resource descriptor parse node
 707  *              CurrentByteOffset   - Offset into the resource template AML
 708  *                                    buffer (to track references to the desc)
 709  *
 710  * RETURN:      Completed resource node
 711  *
 712  * DESCRIPTION: Construct a short "Memory24" descriptor
 713  *
 714  ******************************************************************************/
 715
 716 ASL_RESOURCE_NODE *
 717 RsDoMemory24Descriptor (
 718     ACPI_PARSE_OBJECT       *Op,
 719     UINT32                  CurrentByteOffset)
 720 {
 721     AML_RESOURCE            *Descriptor;
 722     ACPI_PARSE_OBJECT       *InitializerOp;
 723     ASL_RESOURCE_NODE       *Rnode;
 724     UINT32                  i;
 725
 726
 727     InitializerOp = Op->Asl.Child;
 728     Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_MEMORY24));
 729
 730     Descriptor = Rnode->Buffer;
 731     Descriptor->Memory24.DescriptorType  = ACPI_RESOURCE_NAME_MEMORY24;
 732     Descriptor->Memory24.ResourceLength = 9;
 733
 734     /* Process all child initialization nodes */
 735
 736     for (i = 0; InitializerOp; i++)
 737     {
 738         switch (i)
 739         {
 740         case 0: /* Read/Write type */
 741
 742             RsSetFlagBits (&Descriptor->Memory24.Flags, InitializerOp, 0, 1);
 743             RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE,
 744                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory24.Flags), 0);
 745             break;
 746
 747         case 1: /* Min Address */
 748
 749             Descriptor->Memory24.Minimum = (UINT16) InitializerOp->Asl.Value.Integer;
 750             RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
 751                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory24.Minimum));
 752             break;
 753
 754         case 2: /* Max Address */
 755
 756             Descriptor->Memory24.Maximum = (UINT16) InitializerOp->Asl.Value.Integer;
 757             RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
 758                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory24.Maximum));
 759             break;
 760
 761         case 3: /* Alignment */
 762
 763             Descriptor->Memory24.Alignment = (UINT16) InitializerOp->Asl.Value.Integer;
 764             RsCreateByteField (InitializerOp, ACPI_RESTAG_ALIGNMENT,
 765                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory24.Alignment));
 766             break;
 767
 768         case 4: /* Length */
 769
 770             Descriptor->Memory24.AddressLength = (UINT16) InitializerOp->Asl.Value.Integer;
 771             RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
 772                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory24.AddressLength));
 773             break;
 774
 775         case 5: /* Name */
 776
 777             UtAttachNamepathToOwner (Op, InitializerOp);
 778             break;
 779
 780         default:
 781
 782             AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
 783             break;
 784         }
 785
 786         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
 787     }
 788
 789     return (Rnode);
 790 }
 791
 792
 793 /*******************************************************************************
 794  *
 795  * FUNCTION:    RsDoMemory32Descriptor
 796  *
 797  * PARAMETERS:  Op                  - Parent resource descriptor parse node
 798  *              CurrentByteOffset   - Offset into the resource template AML
 799  *                                    buffer (to track references to the desc)
 800  *
 801  * RETURN:      Completed resource node
 802  *
 803  * DESCRIPTION: Construct a short "Memory32" descriptor
 804  *
 805  ******************************************************************************/
 806
 807 ASL_RESOURCE_NODE *
 808 RsDoMemory32Descriptor (
 809     ACPI_PARSE_OBJECT       *Op,
 810     UINT32                  CurrentByteOffset)
 811 {
 812     AML_RESOURCE            *Descriptor;
 813     ACPI_PARSE_OBJECT       *InitializerOp;
 814     ASL_RESOURCE_NODE       *Rnode;
 815     UINT32                  i;
 816
 817
 818     InitializerOp = Op->Asl.Child;
 819     Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_MEMORY32));
 820
 821     Descriptor = Rnode->Buffer;
 822     Descriptor->Memory32.DescriptorType  = ACPI_RESOURCE_NAME_MEMORY32;
 823     Descriptor->Memory32.ResourceLength = 17;
 824
 825     /* Process all child initialization nodes */
 826
 827     for (i = 0; InitializerOp; i++)
 828     {
 829         switch (i)
 830         {
 831         case 0: /* Read/Write type */
 832
 833             RsSetFlagBits (&Descriptor->Memory32.Flags, InitializerOp, 0, 1);
 834             RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE,
 835                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory32.Flags), 0);
 836             break;
 837
 838         case 1:  /* Min Address */
 839
 840             Descriptor->Memory32.Minimum = (UINT32) InitializerOp->Asl.Value.Integer;
 841             RsCreateByteField (InitializerOp, ACPI_RESTAG_MINADDR,
 842                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory32.Minimum));
 843             break;
 844
 845         case 2: /* Max Address */
 846
 847             Descriptor->Memory32.Maximum = (UINT32) InitializerOp->Asl.Value.Integer;
 848             RsCreateByteField (InitializerOp, ACPI_RESTAG_MAXADDR,
 849                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory32.Maximum));
 850             break;
 851
 852         case 3: /* Alignment */
 853
 854             Descriptor->Memory32.Alignment = (UINT32) InitializerOp->Asl.Value.Integer;
 855             RsCreateByteField (InitializerOp, ACPI_RESTAG_ALIGNMENT,
 856                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory32.Alignment));
 857             break;
 858
 859         case 4: /* Length */
 860
 861             Descriptor->Memory32.AddressLength = (UINT32) InitializerOp->Asl.Value.Integer;
 862             RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
 863                 CurrentByteOffset + ASL_RESDESC_OFFSET (Memory32.AddressLength));
 864             break;
 865
 866         case 5: /* Name */
 867
 868             UtAttachNamepathToOwner (Op, InitializerOp);
 869             break;
 870
 871         default:
 872
 873             AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
 874             break;
 875         }
 876
 877         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
 878     }
 879
 880     return (Rnode);
 881 }
 882
 883
 884 /*******************************************************************************
 885  *
 886  * FUNCTION:    RsDoMemory32FixedDescriptor
 887  *
 888  * PARAMETERS:  Op                  - Parent resource descriptor parse node
 889  *              CurrentByteOffset   - Offset into the resource template AML
 890  *                                    buffer (to track references to the desc)
 891  *
 892  * RETURN:      Completed resource node
 893  *
 894  * DESCRIPTION: Construct a short "Memory32Fixed" descriptor
 895  *
 896  ******************************************************************************/
 897
 898 ASL_RESOURCE_NODE *
 899 RsDoMemory32FixedDescriptor (
 900     ACPI_PARSE_OBJECT       *Op,
 901     UINT32                  CurrentByteOffset)
 902 {
 903     AML_RESOURCE            *Descriptor;
 904     ACPI_PARSE_OBJECT       *InitializerOp;
 905     ASL_RESOURCE_NODE       *Rnode;
 906     UINT32                  i;
 907
 908
 909     InitializerOp = Op->Asl.Child;
 910     Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_FIXED_MEMORY32));
 911
 912     Descriptor = Rnode->Buffer;
 913     Descriptor->FixedMemory32.DescriptorType  = ACPI_RESOURCE_NAME_FIXED_MEMORY32;
 914     Descriptor->FixedMemory32.ResourceLength = 9;
 915
 916     /* Process all child initialization nodes */
 917
 918     for (i = 0; InitializerOp; i++)
 919     {
 920         switch (i)
 921         {
 922         case 0: /* Read/Write type */
 923
 924             RsSetFlagBits (&Descriptor->FixedMemory32.Flags, InitializerOp, 0, 1);
 925             RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE,
 926                 CurrentByteOffset + ASL_RESDESC_OFFSET (FixedMemory32.Flags), 0);
 927             break;
 928
 929         case 1: /* Address */
 930
 931             Descriptor->FixedMemory32.Address = (UINT32) InitializerOp->Asl.Value.Integer;
 932             RsCreateByteField (InitializerOp, ACPI_RESTAG_BASEADDRESS,
 933                 CurrentByteOffset + ASL_RESDESC_OFFSET (FixedMemory32.Address));
 934             break;
 935
 936         case 2: /* Length */
 937
 938             Descriptor->FixedMemory32.AddressLength = (UINT32) InitializerOp->Asl.Value.Integer;
 939             RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
 940                 CurrentByteOffset + ASL_RESDESC_OFFSET (FixedMemory32.AddressLength));
 941             break;
 942
 943         case 3: /* Name */
 944
 945             UtAttachNamepathToOwner (Op, InitializerOp);
 946             break;
 947
 948         default:
 949
 950             AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
 951             break;
 952         }
 953
 954         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
 955     }
 956
 957     return (Rnode);
 958 }
 959
 960
 961 /*******************************************************************************
 962  *
 963  * FUNCTION:    RsDoStartDependentDescriptor
 964  *
 965  * PARAMETERS:  Op                  - Parent resource descriptor parse node
 966  *              CurrentByteOffset   - Offset into the resource template AML
 967  *                                    buffer (to track references to the desc)
 968  *
 969  * RETURN:      Completed resource node
 970  *
 971  * DESCRIPTION: Construct a short "StartDependentFn" descriptor
 972  *
 973  ******************************************************************************/
 974
 975 ASL_RESOURCE_NODE *
 976 RsDoStartDependentDescriptor (
 977     ACPI_PARSE_OBJECT       *Op,
 978     UINT32                  CurrentByteOffset)
 979 {
 980     AML_RESOURCE            *Descriptor;
 981     ACPI_PARSE_OBJECT       *InitializerOp;
 982     ASL_RESOURCE_NODE       *Rnode;
 983     ASL_RESOURCE_NODE       *PreviousRnode;
 984     ASL_RESOURCE_NODE       *NextRnode;
 985     UINT32                  i;
 986     UINT8                   State;
 987
 988
 989     InitializerOp = Op->Asl.Child;
 990     Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_START_DEPENDENT));
 991
 992     PreviousRnode = Rnode;
 993     Descriptor = Rnode->Buffer;
 994
 995     /* Descriptor has priority byte */
 996
 997     Descriptor->StartDpf.DescriptorType  = ACPI_RESOURCE_NAME_START_DEPENDENT |
 998                                       (ASL_RDESC_ST_DEPEND_SIZE + 0x01);
 999
1000     /* Process all child initialization nodes */
1001
1002     State = ACPI_RSTATE_START_DEPENDENT;
1003     for (i = 0; InitializerOp; i++)
1004     {
1005         switch (i)
1006         {
1007         case 0: /* Compatibility Priority */
1008
1009             if ((UINT8) InitializerOp->Asl.Value.Integer > 2)
1010             {
1011                 AslError (ASL_ERROR, ASL_MSG_INVALID_PRIORITY,
1012                     InitializerOp, NULL);
1013             }
1014
1015             RsSetFlagBits (&Descriptor->StartDpf.Flags, InitializerOp, 0, 0);
1016             break;
1017
1018         case 1: /* Performance/Robustness Priority */
1019
1020             if ((UINT8) InitializerOp->Asl.Value.Integer > 2)
1021             {
1022                 AslError (ASL_ERROR, ASL_MSG_INVALID_PERFORMANCE,
1023                     InitializerOp, NULL);
1024             }
1025
1026             RsSetFlagBits (&Descriptor->StartDpf.Flags, InitializerOp, 2, 0);
1027             break;
1028
1029         default:
1030             NextRnode = RsDoOneResourceDescriptor  (InitializerOp,
1031                         CurrentByteOffset, &State);
1032
1033             /*
1034              * Update current byte offset to indicate the number of bytes from the
1035              * start of the buffer.  Buffer can include multiple descriptors, we
1036              * must keep track of the offset of not only each descriptor, but each
1037              * element (field) within each descriptor as well.
1038              */
1039
1040             CurrentByteOffset += RsLinkDescriptorChain (&PreviousRnode,
1041                                     NextRnode);
1042             break;
1043         }
1044
1045         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
1046     }
1047
1048     return (Rnode);
1049 }
1050
1051
1052 /*******************************************************************************
1053  *
1054  * FUNCTION:    RsDoStartDependentNoPriDescriptor
1055  *
1056  * PARAMETERS:  Op                  - Parent resource descriptor parse node
1057  *              CurrentByteOffset   - Offset into the resource template AML
1058  *                                    buffer (to track references to the desc)
1059  *
1060  * RETURN:      Completed resource node
1061  *
1062  * DESCRIPTION: Construct a short "StartDependentNoPri" descriptor
1063  *
1064  ******************************************************************************/
1065
1066 ASL_RESOURCE_NODE *
1067 RsDoStartDependentNoPriDescriptor (
1068     ACPI_PARSE_OBJECT       *Op,
1069     UINT32                  CurrentByteOffset)
1070 {
1071     AML_RESOURCE            *Descriptor;
1072     ACPI_PARSE_OBJECT       *InitializerOp;
1073     ASL_RESOURCE_NODE       *Rnode;
1074     ASL_RESOURCE_NODE       *PreviousRnode;
1075     ASL_RESOURCE_NODE       *NextRnode;
1076     UINT8                   State;
1077
1078
1079     InitializerOp = Op->Asl.Child;
1080     Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_START_DEPENDENT_NOPRIO));
1081
1082     Descriptor = Rnode->Buffer;
1083     Descriptor->StartDpf.DescriptorType  = ACPI_RESOURCE_NAME_START_DEPENDENT |
1084                                       ASL_RDESC_ST_DEPEND_SIZE;
1085     PreviousRnode = Rnode;
1086
1087     /* Process all child initialization nodes */
1088
1089     State = ACPI_RSTATE_START_DEPENDENT;
1090     while (InitializerOp)
1091     {
1092         NextRnode = RsDoOneResourceDescriptor  (InitializerOp,
1093                         CurrentByteOffset, &State);
1094
1095         /*
1096          * Update current byte offset to indicate the number of bytes from the
1097          * start of the buffer.  Buffer can include multiple descriptors, we
1098          * must keep track of the offset of not only each descriptor, but each
1099          * element (field) within each descriptor as well.
1100          */
1101         CurrentByteOffset += RsLinkDescriptorChain (&PreviousRnode, NextRnode);
1102
1103         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
1104     }
1105
1106     return (Rnode);
1107 }
1108
1109
1110 /*******************************************************************************
1111  *
1112  * FUNCTION:    RsDoVendorSmallDescriptor
1113  *
1114  * PARAMETERS:  Op                  - Parent resource descriptor parse node
1115  *              CurrentByteOffset   - Offset into the resource template AML
1116  *                                    buffer (to track references to the desc)
1117  *
1118  * RETURN:      Completed resource node
1119  *
1120  * DESCRIPTION: Construct a short "VendorShort" descriptor
1121  *
1122  ******************************************************************************/
1123
1124 ASL_RESOURCE_NODE *
1125 RsDoVendorSmallDescriptor (
1126     ACPI_PARSE_OBJECT       *Op,
1127     UINT32                  CurrentByteOffset)
1128 {
1129     AML_RESOURCE            *Descriptor;
1130     ACPI_PARSE_OBJECT       *InitializerOp;
1131     ASL_RESOURCE_NODE       *Rnode;
1132     UINT8                   *VendorData;
1133     UINT32                  i;
1134
1135
1136     InitializerOp = Op->Asl.Child;
1137
1138     /* Allocate worst case - 7 vendor bytes */
1139
1140     Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_VENDOR_SMALL) + 7);
1141
1142     Descriptor = Rnode->Buffer;
1143     Descriptor->VendorSmall.DescriptorType  = ACPI_RESOURCE_NAME_VENDOR_SMALL;
1144     VendorData = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_SMALL_HEADER);
1145
1146     /* Process all child initialization nodes */
1147
1148     InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
1149     for (i = 0; InitializerOp; i++)
1150     {
1151         if (InitializerOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
1152         {
1153             break;
1154         }
1155
1156         /* Maximum 7 vendor data bytes allowed (0-6) */
1157
1158         if (i >= 7)
1159         {
1160             AslError (ASL_ERROR, ASL_MSG_VENDOR_LIST, InitializerOp, NULL);
1161
1162             /* Eat the excess initializers */
1163
1164             while (InitializerOp)
1165             {
1166                 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
1167             }
1168             break;
1169         }
1170
1171         VendorData[i] = (UINT8) InitializerOp->Asl.Value.Integer;
1172         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
1173     }
1174
1175     /* Adjust the Rnode buffer size, so correct number of bytes are emitted */
1176
1177     Rnode->BufferLength -= (7 - i);
1178
1179     /* Set the length in the Type Tag */
1180
1181     Descriptor->VendorSmall.DescriptorType |= (UINT8) i;
1182     return (Rnode);
1183 }
1184
1185