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