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     /* For each word, 1st byte must be ascii (1-0x7F), 2nd byte must be zero */
 443
 444     for (i = 0; i < (ByteCount - 2); i += 2)
 445     {
 446         if ((ByteData[i] == 0) ||
 447             (ByteData[i] > 0x7F) ||
 448             (ByteData[(ACPI_SIZE) i + 1] != 0))
 449         {
 450             return (FALSE);
 451         }
 452     }
 453
 454     /* Ignore the Size argument in the disassembly of this buffer op */
 455
 456     SizeOp->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
 457     return (TRUE);
 458 }
 459
 460
 461 /*******************************************************************************
 462  *
 463  * FUNCTION:    AcpiDmIsStringBuffer
 464  *
 465  * PARAMETERS:  Op              - Buffer Object to be examined
 466  *
 467  * RETURN:      TRUE if buffer contains a ASCII string, FALSE otherwise
 468  *
 469  * DESCRIPTION: Determine if a buffer Op contains a ASCII string
 470  *
 471  ******************************************************************************/
 472
 473 BOOLEAN
 474 AcpiDmIsStringBuffer (
 475     ACPI_PARSE_OBJECT       *Op)
 476 {
 477     UINT8                   *ByteData;
 478     UINT32                  ByteCount;
 479     ACPI_PARSE_OBJECT       *SizeOp;
 480     ACPI_PARSE_OBJECT       *NextOp;
 481     UINT32                  i;
 482
 483
 484     /* Buffer size is the buffer argument */
 485
 486     SizeOp = Op->Common.Value.Arg;
 487
 488     /* Next, the initializer byte list to examine */
 489
 490     NextOp = SizeOp->Common.Next;
 491     if (!NextOp)
 492     {
 493         return (FALSE);
 494     }
 495
 496     /* Extract the byte list info */
 497
 498     ByteData = NextOp->Named.Data;
 499     ByteCount = (UINT32) NextOp->Common.Value.Integer;
 500
 501     /* Last byte must be the null terminator */
 502
 503     if ((!ByteCount)     ||
 504          (ByteCount < 2) ||
 505          (ByteData[ByteCount-1] != 0))
 506     {
 507         return (FALSE);
 508     }
 509
 510     for (i = 0; i < (ByteCount - 1); i++)
 511     {
 512         /* TBD: allow some escapes (non-ascii chars).
 513          * they will be handled in the string output routine
 514          */
 515
 516         if (!isprint (ByteData[i]))
 517         {
 518             return (FALSE);
 519         }
 520     }
 521
 522     return (TRUE);
 523 }
 524
 525
 526 /*******************************************************************************
 527  *
 528  * FUNCTION:    AcpiDmIsPldBuffer
 529  *
 530  * PARAMETERS:  Op                  - Buffer Object to be examined
 531  *
 532  * RETURN:      TRUE if buffer contains a ASCII string, FALSE otherwise
 533  *
 534  * DESCRIPTION: Determine if a buffer Op contains a _PLD structure
 535  *
 536  ******************************************************************************/
 537
 538 BOOLEAN
 539 AcpiDmIsPldBuffer (
 540     ACPI_PARSE_OBJECT       *Op)
 541 {
 542     ACPI_NAMESPACE_NODE     *Node;
 543     ACPI_PARSE_OBJECT       *SizeOp;
 544     ACPI_PARSE_OBJECT       *ParentOp;
 545
 546
 547     /* Buffer size is the buffer argument */
 548
 549     SizeOp = Op->Common.Value.Arg;
 550
 551     ParentOp = Op->Common.Parent;
 552     if (!ParentOp)
 553     {
 554         return (FALSE);
 555     }
 556
 557     /* Check for form: Name(_PLD, Buffer() {}). Not legal, however */
 558
 559     if (ParentOp->Common.AmlOpcode == AML_NAME_OP)
 560     {
 561         Node = ParentOp->Common.Node;
 562
 563         if (ACPI_COMPARE_NAME (Node->Name.Ascii, METHOD_NAME__PLD))
 564         {
 565             /* Ignore the Size argument in the disassembly of this buffer op */
 566
 567             SizeOp->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
 568             return (TRUE);
 569         }
 570
 571         return (FALSE);
 572     }
 573
 574     /* Check for proper form: Name(_PLD, Package() {Buffer() {}}) */
 575
 576     if (ParentOp->Common.AmlOpcode == AML_PACKAGE_OP)
 577     {
 578         ParentOp = ParentOp->Common.Parent;
 579         if (!ParentOp)
 580         {
 581             return (FALSE);
 582         }
 583
 584         if (ParentOp->Common.AmlOpcode == AML_NAME_OP)
 585         {
 586             Node = ParentOp->Common.Node;
 587
 588             if (ACPI_COMPARE_NAME (Node->Name.Ascii, METHOD_NAME__PLD))
 589             {
 590                 /* Ignore the Size argument in the disassembly of this buffer op */
 591
 592                 SizeOp->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
 593                 return (TRUE);
 594             }
 595         }
 596     }
 597
 598     return (FALSE);
 599 }
 600
 601
 602 /*******************************************************************************
 603  *
 604  * FUNCTION:    AcpiDmFindNameByIndex
 605  *
 606  * PARAMETERS:  Index               - Index of array to check
 607  *              List                - Array to reference
 608  *
 609  * RETURN:      String from List or empty string
 610  *
 611  * DESCRIPTION: Finds and returns the char string located at the given index
 612  *              position in List.
 613  *
 614  ******************************************************************************/
 615
 616 static const char *
 617 AcpiDmFindNameByIndex (
 618     UINT64                  Index,
 619     const char              **List)
 620 {
 621     const char              *NameString;
 622     UINT32                  i;
 623
 624
 625     /* Bounds check */
 626
 627     NameString = List[0];
 628     i = 0;
 629
 630     while (NameString)
 631     {
 632         i++;
 633         NameString = List[i];
 634     }
 635
 636     if (Index >= i)
 637     {
 638         /* TBD: Add error msg */
 639
 640         return ("");
 641     }
 642
 643     return (List[Index]);
 644 }
 645
 646
 647 /*******************************************************************************
 648  *
 649  * FUNCTION:    AcpiDmPldBuffer
 650  *
 651  * PARAMETERS:  Level               - Current source code indentation level
 652  *              ByteData            - Pointer to the byte list
 653  *              ByteCount           - Length of the byte list
 654  *
 655  * RETURN:      None
 656  *
 657  * DESCRIPTION: Dump and format the contents of a _PLD buffer object
 658  *
 659  ******************************************************************************/
 660
 661 #define ACPI_PLD_OUTPUT08   "%*.s%-22s = 0x%X,\n", ACPI_MUL_4 (Level), " "
 662 #define ACPI_PLD_OUTPUT08P  "%*.s%-22s = 0x%X)\n", ACPI_MUL_4 (Level), " "
 663 #define ACPI_PLD_OUTPUT16   "%*.s%-22s = 0x%X,\n", ACPI_MUL_4 (Level), " "
 664 #define ACPI_PLD_OUTPUT16P  "%*.s%-22s = 0x%X)\n", ACPI_MUL_4 (Level), " "
 665 #define ACPI_PLD_OUTPUT24   "%*.s%-22s = 0x%X,\n", ACPI_MUL_4 (Level), " "
 666 #define ACPI_PLD_OUTPUTSTR  "%*.s%-22s = \"%s\",\n", ACPI_MUL_4 (Level), " "
 667
 668 static void
 669 AcpiDmPldBuffer (
 670     UINT32                  Level,
 671     UINT8                   *ByteData,
 672     UINT32                  ByteCount)
 673 {
 674     ACPI_PLD_INFO           *PldInfo;
 675     ACPI_STATUS             Status;
 676
 677
 678     /* Check for valid byte count */
 679
 680     if (ByteCount < ACPI_PLD_REV1_BUFFER_SIZE)
 681     {
 682         return;
 683     }
 684
 685     /* Convert _PLD buffer to local _PLD struct */
 686
 687     Status = AcpiDecodePldBuffer (ByteData, ByteCount, &PldInfo);
 688     if (ACPI_FAILURE (Status))
 689     {
 690         return;
 691     }
 692
 693     AcpiOsPrintf ("\n");
 694
 695     /* First 32-bit dword */
 696
 697     AcpiOsPrintf (ACPI_PLD_OUTPUT08,  "PLD_Revision", PldInfo->Revision);
 698     AcpiOsPrintf (ACPI_PLD_OUTPUT08,  "PLD_IgnoreColor", PldInfo->IgnoreColor);
 699     AcpiOsPrintf (ACPI_PLD_OUTPUT08,  "PLD_Red", PldInfo->Red);
 700     AcpiOsPrintf (ACPI_PLD_OUTPUT08,  "PLD_Green", PldInfo->Green);
 701     AcpiOsPrintf (ACPI_PLD_OUTPUT08,  "PLD_Blue", PldInfo->Blue);
 702
 703     /* Second 32-bit dword */
 704
 705     AcpiOsPrintf (ACPI_PLD_OUTPUT16,  "PLD_Width", PldInfo->Width);
 706     AcpiOsPrintf (ACPI_PLD_OUTPUT16,  "PLD_Height", PldInfo->Height);
 707
 708     /* Third 32-bit dword */
 709
 710     AcpiOsPrintf (ACPI_PLD_OUTPUT08,  "PLD_UserVisible", PldInfo->UserVisible);
 711     AcpiOsPrintf (ACPI_PLD_OUTPUT08,  "PLD_Dock", PldInfo->Dock);
 712     AcpiOsPrintf (ACPI_PLD_OUTPUT08,  "PLD_Lid", PldInfo->Lid);
 713     AcpiOsPrintf (ACPI_PLD_OUTPUTSTR, "PLD_Panel",
 714         AcpiDmFindNameByIndex(PldInfo->Panel, AcpiGbl_PldPanelList));
 715
 716     AcpiOsPrintf (ACPI_PLD_OUTPUTSTR, "PLD_VerticalPosition",
 717         AcpiDmFindNameByIndex(PldInfo->VerticalPosition, AcpiGbl_PldVerticalPositionList));
 718
 719     AcpiOsPrintf (ACPI_PLD_OUTPUTSTR, "PLD_HorizontalPosition",
 720         AcpiDmFindNameByIndex(PldInfo->HorizontalPosition, AcpiGbl_PldHorizontalPositionList));
 721
 722     AcpiOsPrintf (ACPI_PLD_OUTPUTSTR, "PLD_Shape",
 723         AcpiDmFindNameByIndex(PldInfo->Shape, AcpiGbl_PldShapeList));
 724     AcpiOsPrintf (ACPI_PLD_OUTPUT08,  "PLD_GroupOrientation", PldInfo->GroupOrientation);
 725
 726     AcpiOsPrintf (ACPI_PLD_OUTPUT08,  "PLD_GroupToken", PldInfo->GroupToken);
 727     AcpiOsPrintf (ACPI_PLD_OUTPUT08,  "PLD_GroupPosition", PldInfo->GroupPosition);
 728     AcpiOsPrintf (ACPI_PLD_OUTPUT08,  "PLD_Bay", PldInfo->Bay);
 729
 730     /* Fourth 32-bit dword */
 731
 732     AcpiOsPrintf (ACPI_PLD_OUTPUT08,  "PLD_Ejectable", PldInfo->Ejectable);
 733     AcpiOsPrintf (ACPI_PLD_OUTPUT08,  "PLD_EjectRequired", PldInfo->OspmEjectRequired);
 734     AcpiOsPrintf (ACPI_PLD_OUTPUT08,  "PLD_CabinetNumber", PldInfo->CabinetNumber);
 735     AcpiOsPrintf (ACPI_PLD_OUTPUT08,  "PLD_CardCageNumber", PldInfo->CardCageNumber);
 736     AcpiOsPrintf (ACPI_PLD_OUTPUT08,  "PLD_Reference", PldInfo->Reference);
 737     AcpiOsPrintf (ACPI_PLD_OUTPUT08,  "PLD_Rotation", PldInfo->Rotation);
 738
 739     if (ByteCount >= ACPI_PLD_REV2_BUFFER_SIZE)
 740     {
 741         AcpiOsPrintf (ACPI_PLD_OUTPUT08, "PLD_Order", PldInfo->Order);
 742
 743         /* Fifth 32-bit dword */
 744
 745         AcpiOsPrintf (ACPI_PLD_OUTPUT16,  "PLD_VerticalOffset", PldInfo->VerticalOffset);
 746         AcpiOsPrintf (ACPI_PLD_OUTPUT16P, "PLD_HorizontalOffset", PldInfo->HorizontalOffset);
 747     }
 748     else /* Rev 1 buffer */
 749     {
 750         AcpiOsPrintf (ACPI_PLD_OUTPUT08P, "PLD_Order", PldInfo->Order);
 751     }
 752
 753     ACPI_FREE (PldInfo);
 754 }
 755
 756
 757 /*******************************************************************************
 758  *
 759  * FUNCTION:    AcpiDmUnicode
 760  *
 761  * PARAMETERS:  Op              - Byte List op containing Unicode string
 762  *
 763  * RETURN:      None
 764  *
 765  * DESCRIPTION: Dump Unicode string as a standard ASCII string. (Remove
 766  *              the extra zero bytes).
 767  *
 768  ******************************************************************************/
 769
 770 static void
 771 AcpiDmUnicode (
 772     ACPI_PARSE_OBJECT       *Op)
 773 {
 774     UINT16                  *WordData;
 775     UINT32                  WordCount;
 776     UINT32                  i;
 777     int                     OutputValue;
 778
 779
 780     /* Extract the buffer info as a WORD buffer */
 781
 782     WordData = ACPI_CAST_PTR (UINT16, Op->Named.Data);
 783     WordCount = ACPI_DIV_2 (((UINT32) Op->Common.Value.Integer));
 784
 785     /* Write every other byte as an ASCII character */
 786
 787     AcpiOsPrintf ("\"");
 788     for (i = 0; i < (WordCount - 1); i++)
 789     {
 790         OutputValue = (int) WordData[i];
 791
 792         /* Handle values that must be escaped */
 793
 794         if ((OutputValue == '\"') ||
 795             (OutputValue == '\\'))
 796         {
 797             AcpiOsPrintf ("\\%c", OutputValue);
 798         }
 799         else if (!isprint (OutputValue))
 800         {
 801             AcpiOsPrintf ("\\x%2.2X", OutputValue);
 802         }
 803         else
 804         {
 805             AcpiOsPrintf ("%c", OutputValue);
 806         }
 807     }
 808
 809     AcpiOsPrintf ("\")");
 810 }
 811
 812
 813 /*******************************************************************************
 814  *
 815  * FUNCTION:    AcpiDmGetHardwareIdType
 816  *
 817  * PARAMETERS:  Op              - Op to be examined
 818  *
 819  * RETURN:      None
 820  *
 821  * DESCRIPTION: Determine the type of the argument to a _HID or _CID
 822  *              1) Strings are allowed
 823  *              2) If Integer, determine if it is a valid EISAID
 824  *
 825  ******************************************************************************/
 826
 827 static void
 828 AcpiDmGetHardwareIdType (
 829     ACPI_PARSE_OBJECT       *Op)
 830 {
 831     UINT32                  BigEndianId;
 832     UINT32                  Prefix[3];
 833     UINT32                  i;
 834
 835
 836     switch (Op->Common.AmlOpcode)
 837     {
 838     case AML_STRING_OP:
 839
 840         /* Mark this string as an _HID/_CID string */
 841
 842         Op->Common.DisasmOpcode = ACPI_DASM_HID_STRING;
 843         break;
 844
 845     case AML_WORD_OP:
 846     case AML_DWORD_OP:
 847
 848         /* Determine if a Word/Dword is a valid encoded EISAID */
 849
 850         /* Swap from little-endian to big-endian to simplify conversion */
 851
 852         BigEndianId = AcpiUtDwordByteSwap ((UINT32) Op->Common.Value.Integer);
 853
 854         /* Create the 3 leading ASCII letters */
 855
 856         Prefix[0] = ((BigEndianId >> 26) & 0x1F) + 0x40;
 857         Prefix[1] = ((BigEndianId >> 21) & 0x1F) + 0x40;
 858         Prefix[2] = ((BigEndianId >> 16) & 0x1F) + 0x40;
 859
 860         /* Verify that all 3 are ascii and alpha */
 861
 862         for (i = 0; i < 3; i++)
 863         {
 864             if (!ACPI_IS_ASCII (Prefix[i]) ||
 865                 !isalpha (Prefix[i]))
 866             {
 867                 return;
 868             }
 869         }
 870
 871         /* Mark this node as convertable to an EISA ID string */
 872
 873         Op->Common.DisasmOpcode = ACPI_DASM_EISAID;
 874         break;
 875
 876     default:
 877         break;
 878     }
 879 }
 880
 881
 882 /*******************************************************************************
 883  *
 884  * FUNCTION:    AcpiDmCheckForHardwareId
 885  *
 886  * PARAMETERS:  Op              - Op to be examined
 887  *
 888  * RETURN:      None
 889  *
 890  * DESCRIPTION: Determine if a Name() Op is a _HID/_CID.
 891  *
 892  ******************************************************************************/
 893
 894 void
 895 AcpiDmCheckForHardwareId (
 896     ACPI_PARSE_OBJECT       *Op)
 897 {
 898     UINT32                  Name;
 899     ACPI_PARSE_OBJECT       *NextOp;
 900
 901
 902     /* Get the NameSegment */
 903
 904     Name = AcpiPsGetName (Op);
 905     if (!Name)
 906     {
 907         return;
 908     }
 909
 910     NextOp = AcpiPsGetDepthNext (NULL, Op);
 911     if (!NextOp)
 912     {
 913         return;
 914     }
 915
 916     /* Check for _HID - has one argument */
 917
 918     if (ACPI_COMPARE_NAME (&Name, METHOD_NAME__HID))
 919     {
 920         AcpiDmGetHardwareIdType (NextOp);
 921         return;
 922     }
 923
 924     /* Exit if not _CID */
 925
 926     if (!ACPI_COMPARE_NAME (&Name, METHOD_NAME__CID))
 927     {
 928         return;
 929     }
 930
 931     /* _CID can contain a single argument or a package */
 932
 933     if (NextOp->Common.AmlOpcode != AML_PACKAGE_OP)
 934     {
 935         AcpiDmGetHardwareIdType (NextOp);
 936         return;
 937     }
 938
 939     /* _CID with Package: get the package length, check all elements */
 940
 941     NextOp = AcpiPsGetDepthNext (NULL, NextOp);
 942     if (!NextOp)
 943     {
 944         return;
 945     }
 946
 947     /* Don't need to use the length, just walk the peer list */
 948
 949     NextOp = NextOp->Common.Next;
 950     while (NextOp)
 951     {
 952         AcpiDmGetHardwareIdType (NextOp);
 953         NextOp = NextOp->Common.Next;
 954     }
 955 }
 956
 957
 958 /*******************************************************************************
 959  *
 960  * FUNCTION:    AcpiDmDecompressEisaId
 961  *
 962  * PARAMETERS:  EncodedId       - Raw encoded EISA ID.
 963  *
 964  * RETURN:      None
 965  *
 966  * DESCRIPTION: Convert an encoded EISAID back to the original ASCII String
 967  *              and emit the correct ASL statement. If the ID is known, emit
 968  *              a description of the ID as a comment.
 969  *
 970  ******************************************************************************/
 971
 972 void
 973 AcpiDmDecompressEisaId (
 974     UINT32                  EncodedId)
 975 {
 976     char                    IdBuffer[ACPI_EISAID_STRING_SIZE];
 977     const AH_DEVICE_ID      *Info;
 978
 979
 980     /* Convert EISAID to a string an emit the statement */
 981
 982     AcpiExEisaIdToString (IdBuffer, EncodedId);
 983     AcpiOsPrintf ("EisaId (\"%s\")", IdBuffer);
 984
 985     /* If we know about the ID, emit the description */
 986
 987     Info = AcpiAhMatchHardwareId (IdBuffer);
 988     if (Info)
 989     {
 990         AcpiOsPrintf (" /* %s */", Info->Description);
 991     }
 992 }