/* $NetBSD: mavb.c,v 1.14 2019/06/07 13:24:21 isaki Exp $ */
/* $OpenBSD: mavb.c,v 1.6 2005/04/15 13:05:14 mickey Exp $ */
/*
* Copyright (c) 2005 Mark Kettenis
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <sys/kernel.h>
#include <sys/kmem.h>
#include <sys/callout.h>
#include <sys/bus.h>
#include <machine/intr.h>
#include <machine/autoconf.h>
#include <sys/audioio.h>
#include <dev/audio/audio_if.h>
#include <arch/sgimips/mace/macevar.h>
#include <arch/sgimips/mace/macereg.h>
#include <arch/sgimips/mace/mavbreg.h>
#include <dev/ic/ad1843reg.h>
#undef MAVB_DEBUG
#ifdef MAVB_DEBUG
#define DPRINTF(l,x) do { if (mavb_debug & (l)) printf x; } while (0)
#define MAVB_DEBUG_INTR 0x0100
int mavb_debug = ~MAVB_DEBUG_INTR;
#else
#define DPRINTF(l,x) /* nothing */
#endif
/* Repeat delays for volume buttons. */
#define MAVB_VOLUME_BUTTON_REPEAT_DEL1 400 /* 400ms to start repeating */
#define MAVB_VOLUME_BUTTON_REPEAT_DELN 100 /* 100ms between repeats */
/* XXX We need access to some of the MACE ISA registers. */
#define MAVB_ISA_NREGS 0x20
/*
* AD1843 Mixer.
*/
enum {
AD1843_RECORD_CLASS,
AD1843_ADC_SOURCE, /* ADC Source Select */
AD1843_ADC_GAIN, /* ADC Input Gain */
AD1843_INPUT_CLASS,
AD1843_DAC1_GAIN, /* DAC1 Analog/Digital Gain/Attenuation */
AD1843_DAC1_MUTE, /* DAC1 Analog Mute */
AD1843_DAC2_GAIN, /* DAC2 Mix Gain */
AD1843_AUX1_GAIN, /* Auxilliary 1 Mix Gain */
AD1843_AUX2_GAIN, /* Auxilliary 2 Mix Gain */
AD1843_AUX3_GAIN, /* Auxilliary 3 Mix Gain */
AD1843_MIC_GAIN, /* Microphone Mix Gain */
AD1843_MONO_GAIN, /* Mono Mix Gain */
AD1843_DAC2_MUTE, /* DAC2 Mix Mute */
AD1843_AUX1_MUTE, /* Auxilliary 1 Mix Mute */
AD1843_AUX2_MUTE, /* Auxilliary 2 Mix Mute */
AD1843_AUX3_MUTE, /* Auxilliary 3 Mix Mute */
AD1843_MIC_MUTE, /* Microphone Mix Mute */
AD1843_MONO_MUTE, /* Mono Mix Mute */
AD1843_SUM_MUTE, /* Sum Mute */
AD1843_OUTPUT_CLASS,
AD1843_MNO_MUTE, /* Mono Output Mute */
AD1843_HPO_MUTE /* Headphone Output Mute */
};
/* ADC Source Select. The order matches the hardware bits. */
const char *ad1843_source[] = {
AudioNline,
AudioNmicrophone,
AudioNaux "1",
AudioNaux "2",
AudioNaux "3",
AudioNmono,
AudioNdac "1",
AudioNdac "2"
};
/* Mix Control. The order matches the hardware register numbering. */
const char *ad1843_input[] = {
AudioNdac "2", /* AD1843_DAC2__TO_MIXER */
AudioNaux "1",
AudioNaux "2",
AudioNaux "3",
AudioNmicrophone,
AudioNmono /* AD1843_MISC_SETTINGS */
};
static const struct audio_format mavb_formats[] = {
{
.mode = AUMODE_PLAY,
.encoding = AUDIO_ENCODING_SLINEAR_BE,
.validbits = 24,
.precision = 32,
.channels = 2,
.channel_mask = AUFMT_STEREO,
.frequency_type = 0,
.frequency = { 8000, 48000 },
},
};
#define MAVB_NFORMATS __arraycount(mavb_formats)
struct mavb_softc {
device_t sc_dev;
kmutex_t sc_lock;
kmutex_t sc_intr_lock;
bus_space_tag_t sc_st;
bus_space_handle_t sc_sh;
bus_dma_tag_t sc_dmat;
bus_dmamap_t sc_dmamap;
/* XXX We need access to some of the MACE ISA registers. */
bus_space_handle_t sc_isash;
#define MAVB_ISA_RING_SIZE 0x1000
uint8_t *sc_ring;
uint8_t *sc_start, *sc_end;
int sc_blksize;
void (*sc_intr)(void *);
void *sc_intrarg;
void *sc_get;
int sc_count;
u_long sc_play_rate;
u_int sc_play_format;
struct callout sc_volume_button_ch;
};
typedef uint64_t ad1843_addr_t;
uint16_t ad1843_reg_read(struct mavb_softc *, ad1843_addr_t);
uint16_t ad1843_reg_write(struct mavb_softc *, ad1843_addr_t, uint16_t);
void ad1843_dump_regs(struct mavb_softc *);
int mavb_match(device_t, cfdata_t, void *);
void mavb_attach(device_t, device_t, void *);
CFATTACH_DECL_NEW(mavb, sizeof(struct mavb_softc),
mavb_match, mavb_attach, NULL, NULL);
int mavb_query_format(void *, audio_format_query_t *);
int mavb_set_format(void *, int,
const audio_params_t *, const audio_params_t *,
audio_filter_reg_t *, audio_filter_reg_t *);
int mavb_round_blocksize(void *hdl, int, int, const audio_params_t *);
int mavb_halt_output(void *);
int mavb_halt_input(void *);
int mavb_getdev(void *, struct audio_device *);
int mavb_set_port(void *, struct mixer_ctrl *);
int mavb_get_port(void *, struct mixer_ctrl *);
int mavb_query_devinfo(void *, struct mixer_devinfo *);
int mavb_get_props(void *);
int mavb_trigger_output(void *, void *, void *, int, void (*)(void *),
void *, const audio_params_t *);
int mavb_trigger_input(void *, void *, void *, int, void (*)(void *),
void *, const audio_params_t *);
void mavb_get_locks(void *, kmutex_t **, kmutex_t **);
struct audio_hw_if mavb_sa_hw_if = {
.query_format = mavb_query_format,
.set_format = mavb_set_format,
.round_blocksize = mavb_round_blocksize,
.halt_output = mavb_halt_output,
.halt_input = mavb_halt_input,
.getdev = mavb_getdev,
.set_port = mavb_set_port,
.get_port = mavb_get_port,
.query_devinfo = mavb_query_devinfo,
.get_props = mavb_get_props,
.trigger_output = mavb_trigger_output,
.trigger_input = mavb_trigger_input,
.get_locks = mavb_get_locks,
};
struct audio_device mavb_device = {
"A3",
"",
"mavb"
};
static void
mavb_internal_to_slinear24_32(audio_filter_arg_t *arg)
{
const aint_t *src;
uint32_t *dst;
u_int sample_count;
u_int i;
src = arg->src;
dst = arg->dst;
sample_count = arg->count * arg->srcfmt->channels;
for (i = 0; i < sample_count; i++) {
*dst++ = (*src++) << 8;
}
}
int
mavb_query_format(void *hdl, audio_format_query_t *afp)
{
return audio_query_format(mavb_formats, MAVB_NFORMATS, afp);
}
static int
mavb_set_play_rate(struct mavb_softc *sc, u_long sample_rate)
{
KASSERT((4000 <= sample_rate && sample_rate <= 48000));
if (sc->sc_play_rate != sample_rate) {
ad1843_reg_write(sc, AD1843_CLOCK2_SAMPLE_RATE, sample_rate);
sc->sc_play_rate = sample_rate;
}
return 0;
}
static int
mavb_set_play_format(struct mavb_softc *sc, u_int encoding)
{
uint16_t value;
u_int format;
switch(encoding) {
case AUDIO_ENCODING_SLINEAR_BE:
format = AD1843_PCM16;
break;
default:
return EINVAL;
}
if (sc->sc_play_format != format) {
value = ad1843_reg_read(sc, AD1843_SERIAL_INTERFACE);
value &= ~AD1843_DA1F_MASK;
value |= (format << AD1843_DA1F_SHIFT);
ad1843_reg_write(sc, AD1843_SERIAL_INTERFACE, value);
sc->sc_play_format = format;
}
return 0;
}
int
mavb_set_format(void *hdl, int setmode,
const audio_params_t *play, const audio_params_t *rec,
audio_filter_reg_t *pfil, audio_filter_reg_t *rfil)
{
struct mavb_softc *sc = (struct mavb_softc *)hdl;
int error;
DPRINTF(1, ("%s: %s: sample=%u precision=%d channels=%d\n",
device_xname(sc->sc_dev), __func__,
play->sample_rate, play->precision, play->channels));
if (setmode & AUMODE_PLAY) {
pfil->codec = mavb_internal_to_slinear24_32;
error = mavb_set_play_rate(sc, play->sample_rate);
if (error)
return error;
error = mavb_set_play_format(sc, play->encoding);
if (error)
return error;
}
#if 0
if (setmode & AUMODE_RECORD) {
}
#endif
return 0;
}
int
mavb_round_blocksize(void *hdl, int bs, int mode, const audio_params_t *p)
{
/* Block size should be a multiple of 32. */
return (bs + 0x1f) & ~0x1f;
}
int
mavb_halt_output(void *hdl)
{
struct mavb_softc *sc = (struct mavb_softc *)hdl;
DPRINTF(1, ("%s: mavb_halt_output called\n", device_xname(sc->sc_dev)));
bus_space_write_8(sc->sc_st, sc->sc_sh, MAVB_CHANNEL2_CONTROL, 0);
return 0;
}
int
mavb_halt_input(void *hdl)
{
return 0;
}
int
mavb_getdev(void *hdl, struct audio_device *ret)
{
*ret = mavb_device;
return 0;
}
int
mavb_set_port(void *hdl, struct mixer_ctrl *mc)
{
struct mavb_softc *sc = (struct mavb_softc *)hdl;
u_char left, right;
ad1843_addr_t reg;
uint16_t value;
DPRINTF(1, ("%s: mavb_set_port: dev=%d\n", device_xname(sc->sc_dev),
mc->dev));
switch (mc->dev) {
case AD1843_ADC_SOURCE:
value = ad1843_reg_read(sc, AD1843_ADC_SOURCE_GAIN);
value &= ~(AD1843_LSS_MASK | AD1843_RSS_MASK);
value |= ((mc->un.ord << AD1843_LSS_SHIFT) & AD1843_LSS_MASK);
value |= ((mc->un.ord << AD1843_RSS_SHIFT) & AD1843_RSS_MASK);
ad1843_reg_write(sc, AD1843_ADC_SOURCE_GAIN, value);
break;
case AD1843_ADC_GAIN:
left = mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT];
right = mc->un.value.level[AUDIO_MIXER_LEVEL_RIGHT];
value = ad1843_reg_read(sc, AD1843_ADC_SOURCE_GAIN);
value &= ~(AD1843_LIG_MASK | AD1843_RIG_MASK);
value |= ((left >> 4) << AD1843_LIG_SHIFT);
value |= ((right >> 4) << AD1843_RIG_SHIFT);
ad1843_reg_write(sc, AD1843_ADC_SOURCE_GAIN, value);
break;
case AD1843_DAC1_GAIN:
left = AUDIO_MAX_GAIN -
mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT];
right = AUDIO_MAX_GAIN -
mc->un.value.level[AUDIO_MIXER_LEVEL_RIGHT];
value = ad1843_reg_read(sc, AD1843_DAC1_ANALOG_GAIN);
value &= ~(AD1843_LDA1G_MASK | AD1843_RDA1G_MASK);
value |= ((left >> 2) << AD1843_LDA1G_SHIFT);
value |= ((right >> 2) << AD1843_RDA1G_SHIFT);
ad1843_reg_write(sc, AD1843_DAC1_ANALOG_GAIN, value);
break;
case AD1843_DAC1_MUTE:
value = ad1843_reg_read(sc, AD1843_DAC1_ANALOG_GAIN);
if (mc->un.ord == 0)
value &= ~(AD1843_LDA1GM | AD1843_RDA1GM);
else
value |= (AD1843_LDA1GM | AD1843_RDA1GM);
ad1843_reg_write(sc, AD1843_DAC1_ANALOG_GAIN, value);
break;
case AD1843_DAC2_GAIN:
case AD1843_AUX1_GAIN:
case AD1843_AUX2_GAIN:
case AD1843_AUX3_GAIN:
case AD1843_MIC_GAIN:
left = AUDIO_MAX_GAIN -
mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT];
right = AUDIO_MAX_GAIN -
mc->un.value.level[AUDIO_MIXER_LEVEL_RIGHT];
reg = AD1843_DAC2_TO_MIXER + mc->dev - AD1843_DAC2_GAIN;
value = ad1843_reg_read(sc, reg);
value &= ~(AD1843_LD2M_MASK | AD1843_RD2M_MASK);
value |= ((left >> 3) << AD1843_LD2M_SHIFT);
value |= ((right >> 3) << AD1843_RD2M_SHIFT);
ad1843_reg_write(sc, reg, value);
break;
case AD1843_MONO_GAIN:
left = AUDIO_MAX_GAIN -
mc->un.value.level[AUDIO_MIXER_LEVEL_MONO];
value = ad1843_reg_read(sc, AD1843_MISC_SETTINGS);
value &= ~AD1843_MNM_MASK;
value |= ((left >> 3) << AD1843_MNM_SHIFT);
ad1843_reg_write(sc, AD1843_MISC_SETTINGS, value);
break;
case AD1843_DAC2_MUTE:
case AD1843_AUX1_MUTE:
case AD1843_AUX2_MUTE:
case AD1843_AUX3_MUTE:
case AD1843_MIC_MUTE:
case AD1843_MONO_MUTE: /* matches left channel */
reg = AD1843_DAC2_TO_MIXER + mc->dev - AD1843_DAC2_MUTE;
value = ad1843_reg_read(sc, reg);
if (mc->un.ord == 0)
value &= ~(AD1843_LD2MM | AD1843_RD2MM);
else
value |= (AD1843_LD2MM | AD1843_RD2MM);
ad1843_reg_write(sc, reg, value);
break;
case AD1843_SUM_MUTE:
value = ad1843_reg_read(sc, AD1843_MISC_SETTINGS);
if (mc->un.ord == 0)
value &= ~AD1843_SUMM;
else
value |= AD1843_SUMM;
ad1843_reg_write(sc, AD1843_MISC_SETTINGS, value);
break;
case AD1843_MNO_MUTE:
value = ad1843_reg_read(sc, AD1843_MISC_SETTINGS);
if (mc->un.ord == 0)
value &= ~AD1843_MNOM;
else
value |= AD1843_MNOM;
ad1843_reg_write(sc, AD1843_MISC_SETTINGS, value);
break;
case AD1843_HPO_MUTE:
value = ad1843_reg_read(sc, AD1843_MISC_SETTINGS);
if (mc->un.ord == 0)
value &= ~AD1843_HPOM;
else
value |= AD1843_HPOM;
ad1843_reg_write(sc, AD1843_MISC_SETTINGS, value);
value = ad1843_reg_read(sc, AD1843_MISC_SETTINGS);
break;
default:
return EINVAL;
}
return 0;
}
int
mavb_get_port(void *hdl, struct mixer_ctrl *mc)
{
struct mavb_softc *sc = (struct mavb_softc *)hdl;
u_char left, right;
ad1843_addr_t reg;
uint16_t value;
DPRINTF(1, ("%s: mavb_get_port: dev=%d\n", device_xname(sc->sc_dev),
mc->dev));
switch (mc->dev) {
case AD1843_ADC_SOURCE:
value = ad1843_reg_read(sc, AD1843_ADC_SOURCE_GAIN);
mc->un.ord = (value & AD1843_LSS_MASK) >> AD1843_LSS_SHIFT;
break;
case AD1843_ADC_GAIN:
value = ad1843_reg_read(sc, AD1843_ADC_SOURCE_GAIN);
left = (value & AD1843_LIG_MASK) >> AD1843_LIG_SHIFT;
right = (value & AD1843_RIG_MASK) >> AD1843_RIG_SHIFT;
mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT] =
(left << 4) | left;
mc->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] =
(right << 2) | right;
break;
case AD1843_DAC1_GAIN:
value = ad1843_reg_read(sc, AD1843_DAC1_ANALOG_GAIN);
left = (value & AD1843_LDA1G_MASK) >> AD1843_LDA1G_SHIFT;
right = (value & AD1843_RDA1G_MASK) >> AD1843_RDA1G_SHIFT;
mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT] =
AUDIO_MAX_GAIN - (left << 2);
mc->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] =
AUDIO_MAX_GAIN - (right << 2);
break;
case AD1843_DAC1_MUTE:
value = ad1843_reg_read(sc, AD1843_DAC1_ANALOG_GAIN);
mc->un.ord = (value & AD1843_LDA1GM) ? 1 : 0;
break;
case AD1843_DAC2_GAIN:
case AD1843_AUX1_GAIN:
case AD1843_AUX2_GAIN:
case AD1843_AUX3_GAIN:
case AD1843_MIC_GAIN:
reg = AD1843_DAC2_TO_MIXER + mc->dev - AD1843_DAC2_GAIN;
value = ad1843_reg_read(sc, reg);
left = (value & AD1843_LD2M_MASK) >> AD1843_LD2M_SHIFT;
right = (value & AD1843_RD2M_MASK) >> AD1843_RD2M_SHIFT;
mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT] =
AUDIO_MAX_GAIN - (left << 3);
mc->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] =
AUDIO_MAX_GAIN - (right << 3);
break;
case AD1843_MONO_GAIN:
if (mc->un.value.num_channels != 1)
return EINVAL;
value = ad1843_reg_read(sc, AD1843_MISC_SETTINGS);
left = (value & AD1843_MNM_MASK) >> AD1843_MNM_SHIFT;
mc->un.value.level[AUDIO_MIXER_LEVEL_MONO] =
AUDIO_MAX_GAIN - (left << 3);
break;
case AD1843_DAC2_MUTE:
case AD1843_AUX1_MUTE:
case AD1843_AUX2_MUTE:
case AD1843_AUX3_MUTE:
case AD1843_MIC_MUTE:
case AD1843_MONO_MUTE: /* matches left channel */
reg = AD1843_DAC2_TO_MIXER + mc->dev - AD1843_DAC2_MUTE;
value = ad1843_reg_read(sc, reg);
mc->un.ord = (value & AD1843_LD2MM) ? 1 : 0;
break;
case AD1843_SUM_MUTE:
value = ad1843_reg_read(sc, AD1843_MISC_SETTINGS);
mc->un.ord = (value & AD1843_SUMM) ? 1 : 0;
break;
case AD1843_MNO_MUTE:
value = ad1843_reg_read(sc, AD1843_MISC_SETTINGS);
mc->un.ord = (value & AD1843_MNOM) ? 1 : 0;
break;
case AD1843_HPO_MUTE:
value = ad1843_reg_read(sc, AD1843_MISC_SETTINGS);
mc->un.ord = (value & AD1843_HPOM) ? 1 : 0;
break;
default:
return EINVAL;
}
return 0;
}
int
mavb_query_devinfo(void *hdl, struct mixer_devinfo *di)
{
int i;
di->prev = di->next = AUDIO_MIXER_LAST;
switch (di->index) {
case AD1843_RECORD_CLASS:
di->type = AUDIO_MIXER_CLASS;
di->mixer_class = AD1843_RECORD_CLASS;
strlcpy(di->label.name, AudioCrecord, sizeof di->label.name);
break;
case AD1843_ADC_SOURCE:
di->type = AUDIO_MIXER_ENUM;
di->mixer_class = AD1843_RECORD_CLASS;
di->next = AD1843_ADC_GAIN;
strlcpy(di->label.name, AudioNsource, sizeof di->label.name);
di->un.e.num_mem =
sizeof ad1843_source / sizeof ad1843_source[1];
for (i = 0; i < di->un.e.num_mem; i++) {
strlcpy(di->un.e.member[i].label.name,
ad1843_source[i],
sizeof di->un.e.member[0].label.name);
di->un.e.member[i].ord = i;
}
break;
case AD1843_ADC_GAIN:
di->type = AUDIO_MIXER_VALUE;
di->mixer_class = AD1843_RECORD_CLASS;
di->prev = AD1843_ADC_SOURCE;
strlcpy(di->label.name, AudioNvolume, sizeof di->label.name);
di->un.v.num_channels = 2;
strlcpy(di->un.v.units.name, AudioNvolume,
sizeof di->un.v.units.name);
break;
case AD1843_INPUT_CLASS:
di->type = AUDIO_MIXER_CLASS;
di->mixer_class = AD1843_INPUT_CLASS;
strlcpy(di->label.name, AudioCinputs, sizeof di->label.name);
break;
case AD1843_DAC1_GAIN:
di->type = AUDIO_MIXER_VALUE;
di->mixer_class = AD1843_OUTPUT_CLASS;
di->next = AD1843_DAC1_MUTE;
strlcpy(di->label.name, AudioNmaster, sizeof di->label.name);
di->un.v.num_channels = 2;
strlcpy(di->un.v.units.name, AudioNvolume,
sizeof di->un.v.units.name);
break;
case AD1843_DAC1_MUTE:
di->type = AUDIO_MIXER_ENUM;
di->mixer_class = AD1843_OUTPUT_CLASS;
di->prev = AD1843_DAC1_GAIN;
strlcpy(di->label.name, AudioNmute, sizeof di->label.name);
di->un.e.num_mem = 2;
strlcpy(di->un.e.member[0].label.name, AudioNoff,
sizeof di->un.e.member[0].label.name);
di->un.e.member[0].ord = 0;
strlcpy(di->un.e.member[1].label.name, AudioNon,
sizeof di->un.e.member[1].label.name);
di->un.e.member[1].ord = 1;
break;
case AD1843_DAC2_GAIN:
case AD1843_AUX1_GAIN:
case AD1843_AUX2_GAIN:
case AD1843_AUX3_GAIN:
case AD1843_MIC_GAIN:
case AD1843_MONO_GAIN:
di->type = AUDIO_MIXER_VALUE;
di->mixer_class = AD1843_INPUT_CLASS;
di->next = di->index + AD1843_DAC2_MUTE - AD1843_DAC2_GAIN;
strlcpy(di->label.name,
ad1843_input[di->index - AD1843_DAC2_GAIN],
sizeof di->label.name);
if (di->index == AD1843_MONO_GAIN)
di->un.v.num_channels = 1;
else
di->un.v.num_channels = 2;
strlcpy(di->un.v.units.name, AudioNvolume,
sizeof di->un.v.units.name);
break;
case AD1843_DAC2_MUTE:
case AD1843_AUX1_MUTE:
case AD1843_AUX2_MUTE:
case AD1843_AUX3_MUTE:
case AD1843_MIC_MUTE:
case AD1843_MONO_MUTE:
di->type = AUDIO_MIXER_ENUM;
di->mixer_class = AD1843_INPUT_CLASS;
di->prev = di->index + AD1843_DAC2_GAIN - AD1843_DAC2_MUTE;
strlcpy(di->label.name, AudioNmute, sizeof di->label.name);
di->un.e.num_mem = 2;
strlcpy(di->un.e.member[0].label.name, AudioNoff,
sizeof di->un.e.member[0].label.name);
di->un.e.member[0].ord = 0;
strlcpy(di->un.e.member[1].label.name, AudioNon,
sizeof di->un.e.member[1].label.name);
di->un.e.member[1].ord = 1;
break;
case AD1843_SUM_MUTE:
di->type = AUDIO_MIXER_ENUM;
di->mixer_class = AD1843_INPUT_CLASS;
strlcpy(di->label.name, "sum." AudioNmute,
sizeof di->label.name);
di->un.e.num_mem = 2;
strlcpy(di->un.e.member[0].label.name, AudioNoff,
sizeof di->un.e.member[0].label.name);
di->un.e.member[0].ord = 0;
strlcpy(di->un.e.member[1].label.name, AudioNon,
sizeof di->un.e.member[1].label.name);
di->un.e.member[1].ord = 1;
break;
case AD1843_OUTPUT_CLASS:
di->type = AUDIO_MIXER_CLASS;
di->mixer_class = AD1843_OUTPUT_CLASS;
strlcpy(di->label.name, AudioCoutputs, sizeof di->label.name);
break;
case AD1843_MNO_MUTE:
di->type = AUDIO_MIXER_ENUM;
di->mixer_class = AD1843_OUTPUT_CLASS;
strlcpy(di->label.name, AudioNmono "." AudioNmute,
sizeof di->label.name);
di->un.e.num_mem = 2;
strlcpy(di->un.e.member[0].label.name, AudioNoff,
sizeof di->un.e.member[0].label.name);
di->un.e.member[0].ord = 0;
strlcpy(di->un.e.member[1].label.name, AudioNon,
sizeof di->un.e.member[1].label.name);
di->un.e.member[1].ord = 1;
break;
case AD1843_HPO_MUTE:
di->type = AUDIO_MIXER_ENUM;
di->mixer_class = AD1843_OUTPUT_CLASS;
strlcpy(di->label.name, AudioNheadphone "." AudioNmute,
sizeof di->label.name);
di->un.e.num_mem = 2;
strlcpy(di->un.e.member[0].label.name, AudioNoff,
sizeof di->un.e.member[0].label.name);
di->un.e.member[0].ord = 0;
strlcpy(di->un.e.member[1].label.name, AudioNon,
sizeof di->un.e.member[1].label.name);
di->un.e.member[1].ord = 1;
break;
default:
return EINVAL;
}
return 0;
}
int
mavb_get_props(void *hdl)
{
return AUDIO_PROP_PLAYBACK;
}
static void
mavb_dma_output(struct mavb_softc *sc)
{
bus_space_tag_t st = sc->sc_st;
bus_space_handle_t sh = sc->sc_sh;
uint64_t write_ptr;
uint64_t depth;
uint8_t *src, *dst;
int count;
KASSERT(mutex_owned(&sc->sc_intr_lock));
write_ptr = bus_space_read_8(st, sh, MAVB_CHANNEL2_WRITE_PTR);
depth = bus_space_read_8(st, sh, MAVB_CHANNEL2_DEPTH);
dst = sc->sc_ring + write_ptr;
src = sc->sc_get;
count = (MAVB_ISA_RING_SIZE - depth - 32);
while (--count >= 0) {
*dst++ = *src++;
if (dst >= sc->sc_ring + MAVB_ISA_RING_SIZE)
dst = sc->sc_ring;
if (src >= sc->sc_end)
src = sc->sc_start;
if (++sc->sc_count >= sc->sc_blksize) {
if (sc->sc_intr)
sc->sc_intr(sc->sc_intrarg);
sc->sc_count = 0;
}
}
write_ptr = dst - sc->sc_ring;
bus_space_write_8(st, sh, MAVB_CHANNEL2_WRITE_PTR, write_ptr);
sc->sc_get = src;
}
int
mavb_trigger_output(void *hdl, void *start, void *end, int blksize,
void (*intr)(void *), void *intrarg,
const audio_params_t *param)
{
struct mavb_softc *sc = (struct mavb_softc *)hdl;
DPRINTF(1, ("%s: mavb_trigger_output: start=%p end=%p "
"blksize=%d intr=%p(%p)\n", device_xname(sc->sc_dev),
start, end, blksize, intr, intrarg));
sc->sc_blksize = blksize;
sc->sc_intr = intr;
sc->sc_intrarg = intrarg;
sc->sc_start = sc->sc_get = start;
sc->sc_end = end;
sc->sc_count = 0;
bus_space_write_8(sc->sc_st, sc->sc_sh, MAVB_CHANNEL2_CONTROL,
MAVB_CHANNEL_RESET);
delay(1000);
bus_space_write_8(sc->sc_st, sc->sc_sh, MAVB_CHANNEL2_CONTROL, 0);
mavb_dma_output(sc);
bus_space_write_8(sc->sc_st, sc->sc_sh, MAVB_CHANNEL2_CONTROL,
MAVB_CHANNEL_DMA_ENABLE | MAVB_CHANNEL_INT_50);
return 0;
}
int
mavb_trigger_input(void *hdl, void *start, void *end, int blksize,
void (*intr)(void *), void *intrarg,
const audio_params_t *param)
{
return 0;
}
void
mavb_get_locks(void *hdl, kmutex_t **intr, kmutex_t **thread)
{
struct mavb_softc *sc = (struct mavb_softc *)hdl;
*intr = &sc->sc_intr_lock;
*thread = &sc->sc_lock;
}
static void
mavb_button_repeat(void *hdl)
{
struct mavb_softc *sc = (struct mavb_softc *)hdl;
uint64_t intmask, control;
uint16_t value, left, right;
DPRINTF(1, ("%s: mavb_repeat called\n", device_xname(sc->sc_dev)));
#define MAVB_CONTROL_VOLUME_BUTTONS \
(MAVB_CONTROL_VOLUME_BUTTON_UP | MAVB_CONTROL_VOLUME_BUTTON_DOWN)
control = bus_space_read_8(sc->sc_st, sc->sc_sh, MAVB_CONTROL);
if (control & MAVB_CONTROL_VOLUME_BUTTONS) {
value = ad1843_reg_read(sc, AD1843_DAC1_ANALOG_GAIN);
left = (value & AD1843_LDA1G_MASK) >> AD1843_LDA1G_SHIFT;
right = (value & AD1843_RDA1G_MASK) >> AD1843_RDA1G_SHIFT;
if (control & MAVB_CONTROL_VOLUME_BUTTON_UP) {
control &= ~MAVB_CONTROL_VOLUME_BUTTON_UP;
if (left > 0)
left--; /* attenuation! */
if (right > 0)
right--;
}
if (control & MAVB_CONTROL_VOLUME_BUTTON_DOWN) {
control &= ~MAVB_CONTROL_VOLUME_BUTTON_DOWN;
if (left < 63)
left++;
if (right < 63)
right++;
}
bus_space_write_8(sc->sc_st, sc->sc_sh, MAVB_CONTROL, control);
value &= ~(AD1843_LDA1G_MASK | AD1843_RDA1G_MASK);
value |= (left << AD1843_LDA1G_SHIFT);
value |= (right << AD1843_RDA1G_SHIFT);
ad1843_reg_write(sc, AD1843_DAC1_ANALOG_GAIN, value);
callout_reset(&sc->sc_volume_button_ch,
(hz * MAVB_VOLUME_BUTTON_REPEAT_DELN) / 1000,
mavb_button_repeat, sc);
} else {
/* Enable volume button interrupts again. */
intmask = bus_space_read_8(sc->sc_st, sc->sc_isash,
MACE_ISA_INT_MASK);
bus_space_write_8(sc->sc_st, sc->sc_isash, MACE_ISA_INT_MASK,
intmask | MACE_ISA_INT_AUDIO_SC);
}
}
static int
mavb_intr(void *arg)
{
struct mavb_softc *sc = arg;
uint64_t stat, intmask;
mutex_spin_enter(&sc->sc_intr_lock);
stat = bus_space_read_8(sc->sc_st, sc->sc_isash, MACE_ISA_INT_STATUS);
DPRINTF(MAVB_DEBUG_INTR, ("%s: mavb_intr: stat = 0x%llx\n",
device_xname(sc->sc_dev), stat));
if (stat & MACE_ISA_INT_AUDIO_SC) {
/* Disable volume button interrupts. */
intmask = bus_space_read_8(sc->sc_st, sc->sc_isash,
MACE_ISA_INT_MASK);
bus_space_write_8(sc->sc_st, sc->sc_isash, MACE_ISA_INT_MASK,
intmask & ~MACE_ISA_INT_AUDIO_SC);
callout_reset(&sc->sc_volume_button_ch,
(hz * MAVB_VOLUME_BUTTON_REPEAT_DEL1) / 1000,
mavb_button_repeat, sc);
}
if (stat & MACE_ISA_INT_AUDIO_DMA2)
mavb_dma_output(sc);
mutex_spin_exit(&sc->sc_intr_lock);
return 1;
}
int
mavb_match(device_t parent, cfdata_t match, void *aux)
{
return 1;
}
void
mavb_attach(device_t parent, device_t self, void *aux)
{
struct mavb_softc *sc = device_private(self);
struct mace_attach_args *maa = aux;
bus_dma_segment_t seg;
uint64_t control;
uint16_t value;
int rseg;
sc->sc_dev = self;
mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_NONE);
mutex_init(&sc->sc_intr_lock, MUTEX_DEFAULT, IPL_SCHED);
sc->sc_st = maa->maa_st;
if (bus_space_subregion(sc->sc_st, maa->maa_sh, maa->maa_offset,
0, &sc->sc_sh) != 0) {
printf(": can't map i/o space\n");
return;
}
/* XXX We need access to some of the MACE ISA registers. */
if (bus_space_subregion(sc->sc_st, maa->maa_sh, 0, 0,
&sc->sc_isash) != 0) {
printf(": can't map isa i/o space\n");
return;
}
/* Set up DMA structures. */
sc->sc_dmat = maa->maa_dmat;
if (bus_dmamap_create(sc->sc_dmat, 4 * MAVB_ISA_RING_SIZE, 1,
4 * MAVB_ISA_RING_SIZE, 0, 0, &sc->sc_dmamap)) {
printf(": can't create MACE ISA DMA map\n");
return;
}
if (bus_dmamem_alloc(sc->sc_dmat, 4 * MAVB_ISA_RING_SIZE,
MACE_ISA_RING_ALIGN, 0, &seg, 1, &rseg, BUS_DMA_NOWAIT)) {
printf(": can't allocate ring buffer\n");
return;
}
if (bus_dmamem_map(sc->sc_dmat, &seg, rseg, 4 * MAVB_ISA_RING_SIZE,
(void *)&sc->sc_ring, BUS_DMA_COHERENT)) {
printf(": can't map ring buffer\n");
return;
}
if (bus_dmamap_load(sc->sc_dmat, sc->sc_dmamap, sc->sc_ring,
4 * MAVB_ISA_RING_SIZE, NULL, BUS_DMA_NOWAIT)) {
printf(": can't load MACE ISA DMA map\n");
return;
}
sc->sc_ring += MAVB_ISA_RING_SIZE; /* XXX */
bus_space_write_8(sc->sc_st, sc->sc_isash, MACE_ISA_RINGBASE,
sc->sc_dmamap->dm_segs[0].ds_addr);
/* Establish interrupt. */
cpu_intr_establish(maa->maa_intr, maa->maa_intrmask,
mavb_intr, sc);
control = bus_space_read_8(sc->sc_st, sc->sc_sh, MAVB_CONTROL);
if (!(control & MAVB_CONTROL_CODEC_PRESENT)) {
printf(": no codec present\n");
return;
}
/* 2. Assert the RESET signal. */
bus_space_write_8(sc->sc_st, sc->sc_sh, MAVB_CONTROL,
MAVB_CONTROL_RESET);
delay(1); /* at least 100 ns */
/* 3. Deassert the RESET signal and enter a wait period to
allow the AD1843 internal clocks and the external
crystal oscillator to stabilize. */
bus_space_write_8(sc->sc_st, sc->sc_sh, MAVB_CONTROL, 0);
delay(800); /* typically 400 us to 800 us */
if (ad1843_reg_read(sc, AD1843_CODEC_STATUS) & AD1843_INIT) {
printf(": codec not ready\n");
return;
}
/* 4. Put the conversion sources into standby. */
value = ad1843_reg_read(sc, AD1843_FUNDAMENTAL_SETTINGS);
ad1843_reg_write(sc, AD1843_FUNDAMENTAL_SETTINGS,
value & ~AD1843_PDNI);
delay (500000); /* approximately 474 ms */
if (ad1843_reg_read(sc, AD1843_CODEC_STATUS) & AD1843_PDNO) {
printf(": can't power up conversion resources\n");
return;
}
/* 5. Power up the clock generators and enable clock output pins. */
value = ad1843_reg_read(sc, AD1843_FUNDAMENTAL_SETTINGS);
ad1843_reg_write(sc, AD1843_FUNDAMENTAL_SETTINGS, value | AD1843_C2EN);
/* 6. Configure conversion resources while they are in standby. */
value = ad1843_reg_read(sc, AD1843_CHANNEL_SAMPLE_RATE);
ad1843_reg_write(sc, AD1843_CHANNEL_SAMPLE_RATE,
value | (2 << AD1843_DA1C_SHIFT));
/* 7. Enable conversion resources. */
value = ad1843_reg_read(sc, AD1843_CHANNEL_POWER_DOWN);
ad1843_reg_write(sc, AD1843_CHANNEL_POWER_DOWN,
value | (AD1843_DA1EN | AD1843_AAMEN));
/* 8. Configure conversion resources while they are enabled. */
value = ad1843_reg_read(sc, AD1843_DAC1_ANALOG_GAIN);
ad1843_reg_write(sc, AD1843_DAC1_ANALOG_GAIN,
value & ~(AD1843_LDA1GM | AD1843_RDA1GM));
value = ad1843_reg_read(sc, AD1843_DAC1_DIGITAL_GAIN);
ad1843_reg_write(sc, AD1843_DAC1_DIGITAL_GAIN,
value & ~(AD1843_LDA1AM | AD1843_RDA1AM));
value = ad1843_reg_read(sc, AD1843_MISC_SETTINGS);
ad1843_reg_write(sc, AD1843_MISC_SETTINGS,
value & ~(AD1843_HPOM | AD1843_MNOM));
value = ad1843_reg_read(sc, AD1843_CODEC_STATUS);
printf(": AD1843 rev %d\n", (u_int)value & AD1843_REVISION_MASK);
sc->sc_play_rate = 48000;
sc->sc_play_format = AD1843_PCM8;
callout_init(&sc->sc_volume_button_ch, 0);
audio_attach_mi(&mavb_sa_hw_if, sc, self);
return;
}
uint16_t
ad1843_reg_read(struct mavb_softc *sc, ad1843_addr_t addr)
{
bus_space_write_8(sc->sc_st, sc->sc_sh, MAVB_CODEC_CONTROL,
(addr & MAVB_CODEC_ADDRESS_MASK) << MAVB_CODEC_ADDRESS_SHIFT |
MAVB_CODEC_READ);
delay(200);
return bus_space_read_8(sc->sc_st, sc->sc_sh, MAVB_CODEC_STATUS);
}
uint16_t
ad1843_reg_write(struct mavb_softc *sc, ad1843_addr_t addr, uint16_t value)
{
bus_space_write_8(sc->sc_st, sc->sc_sh, MAVB_CODEC_CONTROL,
(addr & MAVB_CODEC_ADDRESS_MASK) << MAVB_CODEC_ADDRESS_SHIFT |
(value & MAVB_CODEC_WORD_MASK) << MAVB_CODEC_WORD_SHIFT);
delay(200);
return bus_space_read_8(sc->sc_st, sc->sc_sh, MAVB_CODEC_STATUS);
}
void
ad1843_dump_regs(struct mavb_softc *sc)
{
uint16_t addr;
for (addr = 0; addr < AD1843_NREGS; addr++)
printf("%d: 0x%04x\n", addr, ad1843_reg_read(sc, addr));
}
