Merge branch 'linus' into release
[linux-2.6.git] / drivers / acpi / acpica / 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 "accommon.h"
46 #include "acnamesp.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 a 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 a 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_size size;
429         acpi_status status = AE_OK;
430
431         ACPI_FUNCTION_TRACE_PTR(ut_get_simple_object_size, internal_object);
432
433         /*
434          * Handle a null object (Could be a uninitialized package
435          * element -- which is legal)
436          */
437         if (!internal_object) {
438                 *obj_length = sizeof(union acpi_object);
439                 return_ACPI_STATUS(AE_OK);
440         }
441
442         /* Start with the length of the Acpi object */
443
444         length = sizeof(union acpi_object);
445
446         if (ACPI_GET_DESCRIPTOR_TYPE(internal_object) == ACPI_DESC_TYPE_NAMED) {
447
448                 /* Object is a named object (reference), just return the length */
449
450                 *obj_length = ACPI_ROUND_UP_TO_NATIVE_WORD(length);
451                 return_ACPI_STATUS(status);
452         }
453
454         /*
455          * The final length depends on the object type
456          * Strings and Buffers are packed right up against the parent object and
457          * must be accessed bytewise or there may be alignment problems on
458          * certain processors
459          */
460         switch (ACPI_GET_OBJECT_TYPE(internal_object)) {
461         case ACPI_TYPE_STRING:
462
463                 length += (acpi_size) internal_object->string.length + 1;
464                 break;
465
466         case ACPI_TYPE_BUFFER:
467
468                 length += (acpi_size) internal_object->buffer.length;
469                 break;
470
471         case ACPI_TYPE_INTEGER:
472         case ACPI_TYPE_PROCESSOR:
473         case ACPI_TYPE_POWER:
474
475                 /* No extra data for these types */
476
477                 break;
478
479         case ACPI_TYPE_LOCAL_REFERENCE:
480
481                 switch (internal_object->reference.class) {
482                 case ACPI_REFCLASS_NAME:
483
484                         /*
485                          * Get the actual length of the full pathname to this object.
486                          * The reference will be converted to the pathname to the object
487                          */
488                         size =
489                             acpi_ns_get_pathname_length(internal_object->
490                                                         reference.node);
491                         if (!size) {
492                                 return_ACPI_STATUS(AE_BAD_PARAMETER);
493                         }
494
495                         length += ACPI_ROUND_UP_TO_NATIVE_WORD(size);
496                         break;
497
498                 default:
499
500                         /*
501                          * No other reference opcodes are supported.
502                          * Notably, Locals and Args are not supported, but this may be
503                          * required eventually.
504                          */
505                         ACPI_ERROR((AE_INFO,
506                                     "Cannot convert to external object - "
507                                     "unsupported Reference Class [%s] %X in object %p",
508                                     acpi_ut_get_reference_name(internal_object),
509                                     internal_object->reference.class,
510                                     internal_object));
511                         status = AE_TYPE;
512                         break;
513                 }
514                 break;
515
516         default:
517
518                 ACPI_ERROR((AE_INFO, "Cannot convert to external object - "
519                             "unsupported type [%s] %X in object %p",
520                             acpi_ut_get_object_type_name(internal_object),
521                             ACPI_GET_OBJECT_TYPE(internal_object),
522                             internal_object));
523                 status = AE_TYPE;
524                 break;
525         }
526
527         /*
528          * Account for the space required by the object rounded up to the next
529          * multiple of the machine word size.  This keeps each object aligned
530          * on a machine word boundary. (preventing alignment faults on some
531          * machines.)
532          */
533         *obj_length = ACPI_ROUND_UP_TO_NATIVE_WORD(length);
534         return_ACPI_STATUS(status);
535 }
536
537 /*******************************************************************************
538  *
539  * FUNCTION:    acpi_ut_get_element_length
540  *
541  * PARAMETERS:  acpi_pkg_callback
542  *
543  * RETURN:      Status
544  *
545  * DESCRIPTION: Get the length of one package element.
546  *
547  ******************************************************************************/
548
549 static acpi_status
550 acpi_ut_get_element_length(u8 object_type,
551                            union acpi_operand_object *source_object,
552                            union acpi_generic_state *state, void *context)
553 {
554         acpi_status status = AE_OK;
555         struct acpi_pkg_info *info = (struct acpi_pkg_info *)context;
556         acpi_size object_space;
557
558         switch (object_type) {
559         case ACPI_COPY_TYPE_SIMPLE:
560
561                 /*
562                  * Simple object - just get the size (Null object/entry is handled
563                  * here also) and sum it into the running package length
564                  */
565                 status =
566                     acpi_ut_get_simple_object_size(source_object,
567                                                    &object_space);
568                 if (ACPI_FAILURE(status)) {
569                         return (status);
570                 }
571
572                 info->length += object_space;
573                 break;
574
575         case ACPI_COPY_TYPE_PACKAGE:
576
577                 /* Package object - nothing much to do here, let the walk handle it */
578
579                 info->num_packages++;
580                 state->pkg.this_target_obj = NULL;
581                 break;
582
583         default:
584
585                 /* No other types allowed */
586
587                 return (AE_BAD_PARAMETER);
588         }
589
590         return (status);
591 }
592
593 /*******************************************************************************
594  *
595  * FUNCTION:    acpi_ut_get_package_object_size
596  *
597  * PARAMETERS:  internal_object     - An ACPI internal object
598  *              obj_length          - Where the length is returned
599  *
600  * RETURN:      Status
601  *
602  * DESCRIPTION: This function is called to determine the space required to
603  *              contain a package object for return to an external user.
604  *
605  *              This is moderately complex since a package contains other
606  *              objects including packages.
607  *
608  ******************************************************************************/
609
610 static acpi_status
611 acpi_ut_get_package_object_size(union acpi_operand_object *internal_object,
612                                 acpi_size * obj_length)
613 {
614         acpi_status status;
615         struct acpi_pkg_info info;
616
617         ACPI_FUNCTION_TRACE_PTR(ut_get_package_object_size, internal_object);
618
619         info.length = 0;
620         info.object_space = 0;
621         info.num_packages = 1;
622
623         status = acpi_ut_walk_package_tree(internal_object, NULL,
624                                            acpi_ut_get_element_length, &info);
625         if (ACPI_FAILURE(status)) {
626                 return_ACPI_STATUS(status);
627         }
628
629         /*
630          * We have handled all of the objects in all levels of the package.
631          * just add the length of the package objects themselves.
632          * Round up to the next machine word.
633          */
634         info.length += ACPI_ROUND_UP_TO_NATIVE_WORD(sizeof(union acpi_object)) *
635             (acpi_size) info.num_packages;
636
637         /* Return the total package length */
638
639         *obj_length = info.length;
640         return_ACPI_STATUS(status);
641 }
642
643 /*******************************************************************************
644  *
645  * FUNCTION:    acpi_ut_get_object_size
646  *
647  * PARAMETERS:  internal_object     - An ACPI internal object
648  *              obj_length          - Where the length will be returned
649  *
650  * RETURN:      Status
651  *
652  * DESCRIPTION: This function is called to determine the space required to
653  *              contain an object for return to an API user.
654  *
655  ******************************************************************************/
656
657 acpi_status
658 acpi_ut_get_object_size(union acpi_operand_object *internal_object,
659                         acpi_size * obj_length)
660 {
661         acpi_status status;
662
663         ACPI_FUNCTION_ENTRY();
664
665         if ((ACPI_GET_DESCRIPTOR_TYPE(internal_object) ==
666              ACPI_DESC_TYPE_OPERAND)
667             && (ACPI_GET_OBJECT_TYPE(internal_object) == ACPI_TYPE_PACKAGE)) {
668                 status =
669                     acpi_ut_get_package_object_size(internal_object,
670                                                     obj_length);
671         } else {
672                 status =
673                     acpi_ut_get_simple_object_size(internal_object, obj_length);
674         }
675
676         return (status);
677 }