1 /*******************************************************************************
2  *
3  * Module Name: rsdump - AML debugger support for resource structures.
4  *
5  ******************************************************************************/
6 
7 /*
8  * Copyright (C) 2000 - 2016, Intel Corp.
9  * All rights reserved.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions, and the following disclaimer,
16  *    without modification.
17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18  *    substantially similar to the "NO WARRANTY" disclaimer below
19  *    ("Disclaimer") and any redistribution must be conditioned upon
20  *    including a substantially similar Disclaimer requirement for further
21  *    binary redistribution.
22  * 3. Neither the names of the above-listed copyright holders nor the names
23  *    of any contributors may be used to endorse or promote products derived
24  *    from this software without specific prior written permission.
25  *
26  * Alternatively, this software may be distributed under the terms of the
27  * GNU General Public License ("GPL") version 2 as published by the Free
28  * Software Foundation.
29  *
30  * NO WARRANTY
31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41  * POSSIBILITY OF SUCH DAMAGES.
42  */
43 
44 #include "acpi.h"
45 #include "accommon.h"
46 #include "acresrc.h"
47 
48 #define _COMPONENT          ACPI_RESOURCES
49         ACPI_MODULE_NAME    ("rsdump")
50 
51 /*
52  * All functions in this module are used by the AML Debugger only
53  */
54 #if defined(ACPI_DEBUGGER)
55 
56 /* Local prototypes */
57 
58 static void
59 AcpiRsOutString (
60     char                    *Title,
61     char                    *Value);
62 
63 static void
64 AcpiRsOutInteger8 (
65     char                    *Title,
66     UINT8                   Value);
67 
68 static void
69 AcpiRsOutInteger16 (
70     char                    *Title,
71     UINT16                  Value);
72 
73 static void
74 AcpiRsOutInteger32 (
75     char                    *Title,
76     UINT32                  Value);
77 
78 static void
79 AcpiRsOutInteger64 (
80     char                    *Title,
81     UINT64                  Value);
82 
83 static void
84 AcpiRsOutTitle (
85     char                    *Title);
86 
87 static void
88 AcpiRsDumpByteList (
89     UINT16                  Length,
90     UINT8                   *Data);
91 
92 static void
93 AcpiRsDumpWordList (
94     UINT16                  Length,
95     UINT16                  *Data);
96 
97 static void
98 AcpiRsDumpDwordList (
99     UINT8                   Length,
100     UINT32                  *Data);
101 
102 static void
103 AcpiRsDumpShortByteList (
104     UINT8                   Length,
105     UINT8                   *Data);
106 
107 static void
108 AcpiRsDumpResourceSource (
109     ACPI_RESOURCE_SOURCE    *ResourceSource);
110 
111 static void
112 AcpiRsDumpAddressCommon (
113     ACPI_RESOURCE_DATA      *Resource);
114 
115 static void
116 AcpiRsDumpDescriptor (
117     void                    *Resource,
118     ACPI_RSDUMP_INFO        *Table);
119 
120 
121 /*******************************************************************************
122  *
123  * FUNCTION:    AcpiRsDumpResourceList
124  *
125  * PARAMETERS:  ResourceList        - Pointer to a resource descriptor list
126  *
127  * RETURN:      None
128  *
129  * DESCRIPTION: Dispatches the structure to the correct dump routine.
130  *
131  ******************************************************************************/
132 
133 void
134 AcpiRsDumpResourceList (
135     ACPI_RESOURCE           *ResourceList)
136 {
137     UINT32                  Count = 0;
138     UINT32                  Type;
139 
140 
141     ACPI_FUNCTION_ENTRY ();
142 
143 
144     /* Check if debug output enabled */
145 
146     if (!ACPI_IS_DEBUG_ENABLED (ACPI_LV_RESOURCES, _COMPONENT))
147     {
148         return;
149     }
150 
151     /* Walk list and dump all resource descriptors (END_TAG terminates) */
152 
153     do
154     {
155         AcpiOsPrintf ("\n[%02X] ", Count);
156         Count++;
157 
158         /* Validate Type before dispatch */
159 
160         Type = ResourceList->Type;
161         if (Type > ACPI_RESOURCE_TYPE_MAX)
162         {
163             AcpiOsPrintf (
164                 "Invalid descriptor type (%X) in resource list\n",
165                 ResourceList->Type);
166             return;
167         }
168 
169         /* Sanity check the length. It must not be zero, or we loop forever */
170 
171         if (!ResourceList->Length)
172         {
173             AcpiOsPrintf (
174                 "Invalid zero length descriptor in resource list\n");
175             return;
176         }
177 
178         /* Dump the resource descriptor */
179 
180         if (Type == ACPI_RESOURCE_TYPE_SERIAL_BUS)
181         {
182             AcpiRsDumpDescriptor (&ResourceList->Data,
183                 AcpiGbl_DumpSerialBusDispatch[
184                     ResourceList->Data.CommonSerialBus.Type]);
185         }
186         else
187         {
188             AcpiRsDumpDescriptor (&ResourceList->Data,
189                 AcpiGbl_DumpResourceDispatch[Type]);
190         }
191 
192         /* Point to the next resource structure */
193 
194         ResourceList = ACPI_NEXT_RESOURCE (ResourceList);
195 
196         /* Exit when END_TAG descriptor is reached */
197 
198     } while (Type != ACPI_RESOURCE_TYPE_END_TAG);
199 }
200 
201 
202 /*******************************************************************************
203  *
204  * FUNCTION:    AcpiRsDumpIrqList
205  *
206  * PARAMETERS:  RouteTable      - Pointer to the routing table to dump.
207  *
208  * RETURN:      None
209  *
210  * DESCRIPTION: Print IRQ routing table
211  *
212  ******************************************************************************/
213 
214 void
215 AcpiRsDumpIrqList (
216     UINT8                   *RouteTable)
217 {
218     ACPI_PCI_ROUTING_TABLE  *PrtElement;
219     UINT8                   Count;
220 
221 
222     ACPI_FUNCTION_ENTRY ();
223 
224 
225     /* Check if debug output enabled */
226 
227     if (!ACPI_IS_DEBUG_ENABLED (ACPI_LV_RESOURCES, _COMPONENT))
228     {
229         return;
230     }
231 
232     PrtElement = ACPI_CAST_PTR (ACPI_PCI_ROUTING_TABLE, RouteTable);
233 
234     /* Dump all table elements, Exit on zero length element */
235 
236     for (Count = 0; PrtElement->Length; Count++)
237     {
238         AcpiOsPrintf ("\n[%02X] PCI IRQ Routing Table Package\n", Count);
239         AcpiRsDumpDescriptor (PrtElement, AcpiRsDumpPrt);
240 
241         PrtElement = ACPI_ADD_PTR (ACPI_PCI_ROUTING_TABLE,
242             PrtElement, PrtElement->Length);
243     }
244 }
245 
246 
247 /*******************************************************************************
248  *
249  * FUNCTION:    AcpiRsDumpDescriptor
250  *
251  * PARAMETERS:  Resource            - Buffer containing the resource
252  *              Table               - Table entry to decode the resource
253  *
254  * RETURN:      None
255  *
256  * DESCRIPTION: Dump a resource descriptor based on a dump table entry.
257  *
258  ******************************************************************************/
259 
260 static void
261 AcpiRsDumpDescriptor (
262     void                    *Resource,
263     ACPI_RSDUMP_INFO        *Table)
264 {
265     UINT8                   *Target = NULL;
266     UINT8                   *PreviousTarget;
267     char                    *Name;
268     UINT8                    Count;
269 
270 
271     /* First table entry must contain the table length (# of table entries) */
272 
273     Count = Table->Offset;
274 
275     while (Count)
276     {
277         PreviousTarget = Target;
278         Target = ACPI_ADD_PTR (UINT8, Resource, Table->Offset);
279         Name = Table->Name;
280 
281         switch (Table->Opcode)
282         {
283         case ACPI_RSD_TITLE:
284             /*
285              * Optional resource title
286              */
287             if (Table->Name)
288             {
289                 AcpiOsPrintf ("%s Resource\n", Name);
290             }
291             break;
292 
293         /* Strings */
294 
295         case ACPI_RSD_LITERAL:
296 
297             AcpiRsOutString (Name, ACPI_CAST_PTR (char, Table->Pointer));
298             break;
299 
300         case ACPI_RSD_STRING:
301 
302             AcpiRsOutString (Name, ACPI_CAST_PTR (char, Target));
303             break;
304 
305         /* Data items, 8/16/32/64 bit */
306 
307         case ACPI_RSD_UINT8:
308 
309             if (Table->Pointer)
310             {
311                 AcpiRsOutString (Name, ACPI_CAST_PTR (char,
312                     Table->Pointer [*Target]));
313             }
314             else
315             {
316                 AcpiRsOutInteger8 (Name, ACPI_GET8 (Target));
317             }
318             break;
319 
320         case ACPI_RSD_UINT16:
321 
322             AcpiRsOutInteger16 (Name, ACPI_GET16 (Target));
323             break;
324 
325         case ACPI_RSD_UINT32:
326 
327             AcpiRsOutInteger32 (Name, ACPI_GET32 (Target));
328             break;
329 
330         case ACPI_RSD_UINT64:
331 
332             AcpiRsOutInteger64 (Name, ACPI_GET64 (Target));
333             break;
334 
335         /* Flags: 1-bit and 2-bit flags supported */
336 
337         case ACPI_RSD_1BITFLAG:
338 
339             AcpiRsOutString (Name, ACPI_CAST_PTR (char,
340                 Table->Pointer [*Target & 0x01]));
341             break;
342 
343         case ACPI_RSD_2BITFLAG:
344 
345             AcpiRsOutString (Name, ACPI_CAST_PTR (char,
346                 Table->Pointer [*Target & 0x03]));
347             break;
348 
349         case ACPI_RSD_3BITFLAG:
350 
351             AcpiRsOutString (Name, ACPI_CAST_PTR (char,
352                 Table->Pointer [*Target & 0x07]));
353             break;
354 
355         case ACPI_RSD_SHORTLIST:
356             /*
357              * Short byte list (single line output) for DMA and IRQ resources
358              * Note: The list length is obtained from the previous table entry
359              */
360             if (PreviousTarget)
361             {
362                 AcpiRsOutTitle (Name);
363                 AcpiRsDumpShortByteList (*PreviousTarget, Target);
364             }
365             break;
366 
367         case ACPI_RSD_SHORTLISTX:
368             /*
369              * Short byte list (single line output) for GPIO vendor data
370              * Note: The list length is obtained from the previous table entry
371              */
372             if (PreviousTarget)
373             {
374                 AcpiRsOutTitle (Name);
375                 AcpiRsDumpShortByteList (*PreviousTarget,
376                     *(ACPI_CAST_INDIRECT_PTR (UINT8, Target)));
377             }
378             break;
379 
380         case ACPI_RSD_LONGLIST:
381             /*
382              * Long byte list for Vendor resource data
383              * Note: The list length is obtained from the previous table entry
384              */
385             if (PreviousTarget)
386             {
387                 AcpiRsDumpByteList (ACPI_GET16 (PreviousTarget), Target);
388             }
389             break;
390 
391         case ACPI_RSD_DWORDLIST:
392             /*
393              * Dword list for Extended Interrupt resources
394              * Note: The list length is obtained from the previous table entry
395              */
396             if (PreviousTarget)
397             {
398                 AcpiRsDumpDwordList (*PreviousTarget,
399                     ACPI_CAST_PTR (UINT32, Target));
400             }
401             break;
402 
403         case ACPI_RSD_WORDLIST:
404             /*
405              * Word list for GPIO Pin Table
406              * Note: The list length is obtained from the previous table entry
407              */
408             if (PreviousTarget)
409             {
410                 AcpiRsDumpWordList (*PreviousTarget,
411                     *(ACPI_CAST_INDIRECT_PTR (UINT16, Target)));
412             }
413             break;
414 
415         case ACPI_RSD_ADDRESS:
416             /*
417              * Common flags for all Address resources
418              */
419             AcpiRsDumpAddressCommon (ACPI_CAST_PTR (
420                 ACPI_RESOURCE_DATA, Target));
421             break;
422 
423         case ACPI_RSD_SOURCE:
424             /*
425              * Optional ResourceSource for Address resources
426              */
427             AcpiRsDumpResourceSource (ACPI_CAST_PTR (
428                 ACPI_RESOURCE_SOURCE, Target));
429             break;
430 
431         default:
432 
433             AcpiOsPrintf ("**** Invalid table opcode [%X] ****\n",
434                 Table->Opcode);
435             return;
436         }
437 
438         Table++;
439         Count--;
440     }
441 }
442 
443 
444 /*******************************************************************************
445  *
446  * FUNCTION:    AcpiRsDumpResourceSource
447  *
448  * PARAMETERS:  ResourceSource      - Pointer to a Resource Source struct
449  *
450  * RETURN:      None
451  *
452  * DESCRIPTION: Common routine for dumping the optional ResourceSource and the
453  *              corresponding ResourceSourceIndex.
454  *
455  ******************************************************************************/
456 
457 static void
458 AcpiRsDumpResourceSource (
459     ACPI_RESOURCE_SOURCE    *ResourceSource)
460 {
461     ACPI_FUNCTION_ENTRY ();
462 
463 
464     if (ResourceSource->Index == 0xFF)
465     {
466         return;
467     }
468 
469     AcpiRsOutInteger8 ("Resource Source Index",
470         ResourceSource->Index);
471 
472     AcpiRsOutString ("Resource Source",
473         ResourceSource->StringPtr ?
474             ResourceSource->StringPtr : "[Not Specified]");
475 }
476 
477 
478 /*******************************************************************************
479  *
480  * FUNCTION:    AcpiRsDumpAddressCommon
481  *
482  * PARAMETERS:  Resource        - Pointer to an internal resource descriptor
483  *
484  * RETURN:      None
485  *
486  * DESCRIPTION: Dump the fields that are common to all Address resource
487  *              descriptors
488  *
489  ******************************************************************************/
490 
491 static void
492 AcpiRsDumpAddressCommon (
493     ACPI_RESOURCE_DATA      *Resource)
494 {
495     ACPI_FUNCTION_ENTRY ();
496 
497 
498    /* Decode the type-specific flags */
499 
500     switch (Resource->Address.ResourceType)
501     {
502     case ACPI_MEMORY_RANGE:
503 
504         AcpiRsDumpDescriptor (Resource, AcpiRsDumpMemoryFlags);
505         break;
506 
507     case ACPI_IO_RANGE:
508 
509         AcpiRsDumpDescriptor (Resource, AcpiRsDumpIoFlags);
510         break;
511 
512     case ACPI_BUS_NUMBER_RANGE:
513 
514         AcpiRsOutString ("Resource Type", "Bus Number Range");
515         break;
516 
517     default:
518 
519         AcpiRsOutInteger8 ("Resource Type",
520             (UINT8) Resource->Address.ResourceType);
521         break;
522     }
523 
524     /* Decode the general flags */
525 
526     AcpiRsDumpDescriptor (Resource, AcpiRsDumpGeneralFlags);
527 }
528 
529 
530 /*******************************************************************************
531  *
532  * FUNCTION:    AcpiRsOut*
533  *
534  * PARAMETERS:  Title       - Name of the resource field
535  *              Value       - Value of the resource field
536  *
537  * RETURN:      None
538  *
539  * DESCRIPTION: Miscellaneous helper functions to consistently format the
540  *              output of the resource dump routines
541  *
542  ******************************************************************************/
543 
544 static void
545 AcpiRsOutString (
546     char                    *Title,
547     char                    *Value)
548 {
549 
550     AcpiOsPrintf ("%27s : %s", Title, Value);
551     if (!*Value)
552     {
553         AcpiOsPrintf ("[NULL NAMESTRING]");
554     }
555     AcpiOsPrintf ("\n");
556 }
557 
558 static void
559 AcpiRsOutInteger8 (
560     char                    *Title,
561     UINT8                   Value)
562 {
563     AcpiOsPrintf ("%27s : %2.2X\n", Title, Value);
564 }
565 
566 static void
567 AcpiRsOutInteger16 (
568     char                    *Title,
569     UINT16                  Value)
570 {
571 
572     AcpiOsPrintf ("%27s : %4.4X\n", Title, Value);
573 }
574 
575 static void
576 AcpiRsOutInteger32 (
577     char                    *Title,
578     UINT32                  Value)
579 {
580 
581     AcpiOsPrintf ("%27s : %8.8X\n", Title, Value);
582 }
583 
584 static void
585 AcpiRsOutInteger64 (
586     char                    *Title,
587     UINT64                  Value)
588 {
589 
590     AcpiOsPrintf ("%27s : %8.8X%8.8X\n", Title,
591         ACPI_FORMAT_UINT64 (Value));
592 }
593 
594 static void
595 AcpiRsOutTitle (
596     char                    *Title)
597 {
598 
599     AcpiOsPrintf ("%27s : ", Title);
600 }
601 
602 
603 /*******************************************************************************
604  *
605  * FUNCTION:    AcpiRsDump*List
606  *
607  * PARAMETERS:  Length      - Number of elements in the list
608  *              Data        - Start of the list
609  *
610  * RETURN:      None
611  *
612  * DESCRIPTION: Miscellaneous functions to dump lists of raw data
613  *
614  ******************************************************************************/
615 
616 static void
617 AcpiRsDumpByteList (
618     UINT16                  Length,
619     UINT8                   *Data)
620 {
621     UINT8                   i;
622 
623 
624     for (i = 0; i < Length; i++)
625     {
626         AcpiOsPrintf ("%25s%2.2X : %2.2X\n", "Byte", i, Data[i]);
627     }
628 }
629 
630 static void
631 AcpiRsDumpShortByteList (
632     UINT8                   Length,
633     UINT8                   *Data)
634 {
635     UINT8                   i;
636 
637 
638     for (i = 0; i < Length; i++)
639     {
640         AcpiOsPrintf ("%X ", Data[i]);
641     }
642 
643     AcpiOsPrintf ("\n");
644 }
645 
646 static void
647 AcpiRsDumpDwordList (
648     UINT8                   Length,
649     UINT32                  *Data)
650 {
651     UINT8                   i;
652 
653 
654     for (i = 0; i < Length; i++)
655     {
656         AcpiOsPrintf ("%25s%2.2X : %8.8X\n", "Dword", i, Data[i]);
657     }
658 }
659 
660 static void
661 AcpiRsDumpWordList (
662     UINT16                  Length,
663     UINT16                  *Data)
664 {
665     UINT16                  i;
666 
667 
668     for (i = 0; i < Length; i++)
669     {
670         AcpiOsPrintf ("%25s%2.2X : %4.4X\n", "Word", i, Data[i]);
671     }
672 }
673 
674 #endif
675