1 /******************************************************************************
2 *
3 * Module Name: osfreebsdtbl - FreeBSD OSL for obtaining ACPI tables
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2013, 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 #include <kenv.h>
47 #include <unistd.h>
48 #include <sys/param.h>
49 #include <sys/sysctl.h>
50
51
52 #define _COMPONENT ACPI_OS_SERVICES
53 ACPI_MODULE_NAME ("osfreebsdtbl")
54
55
56 /* Local prototypes */
57
58 static ACPI_STATUS
59 OslTableInitialize (
60 void);
61
62 static ACPI_STATUS
63 OslMapTable (
64 ACPI_SIZE Address,
65 char *Signature,
66 ACPI_TABLE_HEADER **Table);
67
68 static ACPI_STATUS
69 OslAddTablesToList (
70 void);
71
72 static ACPI_STATUS
73 OslGetTableViaRoot (
74 char *Signature,
75 UINT32 Instance,
76 ACPI_TABLE_HEADER **Table,
77 ACPI_PHYSICAL_ADDRESS *Address);
78
79
80 /* Hints for RSDP */
81
82 #define SYSTEM_KENV "hint.acpi.0.rsdp"
83 #define SYSTEM_SYSCTL "machdep.acpi_root"
84
85 /* Initialization flags */
86
87 UINT8 Gbl_TableListInitialized = FALSE;
88 UINT8 Gbl_MainTableObtained = FALSE;
89
90 /* Local copies of main ACPI tables */
91
92 ACPI_TABLE_RSDP Gbl_Rsdp;
93 ACPI_TABLE_FADT *Gbl_Fadt;
94 ACPI_TABLE_RSDT *Gbl_Rsdt;
95 ACPI_TABLE_XSDT *Gbl_Xsdt;
96
97 /* Fadt address */
98
99 ACPI_PHYSICAL_ADDRESS Gbl_FadtAddress;
100
101 /* Revision of RSD PTR */
102
103 UINT8 Gbl_Revision;
104
105 /* List of information about obtained ACPI tables */
106
107 typedef struct table_info
108 {
109 struct table_info *Next;
110 char Signature[4];
111 UINT32 Instance;
112 ACPI_PHYSICAL_ADDRESS Address;
113
114 } OSL_TABLE_INFO;
115
116 OSL_TABLE_INFO *Gbl_TableListHead = NULL;
117
118
119 /******************************************************************************
120 *
121 * FUNCTION: AcpiOsGetTableByAddress
122 *
123 * PARAMETERS: Address - Physical address of the ACPI table
124 * Table - Where a pointer to the table is returned
125 *
126 * RETURN: Status; Table buffer is returned if AE_OK.
127 * AE_NOT_FOUND: A valid table was not found at the address
128 *
129 * DESCRIPTION: Get an ACPI table via a physical memory address.
130 *
131 *****************************************************************************/
132
133 ACPI_STATUS
134 AcpiOsGetTableByAddress (
135 ACPI_PHYSICAL_ADDRESS Address,
136 ACPI_TABLE_HEADER **Table)
137 {
138 ACPI_TABLE_HEADER *MappedTable;
139 ACPI_TABLE_HEADER *LocalTable;
140 ACPI_STATUS Status;
141
142
143 /* Validate the input physical address to avoid program crash */
144
145 if (Address < ACPI_HI_RSDP_WINDOW_BASE)
146 {
147 fprintf (stderr, "Invalid table address: 0x%8.8X%8.8X\n",
148 ACPI_FORMAT_UINT64 (Address));
149 return (AE_BAD_ADDRESS);
150 }
151
152 /* Map the table and validate it */
153
154 Status = OslMapTable (Address, NULL, &MappedTable);
155 if (ACPI_FAILURE (Status))
156 {
157 return (Status);
158 }
159
160 /* Copy table to local buffer and return it */
161
162 LocalTable = calloc (1, MappedTable->Length);
163 if (!LocalTable)
164 {
165 AcpiOsUnmapMemory (MappedTable, MappedTable->Length);
166 return (AE_NO_MEMORY);
167 }
168
169 ACPI_MEMCPY (LocalTable, MappedTable, MappedTable->Length);
170 AcpiOsUnmapMemory (MappedTable, MappedTable->Length);
171
172 *Table = LocalTable;
173 return (AE_OK);
174 }
175
176
177 /******************************************************************************
178 *
179 * FUNCTION: AcpiOsGetTableByName
180 *
181 * PARAMETERS: Signature - ACPI Signature for desired table. Must be
182 * a null terminated 4-character string.
183 * Instance - Multiple table support for SSDT/UEFI (0...n)
184 * Must be 0 for other tables.
185 * Table - Where a pointer to the table is returned
186 * Address - Where the table physical address is returned
187 *
188 * RETURN: Status; Table buffer and physical address returned if AE_OK.
189 * AE_LIMIT: Instance is beyond valid limit
190 * AE_NOT_FOUND: A table with the signature was not found
191 *
192 * NOTE: Assumes the input signature is uppercase.
193 *
194 *****************************************************************************/
195
196 ACPI_STATUS
197 AcpiOsGetTableByName (
198 char *Signature,
199 UINT32 Instance,
200 ACPI_TABLE_HEADER **Table,
201 ACPI_PHYSICAL_ADDRESS *Address)
202 {
203 ACPI_STATUS Status;
204
205
206 /* Instance is only valid for SSDT/UEFI tables */
207
208 if (Instance &&
209 !ACPI_COMPARE_NAME (Signature, ACPI_SIG_SSDT) &&
210 !ACPI_COMPARE_NAME (Signature, ACPI_SIG_UEFI))
211 {
212 return (AE_LIMIT);
213 }
214
215 /* Initialize main tables */
216
217 Status = OslTableInitialize ();
218 if (ACPI_FAILURE (Status))
219 {
220 return (Status);
221 }
222
223 /*
224 * If one of the main ACPI tables was requested (RSDT/XSDT/FADT),
225 * simply return it immediately.
226 */
227 if (ACPI_COMPARE_NAME (Signature, ACPI_SIG_XSDT))
228 {
229 if (!Gbl_Revision)
230 {
231 return (AE_NOT_FOUND);
232 }
233
234 *Address = Gbl_Rsdp.XsdtPhysicalAddress;
235 *Table = (ACPI_TABLE_HEADER *) Gbl_Xsdt;
236 return (AE_OK);
237 }
238
239 if (ACPI_COMPARE_NAME (Signature, ACPI_SIG_RSDT))
240 {
241 if (!Gbl_Rsdp.RsdtPhysicalAddress)
242 {
243 return (AE_NOT_FOUND);
244 }
245
246 *Address = Gbl_Rsdp.RsdtPhysicalAddress;
247 *Table = (ACPI_TABLE_HEADER *) Gbl_Rsdt;
248 return (AE_OK);
249 }
250
251 if (ACPI_COMPARE_NAME (Signature, ACPI_SIG_FADT))
252 {
253 *Address = Gbl_FadtAddress;
254 *Table = (ACPI_TABLE_HEADER *) Gbl_Fadt;
255 return (AE_OK);
256 }
257
258 /* Not a main ACPI table, attempt to extract it from the RSDT/XSDT */
259
260 Status = OslGetTableViaRoot (Signature, Instance, Table, Address);
261 if (ACPI_FAILURE (Status))
262 {
263 return (Status);
264 }
265
266 return (AE_OK);
267 }
268
269
270 /******************************************************************************
271 *
272 * FUNCTION: AcpiOsGetTableByIndex
273 *
274 * PARAMETERS: Index - Which table to get
275 * Table - Where a pointer to the table is returned
276 * Instance - Where a pointer to the table instance no. is
277 * returned
278 * Address - Where the table physical address is returned
279 *
280 * RETURN: Status; Table buffer and physical address returned if AE_OK.
281 * AE_LIMIT: Index is beyond valid limit
282 *
283 * DESCRIPTION: Get an ACPI table via an index value (0 through n). Returns
284 * AE_LIMIT when an invalid index is reached. Index is not
285 * necessarily an index into the RSDT/XSDT.
286 *
287 *****************************************************************************/
288
289 ACPI_STATUS
290 AcpiOsGetTableByIndex (
291 UINT32 Index,
292 ACPI_TABLE_HEADER **Table,
293 UINT32 *Instance,
294 ACPI_PHYSICAL_ADDRESS *Address)
295 {
296 OSL_TABLE_INFO *Info;
297 ACPI_STATUS Status;
298 UINT32 i;
299
300
301 /* Initialize main tables */
302
303 Status = OslTableInitialize ();
304 if (ACPI_FAILURE (Status))
305 {
306 return (Status);
307 }
308
309 /* Add all tables to list */
310
311 Status = OslAddTablesToList ();
312 if (ACPI_FAILURE (Status))
313 {
314 return (Status);
315 }
316
317 /* Validate Index */
318
319 if (Index >= Gbl_TableListHead->Instance)
320 {
321 return (AE_LIMIT);
322 }
323
324 /* Point to the table list entry specified by the Index argument */
325
326 Info = Gbl_TableListHead;
327 for (i = 0; i <= Index; i++)
328 {
329 Info = Info->Next;
330 }
331
332 /* Now we can just get the table via the address or name */
333
334 if (Info->Address)
335 {
336 Status = AcpiOsGetTableByAddress (Info->Address, Table);
337 if (ACPI_SUCCESS (Status))
338 {
339 *Address = Info->Address;
340 }
341 }
342 else
343 {
344 Status = AcpiOsGetTableByName (Info->Signature, Info->Instance,
345 Table, Address);
346 }
347
348 if (ACPI_SUCCESS (Status))
349 {
350 *Instance = Info->Instance;
351 }
352 return (Status);
353 }
354
355
356 /******************************************************************************
357 *
358 * FUNCTION: OslTableInitialize
359 *
360 * PARAMETERS: None
361 *
362 * RETURN: Status
363 *
364 * DESCRIPTION: Initialize ACPI table data. Get and store main ACPI tables to
365 * local variables. Main ACPI tables include RSDP, FADT, RSDT,
366 * and/or XSDT.
367 *
368 *****************************************************************************/
369
370 static ACPI_STATUS
371 OslTableInitialize (
372 void)
373 {
374 char Buffer[32];
375 ACPI_TABLE_HEADER *MappedTable;
376 UINT8 *TableAddress;
377 UINT8 *RsdpAddress;
378 ACPI_PHYSICAL_ADDRESS RsdpBase;
379 ACPI_SIZE RsdpSize;
380 ACPI_STATUS Status;
381 u_long Address = 0;
382 size_t Length = sizeof (Address);
383
384
385 /* Get main ACPI tables from memory on first invocation of this function */
386
387 if (Gbl_MainTableObtained)
388 {
389 return (AE_OK);
390 }
391
392 /* Attempt to use kenv or sysctl to find RSD PTR record. */
393
394 if (Gbl_RsdpBase)
395 {
396 Address = Gbl_RsdpBase;
397 }
398 else if (kenv (KENV_GET, SYSTEM_KENV, Buffer, sizeof (Buffer)) > 0)
399 {
400 Address = ACPI_STRTOUL (Buffer, NULL, 0);
401 }
402 if (!Address)
403 {
404 if (sysctlbyname (SYSTEM_SYSCTL, &Address, &Length, NULL, 0) != 0)
405 {
406 Address = 0;
407 }
408 }
409 if (Address)
410 {
411 RsdpBase = Address;
412 RsdpSize = sizeof (Gbl_Rsdp);
413 }
414 else
415 {
416 RsdpBase = ACPI_HI_RSDP_WINDOW_BASE;
417 RsdpSize = ACPI_HI_RSDP_WINDOW_SIZE;
418 }
419
420 /* Get RSDP from memory */
421
422 RsdpAddress = AcpiOsMapMemory (RsdpBase, RsdpSize);
423 if (!RsdpAddress)
424 {
425 return (AE_BAD_ADDRESS);
426 }
427
428 /* Search low memory for the RSDP */
429
430 TableAddress = AcpiTbScanMemoryForRsdp (RsdpAddress, RsdpSize);
431 if (!TableAddress)
432 {
433 AcpiOsUnmapMemory (RsdpAddress, RsdpSize);
434 return (AE_ERROR);
435 }
436
437 ACPI_MEMCPY (&Gbl_Rsdp, TableAddress, sizeof (Gbl_Rsdp));
438 AcpiOsUnmapMemory (RsdpAddress, RsdpSize);
439
440 /* Get XSDT from memory */
441
442 if (Gbl_Rsdp.Revision)
443 {
444 Status = OslMapTable (Gbl_Rsdp.XsdtPhysicalAddress,
445 ACPI_SIG_XSDT, &MappedTable);
446 if (ACPI_FAILURE (Status))
447 {
448 return (Status);
449 }
450
451 Gbl_Revision = 2;
452 Gbl_Xsdt = calloc (1, MappedTable->Length);
453 if (!Gbl_Xsdt)
454 {
455 fprintf (stderr,
456 "XSDT: Could not allocate buffer for table of length %X\n",
457 MappedTable->Length);
458 AcpiOsUnmapMemory (MappedTable, MappedTable->Length);
459 return (AE_NO_MEMORY);
460 }
461
462 ACPI_MEMCPY (Gbl_Xsdt, MappedTable, MappedTable->Length);
463 AcpiOsUnmapMemory (MappedTable, MappedTable->Length);
464 }
465
466 /* Get RSDT from memory */
467
468 if (Gbl_Rsdp.RsdtPhysicalAddress)
469 {
470 Status = OslMapTable (Gbl_Rsdp.RsdtPhysicalAddress,
471 ACPI_SIG_RSDT, &MappedTable);
472 if (ACPI_FAILURE (Status))
473 {
474 return (Status);
475 }
476
477 Gbl_Rsdt = calloc (1, MappedTable->Length);
478 if (!Gbl_Rsdt)
479 {
480 fprintf (stderr,
481 "RSDT: Could not allocate buffer for table of length %X\n",
482 MappedTable->Length);
483 AcpiOsUnmapMemory (MappedTable, MappedTable->Length);
484 return (AE_NO_MEMORY);
485 }
486
487 ACPI_MEMCPY (Gbl_Rsdt, MappedTable, MappedTable->Length);
488 AcpiOsUnmapMemory (MappedTable, MappedTable->Length);
489 }
490
491 /* Get FADT from memory */
492
493 if (Gbl_Revision)
494 {
495 Gbl_FadtAddress = Gbl_Xsdt->TableOffsetEntry[0];
496 }
497 else
498 {
499 Gbl_FadtAddress = Gbl_Rsdt->TableOffsetEntry[0];
500 }
501
502 if (!Gbl_FadtAddress)
503 {
504 fprintf(stderr, "FADT: Table could not be found\n");
505 return (AE_ERROR);
506 }
507
508 Status = OslMapTable (Gbl_FadtAddress, ACPI_SIG_FADT, &MappedTable);
509 if (ACPI_FAILURE (Status))
510 {
511 return (Status);
512 }
513
514 Gbl_Fadt = calloc (1, MappedTable->Length);
515 if (!Gbl_Fadt)
516 {
517 fprintf (stderr,
518 "FADT: Could not allocate buffer for table of length %X\n",
519 MappedTable->Length);
520 AcpiOsUnmapMemory (MappedTable, MappedTable->Length);
521 return (AE_NO_MEMORY);
522 }
523
524 ACPI_MEMCPY (Gbl_Fadt, MappedTable, MappedTable->Length);
525 AcpiOsUnmapMemory (MappedTable, MappedTable->Length);
526 Gbl_MainTableObtained = TRUE;
527 return (AE_OK);
528 }
529
530
531 /******************************************************************************
532 *
533 * FUNCTION: OslGetTableViaRoot
534 *
535 * PARAMETERS: Signature - ACPI Signature for common table. Must be
536 * a null terminated 4-character string.
537 * Instance - Multiple table support for SSDT/UEFI (0...n)
538 * Must be 0 for other tables.
539 * Table - Where a pointer to the table is returned
540 * Address - Where the table physical address is returned
541 *
542 * RETURN: Status; Table buffer and physical address returned if AE_OK.
543 * AE_LIMIT: Instance is beyond valid limit
544 * AE_NOT_FOUND: A table with the signature was not found
545 *
546 * DESCRIPTION: Get an ACPI table via the root table (RSDT/XSDT)
547 *
548 * NOTE: Assumes the input signature is uppercase.
549 *
550 *****************************************************************************/
551
552 static ACPI_STATUS
553 OslGetTableViaRoot (
554 char *Signature,
555 UINT32 Instance,
556 ACPI_TABLE_HEADER **Table,
557 ACPI_PHYSICAL_ADDRESS *Address)
558 {
559 ACPI_TABLE_HEADER *LocalTable = NULL;
560 ACPI_TABLE_HEADER *MappedTable = NULL;
561 UINT8 NumberOfTables;
562 UINT32 CurrentInstance = 0;
563 ACPI_PHYSICAL_ADDRESS TableAddress = 0;
564 ACPI_STATUS Status;
565 UINT32 i;
566
567
568 /* DSDT and FACS address must be extracted from the FADT */
569
570 if (ACPI_COMPARE_NAME (Signature, ACPI_SIG_DSDT) ||
571 ACPI_COMPARE_NAME (Signature, ACPI_SIG_FACS))
572 {
573 /*
574 * Get the appropriate address, either 32-bit or 64-bit. Be very
575 * careful about the FADT length and validate table addresses.
576 * Note: The 64-bit addresses have priority.
577 */
578 if (ACPI_COMPARE_NAME (Signature, ACPI_SIG_DSDT))
579 {
580 if ((Gbl_Fadt->Header.Length >= MIN_FADT_FOR_XDSDT) &&
581 Gbl_Fadt->XDsdt)
582 {
583 TableAddress = (ACPI_PHYSICAL_ADDRESS) Gbl_Fadt->XDsdt;
584 }
585 else if ((Gbl_Fadt->Header.Length >= MIN_FADT_FOR_DSDT) &&
586 Gbl_Fadt->Dsdt)
587 {
588 TableAddress = (ACPI_PHYSICAL_ADDRESS) Gbl_Fadt->Dsdt;
589 }
590 }
591 else /* FACS */
592 {
593 if ((Gbl_Fadt->Header.Length >= MIN_FADT_FOR_XFACS) &&
594 Gbl_Fadt->XFacs)
595 {
596 TableAddress = (ACPI_PHYSICAL_ADDRESS) Gbl_Fadt->XFacs;
597 }
598 else if ((Gbl_Fadt->Header.Length >= MIN_FADT_FOR_FACS) &&
599 Gbl_Fadt->Facs)
600 {
601 TableAddress = (ACPI_PHYSICAL_ADDRESS) Gbl_Fadt->Facs;
602 }
603 }
604 }
605 else /* Case for a normal ACPI table */
606 {
607 if (Gbl_Revision)
608 {
609 NumberOfTables =
610 (Gbl_Xsdt->Header.Length - sizeof (Gbl_Xsdt->Header))
611 / sizeof (Gbl_Xsdt->TableOffsetEntry[0]);
612 }
613 else /* Use RSDT if XSDT is not available */
614 {
615 NumberOfTables =
616 (Gbl_Rsdt->Header.Length - sizeof (Gbl_Rsdt->Header))
617 / sizeof (Gbl_Rsdt->TableOffsetEntry[0]);
618 }
619
620 /* Search RSDT/XSDT for the requested table */
621
622 for (i = 0; i < NumberOfTables; i++)
623 {
624 if (Gbl_Revision)
625 {
626 TableAddress = Gbl_Xsdt->TableOffsetEntry[i];
627 }
628 else
629 {
630 TableAddress = Gbl_Rsdt->TableOffsetEntry[i];
631 }
632
633 MappedTable = AcpiOsMapMemory (TableAddress, sizeof (*MappedTable));
634 if (!MappedTable)
635 {
636 return (AE_BAD_ADDRESS);
637 }
638
639 /* Does this table match the requested signature? */
640
641 if (ACPI_COMPARE_NAME (MappedTable->Signature, Signature))
642 {
643
644 /* Match table instance (for SSDT/UEFI tables) */
645
646 if (CurrentInstance == Instance)
647 {
648 AcpiOsUnmapMemory (MappedTable, sizeof (*MappedTable));
649 break;
650 }
651
652 CurrentInstance++;
653 }
654
655 AcpiOsUnmapMemory (MappedTable, MappedTable->Length);
656 TableAddress = 0;
657 }
658 }
659
660 if (!TableAddress)
661 {
662 if (CurrentInstance)
663 {
664 return (AE_LIMIT);
665 }
666 return (AE_NOT_FOUND);
667 }
668
669 /* Now we can get the requested table */
670
671 Status = OslMapTable (TableAddress, Signature, &MappedTable);
672 if (ACPI_FAILURE (Status))
673 {
674 return (Status);
675 }
676
677 /* Copy table to local buffer and return it */
678
679 LocalTable = calloc (1, MappedTable->Length);
680 if (!LocalTable)
681 {
682 AcpiOsUnmapMemory (MappedTable, MappedTable->Length);
683 return (AE_NO_MEMORY);
684 }
685
686 ACPI_MEMCPY (LocalTable, MappedTable, MappedTable->Length);
687 AcpiOsUnmapMemory (MappedTable, MappedTable->Length);
688 *Table = LocalTable;
689 *Address = TableAddress;
690 return (AE_OK);
691 }
692
693
694 /******************************************************************************
695 *
696 * FUNCTION: OslAddTablesToList
697 *
698 * PARAMETERS: None
699 *
700 * RETURN: Status; Table list is initialized if AE_OK.
701 *
702 * DESCRIPTION: Add ACPI tables to the table list.
703 *
704 *****************************************************************************/
705
706 static ACPI_STATUS
707 OslAddTablesToList(
708 void)
709 {
710 ACPI_PHYSICAL_ADDRESS TableAddress;
711 OSL_TABLE_INFO *Info = NULL;
712 OSL_TABLE_INFO *NewInfo;
713 ACPI_TABLE_HEADER *Table;
714 UINT8 Instance;
715 UINT8 NumberOfTables;
716 int i;
717
718
719 /* Initialize the table list on first invocation */
720
721 if (Gbl_TableListInitialized)
722 {
723 return (AE_OK);
724 }
725
726 /* Add mandatory tables to global table list first */
727
728 for (i = 0; i < 4; i++)
729 {
730 NewInfo = calloc (1, sizeof (*NewInfo));
731 if (!NewInfo)
732 {
733 return (AE_NO_MEMORY);
734 }
735
736 switch (i) {
737 case 0:
738
739 Gbl_TableListHead = Info = NewInfo;
740 continue;
741
742 case 1:
743
744 ACPI_MOVE_NAME (NewInfo->Signature,
745 Gbl_Revision ? ACPI_SIG_XSDT : ACPI_SIG_RSDT);
746 break;
747
748 case 2:
749
750 ACPI_MOVE_NAME (NewInfo->Signature, ACPI_SIG_FACS);
751 break;
752
753 default:
754
755 ACPI_MOVE_NAME (NewInfo->Signature, ACPI_SIG_DSDT);
756
757 }
758
759 Info->Next = NewInfo;
760 Info = NewInfo;
761 Gbl_TableListHead->Instance++;
762 }
763
764 /* Add normal tables from RSDT/XSDT to global list */
765
766 if (Gbl_Revision)
767 {
768 NumberOfTables =
769 (Gbl_Xsdt->Header.Length - sizeof (Gbl_Xsdt->Header))
770 / sizeof (Gbl_Xsdt->TableOffsetEntry[0]);
771 }
772 else
773 {
774 NumberOfTables =
775 (Gbl_Rsdt->Header.Length - sizeof (Gbl_Rsdt->Header))
776 / sizeof (Gbl_Rsdt->TableOffsetEntry[0]);
777 }
778
779 for (i = 0; i < NumberOfTables; i++)
780 {
781 if (Gbl_Revision)
782 {
783 TableAddress = Gbl_Xsdt->TableOffsetEntry[i];
784 }
785 else
786 {
787 TableAddress = Gbl_Rsdt->TableOffsetEntry[i];
788 }
789
790 Table = AcpiOsMapMemory (TableAddress, sizeof (*Table));
791 if (!Table)
792 {
793 return (AE_BAD_ADDRESS);
794 }
795
796 Instance = 0;
797 NewInfo = Gbl_TableListHead;
798 while (NewInfo->Next != NULL)
799 {
800 NewInfo = NewInfo->Next;
801 if (ACPI_COMPARE_NAME (Table->Signature, NewInfo->Signature))
802 {
803 Instance++;
804 }
805 }
806
807 NewInfo = calloc (1, sizeof (*NewInfo));
808 if (!NewInfo)
809 {
810 AcpiOsUnmapMemory (Table, sizeof (*Table));
811 return (AE_NO_MEMORY);
812 }
813
814 ACPI_MOVE_NAME (NewInfo->Signature, Table->Signature);
815
816 AcpiOsUnmapMemory (Table, sizeof (*Table));
817
818 NewInfo->Instance = Instance;
819 NewInfo->Address = TableAddress;
820 Info->Next = NewInfo;
821 Info = NewInfo;
822 Gbl_TableListHead->Instance++;
823 }
824
825 Gbl_TableListInitialized = TRUE;
826 return (AE_OK);
827 }
828
829
830 /******************************************************************************
831 *
832 * FUNCTION: OslMapTable
833 *
834 * PARAMETERS: Address - Address of the table in memory
835 * Signature - Optional ACPI Signature for desired table.
836 * Null terminated 4-character string.
837 * Table - Where a pointer to the mapped table is
838 * returned
839 *
840 * RETURN: Status; Mapped table is returned if AE_OK.
841 *
842 * DESCRIPTION: Map entire ACPI table into caller's address space. Also
843 * validates the table and checksum.
844 *
845 *****************************************************************************/
846
847 static ACPI_STATUS
848 OslMapTable (
849 ACPI_SIZE Address,
850 char *Signature,
851 ACPI_TABLE_HEADER **Table)
852 {
853 ACPI_TABLE_HEADER *MappedTable;
854 UINT32 Length;
855
856
857 /* Map the header so we can get the table length */
858
859 MappedTable = AcpiOsMapMemory (Address, sizeof (*MappedTable));
860 if (!MappedTable)
861 {
862 return (AE_BAD_ADDRESS);
863 }
864
865 /* Check if table is valid */
866
867 if (!ApIsValidHeader (MappedTable))
868 {
869 AcpiOsUnmapMemory (MappedTable, sizeof (*MappedTable));
870 return (AE_BAD_HEADER);
871 }
872
873 /* If specified, signature must match */
874
875 if (Signature &&
876 !ACPI_COMPARE_NAME (Signature, MappedTable->Signature))
877 {
878 AcpiOsUnmapMemory (MappedTable, sizeof (*MappedTable));
879 return (AE_NOT_EXIST);
880 }
881
882 /* Map the entire table */
883
884 Length = MappedTable->Length;
885 AcpiOsUnmapMemory (MappedTable, sizeof (*MappedTable));
886
887 MappedTable = AcpiOsMapMemory (Address, Length);
888 if (!MappedTable)
889 {
890 return (AE_BAD_ADDRESS);
891 }
892
893 (void) ApIsValidChecksum (MappedTable);
894
895 *Table = MappedTable;
896
897 return (AE_OK);
898 }