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

   1// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
   2/******************************************************************************
   3 *
   4 * Module Name: evgpeutil - GPE utilities
   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
  14#define _COMPONENT          ACPI_EVENTS
  15ACPI_MODULE_NAME("evgpeutil")
  16
  17#if (!ACPI_REDUCED_HARDWARE)    /* Entire module */
  18/*******************************************************************************
  19 *
  20 * FUNCTION:    acpi_ev_walk_gpe_list
  21 *
  22 * PARAMETERS:  gpe_walk_callback   - Routine called for each GPE block
  23 *              context             - Value passed to callback
  24 *
  25 * RETURN:      Status
  26 *
  27 * DESCRIPTION: Walk the GPE lists.
  28 *
  29 ******************************************************************************/
  30acpi_status
  31acpi_ev_walk_gpe_list(acpi_gpe_callback gpe_walk_callback, void *context)
  32{
  33        struct acpi_gpe_block_info *gpe_block;
  34        struct acpi_gpe_xrupt_info *gpe_xrupt_info;
  35        acpi_status status = AE_OK;
  36        acpi_cpu_flags flags;
  37
  38        ACPI_FUNCTION_TRACE(ev_walk_gpe_list);
  39
  40        flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
  41
  42        /* Walk the interrupt level descriptor list */
  43
  44        gpe_xrupt_info = acpi_gbl_gpe_xrupt_list_head;
  45        while (gpe_xrupt_info) {
  46
  47                /* Walk all Gpe Blocks attached to this interrupt level */
  48
  49                gpe_block = gpe_xrupt_info->gpe_block_list_head;
  50                while (gpe_block) {
  51
  52                        /* One callback per GPE block */
  53
  54                        status =
  55                            gpe_walk_callback(gpe_xrupt_info, gpe_block,
  56                                              context);
  57                        if (ACPI_FAILURE(status)) {
  58                                if (status == AE_CTRL_END) {    /* Callback abort */
  59                                        status = AE_OK;
  60                                }
  61                                goto unlock_and_exit;
  62                        }
  63
  64                        gpe_block = gpe_block->next;
  65                }
  66
  67                gpe_xrupt_info = gpe_xrupt_info->next;
  68        }
  69
  70unlock_and_exit:
  71        acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
  72        return_ACPI_STATUS(status);
  73}
  74
  75/*******************************************************************************
  76 *
  77 * FUNCTION:    acpi_ev_get_gpe_device
  78 *
  79 * PARAMETERS:  GPE_WALK_CALLBACK
  80 *
  81 * RETURN:      Status
  82 *
  83 * DESCRIPTION: Matches the input GPE index (0-current_gpe_count) with a GPE
  84 *              block device. NULL if the GPE is one of the FADT-defined GPEs.
  85 *
  86 ******************************************************************************/
  87
  88acpi_status
  89acpi_ev_get_gpe_device(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
  90                       struct acpi_gpe_block_info *gpe_block, void *context)
  91{
  92        struct acpi_gpe_device_info *info = context;
  93
  94        /* Increment Index by the number of GPEs in this block */
  95
  96        info->next_block_base_index += gpe_block->gpe_count;
  97
  98        if (info->index < info->next_block_base_index) {
  99                /*
 100                 * The GPE index is within this block, get the node. Leave the node
 101                 * NULL for the FADT-defined GPEs
 102                 */
 103                if ((gpe_block->node)->type == ACPI_TYPE_DEVICE) {
 104                        info->gpe_device = gpe_block->node;
 105                }
 106
 107                info->status = AE_OK;
 108                return (AE_CTRL_END);
 109        }
 110
 111        return (AE_OK);
 112}
 113
 114/*******************************************************************************
 115 *
 116 * FUNCTION:    acpi_ev_get_gpe_xrupt_block
 117 *
 118 * PARAMETERS:  interrupt_number            - Interrupt for a GPE block
 119 *              gpe_xrupt_block             - Where the block is returned
 120 *
 121 * RETURN:      Status
 122 *
 123 * DESCRIPTION: Get or Create a GPE interrupt block. There is one interrupt
 124 *              block per unique interrupt level used for GPEs. Should be
 125 *              called only when the GPE lists are semaphore locked and not
 126 *              subject to change.
 127 *
 128 ******************************************************************************/
 129
 130acpi_status
 131acpi_ev_get_gpe_xrupt_block(u32 interrupt_number,
 132                            struct acpi_gpe_xrupt_info **gpe_xrupt_block)
 133{
 134        struct acpi_gpe_xrupt_info *next_gpe_xrupt;
 135        struct acpi_gpe_xrupt_info *gpe_xrupt;
 136        acpi_status status;
 137        acpi_cpu_flags flags;
 138
 139        ACPI_FUNCTION_TRACE(ev_get_gpe_xrupt_block);
 140
 141        /* No need for lock since we are not changing any list elements here */
 142
 143        next_gpe_xrupt = acpi_gbl_gpe_xrupt_list_head;
 144        while (next_gpe_xrupt) {
 145                if (next_gpe_xrupt->interrupt_number == interrupt_number) {
 146                        *gpe_xrupt_block = next_gpe_xrupt;
 147                        return_ACPI_STATUS(AE_OK);
 148                }
 149
 150                next_gpe_xrupt = next_gpe_xrupt->next;
 151        }
 152
 153        /* Not found, must allocate a new xrupt descriptor */
 154
 155        gpe_xrupt = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_gpe_xrupt_info));
 156        if (!gpe_xrupt) {
 157                return_ACPI_STATUS(AE_NO_MEMORY);
 158        }
 159
 160        gpe_xrupt->interrupt_number = interrupt_number;
 161
 162        /* Install new interrupt descriptor with spin lock */
 163
 164        flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
 165        if (acpi_gbl_gpe_xrupt_list_head) {
 166                next_gpe_xrupt = acpi_gbl_gpe_xrupt_list_head;
 167                while (next_gpe_xrupt->next) {
 168                        next_gpe_xrupt = next_gpe_xrupt->next;
 169                }
 170
 171                next_gpe_xrupt->next = gpe_xrupt;
 172                gpe_xrupt->previous = next_gpe_xrupt;
 173        } else {
 174                acpi_gbl_gpe_xrupt_list_head = gpe_xrupt;
 175        }
 176
 177        acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
 178
 179        /* Install new interrupt handler if not SCI_INT */
 180
 181        if (interrupt_number != acpi_gbl_FADT.sci_interrupt) {
 182                status = acpi_os_install_interrupt_handler(interrupt_number,
 183                                                           acpi_ev_gpe_xrupt_handler,
 184                                                           gpe_xrupt);
 185                if (ACPI_FAILURE(status)) {
 186                        ACPI_EXCEPTION((AE_INFO, status,
 187                                        "Could not install GPE interrupt handler at level 0x%X",
 188                                        interrupt_number));
 189                        return_ACPI_STATUS(status);
 190                }
 191        }
 192
 193        *gpe_xrupt_block = gpe_xrupt;
 194        return_ACPI_STATUS(AE_OK);
 195}
 196
 197/*******************************************************************************
 198 *
 199 * FUNCTION:    acpi_ev_delete_gpe_xrupt
 200 *
 201 * PARAMETERS:  gpe_xrupt       - A GPE interrupt info block
 202 *
 203 * RETURN:      Status
 204 *
 205 * DESCRIPTION: Remove and free a gpe_xrupt block. Remove an associated
 206 *              interrupt handler if not the SCI interrupt.
 207 *
 208 ******************************************************************************/
 209
 210acpi_status acpi_ev_delete_gpe_xrupt(struct acpi_gpe_xrupt_info *gpe_xrupt)
 211{
 212        acpi_status status;
 213        acpi_cpu_flags flags;
 214
 215        ACPI_FUNCTION_TRACE(ev_delete_gpe_xrupt);
 216
 217        /* We never want to remove the SCI interrupt handler */
 218
 219        if (gpe_xrupt->interrupt_number == acpi_gbl_FADT.sci_interrupt) {
 220                gpe_xrupt->gpe_block_list_head = NULL;
 221                return_ACPI_STATUS(AE_OK);
 222        }
 223
 224        /* Disable this interrupt */
 225
 226        status =
 227            acpi_os_remove_interrupt_handler(gpe_xrupt->interrupt_number,
 228                                             acpi_ev_gpe_xrupt_handler);
 229        if (ACPI_FAILURE(status)) {
 230                return_ACPI_STATUS(status);
 231        }
 232
 233        /* Unlink the interrupt block with lock */
 234
 235        flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
 236        if (gpe_xrupt->previous) {
 237                gpe_xrupt->previous->next = gpe_xrupt->next;
 238        } else {
 239                /* No previous, update list head */
 240
 241                acpi_gbl_gpe_xrupt_list_head = gpe_xrupt->next;
 242        }
 243
 244        if (gpe_xrupt->next) {
 245                gpe_xrupt->next->previous = gpe_xrupt->previous;
 246        }
 247        acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
 248
 249        /* Free the block */
 250
 251        ACPI_FREE(gpe_xrupt);
 252        return_ACPI_STATUS(AE_OK);
 253}
 254
 255/*******************************************************************************
 256 *
 257 * FUNCTION:    acpi_ev_delete_gpe_handlers
 258 *
 259 * PARAMETERS:  gpe_xrupt_info      - GPE Interrupt info
 260 *              gpe_block           - Gpe Block info
 261 *
 262 * RETURN:      Status
 263 *
 264 * DESCRIPTION: Delete all Handler objects found in the GPE data structs.
 265 *              Used only prior to termination.
 266 *
 267 ******************************************************************************/
 268
 269acpi_status
 270acpi_ev_delete_gpe_handlers(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
 271                            struct acpi_gpe_block_info *gpe_block,
 272                            void *context)
 273{
 274        struct acpi_gpe_event_info *gpe_event_info;
 275        struct acpi_gpe_notify_info *notify;
 276        struct acpi_gpe_notify_info *next;
 277        u32 i;
 278        u32 j;
 279
 280        ACPI_FUNCTION_TRACE(ev_delete_gpe_handlers);
 281
 282        /* Examine each GPE Register within the block */
 283
 284        for (i = 0; i < gpe_block->register_count; i++) {
 285
 286                /* Now look at the individual GPEs in this byte register */
 287
 288                for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++) {
 289                        gpe_event_info = &gpe_block->event_info[((acpi_size)i *
 290                                                                 ACPI_GPE_REGISTER_WIDTH)
 291                                                                + j];
 292
 293                        if ((ACPI_GPE_DISPATCH_TYPE(gpe_event_info->flags) ==
 294                             ACPI_GPE_DISPATCH_HANDLER) ||
 295                            (ACPI_GPE_DISPATCH_TYPE(gpe_event_info->flags) ==
 296                             ACPI_GPE_DISPATCH_RAW_HANDLER)) {
 297
 298                                /* Delete an installed handler block */
 299
 300                                ACPI_FREE(gpe_event_info->dispatch.handler);
 301                                gpe_event_info->dispatch.handler = NULL;
 302                                gpe_event_info->flags &=
 303                                    ~ACPI_GPE_DISPATCH_MASK;
 304                        } else if (ACPI_GPE_DISPATCH_TYPE(gpe_event_info->flags)
 305                                   == ACPI_GPE_DISPATCH_NOTIFY) {
 306
 307                                /* Delete the implicit notification device list */
 308
 309                                notify = gpe_event_info->dispatch.notify_list;
 310                                while (notify) {
 311                                        next = notify->next;
 312                                        ACPI_FREE(notify);
 313                                        notify = next;
 314                                }
 315
 316                                gpe_event_info->dispatch.notify_list = NULL;
 317                                gpe_event_info->flags &=
 318                                    ~ACPI_GPE_DISPATCH_MASK;
 319                        }
 320                }
 321        }
 322
 323        return_ACPI_STATUS(AE_OK);
 324}
 325
 326#endif                          /* !ACPI_REDUCED_HARDWARE */
 327