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