1231798Sjkim/****************************************************************************** 2231798Sjkim * 3231798Sjkim * Name: hwxfsleep.c - ACPI Hardware Sleep/Wake External Interfaces 4231798Sjkim * 5231798Sjkim *****************************************************************************/ 6231798Sjkim 7231798Sjkim/* 8306536Sjkim * Copyright (C) 2000 - 2016, Intel Corp. 9231798Sjkim * All rights reserved. 10231798Sjkim * 11231798Sjkim * Redistribution and use in source and binary forms, with or without 12231798Sjkim * modification, are permitted provided that the following conditions 13231798Sjkim * are met: 14231798Sjkim * 1. Redistributions of source code must retain the above copyright 15231798Sjkim * notice, this list of conditions, and the following disclaimer, 16231798Sjkim * without modification. 17231798Sjkim * 2. Redistributions in binary form must reproduce at minimum a disclaimer 18231798Sjkim * substantially similar to the "NO WARRANTY" disclaimer below 19231798Sjkim * ("Disclaimer") and any redistribution must be conditioned upon 20231798Sjkim * including a substantially similar Disclaimer requirement for further 21231798Sjkim * binary redistribution. 22231798Sjkim * 3. Neither the names of the above-listed copyright holders nor the names 23231798Sjkim * of any contributors may be used to endorse or promote products derived 24231798Sjkim * from this software without specific prior written permission. 25231798Sjkim * 26231798Sjkim * Alternatively, this software may be distributed under the terms of the 27231798Sjkim * GNU General Public License ("GPL") version 2 as published by the Free 28231798Sjkim * Software Foundation. 29231798Sjkim * 30231798Sjkim * NO WARRANTY 31231798Sjkim * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 32231798Sjkim * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 33231798Sjkim * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 34231798Sjkim * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 35231798Sjkim * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 36231798Sjkim * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 37231798Sjkim * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 38231798Sjkim * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 39231798Sjkim * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 40231798Sjkim * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 41231798Sjkim * POSSIBILITY OF SUCH DAMAGES. 42231798Sjkim */ 43231798Sjkim 44281075Sdim#define EXPORT_ACPI_INTERFACES 45281075Sdim 46231844Sjkim#include <contrib/dev/acpica/include/acpi.h> 47231844Sjkim#include <contrib/dev/acpica/include/accommon.h> 48231798Sjkim 49231798Sjkim#define _COMPONENT ACPI_HARDWARE 50231798Sjkim ACPI_MODULE_NAME ("hwxfsleep") 51231798Sjkim 52231798Sjkim/* Local prototypes */ 53231798Sjkim 54306536Sjkim#if (!ACPI_REDUCED_HARDWARE) 55231798Sjkimstatic ACPI_STATUS 56306536SjkimAcpiHwSetFirmwareWakingVector ( 57306536Sjkim ACPI_TABLE_FACS *Facs, 58306536Sjkim ACPI_PHYSICAL_ADDRESS PhysicalAddress, 59306536Sjkim ACPI_PHYSICAL_ADDRESS PhysicalAddress64); 60306536Sjkim#endif 61306536Sjkim 62306536Sjkimstatic ACPI_STATUS 63231798SjkimAcpiHwSleepDispatch ( 64231798Sjkim UINT8 SleepState, 65231798Sjkim UINT32 FunctionId); 66231798Sjkim 67231798Sjkim/* 68231798Sjkim * Dispatch table used to efficiently branch to the various sleep 69231798Sjkim * functions. 70231798Sjkim */ 71231798Sjkim#define ACPI_SLEEP_FUNCTION_ID 0 72231798Sjkim#define ACPI_WAKE_PREP_FUNCTION_ID 1 73231798Sjkim#define ACPI_WAKE_FUNCTION_ID 2 74231798Sjkim 75231798Sjkim/* Legacy functions are optional, based upon ACPI_REDUCED_HARDWARE */ 76231798Sjkim 77231798Sjkimstatic ACPI_SLEEP_FUNCTIONS AcpiSleepDispatch[] = 78231798Sjkim{ 79231798Sjkim {ACPI_HW_OPTIONAL_FUNCTION (AcpiHwLegacySleep), AcpiHwExtendedSleep}, 80231798Sjkim {ACPI_HW_OPTIONAL_FUNCTION (AcpiHwLegacyWakePrep), AcpiHwExtendedWakePrep}, 81231798Sjkim {ACPI_HW_OPTIONAL_FUNCTION (AcpiHwLegacyWake), AcpiHwExtendedWake} 82231798Sjkim}; 83231798Sjkim 84231798Sjkim 85231798Sjkim/* 86231798Sjkim * These functions are removed for the ACPI_REDUCED_HARDWARE case: 87231798Sjkim * AcpiSetFirmwareWakingVector 88231798Sjkim * AcpiEnterSleepStateS4bios 89231798Sjkim */ 90231798Sjkim 91231798Sjkim#if (!ACPI_REDUCED_HARDWARE) 92231798Sjkim/******************************************************************************* 93231798Sjkim * 94306536Sjkim * FUNCTION: AcpiHwSetFirmwareWakingVector 95231798Sjkim * 96306536Sjkim * PARAMETERS: Facs - Pointer to FACS table 97306536Sjkim * PhysicalAddress - 32-bit physical address of ACPI real mode 98306536Sjkim * entry point 99306536Sjkim * PhysicalAddress64 - 64-bit physical address of ACPI protected 100306536Sjkim * mode entry point 101231798Sjkim * 102231798Sjkim * RETURN: Status 103231798Sjkim * 104306536Sjkim * DESCRIPTION: Sets the FirmwareWakingVector fields of the FACS 105231798Sjkim * 106231798Sjkim ******************************************************************************/ 107231798Sjkim 108306536Sjkimstatic ACPI_STATUS 109306536SjkimAcpiHwSetFirmwareWakingVector ( 110306536Sjkim ACPI_TABLE_FACS *Facs, 111306536Sjkim ACPI_PHYSICAL_ADDRESS PhysicalAddress, 112306536Sjkim ACPI_PHYSICAL_ADDRESS PhysicalAddress64) 113231798Sjkim{ 114306536Sjkim ACPI_FUNCTION_TRACE (AcpiHwSetFirmwareWakingVector); 115231798Sjkim 116231798Sjkim 117238381Sjkim /* 118238381Sjkim * According to the ACPI specification 2.0c and later, the 64-bit 119238381Sjkim * waking vector should be cleared and the 32-bit waking vector should 120238381Sjkim * be used, unless we want the wake-up code to be called by the BIOS in 121238381Sjkim * Protected Mode. Some systems (for example HP dv5-1004nr) are known 122238381Sjkim * to fail to resume if the 64-bit vector is used. 123238381Sjkim */ 124238381Sjkim 125231798Sjkim /* Set the 32-bit vector */ 126231798Sjkim 127306536Sjkim Facs->FirmwareWakingVector = (UINT32) PhysicalAddress; 128231798Sjkim 129306536Sjkim if (Facs->Length > 32) 130306536Sjkim { 131306536Sjkim if (Facs->Version >= 1) 132306536Sjkim { 133306536Sjkim /* Set the 64-bit vector */ 134231798Sjkim 135306536Sjkim Facs->XFirmwareWakingVector = PhysicalAddress64; 136306536Sjkim } 137306536Sjkim else 138306536Sjkim { 139306536Sjkim /* Clear the 64-bit vector if it exists */ 140306536Sjkim 141306536Sjkim Facs->XFirmwareWakingVector = 0; 142306536Sjkim } 143231798Sjkim } 144231798Sjkim 145231798Sjkim return_ACPI_STATUS (AE_OK); 146231798Sjkim} 147231798Sjkim 148231798Sjkim 149231798Sjkim/******************************************************************************* 150231798Sjkim * 151306536Sjkim * FUNCTION: AcpiSetFirmwareWakingVector 152231798Sjkim * 153306536Sjkim * PARAMETERS: PhysicalAddress - 32-bit physical address of ACPI real mode 154306536Sjkim * entry point 155306536Sjkim * PhysicalAddress64 - 64-bit physical address of ACPI protected 156306536Sjkim * mode entry point 157231798Sjkim * 158231798Sjkim * RETURN: Status 159231798Sjkim * 160306536Sjkim * DESCRIPTION: Sets the FirmwareWakingVector fields of the FACS 161231798Sjkim * 162231798Sjkim ******************************************************************************/ 163231798Sjkim 164231798SjkimACPI_STATUS 165306536SjkimAcpiSetFirmwareWakingVector ( 166306536Sjkim ACPI_PHYSICAL_ADDRESS PhysicalAddress, 167306536Sjkim ACPI_PHYSICAL_ADDRESS PhysicalAddress64) 168231798Sjkim{ 169231798Sjkim 170306536Sjkim ACPI_FUNCTION_TRACE (AcpiSetFirmwareWakingVector); 171231798Sjkim 172306536Sjkim if (AcpiGbl_FACS) 173231798Sjkim { 174306536Sjkim (void) AcpiHwSetFirmwareWakingVector (AcpiGbl_FACS, 175306536Sjkim PhysicalAddress, PhysicalAddress64); 176231798Sjkim } 177231798Sjkim 178231798Sjkim return_ACPI_STATUS (AE_OK); 179231798Sjkim} 180231798Sjkim 181306536SjkimACPI_EXPORT_SYMBOL (AcpiSetFirmwareWakingVector) 182231798Sjkim 183231798Sjkim 184231798Sjkim/******************************************************************************* 185231798Sjkim * 186231798Sjkim * FUNCTION: AcpiEnterSleepStateS4bios 187231798Sjkim * 188231798Sjkim * PARAMETERS: None 189231798Sjkim * 190231798Sjkim * RETURN: Status 191231798Sjkim * 192231798Sjkim * DESCRIPTION: Perform a S4 bios request. 193231798Sjkim * THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED 194231798Sjkim * 195231798Sjkim ******************************************************************************/ 196231798Sjkim 197231798SjkimACPI_STATUS 198231798SjkimAcpiEnterSleepStateS4bios ( 199231798Sjkim void) 200231798Sjkim{ 201231798Sjkim UINT32 InValue; 202231798Sjkim ACPI_STATUS Status; 203231798Sjkim 204231798Sjkim 205231798Sjkim ACPI_FUNCTION_TRACE (AcpiEnterSleepStateS4bios); 206231798Sjkim 207231798Sjkim 208231798Sjkim /* Clear the wake status bit (PM1) */ 209231798Sjkim 210231798Sjkim Status = AcpiWriteBitRegister (ACPI_BITREG_WAKE_STATUS, ACPI_CLEAR_STATUS); 211231798Sjkim if (ACPI_FAILURE (Status)) 212231798Sjkim { 213231798Sjkim return_ACPI_STATUS (Status); 214231798Sjkim } 215231798Sjkim 216231798Sjkim Status = AcpiHwClearAcpiStatus (); 217231798Sjkim if (ACPI_FAILURE (Status)) 218231798Sjkim { 219231798Sjkim return_ACPI_STATUS (Status); 220231798Sjkim } 221231798Sjkim 222231798Sjkim /* 223231798Sjkim * 1) Disable/Clear all GPEs 224231798Sjkim * 2) Enable all wakeup GPEs 225231798Sjkim */ 226231798Sjkim Status = AcpiHwDisableAllGpes (); 227231798Sjkim if (ACPI_FAILURE (Status)) 228231798Sjkim { 229231798Sjkim return_ACPI_STATUS (Status); 230231798Sjkim } 231231798Sjkim AcpiGbl_SystemAwakeAndRunning = FALSE; 232231798Sjkim 233231798Sjkim Status = AcpiHwEnableAllWakeupGpes (); 234231798Sjkim if (ACPI_FAILURE (Status)) 235231798Sjkim { 236231798Sjkim return_ACPI_STATUS (Status); 237231798Sjkim } 238231798Sjkim 239231798Sjkim ACPI_FLUSH_CPU_CACHE (); 240231798Sjkim 241231798Sjkim Status = AcpiHwWritePort (AcpiGbl_FADT.SmiCommand, 242306536Sjkim (UINT32) AcpiGbl_FADT.S4BiosRequest, 8); 243231798Sjkim 244231798Sjkim do { 245245582Sjkim AcpiOsStall (ACPI_USEC_PER_MSEC); 246231798Sjkim Status = AcpiReadBitRegister (ACPI_BITREG_WAKE_STATUS, &InValue); 247231798Sjkim if (ACPI_FAILURE (Status)) 248231798Sjkim { 249231798Sjkim return_ACPI_STATUS (Status); 250231798Sjkim } 251306536Sjkim 252231798Sjkim } while (!InValue); 253231798Sjkim 254231798Sjkim return_ACPI_STATUS (AE_OK); 255231798Sjkim} 256231798Sjkim 257231798SjkimACPI_EXPORT_SYMBOL (AcpiEnterSleepStateS4bios) 258231798Sjkim 259231798Sjkim#endif /* !ACPI_REDUCED_HARDWARE */ 260231798Sjkim 261231798Sjkim 262231798Sjkim/******************************************************************************* 263231798Sjkim * 264231798Sjkim * FUNCTION: AcpiHwSleepDispatch 265231798Sjkim * 266231798Sjkim * PARAMETERS: SleepState - Which sleep state to enter/exit 267231798Sjkim * FunctionId - Sleep, WakePrep, or Wake 268231798Sjkim * 269231798Sjkim * RETURN: Status from the invoked sleep handling function. 270231798Sjkim * 271231798Sjkim * DESCRIPTION: Dispatch a sleep/wake request to the appropriate handling 272231798Sjkim * function. 273231798Sjkim * 274231798Sjkim ******************************************************************************/ 275231798Sjkim 276231798Sjkimstatic ACPI_STATUS 277231798SjkimAcpiHwSleepDispatch ( 278231798Sjkim UINT8 SleepState, 279231798Sjkim UINT32 FunctionId) 280231798Sjkim{ 281231798Sjkim ACPI_STATUS Status; 282231798Sjkim ACPI_SLEEP_FUNCTIONS *SleepFunctions = &AcpiSleepDispatch[FunctionId]; 283231798Sjkim 284231798Sjkim 285231798Sjkim#if (!ACPI_REDUCED_HARDWARE) 286231798Sjkim /* 287231798Sjkim * If the Hardware Reduced flag is set (from the FADT), we must 288250838Sjkim * use the extended sleep registers (FADT). Note: As per the ACPI 289250838Sjkim * specification, these extended registers are to be used for HW-reduced 290250838Sjkim * platforms only. They are not general-purpose replacements for the 291250838Sjkim * legacy PM register sleep support. 292231798Sjkim */ 293250838Sjkim if (AcpiGbl_ReducedHardware) 294231798Sjkim { 295239340Sjkim Status = SleepFunctions->ExtendedFunction (SleepState); 296231798Sjkim } 297231798Sjkim else 298231798Sjkim { 299231798Sjkim /* Legacy sleep */ 300231798Sjkim 301239340Sjkim Status = SleepFunctions->LegacyFunction (SleepState); 302231798Sjkim } 303231798Sjkim 304231798Sjkim return (Status); 305231798Sjkim 306231798Sjkim#else 307231798Sjkim /* 308231798Sjkim * For the case where reduced-hardware-only code is being generated, 309231798Sjkim * we know that only the extended sleep registers are available 310231798Sjkim */ 311239340Sjkim Status = SleepFunctions->ExtendedFunction (SleepState); 312231798Sjkim return (Status); 313231798Sjkim 314231798Sjkim#endif /* !ACPI_REDUCED_HARDWARE */ 315231798Sjkim} 316231798Sjkim 317231798Sjkim 318231798Sjkim/******************************************************************************* 319231798Sjkim * 320231798Sjkim * FUNCTION: AcpiEnterSleepStatePrep 321231798Sjkim * 322231798Sjkim * PARAMETERS: SleepState - Which sleep state to enter 323231798Sjkim * 324231798Sjkim * RETURN: Status 325231798Sjkim * 326231798Sjkim * DESCRIPTION: Prepare to enter a system sleep state. 327231798Sjkim * This function must execute with interrupts enabled. 328231798Sjkim * We break sleeping into 2 stages so that OSPM can handle 329231798Sjkim * various OS-specific tasks between the two steps. 330231798Sjkim * 331231798Sjkim ******************************************************************************/ 332231798Sjkim 333231798SjkimACPI_STATUS 334231798SjkimAcpiEnterSleepStatePrep ( 335231798Sjkim UINT8 SleepState) 336231798Sjkim{ 337231798Sjkim ACPI_STATUS Status; 338231798Sjkim ACPI_OBJECT_LIST ArgList; 339231798Sjkim ACPI_OBJECT Arg; 340231798Sjkim UINT32 SstValue; 341231798Sjkim 342231798Sjkim 343231798Sjkim ACPI_FUNCTION_TRACE (AcpiEnterSleepStatePrep); 344231798Sjkim 345231798Sjkim 346231798Sjkim Status = AcpiGetSleepTypeData (SleepState, 347306536Sjkim &AcpiGbl_SleepTypeA, &AcpiGbl_SleepTypeB); 348231798Sjkim if (ACPI_FAILURE (Status)) 349231798Sjkim { 350231798Sjkim return_ACPI_STATUS (Status); 351231798Sjkim } 352231798Sjkim 353231798Sjkim /* Execute the _PTS method (Prepare To Sleep) */ 354231798Sjkim 355231798Sjkim ArgList.Count = 1; 356231798Sjkim ArgList.Pointer = &Arg; 357231798Sjkim Arg.Type = ACPI_TYPE_INTEGER; 358231798Sjkim Arg.Integer.Value = SleepState; 359231798Sjkim 360233250Sjkim Status = AcpiEvaluateObject (NULL, METHOD_PATHNAME__PTS, &ArgList, NULL); 361231798Sjkim if (ACPI_FAILURE (Status) && Status != AE_NOT_FOUND) 362231798Sjkim { 363231798Sjkim return_ACPI_STATUS (Status); 364231798Sjkim } 365231798Sjkim 366231798Sjkim /* Setup the argument to the _SST method (System STatus) */ 367231798Sjkim 368231798Sjkim switch (SleepState) 369231798Sjkim { 370231798Sjkim case ACPI_STATE_S0: 371250838Sjkim 372231798Sjkim SstValue = ACPI_SST_WORKING; 373231798Sjkim break; 374231798Sjkim 375231798Sjkim case ACPI_STATE_S1: 376231798Sjkim case ACPI_STATE_S2: 377231798Sjkim case ACPI_STATE_S3: 378250838Sjkim 379231798Sjkim SstValue = ACPI_SST_SLEEPING; 380231798Sjkim break; 381231798Sjkim 382231798Sjkim case ACPI_STATE_S4: 383250838Sjkim 384231798Sjkim SstValue = ACPI_SST_SLEEP_CONTEXT; 385231798Sjkim break; 386231798Sjkim 387231798Sjkim default: 388250838Sjkim 389231798Sjkim SstValue = ACPI_SST_INDICATOR_OFF; /* Default is off */ 390231798Sjkim break; 391231798Sjkim } 392231798Sjkim 393231798Sjkim /* 394231798Sjkim * Set the system indicators to show the desired sleep state. 395231798Sjkim * _SST is an optional method (return no error if not found) 396231798Sjkim */ 397233250Sjkim AcpiHwExecuteSleepMethod (METHOD_PATHNAME__SST, SstValue); 398231798Sjkim return_ACPI_STATUS (AE_OK); 399231798Sjkim} 400231798Sjkim 401231798SjkimACPI_EXPORT_SYMBOL (AcpiEnterSleepStatePrep) 402231798Sjkim 403231798Sjkim 404231798Sjkim/******************************************************************************* 405231798Sjkim * 406231798Sjkim * FUNCTION: AcpiEnterSleepState 407231798Sjkim * 408231798Sjkim * PARAMETERS: SleepState - Which sleep state to enter 409231798Sjkim * 410231798Sjkim * RETURN: Status 411231798Sjkim * 412231798Sjkim * DESCRIPTION: Enter a system sleep state 413231798Sjkim * THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED 414231798Sjkim * 415231798Sjkim ******************************************************************************/ 416231798Sjkim 417231798SjkimACPI_STATUS 418231798SjkimAcpiEnterSleepState ( 419239340Sjkim UINT8 SleepState) 420231798Sjkim{ 421231798Sjkim ACPI_STATUS Status; 422231798Sjkim 423231798Sjkim 424231798Sjkim ACPI_FUNCTION_TRACE (AcpiEnterSleepState); 425231798Sjkim 426231798Sjkim 427231798Sjkim if ((AcpiGbl_SleepTypeA > ACPI_SLEEP_TYPE_MAX) || 428231798Sjkim (AcpiGbl_SleepTypeB > ACPI_SLEEP_TYPE_MAX)) 429231798Sjkim { 430231798Sjkim ACPI_ERROR ((AE_INFO, "Sleep values out of range: A=0x%X B=0x%X", 431231798Sjkim AcpiGbl_SleepTypeA, AcpiGbl_SleepTypeB)); 432231798Sjkim return_ACPI_STATUS (AE_AML_OPERAND_VALUE); 433231798Sjkim } 434231798Sjkim 435239340Sjkim Status = AcpiHwSleepDispatch (SleepState, ACPI_SLEEP_FUNCTION_ID); 436231798Sjkim return_ACPI_STATUS (Status); 437231798Sjkim} 438231798Sjkim 439231798SjkimACPI_EXPORT_SYMBOL (AcpiEnterSleepState) 440231798Sjkim 441231798Sjkim 442231798Sjkim/******************************************************************************* 443231798Sjkim * 444231798Sjkim * FUNCTION: AcpiLeaveSleepStatePrep 445231798Sjkim * 446231798Sjkim * PARAMETERS: SleepState - Which sleep state we are exiting 447231798Sjkim * 448231798Sjkim * RETURN: Status 449231798Sjkim * 450231798Sjkim * DESCRIPTION: Perform the first state of OS-independent ACPI cleanup after a 451231798Sjkim * sleep. Called with interrupts DISABLED. 452231798Sjkim * We break wake/resume into 2 stages so that OSPM can handle 453231798Sjkim * various OS-specific tasks between the two steps. 454231798Sjkim * 455231798Sjkim ******************************************************************************/ 456231798Sjkim 457231798SjkimACPI_STATUS 458231798SjkimAcpiLeaveSleepStatePrep ( 459239340Sjkim UINT8 SleepState) 460231798Sjkim{ 461231798Sjkim ACPI_STATUS Status; 462231798Sjkim 463231798Sjkim 464231798Sjkim ACPI_FUNCTION_TRACE (AcpiLeaveSleepStatePrep); 465231798Sjkim 466231798Sjkim 467239340Sjkim Status = AcpiHwSleepDispatch (SleepState, ACPI_WAKE_PREP_FUNCTION_ID); 468231798Sjkim return_ACPI_STATUS (Status); 469231798Sjkim} 470231798Sjkim 471231798SjkimACPI_EXPORT_SYMBOL (AcpiLeaveSleepStatePrep) 472231798Sjkim 473231798Sjkim 474231798Sjkim/******************************************************************************* 475231798Sjkim * 476231798Sjkim * FUNCTION: AcpiLeaveSleepState 477231798Sjkim * 478231798Sjkim * PARAMETERS: SleepState - Which sleep state we are exiting 479231798Sjkim * 480231798Sjkim * RETURN: Status 481231798Sjkim * 482231798Sjkim * DESCRIPTION: Perform OS-independent ACPI cleanup after a sleep 483231798Sjkim * Called with interrupts ENABLED. 484231798Sjkim * 485231798Sjkim ******************************************************************************/ 486231798Sjkim 487231798SjkimACPI_STATUS 488231798SjkimAcpiLeaveSleepState ( 489231798Sjkim UINT8 SleepState) 490231798Sjkim{ 491231798Sjkim ACPI_STATUS Status; 492231798Sjkim 493231798Sjkim 494231798Sjkim ACPI_FUNCTION_TRACE (AcpiLeaveSleepState); 495231798Sjkim 496231798Sjkim 497239340Sjkim Status = AcpiHwSleepDispatch (SleepState, ACPI_WAKE_FUNCTION_ID); 498231798Sjkim return_ACPI_STATUS (Status); 499231798Sjkim} 500231798Sjkim 501231798SjkimACPI_EXPORT_SYMBOL (AcpiLeaveSleepState) 502