1 /******************************************************************************* 2 * 3 * Module Name: rsdump - Functions to display the resource structures. 4 * 5 ******************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2014, 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 49 ACPI_MODULE_NAME("rsdump") 50 51 #if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DISASSEMBLER) || defined(ACPI_DEBUGGER) 52 /* Local prototypes */ 53 static void acpi_rs_out_string(char *title, char *value); 54 55 static void acpi_rs_out_integer8(char *title, u8 value); 56 57 static void acpi_rs_out_integer16(char *title, u16 value); 58 59 static void acpi_rs_out_integer32(char *title, u32 value); 60 61 static void acpi_rs_out_integer64(char *title, u64 value); 62 63 static void acpi_rs_out_title(char *title); 64 65 static void acpi_rs_dump_byte_list(u16 length, u8 *data); 66 67 static void acpi_rs_dump_word_list(u16 length, u16 *data); 68 69 static void acpi_rs_dump_dword_list(u8 length, u32 *data); 70 71 static void acpi_rs_dump_short_byte_list(u8 length, u8 *data); 72 73 static void 74 acpi_rs_dump_resource_source(struct acpi_resource_source *resource_source); 75 76 static void acpi_rs_dump_address_common(union acpi_resource_data *resource); 77 78 static void 79 acpi_rs_dump_descriptor(void *resource, struct acpi_rsdump_info *table); 80 81 /******************************************************************************* 82 * 83 * FUNCTION: acpi_rs_dump_descriptor 84 * 85 * PARAMETERS: resource - Buffer containing the resource 86 * table - Table entry to decode the resource 87 * 88 * RETURN: None 89 * 90 * DESCRIPTION: Dump a resource descriptor based on a dump table entry. 91 * 92 ******************************************************************************/ 93 94 static void 95 acpi_rs_dump_descriptor(void *resource, struct acpi_rsdump_info *table) 96 { 97 u8 *target = NULL; 98 u8 *previous_target; 99 char *name; 100 u8 count; 101 102 /* First table entry must contain the table length (# of table entries) */ 103 104 count = table->offset; 105 106 while (count) { 107 previous_target = target; 108 target = ACPI_ADD_PTR(u8, resource, table->offset); 109 name = table->name; 110 111 switch (table->opcode) { 112 case ACPI_RSD_TITLE: 113 /* 114 * Optional resource title 115 */ 116 if (table->name) { 117 acpi_os_printf("%s Resource\n", name); 118 } 119 break; 120 121 /* Strings */ 122 123 case ACPI_RSD_LITERAL: 124 125 acpi_rs_out_string(name, 126 ACPI_CAST_PTR(char, table->pointer)); 127 break; 128 129 case ACPI_RSD_STRING: 130 131 acpi_rs_out_string(name, ACPI_CAST_PTR(char, target)); 132 break; 133 134 /* Data items, 8/16/32/64 bit */ 135 136 case ACPI_RSD_UINT8: 137 138 if (table->pointer) { 139 acpi_rs_out_string(name, ACPI_CAST_PTR(char, 140 table-> 141 pointer 142 [*target])); 143 } else { 144 acpi_rs_out_integer8(name, ACPI_GET8(target)); 145 } 146 break; 147 148 case ACPI_RSD_UINT16: 149 150 acpi_rs_out_integer16(name, ACPI_GET16(target)); 151 break; 152 153 case ACPI_RSD_UINT32: 154 155 acpi_rs_out_integer32(name, ACPI_GET32(target)); 156 break; 157 158 case ACPI_RSD_UINT64: 159 160 acpi_rs_out_integer64(name, ACPI_GET64(target)); 161 break; 162 163 /* Flags: 1-bit and 2-bit flags supported */ 164 165 case ACPI_RSD_1BITFLAG: 166 167 acpi_rs_out_string(name, ACPI_CAST_PTR(char, 168 table-> 169 pointer[*target & 170 0x01])); 171 break; 172 173 case ACPI_RSD_2BITFLAG: 174 175 acpi_rs_out_string(name, ACPI_CAST_PTR(char, 176 table-> 177 pointer[*target & 178 0x03])); 179 break; 180 181 case ACPI_RSD_3BITFLAG: 182 183 acpi_rs_out_string(name, ACPI_CAST_PTR(char, 184 table-> 185 pointer[*target & 186 0x07])); 187 break; 188 189 case ACPI_RSD_SHORTLIST: 190 /* 191 * Short byte list (single line output) for DMA and IRQ resources 192 * Note: The list length is obtained from the previous table entry 193 */ 194 if (previous_target) { 195 acpi_rs_out_title(name); 196 acpi_rs_dump_short_byte_list(*previous_target, 197 target); 198 } 199 break; 200 201 case ACPI_RSD_SHORTLISTX: 202 /* 203 * Short byte list (single line output) for GPIO vendor data 204 * Note: The list length is obtained from the previous table entry 205 */ 206 if (previous_target) { 207 acpi_rs_out_title(name); 208 acpi_rs_dump_short_byte_list(*previous_target, 209 * 210 (ACPI_CAST_INDIRECT_PTR 211 (u8, target))); 212 } 213 break; 214 215 case ACPI_RSD_LONGLIST: 216 /* 217 * Long byte list for Vendor resource data 218 * Note: The list length is obtained from the previous table entry 219 */ 220 if (previous_target) { 221 acpi_rs_dump_byte_list(ACPI_GET16 222 (previous_target), 223 target); 224 } 225 break; 226 227 case ACPI_RSD_DWORDLIST: 228 /* 229 * Dword list for Extended Interrupt resources 230 * Note: The list length is obtained from the previous table entry 231 */ 232 if (previous_target) { 233 acpi_rs_dump_dword_list(*previous_target, 234 ACPI_CAST_PTR(u32, 235 target)); 236 } 237 break; 238 239 case ACPI_RSD_WORDLIST: 240 /* 241 * Word list for GPIO Pin Table 242 * Note: The list length is obtained from the previous table entry 243 */ 244 if (previous_target) { 245 acpi_rs_dump_word_list(*previous_target, 246 *(ACPI_CAST_INDIRECT_PTR 247 (u16, target))); 248 } 249 break; 250 251 case ACPI_RSD_ADDRESS: 252 /* 253 * Common flags for all Address resources 254 */ 255 acpi_rs_dump_address_common(ACPI_CAST_PTR 256 (union acpi_resource_data, 257 target)); 258 break; 259 260 case ACPI_RSD_SOURCE: 261 /* 262 * Optional resource_source for Address resources 263 */ 264 acpi_rs_dump_resource_source(ACPI_CAST_PTR 265 (struct 266 acpi_resource_source, 267 target)); 268 break; 269 270 default: 271 272 acpi_os_printf("**** Invalid table opcode [%X] ****\n", 273 table->opcode); 274 return; 275 } 276 277 table++; 278 count--; 279 } 280 } 281 282 /******************************************************************************* 283 * 284 * FUNCTION: acpi_rs_dump_resource_source 285 * 286 * PARAMETERS: resource_source - Pointer to a Resource Source struct 287 * 288 * RETURN: None 289 * 290 * DESCRIPTION: Common routine for dumping the optional resource_source and the 291 * corresponding resource_source_index. 292 * 293 ******************************************************************************/ 294 295 static void 296 acpi_rs_dump_resource_source(struct acpi_resource_source *resource_source) 297 { 298 ACPI_FUNCTION_ENTRY(); 299 300 if (resource_source->index == 0xFF) { 301 return; 302 } 303 304 acpi_rs_out_integer8("Resource Source Index", resource_source->index); 305 306 acpi_rs_out_string("Resource Source", 307 resource_source->string_ptr ? 308 resource_source->string_ptr : "[Not Specified]"); 309 } 310 311 /******************************************************************************* 312 * 313 * FUNCTION: acpi_rs_dump_address_common 314 * 315 * PARAMETERS: resource - Pointer to an internal resource descriptor 316 * 317 * RETURN: None 318 * 319 * DESCRIPTION: Dump the fields that are common to all Address resource 320 * descriptors 321 * 322 ******************************************************************************/ 323 324 static void acpi_rs_dump_address_common(union acpi_resource_data *resource) 325 { 326 ACPI_FUNCTION_ENTRY(); 327 328 /* Decode the type-specific flags */ 329 330 switch (resource->address.resource_type) { 331 case ACPI_MEMORY_RANGE: 332 333 acpi_rs_dump_descriptor(resource, acpi_rs_dump_memory_flags); 334 break; 335 336 case ACPI_IO_RANGE: 337 338 acpi_rs_dump_descriptor(resource, acpi_rs_dump_io_flags); 339 break; 340 341 case ACPI_BUS_NUMBER_RANGE: 342 343 acpi_rs_out_string("Resource Type", "Bus Number Range"); 344 break; 345 346 default: 347 348 acpi_rs_out_integer8("Resource Type", 349 (u8) resource->address.resource_type); 350 break; 351 } 352 353 /* Decode the general flags */ 354 355 acpi_rs_dump_descriptor(resource, acpi_rs_dump_general_flags); 356 } 357 358 /******************************************************************************* 359 * 360 * FUNCTION: acpi_rs_dump_resource_list 361 * 362 * PARAMETERS: resource_list - Pointer to a resource descriptor list 363 * 364 * RETURN: None 365 * 366 * DESCRIPTION: Dispatches the structure to the correct dump routine. 367 * 368 ******************************************************************************/ 369 370 void acpi_rs_dump_resource_list(struct acpi_resource *resource_list) 371 { 372 u32 count = 0; 373 u32 type; 374 375 ACPI_FUNCTION_ENTRY(); 376 377 /* Check if debug output enabled */ 378 379 if (!ACPI_IS_DEBUG_ENABLED(ACPI_LV_RESOURCES, _COMPONENT)) { 380 return; 381 } 382 383 /* Walk list and dump all resource descriptors (END_TAG terminates) */ 384 385 do { 386 acpi_os_printf("\n[%02X] ", count); 387 count++; 388 389 /* Validate Type before dispatch */ 390 391 type = resource_list->type; 392 if (type > ACPI_RESOURCE_TYPE_MAX) { 393 acpi_os_printf 394 ("Invalid descriptor type (%X) in resource list\n", 395 resource_list->type); 396 return; 397 } 398 399 /* Sanity check the length. It must not be zero, or we loop forever */ 400 401 if (!resource_list->length) { 402 acpi_os_printf 403 ("Invalid zero length descriptor in resource list\n"); 404 return; 405 } 406 407 /* Dump the resource descriptor */ 408 409 if (type == ACPI_RESOURCE_TYPE_SERIAL_BUS) { 410 acpi_rs_dump_descriptor(&resource_list->data, 411 acpi_gbl_dump_serial_bus_dispatch 412 [resource_list->data. 413 common_serial_bus.type]); 414 } else { 415 acpi_rs_dump_descriptor(&resource_list->data, 416 acpi_gbl_dump_resource_dispatch 417 [type]); 418 } 419 420 /* Point to the next resource structure */ 421 422 resource_list = ACPI_NEXT_RESOURCE(resource_list); 423 424 /* Exit when END_TAG descriptor is reached */ 425 426 } while (type != ACPI_RESOURCE_TYPE_END_TAG); 427 } 428 429 /******************************************************************************* 430 * 431 * FUNCTION: acpi_rs_dump_irq_list 432 * 433 * PARAMETERS: route_table - Pointer to the routing table to dump. 434 * 435 * RETURN: None 436 * 437 * DESCRIPTION: Print IRQ routing table 438 * 439 ******************************************************************************/ 440 441 void acpi_rs_dump_irq_list(u8 * route_table) 442 { 443 struct acpi_pci_routing_table *prt_element; 444 u8 count; 445 446 ACPI_FUNCTION_ENTRY(); 447 448 /* Check if debug output enabled */ 449 450 if (!ACPI_IS_DEBUG_ENABLED(ACPI_LV_RESOURCES, _COMPONENT)) { 451 return; 452 } 453 454 prt_element = ACPI_CAST_PTR(struct acpi_pci_routing_table, route_table); 455 456 /* Dump all table elements, Exit on zero length element */ 457 458 for (count = 0; prt_element->length; count++) { 459 acpi_os_printf("\n[%02X] PCI IRQ Routing Table Package\n", 460 count); 461 acpi_rs_dump_descriptor(prt_element, acpi_rs_dump_prt); 462 463 prt_element = ACPI_ADD_PTR(struct acpi_pci_routing_table, 464 prt_element, prt_element->length); 465 } 466 } 467 468 /******************************************************************************* 469 * 470 * FUNCTION: acpi_rs_out* 471 * 472 * PARAMETERS: title - Name of the resource field 473 * value - Value of the resource field 474 * 475 * RETURN: None 476 * 477 * DESCRIPTION: Miscellaneous helper functions to consistently format the 478 * output of the resource dump routines 479 * 480 ******************************************************************************/ 481 482 static void acpi_rs_out_string(char *title, char *value) 483 { 484 acpi_os_printf("%27s : %s", title, value); 485 if (!*value) { 486 acpi_os_printf("[NULL NAMESTRING]"); 487 } 488 acpi_os_printf("\n"); 489 } 490 491 static void acpi_rs_out_integer8(char *title, u8 value) 492 { 493 acpi_os_printf("%27s : %2.2X\n", title, value); 494 } 495 496 static void acpi_rs_out_integer16(char *title, u16 value) 497 { 498 acpi_os_printf("%27s : %4.4X\n", title, value); 499 } 500 501 static void acpi_rs_out_integer32(char *title, u32 value) 502 { 503 acpi_os_printf("%27s : %8.8X\n", title, value); 504 } 505 506 static void acpi_rs_out_integer64(char *title, u64 value) 507 { 508 acpi_os_printf("%27s : %8.8X%8.8X\n", title, ACPI_FORMAT_UINT64(value)); 509 } 510 511 static void acpi_rs_out_title(char *title) 512 { 513 acpi_os_printf("%27s : ", title); 514 } 515 516 /******************************************************************************* 517 * 518 * FUNCTION: acpi_rs_dump*List 519 * 520 * PARAMETERS: length - Number of elements in the list 521 * data - Start of the list 522 * 523 * RETURN: None 524 * 525 * DESCRIPTION: Miscellaneous functions to dump lists of raw data 526 * 527 ******************************************************************************/ 528 529 static void acpi_rs_dump_byte_list(u16 length, u8 * data) 530 { 531 u8 i; 532 533 for (i = 0; i < length; i++) { 534 acpi_os_printf("%25s%2.2X : %2.2X\n", "Byte", i, data[i]); 535 } 536 } 537 538 static void acpi_rs_dump_short_byte_list(u8 length, u8 * data) 539 { 540 u8 i; 541 542 for (i = 0; i < length; i++) { 543 acpi_os_printf("%X ", data[i]); 544 } 545 acpi_os_printf("\n"); 546 } 547 548 static void acpi_rs_dump_dword_list(u8 length, u32 * data) 549 { 550 u8 i; 551 552 for (i = 0; i < length; i++) { 553 acpi_os_printf("%25s%2.2X : %8.8X\n", "Dword", i, data[i]); 554 } 555 } 556 557 static void acpi_rs_dump_word_list(u16 length, u16 *data) 558 { 559 u16 i; 560 561 for (i = 0; i < length; i++) { 562 acpi_os_printf("%25s%2.2X : %4.4X\n", "Word", i, data[i]); 563 } 564 } 565 566 #endif 567