/* $NetBSD: ausoc.c,v 1.6 2021/01/27 03:10:21 thorpej Exp $ */

/*-
 * Copyright (c) 2018 Jared McNeill <jmcneill@invisible.ca>
 * All rights reserved.
 *
 * 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 AUTHOR ``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 AUTHOR 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: ausoc.c,v 1.6 2021/01/27 03:10:21 thorpej Exp $");

#include <sys/param.h>
#include <sys/bus.h>
#include <sys/cpu.h>
#include <sys/device.h>
#include <sys/kmem.h>
#include <sys/gpio.h>

#include <sys/audioio.h>
#include <dev/audio/audio_if.h>
#include <dev/audio/audio_dai.h>

#include <dev/fdt/fdtvar.h>

static const struct device_compatible_entry compat_data[] = {
        { .compat = "simple-audio-card" },
        DEVICE_COMPAT_EOL
};

struct ausoc_link {
        const char              *link_name;

        audio_dai_tag_t         link_cpu;
        audio_dai_tag_t         link_codec;
        audio_dai_tag_t         *link_aux;
        u_int                   link_naux;

        u_int                   link_mclk_fs;

        kmutex_t                link_lock;
        kmutex_t                link_intr_lock;
};

struct ausoc_softc {
        device_t                sc_dev;
        int                     sc_phandle;
        const char              *sc_name;

        struct ausoc_link       *sc_link;
        u_int                   sc_nlink;
};

static void
ausoc_close(void *priv)
{
        struct ausoc_link * const link = priv;
        u_int aux;

        for (aux = 0; aux < link->link_naux; aux++)
                audio_dai_close(link->link_aux[aux]);
        audio_dai_close(link->link_codec);
        audio_dai_close(link->link_cpu);
}

static int
ausoc_open(void *priv, int flags)
{
        struct ausoc_link * const link = priv;
        u_int aux;
        int error;

        error = audio_dai_open(link->link_cpu, flags);
        if (error)
                goto failed;

        error = audio_dai_open(link->link_codec, flags);
        if (error)
                goto failed;

        for (aux = 0; aux < link->link_naux; aux++) {
                error = audio_dai_open(link->link_aux[aux], flags);
                if (error)
                        goto failed;
        }

        return 0;

failed:
        ausoc_close(priv);
        return error;
}

static int
ausoc_query_format(void *priv, audio_format_query_t *afp)
{
        struct ausoc_link * const link = priv;

        return audio_dai_query_format(link->link_cpu, afp);
}

static int
ausoc_set_format(void *priv, int setmode,
    const audio_params_t *play, const audio_params_t *rec,
    audio_filter_reg_t *pfil, audio_filter_reg_t *rfil)
{
        struct ausoc_link * const link = priv;
        const audio_params_t *params = (setmode & AUMODE_PLAY) != 0 ?
            play : rec;
        int error;

        if (link->link_mclk_fs) {
                const u_int rate = params->sample_rate * link->link_mclk_fs;
                error = audio_dai_set_sysclk(link->link_codec, rate,
                    AUDIO_DAI_CLOCK_IN);
                if (error)
                        return error;
                error = audio_dai_set_sysclk(link->link_cpu, rate,
                    AUDIO_DAI_CLOCK_OUT);
                if (error)
                        return error;
        }

        error = audio_dai_mi_set_format(link->link_cpu, setmode,
            play, rec, pfil, rfil);
        if (error)
                return error;

        return audio_dai_mi_set_format(link->link_codec, setmode,
            play, rec, pfil, rfil);
}

static int
ausoc_set_port(void *priv, mixer_ctrl_t *mc)
{
        struct ausoc_link * const link = priv;

        return audio_dai_set_port(link->link_codec, mc);
}

static int
ausoc_get_port(void *priv, mixer_ctrl_t *mc)
{
        struct ausoc_link * const link = priv;

        return audio_dai_get_port(link->link_codec, mc);
}

static int
ausoc_query_devinfo(void *priv, mixer_devinfo_t *di)
{
        struct ausoc_link * const link = priv;

        return audio_dai_query_devinfo(link->link_codec, di);
}

static void *
ausoc_allocm(void *priv, int dir, size_t size)
{
        struct ausoc_link * const link = priv;

        return audio_dai_allocm(link->link_cpu, dir, size);
}

static void
ausoc_freem(void *priv, void *addr, size_t size)
{
        struct ausoc_link * const link = priv;

        return audio_dai_freem(link->link_cpu, addr, size);
}

static int
ausoc_getdev(void *priv, struct audio_device *adev)
{
        struct ausoc_link * const link = priv;

        /* Defaults */
        snprintf(adev->name, sizeof(adev->name), "%s", link->link_name);
        snprintf(adev->version, sizeof(adev->version), "");
        snprintf(adev->config, sizeof(adev->config), "ausoc");

        /* Codec can override */
        (void)audio_dai_getdev(link->link_codec, adev);

        return 0;
}

static int
ausoc_get_props(void *priv)
{
        struct ausoc_link * const link = priv;

        return audio_dai_get_props(link->link_cpu);
}

static int
ausoc_round_blocksize(void *priv, int bs, int mode,
    const audio_params_t *params)
{
        struct ausoc_link * const link = priv;

        return audio_dai_round_blocksize(link->link_cpu, bs, mode, params);
}

static size_t
ausoc_round_buffersize(void *priv, int dir, size_t bufsize)
{
        struct ausoc_link * const link = priv;

        return audio_dai_round_buffersize(link->link_cpu, dir, bufsize);
}

static int
ausoc_halt_output(void *priv)
{
        struct ausoc_link * const link = priv;
        u_int n;

        for (n = 0; n < link->link_naux; n++)
                audio_dai_halt(link->link_aux[n], AUMODE_PLAY);

        audio_dai_halt(link->link_codec, AUMODE_PLAY);

        return audio_dai_halt(link->link_cpu, AUMODE_PLAY);
}

static int
ausoc_halt_input(void *priv)
{
        struct ausoc_link * const link = priv;
        u_int n;

        for (n = 0; n < link->link_naux; n++)
                audio_dai_halt(link->link_aux[n], AUMODE_RECORD);

        audio_dai_halt(link->link_codec, AUMODE_RECORD);

        return audio_dai_halt(link->link_cpu, AUMODE_RECORD);
}

static int
ausoc_trigger_output(void *priv, void *start, void *end, int blksize,
    void (*intr)(void *), void *intrarg, const audio_params_t *params)
{
        struct ausoc_link * const link = priv;
        int error;
        u_int n;

        for (n = 0; n < link->link_naux; n++) {
                error = audio_dai_trigger(link->link_aux[n], start, end,
                    blksize, intr, intrarg, params, AUMODE_PLAY);
                if (error)
                        goto failed;
        }
        error = audio_dai_trigger(link->link_codec, start, end, blksize,
            intr, intrarg, params, AUMODE_PLAY);
        if (error)
                goto failed;

        return audio_dai_trigger(link->link_cpu, start, end, blksize,
            intr, intrarg, params, AUMODE_PLAY);

failed:
        ausoc_halt_output(priv);
        return error;
}

static int
ausoc_trigger_input(void *priv, void *start, void *end, int blksize,
    void (*intr)(void *), void *intrarg, const audio_params_t *params)
{
        struct ausoc_link * const link = priv;
        int error;
        u_int n;

        for (n = 0; n < link->link_naux; n++) {
                error = audio_dai_trigger(link->link_aux[n], start, end,
                    blksize, intr, intrarg, params, AUMODE_RECORD);
                if (error)
                        goto failed;
        }
        error = audio_dai_trigger(link->link_codec, start, end, blksize,
            intr, intrarg, params, AUMODE_RECORD);
        if (error)
                goto failed;

        return audio_dai_trigger(link->link_cpu, start, end, blksize,
            intr, intrarg, params, AUMODE_RECORD);

failed:
        ausoc_halt_input(priv);
        return error;
}

static void
ausoc_get_locks(void *priv, kmutex_t **intr, kmutex_t **thread)
{
        struct ausoc_link * const link = priv;

        return audio_dai_get_locks(link->link_cpu, intr, thread);
}

static const struct audio_hw_if ausoc_hw_if = {
        .open = ausoc_open,
        .close = ausoc_close,
        .query_format = ausoc_query_format,
        .set_format = ausoc_set_format,
        .allocm = ausoc_allocm,
        .freem = ausoc_freem,
        .getdev = ausoc_getdev,
        .set_port = ausoc_set_port,
        .get_port = ausoc_get_port,
        .query_devinfo = ausoc_query_devinfo,
        .get_props = ausoc_get_props,
        .round_blocksize = ausoc_round_blocksize,
        .round_buffersize = ausoc_round_buffersize,
        .trigger_output = ausoc_trigger_output,
        .trigger_input = ausoc_trigger_input,
        .halt_output = ausoc_halt_output,
        .halt_input = ausoc_halt_input,
        .get_locks = ausoc_get_locks,
};

static int
ausoc_match(device_t parent, cfdata_t cf, void *aux)
{
        struct fdt_attach_args * const faa = aux;

        return of_compatible_match(faa->faa_phandle, compat_data);
}

static struct {
        const char *name;
        u_int fmt;
} ausoc_dai_formats[] = {
        { "i2s",        AUDIO_DAI_FORMAT_I2S },
        { "right_j",    AUDIO_DAI_FORMAT_RJ },
        { "left_j",     AUDIO_DAI_FORMAT_LJ },
        { "dsp_a",      AUDIO_DAI_FORMAT_DSPA },
        { "dsp_b",      AUDIO_DAI_FORMAT_DSPB },
        { "ac97",       AUDIO_DAI_FORMAT_AC97 },
        { "pdm",        AUDIO_DAI_FORMAT_PDM },
};

static int
ausoc_link_format(struct ausoc_softc *sc, struct ausoc_link *link, int phandle,
    int dai_phandle, bool single_link, u_int *format)
{
        const char *format_prop = single_link ?
            "simple-audio-card,format" : "format";
        const char *frame_master_prop = single_link ?
            "simple-audio-card,frame-master" : "frame-master";
        const char *bitclock_master_prop = single_link ?
            "simple-audio-card,bitclock-master" : "bitclock-master";
        const char *bitclock_inversion_prop = single_link ?
            "simple-audio-card,bitclock-inversion" : "bitclock-inversion";
        const char *frame_inversion_prop = single_link ?
            "simple-audio-card,frame-inversion" : "frame-inversion";

        u_int fmt, pol, clk;
        const char *s;
        u_int n;

        s = fdtbus_get_string(phandle, format_prop);
        if (s) {
                for (n = 0; n < __arraycount(ausoc_dai_formats); n++) {
                        if (strcmp(s, ausoc_dai_formats[n].name) == 0) {
                                fmt = ausoc_dai_formats[n].fmt;
                                break;
                        }
                }
                if (n == __arraycount(ausoc_dai_formats))
                        return EINVAL;
        } else {
                fmt = AUDIO_DAI_FORMAT_I2S;
        }

        const bool frame_master =
            dai_phandle == fdtbus_get_phandle(phandle, frame_master_prop);
        const bool bitclock_master =
            dai_phandle == fdtbus_get_phandle(phandle, bitclock_master_prop);
        if (frame_master) {
                clk = bitclock_master ?
                    AUDIO_DAI_CLOCK_CBM_CFM : AUDIO_DAI_CLOCK_CBS_CFM;
        } else {
                clk = bitclock_master ?
                    AUDIO_DAI_CLOCK_CBM_CFS : AUDIO_DAI_CLOCK_CBS_CFS;
        }

        const bool bitclock_inversion = of_hasprop(phandle, bitclock_inversion_prop);
        const bool frame_inversion = of_hasprop(phandle, frame_inversion_prop);
        if (bitclock_inversion) {
                pol = frame_inversion ?
                    AUDIO_DAI_POLARITY_IB_IF : AUDIO_DAI_POLARITY_IB_NF;
        } else {
                pol = frame_inversion ?
                    AUDIO_DAI_POLARITY_NB_IF : AUDIO_DAI_POLARITY_NB_NF;
        }

        *format = __SHIFTIN(fmt, AUDIO_DAI_FORMAT_MASK) |
                  __SHIFTIN(pol, AUDIO_DAI_POLARITY_MASK) |
                  __SHIFTIN(clk, AUDIO_DAI_CLOCK_MASK);

        return 0;
}

static void
ausoc_attach_link(struct ausoc_softc *sc, struct ausoc_link *link,
    int card_phandle, int link_phandle)
{
        const bool single_link = card_phandle == link_phandle;
        const char *cpu_prop = single_link ?
            "simple-audio-card,cpu" : "cpu";
        const char *codec_prop = single_link ?
            "simple-audio-card,codec" : "codec";
        const char *mclk_fs_prop = single_link ?
            "simple-audio-card,mclk-fs" : "mclk-fs";
        const char *node_name = fdtbus_get_string(link_phandle, "name");
        u_int n, format;

        const int cpu_phandle = of_find_firstchild_byname(link_phandle, cpu_prop);
        if (cpu_phandle <= 0) {
                aprint_error_dev(sc->sc_dev, "missing %s prop on %s node\n",
                    cpu_prop, node_name);
                return;
        }

        link->link_cpu = fdtbus_dai_acquire(cpu_phandle, "sound-dai");
        if (!link->link_cpu) {
                aprint_error_dev(sc->sc_dev,
                    "couldn't acquire cpu dai on %s node\n", node_name);
                return;
        }

        const int codec_phandle = of_find_firstchild_byname(link_phandle, codec_prop);
        if (codec_phandle <= 0) {
                aprint_error_dev(sc->sc_dev, "missing %s prop on %s node\n",
                    codec_prop, node_name);
                return;
        }

        link->link_codec = fdtbus_dai_acquire(codec_phandle, "sound-dai");
        if (!link->link_codec) {
                aprint_error_dev(sc->sc_dev,
                    "couldn't acquire codec dai on %s node\n", node_name);
                return;
        }

        for (;;) {
                if (fdtbus_dai_acquire_index(card_phandle,
                    "simple-audio-card,aux-devs", link->link_naux) == NULL)
                        break;
                link->link_naux++;
        }
        if (link->link_naux) {
                link->link_aux = kmem_zalloc(sizeof(audio_dai_tag_t) * link->link_naux, KM_SLEEP);
                for (n = 0; n < link->link_naux; n++) {
                        link->link_aux[n] = fdtbus_dai_acquire_index(card_phandle,
                            "simple-audio-card,aux-devs", n);
                        KASSERT(link->link_aux[n] != NULL);

                        /* Attach aux devices to codec */
                        audio_dai_add_device(link->link_codec, link->link_aux[n]);
                }
        }

        of_getprop_uint32(link_phandle, mclk_fs_prop, &link->link_mclk_fs);
        if (ausoc_link_format(sc, link, link_phandle, codec_phandle, single_link, &format) != 0) {
                aprint_error_dev(sc->sc_dev, "couldn't parse format properties\n");
                return;
        }
        if (audio_dai_set_format(link->link_cpu, format) != 0) {
                aprint_error_dev(sc->sc_dev, "couldn't set cpu format\n");
                return;
        }
        if (audio_dai_set_format(link->link_codec, format) != 0) {
                aprint_error_dev(sc->sc_dev, "couldn't set codec format\n");
                return;
        }

        aprint_normal_dev(sc->sc_dev, "codec: %s, cpu: %s",
            device_xname(audio_dai_device(link->link_codec)),
            device_xname(audio_dai_device(link->link_cpu)));
        for (n = 0; n < link->link_naux; n++) {
                if (n == 0)
                        aprint_normal(", aux:");
                aprint_normal(" %s",
                    device_xname(audio_dai_device(link->link_aux[n])));
        }
        aprint_normal("\n");

        audio_attach_mi(&ausoc_hw_if, link, sc->sc_dev);
}

static void
ausoc_attach_cb(device_t self)
{
        struct ausoc_softc * const sc = device_private(self);
        const int phandle = sc->sc_phandle;
        const char *name;
        int child, n;
        size_t len;

        /*
         * If the root node defines a cpu and codec, there is only one link. For
         * cards with multiple links, there will be simple-audio-card,dai-link
         * child nodes for each one.
         */
        if (of_find_firstchild_byname(phandle, "simple-audio-card,cpu") > 0 &&
            of_find_firstchild_byname(phandle, "simple-audio-card,codec") > 0) {
                sc->sc_nlink = 1;
                sc->sc_link = kmem_zalloc(sizeof(*sc->sc_link), KM_SLEEP);
                sc->sc_link[0].link_name = sc->sc_name;
                ausoc_attach_link(sc, &sc->sc_link[0], phandle, phandle);
        } else {
                for (child = OF_child(phandle); child; child = OF_peer(child)) {
                        name = fdtbus_get_string(child, "name");
                        len = strlen("simple-audio-card,dai-link");
                        if (strncmp(name, "simple-audio-card,dai-link", len) != 0)
                                continue;
                        sc->sc_nlink++;
                }
                if (sc->sc_nlink == 0)
                        return;
                sc->sc_link = kmem_zalloc(sizeof(*sc->sc_link) * sc->sc_nlink,
                    KM_SLEEP);
                for (child = OF_child(phandle), n = 0; child; child = OF_peer(child)) {
                        name = fdtbus_get_string(child, "name");
                        len = strlen("simple-audio-card,dai-link");
                        if (strncmp(name, "simple-audio-card,dai-link", len) != 0)
                                continue;
                        sc->sc_link[n].link_name = sc->sc_name;
                        ausoc_attach_link(sc, &sc->sc_link[n], phandle, child);
                        n++;
                }
        }
}

static void
ausoc_attach(device_t parent, device_t self, void *aux)
{
        struct ausoc_softc * const sc = device_private(self);
        struct fdt_attach_args * const faa = aux;
        const int phandle = faa->faa_phandle;

        sc->sc_dev = self;
        sc->sc_phandle = phandle;
        sc->sc_name = fdtbus_get_string(phandle, "simple-audio-card,name");
        if (!sc->sc_name)
                sc->sc_name = "SoC Audio";

        aprint_naive("\n");
        aprint_normal(": %s\n", sc->sc_name);

        /*
         * Defer attachment until all other drivers are ready.
         */
        config_defer(self, ausoc_attach_cb);
}

CFATTACH_DECL_NEW(ausoc, sizeof(struct ausoc_softc),
    ausoc_match, ausoc_attach, NULL, NULL);