/*
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2026 Abdelkader Boudih <dragonflybsd@seuros.com>
 *
 * Apple DTGP / _DSM device property extraction.
 *
 * Walks the ACPI namespace looking for devices with _DSM methods,
 * evaluates them with Apple's DTGP UUID, and parses the returned
 * key-value property packages.
 */

#include <sys/uuid.h>

#include "apple_fw.h"

#define APPLE_DTGP_UUID_STRING  "a0b5b7c6-1318-441c-b0c9-fe695eaf949b"

static uint8_t apple_dtgp_uuid[ACPI_UUID_LENGTH];
static int apple_dtgp_uuid_ready;

static void
apple_fw_init_uuid(void)
{
        struct uuid uuid;

        if (apple_dtgp_uuid_ready)
                return;
        if (parse_uuid(APPLE_DTGP_UUID_STRING, &uuid) != 0)
                return;
        le_uuid_enc(apple_dtgp_uuid, &uuid);
        apple_dtgp_uuid_ready = 1;
}

/*
 * Evaluate _DSM on the given handle with Apple's DTGP UUID.
 * func=0: query supported functions (returns buffer with bitmask)
 * func=1: get device properties (returns package of key/value pairs)
 */
static ACPI_STATUS
apple_fw_eval_dsm(ACPI_HANDLE handle, int func, ACPI_BUFFER *result)
{
        ACPI_OBJECT args[4];
        ACPI_OBJECT_LIST arg_list;

        args[0].Type = ACPI_TYPE_BUFFER;
        args[0].Buffer.Length = ACPI_UUID_LENGTH;
        args[0].Buffer.Pointer = apple_dtgp_uuid;

        args[1].Type = ACPI_TYPE_INTEGER;
        args[1].Integer.Value = 1;      /* Revision */

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

        args[3].Type = ACPI_TYPE_PACKAGE;
        args[3].Package.Count = 0;
        args[3].Package.Elements = NULL;

        arg_list.Count = 4;
        arg_list.Pointer = args;

        result->Length = ACPI_ALLOCATE_BUFFER;
        result->Pointer = NULL;

        return (AcpiEvaluateObject(handle, "_DSM", &arg_list, result));
}

/*
 * Parse a package returned by Apple _DSM.
 * Format: alternating key (String), value (Integer/String/Buffer) pairs.
 */
static void
apple_fw_parse_dsm_props(device_t dev, struct apple_fw_dsm_dev *ddev,
    ACPI_OBJECT *pkg)
{
        ACPI_OBJECT *elem;
        uint32_t i;
        int n;

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

        for (i = 0; i + 1 < pkg->Package.Count; i += 2) {
                if (ddev->prop_count >= APPLE_FW_MAX_PROPS)
                        break;

                elem = &pkg->Package.Elements[i];
                if (elem->Type != ACPI_TYPE_STRING)
                        continue;

                n = ddev->prop_count;
                strlcpy(ddev->props[n].key, elem->String.Pointer,
                    sizeof(ddev->props[n].key));

                elem = &pkg->Package.Elements[i + 1];
                switch (elem->Type) {
                case ACPI_TYPE_INTEGER:
                        ddev->props[n].val_type = APPLE_FW_PROP_INT;
                        ddev->props[n].ival = (int64_t)elem->Integer.Value;
                        ddev->props[n].val_len = sizeof(int64_t);
                        break;
                case ACPI_TYPE_STRING:
                        ddev->props[n].val_type = APPLE_FW_PROP_STRING;
                        strlcpy(ddev->props[n].sval, elem->String.Pointer,
                            sizeof(ddev->props[n].sval));
                        ddev->props[n].val_len = elem->String.Length;
                        break;
                case ACPI_TYPE_BUFFER:
                        ddev->props[n].val_type = APPLE_FW_PROP_BUFFER;
                        ddev->props[n].val_len =
                            MIN(elem->Buffer.Length, APPLE_FW_MAX_PROPVAL);
                        memcpy(ddev->props[n].bval, elem->Buffer.Pointer,
                            ddev->props[n].val_len);
                        break;
                default:
                        continue;
                }
                ddev->prop_count++;
        }
}

/*
 * Namespace walk callback: check each device for _DSM with DTGP UUID.
 */
static ACPI_STATUS
apple_fw_dsm_walk_cb(ACPI_HANDLE handle, UINT32 level, void *context,
    void **retval)
{
        device_t dev = (device_t)context;
        struct apple_fw_softc *sc = device_get_softc(dev);
        struct apple_fw_dsm_dev *ddev;
        ACPI_HANDLE dsm_handle;
        ACPI_STATUS status;
        ACPI_BUFFER result;
        ACPI_BUFFER pathbuf;
        ACPI_OBJECT *obj;
        ACPI_DEVICE_INFO *info;
        char namebuf[256];

        /* Check if this device has a _DSM method */
        status = AcpiGetHandle(handle, "_DSM", &dsm_handle);
        if (ACPI_FAILURE(status))
                return (AE_OK); /* Skip, keep walking */

        /* Try evaluating _DSM with DTGP UUID, function 1 */
        status = apple_fw_eval_dsm(handle, 1, &result);
        if (ACPI_FAILURE(status) || result.Pointer == NULL)
                return (AE_OK);

        obj = (ACPI_OBJECT *)result.Pointer;

        /*
         * Apple _DSM returns either a Package (properties) or Integer
         * (error/not-supported).  Only packages contain useful data.
         */
        if (!ACPI_PKG_VALID(obj, 2)) {
                AcpiOsFree(result.Pointer);
                return (AE_OK);
        }

        if (sc->sc_dsm_count >= APPLE_FW_MAX_DSM_DEVS) {
                AcpiOsFree(result.Pointer);
                return (AE_OK);
        }

        ddev = &sc->sc_dsm_devs[sc->sc_dsm_count];
        memset(ddev, 0, sizeof(*ddev));

        /* Get full ACPI path */
        pathbuf.Length = sizeof(namebuf);
        pathbuf.Pointer = namebuf;
        status = AcpiGetName(handle, ACPI_FULL_PATHNAME, &pathbuf);
        if (ACPI_SUCCESS(status))
                strlcpy(ddev->path, namebuf, sizeof(ddev->path));

        /* Get short name from device info */
        status = AcpiGetObjectInfo(handle, &info);
        if (ACPI_SUCCESS(status)) {
                if (info->Valid & ACPI_VALID_HID)
                        strlcpy(ddev->name, info->HardwareId.String,
                            sizeof(ddev->name));
                AcpiOsFree(info);
        }

        /* If no HID, use the ACPI single-segment name */
        if (ddev->name[0] == '\0') {
                ACPI_BUFFER nbuf;
                char snbuf[8];

                nbuf.Length = sizeof(snbuf);
                nbuf.Pointer = snbuf;
                if (ACPI_SUCCESS(AcpiGetName(handle, ACPI_SINGLE_NAME, &nbuf)))
                        strlcpy(ddev->name, snbuf, sizeof(ddev->name));
        }

        /* Parse the property package */
        apple_fw_parse_dsm_props(dev, ddev, obj);
        AcpiOsFree(result.Pointer);

        if (ddev->prop_count > 0)
                sc->sc_dsm_count++;

        return (AE_OK);
}

void
apple_fw_discover_dsm_devices(device_t dev)
{
        struct apple_fw_softc *sc = device_get_softc(dev);

        sc->sc_dsm_count = 0;

        apple_fw_init_uuid();

        AcpiWalkNamespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, 100,
            apple_fw_dsm_walk_cb, NULL, dev, NULL);
}