1/******************************************************************************
2 *
3 * Name: hwsleep.c - ACPI Hardware Sleep/Wake Support functions for the
4 *                   original/legacy sleep/PM registers.
5 *
6 *****************************************************************************/
7
8/******************************************************************************
9 *
10 * 1. Copyright Notice
11 *
12 * Some or all of this work - Copyright (c) 1999 - 2012, Intel Corp.
13 * All rights reserved.
14 *
15 * 2. License
16 *
17 * 2.1. This is your license from Intel Corp. under its intellectual property
18 * rights. You may have additional license terms from the party that provided
19 * you this software, covering your right to use that party's intellectual
20 * property rights.
21 *
22 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
23 * copy of the source code appearing in this file ("Covered Code") an
24 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
25 * base code distributed originally by Intel ("Original Intel Code") to copy,
26 * make derivatives, distribute, use and display any portion of the Covered
27 * Code in any form, with the right to sublicense such rights; and
28 *
29 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
30 * license (with the right to sublicense), under only those claims of Intel
31 * patents that are infringed by the Original Intel Code, to make, use, sell,
32 * offer to sell, and import the Covered Code and derivative works thereof
33 * solely to the minimum extent necessary to exercise the above copyright
34 * license, and in no event shall the patent license extend to any additions
35 * to or modifications of the Original Intel Code. No other license or right
36 * is granted directly or by implication, estoppel or otherwise;
37 *
38 * The above copyright and patent license is granted only if the following
39 * conditions are met:
40 *
41 * 3. Conditions
42 *
43 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
44 * Redistribution of source code of any substantial portion of the Covered
45 * Code or modification with rights to further distribute source must include
46 * the above Copyright Notice, the above License, this list of Conditions,
47 * and the following Disclaimer and Export Compliance provision. In addition,
48 * Licensee must cause all Covered Code to which Licensee contributes to
49 * contain a file documenting the changes Licensee made to create that Covered
50 * Code and the date of any change. Licensee must include in that file the
51 * documentation of any changes made by any predecessor Licensee. Licensee
52 * must include a prominent statement that the modification is derived,
53 * directly or indirectly, from Original Intel Code.
54 *
55 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
56 * Redistribution of source code of any substantial portion of the Covered
57 * Code or modification without rights to further distribute source must
58 * include the following Disclaimer and Export Compliance provision in the
59 * documentation and/or other materials provided with distribution. In
60 * addition, Licensee may not authorize further sublicense of source of any
61 * portion of the Covered Code, and must include terms to the effect that the
62 * license from Licensee to its licensee is limited to the intellectual
63 * property embodied in the software Licensee provides to its licensee, and
64 * not to intellectual property embodied in modifications its licensee may
65 * make.
66 *
67 * 3.3. Redistribution of Executable. Redistribution in executable form of any
68 * substantial portion of the Covered Code or modification must reproduce the
69 * above Copyright Notice, and the following Disclaimer and Export Compliance
70 * provision in the documentation and/or other materials provided with the
71 * distribution.
72 *
73 * 3.4. Intel retains all right, title, and interest in and to the Original
74 * Intel Code.
75 *
76 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
77 * Intel shall be used in advertising or otherwise to promote the sale, use or
78 * other dealings in products derived from or relating to the Covered Code
79 * without prior written authorization from Intel.
80 *
81 * 4. Disclaimer and Export Compliance
82 *
83 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
84 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
85 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
86 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
87 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
88 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
89 * PARTICULAR PURPOSE.
90 *
91 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
92 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
93 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
94 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
95 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
96 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
97 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
98 * LIMITED REMEDY.
99 *
100 * 4.3. Licensee shall not export, either directly or indirectly, any of this
101 * software or system incorporating such software without first obtaining any
102 * required license or other approval from the U. S. Department of Commerce or
103 * any other agency or department of the United States Government. In the
104 * event Licensee exports any such software from the United States or
105 * re-exports any such software from a foreign destination, Licensee shall
106 * ensure that the distribution and export/re-export of the software is in
107 * compliance with all laws, regulations, orders, or other restrictions of the
108 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
109 * any of its subsidiaries will export/re-export any technical data, process,
110 * software, or service, directly or indirectly, to any country for which the
111 * United States government or any agency thereof requires an export license,
112 * other governmental approval, or letter of assurance, without first obtaining
113 * such license, approval or letter.
114 *
115 *****************************************************************************/
116
117#include "acpi.h"
118#include "accommon.h"
119
120#define _COMPONENT          ACPI_HARDWARE
121        ACPI_MODULE_NAME    ("hwsleep")
122
123
124#if (!ACPI_REDUCED_HARDWARE) /* Entire module */
125/*******************************************************************************
126 *
127 * FUNCTION:    AcpiHwLegacySleep
128 *
129 * PARAMETERS:  SleepState          - Which sleep state to enter
130 *
131 * RETURN:      Status
132 *
133 * DESCRIPTION: Enter a system sleep state via the legacy FADT PM registers
134 *              THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED
135 *
136 ******************************************************************************/
137
138ACPI_STATUS
139AcpiHwLegacySleep (
140    UINT8                   SleepState)
141{
142    ACPI_BIT_REGISTER_INFO  *SleepTypeRegInfo;
143    ACPI_BIT_REGISTER_INFO  *SleepEnableRegInfo;
144    UINT32                  Pm1aControl;
145    UINT32                  Pm1bControl;
146    UINT32                  InValue;
147    ACPI_STATUS             Status;
148
149
150    ACPI_FUNCTION_TRACE (HwLegacySleep);
151
152
153    SleepTypeRegInfo = AcpiHwGetBitRegisterInfo (ACPI_BITREG_SLEEP_TYPE);
154    SleepEnableRegInfo = AcpiHwGetBitRegisterInfo (ACPI_BITREG_SLEEP_ENABLE);
155
156    /* Clear wake status */
157
158    Status = AcpiWriteBitRegister (ACPI_BITREG_WAKE_STATUS, ACPI_CLEAR_STATUS);
159    if (ACPI_FAILURE (Status))
160    {
161        return_ACPI_STATUS (Status);
162    }
163
164    /* Clear all fixed and general purpose status bits */
165
166    Status = AcpiHwClearAcpiStatus ();
167    if (ACPI_FAILURE (Status))
168    {
169        return_ACPI_STATUS (Status);
170    }
171
172    /*
173     * 1) Disable/Clear all GPEs
174     * 2) Enable all wakeup GPEs
175     */
176    Status = AcpiHwDisableAllGpes ();
177    if (ACPI_FAILURE (Status))
178    {
179        return_ACPI_STATUS (Status);
180    }
181    AcpiGbl_SystemAwakeAndRunning = FALSE;
182
183    Status = AcpiHwEnableAllWakeupGpes ();
184    if (ACPI_FAILURE (Status))
185    {
186        return_ACPI_STATUS (Status);
187    }
188
189    /* Get current value of PM1A control */
190
191    Status = AcpiHwRegisterRead (ACPI_REGISTER_PM1_CONTROL,
192                &Pm1aControl);
193    if (ACPI_FAILURE (Status))
194    {
195        return_ACPI_STATUS (Status);
196    }
197    ACPI_DEBUG_PRINT ((ACPI_DB_INIT,
198        "Entering sleep state [S%u]\n", SleepState));
199
200    /* Clear the SLP_EN and SLP_TYP fields */
201
202    Pm1aControl &= ~(SleepTypeRegInfo->AccessBitMask |
203                     SleepEnableRegInfo->AccessBitMask);
204    Pm1bControl = Pm1aControl;
205
206    /* Insert the SLP_TYP bits */
207
208    Pm1aControl |= (AcpiGbl_SleepTypeA << SleepTypeRegInfo->BitPosition);
209    Pm1bControl |= (AcpiGbl_SleepTypeB << SleepTypeRegInfo->BitPosition);
210
211    /*
212     * We split the writes of SLP_TYP and SLP_EN to workaround
213     * poorly implemented hardware.
214     */
215
216    /* Write #1: write the SLP_TYP data to the PM1 Control registers */
217
218    Status = AcpiHwWritePm1Control (Pm1aControl, Pm1bControl);
219    if (ACPI_FAILURE (Status))
220    {
221        return_ACPI_STATUS (Status);
222    }
223
224    /* Insert the sleep enable (SLP_EN) bit */
225
226    Pm1aControl |= SleepEnableRegInfo->AccessBitMask;
227    Pm1bControl |= SleepEnableRegInfo->AccessBitMask;
228
229    /* Flush caches, as per ACPI specification */
230
231    ACPI_FLUSH_CPU_CACHE ();
232
233    /* Write #2: Write both SLP_TYP + SLP_EN */
234
235    Status = AcpiHwWritePm1Control (Pm1aControl, Pm1bControl);
236    if (ACPI_FAILURE (Status))
237    {
238        return_ACPI_STATUS (Status);
239    }
240
241    if (SleepState > ACPI_STATE_S3)
242    {
243        /*
244         * We wanted to sleep > S3, but it didn't happen (by virtue of the
245         * fact that we are still executing!)
246         *
247         * Wait ten seconds, then try again. This is to get S4/S5 to work on
248         * all machines.
249         *
250         * We wait so long to allow chipsets that poll this reg very slowly
251         * to still read the right value. Ideally, this block would go
252         * away entirely.
253         */
254        AcpiOsStall (10000000);
255
256        Status = AcpiHwRegisterWrite (ACPI_REGISTER_PM1_CONTROL,
257                    SleepEnableRegInfo->AccessBitMask);
258        if (ACPI_FAILURE (Status))
259        {
260            return_ACPI_STATUS (Status);
261        }
262    }
263
264    /* Wait for transition back to Working State */
265
266    do
267    {
268        Status = AcpiReadBitRegister (ACPI_BITREG_WAKE_STATUS, &InValue);
269        if (ACPI_FAILURE (Status))
270        {
271            return_ACPI_STATUS (Status);
272        }
273
274    } while (!InValue);
275
276    return_ACPI_STATUS (AE_OK);
277}
278
279
280/*******************************************************************************
281 *
282 * FUNCTION:    AcpiHwLegacyWakePrep
283 *
284 * PARAMETERS:  SleepState          - Which sleep state we just exited
285 *
286 * RETURN:      Status
287 *
288 * DESCRIPTION: Perform the first state of OS-independent ACPI cleanup after a
289 *              sleep.
290 *              Called with interrupts ENABLED.
291 *
292 ******************************************************************************/
293
294ACPI_STATUS
295AcpiHwLegacyWakePrep (
296    UINT8                   SleepState)
297{
298    ACPI_STATUS             Status;
299    ACPI_BIT_REGISTER_INFO  *SleepTypeRegInfo;
300    ACPI_BIT_REGISTER_INFO  *SleepEnableRegInfo;
301    UINT32                  Pm1aControl;
302    UINT32                  Pm1bControl;
303
304
305    ACPI_FUNCTION_TRACE (HwLegacyWakePrep);
306
307    /*
308     * Set SLP_TYPE and SLP_EN to state S0.
309     * This is unclear from the ACPI Spec, but it is required
310     * by some machines.
311     */
312    Status = AcpiGetSleepTypeData (ACPI_STATE_S0,
313                    &AcpiGbl_SleepTypeA, &AcpiGbl_SleepTypeB);
314    if (ACPI_SUCCESS (Status))
315    {
316        SleepTypeRegInfo =
317            AcpiHwGetBitRegisterInfo (ACPI_BITREG_SLEEP_TYPE);
318        SleepEnableRegInfo =
319            AcpiHwGetBitRegisterInfo (ACPI_BITREG_SLEEP_ENABLE);
320
321        /* Get current value of PM1A control */
322
323        Status = AcpiHwRegisterRead (ACPI_REGISTER_PM1_CONTROL,
324                    &Pm1aControl);
325        if (ACPI_SUCCESS (Status))
326        {
327            /* Clear the SLP_EN and SLP_TYP fields */
328
329            Pm1aControl &= ~(SleepTypeRegInfo->AccessBitMask |
330                SleepEnableRegInfo->AccessBitMask);
331            Pm1bControl = Pm1aControl;
332
333            /* Insert the SLP_TYP bits */
334
335            Pm1aControl |= (AcpiGbl_SleepTypeA <<
336                SleepTypeRegInfo->BitPosition);
337            Pm1bControl |= (AcpiGbl_SleepTypeB <<
338                SleepTypeRegInfo->BitPosition);
339
340            /* Write the control registers and ignore any errors */
341
342            (void) AcpiHwWritePm1Control (Pm1aControl, Pm1bControl);
343        }
344    }
345
346    return_ACPI_STATUS (Status);
347}
348
349
350/*******************************************************************************
351 *
352 * FUNCTION:    AcpiHwLegacyWake
353 *
354 * PARAMETERS:  SleepState          - Which sleep state we just exited
355 *
356 * RETURN:      Status
357 *
358 * DESCRIPTION: Perform OS-independent ACPI cleanup after a sleep
359 *              Called with interrupts ENABLED.
360 *
361 ******************************************************************************/
362
363ACPI_STATUS
364AcpiHwLegacyWake (
365    UINT8                   SleepState)
366{
367    ACPI_STATUS             Status;
368
369
370    ACPI_FUNCTION_TRACE (HwLegacyWake);
371
372
373    /* Ensure EnterSleepStatePrep -> EnterSleepState ordering */
374
375    AcpiGbl_SleepTypeA = ACPI_SLEEP_TYPE_INVALID;
376    AcpiHwExecuteSleepMethod (METHOD_PATHNAME__SST, ACPI_SST_WAKING);
377
378    /*
379     * GPEs must be enabled before _WAK is called as GPEs
380     * might get fired there
381     *
382     * Restore the GPEs:
383     * 1) Disable/Clear all GPEs
384     * 2) Enable all runtime GPEs
385     */
386    Status = AcpiHwDisableAllGpes ();
387    if (ACPI_FAILURE (Status))
388    {
389        return_ACPI_STATUS (Status);
390    }
391
392    Status = AcpiHwEnableAllRuntimeGpes ();
393    if (ACPI_FAILURE (Status))
394    {
395        return_ACPI_STATUS (Status);
396    }
397
398    /*
399     * Now we can execute _WAK, etc. Some machines require that the GPEs
400     * are enabled before the wake methods are executed.
401     */
402    AcpiHwExecuteSleepMethod (METHOD_PATHNAME__WAK, SleepState);
403
404    /*
405     * Some BIOS code assumes that WAK_STS will be cleared on resume
406     * and use it to determine whether the system is rebooting or
407     * resuming. Clear WAK_STS for compatibility.
408     */
409    (void) AcpiWriteBitRegister (ACPI_BITREG_WAKE_STATUS, ACPI_CLEAR_STATUS);
410    AcpiGbl_SystemAwakeAndRunning = TRUE;
411
412    /* Enable power button */
413
414    (void) AcpiWriteBitRegister(
415            AcpiGbl_FixedEventInfo[ACPI_EVENT_POWER_BUTTON].EnableRegisterId,
416            ACPI_ENABLE_EVENT);
417
418    (void) AcpiWriteBitRegister(
419            AcpiGbl_FixedEventInfo[ACPI_EVENT_POWER_BUTTON].StatusRegisterId,
420            ACPI_CLEAR_STATUS);
421
422    AcpiHwExecuteSleepMethod (METHOD_PATHNAME__SST, ACPI_SST_WORKING);
423    return_ACPI_STATUS (Status);
424}
425
426#endif /* !ACPI_REDUCED_HARDWARE */
427