xref: /titanic_41/usr/src/cmd/acpi/acpidump/utbuffer.c (revision de5d74c22760a6d2cefd94d0e7f0fd87214fb71f)
1 /******************************************************************************
2  *
3  * Module Name: utbuffer - Buffer dump routines
4  *
5  *****************************************************************************/
6 
7 /*
8  * Copyright (C) 2000 - 2016, 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 #include "acpi.h"
45 #include "accommon.h"
46 
47 #define _COMPONENT          ACPI_UTILITIES
48         ACPI_MODULE_NAME    ("utbuffer")
49 
50 
51 /*******************************************************************************
52  *
53  * FUNCTION:    AcpiUtDumpBuffer
54  *
55  * PARAMETERS:  Buffer              - Buffer to dump
56  *              Count               - Amount to dump, in bytes
57  *              Display             - BYTE, WORD, DWORD, or QWORD display:
58  *                                      DB_BYTE_DISPLAY
59  *                                      DB_WORD_DISPLAY
60  *                                      DB_DWORD_DISPLAY
61  *                                      DB_QWORD_DISPLAY
62  *              BaseOffset          - Beginning buffer offset (display only)
63  *
64  * RETURN:      None
65  *
66  * DESCRIPTION: Generic dump buffer in both hex and ascii.
67  *
68  ******************************************************************************/
69 
70 void
AcpiUtDumpBuffer(UINT8 * Buffer,UINT32 Count,UINT32 Display,UINT32 BaseOffset)71 AcpiUtDumpBuffer (
72     UINT8                   *Buffer,
73     UINT32                  Count,
74     UINT32                  Display,
75     UINT32                  BaseOffset)
76 {
77     UINT32                  i = 0;
78     UINT32                  j;
79     UINT32                  Temp32;
80     UINT8                   BufChar;
81 
82 
83     if (!Buffer)
84     {
85         AcpiOsPrintf ("Null Buffer Pointer in DumpBuffer!\n");
86         return;
87     }
88 
89     if ((Count < 4) || (Count & 0x01))
90     {
91         Display = DB_BYTE_DISPLAY;
92     }
93 
94     /* Nasty little dump buffer routine! */
95 
96     while (i < Count)
97     {
98         /* Print current offset */
99 
100         AcpiOsPrintf ("%7.4X: ", (BaseOffset + i));
101 
102         /* Print 16 hex chars */
103 
104         for (j = 0; j < 16;)
105         {
106             if (i + j >= Count)
107             {
108                 /* Dump fill spaces */
109 
110                 AcpiOsPrintf ("%*s", ((Display * 2) + 1), " ");
111                 j += Display;
112                 continue;
113             }
114 
115             switch (Display)
116             {
117             case DB_BYTE_DISPLAY:
118             default:    /* Default is BYTE display */
119 
120                 AcpiOsPrintf ("%02X ", Buffer[(ACPI_SIZE) i + j]);
121                 break;
122 
123             case DB_WORD_DISPLAY:
124 
125                 ACPI_MOVE_16_TO_32 (&Temp32, &Buffer[(ACPI_SIZE) i + j]);
126                 AcpiOsPrintf ("%04X ", Temp32);
127                 break;
128 
129             case DB_DWORD_DISPLAY:
130 
131                 ACPI_MOVE_32_TO_32 (&Temp32, &Buffer[(ACPI_SIZE) i + j]);
132                 AcpiOsPrintf ("%08X ", Temp32);
133                 break;
134 
135             case DB_QWORD_DISPLAY:
136 
137                 ACPI_MOVE_32_TO_32 (&Temp32, &Buffer[(ACPI_SIZE) i + j]);
138                 AcpiOsPrintf ("%08X", Temp32);
139 
140                 ACPI_MOVE_32_TO_32 (&Temp32, &Buffer[(ACPI_SIZE) i + j + 4]);
141                 AcpiOsPrintf ("%08X ", Temp32);
142                 break;
143             }
144 
145             j += Display;
146         }
147 
148         /*
149          * Print the ASCII equivalent characters but watch out for the bad
150          * unprintable ones (printable chars are 0x20 through 0x7E)
151          */
152         AcpiOsPrintf (" ");
153         for (j = 0; j < 16; j++)
154         {
155             if (i + j >= Count)
156             {
157                 AcpiOsPrintf ("\n");
158                 return;
159             }
160 
161             /*
162              * Add comment characters so rest of line is ignored when
163              * compiled
164              */
165             if (j == 0)
166             {
167                 AcpiOsPrintf ("// ");
168             }
169 
170             BufChar = Buffer[(ACPI_SIZE) i + j];
171             if (isprint (BufChar))
172             {
173                 AcpiOsPrintf ("%c", BufChar);
174             }
175             else
176             {
177                 AcpiOsPrintf (".");
178             }
179         }
180 
181         /* Done with that line. */
182 
183         AcpiOsPrintf ("\n");
184         i += 16;
185     }
186 
187     return;
188 }
189 
190 
191 /*******************************************************************************
192  *
193  * FUNCTION:    AcpiUtDebugDumpBuffer
194  *
195  * PARAMETERS:  Buffer              - Buffer to dump
196  *              Count               - Amount to dump, in bytes
197  *              Display             - BYTE, WORD, DWORD, or QWORD display:
198  *                                      DB_BYTE_DISPLAY
199  *                                      DB_WORD_DISPLAY
200  *                                      DB_DWORD_DISPLAY
201  *                                      DB_QWORD_DISPLAY
202  *              ComponentID         - Caller's component ID
203  *
204  * RETURN:      None
205  *
206  * DESCRIPTION: Generic dump buffer in both hex and ascii.
207  *
208  ******************************************************************************/
209 
210 void
AcpiUtDebugDumpBuffer(UINT8 * Buffer,UINT32 Count,UINT32 Display,UINT32 ComponentId)211 AcpiUtDebugDumpBuffer (
212     UINT8                   *Buffer,
213     UINT32                  Count,
214     UINT32                  Display,
215     UINT32                  ComponentId)
216 {
217 
218     /* Only dump the buffer if tracing is enabled */
219 
220     if (!((ACPI_LV_TABLES & AcpiDbgLevel) &&
221         (ComponentId & AcpiDbgLayer)))
222     {
223         return;
224     }
225 
226     AcpiUtDumpBuffer (Buffer, Count, Display, 0);
227 }
228 
229 
230 #ifdef ACPI_APPLICATION
231 /*******************************************************************************
232  *
233  * FUNCTION:    AcpiUtDumpBufferToFile
234  *
235  * PARAMETERS:  File                - File descriptor
236  *              Buffer              - Buffer to dump
237  *              Count               - Amount to dump, in bytes
238  *              Display             - BYTE, WORD, DWORD, or QWORD display:
239  *                                      DB_BYTE_DISPLAY
240  *                                      DB_WORD_DISPLAY
241  *                                      DB_DWORD_DISPLAY
242  *                                      DB_QWORD_DISPLAY
243  *              BaseOffset          - Beginning buffer offset (display only)
244  *
245  * RETURN:      None
246  *
247  * DESCRIPTION: Generic dump buffer in both hex and ascii to a file.
248  *
249  ******************************************************************************/
250 
251 void
AcpiUtDumpBufferToFile(ACPI_FILE File,UINT8 * Buffer,UINT32 Count,UINT32 Display,UINT32 BaseOffset)252 AcpiUtDumpBufferToFile (
253     ACPI_FILE               File,
254     UINT8                   *Buffer,
255     UINT32                  Count,
256     UINT32                  Display,
257     UINT32                  BaseOffset)
258 {
259     UINT32                  i = 0;
260     UINT32                  j;
261     UINT32                  Temp32;
262     UINT8                   BufChar;
263 
264 
265     if (!Buffer)
266     {
267         AcpiUtFilePrintf (File, "Null Buffer Pointer in DumpBuffer!\n");
268         return;
269     }
270 
271     if ((Count < 4) || (Count & 0x01))
272     {
273         Display = DB_BYTE_DISPLAY;
274     }
275 
276     /* Nasty little dump buffer routine! */
277 
278     while (i < Count)
279     {
280         /* Print current offset */
281 
282         AcpiUtFilePrintf (File, "%7.4X: ", (BaseOffset + i));
283 
284         /* Print 16 hex chars */
285 
286         for (j = 0; j < 16;)
287         {
288             if (i + j >= Count)
289             {
290                 /* Dump fill spaces */
291 
292                 AcpiUtFilePrintf (File, "%*s", ((Display * 2) + 1), " ");
293                 j += Display;
294                 continue;
295             }
296 
297             switch (Display)
298             {
299             case DB_BYTE_DISPLAY:
300             default:    /* Default is BYTE display */
301 
302                 AcpiUtFilePrintf (File, "%02X ", Buffer[(ACPI_SIZE) i + j]);
303                 break;
304 
305             case DB_WORD_DISPLAY:
306 
307                 ACPI_MOVE_16_TO_32 (&Temp32, &Buffer[(ACPI_SIZE) i + j]);
308                 AcpiUtFilePrintf (File, "%04X ", Temp32);
309                 break;
310 
311             case DB_DWORD_DISPLAY:
312 
313                 ACPI_MOVE_32_TO_32 (&Temp32, &Buffer[(ACPI_SIZE) i + j]);
314                 AcpiUtFilePrintf (File, "%08X ", Temp32);
315                 break;
316 
317             case DB_QWORD_DISPLAY:
318 
319                 ACPI_MOVE_32_TO_32 (&Temp32, &Buffer[(ACPI_SIZE) i + j]);
320                 AcpiUtFilePrintf (File, "%08X", Temp32);
321 
322                 ACPI_MOVE_32_TO_32 (&Temp32, &Buffer[(ACPI_SIZE) i + j + 4]);
323                 AcpiUtFilePrintf (File, "%08X ", Temp32);
324                 break;
325             }
326 
327             j += Display;
328         }
329 
330         /*
331          * Print the ASCII equivalent characters but watch out for the bad
332          * unprintable ones (printable chars are 0x20 through 0x7E)
333          */
334         AcpiUtFilePrintf (File, " ");
335         for (j = 0; j < 16; j++)
336         {
337             if (i + j >= Count)
338             {
339                 AcpiUtFilePrintf (File, "\n");
340                 return;
341             }
342 
343             BufChar = Buffer[(ACPI_SIZE) i + j];
344             if (isprint (BufChar))
345             {
346                 AcpiUtFilePrintf (File, "%c", BufChar);
347             }
348             else
349             {
350                 AcpiUtFilePrintf (File, ".");
351             }
352         }
353 
354         /* Done with that line. */
355 
356         AcpiUtFilePrintf (File, "\n");
357         i += 16;
358     }
359 
360     return;
361 }
362 #endif
363