1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 /******************************************************************************
3  *
4  * Module Name: evevent - Fixed Event handling and dispatch
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 
14 #define _COMPONENT          ACPI_EVENTS
15 ACPI_MODULE_NAME("evevent")
16 #if (!ACPI_REDUCED_HARDWARE)	/* Entire module */
17 /* Local prototypes */
18 static acpi_status acpi_ev_fixed_event_initialize(void);
19 
20 static u32 acpi_ev_fixed_event_dispatch(u32 event);
21 
22 /*******************************************************************************
23  *
24  * FUNCTION:    acpi_ev_initialize_events
25  *
26  * PARAMETERS:  None
27  *
28  * RETURN:      Status
29  *
30  * DESCRIPTION: Initialize global data structures for ACPI events (Fixed, GPE)
31  *
32  ******************************************************************************/
33 
acpi_ev_initialize_events(void)34 acpi_status acpi_ev_initialize_events(void)
35 {
36 	acpi_status status;
37 
38 	ACPI_FUNCTION_TRACE(ev_initialize_events);
39 
40 	/* If Hardware Reduced flag is set, there are no fixed events */
41 
42 	if (acpi_gbl_reduced_hardware) {
43 		return_ACPI_STATUS(AE_OK);
44 	}
45 
46 	/*
47 	 * Initialize the Fixed and General Purpose Events. This is done prior to
48 	 * enabling SCIs to prevent interrupts from occurring before the handlers
49 	 * are installed.
50 	 */
51 	status = acpi_ev_fixed_event_initialize();
52 	if (ACPI_FAILURE(status)) {
53 		ACPI_EXCEPTION((AE_INFO, status,
54 				"Unable to initialize fixed events"));
55 		return_ACPI_STATUS(status);
56 	}
57 
58 	status = acpi_ev_gpe_initialize();
59 	if (ACPI_FAILURE(status)) {
60 		ACPI_EXCEPTION((AE_INFO, status,
61 				"Unable to initialize general purpose events"));
62 		return_ACPI_STATUS(status);
63 	}
64 
65 	return_ACPI_STATUS(status);
66 }
67 
68 /*******************************************************************************
69  *
70  * FUNCTION:    acpi_ev_install_xrupt_handlers
71  *
72  * PARAMETERS:  None
73  *
74  * RETURN:      Status
75  *
76  * DESCRIPTION: Install interrupt handlers for the SCI and Global Lock
77  *
78  ******************************************************************************/
79 
acpi_ev_install_xrupt_handlers(void)80 acpi_status acpi_ev_install_xrupt_handlers(void)
81 {
82 	acpi_status status;
83 
84 	ACPI_FUNCTION_TRACE(ev_install_xrupt_handlers);
85 
86 	/* If Hardware Reduced flag is set, there is no ACPI h/w */
87 
88 	if (acpi_gbl_reduced_hardware) {
89 		return_ACPI_STATUS(AE_OK);
90 	}
91 
92 	/* Install the SCI handler */
93 
94 	status = acpi_ev_install_sci_handler();
95 	if (ACPI_FAILURE(status)) {
96 		ACPI_EXCEPTION((AE_INFO, status,
97 				"Unable to install System Control Interrupt handler"));
98 		return_ACPI_STATUS(status);
99 	}
100 
101 	/* Install the handler for the Global Lock */
102 
103 	status = acpi_ev_init_global_lock_handler();
104 	if (ACPI_FAILURE(status)) {
105 		ACPI_EXCEPTION((AE_INFO, status,
106 				"Unable to initialize Global Lock handler"));
107 		return_ACPI_STATUS(status);
108 	}
109 
110 	acpi_gbl_events_initialized = TRUE;
111 	return_ACPI_STATUS(status);
112 }
113 
114 /*******************************************************************************
115  *
116  * FUNCTION:    acpi_ev_fixed_event_initialize
117  *
118  * PARAMETERS:  None
119  *
120  * RETURN:      Status
121  *
122  * DESCRIPTION: Install the fixed event handlers and disable all fixed events.
123  *
124  ******************************************************************************/
125 
acpi_ev_fixed_event_initialize(void)126 static acpi_status acpi_ev_fixed_event_initialize(void)
127 {
128 	u32 i;
129 	acpi_status status;
130 
131 	/*
132 	 * Initialize the structure that keeps track of fixed event handlers and
133 	 * disable all of the fixed events.
134 	 */
135 	for (i = 0; i < ACPI_NUM_FIXED_EVENTS; i++) {
136 		acpi_gbl_fixed_event_handlers[i].handler = NULL;
137 		acpi_gbl_fixed_event_handlers[i].context = NULL;
138 
139 		/* Disable the fixed event */
140 
141 		if (acpi_gbl_fixed_event_info[i].enable_register_id != 0xFF) {
142 			status =
143 			    acpi_write_bit_register(acpi_gbl_fixed_event_info
144 						    [i].enable_register_id,
145 						    ACPI_DISABLE_EVENT);
146 			if (ACPI_FAILURE(status)) {
147 				return (status);
148 			}
149 		}
150 	}
151 
152 	return (AE_OK);
153 }
154 
155 /*******************************************************************************
156  *
157  * FUNCTION:    acpi_ev_fixed_event_detect
158  *
159  * PARAMETERS:  None
160  *
161  * RETURN:      INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED
162  *
163  * DESCRIPTION: Checks the PM status register for active fixed events
164  *
165  ******************************************************************************/
166 
acpi_ev_fixed_event_detect(void)167 u32 acpi_ev_fixed_event_detect(void)
168 {
169 	u32 int_status = ACPI_INTERRUPT_NOT_HANDLED;
170 	u32 fixed_status;
171 	u32 fixed_enable;
172 	u32 i;
173 	acpi_status status;
174 
175 	ACPI_FUNCTION_NAME(ev_fixed_event_detect);
176 
177 	/*
178 	 * Read the fixed feature status and enable registers, as all the cases
179 	 * depend on their values. Ignore errors here.
180 	 */
181 	status = acpi_hw_register_read(ACPI_REGISTER_PM1_STATUS, &fixed_status);
182 	status |=
183 	    acpi_hw_register_read(ACPI_REGISTER_PM1_ENABLE, &fixed_enable);
184 	if (ACPI_FAILURE(status)) {
185 		return (int_status);
186 	}
187 
188 	ACPI_DEBUG_PRINT((ACPI_DB_INTERRUPTS,
189 			  "Fixed Event Block: Enable %08X Status %08X\n",
190 			  fixed_enable, fixed_status));
191 
192 	/*
193 	 * Check for all possible Fixed Events and dispatch those that are active
194 	 */
195 	for (i = 0; i < ACPI_NUM_FIXED_EVENTS; i++) {
196 
197 		/* Both the status and enable bits must be on for this event */
198 
199 		if ((fixed_status & acpi_gbl_fixed_event_info[i].
200 		     status_bit_mask)
201 		    && (fixed_enable & acpi_gbl_fixed_event_info[i].
202 			enable_bit_mask)) {
203 			/*
204 			 * Found an active (signalled) event. Invoke global event
205 			 * handler if present.
206 			 */
207 			acpi_fixed_event_count[i]++;
208 			if (acpi_gbl_global_event_handler) {
209 				acpi_gbl_global_event_handler
210 				    (ACPI_EVENT_TYPE_FIXED, NULL, i,
211 				     acpi_gbl_global_event_handler_context);
212 			}
213 
214 			int_status |= acpi_ev_fixed_event_dispatch(i);
215 		}
216 	}
217 
218 	return (int_status);
219 }
220 
221 /*******************************************************************************
222  *
223  * FUNCTION:    acpi_ev_fixed_event_dispatch
224  *
225  * PARAMETERS:  event               - Event type
226  *
227  * RETURN:      INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED
228  *
229  * DESCRIPTION: Clears the status bit for the requested event, calls the
230  *              handler that previously registered for the event.
231  *              NOTE: If there is no handler for the event, the event is
232  *              disabled to prevent further interrupts.
233  *
234  ******************************************************************************/
235 
acpi_ev_fixed_event_dispatch(u32 event)236 static u32 acpi_ev_fixed_event_dispatch(u32 event)
237 {
238 
239 	ACPI_FUNCTION_ENTRY();
240 
241 	/* Clear the status bit */
242 
243 	(void)acpi_write_bit_register(acpi_gbl_fixed_event_info[event].
244 				      status_register_id, ACPI_CLEAR_STATUS);
245 
246 	/*
247 	 * Make sure that a handler exists. If not, report an error
248 	 * and disable the event to prevent further interrupts.
249 	 */
250 	if (!acpi_gbl_fixed_event_handlers[event].handler) {
251 		(void)acpi_write_bit_register(acpi_gbl_fixed_event_info[event].
252 					      enable_register_id,
253 					      ACPI_DISABLE_EVENT);
254 
255 		ACPI_ERROR((AE_INFO,
256 			    "No installed handler for fixed event - %s (%u), disabling",
257 			    acpi_ut_get_event_name(event), event));
258 
259 		return (ACPI_INTERRUPT_NOT_HANDLED);
260 	}
261 
262 	/* Invoke the Fixed Event handler */
263 
264 	return ((acpi_gbl_fixed_event_handlers[event].
265 		 handler) (acpi_gbl_fixed_event_handlers[event].context));
266 }
267 
268 /*******************************************************************************
269  *
270  * FUNCTION:    acpi_any_fixed_event_status_set
271  *
272  * PARAMETERS:  None
273  *
274  * RETURN:      TRUE or FALSE
275  *
276  * DESCRIPTION: Checks the PM status register for active fixed events
277  *
278  ******************************************************************************/
279 
acpi_any_fixed_event_status_set(void)280 u32 acpi_any_fixed_event_status_set(void)
281 {
282 	acpi_status status;
283 	u32 in_status;
284 	u32 in_enable;
285 	u32 i;
286 
287 	status = acpi_hw_register_read(ACPI_REGISTER_PM1_ENABLE, &in_enable);
288 	if (ACPI_FAILURE(status)) {
289 		return (FALSE);
290 	}
291 
292 	status = acpi_hw_register_read(ACPI_REGISTER_PM1_STATUS, &in_status);
293 	if (ACPI_FAILURE(status)) {
294 		return (FALSE);
295 	}
296 
297 	/*
298 	 * Check for all possible Fixed Events and dispatch those that are active
299 	 */
300 	for (i = 0; i < ACPI_NUM_FIXED_EVENTS; i++) {
301 
302 		/* Both the status and enable bits must be on for this event */
303 
304 		if ((in_status & acpi_gbl_fixed_event_info[i].status_bit_mask) &&
305 		    (in_enable & acpi_gbl_fixed_event_info[i].enable_bit_mask)) {
306 			return (TRUE);
307 		}
308 	}
309 
310 	return (FALSE);
311 }
312 
313 #endif				/* !ACPI_REDUCED_HARDWARE */
314