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