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