xref: /freebsd/sys/contrib/dev/acpica/components/disassembler/dmbuffer.c (revision 642870485c089b57000fe538d3485e272b038d59)
1 /*******************************************************************************
2  *
3  * Module Name: dmbuffer - AML disassembler, buffer and string support
4  *
5  ******************************************************************************/
6 
7 /*
8  * Copyright (C) 2000 - 2017, 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 }
1070