acpi.c revision 195947
1/*- 2 * Copyright (c) 1998 Doug Rabson 3 * Copyright (c) 2000 Mitsuru IWASAKI <iwasaki@FreeBSD.org> 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 * 27 * $FreeBSD: head/usr.sbin/acpi/acpidump/acpi.c 195947 2009-07-29 19:07:24Z jhb $ 28 */ 29 30#include <sys/param.h> 31#include <sys/endian.h> 32#include <sys/stat.h> 33#include <sys/wait.h> 34#include <assert.h> 35#include <err.h> 36#include <fcntl.h> 37#include <paths.h> 38#include <stdio.h> 39#include <stdint.h> 40#include <stdlib.h> 41#include <string.h> 42#include <unistd.h> 43 44#include "acpidump.h" 45 46#define BEGIN_COMMENT "/*\n" 47#define END_COMMENT " */\n" 48 49static void acpi_print_string(char *s, size_t length); 50static void acpi_print_gas(struct ACPIgas *gas); 51static int acpi_get_fadt_revision(struct FADTbody *fadt); 52static void acpi_handle_fadt(struct ACPIsdt *fadt); 53static void acpi_print_cpu(u_char cpu_id); 54static void acpi_print_local_apic(u_char cpu_id, u_char apic_id, 55 u_int32_t flags); 56static void acpi_print_io_apic(u_char apic_id, u_int32_t int_base, 57 u_int64_t apic_addr); 58static void acpi_print_mps_flags(u_int16_t flags); 59static void acpi_print_intr(u_int32_t intr, u_int16_t mps_flags); 60static void acpi_print_apic(struct MADT_APIC *mp); 61static void acpi_handle_apic(struct ACPIsdt *sdp); 62static void acpi_handle_hpet(struct ACPIsdt *sdp); 63static void acpi_print_srat_cpu(uint32_t apic_id, uint32_t proximity_domain, 64 uint32_t flags); 65static void acpi_print_srat_memory(struct SRAT_memory *mp); 66static void acpi_print_srat(struct SRATentry *srat); 67static void acpi_handle_srat(struct ACPIsdt *sdp); 68static void acpi_print_sdt(struct ACPIsdt *sdp); 69static void acpi_print_fadt(struct ACPIsdt *sdp); 70static void acpi_print_facs(struct FACSbody *facs); 71static void acpi_print_dsdt(struct ACPIsdt *dsdp); 72static struct ACPIsdt *acpi_map_sdt(vm_offset_t pa); 73static void acpi_print_rsd_ptr(struct ACPIrsdp *rp); 74static void acpi_handle_rsdt(struct ACPIsdt *rsdp); 75 76/* Size of an address. 32-bit for ACPI 1.0, 64-bit for ACPI 2.0 and up. */ 77static int addr_size; 78 79static void 80acpi_print_string(char *s, size_t length) 81{ 82 int c; 83 84 /* Trim trailing spaces and NULLs */ 85 while (length > 0 && (s[length - 1] == ' ' || s[length - 1] == '\0')) 86 length--; 87 88 while (length--) { 89 c = *s++; 90 putchar(c); 91 } 92} 93 94static void 95acpi_print_gas(struct ACPIgas *gas) 96{ 97 switch(gas->address_space_id) { 98 case ACPI_GAS_MEMORY: 99 printf("0x%08lx:%u[%u] (Memory)", (u_long)gas->address, 100 gas->bit_offset, gas->bit_width); 101 break; 102 case ACPI_GAS_IO: 103 printf("0x%02lx:%u[%u] (IO)", (u_long)gas->address, 104 gas->bit_offset, gas->bit_width); 105 break; 106 case ACPI_GAS_PCI: 107 printf("%x:%x+0x%x (PCI)", (uint16_t)(gas->address >> 32), 108 (uint16_t)((gas->address >> 16) & 0xffff), 109 (uint16_t)gas->address); 110 break; 111 /* XXX How to handle these below? */ 112 case ACPI_GAS_EMBEDDED: 113 printf("0x%x:%u[%u] (EC)", (uint16_t)gas->address, 114 gas->bit_offset, gas->bit_width); 115 break; 116 case ACPI_GAS_SMBUS: 117 printf("0x%x:%u[%u] (SMBus)", (uint16_t)gas->address, 118 gas->bit_offset, gas->bit_width); 119 break; 120 case ACPI_GAS_FIXED: 121 default: 122 printf("0x%08lx (?)", (u_long)gas->address); 123 break; 124 } 125} 126 127/* The FADT revision indicates whether we use the DSDT or X_DSDT addresses. */ 128static int 129acpi_get_fadt_revision(struct FADTbody *fadt) 130{ 131 int fadt_revision; 132 133 /* Set the FADT revision separately from the RSDP version. */ 134 if (addr_size == 8) { 135 fadt_revision = 2; 136 137 /* 138 * A few systems (e.g., IBM T23) have an RSDP that claims 139 * revision 2 but the 64 bit addresses are invalid. If 140 * revision 2 and the 32 bit address is non-zero but the 141 * 32 and 64 bit versions don't match, prefer the 32 bit 142 * version for all subsequent tables. 143 */ 144 if (fadt->facs_ptr != 0 && 145 (fadt->x_facs_ptr & 0xffffffff) != fadt->facs_ptr) 146 fadt_revision = 1; 147 } else 148 fadt_revision = 1; 149 return (fadt_revision); 150} 151 152static void 153acpi_handle_fadt(struct ACPIsdt *sdp) 154{ 155 struct ACPIsdt *dsdp; 156 struct FACSbody *facs; 157 struct FADTbody *fadt; 158 int fadt_revision; 159 160 fadt = (struct FADTbody *)sdp->body; 161 acpi_print_fadt(sdp); 162 163 fadt_revision = acpi_get_fadt_revision(fadt); 164 if (fadt_revision == 1) 165 facs = (struct FACSbody *)acpi_map_sdt(fadt->facs_ptr); 166 else 167 facs = (struct FACSbody *)acpi_map_sdt(fadt->x_facs_ptr); 168 if (memcmp(facs->signature, "FACS", 4) != 0 || facs->len < 64) 169 errx(1, "FACS is corrupt"); 170 acpi_print_facs(facs); 171 172 if (fadt_revision == 1) 173 dsdp = (struct ACPIsdt *)acpi_map_sdt(fadt->dsdt_ptr); 174 else 175 dsdp = (struct ACPIsdt *)acpi_map_sdt(fadt->x_dsdt_ptr); 176 if (acpi_checksum(dsdp, dsdp->len)) 177 errx(1, "DSDT is corrupt"); 178 acpi_print_dsdt(dsdp); 179} 180 181static void 182acpi_print_cpu(u_char cpu_id) 183{ 184 185 printf("\tACPI CPU="); 186 if (cpu_id == 0xff) 187 printf("ALL\n"); 188 else 189 printf("%d\n", (u_int)cpu_id); 190} 191 192static void 193acpi_print_local_apic(u_char cpu_id, u_char apic_id, u_int32_t flags) 194{ 195 acpi_print_cpu(cpu_id); 196 printf("\tFlags={"); 197 if (flags & ACPI_MADT_APIC_LOCAL_FLAG_ENABLED) 198 printf("ENABLED"); 199 else 200 printf("DISABLED"); 201 printf("}\n"); 202 printf("\tAPIC ID=%d\n", (u_int)apic_id); 203} 204 205static void 206acpi_print_io_apic(u_char apic_id, u_int32_t int_base, u_int64_t apic_addr) 207{ 208 printf("\tAPIC ID=%d\n", (u_int)apic_id); 209 printf("\tINT BASE=%d\n", int_base); 210 printf("\tADDR=0x%016jx\n", apic_addr); 211} 212 213static void 214acpi_print_mps_flags(u_int16_t flags) 215{ 216 217 printf("\tFlags={Polarity="); 218 switch (flags & MPS_INT_FLAG_POLARITY_MASK) { 219 case MPS_INT_FLAG_POLARITY_CONFORM: 220 printf("conforming"); 221 break; 222 case MPS_INT_FLAG_POLARITY_HIGH: 223 printf("active-hi"); 224 break; 225 case MPS_INT_FLAG_POLARITY_LOW: 226 printf("active-lo"); 227 break; 228 default: 229 printf("0x%x", flags & MPS_INT_FLAG_POLARITY_MASK); 230 break; 231 } 232 printf(", Trigger="); 233 switch (flags & MPS_INT_FLAG_TRIGGER_MASK) { 234 case MPS_INT_FLAG_TRIGGER_CONFORM: 235 printf("conforming"); 236 break; 237 case MPS_INT_FLAG_TRIGGER_EDGE: 238 printf("edge"); 239 break; 240 case MPS_INT_FLAG_TRIGGER_LEVEL: 241 printf("level"); 242 break; 243 default: 244 printf("0x%x", (flags & MPS_INT_FLAG_TRIGGER_MASK) >> 2); 245 } 246 printf("}\n"); 247} 248 249static void 250acpi_print_intr(u_int32_t intr, u_int16_t mps_flags) 251{ 252 253 printf("\tINTR=%d\n", (u_int)intr); 254 acpi_print_mps_flags(mps_flags); 255} 256 257const char *apic_types[] = { "Local APIC", "IO APIC", "INT Override", "NMI", 258 "Local NMI", "Local APIC Override", "IO SAPIC", 259 "Local SAPIC", "Platform Interrupt" }; 260const char *platform_int_types[] = { "PMI", "INIT", 261 "Corrected Platform Error" }; 262 263static void 264acpi_print_apic(struct MADT_APIC *mp) 265{ 266 267 if (mp->type < sizeof(apic_types) / sizeof(apic_types[0])) 268 printf("\tType=%s\n", apic_types[mp->type]); 269 else 270 printf("\tType=%d (unknown)\n", mp->type); 271 switch (mp->type) { 272 case ACPI_MADT_APIC_TYPE_LOCAL_APIC: 273 acpi_print_local_apic(mp->body.local_apic.cpu_id, 274 mp->body.local_apic.apic_id, mp->body.local_apic.flags); 275 break; 276 case ACPI_MADT_APIC_TYPE_IO_APIC: 277 acpi_print_io_apic(mp->body.io_apic.apic_id, 278 mp->body.io_apic.int_base, 279 mp->body.io_apic.apic_addr); 280 break; 281 case ACPI_MADT_APIC_TYPE_INT_OVERRIDE: 282 printf("\tBUS=%d\n", (u_int)mp->body.int_override.bus); 283 printf("\tIRQ=%d\n", (u_int)mp->body.int_override.source); 284 acpi_print_intr(mp->body.int_override.intr, 285 mp->body.int_override.mps_flags); 286 break; 287 case ACPI_MADT_APIC_TYPE_NMI: 288 acpi_print_intr(mp->body.nmi.intr, mp->body.nmi.mps_flags); 289 break; 290 case ACPI_MADT_APIC_TYPE_LOCAL_NMI: 291 acpi_print_cpu(mp->body.local_nmi.cpu_id); 292 printf("\tLINT Pin=%d\n", mp->body.local_nmi.lintpin); 293 acpi_print_mps_flags(mp->body.local_nmi.mps_flags); 294 break; 295 case ACPI_MADT_APIC_TYPE_LOCAL_OVERRIDE: 296 printf("\tLocal APIC ADDR=0x%016jx\n", 297 mp->body.local_apic_override.apic_addr); 298 break; 299 case ACPI_MADT_APIC_TYPE_IO_SAPIC: 300 acpi_print_io_apic(mp->body.io_sapic.apic_id, 301 mp->body.io_sapic.int_base, 302 mp->body.io_sapic.apic_addr); 303 break; 304 case ACPI_MADT_APIC_TYPE_LOCAL_SAPIC: 305 acpi_print_local_apic(mp->body.local_sapic.cpu_id, 306 mp->body.local_sapic.apic_id, mp->body.local_sapic.flags); 307 printf("\tAPIC EID=%d\n", (u_int)mp->body.local_sapic.apic_eid); 308 break; 309 case ACPI_MADT_APIC_TYPE_INT_SRC: 310 printf("\tType=%s\n", 311 platform_int_types[mp->body.int_src.type]); 312 printf("\tCPU ID=%d\n", (u_int)mp->body.int_src.cpu_id); 313 printf("\tCPU EID=%d\n", (u_int)mp->body.int_src.cpu_id); 314 printf("\tSAPIC Vector=%d\n", 315 (u_int)mp->body.int_src.sapic_vector); 316 acpi_print_intr(mp->body.int_src.intr, 317 mp->body.int_src.mps_flags); 318 break; 319 } 320} 321 322static void 323acpi_handle_apic(struct ACPIsdt *sdp) 324{ 325 struct MADTbody *madtp; 326 struct MADT_APIC *madt_apicp; 327 328 printf(BEGIN_COMMENT); 329 acpi_print_sdt(sdp); 330 madtp = (struct MADTbody *) sdp->body; 331 printf("\tLocal APIC ADDR=0x%08x\n", madtp->lapic_addr); 332 printf("\tFlags={"); 333 if (madtp->flags & ACPI_APIC_FLAG_PCAT_COMPAT) 334 printf("PC-AT"); 335 printf("}\n"); 336 madt_apicp = (struct MADT_APIC *)madtp->body; 337 while (((uintptr_t)madt_apicp) - ((uintptr_t)sdp) < sdp->len) { 338 printf("\n"); 339 acpi_print_apic(madt_apicp); 340 madt_apicp = (struct MADT_APIC *) ((char *)madt_apicp + 341 madt_apicp->len); 342 } 343 printf(END_COMMENT); 344} 345 346static void 347acpi_handle_hpet(struct ACPIsdt *sdp) 348{ 349 struct HPETbody *hpetp; 350 351 printf(BEGIN_COMMENT); 352 acpi_print_sdt(sdp); 353 hpetp = (struct HPETbody *) sdp->body; 354 printf("\tHPET Number=%d\n", hpetp->hpet_number); 355 printf("\tADDR="); 356 acpi_print_gas(&hpetp->genaddr); 357 printf("\tHW Rev=0x%x\n", hpetp->block_hwrev); 358 printf("\tComparitors=%d\n", hpetp->block_comparitors); 359 printf("\tCounter Size=%d\n", hpetp->block_counter_size); 360 printf("\tLegacy IRQ routing capable={"); 361 if (hpetp->block_legacy_capable) 362 printf("TRUE}\n"); 363 else 364 printf("FALSE}\n"); 365 printf("\tPCI Vendor ID=0x%04x\n", hpetp->block_pcivendor); 366 printf("\tMinimal Tick=%d\n", hpetp->clock_tick); 367 printf(END_COMMENT); 368} 369 370static void 371acpi_handle_ecdt(struct ACPIsdt *sdp) 372{ 373 struct ECDTbody *ecdt; 374 375 printf(BEGIN_COMMENT); 376 acpi_print_sdt(sdp); 377 ecdt = (struct ECDTbody *) sdp->body; 378 printf("\tEC_CONTROL="); 379 acpi_print_gas(&ecdt->ec_control); 380 printf("\n\tEC_DATA="); 381 acpi_print_gas(&ecdt->ec_data); 382 printf("\n\tUID=%#x, ", ecdt->uid); 383 printf("GPE_BIT=%#x\n", ecdt->gpe_bit); 384 printf("\tEC_ID=%s\n", ecdt->ec_id); 385 printf(END_COMMENT); 386} 387 388static void 389acpi_handle_mcfg(struct ACPIsdt *sdp) 390{ 391 struct MCFGbody *mcfg; 392 u_int i, e; 393 394 printf(BEGIN_COMMENT); 395 acpi_print_sdt(sdp); 396 mcfg = (struct MCFGbody *) sdp->body; 397 398 e = (sdp->len - ((caddr_t)&mcfg->s[0] - (caddr_t)sdp)) / 399 sizeof(*mcfg->s); 400 for (i = 0; i < e; i++, mcfg++) { 401 printf("\n"); 402 printf("\tBase Address=0x%016jx\n", mcfg->s[i].baseaddr); 403 printf("\tSegment Group=0x%04x\n", mcfg->s[i].seg_grp); 404 printf("\tStart Bus=%d\n", mcfg->s[i].start); 405 printf("\tEnd Bus=%d\n", mcfg->s[i].end); 406 } 407 printf(END_COMMENT); 408} 409 410static void 411acpi_print_srat_cpu(uint32_t apic_id, uint32_t proximity_domain, 412 uint32_t flags) 413{ 414 415 printf("\tFlags={"); 416 if (flags & ACPI_SRAT_CPU_ENABLED) 417 printf("ENABLED"); 418 else 419 printf("DISABLED"); 420 printf("}\n"); 421 printf("\tAPIC ID=%d\n", apic_id); 422 printf("\tProximity Domain=%d\n", proximity_domain); 423} 424 425static void 426acpi_print_srat_memory(struct SRAT_memory *mp) 427{ 428 429 printf("\tFlags={"); 430 if (mp->flags & ACPI_SRAT_MEM_ENABLED) 431 printf("ENABLED"); 432 else 433 printf("DISABLED"); 434 if (mp->flags & ACPI_SRAT_MEM_HOT_PLUGGABLE) 435 printf(",HOT_PLUGGABLE"); 436 if (mp->flags & ACPI_SRAT_MEM_NON_VOLATILE) 437 printf(",NON_VOLATILE"); 438 printf("}\n"); 439 printf("\tBase Address=0x%016jx\n", (uintmax_t)mp->base_address); 440 printf("\tLength=0x%016jx\n", (uintmax_t)mp->length); 441 printf("\tProximity Domain=%d\n", mp->proximity_domain); 442} 443 444const char *srat_types[] = { "CPU", "Memory", "X2APIC" }; 445 446static void 447acpi_print_srat(struct SRATentry *srat) 448{ 449 450 if (srat->type < sizeof(srat_types) / sizeof(srat_types[0])) 451 printf("\tType=%s\n", srat_types[srat->type]); 452 else 453 printf("\tType=%d (unknown)\n", srat->type); 454 switch (srat->type) { 455 case ACPI_SRAT_TYPE_CPU_AFFINITY: 456 acpi_print_srat_cpu(srat->body.cpu.apic_id, 457 srat->body.cpu.proximity_domain_hi[2] << 24 | 458 srat->body.cpu.proximity_domain_hi[1] << 16 | 459 srat->body.cpu.proximity_domain_hi[0] << 0 | 460 srat->body.cpu.proximity_domain_lo, srat->body.cpu.flags); 461 break; 462 case ACPI_SRAT_TYPE_MEMORY_AFFINITY: 463 acpi_print_srat_memory(&srat->body.mem); 464 break; 465 case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY: 466 acpi_print_srat_cpu(srat->body.x2apic.apic_id, 467 srat->body.x2apic.proximity_domain, 468 srat->body.x2apic.flags); 469 break; 470 } 471} 472 473static void 474acpi_handle_srat(struct ACPIsdt *sdp) 475{ 476 struct SRATbody *sratp; 477 struct SRATentry *entry; 478 479 printf(BEGIN_COMMENT); 480 acpi_print_sdt(sdp); 481 sratp = (struct SRATbody *)sdp->body; 482 printf("\tTable Revision=%d\n", sratp->table_revision); 483 entry = sratp->body; 484 while (((uintptr_t)entry) - ((uintptr_t)sdp) < sdp->len) { 485 printf("\n"); 486 acpi_print_srat(entry); 487 entry = (struct SRATentry *)((char *)entry + entry->len); 488 } 489 printf(END_COMMENT); 490} 491 492static void 493acpi_print_sdt(struct ACPIsdt *sdp) 494{ 495 printf(" "); 496 acpi_print_string(sdp->signature, 4); 497 printf(": Length=%d, Revision=%d, Checksum=%d,\n", 498 sdp->len, sdp->rev, sdp->check); 499 printf("\tOEMID="); 500 acpi_print_string(sdp->oemid, 6); 501 printf(", OEM Table ID="); 502 acpi_print_string(sdp->oemtblid, 8); 503 printf(", OEM Revision=0x%x,\n", sdp->oemrev); 504 printf("\tCreator ID="); 505 acpi_print_string(sdp->creator, 4); 506 printf(", Creator Revision=0x%x\n", sdp->crerev); 507} 508 509static void 510acpi_print_rsdt(struct ACPIsdt *rsdp) 511{ 512 int i, entries; 513 u_long addr; 514 515 printf(BEGIN_COMMENT); 516 acpi_print_sdt(rsdp); 517 entries = (rsdp->len - SIZEOF_SDT_HDR) / addr_size; 518 printf("\tEntries={ "); 519 for (i = 0; i < entries; i++) { 520 if (i > 0) 521 printf(", "); 522 switch (addr_size) { 523 case 4: 524 addr = le32dec((char*)rsdp->body + i * addr_size); 525 break; 526 case 8: 527 addr = le64dec((char*)rsdp->body + i * addr_size); 528 break; 529 default: 530 addr = 0; 531 } 532 assert(addr != 0); 533 printf("0x%08lx", addr); 534 } 535 printf(" }\n"); 536 printf(END_COMMENT); 537} 538 539static const char *acpi_pm_profiles[] = { 540 "Unspecified", "Desktop", "Mobile", "Workstation", 541 "Enterprise Server", "SOHO Server", "Appliance PC" 542}; 543 544static void 545acpi_print_fadt(struct ACPIsdt *sdp) 546{ 547 struct FADTbody *fadt; 548 const char *pm; 549 char sep; 550 551 fadt = (struct FADTbody *)sdp->body; 552 printf(BEGIN_COMMENT); 553 acpi_print_sdt(sdp); 554 printf(" \tFACS=0x%x, DSDT=0x%x\n", fadt->facs_ptr, 555 fadt->dsdt_ptr); 556 printf("\tINT_MODEL=%s\n", fadt->int_model ? "APIC" : "PIC"); 557 if (fadt->pm_profile >= sizeof(acpi_pm_profiles) / sizeof(char *)) 558 pm = "Reserved"; 559 else 560 pm = acpi_pm_profiles[fadt->pm_profile]; 561 printf("\tPreferred_PM_Profile=%s (%d)\n", pm, fadt->pm_profile); 562 printf("\tSCI_INT=%d\n", fadt->sci_int); 563 printf("\tSMI_CMD=0x%x, ", fadt->smi_cmd); 564 printf("ACPI_ENABLE=0x%x, ", fadt->acpi_enable); 565 printf("ACPI_DISABLE=0x%x, ", fadt->acpi_disable); 566 printf("S4BIOS_REQ=0x%x\n", fadt->s4biosreq); 567 printf("\tPSTATE_CNT=0x%x\n", fadt->pstate_cnt); 568 printf("\tPM1a_EVT_BLK=0x%x-0x%x\n", 569 fadt->pm1a_evt_blk, 570 fadt->pm1a_evt_blk + fadt->pm1_evt_len - 1); 571 if (fadt->pm1b_evt_blk != 0) 572 printf("\tPM1b_EVT_BLK=0x%x-0x%x\n", 573 fadt->pm1b_evt_blk, 574 fadt->pm1b_evt_blk + fadt->pm1_evt_len - 1); 575 printf("\tPM1a_CNT_BLK=0x%x-0x%x\n", 576 fadt->pm1a_cnt_blk, 577 fadt->pm1a_cnt_blk + fadt->pm1_cnt_len - 1); 578 if (fadt->pm1b_cnt_blk != 0) 579 printf("\tPM1b_CNT_BLK=0x%x-0x%x\n", 580 fadt->pm1b_cnt_blk, 581 fadt->pm1b_cnt_blk + fadt->pm1_cnt_len - 1); 582 if (fadt->pm2_cnt_blk != 0) 583 printf("\tPM2_CNT_BLK=0x%x-0x%x\n", 584 fadt->pm2_cnt_blk, 585 fadt->pm2_cnt_blk + fadt->pm2_cnt_len - 1); 586 printf("\tPM_TMR_BLK=0x%x-0x%x\n", 587 fadt->pm_tmr_blk, 588 fadt->pm_tmr_blk + fadt->pm_tmr_len - 1); 589 if (fadt->gpe0_blk != 0) 590 printf("\tGPE0_BLK=0x%x-0x%x\n", 591 fadt->gpe0_blk, 592 fadt->gpe0_blk + fadt->gpe0_len - 1); 593 if (fadt->gpe1_blk != 0) 594 printf("\tGPE1_BLK=0x%x-0x%x, GPE1_BASE=%d\n", 595 fadt->gpe1_blk, 596 fadt->gpe1_blk + fadt->gpe1_len - 1, 597 fadt->gpe1_base); 598 if (fadt->cst_cnt != 0) 599 printf("\tCST_CNT=0x%x\n", fadt->cst_cnt); 600 printf("\tP_LVL2_LAT=%d us, P_LVL3_LAT=%d us\n", 601 fadt->p_lvl2_lat, fadt->p_lvl3_lat); 602 printf("\tFLUSH_SIZE=%d, FLUSH_STRIDE=%d\n", 603 fadt->flush_size, fadt->flush_stride); 604 printf("\tDUTY_OFFSET=%d, DUTY_WIDTH=%d\n", 605 fadt->duty_off, fadt->duty_width); 606 printf("\tDAY_ALRM=%d, MON_ALRM=%d, CENTURY=%d\n", 607 fadt->day_alrm, fadt->mon_alrm, fadt->century); 608 609#define PRINTFLAG(var, flag) do { \ 610 if ((var) & FADT_FLAG_## flag) { \ 611 printf("%c%s", sep, #flag); sep = ','; \ 612 } \ 613} while (0) 614 615 printf("\tIAPC_BOOT_ARCH="); 616 sep = '{'; 617 PRINTFLAG(fadt->iapc_boot_arch, LEGACY_DEV); 618 PRINTFLAG(fadt->iapc_boot_arch, 8042); 619 if (fadt->iapc_boot_arch != 0) 620 printf("}"); 621 printf("\n"); 622 623 printf("\tFlags="); 624 sep = '{'; 625 PRINTFLAG(fadt->flags, WBINVD); 626 PRINTFLAG(fadt->flags, WBINVD_FLUSH); 627 PRINTFLAG(fadt->flags, PROC_C1); 628 PRINTFLAG(fadt->flags, P_LVL2_UP); 629 PRINTFLAG(fadt->flags, PWR_BUTTON); 630 PRINTFLAG(fadt->flags, SLP_BUTTON); 631 PRINTFLAG(fadt->flags, FIX_RTC); 632 PRINTFLAG(fadt->flags, RTC_S4); 633 PRINTFLAG(fadt->flags, TMR_VAL_EXT); 634 PRINTFLAG(fadt->flags, DCK_CAP); 635 PRINTFLAG(fadt->flags, RESET_REG); 636 PRINTFLAG(fadt->flags, SEALED_CASE); 637 PRINTFLAG(fadt->flags, HEADLESS); 638 PRINTFLAG(fadt->flags, CPU_SW_SLP); 639 if (fadt->flags != 0) 640 printf("}\n"); 641 642#undef PRINTFLAG 643 644 if (fadt->flags & FADT_FLAG_RESET_REG) { 645 printf("\tRESET_REG="); 646 acpi_print_gas(&fadt->reset_reg); 647 printf(", RESET_VALUE=%#x\n", fadt->reset_value); 648 } 649 if (acpi_get_fadt_revision(fadt) > 1) { 650 printf("\tX_FACS=0x%08lx, ", (u_long)fadt->x_facs_ptr); 651 printf("X_DSDT=0x%08lx\n", (u_long)fadt->x_dsdt_ptr); 652 printf("\tX_PM1a_EVT_BLK="); 653 acpi_print_gas(&fadt->x_pm1a_evt_blk); 654 if (fadt->x_pm1b_evt_blk.address != 0) { 655 printf("\n\tX_PM1b_EVT_BLK="); 656 acpi_print_gas(&fadt->x_pm1b_evt_blk); 657 } 658 printf("\n\tX_PM1a_CNT_BLK="); 659 acpi_print_gas(&fadt->x_pm1a_cnt_blk); 660 if (fadt->x_pm1b_cnt_blk.address != 0) { 661 printf("\n\tX_PM1b_CNT_BLK="); 662 acpi_print_gas(&fadt->x_pm1b_cnt_blk); 663 } 664 if (fadt->x_pm1b_cnt_blk.address != 0) { 665 printf("\n\tX_PM2_CNT_BLK="); 666 acpi_print_gas(&fadt->x_pm2_cnt_blk); 667 } 668 printf("\n\tX_PM_TMR_BLK="); 669 acpi_print_gas(&fadt->x_pm_tmr_blk); 670 if (fadt->x_gpe0_blk.address != 0) { 671 printf("\n\tX_GPE0_BLK="); 672 acpi_print_gas(&fadt->x_gpe0_blk); 673 } 674 if (fadt->x_gpe1_blk.address != 0) { 675 printf("\n\tX_GPE1_BLK="); 676 acpi_print_gas(&fadt->x_gpe1_blk); 677 } 678 printf("\n"); 679 } 680 681 printf(END_COMMENT); 682} 683 684static void 685acpi_print_facs(struct FACSbody *facs) 686{ 687 printf(BEGIN_COMMENT); 688 printf(" FACS:\tLength=%u, ", facs->len); 689 printf("HwSig=0x%08x, ", facs->hw_sig); 690 printf("Firm_Wake_Vec=0x%08x\n", facs->firm_wake_vec); 691 692 printf("\tGlobal_Lock="); 693 if (facs->global_lock != 0) { 694 if (facs->global_lock & FACS_FLAG_LOCK_PENDING) 695 printf("PENDING,"); 696 if (facs->global_lock & FACS_FLAG_LOCK_OWNED) 697 printf("OWNED"); 698 } 699 printf("\n"); 700 701 printf("\tFlags="); 702 if (facs->flags & FACS_FLAG_S4BIOS_F) 703 printf("S4BIOS"); 704 printf("\n"); 705 706 if (facs->x_firm_wake_vec != 0) { 707 printf("\tX_Firm_Wake_Vec=%08lx\n", 708 (u_long)facs->x_firm_wake_vec); 709 } 710 printf("\tVersion=%u\n", facs->version); 711 712 printf(END_COMMENT); 713} 714 715static void 716acpi_print_dsdt(struct ACPIsdt *dsdp) 717{ 718 printf(BEGIN_COMMENT); 719 acpi_print_sdt(dsdp); 720 printf(END_COMMENT); 721} 722 723int 724acpi_checksum(void *p, size_t length) 725{ 726 u_int8_t *bp; 727 u_int8_t sum; 728 729 bp = p; 730 sum = 0; 731 while (length--) 732 sum += *bp++; 733 734 return (sum); 735} 736 737static struct ACPIsdt * 738acpi_map_sdt(vm_offset_t pa) 739{ 740 struct ACPIsdt *sp; 741 742 sp = acpi_map_physical(pa, sizeof(struct ACPIsdt)); 743 sp = acpi_map_physical(pa, sp->len); 744 return (sp); 745} 746 747static void 748acpi_print_rsd_ptr(struct ACPIrsdp *rp) 749{ 750 printf(BEGIN_COMMENT); 751 printf(" RSD PTR: OEM="); 752 acpi_print_string(rp->oem, 6); 753 printf(", ACPI_Rev=%s (%d)\n", rp->revision < 2 ? "1.0x" : "2.0x", 754 rp->revision); 755 if (rp->revision < 2) { 756 printf("\tRSDT=0x%08x, cksum=%u\n", rp->rsdt_addr, rp->sum); 757 } else { 758 printf("\tXSDT=0x%08lx, length=%u, cksum=%u\n", 759 (u_long)rp->xsdt_addr, rp->length, rp->xsum); 760 } 761 printf(END_COMMENT); 762} 763 764static void 765acpi_handle_rsdt(struct ACPIsdt *rsdp) 766{ 767 struct ACPIsdt *sdp; 768 vm_offset_t addr; 769 int entries, i; 770 771 acpi_print_rsdt(rsdp); 772 entries = (rsdp->len - SIZEOF_SDT_HDR) / addr_size; 773 for (i = 0; i < entries; i++) { 774 switch (addr_size) { 775 case 4: 776 addr = le32dec((char*)rsdp->body + i * addr_size); 777 break; 778 case 8: 779 addr = le64dec((char*)rsdp->body + i * addr_size); 780 break; 781 default: 782 assert((addr = 0)); 783 } 784 785 sdp = (struct ACPIsdt *)acpi_map_sdt(addr); 786 if (acpi_checksum(sdp, sdp->len)) { 787 warnx("RSDT entry %d (sig %.4s) is corrupt", i, 788 sdp->signature); 789 continue; 790 } 791 if (!memcmp(sdp->signature, "FACP", 4)) 792 acpi_handle_fadt(sdp); 793 else if (!memcmp(sdp->signature, "APIC", 4)) 794 acpi_handle_apic(sdp); 795 else if (!memcmp(sdp->signature, "HPET", 4)) 796 acpi_handle_hpet(sdp); 797 else if (!memcmp(sdp->signature, "ECDT", 4)) 798 acpi_handle_ecdt(sdp); 799 else if (!memcmp(sdp->signature, "MCFG", 4)) 800 acpi_handle_mcfg(sdp); 801 else if (!memcmp(sdp->signature, "SRAT", 4)) 802 acpi_handle_srat(sdp); 803 else { 804 printf(BEGIN_COMMENT); 805 acpi_print_sdt(sdp); 806 printf(END_COMMENT); 807 } 808 } 809} 810 811struct ACPIsdt * 812sdt_load_devmem(void) 813{ 814 struct ACPIrsdp *rp; 815 struct ACPIsdt *rsdp; 816 817 rp = acpi_find_rsd_ptr(); 818 if (!rp) 819 errx(1, "Can't find ACPI information"); 820 821 if (tflag) 822 acpi_print_rsd_ptr(rp); 823 if (rp->revision < 2) { 824 rsdp = (struct ACPIsdt *)acpi_map_sdt(rp->rsdt_addr); 825 if (memcmp(rsdp->signature, "RSDT", 4) != 0 || 826 acpi_checksum(rsdp, rsdp->len) != 0) 827 errx(1, "RSDT is corrupted"); 828 addr_size = sizeof(uint32_t); 829 } else { 830 rsdp = (struct ACPIsdt *)acpi_map_sdt(rp->xsdt_addr); 831 if (memcmp(rsdp->signature, "XSDT", 4) != 0 || 832 acpi_checksum(rsdp, rsdp->len) != 0) 833 errx(1, "XSDT is corrupted"); 834 addr_size = sizeof(uint64_t); 835 } 836 return (rsdp); 837} 838 839/* Write the DSDT to a file, concatenating any SSDTs (if present). */ 840static int 841write_dsdt(int fd, struct ACPIsdt *rsdt, struct ACPIsdt *dsdt) 842{ 843 struct ACPIsdt sdt; 844 struct ACPIsdt *ssdt; 845 uint8_t sum; 846 847 /* Create a new checksum to account for the DSDT and any SSDTs. */ 848 sdt = *dsdt; 849 if (rsdt != NULL) { 850 sdt.check = 0; 851 sum = acpi_checksum(dsdt->body, dsdt->len - SIZEOF_SDT_HDR); 852 ssdt = sdt_from_rsdt(rsdt, "SSDT", NULL); 853 while (ssdt != NULL) { 854 sdt.len += ssdt->len - SIZEOF_SDT_HDR; 855 sum += acpi_checksum(ssdt->body, 856 ssdt->len - SIZEOF_SDT_HDR); 857 ssdt = sdt_from_rsdt(rsdt, "SSDT", ssdt); 858 } 859 sum += acpi_checksum(&sdt, SIZEOF_SDT_HDR); 860 sdt.check -= sum; 861 } 862 863 /* Write out the DSDT header and body. */ 864 write(fd, &sdt, SIZEOF_SDT_HDR); 865 write(fd, dsdt->body, dsdt->len - SIZEOF_SDT_HDR); 866 867 /* Write out any SSDTs (if present.) */ 868 if (rsdt != NULL) { 869 ssdt = sdt_from_rsdt(rsdt, "SSDT", NULL); 870 while (ssdt != NULL) { 871 write(fd, ssdt->body, ssdt->len - SIZEOF_SDT_HDR); 872 ssdt = sdt_from_rsdt(rsdt, "SSDT", ssdt); 873 } 874 } 875 return (0); 876} 877 878void 879dsdt_save_file(char *outfile, struct ACPIsdt *rsdt, struct ACPIsdt *dsdp) 880{ 881 int fd; 882 mode_t mode; 883 884 assert(outfile != NULL); 885 mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH; 886 fd = open(outfile, O_WRONLY | O_CREAT | O_TRUNC, mode); 887 if (fd == -1) { 888 perror("dsdt_save_file"); 889 return; 890 } 891 write_dsdt(fd, rsdt, dsdp); 892 close(fd); 893} 894 895void 896aml_disassemble(struct ACPIsdt *rsdt, struct ACPIsdt *dsdp) 897{ 898 char buf[PATH_MAX], tmpstr[PATH_MAX]; 899 const char *tmpdir; 900 char *tmpext; 901 FILE *fp; 902 size_t len; 903 int fd; 904 905 tmpdir = getenv("TMPDIR"); 906 if (tmpdir == NULL) 907 tmpdir = _PATH_TMP; 908 strncpy(tmpstr, tmpdir, sizeof(tmpstr)); 909 strncat(tmpstr, "/acpidump.", sizeof(tmpstr) - strlen(tmpdir)); 910 if (realpath(tmpstr, buf) == NULL) { 911 perror("realpath tmp file"); 912 return; 913 } 914 strncpy(tmpstr, buf, sizeof(tmpstr)); 915 len = strlen(buf); 916 tmpext = tmpstr + len; 917 strncpy(tmpext, "XXXXXX", sizeof(tmpstr) - len); 918 fd = mkstemp(tmpstr); 919 if (fd < 0) { 920 perror("iasl tmp file"); 921 return; 922 } 923 write_dsdt(fd, rsdt, dsdp); 924 close(fd); 925 926 /* Run iasl -d on the temp file */ 927 if (fork() == 0) { 928 close(STDOUT_FILENO); 929 if (vflag == 0) 930 close(STDERR_FILENO); 931 execl("/usr/sbin/iasl", "iasl", "-d", tmpstr, NULL); 932 err(1, "exec"); 933 } 934 935 wait(NULL); 936 unlink(tmpstr); 937 938 /* Dump iasl's output to stdout */ 939 strncpy(tmpext, "dsl", sizeof(tmpstr) - len); 940 fp = fopen(tmpstr, "r"); 941 unlink(tmpstr); 942 if (fp == NULL) { 943 perror("iasl tmp file (read)"); 944 return; 945 } 946 while ((len = fread(buf, 1, sizeof(buf), fp)) > 0) 947 fwrite(buf, 1, len, stdout); 948 fclose(fp); 949} 950 951void 952sdt_print_all(struct ACPIsdt *rsdp) 953{ 954 acpi_handle_rsdt(rsdp); 955} 956 957/* Fetch a table matching the given signature via the RSDT. */ 958struct ACPIsdt * 959sdt_from_rsdt(struct ACPIsdt *rsdt, const char *sig, struct ACPIsdt *last) 960{ 961 struct ACPIsdt *sdt; 962 vm_offset_t addr; 963 int entries, i; 964 965 entries = (rsdt->len - SIZEOF_SDT_HDR) / addr_size; 966 for (i = 0; i < entries; i++) { 967 switch (addr_size) { 968 case 4: 969 addr = le32dec((char*)rsdt->body + i * addr_size); 970 break; 971 case 8: 972 addr = le64dec((char*)rsdt->body + i * addr_size); 973 break; 974 default: 975 assert((addr = 0)); 976 } 977 sdt = (struct ACPIsdt *)acpi_map_sdt(addr); 978 if (last != NULL) { 979 if (sdt == last) 980 last = NULL; 981 continue; 982 } 983 if (memcmp(sdt->signature, sig, strlen(sig))) 984 continue; 985 if (acpi_checksum(sdt, sdt->len)) 986 errx(1, "RSDT entry %d is corrupt", i); 987 return (sdt); 988 } 989 990 return (NULL); 991} 992 993struct ACPIsdt * 994dsdt_from_fadt(struct FADTbody *fadt) 995{ 996 struct ACPIsdt *sdt; 997 998 /* Use the DSDT address if it is version 1, otherwise use X_DSDT. */ 999 if (acpi_get_fadt_revision(fadt) == 1) 1000 sdt = (struct ACPIsdt *)acpi_map_sdt(fadt->dsdt_ptr); 1001 else 1002 sdt = (struct ACPIsdt *)acpi_map_sdt(fadt->x_dsdt_ptr); 1003 if (acpi_checksum(sdt, sdt->len)) 1004 errx(1, "DSDT is corrupt\n"); 1005 return (sdt); 1006} 1007