drivers/acpi/acpica/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 #define ACPI_CREATE_PREDEFINED_TABLE
  46
  47 #include <acpi/acpi.h>
  48 #include "accommon.h"
  49 #include "acnamesp.h"
  50 #include "acpredef.h"
  51
  52 #define _COMPONENT          ACPI_NAMESPACE
  53 ACPI_MODULE_NAME("nspredef")
  54
  55 /*******************************************************************************
  56  *
  57  * This module validates predefined ACPI objects that appear in the namespace,
  58  * at the time they are evaluated (via acpi_evaluate_object). The purpose of this
  59  * validation is to detect problems with BIOS-exposed predefined ACPI objects
  60  * before the results are returned to the ACPI-related drivers.
  61  *
  62  * There are several areas that are validated:
  63  *
  64  *  1) The number of input arguments as defined by the method/object in the
  65  *      ASL is validated against the ACPI specification.
  66  *  2) The type of the return object (if any) is validated against the ACPI
  67  *      specification.
  68  *  3) For returned package objects, the count of package elements is
  69  *      validated, as well as the type of each package element. Nested
  70  *      packages are supported.
  71  *
  72  * For any problems found, a warning message is issued.
  73  *
  74  ******************************************************************************/
  75 /* Local prototypes */
  76 static acpi_status
  77 acpi_ns_check_package(struct acpi_predefined_data *data,
  78                       union acpi_operand_object **return_object_ptr);
  79
  80 static acpi_status
  81 acpi_ns_check_package_list(struct acpi_predefined_data *data,
  82                            const union acpi_predefined_info *package,
  83                            union acpi_operand_object **elements, u32 count);
  84
  85 static acpi_status
  86 acpi_ns_check_package_elements(struct acpi_predefined_data *data,
  87                                union acpi_operand_object **elements,
  88                                u8 type1,
  89                                u32 count1,
  90                                u8 type2, u32 count2, u32 start_index);
  91
  92 static acpi_status
  93 acpi_ns_check_object_type(struct acpi_predefined_data *data,
  94                           union acpi_operand_object **return_object_ptr,
  95                           u32 expected_btypes, u32 package_index);
  96
  97 static acpi_status
  98 acpi_ns_check_reference(struct acpi_predefined_data *data,
  99                         union acpi_operand_object *return_object);
 100
 101 static void acpi_ns_get_expected_types(char *buffer, u32 expected_btypes);
 102
 103 /*
 104  * Names for the types that can be returned by the predefined objects.
 105  * Used for warning messages. Must be in the same order as the ACPI_RTYPEs
 106  */
 107 static const char *acpi_rtype_names[] = {
 108         "/Integer",
 109         "/String",
 110         "/Buffer",
 111         "/Package",
 112         "/Reference",
 113 };
 114
 115 /*******************************************************************************
 116  *
 117  * FUNCTION:    acpi_ns_check_predefined_names
 118  *
 119  * PARAMETERS:  Node            - Namespace node for the method/object
 120  *              user_param_count - Number of parameters actually passed
 121  *              return_status   - Status from the object evaluation
 122  *              return_object_ptr - Pointer to the object returned from the
 123  *                                evaluation of a method or object
 124  *
 125  * RETURN:      Status
 126  *
 127  * DESCRIPTION: Check an ACPI name for a match in the predefined name list.
 128  *
 129  ******************************************************************************/
 130
 131 acpi_status
 132 acpi_ns_check_predefined_names(struct acpi_namespace_node *node,
 133                                u32 user_param_count,
 134                                acpi_status return_status,
 135                                union acpi_operand_object **return_object_ptr)
 136 {
 137         union acpi_operand_object *return_object = *return_object_ptr;
 138         acpi_status status = AE_OK;
 139         const union acpi_predefined_info *predefined;
 140         char *pathname;
 141         struct acpi_predefined_data *data;
 142
 143         /* Match the name for this method/object against the predefined list */
 144
 145         predefined = acpi_ns_check_for_predefined_name(node);
 146
 147         /* Get the full pathname to the object, for use in warning messages */
 148
 149         pathname = acpi_ns_get_external_pathname(node);
 150         if (!pathname) {
 151                 return AE_OK;   /* Could not get pathname, ignore */
 152         }
 153
 154         /*
 155          * Check that the parameter count for this method matches the ASL
 156          * definition. For predefined names, ensure that both the caller and
 157          * the method itself are in accordance with the ACPI specification.
 158          */
 159         acpi_ns_check_parameter_count(pathname, node, user_param_count,
 160                                       predefined);
 161
 162         /* If not a predefined name, we cannot validate the return object */
 163
 164         if (!predefined) {
 165                 goto cleanup;
 166         }
 167
 168         /*
 169          * If the method failed or did not actually return an object, we cannot
 170          * validate the return object
 171          */
 172         if ((return_status != AE_OK) && (return_status != AE_CTRL_RETURN_VALUE)) {
 173                 goto cleanup;
 174         }
 175
 176         /*
 177          * If there is no return value, check if we require a return value for
 178          * this predefined name. Either one return value is expected, or none,
 179          * for both methods and other objects.
 180          *
 181          * Exit now if there is no return object. Warning if one was expected.
 182          */
 183         if (!return_object) {
 184                 if ((predefined->info.expected_btypes) &&
 185                     (!(predefined->info.expected_btypes & ACPI_RTYPE_NONE))) {
 186                         ACPI_WARN_PREDEFINED((AE_INFO, pathname,
 187                                               ACPI_WARN_ALWAYS,
 188                                               "Missing expected return value"));
 189
 190                         status = AE_AML_NO_RETURN_VALUE;
 191                 }
 192                 goto cleanup;
 193         }
 194
 195         /*
 196          * 1) We have a return value, but if one wasn't expected, just exit, this is
 197          * not a problem. For example, if the "Implicit Return" feature is
 198          * enabled, methods will always return a value.
 199          *
 200          * 2) If the return value can be of any type, then we cannot perform any
 201          * validation, exit.
 202          */
 203         if ((!predefined->info.expected_btypes) ||
 204             (predefined->info.expected_btypes == ACPI_RTYPE_ALL)) {
 205                 goto cleanup;
 206         }
 207
 208         /* Create the parameter data block for object validation */
 209
 210         data = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_predefined_data));
 211         if (!data) {
 212                 goto cleanup;
 213         }
 214         data->predefined = predefined;
 215         data->node_flags = node->flags;
 216         data->pathname = pathname;
 217
 218         /*
 219          * Check that the type of the return object is what is expected for
 220          * this predefined name
 221          */
 222         status = acpi_ns_check_object_type(data, return_object_ptr,
 223                                            predefined->info.expected_btypes,
 224                                            ACPI_NOT_PACKAGE_ELEMENT);
 225         if (ACPI_FAILURE(status)) {
 226                 goto check_validation_status;
 227         }
 228
 229         /* For returned Package objects, check the type of all sub-objects */
 230
 231         if (return_object->common.type == ACPI_TYPE_PACKAGE) {
 232                 status = acpi_ns_check_package(data, return_object_ptr);
 233         }
 234
 235 check_validation_status:
 236         /*
 237          * If the object validation failed or if we successfully repaired one
 238          * or more objects, mark the parent node to suppress further warning
 239          * messages during the next evaluation of the same method/object.
 240          */
 241         if (ACPI_FAILURE(status) || (data->flags & ACPI_OBJECT_REPAIRED)) {
 242                 node->flags |= ANOBJ_EVALUATED;
 243         }
 244         ACPI_FREE(data);
 245
 246 cleanup:
 247         ACPI_FREE(pathname);
 248         return (status);
 249 }
 250
 251 /*******************************************************************************
 252  *
 253  * FUNCTION:    acpi_ns_check_parameter_count
 254  *
 255  * PARAMETERS:  Pathname        - Full pathname to the node (for error msgs)
 256  *              Node            - Namespace node for the method/object
 257  *              user_param_count - Number of args passed in by the caller
 258  *              Predefined      - Pointer to entry in predefined name table
 259  *
 260  * RETURN:      None
 261  *
 262  * DESCRIPTION: Check that the declared (in ASL/AML) parameter count for a
 263  *              predefined name is what is expected (i.e., what is defined in
 264  *              the ACPI specification for this predefined name.)
 265  *
 266  ******************************************************************************/
 267
 268 void
 269 acpi_ns_check_parameter_count(char *pathname,
 270                               struct acpi_namespace_node *node,
 271                               u32 user_param_count,
 272                               const union acpi_predefined_info *predefined)
 273 {
 274         u32 param_count;
 275         u32 required_params_current;
 276         u32 required_params_old;
 277
 278         /* Methods have 0-7 parameters. All other types have zero. */
 279
 280         param_count = 0;
 281         if (node->type == ACPI_TYPE_METHOD) {
 282                 param_count = node->object->method.param_count;
 283         }
 284
 285         if (!predefined) {
 286                 /*
 287                  * Check the parameter count for non-predefined methods/objects.
 288                  *
 289                  * Warning if too few or too many arguments have been passed by the
 290                  * caller. An incorrect number of arguments may not cause the method
 291                  * to fail. However, the method will fail if there are too few
 292                  * arguments and the method attempts to use one of the missing ones.
 293                  */
 294                 if (user_param_count < param_count) {
 295                         ACPI_WARN_PREDEFINED((AE_INFO, pathname,
 296                                               ACPI_WARN_ALWAYS,
 297                                               "Insufficient arguments - needs %u, found %u",
 298                                               param_count, user_param_count));
 299                 } else if (user_param_count > param_count) {
 300                         ACPI_WARN_PREDEFINED((AE_INFO, pathname,
 301                                               ACPI_WARN_ALWAYS,
 302                                               "Excess arguments - needs %u, found %u",
 303                                               param_count, user_param_count));
 304                 }
 305                 return;
 306         }
 307
 308         /*
 309          * Validate the user-supplied parameter count.
 310          * Allow two different legal argument counts (_SCP, etc.)
 311          */
 312         required_params_current = predefined->info.param_count & 0x0F;
 313         required_params_old = predefined->info.param_count >> 4;
 314
 315         if (user_param_count != ACPI_UINT32_MAX) {
 316                 if ((user_param_count != required_params_current) &&
 317                     (user_param_count != required_params_old)) {
 318                         ACPI_WARN_PREDEFINED((AE_INFO, pathname,
 319                                               ACPI_WARN_ALWAYS,
 320                                               "Parameter count mismatch - "
 321                                               "caller passed %u, ACPI requires %u",
 322                                               user_param_count,
 323                                               required_params_current));
 324                 }
 325         }
 326
 327         /*
 328          * Check that the ASL-defined parameter count is what is expected for
 329          * this predefined name (parameter count as defined by the ACPI
 330          * specification)
 331          */
 332         if ((param_count != required_params_current) &&
 333             (param_count != required_params_old)) {
 334                 ACPI_WARN_PREDEFINED((AE_INFO, pathname, node->flags,
 335                                       "Parameter count mismatch - ASL declared %u, ACPI requires %u",
 336                                       param_count, required_params_current));
 337         }
 338 }
 339
 340 /*******************************************************************************
 341  *
 342  * FUNCTION:    acpi_ns_check_for_predefined_name
 343  *
 344  * PARAMETERS:  Node            - Namespace node for the method/object
 345  *
 346  * RETURN:      Pointer to entry in predefined table. NULL indicates not found.
 347  *
 348  * DESCRIPTION: Check an object name against the predefined object list.
 349  *
 350  ******************************************************************************/
 351
 352 const union acpi_predefined_info *acpi_ns_check_for_predefined_name(struct
 353                                                                     acpi_namespace_node
 354                                                                     *node)
 355 {
 356         const union acpi_predefined_info *this_name;
 357
 358         /* Quick check for a predefined name, first character must be underscore */
 359
 360         if (node->name.ascii[0] != '_') {
 361                 return (NULL);
 362         }
 363
 364         /* Search info table for a predefined method/object name */
 365
 366         this_name = predefined_names;
 367         while (this_name->info.name[0]) {
 368                 if (ACPI_COMPARE_NAME(node->name.ascii, this_name->info.name)) {
 369                         return (this_name);
 370                 }
 371
 372                 /*
 373                  * Skip next entry in the table if this name returns a Package
 374                  * (next entry contains the package info)
 375                  */
 376                 if (this_name->info.expected_btypes & ACPI_RTYPE_PACKAGE) {
 377                         this_name++;
 378                 }
 379
 380                 this_name++;
 381         }
 382
 383         return (NULL);          /* Not found */
 384 }
 385
 386 /*******************************************************************************
 387  *
 388  * FUNCTION:    acpi_ns_check_package
 389  *
 390  * PARAMETERS:  Data            - Pointer to validation data structure
 391  *              return_object_ptr - Pointer to the object returned from the
 392  *                                evaluation of a method or object
 393  *
 394  * RETURN:      Status
 395  *
 396  * DESCRIPTION: Check a returned package object for the correct count and
 397  *              correct type of all sub-objects.
 398  *
 399  ******************************************************************************/
 400
 401 static acpi_status
 402 acpi_ns_check_package(struct acpi_predefined_data *data,
 403                       union acpi_operand_object **return_object_ptr)
 404 {
 405         union acpi_operand_object *return_object = *return_object_ptr;
 406         const union acpi_predefined_info *package;
 407         union acpi_operand_object **elements;
 408         acpi_status status = AE_OK;
 409         u32 expected_count;
 410         u32 count;
 411         u32 i;
 412
 413         ACPI_FUNCTION_NAME(ns_check_package);
 414
 415         /* The package info for this name is in the next table entry */
 416
 417         package = data->predefined + 1;
 418
 419         ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
 420                           "%s Validating return Package of Type %X, Count %X\n",
 421                           data->pathname, package->ret_info.type,
 422                           return_object->package.count));
 423
 424         /* Extract package count and elements array */
 425
 426         elements = return_object->package.elements;
 427         count = return_object->package.count;
 428
 429         /* The package must have at least one element, else invalid */
 430
 431         if (!count) {
 432                 ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags,
 433                                       "Return Package has no elements (empty)"));
 434
 435                 return (AE_AML_OPERAND_VALUE);
 436         }
 437
 438         /*
 439          * Decode the type of the expected package contents
 440          *
 441          * PTYPE1 packages contain no subpackages
 442          * PTYPE2 packages contain sub-packages
 443          */
 444         switch (package->ret_info.type) {
 445         case ACPI_PTYPE1_FIXED:
 446
 447                 /*
 448                  * The package count is fixed and there are no sub-packages
 449                  *
 450                  * If package is too small, exit.
 451                  * If package is larger than expected, issue warning but continue
 452                  */
 453                 expected_count =
 454                     package->ret_info.count1 + package->ret_info.count2;
 455                 if (count < expected_count) {
 456                         goto package_too_small;
 457                 } else if (count > expected_count) {
 458                         ACPI_WARN_PREDEFINED((AE_INFO, data->pathname,
 459                                               data->node_flags,
 460                                               "Return Package is larger than needed - "
 461                                               "found %u, expected %u", count,
 462                                               expected_count));
 463                 }
 464
 465                 /* Validate all elements of the returned package */
 466
 467                 status = acpi_ns_check_package_elements(data, elements,
 468                                                         package->ret_info.
 469                                                         object_type1,
 470                                                         package->ret_info.
 471                                                         count1,
 472                                                         package->ret_info.
 473                                                         object_type2,
 474                                                         package->ret_info.
 475                                                         count2, 0);
 476                 break;
 477
 478         case ACPI_PTYPE1_VAR:
 479
 480                 /*
 481                  * The package count is variable, there are no sub-packages, and all
 482                  * elements must be of the same type
 483                  */
 484                 for (i = 0; i < count; i++) {
 485                         status = acpi_ns_check_object_type(data, elements,
 486                                                            package->ret_info.
 487                                                            object_type1, i);
 488                         if (ACPI_FAILURE(status)) {
 489                                 return (status);
 490                         }
 491                         elements++;
 492                 }
 493                 break;
 494
 495         case ACPI_PTYPE1_OPTION:
 496
 497                 /*
 498                  * The package count is variable, there are no sub-packages. There are
 499                  * a fixed number of required elements, and a variable number of
 500                  * optional elements.
 501                  *
 502                  * Check if package is at least as large as the minimum required
 503                  */
 504                 expected_count = package->ret_info3.count;
 505                 if (count < expected_count) {
 506                         goto package_too_small;
 507                 }
 508
 509                 /* Variable number of sub-objects */
 510
 511                 for (i = 0; i < count; i++) {
 512                         if (i < package->ret_info3.count) {
 513
 514                                 /* These are the required package elements (0, 1, or 2) */
 515
 516                                 status =
 517                                     acpi_ns_check_object_type(data, elements,
 518                                                               package->
 519                                                               ret_info3.
 520                                                               object_type[i],
 521                                                               i);
 522                                 if (ACPI_FAILURE(status)) {
 523                                         return (status);
 524                                 }
 525                         } else {
 526                                 /* These are the optional package elements */
 527
 528                                 status =
 529                                     acpi_ns_check_object_type(data, elements,
 530                                                               package->
 531                                                               ret_info3.
 532                                                               tail_object_type,
 533                                                               i);
 534                                 if (ACPI_FAILURE(status)) {
 535                                         return (status);
 536                                 }
 537                         }
 538                         elements++;
 539                 }
 540                 break;
 541
 542         case ACPI_PTYPE2_REV_FIXED:
 543
 544                 /* First element is the (Integer) revision */
 545
 546                 status = acpi_ns_check_object_type(data, elements,
 547                                                    ACPI_RTYPE_INTEGER, 0);
 548                 if (ACPI_FAILURE(status)) {
 549                         return (status);
 550                 }
 551
 552                 elements++;
 553                 count--;
 554
 555                 /* Examine the sub-packages */
 556
 557                 status =
 558                     acpi_ns_check_package_list(data, package, elements, count);
 559                 break;
 560
 561         case ACPI_PTYPE2_PKG_COUNT:
 562
 563                 /* First element is the (Integer) count of sub-packages to follow */
 564
 565                 status = acpi_ns_check_object_type(data, elements,
 566                                                    ACPI_RTYPE_INTEGER, 0);
 567                 if (ACPI_FAILURE(status)) {
 568                         return (status);
 569                 }
 570
 571                 /*
 572                  * Count cannot be larger than the parent package length, but allow it
 573                  * to be smaller. The >= accounts for the Integer above.
 574                  */
 575                 expected_count = (u32) (*elements)->integer.value;
 576                 if (expected_count >= count) {
 577                         goto package_too_small;
 578                 }
 579
 580                 count = expected_count;
 581                 elements++;
 582
 583                 /* Examine the sub-packages */
 584
 585                 status =
 586                     acpi_ns_check_package_list(data, package, elements, count);
 587                 break;
 588
 589         case ACPI_PTYPE2:
 590         case ACPI_PTYPE2_FIXED:
 591         case ACPI_PTYPE2_MIN:
 592         case ACPI_PTYPE2_COUNT:
 593
 594                 /*
 595                  * These types all return a single Package that consists of a
 596                  * variable number of sub-Packages.
 597                  *
 598                  * First, ensure that the first element is a sub-Package. If not,
 599                  * the BIOS may have incorrectly returned the object as a single
 600                  * package instead of a Package of Packages (a common error if
 601                  * there is only one entry). We may be able to repair this by
 602                  * wrapping the returned Package with a new outer Package.
 603                  */
 604                 if ((*elements)->common.type != ACPI_TYPE_PACKAGE) {
 605
 606                         /* Create the new outer package and populate it */
 607
 608                         status =
 609                             acpi_ns_repair_package_list(data,
 610                                                         return_object_ptr);
 611                         if (ACPI_FAILURE(status)) {
 612                                 return (status);
 613                         }
 614
 615                         /* Update locals to point to the new package (of 1 element) */
 616
 617                         return_object = *return_object_ptr;
 618                         elements = return_object->package.elements;
 619                         count = 1;
 620                 }
 621
 622                 /* Examine the sub-packages */
 623
 624                 status =
 625                     acpi_ns_check_package_list(data, package, elements, count);
 626                 break;
 627
 628         default:
 629
 630                 /* Should not get here if predefined info table is correct */
 631
 632                 ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags,
 633                                       "Invalid internal return type in table entry: %X",
 634                                       package->ret_info.type));
 635
 636                 return (AE_AML_INTERNAL);
 637         }
 638
 639         return (status);
 640
 641 package_too_small:
 642
 643         /* Error exit for the case with an incorrect package count */
 644
 645         ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags,
 646                               "Return Package is too small - found %u elements, expected %u",
 647                               count, expected_count));
 648
 649         return (AE_AML_OPERAND_VALUE);
 650 }
 651
 652 /*******************************************************************************
 653  *
 654  * FUNCTION:    acpi_ns_check_package_list
 655  *
 656  * PARAMETERS:  Data            - Pointer to validation data structure
 657  *              Package         - Pointer to package-specific info for method
 658  *              Elements        - Element list of parent package. All elements
 659  *                                of this list should be of type Package.
 660  *              Count           - Count of subpackages
 661  *
 662  * RETURN:      Status
 663  *
 664  * DESCRIPTION: Examine a list of subpackages
 665  *
 666  ******************************************************************************/
 667
 668 static acpi_status
 669 acpi_ns_check_package_list(struct acpi_predefined_data *data,
 670                            const union acpi_predefined_info *package,
 671                            union acpi_operand_object **elements, u32 count)
 672 {
 673         union acpi_operand_object *sub_package;
 674         union acpi_operand_object **sub_elements;
 675         acpi_status status;
 676         u32 expected_count;
 677         u32 i;
 678         u32 j;
 679
 680         /* Validate each sub-Package in the parent Package */
 681
 682         for (i = 0; i < count; i++) {
 683                 sub_package = *elements;
 684                 sub_elements = sub_package->package.elements;
 685
 686                 /* Each sub-object must be of type Package */
 687
 688                 status = acpi_ns_check_object_type(data, &sub_package,
 689                                                    ACPI_RTYPE_PACKAGE, i);
 690                 if (ACPI_FAILURE(status)) {
 691                         return (status);
 692                 }
 693
 694                 /* Examine the different types of expected sub-packages */
 695
 696                 switch (package->ret_info.type) {
 697                 case ACPI_PTYPE2:
 698                 case ACPI_PTYPE2_PKG_COUNT:
 699                 case ACPI_PTYPE2_REV_FIXED:
 700
 701                         /* Each subpackage has a fixed number of elements */
 702
 703                         expected_count =
 704                             package->ret_info.count1 + package->ret_info.count2;
 705                         if (sub_package->package.count < expected_count) {
 706                                 goto package_too_small;
 707                         }
 708
 709                         status =
 710                             acpi_ns_check_package_elements(data, sub_elements,
 711                                                            package->ret_info.
 712                                                            object_type1,
 713                                                            package->ret_info.
 714                                                            count1,
 715                                                            package->ret_info.
 716                                                            object_type2,
 717                                                            package->ret_info.
 718                                                            count2, 0);
 719                         if (ACPI_FAILURE(status)) {
 720                                 return (status);
 721                         }
 722                         break;
 723
 724                 case ACPI_PTYPE2_FIXED:
 725
 726                         /* Each sub-package has a fixed length */
 727
 728                         expected_count = package->ret_info2.count;
 729                         if (sub_package->package.count < expected_count) {
 730                                 goto package_too_small;
 731                         }
 732
 733                         /* Check the type of each sub-package element */
 734
 735                         for (j = 0; j < expected_count; j++) {
 736                                 status =
 737                                     acpi_ns_check_object_type(data,
 738                                                               &sub_elements[j],
 739                                                               package->
 740                                                               ret_info2.
 741                                                               object_type[j],
 742                                                               j);
 743                                 if (ACPI_FAILURE(status)) {
 744                                         return (status);
 745                                 }
 746                         }
 747                         break;
 748
 749                 case ACPI_PTYPE2_MIN:
 750
 751                         /* Each sub-package has a variable but minimum length */
 752
 753                         expected_count = package->ret_info.count1;
 754                         if (sub_package->package.count < expected_count) {
 755                                 goto package_too_small;
 756                         }
 757
 758                         /* Check the type of each sub-package element */
 759
 760                         status =
 761                             acpi_ns_check_package_elements(data, sub_elements,
 762                                                            package->ret_info.
 763                                                            object_type1,
 764                                                            sub_package->package.
 765                                                            count, 0, 0, 0);
 766                         if (ACPI_FAILURE(status)) {
 767                                 return (status);
 768                         }
 769                         break;
 770
 771                 case ACPI_PTYPE2_COUNT:
 772
 773                         /*
 774                          * First element is the (Integer) count of elements, including
 775                          * the count field.
 776                          */
 777                         status = acpi_ns_check_object_type(data, sub_elements,
 778                                                            ACPI_RTYPE_INTEGER,
 779                                                            0);
 780                         if (ACPI_FAILURE(status)) {
 781                                 return (status);
 782                         }
 783
 784                         /*
 785                          * Make sure package is large enough for the Count and is
 786                          * is as large as the minimum size
 787                          */
 788                         expected_count = (u32)(*sub_elements)->integer.value;
 789                         if (sub_package->package.count < expected_count) {
 790                                 goto package_too_small;
 791                         }
 792                         if (sub_package->package.count <
 793                             package->ret_info.count1) {
 794                                 expected_count = package->ret_info.count1;
 795                                 goto package_too_small;
 796                         }
 797
 798                         /* Check the type of each sub-package element */
 799
 800                         status =
 801                             acpi_ns_check_package_elements(data,
 802                                                            (sub_elements + 1),
 803                                                            package->ret_info.
 804                                                            object_type1,
 805                                                            (expected_count - 1),
 806                                                            0, 0, 1);
 807                         if (ACPI_FAILURE(status)) {
 808                                 return (status);
 809                         }
 810                         break;
 811
 812                 default:        /* Should not get here, type was validated by caller */
 813
 814                         return (AE_AML_INTERNAL);
 815                 }
 816
 817                 elements++;
 818         }
 819
 820         return (AE_OK);
 821
 822 package_too_small:
 823
 824         /* The sub-package count was smaller than required */
 825
 826         ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags,
 827                               "Return Sub-Package[%u] is too small - found %u elements, expected %u",
 828                               i, sub_package->package.count, expected_count));
 829
 830         return (AE_AML_OPERAND_VALUE);
 831 }
 832
 833 /*******************************************************************************
 834  *
 835  * FUNCTION:    acpi_ns_check_package_elements
 836  *
 837  * PARAMETERS:  Data            - Pointer to validation data structure
 838  *              Elements        - Pointer to the package elements array
 839  *              Type1           - Object type for first group
 840  *              Count1          - Count for first group
 841  *              Type2           - Object type for second group
 842  *              Count2          - Count for second group
 843  *              start_index     - Start of the first group of elements
 844  *
 845  * RETURN:      Status
 846  *
 847  * DESCRIPTION: Check that all elements of a package are of the correct object
 848  *              type. Supports up to two groups of different object types.
 849  *
 850  ******************************************************************************/
 851
 852 static acpi_status
 853 acpi_ns_check_package_elements(struct acpi_predefined_data *data,
 854                                union acpi_operand_object **elements,
 855                                u8 type1,
 856                                u32 count1,
 857                                u8 type2, u32 count2, u32 start_index)
 858 {
 859         union acpi_operand_object **this_element = elements;
 860         acpi_status status;
 861         u32 i;
 862
 863         /*
 864          * Up to two groups of package elements are supported by the data
 865          * structure. All elements in each group must be of the same type.
 866          * The second group can have a count of zero.
 867          */
 868         for (i = 0; i < count1; i++) {
 869                 status = acpi_ns_check_object_type(data, this_element,
 870                                                    type1, i + start_index);
 871                 if (ACPI_FAILURE(status)) {
 872                         return (status);
 873                 }
 874                 this_element++;
 875         }
 876
 877         for (i = 0; i < count2; i++) {
 878                 status = acpi_ns_check_object_type(data, this_element,
 879                                                    type2,
 880                                                    (i + count1 + start_index));
 881                 if (ACPI_FAILURE(status)) {
 882                         return (status);
 883                 }
 884                 this_element++;
 885         }
 886
 887         return (AE_OK);
 888 }
 889
 890 /*******************************************************************************
 891  *
 892  * FUNCTION:    acpi_ns_check_object_type
 893  *
 894  * PARAMETERS:  Data            - Pointer to validation data structure
 895  *              return_object_ptr - Pointer to the object returned from the
 896  *                                evaluation of a method or object
 897  *              expected_btypes - Bitmap of expected return type(s)
 898  *              package_index   - Index of object within parent package (if
 899  *                                applicable - ACPI_NOT_PACKAGE_ELEMENT
 900  *                                otherwise)
 901  *
 902  * RETURN:      Status
 903  *
 904  * DESCRIPTION: Check the type of the return object against the expected object
 905  *              type(s). Use of Btype allows multiple expected object types.
 906  *
 907  ******************************************************************************/
 908
 909 static acpi_status
 910 acpi_ns_check_object_type(struct acpi_predefined_data *data,
 911                           union acpi_operand_object **return_object_ptr,
 912                           u32 expected_btypes, u32 package_index)
 913 {
 914         union acpi_operand_object *return_object = *return_object_ptr;
 915         acpi_status status = AE_OK;
 916         u32 return_btype;
 917         char type_buffer[48];   /* Room for 5 types */
 918
 919         /*
 920          * If we get a NULL return_object here, it is a NULL package element,
 921          * and this is always an error.
 922          */
 923         if (!return_object) {
 924                 goto type_error_exit;
 925         }
 926
 927         /* A Namespace node should not get here, but make sure */
 928
 929         if (ACPI_GET_DESCRIPTOR_TYPE(return_object) == ACPI_DESC_TYPE_NAMED) {
 930                 ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags,
 931                                       "Invalid return type - Found a Namespace node [%4.4s] type %s",
 932                                       return_object->node.name.ascii,
 933                                       acpi_ut_get_type_name(return_object->node.
 934                                                             type)));
 935                 return (AE_AML_OPERAND_TYPE);
 936         }
 937
 938         /*
 939          * Convert the object type (ACPI_TYPE_xxx) to a bitmapped object type.
 940          * The bitmapped type allows multiple possible return types.
 941          *
 942          * Note, the cases below must handle all of the possible types returned
 943          * from all of the predefined names (including elements of returned
 944          * packages)
 945          */
 946         switch (return_object->common.type) {
 947         case ACPI_TYPE_INTEGER:
 948                 return_btype = ACPI_RTYPE_INTEGER;
 949                 break;
 950
 951         case ACPI_TYPE_BUFFER:
 952                 return_btype = ACPI_RTYPE_BUFFER;
 953                 break;
 954
 955         case ACPI_TYPE_STRING:
 956                 return_btype = ACPI_RTYPE_STRING;
 957                 break;
 958
 959         case ACPI_TYPE_PACKAGE:
 960                 return_btype = ACPI_RTYPE_PACKAGE;
 961                 break;
 962
 963         case ACPI_TYPE_LOCAL_REFERENCE:
 964                 return_btype = ACPI_RTYPE_REFERENCE;
 965                 break;
 966
 967         default:
 968                 /* Not one of the supported objects, must be incorrect */
 969
 970                 goto type_error_exit;
 971         }
 972
 973         /* Is the object one of the expected types? */
 974
 975         if (!(return_btype & expected_btypes)) {
 976
 977                 /* Type mismatch -- attempt repair of the returned object */
 978
 979                 status = acpi_ns_repair_object(data, expected_btypes,
 980                                                package_index,
 981                                                return_object_ptr);
 982                 if (ACPI_SUCCESS(status)) {
 983                         return (AE_OK); /* Repair was successful */
 984                 }
 985                 goto type_error_exit;
 986         }
 987
 988         /* For reference objects, check that the reference type is correct */
 989
 990         if (return_object->common.type == ACPI_TYPE_LOCAL_REFERENCE) {
 991                 status = acpi_ns_check_reference(data, return_object);
 992         }
 993
 994         return (status);
 995
 996       type_error_exit:
 997
 998         /* Create a string with all expected types for this predefined object */
 999
1000         acpi_ns_get_expected_types(type_buffer, expected_btypes);
1001
1002         if (package_index == ACPI_NOT_PACKAGE_ELEMENT) {
1003                 ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags,
1004                                       "Return type mismatch - found %s, expected %s",
1005                                       acpi_ut_get_object_type_name
1006                                       (return_object), type_buffer));
1007         } else {
1008                 ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags,
1009                                       "Return Package type mismatch at index %u - "
1010                                       "found %s, expected %s", package_index,
1011                                       acpi_ut_get_object_type_name
1012                                       (return_object), type_buffer));
1013         }
1014
1015         return (AE_AML_OPERAND_TYPE);
1016 }
1017
1018 /*******************************************************************************
1019  *
1020  * FUNCTION:    acpi_ns_check_reference
1021  *
1022  * PARAMETERS:  Data            - Pointer to validation data structure
1023  *              return_object   - Object returned from the evaluation of a
1024  *                                method or object
1025  *
1026  * RETURN:      Status
1027  *
1028  * DESCRIPTION: Check a returned reference object for the correct reference
1029  *              type. The only reference type that can be returned from a
1030  *              predefined method is a named reference. All others are invalid.
1031  *
1032  ******************************************************************************/
1033
1034 static acpi_status
1035 acpi_ns_check_reference(struct acpi_predefined_data *data,
1036                         union acpi_operand_object *return_object)
1037 {
1038
1039         /*
1040          * Check the reference object for the correct reference type (opcode).
1041          * The only type of reference that can be converted to an union acpi_object is
1042          * a reference to a named object (reference class: NAME)
1043          */
1044         if (return_object->reference.class == ACPI_REFCLASS_NAME) {
1045                 return (AE_OK);
1046         }
1047
1048         ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags,
1049                               "Return type mismatch - unexpected reference object type [%s] %2.2X",
1050                               acpi_ut_get_reference_name(return_object),
1051                               return_object->reference.class));
1052
1053         return (AE_AML_OPERAND_TYPE);
1054 }
1055
1056 /*******************************************************************************
1057  *
1058  * FUNCTION:    acpi_ns_get_expected_types
1059  *
1060  * PARAMETERS:  Buffer          - Pointer to where the string is returned
1061  *              expected_btypes - Bitmap of expected return type(s)
1062  *
1063  * RETURN:      Buffer is populated with type names.
1064  *
1065  * DESCRIPTION: Translate the expected types bitmap into a string of ascii
1066  *              names of expected types, for use in warning messages.
1067  *
1068  ******************************************************************************/
1069
1070 static void acpi_ns_get_expected_types(char *buffer, u32 expected_btypes)
1071 {
1072         u32 this_rtype;
1073         u32 i;
1074         u32 j;
1075
1076         j = 1;
1077         buffer[0] = 0;
1078         this_rtype = ACPI_RTYPE_INTEGER;
1079
1080         for (i = 0; i < ACPI_NUM_RTYPES; i++) {
1081
1082                 /* If one of the expected types, concatenate the name of this type */
1083
1084                 if (expected_btypes & this_rtype) {
1085                         ACPI_STRCAT(buffer, &acpi_rtype_names[i][j]);
1086                         j = 0;  /* Use name separator from now on */
1087                 }
1088                 this_rtype <<= 1;       /* Next Rtype */
1089         }
1090 }