1
2
3
4
5
6
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
17ACPI_MODULE_NAME("tbdata")
18
19
20static acpi_status
21acpi_tb_check_duplication(struct acpi_table_desc *table_desc, u32 *table_index);
22
23static u8
24acpi_tb_compare_tables(struct acpi_table_desc *table_desc, u32 table_index);
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40static u8
41acpi_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
58
59
60 is_identical = (u8)((table_desc->length != table_length ||
61 memcmp(table_desc->pointer, table, table_length)) ?
62 FALSE : TRUE);
63
64
65
66 acpi_tb_release_table(table, table_length, table_flags);
67 return (is_identical);
68}
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85void
86acpi_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
93
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118acpi_status
119acpi_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
146
147 if (!table) {
148 return (AE_NO_MEMORY);
149 }
150
151
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
162
163
164
165
166
167
168
169
170
171
172
173void
174acpi_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
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209acpi_status
210acpi_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
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
252
253 return (AE_NO_MEMORY);
254}
255
256
257
258
259
260
261
262
263
264
265
266
267
268void acpi_tb_release_temp_table(struct acpi_table_desc *table_desc)
269{
270
271
272
273
274
275
276 acpi_tb_invalidate_table(table_desc);
277}
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292acpi_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
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
315
316
317
318
319
320
321
322
323
324
325void acpi_tb_invalidate_table(struct acpi_table_desc *table_desc)
326{
327
328 ACPI_FUNCTION_TRACE(tb_invalidate_table);
329
330
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
346
347
348
349
350
351
352
353
354
355
356acpi_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
362
363
364
365
366
367
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
378
379
380
381
382
383
384
385
386
387
388
389
390
391static acpi_status
392acpi_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
399
400 for (i = 0; i < acpi_gbl_root_table_list.current_table_count; ++i) {
401
402
403
404 if (!
405 (acpi_gbl_root_table_list.tables[i].
406 flags & ACPI_TABLE_IS_VERIFIED)) {
407 continue;
408 }
409
410
411
412
413
414 if (!acpi_tb_compare_tables(table_desc, i)) {
415 continue;
416 }
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432 if (acpi_gbl_root_table_list.tables[i].flags &
433 ACPI_TABLE_IS_LOADED) {
434
435
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
445
446 return_ACPI_STATUS(AE_OK);
447}
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466acpi_status
467acpi_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
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
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
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
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
540invalidate_and_exit:
541 acpi_tb_invalidate_table(table_desc);
542 return_ACPI_STATUS(status);
543}
544
545
546
547
548
549
550
551
552
553
554
555
556
557acpi_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
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
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
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
620
621
622
623
624
625
626
627
628
629
630acpi_status
631acpi_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
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
663
664
665
666
667
668
669
670
671
672void 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
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
688
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
707
708
709
710
711
712
713
714
715
716acpi_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
731
732 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
733 return_ACPI_STATUS(AE_NOT_EXIST);
734 }
735
736
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
743
744
745
746
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
760
761
762
763
764
765
766
767
768
769acpi_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
790
791
792
793
794
795
796
797
798
799acpi_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
820
821
822
823
824
825
826
827
828
829
830acpi_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
850
851
852
853
854
855
856
857u8 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
875
876
877
878
879
880
881
882
883
884
885void 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
905
906
907
908
909
910
911
912
913
914
915acpi_status
916acpi_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
926
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
937
938
939
940
941
942
943
944
945
946 acpi_ns_exec_module_code_list();
947
948
949
950
951
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
959
960 acpi_tb_notify_table(ACPI_TABLE_EVENT_LOAD, table);
961 return_ACPI_STATUS(status);
962}
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979acpi_status
980acpi_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
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
998exit:
999 *table_index = i;
1000 return_ACPI_STATUS(status);
1001}
1002
1003ACPI_EXPORT_SYMBOL(acpi_tb_install_and_load_table)
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017acpi_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
1025
1026 if (!acpi_tb_is_table_loaded(table_index)) {
1027 return_ACPI_STATUS(AE_NOT_EXIST);
1028 }
1029
1030
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
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
1049ACPI_EXPORT_SYMBOL(acpi_tb_unload_table)
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064void acpi_tb_notify_table(u32 event, void *table)
1065{
1066
1067
1068 if (acpi_gbl_table_handler) {
1069 (void)acpi_gbl_table_handler(event, table,
1070 acpi_gbl_table_handler_context);
1071 }
1072}
1073