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