xref: /linux/drivers/acpi/acpica/tbdata.c (revision 791d3ef2e11100449837dc0b6fe884e60ca3a484)
1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 /******************************************************************************
3  *
4  * Module Name: tbdata - Table manager data structure functions
5  *
6  * Copyright (C) 2000 - 2018, Intel Corp.
7  *
8  *****************************************************************************/
9 
10 #include <acpi/acpi.h>
11 #include "accommon.h"
12 #include "acnamesp.h"
13 #include "actables.h"
14 #include "acevents.h"
15 
16 #define _COMPONENT          ACPI_TABLES
17 ACPI_MODULE_NAME("tbdata")
18 
19 /* Local prototypes */
20 static acpi_status
21 acpi_tb_check_duplication(struct acpi_table_desc *table_desc, u32 *table_index);
22 
23 static u8
24 acpi_tb_compare_tables(struct acpi_table_desc *table_desc, u32 table_index);
25 
26 /*******************************************************************************
27  *
28  * FUNCTION:    acpi_tb_compare_tables
29  *
30  * PARAMETERS:  table_desc          - Table 1 descriptor to be compared
31  *              table_index         - Index of table 2 to be compared
32  *
33  * RETURN:      TRUE if both tables are identical.
34  *
35  * DESCRIPTION: This function compares a table with another table that has
36  *              already been installed in the root table list.
37  *
38  ******************************************************************************/
39 
40 static u8
41 acpi_tb_compare_tables(struct acpi_table_desc *table_desc, u32 table_index)
42 {
43 	acpi_status status = AE_OK;
44 	u8 is_identical;
45 	struct acpi_table_header *table;
46 	u32 table_length;
47 	u8 table_flags;
48 
49 	status =
50 	    acpi_tb_acquire_table(&acpi_gbl_root_table_list.tables[table_index],
51 				  &table, &table_length, &table_flags);
52 	if (ACPI_FAILURE(status)) {
53 		return (FALSE);
54 	}
55 
56 	/*
57 	 * Check for a table match on the entire table length,
58 	 * not just the header.
59 	 */
60 	is_identical = (u8)((table_desc->length != table_length ||
61 			     memcmp(table_desc->pointer, table, table_length)) ?
62 			    FALSE : TRUE);
63 
64 	/* Release the acquired table */
65 
66 	acpi_tb_release_table(table, table_length, table_flags);
67 	return (is_identical);
68 }
69 
70 /*******************************************************************************
71  *
72  * FUNCTION:    acpi_tb_init_table_descriptor
73  *
74  * PARAMETERS:  table_desc              - Table descriptor
75  *              address                 - Physical address of the table
76  *              flags                   - Allocation flags of the table
77  *              table                   - Pointer to the table
78  *
79  * RETURN:      None
80  *
81  * DESCRIPTION: Initialize a new table descriptor
82  *
83  ******************************************************************************/
84 
85 void
86 acpi_tb_init_table_descriptor(struct acpi_table_desc *table_desc,
87 			      acpi_physical_address address,
88 			      u8 flags, struct acpi_table_header *table)
89 {
90 
91 	/*
92 	 * Initialize the table descriptor. Set the pointer to NULL, since the
93 	 * table is not fully mapped at this time.
94 	 */
95 	memset(table_desc, 0, sizeof(struct acpi_table_desc));
96 	table_desc->address = address;
97 	table_desc->length = table->length;
98 	table_desc->flags = flags;
99 	ACPI_MOVE_32_TO_32(table_desc->signature.ascii, table->signature);
100 }
101 
102 /*******************************************************************************
103  *
104  * FUNCTION:    acpi_tb_acquire_table
105  *
106  * PARAMETERS:  table_desc          - Table descriptor
107  *              table_ptr           - Where table is returned
108  *              table_length        - Where table length is returned
109  *              table_flags         - Where table allocation flags are returned
110  *
111  * RETURN:      Status
112  *
113  * DESCRIPTION: Acquire an ACPI table. It can be used for tables not
114  *              maintained in the acpi_gbl_root_table_list.
115  *
116  ******************************************************************************/
117 
118 acpi_status
119 acpi_tb_acquire_table(struct acpi_table_desc *table_desc,
120 		      struct acpi_table_header **table_ptr,
121 		      u32 *table_length, u8 *table_flags)
122 {
123 	struct acpi_table_header *table = NULL;
124 
125 	switch (table_desc->flags & ACPI_TABLE_ORIGIN_MASK) {
126 	case ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL:
127 
128 		table =
129 		    acpi_os_map_memory(table_desc->address, table_desc->length);
130 		break;
131 
132 	case ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL:
133 	case ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL:
134 
135 		table = ACPI_CAST_PTR(struct acpi_table_header,
136 				      ACPI_PHYSADDR_TO_PTR(table_desc->
137 							   address));
138 		break;
139 
140 	default:
141 
142 		break;
143 	}
144 
145 	/* Table is not valid yet */
146 
147 	if (!table) {
148 		return (AE_NO_MEMORY);
149 	}
150 
151 	/* Fill the return values */
152 
153 	*table_ptr = table;
154 	*table_length = table_desc->length;
155 	*table_flags = table_desc->flags;
156 	return (AE_OK);
157 }
158 
159 /*******************************************************************************
160  *
161  * FUNCTION:    acpi_tb_release_table
162  *
163  * PARAMETERS:  table               - Pointer for the table
164  *              table_length        - Length for the table
165  *              table_flags         - Allocation flags for the table
166  *
167  * RETURN:      None
168  *
169  * DESCRIPTION: Release a table. The inverse of acpi_tb_acquire_table().
170  *
171  ******************************************************************************/
172 
173 void
174 acpi_tb_release_table(struct acpi_table_header *table,
175 		      u32 table_length, u8 table_flags)
176 {
177 
178 	switch (table_flags & ACPI_TABLE_ORIGIN_MASK) {
179 	case ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL:
180 
181 		acpi_os_unmap_memory(table, table_length);
182 		break;
183 
184 	case ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL:
185 	case ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL:
186 	default:
187 
188 		break;
189 	}
190 }
191 
192 /*******************************************************************************
193  *
194  * FUNCTION:    acpi_tb_acquire_temp_table
195  *
196  * PARAMETERS:  table_desc          - Table descriptor to be acquired
197  *              address             - Address of the table
198  *              flags               - Allocation flags of the table
199  *
200  * RETURN:      Status
201  *
202  * DESCRIPTION: This function validates the table header to obtain the length
203  *              of a table and fills the table descriptor to make its state as
204  *              "INSTALLED". Such a table descriptor is only used for verified
205  *              installation.
206  *
207  ******************************************************************************/
208 
209 acpi_status
210 acpi_tb_acquire_temp_table(struct acpi_table_desc *table_desc,
211 			   acpi_physical_address address, u8 flags)
212 {
213 	struct acpi_table_header *table_header;
214 
215 	switch (flags & ACPI_TABLE_ORIGIN_MASK) {
216 	case ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL:
217 
218 		/* Get the length of the full table from the header */
219 
220 		table_header =
221 		    acpi_os_map_memory(address,
222 				       sizeof(struct acpi_table_header));
223 		if (!table_header) {
224 			return (AE_NO_MEMORY);
225 		}
226 
227 		acpi_tb_init_table_descriptor(table_desc, address, flags,
228 					      table_header);
229 		acpi_os_unmap_memory(table_header,
230 				     sizeof(struct acpi_table_header));
231 		return (AE_OK);
232 
233 	case ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL:
234 	case ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL:
235 
236 		table_header = ACPI_CAST_PTR(struct acpi_table_header,
237 					     ACPI_PHYSADDR_TO_PTR(address));
238 		if (!table_header) {
239 			return (AE_NO_MEMORY);
240 		}
241 
242 		acpi_tb_init_table_descriptor(table_desc, address, flags,
243 					      table_header);
244 		return (AE_OK);
245 
246 	default:
247 
248 		break;
249 	}
250 
251 	/* Table is not valid yet */
252 
253 	return (AE_NO_MEMORY);
254 }
255 
256 /*******************************************************************************
257  *
258  * FUNCTION:    acpi_tb_release_temp_table
259  *
260  * PARAMETERS:  table_desc          - Table descriptor to be released
261  *
262  * RETURN:      Status
263  *
264  * DESCRIPTION: The inverse of acpi_tb_acquire_temp_table().
265  *
266  *****************************************************************************/
267 
268 void acpi_tb_release_temp_table(struct acpi_table_desc *table_desc)
269 {
270 
271 	/*
272 	 * Note that the .Address is maintained by the callers of
273 	 * acpi_tb_acquire_temp_table(), thus do not invoke acpi_tb_uninstall_table()
274 	 * where .Address will be freed.
275 	 */
276 	acpi_tb_invalidate_table(table_desc);
277 }
278 
279 /******************************************************************************
280  *
281  * FUNCTION:    acpi_tb_validate_table
282  *
283  * PARAMETERS:  table_desc          - Table descriptor
284  *
285  * RETURN:      Status
286  *
287  * DESCRIPTION: This function is called to validate the table, the returned
288  *              table descriptor is in "VALIDATED" state.
289  *
290  *****************************************************************************/
291 
292 acpi_status acpi_tb_validate_table(struct acpi_table_desc *table_desc)
293 {
294 	acpi_status status = AE_OK;
295 
296 	ACPI_FUNCTION_TRACE(tb_validate_table);
297 
298 	/* Validate the table if necessary */
299 
300 	if (!table_desc->pointer) {
301 		status = acpi_tb_acquire_table(table_desc, &table_desc->pointer,
302 					       &table_desc->length,
303 					       &table_desc->flags);
304 		if (!table_desc->pointer) {
305 			status = AE_NO_MEMORY;
306 		}
307 	}
308 
309 	return_ACPI_STATUS(status);
310 }
311 
312 /*******************************************************************************
313  *
314  * FUNCTION:    acpi_tb_invalidate_table
315  *
316  * PARAMETERS:  table_desc          - Table descriptor
317  *
318  * RETURN:      None
319  *
320  * DESCRIPTION: Invalidate one internal ACPI table, this is the inverse of
321  *              acpi_tb_validate_table().
322  *
323  ******************************************************************************/
324 
325 void acpi_tb_invalidate_table(struct acpi_table_desc *table_desc)
326 {
327 
328 	ACPI_FUNCTION_TRACE(tb_invalidate_table);
329 
330 	/* Table must be validated */
331 
332 	if (!table_desc->pointer) {
333 		return_VOID;
334 	}
335 
336 	acpi_tb_release_table(table_desc->pointer, table_desc->length,
337 			      table_desc->flags);
338 	table_desc->pointer = NULL;
339 
340 	return_VOID;
341 }
342 
343 /******************************************************************************
344  *
345  * FUNCTION:    acpi_tb_validate_temp_table
346  *
347  * PARAMETERS:  table_desc          - Table descriptor
348  *
349  * RETURN:      Status
350  *
351  * DESCRIPTION: This function is called to validate the table, the returned
352  *              table descriptor is in "VALIDATED" state.
353  *
354  *****************************************************************************/
355 
356 acpi_status acpi_tb_validate_temp_table(struct acpi_table_desc *table_desc)
357 {
358 
359 	if (!table_desc->pointer && !acpi_gbl_enable_table_validation) {
360 		/*
361 		 * Only validates the header of the table.
362 		 * Note that Length contains the size of the mapping after invoking
363 		 * this work around, this value is required by
364 		 * acpi_tb_release_temp_table().
365 		 * We can do this because in acpi_init_table_descriptor(), the Length
366 		 * field of the installed descriptor is filled with the actual
367 		 * table length obtaining from the table header.
368 		 */
369 		table_desc->length = sizeof(struct acpi_table_header);
370 	}
371 
372 	return (acpi_tb_validate_table(table_desc));
373 }
374 
375 /*******************************************************************************
376  *
377  * FUNCTION:    acpi_tb_check_duplication
378  *
379  * PARAMETERS:  table_desc          - Table descriptor
380  *              table_index         - Where the table index is returned
381  *
382  * RETURN:      Status
383  *
384  * DESCRIPTION: Avoid installing duplicated tables. However table override and
385  *              user aided dynamic table load is allowed, thus comparing the
386  *              address of the table is not sufficient, and checking the entire
387  *              table content is required.
388  *
389  ******************************************************************************/
390 
391 static acpi_status
392 acpi_tb_check_duplication(struct acpi_table_desc *table_desc, u32 *table_index)
393 {
394 	u32 i;
395 
396 	ACPI_FUNCTION_TRACE(tb_check_duplication);
397 
398 	/* Check if table is already registered */
399 
400 	for (i = 0; i < acpi_gbl_root_table_list.current_table_count; ++i) {
401 
402 		/* Do not compare with unverified tables */
403 
404 		if (!
405 		    (acpi_gbl_root_table_list.tables[i].
406 		     flags & ACPI_TABLE_IS_VERIFIED)) {
407 			continue;
408 		}
409 
410 		/*
411 		 * Check for a table match on the entire table length,
412 		 * not just the header.
413 		 */
414 		if (!acpi_tb_compare_tables(table_desc, i)) {
415 			continue;
416 		}
417 
418 		/*
419 		 * Note: the current mechanism does not unregister a table if it is
420 		 * dynamically unloaded. The related namespace entries are deleted,
421 		 * but the table remains in the root table list.
422 		 *
423 		 * The assumption here is that the number of different tables that
424 		 * will be loaded is actually small, and there is minimal overhead
425 		 * in just keeping the table in case it is needed again.
426 		 *
427 		 * If this assumption changes in the future (perhaps on large
428 		 * machines with many table load/unload operations), tables will
429 		 * need to be unregistered when they are unloaded, and slots in the
430 		 * root table list should be reused when empty.
431 		 */
432 		if (acpi_gbl_root_table_list.tables[i].flags &
433 		    ACPI_TABLE_IS_LOADED) {
434 
435 			/* Table is still loaded, this is an error */
436 
437 			return_ACPI_STATUS(AE_ALREADY_EXISTS);
438 		} else {
439 			*table_index = i;
440 			return_ACPI_STATUS(AE_CTRL_TERMINATE);
441 		}
442 	}
443 
444 	/* Indicate no duplication to the caller */
445 
446 	return_ACPI_STATUS(AE_OK);
447 }
448 
449 /******************************************************************************
450  *
451  * FUNCTION:    acpi_tb_verify_temp_table
452  *
453  * PARAMETERS:  table_desc          - Table descriptor
454  *              signature           - Table signature to verify
455  *              table_index         - Where the table index is returned
456  *
457  * RETURN:      Status
458  *
459  * DESCRIPTION: This function is called to validate and verify the table, the
460  *              returned table descriptor is in "VALIDATED" state.
461  *              Note that 'TableIndex' is required to be set to !NULL to
462  *              enable duplication check.
463  *
464  *****************************************************************************/
465 
466 acpi_status
467 acpi_tb_verify_temp_table(struct acpi_table_desc *table_desc,
468 			  char *signature, u32 *table_index)
469 {
470 	acpi_status status = AE_OK;
471 
472 	ACPI_FUNCTION_TRACE(tb_verify_temp_table);
473 
474 	/* Validate the table */
475 
476 	status = acpi_tb_validate_temp_table(table_desc);
477 	if (ACPI_FAILURE(status)) {
478 		return_ACPI_STATUS(AE_NO_MEMORY);
479 	}
480 
481 	/* If a particular signature is expected (DSDT/FACS), it must match */
482 
483 	if (signature && !ACPI_COMPARE_NAME(&table_desc->signature, signature)) {
484 		ACPI_BIOS_ERROR((AE_INFO,
485 				 "Invalid signature 0x%X for ACPI table, expected [%s]",
486 				 table_desc->signature.integer, signature));
487 		status = AE_BAD_SIGNATURE;
488 		goto invalidate_and_exit;
489 	}
490 
491 	if (acpi_gbl_enable_table_validation) {
492 
493 		/* Verify the checksum */
494 
495 		status =
496 		    acpi_tb_verify_checksum(table_desc->pointer,
497 					    table_desc->length);
498 		if (ACPI_FAILURE(status)) {
499 			ACPI_EXCEPTION((AE_INFO, AE_NO_MEMORY,
500 					"%4.4s 0x%8.8X%8.8X"
501 					" Attempted table install failed",
502 					acpi_ut_valid_nameseg(table_desc->
503 							      signature.
504 							      ascii) ?
505 					table_desc->signature.ascii : "????",
506 					ACPI_FORMAT_UINT64(table_desc->
507 							   address)));
508 
509 			goto invalidate_and_exit;
510 		}
511 
512 		/* Avoid duplications */
513 
514 		if (table_index) {
515 			status =
516 			    acpi_tb_check_duplication(table_desc, table_index);
517 			if (ACPI_FAILURE(status)) {
518 				if (status != AE_CTRL_TERMINATE) {
519 					ACPI_EXCEPTION((AE_INFO, AE_NO_MEMORY,
520 							"%4.4s 0x%8.8X%8.8X"
521 							" Table is duplicated",
522 							acpi_ut_valid_nameseg
523 							(table_desc->signature.
524 							 ascii) ? table_desc->
525 							signature.
526 							ascii : "????",
527 							ACPI_FORMAT_UINT64
528 							(table_desc->address)));
529 				}
530 
531 				goto invalidate_and_exit;
532 			}
533 		}
534 
535 		table_desc->flags |= ACPI_TABLE_IS_VERIFIED;
536 	}
537 
538 	return_ACPI_STATUS(status);
539 
540 invalidate_and_exit:
541 	acpi_tb_invalidate_table(table_desc);
542 	return_ACPI_STATUS(status);
543 }
544 
545 /*******************************************************************************
546  *
547  * FUNCTION:    acpi_tb_resize_root_table_list
548  *
549  * PARAMETERS:  None
550  *
551  * RETURN:      Status
552  *
553  * DESCRIPTION: Expand the size of global table array
554  *
555  ******************************************************************************/
556 
557 acpi_status acpi_tb_resize_root_table_list(void)
558 {
559 	struct acpi_table_desc *tables;
560 	u32 table_count;
561 	u32 current_table_count, max_table_count;
562 	u32 i;
563 
564 	ACPI_FUNCTION_TRACE(tb_resize_root_table_list);
565 
566 	/* allow_resize flag is a parameter to acpi_initialize_tables */
567 
568 	if (!(acpi_gbl_root_table_list.flags & ACPI_ROOT_ALLOW_RESIZE)) {
569 		ACPI_ERROR((AE_INFO,
570 			    "Resize of Root Table Array is not allowed"));
571 		return_ACPI_STATUS(AE_SUPPORT);
572 	}
573 
574 	/* Increase the Table Array size */
575 
576 	if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) {
577 		table_count = acpi_gbl_root_table_list.max_table_count;
578 	} else {
579 		table_count = acpi_gbl_root_table_list.current_table_count;
580 	}
581 
582 	max_table_count = table_count + ACPI_ROOT_TABLE_SIZE_INCREMENT;
583 	tables = ACPI_ALLOCATE_ZEROED(((acpi_size)max_table_count) *
584 				      sizeof(struct acpi_table_desc));
585 	if (!tables) {
586 		ACPI_ERROR((AE_INFO,
587 			    "Could not allocate new root table array"));
588 		return_ACPI_STATUS(AE_NO_MEMORY);
589 	}
590 
591 	/* Copy and free the previous table array */
592 
593 	current_table_count = 0;
594 	if (acpi_gbl_root_table_list.tables) {
595 		for (i = 0; i < table_count; i++) {
596 			if (acpi_gbl_root_table_list.tables[i].address) {
597 				memcpy(tables + current_table_count,
598 				       acpi_gbl_root_table_list.tables + i,
599 				       sizeof(struct acpi_table_desc));
600 				current_table_count++;
601 			}
602 		}
603 
604 		if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) {
605 			ACPI_FREE(acpi_gbl_root_table_list.tables);
606 		}
607 	}
608 
609 	acpi_gbl_root_table_list.tables = tables;
610 	acpi_gbl_root_table_list.max_table_count = max_table_count;
611 	acpi_gbl_root_table_list.current_table_count = current_table_count;
612 	acpi_gbl_root_table_list.flags |= ACPI_ROOT_ORIGIN_ALLOCATED;
613 
614 	return_ACPI_STATUS(AE_OK);
615 }
616 
617 /*******************************************************************************
618  *
619  * FUNCTION:    acpi_tb_get_next_table_descriptor
620  *
621  * PARAMETERS:  table_index         - Where table index is returned
622  *              table_desc          - Where table descriptor is returned
623  *
624  * RETURN:      Status and table index/descriptor.
625  *
626  * DESCRIPTION: Allocate a new ACPI table entry to the global table list
627  *
628  ******************************************************************************/
629 
630 acpi_status
631 acpi_tb_get_next_table_descriptor(u32 *table_index,
632 				  struct acpi_table_desc **table_desc)
633 {
634 	acpi_status status;
635 	u32 i;
636 
637 	/* Ensure that there is room for the table in the Root Table List */
638 
639 	if (acpi_gbl_root_table_list.current_table_count >=
640 	    acpi_gbl_root_table_list.max_table_count) {
641 		status = acpi_tb_resize_root_table_list();
642 		if (ACPI_FAILURE(status)) {
643 			return (status);
644 		}
645 	}
646 
647 	i = acpi_gbl_root_table_list.current_table_count;
648 	acpi_gbl_root_table_list.current_table_count++;
649 
650 	if (table_index) {
651 		*table_index = i;
652 	}
653 	if (table_desc) {
654 		*table_desc = &acpi_gbl_root_table_list.tables[i];
655 	}
656 
657 	return (AE_OK);
658 }
659 
660 /*******************************************************************************
661  *
662  * FUNCTION:    acpi_tb_terminate
663  *
664  * PARAMETERS:  None
665  *
666  * RETURN:      None
667  *
668  * DESCRIPTION: Delete all internal ACPI tables
669  *
670  ******************************************************************************/
671 
672 void acpi_tb_terminate(void)
673 {
674 	u32 i;
675 
676 	ACPI_FUNCTION_TRACE(tb_terminate);
677 
678 	(void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
679 
680 	/* Delete the individual tables */
681 
682 	for (i = 0; i < acpi_gbl_root_table_list.current_table_count; i++) {
683 		acpi_tb_uninstall_table(&acpi_gbl_root_table_list.tables[i]);
684 	}
685 
686 	/*
687 	 * Delete the root table array if allocated locally. Array cannot be
688 	 * mapped, so we don't need to check for that flag.
689 	 */
690 	if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) {
691 		ACPI_FREE(acpi_gbl_root_table_list.tables);
692 	}
693 
694 	acpi_gbl_root_table_list.tables = NULL;
695 	acpi_gbl_root_table_list.flags = 0;
696 	acpi_gbl_root_table_list.current_table_count = 0;
697 
698 	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "ACPI Tables freed\n"));
699 
700 	(void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
701 	return_VOID;
702 }
703 
704 /*******************************************************************************
705  *
706  * FUNCTION:    acpi_tb_delete_namespace_by_owner
707  *
708  * PARAMETERS:  table_index         - Table index
709  *
710  * RETURN:      Status
711  *
712  * DESCRIPTION: Delete all namespace objects created when this table was loaded.
713  *
714  ******************************************************************************/
715 
716 acpi_status acpi_tb_delete_namespace_by_owner(u32 table_index)
717 {
718 	acpi_owner_id owner_id;
719 	acpi_status status;
720 
721 	ACPI_FUNCTION_TRACE(tb_delete_namespace_by_owner);
722 
723 	status = acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
724 	if (ACPI_FAILURE(status)) {
725 		return_ACPI_STATUS(status);
726 	}
727 
728 	if (table_index >= acpi_gbl_root_table_list.current_table_count) {
729 
730 		/* The table index does not exist */
731 
732 		(void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
733 		return_ACPI_STATUS(AE_NOT_EXIST);
734 	}
735 
736 	/* Get the owner ID for this table, used to delete namespace nodes */
737 
738 	owner_id = acpi_gbl_root_table_list.tables[table_index].owner_id;
739 	(void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
740 
741 	/*
742 	 * Need to acquire the namespace writer lock to prevent interference
743 	 * with any concurrent namespace walks. The interpreter must be
744 	 * released during the deletion since the acquisition of the deletion
745 	 * lock may block, and also since the execution of a namespace walk
746 	 * must be allowed to use the interpreter.
747 	 */
748 	status = acpi_ut_acquire_write_lock(&acpi_gbl_namespace_rw_lock);
749 	if (ACPI_FAILURE(status)) {
750 		return_ACPI_STATUS(status);
751 	}
752 	acpi_ns_delete_namespace_by_owner(owner_id);
753 	acpi_ut_release_write_lock(&acpi_gbl_namespace_rw_lock);
754 	return_ACPI_STATUS(status);
755 }
756 
757 /*******************************************************************************
758  *
759  * FUNCTION:    acpi_tb_allocate_owner_id
760  *
761  * PARAMETERS:  table_index         - Table index
762  *
763  * RETURN:      Status
764  *
765  * DESCRIPTION: Allocates owner_id in table_desc
766  *
767  ******************************************************************************/
768 
769 acpi_status acpi_tb_allocate_owner_id(u32 table_index)
770 {
771 	acpi_status status = AE_BAD_PARAMETER;
772 
773 	ACPI_FUNCTION_TRACE(tb_allocate_owner_id);
774 
775 	(void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
776 	if (table_index < acpi_gbl_root_table_list.current_table_count) {
777 		status =
778 		    acpi_ut_allocate_owner_id(&
779 					      (acpi_gbl_root_table_list.
780 					       tables[table_index].owner_id));
781 	}
782 
783 	(void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
784 	return_ACPI_STATUS(status);
785 }
786 
787 /*******************************************************************************
788  *
789  * FUNCTION:    acpi_tb_release_owner_id
790  *
791  * PARAMETERS:  table_index         - Table index
792  *
793  * RETURN:      Status
794  *
795  * DESCRIPTION: Releases owner_id in table_desc
796  *
797  ******************************************************************************/
798 
799 acpi_status acpi_tb_release_owner_id(u32 table_index)
800 {
801 	acpi_status status = AE_BAD_PARAMETER;
802 
803 	ACPI_FUNCTION_TRACE(tb_release_owner_id);
804 
805 	(void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
806 	if (table_index < acpi_gbl_root_table_list.current_table_count) {
807 		acpi_ut_release_owner_id(&
808 					 (acpi_gbl_root_table_list.
809 					  tables[table_index].owner_id));
810 		status = AE_OK;
811 	}
812 
813 	(void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
814 	return_ACPI_STATUS(status);
815 }
816 
817 /*******************************************************************************
818  *
819  * FUNCTION:    acpi_tb_get_owner_id
820  *
821  * PARAMETERS:  table_index         - Table index
822  *              owner_id            - Where the table owner_id is returned
823  *
824  * RETURN:      Status
825  *
826  * DESCRIPTION: returns owner_id for the ACPI table
827  *
828  ******************************************************************************/
829 
830 acpi_status acpi_tb_get_owner_id(u32 table_index, acpi_owner_id *owner_id)
831 {
832 	acpi_status status = AE_BAD_PARAMETER;
833 
834 	ACPI_FUNCTION_TRACE(tb_get_owner_id);
835 
836 	(void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
837 	if (table_index < acpi_gbl_root_table_list.current_table_count) {
838 		*owner_id =
839 		    acpi_gbl_root_table_list.tables[table_index].owner_id;
840 		status = AE_OK;
841 	}
842 
843 	(void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
844 	return_ACPI_STATUS(status);
845 }
846 
847 /*******************************************************************************
848  *
849  * FUNCTION:    acpi_tb_is_table_loaded
850  *
851  * PARAMETERS:  table_index         - Index into the root table
852  *
853  * RETURN:      Table Loaded Flag
854  *
855  ******************************************************************************/
856 
857 u8 acpi_tb_is_table_loaded(u32 table_index)
858 {
859 	u8 is_loaded = FALSE;
860 
861 	(void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
862 	if (table_index < acpi_gbl_root_table_list.current_table_count) {
863 		is_loaded = (u8)
864 		    (acpi_gbl_root_table_list.tables[table_index].flags &
865 		     ACPI_TABLE_IS_LOADED);
866 	}
867 
868 	(void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
869 	return (is_loaded);
870 }
871 
872 /*******************************************************************************
873  *
874  * FUNCTION:    acpi_tb_set_table_loaded_flag
875  *
876  * PARAMETERS:  table_index         - Table index
877  *              is_loaded           - TRUE if table is loaded, FALSE otherwise
878  *
879  * RETURN:      None
880  *
881  * DESCRIPTION: Sets the table loaded flag to either TRUE or FALSE.
882  *
883  ******************************************************************************/
884 
885 void acpi_tb_set_table_loaded_flag(u32 table_index, u8 is_loaded)
886 {
887 
888 	(void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
889 	if (table_index < acpi_gbl_root_table_list.current_table_count) {
890 		if (is_loaded) {
891 			acpi_gbl_root_table_list.tables[table_index].flags |=
892 			    ACPI_TABLE_IS_LOADED;
893 		} else {
894 			acpi_gbl_root_table_list.tables[table_index].flags &=
895 			    ~ACPI_TABLE_IS_LOADED;
896 		}
897 	}
898 
899 	(void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
900 }
901 
902 /*******************************************************************************
903  *
904  * FUNCTION:    acpi_tb_load_table
905  *
906  * PARAMETERS:  table_index             - Table index
907  *              parent_node             - Where table index is returned
908  *
909  * RETURN:      Status
910  *
911  * DESCRIPTION: Load an ACPI table
912  *
913  ******************************************************************************/
914 
915 acpi_status
916 acpi_tb_load_table(u32 table_index, struct acpi_namespace_node *parent_node)
917 {
918 	struct acpi_table_header *table;
919 	acpi_status status;
920 	acpi_owner_id owner_id;
921 
922 	ACPI_FUNCTION_TRACE(tb_load_table);
923 
924 	/*
925 	 * Note: Now table is "INSTALLED", it must be validated before
926 	 * using.
927 	 */
928 	status = acpi_get_table_by_index(table_index, &table);
929 	if (ACPI_FAILURE(status)) {
930 		return_ACPI_STATUS(status);
931 	}
932 
933 	status = acpi_ns_load_table(table_index, parent_node);
934 
935 	/*
936 	 * This case handles the legacy option that groups all module-level
937 	 * code blocks together and defers execution until all of the tables
938 	 * are loaded. Execute all of these blocks at this time.
939 	 * Execute any module-level code that was detected during the table
940 	 * load phase.
941 	 *
942 	 * Note: this option is deprecated and will be eliminated in the
943 	 * future. Use of this option can cause problems with AML code that
944 	 * depends upon in-order immediate execution of module-level code.
945 	 */
946 	acpi_ns_exec_module_code_list();
947 
948 	/*
949 	 * Update GPEs for any new _Lxx/_Exx methods. Ignore errors. The host is
950 	 * responsible for discovering any new wake GPEs by running _PRW methods
951 	 * that may have been loaded by this table.
952 	 */
953 	status = acpi_tb_get_owner_id(table_index, &owner_id);
954 	if (ACPI_SUCCESS(status)) {
955 		acpi_ev_update_gpes(owner_id);
956 	}
957 
958 	/* Invoke table handler */
959 
960 	acpi_tb_notify_table(ACPI_TABLE_EVENT_LOAD, table);
961 	return_ACPI_STATUS(status);
962 }
963 
964 /*******************************************************************************
965  *
966  * FUNCTION:    acpi_tb_install_and_load_table
967  *
968  * PARAMETERS:  address                 - Physical address of the table
969  *              flags                   - Allocation flags of the table
970  *              override                - Whether override should be performed
971  *              table_index             - Where table index is returned
972  *
973  * RETURN:      Status
974  *
975  * DESCRIPTION: Install and load an ACPI table
976  *
977  ******************************************************************************/
978 
979 acpi_status
980 acpi_tb_install_and_load_table(acpi_physical_address address,
981 			       u8 flags, u8 override, u32 *table_index)
982 {
983 	acpi_status status;
984 	u32 i;
985 
986 	ACPI_FUNCTION_TRACE(tb_install_and_load_table);
987 
988 	/* Install the table and load it into the namespace */
989 
990 	status = acpi_tb_install_standard_table(address, flags, TRUE,
991 						override, &i);
992 	if (ACPI_FAILURE(status)) {
993 		goto exit;
994 	}
995 
996 	status = acpi_tb_load_table(i, acpi_gbl_root_node);
997 
998 exit:
999 	*table_index = i;
1000 	return_ACPI_STATUS(status);
1001 }
1002 
1003 ACPI_EXPORT_SYMBOL(acpi_tb_install_and_load_table)
1004 
1005 /*******************************************************************************
1006  *
1007  * FUNCTION:    acpi_tb_unload_table
1008  *
1009  * PARAMETERS:  table_index             - Table index
1010  *
1011  * RETURN:      Status
1012  *
1013  * DESCRIPTION: Unload an ACPI table
1014  *
1015  ******************************************************************************/
1016 
1017 acpi_status acpi_tb_unload_table(u32 table_index)
1018 {
1019 	acpi_status status = AE_OK;
1020 	struct acpi_table_header *table;
1021 
1022 	ACPI_FUNCTION_TRACE(tb_unload_table);
1023 
1024 	/* Ensure the table is still loaded */
1025 
1026 	if (!acpi_tb_is_table_loaded(table_index)) {
1027 		return_ACPI_STATUS(AE_NOT_EXIST);
1028 	}
1029 
1030 	/* Invoke table handler */
1031 
1032 	status = acpi_get_table_by_index(table_index, &table);
1033 	if (ACPI_SUCCESS(status)) {
1034 		acpi_tb_notify_table(ACPI_TABLE_EVENT_UNLOAD, table);
1035 	}
1036 
1037 	/* Delete the portion of the namespace owned by this table */
1038 
1039 	status = acpi_tb_delete_namespace_by_owner(table_index);
1040 	if (ACPI_FAILURE(status)) {
1041 		return_ACPI_STATUS(status);
1042 	}
1043 
1044 	(void)acpi_tb_release_owner_id(table_index);
1045 	acpi_tb_set_table_loaded_flag(table_index, FALSE);
1046 	return_ACPI_STATUS(status);
1047 }
1048 
1049 ACPI_EXPORT_SYMBOL(acpi_tb_unload_table)
1050 
1051 /*******************************************************************************
1052  *
1053  * FUNCTION:    acpi_tb_notify_table
1054  *
1055  * PARAMETERS:  event               - Table event
1056  *              table               - Validated table pointer
1057  *
1058  * RETURN:      None
1059  *
1060  * DESCRIPTION: Notify a table event to the users.
1061  *
1062  ******************************************************************************/
1063 
1064 void acpi_tb_notify_table(u32 event, void *table)
1065 {
1066 	/* Invoke table handler if present */
1067 
1068 	if (acpi_gbl_table_handler) {
1069 		(void)acpi_gbl_table_handler(event, table,
1070 					     acpi_gbl_table_handler_context);
1071 	}
1072 }
1073