ACPI: ACPICA 20060310
Bob Moore [Tue, 3 Oct 2006 04:00:00 +0000 (00:00 -0400)]
Tagged all external interfaces to the subsystem with the
new ACPI_EXPORT_SYMBOL macro. This macro can be defined
as necessary to assist kernel integration. For Linux,
the macro resolves to the EXPORT_SYMBOL macro. The default
definition is NULL.

Added the ACPI_THREAD_ID type for the return value from
acpi_os_get_thread_id(). This allows the host to define this
as necessary to simplify kernel integration. The default
definition is ACPI_NATIVE_UINT.

Valery Podrezov fixed two interpreter problems related
to error processing, the deletion of objects, and placing
invalid pointers onto the internal operator result stack.
http://bugzilla.kernel.org/show_bug.cgi?id=6028
http://bugzilla.kernel.org/show_bug.cgi?id=6151

Increased the reference count threshold where a warning is
emitted for large reference counts in order to eliminate
unnecessary warnings on systems with large namespaces
(especially 64-bit.) Increased the value from 0x400
to 0x800.

Due to universal disagreement as to the meaning of the
'c' in the calloc() function, the ACPI_MEM_CALLOCATE
macro has been renamed to ACPI_ALLOCATE_ZEROED so that the
purpose of the interface is 'clear'. ACPI_MEM_ALLOCATE and
ACPI_MEM_FREE are renamed to ACPI_ALLOCATE and ACPI_FREE.

Signed-off-by: Bob Moore <robert.moore@intel.com>
Signed-off-by: Len Brown <len.brown@intel.com>

65 files changed:
drivers/acpi/dispatcher/dsmthdat.c
drivers/acpi/dispatcher/dsobject.c
drivers/acpi/dispatcher/dsutils.c
drivers/acpi/dispatcher/dswload.c
drivers/acpi/dispatcher/dswstate.c
drivers/acpi/events/evgpeblk.c
drivers/acpi/events/evregion.c
drivers/acpi/events/evrgnini.c
drivers/acpi/events/evxface.c
drivers/acpi/events/evxfevnt.c
drivers/acpi/events/evxfregn.c
drivers/acpi/executer/exconfig.c
drivers/acpi/executer/exdump.c
drivers/acpi/executer/exfield.c
drivers/acpi/executer/exnames.c
drivers/acpi/executer/exoparg1.c
drivers/acpi/executer/exoparg2.c
drivers/acpi/executer/exoparg3.c
drivers/acpi/executer/exregion.c
drivers/acpi/executer/exstorob.c
drivers/acpi/hardware/hwregs.c
drivers/acpi/hardware/hwsleep.c
drivers/acpi/hardware/hwtimer.c
drivers/acpi/namespace/nsaccess.c
drivers/acpi/namespace/nsalloc.c
drivers/acpi/namespace/nsdumpdv.c
drivers/acpi/namespace/nseval.c
drivers/acpi/namespace/nsinit.c
drivers/acpi/namespace/nsnames.c
drivers/acpi/namespace/nsparse.c
drivers/acpi/namespace/nssearch.c
drivers/acpi/namespace/nsutils.c
drivers/acpi/namespace/nsxfeval.c
drivers/acpi/namespace/nsxfname.c
drivers/acpi/namespace/nsxfobj.c
drivers/acpi/parser/pstree.c
drivers/acpi/resources/rsinfo.c
drivers/acpi/resources/rsxface.c
drivers/acpi/tables/tbconvrt.c
drivers/acpi/tables/tbget.c
drivers/acpi/tables/tbinstal.c
drivers/acpi/tables/tbxface.c
drivers/acpi/tables/tbxfroot.c
drivers/acpi/utilities/utalloc.c
drivers/acpi/utilities/utcache.c
drivers/acpi/utilities/utcopy.c
drivers/acpi/utilities/utdebug.c
drivers/acpi/utilities/utdelete.c
drivers/acpi/utilities/uteval.c
drivers/acpi/utilities/utglobal.c
drivers/acpi/utilities/utinit.c
drivers/acpi/utilities/utmisc.c
drivers/acpi/utilities/utmutex.c
drivers/acpi/utilities/utobject.c
drivers/acpi/utilities/utxface.c
include/acpi/acconfig.h
include/acpi/acdisasm.h
include/acpi/aclocal.h
include/acpi/acmacros.h
include/acpi/acnamesp.h
include/acpi/acpiosxf.h
include/acpi/actypes.h
include/acpi/amlresrc.h
include/acpi/platform/acenv.h
include/acpi/platform/aclinux.h

index f7cb517..2ed4843 100644 (file)
@@ -81,7 +81,7 @@ acpi_ds_method_data_get_type(u16 opcode,
  *              special data types.
  *
  * NOTES:       walk_state fields are initialized to zero by the
- *              ACPI_MEM_CALLOCATE().
+ *              ACPI_ALLOCATE_ZEROED().
  *
  *              A pseudo-Namespace Node is assigned to each argument and local
  *              so that ref_of() can return a pointer to the Node.
index 1f2d0c6..ce54715 100644 (file)
@@ -245,7 +245,7 @@ acpi_ds_build_internal_buffer_obj(struct acpi_walk_state *walk_state,
                                  "Buffer defined with zero length in AML, creating\n"));
        } else {
                obj_desc->buffer.pointer =
-                   ACPI_MEM_CALLOCATE(obj_desc->buffer.length);
+                   ACPI_ALLOCATE_ZEROED(obj_desc->buffer.length);
                if (!obj_desc->buffer.pointer) {
                        acpi_ut_delete_object_desc(obj_desc);
                        return_ACPI_STATUS(AE_NO_MEMORY);
@@ -341,9 +341,10 @@ acpi_ds_build_internal_package_obj(struct acpi_walk_state *walk_state,
         * individual objects). Add an extra pointer slot so
         * that the list is always null terminated.
         */
-       obj_desc->package.elements = ACPI_MEM_CALLOCATE(((acpi_size) obj_desc->
-                                                        package.count +
-                                                        1) * sizeof(void *));
+       obj_desc->package.elements = ACPI_ALLOCATE_ZEROED(((acpi_size)
+                                                          obj_desc->package.
+                                                          count +
+                                                          1) * sizeof(void *));
 
        if (!obj_desc->package.elements) {
                acpi_ut_delete_object_desc(obj_desc);
index 3fbe17e..ab24aa8 100644 (file)
@@ -577,7 +577,7 @@ acpi_ds_create_operand(struct acpi_walk_state *walk_state,
 
                /* Free the namestring created above */
 
-               ACPI_MEM_FREE(name_string);
+               ACPI_FREE(name_string);
 
                /* Check status from the lookup */
 
index 02b0312..1ad7870 100644 (file)
@@ -1113,7 +1113,6 @@ acpi_status acpi_ds_load2_end_op(struct acpi_walk_state *walk_state)
                                   ACPI_NS_DONT_OPEN_SCOPE, walk_state,
                                   &(new_node));
                if (ACPI_SUCCESS(status)) {
-
                        /*
                         * Make sure that what we found is indeed a method
                         * We didn't search for a method on purpose, to see if the name
index 5bc340b..d2846ff 100644 (file)
@@ -66,7 +66,6 @@ void *acpi_ds_obj_stack_get_value(u32 index,
 #endif
 
 #ifdef ACPI_FUTURE_USAGE
-
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ds_result_remove
@@ -128,7 +127,6 @@ acpi_ds_result_remove(union acpi_operand_object **object,
 
        return (AE_OK);
 }
-
 #endif                         /*  ACPI_FUTURE_USAGE  */
 
 /*******************************************************************************
@@ -645,7 +643,7 @@ struct acpi_walk_state *acpi_ds_create_walk_state(acpi_owner_id owner_id,
 
        ACPI_FUNCTION_TRACE("ds_create_walk_state");
 
-       walk_state = ACPI_MEM_CALLOCATE(sizeof(struct acpi_walk_state));
+       walk_state = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_walk_state));
        if (!walk_state) {
                return_PTR(NULL);
        }
@@ -668,7 +666,7 @@ struct acpi_walk_state *acpi_ds_create_walk_state(acpi_owner_id owner_id,
 
        status = acpi_ds_result_stack_push(walk_state);
        if (ACPI_FAILURE(status)) {
-               ACPI_MEM_FREE(walk_state);
+               ACPI_FREE(walk_state);
                return_PTR(NULL);
        }
 
@@ -859,7 +857,7 @@ void acpi_ds_delete_walk_state(struct acpi_walk_state *walk_state)
                acpi_ut_delete_generic_state(state);
        }
 
-       ACPI_MEM_FREE(walk_state);
+       ACPI_FREE(walk_state);
        return_VOID;
 }
 
index 87e77a1..e8e7298 100644 (file)
@@ -207,7 +207,7 @@ acpi_ev_delete_gpe_handlers(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
 
                        if ((gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) ==
                            ACPI_GPE_DISPATCH_HANDLER) {
-                               ACPI_MEM_FREE(gpe_event_info->dispatch.handler);
+                               ACPI_FREE(gpe_event_info->dispatch.handler);
                                gpe_event_info->dispatch.handler = NULL;
                                gpe_event_info->flags &=
                                    ~ACPI_GPE_DISPATCH_MASK;
@@ -504,7 +504,7 @@ static struct acpi_gpe_xrupt_info *acpi_ev_get_gpe_xrupt_block(u32
 
        /* Not found, must allocate a new xrupt descriptor */
 
-       gpe_xrupt = ACPI_MEM_CALLOCATE(sizeof(struct acpi_gpe_xrupt_info));
+       gpe_xrupt = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_gpe_xrupt_info));
        if (!gpe_xrupt) {
                return_PTR(NULL);
        }
@@ -595,7 +595,7 @@ acpi_ev_delete_gpe_xrupt(struct acpi_gpe_xrupt_info *gpe_xrupt)
 
        /* Free the block */
 
-       ACPI_MEM_FREE(gpe_xrupt);
+       ACPI_FREE(gpe_xrupt);
        return_ACPI_STATUS(AE_OK);
 }
 
@@ -712,9 +712,9 @@ acpi_status acpi_ev_delete_gpe_block(struct acpi_gpe_block_info *gpe_block)
 
        /* Free the gpe_block */
 
-       ACPI_MEM_FREE(gpe_block->register_info);
-       ACPI_MEM_FREE(gpe_block->event_info);
-       ACPI_MEM_FREE(gpe_block);
+       ACPI_FREE(gpe_block->register_info);
+       ACPI_FREE(gpe_block->event_info);
+       ACPI_FREE(gpe_block);
 
       unlock_and_exit:
        status = acpi_ut_release_mutex(ACPI_MTX_EVENTS);
@@ -748,10 +748,10 @@ acpi_ev_create_gpe_info_blocks(struct acpi_gpe_block_info *gpe_block)
 
        /* Allocate the GPE register information block */
 
-       gpe_register_info = ACPI_MEM_CALLOCATE((acpi_size) gpe_block->
-                                              register_count *
-                                              sizeof(struct
-                                                     acpi_gpe_register_info));
+       gpe_register_info = ACPI_ALLOCATE_ZEROED((acpi_size) gpe_block->
+                                                register_count *
+                                                sizeof(struct
+                                                       acpi_gpe_register_info));
        if (!gpe_register_info) {
                ACPI_ERROR((AE_INFO,
                            "Could not allocate the gpe_register_info table"));
@@ -762,10 +762,11 @@ acpi_ev_create_gpe_info_blocks(struct acpi_gpe_block_info *gpe_block)
         * Allocate the GPE event_info block. There are eight distinct GPEs
         * per register. Initialization to zeros is sufficient.
         */
-       gpe_event_info = ACPI_MEM_CALLOCATE(((acpi_size) gpe_block->
-                                            register_count *
-                                            ACPI_GPE_REGISTER_WIDTH) *
-                                           sizeof(struct acpi_gpe_event_info));
+       gpe_event_info = ACPI_ALLOCATE_ZEROED(((acpi_size) gpe_block->
+                                              register_count *
+                                              ACPI_GPE_REGISTER_WIDTH) *
+                                             sizeof(struct
+                                                    acpi_gpe_event_info));
        if (!gpe_event_info) {
                ACPI_ERROR((AE_INFO,
                            "Could not allocate the gpe_event_info table"));
@@ -848,10 +849,10 @@ acpi_ev_create_gpe_info_blocks(struct acpi_gpe_block_info *gpe_block)
 
       error_exit:
        if (gpe_register_info) {
-               ACPI_MEM_FREE(gpe_register_info);
+               ACPI_FREE(gpe_register_info);
        }
        if (gpe_event_info) {
-               ACPI_MEM_FREE(gpe_event_info);
+               ACPI_FREE(gpe_event_info);
        }
 
        return_ACPI_STATUS(status);
@@ -895,7 +896,7 @@ acpi_ev_create_gpe_block(struct acpi_namespace_node *gpe_device,
 
        /* Allocate a new GPE block */
 
-       gpe_block = ACPI_MEM_CALLOCATE(sizeof(struct acpi_gpe_block_info));
+       gpe_block = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_gpe_block_info));
        if (!gpe_block) {
                return_ACPI_STATUS(AE_NO_MEMORY);
        }
@@ -915,7 +916,7 @@ acpi_ev_create_gpe_block(struct acpi_namespace_node *gpe_device,
         */
        status = acpi_ev_create_gpe_info_blocks(gpe_block);
        if (ACPI_FAILURE(status)) {
-               ACPI_MEM_FREE(gpe_block);
+               ACPI_FREE(gpe_block);
                return_ACPI_STATUS(status);
        }
 
@@ -923,7 +924,7 @@ acpi_ev_create_gpe_block(struct acpi_namespace_node *gpe_device,
 
        status = acpi_ev_install_gpe_block(gpe_block, interrupt_number);
        if (ACPI_FAILURE(status)) {
-               ACPI_MEM_FREE(gpe_block);
+               ACPI_FREE(gpe_block);
                return_ACPI_STATUS(status);
        }
 
index b831ec4..2b900ef 100644 (file)
@@ -366,7 +366,7 @@ acpi_ev_address_space_dispatch(union acpi_operand_object *region_obj,
 
                                /* The handler for this region was already installed */
 
-                               ACPI_MEM_FREE(region_context);
+                               ACPI_FREE(region_context);
                        } else {
                                /*
                                 * Save the returned context for use in all accesses to
index a0bffc2..db98747 100644 (file)
@@ -75,7 +75,7 @@ acpi_ev_system_memory_region_setup(acpi_handle handle,
 
        if (function == ACPI_REGION_DEACTIVATE) {
                if (*region_context) {
-                       ACPI_MEM_FREE(*region_context);
+                       ACPI_FREE(*region_context);
                        *region_context = NULL;
                }
                return_ACPI_STATUS(AE_OK);
@@ -84,7 +84,7 @@ acpi_ev_system_memory_region_setup(acpi_handle handle,
        /* Create a new context */
 
        local_region_context =
-           ACPI_MEM_CALLOCATE(sizeof(struct acpi_mem_space_context));
+           ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_mem_space_context));
        if (!(local_region_context)) {
                return_ACPI_STATUS(AE_NO_MEMORY);
        }
@@ -178,7 +178,7 @@ acpi_ev_pci_config_region_setup(acpi_handle handle,
        *region_context = NULL;
        if (function == ACPI_REGION_DEACTIVATE) {
                if (pci_id) {
-                       ACPI_MEM_FREE(pci_id);
+                       ACPI_FREE(pci_id);
                }
                return_ACPI_STATUS(status);
        }
@@ -264,7 +264,7 @@ acpi_ev_pci_config_region_setup(acpi_handle handle,
 
        /* Region is still not initialized. Create a new context */
 
-       pci_id = ACPI_MEM_CALLOCATE(sizeof(struct acpi_pci_id));
+       pci_id = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_pci_id));
        if (!pci_id) {
                return_ACPI_STATUS(AE_NO_MEMORY);
        }
index ba16fda..7d1cebc 100644 (file)
@@ -41,8 +41,6 @@
  * POSSIBILITY OF SUCH DAMAGES.
  */
 
-#include <linux/module.h>
-
 #include <acpi/acpi.h>
 #include <acpi/acnamesp.h>
 #include <acpi/acevents.h>
@@ -90,6 +88,8 @@ acpi_status acpi_install_exception_handler(acpi_exception_handler handler)
        (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
        return_ACPI_STATUS(status);
 }
+
+ACPI_EXPORT_SYMBOL(acpi_install_exception_handler)
 #endif                         /*  ACPI_FUTURE_USAGE  */
 
 /*******************************************************************************
@@ -107,7 +107,6 @@ acpi_status acpi_install_exception_handler(acpi_exception_handler handler)
  *              event.
  *
  ******************************************************************************/
-
 acpi_status
 acpi_install_fixed_event_handler(u32 event,
                                 acpi_event_handler handler, void *context)
@@ -161,7 +160,7 @@ acpi_install_fixed_event_handler(u32 event,
        return_ACPI_STATUS(status);
 }
 
-EXPORT_SYMBOL(acpi_install_fixed_event_handler);
+ACPI_EXPORT_SYMBOL(acpi_install_fixed_event_handler)
 
 /*******************************************************************************
  *
@@ -175,7 +174,6 @@ EXPORT_SYMBOL(acpi_install_fixed_event_handler);
  * DESCRIPTION: Disables the event and unregisters the event handler.
  *
  ******************************************************************************/
-
 acpi_status
 acpi_remove_fixed_event_handler(u32 event, acpi_event_handler handler)
 {
@@ -216,7 +214,7 @@ acpi_remove_fixed_event_handler(u32 event, acpi_event_handler handler)
        return_ACPI_STATUS(status);
 }
 
-EXPORT_SYMBOL(acpi_remove_fixed_event_handler);
+ACPI_EXPORT_SYMBOL(acpi_remove_fixed_event_handler)
 
 /*******************************************************************************
  *
@@ -235,7 +233,6 @@ EXPORT_SYMBOL(acpi_remove_fixed_event_handler);
  * DESCRIPTION: Install a handler for notifies on an ACPI device
  *
  ******************************************************************************/
-
 acpi_status
 acpi_install_notify_handler(acpi_handle device,
                            u32 handler_type,
@@ -384,7 +381,7 @@ acpi_install_notify_handler(acpi_handle device,
        return_ACPI_STATUS(status);
 }
 
-EXPORT_SYMBOL(acpi_install_notify_handler);
+ACPI_EXPORT_SYMBOL(acpi_install_notify_handler)
 
 /*******************************************************************************
  *
@@ -402,7 +399,6 @@ EXPORT_SYMBOL(acpi_install_notify_handler);
  * DESCRIPTION: Remove a handler for notifies on an ACPI device
  *
  ******************************************************************************/
-
 acpi_status
 acpi_remove_notify_handler(acpi_handle device,
                           u32 handler_type, acpi_notify_handler handler)
@@ -538,7 +534,7 @@ acpi_remove_notify_handler(acpi_handle device,
        return_ACPI_STATUS(status);
 }
 
-EXPORT_SYMBOL(acpi_remove_notify_handler);
+ACPI_EXPORT_SYMBOL(acpi_remove_notify_handler)
 
 /*******************************************************************************
  *
@@ -557,7 +553,6 @@ EXPORT_SYMBOL(acpi_remove_notify_handler);
  * DESCRIPTION: Install a handler for a General Purpose Event.
  *
  ******************************************************************************/
-
 acpi_status
 acpi_install_gpe_handler(acpi_handle gpe_device,
                         u32 gpe_number,
@@ -599,7 +594,7 @@ acpi_install_gpe_handler(acpi_handle gpe_device,
 
        /* Allocate and init handler object */
 
-       handler = ACPI_MEM_CALLOCATE(sizeof(struct acpi_handler_info));
+       handler = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_handler_info));
        if (!handler) {
                status = AE_NO_MEMORY;
                goto unlock_and_exit;
@@ -633,7 +628,7 @@ acpi_install_gpe_handler(acpi_handle gpe_device,
        return_ACPI_STATUS(status);
 }
 
-EXPORT_SYMBOL(acpi_install_gpe_handler);
+ACPI_EXPORT_SYMBOL(acpi_install_gpe_handler)
 
 /*******************************************************************************
  *
@@ -649,7 +644,6 @@ EXPORT_SYMBOL(acpi_install_gpe_handler);
  * DESCRIPTION: Remove a handler for a General Purpose acpi_event.
  *
  ******************************************************************************/
-
 acpi_status
 acpi_remove_gpe_handler(acpi_handle gpe_device,
                        u32 gpe_number, acpi_event_handler address)
@@ -727,14 +721,14 @@ acpi_remove_gpe_handler(acpi_handle gpe_device,
 
        /* Now we can free the handler object */
 
-       ACPI_MEM_FREE(handler);
+       ACPI_FREE(handler);
 
       unlock_and_exit:
        (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
        return_ACPI_STATUS(status);
 }
 
-EXPORT_SYMBOL(acpi_remove_gpe_handler);
+ACPI_EXPORT_SYMBOL(acpi_remove_gpe_handler)
 
 /*******************************************************************************
  *
@@ -749,7 +743,6 @@ EXPORT_SYMBOL(acpi_remove_gpe_handler);
  * DESCRIPTION: Acquire the ACPI Global Lock
  *
  ******************************************************************************/
-
 acpi_status acpi_acquire_global_lock(u16 timeout, u32 * handle)
 {
        acpi_status status;
@@ -774,7 +767,7 @@ acpi_status acpi_acquire_global_lock(u16 timeout, u32 * handle)
        return (status);
 }
 
-EXPORT_SYMBOL(acpi_acquire_global_lock);
+ACPI_EXPORT_SYMBOL(acpi_acquire_global_lock)
 
 /*******************************************************************************
  *
@@ -787,7 +780,6 @@ EXPORT_SYMBOL(acpi_acquire_global_lock);
  * DESCRIPTION: Release the ACPI Global Lock. The handle must be valid.
  *
  ******************************************************************************/
-
 acpi_status acpi_release_global_lock(u32 handle)
 {
        acpi_status status;
@@ -800,4 +792,4 @@ acpi_status acpi_release_global_lock(u32 handle)
        return (status);
 }
 
-EXPORT_SYMBOL(acpi_release_global_lock);
+ACPI_EXPORT_SYMBOL(acpi_release_global_lock)
index babebb5..4a36559 100644 (file)
@@ -41,8 +41,6 @@
  * POSSIBILITY OF SUCH DAMAGES.
  */
 
-#include <linux/module.h>
-
 #include <acpi/acpi.h>
 #include <acpi/acevents.h>
 #include <acpi/acnamesp.h>
@@ -94,6 +92,8 @@ acpi_status acpi_enable(void)
        return_ACPI_STATUS(status);
 }
 
+ACPI_EXPORT_SYMBOL(acpi_enable)
+
 /*******************************************************************************
  *
  * FUNCTION:    acpi_disable
@@ -105,7 +105,6 @@ acpi_status acpi_enable(void)
  * DESCRIPTION: Transfers the system into LEGACY (non-ACPI) mode.
  *
  ******************************************************************************/
-
 acpi_status acpi_disable(void)
 {
        acpi_status status = AE_OK;
@@ -137,6 +136,8 @@ acpi_status acpi_disable(void)
        return_ACPI_STATUS(status);
 }
 
+ACPI_EXPORT_SYMBOL(acpi_disable)
+
 /*******************************************************************************
  *
  * FUNCTION:    acpi_enable_event
@@ -149,7 +150,6 @@ acpi_status acpi_disable(void)
  * DESCRIPTION: Enable an ACPI event (fixed)
  *
  ******************************************************************************/
-
 acpi_status acpi_enable_event(u32 event, u32 flags)
 {
        acpi_status status = AE_OK;
@@ -193,7 +193,7 @@ acpi_status acpi_enable_event(u32 event, u32 flags)
        return_ACPI_STATUS(status);
 }
 
-EXPORT_SYMBOL(acpi_enable_event);
+ACPI_EXPORT_SYMBOL(acpi_enable_event)
 
 /*******************************************************************************
  *
@@ -208,7 +208,6 @@ EXPORT_SYMBOL(acpi_enable_event);
  * DESCRIPTION: Set the type of an individual GPE
  *
  ******************************************************************************/
-
 acpi_status acpi_set_gpe_type(acpi_handle gpe_device, u32 gpe_number, u8 type)
 {
        acpi_status status = AE_OK;
@@ -236,7 +235,7 @@ acpi_status acpi_set_gpe_type(acpi_handle gpe_device, u32 gpe_number, u8 type)
        return_ACPI_STATUS(status);
 }
 
-EXPORT_SYMBOL(acpi_set_gpe_type);
+ACPI_EXPORT_SYMBOL(acpi_set_gpe_type)
 
 /*******************************************************************************
  *
@@ -252,7 +251,6 @@ EXPORT_SYMBOL(acpi_set_gpe_type);
  * DESCRIPTION: Enable an ACPI event (general purpose)
  *
  ******************************************************************************/
-
 acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number, u32 flags)
 {
        acpi_status status = AE_OK;
@@ -288,7 +286,7 @@ acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number, u32 flags)
        return_ACPI_STATUS(status);
 }
 
-EXPORT_SYMBOL(acpi_enable_gpe);
+ACPI_EXPORT_SYMBOL(acpi_enable_gpe)
 
 /*******************************************************************************
  *
@@ -304,7 +302,6 @@ EXPORT_SYMBOL(acpi_enable_gpe);
  * DESCRIPTION: Disable an ACPI event (general purpose)
  *
  ******************************************************************************/
-
 acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number, u32 flags)
 {
        acpi_status status = AE_OK;
@@ -338,6 +335,8 @@ acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number, u32 flags)
        return_ACPI_STATUS(status);
 }
 
+ACPI_EXPORT_SYMBOL(acpi_disable_gpe)
+
 /*******************************************************************************
  *
  * FUNCTION:    acpi_disable_event
@@ -350,7 +349,6 @@ acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number, u32 flags)
  * DESCRIPTION: Disable an ACPI event (fixed)
  *
  ******************************************************************************/
-
 acpi_status acpi_disable_event(u32 event, u32 flags)
 {
        acpi_status status = AE_OK;
@@ -392,7 +390,7 @@ acpi_status acpi_disable_event(u32 event, u32 flags)
        return_ACPI_STATUS(status);
 }
 
-EXPORT_SYMBOL(acpi_disable_event);
+ACPI_EXPORT_SYMBOL(acpi_disable_event)
 
 /*******************************************************************************
  *
@@ -405,7 +403,6 @@ EXPORT_SYMBOL(acpi_disable_event);
  * DESCRIPTION: Clear an ACPI event (fixed)
  *
  ******************************************************************************/
-
 acpi_status acpi_clear_event(u32 event)
 {
        acpi_status status = AE_OK;
@@ -429,7 +426,7 @@ acpi_status acpi_clear_event(u32 event)
        return_ACPI_STATUS(status);
 }
 
-EXPORT_SYMBOL(acpi_clear_event);
+ACPI_EXPORT_SYMBOL(acpi_clear_event)
 
 /*******************************************************************************
  *
@@ -444,7 +441,6 @@ EXPORT_SYMBOL(acpi_clear_event);
  * DESCRIPTION: Clear an ACPI event (general purpose)
  *
  ******************************************************************************/
-
 acpi_status acpi_clear_gpe(acpi_handle gpe_device, u32 gpe_number, u32 flags)
 {
        acpi_status status = AE_OK;
@@ -478,6 +474,8 @@ acpi_status acpi_clear_gpe(acpi_handle gpe_device, u32 gpe_number, u32 flags)
        return_ACPI_STATUS(status);
 }
 
+ACPI_EXPORT_SYMBOL(acpi_clear_gpe)
+
 #ifdef ACPI_FUTURE_USAGE
 /*******************************************************************************
  *
@@ -492,7 +490,6 @@ acpi_status acpi_clear_gpe(acpi_handle gpe_device, u32 gpe_number, u32 flags)
  * DESCRIPTION: Obtains and returns the current status of the event
  *
  ******************************************************************************/
-
 acpi_status acpi_get_event_status(u32 event, acpi_event_status * event_status)
 {
        acpi_status status = AE_OK;
@@ -518,6 +515,8 @@ acpi_status acpi_get_event_status(u32 event, acpi_event_status * event_status)
        return_ACPI_STATUS(status);
 }
 
+ACPI_EXPORT_SYMBOL(acpi_get_event_status)
+
 /*******************************************************************************
  *
  * FUNCTION:    acpi_get_gpe_status
@@ -533,7 +532,6 @@ acpi_status acpi_get_event_status(u32 event, acpi_event_status * event_status)
  * DESCRIPTION: Get status of an event (general purpose)
  *
  ******************************************************************************/
-
 acpi_status
 acpi_get_gpe_status(acpi_handle gpe_device,
                    u32 gpe_number, u32 flags, acpi_event_status * event_status)
@@ -570,6 +568,8 @@ acpi_get_gpe_status(acpi_handle gpe_device,
        }
        return_ACPI_STATUS(status);
 }
+
+ACPI_EXPORT_SYMBOL(acpi_get_gpe_status)
 #endif                         /*  ACPI_FUTURE_USAGE  */
 
 /*******************************************************************************
@@ -586,7 +586,6 @@ acpi_get_gpe_status(acpi_handle gpe_device,
  * DESCRIPTION: Create and Install a block of GPE registers
  *
  ******************************************************************************/
-
 acpi_status
 acpi_install_gpe_block(acpi_handle gpe_device,
                       struct acpi_generic_address *gpe_block_address,
@@ -666,7 +665,7 @@ acpi_install_gpe_block(acpi_handle gpe_device,
        return_ACPI_STATUS(status);
 }
 
-EXPORT_SYMBOL(acpi_install_gpe_block);
+ACPI_EXPORT_SYMBOL(acpi_install_gpe_block)
 
 /*******************************************************************************
  *
@@ -679,7 +678,6 @@ EXPORT_SYMBOL(acpi_install_gpe_block);
  * DESCRIPTION: Remove a previously installed block of GPE registers
  *
  ******************************************************************************/
-
 acpi_status acpi_remove_gpe_block(acpi_handle gpe_device)
 {
        union acpi_operand_object *obj_desc;
@@ -722,4 +720,4 @@ acpi_status acpi_remove_gpe_block(acpi_handle gpe_device)
        return_ACPI_STATUS(status);
 }
 
-EXPORT_SYMBOL(acpi_remove_gpe_block);
+ACPI_EXPORT_SYMBOL(acpi_remove_gpe_block)
index 368c8aa..63a070b 100644 (file)
@@ -42,8 +42,6 @@
  * POSSIBILITY OF SUCH DAMAGES.
  */
 
-#include <linux/module.h>
-
 #include <acpi/acpi.h>
 #include <acpi/acnamesp.h>
 #include <acpi/acevents.h>
@@ -114,7 +112,7 @@ acpi_install_address_space_handler(acpi_handle device,
        return_ACPI_STATUS(status);
 }
 
-EXPORT_SYMBOL(acpi_install_address_space_handler);
+ACPI_EXPORT_SYMBOL(acpi_install_address_space_handler)
 
 /*******************************************************************************
  *
@@ -129,7 +127,6 @@ EXPORT_SYMBOL(acpi_install_address_space_handler);
  * DESCRIPTION: Remove a previously installed handler.
  *
  ******************************************************************************/
-
 acpi_status
 acpi_remove_address_space_handler(acpi_handle device,
                                  acpi_adr_space_type space_id,
@@ -242,4 +239,4 @@ acpi_remove_address_space_handler(acpi_handle device,
        return_ACPI_STATUS(status);
 }
 
-EXPORT_SYMBOL(acpi_remove_address_space_handler);
+ACPI_EXPORT_SYMBOL(acpi_remove_address_space_handler)
index 864530f..e0deffb 100644 (file)
@@ -349,7 +349,7 @@ acpi_ex_load_op(union acpi_operand_object *obj_desc,
 
                /* Allocate a buffer for the entire table */
 
-               table_ptr = ACPI_MEM_ALLOCATE(table_header.length);
+               table_ptr = ACPI_ALLOCATE(table_header.length);
                if (!table_ptr) {
                        return_ACPI_STATUS(AE_NO_MEMORY);
                }
@@ -447,7 +447,7 @@ acpi_ex_load_op(union acpi_operand_object *obj_desc,
 
       cleanup:
        if (ACPI_FAILURE(status)) {
-               ACPI_MEM_FREE(table_ptr);
+               ACPI_FREE(table_ptr);
        }
        return_ACPI_STATUS(status);
 }
index 0a53d31..502293c 100644 (file)
@@ -903,7 +903,7 @@ static void acpi_ex_dump_reference_obj(union acpi_operand_object *obj_desc)
                        acpi_os_printf("Could not convert name to pathname\n");
                } else {
                        acpi_os_printf("%s\n", (char *)ret_buf.pointer);
-                       ACPI_MEM_FREE(ret_buf.pointer);
+                       ACPI_FREE(ret_buf.pointer);
                }
        } else if (obj_desc->reference.object) {
                acpi_os_printf("\nReferenced Object: %p\n",
index 215783a..36c265a 100644 (file)
@@ -333,7 +333,7 @@ acpi_ex_write_data_to_field(union acpi_operand_object *source_desc,
 
                /* We need to create a new buffer */
 
-               new_buffer = ACPI_MEM_CALLOCATE(required_length);
+               new_buffer = ACPI_ALLOCATE_ZEROED(required_length);
                if (!new_buffer) {
                        return_ACPI_STATUS(AE_NO_MEMORY);
                }
@@ -377,7 +377,7 @@ acpi_ex_write_data_to_field(union acpi_operand_object *source_desc,
        /* Free temporary buffer if we used one */
 
        if (new_buffer) {
-               ACPI_MEM_FREE(new_buffer);
+               ACPI_FREE(new_buffer);
        }
 
        return_ACPI_STATUS(status);
index f9bc81c..80bbc20 100644 (file)
@@ -98,7 +98,7 @@ static char *acpi_ex_allocate_name_string(u32 prefix_count, u32 num_name_segs)
         * Allocate a buffer for the name.
         * This buffer must be deleted by the caller!
         */
-       name_string = ACPI_MEM_ALLOCATE(size_needed);
+       name_string = ACPI_ALLOCATE(size_needed);
        if (!name_string) {
                ACPI_ERROR((AE_INFO,
                            "Could not allocate size %d", size_needed));
@@ -424,7 +424,7 @@ acpi_ex_get_name_string(acpi_object_type data_type,
 
        if (ACPI_FAILURE(status)) {
                if (name_string) {
-                       ACPI_MEM_FREE(name_string);
+                       ACPI_FREE(name_string);
                }
                return_ACPI_STATUS(status);
        }
index 4f3627e..d00f766 100644 (file)
@@ -554,16 +554,18 @@ acpi_status acpi_ex_opcode_1A_1T_1R(struct acpi_walk_state *walk_state)
 
       cleanup:
 
-       if (!walk_state->result_obj) {
-               walk_state->result_obj = return_desc;
-       }
-
        /* Delete return object on error */
 
        if (ACPI_FAILURE(status)) {
                acpi_ut_remove_reference(return_desc);
        }
 
+       /* Save return object on success */
+
+       else if (!walk_state->result_obj) {
+               walk_state->result_obj = return_desc;
+       }
+
        return_ACPI_STATUS(status);
 }
 
@@ -1028,6 +1030,11 @@ acpi_status acpi_ex_opcode_1A_0T_1R(struct acpi_walk_state *walk_state)
                acpi_ut_remove_reference(return_desc);
        }
 
-       walk_state->result_obj = return_desc;
+       /* Save return object on success */
+
+       else {
+               walk_state->result_obj = return_desc;
+       }
+
        return_ACPI_STATUS(status);
 }
index 5e1abb1..690e43d 100644 (file)
@@ -391,7 +391,6 @@ acpi_status acpi_ex_opcode_2A_1T_1R(struct acpi_walk_state *walk_state)
                index = operand[1]->integer.value;
                return_desc->reference.offset = (u32) index;
                return_desc->reference.opcode = AML_INDEX_OP;
-               return_desc->reference.object = operand[0];
 
                /*
                 * At this point, the Source operand is a String, Buffer, or Package.
@@ -445,9 +444,10 @@ acpi_status acpi_ex_opcode_2A_1T_1R(struct acpi_walk_state *walk_state)
                }
 
                /*
-                * Add a reference to the target package/buffer/string for the life
+                * Save the target object and add a reference to it for the life
                 * of the index
                 */
+               return_desc->reference.object = operand[0];
                acpi_ut_add_reference(operand[0]);
 
                /* Store the reference to the Target */
index 8da794e..4897e6c 100644 (file)
@@ -100,8 +100,7 @@ acpi_status acpi_ex_opcode_3A_0T_0R(struct acpi_walk_state *walk_state)
                                  (u32) operand[1]->integer.value,
                                  (u32) operand[2]->integer.value));
 
-               fatal =
-                   ACPI_MEM_ALLOCATE(sizeof(struct acpi_signal_fatal_info));
+               fatal = ACPI_ALLOCATE(sizeof(struct acpi_signal_fatal_info));
                if (fatal) {
                        fatal->type = (u32) operand[0]->integer.value;
                        fatal->code = (u32) operand[1]->integer.value;
@@ -114,7 +113,7 @@ acpi_status acpi_ex_opcode_3A_0T_0R(struct acpi_walk_state *walk_state)
 
                /* Might return while OS is shutting down, just continue */
 
-               ACPI_MEM_FREE(fatal);
+               ACPI_FREE(fatal);
                break;
 
        default:
@@ -196,7 +195,7 @@ acpi_status acpi_ex_opcode_3A_1T_1R(struct acpi_walk_state *walk_state)
 
                        /* Always allocate a new buffer for the String */
 
-                       buffer = ACPI_MEM_CALLOCATE((acpi_size) length + 1);
+                       buffer = ACPI_ALLOCATE_ZEROED((acpi_size) length + 1);
                        if (!buffer) {
                                status = AE_NO_MEMORY;
                                goto cleanup;
@@ -211,7 +210,7 @@ acpi_status acpi_ex_opcode_3A_1T_1R(struct acpi_walk_state *walk_state)
 
                                /* Allocate a new buffer for the Buffer */
 
-                               buffer = ACPI_MEM_CALLOCATE(length);
+                               buffer = ACPI_ALLOCATE_ZEROED(length);
                                if (!buffer) {
                                        status = AE_NO_MEMORY;
                                        goto cleanup;
index 9db68d1..fdeda7b 100644 (file)
@@ -182,8 +182,8 @@ acpi_ex_system_memory_space_handler(u32 function,
             (acpi_integer) mem_info->mapped_physical_address);
 
        ACPI_DEBUG_PRINT((ACPI_DB_INFO,
-                         "system_memory %d (%d width) Address=%8.8X%8.8X\n",
-                         function, bit_width, ACPI_FORMAT_UINT64(address)));
+                         "System-Memory (width %d) R/W %d Address=%8.8X%8.8X\n",
+                         bit_width, function, ACPI_FORMAT_UINT64(address)));
 
        /*
         * Perform the memory read or write
@@ -287,8 +287,8 @@ acpi_ex_system_io_space_handler(u32 function,
        ACPI_FUNCTION_TRACE("ex_system_io_space_handler");
 
        ACPI_DEBUG_PRINT((ACPI_DB_INFO,
-                         "system_iO %d (%d width) Address=%8.8X%8.8X\n",
-                         function, bit_width, ACPI_FORMAT_UINT64(address)));
+                         "System-IO (width %d) R/W %d Address=%8.8X%8.8X\n",
+                         bit_width, function, ACPI_FORMAT_UINT64(address)));
 
        /* Decode the function parameter */
 
@@ -361,7 +361,7 @@ acpi_ex_pci_config_space_handler(u32 function,
        pci_register = (u16) (u32) address;
 
        ACPI_DEBUG_PRINT((ACPI_DB_INFO,
-                         "pci_config %d (%d) Seg(%04x) Bus(%04x) Dev(%04x) Func(%04x) Reg(%04x)\n",
+                         "Pci-Config %d (%d) Seg(%04x) Bus(%04x) Dev(%04x) Func(%04x) Reg(%04x)\n",
                          function, bit_width, pci_id->segment, pci_id->bus,
                          pci_id->device, pci_id->function, pci_register));
 
index 41732d3..db42461 100644 (file)
@@ -80,7 +80,7 @@ acpi_ex_store_buffer_to_buffer(union acpi_operand_object *source_desc,
         */
        if ((target_desc->buffer.length == 0) ||
            (target_desc->common.flags & AOPOBJ_STATIC_POINTER)) {
-               target_desc->buffer.pointer = ACPI_MEM_ALLOCATE(length);
+               target_desc->buffer.pointer = ACPI_ALLOCATE(length);
                if (!target_desc->buffer.pointer) {
                        return_ACPI_STATUS(AE_NO_MEMORY);
                }
@@ -188,11 +188,11 @@ acpi_ex_store_string_to_string(union acpi_operand_object *source_desc,
 
                        /* Only free if not a pointer into the DSDT */
 
-                       ACPI_MEM_FREE(target_desc->string.pointer);
+                       ACPI_FREE(target_desc->string.pointer);
                }
 
-               target_desc->string.pointer = ACPI_MEM_CALLOCATE((acpi_size)
-                                                                length + 1);
+               target_desc->string.pointer = ACPI_ALLOCATE_ZEROED((acpi_size)
+                                                                  length + 1);
                if (!target_desc->string.pointer) {
                        return_ACPI_STATUS(AE_NO_MEMORY);
                }
index 95c4ccb..3d1f41c 100644 (file)
@@ -43,8 +43,6 @@
  * POSSIBILITY OF SUCH DAMAGES.
  */
 
-#include <linux/module.h>
-
 #include <acpi/acpi.h>
 #include <acpi/acnamesp.h>
 #include <acpi/acevents.h>
@@ -220,7 +218,7 @@ acpi_get_sleep_type_data(u8 sleep_state, u8 * sleep_type_a, u8 * sleep_type_b)
        return_ACPI_STATUS(status);
 }
 
-EXPORT_SYMBOL(acpi_get_sleep_type_data);
+ACPI_EXPORT_SYMBOL(acpi_get_sleep_type_data)
 
 /*******************************************************************************
  *
@@ -233,7 +231,6 @@ EXPORT_SYMBOL(acpi_get_sleep_type_data);
  * DESCRIPTION: Map register_id into a register bitmask.
  *
  ******************************************************************************/
-
 struct acpi_bit_register_info *acpi_hw_get_bit_register_info(u32 register_id)
 {
        ACPI_FUNCTION_ENTRY();
@@ -312,7 +309,7 @@ acpi_status acpi_get_register(u32 register_id, u32 * return_value, u32 flags)
        return_ACPI_STATUS(status);
 }
 
-EXPORT_SYMBOL(acpi_get_register);
+ACPI_EXPORT_SYMBOL(acpi_get_register)
 
 /*******************************************************************************
  *
@@ -328,7 +325,6 @@ EXPORT_SYMBOL(acpi_get_register);
  * DESCRIPTION: ACPI Bit Register write function.
  *
  ******************************************************************************/
-
 acpi_status acpi_set_register(u32 register_id, u32 value, u32 flags)
 {
        u32 register_value = 0;
@@ -475,7 +471,7 @@ acpi_status acpi_set_register(u32 register_id, u32 value, u32 flags)
        return_ACPI_STATUS(status);
 }
 
-EXPORT_SYMBOL(acpi_set_register);
+ACPI_EXPORT_SYMBOL(acpi_set_register)
 
 /******************************************************************************
  *
@@ -491,7 +487,6 @@ EXPORT_SYMBOL(acpi_set_register);
  *              given offset.
  *
  ******************************************************************************/
-
 acpi_status
 acpi_hw_register_read(u8 use_lock, u32 register_id, u32 * return_value)
 {
index 284a59e..685deba 100644 (file)
@@ -42,7 +42,6 @@
  * POSSIBILITY OF SUCH DAMAGES.
  */
 
-#include <linux/module.h>
 #include <acpi/acpi.h>
 
 #define _COMPONENT          ACPI_HARDWARE
@@ -79,6 +78,8 @@ acpi_set_firmware_waking_vector(acpi_physical_address physical_address)
        return_ACPI_STATUS(AE_OK);
 }
 
+ACPI_EXPORT_SYMBOL(acpi_set_firmware_waking_vector)
+
 /*******************************************************************************
  *
  * FUNCTION:    acpi_get_firmware_waking_vector
@@ -92,7 +93,6 @@ acpi_set_firmware_waking_vector(acpi_physical_address physical_address)
  * DESCRIPTION: Access function for the firmware_waking_vector field in FACS
  *
  ******************************************************************************/
-
 #ifdef ACPI_FUTURE_USAGE
 acpi_status
 acpi_get_firmware_waking_vector(acpi_physical_address * physical_address)
@@ -118,6 +118,8 @@ acpi_get_firmware_waking_vector(acpi_physical_address * physical_address)
 
        return_ACPI_STATUS(AE_OK);
 }
+
+ACPI_EXPORT_SYMBOL(acpi_get_firmware_waking_vector)
 #endif
 
 /*******************************************************************************
@@ -134,7 +136,6 @@ acpi_get_firmware_waking_vector(acpi_physical_address * physical_address)
  *              various OS-specific tasks between the two steps.
  *
  ******************************************************************************/
-
 acpi_status acpi_enter_sleep_state_prep(u8 sleep_state)
 {
        acpi_status status;
@@ -206,6 +207,8 @@ acpi_status acpi_enter_sleep_state_prep(u8 sleep_state)
        return_ACPI_STATUS(AE_OK);
 }
 
+ACPI_EXPORT_SYMBOL(acpi_enter_sleep_state_prep)
+
 /*******************************************************************************
  *
  * FUNCTION:    acpi_enter_sleep_state
@@ -218,7 +221,6 @@ acpi_status acpi_enter_sleep_state_prep(u8 sleep_state)
  *              THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED
  *
  ******************************************************************************/
-
 acpi_status asmlinkage acpi_enter_sleep_state(u8 sleep_state)
 {
        u32 PM1Acontrol;
@@ -378,7 +380,7 @@ acpi_status asmlinkage acpi_enter_sleep_state(u8 sleep_state)
        return_ACPI_STATUS(AE_OK);
 }
 
-EXPORT_SYMBOL(acpi_enter_sleep_state);
+ACPI_EXPORT_SYMBOL(acpi_enter_sleep_state)
 
 /*******************************************************************************
  *
@@ -392,7 +394,6 @@ EXPORT_SYMBOL(acpi_enter_sleep_state);
  *              THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED
  *
  ******************************************************************************/
-
 acpi_status asmlinkage acpi_enter_sleep_state_s4bios(void)
 {
        u32 in_value;
@@ -443,7 +444,7 @@ acpi_status asmlinkage acpi_enter_sleep_state_s4bios(void)
        return_ACPI_STATUS(AE_OK);
 }
 
-EXPORT_SYMBOL(acpi_enter_sleep_state_s4bios);
+ACPI_EXPORT_SYMBOL(acpi_enter_sleep_state_s4bios)
 
 /*******************************************************************************
  *
@@ -457,7 +458,6 @@ EXPORT_SYMBOL(acpi_enter_sleep_state_s4bios);
  *              Called with interrupts ENABLED.
  *
  ******************************************************************************/
-
 acpi_status acpi_leave_sleep_state(u8 sleep_state)
 {
        struct acpi_object_list arg_list;
@@ -584,3 +584,5 @@ acpi_status acpi_leave_sleep_state(u8 sleep_state)
 
        return_ACPI_STATUS(status);
 }
+
+ACPI_EXPORT_SYMBOL(acpi_leave_sleep_state)
index ef7c98e..9d53e46 100644 (file)
@@ -42,7 +42,6 @@
  * POSSIBILITY OF SUCH DAMAGES.
  */
 
-#include <linux/module.h>
 #include <acpi/acpi.h>
 
 #define _COMPONENT          ACPI_HARDWARE
@@ -76,6 +75,8 @@ acpi_status acpi_get_timer_resolution(u32 * resolution)
        return_ACPI_STATUS(AE_OK);
 }
 
+ACPI_EXPORT_SYMBOL(acpi_get_timer_resolution)
+
 /******************************************************************************
  *
  * FUNCTION:    acpi_get_timer
@@ -87,7 +88,6 @@ acpi_status acpi_get_timer_resolution(u32 * resolution)
  * DESCRIPTION: Obtains current value of ACPI PM Timer (in ticks).
  *
  ******************************************************************************/
-
 acpi_status acpi_get_timer(u32 * ticks)
 {
        acpi_status status;
@@ -103,7 +103,7 @@ acpi_status acpi_get_timer(u32 * ticks)
        return_ACPI_STATUS(status);
 }
 
-EXPORT_SYMBOL(acpi_get_timer);
+ACPI_EXPORT_SYMBOL(acpi_get_timer)
 
 /******************************************************************************
  *
@@ -133,7 +133,6 @@ EXPORT_SYMBOL(acpi_get_timer);
  *              2**32 Ticks / 3,600,000 Ticks/Sec = 1193 sec or 19.88 minutes
  *
  ******************************************************************************/
-
 acpi_status
 acpi_get_timer_duration(u32 start_ticks, u32 end_ticks, u32 * time_elapsed)
 {
@@ -184,4 +183,4 @@ acpi_get_timer_duration(u32 start_ticks, u32 end_ticks, u32 * time_elapsed)
        return_ACPI_STATUS(status);
 }
 
-EXPORT_SYMBOL(acpi_get_timer_duration);
+ACPI_EXPORT_SYMBOL(acpi_get_timer_duration)
index 6bdad8b..d4914fd 100644 (file)
@@ -347,14 +347,17 @@ acpi_ns_lookup(union acpi_generic_state *scope_info,
                        return_ACPI_STATUS(AE_AML_INTERNAL);
                }
 
-               /*
-                * This node might not be a actual "scope" node (such as a
-                * Device/Method, etc.)  It could be a Package or other object node.
-                * Backup up the tree to find the containing scope node.
-                */
-               while (!acpi_ns_opens_scope(prefix_node->type) &&
-                      prefix_node->type != ACPI_TYPE_ANY) {
-                       prefix_node = acpi_ns_get_parent_node(prefix_node);
+               if (!(flags & ACPI_NS_PREFIX_IS_SCOPE)) {
+                       /*
+                        * This node might not be a actual "scope" node (such as a
+                        * Device/Method, etc.)  It could be a Package or other object node.
+                        * Backup up the tree to find the containing scope node.
+                        */
+                       while (!acpi_ns_opens_scope(prefix_node->type) &&
+                              prefix_node->type != ACPI_TYPE_ANY) {
+                               prefix_node =
+                                   acpi_ns_get_parent_node(prefix_node);
+                       }
                }
        }
 
index cd26cb9..acd4b67 100644 (file)
@@ -68,7 +68,7 @@ struct acpi_namespace_node *acpi_ns_create_node(u32 name)
 
        ACPI_FUNCTION_TRACE("ns_create_node");
 
-       node = ACPI_MEM_CALLOCATE(sizeof(struct acpi_namespace_node));
+       node = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_namespace_node));
        if (!node) {
                return_PTR(NULL);
        }
@@ -142,7 +142,7 @@ void acpi_ns_delete_node(struct acpi_namespace_node *node)
         * Detach an object if there is one then delete the node
         */
        acpi_ns_detach_object(node);
-       ACPI_MEM_FREE(node);
+       ACPI_FREE(node);
        return_VOID;
 }
 
@@ -311,7 +311,7 @@ void acpi_ns_delete_children(struct acpi_namespace_node *parent_node)
 
                /* Now we can delete the node */
 
-               ACPI_MEM_FREE(child_node);
+               ACPI_FREE(child_node);
 
                /* And move on to the next child in the list */
 
index aff899a..2b311da 100644 (file)
@@ -92,7 +92,7 @@ acpi_ns_dump_one_device(acpi_handle obj_handle,
                                      info->hardware_id.value,
                                      ACPI_FORMAT_UINT64(info->address),
                                      info->current_status));
-               ACPI_MEM_FREE(info);
+               ACPI_FREE(info);
        }
 
        return (status);
index 80ef955..f5d8e71 100644 (file)
@@ -151,7 +151,7 @@ acpi_ns_evaluate_relative(char *pathname, struct acpi_parameter_info *info)
        acpi_ut_delete_generic_state(scope_info);
 
       cleanup1:
-       ACPI_MEM_FREE(internal_path);
+       ACPI_FREE(internal_path);
        return_ACPI_STATUS(status);
 }
 
@@ -228,7 +228,7 @@ acpi_ns_evaluate_by_name(char *pathname, struct acpi_parameter_info *info)
        /* Cleanup */
 
        if (internal_path) {
-               ACPI_MEM_FREE(internal_path);
+               ACPI_FREE(internal_path);
        }
 
        return_ACPI_STATUS(status);
index 9aa337c..57b2537 100644 (file)
@@ -424,7 +424,7 @@ acpi_ns_init_one_device(acpi_handle obj_handle,
                ACPI_WARNING((AE_INFO, "%s._INI failed: %s",
                              scope_name, acpi_format_exception(status)));
 
-               ACPI_MEM_FREE(scope_name);
+               ACPI_FREE(scope_name);
 #endif
        } else {
                /* Delete any return object (especially if implicit_return is enabled) */
index 639f653..ba812f4 100644 (file)
 #define _COMPONENT          ACPI_NAMESPACE
 ACPI_MODULE_NAME("nsnames")
 
-/* Local prototypes */
-static void
-acpi_ns_build_external_path(struct acpi_namespace_node *node,
-                           acpi_size size, char *name_buffer);
-
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ns_build_external_path
@@ -67,8 +62,7 @@ acpi_ns_build_external_path(struct acpi_namespace_node *node,
  * DESCRIPTION: Generate a full pathaname
  *
  ******************************************************************************/
-
-static void
+void
 acpi_ns_build_external_path(struct acpi_namespace_node *node,
                            acpi_size size, char *name_buffer)
 {
@@ -146,7 +140,7 @@ char *acpi_ns_get_external_pathname(struct acpi_namespace_node *node)
 
        /* Allocate a buffer to be returned to caller */
 
-       name_buffer = ACPI_MEM_CALLOCATE(size);
+       name_buffer = ACPI_ALLOCATE_ZEROED(size);
        if (!name_buffer) {
                ACPI_ERROR((AE_INFO, "Allocation failure"));
                return_PTR(NULL);
index 232be43..64daf30 100644 (file)
@@ -62,7 +62,7 @@ ACPI_MODULE_NAME("nsparse")
  *
  ******************************************************************************/
 acpi_status
-acpi_ns_one_complete_parse(u8 pass_number, struct acpi_table_desc * table_desc)
+acpi_ns_one_complete_parse(u8 pass_number, struct acpi_table_desc *table_desc)
 {
        union acpi_parse_object *parse_root;
        acpi_status status;
index f73a3d5..c929f45 100644 (file)
@@ -103,7 +103,7 @@ acpi_ns_search_node(u32 target_name,
                                                                          &target_name),
                                          acpi_ut_get_type_name(type)));
 
-                       ACPI_MEM_FREE(scope_name);
+                       ACPI_FREE(scope_name);
                }
        }
 #endif
index 123f454..586014e 100644 (file)
@@ -104,7 +104,7 @@ acpi_ns_report_error(char *module_name,
                }
 
                if (name) {
-                       ACPI_MEM_FREE(name);
+                       ACPI_FREE(name);
                }
        }
 
@@ -187,7 +187,7 @@ acpi_ns_print_node_pathname(struct acpi_namespace_node *node, char *message)
                }
 
                acpi_os_printf("[%s] (Node %p)", (char *)buffer.pointer, node);
-               ACPI_MEM_FREE(buffer.pointer);
+               ACPI_FREE(buffer.pointer);
        }
 }
 
@@ -490,7 +490,7 @@ acpi_status acpi_ns_internalize_name(char *external_name, char **converted_name)
 
        /* We need a segment to store the internal  name */
 
-       internal_name = ACPI_MEM_CALLOCATE(info.length);
+       internal_name = ACPI_ALLOCATE_ZEROED(info.length);
        if (!internal_name) {
                return_ACPI_STATUS(AE_NO_MEMORY);
        }
@@ -500,7 +500,7 @@ acpi_status acpi_ns_internalize_name(char *external_name, char **converted_name)
        info.internal_name = internal_name;
        status = acpi_ns_build_internal_name(&info);
        if (ACPI_FAILURE(status)) {
-               ACPI_MEM_FREE(internal_name);
+               ACPI_FREE(internal_name);
                return_ACPI_STATUS(status);
        }
 
@@ -632,7 +632,7 @@ acpi_ns_externalize_name(u32 internal_name_length,
        /*
         * Build converted_name
         */
-       *converted_name = ACPI_MEM_CALLOCATE(required_length);
+       *converted_name = ACPI_ALLOCATE_ZEROED(required_length);
        if (!(*converted_name)) {
                return_ACPI_STATUS(AE_NO_MEMORY);
        }
@@ -879,7 +879,7 @@ acpi_ns_get_node_by_path(char *pathname,
 
       cleanup:
        if (internal_path) {
-               ACPI_MEM_FREE(internal_path);
+               ACPI_FREE(internal_path);
        }
        return_ACPI_STATUS(status);
 }
index 71e7769..7cdedc9 100644 (file)
@@ -42,8 +42,6 @@
  * POSSIBILITY OF SUCH DAMAGES.
  */
 
-#include <linux/module.h>
-
 #include <acpi/acpi.h>
 #include <acpi/acnamesp.h>
 #include <acpi/acinterp.h>
@@ -51,6 +49,7 @@
 #define _COMPONENT          ACPI_NAMESPACE
 ACPI_MODULE_NAME("nsxfeval")
 
+#ifdef ACPI_FUTURE_USAGE
 /*******************************************************************************
  *
  * FUNCTION:    acpi_evaluate_object_typed
@@ -71,12 +70,11 @@ ACPI_MODULE_NAME("nsxfeval")
  *              be valid (non-null)
  *
  ******************************************************************************/
-#ifdef ACPI_FUTURE_USAGE
 acpi_status
 acpi_evaluate_object_typed(acpi_handle handle,
                           acpi_string pathname,
-                          struct acpi_object_list *external_params,
-                          struct acpi_buffer *return_buffer,
+                          struct acpi_object_list * external_params,
+                          struct acpi_buffer * return_buffer,
                           acpi_object_type return_type)
 {
        acpi_status status;
@@ -142,6 +140,8 @@ acpi_evaluate_object_typed(acpi_handle handle,
        return_buffer->length = 0;
        return_ACPI_STATUS(AE_TYPE);
 }
+
+ACPI_EXPORT_SYMBOL(acpi_evaluate_object_typed)
 #endif                         /*  ACPI_FUTURE_USAGE  */
 
 /*******************************************************************************
@@ -163,7 +163,6 @@ acpi_evaluate_object_typed(acpi_handle handle,
  *              be valid (non-null)
  *
  ******************************************************************************/
-
 acpi_status
 acpi_evaluate_object(acpi_handle handle,
                     acpi_string pathname,
@@ -193,9 +192,9 @@ acpi_evaluate_object(acpi_handle handle,
                 * Allocate a new parameter block for the internal objects
                 * Add 1 to count to allow for null terminated internal list
                 */
-               info.parameters = ACPI_MEM_CALLOCATE(((acpi_size)
-                                                     external_params->count +
-                                                     1) * sizeof(void *));
+               info.parameters = ACPI_ALLOCATE_ZEROED(((acpi_size)
+                                                       external_params->count +
+                                                       1) * sizeof(void *));
                if (!info.parameters) {
                        return_ACPI_STATUS(AE_NO_MEMORY);
                }
@@ -356,7 +355,7 @@ acpi_evaluate_object(acpi_handle handle,
        return_ACPI_STATUS(status);
 }
 
-EXPORT_SYMBOL(acpi_evaluate_object);
+ACPI_EXPORT_SYMBOL(acpi_evaluate_object)
 
 /*******************************************************************************
  *
@@ -387,7 +386,6 @@ EXPORT_SYMBOL(acpi_evaluate_object);
  *              function, etc.
  *
  ******************************************************************************/
-
 acpi_status
 acpi_walk_namespace(acpi_object_type type,
                    acpi_handle start_object,
@@ -424,7 +422,7 @@ acpi_walk_namespace(acpi_object_type type,
        return_ACPI_STATUS(status);
 }
 
-EXPORT_SYMBOL(acpi_walk_namespace);
+ACPI_EXPORT_SYMBOL(acpi_walk_namespace)
 
 /*******************************************************************************
  *
@@ -439,7 +437,6 @@ EXPORT_SYMBOL(acpi_walk_namespace);
  *              on that.
  *
  ******************************************************************************/
-
 static acpi_status
 acpi_ns_get_device_callback(acpi_handle obj_handle,
                            u32 nesting_level,
@@ -510,11 +507,11 @@ acpi_ns_get_device_callback(acpi_handle obj_handle,
                                                 sizeof(struct
                                                        acpi_compatible_id)) !=
                                    0) {
-                                       ACPI_MEM_FREE(cid);
+                                       ACPI_FREE(cid);
                                        return (AE_OK);
                                }
                        }
-                       ACPI_MEM_FREE(cid);
+                       ACPI_FREE(cid);
                }
        }
 
@@ -592,7 +589,7 @@ acpi_get_devices(char *HID,
        return_ACPI_STATUS(status);
 }
 
-EXPORT_SYMBOL(acpi_get_devices);
+ACPI_EXPORT_SYMBOL(acpi_get_devices)
 
 /*******************************************************************************
  *
@@ -607,7 +604,6 @@ EXPORT_SYMBOL(acpi_get_devices);
  * DESCRIPTION: Attach arbitrary data and handler to a namespace node.
  *
  ******************************************************************************/
-
 acpi_status
 acpi_attach_data(acpi_handle obj_handle,
                 acpi_object_handler handler, void *data)
@@ -641,6 +637,8 @@ acpi_attach_data(acpi_handle obj_handle,
        return (status);
 }
 
+ACPI_EXPORT_SYMBOL(acpi_attach_data)
+
 /*******************************************************************************
  *
  * FUNCTION:    acpi_detach_data
@@ -653,7 +651,6 @@ acpi_attach_data(acpi_handle obj_handle,
  * DESCRIPTION: Remove data that was previously attached to a node.
  *
  ******************************************************************************/
-
 acpi_status
 acpi_detach_data(acpi_handle obj_handle, acpi_object_handler handler)
 {
@@ -686,6 +683,8 @@ acpi_detach_data(acpi_handle obj_handle, acpi_object_handler handler)
        return (status);
 }
 
+ACPI_EXPORT_SYMBOL(acpi_detach_data)
+
 /*******************************************************************************
  *
  * FUNCTION:    acpi_get_data
@@ -699,7 +698,6 @@ acpi_detach_data(acpi_handle obj_handle, acpi_object_handler handler)
  * DESCRIPTION: Retrieve data that was previously attached to a namespace node.
  *
  ******************************************************************************/
-
 acpi_status
 acpi_get_data(acpi_handle obj_handle, acpi_object_handler handler, void **data)
 {
@@ -731,3 +729,5 @@ acpi_get_data(acpi_handle obj_handle, acpi_object_handler handler, void **data)
        (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
        return (status);
 }
+
+ACPI_EXPORT_SYMBOL(acpi_get_data)
index 55d2662..1303e2b 100644 (file)
@@ -42,8 +42,6 @@
  * POSSIBILITY OF SUCH DAMAGES.
  */
 
-#include <linux/module.h>
-
 #include <acpi/acpi.h>
 #include <acpi/acnamesp.h>
 
@@ -126,7 +124,7 @@ acpi_get_handle(acpi_handle parent,
        return (status);
 }
 
-EXPORT_SYMBOL(acpi_get_handle);
+ACPI_EXPORT_SYMBOL(acpi_get_handle)
 
 /******************************************************************************
  *
@@ -143,7 +141,6 @@ EXPORT_SYMBOL(acpi_get_handle);
  *              complementary functions.
  *
  ******************************************************************************/
-
 acpi_status
 acpi_get_name(acpi_handle handle, u32 name_type, struct acpi_buffer * buffer)
 {
@@ -204,7 +201,7 @@ acpi_get_name(acpi_handle handle, u32 name_type, struct acpi_buffer * buffer)
        return (status);
 }
 
-EXPORT_SYMBOL(acpi_get_name);
+ACPI_EXPORT_SYMBOL(acpi_get_name)
 
 /******************************************************************************
  *
@@ -220,7 +217,6 @@ EXPORT_SYMBOL(acpi_get_name);
  *              control methods (Such as in the case of a device.)
  *
  ******************************************************************************/
-
 acpi_status
 acpi_get_object_info(acpi_handle handle, struct acpi_buffer * buffer)
 {
@@ -242,7 +238,7 @@ acpi_get_object_info(acpi_handle handle, struct acpi_buffer * buffer)
                return (status);
        }
 
-       info = ACPI_MEM_CALLOCATE(sizeof(struct acpi_device_info));
+       info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_device_info));
        if (!info) {
                return (AE_NO_MEMORY);
        }
@@ -346,11 +342,11 @@ acpi_get_object_info(acpi_handle handle, struct acpi_buffer * buffer)
        }
 
       cleanup:
-       ACPI_MEM_FREE(info);
+       ACPI_FREE(info);
        if (cid_list) {
-               ACPI_MEM_FREE(cid_list);
+               ACPI_FREE(cid_list);
        }
        return (status);
 }
 
-EXPORT_SYMBOL(acpi_get_object_info);
+ACPI_EXPORT_SYMBOL(acpi_get_object_info)
index 9c5f330..a163e1d 100644 (file)
@@ -42,8 +42,6 @@
  * POSSIBILITY OF SUCH DAMAGES.
  */
 
-#include <linux/module.h>
-
 #include <acpi/acpi.h>
 #include <acpi/acnamesp.h>
 
@@ -101,7 +99,7 @@ acpi_status acpi_get_type(acpi_handle handle, acpi_object_type * ret_type)
        return (status);
 }
 
-EXPORT_SYMBOL(acpi_get_type);
+ACPI_EXPORT_SYMBOL(acpi_get_type)
 
 /*******************************************************************************
  *
@@ -116,7 +114,6 @@ EXPORT_SYMBOL(acpi_get_type);
  *              Handle.
  *
  ******************************************************************************/
-
 acpi_status acpi_get_parent(acpi_handle handle, acpi_handle * ret_handle)
 {
        struct acpi_namespace_node *node;
@@ -162,7 +159,7 @@ acpi_status acpi_get_parent(acpi_handle handle, acpi_handle * ret_handle)
        return (status);
 }
 
-EXPORT_SYMBOL(acpi_get_parent);
+ACPI_EXPORT_SYMBOL(acpi_get_parent)
 
 /*******************************************************************************
  *
@@ -181,7 +178,6 @@ EXPORT_SYMBOL(acpi_get_parent);
  *              Scope is returned.
  *
  ******************************************************************************/
-
 acpi_status
 acpi_get_next_object(acpi_object_type type,
                     acpi_handle parent,
@@ -243,4 +239,4 @@ acpi_get_next_object(acpi_object_type type,
        return (status);
 }
 
-EXPORT_SYMBOL(acpi_get_next_object);
+ACPI_EXPORT_SYMBOL(acpi_get_next_object)
index 6aa0012..0015717 100644 (file)
@@ -306,5 +306,4 @@ union acpi_parse_object *acpi_ps_get_child(union acpi_parse_object *op)
        return (child);
 }
 #endif
-
 #endif                         /*  ACPI_FUTURE_USAGE  */
index d9ae64b..9e7ae2f 100644 (file)
@@ -141,6 +141,7 @@ struct acpi_rsdump_info *acpi_gbl_dump_resource_dispatch[] = {
        acpi_rs_dump_generic_reg,       /* ACPI_RESOURCE_TYPE_GENERIC_REGISTER */
 };
 #endif
+
 #endif /* ACPI_FUTURE_USAGE */
 /*
  * Base sizes for external AML resource descriptors, indexed by internal type.
index 2e1bc71..b3feebb 100644 (file)
@@ -41,8 +41,6 @@
  * POSSIBILITY OF SUCH DAMAGES.
  */
 
-#include <linux/module.h>
-
 #include <acpi/acpi.h>
 #include <acpi/acresrc.h>
 
@@ -118,6 +116,8 @@ acpi_get_irq_routing_table(acpi_handle device_handle,
        return_ACPI_STATUS(status);
 }
 
+ACPI_EXPORT_SYMBOL(acpi_get_irq_routing_table)
+
 /*******************************************************************************
  *
  * FUNCTION:    acpi_get_current_resources
@@ -141,7 +141,6 @@ acpi_get_irq_routing_table(acpi_handle device_handle,
  *              the object indicated by the passed device_handle.
  *
  ******************************************************************************/
-
 acpi_status
 acpi_get_current_resources(acpi_handle device_handle,
                           struct acpi_buffer *ret_buffer)
@@ -169,8 +168,9 @@ acpi_get_current_resources(acpi_handle device_handle,
        return_ACPI_STATUS(status);
 }
 
-EXPORT_SYMBOL(acpi_get_current_resources);
+ACPI_EXPORT_SYMBOL(acpi_get_current_resources)
 
+#ifdef ACPI_FUTURE_USAGE
 /*******************************************************************************
  *
  * FUNCTION:    acpi_get_possible_resources
@@ -191,8 +191,6 @@ EXPORT_SYMBOL(acpi_get_current_resources);
  *              and the value of ret_buffer is undefined.
  *
  ******************************************************************************/
-
-#ifdef ACPI_FUTURE_USAGE
 acpi_status
 acpi_get_possible_resources(acpi_handle device_handle,
                            struct acpi_buffer *ret_buffer)
@@ -220,7 +218,7 @@ acpi_get_possible_resources(acpi_handle device_handle,
        return_ACPI_STATUS(status);
 }
 
-EXPORT_SYMBOL(acpi_get_possible_resources);
+ACPI_EXPORT_SYMBOL(acpi_get_possible_resources)
 #endif                         /*  ACPI_FUTURE_USAGE  */
 
 /*******************************************************************************
@@ -241,7 +239,6 @@ EXPORT_SYMBOL(acpi_get_possible_resources);
  *              each resource in the list.
  *
  ******************************************************************************/
-
 acpi_status
 acpi_walk_resources(acpi_handle device_handle,
                    char *name,
@@ -313,11 +310,11 @@ acpi_walk_resources(acpi_handle device_handle,
                                 resource->length);
        }
 
-       ACPI_MEM_FREE(buffer.pointer);
+       ACPI_FREE(buffer.pointer);
        return_ACPI_STATUS(status);
 }
 
-EXPORT_SYMBOL(acpi_walk_resources);
+ACPI_EXPORT_SYMBOL(acpi_walk_resources)
 
 /*******************************************************************************
  *
@@ -336,7 +333,6 @@ EXPORT_SYMBOL(acpi_walk_resources);
  *              the buffer pointed to by the in_buffer variable.
  *
  ******************************************************************************/
-
 acpi_status
 acpi_set_current_resources(acpi_handle device_handle,
                           struct acpi_buffer *in_buffer)
@@ -356,7 +352,7 @@ acpi_set_current_resources(acpi_handle device_handle,
        return_ACPI_STATUS(status);
 }
 
-EXPORT_SYMBOL(acpi_set_current_resources);
+ACPI_EXPORT_SYMBOL(acpi_set_current_resources)
 
 /******************************************************************************
  *
@@ -375,7 +371,6 @@ EXPORT_SYMBOL(acpi_set_current_resources);
  *              addresses.
  *
  ******************************************************************************/
-
 acpi_status
 acpi_resource_to_address64(struct acpi_resource *resource,
                           struct acpi_resource_address64 *out)
@@ -417,7 +412,7 @@ acpi_resource_to_address64(struct acpi_resource *resource,
        return (AE_OK);
 }
 
-EXPORT_SYMBOL(acpi_resource_to_address64);
+ACPI_EXPORT_SYMBOL(acpi_resource_to_address64)
 
 /*******************************************************************************
  *
@@ -437,7 +432,6 @@ EXPORT_SYMBOL(acpi_resource_to_address64);
  *              UUID subtype. Returns a struct acpi_resource of type Vendor.
  *
  ******************************************************************************/
-
 acpi_status
 acpi_get_vendor_resource(acpi_handle device_handle,
                         char *name,
@@ -469,6 +463,8 @@ acpi_get_vendor_resource(acpi_handle device_handle,
        return (info.status);
 }
 
+ACPI_EXPORT_SYMBOL(acpi_get_vendor_resource)
+
 /*******************************************************************************
  *
  * FUNCTION:    acpi_rs_match_vendor_resource
@@ -480,7 +476,6 @@ acpi_get_vendor_resource(acpi_handle device_handle,
  * DESCRIPTION: Match a vendor resource via the ACPI 3.0 UUID
  *
  ******************************************************************************/
-
 static acpi_status
 acpi_rs_match_vendor_resource(struct acpi_resource *resource, void *context)
 {
@@ -528,3 +523,5 @@ acpi_rs_match_vendor_resource(struct acpi_resource *resource, void *context)
        info->status = AE_OK;
        return (AE_CTRL_TERMINATE);
 }
+
+ACPI_EXPORT_SYMBOL(acpi_rs_match_vendor_resource)
index 254ebdb..5155b27 100644 (file)
@@ -41,8 +41,6 @@
  * POSSIBILITY OF SUCH DAMAGES.
  */
 
-#include <linux/module.h>
-
 #include <acpi/acpi.h>
 #include <acpi/actables.h>
 
@@ -64,7 +62,7 @@ acpi_tb_convert_fadt2(struct fadt_descriptor_rev2 *local_fadt,
                      struct fadt_descriptor_rev2 *original_fadt);
 
 u8 acpi_fadt_is_v1;
-EXPORT_SYMBOL(acpi_fadt_is_v1);
+ACPI_EXPORT_SYMBOL(acpi_fadt_is_v1)
 
 /*******************************************************************************
  *
@@ -133,7 +131,7 @@ acpi_status acpi_tb_convert_to_xsdt(struct acpi_table_desc *table_info)
 
        /* Allocate an XSDT */
 
-       new_table = ACPI_MEM_CALLOCATE(table_size);
+       new_table = ACPI_ALLOCATE_ZEROED(table_size);
        if (!new_table) {
                return (AE_NO_MEMORY);
        }
@@ -509,7 +507,7 @@ acpi_status acpi_tb_convert_table_fadt(void)
 
        /* Allocate buffer for the ACPI 2.0(+) FADT */
 
-       local_fadt = ACPI_MEM_CALLOCATE(sizeof(struct fadt_descriptor_rev2));
+       local_fadt = ACPI_ALLOCATE_ZEROED(sizeof(struct fadt_descriptor_rev2));
        if (!local_fadt) {
                return_ACPI_STATUS(AE_NO_MEMORY);
        }
index 4615e1a..b7bd20b 100644 (file)
@@ -330,7 +330,7 @@ acpi_tb_get_this_table(struct acpi_pointer *address,
 
                /* Pointer matches processor mode, copy the table to a new buffer */
 
-               full_table = ACPI_MEM_ALLOCATE(header->length);
+               full_table = ACPI_ALLOCATE(header->length);
                if (!full_table) {
                        ACPI_ERROR((AE_INFO,
                                    "Could not allocate table memory for [%4.4s] length %X",
index ec2cb97..ce57a19 100644 (file)
@@ -248,7 +248,7 @@ acpi_tb_init_table_descriptor(acpi_table_type table_type,
 
        /* Allocate a descriptor for this table */
 
-       table_desc = ACPI_MEM_CALLOCATE(sizeof(struct acpi_table_desc));
+       table_desc = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_table_desc));
        if (!table_desc) {
                return_ACPI_STATUS(AE_NO_MEMORY);
        }
@@ -275,7 +275,7 @@ acpi_tb_init_table_descriptor(acpi_table_type table_type,
                 * at this location, so return an error.
                 */
                if (list_head->next) {
-                       ACPI_MEM_FREE(table_desc);
+                       ACPI_FREE(table_desc);
                        return_ACPI_STATUS(AE_ALREADY_EXISTS);
                }
 
@@ -472,7 +472,7 @@ void acpi_tb_delete_single_table(struct acpi_table_desc *table_desc)
 
        case ACPI_MEM_ALLOCATED:
 
-               ACPI_MEM_FREE(table_desc->pointer);
+               ACPI_FREE(table_desc->pointer);
                break;
 
        case ACPI_MEM_MAPPED:
@@ -531,7 +531,7 @@ struct acpi_table_desc *acpi_tb_uninstall_table(struct acpi_table_desc
        /* Free the table descriptor */
 
        next_desc = table_desc->next;
-       ACPI_MEM_FREE(table_desc);
+       ACPI_FREE(table_desc);
 
        /* Return pointer to the next descriptor */
 
index 3e902cd..53c627e 100644 (file)
@@ -42,8 +42,6 @@
  * POSSIBILITY OF SUCH DAMAGES.
  */
 
-#include <linux/module.h>
-
 #include <acpi/acpi.h>
 #include <acpi/acnamesp.h>
 #include <acpi/actables.h>
@@ -123,6 +121,8 @@ acpi_status acpi_load_tables(void)
        return_ACPI_STATUS(status);
 }
 
+ACPI_EXPORT_SYMBOL(acpi_load_tables)
+
 #ifdef ACPI_FUTURE_USAGE
 /*******************************************************************************
  *
@@ -139,7 +139,6 @@ acpi_status acpi_load_tables(void)
  *              is determined that the table is invalid, the call will fail.
  *
  ******************************************************************************/
-
 acpi_status acpi_load_table(struct acpi_table_header *table_ptr)
 {
        acpi_status status;
@@ -218,6 +217,8 @@ acpi_status acpi_load_table(struct acpi_table_header *table_ptr)
        return_ACPI_STATUS(status);
 }
 
+ACPI_EXPORT_SYMBOL(acpi_load_table)
+
 /*******************************************************************************
  *
  * FUNCTION:    acpi_unload_table
@@ -229,7 +230,6 @@ acpi_status acpi_load_table(struct acpi_table_header *table_ptr)
  * DESCRIPTION: This routine is used to force the unload of a table
  *
  ******************************************************************************/
-
 acpi_status acpi_unload_table(acpi_table_type table_type)
 {
        struct acpi_table_desc *table_desc;
@@ -263,6 +263,8 @@ acpi_status acpi_unload_table(acpi_table_type table_type)
        return_ACPI_STATUS(AE_OK);
 }
 
+ACPI_EXPORT_SYMBOL(acpi_unload_table)
+
 /*******************************************************************************
  *
  * FUNCTION:    acpi_get_table_header
@@ -283,7 +285,6 @@ acpi_status acpi_unload_table(acpi_table_type table_type)
  *              have a standard header and is fixed length.
  *
  ******************************************************************************/
-
 acpi_status
 acpi_get_table_header(acpi_table_type table_type,
                      u32 instance, struct acpi_table_header *out_table_header)
@@ -327,6 +328,7 @@ acpi_get_table_header(acpi_table_type table_type,
        return_ACPI_STATUS(status);
 }
 
+ACPI_EXPORT_SYMBOL(acpi_get_table_header)
 #endif                         /*  ACPI_FUTURE_USAGE  */
 
 /*******************************************************************************
@@ -351,7 +353,6 @@ acpi_get_table_header(acpi_table_type table_type,
  *              a complete table including the header.
  *
  ******************************************************************************/
-
 acpi_status
 acpi_get_table(acpi_table_type table_type,
               u32 instance, struct acpi_buffer *ret_buffer)
@@ -420,4 +421,4 @@ acpi_get_table(acpi_table_type table_type,
        return_ACPI_STATUS(AE_OK);
 }
 
-EXPORT_SYMBOL(acpi_get_table);
+ACPI_EXPORT_SYMBOL(acpi_get_table)
index 7f68b75..1b6d8c5 100644 (file)
@@ -41,8 +41,6 @@
  * POSSIBILITY OF SUCH DAMAGES.
  */
 
-#include <linux/module.h>
-
 #include <acpi/acpi.h>
 #include <acpi/actables.h>
 
@@ -263,7 +261,7 @@ acpi_get_firmware_table(acpi_string signature,
 
        /* Get and validate the RSDT */
 
-       rsdt_info = ACPI_MEM_CALLOCATE(sizeof(struct acpi_table_desc));
+       rsdt_info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_table_desc));
        if (!rsdt_info) {
                return_ACPI_STATUS(AE_NO_MEMORY);
        }
@@ -280,13 +278,13 @@ acpi_get_firmware_table(acpi_string signature,
 
        /* Allocate a scratch table header and table descriptor */
 
-       header = ACPI_MEM_ALLOCATE(sizeof(struct acpi_table_header));
+       header = ACPI_ALLOCATE(sizeof(struct acpi_table_header));
        if (!header) {
                status = AE_NO_MEMORY;
                goto cleanup;
        }
 
-       table_info = ACPI_MEM_ALLOCATE(sizeof(struct acpi_table_desc));
+       table_info = ACPI_ALLOCATE(sizeof(struct acpi_table_desc));
        if (!table_info) {
                status = AE_NO_MEMORY;
                goto cleanup;
@@ -359,23 +357,21 @@ acpi_get_firmware_table(acpi_string signature,
                acpi_os_unmap_memory(rsdt_info->pointer,
                                     (acpi_size) rsdt_info->pointer->length);
        }
-       ACPI_MEM_FREE(rsdt_info);
+       ACPI_FREE(rsdt_info);
 
        if (header) {
-               ACPI_MEM_FREE(header);
+               ACPI_FREE(header);
        }
        if (table_info) {
-               ACPI_MEM_FREE(table_info);
+               ACPI_FREE(table_info);
        }
        return_ACPI_STATUS(status);
 }
 
-EXPORT_SYMBOL(acpi_get_firmware_table);
+ACPI_EXPORT_SYMBOL(acpi_get_firmware_table)
 
 /* TBD: Move to a new file */
-
 #if ACPI_MACHINE_WIDTH != 16
-
 /*******************************************************************************
  *
  * FUNCTION:    acpi_find_root_pointer
@@ -388,7 +384,6 @@ EXPORT_SYMBOL(acpi_get_firmware_table);
  * DESCRIPTION: Find the RSDP
  *
  ******************************************************************************/
-
 acpi_status acpi_find_root_pointer(u32 flags, struct acpi_pointer *rsdp_address)
 {
        struct acpi_table_desc table_info;
@@ -411,6 +406,8 @@ acpi_status acpi_find_root_pointer(u32 flags, struct acpi_pointer *rsdp_address)
        return_ACPI_STATUS(AE_OK);
 }
 
+ACPI_EXPORT_SYMBOL(acpi_find_root_pointer)
+
 /*******************************************************************************
  *
  * FUNCTION:    acpi_tb_scan_memory_for_rsdp
@@ -423,7 +420,6 @@ acpi_status acpi_find_root_pointer(u32 flags, struct acpi_pointer *rsdp_address)
  * DESCRIPTION: Search a block of memory for the RSDP signature
  *
  ******************************************************************************/
-
 static u8 *acpi_tb_scan_memory_for_rsdp(u8 * start_address, u32 length)
 {
        acpi_status status;
index 34de379..7b35eb8 100644 (file)
@@ -252,7 +252,7 @@ acpi_ut_initialize_buffer(struct acpi_buffer * buffer,
 
                /* Allocate a new buffer with local interface to allow tracking */
 
-               buffer->pointer = ACPI_MEM_CALLOCATE(required_length);
+               buffer->pointer = ACPI_ALLOCATE_ZEROED(required_length);
                if (!buffer->pointer) {
                        return (AE_NO_MEMORY);
                }
index 044c890..5d2f4b2 100644 (file)
@@ -125,7 +125,7 @@ acpi_status acpi_os_purge_cache(struct acpi_memory_list * cache)
                                                &(((char *)cache->
                                                   list_head)[cache->
                                                              link_offset])));
-               ACPI_MEM_FREE(cache->list_head);
+               ACPI_FREE(cache->list_head);
 
                cache->list_head = next;
                cache->current_depth--;
@@ -194,7 +194,7 @@ acpi_os_release_object(struct acpi_memory_list * cache, void *object)
        /* If cache is full, just free this object */
 
        if (cache->current_depth >= cache->max_depth) {
-               ACPI_MEM_FREE(object);
+               ACPI_FREE(object);
                ACPI_MEM_TRACKING(cache->total_freed++);
        }
 
@@ -289,14 +289,14 @@ void *acpi_os_acquire_object(struct acpi_memory_list *cache)
 
                ACPI_MEM_TRACKING(cache->total_allocated++);
 
-               /* Avoid deadlock with ACPI_MEM_CALLOCATE */
+               /* Avoid deadlock with ACPI_ALLOCATE_ZEROED */
 
                status = acpi_ut_release_mutex(ACPI_MTX_CACHES);
                if (ACPI_FAILURE(status)) {
                        return (NULL);
                }
 
-               object = ACPI_MEM_CALLOCATE(cache->object_size);
+               object = ACPI_ALLOCATE_ZEROED(cache->object_size);
                if (!object) {
                        return (NULL);
                }
index 4787593..371cddc 100644 (file)
@@ -472,8 +472,8 @@ acpi_ut_copy_esimple_to_isimple(union acpi_object *external_object,
        case ACPI_TYPE_STRING:
 
                internal_object->string.pointer =
-                   ACPI_MEM_CALLOCATE((acpi_size) external_object->string.
-                                      length + 1);
+                   ACPI_ALLOCATE_ZEROED((acpi_size) external_object->string.
+                                        length + 1);
                if (!internal_object->string.pointer) {
                        goto error_exit;
                }
@@ -488,7 +488,7 @@ acpi_ut_copy_esimple_to_isimple(union acpi_object *external_object,
        case ACPI_TYPE_BUFFER:
 
                internal_object->buffer.pointer =
-                   ACPI_MEM_CALLOCATE(external_object->buffer.length);
+                   ACPI_ALLOCATE_ZEROED(external_object->buffer.length);
                if (!internal_object->buffer.pointer) {
                        goto error_exit;
                }
@@ -676,7 +676,7 @@ acpi_ut_copy_simple_object(union acpi_operand_object *source_desc,
                if ((source_desc->buffer.pointer) &&
                    (source_desc->buffer.length)) {
                        dest_desc->buffer.pointer =
-                           ACPI_MEM_ALLOCATE(source_desc->buffer.length);
+                           ACPI_ALLOCATE(source_desc->buffer.length);
                        if (!dest_desc->buffer.pointer) {
                                return (AE_NO_MEMORY);
                        }
@@ -697,8 +697,8 @@ acpi_ut_copy_simple_object(union acpi_operand_object *source_desc,
                 */
                if (source_desc->string.pointer) {
                        dest_desc->string.pointer =
-                           ACPI_MEM_ALLOCATE((acpi_size) source_desc->string.
-                                             length + 1);
+                           ACPI_ALLOCATE((acpi_size) source_desc->string.
+                                         length + 1);
                        if (!dest_desc->string.pointer) {
                                return (AE_NO_MEMORY);
                        }
@@ -805,9 +805,7 @@ acpi_ut_copy_ielement_to_ielement(u8 object_type,
                /*
                 * Create the object array
                 */
-               target_object->package.elements =
-                   ACPI_MEM_CALLOCATE(((acpi_size) source_object->package.
-                                       count + 1) * sizeof(void *));
+               target_object->package.elements = ACPI_ALLOCATE_ZEROED(((acpi_size) source_object->package.count + 1) * sizeof(void *));
                if (!target_object->package.elements) {
                        status = AE_NO_MEMORY;
                        goto error_exit;
@@ -865,10 +863,10 @@ acpi_ut_copy_ipackage_to_ipackage(union acpi_operand_object *source_obj,
        /*
         * Create the object array and walk the source package tree
         */
-       dest_obj->package.elements = ACPI_MEM_CALLOCATE(((acpi_size)
-                                                        source_obj->package.
-                                                        count +
-                                                        1) * sizeof(void *));
+       dest_obj->package.elements = ACPI_ALLOCATE_ZEROED(((acpi_size)
+                                                          source_obj->package.
+                                                          count +
+                                                          1) * sizeof(void *));
        if (!dest_obj->package.elements) {
                ACPI_ERROR((AE_INFO, "Package allocation failure"));
                return_ACPI_STATUS(AE_NO_MEMORY);
index 6e92b2a..a8c3506 100644 (file)
@@ -41,8 +41,6 @@
  * POSSIBILITY OF SUCH DAMAGES.
  */
 
-#include <linux/module.h>
-
 #include <acpi/acpi.h>
 
 #define _COMPONENT          ACPI_UTILITIES
@@ -164,7 +162,7 @@ acpi_ut_debug_print(u32 requested_debug_level,
                    const char *function_name,
                    char *module_name, u32 component_id, char *format, ...)
 {
-       u32 thread_id;
+       acpi_thread_id thread_id;
        va_list args;
 
        /*
@@ -179,7 +177,6 @@ acpi_ut_debug_print(u32 requested_debug_level,
         * Thread tracking and context switch notification
         */
        thread_id = acpi_os_get_thread_id();
-
        if (thread_id != acpi_gbl_prev_thread_id) {
                if (ACPI_LV_THREADS & acpi_dbg_level) {
                        acpi_os_printf
@@ -208,7 +205,7 @@ acpi_ut_debug_print(u32 requested_debug_level,
        acpi_os_vprintf(format, args);
 }
 
-EXPORT_SYMBOL(acpi_ut_debug_print);
+ACPI_EXPORT_SYMBOL(acpi_ut_debug_print)
 
 /*******************************************************************************
  *
@@ -228,7 +225,6 @@ EXPORT_SYMBOL(acpi_ut_debug_print);
  *              debug_print so that the same macros can be used.
  *
  ******************************************************************************/
-
 void ACPI_INTERNAL_VAR_XFACE
 acpi_ut_debug_print_raw(u32 requested_debug_level,
                        u32 line_number,
@@ -246,7 +242,7 @@ acpi_ut_debug_print_raw(u32 requested_debug_level,
        acpi_os_vprintf(format, args);
 }
 
-EXPORT_SYMBOL(acpi_ut_debug_print_raw);
+ACPI_EXPORT_SYMBOL(acpi_ut_debug_print_raw)
 
 /*******************************************************************************
  *
@@ -263,7 +259,6 @@ EXPORT_SYMBOL(acpi_ut_debug_print_raw);
  *              set in debug_level
  *
  ******************************************************************************/
-
 void
 acpi_ut_trace(u32 line_number,
              const char *function_name, char *module_name, u32 component_id)
@@ -277,7 +272,7 @@ acpi_ut_trace(u32 line_number,
                            component_id, "%s\n", acpi_gbl_fn_entry_str);
 }
 
-EXPORT_SYMBOL(acpi_ut_trace);
+ACPI_EXPORT_SYMBOL(acpi_ut_trace)
 
 /*******************************************************************************
  *
@@ -295,7 +290,6 @@ EXPORT_SYMBOL(acpi_ut_trace);
  *              set in debug_level
  *
  ******************************************************************************/
-
 void
 acpi_ut_trace_ptr(u32 line_number,
                  const char *function_name,
@@ -402,7 +396,7 @@ acpi_ut_exit(u32 line_number,
        acpi_gbl_nesting_level--;
 }
 
-EXPORT_SYMBOL(acpi_ut_exit);
+ACPI_EXPORT_SYMBOL(acpi_ut_exit)
 
 /*******************************************************************************
  *
@@ -420,7 +414,6 @@ EXPORT_SYMBOL(acpi_ut_exit);
  *              set in debug_level. Prints exit status also.
  *
  ******************************************************************************/
-
 void
 acpi_ut_status_exit(u32 line_number,
                    const char *function_name,
@@ -444,7 +437,7 @@ acpi_ut_status_exit(u32 line_number,
        acpi_gbl_nesting_level--;
 }
 
-EXPORT_SYMBOL(acpi_ut_status_exit);
+ACPI_EXPORT_SYMBOL(acpi_ut_status_exit)
 
 /*******************************************************************************
  *
@@ -462,7 +455,6 @@ EXPORT_SYMBOL(acpi_ut_status_exit);
  *              set in debug_level. Prints exit value also.
  *
  ******************************************************************************/
-
 void
 acpi_ut_value_exit(u32 line_number,
                   const char *function_name,
@@ -477,7 +469,7 @@ acpi_ut_value_exit(u32 line_number,
        acpi_gbl_nesting_level--;
 }
 
-EXPORT_SYMBOL(acpi_ut_value_exit);
+ACPI_EXPORT_SYMBOL(acpi_ut_value_exit)
 
 /*******************************************************************************
  *
@@ -495,7 +487,6 @@ EXPORT_SYMBOL(acpi_ut_value_exit);
  *              set in debug_level. Prints exit value also.
  *
  ******************************************************************************/
-
 void
 acpi_ut_ptr_exit(u32 line_number,
                 const char *function_name,
index dbae721..9c6867f 100644 (file)
@@ -236,7 +236,7 @@ static void acpi_ut_delete_internal_obj(union acpi_operand_object *object)
        if (obj_pointer) {
                ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
                                  "Deleting Object Subptr %p\n", obj_pointer));
-               ACPI_MEM_FREE(obj_pointer);
+               ACPI_FREE(obj_pointer);
        }
 
        /* Now the object can be safely deleted */
@@ -275,7 +275,7 @@ void acpi_ut_delete_internal_object_list(union acpi_operand_object **obj_list)
 
        /* Free the combined parameter pointer list and object array */
 
-       ACPI_MEM_FREE(obj_list);
+       ACPI_FREE(obj_list);
        return_VOID;
 }
 
index 952ffde..68b9eff 100644 (file)
@@ -461,7 +461,7 @@ acpi_ut_execute_CID(struct acpi_namespace_node * device_node,
        size = (((count - 1) * sizeof(struct acpi_compatible_id)) +
                sizeof(struct acpi_compatible_id_list));
 
-       cid_list = ACPI_MEM_CALLOCATE((acpi_size) size);
+       cid_list = ACPI_ALLOCATE_ZEROED((acpi_size) size);
        if (!cid_list) {
                return_ACPI_STATUS(AE_NO_MEMORY);
        }
@@ -502,7 +502,7 @@ acpi_ut_execute_CID(struct acpi_namespace_node * device_node,
        /* Cleanup on error */
 
        if (ACPI_FAILURE(status)) {
-               ACPI_MEM_FREE(cid_list);
+               ACPI_FREE(cid_list);
        } else {
                *return_cid_list = cid_list;
        }
index 767c5e4..5bc8da7 100644 (file)
@@ -43,7 +43,6 @@
 
 #define DEFINE_ACPI_GLOBALS
 
-#include <linux/module.h>
 #include <acpi/acpi.h>
 #include <acpi/acnamesp.h>
 
@@ -144,12 +143,10 @@ const char *acpi_format_exception(acpi_status status)
 
 /* Debug switch - level and trace mask */
 u32 acpi_dbg_level = ACPI_DEBUG_DEFAULT;
-EXPORT_SYMBOL(acpi_dbg_level);
 
 /* Debug switch - layer (component) mask */
 
 u32 acpi_dbg_layer = ACPI_COMPONENT_DEFAULT | ACPI_ALL_DRIVERS;
-EXPORT_SYMBOL(acpi_dbg_layer);
 u32 acpi_gbl_nesting_level = 0;
 
 /* Debugger globals */
@@ -871,3 +868,6 @@ void acpi_ut_init_globals(void)
 
        return_VOID;
 }
+
+ACPI_EXPORT_SYMBOL(acpi_dbg_level)
+ACPI_EXPORT_SYMBOL(acpi_dbg_layer)
index ba771b4..40313de 100644 (file)
@@ -186,14 +186,14 @@ static void acpi_ut_terminate(void)
                gpe_block = gpe_xrupt_info->gpe_block_list_head;
                while (gpe_block) {
                        next_gpe_block = gpe_block->next;
-                       ACPI_MEM_FREE(gpe_block->event_info);
-                       ACPI_MEM_FREE(gpe_block->register_info);
-                       ACPI_MEM_FREE(gpe_block);
+                       ACPI_FREE(gpe_block->event_info);
+                       ACPI_FREE(gpe_block->register_info);
+                       ACPI_FREE(gpe_block);
 
                        gpe_block = next_gpe_block;
                }
                next_gpe_xrupt_info = gpe_xrupt_info->next;
-               ACPI_MEM_FREE(gpe_xrupt_info);
+               ACPI_FREE(gpe_xrupt_info);
                gpe_xrupt_info = next_gpe_xrupt_info;
        }
 
index 60f3613..77268ba 100644 (file)
@@ -463,7 +463,7 @@ acpi_ut_display_init_pathname(u8 type,
        }
        acpi_os_printf("\n");
 
-       ACPI_MEM_FREE(buffer.pointer);
+       ACPI_FREE(buffer.pointer);
 }
 #endif
 
index 45a7244..0ac6700 100644 (file)
@@ -192,7 +192,7 @@ static acpi_status acpi_ut_delete_mutex(acpi_mutex_handle mutex_id)
 acpi_status acpi_ut_acquire_mutex(acpi_mutex_handle mutex_id)
 {
        acpi_status status;
-       u32 this_thread_id;
+       acpi_thread_id this_thread_id;
 
        ACPI_FUNCTION_NAME("ut_acquire_mutex");
 
@@ -275,7 +275,7 @@ acpi_status acpi_ut_acquire_mutex(acpi_mutex_handle mutex_id)
 acpi_status acpi_ut_release_mutex(acpi_mutex_handle mutex_id)
 {
        acpi_status status;
-       u32 this_thread_id;
+       acpi_thread_id this_thread_id;
 
        ACPI_FUNCTION_NAME("ut_release_mutex");
 
index b1205a5..8e3dcbd 100644 (file)
@@ -176,7 +176,7 @@ union acpi_operand_object *acpi_ut_create_buffer_object(acpi_size buffer_size)
 
                /* Allocate the actual buffer */
 
-               buffer = ACPI_MEM_CALLOCATE(buffer_size);
+               buffer = ACPI_ALLOCATE_ZEROED(buffer_size);
                if (!buffer) {
                        ACPI_ERROR((AE_INFO, "Could not allocate size %X",
                                    (u32) buffer_size));
@@ -228,7 +228,7 @@ union acpi_operand_object *acpi_ut_create_string_object(acpi_size string_size)
         * Allocate the actual string buffer -- (Size + 1) for NULL terminator.
         * NOTE: Zero-length strings are NULL terminated
         */
-       string = ACPI_MEM_CALLOCATE(string_size + 1);
+       string = ACPI_ALLOCATE_ZEROED(string_size + 1);
        if (!string) {
                ACPI_ERROR((AE_INFO, "Could not allocate size %X",
                            (u32) string_size));
@@ -320,6 +320,7 @@ void *acpi_ut_allocate_object_desc_dbg(char *module_name,
        }
 
        /* Mark the descriptor type */
+
        memset(object, 0, sizeof(union acpi_operand_object));
        ACPI_SET_DESCRIPTOR_TYPE(object, ACPI_DESC_TYPE_OPERAND);
 
index 308a960..ac90048 100644 (file)
@@ -41,8 +41,6 @@
  * POSSIBILITY OF SUCH DAMAGES.
  */
 
-#include <linux/module.h>
-
 #include <acpi/acpi.h>
 #include <acpi/acevents.h>
 #include <acpi/acnamesp.h>
@@ -109,6 +107,8 @@ acpi_status acpi_initialize_subsystem(void)
        return_ACPI_STATUS(status);
 }
 
+ACPI_EXPORT_SYMBOL(acpi_initialize_subsystem)
+
 /*******************************************************************************
  *
  * FUNCTION:    acpi_enable_subsystem
@@ -121,7 +121,6 @@ acpi_status acpi_initialize_subsystem(void)
  *              Puts system into ACPI mode if it isn't already.
  *
  ******************************************************************************/
-
 acpi_status acpi_enable_subsystem(u32 flags)
 {
        acpi_status status = AE_OK;
@@ -229,6 +228,8 @@ acpi_status acpi_enable_subsystem(u32 flags)
        return_ACPI_STATUS(status);
 }
 
+ACPI_EXPORT_SYMBOL(acpi_enable_subsystem)
+
 /*******************************************************************************
  *
  * FUNCTION:    acpi_initialize_objects
@@ -241,7 +242,6 @@ acpi_status acpi_enable_subsystem(u32 flags)
  *              objects and executing AML code for Regions, buffers, etc.
  *
  ******************************************************************************/
-
 acpi_status acpi_initialize_objects(u32 flags)
 {
        acpi_status status = AE_OK;
@@ -305,6 +305,8 @@ acpi_status acpi_initialize_objects(u32 flags)
        return_ACPI_STATUS(status);
 }
 
+ACPI_EXPORT_SYMBOL(acpi_initialize_objects)
+
 /*******************************************************************************
  *
  * FUNCTION:    acpi_terminate
@@ -316,7 +318,6 @@ acpi_status acpi_initialize_objects(u32 flags)
  * DESCRIPTION: Shutdown the ACPI subsystem.  Release all resources.
  *
  ******************************************************************************/
-
 acpi_status acpi_terminate(void)
 {
        acpi_status status;
@@ -348,6 +349,8 @@ acpi_status acpi_terminate(void)
        return_ACPI_STATUS(status);
 }
 
+ACPI_EXPORT_SYMBOL(acpi_terminate)
+
 #ifdef ACPI_FUTURE_USAGE
 /*******************************************************************************
  *
@@ -362,7 +365,6 @@ acpi_status acpi_terminate(void)
  *              initialized successfully.
  *
  ******************************************************************************/
-
 acpi_status acpi_subsystem_status(void)
 {
 
@@ -373,6 +375,8 @@ acpi_status acpi_subsystem_status(void)
        }
 }
 
+ACPI_EXPORT_SYMBOL(acpi_subsystem_status)
+
 /*******************************************************************************
  *
  * FUNCTION:    acpi_get_system_info
@@ -390,7 +394,6 @@ acpi_status acpi_subsystem_status(void)
  *              and the value of out_buffer is undefined.
  *
  ******************************************************************************/
-
 acpi_status acpi_get_system_info(struct acpi_buffer * out_buffer)
 {
        struct acpi_system_info *info_ptr;
@@ -456,7 +459,7 @@ acpi_status acpi_get_system_info(struct acpi_buffer * out_buffer)
        return_ACPI_STATUS(AE_OK);
 }
 
-EXPORT_SYMBOL(acpi_get_system_info);
+ACPI_EXPORT_SYMBOL(acpi_get_system_info)
 
 /*****************************************************************************
  *
@@ -472,7 +475,6 @@ EXPORT_SYMBOL(acpi_get_system_info);
  * TBD: When a second function is added, must save the Function also.
  *
  ****************************************************************************/
-
 acpi_status
 acpi_install_initialization_handler(acpi_init_handler handler, u32 function)
 {
@@ -489,6 +491,7 @@ acpi_install_initialization_handler(acpi_init_handler handler, u32 function)
        return AE_OK;
 }
 
+ACPI_EXPORT_SYMBOL(acpi_install_initialization_handler)
 #endif                         /*  ACPI_FUTURE_USAGE  */
 
 /*****************************************************************************
@@ -502,7 +505,6 @@ acpi_install_initialization_handler(acpi_init_handler handler, u32 function)
  * DESCRIPTION: Empty all caches (delete the cached objects)
  *
  ****************************************************************************/
-
 acpi_status acpi_purge_cached_objects(void)
 {
        ACPI_FUNCTION_TRACE("acpi_purge_cached_objects");
@@ -513,3 +515,5 @@ acpi_status acpi_purge_cached_objects(void)
        (void)acpi_os_purge_cache(acpi_gbl_ps_node_ext_cache);
        return_ACPI_STATUS(AE_OK);
 }
+
+ACPI_EXPORT_SYMBOL(acpi_purge_cached_objects)
index 7885022..ebe793f 100644 (file)
@@ -63,7 +63,7 @@
 
 /* Current ACPICA subsystem version in YYYYMMDD format */
 
-#define ACPI_CA_VERSION                 0x20060217
+#define ACPI_CA_VERSION                 0x20060310
 
 /*
  * OS name, used for the _OS object.  The _OS object is essentially obsolete,
 
 #define ACPI_MAX_SEMAPHORE_COUNT        256
 
-/* Max reference count (for debug only) */
+/* Maximum object reference count (detects object deletion issues) */
 
-#define ACPI_MAX_REFERENCE_COUNT        0x400
+#define ACPI_MAX_REFERENCE_COUNT        0x800
 
 /* Size of cached memory mapping for system memory operation region */
 
index 0727c13..f004461 100644 (file)
@@ -50,6 +50,7 @@
 #define BLOCK_PAREN             1
 #define BLOCK_BRACE             2
 #define BLOCK_COMMA_LIST        4
+#define ACPI_DEFAULT_RESNAME    *(u32 *) "__RD"
 
 struct acpi_external_list {
        char *path;
@@ -78,6 +79,11 @@ typedef
 acpi_status(*asl_walk_callback) (union acpi_parse_object * op,
                                 u32 level, void *context);
 
+struct acpi_resource_tag {
+       u32 bit_index;
+       char *tag;
+};
+
 /*
  * dmwalk
  */
@@ -85,6 +91,11 @@ void
 acpi_dm_disassemble(struct acpi_walk_state *walk_state,
                    union acpi_parse_object *origin, u32 num_opcodes);
 
+void
+acpi_dm_walk_parse_tree(union acpi_parse_object *op,
+                       asl_walk_callback descending_callback,
+                       asl_walk_callback ascending_callback, void *context);
+
 /*
  * dmopcode
  */
@@ -167,6 +178,7 @@ void acpi_dm_dump_integer64(u64 value, char *name);
 
 void
 acpi_dm_resource_template(struct acpi_op_walk_info *info,
+                         union acpi_parse_object *op,
                          u8 * byte_data, u32 byte_count);
 
 u8 acpi_dm_is_resource_template(union acpi_parse_object *op);
@@ -177,6 +189,8 @@ void acpi_dm_bit_list(u16 mask);
 
 void acpi_dm_decode_attribute(u8 attribute);
 
+void acpi_dm_descriptor_name(void);
+
 /*
  * dmresrcl
  */
@@ -251,4 +265,13 @@ acpi_dm_vendor_small_descriptor(union aml_resource *resource,
  */
 void acpi_dm_add_to_external_list(char *path);
 
+/*
+ * dmrestag
+ */
+void acpi_dm_find_resources(union acpi_parse_object *root);
+
+void
+acpi_dm_check_resource_reference(union acpi_parse_object *op,
+                                struct acpi_walk_state *walk_state);
+
 #endif                         /* __ACDISASM_H__ */
index 8361820..94fbf96 100644 (file)
@@ -129,7 +129,7 @@ typedef u8 acpi_owner_id;
 struct acpi_mutex_info {
        acpi_mutex mutex;
        u32 use_count;
-       u32 thread_id;
+       acpi_thread_id thread_id;
 };
 
 /* Lock flag parameter for various interfaces */
@@ -181,9 +181,9 @@ struct acpi_namespace_node {
        u8 owner_id;            /* Who created this node */
        u8 flags;
 
-       /* Fields used by the ASL compiler only */
+       /* Fields used by the ASL compiler and disassembler only */
 
-#ifdef ACPI_ASL_COMPILER
+#ifdef ACPI_LARGE_NAMESPACE_NODE
        u32 value;
        union acpi_parse_object *op;
 #endif
@@ -479,7 +479,7 @@ struct acpi_pscope_state {
 struct acpi_thread_state {
        ACPI_STATE_COMMON struct acpi_walk_state *walk_state_list;      /* Head of list of walk_states for this thread */
        union acpi_operand_object *acquired_mutex_list; /* List of all currently acquired mutexes */
-       u32 thread_id;          /* Running thread ID */
+       acpi_thread_id thread_id;       /* Running thread ID */
        u8 current_sync_level;  /* Mutex Sync (nested acquire) level */
 };
 
index dd5644d..c8aa73f 100644 (file)
 
 /* Memory allocation */
 
-#define ACPI_MEM_ALLOCATE(a)            acpi_ut_allocate((acpi_size)(a),_COMPONENT,_acpi_module_name,__LINE__)
-#define ACPI_MEM_CALLOCATE(a)           acpi_ut_callocate((acpi_size)(a), _COMPONENT,_acpi_module_name,__LINE__)
-#define ACPI_MEM_FREE(a)                acpi_os_free(a)
+#define ACPI_ALLOCATE(a)            acpi_ut_allocate((acpi_size)(a),_COMPONENT,_acpi_module_name,__LINE__)
+#define ACPI_ALLOCATE_ZEROED(a)           acpi_ut_callocate((acpi_size)(a), _COMPONENT,_acpi_module_name,__LINE__)
+#define ACPI_FREE(a)                acpi_os_free(a)
 #define ACPI_MEM_TRACKING(a)
 
 #else
 
 /* Memory allocation */
 
-#define ACPI_MEM_ALLOCATE(a)            acpi_ut_allocate_and_track((acpi_size)(a),_COMPONENT,_acpi_module_name,__LINE__)
-#define ACPI_MEM_CALLOCATE(a)           acpi_ut_callocate_and_track((acpi_size)(a), _COMPONENT,_acpi_module_name,__LINE__)
-#define ACPI_MEM_FREE(a)                acpi_ut_free_and_track(a,_COMPONENT,_acpi_module_name,__LINE__)
+#define ACPI_ALLOCATE(a)            acpi_ut_allocate_and_track((acpi_size)(a),_COMPONENT,_acpi_module_name,__LINE__)
+#define ACPI_ALLOCATE_ZEROED(a)           acpi_ut_callocate_and_track((acpi_size)(a), _COMPONENT,_acpi_module_name,__LINE__)
+#define ACPI_FREE(a)                acpi_ut_free_and_track(a,_COMPONENT,_acpi_module_name,__LINE__)
 #define ACPI_MEM_TRACKING(a)            a
 
 #endif                         /* ACPI_DBG_TRACK_ALLOCATIONS */
index b667a80..132d64a 100644 (file)
@@ -63,6 +63,7 @@
 #define ACPI_NS_DONT_OPEN_SCOPE     0x02
 #define ACPI_NS_NO_PEER_SEARCH      0x04
 #define ACPI_NS_ERROR_IF_FOUND      0x08
+#define ACPI_NS_PREFIX_IS_SCOPE     0x10
 
 #define ACPI_NS_WALK_UNLOCK         TRUE
 #define ACPI_NS_WALK_NO_UNLOCK      FALSE
@@ -184,6 +185,10 @@ acpi_ns_evaluate_relative(char *pathname, struct acpi_parameter_info *info);
  */
 u32 acpi_ns_opens_scope(acpi_object_type type);
 
+void
+acpi_ns_build_external_path(struct acpi_namespace_node *node,
+                           acpi_size size, char *name_buffer);
+
 char *acpi_ns_get_external_pathname(struct acpi_namespace_node *node);
 
 char *acpi_ns_name_of_current_scope(struct acpi_walk_state *walk_state);
index 970e9a6..91c3cdf 100644 (file)
@@ -161,7 +161,7 @@ acpi_os_remove_interrupt_handler(u32 gsi, acpi_osd_handler service_routine);
 /*
  * Threads and Scheduling
  */
-u32 acpi_os_get_thread_id(void);
+acpi_thread_id acpi_os_get_thread_id(void);
 
 acpi_status
 acpi_os_queue_for_execution(u32 priority,
index 95c3c8b..520f315 100644 (file)
@@ -288,6 +288,21 @@ typedef acpi_native_uint acpi_size;
 #define ACPI_UNUSED_VAR
 #endif
 
+/*
+ * All ACPICA functions that are available to the rest of the kernel are
+ * tagged with this macro which can be defined as appropriate for the host.
+ */
+#ifndef ACPI_EXPORT_SYMBOL
+#define ACPI_EXPORT_SYMBOL(symbol)
+#endif
+
+/*
+ * thread_id is returned by acpi_os_get_thread_id.
+ */
+#ifndef acpi_thread_id
+#define acpi_thread_id                          acpi_native_uint
+#endif
+
 /*******************************************************************************
  *
  * Independent types
index fb47353..e5b42eb 100644 (file)
 #ifndef __AMLRESRC_H
 #define __AMLRESRC_H
 
-#define ASL_RESNAME_ADDRESS                     "_ADR"
-#define ASL_RESNAME_ALIGNMENT                   "_ALN"
-#define ASL_RESNAME_ADDRESSSPACE                "_ASI"
-#define ASL_RESNAME_ACCESSSIZE                  "_ASZ"
-#define ASL_RESNAME_TYPESPECIFICATTRIBUTES      "_ATT"
-#define ASL_RESNAME_BASEADDRESS                 "_BAS"
-#define ASL_RESNAME_BUSMASTER                   "_BM_" /* Master(1), Slave(0) */
-#define ASL_RESNAME_DECODE                      "_DEC"
-#define ASL_RESNAME_DMA                         "_DMA"
-#define ASL_RESNAME_DMATYPE                     "_TYP" /* Compatible(0), A(1), B(2), F(3) */
-#define ASL_RESNAME_GRANULARITY                 "_GRA"
-#define ASL_RESNAME_INTERRUPT                   "_INT"
-#define ASL_RESNAME_INTERRUPTLEVEL              "_LL_" /* active_lo(1), active_hi(0) */
-#define ASL_RESNAME_INTERRUPTSHARE              "_SHR" /* Shareable(1), no_share(0) */
-#define ASL_RESNAME_INTERRUPTTYPE               "_HE_" /* Edge(1), Level(0) */
-#define ASL_RESNAME_LENGTH                      "_LEN"
-#define ASL_RESNAME_MEMATTRIBUTES               "_MTP" /* Memory(0), Reserved(1), ACPI(2), NVS(3) */
-#define ASL_RESNAME_MEMTYPE                     "_MEM" /* non_cache(0), Cacheable(1) Cache+combine(2), Cache+prefetch(3) */
-#define ASL_RESNAME_MAXADDR                     "_MAX"
-#define ASL_RESNAME_MINADDR                     "_MIN"
-#define ASL_RESNAME_MAXTYPE                     "_MAF"
-#define ASL_RESNAME_MINTYPE                     "_MIF"
-#define ASL_RESNAME_REGISTERBITOFFSET           "_RBO"
-#define ASL_RESNAME_REGISTERBITWIDTH            "_RBW"
-#define ASL_RESNAME_RANGETYPE                   "_RNG"
-#define ASL_RESNAME_READWRITETYPE               "_RW_" /* read_only(0), Writeable (1) */
-#define ASL_RESNAME_TRANSLATION                 "_TRA"
-#define ASL_RESNAME_TRANSTYPE                   "_TRS" /* Sparse(1), Dense(0) */
-#define ASL_RESNAME_TYPE                        "_TTP" /* Translation(1), Static (0) */
-#define ASL_RESNAME_XFERTYPE                    "_SIz" /* 8(0), 8_and16(1), 16(2) */
+#define ACPI_RESTAG_ADDRESS                     "_ADR"
+#define ACPI_RESTAG_ALIGNMENT                   "_ALN"
+#define ACPI_RESTAG_ADDRESSSPACE                "_ASI"
+#define ACPI_RESTAG_ACCESSSIZE                  "_ASZ"
+#define ACPI_RESTAG_TYPESPECIFICATTRIBUTES      "_ATT"
+#define ACPI_RESTAG_BASEADDRESS                 "_BAS"
+#define ACPI_RESTAG_BUSMASTER                   "_BM_" /* Master(1), Slave(0) */
+#define ACPI_RESTAG_DECODE                      "_DEC"
+#define ACPI_RESTAG_DMA                         "_DMA"
+#define ACPI_RESTAG_DMATYPE                     "_TYP" /* Compatible(0), A(1), B(2), F(3) */
+#define ACPI_RESTAG_GRANULARITY                 "_GRA"
+#define ACPI_RESTAG_INTERRUPT                   "_INT"
+#define ACPI_RESTAG_INTERRUPTLEVEL              "_LL_" /* active_lo(1), active_hi(0) */
+#define ACPI_RESTAG_INTERRUPTSHARE              "_SHR" /* Shareable(1), no_share(0) */
+#define ACPI_RESTAG_INTERRUPTTYPE               "_HE_" /* Edge(1), Level(0) */
+#define ACPI_RESTAG_LENGTH                      "_LEN"
+#define ACPI_RESTAG_MEMATTRIBUTES               "_MTP" /* Memory(0), Reserved(1), ACPI(2), NVS(3) */
+#define ACPI_RESTAG_MEMTYPE                     "_MEM" /* non_cache(0), Cacheable(1) Cache+combine(2), Cache+prefetch(3) */
+#define ACPI_RESTAG_MAXADDR                     "_MAX"
+#define ACPI_RESTAG_MINADDR                     "_MIN"
+#define ACPI_RESTAG_MAXTYPE                     "_MAF"
+#define ACPI_RESTAG_MINTYPE                     "_MIF"
+#define ACPI_RESTAG_REGISTERBITOFFSET           "_RBO"
+#define ACPI_RESTAG_REGISTERBITWIDTH            "_RBW"
+#define ACPI_RESTAG_RANGETYPE                   "_RNG"
+#define ACPI_RESTAG_READWRITETYPE               "_RW_" /* read_only(0), Writeable (1) */
+#define ACPI_RESTAG_TRANSLATION                 "_TRA"
+#define ACPI_RESTAG_TRANSTYPE                   "_TRS" /* Sparse(1), Dense(0) */
+#define ACPI_RESTAG_TYPE                        "_TTP" /* Translation(1), Static (0) */
+#define ACPI_RESTAG_XFERTYPE                    "_SIz" /* 8(0), 8_and16(1), 16(2) */
 
 /* Default sizes for "small" resource descriptors */
 
@@ -266,6 +266,7 @@ struct aml_resource_generic_register {
 union aml_resource {
        /* Descriptor headers */
 
+       u8 descriptor_type;
        struct aml_resource_small_header small_header;
        struct aml_resource_large_header large_header;
 
index 223ec64..d5a7f56 100644 (file)
@@ -59,6 +59,7 @@
 #define ACPI_APPLICATION
 #define ACPI_DISASSEMBLER
 #define ACPI_NO_METHOD_EXECUTION
+#define ACPI_LARGE_NAMESPACE_NODE
 #endif
 
 #ifdef ACPI_EXEC_APP
@@ -76,6 +77,7 @@
 #define ACPI_APPLICATION
 #define ACPI_DISASSEMBLER
 #define ACPI_CONSTANT_EVAL_ONLY
+#define ACPI_LARGE_NAMESPACE_NODE
 #endif
 
 #ifdef ACPI_APPLICATION
@@ -271,8 +273,8 @@ typedef char *va_list;
 /*
  * Storage alignment properties
  */
-#define  _AUPBND                (sizeof (acpi_native_uint) - 1)
-#define  _ADNBND                (sizeof (acpi_native_uint) - 1)
+#define  _AUPBND                (sizeof (acpi_native_int) - 1)
+#define  _ADNBND                (sizeof (acpi_native_int) - 1)
 
 /*
  * Variable argument list macro definitions
index 2e6d545..2f5bb5b 100644 (file)
 #include <linux/config.h>
 #include <linux/string.h>
 #include <linux/kernel.h>
+#include <linux/module.h>
 #include <linux/ctype.h>
 #include <asm/system.h>
 #include <asm/atomic.h>
 #include <asm/div64.h>
 #include <asm/acpi.h>
+#include <linux/slab.h>
 
-#define strtoul simple_strtoul
-
-#define ACPI_MACHINE_WIDTH  BITS_PER_LONG
+/* Host-dependent types and defines */
 
-/* Type(s) for the OSL */
-
-#ifdef ACPI_USE_LOCAL_CACHE
-#define acpi_cache_t   struct acpi_memory_list
-#else
-#include <linux/slab.h>
-#define acpi_cache_t   kmem_cache_t
-#endif
+#define ACPI_MACHINE_WIDTH          BITS_PER_LONG
+#define acpi_cache_t                        kmem_cache_t
+#define ACPI_EXPORT_SYMBOL(symbol)  EXPORT_SYMBOL(symbol);
+#define strtoul                     simple_strtoul
 
 /* Full namespace pathname length limit - arbitrary */
-
 #define ACPI_PATHNAME_MAX              256
 
 #else                          /* !__KERNEL__ */