xref: /src/sys/dev/ic/tms320av110.c

/*	$NetBSD: tms320av110.c,v 1.27 2019/06/08 08:02:38 isaki Exp $	*/

/*-
 * Copyright (c) 1997 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Ignatios Souvatzis.
 *
 * 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 NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``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 FOUNDATION OR CONTRIBUTORS
 * 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.
 */

/*
 * Machine independent part of TMS320AV110 driver.
 *
 * Currently, only minimum support for audio output. For audio/video
 * synchronization, more is needed.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: tms320av110.c,v 1.27 2019/06/08 08:02:38 isaki Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/device.h>
#include <sys/proc.h>

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

#include <dev/ic/tms320av110reg.h>
#include <dev/ic/tms320av110var.h>

#include <sys/bus.h>

void tav_close(void *);
int tav_query_format(void *, audio_format_query_t *);
int tav_set_format(void *, int,
    const audio_params_t *, const audio_params_t *,
    audio_filter_reg_t *, audio_filter_reg_t *);
int tav_round_blocksize(void *, int, int, const audio_params_t *);
int tav_start_output(void *, void *, int, void (*)(void *), void *);
int tav_start_input(void *, void *, int, void (*)(void *), void *);
int tav_halt_output(void *);
int tav_halt_input(void *);
int tav_speaker_ctl(void *, int);
int tav_getdev(void *, struct audio_device *);
int tav_set_port(void *, mixer_ctrl_t *);
int tav_get_port(void *, mixer_ctrl_t *);
int tav_query_devinfo(void *, mixer_devinfo_t *);
int tav_get_props(void *);
void tav_get_locks(void *, kmutex_t **, kmutex_t **);

const struct audio_hw_if tav_audio_if = {
	.close			= tav_close,
	.query_format		= tav_query_format,
	.set_format		= tav_set_format,
	.round_blocksize	= tav_round_blocksize,
	.start_output		= tav_start_output,
	.start_input		= tav_start_input,
	.halt_output		= tav_halt_output,
	.halt_input		= tav_halt_input,
	.speaker_ctl		= tav_speaker_ctl,	/* optional */
	.getdev			= tav_getdev,
	.set_port		= tav_set_port,
	.get_port		= tav_get_port,
	.query_devinfo		= tav_query_devinfo,
	.get_props		= tav_get_props,
	.get_locks		= tav_get_locks,
};

/*
 * XXX: The frequency might depend on the specific board.
 * should be handled by the backend.
 */
#define TAV_FORMAT(prio, enc, prec) \
	{ \
		.priority	= (prio), \
		.mode		= AUMODE_PLAY, \
		.encoding	= (enc), \
		.validbits	= (prec), \
		.precision	= (prec), \
		.channels	= 2, \
		.channel_mask	= AUFMT_STEREO, \
		.frequency_type	= 1, \
		.frequency	= { 44100 }, \
	}
const struct audio_format tav_formats[] = {
	TAV_FORMAT(-1, AUDIO_ENCODING_MPEG_L2_STREAM, 1),
	TAV_FORMAT(-1, AUDIO_ENCODING_MPEG_L2_PACKETS, 1),
	TAV_FORMAT(-1, AUDIO_ENCODING_MPEG_L2_SYSTEM, 1),
	TAV_FORMAT( 0, AUDIO_ENCODING_SLINEAR_BE, 16),
};
#define TAV_NFORMATS __arraycount(tav_formats)

void
tms320av110_attach_mi(struct tav_softc *sc)
{
	bus_space_tag_t iot;
	bus_space_handle_t ioh;

	iot = sc->sc_iot;
	ioh = sc->sc_ioh;
	tav_write_byte(iot, ioh, TAV_RESET, 1);
	while (tav_read_byte(iot, ioh, TAV_RESET))
		delay(250);

	tav_write_byte(iot, ioh, TAV_PCM_ORD, sc->sc_pcm_ord);
	tav_write_byte(iot, ioh, TAV_PCM_18, sc->sc_pcm_18);
	tav_write_byte(iot, ioh, TAV_DIF, sc->sc_dif);
	tav_write_byte(iot, ioh, TAV_PCM_DIV, sc->sc_pcm_div);

	printf(": chip rev. %d, %d bytes buffer\n",
	    tav_read_byte(iot, ioh, TAV_VERSION),
	    TAV_DRAM_SIZE(tav_read_byte(iot, ioh, TAV_DRAM_EXT)));

	tav_write_byte(iot, ioh, TAV_AUD_ID_EN, 0);
	tav_write_byte(iot, ioh, TAV_SKIP, 0);
	tav_write_byte(iot, ioh, TAV_REPEAT, 0);
	tav_write_byte(iot, ioh, TAV_MUTE, 0);
	tav_write_byte(iot, ioh, TAV_PLAY, 1);
	tav_write_byte(iot, ioh, TAV_SYNC_ECM, 0);
	tav_write_byte(iot, ioh, TAV_CRC_ECM, 0);
	tav_write_byte(iot, ioh, TAV_ATTEN_L, 0);
	tav_write_byte(iot, ioh, TAV_ATTEN_R, 0);
	tav_write_short(iot, ioh, TAV_FREE_FORM, 0);
	tav_write_byte(iot, ioh, TAV_SIN_EN, 0);
	tav_write_byte(iot, ioh, TAV_SYNC_ECM, TAV_ECM_REPEAT);
	tav_write_byte(iot, ioh, TAV_CRC_ECM, TAV_ECM_REPEAT);

	sc->sc_active = 0;

	audio_attach_mi(&tav_audio_if, sc, sc->sc_dev);
}

int
tms320av110_intr(void *p)
{
	struct tav_softc *sc;
	uint16_t intlist;

	sc = p;

	mutex_spin_enter(&sc->sc_intr_lock);

	intlist = tav_read_short(sc->sc_iot, sc->sc_ioh, TAV_INTR)
	    /* & tav_read_short(sc->sc_iot, sc->sc_ioh, TAV_INTR_EN)*/;

	if (!intlist) {
		mutex_spin_exit(&sc->sc_intr_lock);
		return 0;
	}

	/* ack now, so that we don't miss later interrupts */
	if (sc->sc_intack)
		(sc->sc_intack)(sc);

	if (intlist & TAV_INTR_LOWWATER) {
		(*sc->sc_intr)(sc->sc_intrarg);
	}

	mutex_spin_exit(&sc->sc_intr_lock);

	return 1;
}

void
tav_close(void *hdl)
{
	struct tav_softc *sc;
	bus_space_tag_t iot;
	bus_space_handle_t ioh;

	sc = hdl;
	iot = sc->sc_iot;
	ioh = sc->sc_ioh;

	/* re"start" chip, also clears interrupts and interrupt enable */
	tav_write_short(iot, ioh, TAV_INTR_EN, 0);
	if (sc->sc_intack)
		(*sc->sc_intack)(sc);
}

int
tav_query_format(void *hdl, audio_format_query_t *afp)
{

	return audio_query_format(tav_formats, TAV_NFORMATS, afp);
}

int
tav_start_input(void *hdl, void *block, int bsize,
    void (*intr)(void *), void *intrarg)
{

	return ENOTTY;
}

int
tav_halt_input(void *hdl)
{

	return ENOTTY;
}

int
tav_start_output(void *hdl, void *block, int bsize,
    void (*intr)(void *), void *intrarg)
{
	struct tav_softc *sc;
	bus_space_tag_t iot;
	bus_space_handle_t ioh;
	uint8_t *ptr;
	int count;

	sc = hdl;
	iot = sc->sc_iot;
	ioh = sc->sc_ioh;
	ptr = block;
	count = bsize;

	sc->sc_intr = intr;
	sc->sc_intrarg = intrarg;

	if (sc->sc_active == 0) {
		tav_write_byte(iot, ioh, TAV_PLAY, 1);
		tav_write_byte(iot, ioh, TAV_MUTE, 0);
		sc->sc_active = 1;
	}

	bus_space_write_multi_1(iot, ioh, TAV_DATAIN, ptr, count);
	tav_write_short(iot, ioh, TAV_INTR_EN, TAV_INTR_LOWWATER);

	return 0;
}

int
tav_halt_output(void *hdl)
{
	struct tav_softc *sc;
	bus_space_tag_t iot;
	bus_space_handle_t ioh;

	sc = hdl;
	iot = sc->sc_iot;
	ioh = sc->sc_ioh;

	tav_write_byte(iot, ioh, TAV_PLAY, 0);
	sc->sc_active = 0;

	return 0;
}

int
tav_getdev(void *hdl, struct audio_device *ret)
{
	struct tav_softc *sc;
	bus_space_tag_t iot;
	bus_space_handle_t ioh;

	sc = hdl;
	iot = sc->sc_iot;
	ioh = sc->sc_ioh;

	strlcpy(ret->name, "tms320av110", sizeof(ret->name));
	/* guaranteed to be <= 4 in length */
	snprintf(ret->version, sizeof(ret->version), "%u",
	    tav_read_byte(iot, ioh, TAV_VERSION));
	strlcpy(ret->config, device_xname(sc->sc_dev), sizeof(ret->config));

	return 0;
}

int
tav_round_blocksize(void *hdl, int size, int mode, const audio_params_t *param)
{
	struct tav_softc *sc;
	bus_space_tag_t iot;
	bus_space_handle_t ioh;
	int maxhalf;

	sc = hdl;
	iot = sc->sc_iot;
	ioh = sc->sc_ioh;

	maxhalf = TAV_DRAM_HSIZE(tav_read_byte(iot, ioh, TAV_DRAM_EXT));
	if (size > maxhalf)
		size = maxhalf;

	/* XXX should round to 128 bytes limits for audio bypass */
	size &= ~3;

	tav_write_short(iot, ioh, TAV_BALE_LIM, size/8);

	/* the buffer limits are in units of 4 bytes */
	return (size);
}

int
tav_get_props(void *hdl)
{

	return AUDIO_PROP_PLAYBACK | AUDIO_PROP_CAPTURE;
}

void
tav_get_locks(void *hdl, kmutex_t **intr, kmutex_t **thread)
{
	struct tav_softc *sc;

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

int
tav_set_format(void *hdl, int setmode,
    const audio_params_t *p, const audio_params_t *r,
    audio_filter_reg_t *pfil, audio_filter_reg_t *rfil)
{
	struct tav_softc *sc;
	bus_space_tag_t iot;
	bus_space_handle_t ioh;

	sc = hdl;
	iot = sc->sc_iot;
	ioh = sc->sc_ioh;

	KASSERT((setmode & AUMODE_PLAY));
	KASSERT(p->encoding == AUDIO_ENCODING_SLINEAR_BE);

	bus_space_write_1(iot, ioh, TAV_STR_SEL, TAV_STR_SEL_AUDIO_BYPASS);

	tav_write_byte(iot, ioh, TAV_RESTART, 1);
	do {
		delay(10);
	} while (tav_read_byte(iot, ioh, TAV_RESTART));

	return 0;
}

int
tav_set_port(void *hdl, mixer_ctrl_t *mc)
{

	/* dummy */
	return 0;
}

int
tav_get_port(void *hdl, mixer_ctrl_t *mc)
{

	/* dummy */
	return 0;
}

int
tav_query_devinfo(void *hdl, mixer_devinfo_t *di)
{
	return ENXIO;
}

int
tav_speaker_ctl(void *hdl, int value)
{
	struct tav_softc *sc;
	bus_space_tag_t iot;
	bus_space_handle_t ioh;

	sc = hdl;
	iot = sc->sc_iot;
	ioh = sc->sc_ioh;

	tav_write_byte(iot, ioh, TAV_MUTE, !value);

	return 0;
}