1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 /******************************************************************************
3  *
4  * Module Name: evxfregn - External Interfaces, ACPI Operation Regions and
5  *                         Address Spaces.
6  *
7  * Copyright (C) 2000 - 2023, Intel Corp.
8  *
9  *****************************************************************************/
10 
11 #define EXPORT_ACPI_INTERFACES
12 
13 #include <acpi/acpi.h>
14 #include "accommon.h"
15 #include "acnamesp.h"
16 #include "acevents.h"
17 
18 #define _COMPONENT          ACPI_EVENTS
19 ACPI_MODULE_NAME("evxfregn")
20 
21 /*******************************************************************************
22  *
23  * FUNCTION:    acpi_install_address_space_handler_internal
24  *
25  * PARAMETERS:  device          - Handle for the device
26  *              space_id        - The address space ID
27  *              handler         - Address of the handler
28  *              setup           - Address of the setup function
29  *              context         - Value passed to the handler on each access
30  *              Run_reg         - Run _REG methods for this address space?
31  *
32  * RETURN:      Status
33  *
34  * DESCRIPTION: Install a handler for all op_regions of a given space_id.
35  *
36  * NOTE: This function should only be called after acpi_enable_subsystem has
37  * been called. This is because any _REG methods associated with the Space ID
38  * are executed here, and these methods can only be safely executed after
39  * the default handlers have been installed and the hardware has been
40  * initialized (via acpi_enable_subsystem.)
41  * To avoid this problem pass FALSE for Run_Reg and later on call
42  * acpi_execute_reg_methods() to execute _REG.
43  *
44  ******************************************************************************/
45 static acpi_status
acpi_install_address_space_handler_internal(acpi_handle device,acpi_adr_space_type space_id,acpi_adr_space_handler handler,acpi_adr_space_setup setup,void * context,u8 run_reg)46 acpi_install_address_space_handler_internal(acpi_handle device,
47 					    acpi_adr_space_type space_id,
48 					    acpi_adr_space_handler handler,
49 					    acpi_adr_space_setup setup,
50 					    void *context, u8 run_reg)
51 {
52 	struct acpi_namespace_node *node;
53 	acpi_status status;
54 
55 	ACPI_FUNCTION_TRACE(acpi_install_address_space_handler);
56 
57 	/* Parameter validation */
58 
59 	if (!device) {
60 		return_ACPI_STATUS(AE_BAD_PARAMETER);
61 	}
62 
63 	status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
64 	if (ACPI_FAILURE(status)) {
65 		return_ACPI_STATUS(status);
66 	}
67 
68 	/* Convert and validate the device handle */
69 
70 	node = acpi_ns_validate_handle(device);
71 	if (!node) {
72 		status = AE_BAD_PARAMETER;
73 		goto unlock_and_exit;
74 	}
75 
76 	/* Install the handler for all Regions for this Space ID */
77 
78 	status =
79 	    acpi_ev_install_space_handler(node, space_id, handler, setup,
80 					  context);
81 	if (ACPI_FAILURE(status)) {
82 		goto unlock_and_exit;
83 	}
84 
85 	/* Run all _REG methods for this address space */
86 
87 	if (run_reg) {
88 		acpi_ev_execute_reg_methods(node, space_id, ACPI_REG_CONNECT);
89 	}
90 
91 unlock_and_exit:
92 	(void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
93 	return_ACPI_STATUS(status);
94 }
95 
96 acpi_status
acpi_install_address_space_handler(acpi_handle device,acpi_adr_space_type space_id,acpi_adr_space_handler handler,acpi_adr_space_setup setup,void * context)97 acpi_install_address_space_handler(acpi_handle device,
98 				   acpi_adr_space_type space_id,
99 				   acpi_adr_space_handler handler,
100 				   acpi_adr_space_setup setup, void *context)
101 {
102 	return acpi_install_address_space_handler_internal(device, space_id,
103 							   handler, setup,
104 							   context, TRUE);
105 }
106 
ACPI_EXPORT_SYMBOL(acpi_install_address_space_handler)107 ACPI_EXPORT_SYMBOL(acpi_install_address_space_handler)
108 acpi_status
109 acpi_install_address_space_handler_no_reg(acpi_handle device,
110 					  acpi_adr_space_type space_id,
111 					  acpi_adr_space_handler handler,
112 					  acpi_adr_space_setup setup,
113 					  void *context)
114 {
115 	return acpi_install_address_space_handler_internal(device, space_id,
116 							   handler, setup,
117 							   context, FALSE);
118 }
119 
ACPI_EXPORT_SYMBOL(acpi_install_address_space_handler_no_reg)120 ACPI_EXPORT_SYMBOL(acpi_install_address_space_handler_no_reg)
121 
122 /*******************************************************************************
123  *
124  * FUNCTION:    acpi_remove_address_space_handler
125  *
126  * PARAMETERS:  device          - Handle for the device
127  *              space_id        - The address space ID
128  *              handler         - Address of the handler
129  *
130  * RETURN:      Status
131  *
132  * DESCRIPTION: Remove a previously installed handler.
133  *
134  ******************************************************************************/
135 acpi_status
136 acpi_remove_address_space_handler(acpi_handle device,
137 				  acpi_adr_space_type space_id,
138 				  acpi_adr_space_handler handler)
139 {
140 	union acpi_operand_object *obj_desc;
141 	union acpi_operand_object *handler_obj;
142 	union acpi_operand_object *region_obj;
143 	union acpi_operand_object **last_obj_ptr;
144 	struct acpi_namespace_node *node;
145 	acpi_status status;
146 
147 	ACPI_FUNCTION_TRACE(acpi_remove_address_space_handler);
148 
149 	/* Parameter validation */
150 
151 	if (!device) {
152 		return_ACPI_STATUS(AE_BAD_PARAMETER);
153 	}
154 
155 	status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
156 	if (ACPI_FAILURE(status)) {
157 		return_ACPI_STATUS(status);
158 	}
159 
160 	/* Convert and validate the device handle */
161 
162 	node = acpi_ns_validate_handle(device);
163 	if (!node ||
164 	    ((node->type != ACPI_TYPE_DEVICE) &&
165 	     (node->type != ACPI_TYPE_PROCESSOR) &&
166 	     (node->type != ACPI_TYPE_THERMAL) &&
167 	     (node != acpi_gbl_root_node))) {
168 		status = AE_BAD_PARAMETER;
169 		goto unlock_and_exit;
170 	}
171 
172 	/* Make sure the internal object exists */
173 
174 	obj_desc = acpi_ns_get_attached_object(node);
175 	if (!obj_desc) {
176 		status = AE_NOT_EXIST;
177 		goto unlock_and_exit;
178 	}
179 
180 	/* Find the address handler the user requested */
181 
182 	handler_obj = obj_desc->common_notify.handler;
183 	last_obj_ptr = &obj_desc->common_notify.handler;
184 	while (handler_obj) {
185 
186 		/* We have a handler, see if user requested this one */
187 
188 		if (handler_obj->address_space.space_id == space_id) {
189 
190 			/* Handler must be the same as the installed handler */
191 
192 			if (handler_obj->address_space.handler != handler) {
193 				status = AE_BAD_PARAMETER;
194 				goto unlock_and_exit;
195 			}
196 
197 			/* Matched space_id, first dereference this in the Regions */
198 
199 			ACPI_DEBUG_PRINT((ACPI_DB_OPREGION,
200 					  "Removing address handler %p(%p) for region %s "
201 					  "on Device %p(%p)\n",
202 					  handler_obj, handler,
203 					  acpi_ut_get_region_name(space_id),
204 					  node, obj_desc));
205 
206 			region_obj = handler_obj->address_space.region_list;
207 
208 			/* Walk the handler's region list */
209 
210 			while (region_obj) {
211 				/*
212 				 * First disassociate the handler from the region.
213 				 *
214 				 * NOTE: this doesn't mean that the region goes away
215 				 * The region is just inaccessible as indicated to
216 				 * the _REG method
217 				 */
218 				acpi_ev_detach_region(region_obj, TRUE);
219 
220 				/*
221 				 * Walk the list: Just grab the head because the
222 				 * detach_region removed the previous head.
223 				 */
224 				region_obj =
225 				    handler_obj->address_space.region_list;
226 			}
227 
228 			/* Remove this Handler object from the list */
229 
230 			*last_obj_ptr = handler_obj->address_space.next;
231 
232 			/* Now we can delete the handler object */
233 
234 			acpi_os_release_mutex(handler_obj->address_space.
235 					      context_mutex);
236 			acpi_ut_remove_reference(handler_obj);
237 			goto unlock_and_exit;
238 		}
239 
240 		/* Walk the linked list of handlers */
241 
242 		last_obj_ptr = &handler_obj->address_space.next;
243 		handler_obj = handler_obj->address_space.next;
244 	}
245 
246 	/* The handler does not exist */
247 
248 	ACPI_DEBUG_PRINT((ACPI_DB_OPREGION,
249 			  "Unable to remove address handler %p for %s(%X), DevNode %p, obj %p\n",
250 			  handler, acpi_ut_get_region_name(space_id), space_id,
251 			  node, obj_desc));
252 
253 	status = AE_NOT_EXIST;
254 
255 unlock_and_exit:
256 	(void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
257 	return_ACPI_STATUS(status);
258 }
259 
ACPI_EXPORT_SYMBOL(acpi_remove_address_space_handler)260 ACPI_EXPORT_SYMBOL(acpi_remove_address_space_handler)
261 /*******************************************************************************
262  *
263  * FUNCTION:    acpi_execute_reg_methods
264  *
265  * PARAMETERS:  device          - Handle for the device
266  *              space_id        - The address space ID
267  *
268  * RETURN:      Status
269  *
270  * DESCRIPTION: Execute _REG for all op_regions of a given space_id.
271  *
272  ******************************************************************************/
273 acpi_status
274 acpi_execute_reg_methods(acpi_handle device, acpi_adr_space_type space_id)
275 {
276 	struct acpi_namespace_node *node;
277 	acpi_status status;
278 
279 	ACPI_FUNCTION_TRACE(acpi_execute_reg_methods);
280 
281 	/* Parameter validation */
282 
283 	if (!device) {
284 		return_ACPI_STATUS(AE_BAD_PARAMETER);
285 	}
286 
287 	status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
288 	if (ACPI_FAILURE(status)) {
289 		return_ACPI_STATUS(status);
290 	}
291 
292 	/* Convert and validate the device handle */
293 
294 	node = acpi_ns_validate_handle(device);
295 	if (node) {
296 
297 		/* Run all _REG methods for this address space */
298 
299 		acpi_ev_execute_reg_methods(node, space_id, ACPI_REG_CONNECT);
300 	} else {
301 		status = AE_BAD_PARAMETER;
302 	}
303 
304 	(void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
305 	return_ACPI_STATUS(status);
306 }
307 
308 ACPI_EXPORT_SYMBOL(acpi_execute_reg_methods)
309