projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
ACPICA: De-macroize calls to standard C library functions
[deliverable/linux.git] / tools / power / acpi / os_specific / service_layers / oslinuxtbl.c
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 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) {
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 = 0;
812 u32 table_length = 0;
813 acpi_status status = AE_OK;
814 u32 i;
815
816 /* Handle special tables whose addresses are not in RSDT/XSDT */
817
818 if (ACPI_COMPARE_NAME(signature, ACPI_RSDP_NAME) ||
819 ACPI_COMPARE_NAME(signature, ACPI_SIG_RSDT) ||
820 ACPI_COMPARE_NAME(signature, ACPI_SIG_XSDT) ||
821 ACPI_COMPARE_NAME(signature, ACPI_SIG_DSDT) ||
822 ACPI_COMPARE_NAME(signature, ACPI_SIG_FACS)) {
823 if (instance > 0) {
824 return (AE_LIMIT);
825 }
826
827 /*
828 * Get the appropriate address, either 32-bit or 64-bit. Be very
829 * careful about the FADT length and validate table addresses.
830 * Note: The 64-bit addresses have priority.
831 */
832 if (ACPI_COMPARE_NAME(signature, ACPI_SIG_DSDT)) {
833 if ((gbl_fadt->header.length >= MIN_FADT_FOR_XDSDT) &&
834 gbl_fadt->Xdsdt) {
835 table_address =
836 (acpi_physical_address) gbl_fadt->Xdsdt;
837 } else
838 if ((gbl_fadt->header.length >= MIN_FADT_FOR_DSDT)
839 && gbl_fadt->dsdt) {
840 table_address =
841 (acpi_physical_address) gbl_fadt->dsdt;
842 }
843 } else if (ACPI_COMPARE_NAME(signature, ACPI_SIG_FACS)) {
844 if ((gbl_fadt->header.length >= MIN_FADT_FOR_XFACS) &&
845 gbl_fadt->Xfacs) {
846 table_address =
847 (acpi_physical_address) gbl_fadt->Xfacs;
848 } else
849 if ((gbl_fadt->header.length >= MIN_FADT_FOR_FACS)
850 && gbl_fadt->facs) {
851 table_address =
852 (acpi_physical_address) gbl_fadt->facs;
853 }
854 } else if (ACPI_COMPARE_NAME(signature, ACPI_SIG_XSDT)) {
855 if (!gbl_revision) {
856 return (AE_BAD_SIGNATURE);
857 }
858 table_address =
859 (acpi_physical_address) gbl_rsdp.
860 xsdt_physical_address;
861 } else if (ACPI_COMPARE_NAME(signature, ACPI_SIG_RSDT)) {
862 table_address =
863 (acpi_physical_address) gbl_rsdp.
864 rsdt_physical_address;
865 } else {
866 table_address =
867 (acpi_physical_address) gbl_rsdp_address;
868 signature = ACPI_SIG_RSDP;
869 }
870
871 /* Now we can get the requested special table */
872
873 status = osl_map_table(table_address, signature, &mapped_table);
874 if (ACPI_FAILURE(status)) {
875 return (status);
876 }
877
878 table_length = ap_get_table_length(mapped_table);
879 } else { /* Case for a normal ACPI table */
880
881 if (osl_can_use_xsdt()) {
882 item_size = sizeof(u64);
883 table_data =
884 ACPI_CAST8(gbl_xsdt) +
885 sizeof(struct acpi_table_header);
886 number_of_tables =
887 (u8)((gbl_xsdt->header.length -
888 sizeof(struct acpi_table_header))
889 / item_size);
890 } else { /* Use RSDT if XSDT is not available */
891
892 item_size = sizeof(u32);
893 table_data =
894 ACPI_CAST8(gbl_rsdt) +
895 sizeof(struct acpi_table_header);
896 number_of_tables =
897 (u8)((gbl_rsdt->header.length -
898 sizeof(struct acpi_table_header))
899 / item_size);
900 }
901
902 /* Search RSDT/XSDT for the requested table */
903
904 for (i = 0; i < number_of_tables; ++i, table_data += item_size) {
905 if (osl_can_use_xsdt()) {
906 table_address =
907 (acpi_physical_address) (*ACPI_CAST64
908 (table_data));
909 } else {
910 table_address =
911 (acpi_physical_address) (*ACPI_CAST32
912 (table_data));
913 }
914
915 /* Skip NULL entries in RSDT/XSDT */
916
917 if (!table_address) {
918 continue;
919 }
920
921 status =
922 osl_map_table(table_address, NULL, &mapped_table);
923 if (ACPI_FAILURE(status)) {
924 return (status);
925 }
926 table_length = mapped_table->length;
927
928 /* Does this table match the requested signature? */
929
930 if (!ACPI_COMPARE_NAME
931 (mapped_table->signature, signature)) {
932 osl_unmap_table(mapped_table);
933 mapped_table = NULL;
934 continue;
935 }
936
937 /* Match table instance (for SSDT/UEFI tables) */
938
939 if (current_instance != instance) {
940 osl_unmap_table(mapped_table);
941 mapped_table = NULL;
942 current_instance++;
943 continue;
944 }
945
946 break;
947 }
948 }
949
950 if (!mapped_table) {
951 return (AE_LIMIT);
952 }
953
954 if (table_length == 0) {
955 status = AE_BAD_HEADER;
956 goto exit;
957 }
958
959 /* Copy table to local buffer and return it */
960
961 local_table = calloc(1, table_length);
962 if (!local_table) {
963 status = AE_NO_MEMORY;
964 goto exit;
965 }
966
967 memcpy(local_table, mapped_table, table_length);
968 *address = table_address;
969 *table = local_table;
970
971 exit:
972 osl_unmap_table(mapped_table);
973 return (status);
974 }
975
976 /******************************************************************************
977 *
978 * FUNCTION: osl_list_customized_tables
979 *
980 * PARAMETERS: directory - Directory that contains the tables
981 *
982 * RETURN: Status; Table list is initialized if AE_OK.
983 *
984 * DESCRIPTION: Add ACPI tables to the table list from a directory.
985 *
986 *****************************************************************************/
987
988 static acpi_status osl_list_customized_tables(char *directory)
989 {
990 void *table_dir;
991 u32 instance;
992 char temp_name[ACPI_NAME_SIZE];
993 char *filename;
994 acpi_status status = AE_OK;
995
996 /* Open the requested directory */
997
998 table_dir = acpi_os_open_directory(directory, "*", REQUEST_FILE_ONLY);
999 if (!table_dir) {
1000 return (osl_get_last_status(AE_NOT_FOUND));
1001 }
1002
1003 /* Examine all entries in this directory */
1004
1005 while ((filename = acpi_os_get_next_filename(table_dir))) {
1006
1007 /* Extract table name and instance number */
1008
1009 status =
1010 osl_table_name_from_file(filename, temp_name, &instance);
1011
1012 /* Ignore meaningless files */
1013
1014 if (ACPI_FAILURE(status)) {
1015 continue;
1016 }
1017
1018 /* Add new info node to global table list */
1019
1020 status = osl_add_table_to_list(temp_name, instance);
1021 if (ACPI_FAILURE(status)) {
1022 break;
1023 }
1024 }
1025
1026 acpi_os_close_directory(table_dir);
1027 return (status);
1028 }
1029
1030 /******************************************************************************
1031 *
1032 * FUNCTION: osl_map_table
1033 *
1034 * PARAMETERS: address - Address of the table in memory
1035 * signature - Optional ACPI Signature for desired table.
1036 * Null terminated 4-character string.
1037 * table - Where a pointer to the mapped table is
1038 * returned
1039 *
1040 * RETURN: Status; Mapped table is returned if AE_OK.
1041 * AE_NOT_FOUND: A valid table was not found at the address
1042 *
1043 * DESCRIPTION: Map entire ACPI table into caller's address space.
1044 *
1045 *****************************************************************************/
1046
1047 static acpi_status
1048 osl_map_table(acpi_size address,
1049 char *signature, struct acpi_table_header **table)
1050 {
1051 struct acpi_table_header *mapped_table;
1052 u32 length;
1053
1054 if (!address) {
1055 return (AE_BAD_ADDRESS);
1056 }
1057
1058 /*
1059 * Map the header so we can get the table length.
1060 * Use sizeof (struct acpi_table_header) as:
1061 * 1. it is bigger than 24 to include RSDP->Length
1062 * 2. it is smaller than sizeof (struct acpi_table_rsdp)
1063 */
1064 mapped_table =
1065 acpi_os_map_memory(address, sizeof(struct acpi_table_header));
1066 if (!mapped_table) {
1067 fprintf(stderr, "Could not map table header at 0x%8.8X%8.8X\n",
1068 ACPI_FORMAT_UINT64(address));
1069 return (osl_get_last_status(AE_BAD_ADDRESS));
1070 }
1071
1072 /* If specified, signature must match */
1073
1074 if (signature) {
1075 if (ACPI_VALIDATE_RSDP_SIG(signature)) {
1076 if (!ACPI_VALIDATE_RSDP_SIG(mapped_table->signature)) {
1077 acpi_os_unmap_memory(mapped_table,
1078 sizeof(struct
1079 acpi_table_header));
1080 return (AE_BAD_SIGNATURE);
1081 }
1082 } else
1083 if (!ACPI_COMPARE_NAME(signature, mapped_table->signature))
1084 {
1085 acpi_os_unmap_memory(mapped_table,
1086 sizeof(struct acpi_table_header));
1087 return (AE_BAD_SIGNATURE);
1088 }
1089 }
1090
1091 /* Map the entire table */
1092
1093 length = ap_get_table_length(mapped_table);
1094 acpi_os_unmap_memory(mapped_table, sizeof(struct acpi_table_header));
1095 if (length == 0) {
1096 return (AE_BAD_HEADER);
1097 }
1098
1099 mapped_table = acpi_os_map_memory(address, length);
1100 if (!mapped_table) {
1101 fprintf(stderr,
1102 "Could not map table at 0x%8.8X%8.8X length %8.8X\n",
1103 ACPI_FORMAT_UINT64(address), length);
1104 return (osl_get_last_status(AE_INVALID_TABLE_LENGTH));
1105 }
1106
1107 (void)ap_is_valid_checksum(mapped_table);
1108
1109 *table = mapped_table;
1110 return (AE_OK);
1111 }
1112
1113 /******************************************************************************
1114 *
1115 * FUNCTION: osl_unmap_table
1116 *
1117 * PARAMETERS: table - A pointer to the mapped table
1118 *
1119 * RETURN: None
1120 *
1121 * DESCRIPTION: Unmap entire ACPI table.
1122 *
1123 *****************************************************************************/
1124
1125 static void osl_unmap_table(struct acpi_table_header *table)
1126 {
1127 if (table) {
1128 acpi_os_unmap_memory(table, ap_get_table_length(table));
1129 }
1130 }
1131
1132 /******************************************************************************
1133 *
1134 * FUNCTION: osl_table_name_from_file
1135 *
1136 * PARAMETERS: filename - File that contains the desired table
1137 * signature - Pointer to 4-character buffer to store
1138 * extracted table signature.
1139 * instance - Pointer to integer to store extracted
1140 * table instance number.
1141 *
1142 * RETURN: Status; Table name is extracted if AE_OK.
1143 *
1144 * DESCRIPTION: Extract table signature and instance number from a table file
1145 * name.
1146 *
1147 *****************************************************************************/
1148
1149 static acpi_status
1150 osl_table_name_from_file(char *filename, char *signature, u32 *instance)
1151 {
1152
1153 /* Ignore meaningless files */
1154
1155 if (strlen(filename) < ACPI_NAME_SIZE) {
1156 return (AE_BAD_SIGNATURE);
1157 }
1158
1159 /* Extract instance number */
1160
1161 if (isdigit((int)filename[ACPI_NAME_SIZE])) {
1162 sscanf(&filename[ACPI_NAME_SIZE], "%u", instance);
1163 } else if (strlen(filename) != ACPI_NAME_SIZE) {
1164 return (AE_BAD_SIGNATURE);
1165 } else {
1166 *instance = 0;
1167 }
1168
1169 /* Extract signature */
1170
1171 ACPI_MOVE_NAME(signature, filename);
1172 return (AE_OK);
1173 }
1174
1175 /******************************************************************************
1176 *
1177 * FUNCTION: osl_read_table_from_file
1178 *
1179 * PARAMETERS: filename - File that contains the desired table
1180 * file_offset - Offset of the table in file
1181 * signature - Optional ACPI Signature for desired table.
1182 * A null terminated 4-character string.
1183 * table - Where a pointer to the table is returned
1184 *
1185 * RETURN: Status; Table buffer is returned if AE_OK.
1186 *
1187 * DESCRIPTION: Read a ACPI table from a file.
1188 *
1189 *****************************************************************************/
1190
1191 static acpi_status
1192 osl_read_table_from_file(char *filename,
1193 acpi_size file_offset,
1194 char *signature, struct acpi_table_header **table)
1195 {
1196 FILE *table_file;
1197 struct acpi_table_header header;
1198 struct acpi_table_header *local_table = NULL;
1199 u32 table_length;
1200 s32 count;
1201 acpi_status status = AE_OK;
1202
1203 /* Open the file */
1204
1205 table_file = fopen(filename, "rb");
1206 if (table_file == NULL) {
1207 fprintf(stderr, "Could not open table file: %s\n", filename);
1208 return (osl_get_last_status(AE_NOT_FOUND));
1209 }
1210
1211 fseek(table_file, file_offset, SEEK_SET);
1212
1213 /* Read the Table header to get the table length */
1214
1215 count = fread(&header, 1, sizeof(struct acpi_table_header), table_file);
1216 if (count != sizeof(struct acpi_table_header)) {
1217 fprintf(stderr, "Could not read table header: %s\n", filename);
1218 status = AE_BAD_HEADER;
1219 goto exit;
1220 }
1221
1222 /* If signature is specified, it must match the table */
1223
1224 if (signature) {
1225 if (ACPI_VALIDATE_RSDP_SIG(signature)) {
1226 if (!ACPI_VALIDATE_RSDP_SIG(header.signature)) {
1227 fprintf(stderr,
1228 "Incorrect RSDP signature: found %8.8s\n",
1229 header.signature);
1230 status = AE_BAD_SIGNATURE;
1231 goto exit;
1232 }
1233 } else if (!ACPI_COMPARE_NAME(signature, header.signature)) {
1234 fprintf(stderr,
1235 "Incorrect signature: Expecting %4.4s, found %4.4s\n",
1236 signature, header.signature);
1237 status = AE_BAD_SIGNATURE;
1238 goto exit;
1239 }
1240 }
1241
1242 table_length = ap_get_table_length(&header);
1243 if (table_length == 0) {
1244 status = AE_BAD_HEADER;
1245 goto exit;
1246 }
1247
1248 /* Read the entire table into a local buffer */
1249
1250 local_table = calloc(1, table_length);
1251 if (!local_table) {
1252 fprintf(stderr,
1253 "%4.4s: Could not allocate buffer for table of length %X\n",
1254 header.signature, table_length);
1255 status = AE_NO_MEMORY;
1256 goto exit;
1257 }
1258
1259 fseek(table_file, file_offset, SEEK_SET);
1260
1261 count = fread(local_table, 1, table_length, table_file);
1262 if (count != table_length) {
1263 fprintf(stderr, "%4.4s: Could not read table content\n",
1264 header.signature);
1265 status = AE_INVALID_TABLE_LENGTH;
1266 goto exit;
1267 }
1268
1269 /* Validate checksum */
1270
1271 (void)ap_is_valid_checksum(local_table);
1272
1273 exit:
1274 fclose(table_file);
1275 *table = local_table;
1276 return (status);
1277 }
1278
1279 /******************************************************************************
1280 *
1281 * FUNCTION: osl_get_customized_table
1282 *
1283 * PARAMETERS: pathname - Directory to find Linux customized table
1284 * signature - ACPI Signature for desired table. Must be
1285 * a null terminated 4-character string.
1286 * instance - Multiple table support for SSDT/UEFI (0...n)
1287 * Must be 0 for other tables.
1288 * table - Where a pointer to the table is returned
1289 * address - Where the table physical address is returned
1290 *
1291 * RETURN: Status; Table buffer is returned if AE_OK.
1292 * AE_LIMIT: Instance is beyond valid limit
1293 * AE_NOT_FOUND: A table with the signature was not found
1294 *
1295 * DESCRIPTION: Get an OS customized table.
1296 *
1297 *****************************************************************************/
1298
1299 static acpi_status
1300 osl_get_customized_table(char *pathname,
1301 char *signature,
1302 u32 instance,
1303 struct acpi_table_header **table,
1304 acpi_physical_address * address)
1305 {
1306 void *table_dir;
1307 u32 current_instance = 0;
1308 char temp_name[ACPI_NAME_SIZE];
1309 char table_filename[PATH_MAX];
1310 char *filename;
1311 acpi_status status;
1312
1313 /* Open the directory for customized tables */
1314
1315 table_dir = acpi_os_open_directory(pathname, "*", REQUEST_FILE_ONLY);
1316 if (!table_dir) {
1317 return (osl_get_last_status(AE_NOT_FOUND));
1318 }
1319
1320 /* Attempt to find the table in the directory */
1321
1322 while ((filename = acpi_os_get_next_filename(table_dir))) {
1323
1324 /* Ignore meaningless files */
1325
1326 if (!ACPI_COMPARE_NAME(filename, signature)) {
1327 continue;
1328 }
1329
1330 /* Extract table name and instance number */
1331
1332 status =
1333 osl_table_name_from_file(filename, temp_name,
1334 &current_instance);
1335
1336 /* Ignore meaningless files */
1337
1338 if (ACPI_FAILURE(status) || current_instance != instance) {
1339 continue;
1340 }
1341
1342 /* Create the table pathname */
1343
1344 if (instance != 0) {
1345 sprintf(table_filename, "%s/%4.4s%d", pathname,
1346 temp_name, instance);
1347 } else {
1348 sprintf(table_filename, "%s/%4.4s", pathname,
1349 temp_name);
1350 }
1351 break;
1352 }
1353
1354 acpi_os_close_directory(table_dir);
1355
1356 if (!filename) {
1357 return (AE_LIMIT);
1358 }
1359
1360 /* There is no physical address saved for customized tables, use zero */
1361
1362 *address = 0;
1363 status = osl_read_table_from_file(table_filename, 0, NULL, table);
1364
1365 return (status);
1366 }
Linux kernel - Deliverables
This page took 0.080092 seconds and 5 git commands to generate.