1 /******************************************************************************
2 *
3 * Module Name: dttable2.c - handling for specific ACPI tables
4 *
5 *****************************************************************************/
6
7 /******************************************************************************
8 *
9 * 1. Copyright Notice
10 *
11 * Some or all of this work - Copyright (c) 1999 - 2018, Intel Corp.
12 * All rights reserved.
13 *
14 * 2. License
15 *
16 * 2.1. This is your license from Intel Corp. under its intellectual property
17 * rights. You may have additional license terms from the party that provided
18 * you this software, covering your right to use that party's intellectual
19 * property rights.
20 *
21 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
22 * copy of the source code appearing in this file ("Covered Code") an
23 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
24 * base code distributed originally by Intel ("Original Intel Code") to copy,
25 * make derivatives, distribute, use and display any portion of the Covered
26 * Code in any form, with the right to sublicense such rights; and
27 *
28 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
29 * license (with the right to sublicense), under only those claims of Intel
30 * patents that are infringed by the Original Intel Code, to make, use, sell,
31 * offer to sell, and import the Covered Code and derivative works thereof
32 * solely to the minimum extent necessary to exercise the above copyright
33 * license, and in no event shall the patent license extend to any additions
34 * to or modifications of the Original Intel Code. No other license or right
35 * is granted directly or by implication, estoppel or otherwise;
36 *
37 * The above copyright and patent license is granted only if the following
38 * conditions are met:
39 *
40 * 3. Conditions
41 *
42 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
43 * Redistribution of source code of any substantial portion of the Covered
44 * Code or modification with rights to further distribute source must include
45 * the above Copyright Notice, the above License, this list of Conditions,
46 * and the following Disclaimer and Export Compliance provision. In addition,
47 * Licensee must cause all Covered Code to which Licensee contributes to
48 * contain a file documenting the changes Licensee made to create that Covered
49 * Code and the date of any change. Licensee must include in that file the
50 * documentation of any changes made by any predecessor Licensee. Licensee
51 * must include a prominent statement that the modification is derived,
52 * directly or indirectly, from Original Intel Code.
53 *
54 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
55 * Redistribution of source code of any substantial portion of the Covered
56 * Code or modification without rights to further distribute source must
57 * include the following Disclaimer and Export Compliance provision in the
58 * documentation and/or other materials provided with distribution. In
59 * addition, Licensee may not authorize further sublicense of source of any
60 * portion of the Covered Code, and must include terms to the effect that the
61 * license from Licensee to its licensee is limited to the intellectual
62 * property embodied in the software Licensee provides to its licensee, and
63 * not to intellectual property embodied in modifications its licensee may
64 * make.
65 *
66 * 3.3. Redistribution of Executable. Redistribution in executable form of any
67 * substantial portion of the Covered Code or modification must reproduce the
68 * above Copyright Notice, and the following Disclaimer and Export Compliance
69 * provision in the documentation and/or other materials provided with the
70 * distribution.
71 *
72 * 3.4. Intel retains all right, title, and interest in and to the Original
73 * Intel Code.
74 *
75 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
76 * Intel shall be used in advertising or otherwise to promote the sale, use or
77 * other dealings in products derived from or relating to the Covered Code
78 * without prior written authorization from Intel.
79 *
80 * 4. Disclaimer and Export Compliance
81 *
82 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
83 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
84 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
85 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
86 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
87 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
88 * PARTICULAR PURPOSE.
89 *
90 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
91 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
92 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
93 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
94 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
95 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
96 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
97 * LIMITED REMEDY.
98 *
99 * 4.3. Licensee shall not export, either directly or indirectly, any of this
100 * software or system incorporating such software without first obtaining any
101 * required license or other approval from the U. S. Department of Commerce or
102 * any other agency or department of the United States Government. In the
103 * event Licensee exports any such software from the United States or
104 * re-exports any such software from a foreign destination, Licensee shall
105 * ensure that the distribution and export/re-export of the software is in
106 * compliance with all laws, regulations, orders, or other restrictions of the
107 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
108 * any of its subsidiaries will export/re-export any technical data, process,
109 * software, or service, directly or indirectly, to any country for which the
110 * United States government or any agency thereof requires an export license,
111 * other governmental approval, or letter of assurance, without first obtaining
112 * such license, approval or letter.
113 *
114 *****************************************************************************
115 *
116 * Alternatively, you may choose to be licensed under the terms of the
117 * following license:
118 *
119 * Redistribution and use in source and binary forms, with or without
120 * modification, are permitted provided that the following conditions
121 * are met:
122 * 1. Redistributions of source code must retain the above copyright
123 * notice, this list of conditions, and the following disclaimer,
124 * without modification.
125 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
126 * substantially similar to the "NO WARRANTY" disclaimer below
127 * ("Disclaimer") and any redistribution must be conditioned upon
128 * including a substantially similar Disclaimer requirement for further
129 * binary redistribution.
130 * 3. Neither the names of the above-listed copyright holders nor the names
131 * of any contributors may be used to endorse or promote products derived
132 * from this software without specific prior written permission.
133 *
134 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
135 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
136 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
137 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
138 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
139 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
140 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
141 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
142 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
143 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
144 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
145 *
146 * Alternatively, you may choose to be licensed under the terms of the
147 * GNU General Public License ("GPL") version 2 as published by the Free
148 * Software Foundation.
149 *
150 *****************************************************************************/
151
152 /* Compile all complex data tables, signatures starting with L-Z */
153
154 #include "aslcompiler.h"
155
156 #define _COMPONENT DT_COMPILER
157 ACPI_MODULE_NAME ("dttable2")
158
159
160 /******************************************************************************
161 *
162 * FUNCTION: DtCompileLpit
163 *
164 * PARAMETERS: List - Current field list pointer
165 *
166 * RETURN: Status
167 *
168 * DESCRIPTION: Compile LPIT.
169 *
170 *****************************************************************************/
171
172 ACPI_STATUS
DtCompileLpit(void ** List)173 DtCompileLpit (
174 void **List)
175 {
176 ACPI_STATUS Status;
177 DT_SUBTABLE *Subtable;
178 DT_SUBTABLE *ParentTable;
179 DT_FIELD **PFieldList = (DT_FIELD **) List;
180 DT_FIELD *SubtableStart;
181 ACPI_DMTABLE_INFO *InfoTable;
182 ACPI_LPIT_HEADER *LpitHeader;
183
184
185 /* Note: Main table consists only of the standard ACPI table header */
186
187 while (*PFieldList)
188 {
189 SubtableStart = *PFieldList;
190
191 /* LPIT Subtable header */
192
193 Status = DtCompileTable (PFieldList, AcpiDmTableInfoLpitHdr,
194 &Subtable);
195 if (ACPI_FAILURE (Status))
196 {
197 return (Status);
198 }
199
200 ParentTable = DtPeekSubtable ();
201 DtInsertSubtable (ParentTable, Subtable);
202 DtPushSubtable (Subtable);
203
204 LpitHeader = ACPI_CAST_PTR (ACPI_LPIT_HEADER, Subtable->Buffer);
205
206 switch (LpitHeader->Type)
207 {
208 case ACPI_LPIT_TYPE_NATIVE_CSTATE:
209
210 InfoTable = AcpiDmTableInfoLpit0;
211 break;
212
213 default:
214
215 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "LPIT");
216 return (AE_ERROR);
217 }
218
219 /* LPIT Subtable */
220
221 Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
222 if (ACPI_FAILURE (Status))
223 {
224 return (Status);
225 }
226
227 ParentTable = DtPeekSubtable ();
228 DtInsertSubtable (ParentTable, Subtable);
229 DtPopSubtable ();
230 }
231
232 return (AE_OK);
233 }
234
235
236 /******************************************************************************
237 *
238 * FUNCTION: DtCompileMadt
239 *
240 * PARAMETERS: List - Current field list pointer
241 *
242 * RETURN: Status
243 *
244 * DESCRIPTION: Compile MADT.
245 *
246 *****************************************************************************/
247
248 ACPI_STATUS
DtCompileMadt(void ** List)249 DtCompileMadt (
250 void **List)
251 {
252 ACPI_STATUS Status;
253 DT_SUBTABLE *Subtable;
254 DT_SUBTABLE *ParentTable;
255 DT_FIELD **PFieldList = (DT_FIELD **) List;
256 DT_FIELD *SubtableStart;
257 ACPI_SUBTABLE_HEADER *MadtHeader;
258 ACPI_DMTABLE_INFO *InfoTable;
259
260
261 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMadt,
262 &Subtable);
263 if (ACPI_FAILURE (Status))
264 {
265 return (Status);
266 }
267
268 ParentTable = DtPeekSubtable ();
269 DtInsertSubtable (ParentTable, Subtable);
270
271 while (*PFieldList)
272 {
273 SubtableStart = *PFieldList;
274 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMadtHdr,
275 &Subtable);
276 if (ACPI_FAILURE (Status))
277 {
278 return (Status);
279 }
280
281 ParentTable = DtPeekSubtable ();
282 DtInsertSubtable (ParentTable, Subtable);
283 DtPushSubtable (Subtable);
284
285 MadtHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer);
286
287 switch (MadtHeader->Type)
288 {
289 case ACPI_MADT_TYPE_LOCAL_APIC:
290
291 InfoTable = AcpiDmTableInfoMadt0;
292 break;
293
294 case ACPI_MADT_TYPE_IO_APIC:
295
296 InfoTable = AcpiDmTableInfoMadt1;
297 break;
298
299 case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE:
300
301 InfoTable = AcpiDmTableInfoMadt2;
302 break;
303
304 case ACPI_MADT_TYPE_NMI_SOURCE:
305
306 InfoTable = AcpiDmTableInfoMadt3;
307 break;
308
309 case ACPI_MADT_TYPE_LOCAL_APIC_NMI:
310
311 InfoTable = AcpiDmTableInfoMadt4;
312 break;
313
314 case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE:
315
316 InfoTable = AcpiDmTableInfoMadt5;
317 break;
318
319 case ACPI_MADT_TYPE_IO_SAPIC:
320
321 InfoTable = AcpiDmTableInfoMadt6;
322 break;
323
324 case ACPI_MADT_TYPE_LOCAL_SAPIC:
325
326 InfoTable = AcpiDmTableInfoMadt7;
327 break;
328
329 case ACPI_MADT_TYPE_INTERRUPT_SOURCE:
330
331 InfoTable = AcpiDmTableInfoMadt8;
332 break;
333
334 case ACPI_MADT_TYPE_LOCAL_X2APIC:
335
336 InfoTable = AcpiDmTableInfoMadt9;
337 break;
338
339 case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI:
340
341 InfoTable = AcpiDmTableInfoMadt10;
342 break;
343
344 case ACPI_MADT_TYPE_GENERIC_INTERRUPT:
345
346 InfoTable = AcpiDmTableInfoMadt11;
347 break;
348
349 case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR:
350
351 InfoTable = AcpiDmTableInfoMadt12;
352 break;
353
354 case ACPI_MADT_TYPE_GENERIC_MSI_FRAME:
355
356 InfoTable = AcpiDmTableInfoMadt13;
357 break;
358
359 case ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR:
360
361 InfoTable = AcpiDmTableInfoMadt14;
362 break;
363
364 case ACPI_MADT_TYPE_GENERIC_TRANSLATOR:
365
366 InfoTable = AcpiDmTableInfoMadt15;
367 break;
368
369 default:
370
371 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "MADT");
372 return (AE_ERROR);
373 }
374
375 Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
376 if (ACPI_FAILURE (Status))
377 {
378 return (Status);
379 }
380
381 ParentTable = DtPeekSubtable ();
382 DtInsertSubtable (ParentTable, Subtable);
383 DtPopSubtable ();
384 }
385
386 return (AE_OK);
387 }
388
389
390 /******************************************************************************
391 *
392 * FUNCTION: DtCompileMcfg
393 *
394 * PARAMETERS: List - Current field list pointer
395 *
396 * RETURN: Status
397 *
398 * DESCRIPTION: Compile MCFG.
399 *
400 *****************************************************************************/
401
402 ACPI_STATUS
DtCompileMcfg(void ** List)403 DtCompileMcfg (
404 void **List)
405 {
406 ACPI_STATUS Status;
407
408
409 Status = DtCompileTwoSubtables (List,
410 AcpiDmTableInfoMcfg, AcpiDmTableInfoMcfg0);
411 return (Status);
412 }
413
414
415 /******************************************************************************
416 *
417 * FUNCTION: DtCompileMpst
418 *
419 * PARAMETERS: List - Current field list pointer
420 *
421 * RETURN: Status
422 *
423 * DESCRIPTION: Compile MPST.
424 *
425 *****************************************************************************/
426
427 ACPI_STATUS
DtCompileMpst(void ** List)428 DtCompileMpst (
429 void **List)
430 {
431 ACPI_STATUS Status;
432 DT_SUBTABLE *Subtable;
433 DT_SUBTABLE *ParentTable;
434 DT_FIELD **PFieldList = (DT_FIELD **) List;
435 ACPI_MPST_CHANNEL *MpstChannelInfo;
436 ACPI_MPST_POWER_NODE *MpstPowerNode;
437 ACPI_MPST_DATA_HDR *MpstDataHeader;
438 UINT16 SubtableCount;
439 UINT32 PowerStateCount;
440 UINT32 ComponentCount;
441
442
443 /* Main table */
444
445 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst, &Subtable);
446 if (ACPI_FAILURE (Status))
447 {
448 return (Status);
449 }
450
451 ParentTable = DtPeekSubtable ();
452 DtInsertSubtable (ParentTable, Subtable);
453 DtPushSubtable (Subtable);
454
455 MpstChannelInfo = ACPI_CAST_PTR (ACPI_MPST_CHANNEL, Subtable->Buffer);
456 SubtableCount = MpstChannelInfo->PowerNodeCount;
457
458 while (*PFieldList && SubtableCount)
459 {
460 /* Subtable: Memory Power Node(s) */
461
462 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst0,
463 &Subtable);
464 if (ACPI_FAILURE (Status))
465 {
466 return (Status);
467 }
468
469 ParentTable = DtPeekSubtable ();
470 DtInsertSubtable (ParentTable, Subtable);
471 DtPushSubtable (Subtable);
472
473 MpstPowerNode = ACPI_CAST_PTR (ACPI_MPST_POWER_NODE, Subtable->Buffer);
474 PowerStateCount = MpstPowerNode->NumPowerStates;
475 ComponentCount = MpstPowerNode->NumPhysicalComponents;
476
477 ParentTable = DtPeekSubtable ();
478
479 /* Sub-subtables - Memory Power State Structure(s) */
480
481 while (*PFieldList && PowerStateCount)
482 {
483 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst0A,
484 &Subtable);
485 if (ACPI_FAILURE (Status))
486 {
487 return (Status);
488 }
489
490 DtInsertSubtable (ParentTable, Subtable);
491 PowerStateCount--;
492 }
493
494 /* Sub-subtables - Physical Component ID Structure(s) */
495
496 while (*PFieldList && ComponentCount)
497 {
498 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst0B,
499 &Subtable);
500 if (ACPI_FAILURE (Status))
501 {
502 return (Status);
503 }
504
505 DtInsertSubtable (ParentTable, Subtable);
506 ComponentCount--;
507 }
508
509 SubtableCount--;
510 DtPopSubtable ();
511 }
512
513 /* Subtable: Count of Memory Power State Characteristic structures */
514
515 DtPopSubtable ();
516
517 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst1, &Subtable);
518 if (ACPI_FAILURE (Status))
519 {
520 return (Status);
521 }
522
523 ParentTable = DtPeekSubtable ();
524 DtInsertSubtable (ParentTable, Subtable);
525 DtPushSubtable (Subtable);
526
527 MpstDataHeader = ACPI_CAST_PTR (ACPI_MPST_DATA_HDR, Subtable->Buffer);
528 SubtableCount = MpstDataHeader->CharacteristicsCount;
529
530 ParentTable = DtPeekSubtable ();
531
532 /* Subtable: Memory Power State Characteristics structure(s) */
533
534 while (*PFieldList && SubtableCount)
535 {
536 Status = DtCompileTable (PFieldList, AcpiDmTableInfoMpst2,
537 &Subtable);
538 if (ACPI_FAILURE (Status))
539 {
540 return (Status);
541 }
542
543 DtInsertSubtable (ParentTable, Subtable);
544 SubtableCount--;
545 }
546
547 DtPopSubtable ();
548 return (AE_OK);
549 }
550
551
552 /******************************************************************************
553 *
554 * FUNCTION: DtCompileMsct
555 *
556 * PARAMETERS: List - Current field list pointer
557 *
558 * RETURN: Status
559 *
560 * DESCRIPTION: Compile MSCT.
561 *
562 *****************************************************************************/
563
564 ACPI_STATUS
DtCompileMsct(void ** List)565 DtCompileMsct (
566 void **List)
567 {
568 ACPI_STATUS Status;
569
570
571 Status = DtCompileTwoSubtables (List,
572 AcpiDmTableInfoMsct, AcpiDmTableInfoMsct0);
573 return (Status);
574 }
575
576
577 /******************************************************************************
578 *
579 * FUNCTION: DtCompileMtmr
580 *
581 * PARAMETERS: List - Current field list pointer
582 *
583 * RETURN: Status
584 *
585 * DESCRIPTION: Compile MTMR.
586 *
587 *****************************************************************************/
588
589 ACPI_STATUS
DtCompileMtmr(void ** List)590 DtCompileMtmr (
591 void **List)
592 {
593 ACPI_STATUS Status;
594
595
596 Status = DtCompileTwoSubtables (List,
597 AcpiDmTableInfoMtmr, AcpiDmTableInfoMtmr0);
598 return (Status);
599 }
600
601
602 /******************************************************************************
603 *
604 * FUNCTION: DtCompileNfit
605 *
606 * PARAMETERS: List - Current field list pointer
607 *
608 * RETURN: Status
609 *
610 * DESCRIPTION: Compile NFIT.
611 *
612 *****************************************************************************/
613
614 ACPI_STATUS
DtCompileNfit(void ** List)615 DtCompileNfit (
616 void **List)
617 {
618 ACPI_STATUS Status;
619 DT_SUBTABLE *Subtable;
620 DT_SUBTABLE *ParentTable;
621 DT_FIELD **PFieldList = (DT_FIELD **) List;
622 DT_FIELD *SubtableStart;
623 ACPI_NFIT_HEADER *NfitHeader;
624 ACPI_DMTABLE_INFO *InfoTable;
625 UINT32 Count;
626 ACPI_NFIT_INTERLEAVE *Interleave = NULL;
627 ACPI_NFIT_FLUSH_ADDRESS *Hint = NULL;
628
629
630 /* Main table */
631
632 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit,
633 &Subtable);
634 if (ACPI_FAILURE (Status))
635 {
636 return (Status);
637 }
638
639 ParentTable = DtPeekSubtable ();
640 DtInsertSubtable (ParentTable, Subtable);
641 DtPushSubtable (Subtable);
642
643 /* Subtables */
644
645 while (*PFieldList)
646 {
647 SubtableStart = *PFieldList;
648 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfitHdr,
649 &Subtable);
650 if (ACPI_FAILURE (Status))
651 {
652 return (Status);
653 }
654
655 ParentTable = DtPeekSubtable ();
656 DtInsertSubtable (ParentTable, Subtable);
657 DtPushSubtable (Subtable);
658
659 NfitHeader = ACPI_CAST_PTR (ACPI_NFIT_HEADER, Subtable->Buffer);
660
661 switch (NfitHeader->Type)
662 {
663 case ACPI_NFIT_TYPE_SYSTEM_ADDRESS:
664
665 InfoTable = AcpiDmTableInfoNfit0;
666 break;
667
668 case ACPI_NFIT_TYPE_MEMORY_MAP:
669
670 InfoTable = AcpiDmTableInfoNfit1;
671 break;
672
673 case ACPI_NFIT_TYPE_INTERLEAVE:
674
675 Interleave = ACPI_CAST_PTR (ACPI_NFIT_INTERLEAVE, Subtable->Buffer);
676 InfoTable = AcpiDmTableInfoNfit2;
677 break;
678
679 case ACPI_NFIT_TYPE_SMBIOS:
680
681 InfoTable = AcpiDmTableInfoNfit3;
682 break;
683
684 case ACPI_NFIT_TYPE_CONTROL_REGION:
685
686 InfoTable = AcpiDmTableInfoNfit4;
687 break;
688
689 case ACPI_NFIT_TYPE_DATA_REGION:
690
691 InfoTable = AcpiDmTableInfoNfit5;
692 break;
693
694 case ACPI_NFIT_TYPE_FLUSH_ADDRESS:
695
696 Hint = ACPI_CAST_PTR (ACPI_NFIT_FLUSH_ADDRESS, Subtable->Buffer);
697 InfoTable = AcpiDmTableInfoNfit6;
698 break;
699
700 case ACPI_NFIT_TYPE_CAPABILITIES:
701
702 InfoTable = AcpiDmTableInfoNfit7;
703 break;
704
705 default:
706
707 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "NFIT");
708 return (AE_ERROR);
709 }
710
711 Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
712 if (ACPI_FAILURE (Status))
713 {
714 return (Status);
715 }
716
717 ParentTable = DtPeekSubtable ();
718 DtInsertSubtable (ParentTable, Subtable);
719 DtPopSubtable ();
720
721 switch (NfitHeader->Type)
722 {
723 case ACPI_NFIT_TYPE_INTERLEAVE:
724
725 Count = 0;
726 DtPushSubtable (Subtable);
727 while (*PFieldList)
728 {
729 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit2a,
730 &Subtable);
731 if (ACPI_FAILURE (Status))
732 {
733 return (Status);
734 }
735
736 if (!Subtable)
737 {
738 DtPopSubtable ();
739 break;
740 }
741
742 ParentTable = DtPeekSubtable ();
743 DtInsertSubtable (ParentTable, Subtable);
744 Count++;
745 }
746
747 Interleave->LineCount = Count;
748 break;
749
750 case ACPI_NFIT_TYPE_SMBIOS:
751
752 if (*PFieldList)
753 {
754 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit3a,
755 &Subtable);
756 if (ACPI_FAILURE (Status))
757 {
758 return (Status);
759 }
760
761 if (Subtable)
762 {
763 DtInsertSubtable (ParentTable, Subtable);
764 }
765 }
766 break;
767
768 case ACPI_NFIT_TYPE_FLUSH_ADDRESS:
769
770 Count = 0;
771 DtPushSubtable (Subtable);
772 while (*PFieldList)
773 {
774 Status = DtCompileTable (PFieldList, AcpiDmTableInfoNfit6a,
775 &Subtable);
776 if (ACPI_FAILURE (Status))
777 {
778 return (Status);
779 }
780
781 if (!Subtable)
782 {
783 DtPopSubtable ();
784 break;
785 }
786
787 ParentTable = DtPeekSubtable ();
788 DtInsertSubtable (ParentTable, Subtable);
789 Count++;
790 }
791
792 Hint->HintCount = (UINT16) Count;
793 break;
794
795 default:
796 break;
797 }
798 }
799
800 return (AE_OK);
801 }
802
803
804 /******************************************************************************
805 *
806 * FUNCTION: DtCompilePcct
807 *
808 * PARAMETERS: List - Current field list pointer
809 *
810 * RETURN: Status
811 *
812 * DESCRIPTION: Compile PCCT.
813 *
814 *****************************************************************************/
815
816 ACPI_STATUS
DtCompilePcct(void ** List)817 DtCompilePcct (
818 void **List)
819 {
820 ACPI_STATUS Status;
821 DT_SUBTABLE *Subtable;
822 DT_SUBTABLE *ParentTable;
823 DT_FIELD **PFieldList = (DT_FIELD **) List;
824 DT_FIELD *SubtableStart;
825 ACPI_SUBTABLE_HEADER *PcctHeader;
826 ACPI_DMTABLE_INFO *InfoTable;
827
828
829 /* Main table */
830
831 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPcct,
832 &Subtable);
833 if (ACPI_FAILURE (Status))
834 {
835 return (Status);
836 }
837
838 ParentTable = DtPeekSubtable ();
839 DtInsertSubtable (ParentTable, Subtable);
840
841 /* Subtables */
842
843 while (*PFieldList)
844 {
845 SubtableStart = *PFieldList;
846 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPcctHdr,
847 &Subtable);
848 if (ACPI_FAILURE (Status))
849 {
850 return (Status);
851 }
852
853 ParentTable = DtPeekSubtable ();
854 DtInsertSubtable (ParentTable, Subtable);
855 DtPushSubtable (Subtable);
856
857 PcctHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer);
858
859 switch (PcctHeader->Type)
860 {
861 case ACPI_PCCT_TYPE_GENERIC_SUBSPACE:
862
863 InfoTable = AcpiDmTableInfoPcct0;
864 break;
865
866 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE:
867
868 InfoTable = AcpiDmTableInfoPcct1;
869 break;
870
871 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE_TYPE2:
872
873 InfoTable = AcpiDmTableInfoPcct2;
874 break;
875
876 case ACPI_PCCT_TYPE_EXT_PCC_MASTER_SUBSPACE:
877
878 InfoTable = AcpiDmTableInfoPcct3;
879 break;
880
881 case ACPI_PCCT_TYPE_EXT_PCC_SLAVE_SUBSPACE:
882
883 InfoTable = AcpiDmTableInfoPcct4;
884 break;
885
886 default:
887
888 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "PCCT");
889 return (AE_ERROR);
890 }
891
892 Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
893 if (ACPI_FAILURE (Status))
894 {
895 return (Status);
896 }
897
898 ParentTable = DtPeekSubtable ();
899 DtInsertSubtable (ParentTable, Subtable);
900 DtPopSubtable ();
901 }
902
903 return (AE_OK);
904 }
905
906
907 /******************************************************************************
908 *
909 * FUNCTION: DtCompilePdtt
910 *
911 * PARAMETERS: List - Current field list pointer
912 *
913 * RETURN: Status
914 *
915 * DESCRIPTION: Compile PDTT.
916 *
917 *****************************************************************************/
918
919 ACPI_STATUS
DtCompilePdtt(void ** List)920 DtCompilePdtt (
921 void **List)
922 {
923 ACPI_STATUS Status;
924 DT_SUBTABLE *Subtable;
925 DT_SUBTABLE *ParentTable;
926 DT_FIELD **PFieldList = (DT_FIELD **) List;
927 ACPI_TABLE_PDTT *PdttHeader;
928 UINT32 Count = 0;
929
930
931 /* Main table */
932
933 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPdtt, &Subtable);
934 if (ACPI_FAILURE (Status))
935 {
936 return (Status);
937 }
938
939 ParentTable = DtPeekSubtable ();
940 DtInsertSubtable (ParentTable, Subtable);
941
942 PdttHeader = ACPI_CAST_PTR (ACPI_TABLE_PDTT, ParentTable->Buffer);
943 PdttHeader->ArrayOffset = sizeof (ACPI_TABLE_PDTT);
944
945 /* There is only one type of subtable at this time, no need to decode */
946
947 while (*PFieldList)
948 {
949 /* List of subchannel IDs, each 2 bytes */
950
951 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPdtt0,
952 &Subtable);
953 if (ACPI_FAILURE (Status))
954 {
955 return (Status);
956 }
957
958 DtInsertSubtable (ParentTable, Subtable);
959 Count++;
960 }
961
962 PdttHeader->TriggerCount = (UINT8) Count;
963 return (AE_OK);
964 }
965
966
967 /******************************************************************************
968 *
969 * FUNCTION: DtCompilePmtt
970 *
971 * PARAMETERS: List - Current field list pointer
972 *
973 * RETURN: Status
974 *
975 * DESCRIPTION: Compile PMTT.
976 *
977 *****************************************************************************/
978
979 ACPI_STATUS
DtCompilePmtt(void ** List)980 DtCompilePmtt (
981 void **List)
982 {
983 ACPI_STATUS Status;
984 DT_SUBTABLE *Subtable;
985 DT_SUBTABLE *ParentTable;
986 DT_FIELD **PFieldList = (DT_FIELD **) List;
987 DT_FIELD *SubtableStart;
988 ACPI_PMTT_HEADER *PmttHeader;
989 ACPI_PMTT_CONTROLLER *PmttController;
990 UINT16 DomainCount;
991 UINT8 PrevType = ACPI_PMTT_TYPE_SOCKET;
992
993
994 /* Main table */
995
996 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt, &Subtable);
997 if (ACPI_FAILURE (Status))
998 {
999 return (Status);
1000 }
1001
1002 ParentTable = DtPeekSubtable ();
1003 DtInsertSubtable (ParentTable, Subtable);
1004 DtPushSubtable (Subtable);
1005
1006 while (*PFieldList)
1007 {
1008 SubtableStart = *PFieldList;
1009 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmttHdr,
1010 &Subtable);
1011 if (ACPI_FAILURE (Status))
1012 {
1013 return (Status);
1014 }
1015
1016 PmttHeader = ACPI_CAST_PTR (ACPI_PMTT_HEADER, Subtable->Buffer);
1017 while (PrevType >= PmttHeader->Type)
1018 {
1019 DtPopSubtable ();
1020
1021 if (PrevType == ACPI_PMTT_TYPE_SOCKET)
1022 {
1023 break;
1024 }
1025
1026 PrevType--;
1027 }
1028
1029 PrevType = PmttHeader->Type;
1030
1031 ParentTable = DtPeekSubtable ();
1032 DtInsertSubtable (ParentTable, Subtable);
1033 DtPushSubtable (Subtable);
1034
1035 switch (PmttHeader->Type)
1036 {
1037 case ACPI_PMTT_TYPE_SOCKET:
1038
1039 /* Subtable: Socket Structure */
1040
1041 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt0,
1042 &Subtable);
1043 if (ACPI_FAILURE (Status))
1044 {
1045 return (Status);
1046 }
1047
1048 ParentTable = DtPeekSubtable ();
1049 DtInsertSubtable (ParentTable, Subtable);
1050 break;
1051
1052 case ACPI_PMTT_TYPE_CONTROLLER:
1053
1054 /* Subtable: Memory Controller Structure */
1055
1056 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt1,
1057 &Subtable);
1058 if (ACPI_FAILURE (Status))
1059 {
1060 return (Status);
1061 }
1062
1063 ParentTable = DtPeekSubtable ();
1064 DtInsertSubtable (ParentTable, Subtable);
1065
1066 PmttController = ACPI_CAST_PTR (ACPI_PMTT_CONTROLLER,
1067 (Subtable->Buffer - sizeof (ACPI_PMTT_HEADER)));
1068 DomainCount = PmttController->DomainCount;
1069
1070 while (DomainCount)
1071 {
1072 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt1a,
1073 &Subtable);
1074 if (ACPI_FAILURE (Status))
1075 {
1076 return (Status);
1077 }
1078
1079 DtInsertSubtable (ParentTable, Subtable);
1080 DomainCount--;
1081 }
1082 break;
1083
1084 case ACPI_PMTT_TYPE_DIMM:
1085
1086 /* Subtable: Physical Component Structure */
1087
1088 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPmtt2,
1089 &Subtable);
1090 if (ACPI_FAILURE (Status))
1091 {
1092 return (Status);
1093 }
1094
1095 ParentTable = DtPeekSubtable ();
1096 DtInsertSubtable (ParentTable, Subtable);
1097 break;
1098
1099 default:
1100
1101 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "PMTT");
1102 return (AE_ERROR);
1103 }
1104 }
1105
1106 return (Status);
1107 }
1108
1109
1110 /******************************************************************************
1111 *
1112 * FUNCTION: DtCompilePptt
1113 *
1114 * PARAMETERS: List - Current field list pointer
1115 *
1116 * RETURN: Status
1117 *
1118 * DESCRIPTION: Compile PPTT.
1119 *
1120 *****************************************************************************/
1121
1122 ACPI_STATUS
DtCompilePptt(void ** List)1123 DtCompilePptt (
1124 void **List)
1125 {
1126 ACPI_STATUS Status;
1127 ACPI_SUBTABLE_HEADER *PpttHeader;
1128 ACPI_PPTT_PROCESSOR *PpttProcessor = NULL;
1129 DT_SUBTABLE *Subtable;
1130 DT_SUBTABLE *ParentTable;
1131 ACPI_DMTABLE_INFO *InfoTable;
1132 DT_FIELD **PFieldList = (DT_FIELD **) List;
1133 DT_FIELD *SubtableStart;
1134
1135
1136 ParentTable = DtPeekSubtable ();
1137 while (*PFieldList)
1138 {
1139 SubtableStart = *PFieldList;
1140
1141 /* Compile PPTT subtable header */
1142
1143 Status = DtCompileTable (PFieldList, AcpiDmTableInfoPpttHdr,
1144 &Subtable);
1145 if (ACPI_FAILURE (Status))
1146 {
1147 return (Status);
1148 }
1149 DtInsertSubtable (ParentTable, Subtable);
1150 PpttHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer);
1151 PpttHeader->Length = (UINT8)(Subtable->Length);
1152
1153 switch (PpttHeader->Type)
1154 {
1155 case ACPI_PPTT_TYPE_PROCESSOR:
1156
1157 InfoTable = AcpiDmTableInfoPptt0;
1158 break;
1159
1160 case ACPI_PPTT_TYPE_CACHE:
1161
1162 InfoTable = AcpiDmTableInfoPptt1;
1163 break;
1164
1165 case ACPI_PPTT_TYPE_ID:
1166
1167 InfoTable = AcpiDmTableInfoPptt2;
1168 break;
1169
1170 default:
1171
1172 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "PPTT");
1173 return (AE_ERROR);
1174 }
1175
1176 /* Compile PPTT subtable body */
1177
1178 Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
1179 if (ACPI_FAILURE (Status))
1180 {
1181 return (Status);
1182 }
1183 DtInsertSubtable (ParentTable, Subtable);
1184 PpttHeader->Length += (UINT8)(Subtable->Length);
1185
1186 /* Compile PPTT subtable additionals */
1187
1188 switch (PpttHeader->Type)
1189 {
1190 case ACPI_PPTT_TYPE_PROCESSOR:
1191
1192 PpttProcessor = ACPI_SUB_PTR (ACPI_PPTT_PROCESSOR,
1193 Subtable->Buffer, sizeof (ACPI_SUBTABLE_HEADER));
1194 if (PpttProcessor)
1195 {
1196 /* Compile initiator proximity domain list */
1197
1198 PpttProcessor->NumberOfPrivResources = 0;
1199 while (*PFieldList)
1200 {
1201 Status = DtCompileTable (PFieldList,
1202 AcpiDmTableInfoPptt0a, &Subtable);
1203 if (ACPI_FAILURE (Status))
1204 {
1205 return (Status);
1206 }
1207 if (!Subtable)
1208 {
1209 break;
1210 }
1211
1212 DtInsertSubtable (ParentTable, Subtable);
1213 PpttHeader->Length += (UINT8)(Subtable->Length);
1214 PpttProcessor->NumberOfPrivResources++;
1215 }
1216 }
1217 break;
1218
1219 default:
1220
1221 break;
1222 }
1223 }
1224
1225 return (AE_OK);
1226 }
1227
1228
1229 /******************************************************************************
1230 *
1231 * FUNCTION: DtCompileRsdt
1232 *
1233 * PARAMETERS: List - Current field list pointer
1234 *
1235 * RETURN: Status
1236 *
1237 * DESCRIPTION: Compile RSDT.
1238 *
1239 *****************************************************************************/
1240
1241 ACPI_STATUS
DtCompileRsdt(void ** List)1242 DtCompileRsdt (
1243 void **List)
1244 {
1245 DT_SUBTABLE *Subtable;
1246 DT_SUBTABLE *ParentTable;
1247 DT_FIELD *FieldList = *(DT_FIELD **) List;
1248 UINT32 Address;
1249
1250
1251 ParentTable = DtPeekSubtable ();
1252
1253 while (FieldList)
1254 {
1255 DtCompileInteger ((UINT8 *) &Address, FieldList, 4, DT_NON_ZERO);
1256
1257 DtCreateSubtable ((UINT8 *) &Address, 4, &Subtable);
1258 DtInsertSubtable (ParentTable, Subtable);
1259 FieldList = FieldList->Next;
1260 }
1261
1262 return (AE_OK);
1263 }
1264
1265
1266 /******************************************************************************
1267 *
1268 * FUNCTION: DtCompileS3pt
1269 *
1270 * PARAMETERS: PFieldList - Current field list pointer
1271 *
1272 * RETURN: Status
1273 *
1274 * DESCRIPTION: Compile S3PT (Pointed to by FPDT)
1275 *
1276 *****************************************************************************/
1277
1278 ACPI_STATUS
DtCompileS3pt(DT_FIELD ** PFieldList)1279 DtCompileS3pt (
1280 DT_FIELD **PFieldList)
1281 {
1282 ACPI_STATUS Status;
1283 ACPI_FPDT_HEADER *S3ptHeader;
1284 DT_SUBTABLE *Subtable;
1285 DT_SUBTABLE *ParentTable;
1286 ACPI_DMTABLE_INFO *InfoTable;
1287 DT_FIELD *SubtableStart;
1288
1289
1290 Status = DtCompileTable (PFieldList, AcpiDmTableInfoS3pt,
1291 &Gbl_RootTable);
1292 if (ACPI_FAILURE (Status))
1293 {
1294 return (Status);
1295 }
1296
1297 DtPushSubtable (Gbl_RootTable);
1298
1299 while (*PFieldList)
1300 {
1301 SubtableStart = *PFieldList;
1302 Status = DtCompileTable (PFieldList, AcpiDmTableInfoS3ptHdr,
1303 &Subtable);
1304 if (ACPI_FAILURE (Status))
1305 {
1306 return (Status);
1307 }
1308
1309 ParentTable = DtPeekSubtable ();
1310 DtInsertSubtable (ParentTable, Subtable);
1311 DtPushSubtable (Subtable);
1312
1313 S3ptHeader = ACPI_CAST_PTR (ACPI_FPDT_HEADER, Subtable->Buffer);
1314
1315 switch (S3ptHeader->Type)
1316 {
1317 case ACPI_S3PT_TYPE_RESUME:
1318
1319 InfoTable = AcpiDmTableInfoS3pt0;
1320 break;
1321
1322 case ACPI_S3PT_TYPE_SUSPEND:
1323
1324 InfoTable = AcpiDmTableInfoS3pt1;
1325 break;
1326
1327 default:
1328
1329 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "S3PT");
1330 return (AE_ERROR);
1331 }
1332
1333 Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
1334 if (ACPI_FAILURE (Status))
1335 {
1336 return (Status);
1337 }
1338
1339 ParentTable = DtPeekSubtable ();
1340 DtInsertSubtable (ParentTable, Subtable);
1341 DtPopSubtable ();
1342 }
1343
1344 return (AE_OK);
1345 }
1346
1347
1348 /******************************************************************************
1349 *
1350 * FUNCTION: DtCompileSdev
1351 *
1352 * PARAMETERS: List - Current field list pointer
1353 *
1354 * RETURN: Status
1355 *
1356 * DESCRIPTION: Compile SDEV.
1357 *
1358 *****************************************************************************/
1359
1360 ACPI_STATUS
DtCompileSdev(void ** List)1361 DtCompileSdev (
1362 void **List)
1363 {
1364 ACPI_STATUS Status;
1365 ACPI_SDEV_HEADER *SdevHeader;
1366 DT_SUBTABLE *Subtable;
1367 DT_SUBTABLE *ParentTable;
1368 ACPI_DMTABLE_INFO *InfoTable;
1369 DT_FIELD **PFieldList = (DT_FIELD **) List;
1370 DT_FIELD *SubtableStart;
1371 ACPI_SDEV_PCIE *Pcie = NULL;
1372 ACPI_SDEV_NAMESPACE *Namesp = NULL;
1373 UINT32 EntryCount;
1374
1375
1376 /* Subtables */
1377
1378 while (*PFieldList)
1379 {
1380 /* Compile common SDEV subtable header */
1381
1382 SubtableStart = *PFieldList;
1383 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSdevHdr,
1384 &Subtable);
1385 if (ACPI_FAILURE (Status))
1386 {
1387 return (Status);
1388 }
1389
1390 ParentTable = DtPeekSubtable ();
1391 DtInsertSubtable (ParentTable, Subtable);
1392 DtPushSubtable (Subtable);
1393
1394 SdevHeader = ACPI_CAST_PTR (ACPI_SDEV_HEADER, Subtable->Buffer);
1395 SdevHeader->Length = (UINT8)(sizeof (ACPI_SDEV_HEADER));
1396
1397 switch (SdevHeader->Type)
1398 {
1399 case ACPI_SDEV_TYPE_NAMESPACE_DEVICE:
1400
1401 InfoTable = AcpiDmTableInfoSdev0;
1402 Namesp = ACPI_CAST_PTR (ACPI_SDEV_NAMESPACE, Subtable->Buffer);
1403 break;
1404
1405 case ACPI_SDEV_TYPE_PCIE_ENDPOINT_DEVICE:
1406
1407 InfoTable = AcpiDmTableInfoSdev1;
1408 Pcie = ACPI_CAST_PTR (ACPI_SDEV_PCIE, Subtable->Buffer);
1409 break;
1410
1411 default:
1412
1413 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "SDEV");
1414 return (AE_ERROR);
1415 }
1416
1417 /* Compile SDEV subtable body */
1418
1419 Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
1420 if (ACPI_FAILURE (Status))
1421 {
1422 return (Status);
1423 }
1424
1425 ParentTable = DtPeekSubtable ();
1426 DtInsertSubtable (ParentTable, Subtable);
1427
1428 /* Optional data fields are appended to the main subtable body */
1429
1430 switch (SdevHeader->Type)
1431 {
1432 case ACPI_SDEV_TYPE_NAMESPACE_DEVICE:
1433
1434 /* Append DeviceId namespace string */
1435
1436 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSdev0a,
1437 &Subtable);
1438 if (ACPI_FAILURE (Status))
1439 {
1440 return (Status);
1441 }
1442
1443 if (!Subtable)
1444 {
1445 break;
1446 }
1447
1448 ParentTable = DtPeekSubtable ();
1449 DtInsertSubtable (ParentTable, Subtable);
1450
1451 Namesp->DeviceIdOffset = sizeof (ACPI_SDEV_NAMESPACE);
1452 Namesp->DeviceIdLength = (UINT16) Subtable->Length;
1453
1454 /* Append Vendor data */
1455
1456 Namesp->VendorDataLength = 0;
1457 Namesp->VendorDataOffset = 0;
1458
1459 if (*PFieldList)
1460 {
1461 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSdev1b,
1462 &Subtable);
1463 if (ACPI_FAILURE (Status))
1464 {
1465 return (Status);
1466 }
1467
1468 if (Subtable)
1469 {
1470 ParentTable = DtPeekSubtable ();
1471 DtInsertSubtable (ParentTable, Subtable);
1472
1473 Namesp->VendorDataOffset =
1474 Namesp->DeviceIdOffset + Namesp->DeviceIdLength;
1475 Namesp->VendorDataLength =
1476 (UINT16) Subtable->Length;
1477 }
1478 }
1479
1480 /* Final size of entire namespace structure */
1481
1482 SdevHeader->Length = (UINT16) (sizeof (ACPI_SDEV_NAMESPACE) +
1483 Subtable->Length + Namesp->DeviceIdLength);
1484 break;
1485
1486 case ACPI_SDEV_TYPE_PCIE_ENDPOINT_DEVICE:
1487
1488 /* Append the PCIe path info first */
1489
1490 EntryCount = 0;
1491 while (*PFieldList && !strcmp ((*PFieldList)->Name, "Device"))
1492 {
1493 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSdev1a,
1494 &Subtable);
1495 if (ACPI_FAILURE (Status))
1496 {
1497 return (Status);
1498 }
1499
1500 if (!Subtable)
1501 {
1502 DtPopSubtable ();
1503 break;
1504 }
1505
1506 ParentTable = DtPeekSubtable ();
1507 DtInsertSubtable (ParentTable, Subtable);
1508 EntryCount++;
1509 }
1510
1511 /* Path offset will point immediately after the main subtable */
1512
1513 Pcie->PathOffset = sizeof (ACPI_SDEV_PCIE);
1514 Pcie->PathLength = (UINT16)
1515 (EntryCount * sizeof (ACPI_SDEV_PCIE_PATH));
1516
1517 /* Append the Vendor Data last */
1518
1519 Pcie->VendorDataLength = 0;
1520 Pcie->VendorDataOffset = 0;
1521
1522 if (*PFieldList)
1523 {
1524 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSdev1b,
1525 &Subtable);
1526 if (ACPI_FAILURE (Status))
1527 {
1528 return (Status);
1529 }
1530
1531 if (Subtable)
1532 {
1533 ParentTable = DtPeekSubtable ();
1534 DtInsertSubtable (ParentTable, Subtable);
1535
1536 Pcie->VendorDataOffset =
1537 Pcie->PathOffset + Pcie->PathLength;
1538 Pcie->VendorDataLength = (UINT16)
1539 Subtable->Length;
1540 }
1541 }
1542
1543 SdevHeader->Length =
1544 sizeof (ACPI_SDEV_PCIE) +
1545 Pcie->PathLength + Pcie->VendorDataLength;
1546 break;
1547
1548 default:
1549
1550 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "SDEV");
1551 return (AE_ERROR);
1552 }
1553
1554 DtPopSubtable ();
1555 }
1556
1557 return (AE_OK);
1558 }
1559
1560
1561 /******************************************************************************
1562 *
1563 * FUNCTION: DtCompileSlic
1564 *
1565 * PARAMETERS: List - Current field list pointer
1566 *
1567 * RETURN: Status
1568 *
1569 * DESCRIPTION: Compile SLIC.
1570 *
1571 *****************************************************************************/
1572
1573 ACPI_STATUS
DtCompileSlic(void ** List)1574 DtCompileSlic (
1575 void **List)
1576 {
1577 ACPI_STATUS Status;
1578 DT_SUBTABLE *Subtable;
1579 DT_SUBTABLE *ParentTable;
1580 DT_FIELD **PFieldList = (DT_FIELD **) List;
1581
1582
1583 while (*PFieldList)
1584 {
1585 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSlic,
1586 &Subtable);
1587 if (ACPI_FAILURE (Status))
1588 {
1589 return (Status);
1590 }
1591
1592 ParentTable = DtPeekSubtable ();
1593 DtInsertSubtable (ParentTable, Subtable);
1594 DtPushSubtable (Subtable);
1595 DtPopSubtable ();
1596 }
1597
1598 return (AE_OK);
1599 }
1600
1601
1602 /******************************************************************************
1603 *
1604 * FUNCTION: DtCompileSlit
1605 *
1606 * PARAMETERS: List - Current field list pointer
1607 *
1608 * RETURN: Status
1609 *
1610 * DESCRIPTION: Compile SLIT.
1611 *
1612 *****************************************************************************/
1613
1614 ACPI_STATUS
DtCompileSlit(void ** List)1615 DtCompileSlit (
1616 void **List)
1617 {
1618 ACPI_STATUS Status;
1619 DT_SUBTABLE *Subtable;
1620 DT_SUBTABLE *ParentTable;
1621 DT_FIELD **PFieldList = (DT_FIELD **) List;
1622 DT_FIELD *FieldList;
1623 UINT32 Localities;
1624 UINT8 *LocalityBuffer;
1625
1626
1627 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSlit,
1628 &Subtable);
1629 if (ACPI_FAILURE (Status))
1630 {
1631 return (Status);
1632 }
1633
1634 ParentTable = DtPeekSubtable ();
1635 DtInsertSubtable (ParentTable, Subtable);
1636
1637 Localities = *ACPI_CAST_PTR (UINT32, Subtable->Buffer);
1638 LocalityBuffer = UtLocalCalloc (Localities);
1639
1640 /* Compile each locality buffer */
1641
1642 FieldList = *PFieldList;
1643 while (FieldList)
1644 {
1645 DtCompileBuffer (LocalityBuffer,
1646 FieldList->Value, FieldList, Localities);
1647
1648 DtCreateSubtable (LocalityBuffer, Localities, &Subtable);
1649 DtInsertSubtable (ParentTable, Subtable);
1650 FieldList = FieldList->Next;
1651 }
1652
1653 ACPI_FREE (LocalityBuffer);
1654 return (AE_OK);
1655 }
1656
1657
1658 /******************************************************************************
1659 *
1660 * FUNCTION: DtCompileSrat
1661 *
1662 * PARAMETERS: List - Current field list pointer
1663 *
1664 * RETURN: Status
1665 *
1666 * DESCRIPTION: Compile SRAT.
1667 *
1668 *****************************************************************************/
1669
1670 ACPI_STATUS
DtCompileSrat(void ** List)1671 DtCompileSrat (
1672 void **List)
1673 {
1674 ACPI_STATUS Status;
1675 DT_SUBTABLE *Subtable;
1676 DT_SUBTABLE *ParentTable;
1677 DT_FIELD **PFieldList = (DT_FIELD **) List;
1678 DT_FIELD *SubtableStart;
1679 ACPI_SUBTABLE_HEADER *SratHeader;
1680 ACPI_DMTABLE_INFO *InfoTable;
1681
1682
1683 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSrat,
1684 &Subtable);
1685 if (ACPI_FAILURE (Status))
1686 {
1687 return (Status);
1688 }
1689
1690 ParentTable = DtPeekSubtable ();
1691 DtInsertSubtable (ParentTable, Subtable);
1692
1693 while (*PFieldList)
1694 {
1695 SubtableStart = *PFieldList;
1696 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSratHdr,
1697 &Subtable);
1698 if (ACPI_FAILURE (Status))
1699 {
1700 return (Status);
1701 }
1702
1703 ParentTable = DtPeekSubtable ();
1704 DtInsertSubtable (ParentTable, Subtable);
1705 DtPushSubtable (Subtable);
1706
1707 SratHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer);
1708
1709 switch (SratHeader->Type)
1710 {
1711 case ACPI_SRAT_TYPE_CPU_AFFINITY:
1712
1713 InfoTable = AcpiDmTableInfoSrat0;
1714 break;
1715
1716 case ACPI_SRAT_TYPE_MEMORY_AFFINITY:
1717
1718 InfoTable = AcpiDmTableInfoSrat1;
1719 break;
1720
1721 case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY:
1722
1723 InfoTable = AcpiDmTableInfoSrat2;
1724 break;
1725
1726 case ACPI_SRAT_TYPE_GICC_AFFINITY:
1727
1728 InfoTable = AcpiDmTableInfoSrat3;
1729 break;
1730
1731 case ACPI_SRAT_TYPE_GIC_ITS_AFFINITY:
1732
1733 InfoTable = AcpiDmTableInfoSrat4;
1734 break;
1735
1736 default:
1737
1738 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "SRAT");
1739 return (AE_ERROR);
1740 }
1741
1742 Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
1743 if (ACPI_FAILURE (Status))
1744 {
1745 return (Status);
1746 }
1747
1748 ParentTable = DtPeekSubtable ();
1749 DtInsertSubtable (ParentTable, Subtable);
1750 DtPopSubtable ();
1751 }
1752
1753 return (AE_OK);
1754 }
1755
1756
1757 /******************************************************************************
1758 *
1759 * FUNCTION: DtCompileStao
1760 *
1761 * PARAMETERS: PFieldList - Current field list pointer
1762 *
1763 * RETURN: Status
1764 *
1765 * DESCRIPTION: Compile STAO.
1766 *
1767 *****************************************************************************/
1768
1769 ACPI_STATUS
DtCompileStao(void ** List)1770 DtCompileStao (
1771 void **List)
1772 {
1773 DT_FIELD **PFieldList = (DT_FIELD **) List;
1774 DT_SUBTABLE *Subtable;
1775 DT_SUBTABLE *ParentTable;
1776 ACPI_STATUS Status;
1777
1778
1779 /* Compile the main table */
1780
1781 Status = DtCompileTable (PFieldList, AcpiDmTableInfoStao,
1782 &Subtable);
1783 if (ACPI_FAILURE (Status))
1784 {
1785 return (Status);
1786 }
1787
1788 ParentTable = DtPeekSubtable ();
1789 DtInsertSubtable (ParentTable, Subtable);
1790
1791 /* Compile each ASCII namestring as a subtable */
1792
1793 while (*PFieldList)
1794 {
1795 Status = DtCompileTable (PFieldList, AcpiDmTableInfoStaoStr,
1796 &Subtable);
1797 if (ACPI_FAILURE (Status))
1798 {
1799 return (Status);
1800 }
1801
1802 ParentTable = DtPeekSubtable ();
1803 DtInsertSubtable (ParentTable, Subtable);
1804 }
1805
1806 return (AE_OK);
1807 }
1808
1809
1810 /******************************************************************************
1811 *
1812 * FUNCTION: DtCompileTcpa
1813 *
1814 * PARAMETERS: PFieldList - Current field list pointer
1815 *
1816 * RETURN: Status
1817 *
1818 * DESCRIPTION: Compile TCPA.
1819 *
1820 *****************************************************************************/
1821
1822 ACPI_STATUS
DtCompileTcpa(void ** List)1823 DtCompileTcpa (
1824 void **List)
1825 {
1826 DT_FIELD **PFieldList = (DT_FIELD **) List;
1827 DT_SUBTABLE *Subtable;
1828 ACPI_TABLE_TCPA_HDR *TcpaHeader;
1829 DT_SUBTABLE *ParentTable;
1830 ACPI_STATUS Status;
1831
1832
1833 /* Compile the main table */
1834
1835 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaHdr,
1836 &Subtable);
1837 if (ACPI_FAILURE (Status))
1838 {
1839 return (Status);
1840 }
1841
1842 ParentTable = DtPeekSubtable ();
1843 DtInsertSubtable (ParentTable, Subtable);
1844
1845 /*
1846 * Examine the PlatformClass field to determine the table type.
1847 * Either a client or server table. Only one.
1848 */
1849 TcpaHeader = ACPI_CAST_PTR (ACPI_TABLE_TCPA_HDR, ParentTable->Buffer);
1850
1851 switch (TcpaHeader->PlatformClass)
1852 {
1853 case ACPI_TCPA_CLIENT_TABLE:
1854
1855 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaClient,
1856 &Subtable);
1857 break;
1858
1859 case ACPI_TCPA_SERVER_TABLE:
1860
1861 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaServer,
1862 &Subtable);
1863 break;
1864
1865 default:
1866
1867 AcpiOsPrintf ("\n**** Unknown TCPA Platform Class 0x%X\n",
1868 TcpaHeader->PlatformClass);
1869 Status = AE_ERROR;
1870 break;
1871 }
1872
1873 ParentTable = DtPeekSubtable ();
1874 DtInsertSubtable (ParentTable, Subtable);
1875 return (Status);
1876 }
1877
1878
1879 /******************************************************************************
1880 *
1881 * FUNCTION: DtCompileTpm2
1882 *
1883 * PARAMETERS: PFieldList - Current field list pointer
1884 *
1885 * RETURN: Status
1886 *
1887 * DESCRIPTION: Compile TPM2.
1888 *
1889 *****************************************************************************/
1890
1891 ACPI_STATUS
DtCompileTpm2(void ** List)1892 DtCompileTpm2 (
1893 void **List)
1894 {
1895 DT_FIELD **PFieldList = (DT_FIELD **) List;
1896 DT_SUBTABLE *Subtable;
1897 ACPI_TABLE_TPM2 *Tpm2Header;
1898 DT_SUBTABLE *ParentTable;
1899 ACPI_STATUS Status = AE_OK;
1900
1901
1902 /* Compile the main table */
1903
1904 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTpm2,
1905 &Subtable);
1906 if (ACPI_FAILURE (Status))
1907 {
1908 return (Status);
1909 }
1910
1911 ParentTable = DtPeekSubtable ();
1912 DtInsertSubtable (ParentTable, Subtable);
1913
1914 Tpm2Header = ACPI_CAST_PTR (ACPI_TABLE_TPM2, ParentTable->Buffer);
1915
1916 /* Method parameters */
1917 /* Optional: Log area minimum length */
1918 /* Optional: Log area start address */
1919 /* TBD: Optional fields above not fully implemented (not optional at this time) */
1920
1921 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTpm2a,
1922 &Subtable);
1923 if (ACPI_FAILURE (Status))
1924 {
1925 return (Status);
1926 }
1927
1928 ParentTable = DtPeekSubtable ();
1929 DtInsertSubtable (ParentTable, Subtable);
1930
1931
1932 /* Subtable type depends on the StartMethod */
1933
1934 switch (Tpm2Header->StartMethod)
1935 {
1936 case ACPI_TPM2_COMMAND_BUFFER_WITH_ARM_SMC:
1937
1938 /* Subtable specific to to ARM_SMC */
1939
1940 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTpm211,
1941 &Subtable);
1942 if (ACPI_FAILURE (Status))
1943 {
1944 return (Status);
1945 }
1946
1947 ParentTable = DtPeekSubtable ();
1948 DtInsertSubtable (ParentTable, Subtable);
1949 break;
1950
1951 case ACPI_TPM2_START_METHOD:
1952 case ACPI_TPM2_MEMORY_MAPPED:
1953 case ACPI_TPM2_COMMAND_BUFFER:
1954 case ACPI_TPM2_COMMAND_BUFFER_WITH_START_METHOD:
1955 break;
1956
1957 case ACPI_TPM2_RESERVED1:
1958 case ACPI_TPM2_RESERVED3:
1959 case ACPI_TPM2_RESERVED4:
1960 case ACPI_TPM2_RESERVED5:
1961 case ACPI_TPM2_RESERVED9:
1962 case ACPI_TPM2_RESERVED10:
1963
1964 AcpiOsPrintf ("\n**** Reserved TPM2 Start Method type 0x%X\n",
1965 Tpm2Header->StartMethod);
1966 Status = AE_ERROR;
1967 break;
1968
1969 case ACPI_TPM2_NOT_ALLOWED:
1970 default:
1971
1972 AcpiOsPrintf ("\n**** Unknown TPM2 Start Method type 0x%X\n",
1973 Tpm2Header->StartMethod);
1974 Status = AE_ERROR;
1975 break;
1976 }
1977
1978 return (Status);
1979 }
1980
1981
1982 /******************************************************************************
1983 *
1984 * FUNCTION: DtGetGenericTableInfo
1985 *
1986 * PARAMETERS: Name - Generic type name
1987 *
1988 * RETURN: Info entry
1989 *
1990 * DESCRIPTION: Obtain table info for a generic name entry
1991 *
1992 *****************************************************************************/
1993
1994 ACPI_DMTABLE_INFO *
DtGetGenericTableInfo(char * Name)1995 DtGetGenericTableInfo (
1996 char *Name)
1997 {
1998 ACPI_DMTABLE_INFO *Info;
1999 UINT32 i;
2000
2001
2002 if (!Name)
2003 {
2004 return (NULL);
2005 }
2006
2007 /* Search info table for name match */
2008
2009 for (i = 0; ; i++)
2010 {
2011 Info = AcpiDmTableInfoGeneric[i];
2012 if (Info->Opcode == ACPI_DMT_EXIT)
2013 {
2014 Info = NULL;
2015 break;
2016 }
2017
2018 /* Use caseless compare for generic keywords */
2019
2020 if (!AcpiUtStricmp (Name, Info->Name))
2021 {
2022 break;
2023 }
2024 }
2025
2026 return (Info);
2027 }
2028
2029
2030 /******************************************************************************
2031 *
2032 * FUNCTION: DtCompileUefi
2033 *
2034 * PARAMETERS: List - Current field list pointer
2035 *
2036 * RETURN: Status
2037 *
2038 * DESCRIPTION: Compile UEFI.
2039 *
2040 *****************************************************************************/
2041
2042 ACPI_STATUS
DtCompileUefi(void ** List)2043 DtCompileUefi (
2044 void **List)
2045 {
2046 ACPI_STATUS Status;
2047 DT_SUBTABLE *Subtable;
2048 DT_SUBTABLE *ParentTable;
2049 DT_FIELD **PFieldList = (DT_FIELD **) List;
2050 UINT16 *DataOffset;
2051
2052
2053 /* Compile the predefined portion of the UEFI table */
2054
2055 Status = DtCompileTable (PFieldList, AcpiDmTableInfoUefi,
2056 &Subtable);
2057 if (ACPI_FAILURE (Status))
2058 {
2059 return (Status);
2060 }
2061
2062 DataOffset = (UINT16 *) (Subtable->Buffer + 16);
2063 *DataOffset = sizeof (ACPI_TABLE_UEFI);
2064
2065 ParentTable = DtPeekSubtable ();
2066 DtInsertSubtable (ParentTable, Subtable);
2067
2068 /*
2069 * Compile the "generic" portion of the UEFI table. This
2070 * part of the table is not predefined and any of the generic
2071 * operators may be used.
2072 */
2073 DtCompileGeneric ((void **) PFieldList, NULL, NULL);
2074 return (AE_OK);
2075 }
2076
2077
2078 /******************************************************************************
2079 *
2080 * FUNCTION: DtCompileVrtc
2081 *
2082 * PARAMETERS: List - Current field list pointer
2083 *
2084 * RETURN: Status
2085 *
2086 * DESCRIPTION: Compile VRTC.
2087 *
2088 *****************************************************************************/
2089
2090 ACPI_STATUS
DtCompileVrtc(void ** List)2091 DtCompileVrtc (
2092 void **List)
2093 {
2094 ACPI_STATUS Status;
2095
2096
2097 Status = DtCompileTwoSubtables (List,
2098 AcpiDmTableInfoVrtc, AcpiDmTableInfoVrtc0);
2099 return (Status);
2100 }
2101
2102
2103 /******************************************************************************
2104 *
2105 * FUNCTION: DtCompileWdat
2106 *
2107 * PARAMETERS: List - Current field list pointer
2108 *
2109 * RETURN: Status
2110 *
2111 * DESCRIPTION: Compile WDAT.
2112 *
2113 *****************************************************************************/
2114
2115 ACPI_STATUS
DtCompileWdat(void ** List)2116 DtCompileWdat (
2117 void **List)
2118 {
2119 ACPI_STATUS Status;
2120
2121
2122 Status = DtCompileTwoSubtables (List,
2123 AcpiDmTableInfoWdat, AcpiDmTableInfoWdat0);
2124 return (Status);
2125 }
2126
2127
2128 /******************************************************************************
2129 *
2130 * FUNCTION: DtCompileWpbt
2131 *
2132 * PARAMETERS: List - Current field list pointer
2133 *
2134 * RETURN: Status
2135 *
2136 * DESCRIPTION: Compile WPBT.
2137 *
2138 *****************************************************************************/
2139
2140 ACPI_STATUS
DtCompileWpbt(void ** List)2141 DtCompileWpbt (
2142 void **List)
2143 {
2144 DT_FIELD **PFieldList = (DT_FIELD **) List;
2145 DT_SUBTABLE *Subtable;
2146 DT_SUBTABLE *ParentTable;
2147 ACPI_TABLE_WPBT *Table;
2148 ACPI_STATUS Status;
2149 UINT16 Length;
2150
2151
2152 /* Compile the main table */
2153
2154 Status = DtCompileTable (PFieldList, AcpiDmTableInfoWpbt,
2155 &Subtable);
2156 if (ACPI_FAILURE (Status))
2157 {
2158 return (Status);
2159 }
2160
2161 ParentTable = DtPeekSubtable ();
2162 DtInsertSubtable (ParentTable, Subtable);
2163
2164 /* Compile the argument list subtable */
2165
2166 Status = DtCompileTable (PFieldList, AcpiDmTableInfoWpbt0,
2167 &Subtable);
2168 if (ACPI_FAILURE (Status))
2169 {
2170 return (Status);
2171 }
2172
2173 /* Extract the length of the Arguments buffer, insert into main table */
2174
2175 Length = (UINT16) Subtable->TotalLength;
2176 Table = ACPI_CAST_PTR (ACPI_TABLE_WPBT, ParentTable->Buffer);
2177 Table->ArgumentsLength = Length;
2178
2179 ParentTable = DtPeekSubtable ();
2180 DtInsertSubtable (ParentTable, Subtable);
2181 return (AE_OK);
2182 }
2183
2184
2185 /******************************************************************************
2186 *
2187 * FUNCTION: DtCompileXsdt
2188 *
2189 * PARAMETERS: List - Current field list pointer
2190 *
2191 * RETURN: Status
2192 *
2193 * DESCRIPTION: Compile XSDT.
2194 *
2195 *****************************************************************************/
2196
2197 ACPI_STATUS
DtCompileXsdt(void ** List)2198 DtCompileXsdt (
2199 void **List)
2200 {
2201 DT_SUBTABLE *Subtable;
2202 DT_SUBTABLE *ParentTable;
2203 DT_FIELD *FieldList = *(DT_FIELD **) List;
2204 UINT64 Address;
2205
2206
2207 ParentTable = DtPeekSubtable ();
2208
2209 while (FieldList)
2210 {
2211 DtCompileInteger ((UINT8 *) &Address, FieldList, 8, DT_NON_ZERO);
2212
2213 DtCreateSubtable ((UINT8 *) &Address, 8, &Subtable);
2214 DtInsertSubtable (ParentTable, Subtable);
2215 FieldList = FieldList->Next;
2216 }
2217
2218 return (AE_OK);
2219 }
2220
2221
2222 /******************************************************************************
2223 *
2224 * FUNCTION: DtCompileGeneric
2225 *
2226 * PARAMETERS: List - Current field list pointer
2227 * Name - Field name to end generic compiling
2228 * Length - Compiled table length to return
2229 *
2230 * RETURN: Status
2231 *
2232 * DESCRIPTION: Compile generic unknown table.
2233 *
2234 *****************************************************************************/
2235
2236 ACPI_STATUS
DtCompileGeneric(void ** List,char * Name,UINT32 * Length)2237 DtCompileGeneric (
2238 void **List,
2239 char *Name,
2240 UINT32 *Length)
2241 {
2242 ACPI_STATUS Status;
2243 DT_SUBTABLE *Subtable;
2244 DT_SUBTABLE *ParentTable;
2245 DT_FIELD **PFieldList = (DT_FIELD **) List;
2246 ACPI_DMTABLE_INFO *Info;
2247
2248
2249 ParentTable = DtPeekSubtable ();
2250
2251 /*
2252 * Compile the "generic" portion of the table. This
2253 * part of the table is not predefined and any of the generic
2254 * operators may be used.
2255 */
2256
2257 /* Find any and all labels in the entire generic portion */
2258
2259 DtDetectAllLabels (*PFieldList);
2260
2261 /* Now we can actually compile the parse tree */
2262
2263 if (Length && *Length)
2264 {
2265 *Length = 0;
2266 }
2267 while (*PFieldList)
2268 {
2269 if (Name && !strcmp ((*PFieldList)->Name, Name))
2270 {
2271 break;
2272 }
2273
2274 Info = DtGetGenericTableInfo ((*PFieldList)->Name);
2275 if (!Info)
2276 {
2277 sprintf (MsgBuffer, "Generic data type \"%s\" not found",
2278 (*PFieldList)->Name);
2279 DtNameError (ASL_ERROR, ASL_MSG_INVALID_FIELD_NAME,
2280 (*PFieldList), MsgBuffer);
2281
2282 *PFieldList = (*PFieldList)->Next;
2283 continue;
2284 }
2285
2286 Status = DtCompileTable (PFieldList, Info,
2287 &Subtable);
2288 if (ACPI_SUCCESS (Status))
2289 {
2290 DtInsertSubtable (ParentTable, Subtable);
2291 if (Length)
2292 {
2293 *Length += Subtable->Length;
2294 }
2295 }
2296 else
2297 {
2298 *PFieldList = (*PFieldList)->Next;
2299
2300 if (Status == AE_NOT_FOUND)
2301 {
2302 sprintf (MsgBuffer, "Generic data type \"%s\" not found",
2303 (*PFieldList)->Name);
2304 DtNameError (ASL_ERROR, ASL_MSG_INVALID_FIELD_NAME,
2305 (*PFieldList), MsgBuffer);
2306 }
2307 }
2308 }
2309
2310 return (AE_OK);
2311 }
2312