drivers/acpi/namespace/nseval.c

   1
   2 /******************************************************************************
   3  *
   4  * Module Name: nseval - Object evaluation interfaces -- includes control
   5  *                       method lookup and execution.
   6  *
   7  *****************************************************************************/
   8
   9 /*
  10  *  Copyright (C) 2000 R. Byron Moore
  11  *
  12  *  This program is free software; you can redistribute it and/or modify
  13  *  it under the terms of the GNU General Public License as published by
  14  *  the Free Software Foundation; either version 2 of the License, or
  15  *  (at your option) any later version.
  16  *
  17  *  This program is distributed in the hope that it will be useful,
  18  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  *  GNU General Public License for more details.
  21  *
  22  *  You should have received a copy of the GNU General Public License
  23  *  along with this program; if not, write to the Free Software
  24  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  25  */
  26
  27
  28 #include "acpi.h"
  29 #include "amlcode.h"
  30 #include "parser.h"
  31 #include "interp.h"
  32 #include "namesp.h"
  33
  34
  35 #define _COMPONENT          NAMESPACE
  36          MODULE_NAME         ("nseval");
  37
  38
  39 /****************************************************************************
  40  *
  41  * FUNCTION:    Acpi_ns_evaluate_relative
  42  *
  43  * PARAMETERS:  Rel_obj_entry       - NTE of the relative containing object
  44  *              *Pathname           - Name of method to execute, If NULL, the
  45  *                                    handle is the object to execute
  46  *              **Params            - List of parameters to pass to the method,
  47  *                                    terminated by NULL.  Params itself may be
  48  *                                    NULL if no parameters are being passed.
  49  *              *Return_object      - Where to put method's return value (if
  50  *                                    any).  If NULL, no value is returned.
  51  *
  52  * RETURN:      Status
  53  *
  54  * DESCRIPTION: Find and execute the requested method using the handle as a
  55  *              scope
  56  *
  57  * MUTEX:       Locks Namespace
  58  *
  59  ****************************************************************************/
  60
  61 ACPI_STATUS
  62 acpi_ns_evaluate_relative (
  63         ACPI_NAMED_OBJECT       *handle,
  64         char                    *pathname,
  65         ACPI_OBJECT_INTERNAL    **params,
  66         ACPI_OBJECT_INTERNAL    **return_object)
  67 {
  68         ACPI_NAMED_OBJECT       *rel_obj_entry;
  69         ACPI_STATUS             status;
  70         ACPI_NAMED_OBJECT       *obj_entry = NULL;
  71         char                    *internal_path = NULL;
  72         ACPI_GENERIC_STATE      scope_info;
  73
  74
  75         /*
  76          * Must have a valid object handle
  77          */
  78         if (!handle) {
  79                 return (AE_BAD_PARAMETER);
  80         }
  81
  82         /* Build an internal name string for the method */
  83
  84         status = acpi_ns_internalize_name (pathname, &internal_path);
  85         if (ACPI_FAILURE (status)) {
  86                 return (status);
  87         }
  88
  89         /* Get the prefix handle and NTE */
  90
  91         acpi_cm_acquire_mutex (ACPI_MTX_NAMESPACE);
  92
  93         rel_obj_entry = acpi_ns_convert_handle_to_entry (handle);
  94         if (!rel_obj_entry) {
  95                 acpi_cm_release_mutex (ACPI_MTX_NAMESPACE);
  96                 status = AE_BAD_PARAMETER;
  97                 goto cleanup;
  98         }
  99
 100         /* Lookup the name in the namespace */
 101
 102         scope_info.scope.name_table = rel_obj_entry->child_table;
 103         status = acpi_ns_lookup (&scope_info, internal_path, ACPI_TYPE_ANY,
 104                          IMODE_EXECUTE,
 105                          NS_NO_UPSEARCH, NULL,
 106                          &obj_entry);
 107
 108         acpi_cm_release_mutex (ACPI_MTX_NAMESPACE);
 109
 110         if (status != AE_OK) {
 111                 goto cleanup;
 112         }
 113
 114         /*
 115          * Now that we have a handle to the object, we can attempt
 116          * to evaluate it.
 117          */
 118
 119         status = acpi_ns_evaluate_by_handle (obj_entry, params, return_object);
 120
 121 cleanup:
 122
 123         /* Cleanup */
 124
 125         acpi_cm_free (internal_path);
 126
 127         return (status);
 128 }
 129
 130
 131 /****************************************************************************
 132  *
 133  * FUNCTION:    Acpi_ns_evaluate_by_name
 134  *
 135  * PARAMETERS:  Pathname            - Fully qualified pathname to the object
 136  *              *Return_object      - Where to put method's return value (if
 137  *                                    any).  If NULL, no value is returned.
 138  *              **Params            - List of parameters to pass to the method,
 139  *                                    terminated by NULL.  Params itself may be
 140  *                                    NULL if no parameters are being passed.
 141  *
 142  * RETURN:      Status
 143  *
 144  * DESCRIPTION: Find and execute the requested method passing the given
 145  *              parameters
 146  *
 147  * MUTEX:       Locks Namespace
 148  *
 149  ****************************************************************************/
 150
 151 ACPI_STATUS
 152 acpi_ns_evaluate_by_name (
 153         char                    *pathname,
 154         ACPI_OBJECT_INTERNAL    **params,
 155         ACPI_OBJECT_INTERNAL    **return_object)
 156 {
 157         ACPI_STATUS             status;
 158         ACPI_NAMED_OBJECT       *obj_entry = NULL;
 159         char                    *internal_path = NULL;
 160
 161
 162         /* Build an internal name string for the method */
 163
 164         if (pathname[0] != '\\' || pathname[1] != '/') {
 165                 status = acpi_ns_internalize_name (pathname, &internal_path);
 166                 if (ACPI_FAILURE (status)) {
 167                         return (status);
 168                 }
 169         }
 170
 171         acpi_cm_acquire_mutex (ACPI_MTX_NAMESPACE);
 172
 173         /* Lookup the name in the namespace */
 174
 175         status = acpi_ns_lookup (NULL, internal_path, ACPI_TYPE_ANY,
 176                          IMODE_EXECUTE,
 177                          NS_NO_UPSEARCH, NULL,
 178                          &obj_entry);
 179
 180         acpi_cm_release_mutex (ACPI_MTX_NAMESPACE);
 181
 182         if (status != AE_OK) {
 183                 goto cleanup;
 184         }
 185
 186         /*
 187          * Now that we have a handle to the object, we can attempt
 188          * to evaluate it.
 189          */
 190
 191         status = acpi_ns_evaluate_by_handle (obj_entry, params, return_object);
 192
 193
 194 cleanup:
 195
 196         /* Cleanup */
 197
 198         if (internal_path) {
 199                 acpi_cm_free (internal_path);
 200         }
 201
 202         return (status);
 203 }
 204
 205
 206 /****************************************************************************
 207  *
 208  * FUNCTION:    Acpi_ns_evaluate_by_handle
 209  *
 210  * PARAMETERS:  Obj_entry           - NTE of method to execute
 211  *              *Return_object      - Where to put method's return value (if
 212  *                                    any).  If NULL, no value is returned.
 213  *              **Params            - List of parameters to pass to the method,
 214  *                                    terminated by NULL.  Params itself may be
 215  *                                    NULL if no parameters are being passed.
 216  *
 217  * RETURN:      Status
 218  *
 219  * DESCRIPTION: Execute the requested method passing the given parameters
 220  *
 221  * MUTEX:       Locks Namespace
 222  *
 223  ****************************************************************************/
 224
 225 ACPI_STATUS
 226 acpi_ns_evaluate_by_handle (
 227         ACPI_NAMED_OBJECT       *handle,
 228         ACPI_OBJECT_INTERNAL    **params,
 229         ACPI_OBJECT_INTERNAL    **return_object)
 230 {
 231         ACPI_NAMED_OBJECT       *obj_entry;
 232         ACPI_STATUS             status;
 233         ACPI_OBJECT_INTERNAL    *local_return_object;
 234
 235
 236         /* Check if namespace has been initialized */
 237
 238         if (!acpi_gbl_root_object->child_table) {
 239                 return (AE_NO_NAMESPACE);
 240         }
 241
 242         /* Parameter Validation */
 243
 244         if (!handle) {
 245                 return (AE_BAD_PARAMETER);
 246         }
 247
 248         if (return_object) {
 249                 /* Initialize the return value to an invalid object */
 250
 251                 *return_object = NULL;
 252         }
 253
 254         /* Get the prefix handle and NTE */
 255
 256         acpi_cm_acquire_mutex (ACPI_MTX_NAMESPACE);
 257
 258         obj_entry = acpi_ns_convert_handle_to_entry (handle);
 259         if (!obj_entry) {
 260                 status = AE_BAD_PARAMETER;
 261                 goto unlock_and_exit;
 262         }
 263
 264
 265         /*
 266          * Two major cases here:
 267          * 1) The object is an actual control method -- execute it.
 268          * 2) The object is not a method -- just return it's current
 269          *      value
 270          *
 271          * In both cases, the namespace is unlocked by the
 272          *  Acpi_ns* procedure
 273          */
 274
 275         if (acpi_ns_get_type (obj_entry) == ACPI_TYPE_METHOD) {
 276                 /*
 277                  * Case 1) We have an actual control method to execute
 278                  */
 279
 280                 status = acpi_ns_execute_control_method (obj_entry,
 281                                  params,
 282                                  &local_return_object);
 283         }
 284
 285         else {
 286                 /*
 287                  * Case 2) Object is NOT a method, just return its
 288                  * current value
 289                  */
 290
 291                 status = acpi_ns_get_object_value (obj_entry,
 292                                    &local_return_object);
 293         }
 294
 295
 296         /*
 297          * Check if there is a return value on the stack that must
 298          * be dealt with
 299          */
 300
 301         if (status == AE_CTRL_RETURN_VALUE) {
 302                 /*
 303                  * If the Method returned a value and the caller
 304                  * provided a place to store a returned value, Copy
 305                  * the returned value to the object descriptor provided
 306                  * by the caller.
 307                  */
 308
 309                 if (return_object) {
 310                         /*
 311                          * Valid return object, copy the pointer to
 312                          * the returned object
 313                          */
 314
 315                         *return_object = local_return_object;
 316                 }
 317
 318
 319                 /* Map AE_RETURN_VALUE to AE_OK, we are done with it */
 320
 321                 if (status == AE_CTRL_RETURN_VALUE) {
 322                         status = AE_OK;
 323                 }
 324         }
 325
 326         /*
 327          * Namespace was unlocked by the handling Acpi_ns* function,
 328          * so we just return
 329          */
 330
 331         return (status);
 332
 333
 334 unlock_and_exit:
 335
 336         acpi_cm_release_mutex (ACPI_MTX_NAMESPACE);
 337         return (status);
 338 }
 339
 340
 341 /****************************************************************************
 342  *
 343  * FUNCTION:    Acpi_ns_execute_control_method
 344  *
 345  * PARAMETERS:  Method_entry        - The Nte of the object/method
 346  *              **Params            - List of parameters to pass to the method,
 347  *                                    terminated by NULL.  Params itself may be
 348  *                                    NULL if no parameters are being passed.
 349  *
 350  * RETURN:      Status
 351  *
 352  * DESCRIPTION: Execute the requested method passing the given parameters
 353  *
 354  * MUTEX:       Assumes namespace is locked
 355  *
 356  ****************************************************************************/
 357
 358 ACPI_STATUS
 359 acpi_ns_execute_control_method (
 360         ACPI_NAMED_OBJECT       *method_entry,
 361         ACPI_OBJECT_INTERNAL    **params,
 362         ACPI_OBJECT_INTERNAL    **return_obj_desc)
 363 {
 364         ACPI_STATUS             status;
 365         ACPI_OBJECT_INTERNAL    *obj_desc;
 366
 367
 368         /* Verify that there is a method associated with this object */
 369
 370         obj_desc = acpi_ns_get_attached_object ((ACPI_HANDLE) method_entry);
 371         if (!obj_desc) {
 372                 return (AE_ERROR);
 373         }
 374
 375         /*
 376          * Valid method, Set the current scope to that of the Method,
 377          * and execute it.
 378          */
 379
 380
 381         /*
 382          * Unlock the namespace before execution.  This allows namespace access
 383          * via the external Acpi* interfaces while a method is being executed.
 384          * However, any namespace deletion must acquire both the namespace and
 385          * interpter locks to ensure that no thread is using the portion of the
 386          * namespace that is being deleted.
 387          */
 388
 389         acpi_cm_release_mutex (ACPI_MTX_NAMESPACE);
 390
 391         /*
 392          * Excecute the method via the interpreter
 393          */
 394         status = acpi_aml_execute_method (method_entry, params, return_obj_desc);
 395
 396         return (status);
 397 }
 398
 399
 400 /****************************************************************************
 401  *
 402  * FUNCTION:    Acpi_ns_get_object_value
 403  *
 404  * PARAMETERS:  Object_entry        - The Nte of the object
 405  *
 406  * RETURN:      Status
 407  *
 408  * DESCRIPTION: Return the current value of the object
 409  *
 410  * MUTEX:       Assumes namespace is locked
 411  *
 412  ****************************************************************************/
 413
 414 ACPI_STATUS
 415 acpi_ns_get_object_value (
 416         ACPI_NAMED_OBJECT       *object_entry,
 417         ACPI_OBJECT_INTERNAL    **return_obj_desc)
 418 {
 419         ACPI_STATUS             status = AE_OK;
 420         ACPI_OBJECT_INTERNAL    *obj_desc;
 421         ACPI_OBJECT_INTERNAL    *val_desc;
 422
 423
 424         /*
 425          *  We take the value from certain objects directly
 426          */
 427
 428         if ((object_entry->type == ACPI_TYPE_PROCESSOR) ||
 429                 (object_entry->type == ACPI_TYPE_POWER))
 430         {
 431
 432                 /*
 433                  *  Create a Reference object to contain the object
 434                  */
 435                 obj_desc = acpi_cm_create_internal_object (object_entry->type);
 436                 if (!obj_desc) {
 437                    status = AE_NO_MEMORY;
 438                    goto unlock_and_exit;
 439                 }
 440
 441                 /*
 442                  *  Get the attached object
 443                  */
 444
 445                 val_desc = acpi_ns_get_attached_object (object_entry);
 446                 if (!val_desc) {
 447                         status = AE_NULL_OBJECT;
 448                         goto unlock_and_exit;
 449                 }
 450
 451                 /*
 452                  *  Just copy from the original to the return object
 453                  */
 454
 455                 MEMCPY (&obj_desc->common.first_non_common_byte,
 456                                 &val_desc->common.first_non_common_byte,
 457                                 (sizeof(ACPI_OBJECT_COMMON) -
 458                                 sizeof(obj_desc->common.first_non_common_byte)));
 459         }
 460
 461
 462         /*
 463          * Other objects require a reference object wrapper which we
 464          * then attempt to resolve.
 465          */
 466         else {
 467                 /* Create an Reference object to contain the object */
 468
 469                 obj_desc = acpi_cm_create_internal_object (INTERNAL_TYPE_REFERENCE);
 470                 if (!obj_desc) {
 471                    status = AE_NO_MEMORY;
 472                    goto unlock_and_exit;
 473                 }
 474
 475                 /* Construct a descriptor pointing to the name */
 476
 477                 obj_desc->reference.op_code = (u8) AML_NAME_OP;
 478                 obj_desc->reference.object = (void *) object_entry;
 479
 480                 /*
 481                  * Use Acpi_aml_resolve_to_value() to get the associated value.
 482                  * The call to Acpi_aml_resolve_to_value causes
 483                  * Obj_desc (allocated above) to always be deleted.
 484                  */
 485
 486                 status = acpi_aml_resolve_to_value (&obj_desc);
 487         }
 488
 489         /*
 490          * If Acpi_aml_resolve_to_value() succeeded, the return value was
 491          * placed in Obj_desc.
 492          */
 493
 494         if (status == AE_OK) {
 495                 status = AE_CTRL_RETURN_VALUE;
 496
 497                 *return_obj_desc = obj_desc;
 498         }
 499
 500
 501 unlock_and_exit:
 502
 503         /* Unlock the namespace */
 504
 505         acpi_cm_release_mutex (ACPI_MTX_NAMESPACE);
 506         return (status);
 507 }