1 /******************************************************************************
2 *
3 * Module Name: exconvrt - Object conversion routines
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2011, 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.
97
98 switch (ObjDesc->Common.Type)
99 {
100 case ACPI_TYPE_INTEGER:
101
102 /* No conversion necessary */
103
104 *ResultDesc = ObjDesc;
105 return_ACPI_STATUS (AE_OK);
106
107 case ACPI_TYPE_BUFFER:
108 case ACPI_TYPE_STRING:
109
110 /* Note: Takes advantage of common buffer/string fields */
111
112 Pointer = ObjDesc->Buffer.Pointer;
113 Count = ObjDesc->Buffer.Length;
114 break;
115
116 default:
117 return_ACPI_STATUS (AE_TYPE);
118 }
119
120 /*
121 * Convert the buffer/string to an integer. Note that both buffers and
122 * strings are treated as raw data - we don't convert ascii to hex for
123 * strings.
124 *
125 * There are two terminating conditions for the loop:
126 * 1) The size of an integer has been reached, or
127 * 2) The end of the buffer or string has been reached
128 */
129 Result = 0;
130
131 /* String conversion is different than Buffer conversion */
132
133 switch (ObjDesc->Common.Type)
134 {
135 case ACPI_TYPE_STRING:
136
137 /*
138 * Convert string to an integer - for most cases, the string must be
139 * hexadecimal as per the ACPI specification. The only exception (as
140 * of ACPI 3.0) is that the ToInteger() operator allows both decimal
141 * and hexadecimal strings (hex prefixed with "0x").
142 */
143 Status = AcpiUtStrtoul64 ((char *) Pointer, Flags, &Result);
144 if (ACPI_FAILURE (Status))
145 {
146 return_ACPI_STATUS (Status);
147 }
148 break;
149
150
151 case ACPI_TYPE_BUFFER:
152
153 /* Check for zero-length buffer */
154
155 if (!Count)
156 {
157 return_ACPI_STATUS (AE_AML_BUFFER_LIMIT);
158 }
159
160 /* Transfer no more than an integer's worth of data */
161
162 if (Count > AcpiGbl_IntegerByteWidth)
163 {
164 Count = AcpiGbl_IntegerByteWidth;
165 }
166
167 /*
168 * Convert buffer to an integer - we simply grab enough raw data
169 * from the buffer to fill an integer
170 */
171 for (i = 0; i < Count; i++)
172 {
173 /*
174 * Get next byte and shift it into the Result.
175 * Little endian is used, meaning that the first byte of the buffer
176 * is the LSB of the integer
177 */
178 Result |= (((UINT64) Pointer[i]) << (i * 8));
179 }
180 break;
181
182
183 default:
184
185 /* No other types can get here */
186 break;
187 }
188
189 /* Create a new integer */
190
191 ReturnDesc = AcpiUtCreateIntegerObject (Result);
192 if (!ReturnDesc)
193 {
194 return_ACPI_STATUS (AE_NO_MEMORY);
195 }
196
197 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Converted value: %8.8X%8.8X\n",
198 ACPI_FORMAT_UINT64 (Result)));
199
200 /* Save the Result */
201
202 AcpiExTruncateFor32bitTable (ReturnDesc);
203 *ResultDesc = ReturnDesc;
204 return_ACPI_STATUS (AE_OK);
205 }
206
207
208 /*******************************************************************************
209 *
210 * FUNCTION: AcpiExConvertToBuffer
211 *
212 * PARAMETERS: ObjDesc - Object to be converted. Must be an
213 * Integer, Buffer, or String
214 * ResultDesc - Where the new buffer object is returned
215 *
216 * RETURN: Status
217 *
218 * DESCRIPTION: Convert an ACPI Object to a Buffer
219 *
220 ******************************************************************************/
221
222 ACPI_STATUS
225 ACPI_OPERAND_OBJECT **ResultDesc)
226 {
227 ACPI_OPERAND_OBJECT *ReturnDesc;
228 UINT8 *NewBuf;
229
230
231 ACPI_FUNCTION_TRACE_PTR (ExConvertToBuffer, ObjDesc);
232
233
234 switch (ObjDesc->Common.Type)
235 {
236 case ACPI_TYPE_BUFFER:
237
238 /* No conversion necessary */
239
240 *ResultDesc = ObjDesc;
241 return_ACPI_STATUS (AE_OK);
242
243
244 case ACPI_TYPE_INTEGER:
245
246 /*
247 * Create a new Buffer object.
248 * Need enough space for one integer
249 */
250 ReturnDesc = AcpiUtCreateBufferObject (AcpiGbl_IntegerByteWidth);
251 if (!ReturnDesc)
252 {
253 return_ACPI_STATUS (AE_NO_MEMORY);
254 }
255
256 /* Copy the integer to the buffer, LSB first */
257
258 NewBuf = ReturnDesc->Buffer.Pointer;
259 ACPI_MEMCPY (NewBuf,
260 &ObjDesc->Integer.Value,
261 AcpiGbl_IntegerByteWidth);
262 break;
263
264
265 case ACPI_TYPE_STRING:
266
267 /*
268 * Create a new Buffer object
269 * Size will be the string length
270 *
271 * NOTE: Add one to the string length to include the null terminator.
272 * The ACPI spec is unclear on this subject, but there is existing
273 * ASL/AML code that depends on the null being transferred to the new
274 * buffer.
275 */
276 ReturnDesc = AcpiUtCreateBufferObject (
277 (ACPI_SIZE) ObjDesc->String.Length + 1);
278 if (!ReturnDesc)
279 {
280 return_ACPI_STATUS (AE_NO_MEMORY);
281 }
282
283 /* Copy the string to the buffer */
284
285 NewBuf = ReturnDesc->Buffer.Pointer;
286 ACPI_STRNCPY ((char *) NewBuf, (char *) ObjDesc->String.Pointer,
287 ObjDesc->String.Length);
288 break;
289
290
291 default:
292 return_ACPI_STATUS (AE_TYPE);
293 }
294
295 /* Mark buffer initialized */
296
297 ReturnDesc->Common.Flags |= AOPOBJ_DATA_VALID;
298 *ResultDesc = ReturnDesc;
299 return_ACPI_STATUS (AE_OK);
300 }
301
302
303 /*******************************************************************************
304 *
305 * FUNCTION: AcpiExConvertToAscii
306 *
307 * PARAMETERS: Integer - Value to be converted
308 * Base - ACPI_STRING_DECIMAL or ACPI_STRING_HEX
309 * String - Where the string is returned
310 * DataWidth - Size of data item to be converted, in bytes
311 *
327 UINT32 j;
328 UINT32 k = 0;
329 UINT32 HexLength;
330 UINT32 DecimalLength;
331 UINT32 Remainder;
332 BOOLEAN SupressZeros;
333
334
335 ACPI_FUNCTION_ENTRY ();
336
337
338 switch (Base)
339 {
340 case 10:
341
342 /* Setup max length for the decimal number */
343
344 switch (DataWidth)
345 {
346 case 1:
347 DecimalLength = ACPI_MAX8_DECIMAL_DIGITS;
348 break;
349
350 case 4:
351 DecimalLength = ACPI_MAX32_DECIMAL_DIGITS;
352 break;
353
354 case 8:
355 default:
356 DecimalLength = ACPI_MAX64_DECIMAL_DIGITS;
357 break;
358 }
359
360 SupressZeros = TRUE; /* No leading zeros */
361 Remainder = 0;
362
363 for (i = DecimalLength; i > 0; i--)
364 {
365 /* Divide by nth factor of 10 */
366
367 Digit = Integer;
368 for (j = 0; j < i; j++)
369 {
370 (void) AcpiUtShortDivide (Digit, 10, &Digit, &Remainder);
371 }
372
373 /* Handle leading zeros */
374
375 if (Remainder != 0)
444 ACPI_OPERAND_OBJECT *ReturnDesc;
445 UINT8 *NewBuf;
446 UINT32 i;
447 UINT32 StringLength = 0;
448 UINT16 Base = 16;
449 UINT8 Separator = ',';
450
451
452 ACPI_FUNCTION_TRACE_PTR (ExConvertToString, ObjDesc);
453
454
455 switch (ObjDesc->Common.Type)
456 {
457 case ACPI_TYPE_STRING:
458
459 /* No conversion necessary */
460
461 *ResultDesc = ObjDesc;
462 return_ACPI_STATUS (AE_OK);
463
464
465 case ACPI_TYPE_INTEGER:
466
467 switch (Type)
468 {
469 case ACPI_EXPLICIT_CONVERT_DECIMAL:
470
471 /* Make room for maximum decimal number */
472
473 StringLength = ACPI_MAX_DECIMAL_DIGITS;
474 Base = 10;
475 break;
476
477 default:
478
479 /* Two hex string characters for each integer byte */
480
481 StringLength = ACPI_MUL_2 (AcpiGbl_IntegerByteWidth);
482 break;
483 }
484
488 */
489 ReturnDesc = AcpiUtCreateStringObject ((ACPI_SIZE) StringLength);
490 if (!ReturnDesc)
491 {
492 return_ACPI_STATUS (AE_NO_MEMORY);
493 }
494
495 NewBuf = ReturnDesc->Buffer.Pointer;
496
497 /* Convert integer to string */
498
499 StringLength = AcpiExConvertToAscii (ObjDesc->Integer.Value, Base,
500 NewBuf, AcpiGbl_IntegerByteWidth);
501
502 /* Null terminate at the correct place */
503
504 ReturnDesc->String.Length = StringLength;
505 NewBuf [StringLength] = 0;
506 break;
507
508
509 case ACPI_TYPE_BUFFER:
510
511 /* Setup string length, base, and separator */
512
513 switch (Type)
514 {
515 case ACPI_EXPLICIT_CONVERT_DECIMAL: /* Used by ToDecimalString */
516 /*
517 * From ACPI: "If Data is a buffer, it is converted to a string of
518 * decimal values separated by commas."
519 */
520 Base = 10;
521
522 /*
523 * Calculate the final string length. Individual string values
524 * are variable length (include separator for each)
525 */
526 for (i = 0; i < ObjDesc->Buffer.Length; i++)
527 {
528 if (ObjDesc->Buffer.Pointer[i] >= 100)
587 for (i = 0; i < ObjDesc->Buffer.Length; i++)
588 {
589 NewBuf += AcpiExConvertToAscii (
590 (UINT64) ObjDesc->Buffer.Pointer[i], Base,
591 NewBuf, 1);
592 *NewBuf++ = Separator; /* each separated by a comma or space */
593 }
594
595 /*
596 * Null terminate the string
597 * (overwrites final comma/space from above)
598 */
599 if (ObjDesc->Buffer.Length)
600 {
601 NewBuf--;
602 }
603 *NewBuf = 0;
604 break;
605
606 default:
607 return_ACPI_STATUS (AE_TYPE);
608 }
609
610 *ResultDesc = ReturnDesc;
611 return_ACPI_STATUS (AE_OK);
612 }
613
614
615 /*******************************************************************************
616 *
617 * FUNCTION: AcpiExConvertToTargetType
618 *
619 * PARAMETERS: DestinationType - Current type of the destination
620 * SourceDesc - Source object to be converted.
621 * ResultDesc - Where the converted object is returned
622 * WalkState - Current method state
623 *
624 * RETURN: Status
625 *
626 * DESCRIPTION: Implements "implicit conversion" rules for storing an object.
646
647 /*
648 * If required by the target,
649 * perform implicit conversion on the source before we store it.
650 */
651 switch (GET_CURRENT_ARG_TYPE (WalkState->OpInfo->RuntimeArgs))
652 {
653 case ARGI_SIMPLE_TARGET:
654 case ARGI_FIXED_TARGET:
655 case ARGI_INTEGER_REF: /* Handles Increment, Decrement cases */
656
657 switch (DestinationType)
658 {
659 case ACPI_TYPE_LOCAL_REGION_FIELD:
660 /*
661 * Named field can always handle conversions
662 */
663 break;
664
665 default:
666 /* No conversion allowed for these types */
667
668 if (DestinationType != SourceDesc->Common.Type)
669 {
670 ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
671 "Explicit operator, will store (%s) over existing type (%s)\n",
672 AcpiUtGetObjectTypeName (SourceDesc),
673 AcpiUtGetTypeName (DestinationType)));
674 Status = AE_TYPE;
675 }
676 }
677 break;
678
679
680 case ARGI_TARGETREF:
681
682 switch (DestinationType)
683 {
684 case ACPI_TYPE_INTEGER:
685 case ACPI_TYPE_BUFFER_FIELD:
686 case ACPI_TYPE_LOCAL_BANK_FIELD:
687 case ACPI_TYPE_LOCAL_INDEX_FIELD:
688 /*
689 * These types require an Integer operand. We can convert
690 * a Buffer or a String to an Integer if necessary.
691 */
692 Status = AcpiExConvertToInteger (SourceDesc, ResultDesc,
693 16);
694 break;
695
696
697 case ACPI_TYPE_STRING:
698 /*
699 * The operand must be a String. We can convert an
700 * Integer or Buffer if necessary
701 */
702 Status = AcpiExConvertToString (SourceDesc, ResultDesc,
703 ACPI_IMPLICIT_CONVERT_HEX);
704 break;
705
706
707 case ACPI_TYPE_BUFFER:
708 /*
709 * The operand must be a Buffer. We can convert an
710 * Integer or String if necessary
711 */
712 Status = AcpiExConvertToBuffer (SourceDesc, ResultDesc);
713 break;
714
715
716 default:
717 ACPI_ERROR ((AE_INFO, "Bad destination type during conversion: 0x%X",
718 DestinationType));
719 Status = AE_AML_INTERNAL;
720 break;
721 }
722 break;
723
724
725 case ARGI_REFERENCE:
726 /*
727 * CreateXxxxField cases - we are storing the field object into the name
728 */
729 break;
730
731
732 default:
733 ACPI_ERROR ((AE_INFO,
734 "Unknown Target type ID 0x%X AmlOpcode 0x%X DestType %s",
735 GET_CURRENT_ARG_TYPE (WalkState->OpInfo->RuntimeArgs),
736 WalkState->Opcode, AcpiUtGetTypeName (DestinationType)));
737 Status = AE_AML_INTERNAL;
738 }
739
740 /*
741 * Source-to-Target conversion semantics:
742 *
743 * If conversion to the target type cannot be performed, then simply
744 * overwrite the target with the new object and type.
745 */
746 if (Status == AE_TYPE)
747 {
748 Status = AE_OK;
749 }
750
751 return_ACPI_STATUS (Status);
752 }
753
754
|
1 /******************************************************************************
2 *
3 * Module Name: exconvrt - Object conversion routines
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2013, 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.
97
98 switch (ObjDesc->Common.Type)
99 {
100 case ACPI_TYPE_INTEGER:
101
102 /* No conversion necessary */
103
104 *ResultDesc = ObjDesc;
105 return_ACPI_STATUS (AE_OK);
106
107 case ACPI_TYPE_BUFFER:
108 case ACPI_TYPE_STRING:
109
110 /* Note: Takes advantage of common buffer/string fields */
111
112 Pointer = ObjDesc->Buffer.Pointer;
113 Count = ObjDesc->Buffer.Length;
114 break;
115
116 default:
117
118 return_ACPI_STATUS (AE_TYPE);
119 }
120
121 /*
122 * Convert the buffer/string to an integer. Note that both buffers and
123 * strings are treated as raw data - we don't convert ascii to hex for
124 * strings.
125 *
126 * There are two terminating conditions for the loop:
127 * 1) The size of an integer has been reached, or
128 * 2) The end of the buffer or string has been reached
129 */
130 Result = 0;
131
132 /* String conversion is different than Buffer conversion */
133
134 switch (ObjDesc->Common.Type)
135 {
136 case ACPI_TYPE_STRING:
137 /*
138 * Convert string to an integer - for most cases, the string must be
139 * hexadecimal as per the ACPI specification. The only exception (as
140 * of ACPI 3.0) is that the ToInteger() operator allows both decimal
141 * and hexadecimal strings (hex prefixed with "0x").
142 */
143 Status = AcpiUtStrtoul64 ((char *) Pointer, Flags, &Result);
144 if (ACPI_FAILURE (Status))
145 {
146 return_ACPI_STATUS (Status);
147 }
148 break;
149
150 case ACPI_TYPE_BUFFER:
151
152 /* Check for zero-length buffer */
153
154 if (!Count)
155 {
156 return_ACPI_STATUS (AE_AML_BUFFER_LIMIT);
157 }
158
159 /* Transfer no more than an integer's worth of data */
160
161 if (Count > AcpiGbl_IntegerByteWidth)
162 {
163 Count = AcpiGbl_IntegerByteWidth;
164 }
165
166 /*
167 * Convert buffer to an integer - we simply grab enough raw data
168 * from the buffer to fill an integer
169 */
170 for (i = 0; i < Count; i++)
171 {
172 /*
173 * Get next byte and shift it into the Result.
174 * Little endian is used, meaning that the first byte of the buffer
175 * is the LSB of the integer
176 */
177 Result |= (((UINT64) Pointer[i]) << (i * 8));
178 }
179 break;
180
181 default:
182
183 /* No other types can get here */
184
185 break;
186 }
187
188 /* Create a new integer */
189
190 ReturnDesc = AcpiUtCreateIntegerObject (Result);
191 if (!ReturnDesc)
192 {
193 return_ACPI_STATUS (AE_NO_MEMORY);
194 }
195
196 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Converted value: %8.8X%8.8X\n",
197 ACPI_FORMAT_UINT64 (Result)));
198
199 /* Save the Result */
200
201 (void) AcpiExTruncateFor32bitTable (ReturnDesc);
202 *ResultDesc = ReturnDesc;
203 return_ACPI_STATUS (AE_OK);
204 }
205
206
207 /*******************************************************************************
208 *
209 * FUNCTION: AcpiExConvertToBuffer
210 *
211 * PARAMETERS: ObjDesc - Object to be converted. Must be an
212 * Integer, Buffer, or String
213 * ResultDesc - Where the new buffer object is returned
214 *
215 * RETURN: Status
216 *
217 * DESCRIPTION: Convert an ACPI Object to a Buffer
218 *
219 ******************************************************************************/
220
221 ACPI_STATUS
224 ACPI_OPERAND_OBJECT **ResultDesc)
225 {
226 ACPI_OPERAND_OBJECT *ReturnDesc;
227 UINT8 *NewBuf;
228
229
230 ACPI_FUNCTION_TRACE_PTR (ExConvertToBuffer, ObjDesc);
231
232
233 switch (ObjDesc->Common.Type)
234 {
235 case ACPI_TYPE_BUFFER:
236
237 /* No conversion necessary */
238
239 *ResultDesc = ObjDesc;
240 return_ACPI_STATUS (AE_OK);
241
242
243 case ACPI_TYPE_INTEGER:
244 /*
245 * Create a new Buffer object.
246 * Need enough space for one integer
247 */
248 ReturnDesc = AcpiUtCreateBufferObject (AcpiGbl_IntegerByteWidth);
249 if (!ReturnDesc)
250 {
251 return_ACPI_STATUS (AE_NO_MEMORY);
252 }
253
254 /* Copy the integer to the buffer, LSB first */
255
256 NewBuf = ReturnDesc->Buffer.Pointer;
257 ACPI_MEMCPY (NewBuf,
258 &ObjDesc->Integer.Value,
259 AcpiGbl_IntegerByteWidth);
260 break;
261
262 case ACPI_TYPE_STRING:
263 /*
264 * Create a new Buffer object
265 * Size will be the string length
266 *
267 * NOTE: Add one to the string length to include the null terminator.
268 * The ACPI spec is unclear on this subject, but there is existing
269 * ASL/AML code that depends on the null being transferred to the new
270 * buffer.
271 */
272 ReturnDesc = AcpiUtCreateBufferObject (
273 (ACPI_SIZE) ObjDesc->String.Length + 1);
274 if (!ReturnDesc)
275 {
276 return_ACPI_STATUS (AE_NO_MEMORY);
277 }
278
279 /* Copy the string to the buffer */
280
281 NewBuf = ReturnDesc->Buffer.Pointer;
282 ACPI_STRNCPY ((char *) NewBuf, (char *) ObjDesc->String.Pointer,
283 ObjDesc->String.Length);
284 break;
285
286 default:
287
288 return_ACPI_STATUS (AE_TYPE);
289 }
290
291 /* Mark buffer initialized */
292
293 ReturnDesc->Common.Flags |= AOPOBJ_DATA_VALID;
294 *ResultDesc = ReturnDesc;
295 return_ACPI_STATUS (AE_OK);
296 }
297
298
299 /*******************************************************************************
300 *
301 * FUNCTION: AcpiExConvertToAscii
302 *
303 * PARAMETERS: Integer - Value to be converted
304 * Base - ACPI_STRING_DECIMAL or ACPI_STRING_HEX
305 * String - Where the string is returned
306 * DataWidth - Size of data item to be converted, in bytes
307 *
323 UINT32 j;
324 UINT32 k = 0;
325 UINT32 HexLength;
326 UINT32 DecimalLength;
327 UINT32 Remainder;
328 BOOLEAN SupressZeros;
329
330
331 ACPI_FUNCTION_ENTRY ();
332
333
334 switch (Base)
335 {
336 case 10:
337
338 /* Setup max length for the decimal number */
339
340 switch (DataWidth)
341 {
342 case 1:
343
344 DecimalLength = ACPI_MAX8_DECIMAL_DIGITS;
345 break;
346
347 case 4:
348
349 DecimalLength = ACPI_MAX32_DECIMAL_DIGITS;
350 break;
351
352 case 8:
353 default:
354
355 DecimalLength = ACPI_MAX64_DECIMAL_DIGITS;
356 break;
357 }
358
359 SupressZeros = TRUE; /* No leading zeros */
360 Remainder = 0;
361
362 for (i = DecimalLength; i > 0; i--)
363 {
364 /* Divide by nth factor of 10 */
365
366 Digit = Integer;
367 for (j = 0; j < i; j++)
368 {
369 (void) AcpiUtShortDivide (Digit, 10, &Digit, &Remainder);
370 }
371
372 /* Handle leading zeros */
373
374 if (Remainder != 0)
443 ACPI_OPERAND_OBJECT *ReturnDesc;
444 UINT8 *NewBuf;
445 UINT32 i;
446 UINT32 StringLength = 0;
447 UINT16 Base = 16;
448 UINT8 Separator = ',';
449
450
451 ACPI_FUNCTION_TRACE_PTR (ExConvertToString, ObjDesc);
452
453
454 switch (ObjDesc->Common.Type)
455 {
456 case ACPI_TYPE_STRING:
457
458 /* No conversion necessary */
459
460 *ResultDesc = ObjDesc;
461 return_ACPI_STATUS (AE_OK);
462
463 case ACPI_TYPE_INTEGER:
464
465 switch (Type)
466 {
467 case ACPI_EXPLICIT_CONVERT_DECIMAL:
468
469 /* Make room for maximum decimal number */
470
471 StringLength = ACPI_MAX_DECIMAL_DIGITS;
472 Base = 10;
473 break;
474
475 default:
476
477 /* Two hex string characters for each integer byte */
478
479 StringLength = ACPI_MUL_2 (AcpiGbl_IntegerByteWidth);
480 break;
481 }
482
486 */
487 ReturnDesc = AcpiUtCreateStringObject ((ACPI_SIZE) StringLength);
488 if (!ReturnDesc)
489 {
490 return_ACPI_STATUS (AE_NO_MEMORY);
491 }
492
493 NewBuf = ReturnDesc->Buffer.Pointer;
494
495 /* Convert integer to string */
496
497 StringLength = AcpiExConvertToAscii (ObjDesc->Integer.Value, Base,
498 NewBuf, AcpiGbl_IntegerByteWidth);
499
500 /* Null terminate at the correct place */
501
502 ReturnDesc->String.Length = StringLength;
503 NewBuf [StringLength] = 0;
504 break;
505
506 case ACPI_TYPE_BUFFER:
507
508 /* Setup string length, base, and separator */
509
510 switch (Type)
511 {
512 case ACPI_EXPLICIT_CONVERT_DECIMAL: /* Used by ToDecimalString */
513 /*
514 * From ACPI: "If Data is a buffer, it is converted to a string of
515 * decimal values separated by commas."
516 */
517 Base = 10;
518
519 /*
520 * Calculate the final string length. Individual string values
521 * are variable length (include separator for each)
522 */
523 for (i = 0; i < ObjDesc->Buffer.Length; i++)
524 {
525 if (ObjDesc->Buffer.Pointer[i] >= 100)
584 for (i = 0; i < ObjDesc->Buffer.Length; i++)
585 {
586 NewBuf += AcpiExConvertToAscii (
587 (UINT64) ObjDesc->Buffer.Pointer[i], Base,
588 NewBuf, 1);
589 *NewBuf++ = Separator; /* each separated by a comma or space */
590 }
591
592 /*
593 * Null terminate the string
594 * (overwrites final comma/space from above)
595 */
596 if (ObjDesc->Buffer.Length)
597 {
598 NewBuf--;
599 }
600 *NewBuf = 0;
601 break;
602
603 default:
604
605 return_ACPI_STATUS (AE_TYPE);
606 }
607
608 *ResultDesc = ReturnDesc;
609 return_ACPI_STATUS (AE_OK);
610 }
611
612
613 /*******************************************************************************
614 *
615 * FUNCTION: AcpiExConvertToTargetType
616 *
617 * PARAMETERS: DestinationType - Current type of the destination
618 * SourceDesc - Source object to be converted.
619 * ResultDesc - Where the converted object is returned
620 * WalkState - Current method state
621 *
622 * RETURN: Status
623 *
624 * DESCRIPTION: Implements "implicit conversion" rules for storing an object.
644
645 /*
646 * If required by the target,
647 * perform implicit conversion on the source before we store it.
648 */
649 switch (GET_CURRENT_ARG_TYPE (WalkState->OpInfo->RuntimeArgs))
650 {
651 case ARGI_SIMPLE_TARGET:
652 case ARGI_FIXED_TARGET:
653 case ARGI_INTEGER_REF: /* Handles Increment, Decrement cases */
654
655 switch (DestinationType)
656 {
657 case ACPI_TYPE_LOCAL_REGION_FIELD:
658 /*
659 * Named field can always handle conversions
660 */
661 break;
662
663 default:
664
665 /* No conversion allowed for these types */
666
667 if (DestinationType != SourceDesc->Common.Type)
668 {
669 ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
670 "Explicit operator, will store (%s) over existing type (%s)\n",
671 AcpiUtGetObjectTypeName (SourceDesc),
672 AcpiUtGetTypeName (DestinationType)));
673 Status = AE_TYPE;
674 }
675 }
676 break;
677
678 case ARGI_TARGETREF:
679
680 switch (DestinationType)
681 {
682 case ACPI_TYPE_INTEGER:
683 case ACPI_TYPE_BUFFER_FIELD:
684 case ACPI_TYPE_LOCAL_BANK_FIELD:
685 case ACPI_TYPE_LOCAL_INDEX_FIELD:
686 /*
687 * These types require an Integer operand. We can convert
688 * a Buffer or a String to an Integer if necessary.
689 */
690 Status = AcpiExConvertToInteger (SourceDesc, ResultDesc,
691 16);
692 break;
693
694 case ACPI_TYPE_STRING:
695 /*
696 * The operand must be a String. We can convert an
697 * Integer or Buffer if necessary
698 */
699 Status = AcpiExConvertToString (SourceDesc, ResultDesc,
700 ACPI_IMPLICIT_CONVERT_HEX);
701 break;
702
703 case ACPI_TYPE_BUFFER:
704 /*
705 * The operand must be a Buffer. We can convert an
706 * Integer or String if necessary
707 */
708 Status = AcpiExConvertToBuffer (SourceDesc, ResultDesc);
709 break;
710
711 default:
712
713 ACPI_ERROR ((AE_INFO, "Bad destination type during conversion: 0x%X",
714 DestinationType));
715 Status = AE_AML_INTERNAL;
716 break;
717 }
718 break;
719
720 case ARGI_REFERENCE:
721 /*
722 * CreateXxxxField cases - we are storing the field object into the name
723 */
724 break;
725
726 default:
727
728 ACPI_ERROR ((AE_INFO,
729 "Unknown Target type ID 0x%X AmlOpcode 0x%X DestType %s",
730 GET_CURRENT_ARG_TYPE (WalkState->OpInfo->RuntimeArgs),
731 WalkState->Opcode, AcpiUtGetTypeName (DestinationType)));
732 Status = AE_AML_INTERNAL;
733 }
734
735 /*
736 * Source-to-Target conversion semantics:
737 *
738 * If conversion to the target type cannot be performed, then simply
739 * overwrite the target with the new object and type.
740 */
741 if (Status == AE_TYPE)
742 {
743 Status = AE_OK;
744 }
745
746 return_ACPI_STATUS (Status);
747 }
|