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