xref: /freebsd/sys/contrib/dev/acpica/compiler/dtfield.c (revision f6a3b357e9be4c6423c85eff9a847163a0d307c8)
1 /******************************************************************************
2  *
3  * Module Name: dtfield.c - Code generation for individual source fields
4  *
5  *****************************************************************************/
6 
7 /******************************************************************************
8  *
9  * 1. Copyright Notice
10  *
11  * Some or all of this work - Copyright (c) 1999 - 2019, 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 <contrib/dev/acpica/compiler/aslcompiler.h>
153 
154 #define _COMPONENT          DT_COMPILER
155         ACPI_MODULE_NAME    ("dtfield")
156 
157 
158 /* Local prototypes */
159 
160 static void
161 DtCompileString (
162     UINT8                   *Buffer,
163     DT_FIELD                *Field,
164     UINT32                  ByteLength);
165 
166 static void
167 DtCompileUnicode (
168     UINT8                   *Buffer,
169     DT_FIELD                *Field,
170     UINT32                  ByteLength);
171 
172 static ACPI_STATUS
173 DtCompileUuid (
174     UINT8                   *Buffer,
175     DT_FIELD                *Field,
176     UINT32                  ByteLength);
177 
178 static char *
179 DtNormalizeBuffer (
180     char                    *Buffer,
181     UINT32                  *Count);
182 
183 
184 /******************************************************************************
185  *
186  * FUNCTION:    DtCompileOneField
187  *
188  * PARAMETERS:  Buffer              - Output buffer
189  *              Field               - Field to be compiled
190  *              ByteLength          - Byte length of the field
191  *              Type                - Field type
192  *
193  * RETURN:      None
194  *
195  * DESCRIPTION: Compile a field value to binary
196  *
197  *****************************************************************************/
198 
199 void
200 DtCompileOneField (
201     UINT8                   *Buffer,
202     DT_FIELD                *Field,
203     UINT32                  ByteLength,
204     UINT8                   Type,
205     UINT8                   Flags)
206 {
207     ACPI_STATUS             Status;
208 
209 
210     switch (Type)
211     {
212     case DT_FIELD_TYPE_INTEGER:
213 
214         DtCompileInteger (Buffer, Field, ByteLength, Flags);
215         break;
216 
217     case DT_FIELD_TYPE_STRING:
218 
219         DtCompileString (Buffer, Field, ByteLength);
220         break;
221 
222     case DT_FIELD_TYPE_UUID:
223 
224         Status = DtCompileUuid (Buffer, Field, ByteLength);
225         if (ACPI_SUCCESS (Status))
226         {
227             break;
228         }
229 
230         /* Fall through. */
231 
232     case DT_FIELD_TYPE_BUFFER:
233 
234         DtCompileBuffer (Buffer, Field->Value, Field, ByteLength);
235         break;
236 
237     case DT_FIELD_TYPE_UNICODE:
238 
239         DtCompileUnicode (Buffer, Field, ByteLength);
240         break;
241 
242     case DT_FIELD_TYPE_DEVICE_PATH:
243 
244         break;
245 
246     default:
247 
248         DtFatal (ASL_MSG_COMPILER_INTERNAL, Field, "Invalid field type");
249         break;
250     }
251 }
252 
253 
254 /******************************************************************************
255  *
256  * FUNCTION:    DtCompileString
257  *
258  * PARAMETERS:  Buffer              - Output buffer
259  *              Field               - String to be copied to buffer
260  *              ByteLength          - Maximum length of string
261  *
262  * RETURN:      None
263  *
264  * DESCRIPTION: Copy string to the buffer
265  *
266  *****************************************************************************/
267 
268 static void
269 DtCompileString (
270     UINT8                   *Buffer,
271     DT_FIELD                *Field,
272     UINT32                  ByteLength)
273 {
274     UINT32                  Length;
275 
276 
277     Length = strlen (Field->Value);
278 
279     /* Check if the string is too long for the field */
280 
281     if (Length > ByteLength)
282     {
283         sprintf (AslGbl_MsgBuffer, "Maximum %u characters", ByteLength);
284         DtError (ASL_ERROR, ASL_MSG_STRING_LENGTH, Field, AslGbl_MsgBuffer);
285         Length = ByteLength;
286     }
287 
288     memcpy (Buffer, Field->Value, Length);
289 }
290 
291 
292 /******************************************************************************
293  *
294  * FUNCTION:    DtCompileUnicode
295  *
296  * PARAMETERS:  Buffer              - Output buffer
297  *              Field               - String to be copied to buffer
298  *              ByteLength          - Maximum length of string
299  *
300  * RETURN:      None
301  *
302  * DESCRIPTION: Convert ASCII string to Unicode string
303  *
304  * Note:  The Unicode string is 16 bits per character, no leading signature,
305  *        with a 16-bit terminating NULL.
306  *
307  *****************************************************************************/
308 
309 static void
310 DtCompileUnicode (
311     UINT8                   *Buffer,
312     DT_FIELD                *Field,
313     UINT32                  ByteLength)
314 {
315     UINT32                  Count;
316     UINT32                  i;
317     char                    *AsciiString;
318     UINT16                  *UnicodeString;
319 
320 
321     AsciiString = Field->Value;
322     UnicodeString = (UINT16 *) Buffer;
323     Count = strlen (AsciiString) + 1;
324 
325     /* Convert to Unicode string (including null terminator) */
326 
327     for (i = 0; i < Count; i++)
328     {
329         UnicodeString[i] = (UINT16) AsciiString[i];
330     }
331 }
332 
333 
334 /*******************************************************************************
335  *
336  * FUNCTION:    DtCompileUuid
337  *
338  * PARAMETERS:  Buffer              - Output buffer
339  *              Field               - String to be copied to buffer
340  *              ByteLength          - Maximum length of string
341  *
342  * RETURN:      None
343  *
344  * DESCRIPTION: Convert UUID string to 16-byte buffer
345  *
346  ******************************************************************************/
347 
348 static ACPI_STATUS
349 DtCompileUuid (
350     UINT8                   *Buffer,
351     DT_FIELD                *Field,
352     UINT32                  ByteLength)
353 {
354     char                    *InString;
355     ACPI_STATUS             Status;
356 
357 
358     InString = Field->Value;
359 
360     Status = AuValidateUuid (InString);
361     if (ACPI_FAILURE (Status))
362     {
363         sprintf (AslGbl_MsgBuffer, "%s", Field->Value);
364         DtNameError (ASL_ERROR, ASL_MSG_INVALID_UUID, Field, AslGbl_MsgBuffer);
365     }
366     else
367     {
368         AcpiUtConvertStringToUuid (InString, Buffer);
369     }
370 
371     return (Status);
372 }
373 
374 
375 /******************************************************************************
376  *
377  * FUNCTION:    DtCompileInteger
378  *
379  * PARAMETERS:  Buffer              - Output buffer
380  *              Field               - Field obj with Integer to be compiled
381  *              ByteLength          - Byte length of the integer
382  *              Flags               - Additional compile info
383  *
384  * RETURN:      None
385  *
386  * DESCRIPTION: Compile an integer. Supports integer expressions with C-style
387  *              operators.
388  *
389  *****************************************************************************/
390 
391 void
392 DtCompileInteger (
393     UINT8                   *Buffer,
394     DT_FIELD                *Field,
395     UINT32                  ByteLength,
396     UINT8                   Flags)
397 {
398     UINT64                  Value;
399     UINT64                  MaxValue;
400     ACPI_STATUS             Status;
401 
402 
403     /* Output buffer byte length must be in range 1-8 */
404 
405     if ((ByteLength > 8) || (ByteLength == 0))
406     {
407         DtFatal (ASL_MSG_COMPILER_INTERNAL, Field,
408             "Invalid internal Byte length");
409         return;
410     }
411 
412     /* Resolve integer expression to a single integer value */
413 
414     Status = DtResolveIntegerExpression (Field, &Value);
415     if (ACPI_FAILURE (Status))
416     {
417         return;
418     }
419 
420     /*
421      * Ensure that reserved fields are set properly. Note: uses
422      * the DT_NON_ZERO flag to indicate that the reserved value
423      * must be exactly one. Otherwise, the value must be zero.
424      * This is sufficient for now.
425      */
426 
427     /* TBD: Should use a flag rather than compare "Reserved" */
428 
429     if (!strcmp (Field->Name, "Reserved"))
430     {
431         if (Flags & DT_NON_ZERO)
432         {
433             if (Value != 1)
434             {
435                 DtError (ASL_WARNING, ASL_MSG_RESERVED_VALUE, Field,
436                     "Must be one, setting to one");
437                 Value = 1;
438             }
439         }
440         else if (Value != 0)
441         {
442             DtError (ASL_WARNING, ASL_MSG_RESERVED_VALUE, Field,
443                 "Must be zero, setting to zero");
444             Value = 0;
445         }
446     }
447 
448     /* Check if the value must be non-zero */
449 
450     else if ((Flags & DT_NON_ZERO) && (Value == 0))
451     {
452         DtError (ASL_ERROR, ASL_MSG_ZERO_VALUE, Field, NULL);
453     }
454 
455     /*
456      * Generate the maximum value for the data type (ByteLength)
457      * Note: construct chosen for maximum portability
458      */
459     MaxValue = ((UINT64) (-1)) >> (64 - (ByteLength * 8));
460 
461     /* Validate that the input value is within range of the target */
462 
463     if (Value > MaxValue)
464     {
465         sprintf (AslGbl_MsgBuffer, "%8.8X%8.8X - max %u bytes",
466             ACPI_FORMAT_UINT64 (Value), ByteLength);
467         DtError (ASL_ERROR, ASL_MSG_INTEGER_SIZE, Field, AslGbl_MsgBuffer);
468     }
469 
470     memcpy (Buffer, &Value, ByteLength);
471     return;
472 }
473 
474 
475 /******************************************************************************
476  *
477  * FUNCTION:    DtNormalizeBuffer
478  *
479  * PARAMETERS:  Buffer              - Input buffer
480  *              Count               - Output the count of hex numbers in
481  *                                    the Buffer
482  *
483  * RETURN:      The normalized buffer, must be freed by caller
484  *
485  * DESCRIPTION: [1A,2B,3C,4D] or 1A, 2B, 3C, 4D will be normalized
486  *              to 1A 2B 3C 4D
487  *
488  *****************************************************************************/
489 
490 static char *
491 DtNormalizeBuffer (
492     char                    *Buffer,
493     UINT32                  *Count)
494 {
495     char                    *NewBuffer;
496     char                    *TmpBuffer;
497     UINT32                  BufferCount = 0;
498     BOOLEAN                 Separator = TRUE;
499     char                    c;
500 
501 
502     NewBuffer = UtLocalCalloc (strlen (Buffer) + 1);
503     TmpBuffer = NewBuffer;
504 
505     while ((c = *Buffer++))
506     {
507         switch (c)
508         {
509         /* Valid separators */
510 
511         case '[':
512         case ']':
513         case ' ':
514         case ',':
515 
516             Separator = TRUE;
517             break;
518 
519         default:
520 
521             if (Separator)
522             {
523                 /* Insert blank as the standard separator */
524 
525                 if (NewBuffer[0])
526                 {
527                     *TmpBuffer++ = ' ';
528                     BufferCount++;
529                 }
530 
531                 Separator = FALSE;
532             }
533 
534             *TmpBuffer++ = c;
535             break;
536         }
537     }
538 
539     *Count = BufferCount + 1;
540     return (NewBuffer);
541 }
542 
543 
544 /******************************************************************************
545  *
546  * FUNCTION:    DtCompileBuffer
547  *
548  * PARAMETERS:  Buffer              - Output buffer
549  *              StringValue         - Integer list to be compiled
550  *              Field               - Current field object
551  *              ByteLength          - Byte length of the integer list
552  *
553  * RETURN:      Count of remaining data in the input list
554  *
555  * DESCRIPTION: Compile and pack an integer list, for example
556  *              "AA 1F 20 3B" ==> Buffer[] = {0xAA,0x1F,0x20,0x3B}
557  *
558  *****************************************************************************/
559 
560 UINT32
561 DtCompileBuffer (
562     UINT8                   *Buffer,
563     char                    *StringValue,
564     DT_FIELD                *Field,
565     UINT32                  ByteLength)
566 {
567     char                    *Substring;
568     ACPI_STATUS             Status;
569     UINT32                  Count;
570     UINT32                  i;
571 
572 
573     /* Allow several different types of value separators */
574 
575     StringValue = DtNormalizeBuffer (StringValue, &Count);
576     Substring = StringValue;
577 
578     /* Each element of StringValue is now three chars (2 hex + 1 space) */
579 
580     for (i = 0; i < Count; i++, Substring += 3)
581     {
582         /* Check for byte value too long */
583 
584         if (*(&Substring[2]) &&
585            (*(&Substring[2]) != ' '))
586         {
587             DtError (ASL_ERROR, ASL_MSG_BUFFER_ELEMENT, Field, Substring);
588             goto Exit;
589         }
590 
591         /* Convert two ASCII characters to one hex byte */
592 
593         Status = AcpiUtAsciiToHexByte (Substring, &Buffer[i]);
594         if (ACPI_FAILURE (Status))
595         {
596             DtError (ASL_ERROR, ASL_MSG_BUFFER_ELEMENT, Field, Substring);
597             goto Exit;
598         }
599     }
600 
601 Exit:
602     ACPI_FREE (StringValue);
603     return (ByteLength - Count);
604 }
605 
606 
607 /******************************************************************************
608  *
609  * FUNCTION:    DtCompileFlag
610  *
611  * PARAMETERS:  Buffer                      - Output buffer
612  *              Field                       - Field to be compiled
613  *              Info                        - Flag info
614  *
615  * RETURN:      None
616  *
617  * DESCRIPTION: Compile a flag field. Handles flags up to 64 bits.
618  *
619  *****************************************************************************/
620 
621 void
622 DtCompileFlag (
623     UINT8                   *Buffer,
624     DT_FIELD                *Field,
625     ACPI_DMTABLE_INFO       *Info)
626 {
627     UINT64                  Value = 0;
628     UINT32                  BitLength = 1;
629     UINT8                   BitPosition = 0;
630 
631 
632     Value = AcpiUtImplicitStrtoul64 (Field->Value);
633 
634     switch (Info->Opcode)
635     {
636     case ACPI_DMT_FLAG0:
637     case ACPI_DMT_FLAG1:
638     case ACPI_DMT_FLAG2:
639     case ACPI_DMT_FLAG3:
640     case ACPI_DMT_FLAG4:
641     case ACPI_DMT_FLAG5:
642     case ACPI_DMT_FLAG6:
643     case ACPI_DMT_FLAG7:
644 
645         BitPosition = Info->Opcode;
646         BitLength = 1;
647         break;
648 
649     case ACPI_DMT_FLAGS0:
650 
651         BitPosition = 0;
652         BitLength = 2;
653         break;
654 
655 
656     case ACPI_DMT_FLAGS1:
657 
658         BitPosition = 1;
659         BitLength = 2;
660         break;
661 
662 
663     case ACPI_DMT_FLAGS2:
664 
665         BitPosition = 2;
666         BitLength = 2;
667         break;
668 
669     case ACPI_DMT_FLAGS4:
670 
671         BitPosition = 4;
672         BitLength = 2;
673         break;
674 
675     case ACPI_DMT_FLAGS4_0:
676 
677         BitPosition = 0;
678         BitLength = 4;
679         break;
680 
681     case ACPI_DMT_FLAGS4_4:
682 
683         BitPosition = 4;
684         BitLength = 4;
685         break;
686 
687     case ACPI_DMT_FLAGS4_8:
688 
689         BitPosition = 8;
690         BitLength = 4;
691         break;
692 
693     case ACPI_DMT_FLAGS4_12:
694 
695         BitPosition = 12;
696         BitLength = 4;
697         break;
698 
699     case ACPI_DMT_FLAGS16_16:
700 
701         BitPosition = 16;
702         BitLength = 16;
703         break;
704 
705     default:
706 
707         DtFatal (ASL_MSG_COMPILER_INTERNAL, Field, "Invalid flag opcode");
708         break;
709     }
710 
711     /* Check range of the input flag value */
712 
713     if (Value >= ((UINT64) 1 << BitLength))
714     {
715         sprintf (AslGbl_MsgBuffer, "Maximum %u bit", BitLength);
716         DtError (ASL_ERROR, ASL_MSG_FLAG_VALUE, Field, AslGbl_MsgBuffer);
717         Value = 0;
718     }
719 
720     *Buffer |= (UINT8) (Value << BitPosition);
721 }
722