diff --git a/usr.sbin/acpi/acpidump/acpi.c b/usr.sbin/acpi/acpidump/acpi.c index 6b1b2a9155d5..6241dfdd3f69 100644 --- a/usr.sbin/acpi/acpidump/acpi.c +++ b/usr.sbin/acpi/acpidump/acpi.c @@ -1,873 +1,897 @@ /*- * Copyright (c) 1998 Doug Rabson * Copyright (c) 2000 Mitsuru IWASAKI * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD$ */ #include #include #include #include #include #include #include #include #include #include #include "acpidump.h" #define BEGIN_COMMENT "/*\n" #define END_COMMENT " */\n" static void acpi_print_string(char *s, size_t length); static void acpi_print_gas(struct ACPIgas *gas); static int acpi_get_fadt_revision(struct FADTbody *fadt); static void acpi_handle_fadt(struct ACPIsdt *fadt); static void acpi_print_cpu(u_char cpu_id); static void acpi_print_local_apic(u_char cpu_id, u_char apic_id, u_int32_t flags); static void acpi_print_io_apic(u_char apic_id, u_int32_t int_base, u_int64_t apic_addr); static void acpi_print_mps_flags(u_int16_t flags); static void acpi_print_intr(u_int32_t intr, u_int16_t mps_flags); static void acpi_print_apic(struct MADT_APIC *mp); static void acpi_handle_apic(struct ACPIsdt *sdp); static void acpi_handle_hpet(struct ACPIsdt *sdp); static void acpi_print_sdt(struct ACPIsdt *sdp); static void acpi_print_fadt(struct ACPIsdt *sdp); static void acpi_print_facs(struct FACSbody *facs); static void acpi_print_dsdt(struct ACPIsdt *dsdp); static struct ACPIsdt *acpi_map_sdt(vm_offset_t pa); static void acpi_print_rsd_ptr(struct ACPIrsdp *rp); static void acpi_handle_rsdt(struct ACPIsdt *rsdp); /* Size of an address. 32-bit for ACPI 1.0, 64-bit for ACPI 2.0 and up. */ static int addr_size; static void acpi_print_string(char *s, size_t length) { int c; /* Trim trailing spaces and NULLs */ while (length > 0 && (s[length - 1] == ' ' || s[length - 1] == '\0')) length--; while (length--) { c = *s++; putchar(c); } } static void acpi_print_gas(struct ACPIgas *gas) { switch(gas->address_space_id) { case ACPI_GAS_MEMORY: printf("0x%08lx:%u[%u] (Memory)", (u_long)gas->address, gas->bit_offset, gas->bit_width); break; case ACPI_GAS_IO: printf("0x%02lx:%u[%u] (IO)", (u_long)gas->address, gas->bit_offset, gas->bit_width); break; case ACPI_GAS_PCI: printf("%x:%x+0x%x (PCI)", (uint16_t)(gas->address >> 32), (uint16_t)((gas->address >> 16) & 0xffff), (uint16_t)gas->address); break; /* XXX How to handle these below? */ case ACPI_GAS_EMBEDDED: printf("0x%x:%u[%u] (EC)", (uint16_t)gas->address, gas->bit_offset, gas->bit_width); break; case ACPI_GAS_SMBUS: printf("0x%x:%u[%u] (SMBus)", (uint16_t)gas->address, gas->bit_offset, gas->bit_width); break; case ACPI_GAS_FIXED: default: printf("0x%08lx (?)", (u_long)gas->address); break; } } /* The FADT revision indicates whether we use the DSDT or X_DSDT addresses. */ static int acpi_get_fadt_revision(struct FADTbody *fadt) { int fadt_revision; /* Set the FADT revision separately from the RSDP version. */ if (addr_size == 8) { fadt_revision = 2; /* * A few systems (e.g., IBM T23) have an RSDP that claims * revision 2 but the 64 bit addresses are invalid. If * revision 2 and the 32 bit address is non-zero but the * 32 and 64 bit versions don't match, prefer the 32 bit * version for all subsequent tables. */ if (fadt->facs_ptr != 0 && (fadt->x_facs_ptr & 0xffffffff) != fadt->facs_ptr) fadt_revision = 1; } else fadt_revision = 1; return (fadt_revision); } static void acpi_handle_fadt(struct ACPIsdt *sdp) { struct ACPIsdt *dsdp; struct FACSbody *facs; struct FADTbody *fadt; int fadt_revision; fadt = (struct FADTbody *)sdp->body; acpi_print_fadt(sdp); fadt_revision = acpi_get_fadt_revision(fadt); if (fadt_revision == 1) facs = (struct FACSbody *)acpi_map_sdt(fadt->facs_ptr); else facs = (struct FACSbody *)acpi_map_sdt(fadt->x_facs_ptr); if (memcmp(facs->signature, "FACS", 4) != 0 || facs->len < 64) errx(1, "FACS is corrupt"); acpi_print_facs(facs); if (fadt_revision == 1) dsdp = (struct ACPIsdt *)acpi_map_sdt(fadt->dsdt_ptr); else dsdp = (struct ACPIsdt *)acpi_map_sdt(fadt->x_dsdt_ptr); if (acpi_checksum(dsdp, dsdp->len)) errx(1, "DSDT is corrupt"); acpi_print_dsdt(dsdp); } static void acpi_print_cpu(u_char cpu_id) { printf("\tACPI CPU="); if (cpu_id == 0xff) printf("ALL\n"); else printf("%d\n", (u_int)cpu_id); } static void acpi_print_local_apic(u_char cpu_id, u_char apic_id, u_int32_t flags) { acpi_print_cpu(cpu_id); printf("\tFlags={"); if (flags & ACPI_MADT_APIC_LOCAL_FLAG_ENABLED) printf("ENABLED"); else printf("DISABLED"); printf("}\n"); printf("\tAPIC ID=%d\n", (u_int)apic_id); } static void acpi_print_io_apic(u_char apic_id, u_int32_t int_base, u_int64_t apic_addr) { printf("\tAPIC ID=%d\n", (u_int)apic_id); printf("\tINT BASE=%d\n", int_base); printf("\tADDR=0x%016jx\n", apic_addr); } static void acpi_print_mps_flags(u_int16_t flags) { printf("\tFlags={Polarity="); switch (flags & MPS_INT_FLAG_POLARITY_MASK) { case MPS_INT_FLAG_POLARITY_CONFORM: printf("conforming"); break; case MPS_INT_FLAG_POLARITY_HIGH: printf("active-hi"); break; case MPS_INT_FLAG_POLARITY_LOW: printf("active-lo"); break; default: printf("0x%x", flags & MPS_INT_FLAG_POLARITY_MASK); break; } printf(", Trigger="); switch (flags & MPS_INT_FLAG_TRIGGER_MASK) { case MPS_INT_FLAG_TRIGGER_CONFORM: printf("conforming"); break; case MPS_INT_FLAG_TRIGGER_EDGE: printf("edge"); break; case MPS_INT_FLAG_TRIGGER_LEVEL: printf("level"); break; default: printf("0x%x", (flags & MPS_INT_FLAG_TRIGGER_MASK) >> 2); } printf("}\n"); } static void acpi_print_intr(u_int32_t intr, u_int16_t mps_flags) { printf("\tINTR=%d\n", (u_int)intr); acpi_print_mps_flags(mps_flags); } const char *apic_types[] = { "Local APIC", "IO APIC", "INT Override", "NMI", "Local NMI", "Local APIC Override", "IO SAPIC", "Local SAPIC", "Platform Interrupt" }; const char *platform_int_types[] = { "PMI", "INIT", "Corrected Platform Error" }; static void acpi_print_apic(struct MADT_APIC *mp) { printf("\tType=%s\n", apic_types[mp->type]); switch (mp->type) { case ACPI_MADT_APIC_TYPE_LOCAL_APIC: acpi_print_local_apic(mp->body.local_apic.cpu_id, mp->body.local_apic.apic_id, mp->body.local_apic.flags); break; case ACPI_MADT_APIC_TYPE_IO_APIC: acpi_print_io_apic(mp->body.io_apic.apic_id, mp->body.io_apic.int_base, mp->body.io_apic.apic_addr); break; case ACPI_MADT_APIC_TYPE_INT_OVERRIDE: printf("\tBUS=%d\n", (u_int)mp->body.int_override.bus); printf("\tIRQ=%d\n", (u_int)mp->body.int_override.source); acpi_print_intr(mp->body.int_override.intr, mp->body.int_override.mps_flags); break; case ACPI_MADT_APIC_TYPE_NMI: acpi_print_intr(mp->body.nmi.intr, mp->body.nmi.mps_flags); break; case ACPI_MADT_APIC_TYPE_LOCAL_NMI: acpi_print_cpu(mp->body.local_nmi.cpu_id); printf("\tLINT Pin=%d\n", mp->body.local_nmi.lintpin); acpi_print_mps_flags(mp->body.local_nmi.mps_flags); break; case ACPI_MADT_APIC_TYPE_LOCAL_OVERRIDE: printf("\tLocal APIC ADDR=0x%016jx\n", mp->body.local_apic_override.apic_addr); break; case ACPI_MADT_APIC_TYPE_IO_SAPIC: acpi_print_io_apic(mp->body.io_sapic.apic_id, mp->body.io_sapic.int_base, mp->body.io_sapic.apic_addr); break; case ACPI_MADT_APIC_TYPE_LOCAL_SAPIC: acpi_print_local_apic(mp->body.local_sapic.cpu_id, mp->body.local_sapic.apic_id, mp->body.local_sapic.flags); printf("\tAPIC EID=%d\n", (u_int)mp->body.local_sapic.apic_eid); break; case ACPI_MADT_APIC_TYPE_INT_SRC: printf("\tType=%s\n", platform_int_types[mp->body.int_src.type]); printf("\tCPU ID=%d\n", (u_int)mp->body.int_src.cpu_id); printf("\tCPU EID=%d\n", (u_int)mp->body.int_src.cpu_id); printf("\tSAPIC Vector=%d\n", (u_int)mp->body.int_src.sapic_vector); acpi_print_intr(mp->body.int_src.intr, mp->body.int_src.mps_flags); break; default: printf("\tUnknown type %d\n", (u_int)mp->type); break; } } static void acpi_handle_apic(struct ACPIsdt *sdp) { struct MADTbody *madtp; struct MADT_APIC *madt_apicp; printf(BEGIN_COMMENT); acpi_print_sdt(sdp); madtp = (struct MADTbody *) sdp->body; printf("\tLocal APIC ADDR=0x%08x\n", madtp->lapic_addr); printf("\tFlags={"); if (madtp->flags & ACPI_APIC_FLAG_PCAT_COMPAT) printf("PC-AT"); printf("}\n"); madt_apicp = (struct MADT_APIC *)madtp->body; while (((uintptr_t)madt_apicp) - ((uintptr_t)sdp) < sdp->len) { printf("\n"); acpi_print_apic(madt_apicp); madt_apicp = (struct MADT_APIC *) ((char *)madt_apicp + madt_apicp->len); } printf(END_COMMENT); } static void acpi_handle_hpet(struct ACPIsdt *sdp) { struct HPETbody *hpetp; printf(BEGIN_COMMENT); acpi_print_sdt(sdp); hpetp = (struct HPETbody *) sdp->body; printf("\tHPET Number=%d\n", hpetp->hpet_number); printf("\tADDR=0x%08x\n", hpetp->base_addr); printf("\tHW Rev=0x%x\n", hpetp->block_hwrev); printf("\tComparitors=%d\n", hpetp->block_comparitors); printf("\tCounter Size=%d\n", hpetp->block_counter_size); printf("\tLegacy IRQ routing capable={"); if (hpetp->block_legacy_capable) printf("TRUE}\n"); else printf("FALSE}\n"); printf("\tPCI Vendor ID=0x%04x\n", hpetp->block_pcivendor); printf("\tMinimal Tick=%d\n", hpetp->clock_tick); printf(END_COMMENT); } static void acpi_handle_ecdt(struct ACPIsdt *sdp) { struct ECDTbody *ecdt; printf(BEGIN_COMMENT); acpi_print_sdt(sdp); ecdt = (struct ECDTbody *) sdp->body; printf("\tEC_CONTROL="); acpi_print_gas(&ecdt->ec_control); printf("\n\tEC_DATA="); acpi_print_gas(&ecdt->ec_data); printf("\n\tUID=%#x, ", ecdt->uid); printf("GPE_BIT=%#x\n", ecdt->gpe_bit); printf("\tEC_ID=%s\n", ecdt->ec_id); printf(END_COMMENT); } +static void +acpi_handle_mcfg(struct ACPIsdt *sdp) +{ + struct MCFGbody *mcfg; + u_int i, e; + + printf(BEGIN_COMMENT); + acpi_print_sdt(sdp); + mcfg = (struct MCFGbody *) sdp->body; + + e = (sdp->len - ((caddr_t)&mcfg->s[0] - (caddr_t)sdp)) / + sizeof(*mcfg->s); + for (i = 0; i < e; i++, mcfg++) { + printf("\n"); + printf("\tBase Address= 0x%016jx\n", mcfg->s[i].baseaddr); + printf("\tSegment Group= 0x%04x\n", mcfg->s[i].seg_grp); + printf("\tStart Bus= %d\n", mcfg->s[i].start); + printf("\tEnd Bus= %d\n", mcfg->s[i].end); + } + printf(END_COMMENT); +} + static void acpi_print_sdt(struct ACPIsdt *sdp) { printf(" "); acpi_print_string(sdp->signature, 4); printf(": Length=%d, Revision=%d, Checksum=%d,\n", sdp->len, sdp->rev, sdp->check); printf("\tOEMID="); acpi_print_string(sdp->oemid, 6); printf(", OEM Table ID="); acpi_print_string(sdp->oemtblid, 8); printf(", OEM Revision=0x%x,\n", sdp->oemrev); printf("\tCreator ID="); acpi_print_string(sdp->creator, 4); printf(", Creator Revision=0x%x\n", sdp->crerev); } static void acpi_print_rsdt(struct ACPIsdt *rsdp) { int i, entries; u_long addr; printf(BEGIN_COMMENT); acpi_print_sdt(rsdp); entries = (rsdp->len - SIZEOF_SDT_HDR) / addr_size; printf("\tEntries={ "); for (i = 0; i < entries; i++) { if (i > 0) printf(", "); switch (addr_size) { case 4: addr = le32dec((char*)rsdp->body + i * addr_size); break; case 8: addr = le64dec((char*)rsdp->body + i * addr_size); break; default: addr = 0; } assert(addr != 0); printf("0x%08lx", addr); } printf(" }\n"); printf(END_COMMENT); } static const char *acpi_pm_profiles[] = { "Unspecified", "Desktop", "Mobile", "Workstation", "Enterprise Server", "SOHO Server", "Appliance PC" }; static void acpi_print_fadt(struct ACPIsdt *sdp) { struct FADTbody *fadt; const char *pm; char sep; fadt = (struct FADTbody *)sdp->body; printf(BEGIN_COMMENT); acpi_print_sdt(sdp); printf(" \tFACS=0x%x, DSDT=0x%x\n", fadt->facs_ptr, fadt->dsdt_ptr); printf("\tINT_MODEL=%s\n", fadt->int_model ? "APIC" : "PIC"); if (fadt->pm_profile >= sizeof(acpi_pm_profiles) / sizeof(char *)) pm = "Reserved"; else pm = acpi_pm_profiles[fadt->pm_profile]; printf("\tPreferred_PM_Profile=%s (%d)\n", pm, fadt->pm_profile); printf("\tSCI_INT=%d\n", fadt->sci_int); printf("\tSMI_CMD=0x%x, ", fadt->smi_cmd); printf("ACPI_ENABLE=0x%x, ", fadt->acpi_enable); printf("ACPI_DISABLE=0x%x, ", fadt->acpi_disable); printf("S4BIOS_REQ=0x%x\n", fadt->s4biosreq); printf("\tPSTATE_CNT=0x%x\n", fadt->pstate_cnt); printf("\tPM1a_EVT_BLK=0x%x-0x%x\n", fadt->pm1a_evt_blk, fadt->pm1a_evt_blk + fadt->pm1_evt_len - 1); if (fadt->pm1b_evt_blk != 0) printf("\tPM1b_EVT_BLK=0x%x-0x%x\n", fadt->pm1b_evt_blk, fadt->pm1b_evt_blk + fadt->pm1_evt_len - 1); printf("\tPM1a_CNT_BLK=0x%x-0x%x\n", fadt->pm1a_cnt_blk, fadt->pm1a_cnt_blk + fadt->pm1_cnt_len - 1); if (fadt->pm1b_cnt_blk != 0) printf("\tPM1b_CNT_BLK=0x%x-0x%x\n", fadt->pm1b_cnt_blk, fadt->pm1b_cnt_blk + fadt->pm1_cnt_len - 1); if (fadt->pm2_cnt_blk != 0) printf("\tPM2_CNT_BLK=0x%x-0x%x\n", fadt->pm2_cnt_blk, fadt->pm2_cnt_blk + fadt->pm2_cnt_len - 1); printf("\tPM_TMR_BLK=0x%x-0x%x\n", fadt->pm_tmr_blk, fadt->pm_tmr_blk + fadt->pm_tmr_len - 1); if (fadt->gpe0_blk != 0) printf("\tGPE0_BLK=0x%x-0x%x\n", fadt->gpe0_blk, fadt->gpe0_blk + fadt->gpe0_len - 1); if (fadt->gpe1_blk != 0) printf("\tGPE1_BLK=0x%x-0x%x, GPE1_BASE=%d\n", fadt->gpe1_blk, fadt->gpe1_blk + fadt->gpe1_len - 1, fadt->gpe1_base); if (fadt->cst_cnt != 0) printf("\tCST_CNT=0x%x\n", fadt->cst_cnt); printf("\tP_LVL2_LAT=%d us, P_LVL3_LAT=%d us\n", fadt->p_lvl2_lat, fadt->p_lvl3_lat); printf("\tFLUSH_SIZE=%d, FLUSH_STRIDE=%d\n", fadt->flush_size, fadt->flush_stride); printf("\tDUTY_OFFSET=%d, DUTY_WIDTH=%d\n", fadt->duty_off, fadt->duty_width); printf("\tDAY_ALRM=%d, MON_ALRM=%d, CENTURY=%d\n", fadt->day_alrm, fadt->mon_alrm, fadt->century); #define PRINTFLAG(var, flag) do { \ if ((var) & FADT_FLAG_## flag) { \ printf("%c%s", sep, #flag); sep = ','; \ } \ } while (0) printf("\tIAPC_BOOT_ARCH="); sep = '{'; PRINTFLAG(fadt->iapc_boot_arch, LEGACY_DEV); PRINTFLAG(fadt->iapc_boot_arch, 8042); if (fadt->iapc_boot_arch != 0) printf("}"); printf("\n"); printf("\tFlags="); sep = '{'; PRINTFLAG(fadt->flags, WBINVD); PRINTFLAG(fadt->flags, WBINVD_FLUSH); PRINTFLAG(fadt->flags, PROC_C1); PRINTFLAG(fadt->flags, P_LVL2_UP); PRINTFLAG(fadt->flags, PWR_BUTTON); PRINTFLAG(fadt->flags, SLP_BUTTON); PRINTFLAG(fadt->flags, FIX_RTC); PRINTFLAG(fadt->flags, RTC_S4); PRINTFLAG(fadt->flags, TMR_VAL_EXT); PRINTFLAG(fadt->flags, DCK_CAP); PRINTFLAG(fadt->flags, RESET_REG); PRINTFLAG(fadt->flags, SEALED_CASE); PRINTFLAG(fadt->flags, HEADLESS); PRINTFLAG(fadt->flags, CPU_SW_SLP); if (fadt->flags != 0) printf("}\n"); #undef PRINTFLAG if (fadt->flags & FADT_FLAG_RESET_REG) { printf("\tRESET_REG="); acpi_print_gas(&fadt->reset_reg); printf(", RESET_VALUE=%#x\n", fadt->reset_value); } if (acpi_get_fadt_revision(fadt) > 1) { printf("\tX_FACS=0x%08lx, ", (u_long)fadt->x_facs_ptr); printf("X_DSDT=0x%08lx\n", (u_long)fadt->x_dsdt_ptr); printf("\tX_PM1a_EVT_BLK="); acpi_print_gas(&fadt->x_pm1a_evt_blk); if (fadt->x_pm1b_evt_blk.address != 0) { printf("\n\tX_PM1b_EVT_BLK="); acpi_print_gas(&fadt->x_pm1b_evt_blk); } printf("\n\tX_PM1a_CNT_BLK="); acpi_print_gas(&fadt->x_pm1a_cnt_blk); if (fadt->x_pm1b_cnt_blk.address != 0) { printf("\n\tX_PM1b_CNT_BLK="); acpi_print_gas(&fadt->x_pm1b_cnt_blk); } if (fadt->x_pm1b_cnt_blk.address != 0) { printf("\n\tX_PM2_CNT_BLK="); acpi_print_gas(&fadt->x_pm2_cnt_blk); } printf("\n\tX_PM_TMR_BLK="); acpi_print_gas(&fadt->x_pm_tmr_blk); if (fadt->x_gpe0_blk.address != 0) { printf("\n\tX_GPE0_BLK="); acpi_print_gas(&fadt->x_gpe0_blk); } if (fadt->x_gpe1_blk.address != 0) { printf("\n\tX_GPE1_BLK="); acpi_print_gas(&fadt->x_gpe1_blk); } printf("\n"); } printf(END_COMMENT); } static void acpi_print_facs(struct FACSbody *facs) { printf(BEGIN_COMMENT); printf(" FACS:\tLength=%u, ", facs->len); printf("HwSig=0x%08x, ", facs->hw_sig); printf("Firm_Wake_Vec=0x%08x\n", facs->firm_wake_vec); printf("\tGlobal_Lock="); if (facs->global_lock != 0) { if (facs->global_lock & FACS_FLAG_LOCK_PENDING) printf("PENDING,"); if (facs->global_lock & FACS_FLAG_LOCK_OWNED) printf("OWNED"); } printf("\n"); printf("\tFlags="); if (facs->flags & FACS_FLAG_S4BIOS_F) printf("S4BIOS"); printf("\n"); if (facs->x_firm_wake_vec != 0) { printf("\tX_Firm_Wake_Vec=%08lx\n", (u_long)facs->x_firm_wake_vec); } printf("\tVersion=%u\n", facs->version); printf(END_COMMENT); } static void acpi_print_dsdt(struct ACPIsdt *dsdp) { printf(BEGIN_COMMENT); acpi_print_sdt(dsdp); printf(END_COMMENT); } int acpi_checksum(void *p, size_t length) { u_int8_t *bp; u_int8_t sum; bp = p; sum = 0; while (length--) sum += *bp++; return (sum); } static struct ACPIsdt * acpi_map_sdt(vm_offset_t pa) { struct ACPIsdt *sp; sp = acpi_map_physical(pa, sizeof(struct ACPIsdt)); sp = acpi_map_physical(pa, sp->len); return (sp); } static void acpi_print_rsd_ptr(struct ACPIrsdp *rp) { printf(BEGIN_COMMENT); printf(" RSD PTR: OEM="); acpi_print_string(rp->oem, 6); printf(", ACPI_Rev=%s (%d)\n", rp->revision < 2 ? "1.0x" : "2.0x", rp->revision); if (rp->revision < 2) { printf("\tRSDT=0x%08x, cksum=%u\n", rp->rsdt_addr, rp->sum); } else { printf("\tXSDT=0x%08lx, length=%u, cksum=%u\n", (u_long)rp->xsdt_addr, rp->length, rp->xsum); } printf(END_COMMENT); } static void acpi_handle_rsdt(struct ACPIsdt *rsdp) { struct ACPIsdt *sdp; vm_offset_t addr; int entries, i; acpi_print_rsdt(rsdp); entries = (rsdp->len - SIZEOF_SDT_HDR) / addr_size; for (i = 0; i < entries; i++) { switch (addr_size) { case 4: addr = le32dec((char*)rsdp->body + i * addr_size); break; case 8: addr = le64dec((char*)rsdp->body + i * addr_size); break; default: assert((addr = 0)); } sdp = (struct ACPIsdt *)acpi_map_sdt(addr); if (acpi_checksum(sdp, sdp->len)) { warnx("RSDT entry %d (sig %.4s) is corrupt", i, sdp->signature); continue; } if (!memcmp(sdp->signature, "FACP", 4)) acpi_handle_fadt(sdp); else if (!memcmp(sdp->signature, "APIC", 4)) acpi_handle_apic(sdp); else if (!memcmp(sdp->signature, "HPET", 4)) acpi_handle_hpet(sdp); else if (!memcmp(sdp->signature, "ECDT", 4)) acpi_handle_ecdt(sdp); + else if (!memcmp(sdp->signature, "MCFG", 4)) + acpi_handle_mcfg(sdp); else { printf(BEGIN_COMMENT); acpi_print_sdt(sdp); printf(END_COMMENT); } } } struct ACPIsdt * sdt_load_devmem(void) { struct ACPIrsdp *rp; struct ACPIsdt *rsdp; rp = acpi_find_rsd_ptr(); if (!rp) errx(1, "Can't find ACPI information"); if (tflag) acpi_print_rsd_ptr(rp); if (rp->revision < 2) { rsdp = (struct ACPIsdt *)acpi_map_sdt(rp->rsdt_addr); if (memcmp(rsdp->signature, "RSDT", 4) != 0 || acpi_checksum(rsdp, rsdp->len) != 0) errx(1, "RSDT is corrupted"); addr_size = sizeof(uint32_t); } else { rsdp = (struct ACPIsdt *)acpi_map_sdt(rp->xsdt_addr); if (memcmp(rsdp->signature, "XSDT", 4) != 0 || acpi_checksum(rsdp, rsdp->len) != 0) errx(1, "XSDT is corrupted"); addr_size = sizeof(uint64_t); } return (rsdp); } /* Write the DSDT to a file, concatenating any SSDTs (if present). */ static int write_dsdt(int fd, struct ACPIsdt *rsdt, struct ACPIsdt *dsdt) { struct ACPIsdt sdt; struct ACPIsdt *ssdt; uint8_t sum; /* Create a new checksum to account for the DSDT and any SSDTs. */ sdt = *dsdt; if (rsdt != NULL) { sdt.check = 0; sum = acpi_checksum(dsdt->body, dsdt->len - SIZEOF_SDT_HDR); ssdt = sdt_from_rsdt(rsdt, "SSDT", NULL); while (ssdt != NULL) { sdt.len += ssdt->len - SIZEOF_SDT_HDR; sum += acpi_checksum(ssdt->body, ssdt->len - SIZEOF_SDT_HDR); ssdt = sdt_from_rsdt(rsdt, "SSDT", ssdt); } sum += acpi_checksum(&sdt, SIZEOF_SDT_HDR); sdt.check -= sum; } /* Write out the DSDT header and body. */ write(fd, &sdt, SIZEOF_SDT_HDR); write(fd, dsdt->body, dsdt->len - SIZEOF_SDT_HDR); /* Write out any SSDTs (if present.) */ if (rsdt != NULL) { ssdt = sdt_from_rsdt(rsdt, "SSDT", NULL); while (ssdt != NULL) { write(fd, ssdt->body, ssdt->len - SIZEOF_SDT_HDR); ssdt = sdt_from_rsdt(rsdt, "SSDT", ssdt); } } return (0); } void dsdt_save_file(char *outfile, struct ACPIsdt *rsdt, struct ACPIsdt *dsdp) { int fd; mode_t mode; assert(outfile != NULL); mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH; fd = open(outfile, O_WRONLY | O_CREAT | O_TRUNC, mode); if (fd == -1) { perror("dsdt_save_file"); return; } write_dsdt(fd, rsdt, dsdp); close(fd); } void aml_disassemble(struct ACPIsdt *rsdt, struct ACPIsdt *dsdp) { char tmpstr[32], buf[256]; FILE *fp; int fd, len; strcpy(tmpstr, "/tmp/acpidump.XXXXXX"); fd = mkstemp(tmpstr); if (fd < 0) { perror("iasl tmp file"); return; } write_dsdt(fd, rsdt, dsdp); close(fd); /* Run iasl -d on the temp file */ if (fork() == 0) { close(STDOUT_FILENO); if (vflag == 0) close(STDERR_FILENO); execl("/usr/sbin/iasl", "iasl", "-d", tmpstr, 0); err(1, "exec"); } wait(NULL); unlink(tmpstr); /* Dump iasl's output to stdout */ fp = fopen("acpidump.dsl", "r"); unlink("acpidump.dsl"); if (fp == NULL) { perror("iasl tmp file (read)"); return; } while ((len = fread(buf, 1, sizeof(buf), fp)) > 0) fwrite(buf, 1, len, stdout); fclose(fp); } void sdt_print_all(struct ACPIsdt *rsdp) { acpi_handle_rsdt(rsdp); } /* Fetch a table matching the given signature via the RSDT. */ struct ACPIsdt * sdt_from_rsdt(struct ACPIsdt *rsdt, const char *sig, struct ACPIsdt *last) { struct ACPIsdt *sdt; vm_offset_t addr; int entries, i; entries = (rsdt->len - SIZEOF_SDT_HDR) / addr_size; for (i = 0; i < entries; i++) { switch (addr_size) { case 4: addr = le32dec((char*)rsdt->body + i * addr_size); break; case 8: addr = le64dec((char*)rsdt->body + i * addr_size); break; default: assert((addr = 0)); } sdt = (struct ACPIsdt *)acpi_map_sdt(addr); if (last != NULL) { if (sdt == last) last = NULL; continue; } if (memcmp(sdt->signature, sig, strlen(sig))) continue; if (acpi_checksum(sdt, sdt->len)) errx(1, "RSDT entry %d is corrupt", i); return (sdt); } return (NULL); } struct ACPIsdt * dsdt_from_fadt(struct FADTbody *fadt) { struct ACPIsdt *sdt; /* Use the DSDT address if it is version 1, otherwise use X_DSDT. */ if (acpi_get_fadt_revision(fadt) == 1) sdt = (struct ACPIsdt *)acpi_map_sdt(fadt->dsdt_ptr); else sdt = (struct ACPIsdt *)acpi_map_sdt(fadt->x_dsdt_ptr); if (acpi_checksum(sdt, sdt->len)) errx(1, "DSDT is corrupt\n"); return (sdt); } diff --git a/usr.sbin/acpi/acpidump/acpidump.h b/usr.sbin/acpi/acpidump/acpidump.h index ca56398af2a9..0b7712aea276 100644 --- a/usr.sbin/acpi/acpidump/acpidump.h +++ b/usr.sbin/acpi/acpidump/acpidump.h @@ -1,338 +1,350 @@ /*- * Copyright (c) 1999 Doug Rabson * Copyright (c) 2000 Mitsuru IWASAKI * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD$ */ #ifndef _ACPIDUMP_H_ #define _ACPIDUMP_H_ /* Generic Address structure */ struct ACPIgas { u_int8_t address_space_id; #define ACPI_GAS_MEMORY 0 #define ACPI_GAS_IO 1 #define ACPI_GAS_PCI 2 #define ACPI_GAS_EMBEDDED 3 #define ACPI_GAS_SMBUS 4 #define ACPI_GAS_FIXED 0x7f u_int8_t bit_width; u_int8_t bit_offset; u_int8_t _reserved; u_int64_t address; } __packed; /* Root System Description Pointer */ struct ACPIrsdp { u_char signature[8]; u_char sum; u_char oem[6]; u_char revision; u_int32_t rsdt_addr; u_int32_t length; u_int64_t xsdt_addr; u_char xsum; u_char _reserved_[3]; } __packed; /* System Description Table */ struct ACPIsdt { u_char signature[4]; u_int32_t len; u_char rev; u_char check; u_char oemid[6]; u_char oemtblid[8]; u_int32_t oemrev; u_char creator[4]; u_int32_t crerev; #define SIZEOF_SDT_HDR 36 /* struct size except body */ u_int32_t body[1];/* This member should be casted */ } __packed; /* Fixed ACPI Description Table (body) */ struct FADTbody { u_int32_t facs_ptr; u_int32_t dsdt_ptr; u_int8_t int_model; #define ACPI_FADT_INTMODEL_PIC 0 /* Standard PC-AT PIC */ #define ACPI_FADT_INTMODEL_APIC 1 /* Multiple APIC */ u_int8_t pm_profile; u_int16_t sci_int; u_int32_t smi_cmd; u_int8_t acpi_enable; u_int8_t acpi_disable; u_int8_t s4biosreq; u_int8_t pstate_cnt; u_int32_t pm1a_evt_blk; u_int32_t pm1b_evt_blk; u_int32_t pm1a_cnt_blk; u_int32_t pm1b_cnt_blk; u_int32_t pm2_cnt_blk; u_int32_t pm_tmr_blk; u_int32_t gpe0_blk; u_int32_t gpe1_blk; u_int8_t pm1_evt_len; u_int8_t pm1_cnt_len; u_int8_t pm2_cnt_len; u_int8_t pm_tmr_len; u_int8_t gpe0_len; u_int8_t gpe1_len; u_int8_t gpe1_base; u_int8_t cst_cnt; u_int16_t p_lvl2_lat; u_int16_t p_lvl3_lat; u_int16_t flush_size; u_int16_t flush_stride; u_int8_t duty_off; u_int8_t duty_width; u_int8_t day_alrm; u_int8_t mon_alrm; u_int8_t century; u_int16_t iapc_boot_arch; #define FADT_FLAG_LEGACY_DEV 1 /* System has legacy devices */ #define FADT_FLAG_8042 2 /* 8042 keyboard controller */ u_char reserved4[1]; u_int32_t flags; #define FADT_FLAG_WBINVD 1 /* WBINVD is correctly supported */ #define FADT_FLAG_WBINVD_FLUSH 2 /* WBINVD flushes caches */ #define FADT_FLAG_PROC_C1 4 /* C1 power state supported */ #define FADT_FLAG_P_LVL2_UP 8 /* C2 power state works on SMP */ #define FADT_FLAG_PWR_BUTTON 16 /* Power button uses control method */ #define FADT_FLAG_SLP_BUTTON 32 /* Sleep button uses control method */ #define FADT_FLAG_FIX_RTC 64 /* RTC wakeup not supported */ #define FADT_FLAG_RTC_S4 128 /* RTC can wakeup from S4 state */ #define FADT_FLAG_TMR_VAL_EXT 256 /* TMR_VAL is 32bit */ #define FADT_FLAG_DCK_CAP 512 /* Can support docking */ #define FADT_FLAG_RESET_REG 1024 /* Supports RESET_REG */ #define FADT_FLAG_SEALED_CASE 2048 /* Case cannot be opened */ #define FADT_FLAG_HEADLESS 4096 /* No monitor */ #define FADT_FLAG_CPU_SW_SLP 8192 /* Supports CPU software sleep */ struct ACPIgas reset_reg; u_int8_t reset_value; u_int8_t reserved5[3]; u_int64_t x_facs_ptr; u_int64_t x_dsdt_ptr; struct ACPIgas x_pm1a_evt_blk; struct ACPIgas x_pm1b_evt_blk; struct ACPIgas x_pm1a_cnt_blk; struct ACPIgas x_pm1b_cnt_blk; struct ACPIgas x_pm2_cnt_blk; struct ACPIgas x_pm_tmr_blk; struct ACPIgas x_gpe0_blk; struct ACPIgas x_gpe1_blk; } __packed; /* Firmware ACPI Control Structure */ struct FACSbody { u_char signature[4]; u_int32_t len; u_int32_t hw_sig; /* * NOTE This should be filled with physical address below 1MB!! * sigh.... */ u_int32_t firm_wake_vec; u_int32_t global_lock; #define FACS_FLAG_LOCK_PENDING 1 /* 5.2.6.1 Global Lock */ #define FACS_FLAG_LOCK_OWNED 2 u_int32_t flags; #define FACS_FLAG_S4BIOS_F 1 /* Supports S4BIOS_SEQ */ u_int64_t x_firm_wake_vec; u_int8_t version; char reserved[31]; } __packed; struct MADT_local_apic { u_char cpu_id; u_char apic_id; u_int32_t flags; #define ACPI_MADT_APIC_LOCAL_FLAG_ENABLED 1 } __packed; struct MADT_io_apic { u_char apic_id; u_char reserved; u_int32_t apic_addr; u_int32_t int_base; } __packed; struct MADT_int_override { u_char bus; u_char source; u_int32_t intr; u_int16_t mps_flags; #define MPS_INT_FLAG_POLARITY_MASK 0x3 #define MPS_INT_FLAG_POLARITY_CONFORM 0x0 #define MPS_INT_FLAG_POLARITY_HIGH 0x1 #define MPS_INT_FLAG_POLARITY_LOW 0x3 #define MPS_INT_FLAG_TRIGGER_MASK 0xc #define MPS_INT_FLAG_TRIGGER_CONFORM 0x0 #define MPS_INT_FLAG_TRIGGER_EDGE 0x4 #define MPS_INT_FLAG_TRIGGER_LEVEL 0xc } __packed; struct MADT_nmi { u_int16_t mps_flags; u_int32_t intr; } __packed; struct MADT_local_nmi { u_char cpu_id; u_int16_t mps_flags; u_char lintpin; } __packed; struct MADT_local_apic_override { u_char reserved[2]; u_int64_t apic_addr; } __packed; struct MADT_io_sapic { u_char apic_id; u_char reserved; u_int32_t int_base; u_int64_t apic_addr; } __packed; struct MADT_local_sapic { u_char cpu_id; u_char apic_id; u_char apic_eid; u_char reserved[3]; u_int32_t flags; } __packed; struct MADT_int_src { u_int16_t mps_flags; u_char type; #define ACPI_MADT_APIC_INT_SOURCE_PMI 1 #define ACPI_MADT_APIC_INT_SOURCE_INIT 2 #define ACPI_MADT_APIC_INT_SOURCE_CPEI 3 /* Corrected Platform Error */ u_char cpu_id; u_char cpu_eid; u_char sapic_vector; u_int32_t intr; u_char reserved[4]; } __packed; struct MADT_APIC { u_char type; #define ACPI_MADT_APIC_TYPE_LOCAL_APIC 0 #define ACPI_MADT_APIC_TYPE_IO_APIC 1 #define ACPI_MADT_APIC_TYPE_INT_OVERRIDE 2 #define ACPI_MADT_APIC_TYPE_NMI 3 #define ACPI_MADT_APIC_TYPE_LOCAL_NMI 4 #define ACPI_MADT_APIC_TYPE_LOCAL_OVERRIDE 5 #define ACPI_MADT_APIC_TYPE_IO_SAPIC 6 #define ACPI_MADT_APIC_TYPE_LOCAL_SAPIC 7 #define ACPI_MADT_APIC_TYPE_INT_SRC 8 u_char len; union { struct MADT_local_apic local_apic; struct MADT_io_apic io_apic; struct MADT_int_override int_override; struct MADT_nmi nmi; struct MADT_local_nmi local_nmi; struct MADT_local_apic_override local_apic_override; struct MADT_io_sapic io_sapic; struct MADT_local_sapic local_sapic; struct MADT_int_src int_src; } body; } __packed; struct MADTbody { u_int32_t lapic_addr; u_int32_t flags; #define ACPI_APIC_FLAG_PCAT_COMPAT 1 /* System has dual-8259 setup. */ u_char body[1]; } __packed; struct HPETbody { u_int32_t block_hwrev:8, block_comparitors:5, block_counter_size:1, :1, block_legacy_capable:1, block_pcivendor:16; u_int32_t base_addr; u_int64_t reserved1; u_int8_t hpet_number; u_int16_t clock_tick __packed; } __packed; /* Embedded Controller Description Table */ struct ECDTbody { struct ACPIgas ec_control; /* Control register */ struct ACPIgas ec_data; /* Data register */ uint32_t uid; /* Same value as _UID in namespace */ uint8_t gpe_bit; /* GPE bit for the EC */ u_char ec_id[1]; /* Variable length name string */ } __packed; +/* Memory Mapped PCI config space base allocation structure */ +struct MCFGbody { + uint8_t rsvd[8]; + struct { + uint64_t baseaddr; /* Base Address */ + uint16_t seg_grp; /* Segment group number */ + uint8_t start; /* Starting bus number */ + uint8_t end; /* Ending bus number */ + uint8_t rsvd[4]; /* Reserved */ + } s[]; +} __packed; + /* * Addresses to scan on ia32 for the RSD PTR. According to section 5.2.2 * of the ACPI spec, we only consider two regions for the base address: * 1. EBDA (1 KB area addressed to by 16 bit pointer at 0x40E) * 2. High memory (0xE0000 - 0xFFFFF) */ #define RSDP_EBDA_PTR 0x40E #define RSDP_EBDA_SIZE 0x400 #define RSDP_HI_START 0xE0000 #define RSDP_HI_SIZE 0x20000 /* Find and map the RSD PTR structure and return it for parsing */ struct ACPIsdt *sdt_load_devmem(void); /* * Load the DSDT from a previous save file. Note that other tables are * not saved (i.e. FADT) */ struct ACPIsdt *dsdt_load_file(char *); /* Save the DSDT to a file */ void dsdt_save_file(char *, struct ACPIsdt *, struct ACPIsdt *); /* Print out as many fixed tables as possible, given the RSD PTR */ void sdt_print_all(struct ACPIsdt *); /* Disassemble the AML in the DSDT */ void aml_disassemble(struct ACPIsdt *, struct ACPIsdt *); /* Routines for accessing tables in physical memory */ struct ACPIrsdp *acpi_find_rsd_ptr(void); void *acpi_map_physical(vm_offset_t, size_t); struct ACPIsdt *sdt_from_rsdt(struct ACPIsdt *, const char *, struct ACPIsdt *); struct ACPIsdt *dsdt_from_fadt(struct FADTbody *); int acpi_checksum(void *, size_t); /* Command line flags */ extern int dflag; extern int tflag; extern int vflag; #endif /* !_ACPIDUMP_H_ */