linux/drivers/acpi/acpica/hwsleep.c
<<
>>
Prefs 
   1
   2/******************************************************************************
   3 *
   4 * Name: hwsleep.c - ACPI Hardware Sleep/Wake Interface
   5 *
   6 *****************************************************************************/
   7
   8/*
   9 * Copyright (C) 2000 - 2008, 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 "accommon.h"
  47#include "actables.h"
  48#include <linux/tboot.h>
  49
  50#define _COMPONENT          ACPI_HARDWARE
  51ACPI_MODULE_NAME("hwsleep")
  52
  53/*******************************************************************************
  54 *
  55 * FUNCTION:    acpi_set_firmware_waking_vector
  56 *
  57 * PARAMETERS:  physical_address    - 32-bit physical address of ACPI real mode
  58 *                                    entry point.
  59 *
  60 * RETURN:      Status
  61 *
  62 * DESCRIPTION: Sets the 32-bit firmware_waking_vector field of the FACS
  63 *
  64 ******************************************************************************/
  65acpi_status
  66acpi_set_firmware_waking_vector(u32 physical_address)
  67{
  68        ACPI_FUNCTION_TRACE(acpi_set_firmware_waking_vector);
  69
  70
  71        /*
  72         * According to the ACPI specification 2.0c and later, the 64-bit
  73         * waking vector should be cleared and the 32-bit waking vector should
  74         * be used, unless we want the wake-up code to be called by the BIOS in
  75         * Protected Mode.  Some systems (for example HP dv5-1004nr) are known
  76         * to fail to resume if the 64-bit vector is used.
  77         */
  78
  79        /* Set the 32-bit vector */
  80
  81        acpi_gbl_FACS->firmware_waking_vector = physical_address;
  82
  83        /* Clear the 64-bit vector if it exists */
  84
  85        if ((acpi_gbl_FACS->length > 32) && (acpi_gbl_FACS->version >= 1)) {
  86                acpi_gbl_FACS->xfirmware_waking_vector = 0;
  87        }
  88
  89        return_ACPI_STATUS(AE_OK);
  90}
  91
  92ACPI_EXPORT_SYMBOL(acpi_set_firmware_waking_vector)
  93
  94#if ACPI_MACHINE_WIDTH == 64
  95/*******************************************************************************
  96 *
  97 * FUNCTION:    acpi_set_firmware_waking_vector64
  98 *
  99 * PARAMETERS:  physical_address    - 64-bit physical address of ACPI protected
 100 *                                    mode entry point.
 101 *
 102 * RETURN:      Status
 103 *
 104 * DESCRIPTION: Sets the 64-bit X_firmware_waking_vector field of the FACS, if
 105 *              it exists in the table. This function is intended for use with
 106 *              64-bit host operating systems.
 107 *
 108 ******************************************************************************/
 109acpi_status
 110acpi_set_firmware_waking_vector64(u64 physical_address)
 111{
 112        ACPI_FUNCTION_TRACE(acpi_set_firmware_waking_vector64);
 113
 114
 115        /* Determine if the 64-bit vector actually exists */
 116
 117        if ((acpi_gbl_FACS->length <= 32) || (acpi_gbl_FACS->version < 1)) {
 118                return_ACPI_STATUS(AE_NOT_EXIST);
 119        }
 120
 121        /* Clear 32-bit vector, set the 64-bit X_ vector */
 122
 123        acpi_gbl_FACS->firmware_waking_vector = 0;
 124        acpi_gbl_FACS->xfirmware_waking_vector = physical_address;
 125
 126        return_ACPI_STATUS(AE_OK);
 127}
 128
 129ACPI_EXPORT_SYMBOL(acpi_set_firmware_waking_vector64)
 130#endif
 131
 132/*******************************************************************************
 133 *
 134 * FUNCTION:    acpi_enter_sleep_state_prep
 135 *
 136 * PARAMETERS:  sleep_state         - Which sleep state to enter
 137 *
 138 * RETURN:      Status
 139 *
 140 * DESCRIPTION: Prepare to enter a system sleep state (see ACPI 2.0 spec p 231)
 141 *              This function must execute with interrupts enabled.
 142 *              We break sleeping into 2 stages so that OSPM can handle
 143 *              various OS-specific tasks between the two steps.
 144 *
 145 ******************************************************************************/
 146acpi_status acpi_enter_sleep_state_prep(u8 sleep_state)
 147{
 148        acpi_status status;
 149        struct acpi_object_list arg_list;
 150        union acpi_object arg;
 151
 152        ACPI_FUNCTION_TRACE(acpi_enter_sleep_state_prep);
 153
 154        /* _PSW methods could be run here to enable wake-on keyboard, LAN, etc. */
 155
 156        status = acpi_get_sleep_type_data(sleep_state,
 157                                          &acpi_gbl_sleep_type_a,
 158                                          &acpi_gbl_sleep_type_b);
 159        if (ACPI_FAILURE(status)) {
 160                return_ACPI_STATUS(status);
 161        }
 162
 163        /* Setup parameter object */
 164
 165        arg_list.count = 1;
 166        arg_list.pointer = &arg;
 167
 168        arg.type = ACPI_TYPE_INTEGER;
 169        arg.integer.value = sleep_state;
 170
 171        /* Run the _PTS method */
 172
 173        status = acpi_evaluate_object(NULL, METHOD_NAME__PTS, &arg_list, NULL);
 174        if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
 175                return_ACPI_STATUS(status);
 176        }
 177
 178        /* Setup the argument to _SST */
 179
 180        switch (sleep_state) {
 181        case ACPI_STATE_S0:
 182                arg.integer.value = ACPI_SST_WORKING;
 183                break;
 184
 185        case ACPI_STATE_S1:
 186        case ACPI_STATE_S2:
 187        case ACPI_STATE_S3:
 188                arg.integer.value = ACPI_SST_SLEEPING;
 189                break;
 190
 191        case ACPI_STATE_S4:
 192                arg.integer.value = ACPI_SST_SLEEP_CONTEXT;
 193                break;
 194
 195        default:
 196                arg.integer.value = ACPI_SST_INDICATOR_OFF;     /* Default is off */
 197                break;
 198        }
 199
 200        /*
 201         * Set the system indicators to show the desired sleep state.
 202         * _SST is an optional method (return no error if not found)
 203         */
 204        status = acpi_evaluate_object(NULL, METHOD_NAME__SST, &arg_list, NULL);
 205        if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
 206                ACPI_EXCEPTION((AE_INFO, status,
 207                                "While executing method _SST"));
 208        }
 209
 210        return_ACPI_STATUS(AE_OK);
 211}
 212
 213ACPI_EXPORT_SYMBOL(acpi_enter_sleep_state_prep)
 214
 215static unsigned int gts, bfs;
 216module_param(gts, uint, 0644);
 217module_param(bfs, uint, 0644);
 218MODULE_PARM_DESC(gts, "Enable evaluation of _GTS on suspend.");
 219MODULE_PARM_DESC(bfs, "Enable evaluation of _BFS on resume".);
 220
 221/*******************************************************************************
 222 *
 223 * FUNCTION:    acpi_enter_sleep_state
 224 *
 225 * PARAMETERS:  sleep_state         - Which sleep state to enter
 226 *
 227 * RETURN:      Status
 228 *
 229 * DESCRIPTION: Enter a system sleep state (see ACPI 2.0 spec p 231)
 230 *              THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED
 231 *
 232 ******************************************************************************/
 233acpi_status asmlinkage acpi_enter_sleep_state(u8 sleep_state)
 234{
 235        u32 pm1a_control;
 236        u32 pm1b_control;
 237        struct acpi_bit_register_info *sleep_type_reg_info;
 238        struct acpi_bit_register_info *sleep_enable_reg_info;
 239        u32 in_value;
 240        struct acpi_object_list arg_list;
 241        union acpi_object arg;
 242        acpi_status status;
 243
 244        ACPI_FUNCTION_TRACE(acpi_enter_sleep_state);
 245
 246        if ((acpi_gbl_sleep_type_a > ACPI_SLEEP_TYPE_MAX) ||
 247            (acpi_gbl_sleep_type_b > ACPI_SLEEP_TYPE_MAX)) {
 248                ACPI_ERROR((AE_INFO, "Sleep values out of range: A=%X B=%X",
 249                            acpi_gbl_sleep_type_a, acpi_gbl_sleep_type_b));
 250                return_ACPI_STATUS(AE_AML_OPERAND_VALUE);
 251        }
 252
 253        sleep_type_reg_info =
 254            acpi_hw_get_bit_register_info(ACPI_BITREG_SLEEP_TYPE);
 255        sleep_enable_reg_info =
 256            acpi_hw_get_bit_register_info(ACPI_BITREG_SLEEP_ENABLE);
 257
 258        /* Clear wake status */
 259
 260        status =
 261            acpi_write_bit_register(ACPI_BITREG_WAKE_STATUS, ACPI_CLEAR_STATUS);
 262        if (ACPI_FAILURE(status)) {
 263                return_ACPI_STATUS(status);
 264        }
 265
 266        /* Clear all fixed and general purpose status bits */
 267
 268        status = acpi_hw_clear_acpi_status();
 269        if (ACPI_FAILURE(status)) {
 270                return_ACPI_STATUS(status);
 271        }
 272
 273        /*
 274         * 1) Disable/Clear all GPEs
 275         * 2) Enable all wakeup GPEs
 276         */
 277        status = acpi_hw_disable_all_gpes();
 278        if (ACPI_FAILURE(status)) {
 279                return_ACPI_STATUS(status);
 280        }
 281        acpi_gbl_system_awake_and_running = FALSE;
 282
 283        status = acpi_hw_enable_all_wakeup_gpes();
 284        if (ACPI_FAILURE(status)) {
 285                return_ACPI_STATUS(status);
 286        }
 287
 288        if (gts) {
 289                /* Execute the _GTS method */
 290
 291                arg_list.count = 1;
 292                arg_list.pointer = &arg;
 293                arg.type = ACPI_TYPE_INTEGER;
 294                arg.integer.value = sleep_state;
 295
 296                status = acpi_evaluate_object(NULL, METHOD_NAME__GTS, &arg_list, NULL);
 297                if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
 298                        return_ACPI_STATUS(status);
 299                }
 300        }
 301
 302        /* Get current value of PM1A control */
 303
 304        status = acpi_hw_register_read(ACPI_REGISTER_PM1_CONTROL,
 305                                       &pm1a_control);
 306        if (ACPI_FAILURE(status)) {
 307                return_ACPI_STATUS(status);
 308        }
 309        ACPI_DEBUG_PRINT((ACPI_DB_INIT,
 310                          "Entering sleep state [S%d]\n", sleep_state));
 311
 312        /* Clear the SLP_EN and SLP_TYP fields */
 313
 314        pm1a_control &= ~(sleep_type_reg_info->access_bit_mask |
 315                          sleep_enable_reg_info->access_bit_mask);
 316        pm1b_control = pm1a_control;
 317
 318        /* Insert the SLP_TYP bits */
 319
 320        pm1a_control |=
 321            (acpi_gbl_sleep_type_a << sleep_type_reg_info->bit_position);
 322        pm1b_control |=
 323            (acpi_gbl_sleep_type_b << sleep_type_reg_info->bit_position);
 324
 325        /*
 326         * We split the writes of SLP_TYP and SLP_EN to workaround
 327         * poorly implemented hardware.
 328         */
 329
 330        /* Write #1: write the SLP_TYP data to the PM1 Control registers */
 331
 332        status = acpi_hw_write_pm1_control(pm1a_control, pm1b_control);
 333        if (ACPI_FAILURE(status)) {
 334                return_ACPI_STATUS(status);
 335        }
 336
 337        /* Insert the sleep enable (SLP_EN) bit */
 338
 339        pm1a_control |= sleep_enable_reg_info->access_bit_mask;
 340        pm1b_control |= sleep_enable_reg_info->access_bit_mask;
 341
 342        /* Flush caches, as per ACPI specification */
 343
 344        ACPI_FLUSH_CPU_CACHE();
 345
 346        tboot_sleep(sleep_state, pm1a_control, pm1b_control);
 347
 348        /* Write #2: Write both SLP_TYP + SLP_EN */
 349
 350        status = acpi_hw_write_pm1_control(pm1a_control, pm1b_control);
 351        if (ACPI_FAILURE(status)) {
 352                return_ACPI_STATUS(status);
 353        }
 354
 355        if (sleep_state > ACPI_STATE_S3) {
 356                /*
 357                 * We wanted to sleep > S3, but it didn't happen (by virtue of the
 358                 * fact that we are still executing!)
 359                 *
 360                 * Wait ten seconds, then try again. This is to get S4/S5 to work on
 361                 * all machines.
 362                 *
 363                 * We wait so long to allow chipsets that poll this reg very slowly
 364                 * to still read the right value. Ideally, this block would go
 365                 * away entirely.
 366                 */
 367                acpi_os_stall(10000000);
 368
 369                status = acpi_hw_register_write(ACPI_REGISTER_PM1_CONTROL,
 370                                                sleep_enable_reg_info->
 371                                                access_bit_mask);
 372                if (ACPI_FAILURE(status)) {
 373                        return_ACPI_STATUS(status);
 374                }
 375        }
 376
 377        /* Wait until we enter sleep state */
 378
 379        do {
 380                status = acpi_read_bit_register(ACPI_BITREG_WAKE_STATUS,
 381                                                    &in_value);
 382                if (ACPI_FAILURE(status)) {
 383                        return_ACPI_STATUS(status);
 384                }
 385
 386                /* Spin until we wake */
 387
 388        } while (!in_value);
 389
 390        return_ACPI_STATUS(AE_OK);
 391}
 392
 393ACPI_EXPORT_SYMBOL(acpi_enter_sleep_state)
 394
 395/*******************************************************************************
 396 *
 397 * FUNCTION:    acpi_enter_sleep_state_s4bios
 398 *
 399 * PARAMETERS:  None
 400 *
 401 * RETURN:      Status
 402 *
 403 * DESCRIPTION: Perform a S4 bios request.
 404 *              THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED
 405 *
 406 ******************************************************************************/
 407acpi_status asmlinkage acpi_enter_sleep_state_s4bios(void)
 408{
 409        u32 in_value;
 410        acpi_status status;
 411
 412        ACPI_FUNCTION_TRACE(acpi_enter_sleep_state_s4bios);
 413
 414        /* Clear the wake status bit (PM1) */
 415
 416        status =
 417            acpi_write_bit_register(ACPI_BITREG_WAKE_STATUS, ACPI_CLEAR_STATUS);
 418        if (ACPI_FAILURE(status)) {
 419                return_ACPI_STATUS(status);
 420        }
 421
 422        status = acpi_hw_clear_acpi_status();
 423        if (ACPI_FAILURE(status)) {
 424                return_ACPI_STATUS(status);
 425        }
 426
 427        /*
 428         * 1) Disable/Clear all GPEs
 429         * 2) Enable all wakeup GPEs
 430         */
 431        status = acpi_hw_disable_all_gpes();
 432        if (ACPI_FAILURE(status)) {
 433                return_ACPI_STATUS(status);
 434        }
 435        acpi_gbl_system_awake_and_running = FALSE;
 436
 437        status = acpi_hw_enable_all_wakeup_gpes();
 438        if (ACPI_FAILURE(status)) {
 439                return_ACPI_STATUS(status);
 440        }
 441
 442        ACPI_FLUSH_CPU_CACHE();
 443
 444        status = acpi_hw_write_port(acpi_gbl_FADT.smi_command,
 445                                    (u32) acpi_gbl_FADT.S4bios_request, 8);
 446
 447        do {
 448                acpi_os_stall(1000);
 449                status =
 450                    acpi_read_bit_register(ACPI_BITREG_WAKE_STATUS, &in_value);
 451                if (ACPI_FAILURE(status)) {
 452                        return_ACPI_STATUS(status);
 453                }
 454        } while (!in_value);
 455
 456        return_ACPI_STATUS(AE_OK);
 457}
 458
 459ACPI_EXPORT_SYMBOL(acpi_enter_sleep_state_s4bios)
 460
 461/*******************************************************************************
 462 *
 463 * FUNCTION:    acpi_leave_sleep_state_prep
 464 *
 465 * PARAMETERS:  sleep_state         - Which sleep state we are exiting
 466 *
 467 * RETURN:      Status
 468 *
 469 * DESCRIPTION: Perform the first state of OS-independent ACPI cleanup after a
 470 *              sleep.
 471 *              Called with interrupts DISABLED.
 472 *
 473 ******************************************************************************/
 474acpi_status acpi_leave_sleep_state_prep(u8 sleep_state)
 475{
 476        struct acpi_object_list arg_list;
 477        union acpi_object arg;
 478        acpi_status status;
 479        struct acpi_bit_register_info *sleep_type_reg_info;
 480        struct acpi_bit_register_info *sleep_enable_reg_info;
 481        u32 pm1a_control;
 482        u32 pm1b_control;
 483
 484        ACPI_FUNCTION_TRACE(acpi_leave_sleep_state_prep);
 485
 486        /*
 487         * Set SLP_TYPE and SLP_EN to state S0.
 488         * This is unclear from the ACPI Spec, but it is required
 489         * by some machines.
 490         */
 491        status = acpi_get_sleep_type_data(ACPI_STATE_S0,
 492                                          &acpi_gbl_sleep_type_a,
 493                                          &acpi_gbl_sleep_type_b);
 494        if (ACPI_SUCCESS(status)) {
 495                sleep_type_reg_info =
 496                    acpi_hw_get_bit_register_info(ACPI_BITREG_SLEEP_TYPE);
 497                sleep_enable_reg_info =
 498                    acpi_hw_get_bit_register_info(ACPI_BITREG_SLEEP_ENABLE);
 499
 500                /* Get current value of PM1A control */
 501
 502                status = acpi_hw_register_read(ACPI_REGISTER_PM1_CONTROL,
 503                                               &pm1a_control);
 504                if (ACPI_SUCCESS(status)) {
 505
 506                        /* Clear the SLP_EN and SLP_TYP fields */
 507
 508                        pm1a_control &= ~(sleep_type_reg_info->access_bit_mask |
 509                                          sleep_enable_reg_info->
 510                                          access_bit_mask);
 511                        pm1b_control = pm1a_control;
 512
 513                        /* Insert the SLP_TYP bits */
 514
 515                        pm1a_control |= (acpi_gbl_sleep_type_a <<
 516                                         sleep_type_reg_info->bit_position);
 517                        pm1b_control |= (acpi_gbl_sleep_type_b <<
 518                                         sleep_type_reg_info->bit_position);
 519
 520                        /* Write the control registers and ignore any errors */
 521
 522                        (void)acpi_hw_write_pm1_control(pm1a_control,
 523                                                        pm1b_control);
 524                }
 525        }
 526
 527        if (bfs) {
 528                /* Execute the _BFS method */
 529
 530                arg_list.count = 1;
 531                arg_list.pointer = &arg;
 532                arg.type = ACPI_TYPE_INTEGER;
 533                arg.integer.value = sleep_state;
 534
 535                status = acpi_evaluate_object(NULL, METHOD_NAME__BFS, &arg_list, NULL);
 536                if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
 537                        ACPI_EXCEPTION((AE_INFO, status, "During Method _BFS"));
 538                }
 539        }
 540        return_ACPI_STATUS(status);
 541}
 542
 543/*******************************************************************************
 544 *
 545 * FUNCTION:    acpi_leave_sleep_state
 546 *
 547 * PARAMETERS:  sleep_state         - Which sleep state we just exited
 548 *
 549 * RETURN:      Status
 550 *
 551 * DESCRIPTION: Perform OS-independent ACPI cleanup after a sleep
 552 *              Called with interrupts ENABLED.
 553 *
 554 ******************************************************************************/
 555acpi_status acpi_leave_sleep_state(u8 sleep_state)
 556{
 557        struct acpi_object_list arg_list;
 558        union acpi_object arg;
 559        acpi_status status;
 560
 561        ACPI_FUNCTION_TRACE(acpi_leave_sleep_state);
 562
 563        /* Ensure enter_sleep_state_prep -> enter_sleep_state ordering */
 564
 565        acpi_gbl_sleep_type_a = ACPI_SLEEP_TYPE_INVALID;
 566
 567        /* Setup parameter object */
 568
 569        arg_list.count = 1;
 570        arg_list.pointer = &arg;
 571        arg.type = ACPI_TYPE_INTEGER;
 572
 573        /* Ignore any errors from these methods */
 574
 575        arg.integer.value = ACPI_SST_WAKING;
 576        status = acpi_evaluate_object(NULL, METHOD_NAME__SST, &arg_list, NULL);
 577        if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
 578                ACPI_EXCEPTION((AE_INFO, status, "During Method _SST"));
 579        }
 580
 581        /*
 582         * GPEs must be enabled before _WAK is called as GPEs
 583         * might get fired there
 584         *
 585         * Restore the GPEs:
 586         * 1) Disable/Clear all GPEs
 587         * 2) Enable all runtime GPEs
 588         */
 589        status = acpi_hw_disable_all_gpes();
 590        if (ACPI_FAILURE(status)) {
 591                return_ACPI_STATUS(status);
 592        }
 593        status = acpi_hw_enable_all_runtime_gpes();
 594        if (ACPI_FAILURE(status)) {
 595                return_ACPI_STATUS(status);
 596        }
 597
 598        arg.integer.value = sleep_state;
 599        status = acpi_evaluate_object(NULL, METHOD_NAME__WAK, &arg_list, NULL);
 600        if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
 601                ACPI_EXCEPTION((AE_INFO, status, "During Method _WAK"));
 602        }
 603        /* TBD: _WAK "sometimes" returns stuff - do we want to look at it? */
 604
 605        /*
 606         * Some BIOSes assume that WAK_STS will be cleared on resume and use
 607         * it to determine whether the system is rebooting or resuming. Clear
 608         * it for compatibility.
 609         */
 610        acpi_write_bit_register(ACPI_BITREG_WAKE_STATUS, 1);
 611
 612        acpi_gbl_system_awake_and_running = TRUE;
 613
 614        /* Enable power button */
 615
 616        (void)
 617            acpi_write_bit_register(acpi_gbl_fixed_event_info
 618                              [ACPI_EVENT_POWER_BUTTON].
 619                              enable_register_id, ACPI_ENABLE_EVENT);
 620
 621        (void)
 622            acpi_write_bit_register(acpi_gbl_fixed_event_info
 623                              [ACPI_EVENT_POWER_BUTTON].
 624                              status_register_id, ACPI_CLEAR_STATUS);
 625
 626        arg.integer.value = ACPI_SST_WORKING;
 627        status = acpi_evaluate_object(NULL, METHOD_NAME__SST, &arg_list, NULL);
 628        if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
 629                ACPI_EXCEPTION((AE_INFO, status, "During Method _SST"));
 630        }
 631
 632        return_ACPI_STATUS(status);
 633}
 634
 635ACPI_EXPORT_SYMBOL(acpi_leave_sleep_state)
 636
Hosted by Missing Link Electronics. The original LXR software by the LXR community, this experimental version by lxr@linux.no.