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

   1/******************************************************************************
   2 *
   3 * Module Name: evxfevnt - External Interfaces, ACPI event disable/enable
   4 *
   5 *****************************************************************************/
   6
   7/*
   8 * Copyright (C) 2000 - 2012, Intel Corp.
   9 * All rights reserved.
  10 *
  11 * Redistribution and use in source and binary forms, with or without
  12 * modification, are permitted provided that the following conditions
  13 * are met:
  14 * 1. Redistributions of source code must retain the above copyright
  15 *    notice, this list of conditions, and the following disclaimer,
  16 *    without modification.
  17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  18 *    substantially similar to the "NO WARRANTY" disclaimer below
  19 *    ("Disclaimer") and any redistribution must be conditioned upon
  20 *    including a substantially similar Disclaimer requirement for further
  21 *    binary redistribution.
  22 * 3. Neither the names of the above-listed copyright holders nor the names
  23 *    of any contributors may be used to endorse or promote products derived
  24 *    from this software without specific prior written permission.
  25 *
  26 * Alternatively, this software may be distributed under the terms of the
  27 * GNU General Public License ("GPL") version 2 as published by the Free
  28 * Software Foundation.
  29 *
  30 * NO WARRANTY
  31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  41 * POSSIBILITY OF SUCH DAMAGES.
  42 */
  43
  44#include <linux/export.h>
  45#include <acpi/acpi.h>
  46#include "accommon.h"
  47#include "actables.h"
  48
  49#define _COMPONENT          ACPI_EVENTS
  50ACPI_MODULE_NAME("evxfevnt")
  51
  52#if (!ACPI_REDUCED_HARDWARE)    /* Entire module */
  53/*******************************************************************************
  54 *
  55 * FUNCTION:    acpi_enable
  56 *
  57 * PARAMETERS:  None
  58 *
  59 * RETURN:      Status
  60 *
  61 * DESCRIPTION: Transfers the system into ACPI mode.
  62 *
  63 ******************************************************************************/
  64
  65acpi_status acpi_enable(void)
  66{
  67        acpi_status status;
  68        int retry;
  69
  70        ACPI_FUNCTION_TRACE(acpi_enable);
  71
  72        /* ACPI tables must be present */
  73
  74        if (!acpi_tb_tables_loaded()) {
  75                return_ACPI_STATUS(AE_NO_ACPI_TABLES);
  76        }
  77
  78        /* Check current mode */
  79
  80        if (acpi_hw_get_mode() == ACPI_SYS_MODE_ACPI) {
  81                ACPI_DEBUG_PRINT((ACPI_DB_INIT,
  82                                  "System is already in ACPI mode\n"));
  83                return_ACPI_STATUS(AE_OK);
  84        }
  85
  86        /* Transition to ACPI mode */
  87
  88        status = acpi_hw_set_mode(ACPI_SYS_MODE_ACPI);
  89        if (ACPI_FAILURE(status)) {
  90                ACPI_ERROR((AE_INFO,
  91                            "Could not transition to ACPI mode"));
  92                return_ACPI_STATUS(status);
  93        }
  94
  95        /* Sanity check that transition succeeded */
  96
  97        for (retry = 0; retry < 30000; ++retry) {
  98                if (acpi_hw_get_mode() == ACPI_SYS_MODE_ACPI) {
  99                        if (retry != 0)
 100                                ACPI_WARNING((AE_INFO,
 101                                "Platform took > %d00 usec to enter ACPI mode", retry));
 102                        return_ACPI_STATUS(AE_OK);
 103                }
 104                acpi_os_stall(100);     /* 100 usec */
 105        }
 106
 107        ACPI_ERROR((AE_INFO, "Hardware did not enter ACPI mode"));
 108        return_ACPI_STATUS(AE_NO_HARDWARE_RESPONSE);
 109}
 110
 111ACPI_EXPORT_SYMBOL(acpi_enable)
 112
 113/*******************************************************************************
 114 *
 115 * FUNCTION:    acpi_disable
 116 *
 117 * PARAMETERS:  None
 118 *
 119 * RETURN:      Status
 120 *
 121 * DESCRIPTION: Transfers the system into LEGACY (non-ACPI) mode.
 122 *
 123 ******************************************************************************/
 124acpi_status acpi_disable(void)
 125{
 126        acpi_status status = AE_OK;
 127
 128        ACPI_FUNCTION_TRACE(acpi_disable);
 129
 130        if (acpi_hw_get_mode() == ACPI_SYS_MODE_LEGACY) {
 131                ACPI_DEBUG_PRINT((ACPI_DB_INIT,
 132                                  "System is already in legacy (non-ACPI) mode\n"));
 133        } else {
 134                /* Transition to LEGACY mode */
 135
 136                status = acpi_hw_set_mode(ACPI_SYS_MODE_LEGACY);
 137
 138                if (ACPI_FAILURE(status)) {
 139                        ACPI_ERROR((AE_INFO,
 140                                    "Could not exit ACPI mode to legacy mode"));
 141                        return_ACPI_STATUS(status);
 142                }
 143
 144                ACPI_DEBUG_PRINT((ACPI_DB_INIT, "ACPI mode disabled\n"));
 145        }
 146
 147        return_ACPI_STATUS(status);
 148}
 149
 150ACPI_EXPORT_SYMBOL(acpi_disable)
 151
 152/*******************************************************************************
 153 *
 154 * FUNCTION:    acpi_enable_event
 155 *
 156 * PARAMETERS:  Event           - The fixed eventto be enabled
 157 *              Flags           - Reserved
 158 *
 159 * RETURN:      Status
 160 *
 161 * DESCRIPTION: Enable an ACPI event (fixed)
 162 *
 163 ******************************************************************************/
 164acpi_status acpi_enable_event(u32 event, u32 flags)
 165{
 166        acpi_status status = AE_OK;
 167        u32 value;
 168
 169        ACPI_FUNCTION_TRACE(acpi_enable_event);
 170
 171        /* Decode the Fixed Event */
 172
 173        if (event > ACPI_EVENT_MAX) {
 174                return_ACPI_STATUS(AE_BAD_PARAMETER);
 175        }
 176
 177        /*
 178         * Enable the requested fixed event (by writing a one to the enable
 179         * register bit)
 180         */
 181        status =
 182            acpi_write_bit_register(acpi_gbl_fixed_event_info[event].
 183                                    enable_register_id, ACPI_ENABLE_EVENT);
 184        if (ACPI_FAILURE(status)) {
 185                return_ACPI_STATUS(status);
 186        }
 187
 188        /* Make sure that the hardware responded */
 189
 190        status =
 191            acpi_read_bit_register(acpi_gbl_fixed_event_info[event].
 192                                   enable_register_id, &value);
 193        if (ACPI_FAILURE(status)) {
 194                return_ACPI_STATUS(status);
 195        }
 196
 197        if (value != 1) {
 198                ACPI_ERROR((AE_INFO,
 199                            "Could not enable %s event",
 200                            acpi_ut_get_event_name(event)));
 201                return_ACPI_STATUS(AE_NO_HARDWARE_RESPONSE);
 202        }
 203
 204        return_ACPI_STATUS(status);
 205}
 206
 207ACPI_EXPORT_SYMBOL(acpi_enable_event)
 208
 209/*******************************************************************************
 210 *
 211 * FUNCTION:    acpi_disable_event
 212 *
 213 * PARAMETERS:  Event           - The fixed eventto be enabled
 214 *              Flags           - Reserved
 215 *
 216 * RETURN:      Status
 217 *
 218 * DESCRIPTION: Disable an ACPI event (fixed)
 219 *
 220 ******************************************************************************/
 221acpi_status acpi_disable_event(u32 event, u32 flags)
 222{
 223        acpi_status status = AE_OK;
 224        u32 value;
 225
 226        ACPI_FUNCTION_TRACE(acpi_disable_event);
 227
 228        /* Decode the Fixed Event */
 229
 230        if (event > ACPI_EVENT_MAX) {
 231                return_ACPI_STATUS(AE_BAD_PARAMETER);
 232        }
 233
 234        /*
 235         * Disable the requested fixed event (by writing a zero to the enable
 236         * register bit)
 237         */
 238        status =
 239            acpi_write_bit_register(acpi_gbl_fixed_event_info[event].
 240                                    enable_register_id, ACPI_DISABLE_EVENT);
 241        if (ACPI_FAILURE(status)) {
 242                return_ACPI_STATUS(status);
 243        }
 244
 245        status =
 246            acpi_read_bit_register(acpi_gbl_fixed_event_info[event].
 247                                   enable_register_id, &value);
 248        if (ACPI_FAILURE(status)) {
 249                return_ACPI_STATUS(status);
 250        }
 251
 252        if (value != 0) {
 253                ACPI_ERROR((AE_INFO,
 254                            "Could not disable %s events",
 255                            acpi_ut_get_event_name(event)));
 256                return_ACPI_STATUS(AE_NO_HARDWARE_RESPONSE);
 257        }
 258
 259        return_ACPI_STATUS(status);
 260}
 261
 262ACPI_EXPORT_SYMBOL(acpi_disable_event)
 263
 264/*******************************************************************************
 265 *
 266 * FUNCTION:    acpi_clear_event
 267 *
 268 * PARAMETERS:  Event           - The fixed event to be cleared
 269 *
 270 * RETURN:      Status
 271 *
 272 * DESCRIPTION: Clear an ACPI event (fixed)
 273 *
 274 ******************************************************************************/
 275acpi_status acpi_clear_event(u32 event)
 276{
 277        acpi_status status = AE_OK;
 278
 279        ACPI_FUNCTION_TRACE(acpi_clear_event);
 280
 281        /* Decode the Fixed Event */
 282
 283        if (event > ACPI_EVENT_MAX) {
 284                return_ACPI_STATUS(AE_BAD_PARAMETER);
 285        }
 286
 287        /*
 288         * Clear the requested fixed event (By writing a one to the status
 289         * register bit)
 290         */
 291        status =
 292            acpi_write_bit_register(acpi_gbl_fixed_event_info[event].
 293                                    status_register_id, ACPI_CLEAR_STATUS);
 294
 295        return_ACPI_STATUS(status);
 296}
 297
 298ACPI_EXPORT_SYMBOL(acpi_clear_event)
 299
 300/*******************************************************************************
 301 *
 302 * FUNCTION:    acpi_get_event_status
 303 *
 304 * PARAMETERS:  Event           - The fixed event
 305 *              event_status    - Where the current status of the event will
 306 *                                be returned
 307 *
 308 * RETURN:      Status
 309 *
 310 * DESCRIPTION: Obtains and returns the current status of the event
 311 *
 312 ******************************************************************************/
 313acpi_status acpi_get_event_status(u32 event, acpi_event_status * event_status)
 314{
 315        acpi_status status = AE_OK;
 316        u32 value;
 317
 318        ACPI_FUNCTION_TRACE(acpi_get_event_status);
 319
 320        if (!event_status) {
 321                return_ACPI_STATUS(AE_BAD_PARAMETER);
 322        }
 323
 324        /* Decode the Fixed Event */
 325
 326        if (event > ACPI_EVENT_MAX) {
 327                return_ACPI_STATUS(AE_BAD_PARAMETER);
 328        }
 329
 330        /* Get the status of the requested fixed event */
 331
 332        status =
 333            acpi_read_bit_register(acpi_gbl_fixed_event_info[event].
 334                              enable_register_id, &value);
 335        if (ACPI_FAILURE(status))
 336                return_ACPI_STATUS(status);
 337
 338        *event_status = value;
 339
 340        status =
 341            acpi_read_bit_register(acpi_gbl_fixed_event_info[event].
 342                              status_register_id, &value);
 343        if (ACPI_FAILURE(status))
 344                return_ACPI_STATUS(status);
 345
 346        if (value)
 347                *event_status |= ACPI_EVENT_FLAG_SET;
 348
 349        if (acpi_gbl_fixed_event_handlers[event].handler)
 350                *event_status |= ACPI_EVENT_FLAG_HANDLE;
 351
 352        return_ACPI_STATUS(status);
 353}
 354
 355ACPI_EXPORT_SYMBOL(acpi_get_event_status)
 356#endif                          /* !ACPI_REDUCED_HARDWARE */
 357