drivers/acpi/acpica/rsdump.c

   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