1 /******************************************************************************
2 *
3 * Name: hwxfsleep.c - ACPI Hardware Sleep/Wake External Interfaces
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2022, Intel Corp.
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions, and the following disclaimer,
16 * without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 * substantially similar to the "NO WARRANTY" disclaimer below
19 * ("Disclaimer") and any redistribution must be conditioned upon
20 * including a substantially similar Disclaimer requirement for further
21 * binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 * of any contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
25 *
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
29 *
30 * NO WARRANTY
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
42 */
43
44 #define EXPORT_ACPI_INTERFACES
45
46 #include "acpi.h"
47 #include "accommon.h"
48
49 #define _COMPONENT ACPI_HARDWARE
50 ACPI_MODULE_NAME ("hwxfsleep")
51
52 /* Local prototypes */
53
54 #if (!ACPI_REDUCED_HARDWARE)
55 static ACPI_STATUS
56 AcpiHwSetFirmwareWakingVector (
57 ACPI_TABLE_FACS *Facs,
58 ACPI_PHYSICAL_ADDRESS PhysicalAddress,
59 ACPI_PHYSICAL_ADDRESS PhysicalAddress64);
60 #endif
61
62 static ACPI_STATUS
63 AcpiHwSleepDispatch (
64 UINT8 SleepState,
65 UINT32 FunctionId);
66
67 /*
68 * Dispatch table used to efficiently branch to the various sleep
69 * functions.
70 */
71 #define ACPI_SLEEP_FUNCTION_ID 0
72 #define ACPI_WAKE_PREP_FUNCTION_ID 1
73 #define ACPI_WAKE_FUNCTION_ID 2
74
75 /* Legacy functions are optional, based upon ACPI_REDUCED_HARDWARE */
76
77 static ACPI_SLEEP_FUNCTIONS AcpiSleepDispatch[] =
78 {
79 {ACPI_STRUCT_INIT (LegacyFunction,
80 ACPI_HW_OPTIONAL_FUNCTION (AcpiHwLegacySleep)),
81 ACPI_STRUCT_INIT (ExtendedFunction,
82 AcpiHwExtendedSleep) },
83 {ACPI_STRUCT_INIT (LegacyFunction,
84 ACPI_HW_OPTIONAL_FUNCTION (AcpiHwLegacyWakePrep)),
85 ACPI_STRUCT_INIT (ExtendedFunction,
86 AcpiHwExtendedWakePrep) },
87 {ACPI_STRUCT_INIT (LegacyFunction,
88 ACPI_HW_OPTIONAL_FUNCTION (AcpiHwLegacyWake)),
89 ACPI_STRUCT_INIT (ExtendedFunction,
90 AcpiHwExtendedWake) }
91 };
92
93
94 /*
95 * These functions are removed for the ACPI_REDUCED_HARDWARE case:
96 * AcpiSetFirmwareWakingVector
97 * AcpiEnterSleepStateS4bios
98 */
99
100 #if (!ACPI_REDUCED_HARDWARE)
101 /*******************************************************************************
102 *
103 * FUNCTION: AcpiHwSetFirmwareWakingVector
104 *
105 * PARAMETERS: Facs - Pointer to FACS table
106 * PhysicalAddress - 32-bit physical address of ACPI real mode
107 * entry point
108 * PhysicalAddress64 - 64-bit physical address of ACPI protected
109 * mode entry point
110 *
111 * RETURN: Status
112 *
113 * DESCRIPTION: Sets the FirmwareWakingVector fields of the FACS
114 *
115 ******************************************************************************/
116
117 static ACPI_STATUS
AcpiHwSetFirmwareWakingVector(ACPI_TABLE_FACS * Facs,ACPI_PHYSICAL_ADDRESS PhysicalAddress,ACPI_PHYSICAL_ADDRESS PhysicalAddress64)118 AcpiHwSetFirmwareWakingVector (
119 ACPI_TABLE_FACS *Facs,
120 ACPI_PHYSICAL_ADDRESS PhysicalAddress,
121 ACPI_PHYSICAL_ADDRESS PhysicalAddress64)
122 {
123 ACPI_FUNCTION_TRACE (AcpiHwSetFirmwareWakingVector);
124
125
126 /*
127 * According to the ACPI specification 2.0c and later, the 64-bit
128 * waking vector should be cleared and the 32-bit waking vector should
129 * be used, unless we want the wake-up code to be called by the BIOS in
130 * Protected Mode. Some systems (for example HP dv5-1004nr) are known
131 * to fail to resume if the 64-bit vector is used.
132 */
133
134 /* Set the 32-bit vector */
135
136 Facs->FirmwareWakingVector = (UINT32) PhysicalAddress;
137
138 if (Facs->Length > 32)
139 {
140 if (Facs->Version >= 1)
141 {
142 /* Set the 64-bit vector */
143
144 Facs->XFirmwareWakingVector = PhysicalAddress64;
145 }
146 else
147 {
148 /* Clear the 64-bit vector if it exists */
149
150 Facs->XFirmwareWakingVector = 0;
151 }
152 }
153
154 return_ACPI_STATUS (AE_OK);
155 }
156
157
158 /*******************************************************************************
159 *
160 * FUNCTION: AcpiSetFirmwareWakingVector
161 *
162 * PARAMETERS: PhysicalAddress - 32-bit physical address of ACPI real mode
163 * entry point
164 * PhysicalAddress64 - 64-bit physical address of ACPI protected
165 * mode entry point
166 *
167 * RETURN: Status
168 *
169 * DESCRIPTION: Sets the FirmwareWakingVector fields of the FACS
170 *
171 ******************************************************************************/
172
173 ACPI_STATUS
AcpiSetFirmwareWakingVector(ACPI_PHYSICAL_ADDRESS PhysicalAddress,ACPI_PHYSICAL_ADDRESS PhysicalAddress64)174 AcpiSetFirmwareWakingVector (
175 ACPI_PHYSICAL_ADDRESS PhysicalAddress,
176 ACPI_PHYSICAL_ADDRESS PhysicalAddress64)
177 {
178
179 ACPI_FUNCTION_TRACE (AcpiSetFirmwareWakingVector);
180
181 if (AcpiGbl_FACS)
182 {
183 (void) AcpiHwSetFirmwareWakingVector (AcpiGbl_FACS,
184 PhysicalAddress, PhysicalAddress64);
185 }
186
187 return_ACPI_STATUS (AE_OK);
188 }
189
ACPI_EXPORT_SYMBOL(AcpiSetFirmwareWakingVector)190 ACPI_EXPORT_SYMBOL (AcpiSetFirmwareWakingVector)
191
192
193 /*******************************************************************************
194 *
195 * FUNCTION: AcpiEnterSleepStateS4bios
196 *
197 * PARAMETERS: None
198 *
199 * RETURN: Status
200 *
201 * DESCRIPTION: Perform a S4 bios request.
202 * THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED
203 *
204 ******************************************************************************/
205
206 ACPI_STATUS
207 AcpiEnterSleepStateS4bios (
208 void)
209 {
210 UINT32 InValue;
211 ACPI_STATUS Status;
212
213
214 ACPI_FUNCTION_TRACE (AcpiEnterSleepStateS4bios);
215
216
217 /* Clear the wake status bit (PM1) */
218
219 Status = AcpiWriteBitRegister (ACPI_BITREG_WAKE_STATUS, ACPI_CLEAR_STATUS);
220 if (ACPI_FAILURE (Status))
221 {
222 return_ACPI_STATUS (Status);
223 }
224
225 Status = AcpiHwClearAcpiStatus ();
226 if (ACPI_FAILURE (Status))
227 {
228 return_ACPI_STATUS (Status);
229 }
230
231 /*
232 * 1) Disable all GPEs
233 * 2) Enable all wakeup GPEs
234 */
235 Status = AcpiHwDisableAllGpes ();
236 if (ACPI_FAILURE (Status))
237 {
238 return_ACPI_STATUS (Status);
239 }
240 AcpiGbl_SystemAwakeAndRunning = FALSE;
241
242 Status = AcpiHwEnableAllWakeupGpes ();
243 if (ACPI_FAILURE (Status))
244 {
245 return_ACPI_STATUS (Status);
246 }
247
248 Status = AcpiHwWritePort (AcpiGbl_FADT.SmiCommand,
249 (UINT32) AcpiGbl_FADT.S4BiosRequest, 8);
250 if (ACPI_FAILURE (Status))
251 {
252 return_ACPI_STATUS (Status);
253 }
254
255 do {
256 AcpiOsStall (ACPI_USEC_PER_MSEC);
257 Status = AcpiReadBitRegister (ACPI_BITREG_WAKE_STATUS, &InValue);
258 if (ACPI_FAILURE (Status))
259 {
260 return_ACPI_STATUS (Status);
261 }
262
263 } while (!InValue);
264
265 return_ACPI_STATUS (AE_OK);
266 }
267
ACPI_EXPORT_SYMBOL(AcpiEnterSleepStateS4bios)268 ACPI_EXPORT_SYMBOL (AcpiEnterSleepStateS4bios)
269
270 #endif /* !ACPI_REDUCED_HARDWARE */
271
272
273 /*******************************************************************************
274 *
275 * FUNCTION: AcpiHwSleepDispatch
276 *
277 * PARAMETERS: SleepState - Which sleep state to enter/exit
278 * FunctionId - Sleep, WakePrep, or Wake
279 *
280 * RETURN: Status from the invoked sleep handling function.
281 *
282 * DESCRIPTION: Dispatch a sleep/wake request to the appropriate handling
283 * function.
284 *
285 ******************************************************************************/
286
287 static ACPI_STATUS
288 AcpiHwSleepDispatch (
289 UINT8 SleepState,
290 UINT32 FunctionId)
291 {
292 ACPI_STATUS Status;
293 ACPI_SLEEP_FUNCTIONS *SleepFunctions = &AcpiSleepDispatch[FunctionId];
294
295
296 #if (!ACPI_REDUCED_HARDWARE)
297 /*
298 * If the Hardware Reduced flag is set (from the FADT), we must
299 * use the extended sleep registers (FADT). Note: As per the ACPI
300 * specification, these extended registers are to be used for HW-reduced
301 * platforms only. They are not general-purpose replacements for the
302 * legacy PM register sleep support.
303 */
304 if (AcpiGbl_ReducedHardware)
305 {
306 Status = SleepFunctions->ExtendedFunction (SleepState);
307 }
308 else
309 {
310 /* Legacy sleep */
311
312 Status = SleepFunctions->LegacyFunction (SleepState);
313 }
314
315 return (Status);
316
317 #else
318 /*
319 * For the case where reduced-hardware-only code is being generated,
320 * we know that only the extended sleep registers are available
321 */
322 Status = SleepFunctions->ExtendedFunction (SleepState);
323 return (Status);
324
325 #endif /* !ACPI_REDUCED_HARDWARE */
326 }
327
328
329 /*******************************************************************************
330 *
331 * FUNCTION: AcpiEnterSleepStatePrep
332 *
333 * PARAMETERS: SleepState - Which sleep state to enter
334 *
335 * RETURN: Status
336 *
337 * DESCRIPTION: Prepare to enter a system sleep state.
338 * This function must execute with interrupts enabled.
339 * We break sleeping into 2 stages so that OSPM can handle
340 * various OS-specific tasks between the two steps.
341 *
342 ******************************************************************************/
343
344 ACPI_STATUS
AcpiEnterSleepStatePrep(UINT8 SleepState)345 AcpiEnterSleepStatePrep (
346 UINT8 SleepState)
347 {
348 ACPI_STATUS Status;
349 ACPI_OBJECT_LIST ArgList;
350 ACPI_OBJECT Arg;
351 UINT32 SstValue;
352
353
354 ACPI_FUNCTION_TRACE (AcpiEnterSleepStatePrep);
355
356
357 Status = AcpiGetSleepTypeData (SleepState,
358 &AcpiGbl_SleepTypeA, &AcpiGbl_SleepTypeB);
359 if (ACPI_FAILURE (Status))
360 {
361 return_ACPI_STATUS (Status);
362 }
363
364 Status = AcpiGetSleepTypeData (ACPI_STATE_S0,
365 &AcpiGbl_SleepTypeAS0, &AcpiGbl_SleepTypeBS0);
366 if (ACPI_FAILURE (Status)) {
367 AcpiGbl_SleepTypeAS0 = ACPI_SLEEP_TYPE_INVALID;
368 }
369
370 /* Execute the _PTS method (Prepare To Sleep) */
371
372 ArgList.Count = 1;
373 ArgList.Pointer = &Arg;
374 Arg.Type = ACPI_TYPE_INTEGER;
375 Arg.Integer.Value = SleepState;
376
377 Status = AcpiEvaluateObject (NULL, METHOD_PATHNAME__PTS, &ArgList, NULL);
378 if (ACPI_FAILURE (Status) && Status != AE_NOT_FOUND)
379 {
380 return_ACPI_STATUS (Status);
381 }
382
383 /* Setup the argument to the _SST method (System STatus) */
384
385 switch (SleepState)
386 {
387 case ACPI_STATE_S0:
388
389 SstValue = ACPI_SST_WORKING;
390 break;
391
392 case ACPI_STATE_S1:
393 case ACPI_STATE_S2:
394 case ACPI_STATE_S3:
395
396 SstValue = ACPI_SST_SLEEPING;
397 break;
398
399 case ACPI_STATE_S4:
400
401 SstValue = ACPI_SST_SLEEP_CONTEXT;
402 break;
403
404 default:
405
406 SstValue = ACPI_SST_INDICATOR_OFF; /* Default is off */
407 break;
408 }
409
410 /*
411 * Set the system indicators to show the desired sleep state.
412 * _SST is an optional method (return no error if not found)
413 */
414 AcpiHwExecuteSleepMethod (METHOD_PATHNAME__SST, SstValue);
415 return_ACPI_STATUS (AE_OK);
416 }
417
ACPI_EXPORT_SYMBOL(AcpiEnterSleepStatePrep)418 ACPI_EXPORT_SYMBOL (AcpiEnterSleepStatePrep)
419
420
421 /*******************************************************************************
422 *
423 * FUNCTION: AcpiEnterSleepState
424 *
425 * PARAMETERS: SleepState - Which sleep state to enter
426 *
427 * RETURN: Status
428 *
429 * DESCRIPTION: Enter a system sleep state
430 * THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED
431 *
432 ******************************************************************************/
433
434 ACPI_STATUS
435 AcpiEnterSleepState (
436 UINT8 SleepState)
437 {
438 ACPI_STATUS Status;
439
440
441 ACPI_FUNCTION_TRACE (AcpiEnterSleepState);
442
443
444 if ((AcpiGbl_SleepTypeA > ACPI_SLEEP_TYPE_MAX) ||
445 (AcpiGbl_SleepTypeB > ACPI_SLEEP_TYPE_MAX))
446 {
447 ACPI_ERROR ((AE_INFO, "Sleep values out of range: A=0x%X B=0x%X",
448 AcpiGbl_SleepTypeA, AcpiGbl_SleepTypeB));
449 return_ACPI_STATUS (AE_AML_OPERAND_VALUE);
450 }
451
452 Status = AcpiHwSleepDispatch (SleepState, ACPI_SLEEP_FUNCTION_ID);
453 return_ACPI_STATUS (Status);
454 }
455
ACPI_EXPORT_SYMBOL(AcpiEnterSleepState)456 ACPI_EXPORT_SYMBOL (AcpiEnterSleepState)
457
458
459 /*******************************************************************************
460 *
461 * FUNCTION: AcpiLeaveSleepStatePrep
462 *
463 * PARAMETERS: SleepState - Which sleep state we are exiting
464 *
465 * RETURN: Status
466 *
467 * DESCRIPTION: Perform the first state of OS-independent ACPI cleanup after a
468 * sleep. Called with interrupts DISABLED.
469 * We break wake/resume into 2 stages so that OSPM can handle
470 * various OS-specific tasks between the two steps.
471 *
472 ******************************************************************************/
473
474 ACPI_STATUS
475 AcpiLeaveSleepStatePrep (
476 UINT8 SleepState)
477 {
478 ACPI_STATUS Status;
479
480
481 ACPI_FUNCTION_TRACE (AcpiLeaveSleepStatePrep);
482
483
484 Status = AcpiHwSleepDispatch (SleepState, ACPI_WAKE_PREP_FUNCTION_ID);
485 return_ACPI_STATUS (Status);
486 }
487
ACPI_EXPORT_SYMBOL(AcpiLeaveSleepStatePrep)488 ACPI_EXPORT_SYMBOL (AcpiLeaveSleepStatePrep)
489
490
491 /*******************************************************************************
492 *
493 * FUNCTION: AcpiLeaveSleepState
494 *
495 * PARAMETERS: SleepState - Which sleep state we are exiting
496 *
497 * RETURN: Status
498 *
499 * DESCRIPTION: Perform OS-independent ACPI cleanup after a sleep
500 * Called with interrupts ENABLED.
501 *
502 ******************************************************************************/
503
504 ACPI_STATUS
505 AcpiLeaveSleepState (
506 UINT8 SleepState)
507 {
508 ACPI_STATUS Status;
509
510
511 ACPI_FUNCTION_TRACE (AcpiLeaveSleepState);
512
513
514 Status = AcpiHwSleepDispatch (SleepState, ACPI_WAKE_FUNCTION_ID);
515 return_ACPI_STATUS (Status);
516 }
517
518 ACPI_EXPORT_SYMBOL (AcpiLeaveSleepState)
519