1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 2 /****************************************************************************** 3 * 4 * Module Name: evgpeutil - GPE utilities 5 * 6 * Copyright (C) 2000 - 2023, 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 */ 327