err.no Git - linux-2.6/blob - drivers/acpi/utilities/uteval.c

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