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
acpi_tb_compare_tables(struct acpi_table_desc * table_desc,u32 table_index)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
acpi_tb_init_table_descriptor(struct acpi_table_desc * table_desc,acpi_physical_address address,u8 flags,struct acpi_table_header * table)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
acpi_tb_acquire_table(struct acpi_table_desc * table_desc,struct acpi_table_header ** table_ptr,u32 * table_length,u8 * table_flags)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
acpi_tb_release_table(struct acpi_table_header * table,u32 table_length,u8 table_flags)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
acpi_tb_acquire_temp_table(struct acpi_table_desc * table_desc,acpi_physical_address address,u8 flags)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
acpi_tb_release_temp_table(struct acpi_table_desc * table_desc)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
acpi_tb_validate_table(struct acpi_table_desc * table_desc)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
acpi_tb_invalidate_table(struct acpi_table_desc * table_desc)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
acpi_tb_validate_temp_table(struct acpi_table_desc * table_desc)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
acpi_tb_check_duplication(struct acpi_table_desc * table_desc,u32 * table_index)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
acpi_tb_verify_temp_table(struct acpi_table_desc * table_desc,char * signature,u32 * table_index)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, status,
520 "%4.4s 0x%8.8X%8.8X"
521 " Table is already loaded",
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
acpi_tb_resize_root_table_list(void)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
acpi_tb_get_next_table_descriptor(u32 * table_index,struct acpi_table_desc ** table_desc)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
acpi_tb_terminate(void)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
acpi_tb_delete_namespace_by_owner(u32 table_index)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
acpi_tb_allocate_owner_id(u32 table_index)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
acpi_tb_release_owner_id(u32 table_index)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
acpi_tb_get_owner_id(u32 table_index,acpi_owner_id * owner_id)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
acpi_tb_is_table_loaded(u32 table_index)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
acpi_tb_set_table_loaded_flag(u32 table_index,u8 is_loaded)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
acpi_tb_load_table(u32 table_index,struct acpi_namespace_node * parent_node)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
acpi_tb_install_and_load_table(acpi_physical_address address,u8 flags,u8 override,u32 * table_index)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
ACPI_EXPORT_SYMBOL(acpi_tb_install_and_load_table)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
ACPI_EXPORT_SYMBOL(acpi_tb_unload_table)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
