?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.16-rc1
[cris-mirror.git] / tools / power / acpi / os_specific / service_layers / oslinuxtbl.c
blobe7347edfd4f9f7de127eb4cca5ac9803779a6d14
1 /******************************************************************************
2 *
3 * Module Name: oslinuxtbl - Linux OSL for obtaining ACPI tables
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2018, Intel Corp.
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions, and the following disclaimer,
16 * without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 * substantially similar to the "NO WARRANTY" disclaimer below
19 * ("Disclaimer") and any redistribution must be conditioned upon
20 * including a substantially similar Disclaimer requirement for further
21 * binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 * of any contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
25 *
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
29 *
30 * NO WARRANTY
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
42 */
43
44 #include "acpidump.h"
45
46 #define _COMPONENT ACPI_OS_SERVICES
47 ACPI_MODULE_NAME("oslinuxtbl")
48
49 #ifndef PATH_MAX
50 #define PATH_MAX 256
51 #endif
52 /* List of information about obtained ACPI tables */
53 typedef struct osl_table_info {
54 struct osl_table_info *next;
55 u32 instance;
56 char signature[ACPI_NAME_SIZE];
57
58 } osl_table_info;
59
60 /* Local prototypes */
61
62 static acpi_status osl_table_initialize(void);
63
64 static acpi_status
65 osl_table_name_from_file(char *filename, char *signature, u32 *instance);
66
67 static acpi_status osl_add_table_to_list(char *signature, u32 instance);
68
69 static acpi_status
70 osl_read_table_from_file(char *filename,
71 acpi_size file_offset,
72 char *signature, struct acpi_table_header **table);
73
74 static acpi_status
75 osl_map_table(acpi_size address,
76 char *signature, struct acpi_table_header **table);
77
78 static void osl_unmap_table(struct acpi_table_header *table);
79
80 static acpi_physical_address
81 osl_find_rsdp_via_efi_by_keyword(FILE * file, const char *keyword);
82
83 static acpi_physical_address osl_find_rsdp_via_efi(void);
84
85 static acpi_status osl_load_rsdp(void);
86
87 static acpi_status osl_list_customized_tables(char *directory);
88
89 static acpi_status
90 osl_get_customized_table(char *pathname,
91 char *signature,
92 u32 instance,
93 struct acpi_table_header **table,
94 acpi_physical_address *address);
95
96 static acpi_status osl_list_bios_tables(void);
97
98 static acpi_status
99 osl_get_bios_table(char *signature,
100 u32 instance,
101 struct acpi_table_header **table,
102 acpi_physical_address *address);
103
104 static acpi_status osl_get_last_status(acpi_status default_status);
105
106 /* File locations */
107
108 #define DYNAMIC_TABLE_DIR "/sys/firmware/acpi/tables/dynamic"
109 #define STATIC_TABLE_DIR "/sys/firmware/acpi/tables"
110 #define EFI_SYSTAB "/sys/firmware/efi/systab"
111
112 /* Should we get dynamically loaded SSDTs from DYNAMIC_TABLE_DIR? */
113
114 u8 gbl_dump_dynamic_tables = TRUE;
115
116 /* Initialization flags */
117
118 u8 gbl_table_list_initialized = FALSE;
119
120 /* Local copies of main ACPI tables */
121
122 struct acpi_table_rsdp gbl_rsdp;
123 struct acpi_table_fadt *gbl_fadt = NULL;
124 struct acpi_table_rsdt *gbl_rsdt = NULL;
125 struct acpi_table_xsdt *gbl_xsdt = NULL;
126
127 /* Table addresses */
128
129 acpi_physical_address gbl_fadt_address = 0;
130 acpi_physical_address gbl_rsdp_address = 0;
131
132 /* Revision of RSD PTR */
133
134 u8 gbl_revision = 0;
135
136 struct osl_table_info *gbl_table_list_head = NULL;
137 u32 gbl_table_count = 0;
138
139 /******************************************************************************
140 *
141 * FUNCTION: osl_get_last_status
142 *
143 * PARAMETERS: default_status - Default error status to return
144 *
145 * RETURN: Status; Converted from errno.
146 *
147 * DESCRIPTION: Get last errno and conver it to acpi_status.
148 *
149 *****************************************************************************/
150
151 static acpi_status osl_get_last_status(acpi_status default_status)
152 {
153
154 switch (errno) {
155 case EACCES:
156 case EPERM:
157
158 return (AE_ACCESS);
159
160 case ENOENT:
161
162 return (AE_NOT_FOUND);
163
164 case ENOMEM:
165
166 return (AE_NO_MEMORY);
167
168 default:
169
170 return (default_status);
171 }
172 }
173
174 /******************************************************************************
175 *
176 * FUNCTION: acpi_os_get_table_by_address
177 *
178 * PARAMETERS: address - Physical address of the ACPI table
179 * table - Where a pointer to the table is returned
180 *
181 * RETURN: Status; Table buffer is returned if AE_OK.
182 * AE_NOT_FOUND: A valid table was not found at the address
183 *
184 * DESCRIPTION: Get an ACPI table via a physical memory address.
185 *
186 *****************************************************************************/
187
188 acpi_status
189 acpi_os_get_table_by_address(acpi_physical_address address,
190 struct acpi_table_header **table)
191 {
192 u32 table_length;
193 struct acpi_table_header *mapped_table;
194 struct acpi_table_header *local_table = NULL;
195 acpi_status status = AE_OK;
196
197 /* Get main ACPI tables from memory on first invocation of this function */
198
199 status = osl_table_initialize();
200 if (ACPI_FAILURE(status)) {
201 return (status);
202 }
203
204 /* Map the table and validate it */
205
206 status = osl_map_table(address, NULL, &mapped_table);
207 if (ACPI_FAILURE(status)) {
208 return (status);
209 }
210
211 /* Copy table to local buffer and return it */
212
213 table_length = ap_get_table_length(mapped_table);
214 if (table_length == 0) {
215 status = AE_BAD_HEADER;
216 goto exit;
217 }
218
219 local_table = calloc(1, table_length);
220 if (!local_table) {
221 status = AE_NO_MEMORY;
222 goto exit;
223 }
224
225 memcpy(local_table, mapped_table, table_length);
226
227 exit:
228 osl_unmap_table(mapped_table);
229 *table = local_table;
230 return (status);
231 }
232
233 /******************************************************************************
234 *
235 * FUNCTION: acpi_os_get_table_by_name
236 *
237 * PARAMETERS: signature - ACPI Signature for desired table. Must be
238 * a null terminated 4-character string.
239 * instance - Multiple table support for SSDT/UEFI (0...n)
240 * Must be 0 for other tables.
241 * table - Where a pointer to the table is returned
242 * address - Where the table physical address is returned
243 *
244 * RETURN: Status; Table buffer and physical address returned if AE_OK.
245 * AE_LIMIT: Instance is beyond valid limit
246 * AE_NOT_FOUND: A table with the signature was not found
247 *
248 * NOTE: Assumes the input signature is uppercase.
249 *
250 *****************************************************************************/
251
252 acpi_status
253 acpi_os_get_table_by_name(char *signature,
254 u32 instance,
255 struct acpi_table_header **table,
256 acpi_physical_address *address)
257 {
258 acpi_status status;
259
260 /* Get main ACPI tables from memory on first invocation of this function */
261
262 status = osl_table_initialize();
263 if (ACPI_FAILURE(status)) {
264 return (status);
265 }
266
267 /* Not a main ACPI table, attempt to extract it from the RSDT/XSDT */
268
269 if (!gbl_dump_customized_tables) {
270
271 /* Attempt to get the table from the memory */
272
273 status =
274 osl_get_bios_table(signature, instance, table, address);
275 } else {
276 /* Attempt to get the table from the static directory */
277
278 status = osl_get_customized_table(STATIC_TABLE_DIR, signature,
279 instance, table, address);
280 }
281
282 if (ACPI_FAILURE(status) && status == AE_LIMIT) {
283 if (gbl_dump_dynamic_tables) {
284
285 /* Attempt to get a dynamic table */
286
287 status =
288 osl_get_customized_table(DYNAMIC_TABLE_DIR,
289 signature, instance, table,
290 address);
291 }
292 }
293
294 return (status);
295 }
296
297 /******************************************************************************
298 *
299 * FUNCTION: osl_add_table_to_list
300 *
301 * PARAMETERS: signature - Table signature
302 * instance - Table instance
303 *
304 * RETURN: Status; Successfully added if AE_OK.
305 * AE_NO_MEMORY: Memory allocation error
306 *
307 * DESCRIPTION: Insert a table structure into OSL table list.
308 *
309 *****************************************************************************/
310
311 static acpi_status osl_add_table_to_list(char *signature, u32 instance)
312 {
313 struct osl_table_info *new_info;
314 struct osl_table_info *next;
315 u32 next_instance = 0;
316 u8 found = FALSE;
317
318 new_info = calloc(1, sizeof(struct osl_table_info));
319 if (!new_info) {
320 return (AE_NO_MEMORY);
321 }
322
323 ACPI_MOVE_NAME(new_info->signature, signature);
324
325 if (!gbl_table_list_head) {
326 gbl_table_list_head = new_info;
327 } else {
328 next = gbl_table_list_head;
329 while (1) {
330 if (ACPI_COMPARE_NAME(next->signature, signature)) {
331 if (next->instance == instance) {
332 found = TRUE;
333 }
334 if (next->instance >= next_instance) {
335 next_instance = next->instance + 1;
336 }
337 }
338
339 if (!next->next) {
340 break;
341 }
342 next = next->next;
343 }
344 next->next = new_info;
345 }
346
347 if (found) {
348 if (instance) {
349 fprintf(stderr,
350 "%4.4s: Warning unmatched table instance %d, expected %d\n",
351 signature, instance, next_instance);
352 }
353 instance = next_instance;
354 }
355
356 new_info->instance = instance;
357 gbl_table_count++;
358
359 return (AE_OK);
360 }
361
362 /******************************************************************************
363 *
364 * FUNCTION: acpi_os_get_table_by_index
365 *
366 * PARAMETERS: index - Which table to get
367 * table - Where a pointer to the table is returned
368 * instance - Where a pointer to the table instance no. is
369 * returned
370 * address - Where the table physical address is returned
371 *
372 * RETURN: Status; Table buffer and physical address returned if AE_OK.
373 * AE_LIMIT: Index is beyond valid limit
374 *
375 * DESCRIPTION: Get an ACPI table via an index value (0 through n). Returns
376 * AE_LIMIT when an invalid index is reached. Index is not
377 * necessarily an index into the RSDT/XSDT.
378 *
379 *****************************************************************************/
380
381 acpi_status
382 acpi_os_get_table_by_index(u32 index,
383 struct acpi_table_header **table,
384 u32 *instance, acpi_physical_address *address)
385 {
386 struct osl_table_info *info;
387 acpi_status status;
388 u32 i;
389
390 /* Get main ACPI tables from memory on first invocation of this function */
391
392 status = osl_table_initialize();
393 if (ACPI_FAILURE(status)) {
394 return (status);
395 }
396
397 /* Validate Index */
398
399 if (index >= gbl_table_count) {
400 return (AE_LIMIT);
401 }
402
403 /* Point to the table list entry specified by the Index argument */
404
405 info = gbl_table_list_head;
406 for (i = 0; i < index; i++) {
407 info = info->next;
408 }
409
410 /* Now we can just get the table via the signature */
411
412 status = acpi_os_get_table_by_name(info->signature, info->instance,
413 table, address);
414
415 if (ACPI_SUCCESS(status)) {
416 *instance = info->instance;
417 }
418 return (status);
419 }
420
421 /******************************************************************************
422 *
423 * FUNCTION: osl_find_rsdp_via_efi_by_keyword
424 *
425 * PARAMETERS: keyword - Character string indicating ACPI GUID version
426 * in the EFI table
427 *
428 * RETURN: RSDP address if found
429 *
430 * DESCRIPTION: Find RSDP address via EFI using keyword indicating the ACPI
431 * GUID version.
432 *
433 *****************************************************************************/
434
435 static acpi_physical_address
436 osl_find_rsdp_via_efi_by_keyword(FILE * file, const char *keyword)
437 {
438 char buffer[80];
439 unsigned long long address = 0;
440 char format[32];
441
442 snprintf(format, 32, "%s=%s", keyword, "%llx");
443 fseek(file, 0, SEEK_SET);
444 while (fgets(buffer, 80, file)) {
445 if (sscanf(buffer, format, &address) == 1) {
446 break;
447 }
448 }
449
450 return ((acpi_physical_address)(address));
451 }
452
453 /******************************************************************************
454 *
455 * FUNCTION: osl_find_rsdp_via_efi
456 *
457 * PARAMETERS: None
458 *
459 * RETURN: RSDP address if found
460 *
461 * DESCRIPTION: Find RSDP address via EFI.
462 *
463 *****************************************************************************/
464
465 static acpi_physical_address osl_find_rsdp_via_efi(void)
466 {
467 FILE *file;
468 acpi_physical_address address = 0;
469
470 file = fopen(EFI_SYSTAB, "r");
471 if (file) {
472 address = osl_find_rsdp_via_efi_by_keyword(file, "ACPI20");
473 if (!address) {
474 address =
475 osl_find_rsdp_via_efi_by_keyword(file, "ACPI");
476 }
477 fclose(file);
478 }
479
480 return (address);
481 }
482
483 /******************************************************************************
484 *
485 * FUNCTION: osl_load_rsdp
486 *
487 * PARAMETERS: None
488 *
489 * RETURN: Status
490 *
491 * DESCRIPTION: Scan and load RSDP.
492 *
493 *****************************************************************************/
494
495 static acpi_status osl_load_rsdp(void)
496 {
497 struct acpi_table_header *mapped_table;
498 u8 *rsdp_address;
499 acpi_physical_address rsdp_base;
500 acpi_size rsdp_size;
501
502 /* Get RSDP from memory */
503
504 rsdp_size = sizeof(struct acpi_table_rsdp);
505 if (gbl_rsdp_base) {
506 rsdp_base = gbl_rsdp_base;
507 } else {
508 rsdp_base = osl_find_rsdp_via_efi();
509 }
510
511 if (!rsdp_base) {
512 rsdp_base = ACPI_HI_RSDP_WINDOW_BASE;
513 rsdp_size = ACPI_HI_RSDP_WINDOW_SIZE;
514 }
515
516 rsdp_address = acpi_os_map_memory(rsdp_base, rsdp_size);
517 if (!rsdp_address) {
518 return (osl_get_last_status(AE_BAD_ADDRESS));
519 }
520
521 /* Search low memory for the RSDP */
522
523 mapped_table = ACPI_CAST_PTR(struct acpi_table_header,
524 acpi_tb_scan_memory_for_rsdp(rsdp_address,
525 rsdp_size));
526 if (!mapped_table) {
527 acpi_os_unmap_memory(rsdp_address, rsdp_size);
528 return (AE_NOT_FOUND);
529 }
530
531 gbl_rsdp_address =
532 rsdp_base + (ACPI_CAST8(mapped_table) - rsdp_address);
533
534 memcpy(&gbl_rsdp, mapped_table, sizeof(struct acpi_table_rsdp));
535 acpi_os_unmap_memory(rsdp_address, rsdp_size);
536
537 return (AE_OK);
538 }
539
540 /******************************************************************************
541 *
542 * FUNCTION: osl_can_use_xsdt
543 *
544 * PARAMETERS: None
545 *
546 * RETURN: TRUE if XSDT is allowed to be used.
547 *
548 * DESCRIPTION: This function collects logic that can be used to determine if
549 * XSDT should be used instead of RSDT.
550 *
551 *****************************************************************************/
552
553 static u8 osl_can_use_xsdt(void)
554 {
555 if (gbl_revision && !acpi_gbl_do_not_use_xsdt) {
556 return (TRUE);
557 } else {
558 return (FALSE);
559 }
560 }
561
562 /******************************************************************************
563 *
564 * FUNCTION: osl_table_initialize
565 *
566 * PARAMETERS: None
567 *
568 * RETURN: Status
569 *
570 * DESCRIPTION: Initialize ACPI table data. Get and store main ACPI tables to
571 * local variables. Main ACPI tables include RSDT, FADT, RSDT,
572 * and/or XSDT.
573 *
574 *****************************************************************************/
575
576 static acpi_status osl_table_initialize(void)
577 {
578 acpi_status status;
579 acpi_physical_address address;
580
581 if (gbl_table_list_initialized) {
582 return (AE_OK);
583 }
584
585 if (!gbl_dump_customized_tables) {
586
587 /* Get RSDP from memory */
588
589 status = osl_load_rsdp();
590 if (ACPI_FAILURE(status)) {
591 return (status);
592 }
593
594 /* Get XSDT from memory */
595
596 if (gbl_rsdp.revision && !gbl_do_not_dump_xsdt) {
597 if (gbl_xsdt) {
598 free(gbl_xsdt);
599 gbl_xsdt = NULL;
600 }
601
602 gbl_revision = 2;
603 status = osl_get_bios_table(ACPI_SIG_XSDT, 0,
604 ACPI_CAST_PTR(struct
605 acpi_table_header
606 *, &gbl_xsdt),
607 &address);
608 if (ACPI_FAILURE(status)) {
609 return (status);
610 }
611 }
612
613 /* Get RSDT from memory */
614
615 if (gbl_rsdp.rsdt_physical_address) {
616 if (gbl_rsdt) {
617 free(gbl_rsdt);
618 gbl_rsdt = NULL;
619 }
620
621 status = osl_get_bios_table(ACPI_SIG_RSDT, 0,
622 ACPI_CAST_PTR(struct
623 acpi_table_header
624 *, &gbl_rsdt),
625 &address);
626 if (ACPI_FAILURE(status)) {
627 return (status);
628 }
629 }
630
631 /* Get FADT from memory */
632
633 if (gbl_fadt) {
634 free(gbl_fadt);
635 gbl_fadt = NULL;
636 }
637
638 status = osl_get_bios_table(ACPI_SIG_FADT, 0,
639 ACPI_CAST_PTR(struct
640 acpi_table_header *,
641 &gbl_fadt),
642 &gbl_fadt_address);
643 if (ACPI_FAILURE(status)) {
644 return (status);
645 }
646
647 /* Add mandatory tables to global table list first */
648
649 status = osl_add_table_to_list(ACPI_RSDP_NAME, 0);
650 if (ACPI_FAILURE(status)) {
651 return (status);
652 }
653
654 status = osl_add_table_to_list(ACPI_SIG_RSDT, 0);
655 if (ACPI_FAILURE(status)) {
656 return (status);
657 }
658
659 if (gbl_revision == 2) {
660 status = osl_add_table_to_list(ACPI_SIG_XSDT, 0);
661 if (ACPI_FAILURE(status)) {
662 return (status);
663 }
664 }
665
666 status = osl_add_table_to_list(ACPI_SIG_DSDT, 0);
667 if (ACPI_FAILURE(status)) {
668 return (status);
669 }
670
671 status = osl_add_table_to_list(ACPI_SIG_FACS, 0);
672 if (ACPI_FAILURE(status)) {
673 return (status);
674 }
675
676 /* Add all tables found in the memory */
677
678 status = osl_list_bios_tables();
679 if (ACPI_FAILURE(status)) {
680 return (status);
681 }
682 } else {
683 /* Add all tables found in the static directory */
684
685 status = osl_list_customized_tables(STATIC_TABLE_DIR);
686 if (ACPI_FAILURE(status)) {
687 return (status);
688 }
689 }
690
691 if (gbl_dump_dynamic_tables) {
692
693 /* Add all dynamically loaded tables in the dynamic directory */
694
695 status = osl_list_customized_tables(DYNAMIC_TABLE_DIR);
696 if (ACPI_FAILURE(status)) {
697 return (status);
698 }
699 }
700
701 gbl_table_list_initialized = TRUE;
702 return (AE_OK);
703 }
704
705 /******************************************************************************
706 *
707 * FUNCTION: osl_list_bios_tables
708 *
709 * PARAMETERS: None
710 *
711 * RETURN: Status; Table list is initialized if AE_OK.
712 *
713 * DESCRIPTION: Add ACPI tables to the table list from memory.
714 *
715 * NOTE: This works on Linux as table customization does not modify the
716 * addresses stored in RSDP/RSDT/XSDT/FADT.
717 *
718 *****************************************************************************/
719
720 static acpi_status osl_list_bios_tables(void)
721 {
722 struct acpi_table_header *mapped_table = NULL;
723 u8 *table_data;
724 u8 number_of_tables;
725 u8 item_size;
726 acpi_physical_address table_address = 0;
727 acpi_status status = AE_OK;
728 u32 i;
729
730 if (osl_can_use_xsdt()) {
731 item_size = sizeof(u64);
732 table_data =
733 ACPI_CAST8(gbl_xsdt) + sizeof(struct acpi_table_header);
734 number_of_tables =
735 (u8)((gbl_xsdt->header.length -
736 sizeof(struct acpi_table_header))
737 / item_size);
738 } else { /* Use RSDT if XSDT is not available */
739
740 item_size = sizeof(u32);
741 table_data =
742 ACPI_CAST8(gbl_rsdt) + sizeof(struct acpi_table_header);
743 number_of_tables =
744 (u8)((gbl_rsdt->header.length -
745 sizeof(struct acpi_table_header))
746 / item_size);
747 }
748
749 /* Search RSDT/XSDT for the requested table */
750
751 for (i = 0; i < number_of_tables; ++i, table_data += item_size) {
752 if (osl_can_use_xsdt()) {
753 table_address =
754 (acpi_physical_address)(*ACPI_CAST64(table_data));
755 } else {
756 table_address =
757 (acpi_physical_address)(*ACPI_CAST32(table_data));
758 }
759
760 /* Skip NULL entries in RSDT/XSDT */
761
762 if (table_address == 0) {
763 continue;
764 }
765
766 status = osl_map_table(table_address, NULL, &mapped_table);
767 if (ACPI_FAILURE(status)) {
768 return (status);
769 }
770
771 osl_add_table_to_list(mapped_table->signature, 0);
772 osl_unmap_table(mapped_table);
773 }
774
775 return (AE_OK);
776 }
777
778 /******************************************************************************
779 *
780 * FUNCTION: osl_get_bios_table
781 *
782 * PARAMETERS: signature - ACPI Signature for common table. Must be
783 * a null terminated 4-character string.
784 * instance - Multiple table support for SSDT/UEFI (0...n)
785 * Must be 0 for other tables.
786 * table - Where a pointer to the table is returned
787 * address - Where the table physical address is returned
788 *
789 * RETURN: Status; Table buffer and physical address returned if AE_OK.
790 * AE_LIMIT: Instance is beyond valid limit
791 * AE_NOT_FOUND: A table with the signature was not found
792 *
793 * DESCRIPTION: Get a BIOS provided ACPI table
794 *
795 * NOTE: Assumes the input signature is uppercase.
796 *
797 *****************************************************************************/
798
799 static acpi_status
800 osl_get_bios_table(char *signature,
801 u32 instance,
802 struct acpi_table_header **table,
803 acpi_physical_address *address)
804 {
805 struct acpi_table_header *local_table = NULL;
806 struct acpi_table_header *mapped_table = NULL;
807 u8 *table_data;
808 u8 number_of_tables;
809 u8 item_size;
810 u32 current_instance = 0;
811 acpi_physical_address table_address;
812 acpi_physical_address first_table_address = 0;
813 u32 table_length = 0;
814 acpi_status status = AE_OK;
815 u32 i;
816
817 /* Handle special tables whose addresses are not in RSDT/XSDT */
818
819 if (ACPI_COMPARE_NAME(signature, ACPI_RSDP_NAME) ||
820 ACPI_COMPARE_NAME(signature, ACPI_SIG_RSDT) ||
821 ACPI_COMPARE_NAME(signature, ACPI_SIG_XSDT) ||
822 ACPI_COMPARE_NAME(signature, ACPI_SIG_DSDT) ||
823 ACPI_COMPARE_NAME(signature, ACPI_SIG_FACS)) {
824
825 find_next_instance:
826
827 table_address = 0;
828
829 /*
830 * Get the appropriate address, either 32-bit or 64-bit. Be very
831 * careful about the FADT length and validate table addresses.
832 * Note: The 64-bit addresses have priority.
833 */
834 if (ACPI_COMPARE_NAME(signature, ACPI_SIG_DSDT)) {
835 if (current_instance < 2) {
836 if ((gbl_fadt->header.length >=
837 MIN_FADT_FOR_XDSDT) && gbl_fadt->Xdsdt
838 && current_instance == 0) {
839 table_address =
840 (acpi_physical_address)gbl_fadt->
841 Xdsdt;
842 } else
843 if ((gbl_fadt->header.length >=
844 MIN_FADT_FOR_DSDT)
845 && gbl_fadt->dsdt !=
846 first_table_address) {
847 table_address =
848 (acpi_physical_address)gbl_fadt->
849 dsdt;
850 }
851 }
852 } else if (ACPI_COMPARE_NAME(signature, ACPI_SIG_FACS)) {
853 if (current_instance < 2) {
854 if ((gbl_fadt->header.length >=
855 MIN_FADT_FOR_XFACS) && gbl_fadt->Xfacs
856 && current_instance == 0) {
857 table_address =
858 (acpi_physical_address)gbl_fadt->
859 Xfacs;
860 } else
861 if ((gbl_fadt->header.length >=
862 MIN_FADT_FOR_FACS)
863 && gbl_fadt->facs !=
864 first_table_address) {
865 table_address =
866 (acpi_physical_address)gbl_fadt->
867 facs;
868 }
869 }
870 } else if (ACPI_COMPARE_NAME(signature, ACPI_SIG_XSDT)) {
871 if (!gbl_revision) {
872 return (AE_BAD_SIGNATURE);
873 }
874 if (current_instance == 0) {
875 table_address =
876 (acpi_physical_address)gbl_rsdp.
877 xsdt_physical_address;
878 }
879 } else if (ACPI_COMPARE_NAME(signature, ACPI_SIG_RSDT)) {
880 if (current_instance == 0) {
881 table_address =
882 (acpi_physical_address)gbl_rsdp.
883 rsdt_physical_address;
884 }
885 } else {
886 if (current_instance == 0) {
887 table_address =
888 (acpi_physical_address)gbl_rsdp_address;
889 signature = ACPI_SIG_RSDP;
890 }
891 }
892
893 if (table_address == 0) {
894 goto exit_find_table;
895 }
896
897 /* Now we can get the requested special table */
898
899 status = osl_map_table(table_address, signature, &mapped_table);
900 if (ACPI_FAILURE(status)) {
901 return (status);
902 }
903
904 table_length = ap_get_table_length(mapped_table);
905 if (first_table_address == 0) {
906 first_table_address = table_address;
907 }
908
909 /* Match table instance */
910
911 if (current_instance != instance) {
912 osl_unmap_table(mapped_table);
913 mapped_table = NULL;
914 current_instance++;
915 goto find_next_instance;
916 }
917 } else { /* Case for a normal ACPI table */
918
919 if (osl_can_use_xsdt()) {
920 item_size = sizeof(u64);
921 table_data =
922 ACPI_CAST8(gbl_xsdt) +
923 sizeof(struct acpi_table_header);
924 number_of_tables =
925 (u8)((gbl_xsdt->header.length -
926 sizeof(struct acpi_table_header))
927 / item_size);
928 } else { /* Use RSDT if XSDT is not available */
929
930 item_size = sizeof(u32);
931 table_data =
932 ACPI_CAST8(gbl_rsdt) +
933 sizeof(struct acpi_table_header);
934 number_of_tables =
935 (u8)((gbl_rsdt->header.length -
936 sizeof(struct acpi_table_header))
937 / item_size);
938 }
939
940 /* Search RSDT/XSDT for the requested table */
941
942 for (i = 0; i < number_of_tables; ++i, table_data += item_size) {
943 if (osl_can_use_xsdt()) {
944 table_address =
945 (acpi_physical_address)(*ACPI_CAST64
946 (table_data));
947 } else {
948 table_address =
949 (acpi_physical_address)(*ACPI_CAST32
950 (table_data));
951 }
952
953 /* Skip NULL entries in RSDT/XSDT */
954
955 if (table_address == 0) {
956 continue;
957 }
958
959 status =
960 osl_map_table(table_address, NULL, &mapped_table);
961 if (ACPI_FAILURE(status)) {
962 return (status);
963 }
964 table_length = mapped_table->length;
965
966 /* Does this table match the requested signature? */
967
968 if (!ACPI_COMPARE_NAME
969 (mapped_table->signature, signature)) {
970 osl_unmap_table(mapped_table);
971 mapped_table = NULL;
972 continue;
973 }
974
975 /* Match table instance (for SSDT/UEFI tables) */
976
977 if (current_instance != instance) {
978 osl_unmap_table(mapped_table);
979 mapped_table = NULL;
980 current_instance++;
981 continue;
982 }
983
984 break;
985 }
986 }
987
988 exit_find_table:
989
990 if (!mapped_table) {
991 return (AE_LIMIT);
992 }
993
994 if (table_length == 0) {
995 status = AE_BAD_HEADER;
996 goto exit;
997 }
998
999 /* Copy table to local buffer and return it */
1000
1001 local_table = calloc(1, table_length);
1002 if (!local_table) {
1003 status = AE_NO_MEMORY;
1004 goto exit;
1005 }
1006
1007 memcpy(local_table, mapped_table, table_length);
1008 *address = table_address;
1009 *table = local_table;
1010
1011 exit:
1012 osl_unmap_table(mapped_table);
1013 return (status);
1014 }
1015
1016 /******************************************************************************
1017 *
1018 * FUNCTION: osl_list_customized_tables
1019 *
1020 * PARAMETERS: directory - Directory that contains the tables
1021 *
1022 * RETURN: Status; Table list is initialized if AE_OK.
1023 *
1024 * DESCRIPTION: Add ACPI tables to the table list from a directory.
1025 *
1026 *****************************************************************************/
1027
1028 static acpi_status osl_list_customized_tables(char *directory)
1029 {
1030 void *table_dir;
1031 u32 instance;
1032 char temp_name[ACPI_NAME_SIZE];
1033 char *filename;
1034 acpi_status status = AE_OK;
1035
1036 /* Open the requested directory */
1037
1038 table_dir = acpi_os_open_directory(directory, "*", REQUEST_FILE_ONLY);
1039 if (!table_dir) {
1040 return (osl_get_last_status(AE_NOT_FOUND));
1041 }
1042
1043 /* Examine all entries in this directory */
1044
1045 while ((filename = acpi_os_get_next_filename(table_dir))) {
1046
1047 /* Extract table name and instance number */
1048
1049 status =
1050 osl_table_name_from_file(filename, temp_name, &instance);
1051
1052 /* Ignore meaningless files */
1053
1054 if (ACPI_FAILURE(status)) {
1055 continue;
1056 }
1057
1058 /* Add new info node to global table list */
1059
1060 status = osl_add_table_to_list(temp_name, instance);
1061 if (ACPI_FAILURE(status)) {
1062 break;
1063 }
1064 }
1065
1066 acpi_os_close_directory(table_dir);
1067 return (status);
1068 }
1069
1070 /******************************************************************************
1071 *
1072 * FUNCTION: osl_map_table
1073 *
1074 * PARAMETERS: address - Address of the table in memory
1075 * signature - Optional ACPI Signature for desired table.
1076 * Null terminated 4-character string.
1077 * table - Where a pointer to the mapped table is
1078 * returned
1079 *
1080 * RETURN: Status; Mapped table is returned if AE_OK.
1081 * AE_NOT_FOUND: A valid table was not found at the address
1082 *
1083 * DESCRIPTION: Map entire ACPI table into caller's address space.
1084 *
1085 *****************************************************************************/
1086
1087 static acpi_status
1088 osl_map_table(acpi_size address,
1089 char *signature, struct acpi_table_header **table)
1090 {
1091 struct acpi_table_header *mapped_table;
1092 u32 length;
1093
1094 if (!address) {
1095 return (AE_BAD_ADDRESS);
1096 }
1097
1098 /*
1099 * Map the header so we can get the table length.
1100 * Use sizeof (struct acpi_table_header) as:
1101 * 1. it is bigger than 24 to include RSDP->Length
1102 * 2. it is smaller than sizeof (struct acpi_table_rsdp)
1103 */
1104 mapped_table =
1105 acpi_os_map_memory(address, sizeof(struct acpi_table_header));
1106 if (!mapped_table) {
1107 fprintf(stderr, "Could not map table header at 0x%8.8X%8.8X\n",
1108 ACPI_FORMAT_UINT64(address));
1109 return (osl_get_last_status(AE_BAD_ADDRESS));
1110 }
1111
1112 /* If specified, signature must match */
1113
1114 if (signature) {
1115 if (ACPI_VALIDATE_RSDP_SIG(signature)) {
1116 if (!ACPI_VALIDATE_RSDP_SIG(mapped_table->signature)) {
1117 acpi_os_unmap_memory(mapped_table,
1118 sizeof(struct
1119 acpi_table_header));
1120 return (AE_BAD_SIGNATURE);
1121 }
1122 } else
1123 if (!ACPI_COMPARE_NAME(signature, mapped_table->signature))
1124 {
1125 acpi_os_unmap_memory(mapped_table,
1126 sizeof(struct acpi_table_header));
1127 return (AE_BAD_SIGNATURE);
1128 }
1129 }
1130
1131 /* Map the entire table */
1132
1133 length = ap_get_table_length(mapped_table);
1134 acpi_os_unmap_memory(mapped_table, sizeof(struct acpi_table_header));
1135 if (length == 0) {
1136 return (AE_BAD_HEADER);
1137 }
1138
1139 mapped_table = acpi_os_map_memory(address, length);
1140 if (!mapped_table) {
1141 fprintf(stderr,
1142 "Could not map table at 0x%8.8X%8.8X length %8.8X\n",
1143 ACPI_FORMAT_UINT64(address), length);
1144 return (osl_get_last_status(AE_INVALID_TABLE_LENGTH));
1145 }
1146
1147 (void)ap_is_valid_checksum(mapped_table);
1148
1149 *table = mapped_table;
1150 return (AE_OK);
1151 }
1152
1153 /******************************************************************************
1154 *
1155 * FUNCTION: osl_unmap_table
1156 *
1157 * PARAMETERS: table - A pointer to the mapped table
1158 *
1159 * RETURN: None
1160 *
1161 * DESCRIPTION: Unmap entire ACPI table.
1162 *
1163 *****************************************************************************/
1164
1165 static void osl_unmap_table(struct acpi_table_header *table)
1166 {
1167 if (table) {
1168 acpi_os_unmap_memory(table, ap_get_table_length(table));
1169 }
1170 }
1171
1172 /******************************************************************************
1173 *
1174 * FUNCTION: osl_table_name_from_file
1175 *
1176 * PARAMETERS: filename - File that contains the desired table
1177 * signature - Pointer to 4-character buffer to store
1178 * extracted table signature.
1179 * instance - Pointer to integer to store extracted
1180 * table instance number.
1181 *
1182 * RETURN: Status; Table name is extracted if AE_OK.
1183 *
1184 * DESCRIPTION: Extract table signature and instance number from a table file
1185 * name.
1186 *
1187 *****************************************************************************/
1188
1189 static acpi_status
1190 osl_table_name_from_file(char *filename, char *signature, u32 *instance)
1191 {
1192
1193 /* Ignore meaningless files */
1194
1195 if (strlen(filename) < ACPI_NAME_SIZE) {
1196 return (AE_BAD_SIGNATURE);
1197 }
1198
1199 /* Extract instance number */
1200
1201 if (isdigit((int)filename[ACPI_NAME_SIZE])) {
1202 sscanf(&filename[ACPI_NAME_SIZE], "%u", instance);
1203 } else if (strlen(filename) != ACPI_NAME_SIZE) {
1204 return (AE_BAD_SIGNATURE);
1205 } else {
1206 *instance = 0;
1207 }
1208
1209 /* Extract signature */
1210
1211 ACPI_MOVE_NAME(signature, filename);
1212 return (AE_OK);
1213 }
1214
1215 /******************************************************************************
1216 *
1217 * FUNCTION: osl_read_table_from_file
1218 *
1219 * PARAMETERS: filename - File that contains the desired table
1220 * file_offset - Offset of the table in file
1221 * signature - Optional ACPI Signature for desired table.
1222 * A null terminated 4-character string.
1223 * table - Where a pointer to the table is returned
1224 *
1225 * RETURN: Status; Table buffer is returned if AE_OK.
1226 *
1227 * DESCRIPTION: Read a ACPI table from a file.
1228 *
1229 *****************************************************************************/
1230
1231 static acpi_status
1232 osl_read_table_from_file(char *filename,
1233 acpi_size file_offset,
1234 char *signature, struct acpi_table_header **table)
1235 {
1236 FILE *table_file;
1237 struct acpi_table_header header;
1238 struct acpi_table_header *local_table = NULL;
1239 u32 table_length;
1240 s32 count;
1241 acpi_status status = AE_OK;
1242
1243 /* Open the file */
1244
1245 table_file = fopen(filename, "rb");
1246 if (table_file == NULL) {
1247 fprintf(stderr, "Could not open table file: %s\n", filename);
1248 return (osl_get_last_status(AE_NOT_FOUND));
1249 }
1250
1251 fseek(table_file, file_offset, SEEK_SET);
1252
1253 /* Read the Table header to get the table length */
1254
1255 count = fread(&header, 1, sizeof(struct acpi_table_header), table_file);
1256 if (count != sizeof(struct acpi_table_header)) {
1257 fprintf(stderr, "Could not read table header: %s\n", filename);
1258 status = AE_BAD_HEADER;
1259 goto exit;
1260 }
1261
1262 /* If signature is specified, it must match the table */
1263
1264 if (signature) {
1265 if (ACPI_VALIDATE_RSDP_SIG(signature)) {
1266 if (!ACPI_VALIDATE_RSDP_SIG(header.signature)) {
1267 fprintf(stderr,
1268 "Incorrect RSDP signature: found %8.8s\n",
1269 header.signature);
1270 status = AE_BAD_SIGNATURE;
1271 goto exit;
1272 }
1273 } else if (!ACPI_COMPARE_NAME(signature, header.signature)) {
1274 fprintf(stderr,
1275 "Incorrect signature: Expecting %4.4s, found %4.4s\n",
1276 signature, header.signature);
1277 status = AE_BAD_SIGNATURE;
1278 goto exit;
1279 }
1280 }
1281
1282 table_length = ap_get_table_length(&header);
1283 if (table_length == 0) {
1284 status = AE_BAD_HEADER;
1285 goto exit;
1286 }
1287
1288 /* Read the entire table into a local buffer */
1289
1290 local_table = calloc(1, table_length);
1291 if (!local_table) {
1292 fprintf(stderr,
1293 "%4.4s: Could not allocate buffer for table of length %X\n",
1294 header.signature, table_length);
1295 status = AE_NO_MEMORY;
1296 goto exit;
1297 }
1298
1299 fseek(table_file, file_offset, SEEK_SET);
1300
1301 count = fread(local_table, 1, table_length, table_file);
1302 if (count != table_length) {
1303 fprintf(stderr, "%4.4s: Could not read table content\n",
1304 header.signature);
1305 status = AE_INVALID_TABLE_LENGTH;
1306 goto exit;
1307 }
1308
1309 /* Validate checksum */
1310
1311 (void)ap_is_valid_checksum(local_table);
1312
1313 exit:
1314 fclose(table_file);
1315 *table = local_table;
1316 return (status);
1317 }
1318
1319 /******************************************************************************
1320 *
1321 * FUNCTION: osl_get_customized_table
1322 *
1323 * PARAMETERS: pathname - Directory to find Linux customized table
1324 * signature - ACPI Signature for desired table. Must be
1325 * a null terminated 4-character string.
1326 * instance - Multiple table support for SSDT/UEFI (0...n)
1327 * Must be 0 for other tables.
1328 * table - Where a pointer to the table is returned
1329 * address - Where the table physical address is returned
1330 *
1331 * RETURN: Status; Table buffer is returned if AE_OK.
1332 * AE_LIMIT: Instance is beyond valid limit
1333 * AE_NOT_FOUND: A table with the signature was not found
1334 *
1335 * DESCRIPTION: Get an OS customized table.
1336 *
1337 *****************************************************************************/
1338
1339 static acpi_status
1340 osl_get_customized_table(char *pathname,
1341 char *signature,
1342 u32 instance,
1343 struct acpi_table_header **table,
1344 acpi_physical_address *address)
1345 {
1346 void *table_dir;
1347 u32 current_instance = 0;
1348 char temp_name[ACPI_NAME_SIZE];
1349 char table_filename[PATH_MAX];
1350 char *filename;
1351 acpi_status status;
1352
1353 /* Open the directory for customized tables */
1354
1355 table_dir = acpi_os_open_directory(pathname, "*", REQUEST_FILE_ONLY);
1356 if (!table_dir) {
1357 return (osl_get_last_status(AE_NOT_FOUND));
1358 }
1359
1360 /* Attempt to find the table in the directory */
1361
1362 while ((filename = acpi_os_get_next_filename(table_dir))) {
1363
1364 /* Ignore meaningless files */
1365
1366 if (!ACPI_COMPARE_NAME(filename, signature)) {
1367 continue;
1368 }
1369
1370 /* Extract table name and instance number */
1371
1372 status =
1373 osl_table_name_from_file(filename, temp_name,
1374 &current_instance);
1375
1376 /* Ignore meaningless files */
1377
1378 if (ACPI_FAILURE(status) || current_instance != instance) {
1379 continue;
1380 }
1381
1382 /* Create the table pathname */
1383
1384 if (instance != 0) {
1385 sprintf(table_filename, "%s/%4.4s%d", pathname,
1386 temp_name, instance);
1387 } else {
1388 sprintf(table_filename, "%s/%4.4s", pathname,
1389 temp_name);
1390 }
1391 break;
1392 }
1393
1394 acpi_os_close_directory(table_dir);
1395
1396 if (!filename) {
1397 return (AE_LIMIT);
1398 }
1399
1400 /* There is no physical address saved for customized tables, use zero */
1401
1402 *address = 0;
1403 status = osl_read_table_from_file(table_filename, 0, NULL, table);
1404
1405 return (status);
1406 }
CRIS linux kernel tree