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
acpi_ev_walk_gpe_list(acpi_gpe_callback gpe_walk_callback,void * context)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
acpi_ev_get_gpe_device(struct acpi_gpe_xrupt_info * gpe_xrupt_info,struct acpi_gpe_block_info * gpe_block,void * context)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
acpi_ev_get_gpe_xrupt_block(u32 interrupt_number,struct acpi_gpe_xrupt_info ** gpe_xrupt_block)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 
acpi_ev_delete_gpe_xrupt(struct acpi_gpe_xrupt_info * gpe_xrupt)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
acpi_ev_delete_gpe_handlers(struct acpi_gpe_xrupt_info * gpe_xrupt_info,struct acpi_gpe_block_info * gpe_block,void * context)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