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 - 2011, 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 main return object is what is expected
 220          * for 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 exit;
 227         }
 228
 229         /*
 230          * For returned Package objects, check the type of all sub-objects.
 231          * Note: Package may have been newly created by call above.
 232          */
 233         if ((*return_object_ptr)->common.type == ACPI_TYPE_PACKAGE) {
 234                 data->parent_package = *return_object_ptr;
 235                 status = acpi_ns_check_package(data, return_object_ptr);
 236                 if (ACPI_FAILURE(status)) {
 237                         goto exit;
 238                 }
 239         }
 240
 241         /*
 242          * The return object was OK, or it was successfully repaired above.
 243          * Now make some additional checks such as verifying that package
 244          * objects are sorted correctly (if required) or buffer objects have
 245          * the correct data width (bytes vs. dwords). These repairs are
 246          * performed on a per-name basis, i.e., the code is specific to
 247          * particular predefined names.
 248          */
 249         status = acpi_ns_complex_repairs(data, node, status, return_object_ptr);
 250
 251 exit:
 252         /*
 253          * If the object validation failed or if we successfully repaired one
 254          * or more objects, mark the parent node to suppress further warning
 255          * messages during the next evaluation of the same method/object.
 256          */
 257         if (ACPI_FAILURE(status) || (data->flags & ACPI_OBJECT_REPAIRED)) {
 258                 node->flags |= ANOBJ_EVALUATED;
 259         }
 260         ACPI_FREE(data);
 261
 262 cleanup:
 263         ACPI_FREE(pathname);
 264         return (status);
 265 }
 266
 267 /*******************************************************************************
 268  *
 269  * FUNCTION:    acpi_ns_check_parameter_count
 270  *
 271  * PARAMETERS:  Pathname        - Full pathname to the node (for error msgs)
 272  *              Node            - Namespace node for the method/object
 273  *              user_param_count - Number of args passed in by the caller
 274  *              Predefined      - Pointer to entry in predefined name table
 275  *
 276  * RETURN:      None
 277  *
 278  * DESCRIPTION: Check that the declared (in ASL/AML) parameter count for a
 279  *              predefined name is what is expected (i.e., what is defined in
 280  *              the ACPI specification for this predefined name.)
 281  *
 282  ******************************************************************************/
 283
 284 void
 285 acpi_ns_check_parameter_count(char *pathname,
 286                               struct acpi_namespace_node *node,
 287                               u32 user_param_count,
 288                               const union acpi_predefined_info *predefined)
 289 {
 290         u32 param_count;
 291         u32 required_params_current;
 292         u32 required_params_old;
 293
 294         /* Methods have 0-7 parameters. All other types have zero. */
 295
 296         param_count = 0;
 297         if (node->type == ACPI_TYPE_METHOD) {
 298                 param_count = node->object->method.param_count;
 299         }
 300
 301         if (!predefined) {
 302                 /*
 303                  * Check the parameter count for non-predefined methods/objects.
 304                  *
 305                  * Warning if too few or too many arguments have been passed by the
 306                  * caller. An incorrect number of arguments may not cause the method
 307                  * to fail. However, the method will fail if there are too few
 308                  * arguments and the method attempts to use one of the missing ones.
 309                  */
 310                 if (user_param_count < param_count) {
 311                         ACPI_WARN_PREDEFINED((AE_INFO, pathname,
 312                                               ACPI_WARN_ALWAYS,
 313                                               "Insufficient arguments - needs %u, found %u",
 314                                               param_count, user_param_count));
 315                 } else if (user_param_count > param_count) {
 316                         ACPI_WARN_PREDEFINED((AE_INFO, pathname,
 317                                               ACPI_WARN_ALWAYS,
 318                                               "Excess arguments - needs %u, found %u",
 319                                               param_count, user_param_count));
 320                 }
 321                 return;
 322         }
 323
 324         /*
 325          * Validate the user-supplied parameter count.
 326          * Allow two different legal argument counts (_SCP, etc.)
 327          */
 328         required_params_current = predefined->info.param_count & 0x0F;
 329         required_params_old = predefined->info.param_count >> 4;
 330
 331         if (user_param_count != ACPI_UINT32_MAX) {
 332                 if ((user_param_count != required_params_current) &&
 333                     (user_param_count != required_params_old)) {
 334                         ACPI_WARN_PREDEFINED((AE_INFO, pathname,
 335                                               ACPI_WARN_ALWAYS,
 336                                               "Parameter count mismatch - "
 337                                               "caller passed %u, ACPI requires %u",
 338                                               user_param_count,
 339                                               required_params_current));
 340                 }
 341         }
 342
 343         /*
 344          * Check that the ASL-defined parameter count is what is expected for
 345          * this predefined name (parameter count as defined by the ACPI
 346          * specification)
 347          */
 348         if ((param_count != required_params_current) &&
 349             (param_count != required_params_old)) {
 350                 ACPI_WARN_PREDEFINED((AE_INFO, pathname, node->flags,
 351                                       "Parameter count mismatch - ASL declared %u, ACPI requires %u",
 352                                       param_count, required_params_current));
 353         }
 354 }
 355
 356 /*******************************************************************************
 357  *
 358  * FUNCTION:    acpi_ns_check_for_predefined_name
 359  *
 360  * PARAMETERS:  Node            - Namespace node for the method/object
 361  *
 362  * RETURN:      Pointer to entry in predefined table. NULL indicates not found.
 363  *
 364  * DESCRIPTION: Check an object name against the predefined object list.
 365  *
 366  ******************************************************************************/
 367
 368 const union acpi_predefined_info *acpi_ns_check_for_predefined_name(struct
 369                                                                     acpi_namespace_node
 370                                                                     *node)
 371 {
 372         const union acpi_predefined_info *this_name;
 373
 374         /* Quick check for a predefined name, first character must be underscore */
 375
 376         if (node->name.ascii[0] != '_') {
 377                 return (NULL);
 378         }
 379
 380         /* Search info table for a predefined method/object name */
 381
 382         this_name = predefined_names;
 383         while (this_name->info.name[0]) {
 384                 if (ACPI_COMPARE_NAME(node->name.ascii, this_name->info.name)) {
 385                         return (this_name);
 386                 }
 387
 388                 /*
 389                  * Skip next entry in the table if this name returns a Package
 390                  * (next entry contains the package info)
 391                  */
 392                 if (this_name->info.expected_btypes & ACPI_RTYPE_PACKAGE) {
 393                         this_name++;
 394                 }
 395
 396                 this_name++;
 397         }
 398
 399         return (NULL);          /* Not found */
 400 }
 401
 402 /*******************************************************************************
 403  *
 404  * FUNCTION:    acpi_ns_check_package
 405  *
 406  * PARAMETERS:  Data            - Pointer to validation data structure
 407  *              return_object_ptr - Pointer to the object returned from the
 408  *                                evaluation of a method or object
 409  *
 410  * RETURN:      Status
 411  *
 412  * DESCRIPTION: Check a returned package object for the correct count and
 413  *              correct type of all sub-objects.
 414  *
 415  ******************************************************************************/
 416
 417 static acpi_status
 418 acpi_ns_check_package(struct acpi_predefined_data *data,
 419                       union acpi_operand_object **return_object_ptr)
 420 {
 421         union acpi_operand_object *return_object = *return_object_ptr;
 422         const union acpi_predefined_info *package;
 423         union acpi_operand_object **elements;
 424         acpi_status status = AE_OK;
 425         u32 expected_count;
 426         u32 count;
 427         u32 i;
 428
 429         ACPI_FUNCTION_NAME(ns_check_package);
 430
 431         /* The package info for this name is in the next table entry */
 432
 433         package = data->predefined + 1;
 434
 435         ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
 436                           "%s Validating return Package of Type %X, Count %X\n",
 437                           data->pathname, package->ret_info.type,
 438                           return_object->package.count));
 439
 440         /*
 441          * For variable-length Packages, we can safely remove all embedded
 442          * and trailing NULL package elements
 443          */
 444         acpi_ns_remove_null_elements(data, package->ret_info.type,
 445                                      return_object);
 446
 447         /* Extract package count and elements array */
 448
 449         elements = return_object->package.elements;
 450         count = return_object->package.count;
 451
 452         /* The package must have at least one element, else invalid */
 453
 454         if (!count) {
 455                 ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags,
 456                                       "Return Package has no elements (empty)"));
 457
 458                 return (AE_AML_OPERAND_VALUE);
 459         }
 460
 461         /*
 462          * Decode the type of the expected package contents
 463          *
 464          * PTYPE1 packages contain no subpackages
 465          * PTYPE2 packages contain sub-packages
 466          */
 467         switch (package->ret_info.type) {
 468         case ACPI_PTYPE1_FIXED:
 469
 470                 /*
 471                  * The package count is fixed and there are no sub-packages
 472                  *
 473                  * If package is too small, exit.
 474                  * If package is larger than expected, issue warning but continue
 475                  */
 476                 expected_count =
 477                     package->ret_info.count1 + package->ret_info.count2;
 478                 if (count < expected_count) {
 479                         goto package_too_small;
 480                 } else if (count > expected_count) {
 481                         ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
 482                                           "%s: Return Package is larger than needed - "
 483                                           "found %u, expected %u\n",
 484                                           data->pathname, count,
 485                                           expected_count));
 486                 }
 487
 488                 /* Validate all elements of the returned package */
 489
 490                 status = acpi_ns_check_package_elements(data, elements,
 491                                                         package->ret_info.
 492                                                         object_type1,
 493                                                         package->ret_info.
 494                                                         count1,
 495                                                         package->ret_info.
 496                                                         object_type2,
 497                                                         package->ret_info.
 498                                                         count2, 0);
 499                 break;
 500
 501         case ACPI_PTYPE1_VAR:
 502
 503                 /*
 504                  * The package count is variable, there are no sub-packages, and all
 505                  * elements must be of the same type
 506                  */
 507                 for (i = 0; i < count; i++) {
 508                         status = acpi_ns_check_object_type(data, elements,
 509                                                            package->ret_info.
 510                                                            object_type1, i);
 511                         if (ACPI_FAILURE(status)) {
 512                                 return (status);
 513                         }
 514                         elements++;
 515                 }
 516                 break;
 517
 518         case ACPI_PTYPE1_OPTION:
 519
 520                 /*
 521                  * The package count is variable, there are no sub-packages. There are
 522                  * a fixed number of required elements, and a variable number of
 523                  * optional elements.
 524                  *
 525                  * Check if package is at least as large as the minimum required
 526                  */
 527                 expected_count = package->ret_info3.count;
 528                 if (count < expected_count) {
 529                         goto package_too_small;
 530                 }
 531
 532                 /* Variable number of sub-objects */
 533
 534                 for (i = 0; i < count; i++) {
 535                         if (i < package->ret_info3.count) {
 536
 537                                 /* These are the required package elements (0, 1, or 2) */
 538
 539                                 status =
 540                                     acpi_ns_check_object_type(data, elements,
 541                                                               package->
 542                                                               ret_info3.
 543                                                               object_type[i],
 544                                                               i);
 545                                 if (ACPI_FAILURE(status)) {
 546                                         return (status);
 547                                 }
 548                         } else {
 549                                 /* These are the optional package elements */
 550
 551                                 status =
 552                                     acpi_ns_check_object_type(data, elements,
 553                                                               package->
 554                                                               ret_info3.
 555                                                               tail_object_type,
 556                                                               i);
 557                                 if (ACPI_FAILURE(status)) {
 558                                         return (status);
 559                                 }
 560                         }
 561                         elements++;
 562                 }
 563                 break;
 564
 565         case ACPI_PTYPE2_REV_FIXED:
 566
 567                 /* First element is the (Integer) revision */
 568
 569                 status = acpi_ns_check_object_type(data, elements,
 570                                                    ACPI_RTYPE_INTEGER, 0);
 571                 if (ACPI_FAILURE(status)) {
 572                         return (status);
 573                 }
 574
 575                 elements++;
 576                 count--;
 577
 578                 /* Examine the sub-packages */
 579
 580                 status =
 581                     acpi_ns_check_package_list(data, package, elements, count);
 582                 break;
 583
 584         case ACPI_PTYPE2_PKG_COUNT:
 585
 586                 /* First element is the (Integer) count of sub-packages to follow */
 587
 588                 status = acpi_ns_check_object_type(data, elements,
 589                                                    ACPI_RTYPE_INTEGER, 0);
 590                 if (ACPI_FAILURE(status)) {
 591                         return (status);
 592                 }
 593
 594                 /*
 595                  * Count cannot be larger than the parent package length, but allow it
 596                  * to be smaller. The >= accounts for the Integer above.
 597                  */
 598                 expected_count = (u32) (*elements)->integer.value;
 599                 if (expected_count >= count) {
 600                         goto package_too_small;
 601                 }
 602
 603                 count = expected_count;
 604                 elements++;
 605
 606                 /* Examine the sub-packages */
 607
 608                 status =
 609                     acpi_ns_check_package_list(data, package, elements, count);
 610                 break;
 611
 612         case ACPI_PTYPE2:
 613         case ACPI_PTYPE2_FIXED:
 614         case ACPI_PTYPE2_MIN:
 615         case ACPI_PTYPE2_COUNT:
 616
 617                 /*
 618                  * These types all return a single Package that consists of a
 619                  * variable number of sub-Packages.
 620                  *
 621                  * First, ensure that the first element is a sub-Package. If not,
 622                  * the BIOS may have incorrectly returned the object as a single
 623                  * package instead of a Package of Packages (a common error if
 624                  * there is only one entry). We may be able to repair this by
 625                  * wrapping the returned Package with a new outer Package.
 626                  */
 627                 if (*elements
 628                     && ((*elements)->common.type != ACPI_TYPE_PACKAGE)) {
 629
 630                         /* Create the new outer package and populate it */
 631
 632                         status =
 633                             acpi_ns_repair_package_list(data,
 634                                                         return_object_ptr);
 635                         if (ACPI_FAILURE(status)) {
 636                                 return (status);
 637                         }
 638
 639                         /* Update locals to point to the new package (of 1 element) */
 640
 641                         return_object = *return_object_ptr;
 642                         elements = return_object->package.elements;
 643                         count = 1;
 644                 }
 645
 646                 /* Examine the sub-packages */
 647
 648                 status =
 649                     acpi_ns_check_package_list(data, package, elements, count);
 650                 break;
 651
 652         default:
 653
 654                 /* Should not get here if predefined info table is correct */
 655
 656                 ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags,
 657                                       "Invalid internal return type in table entry: %X",
 658                                       package->ret_info.type));
 659
 660                 return (AE_AML_INTERNAL);
 661         }
 662
 663         return (status);
 664
 665 package_too_small:
 666
 667         /* Error exit for the case with an incorrect package count */
 668
 669         ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags,
 670                               "Return Package is too small - found %u elements, expected %u",
 671                               count, expected_count));
 672
 673         return (AE_AML_OPERAND_VALUE);
 674 }
 675
 676 /*******************************************************************************
 677  *
 678  * FUNCTION:    acpi_ns_check_package_list
 679  *
 680  * PARAMETERS:  Data            - Pointer to validation data structure
 681  *              Package         - Pointer to package-specific info for method
 682  *              Elements        - Element list of parent package. All elements
 683  *                                of this list should be of type Package.
 684  *              Count           - Count of subpackages
 685  *
 686  * RETURN:      Status
 687  *
 688  * DESCRIPTION: Examine a list of subpackages
 689  *
 690  ******************************************************************************/
 691
 692 static acpi_status
 693 acpi_ns_check_package_list(struct acpi_predefined_data *data,
 694                            const union acpi_predefined_info *package,
 695                            union acpi_operand_object **elements, u32 count)
 696 {
 697         union acpi_operand_object *sub_package;
 698         union acpi_operand_object **sub_elements;
 699         acpi_status status;
 700         u32 expected_count;
 701         u32 i;
 702         u32 j;
 703
 704         /*
 705          * Validate each sub-Package in the parent Package
 706          *
 707          * NOTE: assumes list of sub-packages contains no NULL elements.
 708          * Any NULL elements should have been removed by earlier call
 709          * to acpi_ns_remove_null_elements.
 710          */
 711         for (i = 0; i < count; i++) {
 712                 sub_package = *elements;
 713                 sub_elements = sub_package->package.elements;
 714                 data->parent_package = sub_package;
 715
 716                 /* Each sub-object must be of type Package */
 717
 718                 status = acpi_ns_check_object_type(data, &sub_package,
 719                                                    ACPI_RTYPE_PACKAGE, i);
 720                 if (ACPI_FAILURE(status)) {
 721                         return (status);
 722                 }
 723
 724                 /* Examine the different types of expected sub-packages */
 725
 726                 data->parent_package = sub_package;
 727                 switch (package->ret_info.type) {
 728                 case ACPI_PTYPE2:
 729                 case ACPI_PTYPE2_PKG_COUNT:
 730                 case ACPI_PTYPE2_REV_FIXED:
 731
 732                         /* Each subpackage has a fixed number of elements */
 733
 734                         expected_count =
 735                             package->ret_info.count1 + package->ret_info.count2;
 736                         if (sub_package->package.count < expected_count) {
 737                                 goto package_too_small;
 738                         }
 739
 740                         status =
 741                             acpi_ns_check_package_elements(data, sub_elements,
 742                                                            package->ret_info.
 743                                                            object_type1,
 744                                                            package->ret_info.
 745                                                            count1,
 746                                                            package->ret_info.
 747                                                            object_type2,
 748                                                            package->ret_info.
 749                                                            count2, 0);
 750                         if (ACPI_FAILURE(status)) {
 751                                 return (status);
 752                         }
 753                         break;
 754
 755                 case ACPI_PTYPE2_FIXED:
 756
 757                         /* Each sub-package has a fixed length */
 758
 759                         expected_count = package->ret_info2.count;
 760                         if (sub_package->package.count < expected_count) {
 761                                 goto package_too_small;
 762                         }
 763
 764                         /* Check the type of each sub-package element */
 765
 766                         for (j = 0; j < expected_count; j++) {
 767                                 status =
 768                                     acpi_ns_check_object_type(data,
 769                                                               &sub_elements[j],
 770                                                               package->
 771                                                               ret_info2.
 772                                                               object_type[j],
 773                                                               j);
 774                                 if (ACPI_FAILURE(status)) {
 775                                         return (status);
 776                                 }
 777                         }
 778                         break;
 779
 780                 case ACPI_PTYPE2_MIN:
 781
 782                         /* Each sub-package has a variable but minimum length */
 783
 784                         expected_count = package->ret_info.count1;
 785                         if (sub_package->package.count < expected_count) {
 786                                 goto package_too_small;
 787                         }
 788
 789                         /* Check the type of each sub-package element */
 790
 791                         status =
 792                             acpi_ns_check_package_elements(data, sub_elements,
 793                                                            package->ret_info.
 794                                                            object_type1,
 795                                                            sub_package->package.
 796                                                            count, 0, 0, 0);
 797                         if (ACPI_FAILURE(status)) {
 798                                 return (status);
 799                         }
 800                         break;
 801
 802                 case ACPI_PTYPE2_COUNT:
 803
 804                         /*
 805                          * First element is the (Integer) count of elements, including
 806                          * the count field (the ACPI name is num_elements)
 807                          */
 808                         status = acpi_ns_check_object_type(data, sub_elements,
 809                                                            ACPI_RTYPE_INTEGER,
 810                                                            0);
 811                         if (ACPI_FAILURE(status)) {
 812                                 return (status);
 813                         }
 814
 815                         /*
 816                          * Make sure package is large enough for the Count and is
 817                          * is as large as the minimum size
 818                          */
 819                         expected_count = (u32)(*sub_elements)->integer.value;
 820                         if (sub_package->package.count < expected_count) {
 821                                 goto package_too_small;
 822                         }
 823                         if (sub_package->package.count <
 824                             package->ret_info.count1) {
 825                                 expected_count = package->ret_info.count1;
 826                                 goto package_too_small;
 827                         }
 828                         if (expected_count == 0) {
 829                                 /*
 830                                  * Either the num_entries element was originally zero or it was
 831                                  * a NULL element and repaired to an Integer of value zero.
 832                                  * In either case, repair it by setting num_entries to be the
 833                                  * actual size of the subpackage.
 834                                  */
 835                                 expected_count = sub_package->package.count;
 836                                 (*sub_elements)->integer.value = expected_count;
 837                         }
 838
 839                         /* Check the type of each sub-package element */
 840
 841                         status =
 842                             acpi_ns_check_package_elements(data,
 843                                                            (sub_elements + 1),
 844                                                            package->ret_info.
 845                                                            object_type1,
 846                                                            (expected_count - 1),
 847                                                            0, 0, 1);
 848                         if (ACPI_FAILURE(status)) {
 849                                 return (status);
 850                         }
 851                         break;
 852
 853                 default:        /* Should not get here, type was validated by caller */
 854
 855                         return (AE_AML_INTERNAL);
 856                 }
 857
 858                 elements++;
 859         }
 860
 861         return (AE_OK);
 862
 863 package_too_small:
 864
 865         /* The sub-package count was smaller than required */
 866
 867         ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags,
 868                               "Return Sub-Package[%u] is too small - found %u elements, expected %u",
 869                               i, sub_package->package.count, expected_count));
 870
 871         return (AE_AML_OPERAND_VALUE);
 872 }
 873
 874 /*******************************************************************************
 875  *
 876  * FUNCTION:    acpi_ns_check_package_elements
 877  *
 878  * PARAMETERS:  Data            - Pointer to validation data structure
 879  *              Elements        - Pointer to the package elements array
 880  *              Type1           - Object type for first group
 881  *              Count1          - Count for first group
 882  *              Type2           - Object type for second group
 883  *              Count2          - Count for second group
 884  *              start_index     - Start of the first group of elements
 885  *
 886  * RETURN:      Status
 887  *
 888  * DESCRIPTION: Check that all elements of a package are of the correct object
 889  *              type. Supports up to two groups of different object types.
 890  *
 891  ******************************************************************************/
 892
 893 static acpi_status
 894 acpi_ns_check_package_elements(struct acpi_predefined_data *data,
 895                                union acpi_operand_object **elements,
 896                                u8 type1,
 897                                u32 count1,
 898                                u8 type2, u32 count2, u32 start_index)
 899 {
 900         union acpi_operand_object **this_element = elements;
 901         acpi_status status;
 902         u32 i;
 903
 904         /*
 905          * Up to two groups of package elements are supported by the data
 906          * structure. All elements in each group must be of the same type.
 907          * The second group can have a count of zero.
 908          */
 909         for (i = 0; i < count1; i++) {
 910                 status = acpi_ns_check_object_type(data, this_element,
 911                                                    type1, i + start_index);
 912                 if (ACPI_FAILURE(status)) {
 913                         return (status);
 914                 }
 915                 this_element++;
 916         }
 917
 918         for (i = 0; i < count2; i++) {
 919                 status = acpi_ns_check_object_type(data, this_element,
 920                                                    type2,
 921                                                    (i + count1 + start_index));
 922                 if (ACPI_FAILURE(status)) {
 923                         return (status);
 924                 }
 925                 this_element++;
 926         }
 927
 928         return (AE_OK);
 929 }
 930
 931 /*******************************************************************************
 932  *
 933  * FUNCTION:    acpi_ns_check_object_type
 934  *
 935  * PARAMETERS:  Data            - Pointer to validation data structure
 936  *              return_object_ptr - Pointer to the object returned from the
 937  *                                evaluation of a method or object
 938  *              expected_btypes - Bitmap of expected return type(s)
 939  *              package_index   - Index of object within parent package (if
 940  *                                applicable - ACPI_NOT_PACKAGE_ELEMENT
 941  *                                otherwise)
 942  *
 943  * RETURN:      Status
 944  *
 945  * DESCRIPTION: Check the type of the return object against the expected object
 946  *              type(s). Use of Btype allows multiple expected object types.
 947  *
 948  ******************************************************************************/
 949
 950 static acpi_status
 951 acpi_ns_check_object_type(struct acpi_predefined_data *data,
 952                           union acpi_operand_object **return_object_ptr,
 953                           u32 expected_btypes, u32 package_index)
 954 {
 955         union acpi_operand_object *return_object = *return_object_ptr;
 956         acpi_status status = AE_OK;
 957         u32 return_btype;
 958         char type_buffer[48];   /* Room for 5 types */
 959
 960         /*
 961          * If we get a NULL return_object here, it is a NULL package element.
 962          * Since all extraneous NULL package elements were removed earlier by a
 963          * call to acpi_ns_remove_null_elements, this is an unexpected NULL element.
 964          * We will attempt to repair it.
 965          */
 966         if (!return_object) {
 967                 status = acpi_ns_repair_null_element(data, expected_btypes,
 968                                                      package_index,
 969                                                      return_object_ptr);
 970                 if (ACPI_SUCCESS(status)) {
 971                         return (AE_OK); /* Repair was successful */
 972                 }
 973                 goto type_error_exit;
 974         }
 975
 976         /* A Namespace node should not get here, but make sure */
 977
 978         if (ACPI_GET_DESCRIPTOR_TYPE(return_object) == ACPI_DESC_TYPE_NAMED) {
 979                 ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags,
 980                                       "Invalid return type - Found a Namespace node [%4.4s] type %s",
 981                                       return_object->node.name.ascii,
 982                                       acpi_ut_get_type_name(return_object->node.
 983                                                             type)));
 984                 return (AE_AML_OPERAND_TYPE);
 985         }
 986
 987         /*
 988          * Convert the object type (ACPI_TYPE_xxx) to a bitmapped object type.
 989          * The bitmapped type allows multiple possible return types.
 990          *
 991          * Note, the cases below must handle all of the possible types returned
 992          * from all of the predefined names (including elements of returned
 993          * packages)
 994          */
 995         switch (return_object->common.type) {
 996         case ACPI_TYPE_INTEGER:
 997                 return_btype = ACPI_RTYPE_INTEGER;
 998                 break;
 999
1000         case ACPI_TYPE_BUFFER:
1001                 return_btype = ACPI_RTYPE_BUFFER;
1002                 break;
1003
1004         case ACPI_TYPE_STRING:
1005                 return_btype = ACPI_RTYPE_STRING;
1006                 break;
1007
1008         case ACPI_TYPE_PACKAGE:
1009                 return_btype = ACPI_RTYPE_PACKAGE;
1010                 break;
1011
1012         case ACPI_TYPE_LOCAL_REFERENCE:
1013                 return_btype = ACPI_RTYPE_REFERENCE;
1014                 break;
1015
1016         default:
1017                 /* Not one of the supported objects, must be incorrect */
1018
1019                 goto type_error_exit;
1020         }
1021
1022         /* Is the object one of the expected types? */
1023
1024         if (return_btype & expected_btypes) {
1025
1026                 /* For reference objects, check that the reference type is correct */
1027
1028                 if (return_object->common.type == ACPI_TYPE_LOCAL_REFERENCE) {
1029                         status = acpi_ns_check_reference(data, return_object);
1030                 }
1031
1032                 return (status);
1033         }
1034
1035         /* Type mismatch -- attempt repair of the returned object */
1036
1037         status = acpi_ns_repair_object(data, expected_btypes,
1038                                        package_index, return_object_ptr);
1039         if (ACPI_SUCCESS(status)) {
1040                 return (AE_OK); /* Repair was successful */
1041         }
1042
1043       type_error_exit:
1044
1045         /* Create a string with all expected types for this predefined object */
1046
1047         acpi_ns_get_expected_types(type_buffer, expected_btypes);
1048
1049         if (package_index == ACPI_NOT_PACKAGE_ELEMENT) {
1050                 ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags,
1051                                       "Return type mismatch - found %s, expected %s",
1052                                       acpi_ut_get_object_type_name
1053                                       (return_object), type_buffer));
1054         } else {
1055                 ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags,
1056                                       "Return Package type mismatch at index %u - "
1057                                       "found %s, expected %s", package_index,
1058                                       acpi_ut_get_object_type_name
1059                                       (return_object), type_buffer));
1060         }
1061
1062         return (AE_AML_OPERAND_TYPE);
1063 }
1064
1065 /*******************************************************************************
1066  *
1067  * FUNCTION:    acpi_ns_check_reference
1068  *
1069  * PARAMETERS:  Data            - Pointer to validation data structure
1070  *              return_object   - Object returned from the evaluation of a
1071  *                                method or object
1072  *
1073  * RETURN:      Status
1074  *
1075  * DESCRIPTION: Check a returned reference object for the correct reference
1076  *              type. The only reference type that can be returned from a
1077  *              predefined method is a named reference. All others are invalid.
1078  *
1079  ******************************************************************************/
1080
1081 static acpi_status
1082 acpi_ns_check_reference(struct acpi_predefined_data *data,
1083                         union acpi_operand_object *return_object)
1084 {
1085
1086         /*
1087          * Check the reference object for the correct reference type (opcode).
1088          * The only type of reference that can be converted to an union acpi_object is
1089          * a reference to a named object (reference class: NAME)
1090          */
1091         if (return_object->reference.class == ACPI_REFCLASS_NAME) {
1092                 return (AE_OK);
1093         }
1094
1095         ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags,
1096                               "Return type mismatch - unexpected reference object type [%s] %2.2X",
1097                               acpi_ut_get_reference_name(return_object),
1098                               return_object->reference.class));
1099
1100         return (AE_AML_OPERAND_TYPE);
1101 }
1102
1103 /*******************************************************************************
1104  *
1105  * FUNCTION:    acpi_ns_get_expected_types
1106  *
1107  * PARAMETERS:  Buffer          - Pointer to where the string is returned
1108  *              expected_btypes - Bitmap of expected return type(s)
1109  *
1110  * RETURN:      Buffer is populated with type names.
1111  *
1112  * DESCRIPTION: Translate the expected types bitmap into a string of ascii
1113  *              names of expected types, for use in warning messages.
1114  *
1115  ******************************************************************************/
1116
1117 static void acpi_ns_get_expected_types(char *buffer, u32 expected_btypes)
1118 {
1119         u32 this_rtype;
1120         u32 i;
1121         u32 j;
1122
1123         j = 1;
1124         buffer[0] = 0;
1125         this_rtype = ACPI_RTYPE_INTEGER;
1126
1127         for (i = 0; i < ACPI_NUM_RTYPES; i++) {
1128
1129                 /* If one of the expected types, concatenate the name of this type */
1130
1131                 if (expected_btypes & this_rtype) {
1132                         ACPI_STRCAT(buffer, &acpi_rtype_names[i][j]);
1133                         j = 0;  /* Use name separator from now on */
1134                 }
1135                 this_rtype <<= 1;       /* Next Rtype */
1136         }
1137 }