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