1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 2 /****************************************************************************** 3 * 4 * Module Name: exconvrt - Object conversion routines 5 * 6 * Copyright (C) 2000 - 2023, Intel Corp. 7 * 8 *****************************************************************************/ 9 10 #include <acpi/acpi.h> 11 #include "accommon.h" 12 #include "acinterp.h" 13 #include "amlcode.h" 14 15 #define _COMPONENT ACPI_EXECUTER 16 ACPI_MODULE_NAME("exconvrt") 17 18 /* Local prototypes */ 19 static u32 20 acpi_ex_convert_to_ascii(u64 integer, 21 u16 base, u8 *string, u8 max_length, u8 leading_zeros); 22 23 /******************************************************************************* 24 * 25 * FUNCTION: acpi_ex_convert_to_integer 26 * 27 * PARAMETERS: obj_desc - Object to be converted. Must be an 28 * Integer, Buffer, or String 29 * result_desc - Where the new Integer object is returned 30 * implicit_conversion - Used for string conversion 31 * 32 * RETURN: Status 33 * 34 * DESCRIPTION: Convert an ACPI Object to an integer. 35 * 36 ******************************************************************************/ 37 38 acpi_status acpi_ex_convert_to_integer(union acpi_operand_object * obj_desc,union acpi_operand_object ** result_desc,u32 implicit_conversion)39 acpi_ex_convert_to_integer(union acpi_operand_object *obj_desc, 40 union acpi_operand_object **result_desc, 41 u32 implicit_conversion) 42 { 43 union acpi_operand_object *return_desc; 44 u8 *pointer; 45 u64 result; 46 u32 i; 47 u32 count; 48 49 ACPI_FUNCTION_TRACE_PTR(ex_convert_to_integer, obj_desc); 50 51 switch (obj_desc->common.type) { 52 case ACPI_TYPE_INTEGER: 53 54 /* No conversion necessary */ 55 56 *result_desc = obj_desc; 57 return_ACPI_STATUS(AE_OK); 58 59 case ACPI_TYPE_BUFFER: 60 case ACPI_TYPE_STRING: 61 62 /* Note: Takes advantage of common buffer/string fields */ 63 64 pointer = obj_desc->buffer.pointer; 65 count = obj_desc->buffer.length; 66 break; 67 68 default: 69 70 return_ACPI_STATUS(AE_TYPE); 71 } 72 73 /* 74 * Convert the buffer/string to an integer. Note that both buffers and 75 * strings are treated as raw data - we don't convert ascii to hex for 76 * strings. 77 * 78 * There are two terminating conditions for the loop: 79 * 1) The size of an integer has been reached, or 80 * 2) The end of the buffer or string has been reached 81 */ 82 result = 0; 83 84 /* String conversion is different than Buffer conversion */ 85 86 switch (obj_desc->common.type) { 87 case ACPI_TYPE_STRING: 88 /* 89 * Convert string to an integer - for most cases, the string must be 90 * hexadecimal as per the ACPI specification. The only exception (as 91 * of ACPI 3.0) is that the to_integer() operator allows both decimal 92 * and hexadecimal strings (hex prefixed with "0x"). 93 * 94 * Explicit conversion is used only by to_integer. 95 * All other string-to-integer conversions are implicit conversions. 96 */ 97 if (implicit_conversion) { 98 result = 99 acpi_ut_implicit_strtoul64(ACPI_CAST_PTR 100 (char, pointer)); 101 } else { 102 result = 103 acpi_ut_explicit_strtoul64(ACPI_CAST_PTR 104 (char, pointer)); 105 } 106 break; 107 108 case ACPI_TYPE_BUFFER: 109 110 /* Check for zero-length buffer */ 111 112 if (!count) { 113 return_ACPI_STATUS(AE_AML_BUFFER_LIMIT); 114 } 115 116 /* Transfer no more than an integer's worth of data */ 117 118 if (count > acpi_gbl_integer_byte_width) { 119 count = acpi_gbl_integer_byte_width; 120 } 121 122 /* 123 * Convert buffer to an integer - we simply grab enough raw data 124 * from the buffer to fill an integer 125 */ 126 for (i = 0; i < count; i++) { 127 /* 128 * Get next byte and shift it into the Result. 129 * Little endian is used, meaning that the first byte of the buffer 130 * is the LSB of the integer 131 */ 132 result |= (((u64) pointer[i]) << (i * 8)); 133 } 134 break; 135 136 default: 137 138 /* No other types can get here */ 139 140 break; 141 } 142 143 /* Create a new integer */ 144 145 return_desc = acpi_ut_create_integer_object(result); 146 if (!return_desc) { 147 return_ACPI_STATUS(AE_NO_MEMORY); 148 } 149 150 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Converted value: %8.8X%8.8X\n", 151 ACPI_FORMAT_UINT64(result))); 152 153 /* Save the Result */ 154 155 (void)acpi_ex_truncate_for32bit_table(return_desc); 156 *result_desc = return_desc; 157 return_ACPI_STATUS(AE_OK); 158 } 159 160 /******************************************************************************* 161 * 162 * FUNCTION: acpi_ex_convert_to_buffer 163 * 164 * PARAMETERS: obj_desc - Object to be converted. Must be an 165 * Integer, Buffer, or String 166 * result_desc - Where the new buffer object is returned 167 * 168 * RETURN: Status 169 * 170 * DESCRIPTION: Convert an ACPI Object to a Buffer 171 * 172 ******************************************************************************/ 173 174 acpi_status acpi_ex_convert_to_buffer(union acpi_operand_object * obj_desc,union acpi_operand_object ** result_desc)175 acpi_ex_convert_to_buffer(union acpi_operand_object *obj_desc, 176 union acpi_operand_object **result_desc) 177 { 178 union acpi_operand_object *return_desc; 179 u8 *new_buf; 180 181 ACPI_FUNCTION_TRACE_PTR(ex_convert_to_buffer, obj_desc); 182 183 switch (obj_desc->common.type) { 184 case ACPI_TYPE_BUFFER: 185 186 /* No conversion necessary */ 187 188 *result_desc = obj_desc; 189 return_ACPI_STATUS(AE_OK); 190 191 case ACPI_TYPE_INTEGER: 192 /* 193 * Create a new Buffer object. 194 * Need enough space for one integer 195 */ 196 return_desc = 197 acpi_ut_create_buffer_object(acpi_gbl_integer_byte_width); 198 if (!return_desc) { 199 return_ACPI_STATUS(AE_NO_MEMORY); 200 } 201 202 /* Copy the integer to the buffer, LSB first */ 203 204 new_buf = return_desc->buffer.pointer; 205 memcpy(new_buf, &obj_desc->integer.value, 206 acpi_gbl_integer_byte_width); 207 break; 208 209 case ACPI_TYPE_STRING: 210 /* 211 * Create a new Buffer object 212 * Size will be the string length 213 * 214 * NOTE: Add one to the string length to include the null terminator. 215 * The ACPI spec is unclear on this subject, but there is existing 216 * ASL/AML code that depends on the null being transferred to the new 217 * buffer. 218 */ 219 return_desc = acpi_ut_create_buffer_object((acpi_size) 220 obj_desc->string. 221 length + 1); 222 if (!return_desc) { 223 return_ACPI_STATUS(AE_NO_MEMORY); 224 } 225 226 /* Copy the string to the buffer */ 227 228 new_buf = return_desc->buffer.pointer; 229 strncpy((char *)new_buf, (char *)obj_desc->string.pointer, 230 obj_desc->string.length); 231 break; 232 233 default: 234 235 return_ACPI_STATUS(AE_TYPE); 236 } 237 238 /* Mark buffer initialized */ 239 240 return_desc->common.flags |= AOPOBJ_DATA_VALID; 241 *result_desc = return_desc; 242 return_ACPI_STATUS(AE_OK); 243 } 244 245 /******************************************************************************* 246 * 247 * FUNCTION: acpi_ex_convert_to_ascii 248 * 249 * PARAMETERS: integer - Value to be converted 250 * base - ACPI_STRING_DECIMAL or ACPI_STRING_HEX 251 * string - Where the string is returned 252 * data_width - Size of data item to be converted, in bytes 253 * leading_zeros - Allow leading zeros 254 * 255 * RETURN: Actual string length 256 * 257 * DESCRIPTION: Convert an ACPI Integer to a hex or decimal string 258 * 259 ******************************************************************************/ 260 261 static u32 acpi_ex_convert_to_ascii(u64 integer,u16 base,u8 * string,u8 data_width,u8 leading_zeros)262 acpi_ex_convert_to_ascii(u64 integer, 263 u16 base, u8 *string, u8 data_width, u8 leading_zeros) 264 { 265 u64 digit; 266 u32 i; 267 u32 j; 268 u32 k = 0; 269 u32 hex_length; 270 u32 decimal_length; 271 u32 remainder; 272 u8 supress_zeros = !leading_zeros; 273 u8 hex_char; 274 275 ACPI_FUNCTION_ENTRY(); 276 277 switch (base) { 278 case 10: 279 280 /* Setup max length for the decimal number */ 281 282 switch (data_width) { 283 case 1: 284 285 decimal_length = ACPI_MAX8_DECIMAL_DIGITS; 286 break; 287 288 case 4: 289 290 decimal_length = ACPI_MAX32_DECIMAL_DIGITS; 291 break; 292 293 case 8: 294 default: 295 296 decimal_length = ACPI_MAX64_DECIMAL_DIGITS; 297 break; 298 } 299 300 remainder = 0; 301 302 for (i = decimal_length; i > 0; i--) { 303 304 /* Divide by nth factor of 10 */ 305 306 digit = integer; 307 for (j = 0; j < i; j++) { 308 (void)acpi_ut_short_divide(digit, 10, &digit, 309 &remainder); 310 } 311 312 /* Handle leading zeros */ 313 314 if (remainder != 0) { 315 supress_zeros = FALSE; 316 } 317 318 if (!supress_zeros) { 319 string[k] = (u8) (ACPI_ASCII_ZERO + remainder); 320 k++; 321 } 322 } 323 break; 324 325 case 16: 326 327 /* hex_length: 2 ascii hex chars per data byte */ 328 329 hex_length = (data_width * 2); 330 for (i = 0, j = (hex_length - 1); i < hex_length; i++, j--) { 331 332 /* Get one hex digit, most significant digits first */ 333 334 hex_char = (u8) 335 acpi_ut_hex_to_ascii_char(integer, ACPI_MUL_4(j)); 336 337 /* Supress leading zeros until the first non-zero character */ 338 339 if (hex_char == ACPI_ASCII_ZERO && supress_zeros) { 340 continue; 341 } 342 343 supress_zeros = FALSE; 344 string[k] = hex_char; 345 k++; 346 } 347 break; 348 349 default: 350 return (0); 351 } 352 353 /* 354 * Since leading zeros are suppressed, we must check for the case where 355 * the integer equals 0 356 * 357 * Finally, null terminate the string and return the length 358 */ 359 if (!k) { 360 string[0] = ACPI_ASCII_ZERO; 361 k = 1; 362 } 363 364 string[k] = 0; 365 return ((u32) k); 366 } 367 368 /******************************************************************************* 369 * 370 * FUNCTION: acpi_ex_convert_to_string 371 * 372 * PARAMETERS: obj_desc - Object to be converted. Must be an 373 * Integer, Buffer, or String 374 * result_desc - Where the string object is returned 375 * type - String flags (base and conversion type) 376 * 377 * RETURN: Status 378 * 379 * DESCRIPTION: Convert an ACPI Object to a string. Supports both implicit 380 * and explicit conversions and related rules. 381 * 382 ******************************************************************************/ 383 384 acpi_status acpi_ex_convert_to_string(union acpi_operand_object * obj_desc,union acpi_operand_object ** result_desc,u32 type)385 acpi_ex_convert_to_string(union acpi_operand_object * obj_desc, 386 union acpi_operand_object ** result_desc, u32 type) 387 { 388 union acpi_operand_object *return_desc; 389 u8 *new_buf; 390 u32 i; 391 u32 string_length = 0; 392 u16 base = 16; 393 u8 separator = ','; 394 u8 leading_zeros; 395 396 ACPI_FUNCTION_TRACE_PTR(ex_convert_to_string, obj_desc); 397 398 switch (obj_desc->common.type) { 399 case ACPI_TYPE_STRING: 400 401 /* No conversion necessary */ 402 403 *result_desc = obj_desc; 404 return_ACPI_STATUS(AE_OK); 405 406 case ACPI_TYPE_INTEGER: 407 408 switch (type) { 409 case ACPI_EXPLICIT_CONVERT_DECIMAL: 410 /* 411 * From to_decimal_string, integer source. 412 * 413 * Make room for the maximum decimal number size 414 */ 415 string_length = ACPI_MAX_DECIMAL_DIGITS; 416 leading_zeros = FALSE; 417 base = 10; 418 break; 419 420 case ACPI_EXPLICIT_CONVERT_HEX: 421 /* 422 * From to_hex_string. 423 * 424 * Supress leading zeros and append "0x" 425 */ 426 string_length = 427 ACPI_MUL_2(acpi_gbl_integer_byte_width) + 2; 428 leading_zeros = FALSE; 429 break; 430 default: 431 432 /* Two hex string characters for each integer byte */ 433 434 string_length = ACPI_MUL_2(acpi_gbl_integer_byte_width); 435 leading_zeros = TRUE; 436 break; 437 } 438 439 /* 440 * Create a new String 441 * Need enough space for one ASCII integer (plus null terminator) 442 */ 443 return_desc = 444 acpi_ut_create_string_object((acpi_size)string_length); 445 if (!return_desc) { 446 return_ACPI_STATUS(AE_NO_MEMORY); 447 } 448 449 new_buf = return_desc->buffer.pointer; 450 if (type == ACPI_EXPLICIT_CONVERT_HEX) { 451 452 /* Append "0x" prefix for explicit hex conversion */ 453 454 *new_buf++ = '0'; 455 *new_buf++ = 'x'; 456 } 457 458 /* Convert integer to string */ 459 460 string_length = 461 acpi_ex_convert_to_ascii(obj_desc->integer.value, base, 462 new_buf, 463 acpi_gbl_integer_byte_width, 464 leading_zeros); 465 466 /* Null terminate at the correct place */ 467 468 return_desc->string.length = string_length; 469 if (type == ACPI_EXPLICIT_CONVERT_HEX) { 470 471 /* Take "0x" prefix into account */ 472 473 return_desc->string.length += 2; 474 } 475 476 new_buf[string_length] = 0; 477 break; 478 479 case ACPI_TYPE_BUFFER: 480 481 /* Setup string length, base, and separator */ 482 483 switch (type) { 484 case ACPI_EXPLICIT_CONVERT_DECIMAL: /* Used by to_decimal_string */ 485 /* 486 * Explicit conversion from the to_decimal_string ASL operator. 487 * 488 * From ACPI: "If the input is a buffer, it is converted to a 489 * a string of decimal values separated by commas." 490 */ 491 leading_zeros = FALSE; 492 base = 10; 493 494 /* 495 * Calculate the final string length. Individual string values 496 * are variable length (include separator for each) 497 */ 498 for (i = 0; i < obj_desc->buffer.length; i++) { 499 if (obj_desc->buffer.pointer[i] >= 100) { 500 string_length += 4; 501 } else if (obj_desc->buffer.pointer[i] >= 10) { 502 string_length += 3; 503 } else { 504 string_length += 2; 505 } 506 } 507 break; 508 509 case ACPI_IMPLICIT_CONVERT_HEX: 510 /* 511 * Implicit buffer-to-string conversion 512 * 513 * From the ACPI spec: 514 * "The entire contents of the buffer are converted to a string of 515 * two-character hexadecimal numbers, each separated by a space." 516 * 517 * Each hex number is prefixed with 0x (11/2018) 518 */ 519 leading_zeros = TRUE; 520 separator = ' '; 521 string_length = (obj_desc->buffer.length * 5); 522 break; 523 524 case ACPI_EXPLICIT_CONVERT_HEX: 525 /* 526 * Explicit conversion from the to_hex_string ASL operator. 527 * 528 * From ACPI: "If Data is a buffer, it is converted to a string of 529 * hexadecimal values separated by commas." 530 * 531 * Each hex number is prefixed with 0x (11/2018) 532 */ 533 leading_zeros = TRUE; 534 separator = ','; 535 string_length = (obj_desc->buffer.length * 5); 536 break; 537 538 default: 539 return_ACPI_STATUS(AE_BAD_PARAMETER); 540 } 541 542 /* 543 * Create a new string object and string buffer 544 * (-1 because of extra separator included in string_length from above) 545 * Allow creation of zero-length strings from zero-length buffers. 546 */ 547 if (string_length) { 548 string_length--; 549 } 550 551 return_desc = 552 acpi_ut_create_string_object((acpi_size)string_length); 553 if (!return_desc) { 554 return_ACPI_STATUS(AE_NO_MEMORY); 555 } 556 557 new_buf = return_desc->buffer.pointer; 558 559 /* 560 * Convert buffer bytes to hex or decimal values 561 * (separated by commas or spaces) 562 */ 563 for (i = 0; i < obj_desc->buffer.length; i++) { 564 if (base == 16) { 565 566 /* Emit 0x prefix for explicit/implicit hex conversion */ 567 568 *new_buf++ = '0'; 569 *new_buf++ = 'x'; 570 } 571 572 new_buf += acpi_ex_convert_to_ascii((u64) obj_desc-> 573 buffer.pointer[i], 574 base, new_buf, 1, 575 leading_zeros); 576 577 /* Each digit is separated by either a comma or space */ 578 579 *new_buf++ = separator; 580 } 581 582 /* 583 * Null terminate the string 584 * (overwrites final comma/space from above) 585 */ 586 if (obj_desc->buffer.length) { 587 new_buf--; 588 } 589 *new_buf = 0; 590 break; 591 592 default: 593 594 return_ACPI_STATUS(AE_TYPE); 595 } 596 597 *result_desc = return_desc; 598 return_ACPI_STATUS(AE_OK); 599 } 600 601 /******************************************************************************* 602 * 603 * FUNCTION: acpi_ex_convert_to_target_type 604 * 605 * PARAMETERS: destination_type - Current type of the destination 606 * source_desc - Source object to be converted. 607 * result_desc - Where the converted object is returned 608 * walk_state - Current method state 609 * 610 * RETURN: Status 611 * 612 * DESCRIPTION: Implements "implicit conversion" rules for storing an object. 613 * 614 ******************************************************************************/ 615 616 acpi_status acpi_ex_convert_to_target_type(acpi_object_type destination_type,union acpi_operand_object * source_desc,union acpi_operand_object ** result_desc,struct acpi_walk_state * walk_state)617 acpi_ex_convert_to_target_type(acpi_object_type destination_type, 618 union acpi_operand_object *source_desc, 619 union acpi_operand_object **result_desc, 620 struct acpi_walk_state *walk_state) 621 { 622 acpi_status status = AE_OK; 623 624 ACPI_FUNCTION_TRACE(ex_convert_to_target_type); 625 626 /* Default behavior */ 627 628 *result_desc = source_desc; 629 630 /* 631 * If required by the target, 632 * perform implicit conversion on the source before we store it. 633 */ 634 switch (GET_CURRENT_ARG_TYPE(walk_state->op_info->runtime_args)) { 635 case ARGI_SIMPLE_TARGET: 636 case ARGI_FIXED_TARGET: 637 case ARGI_INTEGER_REF: /* Handles Increment, Decrement cases */ 638 639 switch (destination_type) { 640 case ACPI_TYPE_LOCAL_REGION_FIELD: 641 /* 642 * Named field can always handle conversions 643 */ 644 break; 645 646 default: 647 648 /* No conversion allowed for these types */ 649 650 if (destination_type != source_desc->common.type) { 651 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 652 "Explicit operator, will store (%s) over existing type (%s)\n", 653 acpi_ut_get_object_type_name 654 (source_desc), 655 acpi_ut_get_type_name 656 (destination_type))); 657 status = AE_TYPE; 658 } 659 } 660 break; 661 662 case ARGI_TARGETREF: 663 case ARGI_STORE_TARGET: 664 665 switch (destination_type) { 666 case ACPI_TYPE_INTEGER: 667 case ACPI_TYPE_BUFFER_FIELD: 668 case ACPI_TYPE_LOCAL_BANK_FIELD: 669 case ACPI_TYPE_LOCAL_INDEX_FIELD: 670 /* 671 * These types require an Integer operand. We can convert 672 * a Buffer or a String to an Integer if necessary. 673 */ 674 status = 675 acpi_ex_convert_to_integer(source_desc, result_desc, 676 ACPI_IMPLICIT_CONVERSION); 677 break; 678 679 case ACPI_TYPE_STRING: 680 /* 681 * The operand must be a String. We can convert an 682 * Integer or Buffer if necessary 683 */ 684 status = 685 acpi_ex_convert_to_string(source_desc, result_desc, 686 ACPI_IMPLICIT_CONVERT_HEX); 687 break; 688 689 case ACPI_TYPE_BUFFER: 690 /* 691 * The operand must be a Buffer. We can convert an 692 * Integer or String if necessary 693 */ 694 status = 695 acpi_ex_convert_to_buffer(source_desc, result_desc); 696 break; 697 698 default: 699 700 ACPI_ERROR((AE_INFO, 701 "Bad destination type during conversion: 0x%X", 702 destination_type)); 703 status = AE_AML_INTERNAL; 704 break; 705 } 706 break; 707 708 case ARGI_REFERENCE: 709 /* 710 * create_xxxx_field cases - we are storing the field object into the name 711 */ 712 break; 713 714 default: 715 716 ACPI_ERROR((AE_INFO, 717 "Unknown Target type ID 0x%X AmlOpcode 0x%X DestType %s", 718 GET_CURRENT_ARG_TYPE(walk_state->op_info-> 719 runtime_args), 720 walk_state->opcode, 721 acpi_ut_get_type_name(destination_type))); 722 status = AE_AML_INTERNAL; 723 } 724 725 /* 726 * Source-to-Target conversion semantics: 727 * 728 * If conversion to the target type cannot be performed, then simply 729 * overwrite the target with the new object and type. 730 */ 731 if (status == AE_TYPE) { 732 status = AE_OK; 733 } 734 735 return_ACPI_STATUS(status); 736 } 737