xref: /illumos-gate/usr/src/cmd/acpi/iasl/dtutils.c (revision fe73c3d85090a18528209704deee9a7e84f3b5c6)
1 /******************************************************************************
2  *
3  * Module Name: dtutils.c - Utility routines for the data table compiler
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 #include "aslcompiler.h"
153 #include "actables.h"
154 
155 #define _COMPONENT          DT_COMPILER
156         ACPI_MODULE_NAME    ("dtutils")
157 
158 /* Local prototypes */
159 
160 static void
161 DtSum (
162     DT_SUBTABLE             *Subtable,
163     void                    *Context,
164     void                    *ReturnValue);
165 
166 
167 /******************************************************************************
168  *
169  * FUNCTION:    DtError
170  *
171  * PARAMETERS:  Level               - Seriousness (Warning/error, etc.)
172  *              MessageId           - Index into global message buffer
173  *              Op                  - Parse node where error happened
174  *              ExtraMessage        - additional error message
175  *
176  * RETURN:      None
177  *
178  * DESCRIPTION: Common error interface for data table compiler
179  *
180  *****************************************************************************/
181 
182 void
183 DtError (
184     UINT8                   Level,
185     UINT16                  MessageId,
186     DT_FIELD                *FieldObject,
187     char                    *ExtraMessage)
188 {
189 
190     /* Check if user wants to ignore this exception */
191 
192     if (AslIsExceptionIgnored (Level, MessageId))
193     {
194         return;
195     }
196 
197     if (FieldObject)
198     {
199         AslCommonError (Level, MessageId,
200             FieldObject->Line,
201             FieldObject->Line,
202             FieldObject->ByteOffset,
203             FieldObject->Column,
204             Gbl_Files[ASL_FILE_INPUT].Filename, ExtraMessage);
205     }
206     else
207     {
208         AslCommonError (Level, MessageId, 0,
209             0, 0, 0, 0, ExtraMessage);
210     }
211 }
212 
213 
214 /******************************************************************************
215  *
216  * FUNCTION:    DtNameError
217  *
218  * PARAMETERS:  Level               - Seriousness (Warning/error, etc.)
219  *              MessageId           - Index into global message buffer
220  *              Op                  - Parse node where error happened
221  *              ExtraMessage        - additional error message
222  *
223  * RETURN:      None
224  *
225  * DESCRIPTION: Error interface for named objects
226  *
227  *****************************************************************************/
228 
229 void
230 DtNameError (
231     UINT8                   Level,
232     UINT16                  MessageId,
233     DT_FIELD                *FieldObject,
234     char                    *ExtraMessage)
235 {
236 
237     switch (Level)
238     {
239     case ASL_WARNING2:
240     case ASL_WARNING3:
241 
242         if (Gbl_WarningLevel < Level)
243         {
244             return;
245         }
246         break;
247 
248     default:
249 
250         break;
251     }
252 
253     if (FieldObject)
254     {
255         AslCommonError (Level, MessageId,
256             FieldObject->Line,
257             FieldObject->Line,
258             FieldObject->ByteOffset,
259             FieldObject->NameColumn,
260             Gbl_Files[ASL_FILE_INPUT].Filename, ExtraMessage);
261     }
262     else
263     {
264         AslCommonError (Level, MessageId, 0,
265             0, 0, 0, 0, ExtraMessage);
266     }
267 }
268 
269 
270 /*******************************************************************************
271  *
272  * FUNCTION:    DtFatal
273  *
274  * PARAMETERS:  None
275  *
276  * RETURN:      None
277  *
278  * DESCRIPTION: Dump the error log and abort the compiler. Used for serious
279  *              compile or I/O errors
280  *
281  ******************************************************************************/
282 
283 void
284 DtFatal (
285     UINT16                  MessageId,
286     DT_FIELD                *FieldObject,
287     char                    *ExtraMessage)
288 {
289 
290     DtError (ASL_ERROR, MessageId, FieldObject, ExtraMessage);
291 
292 /*
293  * TBD: remove this entire function, DtFatal
294  *
295  * We cannot abort the compiler on error, because we may be compiling a
296  * list of files. We must move on to the next file.
297  */
298 #ifdef __OBSOLETE
299     CmCleanupAndExit ();
300     exit (1);
301 #endif
302 }
303 
304 
305 /*******************************************************************************
306  *
307  * FUNCTION:    DtDoConstant
308  *
309  * PARAMETERS:  String              - Only hex constants are supported,
310  *                                    regardless of whether the 0x prefix
311  *                                    is used
312  *
313  * RETURN:      Converted Integer
314  *
315  * DESCRIPTION: Convert a string to an integer, with overflow/error checking.
316  *
317  ******************************************************************************/
318 
319 UINT64
320 DtDoConstant (
321     char                    *String)
322 {
323     UINT64                  ConvertedInteger;
324 
325 
326     /*
327      * TBD: The ImplicitStrtoul64 function does not report overflow
328      * conditions. The input string is simply truncated. If it is
329      * desired to report overflow to the table compiler, this should
330      * somehow be added here. Note: integers that are prefixed with 0x
331      * or not are both hex integers.
332      */
333     ConvertedInteger = AcpiUtImplicitStrtoul64 (String);
334     return (ConvertedInteger);
335 }
336 
337 /******************************************************************************
338  *
339  * FUNCTION:    DtGetFieldValue
340  *
341  * PARAMETERS:  Field               - Current field list pointer
342  *
343  * RETURN:      Field value
344  *
345  * DESCRIPTION: Get field value
346  *
347  *****************************************************************************/
348 
349 char *
350 DtGetFieldValue (
351     DT_FIELD                *Field)
352 {
353     if (!Field)
354     {
355         return (NULL);
356     }
357 
358     return (Field->Value);
359 }
360 
361 
362 /******************************************************************************
363  *
364  * FUNCTION:    DtGetFieldType
365  *
366  * PARAMETERS:  Info                - Data table info
367  *
368  * RETURN:      Field type
369  *
370  * DESCRIPTION: Get field type
371  *
372  *****************************************************************************/
373 
374 UINT8
375 DtGetFieldType (
376     ACPI_DMTABLE_INFO       *Info)
377 {
378     UINT8                   Type;
379 
380 
381     /* DT_FLAG means that this is the start of a block of flag bits */
382     /* TBD - we can make these a separate opcode later */
383 
384     if (Info->Flags & DT_FLAG)
385     {
386         return (DT_FIELD_TYPE_FLAGS_INTEGER);
387     }
388 
389     /* Type is based upon the opcode for this field in the info table */
390 
391     switch (Info->Opcode)
392     {
393     case ACPI_DMT_FLAG0:
394     case ACPI_DMT_FLAG1:
395     case ACPI_DMT_FLAG2:
396     case ACPI_DMT_FLAG3:
397     case ACPI_DMT_FLAG4:
398     case ACPI_DMT_FLAG5:
399     case ACPI_DMT_FLAG6:
400     case ACPI_DMT_FLAG7:
401     case ACPI_DMT_FLAGS0:
402     case ACPI_DMT_FLAGS1:
403     case ACPI_DMT_FLAGS2:
404     case ACPI_DMT_FLAGS4:
405     case ACPI_DMT_FLAGS4_0:
406     case ACPI_DMT_FLAGS4_4:
407     case ACPI_DMT_FLAGS4_8:
408     case ACPI_DMT_FLAGS4_12:
409     case ACPI_DMT_FLAGS16_16:
410 
411         Type = DT_FIELD_TYPE_FLAG;
412         break;
413 
414     case ACPI_DMT_NAME4:
415     case ACPI_DMT_SIG:
416     case ACPI_DMT_NAME6:
417     case ACPI_DMT_NAME8:
418     case ACPI_DMT_STRING:
419 
420         Type = DT_FIELD_TYPE_STRING;
421         break;
422 
423     case ACPI_DMT_BUFFER:
424     case ACPI_DMT_RAW_BUFFER:
425     case ACPI_DMT_BUF7:
426     case ACPI_DMT_BUF10:
427     case ACPI_DMT_BUF12:
428     case ACPI_DMT_BUF16:
429     case ACPI_DMT_BUF128:
430     case ACPI_DMT_PCI_PATH:
431 
432         Type = DT_FIELD_TYPE_BUFFER;
433         break;
434 
435     case ACPI_DMT_GAS:
436     case ACPI_DMT_HESTNTFY:
437     case ACPI_DMT_IORTMEM:
438 
439         Type = DT_FIELD_TYPE_INLINE_SUBTABLE;
440         break;
441 
442     case ACPI_DMT_UNICODE:
443 
444         Type = DT_FIELD_TYPE_UNICODE;
445         break;
446 
447     case ACPI_DMT_UUID:
448 
449         Type = DT_FIELD_TYPE_UUID;
450         break;
451 
452     case ACPI_DMT_DEVICE_PATH:
453 
454         Type = DT_FIELD_TYPE_DEVICE_PATH;
455         break;
456 
457     case ACPI_DMT_LABEL:
458 
459         Type = DT_FIELD_TYPE_LABEL;
460         break;
461 
462     default:
463 
464         Type = DT_FIELD_TYPE_INTEGER;
465         break;
466     }
467 
468     return (Type);
469 }
470 
471 
472 /******************************************************************************
473  *
474  * FUNCTION:    DtGetBufferLength
475  *
476  * PARAMETERS:  Buffer              - List of integers,
477  *                                    for example "10 3A 4F 2E"
478  *
479  * RETURN:      Count of integer
480  *
481  * DESCRIPTION: Get length of bytes needed to store the integers
482  *
483  *****************************************************************************/
484 
485 UINT32
486 DtGetBufferLength (
487     char                    *Buffer)
488 {
489     UINT32                  ByteLength = 0;
490 
491 
492     while (*Buffer)
493     {
494         if (*Buffer == ' ')
495         {
496             ByteLength++;
497 
498             while (*Buffer == ' ')
499             {
500                 Buffer++;
501             }
502         }
503 
504         Buffer++;
505     }
506 
507     return (++ByteLength);
508 }
509 
510 
511 /******************************************************************************
512  *
513  * FUNCTION:    DtGetFieldLength
514  *
515  * PARAMETERS:  Field               - Current field
516  *              Info                - Data table info
517  *
518  * RETURN:      Field length
519  *
520  * DESCRIPTION: Get length of bytes needed to compile the field
521  *
522  * Note: This function must remain in sync with AcpiDmDumpTable.
523  *
524  *****************************************************************************/
525 
526 UINT32
527 DtGetFieldLength (
528     DT_FIELD                *Field,
529     ACPI_DMTABLE_INFO       *Info)
530 {
531     UINT32                  ByteLength = 0;
532     char                    *Value;
533 
534 
535     /* Length is based upon the opcode for this field in the info table */
536 
537     switch (Info->Opcode)
538     {
539     case ACPI_DMT_FLAG0:
540     case ACPI_DMT_FLAG1:
541     case ACPI_DMT_FLAG2:
542     case ACPI_DMT_FLAG3:
543     case ACPI_DMT_FLAG4:
544     case ACPI_DMT_FLAG5:
545     case ACPI_DMT_FLAG6:
546     case ACPI_DMT_FLAG7:
547     case ACPI_DMT_FLAGS0:
548     case ACPI_DMT_FLAGS1:
549     case ACPI_DMT_FLAGS2:
550     case ACPI_DMT_FLAGS4:
551     case ACPI_DMT_FLAGS4_0:
552     case ACPI_DMT_FLAGS4_4:
553     case ACPI_DMT_FLAGS4_8:
554     case ACPI_DMT_FLAGS4_12:
555     case ACPI_DMT_FLAGS16_16:
556     case ACPI_DMT_LABEL:
557     case ACPI_DMT_EXTRA_TEXT:
558 
559         ByteLength = 0;
560         break;
561 
562     case ACPI_DMT_UINT8:
563     case ACPI_DMT_CHKSUM:
564     case ACPI_DMT_SPACEID:
565     case ACPI_DMT_ACCWIDTH:
566     case ACPI_DMT_IVRS:
567     case ACPI_DMT_GTDT:
568     case ACPI_DMT_MADT:
569     case ACPI_DMT_PCCT:
570     case ACPI_DMT_PMTT:
571     case ACPI_DMT_PPTT:
572     case ACPI_DMT_SDEV:
573     case ACPI_DMT_SRAT:
574     case ACPI_DMT_ASF:
575     case ACPI_DMT_HESTNTYP:
576     case ACPI_DMT_FADTPM:
577     case ACPI_DMT_EINJACT:
578     case ACPI_DMT_EINJINST:
579     case ACPI_DMT_ERSTACT:
580     case ACPI_DMT_ERSTINST:
581     case ACPI_DMT_DMAR_SCOPE:
582 
583         ByteLength = 1;
584         break;
585 
586     case ACPI_DMT_UINT16:
587     case ACPI_DMT_DMAR:
588     case ACPI_DMT_HEST:
589     case ACPI_DMT_HMAT:
590     case ACPI_DMT_NFIT:
591     case ACPI_DMT_PCI_PATH:
592 
593         ByteLength = 2;
594         break;
595 
596     case ACPI_DMT_UINT24:
597 
598         ByteLength = 3;
599         break;
600 
601     case ACPI_DMT_UINT32:
602     case ACPI_DMT_NAME4:
603     case ACPI_DMT_SIG:
604     case ACPI_DMT_LPIT:
605     case ACPI_DMT_TPM2:
606 
607         ByteLength = 4;
608         break;
609 
610     case ACPI_DMT_UINT40:
611 
612         ByteLength = 5;
613         break;
614 
615     case ACPI_DMT_UINT48:
616     case ACPI_DMT_NAME6:
617 
618         ByteLength = 6;
619         break;
620 
621     case ACPI_DMT_UINT56:
622     case ACPI_DMT_BUF7:
623 
624         ByteLength = 7;
625         break;
626 
627     case ACPI_DMT_UINT64:
628     case ACPI_DMT_NAME8:
629 
630         ByteLength = 8;
631         break;
632 
633     case ACPI_DMT_STRING:
634 
635         Value = DtGetFieldValue (Field);
636         if (Value)
637         {
638             ByteLength = strlen (Value) + 1;
639         }
640         else
641         {   /* At this point, this is a fatal error */
642 
643             sprintf (MsgBuffer, "Expected \"%s\"", Info->Name);
644             DtFatal (ASL_MSG_COMPILER_INTERNAL, NULL, MsgBuffer);
645             return (0);
646         }
647         break;
648 
649     case ACPI_DMT_GAS:
650 
651         ByteLength = sizeof (ACPI_GENERIC_ADDRESS);
652         break;
653 
654     case ACPI_DMT_HESTNTFY:
655 
656         ByteLength = sizeof (ACPI_HEST_NOTIFY);
657         break;
658 
659     case ACPI_DMT_IORTMEM:
660 
661         ByteLength = sizeof (ACPI_IORT_MEMORY_ACCESS);
662         break;
663 
664     case ACPI_DMT_BUFFER:
665     case ACPI_DMT_RAW_BUFFER:
666 
667         Value = DtGetFieldValue (Field);
668         if (Value)
669         {
670             ByteLength = DtGetBufferLength (Value);
671         }
672         else
673         {   /* At this point, this is a fatal error */
674 
675             sprintf (MsgBuffer, "Expected \"%s\"", Info->Name);
676             DtFatal (ASL_MSG_COMPILER_INTERNAL, NULL, MsgBuffer);
677             return (0);
678         }
679         break;
680 
681     case ACPI_DMT_BUF10:
682 
683         ByteLength = 10;
684         break;
685 
686     case ACPI_DMT_BUF12:
687 
688         ByteLength = 12;
689         break;
690 
691     case ACPI_DMT_BUF16:
692     case ACPI_DMT_UUID:
693 
694         ByteLength = 16;
695         break;
696 
697     case ACPI_DMT_BUF128:
698 
699         ByteLength = 128;
700         break;
701 
702     case ACPI_DMT_UNICODE:
703 
704         Value = DtGetFieldValue (Field);
705 
706         /* TBD: error if Value is NULL? (as below?) */
707 
708         ByteLength = (strlen (Value) + 1) * sizeof(UINT16);
709         break;
710 
711     default:
712 
713         DtFatal (ASL_MSG_COMPILER_INTERNAL, Field, "Invalid table opcode");
714         return (0);
715     }
716 
717     return (ByteLength);
718 }
719 
720 
721 /******************************************************************************
722  *
723  * FUNCTION:    DtSum
724  *
725  * PARAMETERS:  DT_WALK_CALLBACK:
726  *              Subtable            - Subtable
727  *              Context             - Unused
728  *              ReturnValue         - Store the checksum of subtable
729  *
730  * RETURN:      Status
731  *
732  * DESCRIPTION: Get the checksum of subtable
733  *
734  *****************************************************************************/
735 
736 static void
737 DtSum (
738     DT_SUBTABLE             *Subtable,
739     void                    *Context,
740     void                    *ReturnValue)
741 {
742     UINT8                   Checksum;
743     UINT8                   *Sum = ReturnValue;
744 
745 
746     Checksum = AcpiTbChecksum (Subtable->Buffer, Subtable->Length);
747     *Sum = (UINT8) (*Sum + Checksum);
748 }
749 
750 
751 /******************************************************************************
752  *
753  * FUNCTION:    DtSetTableChecksum
754  *
755  * PARAMETERS:  ChecksumPointer     - Where to return the checksum
756  *
757  * RETURN:      None
758  *
759  * DESCRIPTION: Set checksum of the whole data table into the checksum field
760  *
761  *****************************************************************************/
762 
763 void
764 DtSetTableChecksum (
765     UINT8                   *ChecksumPointer)
766 {
767     UINT8                   Checksum = 0;
768     UINT8                   OldSum;
769 
770 
771     DtWalkTableTree (Gbl_RootTable, DtSum, NULL, &Checksum);
772 
773     OldSum = *ChecksumPointer;
774     Checksum = (UINT8) (Checksum - OldSum);
775 
776     /* Compute the final checksum */
777 
778     Checksum = (UINT8) (0 - Checksum);
779     *ChecksumPointer = Checksum;
780 }
781 
782 
783 /******************************************************************************
784  *
785  * FUNCTION:    DtSetTableLength
786  *
787  * PARAMETERS:  None
788  *
789  * RETURN:      None
790  *
791  * DESCRIPTION: Walk the subtables and set all the length fields
792  *
793  *****************************************************************************/
794 
795 void
796 DtSetTableLength (
797     void)
798 {
799     DT_SUBTABLE             *ParentTable;
800     DT_SUBTABLE             *ChildTable;
801 
802 
803     ParentTable = Gbl_RootTable;
804     ChildTable = NULL;
805 
806     if (!ParentTable)
807     {
808         return;
809     }
810 
811     DtSetSubtableLength (ParentTable);
812 
813     while (1)
814     {
815         ChildTable = DtGetNextSubtable (ParentTable, ChildTable);
816         if (ChildTable)
817         {
818             if (ChildTable->LengthField)
819             {
820                 DtSetSubtableLength (ChildTable);
821             }
822 
823             if (ChildTable->Child)
824             {
825                 ParentTable = ChildTable;
826                 ChildTable = NULL;
827             }
828             else
829             {
830                 ParentTable->TotalLength += ChildTable->TotalLength;
831                 if (ParentTable->LengthField)
832                 {
833                     DtSetSubtableLength (ParentTable);
834                 }
835             }
836         }
837         else
838         {
839             ChildTable = ParentTable;
840 
841             if (ChildTable == Gbl_RootTable)
842             {
843                 break;
844             }
845 
846             ParentTable = DtGetParentSubtable (ParentTable);
847 
848             ParentTable->TotalLength += ChildTable->TotalLength;
849             if (ParentTable->LengthField)
850             {
851                 DtSetSubtableLength (ParentTable);
852             }
853         }
854     }
855 }
856 
857 
858 /******************************************************************************
859  *
860  * FUNCTION:    DtWalkTableTree
861  *
862  * PARAMETERS:  StartTable          - Subtable in the tree where walking begins
863  *              UserFunction        - Called during the walk
864  *              Context             - Passed to user function
865  *              ReturnValue         - The return value of UserFunction
866  *
867  * RETURN:      None
868  *
869  * DESCRIPTION: Performs a depth-first walk of the subtable tree
870  *
871  *****************************************************************************/
872 
873 void
874 DtWalkTableTree (
875     DT_SUBTABLE             *StartTable,
876     DT_WALK_CALLBACK        UserFunction,
877     void                    *Context,
878     void                    *ReturnValue)
879 {
880     DT_SUBTABLE             *ParentTable;
881     DT_SUBTABLE             *ChildTable;
882 
883 
884     ParentTable = StartTable;
885     ChildTable = NULL;
886 
887     if (!ParentTable)
888     {
889         return;
890     }
891 
892     UserFunction (ParentTable, Context, ReturnValue);
893 
894     while (1)
895     {
896         ChildTable = DtGetNextSubtable (ParentTable, ChildTable);
897         if (ChildTable)
898         {
899             UserFunction (ChildTable, Context, ReturnValue);
900 
901             if (ChildTable->Child)
902             {
903                 ParentTable = ChildTable;
904                 ChildTable = NULL;
905             }
906         }
907         else
908         {
909             ChildTable = ParentTable;
910             if (ChildTable == Gbl_RootTable)
911             {
912                 break;
913             }
914 
915             ParentTable = DtGetParentSubtable (ParentTable);
916 
917             if (ChildTable->Peer == StartTable)
918             {
919                 break;
920             }
921         }
922     }
923 }
924