Home | History | Annotate | Line # | Download | only in hardware 
      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  * Copyright (C) 2000 - 2025, Intel Corp.
     10  * All rights reserved.
     11  *
     12  * Redistribution and use in source and binary forms, with or without
     13  * modification, are permitted provided that the following conditions
     14  * are met:
     15  * 1. Redistributions of source code must retain the above copyright
     16  *    notice, this list of conditions, and the following disclaimer,
     17  *    without modification.
     18  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
     19  *    substantially similar to the "NO WARRANTY" disclaimer below
     20  *    ("Disclaimer") and any redistribution must be conditioned upon
     21  *    including a substantially similar Disclaimer requirement for further
     22  *    binary redistribution.
     23  * 3. Neither the names of the above-listed copyright holders nor the names
     24  *    of any contributors may be used to endorse or promote products derived
     25  *    from this software without specific prior written permission.
     26  *
     27  * Alternatively, this software may be distributed under the terms of the
     28  * GNU General Public License ("GPL") version 2 as published by the Free
     29  * Software Foundation.
     30  *
     31  * NO WARRANTY
     32  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     33  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     34  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
     35  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     36  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     37  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     38  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     39  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
     40  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
     41  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     42  * POSSIBILITY OF SUCH DAMAGES.
     43  */
     44 
     45 #include "acpi.h"
     46 #include "accommon.h"
     47 
     48 #define _COMPONENT          ACPI_HARDWARE
     49         ACPI_MODULE_NAME    ("hwsleep")
     50 
     51 
     52 #if (!ACPI_REDUCED_HARDWARE) /* Entire module */
     53 /*******************************************************************************
     54  *
     55  * FUNCTION:    AcpiHwLegacySleep
     56  *
     57  * PARAMETERS:  SleepState          - Which sleep state to enter
     58  *
     59  * RETURN:      Status
     60  *
     61  * DESCRIPTION: Enter a system sleep state via the legacy FADT PM registers
     62  *              THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED
     63  *
     64  ******************************************************************************/
     65 
     66 ACPI_STATUS
     67 AcpiHwLegacySleep (
     68     UINT8                   SleepState)
     69 {
     70     ACPI_BIT_REGISTER_INFO  *SleepTypeRegInfo;
     71     ACPI_BIT_REGISTER_INFO  *SleepEnableRegInfo;
     72     UINT32                  Pm1aControl;
     73     UINT32                  Pm1bControl;
     74     UINT32                  InValue;
     75     ACPI_STATUS             Status;
     76 
     77 
     78     ACPI_FUNCTION_TRACE (HwLegacySleep);
     79 
     80 
     81     SleepTypeRegInfo = AcpiHwGetBitRegisterInfo (ACPI_BITREG_SLEEP_TYPE);
     82     SleepEnableRegInfo = AcpiHwGetBitRegisterInfo (ACPI_BITREG_SLEEP_ENABLE);
     83 
     84     /* Clear wake status */
     85 
     86     Status = AcpiWriteBitRegister (ACPI_BITREG_WAKE_STATUS,
     87         ACPI_CLEAR_STATUS);
     88     if (ACPI_FAILURE (Status))
     89     {
     90         return_ACPI_STATUS (Status);
     91     }
     92 
     93     /* Disable all GPEs */
     94 
     95     Status = AcpiHwDisableAllGpes ();
     96     if (ACPI_FAILURE (Status))
     97     {
     98         return_ACPI_STATUS (Status);
     99     }
    100     Status = AcpiHwClearAcpiStatus();
    101     if (ACPI_FAILURE(Status))
    102     {
    103         return_ACPI_STATUS(Status);
    104     }
    105     AcpiGbl_SystemAwakeAndRunning = FALSE;
    106 
    107     /* Enable all wakeup GPEs */
    108 
    109     Status = AcpiHwEnableAllWakeupGpes ();
    110     if (ACPI_FAILURE (Status))
    111     {
    112         return_ACPI_STATUS (Status);
    113     }
    114 
    115     /* Get current value of PM1A control */
    116 
    117     Status = AcpiHwRegisterRead (ACPI_REGISTER_PM1_CONTROL,
    118         &Pm1aControl);
    119     if (ACPI_FAILURE (Status))
    120     {
    121         return_ACPI_STATUS (Status);
    122     }
    123     ACPI_DEBUG_PRINT ((ACPI_DB_INIT,
    124         "Entering sleep state [S%u]\n", SleepState));
    125 
    126     /* Clear the SLP_EN and SLP_TYP fields */
    127 
    128     Pm1aControl &= ~(SleepTypeRegInfo->AccessBitMask |
    129          SleepEnableRegInfo->AccessBitMask);
    130     Pm1bControl = Pm1aControl;
    131 
    132     /* Insert the SLP_TYP bits */
    133 
    134     Pm1aControl |= (AcpiGbl_SleepTypeA << SleepTypeRegInfo->BitPosition);
    135     Pm1bControl |= (AcpiGbl_SleepTypeB << SleepTypeRegInfo->BitPosition);
    136 
    137     /*
    138      * We split the writes of SLP_TYP and SLP_EN to workaround
    139      * poorly implemented hardware.
    140      */
    141 
    142     /* Write #1: write the SLP_TYP data to the PM1 Control registers */
    143 
    144     Status = AcpiHwWritePm1Control (Pm1aControl, Pm1bControl);
    145     if (ACPI_FAILURE (Status))
    146     {
    147         return_ACPI_STATUS (Status);
    148     }
    149 
    150     /* Insert the sleep enable (SLP_EN) bit */
    151 
    152     Pm1aControl |= SleepEnableRegInfo->AccessBitMask;
    153     Pm1bControl |= SleepEnableRegInfo->AccessBitMask;
    154 
    155     /* Flush caches, as per ACPI specification */
    156 
    157     if (SleepState < ACPI_STATE_S4)
    158     {
    159         ACPI_FLUSH_CPU_CACHE ();
    160     }
    161 
    162     Status = AcpiOsEnterSleep (SleepState, Pm1aControl, Pm1bControl);
    163     if (Status == AE_CTRL_TERMINATE)
    164     {
    165         return_ACPI_STATUS (AE_OK);
    166     }
    167     if (ACPI_FAILURE (Status))
    168     {
    169         return_ACPI_STATUS (Status);
    170     }
    171 
    172     /* Write #2: Write both SLP_TYP + SLP_EN */
    173 
    174     Status = AcpiHwWritePm1Control (Pm1aControl, Pm1bControl);
    175     if (ACPI_FAILURE (Status))
    176     {
    177         return_ACPI_STATUS (Status);
    178     }
    179 
    180     if (SleepState > ACPI_STATE_S3)
    181     {
    182         /*
    183          * We wanted to sleep > S3, but it didn't happen (by virtue of the
    184          * fact that we are still executing!)
    185          *
    186          * Wait ten seconds, then try again. This is to get S4/S5 to work on
    187          * all machines.
    188          *
    189          * We wait so long to allow chipsets that poll this reg very slowly
    190          * to still read the right value. Ideally, this block would go
    191          * away entirely.
    192          */
    193         AcpiOsStall (10 * ACPI_USEC_PER_SEC);
    194 
    195         Status = AcpiHwRegisterWrite (ACPI_REGISTER_PM1_CONTROL,
    196             SleepEnableRegInfo->AccessBitMask);
    197         if (ACPI_FAILURE (Status))
    198         {
    199             return_ACPI_STATUS (Status);
    200         }
    201     }
    202 
    203     /* Wait for transition back to Working State */
    204 
    205     do
    206     {
    207         Status = AcpiReadBitRegister (ACPI_BITREG_WAKE_STATUS, &InValue);
    208         if (ACPI_FAILURE (Status))
    209         {
    210             return_ACPI_STATUS (Status);
    211         }
    212 
    213     } while (!InValue);
    214 
    215     return_ACPI_STATUS (AE_OK);
    216 }
    217 
    218 
    219 /*******************************************************************************
    220  *
    221  * FUNCTION:    AcpiHwLegacyWakePrep
    222  *
    223  * PARAMETERS:  SleepState          - Which sleep state we just exited
    224  *
    225  * RETURN:      Status
    226  *
    227  * DESCRIPTION: Perform the first state of OS-independent ACPI cleanup after a
    228  *              sleep.
    229  *              Called with interrupts ENABLED.
    230  *
    231  ******************************************************************************/
    232 
    233 ACPI_STATUS
    234 AcpiHwLegacyWakePrep (
    235     UINT8                   SleepState)
    236 {
    237     ACPI_STATUS             Status = AE_OK;
    238     ACPI_BIT_REGISTER_INFO  *SleepTypeRegInfo;
    239     ACPI_BIT_REGISTER_INFO  *SleepEnableRegInfo;
    240     UINT32                  Pm1aControl;
    241     UINT32                  Pm1bControl;
    242 
    243 
    244     ACPI_FUNCTION_TRACE (HwLegacyWakePrep);
    245 
    246     /*
    247      * Set SLP_TYPE and SLP_EN to state S0.
    248      * This is unclear from the ACPI Spec, but it is required
    249      * by some machines.
    250      */
    251     if (AcpiGbl_SleepTypeAS0 != ACPI_SLEEP_TYPE_INVALID)
    252     {
    253         SleepTypeRegInfo =
    254             AcpiHwGetBitRegisterInfo (ACPI_BITREG_SLEEP_TYPE);
    255         SleepEnableRegInfo =
    256             AcpiHwGetBitRegisterInfo (ACPI_BITREG_SLEEP_ENABLE);
    257 
    258         /* Get current value of PM1A control */
    259 
    260         Status = AcpiHwRegisterRead (ACPI_REGISTER_PM1_CONTROL,
    261             &Pm1aControl);
    262         if (ACPI_SUCCESS (Status))
    263         {
    264             /* Clear the SLP_EN and SLP_TYP fields */
    265 
    266             Pm1aControl &= ~(SleepTypeRegInfo->AccessBitMask |
    267                 SleepEnableRegInfo->AccessBitMask);
    268             Pm1bControl = Pm1aControl;
    269 
    270             /* Insert the SLP_TYP bits */
    271 
    272             Pm1aControl |= (AcpiGbl_SleepTypeAS0 <<
    273                 SleepTypeRegInfo->BitPosition);
    274             Pm1bControl |= (AcpiGbl_SleepTypeBS0 <<
    275                 SleepTypeRegInfo->BitPosition);
    276 
    277             /* Write the control registers and ignore any errors */
    278 
    279             (void) AcpiHwWritePm1Control (Pm1aControl, Pm1bControl);
    280         }
    281     }
    282 
    283     return_ACPI_STATUS (Status);
    284 }
    285 
    286 
    287 /*******************************************************************************
    288  *
    289  * FUNCTION:    AcpiHwLegacyWake
    290  *
    291  * PARAMETERS:  SleepState          - Which sleep state we just exited
    292  *
    293  * RETURN:      Status
    294  *
    295  * DESCRIPTION: Perform OS-independent ACPI cleanup after a sleep
    296  *              Called with interrupts ENABLED.
    297  *
    298  ******************************************************************************/
    299 
    300 ACPI_STATUS
    301 AcpiHwLegacyWake (
    302     UINT8                   SleepState)
    303 {
    304     ACPI_STATUS             Status;
    305 
    306 
    307     ACPI_FUNCTION_TRACE (HwLegacyWake);
    308 
    309 
    310     /* Ensure EnterSleepStatePrep -> EnterSleepState ordering */
    311 
    312     AcpiGbl_SleepTypeA = ACPI_SLEEP_TYPE_INVALID;
    313     AcpiHwExecuteSleepMethod (__UNCONST(METHOD_PATHNAME__SST), ACPI_SST_WAKING);
    314 
    315     /*
    316      * GPEs must be enabled before _WAK is called as GPEs
    317      * might get fired there
    318      *
    319      * Restore the GPEs:
    320      * 1) Disable all GPEs
    321      * 2) Enable all runtime GPEs
    322      */
    323     Status = AcpiHwDisableAllGpes ();
    324     if (ACPI_FAILURE (Status))
    325     {
    326         return_ACPI_STATUS (Status);
    327     }
    328 
    329     Status = AcpiHwEnableAllRuntimeGpes ();
    330     if (ACPI_FAILURE (Status))
    331     {
    332         return_ACPI_STATUS (Status);
    333     }
    334 
    335     /*
    336      * Now we can execute _WAK, etc. Some machines require that the GPEs
    337      * are enabled before the wake methods are executed.
    338      */
    339     AcpiHwExecuteSleepMethod (__UNCONST(METHOD_PATHNAME__WAK), SleepState);
    340 
    341     /*
    342      * Some BIOS code assumes that WAK_STS will be cleared on resume
    343      * and use it to determine whether the system is rebooting or
    344      * resuming. Clear WAK_STS for compatibility.
    345      */
    346     (void) AcpiWriteBitRegister (ACPI_BITREG_WAKE_STATUS,
    347         ACPI_CLEAR_STATUS);
    348     AcpiGbl_SystemAwakeAndRunning = TRUE;
    349 
    350     /* Enable power button */
    351 
    352     (void) AcpiWriteBitRegister(
    353             AcpiGbl_FixedEventInfo[ACPI_EVENT_POWER_BUTTON].EnableRegisterId,
    354             ACPI_ENABLE_EVENT);
    355 
    356     (void) AcpiWriteBitRegister(
    357             AcpiGbl_FixedEventInfo[ACPI_EVENT_POWER_BUTTON].StatusRegisterId,
    358             ACPI_CLEAR_STATUS);
    359 
    360     /* Enable sleep button */
    361 
    362     (void) AcpiWriteBitRegister (
    363             AcpiGbl_FixedEventInfo[ACPI_EVENT_SLEEP_BUTTON].EnableRegisterId,
    364             ACPI_ENABLE_EVENT);
    365 
    366     (void) AcpiWriteBitRegister (
    367             AcpiGbl_FixedEventInfo[ACPI_EVENT_SLEEP_BUTTON].StatusRegisterId,
    368             ACPI_CLEAR_STATUS);
    369 
    370     AcpiHwExecuteSleepMethod (METHOD_PATHNAME__SST, ACPI_SST_WORKING);
    371     return_ACPI_STATUS (Status);
    372 }
    373 
    374 #endif /* !ACPI_REDUCED_HARDWARE */
    375