[mirror_ubuntu-hirsute-kernel.git] / drivers / acpi / acpica / exmutex.c

// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
/******************************************************************************
 *
 * Module Name: exmutex - ASL Mutex Acquire/Release functions
 *
 * Copyright (C) 2000 - 2018, Intel Corp.
 *
 *****************************************************************************/

#include <acpi/acpi.h>
#include "accommon.h"
#include "acinterp.h"
#include "acevents.h"

#define _COMPONENT          ACPI_EXECUTER
ACPI_MODULE_NAME("exmutex")

/* Local prototypes */
static void
acpi_ex_link_mutex(union acpi_operand_object *obj_desc,
		   struct acpi_thread_state *thread);

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_unlink_mutex
 *
 * PARAMETERS:  obj_desc            - The mutex to be unlinked
 *
 * RETURN:      None
 *
 * DESCRIPTION: Remove a mutex from the "AcquiredMutex" list
 *
 ******************************************************************************/

void acpi_ex_unlink_mutex(union acpi_operand_object *obj_desc)
{
	struct acpi_thread_state *thread = obj_desc->mutex.owner_thread;

	if (!thread) {
		return;
	}

	/* Doubly linked list */

	if (obj_desc->mutex.next) {
		(obj_desc->mutex.next)->mutex.prev = obj_desc->mutex.prev;
	}

	if (obj_desc->mutex.prev) {
		(obj_desc->mutex.prev)->mutex.next = obj_desc->mutex.next;

		/*
		 * Migrate the previous sync level associated with this mutex to
		 * the previous mutex on the list so that it may be preserved.
		 * This handles the case where several mutexes have been acquired
		 * at the same level, but are not released in opposite order.
		 */
		(obj_desc->mutex.prev)->mutex.original_sync_level =
		    obj_desc->mutex.original_sync_level;
	} else {
		thread->acquired_mutex_list = obj_desc->mutex.next;
	}
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_link_mutex
 *
 * PARAMETERS:  obj_desc            - The mutex to be linked
 *              thread              - Current executing thread object
 *
 * RETURN:      None
 *
 * DESCRIPTION: Add a mutex to the "AcquiredMutex" list for this walk
 *
 ******************************************************************************/

static void
acpi_ex_link_mutex(union acpi_operand_object *obj_desc,
		   struct acpi_thread_state *thread)
{
	union acpi_operand_object *list_head;

	list_head = thread->acquired_mutex_list;

	/* This object will be the first object in the list */

	obj_desc->mutex.prev = NULL;
	obj_desc->mutex.next = list_head;

	/* Update old first object to point back to this object */

	if (list_head) {
		list_head->mutex.prev = obj_desc;
	}

	/* Update list head */

	thread->acquired_mutex_list = obj_desc;
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_acquire_mutex_object
 *
 * PARAMETERS:  timeout             - Timeout in milliseconds
 *              obj_desc            - Mutex object
 *              thread_id           - Current thread state
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Acquire an AML mutex, low-level interface. Provides a common
 *              path that supports multiple acquires by the same thread.
 *
 * MUTEX:       Interpreter must be locked
 *
 * NOTE: This interface is called from three places:
 * 1) From acpi_ex_acquire_mutex, via an AML Acquire() operator
 * 2) From acpi_ex_acquire_global_lock when an AML Field access requires the
 *    global lock
 * 3) From the external interface, acpi_acquire_global_lock
 *
 ******************************************************************************/

acpi_status
acpi_ex_acquire_mutex_object(u16 timeout,
			     union acpi_operand_object *obj_desc,
			     acpi_thread_id thread_id)
{
	acpi_status status;

	ACPI_FUNCTION_TRACE_PTR(ex_acquire_mutex_object, obj_desc);

	if (!obj_desc) {
		return_ACPI_STATUS(AE_BAD_PARAMETER);
	}

	/* Support for multiple acquires by the owning thread */

	if (obj_desc->mutex.thread_id == thread_id) {
		/*
		 * The mutex is already owned by this thread, just increment the
		 * acquisition depth
		 */
		obj_desc->mutex.acquisition_depth++;
		return_ACPI_STATUS(AE_OK);
	}

	/* Acquire the mutex, wait if necessary. Special case for Global Lock */

	if (obj_desc == acpi_gbl_global_lock_mutex) {
		status = acpi_ev_acquire_global_lock(timeout);
	} else {
		status =
		    acpi_ex_system_wait_mutex(obj_desc->mutex.os_mutex,
					      timeout);
	}

	if (ACPI_FAILURE(status)) {

		/* Includes failure from a timeout on time_desc */

		return_ACPI_STATUS(status);
	}

	/* Acquired the mutex: update mutex object */

	obj_desc->mutex.thread_id = thread_id;
	obj_desc->mutex.acquisition_depth = 1;
	obj_desc->mutex.original_sync_level = 0;
	obj_desc->mutex.owner_thread = NULL;	/* Used only for AML Acquire() */

	return_ACPI_STATUS(AE_OK);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_acquire_mutex
 *
 * PARAMETERS:  time_desc           - Timeout integer
 *              obj_desc            - Mutex object
 *              walk_state          - Current method execution state
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Acquire an AML mutex
 *
 ******************************************************************************/

acpi_status
acpi_ex_acquire_mutex(union acpi_operand_object *time_desc,
		      union acpi_operand_object *obj_desc,
		      struct acpi_walk_state *walk_state)
{
	acpi_status status;

	ACPI_FUNCTION_TRACE_PTR(ex_acquire_mutex, obj_desc);

	if (!obj_desc) {
		return_ACPI_STATUS(AE_BAD_PARAMETER);
	}

	/* Must have a valid thread state struct */

	if (!walk_state->thread) {
		ACPI_ERROR((AE_INFO,
			    "Cannot acquire Mutex [%4.4s], null thread info",
			    acpi_ut_get_node_name(obj_desc->mutex.node)));
		return_ACPI_STATUS(AE_AML_INTERNAL);
	}

	/*
	 * Current sync level must be less than or equal to the sync level
	 * of the mutex. This mechanism provides some deadlock prevention.
	 */
	if (walk_state->thread->current_sync_level > obj_desc->mutex.sync_level) {
		ACPI_ERROR((AE_INFO,
			    "Cannot acquire Mutex [%4.4s], "
			    "current SyncLevel is too large (%u)",
			    acpi_ut_get_node_name(obj_desc->mutex.node),
			    walk_state->thread->current_sync_level));
		return_ACPI_STATUS(AE_AML_MUTEX_ORDER);
	}

	ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
			  "Acquiring: Mutex SyncLevel %u, Thread SyncLevel %u, "
			  "Depth %u TID %p\n",
			  obj_desc->mutex.sync_level,
			  walk_state->thread->current_sync_level,
			  obj_desc->mutex.acquisition_depth,
			  walk_state->thread));

	status = acpi_ex_acquire_mutex_object((u16)time_desc->integer.value,
					      obj_desc,
					      walk_state->thread->thread_id);

	if (ACPI_SUCCESS(status) && obj_desc->mutex.acquisition_depth == 1) {

		/* Save Thread object, original/current sync levels */

		obj_desc->mutex.owner_thread = walk_state->thread;
		obj_desc->mutex.original_sync_level =
		    walk_state->thread->current_sync_level;
		walk_state->thread->current_sync_level =
		    obj_desc->mutex.sync_level;

		/* Link the mutex to the current thread for force-unlock at method exit */

		acpi_ex_link_mutex(obj_desc, walk_state->thread);
	}

	ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
			  "Acquired: Mutex SyncLevel %u, Thread SyncLevel %u, Depth %u\n",
			  obj_desc->mutex.sync_level,
			  walk_state->thread->current_sync_level,
			  obj_desc->mutex.acquisition_depth));

	return_ACPI_STATUS(status);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_release_mutex_object
 *
 * PARAMETERS:  obj_desc            - The object descriptor for this op
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Release a previously acquired Mutex, low level interface.
 *              Provides a common path that supports multiple releases (after
 *              previous multiple acquires) by the same thread.
 *
 * MUTEX:       Interpreter must be locked
 *
 * NOTE: This interface is called from three places:
 * 1) From acpi_ex_release_mutex, via an AML Acquire() operator
 * 2) From acpi_ex_release_global_lock when an AML Field access requires the
 *    global lock
 * 3) From the external interface, acpi_release_global_lock
 *
 ******************************************************************************/

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

	ACPI_FUNCTION_TRACE(ex_release_mutex_object);

	if (obj_desc->mutex.acquisition_depth == 0) {
		return_ACPI_STATUS(AE_NOT_ACQUIRED);
	}

	/* Match multiple Acquires with multiple Releases */

	obj_desc->mutex.acquisition_depth--;
	if (obj_desc->mutex.acquisition_depth != 0) {

		/* Just decrement the depth and return */

		return_ACPI_STATUS(AE_OK);
	}

	if (obj_desc->mutex.owner_thread) {

		/* Unlink the mutex from the owner's list */

		acpi_ex_unlink_mutex(obj_desc);
		obj_desc->mutex.owner_thread = NULL;
	}

	/* Release the mutex, special case for Global Lock */

	if (obj_desc == acpi_gbl_global_lock_mutex) {
		status = acpi_ev_release_global_lock();
	} else {
		acpi_os_release_mutex(obj_desc->mutex.os_mutex);
	}

	/* Clear mutex info */

	obj_desc->mutex.thread_id = 0;
	return_ACPI_STATUS(status);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_release_mutex
 *
 * PARAMETERS:  obj_desc            - The object descriptor for this op
 *              walk_state          - Current method execution state
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Release a previously acquired Mutex.
 *
 ******************************************************************************/

acpi_status
acpi_ex_release_mutex(union acpi_operand_object *obj_desc,
		      struct acpi_walk_state *walk_state)
{
	u8 previous_sync_level;
	struct acpi_thread_state *owner_thread;
	acpi_status status = AE_OK;

	ACPI_FUNCTION_TRACE(ex_release_mutex);

	if (!obj_desc) {
		return_ACPI_STATUS(AE_BAD_PARAMETER);
	}

	owner_thread = obj_desc->mutex.owner_thread;

	/* The mutex must have been previously acquired in order to release it */

	if (!owner_thread) {
		ACPI_ERROR((AE_INFO,
			    "Cannot release Mutex [%4.4s], not acquired",
			    acpi_ut_get_node_name(obj_desc->mutex.node)));
		return_ACPI_STATUS(AE_AML_MUTEX_NOT_ACQUIRED);
	}

	/* Must have a valid thread ID */

	if (!walk_state->thread) {
		ACPI_ERROR((AE_INFO,
			    "Cannot release Mutex [%4.4s], null thread info",
			    acpi_ut_get_node_name(obj_desc->mutex.node)));
		return_ACPI_STATUS(AE_AML_INTERNAL);
	}

	/*
	 * The Mutex is owned, but this thread must be the owner.
	 * Special case for Global Lock, any thread can release
	 */
	if ((owner_thread->thread_id != walk_state->thread->thread_id) &&
	    (obj_desc != acpi_gbl_global_lock_mutex)) {
		ACPI_ERROR((AE_INFO,
			    "Thread %u cannot release Mutex [%4.4s] acquired by thread %u",
			    (u32)walk_state->thread->thread_id,
			    acpi_ut_get_node_name(obj_desc->mutex.node),
			    (u32)owner_thread->thread_id));
		return_ACPI_STATUS(AE_AML_NOT_OWNER);
	}

	/*
	 * The sync level of the mutex must be equal to the current sync level. In
	 * other words, the current level means that at least one mutex at that
	 * level is currently being held. Attempting to release a mutex of a
	 * different level can only mean that the mutex ordering rule is being
	 * violated. This behavior is clarified in ACPI 4.0 specification.
	 */
	if (obj_desc->mutex.sync_level != owner_thread->current_sync_level) {
		ACPI_ERROR((AE_INFO,
			    "Cannot release Mutex [%4.4s], SyncLevel mismatch: "
			    "mutex %u current %u",
			    acpi_ut_get_node_name(obj_desc->mutex.node),
			    obj_desc->mutex.sync_level,
			    walk_state->thread->current_sync_level));
		return_ACPI_STATUS(AE_AML_MUTEX_ORDER);
	}

	/*
	 * Get the previous sync_level from the head of the acquired mutex list.
	 * This handles the case where several mutexes at the same level have been
	 * acquired, but are not released in reverse order.
	 */
	previous_sync_level =
	    owner_thread->acquired_mutex_list->mutex.original_sync_level;

	ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
			  "Releasing: Object SyncLevel %u, Thread SyncLevel %u, "
			  "Prev SyncLevel %u, Depth %u TID %p\n",
			  obj_desc->mutex.sync_level,
			  walk_state->thread->current_sync_level,
			  previous_sync_level,
			  obj_desc->mutex.acquisition_depth,
			  walk_state->thread));

	status = acpi_ex_release_mutex_object(obj_desc);
	if (ACPI_FAILURE(status)) {
		return_ACPI_STATUS(status);
	}

	if (obj_desc->mutex.acquisition_depth == 0) {

		/* Restore the previous sync_level */

		owner_thread->current_sync_level = previous_sync_level;
	}

	ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
			  "Released: Object SyncLevel %u, Thread SyncLevel, %u, "
			  "Prev SyncLevel %u, Depth %u\n",
			  obj_desc->mutex.sync_level,
			  walk_state->thread->current_sync_level,
			  previous_sync_level,
			  obj_desc->mutex.acquisition_depth));

	return_ACPI_STATUS(status);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_release_all_mutexes
 *
 * PARAMETERS:  thread              - Current executing thread object
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Release all mutexes held by this thread
 *
 * NOTE: This function is called as the thread is exiting the interpreter.
 * Mutexes are not released when an individual control method is exited, but
 * only when the parent thread actually exits the interpreter. This allows one
 * method to acquire a mutex, and a different method to release it, as long as
 * this is performed underneath a single parent control method.
 *
 ******************************************************************************/

void acpi_ex_release_all_mutexes(struct acpi_thread_state *thread)
{
	union acpi_operand_object *next = thread->acquired_mutex_list;
	union acpi_operand_object *obj_desc;

	ACPI_FUNCTION_TRACE(ex_release_all_mutexes);

	/* Traverse the list of owned mutexes, releasing each one */

	while (next) {
		obj_desc = next;
		ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
				  "Mutex [%4.4s] force-release, SyncLevel %u Depth %u\n",
				  obj_desc->mutex.node->name.ascii,
				  obj_desc->mutex.sync_level,
				  obj_desc->mutex.acquisition_depth));

		/* Release the mutex, special case for Global Lock */

		if (obj_desc == acpi_gbl_global_lock_mutex) {

			/* Ignore errors */

			(void)acpi_ev_release_global_lock();
		} else {
			acpi_os_release_mutex(obj_desc->mutex.os_mutex);
		}

		/* Update Thread sync_level (Last mutex is the important one) */

		thread->current_sync_level =
		    obj_desc->mutex.original_sync_level;

		/* Mark mutex unowned */

		next = obj_desc->mutex.next;

		obj_desc->mutex.prev = NULL;
		obj_desc->mutex.next = NULL;
		obj_desc->mutex.acquisition_depth = 0;
		obj_desc->mutex.owner_thread = NULL;
		obj_desc->mutex.thread_id = 0;
	}

	return_VOID;
}
Commit	Line	Data
95857638	1	// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
1da177e4 LT	2	/******************************************************************************
	3	*
	4	* Module Name: exmutex - ASL Mutex Acquire/Release functions
	5	*
da6f8320	6	* Copyright (C) 2000 - 2018, Intel Corp.
1da177e4	7	*
95857638	8	*****************************************************************************/
1da177e4	9
1da177e4	10	#include <acpi/acpi.h>
e2f7a777 LB	11	#include "accommon.h"
	12	#include "acinterp.h"
	13	#include "acevents.h"
1da177e4 LT	14
1da177e4 LT	15	#define _COMPONENT ACPI_EXECUTER
4be44fcd	16	ACPI_MODULE_NAME("exmutex")
1da177e4	17
44f6c012	18	/* Local prototypes */
44f6c012	19	static void
4be44fcd LB	20	acpi_ex_link_mutex(union acpi_operand_object *obj_desc,
4be44fcd LB	21	struct acpi_thread_state *thread);
1da177e4 LT	22
	23	/*******************************************************************************
	24	*
	25	* FUNCTION: acpi_ex_unlink_mutex
	26	*
	27	* PARAMETERS: obj_desc - The mutex to be unlinked
	28	*
44f6c012	29	* RETURN: None
1da177e4	30	*
b229cf92	31	* DESCRIPTION: Remove a mutex from the "AcquiredMutex" list
1da177e4 LT	32	*
	33	******************************************************************************/
	34
262a7a28	35	void acpi_ex_unlink_mutex(union acpi_operand_object *obj_desc)
1da177e4	36	{
262a7a28 LB	37	struct acpi_thread_state *thread = obj_desc->mutex.owner_thread;
262a7a28 LB	38
1da177e4 LT	39	if (!thread) {
	40	return;
	41	}
	42
	43	/* Doubly linked list */
	44
	45	if (obj_desc->mutex.next) {
	46	(obj_desc->mutex.next)->mutex.prev = obj_desc->mutex.prev;
	47	}
	48
	49	if (obj_desc->mutex.prev) {
	50	(obj_desc->mutex.prev)->mutex.next = obj_desc->mutex.next;
10a3b461 BM	51
10a3b461 BM	52	/*
a7499bc8 BM	53	* Migrate the previous sync level associated with this mutex to
	54	* the previous mutex on the list so that it may be preserved.
	55	* This handles the case where several mutexes have been acquired
	56	* at the same level, but are not released in opposite order.
10a3b461 BM	57	*/
	58	(obj_desc->mutex.prev)->mutex.original_sync_level =
	59	obj_desc->mutex.original_sync_level;
4be44fcd	60	} else {
1da177e4 LT	61	thread->acquired_mutex_list = obj_desc->mutex.next;
	62	}
	63	}
	64
1da177e4 LT	65	/*******************************************************************************
	66	*
	67	* FUNCTION: acpi_ex_link_mutex
	68	*
a7499bc8	69	* PARAMETERS: obj_desc - The mutex to be linked
ba494bee	70	* thread - Current executing thread object
1da177e4	71	*
44f6c012	72	* RETURN: None
1da177e4	73	*
b229cf92	74	* DESCRIPTION: Add a mutex to the "AcquiredMutex" list for this walk
1da177e4 LT	75	*
	76	******************************************************************************/
	77
44f6c012	78	static void
4be44fcd LB	79	acpi_ex_link_mutex(union acpi_operand_object *obj_desc,
4be44fcd LB	80	struct acpi_thread_state *thread)
1da177e4	81	{
4be44fcd	82	union acpi_operand_object *list_head;
1da177e4 LT	83
	84	list_head = thread->acquired_mutex_list;
	85
	86	/* This object will be the first object in the list */
	87
	88	obj_desc->mutex.prev = NULL;
	89	obj_desc->mutex.next = list_head;
	90
	91	/* Update old first object to point back to this object */
	92
	93	if (list_head) {
	94	list_head->mutex.prev = obj_desc;
	95	}
	96
	97	/* Update list head */
	98
	99	thread->acquired_mutex_list = obj_desc;
	100	}
	101
ba886cd4 BM	102	/*******************************************************************************
	103	*
	104	* FUNCTION: acpi_ex_acquire_mutex_object
	105	*
ba494bee	106	* PARAMETERS: timeout - Timeout in milliseconds
ba886cd4	107	* obj_desc - Mutex object
a7499bc8	108	* thread_id - Current thread state
ba886cd4 BM	109	*
	110	* RETURN: Status
	111	*
91e38d10 BM	112	* DESCRIPTION: Acquire an AML mutex, low-level interface. Provides a common
	113	* path that supports multiple acquires by the same thread.
	114	*
	115	* MUTEX: Interpreter must be locked
	116	*
	117	* NOTE: This interface is called from three places:
	118	* 1) From acpi_ex_acquire_mutex, via an AML Acquire() operator
	119	* 2) From acpi_ex_acquire_global_lock when an AML Field access requires the
	120	* global lock
	121	* 3) From the external interface, acpi_acquire_global_lock
ba886cd4 BM	122	*
	123	******************************************************************************/
	124
	125	acpi_status
	126	acpi_ex_acquire_mutex_object(u16 timeout,
	127	union acpi_operand_object *obj_desc,
	128	acpi_thread_id thread_id)
	129	{
	130	acpi_status status;
	131
	132	ACPI_FUNCTION_TRACE_PTR(ex_acquire_mutex_object, obj_desc);
	133
f02e9fa1 BM	134	if (!obj_desc) {
	135	return_ACPI_STATUS(AE_BAD_PARAMETER);
	136	}
	137
ba886cd4 BM	138	/* Support for multiple acquires by the owning thread */
	139
	140	if (obj_desc->mutex.thread_id == thread_id) {
	141	/*
	142	* The mutex is already owned by this thread, just increment the
	143	* acquisition depth
	144	*/
	145	obj_desc->mutex.acquisition_depth++;
	146	return_ACPI_STATUS(AE_OK);
	147	}
	148
	149	/* Acquire the mutex, wait if necessary. Special case for Global Lock */
	150
	151	if (obj_desc == acpi_gbl_global_lock_mutex) {
	152	status = acpi_ev_acquire_global_lock(timeout);
	153	} else {
cd162b35 BM	154	status =
	155	acpi_ex_system_wait_mutex(obj_desc->mutex.os_mutex,
	156	timeout);
ba886cd4 BM	157	}
	158
	159	if (ACPI_FAILURE(status)) {
	160
	161	/* Includes failure from a timeout on time_desc */
	162
	163	return_ACPI_STATUS(status);
	164	}
	165
91e38d10	166	/* Acquired the mutex: update mutex object */
ba886cd4 BM	167
	168	obj_desc->mutex.thread_id = thread_id;
	169	obj_desc->mutex.acquisition_depth = 1;
	170	obj_desc->mutex.original_sync_level = 0;
	171	obj_desc->mutex.owner_thread = NULL; /* Used only for AML Acquire() */
	172
	173	return_ACPI_STATUS(AE_OK);
	174	}
	175
1da177e4 LT	176	/*******************************************************************************
	177	*
	178	* FUNCTION: acpi_ex_acquire_mutex
	179	*
44f6c012 RM	180	* PARAMETERS: time_desc - Timeout integer
	181	* obj_desc - Mutex object
	182	* walk_state - Current method execution state
1da177e4 LT	183	*
	184	* RETURN: Status
	185	*
	186	* DESCRIPTION: Acquire an AML mutex
	187	*
	188	******************************************************************************/
	189
	190	acpi_status
4be44fcd LB	191	acpi_ex_acquire_mutex(union acpi_operand_object *time_desc,
	192	union acpi_operand_object *obj_desc,
	193	struct acpi_walk_state *walk_state)
1da177e4	194	{
4be44fcd	195	acpi_status status;
1da177e4	196
b229cf92	197	ACPI_FUNCTION_TRACE_PTR(ex_acquire_mutex, obj_desc);
1da177e4 LT	198
1da177e4 LT	199	if (!obj_desc) {
4be44fcd	200	return_ACPI_STATUS(AE_BAD_PARAMETER);
1da177e4 LT	201	}
1da177e4 LT	202
a7499bc8	203	/* Must have a valid thread state struct */
1da177e4 LT	204
1da177e4 LT	205	if (!walk_state->thread) {
b8e4d893 BM	206	ACPI_ERROR((AE_INFO,
	207	"Cannot acquire Mutex [%4.4s], null thread info",
	208	acpi_ut_get_node_name(obj_desc->mutex.node)));
4be44fcd	209	return_ACPI_STATUS(AE_AML_INTERNAL);
1da177e4 LT	210	}
	211
	212	/*
cd162b35 BM	213	* Current sync level must be less than or equal to the sync level
cd162b35 BM	214	* of the mutex. This mechanism provides some deadlock prevention.
1da177e4 LT	215	*/
1da177e4 LT	216	if (walk_state->thread->current_sync_level > obj_desc->mutex.sync_level) {
b8e4d893	217	ACPI_ERROR((AE_INFO,
cd162b35 BM	218	"Cannot acquire Mutex [%4.4s], "
cd162b35 BM	219	"current SyncLevel is too large (%u)",
967440e3 BM	220	acpi_ut_get_node_name(obj_desc->mutex.node),
967440e3 BM	221	walk_state->thread->current_sync_level));
4be44fcd	222	return_ACPI_STATUS(AE_AML_MUTEX_ORDER);
1da177e4 LT	223	}
1da177e4 LT	224
cd162b35 BM	225	ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
	226	"Acquiring: Mutex SyncLevel %u, Thread SyncLevel %u, "
	227	"Depth %u TID %p\n",
	228	obj_desc->mutex.sync_level,
	229	walk_state->thread->current_sync_level,
	230	obj_desc->mutex.acquisition_depth,
	231	walk_state->thread));
	232
5431b654	233	status = acpi_ex_acquire_mutex_object((u16)time_desc->integer.value,
ba886cd4 BM	234	obj_desc,
ba886cd4 BM	235	walk_state->thread->thread_id);
cd162b35	236
ba886cd4	237	if (ACPI_SUCCESS(status) && obj_desc->mutex.acquisition_depth == 1) {
91e38d10 BM	238
	239	/* Save Thread object, original/current sync levels */
	240
ba886cd4 BM	241	obj_desc->mutex.owner_thread = walk_state->thread;
	242	obj_desc->mutex.original_sync_level =
	243	walk_state->thread->current_sync_level;
	244	walk_state->thread->current_sync_level =
	245	obj_desc->mutex.sync_level;
1da177e4	246
ba886cd4 BM	247	/* Link the mutex to the current thread for force-unlock at method exit */
	248
	249	acpi_ex_link_mutex(obj_desc, walk_state->thread);
1da177e4 LT	250	}
1da177e4 LT	251
cd162b35 BM	252	ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
	253	"Acquired: Mutex SyncLevel %u, Thread SyncLevel %u, Depth %u\n",
	254	obj_desc->mutex.sync_level,
	255	walk_state->thread->current_sync_level,
	256	obj_desc->mutex.acquisition_depth));
	257
ba886cd4 BM	258	return_ACPI_STATUS(status);
ba886cd4 BM	259	}
c81da666	260
ba886cd4 BM	261	/*******************************************************************************
	262	*
	263	* FUNCTION: acpi_ex_release_mutex_object
	264	*
	265	* PARAMETERS: obj_desc - The object descriptor for this op
	266	*
	267	* RETURN: Status
	268	*
	269	* DESCRIPTION: Release a previously acquired Mutex, low level interface.
91e38d10 BM	270	* Provides a common path that supports multiple releases (after
	271	* previous multiple acquires) by the same thread.
	272	*
	273	* MUTEX: Interpreter must be locked
	274	*
	275	* NOTE: This interface is called from three places:
	276	* 1) From acpi_ex_release_mutex, via an AML Acquire() operator
	277	* 2) From acpi_ex_release_global_lock when an AML Field access requires the
	278	* global lock
	279	* 3) From the external interface, acpi_release_global_lock
ba886cd4 BM	280	*
ba886cd4 BM	281	******************************************************************************/
1da177e4	282
ba886cd4 BM	283	acpi_status acpi_ex_release_mutex_object(union acpi_operand_object *obj_desc)
	284	{
	285	acpi_status status = AE_OK;
52fc0b02	286
ba886cd4	287	ACPI_FUNCTION_TRACE(ex_release_mutex_object);
1da177e4	288
f02e9fa1	289	if (obj_desc->mutex.acquisition_depth == 0) {
68aafc35	290	return_ACPI_STATUS(AE_NOT_ACQUIRED);
f02e9fa1 BM	291	}
f02e9fa1 BM	292
ba886cd4 BM	293	/* Match multiple Acquires with multiple Releases */
	294
	295	obj_desc->mutex.acquisition_depth--;
	296	if (obj_desc->mutex.acquisition_depth != 0) {
	297
	298	/* Just decrement the depth and return */
	299
	300	return_ACPI_STATUS(AE_OK);
1da177e4 LT	301	}
1da177e4 LT	302
ba886cd4	303	if (obj_desc->mutex.owner_thread) {
1da177e4	304
ba886cd4 BM	305	/* Unlink the mutex from the owner's list */
	306
	307	acpi_ex_unlink_mutex(obj_desc);
	308	obj_desc->mutex.owner_thread = NULL;
	309	}
1da177e4	310
ba886cd4	311	/* Release the mutex, special case for Global Lock */
1da177e4	312
ba886cd4 BM	313	if (obj_desc == acpi_gbl_global_lock_mutex) {
	314	status = acpi_ev_release_global_lock();
	315	} else {
	316	acpi_os_release_mutex(obj_desc->mutex.os_mutex);
	317	}
1da177e4	318
91e38d10 BM	319	/* Clear mutex info */
91e38d10 BM	320
28eb3fcf	321	obj_desc->mutex.thread_id = 0;
ba886cd4	322	return_ACPI_STATUS(status);
1da177e4 LT	323	}
1da177e4 LT	324
1da177e4 LT	325	/*******************************************************************************
	326	*
	327	* FUNCTION: acpi_ex_release_mutex
	328	*
	329	* PARAMETERS: obj_desc - The object descriptor for this op
44f6c012	330	* walk_state - Current method execution state
1da177e4 LT	331	*
	332	* RETURN: Status
	333	*
	334	* DESCRIPTION: Release a previously acquired Mutex.
	335	*
	336	******************************************************************************/
	337
	338	acpi_status
4be44fcd LB	339	acpi_ex_release_mutex(union acpi_operand_object *obj_desc,
4be44fcd LB	340	struct acpi_walk_state *walk_state)
1da177e4	341	{
10a3b461	342	u8 previous_sync_level;
e0f40281	343	struct acpi_thread_state *owner_thread;
cd162b35	344	acpi_status status = AE_OK;
1da177e4	345
b229cf92	346	ACPI_FUNCTION_TRACE(ex_release_mutex);
1da177e4 LT	347
1da177e4 LT	348	if (!obj_desc) {
4be44fcd	349	return_ACPI_STATUS(AE_BAD_PARAMETER);
1da177e4 LT	350	}
1da177e4 LT	351
e0f40281 LM	352	owner_thread = obj_desc->mutex.owner_thread;
e0f40281 LM	353
1da177e4 LT	354	/* The mutex must have been previously acquired in order to release it */
1da177e4 LT	355
e0f40281	356	if (!owner_thread) {
b8e4d893 BM	357	ACPI_ERROR((AE_INFO,
	358	"Cannot release Mutex [%4.4s], not acquired",
	359	acpi_ut_get_node_name(obj_desc->mutex.node)));
4be44fcd	360	return_ACPI_STATUS(AE_AML_MUTEX_NOT_ACQUIRED);
1da177e4 LT	361	}
1da177e4 LT	362
75c8044f	363	/* Must have a valid thread ID */
3e8214e5	364
fbc3be2a DC	365	if (!walk_state->thread) {
	366	ACPI_ERROR((AE_INFO,
	367	"Cannot release Mutex [%4.4s], null thread info",
	368	acpi_ut_get_node_name(obj_desc->mutex.node)));
	369	return_ACPI_STATUS(AE_AML_INTERNAL);
	370	}
	371
1da177e4 LT	372	/*
	373	* The Mutex is owned, but this thread must be the owner.
	374	* Special case for Global Lock, any thread can release
	375	*/
e0f40281 LM	376	if ((owner_thread->thread_id != walk_state->thread->thread_id) &&
e0f40281 LM	377	(obj_desc != acpi_gbl_global_lock_mutex)) {
b8e4d893	378	ACPI_ERROR((AE_INFO,
28eb3fcf LM	379	"Thread %u cannot release Mutex [%4.4s] acquired by thread %u",
28eb3fcf LM	380	(u32)walk_state->thread->thread_id,
b8e4d893	381	acpi_ut_get_node_name(obj_desc->mutex.node),
28eb3fcf	382	(u32)owner_thread->thread_id));
4be44fcd	383	return_ACPI_STATUS(AE_AML_NOT_OWNER);
1da177e4 LT	384	}
	385
	386	/*
315c7288 BM	387	* The sync level of the mutex must be equal to the current sync level. In
	388	* other words, the current level means that at least one mutex at that
	389	* level is currently being held. Attempting to release a mutex of a
	390	* different level can only mean that the mutex ordering rule is being
	391	* violated. This behavior is clarified in ACPI 4.0 specification.
1da177e4	392	*/
e0f40281	393	if (obj_desc->mutex.sync_level != owner_thread->current_sync_level) {
b8e4d893	394	ACPI_ERROR((AE_INFO,
cd162b35 BM	395	"Cannot release Mutex [%4.4s], SyncLevel mismatch: "
cd162b35 BM	396	"mutex %u current %u",
f02e9fa1 BM	397	acpi_ut_get_node_name(obj_desc->mutex.node),
	398	obj_desc->mutex.sync_level,
	399	walk_state->thread->current_sync_level));
4be44fcd	400	return_ACPI_STATUS(AE_AML_MUTEX_ORDER);
1da177e4 LT	401	}
1da177e4 LT	402
10a3b461 BM	403	/*
	404	* Get the previous sync_level from the head of the acquired mutex list.
	405	* This handles the case where several mutexes at the same level have been
	406	* acquired, but are not released in reverse order.
	407	*/
	408	previous_sync_level =
e0f40281	409	owner_thread->acquired_mutex_list->mutex.original_sync_level;
10a3b461	410
cd162b35 BM	411	ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
	412	"Releasing: Object SyncLevel %u, Thread SyncLevel %u, "
	413	"Prev SyncLevel %u, Depth %u TID %p\n",
	414	obj_desc->mutex.sync_level,
	415	walk_state->thread->current_sync_level,
	416	previous_sync_level,
	417	obj_desc->mutex.acquisition_depth,
	418	walk_state->thread));
	419
ba886cd4	420	status = acpi_ex_release_mutex_object(obj_desc);
315c7288 BM	421	if (ACPI_FAILURE(status)) {
	422	return_ACPI_STATUS(status);
	423	}
1da177e4	424
f02e9fa1	425	if (obj_desc->mutex.acquisition_depth == 0) {
1da177e4	426
315c7288	427	/* Restore the previous sync_level */
f02e9fa1	428
e0f40281	429	owner_thread->current_sync_level = previous_sync_level;
f02e9fa1	430	}
a7499bc8	431
cd162b35 BM	432	ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
	433	"Released: Object SyncLevel %u, Thread SyncLevel, %u, "
	434	"Prev SyncLevel %u, Depth %u\n",
	435	obj_desc->mutex.sync_level,
	436	walk_state->thread->current_sync_level,
	437	previous_sync_level,
	438	obj_desc->mutex.acquisition_depth));
	439
4be44fcd	440	return_ACPI_STATUS(status);
1da177e4 LT	441	}
1da177e4 LT	442
1da177e4 LT	443	/*******************************************************************************
	444	*
	445	* FUNCTION: acpi_ex_release_all_mutexes
	446	*
ba494bee	447	* PARAMETERS: thread - Current executing thread object
1da177e4 LT	448	*
	449	* RETURN: Status
	450	*
44f6c012	451	* DESCRIPTION: Release all mutexes held by this thread
1da177e4	452	*
f70a5e7b BM	453	* NOTE: This function is called as the thread is exiting the interpreter.
	454	* Mutexes are not released when an individual control method is exited, but
	455	* only when the parent thread actually exits the interpreter. This allows one
	456	* method to acquire a mutex, and a different method to release it, as long as
	457	* this is performed underneath a single parent control method.
	458	*
1da177e4 LT	459	******************************************************************************/
1da177e4 LT	460
4be44fcd	461	void acpi_ex_release_all_mutexes(struct acpi_thread_state *thread)
1da177e4	462	{
4be44fcd	463	union acpi_operand_object *next = thread->acquired_mutex_list;
c81da666	464	union acpi_operand_object *obj_desc;
1da177e4	465
cd162b35	466	ACPI_FUNCTION_TRACE(ex_release_all_mutexes);
1da177e4 LT	467
	468	/* Traverse the list of owned mutexes, releasing each one */
	469
	470	while (next) {
c81da666	471	obj_desc = next;
2489ef01	472	ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
cd162b35 BM	473	"Mutex [%4.4s] force-release, SyncLevel %u Depth %u\n",
	474	obj_desc->mutex.node->name.ascii,
	475	obj_desc->mutex.sync_level,
	476	obj_desc->mutex.acquisition_depth));
2489ef01	477
c81da666	478	/* Release the mutex, special case for Global Lock */
1da177e4	479
ba886cd4	480	if (obj_desc == acpi_gbl_global_lock_mutex) {
1da177e4	481
c81da666	482	/* Ignore errors */
1da177e4	483
c81da666 BM	484	(void)acpi_ev_release_global_lock();
	485	} else {
	486	acpi_os_release_mutex(obj_desc->mutex.os_mutex);
1da177e4 LT	487	}
1da177e4 LT	488
1da177e4 LT	489	/* Update Thread sync_level (Last mutex is the important one) */
1da177e4 LT	490
c81da666 BM	491	thread->current_sync_level =
c81da666 BM	492	obj_desc->mutex.original_sync_level;
cd162b35 BM	493
	494	/* Mark mutex unowned */
	495
	496	next = obj_desc->mutex.next;
	497
	498	obj_desc->mutex.prev = NULL;
	499	obj_desc->mutex.next = NULL;
	500	obj_desc->mutex.acquisition_depth = 0;
	501	obj_desc->mutex.owner_thread = NULL;
	502	obj_desc->mutex.thread_id = 0;
1da177e4	503	}
cd162b35 BM	504
cd162b35 BM	505	return_VOID;
1da177e4	506	}