Aren/NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
dc51abea5c
NetBSD/sys/dev/ic/uda1341.c
isaki e622eac459 Merge isaki-audio2 branch, the overhaul of audio subsystem. 
- Interrupt-oriented system rather than thread-oriented.
- Improve stability, quality and performance.
- Split playback and record cleanly.  Improve halfduplex support.
- Many bugs are fixed including deadlocks, resource leaks, abuses, etc.
- Simplify audio filter mechanism.  The encoding/channels/frequency
  conversions are completely handled in the upper layer.  So the hard-
  ware driver only converts its hardware encoding (if necessary).
- audio_hw_if changes:
  - Obsoletes query_encoding and add query_format instead.
  - Obsoletes set_params and add set_format instead.
  - Remove drain, setfd, mappage.
  - The call sequences are changed.
- ioctl AUDIO_GETFD/SETFD, AUDIO_GETCHAN/SETCHAN are obsoleted.
- ioctl AUDIO_{QUERY,GET,SET}FORMAT are introduced.
- cleanup config attributes: au*conv and mulaw.
- All hardware drivers should follow it (I've done as much as possible).

Some file paths are changed:
- dev/audio.c         -> dev/audio/audio.c (rewritten)
- dev/audiovar.h      -> dev/audio/audiovar.h
- dev/audio_dai.h     -> dev/audio/audio_dai.h
- dev/audio_if.h      -> dev/audio/audio_if.h
- dev/audiobell.c     -> dev/audio/audiobell.c
- dev/audiobellvar.h  -> dev/audio/audiobellvar.h
- dev/mulaw.[ch]      -> dev/audio/mulaw.[ch] + dev/audio/alaw.c
2019-05-08 13:40:13 +00:00

705 lines
19 KiB
C
Raw Blame History

/*-
* 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;
}
Reference in New Issue View Git Blame Copy Permalink