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