drivers/acpi/utilities/uteval.c

   1 /******************************************************************************
   2  *
   3  * Module Name: uteval - Object evaluation
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2005, R. Byron Moore
   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 #include <acpi/acpi.h>
  45 #include <acpi/acnamesp.h>
  46 #include <acpi/acinterp.h>
  47
  48 #define _COMPONENT          ACPI_UTILITIES
  49 ACPI_MODULE_NAME("uteval")
  50
  51 /* Local prototypes */
  52 static void
  53 acpi_ut_copy_id_string(char *destination, char *source, acpi_size max_length);
  54
  55 static acpi_status
  56 acpi_ut_translate_one_cid(union acpi_operand_object *obj_desc,
  57                           struct acpi_compatible_id *one_cid);
  58
  59 /*******************************************************************************
  60  *
  61  * FUNCTION:    acpi_ut_osi_implementation
  62  *
  63  * PARAMETERS:  walk_state          - Current walk state
  64  *
  65  * RETURN:      Status
  66  *
  67  * DESCRIPTION: Implementation of _OSI predefined control method
  68  *              Supported = _OSI (String)
  69  *
  70  ******************************************************************************/
  71
  72 acpi_status acpi_ut_osi_implementation(struct acpi_walk_state *walk_state)
  73 {
  74         union acpi_operand_object *string_desc;
  75         union acpi_operand_object *return_desc;
  76         acpi_native_uint i;
  77
  78         ACPI_FUNCTION_TRACE("ut_osi_implementation");
  79
  80         /* Validate the string input argument */
  81
  82         string_desc = walk_state->arguments[0].object;
  83         if (!string_desc || (string_desc->common.type != ACPI_TYPE_STRING)) {
  84                 return_ACPI_STATUS(AE_TYPE);
  85         }
  86
  87         /* Create a return object (Default value = 0) */
  88
  89         return_desc = acpi_ut_create_internal_object(ACPI_TYPE_INTEGER);
  90         if (!return_desc) {
  91                 return_ACPI_STATUS(AE_NO_MEMORY);
  92         }
  93
  94         /* Compare input string to table of supported strings */
  95
  96         for (i = 0; i < ACPI_NUM_OSI_STRINGS; i++) {
  97                 if (!ACPI_STRCMP(string_desc->string.pointer,
  98                                  (char *)acpi_gbl_valid_osi_strings[i])) {
  99                         /* This string is supported */
 100
 101                         return_desc->integer.value = 0xFFFFFFFF;
 102                         break;
 103                 }
 104         }
 105
 106         walk_state->return_desc = return_desc;
 107         return_ACPI_STATUS(AE_CTRL_TERMINATE);
 108 }
 109
 110 /*******************************************************************************
 111  *
 112  * FUNCTION:    acpi_ut_evaluate_object
 113  *
 114  * PARAMETERS:  prefix_node         - Starting node
 115  *              Path                - Path to object from starting node
 116  *              expected_return_types - Bitmap of allowed return types
 117  *              return_desc         - Where a return value is stored
 118  *
 119  * RETURN:      Status
 120  *
 121  * DESCRIPTION: Evaluates a namespace object and verifies the type of the
 122  *              return object.  Common code that simplifies accessing objects
 123  *              that have required return objects of fixed types.
 124  *
 125  *              NOTE: Internal function, no parameter validation
 126  *
 127  ******************************************************************************/
 128
 129 acpi_status
 130 acpi_ut_evaluate_object(struct acpi_namespace_node *prefix_node,
 131                         char *path,
 132                         u32 expected_return_btypes,
 133                         union acpi_operand_object **return_desc)
 134 {
 135         struct acpi_parameter_info info;
 136         acpi_status status;
 137         u32 return_btype;
 138
 139         ACPI_FUNCTION_TRACE("ut_evaluate_object");
 140
 141         info.node = prefix_node;
 142         info.parameters = NULL;
 143         info.parameter_type = ACPI_PARAM_ARGS;
 144
 145         /* Evaluate the object/method */
 146
 147         status = acpi_ns_evaluate_relative(path, &info);
 148         if (ACPI_FAILURE(status)) {
 149                 if (status == AE_NOT_FOUND) {
 150                         ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
 151                                           "[%4.4s.%s] was not found\n",
 152                                           acpi_ut_get_node_name(prefix_node),
 153                                           path));
 154                 } else {
 155                         ACPI_REPORT_METHOD_ERROR("Method execution failed",
 156                                                  prefix_node, path, status);
 157                 }
 158
 159                 return_ACPI_STATUS(status);
 160         }
 161
 162         /* Did we get a return object? */
 163
 164         if (!info.return_object) {
 165                 if (expected_return_btypes) {
 166                         ACPI_REPORT_METHOD_ERROR("No object was returned from",
 167                                                  prefix_node, path,
 168                                                  AE_NOT_EXIST);
 169
 170                         return_ACPI_STATUS(AE_NOT_EXIST);
 171                 }
 172
 173                 return_ACPI_STATUS(AE_OK);
 174         }
 175
 176         /* Map the return object type to the bitmapped type */
 177
 178         switch (ACPI_GET_OBJECT_TYPE(info.return_object)) {
 179         case ACPI_TYPE_INTEGER:
 180                 return_btype = ACPI_BTYPE_INTEGER;
 181                 break;
 182
 183         case ACPI_TYPE_BUFFER:
 184                 return_btype = ACPI_BTYPE_BUFFER;
 185                 break;
 186
 187         case ACPI_TYPE_STRING:
 188                 return_btype = ACPI_BTYPE_STRING;
 189                 break;
 190
 191         case ACPI_TYPE_PACKAGE:
 192                 return_btype = ACPI_BTYPE_PACKAGE;
 193                 break;
 194
 195         default:
 196                 return_btype = 0;
 197                 break;
 198         }
 199
 200         if ((acpi_gbl_enable_interpreter_slack) && (!expected_return_btypes)) {
 201                 /*
 202                  * We received a return object, but one was not expected.  This can
 203                  * happen frequently if the "implicit return" feature is enabled.
 204                  * Just delete the return object and return AE_OK.
 205                  */
 206                 acpi_ut_remove_reference(info.return_object);
 207                 return_ACPI_STATUS(AE_OK);
 208         }
 209
 210         /* Is the return object one of the expected types? */
 211
 212         if (!(expected_return_btypes & return_btype)) {
 213                 ACPI_REPORT_METHOD_ERROR("Return object type is incorrect",
 214                                          prefix_node, path, AE_TYPE);
 215
 216                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 217                                   "Type returned from %s was incorrect: %s, expected Btypes: %X\n",
 218                                   path,
 219                                   acpi_ut_get_object_type_name(info.
 220                                                                return_object),
 221                                   expected_return_btypes));
 222
 223                 /* On error exit, we must delete the return object */
 224
 225                 acpi_ut_remove_reference(info.return_object);
 226                 return_ACPI_STATUS(AE_TYPE);
 227         }
 228
 229         /* Object type is OK, return it */
 230
 231         *return_desc = info.return_object;
 232         return_ACPI_STATUS(AE_OK);
 233 }
 234
 235 /*******************************************************************************
 236  *
 237  * FUNCTION:    acpi_ut_evaluate_numeric_object
 238  *
 239  * PARAMETERS:  object_name         - Object name to be evaluated
 240  *              device_node         - Node for the device
 241  *              Address             - Where the value is returned
 242  *
 243  * RETURN:      Status
 244  *
 245  * DESCRIPTION: Evaluates a numeric namespace object for a selected device
 246  *              and stores result in *Address.
 247  *
 248  *              NOTE: Internal function, no parameter validation
 249  *
 250  ******************************************************************************/
 251
 252 acpi_status
 253 acpi_ut_evaluate_numeric_object(char *object_name,
 254                                 struct acpi_namespace_node *device_node,
 255                                 acpi_integer * address)
 256 {
 257         union acpi_operand_object *obj_desc;
 258         acpi_status status;
 259
 260         ACPI_FUNCTION_TRACE("ut_evaluate_numeric_object");
 261
 262         status = acpi_ut_evaluate_object(device_node, object_name,
 263                                          ACPI_BTYPE_INTEGER, &obj_desc);
 264         if (ACPI_FAILURE(status)) {
 265                 return_ACPI_STATUS(status);
 266         }
 267
 268         /* Get the returned Integer */
 269
 270         *address = obj_desc->integer.value;
 271
 272         /* On exit, we must delete the return object */
 273
 274         acpi_ut_remove_reference(obj_desc);
 275         return_ACPI_STATUS(status);
 276 }
 277
 278 /*******************************************************************************
 279  *
 280  * FUNCTION:    acpi_ut_copy_id_string
 281  *
 282  * PARAMETERS:  Destination         - Where to copy the string
 283  *              Source              - Source string
 284  *              max_length          - Length of the destination buffer
 285  *
 286  * RETURN:      None
 287  *
 288  * DESCRIPTION: Copies an ID string for the _HID, _CID, and _UID methods.
 289  *              Performs removal of a leading asterisk if present -- workaround
 290  *              for a known issue on a bunch of machines.
 291  *
 292  ******************************************************************************/
 293
 294 static void
 295 acpi_ut_copy_id_string(char *destination, char *source, acpi_size max_length)
 296 {
 297
 298         /*
 299          * Workaround for ID strings that have a leading asterisk. This construct
 300          * is not allowed by the ACPI specification  (ID strings must be
 301          * alphanumeric), but enough existing machines have this embedded in their
 302          * ID strings that the following code is useful.
 303          */
 304         if (*source == '*') {
 305                 source++;
 306         }
 307
 308         /* Do the actual copy */
 309
 310         ACPI_STRNCPY(destination, source, max_length);
 311 }
 312
 313 /*******************************************************************************
 314  *
 315  * FUNCTION:    acpi_ut_execute_HID
 316  *
 317  * PARAMETERS:  device_node         - Node for the device
 318  *              Hid                 - Where the HID is returned
 319  *
 320  * RETURN:      Status
 321  *
 322  * DESCRIPTION: Executes the _HID control method that returns the hardware
 323  *              ID of the device.
 324  *
 325  *              NOTE: Internal function, no parameter validation
 326  *
 327  ******************************************************************************/
 328
 329 acpi_status
 330 acpi_ut_execute_HID(struct acpi_namespace_node *device_node,
 331                     struct acpi_device_id *hid)
 332 {
 333         union acpi_operand_object *obj_desc;
 334         acpi_status status;
 335
 336         ACPI_FUNCTION_TRACE("ut_execute_HID");
 337
 338         status = acpi_ut_evaluate_object(device_node, METHOD_NAME__HID,
 339                                          ACPI_BTYPE_INTEGER | ACPI_BTYPE_STRING,
 340                                          &obj_desc);
 341         if (ACPI_FAILURE(status)) {
 342                 return_ACPI_STATUS(status);
 343         }
 344
 345         if (ACPI_GET_OBJECT_TYPE(obj_desc) == ACPI_TYPE_INTEGER) {
 346                 /* Convert the Numeric HID to string */
 347
 348                 acpi_ex_eisa_id_to_string((u32) obj_desc->integer.value,
 349                                           hid->value);
 350         } else {
 351                 /* Copy the String HID from the returned object */
 352
 353                 acpi_ut_copy_id_string(hid->value, obj_desc->string.pointer,
 354                                        sizeof(hid->value));
 355         }
 356
 357         /* On exit, we must delete the return object */
 358
 359         acpi_ut_remove_reference(obj_desc);
 360         return_ACPI_STATUS(status);
 361 }
 362
 363 /*******************************************************************************
 364  *
 365  * FUNCTION:    acpi_ut_translate_one_cid
 366  *
 367  * PARAMETERS:  obj_desc            - _CID object, must be integer or string
 368  *              one_cid             - Where the CID string is returned
 369  *
 370  * RETURN:      Status
 371  *
 372  * DESCRIPTION: Return a numeric or string _CID value as a string.
 373  *              (Compatible ID)
 374  *
 375  *              NOTE:  Assumes a maximum _CID string length of
 376  *                     ACPI_MAX_CID_LENGTH.
 377  *
 378  ******************************************************************************/
 379
 380 static acpi_status
 381 acpi_ut_translate_one_cid(union acpi_operand_object *obj_desc,
 382                           struct acpi_compatible_id *one_cid)
 383 {
 384
 385         switch (ACPI_GET_OBJECT_TYPE(obj_desc)) {
 386         case ACPI_TYPE_INTEGER:
 387
 388                 /* Convert the Numeric CID to string */
 389
 390                 acpi_ex_eisa_id_to_string((u32) obj_desc->integer.value,
 391                                           one_cid->value);
 392                 return (AE_OK);
 393
 394         case ACPI_TYPE_STRING:
 395
 396                 if (obj_desc->string.length > ACPI_MAX_CID_LENGTH) {
 397                         return (AE_AML_STRING_LIMIT);
 398                 }
 399
 400                 /* Copy the String CID from the returned object */
 401
 402                 acpi_ut_copy_id_string(one_cid->value, obj_desc->string.pointer,
 403                                        ACPI_MAX_CID_LENGTH);
 404                 return (AE_OK);
 405
 406         default:
 407
 408                 return (AE_TYPE);
 409         }
 410 }
 411
 412 /*******************************************************************************
 413  *
 414  * FUNCTION:    acpi_ut_execute_CID
 415  *
 416  * PARAMETERS:  device_node         - Node for the device
 417  *              return_cid_list     - Where the CID list is returned
 418  *
 419  * RETURN:      Status
 420  *
 421  * DESCRIPTION: Executes the _CID control method that returns one or more
 422  *              compatible hardware IDs for the device.
 423  *
 424  *              NOTE: Internal function, no parameter validation
 425  *
 426  ******************************************************************************/
 427
 428 acpi_status
 429 acpi_ut_execute_CID(struct acpi_namespace_node * device_node,
 430                     struct acpi_compatible_id_list ** return_cid_list)
 431 {
 432         union acpi_operand_object *obj_desc;
 433         acpi_status status;
 434         u32 count;
 435         u32 size;
 436         struct acpi_compatible_id_list *cid_list;
 437         acpi_native_uint i;
 438
 439         ACPI_FUNCTION_TRACE("ut_execute_CID");
 440
 441         /* Evaluate the _CID method for this device */
 442
 443         status = acpi_ut_evaluate_object(device_node, METHOD_NAME__CID,
 444                                          ACPI_BTYPE_INTEGER | ACPI_BTYPE_STRING
 445                                          | ACPI_BTYPE_PACKAGE, &obj_desc);
 446         if (ACPI_FAILURE(status)) {
 447                 return_ACPI_STATUS(status);
 448         }
 449
 450         /* Get the number of _CIDs returned */
 451
 452         count = 1;
 453         if (ACPI_GET_OBJECT_TYPE(obj_desc) == ACPI_TYPE_PACKAGE) {
 454                 count = obj_desc->package.count;
 455         }
 456
 457         /* Allocate a worst-case buffer for the _CIDs */
 458
 459         size = (((count - 1) * sizeof(struct acpi_compatible_id)) +
 460                 sizeof(struct acpi_compatible_id_list));
 461
 462         cid_list = ACPI_MEM_CALLOCATE((acpi_size) size);
 463         if (!cid_list) {
 464                 return_ACPI_STATUS(AE_NO_MEMORY);
 465         }
 466
 467         /* Init CID list */
 468
 469         cid_list->count = count;
 470         cid_list->size = size;
 471
 472         /*
 473          *  A _CID can return either a single compatible ID or a package of
 474          *  compatible IDs.  Each compatible ID can be one of the following:
 475          *  1) Integer (32 bit compressed EISA ID) or
 476          *  2) String (PCI ID format, e.g. "PCI\VEN_vvvv&DEV_dddd&SUBSYS_ssssssss")
 477          */
 478
 479         /* The _CID object can be either a single CID or a package (list) of CIDs */
 480
 481         if (ACPI_GET_OBJECT_TYPE(obj_desc) == ACPI_TYPE_PACKAGE) {
 482                 /* Translate each package element */
 483
 484                 for (i = 0; i < count; i++) {
 485                         status =
 486                             acpi_ut_translate_one_cid(obj_desc->package.
 487                                                       elements[i],
 488                                                       &cid_list->id[i]);
 489                         if (ACPI_FAILURE(status)) {
 490                                 break;
 491                         }
 492                 }
 493         } else {
 494                 /* Only one CID, translate to a string */
 495
 496                 status = acpi_ut_translate_one_cid(obj_desc, cid_list->id);
 497         }
 498
 499         /* Cleanup on error */
 500
 501         if (ACPI_FAILURE(status)) {
 502                 ACPI_MEM_FREE(cid_list);
 503         } else {
 504                 *return_cid_list = cid_list;
 505         }
 506
 507         /* On exit, we must delete the _CID return object */
 508
 509         acpi_ut_remove_reference(obj_desc);
 510         return_ACPI_STATUS(status);
 511 }
 512
 513 /*******************************************************************************
 514  *
 515  * FUNCTION:    acpi_ut_execute_UID
 516  *
 517  * PARAMETERS:  device_node         - Node for the device
 518  *              Uid                 - Where the UID is returned
 519  *
 520  * RETURN:      Status
 521  *
 522  * DESCRIPTION: Executes the _UID control method that returns the hardware
 523  *              ID of the device.
 524  *
 525  *              NOTE: Internal function, no parameter validation
 526  *
 527  ******************************************************************************/
 528
 529 acpi_status
 530 acpi_ut_execute_UID(struct acpi_namespace_node *device_node,
 531                     struct acpi_device_id *uid)
 532 {
 533         union acpi_operand_object *obj_desc;
 534         acpi_status status;
 535
 536         ACPI_FUNCTION_TRACE("ut_execute_UID");
 537
 538         status = acpi_ut_evaluate_object(device_node, METHOD_NAME__UID,
 539                                          ACPI_BTYPE_INTEGER | ACPI_BTYPE_STRING,
 540                                          &obj_desc);
 541         if (ACPI_FAILURE(status)) {
 542                 return_ACPI_STATUS(status);
 543         }
 544
 545         if (ACPI_GET_OBJECT_TYPE(obj_desc) == ACPI_TYPE_INTEGER) {
 546                 /* Convert the Numeric UID to string */
 547
 548                 acpi_ex_unsigned_integer_to_string(obj_desc->integer.value,
 549                                                    uid->value);
 550         } else {
 551                 /* Copy the String UID from the returned object */
 552
 553                 acpi_ut_copy_id_string(uid->value, obj_desc->string.pointer,
 554                                        sizeof(uid->value));
 555         }
 556
 557         /* On exit, we must delete the return object */
 558
 559         acpi_ut_remove_reference(obj_desc);
 560         return_ACPI_STATUS(status);
 561 }
 562
 563 /*******************************************************************************
 564  *
 565  * FUNCTION:    acpi_ut_execute_STA
 566  *
 567  * PARAMETERS:  device_node         - Node for the device
 568  *              Flags               - Where the status flags are returned
 569  *
 570  * RETURN:      Status
 571  *
 572  * DESCRIPTION: Executes _STA for selected device and stores results in
 573  *              *Flags.
 574  *
 575  *              NOTE: Internal function, no parameter validation
 576  *
 577  ******************************************************************************/
 578
 579 acpi_status
 580 acpi_ut_execute_STA(struct acpi_namespace_node *device_node, u32 * flags)
 581 {
 582         union acpi_operand_object *obj_desc;
 583         acpi_status status;
 584
 585         ACPI_FUNCTION_TRACE("ut_execute_STA");
 586
 587         status = acpi_ut_evaluate_object(device_node, METHOD_NAME__STA,
 588                                          ACPI_BTYPE_INTEGER, &obj_desc);
 589         if (ACPI_FAILURE(status)) {
 590                 if (AE_NOT_FOUND == status) {
 591                         ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
 592                                           "_STA on %4.4s was not found, assuming device is present\n",
 593                                           acpi_ut_get_node_name(device_node)));
 594
 595                         *flags = 0x0F;
 596                         status = AE_OK;
 597                 }
 598
 599                 return_ACPI_STATUS(status);
 600         }
 601
 602         /* Extract the status flags */
 603
 604         *flags = (u32) obj_desc->integer.value;
 605
 606         /* On exit, we must delete the return object */
 607
 608         acpi_ut_remove_reference(obj_desc);
 609         return_ACPI_STATUS(status);
 610 }
 611
 612 /*******************************************************************************
 613  *
 614  * FUNCTION:    acpi_ut_execute_Sxds
 615  *
 616  * PARAMETERS:  device_node         - Node for the device
 617  *              Flags               - Where the status flags are returned
 618  *
 619  * RETURN:      Status
 620  *
 621  * DESCRIPTION: Executes _STA for selected device and stores results in
 622  *              *Flags.
 623  *
 624  *              NOTE: Internal function, no parameter validation
 625  *
 626  ******************************************************************************/
 627
 628 acpi_status
 629 acpi_ut_execute_sxds(struct acpi_namespace_node *device_node, u8 * highest)
 630 {
 631         union acpi_operand_object *obj_desc;
 632         acpi_status status;
 633         u32 i;
 634
 635         ACPI_FUNCTION_TRACE("ut_execute_Sxds");
 636
 637         for (i = 0; i < 4; i++) {
 638                 highest[i] = 0xFF;
 639                 status = acpi_ut_evaluate_object(device_node,
 640                                                  (char *)
 641                                                  acpi_gbl_highest_dstate_names
 642                                                  [i], ACPI_BTYPE_INTEGER,
 643                                                  &obj_desc);
 644                 if (ACPI_FAILURE(status)) {
 645                         if (status != AE_NOT_FOUND) {
 646                                 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
 647                                                   "%s on Device %4.4s, %s\n",
 648                                                   (char *)
 649                                                   acpi_gbl_highest_dstate_names
 650                                                   [i],
 651                                                   acpi_ut_get_node_name
 652                                                   (device_node),
 653                                                   acpi_format_exception
 654                                                   (status)));
 655
 656                                 return_ACPI_STATUS(status);
 657                         }
 658                 } else {
 659                         /* Extract the Dstate value */
 660
 661                         highest[i] = (u8) obj_desc->integer.value;
 662
 663                         /* Delete the return object */
 664
 665                         acpi_ut_remove_reference(obj_desc);
 666                 }
 667         }
 668
 669         return_ACPI_STATUS(AE_OK);
 670 }