l4/pkg/acpica/lib-acpi/src/acpica/components/hardware/hwxfsleep.c

   1 /******************************************************************************
   2  *
   3  * Name: hwxfsleep.c - ACPI Hardware Sleep/Wake External Interfaces
   4  *
   5  *****************************************************************************/
   6
   7 /******************************************************************************
   8  *
   9  * 1. Copyright Notice
  10  *
  11  * Some or all of this work - Copyright (c) 1999 - 2012, Intel Corp.
  12  * All rights reserved.
  13  *
  14  * 2. License
  15  *
  16  * 2.1. This is your license from Intel Corp. under its intellectual property
  17  * rights. You may have additional license terms from the party that provided
  18  * you this software, covering your right to use that party's intellectual
  19  * property rights.
  20  *
  21  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  22  * copy of the source code appearing in this file ("Covered Code") an
  23  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  24  * base code distributed originally by Intel ("Original Intel Code") to copy,
  25  * make derivatives, distribute, use and display any portion of the Covered
  26  * Code in any form, with the right to sublicense such rights; and
  27  *
  28  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  29  * license (with the right to sublicense), under only those claims of Intel
  30  * patents that are infringed by the Original Intel Code, to make, use, sell,
  31  * offer to sell, and import the Covered Code and derivative works thereof
  32  * solely to the minimum extent necessary to exercise the above copyright
  33  * license, and in no event shall the patent license extend to any additions
  34  * to or modifications of the Original Intel Code. No other license or right
  35  * is granted directly or by implication, estoppel or otherwise;
  36  *
  37  * The above copyright and patent license is granted only if the following
  38  * conditions are met:
  39  *
  40  * 3. Conditions
  41  *
  42  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  43  * Redistribution of source code of any substantial portion of the Covered
  44  * Code or modification with rights to further distribute source must include
  45  * the above Copyright Notice, the above License, this list of Conditions,
  46  * and the following Disclaimer and Export Compliance provision. In addition,
  47  * Licensee must cause all Covered Code to which Licensee contributes to
  48  * contain a file documenting the changes Licensee made to create that Covered
  49  * Code and the date of any change. Licensee must include in that file the
  50  * documentation of any changes made by any predecessor Licensee. Licensee
  51  * must include a prominent statement that the modification is derived,
  52  * directly or indirectly, from Original Intel Code.
  53  *
  54  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  55  * Redistribution of source code of any substantial portion of the Covered
  56  * Code or modification without rights to further distribute source must
  57  * include the following Disclaimer and Export Compliance provision in the
  58  * documentation and/or other materials provided with distribution. In
  59  * addition, Licensee may not authorize further sublicense of source of any
  60  * portion of the Covered Code, and must include terms to the effect that the
  61  * license from Licensee to its licensee is limited to the intellectual
  62  * property embodied in the software Licensee provides to its licensee, and
  63  * not to intellectual property embodied in modifications its licensee may
  64  * make.
  65  *
  66  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  67  * substantial portion of the Covered Code or modification must reproduce the
  68  * above Copyright Notice, and the following Disclaimer and Export Compliance
  69  * provision in the documentation and/or other materials provided with the
  70  * distribution.
  71  *
  72  * 3.4. Intel retains all right, title, and interest in and to the Original
  73  * Intel Code.
  74  *
  75  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  76  * Intel shall be used in advertising or otherwise to promote the sale, use or
  77  * other dealings in products derived from or relating to the Covered Code
  78  * without prior written authorization from Intel.
  79  *
  80  * 4. Disclaimer and Export Compliance
  81  *
  82  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  83  * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  84  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
  85  * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
  86  * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
  87  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  88  * PARTICULAR PURPOSE.
  89  *
  90  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  91  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  92  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  93  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  94  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  95  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
  96  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  97  * LIMITED REMEDY.
  98  *
  99  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 100  * software or system incorporating such software without first obtaining any
 101  * required license or other approval from the U. S. Department of Commerce or
 102  * any other agency or department of the United States Government. In the
 103  * event Licensee exports any such software from the United States or
 104  * re-exports any such software from a foreign destination, Licensee shall
 105  * ensure that the distribution and export/re-export of the software is in
 106  * compliance with all laws, regulations, orders, or other restrictions of the
 107  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 108  * any of its subsidiaries will export/re-export any technical data, process,
 109  * software, or service, directly or indirectly, to any country for which the
 110  * United States government or any agency thereof requires an export license,
 111  * other governmental approval, or letter of assurance, without first obtaining
 112  * such license, approval or letter.
 113  *
 114  *****************************************************************************/
 115
 116 #include "acpi.h"
 117 #include "accommon.h"
 118
 119 #define _COMPONENT          ACPI_HARDWARE
 120         ACPI_MODULE_NAME    ("hwxfsleep")
 121
 122 /* Local prototypes */
 123
 124 static ACPI_STATUS
 125 AcpiHwSleepDispatch (
 126     UINT8                   SleepState,
 127     UINT32                  FunctionId);
 128
 129 /*
 130  * Dispatch table used to efficiently branch to the various sleep
 131  * functions.
 132  */
 133 #define ACPI_SLEEP_FUNCTION_ID          0
 134 #define ACPI_WAKE_PREP_FUNCTION_ID      1
 135 #define ACPI_WAKE_FUNCTION_ID           2
 136
 137 /* Legacy functions are optional, based upon ACPI_REDUCED_HARDWARE */
 138
 139 static ACPI_SLEEP_FUNCTIONS         AcpiSleepDispatch[] =
 140 {
 141     {ACPI_HW_OPTIONAL_FUNCTION (AcpiHwLegacySleep),    AcpiHwExtendedSleep},
 142     {ACPI_HW_OPTIONAL_FUNCTION (AcpiHwLegacyWakePrep), AcpiHwExtendedWakePrep},
 143     {ACPI_HW_OPTIONAL_FUNCTION (AcpiHwLegacyWake),     AcpiHwExtendedWake}
 144 };
 145
 146
 147 /*
 148  * These functions are removed for the ACPI_REDUCED_HARDWARE case:
 149  *      AcpiSetFirmwareWakingVector
 150  *      AcpiSetFirmwareWakingVector64
 151  *      AcpiEnterSleepStateS4bios
 152  */
 153
 154 #if (!ACPI_REDUCED_HARDWARE)
 155 /*******************************************************************************
 156  *
 157  * FUNCTION:    AcpiSetFirmwareWakingVector
 158  *
 159  * PARAMETERS:  PhysicalAddress     - 32-bit physical address of ACPI real mode
 160  *                                    entry point.
 161  *
 162  * RETURN:      Status
 163  *
 164  * DESCRIPTION: Sets the 32-bit FirmwareWakingVector field of the FACS
 165  *
 166  ******************************************************************************/
 167
 168 ACPI_STATUS
 169 AcpiSetFirmwareWakingVector (
 170     UINT32                  PhysicalAddress)
 171 {
 172     ACPI_FUNCTION_TRACE (AcpiSetFirmwareWakingVector);
 173
 174
 175     /*
 176      * According to the ACPI specification 2.0c and later, the 64-bit
 177      * waking vector should be cleared and the 32-bit waking vector should
 178      * be used, unless we want the wake-up code to be called by the BIOS in
 179      * Protected Mode. Some systems (for example HP dv5-1004nr) are known
 180      * to fail to resume if the 64-bit vector is used.
 181      */
 182
 183     /* Set the 32-bit vector */
 184
 185     AcpiGbl_FACS->FirmwareWakingVector = PhysicalAddress;
 186
 187     /* Clear the 64-bit vector if it exists */
 188
 189     if ((AcpiGbl_FACS->Length > 32) && (AcpiGbl_FACS->Version >= 1))
 190     {
 191         AcpiGbl_FACS->XFirmwareWakingVector = 0;
 192     }
 193
 194     return_ACPI_STATUS (AE_OK);
 195 }
 196
 197 ACPI_EXPORT_SYMBOL (AcpiSetFirmwareWakingVector)
 198
 199
 200 #if ACPI_MACHINE_WIDTH == 64
 201 /*******************************************************************************
 202  *
 203  * FUNCTION:    AcpiSetFirmwareWakingVector64
 204  *
 205  * PARAMETERS:  PhysicalAddress     - 64-bit physical address of ACPI protected
 206  *                                    mode entry point.
 207  *
 208  * RETURN:      Status
 209  *
 210  * DESCRIPTION: Sets the 64-bit X_FirmwareWakingVector field of the FACS, if
 211  *              it exists in the table. This function is intended for use with
 212  *              64-bit host operating systems.
 213  *
 214  ******************************************************************************/
 215
 216 ACPI_STATUS
 217 AcpiSetFirmwareWakingVector64 (
 218     UINT64                  PhysicalAddress)
 219 {
 220     ACPI_FUNCTION_TRACE (AcpiSetFirmwareWakingVector64);
 221
 222
 223     /* Determine if the 64-bit vector actually exists */
 224
 225     if ((AcpiGbl_FACS->Length <= 32) || (AcpiGbl_FACS->Version < 1))
 226     {
 227         return_ACPI_STATUS (AE_NOT_EXIST);
 228     }
 229
 230     /* Clear 32-bit vector, set the 64-bit X_ vector */
 231
 232     AcpiGbl_FACS->FirmwareWakingVector = 0;
 233     AcpiGbl_FACS->XFirmwareWakingVector = PhysicalAddress;
 234     return_ACPI_STATUS (AE_OK);
 235 }
 236
 237 ACPI_EXPORT_SYMBOL (AcpiSetFirmwareWakingVector64)
 238 #endif
 239
 240
 241 /*******************************************************************************
 242  *
 243  * FUNCTION:    AcpiEnterSleepStateS4bios
 244  *
 245  * PARAMETERS:  None
 246  *
 247  * RETURN:      Status
 248  *
 249  * DESCRIPTION: Perform a S4 bios request.
 250  *              THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED
 251  *
 252  ******************************************************************************/
 253
 254 ACPI_STATUS
 255 AcpiEnterSleepStateS4bios (
 256     void)
 257 {
 258     UINT32                  InValue;
 259     ACPI_STATUS             Status;
 260
 261
 262     ACPI_FUNCTION_TRACE (AcpiEnterSleepStateS4bios);
 263
 264
 265     /* Clear the wake status bit (PM1) */
 266
 267     Status = AcpiWriteBitRegister (ACPI_BITREG_WAKE_STATUS, ACPI_CLEAR_STATUS);
 268     if (ACPI_FAILURE (Status))
 269     {
 270         return_ACPI_STATUS (Status);
 271     }
 272
 273     Status = AcpiHwClearAcpiStatus ();
 274     if (ACPI_FAILURE (Status))
 275     {
 276         return_ACPI_STATUS (Status);
 277     }
 278
 279     /*
 280      * 1) Disable/Clear all GPEs
 281      * 2) Enable all wakeup GPEs
 282      */
 283     Status = AcpiHwDisableAllGpes ();
 284     if (ACPI_FAILURE (Status))
 285     {
 286         return_ACPI_STATUS (Status);
 287     }
 288     AcpiGbl_SystemAwakeAndRunning = FALSE;
 289
 290     Status = AcpiHwEnableAllWakeupGpes ();
 291     if (ACPI_FAILURE (Status))
 292     {
 293         return_ACPI_STATUS (Status);
 294     }
 295
 296     ACPI_FLUSH_CPU_CACHE ();
 297
 298     Status = AcpiHwWritePort (AcpiGbl_FADT.SmiCommand,
 299                 (UINT32) AcpiGbl_FADT.S4BiosRequest, 8);
 300
 301     do {
 302         AcpiOsStall(1000);
 303         Status = AcpiReadBitRegister (ACPI_BITREG_WAKE_STATUS, &InValue);
 304         if (ACPI_FAILURE (Status))
 305         {
 306             return_ACPI_STATUS (Status);
 307         }
 308     } while (!InValue);
 309
 310     return_ACPI_STATUS (AE_OK);
 311 }
 312
 313 ACPI_EXPORT_SYMBOL (AcpiEnterSleepStateS4bios)
 314
 315 #endif /* !ACPI_REDUCED_HARDWARE */
 316
 317
 318 /*******************************************************************************
 319  *
 320  * FUNCTION:    AcpiHwSleepDispatch
 321  *
 322  * PARAMETERS:  SleepState          - Which sleep state to enter/exit
 323  *              FunctionId          - Sleep, WakePrep, or Wake
 324  *
 325  * RETURN:      Status from the invoked sleep handling function.
 326  *
 327  * DESCRIPTION: Dispatch a sleep/wake request to the appropriate handling
 328  *              function.
 329  *
 330  ******************************************************************************/
 331
 332 static ACPI_STATUS
 333 AcpiHwSleepDispatch (
 334     UINT8                   SleepState,
 335     UINT32                  FunctionId)
 336 {
 337     ACPI_STATUS             Status;
 338     ACPI_SLEEP_FUNCTIONS    *SleepFunctions = &AcpiSleepDispatch[FunctionId];
 339
 340
 341 #if (!ACPI_REDUCED_HARDWARE)
 342
 343     /*
 344      * If the Hardware Reduced flag is set (from the FADT), we must
 345      * use the extended sleep registers
 346      */
 347     if (AcpiGbl_ReducedHardware ||
 348         AcpiGbl_FADT.SleepControl.Address)
 349     {
 350         Status = SleepFunctions->ExtendedFunction (SleepState);
 351     }
 352     else
 353     {
 354         /* Legacy sleep */
 355
 356         Status = SleepFunctions->LegacyFunction (SleepState);
 357     }
 358
 359     return (Status);
 360
 361 #else
 362     /*
 363      * For the case where reduced-hardware-only code is being generated,
 364      * we know that only the extended sleep registers are available
 365      */
 366     Status = SleepFunctions->ExtendedFunction (SleepState);
 367     return (Status);
 368
 369 #endif /* !ACPI_REDUCED_HARDWARE */
 370 }
 371
 372
 373 /*******************************************************************************
 374  *
 375  * FUNCTION:    AcpiEnterSleepStatePrep
 376  *
 377  * PARAMETERS:  SleepState          - Which sleep state to enter
 378  *
 379  * RETURN:      Status
 380  *
 381  * DESCRIPTION: Prepare to enter a system sleep state.
 382  *              This function must execute with interrupts enabled.
 383  *              We break sleeping into 2 stages so that OSPM can handle
 384  *              various OS-specific tasks between the two steps.
 385  *
 386  ******************************************************************************/
 387
 388 ACPI_STATUS
 389 AcpiEnterSleepStatePrep (
 390     UINT8                   SleepState)
 391 {
 392     ACPI_STATUS             Status;
 393     ACPI_OBJECT_LIST        ArgList;
 394     ACPI_OBJECT             Arg;
 395     UINT32                  SstValue;
 396
 397
 398     ACPI_FUNCTION_TRACE (AcpiEnterSleepStatePrep);
 399
 400
 401     Status = AcpiGetSleepTypeData (SleepState,
 402                     &AcpiGbl_SleepTypeA, &AcpiGbl_SleepTypeB);
 403     if (ACPI_FAILURE (Status))
 404     {
 405         return_ACPI_STATUS (Status);
 406     }
 407
 408     /* Execute the _PTS method (Prepare To Sleep) */
 409
 410     ArgList.Count = 1;
 411     ArgList.Pointer = &Arg;
 412     Arg.Type = ACPI_TYPE_INTEGER;
 413     Arg.Integer.Value = SleepState;
 414
 415     Status = AcpiEvaluateObject (NULL, METHOD_PATHNAME__PTS, &ArgList, NULL);
 416     if (ACPI_FAILURE (Status) && Status != AE_NOT_FOUND)
 417     {
 418         return_ACPI_STATUS (Status);
 419     }
 420
 421     /* Setup the argument to the _SST method (System STatus) */
 422
 423     switch (SleepState)
 424     {
 425     case ACPI_STATE_S0:
 426         SstValue = ACPI_SST_WORKING;
 427         break;
 428
 429     case ACPI_STATE_S1:
 430     case ACPI_STATE_S2:
 431     case ACPI_STATE_S3:
 432         SstValue = ACPI_SST_SLEEPING;
 433         break;
 434
 435     case ACPI_STATE_S4:
 436         SstValue = ACPI_SST_SLEEP_CONTEXT;
 437         break;
 438
 439     default:
 440         SstValue = ACPI_SST_INDICATOR_OFF; /* Default is off */
 441         break;
 442     }
 443
 444     /*
 445      * Set the system indicators to show the desired sleep state.
 446      * _SST is an optional method (return no error if not found)
 447      */
 448     AcpiHwExecuteSleepMethod (METHOD_PATHNAME__SST, SstValue);
 449     return_ACPI_STATUS (AE_OK);
 450 }
 451
 452 ACPI_EXPORT_SYMBOL (AcpiEnterSleepStatePrep)
 453
 454
 455 /*******************************************************************************
 456  *
 457  * FUNCTION:    AcpiEnterSleepState
 458  *
 459  * PARAMETERS:  SleepState          - Which sleep state to enter
 460  *
 461  * RETURN:      Status
 462  *
 463  * DESCRIPTION: Enter a system sleep state
 464  *              THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED
 465  *
 466  ******************************************************************************/
 467
 468 ACPI_STATUS
 469 AcpiEnterSleepState (
 470     UINT8                   SleepState)
 471 {
 472     ACPI_STATUS             Status;
 473
 474
 475     ACPI_FUNCTION_TRACE (AcpiEnterSleepState);
 476
 477
 478     if ((AcpiGbl_SleepTypeA > ACPI_SLEEP_TYPE_MAX) ||
 479         (AcpiGbl_SleepTypeB > ACPI_SLEEP_TYPE_MAX))
 480     {
 481         ACPI_ERROR ((AE_INFO, "Sleep values out of range: A=0x%X B=0x%X",
 482             AcpiGbl_SleepTypeA, AcpiGbl_SleepTypeB));
 483         return_ACPI_STATUS (AE_AML_OPERAND_VALUE);
 484     }
 485
 486     Status = AcpiHwSleepDispatch (SleepState, ACPI_SLEEP_FUNCTION_ID);
 487     return_ACPI_STATUS (Status);
 488 }
 489
 490 ACPI_EXPORT_SYMBOL (AcpiEnterSleepState)
 491
 492
 493 /*******************************************************************************
 494  *
 495  * FUNCTION:    AcpiLeaveSleepStatePrep
 496  *
 497  * PARAMETERS:  SleepState          - Which sleep state we are exiting
 498  *
 499  * RETURN:      Status
 500  *
 501  * DESCRIPTION: Perform the first state of OS-independent ACPI cleanup after a
 502  *              sleep. Called with interrupts DISABLED.
 503  *              We break wake/resume into 2 stages so that OSPM can handle
 504  *              various OS-specific tasks between the two steps.
 505  *
 506  ******************************************************************************/
 507
 508 ACPI_STATUS
 509 AcpiLeaveSleepStatePrep (
 510     UINT8                   SleepState)
 511 {
 512     ACPI_STATUS             Status;
 513
 514
 515     ACPI_FUNCTION_TRACE (AcpiLeaveSleepStatePrep);
 516
 517
 518     Status = AcpiHwSleepDispatch (SleepState, ACPI_WAKE_PREP_FUNCTION_ID);
 519     return_ACPI_STATUS (Status);
 520 }
 521
 522 ACPI_EXPORT_SYMBOL (AcpiLeaveSleepStatePrep)
 523
 524
 525 /*******************************************************************************
 526  *
 527  * FUNCTION:    AcpiLeaveSleepState
 528  *
 529  * PARAMETERS:  SleepState          - Which sleep state we are exiting
 530  *
 531  * RETURN:      Status
 532  *
 533  * DESCRIPTION: Perform OS-independent ACPI cleanup after a sleep
 534  *              Called with interrupts ENABLED.
 535  *
 536  ******************************************************************************/
 537
 538 ACPI_STATUS
 539 AcpiLeaveSleepState (
 540     UINT8                   SleepState)
 541 {
 542     ACPI_STATUS             Status;
 543
 544
 545     ACPI_FUNCTION_TRACE (AcpiLeaveSleepState);
 546
 547
 548     Status = AcpiHwSleepDispatch (SleepState, ACPI_WAKE_FUNCTION_ID);
 549     return_ACPI_STATUS (Status);
 550 }
 551
 552 ACPI_EXPORT_SYMBOL (AcpiLeaveSleepState)