src/add-ons/kernel/bus_managers/acpi/acpica/components/utilities/utbuffer.c

   1 /******************************************************************************
   2  *
   3  * Module Name: utbuffer - Buffer dump routines
   4  *
   5  *****************************************************************************/
   6
   7 /******************************************************************************
   8  *
   9  * 1. Copyright Notice
  10  *
  11  * Some or all of this work - Copyright (c) 1999 - 2014, 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 #define __UTBUFFER_C__
 117
 118 #include "acpi.h"
 119 #include "accommon.h"
 120
 121 #define _COMPONENT          ACPI_UTILITIES
 122         ACPI_MODULE_NAME    ("utbuffer")
 123
 124
 125 /*******************************************************************************
 126  *
 127  * FUNCTION:    AcpiUtDumpBuffer
 128  *
 129  * PARAMETERS:  Buffer              - Buffer to dump
 130  *              Count               - Amount to dump, in bytes
 131  *              Display             - BYTE, WORD, DWORD, or QWORD display:
 132  *                                      DB_BYTE_DISPLAY
 133  *                                      DB_WORD_DISPLAY
 134  *                                      DB_DWORD_DISPLAY
 135  *                                      DB_QWORD_DISPLAY
 136  *              BaseOffset          - Beginning buffer offset (display only)
 137  *
 138  * RETURN:      None
 139  *
 140  * DESCRIPTION: Generic dump buffer in both hex and ascii.
 141  *
 142  ******************************************************************************/
 143
 144 void
 145 AcpiUtDumpBuffer (
 146     UINT8                   *Buffer,
 147     UINT32                  Count,
 148     UINT32                  Display,
 149     UINT32                  BaseOffset)
 150 {
 151     UINT32                  i = 0;
 152     UINT32                  j;
 153     UINT32                  Temp32;
 154     UINT8                   BufChar;
 155
 156
 157     if (!Buffer)
 158     {
 159         AcpiOsPrintf ("Null Buffer Pointer in DumpBuffer!\n");
 160         return;
 161     }
 162
 163     if ((Count < 4) || (Count & 0x01))
 164     {
 165         Display = DB_BYTE_DISPLAY;
 166     }
 167
 168     /* Nasty little dump buffer routine! */
 169
 170     while (i < Count)
 171     {
 172         /* Print current offset */
 173
 174         AcpiOsPrintf ("%6.4X: ", (BaseOffset + i));
 175
 176         /* Print 16 hex chars */
 177
 178         for (j = 0; j < 16;)
 179         {
 180             if (i + j >= Count)
 181             {
 182                 /* Dump fill spaces */
 183
 184                 AcpiOsPrintf ("%*s", ((Display * 2) + 1), " ");
 185                 j += Display;
 186                 continue;
 187             }
 188
 189             switch (Display)
 190             {
 191             case DB_BYTE_DISPLAY:
 192             default:    /* Default is BYTE display */
 193
 194                 AcpiOsPrintf ("%02X ", Buffer[(ACPI_SIZE) i + j]);
 195                 break;
 196
 197             case DB_WORD_DISPLAY:
 198
 199                 ACPI_MOVE_16_TO_32 (&Temp32, &Buffer[(ACPI_SIZE) i + j]);
 200                 AcpiOsPrintf ("%04X ", Temp32);
 201                 break;
 202
 203             case DB_DWORD_DISPLAY:
 204
 205                 ACPI_MOVE_32_TO_32 (&Temp32, &Buffer[(ACPI_SIZE) i + j]);
 206                 AcpiOsPrintf ("%08X ", Temp32);
 207                 break;
 208
 209             case DB_QWORD_DISPLAY:
 210
 211                 ACPI_MOVE_32_TO_32 (&Temp32, &Buffer[(ACPI_SIZE) i + j]);
 212                 AcpiOsPrintf ("%08X", Temp32);
 213
 214                 ACPI_MOVE_32_TO_32 (&Temp32, &Buffer[(ACPI_SIZE) i + j + 4]);
 215                 AcpiOsPrintf ("%08X ", Temp32);
 216                 break;
 217             }
 218
 219             j += Display;
 220         }
 221
 222         /*
 223          * Print the ASCII equivalent characters but watch out for the bad
 224          * unprintable ones (printable chars are 0x20 through 0x7E)
 225          */
 226         AcpiOsPrintf (" ");
 227         for (j = 0; j < 16; j++)
 228         {
 229             if (i + j >= Count)
 230             {
 231                 AcpiOsPrintf ("\n");
 232                 return;
 233             }
 234
 235             BufChar = Buffer[(ACPI_SIZE) i + j];
 236             if (ACPI_IS_PRINT (BufChar))
 237             {
 238                 AcpiOsPrintf ("%c", BufChar);
 239             }
 240             else
 241             {
 242                 AcpiOsPrintf (".");
 243             }
 244         }
 245
 246         /* Done with that line. */
 247
 248         AcpiOsPrintf ("\n");
 249         i += 16;
 250     }
 251
 252     return;
 253 }
 254
 255
 256 /*******************************************************************************
 257  *
 258  * FUNCTION:    AcpiUtDebugDumpBuffer
 259  *
 260  * PARAMETERS:  Buffer              - Buffer to dump
 261  *              Count               - Amount to dump, in bytes
 262  *              Display             - BYTE, WORD, DWORD, or QWORD display:
 263  *                                      DB_BYTE_DISPLAY
 264  *                                      DB_WORD_DISPLAY
 265  *                                      DB_DWORD_DISPLAY
 266  *                                      DB_QWORD_DISPLAY
 267  *              ComponentID         - Caller's component ID
 268  *
 269  * RETURN:      None
 270  *
 271  * DESCRIPTION: Generic dump buffer in both hex and ascii.
 272  *
 273  ******************************************************************************/
 274
 275 void
 276 AcpiUtDebugDumpBuffer (
 277     UINT8                   *Buffer,
 278     UINT32                  Count,
 279     UINT32                  Display,
 280     UINT32                  ComponentId)
 281 {
 282
 283     /* Only dump the buffer if tracing is enabled */
 284
 285     if (!((ACPI_LV_TABLES & AcpiDbgLevel) &&
 286         (ComponentId & AcpiDbgLayer)))
 287     {
 288         return;
 289     }
 290
 291     AcpiUtDumpBuffer (Buffer, Count, Display, 0);
 292 }
 293
 294
 295 #ifdef ACPI_APPLICATION
 296 /*******************************************************************************
 297  *
 298  * FUNCTION:    AcpiUtDumpBufferToFile
 299  *
 300  * PARAMETERS:  File                - File descriptor
 301  *              Buffer              - Buffer to dump
 302  *              Count               - Amount to dump, in bytes
 303  *              Display             - BYTE, WORD, DWORD, or QWORD display:
 304  *                                      DB_BYTE_DISPLAY
 305  *                                      DB_WORD_DISPLAY
 306  *                                      DB_DWORD_DISPLAY
 307  *                                      DB_QWORD_DISPLAY
 308  *              BaseOffset          - Beginning buffer offset (display only)
 309  *
 310  * RETURN:      None
 311  *
 312  * DESCRIPTION: Generic dump buffer in both hex and ascii to a file.
 313  *
 314  ******************************************************************************/
 315
 316 void
 317 AcpiUtDumpBufferToFile (
 318     ACPI_FILE               File,
 319     UINT8                   *Buffer,
 320     UINT32                  Count,
 321     UINT32                  Display,
 322     UINT32                  BaseOffset)
 323 {
 324     UINT32                  i = 0;
 325     UINT32                  j;
 326     UINT32                  Temp32;
 327     UINT8                   BufChar;
 328
 329
 330     if (!Buffer)
 331     {
 332         AcpiUtFilePrintf (File, "Null Buffer Pointer in DumpBuffer!\n");
 333         return;
 334     }
 335
 336     if ((Count < 4) || (Count & 0x01))
 337     {
 338         Display = DB_BYTE_DISPLAY;
 339     }
 340
 341     /* Nasty little dump buffer routine! */
 342
 343     while (i < Count)
 344     {
 345         /* Print current offset */
 346
 347         AcpiUtFilePrintf (File, "%6.4X: ", (BaseOffset + i));
 348
 349         /* Print 16 hex chars */
 350
 351         for (j = 0; j < 16;)
 352         {
 353             if (i + j >= Count)
 354             {
 355                 /* Dump fill spaces */
 356
 357                 AcpiUtFilePrintf (File, "%*s", ((Display * 2) + 1), " ");
 358                 j += Display;
 359                 continue;
 360             }
 361
 362             switch (Display)
 363             {
 364             case DB_BYTE_DISPLAY:
 365             default:    /* Default is BYTE display */
 366
 367                 AcpiUtFilePrintf (File, "%02X ", Buffer[(ACPI_SIZE) i + j]);
 368                 break;
 369
 370             case DB_WORD_DISPLAY:
 371
 372                 ACPI_MOVE_16_TO_32 (&Temp32, &Buffer[(ACPI_SIZE) i + j]);
 373                 AcpiUtFilePrintf (File, "%04X ", Temp32);
 374                 break;
 375
 376             case DB_DWORD_DISPLAY:
 377
 378                 ACPI_MOVE_32_TO_32 (&Temp32, &Buffer[(ACPI_SIZE) i + j]);
 379                 AcpiUtFilePrintf (File, "%08X ", Temp32);
 380                 break;
 381
 382             case DB_QWORD_DISPLAY:
 383
 384                 ACPI_MOVE_32_TO_32 (&Temp32, &Buffer[(ACPI_SIZE) i + j]);
 385                 AcpiUtFilePrintf (File, "%08X", Temp32);
 386
 387                 ACPI_MOVE_32_TO_32 (&Temp32, &Buffer[(ACPI_SIZE) i + j + 4]);
 388                 AcpiUtFilePrintf (File, "%08X ", Temp32);
 389                 break;
 390             }
 391
 392             j += Display;
 393         }
 394
 395         /*
 396          * Print the ASCII equivalent characters but watch out for the bad
 397          * unprintable ones (printable chars are 0x20 through 0x7E)
 398          */
 399         AcpiUtFilePrintf (File, " ");
 400         for (j = 0; j < 16; j++)
 401         {
 402             if (i + j >= Count)
 403             {
 404                 AcpiUtFilePrintf (File, "\n");
 405                 return;
 406             }
 407
 408             BufChar = Buffer[(ACPI_SIZE) i + j];
 409             if (ACPI_IS_PRINT (BufChar))
 410             {
 411                 AcpiUtFilePrintf (File, "%c", BufChar);
 412             }
 413             else
 414             {
 415                 AcpiUtFilePrintf (File, ".");
 416             }
 417         }
 418
 419         /* Done with that line. */
 420
 421         AcpiUtFilePrintf (File, "\n");
 422         i += 16;
 423     }
 424
 425     return;
 426 }
 427 #endif