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