![David Henningsson](/assets/img/avatar_default.png)
Increase readability and understandability in the automute code. Signed-off-by: David Henningsson <david.henningsson@canonical.com> Signed-off-by: Takashi Iwai <tiwai@suse.de>
481 lines
16 KiB
C
481 lines
16 KiB
C
/*
|
|
* Common codes for Realtek codec quirks
|
|
* included by patch_realtek.c
|
|
*/
|
|
|
|
/*
|
|
* configuration template - to be copied to the spec instance
|
|
*/
|
|
struct alc_config_preset {
|
|
const struct snd_kcontrol_new *mixers[5]; /* should be identical size
|
|
* with spec
|
|
*/
|
|
const struct snd_kcontrol_new *cap_mixer; /* capture mixer */
|
|
const struct hda_verb *init_verbs[5];
|
|
unsigned int num_dacs;
|
|
const hda_nid_t *dac_nids;
|
|
hda_nid_t dig_out_nid; /* optional */
|
|
hda_nid_t hp_nid; /* optional */
|
|
const hda_nid_t *slave_dig_outs;
|
|
unsigned int num_adc_nids;
|
|
const hda_nid_t *adc_nids;
|
|
const hda_nid_t *capsrc_nids;
|
|
hda_nid_t dig_in_nid;
|
|
unsigned int num_channel_mode;
|
|
const struct hda_channel_mode *channel_mode;
|
|
int need_dac_fix;
|
|
int const_channel_count;
|
|
unsigned int num_mux_defs;
|
|
const struct hda_input_mux *input_mux;
|
|
void (*unsol_event)(struct hda_codec *, unsigned int);
|
|
void (*setup)(struct hda_codec *);
|
|
void (*init_hook)(struct hda_codec *);
|
|
#ifdef CONFIG_SND_HDA_POWER_SAVE
|
|
const struct hda_amp_list *loopbacks;
|
|
void (*power_hook)(struct hda_codec *codec);
|
|
#endif
|
|
};
|
|
|
|
/*
|
|
* channel mode setting
|
|
*/
|
|
static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_info *uinfo)
|
|
{
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
struct alc_spec *spec = codec->spec;
|
|
return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
|
|
spec->num_channel_mode);
|
|
}
|
|
|
|
static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
struct alc_spec *spec = codec->spec;
|
|
return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
|
|
spec->num_channel_mode,
|
|
spec->ext_channel_count);
|
|
}
|
|
|
|
static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
struct alc_spec *spec = codec->spec;
|
|
int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
|
|
spec->num_channel_mode,
|
|
&spec->ext_channel_count);
|
|
if (err >= 0 && !spec->const_channel_count) {
|
|
spec->multiout.max_channels = spec->ext_channel_count;
|
|
if (spec->need_dac_fix)
|
|
spec->multiout.num_dacs = spec->multiout.max_channels / 2;
|
|
}
|
|
return err;
|
|
}
|
|
|
|
/*
|
|
* Control the mode of pin widget settings via the mixer. "pc" is used
|
|
* instead of "%" to avoid consequences of accidentally treating the % as
|
|
* being part of a format specifier. Maximum allowed length of a value is
|
|
* 63 characters plus NULL terminator.
|
|
*
|
|
* Note: some retasking pin complexes seem to ignore requests for input
|
|
* states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
|
|
* are requested. Therefore order this list so that this behaviour will not
|
|
* cause problems when mixer clients move through the enum sequentially.
|
|
* NIDs 0x0f and 0x10 have been observed to have this behaviour as of
|
|
* March 2006.
|
|
*/
|
|
static const char * const alc_pin_mode_names[] = {
|
|
"Mic 50pc bias", "Mic 80pc bias",
|
|
"Line in", "Line out", "Headphone out",
|
|
};
|
|
static const unsigned char alc_pin_mode_values[] = {
|
|
PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
|
|
};
|
|
/* The control can present all 5 options, or it can limit the options based
|
|
* in the pin being assumed to be exclusively an input or an output pin. In
|
|
* addition, "input" pins may or may not process the mic bias option
|
|
* depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
|
|
* accept requests for bias as of chip versions up to March 2006) and/or
|
|
* wiring in the computer.
|
|
*/
|
|
#define ALC_PIN_DIR_IN 0x00
|
|
#define ALC_PIN_DIR_OUT 0x01
|
|
#define ALC_PIN_DIR_INOUT 0x02
|
|
#define ALC_PIN_DIR_IN_NOMICBIAS 0x03
|
|
#define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
|
|
|
|
/* Info about the pin modes supported by the different pin direction modes.
|
|
* For each direction the minimum and maximum values are given.
|
|
*/
|
|
static const signed char alc_pin_mode_dir_info[5][2] = {
|
|
{ 0, 2 }, /* ALC_PIN_DIR_IN */
|
|
{ 3, 4 }, /* ALC_PIN_DIR_OUT */
|
|
{ 0, 4 }, /* ALC_PIN_DIR_INOUT */
|
|
{ 2, 2 }, /* ALC_PIN_DIR_IN_NOMICBIAS */
|
|
{ 2, 4 }, /* ALC_PIN_DIR_INOUT_NOMICBIAS */
|
|
};
|
|
#define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
|
|
#define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
|
|
#define alc_pin_mode_n_items(_dir) \
|
|
(alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
|
|
|
|
static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_info *uinfo)
|
|
{
|
|
unsigned int item_num = uinfo->value.enumerated.item;
|
|
unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
|
|
|
|
uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
|
|
uinfo->count = 1;
|
|
uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
|
|
|
|
if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
|
|
item_num = alc_pin_mode_min(dir);
|
|
strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
|
|
return 0;
|
|
}
|
|
|
|
static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
unsigned int i;
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
hda_nid_t nid = kcontrol->private_value & 0xffff;
|
|
unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
|
|
long *valp = ucontrol->value.integer.value;
|
|
unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
|
|
AC_VERB_GET_PIN_WIDGET_CONTROL,
|
|
0x00);
|
|
|
|
/* Find enumerated value for current pinctl setting */
|
|
i = alc_pin_mode_min(dir);
|
|
while (i <= alc_pin_mode_max(dir) && alc_pin_mode_values[i] != pinctl)
|
|
i++;
|
|
*valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
|
|
return 0;
|
|
}
|
|
|
|
static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
signed int change;
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
hda_nid_t nid = kcontrol->private_value & 0xffff;
|
|
unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
|
|
long val = *ucontrol->value.integer.value;
|
|
unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
|
|
AC_VERB_GET_PIN_WIDGET_CONTROL,
|
|
0x00);
|
|
|
|
if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
|
|
val = alc_pin_mode_min(dir);
|
|
|
|
change = pinctl != alc_pin_mode_values[val];
|
|
if (change) {
|
|
/* Set pin mode to that requested */
|
|
snd_hda_codec_write_cache(codec, nid, 0,
|
|
AC_VERB_SET_PIN_WIDGET_CONTROL,
|
|
alc_pin_mode_values[val]);
|
|
|
|
/* Also enable the retasking pin's input/output as required
|
|
* for the requested pin mode. Enum values of 2 or less are
|
|
* input modes.
|
|
*
|
|
* Dynamically switching the input/output buffers probably
|
|
* reduces noise slightly (particularly on input) so we'll
|
|
* do it. However, having both input and output buffers
|
|
* enabled simultaneously doesn't seem to be problematic if
|
|
* this turns out to be necessary in the future.
|
|
*/
|
|
if (val <= 2) {
|
|
snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
|
|
HDA_AMP_MUTE, HDA_AMP_MUTE);
|
|
snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
|
|
HDA_AMP_MUTE, 0);
|
|
} else {
|
|
snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
|
|
HDA_AMP_MUTE, HDA_AMP_MUTE);
|
|
snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
|
|
HDA_AMP_MUTE, 0);
|
|
}
|
|
}
|
|
return change;
|
|
}
|
|
|
|
#define ALC_PIN_MODE(xname, nid, dir) \
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
|
|
.subdevice = HDA_SUBDEV_NID_FLAG | nid, \
|
|
.info = alc_pin_mode_info, \
|
|
.get = alc_pin_mode_get, \
|
|
.put = alc_pin_mode_put, \
|
|
.private_value = nid | (dir<<16) }
|
|
|
|
/* A switch control for ALC260 GPIO pins. Multiple GPIOs can be ganged
|
|
* together using a mask with more than one bit set. This control is
|
|
* currently used only by the ALC260 test model. At this stage they are not
|
|
* needed for any "production" models.
|
|
*/
|
|
#ifdef CONFIG_SND_DEBUG
|
|
#define alc_gpio_data_info snd_ctl_boolean_mono_info
|
|
|
|
static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
hda_nid_t nid = kcontrol->private_value & 0xffff;
|
|
unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
|
|
long *valp = ucontrol->value.integer.value;
|
|
unsigned int val = snd_hda_codec_read(codec, nid, 0,
|
|
AC_VERB_GET_GPIO_DATA, 0x00);
|
|
|
|
*valp = (val & mask) != 0;
|
|
return 0;
|
|
}
|
|
static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
signed int change;
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
hda_nid_t nid = kcontrol->private_value & 0xffff;
|
|
unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
|
|
long val = *ucontrol->value.integer.value;
|
|
unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
|
|
AC_VERB_GET_GPIO_DATA,
|
|
0x00);
|
|
|
|
/* Set/unset the masked GPIO bit(s) as needed */
|
|
change = (val == 0 ? 0 : mask) != (gpio_data & mask);
|
|
if (val == 0)
|
|
gpio_data &= ~mask;
|
|
else
|
|
gpio_data |= mask;
|
|
snd_hda_codec_write_cache(codec, nid, 0,
|
|
AC_VERB_SET_GPIO_DATA, gpio_data);
|
|
|
|
return change;
|
|
}
|
|
#define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
|
|
.subdevice = HDA_SUBDEV_NID_FLAG | nid, \
|
|
.info = alc_gpio_data_info, \
|
|
.get = alc_gpio_data_get, \
|
|
.put = alc_gpio_data_put, \
|
|
.private_value = nid | (mask<<16) }
|
|
#endif /* CONFIG_SND_DEBUG */
|
|
|
|
/* A switch control to allow the enabling of the digital IO pins on the
|
|
* ALC260. This is incredibly simplistic; the intention of this control is
|
|
* to provide something in the test model allowing digital outputs to be
|
|
* identified if present. If models are found which can utilise these
|
|
* outputs a more complete mixer control can be devised for those models if
|
|
* necessary.
|
|
*/
|
|
#ifdef CONFIG_SND_DEBUG
|
|
#define alc_spdif_ctrl_info snd_ctl_boolean_mono_info
|
|
|
|
static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
hda_nid_t nid = kcontrol->private_value & 0xffff;
|
|
unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
|
|
long *valp = ucontrol->value.integer.value;
|
|
unsigned int val = snd_hda_codec_read(codec, nid, 0,
|
|
AC_VERB_GET_DIGI_CONVERT_1, 0x00);
|
|
|
|
*valp = (val & mask) != 0;
|
|
return 0;
|
|
}
|
|
static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
signed int change;
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
hda_nid_t nid = kcontrol->private_value & 0xffff;
|
|
unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
|
|
long val = *ucontrol->value.integer.value;
|
|
unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
|
|
AC_VERB_GET_DIGI_CONVERT_1,
|
|
0x00);
|
|
|
|
/* Set/unset the masked control bit(s) as needed */
|
|
change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
|
|
if (val==0)
|
|
ctrl_data &= ~mask;
|
|
else
|
|
ctrl_data |= mask;
|
|
snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
|
|
ctrl_data);
|
|
|
|
return change;
|
|
}
|
|
#define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
|
|
.subdevice = HDA_SUBDEV_NID_FLAG | nid, \
|
|
.info = alc_spdif_ctrl_info, \
|
|
.get = alc_spdif_ctrl_get, \
|
|
.put = alc_spdif_ctrl_put, \
|
|
.private_value = nid | (mask<<16) }
|
|
#endif /* CONFIG_SND_DEBUG */
|
|
|
|
/* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
|
|
* Again, this is only used in the ALC26x test models to help identify when
|
|
* the EAPD line must be asserted for features to work.
|
|
*/
|
|
#ifdef CONFIG_SND_DEBUG
|
|
#define alc_eapd_ctrl_info snd_ctl_boolean_mono_info
|
|
|
|
static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
hda_nid_t nid = kcontrol->private_value & 0xffff;
|
|
unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
|
|
long *valp = ucontrol->value.integer.value;
|
|
unsigned int val = snd_hda_codec_read(codec, nid, 0,
|
|
AC_VERB_GET_EAPD_BTLENABLE, 0x00);
|
|
|
|
*valp = (val & mask) != 0;
|
|
return 0;
|
|
}
|
|
|
|
static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
int change;
|
|
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
|
hda_nid_t nid = kcontrol->private_value & 0xffff;
|
|
unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
|
|
long val = *ucontrol->value.integer.value;
|
|
unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
|
|
AC_VERB_GET_EAPD_BTLENABLE,
|
|
0x00);
|
|
|
|
/* Set/unset the masked control bit(s) as needed */
|
|
change = (!val ? 0 : mask) != (ctrl_data & mask);
|
|
if (!val)
|
|
ctrl_data &= ~mask;
|
|
else
|
|
ctrl_data |= mask;
|
|
snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
|
|
ctrl_data);
|
|
|
|
return change;
|
|
}
|
|
|
|
#define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
|
|
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
|
|
.subdevice = HDA_SUBDEV_NID_FLAG | nid, \
|
|
.info = alc_eapd_ctrl_info, \
|
|
.get = alc_eapd_ctrl_get, \
|
|
.put = alc_eapd_ctrl_put, \
|
|
.private_value = nid | (mask<<16) }
|
|
#endif /* CONFIG_SND_DEBUG */
|
|
|
|
static void alc_fixup_autocfg_pin_nums(struct hda_codec *codec)
|
|
{
|
|
struct alc_spec *spec = codec->spec;
|
|
struct auto_pin_cfg *cfg = &spec->autocfg;
|
|
|
|
if (!cfg->line_outs) {
|
|
while (cfg->line_outs < AUTO_CFG_MAX_OUTS &&
|
|
cfg->line_out_pins[cfg->line_outs])
|
|
cfg->line_outs++;
|
|
}
|
|
if (!cfg->speaker_outs) {
|
|
while (cfg->speaker_outs < AUTO_CFG_MAX_OUTS &&
|
|
cfg->speaker_pins[cfg->speaker_outs])
|
|
cfg->speaker_outs++;
|
|
}
|
|
if (!cfg->hp_outs) {
|
|
while (cfg->hp_outs < AUTO_CFG_MAX_OUTS &&
|
|
cfg->hp_pins[cfg->hp_outs])
|
|
cfg->hp_outs++;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* set up from the preset table
|
|
*/
|
|
static void setup_preset(struct hda_codec *codec,
|
|
const struct alc_config_preset *preset)
|
|
{
|
|
struct alc_spec *spec = codec->spec;
|
|
int i;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
|
|
add_mixer(spec, preset->mixers[i]);
|
|
spec->cap_mixer = preset->cap_mixer;
|
|
for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
|
|
i++)
|
|
add_verb(spec, preset->init_verbs[i]);
|
|
|
|
spec->channel_mode = preset->channel_mode;
|
|
spec->num_channel_mode = preset->num_channel_mode;
|
|
spec->need_dac_fix = preset->need_dac_fix;
|
|
spec->const_channel_count = preset->const_channel_count;
|
|
|
|
if (preset->const_channel_count)
|
|
spec->multiout.max_channels = preset->const_channel_count;
|
|
else
|
|
spec->multiout.max_channels = spec->channel_mode[0].channels;
|
|
spec->ext_channel_count = spec->channel_mode[0].channels;
|
|
|
|
spec->multiout.num_dacs = preset->num_dacs;
|
|
spec->multiout.dac_nids = preset->dac_nids;
|
|
spec->multiout.dig_out_nid = preset->dig_out_nid;
|
|
spec->multiout.slave_dig_outs = preset->slave_dig_outs;
|
|
spec->multiout.hp_nid = preset->hp_nid;
|
|
|
|
spec->num_mux_defs = preset->num_mux_defs;
|
|
if (!spec->num_mux_defs)
|
|
spec->num_mux_defs = 1;
|
|
spec->input_mux = preset->input_mux;
|
|
|
|
spec->num_adc_nids = preset->num_adc_nids;
|
|
spec->adc_nids = preset->adc_nids;
|
|
spec->capsrc_nids = preset->capsrc_nids;
|
|
spec->dig_in_nid = preset->dig_in_nid;
|
|
|
|
spec->unsol_event = preset->unsol_event;
|
|
spec->init_hook = preset->init_hook;
|
|
#ifdef CONFIG_SND_HDA_POWER_SAVE
|
|
spec->power_hook = preset->power_hook;
|
|
spec->loopback.amplist = preset->loopbacks;
|
|
#endif
|
|
|
|
if (preset->setup)
|
|
preset->setup(codec);
|
|
|
|
alc_fixup_autocfg_pin_nums(codec);
|
|
}
|
|
|
|
static void alc_simple_setup_automute(struct alc_spec *spec, int mode)
|
|
{
|
|
int lo_pin = spec->autocfg.line_out_pins[0];
|
|
|
|
if (lo_pin == spec->autocfg.speaker_pins[0] ||
|
|
lo_pin == spec->autocfg.hp_pins[0])
|
|
lo_pin = 0;
|
|
spec->automute_mode = mode;
|
|
spec->detect_hp = !!spec->autocfg.hp_pins[0];
|
|
spec->detect_lo = !!lo_pin;
|
|
spec->automute_lo = spec->automute_lo_possible = !!lo_pin;
|
|
spec->automute_speaker = spec->automute_speaker_possible = !!spec->autocfg.speaker_pins[0];
|
|
}
|
|
|
|
/* auto-toggle front mic */
|
|
static void alc88x_simple_mic_automute(struct hda_codec *codec)
|
|
{
|
|
unsigned int present;
|
|
unsigned char bits;
|
|
|
|
present = snd_hda_jack_detect(codec, 0x18);
|
|
bits = present ? HDA_AMP_MUTE : 0;
|
|
snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
|
|
}
|
|
|