1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 /******************************************************************************
3  *
4  * Name: hwxfsleep.c - ACPI Hardware Sleep/Wake External Interfaces
5  *
6  * Copyright (C) 2000 - 2023, Intel Corp.
7  *
8  *****************************************************************************/
9 
10 #define EXPORT_ACPI_INTERFACES
11 
12 #include <acpi/acpi.h>
13 #include "accommon.h"
14 
15 #define _COMPONENT          ACPI_HARDWARE
16 ACPI_MODULE_NAME("hwxfsleep")
17 
18 /* Local prototypes */
19 #if (!ACPI_REDUCED_HARDWARE)
20 static acpi_status
21 acpi_hw_set_firmware_waking_vector(struct acpi_table_facs *facs,
22 				   acpi_physical_address physical_address,
23 				   acpi_physical_address physical_address64);
24 #endif
25 
26 /*
27  * These functions are removed for the ACPI_REDUCED_HARDWARE case:
28  *      acpi_set_firmware_waking_vector
29  *      acpi_enter_sleep_state_s4bios
30  */
31 
32 #if (!ACPI_REDUCED_HARDWARE)
33 /*******************************************************************************
34  *
35  * FUNCTION:    acpi_hw_set_firmware_waking_vector
36  *
37  * PARAMETERS:  facs                - Pointer to FACS table
38  *              physical_address    - 32-bit physical address of ACPI real mode
39  *                                    entry point
40  *              physical_address64  - 64-bit physical address of ACPI protected
41  *                                    mode entry point
42  *
43  * RETURN:      Status
44  *
45  * DESCRIPTION: Sets the firmware_waking_vector fields of the FACS
46  *
47  ******************************************************************************/
48 
49 static acpi_status
acpi_hw_set_firmware_waking_vector(struct acpi_table_facs * facs,acpi_physical_address physical_address,acpi_physical_address physical_address64)50 acpi_hw_set_firmware_waking_vector(struct acpi_table_facs *facs,
51 				   acpi_physical_address physical_address,
52 				   acpi_physical_address physical_address64)
53 {
54 	ACPI_FUNCTION_TRACE(acpi_hw_set_firmware_waking_vector);
55 
56 
57 	/*
58 	 * According to the ACPI specification 2.0c and later, the 64-bit
59 	 * waking vector should be cleared and the 32-bit waking vector should
60 	 * be used, unless we want the wake-up code to be called by the BIOS in
61 	 * Protected Mode.  Some systems (for example HP dv5-1004nr) are known
62 	 * to fail to resume if the 64-bit vector is used.
63 	 */
64 
65 	/* Set the 32-bit vector */
66 
67 	facs->firmware_waking_vector = (u32)physical_address;
68 
69 	if (facs->length > 32) {
70 		if (facs->version >= 1) {
71 
72 			/* Set the 64-bit vector */
73 
74 			facs->xfirmware_waking_vector = physical_address64;
75 		} else {
76 			/* Clear the 64-bit vector if it exists */
77 
78 			facs->xfirmware_waking_vector = 0;
79 		}
80 	}
81 
82 	return_ACPI_STATUS(AE_OK);
83 }
84 
85 /*******************************************************************************
86  *
87  * FUNCTION:    acpi_set_firmware_waking_vector
88  *
89  * PARAMETERS:  physical_address    - 32-bit physical address of ACPI real mode
90  *                                    entry point
91  *              physical_address64  - 64-bit physical address of ACPI protected
92  *                                    mode entry point
93  *
94  * RETURN:      Status
95  *
96  * DESCRIPTION: Sets the firmware_waking_vector fields of the FACS
97  *
98  ******************************************************************************/
99 
100 acpi_status
acpi_set_firmware_waking_vector(acpi_physical_address physical_address,acpi_physical_address physical_address64)101 acpi_set_firmware_waking_vector(acpi_physical_address physical_address,
102 				acpi_physical_address physical_address64)
103 {
104 
105 	ACPI_FUNCTION_TRACE(acpi_set_firmware_waking_vector);
106 
107 	if (acpi_gbl_FACS) {
108 		(void)acpi_hw_set_firmware_waking_vector(acpi_gbl_FACS,
109 							 physical_address,
110 							 physical_address64);
111 	}
112 
113 	return_ACPI_STATUS(AE_OK);
114 }
115 
ACPI_EXPORT_SYMBOL(acpi_set_firmware_waking_vector)116 ACPI_EXPORT_SYMBOL(acpi_set_firmware_waking_vector)
117 
118 /*******************************************************************************
119  *
120  * FUNCTION:    acpi_enter_sleep_state_s4bios
121  *
122  * PARAMETERS:  None
123  *
124  * RETURN:      Status
125  *
126  * DESCRIPTION: Perform a S4 bios request.
127  *              THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED
128  *
129  ******************************************************************************/
130 acpi_status acpi_enter_sleep_state_s4bios(void)
131 {
132 	u32 in_value;
133 	acpi_status status;
134 
135 	ACPI_FUNCTION_TRACE(acpi_enter_sleep_state_s4bios);
136 
137 	/* Clear the wake status bit (PM1) */
138 
139 	status =
140 	    acpi_write_bit_register(ACPI_BITREG_WAKE_STATUS, ACPI_CLEAR_STATUS);
141 	if (ACPI_FAILURE(status)) {
142 		return_ACPI_STATUS(status);
143 	}
144 
145 	status = acpi_hw_clear_acpi_status();
146 	if (ACPI_FAILURE(status)) {
147 		return_ACPI_STATUS(status);
148 	}
149 
150 	/*
151 	 * 1) Disable all GPEs
152 	 * 2) Enable all wakeup GPEs
153 	 */
154 	status = acpi_hw_disable_all_gpes();
155 	if (ACPI_FAILURE(status)) {
156 		return_ACPI_STATUS(status);
157 	}
158 	acpi_gbl_system_awake_and_running = FALSE;
159 
160 	status = acpi_hw_enable_all_wakeup_gpes();
161 	if (ACPI_FAILURE(status)) {
162 		return_ACPI_STATUS(status);
163 	}
164 
165 	status = acpi_hw_write_port(acpi_gbl_FADT.smi_command,
166 				    (u32)acpi_gbl_FADT.s4_bios_request, 8);
167 	if (ACPI_FAILURE(status)) {
168 		return_ACPI_STATUS(status);
169 	}
170 
171 	do {
172 		acpi_os_stall(ACPI_USEC_PER_MSEC);
173 		status =
174 		    acpi_read_bit_register(ACPI_BITREG_WAKE_STATUS, &in_value);
175 		if (ACPI_FAILURE(status)) {
176 			return_ACPI_STATUS(status);
177 		}
178 
179 	} while (!in_value);
180 
181 	return_ACPI_STATUS(AE_OK);
182 }
183 
ACPI_EXPORT_SYMBOL(acpi_enter_sleep_state_s4bios)184 ACPI_EXPORT_SYMBOL(acpi_enter_sleep_state_s4bios)
185 #endif				/* !ACPI_REDUCED_HARDWARE */
186 
187 /*******************************************************************************
188  *
189  * FUNCTION:    acpi_enter_sleep_state_prep
190  *
191  * PARAMETERS:  sleep_state         - Which sleep state to enter
192  *
193  * RETURN:      Status
194  *
195  * DESCRIPTION: Prepare to enter a system sleep state.
196  *              This function must execute with interrupts enabled.
197  *              We break sleeping into 2 stages so that OSPM can handle
198  *              various OS-specific tasks between the two steps.
199  *
200  ******************************************************************************/
201 
202 acpi_status acpi_enter_sleep_state_prep(u8 sleep_state)
203 {
204 	acpi_status status;
205 	struct acpi_object_list arg_list;
206 	union acpi_object arg;
207 	u32 sst_value;
208 
209 	ACPI_FUNCTION_TRACE(acpi_enter_sleep_state_prep);
210 
211 	status = acpi_get_sleep_type_data(sleep_state,
212 					  &acpi_gbl_sleep_type_a,
213 					  &acpi_gbl_sleep_type_b);
214 	if (ACPI_FAILURE(status)) {
215 		return_ACPI_STATUS(status);
216 	}
217 
218 	status = acpi_get_sleep_type_data(ACPI_STATE_S0,
219 					  &acpi_gbl_sleep_type_a_s0,
220 					  &acpi_gbl_sleep_type_b_s0);
221 	if (ACPI_FAILURE(status)) {
222 		acpi_gbl_sleep_type_a_s0 = ACPI_SLEEP_TYPE_INVALID;
223 	}
224 
225 	/* Execute the _PTS method (Prepare To Sleep) */
226 
227 	arg_list.count = 1;
228 	arg_list.pointer = &arg;
229 	arg.type = ACPI_TYPE_INTEGER;
230 	arg.integer.value = sleep_state;
231 
232 	status =
233 	    acpi_evaluate_object(NULL, METHOD_PATHNAME__PTS, &arg_list, NULL);
234 	if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
235 		return_ACPI_STATUS(status);
236 	}
237 
238 	/* Setup the argument to the _SST method (System STatus) */
239 
240 	switch (sleep_state) {
241 	case ACPI_STATE_S0:
242 
243 		sst_value = ACPI_SST_WORKING;
244 		break;
245 
246 	case ACPI_STATE_S1:
247 	case ACPI_STATE_S2:
248 	case ACPI_STATE_S3:
249 
250 		sst_value = ACPI_SST_SLEEPING;
251 		break;
252 
253 	case ACPI_STATE_S4:
254 
255 		sst_value = ACPI_SST_SLEEP_CONTEXT;
256 		break;
257 
258 	default:
259 
260 		sst_value = ACPI_SST_INDICATOR_OFF;	/* Default is off */
261 		break;
262 	}
263 
264 	/*
265 	 * Set the system indicators to show the desired sleep state.
266 	 * _SST is an optional method (return no error if not found)
267 	 */
268 	acpi_hw_execute_sleep_method(METHOD_PATHNAME__SST, sst_value);
269 	return_ACPI_STATUS(AE_OK);
270 }
271 
ACPI_EXPORT_SYMBOL(acpi_enter_sleep_state_prep)272 ACPI_EXPORT_SYMBOL(acpi_enter_sleep_state_prep)
273 
274 /*******************************************************************************
275  *
276  * FUNCTION:    acpi_enter_sleep_state
277  *
278  * PARAMETERS:  sleep_state         - Which sleep state to enter
279  *
280  * RETURN:      Status
281  *
282  * DESCRIPTION: Enter a system sleep state
283  *              THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED
284  *
285  ******************************************************************************/
286 acpi_status acpi_enter_sleep_state(u8 sleep_state)
287 {
288 	acpi_status status;
289 
290 	ACPI_FUNCTION_TRACE(acpi_enter_sleep_state);
291 
292 	if ((acpi_gbl_sleep_type_a > ACPI_SLEEP_TYPE_MAX) ||
293 	    (acpi_gbl_sleep_type_b > ACPI_SLEEP_TYPE_MAX)) {
294 		ACPI_ERROR((AE_INFO, "Sleep values out of range: A=0x%X B=0x%X",
295 			    acpi_gbl_sleep_type_a, acpi_gbl_sleep_type_b));
296 		return_ACPI_STATUS(AE_AML_OPERAND_VALUE);
297 	}
298 
299 #if !ACPI_REDUCED_HARDWARE
300 	if (!acpi_gbl_reduced_hardware)
301 		status = acpi_hw_legacy_sleep(sleep_state);
302 	else
303 #endif
304 		status = acpi_hw_extended_sleep(sleep_state);
305 	return_ACPI_STATUS(status);
306 }
307 
ACPI_EXPORT_SYMBOL(acpi_enter_sleep_state)308 ACPI_EXPORT_SYMBOL(acpi_enter_sleep_state)
309 
310 /*******************************************************************************
311  *
312  * FUNCTION:    acpi_leave_sleep_state_prep
313  *
314  * PARAMETERS:  sleep_state         - Which sleep state we are exiting
315  *
316  * RETURN:      Status
317  *
318  * DESCRIPTION: Perform the first state of OS-independent ACPI cleanup after a
319  *              sleep. Called with interrupts DISABLED.
320  *              We break wake/resume into 2 stages so that OSPM can handle
321  *              various OS-specific tasks between the two steps.
322  *
323  ******************************************************************************/
324 acpi_status acpi_leave_sleep_state_prep(u8 sleep_state)
325 {
326 	acpi_status status;
327 
328 	ACPI_FUNCTION_TRACE(acpi_leave_sleep_state_prep);
329 
330 #if !ACPI_REDUCED_HARDWARE
331 	if (!acpi_gbl_reduced_hardware)
332 		status = acpi_hw_legacy_wake_prep(sleep_state);
333 	else
334 #endif
335 		status = acpi_hw_extended_wake_prep(sleep_state);
336 	return_ACPI_STATUS(status);
337 }
338 
ACPI_EXPORT_SYMBOL(acpi_leave_sleep_state_prep)339 ACPI_EXPORT_SYMBOL(acpi_leave_sleep_state_prep)
340 
341 /*******************************************************************************
342  *
343  * FUNCTION:    acpi_leave_sleep_state
344  *
345  * PARAMETERS:  sleep_state         - Which sleep state we are exiting
346  *
347  * RETURN:      Status
348  *
349  * DESCRIPTION: Perform OS-independent ACPI cleanup after a sleep
350  *              Called with interrupts ENABLED.
351  *
352  ******************************************************************************/
353 acpi_status acpi_leave_sleep_state(u8 sleep_state)
354 {
355 	acpi_status status;
356 
357 	ACPI_FUNCTION_TRACE(acpi_leave_sleep_state);
358 
359 #if !ACPI_REDUCED_HARDWARE
360 	if (!acpi_gbl_reduced_hardware)
361 		status = acpi_hw_legacy_wake(sleep_state);
362 	else
363 #endif
364 		status = acpi_hw_extended_wake(sleep_state);
365 	return_ACPI_STATUS(status);
366 }
367 
368 ACPI_EXPORT_SYMBOL(acpi_leave_sleep_state)
369