1 /******************************************************************************
2  *
3  * Module Name: dttable2.c - handling for specific 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 /* Compile all complex data tables, signatures starting with L-Z */
45 
46 #include "aslcompiler.h"
47 #include "dtcompiler.h"
48 
49 #define _COMPONENT          DT_COMPILER
50         ACPI_MODULE_NAME    ("dttable2")
51 
52 
53 /******************************************************************************
54  *
55  * FUNCTION:    DtCompileLpit
56  *
57  * PARAMETERS:  List                - Current field list pointer
58  *
59  * RETURN:      Status
60  *
61  * DESCRIPTION: Compile LPIT.
62  *
63  *****************************************************************************/
64 
65 ACPI_STATUS
66 DtCompileLpit (
67     void                    **List)
68 {
69     ACPI_STATUS             Status;
70     DT_SUBTABLE             *Subtable;
71     DT_SUBTABLE             *ParentTable;
72     DT_FIELD                **PFieldList = (DT_FIELD **) List;
73     DT_FIELD                *SubtableStart;
74     ACPI_DMTABLE_INFO       *InfoTable;
75     ACPI_LPIT_HEADER        *LpitHeader;
76 
77 
78     /* Note: Main table consists only of the standard ACPI table header */
79 
80     while (*PFieldList)
81     {
82         SubtableStart = *PFieldList;
83 
84         /* LPIT Subtable header */
85 
86         Status = DtCompileTable (PFieldList, AcpiDmTableInfoLpitHdr,
87             &Subtable, TRUE);
88         if (ACPI_FAILURE (Status))
89         {
90             return (Status);
91         }
92 
93         ParentTable = DtPeekSubtable ();
94         DtInsertSubtable (ParentTable, Subtable);
95         DtPushSubtable (Subtable);
96 
97         LpitHeader = ACPI_CAST_PTR (ACPI_LPIT_HEADER, Subtable->Buffer);
98 
99         switch (LpitHeader->Type)
100         {
101         case ACPI_LPIT_TYPE_NATIVE_CSTATE:
102 
103             InfoTable = AcpiDmTableInfoLpit0;
104             break;
105 
106         default:
107 
108             DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "LPIT");
109             return (AE_ERROR);
110         }
111 
112         /* LPIT Subtable */
113 
114         Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
115         if (ACPI_FAILURE (Status))
116         {
117             return (Status);
118         }
119 
120         ParentTable = DtPeekSubtable ();
121         DtInsertSubtable (ParentTable, Subtable);
122         DtPopSubtable ();
123     }
124 
125     return (AE_OK);
126 }
127 
128 
129 /******************************************************************************
130  *
131  * FUNCTION:    DtCompileMadt
132  *
133  * PARAMETERS:  List                - Current field list pointer
134  *
135  * RETURN:      Status
136  *
137  * DESCRIPTION: Compile MADT.
138  *
139  *****************************************************************************/
140 
141 ACPI_STATUS
142 DtCompileMadt (
143     void                    **List)
144 {
145     ACPI_STATUS             Status;
146     DT_SUBTABLE             *Subtable;
147     DT_SUBTABLE             *ParentTable;
148     DT_FIELD                **PFieldList = (DT_FIELD **) List;
149     DT_FIELD                *SubtableStart;
150     ACPI_SUBTABLE_HEADER    *MadtHeader;
151     ACPI_DMTABLE_INFO       *InfoTable;
152 
153 
154     Status = DtCompileTable (PFieldList, AcpiDmTableInfoMadt,
155         &Subtable, TRUE);
156     if (ACPI_FAILURE (Status))
157     {
158         return (Status);
159     }
160 
161     ParentTable = DtPeekSubtable ();
162     DtInsertSubtable (ParentTable, Subtable);
163 
164     while (*PFieldList)
165     {
166         SubtableStart = *PFieldList;
167         Status = DtCompileTable (PFieldList, AcpiDmTableInfoMadtHdr,
168             &Subtable, TRUE);
169         if (ACPI_FAILURE (Status))
170         {
171             return (Status);
172         }
173 
174         ParentTable = DtPeekSubtable ();
175         DtInsertSubtable (ParentTable, Subtable);
176         DtPushSubtable (Subtable);
177 
178         MadtHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer);
179 
180         switch (MadtHeader->Type)
181         {
182         case ACPI_MADT_TYPE_LOCAL_APIC:
183 
184             InfoTable = AcpiDmTableInfoMadt0;
185             break;
186 
187         case ACPI_MADT_TYPE_IO_APIC:
188 
189             InfoTable = AcpiDmTableInfoMadt1;
190             break;
191 
192         case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE:
193 
194             InfoTable = AcpiDmTableInfoMadt2;
195             break;
196 
197         case ACPI_MADT_TYPE_NMI_SOURCE:
198 
199             InfoTable = AcpiDmTableInfoMadt3;
200             break;
201 
202         case ACPI_MADT_TYPE_LOCAL_APIC_NMI:
203 
204             InfoTable = AcpiDmTableInfoMadt4;
205             break;
206 
207         case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE:
208 
209             InfoTable = AcpiDmTableInfoMadt5;
210             break;
211 
212         case ACPI_MADT_TYPE_IO_SAPIC:
213 
214             InfoTable = AcpiDmTableInfoMadt6;
215             break;
216 
217         case ACPI_MADT_TYPE_LOCAL_SAPIC:
218 
219             InfoTable = AcpiDmTableInfoMadt7;
220             break;
221 
222         case ACPI_MADT_TYPE_INTERRUPT_SOURCE:
223 
224             InfoTable = AcpiDmTableInfoMadt8;
225             break;
226 
227         case ACPI_MADT_TYPE_LOCAL_X2APIC:
228 
229             InfoTable = AcpiDmTableInfoMadt9;
230             break;
231 
232         case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI:
233 
234             InfoTable = AcpiDmTableInfoMadt10;
235             break;
236 
237         case ACPI_MADT_TYPE_GENERIC_INTERRUPT:
238 
239             InfoTable = AcpiDmTableInfoMadt11;
240             break;
241 
242         case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR:
243 
244             InfoTable = AcpiDmTableInfoMadt12;
245             break;
246 
247         case ACPI_MADT_TYPE_GENERIC_MSI_FRAME:
248 
249             InfoTable = AcpiDmTableInfoMadt13;
250             break;
251 
252         case ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR:
253 
254             InfoTable = AcpiDmTableInfoMadt14;
255             break;
256 
257         case ACPI_MADT_TYPE_GENERIC_TRANSLATOR:
258 
259             InfoTable = AcpiDmTableInfoMadt15;
260             break;
261 
262         default:
263 
264             DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "MADT");
265             return (AE_ERROR);
266         }
267 
268         Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
269         if (ACPI_FAILURE (Status))
270         {
271             return (Status);
272         }
273 
274         ParentTable = DtPeekSubtable ();
275         DtInsertSubtable (ParentTable, Subtable);
276         DtPopSubtable ();
277     }
278 
279     return (AE_OK);
280 }
281 
282 
283 /******************************************************************************
284  *
285  * FUNCTION:    DtCompileMcfg
286  *
287  * PARAMETERS:  List                - Current field list pointer
288  *
289  * RETURN:      Status
290  *
291  * DESCRIPTION: Compile MCFG.
292  *
293  *****************************************************************************/
294 
295 ACPI_STATUS
296 DtCompileMcfg (
297     void                    **List)
298 {
299     ACPI_STATUS             Status;
300 
301 
302     Status = DtCompileTwoSubtables (List,
303         AcpiDmTableInfoMcfg, AcpiDmTableInfoMcfg0);
304     return (Status);
305 }
306 
307 
308 /******************************************************************************
309  *
310  * FUNCTION:    DtCompileMpst
311  *
312  * PARAMETERS:  List                - Current field list pointer
313  *
314  * RETURN:      Status
315  *
316  * DESCRIPTION: Compile MPST.
317  *
318  *****************************************************************************/
319 
320 ACPI_STATUS
321 DtCompileMpst (
322     void                    **List)
323 {
324     ACPI_STATUS             Status;
325     DT_SUBTABLE             *Subtable;
326     DT_SUBTABLE             *ParentTable;
327     DT_FIELD                **PFieldList = (DT_FIELD **) List;
328     ACPI_MPST_CHANNEL       *MpstChannelInfo;
329     ACPI_MPST_POWER_NODE    *MpstPowerNode;
330     ACPI_MPST_DATA_HDR      *MpstDataHeader;
331     UINT16                  SubtableCount;
332     UINT32                  PowerStateCount;
333     UINT32                  ComponentCount;
334 
335 
336     /* Main table */
337 
338     Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst, &Subtable, TRUE);
339     if (ACPI_FAILURE (Status))
340     {
341         return (Status);
342     }
343 
344     ParentTable = DtPeekSubtable ();
345     DtInsertSubtable (ParentTable, Subtable);
346     DtPushSubtable (Subtable);
347 
348     MpstChannelInfo = ACPI_CAST_PTR (ACPI_MPST_CHANNEL, Subtable->Buffer);
349     SubtableCount = MpstChannelInfo->PowerNodeCount;
350 
351     while (*PFieldList && SubtableCount)
352     {
353         /* Subtable: Memory Power Node(s) */
354 
355         Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst0,
356             &Subtable, TRUE);
357         if (ACPI_FAILURE (Status))
358         {
359             return (Status);
360         }
361 
362         ParentTable = DtPeekSubtable ();
363         DtInsertSubtable (ParentTable, Subtable);
364         DtPushSubtable (Subtable);
365 
366         MpstPowerNode = ACPI_CAST_PTR (ACPI_MPST_POWER_NODE, Subtable->Buffer);
367         PowerStateCount = MpstPowerNode->NumPowerStates;
368         ComponentCount = MpstPowerNode->NumPhysicalComponents;
369 
370         ParentTable = DtPeekSubtable ();
371 
372         /* Sub-subtables - Memory Power State Structure(s) */
373 
374         while (*PFieldList && PowerStateCount)
375         {
376             Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst0A,
377                 &Subtable, TRUE);
378             if (ACPI_FAILURE (Status))
379             {
380                 return (Status);
381             }
382 
383             DtInsertSubtable (ParentTable, Subtable);
384             PowerStateCount--;
385         }
386 
387         /* Sub-subtables - Physical Component ID Structure(s) */
388 
389         while (*PFieldList && ComponentCount)
390         {
391             Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst0B,
392                 &Subtable, TRUE);
393             if (ACPI_FAILURE (Status))
394             {
395                 return (Status);
396             }
397 
398             DtInsertSubtable (ParentTable, Subtable);
399             ComponentCount--;
400         }
401 
402         SubtableCount--;
403         DtPopSubtable ();
404     }
405 
406     /* Subtable: Count of Memory Power State Characteristic structures */
407 
408     DtPopSubtable ();
409 
410     Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst1, &Subtable, TRUE);
411     if (ACPI_FAILURE (Status))
412     {
413         return (Status);
414     }
415 
416     ParentTable = DtPeekSubtable ();
417     DtInsertSubtable (ParentTable, Subtable);
418     DtPushSubtable (Subtable);
419 
420     MpstDataHeader = ACPI_CAST_PTR (ACPI_MPST_DATA_HDR, Subtable->Buffer);
421     SubtableCount = MpstDataHeader->CharacteristicsCount;
422 
423     ParentTable = DtPeekSubtable ();
424 
425     /* Subtable: Memory Power State Characteristics structure(s) */
426 
427     while (*PFieldList && SubtableCount)
428     {
429         Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst2,
430             &Subtable, TRUE);
431         if (ACPI_FAILURE (Status))
432         {
433             return (Status);
434         }
435 
436         DtInsertSubtable (ParentTable, Subtable);
437         SubtableCount--;
438     }
439 
440     DtPopSubtable ();
441     return (AE_OK);
442 }
443 
444 
445 /******************************************************************************
446  *
447  * FUNCTION:    DtCompileMsct
448  *
449  * PARAMETERS:  List                - Current field list pointer
450  *
451  * RETURN:      Status
452  *
453  * DESCRIPTION: Compile MSCT.
454  *
455  *****************************************************************************/
456 
457 ACPI_STATUS
458 DtCompileMsct (
459     void                    **List)
460 {
461     ACPI_STATUS             Status;
462 
463 
464     Status = DtCompileTwoSubtables (List,
465         AcpiDmTableInfoMsct, AcpiDmTableInfoMsct0);
466     return (Status);
467 }
468 
469 
470 /******************************************************************************
471  *
472  * FUNCTION:    DtCompileMtmr
473  *
474  * PARAMETERS:  List                - Current field list pointer
475  *
476  * RETURN:      Status
477  *
478  * DESCRIPTION: Compile MTMR.
479  *
480  *****************************************************************************/
481 
482 ACPI_STATUS
483 DtCompileMtmr (
484     void                    **List)
485 {
486     ACPI_STATUS             Status;
487 
488 
489     Status = DtCompileTwoSubtables (List,
490         AcpiDmTableInfoMtmr, AcpiDmTableInfoMtmr0);
491     return (Status);
492 }
493 
494 
495 /******************************************************************************
496  *
497  * FUNCTION:    DtCompileNfit
498  *
499  * PARAMETERS:  List                - Current field list pointer
500  *
501  * RETURN:      Status
502  *
503  * DESCRIPTION: Compile NFIT.
504  *
505  *****************************************************************************/
506 
507 ACPI_STATUS
508 DtCompileNfit (
509     void                    **List)
510 {
511     ACPI_STATUS             Status;
512     DT_SUBTABLE             *Subtable;
513     DT_SUBTABLE             *ParentTable;
514     DT_FIELD                **PFieldList = (DT_FIELD **) List;
515     DT_FIELD                *SubtableStart;
516     ACPI_NFIT_HEADER        *NfitHeader;
517     ACPI_DMTABLE_INFO       *InfoTable;
518     UINT32                  Count;
519     ACPI_NFIT_INTERLEAVE    *Interleave = NULL;
520     ACPI_NFIT_FLUSH_ADDRESS *Hint = NULL;
521 
522 
523     /* Main table */
524 
525     Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit,
526         &Subtable, TRUE);
527     if (ACPI_FAILURE (Status))
528     {
529         return (Status);
530     }
531 
532     ParentTable = DtPeekSubtable ();
533     DtInsertSubtable (ParentTable, Subtable);
534     DtPushSubtable (Subtable);
535 
536     /* Subtables */
537 
538     while (*PFieldList)
539     {
540         SubtableStart = *PFieldList;
541         Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfitHdr,
542             &Subtable, TRUE);
543         if (ACPI_FAILURE (Status))
544         {
545             return (Status);
546         }
547 
548         ParentTable = DtPeekSubtable ();
549         DtInsertSubtable (ParentTable, Subtable);
550         DtPushSubtable (Subtable);
551 
552         NfitHeader = ACPI_CAST_PTR (ACPI_NFIT_HEADER, Subtable->Buffer);
553 
554         switch (NfitHeader->Type)
555         {
556         case ACPI_NFIT_TYPE_SYSTEM_ADDRESS:
557 
558             InfoTable = AcpiDmTableInfoNfit0;
559             break;
560 
561         case ACPI_NFIT_TYPE_MEMORY_MAP:
562 
563             InfoTable = AcpiDmTableInfoNfit1;
564             break;
565 
566         case ACPI_NFIT_TYPE_INTERLEAVE:
567 
568             Interleave = ACPI_CAST_PTR (ACPI_NFIT_INTERLEAVE, Subtable->Buffer);
569             InfoTable = AcpiDmTableInfoNfit2;
570             break;
571 
572         case ACPI_NFIT_TYPE_SMBIOS:
573 
574             InfoTable = AcpiDmTableInfoNfit3;
575             break;
576 
577         case ACPI_NFIT_TYPE_CONTROL_REGION:
578 
579             InfoTable = AcpiDmTableInfoNfit4;
580             break;
581 
582         case ACPI_NFIT_TYPE_DATA_REGION:
583 
584             InfoTable = AcpiDmTableInfoNfit5;
585             break;
586 
587         case ACPI_NFIT_TYPE_FLUSH_ADDRESS:
588 
589             Hint = ACPI_CAST_PTR (ACPI_NFIT_FLUSH_ADDRESS, Subtable->Buffer);
590             InfoTable = AcpiDmTableInfoNfit6;
591             break;
592 
593         default:
594 
595             DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "NFIT");
596             return (AE_ERROR);
597         }
598 
599         Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
600         if (ACPI_FAILURE (Status))
601         {
602             return (Status);
603         }
604 
605         ParentTable = DtPeekSubtable ();
606         DtInsertSubtable (ParentTable, Subtable);
607         DtPopSubtable ();
608 
609         switch (NfitHeader->Type)
610         {
611         case ACPI_NFIT_TYPE_INTERLEAVE:
612 
613             Count = 0;
614             DtPushSubtable (Subtable);
615             while (*PFieldList)
616             {
617                 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit2a,
618                     &Subtable, FALSE);
619                 if (ACPI_FAILURE (Status))
620                 {
621                     return (Status);
622                 }
623 
624                 if (!Subtable)
625                 {
626                     DtPopSubtable ();
627                     break;
628                 }
629 
630                 ParentTable = DtPeekSubtable ();
631                 DtInsertSubtable (ParentTable, Subtable);
632                 Count++;
633             }
634 
635             Interleave->LineCount = Count;
636             DtPopSubtable ();
637             break;
638 
639         case ACPI_NFIT_TYPE_SMBIOS:
640 
641             if (*PFieldList)
642             {
643                 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit3a,
644                     &Subtable, TRUE);
645                 if (ACPI_FAILURE (Status))
646                 {
647                     return (Status);
648                 }
649 
650                 if (Subtable)
651                 {
652                     DtInsertSubtable (ParentTable, Subtable);
653                 }
654             }
655             break;
656 
657         case ACPI_NFIT_TYPE_FLUSH_ADDRESS:
658 
659             Count = 0;
660             DtPushSubtable (Subtable);
661             while (*PFieldList)
662             {
663                 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit6a,
664                     &Subtable, FALSE);
665                 if (ACPI_FAILURE (Status))
666                 {
667                     return (Status);
668                 }
669 
670                 if (!Subtable)
671                 {
672                     DtPopSubtable ();
673                     break;
674                 }
675 
676                 ParentTable = DtPeekSubtable ();
677                 DtInsertSubtable (ParentTable, Subtable);
678                 Count++;
679             }
680 
681             Hint->HintCount = (UINT16) Count;
682             DtPopSubtable ();
683             break;
684 
685         default:
686             break;
687         }
688     }
689 
690     return (AE_OK);
691 }
692 
693 
694 /******************************************************************************
695  *
696  * FUNCTION:    DtCompilePcct
697  *
698  * PARAMETERS:  List                - Current field list pointer
699  *
700  * RETURN:      Status
701  *
702  * DESCRIPTION: Compile PCCT.
703  *
704  *****************************************************************************/
705 
706 ACPI_STATUS
707 DtCompilePcct (
708     void                    **List)
709 {
710     ACPI_STATUS             Status;
711     DT_SUBTABLE             *Subtable;
712     DT_SUBTABLE             *ParentTable;
713     DT_FIELD                **PFieldList = (DT_FIELD **) List;
714     DT_FIELD                *SubtableStart;
715     ACPI_SUBTABLE_HEADER    *PcctHeader;
716     ACPI_DMTABLE_INFO       *InfoTable;
717 
718 
719     /* Main table */
720 
721     Status = DtCompileTable (PFieldList, AcpiDmTableInfoPcct,
722         &Subtable, TRUE);
723     if (ACPI_FAILURE (Status))
724     {
725         return (Status);
726     }
727 
728     ParentTable = DtPeekSubtable ();
729     DtInsertSubtable (ParentTable, Subtable);
730 
731     /* Subtables */
732 
733     while (*PFieldList)
734     {
735         SubtableStart = *PFieldList;
736         Status = DtCompileTable (PFieldList, AcpiDmTableInfoPcctHdr,
737             &Subtable, TRUE);
738         if (ACPI_FAILURE (Status))
739         {
740             return (Status);
741         }
742 
743         ParentTable = DtPeekSubtable ();
744         DtInsertSubtable (ParentTable, Subtable);
745         DtPushSubtable (Subtable);
746 
747         PcctHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer);
748 
749         switch (PcctHeader->Type)
750         {
751         case ACPI_PCCT_TYPE_GENERIC_SUBSPACE:
752 
753             InfoTable = AcpiDmTableInfoPcct0;
754             break;
755 
756         case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE:
757 
758             InfoTable = AcpiDmTableInfoPcct1;
759             break;
760 
761         default:
762 
763             DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "PCCT");
764             return (AE_ERROR);
765         }
766 
767         Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
768         if (ACPI_FAILURE (Status))
769         {
770             return (Status);
771         }
772 
773         ParentTable = DtPeekSubtable ();
774         DtInsertSubtable (ParentTable, Subtable);
775         DtPopSubtable ();
776     }
777 
778     return (AE_OK);
779 }
780 
781 
782 /******************************************************************************
783  *
784  * FUNCTION:    DtCompilePmtt
785  *
786  * PARAMETERS:  List                - Current field list pointer
787  *
788  * RETURN:      Status
789  *
790  * DESCRIPTION: Compile PMTT.
791  *
792  *****************************************************************************/
793 
794 ACPI_STATUS
795 DtCompilePmtt (
796     void                    **List)
797 {
798     ACPI_STATUS             Status;
799     DT_SUBTABLE             *Subtable;
800     DT_SUBTABLE             *ParentTable;
801     DT_FIELD                **PFieldList = (DT_FIELD **) List;
802     DT_FIELD                *SubtableStart;
803     ACPI_PMTT_HEADER        *PmttHeader;
804     ACPI_PMTT_CONTROLLER    *PmttController;
805     UINT16                  DomainCount;
806     UINT8                   PrevType = ACPI_PMTT_TYPE_SOCKET;
807 
808 
809     /* Main table */
810 
811     Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt, &Subtable, TRUE);
812     if (ACPI_FAILURE (Status))
813     {
814         return (Status);
815     }
816 
817     ParentTable = DtPeekSubtable ();
818     DtInsertSubtable (ParentTable, Subtable);
819     DtPushSubtable (Subtable);
820 
821     while (*PFieldList)
822     {
823         SubtableStart = *PFieldList;
824         Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmttHdr,
825             &Subtable, TRUE);
826         if (ACPI_FAILURE (Status))
827         {
828             return (Status);
829         }
830 
831         PmttHeader = ACPI_CAST_PTR (ACPI_PMTT_HEADER, Subtable->Buffer);
832         while (PrevType >= PmttHeader->Type)
833         {
834             DtPopSubtable ();
835 
836             if (PrevType == ACPI_PMTT_TYPE_SOCKET)
837             {
838                 break;
839             }
840 
841             PrevType--;
842         }
843 
844         PrevType = PmttHeader->Type;
845 
846         ParentTable = DtPeekSubtable ();
847         DtInsertSubtable (ParentTable, Subtable);
848         DtPushSubtable (Subtable);
849 
850         switch (PmttHeader->Type)
851         {
852         case ACPI_PMTT_TYPE_SOCKET:
853 
854             /* Subtable: Socket Structure */
855 
856             Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt0,
857                 &Subtable, TRUE);
858             if (ACPI_FAILURE (Status))
859             {
860                 return (Status);
861             }
862 
863             ParentTable = DtPeekSubtable ();
864             DtInsertSubtable (ParentTable, Subtable);
865             break;
866 
867         case ACPI_PMTT_TYPE_CONTROLLER:
868 
869             /* Subtable: Memory Controller Structure */
870 
871             Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt1,
872                 &Subtable, TRUE);
873             if (ACPI_FAILURE (Status))
874             {
875                 return (Status);
876             }
877 
878             ParentTable = DtPeekSubtable ();
879             DtInsertSubtable (ParentTable, Subtable);
880 
881             PmttController = ACPI_CAST_PTR (ACPI_PMTT_CONTROLLER,
882                 (Subtable->Buffer - sizeof (ACPI_PMTT_HEADER)));
883             DomainCount = PmttController->DomainCount;
884 
885             while (DomainCount)
886             {
887                 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt1a,
888                     &Subtable, TRUE);
889                 if (ACPI_FAILURE (Status))
890                 {
891                     return (Status);
892                 }
893 
894                 DtInsertSubtable (ParentTable, Subtable);
895                 DomainCount--;
896             }
897             break;
898 
899         case ACPI_PMTT_TYPE_DIMM:
900 
901             /* Subtable: Physical Component Structure */
902 
903             Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt2,
904                 &Subtable, TRUE);
905             if (ACPI_FAILURE (Status))
906             {
907                 return (Status);
908             }
909 
910             ParentTable = DtPeekSubtable ();
911             DtInsertSubtable (ParentTable, Subtable);
912             break;
913 
914         default:
915 
916             DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "PMTT");
917             return (AE_ERROR);
918         }
919     }
920 
921     return (Status);
922 }
923 
924 
925 /******************************************************************************
926  *
927  * FUNCTION:    DtCompileRsdt
928  *
929  * PARAMETERS:  List                - Current field list pointer
930  *
931  * RETURN:      Status
932  *
933  * DESCRIPTION: Compile RSDT.
934  *
935  *****************************************************************************/
936 
937 ACPI_STATUS
938 DtCompileRsdt (
939     void                    **List)
940 {
941     DT_SUBTABLE             *Subtable;
942     DT_SUBTABLE             *ParentTable;
943     DT_FIELD                *FieldList = *(DT_FIELD **) List;
944     UINT32                  Address;
945 
946 
947     ParentTable = DtPeekSubtable ();
948 
949     while (FieldList)
950     {
951         DtCompileInteger ((UINT8 *) &Address, FieldList, 4, DT_NON_ZERO);
952 
953         DtCreateSubtable ((UINT8 *) &Address, 4, &Subtable);
954         DtInsertSubtable (ParentTable, Subtable);
955         FieldList = FieldList->Next;
956     }
957 
958     return (AE_OK);
959 }
960 
961 
962 /******************************************************************************
963  *
964  * FUNCTION:    DtCompileS3pt
965  *
966  * PARAMETERS:  PFieldList          - Current field list pointer
967  *
968  * RETURN:      Status
969  *
970  * DESCRIPTION: Compile S3PT (Pointed to by FPDT)
971  *
972  *****************************************************************************/
973 
974 ACPI_STATUS
975 DtCompileS3pt (
976     DT_FIELD                **PFieldList)
977 {
978     ACPI_STATUS             Status;
979     ACPI_S3PT_HEADER        *S3ptHeader;
980     DT_SUBTABLE             *Subtable;
981     DT_SUBTABLE             *ParentTable;
982     ACPI_DMTABLE_INFO       *InfoTable;
983     DT_FIELD                *SubtableStart;
984 
985 
986     Status = DtCompileTable (PFieldList, AcpiDmTableInfoS3pt,
987         &Gbl_RootTable, TRUE);
988     if (ACPI_FAILURE (Status))
989     {
990         return (Status);
991     }
992 
993     DtPushSubtable (Gbl_RootTable);
994 
995     while (*PFieldList)
996     {
997         SubtableStart = *PFieldList;
998         Status = DtCompileTable (PFieldList, AcpiDmTableInfoS3ptHdr,
999             &Subtable, TRUE);
1000         if (ACPI_FAILURE (Status))
1001         {
1002             return (Status);
1003         }
1004 
1005         ParentTable = DtPeekSubtable ();
1006         DtInsertSubtable (ParentTable, Subtable);
1007         DtPushSubtable (Subtable);
1008 
1009         S3ptHeader = ACPI_CAST_PTR (ACPI_S3PT_HEADER, Subtable->Buffer);
1010 
1011         switch (S3ptHeader->Type)
1012         {
1013         case ACPI_S3PT_TYPE_RESUME:
1014 
1015             InfoTable = AcpiDmTableInfoS3pt0;
1016             break;
1017 
1018         case ACPI_S3PT_TYPE_SUSPEND:
1019 
1020             InfoTable = AcpiDmTableInfoS3pt1;
1021             break;
1022 
1023         default:
1024 
1025             DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "S3PT");
1026             return (AE_ERROR);
1027         }
1028 
1029         Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
1030         if (ACPI_FAILURE (Status))
1031         {
1032             return (Status);
1033         }
1034 
1035         ParentTable = DtPeekSubtable ();
1036         DtInsertSubtable (ParentTable, Subtable);
1037         DtPopSubtable ();
1038     }
1039 
1040     return (AE_OK);
1041 }
1042 
1043 
1044 /******************************************************************************
1045  *
1046  * FUNCTION:    DtCompileSlic
1047  *
1048  * PARAMETERS:  List                - Current field list pointer
1049  *
1050  * RETURN:      Status
1051  *
1052  * DESCRIPTION: Compile SLIC.
1053  *
1054  *****************************************************************************/
1055 
1056 ACPI_STATUS
1057 DtCompileSlic (
1058     void                    **List)
1059 {
1060     ACPI_STATUS             Status;
1061     DT_SUBTABLE             *Subtable;
1062     DT_SUBTABLE             *ParentTable;
1063     DT_FIELD                **PFieldList = (DT_FIELD **) List;
1064 
1065 
1066     while (*PFieldList)
1067     {
1068         Status = DtCompileTable (PFieldList, AcpiDmTableInfoSlic,
1069             &Subtable, TRUE);
1070         if (ACPI_FAILURE (Status))
1071         {
1072             return (Status);
1073         }
1074 
1075         ParentTable = DtPeekSubtable ();
1076         DtInsertSubtable (ParentTable, Subtable);
1077         DtPushSubtable (Subtable);
1078         DtPopSubtable ();
1079     }
1080 
1081     return (AE_OK);
1082 }
1083 
1084 
1085 /******************************************************************************
1086  *
1087  * FUNCTION:    DtCompileSlit
1088  *
1089  * PARAMETERS:  List                - Current field list pointer
1090  *
1091  * RETURN:      Status
1092  *
1093  * DESCRIPTION: Compile SLIT.
1094  *
1095  *****************************************************************************/
1096 
1097 ACPI_STATUS
1098 DtCompileSlit (
1099     void                    **List)
1100 {
1101     ACPI_STATUS             Status;
1102     DT_SUBTABLE             *Subtable;
1103     DT_SUBTABLE             *ParentTable;
1104     DT_FIELD                **PFieldList = (DT_FIELD **) List;
1105     DT_FIELD                *FieldList;
1106     UINT32                  Localities;
1107     UINT8                   *LocalityBuffer;
1108 
1109 
1110     Status = DtCompileTable (PFieldList, AcpiDmTableInfoSlit,
1111         &Subtable, TRUE);
1112     if (ACPI_FAILURE (Status))
1113     {
1114         return (Status);
1115     }
1116 
1117     ParentTable = DtPeekSubtable ();
1118     DtInsertSubtable (ParentTable, Subtable);
1119 
1120     Localities = *ACPI_CAST_PTR (UINT32, Subtable->Buffer);
1121     LocalityBuffer = UtLocalCalloc (Localities);
1122 
1123     /* Compile each locality buffer */
1124 
1125     FieldList = *PFieldList;
1126     while (FieldList)
1127     {
1128         DtCompileBuffer (LocalityBuffer,
1129             FieldList->Value, FieldList, Localities);
1130 
1131         DtCreateSubtable (LocalityBuffer, Localities, &Subtable);
1132         DtInsertSubtable (ParentTable, Subtable);
1133         FieldList = FieldList->Next;
1134     }
1135 
1136     ACPI_FREE (LocalityBuffer);
1137     return (AE_OK);
1138 }
1139 
1140 
1141 /******************************************************************************
1142  *
1143  * FUNCTION:    DtCompileSrat
1144  *
1145  * PARAMETERS:  List                - Current field list pointer
1146  *
1147  * RETURN:      Status
1148  *
1149  * DESCRIPTION: Compile SRAT.
1150  *
1151  *****************************************************************************/
1152 
1153 ACPI_STATUS
1154 DtCompileSrat (
1155     void                    **List)
1156 {
1157     ACPI_STATUS             Status;
1158     DT_SUBTABLE             *Subtable;
1159     DT_SUBTABLE             *ParentTable;
1160     DT_FIELD                **PFieldList = (DT_FIELD **) List;
1161     DT_FIELD                *SubtableStart;
1162     ACPI_SUBTABLE_HEADER    *SratHeader;
1163     ACPI_DMTABLE_INFO       *InfoTable;
1164 
1165 
1166     Status = DtCompileTable (PFieldList, AcpiDmTableInfoSrat,
1167         &Subtable, TRUE);
1168     if (ACPI_FAILURE (Status))
1169     {
1170         return (Status);
1171     }
1172 
1173     ParentTable = DtPeekSubtable ();
1174     DtInsertSubtable (ParentTable, Subtable);
1175 
1176     while (*PFieldList)
1177     {
1178         SubtableStart = *PFieldList;
1179         Status = DtCompileTable (PFieldList, AcpiDmTableInfoSratHdr,
1180             &Subtable, TRUE);
1181         if (ACPI_FAILURE (Status))
1182         {
1183             return (Status);
1184         }
1185 
1186         ParentTable = DtPeekSubtable ();
1187         DtInsertSubtable (ParentTable, Subtable);
1188         DtPushSubtable (Subtable);
1189 
1190         SratHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer);
1191 
1192         switch (SratHeader->Type)
1193         {
1194         case ACPI_SRAT_TYPE_CPU_AFFINITY:
1195 
1196             InfoTable = AcpiDmTableInfoSrat0;
1197             break;
1198 
1199         case ACPI_SRAT_TYPE_MEMORY_AFFINITY:
1200 
1201             InfoTable = AcpiDmTableInfoSrat1;
1202             break;
1203 
1204         case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY:
1205 
1206             InfoTable = AcpiDmTableInfoSrat2;
1207             break;
1208 
1209         case ACPI_SRAT_TYPE_GICC_AFFINITY:
1210 
1211             InfoTable = AcpiDmTableInfoSrat3;
1212             break;
1213 
1214         default:
1215 
1216             DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "SRAT");
1217             return (AE_ERROR);
1218         }
1219 
1220         Status = DtCompileTable (PFieldList, InfoTable, &Subtable, TRUE);
1221         if (ACPI_FAILURE (Status))
1222         {
1223             return (Status);
1224         }
1225 
1226         ParentTable = DtPeekSubtable ();
1227         DtInsertSubtable (ParentTable, Subtable);
1228         DtPopSubtable ();
1229     }
1230 
1231     return (AE_OK);
1232 }
1233 
1234 
1235 /******************************************************************************
1236  *
1237  * FUNCTION:    DtCompileStao
1238  *
1239  * PARAMETERS:  PFieldList          - Current field list pointer
1240  *
1241  * RETURN:      Status
1242  *
1243  * DESCRIPTION: Compile STAO.
1244  *
1245  *****************************************************************************/
1246 
1247 ACPI_STATUS
1248 DtCompileStao (
1249     void                    **List)
1250 {
1251     DT_FIELD                **PFieldList = (DT_FIELD **) List;
1252     DT_SUBTABLE             *Subtable;
1253     DT_SUBTABLE             *ParentTable;
1254     ACPI_STATUS             Status;
1255 
1256 
1257     /* Compile the main table */
1258 
1259     Status = DtCompileTable (PFieldList, AcpiDmTableInfoStao,
1260         &Subtable, TRUE);
1261     if (ACPI_FAILURE (Status))
1262     {
1263         return (Status);
1264     }
1265 
1266     ParentTable = DtPeekSubtable ();
1267     DtInsertSubtable (ParentTable, Subtable);
1268 
1269     /* Compile each ASCII namestring as a subtable */
1270 
1271     while (*PFieldList)
1272     {
1273         Status = DtCompileTable (PFieldList, AcpiDmTableInfoStaoStr,
1274             &Subtable, TRUE);
1275         if (ACPI_FAILURE (Status))
1276         {
1277             return (Status);
1278         }
1279 
1280         ParentTable = DtPeekSubtable ();
1281         DtInsertSubtable (ParentTable, Subtable);
1282     }
1283 
1284     return (AE_OK);
1285 }
1286 
1287 
1288 /******************************************************************************
1289  *
1290  * FUNCTION:    DtCompileTcpa
1291  *
1292  * PARAMETERS:  PFieldList          - Current field list pointer
1293  *
1294  * RETURN:      Status
1295  *
1296  * DESCRIPTION: Compile TCPA.
1297  *
1298  *****************************************************************************/
1299 
1300 ACPI_STATUS
1301 DtCompileTcpa (
1302     void                    **List)
1303 {
1304     DT_FIELD                **PFieldList = (DT_FIELD **) List;
1305     DT_SUBTABLE             *Subtable;
1306     ACPI_TABLE_TCPA_HDR     *TcpaHeader;
1307     DT_SUBTABLE             *ParentTable;
1308     ACPI_STATUS             Status;
1309 
1310 
1311     /* Compile the main table */
1312 
1313     Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaHdr,
1314         &Subtable, TRUE);
1315     if (ACPI_FAILURE (Status))
1316     {
1317         return (Status);
1318     }
1319 
1320     ParentTable = DtPeekSubtable ();
1321     DtInsertSubtable (ParentTable, Subtable);
1322 
1323     /*
1324      * Examine the PlatformClass field to determine the table type.
1325      * Either a client or server table. Only one.
1326      */
1327     TcpaHeader = ACPI_CAST_PTR (ACPI_TABLE_TCPA_HDR, ParentTable->Buffer);
1328 
1329     switch (TcpaHeader->PlatformClass)
1330     {
1331     case ACPI_TCPA_CLIENT_TABLE:
1332 
1333         Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaClient,
1334             &Subtable, TRUE);
1335         break;
1336 
1337     case ACPI_TCPA_SERVER_TABLE:
1338 
1339         Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaServer,
1340             &Subtable, TRUE);
1341         break;
1342 
1343     default:
1344 
1345         AcpiOsPrintf ("\n**** Unknown TCPA Platform Class 0x%X\n",
1346             TcpaHeader->PlatformClass);
1347         Status = AE_ERROR;
1348         break;
1349     }
1350 
1351     ParentTable = DtPeekSubtable ();
1352     DtInsertSubtable (ParentTable, Subtable);
1353     return (Status);
1354 }
1355 
1356 
1357 /******************************************************************************
1358  *
1359  * FUNCTION:    DtGetGenericTableInfo
1360  *
1361  * PARAMETERS:  Name                - Generic type name
1362  *
1363  * RETURN:      Info entry
1364  *
1365  * DESCRIPTION: Obtain table info for a generic name entry
1366  *
1367  *****************************************************************************/
1368 
1369 ACPI_DMTABLE_INFO *
1370 DtGetGenericTableInfo (
1371     char                    *Name)
1372 {
1373     ACPI_DMTABLE_INFO       *Info;
1374     UINT32                  i;
1375 
1376 
1377     if (!Name)
1378     {
1379         return (NULL);
1380     }
1381 
1382     /* Search info table for name match */
1383 
1384     for (i = 0; ; i++)
1385     {
1386         Info = AcpiDmTableInfoGeneric[i];
1387         if (Info->Opcode == ACPI_DMT_EXIT)
1388         {
1389             Info = NULL;
1390             break;
1391         }
1392 
1393         /* Use caseless compare for generic keywords */
1394 
1395         if (!AcpiUtStricmp (Name, Info->Name))
1396         {
1397             break;
1398         }
1399     }
1400 
1401     return (Info);
1402 }
1403 
1404 
1405 /******************************************************************************
1406  *
1407  * FUNCTION:    DtCompileUefi
1408  *
1409  * PARAMETERS:  List                - Current field list pointer
1410  *
1411  * RETURN:      Status
1412  *
1413  * DESCRIPTION: Compile UEFI.
1414  *
1415  *****************************************************************************/
1416 
1417 ACPI_STATUS
1418 DtCompileUefi (
1419     void                    **List)
1420 {
1421     ACPI_STATUS             Status;
1422     DT_SUBTABLE             *Subtable;
1423     DT_SUBTABLE             *ParentTable;
1424     DT_FIELD                **PFieldList = (DT_FIELD **) List;
1425     UINT16                  *DataOffset;
1426 
1427 
1428     /* Compile the predefined portion of the UEFI table */
1429 
1430     Status = DtCompileTable (PFieldList, AcpiDmTableInfoUefi,
1431         &Subtable, TRUE);
1432     if (ACPI_FAILURE (Status))
1433     {
1434         return (Status);
1435     }
1436 
1437     DataOffset = (UINT16 *) (Subtable->Buffer + 16);
1438     *DataOffset = sizeof (ACPI_TABLE_UEFI);
1439 
1440     ParentTable = DtPeekSubtable ();
1441     DtInsertSubtable (ParentTable, Subtable);
1442 
1443     /*
1444      * Compile the "generic" portion of the UEFI table. This
1445      * part of the table is not predefined and any of the generic
1446      * operators may be used.
1447      */
1448     DtCompileGeneric ((void **) PFieldList, NULL, NULL);
1449     return (AE_OK);
1450 }
1451 
1452 
1453 /******************************************************************************
1454  *
1455  * FUNCTION:    DtCompileVrtc
1456  *
1457  * PARAMETERS:  List                - Current field list pointer
1458  *
1459  * RETURN:      Status
1460  *
1461  * DESCRIPTION: Compile VRTC.
1462  *
1463  *****************************************************************************/
1464 
1465 ACPI_STATUS
1466 DtCompileVrtc (
1467     void                    **List)
1468 {
1469     ACPI_STATUS             Status;
1470 
1471 
1472     Status = DtCompileTwoSubtables (List,
1473         AcpiDmTableInfoVrtc, AcpiDmTableInfoVrtc0);
1474     return (Status);
1475 }
1476 
1477 
1478 /******************************************************************************
1479  *
1480  * FUNCTION:    DtCompileWdat
1481  *
1482  * PARAMETERS:  List                - Current field list pointer
1483  *
1484  * RETURN:      Status
1485  *
1486  * DESCRIPTION: Compile WDAT.
1487  *
1488  *****************************************************************************/
1489 
1490 ACPI_STATUS
1491 DtCompileWdat (
1492     void                    **List)
1493 {
1494     ACPI_STATUS             Status;
1495 
1496 
1497     Status = DtCompileTwoSubtables (List,
1498         AcpiDmTableInfoWdat, AcpiDmTableInfoWdat0);
1499     return (Status);
1500 }
1501 
1502 
1503 /******************************************************************************
1504  *
1505  * FUNCTION:    DtCompileWpbt
1506  *
1507  * PARAMETERS:  List                - Current field list pointer
1508  *
1509  * RETURN:      Status
1510  *
1511  * DESCRIPTION: Compile WPBT.
1512  *
1513  *****************************************************************************/
1514 
1515 ACPI_STATUS
1516 DtCompileWpbt (
1517     void                    **List)
1518 {
1519     DT_FIELD                **PFieldList = (DT_FIELD **) List;
1520     DT_SUBTABLE             *Subtable;
1521     DT_SUBTABLE             *ParentTable;
1522     ACPI_TABLE_WPBT         *Table;
1523     ACPI_STATUS             Status;
1524     UINT16                  Length;
1525 
1526 
1527     /* Compile the main table */
1528 
1529     Status = DtCompileTable (PFieldList, AcpiDmTableInfoWpbt,
1530         &Subtable, TRUE);
1531     if (ACPI_FAILURE (Status))
1532     {
1533         return (Status);
1534     }
1535 
1536     ParentTable = DtPeekSubtable ();
1537     DtInsertSubtable (ParentTable, Subtable);
1538 
1539     /* Compile the argument list subtable */
1540 
1541     Status = DtCompileTable (PFieldList, AcpiDmTableInfoWpbt0,
1542         &Subtable, TRUE);
1543     if (ACPI_FAILURE (Status))
1544     {
1545         return (Status);
1546     }
1547 
1548     /* Extract the length of the Arguments buffer, insert into main table */
1549 
1550     Length = (UINT16) Subtable->TotalLength;
1551     Table = ACPI_CAST_PTR (ACPI_TABLE_WPBT, ParentTable->Buffer);
1552     Table->ArgumentsLength = Length;
1553 
1554     ParentTable = DtPeekSubtable ();
1555     DtInsertSubtable (ParentTable, Subtable);
1556     return (AE_OK);
1557 }
1558 
1559 
1560 /******************************************************************************
1561  *
1562  * FUNCTION:    DtCompileXsdt
1563  *
1564  * PARAMETERS:  List                - Current field list pointer
1565  *
1566  * RETURN:      Status
1567  *
1568  * DESCRIPTION: Compile XSDT.
1569  *
1570  *****************************************************************************/
1571 
1572 ACPI_STATUS
1573 DtCompileXsdt (
1574     void                    **List)
1575 {
1576     DT_SUBTABLE             *Subtable;
1577     DT_SUBTABLE             *ParentTable;
1578     DT_FIELD                *FieldList = *(DT_FIELD **) List;
1579     UINT64                  Address;
1580 
1581 
1582     ParentTable = DtPeekSubtable ();
1583 
1584     while (FieldList)
1585     {
1586         DtCompileInteger ((UINT8 *) &Address, FieldList, 8, DT_NON_ZERO);
1587 
1588         DtCreateSubtable ((UINT8 *) &Address, 8, &Subtable);
1589         DtInsertSubtable (ParentTable, Subtable);
1590         FieldList = FieldList->Next;
1591     }
1592 
1593     return (AE_OK);
1594 }
1595 
1596 
1597 /******************************************************************************
1598  *
1599  * FUNCTION:    DtCompileGeneric
1600  *
1601  * PARAMETERS:  List                - Current field list pointer
1602  *              Name                - Field name to end generic compiling
1603  *              Length              - Compiled table length to return
1604  *
1605  * RETURN:      Status
1606  *
1607  * DESCRIPTION: Compile generic unknown table.
1608  *
1609  *****************************************************************************/
1610 
1611 ACPI_STATUS
1612 DtCompileGeneric (
1613     void                    **List,
1614     char                    *Name,
1615     UINT32                  *Length)
1616 {
1617     ACPI_STATUS             Status;
1618     DT_SUBTABLE             *Subtable;
1619     DT_SUBTABLE             *ParentTable;
1620     DT_FIELD                **PFieldList = (DT_FIELD **) List;
1621     ACPI_DMTABLE_INFO       *Info;
1622 
1623 
1624     ParentTable = DtPeekSubtable ();
1625 
1626     /*
1627      * Compile the "generic" portion of the table. This
1628      * part of the table is not predefined and any of the generic
1629      * operators may be used.
1630      */
1631 
1632     /* Find any and all labels in the entire generic portion */
1633 
1634     DtDetectAllLabels (*PFieldList);
1635 
1636     /* Now we can actually compile the parse tree */
1637 
1638     if (Length && *Length)
1639     {
1640         *Length = 0;
1641     }
1642     while (*PFieldList)
1643     {
1644         if (Name && !strcmp ((*PFieldList)->Name, Name))
1645         {
1646             break;
1647         }
1648 
1649         Info = DtGetGenericTableInfo ((*PFieldList)->Name);
1650         if (!Info)
1651         {
1652             sprintf (MsgBuffer, "Generic data type \"%s\" not found",
1653                 (*PFieldList)->Name);
1654             DtNameError (ASL_ERROR, ASL_MSG_INVALID_FIELD_NAME,
1655                 (*PFieldList), MsgBuffer);
1656 
1657             *PFieldList = (*PFieldList)->Next;
1658             continue;
1659         }
1660 
1661         Status = DtCompileTable (PFieldList, Info,
1662             &Subtable, TRUE);
1663         if (ACPI_SUCCESS (Status))
1664         {
1665             DtInsertSubtable (ParentTable, Subtable);
1666             if (Length)
1667             {
1668                 *Length += Subtable->Length;
1669             }
1670         }
1671         else
1672         {
1673             *PFieldList = (*PFieldList)->Next;
1674 
1675             if (Status == AE_NOT_FOUND)
1676             {
1677                 sprintf (MsgBuffer, "Generic data type \"%s\" not found",
1678                     (*PFieldList)->Name);
1679                 DtNameError (ASL_ERROR, ASL_MSG_INVALID_FIELD_NAME,
1680                     (*PFieldList), MsgBuffer);
1681             }
1682         }
1683     }
1684 
1685     return (AE_OK);
1686 }
1687