Commit | Line | Data |
---|---|---|
1da177e4 LT |
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 | ||
45 | #include <acpi/acpi.h> | |
46 | #include <acpi/acresrc.h> | |
47 | ||
48 | #define _COMPONENT ACPI_RESOURCES | |
49 | ACPI_MODULE_NAME ("rsdump") | |
50 | ||
51 | ||
52 | #if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER) | |
53 | ||
54 | /******************************************************************************* | |
55 | * | |
56 | * FUNCTION: acpi_rs_dump_irq | |
57 | * | |
58 | * PARAMETERS: Data - pointer to the resource structure to dump. | |
59 | * | |
60 | * RETURN: None | |
61 | * | |
62 | * DESCRIPTION: Prints out the various members of the Data structure type. | |
63 | * | |
64 | ******************************************************************************/ | |
65 | ||
66 | void | |
67 | acpi_rs_dump_irq ( | |
68 | union acpi_resource_data *data) | |
69 | { | |
70 | struct acpi_resource_irq *irq_data = (struct acpi_resource_irq *) data; | |
71 | u8 index = 0; | |
72 | ||
73 | ||
74 | ACPI_FUNCTION_ENTRY (); | |
75 | ||
76 | ||
77 | acpi_os_printf ("IRQ Resource\n"); | |
78 | ||
79 | acpi_os_printf (" %s Triggered\n", | |
80 | ACPI_LEVEL_SENSITIVE == irq_data->edge_level ? "Level" : "Edge"); | |
81 | ||
82 | acpi_os_printf (" Active %s\n", | |
83 | ACPI_ACTIVE_LOW == irq_data->active_high_low ? "Low" : "High"); | |
84 | ||
85 | acpi_os_printf (" %s\n", | |
86 | ACPI_SHARED == irq_data->shared_exclusive ? "Shared" : "Exclusive"); | |
87 | ||
88 | acpi_os_printf (" %X Interrupts ( ", irq_data->number_of_interrupts); | |
89 | ||
90 | for (index = 0; index < irq_data->number_of_interrupts; index++) { | |
91 | acpi_os_printf ("%X ", irq_data->interrupts[index]); | |
92 | } | |
93 | ||
94 | acpi_os_printf (")\n"); | |
95 | return; | |
96 | } | |
97 | ||
98 | ||
99 | /******************************************************************************* | |
100 | * | |
101 | * FUNCTION: acpi_rs_dump_dma | |
102 | * | |
103 | * PARAMETERS: Data - pointer to the resource structure to dump. | |
104 | * | |
105 | * RETURN: None | |
106 | * | |
107 | * DESCRIPTION: Prints out the various members of the Data structure type. | |
108 | * | |
109 | ******************************************************************************/ | |
110 | ||
111 | void | |
112 | acpi_rs_dump_dma ( | |
113 | union acpi_resource_data *data) | |
114 | { | |
115 | struct acpi_resource_dma *dma_data = (struct acpi_resource_dma *) data; | |
116 | u8 index = 0; | |
117 | ||
118 | ||
119 | ACPI_FUNCTION_ENTRY (); | |
120 | ||
121 | ||
122 | acpi_os_printf ("DMA Resource\n"); | |
123 | ||
124 | switch (dma_data->type) { | |
125 | case ACPI_COMPATIBILITY: | |
126 | acpi_os_printf (" Compatibility mode\n"); | |
127 | break; | |
128 | ||
129 | case ACPI_TYPE_A: | |
130 | acpi_os_printf (" Type A\n"); | |
131 | break; | |
132 | ||
133 | case ACPI_TYPE_B: | |
134 | acpi_os_printf (" Type B\n"); | |
135 | break; | |
136 | ||
137 | case ACPI_TYPE_F: | |
138 | acpi_os_printf (" Type F\n"); | |
139 | break; | |
140 | ||
141 | default: | |
142 | acpi_os_printf (" Invalid DMA type\n"); | |
143 | break; | |
144 | } | |
145 | ||
146 | acpi_os_printf (" %sBus Master\n", | |
147 | ACPI_BUS_MASTER == dma_data->bus_master ? "" : "Not a "); | |
148 | ||
149 | ||
150 | switch (dma_data->transfer) { | |
151 | case ACPI_TRANSFER_8: | |
152 | acpi_os_printf (" 8-bit only transfer\n"); | |
153 | break; | |
154 | ||
155 | case ACPI_TRANSFER_8_16: | |
156 | acpi_os_printf (" 8 and 16-bit transfer\n"); | |
157 | break; | |
158 | ||
159 | case ACPI_TRANSFER_16: | |
160 | acpi_os_printf (" 16 bit only transfer\n"); | |
161 | break; | |
162 | ||
163 | default: | |
164 | acpi_os_printf (" Invalid transfer preference\n"); | |
165 | break; | |
166 | } | |
167 | ||
168 | acpi_os_printf (" Number of Channels: %X ( ", dma_data->number_of_channels); | |
169 | ||
170 | for (index = 0; index < dma_data->number_of_channels; index++) { | |
171 | acpi_os_printf ("%X ", dma_data->channels[index]); | |
172 | } | |
173 | ||
174 | acpi_os_printf (")\n"); | |
175 | return; | |
176 | } | |
177 | ||
178 | ||
179 | /******************************************************************************* | |
180 | * | |
181 | * FUNCTION: acpi_rs_dump_start_depend_fns | |
182 | * | |
183 | * PARAMETERS: Data - pointer to the resource structure to dump. | |
184 | * | |
185 | * RETURN: None | |
186 | * | |
187 | * DESCRIPTION: Prints out the various members of the Data structure type. | |
188 | * | |
189 | ******************************************************************************/ | |
190 | ||
191 | void | |
192 | acpi_rs_dump_start_depend_fns ( | |
193 | union acpi_resource_data *data) | |
194 | { | |
195 | struct acpi_resource_start_dpf *sdf_data = (struct acpi_resource_start_dpf *) data; | |
196 | ||
197 | ||
198 | ACPI_FUNCTION_ENTRY (); | |
199 | ||
200 | ||
201 | acpi_os_printf ("Start Dependent Functions Resource\n"); | |
202 | ||
203 | switch (sdf_data->compatibility_priority) { | |
204 | case ACPI_GOOD_CONFIGURATION: | |
205 | acpi_os_printf (" Good configuration\n"); | |
206 | break; | |
207 | ||
208 | case ACPI_ACCEPTABLE_CONFIGURATION: | |
209 | acpi_os_printf (" Acceptable configuration\n"); | |
210 | break; | |
211 | ||
212 | case ACPI_SUB_OPTIMAL_CONFIGURATION: | |
213 | acpi_os_printf (" Sub-optimal configuration\n"); | |
214 | break; | |
215 | ||
216 | default: | |
217 | acpi_os_printf (" Invalid compatibility priority\n"); | |
218 | break; | |
219 | } | |
220 | ||
221 | switch(sdf_data->performance_robustness) { | |
222 | case ACPI_GOOD_CONFIGURATION: | |
223 | acpi_os_printf (" Good configuration\n"); | |
224 | break; | |
225 | ||
226 | case ACPI_ACCEPTABLE_CONFIGURATION: | |
227 | acpi_os_printf (" Acceptable configuration\n"); | |
228 | break; | |
229 | ||
230 | case ACPI_SUB_OPTIMAL_CONFIGURATION: | |
231 | acpi_os_printf (" Sub-optimal configuration\n"); | |
232 | break; | |
233 | ||
234 | default: | |
235 | acpi_os_printf (" Invalid performance " | |
236 | "robustness preference\n"); | |
237 | break; | |
238 | } | |
239 | ||
240 | return; | |
241 | } | |
242 | ||
243 | ||
244 | /******************************************************************************* | |
245 | * | |
246 | * FUNCTION: acpi_rs_dump_io | |
247 | * | |
248 | * PARAMETERS: Data - pointer to the resource structure to dump. | |
249 | * | |
250 | * RETURN: None | |
251 | * | |
252 | * DESCRIPTION: Prints out the various members of the Data structure type. | |
253 | * | |
254 | ******************************************************************************/ | |
255 | ||
256 | void | |
257 | acpi_rs_dump_io ( | |
258 | union acpi_resource_data *data) | |
259 | { | |
260 | struct acpi_resource_io *io_data = (struct acpi_resource_io *) data; | |
261 | ||
262 | ||
263 | ACPI_FUNCTION_ENTRY (); | |
264 | ||
265 | ||
266 | acpi_os_printf ("Io Resource\n"); | |
267 | ||
268 | acpi_os_printf (" %d bit decode\n", | |
269 | ACPI_DECODE_16 == io_data->io_decode ? 16 : 10); | |
270 | ||
271 | acpi_os_printf (" Range minimum base: %08X\n", | |
272 | io_data->min_base_address); | |
273 | ||
274 | acpi_os_printf (" Range maximum base: %08X\n", | |
275 | io_data->max_base_address); | |
276 | ||
277 | acpi_os_printf (" Alignment: %08X\n", | |
278 | io_data->alignment); | |
279 | ||
280 | acpi_os_printf (" Range Length: %08X\n", | |
281 | io_data->range_length); | |
282 | ||
283 | return; | |
284 | } | |
285 | ||
286 | ||
287 | /******************************************************************************* | |
288 | * | |
289 | * FUNCTION: acpi_rs_dump_fixed_io | |
290 | * | |
291 | * PARAMETERS: Data - pointer to the resource structure to dump. | |
292 | * | |
293 | * RETURN: None | |
294 | * | |
295 | * DESCRIPTION: Prints out the various members of the Data structure type. | |
296 | * | |
297 | ******************************************************************************/ | |
298 | ||
299 | void | |
300 | acpi_rs_dump_fixed_io ( | |
301 | union acpi_resource_data *data) | |
302 | { | |
303 | struct acpi_resource_fixed_io *fixed_io_data = (struct acpi_resource_fixed_io *) data; | |
304 | ||
305 | ||
306 | ACPI_FUNCTION_ENTRY (); | |
307 | ||
308 | ||
309 | acpi_os_printf ("Fixed Io Resource\n"); | |
310 | acpi_os_printf (" Range base address: %08X", | |
311 | fixed_io_data->base_address); | |
312 | ||
313 | acpi_os_printf (" Range length: %08X", | |
314 | fixed_io_data->range_length); | |
315 | ||
316 | return; | |
317 | } | |
318 | ||
319 | ||
320 | /******************************************************************************* | |
321 | * | |
322 | * FUNCTION: acpi_rs_dump_vendor_specific | |
323 | * | |
324 | * PARAMETERS: Data - pointer to the resource structure to dump. | |
325 | * | |
326 | * RETURN: None | |
327 | * | |
328 | * DESCRIPTION: Prints out the various members of the Data structure type. | |
329 | * | |
330 | ******************************************************************************/ | |
331 | ||
332 | void | |
333 | acpi_rs_dump_vendor_specific ( | |
334 | union acpi_resource_data *data) | |
335 | { | |
336 | struct acpi_resource_vendor *vendor_data = (struct acpi_resource_vendor *) data; | |
337 | u16 index = 0; | |
338 | ||
339 | ||
340 | ACPI_FUNCTION_ENTRY (); | |
341 | ||
342 | ||
343 | acpi_os_printf ("Vendor Specific Resource\n"); | |
344 | ||
345 | acpi_os_printf (" Length: %08X\n", vendor_data->length); | |
346 | ||
347 | for (index = 0; index < vendor_data->length; index++) { | |
348 | acpi_os_printf (" Byte %X: %08X\n", | |
349 | index, vendor_data->reserved[index]); | |
350 | } | |
351 | ||
352 | return; | |
353 | } | |
354 | ||
355 | ||
356 | /******************************************************************************* | |
357 | * | |
358 | * FUNCTION: acpi_rs_dump_memory24 | |
359 | * | |
360 | * PARAMETERS: Data - pointer to the resource structure to dump. | |
361 | * | |
362 | * RETURN: None | |
363 | * | |
364 | * DESCRIPTION: Prints out the various members of the Data structure type. | |
365 | * | |
366 | ******************************************************************************/ | |
367 | ||
368 | void | |
369 | acpi_rs_dump_memory24 ( | |
370 | union acpi_resource_data *data) | |
371 | { | |
372 | struct acpi_resource_mem24 *memory24_data = (struct acpi_resource_mem24 *) data; | |
373 | ||
374 | ||
375 | ACPI_FUNCTION_ENTRY (); | |
376 | ||
377 | ||
378 | acpi_os_printf ("24-Bit Memory Range Resource\n"); | |
379 | ||
380 | acpi_os_printf (" Read%s\n", | |
381 | ACPI_READ_WRITE_MEMORY == | |
382 | memory24_data->read_write_attribute ? | |
383 | "/Write" : " only"); | |
384 | ||
385 | acpi_os_printf (" Range minimum base: %08X\n", | |
386 | memory24_data->min_base_address); | |
387 | ||
388 | acpi_os_printf (" Range maximum base: %08X\n", | |
389 | memory24_data->max_base_address); | |
390 | ||
391 | acpi_os_printf (" Alignment: %08X\n", | |
392 | memory24_data->alignment); | |
393 | ||
394 | acpi_os_printf (" Range length: %08X\n", | |
395 | memory24_data->range_length); | |
396 | ||
397 | return; | |
398 | } | |
399 | ||
400 | ||
401 | /******************************************************************************* | |
402 | * | |
403 | * FUNCTION: acpi_rs_dump_memory32 | |
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 | acpi_rs_dump_memory32 ( | |
415 | union acpi_resource_data *data) | |
416 | { | |
417 | struct acpi_resource_mem32 *memory32_data = (struct acpi_resource_mem32 *) data; | |
418 | ||
419 | ||
420 | ACPI_FUNCTION_ENTRY (); | |
421 | ||
422 | ||
423 | acpi_os_printf ("32-Bit Memory Range Resource\n"); | |
424 | ||
425 | acpi_os_printf (" Read%s\n", | |
426 | ACPI_READ_WRITE_MEMORY == | |
427 | memory32_data->read_write_attribute ? | |
428 | "/Write" : " only"); | |
429 | ||
430 | acpi_os_printf (" Range minimum base: %08X\n", | |
431 | memory32_data->min_base_address); | |
432 | ||
433 | acpi_os_printf (" Range maximum base: %08X\n", | |
434 | memory32_data->max_base_address); | |
435 | ||
436 | acpi_os_printf (" Alignment: %08X\n", | |
437 | memory32_data->alignment); | |
438 | ||
439 | acpi_os_printf (" Range length: %08X\n", | |
440 | memory32_data->range_length); | |
441 | ||
442 | return; | |
443 | } | |
444 | ||
445 | ||
446 | /******************************************************************************* | |
447 | * | |
448 | * FUNCTION: acpi_rs_dump_fixed_memory32 | |
449 | * | |
450 | * PARAMETERS: Data - pointer to the resource structure to dump. | |
451 | * | |
452 | * RETURN: | |
453 | * | |
454 | * DESCRIPTION: Prints out the various members of the Data structure type. | |
455 | * | |
456 | ******************************************************************************/ | |
457 | ||
458 | void | |
459 | acpi_rs_dump_fixed_memory32 ( | |
460 | union acpi_resource_data *data) | |
461 | { | |
462 | struct acpi_resource_fixed_mem32 *fixed_memory32_data = (struct acpi_resource_fixed_mem32 *) data; | |
463 | ||
464 | ||
465 | ACPI_FUNCTION_ENTRY (); | |
466 | ||
467 | ||
468 | acpi_os_printf ("32-Bit Fixed Location Memory Range Resource\n"); | |
469 | ||
470 | acpi_os_printf (" Read%s\n", | |
471 | ACPI_READ_WRITE_MEMORY == | |
472 | fixed_memory32_data->read_write_attribute ? | |
473 | "/Write" : " Only"); | |
474 | ||
475 | acpi_os_printf (" Range base address: %08X\n", | |
476 | fixed_memory32_data->range_base_address); | |
477 | ||
478 | acpi_os_printf (" Range length: %08X\n", | |
479 | fixed_memory32_data->range_length); | |
480 | ||
481 | return; | |
482 | } | |
483 | ||
484 | ||
485 | /******************************************************************************* | |
486 | * | |
487 | * FUNCTION: acpi_rs_dump_address16 | |
488 | * | |
489 | * PARAMETERS: Data - pointer to the resource structure to dump. | |
490 | * | |
491 | * RETURN: None | |
492 | * | |
493 | * DESCRIPTION: Prints out the various members of the Data structure type. | |
494 | * | |
495 | ******************************************************************************/ | |
496 | ||
497 | void | |
498 | acpi_rs_dump_address16 ( | |
499 | union acpi_resource_data *data) | |
500 | { | |
501 | struct acpi_resource_address16 *address16_data = (struct acpi_resource_address16 *) data; | |
502 | ||
503 | ||
504 | ACPI_FUNCTION_ENTRY (); | |
505 | ||
506 | ||
507 | acpi_os_printf ("16-Bit Address Space Resource\n"); | |
508 | acpi_os_printf (" Resource Type: "); | |
509 | ||
510 | switch (address16_data->resource_type) { | |
511 | case ACPI_MEMORY_RANGE: | |
512 | ||
513 | acpi_os_printf ("Memory Range\n"); | |
514 | ||
515 | switch (address16_data->attribute.memory.cache_attribute) { | |
516 | case ACPI_NON_CACHEABLE_MEMORY: | |
517 | acpi_os_printf (" Type Specific: " | |
518 | "Noncacheable memory\n"); | |
519 | break; | |
520 | ||
521 | case ACPI_CACHABLE_MEMORY: | |
522 | acpi_os_printf (" Type Specific: " | |
523 | "Cacheable memory\n"); | |
524 | break; | |
525 | ||
526 | case ACPI_WRITE_COMBINING_MEMORY: | |
527 | acpi_os_printf (" Type Specific: " | |
528 | "Write-combining memory\n"); | |
529 | break; | |
530 | ||
531 | case ACPI_PREFETCHABLE_MEMORY: | |
532 | acpi_os_printf (" Type Specific: " | |
533 | "Prefetchable memory\n"); | |
534 | break; | |
535 | ||
536 | default: | |
537 | acpi_os_printf (" Type Specific: " | |
538 | "Invalid cache attribute\n"); | |
539 | break; | |
540 | } | |
541 | ||
542 | acpi_os_printf (" Type Specific: Read%s\n", | |
543 | ACPI_READ_WRITE_MEMORY == | |
544 | address16_data->attribute.memory.read_write_attribute ? | |
545 | "/Write" : " Only"); | |
546 | break; | |
547 | ||
548 | case ACPI_IO_RANGE: | |
549 | ||
550 | acpi_os_printf ("I/O Range\n"); | |
551 | ||
552 | switch (address16_data->attribute.io.range_attribute) { | |
553 | case ACPI_NON_ISA_ONLY_RANGES: | |
554 | acpi_os_printf (" Type Specific: " | |
555 | "Non-ISA Io Addresses\n"); | |
556 | break; | |
557 | ||
558 | case ACPI_ISA_ONLY_RANGES: | |
559 | acpi_os_printf (" Type Specific: " | |
560 | "ISA Io Addresses\n"); | |
561 | break; | |
562 | ||
563 | case ACPI_ENTIRE_RANGE: | |
564 | acpi_os_printf (" Type Specific: " | |
565 | "ISA and non-ISA Io Addresses\n"); | |
566 | break; | |
567 | ||
568 | default: | |
569 | acpi_os_printf (" Type Specific: " | |
570 | "Invalid range attribute\n"); | |
571 | break; | |
572 | } | |
573 | ||
574 | acpi_os_printf (" Type Specific: %s Translation\n", | |
575 | ACPI_SPARSE_TRANSLATION == | |
576 | address16_data->attribute.io.translation_attribute ? | |
577 | "Sparse" : "Dense"); | |
578 | break; | |
579 | ||
580 | case ACPI_BUS_NUMBER_RANGE: | |
581 | ||
582 | acpi_os_printf ("Bus Number Range\n"); | |
583 | break; | |
584 | ||
585 | default: | |
586 | ||
587 | acpi_os_printf ("0x%2.2X\n", address16_data->resource_type); | |
588 | break; | |
589 | } | |
590 | ||
591 | acpi_os_printf (" Resource %s\n", | |
592 | ACPI_CONSUMER == address16_data->producer_consumer ? | |
593 | "Consumer" : "Producer"); | |
594 | ||
595 | acpi_os_printf (" %s decode\n", | |
596 | ACPI_SUB_DECODE == address16_data->decode ? | |
597 | "Subtractive" : "Positive"); | |
598 | ||
599 | acpi_os_printf (" Min address is %s fixed\n", | |
600 | ACPI_ADDRESS_FIXED == address16_data->min_address_fixed ? | |
601 | "" : "not"); | |
602 | ||
603 | acpi_os_printf (" Max address is %s fixed\n", | |
604 | ACPI_ADDRESS_FIXED == address16_data->max_address_fixed ? | |
605 | "" : "not"); | |
606 | ||
607 | acpi_os_printf (" Granularity: %08X\n", | |
608 | address16_data->granularity); | |
609 | ||
610 | acpi_os_printf (" Address range min: %08X\n", | |
611 | address16_data->min_address_range); | |
612 | ||
613 | acpi_os_printf (" Address range max: %08X\n", | |
614 | address16_data->max_address_range); | |
615 | ||
616 | acpi_os_printf (" Address translation offset: %08X\n", | |
617 | address16_data->address_translation_offset); | |
618 | ||
619 | acpi_os_printf (" Address Length: %08X\n", | |
620 | address16_data->address_length); | |
621 | ||
622 | if (0xFF != address16_data->resource_source.index) { | |
623 | acpi_os_printf (" Resource Source Index: %X\n", | |
624 | address16_data->resource_source.index); | |
625 | acpi_os_printf (" Resource Source: %s\n", | |
626 | address16_data->resource_source.string_ptr); | |
627 | } | |
628 | ||
629 | return; | |
630 | } | |
631 | ||
632 | ||
633 | /******************************************************************************* | |
634 | * | |
635 | * FUNCTION: acpi_rs_dump_address32 | |
636 | * | |
637 | * PARAMETERS: Data - pointer to the resource structure to dump. | |
638 | * | |
639 | * RETURN: None | |
640 | * | |
641 | * DESCRIPTION: Prints out the various members of the Data structure type. | |
642 | * | |
643 | ******************************************************************************/ | |
644 | ||
645 | void | |
646 | acpi_rs_dump_address32 ( | |
647 | union acpi_resource_data *data) | |
648 | { | |
649 | struct acpi_resource_address32 *address32_data = (struct acpi_resource_address32 *) data; | |
650 | ||
651 | ||
652 | ACPI_FUNCTION_ENTRY (); | |
653 | ||
654 | ||
655 | acpi_os_printf ("32-Bit Address Space Resource\n"); | |
656 | ||
657 | switch (address32_data->resource_type) { | |
658 | case ACPI_MEMORY_RANGE: | |
659 | ||
660 | acpi_os_printf (" Resource Type: Memory Range\n"); | |
661 | ||
662 | switch (address32_data->attribute.memory.cache_attribute) { | |
663 | case ACPI_NON_CACHEABLE_MEMORY: | |
664 | acpi_os_printf (" Type Specific: " | |
665 | "Noncacheable memory\n"); | |
666 | break; | |
667 | ||
668 | case ACPI_CACHABLE_MEMORY: | |
669 | acpi_os_printf (" Type Specific: " | |
670 | "Cacheable memory\n"); | |
671 | break; | |
672 | ||
673 | case ACPI_WRITE_COMBINING_MEMORY: | |
674 | acpi_os_printf (" Type Specific: " | |
675 | "Write-combining memory\n"); | |
676 | break; | |
677 | ||
678 | case ACPI_PREFETCHABLE_MEMORY: | |
679 | acpi_os_printf (" Type Specific: " | |
680 | "Prefetchable memory\n"); | |
681 | break; | |
682 | ||
683 | default: | |
684 | acpi_os_printf (" Type Specific: " | |
685 | "Invalid cache attribute\n"); | |
686 | break; | |
687 | } | |
688 | ||
689 | acpi_os_printf (" Type Specific: Read%s\n", | |
690 | ACPI_READ_WRITE_MEMORY == | |
691 | address32_data->attribute.memory.read_write_attribute ? | |
692 | "/Write" : " Only"); | |
693 | break; | |
694 | ||
695 | case ACPI_IO_RANGE: | |
696 | ||
697 | acpi_os_printf (" Resource Type: Io Range\n"); | |
698 | ||
699 | switch (address32_data->attribute.io.range_attribute) { | |
700 | case ACPI_NON_ISA_ONLY_RANGES: | |
701 | acpi_os_printf (" Type Specific: " | |
702 | "Non-ISA Io Addresses\n"); | |
703 | break; | |
704 | ||
705 | case ACPI_ISA_ONLY_RANGES: | |
706 | acpi_os_printf (" Type Specific: " | |
707 | "ISA Io Addresses\n"); | |
708 | break; | |
709 | ||
710 | case ACPI_ENTIRE_RANGE: | |
711 | acpi_os_printf (" Type Specific: " | |
712 | "ISA and non-ISA Io Addresses\n"); | |
713 | break; | |
714 | ||
715 | default: | |
716 | acpi_os_printf (" Type Specific: " | |
717 | "Invalid Range attribute"); | |
718 | break; | |
719 | } | |
720 | ||
721 | acpi_os_printf (" Type Specific: %s Translation\n", | |
722 | ACPI_SPARSE_TRANSLATION == | |
723 | address32_data->attribute.io.translation_attribute ? | |
724 | "Sparse" : "Dense"); | |
725 | break; | |
726 | ||
727 | case ACPI_BUS_NUMBER_RANGE: | |
728 | ||
729 | acpi_os_printf (" Resource Type: Bus Number Range\n"); | |
730 | break; | |
731 | ||
732 | default: | |
733 | ||
734 | acpi_os_printf (" Resource Type: 0x%2.2X\n", address32_data->resource_type); | |
735 | break; | |
736 | } | |
737 | ||
738 | acpi_os_printf (" Resource %s\n", | |
739 | ACPI_CONSUMER == address32_data->producer_consumer ? | |
740 | "Consumer" : "Producer"); | |
741 | ||
742 | acpi_os_printf (" %s decode\n", | |
743 | ACPI_SUB_DECODE == address32_data->decode ? | |
744 | "Subtractive" : "Positive"); | |
745 | ||
746 | acpi_os_printf (" Min address is %s fixed\n", | |
747 | ACPI_ADDRESS_FIXED == address32_data->min_address_fixed ? | |
748 | "" : "not "); | |
749 | ||
750 | acpi_os_printf (" Max address is %s fixed\n", | |
751 | ACPI_ADDRESS_FIXED == address32_data->max_address_fixed ? | |
752 | "" : "not "); | |
753 | ||
754 | acpi_os_printf (" Granularity: %08X\n", | |
755 | address32_data->granularity); | |
756 | ||
757 | acpi_os_printf (" Address range min: %08X\n", | |
758 | address32_data->min_address_range); | |
759 | ||
760 | acpi_os_printf (" Address range max: %08X\n", | |
761 | address32_data->max_address_range); | |
762 | ||
763 | acpi_os_printf (" Address translation offset: %08X\n", | |
764 | address32_data->address_translation_offset); | |
765 | ||
766 | acpi_os_printf (" Address Length: %08X\n", | |
767 | address32_data->address_length); | |
768 | ||
769 | if(0xFF != address32_data->resource_source.index) { | |
770 | acpi_os_printf (" Resource Source Index: %X\n", | |
771 | address32_data->resource_source.index); | |
772 | acpi_os_printf (" Resource Source: %s\n", | |
773 | address32_data->resource_source.string_ptr); | |
774 | } | |
775 | ||
776 | return; | |
777 | } | |
778 | ||
779 | ||
780 | /******************************************************************************* | |
781 | * | |
782 | * FUNCTION: acpi_rs_dump_address64 | |
783 | * | |
784 | * PARAMETERS: Data - pointer to the resource structure to dump. | |
785 | * | |
786 | * RETURN: None | |
787 | * | |
788 | * DESCRIPTION: Prints out the various members of the Data structure type. | |
789 | * | |
790 | ******************************************************************************/ | |
791 | ||
792 | void | |
793 | acpi_rs_dump_address64 ( | |
794 | union acpi_resource_data *data) | |
795 | { | |
796 | struct acpi_resource_address64 *address64_data = (struct acpi_resource_address64 *) data; | |
797 | ||
798 | ||
799 | ACPI_FUNCTION_ENTRY (); | |
800 | ||
801 | ||
802 | acpi_os_printf ("64-Bit Address Space Resource\n"); | |
803 | ||
804 | switch (address64_data->resource_type) { | |
805 | case ACPI_MEMORY_RANGE: | |
806 | ||
807 | acpi_os_printf (" Resource Type: Memory Range\n"); | |
808 | ||
809 | switch (address64_data->attribute.memory.cache_attribute) { | |
810 | case ACPI_NON_CACHEABLE_MEMORY: | |
811 | acpi_os_printf (" Type Specific: " | |
812 | "Noncacheable memory\n"); | |
813 | break; | |
814 | ||
815 | case ACPI_CACHABLE_MEMORY: | |
816 | acpi_os_printf (" Type Specific: " | |
817 | "Cacheable memory\n"); | |
818 | break; | |
819 | ||
820 | case ACPI_WRITE_COMBINING_MEMORY: | |
821 | acpi_os_printf (" Type Specific: " | |
822 | "Write-combining memory\n"); | |
823 | break; | |
824 | ||
825 | case ACPI_PREFETCHABLE_MEMORY: | |
826 | acpi_os_printf (" Type Specific: " | |
827 | "Prefetchable memory\n"); | |
828 | break; | |
829 | ||
830 | default: | |
831 | acpi_os_printf (" Type Specific: " | |
832 | "Invalid cache attribute\n"); | |
833 | break; | |
834 | } | |
835 | ||
836 | acpi_os_printf (" Type Specific: Read%s\n", | |
837 | ACPI_READ_WRITE_MEMORY == | |
838 | address64_data->attribute.memory.read_write_attribute ? | |
839 | "/Write" : " Only"); | |
840 | break; | |
841 | ||
842 | case ACPI_IO_RANGE: | |
843 | ||
844 | acpi_os_printf (" Resource Type: Io Range\n"); | |
845 | ||
846 | switch (address64_data->attribute.io.range_attribute) { | |
847 | case ACPI_NON_ISA_ONLY_RANGES: | |
848 | acpi_os_printf (" Type Specific: " | |
849 | "Non-ISA Io Addresses\n"); | |
850 | break; | |
851 | ||
852 | case ACPI_ISA_ONLY_RANGES: | |
853 | acpi_os_printf (" Type Specific: " | |
854 | "ISA Io Addresses\n"); | |
855 | break; | |
856 | ||
857 | case ACPI_ENTIRE_RANGE: | |
858 | acpi_os_printf (" Type Specific: " | |
859 | "ISA and non-ISA Io Addresses\n"); | |
860 | break; | |
861 | ||
862 | default: | |
863 | acpi_os_printf (" Type Specific: " | |
864 | "Invalid Range attribute"); | |
865 | break; | |
866 | } | |
867 | ||
868 | acpi_os_printf (" Type Specific: %s Translation\n", | |
869 | ACPI_SPARSE_TRANSLATION == | |
870 | address64_data->attribute.io.translation_attribute ? | |
871 | "Sparse" : "Dense"); | |
872 | break; | |
873 | ||
874 | case ACPI_BUS_NUMBER_RANGE: | |
875 | ||
876 | acpi_os_printf (" Resource Type: Bus Number Range\n"); | |
877 | break; | |
878 | ||
879 | default: | |
880 | ||
881 | acpi_os_printf (" Resource Type: 0x%2.2X\n", address64_data->resource_type); | |
882 | break; | |
883 | } | |
884 | ||
885 | acpi_os_printf (" Resource %s\n", | |
886 | ACPI_CONSUMER == address64_data->producer_consumer ? | |
887 | "Consumer" : "Producer"); | |
888 | ||
889 | acpi_os_printf (" %s decode\n", | |
890 | ACPI_SUB_DECODE == address64_data->decode ? | |
891 | "Subtractive" : "Positive"); | |
892 | ||
893 | acpi_os_printf (" Min address is %s fixed\n", | |
894 | ACPI_ADDRESS_FIXED == address64_data->min_address_fixed ? | |
895 | "" : "not "); | |
896 | ||
897 | acpi_os_printf (" Max address is %s fixed\n", | |
898 | ACPI_ADDRESS_FIXED == address64_data->max_address_fixed ? | |
899 | "" : "not "); | |
900 | ||
901 | acpi_os_printf (" Granularity: %8.8X%8.8X\n", | |
902 | ACPI_FORMAT_UINT64 (address64_data->granularity)); | |
903 | ||
904 | acpi_os_printf (" Address range min: %8.8X%8.8X\n", | |
905 | ACPI_FORMAT_UINT64 (address64_data->min_address_range)); | |
906 | ||
907 | acpi_os_printf (" Address range max: %8.8X%8.8X\n", | |
908 | ACPI_FORMAT_UINT64 (address64_data->max_address_range)); | |
909 | ||
910 | acpi_os_printf (" Address translation offset: %8.8X%8.8X\n", | |
911 | ACPI_FORMAT_UINT64 (address64_data->address_translation_offset)); | |
912 | ||
913 | acpi_os_printf (" Address Length: %8.8X%8.8X\n", | |
914 | ACPI_FORMAT_UINT64 (address64_data->address_length)); | |
915 | ||
916 | acpi_os_printf (" Type Specific Attributes: %8.8X%8.8X\n", | |
917 | ACPI_FORMAT_UINT64 (address64_data->type_specific_attributes)); | |
918 | ||
919 | if (0xFF != address64_data->resource_source.index) { | |
920 | acpi_os_printf (" Resource Source Index: %X\n", | |
921 | address64_data->resource_source.index); | |
922 | acpi_os_printf (" Resource Source: %s\n", | |
923 | address64_data->resource_source.string_ptr); | |
924 | } | |
925 | ||
926 | return; | |
927 | } | |
928 | ||
929 | ||
930 | /******************************************************************************* | |
931 | * | |
932 | * FUNCTION: acpi_rs_dump_extended_irq | |
933 | * | |
934 | * PARAMETERS: Data - pointer to the resource structure to dump. | |
935 | * | |
936 | * RETURN: None | |
937 | * | |
938 | * DESCRIPTION: Prints out the various members of the Data structure type. | |
939 | * | |
940 | ******************************************************************************/ | |
941 | ||
942 | void | |
943 | acpi_rs_dump_extended_irq ( | |
944 | union acpi_resource_data *data) | |
945 | { | |
946 | struct acpi_resource_ext_irq *ext_irq_data = (struct acpi_resource_ext_irq *) data; | |
947 | u8 index = 0; | |
948 | ||
949 | ||
950 | ACPI_FUNCTION_ENTRY (); | |
951 | ||
952 | ||
953 | acpi_os_printf ("Extended IRQ Resource\n"); | |
954 | ||
955 | acpi_os_printf (" Resource %s\n", | |
956 | ACPI_CONSUMER == ext_irq_data->producer_consumer ? | |
957 | "Consumer" : "Producer"); | |
958 | ||
959 | acpi_os_printf (" %s\n", | |
960 | ACPI_LEVEL_SENSITIVE == ext_irq_data->edge_level ? | |
961 | "Level" : "Edge"); | |
962 | ||
963 | acpi_os_printf (" Active %s\n", | |
964 | ACPI_ACTIVE_LOW == ext_irq_data->active_high_low ? | |
965 | "low" : "high"); | |
966 | ||
967 | acpi_os_printf (" %s\n", | |
968 | ACPI_SHARED == ext_irq_data->shared_exclusive ? | |
969 | "Shared" : "Exclusive"); | |
970 | ||
971 | acpi_os_printf (" Interrupts : %X ( ", | |
972 | ext_irq_data->number_of_interrupts); | |
973 | ||
974 | for (index = 0; index < ext_irq_data->number_of_interrupts; index++) { | |
975 | acpi_os_printf ("%X ", ext_irq_data->interrupts[index]); | |
976 | } | |
977 | ||
978 | acpi_os_printf (")\n"); | |
979 | ||
980 | if(0xFF != ext_irq_data->resource_source.index) { | |
981 | acpi_os_printf (" Resource Source Index: %X", | |
982 | ext_irq_data->resource_source.index); | |
983 | acpi_os_printf (" Resource Source: %s", | |
984 | ext_irq_data->resource_source.string_ptr); | |
985 | } | |
986 | ||
987 | return; | |
988 | } | |
989 | ||
990 | ||
991 | /******************************************************************************* | |
992 | * | |
993 | * FUNCTION: acpi_rs_dump_resource_list | |
994 | * | |
995 | * PARAMETERS: Data - pointer to the resource structure to dump. | |
996 | * | |
997 | * RETURN: None | |
998 | * | |
999 | * DESCRIPTION: Dispatches the structure to the correct dump routine. | |
1000 | * | |
1001 | ******************************************************************************/ | |
1002 | ||
1003 | void | |
1004 | acpi_rs_dump_resource_list ( | |
1005 | struct acpi_resource *resource) | |
1006 | { | |
1007 | u8 count = 0; | |
1008 | u8 done = FALSE; | |
1009 | ||
1010 | ||
1011 | ACPI_FUNCTION_ENTRY (); | |
1012 | ||
1013 | ||
1014 | if (acpi_dbg_level & ACPI_LV_RESOURCES && _COMPONENT & acpi_dbg_layer) { | |
1015 | while (!done) { | |
1016 | acpi_os_printf ("Resource structure %X.\n", count++); | |
1017 | ||
1018 | switch (resource->id) { | |
1019 | case ACPI_RSTYPE_IRQ: | |
1020 | acpi_rs_dump_irq (&resource->data); | |
1021 | break; | |
1022 | ||
1023 | case ACPI_RSTYPE_DMA: | |
1024 | acpi_rs_dump_dma (&resource->data); | |
1025 | break; | |
1026 | ||
1027 | case ACPI_RSTYPE_START_DPF: | |
1028 | acpi_rs_dump_start_depend_fns (&resource->data); | |
1029 | break; | |
1030 | ||
1031 | case ACPI_RSTYPE_END_DPF: | |
1032 | acpi_os_printf ("end_dependent_functions Resource\n"); | |
1033 | /* acpi_rs_dump_end_dependent_functions (Resource->Data);*/ | |
1034 | break; | |
1035 | ||
1036 | case ACPI_RSTYPE_IO: | |
1037 | acpi_rs_dump_io (&resource->data); | |
1038 | break; | |
1039 | ||
1040 | case ACPI_RSTYPE_FIXED_IO: | |
1041 | acpi_rs_dump_fixed_io (&resource->data); | |
1042 | break; | |
1043 | ||
1044 | case ACPI_RSTYPE_VENDOR: | |
1045 | acpi_rs_dump_vendor_specific (&resource->data); | |
1046 | break; | |
1047 | ||
1048 | case ACPI_RSTYPE_END_TAG: | |
1049 | /*rs_dump_end_tag (Resource->Data);*/ | |
1050 | acpi_os_printf ("end_tag Resource\n"); | |
1051 | done = TRUE; | |
1052 | break; | |
1053 | ||
1054 | case ACPI_RSTYPE_MEM24: | |
1055 | acpi_rs_dump_memory24 (&resource->data); | |
1056 | break; | |
1057 | ||
1058 | case ACPI_RSTYPE_MEM32: | |
1059 | acpi_rs_dump_memory32 (&resource->data); | |
1060 | break; | |
1061 | ||
1062 | case ACPI_RSTYPE_FIXED_MEM32: | |
1063 | acpi_rs_dump_fixed_memory32 (&resource->data); | |
1064 | break; | |
1065 | ||
1066 | case ACPI_RSTYPE_ADDRESS16: | |
1067 | acpi_rs_dump_address16 (&resource->data); | |
1068 | break; | |
1069 | ||
1070 | case ACPI_RSTYPE_ADDRESS32: | |
1071 | acpi_rs_dump_address32 (&resource->data); | |
1072 | break; | |
1073 | ||
1074 | case ACPI_RSTYPE_ADDRESS64: | |
1075 | acpi_rs_dump_address64 (&resource->data); | |
1076 | break; | |
1077 | ||
1078 | case ACPI_RSTYPE_EXT_IRQ: | |
1079 | acpi_rs_dump_extended_irq (&resource->data); | |
1080 | break; | |
1081 | ||
1082 | default: | |
1083 | acpi_os_printf ("Invalid resource type\n"); | |
1084 | break; | |
1085 | ||
1086 | } | |
1087 | ||
1088 | resource = ACPI_PTR_ADD (struct acpi_resource, resource, resource->length); | |
1089 | } | |
1090 | } | |
1091 | ||
1092 | return; | |
1093 | } | |
1094 | ||
1095 | /******************************************************************************* | |
1096 | * | |
1097 | * FUNCTION: acpi_rs_dump_irq_list | |
1098 | * | |
1099 | * PARAMETERS: Data - pointer to the routing table to dump. | |
1100 | * | |
1101 | * RETURN: None | |
1102 | * | |
1103 | * DESCRIPTION: Dispatches the structures to the correct dump routine. | |
1104 | * | |
1105 | ******************************************************************************/ | |
1106 | ||
1107 | void | |
1108 | acpi_rs_dump_irq_list ( | |
1109 | u8 *route_table) | |
1110 | { | |
1111 | u8 *buffer = route_table; | |
1112 | u8 count = 0; | |
1113 | u8 done = FALSE; | |
1114 | struct acpi_pci_routing_table *prt_element; | |
1115 | ||
1116 | ||
1117 | ACPI_FUNCTION_ENTRY (); | |
1118 | ||
1119 | ||
1120 | if (acpi_dbg_level & ACPI_LV_RESOURCES && _COMPONENT & acpi_dbg_layer) { | |
1121 | prt_element = ACPI_CAST_PTR (struct acpi_pci_routing_table, buffer); | |
1122 | ||
1123 | while (!done) { | |
1124 | acpi_os_printf ("PCI IRQ Routing Table structure %X.\n", count++); | |
1125 | ||
1126 | acpi_os_printf (" Address: %8.8X%8.8X\n", | |
1127 | ACPI_FORMAT_UINT64 (prt_element->address)); | |
1128 | ||
1129 | acpi_os_printf (" Pin: %X\n", prt_element->pin); | |
1130 | ||
1131 | acpi_os_printf (" Source: %s\n", prt_element->source); | |
1132 | ||
1133 | acpi_os_printf (" source_index: %X\n", | |
1134 | prt_element->source_index); | |
1135 | ||
1136 | buffer += prt_element->length; | |
1137 | ||
1138 | prt_element = ACPI_CAST_PTR (struct acpi_pci_routing_table, buffer); | |
1139 | ||
1140 | if(0 == prt_element->length) { | |
1141 | done = TRUE; | |
1142 | } | |
1143 | } | |
1144 | } | |
1145 | ||
1146 | return; | |
1147 | } | |
1148 | ||
1149 | #endif | |
1150 |