1 /******************************************************************************
2 *
3 * Module Name: utbuffer - Buffer dump routines
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2014, 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 ("%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 BufChar = Buffer[(ACPI_SIZE) i + j];
162 if (ACPI_IS_PRINT (BufChar))
163 {
164 AcpiOsPrintf ("%c", BufChar);
165 }
166 else
167 {
168 AcpiOsPrintf (".");
169 }
170 }
171
172 /* Done with that line. */
173
174 AcpiOsPrintf ("\n");
175 i += 16;
176 }
177
178 return;
179 }
180
181
182 /*******************************************************************************
183 *
184 * FUNCTION: AcpiUtDebugDumpBuffer
185 *
186 * PARAMETERS: Buffer - Buffer to dump
187 * Count - Amount to dump, in bytes
188 * Display - BYTE, WORD, DWORD, or QWORD display:
189 * DB_BYTE_DISPLAY
190 * DB_WORD_DISPLAY
191 * DB_DWORD_DISPLAY
192 * DB_QWORD_DISPLAY
193 * ComponentID - Caller's component ID
194 *
195 * RETURN: None
196 *
197 * DESCRIPTION: Generic dump buffer in both hex and ascii.
198 *
199 ******************************************************************************/
200
201 void
AcpiUtDebugDumpBuffer(UINT8 * Buffer,UINT32 Count,UINT32 Display,UINT32 ComponentId)202 AcpiUtDebugDumpBuffer (
203 UINT8 *Buffer,
204 UINT32 Count,
205 UINT32 Display,
206 UINT32 ComponentId)
207 {
208
209 /* Only dump the buffer if tracing is enabled */
210
211 if (!((ACPI_LV_TABLES & AcpiDbgLevel) &&
212 (ComponentId & AcpiDbgLayer)))
213 {
214 return;
215 }
216
217 AcpiUtDumpBuffer (Buffer, Count, Display, 0);
218 }
219
220
221 #ifdef ACPI_APPLICATION
222 /*******************************************************************************
223 *
224 * FUNCTION: AcpiUtDumpBufferToFile
225 *
226 * PARAMETERS: File - File descriptor
227 * Buffer - Buffer to dump
228 * Count - Amount to dump, in bytes
229 * Display - BYTE, WORD, DWORD, or QWORD display:
230 * DB_BYTE_DISPLAY
231 * DB_WORD_DISPLAY
232 * DB_DWORD_DISPLAY
233 * DB_QWORD_DISPLAY
234 * BaseOffset - Beginning buffer offset (display only)
235 *
236 * RETURN: None
237 *
238 * DESCRIPTION: Generic dump buffer in both hex and ascii to a file.
239 *
240 ******************************************************************************/
241
242 void
AcpiUtDumpBufferToFile(ACPI_FILE File,UINT8 * Buffer,UINT32 Count,UINT32 Display,UINT32 BaseOffset)243 AcpiUtDumpBufferToFile (
244 ACPI_FILE File,
245 UINT8 *Buffer,
246 UINT32 Count,
247 UINT32 Display,
248 UINT32 BaseOffset)
249 {
250 UINT32 i = 0;
251 UINT32 j;
252 UINT32 Temp32;
253 UINT8 BufChar;
254
255
256 if (!Buffer)
257 {
258 AcpiUtFilePrintf (File, "Null Buffer Pointer in DumpBuffer!\n");
259 return;
260 }
261
262 if ((Count < 4) || (Count & 0x01))
263 {
264 Display = DB_BYTE_DISPLAY;
265 }
266
267 /* Nasty little dump buffer routine! */
268
269 while (i < Count)
270 {
271 /* Print current offset */
272
273 AcpiUtFilePrintf (File, "%6.4X: ", (BaseOffset + i));
274
275 /* Print 16 hex chars */
276
277 for (j = 0; j < 16;)
278 {
279 if (i + j >= Count)
280 {
281 /* Dump fill spaces */
282
283 AcpiUtFilePrintf (File, "%*s", ((Display * 2) + 1), " ");
284 j += Display;
285 continue;
286 }
287
288 switch (Display)
289 {
290 case DB_BYTE_DISPLAY:
291 default: /* Default is BYTE display */
292
293 AcpiUtFilePrintf (File, "%02X ", Buffer[(ACPI_SIZE) i + j]);
294 break;
295
296 case DB_WORD_DISPLAY:
297
298 ACPI_MOVE_16_TO_32 (&Temp32, &Buffer[(ACPI_SIZE) i + j]);
299 AcpiUtFilePrintf (File, "%04X ", Temp32);
300 break;
301
302 case DB_DWORD_DISPLAY:
303
304 ACPI_MOVE_32_TO_32 (&Temp32, &Buffer[(ACPI_SIZE) i + j]);
305 AcpiUtFilePrintf (File, "%08X ", Temp32);
306 break;
307
308 case DB_QWORD_DISPLAY:
309
310 ACPI_MOVE_32_TO_32 (&Temp32, &Buffer[(ACPI_SIZE) i + j]);
311 AcpiUtFilePrintf (File, "%08X", Temp32);
312
313 ACPI_MOVE_32_TO_32 (&Temp32, &Buffer[(ACPI_SIZE) i + j + 4]);
314 AcpiUtFilePrintf (File, "%08X ", Temp32);
315 break;
316 }
317
318 j += Display;
319 }
320
321 /*
322 * Print the ASCII equivalent characters but watch out for the bad
323 * unprintable ones (printable chars are 0x20 through 0x7E)
324 */
325 AcpiUtFilePrintf (File, " ");
326 for (j = 0; j < 16; j++)
327 {
328 if (i + j >= Count)
329 {
330 AcpiUtFilePrintf (File, "\n");
331 return;
332 }
333
334 BufChar = Buffer[(ACPI_SIZE) i + j];
335 if (ACPI_IS_PRINT (BufChar))
336 {
337 AcpiUtFilePrintf (File, "%c", BufChar);
338 }
339 else
340 {
341 AcpiUtFilePrintf (File, ".");
342 }
343 }
344
345 /* Done with that line. */
346
347 AcpiUtFilePrintf (File, "\n");
348 i += 16;
349 }
350
351 return;
352 }
353 #endif
354