1 /******************************************************************************
2  *
3  * Module Name: aslhex - ASCII hex output file generation (C, ASM, and ASL)
4  *
5  *****************************************************************************/
6 
7 /*
8  * Copyright (C) 2000 - 2013, 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 
45 #include "aslcompiler.h"
46 
47 #define _COMPONENT          ACPI_COMPILER
48         ACPI_MODULE_NAME    ("ashex")
49 
50 /*
51  * This module emits ASCII hex output files in either C, ASM, or ASL format
52  */
53 
54 
55 /* Local prototypes */
56 
57 static void
58 HxDoHexOutputC (
59     void);
60 
61 static void
62 HxDoHexOutputAsl (
63     void);
64 
65 static void
66 HxDoHexOutputAsm (
67     void);
68 
69 static UINT32
70 HxReadAmlOutputFile (
71     UINT8                   *Buffer);
72 
73 
74 /*******************************************************************************
75  *
76  * FUNCTION:    HxDoHexOutput
77  *
78  * PARAMETERS:  None
79  *
80  * RETURN:      None
81  *
82  * DESCRIPTION: Create the hex output file. Note: data is obtained by reading
83  *              the entire AML output file that was previously generated.
84  *
85  ******************************************************************************/
86 
87 void
88 HxDoHexOutput (
89     void)
90 {
91 
92     switch (Gbl_HexOutputFlag)
93     {
94     case HEX_OUTPUT_C:
95 
96         HxDoHexOutputC ();
97         break;
98 
99     case HEX_OUTPUT_ASM:
100 
101         HxDoHexOutputAsm ();
102         break;
103 
104     case HEX_OUTPUT_ASL:
105 
106         HxDoHexOutputAsl ();
107         break;
108 
109     default:
110 
111         /* No other output types supported */
112 
113         break;
114     }
115 }
116 
117 
118 /*******************************************************************************
119  *
120  * FUNCTION:    HxReadAmlOutputFile
121  *
122  * PARAMETERS:  Buffer              - Where to return data
123  *
124  * RETURN:      None
125  *
126  * DESCRIPTION: Read a line of the AML output prior to formatting the data
127  *
128  ******************************************************************************/
129 
130 static UINT32
131 HxReadAmlOutputFile (
132     UINT8                   *Buffer)
133 {
134     UINT32                  Actual;
135 
136 
137     Actual = fread (Buffer, 1, HEX_TABLE_LINE_SIZE,
138         Gbl_Files[ASL_FILE_AML_OUTPUT].Handle);
139 
140     if (ferror (Gbl_Files[ASL_FILE_AML_OUTPUT].Handle))
141     {
142         FlFileError (ASL_FILE_AML_OUTPUT, ASL_MSG_READ);
143         AslAbort ();
144     }
145 
146     return (Actual);
147 }
148 
149 
150 /*******************************************************************************
151  *
152  * FUNCTION:    HxDoHexOutputC
153  *
154  * PARAMETERS:  None
155  *
156  * RETURN:      None
157  *
158  * DESCRIPTION: Create the hex output file. This is the same data as the AML
159  *              output file, but formatted into hex/ascii bytes suitable for
160  *              inclusion into a C source file.
161  *
162  ******************************************************************************/
163 
164 static void
165 HxDoHexOutputC (
166     void)
167 {
168     UINT8                   FileData[HEX_TABLE_LINE_SIZE];
169     UINT32                  LineLength;
170     UINT32                  Offset = 0;
171     UINT32                  AmlFileSize;
172     UINT32                  i;
173 
174 
175     /* Get AML size, seek back to start */
176 
177     AmlFileSize = FlGetFileSize (ASL_FILE_AML_OUTPUT);
178     FlSeekFile (ASL_FILE_AML_OUTPUT, 0);
179 
180     FlPrintFile (ASL_FILE_HEX_OUTPUT, " * C source code output\n");
181     FlPrintFile (ASL_FILE_HEX_OUTPUT, " * AML code block contains 0x%X bytes\n *\n */\n",
182         AmlFileSize);
183     FlPrintFile (ASL_FILE_HEX_OUTPUT, "unsigned char AmlCode[] =\n{\n");
184 
185     while (Offset < AmlFileSize)
186     {
187         /* Read enough bytes needed for one output line */
188 
189         LineLength = HxReadAmlOutputFile (FileData);
190         if (!LineLength)
191         {
192             break;
193         }
194 
195         FlPrintFile (ASL_FILE_HEX_OUTPUT, "    ");
196 
197         for (i = 0; i < LineLength; i++)
198         {
199             /*
200              * Print each hex byte.
201              * Add a comma until the very last byte of the AML file
202              * (Some C compilers complain about a trailing comma)
203              */
204             FlPrintFile (ASL_FILE_HEX_OUTPUT, "0x%2.2X", FileData[i]);
205             if ((Offset + i + 1) < AmlFileSize)
206             {
207                 FlPrintFile (ASL_FILE_HEX_OUTPUT, ",");
208             }
209             else
210             {
211                 FlPrintFile (ASL_FILE_HEX_OUTPUT, " ");
212             }
213         }
214 
215         /* Add fill spaces if needed for last line */
216 
217         if (LineLength < HEX_TABLE_LINE_SIZE)
218         {
219             FlPrintFile (ASL_FILE_HEX_OUTPUT, "%*s",
220                 5 * (HEX_TABLE_LINE_SIZE - LineLength), " ");
221         }
222 
223         /* Emit the offset and ascii dump for the entire line */
224 
225         FlPrintFile (ASL_FILE_HEX_OUTPUT, "  /* %8.8X", Offset);
226         LsDumpAsciiInComment (ASL_FILE_HEX_OUTPUT, LineLength, FileData);
227         FlPrintFile (ASL_FILE_HEX_OUTPUT, "%*s*/\n",
228             HEX_TABLE_LINE_SIZE - LineLength + 1, " ");
229 
230         Offset += LineLength;
231     }
232 
233     FlPrintFile (ASL_FILE_HEX_OUTPUT, "};\n");
234 }
235 
236 
237 /*******************************************************************************
238  *
239  * FUNCTION:    HxDoHexOutputAsl
240  *
241  * PARAMETERS:  None
242  *
243  * RETURN:      None
244  *
245  * DESCRIPTION: Create the hex output file. This is the same data as the AML
246  *              output file, but formatted into hex/ascii bytes suitable for
247  *              inclusion into a C source file.
248  *
249  ******************************************************************************/
250 
251 static void
252 HxDoHexOutputAsl (
253     void)
254 {
255     UINT8                   FileData[HEX_TABLE_LINE_SIZE];
256     UINT32                  LineLength;
257     UINT32                  Offset = 0;
258     UINT32                  AmlFileSize;
259     UINT32                  i;
260 
261 
262     /* Get AML size, seek back to start */
263 
264     AmlFileSize = FlGetFileSize (ASL_FILE_AML_OUTPUT);
265     FlSeekFile (ASL_FILE_AML_OUTPUT, 0);
266 
267     FlPrintFile (ASL_FILE_HEX_OUTPUT, " * ASL source code output\n");
268     FlPrintFile (ASL_FILE_HEX_OUTPUT, " * AML code block contains 0x%X bytes\n *\n */\n",
269         AmlFileSize);
270     FlPrintFile (ASL_FILE_HEX_OUTPUT, "    Name (BUF1, Buffer()\n    {\n");
271 
272     while (Offset < AmlFileSize)
273     {
274         /* Read enough bytes needed for one output line */
275 
276         LineLength = HxReadAmlOutputFile (FileData);
277         if (!LineLength)
278         {
279             break;
280         }
281 
282         FlPrintFile (ASL_FILE_HEX_OUTPUT, "        ");
283 
284         for (i = 0; i < LineLength; i++)
285         {
286             /*
287              * Print each hex byte.
288              * Add a comma until the very last byte of the AML file
289              * (Some C compilers complain about a trailing comma)
290              */
291             FlPrintFile (ASL_FILE_HEX_OUTPUT, "0x%2.2X", FileData[i]);
292             if ((Offset + i + 1) < AmlFileSize)
293             {
294                 FlPrintFile (ASL_FILE_HEX_OUTPUT, ",");
295             }
296             else
297             {
298                 FlPrintFile (ASL_FILE_HEX_OUTPUT, " ");
299             }
300         }
301 
302         /* Add fill spaces if needed for last line */
303 
304         if (LineLength < HEX_TABLE_LINE_SIZE)
305         {
306             FlPrintFile (ASL_FILE_HEX_OUTPUT, "%*s",
307                 5 * (HEX_TABLE_LINE_SIZE - LineLength), " ");
308         }
309 
310         /* Emit the offset and ascii dump for the entire line */
311 
312         FlPrintFile (ASL_FILE_HEX_OUTPUT, "  /* %8.8X", Offset);
313         LsDumpAsciiInComment (ASL_FILE_HEX_OUTPUT, LineLength, FileData);
314         FlPrintFile (ASL_FILE_HEX_OUTPUT, "%*s*/\n",
315             HEX_TABLE_LINE_SIZE - LineLength + 1, " ");
316 
317         Offset += LineLength;
318     }
319 
320     FlPrintFile (ASL_FILE_HEX_OUTPUT, "    })\n");
321 }
322 
323 
324 /*******************************************************************************
325  *
326  * FUNCTION:    HxDoHexOutputAsm
327  *
328  * PARAMETERS:  None
329  *
330  * RETURN:      None
331  *
332  * DESCRIPTION: Create the hex output file. This is the same data as the AML
333  *              output file, but formatted into hex/ascii bytes suitable for
334  *              inclusion into a ASM source file.
335  *
336  ******************************************************************************/
337 
338 static void
339 HxDoHexOutputAsm (
340     void)
341 {
342     UINT8                   FileData[HEX_TABLE_LINE_SIZE];
343     UINT32                  LineLength;
344     UINT32                  Offset = 0;
345     UINT32                  AmlFileSize;
346     UINT32                  i;
347 
348 
349     /* Get AML size, seek back to start */
350 
351     AmlFileSize = FlGetFileSize (ASL_FILE_AML_OUTPUT);
352     FlSeekFile (ASL_FILE_AML_OUTPUT, 0);
353 
354     FlPrintFile (ASL_FILE_HEX_OUTPUT, "; Assembly code source output\n");
355     FlPrintFile (ASL_FILE_HEX_OUTPUT, "; AML code block contains 0x%X bytes\n;\n",
356         AmlFileSize);
357 
358     while (Offset < AmlFileSize)
359     {
360         /* Read enough bytes needed for one output line */
361 
362         LineLength = HxReadAmlOutputFile (FileData);
363         if (!LineLength)
364         {
365             break;
366         }
367 
368         FlPrintFile (ASL_FILE_HEX_OUTPUT, "  db  ");
369 
370         for (i = 0; i < LineLength; i++)
371         {
372             /*
373              * Print each hex byte.
374              * Add a comma until the last byte of the line
375              */
376             FlPrintFile (ASL_FILE_HEX_OUTPUT, "0%2.2Xh", FileData[i]);
377             if ((i + 1) < LineLength)
378             {
379                 FlPrintFile (ASL_FILE_HEX_OUTPUT, ",");
380             }
381         }
382 
383         FlPrintFile (ASL_FILE_HEX_OUTPUT, " ");
384 
385         /* Add fill spaces if needed for last line */
386 
387         if (LineLength < HEX_TABLE_LINE_SIZE)
388         {
389             FlPrintFile (ASL_FILE_HEX_OUTPUT, "%*s",
390                 5 * (HEX_TABLE_LINE_SIZE - LineLength), " ");
391         }
392 
393         /* Emit the offset and ascii dump for the entire line */
394 
395         FlPrintFile (ASL_FILE_HEX_OUTPUT, "  ; %8.8X", Offset);
396         LsDumpAsciiInComment (ASL_FILE_HEX_OUTPUT, LineLength, FileData);
397         FlPrintFile (ASL_FILE_HEX_OUTPUT, "\n");
398 
399         Offset += LineLength;
400     }
401 
402     FlPrintFile (ASL_FILE_HEX_OUTPUT, "\n");
403 }
404