Some laptops return other values for working toucpads. Allow test_aux_port to
[dragonfly.git] / sys / contrib / dev / acpica-unix-20031203 / resources / rsdump.c
1 /*******************************************************************************
2  *
3  * Module Name: rsdump - Functions to display the resource structures.
4  *              $Revision: 37 $
5  *
6  ******************************************************************************/
7
8 /******************************************************************************
9  *
10  * 1. Copyright Notice
11  *
12  * Some or all of this work - Copyright (c) 1999 - 2003, 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 "acpi.h"
121 #include "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
141 void
142 AcpiRsDumpIrq (
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
187 void
188 AcpiRsDumpDma (
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
270 void
271 AcpiRsDumpStartDependFns (
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
337 void
338 AcpiRsDumpIo (
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
380 void
381 AcpiRsDumpFixedIo (
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
413 void
414 AcpiRsDumpVendorSpecific (
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
450 void
451 AcpiRsDumpMemory24 (
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
495 void
496 AcpiRsDumpMemory32 (
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
540 void
541 AcpiRsDumpFixedMemory32 (
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
579 void
580 AcpiRsDumpAddress16 (
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
731 void
732 AcpiRsDumpAddress32 (
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
882 void
883 AcpiRsDumpAddress64 (
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
1033 void
1034 AcpiRsDumpExtendedIrq (
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
1096 void
1097 AcpiRsDumpResourceList (
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
1203 void
1204 AcpiRsDumpIrqList (
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