utbuffer.c revision 306536 
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 <contrib/dev/acpica/include/acpi.h>
45#include <contrib/dev/acpica/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
70void
71AcpiUtDumpBuffer (
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 ("%6.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
210void
211AcpiUtDebugDumpBuffer (
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
251void
252AcpiUtDumpBufferToFile (
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, "%6.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