1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 /******************************************************************************
3  *
4  * Module Name: evgpeblk - GPE block creation and initialization.
5  *
6  * Copyright (C) 2000 - 2022, 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("evgpeblk")
17 #if (!ACPI_REDUCED_HARDWARE)	/* Entire module */
18 /* Local prototypes */
19 static acpi_status
20 acpi_ev_install_gpe_block(struct acpi_gpe_block_info *gpe_block,
21 			  u32 interrupt_number);
22 
23 static acpi_status
24 acpi_ev_create_gpe_info_blocks(struct acpi_gpe_block_info *gpe_block);
25 
26 /*******************************************************************************
27  *
28  * FUNCTION:    acpi_ev_install_gpe_block
29  *
30  * PARAMETERS:  gpe_block               - New GPE block
31  *              interrupt_number        - Xrupt to be associated with this
32  *                                        GPE block
33  *
34  * RETURN:      Status
35  *
36  * DESCRIPTION: Install new GPE block with mutex support
37  *
38  ******************************************************************************/
39 
40 static acpi_status
acpi_ev_install_gpe_block(struct acpi_gpe_block_info * gpe_block,u32 interrupt_number)41 acpi_ev_install_gpe_block(struct acpi_gpe_block_info *gpe_block,
42 			  u32 interrupt_number)
43 {
44 	struct acpi_gpe_block_info *next_gpe_block;
45 	struct acpi_gpe_xrupt_info *gpe_xrupt_block;
46 	acpi_status status;
47 	acpi_cpu_flags flags;
48 
49 	ACPI_FUNCTION_TRACE(ev_install_gpe_block);
50 
51 	status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
52 	if (ACPI_FAILURE(status)) {
53 		return_ACPI_STATUS(status);
54 	}
55 
56 	status =
57 	    acpi_ev_get_gpe_xrupt_block(interrupt_number, &gpe_xrupt_block);
58 	if (ACPI_FAILURE(status)) {
59 		goto unlock_and_exit;
60 	}
61 
62 	/* Install the new block at the end of the list with lock */
63 
64 	flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
65 	if (gpe_xrupt_block->gpe_block_list_head) {
66 		next_gpe_block = gpe_xrupt_block->gpe_block_list_head;
67 		while (next_gpe_block->next) {
68 			next_gpe_block = next_gpe_block->next;
69 		}
70 
71 		next_gpe_block->next = gpe_block;
72 		gpe_block->previous = next_gpe_block;
73 	} else {
74 		gpe_xrupt_block->gpe_block_list_head = gpe_block;
75 	}
76 
77 	gpe_block->xrupt_block = gpe_xrupt_block;
78 	acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
79 
80 unlock_and_exit:
81 	(void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
82 	return_ACPI_STATUS(status);
83 }
84 
85 /*******************************************************************************
86  *
87  * FUNCTION:    acpi_ev_delete_gpe_block
88  *
89  * PARAMETERS:  gpe_block           - Existing GPE block
90  *
91  * RETURN:      Status
92  *
93  * DESCRIPTION: Remove a GPE block
94  *
95  ******************************************************************************/
96 
acpi_ev_delete_gpe_block(struct acpi_gpe_block_info * gpe_block)97 acpi_status acpi_ev_delete_gpe_block(struct acpi_gpe_block_info *gpe_block)
98 {
99 	acpi_status status;
100 	acpi_cpu_flags flags;
101 
102 	ACPI_FUNCTION_TRACE(ev_install_gpe_block);
103 
104 	status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
105 	if (ACPI_FAILURE(status)) {
106 		return_ACPI_STATUS(status);
107 	}
108 
109 	/* Disable all GPEs in this block */
110 
111 	status =
112 	    acpi_hw_disable_gpe_block(gpe_block->xrupt_block, gpe_block, NULL);
113 	if (ACPI_FAILURE(status)) {
114 		return_ACPI_STATUS(status);
115 	}
116 
117 	if (!gpe_block->previous && !gpe_block->next) {
118 
119 		/* This is the last gpe_block on this interrupt */
120 
121 		status = acpi_ev_delete_gpe_xrupt(gpe_block->xrupt_block);
122 		if (ACPI_FAILURE(status)) {
123 			goto unlock_and_exit;
124 		}
125 	} else {
126 		/* Remove the block on this interrupt with lock */
127 
128 		flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
129 		if (gpe_block->previous) {
130 			gpe_block->previous->next = gpe_block->next;
131 		} else {
132 			gpe_block->xrupt_block->gpe_block_list_head =
133 			    gpe_block->next;
134 		}
135 
136 		if (gpe_block->next) {
137 			gpe_block->next->previous = gpe_block->previous;
138 		}
139 
140 		acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
141 	}
142 
143 	acpi_current_gpe_count -= gpe_block->gpe_count;
144 
145 	/* Free the gpe_block */
146 
147 	ACPI_FREE(gpe_block->register_info);
148 	ACPI_FREE(gpe_block->event_info);
149 	ACPI_FREE(gpe_block);
150 
151 unlock_and_exit:
152 	status = acpi_ut_release_mutex(ACPI_MTX_EVENTS);
153 	return_ACPI_STATUS(status);
154 }
155 
156 /*******************************************************************************
157  *
158  * FUNCTION:    acpi_ev_create_gpe_info_blocks
159  *
160  * PARAMETERS:  gpe_block   - New GPE block
161  *
162  * RETURN:      Status
163  *
164  * DESCRIPTION: Create the register_info and event_info blocks for this GPE block
165  *
166  ******************************************************************************/
167 
168 static acpi_status
acpi_ev_create_gpe_info_blocks(struct acpi_gpe_block_info * gpe_block)169 acpi_ev_create_gpe_info_blocks(struct acpi_gpe_block_info *gpe_block)
170 {
171 	struct acpi_gpe_register_info *gpe_register_info = NULL;
172 	struct acpi_gpe_event_info *gpe_event_info = NULL;
173 	struct acpi_gpe_event_info *this_event;
174 	struct acpi_gpe_register_info *this_register;
175 	u32 i;
176 	u32 j;
177 	acpi_status status;
178 
179 	ACPI_FUNCTION_TRACE(ev_create_gpe_info_blocks);
180 
181 	/* Allocate the GPE register information block */
182 
183 	gpe_register_info = ACPI_ALLOCATE_ZEROED((acpi_size)gpe_block->
184 						 register_count *
185 						 sizeof(struct
186 							acpi_gpe_register_info));
187 	if (!gpe_register_info) {
188 		ACPI_ERROR((AE_INFO,
189 			    "Could not allocate the GpeRegisterInfo table"));
190 		return_ACPI_STATUS(AE_NO_MEMORY);
191 	}
192 
193 	/*
194 	 * Allocate the GPE event_info block. There are eight distinct GPEs
195 	 * per register. Initialization to zeros is sufficient.
196 	 */
197 	gpe_event_info = ACPI_ALLOCATE_ZEROED((acpi_size)gpe_block->gpe_count *
198 					      sizeof(struct
199 						     acpi_gpe_event_info));
200 	if (!gpe_event_info) {
201 		ACPI_ERROR((AE_INFO,
202 			    "Could not allocate the GpeEventInfo table"));
203 		status = AE_NO_MEMORY;
204 		goto error_exit;
205 	}
206 
207 	/* Save the new Info arrays in the GPE block */
208 
209 	gpe_block->register_info = gpe_register_info;
210 	gpe_block->event_info = gpe_event_info;
211 
212 	/*
213 	 * Initialize the GPE Register and Event structures. A goal of these
214 	 * tables is to hide the fact that there are two separate GPE register
215 	 * sets in a given GPE hardware block, the status registers occupy the
216 	 * first half, and the enable registers occupy the second half.
217 	 */
218 	this_register = gpe_register_info;
219 	this_event = gpe_event_info;
220 
221 	for (i = 0; i < gpe_block->register_count; i++) {
222 
223 		/* Init the register_info for this GPE register (8 GPEs) */
224 
225 		this_register->base_gpe_number = (u16)
226 		    (gpe_block->block_base_number +
227 		     (i * ACPI_GPE_REGISTER_WIDTH));
228 
229 		this_register->status_address.address = gpe_block->address + i;
230 
231 		this_register->enable_address.address =
232 		    gpe_block->address + i + gpe_block->register_count;
233 
234 		this_register->status_address.space_id = gpe_block->space_id;
235 		this_register->enable_address.space_id = gpe_block->space_id;
236 
237 		/* Init the event_info for each GPE within this register */
238 
239 		for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++) {
240 			this_event->gpe_number =
241 			    (u8) (this_register->base_gpe_number + j);
242 			this_event->register_info = this_register;
243 			this_event++;
244 		}
245 
246 		/* Disable all GPEs within this register */
247 
248 		status = acpi_hw_gpe_write(0x00, &this_register->enable_address);
249 		if (ACPI_FAILURE(status)) {
250 			goto error_exit;
251 		}
252 
253 		/* Clear any pending GPE events within this register */
254 
255 		status = acpi_hw_gpe_write(0xFF, &this_register->status_address);
256 		if (ACPI_FAILURE(status)) {
257 			goto error_exit;
258 		}
259 
260 		this_register++;
261 	}
262 
263 	return_ACPI_STATUS(AE_OK);
264 
265 error_exit:
266 	if (gpe_register_info) {
267 		ACPI_FREE(gpe_register_info);
268 	}
269 	if (gpe_event_info) {
270 		ACPI_FREE(gpe_event_info);
271 	}
272 
273 	return_ACPI_STATUS(status);
274 }
275 
276 /*******************************************************************************
277  *
278  * FUNCTION:    acpi_ev_create_gpe_block
279  *
280  * PARAMETERS:  gpe_device          - Handle to the parent GPE block
281  *              gpe_block_address   - Address and space_ID
282  *              register_count      - Number of GPE register pairs in the block
283  *              gpe_block_base_number - Starting GPE number for the block
284  *              interrupt_number    - H/W interrupt for the block
285  *              return_gpe_block    - Where the new block descriptor is returned
286  *
287  * RETURN:      Status
288  *
289  * DESCRIPTION: Create and Install a block of GPE registers. All GPEs within
290  *              the block are disabled at exit.
291  *              Note: Assumes namespace is locked.
292  *
293  ******************************************************************************/
294 
295 acpi_status
acpi_ev_create_gpe_block(struct acpi_namespace_node * gpe_device,u64 address,u8 space_id,u32 register_count,u16 gpe_block_base_number,u32 interrupt_number,struct acpi_gpe_block_info ** return_gpe_block)296 acpi_ev_create_gpe_block(struct acpi_namespace_node *gpe_device,
297 			 u64 address,
298 			 u8 space_id,
299 			 u32 register_count,
300 			 u16 gpe_block_base_number,
301 			 u32 interrupt_number,
302 			 struct acpi_gpe_block_info **return_gpe_block)
303 {
304 	acpi_status status;
305 	struct acpi_gpe_block_info *gpe_block;
306 	struct acpi_gpe_walk_info walk_info;
307 
308 	ACPI_FUNCTION_TRACE(ev_create_gpe_block);
309 
310 	if (!register_count) {
311 		return_ACPI_STATUS(AE_OK);
312 	}
313 
314 	/* Validate the space_ID */
315 
316 	if ((space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY) &&
317 	    (space_id != ACPI_ADR_SPACE_SYSTEM_IO)) {
318 		ACPI_ERROR((AE_INFO,
319 			    "Unsupported address space: 0x%X", space_id));
320 		return_ACPI_STATUS(AE_SUPPORT);
321 	}
322 
323 	if (space_id == ACPI_ADR_SPACE_SYSTEM_IO) {
324 		status = acpi_hw_validate_io_block(address,
325 						   ACPI_GPE_REGISTER_WIDTH,
326 						   register_count);
327 		if (ACPI_FAILURE(status))
328 			return_ACPI_STATUS(status);
329 	}
330 
331 	/* Allocate a new GPE block */
332 
333 	gpe_block = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_gpe_block_info));
334 	if (!gpe_block) {
335 		return_ACPI_STATUS(AE_NO_MEMORY);
336 	}
337 
338 	/* Initialize the new GPE block */
339 
340 	gpe_block->address = address;
341 	gpe_block->space_id = space_id;
342 	gpe_block->node = gpe_device;
343 	gpe_block->gpe_count = (u16)(register_count * ACPI_GPE_REGISTER_WIDTH);
344 	gpe_block->initialized = FALSE;
345 	gpe_block->register_count = register_count;
346 	gpe_block->block_base_number = gpe_block_base_number;
347 
348 	/*
349 	 * Create the register_info and event_info sub-structures
350 	 * Note: disables and clears all GPEs in the block
351 	 */
352 	status = acpi_ev_create_gpe_info_blocks(gpe_block);
353 	if (ACPI_FAILURE(status)) {
354 		ACPI_FREE(gpe_block);
355 		return_ACPI_STATUS(status);
356 	}
357 
358 	/* Install the new block in the global lists */
359 
360 	status = acpi_ev_install_gpe_block(gpe_block, interrupt_number);
361 	if (ACPI_FAILURE(status)) {
362 		ACPI_FREE(gpe_block->register_info);
363 		ACPI_FREE(gpe_block->event_info);
364 		ACPI_FREE(gpe_block);
365 		return_ACPI_STATUS(status);
366 	}
367 
368 	acpi_gbl_all_gpes_initialized = FALSE;
369 
370 	/* Find all GPE methods (_Lxx or_Exx) for this block */
371 
372 	walk_info.gpe_block = gpe_block;
373 	walk_info.gpe_device = gpe_device;
374 	walk_info.execute_by_owner_id = FALSE;
375 
376 	(void)acpi_ns_walk_namespace(ACPI_TYPE_METHOD, gpe_device,
377 				     ACPI_UINT32_MAX, ACPI_NS_WALK_NO_UNLOCK,
378 				     acpi_ev_match_gpe_method, NULL, &walk_info,
379 				     NULL);
380 
381 	/* Return the new block */
382 
383 	if (return_gpe_block) {
384 		(*return_gpe_block) = gpe_block;
385 	}
386 
387 	ACPI_DEBUG_PRINT_RAW((ACPI_DB_INIT,
388 			      "    Initialized GPE %02X to %02X [%4.4s] %u regs on interrupt 0x%X%s\n",
389 			      (u32)gpe_block->block_base_number,
390 			      (u32)(gpe_block->block_base_number +
391 				    (gpe_block->gpe_count - 1)),
392 			      gpe_device->name.ascii, gpe_block->register_count,
393 			      interrupt_number,
394 			      interrupt_number ==
395 			      acpi_gbl_FADT.sci_interrupt ? " (SCI)" : ""));
396 
397 	/* Update global count of currently available GPEs */
398 
399 	acpi_current_gpe_count += gpe_block->gpe_count;
400 	return_ACPI_STATUS(AE_OK);
401 }
402 
403 /*******************************************************************************
404  *
405  * FUNCTION:    acpi_ev_initialize_gpe_block
406  *
407  * PARAMETERS:  acpi_gpe_callback
408  *
409  * RETURN:      Status
410  *
411  * DESCRIPTION: Initialize and enable a GPE block. Enable GPEs that have
412  *              associated methods.
413  *              Note: Assumes namespace is locked.
414  *
415  ******************************************************************************/
416 
417 acpi_status
acpi_ev_initialize_gpe_block(struct acpi_gpe_xrupt_info * gpe_xrupt_info,struct acpi_gpe_block_info * gpe_block,void * context)418 acpi_ev_initialize_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
419 			     struct acpi_gpe_block_info *gpe_block,
420 			     void *context)
421 {
422 	acpi_status status;
423 	struct acpi_gpe_event_info *gpe_event_info;
424 	u32 gpe_enabled_count;
425 	u32 gpe_index;
426 	u32 i;
427 	u32 j;
428 	u8 *is_polling_needed = context;
429 	ACPI_ERROR_ONLY(u32 gpe_number);
430 
431 	ACPI_FUNCTION_TRACE(ev_initialize_gpe_block);
432 
433 	/*
434 	 * Ignore a null GPE block (e.g., if no GPE block 1 exists), and
435 	 * any GPE blocks that have been initialized already.
436 	 */
437 	if (!gpe_block || gpe_block->initialized) {
438 		return_ACPI_STATUS(AE_OK);
439 	}
440 
441 	/*
442 	 * Enable all GPEs that have a corresponding method and have the
443 	 * ACPI_GPE_CAN_WAKE flag unset. Any other GPEs within this block
444 	 * must be enabled via the acpi_enable_gpe() interface.
445 	 */
446 	gpe_enabled_count = 0;
447 
448 	for (i = 0; i < gpe_block->register_count; i++) {
449 		for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++) {
450 
451 			/* Get the info block for this particular GPE */
452 
453 			gpe_index = (i * ACPI_GPE_REGISTER_WIDTH) + j;
454 			gpe_event_info = &gpe_block->event_info[gpe_index];
455 			ACPI_ERROR_ONLY(gpe_number =
456 					gpe_block->block_base_number +
457 					gpe_index);
458 			gpe_event_info->flags |= ACPI_GPE_INITIALIZED;
459 
460 			/*
461 			 * Ignore GPEs that have no corresponding _Lxx/_Exx method
462 			 * and GPEs that are used for wakeup
463 			 */
464 			if ((ACPI_GPE_DISPATCH_TYPE(gpe_event_info->flags) !=
465 			     ACPI_GPE_DISPATCH_METHOD)
466 			    || (gpe_event_info->flags & ACPI_GPE_CAN_WAKE)) {
467 				continue;
468 			}
469 
470 			status = acpi_ev_add_gpe_reference(gpe_event_info, FALSE);
471 			if (ACPI_FAILURE(status)) {
472 				ACPI_EXCEPTION((AE_INFO, status,
473 					"Could not enable GPE 0x%02X",
474 					gpe_number));
475 				continue;
476 			}
477 
478 			gpe_event_info->flags |= ACPI_GPE_AUTO_ENABLED;
479 
480 			if (is_polling_needed &&
481 			    ACPI_GPE_IS_POLLING_NEEDED(gpe_event_info)) {
482 				*is_polling_needed = TRUE;
483 			}
484 
485 			gpe_enabled_count++;
486 		}
487 	}
488 
489 	if (gpe_enabled_count) {
490 		ACPI_INFO(("Enabled %u GPEs in block %02X to %02X",
491 			   gpe_enabled_count, (u32)gpe_block->block_base_number,
492 			   (u32)(gpe_block->block_base_number +
493 				 (gpe_block->gpe_count - 1))));
494 	}
495 
496 	gpe_block->initialized = TRUE;
497 
498 	return_ACPI_STATUS(AE_OK);
499 }
500 
501 #endif				/* !ACPI_REDUCED_HARDWARE */
502