aslpredef.c revision 249663
1/****************************************************************************** 2 * 3 * Module Name: aslpredef - support for ACPI predefined names 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#define ACPI_CREATE_PREDEFINED_TABLE 45#define ACPI_CREATE_RESOURCE_TABLE 46 47#include <contrib/dev/acpica/compiler/aslcompiler.h> 48#include "aslcompiler.y.h" 49#include <contrib/dev/acpica/include/acpredef.h> 50#include <contrib/dev/acpica/include/acnamesp.h> 51 52 53#define _COMPONENT ACPI_COMPILER 54 ACPI_MODULE_NAME ("aslpredef") 55 56 57/* Local prototypes */ 58 59static void 60ApCheckForUnexpectedReturnValue ( 61 ACPI_PARSE_OBJECT *Op, 62 ASL_METHOD_INFO *MethodInfo); 63 64static UINT32 65ApCheckForSpecialName ( 66 ACPI_PARSE_OBJECT *Op, 67 char *Name); 68 69 70/******************************************************************************* 71 * 72 * FUNCTION: ApCheckForPredefinedMethod 73 * 74 * PARAMETERS: Op - A parse node of type "METHOD". 75 * MethodInfo - Saved info about this method 76 * 77 * RETURN: None 78 * 79 * DESCRIPTION: If method is a predefined name, check that the number of 80 * arguments and the return type (returns a value or not) 81 * is correct. 82 * 83 ******************************************************************************/ 84 85BOOLEAN 86ApCheckForPredefinedMethod ( 87 ACPI_PARSE_OBJECT *Op, 88 ASL_METHOD_INFO *MethodInfo) 89{ 90 UINT32 Index; 91 UINT32 RequiredArgCount; 92 const ACPI_PREDEFINED_INFO *ThisName; 93 94 95 /* Check for a match against the predefined name list */ 96 97 Index = ApCheckForPredefinedName (Op, Op->Asl.NameSeg); 98 99 switch (Index) 100 { 101 case ACPI_NOT_RESERVED_NAME: /* No underscore or _Txx or _xxx name not matched */ 102 case ACPI_PREDEFINED_NAME: /* Resource Name or reserved scope name */ 103 case ACPI_COMPILER_RESERVED_NAME: /* A _Txx that was not emitted by compiler */ 104 105 /* Just return, nothing to do */ 106 return (FALSE); 107 108 109 case ACPI_EVENT_RESERVED_NAME: /* _Lxx/_Exx/_Wxx/_Qxx methods */ 110 111 Gbl_ReservedMethods++; 112 113 /* NumArguments must be zero for all _Lxx/_Exx/_Wxx/_Qxx methods */ 114 115 if (MethodInfo->NumArguments != 0) 116 { 117 sprintf (MsgBuffer, "%s requires %u", Op->Asl.ExternalName, 0); 118 119 AslError (ASL_WARNING, ASL_MSG_RESERVED_ARG_COUNT_HI, Op, 120 MsgBuffer); 121 } 122 break; 123 124 125 default: 126 /* 127 * Matched a predefined method name - validate the ASL-defined 128 * argument count against the ACPI specification. 129 * 130 * Some methods are allowed to have a "minimum" number of args 131 * (_SCP) because their definition in ACPI has changed over time. 132 */ 133 Gbl_ReservedMethods++; 134 ThisName = &AcpiGbl_PredefinedMethods[Index]; 135 RequiredArgCount = METHOD_GET_ARG_COUNT (ThisName->Info.ArgumentList); 136 137 if (MethodInfo->NumArguments != RequiredArgCount) 138 { 139 sprintf (MsgBuffer, "%4.4s requires %u", 140 ThisName->Info.Name, RequiredArgCount); 141 142 if (MethodInfo->NumArguments < RequiredArgCount) 143 { 144 AslError (ASL_WARNING, ASL_MSG_RESERVED_ARG_COUNT_LO, Op, 145 MsgBuffer); 146 } 147 else if ((MethodInfo->NumArguments > RequiredArgCount) && 148 !(ThisName->Info.ArgumentList & ARG_COUNT_IS_MINIMUM)) 149 { 150 AslError (ASL_WARNING, ASL_MSG_RESERVED_ARG_COUNT_HI, Op, 151 MsgBuffer); 152 } 153 } 154 155 /* 156 * Check if method returns no value, but the predefined name is 157 * required to return a value 158 */ 159 if (MethodInfo->NumReturnNoValue && 160 ThisName->Info.ExpectedBtypes) 161 { 162 AcpiUtGetExpectedReturnTypes (StringBuffer, 163 ThisName->Info.ExpectedBtypes); 164 165 sprintf (MsgBuffer, "%s required for %4.4s", 166 StringBuffer, ThisName->Info.Name); 167 168 AslError (ASL_WARNING, ASL_MSG_RESERVED_RETURN_VALUE, Op, 169 MsgBuffer); 170 } 171 break; 172 } 173 174 return (TRUE); 175} 176 177 178/******************************************************************************* 179 * 180 * FUNCTION: ApCheckForUnexpectedReturnValue 181 * 182 * PARAMETERS: Op - A parse node of type "RETURN". 183 * MethodInfo - Saved info about this method 184 * 185 * RETURN: None 186 * 187 * DESCRIPTION: Check for an unexpected return value from a predefined method. 188 * Invoked for predefined methods that are defined to not return 189 * any value. If there is a return value, issue a remark, since 190 * the ASL writer may be confused as to the method definition 191 * and/or functionality. 192 * 193 * Note: We ignore all return values of "Zero", since this is what a standalone 194 * Return() statement will always generate -- so we ignore it here -- 195 * i.e., there is no difference between Return() and Return(Zero). 196 * Also, a null Return() will be disassembled to return(Zero) -- so, we 197 * don't want to generate extraneous remarks/warnings for a disassembled 198 * ASL file. 199 * 200 ******************************************************************************/ 201 202static void 203ApCheckForUnexpectedReturnValue ( 204 ACPI_PARSE_OBJECT *Op, 205 ASL_METHOD_INFO *MethodInfo) 206{ 207 ACPI_PARSE_OBJECT *ReturnValueOp; 208 209 210 /* Ignore Return() and Return(Zero) (they are the same) */ 211 212 ReturnValueOp = Op->Asl.Child; 213 if (ReturnValueOp->Asl.ParseOpcode == PARSEOP_ZERO) 214 { 215 return; 216 } 217 218 /* We have a valid return value, but the reserved name did not expect it */ 219 220 AslError (ASL_WARNING, ASL_MSG_RESERVED_NO_RETURN_VAL, 221 Op, MethodInfo->Op->Asl.ExternalName); 222} 223 224 225/******************************************************************************* 226 * 227 * FUNCTION: ApCheckPredefinedReturnValue 228 * 229 * PARAMETERS: Op - A parse node of type "RETURN". 230 * MethodInfo - Saved info about this method 231 * 232 * RETURN: None 233 * 234 * DESCRIPTION: If method is a predefined name, attempt to validate the return 235 * value. Only "static" types can be validated - a simple return 236 * of an integer/string/buffer/package or a named reference to 237 * a static object. Values such as a Localx or Argx or a control 238 * method invocation are not checked. Issue a warning if there is 239 * a valid return value, but the reserved method defines no 240 * return value. 241 * 242 ******************************************************************************/ 243 244void 245ApCheckPredefinedReturnValue ( 246 ACPI_PARSE_OBJECT *Op, 247 ASL_METHOD_INFO *MethodInfo) 248{ 249 UINT32 Index; 250 ACPI_PARSE_OBJECT *ReturnValueOp; 251 const ACPI_PREDEFINED_INFO *ThisName; 252 253 254 /* Check parent method for a match against the predefined name list */ 255 256 Index = ApCheckForPredefinedName (MethodInfo->Op, 257 MethodInfo->Op->Asl.NameSeg); 258 259 switch (Index) 260 { 261 case ACPI_EVENT_RESERVED_NAME: /* _Lxx/_Exx/_Wxx/_Qxx methods */ 262 263 /* No return value expected, warn if there is one */ 264 265 ApCheckForUnexpectedReturnValue (Op, MethodInfo); 266 return; 267 268 case ACPI_NOT_RESERVED_NAME: /* No underscore or _Txx or _xxx name not matched */ 269 case ACPI_PREDEFINED_NAME: /* Resource Name or reserved scope name */ 270 case ACPI_COMPILER_RESERVED_NAME: /* A _Txx that was not emitted by compiler */ 271 272 /* Just return, nothing to do */ 273 return; 274 275 default: /* A standard predefined ACPI name */ 276 277 ThisName = &AcpiGbl_PredefinedMethods[Index]; 278 if (!ThisName->Info.ExpectedBtypes) 279 { 280 /* No return value expected, warn if there is one */ 281 282 ApCheckForUnexpectedReturnValue (Op, MethodInfo); 283 return; 284 } 285 286 /* Get the object returned, it is the next argument */ 287 288 ReturnValueOp = Op->Asl.Child; 289 switch (ReturnValueOp->Asl.ParseOpcode) 290 { 291 case PARSEOP_ZERO: 292 case PARSEOP_ONE: 293 case PARSEOP_ONES: 294 case PARSEOP_INTEGER: 295 case PARSEOP_STRING_LITERAL: 296 case PARSEOP_BUFFER: 297 case PARSEOP_PACKAGE: 298 299 /* Static data return object - check against expected type */ 300 301 ApCheckObjectType (ThisName->Info.Name, ReturnValueOp, 302 ThisName->Info.ExpectedBtypes, ACPI_NOT_PACKAGE_ELEMENT); 303 304 /* For packages, check the individual package elements */ 305 306 if (ReturnValueOp->Asl.ParseOpcode == PARSEOP_PACKAGE) 307 { 308 ApCheckPackage (ReturnValueOp, ThisName); 309 } 310 break; 311 312 default: 313 314 /* 315 * All other ops are very difficult or impossible to typecheck at 316 * compile time. These include all Localx, Argx, and method 317 * invocations. Also, NAMESEG and NAMESTRING because the type of 318 * any named object can be changed at runtime (for example, 319 * CopyObject will change the type of the target object.) 320 */ 321 break; 322 } 323 } 324} 325 326 327/******************************************************************************* 328 * 329 * FUNCTION: ApCheckForPredefinedObject 330 * 331 * PARAMETERS: Op - A parse node 332 * Name - The ACPI name to be checked 333 * 334 * RETURN: None 335 * 336 * DESCRIPTION: Check for a predefined name for a static object (created via 337 * the ASL Name operator). If it is a predefined ACPI name, ensure 338 * that the name does not require any arguments (which would 339 * require a control method implemenation of the name), and that 340 * the type of the object is one of the expected types for the 341 * predefined name. 342 * 343 ******************************************************************************/ 344 345void 346ApCheckForPredefinedObject ( 347 ACPI_PARSE_OBJECT *Op, 348 char *Name) 349{ 350 UINT32 Index; 351 ACPI_PARSE_OBJECT *ObjectOp; 352 const ACPI_PREDEFINED_INFO *ThisName; 353 354 355 /* 356 * Check for a real predefined name -- not a resource descriptor name 357 * or a predefined scope name 358 */ 359 Index = ApCheckForPredefinedName (Op, Name); 360 361 switch (Index) 362 { 363 case ACPI_NOT_RESERVED_NAME: /* No underscore or _Txx or _xxx name not matched */ 364 case ACPI_PREDEFINED_NAME: /* Resource Name or reserved scope name */ 365 case ACPI_COMPILER_RESERVED_NAME: /* A _Txx that was not emitted by compiler */ 366 367 /* Nothing to do */ 368 return; 369 370 case ACPI_EVENT_RESERVED_NAME: /* _Lxx/_Exx/_Wxx/_Qxx methods */ 371 372 /* 373 * These names must be control methods, by definition in ACPI spec. 374 * Also because they are defined to return no value. None of them 375 * require any arguments. 376 */ 377 AslError (ASL_ERROR, ASL_MSG_RESERVED_METHOD, Op, 378 "with zero arguments"); 379 return; 380 381 default: 382 break; 383 } 384 385 /* A standard predefined ACPI name */ 386 387 /* 388 * If this predefined name requires input arguments, then 389 * it must be implemented as a control method 390 */ 391 ThisName = &AcpiGbl_PredefinedMethods[Index]; 392 if (METHOD_GET_ARG_COUNT (ThisName->Info.ArgumentList) > 0) 393 { 394 AslError (ASL_ERROR, ASL_MSG_RESERVED_METHOD, Op, 395 "with arguments"); 396 return; 397 } 398 399 /* 400 * If no return value is expected from this predefined name, then 401 * it follows that it must be implemented as a control method 402 * (with zero args, because the args > 0 case was handled above) 403 * Examples are: _DIS, _INI, _IRC, _OFF, _ON, _PSx 404 */ 405 if (!ThisName->Info.ExpectedBtypes) 406 { 407 AslError (ASL_ERROR, ASL_MSG_RESERVED_METHOD, Op, 408 "with zero arguments"); 409 return; 410 } 411 412 /* Typecheck the actual object, it is the next argument */ 413 414 ObjectOp = Op->Asl.Child->Asl.Next; 415 ApCheckObjectType (ThisName->Info.Name, Op->Asl.Child->Asl.Next, 416 ThisName->Info.ExpectedBtypes, ACPI_NOT_PACKAGE_ELEMENT); 417 418 /* For packages, check the individual package elements */ 419 420 if (ObjectOp->Asl.ParseOpcode == PARSEOP_PACKAGE) 421 { 422 ApCheckPackage (ObjectOp, ThisName); 423 } 424} 425 426 427/******************************************************************************* 428 * 429 * FUNCTION: ApCheckForPredefinedName 430 * 431 * PARAMETERS: Op - A parse node 432 * Name - NameSeg to check 433 * 434 * RETURN: None 435 * 436 * DESCRIPTION: Check a NameSeg against the reserved list. 437 * 438 ******************************************************************************/ 439 440UINT32 441ApCheckForPredefinedName ( 442 ACPI_PARSE_OBJECT *Op, 443 char *Name) 444{ 445 UINT32 i; 446 const ACPI_PREDEFINED_INFO *ThisName; 447 448 449 if (Name[0] == 0) 450 { 451 AcpiOsPrintf ("Found a null name, external = %s\n", 452 Op->Asl.ExternalName); 453 } 454 455 /* All reserved names are prefixed with a single underscore */ 456 457 if (Name[0] != '_') 458 { 459 return (ACPI_NOT_RESERVED_NAME); 460 } 461 462 /* Check for a standard predefined method name */ 463 464 ThisName = AcpiGbl_PredefinedMethods; 465 for (i = 0; ThisName->Info.Name[0]; i++) 466 { 467 if (ACPI_COMPARE_NAME (Name, ThisName->Info.Name)) 468 { 469 /* Return index into predefined array */ 470 return (i); 471 } 472 473 ThisName++; /* Does not account for extra package data, but is OK */ 474 } 475 476 /* Check for resource names and predefined scope names */ 477 478 ThisName = AcpiGbl_ResourceNames; 479 while (ThisName->Info.Name[0]) 480 { 481 if (ACPI_COMPARE_NAME (Name, ThisName->Info.Name)) 482 { 483 return (ACPI_PREDEFINED_NAME); 484 } 485 486 ThisName++; 487 } 488 489 ThisName = AcpiGbl_ScopeNames; 490 while (ThisName->Info.Name[0]) 491 { 492 if (ACPI_COMPARE_NAME (Name, ThisName->Info.Name)) 493 { 494 return (ACPI_PREDEFINED_NAME); 495 } 496 497 ThisName++; 498 } 499 500 /* Check for _Lxx/_Exx/_Wxx/_Qxx/_T_x. Warning if unknown predefined name */ 501 502 return (ApCheckForSpecialName (Op, Name)); 503} 504 505 506/******************************************************************************* 507 * 508 * FUNCTION: ApCheckForSpecialName 509 * 510 * PARAMETERS: Op - A parse node 511 * Name - NameSeg to check 512 * 513 * RETURN: None 514 * 515 * DESCRIPTION: Check for the "special" predefined names - 516 * _Lxx, _Exx, _Qxx, _Wxx, and _T_x 517 * 518 ******************************************************************************/ 519 520static UINT32 521ApCheckForSpecialName ( 522 ACPI_PARSE_OBJECT *Op, 523 char *Name) 524{ 525 526 /* 527 * Check for the "special" predefined names. We already know that the 528 * first character is an underscore. 529 * GPE: _Lxx 530 * GPE: _Exx 531 * GPE: _Wxx 532 * EC: _Qxx 533 */ 534 if ((Name[1] == 'L') || 535 (Name[1] == 'E') || 536 (Name[1] == 'W') || 537 (Name[1] == 'Q')) 538 { 539 /* The next two characters must be hex digits */ 540 541 if ((isxdigit ((int) Name[2])) && 542 (isxdigit ((int) Name[3]))) 543 { 544 return (ACPI_EVENT_RESERVED_NAME); 545 } 546 } 547 548 /* Check for the names reserved for the compiler itself: _T_x */ 549 550 else if ((Op->Asl.ExternalName[1] == 'T') && 551 (Op->Asl.ExternalName[2] == '_')) 552 { 553 /* Ignore if actually emitted by the compiler */ 554 555 if (Op->Asl.CompileFlags & NODE_COMPILER_EMITTED) 556 { 557 return (ACPI_NOT_RESERVED_NAME); 558 } 559 560 /* 561 * Was not actually emitted by the compiler. This is a special case, 562 * however. If the ASL code being compiled was the result of a 563 * dissasembly, it may possibly contain valid compiler-emitted names 564 * of the form "_T_x". We don't want to issue an error or even a 565 * warning and force the user to manually change the names. So, we 566 * will issue a remark instead. 567 */ 568 AslError (ASL_REMARK, ASL_MSG_COMPILER_RESERVED, Op, Op->Asl.ExternalName); 569 return (ACPI_COMPILER_RESERVED_NAME); 570 } 571 572 /* 573 * The name didn't match any of the known predefined names. Flag it as a 574 * warning, since the entire namespace starting with an underscore is 575 * reserved by the ACPI spec. 576 */ 577 AslError (ASL_WARNING, ASL_MSG_UNKNOWN_RESERVED_NAME, Op, 578 Op->Asl.ExternalName); 579 580 return (ACPI_NOT_RESERVED_NAME); 581} 582 583 584/******************************************************************************* 585 * 586 * FUNCTION: ApCheckObjectType 587 * 588 * PARAMETERS: PredefinedName - Name of the predefined object we are checking 589 * Op - Current parse node 590 * ExpectedBtypes - Bitmap of expected return type(s) 591 * PackageIndex - Index of object within parent package (if 592 * applicable - ACPI_NOT_PACKAGE_ELEMENT 593 * otherwise) 594 * 595 * RETURN: None 596 * 597 * DESCRIPTION: Check if the object type is one of the types that is expected 598 * by the predefined name. Only a limited number of object types 599 * can be returned by the predefined names. 600 * 601 ******************************************************************************/ 602 603ACPI_STATUS 604ApCheckObjectType ( 605 const char *PredefinedName, 606 ACPI_PARSE_OBJECT *Op, 607 UINT32 ExpectedBtypes, 608 UINT32 PackageIndex) 609{ 610 UINT32 ReturnBtype; 611 char *TypeName; 612 613 614 if (!Op) 615 { 616 return (AE_TYPE); 617 } 618 619 /* Map the parse opcode to a bitmapped return type (RTYPE) */ 620 621 switch (Op->Asl.ParseOpcode) 622 { 623 case PARSEOP_ZERO: 624 case PARSEOP_ONE: 625 case PARSEOP_ONES: 626 case PARSEOP_INTEGER: 627 ReturnBtype = ACPI_RTYPE_INTEGER; 628 TypeName = "Integer"; 629 break; 630 631 case PARSEOP_STRING_LITERAL: 632 ReturnBtype = ACPI_RTYPE_STRING; 633 TypeName = "String"; 634 break; 635 636 case PARSEOP_BUFFER: 637 ReturnBtype = ACPI_RTYPE_BUFFER; 638 TypeName = "Buffer"; 639 break; 640 641 case PARSEOP_PACKAGE: 642 case PARSEOP_VAR_PACKAGE: 643 ReturnBtype = ACPI_RTYPE_PACKAGE; 644 TypeName = "Package"; 645 break; 646 647 case PARSEOP_NAMESEG: 648 case PARSEOP_NAMESTRING: 649 ReturnBtype = ACPI_RTYPE_REFERENCE; 650 TypeName = "Reference"; 651 break; 652 653 default: 654 /* Not one of the supported object types */ 655 656 TypeName = UtGetOpName (Op->Asl.ParseOpcode); 657 goto TypeErrorExit; 658 } 659 660 /* Exit if the object is one of the expected types */ 661 662 if (ReturnBtype & ExpectedBtypes) 663 { 664 return (AE_OK); 665 } 666 667 668TypeErrorExit: 669 670 /* Format the expected types and emit an error message */ 671 672 AcpiUtGetExpectedReturnTypes (StringBuffer, ExpectedBtypes); 673 674 if (PackageIndex == ACPI_NOT_PACKAGE_ELEMENT) 675 { 676 sprintf (MsgBuffer, "%4.4s: found %s, %s required", 677 PredefinedName, TypeName, StringBuffer); 678 } 679 else 680 { 681 sprintf (MsgBuffer, "%4.4s: found %s at index %u, %s required", 682 PredefinedName, TypeName, PackageIndex, StringBuffer); 683 } 684 685 AslError (ASL_ERROR, ASL_MSG_RESERVED_OPERAND_TYPE, Op, MsgBuffer); 686 return (AE_TYPE); 687} 688 689 690/******************************************************************************* 691 * 692 * FUNCTION: ApDisplayReservedNames 693 * 694 * PARAMETERS: None 695 * 696 * RETURN: None 697 * 698 * DESCRIPTION: Dump information about the ACPI predefined names and predefined 699 * resource descriptor names. 700 * 701 ******************************************************************************/ 702 703void 704ApDisplayReservedNames ( 705 void) 706{ 707 const ACPI_PREDEFINED_INFO *ThisName; 708 UINT32 Count; 709 UINT32 NumTypes; 710 711 712 /* 713 * Predefined names/methods 714 */ 715 printf ("\nPredefined Name Information\n\n"); 716 717 Count = 0; 718 ThisName = AcpiGbl_PredefinedMethods; 719 while (ThisName->Info.Name[0]) 720 { 721 AcpiUtDisplayPredefinedMethod (MsgBuffer, ThisName, FALSE); 722 Count++; 723 ThisName = AcpiUtGetNextPredefinedMethod (ThisName); 724 } 725 726 printf ("%u Predefined Names are recognized\n", Count); 727 728 /* 729 * Resource Descriptor names 730 */ 731 printf ("\nPredefined Names for Resource Descriptor Fields\n\n"); 732 733 Count = 0; 734 ThisName = AcpiGbl_ResourceNames; 735 while (ThisName->Info.Name[0]) 736 { 737 NumTypes = AcpiUtGetResourceBitWidth (MsgBuffer, 738 ThisName->Info.ArgumentList); 739 740 printf ("%4.4s Field is %s bits wide%s\n", 741 ThisName->Info.Name, MsgBuffer, 742 (NumTypes > 1) ? " (depending on descriptor type)" : ""); 743 744 Count++; 745 ThisName++; 746 } 747 748 printf ("%u Resource Descriptor Field Names are recognized\n", Count); 749 750 /* 751 * Predefined scope names 752 */ 753 printf ("\nPredefined Scope/Device Names (automatically created at root)\n\n"); 754 755 ThisName = AcpiGbl_ScopeNames; 756 while (ThisName->Info.Name[0]) 757 { 758 printf ("%4.4s Scope/Device\n", ThisName->Info.Name); 759 ThisName++; 760 } 761} 762