?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.1.18
[linux/fpc-iii.git] / tools / power / acpi / os_specific / service_layers / oslinuxtbl.c
blobdb15c9d2049e08f6090d3d391a7617246aa9c1c5
1 /******************************************************************************
2 *
3 * Module Name: oslinuxtbl - Linux OSL for obtaining ACPI tables
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2015, 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 ACPI_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 ACPI_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 /* Get RSDP from memory */
586
587 status = osl_load_rsdp();
588 if (ACPI_FAILURE(status)) {
589 return (status);
590 }
591
592 /* Get XSDT from memory */
593
594 if (gbl_rsdp.revision && !gbl_do_not_dump_xsdt) {
595 if (gbl_xsdt) {
596 free(gbl_xsdt);
597 gbl_xsdt = NULL;
598 }
599
600 gbl_revision = 2;
601 status = osl_get_bios_table(ACPI_SIG_XSDT, 0,
602 ACPI_CAST_PTR(struct
603 acpi_table_header *,
604 &gbl_xsdt), &address);
605 if (ACPI_FAILURE(status)) {
606 return (status);
607 }
608 }
609
610 /* Get RSDT from memory */
611
612 if (gbl_rsdp.rsdt_physical_address) {
613 if (gbl_rsdt) {
614 free(gbl_rsdt);
615 gbl_rsdt = NULL;
616 }
617
618 status = osl_get_bios_table(ACPI_SIG_RSDT, 0,
619 ACPI_CAST_PTR(struct
620 acpi_table_header *,
621 &gbl_rsdt), &address);
622 if (ACPI_FAILURE(status)) {
623 return (status);
624 }
625 }
626
627 /* Get FADT from memory */
628
629 if (gbl_fadt) {
630 free(gbl_fadt);
631 gbl_fadt = NULL;
632 }
633
634 status = osl_get_bios_table(ACPI_SIG_FADT, 0,
635 ACPI_CAST_PTR(struct acpi_table_header *,
636 &gbl_fadt),
637 &gbl_fadt_address);
638 if (ACPI_FAILURE(status)) {
639 return (status);
640 }
641
642 if (!gbl_dump_customized_tables) {
643
644 /* Add mandatory tables to global table list first */
645
646 status = osl_add_table_to_list(ACPI_RSDP_NAME, 0);
647 if (ACPI_FAILURE(status)) {
648 return (status);
649 }
650
651 status = osl_add_table_to_list(ACPI_SIG_RSDT, 0);
652 if (ACPI_FAILURE(status)) {
653 return (status);
654 }
655
656 if (gbl_revision == 2) {
657 status = osl_add_table_to_list(ACPI_SIG_XSDT, 0);
658 if (ACPI_FAILURE(status)) {
659 return (status);
660 }
661 }
662
663 status = osl_add_table_to_list(ACPI_SIG_DSDT, 0);
664 if (ACPI_FAILURE(status)) {
665 return (status);
666 }
667
668 status = osl_add_table_to_list(ACPI_SIG_FACS, 0);
669 if (ACPI_FAILURE(status)) {
670 return (status);
671 }
672
673 /* Add all tables found in the memory */
674
675 status = osl_list_bios_tables();
676 if (ACPI_FAILURE(status)) {
677 return (status);
678 }
679 } else {
680 /* Add all tables found in the static directory */
681
682 status = osl_list_customized_tables(STATIC_TABLE_DIR);
683 if (ACPI_FAILURE(status)) {
684 return (status);
685 }
686 }
687
688 if (gbl_dump_dynamic_tables) {
689
690 /* Add all dynamically loaded tables in the dynamic directory */
691
692 status = osl_list_customized_tables(DYNAMIC_TABLE_DIR);
693 if (ACPI_FAILURE(status)) {
694 return (status);
695 }
696 }
697
698 gbl_table_list_initialized = TRUE;
699 return (AE_OK);
700 }
701
702 /******************************************************************************
703 *
704 * FUNCTION: osl_list_bios_tables
705 *
706 * PARAMETERS: None
707 *
708 * RETURN: Status; Table list is initialized if AE_OK.
709 *
710 * DESCRIPTION: Add ACPI tables to the table list from memory.
711 *
712 * NOTE: This works on Linux as table customization does not modify the
713 * addresses stored in RSDP/RSDT/XSDT/FADT.
714 *
715 *****************************************************************************/
716
717 static acpi_status osl_list_bios_tables(void)
718 {
719 struct acpi_table_header *mapped_table = NULL;
720 u8 *table_data;
721 u8 number_of_tables;
722 u8 item_size;
723 acpi_physical_address table_address = 0;
724 acpi_status status = AE_OK;
725 u32 i;
726
727 if (osl_can_use_xsdt()) {
728 item_size = sizeof(u64);
729 table_data =
730 ACPI_CAST8(gbl_xsdt) + sizeof(struct acpi_table_header);
731 number_of_tables =
732 (u8)((gbl_xsdt->header.length -
733 sizeof(struct acpi_table_header))
734 / item_size);
735 } else { /* Use RSDT if XSDT is not available */
736
737 item_size = sizeof(u32);
738 table_data =
739 ACPI_CAST8(gbl_rsdt) + sizeof(struct acpi_table_header);
740 number_of_tables =
741 (u8)((gbl_rsdt->header.length -
742 sizeof(struct acpi_table_header))
743 / item_size);
744 }
745
746 /* Search RSDT/XSDT for the requested table */
747
748 for (i = 0; i < number_of_tables; ++i, table_data += item_size) {
749 if (osl_can_use_xsdt()) {
750 table_address =
751 (acpi_physical_address) (*ACPI_CAST64(table_data));
752 } else {
753 table_address =
754 (acpi_physical_address) (*ACPI_CAST32(table_data));
755 }
756
757 /* Skip NULL entries in RSDT/XSDT */
758
759 if (!table_address) {
760 continue;
761 }
762
763 status = osl_map_table(table_address, NULL, &mapped_table);
764 if (ACPI_FAILURE(status)) {
765 return (status);
766 }
767
768 osl_add_table_to_list(mapped_table->signature, 0);
769 osl_unmap_table(mapped_table);
770 }
771
772 return (AE_OK);
773 }
774
775 /******************************************************************************
776 *
777 * FUNCTION: osl_get_bios_table
778 *
779 * PARAMETERS: signature - ACPI Signature for common table. Must be
780 * a null terminated 4-character string.
781 * instance - Multiple table support for SSDT/UEFI (0...n)
782 * Must be 0 for other tables.
783 * table - Where a pointer to the table is returned
784 * address - Where the table physical address is returned
785 *
786 * RETURN: Status; Table buffer and physical address returned if AE_OK.
787 * AE_LIMIT: Instance is beyond valid limit
788 * AE_NOT_FOUND: A table with the signature was not found
789 *
790 * DESCRIPTION: Get a BIOS provided ACPI table
791 *
792 * NOTE: Assumes the input signature is uppercase.
793 *
794 *****************************************************************************/
795
796 static acpi_status
797 osl_get_bios_table(char *signature,
798 u32 instance,
799 struct acpi_table_header **table,
800 acpi_physical_address * address)
801 {
802 struct acpi_table_header *local_table = NULL;
803 struct acpi_table_header *mapped_table = NULL;
804 u8 *table_data;
805 u8 number_of_tables;
806 u8 item_size;
807 u32 current_instance = 0;
808 acpi_physical_address table_address = 0;
809 u32 table_length = 0;
810 acpi_status status = AE_OK;
811 u32 i;
812
813 /* Handle special tables whose addresses are not in RSDT/XSDT */
814
815 if (ACPI_COMPARE_NAME(signature, ACPI_RSDP_NAME) ||
816 ACPI_COMPARE_NAME(signature, ACPI_SIG_RSDT) ||
817 ACPI_COMPARE_NAME(signature, ACPI_SIG_XSDT) ||
818 ACPI_COMPARE_NAME(signature, ACPI_SIG_DSDT) ||
819 ACPI_COMPARE_NAME(signature, ACPI_SIG_FACS)) {
820 if (instance > 0) {
821 return (AE_LIMIT);
822 }
823
824 /*
825 * Get the appropriate address, either 32-bit or 64-bit. Be very
826 * careful about the FADT length and validate table addresses.
827 * Note: The 64-bit addresses have priority.
828 */
829 if (ACPI_COMPARE_NAME(signature, ACPI_SIG_DSDT)) {
830 if ((gbl_fadt->header.length >= MIN_FADT_FOR_XDSDT) &&
831 gbl_fadt->Xdsdt) {
832 table_address =
833 (acpi_physical_address) gbl_fadt->Xdsdt;
834 } else
835 if ((gbl_fadt->header.length >= MIN_FADT_FOR_DSDT)
836 && gbl_fadt->dsdt) {
837 table_address =
838 (acpi_physical_address) gbl_fadt->dsdt;
839 }
840 } else if (ACPI_COMPARE_NAME(signature, ACPI_SIG_FACS)) {
841 if ((gbl_fadt->header.length >= MIN_FADT_FOR_XFACS) &&
842 gbl_fadt->Xfacs) {
843 table_address =
844 (acpi_physical_address) gbl_fadt->Xfacs;
845 } else
846 if ((gbl_fadt->header.length >= MIN_FADT_FOR_FACS)
847 && gbl_fadt->facs) {
848 table_address =
849 (acpi_physical_address) gbl_fadt->facs;
850 }
851 } else if (ACPI_COMPARE_NAME(signature, ACPI_SIG_XSDT)) {
852 if (!gbl_revision) {
853 return (AE_BAD_SIGNATURE);
854 }
855 table_address =
856 (acpi_physical_address) gbl_rsdp.
857 xsdt_physical_address;
858 } else if (ACPI_COMPARE_NAME(signature, ACPI_SIG_RSDT)) {
859 table_address =
860 (acpi_physical_address) gbl_rsdp.
861 rsdt_physical_address;
862 } else {
863 table_address =
864 (acpi_physical_address) gbl_rsdp_address;
865 signature = ACPI_SIG_RSDP;
866 }
867
868 /* Now we can get the requested special table */
869
870 status = osl_map_table(table_address, signature, &mapped_table);
871 if (ACPI_FAILURE(status)) {
872 return (status);
873 }
874
875 table_length = ap_get_table_length(mapped_table);
876 } else { /* Case for a normal ACPI table */
877
878 if (osl_can_use_xsdt()) {
879 item_size = sizeof(u64);
880 table_data =
881 ACPI_CAST8(gbl_xsdt) +
882 sizeof(struct acpi_table_header);
883 number_of_tables =
884 (u8)((gbl_xsdt->header.length -
885 sizeof(struct acpi_table_header))
886 / item_size);
887 } else { /* Use RSDT if XSDT is not available */
888
889 item_size = sizeof(u32);
890 table_data =
891 ACPI_CAST8(gbl_rsdt) +
892 sizeof(struct acpi_table_header);
893 number_of_tables =
894 (u8)((gbl_rsdt->header.length -
895 sizeof(struct acpi_table_header))
896 / item_size);
897 }
898
899 /* Search RSDT/XSDT for the requested table */
900
901 for (i = 0; i < number_of_tables; ++i, table_data += item_size) {
902 if (osl_can_use_xsdt()) {
903 table_address =
904 (acpi_physical_address) (*ACPI_CAST64
905 (table_data));
906 } else {
907 table_address =
908 (acpi_physical_address) (*ACPI_CAST32
909 (table_data));
910 }
911
912 /* Skip NULL entries in RSDT/XSDT */
913
914 if (!table_address) {
915 continue;
916 }
917
918 status =
919 osl_map_table(table_address, NULL, &mapped_table);
920 if (ACPI_FAILURE(status)) {
921 return (status);
922 }
923 table_length = mapped_table->length;
924
925 /* Does this table match the requested signature? */
926
927 if (!ACPI_COMPARE_NAME
928 (mapped_table->signature, signature)) {
929 osl_unmap_table(mapped_table);
930 mapped_table = NULL;
931 continue;
932 }
933
934 /* Match table instance (for SSDT/UEFI tables) */
935
936 if (current_instance != instance) {
937 osl_unmap_table(mapped_table);
938 mapped_table = NULL;
939 current_instance++;
940 continue;
941 }
942
943 break;
944 }
945 }
946
947 if (!mapped_table) {
948 return (AE_LIMIT);
949 }
950
951 if (table_length == 0) {
952 status = AE_BAD_HEADER;
953 goto exit;
954 }
955
956 /* Copy table to local buffer and return it */
957
958 local_table = calloc(1, table_length);
959 if (!local_table) {
960 status = AE_NO_MEMORY;
961 goto exit;
962 }
963
964 ACPI_MEMCPY(local_table, mapped_table, table_length);
965 *address = table_address;
966 *table = local_table;
967
968 exit:
969 osl_unmap_table(mapped_table);
970 return (status);
971 }
972
973 /******************************************************************************
974 *
975 * FUNCTION: osl_list_customized_tables
976 *
977 * PARAMETERS: directory - Directory that contains the tables
978 *
979 * RETURN: Status; Table list is initialized if AE_OK.
980 *
981 * DESCRIPTION: Add ACPI tables to the table list from a directory.
982 *
983 *****************************************************************************/
984
985 static acpi_status osl_list_customized_tables(char *directory)
986 {
987 void *table_dir;
988 u32 instance;
989 char temp_name[ACPI_NAME_SIZE];
990 char *filename;
991 acpi_status status = AE_OK;
992
993 /* Open the requested directory */
994
995 table_dir = acpi_os_open_directory(directory, "*", REQUEST_FILE_ONLY);
996 if (!table_dir) {
997 return (osl_get_last_status(AE_NOT_FOUND));
998 }
999
1000 /* Examine all entries in this directory */
1001
1002 while ((filename = acpi_os_get_next_filename(table_dir))) {
1003
1004 /* Extract table name and instance number */
1005
1006 status =
1007 osl_table_name_from_file(filename, temp_name, &instance);
1008
1009 /* Ignore meaningless files */
1010
1011 if (ACPI_FAILURE(status)) {
1012 continue;
1013 }
1014
1015 /* Add new info node to global table list */
1016
1017 status = osl_add_table_to_list(temp_name, instance);
1018 if (ACPI_FAILURE(status)) {
1019 break;
1020 }
1021 }
1022
1023 acpi_os_close_directory(table_dir);
1024 return (status);
1025 }
1026
1027 /******************************************************************************
1028 *
1029 * FUNCTION: osl_map_table
1030 *
1031 * PARAMETERS: address - Address of the table in memory
1032 * signature - Optional ACPI Signature for desired table.
1033 * Null terminated 4-character string.
1034 * table - Where a pointer to the mapped table is
1035 * returned
1036 *
1037 * RETURN: Status; Mapped table is returned if AE_OK.
1038 * AE_NOT_FOUND: A valid table was not found at the address
1039 *
1040 * DESCRIPTION: Map entire ACPI table into caller's address space.
1041 *
1042 *****************************************************************************/
1043
1044 static acpi_status
1045 osl_map_table(acpi_size address,
1046 char *signature, struct acpi_table_header **table)
1047 {
1048 struct acpi_table_header *mapped_table;
1049 u32 length;
1050
1051 if (!address) {
1052 return (AE_BAD_ADDRESS);
1053 }
1054
1055 /*
1056 * Map the header so we can get the table length.
1057 * Use sizeof (struct acpi_table_header) as:
1058 * 1. it is bigger than 24 to include RSDP->Length
1059 * 2. it is smaller than sizeof (struct acpi_table_rsdp)
1060 */
1061 mapped_table =
1062 acpi_os_map_memory(address, sizeof(struct acpi_table_header));
1063 if (!mapped_table) {
1064 fprintf(stderr, "Could not map table header at 0x%8.8X%8.8X\n",
1065 ACPI_FORMAT_UINT64(address));
1066 return (osl_get_last_status(AE_BAD_ADDRESS));
1067 }
1068
1069 /* If specified, signature must match */
1070
1071 if (signature) {
1072 if (ACPI_VALIDATE_RSDP_SIG(signature)) {
1073 if (!ACPI_VALIDATE_RSDP_SIG(mapped_table->signature)) {
1074 acpi_os_unmap_memory(mapped_table,
1075 sizeof(struct
1076 acpi_table_header));
1077 return (AE_BAD_SIGNATURE);
1078 }
1079 } else
1080 if (!ACPI_COMPARE_NAME(signature, mapped_table->signature))
1081 {
1082 acpi_os_unmap_memory(mapped_table,
1083 sizeof(struct acpi_table_header));
1084 return (AE_BAD_SIGNATURE);
1085 }
1086 }
1087
1088 /* Map the entire table */
1089
1090 length = ap_get_table_length(mapped_table);
1091 acpi_os_unmap_memory(mapped_table, sizeof(struct acpi_table_header));
1092 if (length == 0) {
1093 return (AE_BAD_HEADER);
1094 }
1095
1096 mapped_table = acpi_os_map_memory(address, length);
1097 if (!mapped_table) {
1098 fprintf(stderr,
1099 "Could not map table at 0x%8.8X%8.8X length %8.8X\n",
1100 ACPI_FORMAT_UINT64(address), length);
1101 return (osl_get_last_status(AE_INVALID_TABLE_LENGTH));
1102 }
1103
1104 (void)ap_is_valid_checksum(mapped_table);
1105
1106 *table = mapped_table;
1107 return (AE_OK);
1108 }
1109
1110 /******************************************************************************
1111 *
1112 * FUNCTION: osl_unmap_table
1113 *
1114 * PARAMETERS: table - A pointer to the mapped table
1115 *
1116 * RETURN: None
1117 *
1118 * DESCRIPTION: Unmap entire ACPI table.
1119 *
1120 *****************************************************************************/
1121
1122 static void osl_unmap_table(struct acpi_table_header *table)
1123 {
1124 if (table) {
1125 acpi_os_unmap_memory(table, ap_get_table_length(table));
1126 }
1127 }
1128
1129 /******************************************************************************
1130 *
1131 * FUNCTION: osl_table_name_from_file
1132 *
1133 * PARAMETERS: filename - File that contains the desired table
1134 * signature - Pointer to 4-character buffer to store
1135 * extracted table signature.
1136 * instance - Pointer to integer to store extracted
1137 * table instance number.
1138 *
1139 * RETURN: Status; Table name is extracted if AE_OK.
1140 *
1141 * DESCRIPTION: Extract table signature and instance number from a table file
1142 * name.
1143 *
1144 *****************************************************************************/
1145
1146 static acpi_status
1147 osl_table_name_from_file(char *filename, char *signature, u32 *instance)
1148 {
1149
1150 /* Ignore meaningless files */
1151
1152 if (strlen(filename) < ACPI_NAME_SIZE) {
1153 return (AE_BAD_SIGNATURE);
1154 }
1155
1156 /* Extract instance number */
1157
1158 if (isdigit((int)filename[ACPI_NAME_SIZE])) {
1159 sscanf(&filename[ACPI_NAME_SIZE], "%u", instance);
1160 } else if (strlen(filename) != ACPI_NAME_SIZE) {
1161 return (AE_BAD_SIGNATURE);
1162 } else {
1163 *instance = 0;
1164 }
1165
1166 /* Extract signature */
1167
1168 ACPI_MOVE_NAME(signature, filename);
1169 return (AE_OK);
1170 }
1171
1172 /******************************************************************************
1173 *
1174 * FUNCTION: osl_read_table_from_file
1175 *
1176 * PARAMETERS: filename - File that contains the desired table
1177 * file_offset - Offset of the table in file
1178 * signature - Optional ACPI Signature for desired table.
1179 * A null terminated 4-character string.
1180 * table - Where a pointer to the table is returned
1181 *
1182 * RETURN: Status; Table buffer is returned if AE_OK.
1183 *
1184 * DESCRIPTION: Read a ACPI table from a file.
1185 *
1186 *****************************************************************************/
1187
1188 static acpi_status
1189 osl_read_table_from_file(char *filename,
1190 acpi_size file_offset,
1191 char *signature, struct acpi_table_header **table)
1192 {
1193 FILE *table_file;
1194 struct acpi_table_header header;
1195 struct acpi_table_header *local_table = NULL;
1196 u32 table_length;
1197 s32 count;
1198 acpi_status status = AE_OK;
1199
1200 /* Open the file */
1201
1202 table_file = fopen(filename, "rb");
1203 if (table_file == NULL) {
1204 fprintf(stderr, "Could not open table file: %s\n", filename);
1205 return (osl_get_last_status(AE_NOT_FOUND));
1206 }
1207
1208 fseek(table_file, file_offset, SEEK_SET);
1209
1210 /* Read the Table header to get the table length */
1211
1212 count = fread(&header, 1, sizeof(struct acpi_table_header), table_file);
1213 if (count != sizeof(struct acpi_table_header)) {
1214 fprintf(stderr, "Could not read table header: %s\n", filename);
1215 status = AE_BAD_HEADER;
1216 goto exit;
1217 }
1218
1219 /* If signature is specified, it must match the table */
1220
1221 if (signature) {
1222 if (ACPI_VALIDATE_RSDP_SIG(signature)) {
1223 if (!ACPI_VALIDATE_RSDP_SIG(header.signature)) {
1224 fprintf(stderr,
1225 "Incorrect RSDP signature: found %8.8s\n",
1226 header.signature);
1227 status = AE_BAD_SIGNATURE;
1228 goto exit;
1229 }
1230 } else if (!ACPI_COMPARE_NAME(signature, header.signature)) {
1231 fprintf(stderr,
1232 "Incorrect signature: Expecting %4.4s, found %4.4s\n",
1233 signature, header.signature);
1234 status = AE_BAD_SIGNATURE;
1235 goto exit;
1236 }
1237 }
1238
1239 table_length = ap_get_table_length(&header);
1240 if (table_length == 0) {
1241 status = AE_BAD_HEADER;
1242 goto exit;
1243 }
1244
1245 /* Read the entire table into a local buffer */
1246
1247 local_table = calloc(1, table_length);
1248 if (!local_table) {
1249 fprintf(stderr,
1250 "%4.4s: Could not allocate buffer for table of length %X\n",
1251 header.signature, table_length);
1252 status = AE_NO_MEMORY;
1253 goto exit;
1254 }
1255
1256 fseek(table_file, file_offset, SEEK_SET);
1257
1258 count = fread(local_table, 1, table_length, table_file);
1259 if (count != table_length) {
1260 fprintf(stderr, "%4.4s: Could not read table content\n",
1261 header.signature);
1262 status = AE_INVALID_TABLE_LENGTH;
1263 goto exit;
1264 }
1265
1266 /* Validate checksum */
1267
1268 (void)ap_is_valid_checksum(local_table);
1269
1270 exit:
1271 fclose(table_file);
1272 *table = local_table;
1273 return (status);
1274 }
1275
1276 /******************************************************************************
1277 *
1278 * FUNCTION: osl_get_customized_table
1279 *
1280 * PARAMETERS: pathname - Directory to find Linux customized table
1281 * signature - ACPI Signature for desired table. Must be
1282 * a null terminated 4-character string.
1283 * instance - Multiple table support for SSDT/UEFI (0...n)
1284 * Must be 0 for other tables.
1285 * table - Where a pointer to the table is returned
1286 * address - Where the table physical address is returned
1287 *
1288 * RETURN: Status; Table buffer is returned if AE_OK.
1289 * AE_LIMIT: Instance is beyond valid limit
1290 * AE_NOT_FOUND: A table with the signature was not found
1291 *
1292 * DESCRIPTION: Get an OS customized table.
1293 *
1294 *****************************************************************************/
1295
1296 static acpi_status
1297 osl_get_customized_table(char *pathname,
1298 char *signature,
1299 u32 instance,
1300 struct acpi_table_header **table,
1301 acpi_physical_address * address)
1302 {
1303 void *table_dir;
1304 u32 current_instance = 0;
1305 char temp_name[ACPI_NAME_SIZE];
1306 char table_filename[PATH_MAX];
1307 char *filename;
1308 acpi_status status;
1309
1310 /* Open the directory for customized tables */
1311
1312 table_dir = acpi_os_open_directory(pathname, "*", REQUEST_FILE_ONLY);
1313 if (!table_dir) {
1314 return (osl_get_last_status(AE_NOT_FOUND));
1315 }
1316
1317 /* Attempt to find the table in the directory */
1318
1319 while ((filename = acpi_os_get_next_filename(table_dir))) {
1320
1321 /* Ignore meaningless files */
1322
1323 if (!ACPI_COMPARE_NAME(filename, signature)) {
1324 continue;
1325 }
1326
1327 /* Extract table name and instance number */
1328
1329 status =
1330 osl_table_name_from_file(filename, temp_name,
1331 &current_instance);
1332
1333 /* Ignore meaningless files */
1334
1335 if (ACPI_FAILURE(status) || current_instance != instance) {
1336 continue;
1337 }
1338
1339 /* Create the table pathname */
1340
1341 if (instance != 0) {
1342 sprintf(table_filename, "%s/%4.4s%d", pathname,
1343 temp_name, instance);
1344 } else {
1345 sprintf(table_filename, "%s/%4.4s", pathname,
1346 temp_name);
1347 }
1348 break;
1349 }
1350
1351 acpi_os_close_directory(table_dir);
1352
1353 if (!filename) {
1354 return (AE_LIMIT);
1355 }
1356
1357 /* There is no physical address saved for customized tables, use zero */
1358
1359 *address = 0;
1360 status = osl_read_table_from_file(table_filename, 0, NULL, table);
1361
1362 return (status);
1363 }
Linux with added FPC-III support