[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / acpi / acpica / exsystem.c


/******************************************************************************
 *
 * Module Name: exsystem - Interface to OS services
 *
 *****************************************************************************/

/*
 * Copyright (C) 2000 - 2008, 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 <acpi/acpi.h>
#include "accommon.h"
#include "acinterp.h"

#define _COMPONENT          ACPI_EXECUTER
ACPI_MODULE_NAME("exsystem")

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_system_wait_semaphore
 *
 * PARAMETERS:  Semaphore       - Semaphore to wait on
 *              Timeout         - Max time to wait
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Implements a semaphore wait with a check to see if the
 *              semaphore is available immediately.  If it is not, the
 *              interpreter is released before waiting.
 *
 ******************************************************************************/
acpi_status acpi_ex_system_wait_semaphore(acpi_semaphore semaphore, u16 timeout)
{
	acpi_status status;

	ACPI_FUNCTION_TRACE(ex_system_wait_semaphore);

	status = acpi_os_wait_semaphore(semaphore, 1, ACPI_DO_NOT_WAIT);
	if (ACPI_SUCCESS(status)) {
		return_ACPI_STATUS(status);
	}

	if (status == AE_TIME) {

		/* We must wait, so unlock the interpreter */

		acpi_ex_relinquish_interpreter();

		status = acpi_os_wait_semaphore(semaphore, 1, timeout);

		ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
				  "*** Thread awake after blocking, %s\n",
				  acpi_format_exception(status)));

		/* Reacquire the interpreter */

		acpi_ex_reacquire_interpreter();
	}

	return_ACPI_STATUS(status);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_system_wait_mutex
 *
 * PARAMETERS:  Mutex           - Mutex to wait on
 *              Timeout         - Max time to wait
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Implements a mutex wait with a check to see if the
 *              mutex is available immediately.  If it is not, the
 *              interpreter is released before waiting.
 *
 ******************************************************************************/

acpi_status acpi_ex_system_wait_mutex(acpi_mutex mutex, u16 timeout)
{
	acpi_status status;

	ACPI_FUNCTION_TRACE(ex_system_wait_mutex);

	status = acpi_os_acquire_mutex(mutex, ACPI_DO_NOT_WAIT);
	if (ACPI_SUCCESS(status)) {
		return_ACPI_STATUS(status);
	}

	if (status == AE_TIME) {

		/* We must wait, so unlock the interpreter */

		acpi_ex_relinquish_interpreter();

		status = acpi_os_acquire_mutex(mutex, timeout);

		ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
				  "*** Thread awake after blocking, %s\n",
				  acpi_format_exception(status)));

		/* Reacquire the interpreter */

		acpi_ex_reacquire_interpreter();
	}

	return_ACPI_STATUS(status);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_system_do_stall
 *
 * PARAMETERS:  how_long        - The amount of time to stall,
 *                                in microseconds
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Suspend running thread for specified amount of time.
 *              Note: ACPI specification requires that Stall() does not
 *              relinquish the processor, and delays longer than 100 usec
 *              should use Sleep() instead.  We allow stalls up to 255 usec
 *              for compatibility with other interpreters and existing BIOSs.
 *
 ******************************************************************************/

acpi_status acpi_ex_system_do_stall(u32 how_long)
{
	acpi_status status = AE_OK;

	ACPI_FUNCTION_ENTRY();

	if (how_long > 255) {	/* 255 microseconds */
		/*
		 * Longer than 255 usec, this is an error
		 *
		 * (ACPI specifies 100 usec as max, but this gives some slack in
		 * order to support existing BIOSs)
		 */
		ACPI_ERROR((AE_INFO, "Time parameter is too large (%d)",
			    how_long));
		status = AE_AML_OPERAND_VALUE;
	} else {
		acpi_os_stall(how_long);
	}

	return (status);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_system_do_suspend
 *
 * PARAMETERS:  how_long        - The amount of time to suspend,
 *                                in milliseconds
 *
 * RETURN:      None
 *
 * DESCRIPTION: Suspend running thread for specified amount of time.
 *
 ******************************************************************************/

acpi_status acpi_ex_system_do_suspend(acpi_integer how_long)
{
	ACPI_FUNCTION_ENTRY();

	/* Since this thread will sleep, we must release the interpreter */

	acpi_ex_relinquish_interpreter();

	acpi_os_sleep(how_long);

	/* And now we must get the interpreter again */

	acpi_ex_reacquire_interpreter();
	return (AE_OK);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_system_signal_event
 *
 * PARAMETERS:  obj_desc        - The object descriptor for this op
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Provides an access point to perform synchronization operations
 *              within the AML.
 *
 ******************************************************************************/

acpi_status acpi_ex_system_signal_event(union acpi_operand_object * obj_desc)
{
	acpi_status status = AE_OK;

	ACPI_FUNCTION_TRACE(ex_system_signal_event);

	if (obj_desc) {
		status =
		    acpi_os_signal_semaphore(obj_desc->event.os_semaphore, 1);
	}

	return_ACPI_STATUS(status);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_system_wait_event
 *
 * PARAMETERS:  time_desc       - The 'time to delay' object descriptor
 *              obj_desc        - The object descriptor for this op
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Provides an access point to perform synchronization operations
 *              within the AML.  This operation is a request to wait for an
 *              event.
 *
 ******************************************************************************/

acpi_status
acpi_ex_system_wait_event(union acpi_operand_object *time_desc,
			  union acpi_operand_object *obj_desc)
{
	acpi_status status = AE_OK;

	ACPI_FUNCTION_TRACE(ex_system_wait_event);

	if (obj_desc) {
		status =
		    acpi_ex_system_wait_semaphore(obj_desc->event.os_semaphore,
						  (u16) time_desc->integer.
						  value);
	}

	return_ACPI_STATUS(status);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_system_reset_event
 *
 * PARAMETERS:  obj_desc        - The object descriptor for this op
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Reset an event to a known state.
 *
 ******************************************************************************/

acpi_status acpi_ex_system_reset_event(union acpi_operand_object *obj_desc)
{
	acpi_status status = AE_OK;
	acpi_semaphore temp_semaphore;

	ACPI_FUNCTION_ENTRY();

	/*
	 * We are going to simply delete the existing semaphore and
	 * create a new one!
	 */
	status =
	    acpi_os_create_semaphore(ACPI_NO_UNIT_LIMIT, 0, &temp_semaphore);
	if (ACPI_SUCCESS(status)) {
		(void)acpi_os_delete_semaphore(obj_desc->event.os_semaphore);
		obj_desc->event.os_semaphore = temp_semaphore;
	}

	return (status);
}
Commit	Line	Data
1da177e4 LT	1
	2	/******************************************************************************
	3	*
	4	* Module Name: exsystem - Interface to OS services
	5	*
	6	*****************************************************************************/
	7
	8	/*
75a44ce0	9	* Copyright (C) 2000 - 2008, Intel Corp.
1da177e4 LT	10	* All rights reserved.
	11	*
	12	* Redistribution and use in source and binary forms, with or without
	13	* modification, are permitted provided that the following conditions
	14	* are met:
	15	* 1. Redistributions of source code must retain the above copyright
	16	* notice, this list of conditions, and the following disclaimer,
	17	* without modification.
	18	* 2. Redistributions in binary form must reproduce at minimum a disclaimer
	19	* substantially similar to the "NO WARRANTY" disclaimer below
	20	* ("Disclaimer") and any redistribution must be conditioned upon
	21	* including a substantially similar Disclaimer requirement for further
	22	* binary redistribution.
	23	* 3. Neither the names of the above-listed copyright holders nor the names
	24	* of any contributors may be used to endorse or promote products derived
	25	* from this software without specific prior written permission.
	26	*
	27	* Alternatively, this software may be distributed under the terms of the
	28	* GNU General Public License ("GPL") version 2 as published by the Free
	29	* Software Foundation.
	30	*
	31	* NO WARRANTY
	32	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	33	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	34	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
	35	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	36	* HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	37	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	38	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	39	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
	40	* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
	41	* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	42	* POSSIBILITY OF SUCH DAMAGES.
	43	*/
	44
1da177e4	45	#include <acpi/acpi.h>
e2f7a777 LB	46	#include "accommon.h"
e2f7a777 LB	47	#include "acinterp.h"
1da177e4 LT	48
1da177e4 LT	49	#define _COMPONENT ACPI_EXECUTER
4be44fcd	50	ACPI_MODULE_NAME("exsystem")
1da177e4 LT	51
	52	/*******************************************************************************
	53	*
	54	* FUNCTION: acpi_ex_system_wait_semaphore
	55	*
44f6c012 RM	56	* PARAMETERS: Semaphore - Semaphore to wait on
44f6c012 RM	57	* Timeout - Max time to wait
1da177e4 LT	58	*
	59	* RETURN: Status
	60	*
	61	* DESCRIPTION: Implements a semaphore wait with a check to see if the
	62	* semaphore is available immediately. If it is not, the
f6dd9221	63	* interpreter is released before waiting.
1da177e4 LT	64	*
1da177e4 LT	65	******************************************************************************/
967440e3	66	acpi_status acpi_ex_system_wait_semaphore(acpi_semaphore semaphore, u16 timeout)
1da177e4	67	{
4be44fcd	68	acpi_status status;
1da177e4	69
b229cf92	70	ACPI_FUNCTION_TRACE(ex_system_wait_semaphore);
1da177e4	71
967440e3	72	status = acpi_os_wait_semaphore(semaphore, 1, ACPI_DO_NOT_WAIT);
4be44fcd LB	73	if (ACPI_SUCCESS(status)) {
4be44fcd LB	74	return_ACPI_STATUS(status);
1da177e4 LT	75	}
	76
	77	if (status == AE_TIME) {
52fc0b02	78
1da177e4 LT	79	/* We must wait, so unlock the interpreter */
1da177e4 LT	80
4d2acd9e	81	acpi_ex_relinquish_interpreter();
1da177e4	82
4be44fcd	83	status = acpi_os_wait_semaphore(semaphore, 1, timeout);
1da177e4	84
4be44fcd LB	85	ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
	86	"*** Thread awake after blocking, %s\n",
	87	acpi_format_exception(status)));
1da177e4 LT	88
	89	/* Reacquire the interpreter */
	90
4d2acd9e	91	acpi_ex_reacquire_interpreter();
1da177e4 LT	92	}
1da177e4 LT	93
4be44fcd	94	return_ACPI_STATUS(status);
1da177e4 LT	95	}
1da177e4 LT	96
967440e3 BM	97	/*******************************************************************************
	98	*
	99	* FUNCTION: acpi_ex_system_wait_mutex
	100	*
	101	* PARAMETERS: Mutex - Mutex to wait on
	102	* Timeout - Max time to wait
	103	*
	104	* RETURN: Status
	105	*
f6dd9221 BM	106	* DESCRIPTION: Implements a mutex wait with a check to see if the
	107	* mutex is available immediately. If it is not, the
	108	* interpreter is released before waiting.
967440e3 BM	109	*
	110	******************************************************************************/
	111
	112	acpi_status acpi_ex_system_wait_mutex(acpi_mutex mutex, u16 timeout)
	113	{
	114	acpi_status status;
967440e3 BM	115
	116	ACPI_FUNCTION_TRACE(ex_system_wait_mutex);
	117
	118	status = acpi_os_acquire_mutex(mutex, ACPI_DO_NOT_WAIT);
	119	if (ACPI_SUCCESS(status)) {
	120	return_ACPI_STATUS(status);
	121	}
	122
	123	if (status == AE_TIME) {
	124
	125	/* We must wait, so unlock the interpreter */
	126
4d2acd9e	127	acpi_ex_relinquish_interpreter();
967440e3 BM	128
	129	status = acpi_os_acquire_mutex(mutex, timeout);
	130
	131	ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
	132	"*** Thread awake after blocking, %s\n",
	133	acpi_format_exception(status)));
	134
	135	/* Reacquire the interpreter */
	136
4d2acd9e	137	acpi_ex_reacquire_interpreter();
967440e3 BM	138	}
	139
	140	return_ACPI_STATUS(status);
	141	}
	142
1da177e4 LT	143	/*******************************************************************************
	144	*
	145	* FUNCTION: acpi_ex_system_do_stall
	146	*
44f6c012 RM	147	* PARAMETERS: how_long - The amount of time to stall,
44f6c012 RM	148	* in microseconds
1da177e4 LT	149	*
	150	* RETURN: Status
	151	*
	152	* DESCRIPTION: Suspend running thread for specified amount of time.
	153	* Note: ACPI specification requires that Stall() does not
	154	* relinquish the processor, and delays longer than 100 usec
	155	* should use Sleep() instead. We allow stalls up to 255 usec
	156	* for compatibility with other interpreters and existing BIOSs.
	157	*
	158	******************************************************************************/
	159
4be44fcd	160	acpi_status acpi_ex_system_do_stall(u32 how_long)
1da177e4	161	{
4be44fcd	162	acpi_status status = AE_OK;
1da177e4	163
4be44fcd	164	ACPI_FUNCTION_ENTRY();
1da177e4	165
4be44fcd	166	if (how_long > 255) { /* 255 microseconds */
1da177e4 LT	167	/*
	168	* Longer than 255 usec, this is an error
	169	*
	170	* (ACPI specifies 100 usec as max, but this gives some slack in
	171	* order to support existing BIOSs)
	172	*/
b8e4d893 BM	173	ACPI_ERROR((AE_INFO, "Time parameter is too large (%d)",
b8e4d893 BM	174	how_long));
1da177e4	175	status = AE_AML_OPERAND_VALUE;
4be44fcd LB	176	} else {
4be44fcd LB	177	acpi_os_stall(how_long);
1da177e4 LT	178	}
	179
	180	return (status);
	181	}
	182
1da177e4 LT	183	/*******************************************************************************
	184	*
	185	* FUNCTION: acpi_ex_system_do_suspend
	186	*
44f6c012 RM	187	* PARAMETERS: how_long - The amount of time to suspend,
44f6c012 RM	188	* in milliseconds
1da177e4 LT	189	*
	190	* RETURN: None
	191	*
	192	* DESCRIPTION: Suspend running thread for specified amount of time.
	193	*
	194	******************************************************************************/
	195
4be44fcd	196	acpi_status acpi_ex_system_do_suspend(acpi_integer how_long)
1da177e4	197	{
4be44fcd	198	ACPI_FUNCTION_ENTRY();
1da177e4 LT	199
	200	/* Since this thread will sleep, we must release the interpreter */
	201
4d2acd9e	202	acpi_ex_relinquish_interpreter();
1da177e4	203
4be44fcd	204	acpi_os_sleep(how_long);
1da177e4 LT	205
	206	/* And now we must get the interpreter again */
	207
4d2acd9e LB	208	acpi_ex_reacquire_interpreter();
4d2acd9e LB	209	return (AE_OK);
1da177e4 LT	210	}
1da177e4 LT	211
1da177e4 LT	212	/*******************************************************************************
	213	*
	214	* FUNCTION: acpi_ex_system_signal_event
	215	*
44f6c012	216	* PARAMETERS: obj_desc - The object descriptor for this op
1da177e4	217	*
44f6c012	218	* RETURN: Status
1da177e4 LT	219	*
	220	* DESCRIPTION: Provides an access point to perform synchronization operations
	221	* within the AML.
	222	*
	223	******************************************************************************/
	224
c81da666	225	acpi_status acpi_ex_system_signal_event(union acpi_operand_object * obj_desc)
1da177e4	226	{
4be44fcd	227	acpi_status status = AE_OK;
1da177e4	228
b229cf92	229	ACPI_FUNCTION_TRACE(ex_system_signal_event);
1da177e4 LT	230
1da177e4 LT	231	if (obj_desc) {
967440e3 BM	232	status =
967440e3 BM	233	acpi_os_signal_semaphore(obj_desc->event.os_semaphore, 1);
1da177e4 LT	234	}
1da177e4 LT	235
4be44fcd	236	return_ACPI_STATUS(status);
1da177e4 LT	237	}
1da177e4 LT	238
1da177e4 LT	239	/*******************************************************************************
	240	*
	241	* FUNCTION: acpi_ex_system_wait_event
	242	*
44f6c012 RM	243	* PARAMETERS: time_desc - The 'time to delay' object descriptor
44f6c012 RM	244	* obj_desc - The object descriptor for this op
1da177e4 LT	245	*
	246	* RETURN: Status
	247	*
	248	* DESCRIPTION: Provides an access point to perform synchronization operations
	249	* within the AML. This operation is a request to wait for an
	250	* event.
	251	*
	252	******************************************************************************/
	253
	254	acpi_status
4be44fcd LB	255	acpi_ex_system_wait_event(union acpi_operand_object *time_desc,
4be44fcd LB	256	union acpi_operand_object *obj_desc)
1da177e4	257	{
4be44fcd	258	acpi_status status = AE_OK;
1da177e4	259
b229cf92	260	ACPI_FUNCTION_TRACE(ex_system_wait_event);
1da177e4 LT	261
1da177e4 LT	262	if (obj_desc) {
4be44fcd	263	status =
967440e3	264	acpi_ex_system_wait_semaphore(obj_desc->event.os_semaphore,
4be44fcd LB	265	(u16) time_desc->integer.
4be44fcd LB	266	value);
1da177e4 LT	267	}
1da177e4 LT	268
4be44fcd	269	return_ACPI_STATUS(status);
1da177e4 LT	270	}
1da177e4 LT	271
1da177e4 LT	272	/*******************************************************************************
	273	*
	274	* FUNCTION: acpi_ex_system_reset_event
	275	*
44f6c012	276	* PARAMETERS: obj_desc - The object descriptor for this op
1da177e4 LT	277	*
	278	* RETURN: Status
	279	*
	280	* DESCRIPTION: Reset an event to a known state.
	281	*
	282	******************************************************************************/
	283
4be44fcd	284	acpi_status acpi_ex_system_reset_event(union acpi_operand_object *obj_desc)
1da177e4	285	{
4be44fcd	286	acpi_status status = AE_OK;
967440e3	287	acpi_semaphore temp_semaphore;
1da177e4	288
4be44fcd	289	ACPI_FUNCTION_ENTRY();
1da177e4 LT	290
	291	/*
	292	* We are going to simply delete the existing semaphore and
	293	* create a new one!
	294	*/
4be44fcd LB	295	status =
	296	acpi_os_create_semaphore(ACPI_NO_UNIT_LIMIT, 0, &temp_semaphore);
	297	if (ACPI_SUCCESS(status)) {
967440e3 BM	298	(void)acpi_os_delete_semaphore(obj_desc->event.os_semaphore);
967440e3 BM	299	obj_desc->event.os_semaphore = temp_semaphore;
1da177e4 LT	300	}
	301
	302	return (status);
	303	}