LCOV - code coverage report
Current view: top level - drivers/acpi/acpica - evgpe.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 96 228 42.1 %
Date: 2022-03-28 13:20:08 Functions: 6 13 46.2 %
Branches: 23 102 22.5 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
       2                 :            : /******************************************************************************
       3                 :            :  *
       4                 :            :  * Module Name: evgpe - General Purpose Event handling and dispatch
       5                 :            :  *
       6                 :            :  * Copyright (C) 2000 - 2020, Intel Corp.
       7                 :            :  *
       8                 :            :  *****************************************************************************/
       9                 :            : 
      10                 :            : #include <acpi/acpi.h>
      11                 :            : #include "accommon.h"
      12                 :            : #include "acevents.h"
      13                 :            : #include "acnamesp.h"
      14                 :            : 
      15                 :            : #define _COMPONENT          ACPI_EVENTS
      16                 :            : ACPI_MODULE_NAME("evgpe")
      17                 :            : #if (!ACPI_REDUCED_HARDWARE)    /* Entire module */
      18                 :            : /* Local prototypes */
      19                 :            : static void ACPI_SYSTEM_XFACE acpi_ev_asynch_execute_gpe_method(void *context);
      20                 :            : 
      21                 :            : static void ACPI_SYSTEM_XFACE acpi_ev_asynch_enable_gpe(void *context);
      22                 :            : 
      23                 :            : /*******************************************************************************
      24                 :            :  *
      25                 :            :  * FUNCTION:    acpi_ev_update_gpe_enable_mask
      26                 :            :  *
      27                 :            :  * PARAMETERS:  gpe_event_info          - GPE to update
      28                 :            :  *
      29                 :            :  * RETURN:      Status
      30                 :            :  *
      31                 :            :  * DESCRIPTION: Updates GPE register enable mask based upon whether there are
      32                 :            :  *              runtime references to this GPE
      33                 :            :  *
      34                 :            :  ******************************************************************************/
      35                 :            : 
      36                 :            : acpi_status
      37                 :         60 : acpi_ev_update_gpe_enable_mask(struct acpi_gpe_event_info *gpe_event_info)
      38                 :            : {
      39                 :         60 :         struct acpi_gpe_register_info *gpe_register_info;
      40                 :         60 :         u32 register_bit;
      41                 :            : 
      42                 :         60 :         ACPI_FUNCTION_TRACE(ev_update_gpe_enable_mask);
      43                 :            : 
      44                 :         60 :         gpe_register_info = gpe_event_info->register_info;
      45         [ +  - ]:         60 :         if (!gpe_register_info) {
      46                 :            :                 return_ACPI_STATUS(AE_NOT_EXIST);
      47                 :            :         }
      48                 :            : 
      49                 :         60 :         register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info);
      50                 :            : 
      51                 :            :         /* Clear the run bit up front */
      52                 :            : 
      53                 :         60 :         ACPI_CLEAR_BIT(gpe_register_info->enable_for_run, register_bit);
      54                 :            : 
      55                 :            :         /* Set the mask bit only if there are references to this GPE */
      56                 :            : 
      57         [ +  - ]:         60 :         if (gpe_event_info->runtime_count) {
      58                 :         60 :                 ACPI_SET_BIT(gpe_register_info->enable_for_run,
      59                 :            :                              (u8)register_bit);
      60                 :            :         }
      61                 :            : 
      62                 :         60 :         gpe_register_info->enable_mask = gpe_register_info->enable_for_run;
      63                 :         60 :         return_ACPI_STATUS(AE_OK);
      64                 :            : }
      65                 :            : 
      66                 :            : /*******************************************************************************
      67                 :            :  *
      68                 :            :  * FUNCTION:    acpi_ev_enable_gpe
      69                 :            :  *
      70                 :            :  * PARAMETERS:  gpe_event_info          - GPE to enable
      71                 :            :  *
      72                 :            :  * RETURN:      Status
      73                 :            :  *
      74                 :            :  * DESCRIPTION: Enable a GPE.
      75                 :            :  *
      76                 :            :  ******************************************************************************/
      77                 :            : 
      78                 :         60 : acpi_status acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info)
      79                 :            : {
      80                 :         60 :         acpi_status status;
      81                 :            : 
      82                 :         60 :         ACPI_FUNCTION_TRACE(ev_enable_gpe);
      83                 :            : 
      84                 :            :         /* Enable the requested GPE */
      85                 :            : 
      86                 :         60 :         status = acpi_hw_low_set_gpe(gpe_event_info, ACPI_GPE_ENABLE);
      87                 :         60 :         return_ACPI_STATUS(status);
      88                 :            : }
      89                 :            : 
      90                 :            : /*******************************************************************************
      91                 :            :  *
      92                 :            :  * FUNCTION:    acpi_ev_mask_gpe
      93                 :            :  *
      94                 :            :  * PARAMETERS:  gpe_event_info          - GPE to be blocked/unblocked
      95                 :            :  *              is_masked               - Whether the GPE is masked or not
      96                 :            :  *
      97                 :            :  * RETURN:      Status
      98                 :            :  *
      99                 :            :  * DESCRIPTION: Unconditionally mask/unmask a GPE during runtime.
     100                 :            :  *
     101                 :            :  ******************************************************************************/
     102                 :            : 
     103                 :            : acpi_status
     104                 :          0 : acpi_ev_mask_gpe(struct acpi_gpe_event_info *gpe_event_info, u8 is_masked)
     105                 :            : {
     106                 :          0 :         struct acpi_gpe_register_info *gpe_register_info;
     107                 :          0 :         u32 register_bit;
     108                 :            : 
     109                 :          0 :         ACPI_FUNCTION_TRACE(ev_mask_gpe);
     110                 :            : 
     111                 :          0 :         gpe_register_info = gpe_event_info->register_info;
     112         [ #  # ]:          0 :         if (!gpe_register_info) {
     113                 :            :                 return_ACPI_STATUS(AE_NOT_EXIST);
     114                 :            :         }
     115                 :            : 
     116                 :          0 :         register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info);
     117                 :            : 
     118                 :            :         /* Perform the action */
     119                 :            : 
     120         [ #  # ]:          0 :         if (is_masked) {
     121         [ #  # ]:          0 :                 if (register_bit & gpe_register_info->mask_for_run) {
     122                 :            :                         return_ACPI_STATUS(AE_BAD_PARAMETER);
     123                 :            :                 }
     124                 :            : 
     125                 :          0 :                 (void)acpi_hw_low_set_gpe(gpe_event_info, ACPI_GPE_DISABLE);
     126                 :          0 :                 ACPI_SET_BIT(gpe_register_info->mask_for_run, (u8)register_bit);
     127                 :            :         } else {
     128         [ #  # ]:          0 :                 if (!(register_bit & gpe_register_info->mask_for_run)) {
     129                 :            :                         return_ACPI_STATUS(AE_BAD_PARAMETER);
     130                 :            :                 }
     131                 :            : 
     132                 :          0 :                 ACPI_CLEAR_BIT(gpe_register_info->mask_for_run,
     133                 :            :                                (u8)register_bit);
     134         [ #  # ]:          0 :                 if (gpe_event_info->runtime_count
     135         [ #  # ]:          0 :                     && !gpe_event_info->disable_for_dispatch) {
     136                 :          0 :                         (void)acpi_hw_low_set_gpe(gpe_event_info,
     137                 :            :                                                   ACPI_GPE_ENABLE);
     138                 :            :                 }
     139                 :            :         }
     140                 :            : 
     141                 :            :         return_ACPI_STATUS(AE_OK);
     142                 :            : }
     143                 :            : 
     144                 :            : /*******************************************************************************
     145                 :            :  *
     146                 :            :  * FUNCTION:    acpi_ev_add_gpe_reference
     147                 :            :  *
     148                 :            :  * PARAMETERS:  gpe_event_info          - Add a reference to this GPE
     149                 :            :  *              clear_on_enable         - Clear GPE status before enabling it
     150                 :            :  *
     151                 :            :  * RETURN:      Status
     152                 :            :  *
     153                 :            :  * DESCRIPTION: Add a reference to a GPE. On the first reference, the GPE is
     154                 :            :  *              hardware-enabled.
     155                 :            :  *
     156                 :            :  ******************************************************************************/
     157                 :            : 
     158                 :            : acpi_status
     159                 :         60 : acpi_ev_add_gpe_reference(struct acpi_gpe_event_info *gpe_event_info,
     160                 :            :                           u8 clear_on_enable)
     161                 :            : {
     162                 :         60 :         acpi_status status = AE_OK;
     163                 :            : 
     164                 :         60 :         ACPI_FUNCTION_TRACE(ev_add_gpe_reference);
     165                 :            : 
     166         [ +  - ]:         60 :         if (gpe_event_info->runtime_count == ACPI_UINT8_MAX) {
     167                 :            :                 return_ACPI_STATUS(AE_LIMIT);
     168                 :            :         }
     169                 :            : 
     170                 :         60 :         gpe_event_info->runtime_count++;
     171         [ +  - ]:         60 :         if (gpe_event_info->runtime_count == 1) {
     172                 :            : 
     173                 :            :                 /* Enable on first reference */
     174                 :            : 
     175         [ -  + ]:         60 :                 if (clear_on_enable) {
     176                 :          0 :                         (void)acpi_hw_clear_gpe(gpe_event_info);
     177                 :            :                 }
     178                 :            : 
     179                 :         60 :                 status = acpi_ev_update_gpe_enable_mask(gpe_event_info);
     180         [ +  - ]:         60 :                 if (ACPI_SUCCESS(status)) {
     181                 :         60 :                         status = acpi_ev_enable_gpe(gpe_event_info);
     182                 :            :                 }
     183                 :            : 
     184         [ -  + ]:         60 :                 if (ACPI_FAILURE(status)) {
     185                 :          0 :                         gpe_event_info->runtime_count--;
     186                 :            :                 }
     187                 :            :         }
     188                 :            : 
     189                 :            :         return_ACPI_STATUS(status);
     190                 :            : }
     191                 :            : 
     192                 :            : /*******************************************************************************
     193                 :            :  *
     194                 :            :  * FUNCTION:    acpi_ev_remove_gpe_reference
     195                 :            :  *
     196                 :            :  * PARAMETERS:  gpe_event_info          - Remove a reference to this GPE
     197                 :            :  *
     198                 :            :  * RETURN:      Status
     199                 :            :  *
     200                 :            :  * DESCRIPTION: Remove a reference to a GPE. When the last reference is
     201                 :            :  *              removed, the GPE is hardware-disabled.
     202                 :            :  *
     203                 :            :  ******************************************************************************/
     204                 :            : 
     205                 :            : acpi_status
     206                 :          0 : acpi_ev_remove_gpe_reference(struct acpi_gpe_event_info *gpe_event_info)
     207                 :            : {
     208                 :          0 :         acpi_status status = AE_OK;
     209                 :            : 
     210                 :          0 :         ACPI_FUNCTION_TRACE(ev_remove_gpe_reference);
     211                 :            : 
     212         [ #  # ]:          0 :         if (!gpe_event_info->runtime_count) {
     213                 :            :                 return_ACPI_STATUS(AE_LIMIT);
     214                 :            :         }
     215                 :            : 
     216                 :          0 :         gpe_event_info->runtime_count--;
     217         [ #  # ]:          0 :         if (!gpe_event_info->runtime_count) {
     218                 :            : 
     219                 :            :                 /* Disable on last reference */
     220                 :            : 
     221                 :          0 :                 status = acpi_ev_update_gpe_enable_mask(gpe_event_info);
     222         [ #  # ]:          0 :                 if (ACPI_SUCCESS(status)) {
     223                 :          0 :                         status =
     224                 :          0 :                             acpi_hw_low_set_gpe(gpe_event_info,
     225                 :            :                                                 ACPI_GPE_DISABLE);
     226                 :            :                 }
     227                 :            : 
     228         [ #  # ]:          0 :                 if (ACPI_FAILURE(status)) {
     229                 :          0 :                         gpe_event_info->runtime_count++;
     230                 :            :                 }
     231                 :            :         }
     232                 :            : 
     233                 :            :         return_ACPI_STATUS(status);
     234                 :            : }
     235                 :            : 
     236                 :            : /*******************************************************************************
     237                 :            :  *
     238                 :            :  * FUNCTION:    acpi_ev_low_get_gpe_info
     239                 :            :  *
     240                 :            :  * PARAMETERS:  gpe_number          - Raw GPE number
     241                 :            :  *              gpe_block           - A GPE info block
     242                 :            :  *
     243                 :            :  * RETURN:      A GPE event_info struct. NULL if not a valid GPE (The gpe_number
     244                 :            :  *              is not within the specified GPE block)
     245                 :            :  *
     246                 :            :  * DESCRIPTION: Returns the event_info struct associated with this GPE. This is
     247                 :            :  *              the low-level implementation of ev_get_gpe_event_info.
     248                 :            :  *
     249                 :            :  ******************************************************************************/
     250                 :            : 
     251                 :         60 : struct acpi_gpe_event_info *acpi_ev_low_get_gpe_info(u32 gpe_number,
     252                 :            :                                                      struct acpi_gpe_block_info
     253                 :            :                                                      *gpe_block)
     254                 :            : {
     255                 :         60 :         u32 gpe_index;
     256                 :            : 
     257                 :            :         /*
     258                 :            :          * Validate that the gpe_number is within the specified gpe_block.
     259                 :            :          * (Two steps)
     260                 :            :          */
     261   [ +  -  +  - ]:         60 :         if (!gpe_block || (gpe_number < gpe_block->block_base_number)) {
     262                 :            :                 return (NULL);
     263                 :            :         }
     264                 :            : 
     265                 :         60 :         gpe_index = gpe_number - gpe_block->block_base_number;
     266         [ +  - ]:         60 :         if (gpe_index >= gpe_block->gpe_count) {
     267                 :            :                 return (NULL);
     268                 :            :         }
     269                 :            : 
     270                 :         60 :         return (&gpe_block->event_info[gpe_index]);
     271                 :            : }
     272                 :            : 
     273                 :            : 
     274                 :            : /*******************************************************************************
     275                 :            :  *
     276                 :            :  * FUNCTION:    acpi_ev_get_gpe_event_info
     277                 :            :  *
     278                 :            :  * PARAMETERS:  gpe_device          - Device node. NULL for GPE0/GPE1
     279                 :            :  *              gpe_number          - Raw GPE number
     280                 :            :  *
     281                 :            :  * RETURN:      A GPE event_info struct. NULL if not a valid GPE
     282                 :            :  *
     283                 :            :  * DESCRIPTION: Returns the event_info struct associated with this GPE.
     284                 :            :  *              Validates the gpe_block and the gpe_number
     285                 :            :  *
     286                 :            :  *              Should be called only when the GPE lists are semaphore locked
     287                 :            :  *              and not subject to change.
     288                 :            :  *
     289                 :            :  ******************************************************************************/
     290                 :            : 
     291                 :          0 : struct acpi_gpe_event_info *acpi_ev_get_gpe_event_info(acpi_handle gpe_device,
     292                 :            :                                                        u32 gpe_number)
     293                 :            : {
     294                 :          0 :         union acpi_operand_object *obj_desc;
     295                 :          0 :         struct acpi_gpe_event_info *gpe_info;
     296                 :          0 :         u32 i;
     297                 :            : 
     298                 :          0 :         ACPI_FUNCTION_ENTRY();
     299                 :            : 
     300                 :            :         /* A NULL gpe_device means use the FADT-defined GPE block(s) */
     301                 :            : 
     302         [ #  # ]:          0 :         if (!gpe_device) {
     303                 :            : 
     304                 :            :                 /* Examine GPE Block 0 and 1 (These blocks are permanent) */
     305                 :            : 
     306         [ #  # ]:          0 :                 for (i = 0; i < ACPI_MAX_GPE_BLOCKS; i++) {
     307                 :          0 :                         gpe_info = acpi_ev_low_get_gpe_info(gpe_number,
     308                 :            :                                                             acpi_gbl_gpe_fadt_blocks
     309                 :            :                                                             [i]);
     310         [ #  # ]:          0 :                         if (gpe_info) {
     311                 :          0 :                                 return (gpe_info);
     312                 :            :                         }
     313                 :            :                 }
     314                 :            : 
     315                 :            :                 /* The gpe_number was not in the range of either FADT GPE block */
     316                 :            : 
     317                 :            :                 return (NULL);
     318                 :            :         }
     319                 :            : 
     320                 :            :         /* A Non-NULL gpe_device means this is a GPE Block Device */
     321                 :            : 
     322                 :          0 :         obj_desc =
     323                 :          0 :             acpi_ns_get_attached_object((struct acpi_namespace_node *)
     324                 :            :                                                gpe_device);
     325   [ #  #  #  # ]:          0 :         if (!obj_desc || !obj_desc->device.gpe_block) {
     326                 :            :                 return (NULL);
     327                 :            :         }
     328                 :            : 
     329                 :          0 :         return (acpi_ev_low_get_gpe_info
     330                 :            :                 (gpe_number, obj_desc->device.gpe_block));
     331                 :            : }
     332                 :            : 
     333                 :            : /*******************************************************************************
     334                 :            :  *
     335                 :            :  * FUNCTION:    acpi_ev_gpe_detect
     336                 :            :  *
     337                 :            :  * PARAMETERS:  gpe_xrupt_list      - Interrupt block for this interrupt.
     338                 :            :  *                                    Can have multiple GPE blocks attached.
     339                 :            :  *
     340                 :            :  * RETURN:      INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED
     341                 :            :  *
     342                 :            :  * DESCRIPTION: Detect if any GP events have occurred. This function is
     343                 :            :  *              executed at interrupt level.
     344                 :            :  *
     345                 :            :  ******************************************************************************/
     346                 :            : 
     347                 :         30 : u32 acpi_ev_gpe_detect(struct acpi_gpe_xrupt_info *gpe_xrupt_list)
     348                 :            : {
     349                 :         30 :         struct acpi_gpe_block_info *gpe_block;
     350                 :         30 :         struct acpi_namespace_node *gpe_device;
     351                 :         30 :         struct acpi_gpe_register_info *gpe_register_info;
     352                 :         30 :         struct acpi_gpe_event_info *gpe_event_info;
     353                 :         30 :         u32 gpe_number;
     354                 :         30 :         u32 int_status = ACPI_INTERRUPT_NOT_HANDLED;
     355                 :         30 :         acpi_cpu_flags flags;
     356                 :         30 :         u32 i;
     357                 :         30 :         u32 j;
     358                 :            : 
     359                 :         30 :         ACPI_FUNCTION_NAME(ev_gpe_detect);
     360                 :            : 
     361                 :            :         /* Check for the case where there are no GPEs */
     362                 :            : 
     363         [ +  - ]:         30 :         if (!gpe_xrupt_list) {
     364                 :            :                 return (int_status);
     365                 :            :         }
     366                 :            : 
     367                 :            :         /*
     368                 :            :          * We need to obtain the GPE lock for both the data structs and registers
     369                 :            :          * Note: Not necessary to obtain the hardware lock, since the GPE
     370                 :            :          * registers are owned by the gpe_lock.
     371                 :            :          */
     372                 :         30 :         flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
     373                 :            : 
     374                 :            :         /* Examine all GPE blocks attached to this interrupt level */
     375                 :            : 
     376                 :         30 :         gpe_block = gpe_xrupt_list->gpe_block_list_head;
     377         [ +  + ]:         60 :         while (gpe_block) {
     378                 :         30 :                 gpe_device = gpe_block->node;
     379                 :            : 
     380                 :            :                 /*
     381                 :            :                  * Read all of the 8-bit GPE status and enable registers in this GPE
     382                 :            :                  * block, saving all of them. Find all currently active GP events.
     383                 :            :                  */
     384         [ +  + ]:         90 :                 for (i = 0; i < gpe_block->register_count; i++) {
     385                 :            : 
     386                 :            :                         /* Get the next status/enable pair */
     387                 :            : 
     388                 :         60 :                         gpe_register_info = &gpe_block->register_info[i];
     389                 :            : 
     390                 :            :                         /*
     391                 :            :                          * Optimization: If there are no GPEs enabled within this
     392                 :            :                          * register, we can safely ignore the entire register.
     393                 :            :                          */
     394                 :         60 :                         if (!(gpe_register_info->enable_for_run |
     395         [ +  + ]:         60 :                               gpe_register_info->enable_for_wake)) {
     396                 :            :                                 ACPI_DEBUG_PRINT((ACPI_DB_INTERRUPTS,
     397                 :            :                                                   "Ignore disabled registers for GPE %02X-%02X: "
     398                 :            :                                                   "RunEnable=%02X, WakeEnable=%02X\n",
     399                 :            :                                                   gpe_register_info->
     400                 :            :                                                   base_gpe_number,
     401                 :            :                                                   gpe_register_info->
     402                 :            :                                                   base_gpe_number +
     403                 :            :                                                   (ACPI_GPE_REGISTER_WIDTH - 1),
     404                 :            :                                                   gpe_register_info->
     405                 :            :                                                   enable_for_run,
     406                 :            :                                                   gpe_register_info->
     407                 :         30 :                                                   enable_for_wake));
     408                 :         30 :                                 continue;
     409                 :            :                         }
     410                 :            : 
     411                 :            :                         /* Now look at the individual GPEs in this byte register */
     412                 :            : 
     413         [ +  + ]:        270 :                         for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++) {
     414                 :            : 
     415                 :            :                                 /* Detect and dispatch one GPE bit */
     416                 :            : 
     417                 :        240 :                                 gpe_event_info =
     418                 :        240 :                                     &gpe_block->
     419                 :        240 :                                     event_info[((acpi_size)i *
     420                 :        240 :                                                 ACPI_GPE_REGISTER_WIDTH) + j];
     421                 :        240 :                                 gpe_number =
     422                 :        240 :                                     j + gpe_register_info->base_gpe_number;
     423                 :        240 :                                 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
     424                 :        480 :                                 int_status |=
     425                 :        240 :                                     acpi_ev_detect_gpe(gpe_device,
     426                 :            :                                                        gpe_event_info,
     427                 :            :                                                        gpe_number);
     428                 :        240 :                                 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
     429                 :            :                         }
     430                 :            :                 }
     431                 :            : 
     432                 :         30 :                 gpe_block = gpe_block->next;
     433                 :            :         }
     434                 :            : 
     435                 :         30 :         acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
     436                 :         30 :         return (int_status);
     437                 :            : }
     438                 :            : 
     439                 :            : /*******************************************************************************
     440                 :            :  *
     441                 :            :  * FUNCTION:    acpi_ev_asynch_execute_gpe_method
     442                 :            :  *
     443                 :            :  * PARAMETERS:  Context (gpe_event_info) - Info for this GPE
     444                 :            :  *
     445                 :            :  * RETURN:      None
     446                 :            :  *
     447                 :            :  * DESCRIPTION: Perform the actual execution of a GPE control method. This
     448                 :            :  *              function is called from an invocation of acpi_os_execute and
     449                 :            :  *              therefore does NOT execute at interrupt level - so that
     450                 :            :  *              the control method itself is not executed in the context of
     451                 :            :  *              an interrupt handler.
     452                 :            :  *
     453                 :            :  ******************************************************************************/
     454                 :            : 
     455                 :          0 : static void ACPI_SYSTEM_XFACE acpi_ev_asynch_execute_gpe_method(void *context)
     456                 :            : {
     457                 :          0 :         struct acpi_gpe_event_info *gpe_event_info = context;
     458                 :          0 :         acpi_status status = AE_OK;
     459                 :          0 :         struct acpi_evaluate_info *info;
     460                 :          0 :         struct acpi_gpe_notify_info *notify;
     461                 :            : 
     462                 :          0 :         ACPI_FUNCTION_TRACE(ev_asynch_execute_gpe_method);
     463                 :            : 
     464                 :            :         /* Do the correct dispatch - normal method or implicit notify */
     465                 :            : 
     466      [ #  #  # ]:          0 :         switch (ACPI_GPE_DISPATCH_TYPE(gpe_event_info->flags)) {
     467                 :          0 :         case ACPI_GPE_DISPATCH_NOTIFY:
     468                 :            :                 /*
     469                 :            :                  * Implicit notify.
     470                 :            :                  * Dispatch a DEVICE_WAKE notify to the appropriate handler.
     471                 :            :                  * NOTE: the request is queued for execution after this method
     472                 :            :                  * completes. The notify handlers are NOT invoked synchronously
     473                 :            :                  * from this thread -- because handlers may in turn run other
     474                 :            :                  * control methods.
     475                 :            :                  *
     476                 :            :                  * June 2012: Expand implicit notify mechanism to support
     477                 :            :                  * notifies on multiple device objects.
     478                 :            :                  */
     479                 :          0 :                 notify = gpe_event_info->dispatch.notify_list;
     480         [ #  # ]:          0 :                 while (ACPI_SUCCESS(status) && notify) {
     481                 :          0 :                         status =
     482                 :          0 :                             acpi_ev_queue_notify_request(notify->device_node,
     483                 :            :                                                          ACPI_NOTIFY_DEVICE_WAKE);
     484                 :            : 
     485                 :          0 :                         notify = notify->next;
     486                 :            :                 }
     487                 :            : 
     488                 :            :                 break;
     489                 :            : 
     490                 :          0 :         case ACPI_GPE_DISPATCH_METHOD:
     491                 :            : 
     492                 :            :                 /* Allocate the evaluation information block */
     493                 :            : 
     494                 :          0 :                 info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info));
     495         [ #  # ]:          0 :                 if (!info) {
     496                 :            :                         status = AE_NO_MEMORY;
     497                 :            :                 } else {
     498                 :            :                         /*
     499                 :            :                          * Invoke the GPE Method (_Lxx, _Exx) i.e., evaluate the
     500                 :            :                          * _Lxx/_Exx control method that corresponds to this GPE
     501                 :            :                          */
     502                 :          0 :                         info->prefix_node =
     503                 :          0 :                             gpe_event_info->dispatch.method_node;
     504                 :          0 :                         info->flags = ACPI_IGNORE_RETURN_VALUE;
     505                 :            : 
     506                 :          0 :                         status = acpi_ns_evaluate(info);
     507                 :          0 :                         ACPI_FREE(info);
     508                 :            :                 }
     509                 :            : 
     510         [ #  # ]:          0 :                 if (ACPI_FAILURE(status)) {
     511                 :          0 :                         ACPI_EXCEPTION((AE_INFO, status,
     512                 :            :                                         "while evaluating GPE method [%4.4s]",
     513                 :            :                                         acpi_ut_get_node_name(gpe_event_info->
     514                 :            :                                                               dispatch.
     515                 :            :                                                               method_node)));
     516                 :            :                 }
     517                 :            :                 break;
     518                 :            : 
     519                 :          0 :         default:
     520                 :            : 
     521                 :          0 :                 goto error_exit;        /* Should never happen */
     522                 :            :         }
     523                 :            : 
     524                 :            :         /* Defer enabling of GPE until all notify handlers are done */
     525                 :            : 
     526                 :          0 :         status = acpi_os_execute(OSL_NOTIFY_HANDLER,
     527                 :            :                                  acpi_ev_asynch_enable_gpe, gpe_event_info);
     528         [ #  # ]:          0 :         if (ACPI_SUCCESS(status)) {
     529                 :            :                 return_VOID;
     530                 :            :         }
     531                 :            : 
     532                 :          0 : error_exit:
     533                 :          0 :         acpi_ev_asynch_enable_gpe(gpe_event_info);
     534                 :          0 :         return_VOID;
     535                 :            : }
     536                 :            : 
     537                 :            : 
     538                 :            : /*******************************************************************************
     539                 :            :  *
     540                 :            :  * FUNCTION:    acpi_ev_asynch_enable_gpe
     541                 :            :  *
     542                 :            :  * PARAMETERS:  Context (gpe_event_info) - Info for this GPE
     543                 :            :  *              Callback from acpi_os_execute
     544                 :            :  *
     545                 :            :  * RETURN:      None
     546                 :            :  *
     547                 :            :  * DESCRIPTION: Asynchronous clear/enable for GPE. This allows the GPE to
     548                 :            :  *              complete (i.e., finish execution of Notify)
     549                 :            :  *
     550                 :            :  ******************************************************************************/
     551                 :            : 
     552                 :          0 : static void ACPI_SYSTEM_XFACE acpi_ev_asynch_enable_gpe(void *context)
     553                 :            : {
     554                 :          0 :         struct acpi_gpe_event_info *gpe_event_info = context;
     555                 :          0 :         acpi_cpu_flags flags;
     556                 :            : 
     557                 :          0 :         flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
     558                 :          0 :         (void)acpi_ev_finish_gpe(gpe_event_info);
     559                 :          0 :         acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
     560                 :            : 
     561                 :          0 :         return;
     562                 :            : }
     563                 :            : 
     564                 :            : 
     565                 :            : /*******************************************************************************
     566                 :            :  *
     567                 :            :  * FUNCTION:    acpi_ev_finish_gpe
     568                 :            :  *
     569                 :            :  * PARAMETERS:  gpe_event_info      - Info for this GPE
     570                 :            :  *
     571                 :            :  * RETURN:      Status
     572                 :            :  *
     573                 :            :  * DESCRIPTION: Clear/Enable a GPE. Common code that is used after execution
     574                 :            :  *              of a GPE method or a synchronous or asynchronous GPE handler.
     575                 :            :  *
     576                 :            :  ******************************************************************************/
     577                 :            : 
     578                 :          0 : acpi_status acpi_ev_finish_gpe(struct acpi_gpe_event_info *gpe_event_info)
     579                 :            : {
     580                 :          0 :         acpi_status status;
     581                 :            : 
     582         [ #  # ]:          0 :         if ((gpe_event_info->flags & ACPI_GPE_XRUPT_TYPE_MASK) ==
     583                 :            :             ACPI_GPE_LEVEL_TRIGGERED) {
     584                 :            :                 /*
     585                 :            :                  * GPE is level-triggered, we clear the GPE status bit after
     586                 :            :                  * handling the event.
     587                 :            :                  */
     588                 :          0 :                 status = acpi_hw_clear_gpe(gpe_event_info);
     589         [ #  # ]:          0 :                 if (ACPI_FAILURE(status)) {
     590                 :            :                         return (status);
     591                 :            :                 }
     592                 :            :         }
     593                 :            : 
     594                 :            :         /*
     595                 :            :          * Enable this GPE, conditionally. This means that the GPE will
     596                 :            :          * only be physically enabled if the enable_mask bit is set
     597                 :            :          * in the event_info.
     598                 :            :          */
     599                 :          0 :         (void)acpi_hw_low_set_gpe(gpe_event_info, ACPI_GPE_CONDITIONAL_ENABLE);
     600                 :          0 :         gpe_event_info->disable_for_dispatch = FALSE;
     601                 :          0 :         return (AE_OK);
     602                 :            : }
     603                 :            : 
     604                 :            : 
     605                 :            : /*******************************************************************************
     606                 :            :  *
     607                 :            :  * FUNCTION:    acpi_ev_detect_gpe
     608                 :            :  *
     609                 :            :  * PARAMETERS:  gpe_device          - Device node. NULL for GPE0/GPE1
     610                 :            :  *              gpe_event_info      - Info for this GPE
     611                 :            :  *              gpe_number          - Number relative to the parent GPE block
     612                 :            :  *
     613                 :            :  * RETURN:      INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED
     614                 :            :  *
     615                 :            :  * DESCRIPTION: Detect and dispatch a General Purpose Event to either a function
     616                 :            :  *              (e.g. EC) or method (e.g. _Lxx/_Exx) handler.
     617                 :            :  * NOTE:        GPE is W1C, so it is possible to handle a single GPE from both
     618                 :            :  *              task and irq context in parallel as long as the process to
     619                 :            :  *              detect and mask the GPE is atomic.
     620                 :            :  *              However the atomicity of ACPI_GPE_DISPATCH_RAW_HANDLER is
     621                 :            :  *              dependent on the raw handler itself.
     622                 :            :  *
     623                 :            :  ******************************************************************************/
     624                 :            : 
     625                 :            : u32
     626                 :        240 : acpi_ev_detect_gpe(struct acpi_namespace_node *gpe_device,
     627                 :            :                    struct acpi_gpe_event_info *gpe_event_info, u32 gpe_number)
     628                 :            : {
     629                 :        240 :         u32 int_status = ACPI_INTERRUPT_NOT_HANDLED;
     630                 :        240 :         u8 enabled_status_byte;
     631                 :        240 :         u64 status_reg;
     632                 :        240 :         u64 enable_reg;
     633                 :        240 :         u32 register_bit;
     634                 :        240 :         struct acpi_gpe_register_info *gpe_register_info;
     635                 :        240 :         struct acpi_gpe_handler_info *gpe_handler_info;
     636                 :        240 :         acpi_cpu_flags flags;
     637                 :        240 :         acpi_status status;
     638                 :            : 
     639                 :        240 :         ACPI_FUNCTION_TRACE(ev_gpe_detect);
     640                 :            : 
     641                 :        240 :         flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
     642                 :            : 
     643         [ -  + ]:        240 :         if (!gpe_event_info) {
     644                 :          0 :                 gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
     645         [ #  # ]:          0 :                 if (!gpe_event_info)
     646                 :          0 :                         goto error_exit;
     647                 :            :         }
     648                 :            : 
     649                 :            :         /* Get the info block for the entire GPE register */
     650                 :            : 
     651                 :        240 :         gpe_register_info = gpe_event_info->register_info;
     652                 :            : 
     653                 :            :         /* Get the register bitmask for this GPE */
     654                 :            : 
     655                 :        240 :         register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info);
     656                 :            : 
     657                 :            :         /* GPE currently enabled (enable bit == 1)? */
     658                 :            : 
     659                 :        240 :         status = acpi_hw_read(&enable_reg, &gpe_register_info->enable_address);
     660         [ -  + ]:        240 :         if (ACPI_FAILURE(status)) {
     661                 :          0 :                 goto error_exit;
     662                 :            :         }
     663                 :            : 
     664                 :            :         /* GPE currently active (status bit == 1)? */
     665                 :            : 
     666                 :        240 :         status = acpi_hw_read(&status_reg, &gpe_register_info->status_address);
     667         [ -  + ]:        240 :         if (ACPI_FAILURE(status)) {
     668                 :          0 :                 goto error_exit;
     669                 :            :         }
     670                 :            : 
     671                 :            :         /* Check if there is anything active at all in this GPE */
     672                 :            : 
     673                 :            :         ACPI_DEBUG_PRINT((ACPI_DB_INTERRUPTS,
     674                 :            :                           "Read registers for GPE %02X: Status=%02X, Enable=%02X, "
     675                 :            :                           "RunEnable=%02X, WakeEnable=%02X\n",
     676                 :            :                           gpe_number,
     677                 :            :                           (u32)(status_reg & register_bit),
     678                 :            :                           (u32)(enable_reg & register_bit),
     679                 :            :                           gpe_register_info->enable_for_run,
     680                 :        240 :                           gpe_register_info->enable_for_wake));
     681                 :            : 
     682                 :        240 :         enabled_status_byte = (u8)(status_reg & enable_reg);
     683         [ +  - ]:        240 :         if (!(enabled_status_byte & register_bit)) {
     684                 :        240 :                 goto error_exit;
     685                 :            :         }
     686                 :            : 
     687                 :            :         /* Invoke global event handler if present */
     688                 :            : 
     689                 :          0 :         acpi_gpe_count++;
     690         [ #  # ]:          0 :         if (acpi_gbl_global_event_handler) {
     691                 :          0 :                 acpi_gbl_global_event_handler(ACPI_EVENT_TYPE_GPE,
     692                 :            :                                               gpe_device, gpe_number,
     693                 :            :                                               acpi_gbl_global_event_handler_context);
     694                 :            :         }
     695                 :            : 
     696                 :            :         /* Found an active GPE */
     697                 :            : 
     698         [ #  # ]:          0 :         if (ACPI_GPE_DISPATCH_TYPE(gpe_event_info->flags) ==
     699                 :            :             ACPI_GPE_DISPATCH_RAW_HANDLER) {
     700                 :            : 
     701                 :            :                 /* Dispatch the event to a raw handler */
     702                 :            : 
     703                 :          0 :                 gpe_handler_info = gpe_event_info->dispatch.handler;
     704                 :            : 
     705                 :            :                 /*
     706                 :            :                  * There is no protection around the namespace node
     707                 :            :                  * and the GPE handler to ensure a safe destruction
     708                 :            :                  * because:
     709                 :            :                  * 1. The namespace node is expected to always
     710                 :            :                  *    exist after loading a table.
     711                 :            :                  * 2. The GPE handler is expected to be flushed by
     712                 :            :                  *    acpi_os_wait_events_complete() before the
     713                 :            :                  *    destruction.
     714                 :            :                  */
     715                 :          0 :                 acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
     716                 :          0 :                 int_status |=
     717                 :          0 :                     gpe_handler_info->address(gpe_device, gpe_number,
     718                 :            :                                               gpe_handler_info->context);
     719                 :          0 :                 flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
     720                 :            :         } else {
     721                 :            :                 /* Dispatch the event to a standard handler or method. */
     722                 :            : 
     723                 :          0 :                 int_status |= acpi_ev_gpe_dispatch(gpe_device,
     724                 :            :                                                    gpe_event_info, gpe_number);
     725                 :            :         }
     726                 :            : 
     727                 :        240 : error_exit:
     728                 :        240 :         acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
     729                 :        240 :         return (int_status);
     730                 :            : }
     731                 :            : 
     732                 :            : /*******************************************************************************
     733                 :            :  *
     734                 :            :  * FUNCTION:    acpi_ev_gpe_dispatch
     735                 :            :  *
     736                 :            :  * PARAMETERS:  gpe_device          - Device node. NULL for GPE0/GPE1
     737                 :            :  *              gpe_event_info      - Info for this GPE
     738                 :            :  *              gpe_number          - Number relative to the parent GPE block
     739                 :            :  *
     740                 :            :  * RETURN:      INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED
     741                 :            :  *
     742                 :            :  * DESCRIPTION: Dispatch a General Purpose Event to either a function (e.g. EC)
     743                 :            :  *              or method (e.g. _Lxx/_Exx) handler.
     744                 :            :  *
     745                 :            :  ******************************************************************************/
     746                 :            : 
     747                 :            : u32
     748                 :          0 : acpi_ev_gpe_dispatch(struct acpi_namespace_node *gpe_device,
     749                 :            :                      struct acpi_gpe_event_info *gpe_event_info, u32 gpe_number)
     750                 :            : {
     751                 :          0 :         acpi_status status;
     752                 :          0 :         u32 return_value;
     753                 :            : 
     754                 :          0 :         ACPI_FUNCTION_TRACE(ev_gpe_dispatch);
     755                 :            : 
     756                 :            :         /*
     757                 :            :          * Always disable the GPE so that it does not keep firing before
     758                 :            :          * any asynchronous activity completes (either from the execution
     759                 :            :          * of a GPE method or an asynchronous GPE handler.)
     760                 :            :          *
     761                 :            :          * If there is no handler or method to run, just disable the
     762                 :            :          * GPE and leave it disabled permanently to prevent further such
     763                 :            :          * pointless events from firing.
     764                 :            :          */
     765                 :          0 :         status = acpi_hw_low_set_gpe(gpe_event_info, ACPI_GPE_DISABLE);
     766         [ #  # ]:          0 :         if (ACPI_FAILURE(status)) {
     767                 :          0 :                 ACPI_EXCEPTION((AE_INFO, status,
     768                 :            :                                 "Unable to disable GPE %02X", gpe_number));
     769                 :          0 :                 return_UINT32(ACPI_INTERRUPT_NOT_HANDLED);
     770                 :            :         }
     771                 :            : 
     772                 :            :         /*
     773                 :            :          * If edge-triggered, clear the GPE status bit now. Note that
     774                 :            :          * level-triggered events are cleared after the GPE is serviced.
     775                 :            :          */
     776         [ #  # ]:          0 :         if ((gpe_event_info->flags & ACPI_GPE_XRUPT_TYPE_MASK) ==
     777                 :            :             ACPI_GPE_EDGE_TRIGGERED) {
     778                 :          0 :                 status = acpi_hw_clear_gpe(gpe_event_info);
     779         [ #  # ]:          0 :                 if (ACPI_FAILURE(status)) {
     780                 :          0 :                         ACPI_EXCEPTION((AE_INFO, status,
     781                 :            :                                         "Unable to clear GPE %02X",
     782                 :            :                                         gpe_number));
     783                 :          0 :                         (void)acpi_hw_low_set_gpe(gpe_event_info,
     784                 :            :                                                   ACPI_GPE_CONDITIONAL_ENABLE);
     785                 :          0 :                         return_UINT32(ACPI_INTERRUPT_NOT_HANDLED);
     786                 :            :                 }
     787                 :            :         }
     788                 :            : 
     789                 :          0 :         gpe_event_info->disable_for_dispatch = TRUE;
     790                 :            : 
     791                 :            :         /*
     792                 :            :          * Dispatch the GPE to either an installed handler or the control
     793                 :            :          * method associated with this GPE (_Lxx or _Exx). If a handler
     794                 :            :          * exists, we invoke it and do not attempt to run the method.
     795                 :            :          * If there is neither a handler nor a method, leave the GPE
     796                 :            :          * disabled.
     797                 :            :          */
     798      [ #  #  # ]:          0 :         switch (ACPI_GPE_DISPATCH_TYPE(gpe_event_info->flags)) {
     799                 :          0 :         case ACPI_GPE_DISPATCH_HANDLER:
     800                 :            : 
     801                 :            :                 /* Invoke the installed handler (at interrupt level) */
     802                 :            : 
     803                 :          0 :                 return_value =
     804                 :          0 :                     gpe_event_info->dispatch.handler->address(gpe_device,
     805                 :            :                                                               gpe_number,
     806                 :            :                                                               gpe_event_info->
     807                 :            :                                                               dispatch.handler->
     808                 :            :                                                               context);
     809                 :            : 
     810                 :            :                 /* If requested, clear (if level-triggered) and re-enable the GPE */
     811                 :            : 
     812         [ #  # ]:          0 :                 if (return_value & ACPI_REENABLE_GPE) {
     813                 :          0 :                         (void)acpi_ev_finish_gpe(gpe_event_info);
     814                 :            :                 }
     815                 :            :                 break;
     816                 :            : 
     817                 :          0 :         case ACPI_GPE_DISPATCH_METHOD:
     818                 :            :         case ACPI_GPE_DISPATCH_NOTIFY:
     819                 :            :                 /*
     820                 :            :                  * Execute the method associated with the GPE
     821                 :            :                  * NOTE: Level-triggered GPEs are cleared after the method completes.
     822                 :            :                  */
     823                 :          0 :                 status = acpi_os_execute(OSL_GPE_HANDLER,
     824                 :            :                                          acpi_ev_asynch_execute_gpe_method,
     825                 :            :                                          gpe_event_info);
     826         [ #  # ]:          0 :                 if (ACPI_FAILURE(status)) {
     827                 :          0 :                         ACPI_EXCEPTION((AE_INFO, status,
     828                 :            :                                         "Unable to queue handler for GPE %02X - event disabled",
     829                 :            :                                         gpe_number));
     830                 :            :                 }
     831                 :            :                 break;
     832                 :            : 
     833                 :          0 :         default:
     834                 :            :                 /*
     835                 :            :                  * No handler or method to run!
     836                 :            :                  * 03/2010: This case should no longer be possible. We will not allow
     837                 :            :                  * a GPE to be enabled if it has no handler or method.
     838                 :            :                  */
     839                 :          0 :                 ACPI_ERROR((AE_INFO,
     840                 :            :                             "No handler or method for GPE %02X, disabling event",
     841                 :            :                             gpe_number));
     842                 :            : 
     843                 :          0 :                 break;
     844                 :            :         }
     845                 :            : 
     846                 :            :         return_UINT32(ACPI_INTERRUPT_HANDLED);
     847                 :            : }
     848                 :            : 
     849                 :            : #endif                          /* !ACPI_REDUCED_HARDWARE */

Generated by: LCOV version 1.14