// SPDX-License-Identifier: GPL-2.0
//
// soc-link.c
//
// Copyright (C) 2019 Renesas Electronics Corp.
// Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
//
#include <sound/soc.h>
#include <sound/soc-link.h>

#define soc_link_ret(rtd, ret) _soc_link_ret(rtd, __func__, ret)
static inline int _soc_link_ret(struct snd_soc_pcm_runtime *rtd,
                                const char *func, int ret)
{
        return snd_soc_ret(rtd->dev, ret,
                           "at %s() on %s\n", func, rtd->dai_link->name);
}

/*
 * We might want to check substream by using list.
 * In such case, we can update these macros.
 */
#define soc_link_mark_push(rtd, substream, tgt)         ((rtd)->mark_##tgt = substream)
#define soc_link_mark_pop(rtd, tgt)             ((rtd)->mark_##tgt = NULL)
#define soc_link_mark_match(rtd, substream, tgt)        ((rtd)->mark_##tgt == substream)

int snd_soc_link_init(struct snd_soc_pcm_runtime *rtd)
{
        int ret = 0;

        if (rtd->dai_link->init)
                ret = rtd->dai_link->init(rtd);

        return soc_link_ret(rtd, ret);
}

void snd_soc_link_exit(struct snd_soc_pcm_runtime *rtd)
{
        if (rtd->dai_link->exit)
                rtd->dai_link->exit(rtd);
}

int snd_soc_link_be_hw_params_fixup(struct snd_soc_pcm_runtime *rtd,
                                    struct snd_pcm_hw_params *params)
{
        int ret = 0;

        if (rtd->dai_link->be_hw_params_fixup)
                ret = rtd->dai_link->be_hw_params_fixup(rtd, params);

        return soc_link_ret(rtd, ret);
}

int snd_soc_link_startup(struct snd_pcm_substream *substream)
{
        struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
        int ret = 0;

        if (rtd->dai_link->ops &&
            rtd->dai_link->ops->startup)
                ret = rtd->dai_link->ops->startup(substream);

        /* mark substream if succeeded */
        if (ret == 0)
                soc_link_mark_push(rtd, substream, startup);

        return soc_link_ret(rtd, ret);
}

void snd_soc_link_shutdown(struct snd_pcm_substream *substream,
                           int rollback)
{
        struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);

        if (rollback && !soc_link_mark_match(rtd, substream, startup))
                return;

        if (rtd->dai_link->ops &&
            rtd->dai_link->ops->shutdown)
                rtd->dai_link->ops->shutdown(substream);

        /* remove marked substream */
        soc_link_mark_pop(rtd, startup);
}

int snd_soc_link_prepare(struct snd_pcm_substream *substream)
{
        struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
        int ret = 0;

        if (rtd->dai_link->ops &&
            rtd->dai_link->ops->prepare)
                ret = rtd->dai_link->ops->prepare(substream);

        return soc_link_ret(rtd, ret);
}

int snd_soc_link_hw_params(struct snd_pcm_substream *substream,
                           struct snd_pcm_hw_params *params)
{
        struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
        int ret = 0;

        if (rtd->dai_link->ops &&
            rtd->dai_link->ops->hw_params)
                ret = rtd->dai_link->ops->hw_params(substream, params);

        /* mark substream if succeeded */
        if (ret == 0)
                soc_link_mark_push(rtd, substream, hw_params);

        return soc_link_ret(rtd, ret);
}

void snd_soc_link_hw_free(struct snd_pcm_substream *substream, int rollback)
{
        struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);

        if (rollback && !soc_link_mark_match(rtd, substream, hw_params))
                return;

        if (rtd->dai_link->ops &&
            rtd->dai_link->ops->hw_free)
                rtd->dai_link->ops->hw_free(substream);

        /* remove marked substream */
        soc_link_mark_pop(rtd, hw_params);
}

static int soc_link_trigger(struct snd_pcm_substream *substream, int cmd)
{
        struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
        int ret = 0;

        if (rtd->dai_link->ops &&
            rtd->dai_link->ops->trigger)
                ret = rtd->dai_link->ops->trigger(substream, cmd);

        return soc_link_ret(rtd, ret);
}

int snd_soc_link_trigger(struct snd_pcm_substream *substream, int cmd,
                         int rollback)
{
        struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
        int ret = 0;

        switch (cmd) {
        case SNDRV_PCM_TRIGGER_START:
        case SNDRV_PCM_TRIGGER_RESUME:
        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
                ret = soc_link_trigger(substream, cmd);
                if (ret < 0)
                        break;
                soc_link_mark_push(rtd, substream, trigger);
                break;
        case SNDRV_PCM_TRIGGER_STOP:
        case SNDRV_PCM_TRIGGER_SUSPEND:
        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
                if (rollback && !soc_link_mark_match(rtd, substream, trigger))
                        break;

                ret = soc_link_trigger(substream, cmd);
                soc_link_mark_pop(rtd, startup);
        }

        return ret;
}

int snd_soc_link_compr_startup(struct snd_compr_stream *cstream)
{
        struct snd_soc_pcm_runtime *rtd = cstream->private_data;
        int ret = 0;

        if (rtd->dai_link->compr_ops &&
            rtd->dai_link->compr_ops->startup)
                ret = rtd->dai_link->compr_ops->startup(cstream);

        if (ret == 0)
                soc_link_mark_push(rtd, cstream, compr_startup);

        return soc_link_ret(rtd, ret);
}
EXPORT_SYMBOL_GPL(snd_soc_link_compr_startup);

void snd_soc_link_compr_shutdown(struct snd_compr_stream *cstream,
                                 int rollback)
{
        struct snd_soc_pcm_runtime *rtd = cstream->private_data;

        if (rollback && !soc_link_mark_match(rtd, cstream, compr_startup))
                return;

        if (rtd->dai_link->compr_ops &&
            rtd->dai_link->compr_ops->shutdown)
                rtd->dai_link->compr_ops->shutdown(cstream);

        soc_link_mark_pop(rtd, compr_startup);
}
EXPORT_SYMBOL_GPL(snd_soc_link_compr_shutdown);

int snd_soc_link_compr_set_params(struct snd_compr_stream *cstream)
{
        struct snd_soc_pcm_runtime *rtd = cstream->private_data;
        int ret = 0;

        if (rtd->dai_link->compr_ops &&
            rtd->dai_link->compr_ops->set_params)
                ret = rtd->dai_link->compr_ops->set_params(cstream);

        return soc_link_ret(rtd, ret);
}
EXPORT_SYMBOL_GPL(snd_soc_link_compr_set_params);