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
  15 ACPI_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  ******************************************************************************/
  30 acpi_status
  31 acpi_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
  70 unlock_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
  88 acpi_status
  89 acpi_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
 130 acpi_status
 131 acpi_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
 210 acpi_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
 269 acpi_status
 270 acpi_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 */