drivers/acpi/acpica/nspredef.c

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