rsdump.c revision 281687 
1/*******************************************************************************
2 *
3 * Module Name: rsdump - AML debugger support for resource structures.
4 *
5 ******************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2015, 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 <contrib/dev/acpica/include/acpi.h>
45#include <contrib/dev/acpica/include/accommon.h>
46#include <contrib/dev/acpica/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
58static void
59AcpiRsOutString (
60    char                    *Title,
61    char                    *Value);
62
63static void
64AcpiRsOutInteger8 (
65    char                    *Title,
66    UINT8                   Value);
67
68static void
69AcpiRsOutInteger16 (
70    char                    *Title,
71    UINT16                  Value);
72
73static void
74AcpiRsOutInteger32 (
75    char                    *Title,
76    UINT32                  Value);
77
78static void
79AcpiRsOutInteger64 (
80    char                    *Title,
81    UINT64                  Value);
82
83static void
84AcpiRsOutTitle (
85    char                    *Title);
86
87static void
88AcpiRsDumpByteList (
89    UINT16                  Length,
90    UINT8                   *Data);
91
92static void
93AcpiRsDumpWordList (
94    UINT16                  Length,
95    UINT16                  *Data);
96
97static void
98AcpiRsDumpDwordList (
99    UINT8                   Length,
100    UINT32                  *Data);
101
102static void
103AcpiRsDumpShortByteList (
104    UINT8                   Length,
105    UINT8                   *Data);
106
107static void
108AcpiRsDumpResourceSource (
109    ACPI_RESOURCE_SOURCE    *ResourceSource);
110
111static void
112AcpiRsDumpAddressCommon (
113    ACPI_RESOURCE_DATA      *Resource);
114
115static void
116AcpiRsDumpDescriptor (
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
133void
134AcpiRsDumpResourceList (
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
214void
215AcpiRsDumpIrqList (
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
260static void
261AcpiRsDumpDescriptor (
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
457static void
458AcpiRsDumpResourceSource (
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
491static void
492AcpiRsDumpAddressCommon (
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
544static void
545AcpiRsOutString (
546    char                    *Title,
547    char                    *Value)
548{
549    AcpiOsPrintf ("%27s : %s", Title, Value);
550    if (!*Value)
551    {
552        AcpiOsPrintf ("[NULL NAMESTRING]");
553    }
554    AcpiOsPrintf ("\n");
555}
556
557static void
558AcpiRsOutInteger8 (
559    char                    *Title,
560    UINT8                   Value)
561{
562    AcpiOsPrintf ("%27s : %2.2X\n", Title, Value);
563}
564
565static void
566AcpiRsOutInteger16 (
567    char                    *Title,
568    UINT16                  Value)
569{
570    AcpiOsPrintf ("%27s : %4.4X\n", Title, Value);
571}
572
573static void
574AcpiRsOutInteger32 (
575    char                    *Title,
576    UINT32                  Value)
577{
578    AcpiOsPrintf ("%27s : %8.8X\n", Title, Value);
579}
580
581static void
582AcpiRsOutInteger64 (
583    char                    *Title,
584    UINT64                  Value)
585{
586    AcpiOsPrintf ("%27s : %8.8X%8.8X\n", Title,
587        ACPI_FORMAT_UINT64 (Value));
588}
589
590static void
591AcpiRsOutTitle (
592    char                    *Title)
593{
594    AcpiOsPrintf ("%27s : ", Title);
595}
596
597
598/*******************************************************************************
599 *
600 * FUNCTION:    AcpiRsDump*List
601 *
602 * PARAMETERS:  Length      - Number of elements in the list
603 *              Data        - Start of the list
604 *
605 * RETURN:      None
606 *
607 * DESCRIPTION: Miscellaneous functions to dump lists of raw data
608 *
609 ******************************************************************************/
610
611static void
612AcpiRsDumpByteList (
613    UINT16                  Length,
614    UINT8                   *Data)
615{
616    UINT8                   i;
617
618
619    for (i = 0; i < Length; i++)
620    {
621        AcpiOsPrintf ("%25s%2.2X : %2.2X\n",
622            "Byte", i, Data[i]);
623    }
624}
625
626static void
627AcpiRsDumpShortByteList (
628    UINT8                   Length,
629    UINT8                   *Data)
630{
631    UINT8                   i;
632
633
634    for (i = 0; i < Length; i++)
635    {
636        AcpiOsPrintf ("%X ", Data[i]);
637    }
638    AcpiOsPrintf ("\n");
639}
640
641static void
642AcpiRsDumpDwordList (
643    UINT8                   Length,
644    UINT32                  *Data)
645{
646    UINT8                   i;
647
648
649    for (i = 0; i < Length; i++)
650    {
651        AcpiOsPrintf ("%25s%2.2X : %8.8X\n",
652            "Dword", i, Data[i]);
653    }
654}
655
656static void
657AcpiRsDumpWordList (
658    UINT16                  Length,
659    UINT16                  *Data)
660{
661    UINT16                  i;
662
663
664    for (i = 0; i < Length; i++)
665    {
666        AcpiOsPrintf ("%25s%2.2X : %4.4X\n",
667            "Word", i, Data[i]);
668    }
669}
670
671#endif
672