sys/contrib/dev/acpica/components/disassembler/dmbuffer.c

   1 /*******************************************************************************
   2  *
   3  * Module Name: dmbuffer - AML disassembler, buffer and string support
   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 #include <contrib/dev/acpica/include/acutils.h>
  47 #include <contrib/dev/acpica/include/acdisasm.h>
  48 #include <contrib/dev/acpica/include/acparser.h>
  49 #include <contrib/dev/acpica/include/amlcode.h>
  50 #include <contrib/dev/acpica/include/acinterp.h>
  51
  52
  53 #define _COMPONENT          ACPI_CA_DEBUGGER
  54         ACPI_MODULE_NAME    ("dmbuffer")
  55
  56 /* Local prototypes */
  57
  58 static void
  59 AcpiDmUuid (
  60     ACPI_PARSE_OBJECT       *Op);
  61
  62 static void
  63 AcpiDmUnicode (
  64     ACPI_PARSE_OBJECT       *Op);
  65
  66 static void
  67 AcpiDmGetHardwareIdType (
  68     ACPI_PARSE_OBJECT       *Op);
  69
  70 static void
  71 AcpiDmPldBuffer (
  72     UINT32                  Level,
  73     UINT8                   *ByteData,
  74     UINT32                  ByteCount);
  75
  76 static const char *
  77 AcpiDmFindNameByIndex (
  78     UINT64                  Index,
  79     const char              **List);
  80
  81
  82 #define ACPI_BUFFER_BYTES_PER_LINE      8
  83
  84
  85 /*******************************************************************************
  86  *
  87  * FUNCTION:    AcpiDmDisasmByteList
  88  *
  89  * PARAMETERS:  Level               - Current source code indentation level
  90  *              ByteData            - Pointer to the byte list
  91  *              ByteCount           - Length of the byte list
  92  *
  93  * RETURN:      None
  94  *
  95  * DESCRIPTION: Dump an AML "ByteList" in Hex format. 8 bytes per line, prefixed
  96  *              with the hex buffer offset.
  97  *
  98  ******************************************************************************/
  99
 100 void
 101 AcpiDmDisasmByteList (
 102     UINT32                  Level,
 103     UINT8                   *ByteData,
 104     UINT32                  ByteCount)
 105 {
 106     UINT32                  i;
 107     UINT32                  j;
 108     UINT32                  CurrentIndex;
 109     UINT8                   BufChar;
 110
 111
 112     if (!ByteCount)
 113     {
 114         return;
 115     }
 116
 117     for (i = 0; i < ByteCount; i += ACPI_BUFFER_BYTES_PER_LINE)
 118     {
 119         /* Line indent and offset prefix for each new line */
 120
 121         AcpiDmIndent (Level);
 122         if (ByteCount > ACPI_BUFFER_BYTES_PER_LINE)
 123         {
 124             AcpiOsPrintf ("/* %04X */ ", i);
 125         }
 126
 127         /* Dump the actual hex values */
 128
 129         for (j = 0; j < ACPI_BUFFER_BYTES_PER_LINE; j++)
 130         {
 131             CurrentIndex = i + j;
 132             if (CurrentIndex >= ByteCount)
 133             {
 134                 /* Dump fill spaces */
 135
 136                 AcpiOsPrintf ("      ");
 137                 continue;
 138             }
 139
 140             AcpiOsPrintf (" 0x%2.2X", ByteData[CurrentIndex]);
 141
 142             /* Add comma if there are more bytes to display */
 143
 144             if (CurrentIndex < (ByteCount - 1))
 145             {
 146                 AcpiOsPrintf (",");
 147             }
 148             else
 149             {
 150                 AcpiOsPrintf (" ");
 151             }
 152         }
 153
 154         /* Dump the ASCII equivalents within a comment */
 155
 156         AcpiOsPrintf ("  /* ");
 157         for (j = 0; j < ACPI_BUFFER_BYTES_PER_LINE; j++)
 158         {
 159             CurrentIndex = i + j;
 160             if (CurrentIndex >= ByteCount)
 161             {
 162                 break;
 163             }
 164
 165             BufChar = ByteData[CurrentIndex];
 166             if (isprint (BufChar))
 167             {
 168                 AcpiOsPrintf ("%c", BufChar);
 169             }
 170             else
 171             {
 172                 AcpiOsPrintf (".");
 173             }
 174         }
 175
 176         /* Finished with this line */
 177
 178         AcpiOsPrintf (" */\n");
 179     }
 180 }
 181
 182
 183 /*******************************************************************************
 184  *
 185  * FUNCTION:    AcpiDmByteList
 186  *
 187  * PARAMETERS:  Info            - Parse tree walk info
 188  *              Op              - Byte list op
 189  *
 190  * RETURN:      None
 191  *
 192  * DESCRIPTION: Dump a buffer byte list, handling the various types of buffers.
 193  *              Buffer type must be already set in the Op DisasmOpcode.
 194  *
 195  ******************************************************************************/
 196
 197 void
 198 AcpiDmByteList (
 199     ACPI_OP_WALK_INFO       *Info,
 200     ACPI_PARSE_OBJECT       *Op)
 201 {
 202     UINT8                   *ByteData;
 203     UINT32                  ByteCount;
 204
 205
 206     ByteData = Op->Named.Data;
 207     ByteCount = (UINT32) Op->Common.Value.Integer;
 208
 209     /*
 210      * The byte list belongs to a buffer, and can be produced by either
 211      * a ResourceTemplate, Unicode, quoted string, or a plain byte list.
 212      */
 213     switch (Op->Common.Parent->Common.DisasmOpcode)
 214     {
 215     case ACPI_DASM_RESOURCE:
 216
 217         AcpiDmResourceTemplate (
 218             Info, Op->Common.Parent, ByteData, ByteCount);
 219         break;
 220
 221     case ACPI_DASM_STRING:
 222
 223         AcpiDmIndent (Info->Level);
 224         AcpiUtPrintString ((char *) ByteData, ACPI_UINT16_MAX);
 225         AcpiOsPrintf ("\n");
 226         break;
 227
 228     case ACPI_DASM_UUID:
 229
 230         AcpiDmUuid (Op);
 231         break;
 232
 233     case ACPI_DASM_UNICODE:
 234
 235         AcpiDmUnicode (Op);
 236         break;
 237
 238     case ACPI_DASM_PLD_METHOD:
 239 #if 0
 240         AcpiDmDisasmByteList (Info->Level, ByteData, ByteCount);
 241 #endif
 242         AcpiDmPldBuffer (Info->Level, ByteData, ByteCount);
 243         break;
 244
 245     case ACPI_DASM_BUFFER:
 246     default:
 247         /*
 248          * Not a resource, string, or unicode string.
 249          * Just dump the buffer
 250          */
 251         AcpiDmDisasmByteList (Info->Level, ByteData, ByteCount);
 252         break;
 253     }
 254 }
 255
 256
 257 /*******************************************************************************
 258  *
 259  * FUNCTION:    AcpiDmIsUuidBuffer
 260  *
 261  * PARAMETERS:  Op              - Buffer Object to be examined
 262  *
 263  * RETURN:      TRUE if buffer contains a UUID
 264  *
 265  * DESCRIPTION: Determine if a buffer Op contains a UUID
 266  *
 267  * To help determine whether the buffer is a UUID versus a raw data buffer,
 268  * there a are a couple bytes we can look at:
 269  *
 270  *    xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx
 271  *
 272  * The variant covered by the UUID specification is indicated by the two most
 273  * significant bits of N being 1 0 (i.e., the hexadecimal N will always be
 274  * 8, 9, A, or B).
 275  *
 276  * The variant covered by the UUID specification has five versions. For this
 277  * variant, the four bits of M indicates the UUID version (i.e., the
 278  * hexadecimal M will be either 1, 2, 3, 4, or 5).
 279  *
 280  ******************************************************************************/
 281
 282 BOOLEAN
 283 AcpiDmIsUuidBuffer (
 284     ACPI_PARSE_OBJECT       *Op)
 285 {
 286     UINT8                   *ByteData;
 287     UINT32                  ByteCount;
 288     ACPI_PARSE_OBJECT       *SizeOp;
 289     ACPI_PARSE_OBJECT       *NextOp;
 290
 291
 292     /* Buffer size is the buffer argument */
 293
 294     SizeOp = Op->Common.Value.Arg;
 295
 296     /* Next, the initializer byte list to examine */
 297
 298     NextOp = SizeOp->Common.Next;
 299     if (!NextOp)
 300     {
 301         return (FALSE);
 302     }
 303
 304     /* Extract the byte list info */
 305
 306     ByteData = NextOp->Named.Data;
 307     ByteCount = (UINT32) NextOp->Common.Value.Integer;
 308
 309     /* Byte count must be exactly 16 */
 310
 311     if (ByteCount != UUID_BUFFER_LENGTH)
 312     {
 313         return (FALSE);
 314     }
 315
 316     /* Check for valid "M" and "N" values (see function header above) */
 317
 318     if (((ByteData[7] & 0xF0) == 0x00) || /* M={1,2,3,4,5} */
 319         ((ByteData[7] & 0xF0) > 0x50)  ||
 320         ((ByteData[8] & 0xF0) < 0x80)  || /* N={8,9,A,B} */
 321         ((ByteData[8] & 0xF0) > 0xB0))
 322     {
 323         return (FALSE);
 324     }
 325
 326     /* Ignore the Size argument in the disassembly of this buffer op */
 327
 328     SizeOp->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
 329     return (TRUE);
 330 }
 331
 332
 333 /*******************************************************************************
 334  *
 335  * FUNCTION:    AcpiDmUuid
 336  *
 337  * PARAMETERS:  Op              - Byte List op containing a UUID
 338  *
 339  * RETURN:      None
 340  *
 341  * DESCRIPTION: Dump a buffer containing a UUID as a standard ASCII string.
 342  *
 343  * Output Format:
 344  * In its canonical form, the UUID is represented by a string containing 32
 345  * lowercase hexadecimal digits, displayed in 5 groups separated by hyphens.
 346  * The complete form is 8-4-4-4-12 for a total of 36 characters (32
 347  * alphanumeric characters representing hex digits and 4 hyphens). In bytes,
 348  * 4-2-2-2-6. Example:
 349  *
 350  *    ToUUID ("107ededd-d381-4fd7-8da9-08e9a6c79644")
 351  *
 352  ******************************************************************************/
 353
 354 static void
 355 AcpiDmUuid (
 356     ACPI_PARSE_OBJECT       *Op)
 357 {
 358     UINT8                   *Data;
 359     const char              *Description;
 360
 361
 362     Data = ACPI_CAST_PTR (UINT8, Op->Named.Data);
 363
 364     /* Emit the 36-byte UUID string in the proper format/order */
 365
 366     AcpiOsPrintf (
 367         "\"%2.2x%2.2x%2.2x%2.2x-"
 368         "%2.2x%2.2x-"
 369         "%2.2x%2.2x-"
 370         "%2.2x%2.2x-"
 371         "%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x\")",
 372         Data[3], Data[2], Data[1], Data[0],
 373         Data[5], Data[4],
 374         Data[7], Data[6],
 375         Data[8], Data[9],
 376         Data[10], Data[11], Data[12], Data[13], Data[14], Data[15]);
 377
 378     /* Dump the UUID description string if available */
 379
 380     Description = AcpiAhMatchUuid (Data);
 381     if (Description)
 382     {
 383         AcpiOsPrintf (" /* %s */", Description);
 384     }
 385 }
 386
 387
 388 /*******************************************************************************
 389  *
 390  * FUNCTION:    AcpiDmIsUnicodeBuffer
 391  *
 392  * PARAMETERS:  Op              - Buffer Object to be examined
 393  *
 394  * RETURN:      TRUE if buffer contains a UNICODE string
 395  *
 396  * DESCRIPTION: Determine if a buffer Op contains a Unicode string
 397  *
 398  ******************************************************************************/
 399
 400 BOOLEAN
 401 AcpiDmIsUnicodeBuffer (
 402     ACPI_PARSE_OBJECT       *Op)
 403 {
 404     UINT8                   *ByteData;
 405     UINT32                  ByteCount;
 406     UINT32                  WordCount;
 407     ACPI_PARSE_OBJECT       *SizeOp;
 408     ACPI_PARSE_OBJECT       *NextOp;
 409     UINT32                  i;
 410
 411
 412     /* Buffer size is the buffer argument */
 413
 414     SizeOp = Op->Common.Value.Arg;
 415
 416     /* Next, the initializer byte list to examine */
 417
 418     NextOp = SizeOp->Common.Next;
 419     if (!NextOp)
 420     {
 421         return (FALSE);
 422     }
 423
 424     /* Extract the byte list info */
 425
 426     ByteData = NextOp->Named.Data;
 427     ByteCount = (UINT32) NextOp->Common.Value.Integer;
 428     WordCount = ACPI_DIV_2 (ByteCount);
 429
 430     /*
 431      * Unicode string must have an even number of bytes and last
 432      * word must be zero
 433      */
 434     if ((!ByteCount)     ||
 435          (ByteCount < 4) ||
 436          (ByteCount & 1) ||
 437         ((UINT16 *) (void *) ByteData)[WordCount - 1] != 0)
 438     {
 439         return (FALSE);
 440     }
 441
 442     /*
 443      * For each word, 1st byte must be printable ascii, and the
 444      * 2nd byte must be zero. This does not allow for escape
 445      * sequences, but it is the most secure way to detect a
 446      * unicode string.
 447      */
 448     for (i = 0; i < (ByteCount - 2); i += 2)
 449     {
 450         if ((ByteData[i] == 0) ||
 451             !(isprint (ByteData[i])) ||
 452             (ByteData[(ACPI_SIZE) i + 1] != 0))
 453         {
 454             return (FALSE);
 455         }
 456     }
 457
 458     /* Ignore the Size argument in the disassembly of this buffer op */
 459
 460     SizeOp->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
 461     return (TRUE);
 462 }
 463
 464
 465 /*******************************************************************************
 466  *
 467  * FUNCTION:    AcpiDmIsStringBuffer
 468  *
 469  * PARAMETERS:  Op              - Buffer Object to be examined
 470  *
 471  * RETURN:      TRUE if buffer contains a ASCII string, FALSE otherwise
 472  *
 473  * DESCRIPTION: Determine if a buffer Op contains a ASCII string
 474  *
 475  ******************************************************************************/
 476
 477 BOOLEAN
 478 AcpiDmIsStringBuffer (
 479     ACPI_PARSE_OBJECT       *Op)
 480 {
 481     UINT8                   *ByteData;
 482     UINT32                  ByteCount;
 483     ACPI_PARSE_OBJECT       *SizeOp;
 484     ACPI_PARSE_OBJECT       *NextOp;
 485     UINT32                  i;
 486
 487
 488     /* Buffer size is the buffer argument */
 489
 490     SizeOp = Op->Common.Value.Arg;
 491
 492     /* Next, the initializer byte list to examine */
 493
 494     NextOp = SizeOp->Common.Next;
 495     if (!NextOp)
 496     {
 497         return (FALSE);
 498     }
 499
 500     /* Extract the byte list info */
 501
 502     ByteData = NextOp->Named.Data;
 503     ByteCount = (UINT32) NextOp->Common.Value.Integer;
 504
 505     /* Last byte must be the null terminator */
 506
 507     if ((!ByteCount)     ||
 508          (ByteCount < 2) ||
 509          (ByteData[ByteCount-1] != 0))
 510     {
 511         return (FALSE);
 512     }
 513
 514     /*
 515      * Check for a possible standalone resource EndTag, ignore it
 516      * here. However, this sequence is also the string "Y", but
 517      * this seems rare enough to be acceptable.
 518      */
 519     if ((ByteCount == 2) && (ByteData[0] == 0x79))
 520     {
 521         return (FALSE);
 522     }
 523
 524     /* Check all bytes for ASCII */
 525
 526     for (i = 0; i < (ByteCount - 1); i++)
 527     {
 528         /*
 529          * TBD: allow some escapes (non-ascii chars).
 530          * they will be handled in the string output routine
 531          */
 532
 533         /* Not a string if not printable ascii */
 534
 535         if (!isprint (ByteData[i]))
 536         {
 537             return (FALSE);
 538         }
 539     }
 540
 541     return (TRUE);
 542 }
 543
 544
 545 /*******************************************************************************
 546  *
 547  * FUNCTION:    AcpiDmIsPldBuffer
 548  *
 549  * PARAMETERS:  Op                  - Buffer Object to be examined
 550  *
 551  * RETURN:      TRUE if buffer appears to contain data produced via the
 552  *              ToPLD macro, FALSE otherwise
 553  *
 554  * DESCRIPTION: Determine if a buffer Op contains a _PLD structure
 555  *
 556  ******************************************************************************/
 557
 558 BOOLEAN
 559 AcpiDmIsPldBuffer (
 560     ACPI_PARSE_OBJECT       *Op)
 561 {
 562     ACPI_NAMESPACE_NODE     *Node;
 563     ACPI_PARSE_OBJECT       *SizeOp;
 564     ACPI_PARSE_OBJECT       *ByteListOp;
 565     ACPI_PARSE_OBJECT       *ParentOp;
 566     UINT64                  BufferSize;
 567     UINT64                  InitializerSize;
 568
 569
 570     /*
 571      * Get the BufferSize argument - Buffer(BufferSize)
 572      * If the buffer was generated by the ToPld macro, it must
 573      * be a BYTE constant.
 574      */
 575     SizeOp = Op->Common.Value.Arg;
 576     if (SizeOp->Common.AmlOpcode != AML_BYTE_OP)
 577     {
 578         return (FALSE);
 579     }
 580
 581     /* Check the declared BufferSize, two possibilities */
 582
 583     BufferSize = SizeOp->Common.Value.Integer;
 584     if ((BufferSize != ACPI_PLD_REV1_BUFFER_SIZE) &&
 585         (BufferSize != ACPI_PLD_REV2_BUFFER_SIZE))
 586     {
 587         return (FALSE);
 588     }
 589
 590     /*
 591      * Check the initializer list length. This is the actual
 592      * number of bytes in the buffer as counted by the AML parser.
 593      * The declared BufferSize can be larger than the actual length.
 594      * However, for the ToPLD macro, the BufferSize will be the same
 595      * as the initializer list length.
 596      */
 597     ByteListOp = SizeOp->Common.Next;
 598     if (!ByteListOp)
 599     {
 600         return (FALSE); /* Zero-length buffer case */
 601     }
 602
 603     InitializerSize = ByteListOp->Common.Value.Integer;
 604     if ((InitializerSize != ACPI_PLD_REV1_BUFFER_SIZE) &&
 605         (InitializerSize != ACPI_PLD_REV2_BUFFER_SIZE))
 606     {
 607         return (FALSE);
 608     }
 609
 610     /* Final size check */
 611
 612     if (BufferSize != InitializerSize)
 613     {
 614         return (FALSE);
 615     }
 616
 617     /* Now examine the buffer parent */
 618
 619     ParentOp = Op->Common.Parent;
 620     if (!ParentOp)
 621     {
 622         return (FALSE);
 623     }
 624
 625     /* Check for form: Name(_PLD, Buffer() {}). Not legal, however */
 626
 627     if (ParentOp->Common.AmlOpcode == AML_NAME_OP)
 628     {
 629         Node = ParentOp->Common.Node;
 630
 631         if (ACPI_COMPARE_NAME (Node->Name.Ascii, METHOD_NAME__PLD))
 632         {
 633             /* Ignore the Size argument in the disassembly of this buffer op */
 634
 635             SizeOp->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
 636             return (TRUE);
 637         }
 638
 639         return (FALSE);
 640     }
 641
 642     /*
 643      * Check for proper form: Name(_PLD, Package() {ToPLD()})
 644      *
 645      * Note: All other forms such as
 646      *      Return (Package() {ToPLD()})
 647      *      Local0 = ToPLD()
 648      * etc. are not converted back to the ToPLD macro, because
 649      * there is really no deterministic way to disassemble the buffer
 650      * back to the ToPLD macro, other than trying to find the "_PLD"
 651      * name
 652      */
 653     if (ParentOp->Common.AmlOpcode == AML_PACKAGE_OP)
 654     {
 655         ParentOp = ParentOp->Common.Parent;
 656         if (!ParentOp)
 657         {
 658             return (FALSE);
 659         }
 660
 661         if (ParentOp->Common.AmlOpcode == AML_NAME_OP)
 662         {
 663             Node = ParentOp->Common.Node;
 664
 665             if (ACPI_COMPARE_NAME (Node->Name.Ascii, METHOD_NAME__PLD))
 666             {
 667                 /* Ignore the Size argument in the disassembly of this buffer op */
 668
 669                 SizeOp->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
 670                 return (TRUE);
 671             }
 672         }
 673     }
 674
 675     return (FALSE);
 676 }
 677
 678
 679 /*******************************************************************************
 680  *
 681  * FUNCTION:    AcpiDmFindNameByIndex
 682  *
 683  * PARAMETERS:  Index               - Index of array to check
 684  *              List                - Array to reference
 685  *
 686  * RETURN:      String from List or empty string
 687  *
 688  * DESCRIPTION: Finds and returns the char string located at the given index
 689  *              position in List.
 690  *
 691  ******************************************************************************/
 692
 693 static const char *
 694 AcpiDmFindNameByIndex (
 695     UINT64                  Index,
 696     const char              **List)
 697 {
 698     const char              *NameString;
 699     UINT32                  i;
 700
 701
 702     /* Bounds check */
 703
 704     NameString = List[0];
 705     i = 0;
 706
 707     while (NameString)
 708     {
 709         i++;
 710         NameString = List[i];
 711     }
 712
 713     if (Index >= i)
 714     {
 715         /* TBD: Add error msg */
 716
 717         return ("");
 718     }
 719
 720     return (List[Index]);
 721 }
 722
 723
 724 /*******************************************************************************
 725  *
 726  * FUNCTION:    AcpiDmPldBuffer
 727  *
 728  * PARAMETERS:  Level               - Current source code indentation level
 729  *              ByteData            - Pointer to the byte list
 730  *              ByteCount           - Length of the byte list
 731  *
 732  * RETURN:      None
 733  *
 734  * DESCRIPTION: Dump and format the contents of a _PLD buffer object
 735  *
 736  ******************************************************************************/
 737
 738 #define ACPI_PLD_OUTPUT08   "%*.s%-22s = 0x%X,\n", ACPI_MUL_4 (Level), " "
 739 #define ACPI_PLD_OUTPUT08P  "%*.s%-22s = 0x%X)\n", ACPI_MUL_4 (Level), " "
 740 #define ACPI_PLD_OUTPUT16   "%*.s%-22s = 0x%X,\n", ACPI_MUL_4 (Level), " "
 741 #define ACPI_PLD_OUTPUT16P  "%*.s%-22s = 0x%X)\n", ACPI_MUL_4 (Level), " "
 742 #define ACPI_PLD_OUTPUT24   "%*.s%-22s = 0x%X,\n", ACPI_MUL_4 (Level), " "
 743 #define ACPI_PLD_OUTPUTSTR  "%*.s%-22s = \"%s\",\n", ACPI_MUL_4 (Level), " "
 744
 745 static void
 746 AcpiDmPldBuffer (
 747     UINT32                  Level,
 748     UINT8                   *ByteData,
 749     UINT32                  ByteCount)
 750 {
 751     ACPI_PLD_INFO           *PldInfo;
 752     ACPI_STATUS             Status;
 753
 754
 755     /* Check for valid byte count */
 756
 757     if (ByteCount < ACPI_PLD_REV1_BUFFER_SIZE)
 758     {
 759         return;
 760     }
 761
 762     /* Convert _PLD buffer to local _PLD struct */
 763
 764     Status = AcpiDecodePldBuffer (ByteData, ByteCount, &PldInfo);
 765     if (ACPI_FAILURE (Status))
 766     {
 767         return;
 768     }
 769
 770     AcpiOsPrintf ("\n");
 771
 772     /* First 32-bit dword */
 773
 774     AcpiOsPrintf (ACPI_PLD_OUTPUT08,  "PLD_Revision", PldInfo->Revision);
 775     AcpiOsPrintf (ACPI_PLD_OUTPUT08,  "PLD_IgnoreColor", PldInfo->IgnoreColor);
 776     AcpiOsPrintf (ACPI_PLD_OUTPUT08,  "PLD_Red", PldInfo->Red);
 777     AcpiOsPrintf (ACPI_PLD_OUTPUT08,  "PLD_Green", PldInfo->Green);
 778     AcpiOsPrintf (ACPI_PLD_OUTPUT08,  "PLD_Blue", PldInfo->Blue);
 779
 780     /* Second 32-bit dword */
 781
 782     AcpiOsPrintf (ACPI_PLD_OUTPUT16,  "PLD_Width", PldInfo->Width);
 783     AcpiOsPrintf (ACPI_PLD_OUTPUT16,  "PLD_Height", PldInfo->Height);
 784
 785     /* Third 32-bit dword */
 786
 787     AcpiOsPrintf (ACPI_PLD_OUTPUT08,  "PLD_UserVisible", PldInfo->UserVisible);
 788     AcpiOsPrintf (ACPI_PLD_OUTPUT08,  "PLD_Dock", PldInfo->Dock);
 789     AcpiOsPrintf (ACPI_PLD_OUTPUT08,  "PLD_Lid", PldInfo->Lid);
 790     AcpiOsPrintf (ACPI_PLD_OUTPUTSTR, "PLD_Panel",
 791         AcpiDmFindNameByIndex(PldInfo->Panel, AcpiGbl_PldPanelList));
 792
 793     AcpiOsPrintf (ACPI_PLD_OUTPUTSTR, "PLD_VerticalPosition",
 794         AcpiDmFindNameByIndex(PldInfo->VerticalPosition, AcpiGbl_PldVerticalPositionList));
 795
 796     AcpiOsPrintf (ACPI_PLD_OUTPUTSTR, "PLD_HorizontalPosition",
 797         AcpiDmFindNameByIndex(PldInfo->HorizontalPosition, AcpiGbl_PldHorizontalPositionList));
 798
 799     AcpiOsPrintf (ACPI_PLD_OUTPUTSTR, "PLD_Shape",
 800         AcpiDmFindNameByIndex(PldInfo->Shape, AcpiGbl_PldShapeList));
 801     AcpiOsPrintf (ACPI_PLD_OUTPUT08,  "PLD_GroupOrientation", PldInfo->GroupOrientation);
 802
 803     AcpiOsPrintf (ACPI_PLD_OUTPUT08,  "PLD_GroupToken", PldInfo->GroupToken);
 804     AcpiOsPrintf (ACPI_PLD_OUTPUT08,  "PLD_GroupPosition", PldInfo->GroupPosition);
 805     AcpiOsPrintf (ACPI_PLD_OUTPUT08,  "PLD_Bay", PldInfo->Bay);
 806
 807     /* Fourth 32-bit dword */
 808
 809     AcpiOsPrintf (ACPI_PLD_OUTPUT08,  "PLD_Ejectable", PldInfo->Ejectable);
 810     AcpiOsPrintf (ACPI_PLD_OUTPUT08,  "PLD_EjectRequired", PldInfo->OspmEjectRequired);
 811     AcpiOsPrintf (ACPI_PLD_OUTPUT08,  "PLD_CabinetNumber", PldInfo->CabinetNumber);
 812     AcpiOsPrintf (ACPI_PLD_OUTPUT08,  "PLD_CardCageNumber", PldInfo->CardCageNumber);
 813     AcpiOsPrintf (ACPI_PLD_OUTPUT08,  "PLD_Reference", PldInfo->Reference);
 814     AcpiOsPrintf (ACPI_PLD_OUTPUT08,  "PLD_Rotation", PldInfo->Rotation);
 815
 816     if (ByteCount >= ACPI_PLD_REV2_BUFFER_SIZE)
 817     {
 818         AcpiOsPrintf (ACPI_PLD_OUTPUT08, "PLD_Order", PldInfo->Order);
 819
 820         /* Fifth 32-bit dword */
 821
 822         AcpiOsPrintf (ACPI_PLD_OUTPUT16,  "PLD_VerticalOffset", PldInfo->VerticalOffset);
 823         AcpiOsPrintf (ACPI_PLD_OUTPUT16P, "PLD_HorizontalOffset", PldInfo->HorizontalOffset);
 824     }
 825     else /* Rev 1 buffer */
 826     {
 827         AcpiOsPrintf (ACPI_PLD_OUTPUT08P, "PLD_Order", PldInfo->Order);
 828     }
 829
 830     ACPI_FREE (PldInfo);
 831 }
 832
 833
 834 /*******************************************************************************
 835  *
 836  * FUNCTION:    AcpiDmUnicode
 837  *
 838  * PARAMETERS:  Op              - Byte List op containing Unicode string
 839  *
 840  * RETURN:      None
 841  *
 842  * DESCRIPTION: Dump Unicode string as a standard ASCII string. (Remove
 843  *              the extra zero bytes).
 844  *
 845  ******************************************************************************/
 846
 847 static void
 848 AcpiDmUnicode (
 849     ACPI_PARSE_OBJECT       *Op)
 850 {
 851     UINT16                  *WordData;
 852     UINT32                  WordCount;
 853     UINT32                  i;
 854     int                     OutputValue;
 855
 856
 857     /* Extract the buffer info as a WORD buffer */
 858
 859     WordData = ACPI_CAST_PTR (UINT16, Op->Named.Data);
 860     WordCount = ACPI_DIV_2 (((UINT32) Op->Common.Value.Integer));
 861
 862     /* Write every other byte as an ASCII character */
 863
 864     AcpiOsPrintf ("\"");
 865     for (i = 0; i < (WordCount - 1); i++)
 866     {
 867         OutputValue = (int) WordData[i];
 868
 869         /* Handle values that must be escaped */
 870
 871         if ((OutputValue == '\"') ||
 872             (OutputValue == '\\'))
 873         {
 874             AcpiOsPrintf ("\\%c", OutputValue);
 875         }
 876         else if (!isprint (OutputValue))
 877         {
 878             AcpiOsPrintf ("\\x%2.2X", OutputValue);
 879         }
 880         else
 881         {
 882             AcpiOsPrintf ("%c", OutputValue);
 883         }
 884     }
 885
 886     AcpiOsPrintf ("\")");
 887 }
 888
 889
 890 /*******************************************************************************
 891  *
 892  * FUNCTION:    AcpiDmGetHardwareIdType
 893  *
 894  * PARAMETERS:  Op              - Op to be examined
 895  *
 896  * RETURN:      None
 897  *
 898  * DESCRIPTION: Determine the type of the argument to a _HID or _CID
 899  *              1) Strings are allowed
 900  *              2) If Integer, determine if it is a valid EISAID
 901  *
 902  ******************************************************************************/
 903
 904 static void
 905 AcpiDmGetHardwareIdType (
 906     ACPI_PARSE_OBJECT       *Op)
 907 {
 908     UINT32                  BigEndianId;
 909     UINT32                  Prefix[3];
 910     UINT32                  i;
 911
 912
 913     switch (Op->Common.AmlOpcode)
 914     {
 915     case AML_STRING_OP:
 916
 917         /* Mark this string as an _HID/_CID string */
 918
 919         Op->Common.DisasmOpcode = ACPI_DASM_HID_STRING;
 920         break;
 921
 922     case AML_WORD_OP:
 923     case AML_DWORD_OP:
 924
 925         /* Determine if a Word/Dword is a valid encoded EISAID */
 926
 927         /* Swap from little-endian to big-endian to simplify conversion */
 928
 929         BigEndianId = AcpiUtDwordByteSwap ((UINT32) Op->Common.Value.Integer);
 930
 931         /* Create the 3 leading ASCII letters */
 932
 933         Prefix[0] = ((BigEndianId >> 26) & 0x1F) + 0x40;
 934         Prefix[1] = ((BigEndianId >> 21) & 0x1F) + 0x40;
 935         Prefix[2] = ((BigEndianId >> 16) & 0x1F) + 0x40;
 936
 937         /* Verify that all 3 are ascii and alpha */
 938
 939         for (i = 0; i < 3; i++)
 940         {
 941             if (!ACPI_IS_ASCII (Prefix[i]) ||
 942                 !isalpha (Prefix[i]))
 943             {
 944                 return;
 945             }
 946         }
 947
 948         /* Mark this node as convertable to an EISA ID string */
 949
 950         Op->Common.DisasmOpcode = ACPI_DASM_EISAID;
 951         break;
 952
 953     default:
 954         break;
 955     }
 956 }
 957
 958
 959 /*******************************************************************************
 960  *
 961  * FUNCTION:    AcpiDmCheckForHardwareId
 962  *
 963  * PARAMETERS:  Op              - Op to be examined
 964  *
 965  * RETURN:      None
 966  *
 967  * DESCRIPTION: Determine if a Name() Op is a _HID/_CID.
 968  *
 969  ******************************************************************************/
 970
 971 void
 972 AcpiDmCheckForHardwareId (
 973     ACPI_PARSE_OBJECT       *Op)
 974 {
 975     UINT32                  Name;
 976     ACPI_PARSE_OBJECT       *NextOp;
 977
 978
 979     /* Get the NameSegment */
 980
 981     Name = AcpiPsGetName (Op);
 982     if (!Name)
 983     {
 984         return;
 985     }
 986
 987     NextOp = AcpiPsGetDepthNext (NULL, Op);
 988     if (!NextOp)
 989     {
 990         return;
 991     }
 992
 993     /* Check for _HID - has one argument */
 994
 995     if (ACPI_COMPARE_NAME (&Name, METHOD_NAME__HID))
 996     {
 997         AcpiDmGetHardwareIdType (NextOp);
 998         return;
 999     }
1000
1001     /* Exit if not _CID */
1002
1003     if (!ACPI_COMPARE_NAME (&Name, METHOD_NAME__CID))
1004     {
1005         return;
1006     }
1007
1008     /* _CID can contain a single argument or a package */
1009
1010     if (NextOp->Common.AmlOpcode != AML_PACKAGE_OP)
1011     {
1012         AcpiDmGetHardwareIdType (NextOp);
1013         return;
1014     }
1015
1016     /* _CID with Package: get the package length, check all elements */
1017
1018     NextOp = AcpiPsGetDepthNext (NULL, NextOp);
1019     if (!NextOp)
1020     {
1021         return;
1022     }
1023
1024     /* Don't need to use the length, just walk the peer list */
1025
1026     NextOp = NextOp->Common.Next;
1027     while (NextOp)
1028     {
1029         AcpiDmGetHardwareIdType (NextOp);
1030         NextOp = NextOp->Common.Next;
1031     }
1032 }
1033
1034
1035 /*******************************************************************************
1036  *
1037  * FUNCTION:    AcpiDmDecompressEisaId
1038  *
1039  * PARAMETERS:  EncodedId       - Raw encoded EISA ID.
1040  *
1041  * RETURN:      None
1042  *
1043  * DESCRIPTION: Convert an encoded EISAID back to the original ASCII String
1044  *              and emit the correct ASL statement. If the ID is known, emit
1045  *              a description of the ID as a comment.
1046  *
1047  ******************************************************************************/
1048
1049 void
1050 AcpiDmDecompressEisaId (
1051     UINT32                  EncodedId)
1052 {
1053     char                    IdBuffer[ACPI_EISAID_STRING_SIZE];
1054     const AH_DEVICE_ID      *Info;
1055
1056
1057     /* Convert EISAID to a string an emit the statement */
1058
1059     AcpiExEisaIdToString (IdBuffer, EncodedId);
1060     AcpiOsPrintf ("EisaId (\"%s\")", IdBuffer);
1061
1062     /* If we know about the ID, emit the description */
1063
1064     Info = AcpiAhMatchHardwareId (IdBuffer);
1065     if (Info)
1066     {
1067         AcpiOsPrintf (" /* %s */", Info->Description);
1068     }
1069 }