drivers/acpi/utilities/uteval.c

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