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 - 2020, 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 <contrib/dev/acpica/compiler/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 &AslGbl_RootTable);
1292 if (ACPI_FAILURE (Status))
1293 {
1294 return (Status);
1295 }
1296
1297 DtPushSubtable (AslGbl_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 /* Final size of entire namespace structure */
1479
1480 SdevHeader->Length = (UINT16)(sizeof(ACPI_SDEV_NAMESPACE) +
1481 Subtable->Length + Namesp->DeviceIdLength);
1482 }
1483 }
1484
1485 break;
1486
1487 case ACPI_SDEV_TYPE_PCIE_ENDPOINT_DEVICE:
1488
1489 /* Append the PCIe path info first */
1490
1491 EntryCount = 0;
1492 while (*PFieldList && !strcmp ((*PFieldList)->Name, "Device"))
1493 {
1494 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSdev1a,
1495 &Subtable);
1496 if (ACPI_FAILURE (Status))
1497 {
1498 return (Status);
1499 }
1500
1501 if (!Subtable)
1502 {
1503 DtPopSubtable ();
1504 break;
1505 }
1506
1507 ParentTable = DtPeekSubtable ();
1508 DtInsertSubtable (ParentTable, Subtable);
1509 EntryCount++;
1510 }
1511
1512 /* Path offset will point immediately after the main subtable */
1513
1514 Pcie->PathOffset = sizeof (ACPI_SDEV_PCIE);
1515 Pcie->PathLength = (UINT16)
1516 (EntryCount * sizeof (ACPI_SDEV_PCIE_PATH));
1517
1518 /* Append the Vendor Data last */
1519
1520 Pcie->VendorDataLength = 0;
1521 Pcie->VendorDataOffset = 0;
1522
1523 if (*PFieldList)
1524 {
1525 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSdev1b,
1526 &Subtable);
1527 if (ACPI_FAILURE (Status))
1528 {
1529 return (Status);
1530 }
1531
1532 if (Subtable)
1533 {
1534 ParentTable = DtPeekSubtable ();
1535 DtInsertSubtable (ParentTable, Subtable);
1536
1537 Pcie->VendorDataOffset =
1538 Pcie->PathOffset + Pcie->PathLength;
1539 Pcie->VendorDataLength = (UINT16)
1540 Subtable->Length;
1541 }
1542 }
1543
1544 SdevHeader->Length =
1545 sizeof (ACPI_SDEV_PCIE) +
1546 Pcie->PathLength + Pcie->VendorDataLength;
1547 break;
1548
1549 default:
1550
1551 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "SDEV");
1552 return (AE_ERROR);
1553 }
1554
1555 DtPopSubtable ();
1556 }
1557
1558 return (AE_OK);
1559 }
1560
1561
1562 /******************************************************************************
1563 *
1564 * FUNCTION: DtCompileSlic
1565 *
1566 * PARAMETERS: List - Current field list pointer
1567 *
1568 * RETURN: Status
1569 *
1570 * DESCRIPTION: Compile SLIC.
1571 *
1572 *****************************************************************************/
1573
1574 ACPI_STATUS
DtCompileSlic(void ** List)1575 DtCompileSlic (
1576 void **List)
1577 {
1578 ACPI_STATUS Status;
1579 DT_SUBTABLE *Subtable;
1580 DT_SUBTABLE *ParentTable;
1581 DT_FIELD **PFieldList = (DT_FIELD **) List;
1582
1583
1584 while (*PFieldList)
1585 {
1586 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSlic,
1587 &Subtable);
1588 if (ACPI_FAILURE (Status))
1589 {
1590 return (Status);
1591 }
1592
1593 ParentTable = DtPeekSubtable ();
1594 DtInsertSubtable (ParentTable, Subtable);
1595 DtPushSubtable (Subtable);
1596 DtPopSubtable ();
1597 }
1598
1599 return (AE_OK);
1600 }
1601
1602
1603 /******************************************************************************
1604 *
1605 * FUNCTION: DtCompileSlit
1606 *
1607 * PARAMETERS: List - Current field list pointer
1608 *
1609 * RETURN: Status
1610 *
1611 * DESCRIPTION: Compile SLIT.
1612 *
1613 *****************************************************************************/
1614
1615 ACPI_STATUS
DtCompileSlit(void ** List)1616 DtCompileSlit (
1617 void **List)
1618 {
1619 ACPI_STATUS Status;
1620 DT_SUBTABLE *Subtable;
1621 DT_SUBTABLE *ParentTable;
1622 DT_FIELD **PFieldList = (DT_FIELD **) List;
1623 DT_FIELD *FieldList;
1624 DT_FIELD *EndOfFieldList = NULL;
1625 UINT32 Localities;
1626 UINT32 LocalityListLength;
1627 UINT8 *LocalityBuffer;
1628
1629
1630 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSlit,
1631 &Subtable);
1632 if (ACPI_FAILURE (Status))
1633 {
1634 return (Status);
1635 }
1636
1637 ParentTable = DtPeekSubtable ();
1638 DtInsertSubtable (ParentTable, Subtable);
1639
1640 Localities = *ACPI_CAST_PTR (UINT32, Subtable->Buffer);
1641 LocalityBuffer = UtLocalCalloc (Localities);
1642 LocalityListLength = 0;
1643
1644 /* Compile each locality buffer */
1645
1646 FieldList = *PFieldList;
1647 while (FieldList)
1648 {
1649 DtCompileBuffer (LocalityBuffer,
1650 FieldList->Value, FieldList, Localities);
1651
1652 LocalityListLength++;
1653 DtCreateSubtable (LocalityBuffer, Localities, &Subtable);
1654 DtInsertSubtable (ParentTable, Subtable);
1655 EndOfFieldList = FieldList;
1656 FieldList = FieldList->Next;
1657 }
1658
1659 if (LocalityListLength != Localities)
1660 {
1661 sprintf(AslGbl_MsgBuffer,
1662 "Found %u entries, must match LocalityCount: %u",
1663 LocalityListLength, Localities);
1664 DtError (ASL_ERROR, ASL_MSG_ENTRY_LIST, EndOfFieldList, AslGbl_MsgBuffer);
1665 ACPI_FREE (LocalityBuffer);
1666 return (AE_LIMIT);
1667 }
1668
1669 ACPI_FREE (LocalityBuffer);
1670 return (AE_OK);
1671 }
1672
1673
1674 /******************************************************************************
1675 *
1676 * FUNCTION: DtCompileSrat
1677 *
1678 * PARAMETERS: List - Current field list pointer
1679 *
1680 * RETURN: Status
1681 *
1682 * DESCRIPTION: Compile SRAT.
1683 *
1684 *****************************************************************************/
1685
1686 ACPI_STATUS
DtCompileSrat(void ** List)1687 DtCompileSrat (
1688 void **List)
1689 {
1690 ACPI_STATUS Status;
1691 DT_SUBTABLE *Subtable;
1692 DT_SUBTABLE *ParentTable;
1693 DT_FIELD **PFieldList = (DT_FIELD **) List;
1694 DT_FIELD *SubtableStart;
1695 ACPI_SUBTABLE_HEADER *SratHeader;
1696 ACPI_DMTABLE_INFO *InfoTable;
1697
1698
1699 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSrat,
1700 &Subtable);
1701 if (ACPI_FAILURE (Status))
1702 {
1703 return (Status);
1704 }
1705
1706 ParentTable = DtPeekSubtable ();
1707 DtInsertSubtable (ParentTable, Subtable);
1708
1709 while (*PFieldList)
1710 {
1711 SubtableStart = *PFieldList;
1712 Status = DtCompileTable (PFieldList, AcpiDmTableInfoSratHdr,
1713 &Subtable);
1714 if (ACPI_FAILURE (Status))
1715 {
1716 return (Status);
1717 }
1718
1719 ParentTable = DtPeekSubtable ();
1720 DtInsertSubtable (ParentTable, Subtable);
1721 DtPushSubtable (Subtable);
1722
1723 SratHeader = ACPI_CAST_PTR (ACPI_SUBTABLE_HEADER, Subtable->Buffer);
1724
1725 switch (SratHeader->Type)
1726 {
1727 case ACPI_SRAT_TYPE_CPU_AFFINITY:
1728
1729 InfoTable = AcpiDmTableInfoSrat0;
1730 break;
1731
1732 case ACPI_SRAT_TYPE_MEMORY_AFFINITY:
1733
1734 InfoTable = AcpiDmTableInfoSrat1;
1735 break;
1736
1737 case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY:
1738
1739 InfoTable = AcpiDmTableInfoSrat2;
1740 break;
1741
1742 case ACPI_SRAT_TYPE_GICC_AFFINITY:
1743
1744 InfoTable = AcpiDmTableInfoSrat3;
1745 break;
1746
1747 case ACPI_SRAT_TYPE_GIC_ITS_AFFINITY:
1748
1749 InfoTable = AcpiDmTableInfoSrat4;
1750 break;
1751
1752 case ACPI_SRAT_TYPE_GENERIC_AFFINITY:
1753
1754 InfoTable = AcpiDmTableInfoSrat5;
1755 break;
1756
1757 default:
1758
1759 DtFatal (ASL_MSG_UNKNOWN_SUBTABLE, SubtableStart, "SRAT");
1760 return (AE_ERROR);
1761 }
1762
1763 Status = DtCompileTable (PFieldList, InfoTable, &Subtable);
1764 if (ACPI_FAILURE (Status))
1765 {
1766 return (Status);
1767 }
1768
1769 ParentTable = DtPeekSubtable ();
1770 DtInsertSubtable (ParentTable, Subtable);
1771 DtPopSubtable ();
1772 }
1773
1774 return (AE_OK);
1775 }
1776
1777
1778 /******************************************************************************
1779 *
1780 * FUNCTION: DtCompileStao
1781 *
1782 * PARAMETERS: PFieldList - Current field list pointer
1783 *
1784 * RETURN: Status
1785 *
1786 * DESCRIPTION: Compile STAO.
1787 *
1788 *****************************************************************************/
1789
1790 ACPI_STATUS
DtCompileStao(void ** List)1791 DtCompileStao (
1792 void **List)
1793 {
1794 DT_FIELD **PFieldList = (DT_FIELD **) List;
1795 DT_SUBTABLE *Subtable;
1796 DT_SUBTABLE *ParentTable;
1797 ACPI_STATUS Status;
1798
1799
1800 /* Compile the main table */
1801
1802 Status = DtCompileTable (PFieldList, AcpiDmTableInfoStao,
1803 &Subtable);
1804 if (ACPI_FAILURE (Status))
1805 {
1806 return (Status);
1807 }
1808
1809 ParentTable = DtPeekSubtable ();
1810 DtInsertSubtable (ParentTable, Subtable);
1811
1812 /* Compile each ASCII namestring as a subtable */
1813
1814 while (*PFieldList)
1815 {
1816 Status = DtCompileTable (PFieldList, AcpiDmTableInfoStaoStr,
1817 &Subtable);
1818 if (ACPI_FAILURE (Status))
1819 {
1820 return (Status);
1821 }
1822
1823 ParentTable = DtPeekSubtable ();
1824 DtInsertSubtable (ParentTable, Subtable);
1825 }
1826
1827 return (AE_OK);
1828 }
1829
1830
1831 /******************************************************************************
1832 *
1833 * FUNCTION: DtCompileTcpa
1834 *
1835 * PARAMETERS: PFieldList - Current field list pointer
1836 *
1837 * RETURN: Status
1838 *
1839 * DESCRIPTION: Compile TCPA.
1840 *
1841 *****************************************************************************/
1842
1843 ACPI_STATUS
DtCompileTcpa(void ** List)1844 DtCompileTcpa (
1845 void **List)
1846 {
1847 DT_FIELD **PFieldList = (DT_FIELD **) List;
1848 DT_SUBTABLE *Subtable;
1849 ACPI_TABLE_TCPA_HDR *TcpaHeader;
1850 DT_SUBTABLE *ParentTable;
1851 ACPI_STATUS Status;
1852
1853
1854 /* Compile the main table */
1855
1856 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaHdr,
1857 &Subtable);
1858 if (ACPI_FAILURE (Status))
1859 {
1860 return (Status);
1861 }
1862
1863 ParentTable = DtPeekSubtable ();
1864 DtInsertSubtable (ParentTable, Subtable);
1865
1866 /*
1867 * Examine the PlatformClass field to determine the table type.
1868 * Either a client or server table. Only one.
1869 */
1870 TcpaHeader = ACPI_CAST_PTR (ACPI_TABLE_TCPA_HDR, ParentTable->Buffer);
1871
1872 switch (TcpaHeader->PlatformClass)
1873 {
1874 case ACPI_TCPA_CLIENT_TABLE:
1875
1876 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaClient,
1877 &Subtable);
1878 break;
1879
1880 case ACPI_TCPA_SERVER_TABLE:
1881
1882 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTcpaServer,
1883 &Subtable);
1884 break;
1885
1886 default:
1887
1888 AcpiOsPrintf ("\n**** Unknown TCPA Platform Class 0x%X\n",
1889 TcpaHeader->PlatformClass);
1890 Status = AE_ERROR;
1891 break;
1892 }
1893
1894 ParentTable = DtPeekSubtable ();
1895 DtInsertSubtable (ParentTable, Subtable);
1896 return (Status);
1897 }
1898
1899
1900 /******************************************************************************
1901 *
1902 * FUNCTION: DtCompileTpm2Rev3
1903 *
1904 * PARAMETERS: PFieldList - Current field list pointer
1905 *
1906 * RETURN: Status
1907 *
1908 * DESCRIPTION: Compile TPM2 revision 3
1909 *
1910 *****************************************************************************/
1911 static ACPI_STATUS
DtCompileTpm2Rev3(void ** List)1912 DtCompileTpm2Rev3 (
1913 void **List)
1914 {
1915 DT_FIELD **PFieldList = (DT_FIELD **) List;
1916 DT_SUBTABLE *Subtable;
1917 ACPI_TABLE_TPM23 *Tpm23Header;
1918 DT_SUBTABLE *ParentTable;
1919 ACPI_STATUS Status = AE_OK;
1920
1921
1922 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTpm23,
1923 &Subtable);
1924
1925 ParentTable = DtPeekSubtable ();
1926 DtInsertSubtable (ParentTable, Subtable);
1927 Tpm23Header = ACPI_CAST_PTR (ACPI_TABLE_TPM23, ParentTable->Buffer);
1928
1929 /* Subtable type depends on the StartMethod */
1930
1931 switch (Tpm23Header->StartMethod)
1932 {
1933 case ACPI_TPM23_ACPI_START_METHOD:
1934
1935 /* Subtable specific to to ARM_SMC */
1936
1937 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTpm23a,
1938 &Subtable);
1939 if (ACPI_FAILURE (Status))
1940 {
1941 return (Status);
1942 }
1943
1944 ParentTable = DtPeekSubtable ();
1945 DtInsertSubtable (ParentTable, Subtable);
1946 break;
1947
1948 default:
1949 break;
1950 }
1951
1952 return (Status);
1953 }
1954
1955
1956 /******************************************************************************
1957 *
1958 * FUNCTION: DtCompileTpm2
1959 *
1960 * PARAMETERS: PFieldList - Current field list pointer
1961 *
1962 * RETURN: Status
1963 *
1964 * DESCRIPTION: Compile TPM2.
1965 *
1966 *****************************************************************************/
1967
1968 ACPI_STATUS
DtCompileTpm2(void ** List)1969 DtCompileTpm2 (
1970 void **List)
1971 {
1972 DT_FIELD **PFieldList = (DT_FIELD **) List;
1973 DT_SUBTABLE *Subtable;
1974 ACPI_TABLE_TPM2 *Tpm2Header;
1975 DT_SUBTABLE *ParentTable;
1976 ACPI_STATUS Status = AE_OK;
1977 ACPI_TABLE_HEADER *Header;
1978
1979
1980 ParentTable = DtPeekSubtable ();
1981
1982 Header = ACPI_CAST_PTR (ACPI_TABLE_HEADER, ParentTable->Buffer);
1983
1984 if (Header->Revision == 3)
1985 {
1986 return (DtCompileTpm2Rev3 (List));
1987 }
1988
1989 /* Compile the main table */
1990
1991 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTpm2,
1992 &Subtable);
1993 if (ACPI_FAILURE (Status))
1994 {
1995 return (Status);
1996 }
1997
1998 ParentTable = DtPeekSubtable ();
1999 DtInsertSubtable (ParentTable, Subtable);
2000
2001 Tpm2Header = ACPI_CAST_PTR (ACPI_TABLE_TPM2, ParentTable->Buffer);
2002
2003 /* Method parameters */
2004 /* Optional: Log area minimum length */
2005 /* Optional: Log area start address */
2006 /* TBD: Optional fields above not fully implemented (not optional at this time) */
2007
2008 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTpm2a,
2009 &Subtable);
2010 if (ACPI_FAILURE (Status))
2011 {
2012 return (Status);
2013 }
2014
2015 ParentTable = DtPeekSubtable ();
2016 DtInsertSubtable (ParentTable, Subtable);
2017
2018
2019 /* Subtable type depends on the StartMethod */
2020
2021 switch (Tpm2Header->StartMethod)
2022 {
2023 case ACPI_TPM2_COMMAND_BUFFER_WITH_ARM_SMC:
2024
2025 /* Subtable specific to to ARM_SMC */
2026
2027 Status = DtCompileTable (PFieldList, AcpiDmTableInfoTpm211,
2028 &Subtable);
2029 if (ACPI_FAILURE (Status))
2030 {
2031 return (Status);
2032 }
2033
2034 ParentTable = DtPeekSubtable ();
2035 DtInsertSubtable (ParentTable, Subtable);
2036 break;
2037
2038 case ACPI_TPM2_START_METHOD:
2039 case ACPI_TPM2_MEMORY_MAPPED:
2040 case ACPI_TPM2_COMMAND_BUFFER:
2041 case ACPI_TPM2_COMMAND_BUFFER_WITH_START_METHOD:
2042 break;
2043
2044 case ACPI_TPM2_RESERVED1:
2045 case ACPI_TPM2_RESERVED3:
2046 case ACPI_TPM2_RESERVED4:
2047 case ACPI_TPM2_RESERVED5:
2048 case ACPI_TPM2_RESERVED9:
2049 case ACPI_TPM2_RESERVED10:
2050
2051 AcpiOsPrintf ("\n**** Reserved TPM2 Start Method type 0x%X\n",
2052 Tpm2Header->StartMethod);
2053 Status = AE_ERROR;
2054 break;
2055
2056 case ACPI_TPM2_NOT_ALLOWED:
2057 default:
2058
2059 AcpiOsPrintf ("\n**** Unknown TPM2 Start Method type 0x%X\n",
2060 Tpm2Header->StartMethod);
2061 Status = AE_ERROR;
2062 break;
2063 }
2064
2065 return (Status);
2066 }
2067
2068
2069 /******************************************************************************
2070 *
2071 * FUNCTION: DtGetGenericTableInfo
2072 *
2073 * PARAMETERS: Name - Generic type name
2074 *
2075 * RETURN: Info entry
2076 *
2077 * DESCRIPTION: Obtain table info for a generic name entry
2078 *
2079 *****************************************************************************/
2080
2081 ACPI_DMTABLE_INFO *
DtGetGenericTableInfo(char * Name)2082 DtGetGenericTableInfo (
2083 char *Name)
2084 {
2085 ACPI_DMTABLE_INFO *Info;
2086 UINT32 i;
2087
2088
2089 if (!Name)
2090 {
2091 return (NULL);
2092 }
2093
2094 /* Search info table for name match */
2095
2096 for (i = 0; ; i++)
2097 {
2098 Info = AcpiDmTableInfoGeneric[i];
2099 if (Info->Opcode == ACPI_DMT_EXIT)
2100 {
2101 Info = NULL;
2102 break;
2103 }
2104
2105 /* Use caseless compare for generic keywords */
2106
2107 if (!AcpiUtStricmp (Name, Info->Name))
2108 {
2109 break;
2110 }
2111 }
2112
2113 return (Info);
2114 }
2115
2116
2117 /******************************************************************************
2118 *
2119 * FUNCTION: DtCompileUefi
2120 *
2121 * PARAMETERS: List - Current field list pointer
2122 *
2123 * RETURN: Status
2124 *
2125 * DESCRIPTION: Compile UEFI.
2126 *
2127 *****************************************************************************/
2128
2129 ACPI_STATUS
DtCompileUefi(void ** List)2130 DtCompileUefi (
2131 void **List)
2132 {
2133 ACPI_STATUS Status;
2134 DT_SUBTABLE *Subtable;
2135 DT_SUBTABLE *ParentTable;
2136 DT_FIELD **PFieldList = (DT_FIELD **) List;
2137 UINT16 *DataOffset;
2138
2139
2140 /* Compile the predefined portion of the UEFI table */
2141
2142 Status = DtCompileTable (PFieldList, AcpiDmTableInfoUefi,
2143 &Subtable);
2144 if (ACPI_FAILURE (Status))
2145 {
2146 return (Status);
2147 }
2148
2149 DataOffset = (UINT16 *) (Subtable->Buffer + 16);
2150 *DataOffset = sizeof (ACPI_TABLE_UEFI);
2151
2152 ParentTable = DtPeekSubtable ();
2153 DtInsertSubtable (ParentTable, Subtable);
2154
2155 /*
2156 * Compile the "generic" portion of the UEFI table. This
2157 * part of the table is not predefined and any of the generic
2158 * operators may be used.
2159 */
2160 DtCompileGeneric ((void **) PFieldList, NULL, NULL);
2161 return (AE_OK);
2162 }
2163
2164
2165 /******************************************************************************
2166 *
2167 * FUNCTION: DtCompileVrtc
2168 *
2169 * PARAMETERS: List - Current field list pointer
2170 *
2171 * RETURN: Status
2172 *
2173 * DESCRIPTION: Compile VRTC.
2174 *
2175 *****************************************************************************/
2176
2177 ACPI_STATUS
DtCompileVrtc(void ** List)2178 DtCompileVrtc (
2179 void **List)
2180 {
2181 ACPI_STATUS Status;
2182
2183
2184 Status = DtCompileTwoSubtables (List,
2185 AcpiDmTableInfoVrtc, AcpiDmTableInfoVrtc0);
2186 return (Status);
2187 }
2188
2189
2190 /******************************************************************************
2191 *
2192 * FUNCTION: DtCompileWdat
2193 *
2194 * PARAMETERS: List - Current field list pointer
2195 *
2196 * RETURN: Status
2197 *
2198 * DESCRIPTION: Compile WDAT.
2199 *
2200 *****************************************************************************/
2201
2202 ACPI_STATUS
DtCompileWdat(void ** List)2203 DtCompileWdat (
2204 void **List)
2205 {
2206 ACPI_STATUS Status;
2207
2208
2209 Status = DtCompileTwoSubtables (List,
2210 AcpiDmTableInfoWdat, AcpiDmTableInfoWdat0);
2211 return (Status);
2212 }
2213
2214
2215 /******************************************************************************
2216 *
2217 * FUNCTION: DtCompileWpbt
2218 *
2219 * PARAMETERS: List - Current field list pointer
2220 *
2221 * RETURN: Status
2222 *
2223 * DESCRIPTION: Compile WPBT.
2224 *
2225 *****************************************************************************/
2226
2227 ACPI_STATUS
DtCompileWpbt(void ** List)2228 DtCompileWpbt (
2229 void **List)
2230 {
2231 DT_FIELD **PFieldList = (DT_FIELD **) List;
2232 DT_SUBTABLE *Subtable;
2233 DT_SUBTABLE *ParentTable;
2234 ACPI_TABLE_WPBT *Table;
2235 ACPI_STATUS Status;
2236 UINT16 Length;
2237
2238
2239 /* Compile the main table */
2240
2241 Status = DtCompileTable (PFieldList, AcpiDmTableInfoWpbt,
2242 &Subtable);
2243 if (ACPI_FAILURE (Status))
2244 {
2245 return (Status);
2246 }
2247
2248 ParentTable = DtPeekSubtable ();
2249 DtInsertSubtable (ParentTable, Subtable);
2250
2251 /* Compile the argument list subtable */
2252
2253 Status = DtCompileTable (PFieldList, AcpiDmTableInfoWpbt0,
2254 &Subtable);
2255 if (ACPI_FAILURE (Status))
2256 {
2257 return (Status);
2258 }
2259
2260 /* Extract the length of the Arguments buffer, insert into main table */
2261
2262 Length = (UINT16) Subtable->TotalLength;
2263 Table = ACPI_CAST_PTR (ACPI_TABLE_WPBT, ParentTable->Buffer);
2264 Table->ArgumentsLength = Length;
2265
2266 ParentTable = DtPeekSubtable ();
2267 DtInsertSubtable (ParentTable, Subtable);
2268 return (AE_OK);
2269 }
2270
2271
2272 /******************************************************************************
2273 *
2274 * FUNCTION: DtCompileXsdt
2275 *
2276 * PARAMETERS: List - Current field list pointer
2277 *
2278 * RETURN: Status
2279 *
2280 * DESCRIPTION: Compile XSDT.
2281 *
2282 *****************************************************************************/
2283
2284 ACPI_STATUS
DtCompileXsdt(void ** List)2285 DtCompileXsdt (
2286 void **List)
2287 {
2288 DT_SUBTABLE *Subtable;
2289 DT_SUBTABLE *ParentTable;
2290 DT_FIELD *FieldList = *(DT_FIELD **) List;
2291 UINT64 Address;
2292
2293
2294 ParentTable = DtPeekSubtable ();
2295
2296 while (FieldList)
2297 {
2298 DtCompileInteger ((UINT8 *) &Address, FieldList, 8, DT_NON_ZERO);
2299
2300 DtCreateSubtable ((UINT8 *) &Address, 8, &Subtable);
2301 DtInsertSubtable (ParentTable, Subtable);
2302 FieldList = FieldList->Next;
2303 }
2304
2305 return (AE_OK);
2306 }
2307
2308
2309 /******************************************************************************
2310 *
2311 * FUNCTION: DtCompileGeneric
2312 *
2313 * PARAMETERS: List - Current field list pointer
2314 * Name - Field name to end generic compiling
2315 * Length - Compiled table length to return
2316 *
2317 * RETURN: Status
2318 *
2319 * DESCRIPTION: Compile generic unknown table.
2320 *
2321 *****************************************************************************/
2322
2323 ACPI_STATUS
DtCompileGeneric(void ** List,char * Name,UINT32 * Length)2324 DtCompileGeneric (
2325 void **List,
2326 char *Name,
2327 UINT32 *Length)
2328 {
2329 ACPI_STATUS Status;
2330 DT_SUBTABLE *Subtable;
2331 DT_SUBTABLE *ParentTable;
2332 DT_FIELD **PFieldList = (DT_FIELD **) List;
2333 ACPI_DMTABLE_INFO *Info;
2334
2335
2336 ParentTable = DtPeekSubtable ();
2337
2338 /*
2339 * Compile the "generic" portion of the table. This
2340 * part of the table is not predefined and any of the generic
2341 * operators may be used.
2342 */
2343
2344 /* Find any and all labels in the entire generic portion */
2345
2346 DtDetectAllLabels (*PFieldList);
2347
2348 /* Now we can actually compile the parse tree */
2349
2350 if (Length && *Length)
2351 {
2352 *Length = 0;
2353 }
2354 while (*PFieldList)
2355 {
2356 if (Name && !strcmp ((*PFieldList)->Name, Name))
2357 {
2358 break;
2359 }
2360
2361 Info = DtGetGenericTableInfo ((*PFieldList)->Name);
2362 if (!Info)
2363 {
2364 sprintf (AslGbl_MsgBuffer, "Generic data type \"%s\" not found",
2365 (*PFieldList)->Name);
2366 DtNameError (ASL_ERROR, ASL_MSG_INVALID_FIELD_NAME,
2367 (*PFieldList), AslGbl_MsgBuffer);
2368
2369 *PFieldList = (*PFieldList)->Next;
2370 continue;
2371 }
2372
2373 Status = DtCompileTable (PFieldList, Info,
2374 &Subtable);
2375 if (ACPI_SUCCESS (Status))
2376 {
2377 DtInsertSubtable (ParentTable, Subtable);
2378 if (Length)
2379 {
2380 *Length += Subtable->Length;
2381 }
2382 }
2383 else
2384 {
2385 *PFieldList = (*PFieldList)->Next;
2386
2387 if (Status == AE_NOT_FOUND)
2388 {
2389 sprintf (AslGbl_MsgBuffer, "Generic data type \"%s\" not found",
2390 (*PFieldList)->Name);
2391 DtNameError (ASL_ERROR, ASL_MSG_INVALID_FIELD_NAME,
2392 (*PFieldList), AslGbl_MsgBuffer);
2393 }
2394 }
2395 }
2396
2397 return (AE_OK);
2398 }
2399