1 /******************************************************************************
3 * Module Name: exconvrt - Object conversion routines
5 *****************************************************************************/
8 * Copyright (C) 2000 - 2004, R. Byron Moore
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
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.
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.
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.
45 #include <acpi/acpi.h>
46 #include <acpi/acinterp.h>
47 #include <acpi/amlcode.h>
50 #define _COMPONENT ACPI_EXECUTER
51 ACPI_MODULE_NAME ("exconvrt")
54 /*******************************************************************************
56 * FUNCTION: acpi_ex_convert_to_integer
58 * PARAMETERS: obj_desc - Object to be converted. Must be an
59 * Integer, Buffer, or String
60 * result_desc - Where the new Integer object is returned
61 * Flags - Used for string conversion
65 * DESCRIPTION: Convert an ACPI Object to an integer.
67 ******************************************************************************/
70 acpi_ex_convert_to_integer (
71 union acpi_operand_object *obj_desc,
72 union acpi_operand_object **result_desc,
75 union acpi_operand_object *return_desc;
83 ACPI_FUNCTION_TRACE_PTR ("ex_convert_to_integer", obj_desc);
86 switch (ACPI_GET_OBJECT_TYPE (obj_desc)) {
87 case ACPI_TYPE_INTEGER:
89 /* No conversion necessary */
91 *result_desc = obj_desc;
92 return_ACPI_STATUS (AE_OK);
94 case ACPI_TYPE_BUFFER:
95 case ACPI_TYPE_STRING:
97 /* Note: Takes advantage of common buffer/string fields */
99 pointer = obj_desc->buffer.pointer;
100 count = obj_desc->buffer.length;
104 return_ACPI_STATUS (AE_TYPE);
108 * Convert the buffer/string to an integer. Note that both buffers and
109 * strings are treated as raw data - we don't convert ascii to hex for
112 * There are two terminating conditions for the loop:
113 * 1) The size of an integer has been reached, or
114 * 2) The end of the buffer or string has been reached
118 /* Transfer no more than an integer's worth of data */
120 if (count > acpi_gbl_integer_byte_width) {
121 count = acpi_gbl_integer_byte_width;
125 * String conversion is different than Buffer conversion
127 switch (ACPI_GET_OBJECT_TYPE (obj_desc)) {
128 case ACPI_TYPE_STRING:
131 * Convert string to an integer - for most cases, the string must be
132 * hexadecimal as per the ACPI specification. The only exception (as
133 * of ACPI 3.0) is that the to_integer() operator allows both decimal
134 * and hexadecimal strings (hex prefixed with "0x").
136 status = acpi_ut_strtoul64 ((char *) pointer, flags, &result);
137 if (ACPI_FAILURE (status)) {
138 return_ACPI_STATUS (status);
143 case ACPI_TYPE_BUFFER:
146 * Convert buffer to an integer - we simply grab enough raw data
147 * from the buffer to fill an integer
149 for (i = 0; i < count; i++) {
151 * Get next byte and shift it into the Result.
152 * Little endian is used, meaning that the first byte of the buffer
153 * is the LSB of the integer
155 result |= (((acpi_integer) pointer[i]) << (i * 8));
161 /* No other types can get here */
166 * Create a new integer
168 return_desc = acpi_ut_create_internal_object (ACPI_TYPE_INTEGER);
170 return_ACPI_STATUS (AE_NO_MEMORY);
173 /* Save the Result */
175 return_desc->integer.value = result;
176 *result_desc = return_desc;
177 return_ACPI_STATUS (AE_OK);
181 /*******************************************************************************
183 * FUNCTION: acpi_ex_convert_to_buffer
185 * PARAMETERS: obj_desc - Object to be converted. Must be an
186 * Integer, Buffer, or String
187 * result_desc - Where the new buffer object is returned
191 * DESCRIPTION: Convert an ACPI Object to a Buffer
193 ******************************************************************************/
196 acpi_ex_convert_to_buffer (
197 union acpi_operand_object *obj_desc,
198 union acpi_operand_object **result_desc)
200 union acpi_operand_object *return_desc;
204 ACPI_FUNCTION_TRACE_PTR ("ex_convert_to_buffer", obj_desc);
207 switch (ACPI_GET_OBJECT_TYPE (obj_desc)) {
208 case ACPI_TYPE_BUFFER:
210 /* No conversion necessary */
212 *result_desc = obj_desc;
213 return_ACPI_STATUS (AE_OK);
216 case ACPI_TYPE_INTEGER:
219 * Create a new Buffer object.
220 * Need enough space for one integer
222 return_desc = acpi_ut_create_buffer_object (acpi_gbl_integer_byte_width);
224 return_ACPI_STATUS (AE_NO_MEMORY);
227 /* Copy the integer to the buffer, LSB first */
229 new_buf = return_desc->buffer.pointer;
230 ACPI_MEMCPY (new_buf,
231 &obj_desc->integer.value,
232 acpi_gbl_integer_byte_width);
236 case ACPI_TYPE_STRING:
239 * Create a new Buffer object
240 * Size will be the string length
242 return_desc = acpi_ut_create_buffer_object ((acpi_size) obj_desc->string.length);
244 return_ACPI_STATUS (AE_NO_MEMORY);
247 /* Copy the string to the buffer */
249 new_buf = return_desc->buffer.pointer;
250 ACPI_STRNCPY ((char *) new_buf, (char *) obj_desc->string.pointer,
251 obj_desc->string.length);
256 return_ACPI_STATUS (AE_TYPE);
259 /* Mark buffer initialized */
261 return_desc->common.flags |= AOPOBJ_DATA_VALID;
262 *result_desc = return_desc;
263 return_ACPI_STATUS (AE_OK);
267 /*******************************************************************************
269 * FUNCTION: acpi_ex_convert_to_ascii
271 * PARAMETERS: Integer - Value to be converted
272 * Base - ACPI_STRING_DECIMAL or ACPI_STRING_HEX
273 * String - Where the string is returned
274 * data_width - Size of data item to be converted, in bytes
276 * RETURN: Actual string length
278 * DESCRIPTION: Convert an ACPI Integer to a hex or decimal string
280 ******************************************************************************/
283 acpi_ex_convert_to_ascii (
284 acpi_integer integer,
292 acpi_native_uint k = 0;
293 acpi_native_uint hex_length;
294 acpi_native_uint decimal_length;
299 ACPI_FUNCTION_ENTRY ();
305 /* Setup max length for the decimal number */
307 switch (data_width) {
309 decimal_length = ACPI_MAX8_DECIMAL_DIGITS;
313 decimal_length = ACPI_MAX32_DECIMAL_DIGITS;
318 decimal_length = ACPI_MAX64_DECIMAL_DIGITS;
322 supress_zeros = TRUE; /* No leading zeros */
325 for (i = decimal_length; i > 0; i--) {
326 /* Divide by nth factor of 10 */
329 for (j = 0; j < i; j++) {
330 (void) acpi_ut_short_divide (digit, 10, &digit, &remainder);
333 /* Handle leading zeros */
335 if (remainder != 0) {
336 supress_zeros = FALSE;
339 if (!supress_zeros) {
340 string[k] = (u8) (ACPI_ASCII_ZERO + remainder);
348 hex_length = ACPI_MUL_2 (data_width); /* 2 ascii hex chars per data byte */
350 for (i = 0, j = (hex_length-1); i < hex_length; i++, j--) {
351 /* Get one hex digit, most significant digits first */
353 string[k] = (u8) acpi_ut_hex_to_ascii_char (integer, ACPI_MUL_4 (j));
363 * Since leading zeros are supressed, we must check for the case where
364 * the integer equals 0
366 * Finally, null terminate the string and return the length
369 string [0] = ACPI_ASCII_ZERO;
378 /*******************************************************************************
380 * FUNCTION: acpi_ex_convert_to_string
382 * PARAMETERS: obj_desc - Object to be converted. Must be an
383 * Integer, Buffer, or String
384 * result_desc - Where the string object is returned
385 * Type - String flags (base and conversion type)
389 * DESCRIPTION: Convert an ACPI Object to a string
391 ******************************************************************************/
394 acpi_ex_convert_to_string (
395 union acpi_operand_object *obj_desc,
396 union acpi_operand_object **result_desc,
399 union acpi_operand_object *return_desc;
401 u32 string_length = 0;
407 ACPI_FUNCTION_TRACE_PTR ("ex_convert_to_string", obj_desc);
410 switch (ACPI_GET_OBJECT_TYPE (obj_desc)) {
411 case ACPI_TYPE_STRING:
413 /* No conversion necessary */
415 *result_desc = obj_desc;
416 return_ACPI_STATUS (AE_OK);
419 case ACPI_TYPE_INTEGER:
422 case ACPI_EXPLICIT_CONVERT_DECIMAL:
424 /* Make room for maximum decimal number */
426 string_length = ACPI_MAX_DECIMAL_DIGITS;
432 /* Two hex string characters for each integer byte */
434 string_length = ACPI_MUL_2 (acpi_gbl_integer_byte_width);
439 * Create a new String
440 * Need enough space for one ASCII integer (plus null terminator)
442 return_desc = acpi_ut_create_string_object ((acpi_size) string_length);
444 return_ACPI_STATUS (AE_NO_MEMORY);
447 new_buf = return_desc->buffer.pointer;
449 /* Convert integer to string */
451 string_length = acpi_ex_convert_to_ascii (obj_desc->integer.value, base,
452 new_buf, acpi_gbl_integer_byte_width);
454 /* Null terminate at the correct place */
456 return_desc->string.length = string_length;
457 new_buf [string_length] = 0;
461 case ACPI_TYPE_BUFFER:
464 case ACPI_EXPLICIT_CONVERT_DECIMAL: /* Used by to_decimal_string operator */
466 * From ACPI: "If Data is a buffer, it is converted to a string of
467 * decimal values separated by commas."
470 string_length = obj_desc->buffer.length; /* 4 chars for each decimal */
472 /*lint -fallthrough */
474 case ACPI_IMPLICIT_CONVERT_HEX:
476 * From the ACPI spec:
477 *"The entire contents of the buffer are converted to a string of
478 * two-character hexadecimal numbers, each separated by a space."
480 if (type == ACPI_IMPLICIT_CONVERT_HEX) {
484 /*lint -fallthrough */
486 case ACPI_EXPLICIT_CONVERT_HEX: /* Used by to_hex_string operator */
488 * From ACPI: "If Data is a buffer, it is converted to a string of
489 * hexadecimal values separated by commas."
491 string_length += (obj_desc->buffer.length * 3);
492 if (string_length > ACPI_MAX_STRING_CONVERSION) /* ACPI limit */ {
493 return_ACPI_STATUS (AE_AML_STRING_LIMIT);
496 /* Create a new string object and string buffer */
498 return_desc = acpi_ut_create_string_object ((acpi_size) string_length -1);
500 return_ACPI_STATUS (AE_NO_MEMORY);
503 new_buf = return_desc->buffer.pointer;
506 * Convert buffer bytes to hex or decimal values
507 * (separated by commas)
509 for (i = 0; i < obj_desc->buffer.length; i++) {
510 new_buf += acpi_ex_convert_to_ascii (
511 (acpi_integer) obj_desc->buffer.pointer[i], base,
513 *new_buf++ = separator; /* each separated by a comma or space */
516 /* Null terminate the string (overwrites final comma from above) */
521 /* Recalculate length */
523 return_desc->string.length = ACPI_STRLEN (return_desc->string.pointer);
527 return_ACPI_STATUS (AE_BAD_PARAMETER);
532 return_ACPI_STATUS (AE_TYPE);
535 *result_desc = return_desc;
536 return_ACPI_STATUS (AE_OK);
540 /*******************************************************************************
542 * FUNCTION: acpi_ex_convert_to_target_type
544 * PARAMETERS: destination_type - Current type of the destination
545 * source_desc - Source object to be converted.
546 * result_desc - Where the converted object is returned
547 * walk_state - Current method state
551 * DESCRIPTION: Implements "implicit conversion" rules for storing an object.
553 ******************************************************************************/
556 acpi_ex_convert_to_target_type (
557 acpi_object_type destination_type,
558 union acpi_operand_object *source_desc,
559 union acpi_operand_object **result_desc,
560 struct acpi_walk_state *walk_state)
562 acpi_status status = AE_OK;
565 ACPI_FUNCTION_TRACE ("ex_convert_to_target_type");
568 /* Default behavior */
570 *result_desc = source_desc;
573 * If required by the target,
574 * perform implicit conversion on the source before we store it.
576 switch (GET_CURRENT_ARG_TYPE (walk_state->op_info->runtime_args)) {
577 case ARGI_SIMPLE_TARGET:
578 case ARGI_FIXED_TARGET:
579 case ARGI_INTEGER_REF: /* Handles Increment, Decrement cases */
581 switch (destination_type) {
582 case ACPI_TYPE_LOCAL_REGION_FIELD:
584 * Named field can always handle conversions
589 /* No conversion allowed for these types */
591 if (destination_type != ACPI_GET_OBJECT_TYPE (source_desc)) {
592 ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
593 "Explicit operator, will store (%s) over existing type (%s)\n",
594 acpi_ut_get_object_type_name (source_desc),
595 acpi_ut_get_type_name (destination_type)));
604 switch (destination_type) {
605 case ACPI_TYPE_INTEGER:
606 case ACPI_TYPE_BUFFER_FIELD:
607 case ACPI_TYPE_LOCAL_BANK_FIELD:
608 case ACPI_TYPE_LOCAL_INDEX_FIELD:
610 * These types require an Integer operand. We can convert
611 * a Buffer or a String to an Integer if necessary.
613 status = acpi_ex_convert_to_integer (source_desc, result_desc,
618 case ACPI_TYPE_STRING:
621 * The operand must be a String. We can convert an
622 * Integer or Buffer if necessary
624 status = acpi_ex_convert_to_string (source_desc, result_desc,
625 ACPI_IMPLICIT_CONVERT_HEX);
629 case ACPI_TYPE_BUFFER:
632 * The operand must be a Buffer. We can convert an
633 * Integer or String if necessary
635 status = acpi_ex_convert_to_buffer (source_desc, result_desc);
640 ACPI_REPORT_ERROR (("Bad destination type during conversion: %X\n",
642 status = AE_AML_INTERNAL;
650 * create_xxxx_field cases - we are storing the field object into the name
656 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
657 "Unknown Target type ID 0x%X Op %s dest_type %s\n",
658 GET_CURRENT_ARG_TYPE (walk_state->op_info->runtime_args),
659 walk_state->op_info->name, acpi_ut_get_type_name (destination_type)));
661 ACPI_REPORT_ERROR (("Bad Target Type (ARGI): %X\n",
662 GET_CURRENT_ARG_TYPE (walk_state->op_info->runtime_args)))
663 status = AE_AML_INTERNAL;
667 * Source-to-Target conversion semantics:
669 * If conversion to the target type cannot be performed, then simply
670 * overwrite the target with the new object and type.
672 if (status == AE_TYPE) {
676 return_ACPI_STATUS (status);