dtutils.c revision 219707 
1/******************************************************************************
2 *
3 * Module Name: dtutils.c - Utility routines for the data table compiler
4 *
5 *****************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2011, Intel Corp.
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 *    notice, this list of conditions, and the following disclaimer,
16 *    without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 *    substantially similar to the "NO WARRANTY" disclaimer below
19 *    ("Disclaimer") and any redistribution must be conditioned upon
20 *    including a substantially similar Disclaimer requirement for further
21 *    binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 *    of any contributors may be used to endorse or promote products derived
24 *    from this software without specific prior written permission.
25 *
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
29 *
30 * NO WARRANTY
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
42 */
43
44#define __DTUTILS_C__
45
46#include <contrib/dev/acpica/compiler/aslcompiler.h>
47#include <contrib/dev/acpica/compiler/dtcompiler.h>
48#include <contrib/dev/acpica/include/actables.h>
49
50#define _COMPONENT          DT_COMPILER
51        ACPI_MODULE_NAME    ("dtutils")
52
53/* Local prototypes */
54
55static void
56DtSum (
57    DT_SUBTABLE             *Subtable,
58    void                    *Context,
59    void                    *ReturnValue);
60
61
62/******************************************************************************
63 *
64 * FUNCTION:    DtError
65 *
66 * PARAMETERS:  Level               - Seriousness (Warning/error, etc.)
67 *              MessageId           - Index into global message buffer
68 *              Op                  - Parse node where error happened
69 *              ExtraMessage        - additional error message
70 *
71 * RETURN:      None
72 *
73 * DESCRIPTION: Common error interface for data table compiler
74 *
75 *****************************************************************************/
76
77void
78DtError (
79    UINT8                   Level,
80    UINT8                   MessageId,
81    DT_FIELD                *FieldObject,
82    char                    *ExtraMessage)
83{
84
85    switch (Level)
86    {
87    case ASL_WARNING2:
88    case ASL_WARNING3:
89        if (Gbl_WarningLevel < Level)
90        {
91            return;
92        }
93        break;
94
95    default:
96        break;
97    }
98
99    if (FieldObject)
100    {
101        AslCommonError (Level, MessageId,
102            FieldObject->Line,
103            FieldObject->Line,
104            FieldObject->ByteOffset,
105            FieldObject->Column,
106            Gbl_Files[ASL_FILE_INPUT].Filename, ExtraMessage);
107    }
108    else
109    {
110        AslCommonError (Level, MessageId, 0,
111            0, 0, 0, 0, ExtraMessage);
112    }
113}
114
115
116/******************************************************************************
117 *
118 * FUNCTION:    DtNameError
119 *
120 * PARAMETERS:  Level               - Seriousness (Warning/error, etc.)
121 *              MessageId           - Index into global message buffer
122 *              Op                  - Parse node where error happened
123 *              ExtraMessage        - additional error message
124 *
125 * RETURN:      None
126 *
127 * DESCRIPTION: Error interface for named objects
128 *
129 *****************************************************************************/
130
131void
132DtNameError (
133    UINT8                   Level,
134    UINT8                   MessageId,
135    DT_FIELD                *FieldObject,
136    char                    *ExtraMessage)
137{
138
139    switch (Level)
140    {
141    case ASL_WARNING2:
142    case ASL_WARNING3:
143        if (Gbl_WarningLevel < Level)
144        {
145            return;
146        }
147        break;
148
149    default:
150        break;
151    }
152
153    if (FieldObject)
154    {
155        AslCommonError (Level, MessageId,
156            FieldObject->Line,
157            FieldObject->Line,
158            FieldObject->ByteOffset,
159            FieldObject->NameColumn,
160            Gbl_Files[ASL_FILE_INPUT].Filename, ExtraMessage);
161    }
162    else
163    {
164        AslCommonError (Level, MessageId, 0,
165            0, 0, 0, 0, ExtraMessage);
166    }
167}
168
169
170/*******************************************************************************
171 *
172 * FUNCTION:    DtFatal
173 *
174 * PARAMETERS:  None
175 *
176 * RETURN:      None
177 *
178 * DESCRIPTION: Dump the error log and abort the compiler. Used for serious
179 *              compile or I/O errors
180 *
181 ******************************************************************************/
182
183void
184DtFatal (
185    UINT8                   MessageId,
186    DT_FIELD                *FieldObject,
187    char                    *ExtraMessage)
188{
189
190    DtError (ASL_ERROR, MessageId, FieldObject, ExtraMessage);
191
192    CmCleanupAndExit ();
193    exit (1);
194}
195
196
197/******************************************************************************
198 *
199 * FUNCTION:    DtStrtoul64
200 *
201 * PARAMETERS:  String              - Null terminated string
202 *              ReturnInteger       - Where the converted integer is returned
203 *
204 * RETURN:      Status
205 *
206 * DESCRIPTION: Simple conversion of a string hex integer constant to unsigned
207 *              value. Assumes no leading "0x" for the constant.
208 *
209 * Portability note: The reason this function exists is because a 64-bit
210 * sscanf is not available in all environments.
211 *
212 *****************************************************************************/
213
214ACPI_STATUS
215DtStrtoul64 (
216    char                    *String,
217    UINT64                  *ReturnInteger)
218{
219    char                    *ThisChar = String;
220    UINT32                  ThisDigit;
221    UINT64                  ReturnValue = 0;
222    int                     DigitCount = 0;
223
224
225    /* Skip over any white space in the buffer */
226
227    while ((*ThisChar == ' ') || (*ThisChar == '\t'))
228    {
229        ThisChar++;
230    }
231
232    /* Skip leading zeros */
233
234    while ((*ThisChar) == '0')
235    {
236        ThisChar++;
237    }
238
239    /* Convert character-by-character */
240
241    while (*ThisChar)
242    {
243        if (ACPI_IS_DIGIT (*ThisChar))
244        {
245            /* Convert ASCII 0-9 to Decimal value */
246
247            ThisDigit = ((UINT8) *ThisChar) - '0';
248        }
249        else /* Letter */
250        {
251            ThisDigit = (UINT32) ACPI_TOUPPER (*ThisChar);
252            if (!ACPI_IS_XDIGIT ((char) ThisDigit))
253            {
254                /* Not A-F */
255
256                return (AE_BAD_CHARACTER);
257            }
258
259            /* Convert ASCII Hex char (A-F) to value */
260
261            ThisDigit = (ThisDigit - 'A') + 10;
262        }
263
264        /* Insert the 4-bit hex digit */
265
266        ReturnValue <<= 4;
267        ReturnValue += ThisDigit;
268
269        ThisChar++;
270        DigitCount++;
271        if (DigitCount > 16)
272        {
273            /* Value is too large (> 64 bits/8 bytes/16 hex digits) */
274
275            return (AE_LIMIT);
276        }
277    }
278
279    *ReturnInteger = ReturnValue;
280    return (AE_OK);
281}
282
283
284/******************************************************************************
285 *
286 * FUNCTION:    DtGetFileSize
287 *
288 * PARAMETERS:  Handle              - Open file handler
289 *
290 * RETURN:      Current file size
291 *
292 * DESCRIPTION: Get the current size of a file. Seek to the EOF and get the
293 *              offset. Seek back to the original location.
294 *
295 *****************************************************************************/
296
297UINT32
298DtGetFileSize (
299    FILE                    *Handle)
300{
301    int                     CurrentOffset;
302    int                     LastOffset;
303
304
305    CurrentOffset = ftell (Handle);
306    fseek (Handle, 0, SEEK_END);
307    LastOffset = ftell (Handle);
308    fseek (Handle, CurrentOffset, SEEK_SET);
309
310    return ((UINT32) LastOffset);
311}
312
313
314/******************************************************************************
315 *
316 * FUNCTION:    DtGetFieldValue
317 *
318 * PARAMETERS:  Field               - Current field list pointer
319 *              Name                - Field name
320 *
321 * RETURN:      Field value
322 *
323 * DESCRIPTION: Get field value
324 *
325 *****************************************************************************/
326
327char *
328DtGetFieldValue (
329    DT_FIELD                *Field,
330    char                    *Name)
331{
332
333    /* Search the field list for the name */
334
335    while (Field)
336    {
337        if (!ACPI_STRCMP (Name, Field->Name))
338        {
339            return (Field->Value);
340        }
341
342        Field = Field->Next;
343    }
344
345    return (NULL);
346}
347
348
349/******************************************************************************
350 *
351 * FUNCTION:    DtGetFieldType
352 *
353 * PARAMETERS:  Info                - Data table info
354 *
355 * RETURN:      Field type
356 *
357 * DESCRIPTION: Get field type
358 *
359 *****************************************************************************/
360
361UINT8
362DtGetFieldType (
363    ACPI_DMTABLE_INFO       *Info)
364{
365    UINT8                   Type;
366
367
368    /* DT_FLAG means that this is the start of a block of flag bits */
369    /* TBD - we can make these a separate opcode later */
370
371    if (Info->Flags & DT_FLAG)
372    {
373        return (DT_FIELD_TYPE_FLAGS_INTEGER);
374    }
375
376    /* Type is based upon the opcode for this field in the info table */
377
378    switch (Info->Opcode)
379    {
380    case ACPI_DMT_FLAG0:
381    case ACPI_DMT_FLAG1:
382    case ACPI_DMT_FLAG2:
383    case ACPI_DMT_FLAG3:
384    case ACPI_DMT_FLAG4:
385    case ACPI_DMT_FLAG5:
386    case ACPI_DMT_FLAG6:
387    case ACPI_DMT_FLAG7:
388    case ACPI_DMT_FLAGS0:
389    case ACPI_DMT_FLAGS2:
390        Type = DT_FIELD_TYPE_FLAG;
391        break;
392
393    case ACPI_DMT_NAME4:
394    case ACPI_DMT_SIG:
395    case ACPI_DMT_NAME6:
396    case ACPI_DMT_NAME8:
397    case ACPI_DMT_STRING:
398        Type = DT_FIELD_TYPE_STRING;
399        break;
400
401    case ACPI_DMT_BUFFER:
402    case ACPI_DMT_BUF7:
403    case ACPI_DMT_BUF16:
404    case ACPI_DMT_BUF128:
405    case ACPI_DMT_PCI_PATH:
406        Type = DT_FIELD_TYPE_BUFFER;
407        break;
408
409    case ACPI_DMT_GAS:
410    case ACPI_DMT_HESTNTFY:
411        Type = DT_FIELD_TYPE_INLINE_SUBTABLE;
412        break;
413
414    case ACPI_DMT_UNICODE:
415        Type = DT_FIELD_TYPE_UNICODE;
416        break;
417
418    case ACPI_DMT_UUID:
419        Type = DT_FIELD_TYPE_UUID;
420        break;
421
422    case ACPI_DMT_DEVICE_PATH:
423        Type = DT_FIELD_TYPE_DEVICE_PATH;
424        break;
425
426    case ACPI_DMT_LABEL:
427        Type = DT_FIELD_TYPE_LABEL;
428        break;
429
430    default:
431        Type = DT_FIELD_TYPE_INTEGER;
432        break;
433    }
434
435    return (Type);
436}
437
438
439/******************************************************************************
440 *
441 * FUNCTION:    DtGetBufferLength
442 *
443 * PARAMETERS:  Buffer              - List of integers,
444 *                                    for example "10 3A 4F 2E"
445 *
446 * RETURN:      Count of integer
447 *
448 * DESCRIPTION: Get length of bytes needed to store the integers
449 *
450 *****************************************************************************/
451
452UINT32
453DtGetBufferLength (
454    char                    *Buffer)
455{
456    UINT32                  ByteLength = 0;
457
458
459    while (*Buffer)
460    {
461        if (*Buffer == ' ')
462        {
463            ByteLength++;
464
465            while (*Buffer == ' ')
466            {
467                Buffer++;
468            }
469        }
470
471        Buffer++;
472    }
473
474    return (++ByteLength);
475}
476
477
478/******************************************************************************
479 *
480 * FUNCTION:    DtGetFieldLength
481 *
482 * PARAMETERS:  Field               - Current field list pointer
483 *              Info                - Data table info
484 *
485 * RETURN:      Field length
486 *
487 * DESCRIPTION: Get length of bytes needed to compile the field
488 *
489 * Note: This function must remain in sync with AcpiDmDumpTable.
490 *
491 *****************************************************************************/
492
493UINT32
494DtGetFieldLength (
495    DT_FIELD                *Field,
496    ACPI_DMTABLE_INFO       *Info)
497{
498    UINT32                  ByteLength = 0;
499    char                    *Value;
500
501
502    /* Length is based upon the opcode for this field in the info table */
503
504    switch (Info->Opcode)
505    {
506    case ACPI_DMT_FLAG0:
507    case ACPI_DMT_FLAG1:
508    case ACPI_DMT_FLAG2:
509    case ACPI_DMT_FLAG3:
510    case ACPI_DMT_FLAG4:
511    case ACPI_DMT_FLAG5:
512    case ACPI_DMT_FLAG6:
513    case ACPI_DMT_FLAG7:
514    case ACPI_DMT_FLAGS0:
515    case ACPI_DMT_FLAGS2:
516    case ACPI_DMT_LABEL:
517        ByteLength = 0;
518        break;
519
520    case ACPI_DMT_UINT8:
521    case ACPI_DMT_CHKSUM:
522    case ACPI_DMT_SPACEID:
523    case ACPI_DMT_ACCWIDTH:
524    case ACPI_DMT_IVRS:
525    case ACPI_DMT_MADT:
526    case ACPI_DMT_SRAT:
527    case ACPI_DMT_ASF:
528    case ACPI_DMT_HESTNTYP:
529    case ACPI_DMT_FADTPM:
530    case ACPI_DMT_EINJACT:
531    case ACPI_DMT_EINJINST:
532    case ACPI_DMT_ERSTACT:
533    case ACPI_DMT_ERSTINST:
534        ByteLength = 1;
535        break;
536
537    case ACPI_DMT_UINT16:
538    case ACPI_DMT_DMAR:
539    case ACPI_DMT_HEST:
540    case ACPI_DMT_PCI_PATH:
541        ByteLength = 2;
542        break;
543
544    case ACPI_DMT_UINT24:
545        ByteLength = 3;
546        break;
547
548    case ACPI_DMT_UINT32:
549    case ACPI_DMT_NAME4:
550    case ACPI_DMT_SLIC:
551    case ACPI_DMT_SIG:
552        ByteLength = 4;
553        break;
554
555    case ACPI_DMT_NAME6:
556        ByteLength = 6;
557        break;
558
559    case ACPI_DMT_UINT56:
560    case ACPI_DMT_BUF7:
561        ByteLength = 7;
562        break;
563
564    case ACPI_DMT_UINT64:
565    case ACPI_DMT_NAME8:
566        ByteLength = 8;
567        break;
568
569    case ACPI_DMT_STRING:
570        Value = DtGetFieldValue (Field, Info->Name);
571        if (Value)
572        {
573            ByteLength = ACPI_STRLEN (Value) + 1;
574        }
575        else
576        {   /* At this point, this is a fatal error */
577
578            sprintf (MsgBuffer, "Expected \"%s\"", Info->Name);
579            DtFatal (ASL_MSG_COMPILER_INTERNAL, NULL, MsgBuffer);
580        }
581        break;
582
583    case ACPI_DMT_GAS:
584        ByteLength = sizeof (ACPI_GENERIC_ADDRESS);
585        break;
586
587    case ACPI_DMT_HESTNTFY:
588        ByteLength = sizeof (ACPI_HEST_NOTIFY);
589        break;
590
591    case ACPI_DMT_BUFFER:
592        Value = DtGetFieldValue (Field, Info->Name);
593        if (Value)
594        {
595            ByteLength = DtGetBufferLength (Value);
596        }
597        else
598        {   /* At this point, this is a fatal error */
599
600            sprintf (MsgBuffer, "Expected \"%s\"", Info->Name);
601            DtFatal (ASL_MSG_COMPILER_INTERNAL, NULL, MsgBuffer);
602        }
603        break;
604
605    case ACPI_DMT_BUF16:
606    case ACPI_DMT_UUID:
607        ByteLength = 16;
608        break;
609
610    case ACPI_DMT_BUF128:
611        ByteLength = 128;
612        break;
613
614    case ACPI_DMT_UNICODE:
615        Value = DtGetFieldValue (Field, Info->Name);
616
617        /* TBD: error if Value is NULL? (as below?) */
618
619        ByteLength = (ACPI_STRLEN (Value) + 1) * sizeof(UINT16);
620        break;
621
622    default:
623        DtFatal (ASL_MSG_COMPILER_INTERNAL, Field, "Invalid table opcode");
624        break;
625    }
626
627    return (ByteLength);
628}
629
630
631/******************************************************************************
632 *
633 * FUNCTION:    DtSum
634 *
635 * PARAMETERS:  DT_WALK_CALLBACK:
636 *              Subtable            - Subtable
637 *              Context             - Unused
638 *              ReturnValue         - Store the checksum of subtable
639 *
640 * RETURN:      Status
641 *
642 * DESCRIPTION: Get the checksum of subtable
643 *
644 *****************************************************************************/
645
646static void
647DtSum (
648    DT_SUBTABLE             *Subtable,
649    void                    *Context,
650    void                    *ReturnValue)
651{
652    UINT8                   Checksum;
653    UINT8                   *Sum = ReturnValue;
654
655
656    Checksum = AcpiTbChecksum (Subtable->Buffer, Subtable->Length);
657    *Sum = (UINT8) (*Sum + Checksum);
658}
659
660
661/******************************************************************************
662 *
663 * FUNCTION:    DtSetTableChecksum
664 *
665 * PARAMETERS:  ChecksumPointer     - Where to return the checksum
666 *
667 * RETURN:      None
668 *
669 * DESCRIPTION: Set checksum of the whole data table into the checksum field
670 *
671 *****************************************************************************/
672
673void
674DtSetTableChecksum (
675    UINT8                   *ChecksumPointer)
676{
677    UINT8                   Checksum = 0;
678    UINT8                   OldSum;
679
680
681    DtWalkTableTree (Gbl_RootTable, DtSum, NULL, &Checksum);
682
683    OldSum = *ChecksumPointer;
684    Checksum = (UINT8) (Checksum - OldSum);
685
686    /* Compute the final checksum */
687
688    Checksum = (UINT8) (0 - Checksum);
689    *ChecksumPointer = Checksum;
690}
691
692
693/******************************************************************************
694 *
695 * FUNCTION:    DtSetTableLength
696 *
697 * PARAMETERS:  None
698 *
699 * RETURN:      None
700 *
701 * DESCRIPTION: Walk the subtables and set all the length fields
702 *
703 *****************************************************************************/
704
705void
706DtSetTableLength (
707    void)
708{
709    DT_SUBTABLE             *ParentTable;
710    DT_SUBTABLE             *ChildTable;
711
712
713    ParentTable = Gbl_RootTable;
714    ChildTable = NULL;
715
716    if (!ParentTable)
717    {
718        return;
719    }
720
721    DtSetSubtableLength (ParentTable);
722
723    while (1)
724    {
725        ChildTable = DtGetNextSubtable (ParentTable, ChildTable);
726        if (ChildTable)
727        {
728            if (ChildTable->LengthField)
729            {
730                DtSetSubtableLength (ChildTable);
731            }
732
733            if (ChildTable->Child)
734            {
735                ParentTable = ChildTable;
736                ChildTable = NULL;
737            }
738            else
739            {
740                ParentTable->TotalLength += ChildTable->TotalLength;
741                if (ParentTable->LengthField)
742                {
743                    DtSetSubtableLength (ParentTable);
744                }
745            }
746        }
747        else
748        {
749            ChildTable = ParentTable;
750
751            if (ChildTable == Gbl_RootTable)
752            {
753                break;
754            }
755
756            ParentTable = DtGetParentSubtable (ParentTable);
757
758            ParentTable->TotalLength += ChildTable->TotalLength;
759            if (ParentTable->LengthField)
760            {
761                DtSetSubtableLength (ParentTable);
762            }
763        }
764    }
765}
766
767
768/******************************************************************************
769 *
770 * FUNCTION:    DtWalkTableTree
771 *
772 * PARAMETERS:  StartTable          - Subtable in the tree where walking begins
773 *              UserFunction        - Called during the walk
774 *              Context             - Passed to user function
775 *              ReturnValue         - The return value of UserFunction
776 *
777 * RETURN:      None
778 *
779 * DESCRIPTION: Performs a depth-first walk of the subtable tree
780 *
781 *****************************************************************************/
782
783void
784DtWalkTableTree (
785    DT_SUBTABLE             *StartTable,
786    DT_WALK_CALLBACK        UserFunction,
787    void                    *Context,
788    void                    *ReturnValue)
789{
790    DT_SUBTABLE             *ParentTable;
791    DT_SUBTABLE             *ChildTable;
792
793
794    ParentTable = StartTable;
795    ChildTable = NULL;
796
797    if (!ParentTable)
798    {
799        return;
800    }
801
802    UserFunction (ParentTable, Context, ReturnValue);
803
804    while (1)
805    {
806        ChildTable = DtGetNextSubtable (ParentTable, ChildTable);
807        if (ChildTable)
808        {
809            UserFunction (ChildTable, Context, ReturnValue);
810
811            if (ChildTable->Child)
812            {
813                ParentTable = ChildTable;
814                ChildTable = NULL;
815            }
816        }
817        else
818        {
819            ChildTable = ParentTable;
820            if (ChildTable == Gbl_RootTable)
821            {
822                break;
823            }
824
825            ParentTable = DtGetParentSubtable (ParentTable);
826
827            if (ChildTable->Peer == StartTable)
828            {
829                break;
830            }
831        }
832    }
833}
834
835
836/******************************************************************************
837 *
838 * FUNCTION:    DtFreeFieldList
839 *
840 * PARAMETERS:  None
841 *
842 * RETURN:      None
843 *
844 * DESCRIPTION: Free the field list
845 *
846 *****************************************************************************/
847
848void
849DtFreeFieldList (
850    void)
851{
852    DT_FIELD                *Field = Gbl_FieldList;
853    DT_FIELD                *NextField;
854
855
856    /* Walk and free entire field list */
857
858    while (Field)
859    {
860        NextField = Field->Next; /* Save link */
861
862        if (!(Field->Flags & DT_FIELD_NOT_ALLOCATED))
863        {
864            ACPI_FREE (Field->Name);
865            ACPI_FREE (Field->Value);
866        }
867
868        ACPI_FREE (Field);
869        Field = NextField;
870    }
871}
872