[linux-2.6-block.git] / drivers / acpi / executer / 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 <acpi/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 LT	45	#include <acpi/acpi.h>
1da177e4 LT	46	#include <acpi/acinterp.h>
1da177e4 LT	47
1da177e4 LT	48	#define _COMPONENT ACPI_EXECUTER
4be44fcd	49	ACPI_MODULE_NAME("exsystem")
1da177e4 LT	50
	51	/*******************************************************************************
	52	*
	53	* FUNCTION: acpi_ex_system_wait_semaphore
	54	*
44f6c012 RM	55	* PARAMETERS: Semaphore - Semaphore to wait on
44f6c012 RM	56	* Timeout - Max time to wait
1da177e4 LT	57	*
	58	* RETURN: Status
	59	*
	60	* DESCRIPTION: Implements a semaphore wait with a check to see if the
	61	* semaphore is available immediately. If it is not, the
f6dd9221	62	* interpreter is released before waiting.
1da177e4 LT	63	*
1da177e4 LT	64	******************************************************************************/
967440e3	65	acpi_status acpi_ex_system_wait_semaphore(acpi_semaphore semaphore, u16 timeout)
1da177e4	66	{
4be44fcd	67	acpi_status status;
1da177e4	68
b229cf92	69	ACPI_FUNCTION_TRACE(ex_system_wait_semaphore);
1da177e4	70
967440e3	71	status = acpi_os_wait_semaphore(semaphore, 1, ACPI_DO_NOT_WAIT);
4be44fcd LB	72	if (ACPI_SUCCESS(status)) {
4be44fcd LB	73	return_ACPI_STATUS(status);
1da177e4 LT	74	}
	75
	76	if (status == AE_TIME) {
52fc0b02	77
1da177e4 LT	78	/* We must wait, so unlock the interpreter */
1da177e4 LT	79
4d2acd9e	80	acpi_ex_relinquish_interpreter();
1da177e4	81
4be44fcd	82	status = acpi_os_wait_semaphore(semaphore, 1, timeout);
1da177e4	83
4be44fcd LB	84	ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
	85	"*** Thread awake after blocking, %s\n",
	86	acpi_format_exception(status)));
1da177e4 LT	87
	88	/* Reacquire the interpreter */
	89
4d2acd9e	90	acpi_ex_reacquire_interpreter();
1da177e4 LT	91	}
1da177e4 LT	92
4be44fcd	93	return_ACPI_STATUS(status);
1da177e4 LT	94	}
1da177e4 LT	95
967440e3 BM	96	/*******************************************************************************
	97	*
	98	* FUNCTION: acpi_ex_system_wait_mutex
	99	*
	100	* PARAMETERS: Mutex - Mutex to wait on
	101	* Timeout - Max time to wait
	102	*
	103	* RETURN: Status
	104	*
f6dd9221 BM	105	* DESCRIPTION: Implements a mutex wait with a check to see if the
	106	* mutex is available immediately. If it is not, the
	107	* interpreter is released before waiting.
967440e3 BM	108	*
	109	******************************************************************************/
	110
	111	acpi_status acpi_ex_system_wait_mutex(acpi_mutex mutex, u16 timeout)
	112	{
	113	acpi_status status;
967440e3 BM	114
	115	ACPI_FUNCTION_TRACE(ex_system_wait_mutex);
	116
	117	status = acpi_os_acquire_mutex(mutex, ACPI_DO_NOT_WAIT);
	118	if (ACPI_SUCCESS(status)) {
	119	return_ACPI_STATUS(status);
	120	}
	121
	122	if (status == AE_TIME) {
	123
	124	/* We must wait, so unlock the interpreter */
	125
4d2acd9e	126	acpi_ex_relinquish_interpreter();
967440e3 BM	127
	128	status = acpi_os_acquire_mutex(mutex, timeout);
	129
	130	ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
	131	"*** Thread awake after blocking, %s\n",
	132	acpi_format_exception(status)));
	133
	134	/* Reacquire the interpreter */
	135
4d2acd9e	136	acpi_ex_reacquire_interpreter();
967440e3 BM	137	}
	138
	139	return_ACPI_STATUS(status);
	140	}
	141
1da177e4 LT	142	/*******************************************************************************
	143	*
	144	* FUNCTION: acpi_ex_system_do_stall
	145	*
44f6c012 RM	146	* PARAMETERS: how_long - The amount of time to stall,
44f6c012 RM	147	* in microseconds
1da177e4 LT	148	*
	149	* RETURN: Status
	150	*
	151	* DESCRIPTION: Suspend running thread for specified amount of time.
	152	* Note: ACPI specification requires that Stall() does not
	153	* relinquish the processor, and delays longer than 100 usec
	154	* should use Sleep() instead. We allow stalls up to 255 usec
	155	* for compatibility with other interpreters and existing BIOSs.
	156	*
	157	******************************************************************************/
	158
4be44fcd	159	acpi_status acpi_ex_system_do_stall(u32 how_long)
1da177e4	160	{
4be44fcd	161	acpi_status status = AE_OK;
1da177e4	162
4be44fcd	163	ACPI_FUNCTION_ENTRY();
1da177e4	164
4be44fcd	165	if (how_long > 255) { /* 255 microseconds */
1da177e4 LT	166	/*
	167	* Longer than 255 usec, this is an error
	168	*
	169	* (ACPI specifies 100 usec as max, but this gives some slack in
	170	* order to support existing BIOSs)
	171	*/
b8e4d893 BM	172	ACPI_ERROR((AE_INFO, "Time parameter is too large (%d)",
b8e4d893 BM	173	how_long));
1da177e4	174	status = AE_AML_OPERAND_VALUE;
4be44fcd LB	175	} else {
4be44fcd LB	176	acpi_os_stall(how_long);
1da177e4 LT	177	}
	178
	179	return (status);
	180	}
	181
1da177e4 LT	182	/*******************************************************************************
	183	*
	184	* FUNCTION: acpi_ex_system_do_suspend
	185	*
44f6c012 RM	186	* PARAMETERS: how_long - The amount of time to suspend,
44f6c012 RM	187	* in milliseconds
1da177e4 LT	188	*
	189	* RETURN: None
	190	*
	191	* DESCRIPTION: Suspend running thread for specified amount of time.
	192	*
	193	******************************************************************************/
	194
4be44fcd	195	acpi_status acpi_ex_system_do_suspend(acpi_integer how_long)
1da177e4	196	{
4be44fcd	197	ACPI_FUNCTION_ENTRY();
1da177e4 LT	198
	199	/* Since this thread will sleep, we must release the interpreter */
	200
4d2acd9e	201	acpi_ex_relinquish_interpreter();
1da177e4	202
4be44fcd	203	acpi_os_sleep(how_long);
1da177e4 LT	204
	205	/* And now we must get the interpreter again */
	206
4d2acd9e LB	207	acpi_ex_reacquire_interpreter();
4d2acd9e LB	208	return (AE_OK);
1da177e4 LT	209	}
1da177e4 LT	210
1da177e4 LT	211	/*******************************************************************************
	212	*
	213	* FUNCTION: acpi_ex_system_signal_event
	214	*
44f6c012	215	* PARAMETERS: obj_desc - The object descriptor for this op
1da177e4	216	*
44f6c012	217	* RETURN: Status
1da177e4 LT	218	*
	219	* DESCRIPTION: Provides an access point to perform synchronization operations
	220	* within the AML.
	221	*
	222	******************************************************************************/
	223
c81da666	224	acpi_status acpi_ex_system_signal_event(union acpi_operand_object * obj_desc)
1da177e4	225	{
4be44fcd	226	acpi_status status = AE_OK;
1da177e4	227
b229cf92	228	ACPI_FUNCTION_TRACE(ex_system_signal_event);
1da177e4 LT	229
1da177e4 LT	230	if (obj_desc) {
967440e3 BM	231	status =
967440e3 BM	232	acpi_os_signal_semaphore(obj_desc->event.os_semaphore, 1);
1da177e4 LT	233	}
1da177e4 LT	234
4be44fcd	235	return_ACPI_STATUS(status);
1da177e4 LT	236	}
1da177e4 LT	237
1da177e4 LT	238	/*******************************************************************************
	239	*
	240	* FUNCTION: acpi_ex_system_wait_event
	241	*
44f6c012 RM	242	* PARAMETERS: time_desc - The 'time to delay' object descriptor
44f6c012 RM	243	* obj_desc - The object descriptor for this op
1da177e4 LT	244	*
	245	* RETURN: Status
	246	*
	247	* DESCRIPTION: Provides an access point to perform synchronization operations
	248	* within the AML. This operation is a request to wait for an
	249	* event.
	250	*
	251	******************************************************************************/
	252
	253	acpi_status
4be44fcd LB	254	acpi_ex_system_wait_event(union acpi_operand_object *time_desc,
4be44fcd LB	255	union acpi_operand_object *obj_desc)
1da177e4	256	{
4be44fcd	257	acpi_status status = AE_OK;
1da177e4	258
b229cf92	259	ACPI_FUNCTION_TRACE(ex_system_wait_event);
1da177e4 LT	260
1da177e4 LT	261	if (obj_desc) {
4be44fcd	262	status =
967440e3	263	acpi_ex_system_wait_semaphore(obj_desc->event.os_semaphore,
4be44fcd LB	264	(u16) time_desc->integer.
4be44fcd LB	265	value);
1da177e4 LT	266	}
1da177e4 LT	267
4be44fcd	268	return_ACPI_STATUS(status);
1da177e4 LT	269	}
1da177e4 LT	270
1da177e4 LT	271	/*******************************************************************************
	272	*
	273	* FUNCTION: acpi_ex_system_reset_event
	274	*
44f6c012	275	* PARAMETERS: obj_desc - The object descriptor for this op
1da177e4 LT	276	*
	277	* RETURN: Status
	278	*
	279	* DESCRIPTION: Reset an event to a known state.
	280	*
	281	******************************************************************************/
	282
4be44fcd	283	acpi_status acpi_ex_system_reset_event(union acpi_operand_object *obj_desc)
1da177e4	284	{
4be44fcd	285	acpi_status status = AE_OK;
967440e3	286	acpi_semaphore temp_semaphore;
1da177e4	287
4be44fcd	288	ACPI_FUNCTION_ENTRY();
1da177e4 LT	289
	290	/*
	291	* We are going to simply delete the existing semaphore and
	292	* create a new one!
	293	*/
4be44fcd LB	294	status =
	295	acpi_os_create_semaphore(ACPI_NO_UNIT_LIMIT, 0, &temp_semaphore);
	296	if (ACPI_SUCCESS(status)) {
967440e3 BM	297	(void)acpi_os_delete_semaphore(obj_desc->event.os_semaphore);
967440e3 BM	298	obj_desc->event.os_semaphore = temp_semaphore;
1da177e4 LT	299	}
	300
	301	return (status);
	302	}