1 /*******************************************************************************
2 *
3 * Module Name: dmbuffer - AML disassembler, buffer and string support
4 *
5 ******************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2013, 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
45 #include "acpi.h"
46 #include "accommon.h"
47 #include "acdisasm.h"
48 #include "acparser.h"
49 #include "amlcode.h"
50
51
52 #ifdef ACPI_DISASSEMBLER
53
54 #define _COMPONENT ACPI_CA_DEBUGGER
55 ACPI_MODULE_NAME ("dmbuffer")
56
57 /* Local prototypes */
58
59 static void
60 AcpiDmUnicode (
61 ACPI_PARSE_OBJECT *Op);
62
63 static void
64 AcpiDmIsEisaIdElement (
65 ACPI_PARSE_OBJECT *Op);
66
67 static void
68 AcpiDmPldBuffer (
69 UINT32 Level,
70 UINT8 *ByteData,
71 UINT32 ByteCount);
72
73
74 /*******************************************************************************
75 *
76 * FUNCTION: AcpiDmDisasmByteList
77 *
78 * PARAMETERS: Level - Current source code indentation level
79 * ByteData - Pointer to the byte list
80 * ByteCount - Length of the byte list
81 *
82 * RETURN: None
83 *
84 * DESCRIPTION: Dump an AML "ByteList" in Hex format. 8 bytes per line, prefixed
85 * with the hex buffer offset.
86 *
87 ******************************************************************************/
88
89 void
90 AcpiDmDisasmByteList (
91 UINT32 Level,
92 UINT8 *ByteData,
93 UINT32 ByteCount)
94 {
95 UINT32 i;
96
97
98 if (!ByteCount)
99 {
100 return;
101 }
102
103 /* Dump the byte list */
104
105 for (i = 0; i < ByteCount; i++)
106 {
107 /* New line every 8 bytes */
108
109 if (((i % 8) == 0) && (i < ByteCount))
110 {
111 if (i > 0)
112 {
113 AcpiOsPrintf ("\n");
114 }
115
116 AcpiDmIndent (Level);
117 if (ByteCount > 8)
118 {
119 AcpiOsPrintf ("/* %04X */ ", i);
120 }
121 }
122
123 AcpiOsPrintf (" 0x%2.2X", (UINT32) ByteData[i]);
124
125 /* Add comma if there are more bytes to display */
126
127 if (i < (ByteCount -1))
128 {
129 AcpiOsPrintf (",");
130 }
131 }
132
133 if (Level)
134 {
135 AcpiOsPrintf ("\n");
136 }
137 }
138
139
140 /*******************************************************************************
141 *
142 * FUNCTION: AcpiDmByteList
143 *
144 * PARAMETERS: Info - Parse tree walk info
145 * Op - Byte list op
146 *
147 * RETURN: None
148 *
149 * DESCRIPTION: Dump a buffer byte list, handling the various types of buffers.
150 * Buffer type must be already set in the Op DisasmOpcode.
151 *
152 ******************************************************************************/
153
154 void
155 AcpiDmByteList (
156 ACPI_OP_WALK_INFO *Info,
157 ACPI_PARSE_OBJECT *Op)
158 {
159 UINT8 *ByteData;
160 UINT32 ByteCount;
161
162
163 ByteData = Op->Named.Data;
164 ByteCount = (UINT32) Op->Common.Value.Integer;
165
166 /*
167 * The byte list belongs to a buffer, and can be produced by either
168 * a ResourceTemplate, Unicode, quoted string, or a plain byte list.
169 */
170 switch (Op->Common.Parent->Common.DisasmOpcode)
171 {
172 case ACPI_DASM_RESOURCE:
173
174 AcpiDmResourceTemplate (Info, Op->Common.Parent, ByteData, ByteCount);
175 break;
176
177 case ACPI_DASM_STRING:
178
179 AcpiDmIndent (Info->Level);
180 AcpiUtPrintString ((char *) ByteData, ACPI_UINT16_MAX);
181 AcpiOsPrintf ("\n");
182 break;
183
184 case ACPI_DASM_UNICODE:
185
186 AcpiDmUnicode (Op);
187 break;
188
189 case ACPI_DASM_PLD_METHOD:
190
191 AcpiDmDisasmByteList (Info->Level, ByteData, ByteCount);
192 AcpiDmPldBuffer (Info->Level, ByteData, ByteCount);
193 break;
194
195 case ACPI_DASM_BUFFER:
196 default:
197 /*
198 * Not a resource, string, or unicode string.
199 * Just dump the buffer
200 */
201 AcpiDmDisasmByteList (Info->Level, ByteData, ByteCount);
202 break;
203 }
204 }
205
206
207 /*******************************************************************************
208 *
209 * FUNCTION: AcpiDmIsUnicodeBuffer
210 *
211 * PARAMETERS: Op - Buffer Object to be examined
212 *
213 * RETURN: TRUE if buffer contains a UNICODE string
214 *
215 * DESCRIPTION: Determine if a buffer Op contains a Unicode string
216 *
217 ******************************************************************************/
218
219 BOOLEAN
220 AcpiDmIsUnicodeBuffer (
221 ACPI_PARSE_OBJECT *Op)
222 {
223 UINT8 *ByteData;
224 UINT32 ByteCount;
225 UINT32 WordCount;
226 ACPI_PARSE_OBJECT *SizeOp;
227 ACPI_PARSE_OBJECT *NextOp;
228 UINT32 i;
229
230
231 /* Buffer size is the buffer argument */
232
233 SizeOp = Op->Common.Value.Arg;
234
235 /* Next, the initializer byte list to examine */
236
237 NextOp = SizeOp->Common.Next;
238 if (!NextOp)
239 {
240 return (FALSE);
241 }
242
243 /* Extract the byte list info */
244
245 ByteData = NextOp->Named.Data;
246 ByteCount = (UINT32) NextOp->Common.Value.Integer;
247 WordCount = ACPI_DIV_2 (ByteCount);
248
249 /*
250 * Unicode string must have an even number of bytes and last
251 * word must be zero
252 */
253 if ((!ByteCount) ||
254 (ByteCount < 4) ||
255 (ByteCount & 1) ||
256 ((UINT16 *) (void *) ByteData)[WordCount - 1] != 0)
257 {
258 return (FALSE);
259 }
260
261 /* For each word, 1st byte must be ascii, 2nd byte must be zero */
262
263 for (i = 0; i < (ByteCount - 2); i += 2)
264 {
265 if ((!ACPI_IS_PRINT (ByteData[i])) ||
266 (ByteData[(ACPI_SIZE) i + 1] != 0))
267 {
268 return (FALSE);
269 }
270 }
271
272 /* Ignore the Size argument in the disassembly of this buffer op */
273
274 SizeOp->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
275 return (TRUE);
276 }
277
278
279 /*******************************************************************************
280 *
281 * FUNCTION: AcpiDmIsStringBuffer
282 *
283 * PARAMETERS: Op - Buffer Object to be examined
284 *
285 * RETURN: TRUE if buffer contains a ASCII string, FALSE otherwise
286 *
287 * DESCRIPTION: Determine if a buffer Op contains a ASCII string
288 *
289 ******************************************************************************/
290
291 BOOLEAN
292 AcpiDmIsStringBuffer (
293 ACPI_PARSE_OBJECT *Op)
294 {
295 UINT8 *ByteData;
296 UINT32 ByteCount;
297 ACPI_PARSE_OBJECT *SizeOp;
298 ACPI_PARSE_OBJECT *NextOp;
299 UINT32 i;
300
301
302 /* Buffer size is the buffer argument */
303
304 SizeOp = Op->Common.Value.Arg;
305
306 /* Next, the initializer byte list to examine */
307
308 NextOp = SizeOp->Common.Next;
309 if (!NextOp)
310 {
311 return (FALSE);
312 }
313
314 /* Extract the byte list info */
315
316 ByteData = NextOp->Named.Data;
317 ByteCount = (UINT32) NextOp->Common.Value.Integer;
318
319 /* Last byte must be the null terminator */
320
321 if ((!ByteCount) ||
322 (ByteCount < 2) ||
323 (ByteData[ByteCount-1] != 0))
324 {
325 return (FALSE);
326 }
327
328 for (i = 0; i < (ByteCount - 1); i++)
329 {
330 /* TBD: allow some escapes (non-ascii chars).
331 * they will be handled in the string output routine
332 */
333
334 if (!ACPI_IS_PRINT (ByteData[i]))
335 {
336 return (FALSE);
337 }
338 }
339
340 return (TRUE);
341 }
342
343
344 /*******************************************************************************
345 *
346 * FUNCTION: AcpiDmIsPldBuffer
347 *
348 * PARAMETERS: Op - Buffer Object to be examined
349 *
350 * RETURN: TRUE if buffer contains a ASCII string, FALSE otherwise
351 *
352 * DESCRIPTION: Determine if a buffer Op contains a _PLD structure
353 *
354 ******************************************************************************/
355
356 BOOLEAN
357 AcpiDmIsPldBuffer (
358 ACPI_PARSE_OBJECT *Op)
359 {
360 ACPI_NAMESPACE_NODE *Node;
361 ACPI_PARSE_OBJECT *ParentOp;
362
363
364 ParentOp = Op->Common.Parent;
365 if (!ParentOp)
366 {
367 return (FALSE);
368 }
369
370 /* Check for form: Name(_PLD, Buffer() {}). Not legal, however */
371
372 if (ParentOp->Common.AmlOpcode == AML_NAME_OP)
373 {
374 Node = ParentOp->Common.Node;
375
376 if (ACPI_COMPARE_NAME (Node->Name.Ascii, METHOD_NAME__PLD))
377 {
378 return (TRUE);
379 }
380
381 return (FALSE);
382 }
383
384 /* Check for proper form: Name(_PLD, Package() {Buffer() {}}) */
385
386 if (ParentOp->Common.AmlOpcode == AML_PACKAGE_OP)
387 {
388 ParentOp = ParentOp->Common.Parent;
389 if (!ParentOp)
390 {
391 return (FALSE);
392 }
393
394 if (ParentOp->Common.AmlOpcode == AML_NAME_OP)
395 {
396 Node = ParentOp->Common.Node;
397
398 if (ACPI_COMPARE_NAME (Node->Name.Ascii, METHOD_NAME__PLD))
399 {
400 return (TRUE);
401 }
402 }
403 }
404
405 return (FALSE);
406 }
407
408
409 /*******************************************************************************
410 *
411 * FUNCTION: AcpiDmPldBuffer
412 *
413 * PARAMETERS: Level - Current source code indentation level
414 * ByteData - Pointer to the byte list
415 * ByteCount - Length of the byte list
416 *
417 * RETURN: None
418 *
419 * DESCRIPTION: Dump and format the contents of a _PLD buffer object
420 *
421 ******************************************************************************/
422
423 #define ACPI_PLD_OUTPUT08 "%*.s/* %18s : %-6.2X */\n", ACPI_MUL_4 (Level), " "
424 #define ACPI_PLD_OUTPUT16 "%*.s/* %18s : %-6.4X */\n", ACPI_MUL_4 (Level), " "
425 #define ACPI_PLD_OUTPUT24 "%*.s/* %18s : %-6.6X */\n", ACPI_MUL_4 (Level), " "
426
427 static void
428 AcpiDmPldBuffer (
429 UINT32 Level,
430 UINT8 *ByteData,
431 UINT32 ByteCount)
432 {
433 ACPI_PLD_INFO *PldInfo;
434 ACPI_STATUS Status;
435
436
437 /* Check for valid byte count */
438
439 if (ByteCount < ACPI_PLD_REV1_BUFFER_SIZE)
440 {
441 return;
442 }
443
444 /* Convert _PLD buffer to local _PLD struct */
445
446 Status = AcpiDecodePldBuffer (ByteData, ByteCount, &PldInfo);
447 if (ACPI_FAILURE (Status))
448 {
449 return;
450 }
451
452 /* First 32-bit dword */
453
454 AcpiOsPrintf (ACPI_PLD_OUTPUT08, "Revision", PldInfo->Revision);
455 AcpiOsPrintf (ACPI_PLD_OUTPUT08, "IgnoreColor", PldInfo->IgnoreColor);
456 AcpiOsPrintf (ACPI_PLD_OUTPUT24,"Color", PldInfo->Color);
457
458 /* Second 32-bit dword */
459
460 AcpiOsPrintf (ACPI_PLD_OUTPUT16,"Width", PldInfo->Width);
461 AcpiOsPrintf (ACPI_PLD_OUTPUT16,"Height", PldInfo->Height);
462
463 /* Third 32-bit dword */
464
465 AcpiOsPrintf (ACPI_PLD_OUTPUT08, "UserVisible", PldInfo->UserVisible);
466 AcpiOsPrintf (ACPI_PLD_OUTPUT08, "Dock", PldInfo->Dock);
467 AcpiOsPrintf (ACPI_PLD_OUTPUT08, "Lid", PldInfo->Lid);
468 AcpiOsPrintf (ACPI_PLD_OUTPUT08, "Panel", PldInfo->Panel);
469 AcpiOsPrintf (ACPI_PLD_OUTPUT08, "VerticalPosition", PldInfo->VerticalPosition);
470 AcpiOsPrintf (ACPI_PLD_OUTPUT08, "HorizontalPosition", PldInfo->HorizontalPosition);
471 AcpiOsPrintf (ACPI_PLD_OUTPUT08, "Shape", PldInfo->Shape);
472 AcpiOsPrintf (ACPI_PLD_OUTPUT08, "GroupOrientation", PldInfo->GroupOrientation);
473 AcpiOsPrintf (ACPI_PLD_OUTPUT08, "GroupToken", PldInfo->GroupToken);
474 AcpiOsPrintf (ACPI_PLD_OUTPUT08, "GroupPosition", PldInfo->GroupPosition);
475 AcpiOsPrintf (ACPI_PLD_OUTPUT08, "Bay", PldInfo->Bay);
476
477 /* Fourth 32-bit dword */
478
479 AcpiOsPrintf (ACPI_PLD_OUTPUT08, "Ejectable", PldInfo->Ejectable);
480 AcpiOsPrintf (ACPI_PLD_OUTPUT08, "OspmEjectRequired", PldInfo->OspmEjectRequired);
481 AcpiOsPrintf (ACPI_PLD_OUTPUT08, "CabinetNumber", PldInfo->CabinetNumber);
482 AcpiOsPrintf (ACPI_PLD_OUTPUT08, "CardCageNumber", PldInfo->CardCageNumber);
483 AcpiOsPrintf (ACPI_PLD_OUTPUT08, "Reference", PldInfo->Reference);
484 AcpiOsPrintf (ACPI_PLD_OUTPUT08, "Rotation", PldInfo->Rotation);
485 AcpiOsPrintf (ACPI_PLD_OUTPUT08, "Order", PldInfo->Order);
486
487 /* Fifth 32-bit dword */
488
489 if (ByteCount >= ACPI_PLD_REV1_BUFFER_SIZE)
490 {
491 AcpiOsPrintf (ACPI_PLD_OUTPUT16,"VerticalOffset", PldInfo->VerticalOffset);
492 AcpiOsPrintf (ACPI_PLD_OUTPUT16,"HorizontalOffset", PldInfo->HorizontalOffset);
493 }
494
495 ACPI_FREE (PldInfo);
496 }
497
498
499 /*******************************************************************************
500 *
501 * FUNCTION: AcpiDmUnicode
502 *
503 * PARAMETERS: Op - Byte List op containing Unicode string
504 *
505 * RETURN: None
506 *
507 * DESCRIPTION: Dump Unicode string as a standard ASCII string. (Remove
508 * the extra zero bytes).
509 *
510 ******************************************************************************/
511
512 static void
513 AcpiDmUnicode (
514 ACPI_PARSE_OBJECT *Op)
515 {
516 UINT16 *WordData;
517 UINT32 WordCount;
518 UINT32 i;
519
520
521 /* Extract the buffer info as a WORD buffer */
522
523 WordData = ACPI_CAST_PTR (UINT16, Op->Named.Data);
524 WordCount = ACPI_DIV_2 (((UINT32) Op->Common.Value.Integer));
525
526 /* Write every other byte as an ASCII character */
527
528 AcpiOsPrintf ("\"");
529 for (i = 0; i < (WordCount - 1); i++)
530 {
531 AcpiOsPrintf ("%c", (int) WordData[i]);
532 }
533
534 AcpiOsPrintf ("\")");
535 }
536
537
538 /*******************************************************************************
539 *
540 * FUNCTION: AcpiDmIsEisaIdElement
541 *
542 * PARAMETERS: Op - Op to be examined
543 *
544 * RETURN: None
545 *
546 * DESCRIPTION: Determine if an Op (argument to _HID or _CID) can be converted
547 * to an EISA ID.
548 *
549 ******************************************************************************/
550
551 static void
552 AcpiDmIsEisaIdElement (
553 ACPI_PARSE_OBJECT *Op)
554 {
555 UINT32 BigEndianId;
556 UINT32 Prefix[3];
557 UINT32 i;
558
559
560 /* The parameter must be either a word or a dword */
561
562 if ((Op->Common.AmlOpcode != AML_DWORD_OP) &&
563 (Op->Common.AmlOpcode != AML_WORD_OP))
564 {
565 return;
566 }
567
568 /* Swap from little-endian to big-endian to simplify conversion */
569
570 BigEndianId = AcpiUtDwordByteSwap ((UINT32) Op->Common.Value.Integer);
571
572 /* Create the 3 leading ASCII letters */
573
574 Prefix[0] = ((BigEndianId >> 26) & 0x1F) + 0x40;
575 Prefix[1] = ((BigEndianId >> 21) & 0x1F) + 0x40;
576 Prefix[2] = ((BigEndianId >> 16) & 0x1F) + 0x40;
577
578 /* Verify that all 3 are ascii and alpha */
579
580 for (i = 0; i < 3; i++)
581 {
582 if (!ACPI_IS_ASCII (Prefix[i]) ||
583 !ACPI_IS_ALPHA (Prefix[i]))
584 {
585 return;
586 }
587 }
588
589 /* OK - mark this node as convertable to an EISA ID */
590
591 Op->Common.DisasmOpcode = ACPI_DASM_EISAID;
592 }
593
594
595 /*******************************************************************************
596 *
597 * FUNCTION: AcpiDmIsEisaId
598 *
599 * PARAMETERS: Op - Op to be examined
600 *
601 * RETURN: None
602 *
603 * DESCRIPTION: Determine if a Name() Op can be converted to an EisaId.
604 *
605 ******************************************************************************/
606
607 void
608 AcpiDmIsEisaId (
609 ACPI_PARSE_OBJECT *Op)
610 {
611 UINT32 Name;
612 ACPI_PARSE_OBJECT *NextOp;
613
614
615 /* Get the NameSegment */
616
617 Name = AcpiPsGetName (Op);
618 if (!Name)
619 {
620 return;
621 }
622
623 NextOp = AcpiPsGetDepthNext (NULL, Op);
624 if (!NextOp)
625 {
626 return;
627 }
628
629 /* Check for _HID - has one argument */
630
631 if (ACPI_COMPARE_NAME (&Name, METHOD_NAME__HID))
632 {
633 AcpiDmIsEisaIdElement (NextOp);
634 return;
635 }
636
637 /* Exit if not _CID */
638
639 if (!ACPI_COMPARE_NAME (&Name, METHOD_NAME__CID))
640 {
641 return;
642 }
643
644 /* _CID can contain a single argument or a package */
645
646 if (NextOp->Common.AmlOpcode != AML_PACKAGE_OP)
647 {
648 AcpiDmIsEisaIdElement (NextOp);
649 return;
650 }
651
652 /* _CID with Package: get the package length */
653
654 NextOp = AcpiPsGetDepthNext (NULL, NextOp);
655
656 /* Don't need to use the length, just walk the peer list */
657
658 NextOp = NextOp->Common.Next;
659 while (NextOp)
660 {
661 AcpiDmIsEisaIdElement (NextOp);
662 NextOp = NextOp->Common.Next;
663 }
664 }
665
666
667 /*******************************************************************************
668 *
669 * FUNCTION: AcpiDmEisaId
670 *
671 * PARAMETERS: EncodedId - Raw encoded EISA ID.
672 *
673 * RETURN: None
674 *
675 * DESCRIPTION: Convert an encoded EISAID back to the original ASCII String.
676 *
677 ******************************************************************************/
678
679 void
680 AcpiDmEisaId (
681 UINT32 EncodedId)
682 {
683 UINT32 BigEndianId;
684
685
686 /* Swap from little-endian to big-endian to simplify conversion */
687
688 BigEndianId = AcpiUtDwordByteSwap (EncodedId);
689
690
691 /* Split to form "AAANNNN" string */
692
693 AcpiOsPrintf ("EisaId (\"%c%c%c%4.4X\")",
694
695 /* Three Alpha characters (AAA), 5 bits each */
696
697 (int) ((BigEndianId >> 26) & 0x1F) + 0x40,
698 (int) ((BigEndianId >> 21) & 0x1F) + 0x40,
699 (int) ((BigEndianId >> 16) & 0x1F) + 0x40,
700
701 /* Numeric part (NNNN) is simply the lower 16 bits */
702
703 (UINT32) (BigEndianId & 0xFFFF));
704 }
705
706 #endif