acpi.c revision 1.39
1 /* $NetBSD: acpi.c,v 1.39 2018/11/01 03:08:46 msaitoh Exp $ */ 2 3 /*- 4 * Copyright (c) 1998 Doug Rabson 5 * Copyright (c) 2000 Mitsuru IWASAKI <iwasaki (at) FreeBSD.org> 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 * 29 * $FreeBSD: head/usr.sbin/acpi/acpidump/acpi.c 321299 2017-07-20 17:36:17Z emaste $ 30 */ 31 32 #include <sys/cdefs.h> 33 __RCSID("$NetBSD: acpi.c,v 1.39 2018/11/01 03:08:46 msaitoh Exp $"); 34 35 #include <sys/param.h> 36 #include <sys/endian.h> 37 #include <sys/stat.h> 38 #include <sys/wait.h> 39 #include <assert.h> 40 #include <err.h> 41 #include <fcntl.h> 42 #include <paths.h> 43 #include <stdbool.h> 44 #include <stdio.h> 45 #include <stdint.h> 46 #include <stdlib.h> 47 #include <string.h> 48 #include <unistd.h> 49 #include <stddef.h> 50 #include <uuid.h> 51 52 #include "acpidump.h" 53 54 #define BEGIN_COMMENT "/*\n" 55 #define END_COMMENT " */\n" 56 57 /* Commonly used helper functions */ 58 static void acpi_print_string(char *s, size_t length); 59 static void acpi_print_tabs(unsigned int n); 60 static void acpi_dump_bytes(uint8_t *p, uint32_t len, unsigned int ntabs); 61 static void acpi_dump_table(ACPI_TABLE_HEADER *sdp); 62 static void acpi_print_gas(ACPI_GENERIC_ADDRESS *gas); 63 static void acpi_print_pci(uint16_t vendorid, uint16_t deviceid, 64 uint8_t seg, uint8_t bus, uint8_t device, uint8_t func); 65 static void acpi_print_pci_sbdf(uint8_t seg, uint8_t bus, uint8_t device, 66 uint8_t func); 67 #ifdef notyet 68 static void acpi_print_hest_generic_status(ACPI_HEST_GENERIC_STATUS *); 69 static void acpi_print_hest_generic_data(ACPI_HEST_GENERIC_DATA *); 70 #endif 71 static void acpi_print_whea(ACPI_WHEA_HEADER *whea, 72 void (*print_action)(ACPI_WHEA_HEADER *), 73 void (*print_ins)(ACPI_WHEA_HEADER *), 74 void (*print_flags)(ACPI_WHEA_HEADER *)); 75 static uint64_t acpi_select_address(uint32_t, uint64_t); 76 77 /* Handlers for each table */ 78 static void acpi_handle_fadt(ACPI_TABLE_HEADER *fadt); 79 static void acpi_print_cpu(u_char cpu_id); 80 static void acpi_print_cpu_uid(uint32_t uid, char *uid_string); 81 static void acpi_print_local_apic(uint32_t apic_id, uint32_t flags); 82 static void acpi_print_io_apic(uint32_t apic_id, uint32_t int_base, 83 uint64_t apic_addr); 84 static void acpi_print_mps_flags(uint16_t flags); 85 static void acpi_print_intr(uint32_t intr, uint16_t mps_flags); 86 static void acpi_print_local_nmi(u_int lint, uint16_t mps_flags); 87 static void acpi_print_madt(ACPI_SUBTABLE_HEADER *mp); 88 static void acpi_handle_bert(ACPI_TABLE_HEADER *sdp); 89 static void acpi_handle_boot(ACPI_TABLE_HEADER *sdp); 90 static void acpi_handle_cpep(ACPI_TABLE_HEADER *sdp); 91 static void acpi_handle_csrt(ACPI_TABLE_HEADER *sdp); 92 static void acpi_handle_dbgp(ACPI_TABLE_HEADER *sdp); 93 static void acpi_handle_dbg2(ACPI_TABLE_HEADER *sdp); 94 static void acpi_handle_einj(ACPI_TABLE_HEADER *sdp); 95 static void acpi_handle_erst(ACPI_TABLE_HEADER *sdp); 96 static void acpi_handle_gtdt(ACPI_TABLE_HEADER *sdp); 97 static void acpi_handle_hest(ACPI_TABLE_HEADER *sdp); 98 static void acpi_handle_lpit(ACPI_TABLE_HEADER *sdp); 99 static void acpi_handle_madt(ACPI_TABLE_HEADER *sdp); 100 static void acpi_handle_msct(ACPI_TABLE_HEADER *sdp); 101 static void acpi_handle_ecdt(ACPI_TABLE_HEADER *sdp); 102 static void acpi_handle_hpet(ACPI_TABLE_HEADER *sdp); 103 static void acpi_handle_mcfg(ACPI_TABLE_HEADER *sdp); 104 static void acpi_handle_pptt(ACPI_TABLE_HEADER *sdp); 105 static void acpi_handle_sbst(ACPI_TABLE_HEADER *sdp); 106 static void acpi_handle_slit(ACPI_TABLE_HEADER *sdp); 107 static void acpi_handle_spcr(ACPI_TABLE_HEADER *sdp); 108 static void acpi_handle_spmi(ACPI_TABLE_HEADER *sdp); 109 static void acpi_print_srat_cpu(uint8_t type, uint32_t apic_id, 110 uint32_t proximity_domain, 111 uint32_t flags, uint32_t clockdomain, uint8_t sapic_eid); 112 static void acpi_print_srat_memory(ACPI_SRAT_MEM_AFFINITY *mp); 113 static void acpi_print_srat(ACPI_SUBTABLE_HEADER *srat); 114 static void acpi_handle_srat(ACPI_TABLE_HEADER *sdp); 115 static void acpi_handle_tcpa(ACPI_TABLE_HEADER *sdp); 116 static void acpi_print_nfit(ACPI_NFIT_HEADER *nfit); 117 static void acpi_handle_nfit(ACPI_TABLE_HEADER *sdp); 118 static void acpi_handle_uefi(ACPI_TABLE_HEADER *sdp); 119 static void acpi_handle_waet(ACPI_TABLE_HEADER *sdp); 120 static void acpi_handle_wdat(ACPI_TABLE_HEADER *sdp); 121 static void acpi_handle_wddt(ACPI_TABLE_HEADER *sdp); 122 static void acpi_handle_wdrt(ACPI_TABLE_HEADER *sdp); 123 static void acpi_print_sdt(ACPI_TABLE_HEADER *sdp); 124 static void acpi_print_fadt(ACPI_TABLE_HEADER *sdp); 125 static void acpi_print_facs(ACPI_TABLE_FACS *facs); 126 static void acpi_print_dsdt(ACPI_TABLE_HEADER *dsdp); 127 static ACPI_TABLE_HEADER *acpi_map_sdt(vm_offset_t pa); 128 static void acpi_print_rsd_ptr(ACPI_TABLE_RSDP *rp); 129 static void acpi_handle_rsdt(ACPI_TABLE_HEADER *rsdp); 130 static void acpi_walk_subtables(ACPI_TABLE_HEADER *table, void *first, 131 void (*action)(ACPI_SUBTABLE_HEADER *)); 132 static void acpi_walk_nfit(ACPI_TABLE_HEADER *table, void *first, 133 void (*action)(ACPI_NFIT_HEADER *)); 134 135 /* Size of an address. 32-bit for ACPI 1.0, 64-bit for ACPI 2.0 and up. */ 136 static int addr_size; 137 138 /* Strings used in the TCPA table */ 139 static const char *tcpa_event_type_strings[] = { 140 "PREBOOT Certificate", 141 "POST Code", 142 "Unused", 143 "No Action", 144 "Separator", 145 "Action", 146 "Event Tag", 147 "S-CRTM Contents", 148 "S-CRTM Version", 149 "CPU Microcode", 150 "Platform Config Flags", 151 "Table of Devices", 152 "Compact Hash", 153 "IPL", 154 "IPL Partition Data", 155 "Non-Host Code", 156 "Non-Host Config", 157 "Non-Host Info" 158 }; 159 160 static const char *TCPA_pcclient_strings[] = { 161 "<undefined>", 162 "SMBIOS", 163 "BIS Certificate", 164 "POST BIOS ROM Strings", 165 "ESCD", 166 "CMOS", 167 "NVRAM", 168 "Option ROM Execute", 169 "Option ROM Configurateion", 170 "<undefined>", 171 "Option ROM Microcode Update ", 172 "S-CRTM Version String", 173 "S-CRTM Contents", 174 "POST Contents", 175 "Table of Devices", 176 }; 177 178 #define PRINTFLAG_END() printflag_end() 179 180 static char pf_sep = '{'; 181 182 static void 183 printflag_end(void) 184 { 185 186 if (pf_sep == ',') { 187 printf("}"); 188 } else if (pf_sep == '{') { 189 printf("{}"); 190 } 191 pf_sep = '{'; 192 printf("\n"); 193 } 194 195 static void 196 printflag(uint64_t var, uint64_t mask, const char *name) 197 { 198 199 if (var & mask) { 200 printf("%c%s", pf_sep, name); 201 pf_sep = ','; 202 } 203 } 204 205 static void 206 acpi_print_string(char *s, size_t length) 207 { 208 int c; 209 210 /* Trim trailing spaces and NULLs */ 211 while (length > 0 && (s[length - 1] == ' ' || s[length - 1] == '\0')) 212 length--; 213 214 while (length--) { 215 c = *s++; 216 putchar(c); 217 } 218 } 219 220 static void 221 acpi_print_gas(ACPI_GENERIC_ADDRESS *gas) 222 { 223 switch (gas->SpaceId) { 224 case ACPI_ADR_SPACE_SYSTEM_MEMORY: 225 if (gas->BitWidth <= 32) 226 printf("0x%08x:%u[%u] (Memory)", 227 (u_int)gas->Address, gas->BitOffset, 228 gas->BitWidth); 229 else 230 printf("0x%016jx:%u[%u] (Memory)", 231 (uintmax_t)gas->Address, gas->BitOffset, 232 gas->BitWidth); 233 break; 234 case ACPI_ADR_SPACE_SYSTEM_IO: 235 printf("0x%02x:%u[%u] (IO)", (u_int)gas->Address, 236 gas->BitOffset, gas->BitWidth); 237 break; 238 case ACPI_ADR_SPACE_PCI_CONFIG: 239 printf("%x:%x+0x%x (PCI)", (uint16_t)(gas->Address >> 32), 240 (uint16_t)((gas->Address >> 16) & 0xffff), 241 (uint16_t)gas->Address); 242 break; 243 /* XXX How to handle these below? */ 244 case ACPI_ADR_SPACE_EC: 245 printf("0x%x:%u[%u] (EC)", (uint16_t)gas->Address, 246 gas->BitOffset, gas->BitWidth); 247 break; 248 case ACPI_ADR_SPACE_SMBUS: 249 printf("0x%x:%u[%u] (SMBus)", (uint16_t)gas->Address, 250 gas->BitOffset, gas->BitWidth); 251 break; 252 case ACPI_ADR_SPACE_CMOS: 253 case ACPI_ADR_SPACE_PCI_BAR_TARGET: 254 case ACPI_ADR_SPACE_IPMI: 255 case ACPI_ADR_SPACE_GPIO: 256 case ACPI_ADR_SPACE_GSBUS: 257 case ACPI_ADR_SPACE_PLATFORM_COMM: 258 case ACPI_ADR_SPACE_FIXED_HARDWARE: 259 default: 260 printf("0x%016jx (SpaceID=%hhu)", (uintmax_t)gas->Address, 261 gas->SpaceId); 262 break; 263 } 264 } 265 266 static void 267 acpi_print_pci(uint16_t vendorid, uint16_t deviceid, 268 uint8_t seg, uint8_t bus, uint8_t device, uint8_t func) 269 { 270 if (vendorid == 0xffff && deviceid == 0xffff) { 271 printf("\tPCI Device=NONE\n"); 272 return; 273 } 274 275 printf("\tPCI device={\n"); 276 printf("\t\tVendor=0x%x\n", vendorid); 277 printf("\t\tDevice=0x%x\n", deviceid); 278 printf("\n"); 279 printf("\t\tSegment Group=%d\n", seg); 280 printf("\t\tBus=%d\n", bus); 281 printf("\t\tDevice=%d\n", device); 282 printf("\t\tFunction=%d\n", func); 283 printf("\t}\n"); 284 } 285 286 static void 287 acpi_print_pci_sbdf(uint8_t seg, uint8_t bus, uint8_t device, uint8_t func) 288 { 289 if (bus == 0xff && device == 0xff && func == 0xff) { 290 printf("\tPCI Device=NONE\n"); 291 return; 292 } 293 294 printf("\tPCI device={\n"); 295 printf("\t\tSegment Group=%d\n", seg); 296 printf("\t\tBus=%d\n", bus); 297 printf("\t\tDevice=%d\n", device); 298 printf("\t\tFunction=%d\n", func); 299 printf("\t}\n"); 300 } 301 302 #ifdef notyet 303 static void 304 acpi_print_hest_errorseverity(uint32_t error) 305 { 306 printf("\tError Severity={ "); 307 switch (error) { 308 case 0: 309 printf("Recoverable"); 310 break; 311 case 1: 312 printf("Fatal"); 313 break; 314 case 2: 315 printf("Corrected"); 316 break; 317 case 3: 318 printf("None"); 319 break; 320 default: 321 printf("%d (reserved)", error); 322 break; 323 } 324 printf("}\n"); 325 } 326 #endif 327 328 static void 329 acpi_print_hest_errorbank(ACPI_HEST_IA_ERROR_BANK *bank) 330 { 331 printf("\n"); 332 printf("\tBank Number=%d\n", bank->BankNumber); 333 printf("\tClear Status On Init={%s}\n", 334 bank->ClearStatusOnInit ? "NO" : "YES"); 335 printf("\tStatus Data Format={ "); 336 switch (bank->StatusFormat) { 337 case 0: 338 printf("IA32 MCA"); 339 break; 340 case 1: 341 printf("EMT64 MCA"); 342 break; 343 case 2: 344 printf("AMD64 MCA"); 345 break; 346 } 347 printf(" }\n"); 348 349 if (bank->ControlRegister) 350 printf("\tControl Register=0x%x\n", bank->ControlRegister); 351 printf("\tControl Init Data=0x%"PRIx64"\n", bank->ControlData); 352 printf("\tStatus MSR=0x%x\n", bank->StatusRegister); 353 printf("\tAddress MSR=0x%x\n", bank->AddressRegister); 354 printf("\tMisc MSR=0x%x\n", bank->MiscRegister); 355 } 356 357 static void 358 acpi_print_hest_header(ACPI_HEST_HEADER *hest) 359 { 360 printf("\tType={"); 361 switch (hest->Type) { 362 case ACPI_HEST_TYPE_IA32_CHECK: 363 printf("IA32 Machine Check Exception"); 364 break; 365 case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK: 366 printf("IA32 Corrected Machine Check"); 367 break; 368 case ACPI_HEST_TYPE_IA32_NMI: 369 printf("IA32 Non-Maskable Interrupt"); 370 break; 371 case ACPI_HEST_TYPE_NOT_USED3: 372 case ACPI_HEST_TYPE_NOT_USED4: 373 case ACPI_HEST_TYPE_NOT_USED5: 374 printf("unused type: %d", hest->Type); 375 break; 376 case ACPI_HEST_TYPE_AER_ROOT_PORT: 377 printf("PCI Express Root Port AER"); 378 break; 379 case ACPI_HEST_TYPE_AER_ENDPOINT: 380 printf("PCI Express Endpoint AER"); 381 break; 382 case ACPI_HEST_TYPE_AER_BRIDGE: 383 printf("PCI Express/PCI-X Bridge AER"); 384 break; 385 case ACPI_HEST_TYPE_GENERIC_ERROR: 386 printf("Generic Hardware Error Source"); 387 break; 388 case ACPI_HEST_TYPE_GENERIC_ERROR_V2: 389 printf("Generic Hardware Error Source version 2"); 390 break; 391 case ACPI_HEST_TYPE_RESERVED: 392 default: 393 printf("Reserved (%d)", hest->Type); 394 break; 395 } 396 printf("}\n"); 397 printf("\tSourceId=%d\n", hest->SourceId); 398 } 399 400 static void 401 acpi_print_hest_aer_common(ACPI_HEST_AER_COMMON *data) 402 { 403 404 #define PRINTFLAG(var, flag) printflag((var), ACPI_HEST_## flag, #flag) 405 406 printf("\tFlags="); 407 PRINTFLAG(data->Flags, FIRMWARE_FIRST); 408 PRINTFLAG(data->Flags, GLOBAL); 409 PRINTFLAG(data->Flags, GHES_ASSIST); 410 PRINTFLAG_END(); 411 412 #undef PRINTFLAG 413 414 printf("\tEnabled={ %s ", data->Flags ? "YES" : "NO"); 415 if (data->Flags & ACPI_HEST_FIRMWARE_FIRST) 416 printf("(ignored) "); 417 printf("}\n"); 418 printf("\tNumber of Record to pre-allocate=%d\n", 419 data->RecordsToPreallocate); 420 printf("\tMax. Sections per Record=%d\n", data->MaxSectionsPerRecord); 421 if (!(data->Flags & ACPI_HEST_GLOBAL)) 422 acpi_print_pci_sbdf(0, data->Bus, data->Device, data->Function); 423 printf("\tDevice Control=0x%x\n", data->DeviceControl); 424 printf("\tUncorrectable Error Mask Register=0x%x\n", 425 data->UncorrectableMask); 426 printf("\tUncorrectable Error Severity Register=0x%x\n", 427 data->UncorrectableSeverity); 428 printf("\tCorrectable Error Mask Register=0x%x\n", 429 data->CorrectableMask); 430 printf("\tAdvanced Capabilities Register=0x%x\n", 431 data->AdvancedCapabilities); 432 } 433 434 static void 435 acpi_print_hest_notify(ACPI_HEST_NOTIFY *notify) 436 { 437 printf("\tHW Error Notification={\n"); 438 printf("\t\tType={"); 439 switch (notify->Type) { 440 case ACPI_HEST_NOTIFY_POLLED: 441 printf("POLLED"); 442 break; 443 case ACPI_HEST_NOTIFY_EXTERNAL: 444 printf("EXTERN"); 445 break; 446 case ACPI_HEST_NOTIFY_LOCAL: 447 printf("LOCAL"); 448 break; 449 case ACPI_HEST_NOTIFY_SCI: 450 printf("SCI"); 451 break; 452 case ACPI_HEST_NOTIFY_NMI: 453 printf("NMI"); 454 break; 455 case ACPI_HEST_NOTIFY_CMCI: 456 printf("CMCI"); 457 break; 458 case ACPI_HEST_NOTIFY_MCE: 459 printf("MCE"); 460 break; 461 case ACPI_HEST_NOTIFY_GPIO: 462 printf("GPIO-Signal"); 463 break; 464 case ACPI_HEST_NOTIFY_SEA: 465 printf("ARMv8 SEA"); 466 break; 467 case ACPI_HEST_NOTIFY_SEI: 468 printf("ARMv8 SEI"); 469 break; 470 case ACPI_HEST_NOTIFY_GSIV: 471 printf("External Interrupt - GSIV"); 472 break; 473 case ACPI_HEST_NOTIFY_RESERVED: 474 printf("RESERVED"); 475 break; 476 default: 477 printf("%d (reserved)", notify->Type); 478 break; 479 } 480 printf("}\n"); 481 482 printf("\t\tLength=%d\n", notify->Length); 483 484 #define PRINTFLAG(var, flag) printflag((var), ACPI_HEST_## flag, #flag) 485 486 printf("\t\tConfig Write Enable="); 487 PRINTFLAG(notify->ConfigWriteEnable, TYPE); 488 PRINTFLAG(notify->ConfigWriteEnable, POLL_INTERVAL); 489 PRINTFLAG(notify->ConfigWriteEnable, POLL_THRESHOLD_VALUE); 490 PRINTFLAG(notify->ConfigWriteEnable, POLL_THRESHOLD_WINDOW); 491 PRINTFLAG(notify->ConfigWriteEnable, ERR_THRESHOLD_VALUE); 492 PRINTFLAG(notify->ConfigWriteEnable, ERR_THRESHOLD_WINDOW); 493 PRINTFLAG_END(); 494 495 #undef PRINTFLAG 496 497 printf("\t\tPoll Interval=%d msec\n", notify->PollInterval); 498 printf("\t\tInterrupt Vector=%d\n", notify->Vector); 499 printf("\t\tSwitch To Polling Threshold Value=%d\n", 500 notify->PollingThresholdValue); 501 printf("\t\tSwitch To Polling Threshold Window=%d msec\n", 502 notify->PollingThresholdWindow); 503 printf("\t\tError Threshold Value=%d\n", 504 notify->ErrorThresholdValue); 505 printf("\t\tError Threshold Window=%d msec\n", 506 notify->ErrorThresholdWindow); 507 printf("\t}\n"); 508 } 509 510 #ifdef notyet 511 static void 512 acpi_print_hest_generic_status(ACPI_HEST_GENERIC_STATUS *data) 513 { 514 uint32_t i, pos, entries; 515 ACPI_HEST_GENERIC_DATA *gen; 516 517 entries = data->BlockStatus & ACPI_HEST_ERROR_ENTRY_COUNT; 518 519 printf("\tGeneric Error Status={\n"); 520 printf("\t\tBlock Status={ "); 521 if (data->BlockStatus & ACPI_HEST_UNCORRECTABLE) 522 printf("UNCORRECTABLE"); 523 if (data->BlockStatus & ACPI_HEST_CORRECTABLE) 524 printf("CORRECTABLE"); 525 if (data->BlockStatus & ACPI_HEST_MULTIPLE_UNCORRECTABLE) 526 printf("MULTIPLE UNCORRECTABLE"); 527 if (data->BlockStatus & ACPI_HEST_MULTIPLE_CORRECTABLE) 528 printf("MULTIPLE CORRECTABLE"); 529 printf(" }\n"); 530 printf("\t\tEntry Count=%d\n", entries); 531 printf("\t\tRaw Data Offset=%d\n", data->RawDataOffset); 532 printf("\t\tRaw Data Length=%d\n", data->RawDataLength); 533 printf("\t\tData Length=%d\n", data->DataLength); 534 printf("\t"); 535 acpi_print_hest_errorseverity(data->ErrorSeverity); 536 printf("\t}\n"); 537 538 pos = sizeof(ACPI_HEST_GENERIC_STATUS); 539 for (i = 0; i < entries; i++) { 540 gen = (ACPI_HEST_GENERIC_DATA *)((char *)data + pos); 541 acpi_print_hest_generic_data(gen); 542 pos += sizeof(ACPI_HEST_GENERIC_DATA); 543 } 544 } 545 #endif 546 547 #ifdef notyet 548 static void 549 acpi_print_hest_generic_data(ACPI_HEST_GENERIC_DATA *data) 550 { 551 printf("\tGeneric Error Data={\n"); 552 printf("\t\tSectionType="); 553 acpi_print_string((char *)data->SectionType, sizeof(data->SectionType)); 554 printf("\n\t"); 555 acpi_print_hest_errorseverity(data->ErrorSeverity); 556 printf("\t\tRevision=0x%x\n", data->Revision); 557 printf("\t\tValidation Bits=0x%x\n", data->ValidationBits); 558 printf("\t\tFlags=0x%x\n", data->Flags); 559 printf("\t\tData Length=%d\n", data->ErrorDataLength); 560 printf("\t\tField Replication Unit Id="); 561 acpi_print_string((char *)data->FruId, sizeof(data->FruId)); 562 printf("\n"); 563 printf("\t\tField Replication Unit="); 564 acpi_print_string((char *)data->FruText, sizeof(data->FruText)); 565 printf("\n"); 566 printf("\t}\n"); 567 } 568 #endif 569 570 static void 571 acpi_print_whea(ACPI_WHEA_HEADER *whea, 572 void (*print_action)(ACPI_WHEA_HEADER *), 573 void (*print_ins)(ACPI_WHEA_HEADER *), 574 void (*print_flags)(ACPI_WHEA_HEADER *)) 575 { 576 printf("\n"); 577 578 print_action(whea); 579 print_ins(whea); 580 if (print_flags) 581 print_flags(whea); 582 printf("\tRegisterRegion="); 583 acpi_print_gas(&whea->RegisterRegion); 584 printf("\n"); 585 printf("\tMASK=0x%08"PRIx64"\n", whea->Mask); 586 } 587 588 static void 589 acpi_print_hest_ia32_check(ACPI_HEST_IA_MACHINE_CHECK *data) 590 { 591 uint32_t i, pos; 592 ACPI_HEST_IA_ERROR_BANK *bank; 593 594 acpi_print_hest_header(&data->Header); 595 printf("\tFlags={ "); 596 if (data->Flags & ACPI_HEST_FIRMWARE_FIRST) 597 printf("FIRMWARE_FIRST"); 598 printf(" }\n"); 599 printf("\tEnabled={ %s }\n", data->Enabled ? "YES" : "NO"); 600 printf("\tNumber of Record to pre-allocate=%d\n", 601 data->RecordsToPreallocate); 602 printf("\tMax Sections per Record=%d\n", 603 data->MaxSectionsPerRecord); 604 printf("\tGlobal Capability Init Data=0x%"PRIx64"\n", 605 data->GlobalCapabilityData); 606 printf("\tGlobal Control Init Data=0x%"PRIx64"\n", 607 data->GlobalControlData); 608 printf("\tNumber of Hardware Error Reporting Banks=%d\n", 609 data->NumHardwareBanks); 610 611 pos = sizeof(ACPI_HEST_IA_MACHINE_CHECK); 612 for (i = 0; i < data->NumHardwareBanks; i++) { 613 bank = (ACPI_HEST_IA_ERROR_BANK *)((char *)data + pos); 614 acpi_print_hest_errorbank(bank); 615 pos += sizeof(ACPI_HEST_IA_ERROR_BANK); 616 } 617 } 618 619 static void 620 acpi_print_hest_ia32_correctedcheck(ACPI_HEST_IA_CORRECTED *data) 621 { 622 uint32_t i, pos; 623 ACPI_HEST_IA_ERROR_BANK *bank; 624 625 acpi_print_hest_header(&data->Header); 626 printf("\tFlags={ "); 627 if (data->Flags & ACPI_HEST_FIRMWARE_FIRST) 628 printf("FIRMWARE_FIRST"); 629 printf(" }\n"); 630 printf("\tEnabled={ %s }\n", data->Enabled ? "YES" : "NO"); 631 printf("\tNumber of Record to pre-allocate=%d\n", 632 data->RecordsToPreallocate); 633 printf("\tMax Sections per Record=%d\n", 634 data->MaxSectionsPerRecord); 635 acpi_print_hest_notify(&data->Notify); 636 637 printf("\tNumber of Hardware Error Reporting Banks=%d\n", 638 data->NumHardwareBanks); 639 640 pos = sizeof(ACPI_HEST_IA_MACHINE_CHECK); 641 for (i = 0; i < data->NumHardwareBanks; i++) { 642 bank = (ACPI_HEST_IA_ERROR_BANK *)((char *)data + pos); 643 acpi_print_hest_errorbank(bank); 644 pos += sizeof(ACPI_HEST_IA_ERROR_BANK); 645 } 646 } 647 648 static void 649 acpi_print_hest_ia32_nmi(ACPI_HEST_IA_NMI *data) 650 { 651 acpi_print_hest_header(&data->Header); 652 printf("\tNumber of Record to pre-allocate=%d\n", 653 data->RecordsToPreallocate); 654 printf("\tMax Sections per Record=%d\n", 655 data->MaxSectionsPerRecord); 656 printf("\tMax Raw Data Length=%d\n", 657 data->MaxRawDataLength); 658 } 659 660 static void 661 acpi_print_hest_aer_root(ACPI_HEST_AER_ROOT *data) 662 { 663 acpi_print_hest_header(&data->Header); 664 acpi_print_hest_aer_common(&data->Aer); 665 printf("Root Error Command Register=0x%x\n", data->RootErrorCommand); 666 } 667 668 static void 669 acpi_print_hest_aer_endpoint(ACPI_HEST_AER *data) 670 { 671 acpi_print_hest_header(&data->Header); 672 acpi_print_hest_aer_common(&data->Aer); 673 } 674 675 static void 676 acpi_print_hest_aer_bridge(ACPI_HEST_AER_BRIDGE *data) 677 { 678 acpi_print_hest_header(&data->Header); 679 acpi_print_hest_aer_common(&data->Aer); 680 681 printf("\tSecondary Uncorrectable Error Mask Register=0x%x\n", 682 data->UncorrectableMask2); 683 printf("\tSecondary Uncorrectable Error Severity Register=0x%x\n", 684 data->UncorrectableSeverity2); 685 printf("\tSecondory Advanced Capabilities Register=0x%x\n", 686 data->AdvancedCapabilities2); 687 } 688 689 static void 690 acpi_print_hest_generic(ACPI_HEST_GENERIC *data) 691 { 692 acpi_print_hest_header(&data->Header); 693 if (data->RelatedSourceId != 0xffff) 694 printf("\tReleated SourceId=%d\n", data->RelatedSourceId); 695 printf("\tEnabled={%s}\n", data->Enabled ? "YES" : "NO"); 696 printf("\tNumber of Records to pre-allocate=%u\n", 697 data->RecordsToPreallocate); 698 printf("\tMax Sections per Record=%u\n", data->MaxSectionsPerRecord); 699 printf("\tMax Raw Data Length=%u\n", data->MaxRawDataLength); 700 printf("\tError Status Address="); 701 acpi_print_gas(&data->ErrorStatusAddress); 702 printf("\n"); 703 acpi_print_hest_notify(&data->Notify); 704 printf("\tError Block Length=%u\n", data->ErrorBlockLength); 705 } 706 707 static void 708 acpi_print_hest_generic_v2(ACPI_HEST_GENERIC_V2 *data) 709 { 710 711 /* The first 64 bytes are the same as ACPI_HEST_GENERIC */ 712 acpi_print_hest_generic((ACPI_HEST_GENERIC *)data); 713 714 printf("\tError Status Address"); 715 acpi_print_gas(&data->ReadAckRegister); 716 printf("\tRead Ack Preserve=0x%016jx\n", 717 (uintmax_t)data->ReadAckPreserve); 718 printf("\tRead Ack Write=0x%016jx\n", 719 (uintmax_t)data->ReadAckWrite); 720 } 721 722 static void 723 acpi_handle_hest(ACPI_TABLE_HEADER *sdp) 724 { 725 ACPI_TABLE_HEST *hest; 726 ACPI_HEST_HEADER *subhest; 727 uint32_t i, pos; 728 729 printf(BEGIN_COMMENT); 730 acpi_print_sdt(sdp); 731 hest = (ACPI_TABLE_HEST *)sdp; 732 733 printf("\tError Source Count=%d\n", hest->ErrorSourceCount); 734 pos = sizeof(ACPI_TABLE_HEST); 735 for (i = 0; i < hest->ErrorSourceCount; i++) { 736 subhest = (ACPI_HEST_HEADER *)((char *)hest + pos); 737 printf("\n"); 738 739 switch (subhest->Type) { 740 case ACPI_HEST_TYPE_IA32_CHECK: 741 acpi_print_hest_ia32_check( 742 (ACPI_HEST_IA_MACHINE_CHECK *)subhest); 743 pos += sizeof(ACPI_HEST_IA_MACHINE_CHECK); 744 break; 745 746 case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK: 747 acpi_print_hest_ia32_correctedcheck( 748 (ACPI_HEST_IA_CORRECTED *)subhest); 749 pos += sizeof(ACPI_HEST_IA_CORRECTED); 750 break; 751 752 case ACPI_HEST_TYPE_IA32_NMI: 753 acpi_print_hest_ia32_nmi( 754 (ACPI_HEST_IA_NMI *)subhest); 755 pos += sizeof(ACPI_HEST_IA_NMI); 756 break; 757 758 case ACPI_HEST_TYPE_NOT_USED3: 759 case ACPI_HEST_TYPE_NOT_USED4: 760 case ACPI_HEST_TYPE_NOT_USED5: 761 pos += sizeof(ACPI_HEST_HEADER); 762 break; 763 764 case ACPI_HEST_TYPE_AER_ROOT_PORT: 765 acpi_print_hest_aer_root((ACPI_HEST_AER_ROOT *)subhest); 766 pos += sizeof(ACPI_HEST_AER_ROOT); 767 break; 768 769 case ACPI_HEST_TYPE_AER_ENDPOINT: 770 acpi_print_hest_aer_endpoint((ACPI_HEST_AER *)subhest); 771 pos += sizeof(ACPI_HEST_AER); 772 break; 773 774 case ACPI_HEST_TYPE_AER_BRIDGE: 775 acpi_print_hest_aer_bridge((ACPI_HEST_AER_BRIDGE *)subhest); 776 pos += sizeof(ACPI_HEST_AER_BRIDGE); 777 break; 778 779 case ACPI_HEST_TYPE_GENERIC_ERROR: 780 acpi_print_hest_generic((ACPI_HEST_GENERIC *)subhest); 781 pos += sizeof(ACPI_HEST_GENERIC); 782 break; 783 784 case ACPI_HEST_TYPE_GENERIC_ERROR_V2: 785 acpi_print_hest_generic_v2( 786 (ACPI_HEST_GENERIC_V2 *)subhest); 787 pos += sizeof(ACPI_HEST_GENERIC_V2); 788 break; 789 790 case ACPI_HEST_TYPE_RESERVED: 791 default: 792 pos += sizeof(ACPI_HEST_HEADER); 793 break; 794 } 795 } 796 797 printf(END_COMMENT); 798 } 799 800 static uint64_t 801 acpi_select_address(uint32_t addr32, uint64_t addr64) 802 { 803 804 if (addr64 == 0) 805 return addr32; 806 807 if ((addr32 != 0) && ((addr64 & 0xfffffff) != addr32)) { 808 /* 809 * A few systems (e.g., IBM T23) have an RSDP that claims 810 * revision 2 but the 64 bit addresses are invalid. If 811 * revision 2 and the 32 bit address is non-zero but the 812 * 32 and 64 bit versions don't match, prefer the 32 bit 813 * version for all subsequent tables. 814 */ 815 return addr32; 816 } 817 818 return addr64; 819 } 820 821 static void 822 acpi_handle_fadt(ACPI_TABLE_HEADER *sdp) 823 { 824 ACPI_TABLE_HEADER *dsdp; 825 ACPI_TABLE_FACS *facs; 826 ACPI_TABLE_FADT *fadt; 827 828 fadt = (ACPI_TABLE_FADT *)sdp; 829 acpi_print_fadt(sdp); 830 831 if (acpi_select_address(fadt->Facs, fadt->XFacs) == 0) { 832 if ((fadt->Flags & ACPI_FADT_HW_REDUCED) == 0) 833 errx(EXIT_FAILURE, "Missing FACS and HW_REDUCED_ACPI flag not set in FADT"); 834 } else { 835 facs = (ACPI_TABLE_FACS *)acpi_map_sdt( 836 acpi_select_address(fadt->Facs, fadt->XFacs)); 837 if (memcmp(facs->Signature, ACPI_SIG_FACS, 4) != 0 || facs->Length < 64) 838 errx(EXIT_FAILURE, "FACS is corrupt"); 839 acpi_print_facs(facs); 840 } 841 842 dsdp = (ACPI_TABLE_HEADER *)acpi_map_sdt( 843 acpi_select_address(fadt->Dsdt, fadt->XDsdt)); 844 if (memcmp(dsdp->Signature, ACPI_SIG_DSDT, 4) != 0) 845 errx(EXIT_FAILURE, "DSDT signature mismatch"); 846 if (acpi_checksum(dsdp, dsdp->Length)) 847 errx(EXIT_FAILURE, "DSDT is corrupt"); 848 acpi_print_dsdt(dsdp); 849 } 850 851 static void 852 acpi_walk_subtables(ACPI_TABLE_HEADER *table, void *first, 853 void (*action)(ACPI_SUBTABLE_HEADER *)) 854 { 855 ACPI_SUBTABLE_HEADER *subtable; 856 char *end; 857 858 subtable = first; 859 end = (char *)table + table->Length; 860 while ((char *)subtable < end) { 861 printf("\n"); 862 if (subtable->Length < sizeof(ACPI_SUBTABLE_HEADER)) { 863 warnx("invalid subtable length %u", subtable->Length); 864 return; 865 } 866 action(subtable); 867 subtable = (ACPI_SUBTABLE_HEADER *)((char *)subtable + 868 subtable->Length); 869 } 870 } 871 872 static void 873 acpi_walk_nfit(ACPI_TABLE_HEADER *table, void *first, 874 void (*action)(ACPI_NFIT_HEADER *)) 875 { 876 ACPI_NFIT_HEADER *subtable; 877 char *end; 878 879 subtable = first; 880 end = (char *)table + table->Length; 881 while ((char *)subtable < end) { 882 printf("\n"); 883 if (subtable->Length < sizeof(ACPI_NFIT_HEADER)) { 884 warnx("invalid subtable length %u", subtable->Length); 885 return; 886 } 887 action(subtable); 888 subtable = (ACPI_NFIT_HEADER *)((char *)subtable + 889 subtable->Length); 890 } 891 } 892 893 static void 894 acpi_print_cpu(u_char cpu_id) 895 { 896 897 printf("\tACPI CPU="); 898 if (cpu_id == 0xff) 899 printf("ALL\n"); 900 else 901 printf("%d\n", (u_int)cpu_id); 902 } 903 904 static void 905 acpi_print_cpu_uid(uint32_t uid, char *uid_string) 906 { 907 908 printf("\tUID=%d", uid); 909 if (uid_string != NULL) 910 printf(" (%s)", uid_string); 911 printf("\n"); 912 } 913 914 static void 915 acpi_print_local_apic(uint32_t apic_id, uint32_t flags) 916 { 917 918 printf("\tFlags={"); 919 if (flags & ACPI_MADT_ENABLED) 920 printf("ENABLED"); 921 else 922 printf("DISABLED"); 923 printf("}\n"); 924 printf("\tAPIC ID=%d\n", apic_id); 925 } 926 927 static void 928 acpi_print_io_apic(uint32_t apic_id, uint32_t int_base, uint64_t apic_addr) 929 { 930 931 printf("\tAPIC ID=%d\n", apic_id); 932 printf("\tINT BASE=%d\n", int_base); 933 printf("\tADDR=0x%016jx\n", (uintmax_t)apic_addr); 934 } 935 936 static void 937 acpi_print_mps_flags(uint16_t flags) 938 { 939 940 printf("\tFlags={Polarity="); 941 switch (flags & ACPI_MADT_POLARITY_MASK) { 942 case ACPI_MADT_POLARITY_CONFORMS: 943 printf("conforming"); 944 break; 945 case ACPI_MADT_POLARITY_ACTIVE_HIGH: 946 printf("active-hi"); 947 break; 948 case ACPI_MADT_POLARITY_ACTIVE_LOW: 949 printf("active-lo"); 950 break; 951 default: 952 printf("0x%x", flags & ACPI_MADT_POLARITY_MASK); 953 break; 954 } 955 printf(", Trigger="); 956 switch (flags & ACPI_MADT_TRIGGER_MASK) { 957 case ACPI_MADT_TRIGGER_CONFORMS: 958 printf("conforming"); 959 break; 960 case ACPI_MADT_TRIGGER_EDGE: 961 printf("edge"); 962 break; 963 case ACPI_MADT_TRIGGER_LEVEL: 964 printf("level"); 965 break; 966 default: 967 printf("0x%x", (flags & ACPI_MADT_TRIGGER_MASK) >> 2); 968 } 969 printf("}\n"); 970 } 971 972 static void 973 acpi_print_gicc_flags(uint32_t flags) 974 { 975 976 printf("\tFlags={Performance intr="); 977 if (flags & ACPI_MADT_PERFORMANCE_IRQ_MODE) 978 printf("edge"); 979 else 980 printf("level"); 981 printf(", VGIC intr="); 982 if (flags & ACPI_MADT_VGIC_IRQ_MODE) 983 printf("edge"); 984 else 985 printf("level"); 986 printf("}\n"); 987 } 988 989 static void 990 acpi_print_intr(uint32_t intr, uint16_t mps_flags) 991 { 992 993 printf("\tINTR=%d\n", intr); 994 acpi_print_mps_flags(mps_flags); 995 } 996 997 static void 998 acpi_print_local_nmi(u_int lint, uint16_t mps_flags) 999 { 1000 1001 printf("\tLINT Pin=%d\n", lint); 1002 acpi_print_mps_flags(mps_flags); 1003 } 1004 1005 static const char *apic_types[] = { 1006 [ACPI_MADT_TYPE_LOCAL_APIC] = "Local APIC", 1007 [ACPI_MADT_TYPE_IO_APIC] = "IO APIC", 1008 [ACPI_MADT_TYPE_INTERRUPT_OVERRIDE] = "INT Override", 1009 [ACPI_MADT_TYPE_NMI_SOURCE] = "NMI", 1010 [ACPI_MADT_TYPE_LOCAL_APIC_NMI] = "Local APIC NMI", 1011 [ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE] = "Local APIC Override", 1012 [ACPI_MADT_TYPE_IO_SAPIC] = "IO SAPIC", 1013 [ACPI_MADT_TYPE_LOCAL_SAPIC] = "Local SAPIC", 1014 [ACPI_MADT_TYPE_INTERRUPT_SOURCE] = "Platform Interrupt", 1015 [ACPI_MADT_TYPE_LOCAL_X2APIC] = "Local X2APIC", 1016 [ACPI_MADT_TYPE_LOCAL_X2APIC_NMI] = "Local X2APIC NMI", 1017 [ACPI_MADT_TYPE_GENERIC_INTERRUPT] = "GIC CPU Interface Structure", 1018 [ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR] = "GIC Distributor Structure", 1019 [ACPI_MADT_TYPE_GENERIC_MSI_FRAME] = "GICv2m MSI Frame", 1020 [ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR] = "GIC Redistributor Structure", 1021 [ACPI_MADT_TYPE_GENERIC_TRANSLATOR] = "GIC ITS Structure" 1022 }; 1023 1024 static const char *platform_int_types[] = { "0 (unknown)", "PMI", "INIT", 1025 "Corrected Platform Error" }; 1026 1027 static void 1028 acpi_print_gicm_flags(ACPI_MADT_GENERIC_MSI_FRAME *gicm) 1029 { 1030 uint32_t flags = gicm->Flags; 1031 1032 printf("\tFLAGS={"); 1033 if (flags & ACPI_MADT_OVERRIDE_SPI_VALUES) 1034 printf("SPI Count/Base Select"); 1035 printf("}\n"); 1036 } 1037 1038 static void 1039 acpi_print_madt(ACPI_SUBTABLE_HEADER *mp) 1040 { 1041 ACPI_MADT_LOCAL_APIC *lapic; 1042 ACPI_MADT_IO_APIC *ioapic; 1043 ACPI_MADT_INTERRUPT_OVERRIDE *over; 1044 ACPI_MADT_NMI_SOURCE *nmi; 1045 ACPI_MADT_LOCAL_APIC_NMI *lapic_nmi; 1046 ACPI_MADT_LOCAL_APIC_OVERRIDE *lapic_over; 1047 ACPI_MADT_IO_SAPIC *iosapic; 1048 ACPI_MADT_LOCAL_SAPIC *lsapic; 1049 ACPI_MADT_INTERRUPT_SOURCE *isrc; 1050 ACPI_MADT_LOCAL_X2APIC *x2apic; 1051 ACPI_MADT_LOCAL_X2APIC_NMI *x2apic_nmi; 1052 ACPI_MADT_GENERIC_INTERRUPT *gicc; 1053 ACPI_MADT_GENERIC_DISTRIBUTOR *gicd; 1054 ACPI_MADT_GENERIC_MSI_FRAME *gicm; 1055 ACPI_MADT_GENERIC_REDISTRIBUTOR *gicr; 1056 ACPI_MADT_GENERIC_TRANSLATOR *gict; 1057 1058 if (mp->Type < __arraycount(apic_types)) 1059 printf("\tType=%s\n", apic_types[mp->Type]); 1060 else 1061 printf("\tType=%d (unknown)\n", mp->Type); 1062 switch (mp->Type) { 1063 case ACPI_MADT_TYPE_LOCAL_APIC: 1064 lapic = (ACPI_MADT_LOCAL_APIC *)mp; 1065 acpi_print_cpu(lapic->ProcessorId); 1066 acpi_print_local_apic(lapic->Id, lapic->LapicFlags); 1067 break; 1068 case ACPI_MADT_TYPE_IO_APIC: 1069 ioapic = (ACPI_MADT_IO_APIC *)mp; 1070 acpi_print_io_apic(ioapic->Id, ioapic->GlobalIrqBase, 1071 ioapic->Address); 1072 break; 1073 case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE: 1074 over = (ACPI_MADT_INTERRUPT_OVERRIDE *)mp; 1075 printf("\tBUS=%d\n", (u_int)over->Bus); 1076 printf("\tIRQ=%d\n", (u_int)over->SourceIrq); 1077 acpi_print_intr(over->GlobalIrq, over->IntiFlags); 1078 break; 1079 case ACPI_MADT_TYPE_NMI_SOURCE: 1080 nmi = (ACPI_MADT_NMI_SOURCE *)mp; 1081 acpi_print_intr(nmi->GlobalIrq, nmi->IntiFlags); 1082 break; 1083 case ACPI_MADT_TYPE_LOCAL_APIC_NMI: 1084 lapic_nmi = (ACPI_MADT_LOCAL_APIC_NMI *)mp; 1085 acpi_print_cpu(lapic_nmi->ProcessorId); 1086 acpi_print_local_nmi(lapic_nmi->Lint, lapic_nmi->IntiFlags); 1087 break; 1088 case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE: 1089 lapic_over = (ACPI_MADT_LOCAL_APIC_OVERRIDE *)mp; 1090 printf("\tLocal APIC ADDR=0x%016jx\n", 1091 (uintmax_t)lapic_over->Address); 1092 break; 1093 case ACPI_MADT_TYPE_IO_SAPIC: 1094 iosapic = (ACPI_MADT_IO_SAPIC *)mp; 1095 acpi_print_io_apic(iosapic->Id, iosapic->GlobalIrqBase, 1096 iosapic->Address); 1097 break; 1098 case ACPI_MADT_TYPE_LOCAL_SAPIC: 1099 lsapic = (ACPI_MADT_LOCAL_SAPIC *)mp; 1100 acpi_print_cpu(lsapic->ProcessorId); 1101 acpi_print_local_apic(lsapic->Id, lsapic->LapicFlags); 1102 printf("\tAPIC EID=%d\n", (u_int)lsapic->Eid); 1103 if (mp->Length > offsetof(ACPI_MADT_LOCAL_SAPIC, Uid)) 1104 acpi_print_cpu_uid(lsapic->Uid, lsapic->UidString); 1105 break; 1106 case ACPI_MADT_TYPE_INTERRUPT_SOURCE: 1107 isrc = (ACPI_MADT_INTERRUPT_SOURCE *)mp; 1108 if (isrc->Type < __arraycount(platform_int_types)) 1109 printf("\tType=%s\n", platform_int_types[isrc->Type]); 1110 else 1111 printf("\tType=%d (unknown)\n", isrc->Type); 1112 printf("\tAPIC ID=%d\n", (u_int)isrc->Id); 1113 printf("\tAPIC EID=%d\n", (u_int)isrc->Eid); 1114 printf("\tSAPIC Vector=%d\n", (u_int)isrc->IoSapicVector); 1115 acpi_print_intr(isrc->GlobalIrq, isrc->IntiFlags); 1116 break; 1117 case ACPI_MADT_TYPE_LOCAL_X2APIC: 1118 x2apic = (ACPI_MADT_LOCAL_X2APIC *)mp; 1119 acpi_print_cpu_uid(x2apic->Uid, NULL); 1120 acpi_print_local_apic(x2apic->LocalApicId, x2apic->LapicFlags); 1121 break; 1122 case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI: 1123 x2apic_nmi = (ACPI_MADT_LOCAL_X2APIC_NMI *)mp; 1124 acpi_print_cpu_uid(x2apic_nmi->Uid, NULL); 1125 acpi_print_local_nmi(x2apic_nmi->Lint, x2apic_nmi->IntiFlags); 1126 break; 1127 case ACPI_MADT_TYPE_GENERIC_INTERRUPT: 1128 gicc = (ACPI_MADT_GENERIC_INTERRUPT *)mp; 1129 acpi_print_cpu_uid(gicc->Uid, NULL); 1130 printf("\tCPU INTERFACE=%x\n", gicc->CpuInterfaceNumber); 1131 acpi_print_gicc_flags(gicc->Flags); 1132 printf("\tParking Protocol Version=%x\n", gicc->ParkingVersion); 1133 printf("\tPERF INTR=%d\n", gicc->PerformanceInterrupt); 1134 printf("\tParked ADDR=%016jx\n", 1135 (uintmax_t)gicc->ParkedAddress); 1136 printf("\tBase ADDR=%016jx\n", (uintmax_t)gicc->BaseAddress); 1137 printf("\tGICV=%016jx\n", (uintmax_t)gicc->GicvBaseAddress); 1138 printf("\tGICH=%016jx\n", (uintmax_t)gicc->GichBaseAddress); 1139 printf("\tVGIC INTR=%d\n", gicc->VgicInterrupt); 1140 printf("\tGICR ADDR=%016jx\n", 1141 (uintmax_t)gicc->GicrBaseAddress); 1142 printf("\tMPIDR=%jx\n", (uintmax_t)gicc->ArmMpidr); 1143 printf("\tEfficency Class=%d\n", (u_int)gicc->EfficiencyClass); 1144 break; 1145 case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR: 1146 gicd = (ACPI_MADT_GENERIC_DISTRIBUTOR *)mp; 1147 printf("\tGIC ID=%d\n", (u_int)gicd->GicId); 1148 printf("\tBase ADDR=%016jx\n", (uintmax_t)gicd->BaseAddress); 1149 printf("\tVector Base=%d\n", gicd->GlobalIrqBase); 1150 printf("\tGIC VERSION=%d\n", (u_int)gicd->Version); 1151 break; 1152 case ACPI_MADT_TYPE_GENERIC_MSI_FRAME: 1153 gicm = (ACPI_MADT_GENERIC_MSI_FRAME*)mp; 1154 printf("\tBase ADDR=%016jx\n", (uintmax_t)gicm->BaseAddress); 1155 acpi_print_gicm_flags(gicm); 1156 printf("\tSPI Count=%u\n", gicm->SpiCount); 1157 printf("\tSPI Base=%u\n", gicm->SpiBase); 1158 break; 1159 case ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR: 1160 gicr = (ACPI_MADT_GENERIC_REDISTRIBUTOR *)mp; 1161 printf("\tBase ADDR=%016jx\n", (uintmax_t)gicr->BaseAddress); 1162 printf("\tLength=%08x\n", gicr->Length); 1163 break; 1164 case ACPI_MADT_TYPE_GENERIC_TRANSLATOR: 1165 gict = (ACPI_MADT_GENERIC_TRANSLATOR *)mp; 1166 printf("\tGIC ITS ID=%d\n", gict->TranslationId); 1167 printf("\tBase ADDR=%016jx\n", (uintmax_t)gict->BaseAddress); 1168 break; 1169 } 1170 } 1171 1172 #ifdef notyet 1173 static void 1174 acpi_print_bert_region(ACPI_BERT_REGION *region) 1175 { 1176 uint32_t i, pos, entries; 1177 ACPI_HEST_GENERIC_DATA *data; 1178 1179 printf("\n"); 1180 printf("\tBlockStatus={ "); 1181 1182 if (region->BlockStatus & ACPI_BERT_UNCORRECTABLE) 1183 printf("Uncorrectable"); 1184 if (region->BlockStatus & ACPI_BERT_CORRECTABLE) 1185 printf("Correctable"); 1186 if (region->BlockStatus & ACPI_BERT_MULTIPLE_UNCORRECTABLE) 1187 printf("Multiple Uncorrectable"); 1188 if (region->BlockStatus & ACPI_BERT_MULTIPLE_CORRECTABLE) 1189 printf("Multiple Correctable"); 1190 entries = region->BlockStatus & ACPI_BERT_ERROR_ENTRY_COUNT; 1191 printf(", Error Entry Count=%d", entries); 1192 printf("}\n"); 1193 1194 printf("\tRaw Data Offset=0x%x\n", region->RawDataOffset); 1195 printf("\tRaw Data Length=0x%x\n", region->RawDataLength); 1196 printf("\tData Length=0x%x\n", region->DataLength); 1197 1198 acpi_print_hest_errorseverity(region->ErrorSeverity); 1199 1200 pos = sizeof(ACPI_BERT_REGION); 1201 for (i = 0; i < entries; i++) { 1202 data = (ACPI_HEST_GENERIC_DATA *)((char *)region + pos); 1203 acpi_print_hest_generic_data(data); 1204 pos += sizeof(ACPI_HEST_GENERIC_DATA); 1205 } 1206 } 1207 #endif 1208 1209 static void 1210 acpi_handle_bert(ACPI_TABLE_HEADER *sdp) 1211 { 1212 ACPI_TABLE_BERT *bert; 1213 1214 printf(BEGIN_COMMENT); 1215 acpi_print_sdt(sdp); 1216 bert = (ACPI_TABLE_BERT *)sdp; 1217 1218 printf("\tLength of Boot Error Region=%d bytes\n", bert->RegionLength); 1219 printf("\tPhysical Address of Region=0x%"PRIx64"\n", bert->Address); 1220 1221 printf(END_COMMENT); 1222 } 1223 1224 static void 1225 acpi_handle_boot(ACPI_TABLE_HEADER *sdp) 1226 { 1227 ACPI_TABLE_BOOT *boot; 1228 1229 printf(BEGIN_COMMENT); 1230 acpi_print_sdt(sdp); 1231 boot = (ACPI_TABLE_BOOT *)sdp; 1232 printf("\tCMOS Index=0x%02x\n", boot->CmosIndex); 1233 printf(END_COMMENT); 1234 } 1235 1236 static void 1237 acpi_handle_cpep(ACPI_TABLE_HEADER *sdp) 1238 { 1239 ACPI_TABLE_CPEP *cpep; 1240 ACPI_CPEP_POLLING *poll; 1241 uint32_t cpep_pos; 1242 1243 printf(BEGIN_COMMENT); 1244 acpi_print_sdt(sdp); 1245 cpep = (ACPI_TABLE_CPEP *)sdp; 1246 1247 cpep_pos = sizeof(ACPI_TABLE_CPEP); 1248 while (cpep_pos < sdp->Length) { 1249 poll = (ACPI_CPEP_POLLING *)((char *)cpep + cpep_pos); 1250 acpi_print_cpu(poll->Id); 1251 printf("\tACPI CPU EId=%d\n", poll->Eid); 1252 printf("\tPoll Interval=%d msec\n", poll->Interval); 1253 cpep_pos += sizeof(ACPI_CPEP_POLLING); 1254 } 1255 printf(END_COMMENT); 1256 } 1257 1258 static void 1259 acpi_print_csrt_resource_group(ACPI_CSRT_GROUP *grp) 1260 { 1261 ACPI_CSRT_DESCRIPTOR *desc; 1262 1263 printf("\tLength=%u\n", grp->Length); 1264 printf("\tVendorId="); 1265 acpi_print_string((char *)&grp->VendorId, 4); 1266 printf("\n"); 1267 if (grp->SubvendorId != 0) { 1268 printf("\tSubvendorId="); 1269 acpi_print_string((char *)&grp->SubvendorId, 4); 1270 printf("\n"); 1271 } 1272 printf("\tDeviceId=0x%08x\n", grp->DeviceId); 1273 if (grp->SubdeviceId != 0) 1274 printf("\tSubdeviceId=0x%08x\n", grp->SubdeviceId); 1275 printf("\tRevision=%hu\n", grp->Revision); 1276 printf("\tSharedInfoLength=%u\n", grp->SharedInfoLength); 1277 1278 /* Next is Shared Info */ 1279 if (grp->SharedInfoLength != 0) { 1280 printf("\tShared Info "); 1281 acpi_dump_bytes((uint8_t *)(grp + 1), 1282 grp->SharedInfoLength, 1); 1283 } 1284 1285 /* And then, Resource Descriptors */ 1286 desc = (ACPI_CSRT_DESCRIPTOR *) 1287 ((vaddr_t)(grp + 1) + grp->SharedInfoLength); 1288 while (desc < (ACPI_CSRT_DESCRIPTOR *)((vaddr_t)grp + grp->Length)) { 1289 bool unknownsubytpe = false; 1290 printf("\n\tLength=%u\n", desc->Length); 1291 printf("\tResource Type="); 1292 switch (desc->Type) { 1293 case ACPI_CSRT_TYPE_INTERRUPT: 1294 printf("Interrupt"); 1295 switch (desc->Subtype) { 1296 case ACPI_CSRT_XRUPT_LINE: 1297 printf("(Interrupt line)\n"); 1298 break; 1299 case ACPI_CSRT_XRUPT_CONTROLLER: 1300 printf("(Interrupt controller)\n"); 1301 break; 1302 default: 1303 unknownsubytpe = true; 1304 break; 1305 } 1306 break; 1307 case ACPI_CSRT_TYPE_TIMER: 1308 printf("Timer"); 1309 switch (desc->Subtype) { 1310 case ACPI_CSRT_TIMER: 1311 printf("\n"); 1312 break; 1313 default: 1314 unknownsubytpe = true; 1315 break; 1316 } 1317 break; 1318 case ACPI_CSRT_TYPE_DMA: 1319 printf("DMA"); 1320 switch (desc->Subtype) { 1321 case ACPI_CSRT_DMA_CHANNEL: 1322 printf("(DMA channel)\n"); 1323 break; 1324 case ACPI_CSRT_DMA_CONTROLLER: 1325 printf("(DMA controller)\n"); 1326 break; 1327 default: 1328 unknownsubytpe = true; 1329 break; 1330 } 1331 break; 1332 case 0x0004: /* XXX Platform Security */ 1333 printf("Platform Security"); 1334 switch (desc->Subtype) { 1335 case 0x0001: 1336 printf("\n"); 1337 /* Platform Security */ 1338 break; 1339 default: 1340 unknownsubytpe = true; 1341 break; 1342 } 1343 break; 1344 default: 1345 printf("Unknown (%hx)\n", desc->Type); 1346 break; 1347 } 1348 if (unknownsubytpe) 1349 printf("(unknown subtype(%hx))\n", desc->Subtype); 1350 1351 printf("\tUID=0x%08x\n", desc->Uid); 1352 printf("\tVendor defined info "); 1353 acpi_dump_bytes((uint8_t *)(desc + 1), 1354 desc->Length - sizeof(ACPI_CSRT_DESCRIPTOR), 1); 1355 1356 /* Next */ 1357 desc = (ACPI_CSRT_DESCRIPTOR *)((vaddr_t)desc + desc->Length); 1358 } 1359 } 1360 1361 static void 1362 acpi_handle_csrt(ACPI_TABLE_HEADER *sdp) 1363 { 1364 ACPI_CSRT_GROUP *grp; 1365 uint totallen = sdp->Length; 1366 1367 printf(BEGIN_COMMENT); 1368 acpi_print_sdt(sdp); 1369 grp = (ACPI_CSRT_GROUP *)(sdp + 1); 1370 1371 while (grp < (ACPI_CSRT_GROUP *)((vaddr_t)sdp + totallen)) { 1372 printf("\n"); 1373 acpi_print_csrt_resource_group(grp); 1374 1375 /* Next */ 1376 grp = (ACPI_CSRT_GROUP *)((vaddr_t)grp + grp->Length); 1377 } 1378 1379 printf(END_COMMENT); 1380 } 1381 1382 static void 1383 acpi_handle_dbgp(ACPI_TABLE_HEADER *sdp) 1384 { 1385 ACPI_TABLE_DBGP *dbgp; 1386 1387 printf(BEGIN_COMMENT); 1388 acpi_print_sdt(sdp); 1389 dbgp = (ACPI_TABLE_DBGP *)sdp; 1390 printf("\tType={"); 1391 switch (dbgp->Type) { 1392 case 0: 1393 printf("full 16550"); 1394 break; 1395 case 1: 1396 printf("subset of 16550"); 1397 break; 1398 } 1399 printf("}\n"); 1400 printf("\tDebugPort="); 1401 acpi_print_gas(&dbgp->DebugPort); 1402 printf("\n"); 1403 printf(END_COMMENT); 1404 } 1405 1406 /* This function is used by DBG2 and SPCR. */ 1407 static void 1408 acpi_print_dbg2_serial_subtype(uint16_t subtype) 1409 { 1410 1411 switch (subtype) { 1412 case ACPI_DBG2_16550_COMPATIBLE: 1413 printf("Fully 16550 compatible\n"); 1414 break; 1415 case ACPI_DBG2_16550_SUBSET: 1416 printf("16550 subset with DBGP Rev. 1\n"); 1417 break; 1418 case ACPI_DBG2_ARM_PL011: 1419 printf("ARM PL011\n"); 1420 break; 1421 case ACPI_DBG2_ARM_SBSA_32BIT: 1422 printf("ARM SBSA 32bit only\n"); 1423 break; 1424 case ACPI_DBG2_ARM_SBSA_GENERIC: 1425 printf("ARM SBSA Generic\n"); 1426 break; 1427 case ACPI_DBG2_ARM_DCC: 1428 printf("ARM DCC\n"); 1429 break; 1430 case ACPI_DBG2_BCM2835: 1431 printf("BCM2835\n"); 1432 break; 1433 default: 1434 printf("reserved (%04hx)\n", subtype); 1435 break; 1436 } 1437 } 1438 1439 static void 1440 acpi_print_dbg2_device(ACPI_DBG2_DEVICE *dev) 1441 { 1442 1443 printf("\t\tRevision=%u\n", dev->Revision); 1444 printf("\t\tLength=%u\n", dev->Length); 1445 printf("\t\tRegisterCount=%u\n", dev->RegisterCount); 1446 1447 printf("\t\tNamepath="); 1448 acpi_print_string((char *)((vaddr_t)dev + dev->NamepathOffset), 1449 dev->NamepathLength); 1450 printf("\n"); 1451 1452 if (dev->OemDataLength) { 1453 printf("\t\tOemDataLength=%u\n", dev->OemDataLength); 1454 printf("\t\tOemDataOffset=%u\n", dev->OemDataOffset); 1455 /* XXX need dump */ 1456 } 1457 1458 printf("\t\tPortType="); 1459 switch (dev->PortType) { 1460 case ACPI_DBG2_SERIAL_PORT: 1461 printf("Serial\n" "\t\tPortSubtype="); 1462 acpi_print_dbg2_serial_subtype(dev->PortSubtype); 1463 break; 1464 case ACPI_DBG2_1394_PORT: 1465 printf("IEEE1394\n" "\t\tPortSubtype="); 1466 if (dev->PortSubtype == ACPI_DBG2_1394_STANDARD) 1467 printf("Standard\n"); 1468 else 1469 printf("reserved (%04hx)\n", dev->PortSubtype); 1470 break; 1471 case ACPI_DBG2_USB_PORT: 1472 printf("USB\n" "\t\tPortSubtype="); 1473 switch (dev->PortSubtype) { 1474 case ACPI_DBG2_USB_XHCI: 1475 printf("XHCIn"); 1476 break; 1477 case ACPI_DBG2_USB_EHCI: 1478 printf("EHCI\n"); 1479 break; 1480 default: 1481 printf("reserved (%04hx)\n", dev->PortSubtype); 1482 break; 1483 } 1484 break; 1485 case ACPI_DBG2_NET_PORT: 1486 printf("Net\n" "\t\tPciVendorID=%04x\n", dev->PortSubtype); 1487 break; 1488 default: 1489 printf("reserved (%04hx)\n", dev->PortType); 1490 printf("\t\tPortSubtype=reserved (%04hx)\n", dev->PortSubtype); 1491 break; 1492 } 1493 1494 printf("\t\tBaseAddressOffset=0x%04x\n", dev->BaseAddressOffset); 1495 printf("\t\tAddressSizeOffset=0x%04x\n", dev->AddressSizeOffset); 1496 } 1497 1498 static void 1499 acpi_handle_dbg2(ACPI_TABLE_HEADER *sdp) 1500 { 1501 ACPI_TABLE_DBG2 *dbg2; 1502 ACPI_DBG2_DEVICE *device; 1503 unsigned int i; 1504 1505 printf(BEGIN_COMMENT); 1506 acpi_print_sdt(sdp); 1507 dbg2 = (ACPI_TABLE_DBG2 *)sdp; 1508 1509 printf("\tCount=%u\n", dbg2->InfoCount); 1510 device = (ACPI_DBG2_DEVICE *)((vaddr_t)sdp + dbg2->InfoOffset); 1511 for (i = 0; i < dbg2->InfoCount; i++) { 1512 printf("\tDevice %u={\n", i); 1513 acpi_print_dbg2_device(device); 1514 printf("\t}\n"); 1515 device++; 1516 } 1517 1518 printf(END_COMMENT); 1519 } 1520 1521 static void 1522 acpi_print_einj_action(ACPI_WHEA_HEADER *whea) 1523 { 1524 printf("\tACTION={"); 1525 switch (whea->Action) { 1526 case ACPI_EINJ_BEGIN_OPERATION: 1527 printf("Begin Operation"); 1528 break; 1529 case ACPI_EINJ_GET_TRIGGER_TABLE: 1530 printf("Get Trigger Table"); 1531 break; 1532 case ACPI_EINJ_SET_ERROR_TYPE: 1533 printf("Set Error Type"); 1534 break; 1535 case ACPI_EINJ_GET_ERROR_TYPE: 1536 printf("Get Error Type"); 1537 break; 1538 case ACPI_EINJ_END_OPERATION: 1539 printf("End Operation"); 1540 break; 1541 case ACPI_EINJ_EXECUTE_OPERATION: 1542 printf("Execute Operation"); 1543 break; 1544 case ACPI_EINJ_CHECK_BUSY_STATUS: 1545 printf("Check Busy Status"); 1546 break; 1547 case ACPI_EINJ_GET_COMMAND_STATUS: 1548 printf("Get Command Status"); 1549 break; 1550 case ACPI_EINJ_SET_ERROR_TYPE_WITH_ADDRESS: 1551 printf("Set Error Type With Address"); 1552 break; 1553 case ACPI_EINJ_GET_EXECUTE_TIMINGS: 1554 printf("Get Execute Operation Timings"); 1555 break; 1556 case ACPI_EINJ_ACTION_RESERVED: 1557 printf("Preserved"); 1558 break; 1559 case ACPI_EINJ_TRIGGER_ERROR: 1560 printf("Trigger Error"); 1561 break; 1562 default: 1563 printf("%d", whea->Action); 1564 break; 1565 } 1566 printf("}\n"); 1567 } 1568 1569 static void 1570 acpi_print_einj_instruction(ACPI_WHEA_HEADER *whea) 1571 { 1572 uint32_t ins = whea->Instruction; 1573 1574 printf("\tINSTRUCTION={"); 1575 switch (ins) { 1576 case ACPI_EINJ_READ_REGISTER: 1577 printf("Read Register"); 1578 break; 1579 case ACPI_EINJ_READ_REGISTER_VALUE: 1580 printf("Read Register Value"); 1581 break; 1582 case ACPI_EINJ_WRITE_REGISTER: 1583 printf("Write Register"); 1584 break; 1585 case ACPI_EINJ_WRITE_REGISTER_VALUE: 1586 printf("Write Register Value"); 1587 break; 1588 case ACPI_EINJ_NOOP: 1589 printf("Noop"); 1590 break; 1591 case ACPI_EINJ_INSTRUCTION_RESERVED: 1592 printf("Reserved"); 1593 break; 1594 default: 1595 printf("%d", ins); 1596 break; 1597 } 1598 printf("}\n"); 1599 } 1600 1601 static void 1602 acpi_print_einj_flags(ACPI_WHEA_HEADER *whea) 1603 { 1604 uint32_t flags = whea->Flags; 1605 1606 printf("\tFLAGS={"); 1607 if (flags & ACPI_EINJ_PRESERVE) 1608 printf("PRESERVED"); 1609 printf("}\n"); 1610 } 1611 1612 static void 1613 acpi_handle_einj(ACPI_TABLE_HEADER *sdp) 1614 { 1615 ACPI_TABLE_EINJ *einj; 1616 ACPI_EINJ_ENTRY *einj_entry; 1617 uint32_t einj_pos; 1618 u_int i; 1619 1620 printf(BEGIN_COMMENT); 1621 acpi_print_sdt(sdp); 1622 einj = (ACPI_TABLE_EINJ *)sdp; 1623 1624 printf("\tHeader Length=%d\n", einj->HeaderLength); 1625 printf("\tFlags=0x%x\n", einj->Flags); 1626 printf("\tEntries=%d\n", einj->Entries); 1627 1628 einj_pos = sizeof(ACPI_TABLE_EINJ); 1629 for (i = 0; i < einj->Entries; i++) { 1630 einj_entry = (ACPI_EINJ_ENTRY *)((char *)einj + einj_pos); 1631 acpi_print_whea(&einj_entry->WheaHeader, 1632 acpi_print_einj_action, acpi_print_einj_instruction, 1633 acpi_print_einj_flags); 1634 einj_pos += sizeof(ACPI_EINJ_ENTRY); 1635 } 1636 printf(END_COMMENT); 1637 } 1638 1639 static void 1640 acpi_print_erst_action(ACPI_WHEA_HEADER *whea) 1641 { 1642 printf("\tACTION={"); 1643 switch (whea->Action) { 1644 case ACPI_ERST_BEGIN_WRITE: 1645 printf("Begin Write"); 1646 break; 1647 case ACPI_ERST_BEGIN_READ: 1648 printf("Begin Read"); 1649 break; 1650 case ACPI_ERST_BEGIN_CLEAR: 1651 printf("Begin Clear"); 1652 break; 1653 case ACPI_ERST_END: 1654 printf("End"); 1655 break; 1656 case ACPI_ERST_SET_RECORD_OFFSET: 1657 printf("Set Record Offset"); 1658 break; 1659 case ACPI_ERST_EXECUTE_OPERATION: 1660 printf("Execute Operation"); 1661 break; 1662 case ACPI_ERST_CHECK_BUSY_STATUS: 1663 printf("Check Busy Status"); 1664 break; 1665 case ACPI_ERST_GET_COMMAND_STATUS: 1666 printf("Get Command Status"); 1667 break; 1668 case ACPI_ERST_GET_RECORD_ID: 1669 printf("Get Record ID"); 1670 break; 1671 case ACPI_ERST_SET_RECORD_ID: 1672 printf("Set Record ID"); 1673 break; 1674 case ACPI_ERST_GET_RECORD_COUNT: 1675 printf("Get Record Count"); 1676 break; 1677 case ACPI_ERST_BEGIN_DUMMY_WRIITE: 1678 printf("Begin Dummy Write"); 1679 break; 1680 case ACPI_ERST_NOT_USED: 1681 printf("Unused"); 1682 break; 1683 case ACPI_ERST_GET_ERROR_RANGE: 1684 printf("Get Error Range"); 1685 break; 1686 case ACPI_ERST_GET_ERROR_LENGTH: 1687 printf("Get Error Length"); 1688 break; 1689 case ACPI_ERST_GET_ERROR_ATTRIBUTES: 1690 printf("Get Error Attributes"); 1691 break; 1692 case ACPI_ERST_EXECUTE_TIMINGS: 1693 printf("Execute Operation Timings"); 1694 break; 1695 case ACPI_ERST_ACTION_RESERVED: 1696 printf("Reserved"); 1697 break; 1698 default: 1699 printf("%d", whea->Action); 1700 break; 1701 } 1702 printf("}\n"); 1703 } 1704 1705 static void 1706 acpi_print_erst_instruction(ACPI_WHEA_HEADER *whea) 1707 { 1708 printf("\tINSTRUCTION={"); 1709 switch (whea->Instruction) { 1710 case ACPI_ERST_READ_REGISTER: 1711 printf("Read Register"); 1712 break; 1713 case ACPI_ERST_READ_REGISTER_VALUE: 1714 printf("Read Register Value"); 1715 break; 1716 case ACPI_ERST_WRITE_REGISTER: 1717 printf("Write Register"); 1718 break; 1719 case ACPI_ERST_WRITE_REGISTER_VALUE: 1720 printf("Write Register Value"); 1721 break; 1722 case ACPI_ERST_NOOP: 1723 printf("Noop"); 1724 break; 1725 case ACPI_ERST_LOAD_VAR1: 1726 printf("Load Var1"); 1727 break; 1728 case ACPI_ERST_LOAD_VAR2: 1729 printf("Load Var2"); 1730 break; 1731 case ACPI_ERST_STORE_VAR1: 1732 printf("Store Var1"); 1733 break; 1734 case ACPI_ERST_ADD: 1735 printf("Add"); 1736 break; 1737 case ACPI_ERST_SUBTRACT: 1738 printf("Subtract"); 1739 break; 1740 case ACPI_ERST_ADD_VALUE: 1741 printf("Add Value"); 1742 break; 1743 case ACPI_ERST_SUBTRACT_VALUE: 1744 printf("Subtract Value"); 1745 break; 1746 case ACPI_ERST_STALL: 1747 printf("Stall"); 1748 break; 1749 case ACPI_ERST_STALL_WHILE_TRUE: 1750 printf("Stall While True"); 1751 break; 1752 case ACPI_ERST_SKIP_NEXT_IF_TRUE: 1753 printf("Skip Next If True"); 1754 break; 1755 case ACPI_ERST_GOTO: 1756 printf("Goto"); 1757 break; 1758 case ACPI_ERST_SET_SRC_ADDRESS_BASE: 1759 printf("Set Src Address Base"); 1760 break; 1761 case ACPI_ERST_SET_DST_ADDRESS_BASE: 1762 printf("Set Dst Address Base"); 1763 break; 1764 case ACPI_ERST_MOVE_DATA: 1765 printf("Move Data"); 1766 break; 1767 case ACPI_ERST_INSTRUCTION_RESERVED: 1768 printf("Reserved"); 1769 break; 1770 default: 1771 printf("%d (reserved)", whea->Instruction); 1772 break; 1773 } 1774 printf("}\n"); 1775 } 1776 1777 static void 1778 acpi_print_erst_flags(ACPI_WHEA_HEADER *whea) 1779 { 1780 uint32_t flags = whea->Flags; 1781 1782 printf("\tFLAGS={"); 1783 if (flags & ACPI_ERST_PRESERVE) 1784 printf("PRESERVED"); 1785 printf("}\n"); 1786 } 1787 1788 static void 1789 acpi_handle_erst(ACPI_TABLE_HEADER *sdp) 1790 { 1791 ACPI_TABLE_ERST *erst; 1792 ACPI_ERST_ENTRY *erst_entry; 1793 uint32_t erst_pos; 1794 u_int i; 1795 1796 printf(BEGIN_COMMENT); 1797 acpi_print_sdt(sdp); 1798 erst = (ACPI_TABLE_ERST *)sdp; 1799 1800 printf("\tHeader Length=%d\n", erst->HeaderLength); 1801 printf("\tEntries=%d\n", erst->Entries); 1802 1803 erst_pos = sizeof(ACPI_TABLE_ERST); 1804 for (i = 0; i < erst->Entries; i++) { 1805 erst_entry = (ACPI_ERST_ENTRY *)((char *)erst + erst_pos); 1806 acpi_print_whea(&erst_entry->WheaHeader, 1807 acpi_print_erst_action, acpi_print_erst_instruction, 1808 acpi_print_erst_flags); 1809 erst_pos += sizeof(ACPI_ERST_ENTRY); 1810 } 1811 printf(END_COMMENT); 1812 } 1813 1814 static void 1815 acpi_print_gtd_timer(const char *name, uint32_t interrupt, uint32_t flags) 1816 { 1817 1818 printf("\t%s Timer GSIV=%d\n", name, interrupt); 1819 printf("\t%s Flags={Mode=", name); 1820 if (flags & ACPI_GTDT_INTERRUPT_MODE) 1821 printf("edge"); 1822 else 1823 printf("level"); 1824 printf(", Polarity="); 1825 if (flags & ACPI_GTDT_INTERRUPT_POLARITY) 1826 printf("active-lo"); 1827 else 1828 printf("active-hi"); 1829 if (flags & ACPI_GTDT_ALWAYS_ON) 1830 printf(", always-on"); 1831 printf("}\n"); 1832 } 1833 1834 static void 1835 acpi_print_gtd_block_timer_flags(const char *name, uint32_t interrupt, 1836 uint32_t flags) 1837 { 1838 1839 printf("\t\t%s Timer GSIV=%d\n", name, interrupt); 1840 printf("\t\t%s Timer Flags={Mode=", name); 1841 if (flags & ACPI_GTDT_GT_IRQ_MODE) 1842 printf("Secure"); 1843 else 1844 printf("Non-Secure"); 1845 printf(", Polarity="); 1846 if (flags & ACPI_GTDT_GT_IRQ_POLARITY) 1847 printf("active-lo"); 1848 else 1849 printf("active-hi"); 1850 printf("}\n"); 1851 } 1852 1853 static void 1854 acpi_print_gtblock(ACPI_GTDT_TIMER_BLOCK *gtblock) 1855 { 1856 ACPI_GTDT_TIMER_ENTRY *entry; 1857 unsigned int i; 1858 1859 printf("\tType=GT Block\n"); 1860 printf("\tLength=%d\n", gtblock->Header.Length); 1861 /* XXX might not 8byte aligned */ 1862 printf("\tBlockAddress=%016jx\n", 1863 (uintmax_t)gtblock->BlockAddress); 1864 1865 printf("\tGT Block Timer Count=%d\n", gtblock->TimerCount); 1866 entry = (ACPI_GTDT_TIMER_ENTRY *)((vaddr_t)gtblock 1867 + gtblock->TimerOffset); 1868 for (i = 0; i < gtblock->TimerCount; i++) { 1869 printf("\n"); 1870 if (entry >= (ACPI_GTDT_TIMER_ENTRY *)((vaddr_t)gtblock 1871 + gtblock->Header.Length)) { 1872 printf("\\ttWrong Timer entry\n"); 1873 break; 1874 } 1875 printf("\t\tFrame Number=%d\n", entry->FrameNumber); 1876 /* XXX might not 8byte aligned */ 1877 printf("\t\tBaseAddress=%016jx\n", 1878 (uintmax_t)entry->BaseAddress); 1879 /* XXX might not 8byte aligned */ 1880 printf("\t\tEl0BaseAddress=%016jx\n", 1881 (uintmax_t)entry->El0BaseAddress); 1882 1883 acpi_print_gtd_block_timer_flags("Physical", 1884 entry->TimerInterrupt, entry->TimerFlags); 1885 acpi_print_gtd_block_timer_flags("Virtual", 1886 entry->VirtualTimerInterrupt, entry->VirtualTimerFlags); 1887 1888 printf("\t\tCommon Flags={Mode="); 1889 if (entry->CommonFlags & ACPI_GTDT_GT_IS_SECURE_TIMER) 1890 printf("Secure"); 1891 else 1892 printf("Non-Secure"); 1893 if (entry->CommonFlags & ACPI_GTDT_GT_ALWAYS_ON) 1894 printf(", always-on"); 1895 printf("}\n"); 1896 1897 entry++; 1898 } 1899 } 1900 1901 static void 1902 acpi_print_sbsa_watchdog(ACPI_GTDT_WATCHDOG *wdog) 1903 { 1904 1905 printf("\tType=Watchdog GT\n"); 1906 printf("\tLength=%d\n", wdog->Header.Length); 1907 /* XXX might not 8byte aligned */ 1908 printf("\tRefreshFrameAddress=%016jx\n", 1909 (uintmax_t)wdog->RefreshFrameAddress); 1910 /* XXX might not 8byte aligned */ 1911 printf("\tControlFrameAddress=%016jx\n", 1912 (uintmax_t)wdog->ControlFrameAddress); 1913 printf("\tGSIV=%d\n", wdog->TimerInterrupt); 1914 1915 printf("\tFlags={Mode="); 1916 if (wdog->TimerFlags & ACPI_GTDT_WATCHDOG_IRQ_MODE) 1917 printf("edge"); 1918 else 1919 printf("level"); 1920 printf(", Polarity="); 1921 if (wdog->TimerFlags & ACPI_GTDT_WATCHDOG_IRQ_POLARITY) 1922 printf("active-lo"); 1923 else 1924 printf("active-hi"); 1925 if (wdog->TimerFlags & ACPI_GTDT_WATCHDOG_SECURE) 1926 printf(", Secure"); 1927 else 1928 printf(", Non-Secure"); 1929 printf("}\n"); 1930 } 1931 1932 static void 1933 acpi_handle_gtdt(ACPI_TABLE_HEADER *sdp) 1934 { 1935 ACPI_TABLE_GTDT *gtdt; 1936 ACPI_GTDT_HEADER *hdr; 1937 u_int i; 1938 1939 printf(BEGIN_COMMENT); 1940 acpi_print_sdt(sdp); 1941 gtdt = (ACPI_TABLE_GTDT *)sdp; 1942 1943 printf("\tCounterBlockAddresss=%016jx\n", 1944 (uintmax_t)gtdt->CounterBlockAddresss); /* XXX not 8byte aligned */ 1945 printf("\tCounterReadBlockAddress=%016jx\n", 1946 (uintmax_t)gtdt->CounterReadBlockAddress); 1947 1948 #define PRINTTIMER(gtdt, name) acpi_print_gtd_timer( \ 1949 #name, (gtdt)-> name## Interrupt, \ 1950 (gtdt)-> name ## Flags) 1951 1952 PRINTTIMER(gtdt, SecureEl1); 1953 PRINTTIMER(gtdt, NonSecureEl1); 1954 PRINTTIMER(gtdt, VirtualTimer); 1955 PRINTTIMER(gtdt, NonSecureEl2); 1956 1957 #undef PRINTTIMER 1958 1959 printf("\tPlatform Timer Count=%d\n", gtdt->PlatformTimerCount); 1960 1961 hdr = (ACPI_GTDT_HEADER *)((vaddr_t)sdp + gtdt->PlatformTimerOffset); 1962 for (i = 0; i < gtdt->PlatformTimerCount; i++) { 1963 printf("\n"); 1964 if (hdr >= (ACPI_GTDT_HEADER *)((vaddr_t)sdp + sdp->Length)) { 1965 printf("\tWrong GTDT header" 1966 "(type = %hhu, length = %hu)\n", 1967 hdr->Type, hdr->Length); 1968 break; 1969 } 1970 1971 switch (hdr->Type) { 1972 case ACPI_GTDT_TYPE_TIMER_BLOCK: 1973 acpi_print_gtblock((ACPI_GTDT_TIMER_BLOCK *)hdr); 1974 break; 1975 case ACPI_GTDT_TYPE_WATCHDOG: 1976 acpi_print_sbsa_watchdog((ACPI_GTDT_WATCHDOG *)hdr); 1977 break; 1978 default: 1979 printf("\tUnknown Platform Timer Type" 1980 "(type = %hhu, length = %hu)\n", 1981 hdr->Type, hdr->Length); 1982 break; 1983 } 1984 /* Next */ 1985 hdr = (ACPI_GTDT_HEADER *)((vaddr_t)hdr + hdr->Length); 1986 } 1987 printf(END_COMMENT); 1988 } 1989 1990 static void 1991 acpi_handle_madt(ACPI_TABLE_HEADER *sdp) 1992 { 1993 ACPI_TABLE_MADT *madt; 1994 1995 printf(BEGIN_COMMENT); 1996 acpi_print_sdt(sdp); 1997 madt = (ACPI_TABLE_MADT *)sdp; 1998 printf("\tLocal APIC ADDR=0x%08x\n", madt->Address); 1999 printf("\tFlags={"); 2000 if (madt->Flags & ACPI_MADT_PCAT_COMPAT) 2001 printf("PC-AT"); 2002 printf("}\n"); 2003 acpi_walk_subtables(sdp, (madt + 1), acpi_print_madt); 2004 printf(END_COMMENT); 2005 } 2006 2007 static void 2008 acpi_handle_hpet(ACPI_TABLE_HEADER *sdp) 2009 { 2010 ACPI_TABLE_HPET *hpet; 2011 2012 printf(BEGIN_COMMENT); 2013 acpi_print_sdt(sdp); 2014 hpet = (ACPI_TABLE_HPET *)sdp; 2015 printf("\tHPET Number=%d\n", hpet->Sequence); 2016 printf("\tADDR="); 2017 acpi_print_gas(&hpet->Address); 2018 printf("\tHW Rev=0x%x\n", hpet->Id & ACPI_HPET_ID_HARDWARE_REV_ID); 2019 printf("\tComparators=%d\n", (hpet->Id & ACPI_HPET_ID_COMPARATORS) >> 2020 8); 2021 printf("\tCounter Size=%d\n", hpet->Id & ACPI_HPET_ID_COUNT_SIZE_CAP ? 2022 1 : 0); 2023 printf("\tLegacy IRQ routing capable={"); 2024 if (hpet->Id & ACPI_HPET_ID_LEGACY_CAPABLE) 2025 printf("TRUE}\n"); 2026 else 2027 printf("FALSE}\n"); 2028 printf("\tPCI Vendor ID=0x%04x\n", hpet->Id >> 16); 2029 printf("\tMinimal Tick=%d\n", hpet->MinimumTick); 2030 printf("\tFlags=0x%02x\n", hpet->Flags); 2031 printf(END_COMMENT); 2032 } 2033 2034 static void 2035 acpi_print_native_lpit(ACPI_LPIT_NATIVE *nl) 2036 { 2037 printf("\tEntryTrigger="); 2038 acpi_print_gas(&nl->EntryTrigger); 2039 printf("\tResidency=%u\n", nl->Residency); 2040 printf("\tLatency=%u\n", nl->Latency); 2041 if (nl->Header.Flags & ACPI_LPIT_NO_COUNTER) 2042 printf("\tResidencyCounter=Not Present"); 2043 else { 2044 printf("\tResidencyCounter="); 2045 acpi_print_gas(&nl->ResidencyCounter); 2046 } 2047 if (nl->CounterFrequency) 2048 printf("\tCounterFrequency=%ju\n", nl->CounterFrequency); 2049 else 2050 printf("\tCounterFrequency=TSC\n"); 2051 } 2052 2053 static void 2054 acpi_print_lpit(ACPI_LPIT_HEADER *lpit) 2055 { 2056 if (lpit->Type == ACPI_LPIT_TYPE_NATIVE_CSTATE) 2057 printf("\tType=ACPI_LPIT_TYPE_NATIVE_CSTATE\n"); 2058 else 2059 warnx("unknown LPIT type %u", lpit->Type); 2060 2061 printf("\tLength=%u\n", lpit->Length); 2062 printf("\tUniqueId=0x%04x\n", lpit->UniqueId); 2063 #define PRINTFLAG(var, flag) printflag((var), ACPI_LPIT_## flag, #flag) 2064 printf("\tFlags="); 2065 PRINTFLAG(lpit->Flags, STATE_DISABLED); 2066 PRINTFLAG_END(); 2067 #undef PRINTFLAG 2068 2069 if (lpit->Type == ACPI_LPIT_TYPE_NATIVE_CSTATE) 2070 return acpi_print_native_lpit((ACPI_LPIT_NATIVE *)lpit); 2071 } 2072 2073 static void 2074 acpi_walk_lpit(ACPI_TABLE_HEADER *table, void *first, 2075 void (*action)(ACPI_LPIT_HEADER *)) 2076 { 2077 ACPI_LPIT_HEADER *subtable; 2078 char *end; 2079 2080 subtable = first; 2081 end = (char *)table + table->Length; 2082 while ((char *)subtable < end) { 2083 printf("\n"); 2084 if (subtable->Length < sizeof(ACPI_LPIT_HEADER)) { 2085 warnx("invalid subtable length %u", subtable->Length); 2086 return; 2087 } 2088 action(subtable); 2089 subtable = (ACPI_LPIT_HEADER *)((char *)subtable + 2090 subtable->Length); 2091 } 2092 } 2093 2094 static void 2095 acpi_handle_lpit(ACPI_TABLE_HEADER *sdp) 2096 { 2097 ACPI_TABLE_LPIT *lpit; 2098 2099 printf(BEGIN_COMMENT); 2100 acpi_print_sdt(sdp); 2101 lpit = (ACPI_TABLE_LPIT *)sdp; 2102 acpi_walk_lpit(sdp, (lpit + 1), acpi_print_lpit); 2103 2104 printf(END_COMMENT); 2105 } 2106 2107 static void 2108 acpi_handle_msct(ACPI_TABLE_HEADER *sdp) 2109 { 2110 ACPI_TABLE_MSCT *msct; 2111 ACPI_MSCT_PROXIMITY *msctentry; 2112 uint32_t pos; 2113 2114 printf(BEGIN_COMMENT); 2115 acpi_print_sdt(sdp); 2116 msct = (ACPI_TABLE_MSCT *)sdp; 2117 2118 printf("\tProximity Offset=0x%x\n", msct->ProximityOffset); 2119 printf("\tMax Proximity Domains=%d\n", msct->MaxProximityDomains); 2120 printf("\tMax Clock Domains=%d\n", msct->MaxClockDomains); 2121 printf("\tMax Physical Address=0x%"PRIx64"\n", msct->MaxAddress); 2122 2123 pos = msct->ProximityOffset; 2124 while (pos < msct->Header.Length) { 2125 msctentry = (ACPI_MSCT_PROXIMITY *)((char *)msct + pos); 2126 pos += msctentry->Length; 2127 2128 printf("\n"); 2129 printf("\tRevision=%d\n", msctentry->Revision); 2130 printf("\tLength=%d\n", msctentry->Length); 2131 printf("\tRange Start=%d\n", msctentry->RangeStart); 2132 printf("\tRange End=%d\n", msctentry->RangeEnd); 2133 printf("\tProcessor Capacity=%d\n", 2134 msctentry->ProcessorCapacity); 2135 printf("\tMemory Capacity=0x%"PRIx64" byte\n", 2136 msctentry->MemoryCapacity); 2137 } 2138 2139 printf(END_COMMENT); 2140 } 2141 2142 static void 2143 acpi_handle_ecdt(ACPI_TABLE_HEADER *sdp) 2144 { 2145 ACPI_TABLE_ECDT *ecdt; 2146 2147 printf(BEGIN_COMMENT); 2148 acpi_print_sdt(sdp); 2149 ecdt = (ACPI_TABLE_ECDT *)sdp; 2150 printf("\tEC_CONTROL="); 2151 acpi_print_gas(&ecdt->Control); 2152 printf("\n\tEC_DATA="); 2153 acpi_print_gas(&ecdt->Data); 2154 printf("\n\tUID=%#x, ", ecdt->Uid); 2155 printf("GPE_BIT=%#x\n", ecdt->Gpe); 2156 printf("\tEC_ID=%s\n", ecdt->Id); 2157 printf(END_COMMENT); 2158 } 2159 2160 static void 2161 acpi_handle_mcfg(ACPI_TABLE_HEADER *sdp) 2162 { 2163 ACPI_TABLE_MCFG *mcfg; 2164 ACPI_MCFG_ALLOCATION *alloc; 2165 u_int i, entries; 2166 2167 printf(BEGIN_COMMENT); 2168 acpi_print_sdt(sdp); 2169 mcfg = (ACPI_TABLE_MCFG *)sdp; 2170 entries = (sdp->Length - sizeof(ACPI_TABLE_MCFG)) / 2171 sizeof(ACPI_MCFG_ALLOCATION); 2172 alloc = (ACPI_MCFG_ALLOCATION *)(mcfg + 1); 2173 for (i = 0; i < entries; i++, alloc++) { 2174 printf("\n"); 2175 printf("\tBase Address=0x%016jx\n", (uintmax_t)alloc->Address); 2176 printf("\tSegment Group=0x%04x\n", alloc->PciSegment); 2177 printf("\tStart Bus=%d\n", alloc->StartBusNumber); 2178 printf("\tEnd Bus=%d\n", alloc->EndBusNumber); 2179 } 2180 printf(END_COMMENT); 2181 } 2182 2183 static void 2184 acpi_print_pptt_processor(ACPI_PPTT_PROCESSOR *processor) 2185 { 2186 uint32_t *private; 2187 unsigned int i; 2188 2189 printf("\tType=processor\n"); 2190 printf("\tLength=%d\n", processor->Header.Length); 2191 #define PRINTFLAG(var, flag) printflag((var), ACPI_PPTT_## flag, #flag) 2192 2193 printf("\tFlags="); 2194 PRINTFLAG(processor->Flags, PHYSICAL_PACKAGE); 2195 PRINTFLAG(processor->Flags, ACPI_PROCESSOR_ID_VALID); 2196 PRINTFLAG_END(); 2197 2198 #undef PRINTFLAG 2199 printf("\tParent=%08x\n", processor->Parent); 2200 printf("\tACPI Processor ID=0x%08x\n", processor->AcpiProcessorId); 2201 printf("\tprivate resources=%d\n", processor->NumberOfPrivResources); 2202 2203 private = (uint32_t *)(processor + 1); 2204 for (i = 0; i < processor->NumberOfPrivResources; i++) 2205 printf("\tprivate resources%d=%08x\n", i, private[i]); 2206 } 2207 2208 static void 2209 acpi_print_pptt_cache(ACPI_PPTT_CACHE *cache) 2210 { 2211 2212 printf("\tType=cache\n"); 2213 printf("\tLength=%d\n", cache->Header.Length); 2214 2215 #define PRINTFLAG(var, flag) printflag((var), ACPI_PPTT_## flag, #flag) 2216 printf("\tFlags="); 2217 PRINTFLAG(cache->Flags, SIZE_PROPERTY_VALID); 2218 PRINTFLAG(cache->Flags, NUMBER_OF_SETS_VALID); 2219 PRINTFLAG(cache->Flags, ASSOCIATIVITY_VALID); 2220 PRINTFLAG(cache->Flags, ALLOCATION_TYPE_VALID); 2221 PRINTFLAG(cache->Flags, CACHE_TYPE_VALID); 2222 PRINTFLAG(cache->Flags, WRITE_POLICY_VALID); 2223 PRINTFLAG(cache->Flags, LINE_SIZE_VALID); 2224 PRINTFLAG_END(); 2225 #undef PRINTFLAG 2226 2227 printf("\tNextLevel=0x%08x\n", cache->NextLevelOfCache); 2228 if (cache->Flags & ACPI_PPTT_SIZE_PROPERTY_VALID) 2229 printf("\tSize=%d\n", cache->Size); 2230 if (cache->Flags & ACPI_PPTT_NUMBER_OF_SETS_VALID) 2231 printf("\tSets=%d\n", cache->NumberOfSets); 2232 if (cache->Flags & ACPI_PPTT_ASSOCIATIVITY_VALID) 2233 printf("\tAssociativity=%d\n", cache->Associativity); 2234 if (cache->Flags & ACPI_PPTT_ALLOCATION_TYPE_VALID) { 2235 printf("\tAllocation type="); 2236 switch (cache->Attributes & ACPI_PPTT_MASK_ALLOCATION_TYPE) { 2237 case ACPI_PPTT_CACHE_READ_ALLOCATE: 2238 printf("Read allocate\n"); 2239 break; 2240 case ACPI_PPTT_CACHE_WRITE_ALLOCATE: 2241 printf("Write allocate\n"); 2242 break; 2243 case ACPI_PPTT_CACHE_RW_ALLOCATE: 2244 case ACPI_PPTT_CACHE_RW_ALLOCATE_ALT: 2245 printf("Read and Write allocate\n"); 2246 break; 2247 } 2248 } 2249 if (cache->Flags & ACPI_PPTT_CACHE_TYPE_VALID) { 2250 printf("\tCache type="); 2251 switch (cache->Attributes & ACPI_PPTT_MASK_CACHE_TYPE) { 2252 case ACPI_PPTT_CACHE_TYPE_DATA: 2253 printf("Data\n"); 2254 break; 2255 case ACPI_PPTT_CACHE_TYPE_INSTR: 2256 printf("Instruction\n"); 2257 break; 2258 case ACPI_PPTT_CACHE_TYPE_UNIFIED: 2259 case ACPI_PPTT_CACHE_TYPE_UNIFIED_ALT: 2260 printf("Unified\n"); 2261 break; 2262 } 2263 } 2264 if (cache->Flags & ACPI_PPTT_WRITE_POLICY_VALID) 2265 printf("\tWrite Policy=Write %s \n", 2266 (cache->Attributes & ACPI_PPTT_MASK_WRITE_POLICY) ? 2267 "through" : "back"); 2268 2269 if (cache->Flags & ACPI_PPTT_LINE_SIZE_VALID) 2270 printf("\tLine size=%d\n", cache->LineSize); 2271 } 2272 2273 static void 2274 acpi_print_pptt_id(ACPI_PPTT_ID *id) 2275 { 2276 2277 printf("\tType=id\n"); 2278 printf("\tLength=%d\n", id->Header.Length); 2279 2280 printf("\tVENDOR_ID="); 2281 acpi_print_string((char *)&id->VendorId, 4); 2282 printf("\n"); 2283 2284 printf("\tLEVEL_1_ID=%016" PRIx64 "\n", id->Level1Id); 2285 printf("\tLEVEL_2_ID=%016" PRIx64 "\n", id->Level2Id); 2286 printf("\tMajor=%hu", id->MajorRev); 2287 printf("\tMinor=%hu", id->MinorRev); 2288 printf("\tSpin=%hu", id->SpinRev); 2289 } 2290 2291 static void 2292 acpi_print_pptt(ACPI_SUBTABLE_HEADER *hdr) 2293 { 2294 switch (hdr->Type) { 2295 case ACPI_PPTT_TYPE_PROCESSOR: 2296 acpi_print_pptt_processor((ACPI_PPTT_PROCESSOR *)hdr); 2297 break; 2298 case ACPI_PPTT_TYPE_CACHE: 2299 acpi_print_pptt_cache((ACPI_PPTT_CACHE *)hdr); 2300 break; 2301 case ACPI_PPTT_TYPE_ID: 2302 acpi_print_pptt_id((ACPI_PPTT_ID *)hdr); 2303 break; 2304 default: 2305 printf("\tUnknown structure" 2306 "(type = %hhu, length = %hhu)\n", 2307 hdr->Type, hdr->Length); 2308 break; 2309 } 2310 } 2311 2312 static void 2313 acpi_handle_pptt(ACPI_TABLE_HEADER *sdp) 2314 { 2315 ACPI_TABLE_PPTT *pptt; 2316 2317 printf(BEGIN_COMMENT); 2318 acpi_print_sdt(sdp); 2319 2320 pptt = (ACPI_TABLE_PPTT *)sdp; 2321 acpi_walk_subtables(sdp, (pptt + 1), acpi_print_pptt); 2322 2323 printf(END_COMMENT); 2324 } 2325 2326 static void 2327 acpi_handle_sbst(ACPI_TABLE_HEADER *sdp) 2328 { 2329 ACPI_TABLE_SBST *sbst; 2330 2331 printf(BEGIN_COMMENT); 2332 acpi_print_sdt(sdp); 2333 sbst = (ACPI_TABLE_SBST *)sdp; 2334 2335 printf("\tWarning Level=%d mWh\n", sbst->WarningLevel); 2336 printf("\tLow Level=%d mWh\n", sbst->LowLevel); 2337 printf("\tCritical Level=%d mWh\n", sbst->CriticalLevel); 2338 2339 printf(END_COMMENT); 2340 } 2341 2342 static void 2343 acpi_handle_slit(ACPI_TABLE_HEADER *sdp) 2344 { 2345 ACPI_TABLE_SLIT *slit; 2346 u_int idx; 2347 uint64_t cnt; 2348 2349 printf(BEGIN_COMMENT); 2350 acpi_print_sdt(sdp); 2351 slit = (ACPI_TABLE_SLIT *)sdp; 2352 2353 cnt = slit->LocalityCount * slit->LocalityCount; 2354 printf("\tLocalityCount=%ju\n", (uintmax_t)slit->LocalityCount); 2355 printf("\tEntry=\n\t"); 2356 for (idx = 0; idx < cnt; idx++) { 2357 printf("%u ", slit->Entry[idx]); 2358 if ((idx % slit->LocalityCount) == (slit->LocalityCount - 1)) { 2359 printf("\n"); 2360 if (idx < cnt - 1) 2361 printf("\t"); 2362 } 2363 } 2364 2365 printf(END_COMMENT); 2366 } 2367 2368 static void 2369 acpi_handle_spcr(ACPI_TABLE_HEADER *sdp) 2370 { 2371 ACPI_TABLE_SPCR *spcr; 2372 2373 printf(BEGIN_COMMENT); 2374 acpi_print_sdt(sdp); 2375 spcr = (ACPI_TABLE_SPCR *)sdp; 2376 2377 printf("\n\tInterface Type="); 2378 switch (sdp->Revision) { 2379 case 1: 2380 printf("full 16550%s\n", 2381 (spcr->InterfaceType == 1) ? 2382 "(must also accept writing FCR register)" : ""); 2383 break; 2384 case 2: 2385 acpi_print_dbg2_serial_subtype(spcr->InterfaceType); 2386 break; 2387 default: 2388 printf("unknown Revision\n"); 2389 break; 2390 } 2391 2392 printf("\tSerial Port="); 2393 acpi_print_gas(&spcr->SerialPort); 2394 printf("\n\tInterrupt Type={"); 2395 if (spcr->InterruptType & 0x1) { 2396 printf("\n\t\tdual-8259 IRQ="); 2397 switch (spcr->PcInterrupt) { 2398 case 2 ... 7: 2399 case 9 ... 12: 2400 case 14 ... 15: 2401 printf("%d", spcr->PcInterrupt); 2402 break; 2403 default: 2404 printf("%d (invalid entry)", spcr->PcInterrupt); 2405 break; 2406 } 2407 } 2408 if (spcr->InterruptType & 0x2) { 2409 printf("\n\t\tIO APIC={ GSI=%d }", spcr->Interrupt); 2410 } 2411 if (spcr->InterruptType & 0x4) { 2412 printf("\n\t\tIO SAPIC={ GSI=%d }", spcr->Interrupt); 2413 } 2414 if (spcr->InterruptType & 0x8) { 2415 printf("\n\t\tARMH GIC={ GSI=%d }", spcr->Interrupt); 2416 } 2417 printf("\n\t}\n"); 2418 2419 printf("\tBaud Rate="); 2420 switch (spcr->BaudRate) { 2421 case 3: 2422 printf("9600"); 2423 break; 2424 case 4: 2425 printf("19200"); 2426 break; 2427 case 6: 2428 printf("57600"); 2429 break; 2430 case 7: 2431 printf("115200"); 2432 break; 2433 default: 2434 printf("unknown speed index %d", spcr->BaudRate); 2435 break; 2436 } 2437 printf("\n\tParity={"); 2438 switch (spcr->Parity) { 2439 case 0: 2440 printf("OFF"); 2441 break; 2442 default: 2443 printf("ON"); 2444 break; 2445 } 2446 printf("}\n"); 2447 2448 printf("\tStop Bits={"); 2449 switch (spcr->StopBits) { 2450 case 1: 2451 printf("ON"); 2452 break; 2453 default: 2454 printf("OFF"); 2455 break; 2456 } 2457 printf("}\n"); 2458 2459 printf("\tFlow Control={"); 2460 if (spcr->FlowControl & 0x1) 2461 printf("DCD, "); 2462 if (spcr->FlowControl & 0x2) 2463 printf("RTS/CTS hardware, "); 2464 if (spcr->FlowControl & 0x4) 2465 printf("XON/XOFF software"); 2466 printf("}\n"); 2467 2468 printf("\tTerminal="); 2469 switch (spcr->TerminalType) { 2470 case 0: 2471 printf("VT100"); 2472 break; 2473 case 1: 2474 printf("VT100+"); 2475 break; 2476 case 2: 2477 printf("VT-UTF8"); 2478 break; 2479 case 3: 2480 printf("ANSI"); 2481 break; 2482 default: 2483 printf("unknown type %d", spcr->TerminalType); 2484 break; 2485 } 2486 printf("\n"); 2487 2488 acpi_print_pci(spcr->PciVendorId, spcr->PciDeviceId, 2489 spcr->PciSegment, spcr->PciBus, spcr->PciDevice, spcr->PciFunction); 2490 2491 printf("\tPCI Flags={"); 2492 if (spcr->PciFlags & ACPI_SPCR_DO_NOT_DISABLE) 2493 printf("DONOT_DISABLE"); 2494 printf("}\n"); 2495 2496 printf(END_COMMENT); 2497 } 2498 2499 static void 2500 acpi_handle_spmi(ACPI_TABLE_HEADER *sdp) 2501 { 2502 ACPI_TABLE_SPMI *spmi; 2503 2504 printf(BEGIN_COMMENT); 2505 acpi_print_sdt(sdp); 2506 spmi = (ACPI_TABLE_SPMI *)sdp; 2507 2508 printf("\tInterface Type="); 2509 switch (spmi->InterfaceType) { 2510 case ACPI_SPMI_KEYBOARD: 2511 printf("Keyboard Controller Stype (KCS)"); 2512 break; 2513 case ACPI_SPMI_SMI: 2514 printf("Server Management Interface Chip (SMIC)"); 2515 break; 2516 case ACPI_SPMI_BLOCK_TRANSFER: 2517 printf("Block Transfer (BT)"); 2518 break; 2519 case ACPI_SPMI_SMBUS: 2520 printf("SMBus System Interface (SSIF)"); 2521 break; 2522 default: 2523 printf("Reserved(%d)", spmi->InterfaceType); 2524 break; 2525 } 2526 printf("\n\tSpecRevision=%d.%d", spmi->SpecRevision >> 8, 2527 spmi->SpecRevision & 0xff); 2528 2529 printf("\n\tInterrupt Type={"); 2530 if (spmi->InterruptType & 0x1) { 2531 printf("\n\t\tSCI triggered GPE=%d", spmi->GpeNumber); 2532 } 2533 if (spmi->InterruptType & 0x2) { 2534 printf("\n\t\tIO APIC/SAPIC={ GSI=%d }", spmi->Interrupt); 2535 } 2536 printf("\n\t}\n"); 2537 2538 printf("\tBase Address="); 2539 acpi_print_gas(&spmi->IpmiRegister); 2540 printf("\n"); 2541 2542 if ((spmi->PciDeviceFlag & 0x01) != 0) 2543 acpi_print_pci_sbdf(spmi->PciSegment, spmi->PciBus, 2544 spmi->PciDevice, spmi->PciFunction); 2545 2546 printf(END_COMMENT); 2547 } 2548 2549 static void 2550 acpi_print_srat_cpu(uint8_t type, uint32_t apic_id, uint32_t proximity_domain, 2551 uint32_t flags, uint32_t clockdomain, uint8_t sapic_eid) 2552 { 2553 2554 printf("\tFlags={"); 2555 if (flags & ACPI_SRAT_CPU_ENABLED) 2556 printf("ENABLED"); 2557 else 2558 printf("DISABLED"); 2559 printf("}\n"); 2560 printf("\t%s ID=%d\n", 2561 (type == ACPI_SRAT_TYPE_GIC_ITS_AFFINITY) ? "ITS" : "APIC", 2562 apic_id); 2563 if (type == ACPI_SRAT_TYPE_CPU_AFFINITY) 2564 printf("\tSAPIC EID=%d\n", sapic_eid); 2565 printf("\tProximity Domain=%d\n", proximity_domain); 2566 if (type != ACPI_SRAT_TYPE_GIC_ITS_AFFINITY) 2567 printf("\tClock Domain=%d\n", clockdomain); 2568 } 2569 2570 static void 2571 acpi_print_srat_memory(ACPI_SRAT_MEM_AFFINITY *mp) 2572 { 2573 2574 printf("\tFlags={"); 2575 if (mp->Flags & ACPI_SRAT_MEM_ENABLED) 2576 printf("ENABLED"); 2577 else 2578 printf("DISABLED"); 2579 if (mp->Flags & ACPI_SRAT_MEM_HOT_PLUGGABLE) 2580 printf(",HOT_PLUGGABLE"); 2581 if (mp->Flags & ACPI_SRAT_MEM_NON_VOLATILE) 2582 printf(",NON_VOLATILE"); 2583 printf("}\n"); 2584 printf("\tBase Address=0x%016jx\n", (uintmax_t)mp->BaseAddress); 2585 printf("\tLength=0x%016jx\n", (uintmax_t)mp->Length); 2586 printf("\tProximity Domain=%d\n", mp->ProximityDomain); 2587 } 2588 2589 static const char *srat_types[] = { 2590 [ACPI_SRAT_TYPE_CPU_AFFINITY] = "CPU", 2591 [ACPI_SRAT_TYPE_MEMORY_AFFINITY] = "Memory", 2592 [ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY] = "X2APIC", 2593 [ACPI_SRAT_TYPE_GICC_AFFINITY] = "GICC", 2594 [ACPI_SRAT_TYPE_GIC_ITS_AFFINITY] = "GIC ITS", 2595 }; 2596 2597 static void 2598 acpi_print_srat(ACPI_SUBTABLE_HEADER *srat) 2599 { 2600 ACPI_SRAT_CPU_AFFINITY *cpu; 2601 ACPI_SRAT_X2APIC_CPU_AFFINITY *x2apic; 2602 ACPI_SRAT_GICC_AFFINITY *gicc; 2603 ACPI_SRAT_GIC_ITS_AFFINITY *gici; 2604 2605 if (srat->Type < __arraycount(srat_types)) 2606 printf("\tType=%s\n", srat_types[srat->Type]); 2607 else 2608 printf("\tType=%d (unknown)\n", srat->Type); 2609 switch (srat->Type) { 2610 case ACPI_SRAT_TYPE_CPU_AFFINITY: 2611 cpu = (ACPI_SRAT_CPU_AFFINITY *)srat; 2612 acpi_print_srat_cpu(srat->Type, cpu->ApicId, 2613 cpu->ProximityDomainHi[2] << 24 | 2614 cpu->ProximityDomainHi[1] << 16 | 2615 cpu->ProximityDomainHi[0] << 0 | 2616 cpu->ProximityDomainLo, 2617 cpu->Flags, cpu->ClockDomain, cpu->LocalSapicEid); 2618 break; 2619 case ACPI_SRAT_TYPE_MEMORY_AFFINITY: 2620 acpi_print_srat_memory((ACPI_SRAT_MEM_AFFINITY *)srat); 2621 break; 2622 case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY: 2623 x2apic = (ACPI_SRAT_X2APIC_CPU_AFFINITY *)srat; 2624 acpi_print_srat_cpu(srat->Type, x2apic->ApicId, 2625 x2apic->ProximityDomain, 2626 x2apic->Flags, x2apic->ClockDomain, 0 /* dummy */); 2627 break; 2628 case ACPI_SRAT_TYPE_GICC_AFFINITY: 2629 gicc = (ACPI_SRAT_GICC_AFFINITY *)srat; 2630 acpi_print_srat_cpu(srat->Type, gicc->AcpiProcessorUid, 2631 gicc->ProximityDomain, 2632 gicc->Flags, gicc->ClockDomain, 0 /* dummy */); 2633 break; 2634 case ACPI_SRAT_TYPE_GIC_ITS_AFFINITY: 2635 gici = (ACPI_SRAT_GIC_ITS_AFFINITY *)srat; 2636 acpi_print_srat_cpu(srat->Type, gici->ItsId, 2637 gici->ProximityDomain, 2638 0 /* dummy */, 0 /* dummy */, 0 /* dummy */); 2639 break; 2640 } 2641 } 2642 2643 static void 2644 acpi_handle_srat(ACPI_TABLE_HEADER *sdp) 2645 { 2646 ACPI_TABLE_SRAT *srat; 2647 2648 printf(BEGIN_COMMENT); 2649 acpi_print_sdt(sdp); 2650 srat = (ACPI_TABLE_SRAT *)sdp; 2651 printf("\tTable Revision=%d\n", srat->TableRevision); 2652 acpi_walk_subtables(sdp, (srat + 1), acpi_print_srat); 2653 printf(END_COMMENT); 2654 } 2655 2656 static const char *nfit_types[] = { 2657 [ACPI_NFIT_TYPE_SYSTEM_ADDRESS] = "System Address", 2658 [ACPI_NFIT_TYPE_MEMORY_MAP] = "Memory Map", 2659 [ACPI_NFIT_TYPE_INTERLEAVE] = "Interleave", 2660 [ACPI_NFIT_TYPE_SMBIOS] = "SMBIOS", 2661 [ACPI_NFIT_TYPE_CONTROL_REGION] = "Control Region", 2662 [ACPI_NFIT_TYPE_DATA_REGION] = "Data Region", 2663 [ACPI_NFIT_TYPE_FLUSH_ADDRESS] = "Flush Address" 2664 }; 2665 2666 2667 static void 2668 acpi_print_nfit(ACPI_NFIT_HEADER *nfit) 2669 { 2670 char *uuidstr; 2671 uint32_t status; 2672 2673 ACPI_NFIT_SYSTEM_ADDRESS *sysaddr; 2674 ACPI_NFIT_MEMORY_MAP *mmap; 2675 ACPI_NFIT_INTERLEAVE *ileave; 2676 ACPI_NFIT_SMBIOS *smbios __unused; 2677 ACPI_NFIT_CONTROL_REGION *ctlreg; 2678 ACPI_NFIT_DATA_REGION *datareg; 2679 ACPI_NFIT_FLUSH_ADDRESS *fladdr; 2680 2681 if (nfit->Type < __arraycount(nfit_types)) 2682 printf("\tType=%s\n", nfit_types[nfit->Type]); 2683 else 2684 printf("\tType=%u (unknown)\n", nfit->Type); 2685 switch (nfit->Type) { 2686 case ACPI_NFIT_TYPE_SYSTEM_ADDRESS: 2687 sysaddr = (ACPI_NFIT_SYSTEM_ADDRESS *)nfit; 2688 printf("\tRangeIndex=%u\n", (u_int)sysaddr->RangeIndex); 2689 printf("\tProximityDomain=%u\n", 2690 (u_int)sysaddr->ProximityDomain); 2691 uuid_to_string((uuid_t *)(sysaddr->RangeGuid), 2692 &uuidstr, &status); 2693 if (status != uuid_s_ok) 2694 errx(1, "uuid_to_string: status=%u", status); 2695 printf("\tRangeGuid=%s\n", uuidstr); 2696 free(uuidstr); 2697 printf("\tAddress=0x%016jx\n", (uintmax_t)sysaddr->Address); 2698 printf("\tLength=0x%016jx\n", (uintmax_t)sysaddr->Length); 2699 printf("\tMemoryMapping=0x%016jx\n", 2700 (uintmax_t)sysaddr->MemoryMapping); 2701 2702 #define PRINTFLAG(var, flag) printflag((var), ACPI_NFIT_## flag, #flag) 2703 2704 printf("\tFlags="); 2705 PRINTFLAG(sysaddr->Flags, ADD_ONLINE_ONLY); 2706 PRINTFLAG(sysaddr->Flags, PROXIMITY_VALID); 2707 PRINTFLAG_END(); 2708 2709 #undef PRINTFLAG 2710 2711 break; 2712 case ACPI_NFIT_TYPE_MEMORY_MAP: 2713 mmap = (ACPI_NFIT_MEMORY_MAP *)nfit; 2714 printf("\tDeviceHandle=%u\n", (u_int)mmap->DeviceHandle); 2715 printf("\tPhysicalId=%u\n", (u_int)mmap->PhysicalId); 2716 printf("\tRegionId=%u\n", (u_int)mmap->RegionId); 2717 printf("\tRangeIndex=%u\n", (u_int)mmap->RangeIndex); 2718 printf("\tRegionIndex=%u\n", (u_int)mmap->RegionIndex); 2719 printf("\tRegionSize=0x%016jx\n", (uintmax_t)mmap->RegionSize); 2720 printf("\tRegionOffset=0x%016jx\n", 2721 (uintmax_t)mmap->RegionOffset); 2722 printf("\tAddress=0x%016jx\n", (uintmax_t)mmap->Address); 2723 printf("\tInterleaveIndex=%u\n", (u_int)mmap->InterleaveIndex); 2724 printf("\tInterleaveWays=%u\n", (u_int)mmap->InterleaveWays); 2725 2726 #define PRINTFLAG(var, flag) printflag((var), ACPI_NFIT_MEM_## flag, #flag) 2727 2728 printf("\tFlags="); 2729 PRINTFLAG(mmap->Flags, SAVE_FAILED); 2730 PRINTFLAG(mmap->Flags, RESTORE_FAILED); 2731 PRINTFLAG(mmap->Flags, FLUSH_FAILED); 2732 PRINTFLAG(mmap->Flags, NOT_ARMED); 2733 PRINTFLAG(mmap->Flags, HEALTH_OBSERVED); 2734 PRINTFLAG(mmap->Flags, HEALTH_ENABLED); 2735 PRINTFLAG(mmap->Flags, MAP_FAILED); 2736 PRINTFLAG_END(); 2737 2738 #undef PRINTFLAG 2739 2740 break; 2741 case ACPI_NFIT_TYPE_INTERLEAVE: 2742 ileave = (ACPI_NFIT_INTERLEAVE *)nfit; 2743 printf("\tInterleaveIndex=%u\n", 2744 (u_int)ileave->InterleaveIndex); 2745 printf("\tLineCount=%u\n", (u_int)ileave->LineCount); 2746 printf("\tLineSize=%u\n", (u_int)ileave->LineSize); 2747 /* XXX ileave->LineOffset[i] output is not supported */ 2748 break; 2749 case ACPI_NFIT_TYPE_SMBIOS: 2750 smbios = (ACPI_NFIT_SMBIOS *)nfit; 2751 /* XXX smbios->Data[x] output is not supported */ 2752 break; 2753 case ACPI_NFIT_TYPE_CONTROL_REGION: 2754 ctlreg = (ACPI_NFIT_CONTROL_REGION *)nfit; 2755 printf("\tRegionIndex=%u\n", (u_int)ctlreg->RegionIndex); 2756 printf("\tVendorId=0x%04x\n", (u_int)ctlreg->VendorId); 2757 printf("\tDeviceId=0x%04x\n", (u_int)ctlreg->DeviceId); 2758 printf("\tRevisionId=%u\n", (u_int)ctlreg->RevisionId); 2759 printf("\tSubsystemVendorId=0x%04x\n", 2760 (u_int)ctlreg->SubsystemVendorId); 2761 printf("\tSubsystemDeviceId=0x%04x\n", 2762 (u_int)ctlreg->SubsystemDeviceId); 2763 printf("\tSubsystemRevisionId=%u\n", 2764 (u_int)ctlreg->SubsystemRevisionId); 2765 printf("\tValidFields=%02x\n", (u_int)ctlreg->ValidFields); 2766 printf("\tManufacturingLocation=%u\n", 2767 (u_int)ctlreg->ManufacturingLocation); 2768 printf("\tManufacturingDate=%u\n", 2769 (u_int)ctlreg->ManufacturingDate); 2770 printf("\tSerialNumber=%u\n", 2771 (u_int)ctlreg->SerialNumber); 2772 printf("\tCode=0x%04x\n", (u_int)ctlreg->Code); 2773 printf("\tWindows=%u\n", (u_int)ctlreg->Windows); 2774 printf("\tWindowSize=0x%016jx\n", 2775 (uintmax_t)ctlreg->WindowSize); 2776 printf("\tCommandOffset=0x%016jx\n", 2777 (uintmax_t)ctlreg->CommandOffset); 2778 printf("\tCommandSize=0x%016jx\n", 2779 (uintmax_t)ctlreg->CommandSize); 2780 printf("\tStatusOffset=0x%016jx\n", 2781 (uintmax_t)ctlreg->StatusOffset); 2782 printf("\tStatusSize=0x%016jx\n", 2783 (uintmax_t)ctlreg->StatusSize); 2784 2785 #define PRINTFLAG(var, flag) printflag((var), ACPI_NFIT_## flag, #flag) 2786 2787 printf("\tFlags="); 2788 PRINTFLAG(ctlreg->Flags, CONTROL_BUFFERED); 2789 PRINTFLAG_END(); 2790 2791 #undef PRINTFLAG 2792 2793 break; 2794 case ACPI_NFIT_TYPE_DATA_REGION: 2795 datareg = (ACPI_NFIT_DATA_REGION *)nfit; 2796 printf("\tRegionIndex=%u\n", (u_int)datareg->RegionIndex); 2797 printf("\tWindows=%u\n", (u_int)datareg->Windows); 2798 printf("\tOffset=0x%016jx\n", (uintmax_t)datareg->Offset); 2799 printf("\tSize=0x%016jx\n", (uintmax_t)datareg->Size); 2800 printf("\tCapacity=0x%016jx\n", (uintmax_t)datareg->Capacity); 2801 printf("\tStartAddress=0x%016jx\n", 2802 (uintmax_t)datareg->StartAddress); 2803 break; 2804 case ACPI_NFIT_TYPE_FLUSH_ADDRESS: 2805 fladdr = (ACPI_NFIT_FLUSH_ADDRESS *)nfit; 2806 printf("\tDeviceHandle=%u\n", (u_int)fladdr->DeviceHandle); 2807 printf("\tHintCount=%u\n", (u_int)fladdr->HintCount); 2808 /* XXX fladdr->HintAddress[i] output is not supported */ 2809 break; 2810 } 2811 } 2812 2813 static void 2814 acpi_handle_nfit(ACPI_TABLE_HEADER *sdp) 2815 { 2816 ACPI_TABLE_NFIT *nfit; 2817 2818 printf(BEGIN_COMMENT); 2819 acpi_print_sdt(sdp); 2820 nfit = (ACPI_TABLE_NFIT *)sdp; 2821 acpi_walk_nfit(sdp, (nfit + 1), acpi_print_nfit); 2822 printf(END_COMMENT); 2823 } 2824 2825 static char * 2826 acpi_tcpa_evname(struct TCPAevent *event) 2827 { 2828 struct TCPApc_event *pc_event; 2829 char *eventname = NULL; 2830 2831 pc_event = (struct TCPApc_event *)(event + 1); 2832 2833 switch (event->event_type) { 2834 case PREBOOT: 2835 case POST_CODE: 2836 case UNUSED: 2837 case NO_ACTION: 2838 case SEPARATOR: 2839 case SCRTM_CONTENTS: 2840 case SCRTM_VERSION: 2841 case CPU_MICROCODE: 2842 case PLATFORM_CONFIG_FLAGS: 2843 case TABLE_OF_DEVICES: 2844 case COMPACT_HASH: 2845 case IPL: 2846 case IPL_PARTITION_DATA: 2847 case NONHOST_CODE: 2848 case NONHOST_CONFIG: 2849 case NONHOST_INFO: 2850 asprintf(&eventname, "%s", 2851 tcpa_event_type_strings[event->event_type]); 2852 break; 2853 2854 case ACTION: 2855 eventname = calloc(event->event_size + 1, sizeof(char)); 2856 memcpy(eventname, pc_event, event->event_size); 2857 break; 2858 2859 case EVENT_TAG: 2860 switch (pc_event->event_id) { 2861 case SMBIOS: 2862 case BIS_CERT: 2863 case CMOS: 2864 case NVRAM: 2865 case OPTION_ROM_EXEC: 2866 case OPTION_ROM_CONFIG: 2867 case S_CRTM_VERSION: 2868 case POST_BIOS_ROM: 2869 case ESCD: 2870 case OPTION_ROM_MICROCODE: 2871 case S_CRTM_CONTENTS: 2872 case POST_CONTENTS: 2873 asprintf(&eventname, "%s", 2874 TCPA_pcclient_strings[pc_event->event_id]); 2875 break; 2876 2877 default: 2878 asprintf(&eventname, "<unknown tag 0x%02x>", 2879 pc_event->event_id); 2880 break; 2881 } 2882 break; 2883 2884 default: 2885 asprintf(&eventname, "<unknown 0x%02x>", event->event_type); 2886 break; 2887 } 2888 2889 return eventname; 2890 } 2891 2892 static void 2893 acpi_print_tcpa(struct TCPAevent *event) 2894 { 2895 int i; 2896 char *eventname; 2897 2898 eventname = acpi_tcpa_evname(event); 2899 2900 printf("\t%d", event->pcr_index); 2901 printf(" 0x"); 2902 for (i = 0; i < 20; i++) 2903 printf("%02x", event->pcr_value[i]); 2904 printf(" [%s]\n", eventname ? eventname : "<unknown>"); 2905 2906 free(eventname); 2907 } 2908 2909 static void 2910 acpi_handle_tcpa(ACPI_TABLE_HEADER *sdp) 2911 { 2912 struct TCPAbody *tcpa; 2913 struct TCPAevent *event; 2914 uintmax_t len, paddr; 2915 unsigned char *vaddr = NULL; 2916 unsigned char *vend = NULL; 2917 2918 printf(BEGIN_COMMENT); 2919 acpi_print_sdt(sdp); 2920 tcpa = (struct TCPAbody *) sdp; 2921 2922 switch (tcpa->platform_class) { 2923 case ACPI_TCPA_BIOS_CLIENT: 2924 len = tcpa->client.log_max_len; 2925 paddr = tcpa->client.log_start_addr; 2926 break; 2927 2928 case ACPI_TCPA_BIOS_SERVER: 2929 len = tcpa->server.log_max_len; 2930 paddr = tcpa->server.log_start_addr; 2931 break; 2932 2933 default: 2934 printf("XXX"); 2935 printf(END_COMMENT); 2936 return; 2937 } 2938 printf("\tClass %u Base Address 0x%jx Length %ju\n\n", 2939 tcpa->platform_class, paddr, len); 2940 2941 if (len == 0) { 2942 printf("\tEmpty TCPA table\n"); 2943 printf(END_COMMENT); 2944 return; 2945 } 2946 if (sdp->Revision == 1) { 2947 printf("\tOLD TCPA spec log found. Dumping not supported.\n"); 2948 printf(END_COMMENT); 2949 return; 2950 } 2951 2952 vaddr = (unsigned char *)acpi_map_physical(paddr, len); 2953 vend = vaddr + len; 2954 2955 while (vaddr != NULL) { 2956 if ((vaddr + sizeof(struct TCPAevent) >= vend)|| 2957 (vaddr + sizeof(struct TCPAevent) < vaddr)) 2958 break; 2959 event = (struct TCPAevent *)(void *)vaddr; 2960 if (vaddr + event->event_size >= vend) 2961 break; 2962 if (vaddr + event->event_size < vaddr) 2963 break; 2964 if (event->event_type == 0 && event->event_size == 0) 2965 break; 2966 #if 0 2967 { 2968 unsigned int i, j, k; 2969 2970 printf("\n\tsize %d\n\t\t%p ", event->event_size, vaddr); 2971 for (j = 0, i = 0; i < 2972 sizeof(struct TCPAevent) + event->event_size; i++) { 2973 printf("%02x ", vaddr[i]); 2974 if ((i+1) % 8 == 0) { 2975 for (k = 0; k < 8; k++) 2976 printf("%c", isprint(vaddr[j+k]) ? 2977 vaddr[j+k] : '.'); 2978 printf("\n\t\t%p ", &vaddr[i + 1]); 2979 j = i + 1; 2980 } 2981 } 2982 printf("\n"); } 2983 #endif 2984 acpi_print_tcpa(event); 2985 2986 vaddr += sizeof(struct TCPAevent) + event->event_size; 2987 } 2988 2989 printf(END_COMMENT); 2990 } 2991 2992 static const char * 2993 devscope_type2str(int type) 2994 { 2995 static char typebuf[16]; 2996 2997 switch (type) { 2998 case 1: 2999 return ("PCI Endpoint Device"); 3000 case 2: 3001 return ("PCI Sub-Hierarchy"); 3002 case 3: 3003 return ("IOAPIC"); 3004 case 4: 3005 return ("HPET"); 3006 case 5: 3007 return ("ACPI Name space"); 3008 default: 3009 snprintf(typebuf, sizeof(typebuf), "%d", type); 3010 return (typebuf); 3011 } 3012 } 3013 3014 static int 3015 acpi_handle_dmar_devscope(void *addr, int remaining) 3016 { 3017 char sep; 3018 int pathlen; 3019 ACPI_DMAR_PCI_PATH *path, *pathend; 3020 ACPI_DMAR_DEVICE_SCOPE *devscope = addr; 3021 3022 if (remaining < (int)sizeof(ACPI_DMAR_DEVICE_SCOPE)) 3023 return (-1); 3024 3025 if (remaining < devscope->Length) 3026 return (-1); 3027 3028 printf("\n"); 3029 printf("\t\tType=%s\n", devscope_type2str(devscope->EntryType)); 3030 printf("\t\tLength=%d\n", devscope->Length); 3031 printf("\t\tEnumerationId=%d\n", devscope->EnumerationId); 3032 printf("\t\tStartBusNumber=%d\n", devscope->Bus); 3033 3034 path = (ACPI_DMAR_PCI_PATH *)(devscope + 1); 3035 pathlen = devscope->Length - sizeof(ACPI_DMAR_DEVICE_SCOPE); 3036 pathend = path + pathlen / sizeof(ACPI_DMAR_PCI_PATH); 3037 if (path < pathend) { 3038 sep = '{'; 3039 printf("\t\tPath="); 3040 do { 3041 printf("%c%d:%d", sep, path->Device, path->Function); 3042 sep=','; 3043 path++; 3044 } while (path < pathend); 3045 printf("}\n"); 3046 } 3047 3048 return (devscope->Length); 3049 } 3050 3051 static void 3052 acpi_handle_dmar_drhd(ACPI_DMAR_HARDWARE_UNIT *drhd) 3053 { 3054 char *cp; 3055 int remaining, consumed; 3056 3057 printf("\n"); 3058 printf("\tType=DRHD\n"); 3059 printf("\tLength=%d\n", drhd->Header.Length); 3060 3061 #define PRINTFLAG(var, flag) printflag((var), ACPI_DMAR_## flag, #flag) 3062 3063 printf("\tFlags="); 3064 PRINTFLAG(drhd->Flags, INCLUDE_ALL); 3065 PRINTFLAG_END(); 3066 3067 #undef PRINTFLAG 3068 3069 printf("\tSegment=%d\n", drhd->Segment); 3070 printf("\tAddress=0x%016jx\n", (uintmax_t)drhd->Address); 3071 3072 remaining = drhd->Header.Length - sizeof(ACPI_DMAR_HARDWARE_UNIT); 3073 if (remaining > 0) 3074 printf("\tDevice Scope:"); 3075 while (remaining > 0) { 3076 cp = (char *)drhd + drhd->Header.Length - remaining; 3077 consumed = acpi_handle_dmar_devscope(cp, remaining); 3078 if (consumed <= 0) 3079 break; 3080 else 3081 remaining -= consumed; 3082 } 3083 } 3084 3085 static void 3086 acpi_handle_dmar_rmrr(ACPI_DMAR_RESERVED_MEMORY *rmrr) 3087 { 3088 char *cp; 3089 int remaining, consumed; 3090 3091 printf("\n"); 3092 printf("\tType=RMRR\n"); 3093 printf("\tLength=%d\n", rmrr->Header.Length); 3094 printf("\tSegment=%d\n", rmrr->Segment); 3095 printf("\tBaseAddress=0x%016jx\n", (uintmax_t)rmrr->BaseAddress); 3096 printf("\tLimitAddress=0x%016jx\n", (uintmax_t)rmrr->EndAddress); 3097 3098 remaining = rmrr->Header.Length - sizeof(ACPI_DMAR_RESERVED_MEMORY); 3099 if (remaining > 0) 3100 printf("\tDevice Scope:"); 3101 while (remaining > 0) { 3102 cp = (char *)rmrr + rmrr->Header.Length - remaining; 3103 consumed = acpi_handle_dmar_devscope(cp, remaining); 3104 if (consumed <= 0) 3105 break; 3106 else 3107 remaining -= consumed; 3108 } 3109 } 3110 3111 static void 3112 acpi_handle_dmar_atsr(ACPI_DMAR_ATSR *atsr) 3113 { 3114 char *cp; 3115 int remaining, consumed; 3116 3117 printf("\n"); 3118 printf("\tType=ATSR\n"); 3119 printf("\tLength=%d\n", atsr->Header.Length); 3120 3121 #define PRINTFLAG(var, flag) printflag((var), ACPI_DMAR_## flag, #flag) 3122 3123 printf("\tFlags="); 3124 PRINTFLAG(atsr->Flags, ALL_PORTS); 3125 PRINTFLAG_END(); 3126 3127 #undef PRINTFLAG 3128 3129 printf("\tSegment=%d\n", atsr->Segment); 3130 3131 remaining = atsr->Header.Length - sizeof(ACPI_DMAR_ATSR); 3132 if (remaining > 0) 3133 printf("\tDevice Scope:"); 3134 while (remaining > 0) { 3135 cp = (char *)atsr + atsr->Header.Length - remaining; 3136 consumed = acpi_handle_dmar_devscope(cp, remaining); 3137 if (consumed <= 0) 3138 break; 3139 else 3140 remaining -= consumed; 3141 } 3142 } 3143 3144 static void 3145 acpi_handle_dmar_rhsa(ACPI_DMAR_RHSA *rhsa) 3146 { 3147 3148 printf("\n"); 3149 printf("\tType=RHSA\n"); 3150 printf("\tLength=%d\n", rhsa->Header.Length); 3151 printf("\tBaseAddress=0x%016jx\n", (uintmax_t)rhsa->BaseAddress); 3152 printf("\tProximityDomain=0x%08x\n", rhsa->ProximityDomain); 3153 } 3154 3155 static void 3156 acpi_handle_dmar_andd(ACPI_DMAR_ANDD *andd) 3157 { 3158 3159 printf("\n"); 3160 printf("\tType=ANDD\n"); 3161 printf("\tLength=%d\n", andd->Header.Length); 3162 printf("\tDeviceNumber=%d\n", andd->DeviceNumber); 3163 printf("\tDeviceName=0x%s\n", andd->DeviceName); 3164 } 3165 3166 static int 3167 acpi_handle_dmar_remapping_structure(void *addr, int remaining) 3168 { 3169 ACPI_DMAR_HEADER *hdr = addr; 3170 3171 if (remaining < (int)sizeof(ACPI_DMAR_HEADER)) 3172 return (-1); 3173 3174 if (remaining < hdr->Length) 3175 return (-1); 3176 3177 switch (hdr->Type) { 3178 case ACPI_DMAR_TYPE_HARDWARE_UNIT: 3179 acpi_handle_dmar_drhd(addr); 3180 break; 3181 case ACPI_DMAR_TYPE_RESERVED_MEMORY: 3182 acpi_handle_dmar_rmrr(addr); 3183 break; 3184 case ACPI_DMAR_TYPE_ROOT_ATS: 3185 acpi_handle_dmar_atsr(addr); 3186 break; 3187 case ACPI_DMAR_TYPE_HARDWARE_AFFINITY: 3188 acpi_handle_dmar_rhsa(addr); 3189 break; 3190 case ACPI_DMAR_TYPE_NAMESPACE: 3191 acpi_handle_dmar_andd(addr); 3192 break; 3193 default: 3194 printf("\n"); 3195 printf("\tType=%d\n", hdr->Type); 3196 printf("\tLength=%d\n", hdr->Length); 3197 break; 3198 } 3199 return (hdr->Length); 3200 } 3201 3202 #ifndef ACPI_DMAR_X2APIC_OPT_OUT 3203 #define ACPI_DMAR_X2APIC_OPT_OUT (0x2) 3204 #endif 3205 3206 static void 3207 acpi_handle_dmar(ACPI_TABLE_HEADER *sdp) 3208 { 3209 char *cp; 3210 int remaining, consumed; 3211 ACPI_TABLE_DMAR *dmar; 3212 3213 printf(BEGIN_COMMENT); 3214 acpi_print_sdt(sdp); 3215 dmar = (ACPI_TABLE_DMAR *)sdp; 3216 printf("\tHost Address Width=%d\n", dmar->Width + 1); 3217 3218 #define PRINTFLAG(var, flag) printflag((var), ACPI_DMAR_## flag, #flag) 3219 3220 printf("\tFlags="); 3221 PRINTFLAG(dmar->Flags, INTR_REMAP); 3222 PRINTFLAG(dmar->Flags, X2APIC_OPT_OUT); 3223 PRINTFLAG(dmar->Flags, X2APIC_MODE); 3224 PRINTFLAG_END(); 3225 3226 #undef PRINTFLAG 3227 3228 remaining = sdp->Length - sizeof(ACPI_TABLE_DMAR); 3229 while (remaining > 0) { 3230 cp = (char *)sdp + sdp->Length - remaining; 3231 consumed = acpi_handle_dmar_remapping_structure(cp, remaining); 3232 if (consumed <= 0) 3233 break; 3234 else 3235 remaining -= consumed; 3236 } 3237 3238 printf(END_COMMENT); 3239 } 3240 3241 static void 3242 acpi_handle_uefi(ACPI_TABLE_HEADER *sdp) 3243 { 3244 ACPI_TABLE_UEFI *uefi; 3245 char *uuidstr; 3246 uint32_t status; 3247 3248 printf(BEGIN_COMMENT); 3249 acpi_print_sdt(sdp); 3250 uefi = (ACPI_TABLE_UEFI *)sdp; 3251 3252 uuid_to_string((uuid_t *)(uefi->Identifier), 3253 &uuidstr, &status); 3254 if (status != uuid_s_ok) 3255 errx(1, "uuid_to_string: status=%u", status); 3256 printf("\tUUID=%s\n", uuidstr); 3257 free(uuidstr); 3258 3259 printf("\tDataOffset=%04hx\n", uefi->DataOffset); 3260 /* XXX need write */ 3261 3262 printf(END_COMMENT); 3263 } 3264 3265 static void 3266 acpi_handle_waet(ACPI_TABLE_HEADER *sdp) 3267 { 3268 ACPI_TABLE_WAET *waet; 3269 3270 printf(BEGIN_COMMENT); 3271 acpi_print_sdt(sdp); 3272 waet = (ACPI_TABLE_WAET *)sdp; 3273 3274 printf("\tRTC Timer={"); 3275 if (waet->Flags & ACPI_WAET_RTC_NO_ACK) 3276 printf("No ACK required"); 3277 else 3278 printf("default behaviour"); 3279 printf("}\n"); 3280 printf("\t ACPI PM Timer={"); 3281 if (waet->Flags & ACPI_WAET_TIMER_ONE_READ) 3282 printf("One Read sufficient"); 3283 else 3284 printf("default behaviour"); 3285 printf("}\n"); 3286 3287 printf(END_COMMENT); 3288 } 3289 3290 static void 3291 acpi_print_wdat_action(ACPI_WHEA_HEADER *whea) 3292 { 3293 printf("\tACTION={"); 3294 switch (whea->Action) { 3295 case ACPI_WDAT_RESET: 3296 printf("RESET"); 3297 break; 3298 case ACPI_WDAT_GET_CURRENT_COUNTDOWN: 3299 printf("GET_CURRENT_COUNTDOWN"); 3300 break; 3301 case ACPI_WDAT_GET_COUNTDOWN: 3302 printf("GET_COUNTDOWN"); 3303 break; 3304 case ACPI_WDAT_SET_COUNTDOWN: 3305 printf("SET_COUNTDOWN"); 3306 break; 3307 case ACPI_WDAT_GET_RUNNING_STATE: 3308 printf("GET_RUNNING_STATE"); 3309 break; 3310 case ACPI_WDAT_SET_RUNNING_STATE: 3311 printf("SET_RUNNING_STATE"); 3312 break; 3313 case ACPI_WDAT_GET_STOPPED_STATE: 3314 printf("GET_STOPPED_STATE"); 3315 break; 3316 case ACPI_WDAT_SET_STOPPED_STATE: 3317 printf("SET_STOPPED_STATE"); 3318 break; 3319 case ACPI_WDAT_GET_REBOOT: 3320 printf("GET_REBOOT"); 3321 break; 3322 case ACPI_WDAT_SET_REBOOT: 3323 printf("SET_REBOOT"); 3324 break; 3325 case ACPI_WDAT_GET_SHUTDOWN: 3326 printf("GET_SHUTDOWN"); 3327 break; 3328 case ACPI_WDAT_SET_SHUTDOWN: 3329 printf("SET_SHUTDOWN"); 3330 break; 3331 case ACPI_WDAT_GET_STATUS: 3332 printf("GET_STATUS"); 3333 break; 3334 case ACPI_WDAT_SET_STATUS: 3335 printf("SET_STATUS"); 3336 break; 3337 case ACPI_WDAT_ACTION_RESERVED: 3338 printf("ACTION_RESERVED"); 3339 break; 3340 default: 3341 printf("%d", whea->Action); 3342 break; 3343 } 3344 printf("}\n"); 3345 } 3346 3347 static void 3348 acpi_print_wdat_instruction(ACPI_WHEA_HEADER *whea) 3349 { 3350 uint32_t ins; 3351 3352 ins = whea->Instruction & ~ACPI_WDAT_PRESERVE_REGISTER; 3353 3354 printf("\tINSTRUCTION={"); 3355 switch (ins) { 3356 case ACPI_WDAT_READ_VALUE: 3357 printf("READ_VALUE"); 3358 break; 3359 case ACPI_WDAT_READ_COUNTDOWN: 3360 printf("READ_COUNTDOWN"); 3361 break; 3362 case ACPI_WDAT_WRITE_VALUE: 3363 printf("WRITE_VALUE"); 3364 break; 3365 case ACPI_WDAT_WRITE_COUNTDOWN: 3366 printf("WRITE_COUNTDOWN"); 3367 break; 3368 case ACPI_WDAT_INSTRUCTION_RESERVED: 3369 printf("INSTRUCTION_RESERVED"); 3370 break; 3371 default: 3372 printf("%d", ins); 3373 break; 3374 } 3375 3376 if (whea->Instruction & ACPI_WDAT_PRESERVE_REGISTER) 3377 printf(", Preserve Register"); 3378 3379 printf("}\n"); 3380 } 3381 3382 static void 3383 acpi_handle_wdat(ACPI_TABLE_HEADER *sdp) 3384 { 3385 ACPI_TABLE_WDAT *wdat; 3386 ACPI_WHEA_HEADER *whea; 3387 ACPI_WDAT_ENTRY *wdat_pos; 3388 u_int i; 3389 3390 printf(BEGIN_COMMENT); 3391 acpi_print_sdt(sdp); 3392 wdat = (ACPI_TABLE_WDAT *)sdp; 3393 3394 printf("\tHeader Length=%d\n", wdat->HeaderLength); 3395 3396 acpi_print_pci_sbdf(wdat->PciSegment, wdat->PciBus, wdat->PciDevice, 3397 wdat->PciFunction); 3398 printf("\n\tTimer Counter Period=%d msec\n", wdat->TimerPeriod); 3399 printf("\tTimer Maximum Counter Value=%d\n", wdat->MaxCount); 3400 printf("\tTimer Minimum Counter Value=%d\n", wdat->MinCount); 3401 3402 printf("\tFlags={"); 3403 if (wdat->Flags & ACPI_WDAT_ENABLED) 3404 printf("ENABLED"); 3405 if (wdat->Flags & ACPI_WDAT_STOPPED) 3406 printf(", STOPPED"); 3407 printf("}\n"); 3408 3409 wdat_pos = (ACPI_WDAT_ENTRY *)((char *)wdat + sizeof(ACPI_TABLE_WDAT)); 3410 3411 for (i = 0; i < wdat->Entries; i++) { 3412 whea = (ACPI_WHEA_HEADER *)wdat_pos; 3413 acpi_print_whea(whea, 3414 acpi_print_wdat_action, acpi_print_wdat_instruction, 3415 NULL); 3416 wdat_pos++; 3417 } 3418 printf(END_COMMENT); 3419 } 3420 3421 static void 3422 acpi_handle_wddt(ACPI_TABLE_HEADER *sdp) 3423 { 3424 ACPI_TABLE_WDDT *wddt; 3425 3426 printf(BEGIN_COMMENT); 3427 acpi_print_sdt(sdp); 3428 wddt = (ACPI_TABLE_WDDT *)sdp; 3429 3430 printf("\tSpecVersion=%04hx\n", wddt->SpecVersion); 3431 printf("\tTableVersion=%04hx\n", wddt->TableVersion); 3432 printf("\tPciVendorID=%04hx\n", wddt->PciVendorId); 3433 printf("\tAddress="); 3434 acpi_print_gas(&wddt->Address); 3435 printf("\n\tTimer Maximum Counter Value=%d\n", wddt->MaxCount); 3436 printf("\tTimer Minimum Counter Value=%d\n", wddt->MinCount); 3437 printf("\tTimer Counter Period=%d\n", wddt->Period); 3438 3439 #define PRINTFLAG(var, flag) printflag((var), ACPI_WDDT_## flag, #flag) 3440 3441 printf("\tStatus="); 3442 PRINTFLAG(wddt->Status, AVAILABLE); 3443 PRINTFLAG(wddt->Status, ACTIVE); 3444 PRINTFLAG(wddt->Status, TCO_OS_OWNED); 3445 PRINTFLAG(wddt->Status, USER_RESET); 3446 PRINTFLAG(wddt->Status, WDT_RESET); 3447 PRINTFLAG(wddt->Status, POWER_FAIL); 3448 PRINTFLAG(wddt->Status, UNKNOWN_RESET); 3449 PRINTFLAG_END(); 3450 3451 printf("\tCapability="); 3452 PRINTFLAG(wddt->Capability, AUTO_RESET); 3453 PRINTFLAG(wddt->Capability, ALERT_SUPPORT); 3454 PRINTFLAG_END(); 3455 3456 #undef PRINTFLAG 3457 3458 printf(END_COMMENT); 3459 } 3460 3461 static void 3462 acpi_handle_wdrt(ACPI_TABLE_HEADER *sdp) 3463 { 3464 ACPI_TABLE_WDRT *wdrt; 3465 3466 printf(BEGIN_COMMENT); 3467 acpi_print_sdt(sdp); 3468 wdrt = (ACPI_TABLE_WDRT *)sdp; 3469 3470 printf("\tControl Register="); 3471 acpi_print_gas(&wdrt->ControlRegister); 3472 printf("\tCount Register="); 3473 acpi_print_gas(&wdrt->CountRegister); 3474 acpi_print_pci(wdrt->PciVendorId, wdrt->PciDeviceId, 3475 wdrt->PciSegment, wdrt->PciBus, wdrt->PciDevice, wdrt->PciFunction); 3476 3477 /* Value must be >= 511 and < 65535 */ 3478 printf("\tMaxCount=%d", wdrt->MaxCount); 3479 if (wdrt->MaxCount < 511) 3480 printf(" (Out of Range. Valid range: 511 <= maxcount < 65535)"); 3481 printf("\n"); 3482 3483 printf("\tUnit={"); 3484 switch (wdrt->Units) { 3485 case 0: 3486 printf("1 seconds/count"); 3487 break; 3488 case 1: 3489 printf("100 milliseconds/count"); 3490 break; 3491 case 2: 3492 printf("10 milliseconds/count"); 3493 break; 3494 default: 3495 printf("%d", wdrt->Units); 3496 break; 3497 } 3498 printf("}\n"); 3499 3500 printf(END_COMMENT); 3501 } 3502 3503 static void 3504 acpi_print_sdt(ACPI_TABLE_HEADER *sdp) 3505 { 3506 printf(" "); 3507 acpi_print_string(sdp->Signature, ACPI_NAME_SIZE); 3508 printf(": Length=%d, Revision=%d, Checksum=%d", 3509 sdp->Length, sdp->Revision, sdp->Checksum); 3510 if (acpi_checksum(sdp, sdp->Length)) 3511 printf(" (Incorrect)"); 3512 printf(",\n\tOEMID="); 3513 acpi_print_string(sdp->OemId, ACPI_OEM_ID_SIZE); 3514 printf(", OEM Table ID="); 3515 acpi_print_string(sdp->OemTableId, ACPI_OEM_TABLE_ID_SIZE); 3516 printf(", OEM Revision=0x%x,\n", sdp->OemRevision); 3517 printf("\tCreator ID="); 3518 acpi_print_string(sdp->AslCompilerId, ACPI_NAME_SIZE); 3519 printf(", Creator Revision=0x%x\n", sdp->AslCompilerRevision); 3520 } 3521 3522 void 3523 acpi_print_tabs(unsigned int n) 3524 { 3525 3526 while (n-- > 0) 3527 printf("\t"); 3528 } 3529 3530 static void 3531 acpi_dump_bytes(uint8_t *p, uint32_t len, unsigned int ntabs) 3532 { 3533 unsigned int i; 3534 3535 acpi_print_tabs(ntabs); 3536 printf("Data={"); 3537 for (i = 0; i < len; i++) { 3538 if (cflag) { 3539 if (i % 64 == 0) { 3540 printf("\n"); 3541 acpi_print_tabs(ntabs); 3542 printf(" "); 3543 }else if (i % 16 == 0) 3544 printf(" "); 3545 printf("%c", (p[i] >= ' ' && p[i] <= '~') ? p[i] : '.'); 3546 } else { 3547 if (i % 16 == 0) { 3548 printf("\n"); 3549 acpi_print_tabs(ntabs + 1); 3550 } else if (i % 8 == 0) 3551 printf(" "); 3552 printf(" %02x", p[i]); 3553 } 3554 } 3555 printf("\n"); 3556 acpi_print_tabs(ntabs); 3557 printf("}\n"); 3558 } 3559 3560 /* Dump data which has ACPI_TABLE_HEADER */ 3561 static void 3562 acpi_dump_table(ACPI_TABLE_HEADER *sdp) 3563 { 3564 3565 acpi_dump_bytes((uint8_t *)sdp, sdp->Length, 1); 3566 } 3567 3568 static void 3569 acpi_print_rsdt(ACPI_TABLE_HEADER *rsdp) 3570 { 3571 ACPI_TABLE_RSDT *rsdt; 3572 ACPI_TABLE_XSDT *xsdt; 3573 int i, entries; 3574 3575 rsdt = (ACPI_TABLE_RSDT *)rsdp; 3576 xsdt = (ACPI_TABLE_XSDT *)rsdp; 3577 printf(BEGIN_COMMENT); 3578 acpi_print_sdt(rsdp); 3579 entries = (rsdp->Length - sizeof(ACPI_TABLE_HEADER)) / addr_size; 3580 printf("\tEntries={ "); 3581 for (i = 0; i < entries; i++) { 3582 if (i > 0) 3583 printf(", "); 3584 if (addr_size == 4) 3585 printf("0x%08x", le32toh(rsdt->TableOffsetEntry[i])); 3586 else 3587 printf("0x%016jx", 3588 (uintmax_t)le64toh(xsdt->TableOffsetEntry[i])); 3589 } 3590 printf(" }\n"); 3591 printf(END_COMMENT); 3592 } 3593 3594 static const char *acpi_pm_profiles[] = { 3595 "Unspecified", "Desktop", "Mobile", "Workstation", 3596 "Enterprise Server", "SOHO Server", "Appliance PC", 3597 "Performance Server", "Tablet" 3598 }; 3599 3600 static void 3601 acpi_print_fadt(ACPI_TABLE_HEADER *sdp) 3602 { 3603 ACPI_TABLE_FADT *fadt; 3604 const char *pm; 3605 3606 fadt = (ACPI_TABLE_FADT *)sdp; 3607 printf(BEGIN_COMMENT); 3608 acpi_print_sdt(sdp); 3609 printf(" \tFACS=0x%x, DSDT=0x%x\n", fadt->Facs, 3610 fadt->Dsdt); 3611 /* XXX ACPI 2.0 eliminated this */ 3612 printf("\tINT_MODEL=%s\n", fadt->Model ? "APIC" : "PIC"); 3613 if (fadt->PreferredProfile >= sizeof(acpi_pm_profiles) / sizeof(char *)) 3614 pm = "Reserved"; 3615 else 3616 pm = acpi_pm_profiles[fadt->PreferredProfile]; 3617 printf("\tPreferred_PM_Profile=%s (%d)\n", pm, fadt->PreferredProfile); 3618 printf("\tSCI_INT=%d\n", fadt->SciInterrupt); 3619 printf("\tSMI_CMD=0x%x, ", fadt->SmiCommand); 3620 printf("ACPI_ENABLE=0x%x, ", fadt->AcpiEnable); 3621 printf("ACPI_DISABLE=0x%x, ", fadt->AcpiDisable); 3622 printf("S4BIOS_REQ=0x%x\n", fadt->S4BiosRequest); 3623 printf("\tPSTATE_CNT=0x%x\n", fadt->PstateControl); 3624 printf("\tPM1a_EVT_BLK=0x%x-0x%x\n", 3625 fadt->Pm1aEventBlock, 3626 fadt->Pm1aEventBlock + fadt->Pm1EventLength - 1); 3627 if (fadt->Pm1bEventBlock != 0) 3628 printf("\tPM1b_EVT_BLK=0x%x-0x%x\n", 3629 fadt->Pm1bEventBlock, 3630 fadt->Pm1bEventBlock + fadt->Pm1EventLength - 1); 3631 printf("\tPM1a_CNT_BLK=0x%x-0x%x\n", 3632 fadt->Pm1aControlBlock, 3633 fadt->Pm1aControlBlock + fadt->Pm1ControlLength - 1); 3634 if (fadt->Pm1bControlBlock != 0) 3635 printf("\tPM1b_CNT_BLK=0x%x-0x%x\n", 3636 fadt->Pm1bControlBlock, 3637 fadt->Pm1bControlBlock + fadt->Pm1ControlLength - 1); 3638 if (fadt->Pm2ControlBlock != 0) 3639 printf("\tPM2_CNT_BLK=0x%x-0x%x\n", 3640 fadt->Pm2ControlBlock, 3641 fadt->Pm2ControlBlock + fadt->Pm2ControlLength - 1); 3642 if (fadt->PmTimerBlock != 0) 3643 printf("\tPM_TMR_BLK=0x%x-0x%x\n", 3644 fadt->PmTimerBlock, 3645 fadt->PmTimerBlock + fadt->PmTimerLength - 1); 3646 if (fadt->Gpe0Block != 0) 3647 printf("\tGPE0_BLK=0x%x-0x%x\n", 3648 fadt->Gpe0Block, 3649 fadt->Gpe0Block + fadt->Gpe0BlockLength - 1); 3650 if (fadt->Gpe1Block != 0) 3651 printf("\tGPE1_BLK=0x%x-0x%x, GPE1_BASE=%d\n", 3652 fadt->Gpe1Block, 3653 fadt->Gpe1Block + fadt->Gpe1BlockLength - 1, 3654 fadt->Gpe1Base); 3655 if (fadt->CstControl != 0) 3656 printf("\tCST_CNT=0x%x\n", fadt->CstControl); 3657 printf("\tP_LVL2_LAT=%d us, P_LVL3_LAT=%d us\n", 3658 fadt->C2Latency, fadt->C3Latency); 3659 printf("\tFLUSH_SIZE=%d, FLUSH_STRIDE=%d\n", 3660 fadt->FlushSize, fadt->FlushStride); 3661 printf("\tDUTY_OFFSET=%d, DUTY_WIDTH=%d\n", 3662 fadt->DutyOffset, fadt->DutyWidth); 3663 printf("\tDAY_ALRM=%d, MON_ALRM=%d, CENTURY=%d\n", 3664 fadt->DayAlarm, fadt->MonthAlarm, fadt->Century); 3665 3666 #define PRINTFLAG(var, flag) printflag((var), ACPI_FADT_## flag, #flag) 3667 3668 printf("\tIAPC_BOOT_ARCH="); 3669 PRINTFLAG(fadt->BootFlags, LEGACY_DEVICES); 3670 PRINTFLAG(fadt->BootFlags, 8042); 3671 PRINTFLAG(fadt->BootFlags, NO_VGA); 3672 PRINTFLAG(fadt->BootFlags, NO_MSI); 3673 PRINTFLAG(fadt->BootFlags, NO_ASPM); 3674 PRINTFLAG(fadt->BootFlags, NO_CMOS_RTC); 3675 PRINTFLAG_END(); 3676 3677 printf("\tFlags="); 3678 PRINTFLAG(fadt->Flags, WBINVD); 3679 PRINTFLAG(fadt->Flags, WBINVD_FLUSH); 3680 PRINTFLAG(fadt->Flags, C1_SUPPORTED); 3681 PRINTFLAG(fadt->Flags, C2_MP_SUPPORTED); 3682 PRINTFLAG(fadt->Flags, POWER_BUTTON); 3683 PRINTFLAG(fadt->Flags, SLEEP_BUTTON); 3684 PRINTFLAG(fadt->Flags, FIXED_RTC); 3685 PRINTFLAG(fadt->Flags, S4_RTC_WAKE); 3686 PRINTFLAG(fadt->Flags, 32BIT_TIMER); 3687 PRINTFLAG(fadt->Flags, DOCKING_SUPPORTED); 3688 PRINTFLAG(fadt->Flags, RESET_REGISTER); 3689 PRINTFLAG(fadt->Flags, SEALED_CASE); 3690 PRINTFLAG(fadt->Flags, HEADLESS); 3691 PRINTFLAG(fadt->Flags, SLEEP_TYPE); 3692 PRINTFLAG(fadt->Flags, PCI_EXPRESS_WAKE); 3693 PRINTFLAG(fadt->Flags, PLATFORM_CLOCK); 3694 PRINTFLAG(fadt->Flags, S4_RTC_VALID); 3695 PRINTFLAG(fadt->Flags, REMOTE_POWER_ON); 3696 PRINTFLAG(fadt->Flags, APIC_CLUSTER); 3697 PRINTFLAG(fadt->Flags, APIC_PHYSICAL); 3698 PRINTFLAG(fadt->Flags, HW_REDUCED); 3699 PRINTFLAG(fadt->Flags, LOW_POWER_S0); 3700 PRINTFLAG_END(); 3701 3702 if (sdp->Length < ACPI_FADT_V2_SIZE) 3703 goto out; 3704 3705 if (fadt->Flags & ACPI_FADT_RESET_REGISTER) { 3706 printf("\tRESET_REG="); 3707 acpi_print_gas(&fadt->ResetRegister); 3708 printf(", RESET_VALUE=%#x\n", fadt->ResetValue); 3709 } 3710 3711 printf("\tArmBootFlags="); 3712 PRINTFLAG(fadt->ArmBootFlags, PSCI_COMPLIANT); 3713 PRINTFLAG(fadt->ArmBootFlags, PSCI_USE_HVC); 3714 PRINTFLAG_END(); 3715 3716 #undef PRINTFLAG 3717 3718 printf("\tMinorRevision=%u\n", fadt->MinorRevision); 3719 3720 if (sdp->Length < ACPI_FADT_V3_SIZE) 3721 goto out; 3722 3723 printf("\tX_FACS=0x%016jx, ", (uintmax_t)fadt->XFacs); 3724 printf("X_DSDT=0x%016jx\n", (uintmax_t)fadt->XDsdt); 3725 printf("\tX_PM1a_EVT_BLK="); 3726 acpi_print_gas(&fadt->XPm1aEventBlock); 3727 if (fadt->XPm1bEventBlock.Address != 0) { 3728 printf("\n\tX_PM1b_EVT_BLK="); 3729 acpi_print_gas(&fadt->XPm1bEventBlock); 3730 } 3731 printf("\n\tX_PM1a_CNT_BLK="); 3732 acpi_print_gas(&fadt->XPm1aControlBlock); 3733 if (fadt->XPm1bControlBlock.Address != 0) { 3734 printf("\n\tX_PM1b_CNT_BLK="); 3735 acpi_print_gas(&fadt->XPm1bControlBlock); 3736 } 3737 if (fadt->XPm2ControlBlock.Address != 0) { 3738 printf("\n\tX_PM2_CNT_BLK="); 3739 acpi_print_gas(&fadt->XPm2ControlBlock); 3740 } 3741 if (fadt->XPmTimerBlock.Address != 0) { 3742 printf("\n\tX_PM_TMR_BLK="); 3743 acpi_print_gas(&fadt->XPmTimerBlock); 3744 } 3745 if (fadt->XGpe0Block.Address != 0) { 3746 printf("\n\tX_GPE0_BLK="); 3747 acpi_print_gas(&fadt->XGpe0Block); 3748 } 3749 if (fadt->XGpe1Block.Address != 0) { 3750 printf("\n\tX_GPE1_BLK="); 3751 acpi_print_gas(&fadt->XGpe1Block); 3752 } 3753 printf("\n"); 3754 3755 if (sdp->Length < ACPI_FADT_V5_SIZE) 3756 goto out; 3757 3758 if (fadt->SleepControl.Address != 0) { 3759 printf("\tSleepControl="); 3760 acpi_print_gas(&fadt->SleepControl); 3761 printf("\n"); 3762 } 3763 if (fadt->SleepStatus.Address != 0) { 3764 printf("\n\tSleepStatus="); 3765 acpi_print_gas(&fadt->SleepStatus); 3766 printf("\n"); 3767 } 3768 3769 if (sdp->Length < ACPI_FADT_V6_SIZE) 3770 goto out; 3771 3772 printf("\tHypervisorId=0x%016"PRIx64"\n", fadt->HypervisorId); 3773 3774 out: 3775 printf(END_COMMENT); 3776 } 3777 3778 static void 3779 acpi_print_facs(ACPI_TABLE_FACS *facs) 3780 { 3781 printf(BEGIN_COMMENT); 3782 printf(" FACS:\tLength=%u, ", facs->Length); 3783 printf("HwSig=0x%08x, ", facs->HardwareSignature); 3784 printf("Firm_Wake_Vec=0x%08x\n", facs->FirmwareWakingVector); 3785 3786 #define PRINTFLAG(var, flag) printflag((var), ACPI_GLOCK_## flag, #flag) 3787 3788 printf("\tGlobal_Lock="); 3789 PRINTFLAG(facs->GlobalLock, PENDING); 3790 PRINTFLAG(facs->GlobalLock, OWNED); 3791 PRINTFLAG_END(); 3792 3793 #undef PRINTFLAG 3794 3795 #define PRINTFLAG(var, flag) printflag((var), ACPI_FACS_## flag, #flag) 3796 3797 printf("\tFlags="); 3798 PRINTFLAG(facs->Flags, S4_BIOS_PRESENT); 3799 PRINTFLAG(facs->Flags, 64BIT_WAKE); 3800 PRINTFLAG_END(); 3801 3802 #undef PRINTFLAG 3803 3804 if (facs->XFirmwareWakingVector != 0) 3805 printf("\tX_Firm_Wake_Vec=%016jx\n", 3806 (uintmax_t)facs->XFirmwareWakingVector); 3807 printf("\tVersion=%u\n", facs->Version); 3808 3809 printf("\tOspmFlags={"); 3810 if (facs->OspmFlags & ACPI_FACS_64BIT_ENVIRONMENT) 3811 printf("64BIT_WAKE"); 3812 printf("}\n"); 3813 3814 printf(END_COMMENT); 3815 } 3816 3817 static void 3818 acpi_print_dsdt(ACPI_TABLE_HEADER *dsdp) 3819 { 3820 printf(BEGIN_COMMENT); 3821 acpi_print_sdt(dsdp); 3822 printf(END_COMMENT); 3823 } 3824 3825 int 3826 acpi_checksum(void *p, size_t length) 3827 { 3828 uint8_t *bp; 3829 uint8_t sum; 3830 3831 bp = p; 3832 sum = 0; 3833 while (length--) 3834 sum += *bp++; 3835 3836 return (sum); 3837 } 3838 3839 static ACPI_TABLE_HEADER * 3840 acpi_map_sdt(vm_offset_t pa) 3841 { 3842 ACPI_TABLE_HEADER *sp; 3843 3844 sp = acpi_map_physical(pa, sizeof(ACPI_TABLE_HEADER)); 3845 sp = acpi_map_physical(pa, sp->Length); 3846 return (sp); 3847 } 3848 3849 static void 3850 acpi_print_rsd_ptr(ACPI_TABLE_RSDP *rp) 3851 { 3852 printf(BEGIN_COMMENT); 3853 printf(" RSD PTR: OEM="); 3854 acpi_print_string(rp->OemId, ACPI_OEM_ID_SIZE); 3855 printf(", ACPI_Rev=%s (%d)\n", rp->Revision < 2 ? "1.0x" : "2.0x", 3856 rp->Revision); 3857 if (rp->Revision < 2) { 3858 printf("\tRSDT=0x%08x, cksum=%u\n", rp->RsdtPhysicalAddress, 3859 rp->Checksum); 3860 } else { 3861 printf("\tXSDT=0x%016jx, length=%u, cksum=%u\n", 3862 (uintmax_t)rp->XsdtPhysicalAddress, rp->Length, 3863 rp->ExtendedChecksum); 3864 } 3865 printf(END_COMMENT); 3866 } 3867 3868 static void 3869 acpi_handle_rsdt(ACPI_TABLE_HEADER *rsdp) 3870 { 3871 ACPI_TABLE_HEADER *sdp; 3872 ACPI_TABLE_RSDT *rsdt; 3873 ACPI_TABLE_XSDT *xsdt; 3874 vm_offset_t addr = 0; 3875 int entries, i; 3876 3877 acpi_print_rsdt(rsdp); 3878 rsdt = (ACPI_TABLE_RSDT *)rsdp; 3879 xsdt = (ACPI_TABLE_XSDT *)rsdp; 3880 entries = (rsdp->Length - sizeof(ACPI_TABLE_HEADER)) / addr_size; 3881 for (i = 0; i < entries; i++) { 3882 if (addr_size == 4) 3883 addr = le32toh(rsdt->TableOffsetEntry[i]); 3884 else 3885 addr = le64toh(xsdt->TableOffsetEntry[i]); 3886 if (addr == 0) 3887 continue; 3888 sdp = (ACPI_TABLE_HEADER *)acpi_map_sdt(addr); 3889 if (acpi_checksum(sdp, sdp->Length)) { 3890 warnx("RSDT entry %d (sig %.4s) is corrupt", i, 3891 sdp->Signature); 3892 if (sflag) 3893 continue; 3894 } 3895 if (!memcmp(sdp->Signature, ACPI_SIG_FADT, 4)) 3896 acpi_handle_fadt(sdp); 3897 else if (!memcmp(sdp->Signature, ACPI_SIG_BERT, 4)) 3898 acpi_handle_bert(sdp); 3899 else if (!memcmp(sdp->Signature, ACPI_SIG_BOOT, 4)) 3900 acpi_handle_boot(sdp); 3901 else if (!memcmp(sdp->Signature, ACPI_SIG_CPEP, 4)) 3902 acpi_handle_cpep(sdp); 3903 else if (!memcmp(sdp->Signature, ACPI_SIG_CSRT, 4)) 3904 acpi_handle_csrt(sdp); 3905 else if (!memcmp(sdp->Signature, ACPI_SIG_DBGP, 4)) 3906 acpi_handle_dbgp(sdp); 3907 else if (!memcmp(sdp->Signature, ACPI_SIG_DBG2, 4)) 3908 acpi_handle_dbg2(sdp); 3909 else if (!memcmp(sdp->Signature, ACPI_SIG_DMAR, 4)) 3910 acpi_handle_dmar(sdp); 3911 else if (!memcmp(sdp->Signature, ACPI_SIG_EINJ, 4)) 3912 acpi_handle_einj(sdp); 3913 else if (!memcmp(sdp->Signature, ACPI_SIG_ERST, 4)) 3914 acpi_handle_erst(sdp); 3915 else if (!memcmp(sdp->Signature, ACPI_SIG_GTDT, 4)) 3916 acpi_handle_gtdt(sdp); 3917 else if (!memcmp(sdp->Signature, ACPI_SIG_MADT, 4)) 3918 acpi_handle_madt(sdp); 3919 else if (!memcmp(sdp->Signature, ACPI_SIG_MSCT, 4)) 3920 acpi_handle_msct(sdp); 3921 else if (!memcmp(sdp->Signature, ACPI_SIG_HEST, 4)) 3922 acpi_handle_hest(sdp); 3923 else if (!memcmp(sdp->Signature, ACPI_SIG_HPET, 4)) 3924 acpi_handle_hpet(sdp); 3925 else if (!memcmp(sdp->Signature, ACPI_SIG_ECDT, 4)) 3926 acpi_handle_ecdt(sdp); 3927 else if (!memcmp(sdp->Signature, ACPI_SIG_LPIT, 4)) 3928 acpi_handle_lpit(sdp); 3929 else if (!memcmp(sdp->Signature, ACPI_SIG_MCFG, 4)) 3930 acpi_handle_mcfg(sdp); 3931 else if (!memcmp(sdp->Signature, ACPI_SIG_PPTT, 4)) 3932 acpi_handle_pptt(sdp); 3933 else if (!memcmp(sdp->Signature, ACPI_SIG_SBST, 4)) 3934 acpi_handle_sbst(sdp); 3935 else if (!memcmp(sdp->Signature, ACPI_SIG_SLIT, 4)) 3936 acpi_handle_slit(sdp); 3937 else if (!memcmp(sdp->Signature, ACPI_SIG_SPCR, 4)) 3938 acpi_handle_spcr(sdp); 3939 else if (!memcmp(sdp->Signature, ACPI_SIG_SPMI, 4)) 3940 acpi_handle_spmi(sdp); 3941 else if (!memcmp(sdp->Signature, ACPI_SIG_SRAT, 4)) 3942 acpi_handle_srat(sdp); 3943 else if (!memcmp(sdp->Signature, ACPI_SIG_TCPA, 4)) 3944 acpi_handle_tcpa(sdp); 3945 else if (!memcmp(sdp->Signature, ACPI_SIG_NFIT, 4)) 3946 acpi_handle_nfit(sdp); 3947 else if (!memcmp(sdp->Signature, ACPI_SIG_UEFI, 4)) 3948 acpi_handle_uefi(sdp); 3949 else if (!memcmp(sdp->Signature, ACPI_SIG_WAET, 4)) 3950 acpi_handle_waet(sdp); 3951 else if (!memcmp(sdp->Signature, ACPI_SIG_WDAT, 4)) 3952 acpi_handle_wdat(sdp); 3953 else if (!memcmp(sdp->Signature, ACPI_SIG_WDDT, 4)) 3954 acpi_handle_wddt(sdp); 3955 else if (!memcmp(sdp->Signature, ACPI_SIG_WDRT, 4)) 3956 acpi_handle_wdrt(sdp); 3957 else { 3958 printf(BEGIN_COMMENT); 3959 acpi_print_sdt(sdp); 3960 printf("\n"); 3961 acpi_dump_table(sdp); 3962 printf(END_COMMENT); 3963 } 3964 } 3965 } 3966 3967 ACPI_TABLE_HEADER * 3968 sdt_load_devmem(void) 3969 { 3970 ACPI_TABLE_RSDP *rp; 3971 ACPI_TABLE_HEADER *rsdp; 3972 3973 rp = acpi_find_rsd_ptr(); 3974 if (!rp) 3975 errx(EXIT_FAILURE, "Can't find ACPI information"); 3976 3977 if (tflag) 3978 acpi_print_rsd_ptr(rp); 3979 if (rp->Revision < 2) { 3980 rsdp = (ACPI_TABLE_HEADER *)acpi_map_sdt(rp->RsdtPhysicalAddress); 3981 if (memcmp(rsdp->Signature, "RSDT", 4) != 0 || 3982 acpi_checksum(rsdp, rsdp->Length) != 0) 3983 errx(EXIT_FAILURE, "RSDT is corrupted"); 3984 addr_size = sizeof(uint32_t); 3985 } else { 3986 rsdp = (ACPI_TABLE_HEADER *)acpi_map_sdt(rp->XsdtPhysicalAddress); 3987 if (memcmp(rsdp->Signature, "XSDT", 4) != 0 || 3988 acpi_checksum(rsdp, rsdp->Length) != 0) 3989 errx(EXIT_FAILURE, "XSDT is corrupted"); 3990 addr_size = sizeof(uint64_t); 3991 } 3992 return (rsdp); 3993 } 3994 3995 /* Write the DSDT to a file, concatenating any SSDTs (if present). */ 3996 static int 3997 write_dsdt(int fd, ACPI_TABLE_HEADER *rsdt, ACPI_TABLE_HEADER *dsdt) 3998 { 3999 ACPI_TABLE_HEADER sdt; 4000 ACPI_TABLE_HEADER *ssdt; 4001 uint8_t sum; 4002 4003 /* Create a new checksum to account for the DSDT and any SSDTs. */ 4004 sdt = *dsdt; 4005 if (rsdt != NULL) { 4006 sdt.Checksum = 0; 4007 sum = acpi_checksum(dsdt + 1, dsdt->Length - 4008 sizeof(ACPI_TABLE_HEADER)); 4009 ssdt = sdt_from_rsdt(rsdt, ACPI_SIG_SSDT, NULL); 4010 while (ssdt != NULL) { 4011 sdt.Length += ssdt->Length - sizeof(ACPI_TABLE_HEADER); 4012 sum += acpi_checksum(ssdt + 1, 4013 ssdt->Length - sizeof(ACPI_TABLE_HEADER)); 4014 ssdt = sdt_from_rsdt(rsdt, ACPI_SIG_SSDT, ssdt); 4015 } 4016 sum += acpi_checksum(&sdt, sizeof(ACPI_TABLE_HEADER)); 4017 sdt.Checksum -= sum; 4018 } 4019 4020 /* Write out the DSDT header and body. */ 4021 write(fd, &sdt, sizeof(ACPI_TABLE_HEADER)); 4022 write(fd, dsdt + 1, dsdt->Length - sizeof(ACPI_TABLE_HEADER)); 4023 4024 /* Write out any SSDTs (if present.) */ 4025 if (rsdt != NULL) { 4026 ssdt = sdt_from_rsdt(rsdt, "SSDT", NULL); 4027 while (ssdt != NULL) { 4028 write(fd, ssdt + 1, ssdt->Length - 4029 sizeof(ACPI_TABLE_HEADER)); 4030 ssdt = sdt_from_rsdt(rsdt, "SSDT", ssdt); 4031 } 4032 } 4033 return (0); 4034 } 4035 4036 void 4037 dsdt_save_file(char *outfile, ACPI_TABLE_HEADER *rsdt, ACPI_TABLE_HEADER *dsdp) 4038 { 4039 int fd; 4040 mode_t mode; 4041 4042 assert(outfile != NULL); 4043 mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH; 4044 fd = open(outfile, O_WRONLY | O_CREAT | O_TRUNC, mode); 4045 if (fd == -1) { 4046 perror("dsdt_save_file"); 4047 return; 4048 } 4049 write_dsdt(fd, rsdt, dsdp); 4050 close(fd); 4051 } 4052 4053 void 4054 aml_disassemble(ACPI_TABLE_HEADER *rsdt, ACPI_TABLE_HEADER *dsdp) 4055 { 4056 char buf[MAXPATHLEN], tmpstr[MAXPATHLEN], wrkdir[MAXPATHLEN]; 4057 const char *iname = "/acpdump.din"; 4058 const char *oname = "/acpdump.dsl"; 4059 const char *tmpdir; 4060 FILE *fp; 4061 size_t len; 4062 int fd, status; 4063 pid_t pid; 4064 4065 if (rsdt == NULL) 4066 errx(EXIT_FAILURE, "aml_disassemble: invalid rsdt"); 4067 if (dsdp == NULL) 4068 errx(EXIT_FAILURE, "aml_disassemble: invalid dsdp"); 4069 4070 tmpdir = getenv("TMPDIR"); 4071 if (tmpdir == NULL) 4072 tmpdir = _PATH_TMP; 4073 if (realpath(tmpdir, buf) == NULL) { 4074 perror("realpath tmp dir"); 4075 return; 4076 } 4077 len = sizeof(wrkdir) - strlen(iname); 4078 if ((size_t)snprintf(wrkdir, len, "%s/acpidump.XXXXXX", buf) > len-1 ) { 4079 fprintf(stderr, "$TMPDIR too long\n"); 4080 return; 4081 } 4082 if (mkdtemp(wrkdir) == NULL) { 4083 perror("mkdtemp tmp working dir"); 4084 return; 4085 } 4086 len = (size_t)snprintf(tmpstr, sizeof(tmpstr), "%s%s", wrkdir, iname); 4087 assert(len <= sizeof(tmpstr) - 1); 4088 fd = open(tmpstr, O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR); 4089 if (fd < 0) { 4090 perror("iasl tmp file"); 4091 return; 4092 } 4093 write_dsdt(fd, rsdt, dsdp); 4094 close(fd); 4095 4096 /* Run iasl -d on the temp file */ 4097 if ((pid = fork()) == 0) { 4098 close(STDOUT_FILENO); 4099 if (vflag == 0) 4100 close(STDERR_FILENO); 4101 execl("/usr/bin/iasl", "iasl", "-d", tmpstr, NULL); 4102 err(EXIT_FAILURE, "exec"); 4103 } 4104 if (pid > 0) 4105 wait(&status); 4106 if (unlink(tmpstr) < 0) { 4107 perror("unlink"); 4108 goto out; 4109 } 4110 if (pid < 0) { 4111 perror("fork"); 4112 goto out; 4113 } 4114 if (status != 0) { 4115 fprintf(stderr, "iast exit status = %d\n", status); 4116 } 4117 4118 /* Dump iasl's output to stdout */ 4119 len = (size_t)snprintf(tmpstr, sizeof(tmpstr), "%s%s", wrkdir, oname); 4120 assert(len <= sizeof(tmpstr) - 1); 4121 fp = fopen(tmpstr, "r"); 4122 if (unlink(tmpstr) < 0) { 4123 perror("unlink"); 4124 goto out; 4125 } 4126 if (fp == NULL) { 4127 perror("iasl tmp file (read)"); 4128 goto out; 4129 } 4130 while ((len = fread(buf, 1, sizeof(buf), fp)) > 0) 4131 fwrite(buf, 1, len, stdout); 4132 fclose(fp); 4133 4134 out: 4135 if (rmdir(wrkdir) < 0) 4136 perror("rmdir"); 4137 } 4138 4139 void 4140 sdt_print_all(ACPI_TABLE_HEADER *rsdp) 4141 { 4142 acpi_handle_rsdt(rsdp); 4143 } 4144 4145 /* Fetch a table matching the given signature via the RSDT. */ 4146 ACPI_TABLE_HEADER * 4147 sdt_from_rsdt(ACPI_TABLE_HEADER *rsdp, const char *sig, ACPI_TABLE_HEADER *last) 4148 { 4149 ACPI_TABLE_HEADER *sdt; 4150 ACPI_TABLE_RSDT *rsdt; 4151 ACPI_TABLE_XSDT *xsdt; 4152 vm_offset_t addr = 0; 4153 int entries, i; 4154 4155 rsdt = (ACPI_TABLE_RSDT *)rsdp; 4156 xsdt = (ACPI_TABLE_XSDT *)rsdp; 4157 entries = (rsdp->Length - sizeof(ACPI_TABLE_HEADER)) / addr_size; 4158 for (i = 0; i < entries; i++) { 4159 if (addr_size == 4) 4160 addr = le32toh(rsdt->TableOffsetEntry[i]); 4161 else 4162 addr = le64toh(xsdt->TableOffsetEntry[i]); 4163 if (addr == 0) 4164 continue; 4165 sdt = (ACPI_TABLE_HEADER *)acpi_map_sdt(addr); 4166 if (last != NULL) { 4167 if (sdt == last) 4168 last = NULL; 4169 continue; 4170 } 4171 if (memcmp(sdt->Signature, sig, strlen(sig))) 4172 continue; 4173 if (acpi_checksum(sdt, sdt->Length)) 4174 errx(EXIT_FAILURE, "RSDT entry %d is corrupt", i); 4175 return (sdt); 4176 } 4177 4178 return (NULL); 4179 } 4180 4181 ACPI_TABLE_HEADER * 4182 dsdt_from_fadt(ACPI_TABLE_FADT *fadt) 4183 { 4184 ACPI_TABLE_HEADER *sdt; 4185 4186 /* Use the DSDT address if it is version 1, otherwise use XDSDT. */ 4187 sdt = (ACPI_TABLE_HEADER *)acpi_map_sdt( 4188 acpi_select_address(fadt->Dsdt, fadt->XDsdt)); 4189 if (acpi_checksum(sdt, sdt->Length)) 4190 errx(EXIT_FAILURE, "DSDT is corrupt"); 4191 return (sdt); 4192 } 4193
Indexes created Sat Sep 20 22:09:52 GMT 2025