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