1/******************************************************************************
2 *
3 * Module Name: exconfig - Namespace reconfiguration (Load/Unload opcodes)
4 *
5 *****************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2014, Intel Corp.
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 *    notice, this list of conditions, and the following disclaimer,
16 *    without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 *    substantially similar to the "NO WARRANTY" disclaimer below
19 *    ("Disclaimer") and any redistribution must be conditioned upon
20 *    including a substantially similar Disclaimer requirement for further
21 *    binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 *    of any contributors may be used to endorse or promote products derived
24 *    from this software without specific prior written permission.
25 *
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
29 *
30 * NO WARRANTY
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
42 */
43
44#include <acpi/acpi.h>
45#include "accommon.h"
46#include "acinterp.h"
47#include "acnamesp.h"
48#include "actables.h"
49#include "acdispat.h"
50#include "acevents.h"
51#include "amlcode.h"
52
53#define _COMPONENT          ACPI_EXECUTER
54ACPI_MODULE_NAME("exconfig")
55
56/* Local prototypes */
57static acpi_status
58acpi_ex_add_table(u32 table_index,
59		  struct acpi_namespace_node *parent_node,
60		  union acpi_operand_object **ddb_handle);
61
62static acpi_status
63acpi_ex_region_read(union acpi_operand_object *obj_desc,
64		    u32 length, u8 *buffer);
65
66/*******************************************************************************
67 *
68 * FUNCTION:    acpi_ex_add_table
69 *
70 * PARAMETERS:  table               - Pointer to raw table
71 *              parent_node         - Where to load the table (scope)
72 *              ddb_handle          - Where to return the table handle.
73 *
74 * RETURN:      Status
75 *
76 * DESCRIPTION: Common function to Install and Load an ACPI table with a
77 *              returned table handle.
78 *
79 ******************************************************************************/
80
81static acpi_status
82acpi_ex_add_table(u32 table_index,
83		  struct acpi_namespace_node *parent_node,
84		  union acpi_operand_object **ddb_handle)
85{
86	union acpi_operand_object *obj_desc;
87	acpi_status status;
88	acpi_owner_id owner_id;
89
90	ACPI_FUNCTION_TRACE(ex_add_table);
91
92	/* Create an object to be the table handle */
93
94	obj_desc = acpi_ut_create_internal_object(ACPI_TYPE_LOCAL_REFERENCE);
95	if (!obj_desc) {
96		return_ACPI_STATUS(AE_NO_MEMORY);
97	}
98
99	/* Init the table handle */
100
101	obj_desc->common.flags |= AOPOBJ_DATA_VALID;
102	obj_desc->reference.class = ACPI_REFCLASS_TABLE;
103	*ddb_handle = obj_desc;
104
105	/* Install the new table into the local data structures */
106
107	obj_desc->reference.value = table_index;
108
109	/* Add the table to the namespace */
110
111	status = acpi_ns_load_table(table_index, parent_node);
112	if (ACPI_FAILURE(status)) {
113		acpi_ut_remove_reference(obj_desc);
114		*ddb_handle = NULL;
115		return_ACPI_STATUS(status);
116	}
117
118	/* Execute any module-level code that was found in the table */
119
120	acpi_ex_exit_interpreter();
121	acpi_ns_exec_module_code_list();
122	acpi_ex_enter_interpreter();
123
124	/*
125	 * Update GPEs for any new _Lxx/_Exx methods. Ignore errors. The host is
126	 * responsible for discovering any new wake GPEs by running _PRW methods
127	 * that may have been loaded by this table.
128	 */
129	status = acpi_tb_get_owner_id(table_index, &owner_id);
130	if (ACPI_SUCCESS(status)) {
131		acpi_ev_update_gpes(owner_id);
132	}
133
134	return_ACPI_STATUS(AE_OK);
135}
136
137/*******************************************************************************
138 *
139 * FUNCTION:    acpi_ex_load_table_op
140 *
141 * PARAMETERS:  walk_state          - Current state with operands
142 *              return_desc         - Where to store the return object
143 *
144 * RETURN:      Status
145 *
146 * DESCRIPTION: Load an ACPI table from the RSDT/XSDT
147 *
148 ******************************************************************************/
149
150acpi_status
151acpi_ex_load_table_op(struct acpi_walk_state *walk_state,
152		      union acpi_operand_object **return_desc)
153{
154	acpi_status status;
155	union acpi_operand_object **operand = &walk_state->operands[0];
156	struct acpi_namespace_node *parent_node;
157	struct acpi_namespace_node *start_node;
158	struct acpi_namespace_node *parameter_node = NULL;
159	union acpi_operand_object *ddb_handle;
160	struct acpi_table_header *table;
161	u32 table_index;
162
163	ACPI_FUNCTION_TRACE(ex_load_table_op);
164
165	/* Validate lengths for the Signature, oem_id, and oem_table_id strings */
166
167	if ((operand[0]->string.length > ACPI_NAME_SIZE) ||
168	    (operand[1]->string.length > ACPI_OEM_ID_SIZE) ||
169	    (operand[2]->string.length > ACPI_OEM_TABLE_ID_SIZE)) {
170		return_ACPI_STATUS(AE_AML_STRING_LIMIT);
171	}
172
173	/* Find the ACPI table in the RSDT/XSDT */
174
175	status = acpi_tb_find_table(operand[0]->string.pointer,
176				    operand[1]->string.pointer,
177				    operand[2]->string.pointer, &table_index);
178	if (ACPI_FAILURE(status)) {
179		if (status != AE_NOT_FOUND) {
180			return_ACPI_STATUS(status);
181		}
182
183		/* Table not found, return an Integer=0 and AE_OK */
184
185		ddb_handle = acpi_ut_create_integer_object((u64) 0);
186		if (!ddb_handle) {
187			return_ACPI_STATUS(AE_NO_MEMORY);
188		}
189
190		*return_desc = ddb_handle;
191		return_ACPI_STATUS(AE_OK);
192	}
193
194	/* Default nodes */
195
196	start_node = walk_state->scope_info->scope.node;
197	parent_node = acpi_gbl_root_node;
198
199	/* root_path (optional parameter) */
200
201	if (operand[3]->string.length > 0) {
202		/*
203		 * Find the node referenced by the root_path_string. This is the
204		 * location within the namespace where the table will be loaded.
205		 */
206		status =
207		    acpi_ns_get_node(start_node, operand[3]->string.pointer,
208				     ACPI_NS_SEARCH_PARENT, &parent_node);
209		if (ACPI_FAILURE(status)) {
210			return_ACPI_STATUS(status);
211		}
212	}
213
214	/* parameter_path (optional parameter) */
215
216	if (operand[4]->string.length > 0) {
217		if ((operand[4]->string.pointer[0] != AML_ROOT_PREFIX) &&
218		    (operand[4]->string.pointer[0] != AML_PARENT_PREFIX)) {
219			/*
220			 * Path is not absolute, so it will be relative to the node
221			 * referenced by the root_path_string (or the NS root if omitted)
222			 */
223			start_node = parent_node;
224		}
225
226		/* Find the node referenced by the parameter_path_string */
227
228		status =
229		    acpi_ns_get_node(start_node, operand[4]->string.pointer,
230				     ACPI_NS_SEARCH_PARENT, &parameter_node);
231		if (ACPI_FAILURE(status)) {
232			return_ACPI_STATUS(status);
233		}
234	}
235
236	/* Load the table into the namespace */
237
238	status = acpi_ex_add_table(table_index, parent_node, &ddb_handle);
239	if (ACPI_FAILURE(status)) {
240		return_ACPI_STATUS(status);
241	}
242
243	/* Parameter Data (optional) */
244
245	if (parameter_node) {
246
247		/* Store the parameter data into the optional parameter object */
248
249		status = acpi_ex_store(operand[5],
250				       ACPI_CAST_PTR(union acpi_operand_object,
251						     parameter_node),
252				       walk_state);
253		if (ACPI_FAILURE(status)) {
254			(void)acpi_ex_unload_table(ddb_handle);
255
256			acpi_ut_remove_reference(ddb_handle);
257			return_ACPI_STATUS(status);
258		}
259	}
260
261	status = acpi_get_table_by_index(table_index, &table);
262	if (ACPI_SUCCESS(status)) {
263		ACPI_INFO((AE_INFO, "Dynamic OEM Table Load:"));
264		acpi_tb_print_table_header(0, table);
265	}
266
267	/* Invoke table handler if present */
268
269	if (acpi_gbl_table_handler) {
270		(void)acpi_gbl_table_handler(ACPI_TABLE_EVENT_LOAD, table,
271					     acpi_gbl_table_handler_context);
272	}
273
274	*return_desc = ddb_handle;
275	return_ACPI_STATUS(status);
276}
277
278/*******************************************************************************
279 *
280 * FUNCTION:    acpi_ex_region_read
281 *
282 * PARAMETERS:  obj_desc        - Region descriptor
283 *              length          - Number of bytes to read
284 *              buffer          - Pointer to where to put the data
285 *
286 * RETURN:      Status
287 *
288 * DESCRIPTION: Read data from an operation region. The read starts from the
289 *              beginning of the region.
290 *
291 ******************************************************************************/
292
293static acpi_status
294acpi_ex_region_read(union acpi_operand_object *obj_desc, u32 length, u8 *buffer)
295{
296	acpi_status status;
297	u64 value;
298	u32 region_offset = 0;
299	u32 i;
300
301	/* Bytewise reads */
302
303	for (i = 0; i < length; i++) {
304		status =
305		    acpi_ev_address_space_dispatch(obj_desc, NULL, ACPI_READ,
306						   region_offset, 8, &value);
307		if (ACPI_FAILURE(status)) {
308			return (status);
309		}
310
311		*buffer = (u8)value;
312		buffer++;
313		region_offset++;
314	}
315
316	return (AE_OK);
317}
318
319/*******************************************************************************
320 *
321 * FUNCTION:    acpi_ex_load_op
322 *
323 * PARAMETERS:  obj_desc        - Region or Buffer/Field where the table will be
324 *                                obtained
325 *              target          - Where a handle to the table will be stored
326 *              walk_state      - Current state
327 *
328 * RETURN:      Status
329 *
330 * DESCRIPTION: Load an ACPI table from a field or operation region
331 *
332 * NOTE: Region Fields (Field, bank_field, index_fields) are resolved to buffer
333 *       objects before this code is reached.
334 *
335 *       If source is an operation region, it must refer to system_memory, as
336 *       per the ACPI specification.
337 *
338 ******************************************************************************/
339
340acpi_status
341acpi_ex_load_op(union acpi_operand_object *obj_desc,
342		union acpi_operand_object *target,
343		struct acpi_walk_state *walk_state)
344{
345	union acpi_operand_object *ddb_handle;
346	struct acpi_table_header *table_header;
347	struct acpi_table_header *table;
348	u32 table_index;
349	acpi_status status;
350	u32 length;
351
352	ACPI_FUNCTION_TRACE(ex_load_op);
353
354	/* Source Object can be either an op_region or a Buffer/Field */
355
356	switch (obj_desc->common.type) {
357	case ACPI_TYPE_REGION:
358
359		ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
360				  "Load table from Region %p\n", obj_desc));
361
362		/* Region must be system_memory (from ACPI spec) */
363
364		if (obj_desc->region.space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY) {
365			return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
366		}
367
368		/*
369		 * If the Region Address and Length have not been previously evaluated,
370		 * evaluate them now and save the results.
371		 */
372		if (!(obj_desc->common.flags & AOPOBJ_DATA_VALID)) {
373			status = acpi_ds_get_region_arguments(obj_desc);
374			if (ACPI_FAILURE(status)) {
375				return_ACPI_STATUS(status);
376			}
377		}
378
379		/* Get the table header first so we can get the table length */
380
381		table_header = ACPI_ALLOCATE(sizeof(struct acpi_table_header));
382		if (!table_header) {
383			return_ACPI_STATUS(AE_NO_MEMORY);
384		}
385
386		status =
387		    acpi_ex_region_read(obj_desc,
388					sizeof(struct acpi_table_header),
389					ACPI_CAST_PTR(u8, table_header));
390		length = table_header->length;
391		ACPI_FREE(table_header);
392
393		if (ACPI_FAILURE(status)) {
394			return_ACPI_STATUS(status);
395		}
396
397		/* Must have at least an ACPI table header */
398
399		if (length < sizeof(struct acpi_table_header)) {
400			return_ACPI_STATUS(AE_INVALID_TABLE_LENGTH);
401		}
402
403		/*
404		 * The original implementation simply mapped the table, with no copy.
405		 * However, the memory region is not guaranteed to remain stable and
406		 * we must copy the table to a local buffer. For example, the memory
407		 * region is corrupted after suspend on some machines. Dynamically
408		 * loaded tables are usually small, so this overhead is minimal.
409		 *
410		 * The latest implementation (5/2009) does not use a mapping at all.
411		 * We use the low-level operation region interface to read the table
412		 * instead of the obvious optimization of using a direct mapping.
413		 * This maintains a consistent use of operation regions across the
414		 * entire subsystem. This is important if additional processing must
415		 * be performed in the (possibly user-installed) operation region
416		 * handler. For example, acpi_exec and ASLTS depend on this.
417		 */
418
419		/* Allocate a buffer for the table */
420
421		table = ACPI_ALLOCATE(length);
422		if (!table) {
423			return_ACPI_STATUS(AE_NO_MEMORY);
424		}
425
426		/* Read the entire table */
427
428		status = acpi_ex_region_read(obj_desc, length,
429					     ACPI_CAST_PTR(u8, table));
430		if (ACPI_FAILURE(status)) {
431			ACPI_FREE(table);
432			return_ACPI_STATUS(status);
433		}
434		break;
435
436	case ACPI_TYPE_BUFFER:	/* Buffer or resolved region_field */
437
438		ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
439				  "Load table from Buffer or Field %p\n",
440				  obj_desc));
441
442		/* Must have at least an ACPI table header */
443
444		if (obj_desc->buffer.length < sizeof(struct acpi_table_header)) {
445			return_ACPI_STATUS(AE_INVALID_TABLE_LENGTH);
446		}
447
448		/* Get the actual table length from the table header */
449
450		table_header =
451		    ACPI_CAST_PTR(struct acpi_table_header,
452				  obj_desc->buffer.pointer);
453		length = table_header->length;
454
455		/* Table cannot extend beyond the buffer */
456
457		if (length > obj_desc->buffer.length) {
458			return_ACPI_STATUS(AE_AML_BUFFER_LIMIT);
459		}
460		if (length < sizeof(struct acpi_table_header)) {
461			return_ACPI_STATUS(AE_INVALID_TABLE_LENGTH);
462		}
463
464		/*
465		 * Copy the table from the buffer because the buffer could be modified
466		 * or even deleted in the future
467		 */
468		table = ACPI_ALLOCATE(length);
469		if (!table) {
470			return_ACPI_STATUS(AE_NO_MEMORY);
471		}
472
473		ACPI_MEMCPY(table, table_header, length);
474		break;
475
476	default:
477
478		return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
479	}
480
481	/* Install the new table into the local data structures */
482
483	ACPI_INFO((AE_INFO, "Dynamic OEM Table Load:"));
484	(void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
485
486	status = acpi_tb_install_standard_table(ACPI_PTR_TO_PHYSADDR(table),
487						ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL,
488						TRUE, TRUE, &table_index);
489
490	(void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
491	if (ACPI_FAILURE(status)) {
492
493		/* Delete allocated table buffer */
494
495		ACPI_FREE(table);
496		return_ACPI_STATUS(status);
497	}
498
499	/*
500	 * Note: Now table is "INSTALLED", it must be validated before
501	 * loading.
502	 */
503	status =
504	    acpi_tb_validate_table(&acpi_gbl_root_table_list.
505				   tables[table_index]);
506	if (ACPI_FAILURE(status)) {
507		return_ACPI_STATUS(status);
508	}
509
510	/*
511	 * Add the table to the namespace.
512	 *
513	 * Note: Load the table objects relative to the root of the namespace.
514	 * This appears to go against the ACPI specification, but we do it for
515	 * compatibility with other ACPI implementations.
516	 */
517	status =
518	    acpi_ex_add_table(table_index, acpi_gbl_root_node, &ddb_handle);
519	if (ACPI_FAILURE(status)) {
520
521		/* On error, table_ptr was deallocated above */
522
523		return_ACPI_STATUS(status);
524	}
525
526	/* Store the ddb_handle into the Target operand */
527
528	status = acpi_ex_store(ddb_handle, target, walk_state);
529	if (ACPI_FAILURE(status)) {
530		(void)acpi_ex_unload_table(ddb_handle);
531
532		/* table_ptr was deallocated above */
533
534		acpi_ut_remove_reference(ddb_handle);
535		return_ACPI_STATUS(status);
536	}
537
538	/* Remove the reference by added by acpi_ex_store above */
539
540	acpi_ut_remove_reference(ddb_handle);
541
542	/* Invoke table handler if present */
543
544	if (acpi_gbl_table_handler) {
545		(void)acpi_gbl_table_handler(ACPI_TABLE_EVENT_LOAD, table,
546					     acpi_gbl_table_handler_context);
547	}
548
549	return_ACPI_STATUS(status);
550}
551
552/*******************************************************************************
553 *
554 * FUNCTION:    acpi_ex_unload_table
555 *
556 * PARAMETERS:  ddb_handle          - Handle to a previously loaded table
557 *
558 * RETURN:      Status
559 *
560 * DESCRIPTION: Unload an ACPI table
561 *
562 ******************************************************************************/
563
564acpi_status acpi_ex_unload_table(union acpi_operand_object *ddb_handle)
565{
566	acpi_status status = AE_OK;
567	union acpi_operand_object *table_desc = ddb_handle;
568	u32 table_index;
569	struct acpi_table_header *table;
570
571	ACPI_FUNCTION_TRACE(ex_unload_table);
572
573	/*
574	 * Temporarily emit a warning so that the ASL for the machine can be
575	 * hopefully obtained. This is to say that the Unload() operator is
576	 * extremely rare if not completely unused.
577	 */
578	ACPI_WARNING((AE_INFO, "Received request to unload an ACPI table"));
579
580	/*
581	 * Validate the handle
582	 * Although the handle is partially validated in acpi_ex_reconfiguration()
583	 * when it calls acpi_ex_resolve_operands(), the handle is more completely
584	 * validated here.
585	 *
586	 * Handle must be a valid operand object of type reference. Also, the
587	 * ddb_handle must still be marked valid (table has not been previously
588	 * unloaded)
589	 */
590	if ((!ddb_handle) ||
591	    (ACPI_GET_DESCRIPTOR_TYPE(ddb_handle) != ACPI_DESC_TYPE_OPERAND) ||
592	    (ddb_handle->common.type != ACPI_TYPE_LOCAL_REFERENCE) ||
593	    (!(ddb_handle->common.flags & AOPOBJ_DATA_VALID))) {
594		return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
595	}
596
597	/* Get the table index from the ddb_handle */
598
599	table_index = table_desc->reference.value;
600
601	/* Ensure the table is still loaded */
602
603	if (!acpi_tb_is_table_loaded(table_index)) {
604		return_ACPI_STATUS(AE_NOT_EXIST);
605	}
606
607	/* Invoke table handler if present */
608
609	if (acpi_gbl_table_handler) {
610		status = acpi_get_table_by_index(table_index, &table);
611		if (ACPI_SUCCESS(status)) {
612			(void)acpi_gbl_table_handler(ACPI_TABLE_EVENT_UNLOAD,
613						     table,
614						     acpi_gbl_table_handler_context);
615		}
616	}
617
618	/* Delete the portion of the namespace owned by this table */
619
620	status = acpi_tb_delete_namespace_by_owner(table_index);
621	if (ACPI_FAILURE(status)) {
622		return_ACPI_STATUS(status);
623	}
624
625	(void)acpi_tb_release_owner_id(table_index);
626	acpi_tb_set_table_loaded_flag(table_index, FALSE);
627
628	/*
629	 * Invalidate the handle. We do this because the handle may be stored
630	 * in a named object and may not be actually deleted until much later.
631	 */
632	ddb_handle->common.flags &= ~AOPOBJ_DATA_VALID;
633	return_ACPI_STATUS(AE_OK);
634}
635