/*      $NetBSD: acpi_util.c,v 1.37 2025/10/04 01:12:15 thorpej Exp $ */

/*-
 * Copyright (c) 2003, 2007, 2021 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Charles M. Hannum of By Noon Software, Inc.
 *
 * 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
 */

/*
 * Copyright 2001, 2003 Wasabi Systems, Inc.
 * All rights reserved.
 *
 * Written by Jason R. Thorpe for Wasabi Systems, Inc.
 *
 * 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.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed for the NetBSD Project by
 *      Wasabi Systems, Inc.
 * 4. The name of Wasabi Systems, Inc. may not be used to endorse
 *    or promote products derived from this software without specific prior
 *    written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``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 WASABI SYSTEMS, INC
 * 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.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: acpi_util.c,v 1.37 2025/10/04 01:12:15 thorpej Exp $");

#include <sys/param.h>
#include <sys/kmem.h>
#include <sys/cpu.h>

#include <dev/acpi/acpireg.h>
#include <dev/acpi/acpivar.h>
#include <dev/acpi/acpi_intr.h>

#include <sys/device_calls.h>

#include <machine/acpi_machdep.h>

#define _COMPONENT      ACPI_BUS_COMPONENT
ACPI_MODULE_NAME        ("acpi_util")

static void             acpi_clean_node(ACPI_HANDLE, void *);
static ACPI_STATUS      acpi_dsd_property(ACPI_HANDLE, const char *,
                            ACPI_BUFFER *, ACPI_OBJECT_TYPE, ACPI_OBJECT **);

static const char * const acpicpu_ids[] = {
        "ACPI0007",
        NULL
};

static const struct device_compatible_entry dtlink_compat_data[] = {
        { .compat = "PRP0001" },
        DEVICE_COMPAT_EOL
};

/*
 * ACPI device handle support.
 */

static device_call_t
acpi_devhandle_lookup_device_call(devhandle_t handle, const char *name,
    devhandle_t *call_handlep)
{
        __link_set_decl(acpi_device_calls, struct device_call_descriptor);
        struct device_call_descriptor * const *desc;

        __link_set_foreach(desc, acpi_device_calls) {
                if (strcmp((*desc)->name, name) == 0) {
                        return (*desc)->call;
                }
        }
        return NULL;
}

static const struct devhandle_impl acpi_devhandle_impl = {
        .type = DEVHANDLE_TYPE_ACPI,
        .lookup_device_call = acpi_devhandle_lookup_device_call,
};

devhandle_t
devhandle_from_acpi(devhandle_t super_handle, ACPI_HANDLE const hdl)
{
        devhandle_type_t super_type = devhandle_type(super_handle);
        devhandle_t handle = { 0 };

        if (super_type == DEVHANDLE_TYPE_ACPI) {
                handle.impl = super_handle.impl;
        } else {
                KASSERT(super_type == DEVHANDLE_TYPE_INVALID);
                handle.impl = &acpi_devhandle_impl;
        }
        handle.pointer = hdl;

        return handle;
}

ACPI_HANDLE
devhandle_to_acpi(devhandle_t const handle)
{
        KASSERT(devhandle_type(handle) == DEVHANDLE_TYPE_ACPI);

        return handle.pointer;
}

static int
acpi_device_enumerate_children(device_t dev, devhandle_t call_handle, void *v)
{
        struct device_enumerate_children_args *args = v;
        ACPI_HANDLE hdl = devhandle_to_acpi(call_handle);
        struct acpi_devnode *devnode, *ad;

        devnode = acpi_match_node(hdl);
        KASSERT(devnode != NULL);

        SIMPLEQ_FOREACH(ad, &devnode->ad_child_head, ad_child_list) {
                if (ad->ad_devinfo->Type != ACPI_TYPE_DEVICE ||
                    !acpi_device_present(ad->ad_handle)) {
                        continue;
                }
                if (!args->callback(dev, devhandle_from_acpi(call_handle,
                                                             ad->ad_handle),
                                    args->callback_arg)) {
                        break;
                }
        }

        return 0;
}
ACPI_DEVICE_CALL_REGISTER(DEVICE_ENUMERATE_CHILDREN_STR,
                          acpi_device_enumerate_children)

static int
acpi_device_register(device_t dev, devhandle_t call_handle, void *v)
{
        ACPI_HANDLE handle = devhandle_to_acpi(call_handle);
        ACPI_BUFFER buf;
        ACPI_STATUS rv;

        buf.Pointer = NULL;
        buf.Length = ACPI_ALLOCATE_LOCAL_BUFFER;

        rv = AcpiGetName(handle, ACPI_FULL_PATHNAME, &buf);

        if (! ACPI_FAILURE(rv)) {
                device_setprop_string(dev, "device-path", buf.Pointer);
        }

        ACPI_FREE(buf.Pointer);
        return 0;
}
ACPI_DEVICE_CALL_REGISTER(DEVICE_REGISTER_STR,
                          acpi_device_register)

static bool
prop_type_to_acpi(prop_type_t type, ACPI_OBJECT_TYPE *out)
{
        switch (type) {
        case PROP_TYPE_NUMBER:
        case PROP_TYPE_BOOL:
                *out = ACPI_TYPE_INTEGER;
                break;

        case PROP_TYPE_DATA:
                /*
                 * If we're requesting DATA, when we map to ANY, since
                 * we want to be able to fetch STRINGs as DATA, too.
                 */
                *out = ACPI_TYPE_ANY;
                break;

        case PROP_TYPE_STRING:
                *out = ACPI_TYPE_STRING;
                break;

        case PROP_TYPE_UNKNOWN:
                *out = ACPI_TYPE_ANY;
                break;

        default:
                return false;
        }

        return true;
}

static bool
acpi_type_to_prop(ACPI_OBJECT_TYPE acpitype, prop_type_t *out)
{
        switch (acpitype) {
        case ACPI_TYPE_INTEGER:
                *out = PROP_TYPE_NUMBER;
                break;

        case ACPI_TYPE_BUFFER:
                *out = PROP_TYPE_DATA;
                break;

        case ACPI_TYPE_STRING:
                *out = PROP_TYPE_STRING;
                break;

        default:
                return false;
        }

        return true;
}

static int
acpi_device_get_property(device_t dev, devhandle_t call_handle, void *v)
{
        struct device_get_property_args *args = v;
        ACPI_HANDLE hdl = devhandle_to_acpi(call_handle);
        ACPI_OBJECT *propval;
        ACPI_OBJECT_TYPE acpitype;
        ACPI_STATUS rv;
        ACPI_BUFFER buf;
        int error = 0;

        /*
         * No need to clamp size; ACPI sizes are unsigned (UINT32),
         * and the upper layer has already clamped to fit in ssize_t.
         */

        if (! prop_type_to_acpi(args->reqtype, &acpitype)) {
                return EFTYPE;
        }

        buf.Pointer = NULL;
        buf.Length = ACPI_ALLOCATE_BUFFER;

        rv = acpi_dsd_property(hdl, args->prop, &buf, acpitype, &propval);
        if (!ACPI_SUCCESS(rv)) {
                if (rv == AE_TYPE) {
                        error = EFTYPE;
                        goto out;
                }
                error = ENOENT;
                goto out;
        }

        args->encoding = _LITTLE_ENDIAN; /* ACPI is always little-endian */
        if (! acpi_type_to_prop(propval->Type, &args->type)) {
                error = EFTYPE;
                goto out;
        }

        switch (propval->Type) {
        case ACPI_TYPE_INTEGER:
                args->propsize = sizeof(propval->Integer.Value);
                if (args->buf != NULL) {
                        /*
                         * We don't have a native boolean type, but we
                         * can test for zero and equate that to false.
                         */
                        if (args->reqtype == PROP_TYPE_BOOL) {
                                KASSERT(args->buflen == sizeof(bool));
                                *(bool *)args->buf =
                                    propval->Integer.Value != 0;
                                goto out;
                        }
                        /*
                         * DATA requests the ANY type (so that it can
                         * get STRINGs, too), so filter out non-NUMBER.
                         */
                        if (args->reqtype != PROP_TYPE_NUMBER) {
                                error = EFTYPE;
                                goto out;
                        }
                        KASSERT(args->buflen == sizeof(uint64_t));
                        *(uint64_t *)args->buf =
                            le64toh(propval->Integer.Value);
                }
                break;

        case ACPI_TYPE_STRING:
                /* +1 for trailing NUL */
                args->propsize = propval->String.Length + 1;
                if (args->buf != NULL) {
                        if (args->buflen < args->propsize) {
                                error = EFBIG;
                                goto out;
                        }
                        strlcpy(args->buf, propval->String.Pointer,
                            args->buflen);
                }
                break;

        case ACPI_TYPE_BUFFER:
                args->propsize = propval->Buffer.Length;
                if (args->buf != NULL) {
                        if (args->buflen < args->propsize) {
                                error = EFBIG;
                                goto out;
                        }
                        memcpy(args->buf, propval->Buffer.Pointer,
                            args->propsize);
                }
                break;

        default:
                error = EFTYPE;
                goto out;
        }

 out:
        if (buf.Pointer != NULL) {
                ACPI_FREE(buf.Pointer);
        }
        return error;
}
ACPI_DEVICE_CALL_REGISTER(DEVICE_GET_PROPERTY_STR,
                          acpi_device_get_property)

/*
 * Evaluate an integer object.
 */
ACPI_STATUS
acpi_eval_integer(ACPI_HANDLE handle, const char *path, ACPI_INTEGER *valp)
{
        ACPI_OBJECT obj;
        ACPI_BUFFER buf;
        ACPI_STATUS rv;

        if (handle == NULL)
                handle = ACPI_ROOT_OBJECT;

        (void)memset(&obj, 0, sizeof(obj));
        buf.Pointer = &obj;
        buf.Length = sizeof(obj);

        rv = AcpiEvaluateObject(handle, path, NULL, &buf);

        if (ACPI_FAILURE(rv))
                return rv;

        /* Check that evaluation produced a return value. */
        if (buf.Length == 0)
                return AE_NULL_OBJECT;

        if (obj.Type != ACPI_TYPE_INTEGER)
                return AE_TYPE;

        if (valp != NULL)
                *valp = obj.Integer.Value;

        return AE_OK;
}

/*
 * Evaluate an integer object with a single integer input parameter.
 */
ACPI_STATUS
acpi_eval_set_integer(ACPI_HANDLE handle, const char *path, ACPI_INTEGER val)
{
        ACPI_OBJECT_LIST arg;
        ACPI_OBJECT obj;

        if (handle == NULL)
                handle = ACPI_ROOT_OBJECT;

        obj.Type = ACPI_TYPE_INTEGER;
        obj.Integer.Value = val;

        arg.Count = 1;
        arg.Pointer = &obj;

        return AcpiEvaluateObject(handle, path, &arg, NULL);
}

/*
 * Evaluate a (Unicode) string object.
 */
ACPI_STATUS
acpi_eval_string(ACPI_HANDLE handle, const char *path, char **stringp)
{
        ACPI_OBJECT *obj;
        ACPI_BUFFER buf;
        ACPI_STATUS rv;

        rv = acpi_eval_struct(handle, path, &buf);

        if (ACPI_FAILURE(rv))
                return rv;

        obj = buf.Pointer;

        if (obj->Type != ACPI_TYPE_STRING) {
                rv = AE_TYPE;
                goto out;
        }

        if (obj->String.Length == 0) {
                rv = AE_BAD_DATA;
                goto out;
        }

        *stringp = ACPI_ALLOCATE(obj->String.Length + 1);

        if (*stringp == NULL) {
                rv = AE_NO_MEMORY;
                goto out;
        }

        (void)memcpy(*stringp, obj->String.Pointer, obj->String.Length);

        (*stringp)[obj->String.Length] = '\0';

out:
        ACPI_FREE(buf.Pointer);

        return rv;
}

/*
 * Evaluate a structure. Caller must free buf.Pointer by ACPI_FREE().
 */
ACPI_STATUS
acpi_eval_struct(ACPI_HANDLE handle, const char *path, ACPI_BUFFER *buf)
{

        if (handle == NULL)
                handle = ACPI_ROOT_OBJECT;

        buf->Pointer = NULL;
        buf->Length = ACPI_ALLOCATE_LOCAL_BUFFER;

        return AcpiEvaluateObject(handle, path, NULL, buf);
}

/*
 * Evaluate a reference handle from an element in a package.
 */
ACPI_STATUS
acpi_eval_reference_handle(ACPI_OBJECT *elm, ACPI_HANDLE *handle)
{

        if (elm == NULL || handle == NULL)
                return AE_BAD_PARAMETER;

        switch (elm->Type) {

        case ACPI_TYPE_ANY:
        case ACPI_TYPE_LOCAL_REFERENCE:

                if (elm->Reference.Handle == NULL)
                        return AE_NULL_ENTRY;

                *handle = elm->Reference.Handle;

                return AE_OK;

        case ACPI_TYPE_STRING:
                return AcpiGetHandle(NULL, elm->String.Pointer, handle);

        default:
                return AE_TYPE;
        }
}

/*
 * Iterate over all objects in a package, and pass them all
 * to a function. If the called function returns non-AE_OK,
 * the iteration is stopped and that value is returned.
 */
ACPI_STATUS
acpi_foreach_package_object(ACPI_OBJECT *pkg,
    ACPI_STATUS (*func)(ACPI_OBJECT *, void *), void *arg)
{
        ACPI_STATUS rv = AE_OK;
        uint32_t i;

        if (pkg == NULL)
                return AE_BAD_PARAMETER;

        if (pkg->Type != ACPI_TYPE_PACKAGE)
                return AE_TYPE;

        for (i = 0; i < pkg->Package.Count; i++) {

                rv = (*func)(&pkg->Package.Elements[i], arg);

                if (ACPI_FAILURE(rv))
                        break;
        }

        return rv;
}

/*
 * Fetch data info the specified (empty) ACPI buffer.
 * Caller must free buf.Pointer by ACPI_FREE().
 */
ACPI_STATUS
acpi_get(ACPI_HANDLE handle, ACPI_BUFFER *buf,
    ACPI_STATUS (*getit)(ACPI_HANDLE, ACPI_BUFFER *))
{

        buf->Pointer = NULL;
        buf->Length = ACPI_ALLOCATE_LOCAL_BUFFER;

        return (*getit)(handle, buf);
}

/*
 * Return a complete pathname from a handle.
 *
 * Note that the function uses static data storage;
 * if the data is needed for future use, it should be
 * copied before any subsequent calls overwrite it.
 */
const char *
acpi_name(ACPI_HANDLE handle)
{
        static char name[80];
        ACPI_BUFFER buf;
        ACPI_STATUS rv;

        if (handle == NULL)
                handle = ACPI_ROOT_OBJECT;

        buf.Pointer = name;
        buf.Length = sizeof(name);

        rv = AcpiGetName(handle, ACPI_FULL_PATHNAME, &buf);

        if (ACPI_FAILURE(rv))
                return "UNKNOWN";

        return name;
}

/*
 * Pack _HID and _CID ID strings into an OpenFirmware-style
 * string list.
 */
char *
acpi_pack_compat_list(struct acpi_devnode *ad, size_t *sizep)
{
        ACPI_DEVICE_INFO *devinfo = ad->ad_devinfo;

        KASSERT(sizep != NULL);

        char *sl = NULL;
        size_t slsize = 0;
        uint32_t i;
        bool dtlink = false;

        ACPI_BUFFER buf;
        ACPI_STATUS ret;
        ACPI_OBJECT *obj;
        char *compatible;
        int n;

        buf.Pointer = NULL;
        buf.Length = ACPI_ALLOCATE_BUFFER;

        if ((devinfo->Valid & ACPI_VALID_HID) != 0) {
                const char *cp = devinfo->HardwareId.String;

                if (device_compatible_pmatch_strlist(cp, strlen(cp) + 1,
                                                     dtlink_compat_data)) {
                        dtlink = true;
                } else {
                        strlist_append(&sl, &slsize, cp);
                }
        }

        if ((devinfo->Valid & ACPI_VALID_CID) != 0) {
                for (i = 0; i < devinfo->CompatibleIdList.Count; i++) {
                        const char *cp =
                            devinfo->CompatibleIdList.Ids[i].String;

                        if (device_compatible_pmatch_strlist(cp, strlen(cp) + 1,
                                                        dtlink_compat_data)) {
                                dtlink = true;
                        } else {
                                strlist_append(&sl, &slsize, cp);
                        }
                }
        }

        if (dtlink) {
                ret = acpi_dsd_string(ad->ad_handle, "compatible",
                    &compatible);
                if (ACPI_SUCCESS(ret)) {
                        strlist_append(&sl, &slsize, compatible);
                        kmem_strfree(compatible);
                        goto done;
                }

                ret = acpi_dsd_property(ad->ad_handle, "compatible", &buf,
                    ACPI_TYPE_PACKAGE, &obj);
                if (ACPI_FAILURE(ret)) {
                        goto done;
                }
                if (obj->Package.Count == 0) {
                        goto done;
                }
                for (n = 0; n < obj->Package.Count; n++) {
                        if (obj->Package.Elements[n].Type != ACPI_TYPE_STRING) {
                                continue;
                        }
                        strlist_append(&sl, &slsize,
                            obj->Package.Elements[n].String.Pointer);
                }
        }

 done:
        if (buf.Pointer != NULL) {
                ACPI_FREE(buf.Pointer);
        }
        *sizep = slsize;
        return sl;
}

/*
 * The ACPI_PNP_DEVICE_ID type is somewhat inconvenient for us to
 * use.  We'll need some temporary space to pack it into an array
 * of C strings.  Room for 8 should be plenty, but we can allocate
 * more if necessary.
 */
#define ACPI_COMPATSTR_MAX      8

static const char **
acpi_compatible_alloc_strarray(ACPI_PNP_DEVICE_ID *ids,
    unsigned int count, const char **buf)
{
        unsigned int i;

        buf = kmem_tmpbuf_alloc(count * sizeof(const char *),
            buf, ACPI_COMPATSTR_MAX * sizeof(const char *), KM_SLEEP);
        for (i = 0; i < count; i++) {
                buf[i] = ids[i].String;
        }
        return buf;
}

static void
acpi_compatible_free_strarray(const char **cpp, unsigned int count,
    const char **buf)
{
        kmem_tmpbuf_free(cpp, count * sizeof(const char *), buf);
}

static int
acpi_compatible_match_dtlink(const struct acpi_attach_args * const aa,
    const struct device_compatible_entry * const dce)
{
        const char *strings[ACPI_COMPATSTR_MAX * sizeof(const char *)];
        ACPI_HANDLE handle = aa->aa_node->ad_handle;
        ACPI_BUFFER buf;
        char *compatible;
        ACPI_STATUS ret;
        ACPI_OBJECT *obj;
        int rv = 0, n;

        buf.Pointer = NULL;
        buf.Length = ACPI_ALLOCATE_BUFFER;

        /* Match a single string _DSD value */
        ret = acpi_dsd_string(handle, "compatible", &compatible);
        if (ACPI_SUCCESS(ret)) {
                strings[0] = compatible;
                rv = device_compatible_pmatch(strings, 1, dce);
                kmem_strfree(compatible);
                goto done;
        }

        /* Match from a list of strings in a _DSD value */
        ret = acpi_dsd_property(handle, "compatible", &buf,
            ACPI_TYPE_PACKAGE, &obj);
        if (ACPI_FAILURE(ret)) {
                goto done;
        }
        if (obj->Package.Count == 0) {
                goto done;
        }
        for (n = 0; n < imin(obj->Package.Count, ACPI_COMPATSTR_MAX); n++) {
                if (obj->Package.Elements[n].Type != ACPI_TYPE_STRING) {
                        goto done;
                }
                strings[n] = obj->Package.Elements[n].String.Pointer;
        }
        rv = device_compatible_pmatch(strings, n, dce);

done:
        if (buf.Pointer != NULL) {
                ACPI_FREE(buf.Pointer);
        }
        if (rv) {
                rv = (rv - 1) + ACPI_MATCHSCORE_CID;
                return imin(rv, ACPI_MATCHSCORE_CID_MAX);
        }
        return 0;
}

/*
 * acpi_compatible_match --
 *
 *      Returns a weighted match value, comparing the _HID and _CID
 *      IDs against a driver's compatibility data.
 */
int
acpi_compatible_match(const struct acpi_attach_args * const aa,
    const struct device_compatible_entry * const dce)
{
        const char *strings[ACPI_COMPATSTR_MAX * sizeof(const char *)];
        const char **cpp;
        bool dtlink = false;
        int rv;

        if (aa->aa_node->ad_type != ACPI_TYPE_DEVICE) {
                return 0;
        }

        ACPI_DEVICE_INFO *ad = aa->aa_node->ad_devinfo;

        if ((ad->Valid & ACPI_VALID_HID) != 0) {
                strings[0] = ad->HardwareId.String;

                /* Matching _HID wins big. */
                if (device_compatible_pmatch(strings, 1, dce) != 0) {
                        return ACPI_MATCHSCORE_HID;
                }

                if (device_compatible_pmatch(strings, 1,
                                             dtlink_compat_data) != 0) {
                        dtlink = true;
                }
        }

        if ((ad->Valid & ACPI_VALID_CID) != 0) {
                cpp = acpi_compatible_alloc_strarray(ad->CompatibleIdList.Ids,
                    ad->CompatibleIdList.Count, strings);

                rv = device_compatible_pmatch(cpp,
                    ad->CompatibleIdList.Count, dce);
                if (!dtlink &&
                    device_compatible_pmatch(cpp, ad->CompatibleIdList.Count,
                                             dtlink_compat_data) != 0) {
                        dtlink = true;
                }
                acpi_compatible_free_strarray(cpp, ad->CompatibleIdList.Count,
                    strings);
                if (rv) {
                        rv = (rv - 1) + ACPI_MATCHSCORE_CID;
                        return imin(rv, ACPI_MATCHSCORE_CID_MAX);
                }
        }

        if (dtlink) {
                return acpi_compatible_match_dtlink(aa, dce);
        }

        return 0;
}

/*
 * acpi_compatible_lookup --
 *
 *      Returns the device_compatible_entry that matches the _HID
 *      or _CID ID.
 */
const struct device_compatible_entry *
acpi_compatible_lookup(const struct acpi_attach_args * const aa,
    const struct device_compatible_entry * const dce)
{
        const struct device_compatible_entry *rv = NULL;
        const char *strings[ACPI_COMPATSTR_MAX];
        const char **cpp;

        if (aa->aa_node->ad_type != ACPI_TYPE_DEVICE) {
                return NULL;
        }

        ACPI_DEVICE_INFO *ad = aa->aa_node->ad_devinfo;

        if ((ad->Valid & ACPI_VALID_HID) != 0) {
                strings[0] = ad->HardwareId.String;

                rv = device_compatible_plookup(strings, 1, dce);
                if (rv != NULL)
                        return rv;
        }

        if ((ad->Valid & ACPI_VALID_CID) != 0) {
                cpp = acpi_compatible_alloc_strarray(ad->CompatibleIdList.Ids,
                    ad->CompatibleIdList.Count, strings);

                rv = device_compatible_plookup(cpp,
                    ad->CompatibleIdList.Count, dce);
                acpi_compatible_free_strarray(cpp, ad->CompatibleIdList.Count,
                    strings);
        }

        return rv;
}

/*
 * Match given IDs against _HID and _CIDs.
 */
int
acpi_match_hid(ACPI_DEVICE_INFO *ad, const char * const *ids)
{
        uint32_t i, n;
        char *id;

        while (*ids) {

                if ((ad->Valid & ACPI_VALID_HID) != 0) {

                        if (pmatch(ad->HardwareId.String, *ids, NULL) == 2)
                                return 1;
                }

                if ((ad->Valid & ACPI_VALID_CID) != 0) {

                        n = ad->CompatibleIdList.Count;

                        for (i = 0; i < n; i++) {

                                id = ad->CompatibleIdList.Ids[i].String;

                                if (pmatch(id, *ids, NULL) == 2)
                                        return 1;
                        }
                }

                ids++;
        }

        return 0;
}

/*
 * Match a PCI-defined bass-class, sub-class, and programming interface
 * against a handle's _CLS object.
 */
int
acpi_match_class(ACPI_HANDLE handle, uint8_t pci_class, uint8_t pci_subclass,
    uint8_t pci_interface)
{
        ACPI_BUFFER buf;
        ACPI_OBJECT *obj;
        ACPI_STATUS rv;
        int match = 0;

        rv = acpi_eval_struct(handle, "_CLS", &buf);
        if (ACPI_FAILURE(rv))
                goto done;

        obj = buf.Pointer;
        if (obj->Type != ACPI_TYPE_PACKAGE)
                goto done;
        if (obj->Package.Count != 3)
                goto done;
        if (obj->Package.Elements[0].Type != ACPI_TYPE_INTEGER ||
            obj->Package.Elements[1].Type != ACPI_TYPE_INTEGER ||
            obj->Package.Elements[2].Type != ACPI_TYPE_INTEGER)
                goto done;

        match = obj->Package.Elements[0].Integer.Value == pci_class &&
                obj->Package.Elements[1].Integer.Value == pci_subclass &&
                obj->Package.Elements[2].Integer.Value == pci_interface;

done:
        if (buf.Pointer)
                ACPI_FREE(buf.Pointer);
        return match ? ACPI_MATCHSCORE_CLS : 0;
}

/*
 * Match a device node from a handle.
 */
struct acpi_devnode *
acpi_match_node(ACPI_HANDLE handle)
{
        struct acpi_devnode *ad;
        ACPI_STATUS rv;

        if (handle == NULL)
                return NULL;

        rv = AcpiGetData(handle, acpi_clean_node, (void **)&ad);

        if (ACPI_FAILURE(rv))
                return NULL;

        return ad;
}

/*
 * Permanently associate a device node with a handle.
 */
void
acpi_match_node_init(struct acpi_devnode *ad)
{
        (void)AcpiAttachData(ad->ad_handle, acpi_clean_node, ad);
}

static void
acpi_clean_node(ACPI_HANDLE handle, void *aux)
{
        /* Nothing. */
}

/*
 * Match a handle from a cpu_info. Returns NULL on failure.
 *
 * Note that acpi_match_node() can be used if the device node
 * is also required.
 */
ACPI_HANDLE
acpi_match_cpu_info(struct cpu_info *ci)
{
        struct acpi_softc *sc = acpi_softc;
        struct acpi_devnode *ad;
        ACPI_INTEGER val;
        ACPI_OBJECT *obj;
        ACPI_BUFFER buf;
        ACPI_HANDLE hdl;
        ACPI_STATUS rv;

        if (sc == NULL)
                return NULL;

        /*
         * CPUs are declared in the ACPI namespace
         * either as a Processor() or as a Device().
         * In both cases the MADT entries are used
         * for the match (see ACPI 4.0, section 8.4).
         */
        SIMPLEQ_FOREACH(ad, &sc->sc_head, ad_list) {

                hdl = ad->ad_handle;

                switch (ad->ad_type) {

                case ACPI_TYPE_DEVICE:

                        if (acpi_match_hid(ad->ad_devinfo, acpicpu_ids) == 0)
                                break;

                        rv = acpi_eval_integer(hdl, "_UID", &val);

                        if (ACPI_SUCCESS(rv) && val == ci->ci_acpiid)
                                return hdl;

                        break;

                case ACPI_TYPE_PROCESSOR:

                        rv = acpi_eval_struct(hdl, NULL, &buf);

                        if (ACPI_FAILURE(rv))
                                break;

                        obj = buf.Pointer;

                        if (obj->Processor.ProcId == ci->ci_acpiid) {
                                ACPI_FREE(buf.Pointer);
                                return hdl;
                        }

                        ACPI_FREE(buf.Pointer);
                        break;
                }
        }

        return NULL;
}

/*
 * Match a CPU from a handle. Returns NULL on failure.
 */
struct cpu_info *
acpi_match_cpu_handle(ACPI_HANDLE hdl)
{
        struct cpu_info *ci;
        ACPI_DEVICE_INFO *di;
        CPU_INFO_ITERATOR cii;
        ACPI_INTEGER val;
        ACPI_OBJECT *obj;
        ACPI_BUFFER buf;
        ACPI_STATUS rv;

        ci = NULL;
        di = NULL;
        buf.Pointer = NULL;

        rv = AcpiGetObjectInfo(hdl, &di);

        if (ACPI_FAILURE(rv))
                return NULL;

        switch (di->Type) {

        case ACPI_TYPE_DEVICE:

                if (acpi_match_hid(di, acpicpu_ids) == 0)
                        goto out;

                rv = acpi_eval_integer(hdl, "_UID", &val);

                if (ACPI_FAILURE(rv))
                        goto out;

                break;

        case ACPI_TYPE_PROCESSOR:

                rv = acpi_eval_struct(hdl, NULL, &buf);

                if (ACPI_FAILURE(rv))
                        goto out;

                obj = buf.Pointer;
                val = obj->Processor.ProcId;
                break;

        default:
                goto out;
        }

        for (CPU_INFO_FOREACH(cii, ci)) {

                if (ci->ci_acpiid == val)
                        goto out;
        }

        ci = NULL;

out:
        if (di != NULL)
                ACPI_FREE(di);

        if (buf.Pointer != NULL)
                ACPI_FREE(buf.Pointer);

        return ci;
}

struct acpi_irq_handler {
        uint32_t aih_irq;
        void *aih_ih;
};

void *
acpi_intr_establish(device_t dev, uint64_t c, int ipl, bool mpsafe,
    int (*intr)(void *), void *iarg, const char *xname)
{
        ACPI_STATUS rv;
        ACPI_HANDLE hdl = (void *)(uintptr_t)c;
        struct acpi_resources res;
        struct acpi_irq *irq;
        void *aih = NULL;

        rv = acpi_resource_parse(dev, hdl, "_CRS", &res,
            &acpi_resource_parse_ops_quiet);
        if (ACPI_FAILURE(rv))
                return NULL;

        irq = acpi_res_irq(&res, 0);
        if (irq == NULL)
                goto end;

        aih = acpi_intr_establish_irq(dev, irq, ipl, mpsafe,
            intr, iarg, xname);

end:
        acpi_resource_cleanup(&res);

        return aih;
}

void *
acpi_intr_establish_irq(device_t dev, struct acpi_irq *irq, int ipl,
    bool mpsafe, int (*intr)(void *), void *iarg, const char *xname)
{
        struct acpi_irq_handler *aih;
        void *ih;

        const int type = (irq->ar_type == ACPI_EDGE_SENSITIVE) ? IST_EDGE : IST_LEVEL;
        ih = acpi_md_intr_establish(irq->ar_irq, ipl, type, intr, iarg, mpsafe, xname);
        if (ih == NULL)
                return NULL;

        aih = kmem_alloc(sizeof(struct acpi_irq_handler), KM_SLEEP);
        aih->aih_irq = irq->ar_irq;
        aih->aih_ih = ih;

        return aih;
}

void
acpi_intr_mask(void *c)
{
        struct acpi_irq_handler * const aih = c;

        acpi_md_intr_mask(aih->aih_ih);
}

void
acpi_intr_unmask(void *c)
{
        struct acpi_irq_handler * const aih = c;

        acpi_md_intr_unmask(aih->aih_ih);
}

void
acpi_intr_disestablish(void *c)
{
        struct acpi_irq_handler *aih = c;

        acpi_md_intr_disestablish(aih->aih_ih);
        kmem_free(aih, sizeof(struct acpi_irq_handler));
}

const char *
acpi_intr_string(void *c, char *buf, size_t size)
{
        struct acpi_irq_handler *aih = c;
        intr_handle_t ih = aih->aih_irq;

        return intr_string(ih, buf, size);
}

/*
 * Device-Specific Data (_DSD) support
 */

static UINT8 acpi_dsd_uuid[ACPI_UUID_LENGTH] = {
        0x14, 0xd8, 0xff, 0xda, 0xba, 0x6e, 0x8c, 0x4d,
        0x8a, 0x91, 0xbc, 0x9b, 0xbf, 0x4a, 0xa3, 0x01
};

static ACPI_STATUS
acpi_dsd_property(ACPI_HANDLE handle, const char *prop, ACPI_BUFFER *pbuf, ACPI_OBJECT_TYPE type, ACPI_OBJECT **ret)
{
        ACPI_OBJECT *obj, *uuid, *props, *pobj, *propkey, *propval;
        ACPI_STATUS rv;
        int n;

        rv = AcpiEvaluateObjectTyped(handle, "_DSD", NULL, pbuf, ACPI_TYPE_PACKAGE);
        if (ACPI_FAILURE(rv))
                return rv;

        props = NULL;
        obj = (ACPI_OBJECT *)pbuf->Pointer;
        for (n = 0; (n + 1) < obj->Package.Count; n += 2) {
                uuid = &obj->Package.Elements[n];
                if (uuid->Buffer.Length == ACPI_UUID_LENGTH &&
                    memcmp(uuid->Buffer.Pointer, acpi_dsd_uuid, ACPI_UUID_LENGTH) == 0) {
                        props = &obj->Package.Elements[n + 1];
                        break;
                }
        }
        if (props == NULL)
                return AE_NOT_FOUND;

        for (n = 0; n < props->Package.Count; n++) {
                pobj = &props->Package.Elements[n];
                if (pobj->Type != ACPI_TYPE_PACKAGE || pobj->Package.Count != 2)
                        continue;
                propkey = (ACPI_OBJECT *)&pobj->Package.Elements[0];
                propval = (ACPI_OBJECT *)&pobj->Package.Elements[1];
                if (propkey->Type != ACPI_TYPE_STRING)
                        continue;
                if (strcmp(propkey->String.Pointer, prop) != 0)
                        continue;

                if (type != ACPI_TYPE_ANY && propval->Type != type) {
                        return AE_TYPE;
                } else {
                        *ret = propval;
                        return AE_OK;
                }
                break;
        }

        return AE_NOT_FOUND;
}

ACPI_STATUS
acpi_dsd_integer(ACPI_HANDLE handle, const char *prop, ACPI_INTEGER *val)
{
        ACPI_OBJECT *propval;
        ACPI_STATUS rv;
        ACPI_BUFFER buf;

        buf.Pointer = NULL;
        buf.Length = ACPI_ALLOCATE_BUFFER;

        rv = acpi_dsd_property(handle, prop, &buf, ACPI_TYPE_INTEGER, &propval);
        if (ACPI_SUCCESS(rv))
                *val = propval->Integer.Value;

        if (buf.Pointer != NULL)
                ACPI_FREE(buf.Pointer);
        return rv;
}

ACPI_STATUS
acpi_dsd_string(ACPI_HANDLE handle, const char *prop, char **val)
{
        ACPI_OBJECT *propval;
        ACPI_STATUS rv;
        ACPI_BUFFER buf;

        buf.Pointer = NULL;
        buf.Length = ACPI_ALLOCATE_BUFFER;

        rv = acpi_dsd_property(handle, prop, &buf, ACPI_TYPE_STRING, &propval);
        if (ACPI_SUCCESS(rv))
                *val = kmem_strdup(propval->String.Pointer, KM_SLEEP);

        if (buf.Pointer != NULL)
                ACPI_FREE(buf.Pointer);
        return rv;
}

ACPI_STATUS
acpi_dsd_bool(ACPI_HANDLE handle, const char *prop, bool *val)
{
        ACPI_STATUS rv;
        ACPI_INTEGER ival;

        rv = acpi_dsd_integer(handle, prop, &ival);
        if (ACPI_SUCCESS(rv)) {
                *val = ival != 0;
        }

        return rv;
}


/*
 * Device Specific Method (_DSM) support
 */

ACPI_STATUS
acpi_dsm_typed(ACPI_HANDLE handle, uint8_t *uuid, ACPI_INTEGER rev,
    ACPI_INTEGER func, const ACPI_OBJECT *arg3, ACPI_OBJECT_TYPE return_type,
    ACPI_OBJECT **return_obj)
{
        ACPI_OBJECT_LIST arg;
        ACPI_OBJECT obj[4];
        ACPI_BUFFER buf;
        ACPI_STATUS status;

        arg.Count = 4;
        arg.Pointer = obj;

        obj[0].Type = ACPI_TYPE_BUFFER;
        obj[0].Buffer.Length = ACPI_UUID_LENGTH;
        obj[0].Buffer.Pointer = uuid;

        obj[1].Type = ACPI_TYPE_INTEGER;
        obj[1].Integer.Value = rev;

        obj[2].Type = ACPI_TYPE_INTEGER;
        obj[2].Integer.Value = func;

        if (arg3 != NULL) {
                obj[3] = *arg3;
        } else {
                obj[3].Type = ACPI_TYPE_PACKAGE;
                obj[3].Package.Count = 0;
                obj[3].Package.Elements = NULL;
        }

        buf.Pointer = NULL;
        buf.Length = ACPI_ALLOCATE_BUFFER;

        if (return_obj == NULL && return_type == ACPI_TYPE_ANY) {
                status = AcpiEvaluateObject(handle, "_DSM", &arg, NULL);
        } else {
                *return_obj = NULL;
                status = AcpiEvaluateObjectTyped(handle, "_DSM", &arg, &buf,
                    return_type);
        }
        if (ACPI_FAILURE(status)) {
                return status;
        }
        if (return_obj != NULL) {
                *return_obj = buf.Pointer;
        } else if (buf.Pointer != NULL) {
                ACPI_FREE(buf.Pointer);
        }
        return AE_OK;
}

ACPI_STATUS
acpi_dsm_integer(ACPI_HANDLE handle, uint8_t *uuid, ACPI_INTEGER rev,
    ACPI_INTEGER func, const ACPI_OBJECT *arg3, ACPI_INTEGER *ret)
{
        ACPI_OBJECT *obj;
        ACPI_STATUS status;

        status = acpi_dsm_typed(handle, uuid, rev, func, arg3,
            ACPI_TYPE_INTEGER, &obj);
        if (ACPI_FAILURE(status)) {
                return status;
        }

        *ret = obj->Integer.Value;
        ACPI_FREE(obj);

        return AE_OK;
}

ACPI_STATUS
acpi_dsm(ACPI_HANDLE handle, uint8_t *uuid, ACPI_INTEGER rev,
    ACPI_INTEGER func, const ACPI_OBJECT *arg3, ACPI_OBJECT **return_obj)
{
        return acpi_dsm_typed(handle, uuid, rev, func, arg3, ACPI_TYPE_ANY,
            return_obj);
}

ACPI_STATUS
acpi_dsm_query(ACPI_HANDLE handle, uint8_t *uuid, ACPI_INTEGER rev,
    ACPI_INTEGER *ret)
{
        ACPI_OBJECT *obj;
        ACPI_STATUS status;
        uint8_t *data;
        u_int n;

        status = acpi_dsm(handle, uuid, rev, 0, NULL, &obj);
        if (ACPI_FAILURE(status)) {
                return status;
        }

        if (obj->Type == ACPI_TYPE_INTEGER) {
                *ret = obj->Integer.Value;
        } else if (obj->Type == ACPI_TYPE_BUFFER &&
                   obj->Buffer.Length <= 8) {
                *ret = 0;
                data = (uint8_t *)obj->Buffer.Pointer;
                for (n = 0; n < obj->Buffer.Length; n++) {
                        *ret |= (uint64_t)data[n] << (n * 8);
                }
        } else {
                status = AE_TYPE;
        }

        ACPI_FREE(obj);

        return status;
}

ACPI_STATUS
acpi_claim_childdevs(device_t dev, struct acpi_devnode *devnode,
    const char *method)
{
        struct acpi_devnode *ad;

        SIMPLEQ_FOREACH(ad, &devnode->ad_child_head, ad_child_list) {
                if (ad->ad_device != NULL)
                        continue;

                if (method != NULL) {
                        ACPI_HANDLE h;
                        ACPI_STATUS rv;

                        rv = AcpiGetHandle(ad->ad_handle, method, &h);
                        if (ACPI_FAILURE(rv)) {
                                continue;
                        }
                }

                aprint_debug_dev(dev, "claiming %s\n",
                    acpi_name(ad->ad_handle));
                ad->ad_device = dev;
                acpi_claim_childdevs(dev, ad, method);
        }

        return AE_OK;
}