drivers/acpi/acpica/hwxfsleep.c

   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
  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
 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
 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
 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
 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
 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
 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)