/* $NetBSD: bwdsp.c,v 1.1 2026/01/09 22:54:29 jmcneill Exp $ */

/*-
 * Copyright (c) 2024 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: bwdsp.c,v 1.1 2026/01/09 22:54:29 jmcneill Exp $");

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

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

#include <machine/wiiu.h>
#include <machine/pio.h>

#include "mainbus.h"
#include "bwai.h"

#define BWDSP_MAP_FLAGS         BUS_DMA_NOCACHE

#define DSP_DMA_START_ADDR_H    0x30
#define DSP_DMA_START_ADDR_L    0x32
#define DSP_DMA_CONTROL_LENGTH  0x36
#define  DSP_DMA_CONTROL_LENGTH_CTRL    __BIT(15)
#define  DSP_DMA_CONTROL_LENGTH_NUM_CLS __BITS(14,0)

#define DSP_DMA_ALIGN           32
#define DSP_DMA_MAX_BUFSIZE     (DSP_DMA_CONTROL_LENGTH_NUM_CLS * 32)

extern struct powerpc_bus_dma_tag wii_mem2_bus_dma_tag;

struct bwdsp_dma {
        LIST_ENTRY(bwdsp_dma)   dma_list;
        bus_dmamap_t            dma_map;
        void                    *dma_addr;
        size_t                  dma_size;
        bus_dma_segment_t       dma_segs[1];
        int                     dma_nsegs;
};

struct bwdsp_softc {
        device_t                sc_dev;
        bus_space_tag_t         sc_bst;
        bus_space_handle_t      sc_bsh;
        bus_dma_tag_t           sc_dmat;

        LIST_HEAD(, bwdsp_dma) sc_dmalist;

        kmutex_t                sc_lock;
        kmutex_t                sc_intr_lock;

        struct audio_format     sc_format;

        audio_dai_tag_t         sc_dai;

        /* Register offsets */
        uint32_t                sc_dma_start_addr_h;
        uint32_t                sc_dma_start_addr_l;
        uint32_t                sc_dma_control_length;
};

#define WR2(sc, reg, val)               \
        bus_space_write_2((sc)->sc_bst, (sc)->sc_bsh, (reg), (val))

static int
bwdsp_allocdma(struct bwdsp_softc *sc, size_t size,
    size_t align, struct bwdsp_dma *dma)
{
        int error;

        dma->dma_size = size;
        error = bus_dmamem_alloc(sc->sc_dmat, dma->dma_size, align, 0,
            dma->dma_segs, 1, &dma->dma_nsegs, BUS_DMA_WAITOK);
        if (error)
                return error;

        error = bus_dmamem_map(sc->sc_dmat, dma->dma_segs, dma->dma_nsegs,
            dma->dma_size, &dma->dma_addr, BUS_DMA_WAITOK | BWDSP_MAP_FLAGS);
        if (error)
                goto free;

        error = bus_dmamap_create(sc->sc_dmat, dma->dma_size, dma->dma_nsegs,
            dma->dma_size, 0, BUS_DMA_WAITOK, &dma->dma_map);
        if (error)
                goto unmap;

        error = bus_dmamap_load(sc->sc_dmat, dma->dma_map, dma->dma_addr,
            dma->dma_size, NULL, BUS_DMA_WAITOK);
        if (error)
                goto destroy;

        return 0;

destroy:
        bus_dmamap_destroy(sc->sc_dmat, dma->dma_map);
unmap:
        bus_dmamem_unmap(sc->sc_dmat, dma->dma_addr, dma->dma_size);
free:
        bus_dmamem_free(sc->sc_dmat, dma->dma_segs, dma->dma_nsegs);

        return error;
}

static void
bwdsp_freedma(struct bwdsp_softc *sc, struct bwdsp_dma *dma)
{
        bus_dmamap_unload(sc->sc_dmat, dma->dma_map);
        bus_dmamap_destroy(sc->sc_dmat, dma->dma_map);
        bus_dmamem_unmap(sc->sc_dmat, dma->dma_addr, dma->dma_size);
        bus_dmamem_free(sc->sc_dmat, dma->dma_segs, dma->dma_nsegs);
}

static int
bwdsp_query_format(void *priv, audio_format_query_t *afp)
{
        struct bwdsp_softc * const sc = priv;

        return audio_query_format(&sc->sc_format, 1, afp);
}

static int
bwdsp_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 bwdsp_softc * const sc = priv;

        return audio_dai_mi_set_format(sc->sc_dai, setmode, play, rec,
            pfil, rfil);
}

static int
bwdsp_set_port(void *priv, mixer_ctrl_t *mc)
{
        struct bwdsp_softc * const sc = priv;

        return audio_dai_set_port(sc->sc_dai, mc);
}

static int
bwdsp_get_port(void *priv, mixer_ctrl_t *mc)
{
        struct bwdsp_softc * const sc = priv;

        return audio_dai_get_port(sc->sc_dai, mc);
}

static int
bwdsp_query_devinfo(void *priv, mixer_devinfo_t *di)
{
        struct bwdsp_softc * const sc = priv;

        return audio_dai_query_devinfo(sc->sc_dai, di);
}

static void *
bwdsp_allocm(void *priv, int dir, size_t size)
{
        struct bwdsp_softc * const sc = priv;
        struct bwdsp_dma *dma;
        int error;

        dma = kmem_alloc(sizeof(*dma), KM_SLEEP);

        error = bwdsp_allocdma(sc, size, DSP_DMA_ALIGN, dma);
        if (error) {
                kmem_free(dma, sizeof(*dma));
                device_printf(sc->sc_dev, "couldn't allocate DMA memory (%d)\n",
                    error);
                return NULL;
        }

        LIST_INSERT_HEAD(&sc->sc_dmalist, dma, dma_list);

        return dma->dma_addr;
}

static void
bwdsp_freem(void *priv, void *addr, size_t size)
{
        struct bwdsp_softc * const sc = priv;
        struct bwdsp_dma *dma;

        LIST_FOREACH(dma, &sc->sc_dmalist, dma_list)
                if (dma->dma_addr == addr) {
                        bwdsp_freedma(sc, dma);
                        LIST_REMOVE(dma, dma_list);
                        kmem_free(dma, sizeof(*dma));
                        break;
                }
}

static int
bwdsp_getdev(void *priv, struct audio_device *adev)
{
        if (wiiu_plat) {
                snprintf(adev->name, sizeof(adev->name), "Latte DSP");
        } else {
                snprintf(adev->name, sizeof(adev->name), "Hollywood DSP");
        }
        snprintf(adev->version, sizeof(adev->version), "");
        snprintf(adev->config, sizeof(adev->config), "bwdsp");

        return 0;
}

static int
bwdsp_get_props(void *priv)
{
        return AUDIO_PROP_PLAYBACK;
}

static int
bwdsp_round_blocksize(void *priv, int bs, int mode,
    const audio_params_t *params)
{
        bs = roundup(bs, DSP_DMA_ALIGN);
        if (bs > DSP_DMA_MAX_BUFSIZE) {
                bs = DSP_DMA_MAX_BUFSIZE;
        }
        return bs;
}

static size_t
bwdsp_round_buffersize(void *priv, int dir, size_t bufsize)
{
        if (bufsize > DSP_DMA_MAX_BUFSIZE) {
                bufsize = DSP_DMA_MAX_BUFSIZE;
        }
        return bufsize;
}

static void
bwdsp_transfer(struct bwdsp_softc *sc, uint32_t phys_addr, size_t bufsize)
{
        if (bufsize != 0) {
                WR2(sc, sc->sc_dma_start_addr_h, phys_addr >> 16);
                WR2(sc, sc->sc_dma_start_addr_l, phys_addr & 0xffff);
                WR2(sc, sc->sc_dma_control_length,
                    DSP_DMA_CONTROL_LENGTH_CTRL | (bufsize / 32));
        } else {
                WR2(sc, sc->sc_dma_control_length, 0);
        }
}

static int
bwdsp_trigger_output(void *priv, void *start, void *end, int blksize,
    void (*intr)(void *), void *intrarg, const audio_params_t *params)
{
        struct bwdsp_softc * const sc = priv;
        struct bwdsp_dma *dma;
        bus_addr_t pstart;
        bus_size_t psize;
        int error;

        pstart = 0;
        psize = (uintptr_t)end - (uintptr_t)start;

        LIST_FOREACH(dma, &sc->sc_dmalist, dma_list)
                if (dma->dma_addr == start) {
                        pstart = dma->dma_map->dm_segs[0].ds_addr;
                        break;
                }
        if (pstart == 0) {
                device_printf(sc->sc_dev, "bad addr %p\n", start);
                return EINVAL;
        }

        error = audio_dai_trigger(sc->sc_dai, start, end, blksize,
            intr, intrarg, params, AUMODE_PLAY);
        if (error != 0) {
                return error;
        }

        /* Start DMA transfer */
        bwdsp_transfer(sc, pstart, psize);

        return 0;
}

static int
bwdsp_halt_output(void *priv)
{
        struct bwdsp_softc * const sc = priv;

        /* Stop DMA transfer */
        bwdsp_transfer(sc, 0, 0);

        return audio_dai_halt(sc->sc_dai, AUMODE_PLAY);
}

static void
bwdsp_get_locks(void *priv, kmutex_t **intr, kmutex_t **thread)
{
        struct bwdsp_softc * const sc = priv;

        *intr = &sc->sc_intr_lock;
        *thread = &sc->sc_lock;
}

static const struct audio_hw_if bwdsp_hw_if = {
        .query_format = bwdsp_query_format,
        .set_format = bwdsp_set_format,
        .allocm = bwdsp_allocm,
        .freem = bwdsp_freem,
        .getdev = bwdsp_getdev,
        .set_port = bwdsp_set_port,
        .get_port = bwdsp_get_port,
        .query_devinfo = bwdsp_query_devinfo,
        .get_props = bwdsp_get_props,
        .round_blocksize = bwdsp_round_blocksize,
        .round_buffersize = bwdsp_round_buffersize,
        .trigger_output = bwdsp_trigger_output,
        .halt_output = bwdsp_halt_output,
        .get_locks = bwdsp_get_locks,
};

static void
bwdsp_late_attach(device_t dev)
{
        struct bwdsp_softc * const sc = device_private(dev);

        sc->sc_dai = bwai_dsp_init(&sc->sc_intr_lock);
        if (sc->sc_dai == NULL) {
                aprint_error_dev(dev, "can't find bwai device\n");
                return;
        }

        audio_attach_mi(&bwdsp_hw_if, sc, dev);
}

static int
bwdsp_match(device_t parent, cfdata_t cf, void *aux)
{
        struct mainbus_attach_args * const maa = aux;

        return strcmp(maa->maa_name, "bwdsp") == 0;
}

static void
bwdsp_attach(device_t parent, device_t self, void *aux)
{
        struct bwdsp_softc * const sc = device_private(self);
        struct mainbus_attach_args * const maa = aux;
        bus_addr_t addr = maa->maa_addr;
        bus_size_t size = 0x200;
        const uint32_t dma_reg_off = wiiu_native ? 0x10 : 0;

        sc->sc_dev = self;
        sc->sc_bst = maa->maa_bst;
        if (bus_space_map(sc->sc_bst, addr, size, 0, &sc->sc_bsh) != 0) {
                aprint_error(": couldn't map registers\n");
                return;
        }
        sc->sc_dmat = &wii_mem2_bus_dma_tag;
        LIST_INIT(&sc->sc_dmalist);
        mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_NONE);
        mutex_init(&sc->sc_intr_lock, MUTEX_DEFAULT, IPL_SCHED);

        sc->sc_dma_start_addr_h = DSP_DMA_START_ADDR_H + dma_reg_off;
        sc->sc_dma_start_addr_l = DSP_DMA_START_ADDR_L + dma_reg_off;
        sc->sc_dma_control_length = DSP_DMA_CONTROL_LENGTH + dma_reg_off;

        aprint_naive("\n");
        aprint_normal(": DSP\n");

        out32(HW_RESETS, in32(HW_RESETS) | RSTB_DSP);

        sc->sc_format.mode = AUMODE_PLAY;
        sc->sc_format.encoding = AUDIO_ENCODING_SLINEAR_BE;
        sc->sc_format.validbits = 16;
        sc->sc_format.precision = 16;
        sc->sc_format.channels = 2;
        sc->sc_format.channel_mask = AUFMT_STEREO;
        sc->sc_format.frequency_type = 1;
        sc->sc_format.frequency[0] = 48000;

        config_defer(self, bwdsp_late_attach);
}

CFATTACH_DECL_NEW(bwdsp, sizeof(struct bwdsp_softc),
    bwdsp_match, bwdsp_attach, NULL, NULL);