From e1e9a4bf77df02678428853e90647d58934683e1 Mon Sep 17 00:00:00 2001 From: Mitsuru IWASAKI Date: Thu, 31 Aug 2000 14:42:32 +0000 Subject: [PATCH] import acpidump(8) from ACPI For FreeBSD project. Obtained from: ACPI For FreeBSD project --- usr.sbin/acpi/acpidump/Makefile | 10 + usr.sbin/acpi/acpidump/acpi.c | 258 ++++++ usr.sbin/acpi/acpidump/acpi_user.c | 165 ++++ usr.sbin/acpi/acpidump/acpidump.c | 103 +++ usr.sbin/acpi/acpidump/acpidump.h | 44 + usr.sbin/acpi/acpidump/aml_dump.c | 59 ++ usr.sbin/acpi/acpidump/asl_dump.c | 1209 ++++++++++++++++++++++++++++ 7 files changed, 1848 insertions(+) create mode 100644 usr.sbin/acpi/acpidump/Makefile create mode 100644 usr.sbin/acpi/acpidump/acpi.c create mode 100644 usr.sbin/acpi/acpidump/acpi_user.c create mode 100644 usr.sbin/acpi/acpidump/acpidump.c create mode 100644 usr.sbin/acpi/acpidump/acpidump.h create mode 100644 usr.sbin/acpi/acpidump/aml_dump.c create mode 100644 usr.sbin/acpi/acpidump/asl_dump.c diff --git a/usr.sbin/acpi/acpidump/Makefile b/usr.sbin/acpi/acpidump/Makefile new file mode 100644 index 000000000000..346dcf2bec15 --- /dev/null +++ b/usr.sbin/acpi/acpidump/Makefile @@ -0,0 +1,10 @@ +# $Id: Makefile,v 1.2 2000/07/14 18:16:29 iwasaki Exp $ +# $FreeBSD$ + +PROG= acpidump +SRCS= acpi.c acpi_user.c asl_dump.c aml_dump.c acpidump.c +NOMAN= yes +#MAN8= acpidump.8 +#DEBUG_FLAGS= -g + +.include diff --git a/usr.sbin/acpi/acpidump/acpi.c b/usr.sbin/acpi/acpidump/acpi.c new file mode 100644 index 000000000000..d52a0d99db98 --- /dev/null +++ b/usr.sbin/acpi/acpidump/acpi.c @@ -0,0 +1,258 @@ +/*- + * 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. + * + * $Id: acpi.c,v 1.4 2000/08/09 14:47:52 iwasaki Exp $ + * $FreeBSD$ + */ + +#include +#include +#include + +#include +#include +#include +#include +#include + +#include "acpidump.h" + +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_handle_dsdt(struct ACPIsdt *dsdp) +{ + u_int8_t *dp; + u_int8_t *end; + + acpi_print_dsdt(dsdp); + dp = (u_int8_t *)dsdp->body; + end = (u_int8_t *)dsdp + dsdp->len; + asl_dump_objectlist(&dp, end, 0); + assert(dp == end); +} + +static void +acpi_handle_facp(struct FACPbody *facp) +{ + struct ACPIsdt *dsdp; + + acpi_print_facp(facp); + dsdp = (struct ACPIsdt *) acpi_map_sdt(facp->dsdt_ptr); + if (acpi_checksum(dsdp, dsdp->len)) + errx(1, "DSDT is corrupt\n"); + acpi_handle_dsdt(dsdp); + aml_dump(dsdp->body, dsdp->len - SIZEOF_SDT_HDR); +} + +/* + * Public interfaces + */ + +void +acpi_print_sdt(struct ACPIsdt *sdp) +{ + + acpi_print_string(sdp->signature, 4); + printf(": Lenth=%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); +} + +void +acpi_print_rsdt(struct ACPIsdt *rsdp) +{ + int i, entries; + + acpi_print_sdt(rsdp); + entries = (rsdp->len - SIZEOF_SDT_HDR) / sizeof(u_int32_t); + printf("\tEntries={ "); + for (i = 0; i < entries; i++) { + if (i > 0) + printf(", "); + printf("0x%08x", rsdp->body[i]); + } + printf(" }\n"); +} + +void +acpi_print_facp(struct FACPbody *facp) +{ + char sep; + + printf("\tDSDT=0x%x\n", facp->dsdt_ptr); + printf("\tINT_MODEL=%s\n", facp->int_model ? "APIC" : "PIC"); + printf("\tSCI_INT=%d\n", facp->sci_int); + printf("\tSMI_CMD=0x%x, ", facp->smi_cmd); + printf("ACPI_ENABLE=0x%x, ", facp->acpi_enable); + printf("ACPI_DISABLE=0x%x, ", facp->acpi_disable); + printf("S4BIOS_REQ=0x%x\n", facp->s4biosreq); + if (facp->pm1a_evt_blk) + printf("\tPM1a_EVT_BLK=0x%x-0x%x\n", + facp->pm1a_evt_blk, + facp->pm1a_evt_blk + facp->pm1_evt_len - 1); + if (facp->pm1b_evt_blk) + printf("\tPM1b_EVT_BLK=0x%x-0x%x\n", + facp->pm1b_evt_blk, + facp->pm1b_evt_blk + facp->pm1_evt_len - 1); + if (facp->pm1a_cnt_blk) + printf("\tPM1a_CNT_BLK=0x%x-0x%x\n", + facp->pm1a_cnt_blk, + facp->pm1a_cnt_blk + facp->pm1_cnt_len - 1); + if (facp->pm1b_cnt_blk) + printf("\tPM1b_CNT_BLK=0x%x-0x%x\n", + facp->pm1b_cnt_blk, + facp->pm1b_cnt_blk + facp->pm1_cnt_len - 1); + if (facp->pm2_cnt_blk) + printf("\tPM2_CNT_BLK=0x%x-0x%x\n", + facp->pm2_cnt_blk, + facp->pm2_cnt_blk + facp->pm2_cnt_len - 1); + if (facp->pm_tmr_blk) + printf("\tPM2_TMR_BLK=0x%x-0x%x\n", + facp->pm_tmr_blk, + facp->pm_tmr_blk + facp->pm_tmr_len - 1); + if (facp->gpe0_blk) + printf("\tPM2_GPE0_BLK=0x%x-0x%x\n", + facp->gpe0_blk, + facp->gpe0_blk + facp->gpe0_len - 1); + if (facp->gpe1_blk) + printf("\tPM2_GPE1_BLK=0x%x-0x%x, GPE1_BASE=%d\n", + facp->gpe1_blk, + facp->gpe1_blk + facp->gpe1_len - 1, + facp->gpe1_base); + printf("\tP_LVL2_LAT=%dms, P_LVL3_LAT=%dms\n", + facp->p_lvl2_lat, facp->p_lvl3_lat); + printf("\tFLUSH_SIZE=%d, FLUSH_STRIDE=%d\n", + facp->flush_size, facp->flush_stride); + printf("\tDUTY_OFFSET=%d, DUTY_WIDTH=%d\n", + facp->duty_off, facp->duty_width); + printf("\tDAY_ALRM=%d, MON_ALRM=%d, CENTURY=%d\n", + facp->day_alrm, facp->mon_alrm, facp->century); + printf("\tFlags="); + sep = '{'; + +#define PRINTFLAG(xx) do { \ + if (facp->flags & ACPI_FACP_FLAG_## xx) { \ + printf("%c%s", sep, #xx); sep = ','; \ + } \ +} while (0) + + PRINTFLAG(WBINVD); + PRINTFLAG(WBINVD_FLUSH); + PRINTFLAG(PROC_C1); + PRINTFLAG(P_LVL2_UP); + PRINTFLAG(PWR_BUTTON); + PRINTFLAG(SLP_BUTTON); + PRINTFLAG(FIX_RTC); + PRINTFLAG(RTC_S4); + PRINTFLAG(TMR_VAL_EXT); + PRINTFLAG(DCK_CAP); + +#undef PRINTFLAG + + printf("}\n"); +} + +void +acpi_print_dsdt(struct ACPIsdt *dsdp) +{ + + acpi_print_sdt(dsdp); +} + +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); +} + +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); +} + +void +acpi_print_rsd_ptr(struct ACPIrsdp *rp) +{ + + printf("RSD PTR: Checksum=%d, OEMID=", rp->sum); + acpi_print_string(rp->oem, 6); + printf(", RsdtAddress=0x%08x\n", rp->addr); +} + +void +acpi_handle_rsdt(struct ACPIsdt *rsdp) +{ + int i; + int entries; + struct ACPIsdt *sdp; + + entries = (rsdp->len - SIZEOF_SDT_HDR) / sizeof(u_int32_t); + acpi_print_rsdt(rsdp); + for (i = 0; i < entries; i++) { + sdp = (struct ACPIsdt *) acpi_map_sdt(rsdp->body[i]); + if (acpi_checksum(sdp, sdp->len)) + errx(1, "RSDT entry %d is corrupt\n", i); + if (!memcmp(sdp->signature, "FACP", 4)) { + acpi_handle_facp((struct FACPbody *) sdp->body); + } else { + acpi_print_sdt(sdp); + } + } +} diff --git a/usr.sbin/acpi/acpidump/acpi_user.c b/usr.sbin/acpi/acpidump/acpi_user.c new file mode 100644 index 000000000000..56d21e7f1457 --- /dev/null +++ b/usr.sbin/acpi/acpidump/acpi_user.c @@ -0,0 +1,165 @@ +/*- + * 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. + * + * $Id: acpi_user.c,v 1.5 2000/08/09 14:47:52 iwasaki Exp $ + * $FreeBSD$ + */ + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include "acpidump.h" + +static int acpi_mem_fd = -1; + +struct acpi_user_mapping { + LIST_ENTRY(acpi_user_mapping) link; + vm_offset_t pa; + caddr_t va; + size_t size; +}; + +LIST_HEAD(acpi_user_mapping_list, acpi_user_mapping) maplist; + +static void +acpi_user_init() +{ + + if (acpi_mem_fd == -1) { + acpi_mem_fd = open("/dev/mem", O_RDONLY); + if (acpi_mem_fd == -1) + err(1, "opening /dev/mem"); + LIST_INIT(&maplist); + } +} + +static struct acpi_user_mapping * +acpi_user_find_mapping(vm_offset_t pa, size_t size) +{ + struct acpi_user_mapping *map; + + /* First search for an existing mapping */ + for (map = LIST_FIRST(&maplist); map; map = LIST_NEXT(map, link)) { + if (map->pa <= pa && map->size >= pa + size - map->pa) + return (map); + } + + /* Then create a new one */ + size = round_page(pa + size) - trunc_page(pa); + pa = trunc_page(pa); + map = malloc(sizeof(struct acpi_user_mapping)); + if (!map) + errx(1, "out of memory"); + map->pa = pa; + map->va = mmap(0, size, PROT_READ, MAP_SHARED, acpi_mem_fd, pa); + map->size = size; + if ((intptr_t) map->va == -1) + err(1, "can't map address"); + LIST_INSERT_HEAD(&maplist, map, link); + + return (map); +} + +/* + * Public interfaces + */ + +struct ACPIrsdp * +acpi_find_rsd_ptr() +{ + int i; + u_int8_t buf[sizeof(struct ACPIrsdp)]; + + acpi_user_init(); + for (i = 0; i < 1024 * 1024; i += 16) { + read(acpi_mem_fd, buf, 16); + if (!memcmp(buf, "RSD PTR ", 8)) { + /* Read the rest of the structure */ + read(acpi_mem_fd, buf + 16, sizeof(struct ACPIrsdp) - 16); + + /* Verify checksum before accepting it. */ + if (acpi_checksum(buf, sizeof(struct ACPIrsdp))) + continue; + return (acpi_map_physical(i, sizeof(struct ACPIrsdp))); + } + } + + return (0); +} + +void * +acpi_map_physical(vm_offset_t pa, size_t size) +{ + struct acpi_user_mapping *map; + + map = acpi_user_find_mapping(pa, size); + return (map->va + (pa - map->pa)); +} + +void +acpi_load_dsdt(char *dumpfile, u_int8_t **dpp, u_int8_t **endp) +{ + u_int8_t *dp; + u_int8_t *end; + struct stat sb; + + if ((acpi_mem_fd = open(dumpfile, O_RDONLY)) == -1) { + errx(1, "opening %s\n", dumpfile); + } + + LIST_INIT(&maplist); + + if (fstat(acpi_mem_fd, &sb) == -1) { + errx(1, "fstat %s\n", dumpfile); + } + + dp = mmap(0, sb.st_size, PROT_READ, MAP_PRIVATE, acpi_mem_fd, 0); + if (dp == NULL) { + errx(1, "mmap %s\n", dumpfile); + } + + /* + * Microsoft asl.exe generates 0x23 byte additional info. + * at the begining of the file, so just ignore it. + */ + if (strncmp(dp, "DSDT", 4) == 0) { + dp += 0x23; + sb.st_size -= 0x23; + } + + end = (u_int8_t *) dp + sb.st_size; + *dpp = dp; + *endp = end; +} diff --git a/usr.sbin/acpi/acpidump/acpidump.c b/usr.sbin/acpi/acpidump/acpidump.c new file mode 100644 index 000000000000..a61f9d6850a5 --- /dev/null +++ b/usr.sbin/acpi/acpidump/acpidump.c @@ -0,0 +1,103 @@ +/*- + * 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. + * + * $Id: acpidump.c,v 1.3 2000/08/08 14:12:21 iwasaki Exp $ + * $FreeBSD$ + */ + +#include +#include + +#include +#include +#include +#include + +#include "acpidump.h" + +static void +asl_dump_from_file(char *file) +{ + u_int8_t *dp; + u_int8_t *end; + + acpi_load_dsdt(file, &dp, &end); + asl_dump_objectlist(&dp, end, 0); +} + +static void +asl_dump_from_devmem() +{ + struct ACPIrsdp *rp; + struct ACPIsdt *rsdp; + + rp = acpi_find_rsd_ptr(); + if (!rp) + errx(1, "Can't find ACPI information\n"); + + acpi_print_rsd_ptr(rp); + rsdp = (struct ACPIsdt *) acpi_map_sdt(rp->addr); + if (memcmp(rsdp->signature, "RSDT", 4) || + acpi_checksum(rsdp, rsdp->len)) + errx(1, "RSDT is corrupted\n"); + + acpi_handle_rsdt(rsdp); +} + +static void +usage(const char *progname) +{ + + printf("usage:\t%s [-o dsdt_file_for_output]\n", progname); + printf("or\t%s [-f dsdt_file_for_input]\n", progname); + exit(1); +} + +int +main(int argc, char *argv[]) +{ + char c, *progname; + + progname = argv[0]; + while ((c = getopt(argc, argv, "f:o:h")) != -1) { + switch (c) { + case 'f': + asl_dump_from_file(optarg); + return (0); + case 'o': + aml_dumpfile = optarg; + break; + case 'h': + usage(progname); + break; + default: + argc -= optind; + argv += optind; + } + } + + asl_dump_from_devmem(); + return (0); +} diff --git a/usr.sbin/acpi/acpidump/acpidump.h b/usr.sbin/acpi/acpidump/acpidump.h new file mode 100644 index 000000000000..fab7e1aa0dbd --- /dev/null +++ b/usr.sbin/acpi/acpidump/acpidump.h @@ -0,0 +1,44 @@ +/*- + * 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. + * + * $Id: acpidump.h,v 1.3 2000/08/09 14:47:52 iwasaki Exp $ + * $FreeBSD$ + */ + +#ifndef _ACPIDUMP_H_ +#define _ACPIDUMP_H_ + +void asl_dump_termobj(u_int8_t **, int); +void asl_dump_objectlist(u_int8_t **, u_int8_t *, int); + +void aml_dump(u_int32_t *, int); + +void acpi_handle_rsdt(struct ACPIsdt *); +void acpi_load_dsdt(char *, u_int8_t **, u_int8_t **); + +extern char *aml_dumpfile; + +#endif /* !_ACPIDUMP_H_ */ diff --git a/usr.sbin/acpi/acpidump/aml_dump.c b/usr.sbin/acpi/acpidump/aml_dump.c new file mode 100644 index 000000000000..6176df321ad0 --- /dev/null +++ b/usr.sbin/acpi/acpidump/aml_dump.c @@ -0,0 +1,59 @@ +/*- + * 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. + * + * $Id: aml_dump.c,v 1.3 2000/08/08 14:12:21 iwasaki Exp $ + * $FreeBSD$ + */ + +#include +#include +#include + +#include +#include +#include + +#include "acpidump.h" + +char *aml_dumpfile = NULL; + +void +aml_dump(u_int32_t *ptr, int len) +{ + int fd; + mode_t mode; + + if (aml_dumpfile == NULL) { + return; + } + + mode = (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH); + fd = open(aml_dumpfile, O_WRONLY | O_CREAT, mode); + if (fd == -1) { + return; + } + write(fd, ptr, len); + close(fd); +} diff --git a/usr.sbin/acpi/acpidump/asl_dump.c b/usr.sbin/acpi/acpidump/asl_dump.c new file mode 100644 index 000000000000..4cbd36259c76 --- /dev/null +++ b/usr.sbin/acpi/acpidump/asl_dump.c @@ -0,0 +1,1209 @@ +/*- + * 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. + * + * $Id: asl_dump.c,v 1.6 2000/08/09 14:47:52 iwasaki Exp $ + * $FreeBSD$ + */ + +#include +#include + +#include +#include +#include + +#include "acpidump.h" + +static u_int32_t +asl_dump_pkglength(u_int8_t **dpp) +{ + u_int8_t *dp; + u_int32_t pkglength; + + dp = *dpp; + pkglength = *dp++; + switch (pkglength >> 6) { + case 0: + break; + case 1: + pkglength = (pkglength & 0xf) + (dp[0] << 4); + dp += 1; + break; + case 2: + pkglength = (pkglength & 0xf) + (dp[0] << 4) + (dp[1] << 12); + dp += 2; + break; + case 3: + pkglength = (pkglength & 0xf) + + (dp[0] << 4) + (dp[1] << 12) + (dp[2] << 20); + dp += 3; + break; + } + + *dpp = dp; + return (pkglength); +} + +static void +print_nameseg(u_int8_t *dp) +{ + + if (dp[3] != '_') + printf("%c%c%c%c", dp[0], dp[1], dp[2], dp[3]); + else if (dp[2] != '_') + printf("%c%c%c_", dp[0], dp[1], dp[2]); + else if (dp[1] != '_') + printf("%c%c__", dp[0], dp[1]); + else if (dp[0] != '_') + printf("%c___", dp[0]); +} + +static u_int8_t +asl_dump_bytedata(u_int8_t **dpp) +{ + u_int8_t *dp; + u_int8_t data; + + dp = *dpp; + data = dp[0]; + *dpp = dp + 1; + return (data); +} + +static u_int16_t +asl_dump_worddata(u_int8_t **dpp) +{ + u_int8_t *dp; + u_int16_t data; + + dp = *dpp; + data = dp[0] + (dp[1] << 8); + *dpp = dp + 2; + return (data); +} + +static u_int32_t +asl_dump_dworddata(u_int8_t **dpp) +{ + u_int8_t *dp; + u_int32_t data; + + dp = *dpp; + data = dp[0] + (dp[1] << 8) + (dp[2] << 16) + (dp[3] << 24); + *dpp = dp + 4; + return (data); +} + +static u_int8_t * +asl_dump_namestring(u_int8_t **dpp) +{ + u_int8_t *dp; + u_int8_t *name; + + dp = *dpp; + name = dp; + if (dp[0] == '\\') + dp++; + else if (dp[0] == '^') + while (dp[0] == '^') + dp++; + if (dp[0] == 0x00) /* NullName */ + dp++; + else if (dp[0] == 0x2e) /* DualNamePrefix */ + dp += 1 + 4 + 4;/* NameSeg, NameSeg */ + else if (dp[0] == 0x2f) { /* MultiNamePrefix */ + int segcount = dp[1]; + dp += 1 + 1 + segcount * 4; /* segcount * NameSeg */ + } else + dp += 4; /* NameSeg */ + + *dpp = dp; + return (name); +} + +static void +print_namestring(u_int8_t *dp) +{ + + if (dp[0] == '\\') { + putchar(dp[0]); + dp++; + } else if (dp[0] == '^') { + while (dp[0] == '^') { + putchar(dp[0]); + dp++; + } + } + if (dp[0] == 0x00) { /* NullName */ + /* printf(""); */ + dp++; + } else if (dp[0] == 0x2e) { /* DualNamePrefix */ + print_nameseg(dp + 1); + putchar('.'); + print_nameseg(dp + 5); + } else if (dp[0] == 0x2f) { /* MultiNamePrefix */ + int segcount = dp[1]; + int i; + for (i = 0, dp += 2; i < segcount; i++, dp += 4) { + if (i > 0) + putchar('.'); + print_nameseg(dp); + } + } else /* NameSeg */ + print_nameseg(dp); +} + +static void +print_indent(int indent) +{ + int i; + + for (i = 0; i < indent; i++) + printf(" "); +} + +static void +asl_dump_defscope(u_int8_t **dpp, int indent) +{ + u_int8_t *dp; + u_int8_t *start; + u_int8_t *end; + u_int32_t pkglength; + + dp = *dpp; + start = dp; + pkglength = asl_dump_pkglength(&dp); + + printf("Scope("); + asl_dump_termobj(&dp, indent); + printf(") {\n"); + end = start + pkglength; + asl_dump_objectlist(&dp, end, indent + 1); + print_indent(indent); + printf("}"); + + assert(dp == end); + + *dpp = dp; +} + +static void +asl_dump_defbuffer(u_int8_t **dpp, int indent) +{ + u_int8_t *dp; + u_int8_t *start; + u_int8_t *end; + u_int32_t pkglength; + + dp = *dpp; + start = dp; + pkglength = asl_dump_pkglength(&dp); + end = start + pkglength; + printf("Buffer("); + asl_dump_termobj(&dp, indent); + printf(") {"); + while (dp < end) { + printf("0x%x", *dp++); + if (dp < end) + printf(", "); + } + printf(" }"); + + *dpp = dp; +} + +static void +asl_dump_defpackage(u_int8_t **dpp, int indent) +{ + u_int8_t *dp; + u_int8_t *start; + u_int8_t *end; + u_int8_t numelements; + u_int32_t pkglength; + + dp = *dpp; + start = dp; + pkglength = asl_dump_pkglength(&dp); + numelements = asl_dump_bytedata(&dp); + end = start + pkglength; + printf("Package(0x%x) {\n", numelements); + while (dp < end) { + print_indent(indent + 1); + asl_dump_termobj(&dp, indent + 1); + printf(",\n"); + } + + print_indent(indent); + printf("}"); + + dp = end; + + *dpp = dp; +} + +static void +asl_dump_defmethod(u_int8_t **dpp, int indent) +{ + u_int8_t *dp; + u_int8_t *start; + u_int8_t *end; + u_int8_t flags; + u_int32_t pkglength; + + dp = *dpp; + start = dp; + pkglength = asl_dump_pkglength(&dp); + + printf("Method("); + asl_dump_termobj(&dp, indent); + flags = *dp++; + if (flags) { + printf(", %d", flags & 7); + if (flags & 8) { + printf(", Serialized"); + } + } + printf(") {\n"); + end = start + pkglength; + asl_dump_objectlist(&dp, end, indent + 1); + print_indent(indent); + printf("}"); + + assert(dp == end); + + *dpp = dp; +} + + +static void +asl_dump_defopregion(u_int8_t **dpp, int indent) +{ + u_int8_t *dp; + const char *regions[] = { + "SystemMemory", + "SystemIO", + "PCI_Config", + "EmbeddedControl", + "SMBus", + }; + + dp = *dpp; + printf("OperationRegion("); + asl_dump_termobj(&dp, indent); /* Name */ + printf(", %s, ", regions[*dp++]); /* Space */ + asl_dump_termobj(&dp, indent); /* Offset */ + printf(", "); + asl_dump_termobj(&dp, indent); /* Length */ + printf(")"); + + *dpp = dp; +} + +static const char *accessnames[] = { + "AnyAcc", + "ByteAcc", + "WordAcc", + "DWordAcc", + "BlockAcc", + "SMBSendRecvAcc", + "SMBQuickAcc" +}; + +static int +asl_dump_field(u_int8_t **dpp, u_int32_t offset) +{ + u_int8_t *dp; + u_int8_t *name; + u_int8_t access, attribute; + u_int32_t width; + + dp = *dpp; + switch (*dp) { + case '\\': + case '^': + case 'A' ... 'Z': + case '_': + case '.': + name = asl_dump_namestring(&dp); + width = asl_dump_pkglength(&dp); + offset += width; + print_namestring(name); + printf(",\t%d", width); + break; + case 0x00: + dp++; + width = asl_dump_pkglength(&dp); + offset += width; + if ((offset % 8) == 0) { + printf("Offset(0x%x)", offset / 8); + } else { + printf(",\t%d", width); + } + break; + case 0x01: + access = dp[1]; + attribute = dp[2]; + dp += 3; + printf("AccessAs(%s, %d)", accessnames[access], attribute); + break; + } + + *dpp = dp; + return (offset); +} + +static void +asl_dump_fieldlist(u_int8_t **dpp, u_int8_t *end, int indent) +{ + u_int8_t *dp; + u_int32_t offset; + + dp = *dpp; + offset = 0; + while (dp < end) { + print_indent(indent); + offset = asl_dump_field(&dp, offset); + if (dp < end) + printf(",\n"); + else + printf("\n"); + } + + *dpp = dp; +} + +static void +asl_dump_deffield(u_int8_t **dpp, int indent) +{ + u_int8_t *dp; + u_int8_t *start; + u_int8_t *end; + u_int8_t flags; + u_int32_t pkglength; + static const char *lockrules[] = {"NoLock", "Lock"}; + static const char *updaterules[] = {"Preserve", "WriteAsOnes", + "WriteAsZeros", "*Error*"}; + + dp = *dpp; + start = dp; + pkglength = asl_dump_pkglength(&dp); + end = start + pkglength; + + printf("Field("); + asl_dump_termobj(&dp, indent); /* Name */ + flags = asl_dump_bytedata(&dp); + printf(", %s, %s, %s) {\n", + accessnames[flags & 0xf], + lockrules[(flags >> 4) & 1], + updaterules[(flags >> 5) & 3]); + asl_dump_fieldlist(&dp, end, indent + 1); + print_indent(indent); + printf("}"); + + assert(dp == end); + + *dpp = dp; +} + +static void +asl_dump_defindexfield(u_int8_t **dpp, int indent) +{ + u_int8_t *dp; + u_int8_t *start; + u_int8_t *end; + u_int8_t flags; + u_int32_t pkglength; + static const char *lockrules[] = {"NoLock", "Lock"}; + static const char *updaterules[] = {"Preserve", "WriteAsOnes", + "WriteAsZeros", "*Error*"}; + + dp = *dpp; + start = dp; + pkglength = asl_dump_pkglength(&dp); + end = start + pkglength; + + printf("IndexField("); + asl_dump_termobj(&dp, indent); /* Name1 */ + printf(", "); + asl_dump_termobj(&dp, indent); /* Name2 */ + flags = asl_dump_bytedata(&dp); + printf(", %s, %s, %s) {\n", + accessnames[flags & 0xf], + lockrules[(flags >> 4) & 1], + updaterules[(flags >> 5) & 3]); + asl_dump_fieldlist(&dp, end, indent + 1); + print_indent(indent); + printf("}"); + + assert(dp == end); + + *dpp = dp; +} + +static void +asl_dump_defbankfield(u_int8_t **dpp, int indent) +{ + u_int8_t *dp; + u_int8_t *start; + u_int8_t *end; + u_int8_t flags; + u_int32_t pkglength; + static const char *lockrules[] = {"NoLock", "Lock"}; + static const char *updaterules[] = {"Preserve", "WriteAsOnes", + "WriteAsZeros", "*Error*"}; + + dp = *dpp; + start = dp; + pkglength = asl_dump_pkglength(&dp); + end = start + pkglength; + + printf("Field("); + asl_dump_termobj(&dp, indent); /* Name1 */ + printf(", "); + asl_dump_termobj(&dp, indent); /* Name2 */ + printf(", "); + asl_dump_termobj(&dp, indent); /* BankValue */ + flags = asl_dump_bytedata(&dp); + printf(", %s, %s, %s) {\n", + accessnames[flags & 0xf], + lockrules[(flags >> 4) & 1], + updaterules[(flags >> 5) & 3]); + asl_dump_fieldlist(&dp, end, indent + 1); + print_indent(indent); + printf("}"); + + assert(dp == end); + + *dpp = dp; +} + +static void +asl_dump_defdevice(u_int8_t **dpp, int indent) +{ + u_int8_t *dp; + u_int8_t *start; + u_int8_t *end; + u_int32_t pkglength; + + dp = *dpp; + start = dp; + pkglength = asl_dump_pkglength(&dp); + end = start + pkglength; + + printf("Device("); + asl_dump_termobj(&dp, indent); + printf(") {\n"); + asl_dump_objectlist(&dp, end, indent + 1); + print_indent(indent); + printf("}"); + + assert(dp == end); + + *dpp = dp; +} + +static void +asl_dump_defprocessor(u_int8_t **dpp, int indent) +{ + u_int8_t *dp; + u_int8_t *start; + u_int8_t *end; + u_int8_t procid; + u_int8_t pblklen; + u_int32_t pkglength; + u_int32_t pblkaddr; + + dp = *dpp; + start = dp; + pkglength = asl_dump_pkglength(&dp); + end = start + pkglength; + + printf("Processor("); + asl_dump_termobj(&dp, indent); + procid = asl_dump_bytedata(&dp); + pblkaddr = asl_dump_dworddata(&dp); + pblklen = asl_dump_bytedata(&dp); + printf(", %d, 0x%x, 0x%x) {\n", procid, pblkaddr, pblklen); + asl_dump_objectlist(&dp, end, indent + 1); + print_indent(indent); + printf("}"); + + assert(dp == end); + + *dpp = dp; +} + +static void +asl_dump_defpowerres(u_int8_t **dpp, int indent) +{ + u_int8_t *dp; + u_int8_t *start; + u_int8_t *end; + u_int8_t systemlevel; + u_int16_t resourceorder; + u_int32_t pkglength; + + dp = *dpp; + start = dp; + pkglength = asl_dump_pkglength(&dp); + end = start + pkglength; + + printf("PowerResource("); + asl_dump_termobj(&dp, indent); + systemlevel = asl_dump_bytedata(&dp); + resourceorder = asl_dump_worddata(&dp); + printf(", %d, %d) {\n", systemlevel, resourceorder); + asl_dump_objectlist(&dp, end, indent + 1); + print_indent(indent); + printf("}"); + + assert(dp == end); + + *dpp = dp; +} + +static void +asl_dump_defthermalzone(u_int8_t **dpp, int indent) +{ + u_int8_t *dp; + u_int8_t *start; + u_int8_t *end; + u_int32_t pkglength; + + dp = *dpp; + start = dp; + pkglength = asl_dump_pkglength(&dp); + end = start + pkglength; + + printf("ThermalZone("); + asl_dump_termobj(&dp, indent); + printf(") {\n"); + asl_dump_objectlist(&dp, end, indent + 1); + print_indent(indent); + printf("}"); + + assert(dp == end); + + *dpp = dp; +} + +static void +asl_dump_defif(u_int8_t **dpp, int indent) +{ + u_int8_t *dp; + u_int8_t *start; + u_int8_t *end; + u_int32_t pkglength; + + dp = *dpp; + start = dp; + pkglength = asl_dump_pkglength(&dp); + end = start + pkglength; + + printf("If("); + asl_dump_termobj(&dp, indent); + printf(") {\n"); + asl_dump_objectlist(&dp, end, indent + 1); + print_indent(indent); + printf("}"); + + assert(dp == end); + + *dpp = dp; +} + +static void +asl_dump_defelse(u_int8_t **dpp, int indent) +{ + u_int8_t *dp; + u_int8_t *start; + u_int8_t *end; + u_int32_t pkglength; + + dp = *dpp; + start = dp; + pkglength = asl_dump_pkglength(&dp); + end = start + pkglength; + + printf("Else {\n"); + asl_dump_objectlist(&dp, end, indent + 1); + print_indent(indent); + printf("}"); + + assert(dp == end); + + *dpp = dp; +} + +static void +asl_dump_defwhile(u_int8_t **dpp, int indent) +{ + u_int8_t *dp; + u_int8_t *start; + u_int8_t *end; + u_int32_t pkglength; + + dp = *dpp; + start = dp; + pkglength = asl_dump_pkglength(&dp); + end = start + pkglength; + + printf("While("); + asl_dump_termobj(&dp, indent); + printf(") {\n"); + asl_dump_objectlist(&dp, end, indent + 1); + print_indent(indent); + printf("}"); + + assert(dp == end); + + *dpp = dp; +} + +/* + * Public interfaces + */ + +void +asl_dump_termobj(u_int8_t **dpp, int indent) +{ + u_int8_t *dp; + u_int8_t opcode; + const char *matchstr[] = { + "MTR", "MEQ", "MLE", "MLT", "MGE", "MGT", + }; + +#define OPTARG() do { \ + printf(", "); \ + if (*dp == 0x00) { \ + dp++; \ + } else { \ + asl_dump_termobj(&dp, indent); \ + } \ +} while (0) + + dp = *dpp; + opcode = *dp++; + switch (opcode) { + case '\\': + case '^': + case 'A' ... 'Z': + case '_': + case '.': + dp--; + print_namestring(asl_dump_namestring(&dp)); + break; + case 0x0a: /* BytePrefix */ + printf("0x%x", asl_dump_bytedata(&dp)); + break; + case 0x0b: /* WordPrefix */ + printf("0x%04x", asl_dump_worddata(&dp)); + break; + case 0x0c: /* DWordPrefix */ + printf("0x%08x", asl_dump_dworddata(&dp)); + break; + case 0x0d: /* StringPrefix */ + printf("\"%s\"", (const char *) dp); + while (*dp) + dp++; + dp++; /* NUL terminate */ + break; + case 0x00: /* ZeroOp */ + printf("Zero"); + break; + case 0x01: /* OneOp */ + printf("One"); + break; + case 0xff: /* OnesOp */ + printf("Ones"); + break; + case 0x06: /* AliasOp */ + printf("Alias("); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + printf(")"); + break; + case 0x08: /* NameOp */ + printf("Name("); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + printf(")"); + break; + case 0x10: /* ScopeOp */ + asl_dump_defscope(&dp, indent); + break; + case 0x11: /* BufferOp */ + asl_dump_defbuffer(&dp, indent); + break; + case 0x12: /* PackageOp */ + asl_dump_defpackage(&dp, indent); + break; + case 0x14: /* MethodOp */ + asl_dump_defmethod(&dp, indent); + break; + case 0x5b: /* ExtOpPrefix */ + opcode = *dp++; + switch (opcode) { + case 0x01: /* MutexOp */ + printf("Mutex("); + asl_dump_termobj(&dp, indent); + printf(", %d)", *dp++); + break; + case 0x02: /* EventOp */ + printf("Event("); + asl_dump_termobj(&dp, indent); + printf(")"); + break; + case 0x12: /* CondRefOfOp */ + printf("CondRefOf("); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + printf(")"); + break; + case 0x13: /* CreateFieldOp */ + printf("CreateField("); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + printf(")"); + break; + case 0x20: /* LoadOp */ + printf("Load("); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + printf(")"); + break; + case 0x21: /* StallOp */ + printf("Stall("); + asl_dump_termobj(&dp, indent); + printf(")"); + break; + case 0x22: /* SleepOp */ + printf("Sleep("); + asl_dump_termobj(&dp, indent); + printf(")"); + break; + case 0x23: /* AcquireOp */ + printf("Acquire("); + asl_dump_termobj(&dp, indent); + printf(", 0x%x)", asl_dump_worddata(&dp)); + break; + case 0x24: /* SignalOp */ + printf("Signal("); + asl_dump_termobj(&dp, indent); + printf(")"); + break; + case 0x25: /* WaitOp */ + printf("Wait("); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + printf(")"); + break; + case 0x26: /* ResetOp */ + printf("Reset("); + asl_dump_termobj(&dp, indent); + printf(")"); + break; + case 0x27: /* ReleaseOp */ + printf("Release("); + asl_dump_termobj(&dp, indent); + printf(")"); + break; + case 0x28: /* FromBCDOp */ + printf("FromBCD("); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + printf(")"); + break; + case 0x29: /* ToBCDOp */ + printf("ToBCD("); + asl_dump_termobj(&dp, indent); + OPTARG(); + printf(")"); + break; + case 0x2a: /* UnloadOp */ + printf("Unload("); + asl_dump_termobj(&dp, indent); + printf(")"); + break; + case 0x30: + printf("Revision"); + break; + case 0x31: + printf("Debug"); + break; + case 0x32: /* FatalOp */ + printf("Fatal("); + printf("0x%x, ", asl_dump_bytedata(&dp)); + printf("0x%x, ", asl_dump_dworddata(&dp)); + asl_dump_termobj(&dp, indent); + printf(")"); + break; + case 0x80: /* OpRegionOp */ + asl_dump_defopregion(&dp, indent); + break; + case 0x81: /* FieldOp */ + asl_dump_deffield(&dp, indent); + break; + case 0x82: /* DeviceOp */ + asl_dump_defdevice(&dp, indent); + break; + case 0x83: /* ProcessorOp */ + asl_dump_defprocessor(&dp, indent); + break; + case 0x84: /* PowerResOp */ + asl_dump_defpowerres(&dp, indent); + break; + case 0x85: /* ThermalZoneOp */ + asl_dump_defthermalzone(&dp, indent); + break; + case 0x86: /* IndexFieldOp */ + asl_dump_defindexfield(&dp, indent); + break; + case 0x87: /* BankFieldOp */ + asl_dump_defbankfield(&dp, indent); + break; + default: + errx(1, "strange opcode 0x5b, 0x%x\n", opcode); + } + break; + case 0x68 ... 0x6e: /* ArgN */ + printf("Arg%d", opcode - 0x68); + break; + case 0x60 ... 0x67: + printf("Local%d", opcode - 0x60); + break; + case 0x70: /* StoreOp */ + printf("Store("); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + printf(")"); + break; + case 0x71: /* RefOfOp */ + printf("RefOf("); + asl_dump_termobj(&dp, indent); + printf(")"); + break; + case 0x72: /* AddOp */ + printf("Add("); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + OPTARG(); + printf(")"); + break; + case 0x73: /* ConcatOp */ + printf("Concat("); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + printf(")"); + break; + case 0x74: /* SubtractOp */ + printf("Subtract("); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + OPTARG(); + printf(")"); + break; + case 0x75: /* IncrementOp */ + printf("Increment("); + asl_dump_termobj(&dp, indent); + printf(")"); + break; + case 0x76: /* DecrementOp */ + printf("Decrement("); + asl_dump_termobj(&dp, indent); + printf(")"); + break; + case 0x77: /* MultiplyOp */ + printf("Multiply("); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + OPTARG(); + printf(")"); + break; + case 0x78: /* DivideOp */ + printf("Divide("); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + OPTARG(); + OPTARG(); + printf(")"); + break; + case 0x79: /* ShiftLeftOp */ + printf("ShiftLeft("); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + OPTARG(); + printf(")"); + break; + case 0x7a: /* ShiftRightOp */ + printf("ShiftRight("); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + OPTARG(); + printf(")"); + break; + case 0x7b: /* AndOp */ + printf("And("); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + OPTARG(); + printf(")"); + break; + case 0x7c: /* NAndOp */ + printf("NAnd("); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + OPTARG(); + printf(")"); + break; + case 0x7d: /* OrOp */ + printf("Or("); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + OPTARG(); + printf(")"); + break; + case 0x7e: /* NOrOp */ + printf("NOr("); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + OPTARG(); + printf(")"); + break; + case 0x7f: /* XOrOp */ + printf("XOr("); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + OPTARG(); + printf(")"); + break; + case 0x80: /* NotOp */ + printf("Not("); + asl_dump_termobj(&dp, indent); + OPTARG(); + printf(")"); + break; + case 0x81: /* FindSetLeftBitOp */ + printf("FindSetLeftBit("); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + printf(")"); + break; + case 0x82: /* FindSetRightBitOp */ + printf("FindSetRightBit("); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + printf(")"); + break; + case 0x83: /* DerefOp */ + printf("DerefOf("); + asl_dump_termobj(&dp, indent); + printf(")"); + break; + case 0x86: /* NotifyOp */ + printf("Notify("); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + printf(")"); + break; + case 0x87: /* SizeOfOp */ + printf("Sizeof("); + asl_dump_termobj(&dp, indent); + printf(")"); + break; + case 0x88: /* IndexOp */ + printf("Index("); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + OPTARG(); + printf(")"); + break; + case 0x89: /* MatchOp */ + printf("Match("); + asl_dump_termobj(&dp, indent); + printf(", %s, ", matchstr[*dp++]); + asl_dump_termobj(&dp, indent); + printf(", %s, ", matchstr[*dp++]); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + printf(")"); + break; + case 0x8a: /* CreateDWordFieldOp */ + printf("CreateDWordField("); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + printf(")"); + break; + case 0x8b: /* CreateWordFieldOp */ + printf("CreateWordField("); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + printf(")"); + break; + case 0x8c: /* CreateByteFieldOp */ + printf("CreateByteField("); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + printf(")"); + break; + case 0x8d: /* CreateBitFieldOp */ + printf("CreateBitField("); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + printf(")"); + break; + case 0x8e: /* ObjectTypeOp */ + printf("ObjectType("); + asl_dump_termobj(&dp, indent); + printf(")"); + break; + case 0x90: + printf("LAnd("); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + printf(")"); + break; + case 0x91: + printf("LOr("); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + printf(")"); + break; + case 0x92: + printf("LNot("); + asl_dump_termobj(&dp, indent); + printf(")"); + break; + case 0x93: + printf("LEqual("); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + printf(")"); + break; + case 0x94: + printf("LGreater("); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + printf(")"); + break; + case 0x95: + printf("LLess("); + asl_dump_termobj(&dp, indent); + printf(", "); + asl_dump_termobj(&dp, indent); + printf(")"); + break; + case 0xa0: /* IfOp */ + asl_dump_defif(&dp, indent); + break; + case 0xa1: /* ElseOp */ + asl_dump_defelse(&dp, indent); + break; + case 0xa2: /* WhileOp */ + asl_dump_defwhile(&dp, indent); + break; + case 0xa3: /* NoopOp */ + printf("Noop"); + break; + case 0xa5: /* BreakOp */ + printf("Break"); + break; + case 0xa4: /* ReturnOp */ + printf("Return("); + asl_dump_termobj(&dp, indent); + printf(")"); + break; + case 0xcc: /* BreakPointOp */ + printf("BreakPoint"); + break; + default: + errx(1, "strange opcode 0x%x\n", opcode); + } + + *dpp = dp; +} + +void +asl_dump_objectlist(u_int8_t **dpp, u_int8_t *end, int indent) +{ + u_int8_t *dp; + + dp = *dpp; + while (dp < end) { + print_indent(indent); + asl_dump_termobj(&dp, indent); + printf("\n"); + } + + *dpp = dp; +}