sys/contrib/dev/acpica/source/compiler/aslprepkg.c

   1 /******************************************************************************
   2  *
   3  * Module Name: aslprepkg - support for ACPI predefined name package objects
   4  *
   5  *****************************************************************************/
   6
   7 /******************************************************************************
   8  *
   9  * 1. Copyright Notice
  10  *
  11  * Some or all of this work - Copyright (c) 1999 - 2018, Intel Corp.
  12  * All rights reserved.
  13  *
  14  * 2. License
  15  *
  16  * 2.1. This is your license from Intel Corp. under its intellectual property
  17  * rights. You may have additional license terms from the party that provided
  18  * you this software, covering your right to use that party's intellectual
  19  * property rights.
  20  *
  21  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  22  * copy of the source code appearing in this file ("Covered Code") an
  23  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  24  * base code distributed originally by Intel ("Original Intel Code") to copy,
  25  * make derivatives, distribute, use and display any portion of the Covered
  26  * Code in any form, with the right to sublicense such rights; and
  27  *
  28  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  29  * license (with the right to sublicense), under only those claims of Intel
  30  * patents that are infringed by the Original Intel Code, to make, use, sell,
  31  * offer to sell, and import the Covered Code and derivative works thereof
  32  * solely to the minimum extent necessary to exercise the above copyright
  33  * license, and in no event shall the patent license extend to any additions
  34  * to or modifications of the Original Intel Code. No other license or right
  35  * is granted directly or by implication, estoppel or otherwise;
  36  *
  37  * The above copyright and patent license is granted only if the following
  38  * conditions are met:
  39  *
  40  * 3. Conditions
  41  *
  42  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  43  * Redistribution of source code of any substantial portion of the Covered
  44  * Code or modification with rights to further distribute source must include
  45  * the above Copyright Notice, the above License, this list of Conditions,
  46  * and the following Disclaimer and Export Compliance provision. In addition,
  47  * Licensee must cause all Covered Code to which Licensee contributes to
  48  * contain a file documenting the changes Licensee made to create that Covered
  49  * Code and the date of any change. Licensee must include in that file the
  50  * documentation of any changes made by any predecessor Licensee. Licensee
  51  * must include a prominent statement that the modification is derived,
  52  * directly or indirectly, from Original Intel Code.
  53  *
  54  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  55  * Redistribution of source code of any substantial portion of the Covered
  56  * Code or modification without rights to further distribute source must
  57  * include the following Disclaimer and Export Compliance provision in the
  58  * documentation and/or other materials provided with distribution. In
  59  * addition, Licensee may not authorize further sublicense of source of any
  60  * portion of the Covered Code, and must include terms to the effect that the
  61  * license from Licensee to its licensee is limited to the intellectual
  62  * property embodied in the software Licensee provides to its licensee, and
  63  * not to intellectual property embodied in modifications its licensee may
  64  * make.
  65  *
  66  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  67  * substantial portion of the Covered Code or modification must reproduce the
  68  * above Copyright Notice, and the following Disclaimer and Export Compliance
  69  * provision in the documentation and/or other materials provided with the
  70  * distribution.
  71  *
  72  * 3.4. Intel retains all right, title, and interest in and to the Original
  73  * Intel Code.
  74  *
  75  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  76  * Intel shall be used in advertising or otherwise to promote the sale, use or
  77  * other dealings in products derived from or relating to the Covered Code
  78  * without prior written authorization from Intel.
  79  *
  80  * 4. Disclaimer and Export Compliance
  81  *
  82  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  83  * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  84  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
  85  * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
  86  * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
  87  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  88  * PARTICULAR PURPOSE.
  89  *
  90  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  91  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  92  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  93  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  94  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  95  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
  96  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  97  * LIMITED REMEDY.
  98  *
  99  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 100  * software or system incorporating such software without first obtaining any
 101  * required license or other approval from the U. S. Department of Commerce or
 102  * any other agency or department of the United States Government. In the
 103  * event Licensee exports any such software from the United States or
 104  * re-exports any such software from a foreign destination, Licensee shall
 105  * ensure that the distribution and export/re-export of the software is in
 106  * compliance with all laws, regulations, orders, or other restrictions of the
 107  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 108  * any of its subsidiaries will export/re-export any technical data, process,
 109  * software, or service, directly or indirectly, to any country for which the
 110  * United States government or any agency thereof requires an export license,
 111  * other governmental approval, or letter of assurance, without first obtaining
 112  * such license, approval or letter.
 113  *
 114  *****************************************************************************
 115  *
 116  * Alternatively, you may choose to be licensed under the terms of the
 117  * following license:
 118  *
 119  * Redistribution and use in source and binary forms, with or without
 120  * modification, are permitted provided that the following conditions
 121  * are met:
 122  * 1. Redistributions of source code must retain the above copyright
 123  *    notice, this list of conditions, and the following disclaimer,
 124  *    without modification.
 125  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
 126  *    substantially similar to the "NO WARRANTY" disclaimer below
 127  *    ("Disclaimer") and any redistribution must be conditioned upon
 128  *    including a substantially similar Disclaimer requirement for further
 129  *    binary redistribution.
 130  * 3. Neither the names of the above-listed copyright holders nor the names
 131  *    of any contributors may be used to endorse or promote products derived
 132  *    from this software without specific prior written permission.
 133  *
 134  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 135  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 136  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 137  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 138  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 139  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 140  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 141  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 142  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 143  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 144  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 145  *
 146  * Alternatively, you may choose to be licensed under the terms of the
 147  * GNU General Public License ("GPL") version 2 as published by the Free
 148  * Software Foundation.
 149  *
 150  *****************************************************************************/
 151
 152 #include "aslcompiler.h"
 153 #include "aslcompiler.y.h"
 154 #include "acpredef.h"
 155
 156
 157 #define _COMPONENT          ACPI_COMPILER
 158         ACPI_MODULE_NAME    ("aslprepkg")
 159
 160
 161 /* Local prototypes */
 162
 163 static ACPI_PARSE_OBJECT *
 164 ApCheckPackageElements (
 165     const char                  *PredefinedName,
 166     ACPI_PARSE_OBJECT           *Op,
 167     UINT8                       Type1,
 168     UINT32                      Count1,
 169     UINT8                       Type2,
 170     UINT32                      Count2);
 171
 172 static void
 173 ApCheckPackageList (
 174     const char                  *PredefinedName,
 175     ACPI_PARSE_OBJECT           *ParentOp,
 176     const ACPI_PREDEFINED_INFO  *Package,
 177     UINT32                      StartIndex,
 178     UINT32                      Count);
 179
 180 static void
 181 ApPackageTooSmall (
 182     const char                  *PredefinedName,
 183     ACPI_PARSE_OBJECT           *Op,
 184     UINT32                      Count,
 185     UINT32                      ExpectedCount);
 186
 187 static void
 188 ApZeroLengthPackage (
 189     const char                  *PredefinedName,
 190     ACPI_PARSE_OBJECT           *Op);
 191
 192 static void
 193 ApPackageTooLarge (
 194     const char                  *PredefinedName,
 195     ACPI_PARSE_OBJECT           *Op,
 196     UINT32                      Count,
 197     UINT32                      ExpectedCount);
 198
 199 static void
 200 ApCustomPackage (
 201     ACPI_PARSE_OBJECT           *ParentOp,
 202     const ACPI_PREDEFINED_INFO  *Predefined);
 203
 204
 205 /*******************************************************************************
 206  *
 207  * FUNCTION:    ApCheckPackage
 208  *
 209  * PARAMETERS:  ParentOp            - Parser op for the package
 210  *              Predefined          - Pointer to package-specific info for
 211  *                                    the method
 212  *
 213  * RETURN:      None
 214  *
 215  * DESCRIPTION: Top-level validation for predefined name return package
 216  *              objects.
 217  *
 218  ******************************************************************************/
 219
 220 void
 221 ApCheckPackage (
 222     ACPI_PARSE_OBJECT           *ParentOp,
 223     const ACPI_PREDEFINED_INFO  *Predefined)
 224 {
 225     ACPI_PARSE_OBJECT           *Op;
 226     const ACPI_PREDEFINED_INFO  *Package;
 227     ACPI_STATUS                 Status;
 228     UINT32                      ExpectedCount;
 229     UINT32                      Count;
 230     UINT32                      i;
 231
 232
 233     /* The package info for this name is in the next table entry */
 234
 235     Package = Predefined + 1;
 236
 237     /* First child is the package length */
 238
 239     Op = ParentOp->Asl.Child;
 240     Count = (UINT32) Op->Asl.Value.Integer;
 241
 242     /*
 243      * Many of the variable-length top-level packages are allowed to simply
 244      * have zero elements. This allows the BIOS to tell the host that even
 245      * though the predefined name/method exists, the feature is not supported.
 246      * Other package types require one or more elements. In any case, there
 247      * is no need to continue validation.
 248      */
 249     if (!Count)
 250     {
 251         switch (Package->RetInfo.Type)
 252         {
 253         case ACPI_PTYPE1_FIXED:
 254         case ACPI_PTYPE1_OPTION:
 255         case ACPI_PTYPE2_PKG_COUNT:
 256         case ACPI_PTYPE2_REV_FIXED:
 257
 258             ApZeroLengthPackage (Predefined->Info.Name, ParentOp);
 259             break;
 260
 261         case ACPI_PTYPE1_VAR:
 262         case ACPI_PTYPE2:
 263         case ACPI_PTYPE2_COUNT:
 264         case ACPI_PTYPE2_FIXED:
 265         case ACPI_PTYPE2_MIN:
 266         case ACPI_PTYPE2_FIX_VAR:
 267         case ACPI_PTYPE2_VAR_VAR:
 268         default:
 269
 270             break;
 271         }
 272
 273         return;
 274     }
 275
 276     /* Get the first element of the package */
 277
 278     Op = Op->Asl.Next;
 279
 280     /* Decode the package type */
 281
 282     switch (Package->RetInfo.Type)
 283     {
 284     case ACPI_PTYPE_CUSTOM:
 285
 286         ApCustomPackage (ParentOp, Predefined);
 287         break;
 288
 289     case ACPI_PTYPE1_FIXED:
 290         /*
 291          * The package count is fixed and there are no subpackages
 292          *
 293          * If package is too small, exit.
 294          * If package is larger than expected, issue warning but continue
 295          */
 296         ExpectedCount = Package->RetInfo.Count1 + Package->RetInfo.Count2;
 297         if (Count < ExpectedCount)
 298         {
 299             goto PackageTooSmall;
 300         }
 301         else if (Count > ExpectedCount)
 302         {
 303             ApPackageTooLarge (Predefined->Info.Name, ParentOp,
 304                 Count, ExpectedCount);
 305         }
 306
 307         /* Validate all elements of the package */
 308
 309         ApCheckPackageElements (Predefined->Info.Name, Op,
 310             Package->RetInfo.ObjectType1, Package->RetInfo.Count1,
 311             Package->RetInfo.ObjectType2, Package->RetInfo.Count2);
 312         break;
 313
 314     case ACPI_PTYPE1_VAR:
 315         /*
 316          * The package count is variable, there are no subpackages,
 317          * and all elements must be of the same type
 318          */
 319         for (i = 0; i < Count; i++)
 320         {
 321             ApCheckObjectType (Predefined->Info.Name, Op,
 322                 Package->RetInfo.ObjectType1, i);
 323             Op = Op->Asl.Next;
 324         }
 325         break;
 326
 327     case ACPI_PTYPE1_OPTION:
 328         /*
 329          * The package count is variable, there are no subpackages.
 330          * There are a fixed number of required elements, and a variable
 331          * number of optional elements.
 332          *
 333          * Check if package is at least as large as the minimum required
 334          */
 335         ExpectedCount = Package->RetInfo3.Count;
 336         if (Count < ExpectedCount)
 337         {
 338             goto PackageTooSmall;
 339         }
 340
 341         /* Variable number of sub-objects */
 342
 343         for (i = 0; i < Count; i++)
 344         {
 345             if (i < Package->RetInfo3.Count)
 346             {
 347                 /* These are the required package elements (0, 1, or 2) */
 348
 349                 ApCheckObjectType (Predefined->Info.Name, Op,
 350                     Package->RetInfo3.ObjectType[i], i);
 351             }
 352             else
 353             {
 354                 /* These are the optional package elements */
 355
 356                 ApCheckObjectType (Predefined->Info.Name, Op,
 357                     Package->RetInfo3.TailObjectType, i);
 358             }
 359
 360             Op = Op->Asl.Next;
 361         }
 362         break;
 363
 364     case ACPI_PTYPE2_REV_FIXED:
 365
 366         /* First element is the (Integer) revision */
 367
 368         ApCheckObjectType (Predefined->Info.Name, Op,
 369             ACPI_RTYPE_INTEGER, 0);
 370
 371         Op = Op->Asl.Next;
 372         Count--;
 373
 374         /* Examine the subpackages */
 375
 376         ApCheckPackageList (Predefined->Info.Name, Op,
 377             Package, 1, Count);
 378         break;
 379
 380     case ACPI_PTYPE2_PKG_COUNT:
 381
 382         /* First element is the (Integer) count of subpackages to follow */
 383
 384         Status = ApCheckObjectType (Predefined->Info.Name, Op,
 385             ACPI_RTYPE_INTEGER, 0);
 386
 387         /* We must have an integer count from above (otherwise, use Count) */
 388
 389         if (ACPI_SUCCESS (Status))
 390         {
 391             /*
 392              * Count cannot be larger than the parent package length, but
 393              * allow it to be smaller. The >= accounts for the Integer above.
 394              */
 395             ExpectedCount = (UINT32) Op->Asl.Value.Integer;
 396             if (ExpectedCount >= Count)
 397             {
 398                 goto PackageTooSmall;
 399             }
 400
 401             Count = ExpectedCount;
 402         }
 403
 404         Op = Op->Asl.Next;
 405
 406         /* Examine the subpackages */
 407
 408         ApCheckPackageList (Predefined->Info.Name, Op,
 409             Package, 1, Count);
 410         break;
 411
 412     case ACPI_PTYPE2_UUID_PAIR:
 413
 414         /* The package contains a variable list of UUID Buffer/Package pairs */
 415
 416         /* The length of the package must be even */
 417
 418         if (Count & 1)
 419         {
 420             sprintf (MsgBuffer, "%4.4s: Package length, %d, must be even.",
 421                 Predefined->Info.Name, Count);
 422
 423             AslError (ASL_ERROR, ASL_MSG_RESERVED_PACKAGE_LENGTH,
 424                 ParentOp->Asl.Child, MsgBuffer);
 425         }
 426
 427         /* Validate the alternating types */
 428
 429         for (i = 0; i < Count; ++i)
 430         {
 431             if (i & 1)
 432             {
 433                 ApCheckObjectType (Predefined->Info.Name, Op,
 434                     Package->RetInfo.ObjectType2, i);
 435             }
 436             else
 437             {
 438                 ApCheckObjectType (Predefined->Info.Name, Op,
 439                     Package->RetInfo.ObjectType1, i);
 440             }
 441
 442             Op = Op->Asl.Next;
 443         }
 444
 445         break;
 446
 447     case ACPI_PTYPE2_VAR_VAR:
 448
 449         /* Check for minimum size (ints at beginning + 1 subpackage) */
 450
 451         ExpectedCount = Package->RetInfo4.Count1 + 1;
 452         if (Count < ExpectedCount)
 453         {
 454             goto PackageTooSmall;
 455         }
 456
 457         /* Check the non-package elements at beginning of main package */
 458
 459         for (i = 0; i < Package->RetInfo4.Count1; ++i)
 460         {
 461             Status = ApCheckObjectType (Predefined->Info.Name, Op,
 462                 Package->RetInfo4.ObjectType1, i);
 463             Op = Op->Asl.Next;
 464         }
 465
 466         /* Examine the variable-length list of subpackages */
 467
 468         ApCheckPackageList (Predefined->Info.Name, Op,
 469             Package, Package->RetInfo4.Count1, Count);
 470
 471         break;
 472
 473     case ACPI_PTYPE2:
 474     case ACPI_PTYPE2_FIXED:
 475     case ACPI_PTYPE2_MIN:
 476     case ACPI_PTYPE2_COUNT:
 477     case ACPI_PTYPE2_FIX_VAR:
 478         /*
 479          * These types all return a single Package that consists of a
 480          * variable number of subpackages.
 481          */
 482
 483         /* Examine the subpackages */
 484
 485         ApCheckPackageList (Predefined->Info.Name, Op,
 486             Package, 0, Count);
 487         break;
 488
 489     default:
 490         return;
 491     }
 492
 493     return;
 494
 495 PackageTooSmall:
 496     ApPackageTooSmall (Predefined->Info.Name, ParentOp,
 497         Count, ExpectedCount);
 498 }
 499
 500
 501 /*******************************************************************************
 502  *
 503  * FUNCTION:    ApCustomPackage
 504  *
 505  * PARAMETERS:  ParentOp            - Parse op for the package
 506  *              Predefined          - Pointer to package-specific info for
 507  *                                    the method
 508  *
 509  * RETURN:      None
 510  *
 511  * DESCRIPTION: Validate packages that don't fit into the standard model and
 512  *              require custom code.
 513  *
 514  * NOTE: Currently used for the _BIX method only. When needed for two or more
 515  * methods, probably a detect/dispatch mechanism will be required.
 516  *
 517  ******************************************************************************/
 518
 519 static void
 520 ApCustomPackage (
 521     ACPI_PARSE_OBJECT           *ParentOp,
 522     const ACPI_PREDEFINED_INFO  *Predefined)
 523 {
 524     ACPI_PARSE_OBJECT           *Op;
 525     UINT32                      Count;
 526     UINT32                      ExpectedCount;
 527     UINT32                      Version;
 528
 529
 530     /* First child is the package length */
 531
 532     Op = ParentOp->Asl.Child;
 533     Count = (UINT32) Op->Asl.Value.Integer;
 534
 535     /* Get the version number, must be Integer */
 536
 537     Op = Op->Asl.Next;
 538     Version = (UINT32) Op->Asl.Value.Integer;
 539     if (Op->Asl.ParseOpcode != PARSEOP_INTEGER)
 540     {
 541         AslError (ASL_ERROR, ASL_MSG_RESERVED_OPERAND_TYPE, Op, MsgBuffer);
 542         return;
 543     }
 544
 545     /* Validate count (# of elements) */
 546
 547     ExpectedCount = 21;         /* Version 1 */
 548     if (Version == 0)
 549     {
 550         ExpectedCount = 20;     /* Version 0 */
 551     }
 552
 553     if (Count < ExpectedCount)
 554     {
 555         ApPackageTooSmall (Predefined->Info.Name, ParentOp,
 556             Count, ExpectedCount);
 557         return;
 558     }
 559     else if (Count > ExpectedCount)
 560     {
 561         ApPackageTooLarge (Predefined->Info.Name, ParentOp,
 562             Count, ExpectedCount);
 563     }
 564
 565     /* Validate all elements of the package */
 566
 567     Op = ApCheckPackageElements (Predefined->Info.Name, Op,
 568         ACPI_RTYPE_INTEGER, 16,
 569         ACPI_RTYPE_STRING, 4);
 570
 571     /* Version 1 has a single trailing integer */
 572
 573     if (Version > 0)
 574     {
 575         ApCheckPackageElements (Predefined->Info.Name, Op,
 576             ACPI_RTYPE_INTEGER, 1, 0, 0);
 577     }
 578 }
 579
 580
 581 /*******************************************************************************
 582  *
 583  * FUNCTION:    ApCheckPackageElements
 584  *
 585  * PARAMETERS:  PredefinedName      - Name of the predefined object
 586  *              Op                  - Parser op for the package
 587  *              Type1               - Object type for first group
 588  *              Count1              - Count for first group
 589  *              Type2               - Object type for second group
 590  *              Count2              - Count for second group
 591  *
 592  * RETURN:      Next Op peer in the parse tree, after all specified elements
 593  *              have been validated. Used for multiple validations (calls
 594  *              to this function).
 595  *
 596  * DESCRIPTION: Validate all elements of a package. Works with packages that
 597  *              are defined to contain up to two groups of different object
 598  *              types.
 599  *
 600  ******************************************************************************/
 601
 602 static ACPI_PARSE_OBJECT *
 603 ApCheckPackageElements (
 604     const char              *PredefinedName,
 605     ACPI_PARSE_OBJECT       *Op,
 606     UINT8                   Type1,
 607     UINT32                  Count1,
 608     UINT8                   Type2,
 609     UINT32                  Count2)
 610 {
 611     UINT32                  i;
 612
 613
 614     /*
 615      * Up to two groups of package elements are supported by the data
 616      * structure. All elements in each group must be of the same type.
 617      * The second group can have a count of zero.
 618      *
 619      * Aborts check upon a NULL package element, as this means (at compile
 620      * time) that the remainder of the package elements are also NULL
 621      * (This is the only way to create NULL package elements.)
 622      */
 623     for (i = 0; (i < Count1) && Op; i++)
 624     {
 625         ApCheckObjectType (PredefinedName, Op, Type1, i);
 626         Op = Op->Asl.Next;
 627     }
 628
 629     for (i = 0; (i < Count2) && Op; i++)
 630     {
 631         ApCheckObjectType (PredefinedName, Op, Type2, (i + Count1));
 632         Op = Op->Asl.Next;
 633     }
 634
 635     return (Op);
 636 }
 637
 638
 639 /*******************************************************************************
 640  *
 641  * FUNCTION:    ApCheckPackageList
 642  *
 643  * PARAMETERS:  PredefinedName      - Name of the predefined object
 644  *              ParentOp            - Parser op of the parent package
 645  *              Package             - Package info for this predefined name
 646  *              StartIndex          - Index in parent package where list begins
 647  *              ParentCount         - Element count of parent package
 648  *
 649  * RETURN:      None
 650  *
 651  * DESCRIPTION: Validate the individual package elements for a predefined name.
 652  *              Handles the cases where the predefined name is defined as a
 653  *              Package of Packages (subpackages). These are the types:
 654  *
 655  *              ACPI_PTYPE2
 656  *              ACPI_PTYPE2_FIXED
 657  *              ACPI_PTYPE2_MIN
 658  *              ACPI_PTYPE2_COUNT
 659  *              ACPI_PTYPE2_FIX_VAR
 660  *              ACPI_PTYPE2_VAR_VAR
 661  *
 662  ******************************************************************************/
 663
 664 static void
 665 ApCheckPackageList (
 666     const char                  *PredefinedName,
 667     ACPI_PARSE_OBJECT           *ParentOp,
 668     const ACPI_PREDEFINED_INFO  *Package,
 669     UINT32                      StartIndex,
 670     UINT32                      ParentCount)
 671 {
 672     ACPI_PARSE_OBJECT           *SubPackageOp = ParentOp;
 673     ACPI_PARSE_OBJECT           *Op;
 674     ACPI_STATUS                 Status;
 675     UINT32                      Count;
 676     UINT32                      ExpectedCount;
 677     UINT32                      i;
 678     UINT32                      j;
 679
 680
 681     /*
 682      * Validate each subpackage in the parent Package
 683      *
 684      * Note: We ignore NULL package elements on the assumption that
 685      * they will be initialized by the BIOS or other ASL code.
 686      */
 687     for (i = 0; (i < ParentCount) && SubPackageOp; i++)
 688     {
 689         /* Each object in the list must be of type Package */
 690
 691         Status = ApCheckObjectType (PredefinedName, SubPackageOp,
 692             ACPI_RTYPE_PACKAGE, i + StartIndex);
 693         if (ACPI_FAILURE (Status))
 694         {
 695             goto NextSubpackage;
 696         }
 697
 698         /* Examine the different types of expected subpackages */
 699
 700         Op = SubPackageOp->Asl.Child;
 701
 702         /* First child is the package length */
 703
 704         Count = (UINT32) Op->Asl.Value.Integer;
 705         Op = Op->Asl.Next;
 706
 707         /*
 708          * Most subpackage must have at least one element, with
 709          * only rare exceptions. (_RDI)
 710          */
 711         if (!Count &&
 712             (Package->RetInfo.Type != ACPI_PTYPE2_VAR_VAR))
 713         {
 714             ApZeroLengthPackage (PredefinedName, SubPackageOp);
 715             goto NextSubpackage;
 716         }
 717
 718         /*
 719          * Decode the package type.
 720          * PTYPE2 indicates that a "package of packages" is expected for
 721          * this name. The various flavors of PTYPE2 indicate the number
 722          * and format of the subpackages.
 723          */
 724         switch (Package->RetInfo.Type)
 725         {
 726         case ACPI_PTYPE2:
 727         case ACPI_PTYPE2_PKG_COUNT:
 728         case ACPI_PTYPE2_REV_FIXED:
 729
 730             /* Each subpackage has a fixed number of elements */
 731
 732             ExpectedCount = Package->RetInfo.Count1 + Package->RetInfo.Count2;
 733             if (Count < ExpectedCount)
 734             {
 735                 ApPackageTooSmall (PredefinedName, SubPackageOp,
 736                     Count, ExpectedCount);
 737                 break;
 738             }
 739             if (Count > ExpectedCount)
 740             {
 741                 ApPackageTooLarge (PredefinedName, SubPackageOp,
 742                     Count, ExpectedCount);
 743                 break;
 744             }
 745
 746             ApCheckPackageElements (PredefinedName, Op,
 747                 Package->RetInfo.ObjectType1, Package->RetInfo.Count1,
 748                 Package->RetInfo.ObjectType2, Package->RetInfo.Count2);
 749             break;
 750
 751         case ACPI_PTYPE2_FIX_VAR:
 752             /*
 753              * Each subpackage has a fixed number of elements and an
 754              * optional element
 755              */
 756             ExpectedCount = Package->RetInfo.Count1 + Package->RetInfo.Count2;
 757             if (Count < ExpectedCount)
 758             {
 759                 ApPackageTooSmall (PredefinedName, SubPackageOp,
 760                     Count, ExpectedCount);
 761                 break;
 762             }
 763
 764             ApCheckPackageElements (PredefinedName, Op,
 765                 Package->RetInfo.ObjectType1, Package->RetInfo.Count1,
 766                 Package->RetInfo.ObjectType2,
 767                 Count - Package->RetInfo.Count1);
 768             break;
 769
 770         case ACPI_PTYPE2_VAR_VAR:
 771             /*
 772              * Must have at least the minimum number elements.
 773              * A zero PkgCount means the number of elements is variable.
 774              */
 775             ExpectedCount = Package->RetInfo4.PkgCount;
 776             if (ExpectedCount && (Count < ExpectedCount))
 777             {
 778                 ApPackageTooSmall (PredefinedName, SubPackageOp,
 779                     Count, 1);
 780                 break;
 781             }
 782
 783             ApCheckPackageElements (PredefinedName, Op,
 784                 Package->RetInfo4.SubObjectTypes,
 785                 Package->RetInfo4.PkgCount,
 786                 0, 0);
 787             break;
 788
 789         case ACPI_PTYPE2_FIXED:
 790
 791             /* Each subpackage has a fixed length */
 792
 793             ExpectedCount = Package->RetInfo2.Count;
 794             if (Count < ExpectedCount)
 795             {
 796                 ApPackageTooSmall (PredefinedName, SubPackageOp,
 797                     Count, ExpectedCount);
 798                 break;
 799             }
 800             if (Count > ExpectedCount)
 801             {
 802                 ApPackageTooLarge (PredefinedName, SubPackageOp,
 803                     Count, ExpectedCount);
 804                 break;
 805             }
 806
 807             /* Check each object/type combination */
 808
 809             for (j = 0; j < ExpectedCount; j++)
 810             {
 811                 ApCheckObjectType (PredefinedName, Op,
 812                     Package->RetInfo2.ObjectType[j], j);
 813
 814                 Op = Op->Asl.Next;
 815             }
 816             break;
 817
 818         case ACPI_PTYPE2_MIN:
 819
 820             /* Each subpackage has a variable but minimum length */
 821
 822             ExpectedCount = Package->RetInfo.Count1;
 823             if (Count < ExpectedCount)
 824             {
 825                 ApPackageTooSmall (PredefinedName, SubPackageOp,
 826                     Count, ExpectedCount);
 827                 break;
 828             }
 829
 830             /* Check the type of each subpackage element */
 831
 832             ApCheckPackageElements (PredefinedName, Op,
 833                 Package->RetInfo.ObjectType1, Count, 0, 0);
 834             break;
 835
 836         case ACPI_PTYPE2_COUNT:
 837             /*
 838              * First element is the (Integer) count of elements, including
 839              * the count field (the ACPI name is NumElements)
 840              */
 841             Status = ApCheckObjectType (PredefinedName, Op,
 842                 ACPI_RTYPE_INTEGER, 0);
 843
 844             /* We must have an integer count from above (otherwise, use Count) */
 845
 846             if (ACPI_SUCCESS (Status))
 847             {
 848                 /*
 849                  * Make sure package is large enough for the Count and is
 850                  * is as large as the minimum size
 851                  */
 852                 ExpectedCount = (UINT32) Op->Asl.Value.Integer;
 853
 854                 if (Count < ExpectedCount)
 855                 {
 856                     ApPackageTooSmall (PredefinedName, SubPackageOp,
 857                         Count, ExpectedCount);
 858                     break;
 859                 }
 860                 else if (Count > ExpectedCount)
 861                 {
 862                     ApPackageTooLarge (PredefinedName, SubPackageOp,
 863                         Count, ExpectedCount);
 864                 }
 865
 866                 /* Some names of this type have a minimum length */
 867
 868                 if (Count < Package->RetInfo.Count1)
 869                 {
 870                     ExpectedCount = Package->RetInfo.Count1;
 871                     ApPackageTooSmall (PredefinedName, SubPackageOp,
 872                         Count, ExpectedCount);
 873                     break;
 874                 }
 875
 876                 Count = ExpectedCount;
 877             }
 878
 879             /* Check the type of each subpackage element */
 880
 881             Op = Op->Asl.Next;
 882             ApCheckPackageElements (PredefinedName, Op,
 883                 Package->RetInfo.ObjectType1, (Count - 1), 0, 0);
 884             break;
 885
 886         default:
 887             break;
 888         }
 889
 890 NextSubpackage:
 891         SubPackageOp = SubPackageOp->Asl.Next;
 892     }
 893 }
 894
 895
 896 /*******************************************************************************
 897  *
 898  * FUNCTION:    ApPackageTooSmall
 899  *
 900  * PARAMETERS:  PredefinedName      - Name of the predefined object
 901  *              Op                  - Current parser op
 902  *              Count               - Actual package element count
 903  *              ExpectedCount       - Expected package element count
 904  *
 905  * RETURN:      None
 906  *
 907  * DESCRIPTION: Issue error message for a package that is smaller than
 908  *              required.
 909  *
 910  ******************************************************************************/
 911
 912 static void
 913 ApPackageTooSmall (
 914     const char                  *PredefinedName,
 915     ACPI_PARSE_OBJECT           *Op,
 916     UINT32                      Count,
 917     UINT32                      ExpectedCount)
 918 {
 919
 920     sprintf (MsgBuffer, "%s: length %u, required minimum is %u",
 921         PredefinedName, Count, ExpectedCount);
 922
 923     AslError (ASL_ERROR, ASL_MSG_RESERVED_PACKAGE_LENGTH, Op, MsgBuffer);
 924 }
 925
 926
 927 /*******************************************************************************
 928  *
 929  * FUNCTION:    ApZeroLengthPackage
 930  *
 931  * PARAMETERS:  PredefinedName      - Name of the predefined object
 932  *              Op                  - Current parser op
 933  *
 934  * RETURN:      None
 935  *
 936  * DESCRIPTION: Issue error message for a zero-length package (a package that
 937  *              is required to have a non-zero length). Variable length
 938  *              packages seem to be allowed to have zero length, however.
 939  *              Even if not allowed, BIOS code does it.
 940  *
 941  ******************************************************************************/
 942
 943 static void
 944 ApZeroLengthPackage (
 945     const char                  *PredefinedName,
 946     ACPI_PARSE_OBJECT           *Op)
 947 {
 948
 949     sprintf (MsgBuffer, "%s: length is zero", PredefinedName);
 950
 951     AslError (ASL_ERROR, ASL_MSG_RESERVED_PACKAGE_LENGTH, Op, MsgBuffer);
 952 }
 953
 954
 955 /*******************************************************************************
 956  *
 957  * FUNCTION:    ApPackageTooLarge
 958  *
 959  * PARAMETERS:  PredefinedName      - Name of the predefined object
 960  *              Op                  - Current parser op
 961  *              Count               - Actual package element count
 962  *              ExpectedCount       - Expected package element count
 963  *
 964  * RETURN:      None
 965  *
 966  * DESCRIPTION: Issue a remark for a package that is larger than expected.
 967  *
 968  ******************************************************************************/
 969
 970 static void
 971 ApPackageTooLarge (
 972     const char                  *PredefinedName,
 973     ACPI_PARSE_OBJECT           *Op,
 974     UINT32                      Count,
 975     UINT32                      ExpectedCount)
 976 {
 977
 978     sprintf (MsgBuffer, "%s: length is %u, only %u required",
 979         PredefinedName, Count, ExpectedCount);
 980
 981     AslError (ASL_REMARK, ASL_MSG_RESERVED_PACKAGE_LENGTH, Op, MsgBuffer);
 982 }