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 45 #define __RSDUMP_C__ 46 47 #include <contrib/dev/acpica/include/acpi.h> 48 #include <contrib/dev/acpica/include/accommon.h> 49 #include <contrib/dev/acpica/include/acresrc.h> 50 51 #define _COMPONENT ACPI_RESOURCES 52 ACPI_MODULE_NAME ("rsdump") 53 54 55 #if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER) 56 57 /* Local prototypes */ 58 59 static void 60 AcpiRsOutString ( 61 char *Title, 62 char *Value); 63 64 static void 65 AcpiRsOutInteger8 ( 66 char *Title, 67 UINT8 Value); 68 69 static void 70 AcpiRsOutInteger16 ( 71 char *Title, 72 UINT16 Value); 73 74 static void 75 AcpiRsOutInteger32 ( 76 char *Title, 77 UINT32 Value); 78 79 static void 80 AcpiRsOutInteger64 ( 81 char *Title, 82 UINT64 Value); 83 84 static void 85 AcpiRsOutTitle ( 86 char *Title); 87 88 static void 89 AcpiRsDumpByteList ( 90 UINT16 Length, 91 UINT8 *Data); 92 93 static void 94 AcpiRsDumpWordList ( 95 UINT16 Length, 96 UINT16 *Data); 97 98 static void 99 AcpiRsDumpDwordList ( 100 UINT8 Length, 101 UINT32 *Data); 102 103 static void 104 AcpiRsDumpShortByteList ( 105 UINT8 Length, 106 UINT8 *Data); 107 108 static void 109 AcpiRsDumpResourceSource ( 110 ACPI_RESOURCE_SOURCE *ResourceSource); 111 112 static void 113 AcpiRsDumpAddressCommon ( 114 ACPI_RESOURCE_DATA *Resource); 115 116 static void 117 AcpiRsDumpDescriptor ( 118 void *Resource, 119 ACPI_RSDUMP_INFO *Table); 120 121 122 /******************************************************************************* 123 * 124 * FUNCTION: AcpiRsDumpDescriptor 125 * 126 * PARAMETERS: Resource - Buffer containing the resource 127 * Table - Table entry to decode the resource 128 * 129 * RETURN: None 130 * 131 * DESCRIPTION: Dump a resource descriptor based on a dump table entry. 132 * 133 ******************************************************************************/ 134 135 static void 136 AcpiRsDumpDescriptor ( 137 void *Resource, 138 ACPI_RSDUMP_INFO *Table) 139 { 140 UINT8 *Target = NULL; 141 UINT8 *PreviousTarget; 142 char *Name; 143 UINT8 Count; 144 145 146 /* First table entry must contain the table length (# of table entries) */ 147 148 Count = Table->Offset; 149 150 while (Count) 151 { 152 PreviousTarget = Target; 153 Target = ACPI_ADD_PTR (UINT8, Resource, Table->Offset); 154 Name = Table->Name; 155 156 switch (Table->Opcode) 157 { 158 case ACPI_RSD_TITLE: 159 /* 160 * Optional resource title 161 */ 162 if (Table->Name) 163 { 164 AcpiOsPrintf ("%s Resource\n", Name); 165 } 166 break; 167 168 /* Strings */ 169 170 case ACPI_RSD_LITERAL: 171 172 AcpiRsOutString (Name, ACPI_CAST_PTR (char, Table->Pointer)); 173 break; 174 175 case ACPI_RSD_STRING: 176 177 AcpiRsOutString (Name, ACPI_CAST_PTR (char, Target)); 178 break; 179 180 /* Data items, 8/16/32/64 bit */ 181 182 case ACPI_RSD_UINT8: 183 184 if (Table->Pointer) 185 { 186 AcpiRsOutString (Name, ACPI_CAST_PTR (char, 187 Table->Pointer [*Target])); 188 } 189 else 190 { 191 AcpiRsOutInteger8 (Name, ACPI_GET8 (Target)); 192 } 193 break; 194 195 case ACPI_RSD_UINT16: 196 197 AcpiRsOutInteger16 (Name, ACPI_GET16 (Target)); 198 break; 199 200 case ACPI_RSD_UINT32: 201 202 AcpiRsOutInteger32 (Name, ACPI_GET32 (Target)); 203 break; 204 205 case ACPI_RSD_UINT64: 206 207 AcpiRsOutInteger64 (Name, ACPI_GET64 (Target)); 208 break; 209 210 /* Flags: 1-bit and 2-bit flags supported */ 211 212 case ACPI_RSD_1BITFLAG: 213 214 AcpiRsOutString (Name, ACPI_CAST_PTR (char, 215 Table->Pointer [*Target & 0x01])); 216 break; 217 218 case ACPI_RSD_2BITFLAG: 219 220 AcpiRsOutString (Name, ACPI_CAST_PTR (char, 221 Table->Pointer [*Target & 0x03])); 222 break; 223 224 case ACPI_RSD_3BITFLAG: 225 226 AcpiRsOutString (Name, ACPI_CAST_PTR (char, 227 Table->Pointer [*Target & 0x07])); 228 break; 229 230 case ACPI_RSD_SHORTLIST: 231 /* 232 * Short byte list (single line output) for DMA and IRQ resources 233 * Note: The list length is obtained from the previous table entry 234 */ 235 if (PreviousTarget) 236 { 237 AcpiRsOutTitle (Name); 238 AcpiRsDumpShortByteList (*PreviousTarget, Target); 239 } 240 break; 241 242 case ACPI_RSD_SHORTLISTX: 243 /* 244 * Short byte list (single line output) for GPIO vendor data 245 * Note: The list length is obtained from the previous table entry 246 */ 247 if (PreviousTarget) 248 { 249 AcpiRsOutTitle (Name); 250 AcpiRsDumpShortByteList (*PreviousTarget, 251 *(ACPI_CAST_INDIRECT_PTR (UINT8, Target))); 252 } 253 break; 254 255 case ACPI_RSD_LONGLIST: 256 /* 257 * Long byte list for Vendor resource data 258 * Note: The list length is obtained from the previous table entry 259 */ 260 if (PreviousTarget) 261 { 262 AcpiRsDumpByteList (ACPI_GET16 (PreviousTarget), Target); 263 } 264 break; 265 266 case ACPI_RSD_DWORDLIST: 267 /* 268 * Dword list for Extended Interrupt resources 269 * Note: The list length is obtained from the previous table entry 270 */ 271 if (PreviousTarget) 272 { 273 AcpiRsDumpDwordList (*PreviousTarget, 274 ACPI_CAST_PTR (UINT32, Target)); 275 } 276 break; 277 278 case ACPI_RSD_WORDLIST: 279 /* 280 * Word list for GPIO Pin Table 281 * Note: The list length is obtained from the previous table entry 282 */ 283 if (PreviousTarget) 284 { 285 AcpiRsDumpWordList (*PreviousTarget, 286 *(ACPI_CAST_INDIRECT_PTR (UINT16, Target))); 287 } 288 break; 289 290 case ACPI_RSD_ADDRESS: 291 /* 292 * Common flags for all Address resources 293 */ 294 AcpiRsDumpAddressCommon (ACPI_CAST_PTR (ACPI_RESOURCE_DATA, Target)); 295 break; 296 297 case ACPI_RSD_SOURCE: 298 /* 299 * Optional ResourceSource for Address resources 300 */ 301 AcpiRsDumpResourceSource (ACPI_CAST_PTR (ACPI_RESOURCE_SOURCE, Target)); 302 break; 303 304 default: 305 306 AcpiOsPrintf ("**** Invalid table opcode [%X] ****\n", 307 Table->Opcode); 308 return; 309 } 310 311 Table++; 312 Count--; 313 } 314 } 315 316 317 /******************************************************************************* 318 * 319 * FUNCTION: AcpiRsDumpResourceSource 320 * 321 * PARAMETERS: ResourceSource - Pointer to a Resource Source struct 322 * 323 * RETURN: None 324 * 325 * DESCRIPTION: Common routine for dumping the optional ResourceSource and the 326 * corresponding ResourceSourceIndex. 327 * 328 ******************************************************************************/ 329 330 static void 331 AcpiRsDumpResourceSource ( 332 ACPI_RESOURCE_SOURCE *ResourceSource) 333 { 334 ACPI_FUNCTION_ENTRY (); 335 336 337 if (ResourceSource->Index == 0xFF) 338 { 339 return; 340 } 341 342 AcpiRsOutInteger8 ("Resource Source Index", 343 ResourceSource->Index); 344 345 AcpiRsOutString ("Resource Source", 346 ResourceSource->StringPtr ? 347 ResourceSource->StringPtr : "[Not Specified]"); 348 } 349 350 351 /******************************************************************************* 352 * 353 * FUNCTION: AcpiRsDumpAddressCommon 354 * 355 * PARAMETERS: Resource - Pointer to an internal resource descriptor 356 * 357 * RETURN: None 358 * 359 * DESCRIPTION: Dump the fields that are common to all Address resource 360 * descriptors 361 * 362 ******************************************************************************/ 363 364 static void 365 AcpiRsDumpAddressCommon ( 366 ACPI_RESOURCE_DATA *Resource) 367 { 368 ACPI_FUNCTION_ENTRY (); 369 370 371 /* Decode the type-specific flags */ 372 373 switch (Resource->Address.ResourceType) 374 { 375 case ACPI_MEMORY_RANGE: 376 377 AcpiRsDumpDescriptor (Resource, AcpiRsDumpMemoryFlags); 378 break; 379 380 case ACPI_IO_RANGE: 381 382 AcpiRsDumpDescriptor (Resource, AcpiRsDumpIoFlags); 383 break; 384 385 case ACPI_BUS_NUMBER_RANGE: 386 387 AcpiRsOutString ("Resource Type", "Bus Number Range"); 388 break; 389 390 default: 391 392 AcpiRsOutInteger8 ("Resource Type", 393 (UINT8) Resource->Address.ResourceType); 394 break; 395 } 396 397 /* Decode the general flags */ 398 399 AcpiRsDumpDescriptor (Resource, AcpiRsDumpGeneralFlags); 400 } 401 402 403 /******************************************************************************* 404 * 405 * FUNCTION: AcpiRsDumpResourceList 406 * 407 * PARAMETERS: ResourceList - Pointer to a resource descriptor list 408 * 409 * RETURN: None 410 * 411 * DESCRIPTION: Dispatches the structure to the correct dump routine. 412 * 413 ******************************************************************************/ 414 415 void 416 AcpiRsDumpResourceList ( 417 ACPI_RESOURCE *ResourceList) 418 { 419 UINT32 Count = 0; 420 UINT32 Type; 421 422 423 ACPI_FUNCTION_ENTRY (); 424 425 426 /* Check if debug output enabled */ 427 428 if (!ACPI_IS_DEBUG_ENABLED (ACPI_LV_RESOURCES, _COMPONENT)) 429 { 430 return; 431 } 432 433 /* Walk list and dump all resource descriptors (END_TAG terminates) */ 434 435 do 436 { 437 AcpiOsPrintf ("\n[%02X] ", Count); 438 Count++; 439 440 /* Validate Type before dispatch */ 441 442 Type = ResourceList->Type; 443 if (Type > ACPI_RESOURCE_TYPE_MAX) 444 { 445 AcpiOsPrintf ( 446 "Invalid descriptor type (%X) in resource list\n", 447 ResourceList->Type); 448 return; 449 } 450 451 /* Sanity check the length. It must not be zero, or we loop forever */ 452 453 if (!ResourceList->Length) 454 { 455 AcpiOsPrintf ( 456 "Invalid zero length descriptor in resource list\n"); 457 return; 458 } 459 460 /* Dump the resource descriptor */ 461 462 if (Type == ACPI_RESOURCE_TYPE_SERIAL_BUS) 463 { 464 AcpiRsDumpDescriptor (&ResourceList->Data, 465 AcpiGbl_DumpSerialBusDispatch[ResourceList->Data.CommonSerialBus.Type]); 466 } 467 else 468 { 469 AcpiRsDumpDescriptor (&ResourceList->Data, 470 AcpiGbl_DumpResourceDispatch[Type]); 471 } 472 473 /* Point to the next resource structure */ 474 475 ResourceList = ACPI_NEXT_RESOURCE (ResourceList); 476 477 /* Exit when END_TAG descriptor is reached */ 478 479 } while (Type != ACPI_RESOURCE_TYPE_END_TAG); 480 } 481 482 483 /******************************************************************************* 484 * 485 * FUNCTION: AcpiRsDumpIrqList 486 * 487 * PARAMETERS: RouteTable - Pointer to the routing table to dump. 488 * 489 * RETURN: None 490 * 491 * DESCRIPTION: Print IRQ routing table 492 * 493 ******************************************************************************/ 494 495 void 496 AcpiRsDumpIrqList ( 497 UINT8 *RouteTable) 498 { 499 ACPI_PCI_ROUTING_TABLE *PrtElement; 500 UINT8 Count; 501 502 503 ACPI_FUNCTION_ENTRY (); 504 505 506 /* Check if debug output enabled */ 507 508 if (!ACPI_IS_DEBUG_ENABLED (ACPI_LV_RESOURCES, _COMPONENT)) 509 { 510 return; 511 } 512 513 PrtElement = ACPI_CAST_PTR (ACPI_PCI_ROUTING_TABLE, RouteTable); 514 515 /* Dump all table elements, Exit on zero length element */ 516 517 for (Count = 0; PrtElement->Length; Count++) 518 { 519 AcpiOsPrintf ("\n[%02X] PCI IRQ Routing Table Package\n", Count); 520 AcpiRsDumpDescriptor (PrtElement, AcpiRsDumpPrt); 521 522 PrtElement = ACPI_ADD_PTR (ACPI_PCI_ROUTING_TABLE, 523 PrtElement, PrtElement->Length); 524 } 525 } 526 527 528 /******************************************************************************* 529 * 530 * FUNCTION: AcpiRsOut* 531 * 532 * PARAMETERS: Title - Name of the resource field 533 * Value - Value of the resource field 534 * 535 * RETURN: None 536 * 537 * DESCRIPTION: Miscellaneous helper functions to consistently format the 538 * output of the resource dump routines 539 * 540 ******************************************************************************/ 541 542 static void 543 AcpiRsOutString ( 544 char *Title, 545 char *Value) 546 { 547 AcpiOsPrintf ("%27s : %s", Title, Value); 548 if (!*Value) 549 { 550 AcpiOsPrintf ("[NULL NAMESTRING]"); 551 } 552 AcpiOsPrintf ("\n"); 553 } 554 555 static void 556 AcpiRsOutInteger8 ( 557 char *Title, 558 UINT8 Value) 559 { 560 AcpiOsPrintf ("%27s : %2.2X\n", Title, Value); 561 } 562 563 static void 564 AcpiRsOutInteger16 ( 565 char *Title, 566 UINT16 Value) 567 { 568 AcpiOsPrintf ("%27s : %4.4X\n", Title, Value); 569 } 570 571 static void 572 AcpiRsOutInteger32 ( 573 char *Title, 574 UINT32 Value) 575 { 576 AcpiOsPrintf ("%27s : %8.8X\n", Title, Value); 577 } 578 579 static void 580 AcpiRsOutInteger64 ( 581 char *Title, 582 UINT64 Value) 583 { 584 AcpiOsPrintf ("%27s : %8.8X%8.8X\n", Title, 585 ACPI_FORMAT_UINT64 (Value)); 586 } 587 588 static void 589 AcpiRsOutTitle ( 590 char *Title) 591 { 592 AcpiOsPrintf ("%27s : ", Title); 593 } 594 595 596 /******************************************************************************* 597 * 598 * FUNCTION: AcpiRsDump*List 599 * 600 * PARAMETERS: Length - Number of elements in the list 601 * Data - Start of the list 602 * 603 * RETURN: None 604 * 605 * DESCRIPTION: Miscellaneous functions to dump lists of raw data 606 * 607 ******************************************************************************/ 608 609 static void 610 AcpiRsDumpByteList ( 611 UINT16 Length, 612 UINT8 *Data) 613 { 614 UINT8 i; 615 616 617 for (i = 0; i < Length; i++) 618 { 619 AcpiOsPrintf ("%25s%2.2X : %2.2X\n", 620 "Byte", i, Data[i]); 621 } 622 } 623 624 static void 625 AcpiRsDumpShortByteList ( 626 UINT8 Length, 627 UINT8 *Data) 628 { 629 UINT8 i; 630 631 632 for (i = 0; i < Length; i++) 633 { 634 AcpiOsPrintf ("%X ", Data[i]); 635 } 636 AcpiOsPrintf ("\n"); 637 } 638 639 static void 640 AcpiRsDumpDwordList ( 641 UINT8 Length, 642 UINT32 *Data) 643 { 644 UINT8 i; 645 646 647 for (i = 0; i < Length; i++) 648 { 649 AcpiOsPrintf ("%25s%2.2X : %8.8X\n", 650 "Dword", i, Data[i]); 651 } 652 } 653 654 static void 655 AcpiRsDumpWordList ( 656 UINT16 Length, 657 UINT16 *Data) 658 { 659 UINT16 i; 660 661 662 for (i = 0; i < Length; i++) 663 { 664 AcpiOsPrintf ("%25s%2.2X : %4.4X\n", 665 "Word", i, Data[i]); 666 } 667 } 668 669 #endif 670