arch/all-pc/acpica/source/components/debugger/dbmethod.c

   1 /*******************************************************************************
   2  *
   3  * Module Name: dbmethod - Debug commands for control methods
   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
  45 #include "acpi.h"
  46 #include "accommon.h"
  47 #include "acdispat.h"
  48 #include "acnamesp.h"
  49 #include "acdebug.h"
  50 #include "acdisasm.h"
  51 #include "acparser.h"
  52 #include "acpredef.h"
  53
  54
  55 #ifdef ACPI_DEBUGGER
  56
  57 #define _COMPONENT          ACPI_CA_DEBUGGER
  58         ACPI_MODULE_NAME    ("dbmethod")
  59
  60
  61 /* Local prototypes */
  62
  63 static ACPI_STATUS
  64 AcpiDbWalkForExecute (
  65     ACPI_HANDLE             ObjHandle,
  66     UINT32                  NestingLevel,
  67     void                    *Context,
  68     void                    **ReturnValue);
  69
  70
  71 /*******************************************************************************
  72  *
  73  * FUNCTION:    AcpiDbSetMethodBreakpoint
  74  *
  75  * PARAMETERS:  Location            - AML offset of breakpoint
  76  *              WalkState           - Current walk info
  77  *              Op                  - Current Op (from parse walk)
  78  *
  79  * RETURN:      None
  80  *
  81  * DESCRIPTION: Set a breakpoint in a control method at the specified
  82  *              AML offset
  83  *
  84  ******************************************************************************/
  85
  86 void
  87 AcpiDbSetMethodBreakpoint (
  88     char                    *Location,
  89     ACPI_WALK_STATE         *WalkState,
  90     ACPI_PARSE_OBJECT       *Op)
  91 {
  92     UINT32                  Address;
  93
  94
  95     if (!Op)
  96     {
  97         AcpiOsPrintf ("There is no method currently executing\n");
  98         return;
  99     }
 100
 101     /* Get and verify the breakpoint address */
 102
 103     Address = ACPI_STRTOUL (Location, NULL, 16);
 104     if (Address <= Op->Common.AmlOffset)
 105     {
 106         AcpiOsPrintf ("Breakpoint %X is beyond current address %X\n",
 107             Address, Op->Common.AmlOffset);
 108     }
 109
 110     /* Save breakpoint in current walk */
 111
 112     WalkState->UserBreakpoint = Address;
 113     AcpiOsPrintf ("Breakpoint set at AML offset %X\n", Address);
 114 }
 115
 116
 117 /*******************************************************************************
 118  *
 119  * FUNCTION:    AcpiDbSetMethodCallBreakpoint
 120  *
 121  * PARAMETERS:  Op                  - Current Op (from parse walk)
 122  *
 123  * RETURN:      None
 124  *
 125  * DESCRIPTION: Set a breakpoint in a control method at the specified
 126  *              AML offset
 127  *
 128  ******************************************************************************/
 129
 130 void
 131 AcpiDbSetMethodCallBreakpoint (
 132     ACPI_PARSE_OBJECT       *Op)
 133 {
 134
 135
 136     if (!Op)
 137     {
 138         AcpiOsPrintf ("There is no method currently executing\n");
 139         return;
 140     }
 141
 142     AcpiGbl_StepToNextCall = TRUE;
 143 }
 144
 145
 146 /*******************************************************************************
 147  *
 148  * FUNCTION:    AcpiDbSetMethodData
 149  *
 150  * PARAMETERS:  TypeArg         - L for local, A for argument
 151  *              IndexArg        - which one
 152  *              ValueArg        - Value to set.
 153  *
 154  * RETURN:      None
 155  *
 156  * DESCRIPTION: Set a local or argument for the running control method.
 157  *              NOTE: only object supported is Number.
 158  *
 159  ******************************************************************************/
 160
 161 void
 162 AcpiDbSetMethodData (
 163     char                    *TypeArg,
 164     char                    *IndexArg,
 165     char                    *ValueArg)
 166 {
 167     char                    Type;
 168     UINT32                  Index;
 169     UINT32                  Value;
 170     ACPI_WALK_STATE         *WalkState;
 171     ACPI_OPERAND_OBJECT     *ObjDesc;
 172     ACPI_STATUS             Status;
 173     ACPI_NAMESPACE_NODE     *Node;
 174
 175
 176     /* Validate TypeArg */
 177
 178     AcpiUtStrupr (TypeArg);
 179     Type = TypeArg[0];
 180     if ((Type != 'L') &&
 181         (Type != 'A') &&
 182         (Type != 'N'))
 183     {
 184         AcpiOsPrintf ("Invalid SET operand: %s\n", TypeArg);
 185         return;
 186     }
 187
 188     Value = ACPI_STRTOUL (ValueArg, NULL, 16);
 189
 190     if (Type == 'N')
 191     {
 192         Node = AcpiDbConvertToNode (IndexArg);
 193         if (Node->Type != ACPI_TYPE_INTEGER)
 194         {
 195             AcpiOsPrintf ("Can only set Integer nodes\n");
 196             return;
 197         }
 198         ObjDesc = Node->Object;
 199         ObjDesc->Integer.Value = Value;
 200         return;
 201     }
 202
 203     /* Get the index and value */
 204
 205     Index = ACPI_STRTOUL (IndexArg, NULL, 16);
 206
 207     WalkState = AcpiDsGetCurrentWalkState (AcpiGbl_CurrentWalkList);
 208     if (!WalkState)
 209     {
 210         AcpiOsPrintf ("There is no method currently executing\n");
 211         return;
 212     }
 213
 214     /* Create and initialize the new object */
 215
 216     ObjDesc = AcpiUtCreateIntegerObject ((UINT64) Value);
 217     if (!ObjDesc)
 218     {
 219         AcpiOsPrintf ("Could not create an internal object\n");
 220         return;
 221     }
 222
 223     /* Store the new object into the target */
 224
 225     switch (Type)
 226     {
 227     case 'A':
 228
 229         /* Set a method argument */
 230
 231         if (Index > ACPI_METHOD_MAX_ARG)
 232         {
 233             AcpiOsPrintf ("Arg%u - Invalid argument name\n", Index);
 234             goto Cleanup;
 235         }
 236
 237         Status = AcpiDsStoreObjectToLocal (ACPI_REFCLASS_ARG, Index, ObjDesc,
 238                     WalkState);
 239         if (ACPI_FAILURE (Status))
 240         {
 241             goto Cleanup;
 242         }
 243
 244         ObjDesc = WalkState->Arguments[Index].Object;
 245
 246         AcpiOsPrintf ("Arg%u: ", Index);
 247         AcpiDmDisplayInternalObject (ObjDesc, WalkState);
 248         break;
 249
 250     case 'L':
 251
 252         /* Set a method local */
 253
 254         if (Index > ACPI_METHOD_MAX_LOCAL)
 255         {
 256             AcpiOsPrintf ("Local%u - Invalid local variable name\n", Index);
 257             goto Cleanup;
 258         }
 259
 260         Status = AcpiDsStoreObjectToLocal (ACPI_REFCLASS_LOCAL, Index, ObjDesc,
 261                     WalkState);
 262         if (ACPI_FAILURE (Status))
 263         {
 264             goto Cleanup;
 265         }
 266
 267         ObjDesc = WalkState->LocalVariables[Index].Object;
 268
 269         AcpiOsPrintf ("Local%u: ", Index);
 270         AcpiDmDisplayInternalObject (ObjDesc, WalkState);
 271         break;
 272
 273     default:
 274
 275         break;
 276     }
 277
 278 Cleanup:
 279     AcpiUtRemoveReference (ObjDesc);
 280 }
 281
 282
 283 /*******************************************************************************
 284  *
 285  * FUNCTION:    AcpiDbDisassembleAml
 286  *
 287  * PARAMETERS:  Statements          - Number of statements to disassemble
 288  *              Op                  - Current Op (from parse walk)
 289  *
 290  * RETURN:      None
 291  *
 292  * DESCRIPTION: Display disassembled AML (ASL) starting from Op for the number
 293  *              of statements specified.
 294  *
 295  ******************************************************************************/
 296
 297 void
 298 AcpiDbDisassembleAml (
 299     char                    *Statements,
 300     ACPI_PARSE_OBJECT       *Op)
 301 {
 302     UINT32                  NumStatements = 8;
 303
 304
 305     if (!Op)
 306     {
 307         AcpiOsPrintf ("There is no method currently executing\n");
 308         return;
 309     }
 310
 311     if (Statements)
 312     {
 313         NumStatements = ACPI_STRTOUL (Statements, NULL, 0);
 314     }
 315
 316     AcpiDmDisassemble (NULL, Op, NumStatements);
 317 }
 318
 319
 320 /*******************************************************************************
 321  *
 322  * FUNCTION:    AcpiDbDisassembleMethod
 323  *
 324  * PARAMETERS:  Name            - Name of control method
 325  *
 326  * RETURN:      None
 327  *
 328  * DESCRIPTION: Display disassembled AML (ASL) starting from Op for the number
 329  *              of statements specified.
 330  *
 331  ******************************************************************************/
 332
 333 ACPI_STATUS
 334 AcpiDbDisassembleMethod (
 335     char                    *Name)
 336 {
 337     ACPI_STATUS             Status;
 338     ACPI_PARSE_OBJECT       *Op;
 339     ACPI_WALK_STATE         *WalkState;
 340     ACPI_OPERAND_OBJECT     *ObjDesc;
 341     ACPI_NAMESPACE_NODE     *Method;
 342
 343
 344     Method = AcpiDbConvertToNode (Name);
 345     if (!Method)
 346     {
 347         return (AE_BAD_PARAMETER);
 348     }
 349
 350     if (Method->Type != ACPI_TYPE_METHOD)
 351     {
 352         ACPI_ERROR ((AE_INFO, "%s (%s): Object must be a control method",
 353             Name, AcpiUtGetTypeName (Method->Type)));
 354         return (AE_BAD_PARAMETER);
 355     }
 356
 357     ObjDesc = Method->Object;
 358
 359     Op = AcpiPsCreateScopeOp ();
 360     if (!Op)
 361     {
 362         return (AE_NO_MEMORY);
 363     }
 364
 365     /* Create and initialize a new walk state */
 366
 367     WalkState = AcpiDsCreateWalkState (0, Op, NULL, NULL);
 368     if (!WalkState)
 369     {
 370         return (AE_NO_MEMORY);
 371     }
 372
 373     Status = AcpiDsInitAmlWalk (WalkState, Op, NULL,
 374         ObjDesc->Method.AmlStart,
 375         ObjDesc->Method.AmlLength, NULL, ACPI_IMODE_LOAD_PASS1);
 376     if (ACPI_FAILURE (Status))
 377     {
 378         return (Status);
 379     }
 380
 381     Status = AcpiUtAllocateOwnerId (&ObjDesc->Method.OwnerId);
 382     WalkState->OwnerId = ObjDesc->Method.OwnerId;
 383
 384     /* Push start scope on scope stack and make it current */
 385
 386     Status = AcpiDsScopeStackPush (Method,
 387         Method->Type, WalkState);
 388     if (ACPI_FAILURE (Status))
 389     {
 390         return (Status);
 391     }
 392
 393     /* Parse the entire method AML including deferred operators */
 394
 395     WalkState->ParseFlags &= ~ACPI_PARSE_DELETE_TREE;
 396     WalkState->ParseFlags |= ACPI_PARSE_DISASSEMBLE;
 397
 398     Status = AcpiPsParseAml (WalkState);
 399     (void) AcpiDmParseDeferredOps (Op);
 400
 401     /* Now we can disassemble the method */
 402
 403     AcpiGbl_DbOpt_verbose = FALSE;
 404     AcpiDmDisassemble (NULL, Op, 0);
 405     AcpiGbl_DbOpt_verbose = TRUE;
 406
 407     AcpiPsDeleteParseTree (Op);
 408
 409     /* Method cleanup */
 410
 411     AcpiNsDeleteNamespaceSubtree (Method);
 412     AcpiNsDeleteNamespaceByOwner (ObjDesc->Method.OwnerId);
 413     AcpiUtReleaseOwnerId (&ObjDesc->Method.OwnerId);
 414     return (AE_OK);
 415 }
 416
 417
 418 /*******************************************************************************
 419  *
 420  * FUNCTION:    AcpiDbWalkForExecute
 421  *
 422  * PARAMETERS:  Callback from WalkNamespace
 423  *
 424  * RETURN:      Status
 425  *
 426  * DESCRIPTION: Batch execution module. Currently only executes predefined
 427  *              ACPI names.
 428  *
 429  ******************************************************************************/
 430
 431 static ACPI_STATUS
 432 AcpiDbWalkForExecute (
 433     ACPI_HANDLE             ObjHandle,
 434     UINT32                  NestingLevel,
 435     void                    *Context,
 436     void                    **ReturnValue)
 437 {
 438     ACPI_NAMESPACE_NODE         *Node = (ACPI_NAMESPACE_NODE *) ObjHandle;
 439     ACPI_DB_EXECUTE_WALK        *Info = (ACPI_DB_EXECUTE_WALK *) Context;
 440     char                        *Pathname;
 441     const ACPI_PREDEFINED_INFO  *Predefined;
 442     ACPI_DEVICE_INFO            *ObjInfo;
 443     ACPI_OBJECT_LIST            ParamObjects;
 444     ACPI_OBJECT                 Params[ACPI_METHOD_NUM_ARGS];
 445     ACPI_OBJECT                 *ThisParam;
 446     ACPI_BUFFER                 ReturnObj;
 447     ACPI_STATUS                 Status;
 448     UINT16                      ArgTypeList;
 449     UINT8                       ArgCount;
 450     UINT8                       ArgType;
 451     UINT32                      i;
 452
 453
 454     /* The name must be a predefined ACPI name */
 455
 456     Predefined = AcpiUtMatchPredefinedMethod (Node->Name.Ascii);
 457     if (!Predefined)
 458     {
 459         return (AE_OK);
 460     }
 461
 462     if (Node->Type == ACPI_TYPE_LOCAL_SCOPE)
 463     {
 464         return (AE_OK);
 465     }
 466
 467     Pathname = AcpiNsGetExternalPathname (Node);
 468     if (!Pathname)
 469     {
 470         return (AE_OK);
 471     }
 472
 473     /* Get the object info for number of method parameters */
 474
 475     Status = AcpiGetObjectInfo (ObjHandle, &ObjInfo);
 476     if (ACPI_FAILURE (Status))
 477     {
 478         return (Status);
 479     }
 480
 481     ParamObjects.Count = 0;
 482     ParamObjects.Pointer = NULL;
 483
 484     if (ObjInfo->Type == ACPI_TYPE_METHOD)
 485     {
 486         /* Setup default parameters (with proper types) */
 487
 488         ArgTypeList = Predefined->Info.ArgumentList;
 489         ArgCount = METHOD_GET_ARG_COUNT (ArgTypeList);
 490
 491         /*
 492          * Setup the ACPI-required number of arguments, regardless of what
 493          * the actual method defines. If there is a difference, then the
 494          * method is wrong and a warning will be issued during execution.
 495          */
 496         ThisParam = Params;
 497         for (i = 0; i < ArgCount; i++)
 498         {
 499             ArgType = METHOD_GET_NEXT_TYPE (ArgTypeList);
 500             ThisParam->Type = ArgType;
 501
 502             switch (ArgType)
 503             {
 504             case ACPI_TYPE_INTEGER:
 505
 506                 ThisParam->Integer.Value = 1;
 507                 break;
 508
 509             case ACPI_TYPE_STRING:
 510
 511                 ThisParam->String.Pointer = "This is the default argument string";
 512                 ThisParam->String.Length = ACPI_STRLEN (ThisParam->String.Pointer);
 513                 break;
 514
 515             case ACPI_TYPE_BUFFER:
 516
 517                 ThisParam->Buffer.Pointer = (UINT8 *) Params; /* just a garbage buffer */
 518                 ThisParam->Buffer.Length = 48;
 519                 break;
 520
 521              case ACPI_TYPE_PACKAGE:
 522
 523                 ThisParam->Package.Elements = NULL;
 524                 ThisParam->Package.Count = 0;
 525                 break;
 526
 527            default:
 528
 529                 AcpiOsPrintf ("%s: Unsupported argument type: %u\n",
 530                     Pathname, ArgType);
 531                 break;
 532             }
 533
 534             ThisParam++;
 535         }
 536
 537         ParamObjects.Count = ArgCount;
 538         ParamObjects.Pointer = Params;
 539     }
 540
 541     ACPI_FREE (ObjInfo);
 542     ReturnObj.Pointer = NULL;
 543     ReturnObj.Length = ACPI_ALLOCATE_BUFFER;
 544
 545     /* Do the actual method execution */
 546
 547     AcpiGbl_MethodExecuting = TRUE;
 548
 549     Status = AcpiEvaluateObject (Node, NULL, &ParamObjects, &ReturnObj);
 550
 551     AcpiOsPrintf ("%-32s returned %s\n", Pathname, AcpiFormatException (Status));
 552     AcpiGbl_MethodExecuting = FALSE;
 553     ACPI_FREE (Pathname);
 554
 555     /* Ignore status from method execution */
 556
 557     Status = AE_OK;
 558
 559     /* Update count, check if we have executed enough methods */
 560
 561     Info->Count++;
 562     if (Info->Count >= Info->MaxCount)
 563     {
 564         Status = AE_CTRL_TERMINATE;
 565     }
 566
 567     return (Status);
 568 }
 569
 570
 571 /*******************************************************************************
 572  *
 573  * FUNCTION:    AcpiDbBatchExecute
 574  *
 575  * PARAMETERS:  CountArg            - Max number of methods to execute
 576  *
 577  * RETURN:      None
 578  *
 579  * DESCRIPTION: Namespace batch execution. Execute predefined names in the
 580  *              namespace, up to the max count, if specified.
 581  *
 582  ******************************************************************************/
 583
 584 void
 585 AcpiDbBatchExecute (
 586     char                    *CountArg)
 587 {
 588     ACPI_DB_EXECUTE_WALK    Info;
 589
 590
 591     Info.Count = 0;
 592     Info.MaxCount = ACPI_UINT32_MAX;
 593
 594     if (CountArg)
 595     {
 596         Info.MaxCount = ACPI_STRTOUL (CountArg, NULL, 0);
 597     }
 598
 599
 600     /* Search all nodes in namespace */
 601
 602     (void) AcpiWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX,
 603                 AcpiDbWalkForExecute, NULL, (void *) &Info, NULL);
 604
 605     AcpiOsPrintf ("Evaluated %u predefined names in the namespace\n", Info.Count);
 606 }
 607
 608 #endif /* ACPI_DEBUGGER */