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