xref: /illumos-gate/usr/src/common/acpica/resources/rsdump.c (revision 35786f6866ae52207d0f1a25fe7ca5f652f32ce0)
1 /*******************************************************************************
2  *
3  * Module Name: rsdump - AML debugger support for resource structures.
4  *
5  ******************************************************************************/
6 
7 /******************************************************************************
8  *
9  * 1. Copyright Notice
10  *
11  * Some or all of this work - Copyright (c) 1999 - 2018, Intel Corp.
12  * All rights reserved.
13  *
14  * 2. License
15  *
16  * 2.1. This is your license from Intel Corp. under its intellectual property
17  * rights. You may have additional license terms from the party that provided
18  * you this software, covering your right to use that party's intellectual
19  * property rights.
20  *
21  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
22  * copy of the source code appearing in this file ("Covered Code") an
23  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
24  * base code distributed originally by Intel ("Original Intel Code") to copy,
25  * make derivatives, distribute, use and display any portion of the Covered
26  * Code in any form, with the right to sublicense such rights; and
27  *
28  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
29  * license (with the right to sublicense), under only those claims of Intel
30  * patents that are infringed by the Original Intel Code, to make, use, sell,
31  * offer to sell, and import the Covered Code and derivative works thereof
32  * solely to the minimum extent necessary to exercise the above copyright
33  * license, and in no event shall the patent license extend to any additions
34  * to or modifications of the Original Intel Code. No other license or right
35  * is granted directly or by implication, estoppel or otherwise;
36  *
37  * The above copyright and patent license is granted only if the following
38  * conditions are met:
39  *
40  * 3. Conditions
41  *
42  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
43  * Redistribution of source code of any substantial portion of the Covered
44  * Code or modification with rights to further distribute source must include
45  * the above Copyright Notice, the above License, this list of Conditions,
46  * and the following Disclaimer and Export Compliance provision. In addition,
47  * Licensee must cause all Covered Code to which Licensee contributes to
48  * contain a file documenting the changes Licensee made to create that Covered
49  * Code and the date of any change. Licensee must include in that file the
50  * documentation of any changes made by any predecessor Licensee. Licensee
51  * must include a prominent statement that the modification is derived,
52  * directly or indirectly, from Original Intel Code.
53  *
54  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
55  * Redistribution of source code of any substantial portion of the Covered
56  * Code or modification without rights to further distribute source must
57  * include the following Disclaimer and Export Compliance provision in the
58  * documentation and/or other materials provided with distribution. In
59  * addition, Licensee may not authorize further sublicense of source of any
60  * portion of the Covered Code, and must include terms to the effect that the
61  * license from Licensee to its licensee is limited to the intellectual
62  * property embodied in the software Licensee provides to its licensee, and
63  * not to intellectual property embodied in modifications its licensee may
64  * make.
65  *
66  * 3.3. Redistribution of Executable. Redistribution in executable form of any
67  * substantial portion of the Covered Code or modification must reproduce the
68  * above Copyright Notice, and the following Disclaimer and Export Compliance
69  * provision in the documentation and/or other materials provided with the
70  * distribution.
71  *
72  * 3.4. Intel retains all right, title, and interest in and to the Original
73  * Intel Code.
74  *
75  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
76  * Intel shall be used in advertising or otherwise to promote the sale, use or
77  * other dealings in products derived from or relating to the Covered Code
78  * without prior written authorization from Intel.
79  *
80  * 4. Disclaimer and Export Compliance
81  *
82  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
83  * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
84  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
85  * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
86  * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
87  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
88  * PARTICULAR PURPOSE.
89  *
90  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
91  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
92  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
93  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
94  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
95  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
96  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
97  * LIMITED REMEDY.
98  *
99  * 4.3. Licensee shall not export, either directly or indirectly, any of this
100  * software or system incorporating such software without first obtaining any
101  * required license or other approval from the U. S. Department of Commerce or
102  * any other agency or department of the United States Government. In the
103  * event Licensee exports any such software from the United States or
104  * re-exports any such software from a foreign destination, Licensee shall
105  * ensure that the distribution and export/re-export of the software is in
106  * compliance with all laws, regulations, orders, or other restrictions of the
107  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
108  * any of its subsidiaries will export/re-export any technical data, process,
109  * software, or service, directly or indirectly, to any country for which the
110  * United States government or any agency thereof requires an export license,
111  * other governmental approval, or letter of assurance, without first obtaining
112  * such license, approval or letter.
113  *
114  *****************************************************************************
115  *
116  * Alternatively, you may choose to be licensed under the terms of the
117  * following license:
118  *
119  * Redistribution and use in source and binary forms, with or without
120  * modification, are permitted provided that the following conditions
121  * are met:
122  * 1. Redistributions of source code must retain the above copyright
123  *    notice, this list of conditions, and the following disclaimer,
124  *    without modification.
125  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
126  *    substantially similar to the "NO WARRANTY" disclaimer below
127  *    ("Disclaimer") and any redistribution must be conditioned upon
128  *    including a substantially similar Disclaimer requirement for further
129  *    binary redistribution.
130  * 3. Neither the names of the above-listed copyright holders nor the names
131  *    of any contributors may be used to endorse or promote products derived
132  *    from this software without specific prior written permission.
133  *
134  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
135  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
136  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
137  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
138  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
139  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
140  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
141  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
142  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
143  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
144  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
145  *
146  * Alternatively, you may choose to be licensed under the terms of the
147  * GNU General Public License ("GPL") version 2 as published by the Free
148  * Software Foundation.
149  *
150  *****************************************************************************/
151 
152 #include "acpi.h"
153 #include "accommon.h"
154 #include "acresrc.h"
155 
156 #define _COMPONENT          ACPI_RESOURCES
157         ACPI_MODULE_NAME    ("rsdump")
158 
159 /*
160  * All functions in this module are used by the AML Debugger only
161  */
162 
163 /* Local prototypes */
164 
165 static void
166 AcpiRsOutString (
167     const char              *Title,
168     const char              *Value);
169 
170 static void
171 AcpiRsOutInteger8 (
172     const char              *Title,
173     UINT8                   Value);
174 
175 static void
176 AcpiRsOutInteger16 (
177     const char              *Title,
178     UINT16                  Value);
179 
180 static void
181 AcpiRsOutInteger32 (
182     const char              *Title,
183     UINT32                  Value);
184 
185 static void
186 AcpiRsOutInteger64 (
187     const char              *Title,
188     UINT64                  Value);
189 
190 static void
191 AcpiRsOutTitle (
192     const char              *Title);
193 
194 static void
195 AcpiRsDumpByteList (
196     UINT16                  Length,
197     UINT8                   *Data);
198 
199 static void
200 AcpiRsDumpWordList (
201     UINT16                  Length,
202     UINT16                  *Data);
203 
204 static void
205 AcpiRsDumpDwordList (
206     UINT8                   Length,
207     UINT32                  *Data);
208 
209 static void
210 AcpiRsDumpShortByteList (
211     UINT8                   Length,
212     UINT8                   *Data);
213 
214 static void
215 AcpiRsDumpResourceSource (
216     ACPI_RESOURCE_SOURCE    *ResourceSource);
217 
218 static void
219 AcpiRsDumpResourceLabel (
220     char                   *Title,
221     ACPI_RESOURCE_LABEL    *ResourceLabel);
222 
223 static void
224 AcpiRsDumpAddressCommon (
225     ACPI_RESOURCE_DATA      *Resource);
226 
227 static void
228 AcpiRsDumpDescriptor (
229     void                    *Resource,
230     ACPI_RSDUMP_INFO        *Table);
231 
232 
233 /*******************************************************************************
234  *
235  * FUNCTION:    AcpiRsDumpResourceList
236  *
237  * PARAMETERS:  ResourceList        - Pointer to a resource descriptor list
238  *
239  * RETURN:      None
240  *
241  * DESCRIPTION: Dispatches the structure to the correct dump routine.
242  *
243  ******************************************************************************/
244 
245 void
AcpiRsDumpResourceList(ACPI_RESOURCE * ResourceList)246 AcpiRsDumpResourceList (
247     ACPI_RESOURCE           *ResourceList)
248 {
249     UINT32                  Count = 0;
250     UINT32                  Type;
251 
252 
253     ACPI_FUNCTION_ENTRY ();
254 
255 
256     /* Check if debug output enabled */
257 
258     if (!ACPI_IS_DEBUG_ENABLED (ACPI_LV_RESOURCES, _COMPONENT))
259     {
260         return;
261     }
262 
263     /* Walk list and dump all resource descriptors (END_TAG terminates) */
264 
265     do
266     {
267         AcpiOsPrintf ("\n[%02X] ", Count);
268         Count++;
269 
270         /* Validate Type before dispatch */
271 
272         Type = ResourceList->Type;
273         if (Type > ACPI_RESOURCE_TYPE_MAX)
274         {
275             AcpiOsPrintf (
276                 "Invalid descriptor type (%X) in resource list\n",
277                 ResourceList->Type);
278             return;
279         }
280 
281         /* Sanity check the length. It must not be zero, or we loop forever */
282 
283         if (!ResourceList->Length)
284         {
285             AcpiOsPrintf (
286                 "Invalid zero length descriptor in resource list\n");
287             return;
288         }
289 
290         /* Dump the resource descriptor */
291 
292         if (Type == ACPI_RESOURCE_TYPE_SERIAL_BUS)
293         {
294             AcpiRsDumpDescriptor (&ResourceList->Data,
295                 AcpiGbl_DumpSerialBusDispatch[
296                     ResourceList->Data.CommonSerialBus.Type]);
297         }
298         else
299         {
300             AcpiRsDumpDescriptor (&ResourceList->Data,
301                 AcpiGbl_DumpResourceDispatch[Type]);
302         }
303 
304         /* Point to the next resource structure */
305 
306         ResourceList = ACPI_NEXT_RESOURCE (ResourceList);
307 
308         /* Exit when END_TAG descriptor is reached */
309 
310     } while (Type != ACPI_RESOURCE_TYPE_END_TAG);
311 }
312 
313 
314 /*******************************************************************************
315  *
316  * FUNCTION:    AcpiRsDumpIrqList
317  *
318  * PARAMETERS:  RouteTable      - Pointer to the routing table to dump.
319  *
320  * RETURN:      None
321  *
322  * DESCRIPTION: Print IRQ routing table
323  *
324  ******************************************************************************/
325 
326 void
AcpiRsDumpIrqList(UINT8 * RouteTable)327 AcpiRsDumpIrqList (
328     UINT8                   *RouteTable)
329 {
330     ACPI_PCI_ROUTING_TABLE  *PrtElement;
331     UINT8                   Count;
332 
333 
334     ACPI_FUNCTION_ENTRY ();
335 
336 
337     /* Check if debug output enabled */
338 
339     if (!ACPI_IS_DEBUG_ENABLED (ACPI_LV_RESOURCES, _COMPONENT))
340     {
341         return;
342     }
343 
344     PrtElement = ACPI_CAST_PTR (ACPI_PCI_ROUTING_TABLE, RouteTable);
345 
346     /* Dump all table elements, Exit on zero length element */
347 
348     for (Count = 0; PrtElement->Length; Count++)
349     {
350         AcpiOsPrintf ("\n[%02X] PCI IRQ Routing Table Package\n", Count);
351         AcpiRsDumpDescriptor (PrtElement, AcpiRsDumpPrt);
352 
353         PrtElement = ACPI_ADD_PTR (ACPI_PCI_ROUTING_TABLE,
354             PrtElement, PrtElement->Length);
355     }
356 }
357 
358 
359 /*******************************************************************************
360  *
361  * FUNCTION:    AcpiRsDumpDescriptor
362  *
363  * PARAMETERS:  Resource            - Buffer containing the resource
364  *              Table               - Table entry to decode the resource
365  *
366  * RETURN:      None
367  *
368  * DESCRIPTION: Dump a resource descriptor based on a dump table entry.
369  *
370  ******************************************************************************/
371 
372 static void
AcpiRsDumpDescriptor(void * Resource,ACPI_RSDUMP_INFO * Table)373 AcpiRsDumpDescriptor (
374     void                    *Resource,
375     ACPI_RSDUMP_INFO        *Table)
376 {
377     UINT8                   *Target = NULL;
378     UINT8                   *PreviousTarget;
379     const char              *Name;
380     UINT8                   Count;
381 
382 
383     /* First table entry must contain the table length (# of table entries) */
384 
385     Count = Table->Offset;
386 
387     while (Count)
388     {
389         PreviousTarget = Target;
390         Target = ACPI_ADD_PTR (UINT8, Resource, Table->Offset);
391         Name = Table->Name;
392 
393         switch (Table->Opcode)
394         {
395         case ACPI_RSD_TITLE:
396             /*
397              * Optional resource title
398              */
399             if (Table->Name)
400             {
401                 AcpiOsPrintf ("%s Resource\n", Name);
402             }
403             break;
404 
405         /* Strings */
406 
407         case ACPI_RSD_LITERAL:
408 
409             AcpiRsOutString (Name, ACPI_CAST_PTR (char, Table->Pointer));
410             break;
411 
412         case ACPI_RSD_STRING:
413 
414             AcpiRsOutString (Name, ACPI_CAST_PTR (char, Target));
415             break;
416 
417         /* Data items, 8/16/32/64 bit */
418 
419         case ACPI_RSD_UINT8:
420 
421             if (Table->Pointer)
422             {
423                 AcpiRsOutString (Name, Table->Pointer [*Target]);
424             }
425             else
426             {
427                 AcpiRsOutInteger8 (Name, ACPI_GET8 (Target));
428             }
429             break;
430 
431         case ACPI_RSD_UINT16:
432 
433             AcpiRsOutInteger16 (Name, ACPI_GET16 (Target));
434             break;
435 
436         case ACPI_RSD_UINT32:
437 
438             AcpiRsOutInteger32 (Name, ACPI_GET32 (Target));
439             break;
440 
441         case ACPI_RSD_UINT64:
442 
443             AcpiRsOutInteger64 (Name, ACPI_GET64 (Target));
444             break;
445 
446         /* Flags: 1-bit and 2-bit flags supported */
447 
448         case ACPI_RSD_1BITFLAG:
449 
450             AcpiRsOutString (Name, Table->Pointer [*Target & 0x01]);
451             break;
452 
453         case ACPI_RSD_2BITFLAG:
454 
455             AcpiRsOutString (Name, Table->Pointer [*Target & 0x03]);
456             break;
457 
458         case ACPI_RSD_3BITFLAG:
459 
460             AcpiRsOutString (Name, Table->Pointer [*Target & 0x07]);
461             break;
462 
463         case ACPI_RSD_SHORTLIST:
464             /*
465              * Short byte list (single line output) for DMA and IRQ resources
466              * Note: The list length is obtained from the previous table entry
467              */
468             if (PreviousTarget)
469             {
470                 AcpiRsOutTitle (Name);
471                 AcpiRsDumpShortByteList (*PreviousTarget, Target);
472             }
473             break;
474 
475         case ACPI_RSD_SHORTLISTX:
476             /*
477              * Short byte list (single line output) for GPIO vendor data
478              * Note: The list length is obtained from the previous table entry
479              */
480             if (PreviousTarget)
481             {
482                 AcpiRsOutTitle (Name);
483                 AcpiRsDumpShortByteList (*PreviousTarget,
484                     *(ACPI_CAST_INDIRECT_PTR (UINT8, Target)));
485             }
486             break;
487 
488         case ACPI_RSD_LONGLIST:
489             /*
490              * Long byte list for Vendor resource data
491              * Note: The list length is obtained from the previous table entry
492              */
493             if (PreviousTarget)
494             {
495                 AcpiRsDumpByteList (ACPI_GET16 (PreviousTarget), Target);
496             }
497             break;
498 
499         case ACPI_RSD_DWORDLIST:
500             /*
501              * Dword list for Extended Interrupt resources
502              * Note: The list length is obtained from the previous table entry
503              */
504             if (PreviousTarget)
505             {
506                 AcpiRsDumpDwordList (*PreviousTarget,
507                     ACPI_CAST_PTR (UINT32, Target));
508             }
509             break;
510 
511         case ACPI_RSD_WORDLIST:
512             /*
513              * Word list for GPIO Pin Table
514              * Note: The list length is obtained from the previous table entry
515              */
516             if (PreviousTarget)
517             {
518                 AcpiRsDumpWordList (*PreviousTarget,
519                     *(ACPI_CAST_INDIRECT_PTR (UINT16, Target)));
520             }
521             break;
522 
523         case ACPI_RSD_ADDRESS:
524             /*
525              * Common flags for all Address resources
526              */
527             AcpiRsDumpAddressCommon (ACPI_CAST_PTR (
528                 ACPI_RESOURCE_DATA, Target));
529             break;
530 
531         case ACPI_RSD_SOURCE:
532             /*
533              * Optional ResourceSource for Address resources
534              */
535             AcpiRsDumpResourceSource (ACPI_CAST_PTR (
536                 ACPI_RESOURCE_SOURCE, Target));
537             break;
538 
539         case ACPI_RSD_LABEL:
540             /*
541              * ResourceLabel
542              */
543             AcpiRsDumpResourceLabel ("Resource Label", ACPI_CAST_PTR (
544                 ACPI_RESOURCE_LABEL, Target));
545             break;
546 
547         case ACPI_RSD_SOURCE_LABEL:
548             /*
549              * ResourceSourceLabel
550              */
551             AcpiRsDumpResourceLabel ("Resource Source Label", ACPI_CAST_PTR (
552                 ACPI_RESOURCE_LABEL, Target));
553             break;
554 
555         default:
556 
557             AcpiOsPrintf ("**** Invalid table opcode [%X] ****\n",
558                 Table->Opcode);
559             return;
560         }
561 
562         Table++;
563         Count--;
564     }
565 }
566 
567 
568 /*******************************************************************************
569  *
570  * FUNCTION:    AcpiRsDumpResourceSource
571  *
572  * PARAMETERS:  ResourceSource      - Pointer to a Resource Source struct
573  *
574  * RETURN:      None
575  *
576  * DESCRIPTION: Common routine for dumping the optional ResourceSource and the
577  *              corresponding ResourceSourceIndex.
578  *
579  ******************************************************************************/
580 
581 static void
AcpiRsDumpResourceSource(ACPI_RESOURCE_SOURCE * ResourceSource)582 AcpiRsDumpResourceSource (
583     ACPI_RESOURCE_SOURCE    *ResourceSource)
584 {
585     ACPI_FUNCTION_ENTRY ();
586 
587 
588     if (ResourceSource->Index == 0xFF)
589     {
590         return;
591     }
592 
593     AcpiRsOutInteger8 ("Resource Source Index",
594         ResourceSource->Index);
595 
596     AcpiRsOutString ("Resource Source",
597         ResourceSource->StringPtr ?
598             ResourceSource->StringPtr : "[Not Specified]");
599 }
600 
601 
602 /*******************************************************************************
603  *
604  * FUNCTION:    AcpiRsDumpResourceLabel
605  *
606  * PARAMETERS:  Title              - Title of the dumped resource field
607  *              ResourceLabel      - Pointer to a Resource Label struct
608  *
609  * RETURN:      None
610  *
611  * DESCRIPTION: Common routine for dumping the ResourceLabel
612  *
613  ******************************************************************************/
614 
615 static void
AcpiRsDumpResourceLabel(char * Title,ACPI_RESOURCE_LABEL * ResourceLabel)616 AcpiRsDumpResourceLabel (
617     char                   *Title,
618     ACPI_RESOURCE_LABEL    *ResourceLabel)
619 {
620     ACPI_FUNCTION_ENTRY ();
621 
622     AcpiRsOutString (Title,
623         ResourceLabel->StringPtr ?
624             ResourceLabel->StringPtr : "[Not Specified]");
625 }
626 
627 
628 /*******************************************************************************
629  *
630  * FUNCTION:    AcpiRsDumpAddressCommon
631  *
632  * PARAMETERS:  Resource        - Pointer to an internal resource descriptor
633  *
634  * RETURN:      None
635  *
636  * DESCRIPTION: Dump the fields that are common to all Address resource
637  *              descriptors
638  *
639  ******************************************************************************/
640 
641 static void
AcpiRsDumpAddressCommon(ACPI_RESOURCE_DATA * Resource)642 AcpiRsDumpAddressCommon (
643     ACPI_RESOURCE_DATA      *Resource)
644 {
645     ACPI_FUNCTION_ENTRY ();
646 
647 
648    /* Decode the type-specific flags */
649 
650     switch (Resource->Address.ResourceType)
651     {
652     case ACPI_MEMORY_RANGE:
653 
654         AcpiRsDumpDescriptor (Resource, AcpiRsDumpMemoryFlags);
655         break;
656 
657     case ACPI_IO_RANGE:
658 
659         AcpiRsDumpDescriptor (Resource, AcpiRsDumpIoFlags);
660         break;
661 
662     case ACPI_BUS_NUMBER_RANGE:
663 
664         AcpiRsOutString ("Resource Type", "Bus Number Range");
665         break;
666 
667     default:
668 
669         AcpiRsOutInteger8 ("Resource Type",
670             (UINT8) Resource->Address.ResourceType);
671         break;
672     }
673 
674     /* Decode the general flags */
675 
676     AcpiRsDumpDescriptor (Resource, AcpiRsDumpGeneralFlags);
677 }
678 
679 
680 /*******************************************************************************
681  *
682  * FUNCTION:    AcpiRsOut*
683  *
684  * PARAMETERS:  Title       - Name of the resource field
685  *              Value       - Value of the resource field
686  *
687  * RETURN:      None
688  *
689  * DESCRIPTION: Miscellaneous helper functions to consistently format the
690  *              output of the resource dump routines
691  *
692  ******************************************************************************/
693 
694 static void
AcpiRsOutString(const char * Title,const char * Value)695 AcpiRsOutString (
696     const char              *Title,
697     const char              *Value)
698 {
699 
700     AcpiOsPrintf ("%27s : %s", Title, Value);
701     if (!*Value)
702     {
703         AcpiOsPrintf ("[NULL NAMESTRING]");
704     }
705     AcpiOsPrintf ("\n");
706 }
707 
708 static void
AcpiRsOutInteger8(const char * Title,UINT8 Value)709 AcpiRsOutInteger8 (
710     const char              *Title,
711     UINT8                   Value)
712 {
713     AcpiOsPrintf ("%27s : %2.2X\n", Title, Value);
714 }
715 
716 static void
AcpiRsOutInteger16(const char * Title,UINT16 Value)717 AcpiRsOutInteger16 (
718     const char              *Title,
719     UINT16                  Value)
720 {
721 
722     AcpiOsPrintf ("%27s : %4.4X\n", Title, Value);
723 }
724 
725 static void
AcpiRsOutInteger32(const char * Title,UINT32 Value)726 AcpiRsOutInteger32 (
727     const char              *Title,
728     UINT32                  Value)
729 {
730 
731     AcpiOsPrintf ("%27s : %8.8X\n", Title, Value);
732 }
733 
734 static void
AcpiRsOutInteger64(const char * Title,UINT64 Value)735 AcpiRsOutInteger64 (
736     const char              *Title,
737     UINT64                  Value)
738 {
739 
740     AcpiOsPrintf ("%27s : %8.8X%8.8X\n", Title,
741         ACPI_FORMAT_UINT64 (Value));
742 }
743 
744 static void
AcpiRsOutTitle(const char * Title)745 AcpiRsOutTitle (
746     const char              *Title)
747 {
748 
749     AcpiOsPrintf ("%27s : ", Title);
750 }
751 
752 
753 /*******************************************************************************
754  *
755  * FUNCTION:    AcpiRsDump*List
756  *
757  * PARAMETERS:  Length      - Number of elements in the list
758  *              Data        - Start of the list
759  *
760  * RETURN:      None
761  *
762  * DESCRIPTION: Miscellaneous functions to dump lists of raw data
763  *
764  ******************************************************************************/
765 
766 static void
AcpiRsDumpByteList(UINT16 Length,UINT8 * Data)767 AcpiRsDumpByteList (
768     UINT16                  Length,
769     UINT8                   *Data)
770 {
771     UINT16                  i;
772 
773 
774     for (i = 0; i < Length; i++)
775     {
776         AcpiOsPrintf ("%25s%2.2X : %2.2X\n", "Byte", i, Data[i]);
777     }
778 }
779 
780 static void
AcpiRsDumpShortByteList(UINT8 Length,UINT8 * Data)781 AcpiRsDumpShortByteList (
782     UINT8                   Length,
783     UINT8                   *Data)
784 {
785     UINT8                   i;
786 
787 
788     for (i = 0; i < Length; i++)
789     {
790         AcpiOsPrintf ("%X ", Data[i]);
791     }
792 
793     AcpiOsPrintf ("\n");
794 }
795 
796 static void
AcpiRsDumpDwordList(UINT8 Length,UINT32 * Data)797 AcpiRsDumpDwordList (
798     UINT8                   Length,
799     UINT32                  *Data)
800 {
801     UINT8                   i;
802 
803 
804     for (i = 0; i < Length; i++)
805     {
806         AcpiOsPrintf ("%25s%2.2X : %8.8X\n", "Dword", i, Data[i]);
807     }
808 }
809 
810 static void
AcpiRsDumpWordList(UINT16 Length,UINT16 * Data)811 AcpiRsDumpWordList (
812     UINT16                  Length,
813     UINT16                  *Data)
814 {
815     UINT16                  i;
816 
817 
818     for (i = 0; i < Length; i++)
819     {
820         AcpiOsPrintf ("%25s%2.2X : %4.4X\n", "Word", i, Data[i]);
821     }
822 }
823