LXR linux/drivers/acpi/acpica/evxfevnt.c

   1// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
   2/******************************************************************************
   3 *
   4 * Module Name: evxfevnt - External Interfaces, ACPI event disable/enable
   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#include "actables.h"
  15
  16#define _COMPONENT          ACPI_EVENTS
  17ACPI_MODULE_NAME("evxfevnt")
  18
  19#if (!ACPI_REDUCED_HARDWARE)    /* Entire module */
  20/*******************************************************************************
  21 *
  22 * FUNCTION:    acpi_enable
  23 *
  24 * PARAMETERS:  None
  25 *
  26 * RETURN:      Status
  27 *
  28 * DESCRIPTION: Transfers the system into ACPI mode.
  29 *
  30 ******************************************************************************/
  31acpi_status acpi_enable(void)
  32{
  33        acpi_status status;
  34        int retry;
  35
  36        ACPI_FUNCTION_TRACE(acpi_enable);
  37
  38        /* ACPI tables must be present */
  39
  40        if (acpi_gbl_fadt_index == ACPI_INVALID_TABLE_INDEX) {
  41                return_ACPI_STATUS(AE_NO_ACPI_TABLES);
  42        }
  43
  44        /* If the Hardware Reduced flag is set, machine is always in acpi mode */
  45
  46        if (acpi_gbl_reduced_hardware) {
  47                return_ACPI_STATUS(AE_OK);
  48        }
  49
  50        /* Check current mode */
  51
  52        if (acpi_hw_get_mode() == ACPI_SYS_MODE_ACPI) {
  53                ACPI_DEBUG_PRINT((ACPI_DB_INIT,
  54                                  "System is already in ACPI mode\n"));
  55                return_ACPI_STATUS(AE_OK);
  56        }
  57
  58        /* Transition to ACPI mode */
  59
  60        status = acpi_hw_set_mode(ACPI_SYS_MODE_ACPI);
  61        if (ACPI_FAILURE(status)) {
  62                ACPI_ERROR((AE_INFO,
  63                            "Could not transition to ACPI mode"));
  64                return_ACPI_STATUS(status);
  65        }
  66
  67        /* Sanity check that transition succeeded */
  68
  69        for (retry = 0; retry < 30000; ++retry) {
  70                if (acpi_hw_get_mode() == ACPI_SYS_MODE_ACPI) {
  71                        if (retry != 0)
  72                                ACPI_WARNING((AE_INFO,
  73                                "Platform took > %d00 usec to enter ACPI mode", retry));
  74                        return_ACPI_STATUS(AE_OK);
  75                }
  76                acpi_os_stall(100);     /* 100 usec */
  77        }
  78
  79        ACPI_ERROR((AE_INFO, "Hardware did not enter ACPI mode"));
  80        return_ACPI_STATUS(AE_NO_HARDWARE_RESPONSE);
  81}
  82
  83ACPI_EXPORT_SYMBOL(acpi_enable)
  84
  85/*******************************************************************************
  86 *
  87 * FUNCTION:    acpi_disable
  88 *
  89 * PARAMETERS:  None
  90 *
  91 * RETURN:      Status
  92 *
  93 * DESCRIPTION: Transfers the system into LEGACY (non-ACPI) mode.
  94 *
  95 ******************************************************************************/
  96acpi_status acpi_disable(void)
  97{
  98        acpi_status status = AE_OK;
  99
 100        ACPI_FUNCTION_TRACE(acpi_disable);
 101
 102        /* If the Hardware Reduced flag is set, machine is always in acpi mode */
 103
 104        if (acpi_gbl_reduced_hardware) {
 105                return_ACPI_STATUS(AE_OK);
 106        }
 107
 108        if (acpi_hw_get_mode() == ACPI_SYS_MODE_LEGACY) {
 109                ACPI_DEBUG_PRINT((ACPI_DB_INIT,
 110                                  "System is already in legacy (non-ACPI) mode\n"));
 111        } else {
 112                /* Transition to LEGACY mode */
 113
 114                status = acpi_hw_set_mode(ACPI_SYS_MODE_LEGACY);
 115
 116                if (ACPI_FAILURE(status)) {
 117                        ACPI_ERROR((AE_INFO,
 118                                    "Could not exit ACPI mode to legacy mode"));
 119                        return_ACPI_STATUS(status);
 120                }
 121
 122                ACPI_DEBUG_PRINT((ACPI_DB_INIT, "ACPI mode disabled\n"));
 123        }
 124
 125        return_ACPI_STATUS(status);
 126}
 127
 128ACPI_EXPORT_SYMBOL(acpi_disable)
 129
 130/*******************************************************************************
 131 *
 132 * FUNCTION:    acpi_enable_event
 133 *
 134 * PARAMETERS:  event           - The fixed eventto be enabled
 135 *              flags           - Reserved
 136 *
 137 * RETURN:      Status
 138 *
 139 * DESCRIPTION: Enable an ACPI event (fixed)
 140 *
 141 ******************************************************************************/
 142acpi_status acpi_enable_event(u32 event, u32 flags)
 143{
 144        acpi_status status = AE_OK;
 145        u32 value;
 146
 147        ACPI_FUNCTION_TRACE(acpi_enable_event);
 148
 149        /* If Hardware Reduced flag is set, there are no fixed events */
 150
 151        if (acpi_gbl_reduced_hardware) {
 152                return_ACPI_STATUS(AE_OK);
 153        }
 154
 155        /* Decode the Fixed Event */
 156
 157        if (event > ACPI_EVENT_MAX) {
 158                return_ACPI_STATUS(AE_BAD_PARAMETER);
 159        }
 160
 161        /*
 162         * Enable the requested fixed event (by writing a one to the enable
 163         * register bit)
 164         */
 165        status =
 166            acpi_write_bit_register(acpi_gbl_fixed_event_info[event].
 167                                    enable_register_id, ACPI_ENABLE_EVENT);
 168        if (ACPI_FAILURE(status)) {
 169                return_ACPI_STATUS(status);
 170        }
 171
 172        /* Make sure that the hardware responded */
 173
 174        status =
 175            acpi_read_bit_register(acpi_gbl_fixed_event_info[event].
 176                                   enable_register_id, &value);
 177        if (ACPI_FAILURE(status)) {
 178                return_ACPI_STATUS(status);
 179        }
 180
 181        if (value != 1) {
 182                ACPI_ERROR((AE_INFO,
 183                            "Could not enable %s event",
 184                            acpi_ut_get_event_name(event)));
 185                return_ACPI_STATUS(AE_NO_HARDWARE_RESPONSE);
 186        }
 187
 188        return_ACPI_STATUS(status);
 189}
 190
 191ACPI_EXPORT_SYMBOL(acpi_enable_event)
 192
 193/*******************************************************************************
 194 *
 195 * FUNCTION:    acpi_disable_event
 196 *
 197 * PARAMETERS:  event           - The fixed event to be disabled
 198 *              flags           - Reserved
 199 *
 200 * RETURN:      Status
 201 *
 202 * DESCRIPTION: Disable an ACPI event (fixed)
 203 *
 204 ******************************************************************************/
 205acpi_status acpi_disable_event(u32 event, u32 flags)
 206{
 207        acpi_status status = AE_OK;
 208        u32 value;
 209
 210        ACPI_FUNCTION_TRACE(acpi_disable_event);
 211
 212        /* If Hardware Reduced flag is set, there are no fixed events */
 213
 214        if (acpi_gbl_reduced_hardware) {
 215                return_ACPI_STATUS(AE_OK);
 216        }
 217
 218        /* Decode the Fixed Event */
 219
 220        if (event > ACPI_EVENT_MAX) {
 221                return_ACPI_STATUS(AE_BAD_PARAMETER);
 222        }
 223
 224        /*
 225         * Disable the requested fixed event (by writing a zero to the enable
 226         * register bit)
 227         */
 228        status =
 229            acpi_write_bit_register(acpi_gbl_fixed_event_info[event].
 230                                    enable_register_id, ACPI_DISABLE_EVENT);
 231        if (ACPI_FAILURE(status)) {
 232                return_ACPI_STATUS(status);
 233        }
 234
 235        status =
 236            acpi_read_bit_register(acpi_gbl_fixed_event_info[event].
 237                                   enable_register_id, &value);
 238        if (ACPI_FAILURE(status)) {
 239                return_ACPI_STATUS(status);
 240        }
 241
 242        if (value != 0) {
 243                ACPI_ERROR((AE_INFO,
 244                            "Could not disable %s events",
 245                            acpi_ut_get_event_name(event)));
 246                return_ACPI_STATUS(AE_NO_HARDWARE_RESPONSE);
 247        }
 248
 249        return_ACPI_STATUS(status);
 250}
 251
 252ACPI_EXPORT_SYMBOL(acpi_disable_event)
 253
 254/*******************************************************************************
 255 *
 256 * FUNCTION:    acpi_clear_event
 257 *
 258 * PARAMETERS:  event           - The fixed event to be cleared
 259 *
 260 * RETURN:      Status
 261 *
 262 * DESCRIPTION: Clear an ACPI event (fixed)
 263 *
 264 ******************************************************************************/
 265acpi_status acpi_clear_event(u32 event)
 266{
 267        acpi_status status = AE_OK;
 268
 269        ACPI_FUNCTION_TRACE(acpi_clear_event);
 270
 271        /* If Hardware Reduced flag is set, there are no fixed events */
 272
 273        if (acpi_gbl_reduced_hardware) {
 274                return_ACPI_STATUS(AE_OK);
 275        }
 276
 277        /* Decode the Fixed Event */
 278
 279        if (event > ACPI_EVENT_MAX) {
 280                return_ACPI_STATUS(AE_BAD_PARAMETER);
 281        }
 282
 283        /*
 284         * Clear the requested fixed event (By writing a one to the status
 285         * register bit)
 286         */
 287        status =
 288            acpi_write_bit_register(acpi_gbl_fixed_event_info[event].
 289                                    status_register_id, ACPI_CLEAR_STATUS);
 290
 291        return_ACPI_STATUS(status);
 292}
 293
 294ACPI_EXPORT_SYMBOL(acpi_clear_event)
 295
 296/*******************************************************************************
 297 *
 298 * FUNCTION:    acpi_get_event_status
 299 *
 300 * PARAMETERS:  event           - The fixed event
 301 *              event_status    - Where the current status of the event will
 302 *                                be returned
 303 *
 304 * RETURN:      Status
 305 *
 306 * DESCRIPTION: Obtains and returns the current status of the event
 307 *
 308 ******************************************************************************/
 309acpi_status acpi_get_event_status(u32 event, acpi_event_status * event_status)
 310{
 311        acpi_status status;
 312        acpi_event_status local_event_status = 0;
 313        u32 in_byte;
 314
 315        ACPI_FUNCTION_TRACE(acpi_get_event_status);
 316
 317        if (!event_status) {
 318                return_ACPI_STATUS(AE_BAD_PARAMETER);
 319        }
 320
 321        /* Decode the Fixed Event */
 322
 323        if (event > ACPI_EVENT_MAX) {
 324                return_ACPI_STATUS(AE_BAD_PARAMETER);
 325        }
 326
 327        /* Fixed event currently can be dispatched? */
 328
 329        if (acpi_gbl_fixed_event_handlers[event].handler) {
 330                local_event_status |= ACPI_EVENT_FLAG_HAS_HANDLER;
 331        }
 332
 333        /* Fixed event currently enabled? */
 334
 335        status =
 336            acpi_read_bit_register(acpi_gbl_fixed_event_info[event].
 337                                   enable_register_id, &in_byte);
 338        if (ACPI_FAILURE(status)) {
 339                return_ACPI_STATUS(status);
 340        }
 341
 342        if (in_byte) {
 343                local_event_status |=
 344                    (ACPI_EVENT_FLAG_ENABLED | ACPI_EVENT_FLAG_ENABLE_SET);
 345        }
 346
 347        /* Fixed event currently active? */
 348
 349        status =
 350            acpi_read_bit_register(acpi_gbl_fixed_event_info[event].
 351                                   status_register_id, &in_byte);
 352        if (ACPI_FAILURE(status)) {
 353                return_ACPI_STATUS(status);
 354        }
 355
 356        if (in_byte) {
 357                local_event_status |= ACPI_EVENT_FLAG_STATUS_SET;
 358        }
 359
 360        (*event_status) = local_event_status;
 361        return_ACPI_STATUS(AE_OK);
 362}
 363
 364ACPI_EXPORT_SYMBOL(acpi_get_event_status)
 365#endif                          /* !ACPI_REDUCED_HARDWARE */
 366