1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45#include <acpi/acpi.h>
46#include "accommon.h"
47#include "acnamesp.h"
48#include "actables.h"
49
50#define _COMPONENT ACPI_TABLES
51ACPI_MODULE_NAME("tbxface")
52
53
54static acpi_status acpi_tb_load_namespace(void);
55
56static int no_auto_ssdt;
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72acpi_status acpi_allocate_root_table(u32 initial_table_count)
73{
74
75 acpi_gbl_root_table_list.size = initial_table_count;
76 acpi_gbl_root_table_list.flags = ACPI_ROOT_ALLOW_RESIZE;
77
78 return (acpi_tb_resize_root_table_list());
79}
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107acpi_status __init
108acpi_initialize_tables(struct acpi_table_desc * initial_table_array,
109 u32 initial_table_count, u8 allow_resize)
110{
111 acpi_physical_address rsdp_address;
112 acpi_status status;
113
114 ACPI_FUNCTION_TRACE(acpi_initialize_tables);
115
116
117
118
119
120 if (!initial_table_array) {
121 status = acpi_allocate_root_table(initial_table_count);
122 if (ACPI_FAILURE(status)) {
123 return_ACPI_STATUS(status);
124 }
125 } else {
126
127
128 ACPI_MEMSET(initial_table_array, 0,
129 (acpi_size) initial_table_count *
130 sizeof(struct acpi_table_desc));
131
132 acpi_gbl_root_table_list.tables = initial_table_array;
133 acpi_gbl_root_table_list.size = initial_table_count;
134 acpi_gbl_root_table_list.flags = ACPI_ROOT_ORIGIN_UNKNOWN;
135 if (allow_resize) {
136 acpi_gbl_root_table_list.flags |=
137 ACPI_ROOT_ALLOW_RESIZE;
138 }
139 }
140
141
142
143 rsdp_address = acpi_os_get_root_pointer();
144 if (!rsdp_address) {
145 return_ACPI_STATUS(AE_NOT_FOUND);
146 }
147
148
149
150
151
152
153 status = acpi_tb_parse_root_table(rsdp_address);
154 return_ACPI_STATUS(status);
155}
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171acpi_status acpi_reallocate_root_table(void)
172{
173 struct acpi_table_desc *tables;
174 acpi_size new_size;
175
176 ACPI_FUNCTION_TRACE(acpi_reallocate_root_table);
177
178
179
180
181
182 if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) {
183 return_ACPI_STATUS(AE_SUPPORT);
184 }
185
186 new_size = ((acpi_size) acpi_gbl_root_table_list.count +
187 ACPI_ROOT_TABLE_SIZE_INCREMENT) *
188 sizeof(struct acpi_table_desc);
189
190
191
192 tables = ACPI_ALLOCATE_ZEROED(new_size);
193 if (!tables) {
194 return_ACPI_STATUS(AE_NO_MEMORY);
195 }
196
197 ACPI_MEMCPY(tables, acpi_gbl_root_table_list.tables, new_size);
198
199 acpi_gbl_root_table_list.size = acpi_gbl_root_table_list.count;
200 acpi_gbl_root_table_list.tables = tables;
201 acpi_gbl_root_table_list.flags =
202 ACPI_ROOT_ORIGIN_ALLOCATED | ACPI_ROOT_ALLOW_RESIZE;
203
204 return_ACPI_STATUS(AE_OK);
205}
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222acpi_status acpi_load_table(struct acpi_table_header *table_ptr)
223{
224 acpi_status status;
225 u32 table_index;
226 struct acpi_table_desc table_desc;
227
228 if (!table_ptr)
229 return AE_BAD_PARAMETER;
230
231 ACPI_MEMSET(&table_desc, 0, sizeof(struct acpi_table_desc));
232 table_desc.pointer = table_ptr;
233 table_desc.length = table_ptr->length;
234 table_desc.flags = ACPI_TABLE_ORIGIN_UNKNOWN;
235
236
237
238
239 status = acpi_tb_add_table(&table_desc, &table_index);
240 if (ACPI_FAILURE(status)) {
241 return status;
242 }
243 status = acpi_ns_load_table(table_index, acpi_gbl_root_node);
244 return status;
245}
246
247ACPI_EXPORT_SYMBOL(acpi_load_table)
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265acpi_status
266acpi_get_table_header(char *signature,
267 u32 instance, struct acpi_table_header *out_table_header)
268{
269 u32 i;
270 u32 j;
271 struct acpi_table_header *header;
272
273
274
275 if (!signature || !out_table_header) {
276 return (AE_BAD_PARAMETER);
277 }
278
279
280
281 for (i = 0, j = 0; i < acpi_gbl_root_table_list.count; i++) {
282 if (!ACPI_COMPARE_NAME
283 (&(acpi_gbl_root_table_list.tables[i].signature),
284 signature)) {
285 continue;
286 }
287
288 if (++j < instance) {
289 continue;
290 }
291
292 if (!acpi_gbl_root_table_list.tables[i].pointer) {
293 if ((acpi_gbl_root_table_list.tables[i].flags &
294 ACPI_TABLE_ORIGIN_MASK) ==
295 ACPI_TABLE_ORIGIN_MAPPED) {
296 header =
297 acpi_os_map_memory(acpi_gbl_root_table_list.
298 tables[i].address,
299 sizeof(struct
300 acpi_table_header));
301 if (!header) {
302 return AE_NO_MEMORY;
303 }
304 ACPI_MEMCPY(out_table_header, header,
305 sizeof(struct acpi_table_header));
306 acpi_os_unmap_memory(header,
307 sizeof(struct
308 acpi_table_header));
309 } else {
310 return AE_NOT_FOUND;
311 }
312 } else {
313 ACPI_MEMCPY(out_table_header,
314 acpi_gbl_root_table_list.tables[i].pointer,
315 sizeof(struct acpi_table_header));
316 }
317 return (AE_OK);
318 }
319
320 return (AE_NOT_FOUND);
321}
322
323ACPI_EXPORT_SYMBOL(acpi_get_table_header)
324
325
326
327
328
329
330
331
332
333
334
335
336acpi_status acpi_unload_table_id(acpi_owner_id id)
337{
338 int i;
339 acpi_status status = AE_NOT_EXIST;
340
341 ACPI_FUNCTION_TRACE(acpi_unload_table_id);
342
343
344 for (i = 0; i < acpi_gbl_root_table_list.count; ++i) {
345 if (id != acpi_gbl_root_table_list.tables[i].owner_id) {
346 continue;
347 }
348
349
350
351
352
353
354 acpi_tb_delete_namespace_by_owner(i);
355 status = acpi_tb_release_owner_id(i);
356 acpi_tb_set_table_loaded_flag(i, FALSE);
357 break;
358 }
359 return_ACPI_STATUS(status);
360}
361
362ACPI_EXPORT_SYMBOL(acpi_unload_table_id)
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377acpi_status
378acpi_get_table_with_size(char *signature,
379 u32 instance, struct acpi_table_header **out_table,
380 acpi_size *tbl_size)
381{
382 u32 i;
383 u32 j;
384 acpi_status status;
385
386
387
388 if (!signature || !out_table) {
389 return (AE_BAD_PARAMETER);
390 }
391
392
393
394 for (i = 0, j = 0; i < acpi_gbl_root_table_list.count; i++) {
395 if (!ACPI_COMPARE_NAME
396 (&(acpi_gbl_root_table_list.tables[i].signature),
397 signature)) {
398 continue;
399 }
400
401 if (++j < instance) {
402 continue;
403 }
404
405 status =
406 acpi_tb_verify_table(&acpi_gbl_root_table_list.tables[i]);
407 if (ACPI_SUCCESS(status)) {
408 *out_table = acpi_gbl_root_table_list.tables[i].pointer;
409 *tbl_size = acpi_gbl_root_table_list.tables[i].length;
410 }
411
412 if (!acpi_gbl_permanent_mmap) {
413 acpi_gbl_root_table_list.tables[i].pointer = NULL;
414 }
415
416 return (status);
417 }
418
419 return (AE_NOT_FOUND);
420}
421
422acpi_status
423acpi_get_table(char *signature,
424 u32 instance, struct acpi_table_header **out_table)
425{
426 acpi_size tbl_size;
427
428 return acpi_get_table_with_size(signature,
429 instance, out_table, &tbl_size);
430}
431ACPI_EXPORT_SYMBOL(acpi_get_table)
432
433
434
435
436
437
438
439
440
441
442
443
444
445acpi_status
446acpi_get_table_by_index(u32 table_index, struct acpi_table_header **table)
447{
448 acpi_status status;
449
450 ACPI_FUNCTION_TRACE(acpi_get_table_by_index);
451
452
453
454 if (!table) {
455 return_ACPI_STATUS(AE_BAD_PARAMETER);
456 }
457
458 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
459
460
461
462 if (table_index >= acpi_gbl_root_table_list.count) {
463 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
464 return_ACPI_STATUS(AE_BAD_PARAMETER);
465 }
466
467 if (!acpi_gbl_root_table_list.tables[table_index].pointer) {
468
469
470
471 status =
472 acpi_tb_verify_table(&acpi_gbl_root_table_list.
473 tables[table_index]);
474 if (ACPI_FAILURE(status)) {
475 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
476 return_ACPI_STATUS(status);
477 }
478 }
479
480 *table = acpi_gbl_root_table_list.tables[table_index].pointer;
481 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
482 return_ACPI_STATUS(AE_OK);
483}
484
485ACPI_EXPORT_SYMBOL(acpi_get_table_by_index)
486
487
488
489
490
491
492
493
494
495
496
497
498
499static acpi_status acpi_tb_load_namespace(void)
500{
501 acpi_status status;
502 u32 i;
503
504 ACPI_FUNCTION_TRACE(tb_load_namespace);
505
506 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
507
508
509
510
511
512 if (!acpi_gbl_root_table_list.count ||
513 !ACPI_COMPARE_NAME(&
514 (acpi_gbl_root_table_list.
515 tables[ACPI_TABLE_INDEX_DSDT].signature),
516 ACPI_SIG_DSDT)
517 ||
518 ACPI_FAILURE(acpi_tb_verify_table
519 (&acpi_gbl_root_table_list.
520 tables[ACPI_TABLE_INDEX_DSDT]))) {
521 status = AE_NO_ACPI_TABLES;
522 goto unlock_and_exit;
523 }
524
525
526
527 status =
528 acpi_tb_verify_table(&acpi_gbl_root_table_list.
529 tables[ACPI_TABLE_INDEX_DSDT]);
530 if (ACPI_FAILURE(status)) {
531
532 status = AE_NO_ACPI_TABLES;
533 goto unlock_and_exit;
534 }
535
536 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
537
538
539
540 status = acpi_ns_load_table(ACPI_TABLE_INDEX_DSDT, acpi_gbl_root_node);
541 if (ACPI_FAILURE(status)) {
542 return_ACPI_STATUS(status);
543 }
544
545
546
547 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
548 for (i = 0; i < acpi_gbl_root_table_list.count; ++i) {
549 if ((!ACPI_COMPARE_NAME
550 (&(acpi_gbl_root_table_list.tables[i].signature),
551 ACPI_SIG_SSDT)
552 &&
553 !ACPI_COMPARE_NAME(&
554 (acpi_gbl_root_table_list.tables[i].
555 signature), ACPI_SIG_PSDT))
556 ||
557 ACPI_FAILURE(acpi_tb_verify_table
558 (&acpi_gbl_root_table_list.tables[i]))) {
559 continue;
560 }
561
562 if (no_auto_ssdt) {
563 printk(KERN_WARNING "ACPI: SSDT ignored due to \"acpi_no_auto_ssdt\"\n");
564 continue;
565 }
566
567
568
569 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
570 (void)acpi_ns_load_table(i, acpi_gbl_root_node);
571 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
572 }
573
574 ACPI_DEBUG_PRINT((ACPI_DB_INIT, "ACPI Tables successfully acquired\n"));
575
576 unlock_and_exit:
577 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
578 return_ACPI_STATUS(status);
579}
580
581
582
583
584
585
586
587
588
589
590
591
592
593acpi_status acpi_load_tables(void)
594{
595 acpi_status status;
596
597 ACPI_FUNCTION_TRACE(acpi_load_tables);
598
599
600
601 status = acpi_tb_load_namespace();
602 if (ACPI_FAILURE(status)) {
603 ACPI_EXCEPTION((AE_INFO, status,
604 "While loading namespace from ACPI tables"));
605 }
606
607 return_ACPI_STATUS(status);
608}
609
610ACPI_EXPORT_SYMBOL(acpi_load_tables)
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625acpi_status
626acpi_install_table_handler(acpi_tbl_handler handler, void *context)
627{
628 acpi_status status;
629
630 ACPI_FUNCTION_TRACE(acpi_install_table_handler);
631
632 if (!handler) {
633 return_ACPI_STATUS(AE_BAD_PARAMETER);
634 }
635
636 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
637 if (ACPI_FAILURE(status)) {
638 return_ACPI_STATUS(status);
639 }
640
641
642
643 if (acpi_gbl_table_handler) {
644 status = AE_ALREADY_EXISTS;
645 goto cleanup;
646 }
647
648
649
650 acpi_gbl_table_handler = handler;
651 acpi_gbl_table_handler_context = context;
652
653 cleanup:
654 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
655 return_ACPI_STATUS(status);
656}
657
658ACPI_EXPORT_SYMBOL(acpi_install_table_handler)
659
660
661
662
663
664
665
666
667
668
669
670
671
672acpi_status acpi_remove_table_handler(acpi_tbl_handler handler)
673{
674 acpi_status status;
675
676 ACPI_FUNCTION_TRACE(acpi_remove_table_handler);
677
678 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
679 if (ACPI_FAILURE(status)) {
680 return_ACPI_STATUS(status);
681 }
682
683
684
685 if (!handler || handler != acpi_gbl_table_handler) {
686 status = AE_BAD_PARAMETER;
687 goto cleanup;
688 }
689
690
691
692 acpi_gbl_table_handler = NULL;
693
694 cleanup:
695 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
696 return_ACPI_STATUS(status);
697}
698
699ACPI_EXPORT_SYMBOL(acpi_remove_table_handler)
700
701
702static int __init acpi_no_auto_ssdt_setup(char *s) {
703
704 printk(KERN_NOTICE "ACPI: SSDT auto-load disabled\n");
705
706 no_auto_ssdt = 1;
707
708 return 1;
709}
710
711__setup("acpi_no_auto_ssdt", acpi_no_auto_ssdt_setup);
712