/*-
 * 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@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/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

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_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_format(void *handle, int setmode,
                   const audio_params_t *play, const audio_params_t *rec,
                   audio_filter_reg_t *pfil, audio_filter_reg_t *rfil)
{
        struct uda1341_softc *sc = handle;
        if (sc->sc_system_clock == UDA1341_CLOCK_NA)
                panic("%s was called without sc_system_clock set!\n", __func__);

        /* 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;
}