hwsleep.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    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 - 2012, 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 MERCHANTIBILITY 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/acpi.h>
   46 #include <linux/acpi.h>
   47 #include "accommon.h"
   48 #include <linux/module.h>
   49 
   50 #define _COMPONENT          ACPI_HARDWARE
   51 ACPI_MODULE_NAME("hwsleep")
   52 
   53 #if (!ACPI_REDUCED_HARDWARE)    /* Entire module */
   54 /*******************************************************************************
   55  *
   56  * FUNCTION:    acpi_hw_legacy_sleep
   57  *
   58  * PARAMETERS:  sleep_state         - Which sleep state to enter
   59  *
   60  * RETURN:      Status
   61  *
   62  * DESCRIPTION: Enter a system sleep state via the legacy FADT PM registers
   63  *              THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED
   64  *
   65  ******************************************************************************/
   66 acpi_status acpi_hw_legacy_sleep(u8 sleep_state)
   67 {
   68         struct acpi_bit_register_info *sleep_type_reg_info;
   69         struct acpi_bit_register_info *sleep_enable_reg_info;
   70         u32 pm1a_control;
   71         u32 pm1b_control;
   72         u32 in_value;
   73         acpi_status status;
   74 
   75         ACPI_FUNCTION_TRACE(hw_legacy_sleep);
   76 
   77         sleep_type_reg_info =
   78             acpi_hw_get_bit_register_info(ACPI_BITREG_SLEEP_TYPE);
   79         sleep_enable_reg_info =
   80             acpi_hw_get_bit_register_info(ACPI_BITREG_SLEEP_ENABLE);
   81 
   82         /* Clear wake status */
   83 
   84         status =
   85             acpi_write_bit_register(ACPI_BITREG_WAKE_STATUS, ACPI_CLEAR_STATUS);
   86         if (ACPI_FAILURE(status)) {
   87                 return_ACPI_STATUS(status);
   88         }
   89 
   90         /* Clear all fixed and general purpose status bits */
   91 
   92         status = acpi_hw_clear_acpi_status();
   93         if (ACPI_FAILURE(status)) {
   94                 return_ACPI_STATUS(status);
   95         }
   96 
   97         /*
   98          * 1) Disable/Clear all GPEs
   99          * 2) Enable all wakeup GPEs
  100          */
  101         status = acpi_hw_disable_all_gpes();
  102         if (ACPI_FAILURE(status)) {
  103                 return_ACPI_STATUS(status);
  104         }
  105         acpi_gbl_system_awake_and_running = FALSE;
  106 
  107         status = acpi_hw_enable_all_wakeup_gpes();
  108         if (ACPI_FAILURE(status)) {
  109                 return_ACPI_STATUS(status);
  110         }
  111 
  112         /* Get current value of PM1A control */
  113 
  114         status = acpi_hw_register_read(ACPI_REGISTER_PM1_CONTROL,
  115                                        &pm1a_control);
  116         if (ACPI_FAILURE(status)) {
  117                 return_ACPI_STATUS(status);
  118         }
  119         ACPI_DEBUG_PRINT((ACPI_DB_INIT,
  120                           "Entering sleep state [S%u]\n", sleep_state));
  121 
  122         /* Clear the SLP_EN and SLP_TYP fields */
  123 
  124         pm1a_control &= ~(sleep_type_reg_info->access_bit_mask |
  125                           sleep_enable_reg_info->access_bit_mask);
  126         pm1b_control = pm1a_control;
  127 
  128         /* Insert the SLP_TYP bits */
  129 
  130         pm1a_control |=
  131             (acpi_gbl_sleep_type_a << sleep_type_reg_info->bit_position);
  132         pm1b_control |=
  133             (acpi_gbl_sleep_type_b << sleep_type_reg_info->bit_position);
  134 
  135         /*
  136          * We split the writes of SLP_TYP and SLP_EN to workaround
  137          * poorly implemented hardware.
  138          */
  139 
  140         /* Write #1: write the SLP_TYP data to the PM1 Control registers */
  141 
  142         status = acpi_hw_write_pm1_control(pm1a_control, pm1b_control);
  143         if (ACPI_FAILURE(status)) {
  144                 return_ACPI_STATUS(status);
  145         }
  146 
  147         /* Insert the sleep enable (SLP_EN) bit */
  148 
  149         pm1a_control |= sleep_enable_reg_info->access_bit_mask;
  150         pm1b_control |= sleep_enable_reg_info->access_bit_mask;
  151 
  152         /* Flush caches, as per ACPI specification */
  153 
  154         ACPI_FLUSH_CPU_CACHE();
  155 
  156         status = acpi_os_prepare_sleep(sleep_state, pm1a_control,
  157                                        pm1b_control);
  158         if (ACPI_SKIP(status))
  159                 return_ACPI_STATUS(AE_OK);
  160         if (ACPI_FAILURE(status))
  161                 return_ACPI_STATUS(status);
  162         /* Write #2: Write both SLP_TYP + SLP_EN */
  163 
  164         status = acpi_hw_write_pm1_control(pm1a_control, pm1b_control);
  165         if (ACPI_FAILURE(status)) {
  166                 return_ACPI_STATUS(status);
  167         }
  168 
  169         if (sleep_state > ACPI_STATE_S3) {
  170                 /*
  171                  * We wanted to sleep > S3, but it didn't happen (by virtue of the
  172                  * fact that we are still executing!)
  173                  *
  174                  * Wait ten seconds, then try again. This is to get S4/S5 to work on
  175                  * all machines.
  176                  *
  177                  * We wait so long to allow chipsets that poll this reg very slowly
  178                  * to still read the right value. Ideally, this block would go
  179                  * away entirely.
  180                  */
  181                 acpi_os_stall(10000000);
  182 
  183                 status = acpi_hw_register_write(ACPI_REGISTER_PM1_CONTROL,
  184                                                 sleep_enable_reg_info->
  185                                                 access_bit_mask);
  186                 if (ACPI_FAILURE(status)) {
  187                         return_ACPI_STATUS(status);
  188                 }
  189         }
  190 
  191         /* Wait for transition back to Working State */
  192 
  193         do {
  194                 status =
  195                     acpi_read_bit_register(ACPI_BITREG_WAKE_STATUS, &in_value);
  196                 if (ACPI_FAILURE(status)) {
  197                         return_ACPI_STATUS(status);
  198                 }
  199 
  200         } while (!in_value);
  201 
  202         return_ACPI_STATUS(AE_OK);
  203 }
  204 
  205 /*******************************************************************************
  206  *
  207  * FUNCTION:    acpi_hw_legacy_wake_prep
  208  *
  209  * PARAMETERS:  sleep_state         - Which sleep state we just exited
  210  *
  211  * RETURN:      Status
  212  *
  213  * DESCRIPTION: Perform the first state of OS-independent ACPI cleanup after a
  214  *              sleep.
  215  *              Called with interrupts ENABLED.
  216  *
  217  ******************************************************************************/
  218 
  219 acpi_status acpi_hw_legacy_wake_prep(u8 sleep_state)
  220 {
  221         acpi_status status;
  222         struct acpi_bit_register_info *sleep_type_reg_info;
  223         struct acpi_bit_register_info *sleep_enable_reg_info;
  224         u32 pm1a_control;
  225         u32 pm1b_control;
  226 
  227         ACPI_FUNCTION_TRACE(hw_legacy_wake_prep);
  228 
  229         /*
  230          * Set SLP_TYPE and SLP_EN to state S0.
  231          * This is unclear from the ACPI Spec, but it is required
  232          * by some machines.
  233          */
  234         status = acpi_get_sleep_type_data(ACPI_STATE_S0,
  235                                           &acpi_gbl_sleep_type_a,
  236                                           &acpi_gbl_sleep_type_b);
  237         if (ACPI_SUCCESS(status)) {
  238                 sleep_type_reg_info =
  239                     acpi_hw_get_bit_register_info(ACPI_BITREG_SLEEP_TYPE);
  240                 sleep_enable_reg_info =
  241                     acpi_hw_get_bit_register_info(ACPI_BITREG_SLEEP_ENABLE);
  242 
  243                 /* Get current value of PM1A control */
  244 
  245                 status = acpi_hw_register_read(ACPI_REGISTER_PM1_CONTROL,
  246                                                &pm1a_control);
  247                 if (ACPI_SUCCESS(status)) {
  248 
  249                         /* Clear the SLP_EN and SLP_TYP fields */
  250 
  251                         pm1a_control &= ~(sleep_type_reg_info->access_bit_mask |
  252                                           sleep_enable_reg_info->
  253                                           access_bit_mask);
  254                         pm1b_control = pm1a_control;
  255 
  256                         /* Insert the SLP_TYP bits */
  257 
  258                         pm1a_control |= (acpi_gbl_sleep_type_a <<
  259                                          sleep_type_reg_info->bit_position);
  260                         pm1b_control |= (acpi_gbl_sleep_type_b <<
  261                                          sleep_type_reg_info->bit_position);
  262 
  263                         /* Write the control registers and ignore any errors */
  264 
  265                         (void)acpi_hw_write_pm1_control(pm1a_control,
  266                                                         pm1b_control);
  267                 }
  268         }
  269 
  270         return_ACPI_STATUS(status);
  271 }
  272 
  273 /*******************************************************************************
  274  *
  275  * FUNCTION:    acpi_hw_legacy_wake
  276  *
  277  * PARAMETERS:  sleep_state         - Which sleep state we just exited
  278  *
  279  * RETURN:      Status
  280  *
  281  * DESCRIPTION: Perform OS-independent ACPI cleanup after a sleep
  282  *              Called with interrupts ENABLED.
  283  *
  284  ******************************************************************************/
  285 
  286 acpi_status acpi_hw_legacy_wake(u8 sleep_state)
  287 {
  288         acpi_status status;
  289 
  290         ACPI_FUNCTION_TRACE(hw_legacy_wake);
  291 
  292         /* Ensure enter_sleep_state_prep -> enter_sleep_state ordering */
  293 
  294         acpi_gbl_sleep_type_a = ACPI_SLEEP_TYPE_INVALID;
  295         acpi_hw_execute_sleep_method(METHOD_PATHNAME__SST, ACPI_SST_WAKING);
  296 
  297         /*
  298          * GPEs must be enabled before _WAK is called as GPEs
  299          * might get fired there
  300          *
  301          * Restore the GPEs:
  302          * 1) Disable/Clear all GPEs
  303          * 2) Enable all runtime GPEs
  304          */
  305         status = acpi_hw_disable_all_gpes();
  306         if (ACPI_FAILURE(status)) {
  307                 return_ACPI_STATUS(status);
  308         }
  309 
  310         status = acpi_hw_enable_all_runtime_gpes();
  311         if (ACPI_FAILURE(status)) {
  312                 return_ACPI_STATUS(status);
  313         }
  314 
  315         /*
  316          * Now we can execute _WAK, etc. Some machines require that the GPEs
  317          * are enabled before the wake methods are executed.
  318          */
  319         acpi_hw_execute_sleep_method(METHOD_PATHNAME__WAK, sleep_state);
  320 
  321         /*
  322          * Some BIOS code assumes that WAK_STS will be cleared on resume
  323          * and use it to determine whether the system is rebooting or
  324          * resuming. Clear WAK_STS for compatibility.
  325          */
  326         acpi_write_bit_register(ACPI_BITREG_WAKE_STATUS, 1);
  327         acpi_gbl_system_awake_and_running = TRUE;
  328 
  329         /* Enable power button */
  330 
  331         (void)
  332             acpi_write_bit_register(acpi_gbl_fixed_event_info
  333                                     [ACPI_EVENT_POWER_BUTTON].
  334                                     enable_register_id, ACPI_ENABLE_EVENT);
  335 
  336         (void)
  337             acpi_write_bit_register(acpi_gbl_fixed_event_info
  338                                     [ACPI_EVENT_POWER_BUTTON].
  339                                     status_register_id, ACPI_CLEAR_STATUS);
  340 
  341         acpi_hw_execute_sleep_method(METHOD_PATHNAME__SST, ACPI_SST_WORKING);
  342         return_ACPI_STATUS(status);
  343 }
  344 
  345 #endif                          /* !ACPI_REDUCED_HARDWARE */
Cache object: a0bdb7bc63a8e453a46194f94f0ec145
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/drivers/acpi/acpica/hwsleep.c

FreeBSD/Linux Kernel Cross Reference
sys/drivers/acpi/acpica/hwsleep.c
