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
19ACPI_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 ******************************************************************************/
45static acpi_status
46acpi_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
91unlock_and_exit:
92	(void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
93	return_ACPI_STATUS(status);
94}
95
96acpi_status
97acpi_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
107ACPI_EXPORT_SYMBOL(acpi_install_address_space_handler)
108acpi_status
109acpi_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
120ACPI_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 ******************************************************************************/
135acpi_status
136acpi_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
255unlock_and_exit:
256	(void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
257	return_ACPI_STATUS(status);
258}
259
260ACPI_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 ******************************************************************************/
273acpi_status
274acpi_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
308ACPI_EXPORT_SYMBOL(acpi_execute_reg_methods)
309