Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/drzeus/mmc
[linux-2.6] / drivers / acpi / utilities / utobject.c
1 /******************************************************************************
2  *
3  * Module Name: utobject - ACPI object create/delete/size/cache 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 <acpi/acnamesp.h>
46 #include <acpi/amlcode.h>
47
48 #define _COMPONENT          ACPI_UTILITIES
49 ACPI_MODULE_NAME("utobject")
50
51 /* Local prototypes */
52 static acpi_status
53 acpi_ut_get_simple_object_size(union acpi_operand_object *obj,
54                                acpi_size * obj_length);
55
56 static acpi_status
57 acpi_ut_get_package_object_size(union acpi_operand_object *obj,
58                                 acpi_size * obj_length);
59
60 static acpi_status
61 acpi_ut_get_element_length(u8 object_type,
62                            union acpi_operand_object *source_object,
63                            union acpi_generic_state *state, void *context);
64
65 /*******************************************************************************
66  *
67  * FUNCTION:    acpi_ut_create_internal_object_dbg
68  *
69  * PARAMETERS:  module_name         - Source file name of caller
70  *              line_number         - Line number of caller
71  *              component_id        - Component type of caller
72  *              Type                - ACPI Type of the new object
73  *
74  * RETURN:      A new internal object, null on failure
75  *
76  * DESCRIPTION: Create and initialize a new internal object.
77  *
78  * NOTE:        We always allocate the worst-case object descriptor because
79  *              these objects are cached, and we want them to be
80  *              one-size-satisifies-any-request.  This in itself may not be
81  *              the most memory efficient, but the efficiency of the object
82  *              cache should more than make up for this!
83  *
84  ******************************************************************************/
85
86 union acpi_operand_object *acpi_ut_create_internal_object_dbg(const char
87                                                               *module_name,
88                                                               u32 line_number,
89                                                               u32 component_id,
90                                                               acpi_object_type
91                                                               type)
92 {
93         union acpi_operand_object *object;
94         union acpi_operand_object *second_object;
95
96         ACPI_FUNCTION_TRACE_STR(ut_create_internal_object_dbg,
97                                 acpi_ut_get_type_name(type));
98
99         /* Allocate the raw object descriptor */
100
101         object =
102             acpi_ut_allocate_object_desc_dbg(module_name, line_number,
103                                              component_id);
104         if (!object) {
105                 return_PTR(NULL);
106         }
107
108         switch (type) {
109         case ACPI_TYPE_REGION:
110         case ACPI_TYPE_BUFFER_FIELD:
111         case ACPI_TYPE_LOCAL_BANK_FIELD:
112
113                 /* These types require a secondary object */
114
115                 second_object = acpi_ut_allocate_object_desc_dbg(module_name,
116                                                                  line_number,
117                                                                  component_id);
118                 if (!second_object) {
119                         acpi_ut_delete_object_desc(object);
120                         return_PTR(NULL);
121                 }
122
123                 second_object->common.type = ACPI_TYPE_LOCAL_EXTRA;
124                 second_object->common.reference_count = 1;
125
126                 /* Link the second object to the first */
127
128                 object->common.next_object = second_object;
129                 break;
130
131         default:
132                 /* All others have no secondary object */
133                 break;
134         }
135
136         /* Save the object type in the object descriptor */
137
138         object->common.type = (u8) type;
139
140         /* Init the reference count */
141
142         object->common.reference_count = 1;
143
144         /* Any per-type initialization should go here */
145
146         return_PTR(object);
147 }
148
149 /*******************************************************************************
150  *
151  * FUNCTION:    acpi_ut_create_package_object
152  *
153  * PARAMETERS:  Count               - Number of package elements
154  *
155  * RETURN:      Pointer to a new Package object, null on failure
156  *
157  * DESCRIPTION: Create a fully initialized package object
158  *
159  ******************************************************************************/
160
161 union acpi_operand_object *acpi_ut_create_package_object(u32 count)
162 {
163         union acpi_operand_object *package_desc;
164         union acpi_operand_object **package_elements;
165
166         ACPI_FUNCTION_TRACE_U32(ut_create_package_object, count);
167
168         /* Create a new Package object */
169
170         package_desc = acpi_ut_create_internal_object(ACPI_TYPE_PACKAGE);
171         if (!package_desc) {
172                 return_PTR(NULL);
173         }
174
175         /*
176          * Create the element array. Count+1 allows the array to be null
177          * terminated.
178          */
179         package_elements = ACPI_ALLOCATE_ZEROED(((acpi_size) count +
180                                                  1) * sizeof(void *));
181         if (!package_elements) {
182                 acpi_ut_remove_reference(package_desc);
183                 return_PTR(NULL);
184         }
185
186         package_desc->package.count = count;
187         package_desc->package.elements = package_elements;
188         return_PTR(package_desc);
189 }
190
191 /*******************************************************************************
192  *
193  * FUNCTION:    acpi_ut_create_buffer_object
194  *
195  * PARAMETERS:  buffer_size            - Size of buffer to be created
196  *
197  * RETURN:      Pointer to a new Buffer object, null on failure
198  *
199  * DESCRIPTION: Create a fully initialized buffer object
200  *
201  ******************************************************************************/
202
203 union acpi_operand_object *acpi_ut_create_buffer_object(acpi_size buffer_size)
204 {
205         union acpi_operand_object *buffer_desc;
206         u8 *buffer = NULL;
207
208         ACPI_FUNCTION_TRACE_U32(ut_create_buffer_object, buffer_size);
209
210         /* Create a new Buffer object */
211
212         buffer_desc = acpi_ut_create_internal_object(ACPI_TYPE_BUFFER);
213         if (!buffer_desc) {
214                 return_PTR(NULL);
215         }
216
217         /* Create an actual buffer only if size > 0 */
218
219         if (buffer_size > 0) {
220
221                 /* Allocate the actual buffer */
222
223                 buffer = ACPI_ALLOCATE_ZEROED(buffer_size);
224                 if (!buffer) {
225                         ACPI_ERROR((AE_INFO, "Could not allocate size %X",
226                                     (u32) buffer_size));
227                         acpi_ut_remove_reference(buffer_desc);
228                         return_PTR(NULL);
229                 }
230         }
231
232         /* Complete buffer object initialization */
233
234         buffer_desc->buffer.flags |= AOPOBJ_DATA_VALID;
235         buffer_desc->buffer.pointer = buffer;
236         buffer_desc->buffer.length = (u32) buffer_size;
237
238         /* Return the new buffer descriptor */
239
240         return_PTR(buffer_desc);
241 }
242
243 /*******************************************************************************
244  *
245  * FUNCTION:    acpi_ut_create_string_object
246  *
247  * PARAMETERS:  string_size         - Size of string to be created. Does not
248  *                                    include NULL terminator, this is added
249  *                                    automatically.
250  *
251  * RETURN:      Pointer to a new String object
252  *
253  * DESCRIPTION: Create a fully initialized string object
254  *
255  ******************************************************************************/
256
257 union acpi_operand_object *acpi_ut_create_string_object(acpi_size string_size)
258 {
259         union acpi_operand_object *string_desc;
260         char *string;
261
262         ACPI_FUNCTION_TRACE_U32(ut_create_string_object, string_size);
263
264         /* Create a new String object */
265
266         string_desc = acpi_ut_create_internal_object(ACPI_TYPE_STRING);
267         if (!string_desc) {
268                 return_PTR(NULL);
269         }
270
271         /*
272          * Allocate the actual string buffer -- (Size + 1) for NULL terminator.
273          * NOTE: Zero-length strings are NULL terminated
274          */
275         string = ACPI_ALLOCATE_ZEROED(string_size + 1);
276         if (!string) {
277                 ACPI_ERROR((AE_INFO, "Could not allocate size %X",
278                             (u32) string_size));
279                 acpi_ut_remove_reference(string_desc);
280                 return_PTR(NULL);
281         }
282
283         /* Complete string object initialization */
284
285         string_desc->string.pointer = string;
286         string_desc->string.length = (u32) string_size;
287
288         /* Return the new string descriptor */
289
290         return_PTR(string_desc);
291 }
292
293 /*******************************************************************************
294  *
295  * FUNCTION:    acpi_ut_valid_internal_object
296  *
297  * PARAMETERS:  Object              - Object to be validated
298  *
299  * RETURN:      TRUE if object is valid, FALSE otherwise
300  *
301  * DESCRIPTION: Validate a pointer to be an union acpi_operand_object
302  *
303  ******************************************************************************/
304
305 u8 acpi_ut_valid_internal_object(void *object)
306 {
307
308         ACPI_FUNCTION_NAME(ut_valid_internal_object);
309
310         /* Check for a null pointer */
311
312         if (!object) {
313                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "**** Null Object Ptr\n"));
314                 return (FALSE);
315         }
316
317         /* Check the descriptor type field */
318
319         switch (ACPI_GET_DESCRIPTOR_TYPE(object)) {
320         case ACPI_DESC_TYPE_OPERAND:
321
322                 /* The object appears to be a valid union acpi_operand_object    */
323
324                 return (TRUE);
325
326         default:
327                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
328                                   "%p is not not an ACPI operand obj [%s]\n",
329                                   object, acpi_ut_get_descriptor_name(object)));
330                 break;
331         }
332
333         return (FALSE);
334 }
335
336 /*******************************************************************************
337  *
338  * FUNCTION:    acpi_ut_allocate_object_desc_dbg
339  *
340  * PARAMETERS:  module_name         - Caller's module name (for error output)
341  *              line_number         - Caller's line number (for error output)
342  *              component_id        - Caller's component ID (for error output)
343  *
344  * RETURN:      Pointer to newly allocated object descriptor.  Null on error
345  *
346  * DESCRIPTION: Allocate a new object descriptor.  Gracefully handle
347  *              error conditions.
348  *
349  ******************************************************************************/
350
351 void *acpi_ut_allocate_object_desc_dbg(const char *module_name,
352                                        u32 line_number, u32 component_id)
353 {
354         union acpi_operand_object *object;
355
356         ACPI_FUNCTION_TRACE(ut_allocate_object_desc_dbg);
357
358         object = acpi_os_acquire_object(acpi_gbl_operand_cache);
359         if (!object) {
360                 ACPI_ERROR((module_name, line_number,
361                             "Could not allocate an object descriptor"));
362
363                 return_PTR(NULL);
364         }
365
366         /* Mark the descriptor type */
367
368         memset(object, 0, sizeof(union acpi_operand_object));
369         ACPI_SET_DESCRIPTOR_TYPE(object, ACPI_DESC_TYPE_OPERAND);
370
371         ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, "%p Size %X\n",
372                           object, (u32) sizeof(union acpi_operand_object)));
373
374         return_PTR(object);
375 }
376
377 /*******************************************************************************
378  *
379  * FUNCTION:    acpi_ut_delete_object_desc
380  *
381  * PARAMETERS:  Object          - An Acpi internal object to be deleted
382  *
383  * RETURN:      None.
384  *
385  * DESCRIPTION: Free an ACPI object descriptor or add it to the object cache
386  *
387  ******************************************************************************/
388
389 void acpi_ut_delete_object_desc(union acpi_operand_object *object)
390 {
391         ACPI_FUNCTION_TRACE_PTR(ut_delete_object_desc, object);
392
393         /* Object must be an union acpi_operand_object    */
394
395         if (ACPI_GET_DESCRIPTOR_TYPE(object) != ACPI_DESC_TYPE_OPERAND) {
396                 ACPI_ERROR((AE_INFO,
397                             "%p is not an ACPI Operand object [%s]", object,
398                             acpi_ut_get_descriptor_name(object)));
399                 return_VOID;
400         }
401
402         (void)acpi_os_release_object(acpi_gbl_operand_cache, object);
403         return_VOID;
404 }
405
406 /*******************************************************************************
407  *
408  * FUNCTION:    acpi_ut_get_simple_object_size
409  *
410  * PARAMETERS:  internal_object    - An ACPI operand object
411  *              obj_length         - Where the length is returned
412  *
413  * RETURN:      Status
414  *
415  * DESCRIPTION: This function is called to determine the space required to
416  *              contain a simple object for return to an external user.
417  *
418  *              The length includes the object structure plus any additional
419  *              needed space.
420  *
421  ******************************************************************************/
422
423 static acpi_status
424 acpi_ut_get_simple_object_size(union acpi_operand_object *internal_object,
425                                acpi_size * obj_length)
426 {
427         acpi_size length;
428         acpi_status status = AE_OK;
429
430         ACPI_FUNCTION_TRACE_PTR(ut_get_simple_object_size, internal_object);
431
432         /*
433          * Handle a null object (Could be a uninitialized package
434          * element -- which is legal)
435          */
436         if (!internal_object) {
437                 *obj_length = sizeof(union acpi_object);
438                 return_ACPI_STATUS(AE_OK);
439         }
440
441         /* Start with the length of the Acpi object */
442
443         length = sizeof(union acpi_object);
444
445         if (ACPI_GET_DESCRIPTOR_TYPE(internal_object) == ACPI_DESC_TYPE_NAMED) {
446
447                 /* Object is a named object (reference), just return the length */
448
449                 *obj_length = ACPI_ROUND_UP_TO_NATIVE_WORD(length);
450                 return_ACPI_STATUS(status);
451         }
452
453         /*
454          * The final length depends on the object type
455          * Strings and Buffers are packed right up against the parent object and
456          * must be accessed bytewise or there may be alignment problems on
457          * certain processors
458          */
459         switch (ACPI_GET_OBJECT_TYPE(internal_object)) {
460         case ACPI_TYPE_STRING:
461
462                 length += (acpi_size) internal_object->string.length + 1;
463                 break;
464
465         case ACPI_TYPE_BUFFER:
466
467                 length += (acpi_size) internal_object->buffer.length;
468                 break;
469
470         case ACPI_TYPE_INTEGER:
471         case ACPI_TYPE_PROCESSOR:
472         case ACPI_TYPE_POWER:
473
474                 /* No extra data for these types */
475
476                 break;
477
478         case ACPI_TYPE_LOCAL_REFERENCE:
479
480                 switch (internal_object->reference.opcode) {
481                 case AML_INT_NAMEPATH_OP:
482
483                         /*
484                          * Get the actual length of the full pathname to this object.
485                          * The reference will be converted to the pathname to the object
486                          */
487                         length +=
488                             ACPI_ROUND_UP_TO_NATIVE_WORD
489                             (acpi_ns_get_pathname_length
490                              (internal_object->reference.node));
491                         break;
492
493                 default:
494
495                         /*
496                          * No other reference opcodes are supported.
497                          * Notably, Locals and Args are not supported, but this may be
498                          * required eventually.
499                          */
500                         ACPI_ERROR((AE_INFO,
501                                     "Unsupported Reference opcode=%X in object %p",
502                                     internal_object->reference.opcode,
503                                     internal_object));
504                         status = AE_TYPE;
505                         break;
506                 }
507                 break;
508
509         default:
510
511                 ACPI_ERROR((AE_INFO, "Unsupported type=%X in object %p",
512                             ACPI_GET_OBJECT_TYPE(internal_object),
513                             internal_object));
514                 status = AE_TYPE;
515                 break;
516         }
517
518         /*
519          * Account for the space required by the object rounded up to the next
520          * multiple of the machine word size.  This keeps each object aligned
521          * on a machine word boundary. (preventing alignment faults on some
522          * machines.)
523          */
524         *obj_length = ACPI_ROUND_UP_TO_NATIVE_WORD(length);
525         return_ACPI_STATUS(status);
526 }
527
528 /*******************************************************************************
529  *
530  * FUNCTION:    acpi_ut_get_element_length
531  *
532  * PARAMETERS:  acpi_pkg_callback
533  *
534  * RETURN:      Status
535  *
536  * DESCRIPTION: Get the length of one package element.
537  *
538  ******************************************************************************/
539
540 static acpi_status
541 acpi_ut_get_element_length(u8 object_type,
542                            union acpi_operand_object *source_object,
543                            union acpi_generic_state *state, void *context)
544 {
545         acpi_status status = AE_OK;
546         struct acpi_pkg_info *info = (struct acpi_pkg_info *)context;
547         acpi_size object_space;
548
549         switch (object_type) {
550         case ACPI_COPY_TYPE_SIMPLE:
551
552                 /*
553                  * Simple object - just get the size (Null object/entry is handled
554                  * here also) and sum it into the running package length
555                  */
556                 status =
557                     acpi_ut_get_simple_object_size(source_object,
558                                                    &object_space);
559                 if (ACPI_FAILURE(status)) {
560                         return (status);
561                 }
562
563                 info->length += object_space;
564                 break;
565
566         case ACPI_COPY_TYPE_PACKAGE:
567
568                 /* Package object - nothing much to do here, let the walk handle it */
569
570                 info->num_packages++;
571                 state->pkg.this_target_obj = NULL;
572                 break;
573
574         default:
575
576                 /* No other types allowed */
577
578                 return (AE_BAD_PARAMETER);
579         }
580
581         return (status);
582 }
583
584 /*******************************************************************************
585  *
586  * FUNCTION:    acpi_ut_get_package_object_size
587  *
588  * PARAMETERS:  internal_object     - An ACPI internal object
589  *              obj_length          - Where the length is returned
590  *
591  * RETURN:      Status
592  *
593  * DESCRIPTION: This function is called to determine the space required to
594  *              contain a package object for return to an external user.
595  *
596  *              This is moderately complex since a package contains other
597  *              objects including packages.
598  *
599  ******************************************************************************/
600
601 static acpi_status
602 acpi_ut_get_package_object_size(union acpi_operand_object *internal_object,
603                                 acpi_size * obj_length)
604 {
605         acpi_status status;
606         struct acpi_pkg_info info;
607
608         ACPI_FUNCTION_TRACE_PTR(ut_get_package_object_size, internal_object);
609
610         info.length = 0;
611         info.object_space = 0;
612         info.num_packages = 1;
613
614         status = acpi_ut_walk_package_tree(internal_object, NULL,
615                                            acpi_ut_get_element_length, &info);
616         if (ACPI_FAILURE(status)) {
617                 return_ACPI_STATUS(status);
618         }
619
620         /*
621          * We have handled all of the objects in all levels of the package.
622          * just add the length of the package objects themselves.
623          * Round up to the next machine word.
624          */
625         info.length += ACPI_ROUND_UP_TO_NATIVE_WORD(sizeof(union acpi_object)) *
626             (acpi_size) info.num_packages;
627
628         /* Return the total package length */
629
630         *obj_length = info.length;
631         return_ACPI_STATUS(status);
632 }
633
634 /*******************************************************************************
635  *
636  * FUNCTION:    acpi_ut_get_object_size
637  *
638  * PARAMETERS:  internal_object     - An ACPI internal object
639  *              obj_length          - Where the length will be returned
640  *
641  * RETURN:      Status
642  *
643  * DESCRIPTION: This function is called to determine the space required to
644  *              contain an object for return to an API user.
645  *
646  ******************************************************************************/
647
648 acpi_status
649 acpi_ut_get_object_size(union acpi_operand_object *internal_object,
650                         acpi_size * obj_length)
651 {
652         acpi_status status;
653
654         ACPI_FUNCTION_ENTRY();
655
656         if ((ACPI_GET_DESCRIPTOR_TYPE(internal_object) ==
657              ACPI_DESC_TYPE_OPERAND)
658             && (ACPI_GET_OBJECT_TYPE(internal_object) == ACPI_TYPE_PACKAGE)) {
659                 status =
660                     acpi_ut_get_package_object_size(internal_object,
661                                                     obj_length);
662         } else {
663                 status =
664                     acpi_ut_get_simple_object_size(internal_object, obj_length);
665         }
666
667         return (status);
668 }