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

/*-
 * Copyright (c) 2012 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Paul Fleischer <paul (at) xpg.dk>
 *
 * 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.
 */

#include <sys/cdefs.h>

#include <sys/param.h>
#include <sys/device.h>
#include <sys/audioio.h>
#include <sys/fcntl.h>

#include <dev/audio_if.h>

#include <dev/ic/uda1341var.h>
#include <dev/ic/uda1341reg.h>

/*#define UDA1341_DEBUG*/

#ifdef UDA1341_DEBUG
#define DPRINTF(x) do {printf x; } while (/*CONSTCOND*/0)
#else
#define DPRINTF(s) do {} while (/*CONSTCOND*/0)
#endif

const struct audio_format uda1341_formats[UDA1341_NFORMATS] =
{
	{NULL, AUMODE_PLAY|AUMODE_RECORD, AUDIO_ENCODING_SLINEAR_LE, 8, 8, 2,
	 AUFMT_STEREO, 0, {8000, 48000}
	},
	{NULL, AUMODE_PLAY|AUMODE_RECORD, AUDIO_ENCODING_SLINEAR_LE, 16, 16, 2,
	 AUFMT_STEREO, 0, {8000, 48000}
	},
	{NULL, AUMODE_PLAY|AUMODE_RECORD, AUDIO_ENCODING_ULINEAR_LE, 8, 8, 2,
	 AUFMT_STEREO, 0, {8000, 48000}
	},
	{NULL, AUMODE_PLAY|AUMODE_RECORD, AUDIO_ENCODING_ULINEAR_LE, 16, 16, 2,
	 AUFMT_STEREO, 0, {8000, 48000}
	},
};

static void uda1341_update_sound_settings(struct uda1341_softc *sc);


int
uda1341_attach(struct uda1341_softc *sc)
{
	sc->sc_system_clock = UDA1341_CLOCK_NA;
	sc->sc_l3_write = NULL;
	sc->sc_volume = 127;
	sc->sc_bass = 0;
	sc->sc_treble = 0;
	sc->sc_mode = 0;
	sc->sc_mute = 0;
	sc->sc_ogain = 0;
	sc->sc_deemphasis = UDA1341_DEEMPHASIS_AUTO;
	sc->sc_dac_power = 0;
	sc->sc_adc_power = 0;
	sc->sc_inmix1 = 0;
	sc->sc_inmix2 = 0;
	sc->sc_micvol = 0;
	sc->sc_inmode = 0;
	sc->sc_agc = 0;
	sc->sc_agc_lvl = 0;
	sc->sc_ch2_gain = 0;

	return 0;
}

int
uda1341_query_encodings(void *handle, audio_encoding_t *ae)
{
	switch(ae->index) {
	case 0:
		strlcpy(ae->name, AudioEmulaw, sizeof(ae->name));
		ae->encoding = AUDIO_ENCODING_ULAW;
		ae->precision = 8;
		ae->flags = AUDIO_ENCODINGFLAG_EMULATED;
		break;
	case 1:
		strlcpy(ae->name, AudioEslinear_le, sizeof(ae->name));
		ae->encoding = AUDIO_ENCODING_SLINEAR_LE;
		ae->precision = 8;
		ae->flags = 0;
		break;
	case 2:
		strlcpy(ae->name, AudioEslinear_le, sizeof(ae->name));
		ae->encoding = AUDIO_ENCODING_SLINEAR_LE;
		ae->precision = 16;
		ae->flags = 0;
		break;
	case 3:
		strlcpy(ae->name, AudioEulinear_le, sizeof(ae->name));
		ae->encoding = AUDIO_ENCODING_ULINEAR_LE;
		ae->precision = 8;
		ae->flags = 0;
		break;
	case 4:
		strlcpy(ae->name, AudioEulinear_le, sizeof(ae->name));
		ae->encoding = AUDIO_ENCODING_ULINEAR_LE;
		ae->precision = 16;
		ae->flags = 0;
		break;

	default:
		return EINVAL;
	}

	return 0;
}

int
uda1341_open(void *handle, int flags)
{
	struct uda1341_softc *sc = handle;

	/* Reset the UDA1341 */
	sc->sc_l3_write(sc, 0, UDA1341_L3_ADDR_DEVICE |
			UDA1341_L3_ADDR_STATUS);
	sc->sc_l3_write(sc, 1,
			UDA1341_L3_STATUS0 |
			UDA1341_L3_STATUS0_RST);

	if (flags & FREAD) {
		sc->sc_adc_power = 1;
	}
	if (flags & FWRITE) {
		sc->sc_dac_power = 1;
	}

#if 0
	/* Power on DAC */
	sc->sc_l3_write(sc, 1,
			UDA1341_L3_STATUS1 | UDA1341_L3_STATUS1_PC_DAC);
#endif
	uda1341_update_sound_settings(sc);

#if 0
	/* TODO: Add mixer support */
	sc->sc_l3_write(sc, 0, 0x14 | 0x0);
	sc->sc_l3_write(sc, 1, 0x15);  /* Volume */
#endif

	return 0;
}

void
uda1341_close(void *handle)
{
	struct uda1341_softc *sc = handle;
	/* Reset the UDA1341 */
	sc->sc_l3_write(sc, 0, UDA1341_L3_ADDR_DEVICE |
			UDA1341_L3_ADDR_STATUS);

	/* Power off DAC and ADC*/
	sc->sc_l3_write(sc, 1,
			UDA1341_L3_STATUS1);

	sc->sc_dac_power = 0;
	sc->sc_adc_power = 0;
}

int
uda1341_set_params(void *handle, int setmode, int usemode,
		   audio_params_t *play, audio_params_t *rec,
		   stream_filter_list_t *pfil, stream_filter_list_t *rfil)
{
	struct uda1341_softc *sc = handle;
	if (sc->sc_system_clock == UDA1341_CLOCK_NA)
		panic("uda1341_set_params was called without sc_system_clock set!\n");

	/* Select status register */
	sc->sc_l3_write(sc, 0, UDA1341_L3_ADDR_DEVICE |
			UDA1341_L3_ADDR_STATUS);

	sc->sc_l3_write(sc, 1, UDA1341_L3_STATUS0 |
			sc->sc_system_clock << UDA1341_L3_STATUS0_SC_SHIFT |
			sc->sc_bus_format << UDA1341_L3_STATUS0_IF_SHIFT
			);

	if (sc->sc_sample_rate_approx != play->sample_rate) {
		sc->sc_sample_rate_approx = play->sample_rate;
		uda1341_update_sound_settings(sc);
	}

	return 0;
}

#define AUDIO_LEVELS	(AUDIO_MAX_GAIN-AUDIO_MIN_GAIN+1)
static void
uda1341_update_sound_settings(struct uda1341_softc *sc)
{
	/* TODO: Refactor this function into smaller parts, such that
	 * a volume change does not trigger updates of all the
	 * other -- unrelated -- registers.
	 */

	uint8_t val, volume, bass, treble, deemphasis;

	sc->sc_l3_write(sc, 0, UDA1341_L3_ADDR_DEVICE | UDA1341_L3_ADDR_STATUS);
	val = UDA1341_L3_STATUS1;
	if (sc->sc_dac_power)
		val |= UDA1341_L3_STATUS1_PC_DAC;
	if (sc->sc_adc_power)
		val |= UDA1341_L3_STATUS1_PC_ADC;
	if (sc->sc_ogain)
		val |= UDA1341_L3_STATUS1_OGS_6DB;

	sc->sc_l3_write(sc, 1, val);

	sc->sc_l3_write(sc, 0, UDA1341_L3_ADDR_DEVICE | UDA1341_L3_ADDR_DATA0);

	/* Update volume */
	/* On the UDA1341 maximal volume is 0x0,
	   while minimal volume is 0x3f */
	volume = (0x3f) - ((sc->sc_volume*(0x3f+1)) / (AUDIO_LEVELS));

	val = UDA1341_L3_DATA0_VOLUME;
	val |= volume & UDA1341_L3_DATA0_VOLUME_MASK;
	sc->sc_l3_write(sc, 1, val);

	/* Update bass and treble */
	bass = (sc->sc_bass*(0xf+1)) / AUDIO_LEVELS;
	treble = (sc->sc_treble*(0x3+1)) / AUDIO_LEVELS;
	val = UDA1341_L3_DATA0_BASS_TREBLE;
	val |= (bass << UDA1341_L3_DATA0_BASS_SHIFT) &
		UDA1341_L3_DATA0_BASS_MASK;
	val |= (treble << UDA1341_L3_DATA0_TREBLE_SHIFT) &
		UDA1341_L3_DATA0_TREBLE_MASK;
	sc->sc_l3_write(sc, 1, val);

	/* Update the remaining output sound controls:
	 * - Peak-detect position
	 * - De-emphasis
	 * - Mute
	 * - Mode Switch
	 * XXX: Only Mode-switch, de-emphasis, and mute is currently supported.
	 */
	val = UDA1341_L3_DATA0_SOUNDC;

	deemphasis = sc->sc_deemphasis;
	if( deemphasis == UDA1341_DEEMPHASIS_AUTO) {
		/* Set deemphasis according to current sample rate */
		switch (sc->sc_sample_rate_approx) {
		case 32000:
			deemphasis = 0x1;
			break;
		case 44100:
			deemphasis = 0x2;
			break;
		case 48000:
			deemphasis = 0x3;
			break;
		default:
			deemphasis = 0x0;
		}
	}

	DPRINTF(("Deemphasis: %d\n", deemphasis));
	val |= (deemphasis << UDA1341_L3_DATA0_SOUNDC_DE_SHIFT) &
		UDA1341_L3_DATA0_SOUNDC_DE_MASK;

	if (sc->sc_mute)
		val |= UDA1341_L3_DATA0_SOUNDC_MUTE;
	val |= sc->sc_mode & UDA1341_L3_DATA0_SOUNDC_MODE_MASK;
	sc->sc_l3_write(sc, 1, val);

	/* Extended Register 0: MA */
	val = UDA1341_L3_DATA0_ED;
	val |= (sc->sc_inmix1 & UDA1341_L3_DATA0_MA_MASK);
	sc->sc_l3_write(sc, 1, UDA1341_L3_DATA0_EA | 0x0);
	sc->sc_l3_write(sc, 1, val);

	/* Extended Register 1: MB */
	val = UDA1341_L3_DATA0_ED;
	val |= (sc->sc_inmix2 & UDA1341_L3_DATA0_MB_MASK);
	sc->sc_l3_write(sc, 1, UDA1341_L3_DATA0_EA | 0x01);
	sc->sc_l3_write(sc, 1, val);

	/* Extended Register 2: MIC sensitivity and mixer mode  */
	val = UDA1341_L3_DATA0_ED;
	val |= (sc->sc_micvol << UDA1341_L3_DATA0_MS_SHIFT) &
		UDA1341_L3_DATA0_MS_MASK;
	val |= sc->sc_inmode & UDA1341_L3_DATA0_MM_MASK;
	sc->sc_l3_write(sc, 1, UDA1341_L3_DATA0_EA | 0x02);
	sc->sc_l3_write(sc, 1, val);

	/* Extended Register 4: AGC and IG (ch2_gain) */
	val = UDA1341_L3_DATA0_ED;

	val |= (sc->sc_agc << UDA1341_L3_DATA0_AGC_SHIFT) &
		UDA1341_L3_DATA0_AGC_MASK;
	val |= (sc->sc_ch2_gain & 0x03) & UDA1341_L3_DATA0_IG_LOW_MASK;
	sc->sc_l3_write(sc, 1, UDA1341_L3_DATA0_EA | 0x04);
	sc->sc_l3_write(sc, 1, val);

	/* Extended Register 5: IG (ch2_gain) */
	val = UDA1341_L3_DATA0_ED;
	val |= (sc->sc_ch2_gain >> 2 ) & UDA1341_L3_DATA0_IG_HIGH_MASK;
	sc->sc_l3_write(sc, 1, UDA1341_L3_DATA0_EA | 0x05);
	sc->sc_l3_write(sc, 1, val);

	/* Extended Register 6: AT and AL */
	/* XXX: Only AL is supported at this point */
	val = UDA1341_L3_DATA0_ED;
	val |= sc->sc_agc_lvl & UDA1341_L3_DATA0_AL_MASK;
	sc->sc_l3_write(sc, 1, UDA1341_L3_DATA0_EA | 0x06);
	sc->sc_l3_write(sc, 1, val);
}

#define UDA1341_MIXER_VOL	0
#define UDA1341_MIXER_BASS	1
#define UDA1341_MIXER_TREBLE	2
#define UDA1341_MIXER_MODE	3
#define UDA1341_MIXER_MUTE	4
#define UDA1341_MIXER_OGAIN	5
#define UDA1341_MIXER_DE	6
#define UDA1341_OUTPUT_CLASS	7

#define UDA1341_MIXER_INMIX1	8
#define UDA1341_MIXER_INMIX2	9
#define UDA1341_MIXER_MICVOL	10
#define UDA1341_MIXER_INMODE	11
#define UDA1341_MIXER_AGC	12
#define UDA1341_MIXER_AGC_LVL	13
#define UDA1341_MIXER_IN_GAIN2	14
/*#define UDA1341_MIXER_AGC_SETTINGS 15*/
#define UDA1341_INPUT_CLASS	15

int
uda1341_query_devinfo(void *handle, mixer_devinfo_t *mi)
{

	switch(mi->index) {
	case UDA1341_MIXER_VOL:
		strlcpy(mi->label.name, AudioNspeaker,
			sizeof(mi->label.name));
		mi->type = AUDIO_MIXER_VALUE;
		mi->mixer_class = UDA1341_OUTPUT_CLASS;
		mi->next = UDA1341_MIXER_BASS;
		mi->prev = AUDIO_MIXER_LAST;
		strlcpy(mi->un.v.units.name, AudioNvolume,
			sizeof(mi->un.v.units.name));
		mi->un.v.num_channels = 1;
		mi->un.v.delta = 256/64;
		break;
	case UDA1341_MIXER_BASS:
		strlcpy(mi->label.name, AudioNbass,
			sizeof(mi->label.name));
		mi->type = AUDIO_MIXER_VALUE;
		mi->mixer_class = UDA1341_OUTPUT_CLASS;
		mi->next = UDA1341_MIXER_TREBLE;
		mi->prev = UDA1341_MIXER_VOL;
		strlcpy(mi->un.v.units.name, AudioNbass,
			sizeof(mi->un.v.units.name));
		mi->un.v.num_channels = 1;
		mi->un.v.delta = 256/16;
		break;
	case UDA1341_MIXER_TREBLE:
		strlcpy(mi->label.name, AudioNtreble,
			sizeof(mi->label.name));
		mi->type = AUDIO_MIXER_VALUE;
		mi->mixer_class = UDA1341_OUTPUT_CLASS;
		mi->next = UDA1341_MIXER_MODE;
		mi->prev = UDA1341_MIXER_BASS;
		strlcpy(mi->un.v.units.name, AudioNtreble,
			sizeof(mi->un.v.units.name));
		mi->un.v.num_channels = 1;
		mi->un.v.delta = 256/4;
		break;
	case UDA1341_MIXER_MODE:
		strlcpy(mi->label.name, AudioNmode,
			sizeof(mi->label.name));
		mi->type = AUDIO_MIXER_ENUM;
		mi->mixer_class = UDA1341_OUTPUT_CLASS;
		mi->next = UDA1341_MIXER_MUTE;
		mi->prev = UDA1341_MIXER_TREBLE;
		mi->un.e.num_mem = 3;

		strlcpy(mi->un.e.member[0].label.name,
			"flat", sizeof(mi->un.e.member[0].label.name));
		mi->un.e.member[0].ord = 0;

		strlcpy(mi->un.e.member[1].label.name,
			"minimum", sizeof(mi->un.e.member[1].label.name));
		mi->un.e.member[1].ord = 1;

		strlcpy(mi->un.e.member[2].label.name,
			"maximum", sizeof(mi->un.e.member[2].label.name));
		mi->un.e.member[2].ord = 3;

		break;
	case UDA1341_MIXER_MUTE:
		strlcpy(mi->label.name, AudioNmute,
			sizeof(mi->label.name));
		mi->type = AUDIO_MIXER_ENUM;
		mi->mixer_class = UDA1341_OUTPUT_CLASS;
		mi->next = UDA1341_MIXER_OGAIN;
		mi->prev = UDA1341_MIXER_MODE;
		mi->un.e.num_mem = 2;

		strlcpy(mi->un.e.member[0].label.name,
			"off", sizeof(mi->un.e.member[0].label.name));
		mi->un.e.member[0].ord = 0;

		strlcpy(mi->un.e.member[1].label.name,
			"on", sizeof(mi->un.e.member[1].label.name));
		mi->un.e.member[1].ord = 1;
		break;
	case UDA1341_MIXER_OGAIN:
		strlcpy(mi->label.name, "gain",
			sizeof(mi->label.name));
		mi->type = AUDIO_MIXER_ENUM;
		mi->mixer_class = UDA1341_OUTPUT_CLASS;
		mi->next = UDA1341_MIXER_DE;
		mi->prev = UDA1341_MIXER_MUTE;
		mi->un.e.num_mem = 2;

		strlcpy(mi->un.e.member[0].label.name,
			"off", sizeof(mi->un.e.member[0].label.name));
		mi->un.e.member[0].ord = 0;

		strlcpy(mi->un.e.member[1].label.name,
			"on", sizeof(mi->un.e.member[1].label.name));
		mi->un.e.member[1].ord = 1;
		break;
	case UDA1341_MIXER_DE:
		strlcpy(mi->label.name, "deemphasis",
			sizeof(mi->label.name));
		mi->type = AUDIO_MIXER_ENUM;
		mi->mixer_class = UDA1341_OUTPUT_CLASS;
		mi->next = AUDIO_MIXER_LAST;
		mi->prev = UDA1341_MIXER_OGAIN;
		mi->un.e.num_mem = 5;

		strlcpy(mi->un.e.member[0].label.name,
			"none", sizeof(mi->un.e.member[0].label.name));
		mi->un.e.member[0].ord = 0;

		strlcpy(mi->un.e.member[1].label.name,
			"32KHz", sizeof(mi->un.e.member[1].label.name));
		mi->un.e.member[1].ord = 1;

		strlcpy(mi->un.e.member[2].label.name,
			"44.1KHz", sizeof(mi->un.e.member[2].label.name));
		mi->un.e.member[2].ord = 2;

		strlcpy(mi->un.e.member[3].label.name,
			"48KHz", sizeof(mi->un.e.member[3].label.name));
		mi->un.e.member[3].ord = 3;

		strlcpy(mi->un.e.member[4].label.name,
			"auto", sizeof(mi->un.e.member[4].label.name));
		mi->un.e.member[4].ord = 4;

		break;
	case UDA1341_OUTPUT_CLASS:
		mi->type = AUDIO_MIXER_CLASS;
		mi->mixer_class = UDA1341_OUTPUT_CLASS;
		mi->prev = AUDIO_MIXER_LAST;
		mi->next = AUDIO_MIXER_LAST;
		strlcpy(mi->label.name, AudioCoutputs,
			sizeof(mi->label.name));
		break;
	case UDA1341_MIXER_INMIX1:
		strlcpy(mi->label.name, "inmix1",
			sizeof(mi->label.name));
		mi->type = AUDIO_MIXER_VALUE;
		mi->mixer_class = UDA1341_INPUT_CLASS;
		mi->next = AUDIO_MIXER_LAST;
		mi->prev = AUDIO_MIXER_LAST;
		strlcpy(mi->un.v.units.name, AudioNvolume,
			sizeof(mi->un.v.units.name));
		mi->un.v.num_channels = 1;
		mi->un.v.delta = 256/64;
		break;
	case UDA1341_MIXER_INMIX2:
		strlcpy(mi->label.name, "inmix2",
			sizeof(mi->label.name));
		mi->type = AUDIO_MIXER_VALUE;
		mi->mixer_class = UDA1341_INPUT_CLASS;
		mi->next = AUDIO_MIXER_LAST;
		mi->prev = AUDIO_MIXER_LAST;
		strlcpy(mi->un.v.units.name, AudioNvolume,
			sizeof(mi->un.v.units.name));
		mi->un.v.num_channels = 1;
		mi->un.v.delta = 256/64;
		break;
	case UDA1341_MIXER_MICVOL:
		strlcpy(mi->label.name, AudioNmicrophone,
			sizeof(mi->label.name));
		mi->type = AUDIO_MIXER_VALUE;
		mi->mixer_class = UDA1341_INPUT_CLASS;
		mi->next = AUDIO_MIXER_LAST;
		mi->prev = AUDIO_MIXER_LAST;
		strlcpy(mi->un.v.units.name, AudioNvolume,
			sizeof(mi->un.v.units.name));
		mi->un.v.num_channels = 1;
		mi->un.v.delta = 256/8;
		break;
	case UDA1341_MIXER_INMODE:
		strlcpy(mi->label.name, "inmode",
			sizeof(mi->label.name));
		mi->type = AUDIO_MIXER_ENUM;
		mi->mixer_class = UDA1341_INPUT_CLASS;
		mi->next = AUDIO_MIXER_LAST;
		mi->prev = AUDIO_MIXER_LAST;
		mi->un.e.num_mem = 4;

		strlcpy(mi->un.e.member[0].label.name,
			"dd", sizeof(mi->un.e.member[0].label.name));
		mi->un.e.member[0].ord = 0;

		strlcpy(mi->un.e.member[1].label.name,
			"ch1", sizeof(mi->un.e.member[1].label.name));
		mi->un.e.member[1].ord = 1;

		strlcpy(mi->un.e.member[2].label.name,
			"ch2", sizeof(mi->un.e.member[2].label.name));
		mi->un.e.member[2].ord = 2;

		strlcpy(mi->un.e.member[3].label.name,
			"mix", sizeof(mi->un.e.member[3].label.name));
		mi->un.e.member[3].ord = 3;
		break;
	case UDA1341_MIXER_AGC:
		strlcpy(mi->label.name, "agc",
			sizeof(mi->label.name));
		mi->type = AUDIO_MIXER_ENUM;
		mi->mixer_class = UDA1341_INPUT_CLASS;
		mi->next = AUDIO_MIXER_LAST;
		mi->prev = AUDIO_MIXER_LAST;
		mi->un.e.num_mem = 2;

		strlcpy(mi->un.e.member[0].label.name,
			"off", sizeof(mi->un.e.member[0].label.name));
		mi->un.e.member[0].ord = 0;

		strlcpy(mi->un.e.member[1].label.name,
			"on", sizeof(mi->un.e.member[1].label.name));
		mi->un.e.member[1].ord = 1;
		break;
	case UDA1341_MIXER_AGC_LVL:
		strlcpy(mi->label.name, "agclevel",
			sizeof(mi->label.name));
		mi->type = AUDIO_MIXER_VALUE;
		mi->mixer_class = UDA1341_INPUT_CLASS;
		mi->next = AUDIO_MIXER_LAST;
		mi->prev = AUDIO_MIXER_LAST;
		strlcpy(mi->un.v.units.name, AudioNvolume,
			sizeof(mi->un.v.units.name));
		mi->un.v.num_channels = 1;
		mi->un.v.delta = 256/4;
		break;
	case UDA1341_MIXER_IN_GAIN2:
		strlcpy(mi->label.name, "ch2gain",
			sizeof(mi->label.name));
		mi->type = AUDIO_MIXER_VALUE;
		mi->mixer_class = UDA1341_INPUT_CLASS;
		mi->next = AUDIO_MIXER_LAST;
		mi->prev = AUDIO_MIXER_LAST;
		strlcpy(mi->un.v.units.name, AudioNvolume,
			sizeof(mi->un.v.units.name));
		mi->un.v.num_channels = 1;
		mi->un.v.delta = 256/128;
		break;
	case UDA1341_INPUT_CLASS:
		mi->type = AUDIO_MIXER_CLASS;
		mi->mixer_class = UDA1341_INPUT_CLASS;
		mi->prev = AUDIO_MIXER_LAST;
		mi->next = AUDIO_MIXER_LAST;
		strlcpy(mi->label.name, AudioCinputs,
			sizeof(mi->label.name));
		break;
	default:
		return ENXIO;
	}

	return 0;
}

int
uda1341_get_port(void *handle, mixer_ctrl_t *mixer)
{
	struct uda1341_softc *sc = handle;

	switch(mixer->dev) {
	case UDA1341_MIXER_VOL:
		if (mixer->type != AUDIO_MIXER_VALUE)
			return EINVAL;
		if (mixer->un.value.num_channels != 1)
			return EINVAL;
		mixer->un.value.level[AUDIO_MIXER_LEVEL_MONO] =
			sc->sc_volume;
		break;
	case UDA1341_MIXER_BASS:
		if (mixer->type != AUDIO_MIXER_VALUE ||
		    mixer->un.value.num_channels != 1)
			return EINVAL;

		mixer->un.value.level[0] = sc->sc_bass;
		break;
	case UDA1341_MIXER_TREBLE:
		if (mixer->type != AUDIO_MIXER_VALUE ||
		    mixer->un.value.num_channels != 1)
			return EINVAL;

		mixer->un.value.level[0] = sc->sc_treble;
		break;
	case UDA1341_MIXER_MODE:
		if (mixer->type != AUDIO_MIXER_ENUM)
			return EINVAL;

		mixer->un.ord = sc->sc_mode;
		break;
	case UDA1341_MIXER_MUTE:
		if (mixer->type != AUDIO_MIXER_ENUM)
			return EINVAL;

		mixer->un.ord = sc->sc_mute;
		break;
	case UDA1341_MIXER_OGAIN:
		if (mixer->type != AUDIO_MIXER_ENUM)
			return EINVAL;

		mixer->un.ord = sc->sc_ogain;
		break;
	case UDA1341_MIXER_DE:
		if (mixer->type != AUDIO_MIXER_ENUM)
			return EINVAL;

		mixer->un.ord = sc->sc_deemphasis;
		break;
	case UDA1341_MIXER_INMIX1:
		if (mixer->type != AUDIO_MIXER_VALUE)
			return EINVAL;

		mixer->un.value.level[0] = sc->sc_inmix1;
		break;
	case UDA1341_MIXER_INMIX2:
		if (mixer->type != AUDIO_MIXER_VALUE)
			return EINVAL;

		mixer->un.value.level[0] = sc->sc_inmix2;
		break;
	case UDA1341_MIXER_MICVOL:
		if (mixer->type != AUDIO_MIXER_VALUE)
			return EINVAL;

		mixer->un.value.level[0] = sc->sc_micvol;
		break;
	case UDA1341_MIXER_INMODE:
		if (mixer->type != AUDIO_MIXER_ENUM)
			return EINVAL;

		mixer->un.ord =	sc->sc_inmode;
		break;
	case UDA1341_MIXER_AGC:
		if (mixer->type != AUDIO_MIXER_ENUM)
			return EINVAL;

		mixer->un.ord =	sc->sc_agc;
		break;
	case UDA1341_MIXER_AGC_LVL:
		if (mixer->type != AUDIO_MIXER_VALUE)
			return EINVAL;

		mixer->un.value.level[0] = sc->sc_agc_lvl;
		break;
	case UDA1341_MIXER_IN_GAIN2:
		if (mixer->type != AUDIO_MIXER_VALUE)
			return EINVAL;

		mixer->un.value.level[0] = sc->sc_ch2_gain;
		break;
	default:
		return EINVAL;
	}

	return 0;
}

int
uda1341_set_port(void *handle, mixer_ctrl_t *mixer)
{
	struct uda1341_softc *sc = handle;

	switch(mixer->dev) {
	case UDA1341_MIXER_VOL:
		sc->sc_volume = mixer->un.value.level[0];
		break;
	case UDA1341_MIXER_BASS:
		sc->sc_bass = mixer->un.value.level[0];
		break;
	case UDA1341_MIXER_TREBLE:
		sc->sc_treble = mixer->un.value.level[0];
		break;
	case UDA1341_MIXER_MODE:
		sc->sc_mode = mixer->un.ord;
		break;
	case UDA1341_MIXER_MUTE:
		sc->sc_mute = mixer->un.ord;
		break;
	case UDA1341_MIXER_OGAIN:
		sc->sc_ogain = mixer->un.ord;
		break;
	case UDA1341_MIXER_DE:
		sc->sc_deemphasis = mixer->un.ord;
		break;
	case UDA1341_MIXER_INMIX1:
		sc->sc_inmix1 = mixer->un.value.level[0];
		break;
	case UDA1341_MIXER_INMIX2:
		sc->sc_inmix2 = mixer->un.value.level[0];
		break;
	case UDA1341_MIXER_MICVOL:
		sc->sc_micvol = mixer->un.value.level[0];
		break;
	case UDA1341_MIXER_INMODE:
		sc->sc_inmode = mixer->un.ord;
		break;
	case UDA1341_MIXER_AGC:
		sc->sc_agc = mixer->un.ord;
		break;
	case UDA1341_MIXER_AGC_LVL:
		sc->sc_agc_lvl = mixer->un.value.level[0];
		break;
	case UDA1341_MIXER_IN_GAIN2:
		sc->sc_ch2_gain = mixer->un.value.level[0];
		break;
	default:
		return EINVAL;
	}

	uda1341_update_sound_settings(sc);

	return 0;
}