1/******************************************************************************* 2 * 3 * Module Name: rsdump - Functions to display the resource structures. 4 * 5 ******************************************************************************/ 6 7/* 8 * Copyright (C) 2000 - 2010, Intel Corp. 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 "accommon.h" 46#include "acresrc.h" 47 48#define _COMPONENT ACPI_RESOURCES 49ACPI_MODULE_NAME("rsdump") 50#if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER) 51/* Local prototypes */ 52static void acpi_rs_out_string(char *title, char *value); 53 54static void acpi_rs_out_integer8(char *title, u8 value); 55 56static void acpi_rs_out_integer16(char *title, u16 value); 57 58static void acpi_rs_out_integer32(char *title, u32 value); 59 60static void acpi_rs_out_integer64(char *title, u64 value); 61 62static void acpi_rs_out_title(char *title); 63 64static void acpi_rs_dump_byte_list(u16 length, u8 * data); 65 66static void acpi_rs_dump_dword_list(u8 length, u32 * data); 67 68static void acpi_rs_dump_short_byte_list(u8 length, u8 * data); 69 70static void 71acpi_rs_dump_resource_source(struct acpi_resource_source *resource_source); 72 73static void acpi_rs_dump_address_common(union acpi_resource_data *resource); 74 75static void 76acpi_rs_dump_descriptor(void *resource, struct acpi_rsdump_info *table); 77 78#define ACPI_RSD_OFFSET(f) (u8) ACPI_OFFSET (union acpi_resource_data,f) 79#define ACPI_PRT_OFFSET(f) (u8) ACPI_OFFSET (struct acpi_pci_routing_table,f) 80#define ACPI_RSD_TABLE_SIZE(name) (sizeof(name) / sizeof (struct acpi_rsdump_info)) 81 82/******************************************************************************* 83 * 84 * Resource Descriptor info tables 85 * 86 * Note: The first table entry must be a Title or Literal and must contain 87 * the table length (number of table entries) 88 * 89 ******************************************************************************/ 90 91struct acpi_rsdump_info acpi_rs_dump_irq[7] = { 92 {ACPI_RSD_TITLE, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_irq), "IRQ", NULL}, 93 {ACPI_RSD_UINT8, ACPI_RSD_OFFSET(irq.descriptor_length), 94 "Descriptor Length", NULL}, 95 {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(irq.triggering), "Triggering", 96 acpi_gbl_he_decode}, 97 {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(irq.polarity), "Polarity", 98 acpi_gbl_ll_decode}, 99 {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(irq.sharable), "Sharing", 100 acpi_gbl_shr_decode}, 101 {ACPI_RSD_UINT8, ACPI_RSD_OFFSET(irq.interrupt_count), 102 "Interrupt Count", NULL}, 103 {ACPI_RSD_SHORTLIST, ACPI_RSD_OFFSET(irq.interrupts[0]), 104 "Interrupt List", NULL} 105}; 106 107struct acpi_rsdump_info acpi_rs_dump_dma[6] = { 108 {ACPI_RSD_TITLE, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_dma), "DMA", NULL}, 109 {ACPI_RSD_2BITFLAG, ACPI_RSD_OFFSET(dma.type), "Speed", 110 acpi_gbl_typ_decode}, 111 {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(dma.bus_master), "Mastering", 112 acpi_gbl_bm_decode}, 113 {ACPI_RSD_2BITFLAG, ACPI_RSD_OFFSET(dma.transfer), "Transfer Type", 114 acpi_gbl_siz_decode}, 115 {ACPI_RSD_UINT8, ACPI_RSD_OFFSET(dma.channel_count), "Channel Count", 116 NULL}, 117 {ACPI_RSD_SHORTLIST, ACPI_RSD_OFFSET(dma.channels[0]), "Channel List", 118 NULL} 119}; 120 121struct acpi_rsdump_info acpi_rs_dump_start_dpf[4] = { 122 {ACPI_RSD_TITLE, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_start_dpf), 123 "Start-Dependent-Functions", NULL}, 124 {ACPI_RSD_UINT8, ACPI_RSD_OFFSET(start_dpf.descriptor_length), 125 "Descriptor Length", NULL}, 126 {ACPI_RSD_2BITFLAG, ACPI_RSD_OFFSET(start_dpf.compatibility_priority), 127 "Compatibility Priority", acpi_gbl_config_decode}, 128 {ACPI_RSD_2BITFLAG, ACPI_RSD_OFFSET(start_dpf.performance_robustness), 129 "Performance/Robustness", acpi_gbl_config_decode} 130}; 131 132struct acpi_rsdump_info acpi_rs_dump_end_dpf[1] = { 133 {ACPI_RSD_TITLE, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_end_dpf), 134 "End-Dependent-Functions", NULL} 135}; 136 137struct acpi_rsdump_info acpi_rs_dump_io[6] = { 138 {ACPI_RSD_TITLE, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_io), "I/O", NULL}, 139 {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(io.io_decode), "Address Decoding", 140 acpi_gbl_io_decode}, 141 {ACPI_RSD_UINT16, ACPI_RSD_OFFSET(io.minimum), "Address Minimum", NULL}, 142 {ACPI_RSD_UINT16, ACPI_RSD_OFFSET(io.maximum), "Address Maximum", NULL}, 143 {ACPI_RSD_UINT8, ACPI_RSD_OFFSET(io.alignment), "Alignment", NULL}, 144 {ACPI_RSD_UINT8, ACPI_RSD_OFFSET(io.address_length), "Address Length", 145 NULL} 146}; 147 148struct acpi_rsdump_info acpi_rs_dump_fixed_io[3] = { 149 {ACPI_RSD_TITLE, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_fixed_io), 150 "Fixed I/O", NULL}, 151 {ACPI_RSD_UINT16, ACPI_RSD_OFFSET(fixed_io.address), "Address", NULL}, 152 {ACPI_RSD_UINT8, ACPI_RSD_OFFSET(fixed_io.address_length), 153 "Address Length", NULL} 154}; 155 156struct acpi_rsdump_info acpi_rs_dump_vendor[3] = { 157 {ACPI_RSD_TITLE, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_vendor), 158 "Vendor Specific", NULL}, 159 {ACPI_RSD_UINT16, ACPI_RSD_OFFSET(vendor.byte_length), "Length", NULL}, 160 {ACPI_RSD_LONGLIST, ACPI_RSD_OFFSET(vendor.byte_data[0]), "Vendor Data", 161 NULL} 162}; 163 164struct acpi_rsdump_info acpi_rs_dump_end_tag[1] = { 165 {ACPI_RSD_TITLE, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_end_tag), "EndTag", 166 NULL} 167}; 168 169struct acpi_rsdump_info acpi_rs_dump_memory24[6] = { 170 {ACPI_RSD_TITLE, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_memory24), 171 "24-Bit Memory Range", NULL}, 172 {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(memory24.write_protect), 173 "Write Protect", acpi_gbl_rw_decode}, 174 {ACPI_RSD_UINT16, ACPI_RSD_OFFSET(memory24.minimum), "Address Minimum", 175 NULL}, 176 {ACPI_RSD_UINT16, ACPI_RSD_OFFSET(memory24.maximum), "Address Maximum", 177 NULL}, 178 {ACPI_RSD_UINT16, ACPI_RSD_OFFSET(memory24.alignment), "Alignment", 179 NULL}, 180 {ACPI_RSD_UINT16, ACPI_RSD_OFFSET(memory24.address_length), 181 "Address Length", NULL} 182}; 183 184struct acpi_rsdump_info acpi_rs_dump_memory32[6] = { 185 {ACPI_RSD_TITLE, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_memory32), 186 "32-Bit Memory Range", NULL}, 187 {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(memory32.write_protect), 188 "Write Protect", acpi_gbl_rw_decode}, 189 {ACPI_RSD_UINT32, ACPI_RSD_OFFSET(memory32.minimum), "Address Minimum", 190 NULL}, 191 {ACPI_RSD_UINT32, ACPI_RSD_OFFSET(memory32.maximum), "Address Maximum", 192 NULL}, 193 {ACPI_RSD_UINT32, ACPI_RSD_OFFSET(memory32.alignment), "Alignment", 194 NULL}, 195 {ACPI_RSD_UINT32, ACPI_RSD_OFFSET(memory32.address_length), 196 "Address Length", NULL} 197}; 198 199struct acpi_rsdump_info acpi_rs_dump_fixed_memory32[4] = { 200 {ACPI_RSD_TITLE, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_fixed_memory32), 201 "32-Bit Fixed Memory Range", NULL}, 202 {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(fixed_memory32.write_protect), 203 "Write Protect", acpi_gbl_rw_decode}, 204 {ACPI_RSD_UINT32, ACPI_RSD_OFFSET(fixed_memory32.address), "Address", 205 NULL}, 206 {ACPI_RSD_UINT32, ACPI_RSD_OFFSET(fixed_memory32.address_length), 207 "Address Length", NULL} 208}; 209 210struct acpi_rsdump_info acpi_rs_dump_address16[8] = { 211 {ACPI_RSD_TITLE, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_address16), 212 "16-Bit WORD Address Space", NULL}, 213 {ACPI_RSD_ADDRESS, 0, NULL, NULL}, 214 {ACPI_RSD_UINT16, ACPI_RSD_OFFSET(address16.granularity), "Granularity", 215 NULL}, 216 {ACPI_RSD_UINT16, ACPI_RSD_OFFSET(address16.minimum), "Address Minimum", 217 NULL}, 218 {ACPI_RSD_UINT16, ACPI_RSD_OFFSET(address16.maximum), "Address Maximum", 219 NULL}, 220 {ACPI_RSD_UINT16, ACPI_RSD_OFFSET(address16.translation_offset), 221 "Translation Offset", NULL}, 222 {ACPI_RSD_UINT16, ACPI_RSD_OFFSET(address16.address_length), 223 "Address Length", NULL}, 224 {ACPI_RSD_SOURCE, ACPI_RSD_OFFSET(address16.resource_source), NULL, NULL} 225}; 226 227struct acpi_rsdump_info acpi_rs_dump_address32[8] = { 228 {ACPI_RSD_TITLE, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_address32), 229 "32-Bit DWORD Address Space", NULL}, 230 {ACPI_RSD_ADDRESS, 0, NULL, NULL}, 231 {ACPI_RSD_UINT32, ACPI_RSD_OFFSET(address32.granularity), "Granularity", 232 NULL}, 233 {ACPI_RSD_UINT32, ACPI_RSD_OFFSET(address32.minimum), "Address Minimum", 234 NULL}, 235 {ACPI_RSD_UINT32, ACPI_RSD_OFFSET(address32.maximum), "Address Maximum", 236 NULL}, 237 {ACPI_RSD_UINT32, ACPI_RSD_OFFSET(address32.translation_offset), 238 "Translation Offset", NULL}, 239 {ACPI_RSD_UINT32, ACPI_RSD_OFFSET(address32.address_length), 240 "Address Length", NULL}, 241 {ACPI_RSD_SOURCE, ACPI_RSD_OFFSET(address32.resource_source), NULL, NULL} 242}; 243 244struct acpi_rsdump_info acpi_rs_dump_address64[8] = { 245 {ACPI_RSD_TITLE, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_address64), 246 "64-Bit QWORD Address Space", NULL}, 247 {ACPI_RSD_ADDRESS, 0, NULL, NULL}, 248 {ACPI_RSD_UINT64, ACPI_RSD_OFFSET(address64.granularity), "Granularity", 249 NULL}, 250 {ACPI_RSD_UINT64, ACPI_RSD_OFFSET(address64.minimum), "Address Minimum", 251 NULL}, 252 {ACPI_RSD_UINT64, ACPI_RSD_OFFSET(address64.maximum), "Address Maximum", 253 NULL}, 254 {ACPI_RSD_UINT64, ACPI_RSD_OFFSET(address64.translation_offset), 255 "Translation Offset", NULL}, 256 {ACPI_RSD_UINT64, ACPI_RSD_OFFSET(address64.address_length), 257 "Address Length", NULL}, 258 {ACPI_RSD_SOURCE, ACPI_RSD_OFFSET(address64.resource_source), NULL, NULL} 259}; 260 261struct acpi_rsdump_info acpi_rs_dump_ext_address64[8] = { 262 {ACPI_RSD_TITLE, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_ext_address64), 263 "64-Bit Extended Address Space", NULL}, 264 {ACPI_RSD_ADDRESS, 0, NULL, NULL}, 265 {ACPI_RSD_UINT64, ACPI_RSD_OFFSET(ext_address64.granularity), 266 "Granularity", NULL}, 267 {ACPI_RSD_UINT64, ACPI_RSD_OFFSET(ext_address64.minimum), 268 "Address Minimum", NULL}, 269 {ACPI_RSD_UINT64, ACPI_RSD_OFFSET(ext_address64.maximum), 270 "Address Maximum", NULL}, 271 {ACPI_RSD_UINT64, ACPI_RSD_OFFSET(ext_address64.translation_offset), 272 "Translation Offset", NULL}, 273 {ACPI_RSD_UINT64, ACPI_RSD_OFFSET(ext_address64.address_length), 274 "Address Length", NULL}, 275 {ACPI_RSD_UINT64, ACPI_RSD_OFFSET(ext_address64.type_specific), 276 "Type-Specific Attribute", NULL} 277}; 278 279struct acpi_rsdump_info acpi_rs_dump_ext_irq[8] = { 280 {ACPI_RSD_TITLE, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_ext_irq), 281 "Extended IRQ", NULL}, 282 {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(extended_irq.producer_consumer), 283 "Type", acpi_gbl_consume_decode}, 284 {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(extended_irq.triggering), 285 "Triggering", acpi_gbl_he_decode}, 286 {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(extended_irq.polarity), "Polarity", 287 acpi_gbl_ll_decode}, 288 {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(extended_irq.sharable), "Sharing", 289 acpi_gbl_shr_decode}, 290 {ACPI_RSD_SOURCE, ACPI_RSD_OFFSET(extended_irq.resource_source), NULL, 291 NULL}, 292 {ACPI_RSD_UINT8, ACPI_RSD_OFFSET(extended_irq.interrupt_count), 293 "Interrupt Count", NULL}, 294 {ACPI_RSD_DWORDLIST, ACPI_RSD_OFFSET(extended_irq.interrupts[0]), 295 "Interrupt List", NULL} 296}; 297 298struct acpi_rsdump_info acpi_rs_dump_generic_reg[6] = { 299 {ACPI_RSD_TITLE, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_generic_reg), 300 "Generic Register", NULL}, 301 {ACPI_RSD_UINT8, ACPI_RSD_OFFSET(generic_reg.space_id), "Space ID", 302 NULL}, 303 {ACPI_RSD_UINT8, ACPI_RSD_OFFSET(generic_reg.bit_width), "Bit Width", 304 NULL}, 305 {ACPI_RSD_UINT8, ACPI_RSD_OFFSET(generic_reg.bit_offset), "Bit Offset", 306 NULL}, 307 {ACPI_RSD_UINT8, ACPI_RSD_OFFSET(generic_reg.access_size), 308 "Access Size", NULL}, 309 {ACPI_RSD_UINT64, ACPI_RSD_OFFSET(generic_reg.address), "Address", NULL} 310}; 311 312/* 313 * Tables used for common address descriptor flag fields 314 */ 315static struct acpi_rsdump_info acpi_rs_dump_general_flags[5] = { 316 {ACPI_RSD_TITLE, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_general_flags), NULL, 317 NULL}, 318 {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(address.producer_consumer), 319 "Consumer/Producer", acpi_gbl_consume_decode}, 320 {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(address.decode), "Address Decode", 321 acpi_gbl_dec_decode}, 322 {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(address.min_address_fixed), 323 "Min Relocatability", acpi_gbl_min_decode}, 324 {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(address.max_address_fixed), 325 "Max Relocatability", acpi_gbl_max_decode} 326}; 327 328static struct acpi_rsdump_info acpi_rs_dump_memory_flags[5] = { 329 {ACPI_RSD_LITERAL, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_memory_flags), 330 "Resource Type", (void *)"Memory Range"}, 331 {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(address.info.mem.write_protect), 332 "Write Protect", acpi_gbl_rw_decode}, 333 {ACPI_RSD_2BITFLAG, ACPI_RSD_OFFSET(address.info.mem.caching), 334 "Caching", acpi_gbl_mem_decode}, 335 {ACPI_RSD_2BITFLAG, ACPI_RSD_OFFSET(address.info.mem.range_type), 336 "Range Type", acpi_gbl_mtp_decode}, 337 {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(address.info.mem.translation), 338 "Translation", acpi_gbl_ttp_decode} 339}; 340 341static struct acpi_rsdump_info acpi_rs_dump_io_flags[4] = { 342 {ACPI_RSD_LITERAL, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_io_flags), 343 "Resource Type", (void *)"I/O Range"}, 344 {ACPI_RSD_2BITFLAG, ACPI_RSD_OFFSET(address.info.io.range_type), 345 "Range Type", acpi_gbl_rng_decode}, 346 {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(address.info.io.translation), 347 "Translation", acpi_gbl_ttp_decode}, 348 {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(address.info.io.translation_type), 349 "Translation Type", acpi_gbl_trs_decode} 350}; 351 352/* 353 * Table used to dump _PRT contents 354 */ 355static struct acpi_rsdump_info acpi_rs_dump_prt[5] = { 356 {ACPI_RSD_TITLE, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_prt), NULL, NULL}, 357 {ACPI_RSD_UINT64, ACPI_PRT_OFFSET(address), "Address", NULL}, 358 {ACPI_RSD_UINT32, ACPI_PRT_OFFSET(pin), "Pin", NULL}, 359 {ACPI_RSD_STRING, ACPI_PRT_OFFSET(source[0]), "Source", NULL}, 360 {ACPI_RSD_UINT32, ACPI_PRT_OFFSET(source_index), "Source Index", NULL} 361}; 362 363/******************************************************************************* 364 * 365 * FUNCTION: acpi_rs_dump_descriptor 366 * 367 * PARAMETERS: Resource 368 * 369 * RETURN: None 370 * 371 * DESCRIPTION: 372 * 373 ******************************************************************************/ 374 375static void 376acpi_rs_dump_descriptor(void *resource, struct acpi_rsdump_info *table) 377{ 378 u8 *target = NULL; 379 u8 *previous_target; 380 char *name; 381 u8 count; 382 383 /* First table entry must contain the table length (# of table entries) */ 384 385 count = table->offset; 386 387 while (count) { 388 previous_target = target; 389 target = ACPI_ADD_PTR(u8, resource, table->offset); 390 name = table->name; 391 392 switch (table->opcode) { 393 case ACPI_RSD_TITLE: 394 /* 395 * Optional resource title 396 */ 397 if (table->name) { 398 acpi_os_printf("%s Resource\n", name); 399 } 400 break; 401 402 /* Strings */ 403 404 case ACPI_RSD_LITERAL: 405 acpi_rs_out_string(name, 406 ACPI_CAST_PTR(char, table->pointer)); 407 break; 408 409 case ACPI_RSD_STRING: 410 acpi_rs_out_string(name, ACPI_CAST_PTR(char, target)); 411 break; 412 413 /* Data items, 8/16/32/64 bit */ 414 415 case ACPI_RSD_UINT8: 416 acpi_rs_out_integer8(name, ACPI_GET8(target)); 417 break; 418 419 case ACPI_RSD_UINT16: 420 acpi_rs_out_integer16(name, ACPI_GET16(target)); 421 break; 422 423 case ACPI_RSD_UINT32: 424 acpi_rs_out_integer32(name, ACPI_GET32(target)); 425 break; 426 427 case ACPI_RSD_UINT64: 428 acpi_rs_out_integer64(name, ACPI_GET64(target)); 429 break; 430 431 /* Flags: 1-bit and 2-bit flags supported */ 432 433 case ACPI_RSD_1BITFLAG: 434 acpi_rs_out_string(name, ACPI_CAST_PTR(char, 435 table-> 436 pointer[*target & 437 0x01])); 438 break; 439 440 case ACPI_RSD_2BITFLAG: 441 acpi_rs_out_string(name, ACPI_CAST_PTR(char, 442 table-> 443 pointer[*target & 444 0x03])); 445 break; 446 447 case ACPI_RSD_SHORTLIST: 448 /* 449 * Short byte list (single line output) for DMA and IRQ resources 450 * Note: The list length is obtained from the previous table entry 451 */ 452 if (previous_target) { 453 acpi_rs_out_title(name); 454 acpi_rs_dump_short_byte_list(*previous_target, 455 target); 456 } 457 break; 458 459 case ACPI_RSD_LONGLIST: 460 /* 461 * Long byte list for Vendor resource data 462 * Note: The list length is obtained from the previous table entry 463 */ 464 if (previous_target) { 465 acpi_rs_dump_byte_list(ACPI_GET16 466 (previous_target), 467 target); 468 } 469 break; 470 471 case ACPI_RSD_DWORDLIST: 472 /* 473 * Dword list for Extended Interrupt resources 474 * Note: The list length is obtained from the previous table entry 475 */ 476 if (previous_target) { 477 acpi_rs_dump_dword_list(*previous_target, 478 ACPI_CAST_PTR(u32, 479 target)); 480 } 481 break; 482 483 case ACPI_RSD_ADDRESS: 484 /* 485 * Common flags for all Address resources 486 */ 487 acpi_rs_dump_address_common(ACPI_CAST_PTR 488 (union acpi_resource_data, 489 target)); 490 break; 491 492 case ACPI_RSD_SOURCE: 493 /* 494 * Optional resource_source for Address resources 495 */ 496 acpi_rs_dump_resource_source(ACPI_CAST_PTR(struct 497 acpi_resource_source, 498 target)); 499 break; 500 501 default: 502 acpi_os_printf("**** Invalid table opcode [%X] ****\n", 503 table->opcode); 504 return; 505 } 506 507 table++; 508 count--; 509 } 510} 511 512/******************************************************************************* 513 * 514 * FUNCTION: acpi_rs_dump_resource_source 515 * 516 * PARAMETERS: resource_source - Pointer to a Resource Source struct 517 * 518 * RETURN: None 519 * 520 * DESCRIPTION: Common routine for dumping the optional resource_source and the 521 * corresponding resource_source_index. 522 * 523 ******************************************************************************/ 524 525static void 526acpi_rs_dump_resource_source(struct acpi_resource_source *resource_source) 527{ 528 ACPI_FUNCTION_ENTRY(); 529 530 if (resource_source->index == 0xFF) { 531 return; 532 } 533 534 acpi_rs_out_integer8("Resource Source Index", resource_source->index); 535 536 acpi_rs_out_string("Resource Source", 537 resource_source->string_ptr ? 538 resource_source->string_ptr : "[Not Specified]"); 539} 540 541/******************************************************************************* 542 * 543 * FUNCTION: acpi_rs_dump_address_common 544 * 545 * PARAMETERS: Resource - Pointer to an internal resource descriptor 546 * 547 * RETURN: None 548 * 549 * DESCRIPTION: Dump the fields that are common to all Address resource 550 * descriptors 551 * 552 ******************************************************************************/ 553 554static void acpi_rs_dump_address_common(union acpi_resource_data *resource) 555{ 556 ACPI_FUNCTION_ENTRY(); 557 558 /* Decode the type-specific flags */ 559 560 switch (resource->address.resource_type) { 561 case ACPI_MEMORY_RANGE: 562 563 acpi_rs_dump_descriptor(resource, acpi_rs_dump_memory_flags); 564 break; 565 566 case ACPI_IO_RANGE: 567 568 acpi_rs_dump_descriptor(resource, acpi_rs_dump_io_flags); 569 break; 570 571 case ACPI_BUS_NUMBER_RANGE: 572 573 acpi_rs_out_string("Resource Type", "Bus Number Range"); 574 break; 575 576 default: 577 578 acpi_rs_out_integer8("Resource Type", 579 (u8) resource->address.resource_type); 580 break; 581 } 582 583 /* Decode the general flags */ 584 585 acpi_rs_dump_descriptor(resource, acpi_rs_dump_general_flags); 586} 587 588/******************************************************************************* 589 * 590 * FUNCTION: acpi_rs_dump_resource_list 591 * 592 * PARAMETERS: resource_list - Pointer to a resource descriptor list 593 * 594 * RETURN: None 595 * 596 * DESCRIPTION: Dispatches the structure to the correct dump routine. 597 * 598 ******************************************************************************/ 599 600void acpi_rs_dump_resource_list(struct acpi_resource *resource_list) 601{ 602 u32 count = 0; 603 u32 type; 604 605 ACPI_FUNCTION_ENTRY(); 606 607 if (!(acpi_dbg_level & ACPI_LV_RESOURCES) 608 || !(_COMPONENT & acpi_dbg_layer)) { 609 return; 610 } 611 612 /* Walk list and dump all resource descriptors (END_TAG terminates) */ 613 614 do { 615 acpi_os_printf("\n[%02X] ", count); 616 count++; 617 618 /* Validate Type before dispatch */ 619 620 type = resource_list->type; 621 if (type > ACPI_RESOURCE_TYPE_MAX) { 622 acpi_os_printf 623 ("Invalid descriptor type (%X) in resource list\n", 624 resource_list->type); 625 return; 626 } 627 628 /* Dump the resource descriptor */ 629 630 acpi_rs_dump_descriptor(&resource_list->data, 631 acpi_gbl_dump_resource_dispatch[type]); 632 633 /* Point to the next resource structure */ 634 635 resource_list = 636 ACPI_ADD_PTR(struct acpi_resource, resource_list, 637 resource_list->length); 638 639 /* Exit when END_TAG descriptor is reached */ 640 641 } while (type != ACPI_RESOURCE_TYPE_END_TAG); 642} 643 644/******************************************************************************* 645 * 646 * FUNCTION: acpi_rs_dump_irq_list 647 * 648 * PARAMETERS: route_table - Pointer to the routing table to dump. 649 * 650 * RETURN: None 651 * 652 * DESCRIPTION: Print IRQ routing table 653 * 654 ******************************************************************************/ 655 656void acpi_rs_dump_irq_list(u8 * route_table) 657{ 658 struct acpi_pci_routing_table *prt_element; 659 u8 count; 660 661 ACPI_FUNCTION_ENTRY(); 662 663 if (!(acpi_dbg_level & ACPI_LV_RESOURCES) 664 || !(_COMPONENT & acpi_dbg_layer)) { 665 return; 666 } 667 668 prt_element = ACPI_CAST_PTR(struct acpi_pci_routing_table, route_table); 669 670 /* Dump all table elements, Exit on zero length element */ 671 672 for (count = 0; prt_element->length; count++) { 673 acpi_os_printf("\n[%02X] PCI IRQ Routing Table Package\n", 674 count); 675 acpi_rs_dump_descriptor(prt_element, acpi_rs_dump_prt); 676 677 prt_element = ACPI_ADD_PTR(struct acpi_pci_routing_table, 678 prt_element, prt_element->length); 679 } 680} 681 682/******************************************************************************* 683 * 684 * FUNCTION: acpi_rs_out* 685 * 686 * PARAMETERS: Title - Name of the resource field 687 * Value - Value of the resource field 688 * 689 * RETURN: None 690 * 691 * DESCRIPTION: Miscellaneous helper functions to consistently format the 692 * output of the resource dump routines 693 * 694 ******************************************************************************/ 695 696static void acpi_rs_out_string(char *title, char *value) 697{ 698 acpi_os_printf("%27s : %s", title, value); 699 if (!*value) { 700 acpi_os_printf("[NULL NAMESTRING]"); 701 } 702 acpi_os_printf("\n"); 703} 704 705static void acpi_rs_out_integer8(char *title, u8 value) 706{ 707 acpi_os_printf("%27s : %2.2X\n", title, value); 708} 709 710static void acpi_rs_out_integer16(char *title, u16 value) 711{ 712 acpi_os_printf("%27s : %4.4X\n", title, value); 713} 714 715static void acpi_rs_out_integer32(char *title, u32 value) 716{ 717 acpi_os_printf("%27s : %8.8X\n", title, value); 718} 719 720static void acpi_rs_out_integer64(char *title, u64 value) 721{ 722 acpi_os_printf("%27s : %8.8X%8.8X\n", title, ACPI_FORMAT_UINT64(value)); 723} 724 725static void acpi_rs_out_title(char *title) 726{ 727 acpi_os_printf("%27s : ", title); 728} 729 730/******************************************************************************* 731 * 732 * FUNCTION: acpi_rs_dump*List 733 * 734 * PARAMETERS: Length - Number of elements in the list 735 * Data - Start of the list 736 * 737 * RETURN: None 738 * 739 * DESCRIPTION: Miscellaneous functions to dump lists of raw data 740 * 741 ******************************************************************************/ 742 743static void acpi_rs_dump_byte_list(u16 length, u8 * data) 744{ 745 u8 i; 746 747 for (i = 0; i < length; i++) { 748 acpi_os_printf("%25s%2.2X : %2.2X\n", "Byte", i, data[i]); 749 } 750} 751 752static void acpi_rs_dump_short_byte_list(u8 length, u8 * data) 753{ 754 u8 i; 755 756 for (i = 0; i < length; i++) { 757 acpi_os_printf("%X ", data[i]); 758 } 759 acpi_os_printf("\n"); 760} 761 762static void acpi_rs_dump_dword_list(u8 length, u32 * data) 763{ 764 u8 i; 765 766 for (i = 0; i < length; i++) { 767 acpi_os_printf("%25s%2.2X : %8.8X\n", "Dword", i, data[i]); 768 } 769} 770 771#endif 772