drivers/acpi/namespace/nspredef.c

   1 /******************************************************************************
   2  *
   3  * Module Name: nspredef - Validation of ACPI predefined methods and objects
   4  *              $Revision: 1.1 $
   5  *
   6  *****************************************************************************/
   7
   8 /*
   9  * Copyright (C) 2000 - 2008, Intel Corp.
  10  * All rights reserved.
  11  *
  12  * Redistribution and use in source and binary forms, with or without
  13  * modification, are permitted provided that the following conditions
  14  * are met:
  15  * 1. Redistributions of source code must retain the above copyright
  16  *    notice, this list of conditions, and the following disclaimer,
  17  *    without modification.
  18  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  19  *    substantially similar to the "NO WARRANTY" disclaimer below
  20  *    ("Disclaimer") and any redistribution must be conditioned upon
  21  *    including a substantially similar Disclaimer requirement for further
  22  *    binary redistribution.
  23  * 3. Neither the names of the above-listed copyright holders nor the names
  24  *    of any contributors may be used to endorse or promote products derived
  25  *    from this software without specific prior written permission.
  26  *
  27  * Alternatively, this software may be distributed under the terms of the
  28  * GNU General Public License ("GPL") version 2 as published by the Free
  29  * Software Foundation.
  30  *
  31  * NO WARRANTY
  32  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  33  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  34  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  35  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  36  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  37  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  38  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  39  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  40  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  41  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  42  * POSSIBILITY OF SUCH DAMAGES.
  43  */
  44
  45 #include <acpi/acpi.h>
  46 #include <acpi/acnamesp.h>
  47 #include <acpi/acpredef.h>
  48
  49 #define _COMPONENT          ACPI_NAMESPACE
  50 ACPI_MODULE_NAME("nspredef")
  51
  52 /*******************************************************************************
  53  *
  54  * This module validates predefined ACPI objects that appear in the namespace,
  55  * at the time they are evaluated (via acpi_evaluate_object). The purpose of this
  56  * validation is to detect problems with BIOS-exposed predefined ACPI objects
  57  * before the results are returned to the ACPI-related drivers.
  58  *
  59  * There are several areas that are validated:
  60  *
  61  *  1) The number of input arguments as defined by the method/object in the
  62  *      ASL is validated against the ACPI specification.
  63  *  2) The type of the return object (if any) is validated against the ACPI
  64  *      specification.
  65  *  3) For returned package objects, the count of package elements is
  66  *      validated, as well as the type of each package element. Nested
  67  *      packages are supported.
  68  *
  69  * For any problems found, a warning message is issued.
  70  *
  71  ******************************************************************************/
  72 /* Local prototypes */
  73 static acpi_status
  74 acpi_ns_check_package(char *pathname,
  75                       union acpi_operand_object *return_object,
  76                       const union acpi_predefined_info *predefined);
  77
  78 static acpi_status
  79 acpi_ns_check_package_elements(char *pathname,
  80                                union acpi_operand_object **elements,
  81                                u8 type1, u32 count1, u8 type2, u32 count2);
  82
  83 static acpi_status
  84 acpi_ns_check_object_type(char *pathname,
  85                           union acpi_operand_object *return_object,
  86                           u32 expected_btypes, u32 package_index);
  87
  88 static acpi_status
  89 acpi_ns_check_reference(char *pathname,
  90                         union acpi_operand_object *return_object);
  91
  92 /*
  93  * Names for the types that can be returned by the predefined objects.
  94  * Used for warning messages. Must be in the same order as the ACPI_RTYPEs
  95  */
  96 static const char *acpi_rtype_names[] = {
  97         "/Integer",
  98         "/String",
  99         "/Buffer",
 100         "/Package",
 101         "/Reference",
 102 };
 103
 104 #define ACPI_NOT_PACKAGE    ACPI_UINT32_MAX
 105
 106 /*******************************************************************************
 107  *
 108  * FUNCTION:    acpi_ns_check_predefined_names
 109  *
 110  * PARAMETERS:  Node            - Namespace node for the method/object
 111  *              return_object   - Object returned from the evaluation of this
 112  *                                method/object
 113  *
 114  * RETURN:      Status
 115  *
 116  * DESCRIPTION: Check an ACPI name for a match in the predefined name list.
 117  *
 118  ******************************************************************************/
 119
 120 acpi_status
 121 acpi_ns_check_predefined_names(struct acpi_namespace_node *node,
 122                                union acpi_operand_object *return_object)
 123 {
 124         acpi_status status = AE_OK;
 125         const union acpi_predefined_info *predefined;
 126         char *pathname;
 127
 128         /* Match the name for this method/object against the predefined list */
 129
 130         predefined = acpi_ns_check_for_predefined_name(node);
 131         if (!predefined) {
 132
 133                 /* Name was not one of the predefined names */
 134
 135                 return (AE_OK);
 136         }
 137
 138         /* Get the full pathname to the object, for use in error messages */
 139
 140         pathname = acpi_ns_get_external_pathname(node);
 141         if (!pathname) {
 142                 pathname = ACPI_CAST_PTR(char, predefined->info.name);
 143         }
 144
 145         /*
 146          * Check that the parameter count for this method is in accordance
 147          * with the ACPI specification.
 148          */
 149         acpi_ns_check_parameter_count(pathname, node, predefined);
 150
 151         /*
 152          * If there is no return value, check if we require a return value for
 153          * this predefined name. Either one return value is expected, or none,
 154          * for both methods and other objects.
 155          *
 156          * Exit now if there is no return object. Warning if one was expected.
 157          */
 158         if (!return_object) {
 159                 if ((predefined->info.expected_btypes) &&
 160                     (!(predefined->info.expected_btypes & ACPI_RTYPE_NONE))) {
 161                         ACPI_ERROR((AE_INFO,
 162                                     "%s: Missing expected return value",
 163                                     pathname));
 164
 165                         status = AE_AML_NO_RETURN_VALUE;
 166                 }
 167                 goto exit;
 168         }
 169
 170         /*
 171          * We have a return value, but if one wasn't expected, just exit, this is
 172          * not a problem
 173          *
 174          * For example, if "Implicit return value" is enabled, methods will
 175          * always return a value
 176          */
 177         if (!predefined->info.expected_btypes) {
 178                 goto exit;
 179         }
 180
 181         /*
 182          * Check that the type of the return object is what is expected for
 183          * this predefined name
 184          */
 185         status = acpi_ns_check_object_type(pathname, return_object,
 186                                            predefined->info.expected_btypes,
 187                                            ACPI_NOT_PACKAGE);
 188         if (ACPI_FAILURE(status)) {
 189                 goto exit;
 190         }
 191
 192         /* For returned Package objects, check the type of all sub-objects */
 193
 194         if (ACPI_GET_OBJECT_TYPE(return_object) == ACPI_TYPE_PACKAGE) {
 195                 status =
 196                     acpi_ns_check_package(pathname, return_object, predefined);
 197         }
 198
 199       exit:
 200         if (pathname) {
 201                 ACPI_FREE(pathname);
 202         }
 203
 204         return (status);
 205 }
 206
 207 /*******************************************************************************
 208  *
 209  * FUNCTION:    acpi_ns_check_parameter_count
 210  *
 211  * PARAMETERS:  Pathname        - Full pathname to the node (for error msgs)
 212  *              Node            - Namespace node for the method/object
 213  *              Predefined      - Pointer to entry in predefined name table
 214  *
 215  * RETURN:      None
 216  *
 217  * DESCRIPTION: Check that the declared (in ASL/AML) parameter count for a
 218  *              predefined name is what is expected (i.e., what is defined in
 219  *              the ACPI specification for this predefined name.)
 220  *
 221  ******************************************************************************/
 222
 223 void
 224 acpi_ns_check_parameter_count(char *pathname,
 225                               struct acpi_namespace_node *node,
 226                               const union acpi_predefined_info *predefined)
 227 {
 228         u32 param_count;
 229         u32 required_params_current;
 230         u32 required_params_old;
 231
 232         /*
 233          * Check that the ASL-defined parameter count is what is expected for
 234          * this predefined name.
 235          *
 236          * Methods have 0-7 parameters. All other types have zero.
 237          */
 238         param_count = 0;
 239         if (node->type == ACPI_TYPE_METHOD) {
 240                 param_count = node->object->method.param_count;
 241         }
 242
 243         /* Validate parameter count - allow two different legal counts (_SCP) */
 244
 245         required_params_current = predefined->info.param_count & 0x0F;
 246         required_params_old = predefined->info.param_count >> 4;
 247
 248         if ((param_count != required_params_current) &&
 249             (param_count != required_params_old)) {
 250                 ACPI_WARNING((AE_INFO,
 251                               "%s: Parameter count mismatch - ASL declared %d, expected %d",
 252                               pathname, param_count, required_params_current));
 253         }
 254 }
 255
 256 /*******************************************************************************
 257  *
 258  * FUNCTION:    acpi_ns_check_for_predefined_name
 259  *
 260  * PARAMETERS:  Node            - Namespace node for the method/object
 261  *
 262  * RETURN:      Pointer to entry in predefined table. NULL indicates not found.
 263  *
 264  * DESCRIPTION: Check an object name against the predefined object list.
 265  *
 266  ******************************************************************************/
 267
 268 const union acpi_predefined_info *acpi_ns_check_for_predefined_name(struct
 269                                                                     acpi_namespace_node
 270                                                                     *node)
 271 {
 272         const union acpi_predefined_info *this_name;
 273
 274         /* Quick check for a predefined name, first character must be underscore */
 275
 276         if (node->name.ascii[0] != '_') {
 277                 return (NULL);
 278         }
 279
 280         /* Search info table for a predefined method/object name */
 281
 282         this_name = predefined_names;
 283         while (this_name->info.name[0]) {
 284                 if (ACPI_COMPARE_NAME(node->name.ascii, this_name->info.name)) {
 285
 286                         /* Return pointer to this table entry */
 287
 288                         return (this_name);
 289                 }
 290
 291                 /*
 292                  * Skip next entry in the table if this name returns a Package
 293                  * (next entry contains the package info)
 294                  */
 295                 if (this_name->info.expected_btypes & ACPI_RTYPE_PACKAGE) {
 296                         this_name++;
 297                 }
 298
 299                 this_name++;
 300         }
 301
 302         return (NULL);
 303 }
 304
 305 /*******************************************************************************
 306  *
 307  * FUNCTION:    acpi_ns_check_package
 308  *
 309  * PARAMETERS:  Pathname        - Full pathname to the node (for error msgs)
 310  *              return_object   - Object returned from the evaluation of a
 311  *                                method or object
 312  *              Predefined      - Pointer to entry in predefined name table
 313  *
 314  * RETURN:      Status
 315  *
 316  * DESCRIPTION: Check a returned package object for the correct count and
 317  *              correct type of all sub-objects.
 318  *
 319  ******************************************************************************/
 320
 321 static acpi_status
 322 acpi_ns_check_package(char *pathname,
 323                       union acpi_operand_object *return_object,
 324                       const union acpi_predefined_info *predefined)
 325 {
 326         const union acpi_predefined_info *package;
 327         union acpi_operand_object *sub_package;
 328         union acpi_operand_object **elements;
 329         union acpi_operand_object **sub_elements;
 330         acpi_status status;
 331         u32 expected_count;
 332         u32 count;
 333         u32 i;
 334         u32 j;
 335
 336         ACPI_FUNCTION_NAME(ns_check_package);
 337
 338         /* The package info for this name is in the next table entry */
 339
 340         package = predefined + 1;
 341
 342         ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
 343                           "%s Validating return Package of Type %X, Count %X\n",
 344                           pathname, package->ret_info.type,
 345                           return_object->package.count));
 346
 347         /* Extract package count and elements array */
 348
 349         elements = return_object->package.elements;
 350         count = return_object->package.count;
 351
 352         /* The package must have at least one element, else invalid */
 353
 354         if (!count) {
 355                 ACPI_WARNING((AE_INFO,
 356                               "%s: Return Package has no elements (empty)",
 357                               pathname));
 358
 359                 return (AE_AML_OPERAND_VALUE);
 360         }
 361
 362         /*
 363          * Decode the type of the expected package contents
 364          *
 365          * PTYPE1 packages contain no subpackages
 366          * PTYPE2 packages contain sub-packages
 367          */
 368         switch (package->ret_info.type) {
 369         case ACPI_PTYPE1_FIXED:
 370
 371                 /*
 372                  * The package count is fixed and there are no sub-packages
 373                  *
 374                  * If package is too small, exit.
 375                  * If package is larger than expected, issue warning but continue
 376                  */
 377                 expected_count =
 378                     package->ret_info.count1 + package->ret_info.count2;
 379                 if (count < expected_count) {
 380                         goto package_too_small;
 381                 } else if (count > expected_count) {
 382                         ACPI_WARNING((AE_INFO,
 383                                       "%s: Return Package is larger than needed - "
 384                                       "found %u, expected %u", pathname, count,
 385                                       expected_count));
 386                 }
 387
 388                 /* Validate all elements of the returned package */
 389
 390                 status = acpi_ns_check_package_elements(pathname, elements,
 391                                                         package->ret_info.
 392                                                         object_type1,
 393                                                         package->ret_info.
 394                                                         count1,
 395                                                         package->ret_info.
 396                                                         object_type2,
 397                                                         package->ret_info.
 398                                                         count2);
 399                 if (ACPI_FAILURE(status)) {
 400                         return (status);
 401                 }
 402                 break;
 403
 404         case ACPI_PTYPE1_VAR:
 405
 406                 /*
 407                  * The package count is variable, there are no sub-packages, and all
 408                  * elements must be of the same type
 409                  */
 410                 for (i = 0; i < count; i++) {
 411                         status = acpi_ns_check_object_type(pathname, *elements,
 412                                                            package->ret_info.
 413                                                            object_type1, i);
 414                         if (ACPI_FAILURE(status)) {
 415                                 return (status);
 416                         }
 417                         elements++;
 418                 }
 419                 break;
 420
 421         case ACPI_PTYPE1_OPTION:
 422
 423                 /*
 424                  * The package count is variable, there are no sub-packages. There are
 425                  * a fixed number of required elements, and a variable number of
 426                  * optional elements.
 427                  *
 428                  * Check if package is at least as large as the minimum required
 429                  */
 430                 expected_count = package->ret_info3.count;
 431                 if (count < expected_count) {
 432                         goto package_too_small;
 433                 }
 434
 435                 /* Variable number of sub-objects */
 436
 437                 for (i = 0; i < count; i++) {
 438                         if (i < package->ret_info3.count) {
 439
 440                                 /* These are the required package elements (0, 1, or 2) */
 441
 442                                 status =
 443                                     acpi_ns_check_object_type(pathname,
 444                                                               *elements,
 445                                                               package->
 446                                                               ret_info3.
 447                                                               object_type[i],
 448                                                               i);
 449                                 if (ACPI_FAILURE(status)) {
 450                                         return (status);
 451                                 }
 452                         } else {
 453                                 /* These are the optional package elements */
 454
 455                                 status =
 456                                     acpi_ns_check_object_type(pathname,
 457                                                               *elements,
 458                                                               package->
 459                                                               ret_info3.
 460                                                               tail_object_type,
 461                                                               i);
 462                                 if (ACPI_FAILURE(status)) {
 463                                         return (status);
 464                                 }
 465                         }
 466                         elements++;
 467                 }
 468                 break;
 469
 470         case ACPI_PTYPE2_PKG_COUNT:
 471
 472                 /* First element is the (Integer) count of sub-packages to follow */
 473
 474                 status = acpi_ns_check_object_type(pathname, *elements,
 475                                                    ACPI_RTYPE_INTEGER, 0);
 476                 if (ACPI_FAILURE(status)) {
 477                         return (status);
 478                 }
 479
 480                 /*
 481                  * Count cannot be larger than the parent package length, but allow it
 482                  * to be smaller. The >= accounts for the Integer above.
 483                  */
 484                 expected_count = (u32) (*elements)->integer.value;
 485                 if (expected_count >= count) {
 486                         goto package_too_small;
 487                 }
 488
 489                 count = expected_count;
 490                 elements++;
 491
 492                 /* Now we can walk the sub-packages */
 493
 494                 /*lint -fallthrough */
 495
 496         case ACPI_PTYPE2:
 497         case ACPI_PTYPE2_FIXED:
 498         case ACPI_PTYPE2_MIN:
 499         case ACPI_PTYPE2_COUNT:
 500
 501                 /*
 502                  * These types all return a single package that consists of a variable
 503                  * number of sub-packages
 504                  */
 505                 for (i = 0; i < count; i++) {
 506                         sub_package = *elements;
 507                         sub_elements = sub_package->package.elements;
 508
 509                         /* Each sub-object must be of type Package */
 510
 511                         status =
 512                             acpi_ns_check_object_type(pathname, sub_package,
 513                                                       ACPI_RTYPE_PACKAGE, i);
 514                         if (ACPI_FAILURE(status)) {
 515                                 return (status);
 516                         }
 517
 518                         /* Examine the different types of sub-packages */
 519
 520                         switch (package->ret_info.type) {
 521                         case ACPI_PTYPE2:
 522                         case ACPI_PTYPE2_PKG_COUNT:
 523
 524                                 /* Each subpackage has a fixed number of elements */
 525
 526                                 expected_count =
 527                                     package->ret_info.count1 +
 528                                     package->ret_info.count2;
 529                                 if (sub_package->package.count !=
 530                                     expected_count) {
 531                                         count = sub_package->package.count;
 532                                         goto package_too_small;
 533                                 }
 534
 535                                 status =
 536                                     acpi_ns_check_package_elements(pathname,
 537                                                                    sub_elements,
 538                                                                    package->
 539                                                                    ret_info.
 540                                                                    object_type1,
 541                                                                    package->
 542                                                                    ret_info.
 543                                                                    count1,
 544                                                                    package->
 545                                                                    ret_info.
 546                                                                    object_type2,
 547                                                                    package->
 548                                                                    ret_info.
 549                                                                    count2);
 550                                 if (ACPI_FAILURE(status)) {
 551                                         return (status);
 552                                 }
 553                                 break;
 554
 555                         case ACPI_PTYPE2_FIXED:
 556
 557                                 /* Each sub-package has a fixed length */
 558
 559                                 expected_count = package->ret_info2.count;
 560                                 if (sub_package->package.count < expected_count) {
 561                                         count = sub_package->package.count;
 562                                         goto package_too_small;
 563                                 }
 564
 565                                 /* Check the type of each sub-package element */
 566
 567                                 for (j = 0; j < expected_count; j++) {
 568                                         status =
 569                                             acpi_ns_check_object_type(pathname,
 570                                                                       sub_elements
 571                                                                       [j],
 572                                                                       package->
 573                                                                       ret_info2.
 574                                                                       object_type
 575                                                                       [j], j);
 576                                         if (ACPI_FAILURE(status)) {
 577                                                 return (status);
 578                                         }
 579                                 }
 580                                 break;
 581
 582                         case ACPI_PTYPE2_MIN:
 583
 584                                 /* Each sub-package has a variable but minimum length */
 585
 586                                 expected_count = package->ret_info.count1;
 587                                 if (sub_package->package.count < expected_count) {
 588                                         count = sub_package->package.count;
 589                                         goto package_too_small;
 590                                 }
 591
 592                                 /* Check the type of each sub-package element */
 593
 594                                 status =
 595                                     acpi_ns_check_package_elements(pathname,
 596                                                                    sub_elements,
 597                                                                    package->
 598                                                                    ret_info.
 599                                                                    object_type1,
 600                                                                    sub_package->
 601                                                                    package.
 602                                                                    count, 0, 0);
 603                                 if (ACPI_FAILURE(status)) {
 604                                         return (status);
 605                                 }
 606                                 break;
 607
 608                         case ACPI_PTYPE2_COUNT:
 609
 610                                 /* First element is the (Integer) count of elements to follow */
 611
 612                                 status =
 613                                     acpi_ns_check_object_type(pathname,
 614                                                               *sub_elements,
 615                                                               ACPI_RTYPE_INTEGER,
 616                                                               0);
 617                                 if (ACPI_FAILURE(status)) {
 618                                         return (status);
 619                                 }
 620
 621                                 /* Make sure package is large enough for the Count */
 622
 623                                 expected_count =
 624                                     (u32) (*sub_elements)->integer.value;
 625                                 if (sub_package->package.count < expected_count) {
 626                                         count = sub_package->package.count;
 627                                         goto package_too_small;
 628                                 }
 629
 630                                 /* Check the type of each sub-package element */
 631
 632                                 status =
 633                                     acpi_ns_check_package_elements(pathname,
 634                                                                    (sub_elements
 635                                                                     + 1),
 636                                                                    package->
 637                                                                    ret_info.
 638                                                                    object_type1,
 639                                                                    (expected_count
 640                                                                     - 1), 0, 0);
 641                                 if (ACPI_FAILURE(status)) {
 642                                         return (status);
 643                                 }
 644                                 break;
 645
 646                         default:
 647                                 break;
 648                         }
 649
 650                         elements++;
 651                 }
 652                 break;
 653
 654         default:
 655
 656                 /* Should not get here if predefined info table is correct */
 657
 658                 ACPI_WARNING((AE_INFO,
 659                               "%s: Invalid internal return type in table entry: %X",
 660                               pathname, package->ret_info.type));
 661
 662                 return (AE_AML_INTERNAL);
 663         }
 664
 665         return (AE_OK);
 666
 667       package_too_small:
 668
 669         /* Error exit for the case with an incorrect package count */
 670
 671         ACPI_WARNING((AE_INFO, "%s: Return Package is too small - "
 672                       "found %u, expected %u", pathname, count,
 673                       expected_count));
 674
 675         return (AE_AML_OPERAND_VALUE);
 676 }
 677
 678 /*******************************************************************************
 679  *
 680  * FUNCTION:    acpi_ns_check_package_elements
 681  *
 682  * PARAMETERS:  Pathname        - Full pathname to the node (for error msgs)
 683  *              Elements        - Pointer to the package elements array
 684  *              Type1           - Object type for first group
 685  *              Count1          - Count for first group
 686  *              Type2           - Object type for second group
 687  *              Count2          - Count for second group
 688  *
 689  * RETURN:      Status
 690  *
 691  * DESCRIPTION: Check that all elements of a package are of the correct object
 692  *              type. Supports up to two groups of different object types.
 693  *
 694  ******************************************************************************/
 695
 696 static acpi_status
 697 acpi_ns_check_package_elements(char *pathname,
 698                                union acpi_operand_object **elements,
 699                                u8 type1, u32 count1, u8 type2, u32 count2)
 700 {
 701         union acpi_operand_object **this_element = elements;
 702         acpi_status status;
 703         u32 i;
 704
 705         /*
 706          * Up to two groups of package elements are supported by the data
 707          * structure. All elements in each group must be of the same type.
 708          * The second group can have a count of zero.
 709          */
 710         for (i = 0; i < count1; i++) {
 711                 status = acpi_ns_check_object_type(pathname, *this_element,
 712                                                    type1, i);
 713                 if (ACPI_FAILURE(status)) {
 714                         return (status);
 715                 }
 716                 this_element++;
 717         }
 718
 719         for (i = 0; i < count2; i++) {
 720                 status = acpi_ns_check_object_type(pathname, *this_element,
 721                                                    type2, (i + count1));
 722                 if (ACPI_FAILURE(status)) {
 723                         return (status);
 724                 }
 725                 this_element++;
 726         }
 727
 728         return (AE_OK);
 729 }
 730
 731 /*******************************************************************************
 732  *
 733  * FUNCTION:    acpi_ns_check_object_type
 734  *
 735  * PARAMETERS:  Pathname        - Full pathname to the node (for error msgs)
 736  *              return_object   - Object return from the execution of this
 737  *                                method/object
 738  *              expected_btypes - Bitmap of expected return type(s)
 739  *              package_index   - Index of object within parent package (if
 740  *                                applicable - ACPI_NOT_PACKAGE otherwise)
 741  *
 742  * RETURN:      Status
 743  *
 744  * DESCRIPTION: Check the type of the return object against the expected object
 745  *              type(s). Use of Btype allows multiple expected object types.
 746  *
 747  ******************************************************************************/
 748
 749 static acpi_status
 750 acpi_ns_check_object_type(char *pathname,
 751                           union acpi_operand_object *return_object,
 752                           u32 expected_btypes, u32 package_index)
 753 {
 754         acpi_status status = AE_OK;
 755         u32 return_btype;
 756         char type_buffer[48];   /* Room for 5 types */
 757         u32 this_rtype;
 758         u32 i;
 759         u32 j;
 760
 761         /*
 762          * If we get a NULL return_object here, it is a NULL package element,
 763          * and this is always an error.
 764          */
 765         if (!return_object) {
 766                 goto type_error_exit;
 767         }
 768
 769         /* A Namespace node should not get here, but make sure */
 770
 771         if (ACPI_GET_DESCRIPTOR_TYPE(return_object) == ACPI_DESC_TYPE_NAMED) {
 772                 ACPI_WARNING((AE_INFO,
 773                               "%s: Invalid return type - Found a Namespace node [%4.4s] type %s",
 774                               pathname, return_object->node.name.ascii,
 775                               acpi_ut_get_type_name(return_object->node.type)));
 776                 return (AE_AML_OPERAND_TYPE);
 777         }
 778
 779         /*
 780          * Convert the object type (ACPI_TYPE_xxx) to a bitmapped object type.
 781          * The bitmapped type allows multiple possible return types.
 782          *
 783          * Note, the cases below must handle all of the possible types returned
 784          * from all of the predefined names (including elements of returned
 785          * packages)
 786          */
 787         switch (ACPI_GET_OBJECT_TYPE(return_object)) {
 788         case ACPI_TYPE_INTEGER:
 789                 return_btype = ACPI_RTYPE_INTEGER;
 790                 break;
 791
 792         case ACPI_TYPE_BUFFER:
 793                 return_btype = ACPI_RTYPE_BUFFER;
 794                 break;
 795
 796         case ACPI_TYPE_STRING:
 797                 return_btype = ACPI_RTYPE_STRING;
 798                 break;
 799
 800         case ACPI_TYPE_PACKAGE:
 801                 return_btype = ACPI_RTYPE_PACKAGE;
 802                 break;
 803
 804         case ACPI_TYPE_LOCAL_REFERENCE:
 805                 return_btype = ACPI_RTYPE_REFERENCE;
 806                 break;
 807
 808         default:
 809                 /* Not one of the supported objects, must be incorrect */
 810
 811                 goto type_error_exit;
 812         }
 813
 814         /* Is the object one of the expected types? */
 815
 816         if (!(return_btype & expected_btypes)) {
 817                 goto type_error_exit;
 818         }
 819
 820         /* For reference objects, check that the reference type is correct */
 821
 822         if (ACPI_GET_OBJECT_TYPE(return_object) == ACPI_TYPE_LOCAL_REFERENCE) {
 823                 status = acpi_ns_check_reference(pathname, return_object);
 824         }
 825
 826         return (status);
 827
 828       type_error_exit:
 829
 830         /* Create a string with all expected types for this predefined object */
 831
 832         j = 1;
 833         type_buffer[0] = 0;
 834         this_rtype = ACPI_RTYPE_INTEGER;
 835
 836         for (i = 0; i < ACPI_NUM_RTYPES; i++) {
 837
 838                 /* If one of the expected types, concatenate the name of this type */
 839
 840                 if (expected_btypes & this_rtype) {
 841                         ACPI_STRCAT(type_buffer, &acpi_rtype_names[i][j]);
 842                         j = 0;  /* Use name separator from now on */
 843                 }
 844                 this_rtype <<= 1;       /* Next Rtype */
 845         }
 846
 847         if (package_index == ACPI_NOT_PACKAGE) {
 848                 ACPI_WARNING((AE_INFO,
 849                               "%s: Return type mismatch - found %s, expected %s",
 850                               pathname,
 851                               acpi_ut_get_object_type_name(return_object),
 852                               type_buffer));
 853         } else {
 854                 ACPI_WARNING((AE_INFO,
 855                               "%s: Return Package type mismatch at index %u - "
 856                               "found %s, expected %s", pathname, package_index,
 857                               acpi_ut_get_object_type_name(return_object),
 858                               type_buffer));
 859         }
 860
 861         return (AE_AML_OPERAND_TYPE);
 862 }
 863
 864 /*******************************************************************************
 865  *
 866  * FUNCTION:    acpi_ns_check_reference
 867  *
 868  * PARAMETERS:  Pathname        - Full pathname to the node (for error msgs)
 869  *              return_object   - Object returned from the evaluation of a
 870  *                                method or object
 871  *
 872  * RETURN:      Status
 873  *
 874  * DESCRIPTION: Check a returned reference object for the correct reference
 875  *              type. The only reference type that can be returned from a
 876  *              predefined method is a named reference. All others are invalid.
 877  *
 878  ******************************************************************************/
 879
 880 static acpi_status
 881 acpi_ns_check_reference(char *pathname,
 882                         union acpi_operand_object *return_object)
 883 {
 884
 885         /*
 886          * Check the reference object for the correct reference type (opcode).
 887          * The only type of reference that can be converted to an union acpi_object is
 888          * a reference to a named object (reference class: NAME)
 889          */
 890         if (return_object->reference.class == ACPI_REFCLASS_NAME) {
 891                 return (AE_OK);
 892         }
 893
 894         ACPI_WARNING((AE_INFO,
 895                       "%s: Return type mismatch - unexpected reference object type [%s] %2.2X",
 896                       pathname, acpi_ut_get_reference_name(return_object),
 897                       return_object->reference.class));
 898
 899         return (AE_AML_OPERAND_TYPE);
 900 }