// SPDX-License-Identifier: MIT
/*
 * Copyright (c) 2024 Linaro Ltd
 */

#include <linux/export.h>
#include <linux/mutex.h>
#include <linux/of_graph.h>
#include <linux/platform_device.h>

#include <drm/drm_connector.h>
#include <drm/drm_device.h>
#include <drm/display/drm_hdmi_audio_helper.h>

#include <sound/hdmi-codec.h>

static int drm_connector_hdmi_audio_startup(struct device *dev, void *data)
{
        struct drm_connector *connector = data;
        const struct drm_connector_hdmi_audio_funcs *funcs =
                connector->hdmi_audio.funcs;

        if (funcs->startup)
                return funcs->startup(connector);

        return 0;
}

static int drm_connector_hdmi_audio_prepare(struct device *dev, void *data,
                                            struct hdmi_codec_daifmt *fmt,
                                            struct hdmi_codec_params *hparms)
{
        struct drm_connector *connector = data;
        const struct drm_connector_hdmi_audio_funcs *funcs =
                connector->hdmi_audio.funcs;

        return funcs->prepare(connector, fmt, hparms);
}

static void drm_connector_hdmi_audio_shutdown(struct device *dev, void *data)
{
        struct drm_connector *connector = data;
        const struct drm_connector_hdmi_audio_funcs *funcs =
                connector->hdmi_audio.funcs;

        return funcs->shutdown(connector);
}

static int drm_connector_hdmi_audio_mute_stream(struct device *dev, void *data,
                                                bool enable, int direction)
{
        struct drm_connector *connector = data;
        const struct drm_connector_hdmi_audio_funcs *funcs =
                connector->hdmi_audio.funcs;

        if (funcs->mute_stream)
                return funcs->mute_stream(connector, enable, direction);

        return -ENOTSUPP;
}

static int drm_connector_hdmi_audio_get_dai_id(struct snd_soc_component *comment,
                                               struct device_node *endpoint,
                                               void *data)
{
        struct drm_connector *connector = data;
        struct of_endpoint of_ep;
        int ret;

        if (connector->hdmi_audio.dai_port < 0)
                return -ENOTSUPP;

        ret = of_graph_parse_endpoint(endpoint, &of_ep);
        if (ret < 0)
                return ret;

        if (of_ep.port == connector->hdmi_audio.dai_port)
                return 0;

        return -EINVAL;
}

static int drm_connector_hdmi_audio_get_eld(struct device *dev, void *data,
                                            uint8_t *buf, size_t len)
{
        struct drm_connector *connector = data;

        mutex_lock(&connector->eld_mutex);
        memcpy(buf, connector->eld, min(sizeof(connector->eld), len));
        mutex_unlock(&connector->eld_mutex);

        return 0;
}

static int drm_connector_hdmi_audio_hook_plugged_cb(struct device *dev,
                                                    void *data,
                                                    hdmi_codec_plugged_cb fn,
                                                    struct device *codec_dev)
{
        struct drm_connector *connector = data;

        mutex_lock(&connector->hdmi_audio.lock);

        connector->hdmi_audio.plugged_cb = fn;
        connector->hdmi_audio.plugged_cb_dev = codec_dev;

        if (fn)
                fn(codec_dev, connector->hdmi_audio.last_state);

        mutex_unlock(&connector->hdmi_audio.lock);

        return 0;
}

void drm_connector_hdmi_audio_plugged_notify(struct drm_connector *connector,
                                             bool plugged)
{
        mutex_lock(&connector->hdmi_audio.lock);

        connector->hdmi_audio.last_state = plugged;

        if (connector->hdmi_audio.plugged_cb &&
            connector->hdmi_audio.plugged_cb_dev)
                connector->hdmi_audio.plugged_cb(connector->hdmi_audio.plugged_cb_dev,
                                                 connector->hdmi_audio.last_state);

        mutex_unlock(&connector->hdmi_audio.lock);
}
EXPORT_SYMBOL(drm_connector_hdmi_audio_plugged_notify);

static const struct hdmi_codec_ops drm_connector_hdmi_audio_ops = {
        .audio_startup = drm_connector_hdmi_audio_startup,
        .prepare = drm_connector_hdmi_audio_prepare,
        .audio_shutdown = drm_connector_hdmi_audio_shutdown,
        .mute_stream = drm_connector_hdmi_audio_mute_stream,
        .get_eld = drm_connector_hdmi_audio_get_eld,
        .get_dai_id = drm_connector_hdmi_audio_get_dai_id,
        .hook_plugged_cb = drm_connector_hdmi_audio_hook_plugged_cb,
};

/**
 * drm_connector_hdmi_audio_init - Initialize HDMI Codec device for the DRM connector
 * @connector: A pointer to the connector to allocate codec for
 * @hdmi_codec_dev: device to be used as a parent for the HDMI Codec
 * @funcs: callbacks for this HDMI Codec
 * @max_i2s_playback_channels: maximum number of playback I2S channels
 * @i2s_formats: set of I2S formats (use 0 for a bus-specific set)
 * @spdif_playback: set if HDMI codec has S/PDIF playback port
 * @dai_port: sound DAI port, -1 if it is not enabled
 *
 * Create a HDMI codec device to be used with the specified connector.
 *
 * Returns:
 * Zero on success, error code on failure.
 */
int drm_connector_hdmi_audio_init(struct drm_connector *connector,
                                  struct device *hdmi_codec_dev,
                                  const struct drm_connector_hdmi_audio_funcs *funcs,
                                  unsigned int max_i2s_playback_channels,
                                  u64 i2s_formats,
                                  bool spdif_playback,
                                  int dai_port)
{
        struct hdmi_codec_pdata codec_pdata = {
                .ops = &drm_connector_hdmi_audio_ops,
                .max_i2s_channels = max_i2s_playback_channels,
                .i2s = !!max_i2s_playback_channels,
                .i2s_formats = i2s_formats,
                .spdif = spdif_playback,
                .no_i2s_capture = true,
                .no_spdif_capture = true,
                .data = connector,
        };
        struct platform_device *pdev;

        if (!funcs ||
            !funcs->prepare ||
            !funcs->shutdown)
                return -EINVAL;

        connector->hdmi_audio.funcs = funcs;
        connector->hdmi_audio.dai_port = dai_port;

        pdev = platform_device_register_data(hdmi_codec_dev,
                                             HDMI_CODEC_DRV_NAME,
                                             PLATFORM_DEVID_AUTO,
                                             &codec_pdata, sizeof(codec_pdata));
        if (IS_ERR(pdev))
                return PTR_ERR(pdev);

        connector->hdmi_audio.codec_pdev = pdev;

        return 0;
}
EXPORT_SYMBOL(drm_connector_hdmi_audio_init);