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