?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.4.0-test9pre1
[davej-history.git] / drivers / acpi / resources / rsdump.c
blobae697840c121d760b950a4d447c832d868dfa395
1 /******************************************************************************
2 *
3 * Module Name: rsdump - Functions do dump out the resource structures.
4 * $Revision: 10 $
5 *
6 *****************************************************************************/
7
8 /*
9 * Copyright (C) 2000 R. Byron Moore
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 */
25
26
27 #include "acpi.h"
28
29 #define _COMPONENT RESOURCE_MANAGER
30 MODULE_NAME ("rsdump")
31
32
33 /******************************************************************************
34 *
35 * FUNCTION: Acpi_rs_dump_irq
36 *
37 * PARAMETERS: Data - pointer to the resource structure to dump.
38 *
39 * RETURN:
40 *
41 * DESCRIPTION: Prints out the various members of the Data structure type.
42 *
43 ******************************************************************************/
44
45 void
46 acpi_rs_dump_irq (
47 RESOURCE_DATA *data)
48 {
49 IRQ_RESOURCE *irq_data = (IRQ_RESOURCE*) data;
50 u8 index = 0;
51
52
53 acpi_os_printf ("\t_iRQ Resource\n");
54
55 acpi_os_printf ("\t\t%s Triggered\n",
56 LEVEL_SENSITIVE == irq_data->edge_level ?
57 "Level" : "Edge");
58
59 acpi_os_printf ("\t\t_active %s\n",
60 ACTIVE_LOW == irq_data->active_high_low ?
61 "Low" : "High");
62
63 acpi_os_printf ("\t\t%s\n",
64 SHARED == irq_data->shared_exclusive ?
65 "Shared" : "Exclusive");
66
67 acpi_os_printf ("\t\t%d Interrupts ( ",
68 irq_data->number_of_interrupts);
69
70 for (index = 0; index < irq_data->number_of_interrupts; index++) {
71 acpi_os_printf ("%d ", irq_data->interrupts[index]);
72 }
73
74 acpi_os_printf (")\n");
75 return;
76 }
77
78
79 /******************************************************************************
80 *
81 * FUNCTION: Acpi_rs_dump_dma
82 *
83 * PARAMETERS: Data - pointer to the resource structure to dump.
84 *
85 * RETURN:
86 *
87 * DESCRIPTION: Prints out the various members of the Data structure type.
88 *
89 ******************************************************************************/
90
91 void
92 acpi_rs_dump_dma (
93 RESOURCE_DATA *data)
94 {
95 DMA_RESOURCE *dma_data = (DMA_RESOURCE*) data;
96 u8 index = 0;
97
98
99 acpi_os_printf ("\t_dMA Resource\n");
100
101 switch (dma_data->type)
102 {
103 case COMPATIBILITY:
104 acpi_os_printf ("\t\t_compatibility mode\n");
105 break;
106
107 case TYPE_A:
108 acpi_os_printf ("\t\t_type A\n");
109 break;
110
111 case TYPE_B:
112 acpi_os_printf ("\t\t_type B\n");
113 break;
114
115 case TYPE_F:
116 acpi_os_printf ("\t\t_type F\n");
117 break;
118
119 default:
120 acpi_os_printf ("\t\t_invalid DMA type\n");
121 break;
122 }
123
124 acpi_os_printf ("\t\t%sBus Master\n",
125 BUS_MASTER == dma_data->bus_master ?
126 "" : "Not a ");
127
128 switch (dma_data->transfer)
129 {
130 case TRANSFER_8:
131 acpi_os_printf ("\t\t8-bit only transfer\n");
132 break;
133
134 case TRANSFER_8_16:
135 acpi_os_printf ("\t\t8 and 16-bit transfer\n");
136 break;
137
138 case TRANSFER_16:
139 acpi_os_printf ("\t\t16 bit only transfer\n");
140 break;
141
142 default:
143 acpi_os_printf ("\t\t_invalid transfer preference\n");
144 break;
145 }
146
147 acpi_os_printf ("\t\t_number of Channels: %d ( ",
148 dma_data->number_of_channels);
149
150 for (index = 0; index < dma_data->number_of_channels; index++) {
151 acpi_os_printf ("%d ", dma_data->channels[index]);
152 }
153
154 acpi_os_printf (")\n");
155 return;
156 }
157
158
159 /******************************************************************************
160 *
161 * FUNCTION: Acpi_rs_dump_start_dependent_functions
162 *
163 * PARAMETERS: Data - pointer to the resource structure to dump.
164 *
165 * RETURN:
166 *
167 * DESCRIPTION: Prints out the various members of the Data structure type.
168 *
169 ******************************************************************************/
170
171 void
172 acpi_rs_dump_start_dependent_functions (
173 RESOURCE_DATA *data)
174 {
175 START_DEPENDENT_FUNCTIONS_RESOURCE *sdf_data =
176 (START_DEPENDENT_FUNCTIONS_RESOURCE*) data;
177
178
179 acpi_os_printf ("\t_start Dependent Functions Resource\n");
180
181 switch (sdf_data->compatibility_priority)
182 {
183 case GOOD_CONFIGURATION:
184 acpi_os_printf ("\t\t_good configuration\n");
185 break;
186
187 case ACCEPTABLE_CONFIGURATION:
188 acpi_os_printf ("\t\t_acceptable configuration\n");
189 break;
190
191 case SUB_OPTIMAL_CONFIGURATION:
192 acpi_os_printf ("\t\t_sub-optimal configuration\n");
193 break;
194
195 default:
196 acpi_os_printf ("\t\t_invalid compatibility priority\n");
197 break;
198 }
199
200 switch(sdf_data->performance_robustness)
201 {
202 case GOOD_CONFIGURATION:
203 acpi_os_printf ("\t\t_good configuration\n");
204 break;
205
206 case ACCEPTABLE_CONFIGURATION:
207 acpi_os_printf ("\t\t_acceptable configuration\n");
208 break;
209
210 case SUB_OPTIMAL_CONFIGURATION:
211 acpi_os_printf ("\t\t_sub-optimal configuration\n");
212 break;
213
214 default:
215 acpi_os_printf ("\t\t_invalid performance "
216 "robustness preference\n");
217 break;
218 }
219
220 return;
221 }
222
223
224 /******************************************************************************
225 *
226 * FUNCTION: Acpi_rs_dump_io
227 *
228 * PARAMETERS: Data - pointer to the resource structure to dump.
229 *
230 * RETURN:
231 *
232 * DESCRIPTION: Prints out the various members of the Data structure type.
233 *
234 ******************************************************************************/
235
236 void
237 acpi_rs_dump_io (
238 RESOURCE_DATA *data)
239 {
240 IO_RESOURCE *io_data = (IO_RESOURCE*) data;
241
242
243 acpi_os_printf ("\t_io Resource\n");
244
245 acpi_os_printf ("\t\t%d bit decode\n",
246 DECODE_16 == io_data->io_decode ? 16 : 10);
247
248 acpi_os_printf ("\t\t_range minimum base: 0x%08x\n",
249 io_data->min_base_address);
250
251 acpi_os_printf ("\t\t_range maximum base: 0x%08x\n",
252 io_data->max_base_address);
253
254 acpi_os_printf ("\t\t_alignment: 0x%08x\n",
255 io_data->alignment);
256
257 acpi_os_printf ("\t\t_range Length: 0x%08x\n",
258 io_data->range_length);
259
260 return;
261 }
262
263
264 /******************************************************************************
265 *
266 * FUNCTION: Acpi_rs_dump_fixed_io
267 *
268 * PARAMETERS: Data - pointer to the resource structure to dump.
269 *
270 * RETURN:
271 *
272 * DESCRIPTION: Prints out the various members of the Data structure type.
273 *
274 ******************************************************************************/
275
276 void
277 acpi_rs_dump_fixed_io (
278 RESOURCE_DATA *data)
279 {
280 FIXED_IO_RESOURCE *fixed_io_data = (FIXED_IO_RESOURCE*) data;
281
282
283 acpi_os_printf ("\t_fixed Io Resource\n");
284 acpi_os_printf ("\t\t_range base address: 0x%08x",
285 fixed_io_data->base_address);
286
287 acpi_os_printf ("\t\t_range length: 0x%08x",
288 fixed_io_data->range_length);
289
290 return;
291 }
292
293
294 /******************************************************************************
295 *
296 * FUNCTION: Acpi_rs_dump_vendor_specific
297 *
298 * PARAMETERS: Data - pointer to the resource structure to dump.
299 *
300 * RETURN:
301 *
302 * DESCRIPTION: Prints out the various members of the Data structure type.
303 *
304 ******************************************************************************/
305
306 void
307 acpi_rs_dump_vendor_specific (
308 RESOURCE_DATA *data)
309 {
310 VENDOR_RESOURCE *vendor_data = (VENDOR_RESOURCE*) data;
311 u16 index = 0;
312
313
314 acpi_os_printf ("\t_vendor Specific Resource\n");
315
316 acpi_os_printf ("\t\t_length: 0x%08x\n", vendor_data->length);
317
318 for (index = 0; index < vendor_data->length; index++) {
319 acpi_os_printf ("\t\t_byte %d: 0x%08x\n",
320 index, vendor_data->reserved[index]);
321 }
322
323 return;
324 }
325
326
327 /******************************************************************************
328 *
329 * FUNCTION: Acpi_rs_dump_memory24
330 *
331 * PARAMETERS: Data - pointer to the resource structure to dump.
332 *
333 * RETURN:
334 *
335 * DESCRIPTION: Prints out the various members of the Data structure type.
336 *
337 ******************************************************************************/
338
339 void
340 acpi_rs_dump_memory24 (
341 RESOURCE_DATA *data)
342 {
343 MEMORY24_RESOURCE *memory24_data = (MEMORY24_RESOURCE*) data;
344
345
346 acpi_os_printf ("\t24-Bit Memory Range Resource\n");
347
348 acpi_os_printf ("\t\t_read%s\n",
349 READ_WRITE_MEMORY ==
350 memory24_data->read_write_attribute ?
351 "/Write" : " only");
352
353 acpi_os_printf ("\t\t_range minimum base: 0x%08x\n",
354 memory24_data->min_base_address);
355
356 acpi_os_printf ("\t\t_range maximum base: 0x%08x\n",
357 memory24_data->max_base_address);
358
359 acpi_os_printf ("\t\t_alignment: 0x%08x\n",
360 memory24_data->alignment);
361
362 acpi_os_printf ("\t\t_range length: 0x%08x\n",
363 memory24_data->range_length);
364
365 return;
366 }
367
368
369 /******************************************************************************
370 *
371 * FUNCTION: Acpi_rs_dump_memory32
372 *
373 * PARAMETERS: Data - pointer to the resource structure to dump.
374 *
375 * RETURN:
376 *
377 * DESCRIPTION: Prints out the various members of the Data structure type.
378 *
379 ******************************************************************************/
380
381 void
382 acpi_rs_dump_memory32 (
383 RESOURCE_DATA *data)
384 {
385 MEMORY32_RESOURCE *memory32_data = (MEMORY32_RESOURCE*) data;
386
387
388 acpi_os_printf ("\t32-Bit Memory Range Resource\n");
389
390 acpi_os_printf ("\t\t_read%s\n",
391 READ_WRITE_MEMORY ==
392 memory32_data->read_write_attribute ?
393 "/Write" : " only");
394
395 acpi_os_printf ("\t\t_range minimum base: 0x%08x\n",
396 memory32_data->min_base_address);
397
398 acpi_os_printf ("\t\t_range maximum base: 0x%08x\n",
399 memory32_data->max_base_address);
400
401 acpi_os_printf ("\t\t_alignment: 0x%08x\n",
402 memory32_data->alignment);
403
404 acpi_os_printf ("\t\t_range length: 0x%08x\n",
405 memory32_data->range_length);
406
407 return;
408 }
409
410
411 /******************************************************************************
412 *
413 * FUNCTION: Acpi_rs_dump_fixed_memory32
414 *
415 * PARAMETERS: Data - pointer to the resource structure to dump.
416 *
417 * RETURN:
418 *
419 * DESCRIPTION: Prints out the various members of the Data structure type.
420 *
421 ******************************************************************************/
422
423 void
424 acpi_rs_dump_fixed_memory32 (
425 RESOURCE_DATA *data)
426 {
427 FIXED_MEMORY32_RESOURCE *fixed_memory32_data = (FIXED_MEMORY32_RESOURCE*) data;
428
429
430 acpi_os_printf ("\t32-Bit Fixed Location Memory Range Resource\n");
431
432 acpi_os_printf ("\t\t_read%s\n",
433 READ_WRITE_MEMORY ==
434 fixed_memory32_data->read_write_attribute ?
435 "/Write" : " Only");
436
437 acpi_os_printf ("\t\t_range base address: 0x%08x\n",
438 fixed_memory32_data->range_base_address);
439
440 acpi_os_printf ("\t\t_range length: 0x%08x\n",
441 fixed_memory32_data->range_length);
442
443 return;
444 }
445
446
447 /******************************************************************************
448 *
449 * FUNCTION: Acpi_rs_dump_address16
450 *
451 * PARAMETERS: Data - pointer to the resource structure to dump.
452 *
453 * RETURN:
454 *
455 * DESCRIPTION: Prints out the various members of the Data structure type.
456 *
457 ******************************************************************************/
458
459 void
460 acpi_rs_dump_address16 (
461 RESOURCE_DATA *data)
462 {
463 ADDRESS16_RESOURCE *address16_data = (ADDRESS16_RESOURCE*) data;
464
465
466 acpi_os_printf ("\t16-Bit Address Space Resource\n");
467 acpi_os_printf ("\t\t_resource Type: ");
468
469 switch (address16_data->resource_type)
470 {
471 case MEMORY_RANGE:
472
473 acpi_os_printf ("Memory Range\n");
474
475 switch (address16_data->attribute.memory.cache_attribute)
476 {
477 case NON_CACHEABLE_MEMORY:
478 acpi_os_printf ("\t\t_type Specific: "
479 "Noncacheable memory\n");
480 break;
481
482 case CACHABLE_MEMORY:
483 acpi_os_printf ("\t\t_type Specific: "
484 "Cacheable memory\n");
485 break;
486
487 case WRITE_COMBINING_MEMORY:
488 acpi_os_printf ("\t\t_type Specific: "
489 "Write-combining memory\n");
490 break;
491
492 case PREFETCHABLE_MEMORY:
493 acpi_os_printf ("\t\t_type Specific: "
494 "Prefetchable memory\n");
495 break;
496
497 default:
498 acpi_os_printf ("\t\t_type Specific: "
499 "Invalid cache attribute\n");
500 break;
501 }
502
503 acpi_os_printf ("\t\t_type Specific: Read%s\n",
504 READ_WRITE_MEMORY ==
505 address16_data->attribute.memory.read_write_attribute ?
506 "/Write" : " Only");
507 break;
508
509 case IO_RANGE:
510
511 acpi_os_printf ("I/O Range\n");
512
513 switch (address16_data->attribute.io.range_attribute)
514 {
515 case NON_ISA_ONLY_RANGES:
516 acpi_os_printf ("\t\t_type Specific: "
517 "Non-ISA Io Addresses\n");
518 break;
519
520 case ISA_ONLY_RANGES:
521 acpi_os_printf ("\t\t_type Specific: "
522 "ISA Io Addresses\n");
523 break;
524
525 case ENTIRE_RANGE:
526 acpi_os_printf ("\t\t_type Specific: "
527 "ISA and non-ISA Io Addresses\n");
528 break;
529
530 default:
531 acpi_os_printf ("\t\t_type Specific: "
532 "Invalid range attribute\n");
533 break;
534 }
535 break;
536
537 case BUS_NUMBER_RANGE:
538
539 acpi_os_printf ("Bus Number Range\n");
540 break;
541
542 default:
543
544 acpi_os_printf ("Invalid resource type. Exiting.\n");
545 return;
546 }
547
548 acpi_os_printf ("\t\t_resource %s\n",
549 CONSUMER == address16_data->producer_consumer ?
550 "Consumer" : "Producer");
551
552 acpi_os_printf ("\t\t%s decode\n",
553 SUB_DECODE == address16_data->decode ?
554 "Subtractive" : "Positive");
555
556 acpi_os_printf ("\t\t_min address is %s fixed\n",
557 ADDRESS_FIXED == address16_data->min_address_fixed ?
558 "" : "not");
559
560 acpi_os_printf ("\t\t_max address is %s fixed\n",
561 ADDRESS_FIXED == address16_data->max_address_fixed ?
562 "" : "not");
563
564 acpi_os_printf ("\t\t_granularity: 0x%08x\n",
565 address16_data->granularity);
566
567 acpi_os_printf ("\t\t_address range min: 0x%08x\n",
568 address16_data->min_address_range);
569
570 acpi_os_printf ("\t\t_address range max: 0x%08x\n",
571 address16_data->max_address_range);
572
573 acpi_os_printf ("\t\t_address translation offset: 0x%08x\n",
574 address16_data->address_translation_offset);
575
576 acpi_os_printf ("\t\t_address Length: 0x%08x\n",
577 address16_data->address_length);
578
579 if (0xFF != address16_data->resource_source_index) {
580 acpi_os_printf ("\t\t_resource Source Index: %d\n",
581 address16_data->resource_source_index);
582 acpi_os_printf ("\t\t_resource Source: %s\n",
583 address16_data->resource_source);
584 }
585
586 return;
587 }
588
589
590 /******************************************************************************
591 *
592 * FUNCTION: Acpi_rs_dump_address32
593 *
594 * PARAMETERS: Data - pointer to the resource structure to dump.
595 *
596 * RETURN:
597 *
598 * DESCRIPTION: Prints out the various members of the Data structure type.
599 *
600 ******************************************************************************/
601
602 void
603 acpi_rs_dump_address32 (
604 RESOURCE_DATA *data)
605 {
606 ADDRESS32_RESOURCE *address32_data = (ADDRESS32_RESOURCE*) data;
607
608
609 acpi_os_printf ("\t32-Bit Address Space Resource\n");
610
611 switch (address32_data->resource_type)
612 {
613 case MEMORY_RANGE:
614
615 acpi_os_printf ("\t\t_resource Type: Memory Range\n");
616
617 switch (address32_data->attribute.memory.cache_attribute)
618 {
619 case NON_CACHEABLE_MEMORY:
620 acpi_os_printf ("\t\t_type Specific: "
621 "Noncacheable memory\n");
622 break;
623
624 case CACHABLE_MEMORY:
625 acpi_os_printf ("\t\t_type Specific: "
626 "Cacheable memory\n");
627 break;
628
629 case WRITE_COMBINING_MEMORY:
630 acpi_os_printf ("\t\t_type Specific: "
631 "Write-combining memory\n");
632 break;
633
634 case PREFETCHABLE_MEMORY:
635 acpi_os_printf ("\t\t_type Specific: "
636 "Prefetchable memory\n");
637 break;
638
639 default:
640 acpi_os_printf ("\t\t_type Specific: "
641 "Invalid cache attribute\n");
642 break;
643 }
644
645 acpi_os_printf ("\t\t_type Specific: Read%s\n",
646 READ_WRITE_MEMORY ==
647 address32_data->attribute.memory.read_write_attribute ?
648 "/Write" : " Only");
649 break;
650
651 case IO_RANGE:
652
653 acpi_os_printf ("\t\t_resource Type: Io Range\n");
654
655 switch (address32_data->attribute.io.range_attribute)
656 {
657 case NON_ISA_ONLY_RANGES:
658 acpi_os_printf ("\t\t_type Specific: "
659 "Non-ISA Io Addresses\n");
660 break;
661
662 case ISA_ONLY_RANGES:
663 acpi_os_printf ("\t\t_type Specific: "
664 "ISA Io Addresses\n");
665 break;
666
667 case ENTIRE_RANGE:
668 acpi_os_printf ("\t\t_type Specific: "
669 "ISA and non-ISA Io Addresses\n");
670 break;
671
672 default:
673 acpi_os_printf ("\t\t_type Specific: "
674 "Invalid Range attribute");
675 break;
676 }
677 break;
678
679 case BUS_NUMBER_RANGE:
680
681 acpi_os_printf ("\t\t_resource Type: Bus Number Range\n");
682 break;
683
684 default:
685
686 acpi_os_printf ("\t\t_invalid Resource Type..exiting.\n");
687 return;
688 }
689
690 acpi_os_printf ("\t\t_resource %s\n",
691 CONSUMER == address32_data->producer_consumer ?
692 "Consumer" : "Producer");
693
694 acpi_os_printf ("\t\t%s decode\n",
695 SUB_DECODE == address32_data->decode ?
696 "Subtractive" : "Positive");
697
698 acpi_os_printf ("\t\t_min address is %s fixed\n",
699 ADDRESS_FIXED == address32_data->min_address_fixed ?
700 "" : "not ");
701
702 acpi_os_printf ("\t\t_max address is %s fixed\n",
703 ADDRESS_FIXED == address32_data->max_address_fixed ?
704 "" : "not ");
705
706 acpi_os_printf ("\t\t_granularity: 0x%08x\n",
707 address32_data->granularity);
708
709 acpi_os_printf ("\t\t_address range min: 0x%08x\n",
710 address32_data->min_address_range);
711
712 acpi_os_printf ("\t\t_address range max: 0x%08x\n",
713 address32_data->max_address_range);
714
715 acpi_os_printf ("\t\t_address translation offset: 0x%08x\n",
716 address32_data->address_translation_offset);
717
718 acpi_os_printf ("\t\t_address Length: 0x%08x\n",
719 address32_data->address_length);
720
721 if(0xFF != address32_data->resource_source_index) {
722 acpi_os_printf ("\t\t_resource Source Index: %d\n",
723 address32_data->resource_source_index);
724 acpi_os_printf ("\t\t_resource Source: %s\n",
725 address32_data->resource_source);
726 }
727
728 return;
729 }
730
731
732 /******************************************************************************
733 *
734 * FUNCTION: Acpi_rs_dump_extended_irq
735 *
736 * PARAMETERS: Data - pointer to the resource structure to dump.
737 *
738 * RETURN:
739 *
740 * DESCRIPTION: Prints out the various members of the Data structure type.
741 *
742 ******************************************************************************/
743
744 void
745 acpi_rs_dump_extended_irq (
746 RESOURCE_DATA *data)
747 {
748 EXTENDED_IRQ_RESOURCE *ext_irq_data = (EXTENDED_IRQ_RESOURCE*) data;
749 u8 index = 0;
750
751
752 acpi_os_printf ("\t_extended IRQ Resource\n");
753
754 acpi_os_printf ("\t\t_resource %s\n",
755 CONSUMER == ext_irq_data->producer_consumer ?
756 "Consumer" : "Producer");
757
758 acpi_os_printf ("\t\t%s\n",
759 LEVEL_SENSITIVE == ext_irq_data->edge_level ?
760 "Level" : "Edge");
761
762 acpi_os_printf ("\t\t_active %s\n",
763 ACTIVE_LOW == ext_irq_data->active_high_low ?
764 "low" : "high");
765
766 acpi_os_printf ("\t\t%s\n",
767 SHARED == ext_irq_data->shared_exclusive ?
768 "Shared" : "Exclusive");
769
770 acpi_os_printf ("\t\t_interrupts : %d ( ",
771 ext_irq_data->number_of_interrupts);
772
773 for (index = 0; index < ext_irq_data->number_of_interrupts; index++) {
774 acpi_os_printf ("%d ", ext_irq_data->interrupts[index]);
775 }
776
777 acpi_os_printf (")\n");
778
779 if(0xFF != ext_irq_data->resource_source_index) {
780 acpi_os_printf ("\t\t_resource Source Index: %d",
781 ext_irq_data->resource_source_index);
782 acpi_os_printf ("\t\t_resource Source: %s",
783 ext_irq_data->resource_source);
784 }
785
786 return;
787 }
788
789
790 /******************************************************************************
791 *
792 * FUNCTION: Acpi_rs_dump_resource_list
793 *
794 * PARAMETERS: Data - pointer to the resource structure to dump.
795 *
796 * RETURN:
797 *
798 * DESCRIPTION: Dispatches the structure to the correct dump routine.
799 *
800 ******************************************************************************/
801
802 void
803 acpi_rs_dump_resource_list (
804 RESOURCE *resource)
805 {
806 u8 count = 0;
807 u8 done = FALSE;
808
809
810 if (acpi_dbg_level & TRACE_RESOURCES && _COMPONENT & acpi_dbg_layer) {
811 while (!done) {
812 acpi_os_printf ("\t_resource structure %x.\n", count++);
813
814 switch (resource->id)
815 {
816 case irq:
817 acpi_rs_dump_irq (&resource->data);
818 break;
819
820 case dma:
821 acpi_rs_dump_dma (&resource->data);
822 break;
823
824 case start_dependent_functions:
825 acpi_rs_dump_start_dependent_functions (&resource->data);
826 break;
827
828 case end_dependent_functions:
829 acpi_os_printf ("\t_end_dependent_functions Resource\n");
830 /* Acpi_rs_dump_end_dependent_functions (Resource->Data);*/
831 break;
832
833 case io:
834 acpi_rs_dump_io (&resource->data);
835 break;
836
837 case fixed_io:
838 acpi_rs_dump_fixed_io (&resource->data);
839 break;
840
841 case vendor_specific:
842 acpi_rs_dump_vendor_specific (&resource->data);
843 break;
844
845 case end_tag:
846 /*Rs_dump_end_tag (Resource->Data);*/
847 acpi_os_printf ("\t_end_tag Resource\n");
848 done = TRUE;
849 break;
850
851 case memory24:
852 acpi_rs_dump_memory24 (&resource->data);
853 break;
854
855 case memory32:
856 acpi_rs_dump_memory32 (&resource->data);
857 break;
858
859 case fixed_memory32:
860 acpi_rs_dump_fixed_memory32 (&resource->data);
861 break;
862
863 case address16:
864 acpi_rs_dump_address16 (&resource->data);
865 break;
866
867 case address32:
868 acpi_rs_dump_address32 (&resource->data);
869 break;
870
871 case extended_irq:
872 acpi_rs_dump_extended_irq (&resource->data);
873 break;
874
875 default:
876 acpi_os_printf ("Invalid resource type\n");
877 break;
878
879 }
880
881 resource = (RESOURCE *) ((NATIVE_UINT) resource +
882 (NATIVE_UINT) resource->length);
883 }
884 }
885
886 return;
887 }
888
889 /******************************************************************************
890 *
891 * FUNCTION: Acpi_rs_dump_irq_list
892 *
893 * PARAMETERS: Data - pointer to the routing table to dump.
894 *
895 * RETURN:
896 *
897 * DESCRIPTION: Dispatches the structures to the correct dump routine.
898 *
899 ******************************************************************************/
900
901 void
902 acpi_rs_dump_irq_list (
903 u8 *route_table)
904 {
905 u8 *buffer = route_table;
906 u8 count = 0;
907 u8 done = FALSE;
908 PCI_ROUTING_TABLE *prt_element;
909
910
911 if (acpi_dbg_level & TRACE_RESOURCES && _COMPONENT & acpi_dbg_layer) {
912 prt_element = (PCI_ROUTING_TABLE *)buffer;
913
914 while (!done) {
915 acpi_os_printf ("\t_pCI IRQ Routing Table structure %x.\n", count++);
916
917 acpi_os_printf ("\t\t_address: 0x%x\n",
918 prt_element->data.address);
919
920 acpi_os_printf ("\t\t_pin: 0x%x\n", prt_element->data.pin);
921
922 acpi_os_printf ("\t\t_source: %s\n", prt_element->data.source);
923
924 acpi_os_printf ("\t\t_source_index: 0x%x\n",
925 prt_element->data.source_index);
926
927 buffer += prt_element->length;
928
929 prt_element = (PCI_ROUTING_TABLE *)buffer;
930
931 if(0 == prt_element->length) {
932 done = TRUE;
933 }
934 }
935 }
936
937 return;
938 }
939
Copy of Dave Jones history.git as used by http://archive.org/details/git-history-of-linux