acpi.c revision 121693
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 121693 2003-10-29 17:59:05Z njl $ 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 <stdio.h> 38#include <string.h> 39#include <unistd.h> 40 41#include "acpidump.h" 42 43#define BEGIN_COMMENT "/*\n" 44#define END_COMMENT " */\n" 45 46static void acpi_print_string(char *s, size_t length); 47static void acpi_print_gas(struct ACPIgas *gas); 48static void acpi_handle_fadt(struct FADTbody *fadt); 49static void acpi_print_cpu(u_char cpu_id); 50static void acpi_print_local_apic(u_char cpu_id, u_char apic_id, 51 u_int32_t flags); 52static void acpi_print_io_apic(u_char apic_id, u_int32_t int_base, 53 u_int64_t apic_addr); 54static void acpi_print_mps_flags(u_int16_t flags); 55static void acpi_print_intr(u_int32_t intr, u_int16_t mps_flags); 56static void acpi_print_apic(struct MADT_APIC *mp); 57static void acpi_handle_apic(struct ACPIsdt *sdp); 58static void acpi_handle_hpet(struct ACPIsdt *sdp); 59static void acpi_print_sdt(struct ACPIsdt *sdp); 60static void acpi_print_fadt(struct FADTbody *fadt); 61static void acpi_print_facs(struct FACSbody *facs); 62static void acpi_print_dsdt(struct ACPIsdt *dsdp); 63static struct ACPIsdt *acpi_map_sdt(vm_offset_t pa); 64static void acpi_print_rsd_ptr(struct ACPIrsdp *rp); 65static void acpi_handle_rsdt(struct ACPIsdt *rsdp); 66 67/* Size of an address. 32-bit for ACPI 1.0, 64-bit for ACPI 2.0 and up. */ 68static int addr_size; 69 70static void 71acpi_print_string(char *s, size_t length) 72{ 73 int c; 74 75 /* Trim trailing spaces and NULLs */ 76 while (length > 0 && (s[length - 1] == ' ' || s[length - 1] == '\0')) 77 length--; 78 79 while (length--) { 80 c = *s++; 81 putchar(c); 82 } 83} 84 85static void 86acpi_print_gas(struct ACPIgas *gas) 87{ 88 switch(gas->address_space_id) { 89 case ACPI_GAS_MEMORY: 90 printf("0x%08lx:%u[%u] (Memory)", (u_long)gas->address, 91 gas->bit_offset, gas->bit_width); 92 break; 93 case ACPI_GAS_IO: 94 printf("0x%02lx:%u[%u] (IO)", (u_long)gas->address, 95 gas->bit_offset, gas->bit_width); 96 break; 97 case ACPI_GAS_PCI: 98 printf("%x:%x+0x%x (PCI)", (uint16_t)(gas->address >> 32), 99 (uint16_t)((gas->address >> 16) & 0xffff), 100 (uint16_t)gas->address); 101 break; 102 /* XXX How to handle these below? */ 103 case ACPI_GAS_EMBEDDED: 104 printf("0x%x:%u[%u] (EC)", (uint16_t)gas->address, 105 gas->bit_offset, gas->bit_width); 106 break; 107 case ACPI_GAS_SMBUS: 108 printf("0x%x:%u[%u] (SMBus)", (uint16_t)gas->address, 109 gas->bit_offset, gas->bit_width); 110 break; 111 case ACPI_GAS_FIXED: 112 default: 113 printf("0x%08lx (?)", (u_long)gas->address); 114 break; 115 } 116} 117 118static void 119acpi_handle_fadt(struct FADTbody *fadt) 120{ 121 struct ACPIsdt *dsdp; 122 struct FACSbody *facs; 123 124 acpi_print_fadt(fadt); 125 126 /* 127 * My T23 is revision 2 but the 64 bit addresses are invalid. 128 * If revision 2 and the 32 bit address is non-zero but the 32 129 * and 64 bit versions don't match, prefer the 32 bit version. 130 */ 131 if (addr_size == 4 || 132 (addr_size == 8 && fadt->facs_ptr != 0 && 133 (fadt->x_facs_ptr & 0xffffffff) != fadt->facs_ptr)) 134 facs = (struct FACSbody *)acpi_map_sdt(fadt->facs_ptr); 135 else 136 facs = (struct FACSbody *)acpi_map_sdt(fadt->x_facs_ptr); 137 if (memcmp(facs->signature, "FACS", 4) != 0 || facs->len < 64) 138 errx(1, "FACS is corrupt"); 139 acpi_print_facs(facs); 140 141 if (addr_size == 4 || 142 (addr_size == 8 && fadt->dsdt_ptr != 0 && 143 (fadt->x_dsdt_ptr & 0xffffffff) != fadt->dsdt_ptr)) 144 dsdp = (struct ACPIsdt *)acpi_map_sdt(fadt->dsdt_ptr); 145 else 146 dsdp = (struct ACPIsdt *)acpi_map_sdt(fadt->x_dsdt_ptr); 147 if (acpi_checksum(dsdp, dsdp->len)) 148 errx(1, "DSDT is corrupt"); 149 acpi_print_dsdt(dsdp); 150} 151 152static void 153acpi_print_cpu(u_char cpu_id) 154{ 155 156 printf("\tACPI CPU="); 157 if (cpu_id == 0xff) 158 printf("ALL\n"); 159 else 160 printf("%d\n", (u_int)cpu_id); 161} 162 163static void 164acpi_print_local_apic(u_char cpu_id, u_char apic_id, u_int32_t flags) 165{ 166 acpi_print_cpu(cpu_id); 167 printf("\tFlags={"); 168 if (flags & ACPI_MADT_APIC_LOCAL_FLAG_ENABLED) 169 printf("ENABLED"); 170 else 171 printf("DISABLED"); 172 printf("}\n"); 173 printf("\tAPIC ID=%d\n", (u_int)apic_id); 174} 175 176static void 177acpi_print_io_apic(u_char apic_id, u_int32_t int_base, u_int64_t apic_addr) 178{ 179 printf("\tAPIC ID=%d\n", (u_int)apic_id); 180 printf("\tINT BASE=%d\n", int_base); 181 printf("\tADDR=0x%016jx\n", apic_addr); 182} 183 184static void 185acpi_print_mps_flags(u_int16_t flags) 186{ 187 188 printf("\tFlags={Polarity="); 189 switch (flags & MPS_INT_FLAG_POLARITY_MASK) { 190 case MPS_INT_FLAG_POLARITY_CONFORM: 191 printf("conforming"); 192 break; 193 case MPS_INT_FLAG_POLARITY_HIGH: 194 printf("active-hi"); 195 break; 196 case MPS_INT_FLAG_POLARITY_LOW: 197 printf("active-lo"); 198 break; 199 default: 200 printf("0x%x", flags & MPS_INT_FLAG_POLARITY_MASK); 201 break; 202 } 203 printf(", Trigger="); 204 switch (flags & MPS_INT_FLAG_TRIGGER_MASK) { 205 case MPS_INT_FLAG_TRIGGER_CONFORM: 206 printf("conforming"); 207 break; 208 case MPS_INT_FLAG_TRIGGER_EDGE: 209 printf("edge"); 210 break; 211 case MPS_INT_FLAG_TRIGGER_LEVEL: 212 printf("level"); 213 break; 214 default: 215 printf("0x%x", (flags & MPS_INT_FLAG_TRIGGER_MASK) >> 2); 216 } 217 printf("}\n"); 218} 219 220static void 221acpi_print_intr(u_int32_t intr, u_int16_t mps_flags) 222{ 223 224 printf("\tINTR=%d\n", (u_int)intr); 225 acpi_print_mps_flags(mps_flags); 226} 227 228const char *apic_types[] = { "Local APIC", "IO APIC", "INT Override", "NMI", 229 "Local NMI", "Local APIC Override", "IO SAPIC", 230 "Local SAPIC", "Platform Interrupt" }; 231const char *platform_int_types[] = { "PMI", "INIT", 232 "Corrected Platform Error" }; 233 234static void 235acpi_print_apic(struct MADT_APIC *mp) 236{ 237 238 printf("\tType=%s\n", apic_types[mp->type]); 239 switch (mp->type) { 240 case ACPI_MADT_APIC_TYPE_LOCAL_APIC: 241 acpi_print_local_apic(mp->body.local_apic.cpu_id, 242 mp->body.local_apic.apic_id, mp->body.local_apic.flags); 243 break; 244 case ACPI_MADT_APIC_TYPE_IO_APIC: 245 acpi_print_io_apic(mp->body.io_apic.apic_id, 246 mp->body.io_apic.int_base, 247 mp->body.io_apic.apic_addr); 248 break; 249 case ACPI_MADT_APIC_TYPE_INT_OVERRIDE: 250 printf("\tBUS=%d\n", (u_int)mp->body.int_override.bus); 251 printf("\tIRQ=%d\n", (u_int)mp->body.int_override.source); 252 acpi_print_intr(mp->body.int_override.intr, 253 mp->body.int_override.mps_flags); 254 break; 255 case ACPI_MADT_APIC_TYPE_NMI: 256 acpi_print_intr(mp->body.nmi.intr, mp->body.nmi.mps_flags); 257 break; 258 case ACPI_MADT_APIC_TYPE_LOCAL_NMI: 259 acpi_print_cpu(mp->body.local_nmi.cpu_id); 260 printf("\tLINT Pin=%d\n", mp->body.local_nmi.lintpin); 261 acpi_print_mps_flags(mp->body.local_nmi.mps_flags); 262 break; 263 case ACPI_MADT_APIC_TYPE_LOCAL_OVERRIDE: 264 printf("\tLocal APIC ADDR=0x%016jx\n", 265 mp->body.local_apic_override.apic_addr); 266 break; 267 case ACPI_MADT_APIC_TYPE_IO_SAPIC: 268 acpi_print_io_apic(mp->body.io_sapic.apic_id, 269 mp->body.io_sapic.int_base, 270 mp->body.io_sapic.apic_addr); 271 break; 272 case ACPI_MADT_APIC_TYPE_LOCAL_SAPIC: 273 acpi_print_local_apic(mp->body.local_sapic.cpu_id, 274 mp->body.local_sapic.apic_id, mp->body.local_sapic.flags); 275 printf("\tAPIC EID=%d\n", (u_int)mp->body.local_sapic.apic_eid); 276 break; 277 case ACPI_MADT_APIC_TYPE_INT_SRC: 278 printf("\tType=%s\n", 279 platform_int_types[mp->body.int_src.type]); 280 printf("\tCPU ID=%d\n", (u_int)mp->body.int_src.cpu_id); 281 printf("\tCPU EID=%d\n", (u_int)mp->body.int_src.cpu_id); 282 printf("\tSAPIC Vector=%d\n", 283 (u_int)mp->body.int_src.sapic_vector); 284 acpi_print_intr(mp->body.int_src.intr, 285 mp->body.int_src.mps_flags); 286 break; 287 default: 288 printf("\tUnknown type %d\n", (u_int)mp->type); 289 break; 290 } 291} 292 293static void 294acpi_handle_apic(struct ACPIsdt *sdp) 295{ 296 struct MADTbody *madtp; 297 struct MADT_APIC *madt_apicp; 298 299 printf(BEGIN_COMMENT); 300 acpi_print_sdt(sdp); 301 madtp = (struct MADTbody *) sdp->body; 302 printf("\tLocal APIC ADDR=0x%08x\n", madtp->lapic_addr); 303 printf("\tFlags={"); 304 if (madtp->flags & ACPI_APIC_FLAG_PCAT_COMPAT) 305 printf("PC-AT"); 306 printf("}\n"); 307 madt_apicp = (struct MADT_APIC *)madtp->body; 308 while (((uintptr_t)madt_apicp) - ((uintptr_t)sdp) < sdp->len) { 309 printf("\n"); 310 acpi_print_apic(madt_apicp); 311 madt_apicp = (struct MADT_APIC *) ((char *)madt_apicp + 312 madt_apicp->len); 313 } 314 printf(END_COMMENT); 315} 316 317static void 318acpi_handle_hpet(struct ACPIsdt *sdp) 319{ 320 struct HPETbody *hpetp; 321 322 printf(BEGIN_COMMENT); 323 acpi_print_sdt(sdp); 324 hpetp = (struct HPETbody *) sdp->body; 325 printf("\tHPET Number=%d\n", hpetp->hpet_number); 326 printf("\tADDR=0x%08x\n", hpetp->base_addr); 327 printf("\tHW Rev=0x%x\n", hpetp->block_hwrev); 328 printf("\tComparitors=%d\n", hpetp->block_comparitors); 329 printf("\tCounter Size=%d\n", hpetp->block_counter_size); 330 printf("\tLegacy IRQ routing capable={"); 331 if (hpetp->block_legacy_capable) 332 printf("TRUE}\n"); 333 else 334 printf("FALSE}\n"); 335 printf("\tPCI Vendor ID=0x%04x\n", hpetp->block_pcivendor); 336 printf("\tMinimal Tick=%d\n", hpetp->clock_tick); 337 printf(END_COMMENT); 338} 339 340static void 341acpi_handle_ecdt(struct ACPIsdt *sdp) 342{ 343 struct ECDTbody *ecdt; 344 345 printf(BEGIN_COMMENT); 346 acpi_print_sdt(sdp); 347 ecdt = (struct ECDTbody *) sdp->body; 348 printf("\tEC_CONTROL="); 349 acpi_print_gas(&ecdt->ec_control); 350 printf("\n\tEC_DATA="); 351 acpi_print_gas(&ecdt->ec_data); 352 printf("\n\tUID=%#x, ", ecdt->uid); 353 printf("GPE_BIT=%#x\n", ecdt->gpe_bit); 354 printf("\tEC_ID=%s\n", ecdt->ec_id); 355 printf(END_COMMENT); 356} 357 358static void 359acpi_print_sdt(struct ACPIsdt *sdp) 360{ 361 printf(" "); 362 acpi_print_string(sdp->signature, 4); 363 printf(": Length=%d, Revision=%d, Checksum=%d,\n", 364 sdp->len, sdp->rev, sdp->check); 365 printf("\tOEMID="); 366 acpi_print_string(sdp->oemid, 6); 367 printf(", OEM Table ID="); 368 acpi_print_string(sdp->oemtblid, 8); 369 printf(", OEM Revision=0x%x,\n", sdp->oemrev); 370 printf("\tCreator ID="); 371 acpi_print_string(sdp->creator, 4); 372 printf(", Creator Revision=0x%x\n", sdp->crerev); 373} 374 375static void 376acpi_print_rsdt(struct ACPIsdt *rsdp) 377{ 378 int i, entries; 379 u_long addr; 380 381 printf(BEGIN_COMMENT); 382 acpi_print_sdt(rsdp); 383 entries = (rsdp->len - SIZEOF_SDT_HDR) / addr_size; 384 printf("\tEntries={ "); 385 for (i = 0; i < entries; i++) { 386 if (i > 0) 387 printf(", "); 388 switch (addr_size) { 389 case 4: 390 addr = le32dec((char*)rsdp->body + i * addr_size); 391 break; 392 case 8: 393 addr = le64dec((char*)rsdp->body + i * addr_size); 394 break; 395 default: 396 addr = 0; 397 } 398 assert(addr != 0); 399 printf("0x%08lx", addr); 400 } 401 printf(" }\n"); 402 printf(END_COMMENT); 403} 404 405static const char *acpi_pm_profiles[] = { 406 "Unspecified", "Desktop", "Mobile", "Workstation", 407 "Enterprise Server", "SOHO Server", "Appliance PC" 408}; 409 410static void 411acpi_print_fadt(struct FADTbody *fadt) 412{ 413 const char *pm; 414 char sep; 415 416 printf(BEGIN_COMMENT); 417 printf(" FADT:\tFACS=0x%x, DSDT=0x%x\n", fadt->facs_ptr, 418 fadt->dsdt_ptr); 419 printf("\tINT_MODEL=%s\n", fadt->int_model ? "APIC" : "PIC"); 420 if (fadt->pm_profile >= sizeof(acpi_pm_profiles) / sizeof(char *)) 421 pm = "Reserved"; 422 else 423 pm = acpi_pm_profiles[fadt->pm_profile]; 424 printf("\tPreferred_PM_Profile=%s (%d)\n", pm, fadt->pm_profile); 425 printf("\tSCI_INT=%d\n", fadt->sci_int); 426 printf("\tSMI_CMD=0x%x, ", fadt->smi_cmd); 427 printf("ACPI_ENABLE=0x%x, ", fadt->acpi_enable); 428 printf("ACPI_DISABLE=0x%x, ", fadt->acpi_disable); 429 printf("S4BIOS_REQ=0x%x\n", fadt->s4biosreq); 430 printf("\tPSTATE_CNT=0x%x\n", fadt->pstate_cnt); 431 printf("\tPM1a_EVT_BLK=0x%x-0x%x\n", 432 fadt->pm1a_evt_blk, 433 fadt->pm1a_evt_blk + fadt->pm1_evt_len - 1); 434 if (fadt->pm1b_evt_blk != 0) 435 printf("\tPM1b_EVT_BLK=0x%x-0x%x\n", 436 fadt->pm1b_evt_blk, 437 fadt->pm1b_evt_blk + fadt->pm1_evt_len - 1); 438 printf("\tPM1a_CNT_BLK=0x%x-0x%x\n", 439 fadt->pm1a_cnt_blk, 440 fadt->pm1a_cnt_blk + fadt->pm1_cnt_len - 1); 441 if (fadt->pm1b_cnt_blk != 0) 442 printf("\tPM1b_CNT_BLK=0x%x-0x%x\n", 443 fadt->pm1b_cnt_blk, 444 fadt->pm1b_cnt_blk + fadt->pm1_cnt_len - 1); 445 if (fadt->pm2_cnt_blk != 0) 446 printf("\tPM2_CNT_BLK=0x%x-0x%x\n", 447 fadt->pm2_cnt_blk, 448 fadt->pm2_cnt_blk + fadt->pm2_cnt_len - 1); 449 printf("\tPM_TMR_BLK=0x%x-0x%x\n", 450 fadt->pm_tmr_blk, 451 fadt->pm_tmr_blk + fadt->pm_tmr_len - 1); 452 if (fadt->gpe0_blk != 0) 453 printf("\tGPE0_BLK=0x%x-0x%x\n", 454 fadt->gpe0_blk, 455 fadt->gpe0_blk + fadt->gpe0_len - 1); 456 if (fadt->gpe1_blk != 0) 457 printf("\tGPE1_BLK=0x%x-0x%x, GPE1_BASE=%d\n", 458 fadt->gpe1_blk, 459 fadt->gpe1_blk + fadt->gpe1_len - 1, 460 fadt->gpe1_base); 461 if (fadt->cst_cnt != 0) 462 printf("\tCST_CNT=0x%x\n", fadt->cst_cnt); 463 printf("\tP_LVL2_LAT=%d us, P_LVL3_LAT=%d us\n", 464 fadt->p_lvl2_lat, fadt->p_lvl3_lat); 465 printf("\tFLUSH_SIZE=%d, FLUSH_STRIDE=%d\n", 466 fadt->flush_size, fadt->flush_stride); 467 printf("\tDUTY_OFFSET=%d, DUTY_WIDTH=%d\n", 468 fadt->duty_off, fadt->duty_width); 469 printf("\tDAY_ALRM=%d, MON_ALRM=%d, CENTURY=%d\n", 470 fadt->day_alrm, fadt->mon_alrm, fadt->century); 471 472#define PRINTFLAG(var, flag) do { \ 473 if ((var) & FADT_FLAG_## flag) { \ 474 printf("%c%s", sep, #flag); sep = ','; \ 475 } \ 476} while (0) 477 478 printf("\tIAPC_BOOT_ARCH="); 479 sep = '{'; 480 PRINTFLAG(fadt->iapc_boot_arch, LEGACY_DEV); 481 PRINTFLAG(fadt->iapc_boot_arch, 8042); 482 if (fadt->iapc_boot_arch != 0) 483 printf("}"); 484 printf("\n"); 485 486 printf("\tFlags="); 487 sep = '{'; 488 PRINTFLAG(fadt->flags, WBINVD); 489 PRINTFLAG(fadt->flags, WBINVD_FLUSH); 490 PRINTFLAG(fadt->flags, PROC_C1); 491 PRINTFLAG(fadt->flags, P_LVL2_UP); 492 PRINTFLAG(fadt->flags, PWR_BUTTON); 493 PRINTFLAG(fadt->flags, SLP_BUTTON); 494 PRINTFLAG(fadt->flags, FIX_RTC); 495 PRINTFLAG(fadt->flags, RTC_S4); 496 PRINTFLAG(fadt->flags, TMR_VAL_EXT); 497 PRINTFLAG(fadt->flags, DCK_CAP); 498 PRINTFLAG(fadt->flags, RESET_REG); 499 PRINTFLAG(fadt->flags, SEALED_CASE); 500 PRINTFLAG(fadt->flags, HEADLESS); 501 PRINTFLAG(fadt->flags, CPU_SW_SLP); 502 if (fadt->flags != 0) 503 printf("}\n"); 504 505#undef PRINTFLAG 506 507 if (fadt->flags & FADT_FLAG_RESET_REG) { 508 printf("\tRESET_REG="); 509 acpi_print_gas(&fadt->reset_reg); 510 printf(", RESET_VALUE=%#x\n", fadt->reset_value); 511 } 512 if (addr_size == 8) { 513 printf("\tX_FACS=0x%08lx, ", (u_long)fadt->x_facs_ptr); 514 printf("X_DSDT=0x%08lx\n", (u_long)fadt->x_dsdt_ptr); 515 printf("\tX_PM1a_EVT_BLK="); 516 acpi_print_gas(&fadt->x_pm1a_evt_blk); 517 if (fadt->x_pm1b_evt_blk.address != 0) { 518 printf("\n\tX_PM1b_EVT_BLK="); 519 acpi_print_gas(&fadt->x_pm1b_evt_blk); 520 } 521 printf("\n\tX_PM1a_CNT_BLK="); 522 acpi_print_gas(&fadt->x_pm1a_cnt_blk); 523 if (fadt->x_pm1b_cnt_blk.address != 0) { 524 printf("\n\tX_PM1b_CNT_BLK="); 525 acpi_print_gas(&fadt->x_pm1b_cnt_blk); 526 } 527 if (fadt->x_pm1b_cnt_blk.address != 0) { 528 printf("\n\tX_PM2_CNT_BLK="); 529 acpi_print_gas(&fadt->x_pm2_cnt_blk); 530 } 531 printf("\n\tX_PM_TMR_BLK="); 532 acpi_print_gas(&fadt->x_pm_tmr_blk); 533 if (fadt->x_gpe0_blk.address != 0) { 534 printf("\n\tX_GPE0_BLK="); 535 acpi_print_gas(&fadt->x_gpe0_blk); 536 } 537 if (fadt->x_gpe1_blk.address != 0) { 538 printf("\n\tX_GPE1_BLK="); 539 acpi_print_gas(&fadt->x_gpe1_blk); 540 } 541 printf("\n"); 542 } 543 544 printf(END_COMMENT); 545} 546 547static void 548acpi_print_facs(struct FACSbody *facs) 549{ 550 printf(BEGIN_COMMENT); 551 printf(" FACS:\tLength=%u, ", facs->len); 552 printf("HwSig=0x%08x, ", facs->hw_sig); 553 printf("Firm_Wake_Vec=0x%08x\n", facs->firm_wake_vec); 554 555 printf("\tGlobal_Lock="); 556 if (facs->global_lock != 0) { 557 if (facs->global_lock & FACS_FLAG_LOCK_PENDING) 558 printf("PENDING,"); 559 if (facs->global_lock & FACS_FLAG_LOCK_OWNED) 560 printf("OWNED"); 561 } 562 printf("\n"); 563 564 printf("\tFlags="); 565 if (facs->flags & FACS_FLAG_S4BIOS_F) 566 printf("S4BIOS"); 567 printf("\n"); 568 569 if (facs->x_firm_wake_vec != 0) { 570 printf("\tX_Firm_Wake_Vec=%08lx\n", 571 (u_long)facs->x_firm_wake_vec); 572 } 573 printf("\tVersion=%u\n", facs->version); 574 575 printf(END_COMMENT); 576} 577 578static void 579acpi_print_dsdt(struct ACPIsdt *dsdp) 580{ 581 printf(BEGIN_COMMENT); 582 acpi_print_sdt(dsdp); 583 printf(END_COMMENT); 584} 585 586int 587acpi_checksum(void *p, size_t length) 588{ 589 u_int8_t *bp; 590 u_int8_t sum; 591 592 bp = p; 593 sum = 0; 594 while (length--) 595 sum += *bp++; 596 597 return (sum); 598} 599 600static struct ACPIsdt * 601acpi_map_sdt(vm_offset_t pa) 602{ 603 struct ACPIsdt *sp; 604 605 sp = acpi_map_physical(pa, sizeof(struct ACPIsdt)); 606 sp = acpi_map_physical(pa, sp->len); 607 return (sp); 608} 609 610static void 611acpi_print_rsd_ptr(struct ACPIrsdp *rp) 612{ 613 printf(BEGIN_COMMENT); 614 printf(" RSD PTR: OEM="); 615 acpi_print_string(rp->oem, 6); 616 printf(", ACPI_Rev=%s (%d)\n", rp->revision < 2 ? "1.0x" : "2.0x", 617 rp->revision); 618 if (rp->revision < 2) { 619 printf("\tRSDT=0x%08x, cksum=%u\n", rp->rsdt_addr, rp->sum); 620 } else { 621 printf("\tXSDT=0x%08lx, length=%u, cksum=%u\n", 622 (u_long)rp->xsdt_addr, rp->length, rp->xsum); 623 } 624 printf(END_COMMENT); 625} 626 627static void 628acpi_handle_rsdt(struct ACPIsdt *rsdp) 629{ 630 struct ACPIsdt *sdp; 631 vm_offset_t addr; 632 int entries, i; 633 634 acpi_print_rsdt(rsdp); 635 entries = (rsdp->len - SIZEOF_SDT_HDR) / addr_size; 636 for (i = 0; i < entries; i++) { 637 switch (addr_size) { 638 case 4: 639 addr = le32dec((char*)rsdp->body + i * addr_size); 640 break; 641 case 8: 642 addr = le64dec((char*)rsdp->body + i * addr_size); 643 break; 644 default: 645 assert((addr = 0)); 646 } 647 648 sdp = (struct ACPIsdt *)acpi_map_sdt(addr); 649 if (acpi_checksum(sdp, sdp->len)) 650 errx(1, "RSDT entry %d is corrupt", i); 651 if (!memcmp(sdp->signature, "FACP", 4)) 652 acpi_handle_fadt((struct FADTbody *) sdp->body); 653 else if (!memcmp(sdp->signature, "APIC", 4)) 654 acpi_handle_apic(sdp); 655 else if (!memcmp(sdp->signature, "HPET", 4)) 656 acpi_handle_hpet(sdp); 657 else if (!memcmp(sdp->signature, "ECDT", 4)) 658 acpi_handle_ecdt(sdp); 659 else { 660 printf(BEGIN_COMMENT); 661 acpi_print_sdt(sdp); 662 printf(END_COMMENT); 663 } 664 } 665} 666 667struct ACPIsdt * 668sdt_load_devmem() 669{ 670 struct ACPIrsdp *rp; 671 struct ACPIsdt *rsdp; 672 673 rp = acpi_find_rsd_ptr(); 674 if (!rp) 675 errx(1, "Can't find ACPI information"); 676 677 if (tflag) 678 acpi_print_rsd_ptr(rp); 679 if (rp->revision < 2) { 680 rsdp = (struct ACPIsdt *)acpi_map_sdt(rp->rsdt_addr); 681 if (memcmp(rsdp->signature, "RSDT", 4) != 0 || 682 acpi_checksum(rsdp, rsdp->len) != 0) 683 errx(1, "RSDT is corrupted"); 684 addr_size = sizeof(uint32_t); 685 } else { 686 rsdp = (struct ACPIsdt *)acpi_map_sdt(rp->xsdt_addr); 687 if (memcmp(rsdp->signature, "XSDT", 4) != 0 || 688 acpi_checksum(rsdp, rsdp->len) != 0) 689 errx(1, "XSDT is corrupted"); 690 addr_size = sizeof(uint64_t); 691 } 692 return (rsdp); 693} 694 695void 696dsdt_save_file(char *outfile, struct ACPIsdt *dsdp) 697{ 698 int fd; 699 mode_t mode; 700 701 assert(outfile != NULL); 702 mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH; 703 fd = open(outfile, O_WRONLY | O_CREAT | O_TRUNC, mode); 704 if (fd == -1) { 705 perror("dsdt_save_file"); 706 return; 707 } 708 write(fd, dsdp, SIZEOF_SDT_HDR); 709 write(fd, dsdp->body, dsdp->len - SIZEOF_SDT_HDR); 710 close(fd); 711} 712 713void 714aml_disassemble(struct ACPIsdt *dsdp) 715{ 716 char tmpstr[32], buf[256]; 717 FILE *fp; 718 int fd, len; 719 720 strcpy(tmpstr, "/tmp/acpidump.XXXXXX"); 721 fd = mkstemp(tmpstr); 722 if (fd < 0) { 723 perror("iasl tmp file"); 724 return; 725 } 726 727 /* Dump DSDT to the temp file */ 728 write(fd, dsdp, SIZEOF_SDT_HDR); 729 write(fd, dsdp->body, dsdp->len - SIZEOF_SDT_HDR); 730 close(fd); 731 732 /* Run iasl -d on the temp file */ 733 if (fork() == 0) { 734 close(STDOUT_FILENO); 735 if (vflag == 0) 736 close(STDERR_FILENO); 737 execl("/usr/sbin/iasl", "iasl", "-d", tmpstr, 0); 738 err(1, "exec"); 739 } 740 741 wait(NULL); 742 unlink(tmpstr); 743 744 /* Dump iasl's output to stdout */ 745 fp = fopen("acpidump.dsl", "r"); 746 unlink("acpidump.dsl"); 747 if (fp == NULL) { 748 perror("iasl tmp file (read)"); 749 return; 750 } 751 while ((len = fread(buf, 1, sizeof(buf), fp)) > 0) 752 fwrite(buf, 1, len, stdout); 753 fclose(fp); 754} 755 756void 757sdt_print_all(struct ACPIsdt *rsdp) 758{ 759 acpi_handle_rsdt(rsdp); 760} 761 762/* Fetch a table matching the given signature via the RSDT */ 763struct ACPIsdt * 764sdt_from_rsdt(struct ACPIsdt *rsdt, const char *sig) 765{ 766 struct ACPIsdt *sdt; 767 vm_offset_t addr; 768 int entries, i; 769 770 entries = (rsdt->len - SIZEOF_SDT_HDR) / addr_size; 771 for (i = 0; i < entries; i++) { 772 switch (addr_size) { 773 case 4: 774 addr = le32dec((char*)rsdt->body + i * addr_size); 775 break; 776 case 8: 777 addr = le64dec((char*)rsdt->body + i * addr_size); 778 break; 779 default: 780 assert((addr = 0)); 781 } 782 sdt = (struct ACPIsdt *)acpi_map_sdt(addr); 783 if (memcmp(sdt->signature, sig, strlen(sig))) 784 continue; 785 if (acpi_checksum(sdt, sdt->len)) 786 errx(1, "RSDT entry %d is corrupt", i); 787 return (sdt); 788 } 789 790 return (NULL); 791} 792 793struct ACPIsdt * 794dsdt_from_fadt(struct FADTbody *fadt) 795{ 796 struct ACPIsdt *sdt; 797 798 /* Use the DSDT address if it is valid and version 1, else X_DSDT */ 799 if (addr_size == 4 || 800 (addr_size == 8 && fadt->dsdt_ptr != 0 && 801 (fadt->x_dsdt_ptr & 0xffffffff) != fadt->dsdt_ptr)) 802 sdt = (struct ACPIsdt *)acpi_map_sdt(fadt->dsdt_ptr); 803 else 804 sdt = (struct ACPIsdt *)acpi_map_sdt(fadt->x_dsdt_ptr); 805 if (acpi_checksum(sdt, sdt->len)) 806 errx(1, "DSDT is corrupt\n"); 807 return (sdt); 808} 809