1 /******************************************************************************* 2 * 3 * Module Name: utmisc - common utility procedures 4 * 5 ******************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2008, 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 <linux/module.h> 45 46 #include <acpi/acpi.h> 47 #include "accommon.h" 48 #include "acnamesp.h" 49 50 #define _COMPONENT ACPI_UTILITIES 51 ACPI_MODULE_NAME("utmisc") 52 53 /* 54 * Common suffix for messages 55 */ 56 #define ACPI_COMMON_MSG_SUFFIX \ 57 acpi_os_printf(" (%8.8X/%s-%u)\n", ACPI_CA_VERSION, module_name, line_number) 58 /******************************************************************************* 59 * 60 * FUNCTION: acpi_ut_validate_exception 61 * 62 * PARAMETERS: Status - The acpi_status code to be formatted 63 * 64 * RETURN: A string containing the exception text. NULL if exception is 65 * not valid. 66 * 67 * DESCRIPTION: This function validates and translates an ACPI exception into 68 * an ASCII string. 69 * 70 ******************************************************************************/ 71 const char *acpi_ut_validate_exception(acpi_status status) 72 { 73 u32 sub_status; 74 const char *exception = NULL; 75 76 ACPI_FUNCTION_ENTRY(); 77 78 /* 79 * Status is composed of two parts, a "type" and an actual code 80 */ 81 sub_status = (status & ~AE_CODE_MASK); 82 83 switch (status & AE_CODE_MASK) { 84 case AE_CODE_ENVIRONMENTAL: 85 86 if (sub_status <= AE_CODE_ENV_MAX) { 87 exception = acpi_gbl_exception_names_env[sub_status]; 88 } 89 break; 90 91 case AE_CODE_PROGRAMMER: 92 93 if (sub_status <= AE_CODE_PGM_MAX) { 94 exception = acpi_gbl_exception_names_pgm[sub_status]; 95 } 96 break; 97 98 case AE_CODE_ACPI_TABLES: 99 100 if (sub_status <= AE_CODE_TBL_MAX) { 101 exception = acpi_gbl_exception_names_tbl[sub_status]; 102 } 103 break; 104 105 case AE_CODE_AML: 106 107 if (sub_status <= AE_CODE_AML_MAX) { 108 exception = acpi_gbl_exception_names_aml[sub_status]; 109 } 110 break; 111 112 case AE_CODE_CONTROL: 113 114 if (sub_status <= AE_CODE_CTRL_MAX) { 115 exception = acpi_gbl_exception_names_ctrl[sub_status]; 116 } 117 break; 118 119 default: 120 break; 121 } 122 123 return (ACPI_CAST_PTR(const char, exception)); 124 } 125 126 /******************************************************************************* 127 * 128 * FUNCTION: acpi_ut_is_pci_root_bridge 129 * 130 * PARAMETERS: Id - The HID/CID in string format 131 * 132 * RETURN: TRUE if the Id is a match for a PCI/PCI-Express Root Bridge 133 * 134 * DESCRIPTION: Determine if the input ID is a PCI Root Bridge ID. 135 * 136 ******************************************************************************/ 137 138 u8 acpi_ut_is_pci_root_bridge(char *id) 139 { 140 141 /* 142 * Check if this is a PCI root bridge. 143 * ACPI 3.0+: check for a PCI Express root also. 144 */ 145 if (!(ACPI_STRCMP(id, 146 PCI_ROOT_HID_STRING)) || 147 !(ACPI_STRCMP(id, PCI_EXPRESS_ROOT_HID_STRING))) { 148 return (TRUE); 149 } 150 151 return (FALSE); 152 } 153 154 /******************************************************************************* 155 * 156 * FUNCTION: acpi_ut_is_aml_table 157 * 158 * PARAMETERS: Table - An ACPI table 159 * 160 * RETURN: TRUE if table contains executable AML; FALSE otherwise 161 * 162 * DESCRIPTION: Check ACPI Signature for a table that contains AML code. 163 * Currently, these are DSDT,SSDT,PSDT. All other table types are 164 * data tables that do not contain AML code. 165 * 166 ******************************************************************************/ 167 168 u8 acpi_ut_is_aml_table(struct acpi_table_header *table) 169 { 170 171 /* These are the only tables that contain executable AML */ 172 173 if (ACPI_COMPARE_NAME(table->signature, ACPI_SIG_DSDT) || 174 ACPI_COMPARE_NAME(table->signature, ACPI_SIG_PSDT) || 175 ACPI_COMPARE_NAME(table->signature, ACPI_SIG_SSDT)) { 176 return (TRUE); 177 } 178 179 return (FALSE); 180 } 181 182 /******************************************************************************* 183 * 184 * FUNCTION: acpi_ut_allocate_owner_id 185 * 186 * PARAMETERS: owner_id - Where the new owner ID is returned 187 * 188 * RETURN: Status 189 * 190 * DESCRIPTION: Allocate a table or method owner ID. The owner ID is used to 191 * track objects created by the table or method, to be deleted 192 * when the method exits or the table is unloaded. 193 * 194 ******************************************************************************/ 195 196 acpi_status acpi_ut_allocate_owner_id(acpi_owner_id * owner_id) 197 { 198 u32 i; 199 u32 j; 200 u32 k; 201 acpi_status status; 202 203 ACPI_FUNCTION_TRACE(ut_allocate_owner_id); 204 205 /* Guard against multiple allocations of ID to the same location */ 206 207 if (*owner_id) { 208 ACPI_ERROR((AE_INFO, "Owner ID [%2.2X] already exists", 209 *owner_id)); 210 return_ACPI_STATUS(AE_ALREADY_EXISTS); 211 } 212 213 /* Mutex for the global ID mask */ 214 215 status = acpi_ut_acquire_mutex(ACPI_MTX_CACHES); 216 if (ACPI_FAILURE(status)) { 217 return_ACPI_STATUS(status); 218 } 219 220 /* 221 * Find a free owner ID, cycle through all possible IDs on repeated 222 * allocations. (ACPI_NUM_OWNERID_MASKS + 1) because first index may have 223 * to be scanned twice. 224 */ 225 for (i = 0, j = acpi_gbl_last_owner_id_index; 226 i < (ACPI_NUM_OWNERID_MASKS + 1); i++, j++) { 227 if (j >= ACPI_NUM_OWNERID_MASKS) { 228 j = 0; /* Wraparound to start of mask array */ 229 } 230 231 for (k = acpi_gbl_next_owner_id_offset; k < 32; k++) { 232 if (acpi_gbl_owner_id_mask[j] == ACPI_UINT32_MAX) { 233 234 /* There are no free IDs in this mask */ 235 236 break; 237 } 238 239 if (!(acpi_gbl_owner_id_mask[j] & (1 << k))) { 240 /* 241 * Found a free ID. The actual ID is the bit index plus one, 242 * making zero an invalid Owner ID. Save this as the last ID 243 * allocated and update the global ID mask. 244 */ 245 acpi_gbl_owner_id_mask[j] |= (1 << k); 246 247 acpi_gbl_last_owner_id_index = (u8) j; 248 acpi_gbl_next_owner_id_offset = (u8) (k + 1); 249 250 /* 251 * Construct encoded ID from the index and bit position 252 * 253 * Note: Last [j].k (bit 255) is never used and is marked 254 * permanently allocated (prevents +1 overflow) 255 */ 256 *owner_id = 257 (acpi_owner_id) ((k + 1) + ACPI_MUL_32(j)); 258 259 ACPI_DEBUG_PRINT((ACPI_DB_VALUES, 260 "Allocated OwnerId: %2.2X\n", 261 (unsigned int)*owner_id)); 262 goto exit; 263 } 264 } 265 266 acpi_gbl_next_owner_id_offset = 0; 267 } 268 269 /* 270 * All owner_ids have been allocated. This typically should 271 * not happen since the IDs are reused after deallocation. The IDs are 272 * allocated upon table load (one per table) and method execution, and 273 * they are released when a table is unloaded or a method completes 274 * execution. 275 * 276 * If this error happens, there may be very deep nesting of invoked control 277 * methods, or there may be a bug where the IDs are not released. 278 */ 279 status = AE_OWNER_ID_LIMIT; 280 ACPI_ERROR((AE_INFO, 281 "Could not allocate new OwnerId (255 max), AE_OWNER_ID_LIMIT")); 282 283 exit: 284 (void)acpi_ut_release_mutex(ACPI_MTX_CACHES); 285 return_ACPI_STATUS(status); 286 } 287 288 /******************************************************************************* 289 * 290 * FUNCTION: acpi_ut_release_owner_id 291 * 292 * PARAMETERS: owner_id_ptr - Pointer to a previously allocated owner_iD 293 * 294 * RETURN: None. No error is returned because we are either exiting a 295 * control method or unloading a table. Either way, we would 296 * ignore any error anyway. 297 * 298 * DESCRIPTION: Release a table or method owner ID. Valid IDs are 1 - 255 299 * 300 ******************************************************************************/ 301 302 void acpi_ut_release_owner_id(acpi_owner_id * owner_id_ptr) 303 { 304 acpi_owner_id owner_id = *owner_id_ptr; 305 acpi_status status; 306 u32 index; 307 u32 bit; 308 309 ACPI_FUNCTION_TRACE_U32(ut_release_owner_id, owner_id); 310 311 /* Always clear the input owner_id (zero is an invalid ID) */ 312 313 *owner_id_ptr = 0; 314 315 /* Zero is not a valid owner_iD */ 316 317 if (owner_id == 0) { 318 ACPI_ERROR((AE_INFO, "Invalid OwnerId: %2.2X", owner_id)); 319 return_VOID; 320 } 321 322 /* Mutex for the global ID mask */ 323 324 status = acpi_ut_acquire_mutex(ACPI_MTX_CACHES); 325 if (ACPI_FAILURE(status)) { 326 return_VOID; 327 } 328 329 /* Normalize the ID to zero */ 330 331 owner_id--; 332 333 /* Decode ID to index/offset pair */ 334 335 index = ACPI_DIV_32(owner_id); 336 bit = 1 << ACPI_MOD_32(owner_id); 337 338 /* Free the owner ID only if it is valid */ 339 340 if (acpi_gbl_owner_id_mask[index] & bit) { 341 acpi_gbl_owner_id_mask[index] ^= bit; 342 } else { 343 ACPI_ERROR((AE_INFO, 344 "Release of non-allocated OwnerId: %2.2X", 345 owner_id + 1)); 346 } 347 348 (void)acpi_ut_release_mutex(ACPI_MTX_CACHES); 349 return_VOID; 350 } 351 352 /******************************************************************************* 353 * 354 * FUNCTION: acpi_ut_strupr (strupr) 355 * 356 * PARAMETERS: src_string - The source string to convert 357 * 358 * RETURN: None 359 * 360 * DESCRIPTION: Convert string to uppercase 361 * 362 * NOTE: This is not a POSIX function, so it appears here, not in utclib.c 363 * 364 ******************************************************************************/ 365 366 void acpi_ut_strupr(char *src_string) 367 { 368 char *string; 369 370 ACPI_FUNCTION_ENTRY(); 371 372 if (!src_string) { 373 return; 374 } 375 376 /* Walk entire string, uppercasing the letters */ 377 378 for (string = src_string; *string; string++) { 379 *string = (char)ACPI_TOUPPER(*string); 380 } 381 382 return; 383 } 384 385 /******************************************************************************* 386 * 387 * FUNCTION: acpi_ut_print_string 388 * 389 * PARAMETERS: String - Null terminated ASCII string 390 * max_length - Maximum output length 391 * 392 * RETURN: None 393 * 394 * DESCRIPTION: Dump an ASCII string with support for ACPI-defined escape 395 * sequences. 396 * 397 ******************************************************************************/ 398 399 void acpi_ut_print_string(char *string, u8 max_length) 400 { 401 u32 i; 402 403 if (!string) { 404 acpi_os_printf("<\"NULL STRING PTR\">"); 405 return; 406 } 407 408 acpi_os_printf("\""); 409 for (i = 0; string[i] && (i < max_length); i++) { 410 411 /* Escape sequences */ 412 413 switch (string[i]) { 414 case 0x07: 415 acpi_os_printf("\\a"); /* BELL */ 416 break; 417 418 case 0x08: 419 acpi_os_printf("\\b"); /* BACKSPACE */ 420 break; 421 422 case 0x0C: 423 acpi_os_printf("\\f"); /* FORMFEED */ 424 break; 425 426 case 0x0A: 427 acpi_os_printf("\\n"); /* LINEFEED */ 428 break; 429 430 case 0x0D: 431 acpi_os_printf("\\r"); /* CARRIAGE RETURN */ 432 break; 433 434 case 0x09: 435 acpi_os_printf("\\t"); /* HORIZONTAL TAB */ 436 break; 437 438 case 0x0B: 439 acpi_os_printf("\\v"); /* VERTICAL TAB */ 440 break; 441 442 case '\'': /* Single Quote */ 443 case '\"': /* Double Quote */ 444 case '\\': /* Backslash */ 445 acpi_os_printf("\\%c", (int)string[i]); 446 break; 447 448 default: 449 450 /* Check for printable character or hex escape */ 451 452 if (ACPI_IS_PRINT(string[i])) { 453 /* This is a normal character */ 454 455 acpi_os_printf("%c", (int)string[i]); 456 } else { 457 /* All others will be Hex escapes */ 458 459 acpi_os_printf("\\x%2.2X", (s32) string[i]); 460 } 461 break; 462 } 463 } 464 acpi_os_printf("\""); 465 466 if (i == max_length && string[i]) { 467 acpi_os_printf("..."); 468 } 469 } 470 471 /******************************************************************************* 472 * 473 * FUNCTION: acpi_ut_dword_byte_swap 474 * 475 * PARAMETERS: Value - Value to be converted 476 * 477 * RETURN: u32 integer with bytes swapped 478 * 479 * DESCRIPTION: Convert a 32-bit value to big-endian (swap the bytes) 480 * 481 ******************************************************************************/ 482 483 u32 acpi_ut_dword_byte_swap(u32 value) 484 { 485 union { 486 u32 value; 487 u8 bytes[4]; 488 } out; 489 union { 490 u32 value; 491 u8 bytes[4]; 492 } in; 493 494 ACPI_FUNCTION_ENTRY(); 495 496 in.value = value; 497 498 out.bytes[0] = in.bytes[3]; 499 out.bytes[1] = in.bytes[2]; 500 out.bytes[2] = in.bytes[1]; 501 out.bytes[3] = in.bytes[0]; 502 503 return (out.value); 504 } 505 506 /******************************************************************************* 507 * 508 * FUNCTION: acpi_ut_set_integer_width 509 * 510 * PARAMETERS: Revision From DSDT header 511 * 512 * RETURN: None 513 * 514 * DESCRIPTION: Set the global integer bit width based upon the revision 515 * of the DSDT. For Revision 1 and 0, Integers are 32 bits. 516 * For Revision 2 and above, Integers are 64 bits. Yes, this 517 * makes a difference. 518 * 519 ******************************************************************************/ 520 521 void acpi_ut_set_integer_width(u8 revision) 522 { 523 524 if (revision < 2) { 525 526 /* 32-bit case */ 527 528 acpi_gbl_integer_bit_width = 32; 529 acpi_gbl_integer_nybble_width = 8; 530 acpi_gbl_integer_byte_width = 4; 531 } else { 532 /* 64-bit case (ACPI 2.0+) */ 533 534 acpi_gbl_integer_bit_width = 64; 535 acpi_gbl_integer_nybble_width = 16; 536 acpi_gbl_integer_byte_width = 8; 537 } 538 } 539 540 #ifdef ACPI_DEBUG_OUTPUT 541 /******************************************************************************* 542 * 543 * FUNCTION: acpi_ut_display_init_pathname 544 * 545 * PARAMETERS: Type - Object type of the node 546 * obj_handle - Handle whose pathname will be displayed 547 * Path - Additional path string to be appended. 548 * (NULL if no extra path) 549 * 550 * RETURN: acpi_status 551 * 552 * DESCRIPTION: Display full pathname of an object, DEBUG ONLY 553 * 554 ******************************************************************************/ 555 556 void 557 acpi_ut_display_init_pathname(u8 type, 558 struct acpi_namespace_node *obj_handle, 559 char *path) 560 { 561 acpi_status status; 562 struct acpi_buffer buffer; 563 564 ACPI_FUNCTION_ENTRY(); 565 566 /* Only print the path if the appropriate debug level is enabled */ 567 568 if (!(acpi_dbg_level & ACPI_LV_INIT_NAMES)) { 569 return; 570 } 571 572 /* Get the full pathname to the node */ 573 574 buffer.length = ACPI_ALLOCATE_LOCAL_BUFFER; 575 status = acpi_ns_handle_to_pathname(obj_handle, &buffer); 576 if (ACPI_FAILURE(status)) { 577 return; 578 } 579 580 /* Print what we're doing */ 581 582 switch (type) { 583 case ACPI_TYPE_METHOD: 584 acpi_os_printf("Executing "); 585 break; 586 587 default: 588 acpi_os_printf("Initializing "); 589 break; 590 } 591 592 /* Print the object type and pathname */ 593 594 acpi_os_printf("%-12s %s", 595 acpi_ut_get_type_name(type), (char *)buffer.pointer); 596 597 /* Extra path is used to append names like _STA, _INI, etc. */ 598 599 if (path) { 600 acpi_os_printf(".%s", path); 601 } 602 acpi_os_printf("\n"); 603 604 ACPI_FREE(buffer.pointer); 605 } 606 #endif 607 608 /******************************************************************************* 609 * 610 * FUNCTION: acpi_ut_valid_acpi_char 611 * 612 * PARAMETERS: Char - The character to be examined 613 * Position - Byte position (0-3) 614 * 615 * RETURN: TRUE if the character is valid, FALSE otherwise 616 * 617 * DESCRIPTION: Check for a valid ACPI character. Must be one of: 618 * 1) Upper case alpha 619 * 2) numeric 620 * 3) underscore 621 * 622 * We allow a '!' as the last character because of the ASF! table 623 * 624 ******************************************************************************/ 625 626 u8 acpi_ut_valid_acpi_char(char character, u32 position) 627 { 628 629 if (!((character >= 'A' && character <= 'Z') || 630 (character >= '0' && character <= '9') || (character == '_'))) { 631 632 /* Allow a '!' in the last position */ 633 634 if (character == '!' && position == 3) { 635 return (TRUE); 636 } 637 638 return (FALSE); 639 } 640 641 return (TRUE); 642 } 643 644 /******************************************************************************* 645 * 646 * FUNCTION: acpi_ut_valid_acpi_name 647 * 648 * PARAMETERS: Name - The name to be examined 649 * 650 * RETURN: TRUE if the name is valid, FALSE otherwise 651 * 652 * DESCRIPTION: Check for a valid ACPI name. Each character must be one of: 653 * 1) Upper case alpha 654 * 2) numeric 655 * 3) underscore 656 * 657 ******************************************************************************/ 658 659 u8 acpi_ut_valid_acpi_name(u32 name) 660 { 661 u32 i; 662 663 ACPI_FUNCTION_ENTRY(); 664 665 for (i = 0; i < ACPI_NAME_SIZE; i++) { 666 if (!acpi_ut_valid_acpi_char 667 ((ACPI_CAST_PTR(char, &name))[i], i)) { 668 return (FALSE); 669 } 670 } 671 672 return (TRUE); 673 } 674 675 /******************************************************************************* 676 * 677 * FUNCTION: acpi_ut_repair_name 678 * 679 * PARAMETERS: Name - The ACPI name to be repaired 680 * 681 * RETURN: Repaired version of the name 682 * 683 * DESCRIPTION: Repair an ACPI name: Change invalid characters to '*' and 684 * return the new name. 685 * 686 ******************************************************************************/ 687 688 acpi_name acpi_ut_repair_name(char *name) 689 { 690 u32 i; 691 char new_name[ACPI_NAME_SIZE]; 692 693 for (i = 0; i < ACPI_NAME_SIZE; i++) { 694 new_name[i] = name[i]; 695 696 /* 697 * Replace a bad character with something printable, yet technically 698 * still invalid. This prevents any collisions with existing "good" 699 * names in the namespace. 700 */ 701 if (!acpi_ut_valid_acpi_char(name[i], i)) { 702 new_name[i] = '*'; 703 } 704 } 705 706 return (*(u32 *) new_name); 707 } 708 709 /******************************************************************************* 710 * 711 * FUNCTION: acpi_ut_strtoul64 712 * 713 * PARAMETERS: String - Null terminated string 714 * Base - Radix of the string: 16 or ACPI_ANY_BASE; 715 * ACPI_ANY_BASE means 'in behalf of to_integer' 716 * ret_integer - Where the converted integer is returned 717 * 718 * RETURN: Status and Converted value 719 * 720 * DESCRIPTION: Convert a string into an unsigned value. Performs either a 721 * 32-bit or 64-bit conversion, depending on the current mode 722 * of the interpreter. 723 * NOTE: Does not support Octal strings, not needed. 724 * 725 ******************************************************************************/ 726 727 acpi_status 728 acpi_ut_strtoul64(char *string, u32 base, acpi_integer * ret_integer) 729 { 730 u32 this_digit = 0; 731 acpi_integer return_value = 0; 732 acpi_integer quotient; 733 acpi_integer dividend; 734 u32 to_integer_op = (base == ACPI_ANY_BASE); 735 u32 mode32 = (acpi_gbl_integer_byte_width == 4); 736 u8 valid_digits = 0; 737 u8 sign_of0x = 0; 738 u8 term = 0; 739 740 ACPI_FUNCTION_TRACE_STR(ut_stroul64, string); 741 742 switch (base) { 743 case ACPI_ANY_BASE: 744 case 16: 745 break; 746 747 default: 748 /* Invalid Base */ 749 return_ACPI_STATUS(AE_BAD_PARAMETER); 750 } 751 752 if (!string) { 753 goto error_exit; 754 } 755 756 /* Skip over any white space in the buffer */ 757 758 while ((*string) && (ACPI_IS_SPACE(*string) || *string == '\t')) { 759 string++; 760 } 761 762 if (to_integer_op) { 763 /* 764 * Base equal to ACPI_ANY_BASE means 'to_integer operation case'. 765 * We need to determine if it is decimal or hexadecimal. 766 */ 767 if ((*string == '0') && (ACPI_TOLOWER(*(string + 1)) == 'x')) { 768 sign_of0x = 1; 769 base = 16; 770 771 /* Skip over the leading '0x' */ 772 string += 2; 773 } else { 774 base = 10; 775 } 776 } 777 778 /* Any string left? Check that '0x' is not followed by white space. */ 779 780 if (!(*string) || ACPI_IS_SPACE(*string) || *string == '\t') { 781 if (to_integer_op) { 782 goto error_exit; 783 } else { 784 goto all_done; 785 } 786 } 787 788 /* 789 * Perform a 32-bit or 64-bit conversion, depending upon the current 790 * execution mode of the interpreter 791 */ 792 dividend = (mode32) ? ACPI_UINT32_MAX : ACPI_UINT64_MAX; 793 794 /* Main loop: convert the string to a 32- or 64-bit integer */ 795 796 while (*string) { 797 if (ACPI_IS_DIGIT(*string)) { 798 799 /* Convert ASCII 0-9 to Decimal value */ 800 801 this_digit = ((u8) * string) - '0'; 802 } else if (base == 10) { 803 804 /* Digit is out of range; possible in to_integer case only */ 805 806 term = 1; 807 } else { 808 this_digit = (u8) ACPI_TOUPPER(*string); 809 if (ACPI_IS_XDIGIT((char)this_digit)) { 810 811 /* Convert ASCII Hex char to value */ 812 813 this_digit = this_digit - 'A' + 10; 814 } else { 815 term = 1; 816 } 817 } 818 819 if (term) { 820 if (to_integer_op) { 821 goto error_exit; 822 } else { 823 break; 824 } 825 } else if ((valid_digits == 0) && (this_digit == 0) 826 && !sign_of0x) { 827 828 /* Skip zeros */ 829 string++; 830 continue; 831 } 832 833 valid_digits++; 834 835 if (sign_of0x && ((valid_digits > 16) 836 || ((valid_digits > 8) && mode32))) { 837 /* 838 * This is to_integer operation case. 839 * No any restrictions for string-to-integer conversion, 840 * see ACPI spec. 841 */ 842 goto error_exit; 843 } 844 845 /* Divide the digit into the correct position */ 846 847 (void) 848 acpi_ut_short_divide((dividend - (acpi_integer) this_digit), 849 base, "ient, NULL); 850 851 if (return_value > quotient) { 852 if (to_integer_op) { 853 goto error_exit; 854 } else { 855 break; 856 } 857 } 858 859 return_value *= base; 860 return_value += this_digit; 861 string++; 862 } 863 864 /* All done, normal exit */ 865 866 all_done: 867 868 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Converted value: %8.8X%8.8X\n", 869 ACPI_FORMAT_UINT64(return_value))); 870 871 *ret_integer = return_value; 872 return_ACPI_STATUS(AE_OK); 873 874 error_exit: 875 /* Base was set/validated above */ 876 877 if (base == 10) { 878 return_ACPI_STATUS(AE_BAD_DECIMAL_CONSTANT); 879 } else { 880 return_ACPI_STATUS(AE_BAD_HEX_CONSTANT); 881 } 882 } 883 884 /******************************************************************************* 885 * 886 * FUNCTION: acpi_ut_create_update_state_and_push 887 * 888 * PARAMETERS: Object - Object to be added to the new state 889 * Action - Increment/Decrement 890 * state_list - List the state will be added to 891 * 892 * RETURN: Status 893 * 894 * DESCRIPTION: Create a new state and push it 895 * 896 ******************************************************************************/ 897 898 acpi_status 899 acpi_ut_create_update_state_and_push(union acpi_operand_object *object, 900 u16 action, 901 union acpi_generic_state **state_list) 902 { 903 union acpi_generic_state *state; 904 905 ACPI_FUNCTION_ENTRY(); 906 907 /* Ignore null objects; these are expected */ 908 909 if (!object) { 910 return (AE_OK); 911 } 912 913 state = acpi_ut_create_update_state(object, action); 914 if (!state) { 915 return (AE_NO_MEMORY); 916 } 917 918 acpi_ut_push_generic_state(state_list, state); 919 return (AE_OK); 920 } 921 922 /******************************************************************************* 923 * 924 * FUNCTION: acpi_ut_walk_package_tree 925 * 926 * PARAMETERS: source_object - The package to walk 927 * target_object - Target object (if package is being copied) 928 * walk_callback - Called once for each package element 929 * Context - Passed to the callback function 930 * 931 * RETURN: Status 932 * 933 * DESCRIPTION: Walk through a package 934 * 935 ******************************************************************************/ 936 937 acpi_status 938 acpi_ut_walk_package_tree(union acpi_operand_object * source_object, 939 void *target_object, 940 acpi_pkg_callback walk_callback, void *context) 941 { 942 acpi_status status = AE_OK; 943 union acpi_generic_state *state_list = NULL; 944 union acpi_generic_state *state; 945 u32 this_index; 946 union acpi_operand_object *this_source_obj; 947 948 ACPI_FUNCTION_TRACE(ut_walk_package_tree); 949 950 state = acpi_ut_create_pkg_state(source_object, target_object, 0); 951 if (!state) { 952 return_ACPI_STATUS(AE_NO_MEMORY); 953 } 954 955 while (state) { 956 957 /* Get one element of the package */ 958 959 this_index = state->pkg.index; 960 this_source_obj = (union acpi_operand_object *) 961 state->pkg.source_object->package.elements[this_index]; 962 963 /* 964 * Check for: 965 * 1) An uninitialized package element. It is completely 966 * legal to declare a package and leave it uninitialized 967 * 2) Not an internal object - can be a namespace node instead 968 * 3) Any type other than a package. Packages are handled in else 969 * case below. 970 */ 971 if ((!this_source_obj) || 972 (ACPI_GET_DESCRIPTOR_TYPE(this_source_obj) != 973 ACPI_DESC_TYPE_OPERAND) 974 || (this_source_obj->common.type != ACPI_TYPE_PACKAGE)) { 975 status = 976 walk_callback(ACPI_COPY_TYPE_SIMPLE, 977 this_source_obj, state, context); 978 if (ACPI_FAILURE(status)) { 979 return_ACPI_STATUS(status); 980 } 981 982 state->pkg.index++; 983 while (state->pkg.index >= 984 state->pkg.source_object->package.count) { 985 /* 986 * We've handled all of the objects at this level, This means 987 * that we have just completed a package. That package may 988 * have contained one or more packages itself. 989 * 990 * Delete this state and pop the previous state (package). 991 */ 992 acpi_ut_delete_generic_state(state); 993 state = acpi_ut_pop_generic_state(&state_list); 994 995 /* Finished when there are no more states */ 996 997 if (!state) { 998 /* 999 * We have handled all of the objects in the top level 1000 * package just add the length of the package objects 1001 * and exit 1002 */ 1003 return_ACPI_STATUS(AE_OK); 1004 } 1005 1006 /* 1007 * Go back up a level and move the index past the just 1008 * completed package object. 1009 */ 1010 state->pkg.index++; 1011 } 1012 } else { 1013 /* This is a subobject of type package */ 1014 1015 status = 1016 walk_callback(ACPI_COPY_TYPE_PACKAGE, 1017 this_source_obj, state, context); 1018 if (ACPI_FAILURE(status)) { 1019 return_ACPI_STATUS(status); 1020 } 1021 1022 /* 1023 * Push the current state and create a new one 1024 * The callback above returned a new target package object. 1025 */ 1026 acpi_ut_push_generic_state(&state_list, state); 1027 state = acpi_ut_create_pkg_state(this_source_obj, 1028 state->pkg. 1029 this_target_obj, 0); 1030 if (!state) { 1031 1032 /* Free any stacked Update State objects */ 1033 1034 while (state_list) { 1035 state = 1036 acpi_ut_pop_generic_state 1037 (&state_list); 1038 acpi_ut_delete_generic_state(state); 1039 } 1040 return_ACPI_STATUS(AE_NO_MEMORY); 1041 } 1042 } 1043 } 1044 1045 /* We should never get here */ 1046 1047 return_ACPI_STATUS(AE_AML_INTERNAL); 1048 } 1049 1050 /******************************************************************************* 1051 * 1052 * FUNCTION: acpi_error, acpi_exception, acpi_warning, acpi_info 1053 * 1054 * PARAMETERS: module_name - Caller's module name (for error output) 1055 * line_number - Caller's line number (for error output) 1056 * Format - Printf format string + additional args 1057 * 1058 * RETURN: None 1059 * 1060 * DESCRIPTION: Print message with module/line/version info 1061 * 1062 ******************************************************************************/ 1063 1064 void ACPI_INTERNAL_VAR_XFACE 1065 acpi_error(const char *module_name, u32 line_number, const char *format, ...) 1066 { 1067 va_list args; 1068 1069 acpi_os_printf("ACPI Error: "); 1070 1071 va_start(args, format); 1072 acpi_os_vprintf(format, args); 1073 ACPI_COMMON_MSG_SUFFIX; 1074 va_end(args); 1075 } 1076 1077 void ACPI_INTERNAL_VAR_XFACE 1078 acpi_exception(const char *module_name, 1079 u32 line_number, acpi_status status, const char *format, ...) 1080 { 1081 va_list args; 1082 1083 acpi_os_printf("ACPI Exception: %s, ", acpi_format_exception(status)); 1084 1085 va_start(args, format); 1086 acpi_os_vprintf(format, args); 1087 ACPI_COMMON_MSG_SUFFIX; 1088 va_end(args); 1089 } 1090 1091 void ACPI_INTERNAL_VAR_XFACE 1092 acpi_warning(const char *module_name, u32 line_number, const char *format, ...) 1093 { 1094 va_list args; 1095 1096 acpi_os_printf("ACPI Warning: "); 1097 1098 va_start(args, format); 1099 acpi_os_vprintf(format, args); 1100 ACPI_COMMON_MSG_SUFFIX; 1101 va_end(args); 1102 } 1103 1104 void ACPI_INTERNAL_VAR_XFACE 1105 acpi_info(const char *module_name, u32 line_number, const char *format, ...) 1106 { 1107 va_list args; 1108 1109 acpi_os_printf("ACPI: "); 1110 1111 va_start(args, format); 1112 acpi_os_vprintf(format, args); 1113 acpi_os_printf("\n"); 1114 va_end(args); 1115 } 1116 1117 ACPI_EXPORT_SYMBOL(acpi_error) 1118 ACPI_EXPORT_SYMBOL(acpi_exception) 1119 ACPI_EXPORT_SYMBOL(acpi_warning) 1120 ACPI_EXPORT_SYMBOL(acpi_info) 1121 1122 /******************************************************************************* 1123 * 1124 * FUNCTION: acpi_ut_predefined_warning 1125 * 1126 * PARAMETERS: module_name - Caller's module name (for error output) 1127 * line_number - Caller's line number (for error output) 1128 * Pathname - Full pathname to the node 1129 * node_flags - From Namespace node for the method/object 1130 * Format - Printf format string + additional args 1131 * 1132 * RETURN: None 1133 * 1134 * DESCRIPTION: Warnings for the predefined validation module. Messages are 1135 * only emitted the first time a problem with a particular 1136 * method/object is detected. This prevents a flood of error 1137 * messages for methods that are repeatedly evaluated. 1138 * 1139 ******************************************************************************/ 1140 1141 void ACPI_INTERNAL_VAR_XFACE 1142 acpi_ut_predefined_warning(const char *module_name, 1143 u32 line_number, 1144 char *pathname, 1145 u8 node_flags, const char *format, ...) 1146 { 1147 va_list args; 1148 1149 /* 1150 * Warning messages for this method/object will be disabled after the 1151 * first time a validation fails or an object is successfully repaired. 1152 */ 1153 if (node_flags & ANOBJ_EVALUATED) { 1154 return; 1155 } 1156 1157 acpi_os_printf("ACPI Warning for %s: ", pathname); 1158 1159 va_start(args, format); 1160 acpi_os_vprintf(format, args); 1161 ACPI_COMMON_MSG_SUFFIX; 1162 va_end(args); 1163 } 1164 1165 /******************************************************************************* 1166 * 1167 * FUNCTION: acpi_ut_predefined_info 1168 * 1169 * PARAMETERS: module_name - Caller's module name (for error output) 1170 * line_number - Caller's line number (for error output) 1171 * Pathname - Full pathname to the node 1172 * node_flags - From Namespace node for the method/object 1173 * Format - Printf format string + additional args 1174 * 1175 * RETURN: None 1176 * 1177 * DESCRIPTION: Info messages for the predefined validation module. Messages 1178 * are only emitted the first time a problem with a particular 1179 * method/object is detected. This prevents a flood of 1180 * messages for methods that are repeatedly evaluated. 1181 * 1182 ******************************************************************************/ 1183 1184 void ACPI_INTERNAL_VAR_XFACE 1185 acpi_ut_predefined_info(const char *module_name, 1186 u32 line_number, 1187 char *pathname, u8 node_flags, const char *format, ...) 1188 { 1189 va_list args; 1190 1191 /* 1192 * Warning messages for this method/object will be disabled after the 1193 * first time a validation fails or an object is successfully repaired. 1194 */ 1195 if (node_flags & ANOBJ_EVALUATED) { 1196 return; 1197 } 1198 1199 acpi_os_printf("ACPI Info for %s: ", pathname); 1200 1201 va_start(args, format); 1202 acpi_os_vprintf(format, args); 1203 ACPI_COMMON_MSG_SUFFIX; 1204 va_end(args); 1205 } 1206