// SPDX-License-Identifier: GPL-2.0-only OR MIT
/* Copyright 2022 Sven Peter <sven@svenpeter.dev> */

#include <linux/completion.h>

#include "afk.h"
#include "dcp.h"
#include "parser.h"

static bool enable_verbose_logging;
module_param(enable_verbose_logging, bool, 0644);
MODULE_PARM_DESC(enable_verbose_logging, "Enable DCP firmware verbose logging");

/*
 * Serialized setProperty("gAFKConfigLogMask", 0xffff) IPC call which
 * will set the DCP firmware log level to the most verbose setting
 */
#define SYSTEM_SET_PROPERTY 0x43
static const u8 setprop_gAFKConfigLogMask_ffff[] = {
        0x14, 0x00, 0x00, 0x00, 0x67, 0x41, 0x46, 0x4b, 0x43, 0x6f,
        0x6e, 0x66, 0x69, 0x67, 0x4c, 0x6f, 0x67, 0x4d, 0x61, 0x73,
        0x6b, 0x00, 0x00, 0x00, 0xd3, 0x00, 0x00, 0x00, 0x40, 0x00,
        0x00, 0x84, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

struct systemep_work {
        struct apple_epic_service *service;
        struct work_struct work;
};

static void system_log_work(struct work_struct *work_)
{
        struct systemep_work *work =
                container_of(work_, struct systemep_work, work);

        afk_send_command(work->service, SYSTEM_SET_PROPERTY,
                         setprop_gAFKConfigLogMask_ffff,
                         sizeof(setprop_gAFKConfigLogMask_ffff), NULL,
                         sizeof(setprop_gAFKConfigLogMask_ffff), NULL);
        complete(&work->service->ep->dcp->systemep_done);
        kfree(work);
}

static void system_init(struct apple_epic_service *service, const char *name,
                        const char *class, s64 unit)
{
        struct systemep_work *work;

        if (!enable_verbose_logging)
                return;

        /*
         * We're called from the service message handler thread and can't
         * dispatch blocking message from there.
         */
        work = kzalloc(sizeof(*work), GFP_KERNEL);
        if (!work)
                return;

        work->service = service;
        INIT_WORK(&work->work, system_log_work);
        schedule_work(&work->work);
}

static void powerlog_init(struct apple_epic_service *service, const char *name,
                          const char *class, s64 unit)
{
}

static int powerlog_report(struct apple_epic_service *service, enum epic_subtype type,
                         const void *data, size_t data_size)
{
        struct dcp_system_ev_mnits mnits;
        struct dcp_parse_ctx parse_ctx;
        struct apple_dcp *dcp = service->ep->dcp;
        int ret;

        dev_dbg(dcp->dev, "systemep[ch:%u]: report type:%02x len:%zu\n",
                service->channel, type, data_size);

        if (type != EPIC_SUBTYPE_STD_SERVICE)
                return 0;

        ret = parse(data, data_size, &parse_ctx);
        if (ret) {
                dev_warn(service->ep->dcp->dev, "systemep: failed to parse report: %d\n", ret);
                return ret;
        }

        ret = parse_system_log_mnits(&parse_ctx, &mnits);
        if (ret) {
                /* ignore parse errors in the case dcp sends unknown log events */
                dev_dbg(dcp->dev, "systemep: failed to parse mNits event: %d\n", ret);
                return 0;
        }

        dev_dbg(dcp->dev, "systemep: mNits event: Nits: %u.%03u, iDAC: %u\n",
                mnits.millinits / 1000, mnits.millinits % 1000, mnits.idac);

        dcp->brightness.nits = mnits.millinits / 1000;

        return 0;
}

static const struct apple_epic_service_ops systemep_ops[] = {
        {
                .name = "system",
                .init = system_init,
        },
        {
                .name = "powerlog-service",
                .init = powerlog_init,
                .report = powerlog_report,
        },
        {}
};

int systemep_init(struct apple_dcp *dcp)
{
        init_completion(&dcp->systemep_done);

        dcp->systemep = afk_init(dcp, SYSTEM_ENDPOINT, systemep_ops);
        afk_start(dcp->systemep);

        if (!enable_verbose_logging)
                return 0;

        /*
         * Timeouts aren't really fatal here: in the worst case we just weren't
         * able to enable additional debug prints inside DCP
         */
        if (!wait_for_completion_timeout(&dcp->systemep_done,
                                         msecs_to_jiffies(MSEC_PER_SEC)))
                dev_err(dcp->dev, "systemep: couldn't enable verbose logs\n");

        return 0;
}