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 - 2021, 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 	ACPI_FLUSH_CPU_CACHE();
166 
167 	status = acpi_hw_write_port(acpi_gbl_FADT.smi_command,
168 				    (u32)acpi_gbl_FADT.s4_bios_request, 8);
169 	if (ACPI_FAILURE(status)) {
170 		return_ACPI_STATUS(status);
171 	}
172 
173 	do {
174 		acpi_os_stall(ACPI_USEC_PER_MSEC);
175 		status =
176 		    acpi_read_bit_register(ACPI_BITREG_WAKE_STATUS, &in_value);
177 		if (ACPI_FAILURE(status)) {
178 			return_ACPI_STATUS(status);
179 		}
180 
181 	} while (!in_value);
182 
183 	return_ACPI_STATUS(AE_OK);
184 }
185 
ACPI_EXPORT_SYMBOL(acpi_enter_sleep_state_s4bios)186 ACPI_EXPORT_SYMBOL(acpi_enter_sleep_state_s4bios)
187 #endif				/* !ACPI_REDUCED_HARDWARE */
188 
189 /*******************************************************************************
190  *
191  * FUNCTION:    acpi_enter_sleep_state_prep
192  *
193  * PARAMETERS:  sleep_state         - Which sleep state to enter
194  *
195  * RETURN:      Status
196  *
197  * DESCRIPTION: Prepare to enter a system sleep state.
198  *              This function must execute with interrupts enabled.
199  *              We break sleeping into 2 stages so that OSPM can handle
200  *              various OS-specific tasks between the two steps.
201  *
202  ******************************************************************************/
203 
204 acpi_status acpi_enter_sleep_state_prep(u8 sleep_state)
205 {
206 	acpi_status status;
207 	struct acpi_object_list arg_list;
208 	union acpi_object arg;
209 	u32 sst_value;
210 
211 	ACPI_FUNCTION_TRACE(acpi_enter_sleep_state_prep);
212 
213 	status = acpi_get_sleep_type_data(sleep_state,
214 					  &acpi_gbl_sleep_type_a,
215 					  &acpi_gbl_sleep_type_b);
216 	if (ACPI_FAILURE(status)) {
217 		return_ACPI_STATUS(status);
218 	}
219 
220 	status = acpi_get_sleep_type_data(ACPI_STATE_S0,
221 					  &acpi_gbl_sleep_type_a_s0,
222 					  &acpi_gbl_sleep_type_b_s0);
223 	if (ACPI_FAILURE(status)) {
224 		acpi_gbl_sleep_type_a_s0 = ACPI_SLEEP_TYPE_INVALID;
225 	}
226 
227 	/* Execute the _PTS method (Prepare To Sleep) */
228 
229 	arg_list.count = 1;
230 	arg_list.pointer = &arg;
231 	arg.type = ACPI_TYPE_INTEGER;
232 	arg.integer.value = sleep_state;
233 
234 	status =
235 	    acpi_evaluate_object(NULL, METHOD_PATHNAME__PTS, &arg_list, NULL);
236 	if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
237 		return_ACPI_STATUS(status);
238 	}
239 
240 	/* Setup the argument to the _SST method (System STatus) */
241 
242 	switch (sleep_state) {
243 	case ACPI_STATE_S0:
244 
245 		sst_value = ACPI_SST_WORKING;
246 		break;
247 
248 	case ACPI_STATE_S1:
249 	case ACPI_STATE_S2:
250 	case ACPI_STATE_S3:
251 
252 		sst_value = ACPI_SST_SLEEPING;
253 		break;
254 
255 	case ACPI_STATE_S4:
256 
257 		sst_value = ACPI_SST_SLEEP_CONTEXT;
258 		break;
259 
260 	default:
261 
262 		sst_value = ACPI_SST_INDICATOR_OFF;	/* Default is off */
263 		break;
264 	}
265 
266 	/*
267 	 * Set the system indicators to show the desired sleep state.
268 	 * _SST is an optional method (return no error if not found)
269 	 */
270 	acpi_hw_execute_sleep_method(METHOD_PATHNAME__SST, sst_value);
271 	return_ACPI_STATUS(AE_OK);
272 }
273 
ACPI_EXPORT_SYMBOL(acpi_enter_sleep_state_prep)274 ACPI_EXPORT_SYMBOL(acpi_enter_sleep_state_prep)
275 
276 /*******************************************************************************
277  *
278  * FUNCTION:    acpi_enter_sleep_state
279  *
280  * PARAMETERS:  sleep_state         - Which sleep state to enter
281  *
282  * RETURN:      Status
283  *
284  * DESCRIPTION: Enter a system sleep state
285  *              THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED
286  *
287  ******************************************************************************/
288 acpi_status acpi_enter_sleep_state(u8 sleep_state)
289 {
290 	acpi_status status;
291 
292 	ACPI_FUNCTION_TRACE(acpi_enter_sleep_state);
293 
294 	if ((acpi_gbl_sleep_type_a > ACPI_SLEEP_TYPE_MAX) ||
295 	    (acpi_gbl_sleep_type_b > ACPI_SLEEP_TYPE_MAX)) {
296 		ACPI_ERROR((AE_INFO, "Sleep values out of range: A=0x%X B=0x%X",
297 			    acpi_gbl_sleep_type_a, acpi_gbl_sleep_type_b));
298 		return_ACPI_STATUS(AE_AML_OPERAND_VALUE);
299 	}
300 
301 #if !ACPI_REDUCED_HARDWARE
302 	if (!acpi_gbl_reduced_hardware)
303 		status = acpi_hw_legacy_sleep(sleep_state);
304 	else
305 #endif
306 		status = acpi_hw_extended_sleep(sleep_state);
307 	return_ACPI_STATUS(status);
308 }
309 
ACPI_EXPORT_SYMBOL(acpi_enter_sleep_state)310 ACPI_EXPORT_SYMBOL(acpi_enter_sleep_state)
311 
312 /*******************************************************************************
313  *
314  * FUNCTION:    acpi_leave_sleep_state_prep
315  *
316  * PARAMETERS:  sleep_state         - Which sleep state we are exiting
317  *
318  * RETURN:      Status
319  *
320  * DESCRIPTION: Perform the first state of OS-independent ACPI cleanup after a
321  *              sleep. Called with interrupts DISABLED.
322  *              We break wake/resume into 2 stages so that OSPM can handle
323  *              various OS-specific tasks between the two steps.
324  *
325  ******************************************************************************/
326 acpi_status acpi_leave_sleep_state_prep(u8 sleep_state)
327 {
328 	acpi_status status;
329 
330 	ACPI_FUNCTION_TRACE(acpi_leave_sleep_state_prep);
331 
332 #if !ACPI_REDUCED_HARDWARE
333 	if (!acpi_gbl_reduced_hardware)
334 		status = acpi_hw_legacy_wake_prep(sleep_state);
335 	else
336 #endif
337 		status = acpi_hw_extended_wake_prep(sleep_state);
338 	return_ACPI_STATUS(status);
339 }
340 
ACPI_EXPORT_SYMBOL(acpi_leave_sleep_state_prep)341 ACPI_EXPORT_SYMBOL(acpi_leave_sleep_state_prep)
342 
343 /*******************************************************************************
344  *
345  * FUNCTION:    acpi_leave_sleep_state
346  *
347  * PARAMETERS:  sleep_state         - Which sleep state we are exiting
348  *
349  * RETURN:      Status
350  *
351  * DESCRIPTION: Perform OS-independent ACPI cleanup after a sleep
352  *              Called with interrupts ENABLED.
353  *
354  ******************************************************************************/
355 acpi_status acpi_leave_sleep_state(u8 sleep_state)
356 {
357 	acpi_status status;
358 
359 	ACPI_FUNCTION_TRACE(acpi_leave_sleep_state);
360 
361 #if !ACPI_REDUCED_HARDWARE
362 	if (!acpi_gbl_reduced_hardware)
363 		status = acpi_hw_legacy_wake(sleep_state);
364 	else
365 #endif
366 		status = acpi_hw_extended_wake(sleep_state);
367 	return_ACPI_STATUS(status);
368 }
369 
370 ACPI_EXPORT_SYMBOL(acpi_leave_sleep_state)
371