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
  50 ACPI_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
  65 acpi_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
 111 ACPI_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  ******************************************************************************/
 124 acpi_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
 150 ACPI_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  ******************************************************************************/
 164 acpi_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
 207 ACPI_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  ******************************************************************************/
 221 acpi_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
 262 ACPI_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  ******************************************************************************/
 275 acpi_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
 298 ACPI_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  ******************************************************************************/
 313 acpi_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
 355 ACPI_EXPORT_SYMBOL(acpi_get_event_status)
 356 #endif                          /* !ACPI_REDUCED_HARDWARE */