• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 /******************************************************************************
3  *
4  * Module Name: evrgnini- ACPI address_space (op_region) init
5  *
6  * Copyright (C) 2000 - 2021, Intel Corp.
7  *
8  *****************************************************************************/
9 
10 #include <acpi/acpi.h>
11 #include "accommon.h"
12 #include "acevents.h"
13 #include "acnamesp.h"
14 #include "acinterp.h"
15 
16 #define _COMPONENT          ACPI_EVENTS
17 ACPI_MODULE_NAME("evrgnini")
18 
19 /*******************************************************************************
20  *
21  * FUNCTION:    acpi_ev_system_memory_region_setup
22  *
23  * PARAMETERS:  handle              - Region we are interested in
24  *              function            - Start or stop
25  *              handler_context     - Address space handler context
26  *              region_context      - Region specific context
27  *
28  * RETURN:      Status
29  *
30  * DESCRIPTION: Setup a system_memory operation region
31  *
32  ******************************************************************************/
33 acpi_status
acpi_ev_system_memory_region_setup(acpi_handle handle,u32 function,void * handler_context,void ** region_context)34 acpi_ev_system_memory_region_setup(acpi_handle handle,
35 				   u32 function,
36 				   void *handler_context, void **region_context)
37 {
38 	union acpi_operand_object *region_desc =
39 	    (union acpi_operand_object *)handle;
40 	struct acpi_mem_space_context *local_region_context;
41 	struct acpi_mem_mapping *mm;
42 
43 	ACPI_FUNCTION_TRACE(ev_system_memory_region_setup);
44 
45 	if (function == ACPI_REGION_DEACTIVATE) {
46 		if (*region_context) {
47 			local_region_context =
48 			    (struct acpi_mem_space_context *)*region_context;
49 
50 			/* Delete memory mappings if present */
51 
52 			while (local_region_context->first_mm) {
53 				mm = local_region_context->first_mm;
54 				local_region_context->first_mm = mm->next_mm;
55 				acpi_os_unmap_memory(mm->logical_address,
56 						     mm->length);
57 				ACPI_FREE(mm);
58 			}
59 			ACPI_FREE(local_region_context);
60 			*region_context = NULL;
61 		}
62 		return_ACPI_STATUS(AE_OK);
63 	}
64 
65 	/* Create a new context */
66 
67 	local_region_context =
68 	    ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_mem_space_context));
69 	if (!(local_region_context)) {
70 		return_ACPI_STATUS(AE_NO_MEMORY);
71 	}
72 
73 	/* Save the region length and address for use in the handler */
74 
75 	local_region_context->length = region_desc->region.length;
76 	local_region_context->address = region_desc->region.address;
77 
78 	*region_context = local_region_context;
79 	return_ACPI_STATUS(AE_OK);
80 }
81 
82 /*******************************************************************************
83  *
84  * FUNCTION:    acpi_ev_io_space_region_setup
85  *
86  * PARAMETERS:  handle              - Region we are interested in
87  *              function            - Start or stop
88  *              handler_context     - Address space handler context
89  *              region_context      - Region specific context
90  *
91  * RETURN:      Status
92  *
93  * DESCRIPTION: Setup a IO operation region
94  *
95  ******************************************************************************/
96 
97 acpi_status
acpi_ev_io_space_region_setup(acpi_handle handle,u32 function,void * handler_context,void ** region_context)98 acpi_ev_io_space_region_setup(acpi_handle handle,
99 			      u32 function,
100 			      void *handler_context, void **region_context)
101 {
102 	ACPI_FUNCTION_TRACE(ev_io_space_region_setup);
103 
104 	if (function == ACPI_REGION_DEACTIVATE) {
105 		*region_context = NULL;
106 	} else {
107 		*region_context = handler_context;
108 	}
109 
110 	return_ACPI_STATUS(AE_OK);
111 }
112 
113 /*******************************************************************************
114  *
115  * FUNCTION:    acpi_ev_pci_config_region_setup
116  *
117  * PARAMETERS:  handle              - Region we are interested in
118  *              function            - Start or stop
119  *              handler_context     - Address space handler context
120  *              region_context      - Region specific context
121  *
122  * RETURN:      Status
123  *
124  * DESCRIPTION: Setup a PCI_Config operation region
125  *
126  * MUTEX:       Assumes namespace is not locked
127  *
128  ******************************************************************************/
129 
130 acpi_status
acpi_ev_pci_config_region_setup(acpi_handle handle,u32 function,void * handler_context,void ** region_context)131 acpi_ev_pci_config_region_setup(acpi_handle handle,
132 				u32 function,
133 				void *handler_context, void **region_context)
134 {
135 	acpi_status status = AE_OK;
136 	u64 pci_value;
137 	struct acpi_pci_id *pci_id = *region_context;
138 	union acpi_operand_object *handler_obj;
139 	struct acpi_namespace_node *parent_node;
140 	struct acpi_namespace_node *pci_root_node;
141 	struct acpi_namespace_node *pci_device_node;
142 	union acpi_operand_object *region_obj =
143 	    (union acpi_operand_object *)handle;
144 
145 	ACPI_FUNCTION_TRACE(ev_pci_config_region_setup);
146 
147 	handler_obj = region_obj->region.handler;
148 	if (!handler_obj) {
149 		/*
150 		 * No installed handler. This shouldn't happen because the dispatch
151 		 * routine checks before we get here, but we check again just in case.
152 		 */
153 		ACPI_DEBUG_PRINT((ACPI_DB_OPREGION,
154 				  "Attempting to init a region %p, with no handler\n",
155 				  region_obj));
156 		return_ACPI_STATUS(AE_NOT_EXIST);
157 	}
158 
159 	*region_context = NULL;
160 	if (function == ACPI_REGION_DEACTIVATE) {
161 		if (pci_id) {
162 			ACPI_FREE(pci_id);
163 		}
164 		return_ACPI_STATUS(status);
165 	}
166 
167 	parent_node = region_obj->region.node->parent;
168 
169 	/*
170 	 * Get the _SEG and _BBN values from the device upon which the handler
171 	 * is installed.
172 	 *
173 	 * We need to get the _SEG and _BBN objects relative to the PCI BUS device.
174 	 * This is the device the handler has been registered to handle.
175 	 */
176 
177 	/*
178 	 * If the address_space.Node is still pointing to the root, we need
179 	 * to scan upward for a PCI Root bridge and re-associate the op_region
180 	 * handlers with that device.
181 	 */
182 	if (handler_obj->address_space.node == acpi_gbl_root_node) {
183 
184 		/* Start search from the parent object */
185 
186 		pci_root_node = parent_node;
187 		while (pci_root_node != acpi_gbl_root_node) {
188 
189 			/* Get the _HID/_CID in order to detect a root_bridge */
190 
191 			if (acpi_ev_is_pci_root_bridge(pci_root_node)) {
192 
193 				/* Install a handler for this PCI root bridge */
194 
195 				status = acpi_install_address_space_handler((acpi_handle)pci_root_node, ACPI_ADR_SPACE_PCI_CONFIG, ACPI_DEFAULT_HANDLER, NULL, NULL);
196 				if (ACPI_FAILURE(status)) {
197 					if (status == AE_SAME_HANDLER) {
198 						/*
199 						 * It is OK if the handler is already installed on the
200 						 * root bridge. Still need to return a context object
201 						 * for the new PCI_Config operation region, however.
202 						 */
203 					} else {
204 						ACPI_EXCEPTION((AE_INFO, status,
205 								"Could not install PciConfig handler "
206 								"for Root Bridge %4.4s",
207 								acpi_ut_get_node_name
208 								(pci_root_node)));
209 					}
210 				}
211 				break;
212 			}
213 
214 			pci_root_node = pci_root_node->parent;
215 		}
216 
217 		/* PCI root bridge not found, use namespace root node */
218 	} else {
219 		pci_root_node = handler_obj->address_space.node;
220 	}
221 
222 	/*
223 	 * If this region is now initialized, we are done.
224 	 * (install_address_space_handler could have initialized it)
225 	 */
226 	if (region_obj->region.flags & AOPOBJ_SETUP_COMPLETE) {
227 		return_ACPI_STATUS(AE_OK);
228 	}
229 
230 	/* Region is still not initialized. Create a new context */
231 
232 	pci_id = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_pci_id));
233 	if (!pci_id) {
234 		return_ACPI_STATUS(AE_NO_MEMORY);
235 	}
236 
237 	/*
238 	 * For PCI_Config space access, we need the segment, bus, device and
239 	 * function numbers. Acquire them here.
240 	 *
241 	 * Find the parent device object. (This allows the operation region to be
242 	 * within a subscope under the device, such as a control method.)
243 	 */
244 	pci_device_node = region_obj->region.node;
245 	while (pci_device_node && (pci_device_node->type != ACPI_TYPE_DEVICE)) {
246 		pci_device_node = pci_device_node->parent;
247 	}
248 
249 	if (!pci_device_node) {
250 		ACPI_FREE(pci_id);
251 		return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
252 	}
253 
254 	/*
255 	 * Get the PCI device and function numbers from the _ADR object
256 	 * contained in the parent's scope.
257 	 */
258 	status = acpi_ut_evaluate_numeric_object(METHOD_NAME__ADR,
259 						 pci_device_node, &pci_value);
260 
261 	/*
262 	 * The default is zero, and since the allocation above zeroed the data,
263 	 * just do nothing on failure.
264 	 */
265 	if (ACPI_SUCCESS(status)) {
266 		pci_id->device = ACPI_HIWORD(ACPI_LODWORD(pci_value));
267 		pci_id->function = ACPI_LOWORD(ACPI_LODWORD(pci_value));
268 	}
269 
270 	/* The PCI segment number comes from the _SEG method */
271 
272 	status = acpi_ut_evaluate_numeric_object(METHOD_NAME__SEG,
273 						 pci_root_node, &pci_value);
274 	if (ACPI_SUCCESS(status)) {
275 		pci_id->segment = ACPI_LOWORD(pci_value);
276 	}
277 
278 	/* The PCI bus number comes from the _BBN method */
279 
280 	status = acpi_ut_evaluate_numeric_object(METHOD_NAME__BBN,
281 						 pci_root_node, &pci_value);
282 	if (ACPI_SUCCESS(status)) {
283 		pci_id->bus = ACPI_LOWORD(pci_value);
284 	}
285 
286 	/* Complete/update the PCI ID for this device */
287 
288 	status =
289 	    acpi_hw_derive_pci_id(pci_id, pci_root_node,
290 				  region_obj->region.node);
291 	if (ACPI_FAILURE(status)) {
292 		ACPI_FREE(pci_id);
293 		return_ACPI_STATUS(status);
294 	}
295 
296 	*region_context = pci_id;
297 	return_ACPI_STATUS(AE_OK);
298 }
299 
300 /*******************************************************************************
301  *
302  * FUNCTION:    acpi_ev_is_pci_root_bridge
303  *
304  * PARAMETERS:  node            - Device node being examined
305  *
306  * RETURN:      TRUE if device is a PCI/PCI-Express Root Bridge
307  *
308  * DESCRIPTION: Determine if the input device represents a PCI Root Bridge by
309  *              examining the _HID and _CID for the device.
310  *
311  ******************************************************************************/
312 
acpi_ev_is_pci_root_bridge(struct acpi_namespace_node * node)313 u8 acpi_ev_is_pci_root_bridge(struct acpi_namespace_node *node)
314 {
315 	acpi_status status;
316 	struct acpi_pnp_device_id *hid;
317 	struct acpi_pnp_device_id_list *cid;
318 	u32 i;
319 	u8 match;
320 
321 	/* Get the _HID and check for a PCI Root Bridge */
322 
323 	status = acpi_ut_execute_HID(node, &hid);
324 	if (ACPI_FAILURE(status)) {
325 		return (FALSE);
326 	}
327 
328 	match = acpi_ut_is_pci_root_bridge(hid->string);
329 	ACPI_FREE(hid);
330 
331 	if (match) {
332 		return (TRUE);
333 	}
334 
335 	/* The _HID did not match. Get the _CID and check for a PCI Root Bridge */
336 
337 	status = acpi_ut_execute_CID(node, &cid);
338 	if (ACPI_FAILURE(status)) {
339 		return (FALSE);
340 	}
341 
342 	/* Check all _CIDs in the returned list */
343 
344 	for (i = 0; i < cid->count; i++) {
345 		if (acpi_ut_is_pci_root_bridge(cid->ids[i].string)) {
346 			ACPI_FREE(cid);
347 			return (TRUE);
348 		}
349 	}
350 
351 	ACPI_FREE(cid);
352 	return (FALSE);
353 }
354 
355 /*******************************************************************************
356  *
357  * FUNCTION:    acpi_ev_pci_bar_region_setup
358  *
359  * PARAMETERS:  handle              - Region we are interested in
360  *              function            - Start or stop
361  *              handler_context     - Address space handler context
362  *              region_context      - Region specific context
363  *
364  * RETURN:      Status
365  *
366  * DESCRIPTION: Setup a pci_BAR operation region
367  *
368  * MUTEX:       Assumes namespace is not locked
369  *
370  ******************************************************************************/
371 
372 acpi_status
acpi_ev_pci_bar_region_setup(acpi_handle handle,u32 function,void * handler_context,void ** region_context)373 acpi_ev_pci_bar_region_setup(acpi_handle handle,
374 			     u32 function,
375 			     void *handler_context, void **region_context)
376 {
377 	ACPI_FUNCTION_TRACE(ev_pci_bar_region_setup);
378 
379 	return_ACPI_STATUS(AE_OK);
380 }
381 
382 /*******************************************************************************
383  *
384  * FUNCTION:    acpi_ev_cmos_region_setup
385  *
386  * PARAMETERS:  handle              - Region we are interested in
387  *              function            - Start or stop
388  *              handler_context     - Address space handler context
389  *              region_context      - Region specific context
390  *
391  * RETURN:      Status
392  *
393  * DESCRIPTION: Setup a CMOS operation region
394  *
395  * MUTEX:       Assumes namespace is not locked
396  *
397  ******************************************************************************/
398 
399 acpi_status
acpi_ev_cmos_region_setup(acpi_handle handle,u32 function,void * handler_context,void ** region_context)400 acpi_ev_cmos_region_setup(acpi_handle handle,
401 			  u32 function,
402 			  void *handler_context, void **region_context)
403 {
404 	ACPI_FUNCTION_TRACE(ev_cmos_region_setup);
405 
406 	return_ACPI_STATUS(AE_OK);
407 }
408 
409 /*******************************************************************************
410  *
411  * FUNCTION:    acpi_ev_default_region_setup
412  *
413  * PARAMETERS:  handle              - Region we are interested in
414  *              function            - Start or stop
415  *              handler_context     - Address space handler context
416  *              region_context      - Region specific context
417  *
418  * RETURN:      Status
419  *
420  * DESCRIPTION: Default region initialization
421  *
422  ******************************************************************************/
423 
424 acpi_status
acpi_ev_default_region_setup(acpi_handle handle,u32 function,void * handler_context,void ** region_context)425 acpi_ev_default_region_setup(acpi_handle handle,
426 			     u32 function,
427 			     void *handler_context, void **region_context)
428 {
429 	ACPI_FUNCTION_TRACE(ev_default_region_setup);
430 
431 	if (function == ACPI_REGION_DEACTIVATE) {
432 		*region_context = NULL;
433 	} else {
434 		*region_context = handler_context;
435 	}
436 
437 	return_ACPI_STATUS(AE_OK);
438 }
439 
440 /*******************************************************************************
441  *
442  * FUNCTION:    acpi_ev_initialize_region
443  *
444  * PARAMETERS:  region_obj      - Region we are initializing
445  *
446  * RETURN:      Status
447  *
448  * DESCRIPTION: Initializes the region, finds any _REG methods and saves them
449  *              for execution at a later time
450  *
451  *              Get the appropriate address space handler for a newly
452  *              created region.
453  *
454  *              This also performs address space specific initialization. For
455  *              example, PCI regions must have an _ADR object that contains
456  *              a PCI address in the scope of the definition. This address is
457  *              required to perform an access to PCI config space.
458  *
459  * MUTEX:       Interpreter should be unlocked, because we may run the _REG
460  *              method for this region.
461  *
462  * NOTE:        Possible incompliance:
463  *              There is a behavior conflict in automatic _REG execution:
464  *              1. When the interpreter is evaluating a method, we can only
465  *                 automatically run _REG for the following case:
466  *                   operation_region (OPR1, 0x80, 0x1000010, 0x4)
467  *              2. When the interpreter is loading a table, we can also
468  *                 automatically run _REG for the following case:
469  *                   operation_region (OPR1, 0x80, 0x1000010, 0x4)
470  *              Though this may not be compliant to the de-facto standard, the
471  *              logic is kept in order not to trigger regressions. And keeping
472  *              this logic should be taken care by the caller of this function.
473  *
474  ******************************************************************************/
475 
acpi_ev_initialize_region(union acpi_operand_object * region_obj)476 acpi_status acpi_ev_initialize_region(union acpi_operand_object *region_obj)
477 {
478 	union acpi_operand_object *handler_obj;
479 	union acpi_operand_object *obj_desc;
480 	acpi_adr_space_type space_id;
481 	struct acpi_namespace_node *node;
482 
483 	ACPI_FUNCTION_TRACE(ev_initialize_region);
484 
485 	if (!region_obj) {
486 		return_ACPI_STATUS(AE_BAD_PARAMETER);
487 	}
488 
489 	if (region_obj->common.flags & AOPOBJ_OBJECT_INITIALIZED) {
490 		return_ACPI_STATUS(AE_OK);
491 	}
492 
493 	region_obj->common.flags |= AOPOBJ_OBJECT_INITIALIZED;
494 
495 	node = region_obj->region.node->parent;
496 	space_id = region_obj->region.space_id;
497 
498 	/*
499 	 * The following loop depends upon the root Node having no parent
500 	 * ie: acpi_gbl_root_node->Parent being set to NULL
501 	 */
502 	while (node) {
503 
504 		/* Check to see if a handler exists */
505 
506 		handler_obj = NULL;
507 		obj_desc = acpi_ns_get_attached_object(node);
508 		if (obj_desc) {
509 
510 			/* Can only be a handler if the object exists */
511 
512 			switch (node->type) {
513 			case ACPI_TYPE_DEVICE:
514 			case ACPI_TYPE_PROCESSOR:
515 			case ACPI_TYPE_THERMAL:
516 
517 				handler_obj = obj_desc->common_notify.handler;
518 				break;
519 
520 			default:
521 
522 				/* Ignore other objects */
523 
524 				break;
525 			}
526 
527 			handler_obj =
528 			    acpi_ev_find_region_handler(space_id, handler_obj);
529 			if (handler_obj) {
530 
531 				/* Found correct handler */
532 
533 				ACPI_DEBUG_PRINT((ACPI_DB_OPREGION,
534 						  "Found handler %p for region %p in obj %p\n",
535 						  handler_obj, region_obj,
536 						  obj_desc));
537 
538 				(void)acpi_ev_attach_region(handler_obj,
539 							    region_obj, FALSE);
540 
541 				/*
542 				 * Tell all users that this region is usable by
543 				 * running the _REG method
544 				 */
545 				acpi_ex_exit_interpreter();
546 				(void)acpi_ev_execute_reg_method(region_obj,
547 								 ACPI_REG_CONNECT);
548 				acpi_ex_enter_interpreter();
549 				return_ACPI_STATUS(AE_OK);
550 			}
551 		}
552 
553 		/* This node does not have the handler we need; Pop up one level */
554 
555 		node = node->parent;
556 	}
557 
558 	/*
559 	 * If we get here, there is no handler for this region. This is not
560 	 * fatal because many regions get created before a handler is installed
561 	 * for said region.
562 	 */
563 	ACPI_DEBUG_PRINT((ACPI_DB_OPREGION,
564 			  "No handler for RegionType %s(%X) (RegionObj %p)\n",
565 			  acpi_ut_get_region_name(space_id), space_id,
566 			  region_obj));
567 
568 	return_ACPI_STATUS(AE_OK);
569 }
570