1 /*******************************************************************************
2 *
3 * Module Name: dmresrcl.c - "Large" Resource Descriptor disassembly
4 *
5 ******************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2011, 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
49
50 #ifdef ACPI_DISASSEMBLER
51
52 #define _COMPONENT ACPI_CA_DEBUGGER
53 ACPI_MODULE_NAME ("dbresrcl")
54
55
56 /* Common names for address and memory descriptors */
57
58 static char *AcpiDmAddressNames[] =
59 {
60 "Granularity",
61 "Range Minimum",
62 "Range Maximum",
63 "Translation Offset",
64 "Length"
65 };
66
67 static char *AcpiDmMemoryNames[] =
68 {
69 "Range Minimum",
70 "Range Maximum",
71 "Alignment",
72 "Length"
73 };
74
75
76 /* Local prototypes */
77
78 static void
79 AcpiDmSpaceFlags (
80 UINT8 Flags);
81
82 static void
83 AcpiDmIoFlags (
84 UINT8 Flags);
85
86 static void
87 AcpiDmIoFlags2 (
88 UINT8 SpecificFlags);
89
90 static void
91 AcpiDmMemoryFlags (
92 UINT8 Flags,
93 UINT8 SpecificFlags);
94
95 static void
96 AcpiDmMemoryFlags2 (
97 UINT8 SpecificFlags);
98
99 static void
100 AcpiDmResourceSource (
101 AML_RESOURCE *Resource,
102 ACPI_SIZE MinimumLength,
103 UINT32 Length);
104
105 static void
106 AcpiDmAddressFields (
107 void *Source,
108 UINT8 Type,
109 UINT32 Level);
110
111 static void
112 AcpiDmAddressPrefix (
113 UINT8 Type);
114
115 static void
116 AcpiDmAddressCommon (
117 AML_RESOURCE *Resource,
118 UINT8 Type,
119 UINT32 Level);
120
121 static void
122 AcpiDmAddressFlags (
123 AML_RESOURCE *Resource);
124
125
126 /*******************************************************************************
127 *
128 * FUNCTION: AcpiDmMemoryFields
129 *
130 * PARAMETERS: Source - Pointer to the contiguous data fields
131 * Type - 16 or 32 (bit)
132 * Level - Current source code indentation level
133 *
134 * RETURN: None
135 *
136 * DESCRIPTION: Decode fields common to Memory24 and Memory32 descriptors
137 *
138 ******************************************************************************/
139
140 static void
141 AcpiDmMemoryFields (
142 void *Source,
143 UINT8 Type,
144 UINT32 Level)
145 {
146 UINT32 i;
147
148
149 for (i = 0; i < 4; i++)
150 {
151 AcpiDmIndent (Level + 1);
152
153 switch (Type)
154 {
155 case 16:
156 AcpiDmDumpInteger16 (ACPI_CAST_PTR (UINT16, Source)[i],
157 AcpiDmMemoryNames[i]);
158 break;
159
160 case 32:
161 AcpiDmDumpInteger32 (ACPI_CAST_PTR (UINT32, Source)[i],
162 AcpiDmMemoryNames[i]);
163 break;
164
165 default:
166 return;
167 }
168 }
169 }
170
171
172 /*******************************************************************************
173 *
174 * FUNCTION: AcpiDmAddressFields
175 *
176 * PARAMETERS: Source - Pointer to the contiguous data fields
177 * Type - 16, 32, or 64 (bit)
178 * Level - Current source code indentation level
179 *
180 * RETURN: None
181 *
182 * DESCRIPTION: Decode fields common to address descriptors
183 *
184 ******************************************************************************/
185
186 static void
187 AcpiDmAddressFields (
188 void *Source,
189 UINT8 Type,
190 UINT32 Level)
191 {
192 UINT32 i;
193
194
195 AcpiOsPrintf ("\n");
196
197 for (i = 0; i < 5; i++)
198 {
199 AcpiDmIndent (Level + 1);
200
201 switch (Type)
202 {
203 case 16:
204 AcpiDmDumpInteger16 (ACPI_CAST_PTR (UINT16, Source)[i],
205 AcpiDmAddressNames[i]);
206 break;
207
208 case 32:
209 AcpiDmDumpInteger32 (ACPI_CAST_PTR (UINT32, Source)[i],
210 AcpiDmAddressNames[i]);
211 break;
212
213 case 64:
214 AcpiDmDumpInteger64 (ACPI_CAST_PTR (UINT64, Source)[i],
215 AcpiDmAddressNames[i]);
216 break;
217
218 default:
219 return;
220 }
221 }
222 }
223
224
225 /*******************************************************************************
226 *
227 * FUNCTION: AcpiDmAddressPrefix
228 *
229 * PARAMETERS: Type - Descriptor type
230 *
231 * RETURN: None
232 *
233 * DESCRIPTION: Emit name prefix representing the address descriptor type
234 *
235 ******************************************************************************/
236
237 static void
238 AcpiDmAddressPrefix (
239 UINT8 Type)
240 {
241
242 switch (Type)
243 {
244 case ACPI_RESOURCE_TYPE_ADDRESS16:
245 AcpiOsPrintf ("Word");
246 break;
247
248 case ACPI_RESOURCE_TYPE_ADDRESS32:
249 AcpiOsPrintf ("DWord");
250 break;
251
252 case ACPI_RESOURCE_TYPE_ADDRESS64:
253 AcpiOsPrintf ("QWord");
254 break;
255
256 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
257 AcpiOsPrintf ("Extended");
258 break;
259
260 default:
261 return;
262 }
263 }
264
265
266 /*******************************************************************************
267 *
268 * FUNCTION: AcpiDmAddressCommon
269 *
270 * PARAMETERS: Resource - Raw AML descriptor
271 * Type - Descriptor type
272 * Level - Current source code indentation level
273 *
274 * RETURN: None
275 *
276 * DESCRIPTION: Emit common name and flag fields common to address descriptors
277 *
278 ******************************************************************************/
279
280 static void
281 AcpiDmAddressCommon (
282 AML_RESOURCE *Resource,
283 UINT8 Type,
284 UINT32 Level)
285 {
286 UINT8 ResourceType;
287 UINT8 SpecificFlags;
288 UINT8 Flags;
289
290
291 ResourceType = Resource->Address.ResourceType;
292 SpecificFlags = Resource->Address.SpecificFlags;
293 Flags = Resource->Address.Flags;
294
295 AcpiDmIndent (Level);
296
297 /* Validate ResourceType */
298
299 if ((ResourceType > 2) && (ResourceType < 0xC0))
300 {
301 AcpiOsPrintf ("/**** Invalid Resource Type: 0x%X ****/", ResourceType);
302 return;
303 }
304
305 /* Prefix is either Word, DWord, QWord, or Extended */
306
307 AcpiDmAddressPrefix (Type);
308
309 /* Resource Types above 0xC0 are vendor-defined */
310
311 if (ResourceType > 2)
312 {
313 AcpiOsPrintf ("Space (0x%2.2X, ", ResourceType);
314 AcpiDmSpaceFlags (Flags);
315 AcpiOsPrintf (" 0x%2.2X,", SpecificFlags);
316 return;
317 }
318
319 /* This is either a Memory, IO, or BusNumber descriptor (0,1,2) */
320
321 AcpiOsPrintf ("%s (", AcpiGbl_WordDecode [ResourceType & 0x3]);
322
323 /* Decode the general and type-specific flags */
324
325 if (ResourceType == ACPI_MEMORY_RANGE)
326 {
327 AcpiDmMemoryFlags (Flags, SpecificFlags);
328 }
329 else /* IO range or BusNumberRange */
330 {
331 AcpiDmIoFlags (Flags);
332 if (ResourceType == ACPI_IO_RANGE)
333 {
334 AcpiOsPrintf (" %s,", AcpiGbl_RngDecode [SpecificFlags & 0x3]);
335 }
336 }
337 }
338
339
340 /*******************************************************************************
341 *
342 * FUNCTION: AcpiDmAddressFlags
343 *
344 * PARAMETERS: Resource - Raw AML descriptor
345 *
346 * RETURN: None
347 *
348 * DESCRIPTION: Emit flags common to address descriptors
349 *
350 ******************************************************************************/
351
352 static void
353 AcpiDmAddressFlags (
354 AML_RESOURCE *Resource)
355 {
356
357 if (Resource->Address.ResourceType == ACPI_IO_RANGE)
358 {
359 AcpiDmIoFlags2 (Resource->Address.SpecificFlags);
360 }
361 else if (Resource->Address.ResourceType == ACPI_MEMORY_RANGE)
362 {
363 AcpiDmMemoryFlags2 (Resource->Address.SpecificFlags);
364 }
365 }
366
367
368 /*******************************************************************************
369 *
370 * FUNCTION: AcpiDmSpaceFlags
371 *
372 * PARAMETERS: Flags - Flag byte to be decoded
373 *
374 * RETURN: None
375 *
376 * DESCRIPTION: Decode the flags specific to Space Address space descriptors
377 *
378 ******************************************************************************/
379
380 static void
381 AcpiDmSpaceFlags (
382 UINT8 Flags)
383 {
384
385 AcpiOsPrintf ("%s, %s, %s, %s,",
386 AcpiGbl_ConsumeDecode [(Flags & 1)],
387 AcpiGbl_DecDecode [(Flags & 0x2) >> 1],
388 AcpiGbl_MinDecode [(Flags & 0x4) >> 2],
389 AcpiGbl_MaxDecode [(Flags & 0x8) >> 3]);
390 }
391
392
393 /*******************************************************************************
394 *
395 * FUNCTION: AcpiDmIoFlags
396 *
397 * PARAMETERS: Flags - Flag byte to be decoded
398 *
399 * RETURN: None
400 *
401 * DESCRIPTION: Decode the flags specific to IO Address space descriptors
402 *
403 ******************************************************************************/
404
405 static void
406 AcpiDmIoFlags (
407 UINT8 Flags)
408 {
409 AcpiOsPrintf ("%s, %s, %s, %s,",
410 AcpiGbl_ConsumeDecode [(Flags & 1)],
411 AcpiGbl_MinDecode [(Flags & 0x4) >> 2],
412 AcpiGbl_MaxDecode [(Flags & 0x8) >> 3],
413 AcpiGbl_DecDecode [(Flags & 0x2) >> 1]);
414 }
415
416
417 /*******************************************************************************
418 *
419 * FUNCTION: AcpiDmIoFlags2
420 *
421 * PARAMETERS: SpecificFlags - "Specific" flag byte to be decoded
422 *
423 * RETURN: None
424 *
425 * DESCRIPTION: Decode the flags specific to IO Address space descriptors
426 *
427 ******************************************************************************/
428
429 static void
430 AcpiDmIoFlags2 (
431 UINT8 SpecificFlags)
432 {
433
434 AcpiOsPrintf (", %s",
435 AcpiGbl_TtpDecode [(SpecificFlags & 0x10) >> 4]);
436
437 /* TRS is only used if TTP is TypeTranslation */
438
439 if (SpecificFlags & 0x10)
440 {
441 AcpiOsPrintf (", %s",
442 AcpiGbl_TrsDecode [(SpecificFlags & 0x20) >> 5]);
443 }
444 }
445
446
447 /*******************************************************************************
448 *
449 * FUNCTION: AcpiDmMemoryFlags
450 *
451 * PARAMETERS: Flags - Flag byte to be decoded
452 * SpecificFlags - "Specific" flag byte to be decoded
453 *
454 * RETURN: None
455 *
456 * DESCRIPTION: Decode flags specific to Memory Address Space descriptors
457 *
458 ******************************************************************************/
459
460 static void
461 AcpiDmMemoryFlags (
462 UINT8 Flags,
463 UINT8 SpecificFlags)
464 {
465
466 AcpiOsPrintf ("%s, %s, %s, %s, %s, %s,",
467 AcpiGbl_ConsumeDecode [(Flags & 1)],
468 AcpiGbl_DecDecode [(Flags & 0x2) >> 1],
469 AcpiGbl_MinDecode [(Flags & 0x4) >> 2],
470 AcpiGbl_MaxDecode [(Flags & 0x8) >> 3],
471 AcpiGbl_MemDecode [(SpecificFlags & 0x6) >> 1],
472 AcpiGbl_RwDecode [(SpecificFlags & 0x1)]);
473 }
474
475
476 /*******************************************************************************
477 *
478 * FUNCTION: AcpiDmMemoryFlags2
479 *
480 * PARAMETERS: SpecificFlags - "Specific" flag byte to be decoded
481 *
482 * RETURN: None
483 *
484 * DESCRIPTION: Decode flags specific to Memory Address Space descriptors
485 *
486 ******************************************************************************/
487
488 static void
489 AcpiDmMemoryFlags2 (
490 UINT8 SpecificFlags)
491 {
492
493 AcpiOsPrintf (", %s, %s",
494 AcpiGbl_MtpDecode [(SpecificFlags & 0x18) >> 3],
495 AcpiGbl_TtpDecode [(SpecificFlags & 0x20) >> 5]);
496 }
497
498
499 /*******************************************************************************
500 *
501 * FUNCTION: AcpiDmResourceSource
502 *
503 * PARAMETERS: Resource - Raw AML descriptor
504 * MinimumLength - descriptor length without optional fields
505 * ResourceLength
506 *
507 * RETURN: None
508 *
509 * DESCRIPTION: Dump optional ResourceSource fields of an address descriptor
510 *
511 ******************************************************************************/
512
513 static void
514 AcpiDmResourceSource (
515 AML_RESOURCE *Resource,
516 ACPI_SIZE MinimumTotalLength,
517 UINT32 ResourceLength)
518 {
519 UINT8 *AmlResourceSource;
520 UINT32 TotalLength;
521
522
523 TotalLength = ResourceLength + sizeof (AML_RESOURCE_LARGE_HEADER);
524
525 /* Check if the optional ResourceSource fields are present */
526
527 if (TotalLength <= MinimumTotalLength)
528 {
529 /* The two optional fields are not used */
530
531 AcpiOsPrintf (",, ");
532 return;
533 }
534
535 /* Get a pointer to the ResourceSource */
536
537 AmlResourceSource = ACPI_ADD_PTR (UINT8, Resource, MinimumTotalLength);
538
539 /*
540 * Always emit the ResourceSourceIndex (Byte)
541 *
542 * NOTE: Some ASL compilers always create a 0 byte (in the AML) for the
543 * Index even if the String does not exist. Although this is in violation
544 * of the ACPI specification, it is very important to emit ASL code that
545 * can be compiled back to the identical AML. There may be fields and/or
546 * indexes into the resource template buffer that are compiled to absolute
547 * offsets, and these will be broken if the AML length is changed.
548 */
549 AcpiOsPrintf ("0x%2.2X,", (UINT32) AmlResourceSource[0]);
550
551 /* Make sure that the ResourceSource string exists before dumping it */
552
553 if (TotalLength > (MinimumTotalLength + 1))
554 {
555 AcpiOsPrintf (" ");
556 AcpiUtPrintString ((char *) &AmlResourceSource[1], ACPI_UINT8_MAX);
557 }
558
559 AcpiOsPrintf (", ");
560 }
561
562
563 /*******************************************************************************
564 *
565 * FUNCTION: AcpiDmWordDescriptor
566 *
567 * PARAMETERS: Resource - Pointer to the resource descriptor
568 * Length - Length of the descriptor in bytes
569 * Level - Current source code indentation level
570 *
571 * RETURN: None
572 *
573 * DESCRIPTION: Decode a Word Address Space descriptor
574 *
575 ******************************************************************************/
576
577 void
578 AcpiDmWordDescriptor (
579 AML_RESOURCE *Resource,
580 UINT32 Length,
581 UINT32 Level)
582 {
583
584 /* Dump resource name and flags */
585
586 AcpiDmAddressCommon (Resource, ACPI_RESOURCE_TYPE_ADDRESS16, Level);
587
588 /* Dump the 5 contiguous WORD values */
589
590 AcpiDmAddressFields (&Resource->Address16.Granularity, 16, Level);
591
592 /* The ResourceSource fields are optional */
593
594 AcpiDmIndent (Level + 1);
595 AcpiDmResourceSource (Resource, sizeof (AML_RESOURCE_ADDRESS16), Length);
596
597 /* Insert a descriptor name */
598
599 AcpiDmDescriptorName ();
600
601 /* Type-specific flags */
602
603 AcpiDmAddressFlags (Resource);
604 AcpiOsPrintf (")\n");
605 }
606
607
608 /*******************************************************************************
609 *
610 * FUNCTION: AcpiDmDwordDescriptor
611 *
612 * PARAMETERS: Resource - Pointer to the resource descriptor
613 * Length - Length of the descriptor in bytes
614 * Level - Current source code indentation level
615 *
616 * RETURN: None
617 *
618 * DESCRIPTION: Decode a DWord Address Space descriptor
619 *
620 ******************************************************************************/
621
622 void
623 AcpiDmDwordDescriptor (
624 AML_RESOURCE *Resource,
625 UINT32 Length,
626 UINT32 Level)
627 {
628
629 /* Dump resource name and flags */
630
631 AcpiDmAddressCommon (Resource, ACPI_RESOURCE_TYPE_ADDRESS32, Level);
632
633 /* Dump the 5 contiguous DWORD values */
634
635 AcpiDmAddressFields (&Resource->Address32.Granularity, 32, Level);
636
637 /* The ResourceSource fields are optional */
638
639 AcpiDmIndent (Level + 1);
640 AcpiDmResourceSource (Resource, sizeof (AML_RESOURCE_ADDRESS32), Length);
641
642 /* Insert a descriptor name */
643
644 AcpiDmDescriptorName ();
645
646 /* Type-specific flags */
647
648 AcpiDmAddressFlags (Resource);
649 AcpiOsPrintf (")\n");
650 }
651
652
653 /*******************************************************************************
654 *
655 * FUNCTION: AcpiDmQwordDescriptor
656 *
657 * PARAMETERS: Resource - Pointer to the resource descriptor
658 * Length - Length of the descriptor in bytes
659 * Level - Current source code indentation level
660 *
661 * RETURN: None
662 *
663 * DESCRIPTION: Decode a QWord Address Space descriptor
664 *
665 ******************************************************************************/
666
667 void
668 AcpiDmQwordDescriptor (
669 AML_RESOURCE *Resource,
670 UINT32 Length,
671 UINT32 Level)
672 {
673
674 /* Dump resource name and flags */
675
676 AcpiDmAddressCommon (Resource, ACPI_RESOURCE_TYPE_ADDRESS64, Level);
677
678 /* Dump the 5 contiguous QWORD values */
679
680 AcpiDmAddressFields (&Resource->Address64.Granularity, 64, Level);
681
682 /* The ResourceSource fields are optional */
683
684 AcpiDmIndent (Level + 1);
685 AcpiDmResourceSource (Resource, sizeof (AML_RESOURCE_ADDRESS64), Length);
686
687 /* Insert a descriptor name */
688
689 AcpiDmDescriptorName ();
690
691 /* Type-specific flags */
692
693 AcpiDmAddressFlags (Resource);
694 AcpiOsPrintf (")\n");
695 }
696
697
698 /*******************************************************************************
699 *
700 * FUNCTION: AcpiDmExtendedDescriptor
701 *
702 * PARAMETERS: Resource - Pointer to the resource descriptor
703 * Length - Length of the descriptor in bytes
704 * Level - Current source code indentation level
705 *
706 * RETURN: None
707 *
708 * DESCRIPTION: Decode a Extended Address Space descriptor
709 *
710 ******************************************************************************/
711
712 void
713 AcpiDmExtendedDescriptor (
714 AML_RESOURCE *Resource,
715 UINT32 Length,
716 UINT32 Level)
717 {
718
719 /* Dump resource name and flags */
720
721 AcpiDmAddressCommon (Resource, ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64, Level);
722
723 /* Dump the 5 contiguous QWORD values */
724
725 AcpiDmAddressFields (&Resource->ExtAddress64.Granularity, 64, Level);
726
727 /* Extra field for this descriptor only */
728
729 AcpiDmIndent (Level + 1);
730 AcpiDmDumpInteger64 (Resource->ExtAddress64.TypeSpecific,
731 "Type-Specific Attributes");
732
733 /* Insert a descriptor name */
734
735 AcpiDmIndent (Level + 1);
736 AcpiDmDescriptorName ();
737
738 /* Type-specific flags */
739
740 AcpiDmAddressFlags (Resource);
741 AcpiOsPrintf (")\n");
742 }
743
744
745 /*******************************************************************************
746 *
747 * FUNCTION: AcpiDmMemory24Descriptor
748 *
749 * PARAMETERS: Resource - Pointer to the resource descriptor
750 * Length - Length of the descriptor in bytes
751 * Level - Current source code indentation level
752 *
753 * RETURN: None
754 *
755 * DESCRIPTION: Decode a Memory24 descriptor
756 *
757 ******************************************************************************/
758
759 void
760 AcpiDmMemory24Descriptor (
761 AML_RESOURCE *Resource,
762 UINT32 Length,
763 UINT32 Level)
764 {
765
766 /* Dump name and read/write flag */
767
768 AcpiDmIndent (Level);
769 AcpiOsPrintf ("Memory24 (%s,\n",
770 AcpiGbl_RwDecode [Resource->Memory24.Flags & 1]);
771
772 /* Dump the 4 contiguous WORD values */
773
774 AcpiDmMemoryFields (&Resource->Memory24.Minimum, 16, Level);
775
776 /* Insert a descriptor name */
777
778 AcpiDmIndent (Level + 1);
779 AcpiDmDescriptorName ();
780 AcpiOsPrintf (")\n");
781 }
782
783
784 /*******************************************************************************
785 *
786 * FUNCTION: AcpiDmMemory32Descriptor
787 *
788 * PARAMETERS: Resource - Pointer to the resource descriptor
789 * Length - Length of the descriptor in bytes
790 * Level - Current source code indentation level
791 *
792 * RETURN: None
793 *
794 * DESCRIPTION: Decode a Memory32 descriptor
795 *
796 ******************************************************************************/
797
798 void
799 AcpiDmMemory32Descriptor (
800 AML_RESOURCE *Resource,
801 UINT32 Length,
802 UINT32 Level)
803 {
804
805 /* Dump name and read/write flag */
806
807 AcpiDmIndent (Level);
808 AcpiOsPrintf ("Memory32 (%s,\n",
809 AcpiGbl_RwDecode [Resource->Memory32.Flags & 1]);
810
811 /* Dump the 4 contiguous DWORD values */
812
813 AcpiDmMemoryFields (&Resource->Memory32.Minimum, 32, Level);
814
815 /* Insert a descriptor name */
816
817 AcpiDmIndent (Level + 1);
818 AcpiDmDescriptorName ();
819 AcpiOsPrintf (")\n");
820 }
821
822
823 /*******************************************************************************
824 *
825 * FUNCTION: AcpiDmFixedMemory32Descriptor
826 *
827 * PARAMETERS: Resource - Pointer to the resource descriptor
828 * Length - Length of the descriptor in bytes
829 * Level - Current source code indentation level
830 *
831 * RETURN: None
832 *
833 * DESCRIPTION: Decode a Fixed Memory32 descriptor
834 *
835 ******************************************************************************/
836
837 void
838 AcpiDmFixedMemory32Descriptor (
839 AML_RESOURCE *Resource,
840 UINT32 Length,
841 UINT32 Level)
842 {
843
844 /* Dump name and read/write flag */
845
846 AcpiDmIndent (Level);
847 AcpiOsPrintf ("Memory32Fixed (%s,\n",
848 AcpiGbl_RwDecode [Resource->FixedMemory32.Flags & 1]);
849
850 AcpiDmIndent (Level + 1);
851 AcpiDmDumpInteger32 (Resource->FixedMemory32.Address, "Address Base");
852
853 AcpiDmIndent (Level + 1);
854 AcpiDmDumpInteger32 (Resource->FixedMemory32.AddressLength, "Address Length");
855
856 /* Insert a descriptor name */
857
858 AcpiDmIndent (Level + 1);
859 AcpiDmDescriptorName ();
860 AcpiOsPrintf (")\n");
861 }
862
863
864 /*******************************************************************************
865 *
866 * FUNCTION: AcpiDmGenericRegisterDescriptor
867 *
868 * PARAMETERS: Resource - Pointer to the resource descriptor
869 * Length - Length of the descriptor in bytes
870 * Level - Current source code indentation level
871 *
872 * RETURN: None
873 *
874 * DESCRIPTION: Decode a Generic Register descriptor
875 *
876 ******************************************************************************/
877
878 void
879 AcpiDmGenericRegisterDescriptor (
880 AML_RESOURCE *Resource,
881 UINT32 Length,
882 UINT32 Level)
883 {
884
885 AcpiDmIndent (Level);
886 AcpiOsPrintf ("Register (");
887 AcpiDmAddressSpace (Resource->GenericReg.AddressSpaceId);
888 AcpiOsPrintf ("\n");
889
890 AcpiDmIndent (Level + 1);
891 AcpiDmDumpInteger8 (Resource->GenericReg.BitWidth, "Bit Width");
892
893 AcpiDmIndent (Level + 1);
894 AcpiDmDumpInteger8 (Resource->GenericReg.BitOffset, "Bit Offset");
895
896 AcpiDmIndent (Level + 1);
897 AcpiDmDumpInteger64 (Resource->GenericReg.Address, "Address");
898
899 /* Optional field for ACPI 3.0 */
900
901 AcpiDmIndent (Level + 1);
902 if (Resource->GenericReg.AccessSize)
903 {
904 AcpiOsPrintf ("0x%2.2X, // %s\n",
905 Resource->GenericReg.AccessSize, "Access Size");
906 AcpiDmIndent (Level + 1);
907 }
908 else
909 {
910 AcpiOsPrintf (",");
911 }
912
913 /* DescriptorName was added for ACPI 3.0+ */
914
915 AcpiDmDescriptorName ();
916 AcpiOsPrintf (")\n");
917 }
918
919
920 /*******************************************************************************
921 *
922 * FUNCTION: AcpiDmInterruptDescriptor
923 *
924 * PARAMETERS: Resource - Pointer to the resource descriptor
925 * Length - Length of the descriptor in bytes
926 * Level - Current source code indentation level
927 *
928 * RETURN: None
929 *
930 * DESCRIPTION: Decode a extended Interrupt descriptor
931 *
932 ******************************************************************************/
933
934 void
935 AcpiDmInterruptDescriptor (
936 AML_RESOURCE *Resource,
937 UINT32 Length,
938 UINT32 Level)
939 {
940 UINT32 i;
941
942
943 AcpiDmIndent (Level);
944 AcpiOsPrintf ("Interrupt (%s, %s, %s, %s, ",
945 AcpiGbl_ConsumeDecode [(Resource->ExtendedIrq.Flags & 1)],
946 AcpiGbl_HeDecode [(Resource->ExtendedIrq.Flags >> 1) & 1],
947 AcpiGbl_LlDecode [(Resource->ExtendedIrq.Flags >> 2) & 1],
948 AcpiGbl_ShrDecode [(Resource->ExtendedIrq.Flags >> 3) & 1]);
949
950 /*
951 * The ResourceSource fields are optional and appear after the interrupt
952 * list. Must compute length based on length of the list. First xrupt
953 * is included in the struct (reason for -1 below)
954 */
955 AcpiDmResourceSource (Resource,
956 sizeof (AML_RESOURCE_EXTENDED_IRQ) +
957 ((UINT32) Resource->ExtendedIrq.InterruptCount - 1) * sizeof (UINT32),
958 Resource->ExtendedIrq.ResourceLength);
959
960 /* Insert a descriptor name */
961
962 AcpiDmDescriptorName ();
963 AcpiOsPrintf (")\n");
964
965 /* Dump the interrupt list */
966
967 AcpiDmIndent (Level);
968 AcpiOsPrintf ("{\n");
969 for (i = 0; i < Resource->ExtendedIrq.InterruptCount; i++)
970 {
971 AcpiDmIndent (Level + 1);
972 AcpiOsPrintf ("0x%8.8X,\n",
973 (UINT32) Resource->ExtendedIrq.Interrupts[i]);
974 }
975
976 AcpiDmIndent (Level);
977 AcpiOsPrintf ("}\n");
978 }
979
980
981 /*******************************************************************************
982 *
983 * FUNCTION: AcpiDmVendorCommon
984 *
985 * PARAMETERS: Name - Descriptor name suffix
986 * ByteData - Pointer to the vendor byte data
987 * Length - Length of the byte data
988 * Level - Current source code indentation level
989 *
990 * RETURN: None
991 *
992 * DESCRIPTION: Decode a Vendor descriptor, both Large and Small
993 *
994 ******************************************************************************/
995
996 void
997 AcpiDmVendorCommon (
998 char *Name,
999 UINT8 *ByteData,
1000 UINT32 Length,
1001 UINT32 Level)
1002 {
1003
1004 /* Dump macro name */
1005
1006 AcpiDmIndent (Level);
1007 AcpiOsPrintf ("Vendor%s (", Name);
1008
1009 /* Insert a descriptor name */
1010
1011 AcpiDmDescriptorName ();
1012 AcpiOsPrintf (") // Length = 0x%.2X\n", Length);
1013
1014 /* Dump the vendor bytes */
1015
1016 AcpiDmIndent (Level);
1017 AcpiOsPrintf ("{\n");
1018
1019 AcpiDmDisasmByteList (Level + 1, ByteData, Length);
1020
1021 AcpiDmIndent (Level);
1022 AcpiOsPrintf ("}\n");
1023 }
1024
1025
1026 /*******************************************************************************
1027 *
1028 * FUNCTION: AcpiDmVendorLargeDescriptor
1029 *
1030 * PARAMETERS: Resource - Pointer to the resource descriptor
1031 * Length - Length of the descriptor in bytes
1032 * Level - Current source code indentation level
1033 *
1034 * RETURN: None
1035 *
1036 * DESCRIPTION: Decode a Vendor Large descriptor
1037 *
1038 ******************************************************************************/
1039
1040 void
1041 AcpiDmVendorLargeDescriptor (
1042 AML_RESOURCE *Resource,
1043 UINT32 Length,
1044 UINT32 Level)
1045 {
1046
1047 AcpiDmVendorCommon ("Long ",
1048 ACPI_ADD_PTR (UINT8, Resource, sizeof (AML_RESOURCE_LARGE_HEADER)),
1049 Length, Level);
1050 }
1051
1052 #endif
1053