Branch data     Line data    Source code

       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 - 2020, 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
      17                 :            : ACPI_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                 :            :  ******************************************************************************/
      31                 :         30 : acpi_status acpi_enable(void)
      32                 :            : {
      33                 :         30 :         acpi_status status;
      34                 :         30 :         int retry;
      35                 :            : 
      36                 :         30 :         ACPI_FUNCTION_TRACE(acpi_enable);
      37                 :            : 
      38                 :            :         /* ACPI tables must be present */
      39                 :            : 
      40         [ +  - ]:         30 :         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         [ +  - ]:         30 :         if (acpi_gbl_reduced_hardware) {
      47                 :            :                 return_ACPI_STATUS(AE_OK);
      48                 :            :         }
      49                 :            : 
      50                 :            :         /* Check current mode */
      51                 :            : 
      52         [ +  - ]:         30 :         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                 :         30 :         status = acpi_hw_set_mode(ACPI_SYS_MODE_ACPI);
      61         [ -  + ]:         30 :         if (ACPI_FAILURE(status)) {
      62                 :          0 :                 ACPI_ERROR((AE_INFO,
      63                 :            :                             "Could not transition to ACPI mode"));
      64                 :          0 :                 return_ACPI_STATUS(status);
      65                 :            :         }
      66                 :            : 
      67                 :            :         /* Sanity check that transition succeeded */
      68                 :            : 
      69         [ +  - ]:         30 :         for (retry = 0; retry < 30000; ++retry) {
      70         [ +  - ]:         30 :                 if (acpi_hw_get_mode() == ACPI_SYS_MODE_ACPI) {
      71         [ -  + ]:         30 :                         if (retry != 0)
      72                 :          0 :                                 ACPI_WARNING((AE_INFO,
      73                 :            :                                 "Platform took > %d00 usec to enter ACPI mode", retry));
      74                 :         30 :                         return_ACPI_STATUS(AE_OK);
      75                 :            :                 }
      76                 :          0 :                 acpi_os_stall(100);     /* 100 usec */
      77                 :            :         }
      78                 :            : 
      79                 :          0 :         ACPI_ERROR((AE_INFO, "Hardware did not enter ACPI mode"));
      80                 :          0 :         return_ACPI_STATUS(AE_NO_HARDWARE_RESPONSE);
      81                 :            : }
      82                 :            : 
      83                 :            : ACPI_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                 :            :  ******************************************************************************/
      96                 :          0 : acpi_status acpi_disable(void)
      97                 :            : {
      98                 :          0 :         acpi_status status = AE_OK;
      99                 :            : 
     100                 :          0 :         ACPI_FUNCTION_TRACE(acpi_disable);
     101                 :            : 
     102                 :            :         /* If the Hardware Reduced flag is set, machine is always in acpi mode */
     103                 :            : 
     104         [ #  # ]:          0 :         if (acpi_gbl_reduced_hardware) {
     105                 :            :                 return_ACPI_STATUS(AE_OK);
     106                 :            :         }
     107                 :            : 
     108         [ #  # ]:          0 :         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                 :          0 :                 status = acpi_hw_set_mode(ACPI_SYS_MODE_LEGACY);
     115                 :            : 
     116         [ #  # ]:          0 :                 if (ACPI_FAILURE(status)) {
     117                 :          0 :                         ACPI_ERROR((AE_INFO,
     118                 :            :                                     "Could not exit ACPI mode to legacy mode"));
     119                 :          0 :                         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                 :            : 
     128                 :            : ACPI_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                 :            :  ******************************************************************************/
     142                 :         90 : acpi_status acpi_enable_event(u32 event, u32 flags)
     143                 :            : {
     144                 :         90 :         acpi_status status = AE_OK;
     145                 :         90 :         u32 value;
     146                 :            : 
     147                 :         90 :         ACPI_FUNCTION_TRACE(acpi_enable_event);
     148                 :            : 
     149                 :            :         /* If Hardware Reduced flag is set, there are no fixed events */
     150                 :            : 
     151         [ +  - ]:         90 :         if (acpi_gbl_reduced_hardware) {
     152                 :            :                 return_ACPI_STATUS(AE_OK);
     153                 :            :         }
     154                 :            : 
     155                 :            :         /* Decode the Fixed Event */
     156                 :            : 
     157         [ +  - ]:         90 :         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                 :         90 :         status =
     166                 :         90 :             acpi_write_bit_register(acpi_gbl_fixed_event_info[event].
     167                 :            :                                     enable_register_id, ACPI_ENABLE_EVENT);
     168         [ +  - ]:         90 :         if (ACPI_FAILURE(status)) {
     169                 :            :                 return_ACPI_STATUS(status);
     170                 :            :         }
     171                 :            : 
     172                 :            :         /* Make sure that the hardware responded */
     173                 :            : 
     174                 :         90 :         status =
     175                 :         90 :             acpi_read_bit_register(acpi_gbl_fixed_event_info[event].
     176                 :            :                                    enable_register_id, &value);
     177         [ +  - ]:         90 :         if (ACPI_FAILURE(status)) {
     178                 :            :                 return_ACPI_STATUS(status);
     179                 :            :         }
     180                 :            : 
     181         [ -  + ]:         90 :         if (value != 1) {
     182                 :          0 :                 ACPI_ERROR((AE_INFO,
     183                 :            :                             "Could not enable %s event",
     184                 :            :                             acpi_ut_get_event_name(event)));
     185                 :          0 :                 return_ACPI_STATUS(AE_NO_HARDWARE_RESPONSE);
     186                 :            :         }
     187                 :            : 
     188                 :            :         return_ACPI_STATUS(status);
     189                 :            : }
     190                 :            : 
     191                 :            : ACPI_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                 :            :  ******************************************************************************/
     205                 :         30 : acpi_status acpi_disable_event(u32 event, u32 flags)
     206                 :            : {
     207                 :         30 :         acpi_status status = AE_OK;
     208                 :         30 :         u32 value;
     209                 :            : 
     210                 :         30 :         ACPI_FUNCTION_TRACE(acpi_disable_event);
     211                 :            : 
     212                 :            :         /* If Hardware Reduced flag is set, there are no fixed events */
     213                 :            : 
     214         [ +  - ]:         30 :         if (acpi_gbl_reduced_hardware) {
     215                 :            :                 return_ACPI_STATUS(AE_OK);
     216                 :            :         }
     217                 :            : 
     218                 :            :         /* Decode the Fixed Event */
     219                 :            : 
     220         [ +  - ]:         30 :         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                 :         30 :         status =
     229                 :         30 :             acpi_write_bit_register(acpi_gbl_fixed_event_info[event].
     230                 :            :                                     enable_register_id, ACPI_DISABLE_EVENT);
     231         [ +  - ]:         30 :         if (ACPI_FAILURE(status)) {
     232                 :            :                 return_ACPI_STATUS(status);
     233                 :            :         }
     234                 :            : 
     235                 :         30 :         status =
     236                 :         30 :             acpi_read_bit_register(acpi_gbl_fixed_event_info[event].
     237                 :            :                                    enable_register_id, &value);
     238         [ +  - ]:         30 :         if (ACPI_FAILURE(status)) {
     239                 :            :                 return_ACPI_STATUS(status);
     240                 :            :         }
     241                 :            : 
     242         [ -  + ]:         30 :         if (value != 0) {
     243                 :          0 :                 ACPI_ERROR((AE_INFO,
     244                 :            :                             "Could not disable %s events",
     245                 :            :                             acpi_ut_get_event_name(event)));
     246                 :          0 :                 return_ACPI_STATUS(AE_NO_HARDWARE_RESPONSE);
     247                 :            :         }
     248                 :            : 
     249                 :            :         return_ACPI_STATUS(status);
     250                 :            : }
     251                 :            : 
     252                 :            : ACPI_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                 :            :  ******************************************************************************/
     265                 :        120 : acpi_status acpi_clear_event(u32 event)
     266                 :            : {
     267                 :        120 :         acpi_status status = AE_OK;
     268                 :            : 
     269                 :        120 :         ACPI_FUNCTION_TRACE(acpi_clear_event);
     270                 :            : 
     271                 :            :         /* If Hardware Reduced flag is set, there are no fixed events */
     272                 :            : 
     273         [ +  - ]:        120 :         if (acpi_gbl_reduced_hardware) {
     274                 :            :                 return_ACPI_STATUS(AE_OK);
     275                 :            :         }
     276                 :            : 
     277                 :            :         /* Decode the Fixed Event */
     278                 :            : 
     279         [ +  - ]:        120 :         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                 :        120 :         status =
     288                 :        120 :             acpi_write_bit_register(acpi_gbl_fixed_event_info[event].
     289                 :            :                                     status_register_id, ACPI_CLEAR_STATUS);
     290                 :            : 
     291                 :        120 :         return_ACPI_STATUS(status);
     292                 :            : }
     293                 :            : 
     294                 :            : ACPI_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                 :            :  ******************************************************************************/
     309                 :          0 : acpi_status acpi_get_event_status(u32 event, acpi_event_status * event_status)
     310                 :            : {
     311                 :          0 :         acpi_status status;
     312                 :          0 :         acpi_event_status local_event_status = 0;
     313                 :          0 :         u32 in_byte;
     314                 :            : 
     315                 :          0 :         ACPI_FUNCTION_TRACE(acpi_get_event_status);
     316                 :            : 
     317         [ #  # ]:          0 :         if (!event_status) {
     318                 :            :                 return_ACPI_STATUS(AE_BAD_PARAMETER);
     319                 :            :         }
     320                 :            : 
     321                 :            :         /* Decode the Fixed Event */
     322                 :            : 
     323         [ #  # ]:          0 :         if (event > ACPI_EVENT_MAX) {
     324                 :            :                 return_ACPI_STATUS(AE_BAD_PARAMETER);
     325                 :            :         }
     326                 :            : 
     327                 :            :         /* Fixed event currently can be dispatched? */
     328                 :            : 
     329         [ #  # ]:          0 :         if (acpi_gbl_fixed_event_handlers[event].handler) {
     330                 :          0 :                 local_event_status |= ACPI_EVENT_FLAG_HAS_HANDLER;
     331                 :            :         }
     332                 :            : 
     333                 :            :         /* Fixed event currently enabled? */
     334                 :            : 
     335                 :          0 :         status =
     336                 :          0 :             acpi_read_bit_register(acpi_gbl_fixed_event_info[event].
     337                 :            :                                    enable_register_id, &in_byte);
     338         [ #  # ]:          0 :         if (ACPI_FAILURE(status)) {
     339                 :            :                 return_ACPI_STATUS(status);
     340                 :            :         }
     341                 :            : 
     342         [ #  # ]:          0 :         if (in_byte) {
     343                 :          0 :                 local_event_status |=
     344                 :            :                     (ACPI_EVENT_FLAG_ENABLED | ACPI_EVENT_FLAG_ENABLE_SET);
     345                 :            :         }
     346                 :            : 
     347                 :            :         /* Fixed event currently active? */
     348                 :            : 
     349                 :          0 :         status =
     350                 :          0 :             acpi_read_bit_register(acpi_gbl_fixed_event_info[event].
     351                 :            :                                    status_register_id, &in_byte);
     352         [ #  # ]:          0 :         if (ACPI_FAILURE(status)) {
     353                 :            :                 return_ACPI_STATUS(status);
     354                 :            :         }
     355                 :            : 
     356         [ #  # ]:          0 :         if (in_byte) {
     357                 :          0 :                 local_event_status |= ACPI_EVENT_FLAG_STATUS_SET;
     358                 :            :         }
     359                 :            : 
     360                 :          0 :         (*event_status) = local_event_status;
     361                 :          0 :         return_ACPI_STATUS(AE_OK);
     362                 :            : }
     363                 :            : 
     364                 :            : ACPI_EXPORT_SYMBOL(acpi_get_event_status)
     365                 :            : #endif                          /* !ACPI_REDUCED_HARDWARE */