[linux-2.6-block.git] / drivers / acpi / acpica / utxface.c

/******************************************************************************
 *
 * Module Name: utxface - External interfaces, miscellaneous utility functions
 *
 *****************************************************************************/

/*
 * Copyright (C) 2000 - 2013, Intel Corp.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions, and the following disclaimer,
 *    without modification.
 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
 *    substantially similar to the "NO WARRANTY" disclaimer below
 *    ("Disclaimer") and any redistribution must be conditioned upon
 *    including a substantially similar Disclaimer requirement for further
 *    binary redistribution.
 * 3. Neither the names of the above-listed copyright holders nor the names
 *    of any contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * Alternatively, this software may be distributed under the terms of the
 * GNU General Public License ("GPL") version 2 as published by the Free
 * Software Foundation.
 *
 * NO WARRANTY
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGES.
 */

#include <linux/export.h>
#include <acpi/acpi.h>
#include "accommon.h"
#include "acdebug.h"

#define _COMPONENT          ACPI_UTILITIES
ACPI_MODULE_NAME("utxface")

/*******************************************************************************
 *
 * FUNCTION:    acpi_terminate
 *
 * PARAMETERS:  None
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Shutdown the ACPICA subsystem and release all resources.
 *
 ******************************************************************************/
acpi_status acpi_terminate(void)
{
	acpi_status status;

	ACPI_FUNCTION_TRACE(acpi_terminate);

	/* Just exit if subsystem is already shutdown */

	if (acpi_gbl_shutdown) {
		ACPI_ERROR((AE_INFO, "ACPI Subsystem is already terminated"));
		return_ACPI_STATUS(AE_OK);
	}

	/* Subsystem appears active, go ahead and shut it down */

	acpi_gbl_shutdown = TRUE;
	acpi_gbl_startup_flags = 0;
	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Shutting down ACPI Subsystem\n"));

	/* Terminate the AML Debugger if present */

	ACPI_DEBUGGER_EXEC(acpi_gbl_db_terminate_threads = TRUE);

	/* Shutdown and free all resources */

	acpi_ut_subsystem_shutdown();

	/* Free the mutex objects */

	acpi_ut_mutex_terminate();

#ifdef ACPI_DEBUGGER

	/* Shut down the debugger */

	acpi_db_terminate();
#endif

	/* Now we can shutdown the OS-dependent layer */

	status = acpi_os_terminate();
	return_ACPI_STATUS(status);
}

ACPI_EXPORT_SYMBOL(acpi_terminate)

#ifndef ACPI_ASL_COMPILER
#ifdef ACPI_FUTURE_USAGE
/*******************************************************************************
 *
 * FUNCTION:    acpi_subsystem_status
 *
 * PARAMETERS:  None
 *
 * RETURN:      Status of the ACPI subsystem
 *
 * DESCRIPTION: Other drivers that use the ACPI subsystem should call this
 *              before making any other calls, to ensure the subsystem
 *              initialized successfully.
 *
 ******************************************************************************/
acpi_status acpi_subsystem_status(void)
{

	if (acpi_gbl_startup_flags & ACPI_INITIALIZED_OK) {
		return (AE_OK);
	} else {
		return (AE_ERROR);
	}
}

ACPI_EXPORT_SYMBOL(acpi_subsystem_status)

/*******************************************************************************
 *
 * FUNCTION:    acpi_get_system_info
 *
 * PARAMETERS:  out_buffer      - A buffer to receive the resources for the
 *                                device
 *
 * RETURN:      status          - the status of the call
 *
 * DESCRIPTION: This function is called to get information about the current
 *              state of the ACPI subsystem. It will return system information
 *              in the out_buffer.
 *
 *              If the function fails an appropriate status will be returned
 *              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;
	acpi_status status;

	ACPI_FUNCTION_TRACE(acpi_get_system_info);

	/* Parameter validation */

	status = acpi_ut_validate_buffer(out_buffer);
	if (ACPI_FAILURE(status)) {
		return_ACPI_STATUS(status);
	}

	/* Validate/Allocate/Clear caller buffer */

	status =
	    acpi_ut_initialize_buffer(out_buffer,
				      sizeof(struct acpi_system_info));
	if (ACPI_FAILURE(status)) {
		return_ACPI_STATUS(status);
	}

	/*
	 * Populate the return buffer
	 */
	info_ptr = (struct acpi_system_info *)out_buffer->pointer;

	info_ptr->acpi_ca_version = ACPI_CA_VERSION;

	/* System flags (ACPI capabilities) */

	info_ptr->flags = ACPI_SYS_MODE_ACPI;

	/* Timer resolution - 24 or 32 bits  */

	if (acpi_gbl_FADT.flags & ACPI_FADT_32BIT_TIMER) {
		info_ptr->timer_resolution = 24;
	} else {
		info_ptr->timer_resolution = 32;
	}

	/* Clear the reserved fields */

	info_ptr->reserved1 = 0;
	info_ptr->reserved2 = 0;

	/* Current debug levels */

	info_ptr->debug_layer = acpi_dbg_layer;
	info_ptr->debug_level = acpi_dbg_level;

	return_ACPI_STATUS(AE_OK);
}

ACPI_EXPORT_SYMBOL(acpi_get_system_info)

/*****************************************************************************
 *
 * FUNCTION:    acpi_install_initialization_handler
 *
 * PARAMETERS:  handler             - Callback procedure
 *              function            - Not (currently) used, see below
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Install an initialization handler
 *
 * TBD: When a second function is added, must save the Function also.
 *
 ****************************************************************************/
acpi_status
acpi_install_initialization_handler(acpi_init_handler handler, u32 function)
{

	if (!handler) {
		return (AE_BAD_PARAMETER);
	}

	if (acpi_gbl_init_handler) {
		return (AE_ALREADY_EXISTS);
	}

	acpi_gbl_init_handler = handler;
	return (AE_OK);
}

ACPI_EXPORT_SYMBOL(acpi_install_initialization_handler)
#endif				/*  ACPI_FUTURE_USAGE  */

/*****************************************************************************
 *
 * FUNCTION:    acpi_purge_cached_objects
 *
 * PARAMETERS:  None
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Empty all caches (delete the cached objects)
 *
 ****************************************************************************/
acpi_status acpi_purge_cached_objects(void)
{
	ACPI_FUNCTION_TRACE(acpi_purge_cached_objects);

	(void)acpi_os_purge_cache(acpi_gbl_state_cache);
	(void)acpi_os_purge_cache(acpi_gbl_operand_cache);
	(void)acpi_os_purge_cache(acpi_gbl_ps_node_cache);
	(void)acpi_os_purge_cache(acpi_gbl_ps_node_ext_cache);

	return_ACPI_STATUS(AE_OK);
}

ACPI_EXPORT_SYMBOL(acpi_purge_cached_objects)

/*****************************************************************************
 *
 * FUNCTION:    acpi_install_interface
 *
 * PARAMETERS:  interface_name      - The interface to install
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Install an _OSI interface to the global list
 *
 ****************************************************************************/
acpi_status acpi_install_interface(acpi_string interface_name)
{
	acpi_status status;
	struct acpi_interface_info *interface_info;

	/* Parameter validation */

	if (!interface_name || (ACPI_STRLEN(interface_name) == 0)) {
		return (AE_BAD_PARAMETER);
	}

	(void)acpi_os_acquire_mutex(acpi_gbl_osi_mutex, ACPI_WAIT_FOREVER);

	/* Check if the interface name is already in the global list */

	interface_info = acpi_ut_get_interface(interface_name);
	if (interface_info) {
		/*
		 * The interface already exists in the list. This is OK if the
		 * interface has been marked invalid -- just clear the bit.
		 */
		if (interface_info->flags & ACPI_OSI_INVALID) {
			interface_info->flags &= ~ACPI_OSI_INVALID;
			status = AE_OK;
		} else {
			status = AE_ALREADY_EXISTS;
		}
	} else {
		/* New interface name, install into the global list */

		status = acpi_ut_install_interface(interface_name);
	}

	acpi_os_release_mutex(acpi_gbl_osi_mutex);
	return (status);
}

ACPI_EXPORT_SYMBOL(acpi_install_interface)

/*****************************************************************************
 *
 * FUNCTION:    acpi_remove_interface
 *
 * PARAMETERS:  interface_name      - The interface to remove
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Remove an _OSI interface from the global list
 *
 ****************************************************************************/
acpi_status acpi_remove_interface(acpi_string interface_name)
{
	acpi_status status;

	/* Parameter validation */

	if (!interface_name || (ACPI_STRLEN(interface_name) == 0)) {
		return (AE_BAD_PARAMETER);
	}

	(void)acpi_os_acquire_mutex(acpi_gbl_osi_mutex, ACPI_WAIT_FOREVER);

	status = acpi_ut_remove_interface(interface_name);

	acpi_os_release_mutex(acpi_gbl_osi_mutex);
	return (status);
}

ACPI_EXPORT_SYMBOL(acpi_remove_interface)

/*****************************************************************************
 *
 * FUNCTION:    acpi_install_interface_handler
 *
 * PARAMETERS:  handler             - The _OSI interface handler to install
 *                                    NULL means "remove existing handler"
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Install a handler for the predefined _OSI ACPI method.
 *              invoked during execution of the internal implementation of
 *              _OSI. A NULL handler simply removes any existing handler.
 *
 ****************************************************************************/
acpi_status acpi_install_interface_handler(acpi_interface_handler handler)
{
	acpi_status status = AE_OK;

	(void)acpi_os_acquire_mutex(acpi_gbl_osi_mutex, ACPI_WAIT_FOREVER);

	if (handler && acpi_gbl_interface_handler) {
		status = AE_ALREADY_EXISTS;
	} else {
		acpi_gbl_interface_handler = handler;
	}

	acpi_os_release_mutex(acpi_gbl_osi_mutex);
	return (status);
}

ACPI_EXPORT_SYMBOL(acpi_install_interface_handler)

/*****************************************************************************
 *
 * FUNCTION:    acpi_check_address_range
 *
 * PARAMETERS:  space_id            - Address space ID
 *              address             - Start address
 *              length              - Length
 *              warn                - TRUE if warning on overlap desired
 *
 * RETURN:      Count of the number of conflicts detected.
 *
 * DESCRIPTION: Check if the input address range overlaps any of the
 *              ASL operation region address ranges.
 *
 ****************************************************************************/
u32
acpi_check_address_range(acpi_adr_space_type space_id,
			 acpi_physical_address address,
			 acpi_size length, u8 warn)
{
	u32 overlaps;
	acpi_status status;

	status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
	if (ACPI_FAILURE(status)) {
		return (0);
	}

	overlaps = acpi_ut_check_address_range(space_id, address,
					       (u32)length, warn);

	(void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
	return (overlaps);
}

ACPI_EXPORT_SYMBOL(acpi_check_address_range)
#endif				/* !ACPI_ASL_COMPILER */
/*******************************************************************************
 *
 * FUNCTION:    acpi_decode_pld_buffer
 *
 * PARAMETERS:  in_buffer           - Buffer returned by _PLD method
 *              length              - Length of the in_buffer
 *              return_buffer       - Where the decode buffer is returned
 *
 * RETURN:      Status and the decoded _PLD buffer. User must deallocate
 *              the buffer via ACPI_FREE.
 *
 * DESCRIPTION: Decode the bit-packed buffer returned by the _PLD method into
 *              a local struct that is much more useful to an ACPI driver.
 *
 ******************************************************************************/
acpi_status
acpi_decode_pld_buffer(u8 *in_buffer,
		       acpi_size length, struct acpi_pld_info ** return_buffer)
{
	struct acpi_pld_info *pld_info;
	u32 *buffer = ACPI_CAST_PTR(u32, in_buffer);
	u32 dword;

	/* Parameter validation */

	if (!in_buffer || !return_buffer || (length < 16)) {
		return (AE_BAD_PARAMETER);
	}

	pld_info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_pld_info));
	if (!pld_info) {
		return (AE_NO_MEMORY);
	}

	/* First 32-bit DWord */

	ACPI_MOVE_32_TO_32(&dword, &buffer[0]);
	pld_info->revision = ACPI_PLD_GET_REVISION(&dword);
	pld_info->ignore_color = ACPI_PLD_GET_IGNORE_COLOR(&dword);
	pld_info->color = ACPI_PLD_GET_COLOR(&dword);

	/* Second 32-bit DWord */

	ACPI_MOVE_32_TO_32(&dword, &buffer[1]);
	pld_info->width = ACPI_PLD_GET_WIDTH(&dword);
	pld_info->height = ACPI_PLD_GET_HEIGHT(&dword);

	/* Third 32-bit DWord */

	ACPI_MOVE_32_TO_32(&dword, &buffer[2]);
	pld_info->user_visible = ACPI_PLD_GET_USER_VISIBLE(&dword);
	pld_info->dock = ACPI_PLD_GET_DOCK(&dword);
	pld_info->lid = ACPI_PLD_GET_LID(&dword);
	pld_info->panel = ACPI_PLD_GET_PANEL(&dword);
	pld_info->vertical_position = ACPI_PLD_GET_VERTICAL(&dword);
	pld_info->horizontal_position = ACPI_PLD_GET_HORIZONTAL(&dword);
	pld_info->shape = ACPI_PLD_GET_SHAPE(&dword);
	pld_info->group_orientation = ACPI_PLD_GET_ORIENTATION(&dword);
	pld_info->group_token = ACPI_PLD_GET_TOKEN(&dword);
	pld_info->group_position = ACPI_PLD_GET_POSITION(&dword);
	pld_info->bay = ACPI_PLD_GET_BAY(&dword);

	/* Fourth 32-bit DWord */

	ACPI_MOVE_32_TO_32(&dword, &buffer[3]);
	pld_info->ejectable = ACPI_PLD_GET_EJECTABLE(&dword);
	pld_info->ospm_eject_required = ACPI_PLD_GET_OSPM_EJECT(&dword);
	pld_info->cabinet_number = ACPI_PLD_GET_CABINET(&dword);
	pld_info->card_cage_number = ACPI_PLD_GET_CARD_CAGE(&dword);
	pld_info->reference = ACPI_PLD_GET_REFERENCE(&dword);
	pld_info->rotation = ACPI_PLD_GET_ROTATION(&dword);
	pld_info->order = ACPI_PLD_GET_ORDER(&dword);

	if (length >= ACPI_PLD_BUFFER_SIZE) {

		/* Fifth 32-bit DWord (Revision 2 of _PLD) */

		ACPI_MOVE_32_TO_32(&dword, &buffer[4]);
		pld_info->vertical_offset = ACPI_PLD_GET_VERT_OFFSET(&dword);
		pld_info->horizontal_offset = ACPI_PLD_GET_HORIZ_OFFSET(&dword);
	}

	*return_buffer = pld_info;
	return (AE_OK);
}

ACPI_EXPORT_SYMBOL(acpi_decode_pld_buffer)
Commit	Line	Data
1da177e4 LT	1	/******************************************************************************
1da177e4 LT	2	*
d978348b	3	* Module Name: utxface - External interfaces, miscellaneous utility functions
1da177e4 LT	4	*
	5	*****************************************************************************/
	6
	7	/*
25f044e6	8	* Copyright (C) 2000 - 2013, Intel Corp.
1da177e4 LT	9	* All rights reserved.
	10	*
	11	* Redistribution and use in source and binary forms, with or without
	12	* modification, are permitted provided that the following conditions
	13	* are met:
	14	* 1. Redistributions of source code must retain the above copyright
	15	* notice, this list of conditions, and the following disclaimer,
	16	* without modification.
	17	* 2. Redistributions in binary form must reproduce at minimum a disclaimer
	18	* substantially similar to the "NO WARRANTY" disclaimer below
	19	* ("Disclaimer") and any redistribution must be conditioned upon
	20	* including a substantially similar Disclaimer requirement for further
	21	* binary redistribution.
	22	* 3. Neither the names of the above-listed copyright holders nor the names
	23	* of any contributors may be used to endorse or promote products derived
	24	* from this software without specific prior written permission.
	25	*
	26	* Alternatively, this software may be distributed under the terms of the
	27	* GNU General Public License ("GPL") version 2 as published by the Free
	28	* Software Foundation.
	29	*
	30	* NO WARRANTY
	31	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	32	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	33	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
	34	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	35	* HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	36	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	37	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	38	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
	39	* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
	40	* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	41	* POSSIBILITY OF SUCH DAMAGES.
	42	*/
	43
214f2c90	44	#include <linux/export.h>
1da177e4	45	#include <acpi/acpi.h>
e2f7a777	46	#include "accommon.h"
e2f7a777	47	#include "acdebug.h"
1da177e4 LT	48
1da177e4 LT	49	#define _COMPONENT ACPI_UTILITIES
4be44fcd	50	ACPI_MODULE_NAME("utxface")
1da177e4	51
1da177e4 LT	52	/*******************************************************************************
	53	*
	54	* FUNCTION: acpi_terminate
	55	*
	56	* PARAMETERS: None
	57	*
	58	* RETURN: Status
	59	*
2f977b36	60	* DESCRIPTION: Shutdown the ACPICA subsystem and release all resources.
1da177e4 LT	61	*
1da177e4 LT	62	******************************************************************************/
4be44fcd	63	acpi_status acpi_terminate(void)
1da177e4	64	{
4be44fcd	65	acpi_status status;
1da177e4	66
b229cf92	67	ACPI_FUNCTION_TRACE(acpi_terminate);
1da177e4	68
2f977b36 BM	69	/* Just exit if subsystem is already shutdown */
	70
	71	if (acpi_gbl_shutdown) {
	72	ACPI_ERROR((AE_INFO, "ACPI Subsystem is already terminated"));
	73	return_ACPI_STATUS(AE_OK);
	74	}
	75
	76	/* Subsystem appears active, go ahead and shut it down */
	77
	78	acpi_gbl_shutdown = TRUE;
	79	acpi_gbl_startup_flags = 0;
	80	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Shutting down ACPI Subsystem\n"));
	81
1da177e4 LT	82	/* Terminate the AML Debugger if present */
	83
	84	ACPI_DEBUGGER_EXEC(acpi_gbl_db_terminate_threads = TRUE);
	85
	86	/* Shutdown and free all resources */
	87
4be44fcd	88	acpi_ut_subsystem_shutdown();
1da177e4 LT	89
	90	/* Free the mutex objects */
	91
4be44fcd	92	acpi_ut_mutex_terminate();
1da177e4 LT	93
	94	#ifdef ACPI_DEBUGGER
	95
	96	/* Shut down the debugger */
	97
4be44fcd	98	acpi_db_terminate();
1da177e4 LT	99	#endif
	100
	101	/* Now we can shutdown the OS-dependent layer */
	102
4be44fcd LB	103	status = acpi_os_terminate();
4be44fcd LB	104	return_ACPI_STATUS(status);
1da177e4 LT	105	}
1da177e4 LT	106
8313524a	107	ACPI_EXPORT_SYMBOL(acpi_terminate)
2f977b36	108
e20a679b	109	#ifndef ACPI_ASL_COMPILER
1da177e4	110	#ifdef ACPI_FUTURE_USAGE
44f6c012	111	/*******************************************************************************
1da177e4 LT	112	*
	113	* FUNCTION: acpi_subsystem_status
	114	*
	115	* PARAMETERS: None
	116	*
	117	* RETURN: Status of the ACPI subsystem
	118	*
	119	* DESCRIPTION: Other drivers that use the ACPI subsystem should call this
44f6c012 RM	120	* before making any other calls, to ensure the subsystem
44f6c012 RM	121	* initialized successfully.
1da177e4	122	*
44f6c012	123	******************************************************************************/
4be44fcd	124	acpi_status acpi_subsystem_status(void)
1da177e4	125	{
44f6c012	126
1da177e4 LT	127	if (acpi_gbl_startup_flags & ACPI_INITIALIZED_OK) {
1da177e4 LT	128	return (AE_OK);
4be44fcd	129	} else {
1da177e4 LT	130	return (AE_ERROR);
	131	}
	132	}
	133
8313524a BM	134	ACPI_EXPORT_SYMBOL(acpi_subsystem_status)
8313524a BM	135
44f6c012	136	/*******************************************************************************
1da177e4 LT	137	*
	138	* FUNCTION: acpi_get_system_info
	139	*
44f6c012 RM	140	* PARAMETERS: out_buffer - A buffer to receive the resources for the
44f6c012 RM	141	* device
1da177e4	142	*
ba494bee	143	* RETURN: status - the status of the call
1da177e4 LT	144	*
1da177e4 LT	145	* DESCRIPTION: This function is called to get information about the current
73a3090a	146	* state of the ACPI subsystem. It will return system information
1da177e4 LT	147	* in the out_buffer.
	148	*
	149	* If the function fails an appropriate status will be returned
	150	* and the value of out_buffer is undefined.
	151	*
	152	******************************************************************************/
4be44fcd	153	acpi_status acpi_get_system_info(struct acpi_buffer * out_buffer)
1da177e4	154	{
4be44fcd LB	155	struct acpi_system_info *info_ptr;
4be44fcd LB	156	acpi_status status;
1da177e4	157
b229cf92	158	ACPI_FUNCTION_TRACE(acpi_get_system_info);
1da177e4 LT	159
	160	/* Parameter validation */
	161
4be44fcd LB	162	status = acpi_ut_validate_buffer(out_buffer);
	163	if (ACPI_FAILURE(status)) {
	164	return_ACPI_STATUS(status);
1da177e4 LT	165	}
	166
	167	/* Validate/Allocate/Clear caller buffer */
	168
4be44fcd LB	169	status =
	170	acpi_ut_initialize_buffer(out_buffer,
	171	sizeof(struct acpi_system_info));
	172	if (ACPI_FAILURE(status)) {
	173	return_ACPI_STATUS(status);
1da177e4 LT	174	}
	175
	176	/*
	177	* Populate the return buffer
	178	*/
4be44fcd	179	info_ptr = (struct acpi_system_info *)out_buffer->pointer;
1da177e4	180
4be44fcd	181	info_ptr->acpi_ca_version = ACPI_CA_VERSION;
1da177e4 LT	182
	183	/* System flags (ACPI capabilities) */
	184
4be44fcd	185	info_ptr->flags = ACPI_SYS_MODE_ACPI;
1da177e4 LT	186
	187	/* Timer resolution - 24 or 32 bits */
	188
f3d2e786	189	if (acpi_gbl_FADT.flags & ACPI_FADT_32BIT_TIMER) {
1da177e4	190	info_ptr->timer_resolution = 24;
4be44fcd	191	} else {
1da177e4 LT	192	info_ptr->timer_resolution = 32;
	193	}
	194
	195	/* Clear the reserved fields */
	196
4be44fcd LB	197	info_ptr->reserved1 = 0;
4be44fcd LB	198	info_ptr->reserved2 = 0;
1da177e4 LT	199
	200	/* Current debug levels */
	201
4be44fcd LB	202	info_ptr->debug_layer = acpi_dbg_layer;
4be44fcd LB	203	info_ptr->debug_level = acpi_dbg_level;
1da177e4	204
4be44fcd	205	return_ACPI_STATUS(AE_OK);
1da177e4	206	}
1da177e4	207
8313524a	208	ACPI_EXPORT_SYMBOL(acpi_get_system_info)
1da177e4 LT	209
	210	/*****************************************************************************
	211	*
	212	* FUNCTION: acpi_install_initialization_handler
	213	*
ba494bee BM	214	* PARAMETERS: handler - Callback procedure
ba494bee BM	215	* function - Not (currently) used, see below
1da177e4 LT	216	*
	217	* RETURN: Status
	218	*
	219	* DESCRIPTION: Install an initialization handler
	220	*
	221	* TBD: When a second function is added, must save the Function also.
	222	*
	223	****************************************************************************/
1da177e4	224	acpi_status
4be44fcd	225	acpi_install_initialization_handler(acpi_init_handler handler, u32 function)
1da177e4 LT	226	{
	227
	228	if (!handler) {
	229	return (AE_BAD_PARAMETER);
	230	}
	231
	232	if (acpi_gbl_init_handler) {
	233	return (AE_ALREADY_EXISTS);
	234	}
	235
	236	acpi_gbl_init_handler = handler;
68aafc35	237	return (AE_OK);
1da177e4 LT	238	}
1da177e4 LT	239
8313524a	240	ACPI_EXPORT_SYMBOL(acpi_install_initialization_handler)
4be44fcd	241	#endif /* ACPI_FUTURE_USAGE */
b0ed7a91	242
1da177e4 LT	243	/*****************************************************************************
	244	*
	245	* FUNCTION: acpi_purge_cached_objects
	246	*
	247	* PARAMETERS: None
	248	*
	249	* RETURN: Status
	250	*
	251	* DESCRIPTION: Empty all caches (delete the cached objects)
	252	*
	253	****************************************************************************/
4be44fcd	254	acpi_status acpi_purge_cached_objects(void)
1da177e4	255	{
b229cf92	256	ACPI_FUNCTION_TRACE(acpi_purge_cached_objects);
1da177e4	257
4be44fcd LB	258	(void)acpi_os_purge_cache(acpi_gbl_state_cache);
	259	(void)acpi_os_purge_cache(acpi_gbl_operand_cache);
	260	(void)acpi_os_purge_cache(acpi_gbl_ps_node_cache);
	261	(void)acpi_os_purge_cache(acpi_gbl_ps_node_ext_cache);
68aafc35	262
4be44fcd	263	return_ACPI_STATUS(AE_OK);
1da177e4	264	}
8313524a BM	265
8313524a BM	266	ACPI_EXPORT_SYMBOL(acpi_purge_cached_objects)
b0ed7a91 LM	267
	268	/*****************************************************************************
	269	*
	270	* FUNCTION: acpi_install_interface
	271	*
	272	* PARAMETERS: interface_name - The interface to install
	273	*
	274	* RETURN: Status
	275	*
	276	* DESCRIPTION: Install an _OSI interface to the global list
	277	*
	278	****************************************************************************/
	279	acpi_status acpi_install_interface(acpi_string interface_name)
	280	{
	281	acpi_status status;
	282	struct acpi_interface_info *interface_info;
	283
	284	/* Parameter validation */
	285
	286	if (!interface_name \|\| (ACPI_STRLEN(interface_name) == 0)) {
	287	return (AE_BAD_PARAMETER);
	288	}
	289
	290	(void)acpi_os_acquire_mutex(acpi_gbl_osi_mutex, ACPI_WAIT_FOREVER);
	291
	292	/* Check if the interface name is already in the global list */
	293
	294	interface_info = acpi_ut_get_interface(interface_name);
	295	if (interface_info) {
	296	/*
	297	* The interface already exists in the list. This is OK if the
	298	* interface has been marked invalid -- just clear the bit.
	299	*/
	300	if (interface_info->flags & ACPI_OSI_INVALID) {
	301	interface_info->flags &= ~ACPI_OSI_INVALID;
	302	status = AE_OK;
	303	} else {
	304	status = AE_ALREADY_EXISTS;
	305	}
	306	} else {
	307	/* New interface name, install into the global list */
	308
	309	status = acpi_ut_install_interface(interface_name);
	310	}
	311
	312	acpi_os_release_mutex(acpi_gbl_osi_mutex);
	313	return (status);
	314	}
	315
	316	ACPI_EXPORT_SYMBOL(acpi_install_interface)
	317
	318	/*****************************************************************************
	319	*
	320	* FUNCTION: acpi_remove_interface
	321	*
	322	* PARAMETERS: interface_name - The interface to remove
	323	*
	324	* RETURN: Status
	325	*
	326	* DESCRIPTION: Remove an _OSI interface from the global list
	327	*
	328	****************************************************************************/
	329	acpi_status acpi_remove_interface(acpi_string interface_name)
	330	{
331	acpi_status status;
332
333	/* Parameter validation */
334
335	if (!interface_name \|\| (ACPI_STRLEN(interface_name) == 0)) {
336	return (AE_BAD_PARAMETER);
337	}
338
339	(void)acpi_os_acquire_mutex(acpi_gbl_osi_mutex, ACPI_WAIT_FOREVER);
340
341	status = acpi_ut_remove_interface(interface_name);
342
343	acpi_os_release_mutex(acpi_gbl_osi_mutex);
344	return (status);
345	}
346
347	ACPI_EXPORT_SYMBOL(acpi_remove_interface)
348
349	/*****************************************************************************
350	*
351	* FUNCTION: acpi_install_interface_handler
352	*
ba494bee	353	* PARAMETERS: handler - The _OSI interface handler to install
b0ed7a91 LM	354	* NULL means "remove existing handler"
	355	*
	356	* RETURN: Status
	357	*
	358	* DESCRIPTION: Install a handler for the predefined _OSI ACPI method.
	359	* invoked during execution of the internal implementation of
	360	* _OSI. A NULL handler simply removes any existing handler.
	361	*
	362	****************************************************************************/
	363	acpi_status acpi_install_interface_handler(acpi_interface_handler handler)
	364	{
	365	acpi_status status = AE_OK;
	366
	367	(void)acpi_os_acquire_mutex(acpi_gbl_osi_mutex, ACPI_WAIT_FOREVER);
	368
	369	if (handler && acpi_gbl_interface_handler) {
	370	status = AE_ALREADY_EXISTS;
	371	} else {
	372	acpi_gbl_interface_handler = handler;
	373	}
	374
	375	acpi_os_release_mutex(acpi_gbl_osi_mutex);
	376	return (status);
	377	}
	378
	379	ACPI_EXPORT_SYMBOL(acpi_install_interface_handler)
f654c0fe LM	380
	381	/*****************************************************************************
	382	*
	383	* FUNCTION: acpi_check_address_range
	384	*
	385	* PARAMETERS: space_id - Address space ID
ba494bee BM	386	* address - Start address
	387	* length - Length
	388	* warn - TRUE if warning on overlap desired
f654c0fe LM	389	*
	390	* RETURN: Count of the number of conflicts detected.
	391	*
	392	* DESCRIPTION: Check if the input address range overlaps any of the
	393	* ASL operation region address ranges.
	394	*
	395	****************************************************************************/
	396	u32
	397	acpi_check_address_range(acpi_adr_space_type space_id,
	398	acpi_physical_address address,
	399	acpi_size length, u8 warn)
	400	{
	401	u32 overlaps;
	402	acpi_status status;
	403
	404	status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
	405	if (ACPI_FAILURE(status)) {
	406	return (0);
	407	}
	408
	409	overlaps = acpi_ut_check_address_range(space_id, address,
	410	(u32)length, warn);
	411
	412	(void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
	413	return (overlaps);
	414	}
	415
	416	ACPI_EXPORT_SYMBOL(acpi_check_address_range)
b0ed7a91	417	#endif /* !ACPI_ASL_COMPILER */
be030a57 BM	418	/*******************************************************************************
	419	*
	420	* FUNCTION: acpi_decode_pld_buffer
	421	*
	422	* PARAMETERS: in_buffer - Buffer returned by _PLD method
	423	* length - Length of the in_buffer
	424	* return_buffer - Where the decode buffer is returned
	425	*
	426	* RETURN: Status and the decoded _PLD buffer. User must deallocate
	427	* the buffer via ACPI_FREE.
	428	*
	429	* DESCRIPTION: Decode the bit-packed buffer returned by the _PLD method into
	430	* a local struct that is much more useful to an ACPI driver.
	431	*
	432	******************************************************************************/
	433	acpi_status
	434	acpi_decode_pld_buffer(u8 *in_buffer,
	435	acpi_size length, struct acpi_pld_info ** return_buffer)
	436	{
	437	struct acpi_pld_info *pld_info;
	438	u32 *buffer = ACPI_CAST_PTR(u32, in_buffer);
	439	u32 dword;
	440
	441	/* Parameter validation */
	442
	443	if (!in_buffer \|\| !return_buffer \|\| (length < 16)) {
	444	return (AE_BAD_PARAMETER);
	445	}
	446
	447	pld_info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_pld_info));
	448	if (!pld_info) {
	449	return (AE_NO_MEMORY);
	450	}
	451
	452	/* First 32-bit DWord */
	453
	454	ACPI_MOVE_32_TO_32(&dword, &buffer[0]);
	455	pld_info->revision = ACPI_PLD_GET_REVISION(&dword);
	456	pld_info->ignore_color = ACPI_PLD_GET_IGNORE_COLOR(&dword);
	457	pld_info->color = ACPI_PLD_GET_COLOR(&dword);
	458
	459	/* Second 32-bit DWord */
	460
	461	ACPI_MOVE_32_TO_32(&dword, &buffer[1]);
	462	pld_info->width = ACPI_PLD_GET_WIDTH(&dword);
	463	pld_info->height = ACPI_PLD_GET_HEIGHT(&dword);
	464
	465	/* Third 32-bit DWord */
	466
	467	ACPI_MOVE_32_TO_32(&dword, &buffer[2]);
	468	pld_info->user_visible = ACPI_PLD_GET_USER_VISIBLE(&dword);
	469	pld_info->dock = ACPI_PLD_GET_DOCK(&dword);
	470	pld_info->lid = ACPI_PLD_GET_LID(&dword);
	471	pld_info->panel = ACPI_PLD_GET_PANEL(&dword);
	472	pld_info->vertical_position = ACPI_PLD_GET_VERTICAL(&dword);
	473	pld_info->horizontal_position = ACPI_PLD_GET_HORIZONTAL(&dword);
	474	pld_info->shape = ACPI_PLD_GET_SHAPE(&dword);
	475	pld_info->group_orientation = ACPI_PLD_GET_ORIENTATION(&dword);
	476	pld_info->group_token = ACPI_PLD_GET_TOKEN(&dword);
	477	pld_info->group_position = ACPI_PLD_GET_POSITION(&dword);
	478	pld_info->bay = ACPI_PLD_GET_BAY(&dword);
	479
	480	/* Fourth 32-bit DWord */
	481
482	ACPI_MOVE_32_TO_32(&dword, &buffer[3]);
483	pld_info->ejectable = ACPI_PLD_GET_EJECTABLE(&dword);
484	pld_info->ospm_eject_required = ACPI_PLD_GET_OSPM_EJECT(&dword);
485	pld_info->cabinet_number = ACPI_PLD_GET_CABINET(&dword);
486	pld_info->card_cage_number = ACPI_PLD_GET_CARD_CAGE(&dword);
487	pld_info->reference = ACPI_PLD_GET_REFERENCE(&dword);
488	pld_info->rotation = ACPI_PLD_GET_ROTATION(&dword);
489	pld_info->order = ACPI_PLD_GET_ORDER(&dword);
490
491	if (length >= ACPI_PLD_BUFFER_SIZE) {
492
493	/* Fifth 32-bit DWord (Revision 2 of _PLD) */
494
495	ACPI_MOVE_32_TO_32(&dword, &buffer[4]);
496	pld_info->vertical_offset = ACPI_PLD_GET_VERT_OFFSET(&dword);
497	pld_info->horizontal_offset = ACPI_PLD_GET_HORIZ_OFFSET(&dword);
498	}
499
500	*return_buffer = pld_info;
501	return (AE_OK);
502	}
503
504	ACPI_EXPORT_SYMBOL(acpi_decode_pld_buffer)