arch/all-pc/acpica/source/components/parser/psxface.c

   1 /******************************************************************************
   2  *
   3  * Module Name: psxface - Parser external interfaces
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2013, Intel Corp.
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions, and the following disclaimer,
  16  *    without modification.
  17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  18  *    substantially similar to the "NO WARRANTY" disclaimer below
  19  *    ("Disclaimer") and any redistribution must be conditioned upon
  20  *    including a substantially similar Disclaimer requirement for further
  21  *    binary redistribution.
  22  * 3. Neither the names of the above-listed copyright holders nor the names
  23  *    of any contributors may be used to endorse or promote products derived
  24  *    from this software without specific prior written permission.
  25  *
  26  * Alternatively, this software may be distributed under the terms of the
  27  * GNU General Public License ("GPL") version 2 as published by the Free
  28  * Software Foundation.
  29  *
  30  * NO WARRANTY
  31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  41  * POSSIBILITY OF SUCH DAMAGES.
  42  */
  43
  44 #define __PSXFACE_C__
  45
  46 #include "acpi.h"
  47 #include "accommon.h"
  48 #include "acparser.h"
  49 #include "acdispat.h"
  50 #include "acinterp.h"
  51 #include "actables.h"
  52
  53
  54 #define _COMPONENT          ACPI_PARSER
  55         ACPI_MODULE_NAME    ("psxface")
  56
  57 /* Local Prototypes */
  58
  59 static void
  60 AcpiPsStartTrace (
  61     ACPI_EVALUATE_INFO      *Info);
  62
  63 static void
  64 AcpiPsStopTrace (
  65     ACPI_EVALUATE_INFO      *Info);
  66
  67 static void
  68 AcpiPsUpdateParameterList (
  69     ACPI_EVALUATE_INFO      *Info,
  70     UINT16                  Action);
  71
  72
  73 /*******************************************************************************
  74  *
  75  * FUNCTION:    AcpiDebugTrace
  76  *
  77  * PARAMETERS:  MethodName      - Valid ACPI name string
  78  *              DebugLevel      - Optional level mask. 0 to use default
  79  *              DebugLayer      - Optional layer mask. 0 to use default
  80  *              Flags           - bit 1: one shot(1) or persistent(0)
  81  *
  82  * RETURN:      Status
  83  *
  84  * DESCRIPTION: External interface to enable debug tracing during control
  85  *              method execution
  86  *
  87  ******************************************************************************/
  88
  89 ACPI_STATUS
  90 AcpiDebugTrace (
  91     char                    *Name,
  92     UINT32                  DebugLevel,
  93     UINT32                  DebugLayer,
  94     UINT32                  Flags)
  95 {
  96     ACPI_STATUS             Status;
  97
  98
  99     Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
 100     if (ACPI_FAILURE (Status))
 101     {
 102         return (Status);
 103     }
 104
 105     /* TBDs: Validate name, allow full path or just nameseg */
 106
 107     AcpiGbl_TraceMethodName = *ACPI_CAST_PTR (UINT32, Name);
 108     AcpiGbl_TraceFlags = Flags;
 109
 110     if (DebugLevel)
 111     {
 112         AcpiGbl_TraceDbgLevel = DebugLevel;
 113     }
 114     if (DebugLayer)
 115     {
 116         AcpiGbl_TraceDbgLayer = DebugLayer;
 117     }
 118
 119     (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
 120     return (AE_OK);
 121 }
 122
 123
 124 /*******************************************************************************
 125  *
 126  * FUNCTION:    AcpiPsStartTrace
 127  *
 128  * PARAMETERS:  Info        - Method info struct
 129  *
 130  * RETURN:      None
 131  *
 132  * DESCRIPTION: Start control method execution trace
 133  *
 134  ******************************************************************************/
 135
 136 static void
 137 AcpiPsStartTrace (
 138     ACPI_EVALUATE_INFO      *Info)
 139 {
 140     ACPI_STATUS             Status;
 141
 142
 143     ACPI_FUNCTION_ENTRY ();
 144
 145
 146     Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
 147     if (ACPI_FAILURE (Status))
 148     {
 149         return;
 150     }
 151
 152     if ((!AcpiGbl_TraceMethodName) ||
 153         (AcpiGbl_TraceMethodName != Info->Node->Name.Integer))
 154     {
 155         goto Exit;
 156     }
 157
 158     AcpiGbl_OriginalDbgLevel = AcpiDbgLevel;
 159     AcpiGbl_OriginalDbgLayer = AcpiDbgLayer;
 160
 161     AcpiDbgLevel = 0x00FFFFFF;
 162     AcpiDbgLayer = ACPI_UINT32_MAX;
 163
 164     if (AcpiGbl_TraceDbgLevel)
 165     {
 166         AcpiDbgLevel = AcpiGbl_TraceDbgLevel;
 167     }
 168     if (AcpiGbl_TraceDbgLayer)
 169     {
 170         AcpiDbgLayer = AcpiGbl_TraceDbgLayer;
 171     }
 172
 173
 174 Exit:
 175     (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
 176 }
 177
 178
 179 /*******************************************************************************
 180  *
 181  * FUNCTION:    AcpiPsStopTrace
 182  *
 183  * PARAMETERS:  Info        - Method info struct
 184  *
 185  * RETURN:      None
 186  *
 187  * DESCRIPTION: Stop control method execution trace
 188  *
 189  ******************************************************************************/
 190
 191 static void
 192 AcpiPsStopTrace (
 193     ACPI_EVALUATE_INFO      *Info)
 194 {
 195     ACPI_STATUS             Status;
 196
 197
 198     ACPI_FUNCTION_ENTRY ();
 199
 200
 201     Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
 202     if (ACPI_FAILURE (Status))
 203     {
 204         return;
 205     }
 206
 207     if ((!AcpiGbl_TraceMethodName) ||
 208         (AcpiGbl_TraceMethodName != Info->Node->Name.Integer))
 209     {
 210         goto Exit;
 211     }
 212
 213     /* Disable further tracing if type is one-shot */
 214
 215     if (AcpiGbl_TraceFlags & 1)
 216     {
 217         AcpiGbl_TraceMethodName = 0;
 218         AcpiGbl_TraceDbgLevel = 0;
 219         AcpiGbl_TraceDbgLayer = 0;
 220     }
 221
 222     AcpiDbgLevel = AcpiGbl_OriginalDbgLevel;
 223     AcpiDbgLayer = AcpiGbl_OriginalDbgLayer;
 224
 225 Exit:
 226     (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
 227 }
 228
 229
 230 /*******************************************************************************
 231  *
 232  * FUNCTION:    AcpiPsExecuteMethod
 233  *
 234  * PARAMETERS:  Info            - Method info block, contains:
 235  *                  Node            - Method Node to execute
 236  *                  ObjDesc         - Method object
 237  *                  Parameters      - List of parameters to pass to the method,
 238  *                                    terminated by NULL. Params itself may be
 239  *                                    NULL if no parameters are being passed.
 240  *                  ReturnObject    - Where to put method's return value (if
 241  *                                    any). If NULL, no value is returned.
 242  *                  ParameterType   - Type of Parameter list
 243  *                  ReturnObject    - Where to put method's return value (if
 244  *                                    any). If NULL, no value is returned.
 245  *                  PassNumber      - Parse or execute pass
 246  *
 247  * RETURN:      Status
 248  *
 249  * DESCRIPTION: Execute a control method
 250  *
 251  ******************************************************************************/
 252
 253 ACPI_STATUS
 254 AcpiPsExecuteMethod (
 255     ACPI_EVALUATE_INFO      *Info)
 256 {
 257     ACPI_STATUS             Status;
 258     ACPI_PARSE_OBJECT       *Op;
 259     ACPI_WALK_STATE         *WalkState;
 260
 261
 262     ACPI_FUNCTION_TRACE (PsExecuteMethod);
 263
 264
 265     /* Quick validation of DSDT header */
 266
 267     AcpiTbCheckDsdtHeader ();
 268
 269     /* Validate the Info and method Node */
 270
 271     if (!Info || !Info->Node)
 272     {
 273         return_ACPI_STATUS (AE_NULL_ENTRY);
 274     }
 275
 276     /* Init for new method, wait on concurrency semaphore */
 277
 278     Status = AcpiDsBeginMethodExecution (Info->Node, Info->ObjDesc, NULL);
 279     if (ACPI_FAILURE (Status))
 280     {
 281         return_ACPI_STATUS (Status);
 282     }
 283
 284     /*
 285      * The caller "owns" the parameters, so give each one an extra reference
 286      */
 287     AcpiPsUpdateParameterList (Info, REF_INCREMENT);
 288
 289     /* Begin tracing if requested */
 290
 291     AcpiPsStartTrace (Info);
 292
 293     /*
 294      * Execute the method. Performs parse simultaneously
 295      */
 296     ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
 297         "**** Begin Method Parse/Execute [%4.4s] **** Node=%p Obj=%p\n",
 298         Info->Node->Name.Ascii, Info->Node, Info->ObjDesc));
 299
 300     /* Create and init a Root Node */
 301
 302     Op = AcpiPsCreateScopeOp ();
 303     if (!Op)
 304     {
 305         Status = AE_NO_MEMORY;
 306         goto Cleanup;
 307     }
 308
 309     /* Create and initialize a new walk state */
 310
 311     Info->PassNumber = ACPI_IMODE_EXECUTE;
 312     WalkState = AcpiDsCreateWalkState (
 313                     Info->ObjDesc->Method.OwnerId, NULL, NULL, NULL);
 314     if (!WalkState)
 315     {
 316         Status = AE_NO_MEMORY;
 317         goto Cleanup;
 318     }
 319
 320     Status = AcpiDsInitAmlWalk (WalkState, Op, Info->Node,
 321                 Info->ObjDesc->Method.AmlStart,
 322                 Info->ObjDesc->Method.AmlLength, Info, Info->PassNumber);
 323     if (ACPI_FAILURE (Status))
 324     {
 325         AcpiDsDeleteWalkState (WalkState);
 326         goto Cleanup;
 327     }
 328
 329     if (Info->ObjDesc->Method.InfoFlags & ACPI_METHOD_MODULE_LEVEL)
 330     {
 331         WalkState->ParseFlags |= ACPI_PARSE_MODULE_LEVEL;
 332     }
 333
 334     /* Invoke an internal method if necessary */
 335
 336     if (Info->ObjDesc->Method.InfoFlags & ACPI_METHOD_INTERNAL_ONLY)
 337     {
 338         Status = Info->ObjDesc->Method.Dispatch.Implementation (WalkState);
 339         Info->ReturnObject = WalkState->ReturnDesc;
 340
 341         /* Cleanup states */
 342
 343         AcpiDsScopeStackClear (WalkState);
 344         AcpiPsCleanupScope (&WalkState->ParserState);
 345         AcpiDsTerminateControlMethod (WalkState->MethodDesc, WalkState);
 346         AcpiDsDeleteWalkState (WalkState);
 347         goto Cleanup;
 348     }
 349
 350     /*
 351      * Start method evaluation with an implicit return of zero.
 352      * This is done for Windows compatibility.
 353      */
 354     if (AcpiGbl_EnableInterpreterSlack)
 355     {
 356         WalkState->ImplicitReturnObj =
 357             AcpiUtCreateIntegerObject ((UINT64) 0);
 358         if (!WalkState->ImplicitReturnObj)
 359         {
 360             Status = AE_NO_MEMORY;
 361             AcpiDsDeleteWalkState (WalkState);
 362             goto Cleanup;
 363         }
 364     }
 365
 366     /* Parse the AML */
 367
 368     Status = AcpiPsParseAml (WalkState);
 369
 370     /* WalkState was deleted by ParseAml */
 371
 372 Cleanup:
 373     AcpiPsDeleteParseTree (Op);
 374
 375     /* End optional tracing */
 376
 377     AcpiPsStopTrace (Info);
 378
 379     /* Take away the extra reference that we gave the parameters above */
 380
 381     AcpiPsUpdateParameterList (Info, REF_DECREMENT);
 382
 383     /* Exit now if error above */
 384
 385     if (ACPI_FAILURE (Status))
 386     {
 387         return_ACPI_STATUS (Status);
 388     }
 389
 390     /*
 391      * If the method has returned an object, signal this to the caller with
 392      * a control exception code
 393      */
 394     if (Info->ReturnObject)
 395     {
 396         ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Method returned ObjDesc=%p\n",
 397             Info->ReturnObject));
 398         ACPI_DUMP_STACK_ENTRY (Info->ReturnObject);
 399
 400         Status = AE_CTRL_RETURN_VALUE;
 401     }
 402
 403     return_ACPI_STATUS (Status);
 404 }
 405
 406
 407 /*******************************************************************************
 408  *
 409  * FUNCTION:    AcpiPsUpdateParameterList
 410  *
 411  * PARAMETERS:  Info            - See ACPI_EVALUATE_INFO
 412  *                                (Used: ParameterType and Parameters)
 413  *              Action          - Add or Remove reference
 414  *
 415  * RETURN:      Status
 416  *
 417  * DESCRIPTION: Update reference count on all method parameter objects
 418  *
 419  ******************************************************************************/
 420
 421 static void
 422 AcpiPsUpdateParameterList (
 423     ACPI_EVALUATE_INFO      *Info,
 424     UINT16                  Action)
 425 {
 426     UINT32                  i;
 427
 428
 429     if (Info->Parameters)
 430     {
 431         /* Update reference count for each parameter */
 432
 433         for (i = 0; Info->Parameters[i]; i++)
 434         {
 435             /* Ignore errors, just do them all */
 436
 437             (void) AcpiUtUpdateObjectReference (Info->Parameters[i], Action);
 438         }
 439     }
 440 }