drivers/acpi/compiler/aslrestype2.c

   1 /******************************************************************************
   2  *
   3  * Module Name: aslrestype2 - Miscellaneous Large resource descriptors
   4  *
   5  *****************************************************************************/
   6
   7 /******************************************************************************
   8  *
   9  * 1. Copyright Notice
  10  *
  11  * Some or all of this work - Copyright (c) 1999 - 2015, Intel Corp.
  12  * All rights reserved.
  13  *
  14  * 2. License
  15  *
  16  * 2.1. This is your license from Intel Corp. under its intellectual property
  17  * rights. You may have additional license terms from the party that provided
  18  * you this software, covering your right to use that party's intellectual
  19  * property rights.
  20  *
  21  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  22  * copy of the source code appearing in this file ("Covered Code") an
  23  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  24  * base code distributed originally by Intel ("Original Intel Code") to copy,
  25  * make derivatives, distribute, use and display any portion of the Covered
  26  * Code in any form, with the right to sublicense such rights; and
  27  *
  28  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  29  * license (with the right to sublicense), under only those claims of Intel
  30  * patents that are infringed by the Original Intel Code, to make, use, sell,
  31  * offer to sell, and import the Covered Code and derivative works thereof
  32  * solely to the minimum extent necessary to exercise the above copyright
  33  * license, and in no event shall the patent license extend to any additions
  34  * to or modifications of the Original Intel Code. No other license or right
  35  * is granted directly or by implication, estoppel or otherwise;
  36  *
  37  * The above copyright and patent license is granted only if the following
  38  * conditions are met:
  39  *
  40  * 3. Conditions
  41  *
  42  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  43  * Redistribution of source code of any substantial portion of the Covered
  44  * Code or modification with rights to further distribute source must include
  45  * the above Copyright Notice, the above License, this list of Conditions,
  46  * and the following Disclaimer and Export Compliance provision. In addition,
  47  * Licensee must cause all Covered Code to which Licensee contributes to
  48  * contain a file documenting the changes Licensee made to create that Covered
  49  * Code and the date of any change. Licensee must include in that file the
  50  * documentation of any changes made by any predecessor Licensee. Licensee
  51  * must include a prominent statement that the modification is derived,
  52  * directly or indirectly, from Original Intel Code.
  53  *
  54  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  55  * Redistribution of source code of any substantial portion of the Covered
  56  * Code or modification without rights to further distribute source must
  57  * include the following Disclaimer and Export Compliance provision in the
  58  * documentation and/or other materials provided with distribution. In
  59  * addition, Licensee may not authorize further sublicense of source of any
  60  * portion of the Covered Code, and must include terms to the effect that the
  61  * license from Licensee to its licensee is limited to the intellectual
  62  * property embodied in the software Licensee provides to its licensee, and
  63  * not to intellectual property embodied in modifications its licensee may
  64  * make.
  65  *
  66  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  67  * substantial portion of the Covered Code or modification must reproduce the
  68  * above Copyright Notice, and the following Disclaimer and Export Compliance
  69  * provision in the documentation and/or other materials provided with the
  70  * distribution.
  71  *
  72  * 3.4. Intel retains all right, title, and interest in and to the Original
  73  * Intel Code.
  74  *
  75  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  76  * Intel shall be used in advertising or otherwise to promote the sale, use or
  77  * other dealings in products derived from or relating to the Covered Code
  78  * without prior written authorization from Intel.
  79  *
  80  * 4. Disclaimer and Export Compliance
  81  *
  82  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  83  * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  84  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
  85  * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
  86  * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
  87  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  88  * PARTICULAR PURPOSE.
  89  *
  90  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  91  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  92  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  93  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  94  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  95  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
  96  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  97  * LIMITED REMEDY.
  98  *
  99  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 100  * software or system incorporating such software without first obtaining any
 101  * required license or other approval from the U. S. Department of Commerce or
 102  * any other agency or department of the United States Government. In the
 103  * event Licensee exports any such software from the United States or
 104  * re-exports any such software from a foreign destination, Licensee shall
 105  * ensure that the distribution and export/re-export of the software is in
 106  * compliance with all laws, regulations, orders, or other restrictions of the
 107  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 108  * any of its subsidiaries will export/re-export any technical data, process,
 109  * software, or service, directly or indirectly, to any country for which the
 110  * United States government or any agency thereof requires an export license,
 111  * other governmental approval, or letter of assurance, without first obtaining
 112  * such license, approval or letter.
 113  *
 114  *****************************************************************************/
 115
 116 #include "aslcompiler.h"
 117 #include "aslcompiler.y.h"
 118 #include "amlcode.h"
 119
 120 #define _COMPONENT          ACPI_COMPILER
 121         ACPI_MODULE_NAME    ("aslrestype2")
 122
 123 /*
 124  * This module contains miscellaneous large resource descriptors:
 125  *
 126  * Register
 127  * Interrupt
 128  * VendorLong
 129  */
 130
 131 /*******************************************************************************
 132  *
 133  * FUNCTION:    RsDoGeneralRegisterDescriptor
 134  *
 135  * PARAMETERS:  Info                - Parse Op and resource template offset
 136  *
 137  * RETURN:      Completed resource node
 138  *
 139  * DESCRIPTION: Construct a long "Register" descriptor
 140  *
 141  ******************************************************************************/
 142
 143 ASL_RESOURCE_NODE *
 144 RsDoGeneralRegisterDescriptor (
 145     ASL_RESOURCE_INFO       *Info)
 146 {
 147     AML_RESOURCE            *Descriptor;
 148     ACPI_PARSE_OBJECT       *InitializerOp;
 149     ASL_RESOURCE_NODE       *Rnode;
 150     UINT32                  CurrentByteOffset;
 151     UINT32                  i;
 152
 153
 154     InitializerOp = Info->DescriptorTypeOp->Asl.Child;
 155     CurrentByteOffset = Info->CurrentByteOffset;
 156     Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_GENERIC_REGISTER));
 157
 158     Descriptor = Rnode->Buffer;
 159     Descriptor->GenericReg.DescriptorType = ACPI_RESOURCE_NAME_GENERIC_REGISTER;
 160     Descriptor->GenericReg.ResourceLength = 12;
 161
 162     /* Process all child initialization nodes */
 163
 164     for (i = 0; InitializerOp; i++)
 165     {
 166         switch (i)
 167         {
 168         case 0: /* Address space */
 169
 170             Descriptor->GenericReg.AddressSpaceId = (UINT8) InitializerOp->Asl.Value.Integer;
 171             RsCreateByteField (InitializerOp, ACPI_RESTAG_ADDRESSSPACE,
 172                 CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.AddressSpaceId));
 173            break;
 174
 175         case 1: /* Register Bit Width */
 176
 177             Descriptor->GenericReg.BitWidth = (UINT8) InitializerOp->Asl.Value.Integer;
 178             RsCreateByteField (InitializerOp, ACPI_RESTAG_REGISTERBITWIDTH,
 179                 CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.BitWidth));
 180             break;
 181
 182         case 2: /* Register Bit Offset */
 183
 184             Descriptor->GenericReg.BitOffset = (UINT8) InitializerOp->Asl.Value.Integer;
 185             RsCreateByteField (InitializerOp, ACPI_RESTAG_REGISTERBITOFFSET,
 186                 CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.BitOffset));
 187             break;
 188
 189         case 3: /* Register Address */
 190
 191             Descriptor->GenericReg.Address = InitializerOp->Asl.Value.Integer;
 192             RsCreateQwordField (InitializerOp, ACPI_RESTAG_ADDRESS,
 193                 CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.Address));
 194             break;
 195
 196         case 4: /* Access Size (ACPI 3.0) */
 197
 198             Descriptor->GenericReg.AccessSize = (UINT8) InitializerOp->Asl.Value.Integer;
 199             RsCreateByteField (InitializerOp, ACPI_RESTAG_ACCESSSIZE,
 200                 CurrentByteOffset + ASL_RESDESC_OFFSET (GenericReg.AccessSize));
 201
 202             if (Descriptor->GenericReg.AccessSize > AML_FIELD_ACCESS_QWORD)
 203             {
 204                 AslError (ASL_ERROR, ASL_MSG_INVALID_ACCESS_SIZE,
 205                     InitializerOp, NULL);
 206             }
 207             break;
 208
 209         case 5: /* ResourceTag (ACPI 3.0b) */
 210
 211             UtAttachNamepathToOwner (Info->DescriptorTypeOp, 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     return (Rnode);
 223 }
 224
 225
 226 /*******************************************************************************
 227  *
 228  * FUNCTION:    RsDoInterruptDescriptor
 229  *
 230  * PARAMETERS:  Info                - Parse Op and resource template offset
 231  *
 232  * RETURN:      Completed resource node
 233  *
 234  * DESCRIPTION: Construct a long "Interrupt" descriptor
 235  *
 236  ******************************************************************************/
 237
 238 ASL_RESOURCE_NODE *
 239 RsDoInterruptDescriptor (
 240     ASL_RESOURCE_INFO       *Info)
 241 {
 242     AML_RESOURCE            *Descriptor;
 243     AML_RESOURCE            *Rover = NULL;
 244     ACPI_PARSE_OBJECT       *InitializerOp;
 245     ASL_RESOURCE_NODE       *Rnode;
 246     UINT16                  StringLength = 0;
 247     UINT32                  OptionIndex = 0;
 248     UINT32                  CurrentByteOffset;
 249     UINT32                  i;
 250     BOOLEAN                 HasResSourceIndex = FALSE;
 251     UINT8                   ResSourceIndex = 0;
 252     UINT8                   *ResSourceString = NULL;
 253
 254
 255     InitializerOp = Info->DescriptorTypeOp->Asl.Child;
 256     CurrentByteOffset = Info->CurrentByteOffset;
 257     StringLength = RsGetStringDataLength (InitializerOp);
 258
 259     /* Count the interrupt numbers */
 260
 261     for (i = 0; InitializerOp; i++)
 262     {
 263         InitializerOp = ASL_GET_PEER_NODE (InitializerOp);
 264
 265         if (i <= 6)
 266         {
 267             if (i == 3 &&
 268                 InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
 269             {
 270                 /*
 271                  * ResourceSourceIndex was specified, always make room for
 272                  * it, even if the ResourceSource was omitted.
 273                  */
 274                 OptionIndex++;
 275             }
 276
 277             continue;
 278         }
 279
 280         OptionIndex += 4;
 281     }
 282
 283     InitializerOp = Info->DescriptorTypeOp->Asl.Child;
 284     Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_EXTENDED_IRQ) +
 285         1 + OptionIndex + StringLength);
 286
 287     Descriptor = Rnode->Buffer;
 288     Descriptor->ExtendedIrq.DescriptorType  = ACPI_RESOURCE_NAME_EXTENDED_IRQ;
 289
 290     /*
 291      * Initial descriptor length -- may be enlarged if there are
 292      * optional fields present
 293      */
 294     Descriptor->ExtendedIrq.ResourceLength  = 2;  /* Flags and table length byte */
 295     Descriptor->ExtendedIrq.InterruptCount  = 0;
 296
 297     Rover = ACPI_CAST_PTR (AML_RESOURCE,
 298                 (&(Descriptor->ExtendedIrq.Interrupts[0])));
 299
 300     /* Process all child initialization nodes */
 301
 302     for (i = 0; InitializerOp; i++)
 303     {
 304         switch (i)
 305         {
 306         case 0: /* Resource Usage (Default: consumer (1) */
 307
 308             RsSetFlagBits (&Descriptor->ExtendedIrq.Flags, InitializerOp, 0, 1);
 309             break;
 310
 311         case 1: /* Interrupt Type (or Mode - edge/level) */
 312
 313             RsSetFlagBits (&Descriptor->ExtendedIrq.Flags, InitializerOp, 1, 0);
 314             RsCreateBitField (InitializerOp, ACPI_RESTAG_INTERRUPTTYPE,
 315                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtendedIrq.Flags), 1);
 316             break;
 317
 318         case 2: /* Interrupt Level (or Polarity - Active high/low) */
 319
 320             RsSetFlagBits (&Descriptor->ExtendedIrq.Flags, InitializerOp, 2, 0);
 321             RsCreateBitField (InitializerOp, ACPI_RESTAG_INTERRUPTLEVEL,
 322                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtendedIrq.Flags), 2);
 323             break;
 324
 325         case 3: /* Share Type - Default: exclusive (0) */
 326
 327             RsSetFlagBits (&Descriptor->ExtendedIrq.Flags, InitializerOp, 3, 0);
 328             RsCreateBitField (InitializerOp, ACPI_RESTAG_INTERRUPTSHARE,
 329                 CurrentByteOffset + ASL_RESDESC_OFFSET (ExtendedIrq.Flags), 3);
 330             break;
 331
 332         case 4: /* ResSourceIndex [Optional Field - BYTE] */
 333
 334             if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
 335             {
 336                 HasResSourceIndex = TRUE;
 337                 ResSourceIndex = (UINT8) InitializerOp->Asl.Value.Integer;
 338             }
 339             break;
 340
 341         case 5: /* ResSource [Optional Field - STRING] */
 342
 343             if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
 344                 (InitializerOp->Asl.Value.String))
 345             {
 346                 if (StringLength)
 347                 {
 348                     ResSourceString = (UINT8 *) InitializerOp->Asl.Value.String;
 349                 }
 350
 351                 /* ResourceSourceIndex must also be valid */
 352
 353                 if (!HasResSourceIndex)
 354                 {
 355                     AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
 356                         InitializerOp, NULL);
 357                 }
 358             }
 359
 360 #if 0
 361             /*
 362              * Not a valid ResourceSource, ResourceSourceIndex must also
 363              * be invalid
 364              */
 365             else if (HasResSourceIndex)
 366             {
 367                 AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
 368                     InitializerOp, NULL);
 369             }
 370 #endif
 371             break;
 372
 373         case 6: /* ResourceTag */
 374
 375             UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
 376             break;
 377
 378         default:
 379             /*
 380              * Interrupt Numbers come through here, repeatedly
 381              */
 382
 383             /* Maximum 255 interrupts allowed for this descriptor */
 384
 385             if (Descriptor->ExtendedIrq.InterruptCount == 255)
 386             {
 387                 AslError (ASL_ERROR, ASL_MSG_EX_INTERRUPT_LIST,
 388                     InitializerOp, NULL);
 389                 return (Rnode);
 390             }
 391
 392             /* Each interrupt number must be a 32-bit value */
 393
 394             if (InitializerOp->Asl.Value.Integer > ACPI_UINT32_MAX)
 395             {
 396                 AslError (ASL_ERROR, ASL_MSG_EX_INTERRUPT_NUMBER,
 397                     InitializerOp, NULL);
 398             }
 399
 400             /* Save the integer and move pointer to the next one */
 401
 402             Rover->DwordItem = (UINT32) InitializerOp->Asl.Value.Integer;
 403             Rover = ACPI_ADD_PTR (AML_RESOURCE, &(Rover->DwordItem), 4);
 404             Descriptor->ExtendedIrq.InterruptCount++;
 405             Descriptor->ExtendedIrq.ResourceLength += 4;
 406
 407             /* Case 7: First interrupt number in list */
 408
 409             if (i == 7)
 410             {
 411                 if (InitializerOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
 412                 {
 413                     /* Must be at least one interrupt */
 414
 415                     AslError (ASL_ERROR, ASL_MSG_EX_INTERRUPT_LIST_MIN,
 416                         InitializerOp, NULL);
 417                 }
 418
 419                 /* Check now for duplicates in list */
 420
 421                 RsCheckListForDuplicates (InitializerOp);
 422
 423                 /* Create a named field at the start of the list */
 424
 425                 RsCreateDwordField (InitializerOp, ACPI_RESTAG_INTERRUPT,
 426                     CurrentByteOffset +
 427                     ASL_RESDESC_OFFSET (ExtendedIrq.Interrupts[0]));
 428             }
 429         }
 430
 431         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
 432     }
 433
 434
 435     /* Add optional ResSourceIndex if present */
 436
 437     if (HasResSourceIndex)
 438     {
 439         Rover->ByteItem = ResSourceIndex;
 440         Rover = ACPI_ADD_PTR (AML_RESOURCE, &(Rover->ByteItem), 1);
 441         Descriptor->ExtendedIrq.ResourceLength += 1;
 442     }
 443
 444     /* Add optional ResSource string if present */
 445
 446     if (StringLength && ResSourceString)
 447     {
 448
 449         strcpy ((char *) Rover, (char *) ResSourceString);
 450         Rover = ACPI_ADD_PTR (
 451                     AML_RESOURCE, &(Rover->ByteItem), StringLength);
 452
 453         Descriptor->ExtendedIrq.ResourceLength = (UINT16)
 454             (Descriptor->ExtendedIrq.ResourceLength + StringLength);
 455     }
 456
 457     Rnode->BufferLength = (ASL_RESDESC_OFFSET (ExtendedIrq.Interrupts[0]) -
 458                            ASL_RESDESC_OFFSET (ExtendedIrq.DescriptorType))
 459                            + OptionIndex + StringLength;
 460     return (Rnode);
 461 }
 462
 463
 464 /*******************************************************************************
 465  *
 466  * FUNCTION:    RsDoVendorLargeDescriptor
 467  *
 468  * PARAMETERS:  Info                - Parse Op and resource template offset
 469  *
 470  * RETURN:      Completed resource node
 471  *
 472  * DESCRIPTION: Construct a long "VendorLong" descriptor
 473  *
 474  ******************************************************************************/
 475
 476 ASL_RESOURCE_NODE *
 477 RsDoVendorLargeDescriptor (
 478     ASL_RESOURCE_INFO       *Info)
 479 {
 480     AML_RESOURCE            *Descriptor;
 481     ACPI_PARSE_OBJECT       *InitializerOp;
 482     ASL_RESOURCE_NODE       *Rnode;
 483     UINT8                   *VendorData;
 484     UINT32                  i;
 485
 486
 487     /* Count the number of data bytes */
 488
 489     InitializerOp = Info->DescriptorTypeOp->Asl.Child;
 490     InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
 491
 492     for (i = 0; InitializerOp; i++)
 493     {
 494         if (InitializerOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
 495         {
 496             break;
 497         }
 498         InitializerOp = InitializerOp->Asl.Next;
 499     }
 500
 501     InitializerOp = Info->DescriptorTypeOp->Asl.Child;
 502     InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
 503     Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_VENDOR_LARGE) + i);
 504
 505     Descriptor = Rnode->Buffer;
 506     Descriptor->VendorLarge.DescriptorType  = ACPI_RESOURCE_NAME_VENDOR_LARGE;
 507     Descriptor->VendorLarge.ResourceLength = (UINT16) i;
 508
 509     /* Point to end-of-descriptor for vendor data */
 510
 511     VendorData = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_LARGE_HEADER);
 512
 513     /* Process all child initialization nodes */
 514
 515     for (i = 0; InitializerOp; i++)
 516     {
 517         if (InitializerOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
 518         {
 519             break;
 520         }
 521
 522         VendorData[i] = (UINT8) InitializerOp->Asl.Value.Integer;
 523         InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
 524     }
 525
 526     return (Rnode);
 527 }