xref: /openbmc/linux/drivers/acpi/acpica/evglock.c (revision 20e2fc42)
1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 /******************************************************************************
3  *
4  * Module Name: evglock - Global Lock support
5  *
6  * Copyright (C) 2000 - 2019, Intel Corp.
7  *
8  *****************************************************************************/
9 
10 #include <acpi/acpi.h>
11 #include "accommon.h"
12 #include "acevents.h"
13 #include "acinterp.h"
14 
15 #define _COMPONENT          ACPI_EVENTS
16 ACPI_MODULE_NAME("evglock")
17 #if (!ACPI_REDUCED_HARDWARE)	/* Entire module */
18 /* Local prototypes */
19 static u32 acpi_ev_global_lock_handler(void *context);
20 
21 /*******************************************************************************
22  *
23  * FUNCTION:    acpi_ev_init_global_lock_handler
24  *
25  * PARAMETERS:  None
26  *
27  * RETURN:      Status
28  *
29  * DESCRIPTION: Install a handler for the global lock release event
30  *
31  ******************************************************************************/
32 
33 acpi_status acpi_ev_init_global_lock_handler(void)
34 {
35 	acpi_status status;
36 
37 	ACPI_FUNCTION_TRACE(ev_init_global_lock_handler);
38 
39 	/* If Hardware Reduced flag is set, there is no global lock */
40 
41 	if (acpi_gbl_reduced_hardware) {
42 		return_ACPI_STATUS(AE_OK);
43 	}
44 
45 	/* Attempt installation of the global lock handler */
46 
47 	status = acpi_install_fixed_event_handler(ACPI_EVENT_GLOBAL,
48 						  acpi_ev_global_lock_handler,
49 						  NULL);
50 
51 	/*
52 	 * If the global lock does not exist on this platform, the attempt to
53 	 * enable GBL_STATUS will fail (the GBL_ENABLE bit will not stick).
54 	 * Map to AE_OK, but mark global lock as not present. Any attempt to
55 	 * actually use the global lock will be flagged with an error.
56 	 */
57 	acpi_gbl_global_lock_present = FALSE;
58 	if (status == AE_NO_HARDWARE_RESPONSE) {
59 		ACPI_ERROR((AE_INFO,
60 			    "No response from Global Lock hardware, disabling lock"));
61 
62 		return_ACPI_STATUS(AE_OK);
63 	}
64 
65 	status = acpi_os_create_lock(&acpi_gbl_global_lock_pending_lock);
66 	if (ACPI_FAILURE(status)) {
67 		return_ACPI_STATUS(status);
68 	}
69 
70 	acpi_gbl_global_lock_pending = FALSE;
71 	acpi_gbl_global_lock_present = TRUE;
72 	return_ACPI_STATUS(status);
73 }
74 
75 /*******************************************************************************
76  *
77  * FUNCTION:    acpi_ev_remove_global_lock_handler
78  *
79  * PARAMETERS:  None
80  *
81  * RETURN:      Status
82  *
83  * DESCRIPTION: Remove the handler for the Global Lock
84  *
85  ******************************************************************************/
86 
87 acpi_status acpi_ev_remove_global_lock_handler(void)
88 {
89 	acpi_status status;
90 
91 	ACPI_FUNCTION_TRACE(ev_remove_global_lock_handler);
92 
93 	acpi_gbl_global_lock_present = FALSE;
94 	status = acpi_remove_fixed_event_handler(ACPI_EVENT_GLOBAL,
95 						 acpi_ev_global_lock_handler);
96 
97 	acpi_os_delete_lock(acpi_gbl_global_lock_pending_lock);
98 	return_ACPI_STATUS(status);
99 }
100 
101 /*******************************************************************************
102  *
103  * FUNCTION:    acpi_ev_global_lock_handler
104  *
105  * PARAMETERS:  context         - From thread interface, not used
106  *
107  * RETURN:      ACPI_INTERRUPT_HANDLED
108  *
109  * DESCRIPTION: Invoked directly from the SCI handler when a global lock
110  *              release interrupt occurs. If there is actually a pending
111  *              request for the lock, signal the waiting thread.
112  *
113  ******************************************************************************/
114 
115 static u32 acpi_ev_global_lock_handler(void *context)
116 {
117 	acpi_status status;
118 	acpi_cpu_flags flags;
119 
120 	flags = acpi_os_acquire_lock(acpi_gbl_global_lock_pending_lock);
121 
122 	/*
123 	 * If a request for the global lock is not actually pending,
124 	 * we are done. This handles "spurious" global lock interrupts
125 	 * which are possible (and have been seen) with bad BIOSs.
126 	 */
127 	if (!acpi_gbl_global_lock_pending) {
128 		goto cleanup_and_exit;
129 	}
130 
131 	/*
132 	 * Send a unit to the global lock semaphore. The actual acquisition
133 	 * of the global lock will be performed by the waiting thread.
134 	 */
135 	status = acpi_os_signal_semaphore(acpi_gbl_global_lock_semaphore, 1);
136 	if (ACPI_FAILURE(status)) {
137 		ACPI_ERROR((AE_INFO, "Could not signal Global Lock semaphore"));
138 	}
139 
140 	acpi_gbl_global_lock_pending = FALSE;
141 
142 cleanup_and_exit:
143 
144 	acpi_os_release_lock(acpi_gbl_global_lock_pending_lock, flags);
145 	return (ACPI_INTERRUPT_HANDLED);
146 }
147 
148 /******************************************************************************
149  *
150  * FUNCTION:    acpi_ev_acquire_global_lock
151  *
152  * PARAMETERS:  timeout         - Max time to wait for the lock, in millisec.
153  *
154  * RETURN:      Status
155  *
156  * DESCRIPTION: Attempt to gain ownership of the Global Lock.
157  *
158  * MUTEX:       Interpreter must be locked
159  *
160  * Note: The original implementation allowed multiple threads to "acquire" the
161  * Global Lock, and the OS would hold the lock until the last thread had
162  * released it. However, this could potentially starve the BIOS out of the
163  * lock, especially in the case where there is a tight handshake between the
164  * Embedded Controller driver and the BIOS. Therefore, this implementation
165  * allows only one thread to acquire the HW Global Lock at a time, and makes
166  * the global lock appear as a standard mutex on the OS side.
167  *
168  *****************************************************************************/
169 
170 acpi_status acpi_ev_acquire_global_lock(u16 timeout)
171 {
172 	acpi_cpu_flags flags;
173 	acpi_status status;
174 	u8 acquired = FALSE;
175 
176 	ACPI_FUNCTION_TRACE(ev_acquire_global_lock);
177 
178 	/*
179 	 * Only one thread can acquire the GL at a time, the global_lock_mutex
180 	 * enforces this. This interface releases the interpreter if we must wait.
181 	 */
182 	status =
183 	    acpi_ex_system_wait_mutex(acpi_gbl_global_lock_mutex->mutex.
184 				      os_mutex, timeout);
185 	if (ACPI_FAILURE(status)) {
186 		return_ACPI_STATUS(status);
187 	}
188 
189 	/*
190 	 * Update the global lock handle and check for wraparound. The handle is
191 	 * only used for the external global lock interfaces, but it is updated
192 	 * here to properly handle the case where a single thread may acquire the
193 	 * lock via both the AML and the acpi_acquire_global_lock interfaces. The
194 	 * handle is therefore updated on the first acquire from a given thread
195 	 * regardless of where the acquisition request originated.
196 	 */
197 	acpi_gbl_global_lock_handle++;
198 	if (acpi_gbl_global_lock_handle == 0) {
199 		acpi_gbl_global_lock_handle = 1;
200 	}
201 
202 	/*
203 	 * Make sure that a global lock actually exists. If not, just
204 	 * treat the lock as a standard mutex.
205 	 */
206 	if (!acpi_gbl_global_lock_present) {
207 		acpi_gbl_global_lock_acquired = TRUE;
208 		return_ACPI_STATUS(AE_OK);
209 	}
210 
211 	flags = acpi_os_acquire_lock(acpi_gbl_global_lock_pending_lock);
212 
213 	do {
214 
215 		/* Attempt to acquire the actual hardware lock */
216 
217 		ACPI_ACQUIRE_GLOBAL_LOCK(acpi_gbl_FACS, acquired);
218 		if (acquired) {
219 			acpi_gbl_global_lock_acquired = TRUE;
220 			ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
221 					  "Acquired hardware Global Lock\n"));
222 			break;
223 		}
224 
225 		/*
226 		 * Did not get the lock. The pending bit was set above, and
227 		 * we must now wait until we receive the global lock
228 		 * released interrupt.
229 		 */
230 		acpi_gbl_global_lock_pending = TRUE;
231 		acpi_os_release_lock(acpi_gbl_global_lock_pending_lock, flags);
232 
233 		ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
234 				  "Waiting for hardware Global Lock\n"));
235 
236 		/*
237 		 * Wait for handshake with the global lock interrupt handler.
238 		 * This interface releases the interpreter if we must wait.
239 		 */
240 		status =
241 		    acpi_ex_system_wait_semaphore
242 		    (acpi_gbl_global_lock_semaphore, ACPI_WAIT_FOREVER);
243 
244 		flags = acpi_os_acquire_lock(acpi_gbl_global_lock_pending_lock);
245 
246 	} while (ACPI_SUCCESS(status));
247 
248 	acpi_gbl_global_lock_pending = FALSE;
249 	acpi_os_release_lock(acpi_gbl_global_lock_pending_lock, flags);
250 
251 	return_ACPI_STATUS(status);
252 }
253 
254 /*******************************************************************************
255  *
256  * FUNCTION:    acpi_ev_release_global_lock
257  *
258  * PARAMETERS:  None
259  *
260  * RETURN:      Status
261  *
262  * DESCRIPTION: Releases ownership of the Global Lock.
263  *
264  ******************************************************************************/
265 
266 acpi_status acpi_ev_release_global_lock(void)
267 {
268 	u8 pending = FALSE;
269 	acpi_status status = AE_OK;
270 
271 	ACPI_FUNCTION_TRACE(ev_release_global_lock);
272 
273 	/* Lock must be already acquired */
274 
275 	if (!acpi_gbl_global_lock_acquired) {
276 		ACPI_WARNING((AE_INFO,
277 			      "Cannot release the ACPI Global Lock, it has not been acquired"));
278 		return_ACPI_STATUS(AE_NOT_ACQUIRED);
279 	}
280 
281 	if (acpi_gbl_global_lock_present) {
282 
283 		/* Allow any thread to release the lock */
284 
285 		ACPI_RELEASE_GLOBAL_LOCK(acpi_gbl_FACS, pending);
286 
287 		/*
288 		 * If the pending bit was set, we must write GBL_RLS to the control
289 		 * register
290 		 */
291 		if (pending) {
292 			status =
293 			    acpi_write_bit_register
294 			    (ACPI_BITREG_GLOBAL_LOCK_RELEASE,
295 			     ACPI_ENABLE_EVENT);
296 		}
297 
298 		ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
299 				  "Released hardware Global Lock\n"));
300 	}
301 
302 	acpi_gbl_global_lock_acquired = FALSE;
303 
304 	/* Release the local GL mutex */
305 
306 	acpi_os_release_mutex(acpi_gbl_global_lock_mutex->mutex.os_mutex);
307 	return_ACPI_STATUS(status);
308 }
309 
310 #endif				/* !ACPI_REDUCED_HARDWARE */
311