utmisc.c revision 117521
1/******************************************************************************* 2 * 3 * Module Name: utmisc - common utility procedures 4 * $Revision: 97 $ 5 * 6 ******************************************************************************/ 7 8/****************************************************************************** 9 * 10 * 1. Copyright Notice 11 * 12 * Some or all of this work - Copyright (c) 1999 - 2003, Intel Corp. 13 * All rights reserved. 14 * 15 * 2. License 16 * 17 * 2.1. This is your license from Intel Corp. under its intellectual property 18 * rights. You may have additional license terms from the party that provided 19 * you this software, covering your right to use that party's intellectual 20 * property rights. 21 * 22 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a 23 * copy of the source code appearing in this file ("Covered Code") an 24 * irrevocable, perpetual, worldwide license under Intel's copyrights in the 25 * base code distributed originally by Intel ("Original Intel Code") to copy, 26 * make derivatives, distribute, use and display any portion of the Covered 27 * Code in any form, with the right to sublicense such rights; and 28 * 29 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent 30 * license (with the right to sublicense), under only those claims of Intel 31 * patents that are infringed by the Original Intel Code, to make, use, sell, 32 * offer to sell, and import the Covered Code and derivative works thereof 33 * solely to the minimum extent necessary to exercise the above copyright 34 * license, and in no event shall the patent license extend to any additions 35 * to or modifications of the Original Intel Code. No other license or right 36 * is granted directly or by implication, estoppel or otherwise; 37 * 38 * The above copyright and patent license is granted only if the following 39 * conditions are met: 40 * 41 * 3. Conditions 42 * 43 * 3.1. Redistribution of Source with Rights to Further Distribute Source. 44 * Redistribution of source code of any substantial portion of the Covered 45 * Code or modification with rights to further distribute source must include 46 * the above Copyright Notice, the above License, this list of Conditions, 47 * and the following Disclaimer and Export Compliance provision. In addition, 48 * Licensee must cause all Covered Code to which Licensee contributes to 49 * contain a file documenting the changes Licensee made to create that Covered 50 * Code and the date of any change. Licensee must include in that file the 51 * documentation of any changes made by any predecessor Licensee. Licensee 52 * must include a prominent statement that the modification is derived, 53 * directly or indirectly, from Original Intel Code. 54 * 55 * 3.2. Redistribution of Source with no Rights to Further Distribute Source. 56 * Redistribution of source code of any substantial portion of the Covered 57 * Code or modification without rights to further distribute source must 58 * include the following Disclaimer and Export Compliance provision in the 59 * documentation and/or other materials provided with distribution. In 60 * addition, Licensee may not authorize further sublicense of source of any 61 * portion of the Covered Code, and must include terms to the effect that the 62 * license from Licensee to its licensee is limited to the intellectual 63 * property embodied in the software Licensee provides to its licensee, and 64 * not to intellectual property embodied in modifications its licensee may 65 * make. 66 * 67 * 3.3. Redistribution of Executable. Redistribution in executable form of any 68 * substantial portion of the Covered Code or modification must reproduce the 69 * above Copyright Notice, and the following Disclaimer and Export Compliance 70 * provision in the documentation and/or other materials provided with the 71 * distribution. 72 * 73 * 3.4. Intel retains all right, title, and interest in and to the Original 74 * Intel Code. 75 * 76 * 3.5. Neither the name Intel nor any other trademark owned or controlled by 77 * Intel shall be used in advertising or otherwise to promote the sale, use or 78 * other dealings in products derived from or relating to the Covered Code 79 * without prior written authorization from Intel. 80 * 81 * 4. Disclaimer and Export Compliance 82 * 83 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED 84 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE 85 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, 86 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY 87 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY 88 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A 89 * PARTICULAR PURPOSE. 90 * 91 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES 92 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR 93 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, 94 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY 95 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL 96 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS 97 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY 98 * LIMITED REMEDY. 99 * 100 * 4.3. Licensee shall not export, either directly or indirectly, any of this 101 * software or system incorporating such software without first obtaining any 102 * required license or other approval from the U. S. Department of Commerce or 103 * any other agency or department of the United States Government. In the 104 * event Licensee exports any such software from the United States or 105 * re-exports any such software from a foreign destination, Licensee shall 106 * ensure that the distribution and export/re-export of the software is in 107 * compliance with all laws, regulations, orders, or other restrictions of the 108 * U.S. Export Administration Regulations. Licensee agrees that neither it nor 109 * any of its subsidiaries will export/re-export any technical data, process, 110 * software, or service, directly or indirectly, to any country for which the 111 * United States government or any agency thereof requires an export license, 112 * other governmental approval, or letter of assurance, without first obtaining 113 * such license, approval or letter. 114 * 115 *****************************************************************************/ 116 117 118#define __UTMISC_C__ 119 120#include "acpi.h" 121#include "acnamesp.h" 122 123 124#define _COMPONENT ACPI_UTILITIES 125 ACPI_MODULE_NAME ("utmisc") 126 127 128/******************************************************************************* 129 * 130 * FUNCTION: AcpiUtPrintString 131 * 132 * PARAMETERS: String - Null terminated ASCII string 133 * 134 * RETURN: None 135 * 136 * DESCRIPTION: Dump an ASCII string with support for ACPI-defined escape 137 * sequences. 138 * 139 ******************************************************************************/ 140 141void 142AcpiUtPrintString ( 143 char *String, 144 UINT8 MaxLength) 145{ 146 UINT32 i; 147 148 149 if (!String) 150 { 151 AcpiOsPrintf ("<\"NULL STRING PTR\">"); 152 return; 153 } 154 155 AcpiOsPrintf ("\""); 156 for (i = 0; String[i] && (i < MaxLength); i++) 157 { 158 /* Escape sequences */ 159 160 switch (String[i]) 161 { 162 case 0x07: 163 AcpiOsPrintf ("\\a"); /* BELL */ 164 break; 165 166 case 0x08: 167 AcpiOsPrintf ("\\b"); /* BACKSPACE */ 168 break; 169 170 case 0x0C: 171 AcpiOsPrintf ("\\f"); /* FORMFEED */ 172 break; 173 174 case 0x0A: 175 AcpiOsPrintf ("\\n"); /* LINEFEED */ 176 break; 177 178 case 0x0D: 179 AcpiOsPrintf ("\\r"); /* CARRIAGE RETURN*/ 180 break; 181 182 case 0x09: 183 AcpiOsPrintf ("\\t"); /* HORIZONTAL TAB */ 184 break; 185 186 case 0x0B: 187 AcpiOsPrintf ("\\v"); /* VERTICAL TAB */ 188 break; 189 190 case '\'': /* Single Quote */ 191 case '\"': /* Double Quote */ 192 case '\\': /* Backslash */ 193 AcpiOsPrintf ("\\%c", (int) String[i]); 194 break; 195 196 default: 197 198 /* Check for printable character or hex escape */ 199 200 if (ACPI_IS_PRINT (String[i])) 201 { 202 /* This is a normal character */ 203 204 AcpiOsPrintf ("%c", (int) String[i]); 205 } 206 else 207 { 208 /* All others will be Hex escapes */ 209 210 AcpiOsPrintf ("\\x%2.2X", (INT32) String[i]); 211 } 212 break; 213 } 214 } 215 AcpiOsPrintf ("\""); 216 217 if (i == MaxLength && String[i]) 218 { 219 AcpiOsPrintf ("..."); 220 } 221} 222 223 224/******************************************************************************* 225 * 226 * FUNCTION: AcpiUtDwordByteSwap 227 * 228 * PARAMETERS: Value - Value to be converted 229 * 230 * DESCRIPTION: Convert a 32-bit value to big-endian (swap the bytes) 231 * 232 ******************************************************************************/ 233 234UINT32 235AcpiUtDwordByteSwap ( 236 UINT32 Value) 237{ 238 union 239 { 240 UINT32 Value; 241 UINT8 Bytes[4]; 242 } Out; 243 244 union 245 { 246 UINT32 Value; 247 UINT8 Bytes[4]; 248 } In; 249 250 251 ACPI_FUNCTION_ENTRY (); 252 253 254 In.Value = Value; 255 256 Out.Bytes[0] = In.Bytes[3]; 257 Out.Bytes[1] = In.Bytes[2]; 258 Out.Bytes[2] = In.Bytes[1]; 259 Out.Bytes[3] = In.Bytes[0]; 260 261 return (Out.Value); 262} 263 264 265/******************************************************************************* 266 * 267 * FUNCTION: AcpiUtSetIntegerWidth 268 * 269 * PARAMETERS: Revision From DSDT header 270 * 271 * RETURN: None 272 * 273 * DESCRIPTION: Set the global integer bit width based upon the revision 274 * of the DSDT. For Revision 1 and 0, Integers are 32 bits. 275 * For Revision 2 and above, Integers are 64 bits. Yes, this 276 * makes a difference. 277 * 278 ******************************************************************************/ 279 280void 281AcpiUtSetIntegerWidth ( 282 UINT8 Revision) 283{ 284 285 if (Revision <= 1) 286 { 287 AcpiGbl_IntegerBitWidth = 32; 288 AcpiGbl_IntegerNybbleWidth = 8; 289 AcpiGbl_IntegerByteWidth = 4; 290 } 291 else 292 { 293 AcpiGbl_IntegerBitWidth = 64; 294 AcpiGbl_IntegerNybbleWidth = 16; 295 AcpiGbl_IntegerByteWidth = 8; 296 } 297} 298 299 300#ifdef ACPI_DEBUG_OUTPUT 301/******************************************************************************* 302 * 303 * FUNCTION: AcpiUtDisplayInitPathname 304 * 305 * PARAMETERS: ObjHandle - Handle whose pathname will be displayed 306 * Path - Additional path string to be appended. 307 * (NULL if no extra path) 308 * 309 * RETURN: ACPI_STATUS 310 * 311 * DESCRIPTION: Display full pathname of an object, DEBUG ONLY 312 * 313 ******************************************************************************/ 314 315void 316AcpiUtDisplayInitPathname ( 317 UINT8 Type, 318 ACPI_NAMESPACE_NODE *ObjHandle, 319 char *Path) 320{ 321 ACPI_STATUS Status; 322 ACPI_BUFFER Buffer; 323 324 325 ACPI_FUNCTION_ENTRY (); 326 327 328 /* Only print the path if the appropriate debug level is enabled */ 329 330 if (!(AcpiDbgLevel & ACPI_LV_INIT_NAMES)) 331 { 332 return; 333 } 334 335 /* Get the full pathname to the node */ 336 337 Buffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER; 338 Status = AcpiNsHandleToPathname (ObjHandle, &Buffer); 339 if (ACPI_FAILURE (Status)) 340 { 341 return; 342 } 343 344 /* Print what we're doing */ 345 346 switch (Type) 347 { 348 case ACPI_TYPE_METHOD: 349 AcpiOsPrintf ("Executing "); 350 break; 351 352 default: 353 AcpiOsPrintf ("Initializing "); 354 break; 355 } 356 357 /* Print the object type and pathname */ 358 359 AcpiOsPrintf ("%-12s %s", AcpiUtGetTypeName (Type), (char *) Buffer.Pointer); 360 361 /* Extra path is used to append names like _STA, _INI, etc. */ 362 363 if (Path) 364 { 365 AcpiOsPrintf (".%s", Path); 366 } 367 AcpiOsPrintf ("\n"); 368 369 ACPI_MEM_FREE (Buffer.Pointer); 370} 371#endif 372 373 374/******************************************************************************* 375 * 376 * FUNCTION: AcpiUtValidAcpiName 377 * 378 * PARAMETERS: Character - The character to be examined 379 * 380 * RETURN: 1 if Character may appear in a name, else 0 381 * 382 * DESCRIPTION: Check for a valid ACPI name. Each character must be one of: 383 * 1) Upper case alpha 384 * 2) numeric 385 * 3) underscore 386 * 387 ******************************************************************************/ 388 389BOOLEAN 390AcpiUtValidAcpiName ( 391 UINT32 Name) 392{ 393 char *NamePtr = (char *) &Name; 394 UINT32 i; 395 396 397 ACPI_FUNCTION_ENTRY (); 398 399 400 for (i = 0; i < ACPI_NAME_SIZE; i++) 401 { 402 if (!((NamePtr[i] == '_') || 403 (NamePtr[i] >= 'A' && NamePtr[i] <= 'Z') || 404 (NamePtr[i] >= '0' && NamePtr[i] <= '9'))) 405 { 406 return (FALSE); 407 } 408 } 409 410 return (TRUE); 411} 412 413 414/******************************************************************************* 415 * 416 * FUNCTION: AcpiUtValidAcpiCharacter 417 * 418 * PARAMETERS: Character - The character to be examined 419 * 420 * RETURN: 1 if Character may appear in a name, else 0 421 * 422 * DESCRIPTION: Check for a printable character 423 * 424 ******************************************************************************/ 425 426BOOLEAN 427AcpiUtValidAcpiCharacter ( 428 char Character) 429{ 430 431 ACPI_FUNCTION_ENTRY (); 432 433 return ((BOOLEAN) ((Character == '_') || 434 (Character >= 'A' && Character <= 'Z') || 435 (Character >= '0' && Character <= '9'))); 436} 437 438 439/******************************************************************************* 440 * 441 * FUNCTION: AcpiUtStrtoul64 442 * 443 * PARAMETERS: String - Null terminated string 444 * Terminater - Where a pointer to the terminating byte is returned 445 * Base - Radix of the string 446 * 447 * RETURN: Converted value 448 * 449 * DESCRIPTION: Convert a string into an unsigned value. 450 * 451 ******************************************************************************/ 452#define NEGATIVE 1 453#define POSITIVE 0 454 455ACPI_STATUS 456AcpiUtStrtoul64 ( 457 char *String, 458 UINT32 Base, 459 ACPI_INTEGER *RetInteger) 460{ 461 UINT32 Index; 462 ACPI_INTEGER ReturnValue = 0; 463 ACPI_STATUS Status = AE_OK; 464 ACPI_INTEGER Dividend; 465 ACPI_INTEGER Quotient; 466 467 468 *RetInteger = 0; 469 470 switch (Base) 471 { 472 case 0: 473 case 8: 474 case 10: 475 case 16: 476 break; 477 478 default: 479 /* 480 * The specified Base parameter is not in the domain of 481 * this function: 482 */ 483 return (AE_BAD_PARAMETER); 484 } 485 486 /* 487 * skip over any white space in the buffer: 488 */ 489 while (ACPI_IS_SPACE (*String) || *String == '\t') 490 { 491 ++String; 492 } 493 494 /* 495 * If the input parameter Base is zero, then we need to 496 * determine if it is octal, decimal, or hexadecimal: 497 */ 498 if (Base == 0) 499 { 500 if (*String == '0') 501 { 502 if (ACPI_TOLOWER (*(++String)) == 'x') 503 { 504 Base = 16; 505 ++String; 506 } 507 else 508 { 509 Base = 8; 510 } 511 } 512 else 513 { 514 Base = 10; 515 } 516 } 517 518 /* 519 * For octal and hexadecimal bases, skip over the leading 520 * 0 or 0x, if they are present. 521 */ 522 if (Base == 8 && *String == '0') 523 { 524 String++; 525 } 526 527 if (Base == 16 && 528 *String == '0' && 529 ACPI_TOLOWER (*(++String)) == 'x') 530 { 531 String++; 532 } 533 534 /* Main loop: convert the string to an unsigned long */ 535 536 while (*String) 537 { 538 if (ACPI_IS_DIGIT (*String)) 539 { 540 Index = ((UINT8) *String) - '0'; 541 } 542 else 543 { 544 Index = (UINT8) ACPI_TOUPPER (*String); 545 if (ACPI_IS_UPPER ((char) Index)) 546 { 547 Index = Index - 'A' + 10; 548 } 549 else 550 { 551 goto ErrorExit; 552 } 553 } 554 555 if (Index >= Base) 556 { 557 goto ErrorExit; 558 } 559 560 /* Check to see if value is out of range: */ 561 562 Dividend = ACPI_INTEGER_MAX - (ACPI_INTEGER) Index; 563 (void) AcpiUtShortDivide (&Dividend, Base, &Quotient, NULL); 564 if (ReturnValue > Quotient) 565 { 566 goto ErrorExit; 567 } 568 569 ReturnValue *= Base; 570 ReturnValue += Index; 571 ++String; 572 } 573 574 *RetInteger = ReturnValue; 575 return (Status); 576 577 578ErrorExit: 579 switch (Base) 580 { 581 case 8: 582 Status = AE_BAD_OCTAL_CONSTANT; 583 break; 584 585 case 10: 586 Status = AE_BAD_DECIMAL_CONSTANT; 587 break; 588 589 case 16: 590 Status = AE_BAD_HEX_CONSTANT; 591 break; 592 593 default: 594 /* Base validated above */ 595 break; 596 } 597 598 return (Status); 599} 600 601 602/******************************************************************************* 603 * 604 * FUNCTION: AcpiUtStrupr 605 * 606 * PARAMETERS: SrcString - The source string to convert to 607 * 608 * RETURN: SrcString 609 * 610 * DESCRIPTION: Convert string to uppercase 611 * 612 ******************************************************************************/ 613 614char * 615AcpiUtStrupr ( 616 char *SrcString) 617{ 618 char *String; 619 620 621 ACPI_FUNCTION_ENTRY (); 622 623 624 /* Walk entire string, uppercasing the letters */ 625 626 for (String = SrcString; *String; ) 627 { 628 *String = (char) ACPI_TOUPPER (*String); 629 String++; 630 } 631 632 return (SrcString); 633} 634 635/******************************************************************************* 636 * 637 * FUNCTION: AcpiUtMutexInitialize 638 * 639 * PARAMETERS: None. 640 * 641 * RETURN: Status 642 * 643 * DESCRIPTION: Create the system mutex objects. 644 * 645 ******************************************************************************/ 646 647ACPI_STATUS 648AcpiUtMutexInitialize ( 649 void) 650{ 651 UINT32 i; 652 ACPI_STATUS Status; 653 654 655 ACPI_FUNCTION_TRACE ("UtMutexInitialize"); 656 657 658 /* 659 * Create each of the predefined mutex objects 660 */ 661 for (i = 0; i < NUM_MUTEX; i++) 662 { 663 Status = AcpiUtCreateMutex (i); 664 if (ACPI_FAILURE (Status)) 665 { 666 return_ACPI_STATUS (Status); 667 } 668 } 669 670 671 Status = AcpiOsCreateLock (&AcpiGbl_GpeLock); 672 673 return_ACPI_STATUS (AE_OK); 674} 675 676 677/******************************************************************************* 678 * 679 * FUNCTION: AcpiUtMutexTerminate 680 * 681 * PARAMETERS: None. 682 * 683 * RETURN: None. 684 * 685 * DESCRIPTION: Delete all of the system mutex objects. 686 * 687 ******************************************************************************/ 688 689void 690AcpiUtMutexTerminate ( 691 void) 692{ 693 UINT32 i; 694 695 696 ACPI_FUNCTION_TRACE ("UtMutexTerminate"); 697 698 699 /* 700 * Delete each predefined mutex object 701 */ 702 for (i = 0; i < NUM_MUTEX; i++) 703 { 704 (void) AcpiUtDeleteMutex (i); 705 } 706 707 AcpiOsDeleteLock (AcpiGbl_GpeLock); 708 return_VOID; 709} 710 711 712/******************************************************************************* 713 * 714 * FUNCTION: AcpiUtCreateMutex 715 * 716 * PARAMETERS: MutexID - ID of the mutex to be created 717 * 718 * RETURN: Status 719 * 720 * DESCRIPTION: Create a mutex object. 721 * 722 ******************************************************************************/ 723 724ACPI_STATUS 725AcpiUtCreateMutex ( 726 ACPI_MUTEX_HANDLE MutexId) 727{ 728 ACPI_STATUS Status = AE_OK; 729 730 731 ACPI_FUNCTION_TRACE_U32 ("UtCreateMutex", MutexId); 732 733 734 if (MutexId > MAX_MUTEX) 735 { 736 return_ACPI_STATUS (AE_BAD_PARAMETER); 737 } 738 739 if (!AcpiGbl_MutexInfo[MutexId].Mutex) 740 { 741 Status = AcpiOsCreateSemaphore (1, 1, 742 &AcpiGbl_MutexInfo[MutexId].Mutex); 743 AcpiGbl_MutexInfo[MutexId].OwnerId = ACPI_MUTEX_NOT_ACQUIRED; 744 AcpiGbl_MutexInfo[MutexId].UseCount = 0; 745 } 746 747 return_ACPI_STATUS (Status); 748} 749 750 751/******************************************************************************* 752 * 753 * FUNCTION: AcpiUtDeleteMutex 754 * 755 * PARAMETERS: MutexID - ID of the mutex to be deleted 756 * 757 * RETURN: Status 758 * 759 * DESCRIPTION: Delete a mutex object. 760 * 761 ******************************************************************************/ 762 763ACPI_STATUS 764AcpiUtDeleteMutex ( 765 ACPI_MUTEX_HANDLE MutexId) 766{ 767 ACPI_STATUS Status; 768 769 770 ACPI_FUNCTION_TRACE_U32 ("UtDeleteMutex", MutexId); 771 772 773 if (MutexId > MAX_MUTEX) 774 { 775 return_ACPI_STATUS (AE_BAD_PARAMETER); 776 } 777 778 Status = AcpiOsDeleteSemaphore (AcpiGbl_MutexInfo[MutexId].Mutex); 779 780 AcpiGbl_MutexInfo[MutexId].Mutex = NULL; 781 AcpiGbl_MutexInfo[MutexId].OwnerId = ACPI_MUTEX_NOT_ACQUIRED; 782 783 return_ACPI_STATUS (Status); 784} 785 786 787/******************************************************************************* 788 * 789 * FUNCTION: AcpiUtAcquireMutex 790 * 791 * PARAMETERS: MutexID - ID of the mutex to be acquired 792 * 793 * RETURN: Status 794 * 795 * DESCRIPTION: Acquire a mutex object. 796 * 797 ******************************************************************************/ 798 799ACPI_STATUS 800AcpiUtAcquireMutex ( 801 ACPI_MUTEX_HANDLE MutexId) 802{ 803 ACPI_STATUS Status; 804 UINT32 i; 805 UINT32 ThisThreadId; 806 807 808 ACPI_FUNCTION_NAME ("UtAcquireMutex"); 809 810 811 if (MutexId > MAX_MUTEX) 812 { 813 return (AE_BAD_PARAMETER); 814 } 815 816 ThisThreadId = AcpiOsGetThreadId (); 817 818 /* 819 * Deadlock prevention. Check if this thread owns any mutexes of value 820 * greater than or equal to this one. If so, the thread has violated 821 * the mutex ordering rule. This indicates a coding error somewhere in 822 * the ACPI subsystem code. 823 */ 824 for (i = MutexId; i < MAX_MUTEX; i++) 825 { 826 if (AcpiGbl_MutexInfo[i].OwnerId == ThisThreadId) 827 { 828 if (i == MutexId) 829 { 830 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, 831 "Mutex [%s] already acquired by this thread [%X]\n", 832 AcpiUtGetMutexName (MutexId), ThisThreadId)); 833 834 return (AE_ALREADY_ACQUIRED); 835 } 836 837 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, 838 "Invalid acquire order: Thread %X owns [%s], wants [%s]\n", 839 ThisThreadId, AcpiUtGetMutexName (i), 840 AcpiUtGetMutexName (MutexId))); 841 842 return (AE_ACQUIRE_DEADLOCK); 843 } 844 } 845 846 ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, 847 "Thread %X attempting to acquire Mutex [%s]\n", 848 ThisThreadId, AcpiUtGetMutexName (MutexId))); 849 850 Status = AcpiOsWaitSemaphore (AcpiGbl_MutexInfo[MutexId].Mutex, 851 1, ACPI_WAIT_FOREVER); 852 if (ACPI_SUCCESS (Status)) 853 { 854 ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, "Thread %X acquired Mutex [%s]\n", 855 ThisThreadId, AcpiUtGetMutexName (MutexId))); 856 857 AcpiGbl_MutexInfo[MutexId].UseCount++; 858 AcpiGbl_MutexInfo[MutexId].OwnerId = ThisThreadId; 859 } 860 else 861 { 862 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Thread %X could not acquire Mutex [%s] %s\n", 863 ThisThreadId, AcpiUtGetMutexName (MutexId), 864 AcpiFormatException (Status))); 865 } 866 867 return (Status); 868} 869 870 871/******************************************************************************* 872 * 873 * FUNCTION: AcpiUtReleaseMutex 874 * 875 * PARAMETERS: MutexID - ID of the mutex to be released 876 * 877 * RETURN: Status 878 * 879 * DESCRIPTION: Release a mutex object. 880 * 881 ******************************************************************************/ 882 883ACPI_STATUS 884AcpiUtReleaseMutex ( 885 ACPI_MUTEX_HANDLE MutexId) 886{ 887 ACPI_STATUS Status; 888 UINT32 i; 889 UINT32 ThisThreadId; 890 891 892 ACPI_FUNCTION_NAME ("UtReleaseMutex"); 893 894 895 ThisThreadId = AcpiOsGetThreadId (); 896 ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, 897 "Thread %X releasing Mutex [%s]\n", ThisThreadId, 898 AcpiUtGetMutexName (MutexId))); 899 900 if (MutexId > MAX_MUTEX) 901 { 902 return (AE_BAD_PARAMETER); 903 } 904 905 /* 906 * Mutex must be acquired in order to release it! 907 */ 908 if (AcpiGbl_MutexInfo[MutexId].OwnerId == ACPI_MUTEX_NOT_ACQUIRED) 909 { 910 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, 911 "Mutex [%s] is not acquired, cannot release\n", 912 AcpiUtGetMutexName (MutexId))); 913 914 return (AE_NOT_ACQUIRED); 915 } 916 917 /* 918 * Deadlock prevention. Check if this thread owns any mutexes of value 919 * greater than this one. If so, the thread has violated the mutex 920 * ordering rule. This indicates a coding error somewhere in 921 * the ACPI subsystem code. 922 */ 923 for (i = MutexId; i < MAX_MUTEX; i++) 924 { 925 if (AcpiGbl_MutexInfo[i].OwnerId == ThisThreadId) 926 { 927 if (i == MutexId) 928 { 929 continue; 930 } 931 932 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, 933 "Invalid release order: owns [%s], releasing [%s]\n", 934 AcpiUtGetMutexName (i), AcpiUtGetMutexName (MutexId))); 935 936 return (AE_RELEASE_DEADLOCK); 937 } 938 } 939 940 /* Mark unlocked FIRST */ 941 942 AcpiGbl_MutexInfo[MutexId].OwnerId = ACPI_MUTEX_NOT_ACQUIRED; 943 944 Status = AcpiOsSignalSemaphore (AcpiGbl_MutexInfo[MutexId].Mutex, 1); 945 946 if (ACPI_FAILURE (Status)) 947 { 948 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Thread %X could not release Mutex [%s] %s\n", 949 ThisThreadId, AcpiUtGetMutexName (MutexId), 950 AcpiFormatException (Status))); 951 } 952 else 953 { 954 ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, "Thread %X released Mutex [%s]\n", 955 ThisThreadId, AcpiUtGetMutexName (MutexId))); 956 } 957 958 return (Status); 959} 960 961 962/******************************************************************************* 963 * 964 * FUNCTION: AcpiUtCreateUpdateStateAndPush 965 * 966 * PARAMETERS: *Object - Object to be added to the new state 967 * Action - Increment/Decrement 968 * StateList - List the state will be added to 969 * 970 * RETURN: None 971 * 972 * DESCRIPTION: Create a new state and push it 973 * 974 ******************************************************************************/ 975 976ACPI_STATUS 977AcpiUtCreateUpdateStateAndPush ( 978 ACPI_OPERAND_OBJECT *Object, 979 UINT16 Action, 980 ACPI_GENERIC_STATE **StateList) 981{ 982 ACPI_GENERIC_STATE *State; 983 984 985 ACPI_FUNCTION_ENTRY (); 986 987 988 /* Ignore null objects; these are expected */ 989 990 if (!Object) 991 { 992 return (AE_OK); 993 } 994 995 State = AcpiUtCreateUpdateState (Object, Action); 996 if (!State) 997 { 998 return (AE_NO_MEMORY); 999 } 1000 1001 AcpiUtPushGenericState (StateList, State); 1002 return (AE_OK); 1003} 1004 1005 1006/******************************************************************************* 1007 * 1008 * FUNCTION: AcpiUtCreatePkgStateAndPush 1009 * 1010 * PARAMETERS: *Object - Object to be added to the new state 1011 * Action - Increment/Decrement 1012 * StateList - List the state will be added to 1013 * 1014 * RETURN: None 1015 * 1016 * DESCRIPTION: Create a new state and push it 1017 * 1018 ******************************************************************************/ 1019 1020ACPI_STATUS 1021AcpiUtCreatePkgStateAndPush ( 1022 void *InternalObject, 1023 void *ExternalObject, 1024 UINT16 Index, 1025 ACPI_GENERIC_STATE **StateList) 1026{ 1027 ACPI_GENERIC_STATE *State; 1028 1029 1030 ACPI_FUNCTION_ENTRY (); 1031 1032 1033 State = AcpiUtCreatePkgState (InternalObject, ExternalObject, Index); 1034 if (!State) 1035 { 1036 return (AE_NO_MEMORY); 1037 } 1038 1039 AcpiUtPushGenericState (StateList, State); 1040 return (AE_OK); 1041} 1042 1043 1044/******************************************************************************* 1045 * 1046 * FUNCTION: AcpiUtPushGenericState 1047 * 1048 * PARAMETERS: ListHead - Head of the state stack 1049 * State - State object to push 1050 * 1051 * RETURN: Status 1052 * 1053 * DESCRIPTION: Push a state object onto a state stack 1054 * 1055 ******************************************************************************/ 1056 1057void 1058AcpiUtPushGenericState ( 1059 ACPI_GENERIC_STATE **ListHead, 1060 ACPI_GENERIC_STATE *State) 1061{ 1062 ACPI_FUNCTION_TRACE ("UtPushGenericState"); 1063 1064 1065 /* Push the state object onto the front of the list (stack) */ 1066 1067 State->Common.Next = *ListHead; 1068 *ListHead = State; 1069 1070 return_VOID; 1071} 1072 1073 1074/******************************************************************************* 1075 * 1076 * FUNCTION: AcpiUtPopGenericState 1077 * 1078 * PARAMETERS: ListHead - Head of the state stack 1079 * 1080 * RETURN: Status 1081 * 1082 * DESCRIPTION: Pop a state object from a state stack 1083 * 1084 ******************************************************************************/ 1085 1086ACPI_GENERIC_STATE * 1087AcpiUtPopGenericState ( 1088 ACPI_GENERIC_STATE **ListHead) 1089{ 1090 ACPI_GENERIC_STATE *State; 1091 1092 1093 ACPI_FUNCTION_TRACE ("UtPopGenericState"); 1094 1095 1096 /* Remove the state object at the head of the list (stack) */ 1097 1098 State = *ListHead; 1099 if (State) 1100 { 1101 /* Update the list head */ 1102 1103 *ListHead = State->Common.Next; 1104 } 1105 1106 return_PTR (State); 1107} 1108 1109 1110/******************************************************************************* 1111 * 1112 * FUNCTION: AcpiUtCreateGenericState 1113 * 1114 * PARAMETERS: None 1115 * 1116 * RETURN: Status 1117 * 1118 * DESCRIPTION: Create a generic state object. Attempt to obtain one from 1119 * the global state cache; If none available, create a new one. 1120 * 1121 ******************************************************************************/ 1122 1123ACPI_GENERIC_STATE * 1124AcpiUtCreateGenericState (void) 1125{ 1126 ACPI_GENERIC_STATE *State; 1127 1128 1129 ACPI_FUNCTION_ENTRY (); 1130 1131 1132 State = AcpiUtAcquireFromCache (ACPI_MEM_LIST_STATE); 1133 1134 /* Initialize */ 1135 1136 if (State) 1137 { 1138 State->Common.DataType = ACPI_DESC_TYPE_STATE; 1139 } 1140 1141 return (State); 1142} 1143 1144 1145/******************************************************************************* 1146 * 1147 * FUNCTION: AcpiUtCreateThreadState 1148 * 1149 * PARAMETERS: None 1150 * 1151 * RETURN: Thread State 1152 * 1153 * DESCRIPTION: Create a "Thread State" - a flavor of the generic state used 1154 * to track per-thread info during method execution 1155 * 1156 ******************************************************************************/ 1157 1158ACPI_THREAD_STATE * 1159AcpiUtCreateThreadState ( 1160 void) 1161{ 1162 ACPI_GENERIC_STATE *State; 1163 1164 1165 ACPI_FUNCTION_TRACE ("UtCreateThreadState"); 1166 1167 1168 /* Create the generic state object */ 1169 1170 State = AcpiUtCreateGenericState (); 1171 if (!State) 1172 { 1173 return_PTR (NULL); 1174 } 1175 1176 /* Init fields specific to the update struct */ 1177 1178 State->Common.DataType = ACPI_DESC_TYPE_STATE_THREAD; 1179 State->Thread.ThreadId = AcpiOsGetThreadId (); 1180 1181 return_PTR ((ACPI_THREAD_STATE *) State); 1182} 1183 1184 1185/******************************************************************************* 1186 * 1187 * FUNCTION: AcpiUtCreateUpdateState 1188 * 1189 * PARAMETERS: Object - Initial Object to be installed in the 1190 * state 1191 * Action - Update action to be performed 1192 * 1193 * RETURN: Status 1194 * 1195 * DESCRIPTION: Create an "Update State" - a flavor of the generic state used 1196 * to update reference counts and delete complex objects such 1197 * as packages. 1198 * 1199 ******************************************************************************/ 1200 1201ACPI_GENERIC_STATE * 1202AcpiUtCreateUpdateState ( 1203 ACPI_OPERAND_OBJECT *Object, 1204 UINT16 Action) 1205{ 1206 ACPI_GENERIC_STATE *State; 1207 1208 1209 ACPI_FUNCTION_TRACE_PTR ("UtCreateUpdateState", Object); 1210 1211 1212 /* Create the generic state object */ 1213 1214 State = AcpiUtCreateGenericState (); 1215 if (!State) 1216 { 1217 return_PTR (NULL); 1218 } 1219 1220 /* Init fields specific to the update struct */ 1221 1222 State->Common.DataType = ACPI_DESC_TYPE_STATE_UPDATE; 1223 State->Update.Object = Object; 1224 State->Update.Value = Action; 1225 1226 return_PTR (State); 1227} 1228 1229 1230/******************************************************************************* 1231 * 1232 * FUNCTION: AcpiUtCreatePkgState 1233 * 1234 * PARAMETERS: Object - Initial Object to be installed in the 1235 * state 1236 * Action - Update action to be performed 1237 * 1238 * RETURN: Status 1239 * 1240 * DESCRIPTION: Create a "Package State" 1241 * 1242 ******************************************************************************/ 1243 1244ACPI_GENERIC_STATE * 1245AcpiUtCreatePkgState ( 1246 void *InternalObject, 1247 void *ExternalObject, 1248 UINT16 Index) 1249{ 1250 ACPI_GENERIC_STATE *State; 1251 1252 1253 ACPI_FUNCTION_TRACE_PTR ("UtCreatePkgState", InternalObject); 1254 1255 1256 /* Create the generic state object */ 1257 1258 State = AcpiUtCreateGenericState (); 1259 if (!State) 1260 { 1261 return_PTR (NULL); 1262 } 1263 1264 /* Init fields specific to the update struct */ 1265 1266 State->Common.DataType = ACPI_DESC_TYPE_STATE_PACKAGE; 1267 State->Pkg.SourceObject = (ACPI_OPERAND_OBJECT *) InternalObject; 1268 State->Pkg.DestObject = ExternalObject; 1269 State->Pkg.Index = Index; 1270 State->Pkg.NumPackages = 1; 1271 1272 return_PTR (State); 1273} 1274 1275 1276/******************************************************************************* 1277 * 1278 * FUNCTION: AcpiUtCreateControlState 1279 * 1280 * PARAMETERS: None 1281 * 1282 * RETURN: Status 1283 * 1284 * DESCRIPTION: Create a "Control State" - a flavor of the generic state used 1285 * to support nested IF/WHILE constructs in the AML. 1286 * 1287 ******************************************************************************/ 1288 1289ACPI_GENERIC_STATE * 1290AcpiUtCreateControlState ( 1291 void) 1292{ 1293 ACPI_GENERIC_STATE *State; 1294 1295 1296 ACPI_FUNCTION_TRACE ("UtCreateControlState"); 1297 1298 1299 /* Create the generic state object */ 1300 1301 State = AcpiUtCreateGenericState (); 1302 if (!State) 1303 { 1304 return_PTR (NULL); 1305 } 1306 1307 /* Init fields specific to the control struct */ 1308 1309 State->Common.DataType = ACPI_DESC_TYPE_STATE_CONTROL; 1310 State->Common.State = ACPI_CONTROL_CONDITIONAL_EXECUTING; 1311 1312 return_PTR (State); 1313} 1314 1315 1316/******************************************************************************* 1317 * 1318 * FUNCTION: AcpiUtDeleteGenericState 1319 * 1320 * PARAMETERS: State - The state object to be deleted 1321 * 1322 * RETURN: Status 1323 * 1324 * DESCRIPTION: Put a state object back into the global state cache. The object 1325 * is not actually freed at this time. 1326 * 1327 ******************************************************************************/ 1328 1329void 1330AcpiUtDeleteGenericState ( 1331 ACPI_GENERIC_STATE *State) 1332{ 1333 ACPI_FUNCTION_TRACE ("UtDeleteGenericState"); 1334 1335 1336 AcpiUtReleaseToCache (ACPI_MEM_LIST_STATE, State); 1337 return_VOID; 1338} 1339 1340 1341/******************************************************************************* 1342 * 1343 * FUNCTION: AcpiUtDeleteGenericStateCache 1344 * 1345 * PARAMETERS: None 1346 * 1347 * RETURN: Status 1348 * 1349 * DESCRIPTION: Purge the global state object cache. Used during subsystem 1350 * termination. 1351 * 1352 ******************************************************************************/ 1353 1354void 1355AcpiUtDeleteGenericStateCache ( 1356 void) 1357{ 1358 ACPI_FUNCTION_TRACE ("UtDeleteGenericStateCache"); 1359 1360 1361 AcpiUtDeleteGenericCache (ACPI_MEM_LIST_STATE); 1362 return_VOID; 1363} 1364 1365 1366/******************************************************************************* 1367 * 1368 * FUNCTION: AcpiUtWalkPackageTree 1369 * 1370 * PARAMETERS: ObjDesc - The Package object on which to resolve refs 1371 * 1372 * RETURN: Status 1373 * 1374 * DESCRIPTION: Walk through a package 1375 * 1376 ******************************************************************************/ 1377 1378ACPI_STATUS 1379AcpiUtWalkPackageTree ( 1380 ACPI_OPERAND_OBJECT *SourceObject, 1381 void *TargetObject, 1382 ACPI_PKG_CALLBACK WalkCallback, 1383 void *Context) 1384{ 1385 ACPI_STATUS Status = AE_OK; 1386 ACPI_GENERIC_STATE *StateList = NULL; 1387 ACPI_GENERIC_STATE *State; 1388 UINT32 ThisIndex; 1389 ACPI_OPERAND_OBJECT *ThisSourceObj; 1390 1391 1392 ACPI_FUNCTION_TRACE ("UtWalkPackageTree"); 1393 1394 1395 State = AcpiUtCreatePkgState (SourceObject, TargetObject, 0); 1396 if (!State) 1397 { 1398 return_ACPI_STATUS (AE_NO_MEMORY); 1399 } 1400 1401 while (State) 1402 { 1403 /* Get one element of the package */ 1404 1405 ThisIndex = State->Pkg.Index; 1406 ThisSourceObj = (ACPI_OPERAND_OBJECT *) 1407 State->Pkg.SourceObject->Package.Elements[ThisIndex]; 1408 1409 /* 1410 * Check for: 1411 * 1) An uninitialized package element. It is completely 1412 * legal to declare a package and leave it uninitialized 1413 * 2) Not an internal object - can be a namespace node instead 1414 * 3) Any type other than a package. Packages are handled in else 1415 * case below. 1416 */ 1417 if ((!ThisSourceObj) || 1418 (ACPI_GET_DESCRIPTOR_TYPE (ThisSourceObj) != ACPI_DESC_TYPE_OPERAND) || 1419 (ACPI_GET_OBJECT_TYPE (ThisSourceObj) != ACPI_TYPE_PACKAGE)) 1420 { 1421 Status = WalkCallback (ACPI_COPY_TYPE_SIMPLE, ThisSourceObj, 1422 State, Context); 1423 if (ACPI_FAILURE (Status)) 1424 { 1425 return_ACPI_STATUS (Status); 1426 } 1427 1428 State->Pkg.Index++; 1429 while (State->Pkg.Index >= State->Pkg.SourceObject->Package.Count) 1430 { 1431 /* 1432 * We've handled all of the objects at this level, This means 1433 * that we have just completed a package. That package may 1434 * have contained one or more packages itself. 1435 * 1436 * Delete this state and pop the previous state (package). 1437 */ 1438 AcpiUtDeleteGenericState (State); 1439 State = AcpiUtPopGenericState (&StateList); 1440 1441 /* Finished when there are no more states */ 1442 1443 if (!State) 1444 { 1445 /* 1446 * We have handled all of the objects in the top level 1447 * package just add the length of the package objects 1448 * and exit 1449 */ 1450 return_ACPI_STATUS (AE_OK); 1451 } 1452 1453 /* 1454 * Go back up a level and move the index past the just 1455 * completed package object. 1456 */ 1457 State->Pkg.Index++; 1458 } 1459 } 1460 else 1461 { 1462 /* This is a subobject of type package */ 1463 1464 Status = WalkCallback (ACPI_COPY_TYPE_PACKAGE, ThisSourceObj, 1465 State, Context); 1466 if (ACPI_FAILURE (Status)) 1467 { 1468 return_ACPI_STATUS (Status); 1469 } 1470 1471 /* 1472 * Push the current state and create a new one 1473 * The callback above returned a new target package object. 1474 */ 1475 AcpiUtPushGenericState (&StateList, State); 1476 State = AcpiUtCreatePkgState (ThisSourceObj, 1477 State->Pkg.ThisTargetObj, 0); 1478 if (!State) 1479 { 1480 return_ACPI_STATUS (AE_NO_MEMORY); 1481 } 1482 } 1483 } 1484 1485 /* We should never get here */ 1486 1487 return_ACPI_STATUS (AE_AML_INTERNAL); 1488} 1489 1490 1491/******************************************************************************* 1492 * 1493 * FUNCTION: AcpiUtGenerateChecksum 1494 * 1495 * PARAMETERS: Buffer - Buffer to be scanned 1496 * Length - number of bytes to examine 1497 * 1498 * RETURN: checksum 1499 * 1500 * DESCRIPTION: Generate a checksum on a raw buffer 1501 * 1502 ******************************************************************************/ 1503 1504UINT8 1505AcpiUtGenerateChecksum ( 1506 UINT8 *Buffer, 1507 UINT32 Length) 1508{ 1509 UINT32 i; 1510 signed char Sum = 0; 1511 1512 1513 for (i = 0; i < Length; i++) 1514 { 1515 Sum = (signed char) (Sum + Buffer[i]); 1516 } 1517 1518 return ((UINT8) (0 - Sum)); 1519} 1520 1521 1522/******************************************************************************* 1523 * 1524 * FUNCTION: AcpiUtGetResourceEndTag 1525 * 1526 * PARAMETERS: ObjDesc - The resource template buffer object 1527 * 1528 * RETURN: Pointer to the end tag 1529 * 1530 * DESCRIPTION: Find the END_TAG resource descriptor in a resource template 1531 * 1532 ******************************************************************************/ 1533 1534 1535UINT8 * 1536AcpiUtGetResourceEndTag ( 1537 ACPI_OPERAND_OBJECT *ObjDesc) 1538{ 1539 UINT8 BufferByte; 1540 UINT8 *Buffer; 1541 UINT8 *EndBuffer; 1542 1543 1544 Buffer = ObjDesc->Buffer.Pointer; 1545 EndBuffer = Buffer + ObjDesc->Buffer.Length; 1546 1547 while (Buffer < EndBuffer) 1548 { 1549 BufferByte = *Buffer; 1550 if (BufferByte & ACPI_RDESC_TYPE_MASK) 1551 { 1552 /* Large Descriptor - Length is next 2 bytes */ 1553 1554 Buffer += ((*(Buffer+1) | (*(Buffer+2) << 8)) + 3); 1555 } 1556 else 1557 { 1558 /* Small Descriptor. End Tag will be found here */ 1559 1560 if ((BufferByte & ACPI_RDESC_SMALL_MASK) == ACPI_RDESC_TYPE_END_TAG) 1561 { 1562 /* Found the end tag descriptor, all done. */ 1563 1564 return (Buffer); 1565 } 1566 1567 /* Length is in the header */ 1568 1569 Buffer += ((BufferByte & 0x07) + 1); 1570 } 1571 } 1572 1573 /* End tag not found */ 1574 1575 return (NULL); 1576} 1577 1578 1579/******************************************************************************* 1580 * 1581 * FUNCTION: AcpiUtReportError 1582 * 1583 * PARAMETERS: ModuleName - Caller's module name (for error output) 1584 * LineNumber - Caller's line number (for error output) 1585 * ComponentId - Caller's component ID (for error output) 1586 * Message - Error message to use on failure 1587 * 1588 * RETURN: None 1589 * 1590 * DESCRIPTION: Print error message 1591 * 1592 ******************************************************************************/ 1593 1594void 1595AcpiUtReportError ( 1596 char *ModuleName, 1597 UINT32 LineNumber, 1598 UINT32 ComponentId) 1599{ 1600 1601 1602 AcpiOsPrintf ("%8s-%04d: *** Error: ", ModuleName, LineNumber); 1603} 1604 1605 1606/******************************************************************************* 1607 * 1608 * FUNCTION: AcpiUtReportWarning 1609 * 1610 * PARAMETERS: ModuleName - Caller's module name (for error output) 1611 * LineNumber - Caller's line number (for error output) 1612 * ComponentId - Caller's component ID (for error output) 1613 * Message - Error message to use on failure 1614 * 1615 * RETURN: None 1616 * 1617 * DESCRIPTION: Print warning message 1618 * 1619 ******************************************************************************/ 1620 1621void 1622AcpiUtReportWarning ( 1623 char *ModuleName, 1624 UINT32 LineNumber, 1625 UINT32 ComponentId) 1626{ 1627 1628 AcpiOsPrintf ("%8s-%04d: *** Warning: ", ModuleName, LineNumber); 1629} 1630 1631 1632/******************************************************************************* 1633 * 1634 * FUNCTION: AcpiUtReportInfo 1635 * 1636 * PARAMETERS: ModuleName - Caller's module name (for error output) 1637 * LineNumber - Caller's line number (for error output) 1638 * ComponentId - Caller's component ID (for error output) 1639 * Message - Error message to use on failure 1640 * 1641 * RETURN: None 1642 * 1643 * DESCRIPTION: Print information message 1644 * 1645 ******************************************************************************/ 1646 1647void 1648AcpiUtReportInfo ( 1649 char *ModuleName, 1650 UINT32 LineNumber, 1651 UINT32 ComponentId) 1652{ 1653 1654 AcpiOsPrintf ("%8s-%04d: *** Info: ", ModuleName, LineNumber); 1655} 1656 1657 1658