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