Merge git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6
[wrt350n-kernel.git] / drivers / acpi / utilities / utobject.c
blob7f3564f436075ad38ed7f87ec5e4fc260fad5421
1 /******************************************************************************
3 * Module Name: utobject - ACPI object create/delete/size/cache routines
5 *****************************************************************************/
7 /*
8 * Copyright (C) 2000 - 2007, R. Byron Moore
9 * All rights reserved.
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.
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.
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.
44 #include <acpi/acpi.h>
45 #include <acpi/acnamesp.h>
46 #include <acpi/amlcode.h>
48 #define _COMPONENT ACPI_UTILITIES
49 ACPI_MODULE_NAME("utobject")
51 /* Local prototypes */
52 static acpi_status
53 acpi_ut_get_simple_object_size(union acpi_operand_object *obj,
54 acpi_size * obj_length);
56 static acpi_status
57 acpi_ut_get_package_object_size(union acpi_operand_object *obj,
58 acpi_size * obj_length);
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);
65 /*******************************************************************************
67 * FUNCTION: acpi_ut_create_internal_object_dbg
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
74 * RETURN: A new internal object, null on failure
76 * DESCRIPTION: Create and initialize a new internal object.
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!
84 ******************************************************************************/
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)
92 union acpi_operand_object *object;
93 union acpi_operand_object *second_object;
95 ACPI_FUNCTION_TRACE_STR(ut_create_internal_object_dbg,
96 acpi_ut_get_type_name(type));
98 /* Allocate the raw object descriptor */
100 object =
101 acpi_ut_allocate_object_desc_dbg(module_name, line_number,
102 component_id);
103 if (!object) {
104 return_PTR(NULL);
107 switch (type) {
108 case ACPI_TYPE_REGION:
109 case ACPI_TYPE_BUFFER_FIELD:
111 /* These types require a secondary object */
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);
121 second_object->common.type = ACPI_TYPE_LOCAL_EXTRA;
122 second_object->common.reference_count = 1;
124 /* Link the second object to the first */
126 object->common.next_object = second_object;
127 break;
129 default:
130 /* All others have no secondary object */
131 break;
134 /* Save the object type in the object descriptor */
136 object->common.type = (u8) type;
138 /* Init the reference count */
140 object->common.reference_count = 1;
142 /* Any per-type initialization should go here */
144 return_PTR(object);
147 /*******************************************************************************
149 * FUNCTION: acpi_ut_create_package_object
151 * PARAMETERS: Count - Number of package elements
153 * RETURN: Pointer to a new Package object, null on failure
155 * DESCRIPTION: Create a fully initialized package object
157 ******************************************************************************/
159 union acpi_operand_object *acpi_ut_create_package_object(u32 count)
161 union acpi_operand_object *package_desc;
162 union acpi_operand_object **package_elements;
164 ACPI_FUNCTION_TRACE_U32(ut_create_package_object, count);
166 /* Create a new Package object */
168 package_desc = acpi_ut_create_internal_object(ACPI_TYPE_PACKAGE);
169 if (!package_desc) {
170 return_PTR(NULL);
174 * Create the element array. Count+1 allows the array to be null
175 * terminated.
177 package_elements = ACPI_ALLOCATE_ZEROED((acpi_size)
178 (count + 1) * sizeof(void *));
179 if (!package_elements) {
180 acpi_ut_remove_reference(package_desc);
181 return_PTR(NULL);
184 package_desc->package.count = count;
185 package_desc->package.elements = package_elements;
186 return_PTR(package_desc);
189 /*******************************************************************************
191 * FUNCTION: acpi_ut_create_buffer_object
193 * PARAMETERS: buffer_size - Size of buffer to be created
195 * RETURN: Pointer to a new Buffer object, null on failure
197 * DESCRIPTION: Create a fully initialized buffer object
199 ******************************************************************************/
201 union acpi_operand_object *acpi_ut_create_buffer_object(acpi_size buffer_size)
203 union acpi_operand_object *buffer_desc;
204 u8 *buffer = NULL;
206 ACPI_FUNCTION_TRACE_U32(ut_create_buffer_object, buffer_size);
208 /* Create a new Buffer object */
210 buffer_desc = acpi_ut_create_internal_object(ACPI_TYPE_BUFFER);
211 if (!buffer_desc) {
212 return_PTR(NULL);
215 /* Create an actual buffer only if size > 0 */
217 if (buffer_size > 0) {
219 /* Allocate the actual buffer */
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);
230 /* Complete buffer object initialization */
232 buffer_desc->buffer.flags |= AOPOBJ_DATA_VALID;
233 buffer_desc->buffer.pointer = buffer;
234 buffer_desc->buffer.length = (u32) buffer_size;
236 /* Return the new buffer descriptor */
238 return_PTR(buffer_desc);
241 /*******************************************************************************
243 * FUNCTION: acpi_ut_create_string_object
245 * PARAMETERS: string_size - Size of string to be created. Does not
246 * include NULL terminator, this is added
247 * automatically.
249 * RETURN: Pointer to a new String object
251 * DESCRIPTION: Create a fully initialized string object
253 ******************************************************************************/
255 union acpi_operand_object *acpi_ut_create_string_object(acpi_size string_size)
257 union acpi_operand_object *string_desc;
258 char *string;
260 ACPI_FUNCTION_TRACE_U32(ut_create_string_object, string_size);
262 /* Create a new String object */
264 string_desc = acpi_ut_create_internal_object(ACPI_TYPE_STRING);
265 if (!string_desc) {
266 return_PTR(NULL);
270 * Allocate the actual string buffer -- (Size + 1) for NULL terminator.
271 * NOTE: Zero-length strings are NULL terminated
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);
281 /* Complete string object initialization */
283 string_desc->string.pointer = string;
284 string_desc->string.length = (u32) string_size;
286 /* Return the new string descriptor */
288 return_PTR(string_desc);
291 /*******************************************************************************
293 * FUNCTION: acpi_ut_valid_internal_object
295 * PARAMETERS: Object - Object to be validated
297 * RETURN: TRUE if object is valid, FALSE otherwise
299 * DESCRIPTION: Validate a pointer to be an union acpi_operand_object
301 ******************************************************************************/
303 u8 acpi_ut_valid_internal_object(void *object)
306 ACPI_FUNCTION_NAME(ut_valid_internal_object);
308 /* Check for a null pointer */
310 if (!object) {
311 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "**** Null Object Ptr\n"));
312 return (FALSE);
315 /* Check the descriptor type field */
317 switch (ACPI_GET_DESCRIPTOR_TYPE(object)) {
318 case ACPI_DESC_TYPE_OPERAND:
320 /* The object appears to be a valid union acpi_operand_object */
322 return (TRUE);
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;
331 return (FALSE);
334 /*******************************************************************************
336 * FUNCTION: acpi_ut_allocate_object_desc_dbg
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)
342 * RETURN: Pointer to newly allocated object descriptor. Null on error
344 * DESCRIPTION: Allocate a new object descriptor. Gracefully handle
345 * error conditions.
347 ******************************************************************************/
349 void *acpi_ut_allocate_object_desc_dbg(char *module_name,
350 u32 line_number, u32 component_id)
352 union acpi_operand_object *object;
354 ACPI_FUNCTION_TRACE(ut_allocate_object_desc_dbg);
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"));
361 return_PTR(NULL);
364 /* Mark the descriptor type */
366 memset(object, 0, sizeof(union acpi_operand_object));
367 ACPI_SET_DESCRIPTOR_TYPE(object, ACPI_DESC_TYPE_OPERAND);
369 ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, "%p Size %X\n",
370 object, (u32) sizeof(union acpi_operand_object)));
372 return_PTR(object);
375 /*******************************************************************************
377 * FUNCTION: acpi_ut_delete_object_desc
379 * PARAMETERS: Object - An Acpi internal object to be deleted
381 * RETURN: None.
383 * DESCRIPTION: Free an ACPI object descriptor or add it to the object cache
385 ******************************************************************************/
387 void acpi_ut_delete_object_desc(union acpi_operand_object *object)
389 ACPI_FUNCTION_TRACE_PTR(ut_delete_object_desc, object);
391 /* Object must be an union acpi_operand_object */
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;
400 (void)acpi_os_release_object(acpi_gbl_operand_cache, object);
401 return_VOID;
404 /*******************************************************************************
406 * FUNCTION: acpi_ut_get_simple_object_size
408 * PARAMETERS: internal_object - An ACPI operand object
409 * obj_length - Where the length is returned
411 * RETURN: Status
413 * DESCRIPTION: This function is called to determine the space required to
414 * contain a simple object for return to an external user.
416 * The length includes the object structure plus any additional
417 * needed space.
419 ******************************************************************************/
421 static acpi_status
422 acpi_ut_get_simple_object_size(union acpi_operand_object *internal_object,
423 acpi_size * obj_length)
425 acpi_size length;
426 acpi_status status = AE_OK;
428 ACPI_FUNCTION_TRACE_PTR(ut_get_simple_object_size, internal_object);
431 * Handle a null object (Could be a uninitialized package
432 * element -- which is legal)
434 if (!internal_object) {
435 <<<<<<< HEAD:drivers/acpi/utilities/utobject.c
436 *obj_length = 0;
437 =======
438 *obj_length = sizeof(union acpi_object);
439 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/acpi/utilities/utobject.c
440 return_ACPI_STATUS(AE_OK);
443 /* Start with the length of the Acpi object */
445 length = sizeof(union acpi_object);
447 if (ACPI_GET_DESCRIPTOR_TYPE(internal_object) == ACPI_DESC_TYPE_NAMED) {
449 /* Object is a named object (reference), just return the length */
451 *obj_length = ACPI_ROUND_UP_TO_NATIVE_WORD(length);
452 return_ACPI_STATUS(status);
456 * The final length depends on the object type
457 * Strings and Buffers are packed right up against the parent object and
458 * must be accessed bytewise or there may be alignment problems on
459 * certain processors
461 switch (ACPI_GET_OBJECT_TYPE(internal_object)) {
462 case ACPI_TYPE_STRING:
464 length += (acpi_size) internal_object->string.length + 1;
465 break;
467 case ACPI_TYPE_BUFFER:
469 length += (acpi_size) internal_object->buffer.length;
470 break;
472 case ACPI_TYPE_INTEGER:
473 case ACPI_TYPE_PROCESSOR:
474 case ACPI_TYPE_POWER:
477 * No extra data for these types
479 break;
481 case ACPI_TYPE_LOCAL_REFERENCE:
483 switch (internal_object->reference.opcode) {
484 case AML_INT_NAMEPATH_OP:
487 * Get the actual length of the full pathname to this object.
488 * The reference will be converted to the pathname to the object
490 length +=
491 ACPI_ROUND_UP_TO_NATIVE_WORD
492 (acpi_ns_get_pathname_length
493 (internal_object->reference.node));
494 break;
496 default:
499 * No other reference opcodes are supported.
500 * Notably, Locals and Args are not supported, but this may be
501 * required eventually.
503 ACPI_ERROR((AE_INFO,
504 "Unsupported Reference opcode=%X in object %p",
505 internal_object->reference.opcode,
506 internal_object));
507 status = AE_TYPE;
508 break;
510 break;
512 default:
514 ACPI_ERROR((AE_INFO, "Unsupported type=%X in object %p",
515 ACPI_GET_OBJECT_TYPE(internal_object),
516 internal_object));
517 status = AE_TYPE;
518 break;
522 * Account for the space required by the object rounded up to the next
523 * multiple of the machine word size. This keeps each object aligned
524 * on a machine word boundary. (preventing alignment faults on some
525 * machines.)
527 *obj_length = ACPI_ROUND_UP_TO_NATIVE_WORD(length);
528 return_ACPI_STATUS(status);
531 /*******************************************************************************
533 * FUNCTION: acpi_ut_get_element_length
535 * PARAMETERS: acpi_pkg_callback
537 * RETURN: Status
539 * DESCRIPTION: Get the length of one package element.
541 ******************************************************************************/
543 static acpi_status
544 acpi_ut_get_element_length(u8 object_type,
545 union acpi_operand_object *source_object,
546 union acpi_generic_state *state, void *context)
548 acpi_status status = AE_OK;
549 struct acpi_pkg_info *info = (struct acpi_pkg_info *)context;
550 acpi_size object_space;
552 switch (object_type) {
553 case ACPI_COPY_TYPE_SIMPLE:
556 * Simple object - just get the size (Null object/entry is handled
557 * here also) and sum it into the running package length
559 status =
560 acpi_ut_get_simple_object_size(source_object,
561 &object_space);
562 if (ACPI_FAILURE(status)) {
563 return (status);
566 info->length += object_space;
567 break;
569 case ACPI_COPY_TYPE_PACKAGE:
571 /* Package object - nothing much to do here, let the walk handle it */
573 info->num_packages++;
574 state->pkg.this_target_obj = NULL;
575 break;
577 default:
579 /* No other types allowed */
581 return (AE_BAD_PARAMETER);
584 return (status);
587 /*******************************************************************************
589 * FUNCTION: acpi_ut_get_package_object_size
591 * PARAMETERS: internal_object - An ACPI internal object
592 * obj_length - Where the length is returned
594 * RETURN: Status
596 * DESCRIPTION: This function is called to determine the space required to
597 * contain a package object for return to an external user.
599 * This is moderately complex since a package contains other
600 * objects including packages.
602 ******************************************************************************/
604 static acpi_status
605 acpi_ut_get_package_object_size(union acpi_operand_object *internal_object,
606 acpi_size * obj_length)
608 acpi_status status;
609 struct acpi_pkg_info info;
611 ACPI_FUNCTION_TRACE_PTR(ut_get_package_object_size, internal_object);
613 info.length = 0;
614 info.object_space = 0;
615 info.num_packages = 1;
617 status = acpi_ut_walk_package_tree(internal_object, NULL,
618 acpi_ut_get_element_length, &info);
619 if (ACPI_FAILURE(status)) {
620 return_ACPI_STATUS(status);
624 * We have handled all of the objects in all levels of the package.
625 * just add the length of the package objects themselves.
626 * Round up to the next machine word.
628 info.length += ACPI_ROUND_UP_TO_NATIVE_WORD(sizeof(union acpi_object)) *
629 (acpi_size) info.num_packages;
631 /* Return the total package length */
633 *obj_length = info.length;
634 return_ACPI_STATUS(status);
637 /*******************************************************************************
639 * FUNCTION: acpi_ut_get_object_size
641 * PARAMETERS: internal_object - An ACPI internal object
642 * obj_length - Where the length will be returned
644 * RETURN: Status
646 * DESCRIPTION: This function is called to determine the space required to
647 * contain an object for return to an API user.
649 ******************************************************************************/
651 acpi_status
652 acpi_ut_get_object_size(union acpi_operand_object *internal_object,
653 acpi_size * obj_length)
655 acpi_status status;
657 ACPI_FUNCTION_ENTRY();
659 if ((ACPI_GET_DESCRIPTOR_TYPE(internal_object) ==
660 ACPI_DESC_TYPE_OPERAND)
661 && (ACPI_GET_OBJECT_TYPE(internal_object) == ACPI_TYPE_PACKAGE)) {
662 status =
663 acpi_ut_get_package_object_size(internal_object,
664 obj_length);
665 } else {
666 status =
667 acpi_ut_get_simple_object_size(internal_object, obj_length);
670 return (status);