rsdump.c revision 151600 
1/*******************************************************************************
2 *
3 * Module Name: rsdump - Functions to display the resource structures.
4 *              $Revision: 38 $
5 *
6 ******************************************************************************/
7
8/******************************************************************************
9 *
10 * 1. Copyright Notice
11 *
12 * Some or all of this work - Copyright (c) 1999 - 2004, Intel Corp.
13 * All rights reserved.
14 *
15 * 2. License
16 *
17 * 2.1. This is your license from Intel Corp. under its intellectual property
18 * rights.  You may have additional license terms from the party that provided
19 * you this software, covering your right to use that party's intellectual
20 * property rights.
21 *
22 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
23 * copy of the source code appearing in this file ("Covered Code") an
24 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
25 * base code distributed originally by Intel ("Original Intel Code") to copy,
26 * make derivatives, distribute, use and display any portion of the Covered
27 * Code in any form, with the right to sublicense such rights; and
28 *
29 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
30 * license (with the right to sublicense), under only those claims of Intel
31 * patents that are infringed by the Original Intel Code, to make, use, sell,
32 * offer to sell, and import the Covered Code and derivative works thereof
33 * solely to the minimum extent necessary to exercise the above copyright
34 * license, and in no event shall the patent license extend to any additions
35 * to or modifications of the Original Intel Code.  No other license or right
36 * is granted directly or by implication, estoppel or otherwise;
37 *
38 * The above copyright and patent license is granted only if the following
39 * conditions are met:
40 *
41 * 3. Conditions
42 *
43 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
44 * Redistribution of source code of any substantial portion of the Covered
45 * Code or modification with rights to further distribute source must include
46 * the above Copyright Notice, the above License, this list of Conditions,
47 * and the following Disclaimer and Export Compliance provision.  In addition,
48 * Licensee must cause all Covered Code to which Licensee contributes to
49 * contain a file documenting the changes Licensee made to create that Covered
50 * Code and the date of any change.  Licensee must include in that file the
51 * documentation of any changes made by any predecessor Licensee.  Licensee
52 * must include a prominent statement that the modification is derived,
53 * directly or indirectly, from Original Intel Code.
54 *
55 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
56 * Redistribution of source code of any substantial portion of the Covered
57 * Code or modification without rights to further distribute source must
58 * include the following Disclaimer and Export Compliance provision in the
59 * documentation and/or other materials provided with distribution.  In
60 * addition, Licensee may not authorize further sublicense of source of any
61 * portion of the Covered Code, and must include terms to the effect that the
62 * license from Licensee to its licensee is limited to the intellectual
63 * property embodied in the software Licensee provides to its licensee, and
64 * not to intellectual property embodied in modifications its licensee may
65 * make.
66 *
67 * 3.3. Redistribution of Executable. Redistribution in executable form of any
68 * substantial portion of the Covered Code or modification must reproduce the
69 * above Copyright Notice, and the following Disclaimer and Export Compliance
70 * provision in the documentation and/or other materials provided with the
71 * distribution.
72 *
73 * 3.4. Intel retains all right, title, and interest in and to the Original
74 * Intel Code.
75 *
76 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
77 * Intel shall be used in advertising or otherwise to promote the sale, use or
78 * other dealings in products derived from or relating to the Covered Code
79 * without prior written authorization from Intel.
80 *
81 * 4. Disclaimer and Export Compliance
82 *
83 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
84 * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
85 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
86 * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
87 * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
88 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
89 * PARTICULAR PURPOSE.
90 *
91 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
92 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
93 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
94 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
95 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
96 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
97 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
98 * LIMITED REMEDY.
99 *
100 * 4.3. Licensee shall not export, either directly or indirectly, any of this
101 * software or system incorporating such software without first obtaining any
102 * required license or other approval from the U. S. Department of Commerce or
103 * any other agency or department of the United States Government.  In the
104 * event Licensee exports any such software from the United States or
105 * re-exports any such software from a foreign destination, Licensee shall
106 * ensure that the distribution and export/re-export of the software is in
107 * compliance with all laws, regulations, orders, or other restrictions of the
108 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
109 * any of its subsidiaries will export/re-export any technical data, process,
110 * software, or service, directly or indirectly, to any country for which the
111 * United States government or any agency thereof requires an export license,
112 * other governmental approval, or letter of assurance, without first obtaining
113 * such license, approval or letter.
114 *
115 *****************************************************************************/
116
117
118#define __RSDUMP_C__
119
120#include <contrib/dev/acpica/acpi.h>
121#include <contrib/dev/acpica/acresrc.h>
122
123#define _COMPONENT          ACPI_RESOURCES
124        ACPI_MODULE_NAME    ("rsdump")
125
126
127#if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
128
129/*******************************************************************************
130 *
131 * FUNCTION:    AcpiRsDumpIrq
132 *
133 * PARAMETERS:  Data            - pointer to the resource structure to dump.
134 *
135 * RETURN:      None
136 *
137 * DESCRIPTION: Prints out the various members of the Data structure type.
138 *
139 ******************************************************************************/
140
141void
142AcpiRsDumpIrq (
143    ACPI_RESOURCE_DATA      *Data)
144{
145    ACPI_RESOURCE_IRQ       *IrqData = (ACPI_RESOURCE_IRQ *) Data;
146    UINT8                   Index = 0;
147
148
149    ACPI_FUNCTION_ENTRY ();
150
151
152    AcpiOsPrintf ("IRQ Resource\n");
153
154    AcpiOsPrintf ("    %s Triggered\n",
155                ACPI_LEVEL_SENSITIVE == IrqData->EdgeLevel ? "Level" : "Edge");
156
157    AcpiOsPrintf ("    Active %s\n",
158                ACPI_ACTIVE_LOW == IrqData->ActiveHighLow ? "Low" : "High");
159
160    AcpiOsPrintf ("    %s\n",
161                ACPI_SHARED == IrqData->SharedExclusive ? "Shared" : "Exclusive");
162
163    AcpiOsPrintf ("    %X Interrupts ( ", IrqData->NumberOfInterrupts);
164
165    for (Index = 0; Index < IrqData->NumberOfInterrupts; Index++)
166    {
167        AcpiOsPrintf ("%X ", IrqData->Interrupts[Index]);
168    }
169
170    AcpiOsPrintf (")\n");
171    return;
172}
173
174
175/*******************************************************************************
176 *
177 * FUNCTION:    AcpiRsDumpDma
178 *
179 * PARAMETERS:  Data            - pointer to the resource structure to dump.
180 *
181 * RETURN:      None
182 *
183 * DESCRIPTION: Prints out the various members of the Data structure type.
184 *
185 ******************************************************************************/
186
187void
188AcpiRsDumpDma (
189    ACPI_RESOURCE_DATA      *Data)
190{
191    ACPI_RESOURCE_DMA       *DmaData = (ACPI_RESOURCE_DMA *) Data;
192    UINT8                   Index = 0;
193
194
195    ACPI_FUNCTION_ENTRY ();
196
197
198    AcpiOsPrintf ("DMA Resource\n");
199
200    switch (DmaData->Type)
201    {
202    case ACPI_COMPATIBILITY:
203        AcpiOsPrintf ("    Compatibility mode\n");
204        break;
205
206    case ACPI_TYPE_A:
207        AcpiOsPrintf ("    Type A\n");
208        break;
209
210    case ACPI_TYPE_B:
211        AcpiOsPrintf ("    Type B\n");
212        break;
213
214    case ACPI_TYPE_F:
215        AcpiOsPrintf ("    Type F\n");
216        break;
217
218    default:
219        AcpiOsPrintf ("    Invalid DMA type\n");
220        break;
221    }
222
223    AcpiOsPrintf ("    %sBus Master\n",
224                ACPI_BUS_MASTER == DmaData->BusMaster ? "" : "Not a ");
225
226
227    switch (DmaData->Transfer)
228    {
229    case ACPI_TRANSFER_8:
230        AcpiOsPrintf ("    8-bit only transfer\n");
231        break;
232
233    case ACPI_TRANSFER_8_16:
234        AcpiOsPrintf ("    8 and 16-bit transfer\n");
235        break;
236
237    case ACPI_TRANSFER_16:
238        AcpiOsPrintf ("    16 bit only transfer\n");
239        break;
240
241    default:
242        AcpiOsPrintf ("    Invalid transfer preference\n");
243        break;
244    }
245
246    AcpiOsPrintf ("    Number of Channels: %X ( ", DmaData->NumberOfChannels);
247
248    for (Index = 0; Index < DmaData->NumberOfChannels; Index++)
249    {
250        AcpiOsPrintf ("%X ", DmaData->Channels[Index]);
251    }
252
253    AcpiOsPrintf (")\n");
254    return;
255}
256
257
258/*******************************************************************************
259 *
260 * FUNCTION:    AcpiRsDumpStartDependFns
261 *
262 * PARAMETERS:  Data            - pointer to the resource structure to dump.
263 *
264 * RETURN:      None
265 *
266 * DESCRIPTION: Prints out the various members of the Data structure type.
267 *
268 ******************************************************************************/
269
270void
271AcpiRsDumpStartDependFns (
272    ACPI_RESOURCE_DATA      *Data)
273{
274    ACPI_RESOURCE_START_DPF *SdfData = (ACPI_RESOURCE_START_DPF *) Data;
275
276
277    ACPI_FUNCTION_ENTRY ();
278
279
280    AcpiOsPrintf ("Start Dependent Functions Resource\n");
281
282    switch (SdfData->CompatibilityPriority)
283    {
284    case ACPI_GOOD_CONFIGURATION:
285        AcpiOsPrintf ("    Good configuration\n");
286        break;
287
288    case ACPI_ACCEPTABLE_CONFIGURATION:
289        AcpiOsPrintf ("    Acceptable configuration\n");
290        break;
291
292    case ACPI_SUB_OPTIMAL_CONFIGURATION:
293        AcpiOsPrintf ("    Sub-optimal configuration\n");
294        break;
295
296    default:
297        AcpiOsPrintf ("    Invalid compatibility priority\n");
298        break;
299    }
300
301    switch(SdfData->PerformanceRobustness)
302    {
303    case ACPI_GOOD_CONFIGURATION:
304        AcpiOsPrintf ("    Good configuration\n");
305        break;
306
307    case ACPI_ACCEPTABLE_CONFIGURATION:
308        AcpiOsPrintf ("    Acceptable configuration\n");
309        break;
310
311    case ACPI_SUB_OPTIMAL_CONFIGURATION:
312        AcpiOsPrintf ("    Sub-optimal configuration\n");
313        break;
314
315    default:
316        AcpiOsPrintf ("    Invalid performance "
317                        "robustness preference\n");
318        break;
319    }
320
321    return;
322}
323
324
325/*******************************************************************************
326 *
327 * FUNCTION:    AcpiRsDumpIo
328 *
329 * PARAMETERS:  Data            - pointer to the resource structure to dump.
330 *
331 * RETURN:      None
332 *
333 * DESCRIPTION: Prints out the various members of the Data structure type.
334 *
335 ******************************************************************************/
336
337void
338AcpiRsDumpIo (
339    ACPI_RESOURCE_DATA      *Data)
340{
341    ACPI_RESOURCE_IO        *IoData = (ACPI_RESOURCE_IO *) Data;
342
343
344    ACPI_FUNCTION_ENTRY ();
345
346
347    AcpiOsPrintf ("Io Resource\n");
348
349    AcpiOsPrintf ("    %d bit decode\n",
350                ACPI_DECODE_16 == IoData->IoDecode ? 16 : 10);
351
352    AcpiOsPrintf ("    Range minimum base: %08X\n",
353                IoData->MinBaseAddress);
354
355    AcpiOsPrintf ("    Range maximum base: %08X\n",
356                IoData->MaxBaseAddress);
357
358    AcpiOsPrintf ("    Alignment: %08X\n",
359                IoData->Alignment);
360
361    AcpiOsPrintf ("    Range Length: %08X\n",
362                IoData->RangeLength);
363
364    return;
365}
366
367
368/*******************************************************************************
369 *
370 * FUNCTION:    AcpiRsDumpFixedIo
371 *
372 * PARAMETERS:  Data            - pointer to the resource structure to dump.
373 *
374 * RETURN:      None
375 *
376 * DESCRIPTION: Prints out the various members of the Data structure type.
377 *
378 ******************************************************************************/
379
380void
381AcpiRsDumpFixedIo (
382    ACPI_RESOURCE_DATA      *Data)
383{
384    ACPI_RESOURCE_FIXED_IO  *FixedIoData = (ACPI_RESOURCE_FIXED_IO *) Data;
385
386
387    ACPI_FUNCTION_ENTRY ();
388
389
390    AcpiOsPrintf ("Fixed Io Resource\n");
391    AcpiOsPrintf ("    Range base address: %08X",
392                FixedIoData->BaseAddress);
393
394    AcpiOsPrintf ("    Range length: %08X",
395                FixedIoData->RangeLength);
396
397    return;
398}
399
400
401/*******************************************************************************
402 *
403 * FUNCTION:    AcpiRsDumpVendorSpecific
404 *
405 * PARAMETERS:  Data            - pointer to the resource structure to dump.
406 *
407 * RETURN:      None
408 *
409 * DESCRIPTION: Prints out the various members of the Data structure type.
410 *
411 ******************************************************************************/
412
413void
414AcpiRsDumpVendorSpecific (
415    ACPI_RESOURCE_DATA      *Data)
416{
417    ACPI_RESOURCE_VENDOR    *VendorData = (ACPI_RESOURCE_VENDOR *) Data;
418    UINT16                  Index = 0;
419
420
421    ACPI_FUNCTION_ENTRY ();
422
423
424    AcpiOsPrintf ("Vendor Specific Resource\n");
425
426    AcpiOsPrintf ("    Length: %08X\n", VendorData->Length);
427
428    for (Index = 0; Index < VendorData->Length; Index++)
429    {
430        AcpiOsPrintf ("    Byte %X: %08X\n",
431                    Index, VendorData->Reserved[Index]);
432    }
433
434    return;
435}
436
437
438/*******************************************************************************
439 *
440 * FUNCTION:    AcpiRsDumpMemory24
441 *
442 * PARAMETERS:  Data            - pointer to the resource structure to dump.
443 *
444 * RETURN:      None
445 *
446 * DESCRIPTION: Prints out the various members of the Data structure type.
447 *
448 ******************************************************************************/
449
450void
451AcpiRsDumpMemory24 (
452    ACPI_RESOURCE_DATA      *Data)
453{
454    ACPI_RESOURCE_MEM24     *Memory24Data = (ACPI_RESOURCE_MEM24 *) Data;
455
456
457    ACPI_FUNCTION_ENTRY ();
458
459
460    AcpiOsPrintf ("24-Bit Memory Range Resource\n");
461
462    AcpiOsPrintf ("    Read%s\n",
463                ACPI_READ_WRITE_MEMORY ==
464                Memory24Data->ReadWriteAttribute ?
465                "/Write" : " only");
466
467    AcpiOsPrintf ("    Range minimum base: %08X\n",
468                Memory24Data->MinBaseAddress);
469
470    AcpiOsPrintf ("    Range maximum base: %08X\n",
471                Memory24Data->MaxBaseAddress);
472
473    AcpiOsPrintf ("    Alignment: %08X\n",
474                Memory24Data->Alignment);
475
476    AcpiOsPrintf ("    Range length: %08X\n",
477                Memory24Data->RangeLength);
478
479    return;
480}
481
482
483/*******************************************************************************
484 *
485 * FUNCTION:    AcpiRsDumpMemory32
486 *
487 * PARAMETERS:  Data            - pointer to the resource structure to dump.
488 *
489 * RETURN:      None
490 *
491 * DESCRIPTION: Prints out the various members of the Data structure type.
492 *
493 ******************************************************************************/
494
495void
496AcpiRsDumpMemory32 (
497    ACPI_RESOURCE_DATA      *Data)
498{
499    ACPI_RESOURCE_MEM32     *Memory32Data = (ACPI_RESOURCE_MEM32 *) Data;
500
501
502    ACPI_FUNCTION_ENTRY ();
503
504
505    AcpiOsPrintf ("32-Bit Memory Range Resource\n");
506
507    AcpiOsPrintf ("    Read%s\n",
508                ACPI_READ_WRITE_MEMORY ==
509                Memory32Data->ReadWriteAttribute ?
510                "/Write" : " only");
511
512    AcpiOsPrintf ("    Range minimum base: %08X\n",
513                Memory32Data->MinBaseAddress);
514
515    AcpiOsPrintf ("    Range maximum base: %08X\n",
516                Memory32Data->MaxBaseAddress);
517
518    AcpiOsPrintf ("    Alignment: %08X\n",
519                Memory32Data->Alignment);
520
521    AcpiOsPrintf ("    Range length: %08X\n",
522                Memory32Data->RangeLength);
523
524    return;
525}
526
527
528/*******************************************************************************
529 *
530 * FUNCTION:    AcpiRsDumpFixedMemory32
531 *
532 * PARAMETERS:  Data            - pointer to the resource structure to dump.
533 *
534 * RETURN:
535 *
536 * DESCRIPTION: Prints out the various members of the Data structure type.
537 *
538 ******************************************************************************/
539
540void
541AcpiRsDumpFixedMemory32 (
542    ACPI_RESOURCE_DATA          *Data)
543{
544    ACPI_RESOURCE_FIXED_MEM32   *FixedMemory32Data = (ACPI_RESOURCE_FIXED_MEM32 *) Data;
545
546
547    ACPI_FUNCTION_ENTRY ();
548
549
550    AcpiOsPrintf ("32-Bit Fixed Location Memory Range Resource\n");
551
552    AcpiOsPrintf ("    Read%s\n",
553                ACPI_READ_WRITE_MEMORY ==
554                FixedMemory32Data->ReadWriteAttribute ?
555                "/Write" : " Only");
556
557    AcpiOsPrintf ("    Range base address: %08X\n",
558                FixedMemory32Data->RangeBaseAddress);
559
560    AcpiOsPrintf ("    Range length: %08X\n",
561                FixedMemory32Data->RangeLength);
562
563    return;
564}
565
566
567/*******************************************************************************
568 *
569 * FUNCTION:    AcpiRsDumpAddress16
570 *
571 * PARAMETERS:  Data            - pointer to the resource structure to dump.
572 *
573 * RETURN:      None
574 *
575 * DESCRIPTION: Prints out the various members of the Data structure type.
576 *
577 ******************************************************************************/
578
579void
580AcpiRsDumpAddress16 (
581    ACPI_RESOURCE_DATA      *Data)
582{
583    ACPI_RESOURCE_ADDRESS16 *Address16Data = (ACPI_RESOURCE_ADDRESS16 *) Data;
584
585
586    ACPI_FUNCTION_ENTRY ();
587
588
589    AcpiOsPrintf ("16-Bit Address Space Resource\n");
590    AcpiOsPrintf ("    Resource Type: ");
591
592    switch (Address16Data->ResourceType)
593    {
594    case ACPI_MEMORY_RANGE:
595
596        AcpiOsPrintf ("Memory Range\n");
597
598        switch (Address16Data->Attribute.Memory.CacheAttribute)
599        {
600        case ACPI_NON_CACHEABLE_MEMORY:
601            AcpiOsPrintf ("    Type Specific: "
602                            "Noncacheable memory\n");
603            break;
604
605        case ACPI_CACHABLE_MEMORY:
606            AcpiOsPrintf ("    Type Specific: "
607                            "Cacheable memory\n");
608            break;
609
610        case ACPI_WRITE_COMBINING_MEMORY:
611            AcpiOsPrintf ("    Type Specific: "
612                            "Write-combining memory\n");
613            break;
614
615        case ACPI_PREFETCHABLE_MEMORY:
616            AcpiOsPrintf ("    Type Specific: "
617                            "Prefetchable memory\n");
618            break;
619
620        default:
621            AcpiOsPrintf ("    Type Specific: "
622                            "Invalid cache attribute\n");
623            break;
624        }
625
626        AcpiOsPrintf ("    Type Specific: Read%s\n",
627            ACPI_READ_WRITE_MEMORY ==
628            Address16Data->Attribute.Memory.ReadWriteAttribute ?
629            "/Write" : " Only");
630        break;
631
632    case ACPI_IO_RANGE:
633
634        AcpiOsPrintf ("I/O Range\n");
635
636        switch (Address16Data->Attribute.Io.RangeAttribute)
637        {
638        case ACPI_NON_ISA_ONLY_RANGES:
639            AcpiOsPrintf ("    Type Specific: "
640                            "Non-ISA Io Addresses\n");
641            break;
642
643        case ACPI_ISA_ONLY_RANGES:
644            AcpiOsPrintf ("    Type Specific: "
645                            "ISA Io Addresses\n");
646            break;
647
648        case ACPI_ENTIRE_RANGE:
649            AcpiOsPrintf ("    Type Specific: "
650                            "ISA and non-ISA Io Addresses\n");
651            break;
652
653        default:
654            AcpiOsPrintf ("    Type Specific: "
655                            "Invalid range attribute\n");
656            break;
657        }
658
659        AcpiOsPrintf ("  Type Specific: %s Translation\n",
660            ACPI_SPARSE_TRANSLATION ==
661            Address16Data->Attribute.Io.TranslationAttribute ?
662            "Sparse" : "Dense");
663        break;
664
665    case ACPI_BUS_NUMBER_RANGE:
666
667        AcpiOsPrintf ("Bus Number Range\n");
668        break;
669
670    default:
671
672        AcpiOsPrintf ("Invalid resource type. Exiting.\n");
673        return;
674    }
675
676    AcpiOsPrintf ("    Resource %s\n",
677            ACPI_CONSUMER == Address16Data->ProducerConsumer ?
678            "Consumer" : "Producer");
679
680    AcpiOsPrintf ("    %s decode\n",
681                ACPI_SUB_DECODE == Address16Data->Decode ?
682                "Subtractive" : "Positive");
683
684    AcpiOsPrintf ("    Min address is %s fixed\n",
685                ACPI_ADDRESS_FIXED == Address16Data->MinAddressFixed ?
686                "" : "not");
687
688    AcpiOsPrintf ("    Max address is %s fixed\n",
689                ACPI_ADDRESS_FIXED == Address16Data->MaxAddressFixed ?
690                "" : "not");
691
692    AcpiOsPrintf ("    Granularity: %08X\n",
693                Address16Data->Granularity);
694
695    AcpiOsPrintf ("    Address range min: %08X\n",
696                Address16Data->MinAddressRange);
697
698    AcpiOsPrintf ("    Address range max: %08X\n",
699                Address16Data->MaxAddressRange);
700
701    AcpiOsPrintf ("    Address translation offset: %08X\n",
702                Address16Data->AddressTranslationOffset);
703
704    AcpiOsPrintf ("    Address Length: %08X\n",
705                Address16Data->AddressLength);
706
707    if (0xFF != Address16Data->ResourceSource.Index)
708    {
709        AcpiOsPrintf ("    Resource Source Index: %X\n",
710                    Address16Data->ResourceSource.Index);
711        AcpiOsPrintf ("    Resource Source: %s\n",
712                    Address16Data->ResourceSource.StringPtr);
713    }
714
715    return;
716}
717
718
719/*******************************************************************************
720 *
721 * FUNCTION:    AcpiRsDumpAddress32
722 *
723 * PARAMETERS:  Data            - pointer to the resource structure to dump.
724 *
725 * RETURN:      None
726 *
727 * DESCRIPTION: Prints out the various members of the Data structure type.
728 *
729 ******************************************************************************/
730
731void
732AcpiRsDumpAddress32 (
733    ACPI_RESOURCE_DATA      *Data)
734{
735    ACPI_RESOURCE_ADDRESS32 *Address32Data = (ACPI_RESOURCE_ADDRESS32 *) Data;
736
737
738    ACPI_FUNCTION_ENTRY ();
739
740
741    AcpiOsPrintf ("32-Bit Address Space Resource\n");
742
743    switch (Address32Data->ResourceType)
744    {
745    case ACPI_MEMORY_RANGE:
746
747        AcpiOsPrintf ("    Resource Type: Memory Range\n");
748
749        switch (Address32Data->Attribute.Memory.CacheAttribute)
750        {
751        case ACPI_NON_CACHEABLE_MEMORY:
752            AcpiOsPrintf ("    Type Specific: "
753                            "Noncacheable memory\n");
754            break;
755
756        case ACPI_CACHABLE_MEMORY:
757            AcpiOsPrintf ("    Type Specific: "
758                            "Cacheable memory\n");
759            break;
760
761        case ACPI_WRITE_COMBINING_MEMORY:
762            AcpiOsPrintf ("    Type Specific: "
763                            "Write-combining memory\n");
764            break;
765
766        case ACPI_PREFETCHABLE_MEMORY:
767            AcpiOsPrintf ("    Type Specific: "
768                            "Prefetchable memory\n");
769            break;
770
771        default:
772            AcpiOsPrintf ("    Type Specific: "
773                            "Invalid cache attribute\n");
774            break;
775        }
776
777        AcpiOsPrintf ("    Type Specific: Read%s\n",
778            ACPI_READ_WRITE_MEMORY ==
779            Address32Data->Attribute.Memory.ReadWriteAttribute ?
780            "/Write" : " Only");
781        break;
782
783    case ACPI_IO_RANGE:
784
785        AcpiOsPrintf ("    Resource Type: Io Range\n");
786
787        switch (Address32Data->Attribute.Io.RangeAttribute)
788        {
789        case ACPI_NON_ISA_ONLY_RANGES:
790            AcpiOsPrintf ("    Type Specific: "
791                            "Non-ISA Io Addresses\n");
792            break;
793
794        case ACPI_ISA_ONLY_RANGES:
795            AcpiOsPrintf ("    Type Specific: "
796                            "ISA Io Addresses\n");
797            break;
798
799        case ACPI_ENTIRE_RANGE:
800            AcpiOsPrintf ("    Type Specific: "
801                            "ISA and non-ISA Io Addresses\n");
802            break;
803
804        default:
805            AcpiOsPrintf ("    Type Specific: "
806                            "Invalid Range attribute");
807            break;
808        }
809
810        AcpiOsPrintf ("  Type Specific: %s Translation\n",
811            ACPI_SPARSE_TRANSLATION ==
812            Address32Data->Attribute.Io.TranslationAttribute ?
813            "Sparse" : "Dense");
814        break;
815
816    case ACPI_BUS_NUMBER_RANGE:
817
818        AcpiOsPrintf ("    Resource Type: Bus Number Range\n");
819        break;
820
821    default:
822
823        AcpiOsPrintf ("    Invalid Resource Type..exiting.\n");
824        return;
825    }
826
827    AcpiOsPrintf ("    Resource %s\n",
828                ACPI_CONSUMER == Address32Data->ProducerConsumer ?
829                "Consumer" : "Producer");
830
831    AcpiOsPrintf ("    %s decode\n",
832                ACPI_SUB_DECODE == Address32Data->Decode ?
833                "Subtractive" : "Positive");
834
835    AcpiOsPrintf ("    Min address is %s fixed\n",
836                ACPI_ADDRESS_FIXED == Address32Data->MinAddressFixed ?
837                "" : "not ");
838
839    AcpiOsPrintf ("    Max address is %s fixed\n",
840                ACPI_ADDRESS_FIXED == Address32Data->MaxAddressFixed ?
841                "" : "not ");
842
843    AcpiOsPrintf ("    Granularity: %08X\n",
844                Address32Data->Granularity);
845
846    AcpiOsPrintf ("    Address range min: %08X\n",
847                Address32Data->MinAddressRange);
848
849    AcpiOsPrintf ("    Address range max: %08X\n",
850                Address32Data->MaxAddressRange);
851
852    AcpiOsPrintf ("    Address translation offset: %08X\n",
853                Address32Data->AddressTranslationOffset);
854
855    AcpiOsPrintf ("    Address Length: %08X\n",
856                Address32Data->AddressLength);
857
858    if(0xFF != Address32Data->ResourceSource.Index)
859    {
860        AcpiOsPrintf ("    Resource Source Index: %X\n",
861                    Address32Data->ResourceSource.Index);
862        AcpiOsPrintf ("    Resource Source: %s\n",
863                    Address32Data->ResourceSource.StringPtr);
864    }
865
866    return;
867}
868
869
870/*******************************************************************************
871 *
872 * FUNCTION:    AcpiRsDumpAddress64
873 *
874 * PARAMETERS:  Data            - pointer to the resource structure to dump.
875 *
876 * RETURN:      None
877 *
878 * DESCRIPTION: Prints out the various members of the Data structure type.
879 *
880 ******************************************************************************/
881
882void
883AcpiRsDumpAddress64 (
884    ACPI_RESOURCE_DATA      *Data)
885{
886    ACPI_RESOURCE_ADDRESS64 *Address64Data = (ACPI_RESOURCE_ADDRESS64 *) Data;
887
888
889    ACPI_FUNCTION_ENTRY ();
890
891
892    AcpiOsPrintf ("64-Bit Address Space Resource\n");
893
894    switch (Address64Data->ResourceType)
895    {
896    case ACPI_MEMORY_RANGE:
897
898        AcpiOsPrintf ("    Resource Type: Memory Range\n");
899
900        switch (Address64Data->Attribute.Memory.CacheAttribute)
901        {
902        case ACPI_NON_CACHEABLE_MEMORY:
903            AcpiOsPrintf ("    Type Specific: "
904                            "Noncacheable memory\n");
905            break;
906
907        case ACPI_CACHABLE_MEMORY:
908            AcpiOsPrintf ("    Type Specific: "
909                            "Cacheable memory\n");
910            break;
911
912        case ACPI_WRITE_COMBINING_MEMORY:
913            AcpiOsPrintf ("    Type Specific: "
914                            "Write-combining memory\n");
915            break;
916
917        case ACPI_PREFETCHABLE_MEMORY:
918            AcpiOsPrintf ("    Type Specific: "
919                            "Prefetchable memory\n");
920            break;
921
922        default:
923            AcpiOsPrintf ("    Type Specific: "
924                            "Invalid cache attribute\n");
925            break;
926        }
927
928        AcpiOsPrintf ("    Type Specific: Read%s\n",
929            ACPI_READ_WRITE_MEMORY ==
930            Address64Data->Attribute.Memory.ReadWriteAttribute ?
931            "/Write" : " Only");
932        break;
933
934    case ACPI_IO_RANGE:
935
936        AcpiOsPrintf ("    Resource Type: Io Range\n");
937
938        switch (Address64Data->Attribute.Io.RangeAttribute)
939        {
940        case ACPI_NON_ISA_ONLY_RANGES:
941            AcpiOsPrintf ("    Type Specific: "
942                            "Non-ISA Io Addresses\n");
943            break;
944
945        case ACPI_ISA_ONLY_RANGES:
946            AcpiOsPrintf ("    Type Specific: "
947                            "ISA Io Addresses\n");
948            break;
949
950        case ACPI_ENTIRE_RANGE:
951            AcpiOsPrintf ("    Type Specific: "
952                            "ISA and non-ISA Io Addresses\n");
953            break;
954
955        default:
956            AcpiOsPrintf ("    Type Specific: "
957                            "Invalid Range attribute");
958            break;
959        }
960
961        AcpiOsPrintf ("  Type Specific: %s Translation\n",
962            ACPI_SPARSE_TRANSLATION ==
963            Address64Data->Attribute.Io.TranslationAttribute ?
964            "Sparse" : "Dense");
965        break;
966
967    case ACPI_BUS_NUMBER_RANGE:
968
969        AcpiOsPrintf ("    Resource Type: Bus Number Range\n");
970        break;
971
972    default:
973
974        AcpiOsPrintf ("    Invalid Resource Type..exiting.\n");
975        return;
976    }
977
978    AcpiOsPrintf ("    Resource %s\n",
979                ACPI_CONSUMER == Address64Data->ProducerConsumer ?
980                "Consumer" : "Producer");
981
982    AcpiOsPrintf ("    %s decode\n",
983                ACPI_SUB_DECODE == Address64Data->Decode ?
984                "Subtractive" : "Positive");
985
986    AcpiOsPrintf ("    Min address is %s fixed\n",
987                ACPI_ADDRESS_FIXED == Address64Data->MinAddressFixed ?
988                "" : "not ");
989
990    AcpiOsPrintf ("    Max address is %s fixed\n",
991                ACPI_ADDRESS_FIXED == Address64Data->MaxAddressFixed ?
992                "" : "not ");
993
994    AcpiOsPrintf ("    Granularity: %8.8X%8.8X\n",
995                ACPI_FORMAT_UINT64 (Address64Data->Granularity));
996
997    AcpiOsPrintf ("    Address range min: %8.8X%8.8X\n",
998                ACPI_FORMAT_UINT64 (Address64Data->MinAddressRange));
999
1000    AcpiOsPrintf ("    Address range max: %8.8X%8.8X\n",
1001                ACPI_FORMAT_UINT64 (Address64Data->MaxAddressRange));
1002
1003    AcpiOsPrintf ("    Address translation offset: %8.8X%8.8X\n",
1004                ACPI_FORMAT_UINT64 (Address64Data->AddressTranslationOffset));
1005
1006    AcpiOsPrintf ("    Address Length: %8.8X%8.8X\n",
1007                ACPI_FORMAT_UINT64 (Address64Data->AddressLength));
1008
1009    if(0xFF != Address64Data->ResourceSource.Index)
1010    {
1011        AcpiOsPrintf ("    Resource Source Index: %X\n",
1012                    Address64Data->ResourceSource.Index);
1013        AcpiOsPrintf ("    Resource Source: %s\n",
1014                    Address64Data->ResourceSource.StringPtr);
1015    }
1016
1017    return;
1018}
1019
1020
1021/*******************************************************************************
1022 *
1023 * FUNCTION:    AcpiRsDumpExtendedIrq
1024 *
1025 * PARAMETERS:  Data            - pointer to the resource structure to dump.
1026 *
1027 * RETURN:      None
1028 *
1029 * DESCRIPTION: Prints out the various members of the Data structure type.
1030 *
1031 ******************************************************************************/
1032
1033void
1034AcpiRsDumpExtendedIrq (
1035    ACPI_RESOURCE_DATA      *Data)
1036{
1037    ACPI_RESOURCE_EXT_IRQ   *ExtIrqData = (ACPI_RESOURCE_EXT_IRQ *) Data;
1038    UINT8                   Index = 0;
1039
1040
1041    ACPI_FUNCTION_ENTRY ();
1042
1043
1044    AcpiOsPrintf ("Extended IRQ Resource\n");
1045
1046    AcpiOsPrintf ("    Resource %s\n",
1047                ACPI_CONSUMER == ExtIrqData->ProducerConsumer ?
1048                "Consumer" : "Producer");
1049
1050    AcpiOsPrintf ("    %s\n",
1051                ACPI_LEVEL_SENSITIVE == ExtIrqData->EdgeLevel ?
1052                "Level" : "Edge");
1053
1054    AcpiOsPrintf ("    Active %s\n",
1055                ACPI_ACTIVE_LOW == ExtIrqData->ActiveHighLow ?
1056                "low" : "high");
1057
1058    AcpiOsPrintf ("    %s\n",
1059                ACPI_SHARED == ExtIrqData->SharedExclusive ?
1060                "Shared" : "Exclusive");
1061
1062    AcpiOsPrintf ("    Interrupts : %X ( ",
1063                ExtIrqData->NumberOfInterrupts);
1064
1065    for (Index = 0; Index < ExtIrqData->NumberOfInterrupts; Index++)
1066    {
1067        AcpiOsPrintf ("%X ", ExtIrqData->Interrupts[Index]);
1068    }
1069
1070    AcpiOsPrintf (")\n");
1071
1072    if(0xFF != ExtIrqData->ResourceSource.Index)
1073    {
1074        AcpiOsPrintf ("    Resource Source Index: %X",
1075                    ExtIrqData->ResourceSource.Index);
1076        AcpiOsPrintf ("    Resource Source: %s",
1077                    ExtIrqData->ResourceSource.StringPtr);
1078    }
1079
1080    return;
1081}
1082
1083
1084/*******************************************************************************
1085 *
1086 * FUNCTION:    AcpiRsDumpResourceList
1087 *
1088 * PARAMETERS:  Data            - pointer to the resource structure to dump.
1089 *
1090 * RETURN:      None
1091 *
1092 * DESCRIPTION: Dispatches the structure to the correct dump routine.
1093 *
1094 ******************************************************************************/
1095
1096void
1097AcpiRsDumpResourceList (
1098    ACPI_RESOURCE       *Resource)
1099{
1100    UINT8               Count = 0;
1101    BOOLEAN             Done = FALSE;
1102
1103
1104    ACPI_FUNCTION_ENTRY ();
1105
1106
1107    if (AcpiDbgLevel & ACPI_LV_RESOURCES && _COMPONENT & AcpiDbgLayer)
1108    {
1109        while (!Done)
1110        {
1111            AcpiOsPrintf ("Resource structure %X.\n", Count++);
1112
1113            switch (Resource->Id)
1114            {
1115            case ACPI_RSTYPE_IRQ:
1116                AcpiRsDumpIrq (&Resource->Data);
1117                break;
1118
1119            case ACPI_RSTYPE_DMA:
1120                AcpiRsDumpDma (&Resource->Data);
1121                break;
1122
1123            case ACPI_RSTYPE_START_DPF:
1124                AcpiRsDumpStartDependFns (&Resource->Data);
1125                break;
1126
1127            case ACPI_RSTYPE_END_DPF:
1128                AcpiOsPrintf ("EndDependentFunctions Resource\n");
1129                /* AcpiRsDumpEndDependentFunctions (Resource->Data);*/
1130                break;
1131
1132            case ACPI_RSTYPE_IO:
1133                AcpiRsDumpIo (&Resource->Data);
1134                break;
1135
1136            case ACPI_RSTYPE_FIXED_IO:
1137                AcpiRsDumpFixedIo (&Resource->Data);
1138                break;
1139
1140            case ACPI_RSTYPE_VENDOR:
1141                AcpiRsDumpVendorSpecific (&Resource->Data);
1142                break;
1143
1144            case ACPI_RSTYPE_END_TAG:
1145                /*RsDumpEndTag (Resource->Data);*/
1146                AcpiOsPrintf ("EndTag Resource\n");
1147                Done = TRUE;
1148                break;
1149
1150            case ACPI_RSTYPE_MEM24:
1151                AcpiRsDumpMemory24 (&Resource->Data);
1152                break;
1153
1154            case ACPI_RSTYPE_MEM32:
1155                AcpiRsDumpMemory32 (&Resource->Data);
1156                break;
1157
1158            case ACPI_RSTYPE_FIXED_MEM32:
1159                AcpiRsDumpFixedMemory32 (&Resource->Data);
1160                break;
1161
1162            case ACPI_RSTYPE_ADDRESS16:
1163                AcpiRsDumpAddress16 (&Resource->Data);
1164                break;
1165
1166            case ACPI_RSTYPE_ADDRESS32:
1167                AcpiRsDumpAddress32 (&Resource->Data);
1168                break;
1169
1170            case ACPI_RSTYPE_ADDRESS64:
1171                AcpiRsDumpAddress64 (&Resource->Data);
1172                break;
1173
1174            case ACPI_RSTYPE_EXT_IRQ:
1175                AcpiRsDumpExtendedIrq (&Resource->Data);
1176                break;
1177
1178            default:
1179                AcpiOsPrintf ("Invalid resource type\n");
1180                break;
1181
1182            }
1183
1184            Resource = ACPI_PTR_ADD (ACPI_RESOURCE, Resource, Resource->Length);
1185        }
1186    }
1187
1188    return;
1189}
1190
1191/*******************************************************************************
1192 *
1193 * FUNCTION:    AcpiRsDumpIrqList
1194 *
1195 * PARAMETERS:  Data            - pointer to the routing table to dump.
1196 *
1197 * RETURN:      None
1198 *
1199 * DESCRIPTION: Dispatches the structures to the correct dump routine.
1200 *
1201 ******************************************************************************/
1202
1203void
1204AcpiRsDumpIrqList (
1205    UINT8                   *RouteTable)
1206{
1207    UINT8                   *Buffer = RouteTable;
1208    UINT8                   Count = 0;
1209    BOOLEAN                 Done = FALSE;
1210    ACPI_PCI_ROUTING_TABLE  *PrtElement;
1211
1212
1213    ACPI_FUNCTION_ENTRY ();
1214
1215
1216    if (AcpiDbgLevel & ACPI_LV_RESOURCES && _COMPONENT & AcpiDbgLayer)
1217    {
1218        PrtElement = ACPI_CAST_PTR (ACPI_PCI_ROUTING_TABLE, Buffer);
1219
1220        while (!Done)
1221        {
1222            AcpiOsPrintf ("PCI IRQ Routing Table structure %X.\n", Count++);
1223
1224            AcpiOsPrintf ("    Address: %8.8X%8.8X\n",
1225                        ACPI_FORMAT_UINT64 (PrtElement->Address));
1226
1227            AcpiOsPrintf ("    Pin: %X\n", PrtElement->Pin);
1228
1229            AcpiOsPrintf ("    Source: %s\n", PrtElement->Source);
1230
1231            AcpiOsPrintf ("    SourceIndex: %X\n",
1232                        PrtElement->SourceIndex);
1233
1234            Buffer += PrtElement->Length;
1235
1236            PrtElement = ACPI_CAST_PTR (ACPI_PCI_ROUTING_TABLE, Buffer);
1237
1238            if(0 == PrtElement->Length)
1239            {
1240                Done = TRUE;
1241            }
1242        }
1243    }
1244
1245    return;
1246}
1247
1248#endif
1249
1250