sys/contrib/dev/acpica/psxface.c

   1 /******************************************************************************
   2  *
   3  * Module Name: psxface - Parser external interfaces
   4  *              $Revision: 1.84 $
   5  *
   6  *****************************************************************************/
   7
   8 /******************************************************************************
   9  *
  10  * 1. Copyright Notice
  11  *
  12  * Some or all of this work - Copyright (c) 1999 - 2005, 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 __PSXFACE_C__
 118
 119 #include <contrib/dev/acpica/acpi.h>
 120 #include <contrib/dev/acpica/acparser.h>
 121 #include <contrib/dev/acpica/acdispat.h>
 122 #include <contrib/dev/acpica/acinterp.h>
 123
 124
 125 #define _COMPONENT          ACPI_PARSER
 126         ACPI_MODULE_NAME    ("psxface")
 127
 128 /* Local Prototypes */
 129
 130 static void
 131 AcpiPsStartTrace (
 132     ACPI_PARAMETER_INFO     *Info);
 133
 134 static void
 135 AcpiPsStopTrace (
 136     ACPI_PARAMETER_INFO     *Info);
 137
 138 static ACPI_STATUS
 139 AcpiPsExecutePass (
 140     ACPI_PARAMETER_INFO     *Info);
 141
 142 static void
 143 AcpiPsUpdateParameterList (
 144     ACPI_PARAMETER_INFO     *Info,
 145     UINT16                  Action);
 146
 147
 148 /*******************************************************************************
 149  *
 150  * FUNCTION:    AcpiDebugTrace
 151  *
 152  * PARAMETERS:  MethodName      - Valid ACPI name string
 153  *              DebugLevel      - Optional level mask. 0 to use default
 154  *              DebugLayer      - Optional layer mask. 0 to use default
 155  *              Flags           - bit 1: one shot(1) or persistent(0)
 156  *
 157  * RETURN:      Status
 158  *
 159  * DESCRIPTION: External interface to enable debug tracing during control
 160  *              method execution
 161  *
 162  ******************************************************************************/
 163
 164 ACPI_STATUS
 165 AcpiDebugTrace (
 166     char                    *Name,
 167     UINT32                  DebugLevel,
 168     UINT32                  DebugLayer,
 169     UINT32                  Flags)
 170 {
 171     ACPI_STATUS             Status;
 172
 173
 174     Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
 175     if (ACPI_FAILURE (Status))
 176     {
 177         return (Status);
 178     }
 179
 180     /* TBDs: Validate name, allow full path or just nameseg */
 181
 182     AcpiGbl_TraceMethodName = *(UINT32 *) Name;
 183     AcpiGbl_TraceFlags = Flags;
 184
 185     if (DebugLevel)
 186     {
 187         AcpiGbl_TraceDbgLevel = DebugLevel;
 188     }
 189     if (DebugLayer)
 190     {
 191         AcpiGbl_TraceDbgLayer = DebugLayer;
 192     }
 193
 194     (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
 195     return (AE_OK);
 196 }
 197
 198
 199 /*******************************************************************************
 200  *
 201  * FUNCTION:    AcpiPsStartTrace
 202  *
 203  * PARAMETERS:  Info        - Method info struct
 204  *
 205  * RETURN:      None
 206  *
 207  * DESCRIPTION: Start control method execution trace
 208  *
 209  ******************************************************************************/
 210
 211 static void
 212 AcpiPsStartTrace (
 213     ACPI_PARAMETER_INFO     *Info)
 214 {
 215     ACPI_STATUS             Status;
 216
 217
 218     ACPI_FUNCTION_ENTRY ();
 219
 220
 221     Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
 222     if (ACPI_FAILURE (Status))
 223     {
 224         return;
 225     }
 226
 227     if ((!AcpiGbl_TraceMethodName) ||
 228         (AcpiGbl_TraceMethodName != Info->Node->Name.Integer))
 229     {
 230         goto Exit;
 231     }
 232
 233     AcpiGbl_OriginalDbgLevel = AcpiDbgLevel;
 234     AcpiGbl_OriginalDbgLayer = AcpiDbgLayer;
 235
 236     AcpiDbgLevel = 0x00FFFFFF;
 237     AcpiDbgLayer = ACPI_UINT32_MAX;
 238
 239     if (AcpiGbl_TraceDbgLevel)
 240     {
 241         AcpiDbgLevel = AcpiGbl_TraceDbgLevel;
 242     }
 243     if (AcpiGbl_TraceDbgLayer)
 244     {
 245         AcpiDbgLayer = AcpiGbl_TraceDbgLayer;
 246     }
 247
 248
 249 Exit:
 250     (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
 251 }
 252
 253
 254 /*******************************************************************************
 255  *
 256  * FUNCTION:    AcpiPsStopTrace
 257  *
 258  * PARAMETERS:  Info        - Method info struct
 259  *
 260  * RETURN:      None
 261  *
 262  * DESCRIPTION: Stop control method execution trace
 263  *
 264  ******************************************************************************/
 265
 266 static void
 267 AcpiPsStopTrace (
 268     ACPI_PARAMETER_INFO     *Info)
 269 {
 270     ACPI_STATUS             Status;
 271
 272
 273     ACPI_FUNCTION_ENTRY ();
 274
 275
 276     Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
 277     if (ACPI_FAILURE (Status))
 278     {
 279         return;
 280     }
 281
 282     if ((!AcpiGbl_TraceMethodName) ||
 283         (AcpiGbl_TraceMethodName != Info->Node->Name.Integer))
 284     {
 285         goto Exit;
 286     }
 287
 288     /* Disable further tracing if type is one-shot */
 289
 290     if (AcpiGbl_TraceFlags & 1)
 291     {
 292         AcpiGbl_TraceMethodName = 0;
 293         AcpiGbl_TraceDbgLevel = 0;
 294         AcpiGbl_TraceDbgLayer = 0;
 295     }
 296
 297     AcpiDbgLevel = AcpiGbl_OriginalDbgLevel;
 298     AcpiDbgLayer = AcpiGbl_OriginalDbgLayer;
 299
 300 Exit:
 301     (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
 302 }
 303
 304
 305 /*******************************************************************************
 306  *
 307  * FUNCTION:    AcpiPsExecuteMethod
 308  *
 309  * PARAMETERS:  Info            - Method info block, contains:
 310  *                  Node            - Method Node to execute
 311  *                  ObjDesc         - Method object
 312  *                  Parameters      - List of parameters to pass to the method,
 313  *                                    terminated by NULL. Params itself may be
 314  *                                    NULL if no parameters are being passed.
 315  *                  ReturnObject    - Where to put method's return value (if
 316  *                                    any). If NULL, no value is returned.
 317  *                  ParameterType   - Type of Parameter list
 318  *                  ReturnObject    - Where to put method's return value (if
 319  *                                    any). If NULL, no value is returned.
 320  *                  PassNumber      - Parse or execute pass
 321  *
 322  * RETURN:      Status
 323  *
 324  * DESCRIPTION: Execute a control method
 325  *
 326  ******************************************************************************/
 327
 328 ACPI_STATUS
 329 AcpiPsExecuteMethod (
 330     ACPI_PARAMETER_INFO     *Info)
 331 {
 332     ACPI_STATUS             Status;
 333
 334
 335     ACPI_FUNCTION_TRACE ("PsExecuteMethod");
 336
 337
 338     /* Validate the Info and method Node */
 339
 340     if (!Info || !Info->Node)
 341     {
 342         return_ACPI_STATUS (AE_NULL_ENTRY);
 343     }
 344
 345     /* Init for new method, wait on concurrency semaphore */
 346
 347     Status = AcpiDsBeginMethodExecution (Info->Node, Info->ObjDesc, NULL);
 348     if (ACPI_FAILURE (Status))
 349     {
 350         return_ACPI_STATUS (Status);
 351     }
 352
 353     /*
 354      * The caller "owns" the parameters, so give each one an extra
 355      * reference
 356      */
 357     AcpiPsUpdateParameterList (Info, REF_INCREMENT);
 358
 359     /* Begin tracing if requested */
 360
 361     AcpiPsStartTrace (Info);
 362
 363     /*
 364      * 1) Perform the first pass parse of the method to enter any
 365      *    named objects that it creates into the namespace
 366      */
 367     ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
 368         "**** Begin Method Parse **** Entry=%p obj=%p\n",
 369         Info->Node, Info->ObjDesc));
 370
 371     Info->PassNumber = 1;
 372     Status = AcpiPsExecutePass (Info);
 373     if (ACPI_FAILURE (Status))
 374     {
 375         goto Cleanup;
 376     }
 377
 378     /*
 379      * 2) Execute the method. Performs second pass parse simultaneously
 380      */
 381     ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
 382         "**** Begin Method Execution **** Entry=%p obj=%p\n",
 383         Info->Node, Info->ObjDesc));
 384
 385     Info->PassNumber = 3;
 386     Status = AcpiPsExecutePass (Info);
 387
 388
 389 Cleanup:
 390     /* End optional tracing */
 391
 392     AcpiPsStopTrace (Info);
 393
 394     /* Take away the extra reference that we gave the parameters above */
 395
 396     AcpiPsUpdateParameterList (Info, REF_DECREMENT);
 397
 398     /* Exit now if error above */
 399
 400     if (ACPI_FAILURE (Status))
 401     {
 402         return_ACPI_STATUS (Status);
 403     }
 404
 405     /*
 406      * If the method has returned an object, signal this to the caller with
 407      * a control exception code
 408      */
 409     if (Info->ReturnObject)
 410     {
 411         ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Method returned ObjDesc=%p\n",
 412             Info->ReturnObject));
 413         ACPI_DUMP_STACK_ENTRY (Info->ReturnObject);
 414
 415         Status = AE_CTRL_RETURN_VALUE;
 416     }
 417
 418     return_ACPI_STATUS (Status);
 419 }
 420
 421
 422 /*******************************************************************************
 423  *
 424  * FUNCTION:    AcpiPsUpdateParameterList
 425  *
 426  * PARAMETERS:  Info            - See ACPI_PARAMETER_INFO
 427  *                                (Used: ParameterType and Parameters)
 428  *              Action          - Add or Remove reference
 429  *
 430  * RETURN:      Status
 431  *
 432  * DESCRIPTION: Update reference count on all method parameter objects
 433  *
 434  ******************************************************************************/
 435
 436 static void
 437 AcpiPsUpdateParameterList (
 438     ACPI_PARAMETER_INFO     *Info,
 439     UINT16                  Action)
 440 {
 441     ACPI_NATIVE_UINT        i;
 442
 443
 444     if ((Info->ParameterType == ACPI_PARAM_ARGS) &&
 445         (Info->Parameters))
 446     {
 447         /* Update reference count for each parameter */
 448
 449         for (i = 0; Info->Parameters[i]; i++)
 450         {
 451             /* Ignore errors, just do them all */
 452
 453             (void) AcpiUtUpdateObjectReference (Info->Parameters[i], Action);
 454         }
 455     }
 456 }
 457
 458
 459 /*******************************************************************************
 460  *
 461  * FUNCTION:    AcpiPsExecutePass
 462  *
 463  * PARAMETERS:  Info            - See ACPI_PARAMETER_INFO
 464  *                                (Used: PassNumber, Node, and ObjDesc)
 465  *
 466  * RETURN:      Status
 467  *
 468  * DESCRIPTION: Single AML pass: Parse or Execute a control method
 469  *
 470  ******************************************************************************/
 471
 472 static ACPI_STATUS
 473 AcpiPsExecutePass (
 474     ACPI_PARAMETER_INFO     *Info)
 475 {
 476     ACPI_STATUS             Status;
 477     ACPI_PARSE_OBJECT       *Op;
 478     ACPI_WALK_STATE         *WalkState;
 479
 480
 481     ACPI_FUNCTION_TRACE ("PsExecutePass");
 482
 483
 484     /* Create and init a Root Node */
 485
 486     Op = AcpiPsCreateScopeOp ();
 487     if (!Op)
 488     {
 489         return_ACPI_STATUS (AE_NO_MEMORY);
 490     }
 491
 492     /* Create and initialize a new walk state */
 493
 494     WalkState = AcpiDsCreateWalkState (
 495                     Info->ObjDesc->Method.OwnerId, NULL, NULL, NULL);
 496     if (!WalkState)
 497     {
 498         Status = AE_NO_MEMORY;
 499         goto Cleanup;
 500     }
 501
 502     Status = AcpiDsInitAmlWalk (WalkState, Op, Info->Node,
 503                     Info->ObjDesc->Method.AmlStart,
 504                     Info->ObjDesc->Method.AmlLength,
 505                     Info->PassNumber == 1 ? NULL : Info,
 506                     Info->PassNumber);
 507     if (ACPI_FAILURE (Status))
 508     {
 509         AcpiDsDeleteWalkState (WalkState);
 510         goto Cleanup;
 511     }
 512
 513     /* Parse the AML */
 514
 515     Status = AcpiPsParseAml (WalkState);
 516
 517     /* Walk state was deleted by ParseAml */
 518
 519 Cleanup:
 520     AcpiPsDeleteParseTree (Op);
 521     return_ACPI_STATUS (Status);
 522 }
 523
 524