blob: 74162a11817dc9b6bff8e30ba2d039a7c1ec47a9 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/******************************************************************************
2 *
3 * Module Name: exconvrt - Object conversion routines
4 *
5 *****************************************************************************/
6
7/*
Bob Mooreb4e104e2011-01-17 11:05:40 +08008 * Copyright (C) 2000 - 2011, Intel Corp.
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 * 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070044#include <acpi/acpi.h>
Len Browne2f7a772009-01-09 00:30:03 -050045#include "accommon.h"
46#include "acinterp.h"
47#include "amlcode.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070048
Linus Torvalds1da177e2005-04-16 15:20:36 -070049#define _COMPONENT ACPI_EXECUTER
Len Brown4be44fc2005-08-05 00:44:28 -040050ACPI_MODULE_NAME("exconvrt")
Linus Torvalds1da177e2005-04-16 15:20:36 -070051
Robert Moore44f6c012005-04-18 22:49:35 -040052/* Local prototypes */
Robert Moore44f6c012005-04-18 22:49:35 -040053static u32
Bob Moore5df7e6c2010-01-21 10:06:32 +080054acpi_ex_convert_to_ascii(u64 integer, u16 base, u8 *string, u8 max_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -070055
56/*******************************************************************************
57 *
58 * FUNCTION: acpi_ex_convert_to_integer
59 *
Bob Moore2425a092008-09-27 10:42:02 +080060 * PARAMETERS: obj_desc - Object to be converted. Must be an
Linus Torvalds1da177e2005-04-16 15:20:36 -070061 * 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
Len Brown4be44fc2005-08-05 00:44:28 -040072acpi_ex_convert_to_integer(union acpi_operand_object *obj_desc,
73 union acpi_operand_object **result_desc, u32 flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -070074{
Len Brown4be44fc2005-08-05 00:44:28 -040075 union acpi_operand_object *return_desc;
76 u8 *pointer;
Bob Moore5df7e6c2010-01-21 10:06:32 +080077 u64 result;
Len Brown4be44fc2005-08-05 00:44:28 -040078 u32 i;
79 u32 count;
80 acpi_status status;
Linus Torvalds1da177e2005-04-16 15:20:36 -070081
Bob Mooreb229cf92006-04-21 17:15:00 -040082 ACPI_FUNCTION_TRACE_PTR(ex_convert_to_integer, obj_desc);
Linus Torvalds1da177e2005-04-16 15:20:36 -070083
Bob Moore3371c192009-02-18 14:44:03 +080084 switch (obj_desc->common.type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070085 case ACPI_TYPE_INTEGER:
86
87 /* No conversion necessary */
88
89 *result_desc = obj_desc;
Len Brown4be44fc2005-08-05 00:44:28 -040090 return_ACPI_STATUS(AE_OK);
Linus Torvalds1da177e2005-04-16 15:20:36 -070091
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;
Len Brown4be44fc2005-08-05 00:44:28 -040098 count = obj_desc->buffer.length;
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 break;
100
101 default:
Len Brown4be44fc2005-08-05 00:44:28 -0400102 return_ACPI_STATUS(AE_TYPE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 }
104
105 /*
Bob Moore2425a092008-09-27 10:42:02 +0800106 * Convert the buffer/string to an integer. Note that both buffers and
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 * 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
Robert Moore44f6c012005-04-18 22:49:35 -0400116 /* String conversion is different than Buffer conversion */
117
Bob Moore3371c192009-02-18 14:44:03 +0800118 switch (obj_desc->common.type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 case ACPI_TYPE_STRING:
120
121 /*
122 * Convert string to an integer - for most cases, the string must be
Bob Moore2425a092008-09-27 10:42:02 +0800123 * hexadecimal as per the ACPI specification. The only exception (as
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 * of ACPI 3.0) is that the to_integer() operator allows both decimal
125 * and hexadecimal strings (hex prefixed with "0x").
126 */
Len Brown4be44fc2005-08-05 00:44:28 -0400127 status = acpi_ut_strtoul64((char *)pointer, flags, &result);
128 if (ACPI_FAILURE(status)) {
129 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 }
131 break;
132
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 case ACPI_TYPE_BUFFER:
134
135 /* Check for zero-length buffer */
136
137 if (!count) {
Len Brown4be44fc2005-08-05 00:44:28 -0400138 return_ACPI_STATUS(AE_AML_BUFFER_LIMIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 }
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 */
Bob Moore5df7e6c2010-01-21 10:06:32 +0800157 result |= (((u64) pointer[i]) << (i * 8));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 }
159 break;
160
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 default:
Bob Moore2425a092008-09-27 10:42:02 +0800162
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 /* No other types can get here */
164 break;
165 }
166
Robert Moore44f6c012005-04-18 22:49:35 -0400167 /* Create a new integer */
168
Bob Mooredc95a272009-11-12 09:52:45 +0800169 return_desc = acpi_ut_create_integer_object(result);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170 if (!return_desc) {
Len Brown4be44fc2005-08-05 00:44:28 -0400171 return_ACPI_STATUS(AE_NO_MEMORY);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 }
173
Bob Mooref6dd9222006-07-07 20:44:38 -0400174 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Converted value: %8.8X%8.8X\n",
175 ACPI_FORMAT_UINT64(result)));
176
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 /* Save the Result */
178
Len Brown4be44fc2005-08-05 00:44:28 -0400179 acpi_ex_truncate_for32bit_table(return_desc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 *result_desc = return_desc;
Len Brown4be44fc2005-08-05 00:44:28 -0400181 return_ACPI_STATUS(AE_OK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182}
183
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184/*******************************************************************************
185 *
186 * FUNCTION: acpi_ex_convert_to_buffer
187 *
Bob Moore2425a092008-09-27 10:42:02 +0800188 * PARAMETERS: obj_desc - Object to be converted. Must be an
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 * 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
Len Brown4be44fc2005-08-05 00:44:28 -0400199acpi_ex_convert_to_buffer(union acpi_operand_object *obj_desc,
200 union acpi_operand_object **result_desc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201{
Len Brown4be44fc2005-08-05 00:44:28 -0400202 union acpi_operand_object *return_desc;
203 u8 *new_buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204
Bob Mooreb229cf92006-04-21 17:15:00 -0400205 ACPI_FUNCTION_TRACE_PTR(ex_convert_to_buffer, obj_desc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206
Bob Moore3371c192009-02-18 14:44:03 +0800207 switch (obj_desc->common.type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 case ACPI_TYPE_BUFFER:
209
210 /* No conversion necessary */
211
212 *result_desc = obj_desc;
Len Brown4be44fc2005-08-05 00:44:28 -0400213 return_ACPI_STATUS(AE_OK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214
215 case ACPI_TYPE_INTEGER:
216
217 /*
218 * Create a new Buffer object.
219 * Need enough space for one integer
220 */
Len Brown4be44fc2005-08-05 00:44:28 -0400221 return_desc =
222 acpi_ut_create_buffer_object(acpi_gbl_integer_byte_width);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 if (!return_desc) {
Len Brown4be44fc2005-08-05 00:44:28 -0400224 return_ACPI_STATUS(AE_NO_MEMORY);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 }
226
227 /* Copy the integer to the buffer, LSB first */
228
229 new_buf = return_desc->buffer.pointer;
Len Brown4be44fc2005-08-05 00:44:28 -0400230 ACPI_MEMCPY(new_buf,
231 &obj_desc->integer.value,
232 acpi_gbl_integer_byte_width);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 break;
234
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 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 */
Len Brown4be44fc2005-08-05 00:44:28 -0400246 return_desc = acpi_ut_create_buffer_object((acpi_size)
247 obj_desc->string.
248 length + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 if (!return_desc) {
Len Brown4be44fc2005-08-05 00:44:28 -0400250 return_ACPI_STATUS(AE_NO_MEMORY);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 }
252
253 /* Copy the string to the buffer */
254
255 new_buf = return_desc->buffer.pointer;
Len Brown4be44fc2005-08-05 00:44:28 -0400256 ACPI_STRNCPY((char *)new_buf, (char *)obj_desc->string.pointer,
257 obj_desc->string.length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 break;
259
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 default:
Len Brown4be44fc2005-08-05 00:44:28 -0400261 return_ACPI_STATUS(AE_TYPE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 }
263
264 /* Mark buffer initialized */
265
266 return_desc->common.flags |= AOPOBJ_DATA_VALID;
267 *result_desc = return_desc;
Len Brown4be44fc2005-08-05 00:44:28 -0400268 return_ACPI_STATUS(AE_OK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269}
270
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271/*******************************************************************************
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
Robert Moore44f6c012005-04-18 22:49:35 -0400286static u32
Bob Moore5df7e6c2010-01-21 10:06:32 +0800287acpi_ex_convert_to_ascii(u64 integer, u16 base, u8 *string, u8 data_width)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288{
Bob Moore5df7e6c2010-01-21 10:06:32 +0800289 u64 digit;
Bob Moore67a119f2008-06-10 13:42:13 +0800290 u32 i;
291 u32 j;
292 u32 k = 0;
293 u32 hex_length;
294 u32 decimal_length;
Len Brown4be44fc2005-08-05 00:44:28 -0400295 u32 remainder;
296 u8 supress_zeros;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297
Len Brown4be44fc2005-08-05 00:44:28 -0400298 ACPI_FUNCTION_ENTRY();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299
300 switch (base) {
301 case 10:
302
303 /* Setup max length for the decimal number */
304
305 switch (data_width) {
306 case 1:
307 decimal_length = ACPI_MAX8_DECIMAL_DIGITS;
308 break;
309
310 case 4:
311 decimal_length = ACPI_MAX32_DECIMAL_DIGITS;
312 break;
313
314 case 8:
315 default:
316 decimal_length = ACPI_MAX64_DECIMAL_DIGITS;
317 break;
318 }
319
Len Brown4be44fc2005-08-05 00:44:28 -0400320 supress_zeros = TRUE; /* No leading zeros */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 remainder = 0;
322
323 for (i = decimal_length; i > 0; i--) {
Bob Moore52fc0b02006-10-02 00:00:00 -0400324
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 /* Divide by nth factor of 10 */
326
327 digit = integer;
328 for (j = 0; j < i; j++) {
Len Brown4be44fc2005-08-05 00:44:28 -0400329 (void)acpi_ut_short_divide(digit, 10, &digit,
330 &remainder);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 }
332
333 /* Handle leading zeros */
334
335 if (remainder != 0) {
336 supress_zeros = FALSE;
337 }
338
339 if (!supress_zeros) {
340 string[k] = (u8) (ACPI_ASCII_ZERO + remainder);
341 k++;
342 }
343 }
344 break;
345
346 case 16:
347
Robert Moore44f6c012005-04-18 22:49:35 -0400348 /* hex_length: 2 ascii hex chars per data byte */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349
Bob Moore67a119f2008-06-10 13:42:13 +0800350 hex_length = ACPI_MUL_2(data_width);
Len Brown4be44fc2005-08-05 00:44:28 -0400351 for (i = 0, j = (hex_length - 1); i < hex_length; i++, j--) {
Bob Moore52fc0b02006-10-02 00:00:00 -0400352
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 /* Get one hex digit, most significant digits first */
354
Len Brown4be44fc2005-08-05 00:44:28 -0400355 string[k] =
356 (u8) acpi_ut_hex_to_ascii_char(integer,
357 ACPI_MUL_4(j));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 k++;
359 }
360 break;
361
362 default:
363 return (0);
364 }
365
366 /*
Bob Moore2425a092008-09-27 10:42:02 +0800367 * Since leading zeros are suppressed, we must check for the case where
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 * the integer equals 0
369 *
370 * Finally, null terminate the string and return the length
371 */
372 if (!k) {
Len Brown4be44fc2005-08-05 00:44:28 -0400373 string[0] = ACPI_ASCII_ZERO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 k = 1;
375 }
376
Len Brown4be44fc2005-08-05 00:44:28 -0400377 string[k] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 return ((u32) k);
379}
380
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381/*******************************************************************************
382 *
383 * FUNCTION: acpi_ex_convert_to_string
384 *
Bob Moore2425a092008-09-27 10:42:02 +0800385 * PARAMETERS: obj_desc - Object to be converted. Must be an
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 * Integer, Buffer, or String
387 * result_desc - Where the string object is returned
388 * Type - String flags (base and conversion type)
389 *
390 * RETURN: Status
391 *
392 * DESCRIPTION: Convert an ACPI Object to a string
393 *
394 ******************************************************************************/
395
396acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400397acpi_ex_convert_to_string(union acpi_operand_object * obj_desc,
398 union acpi_operand_object ** result_desc, u32 type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399{
Len Brown4be44fc2005-08-05 00:44:28 -0400400 union acpi_operand_object *return_desc;
401 u8 *new_buf;
402 u32 i;
403 u32 string_length = 0;
404 u16 base = 16;
405 u8 separator = ',';
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406
Bob Mooreb229cf92006-04-21 17:15:00 -0400407 ACPI_FUNCTION_TRACE_PTR(ex_convert_to_string, obj_desc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408
Bob Moore3371c192009-02-18 14:44:03 +0800409 switch (obj_desc->common.type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 case ACPI_TYPE_STRING:
411
412 /* No conversion necessary */
413
414 *result_desc = obj_desc;
Len Brown4be44fc2005-08-05 00:44:28 -0400415 return_ACPI_STATUS(AE_OK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416
417 case ACPI_TYPE_INTEGER:
418
419 switch (type) {
420 case ACPI_EXPLICIT_CONVERT_DECIMAL:
421
422 /* Make room for maximum decimal number */
423
424 string_length = ACPI_MAX_DECIMAL_DIGITS;
425 base = 10;
426 break;
427
428 default:
429
430 /* Two hex string characters for each integer byte */
431
Len Brown4be44fc2005-08-05 00:44:28 -0400432 string_length = ACPI_MUL_2(acpi_gbl_integer_byte_width);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 break;
434 }
435
436 /*
437 * Create a new String
438 * Need enough space for one ASCII integer (plus null terminator)
439 */
Len Brown4be44fc2005-08-05 00:44:28 -0400440 return_desc =
441 acpi_ut_create_string_object((acpi_size) string_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 if (!return_desc) {
Len Brown4be44fc2005-08-05 00:44:28 -0400443 return_ACPI_STATUS(AE_NO_MEMORY);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 }
445
446 new_buf = return_desc->buffer.pointer;
447
448 /* Convert integer to string */
449
Len Brown4be44fc2005-08-05 00:44:28 -0400450 string_length =
451 acpi_ex_convert_to_ascii(obj_desc->integer.value, base,
452 new_buf,
453 acpi_gbl_integer_byte_width);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454
455 /* Null terminate at the correct place */
456
457 return_desc->string.length = string_length;
Len Brown4be44fc2005-08-05 00:44:28 -0400458 new_buf[string_length] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 break;
460
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 case ACPI_TYPE_BUFFER:
462
463 /* Setup string length, base, and separator */
464
465 switch (type) {
Len Brown4be44fc2005-08-05 00:44:28 -0400466 case ACPI_EXPLICIT_CONVERT_DECIMAL: /* Used by to_decimal_string */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 /*
468 * From ACPI: "If Data is a buffer, it is converted to a string of
469 * decimal values separated by commas."
470 */
471 base = 10;
472
473 /*
Bob Moore2425a092008-09-27 10:42:02 +0800474 * Calculate the final string length. Individual string values
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 * are variable length (include separator for each)
476 */
477 for (i = 0; i < obj_desc->buffer.length; i++) {
478 if (obj_desc->buffer.pointer[i] >= 100) {
479 string_length += 4;
Len Brown4be44fc2005-08-05 00:44:28 -0400480 } else if (obj_desc->buffer.pointer[i] >= 10) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 string_length += 3;
Len Brown4be44fc2005-08-05 00:44:28 -0400482 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 string_length += 2;
484 }
485 }
486 break;
487
488 case ACPI_IMPLICIT_CONVERT_HEX:
489 /*
490 * From the ACPI spec:
491 *"The entire contents of the buffer are converted to a string of
492 * two-character hexadecimal numbers, each separated by a space."
493 */
494 separator = ' ';
495 string_length = (obj_desc->buffer.length * 3);
496 break;
497
Len Brown4be44fc2005-08-05 00:44:28 -0400498 case ACPI_EXPLICIT_CONVERT_HEX: /* Used by to_hex_string */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 /*
500 * From ACPI: "If Data is a buffer, it is converted to a string of
501 * hexadecimal values separated by commas."
502 */
503 string_length = (obj_desc->buffer.length * 3);
504 break;
505
506 default:
Len Brown4be44fc2005-08-05 00:44:28 -0400507 return_ACPI_STATUS(AE_BAD_PARAMETER);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 }
509
510 /*
Bob Moorec51a4de2005-11-17 13:07:00 -0500511 * Create a new string object and string buffer
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 * (-1 because of extra separator included in string_length from above)
Bob Moore4ca846e2008-09-27 13:27:51 +0800513 * Allow creation of zero-length strings from zero-length buffers.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514 */
Bob Moore4ca846e2008-09-27 13:27:51 +0800515 if (string_length) {
516 string_length--;
517 }
518
Len Brownfd350942007-05-09 23:34:35 -0400519 return_desc = acpi_ut_create_string_object((acpi_size)
Bob Moore4ca846e2008-09-27 13:27:51 +0800520 string_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 if (!return_desc) {
Len Brown4be44fc2005-08-05 00:44:28 -0400522 return_ACPI_STATUS(AE_NO_MEMORY);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 }
524
525 new_buf = return_desc->buffer.pointer;
526
527 /*
528 * Convert buffer bytes to hex or decimal values
529 * (separated by commas or spaces)
530 */
531 for (i = 0; i < obj_desc->buffer.length; i++) {
Bob Moore5df7e6c2010-01-21 10:06:32 +0800532 new_buf += acpi_ex_convert_to_ascii((u64) obj_desc->
533 buffer.pointer[i],
534 base, new_buf, 1);
Len Brown4be44fc2005-08-05 00:44:28 -0400535 *new_buf++ = separator; /* each separated by a comma or space */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 }
537
Robert Moore44f6c012005-04-18 22:49:35 -0400538 /*
539 * Null terminate the string
540 * (overwrites final comma/space from above)
541 */
Bob Moore4ca846e2008-09-27 13:27:51 +0800542 if (obj_desc->buffer.length) {
543 new_buf--;
544 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 *new_buf = 0;
546 break;
547
548 default:
Len Brown4be44fc2005-08-05 00:44:28 -0400549 return_ACPI_STATUS(AE_TYPE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 }
551
552 *result_desc = return_desc;
Len Brown4be44fc2005-08-05 00:44:28 -0400553 return_ACPI_STATUS(AE_OK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554}
555
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556/*******************************************************************************
557 *
558 * FUNCTION: acpi_ex_convert_to_target_type
559 *
560 * PARAMETERS: destination_type - Current type of the destination
561 * source_desc - Source object to be converted.
562 * result_desc - Where the converted object is returned
563 * walk_state - Current method state
564 *
565 * RETURN: Status
566 *
567 * DESCRIPTION: Implements "implicit conversion" rules for storing an object.
568 *
569 ******************************************************************************/
570
571acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400572acpi_ex_convert_to_target_type(acpi_object_type destination_type,
573 union acpi_operand_object *source_desc,
574 union acpi_operand_object **result_desc,
575 struct acpi_walk_state *walk_state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576{
Len Brown4be44fc2005-08-05 00:44:28 -0400577 acpi_status status = AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578
Bob Mooreb229cf92006-04-21 17:15:00 -0400579 ACPI_FUNCTION_TRACE(ex_convert_to_target_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580
581 /* Default behavior */
582
583 *result_desc = source_desc;
584
585 /*
586 * If required by the target,
587 * perform implicit conversion on the source before we store it.
588 */
Len Brown4be44fc2005-08-05 00:44:28 -0400589 switch (GET_CURRENT_ARG_TYPE(walk_state->op_info->runtime_args)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 case ARGI_SIMPLE_TARGET:
591 case ARGI_FIXED_TARGET:
Len Brown4be44fc2005-08-05 00:44:28 -0400592 case ARGI_INTEGER_REF: /* Handles Increment, Decrement cases */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593
594 switch (destination_type) {
595 case ACPI_TYPE_LOCAL_REGION_FIELD:
596 /*
597 * Named field can always handle conversions
598 */
599 break;
600
601 default:
602 /* No conversion allowed for these types */
603
Bob Moore3371c192009-02-18 14:44:03 +0800604 if (destination_type != source_desc->common.type) {
Len Brown4be44fc2005-08-05 00:44:28 -0400605 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
606 "Explicit operator, will store (%s) over existing type (%s)\n",
607 acpi_ut_get_object_type_name
608 (source_desc),
609 acpi_ut_get_type_name
610 (destination_type)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 status = AE_TYPE;
612 }
613 }
614 break;
615
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 case ARGI_TARGETREF:
617
618 switch (destination_type) {
619 case ACPI_TYPE_INTEGER:
620 case ACPI_TYPE_BUFFER_FIELD:
621 case ACPI_TYPE_LOCAL_BANK_FIELD:
622 case ACPI_TYPE_LOCAL_INDEX_FIELD:
623 /*
Bob Moore2425a092008-09-27 10:42:02 +0800624 * These types require an Integer operand. We can convert
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 * a Buffer or a String to an Integer if necessary.
626 */
Len Brown4be44fc2005-08-05 00:44:28 -0400627 status =
628 acpi_ex_convert_to_integer(source_desc, result_desc,
629 16);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 break;
631
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 case ACPI_TYPE_STRING:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 /*
Bob Moore2425a092008-09-27 10:42:02 +0800634 * The operand must be a String. We can convert an
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 * Integer or Buffer if necessary
636 */
Len Brown4be44fc2005-08-05 00:44:28 -0400637 status =
638 acpi_ex_convert_to_string(source_desc, result_desc,
639 ACPI_IMPLICIT_CONVERT_HEX);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 break;
641
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 case ACPI_TYPE_BUFFER:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 /*
Bob Moore2425a092008-09-27 10:42:02 +0800644 * The operand must be a Buffer. We can convert an
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 * Integer or String if necessary
646 */
Len Brown4be44fc2005-08-05 00:44:28 -0400647 status =
648 acpi_ex_convert_to_buffer(source_desc, result_desc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 break;
650
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 default:
Bob Mooreb8e4d892006-01-27 16:43:00 -0500652 ACPI_ERROR((AE_INFO,
Bob Mooref6a22b02010-03-05 17:56:40 +0800653 "Bad destination type during conversion: 0x%X",
Bob Mooreb8e4d892006-01-27 16:43:00 -0500654 destination_type));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655 status = AE_AML_INTERNAL;
656 break;
657 }
658 break;
659
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 case ARGI_REFERENCE:
661 /*
662 * create_xxxx_field cases - we are storing the field object into the name
663 */
664 break;
665
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 default:
Bob Mooreb8e4d892006-01-27 16:43:00 -0500667 ACPI_ERROR((AE_INFO,
Bob Mooref6a22b02010-03-05 17:56:40 +0800668 "Unknown Target type ID 0x%X AmlOpcode 0x%X DestType %s",
Bob Mooreb8e4d892006-01-27 16:43:00 -0500669 GET_CURRENT_ARG_TYPE(walk_state->op_info->
670 runtime_args),
671 walk_state->opcode,
672 acpi_ut_get_type_name(destination_type)));
Bob Moore4a90c7e2006-01-13 16:22:00 -0500673 status = AE_AML_INTERNAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 }
675
676 /*
677 * Source-to-Target conversion semantics:
678 *
679 * If conversion to the target type cannot be performed, then simply
680 * overwrite the target with the new object and type.
681 */
682 if (status == AE_TYPE) {
683 status = AE_OK;
684 }
685
Len Brown4be44fc2005-08-05 00:44:28 -0400686 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687}