aslprepkg.c revision 259065
11590Srgrimes/****************************************************************************** 21590Srgrimes * 31590Srgrimes * Module Name: aslprepkg - support for ACPI predefined name package objects 41590Srgrimes * 51590Srgrimes *****************************************************************************/ 61590Srgrimes 71590Srgrimes/* 81590Srgrimes * Copyright (C) 2000 - 2013, Intel Corp. 91590Srgrimes * All rights reserved. 101590Srgrimes * 111590Srgrimes * Redistribution and use in source and binary forms, with or without 121590Srgrimes * modification, are permitted provided that the following conditions 131590Srgrimes * are met: 141590Srgrimes * 1. Redistributions of source code must retain the above copyright 151590Srgrimes * notice, this list of conditions, and the following disclaimer, 161590Srgrimes * without modification. 171590Srgrimes * 2. Redistributions in binary form must reproduce at minimum a disclaimer 181590Srgrimes * substantially similar to the "NO WARRANTY" disclaimer below 191590Srgrimes * ("Disclaimer") and any redistribution must be conditioned upon 201590Srgrimes * including a substantially similar Disclaimer requirement for further 211590Srgrimes * binary redistribution. 221590Srgrimes * 3. Neither the names of the above-listed copyright holders nor the names 231590Srgrimes * of any contributors may be used to endorse or promote products derived 241590Srgrimes * from this software without specific prior written permission. 251590Srgrimes * 261590Srgrimes * Alternatively, this software may be distributed under the terms of the 271590Srgrimes * GNU General Public License ("GPL") version 2 as published by the Free 281590Srgrimes * Software Foundation. 291590Srgrimes * 301590Srgrimes * NO WARRANTY 311590Srgrimes * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 321590Srgrimes * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 3387712Smarkm * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 3487712Smarkm * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 3587712Smarkm * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 3687712Smarkm * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 371590Srgrimes * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 3887712Smarkm * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 3969528Sasmodai * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 401590Srgrimes * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 411590Srgrimes * POSSIBILITY OF SUCH DAMAGES. 421590Srgrimes */ 4387712Smarkm 4487712Smarkm#include <contrib/dev/acpica/compiler/aslcompiler.h> 4587712Smarkm#include "aslcompiler.y.h" 461590Srgrimes#include <contrib/dev/acpica/include/acpredef.h> 471590Srgrimes 481590Srgrimes 491590Srgrimes#define _COMPONENT ACPI_COMPILER 5087712Smarkm ACPI_MODULE_NAME ("aslprepkg") 5187712Smarkm 521590Srgrimes 531590Srgrimes/* Local prototypes */ 541590Srgrimes 551590Srgrimesstatic void 561590SrgrimesApCheckPackageElements ( 571590Srgrimes const char *PredefinedName, 581590Srgrimes ACPI_PARSE_OBJECT *Op, 591590Srgrimes UINT8 Type1, 601590Srgrimes UINT32 Count1, 611590Srgrimes UINT8 Type2, 621590Srgrimes UINT32 Count2); 631590Srgrimes 6417339Sadamstatic void 65193488SbrianApCheckPackageList ( 661590Srgrimes const char *PredefinedName, 6769552Sasmodai ACPI_PARSE_OBJECT *ParentOp, 6869552Sasmodai const ACPI_PREDEFINED_INFO *Package, 691590Srgrimes UINT32 StartIndex, 701590Srgrimes UINT32 Count); 711590Srgrimes 721590Srgrimesstatic void 7317825SpeterApPackageTooSmall ( 741590Srgrimes const char *PredefinedName, 751590Srgrimes ACPI_PARSE_OBJECT *Op, 761590Srgrimes UINT32 Count, 771590Srgrimes UINT32 ExpectedCount); 781590Srgrimes 791590Srgrimesstatic void 801590SrgrimesApZeroLengthPackage ( 811590Srgrimes const char *PredefinedName, 821590Srgrimes ACPI_PARSE_OBJECT *Op); 83193488Sbrian 84172719Skibstatic void 8517339SadamApPackageTooLarge ( 861590Srgrimes const char *PredefinedName, 871590Srgrimes ACPI_PARSE_OBJECT *Op, 881590Srgrimes UINT32 Count, 891590Srgrimes UINT32 ExpectedCount); 901590Srgrimes 911590Srgrimes 921590Srgrimes/******************************************************************************* 931590Srgrimes * 941590Srgrimes * FUNCTION: ApCheckPackage 951590Srgrimes * 961590Srgrimes * PARAMETERS: ParentOp - Parser op for the package 971590Srgrimes * Predefined - Pointer to package-specific info for 981590Srgrimes * the method 991590Srgrimes * 1001590Srgrimes * RETURN: None 1011590Srgrimes * 1021590Srgrimes * DESCRIPTION: Top-level validation for predefined name return package 1031590Srgrimes * objects. 1041590Srgrimes * 1051590Srgrimes ******************************************************************************/ 1061590Srgrimes 1071590Srgrimesvoid 1081590SrgrimesApCheckPackage ( 1091590Srgrimes ACPI_PARSE_OBJECT *ParentOp, 1101590Srgrimes const ACPI_PREDEFINED_INFO *Predefined) 1111590Srgrimes{ 1121590Srgrimes ACPI_PARSE_OBJECT *Op; 1131590Srgrimes const ACPI_PREDEFINED_INFO *Package; 1141590Srgrimes ACPI_STATUS Status; 11587712Smarkm UINT32 ExpectedCount; 11687712Smarkm UINT32 Count; 1171590Srgrimes UINT32 i; 1181590Srgrimes 119172719Skib 120172719Skib /* The package info for this name is in the next table entry */ 12117341Sadam 1221590Srgrimes Package = Predefined + 1; 1231590Srgrimes 1241590Srgrimes /* First child is the package length */ 1251590Srgrimes 1261590Srgrimes Op = ParentOp->Asl.Child; 1271590Srgrimes Count = (UINT32) Op->Asl.Value.Integer; 1281590Srgrimes 1291590Srgrimes /* 1301590Srgrimes * Many of the variable-length top-level packages are allowed to simply 1311590Srgrimes * have zero elements. This allows the BIOS to tell the host that even 1321590Srgrimes * though the predefined name/method exists, the feature is not supported. 1331590Srgrimes * Other package types require one or more elements. In any case, there 13417339Sadam * is no need to continue validation. 135193488Sbrian */ 1361590Srgrimes if (!Count) 1371590Srgrimes { 138116156Smarkm switch (Package->RetInfo.Type) 1391590Srgrimes { 1401590Srgrimes case ACPI_PTYPE1_FIXED: 14187712Smarkm case ACPI_PTYPE1_OPTION: 142172719Skib case ACPI_PTYPE2_PKG_COUNT: 14387712Smarkm case ACPI_PTYPE2_REV_FIXED: 144116156Smarkm 1451590Srgrimes ApZeroLengthPackage (Predefined->Info.Name, ParentOp); 146245184Sdelphij break; 147245184Sdelphij 148173285Scharnier case ACPI_PTYPE1_VAR: 1491590Srgrimes case ACPI_PTYPE2: 150172719Skib case ACPI_PTYPE2_COUNT: 1511590Srgrimes case ACPI_PTYPE2_FIXED: 1521590Srgrimes case ACPI_PTYPE2_MIN: 1531590Srgrimes case ACPI_PTYPE2_FIX_VAR: 1541590Srgrimes default: 15517825Speter 1561590Srgrimes break; 1571590Srgrimes } 1581590Srgrimes 1591590Srgrimes return; 160116156Smarkm } 16187712Smarkm 16287712Smarkm /* Get the first element of the package */ 16387712Smarkm 16417825Speter Op = Op->Asl.Next; 1651590Srgrimes 16687712Smarkm /* Decode the package type */ 1671590Srgrimes 1681590Srgrimes switch (Package->RetInfo.Type) 1691590Srgrimes { 1701590Srgrimes case ACPI_PTYPE1_FIXED: 1711590Srgrimes /* 1721590Srgrimes * The package count is fixed and there are no sub-packages 1731590Srgrimes * 1741590Srgrimes * If package is too small, exit. 1751590Srgrimes * If package is larger than expected, issue warning but continue 176193488Sbrian */ 177172719Skib ExpectedCount = Package->RetInfo.Count1 + Package->RetInfo.Count2; 178172719Skib if (Count < ExpectedCount) 1791590Srgrimes { 1801590Srgrimes goto PackageTooSmall; 18187712Smarkm } 182173838Savatar else if (Count > ExpectedCount) 18387712Smarkm { 1841590Srgrimes ApPackageTooLarge (Predefined->Info.Name, ParentOp, 1851590Srgrimes Count, ExpectedCount); 1861590Srgrimes } 1871590Srgrimes 1881590Srgrimes /* Validate all elements of the package */ 1891590Srgrimes 1901590Srgrimes ApCheckPackageElements (Predefined->Info.Name, Op, 191116156Smarkm Package->RetInfo.ObjectType1, Package->RetInfo.Count1, 19287712Smarkm Package->RetInfo.ObjectType2, Package->RetInfo.Count2); 1931590Srgrimes break; 194116156Smarkm 19587712Smarkm case ACPI_PTYPE1_VAR: 1961590Srgrimes /* 1971590Srgrimes * The package count is variable, there are no sub-packages, 198116156Smarkm * and all elements must be of the same type 19987712Smarkm */ 200116156Smarkm for (i = 0; i < Count; i++) 20187712Smarkm { 2021590Srgrimes ApCheckObjectType (Predefined->Info.Name, Op, 203172719Skib Package->RetInfo.ObjectType1, i); 204172719Skib Op = Op->Asl.Next; 205172719Skib } 206172719Skib break; 207172719Skib 208172719Skib case ACPI_PTYPE1_OPTION: 2091590Srgrimes /* 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 314PackageTooSmall: 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 339static void 340ApCheckPackageElements ( 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 398static void 399ApCheckPackageList ( 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 590NextSubpackage: 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 612static void 613ApPackageTooSmall ( 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 643static void 644ApZeroLengthPackage ( 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 670static void 671ApPackageTooLarge ( 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} 683