arch/all-pc/acpica/source/compiler/aslprepkg.c

   1 /******************************************************************************
   2  *
   3  * Module Name: aslprepkg - support for ACPI predefined name package objects
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2013, 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 "aslcompiler.h"
  45 #include "aslcompiler.y.h"
  46 #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         default:
 155
 156             break;
 157         }
 158
 159         return;
 160     }
 161
 162     /* Get the first element of the package */
 163
 164     Op = Op->Asl.Next;
 165
 166     /* Decode the package type */
 167
 168     switch (Package->RetInfo.Type)
 169     {
 170     case ACPI_PTYPE1_FIXED:
 171         /*
 172          * The package count is fixed and there are no sub-packages
 173          *
 174          * If package is too small, exit.
 175          * If package is larger than expected, issue warning but continue
 176          */
 177         ExpectedCount = Package->RetInfo.Count1 + Package->RetInfo.Count2;
 178         if (Count < ExpectedCount)
 179         {
 180             goto PackageTooSmall;
 181         }
 182         else if (Count > ExpectedCount)
 183         {
 184             ApPackageTooLarge (Predefined->Info.Name, ParentOp,
 185                 Count, ExpectedCount);
 186         }
 187
 188         /* Validate all elements of the package */
 189
 190         ApCheckPackageElements (Predefined->Info.Name, Op,
 191             Package->RetInfo.ObjectType1, Package->RetInfo.Count1,
 192             Package->RetInfo.ObjectType2, Package->RetInfo.Count2);
 193         break;
 194
 195     case ACPI_PTYPE1_VAR:
 196         /*
 197          * The package count is variable, there are no sub-packages,
 198          * and all elements must be of the same type
 199          */
 200         for (i = 0; i < Count; i++)
 201         {
 202             ApCheckObjectType (Predefined->Info.Name, Op,
 203                 Package->RetInfo.ObjectType1, i);
 204             Op = Op->Asl.Next;
 205         }
 206         break;
 207
 208     case ACPI_PTYPE1_OPTION:
 209         /*
 210          * The package count is variable, there are no sub-packages.
 211          * There are a fixed number of required elements, and a variable
 212          * number of optional elements.
 213          *
 214          * Check if package is at least as large as the minimum required
 215          */
 216         ExpectedCount = Package->RetInfo3.Count;
 217         if (Count < ExpectedCount)
 218         {
 219             goto PackageTooSmall;
 220         }
 221
 222         /* Variable number of sub-objects */
 223
 224         for (i = 0; i < Count; i++)
 225         {
 226             if (i < Package->RetInfo3.Count)
 227             {
 228                 /* These are the required package elements (0, 1, or 2) */
 229
 230                 ApCheckObjectType (Predefined->Info.Name, Op,
 231                     Package->RetInfo3.ObjectType[i], i);
 232             }
 233             else
 234             {
 235                 /* These are the optional package elements */
 236
 237                 ApCheckObjectType (Predefined->Info.Name, Op,
 238                     Package->RetInfo3.TailObjectType, i);
 239             }
 240             Op = Op->Asl.Next;
 241         }
 242         break;
 243
 244     case ACPI_PTYPE2_REV_FIXED:
 245
 246         /* First element is the (Integer) revision */
 247
 248         ApCheckObjectType (Predefined->Info.Name, Op,
 249             ACPI_RTYPE_INTEGER, 0);
 250
 251         Op = Op->Asl.Next;
 252         Count--;
 253
 254         /* Examine the sub-packages */
 255
 256         ApCheckPackageList (Predefined->Info.Name, Op,
 257             Package, 1, Count);
 258         break;
 259
 260     case ACPI_PTYPE2_PKG_COUNT:
 261
 262         /* First element is the (Integer) count of sub-packages to follow */
 263
 264         Status = ApCheckObjectType (Predefined->Info.Name, Op,
 265             ACPI_RTYPE_INTEGER, 0);
 266
 267         /* We must have an integer count from above (otherwise, use Count) */
 268
 269         if (ACPI_SUCCESS (Status))
 270         {
 271             /*
 272              * Count cannot be larger than the parent package length, but
 273              * allow it to be smaller. The >= accounts for the Integer above.
 274              */
 275             ExpectedCount = (UINT32) Op->Asl.Value.Integer;
 276             if (ExpectedCount >= Count)
 277             {
 278                 goto PackageTooSmall;
 279             }
 280
 281             Count = ExpectedCount;
 282         }
 283
 284         Op = Op->Asl.Next;
 285
 286         /* Examine the sub-packages */
 287
 288         ApCheckPackageList (Predefined->Info.Name, Op,
 289             Package, 1, Count);
 290         break;
 291
 292     case ACPI_PTYPE2:
 293     case ACPI_PTYPE2_FIXED:
 294     case ACPI_PTYPE2_MIN:
 295     case ACPI_PTYPE2_COUNT:
 296     case ACPI_PTYPE2_FIX_VAR:
 297         /*
 298          * These types all return a single Package that consists of a
 299          * variable number of sub-Packages.
 300          */
 301
 302         /* Examine the sub-packages */
 303
 304         ApCheckPackageList (Predefined->Info.Name, Op,
 305             Package, 0, Count);
 306         break;
 307
 308     default:
 309         return;
 310     }
 311
 312     return;
 313
 314 PackageTooSmall:
 315     ApPackageTooSmall (Predefined->Info.Name, ParentOp,
 316         Count, ExpectedCount);
 317 }
 318
 319
 320 /*******************************************************************************
 321  *
 322  * FUNCTION:    ApCheckPackageElements
 323  *
 324  * PARAMETERS:  PredefinedName      - Name of the predefined object
 325  *              Op                  - Parser op for the package
 326  *              Type1               - Object type for first group
 327  *              Count1              - Count for first group
 328  *              Type2               - Object type for second group
 329  *              Count2              - Count for second group
 330  *
 331  * RETURN:      None
 332  *
 333  * DESCRIPTION: Validate all elements of a package. Works with packages that
 334  *              are defined to contain up to two groups of different object
 335  *              types.
 336  *
 337  ******************************************************************************/
 338
 339 static void
 340 ApCheckPackageElements (
 341     const char              *PredefinedName,
 342     ACPI_PARSE_OBJECT       *Op,
 343     UINT8                   Type1,
 344     UINT32                  Count1,
 345     UINT8                   Type2,
 346     UINT32                  Count2)
 347 {
 348     UINT32                  i;
 349
 350
 351     /*
 352      * Up to two groups of package elements are supported by the data
 353      * structure. All elements in each group must be of the same type.
 354      * The second group can have a count of zero.
 355      *
 356      * Aborts check upon a NULL package element, as this means (at compile
 357      * time) that the remainder of the package elements are also NULL
 358      * (This is the only way to create NULL package elements.)
 359      */
 360     for (i = 0; (i < Count1) && Op; i++)
 361     {
 362         ApCheckObjectType (PredefinedName, Op, Type1, i);
 363         Op = Op->Asl.Next;
 364     }
 365
 366     for (i = 0; (i < Count2) && Op; i++)
 367     {
 368         ApCheckObjectType (PredefinedName, Op, Type2, (i + Count1));
 369         Op = Op->Asl.Next;
 370     }
 371 }
 372
 373
 374 /*******************************************************************************
 375  *
 376  * FUNCTION:    ApCheckPackageList
 377  *
 378  * PARAMETERS:  PredefinedName      - Name of the predefined object
 379  *              ParentOp            - Parser op of the parent package
 380  *              Package             - Package info for this predefined name
 381  *              StartIndex          - Index in parent package where list begins
 382  *              ParentCount         - Element count of parent package
 383  *
 384  * RETURN:      None
 385  *
 386  * DESCRIPTION: Validate the individual package elements for a predefined name.
 387  *              Handles the cases where the predefined name is defined as a
 388  *              Package of Packages (subpackages). These are the types:
 389  *
 390  *              ACPI_PTYPE2
 391  *              ACPI_PTYPE2_FIXED
 392  *              ACPI_PTYPE2_MIN
 393  *              ACPI_PTYPE2_COUNT
 394  *              ACPI_PTYPE2_FIX_VAR
 395  *
 396  ******************************************************************************/
 397
 398 static void
 399 ApCheckPackageList (
 400     const char                  *PredefinedName,
 401     ACPI_PARSE_OBJECT           *ParentOp,
 402     const ACPI_PREDEFINED_INFO  *Package,
 403     UINT32                      StartIndex,
 404     UINT32                      ParentCount)
 405 {
 406     ACPI_PARSE_OBJECT           *SubPackageOp = ParentOp;
 407     ACPI_PARSE_OBJECT           *Op;
 408     ACPI_STATUS                 Status;
 409     UINT32                      Count;
 410     UINT32                      ExpectedCount;
 411     UINT32                      i;
 412     UINT32                      j;
 413
 414
 415     /*
 416      * Validate each subpackage in the parent Package
 417      *
 418      * Note: We ignore NULL package elements on the assumption that
 419      * they will be initialized by the BIOS or other ASL code.
 420      */
 421     for (i = 0; (i < ParentCount) && SubPackageOp; i++)
 422     {
 423         /* Each object in the list must be of type Package */
 424
 425         Status = ApCheckObjectType (PredefinedName, SubPackageOp,
 426             ACPI_RTYPE_PACKAGE, i + StartIndex);
 427         if (ACPI_FAILURE (Status))
 428         {
 429             goto NextSubpackage;
 430         }
 431
 432         /* Examine the different types of expected subpackages */
 433
 434         Op = SubPackageOp->Asl.Child;
 435
 436         /* First child is the package length */
 437
 438         Count = (UINT32) Op->Asl.Value.Integer;
 439         Op = Op->Asl.Next;
 440
 441         /* The subpackage must have at least one element */
 442
 443         if (!Count)
 444         {
 445             ApZeroLengthPackage (PredefinedName, SubPackageOp);
 446             goto NextSubpackage;
 447         }
 448
 449         /*
 450          * Decode the package type.
 451          * PTYPE2 indicates that a "package of packages" is expected for
 452          * this name. The various flavors of PTYPE2 indicate the number
 453          * and format of the subpackages.
 454          */
 455         switch (Package->RetInfo.Type)
 456         {
 457         case ACPI_PTYPE2:
 458         case ACPI_PTYPE2_PKG_COUNT:
 459         case ACPI_PTYPE2_REV_FIXED:
 460
 461             /* Each subpackage has a fixed number of elements */
 462
 463             ExpectedCount = Package->RetInfo.Count1 + Package->RetInfo.Count2;
 464             if (Count < ExpectedCount)
 465             {
 466                 ApPackageTooSmall (PredefinedName, SubPackageOp,
 467                     Count, ExpectedCount);
 468                 break;
 469             }
 470
 471             ApCheckPackageElements (PredefinedName, Op,
 472                 Package->RetInfo.ObjectType1, Package->RetInfo.Count1,
 473                 Package->RetInfo.ObjectType2, Package->RetInfo.Count2);
 474             break;
 475
 476         case ACPI_PTYPE2_FIX_VAR:
 477             /*
 478              * Each subpackage has a fixed number of elements and an
 479              * optional element
 480              */
 481             ExpectedCount = Package->RetInfo.Count1 + Package->RetInfo.Count2;
 482             if (Count < ExpectedCount)
 483             {
 484                 ApPackageTooSmall (PredefinedName, SubPackageOp,
 485                     Count, ExpectedCount);
 486                 break;
 487             }
 488
 489             ApCheckPackageElements (PredefinedName, Op,
 490                 Package->RetInfo.ObjectType1, Package->RetInfo.Count1,
 491                 Package->RetInfo.ObjectType2,
 492                 Count - Package->RetInfo.Count1);
 493             break;
 494
 495         case ACPI_PTYPE2_FIXED:
 496
 497             /* Each sub-package has a fixed length */
 498
 499             ExpectedCount = Package->RetInfo2.Count;
 500             if (Count < ExpectedCount)
 501             {
 502                 ApPackageTooSmall (PredefinedName, SubPackageOp,
 503                     Count, ExpectedCount);
 504                 break;
 505             }
 506
 507             /* Check each object/type combination */
 508
 509             for (j = 0; j < ExpectedCount; j++)
 510             {
 511                 ApCheckObjectType (PredefinedName, Op,
 512                     Package->RetInfo2.ObjectType[j], j);
 513
 514                 Op = Op->Asl.Next;
 515             }
 516             break;
 517
 518         case ACPI_PTYPE2_MIN:
 519
 520             /* Each sub-package has a variable but minimum length */
 521
 522             ExpectedCount = Package->RetInfo.Count1;
 523             if (Count < ExpectedCount)
 524             {
 525                 ApPackageTooSmall (PredefinedName, SubPackageOp,
 526                     Count, ExpectedCount);
 527                 break;
 528             }
 529
 530             /* Check the type of each sub-package element */
 531
 532             ApCheckPackageElements (PredefinedName, Op,
 533                 Package->RetInfo.ObjectType1, Count, 0, 0);
 534             break;
 535
 536         case ACPI_PTYPE2_COUNT:
 537             /*
 538              * First element is the (Integer) count of elements, including
 539              * the count field (the ACPI name is NumElements)
 540              */
 541             Status = ApCheckObjectType (PredefinedName, Op,
 542                 ACPI_RTYPE_INTEGER, 0);
 543
 544             /* We must have an integer count from above (otherwise, use Count) */
 545
 546             if (ACPI_SUCCESS (Status))
 547             {
 548                 /*
 549                  * Make sure package is large enough for the Count and is
 550                  * is as large as the minimum size
 551                  */
 552                 ExpectedCount = (UINT32) Op->Asl.Value.Integer;
 553
 554                 if (Count < ExpectedCount)
 555                 {
 556                     ApPackageTooSmall (PredefinedName, SubPackageOp,
 557                         Count, ExpectedCount);
 558                     break;
 559                 }
 560                 else if (Count > ExpectedCount)
 561                 {
 562                     ApPackageTooLarge (PredefinedName, SubPackageOp,
 563                         Count, ExpectedCount);
 564                 }
 565
 566                 /* Some names of this type have a minimum length */
 567
 568                 if (Count < Package->RetInfo.Count1)
 569                 {
 570                     ExpectedCount = Package->RetInfo.Count1;
 571                     ApPackageTooSmall (PredefinedName, SubPackageOp,
 572                         Count, ExpectedCount);
 573                     break;
 574                 }
 575
 576                 Count = ExpectedCount;
 577             }
 578
 579             /* Check the type of each sub-package element */
 580
 581             Op = Op->Asl.Next;
 582             ApCheckPackageElements (PredefinedName, Op,
 583                 Package->RetInfo.ObjectType1, (Count - 1), 0, 0);
 584             break;
 585
 586         default:
 587             break;
 588         }
 589
 590 NextSubpackage:
 591         SubPackageOp = SubPackageOp->Asl.Next;
 592     }
 593 }
 594
 595
 596 /*******************************************************************************
 597  *
 598  * FUNCTION:    ApPackageTooSmall
 599  *
 600  * PARAMETERS:  PredefinedName      - Name of the predefined object
 601  *              Op                  - Current parser op
 602  *              Count               - Actual package element count
 603  *              ExpectedCount       - Expected package element count
 604  *
 605  * RETURN:      None
 606  *
 607  * DESCRIPTION: Issue error message for a package that is smaller than
 608  *              required.
 609  *
 610  ******************************************************************************/
 611
 612 static void
 613 ApPackageTooSmall (
 614     const char                  *PredefinedName,
 615     ACPI_PARSE_OBJECT           *Op,
 616     UINT32                      Count,
 617     UINT32                      ExpectedCount)
 618 {
 619
 620     sprintf (MsgBuffer, "%s: length %u, required minimum is %u",
 621         PredefinedName, Count, ExpectedCount);
 622
 623     AslError (ASL_ERROR, ASL_MSG_RESERVED_PACKAGE_LENGTH, Op, MsgBuffer);
 624 }
 625
 626
 627 /*******************************************************************************
 628  *
 629  * FUNCTION:    ApZeroLengthPackage
 630  *
 631  * PARAMETERS:  PredefinedName      - Name of the predefined object
 632  *              Op                  - Current parser op
 633  *
 634  * RETURN:      None
 635  *
 636  * DESCRIPTION: Issue error message for a zero-length package (a package that
 637  *              is required to have a non-zero length). Variable length
 638  *              packages seem to be allowed to have zero length, however.
 639  *              Even if not allowed, BIOS code does it.
 640  *
 641  ******************************************************************************/
 642
 643 static void
 644 ApZeroLengthPackage (
 645     const char                  *PredefinedName,
 646     ACPI_PARSE_OBJECT           *Op)
 647 {
 648
 649     sprintf (MsgBuffer, "%s: length is zero", PredefinedName);
 650
 651     AslError (ASL_ERROR, ASL_MSG_RESERVED_PACKAGE_LENGTH, Op, MsgBuffer);
 652 }
 653
 654
 655 /*******************************************************************************
 656  *
 657  * FUNCTION:    ApPackageTooLarge
 658  *
 659  * PARAMETERS:  PredefinedName      - Name of the predefined object
 660  *              Op                  - Current parser op
 661  *              Count               - Actual package element count
 662  *              ExpectedCount       - Expected package element count
 663  *
 664  * RETURN:      None
 665  *
 666  * DESCRIPTION: Issue a remark for a package that is larger than expected.
 667  *
 668  ******************************************************************************/
 669
 670 static void
 671 ApPackageTooLarge (
 672     const char                  *PredefinedName,
 673     ACPI_PARSE_OBJECT           *Op,
 674     UINT32                      Count,
 675     UINT32                      ExpectedCount)
 676 {
 677
 678     sprintf (MsgBuffer, "%s: length is %u, only %u required",
 679         PredefinedName, Count, ExpectedCount);
 680
 681     AslError (ASL_REMARK, ASL_MSG_RESERVED_PACKAGE_LENGTH, Op, MsgBuffer);
 682 }