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