static int
tumbler_init(struct snd_mixer *m)
{
struct tumbler_softc *sc;
u_int x = 0;
sc = device_get_softc(mix_getdevinfo(m));
tumbler_write(sc, TUMBLER_LB0, tumbler_initdata.LB0);
tumbler_write(sc, TUMBLER_LB1, tumbler_initdata.LB1);
tumbler_write(sc, TUMBLER_LB2, tumbler_initdata.LB2);
tumbler_write(sc, TUMBLER_LB3, tumbler_initdata.LB3);
tumbler_write(sc, TUMBLER_LB4, tumbler_initdata.LB4);
tumbler_write(sc, TUMBLER_LB5, tumbler_initdata.LB5);
tumbler_write(sc, TUMBLER_RB0, tumbler_initdata.RB0);
tumbler_write(sc, TUMBLER_RB1, tumbler_initdata.RB1);
tumbler_write(sc, TUMBLER_RB1, tumbler_initdata.RB1);
tumbler_write(sc, TUMBLER_RB2, tumbler_initdata.RB2);
tumbler_write(sc, TUMBLER_RB3, tumbler_initdata.RB3);
tumbler_write(sc, TUMBLER_RB4, tumbler_initdata.RB4);
tumbler_write(sc, TUMBLER_RB5, tumbler_initdata.RB5);
tumbler_write(sc, TUMBLER_MCR, tumbler_initdata.MCR);
tumbler_write(sc, TUMBLER_DRC, tumbler_initdata.DRC);
tumbler_write(sc, TUMBLER_VOLUME, tumbler_initdata.VOLUME);
tumbler_write(sc, TUMBLER_TREBLE, tumbler_initdata.TREBLE);
tumbler_write(sc, TUMBLER_BASS, tumbler_initdata.BASS);
tumbler_write(sc, TUMBLER_MIXER1, tumbler_initdata.MIXER1);
tumbler_write(sc, TUMBLER_MIXER2, tumbler_initdata.MIXER2);
x |= SOUND_MASK_VOLUME;
mix_setdevs(m, x);
return (0);
}
static int
screamer_set(struct snd_mixer *m, unsigned dev, unsigned left, unsigned right)
{
struct davbus_softc *d;
int lval, rval;
lval = ((100 - left) * 15 / 100) & 0xf;
rval = ((100 - right) * 15 / 100) & 0xf;
DPRINTF(("volume %d %d\n", lval, rval));
d = mix_getdevinfo(m);
switch (dev) {
case SOUND_MIXER_VOLUME:
mtx_lock(&d->mutex);
screamer_write_locked(d, SCREAMER_CODEC_ADDR2, (lval << 6) |
rval);
screamer_write_locked(d, SCREAMER_CODEC_ADDR4, (lval << 6) |
rval);
mtx_unlock(&d->mutex);
return (left | (right << 8));
}
return (0);
}
static int
onyx_init(struct snd_mixer *m)
{
struct onyx_softc *sc;
u_int x = 0;
sc = device_get_softc(mix_getdevinfo(m));
onyx_write(sc, PCM3052_REG_LEFT_ATTN, onyx_initdata.LEFT_ATTN);
onyx_write(sc, PCM3052_REG_RIGHT_ATTN, onyx_initdata.RIGHT_ATTN);
onyx_write(sc, PCM3052_REG_CONTROL, onyx_initdata.CONTROL);
onyx_write(sc, PCM3052_REG_DAC_CONTROL,
onyx_initdata.DAC_CONTROL);
onyx_write(sc, PCM3052_REG_DAC_DEEMPH, onyx_initdata.DAC_DEEMPH);
onyx_write(sc, PCM3052_REG_DAC_FILTER, onyx_initdata.DAC_FILTER);
onyx_write(sc, PCM3052_REG_OUT_PHASE, onyx_initdata.OUT_PHASE);
onyx_write(sc, PCM3052_REG_ADC_CONTROL,
onyx_initdata.ADC_CONTROL);
onyx_write(sc, PCM3052_REG_ADC_HPF_BP, onyx_initdata.ADC_HPF_BP);
onyx_write(sc, PCM3052_REG_INFO_1, onyx_initdata.INFO_1);
onyx_write(sc, PCM3052_REG_INFO_2, onyx_initdata.INFO_2);
onyx_write(sc, PCM3052_REG_INFO_3, onyx_initdata.INFO_3);
onyx_write(sc, PCM3052_REG_INFO_4, onyx_initdata.INFO_4);
x |= SOUND_MASK_VOLUME;
mix_setdevs(m, x);
return (0);
}
static int
screamer_init(struct snd_mixer *m)
{
struct davbus_softc *d;
d = mix_getdevinfo(m);
d->read_status = screamer_read_status;
d->set_outputs = screamer_set_outputs;
mtx_lock(&d->mutex);
screamer_write_locked(d, SCREAMER_CODEC_ADDR0, SCREAMER_INPUT_CD |
SCREAMER_DEFAULT_CD_GAIN);
screamer_set_outputs(d, screamer_read_status(d,
bus_read_4(d->reg, DAVBUS_CODEC_STATUS)));
screamer_write_locked(d, SCREAMER_CODEC_ADDR2, 0);
screamer_write_locked(d, SCREAMER_CODEC_ADDR4, 0);
screamer_write_locked(d, SCREAMER_CODEC_ADDR5, 0);
screamer_write_locked(d, SCREAMER_CODEC_ADDR6, 0);
mtx_unlock(&d->mutex);
mix_setdevs(m, SOUND_MASK_VOLUME);
return (0);
}
static int
burgundy_set(struct snd_mixer *m, unsigned dev, unsigned left, unsigned right)
{
struct davbus_softc *d;
int lval, rval;
lval = ((100 - left) * 15 / 100) & 0xf;
rval = ((100 - right) * 15 / 100) & 0xf;
DPRINTF(("volume %d %d\n", lval, rval));
d = mix_getdevinfo(m);
switch (dev) {
case SOUND_MIXER_VOLUME:
mtx_lock(&d->mutex);
burgundy_write_locked(d, BURGUNDY_OL13_REG, lval);
burgundy_write_locked(d, BURGUNDY_OL14_REG, (rval << 4) | lval);
burgundy_write_locked(d, BURGUNDY_OL15_REG, (rval << 4) | lval);
burgundy_write_locked(d, BURGUNDY_OL16_REG, (rval << 4) | lval);
burgundy_write_locked(d, BURGUNDY_OL17_REG, lval);
mtx_unlock(&d->mutex);
return (left | (right << 8));
}
return (0);
}
static u_int32_t
ad1816mix_setrecsrc(struct snd_mixer *m, u_int32_t src)
{
struct ad1816_info *ad1816 = mix_getdevinfo(m);
int dev;
switch (src) {
case SOUND_MASK_LINE:
case SOUND_MASK_LINE3:
dev = 0x00;
break;
case SOUND_MASK_CD:
case SOUND_MASK_LINE1:
dev = 0x20;
break;
case SOUND_MASK_MIC:
default:
dev = 0x50;
src = SOUND_MASK_MIC;
}
dev |= dev << 8;
ad1816_lock(ad1816);
ad1816_write(ad1816, 20, (ad1816_read(ad1816, 20) & ~0x7070) | dev);
ad1816_unlock(ad1816);
return src;
}
static int
ua_mixer_set(struct snd_mixer *m, unsigned type, unsigned left, unsigned right)
{
device_t pa_dev;
struct ua_info *ua = mix_getdevinfo(m);
pa_dev = device_get_parent(ua->sc_dev);
uaudio_mixer_set(pa_dev, type, left, right);
return left | (right << 8);
}
static int
burgundy_init(struct snd_mixer *m)
{
struct davbus_softc *d;
d = mix_getdevinfo(m);
d->read_status = burgundy_read_status;
d->set_outputs = burgundy_set_outputs;
/*
* We configure the Burgundy codec as follows:
*
* o Input subframe 0 is connected to input digital
* stream A (ISA).
* o Stream A (ISA) is mixed in mixer 2 (MIX2).
* o Output of mixer 2 (MIX2) is routed to output sources
* OS0 and OS1 which can be converted to analog.
*
*/
mtx_lock(&d->mutex);
burgundy_write_locked(d, 0x16700, 0x40);
burgundy_write_locked(d, BURGUNDY_MIX0_REG, 0);
burgundy_write_locked(d, BURGUNDY_MIX1_REG, 0);
burgundy_write_locked(d, BURGUNDY_MIX2_REG, BURGUNDY_MIX_ISA);
burgundy_write_locked(d, BURGUNDY_MIX3_REG, 0);
burgundy_write_locked(d, BURGUNDY_OS_REG, BURGUNDY_OS0_MIX2 |
BURGUNDY_OS1_MIX2);
burgundy_write_locked(d, BURGUNDY_SDIN_REG, BURGUNDY_ISA_SF0);
/* Set several digital scalers to unity gain. */
burgundy_write_locked(d, BURGUNDY_MXS2L_REG, BURGUNDY_MXS_UNITY);
burgundy_write_locked(d, BURGUNDY_MXS2R_REG, BURGUNDY_MXS_UNITY);
burgundy_write_locked(d, BURGUNDY_OSS0L_REG, BURGUNDY_OSS_UNITY);
burgundy_write_locked(d, BURGUNDY_OSS0R_REG, BURGUNDY_OSS_UNITY);
burgundy_write_locked(d, BURGUNDY_OSS1L_REG, BURGUNDY_OSS_UNITY);
burgundy_write_locked(d, BURGUNDY_OSS1R_REG, BURGUNDY_OSS_UNITY);
burgundy_write_locked(d, BURGUNDY_ISSAL_REG, BURGUNDY_ISS_UNITY);
burgundy_write_locked(d, BURGUNDY_ISSAR_REG, BURGUNDY_ISS_UNITY);
burgundy_set_outputs(d, burgundy_read_status(d,
bus_read_4(d->reg, DAVBUS_CODEC_STATUS)));
mtx_unlock(&d->mutex);
mix_setdevs(m, SOUND_MASK_VOLUME);
return (0);
}
static int
ua_mixer_init(struct snd_mixer *m)
{
u_int32_t mask;
device_t pa_dev;
struct ua_info *ua = mix_getdevinfo(m);
pa_dev = device_get_parent(ua->sc_dev);
mask = uaudio_query_mix_info(pa_dev);
mix_setdevs(m, mask);
return 0;
}
static int
tumbler_set(struct snd_mixer *m, unsigned dev, unsigned left, unsigned right)
{
struct tumbler_softc *sc;
struct mtx *mixer_lock;
int locked;
u_int l, r;
u_char reg[6];
sc = device_get_softc(mix_getdevinfo(m));
mixer_lock = mixer_get_lock(m);
locked = mtx_owned(mixer_lock);
switch (dev) {
case SOUND_MIXER_VOLUME:
if (left > 100 || right > 100)
return (0);
l = (left == 0 ? 0 : tumbler_volume_table[left - 1]);
r = (right == 0 ? 0 : tumbler_volume_table[right - 1]);
reg[0] = (l & 0xff0000) >> 16;
reg[1] = (l & 0x00ff00) >> 8;
reg[2] = l & 0x0000ff;
reg[3] = (r & 0xff0000) >> 16;
reg[4] = (r & 0x00ff00) >> 8;
reg[5] = r & 0x0000ff;
/*
* We need to unlock the mixer lock because iicbus_transfer()
* may sleep. The mixer lock itself is unnecessary here
* because it is meant to serialize hardware access, which
* is taken care of by the I2C layer, so this is safe.
*/
if (locked)
mtx_unlock(mixer_lock);
tumbler_write(sc, TUMBLER_VOLUME, reg);
if (locked)
mtx_lock(mixer_lock);
return (left | (right << 8));
}
return (0);
}
static int
bcmmix_set(struct snd_mixer *m, unsigned dev, unsigned left, unsigned right)
{
struct bcm2835_audio_info *sc = mix_getdevinfo(m);
switch (dev) {
case SOUND_MIXER_VOLUME:
sc->volume = left;
bcm2835_audio_update_controls(sc);
break;
default:
break;
}
return left | (left << 8);
}
static int
ua_mixer_set(struct snd_mixer *m, unsigned type, unsigned left, unsigned right)
{
struct mtx *mtx = mixer_get_lock(m);
uint8_t do_unlock;
if (mtx_owned(mtx)) {
do_unlock = 0;
} else {
do_unlock = 1;
mtx_lock(mtx);
}
uaudio_mixer_set(mix_getdevinfo(m), type, left, right);
if (do_unlock) {
mtx_unlock(mtx);
}
return (left | (right << 8));
}
static int
ua_mixer_set(struct snd_mixer *m, unsigned type, unsigned left, unsigned right)
{
struct lock *lock = mixer_get_lock(m);
uint8_t do_unlock;
if (lockowned(lock)) {
do_unlock = 0;
} else {
do_unlock = 1;
lockmgr(lock, LK_EXCLUSIVE);
}
uaudio_mixer_set(mix_getdevinfo(m), type, left, right);
if (do_unlock) {
lockmgr(lock, LK_RELEASE);
}
return (left | (right << 8));
}
static uint32_t
ua_mixer_setrecsrc(struct snd_mixer *m, uint32_t src)
{
struct lock *lock = mixer_get_lock(m);
int retval;
uint8_t do_unlock;
if (lockowned(lock)) {
do_unlock = 0;
} else {
do_unlock = 1;
lockmgr(lock, LK_EXCLUSIVE);
}
retval = uaudio_mixer_setrecsrc(mix_getdevinfo(m), src);
if (do_unlock) {
lockmgr(lock, LK_RELEASE);
}
return (retval);
}
static uint32_t
ua_mixer_setrecsrc(struct snd_mixer *m, uint32_t src)
{
struct mtx *mtx = mixer_get_lock(m);
int retval;
uint8_t do_unlock;
if (mtx_owned(mtx)) {
do_unlock = 0;
} else {
do_unlock = 1;
mtx_lock(mtx);
}
retval = uaudio_mixer_setrecsrc(mix_getdevinfo(m), src);
if (do_unlock) {
mtx_unlock(mtx);
}
return (retval);
}
static int
snapper_init(struct snd_mixer *m)
{
struct snapper_softc *sc;
u_int x = 0;
sc = device_get_softc(mix_getdevinfo(m));
snapper_write(sc, SNAPPER_LB0, snapper_initdata.LB0);
snapper_write(sc, SNAPPER_LB1, snapper_initdata.LB1);
snapper_write(sc, SNAPPER_LB2, snapper_initdata.LB2);
snapper_write(sc, SNAPPER_LB3, snapper_initdata.LB3);
snapper_write(sc, SNAPPER_LB4, snapper_initdata.LB4);
snapper_write(sc, SNAPPER_LB5, snapper_initdata.LB5);
snapper_write(sc, SNAPPER_LB6, snapper_initdata.LB6);
snapper_write(sc, SNAPPER_RB0, snapper_initdata.RB0);
snapper_write(sc, SNAPPER_RB1, snapper_initdata.RB1);
snapper_write(sc, SNAPPER_RB1, snapper_initdata.RB1);
snapper_write(sc, SNAPPER_RB2, snapper_initdata.RB2);
snapper_write(sc, SNAPPER_RB3, snapper_initdata.RB3);
snapper_write(sc, SNAPPER_RB4, snapper_initdata.RB4);
snapper_write(sc, SNAPPER_RB5, snapper_initdata.RB5);
snapper_write(sc, SNAPPER_RB6, snapper_initdata.RB6);
snapper_write(sc, SNAPPER_MCR1, snapper_initdata.MCR1);
snapper_write(sc, SNAPPER_MCR2, snapper_initdata.MCR2);
snapper_write(sc, SNAPPER_DRC, snapper_initdata.DRC);
snapper_write(sc, SNAPPER_VOLUME, snapper_initdata.VOLUME);
snapper_write(sc, SNAPPER_TREBLE, snapper_initdata.TREBLE);
snapper_write(sc, SNAPPER_BASS, snapper_initdata.BASS);
snapper_write(sc, SNAPPER_MIXER_L, snapper_initdata.MIXER_L);
snapper_write(sc, SNAPPER_MIXER_R, snapper_initdata.MIXER_R);
snapper_write(sc, SNAPPER_LLB, snapper_initdata.LLB);
snapper_write(sc, SNAPPER_RLB, snapper_initdata.RLB);
snapper_write(sc, SNAPPER_LLB_GAIN, snapper_initdata.LLB_GAIN);
snapper_write(sc, SNAPPER_RLB_GAIN, snapper_initdata.RLB_GAIN);
snapper_write(sc, SNAPPER_ACR, snapper_initdata.ACR);
x |= SOUND_MASK_VOLUME;
mix_setdevs(m, x);
return (0);
}
static int
bcmmix_set(struct snd_mixer *m, unsigned dev, unsigned left, unsigned right)
{
struct bcm2835_audio_info *sc = mix_getdevinfo(m);
switch (dev) {
case SOUND_MIXER_VOLUME:
BCM2835_AUDIO_LOCK(sc);
sc->volume = left;
bcm2835_worker_update_params(sc);
BCM2835_AUDIO_UNLOCK(sc);
break;
default:
break;
}
return left | (left << 8);
}
static int
onyx_set(struct snd_mixer *m, unsigned dev, unsigned left, unsigned right)
{
struct onyx_softc *sc;
struct mtx *mixer_lock;
int locked;
uint8_t l, r;
sc = device_get_softc(mix_getdevinfo(m));
mixer_lock = mixer_get_lock(m);
locked = mtx_owned(mixer_lock);
switch (dev) {
case SOUND_MIXER_VOLUME:
/*
* We need to unlock the mixer lock because iicbus_transfer()
* may sleep. The mixer lock itself is unnecessary here
* because it is meant to serialize hardware access, which
* is taken care of by the I2C layer, so this is safe.
*/
if (left > 100 || right > 100)
return (0);
l = left + 128;
r = right + 128;
if (locked)
mtx_unlock(mixer_lock);
onyx_write(sc, PCM3052_REG_LEFT_ATTN, l);
onyx_write(sc, PCM3052_REG_RIGHT_ATTN, r);
if (locked)
mtx_lock(mixer_lock);
return (left | (right << 8));
}
return (0);
}
static int
a10codec_mixer_init(struct snd_mixer *m)
{
struct a10codec_info *sc = mix_getdevinfo(m);
pcell_t prop[4];
phandle_t node;
device_t gpio;
uint32_t val;
ssize_t len;
int pin;
mix_setdevs(m, SOUND_MASK_VOLUME | SOUND_MASK_LINE | SOUND_MASK_RECLEV);
mix_setrecdevs(m, SOUND_MASK_LINE | SOUND_MASK_LINE1 | SOUND_MASK_MIC);
/* Unmute input source to PA */
val = CODEC_READ(sc, AC_DAC_ACTL);
val |= DAC_ACTL_PAMUTE;
CODEC_WRITE(sc, AC_DAC_ACTL, val);
/* Enable PA */
val = CODEC_READ(sc, AC_ADC_ACTL);
val |= ADC_ACTL_PA_EN;
CODEC_WRITE(sc, AC_ADC_ACTL, val);
/* Unmute PA */
node = ofw_bus_get_node(sc->dev);
len = OF_getencprop(node, "allwinner,pa-gpios", prop, sizeof(prop));
if (len > 0 && (len / sizeof(prop[0])) == 4) {
gpio = OF_device_from_xref(prop[0]);
if (gpio != NULL) {
pin = prop[1] * 32 + prop[2];
GPIO_PIN_SETFLAGS(gpio, pin, GPIO_PIN_OUTPUT);
GPIO_PIN_SET(gpio, pin, GPIO_PIN_LOW);
}
}
return (0);
}
static int
ad1816mix_set(struct snd_mixer *m, unsigned dev, unsigned left, unsigned right)
{
struct ad1816_info *ad1816 = mix_getdevinfo(m);
u_short reg = 0;
/* Scale volumes */
left = AD1816_MUTE - (AD1816_MUTE * left) / 100;
right = AD1816_MUTE - (AD1816_MUTE * right) / 100;
reg = (left << 8) | right;
/* do channel selective muting if volume is zero */
if (left == AD1816_MUTE) reg |= 0x8000;
if (right == AD1816_MUTE) reg |= 0x0080;
ad1816_lock(ad1816);
switch (dev) {
case SOUND_MIXER_VOLUME: /* Register 14 master volume */
ad1816_write(ad1816, 14, reg);
break;
case SOUND_MIXER_CD: /* Register 15 cd */
case SOUND_MIXER_LINE1:
ad1816_write(ad1816, 15, reg);
break;
case SOUND_MIXER_SYNTH: /* Register 16 synth */
ad1816_write(ad1816, 16, reg);
break;
case SOUND_MIXER_PCM: /* Register 4 pcm */
ad1816_write(ad1816, 4, reg);
break;
case SOUND_MIXER_LINE:
case SOUND_MIXER_LINE3: /* Register 18 line in */
ad1816_write(ad1816, 18, reg);
break;
case SOUND_MIXER_MIC: /* Register 19 mic volume */
ad1816_write(ad1816, 19, reg & ~0xff); /* mic is mono */
break;
case SOUND_MIXER_IGAIN:
/* and now to something completely different ... */
ad1816_write(ad1816, 20, ((ad1816_read(ad1816, 20) & ~0x0f0f)
| (((AD1816_MUTE - left) / 2) << 8) /* four bits of adc gain */
| ((AD1816_MUTE - right) / 2)));
break;
default:
printf("ad1816_mixer_set(): unknown device.\n");
break;
}
ad1816_unlock(ad1816);
left = ((AD1816_MUTE - left) * 100) / AD1816_MUTE;
right = ((AD1816_MUTE - right) * 100) / AD1816_MUTE;
return left | (right << 8);
}
static int
ua_mixer_uninit(struct snd_mixer *m)
{
return (uaudio_mixer_uninit_sub(mix_getdevinfo(m)));
}