9d93ee5f0060d15301c4ef34e57fdbc6414320af
[linux-2.6.git] / drivers / acpi / resources / rsdump.c
1 /*******************************************************************************
2  *
3  * Module Name: rsdump - Functions to display the resource structures.
4  *
5  ******************************************************************************/
6
7 /*
8  * Copyright (C) 2000 - 2005, R. Byron Moore
9  * All rights reserved.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions, and the following disclaimer,
16  *    without modification.
17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18  *    substantially similar to the "NO WARRANTY" disclaimer below
19  *    ("Disclaimer") and any redistribution must be conditioned upon
20  *    including a substantially similar Disclaimer requirement for further
21  *    binary redistribution.
22  * 3. Neither the names of the above-listed copyright holders nor the names
23  *    of any contributors may be used to endorse or promote products derived
24  *    from this software without specific prior written permission.
25  *
26  * Alternatively, this software may be distributed under the terms of the
27  * GNU General Public License ("GPL") version 2 as published by the Free
28  * Software Foundation.
29  *
30  * NO WARRANTY
31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41  * POSSIBILITY OF SUCH DAMAGES.
42  */
43
44 #include <acpi/acpi.h>
45 #include <acpi/acresrc.h>
46
47 #define _COMPONENT          ACPI_RESOURCES
48 ACPI_MODULE_NAME("rsdump")
49
50 #if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
51 /* Local prototypes */
52 static void acpi_rs_dump_irq(union acpi_resource_data *resource);
53
54 static void acpi_rs_dump_address16(union acpi_resource_data *resource);
55
56 static void acpi_rs_dump_address32(union acpi_resource_data *resource);
57
58 static void acpi_rs_dump_address64(union acpi_resource_data *resource);
59
60 static void acpi_rs_dump_dma(union acpi_resource_data *resource);
61
62 static void acpi_rs_dump_io(union acpi_resource_data *resource);
63
64 static void acpi_rs_dump_extended_irq(union acpi_resource_data *resource);
65
66 static void acpi_rs_dump_fixed_io(union acpi_resource_data *resource);
67
68 static void acpi_rs_dump_fixed_memory32(union acpi_resource_data *resource);
69
70 static void acpi_rs_dump_memory24(union acpi_resource_data *resource);
71
72 static void acpi_rs_dump_memory32(union acpi_resource_data *resource);
73
74 static void acpi_rs_dump_start_depend_fns(union acpi_resource_data *resource);
75
76 static void acpi_rs_dump_vendor_specific(union acpi_resource_data *resource);
77
78 static void acpi_rs_dump_generic_reg(union acpi_resource_data *resource);
79
80 static void acpi_rs_dump_end_depend_fns(union acpi_resource_data *resource);
81
82 static void acpi_rs_dump_end_tag(union acpi_resource_data *resource);
83
84 static void acpi_rs_out_string(char *title, char *value);
85
86 static void acpi_rs_out_integer8(char *title, u8 value);
87
88 static void acpi_rs_out_integer16(char *title, u16 value);
89
90 static void acpi_rs_out_integer32(char *title, u32 value);
91
92 static void acpi_rs_out_integer64(char *title, u64 value);
93
94 static void acpi_rs_out_title(char *title);
95
96 static void acpi_rs_dump_byte_list(u32 length, u8 * data);
97
98 static void acpi_rs_dump_dword_list(u32 length, u32 * data);
99
100 static void acpi_rs_dump_short_byte_list(u32 length, u32 * data);
101
102 static void
103 acpi_rs_dump_resource_source(struct acpi_resource_source *resource_source);
104
105 static void acpi_rs_dump_address_common(union acpi_resource_data *resource);
106
107 /* Dispatch table for resource dump functions */
108
109 typedef
110 void (*ACPI_DUMP_RESOURCE) (union acpi_resource_data * data);
111
112 static ACPI_DUMP_RESOURCE acpi_gbl_dump_resource_dispatch[] = {
113         acpi_rs_dump_irq,       /* ACPI_RSTYPE_IRQ */
114         acpi_rs_dump_dma,       /* ACPI_RSTYPE_DMA */
115         acpi_rs_dump_start_depend_fns,  /* ACPI_RSTYPE_START_DPF */
116         acpi_rs_dump_end_depend_fns,    /* ACPI_RSTYPE_END_DPF */
117         acpi_rs_dump_io,        /* ACPI_RSTYPE_IO */
118         acpi_rs_dump_fixed_io,  /* ACPI_RSTYPE_FIXED_IO */
119         acpi_rs_dump_vendor_specific,   /* ACPI_RSTYPE_VENDOR */
120         acpi_rs_dump_end_tag,   /* ACPI_RSTYPE_END_TAG */
121         acpi_rs_dump_memory24,  /* ACPI_RSTYPE_MEM24 */
122         acpi_rs_dump_memory32,  /* ACPI_RSTYPE_MEM32 */
123         acpi_rs_dump_fixed_memory32,    /* ACPI_RSTYPE_FIXED_MEM32 */
124         acpi_rs_dump_address16, /* ACPI_RSTYPE_ADDRESS16 */
125         acpi_rs_dump_address32, /* ACPI_RSTYPE_ADDRESS32 */
126         acpi_rs_dump_address64, /* ACPI_RSTYPE_ADDRESS64 */
127         acpi_rs_dump_extended_irq,      /* ACPI_RSTYPE_EXT_IRQ */
128         acpi_rs_dump_generic_reg        /* ACPI_RSTYPE_GENERIC_REG */
129 };
130
131 /*******************************************************************************
132  *
133  * FUNCTION:    acpi_rs_out*
134  *
135  * PARAMETERS:  Title       - Name of the resource field
136  *              Value       - Value of the resource field
137  *
138  * RETURN:      None
139  *
140  * DESCRIPTION: Miscellaneous helper functions to consistently format the
141  *              output of the resource dump routines
142  *
143  ******************************************************************************/
144
145 static void acpi_rs_out_string(char *title, char *value)
146 {
147         acpi_os_printf("%30s : %s\n", title, value);
148 }
149
150 static void acpi_rs_out_integer8(char *title, u8 value)
151 {
152         acpi_os_printf("%30s : %2.2X\n", title, value);
153 }
154
155 static void acpi_rs_out_integer16(char *title, u16 value)
156 {
157         acpi_os_printf("%30s : %4.4X\n", title, value);
158 }
159
160 static void acpi_rs_out_integer32(char *title, u32 value)
161 {
162         acpi_os_printf("%30s : %8.8X\n", title, value);
163 }
164
165 static void acpi_rs_out_integer64(char *title, u64 value)
166 {
167         acpi_os_printf("%30s : %8.8X%8.8X\n", title, ACPI_FORMAT_UINT64(value));
168 }
169
170 static void acpi_rs_out_title(char *title)
171 {
172         acpi_os_printf("%30s : ", title);
173 }
174
175 /*******************************************************************************
176  *
177  * FUNCTION:    acpi_rs_dump*List
178  *
179  * PARAMETERS:  Length      - Number of elements in the list
180  *              Data        - Start of the list
181  *
182  * RETURN:      None
183  *
184  * DESCRIPTION: Miscellaneous functions to dump lists of raw data
185  *
186  ******************************************************************************/
187
188 static void acpi_rs_dump_byte_list(u32 length, u8 * data)
189 {
190         u32 i;
191
192         for (i = 0; i < length; i++) {
193                 acpi_os_printf("%28s%2.2X : %2.2X\n", "Byte", i, data[i]);
194         }
195 }
196
197 static void acpi_rs_dump_dword_list(u32 length, u32 * data)
198 {
199         u32 i;
200
201         for (i = 0; i < length; i++) {
202                 acpi_os_printf("%28s%2.2X : %8.8X\n", "Dword", i, data[i]);
203         }
204 }
205
206 static void acpi_rs_dump_short_byte_list(u32 length, u32 * data)
207 {
208         u32 i;
209
210         for (i = 0; i < length; i++) {
211                 acpi_os_printf("%X ", data[i]);
212         }
213         acpi_os_printf("\n");
214 }
215
216 /*******************************************************************************
217  *
218  * FUNCTION:    acpi_rs_dump_resource_source
219  *
220  * PARAMETERS:  resource_source     - Pointer to a Resource Source struct
221  *
222  * RETURN:      None
223  *
224  * DESCRIPTION: Common routine for dumping the optional resource_source and the
225  *              corresponding resource_source_index.
226  *
227  ******************************************************************************/
228
229 static void
230 acpi_rs_dump_resource_source(struct acpi_resource_source *resource_source)
231 {
232
233         if (resource_source->index == 0xFF) {
234                 return;
235         }
236
237         acpi_rs_out_integer8("Resource Source Index",
238                              (u8) resource_source->index);
239
240         acpi_rs_out_string("Resource Source",
241                            resource_source->string_ptr ?
242                            resource_source->string_ptr : "[Not Specified]");
243 }
244
245 /*******************************************************************************
246  *
247  * FUNCTION:    acpi_rs_dump_address_common
248  *
249  * PARAMETERS:  Resource        - Pointer to an internal resource descriptor
250  *
251  * RETURN:      None
252  *
253  * DESCRIPTION: Dump the fields that are common to all Address resource
254  *              descriptors
255  *
256  ******************************************************************************/
257
258 static void acpi_rs_dump_address_common(union acpi_resource_data *resource)
259 {
260         ACPI_FUNCTION_ENTRY();
261
262         /* Decode the type-specific flags */
263
264         switch (resource->address.resource_type) {
265         case ACPI_MEMORY_RANGE:
266
267                 acpi_rs_out_string("Resource Type", "Memory Range");
268
269                 acpi_rs_out_title("Type-Specific Flags");
270
271                 switch (resource->address.attribute.memory.cache_attribute) {
272                 case ACPI_NON_CACHEABLE_MEMORY:
273                         acpi_os_printf("Noncacheable memory\n");
274                         break;
275
276                 case ACPI_CACHABLE_MEMORY:
277                         acpi_os_printf("Cacheable memory\n");
278                         break;
279
280                 case ACPI_WRITE_COMBINING_MEMORY:
281                         acpi_os_printf("Write-combining memory\n");
282                         break;
283
284                 case ACPI_PREFETCHABLE_MEMORY:
285                         acpi_os_printf("Prefetchable memory\n");
286                         break;
287
288                 default:
289                         acpi_os_printf("Invalid cache attribute\n");
290                         break;
291                 }
292
293                 acpi_rs_out_string("Read/Write Attribute",
294                                    ACPI_READ_WRITE_MEMORY ==
295                                    resource->address.attribute.memory.
296                                    read_write_attribute ? "Read/Write" :
297                                    "Read Only");
298                 break;
299
300         case ACPI_IO_RANGE:
301
302                 acpi_rs_out_string("Resource Type", "I/O Range");
303
304                 acpi_rs_out_title("Type-Specific Flags");
305
306                 switch (resource->address.attribute.io.range_attribute) {
307                 case ACPI_NON_ISA_ONLY_RANGES:
308                         acpi_os_printf("Non-ISA I/O Addresses\n");
309                         break;
310
311                 case ACPI_ISA_ONLY_RANGES:
312                         acpi_os_printf("ISA I/O Addresses\n");
313                         break;
314
315                 case ACPI_ENTIRE_RANGE:
316                         acpi_os_printf("ISA and non-ISA I/O Addresses\n");
317                         break;
318
319                 default:
320                         acpi_os_printf("Invalid range attribute\n");
321                         break;
322                 }
323
324                 acpi_rs_out_string("Translation Attribute",
325                                    ACPI_SPARSE_TRANSLATION ==
326                                    resource->address.attribute.io.
327                                    translation_attribute ? "Sparse Translation"
328                                    : "Dense Translation");
329                 break;
330
331         case ACPI_BUS_NUMBER_RANGE:
332
333                 acpi_rs_out_string("Resource Type", "Bus Number Range");
334                 break;
335
336         default:
337
338                 acpi_rs_out_integer8("Resource Type",
339                                      (u8) resource->address.resource_type);
340                 break;
341         }
342
343         /* Decode the general flags */
344
345         acpi_rs_out_string("Resource",
346                            ACPI_CONSUMER ==
347                            resource->address.
348                            producer_consumer ? "Consumer" : "Producer");
349
350         acpi_rs_out_string("Decode",
351                            ACPI_SUB_DECODE == resource->address.decode ?
352                            "Subtractive" : "Positive");
353
354         acpi_rs_out_string("Min Address",
355                            ACPI_ADDRESS_FIXED ==
356                            resource->address.
357                            min_address_fixed ? "Fixed" : "Not Fixed");
358
359         acpi_rs_out_string("Max Address",
360                            ACPI_ADDRESS_FIXED ==
361                            resource->address.
362                            max_address_fixed ? "Fixed" : "Not Fixed");
363 }
364
365 /*******************************************************************************
366  *
367  * FUNCTION:    acpi_rs_dump_resource_list
368  *
369  * PARAMETERS:  resource_list       - Pointer to a resource descriptor list
370  *
371  * RETURN:      None
372  *
373  * DESCRIPTION: Dispatches the structure to the correct dump routine.
374  *
375  ******************************************************************************/
376
377 void acpi_rs_dump_resource_list(struct acpi_resource *resource_list)
378 {
379         u32 count = 0;
380
381         ACPI_FUNCTION_ENTRY();
382
383         if (!(acpi_dbg_level & ACPI_LV_RESOURCES)
384             || !(_COMPONENT & acpi_dbg_layer)) {
385                 return;
386         }
387
388         /* Dump all resource descriptors in the list */
389
390         while (resource_list) {
391                 acpi_os_printf("\n[%02X] ", count);
392
393                 /* Validate Type before dispatch */
394
395                 if (resource_list->type > ACPI_RSTYPE_MAX) {
396                         acpi_os_printf
397                             ("Invalid descriptor type (%X) in resource list\n",
398                              resource_list->type);
399                         return;
400                 }
401
402                 /* Dump the resource descriptor */
403
404                 acpi_gbl_dump_resource_dispatch[resource_list->
405                                                 type] (&resource_list->data);
406
407                 /* Exit on end tag */
408
409                 if (resource_list->type == ACPI_RSTYPE_END_TAG) {
410                         return;
411                 }
412
413                 /* Get the next resource structure */
414
415                 resource_list =
416                     ACPI_PTR_ADD(struct acpi_resource, resource_list,
417                                  resource_list->length);
418                 count++;
419         }
420 }
421
422 /*******************************************************************************
423  *
424  * FUNCTION:    acpi_rs_dump_irq
425  *
426  * PARAMETERS:  Resource        - Pointer to an internal resource descriptor
427  *
428  * RETURN:      None
429  *
430  * DESCRIPTION: Dump the field names and values of the resource descriptor
431  *
432  ******************************************************************************/
433
434 static void acpi_rs_dump_irq(union acpi_resource_data *resource)
435 {
436         ACPI_FUNCTION_ENTRY();
437
438         acpi_os_printf("IRQ Resource\n");
439
440         acpi_rs_out_string("Triggering",
441                            ACPI_LEVEL_SENSITIVE ==
442                            resource->irq.edge_level ? "Level" : "Edge");
443
444         acpi_rs_out_string("Active",
445                            ACPI_ACTIVE_LOW ==
446                            resource->irq.active_high_low ? "Low" : "High");
447
448         acpi_rs_out_string("Sharing",
449                            ACPI_SHARED ==
450                            resource->irq.
451                            shared_exclusive ? "Shared" : "Exclusive");
452
453         acpi_rs_out_integer8("Interrupt Count",
454                              (u8) resource->irq.number_of_interrupts);
455
456         acpi_rs_out_title("Interrupt List");
457         acpi_rs_dump_short_byte_list(resource->irq.number_of_interrupts,
458                                      resource->irq.interrupts);
459 }
460
461 /*******************************************************************************
462  *
463  * FUNCTION:    acpi_rs_dump_dma
464  *
465  * PARAMETERS:  Resource        - Pointer to an internal resource descriptor
466  *
467  * RETURN:      None
468  *
469  * DESCRIPTION: Dump the field names and values of the resource descriptor
470  *
471  ******************************************************************************/
472
473 static void acpi_rs_dump_dma(union acpi_resource_data *resource)
474 {
475         ACPI_FUNCTION_ENTRY();
476
477         acpi_os_printf("DMA Resource\n");
478
479         acpi_rs_out_title("DMA Type");
480         switch (resource->dma.type) {
481         case ACPI_COMPATIBILITY:
482                 acpi_os_printf("Compatibility mode\n");
483                 break;
484
485         case ACPI_TYPE_A:
486                 acpi_os_printf("Type A\n");
487                 break;
488
489         case ACPI_TYPE_B:
490                 acpi_os_printf("Type B\n");
491                 break;
492
493         case ACPI_TYPE_F:
494                 acpi_os_printf("Type F\n");
495                 break;
496
497         default:
498                 acpi_os_printf("**** Invalid DMA type\n");
499                 break;
500         }
501
502         acpi_rs_out_string("Bus Master",
503                            ACPI_BUS_MASTER ==
504                            resource->dma.bus_master ? "Yes" : "No");
505
506         acpi_rs_out_title("Transfer Type");
507         switch (resource->dma.transfer) {
508         case ACPI_TRANSFER_8:
509                 acpi_os_printf("8-bit transfers only\n");
510                 break;
511
512         case ACPI_TRANSFER_8_16:
513                 acpi_os_printf("8-bit and 16-bit transfers\n");
514                 break;
515
516         case ACPI_TRANSFER_16:
517                 acpi_os_printf("16-bit transfers only\n");
518                 break;
519
520         default:
521                 acpi_os_printf("**** Invalid transfer preference\n");
522                 break;
523         }
524
525         acpi_rs_out_integer8("DMA Channel Count",
526                              (u8) resource->dma.number_of_channels);
527
528         acpi_rs_out_title("Channel List");
529         acpi_rs_dump_short_byte_list(resource->dma.number_of_channels,
530                                      resource->dma.channels);
531 }
532
533 /*******************************************************************************
534  *
535  * FUNCTION:    acpi_rs_dump_start_depend_fns
536  *
537  * PARAMETERS:  Resource        - Pointer to an internal resource descriptor
538  *
539  * RETURN:      None
540  *
541  * DESCRIPTION: Dump the field names and values of the resource descriptor
542  *
543  ******************************************************************************/
544
545 static void acpi_rs_dump_start_depend_fns(union acpi_resource_data *resource)
546 {
547         ACPI_FUNCTION_ENTRY();
548
549         acpi_os_printf("Start Dependent Functions Resource\n");
550
551         acpi_rs_out_title("Compatibility Priority");
552         switch (resource->start_dpf.compatibility_priority) {
553         case ACPI_GOOD_CONFIGURATION:
554                 acpi_os_printf("Good configuration\n");
555                 break;
556
557         case ACPI_ACCEPTABLE_CONFIGURATION:
558                 acpi_os_printf("Acceptable configuration\n");
559                 break;
560
561         case ACPI_SUB_OPTIMAL_CONFIGURATION:
562                 acpi_os_printf("Sub-optimal configuration\n");
563                 break;
564
565         default:
566                 acpi_os_printf("**** Invalid compatibility priority\n");
567                 break;
568         }
569
570         acpi_rs_out_title("Performance/Robustness");
571         switch (resource->start_dpf.performance_robustness) {
572         case ACPI_GOOD_CONFIGURATION:
573                 acpi_os_printf("Good configuration\n");
574                 break;
575
576         case ACPI_ACCEPTABLE_CONFIGURATION:
577                 acpi_os_printf("Acceptable configuration\n");
578                 break;
579
580         case ACPI_SUB_OPTIMAL_CONFIGURATION:
581                 acpi_os_printf("Sub-optimal configuration\n");
582                 break;
583
584         default:
585                 acpi_os_printf
586                     ("**** Invalid performance robustness preference\n");
587                 break;
588         }
589 }
590
591 /*******************************************************************************
592  *
593  * FUNCTION:    acpi_rs_dump_io
594  *
595  * PARAMETERS:  Resource        - Pointer to an internal resource descriptor
596  *
597  * RETURN:      None
598  *
599  * DESCRIPTION: Dump the field names and values of the resource descriptor
600  *
601  ******************************************************************************/
602
603 static void acpi_rs_dump_io(union acpi_resource_data *resource)
604 {
605         ACPI_FUNCTION_ENTRY();
606
607         acpi_os_printf("I/O Resource\n");
608
609         acpi_rs_out_string("Decode",
610                            ACPI_DECODE_16 ==
611                            resource->io.io_decode ? "16-bit" : "10-bit");
612
613         acpi_rs_out_integer32("Range Minimum Base",
614                               resource->io.min_base_address);
615
616         acpi_rs_out_integer32("Range Maximum Base",
617                               resource->io.max_base_address);
618
619         acpi_rs_out_integer32("Alignment", resource->io.alignment);
620
621         acpi_rs_out_integer32("Range Length", resource->io.range_length);
622 }
623
624 /*******************************************************************************
625  *
626  * FUNCTION:    acpi_rs_dump_fixed_io
627  *
628  * PARAMETERS:  Resource        - Pointer to an internal resource descriptor
629  *
630  * RETURN:      None
631  *
632  * DESCRIPTION: Dump the field names and values of the resource descriptor
633  *
634  ******************************************************************************/
635
636 static void acpi_rs_dump_fixed_io(union acpi_resource_data *resource)
637 {
638         ACPI_FUNCTION_ENTRY();
639
640         acpi_os_printf("Fixed I/O Resource\n");
641
642         acpi_rs_out_integer32("Range Base Address",
643                               resource->fixed_io.base_address);
644
645         acpi_rs_out_integer32("Range Length", resource->fixed_io.range_length);
646 }
647
648 /*******************************************************************************
649  *
650  * FUNCTION:    acpi_rs_dump_vendor_specific
651  *
652  * PARAMETERS:  Resource        - Pointer to an internal resource descriptor
653  *
654  * RETURN:      None
655  *
656  * DESCRIPTION: Dump the field names and values of the resource descriptor
657  *
658  ******************************************************************************/
659
660 static void acpi_rs_dump_vendor_specific(union acpi_resource_data *resource)
661 {
662         ACPI_FUNCTION_ENTRY();
663
664         acpi_os_printf("Vendor Specific Resource\n");
665
666         acpi_rs_out_integer16("Length", (u16) resource->vendor_specific.length);
667
668         acpi_rs_dump_byte_list(resource->vendor_specific.length,
669                                resource->vendor_specific.reserved);
670 }
671
672 /*******************************************************************************
673  *
674  * FUNCTION:    acpi_rs_dump_memory24
675  *
676  * PARAMETERS:  Resource        - Pointer to an internal resource descriptor
677  *
678  * RETURN:      None
679  *
680  * DESCRIPTION: Dump the field names and values of the resource descriptor
681  *
682  ******************************************************************************/
683
684 static void acpi_rs_dump_memory24(union acpi_resource_data *resource)
685 {
686         ACPI_FUNCTION_ENTRY();
687
688         acpi_os_printf("24-Bit Memory Range Resource\n");
689
690         acpi_rs_out_string("Attribute",
691                            ACPI_READ_WRITE_MEMORY ==
692                            resource->memory24.read_write_attribute ?
693                            "Read/Write" : "Read Only");
694
695         acpi_rs_out_integer16("Range Minimum Base",
696                               (u16) resource->memory24.min_base_address);
697
698         acpi_rs_out_integer16("Range Maximum Base",
699                               (u16) resource->memory24.max_base_address);
700
701         acpi_rs_out_integer16("Alignment", (u16) resource->memory24.alignment);
702
703         acpi_rs_out_integer16("Range Length",
704                               (u16) resource->memory24.range_length);
705 }
706
707 /*******************************************************************************
708  *
709  * FUNCTION:    acpi_rs_dump_memory32
710  *
711  * PARAMETERS:  Resource        - Pointer to an internal resource descriptor
712  *
713  * RETURN:      None
714  *
715  * DESCRIPTION: Dump the field names and values of the resource descriptor
716  *
717  ******************************************************************************/
718
719 static void acpi_rs_dump_memory32(union acpi_resource_data *resource)
720 {
721         ACPI_FUNCTION_ENTRY();
722
723         acpi_os_printf("32-Bit Memory Range Resource\n");
724
725         acpi_rs_out_string("Attribute",
726                            ACPI_READ_WRITE_MEMORY ==
727                            resource->memory32.read_write_attribute ?
728                            "Read/Write" : "Read Only");
729
730         acpi_rs_out_integer32("Range Minimum Base",
731                               resource->memory32.min_base_address);
732
733         acpi_rs_out_integer32("Range Maximum Base",
734                               resource->memory32.max_base_address);
735
736         acpi_rs_out_integer32("Alignment", resource->memory32.alignment);
737
738         acpi_rs_out_integer32("Range Length", resource->memory32.range_length);
739 }
740
741 /*******************************************************************************
742  *
743  * FUNCTION:    acpi_rs_dump_fixed_memory32
744  *
745  * PARAMETERS:  Resource        - Pointer to an internal resource descriptor
746  *
747  * RETURN:
748  *
749  * DESCRIPTION: Dump the field names and values of the resource descriptor
750  *
751  ******************************************************************************/
752
753 static void acpi_rs_dump_fixed_memory32(union acpi_resource_data *resource)
754 {
755         ACPI_FUNCTION_ENTRY();
756
757         acpi_os_printf("32-Bit Fixed Location Memory Range Resource\n");
758
759         acpi_rs_out_string("Attribute",
760                            ACPI_READ_WRITE_MEMORY ==
761                            resource->fixed_memory32.read_write_attribute ?
762                            "Read/Write" : "Read Only");
763
764         acpi_rs_out_integer32("Range Base Address",
765                               resource->fixed_memory32.range_base_address);
766
767         acpi_rs_out_integer32("Range Length",
768                               resource->fixed_memory32.range_length);
769 }
770
771 /*******************************************************************************
772  *
773  * FUNCTION:    acpi_rs_dump_address16
774  *
775  * PARAMETERS:  Resource        - Pointer to an internal resource descriptor
776  *
777  * RETURN:      None
778  *
779  * DESCRIPTION: Dump the field names and values of the resource descriptor
780  *
781  ******************************************************************************/
782
783 static void acpi_rs_dump_address16(union acpi_resource_data *resource)
784 {
785         ACPI_FUNCTION_ENTRY();
786
787         acpi_os_printf("16-Bit Address Space Resource\n");
788
789         acpi_rs_dump_address_common(resource);
790
791         acpi_rs_out_integer16("Granularity",
792                               (u16) resource->address16.granularity);
793
794         acpi_rs_out_integer16("Address Range Min",
795                               (u16) resource->address16.min_address_range);
796
797         acpi_rs_out_integer16("Address Range Max",
798                               (u16) resource->address16.max_address_range);
799
800         acpi_rs_out_integer16("Address Translation Offset",
801                               (u16) resource->address16.
802                               address_translation_offset);
803
804         acpi_rs_out_integer16("Address Length",
805                               (u16) resource->address16.address_length);
806
807         acpi_rs_dump_resource_source(&resource->address16.resource_source);
808 }
809
810 /*******************************************************************************
811  *
812  * FUNCTION:    acpi_rs_dump_address32
813  *
814  * PARAMETERS:  Resource        - Pointer to an internal resource descriptor
815  *
816  * RETURN:      None
817  *
818  * DESCRIPTION: Dump the field names and values of the resource descriptor
819  *
820  ******************************************************************************/
821
822 static void acpi_rs_dump_address32(union acpi_resource_data *resource)
823 {
824         ACPI_FUNCTION_ENTRY();
825
826         acpi_os_printf("32-Bit Address Space Resource\n");
827
828         acpi_rs_dump_address_common(resource);
829
830         acpi_rs_out_integer32("Granularity", resource->address32.granularity);
831
832         acpi_rs_out_integer32("Address Range Min",
833                               resource->address32.min_address_range);
834
835         acpi_rs_out_integer32("Address Range Max",
836                               resource->address32.max_address_range);
837
838         acpi_rs_out_integer32("Address Translation Offset",
839                               resource->address32.address_translation_offset);
840
841         acpi_rs_out_integer32("Address Length",
842                               resource->address32.address_length);
843
844         acpi_rs_dump_resource_source(&resource->address32.resource_source);
845 }
846
847 /*******************************************************************************
848  *
849  * FUNCTION:    acpi_rs_dump_address64
850  *
851  * PARAMETERS:  Resource        - Pointer to an internal resource descriptor
852  *
853  * RETURN:      None
854  *
855  * DESCRIPTION: Dump the field names and values of the resource descriptor
856  *
857  ******************************************************************************/
858
859 static void acpi_rs_dump_address64(union acpi_resource_data *resource)
860 {
861         ACPI_FUNCTION_ENTRY();
862
863         acpi_os_printf("64-Bit Address Space Resource\n");
864
865         acpi_rs_dump_address_common(resource);
866
867         acpi_rs_out_integer64("Granularity", resource->address64.granularity);
868
869         acpi_rs_out_integer64("Address Range Min",
870                               resource->address64.min_address_range);
871
872         acpi_rs_out_integer64("Address Range Max",
873                               resource->address64.max_address_range);
874
875         acpi_rs_out_integer64("Address Translation Offset",
876                               resource->address64.address_translation_offset);
877
878         acpi_rs_out_integer64("Address Length",
879                               resource->address64.address_length);
880
881         acpi_rs_out_integer64("Type Specific Attributes",
882                               resource->address64.type_specific_attributes);
883
884         acpi_rs_dump_resource_source(&resource->address64.resource_source);
885 }
886
887 /*******************************************************************************
888  *
889  * FUNCTION:    acpi_rs_dump_extended_irq
890  *
891  * PARAMETERS:  Resource        - Pointer to an internal resource descriptor
892  *
893  * RETURN:      None
894  *
895  * DESCRIPTION: Dump the field names and values of the resource descriptor
896  *
897  ******************************************************************************/
898
899 static void acpi_rs_dump_extended_irq(union acpi_resource_data *resource)
900 {
901         ACPI_FUNCTION_ENTRY();
902
903         acpi_os_printf("Extended IRQ Resource\n");
904
905         acpi_rs_out_string("Resource",
906                            ACPI_CONSUMER ==
907                            resource->extended_irq.
908                            producer_consumer ? "Consumer" : "Producer");
909
910         acpi_rs_out_string("Triggering",
911                            ACPI_LEVEL_SENSITIVE ==
912                            resource->extended_irq.
913                            edge_level ? "Level" : "Edge");
914
915         acpi_rs_out_string("Active",
916                            ACPI_ACTIVE_LOW ==
917                            resource->extended_irq.
918                            active_high_low ? "Low" : "High");
919
920         acpi_rs_out_string("Sharing",
921                            ACPI_SHARED ==
922                            resource->extended_irq.
923                            shared_exclusive ? "Shared" : "Exclusive");
924
925         acpi_rs_dump_resource_source(&resource->extended_irq.resource_source);
926
927         acpi_rs_out_integer8("Interrupts",
928                              (u8) resource->extended_irq.number_of_interrupts);
929
930         acpi_rs_dump_dword_list(resource->extended_irq.number_of_interrupts,
931                                 resource->extended_irq.interrupts);
932 }
933
934 /*******************************************************************************
935  *
936  * FUNCTION:    acpi_rs_dump_generic_reg
937  *
938  * PARAMETERS:  Resource        - Pointer to an internal resource descriptor
939  *
940  * RETURN:      None
941  *
942  * DESCRIPTION: Dump the field names and values of the resource descriptor
943  *
944  ******************************************************************************/
945
946 static void acpi_rs_dump_generic_reg(union acpi_resource_data *resource)
947 {
948
949         ACPI_FUNCTION_ENTRY();
950
951         acpi_os_printf("Generic Register Resource\n");
952
953         acpi_rs_out_integer8("Space ID", (u8) resource->generic_reg.space_id);
954
955         acpi_rs_out_integer8("Bit Width", (u8) resource->generic_reg.bit_width);
956
957         acpi_rs_out_integer8("Bit Offset",
958                              (u8) resource->generic_reg.bit_offset);
959
960         acpi_rs_out_integer8("Address Size",
961                              (u8) resource->generic_reg.address_size);
962
963         acpi_rs_out_integer64("Address", resource->generic_reg.address);
964 }
965
966 /*******************************************************************************
967  *
968  * FUNCTION:    acpi_rs_dump_end_depend_fns
969  *
970  * PARAMETERS:  Resource        - Pointer to an internal resource descriptor
971  *
972  * RETURN:      None
973  *
974  * DESCRIPTION: Print type, no data.
975  *
976  ******************************************************************************/
977
978 static void acpi_rs_dump_end_depend_fns(union acpi_resource_data *resource)
979 {
980         ACPI_FUNCTION_ENTRY();
981
982         acpi_os_printf("end_dependent_functions Resource\n");
983 }
984
985 /*******************************************************************************
986  *
987  * FUNCTION:    acpi_rs_dump_end_tag
988  *
989  * PARAMETERS:  Resource        - Pointer to an internal resource descriptor
990  *
991  * RETURN:      None
992  *
993  * DESCRIPTION: Print type, no data.
994  *
995  ******************************************************************************/
996
997 static void acpi_rs_dump_end_tag(union acpi_resource_data *resource)
998 {
999         ACPI_FUNCTION_ENTRY();
1000
1001         acpi_os_printf("end_tag Resource\n");
1002 }
1003
1004 /*******************************************************************************
1005  *
1006  * FUNCTION:    acpi_rs_dump_irq_list
1007  *
1008  * PARAMETERS:  route_table     - Pointer to the routing table to dump.
1009  *
1010  * RETURN:      None
1011  *
1012  * DESCRIPTION: Print IRQ routing table
1013  *
1014  ******************************************************************************/
1015
1016 void acpi_rs_dump_irq_list(u8 * route_table)
1017 {
1018         u8 *buffer = route_table;
1019         u8 count = 0;
1020         struct acpi_pci_routing_table *prt_element;
1021
1022         ACPI_FUNCTION_ENTRY();
1023
1024         if (!(acpi_dbg_level & ACPI_LV_RESOURCES)
1025             || !(_COMPONENT & acpi_dbg_layer)) {
1026                 return;
1027         }
1028
1029         prt_element = ACPI_CAST_PTR(struct acpi_pci_routing_table, buffer);
1030
1031         /* Dump all table elements, Exit on null length element */
1032
1033         while (prt_element->length) {
1034                 acpi_os_printf("\n[%02X] PCI IRQ Routing Table Package\n",
1035                                count);
1036
1037                 acpi_rs_out_integer64("Address", prt_element->address);
1038
1039                 acpi_rs_out_integer32("Pin", prt_element->pin);
1040                 acpi_rs_out_string("Source", prt_element->source);
1041                 acpi_rs_out_integer32("Source Index",
1042                                       prt_element->source_index);
1043
1044                 buffer += prt_element->length;
1045                 prt_element =
1046                     ACPI_CAST_PTR(struct acpi_pci_routing_table, buffer);
1047                 count++;
1048         }
1049 }
1050
1051 #endif