/*
 * Copyright (c) 2026 Abdelkader Boudih <freebsd@seuros.com>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

/* newpcm channel integration for fwisound(4). */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/bus.h>
#include <sys/malloc.h>
#include <sys/lock.h>
#include <sys/mutex.h>
#include <sys/taskqueue.h>

#include <dev/firewire/firewire.h>
#include <dev/firewire/firewirereg.h>
#include <dev/firewire/fwisound.h>

#include <dev/sound/pcm/sound.h>

#define FWISOUND_BUFSZ	65536


static void *
fwisound_chan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b,
    struct pcm_channel *c, int dir)
{
	struct fwisound_softc *sc = devinfo;
	struct fwisound_chan *chan;
	void *buf;
	unsigned int bufsz;

	if (dir != PCMDIR_REC)
		return (NULL);

	chan = malloc(sizeof(*chan), M_DEVBUF, M_WAITOK | M_ZERO);
	chan->sc = sc;
	chan->pcm_chan = c;
	chan->buf = b;

	chan->fmts[0] = SND_FORMAT(AFMT_S16_BE, 2, 0);
	chan->fmts[1] = 0;

	chan->caps.minspeed = 48000;
	chan->caps.maxspeed = 48000;
	chan->caps.fmtlist = chan->fmts;
	chan->caps.caps = 0;

	bufsz = pcm_getbuffersize(sc->pcm_dev, 4096, FWISOUND_BUFSZ, 131072);
	buf = malloc(bufsz, M_DEVBUF, M_WAITOK | M_ZERO);
	if (sndbuf_setup(b, buf, bufsz) != 0) {
		free(buf, M_DEVBUF);
		free(chan, M_DEVBUF);
		return (NULL);
	}

	FWISOUND_LOCK(sc);
	sc->chan = chan;
	FWISOUND_UNLOCK(sc);

	return (chan);
}

static int
fwisound_chan_free(kobj_t obj, void *data)
{
	struct fwisound_chan *chan = data;
	struct fwisound_softc *sc = chan->sc;
	void *buf;

	if (chan->running) {
		taskqueue_enqueue(taskqueue_thread, &sc->stop_task);
		taskqueue_drain(taskqueue_thread, &sc->stop_task);
	}

	FWISOUND_LOCK(sc);
	sc->chan = NULL;
	FWISOUND_UNLOCK(sc);

	buf = sndbuf_getbufofs(chan->buf, 0);
	if (buf != NULL)
		free(buf, M_DEVBUF);

	free(chan, M_DEVBUF);
	return (0);
}

static int
fwisound_chan_setformat(kobj_t obj, void *data, uint32_t fmt)
{

	if (fmt != SND_FORMAT(AFMT_S16_BE, 2, 0))
		return (EINVAL);
	return (0);
}

static uint32_t
fwisound_chan_setspeed(kobj_t obj, void *data, uint32_t speed)
{

	return (48000);
}

static uint32_t
fwisound_chan_setblocksize(kobj_t obj, void *data, uint32_t blksz)
{
	struct fwisound_chan *chan = data;

	blksz = rounddown(blksz, 4);
	if (blksz < 4)
		blksz = 4;

	sndbuf_resize(chan->buf, chan->buf->bufsize / blksz, blksz);

	return (chan->buf->blksz);
}

static int
fwisound_chan_trigger(kobj_t obj, void *data, int go)
{
	struct fwisound_chan *chan = data;
	struct fwisound_softc *sc = chan->sc;

	switch (go) {
	case PCMTRIG_START:
		chan->hw_ptr = 0;
		sc->dropped = 0;
		sc->sample_total = 0;
		chan->running = 1;
		taskqueue_enqueue(taskqueue_thread, &sc->start_task);
		return (0);

	case PCMTRIG_STOP:
	case PCMTRIG_ABORT:
		chan->running = 0;
		taskqueue_drain(taskqueue_thread, &sc->start_task);
		taskqueue_enqueue(taskqueue_thread, &sc->stop_task);
		return (0);

	default:
		return (0);
	}
}

static uint32_t
fwisound_chan_getptr(kobj_t obj, void *data)
{
	struct fwisound_chan *chan = data;

	return (chan->hw_ptr % chan->buf->bufsize);
}

static struct pcmchan_caps *
fwisound_chan_getcaps(kobj_t obj, void *data)
{
	struct fwisound_chan *chan = data;

	return (&chan->caps);
}

static kobj_method_t fwisound_chan_methods[] = {
	KOBJMETHOD(channel_init,	fwisound_chan_init),
	KOBJMETHOD(channel_free,	fwisound_chan_free),
	KOBJMETHOD(channel_setformat,	fwisound_chan_setformat),
	KOBJMETHOD(channel_setspeed,	fwisound_chan_setspeed),
	KOBJMETHOD(channel_setblocksize, fwisound_chan_setblocksize),
	KOBJMETHOD(channel_trigger,	fwisound_chan_trigger),
	KOBJMETHOD(channel_getptr,	fwisound_chan_getptr),
	KOBJMETHOD(channel_getcaps,	fwisound_chan_getcaps),
	KOBJMETHOD_END
};

CHANNEL_DECLARE(fwisound_chan);

static int
fwisound_pcm_probe(device_t dev)
{

	device_set_desc(dev, "Apple FireWire audio");
	return (0);
}

static int
fwisound_pcm_attach(device_t dev)
{
	struct fwisound_softc *sc;
	char status[SND_STATUSLEN];
	int err;

	sc = device_get_softc(device_get_parent(dev));
	sc->pcm_dev = dev;

	pcm_init(dev, sc);
	pcm_setflags(dev, pcm_getflags(dev) | SD_F_MPSAFE);

	err = pcm_addchan(dev, PCMDIR_REC, &fwisound_chan_class, sc);
	if (err != 0) {
		device_printf(dev, "pcm_addchan failed: %d\n", err);
		return (err);
	}

	snprintf(status, sizeof(status), "Apple FireWire audio at %s",
	    device_get_nameunit(device_get_parent(dev)));
	return (pcm_register(dev, status));
}

static int
fwisound_pcm_detach(device_t dev)
{

	return (pcm_unregister(dev));
}

static device_method_t fwisound_pcm_methods[] = {
	DEVMETHOD(device_probe,		fwisound_pcm_probe),
	DEVMETHOD(device_attach,	fwisound_pcm_attach),
	DEVMETHOD(device_detach,	fwisound_pcm_detach),

	DEVMETHOD_END
};

static driver_t fwisound_pcm_driver = {
	"pcm",
	fwisound_pcm_methods,
	PCM_SOFTC_SIZE,
};

DRIVER_MODULE(fwisound_pcm, fwisound, fwisound_pcm_driver, 0, 0);
MODULE_DEPEND(fwisound_pcm, fwisound, 1, 1, 1);
MODULE_DEPEND(fwisound_pcm, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER);