2 * Universal Interface for Intel High Definition Audio Codec
4 * HD audio interface patch for VIA VT17xx/VT18xx/VT20xx codec
6 * (C) 2006-2009 VIA Technology, Inc.
7 * (C) 2006-2008 Takashi Iwai <tiwai@suse.de>
9 * This driver is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This driver is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 /* * * * * * * * * * * * * * Release History * * * * * * * * * * * * * * * * */
26 /* 2006-03-03 Lydia Wang Create the basic patch to support VT1708 codec */
27 /* 2006-03-14 Lydia Wang Modify hard code for some pin widget nid */
28 /* 2006-08-02 Lydia Wang Add support to VT1709 codec */
29 /* 2006-09-08 Lydia Wang Fix internal loopback recording source select bug */
30 /* 2007-09-12 Lydia Wang Add EAPD enable during driver initialization */
31 /* 2007-09-17 Lydia Wang Add VT1708B codec support */
32 /* 2007-11-14 Lydia Wang Add VT1708A codec HP and CD pin connect config */
33 /* 2008-02-03 Lydia Wang Fix Rear channels and Back channels inverse issue */
34 /* 2008-03-06 Lydia Wang Add VT1702 codec and VT1708S codec support */
35 /* 2008-04-09 Lydia Wang Add mute front speaker when HP plugin */
36 /* 2008-04-09 Lydia Wang Add Independent HP feature */
37 /* 2008-05-28 Lydia Wang Add second S/PDIF Out support for VT1702 */
38 /* 2008-09-15 Logan Li Add VT1708S Mic Boost workaround/backdoor */
39 /* 2009-02-16 Logan Li Add support for VT1718S */
40 /* 2009-03-13 Logan Li Add support for VT1716S */
41 /* 2009-04-14 Lydai Wang Add support for VT1828S and VT2020 */
42 /* 2009-07-08 Lydia Wang Add support for VT2002P */
43 /* 2009-07-21 Lydia Wang Add support for VT1812 */
44 /* 2009-09-19 Lydia Wang Add support for VT1818S */
46 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
49 #include <linux/init.h>
50 #include <linux/delay.h>
51 #include <linux/slab.h>
52 #include <linux/module.h>
53 #include <sound/core.h>
54 #include <sound/asoundef.h>
55 #include "hda_codec.h"
56 #include "hda_local.h"
60 #define VT1708_HP_PIN_NID 0x20
61 #define VT1708_CD_PIN_NID 0x24
81 #define VT2002P_COMPATIBLE(spec) \
82 ((spec)->codec_type == VT2002P ||\
83 (spec)->codec_type == VT1812 ||\
84 (spec)->codec_type == VT1802)
86 #define MAX_NID_PATH_DEPTH 5
88 /* output-path: DAC -> ... -> pin
89 * idx[] contains the source index number of the next widget;
90 * e.g. idx[0] is the index of the DAC selected by path[1] widget
91 * multi[] indicates whether it's a selector widget with multi-connectors
92 * (i.e. the connection selection is mandatory)
93 * vol_ctl and mute_ctl contains the NIDs for the assigned mixers
97 hda_nid_t path[MAX_NID_PATH_DEPTH];
98 unsigned char idx[MAX_NID_PATH_DEPTH];
99 unsigned char multi[MAX_NID_PATH_DEPTH];
100 unsigned int vol_ctl;
101 unsigned int mute_ctl;
106 hda_nid_t pin; /* input-pin or aa-mix */
107 int adc_idx; /* ADC index to be used */
108 int mux_idx; /* MUX index (if any) */
109 const char *label; /* input-source label */
112 #define VIA_MAX_ADCS 3
115 STREAM_MULTI_OUT = (1 << 0),
116 STREAM_INDEP_HP = (1 << 1),
120 /* codec parameterization */
121 const struct snd_kcontrol_new *mixers[6];
122 unsigned int num_mixers;
124 const struct hda_verb *init_verbs[5];
125 unsigned int num_iverbs;
127 char stream_name_analog[32];
128 char stream_name_hp[32];
129 const struct hda_pcm_stream *stream_analog_playback;
130 const struct hda_pcm_stream *stream_analog_capture;
132 char stream_name_digital[32];
133 const struct hda_pcm_stream *stream_digital_playback;
134 const struct hda_pcm_stream *stream_digital_capture;
137 struct hda_multi_out multiout;
138 hda_nid_t slave_dig_outs[2];
139 hda_nid_t hp_dac_nid;
140 hda_nid_t speaker_dac_nid;
141 int hp_indep_shared; /* indep HP-DAC is shared with side ch */
142 int opened_streams; /* STREAM_* bits */
143 int active_streams; /* STREAM_* bits */
144 int aamix_mode; /* loopback is enabled for output-path? */
147 * There are different output-paths depending on the setup.
148 * out_path, hp_path and speaker_path are primary paths. If both
149 * direct DAC and aa-loopback routes are available, these contain
150 * the former paths. Meanwhile *_mix_path contain the paths with
151 * loopback mixer. (Since the loopback is only for front channel,
152 * no out_mix_path for surround channels.)
153 * The HP output has another path, hp_indep_path, which is used in
154 * the independent-HP mode.
156 struct nid_path out_path[HDA_SIDE + 1];
157 struct nid_path out_mix_path;
158 struct nid_path hp_path;
159 struct nid_path hp_mix_path;
160 struct nid_path hp_indep_path;
161 struct nid_path speaker_path;
162 struct nid_path speaker_mix_path;
165 unsigned int num_adc_nids;
166 hda_nid_t adc_nids[VIA_MAX_ADCS];
167 hda_nid_t mux_nids[VIA_MAX_ADCS];
168 hda_nid_t aa_mix_nid;
169 hda_nid_t dig_in_nid;
174 struct via_input inputs[AUTO_CFG_MAX_INS + 1];
175 unsigned int cur_mux[VIA_MAX_ADCS];
177 /* dynamic DAC switching */
178 unsigned int cur_dac_stream_tag;
179 unsigned int cur_dac_format;
180 unsigned int cur_hp_stream_tag;
181 unsigned int cur_hp_format;
183 /* dynamic ADC switching */
185 unsigned int cur_adc_stream_tag;
186 unsigned int cur_adc_format;
188 /* PCM information */
189 struct hda_pcm pcm_rec[3];
191 /* dynamic controls, init_verbs and input_mux */
192 struct auto_pin_cfg autocfg;
193 struct snd_array kctls;
194 hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
197 unsigned int hp_independent_mode;
198 unsigned int dmic_enabled;
199 unsigned int no_pin_power_ctl;
200 enum VIA_HDA_CODEC codec_type;
203 unsigned int smart51_nums;
204 hda_nid_t smart51_pins[2];
206 const char *smart51_labels[2];
207 unsigned int smart51_enabled;
209 /* work to check hp jack state */
210 struct hda_codec *codec;
211 struct delayed_work vt1708_hp_work;
213 int vt1708_jack_detect;
214 int vt1708_hp_present;
216 void (*set_widgets_power_state)(struct hda_codec *codec);
218 struct hda_loopback_check loopback;
220 struct hda_amp_list loopback_list[8];
222 /* bind capture-volume */
223 struct hda_bind_ctls *bind_cap_vol;
224 struct hda_bind_ctls *bind_cap_sw;
226 struct mutex config_mutex;
229 static enum VIA_HDA_CODEC get_codec_type(struct hda_codec *codec);
230 static struct via_spec * via_new_spec(struct hda_codec *codec)
232 struct via_spec *spec;
234 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
238 mutex_init(&spec->config_mutex);
241 spec->codec_type = get_codec_type(codec);
242 /* VT1708BCE & VT1708S are almost same */
243 if (spec->codec_type == VT1708BCE)
244 spec->codec_type = VT1708S;
248 static enum VIA_HDA_CODEC get_codec_type(struct hda_codec *codec)
250 u32 vendor_id = codec->vendor_id;
251 u16 ven_id = vendor_id >> 16;
252 u16 dev_id = vendor_id & 0xffff;
253 enum VIA_HDA_CODEC codec_type;
256 if (ven_id != 0x1106)
257 codec_type = UNKNOWN;
258 else if (dev_id >= 0x1708 && dev_id <= 0x170b)
260 else if (dev_id >= 0xe710 && dev_id <= 0xe713)
261 codec_type = VT1709_10CH;
262 else if (dev_id >= 0xe714 && dev_id <= 0xe717)
263 codec_type = VT1709_6CH;
264 else if (dev_id >= 0xe720 && dev_id <= 0xe723) {
265 codec_type = VT1708B_8CH;
266 if (snd_hda_param_read(codec, 0x16, AC_PAR_CONNLIST_LEN) == 0x7)
267 codec_type = VT1708BCE;
268 } else if (dev_id >= 0xe724 && dev_id <= 0xe727)
269 codec_type = VT1708B_4CH;
270 else if ((dev_id & 0xfff) == 0x397
271 && (dev_id >> 12) < 8)
272 codec_type = VT1708S;
273 else if ((dev_id & 0xfff) == 0x398
274 && (dev_id >> 12) < 8)
276 else if ((dev_id & 0xfff) == 0x428
277 && (dev_id >> 12) < 8)
278 codec_type = VT1718S;
279 else if (dev_id == 0x0433 || dev_id == 0xa721)
280 codec_type = VT1716S;
281 else if (dev_id == 0x0441 || dev_id == 0x4441)
282 codec_type = VT1718S;
283 else if (dev_id == 0x0438 || dev_id == 0x4438)
284 codec_type = VT2002P;
285 else if (dev_id == 0x0448)
287 else if (dev_id == 0x0440)
288 codec_type = VT1708S;
289 else if ((dev_id & 0xfff) == 0x446)
292 codec_type = UNKNOWN;
296 #define VIA_JACK_EVENT 0x20
297 #define VIA_HP_EVENT 0x01
298 #define VIA_GPIO_EVENT 0x02
299 #define VIA_LINE_EVENT 0x03
304 VIA_CTL_WIDGET_ANALOG_MUTE,
307 static void analog_low_current_mode(struct hda_codec *codec);
308 static bool is_aa_path_mute(struct hda_codec *codec);
310 #define hp_detect_with_aa(codec) \
311 (snd_hda_get_bool_hint(codec, "analog_loopback_hp_detect") == 1 && \
312 !is_aa_path_mute(codec))
314 static void vt1708_stop_hp_work(struct via_spec *spec)
316 if (spec->codec_type != VT1708 || spec->autocfg.hp_pins[0] == 0)
318 if (spec->hp_work_active) {
319 snd_hda_codec_write(spec->codec, 0x1, 0, 0xf81, 1);
320 cancel_delayed_work_sync(&spec->vt1708_hp_work);
321 spec->hp_work_active = 0;
325 static void vt1708_update_hp_work(struct via_spec *spec)
327 if (spec->codec_type != VT1708 || spec->autocfg.hp_pins[0] == 0)
329 if (spec->vt1708_jack_detect &&
330 (spec->active_streams || hp_detect_with_aa(spec->codec))) {
331 if (!spec->hp_work_active) {
332 snd_hda_codec_write(spec->codec, 0x1, 0, 0xf81, 0);
333 schedule_delayed_work(&spec->vt1708_hp_work,
334 msecs_to_jiffies(100));
335 spec->hp_work_active = 1;
337 } else if (!hp_detect_with_aa(spec->codec))
338 vt1708_stop_hp_work(spec);
341 static void set_widgets_power_state(struct hda_codec *codec)
343 struct via_spec *spec = codec->spec;
344 if (spec->set_widgets_power_state)
345 spec->set_widgets_power_state(codec);
348 static int analog_input_switch_put(struct snd_kcontrol *kcontrol,
349 struct snd_ctl_elem_value *ucontrol)
351 int change = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
352 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
354 set_widgets_power_state(codec);
355 analog_low_current_mode(snd_kcontrol_chip(kcontrol));
356 vt1708_update_hp_work(codec->spec);
360 /* modify .put = snd_hda_mixer_amp_switch_put */
361 #define ANALOG_INPUT_MUTE \
362 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
365 .info = snd_hda_mixer_amp_switch_info, \
366 .get = snd_hda_mixer_amp_switch_get, \
367 .put = analog_input_switch_put, \
368 .private_value = HDA_COMPOSE_AMP_VAL(0, 3, 0, 0) }
370 static const struct snd_kcontrol_new via_control_templates[] = {
371 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
372 HDA_CODEC_MUTE(NULL, 0, 0, 0),
377 /* add dynamic controls */
378 static struct snd_kcontrol_new *__via_clone_ctl(struct via_spec *spec,
379 const struct snd_kcontrol_new *tmpl,
382 struct snd_kcontrol_new *knew;
384 snd_array_init(&spec->kctls, sizeof(*knew), 32);
385 knew = snd_array_new(&spec->kctls);
392 knew->name = kstrdup(name, GFP_KERNEL);
399 static int __via_add_control(struct via_spec *spec, int type, const char *name,
400 int idx, unsigned long val)
402 struct snd_kcontrol_new *knew;
404 knew = __via_clone_ctl(spec, &via_control_templates[type], name);
408 if (get_amp_nid_(val))
409 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
410 knew->private_value = val;
414 #define via_add_control(spec, type, name, val) \
415 __via_add_control(spec, type, name, 0, val)
417 #define via_clone_control(spec, tmpl) __via_clone_ctl(spec, tmpl, NULL)
419 static void via_free_kctls(struct hda_codec *codec)
421 struct via_spec *spec = codec->spec;
423 if (spec->kctls.list) {
424 struct snd_kcontrol_new *kctl = spec->kctls.list;
426 for (i = 0; i < spec->kctls.used; i++)
429 snd_array_free(&spec->kctls);
432 /* create input playback/capture controls for the given pin */
433 static int via_new_analog_input(struct via_spec *spec, const char *ctlname,
434 int type_idx, int idx, int mix_nid)
439 sprintf(name, "%s Playback Volume", ctlname);
440 err = __via_add_control(spec, VIA_CTL_WIDGET_VOL, name, type_idx,
441 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
444 sprintf(name, "%s Playback Switch", ctlname);
445 err = __via_add_control(spec, VIA_CTL_WIDGET_ANALOG_MUTE, name, type_idx,
446 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
452 #define get_connection_index(codec, mux, nid) \
453 snd_hda_get_conn_index(codec, mux, nid, 0)
455 static bool check_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
461 caps = get_wcaps(codec, nid);
462 if (dir == HDA_INPUT)
463 caps &= AC_WCAP_IN_AMP;
465 caps &= AC_WCAP_OUT_AMP;
468 if (query_amp_caps(codec, nid, dir) & mask)
473 #define have_mute(codec, nid, dir) \
474 check_amp_caps(codec, nid, dir, AC_AMPCAP_MUTE)
476 /* enable/disable the output-route mixers */
477 static void activate_output_mix(struct hda_codec *codec, struct nid_path *path,
478 hda_nid_t mix_nid, int idx, bool enable)
484 num = snd_hda_get_conn_list(codec, mix_nid, NULL);
485 for (i = 0; i < num; i++) {
487 val = AMP_IN_UNMUTE(i);
489 val = AMP_IN_MUTE(i);
490 snd_hda_codec_write(codec, mix_nid, 0,
491 AC_VERB_SET_AMP_GAIN_MUTE, val);
495 /* enable/disable the output-route */
496 static void activate_output_path(struct hda_codec *codec, struct nid_path *path,
497 bool enable, bool force)
499 struct via_spec *spec = codec->spec;
501 for (i = 0; i < path->depth; i++) {
503 int idx = path->idx[i];
505 if (i < path->depth - 1)
506 dst = path->path[i + 1];
509 if (enable && path->multi[i])
510 snd_hda_codec_write(codec, dst, 0,
511 AC_VERB_SET_CONNECT_SEL, idx);
512 if (!force && (dst == spec->aa_mix_nid))
514 if (have_mute(codec, dst, HDA_INPUT))
515 activate_output_mix(codec, path, dst, idx, enable);
516 if (!force && (src == path->vol_ctl || src == path->mute_ctl))
518 if (have_mute(codec, src, HDA_OUTPUT)) {
519 int val = enable ? AMP_OUT_UNMUTE : AMP_OUT_MUTE;
520 snd_hda_codec_write(codec, src, 0,
521 AC_VERB_SET_AMP_GAIN_MUTE, val);
526 /* set the given pin as output */
527 static void init_output_pin(struct hda_codec *codec, hda_nid_t pin,
532 snd_hda_codec_write(codec, pin, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
534 if (snd_hda_query_pin_caps(codec, pin) & AC_PINCAP_EAPD)
535 snd_hda_codec_write(codec, pin, 0,
536 AC_VERB_SET_EAPD_BTLENABLE, 0x02);
539 static void via_auto_init_output(struct hda_codec *codec,
540 struct nid_path *path, int pin_type)
547 pin = path->path[path->depth - 1];
549 init_output_pin(codec, pin, pin_type);
550 caps = query_amp_caps(codec, pin, HDA_OUTPUT);
551 if (caps & AC_AMPCAP_MUTE) {
553 val = (caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT;
554 snd_hda_codec_write(codec, pin, 0, AC_VERB_SET_AMP_GAIN_MUTE,
557 activate_output_path(codec, path, true, true); /* force on */
560 static void via_auto_init_multi_out(struct hda_codec *codec)
562 struct via_spec *spec = codec->spec;
563 struct nid_path *path;
566 for (i = 0; i < spec->autocfg.line_outs + spec->smart51_nums; i++) {
567 path = &spec->out_path[i];
568 if (!i && spec->aamix_mode && spec->out_mix_path.depth)
569 path = &spec->out_mix_path;
570 via_auto_init_output(codec, path, PIN_OUT);
574 /* deactivate the inactive headphone-paths */
575 static void deactivate_hp_paths(struct hda_codec *codec)
577 struct via_spec *spec = codec->spec;
578 int shared = spec->hp_indep_shared;
580 if (spec->hp_independent_mode) {
581 activate_output_path(codec, &spec->hp_path, false, false);
582 activate_output_path(codec, &spec->hp_mix_path, false, false);
584 activate_output_path(codec, &spec->out_path[shared],
586 } else if (spec->aamix_mode || !spec->hp_path.depth) {
587 activate_output_path(codec, &spec->hp_indep_path, false, false);
588 activate_output_path(codec, &spec->hp_path, false, false);
590 activate_output_path(codec, &spec->hp_indep_path, false, false);
591 activate_output_path(codec, &spec->hp_mix_path, false, false);
595 static void via_auto_init_hp_out(struct hda_codec *codec)
597 struct via_spec *spec = codec->spec;
599 if (!spec->hp_path.depth) {
600 via_auto_init_output(codec, &spec->hp_mix_path, PIN_HP);
603 deactivate_hp_paths(codec);
604 if (spec->hp_independent_mode)
605 via_auto_init_output(codec, &spec->hp_indep_path, PIN_HP);
606 else if (spec->aamix_mode)
607 via_auto_init_output(codec, &spec->hp_mix_path, PIN_HP);
609 via_auto_init_output(codec, &spec->hp_path, PIN_HP);
612 static void via_auto_init_speaker_out(struct hda_codec *codec)
614 struct via_spec *spec = codec->spec;
616 if (!spec->autocfg.speaker_outs)
618 if (!spec->speaker_path.depth) {
619 via_auto_init_output(codec, &spec->speaker_mix_path, PIN_OUT);
622 if (!spec->aamix_mode) {
623 activate_output_path(codec, &spec->speaker_mix_path,
625 via_auto_init_output(codec, &spec->speaker_path, PIN_OUT);
627 activate_output_path(codec, &spec->speaker_path, false, false);
628 via_auto_init_output(codec, &spec->speaker_mix_path, PIN_OUT);
632 static bool is_smart51_pins(struct hda_codec *codec, hda_nid_t pin);
633 static void via_hp_automute(struct hda_codec *codec);
635 static void via_auto_init_analog_input(struct hda_codec *codec)
637 struct via_spec *spec = codec->spec;
638 const struct auto_pin_cfg *cfg = &spec->autocfg;
639 hda_nid_t conn[HDA_MAX_CONNECTIONS];
644 for (i = 0; i < spec->num_adc_nids; i++) {
645 snd_hda_codec_write(codec, spec->adc_nids[i], 0,
646 AC_VERB_SET_AMP_GAIN_MUTE,
651 for (i = 0; i < cfg->num_inputs; i++) {
652 hda_nid_t nid = cfg->inputs[i].pin;
653 if (spec->smart51_enabled && is_smart51_pins(codec, nid))
655 else if (cfg->inputs[i].type == AUTO_PIN_MIC)
659 snd_hda_codec_write(codec, nid, 0,
660 AC_VERB_SET_PIN_WIDGET_CONTROL, ctl);
664 for (i = 0; i < spec->num_adc_nids; i++) {
665 int adc_idx = spec->inputs[spec->cur_mux[i]].adc_idx;
666 if (spec->mux_nids[adc_idx]) {
667 int mux_idx = spec->inputs[spec->cur_mux[i]].mux_idx;
668 snd_hda_codec_write(codec, spec->mux_nids[adc_idx], 0,
669 AC_VERB_SET_CONNECT_SEL,
672 if (spec->dyn_adc_switch)
673 break; /* only one input-src */
677 if (!spec->aa_mix_nid)
679 num_conns = snd_hda_get_connections(codec, spec->aa_mix_nid, conn,
681 for (i = 0; i < num_conns; i++) {
682 unsigned int caps = get_wcaps(codec, conn[i]);
683 if (get_wcaps_type(caps) == AC_WID_PIN)
684 snd_hda_codec_write(codec, spec->aa_mix_nid, 0,
685 AC_VERB_SET_AMP_GAIN_MUTE,
690 static void set_pin_power_state(struct hda_codec *codec, hda_nid_t nid,
691 unsigned int *affected_parm)
694 unsigned def_conf = snd_hda_codec_get_pincfg(codec, nid);
695 unsigned no_presence = (def_conf & AC_DEFCFG_MISC)
696 >> AC_DEFCFG_MISC_SHIFT
697 & AC_DEFCFG_MISC_NO_PRESENCE; /* do not support pin sense */
698 struct via_spec *spec = codec->spec;
699 unsigned present = 0;
701 no_presence |= spec->no_pin_power_ctl;
703 present = snd_hda_jack_detect(codec, nid);
704 if ((spec->smart51_enabled && is_smart51_pins(codec, nid))
705 || ((no_presence || present)
706 && get_defcfg_connect(def_conf) != AC_JACK_PORT_NONE)) {
707 *affected_parm = AC_PWRST_D0; /* if it's connected */
712 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE, parm);
715 static int via_pin_power_ctl_info(struct snd_kcontrol *kcontrol,
716 struct snd_ctl_elem_info *uinfo)
718 static const char * const texts[] = {
719 "Disabled", "Enabled"
722 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
724 uinfo->value.enumerated.items = 2;
725 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
726 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
727 strcpy(uinfo->value.enumerated.name,
728 texts[uinfo->value.enumerated.item]);
732 static int via_pin_power_ctl_get(struct snd_kcontrol *kcontrol,
733 struct snd_ctl_elem_value *ucontrol)
735 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
736 struct via_spec *spec = codec->spec;
737 ucontrol->value.enumerated.item[0] = !spec->no_pin_power_ctl;
741 static int via_pin_power_ctl_put(struct snd_kcontrol *kcontrol,
742 struct snd_ctl_elem_value *ucontrol)
744 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
745 struct via_spec *spec = codec->spec;
746 unsigned int val = !ucontrol->value.enumerated.item[0];
748 if (val == spec->no_pin_power_ctl)
750 spec->no_pin_power_ctl = val;
751 set_widgets_power_state(codec);
755 static const struct snd_kcontrol_new via_pin_power_ctl_enum = {
756 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
757 .name = "Dynamic Power-Control",
758 .info = via_pin_power_ctl_info,
759 .get = via_pin_power_ctl_get,
760 .put = via_pin_power_ctl_put,
764 static int via_independent_hp_info(struct snd_kcontrol *kcontrol,
765 struct snd_ctl_elem_info *uinfo)
767 static const char * const texts[] = { "OFF", "ON" };
769 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
771 uinfo->value.enumerated.items = 2;
772 if (uinfo->value.enumerated.item >= 2)
773 uinfo->value.enumerated.item = 1;
774 strcpy(uinfo->value.enumerated.name,
775 texts[uinfo->value.enumerated.item]);
779 static int via_independent_hp_get(struct snd_kcontrol *kcontrol,
780 struct snd_ctl_elem_value *ucontrol)
782 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
783 struct via_spec *spec = codec->spec;
785 ucontrol->value.enumerated.item[0] = spec->hp_independent_mode;
789 /* adjust spec->multiout setup according to the current flags */
790 static void setup_playback_multi_pcm(struct via_spec *spec)
792 const struct auto_pin_cfg *cfg = &spec->autocfg;
793 spec->multiout.num_dacs = cfg->line_outs + spec->smart51_nums;
794 spec->multiout.hp_nid = 0;
795 if (!spec->hp_independent_mode) {
796 if (!spec->hp_indep_shared)
797 spec->multiout.hp_nid = spec->hp_dac_nid;
799 if (spec->hp_indep_shared)
800 spec->multiout.num_dacs = cfg->line_outs - 1;
804 /* update DAC setups according to indep-HP switch;
805 * this function is called only when indep-HP is modified
807 static void switch_indep_hp_dacs(struct hda_codec *codec)
809 struct via_spec *spec = codec->spec;
810 int shared = spec->hp_indep_shared;
811 hda_nid_t shared_dac, hp_dac;
813 if (!spec->opened_streams)
816 shared_dac = shared ? spec->multiout.dac_nids[shared] : 0;
817 hp_dac = spec->hp_dac_nid;
818 if (spec->hp_independent_mode) {
819 /* switch to indep-HP mode */
820 if (spec->active_streams & STREAM_MULTI_OUT) {
821 __snd_hda_codec_cleanup_stream(codec, hp_dac, 1);
822 __snd_hda_codec_cleanup_stream(codec, shared_dac, 1);
824 if (spec->active_streams & STREAM_INDEP_HP)
825 snd_hda_codec_setup_stream(codec, hp_dac,
826 spec->cur_hp_stream_tag, 0,
827 spec->cur_hp_format);
829 /* back to HP or shared-DAC */
830 if (spec->active_streams & STREAM_INDEP_HP)
831 __snd_hda_codec_cleanup_stream(codec, hp_dac, 1);
832 if (spec->active_streams & STREAM_MULTI_OUT) {
835 if (shared_dac) { /* reset mutli-ch DAC */
838 } else { /* reset HP DAC */
842 snd_hda_codec_setup_stream(codec, dac,
843 spec->cur_dac_stream_tag, ch,
844 spec->cur_dac_format);
847 setup_playback_multi_pcm(spec);
850 static int via_independent_hp_put(struct snd_kcontrol *kcontrol,
851 struct snd_ctl_elem_value *ucontrol)
853 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
854 struct via_spec *spec = codec->spec;
857 mutex_lock(&spec->config_mutex);
858 cur = !!ucontrol->value.enumerated.item[0];
859 if (spec->hp_independent_mode == cur) {
860 mutex_unlock(&spec->config_mutex);
863 spec->hp_independent_mode = cur;
864 shared = spec->hp_indep_shared;
865 deactivate_hp_paths(codec);
867 activate_output_path(codec, &spec->hp_indep_path, true, false);
870 activate_output_path(codec, &spec->out_path[shared],
872 if (spec->aamix_mode || !spec->hp_path.depth)
873 activate_output_path(codec, &spec->hp_mix_path,
876 activate_output_path(codec, &spec->hp_path,
880 switch_indep_hp_dacs(codec);
881 mutex_unlock(&spec->config_mutex);
883 /* update jack power state */
884 set_widgets_power_state(codec);
885 via_hp_automute(codec);
889 static const struct snd_kcontrol_new via_hp_mixer = {
890 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
891 .name = "Independent HP",
892 .info = via_independent_hp_info,
893 .get = via_independent_hp_get,
894 .put = via_independent_hp_put,
897 static int via_hp_build(struct hda_codec *codec)
899 struct via_spec *spec = codec->spec;
900 struct snd_kcontrol_new *knew;
903 nid = spec->autocfg.hp_pins[0];
904 knew = via_clone_control(spec, &via_hp_mixer);
908 knew->subdevice = HDA_SUBDEV_NID_FLAG | nid;
913 static void notify_aa_path_ctls(struct hda_codec *codec)
915 struct via_spec *spec = codec->spec;
918 for (i = 0; i < spec->smart51_nums; i++) {
919 struct snd_kcontrol *ctl;
920 struct snd_ctl_elem_id id;
921 memset(&id, 0, sizeof(id));
922 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
923 sprintf(id.name, "%s Playback Volume", spec->smart51_labels[i]);
924 ctl = snd_hda_find_mixer_ctl(codec, id.name);
926 snd_ctl_notify(codec->bus->card,
927 SNDRV_CTL_EVENT_MASK_VALUE,
932 static void mute_aa_path(struct hda_codec *codec, int mute)
934 struct via_spec *spec = codec->spec;
935 int val = mute ? HDA_AMP_MUTE : HDA_AMP_UNMUTE;
938 /* check AA path's mute status */
939 for (i = 0; i < spec->smart51_nums; i++) {
940 if (spec->smart51_idxs[i] < 0)
942 snd_hda_codec_amp_stereo(codec, spec->aa_mix_nid,
943 HDA_INPUT, spec->smart51_idxs[i],
948 static bool is_smart51_pins(struct hda_codec *codec, hda_nid_t pin)
950 struct via_spec *spec = codec->spec;
953 for (i = 0; i < spec->smart51_nums; i++)
954 if (spec->smart51_pins[i] == pin)
959 static int via_smart51_get(struct snd_kcontrol *kcontrol,
960 struct snd_ctl_elem_value *ucontrol)
962 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
963 struct via_spec *spec = codec->spec;
965 *ucontrol->value.integer.value = spec->smart51_enabled;
969 static int via_smart51_put(struct snd_kcontrol *kcontrol,
970 struct snd_ctl_elem_value *ucontrol)
972 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
973 struct via_spec *spec = codec->spec;
974 int out_in = *ucontrol->value.integer.value
975 ? AC_PINCTL_OUT_EN : AC_PINCTL_IN_EN;
978 for (i = 0; i < spec->smart51_nums; i++) {
979 hda_nid_t nid = spec->smart51_pins[i];
982 parm = snd_hda_codec_read(codec, nid, 0,
983 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
984 parm &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
986 snd_hda_codec_write(codec, nid, 0,
987 AC_VERB_SET_PIN_WIDGET_CONTROL,
989 if (out_in == AC_PINCTL_OUT_EN) {
990 mute_aa_path(codec, 1);
991 notify_aa_path_ctls(codec);
994 spec->smart51_enabled = *ucontrol->value.integer.value;
995 set_widgets_power_state(codec);
999 static const struct snd_kcontrol_new via_smart51_mixer = {
1000 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1001 .name = "Smart 5.1",
1003 .info = snd_ctl_boolean_mono_info,
1004 .get = via_smart51_get,
1005 .put = via_smart51_put,
1008 static int via_smart51_build(struct hda_codec *codec)
1010 struct via_spec *spec = codec->spec;
1012 if (!spec->smart51_nums)
1014 if (!via_clone_control(spec, &via_smart51_mixer))
1019 /* check AA path's mute status */
1020 static bool is_aa_path_mute(struct hda_codec *codec)
1022 struct via_spec *spec = codec->spec;
1023 const struct hda_amp_list *p;
1026 for (i = 0; i < spec->num_loopbacks; i++) {
1027 p = &spec->loopback_list[i];
1028 for (ch = 0; ch < 2; ch++) {
1029 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
1031 if (!(v & HDA_AMP_MUTE) && v > 0)
1038 /* enter/exit analog low-current mode */
1039 static void analog_low_current_mode(struct hda_codec *codec)
1041 struct via_spec *spec = codec->spec;
1043 unsigned int verb, parm;
1045 enable = is_aa_path_mute(codec) && (spec->opened_streams != 0);
1047 /* decide low current mode's verb & parameter */
1048 switch (spec->codec_type) {
1052 parm = enable ? 0x02 : 0x00; /* 0x02: 2/3x, 0x00: 1x */
1058 parm = enable ? 0x51 : 0xe1; /* 0x51: 4/28x, 0xe1: 1x */
1062 parm = enable ? 0x01 : 0x1d; /* 0x01: 4/40x, 0x1d: 1x */
1068 parm = enable ? 0x00 : 0xe0; /* 0x00: 4/40x, 0xe0: 1x */
1071 return; /* other codecs are not supported */
1074 snd_hda_codec_write(codec, codec->afg, 0, verb, parm);
1078 * generic initialization of ADC, input mixers and output mixers
1080 static const struct hda_verb vt1708_init_verbs[] = {
1081 /* power down jack detect function */
1086 static void set_stream_open(struct hda_codec *codec, int bit, bool active)
1088 struct via_spec *spec = codec->spec;
1091 spec->opened_streams |= bit;
1093 spec->opened_streams &= ~bit;
1094 analog_low_current_mode(codec);
1097 static int via_playback_multi_pcm_open(struct hda_pcm_stream *hinfo,
1098 struct hda_codec *codec,
1099 struct snd_pcm_substream *substream)
1101 struct via_spec *spec = codec->spec;
1102 const struct auto_pin_cfg *cfg = &spec->autocfg;
1105 spec->multiout.num_dacs = cfg->line_outs + spec->smart51_nums;
1106 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
1107 set_stream_open(codec, STREAM_MULTI_OUT, true);
1108 err = snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
1111 set_stream_open(codec, STREAM_MULTI_OUT, false);
1117 static int via_playback_multi_pcm_close(struct hda_pcm_stream *hinfo,
1118 struct hda_codec *codec,
1119 struct snd_pcm_substream *substream)
1121 set_stream_open(codec, STREAM_MULTI_OUT, false);
1125 static int via_playback_hp_pcm_open(struct hda_pcm_stream *hinfo,
1126 struct hda_codec *codec,
1127 struct snd_pcm_substream *substream)
1129 struct via_spec *spec = codec->spec;
1131 if (snd_BUG_ON(!spec->hp_dac_nid))
1133 set_stream_open(codec, STREAM_INDEP_HP, true);
1137 static int via_playback_hp_pcm_close(struct hda_pcm_stream *hinfo,
1138 struct hda_codec *codec,
1139 struct snd_pcm_substream *substream)
1141 set_stream_open(codec, STREAM_INDEP_HP, false);
1145 static int via_playback_multi_pcm_prepare(struct hda_pcm_stream *hinfo,
1146 struct hda_codec *codec,
1147 unsigned int stream_tag,
1148 unsigned int format,
1149 struct snd_pcm_substream *substream)
1151 struct via_spec *spec = codec->spec;
1153 mutex_lock(&spec->config_mutex);
1154 setup_playback_multi_pcm(spec);
1155 snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag,
1157 /* remember for dynamic DAC switch with indep-HP */
1158 spec->active_streams |= STREAM_MULTI_OUT;
1159 spec->cur_dac_stream_tag = stream_tag;
1160 spec->cur_dac_format = format;
1161 mutex_unlock(&spec->config_mutex);
1162 vt1708_update_hp_work(spec);
1166 static int via_playback_hp_pcm_prepare(struct hda_pcm_stream *hinfo,
1167 struct hda_codec *codec,
1168 unsigned int stream_tag,
1169 unsigned int format,
1170 struct snd_pcm_substream *substream)
1172 struct via_spec *spec = codec->spec;
1174 mutex_lock(&spec->config_mutex);
1175 if (spec->hp_independent_mode)
1176 snd_hda_codec_setup_stream(codec, spec->hp_dac_nid,
1177 stream_tag, 0, format);
1178 spec->active_streams |= STREAM_INDEP_HP;
1179 spec->cur_hp_stream_tag = stream_tag;
1180 spec->cur_hp_format = format;
1181 mutex_unlock(&spec->config_mutex);
1182 vt1708_update_hp_work(spec);
1186 static int via_playback_multi_pcm_cleanup(struct hda_pcm_stream *hinfo,
1187 struct hda_codec *codec,
1188 struct snd_pcm_substream *substream)
1190 struct via_spec *spec = codec->spec;
1192 mutex_lock(&spec->config_mutex);
1193 snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
1194 spec->active_streams &= ~STREAM_MULTI_OUT;
1195 mutex_unlock(&spec->config_mutex);
1196 vt1708_update_hp_work(spec);
1200 static int via_playback_hp_pcm_cleanup(struct hda_pcm_stream *hinfo,
1201 struct hda_codec *codec,
1202 struct snd_pcm_substream *substream)
1204 struct via_spec *spec = codec->spec;
1206 mutex_lock(&spec->config_mutex);
1207 if (spec->hp_independent_mode)
1208 snd_hda_codec_setup_stream(codec, spec->hp_dac_nid, 0, 0, 0);
1209 spec->active_streams &= ~STREAM_INDEP_HP;
1210 mutex_unlock(&spec->config_mutex);
1211 vt1708_update_hp_work(spec);
1218 static int via_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
1219 struct hda_codec *codec,
1220 struct snd_pcm_substream *substream)
1222 struct via_spec *spec = codec->spec;
1223 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
1226 static int via_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
1227 struct hda_codec *codec,
1228 struct snd_pcm_substream *substream)
1230 struct via_spec *spec = codec->spec;
1231 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
1234 static int via_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
1235 struct hda_codec *codec,
1236 unsigned int stream_tag,
1237 unsigned int format,
1238 struct snd_pcm_substream *substream)
1240 struct via_spec *spec = codec->spec;
1241 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
1242 stream_tag, format, substream);
1245 static int via_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
1246 struct hda_codec *codec,
1247 struct snd_pcm_substream *substream)
1249 struct via_spec *spec = codec->spec;
1250 snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
1257 static int via_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
1258 struct hda_codec *codec,
1259 unsigned int stream_tag,
1260 unsigned int format,
1261 struct snd_pcm_substream *substream)
1263 struct via_spec *spec = codec->spec;
1265 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
1266 stream_tag, 0, format);
1270 static int via_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
1271 struct hda_codec *codec,
1272 struct snd_pcm_substream *substream)
1274 struct via_spec *spec = codec->spec;
1275 snd_hda_codec_cleanup_stream(codec, spec->adc_nids[substream->number]);
1279 /* analog capture with dynamic ADC switching */
1280 static int via_dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
1281 struct hda_codec *codec,
1282 unsigned int stream_tag,
1283 unsigned int format,
1284 struct snd_pcm_substream *substream)
1286 struct via_spec *spec = codec->spec;
1287 int adc_idx = spec->inputs[spec->cur_mux[0]].adc_idx;
1289 mutex_lock(&spec->config_mutex);
1290 spec->cur_adc = spec->adc_nids[adc_idx];
1291 spec->cur_adc_stream_tag = stream_tag;
1292 spec->cur_adc_format = format;
1293 snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
1294 mutex_unlock(&spec->config_mutex);
1298 static int via_dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
1299 struct hda_codec *codec,
1300 struct snd_pcm_substream *substream)
1302 struct via_spec *spec = codec->spec;
1304 mutex_lock(&spec->config_mutex);
1305 snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
1307 mutex_unlock(&spec->config_mutex);
1311 /* re-setup the stream if running; called from input-src put */
1312 static bool via_dyn_adc_pcm_resetup(struct hda_codec *codec, int cur)
1314 struct via_spec *spec = codec->spec;
1315 int adc_idx = spec->inputs[cur].adc_idx;
1316 hda_nid_t adc = spec->adc_nids[adc_idx];
1319 mutex_lock(&spec->config_mutex);
1320 if (spec->cur_adc && spec->cur_adc != adc) {
1321 /* stream is running, let's swap the current ADC */
1322 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
1323 spec->cur_adc = adc;
1324 snd_hda_codec_setup_stream(codec, adc,
1325 spec->cur_adc_stream_tag, 0,
1326 spec->cur_adc_format);
1329 mutex_unlock(&spec->config_mutex);
1333 static const struct hda_pcm_stream via_pcm_analog_playback = {
1337 /* NID is set in via_build_pcms */
1339 .open = via_playback_multi_pcm_open,
1340 .close = via_playback_multi_pcm_close,
1341 .prepare = via_playback_multi_pcm_prepare,
1342 .cleanup = via_playback_multi_pcm_cleanup
1346 static const struct hda_pcm_stream via_pcm_hp_playback = {
1350 /* NID is set in via_build_pcms */
1352 .open = via_playback_hp_pcm_open,
1353 .close = via_playback_hp_pcm_close,
1354 .prepare = via_playback_hp_pcm_prepare,
1355 .cleanup = via_playback_hp_pcm_cleanup
1359 static const struct hda_pcm_stream vt1708_pcm_analog_s16_playback = {
1363 /* NID is set in via_build_pcms */
1364 /* We got noisy outputs on the right channel on VT1708 when
1365 * 24bit samples are used. Until any workaround is found,
1366 * disable the 24bit format, so far.
1368 .formats = SNDRV_PCM_FMTBIT_S16_LE,
1370 .open = via_playback_multi_pcm_open,
1371 .close = via_playback_multi_pcm_close,
1372 .prepare = via_playback_multi_pcm_prepare,
1373 .cleanup = via_playback_multi_pcm_cleanup
1377 static const struct hda_pcm_stream via_pcm_analog_capture = {
1378 .substreams = 1, /* will be changed in via_build_pcms() */
1381 /* NID is set in via_build_pcms */
1383 .prepare = via_capture_pcm_prepare,
1384 .cleanup = via_capture_pcm_cleanup
1388 static const struct hda_pcm_stream via_pcm_dyn_adc_analog_capture = {
1392 /* NID is set in via_build_pcms */
1394 .prepare = via_dyn_adc_capture_pcm_prepare,
1395 .cleanup = via_dyn_adc_capture_pcm_cleanup,
1399 static const struct hda_pcm_stream via_pcm_digital_playback = {
1403 /* NID is set in via_build_pcms */
1405 .open = via_dig_playback_pcm_open,
1406 .close = via_dig_playback_pcm_close,
1407 .prepare = via_dig_playback_pcm_prepare,
1408 .cleanup = via_dig_playback_pcm_cleanup
1412 static const struct hda_pcm_stream via_pcm_digital_capture = {
1419 * slave controls for virtual master
1421 static const char * const via_slave_vols[] = {
1422 "Front Playback Volume",
1423 "Surround Playback Volume",
1424 "Center Playback Volume",
1425 "LFE Playback Volume",
1426 "Side Playback Volume",
1427 "Headphone Playback Volume",
1428 "Speaker Playback Volume",
1432 static const char * const via_slave_sws[] = {
1433 "Front Playback Switch",
1434 "Surround Playback Switch",
1435 "Center Playback Switch",
1436 "LFE Playback Switch",
1437 "Side Playback Switch",
1438 "Headphone Playback Switch",
1439 "Speaker Playback Switch",
1443 static int via_build_controls(struct hda_codec *codec)
1445 struct via_spec *spec = codec->spec;
1446 struct snd_kcontrol *kctl;
1449 if (spec->set_widgets_power_state)
1450 if (!via_clone_control(spec, &via_pin_power_ctl_enum))
1453 for (i = 0; i < spec->num_mixers; i++) {
1454 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1459 if (spec->multiout.dig_out_nid) {
1460 err = snd_hda_create_spdif_out_ctls(codec,
1461 spec->multiout.dig_out_nid,
1462 spec->multiout.dig_out_nid);
1465 err = snd_hda_create_spdif_share_sw(codec,
1469 spec->multiout.share_spdif = 1;
1471 if (spec->dig_in_nid) {
1472 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1477 /* if we have no master control, let's create it */
1478 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1479 unsigned int vmaster_tlv[4];
1480 snd_hda_set_vmaster_tlv(codec, spec->multiout.dac_nids[0],
1481 HDA_OUTPUT, vmaster_tlv);
1482 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1483 vmaster_tlv, via_slave_vols);
1487 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
1488 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
1489 NULL, via_slave_sws);
1494 /* assign Capture Source enums to NID */
1495 kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
1496 for (i = 0; kctl && i < kctl->count; i++) {
1497 err = snd_hda_add_nid(codec, kctl, i, spec->mux_nids[i]);
1502 /* init power states */
1503 set_widgets_power_state(codec);
1504 analog_low_current_mode(codec);
1506 via_free_kctls(codec); /* no longer needed */
1508 err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
1515 static int via_build_pcms(struct hda_codec *codec)
1517 struct via_spec *spec = codec->spec;
1518 struct hda_pcm *info = spec->pcm_rec;
1520 codec->num_pcms = 0;
1521 codec->pcm_info = info;
1523 if (spec->multiout.num_dacs || spec->num_adc_nids) {
1524 snprintf(spec->stream_name_analog,
1525 sizeof(spec->stream_name_analog),
1526 "%s Analog", codec->chip_name);
1527 info->name = spec->stream_name_analog;
1529 if (spec->multiout.num_dacs) {
1530 if (!spec->stream_analog_playback)
1531 spec->stream_analog_playback =
1532 &via_pcm_analog_playback;
1533 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
1534 *spec->stream_analog_playback;
1535 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
1536 spec->multiout.dac_nids[0];
1537 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
1538 spec->multiout.max_channels;
1541 if (!spec->stream_analog_capture) {
1542 if (spec->dyn_adc_switch)
1543 spec->stream_analog_capture =
1544 &via_pcm_dyn_adc_analog_capture;
1546 spec->stream_analog_capture =
1547 &via_pcm_analog_capture;
1549 if (spec->num_adc_nids) {
1550 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
1551 *spec->stream_analog_capture;
1552 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
1554 if (!spec->dyn_adc_switch)
1555 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
1562 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
1563 snprintf(spec->stream_name_digital,
1564 sizeof(spec->stream_name_digital),
1565 "%s Digital", codec->chip_name);
1566 info->name = spec->stream_name_digital;
1567 info->pcm_type = HDA_PCM_TYPE_SPDIF;
1568 if (spec->multiout.dig_out_nid) {
1569 if (!spec->stream_digital_playback)
1570 spec->stream_digital_playback =
1571 &via_pcm_digital_playback;
1572 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
1573 *spec->stream_digital_playback;
1574 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
1575 spec->multiout.dig_out_nid;
1577 if (spec->dig_in_nid) {
1578 if (!spec->stream_digital_capture)
1579 spec->stream_digital_capture =
1580 &via_pcm_digital_capture;
1581 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
1582 *spec->stream_digital_capture;
1583 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
1590 if (spec->hp_dac_nid) {
1591 snprintf(spec->stream_name_hp, sizeof(spec->stream_name_hp),
1592 "%s HP", codec->chip_name);
1593 info->name = spec->stream_name_hp;
1594 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = via_pcm_hp_playback;
1595 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
1603 static void via_free(struct hda_codec *codec)
1605 struct via_spec *spec = codec->spec;
1610 via_free_kctls(codec);
1611 vt1708_stop_hp_work(spec);
1612 kfree(spec->bind_cap_vol);
1613 kfree(spec->bind_cap_sw);
1617 /* mute/unmute outputs */
1618 static void toggle_output_mutes(struct hda_codec *codec, int num_pins,
1619 hda_nid_t *pins, bool mute)
1622 for (i = 0; i < num_pins; i++) {
1623 unsigned int parm = snd_hda_codec_read(codec, pins[i], 0,
1624 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
1625 if (parm & AC_PINCTL_IN_EN)
1628 parm &= ~AC_PINCTL_OUT_EN;
1630 parm |= AC_PINCTL_OUT_EN;
1631 snd_hda_codec_write(codec, pins[i], 0,
1632 AC_VERB_SET_PIN_WIDGET_CONTROL, parm);
1636 /* mute internal speaker if line-out is plugged */
1637 static void via_line_automute(struct hda_codec *codec, int present)
1639 struct via_spec *spec = codec->spec;
1641 if (!spec->autocfg.speaker_outs)
1644 present = snd_hda_jack_detect(codec,
1645 spec->autocfg.line_out_pins[0]);
1646 toggle_output_mutes(codec, spec->autocfg.speaker_outs,
1647 spec->autocfg.speaker_pins,
1651 /* mute internal speaker if HP is plugged */
1652 static void via_hp_automute(struct hda_codec *codec)
1656 struct via_spec *spec = codec->spec;
1658 if (!spec->hp_independent_mode && spec->autocfg.hp_pins[0] &&
1659 (spec->codec_type != VT1708 || spec->vt1708_jack_detect))
1660 present = snd_hda_jack_detect(codec, spec->autocfg.hp_pins[0]);
1662 if (spec->smart51_enabled)
1663 nums = spec->autocfg.line_outs + spec->smart51_nums;
1665 nums = spec->autocfg.line_outs;
1666 toggle_output_mutes(codec, nums, spec->autocfg.line_out_pins, present);
1668 via_line_automute(codec, present);
1671 static void via_gpio_control(struct hda_codec *codec)
1673 unsigned int gpio_data;
1674 unsigned int vol_counter;
1676 unsigned int master_vol;
1678 struct via_spec *spec = codec->spec;
1680 gpio_data = snd_hda_codec_read(codec, codec->afg, 0,
1681 AC_VERB_GET_GPIO_DATA, 0) & 0x03;
1683 vol_counter = (snd_hda_codec_read(codec, codec->afg, 0,
1684 0xF84, 0) & 0x3F0000) >> 16;
1686 vol = vol_counter & 0x1F;
1687 master_vol = snd_hda_codec_read(codec, 0x1A, 0,
1688 AC_VERB_GET_AMP_GAIN_MUTE,
1691 if (gpio_data == 0x02) {
1692 /* unmute line out */
1693 snd_hda_codec_write(codec, spec->autocfg.line_out_pins[0], 0,
1694 AC_VERB_SET_PIN_WIDGET_CONTROL,
1696 if (vol_counter & 0x20) {
1697 /* decrease volume */
1698 if (vol > master_vol)
1700 snd_hda_codec_amp_stereo(codec, 0x1A, HDA_INPUT,
1704 /* increase volume */
1705 snd_hda_codec_amp_stereo(codec, 0x1A, HDA_INPUT, 0,
1707 ((master_vol+vol) > 0x2A) ? 0x2A :
1710 } else if (!(gpio_data & 0x02)) {
1712 snd_hda_codec_write(codec, spec->autocfg.line_out_pins[0], 0,
1713 AC_VERB_SET_PIN_WIDGET_CONTROL,
1718 /* unsolicited event for jack sensing */
1719 static void via_unsol_event(struct hda_codec *codec,
1723 res = snd_hda_jack_get_action(codec, res);
1725 if (res & VIA_JACK_EVENT)
1726 set_widgets_power_state(codec);
1728 res &= ~VIA_JACK_EVENT;
1730 if (res == VIA_HP_EVENT || res == VIA_LINE_EVENT)
1731 via_hp_automute(codec);
1732 else if (res == VIA_GPIO_EVENT)
1733 via_gpio_control(codec);
1734 snd_hda_jack_report_sync(codec);
1738 static int via_suspend(struct hda_codec *codec, pm_message_t state)
1740 struct via_spec *spec = codec->spec;
1741 vt1708_stop_hp_work(spec);
1746 #ifdef CONFIG_SND_HDA_POWER_SAVE
1747 static int via_check_power_status(struct hda_codec *codec, hda_nid_t nid)
1749 struct via_spec *spec = codec->spec;
1750 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
1757 static int via_init(struct hda_codec *codec);
1759 static const struct hda_codec_ops via_patch_ops = {
1760 .build_controls = via_build_controls,
1761 .build_pcms = via_build_pcms,
1764 .unsol_event = via_unsol_event,
1766 .suspend = via_suspend,
1768 #ifdef CONFIG_SND_HDA_POWER_SAVE
1769 .check_power_status = via_check_power_status,
1773 static bool is_empty_dac(struct hda_codec *codec, hda_nid_t dac)
1775 struct via_spec *spec = codec->spec;
1778 for (i = 0; i < spec->multiout.num_dacs; i++) {
1779 if (spec->multiout.dac_nids[i] == dac)
1782 if (spec->hp_dac_nid == dac)
1787 static bool __parse_output_path(struct hda_codec *codec, hda_nid_t nid,
1788 hda_nid_t target_dac, int with_aa_mix,
1789 struct nid_path *path, int depth)
1791 struct via_spec *spec = codec->spec;
1795 if (nid == spec->aa_mix_nid) {
1798 with_aa_mix = 2; /* mark aa-mix is included */
1801 nums = snd_hda_get_connections(codec, nid, conn, ARRAY_SIZE(conn));
1802 for (i = 0; i < nums; i++) {
1803 if (get_wcaps_type(get_wcaps(codec, conn[i])) != AC_WID_AUD_OUT)
1805 if (conn[i] == target_dac || is_empty_dac(codec, conn[i])) {
1806 /* aa-mix is requested but not included? */
1807 if (!(spec->aa_mix_nid && with_aa_mix == 1))
1811 if (depth >= MAX_NID_PATH_DEPTH)
1813 for (i = 0; i < nums; i++) {
1815 type = get_wcaps_type(get_wcaps(codec, conn[i]));
1816 if (type == AC_WID_AUD_OUT)
1818 if (__parse_output_path(codec, conn[i], target_dac,
1819 with_aa_mix, path, depth + 1))
1825 path->path[path->depth] = conn[i];
1826 path->idx[path->depth] = i;
1827 if (nums > 1 && get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_AUD_MIX)
1828 path->multi[path->depth] = 1;
1833 static bool parse_output_path(struct hda_codec *codec, hda_nid_t nid,
1834 hda_nid_t target_dac, int with_aa_mix,
1835 struct nid_path *path)
1837 if (__parse_output_path(codec, nid, target_dac, with_aa_mix, path, 1)) {
1838 path->path[path->depth] = nid;
1840 snd_printdd("output-path: depth=%d, %02x/%02x/%02x/%02x/%02x\n",
1841 path->depth, path->path[0], path->path[1],
1842 path->path[2], path->path[3], path->path[4]);
1848 static int via_auto_fill_dac_nids(struct hda_codec *codec)
1850 struct via_spec *spec = codec->spec;
1851 const struct auto_pin_cfg *cfg = &spec->autocfg;
1855 spec->multiout.dac_nids = spec->private_dac_nids;
1857 for (i = 0; i < cfg->line_outs; i++) {
1859 nid = cfg->line_out_pins[i];
1862 if (parse_output_path(codec, nid, 0, 0, &spec->out_path[i]))
1863 dac = spec->out_path[i].path[0];
1864 if (!i && parse_output_path(codec, nid, dac, 1,
1865 &spec->out_mix_path))
1866 dac = spec->out_mix_path.path[0];
1868 spec->private_dac_nids[i] = dac;
1872 if (!spec->out_path[0].depth && spec->out_mix_path.depth) {
1873 spec->out_path[0] = spec->out_mix_path;
1874 spec->out_mix_path.depth = 0;
1876 spec->multiout.num_dacs = dac_num;
1880 static int create_ch_ctls(struct hda_codec *codec, const char *pfx,
1881 int chs, bool check_dac, struct nid_path *path)
1883 struct via_spec *spec = codec->spec;
1885 hda_nid_t dac, pin, sel, nid;
1888 dac = check_dac ? path->path[0] : 0;
1889 pin = path->path[path->depth - 1];
1890 sel = path->depth > 1 ? path->path[1] : 0;
1892 if (dac && check_amp_caps(codec, dac, HDA_OUTPUT, AC_AMPCAP_NUM_STEPS))
1894 else if (check_amp_caps(codec, pin, HDA_OUTPUT, AC_AMPCAP_NUM_STEPS))
1896 else if (check_amp_caps(codec, sel, HDA_OUTPUT, AC_AMPCAP_NUM_STEPS))
1901 sprintf(name, "%s Playback Volume", pfx);
1902 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
1903 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
1906 path->vol_ctl = nid;
1909 if (dac && check_amp_caps(codec, dac, HDA_OUTPUT, AC_AMPCAP_MUTE))
1911 else if (check_amp_caps(codec, pin, HDA_OUTPUT, AC_AMPCAP_MUTE))
1913 else if (check_amp_caps(codec, sel, HDA_OUTPUT, AC_AMPCAP_MUTE))
1918 sprintf(name, "%s Playback Switch", pfx);
1919 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
1920 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
1923 path->mute_ctl = nid;
1928 static void mangle_smart51(struct hda_codec *codec)
1930 struct via_spec *spec = codec->spec;
1931 struct auto_pin_cfg *cfg = &spec->autocfg;
1932 struct auto_pin_cfg_item *ins = cfg->inputs;
1933 int i, j, nums, attr;
1934 int pins[AUTO_CFG_MAX_INS];
1936 for (attr = INPUT_PIN_ATTR_REAR; attr >= INPUT_PIN_ATTR_NORMAL; attr--) {
1938 for (i = 0; i < cfg->num_inputs; i++) {
1940 if (ins[i].type > AUTO_PIN_LINE_IN)
1942 def = snd_hda_codec_get_pincfg(codec, ins[i].pin);
1943 if (snd_hda_get_input_pin_attr(def) != attr)
1945 for (j = 0; j < nums; j++)
1946 if (ins[pins[j]].type < ins[i].type) {
1947 memmove(pins + j + 1, pins + j,
1948 (nums - j) * sizeof(int));
1954 if (cfg->line_outs + nums < 3)
1956 for (i = 0; i < nums; i++) {
1957 hda_nid_t pin = ins[pins[i]].pin;
1958 spec->smart51_pins[spec->smart51_nums++] = pin;
1959 cfg->line_out_pins[cfg->line_outs++] = pin;
1960 if (cfg->line_outs == 3)
1967 static void copy_path_mixer_ctls(struct nid_path *dst, struct nid_path *src)
1969 dst->vol_ctl = src->vol_ctl;
1970 dst->mute_ctl = src->mute_ctl;
1973 /* add playback controls from the parsed DAC table */
1974 static int via_auto_create_multi_out_ctls(struct hda_codec *codec)
1976 struct via_spec *spec = codec->spec;
1977 struct auto_pin_cfg *cfg = &spec->autocfg;
1978 struct nid_path *path;
1979 static const char * const chname[4] = {
1980 "Front", "Surround", "C/LFE", "Side"
1986 old_line_outs = cfg->line_outs;
1987 if (cfg->line_outs == 1)
1988 mangle_smart51(codec);
1990 err = via_auto_fill_dac_nids(codec);
1994 if (spec->multiout.num_dacs < 3) {
1995 spec->smart51_nums = 0;
1996 cfg->line_outs = old_line_outs;
1998 for (i = 0; i < cfg->line_outs; i++) {
2000 pin = cfg->line_out_pins[i];
2001 dac = spec->multiout.dac_nids[i];
2004 path = spec->out_path + i;
2005 if (i == HDA_CLFE) {
2006 err = create_ch_ctls(codec, "Center", 1, true, path);
2009 err = create_ch_ctls(codec, "LFE", 2, true, path);
2013 const char *pfx = chname[i];
2014 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT &&
2015 cfg->line_outs == 1)
2017 err = create_ch_ctls(codec, pfx, 3, true, path);
2021 if (path != spec->out_path + i)
2022 copy_path_mixer_ctls(&spec->out_path[i], path);
2023 if (path == spec->out_path && spec->out_mix_path.depth)
2024 copy_path_mixer_ctls(&spec->out_mix_path, path);
2027 idx = get_connection_index(codec, spec->aa_mix_nid,
2028 spec->multiout.dac_nids[0]);
2030 /* add control to mixer */
2032 name = spec->out_mix_path.depth ?
2033 "PCM Loopback Playback Volume" : "PCM Playback Volume";
2034 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
2035 HDA_COMPOSE_AMP_VAL(spec->aa_mix_nid, 3,
2039 name = spec->out_mix_path.depth ?
2040 "PCM Loopback Playback Switch" : "PCM Playback Switch";
2041 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
2042 HDA_COMPOSE_AMP_VAL(spec->aa_mix_nid, 3,
2048 cfg->line_outs = old_line_outs;
2053 static int via_auto_create_hp_ctls(struct hda_codec *codec, hda_nid_t pin)
2055 struct via_spec *spec = codec->spec;
2056 struct nid_path *path;
2063 if (!parse_output_path(codec, pin, 0, 0, &spec->hp_indep_path)) {
2064 for (i = HDA_SIDE; i >= HDA_CLFE; i--) {
2065 if (i < spec->multiout.num_dacs &&
2066 parse_output_path(codec, pin,
2067 spec->multiout.dac_nids[i], 0,
2068 &spec->hp_indep_path)) {
2069 spec->hp_indep_shared = i;
2074 if (spec->hp_indep_path.depth) {
2075 spec->hp_dac_nid = spec->hp_indep_path.path[0];
2076 if (!spec->hp_indep_shared)
2077 spec->hp_path = spec->hp_indep_path;
2079 /* optionally check front-path w/o AA-mix */
2080 if (!spec->hp_path.depth)
2081 parse_output_path(codec, pin,
2082 spec->multiout.dac_nids[HDA_FRONT], 0,
2085 if (!parse_output_path(codec, pin, spec->multiout.dac_nids[HDA_FRONT],
2086 1, &spec->hp_mix_path) && !spec->hp_path.depth)
2089 if (spec->hp_path.depth) {
2090 path = &spec->hp_path;
2093 path = &spec->hp_mix_path;
2096 err = create_ch_ctls(codec, "Headphone", 3, check_dac, path);
2100 copy_path_mixer_ctls(&spec->hp_mix_path, path);
2102 copy_path_mixer_ctls(&spec->hp_path, path);
2103 if (spec->hp_indep_path.depth)
2104 copy_path_mixer_ctls(&spec->hp_indep_path, path);
2108 static int via_auto_create_speaker_ctls(struct hda_codec *codec)
2110 struct via_spec *spec = codec->spec;
2111 struct nid_path *path;
2113 hda_nid_t pin, dac = 0;
2116 pin = spec->autocfg.speaker_pins[0];
2117 if (!spec->autocfg.speaker_outs || !pin)
2120 if (parse_output_path(codec, pin, 0, 0, &spec->speaker_path))
2121 dac = spec->speaker_path.path[0];
2123 parse_output_path(codec, pin,
2124 spec->multiout.dac_nids[HDA_FRONT], 0,
2125 &spec->speaker_path);
2126 if (!parse_output_path(codec, pin, spec->multiout.dac_nids[HDA_FRONT],
2127 1, &spec->speaker_mix_path) && !dac)
2130 /* no AA-path for front? */
2131 if (!spec->out_mix_path.depth && spec->speaker_mix_path.depth)
2134 spec->speaker_dac_nid = dac;
2135 spec->multiout.extra_out_nid[0] = dac;
2137 path = &spec->speaker_path;
2140 path = &spec->speaker_mix_path;
2143 err = create_ch_ctls(codec, "Speaker", 3, check_dac, path);
2147 copy_path_mixer_ctls(&spec->speaker_mix_path, path);
2149 copy_path_mixer_ctls(&spec->speaker_path, path);
2153 #define via_aamix_ctl_info via_pin_power_ctl_info
2155 static int via_aamix_ctl_get(struct snd_kcontrol *kcontrol,
2156 struct snd_ctl_elem_value *ucontrol)
2158 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2159 struct via_spec *spec = codec->spec;
2160 ucontrol->value.enumerated.item[0] = spec->aamix_mode;
2164 static void update_aamix_paths(struct hda_codec *codec, int do_mix,
2165 struct nid_path *nomix, struct nid_path *mix)
2168 activate_output_path(codec, nomix, false, false);
2169 activate_output_path(codec, mix, true, false);
2171 activate_output_path(codec, mix, false, false);
2172 activate_output_path(codec, nomix, true, false);
2176 static int via_aamix_ctl_put(struct snd_kcontrol *kcontrol,
2177 struct snd_ctl_elem_value *ucontrol)
2179 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2180 struct via_spec *spec = codec->spec;
2181 unsigned int val = ucontrol->value.enumerated.item[0];
2183 if (val == spec->aamix_mode)
2185 spec->aamix_mode = val;
2186 /* update front path */
2187 update_aamix_paths(codec, val, &spec->out_path[0], &spec->out_mix_path);
2188 /* update HP path */
2189 if (!spec->hp_independent_mode) {
2190 update_aamix_paths(codec, val, &spec->hp_path,
2191 &spec->hp_mix_path);
2193 /* update speaker path */
2194 update_aamix_paths(codec, val, &spec->speaker_path,
2195 &spec->speaker_mix_path);
2199 static const struct snd_kcontrol_new via_aamix_ctl_enum = {
2200 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2201 .name = "Loopback Mixing",
2202 .info = via_aamix_ctl_info,
2203 .get = via_aamix_ctl_get,
2204 .put = via_aamix_ctl_put,
2207 static int via_auto_create_loopback_switch(struct hda_codec *codec)
2209 struct via_spec *spec = codec->spec;
2211 if (!spec->aa_mix_nid || !spec->out_mix_path.depth)
2212 return 0; /* no loopback switching available */
2213 if (!via_clone_control(spec, &via_aamix_ctl_enum))
2219 static int via_fill_adcs(struct hda_codec *codec)
2221 struct via_spec *spec = codec->spec;
2222 hda_nid_t nid = codec->start_nid;
2225 for (i = 0; i < codec->num_nodes; i++, nid++) {
2226 unsigned int wcaps = get_wcaps(codec, nid);
2227 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
2229 if (wcaps & AC_WCAP_DIGITAL)
2231 if (!(wcaps & AC_WCAP_CONN_LIST))
2233 if (spec->num_adc_nids >= ARRAY_SIZE(spec->adc_nids))
2235 spec->adc_nids[spec->num_adc_nids++] = nid;
2240 /* input-src control */
2241 static int via_mux_enum_info(struct snd_kcontrol *kcontrol,
2242 struct snd_ctl_elem_info *uinfo)
2244 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2245 struct via_spec *spec = codec->spec;
2247 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2249 uinfo->value.enumerated.items = spec->num_inputs;
2250 if (uinfo->value.enumerated.item >= spec->num_inputs)
2251 uinfo->value.enumerated.item = spec->num_inputs - 1;
2252 strcpy(uinfo->value.enumerated.name,
2253 spec->inputs[uinfo->value.enumerated.item].label);
2257 static int via_mux_enum_get(struct snd_kcontrol *kcontrol,
2258 struct snd_ctl_elem_value *ucontrol)
2260 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2261 struct via_spec *spec = codec->spec;
2262 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
2264 ucontrol->value.enumerated.item[0] = spec->cur_mux[idx];
2268 static int via_mux_enum_put(struct snd_kcontrol *kcontrol,
2269 struct snd_ctl_elem_value *ucontrol)
2271 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2272 struct via_spec *spec = codec->spec;
2273 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
2277 cur = ucontrol->value.enumerated.item[0];
2278 if (cur < 0 || cur >= spec->num_inputs)
2280 if (spec->cur_mux[idx] == cur)
2282 spec->cur_mux[idx] = cur;
2283 if (spec->dyn_adc_switch) {
2284 int adc_idx = spec->inputs[cur].adc_idx;
2285 mux = spec->mux_nids[adc_idx];
2286 via_dyn_adc_pcm_resetup(codec, cur);
2288 mux = spec->mux_nids[idx];
2289 if (snd_BUG_ON(!mux))
2294 /* switch to D0 beofre change index */
2295 if (snd_hda_codec_read(codec, mux, 0,
2296 AC_VERB_GET_POWER_STATE, 0x00) != AC_PWRST_D0)
2297 snd_hda_codec_write(codec, mux, 0,
2298 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
2299 snd_hda_codec_write(codec, mux, 0,
2300 AC_VERB_SET_CONNECT_SEL,
2301 spec->inputs[cur].mux_idx);
2304 /* update jack power state */
2305 set_widgets_power_state(codec);
2309 static const struct snd_kcontrol_new via_input_src_ctl = {
2310 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2311 /* The multiple "Capture Source" controls confuse alsamixer
2312 * So call somewhat different..
2314 /* .name = "Capture Source", */
2315 .name = "Input Source",
2316 .info = via_mux_enum_info,
2317 .get = via_mux_enum_get,
2318 .put = via_mux_enum_put,
2321 static int create_input_src_ctls(struct hda_codec *codec, int count)
2323 struct via_spec *spec = codec->spec;
2324 struct snd_kcontrol_new *knew;
2326 if (spec->num_inputs <= 1 || !count)
2327 return 0; /* no need for single src */
2329 knew = via_clone_control(spec, &via_input_src_ctl);
2332 knew->count = count;
2336 /* add the powersave loopback-list entry */
2337 static void add_loopback_list(struct via_spec *spec, hda_nid_t mix, int idx)
2339 struct hda_amp_list *list;
2341 if (spec->num_loopbacks >= ARRAY_SIZE(spec->loopback_list) - 1)
2343 list = spec->loopback_list + spec->num_loopbacks;
2345 list->dir = HDA_INPUT;
2347 spec->num_loopbacks++;
2348 spec->loopback.amplist = spec->loopback_list;
2351 static bool is_reachable_nid(struct hda_codec *codec, hda_nid_t src,
2354 return snd_hda_get_conn_index(codec, src, dst, 1) >= 0;
2357 /* add the input-route to the given pin */
2358 static bool add_input_route(struct hda_codec *codec, hda_nid_t pin)
2360 struct via_spec *spec = codec->spec;
2363 spec->inputs[spec->num_inputs].adc_idx = -1;
2364 spec->inputs[spec->num_inputs].pin = pin;
2365 for (c = 0; c < spec->num_adc_nids; c++) {
2366 if (spec->mux_nids[c]) {
2367 idx = get_connection_index(codec, spec->mux_nids[c],
2371 spec->inputs[spec->num_inputs].mux_idx = idx;
2373 if (!is_reachable_nid(codec, spec->adc_nids[c], pin))
2376 spec->inputs[spec->num_inputs].adc_idx = c;
2377 /* Can primary ADC satisfy all inputs? */
2378 if (!spec->dyn_adc_switch &&
2379 spec->num_inputs > 0 && spec->inputs[0].adc_idx != c) {
2380 snd_printd(KERN_INFO
2381 "via: dynamic ADC switching enabled\n");
2382 spec->dyn_adc_switch = 1;
2389 static int get_mux_nids(struct hda_codec *codec);
2391 /* parse input-routes; fill ADCs, MUXs and input-src entries */
2392 static int parse_analog_inputs(struct hda_codec *codec)
2394 struct via_spec *spec = codec->spec;
2395 const struct auto_pin_cfg *cfg = &spec->autocfg;
2398 err = via_fill_adcs(codec);
2401 err = get_mux_nids(codec);
2405 /* fill all input-routes */
2406 for (i = 0; i < cfg->num_inputs; i++) {
2407 if (add_input_route(codec, cfg->inputs[i].pin))
2408 spec->inputs[spec->num_inputs++].label =
2409 hda_get_autocfg_input_label(codec, cfg, i);
2412 /* check for internal loopback recording */
2413 if (spec->aa_mix_nid &&
2414 add_input_route(codec, spec->aa_mix_nid))
2415 spec->inputs[spec->num_inputs++].label = "Stereo Mixer";
2420 /* create analog-loopback volume/switch controls */
2421 static int create_loopback_ctls(struct hda_codec *codec)
2423 struct via_spec *spec = codec->spec;
2424 const struct auto_pin_cfg *cfg = &spec->autocfg;
2425 const char *prev_label = NULL;
2429 if (!spec->aa_mix_nid)
2432 for (i = 0; i < cfg->num_inputs; i++) {
2433 hda_nid_t pin = cfg->inputs[i].pin;
2434 const char *label = hda_get_autocfg_input_label(codec, cfg, i);
2436 if (prev_label && !strcmp(label, prev_label))
2441 idx = get_connection_index(codec, spec->aa_mix_nid, pin);
2443 err = via_new_analog_input(spec, label, type_idx,
2444 idx, spec->aa_mix_nid);
2447 add_loopback_list(spec, spec->aa_mix_nid, idx);
2450 /* remember the label for smart51 control */
2451 for (j = 0; j < spec->smart51_nums; j++) {
2452 if (spec->smart51_pins[j] == pin) {
2453 spec->smart51_idxs[j] = idx;
2454 spec->smart51_labels[j] = label;
2462 /* create mic-boost controls (if present) */
2463 static int create_mic_boost_ctls(struct hda_codec *codec)
2465 struct via_spec *spec = codec->spec;
2466 const struct auto_pin_cfg *cfg = &spec->autocfg;
2469 for (i = 0; i < cfg->num_inputs; i++) {
2470 hda_nid_t pin = cfg->inputs[i].pin;
2475 if (cfg->inputs[i].type != AUTO_PIN_MIC)
2477 caps = query_amp_caps(codec, pin, HDA_INPUT);
2478 if (caps == -1 || !(caps & AC_AMPCAP_NUM_STEPS))
2480 label = hda_get_autocfg_input_label(codec, cfg, i);
2481 snprintf(name, sizeof(name), "%s Boost Volume", label);
2482 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
2483 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_INPUT));
2490 /* create capture and input-src controls for multiple streams */
2491 static int create_multi_adc_ctls(struct hda_codec *codec)
2493 struct via_spec *spec = codec->spec;
2496 /* create capture mixer elements */
2497 for (i = 0; i < spec->num_adc_nids; i++) {
2498 hda_nid_t adc = spec->adc_nids[i];
2499 err = __via_add_control(spec, VIA_CTL_WIDGET_VOL,
2500 "Capture Volume", i,
2501 HDA_COMPOSE_AMP_VAL(adc, 3, 0,
2505 err = __via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2506 "Capture Switch", i,
2507 HDA_COMPOSE_AMP_VAL(adc, 3, 0,
2513 /* input-source control */
2514 for (i = 0; i < spec->num_adc_nids; i++)
2515 if (!spec->mux_nids[i])
2517 err = create_input_src_ctls(codec, i);
2523 /* bind capture volume/switch */
2524 static struct snd_kcontrol_new via_bind_cap_vol_ctl =
2525 HDA_BIND_VOL("Capture Volume", 0);
2526 static struct snd_kcontrol_new via_bind_cap_sw_ctl =
2527 HDA_BIND_SW("Capture Switch", 0);
2529 static int init_bind_ctl(struct via_spec *spec, struct hda_bind_ctls **ctl_ret,
2530 struct hda_ctl_ops *ops)
2532 struct hda_bind_ctls *ctl;
2535 ctl = kzalloc(sizeof(*ctl) + sizeof(long) * 4, GFP_KERNEL);
2539 for (i = 0; i < spec->num_adc_nids; i++)
2541 HDA_COMPOSE_AMP_VAL(spec->adc_nids[i], 3, 0, HDA_INPUT);
2546 /* create capture and input-src controls for dynamic ADC-switch case */
2547 static int create_dyn_adc_ctls(struct hda_codec *codec)
2549 struct via_spec *spec = codec->spec;
2550 struct snd_kcontrol_new *knew;
2553 /* set up the bind capture ctls */
2554 err = init_bind_ctl(spec, &spec->bind_cap_vol, &snd_hda_bind_vol);
2557 err = init_bind_ctl(spec, &spec->bind_cap_sw, &snd_hda_bind_sw);
2561 /* create capture mixer elements */
2562 knew = via_clone_control(spec, &via_bind_cap_vol_ctl);
2565 knew->private_value = (long)spec->bind_cap_vol;
2567 knew = via_clone_control(spec, &via_bind_cap_sw_ctl);
2570 knew->private_value = (long)spec->bind_cap_sw;
2572 /* input-source control */
2573 err = create_input_src_ctls(codec, 1);
2579 /* parse and create capture-related stuff */
2580 static int via_auto_create_analog_input_ctls(struct hda_codec *codec)
2582 struct via_spec *spec = codec->spec;
2585 err = parse_analog_inputs(codec);
2588 if (spec->dyn_adc_switch)
2589 err = create_dyn_adc_ctls(codec);
2591 err = create_multi_adc_ctls(codec);
2594 err = create_loopback_ctls(codec);
2597 err = create_mic_boost_ctls(codec);
2603 static void vt1708_set_pinconfig_connect(struct hda_codec *codec, hda_nid_t nid)
2605 unsigned int def_conf;
2606 unsigned char seqassoc;
2608 def_conf = snd_hda_codec_get_pincfg(codec, nid);
2609 seqassoc = (unsigned char) get_defcfg_association(def_conf);
2610 seqassoc = (seqassoc << 4) | get_defcfg_sequence(def_conf);
2611 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE
2612 && (seqassoc == 0xf0 || seqassoc == 0xff)) {
2613 def_conf = def_conf & (~(AC_JACK_PORT_BOTH << 30));
2614 snd_hda_codec_set_pincfg(codec, nid, def_conf);
2620 static int vt1708_jack_detect_get(struct snd_kcontrol *kcontrol,
2621 struct snd_ctl_elem_value *ucontrol)
2623 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2624 struct via_spec *spec = codec->spec;
2626 if (spec->codec_type != VT1708)
2628 ucontrol->value.integer.value[0] = spec->vt1708_jack_detect;
2632 static int vt1708_jack_detect_put(struct snd_kcontrol *kcontrol,
2633 struct snd_ctl_elem_value *ucontrol)
2635 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2636 struct via_spec *spec = codec->spec;
2639 if (spec->codec_type != VT1708)
2641 val = !!ucontrol->value.integer.value[0];
2642 if (spec->vt1708_jack_detect == val)
2644 spec->vt1708_jack_detect = val;
2645 if (spec->vt1708_jack_detect &&
2646 snd_hda_get_bool_hint(codec, "analog_loopback_hp_detect") != 1) {
2647 mute_aa_path(codec, 1);
2648 notify_aa_path_ctls(codec);
2650 via_hp_automute(codec);
2651 vt1708_update_hp_work(spec);
2655 static const struct snd_kcontrol_new vt1708_jack_detect_ctl = {
2656 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2657 .name = "Jack Detect",
2659 .info = snd_ctl_boolean_mono_info,
2660 .get = vt1708_jack_detect_get,
2661 .put = vt1708_jack_detect_put,
2664 static void fill_dig_outs(struct hda_codec *codec);
2665 static void fill_dig_in(struct hda_codec *codec);
2667 static int via_parse_auto_config(struct hda_codec *codec)
2669 struct via_spec *spec = codec->spec;
2672 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
2675 if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
2678 err = via_auto_create_multi_out_ctls(codec);
2681 err = via_auto_create_hp_ctls(codec, spec->autocfg.hp_pins[0]);
2684 err = via_auto_create_speaker_ctls(codec);
2687 err = via_auto_create_loopback_switch(codec);
2690 err = via_auto_create_analog_input_ctls(codec);
2694 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
2696 fill_dig_outs(codec);
2699 if (spec->kctls.list)
2700 spec->mixers[spec->num_mixers++] = spec->kctls.list;
2703 if (spec->hp_dac_nid && spec->hp_mix_path.depth) {
2704 err = via_hp_build(codec);
2709 err = via_smart51_build(codec);
2713 /* assign slave outs */
2714 if (spec->slave_dig_outs[0])
2715 codec->slave_dig_outs = spec->slave_dig_outs;
2720 static void via_auto_init_dig_outs(struct hda_codec *codec)
2722 struct via_spec *spec = codec->spec;
2723 if (spec->multiout.dig_out_nid)
2724 init_output_pin(codec, spec->autocfg.dig_out_pins[0], PIN_OUT);
2725 if (spec->slave_dig_outs[0])
2726 init_output_pin(codec, spec->autocfg.dig_out_pins[1], PIN_OUT);
2729 static void via_auto_init_dig_in(struct hda_codec *codec)
2731 struct via_spec *spec = codec->spec;
2732 if (!spec->dig_in_nid)
2734 snd_hda_codec_write(codec, spec->autocfg.dig_in_pin, 0,
2735 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN);
2738 /* initialize the unsolicited events */
2739 static void via_auto_init_unsol_event(struct hda_codec *codec)
2741 struct via_spec *spec = codec->spec;
2742 struct auto_pin_cfg *cfg = &spec->autocfg;
2746 if (cfg->hp_pins[0] && is_jack_detectable(codec, cfg->hp_pins[0]))
2747 snd_hda_jack_detect_enable(codec, cfg->hp_pins[0],
2748 VIA_HP_EVENT | VIA_JACK_EVENT);
2750 if (cfg->speaker_pins[0])
2751 ev = VIA_LINE_EVENT;
2754 for (i = 0; i < cfg->line_outs; i++) {
2755 if (cfg->line_out_pins[i] &&
2756 is_jack_detectable(codec, cfg->line_out_pins[i]))
2757 snd_hda_jack_detect_enable(codec, cfg->line_out_pins[i],
2758 ev | VIA_JACK_EVENT);
2761 for (i = 0; i < cfg->num_inputs; i++) {
2762 if (is_jack_detectable(codec, cfg->inputs[i].pin))
2763 snd_hda_jack_detect_enable(codec, cfg->inputs[i].pin,
2768 static int via_init(struct hda_codec *codec)
2770 struct via_spec *spec = codec->spec;
2773 for (i = 0; i < spec->num_iverbs; i++)
2774 snd_hda_sequence_write(codec, spec->init_verbs[i]);
2776 via_auto_init_multi_out(codec);
2777 via_auto_init_hp_out(codec);
2778 via_auto_init_speaker_out(codec);
2779 via_auto_init_analog_input(codec);
2780 via_auto_init_dig_outs(codec);
2781 via_auto_init_dig_in(codec);
2783 via_auto_init_unsol_event(codec);
2785 via_hp_automute(codec);
2786 vt1708_update_hp_work(spec);
2787 snd_hda_jack_report_sync(codec);
2792 static void vt1708_update_hp_jack_state(struct work_struct *work)
2794 struct via_spec *spec = container_of(work, struct via_spec,
2795 vt1708_hp_work.work);
2796 if (spec->codec_type != VT1708)
2798 snd_hda_jack_set_dirty_all(spec->codec);
2799 /* if jack state toggled */
2800 if (spec->vt1708_hp_present
2801 != snd_hda_jack_detect(spec->codec, spec->autocfg.hp_pins[0])) {
2802 spec->vt1708_hp_present ^= 1;
2803 via_hp_automute(spec->codec);
2805 if (spec->vt1708_jack_detect)
2806 schedule_delayed_work(&spec->vt1708_hp_work,
2807 msecs_to_jiffies(100));
2810 static int get_mux_nids(struct hda_codec *codec)
2812 struct via_spec *spec = codec->spec;
2813 hda_nid_t nid, conn[8];
2817 for (i = 0; i < spec->num_adc_nids; i++) {
2818 nid = spec->adc_nids[i];
2820 type = get_wcaps_type(get_wcaps(codec, nid));
2821 if (type == AC_WID_PIN)
2823 n = snd_hda_get_connections(codec, nid, conn,
2828 spec->mux_nids[i] = nid;
2837 static int patch_vt1708(struct hda_codec *codec)
2839 struct via_spec *spec;
2842 /* create a codec specific record */
2843 spec = via_new_spec(codec);
2847 spec->aa_mix_nid = 0x17;
2849 /* Add HP and CD pin config connect bit re-config action */
2850 vt1708_set_pinconfig_connect(codec, VT1708_HP_PIN_NID);
2851 vt1708_set_pinconfig_connect(codec, VT1708_CD_PIN_NID);
2853 /* automatic parse from the BIOS config */
2854 err = via_parse_auto_config(codec);
2860 /* add jack detect on/off control */
2861 if (!via_clone_control(spec, &vt1708_jack_detect_ctl))
2864 /* disable 32bit format on VT1708 */
2865 if (codec->vendor_id == 0x11061708)
2866 spec->stream_analog_playback = &vt1708_pcm_analog_s16_playback;
2868 spec->init_verbs[spec->num_iverbs++] = vt1708_init_verbs;
2870 codec->patch_ops = via_patch_ops;
2872 INIT_DELAYED_WORK(&spec->vt1708_hp_work, vt1708_update_hp_jack_state);
2876 static int patch_vt1709(struct hda_codec *codec)
2878 struct via_spec *spec;
2881 /* create a codec specific record */
2882 spec = via_new_spec(codec);
2886 spec->aa_mix_nid = 0x18;
2888 err = via_parse_auto_config(codec);
2894 codec->patch_ops = via_patch_ops;
2899 static void set_widgets_power_state_vt1708B(struct hda_codec *codec)
2901 struct via_spec *spec = codec->spec;
2905 if ((spec->codec_type != VT1708B_4CH) &&
2906 (codec->vendor_id != 0x11064397))
2909 /* SW0 (17h) = stereo mixer */
2911 (snd_hda_codec_read(codec, 0x17, 0, AC_VERB_GET_CONNECT_SEL, 0x00)
2912 == ((spec->codec_type == VT1708S) ? 5 : 0));
2914 /* PW 1/2/5 (1ah/1bh/1eh) */
2916 set_pin_power_state(codec, 0x1a, &parm);
2917 set_pin_power_state(codec, 0x1b, &parm);
2918 set_pin_power_state(codec, 0x1e, &parm);
2921 /* SW0 (17h), AIW 0/1 (13h/14h) */
2922 snd_hda_codec_write(codec, 0x17, 0, AC_VERB_SET_POWER_STATE, parm);
2923 snd_hda_codec_write(codec, 0x13, 0, AC_VERB_SET_POWER_STATE, parm);
2924 snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_POWER_STATE, parm);
2927 /* PW0 (19h), SW1 (18h), AOW1 (11h) */
2929 set_pin_power_state(codec, 0x19, &parm);
2930 if (spec->smart51_enabled)
2931 set_pin_power_state(codec, 0x1b, &parm);
2932 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_POWER_STATE, parm);
2933 snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, parm);
2935 /* PW6 (22h), SW2 (26h), AOW2 (24h) */
2938 set_pin_power_state(codec, 0x22, &parm);
2939 if (spec->smart51_enabled)
2940 set_pin_power_state(codec, 0x1a, &parm);
2941 snd_hda_codec_write(codec, 0x26, 0,
2942 AC_VERB_SET_POWER_STATE, parm);
2943 snd_hda_codec_write(codec, 0x24, 0,
2944 AC_VERB_SET_POWER_STATE, parm);
2945 } else if (codec->vendor_id == 0x11064397) {
2946 /* PW7(23h), SW2(27h), AOW2(25h) */
2948 set_pin_power_state(codec, 0x23, &parm);
2949 if (spec->smart51_enabled)
2950 set_pin_power_state(codec, 0x1a, &parm);
2951 snd_hda_codec_write(codec, 0x27, 0,
2952 AC_VERB_SET_POWER_STATE, parm);
2953 snd_hda_codec_write(codec, 0x25, 0,
2954 AC_VERB_SET_POWER_STATE, parm);
2957 /* PW 3/4/7 (1ch/1dh/23h) */
2959 /* force to D0 for internal Speaker */
2960 set_pin_power_state(codec, 0x1c, &parm);
2961 set_pin_power_state(codec, 0x1d, &parm);
2963 set_pin_power_state(codec, 0x23, &parm);
2965 /* MW0 (16h), Sw3 (27h), AOW 0/3 (10h/25h) */
2966 snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_POWER_STATE,
2967 imux_is_smixer ? AC_PWRST_D0 : parm);
2968 snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, parm);
2970 snd_hda_codec_write(codec, 0x25, 0,
2971 AC_VERB_SET_POWER_STATE, parm);
2972 snd_hda_codec_write(codec, 0x27, 0,
2973 AC_VERB_SET_POWER_STATE, parm);
2974 } else if (codec->vendor_id == 0x11064397 && spec->hp_independent_mode)
2975 snd_hda_codec_write(codec, 0x25, 0,
2976 AC_VERB_SET_POWER_STATE, parm);
2979 static int patch_vt1708S(struct hda_codec *codec);
2980 static int patch_vt1708B(struct hda_codec *codec)
2982 struct via_spec *spec;
2985 if (get_codec_type(codec) == VT1708BCE)
2986 return patch_vt1708S(codec);
2988 /* create a codec specific record */
2989 spec = via_new_spec(codec);
2993 spec->aa_mix_nid = 0x16;
2995 /* automatic parse from the BIOS config */
2996 err = via_parse_auto_config(codec);
3002 codec->patch_ops = via_patch_ops;
3004 spec->set_widgets_power_state = set_widgets_power_state_vt1708B;
3009 /* Patch for VT1708S */
3010 static const struct hda_verb vt1708S_init_verbs[] = {
3011 /* Enable Mic Boost Volume backdoor */
3013 /* don't bybass mixer */
3018 /* fill out digital output widgets; one for master and one for slave outputs */
3019 static void fill_dig_outs(struct hda_codec *codec)
3021 struct via_spec *spec = codec->spec;
3024 for (i = 0; i < spec->autocfg.dig_outs; i++) {
3028 nid = spec->autocfg.dig_out_pins[i];
3031 conn = snd_hda_get_connections(codec, nid, &nid, 1);
3034 if (!spec->multiout.dig_out_nid)
3035 spec->multiout.dig_out_nid = nid;
3037 spec->slave_dig_outs[0] = nid;
3038 break; /* at most two dig outs */
3043 static void fill_dig_in(struct hda_codec *codec)
3045 struct via_spec *spec = codec->spec;
3049 if (!spec->autocfg.dig_in_pin)
3052 dig_nid = codec->start_nid;
3053 for (i = 0; i < codec->num_nodes; i++, dig_nid++) {
3054 unsigned int wcaps = get_wcaps(codec, dig_nid);
3055 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
3057 if (!(wcaps & AC_WCAP_DIGITAL))
3059 if (!(wcaps & AC_WCAP_CONN_LIST))
3061 err = get_connection_index(codec, dig_nid,
3062 spec->autocfg.dig_in_pin);
3064 spec->dig_in_nid = dig_nid;
3070 static void override_mic_boost(struct hda_codec *codec, hda_nid_t pin,
3071 int offset, int num_steps, int step_size)
3073 snd_hda_override_amp_caps(codec, pin, HDA_INPUT,
3074 (offset << AC_AMPCAP_OFFSET_SHIFT) |
3075 (num_steps << AC_AMPCAP_NUM_STEPS_SHIFT) |
3076 (step_size << AC_AMPCAP_STEP_SIZE_SHIFT) |
3077 (0 << AC_AMPCAP_MUTE_SHIFT));
3080 static int patch_vt1708S(struct hda_codec *codec)
3082 struct via_spec *spec;
3085 /* create a codec specific record */
3086 spec = via_new_spec(codec);
3090 spec->aa_mix_nid = 0x16;
3091 override_mic_boost(codec, 0x1a, 0, 3, 40);
3092 override_mic_boost(codec, 0x1e, 0, 3, 40);
3094 /* automatic parse from the BIOS config */
3095 err = via_parse_auto_config(codec);
3101 spec->init_verbs[spec->num_iverbs++] = vt1708S_init_verbs;
3103 codec->patch_ops = via_patch_ops;
3105 /* correct names for VT1708BCE */
3106 if (get_codec_type(codec) == VT1708BCE) {
3107 kfree(codec->chip_name);
3108 codec->chip_name = kstrdup("VT1708BCE", GFP_KERNEL);
3109 snprintf(codec->bus->card->mixername,
3110 sizeof(codec->bus->card->mixername),
3111 "%s %s", codec->vendor_name, codec->chip_name);
3113 /* correct names for VT1705 */
3114 if (codec->vendor_id == 0x11064397) {
3115 kfree(codec->chip_name);
3116 codec->chip_name = kstrdup("VT1705", GFP_KERNEL);
3117 snprintf(codec->bus->card->mixername,
3118 sizeof(codec->bus->card->mixername),
3119 "%s %s", codec->vendor_name, codec->chip_name);
3121 spec->set_widgets_power_state = set_widgets_power_state_vt1708B;
3125 /* Patch for VT1702 */
3127 static const struct hda_verb vt1702_init_verbs[] = {
3135 static void set_widgets_power_state_vt1702(struct hda_codec *codec)
3137 int imux_is_smixer =
3138 snd_hda_codec_read(codec, 0x13, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 3;
3141 /* PW 1/2/5 (14h/15h/18h) */
3143 set_pin_power_state(codec, 0x14, &parm);
3144 set_pin_power_state(codec, 0x15, &parm);
3145 set_pin_power_state(codec, 0x18, &parm);
3147 parm = AC_PWRST_D0; /* SW0 (13h) = stereo mixer (idx 3) */
3148 /* SW0 (13h), AIW 0/1/2 (12h/1fh/20h) */
3149 snd_hda_codec_write(codec, 0x13, 0, AC_VERB_SET_POWER_STATE, parm);
3150 snd_hda_codec_write(codec, 0x12, 0, AC_VERB_SET_POWER_STATE, parm);
3151 snd_hda_codec_write(codec, 0x1f, 0, AC_VERB_SET_POWER_STATE, parm);
3152 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_POWER_STATE, parm);
3155 /* PW 3/4 (16h/17h) */
3157 set_pin_power_state(codec, 0x17, &parm);
3158 set_pin_power_state(codec, 0x16, &parm);
3159 /* MW0 (1ah), AOW 0/1 (10h/1dh) */
3160 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_POWER_STATE,
3161 imux_is_smixer ? AC_PWRST_D0 : parm);
3162 snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, parm);
3163 snd_hda_codec_write(codec, 0x1d, 0, AC_VERB_SET_POWER_STATE, parm);
3166 static int patch_vt1702(struct hda_codec *codec)
3168 struct via_spec *spec;
3171 /* create a codec specific record */
3172 spec = via_new_spec(codec);
3176 spec->aa_mix_nid = 0x1a;
3178 /* limit AA path volume to 0 dB */
3179 snd_hda_override_amp_caps(codec, 0x1A, HDA_INPUT,
3180 (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
3181 (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
3182 (0x5 << AC_AMPCAP_STEP_SIZE_SHIFT) |
3183 (1 << AC_AMPCAP_MUTE_SHIFT));
3185 /* automatic parse from the BIOS config */
3186 err = via_parse_auto_config(codec);
3192 spec->init_verbs[spec->num_iverbs++] = vt1702_init_verbs;
3194 codec->patch_ops = via_patch_ops;
3196 spec->set_widgets_power_state = set_widgets_power_state_vt1702;
3200 /* Patch for VT1718S */
3202 static const struct hda_verb vt1718S_init_verbs[] = {
3203 /* Enable MW0 adjust Gain 5 */
3205 /* Enable Boost Volume backdoor */
3211 static void set_widgets_power_state_vt1718S(struct hda_codec *codec)
3213 struct via_spec *spec = codec->spec;
3216 /* MUX6 (1eh) = stereo mixer */
3218 snd_hda_codec_read(codec, 0x1e, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 5;
3220 /* PW 5/6/7 (29h/2ah/2bh) */
3222 set_pin_power_state(codec, 0x29, &parm);
3223 set_pin_power_state(codec, 0x2a, &parm);
3224 set_pin_power_state(codec, 0x2b, &parm);
3227 /* MUX6/7 (1eh/1fh), AIW 0/1 (10h/11h) */
3228 snd_hda_codec_write(codec, 0x1e, 0, AC_VERB_SET_POWER_STATE, parm);
3229 snd_hda_codec_write(codec, 0x1f, 0, AC_VERB_SET_POWER_STATE, parm);
3230 snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, parm);
3231 snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, parm);
3234 /* PW3 (27h), MW2 (1ah), AOW3 (bh) */
3236 set_pin_power_state(codec, 0x27, &parm);
3237 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_POWER_STATE, parm);
3238 snd_hda_codec_write(codec, 0xb, 0, AC_VERB_SET_POWER_STATE, parm);
3240 /* PW2 (26h), AOW2 (ah) */
3242 set_pin_power_state(codec, 0x26, &parm);
3243 if (spec->smart51_enabled)
3244 set_pin_power_state(codec, 0x2b, &parm);
3245 snd_hda_codec_write(codec, 0xa, 0, AC_VERB_SET_POWER_STATE, parm);
3247 /* PW0 (24h), AOW0 (8h) */
3249 set_pin_power_state(codec, 0x24, &parm);
3250 if (!spec->hp_independent_mode) /* check for redirected HP */
3251 set_pin_power_state(codec, 0x28, &parm);
3252 snd_hda_codec_write(codec, 0x8, 0, AC_VERB_SET_POWER_STATE, parm);
3253 /* MW9 (21h), Mw2 (1ah), AOW0 (8h) */
3254 snd_hda_codec_write(codec, 0x21, 0, AC_VERB_SET_POWER_STATE,
3255 imux_is_smixer ? AC_PWRST_D0 : parm);
3257 /* PW1 (25h), AOW1 (9h) */
3259 set_pin_power_state(codec, 0x25, &parm);
3260 if (spec->smart51_enabled)
3261 set_pin_power_state(codec, 0x2a, &parm);
3262 snd_hda_codec_write(codec, 0x9, 0, AC_VERB_SET_POWER_STATE, parm);
3264 if (spec->hp_independent_mode) {
3265 /* PW4 (28h), MW3 (1bh), MUX1(34h), AOW4 (ch) */
3267 set_pin_power_state(codec, 0x28, &parm);
3268 snd_hda_codec_write(codec, 0x1b, 0,
3269 AC_VERB_SET_POWER_STATE, parm);
3270 snd_hda_codec_write(codec, 0x34, 0,
3271 AC_VERB_SET_POWER_STATE, parm);
3272 snd_hda_codec_write(codec, 0xc, 0,
3273 AC_VERB_SET_POWER_STATE, parm);
3277 /* Add a connection to the primary DAC from AA-mixer for some codecs
3278 * This isn't listed from the raw info, but the chip has a secret connection.
3280 static int add_secret_dac_path(struct hda_codec *codec)
3282 struct via_spec *spec = codec->spec;
3287 if (!spec->aa_mix_nid)
3289 nums = snd_hda_get_connections(codec, spec->aa_mix_nid, conn,
3290 ARRAY_SIZE(conn) - 1);
3291 for (i = 0; i < nums; i++) {
3292 if (get_wcaps_type(get_wcaps(codec, conn[i])) == AC_WID_AUD_OUT)
3296 /* find the primary DAC and add to the connection list */
3297 nid = codec->start_nid;
3298 for (i = 0; i < codec->num_nodes; i++, nid++) {
3299 unsigned int caps = get_wcaps(codec, nid);
3300 if (get_wcaps_type(caps) == AC_WID_AUD_OUT &&
3301 !(caps & AC_WCAP_DIGITAL)) {
3303 return snd_hda_override_conn_list(codec,
3312 static int patch_vt1718S(struct hda_codec *codec)
3314 struct via_spec *spec;
3317 /* create a codec specific record */
3318 spec = via_new_spec(codec);
3322 spec->aa_mix_nid = 0x21;
3323 override_mic_boost(codec, 0x2b, 0, 3, 40);
3324 override_mic_boost(codec, 0x29, 0, 3, 40);
3325 add_secret_dac_path(codec);
3327 /* automatic parse from the BIOS config */
3328 err = via_parse_auto_config(codec);
3334 spec->init_verbs[spec->num_iverbs++] = vt1718S_init_verbs;
3336 codec->patch_ops = via_patch_ops;
3338 spec->set_widgets_power_state = set_widgets_power_state_vt1718S;
3343 /* Patch for VT1716S */
3345 static int vt1716s_dmic_info(struct snd_kcontrol *kcontrol,
3346 struct snd_ctl_elem_info *uinfo)
3348 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
3350 uinfo->value.integer.min = 0;
3351 uinfo->value.integer.max = 1;
3355 static int vt1716s_dmic_get(struct snd_kcontrol *kcontrol,
3356 struct snd_ctl_elem_value *ucontrol)
3358 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3361 index = snd_hda_codec_read(codec, 0x26, 0,
3362 AC_VERB_GET_CONNECT_SEL, 0);
3364 *ucontrol->value.integer.value = index;
3369 static int vt1716s_dmic_put(struct snd_kcontrol *kcontrol,
3370 struct snd_ctl_elem_value *ucontrol)
3372 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3373 struct via_spec *spec = codec->spec;
3374 int index = *ucontrol->value.integer.value;
3376 snd_hda_codec_write(codec, 0x26, 0,
3377 AC_VERB_SET_CONNECT_SEL, index);
3378 spec->dmic_enabled = index;
3379 set_widgets_power_state(codec);
3383 static const struct snd_kcontrol_new vt1716s_dmic_mixer[] = {
3384 HDA_CODEC_VOLUME("Digital Mic Capture Volume", 0x22, 0x0, HDA_INPUT),
3386 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3387 .name = "Digital Mic Capture Switch",
3388 .subdevice = HDA_SUBDEV_NID_FLAG | 0x26,
3390 .info = vt1716s_dmic_info,
3391 .get = vt1716s_dmic_get,
3392 .put = vt1716s_dmic_put,
3398 /* mono-out mixer elements */
3399 static const struct snd_kcontrol_new vt1716S_mono_out_mixer[] = {
3400 HDA_CODEC_MUTE("Mono Playback Switch", 0x2a, 0x0, HDA_OUTPUT),
3404 static const struct hda_verb vt1716S_init_verbs[] = {
3405 /* Enable Boost Volume backdoor */
3407 /* don't bybass mixer */
3409 /* Enable mono output */
3414 static void set_widgets_power_state_vt1716S(struct hda_codec *codec)
3416 struct via_spec *spec = codec->spec;
3419 unsigned int mono_out, present;
3420 /* SW0 (17h) = stereo mixer */
3422 (snd_hda_codec_read(codec, 0x17, 0,
3423 AC_VERB_GET_CONNECT_SEL, 0x00) == 5);
3425 /* PW 1/2/5 (1ah/1bh/1eh) */
3427 set_pin_power_state(codec, 0x1a, &parm);
3428 set_pin_power_state(codec, 0x1b, &parm);
3429 set_pin_power_state(codec, 0x1e, &parm);
3432 /* SW0 (17h), AIW0(13h) */
3433 snd_hda_codec_write(codec, 0x17, 0, AC_VERB_SET_POWER_STATE, parm);
3434 snd_hda_codec_write(codec, 0x13, 0, AC_VERB_SET_POWER_STATE, parm);
3437 set_pin_power_state(codec, 0x1e, &parm);
3439 if (spec->dmic_enabled)
3440 set_pin_power_state(codec, 0x22, &parm);
3442 snd_hda_codec_write(codec, 0x22, 0,
3443 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3445 /* SW2(26h), AIW1(14h) */
3446 snd_hda_codec_write(codec, 0x26, 0, AC_VERB_SET_POWER_STATE, parm);
3447 snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_POWER_STATE, parm);
3450 /* PW0 (19h), SW1 (18h), AOW1 (11h) */
3452 set_pin_power_state(codec, 0x19, &parm);
3453 /* Smart 5.1 PW2(1bh) */
3454 if (spec->smart51_enabled)
3455 set_pin_power_state(codec, 0x1b, &parm);
3456 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_POWER_STATE, parm);
3457 snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, parm);
3459 /* PW7 (23h), SW3 (27h), AOW3 (25h) */
3461 set_pin_power_state(codec, 0x23, &parm);
3462 /* Smart 5.1 PW1(1ah) */
3463 if (spec->smart51_enabled)
3464 set_pin_power_state(codec, 0x1a, &parm);
3465 snd_hda_codec_write(codec, 0x27, 0, AC_VERB_SET_POWER_STATE, parm);
3467 /* Smart 5.1 PW5(1eh) */
3468 if (spec->smart51_enabled)
3469 set_pin_power_state(codec, 0x1e, &parm);
3470 snd_hda_codec_write(codec, 0x25, 0, AC_VERB_SET_POWER_STATE, parm);
3473 /* SW4(28h)->MW1(29h)-> PW12 (2ah)*/
3474 present = snd_hda_jack_detect(codec, 0x1c);
3479 present = snd_hda_jack_detect(codec, 0x1d);
3480 if (!spec->hp_independent_mode && present)
3485 parm = mono_out ? AC_PWRST_D0 : AC_PWRST_D3;
3486 snd_hda_codec_write(codec, 0x28, 0, AC_VERB_SET_POWER_STATE, parm);
3487 snd_hda_codec_write(codec, 0x29, 0, AC_VERB_SET_POWER_STATE, parm);
3488 snd_hda_codec_write(codec, 0x2a, 0, AC_VERB_SET_POWER_STATE, parm);
3490 /* PW 3/4 (1ch/1dh) */
3492 set_pin_power_state(codec, 0x1c, &parm);
3493 set_pin_power_state(codec, 0x1d, &parm);
3494 /* HP Independent Mode, power on AOW3 */
3495 if (spec->hp_independent_mode)
3496 snd_hda_codec_write(codec, 0x25, 0,
3497 AC_VERB_SET_POWER_STATE, parm);
3499 /* force to D0 for internal Speaker */
3500 /* MW0 (16h), AOW0 (10h) */
3501 snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_POWER_STATE,
3502 imux_is_smixer ? AC_PWRST_D0 : parm);
3503 snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE,
3504 mono_out ? AC_PWRST_D0 : parm);
3507 static int patch_vt1716S(struct hda_codec *codec)
3509 struct via_spec *spec;
3512 /* create a codec specific record */
3513 spec = via_new_spec(codec);
3517 spec->aa_mix_nid = 0x16;
3518 override_mic_boost(codec, 0x1a, 0, 3, 40);
3519 override_mic_boost(codec, 0x1e, 0, 3, 40);
3521 /* automatic parse from the BIOS config */
3522 err = via_parse_auto_config(codec);
3528 spec->init_verbs[spec->num_iverbs++] = vt1716S_init_verbs;
3530 spec->mixers[spec->num_mixers] = vt1716s_dmic_mixer;
3533 spec->mixers[spec->num_mixers++] = vt1716S_mono_out_mixer;
3535 codec->patch_ops = via_patch_ops;
3537 spec->set_widgets_power_state = set_widgets_power_state_vt1716S;
3543 static const struct hda_verb vt2002P_init_verbs[] = {
3544 /* Class-D speaker related verbs */
3548 /* Enable Boost Volume backdoor */
3550 /* Enable AOW0 to MW9 */
3555 static const struct hda_verb vt1802_init_verbs[] = {
3556 /* Enable Boost Volume backdoor */
3558 /* Enable AOW0 to MW9 */
3563 static void set_widgets_power_state_vt2002P(struct hda_codec *codec)
3565 struct via_spec *spec = codec->spec;
3568 unsigned int present;
3569 /* MUX9 (1eh) = stereo mixer */
3571 snd_hda_codec_read(codec, 0x1e, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 3;
3573 /* PW 5/6/7 (29h/2ah/2bh) */
3575 set_pin_power_state(codec, 0x29, &parm);
3576 set_pin_power_state(codec, 0x2a, &parm);
3577 set_pin_power_state(codec, 0x2b, &parm);
3579 /* MUX9/10 (1eh/1fh), AIW 0/1 (10h/11h) */
3580 snd_hda_codec_write(codec, 0x1e, 0, AC_VERB_SET_POWER_STATE, parm);
3581 snd_hda_codec_write(codec, 0x1f, 0, AC_VERB_SET_POWER_STATE, parm);
3582 snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, parm);
3583 snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, parm);
3587 snd_hda_codec_write(codec, 0x8, 0, AC_VERB_SET_POWER_STATE, parm);
3589 if (spec->codec_type == VT1802) {
3590 /* PW4 (28h), MW4 (18h), MUX4(38h) */
3592 set_pin_power_state(codec, 0x28, &parm);
3593 snd_hda_codec_write(codec, 0x18, 0,
3594 AC_VERB_SET_POWER_STATE, parm);
3595 snd_hda_codec_write(codec, 0x38, 0,
3596 AC_VERB_SET_POWER_STATE, parm);
3598 /* PW4 (26h), MW4 (1ch), MUX4(37h) */
3600 set_pin_power_state(codec, 0x26, &parm);
3601 snd_hda_codec_write(codec, 0x1c, 0,
3602 AC_VERB_SET_POWER_STATE, parm);
3603 snd_hda_codec_write(codec, 0x37, 0,
3604 AC_VERB_SET_POWER_STATE, parm);
3607 if (spec->codec_type == VT1802) {
3608 /* PW1 (25h), MW1 (15h), MUX1(35h), AOW1 (9h) */
3610 set_pin_power_state(codec, 0x25, &parm);
3611 snd_hda_codec_write(codec, 0x15, 0,
3612 AC_VERB_SET_POWER_STATE, parm);
3613 snd_hda_codec_write(codec, 0x35, 0,
3614 AC_VERB_SET_POWER_STATE, parm);
3616 /* PW1 (25h), MW1 (19h), MUX1(35h), AOW1 (9h) */
3618 set_pin_power_state(codec, 0x25, &parm);
3619 snd_hda_codec_write(codec, 0x19, 0,
3620 AC_VERB_SET_POWER_STATE, parm);
3621 snd_hda_codec_write(codec, 0x35, 0,
3622 AC_VERB_SET_POWER_STATE, parm);
3625 if (spec->hp_independent_mode)
3626 snd_hda_codec_write(codec, 0x9, 0,
3627 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3630 /* PW0 (24h), MW0(18h/14h), MUX0(34h) */
3631 present = snd_hda_jack_detect(codec, 0x25);
3634 set_pin_power_state(codec, 0x24, &parm);
3635 parm = present ? AC_PWRST_D3 : AC_PWRST_D0;
3636 if (spec->codec_type == VT1802)
3637 snd_hda_codec_write(codec, 0x14, 0,
3638 AC_VERB_SET_POWER_STATE, parm);
3640 snd_hda_codec_write(codec, 0x18, 0,
3641 AC_VERB_SET_POWER_STATE, parm);
3642 snd_hda_codec_write(codec, 0x34, 0, AC_VERB_SET_POWER_STATE, parm);
3645 present = snd_hda_jack_detect(codec, 0x26);
3647 parm = present ? AC_PWRST_D3 : AC_PWRST_D0;
3648 if (spec->codec_type == VT1802) {
3649 /* PW15 (33h), MW8(1ch), MUX8(3ch) */
3650 snd_hda_codec_write(codec, 0x33, 0,
3651 AC_VERB_SET_POWER_STATE, parm);
3652 snd_hda_codec_write(codec, 0x1c, 0,
3653 AC_VERB_SET_POWER_STATE, parm);
3654 snd_hda_codec_write(codec, 0x3c, 0,
3655 AC_VERB_SET_POWER_STATE, parm);
3657 /* PW15 (31h), MW8(17h), MUX8(3bh) */
3658 snd_hda_codec_write(codec, 0x31, 0,
3659 AC_VERB_SET_POWER_STATE, parm);
3660 snd_hda_codec_write(codec, 0x17, 0,
3661 AC_VERB_SET_POWER_STATE, parm);
3662 snd_hda_codec_write(codec, 0x3b, 0,
3663 AC_VERB_SET_POWER_STATE, parm);
3666 if (imux_is_smixer || !is_aa_path_mute(codec))
3667 snd_hda_codec_write(codec, 0x21, 0,
3668 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3670 snd_hda_codec_write(codec, 0x21, 0,
3671 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3674 /* patch for vt2002P */
3675 static int patch_vt2002P(struct hda_codec *codec)
3677 struct via_spec *spec;
3680 /* create a codec specific record */
3681 spec = via_new_spec(codec);
3685 spec->aa_mix_nid = 0x21;
3686 override_mic_boost(codec, 0x2b, 0, 3, 40);
3687 override_mic_boost(codec, 0x29, 0, 3, 40);
3688 add_secret_dac_path(codec);
3690 /* automatic parse from the BIOS config */
3691 err = via_parse_auto_config(codec);
3697 if (spec->codec_type == VT1802)
3698 spec->init_verbs[spec->num_iverbs++] = vt1802_init_verbs;
3700 spec->init_verbs[spec->num_iverbs++] = vt2002P_init_verbs;
3702 codec->patch_ops = via_patch_ops;
3704 spec->set_widgets_power_state = set_widgets_power_state_vt2002P;
3710 static const struct hda_verb vt1812_init_verbs[] = {
3711 /* Enable Boost Volume backdoor */
3713 /* Enable AOW0 to MW9 */
3718 static void set_widgets_power_state_vt1812(struct hda_codec *codec)
3720 struct via_spec *spec = codec->spec;
3722 unsigned int present;
3724 /* PW 5/6/7 (29h/2ah/2bh) */
3726 set_pin_power_state(codec, 0x29, &parm);
3727 set_pin_power_state(codec, 0x2a, &parm);
3728 set_pin_power_state(codec, 0x2b, &parm);
3730 /* MUX10/11 (1eh/1fh), AIW 0/1 (10h/11h) */
3731 snd_hda_codec_write(codec, 0x1e, 0, AC_VERB_SET_POWER_STATE, parm);
3732 snd_hda_codec_write(codec, 0x1f, 0, AC_VERB_SET_POWER_STATE, parm);
3733 snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, parm);
3734 snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, parm);
3738 snd_hda_codec_write(codec, 0x8, 0,
3739 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3741 /* PW4 (28h), MW4 (18h), MUX4(38h) */
3743 set_pin_power_state(codec, 0x28, &parm);
3744 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_POWER_STATE, parm);
3745 snd_hda_codec_write(codec, 0x38, 0, AC_VERB_SET_POWER_STATE, parm);
3747 /* PW1 (25h), MW1 (15h), MUX1(35h), AOW1 (9h) */
3749 set_pin_power_state(codec, 0x25, &parm);
3750 snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_POWER_STATE, parm);
3751 snd_hda_codec_write(codec, 0x35, 0, AC_VERB_SET_POWER_STATE, parm);
3752 if (spec->hp_independent_mode)
3753 snd_hda_codec_write(codec, 0x9, 0,
3754 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3756 /* Internal Speaker */
3757 /* PW0 (24h), MW0(14h), MUX0(34h) */
3758 present = snd_hda_jack_detect(codec, 0x25);
3761 set_pin_power_state(codec, 0x24, &parm);
3763 snd_hda_codec_write(codec, 0x14, 0,
3764 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3765 snd_hda_codec_write(codec, 0x34, 0,
3766 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3768 snd_hda_codec_write(codec, 0x14, 0,
3769 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3770 snd_hda_codec_write(codec, 0x34, 0,
3771 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3776 /* PW13 (31h), MW13(1ch), MUX13(3ch), MW14(3eh) */
3777 present = snd_hda_jack_detect(codec, 0x28);
3780 set_pin_power_state(codec, 0x31, &parm);
3782 snd_hda_codec_write(codec, 0x1c, 0,
3783 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3784 snd_hda_codec_write(codec, 0x3c, 0,
3785 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3786 snd_hda_codec_write(codec, 0x3e, 0,
3787 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3789 snd_hda_codec_write(codec, 0x1c, 0,
3790 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3791 snd_hda_codec_write(codec, 0x3c, 0,
3792 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3793 snd_hda_codec_write(codec, 0x3e, 0,
3794 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3797 /* PW15 (33h), MW15 (1dh), MUX15(3dh) */
3799 set_pin_power_state(codec, 0x33, &parm);
3800 snd_hda_codec_write(codec, 0x1d, 0, AC_VERB_SET_POWER_STATE, parm);
3801 snd_hda_codec_write(codec, 0x3d, 0, AC_VERB_SET_POWER_STATE, parm);
3805 /* patch for vt1812 */
3806 static int patch_vt1812(struct hda_codec *codec)
3808 struct via_spec *spec;
3811 /* create a codec specific record */
3812 spec = via_new_spec(codec);
3816 spec->aa_mix_nid = 0x21;
3817 override_mic_boost(codec, 0x2b, 0, 3, 40);
3818 override_mic_boost(codec, 0x29, 0, 3, 40);
3819 add_secret_dac_path(codec);
3821 /* automatic parse from the BIOS config */
3822 err = via_parse_auto_config(codec);
3828 spec->init_verbs[spec->num_iverbs++] = vt1812_init_verbs;
3830 codec->patch_ops = via_patch_ops;
3832 spec->set_widgets_power_state = set_widgets_power_state_vt1812;
3839 static const struct hda_codec_preset snd_hda_preset_via[] = {
3840 { .id = 0x11061708, .name = "VT1708", .patch = patch_vt1708},
3841 { .id = 0x11061709, .name = "VT1708", .patch = patch_vt1708},
3842 { .id = 0x1106170a, .name = "VT1708", .patch = patch_vt1708},
3843 { .id = 0x1106170b, .name = "VT1708", .patch = patch_vt1708},
3844 { .id = 0x1106e710, .name = "VT1709 10-Ch",
3845 .patch = patch_vt1709},
3846 { .id = 0x1106e711, .name = "VT1709 10-Ch",
3847 .patch = patch_vt1709},
3848 { .id = 0x1106e712, .name = "VT1709 10-Ch",
3849 .patch = patch_vt1709},
3850 { .id = 0x1106e713, .name = "VT1709 10-Ch",
3851 .patch = patch_vt1709},
3852 { .id = 0x1106e714, .name = "VT1709 6-Ch",
3853 .patch = patch_vt1709},
3854 { .id = 0x1106e715, .name = "VT1709 6-Ch",
3855 .patch = patch_vt1709},
3856 { .id = 0x1106e716, .name = "VT1709 6-Ch",
3857 .patch = patch_vt1709},
3858 { .id = 0x1106e717, .name = "VT1709 6-Ch",
3859 .patch = patch_vt1709},
3860 { .id = 0x1106e720, .name = "VT1708B 8-Ch",
3861 .patch = patch_vt1708B},
3862 { .id = 0x1106e721, .name = "VT1708B 8-Ch",
3863 .patch = patch_vt1708B},
3864 { .id = 0x1106e722, .name = "VT1708B 8-Ch",
3865 .patch = patch_vt1708B},
3866 { .id = 0x1106e723, .name = "VT1708B 8-Ch",
3867 .patch = patch_vt1708B},
3868 { .id = 0x1106e724, .name = "VT1708B 4-Ch",
3869 .patch = patch_vt1708B},
3870 { .id = 0x1106e725, .name = "VT1708B 4-Ch",
3871 .patch = patch_vt1708B},
3872 { .id = 0x1106e726, .name = "VT1708B 4-Ch",
3873 .patch = patch_vt1708B},
3874 { .id = 0x1106e727, .name = "VT1708B 4-Ch",
3875 .patch = patch_vt1708B},
3876 { .id = 0x11060397, .name = "VT1708S",
3877 .patch = patch_vt1708S},
3878 { .id = 0x11061397, .name = "VT1708S",
3879 .patch = patch_vt1708S},
3880 { .id = 0x11062397, .name = "VT1708S",
3881 .patch = patch_vt1708S},
3882 { .id = 0x11063397, .name = "VT1708S",
3883 .patch = patch_vt1708S},
3884 { .id = 0x11064397, .name = "VT1705",
3885 .patch = patch_vt1708S},
3886 { .id = 0x11065397, .name = "VT1708S",
3887 .patch = patch_vt1708S},
3888 { .id = 0x11066397, .name = "VT1708S",
3889 .patch = patch_vt1708S},
3890 { .id = 0x11067397, .name = "VT1708S",
3891 .patch = patch_vt1708S},
3892 { .id = 0x11060398, .name = "VT1702",
3893 .patch = patch_vt1702},
3894 { .id = 0x11061398, .name = "VT1702",
3895 .patch = patch_vt1702},
3896 { .id = 0x11062398, .name = "VT1702",
3897 .patch = patch_vt1702},
3898 { .id = 0x11063398, .name = "VT1702",
3899 .patch = patch_vt1702},
3900 { .id = 0x11064398, .name = "VT1702",
3901 .patch = patch_vt1702},
3902 { .id = 0x11065398, .name = "VT1702",
3903 .patch = patch_vt1702},
3904 { .id = 0x11066398, .name = "VT1702",
3905 .patch = patch_vt1702},
3906 { .id = 0x11067398, .name = "VT1702",
3907 .patch = patch_vt1702},
3908 { .id = 0x11060428, .name = "VT1718S",
3909 .patch = patch_vt1718S},
3910 { .id = 0x11064428, .name = "VT1718S",
3911 .patch = patch_vt1718S},
3912 { .id = 0x11060441, .name = "VT2020",
3913 .patch = patch_vt1718S},
3914 { .id = 0x11064441, .name = "VT1828S",
3915 .patch = patch_vt1718S},
3916 { .id = 0x11060433, .name = "VT1716S",
3917 .patch = patch_vt1716S},
3918 { .id = 0x1106a721, .name = "VT1716S",
3919 .patch = patch_vt1716S},
3920 { .id = 0x11060438, .name = "VT2002P", .patch = patch_vt2002P},
3921 { .id = 0x11064438, .name = "VT2002P", .patch = patch_vt2002P},
3922 { .id = 0x11060448, .name = "VT1812", .patch = patch_vt1812},
3923 { .id = 0x11060440, .name = "VT1818S",
3924 .patch = patch_vt1708S},
3925 { .id = 0x11060446, .name = "VT1802",
3926 .patch = patch_vt2002P},
3927 { .id = 0x11068446, .name = "VT1802",
3928 .patch = patch_vt2002P},
3932 MODULE_ALIAS("snd-hda-codec-id:1106*");
3934 static struct hda_codec_preset_list via_list = {
3935 .preset = snd_hda_preset_via,
3936 .owner = THIS_MODULE,
3939 MODULE_LICENSE("GPL");
3940 MODULE_DESCRIPTION("VIA HD-audio codec");
3942 static int __init patch_via_init(void)
3944 return snd_hda_add_codec_preset(&via_list);
3947 static void __exit patch_via_exit(void)
3949 snd_hda_delete_codec_preset(&via_list);
3952 module_init(patch_via_init)
3953 module_exit(patch_via_exit)