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

   1 /******************************************************************************
   2  *
   3  * Module Name: aslprepkg - support for ACPI predefined name package objects
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2015, 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 #include <contrib/dev/acpica/compiler/aslcompiler.h>
  45 #include "aslcompiler.y.h"
  46 #include <contrib/dev/acpica/include/acpredef.h>
  47
  48
  49 #define _COMPONENT          ACPI_COMPILER
  50         ACPI_MODULE_NAME    ("aslprepkg")
  51
  52
  53 /* Local prototypes */
  54
  55 static void
  56 ApCheckPackageElements (
  57     const char                  *PredefinedName,
  58     ACPI_PARSE_OBJECT           *Op,
  59     UINT8                       Type1,
  60     UINT32                      Count1,
  61     UINT8                       Type2,
  62     UINT32                      Count2);
  63
  64 static void
  65 ApCheckPackageList (
  66     const char                  *PredefinedName,
  67     ACPI_PARSE_OBJECT           *ParentOp,
  68     const ACPI_PREDEFINED_INFO  *Package,
  69     UINT32                      StartIndex,
  70     UINT32                      Count);
  71
  72 static void
  73 ApPackageTooSmall (
  74     const char                  *PredefinedName,
  75     ACPI_PARSE_OBJECT           *Op,
  76     UINT32                      Count,
  77     UINT32                      ExpectedCount);
  78
  79 static void
  80 ApZeroLengthPackage (
  81     const char                  *PredefinedName,
  82     ACPI_PARSE_OBJECT           *Op);
  83
  84 static void
  85 ApPackageTooLarge (
  86     const char                  *PredefinedName,
  87     ACPI_PARSE_OBJECT           *Op,
  88     UINT32                      Count,
  89     UINT32                      ExpectedCount);
  90
  91
  92 /*******************************************************************************
  93  *
  94  * FUNCTION:    ApCheckPackage
  95  *
  96  * PARAMETERS:  ParentOp            - Parser op for the package
  97  *              Predefined          - Pointer to package-specific info for
  98  *                                    the method
  99  *
 100  * RETURN:      None
 101  *
 102  * DESCRIPTION: Top-level validation for predefined name return package
 103  *              objects.
 104  *
 105  ******************************************************************************/
 106
 107 void
 108 ApCheckPackage (
 109     ACPI_PARSE_OBJECT           *ParentOp,
 110     const ACPI_PREDEFINED_INFO  *Predefined)
 111 {
 112     ACPI_PARSE_OBJECT           *Op;
 113     const ACPI_PREDEFINED_INFO  *Package;
 114     ACPI_STATUS                 Status;
 115     UINT32                      ExpectedCount;
 116     UINT32                      Count;
 117     UINT32                      i;
 118
 119
 120     /* The package info for this name is in the next table entry */
 121
 122     Package = Predefined + 1;
 123
 124     /* First child is the package length */
 125
 126     Op = ParentOp->Asl.Child;
 127     Count = (UINT32) Op->Asl.Value.Integer;
 128
 129     /*
 130      * Many of the variable-length top-level packages are allowed to simply
 131      * have zero elements. This allows the BIOS to tell the host that even
 132      * though the predefined name/method exists, the feature is not supported.
 133      * Other package types require one or more elements. In any case, there
 134      * is no need to continue validation.
 135      */
 136     if (!Count)
 137     {
 138         switch (Package->RetInfo.Type)
 139         {
 140         case ACPI_PTYPE1_FIXED:
 141         case ACPI_PTYPE1_OPTION:
 142         case ACPI_PTYPE2_PKG_COUNT:
 143         case ACPI_PTYPE2_REV_FIXED:
 144
 145             ApZeroLengthPackage (Predefined->Info.Name, ParentOp);
 146             break;
 147
 148         case ACPI_PTYPE1_VAR:
 149         case ACPI_PTYPE2:
 150         case ACPI_PTYPE2_COUNT:
 151         case ACPI_PTYPE2_FIXED:
 152         case ACPI_PTYPE2_MIN:
 153         case ACPI_PTYPE2_FIX_VAR:
 154         case ACPI_PTYPE2_VAR_VAR:
 155         default:
 156
 157             break;
 158         }
 159
 160         return;
 161     }
 162
 163     /* Get the first element of the package */
 164
 165     Op = Op->Asl.Next;
 166
 167     /* Decode the package type */
 168
 169     switch (Package->RetInfo.Type)
 170     {
 171     case ACPI_PTYPE1_FIXED:
 172         /*
 173          * The package count is fixed and there are no subpackages
 174          *
 175          * If package is too small, exit.
 176          * If package is larger than expected, issue warning but continue
 177          */
 178         ExpectedCount = Package->RetInfo.Count1 + Package->RetInfo.Count2;
 179         if (Count < ExpectedCount)
 180         {
 181             goto PackageTooSmall;
 182         }
 183         else if (Count > ExpectedCount)
 184         {
 185             ApPackageTooLarge (Predefined->Info.Name, ParentOp,
 186                 Count, ExpectedCount);
 187         }
 188
 189         /* Validate all elements of the package */
 190
 191         ApCheckPackageElements (Predefined->Info.Name, Op,
 192             Package->RetInfo.ObjectType1, Package->RetInfo.Count1,
 193             Package->RetInfo.ObjectType2, Package->RetInfo.Count2);
 194         break;
 195
 196     case ACPI_PTYPE1_VAR:
 197         /*
 198          * The package count is variable, there are no subpackages,
 199          * and all elements must be of the same type
 200          */
 201         for (i = 0; i < Count; i++)
 202         {
 203             ApCheckObjectType (Predefined->Info.Name, Op,
 204                 Package->RetInfo.ObjectType1, i);
 205             Op = Op->Asl.Next;
 206         }
 207         break;
 208
 209     case ACPI_PTYPE1_OPTION:
 210         /*
 211          * The package count is variable, there are no subpackages.
 212          * There are a fixed number of required elements, and a variable
 213          * number of optional elements.
 214          *
 215          * Check if package is at least as large as the minimum required
 216          */
 217         ExpectedCount = Package->RetInfo3.Count;
 218         if (Count < ExpectedCount)
 219         {
 220             goto PackageTooSmall;
 221         }
 222
 223         /* Variable number of sub-objects */
 224
 225         for (i = 0; i < Count; i++)
 226         {
 227             if (i < Package->RetInfo3.Count)
 228             {
 229                 /* These are the required package elements (0, 1, or 2) */
 230
 231                 ApCheckObjectType (Predefined->Info.Name, Op,
 232                     Package->RetInfo3.ObjectType[i], i);
 233             }
 234             else
 235             {
 236                 /* These are the optional package elements */
 237
 238                 ApCheckObjectType (Predefined->Info.Name, Op,
 239                     Package->RetInfo3.TailObjectType, i);
 240             }
 241             Op = Op->Asl.Next;
 242         }
 243         break;
 244
 245     case ACPI_PTYPE2_REV_FIXED:
 246
 247         /* First element is the (Integer) revision */
 248
 249         ApCheckObjectType (Predefined->Info.Name, Op,
 250             ACPI_RTYPE_INTEGER, 0);
 251
 252         Op = Op->Asl.Next;
 253         Count--;
 254
 255         /* Examine the subpackages */
 256
 257         ApCheckPackageList (Predefined->Info.Name, Op,
 258             Package, 1, Count);
 259         break;
 260
 261     case ACPI_PTYPE2_PKG_COUNT:
 262
 263         /* First element is the (Integer) count of subpackages to follow */
 264
 265         Status = ApCheckObjectType (Predefined->Info.Name, Op,
 266             ACPI_RTYPE_INTEGER, 0);
 267
 268         /* We must have an integer count from above (otherwise, use Count) */
 269
 270         if (ACPI_SUCCESS (Status))
 271         {
 272             /*
 273              * Count cannot be larger than the parent package length, but
 274              * allow it to be smaller. The >= accounts for the Integer above.
 275              */
 276             ExpectedCount = (UINT32) Op->Asl.Value.Integer;
 277             if (ExpectedCount >= Count)
 278             {
 279                 goto PackageTooSmall;
 280             }
 281
 282             Count = ExpectedCount;
 283         }
 284
 285         Op = Op->Asl.Next;
 286
 287         /* Examine the subpackages */
 288
 289         ApCheckPackageList (Predefined->Info.Name, Op,
 290             Package, 1, Count);
 291         break;
 292
 293     case ACPI_PTYPE2_UUID_PAIR:
 294
 295         /* The package contains a variable list of UUID Buffer/Package pairs */
 296
 297         /* The length of the package must be even */
 298
 299         if (Count & 1)
 300         {
 301             sprintf (MsgBuffer, "%4.4s: Package length, %d, must be even.",
 302                 Predefined->Info.Name, Count);
 303
 304             AslError (ASL_ERROR, ASL_MSG_RESERVED_PACKAGE_LENGTH,
 305                 ParentOp->Asl.Child, MsgBuffer);
 306         }
 307
 308         /* Validate the alternating types */
 309
 310         for (i = 0; i < Count; ++i)
 311         {
 312             if (i & 1)
 313             {
 314                 ApCheckObjectType (Predefined->Info.Name, Op,
 315                     Package->RetInfo.ObjectType2, i);
 316             }
 317             else
 318             {
 319                 ApCheckObjectType (Predefined->Info.Name, Op,
 320                     Package->RetInfo.ObjectType1, i);
 321             }
 322
 323             Op = Op->Asl.Next;
 324         }
 325
 326         break;
 327
 328     case ACPI_PTYPE2_VAR_VAR:
 329
 330         /* Check for minimum size (ints at beginning + 1 subpackage) */
 331
 332         ExpectedCount = Package->RetInfo4.Count1 + 1;
 333         if (Count < ExpectedCount)
 334         {
 335             goto PackageTooSmall;
 336         }
 337
 338         /* Check the non-package elements at beginning of main package */
 339
 340         for (i = 0; i < Package->RetInfo4.Count1; ++i)
 341         {
 342             Status = ApCheckObjectType (Predefined->Info.Name, Op,
 343                 Package->RetInfo4.ObjectType1, i);
 344             Op = Op->Asl.Next;
 345         }
 346
 347         /* Examine the variable-length list of subpackages */
 348
 349         ApCheckPackageList (Predefined->Info.Name, Op,
 350             Package, Package->RetInfo4.Count1, Count);
 351
 352         break;
 353
 354     case ACPI_PTYPE2:
 355     case ACPI_PTYPE2_FIXED:
 356     case ACPI_PTYPE2_MIN:
 357     case ACPI_PTYPE2_COUNT:
 358     case ACPI_PTYPE2_FIX_VAR:
 359         /*
 360          * These types all return a single Package that consists of a
 361          * variable number of subpackages.
 362          */
 363
 364         /* Examine the subpackages */
 365
 366         ApCheckPackageList (Predefined->Info.Name, Op,
 367             Package, 0, Count);
 368         break;
 369
 370     default:
 371         return;
 372     }
 373
 374     return;
 375
 376 PackageTooSmall:
 377     ApPackageTooSmall (Predefined->Info.Name, ParentOp,
 378         Count, ExpectedCount);
 379 }
 380
 381
 382 /*******************************************************************************
 383  *
 384  * FUNCTION:    ApCheckPackageElements
 385  *
 386  * PARAMETERS:  PredefinedName      - Name of the predefined object
 387  *              Op                  - Parser op for the package
 388  *              Type1               - Object type for first group
 389  *              Count1              - Count for first group
 390  *              Type2               - Object type for second group
 391  *              Count2              - Count for second group
 392  *
 393  * RETURN:      None
 394  *
 395  * DESCRIPTION: Validate all elements of a package. Works with packages that
 396  *              are defined to contain up to two groups of different object
 397  *              types.
 398  *
 399  ******************************************************************************/
 400
 401 static void
 402 ApCheckPackageElements (
 403     const char              *PredefinedName,
 404     ACPI_PARSE_OBJECT       *Op,
 405     UINT8                   Type1,
 406     UINT32                  Count1,
 407     UINT8                   Type2,
 408     UINT32                  Count2)
 409 {
 410     UINT32                  i;
 411
 412
 413     /*
 414      * Up to two groups of package elements are supported by the data
 415      * structure. All elements in each group must be of the same type.
 416      * The second group can have a count of zero.
 417      *
 418      * Aborts check upon a NULL package element, as this means (at compile
 419      * time) that the remainder of the package elements are also NULL
 420      * (This is the only way to create NULL package elements.)
 421      */
 422     for (i = 0; (i < Count1) && Op; i++)
 423     {
 424         ApCheckObjectType (PredefinedName, Op, Type1, i);
 425         Op = Op->Asl.Next;
 426     }
 427
 428     for (i = 0; (i < Count2) && Op; i++)
 429     {
 430         ApCheckObjectType (PredefinedName, Op, Type2, (i + Count1));
 431         Op = Op->Asl.Next;
 432     }
 433 }
 434
 435
 436 /*******************************************************************************
 437  *
 438  * FUNCTION:    ApCheckPackageList
 439  *
 440  * PARAMETERS:  PredefinedName      - Name of the predefined object
 441  *              ParentOp            - Parser op of the parent package
 442  *              Package             - Package info for this predefined name
 443  *              StartIndex          - Index in parent package where list begins
 444  *              ParentCount         - Element count of parent package
 445  *
 446  * RETURN:      None
 447  *
 448  * DESCRIPTION: Validate the individual package elements for a predefined name.
 449  *              Handles the cases where the predefined name is defined as a
 450  *              Package of Packages (subpackages). These are the types:
 451  *
 452  *              ACPI_PTYPE2
 453  *              ACPI_PTYPE2_FIXED
 454  *              ACPI_PTYPE2_MIN
 455  *              ACPI_PTYPE2_COUNT
 456  *              ACPI_PTYPE2_FIX_VAR
 457  *              ACPI_PTYPE2_VAR_VAR
 458  *
 459  ******************************************************************************/
 460
 461 static void
 462 ApCheckPackageList (
 463     const char                  *PredefinedName,
 464     ACPI_PARSE_OBJECT           *ParentOp,
 465     const ACPI_PREDEFINED_INFO  *Package,
 466     UINT32                      StartIndex,
 467     UINT32                      ParentCount)
 468 {
 469     ACPI_PARSE_OBJECT           *SubPackageOp = ParentOp;
 470     ACPI_PARSE_OBJECT           *Op;
 471     ACPI_STATUS                 Status;
 472     UINT32                      Count;
 473     UINT32                      ExpectedCount;
 474     UINT32                      i;
 475     UINT32                      j;
 476
 477
 478     /*
 479      * Validate each subpackage in the parent Package
 480      *
 481      * Note: We ignore NULL package elements on the assumption that
 482      * they will be initialized by the BIOS or other ASL code.
 483      */
 484     for (i = 0; (i < ParentCount) && SubPackageOp; i++)
 485     {
 486         /* Each object in the list must be of type Package */
 487
 488         Status = ApCheckObjectType (PredefinedName, SubPackageOp,
 489             ACPI_RTYPE_PACKAGE, i + StartIndex);
 490         if (ACPI_FAILURE (Status))
 491         {
 492             goto NextSubpackage;
 493         }
 494
 495         /* Examine the different types of expected subpackages */
 496
 497         Op = SubPackageOp->Asl.Child;
 498
 499         /* First child is the package length */
 500
 501         Count = (UINT32) Op->Asl.Value.Integer;
 502         Op = Op->Asl.Next;
 503
 504         /*
 505          * Most subpackage must have at least one element, with
 506          * only rare exceptions. (_RDI)
 507          */
 508         if (!Count &&
 509             (Package->RetInfo.Type != ACPI_PTYPE2_VAR_VAR))
 510         {
 511             ApZeroLengthPackage (PredefinedName, SubPackageOp);
 512             goto NextSubpackage;
 513         }
 514
 515         /*
 516          * Decode the package type.
 517          * PTYPE2 indicates that a "package of packages" is expected for
 518          * this name. The various flavors of PTYPE2 indicate the number
 519          * and format of the subpackages.
 520          */
 521         switch (Package->RetInfo.Type)
 522         {
 523         case ACPI_PTYPE2:
 524         case ACPI_PTYPE2_PKG_COUNT:
 525         case ACPI_PTYPE2_REV_FIXED:
 526
 527             /* Each subpackage has a fixed number of elements */
 528
 529             ExpectedCount = Package->RetInfo.Count1 + Package->RetInfo.Count2;
 530             if (Count < ExpectedCount)
 531             {
 532                 ApPackageTooSmall (PredefinedName, SubPackageOp,
 533                     Count, ExpectedCount);
 534                 break;
 535             }
 536             if (Count > ExpectedCount)
 537             {
 538                 ApPackageTooLarge (PredefinedName, SubPackageOp,
 539                     Count, ExpectedCount);
 540                 break;
 541             }
 542
 543             ApCheckPackageElements (PredefinedName, Op,
 544                 Package->RetInfo.ObjectType1, Package->RetInfo.Count1,
 545                 Package->RetInfo.ObjectType2, Package->RetInfo.Count2);
 546             break;
 547
 548         case ACPI_PTYPE2_FIX_VAR:
 549             /*
 550              * Each subpackage has a fixed number of elements and an
 551              * optional element
 552              */
 553             ExpectedCount = Package->RetInfo.Count1 + Package->RetInfo.Count2;
 554             if (Count < ExpectedCount)
 555             {
 556                 ApPackageTooSmall (PredefinedName, SubPackageOp,
 557                     Count, ExpectedCount);
 558                 break;
 559             }
 560
 561             ApCheckPackageElements (PredefinedName, Op,
 562                 Package->RetInfo.ObjectType1, Package->RetInfo.Count1,
 563                 Package->RetInfo.ObjectType2,
 564                 Count - Package->RetInfo.Count1);
 565             break;
 566
 567         case ACPI_PTYPE2_VAR_VAR:
 568             /*
 569              * Must have at least the minimum number elements.
 570              * A zero PkgCount means the number of elements is variable.
 571              */
 572             ExpectedCount = Package->RetInfo4.PkgCount;
 573             if (ExpectedCount && (Count < ExpectedCount))
 574             {
 575                 ApPackageTooSmall (PredefinedName, SubPackageOp,
 576                     Count, 1);
 577                 break;
 578             }
 579
 580             ApCheckPackageElements (PredefinedName, Op,
 581                 Package->RetInfo4.SubObjectTypes,
 582                 Package->RetInfo4.PkgCount,
 583                 0, 0);
 584             break;
 585
 586         case ACPI_PTYPE2_FIXED:
 587
 588             /* Each subpackage has a fixed length */
 589
 590             ExpectedCount = Package->RetInfo2.Count;
 591             if (Count < ExpectedCount)
 592             {
 593                 ApPackageTooSmall (PredefinedName, SubPackageOp,
 594                     Count, ExpectedCount);
 595                 break;
 596             }
 597             if (Count > ExpectedCount)
 598             {
 599                 ApPackageTooLarge (PredefinedName, SubPackageOp,
 600                     Count, ExpectedCount);
 601                 break;
 602             }
 603
 604             /* Check each object/type combination */
 605
 606             for (j = 0; j < ExpectedCount; j++)
 607             {
 608                 ApCheckObjectType (PredefinedName, Op,
 609                     Package->RetInfo2.ObjectType[j], j);
 610
 611                 Op = Op->Asl.Next;
 612             }
 613             break;
 614
 615         case ACPI_PTYPE2_MIN:
 616
 617             /* Each subpackage has a variable but minimum length */
 618
 619             ExpectedCount = Package->RetInfo.Count1;
 620             if (Count < ExpectedCount)
 621             {
 622                 ApPackageTooSmall (PredefinedName, SubPackageOp,
 623                     Count, ExpectedCount);
 624                 break;
 625             }
 626
 627             /* Check the type of each subpackage element */
 628
 629             ApCheckPackageElements (PredefinedName, Op,
 630                 Package->RetInfo.ObjectType1, Count, 0, 0);
 631             break;
 632
 633         case ACPI_PTYPE2_COUNT:
 634             /*
 635              * First element is the (Integer) count of elements, including
 636              * the count field (the ACPI name is NumElements)
 637              */
 638             Status = ApCheckObjectType (PredefinedName, Op,
 639                 ACPI_RTYPE_INTEGER, 0);
 640
 641             /* We must have an integer count from above (otherwise, use Count) */
 642
 643             if (ACPI_SUCCESS (Status))
 644             {
 645                 /*
 646                  * Make sure package is large enough for the Count and is
 647                  * is as large as the minimum size
 648                  */
 649                 ExpectedCount = (UINT32) Op->Asl.Value.Integer;
 650
 651                 if (Count < ExpectedCount)
 652                 {
 653                     ApPackageTooSmall (PredefinedName, SubPackageOp,
 654                         Count, ExpectedCount);
 655                     break;
 656                 }
 657                 else if (Count > ExpectedCount)
 658                 {
 659                     ApPackageTooLarge (PredefinedName, SubPackageOp,
 660                         Count, ExpectedCount);
 661                 }
 662
 663                 /* Some names of this type have a minimum length */
 664
 665                 if (Count < Package->RetInfo.Count1)
 666                 {
 667                     ExpectedCount = Package->RetInfo.Count1;
 668                     ApPackageTooSmall (PredefinedName, SubPackageOp,
 669                         Count, ExpectedCount);
 670                     break;
 671                 }
 672
 673                 Count = ExpectedCount;
 674             }
 675
 676             /* Check the type of each subpackage element */
 677
 678             Op = Op->Asl.Next;
 679             ApCheckPackageElements (PredefinedName, Op,
 680                 Package->RetInfo.ObjectType1, (Count - 1), 0, 0);
 681             break;
 682
 683         default:
 684             break;
 685         }
 686
 687 NextSubpackage:
 688         SubPackageOp = SubPackageOp->Asl.Next;
 689     }
 690 }
 691
 692
 693 /*******************************************************************************
 694  *
 695  * FUNCTION:    ApPackageTooSmall
 696  *
 697  * PARAMETERS:  PredefinedName      - Name of the predefined object
 698  *              Op                  - Current parser op
 699  *              Count               - Actual package element count
 700  *              ExpectedCount       - Expected package element count
 701  *
 702  * RETURN:      None
 703  *
 704  * DESCRIPTION: Issue error message for a package that is smaller than
 705  *              required.
 706  *
 707  ******************************************************************************/
 708
 709 static void
 710 ApPackageTooSmall (
 711     const char                  *PredefinedName,
 712     ACPI_PARSE_OBJECT           *Op,
 713     UINT32                      Count,
 714     UINT32                      ExpectedCount)
 715 {
 716
 717     sprintf (MsgBuffer, "%s: length %u, required minimum is %u",
 718         PredefinedName, Count, ExpectedCount);
 719
 720     AslError (ASL_ERROR, ASL_MSG_RESERVED_PACKAGE_LENGTH, Op, MsgBuffer);
 721 }
 722
 723
 724 /*******************************************************************************
 725  *
 726  * FUNCTION:    ApZeroLengthPackage
 727  *
 728  * PARAMETERS:  PredefinedName      - Name of the predefined object
 729  *              Op                  - Current parser op
 730  *
 731  * RETURN:      None
 732  *
 733  * DESCRIPTION: Issue error message for a zero-length package (a package that
 734  *              is required to have a non-zero length). Variable length
 735  *              packages seem to be allowed to have zero length, however.
 736  *              Even if not allowed, BIOS code does it.
 737  *
 738  ******************************************************************************/
 739
 740 static void
 741 ApZeroLengthPackage (
 742     const char                  *PredefinedName,
 743     ACPI_PARSE_OBJECT           *Op)
 744 {
 745
 746     sprintf (MsgBuffer, "%s: length is zero", PredefinedName);
 747
 748     AslError (ASL_ERROR, ASL_MSG_RESERVED_PACKAGE_LENGTH, Op, MsgBuffer);
 749 }
 750
 751
 752 /*******************************************************************************
 753  *
 754  * FUNCTION:    ApPackageTooLarge
 755  *
 756  * PARAMETERS:  PredefinedName      - Name of the predefined object
 757  *              Op                  - Current parser op
 758  *              Count               - Actual package element count
 759  *              ExpectedCount       - Expected package element count
 760  *
 761  * RETURN:      None
 762  *
 763  * DESCRIPTION: Issue a remark for a package that is larger than expected.
 764  *
 765  ******************************************************************************/
 766
 767 static void
 768 ApPackageTooLarge (
 769     const char                  *PredefinedName,
 770     ACPI_PARSE_OBJECT           *Op,
 771     UINT32                      Count,
 772     UINT32                      ExpectedCount)
 773 {
 774
 775     sprintf (MsgBuffer, "%s: length is %u, only %u required",
 776         PredefinedName, Count, ExpectedCount);
 777
 778     AslError (ASL_REMARK, ASL_MSG_RESERVED_PACKAGE_LENGTH, Op, MsgBuffer);
 779 }