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