src/add-ons/kernel/bus_managers/acpi/acpica/components/dispatcher/dsargs.c

   1 /******************************************************************************
   2  *
   3  * Module Name: dsargs - Support for execution of dynamic arguments for static
   4  *                       objects (regions, fields, buffer fields, etc.)
   5  *
   6  *****************************************************************************/
   7
   8 /******************************************************************************
   9  *
  10  * 1. Copyright Notice
  11  *
  12  * Some or all of this work - Copyright (c) 1999 - 2014, 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 #define __DSARGS_C__
 118
 119 #include "acpi.h"
 120 #include "accommon.h"
 121 #include "acparser.h"
 122 #include "amlcode.h"
 123 #include "acdispat.h"
 124 #include "acnamesp.h"
 125
 126 #define _COMPONENT          ACPI_DISPATCHER
 127         ACPI_MODULE_NAME    ("dsargs")
 128
 129 /* Local prototypes */
 130
 131 static ACPI_STATUS
 132 AcpiDsExecuteArguments (
 133     ACPI_NAMESPACE_NODE     *Node,
 134     ACPI_NAMESPACE_NODE     *ScopeNode,
 135     UINT32                  AmlLength,
 136     UINT8                   *AmlStart);
 137
 138
 139 /*******************************************************************************
 140  *
 141  * FUNCTION:    AcpiDsExecuteArguments
 142  *
 143  * PARAMETERS:  Node                - Object NS node
 144  *              ScopeNode           - Parent NS node
 145  *              AmlLength           - Length of executable AML
 146  *              AmlStart            - Pointer to the AML
 147  *
 148  * RETURN:      Status.
 149  *
 150  * DESCRIPTION: Late (deferred) execution of region or field arguments
 151  *
 152  ******************************************************************************/
 153
 154 static ACPI_STATUS
 155 AcpiDsExecuteArguments (
 156     ACPI_NAMESPACE_NODE     *Node,
 157     ACPI_NAMESPACE_NODE     *ScopeNode,
 158     UINT32                  AmlLength,
 159     UINT8                   *AmlStart)
 160 {
 161     ACPI_STATUS             Status;
 162     ACPI_PARSE_OBJECT       *Op;
 163     ACPI_WALK_STATE         *WalkState;
 164
 165
 166     ACPI_FUNCTION_TRACE (DsExecuteArguments);
 167
 168
 169     /* Allocate a new parser op to be the root of the parsed tree */
 170
 171     Op = AcpiPsAllocOp (AML_INT_EVAL_SUBTREE_OP);
 172     if (!Op)
 173     {
 174         return_ACPI_STATUS (AE_NO_MEMORY);
 175     }
 176
 177     /* Save the Node for use in AcpiPsParseAml */
 178
 179     Op->Common.Node = ScopeNode;
 180
 181     /* Create and initialize a new parser state */
 182
 183     WalkState = AcpiDsCreateWalkState (0, NULL, NULL, NULL);
 184     if (!WalkState)
 185     {
 186         Status = AE_NO_MEMORY;
 187         goto Cleanup;
 188     }
 189
 190     Status = AcpiDsInitAmlWalk (WalkState, Op, NULL, AmlStart,
 191                     AmlLength, NULL, ACPI_IMODE_LOAD_PASS1);
 192     if (ACPI_FAILURE (Status))
 193     {
 194         AcpiDsDeleteWalkState (WalkState);
 195         goto Cleanup;
 196     }
 197
 198     /* Mark this parse as a deferred opcode */
 199
 200     WalkState->ParseFlags = ACPI_PARSE_DEFERRED_OP;
 201     WalkState->DeferredNode = Node;
 202
 203     /* Pass1: Parse the entire declaration */
 204
 205     Status = AcpiPsParseAml (WalkState);
 206     if (ACPI_FAILURE (Status))
 207     {
 208         goto Cleanup;
 209     }
 210
 211     /* Get and init the Op created above */
 212
 213     Op->Common.Node = Node;
 214     AcpiPsDeleteParseTree (Op);
 215
 216     /* Evaluate the deferred arguments */
 217
 218     Op = AcpiPsAllocOp (AML_INT_EVAL_SUBTREE_OP);
 219     if (!Op)
 220     {
 221         return_ACPI_STATUS (AE_NO_MEMORY);
 222     }
 223
 224     Op->Common.Node = ScopeNode;
 225
 226     /* Create and initialize a new parser state */
 227
 228     WalkState = AcpiDsCreateWalkState (0, NULL, NULL, NULL);
 229     if (!WalkState)
 230     {
 231         Status = AE_NO_MEMORY;
 232         goto Cleanup;
 233     }
 234
 235     /* Execute the opcode and arguments */
 236
 237     Status = AcpiDsInitAmlWalk (WalkState, Op, NULL, AmlStart,
 238                     AmlLength, NULL, ACPI_IMODE_EXECUTE);
 239     if (ACPI_FAILURE (Status))
 240     {
 241         AcpiDsDeleteWalkState (WalkState);
 242         goto Cleanup;
 243     }
 244
 245     /* Mark this execution as a deferred opcode */
 246
 247     WalkState->DeferredNode = Node;
 248     Status = AcpiPsParseAml (WalkState);
 249
 250 Cleanup:
 251     AcpiPsDeleteParseTree (Op);
 252     return_ACPI_STATUS (Status);
 253 }
 254
 255
 256 /*******************************************************************************
 257  *
 258  * FUNCTION:    AcpiDsGetBufferFieldArguments
 259  *
 260  * PARAMETERS:  ObjDesc         - A valid BufferField object
 261  *
 262  * RETURN:      Status.
 263  *
 264  * DESCRIPTION: Get BufferField Buffer and Index. This implements the late
 265  *              evaluation of these field attributes.
 266  *
 267  ******************************************************************************/
 268
 269 ACPI_STATUS
 270 AcpiDsGetBufferFieldArguments (
 271     ACPI_OPERAND_OBJECT     *ObjDesc)
 272 {
 273     ACPI_OPERAND_OBJECT     *ExtraDesc;
 274     ACPI_NAMESPACE_NODE     *Node;
 275     ACPI_STATUS             Status;
 276
 277
 278     ACPI_FUNCTION_TRACE_PTR (DsGetBufferFieldArguments, ObjDesc);
 279
 280
 281     if (ObjDesc->Common.Flags & AOPOBJ_DATA_VALID)
 282     {
 283         return_ACPI_STATUS (AE_OK);
 284     }
 285
 286     /* Get the AML pointer (method object) and BufferField node */
 287
 288     ExtraDesc = AcpiNsGetSecondaryObject (ObjDesc);
 289     Node = ObjDesc->BufferField.Node;
 290
 291     ACPI_DEBUG_EXEC (AcpiUtDisplayInitPathname (ACPI_TYPE_BUFFER_FIELD,
 292         Node, NULL));
 293
 294     ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[%4.4s] BufferField Arg Init\n",
 295         AcpiUtGetNodeName (Node)));
 296
 297     /* Execute the AML code for the TermArg arguments */
 298
 299     Status = AcpiDsExecuteArguments (Node, Node->Parent,
 300                 ExtraDesc->Extra.AmlLength, ExtraDesc->Extra.AmlStart);
 301     return_ACPI_STATUS (Status);
 302 }
 303
 304
 305 /*******************************************************************************
 306  *
 307  * FUNCTION:    AcpiDsGetBankFieldArguments
 308  *
 309  * PARAMETERS:  ObjDesc         - A valid BankField object
 310  *
 311  * RETURN:      Status.
 312  *
 313  * DESCRIPTION: Get BankField BankValue. This implements the late
 314  *              evaluation of these field attributes.
 315  *
 316  ******************************************************************************/
 317
 318 ACPI_STATUS
 319 AcpiDsGetBankFieldArguments (
 320     ACPI_OPERAND_OBJECT     *ObjDesc)
 321 {
 322     ACPI_OPERAND_OBJECT     *ExtraDesc;
 323     ACPI_NAMESPACE_NODE     *Node;
 324     ACPI_STATUS             Status;
 325
 326
 327     ACPI_FUNCTION_TRACE_PTR (DsGetBankFieldArguments, ObjDesc);
 328
 329
 330     if (ObjDesc->Common.Flags & AOPOBJ_DATA_VALID)
 331     {
 332         return_ACPI_STATUS (AE_OK);
 333     }
 334
 335     /* Get the AML pointer (method object) and BankField node */
 336
 337     ExtraDesc = AcpiNsGetSecondaryObject (ObjDesc);
 338     Node = ObjDesc->BankField.Node;
 339
 340     ACPI_DEBUG_EXEC (AcpiUtDisplayInitPathname (ACPI_TYPE_LOCAL_BANK_FIELD,
 341         Node, NULL));
 342
 343     ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[%4.4s] BankField Arg Init\n",
 344         AcpiUtGetNodeName (Node)));
 345
 346     /* Execute the AML code for the TermArg arguments */
 347
 348     Status = AcpiDsExecuteArguments (Node, Node->Parent,
 349                 ExtraDesc->Extra.AmlLength, ExtraDesc->Extra.AmlStart);
 350     return_ACPI_STATUS (Status);
 351 }
 352
 353
 354 /*******************************************************************************
 355  *
 356  * FUNCTION:    AcpiDsGetBufferArguments
 357  *
 358  * PARAMETERS:  ObjDesc         - A valid Buffer object
 359  *
 360  * RETURN:      Status.
 361  *
 362  * DESCRIPTION: Get Buffer length and initializer byte list. This implements
 363  *              the late evaluation of these attributes.
 364  *
 365  ******************************************************************************/
 366
 367 ACPI_STATUS
 368 AcpiDsGetBufferArguments (
 369     ACPI_OPERAND_OBJECT     *ObjDesc)
 370 {
 371     ACPI_NAMESPACE_NODE     *Node;
 372     ACPI_STATUS             Status;
 373
 374
 375     ACPI_FUNCTION_TRACE_PTR (DsGetBufferArguments, ObjDesc);
 376
 377
 378     if (ObjDesc->Common.Flags & AOPOBJ_DATA_VALID)
 379     {
 380         return_ACPI_STATUS (AE_OK);
 381     }
 382
 383     /* Get the Buffer node */
 384
 385     Node = ObjDesc->Buffer.Node;
 386     if (!Node)
 387     {
 388         ACPI_ERROR ((AE_INFO,
 389             "No pointer back to namespace node in buffer object %p", ObjDesc));
 390         return_ACPI_STATUS (AE_AML_INTERNAL);
 391     }
 392
 393     ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Buffer Arg Init\n"));
 394
 395     /* Execute the AML code for the TermArg arguments */
 396
 397     Status = AcpiDsExecuteArguments (Node, Node,
 398                 ObjDesc->Buffer.AmlLength, ObjDesc->Buffer.AmlStart);
 399     return_ACPI_STATUS (Status);
 400 }
 401
 402
 403 /*******************************************************************************
 404  *
 405  * FUNCTION:    AcpiDsGetPackageArguments
 406  *
 407  * PARAMETERS:  ObjDesc         - A valid Package object
 408  *
 409  * RETURN:      Status.
 410  *
 411  * DESCRIPTION: Get Package length and initializer byte list. This implements
 412  *              the late evaluation of these attributes.
 413  *
 414  ******************************************************************************/
 415
 416 ACPI_STATUS
 417 AcpiDsGetPackageArguments (
 418     ACPI_OPERAND_OBJECT     *ObjDesc)
 419 {
 420     ACPI_NAMESPACE_NODE     *Node;
 421     ACPI_STATUS             Status;
 422
 423
 424     ACPI_FUNCTION_TRACE_PTR (DsGetPackageArguments, ObjDesc);
 425
 426
 427     if (ObjDesc->Common.Flags & AOPOBJ_DATA_VALID)
 428     {
 429         return_ACPI_STATUS (AE_OK);
 430     }
 431
 432     /* Get the Package node */
 433
 434     Node = ObjDesc->Package.Node;
 435     if (!Node)
 436     {
 437         ACPI_ERROR ((AE_INFO,
 438             "No pointer back to namespace node in package %p", ObjDesc));
 439         return_ACPI_STATUS (AE_AML_INTERNAL);
 440     }
 441
 442     ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Package Arg Init\n"));
 443
 444     /* Execute the AML code for the TermArg arguments */
 445
 446     Status = AcpiDsExecuteArguments (Node, Node,
 447                 ObjDesc->Package.AmlLength, ObjDesc->Package.AmlStart);
 448     return_ACPI_STATUS (Status);
 449 }
 450
 451
 452 /*******************************************************************************
 453  *
 454  * FUNCTION:    AcpiDsGetRegionArguments
 455  *
 456  * PARAMETERS:  ObjDesc         - A valid region object
 457  *
 458  * RETURN:      Status.
 459  *
 460  * DESCRIPTION: Get region address and length. This implements the late
 461  *              evaluation of these region attributes.
 462  *
 463  ******************************************************************************/
 464
 465 ACPI_STATUS
 466 AcpiDsGetRegionArguments (
 467     ACPI_OPERAND_OBJECT     *ObjDesc)
 468 {
 469     ACPI_NAMESPACE_NODE     *Node;
 470     ACPI_STATUS             Status;
 471     ACPI_OPERAND_OBJECT     *ExtraDesc;
 472
 473
 474     ACPI_FUNCTION_TRACE_PTR (DsGetRegionArguments, ObjDesc);
 475
 476
 477     if (ObjDesc->Region.Flags & AOPOBJ_DATA_VALID)
 478     {
 479         return_ACPI_STATUS (AE_OK);
 480     }
 481
 482     ExtraDesc = AcpiNsGetSecondaryObject (ObjDesc);
 483     if (!ExtraDesc)
 484     {
 485         return_ACPI_STATUS (AE_NOT_EXIST);
 486     }
 487
 488     /* Get the Region node */
 489
 490     Node = ObjDesc->Region.Node;
 491
 492     ACPI_DEBUG_EXEC (AcpiUtDisplayInitPathname (ACPI_TYPE_REGION, Node, NULL));
 493
 494     ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[%4.4s] OpRegion Arg Init at AML %p\n",
 495         AcpiUtGetNodeName (Node), ExtraDesc->Extra.AmlStart));
 496
 497     /* Execute the argument AML */
 498
 499     Status = AcpiDsExecuteArguments (Node, ExtraDesc->Extra.ScopeNode,
 500                 ExtraDesc->Extra.AmlLength, ExtraDesc->Extra.AmlStart);
 501     if (ACPI_FAILURE (Status))
 502     {
 503         return_ACPI_STATUS (Status);
 504     }
 505
 506     Status = AcpiUtAddAddressRange (ObjDesc->Region.SpaceId,
 507                  ObjDesc->Region.Address, ObjDesc->Region.Length,
 508                  Node);
 509     return_ACPI_STATUS (Status);
 510 }