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 <sound/core.h>
53 #include <sound/asoundef.h>
54 #include "hda_codec.h"
55 #include "hda_local.h"
58 #define VT1708_HP_PIN_NID 0x20
59 #define VT1708_CD_PIN_NID 0x24
79 #define VT2002P_COMPATIBLE(spec) \
80 ((spec)->codec_type == VT2002P ||\
81 (spec)->codec_type == VT1812 ||\
82 (spec)->codec_type == VT1802)
84 #define MAX_NID_PATH_DEPTH 5
88 hda_nid_t path[MAX_NID_PATH_DEPTH];
89 short idx[MAX_NID_PATH_DEPTH];
93 /* codec parameterization */
94 const struct snd_kcontrol_new *mixers[6];
95 unsigned int num_mixers;
97 const struct hda_verb *init_verbs[5];
98 unsigned int num_iverbs;
100 char stream_name_analog[32];
101 char stream_name_hp[32];
102 const struct hda_pcm_stream *stream_analog_playback;
103 const struct hda_pcm_stream *stream_analog_capture;
105 char stream_name_digital[32];
106 const struct hda_pcm_stream *stream_digital_playback;
107 const struct hda_pcm_stream *stream_digital_capture;
110 struct hda_multi_out multiout;
111 hda_nid_t slave_dig_outs[2];
112 hda_nid_t hp_dac_nid;
113 int num_active_streams;
115 struct nid_path out_path[4];
116 struct nid_path hp_path;
117 struct nid_path hp_dep_path;
118 struct nid_path speaker_path;
121 unsigned int num_adc_nids;
122 hda_nid_t adc_nids[3];
123 hda_nid_t mux_nids[3];
124 hda_nid_t aa_mix_nid;
125 hda_nid_t dig_in_nid;
128 const struct hda_input_mux *input_mux;
129 unsigned int cur_mux[3];
131 /* PCM information */
132 struct hda_pcm pcm_rec[3];
134 /* dynamic controls, init_verbs and input_mux */
135 struct auto_pin_cfg autocfg;
136 struct snd_array kctls;
137 struct hda_input_mux private_imux[2];
138 hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
141 unsigned int hp_independent_mode;
142 unsigned int dmic_enabled;
143 unsigned int no_pin_power_ctl;
144 enum VIA_HDA_CODEC codec_type;
147 unsigned int smart51_nums;
148 hda_nid_t smart51_pins[2];
150 const char *smart51_labels[2];
151 unsigned int smart51_enabled;
153 /* work to check hp jack state */
154 struct hda_codec *codec;
155 struct delayed_work vt1708_hp_work;
156 int vt1708_jack_detect;
157 int vt1708_hp_present;
159 void (*set_widgets_power_state)(struct hda_codec *codec);
161 struct hda_loopback_check loopback;
163 struct hda_amp_list loopback_list[8];
166 static enum VIA_HDA_CODEC get_codec_type(struct hda_codec *codec);
167 static struct via_spec * via_new_spec(struct hda_codec *codec)
169 struct via_spec *spec;
171 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
177 spec->codec_type = get_codec_type(codec);
178 /* VT1708BCE & VT1708S are almost same */
179 if (spec->codec_type == VT1708BCE)
180 spec->codec_type = VT1708S;
184 static enum VIA_HDA_CODEC get_codec_type(struct hda_codec *codec)
186 u32 vendor_id = codec->vendor_id;
187 u16 ven_id = vendor_id >> 16;
188 u16 dev_id = vendor_id & 0xffff;
189 enum VIA_HDA_CODEC codec_type;
192 if (ven_id != 0x1106)
193 codec_type = UNKNOWN;
194 else if (dev_id >= 0x1708 && dev_id <= 0x170b)
196 else if (dev_id >= 0xe710 && dev_id <= 0xe713)
197 codec_type = VT1709_10CH;
198 else if (dev_id >= 0xe714 && dev_id <= 0xe717)
199 codec_type = VT1709_6CH;
200 else if (dev_id >= 0xe720 && dev_id <= 0xe723) {
201 codec_type = VT1708B_8CH;
202 if (snd_hda_param_read(codec, 0x16, AC_PAR_CONNLIST_LEN) == 0x7)
203 codec_type = VT1708BCE;
204 } else if (dev_id >= 0xe724 && dev_id <= 0xe727)
205 codec_type = VT1708B_4CH;
206 else if ((dev_id & 0xfff) == 0x397
207 && (dev_id >> 12) < 8)
208 codec_type = VT1708S;
209 else if ((dev_id & 0xfff) == 0x398
210 && (dev_id >> 12) < 8)
212 else if ((dev_id & 0xfff) == 0x428
213 && (dev_id >> 12) < 8)
214 codec_type = VT1718S;
215 else if (dev_id == 0x0433 || dev_id == 0xa721)
216 codec_type = VT1716S;
217 else if (dev_id == 0x0441 || dev_id == 0x4441)
218 codec_type = VT1718S;
219 else if (dev_id == 0x0438 || dev_id == 0x4438)
220 codec_type = VT2002P;
221 else if (dev_id == 0x0448)
223 else if (dev_id == 0x0440)
224 codec_type = VT1708S;
225 else if ((dev_id & 0xfff) == 0x446)
228 codec_type = UNKNOWN;
232 #define VIA_JACK_EVENT 0x20
233 #define VIA_HP_EVENT 0x01
234 #define VIA_GPIO_EVENT 0x02
235 #define VIA_LINE_EVENT 0x03
240 VIA_CTL_WIDGET_ANALOG_MUTE,
243 static void analog_low_current_mode(struct hda_codec *codec);
244 static bool is_aa_path_mute(struct hda_codec *codec);
246 static void vt1708_start_hp_work(struct via_spec *spec)
248 if (spec->codec_type != VT1708 || spec->autocfg.hp_pins[0] == 0)
250 snd_hda_codec_write(spec->codec, 0x1, 0, 0xf81,
251 !spec->vt1708_jack_detect);
252 if (!delayed_work_pending(&spec->vt1708_hp_work))
253 schedule_delayed_work(&spec->vt1708_hp_work,
254 msecs_to_jiffies(100));
257 static void vt1708_stop_hp_work(struct via_spec *spec)
259 if (spec->codec_type != VT1708 || spec->autocfg.hp_pins[0] == 0)
261 if (snd_hda_get_bool_hint(spec->codec, "analog_loopback_hp_detect") == 1
262 && !is_aa_path_mute(spec->codec))
264 snd_hda_codec_write(spec->codec, 0x1, 0, 0xf81,
265 !spec->vt1708_jack_detect);
266 cancel_delayed_work_sync(&spec->vt1708_hp_work);
269 static void set_widgets_power_state(struct hda_codec *codec)
271 struct via_spec *spec = codec->spec;
272 if (spec->set_widgets_power_state)
273 spec->set_widgets_power_state(codec);
276 static int analog_input_switch_put(struct snd_kcontrol *kcontrol,
277 struct snd_ctl_elem_value *ucontrol)
279 int change = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
280 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
282 set_widgets_power_state(codec);
283 analog_low_current_mode(snd_kcontrol_chip(kcontrol));
284 if (snd_hda_get_bool_hint(codec, "analog_loopback_hp_detect") == 1) {
285 if (is_aa_path_mute(codec))
286 vt1708_start_hp_work(codec->spec);
288 vt1708_stop_hp_work(codec->spec);
293 /* modify .put = snd_hda_mixer_amp_switch_put */
294 #define ANALOG_INPUT_MUTE \
295 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
298 .info = snd_hda_mixer_amp_switch_info, \
299 .get = snd_hda_mixer_amp_switch_get, \
300 .put = analog_input_switch_put, \
301 .private_value = HDA_COMPOSE_AMP_VAL(0, 3, 0, 0) }
303 static const struct snd_kcontrol_new via_control_templates[] = {
304 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
305 HDA_CODEC_MUTE(NULL, 0, 0, 0),
310 /* add dynamic controls */
311 static struct snd_kcontrol_new *__via_clone_ctl(struct via_spec *spec,
312 const struct snd_kcontrol_new *tmpl,
315 struct snd_kcontrol_new *knew;
317 snd_array_init(&spec->kctls, sizeof(*knew), 32);
318 knew = snd_array_new(&spec->kctls);
325 knew->name = kstrdup(name, GFP_KERNEL);
332 static int __via_add_control(struct via_spec *spec, int type, const char *name,
333 int idx, unsigned long val)
335 struct snd_kcontrol_new *knew;
337 knew = __via_clone_ctl(spec, &via_control_templates[type], name);
341 if (get_amp_nid_(val))
342 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
343 knew->private_value = val;
347 #define via_add_control(spec, type, name, val) \
348 __via_add_control(spec, type, name, 0, val)
350 #define via_clone_control(spec, tmpl) __via_clone_ctl(spec, tmpl, NULL)
352 static void via_free_kctls(struct hda_codec *codec)
354 struct via_spec *spec = codec->spec;
356 if (spec->kctls.list) {
357 struct snd_kcontrol_new *kctl = spec->kctls.list;
359 for (i = 0; i < spec->kctls.used; i++)
362 snd_array_free(&spec->kctls);
365 /* create input playback/capture controls for the given pin */
366 static int via_new_analog_input(struct via_spec *spec, const char *ctlname,
367 int type_idx, int idx, int mix_nid)
372 sprintf(name, "%s Playback Volume", ctlname);
373 err = __via_add_control(spec, VIA_CTL_WIDGET_VOL, name, type_idx,
374 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
377 sprintf(name, "%s Playback Switch", ctlname);
378 err = __via_add_control(spec, VIA_CTL_WIDGET_ANALOG_MUTE, name, type_idx,
379 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
385 /* return the index of the given widget nid as the source of mux;
386 * return -1 if not found;
387 * if num_conns is non-NULL, set the total number of connections
389 static int __get_connection_index(struct hda_codec *codec, hda_nid_t mux,
390 hda_nid_t nid, int *num_conns)
392 hda_nid_t conn[HDA_MAX_NUM_INPUTS];
395 nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
398 for (i = 0; i < nums; i++)
404 #define get_connection_index(codec, mux, nid) \
405 __get_connection_index(codec, mux, nid, NULL)
407 static bool check_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
410 unsigned int caps = get_wcaps(codec, nid);
411 if (dir == HDA_INPUT)
412 caps &= AC_WCAP_IN_AMP;
414 caps &= AC_WCAP_OUT_AMP;
417 if (query_amp_caps(codec, nid, dir) & mask)
422 #define have_vol_or_mute(codec, nid, dir) \
423 check_amp_caps(codec, nid, dir, AC_AMPCAP_NUM_STEPS | AC_AMPCAP_MUTE)
425 /* unmute input amp and select the specificed source */
426 static void unmute_and_select(struct hda_codec *codec, hda_nid_t nid,
427 hda_nid_t src, hda_nid_t mix)
431 idx = __get_connection_index(codec, nid, src, &num_conns);
435 /* select the route explicitly when multiple connections exist */
437 get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_AUD_MIX)
438 snd_hda_codec_write(codec, nid, 0,
439 AC_VERB_SET_CONNECT_SEL, idx);
441 /* unmute if the input amp is present */
442 if (have_vol_or_mute(codec, nid, HDA_INPUT))
443 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
446 /* unmute the src output */
447 if (have_vol_or_mute(codec, src, HDA_OUTPUT))
448 snd_hda_codec_write(codec, src, 0, AC_VERB_SET_AMP_GAIN_MUTE,
451 /* unmute AA-path if present */
452 if (!mix || mix == src)
454 idx = __get_connection_index(codec, nid, mix, NULL);
455 if (idx >= 0 && have_vol_or_mute(codec, nid, HDA_INPUT))
456 snd_hda_codec_write(codec, nid, 0,
457 AC_VERB_SET_AMP_GAIN_MUTE,
461 /* set the given pin as output */
462 static void init_output_pin(struct hda_codec *codec, hda_nid_t pin,
467 snd_hda_codec_write(codec, pin, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
469 if (snd_hda_query_pin_caps(codec, pin) & AC_PINCAP_EAPD)
470 snd_hda_codec_write(codec, pin, 0,
471 AC_VERB_SET_EAPD_BTLENABLE, 0x02);
474 static void via_auto_init_output(struct hda_codec *codec, hda_nid_t pin,
475 int pin_type, struct nid_path *path)
477 struct via_spec *spec = codec->spec;
485 init_output_pin(codec, pin, pin_type);
486 caps = query_amp_caps(codec, pin, HDA_OUTPUT);
487 if (caps & AC_AMPCAP_MUTE) {
489 val = (caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT;
490 snd_hda_codec_write(codec, pin, 0, AC_VERB_SET_AMP_GAIN_MUTE,
494 /* initialize the output path */
495 for (i = path->depth - 1; i > 0; i--) {
496 nid = path->path[i - 1];
497 unmute_and_select(codec, path->path[i], nid, spec->aa_mix_nid);
502 static void via_auto_init_multi_out(struct hda_codec *codec)
504 struct via_spec *spec = codec->spec;
507 for (i = 0; i < spec->autocfg.line_outs + spec->smart51_nums; i++)
508 via_auto_init_output(codec, spec->autocfg.line_out_pins[i],
509 PIN_OUT, &spec->out_path[i]);
512 static void via_auto_init_hp_out(struct hda_codec *codec)
514 struct via_spec *spec = codec->spec;
516 if (spec->hp_dac_nid)
517 via_auto_init_output(codec, spec->autocfg.hp_pins[0], PIN_HP,
520 via_auto_init_output(codec, spec->autocfg.hp_pins[0], PIN_HP,
524 static void via_auto_init_speaker_out(struct hda_codec *codec)
526 struct via_spec *spec = codec->spec;
528 if (spec->autocfg.speaker_outs)
529 via_auto_init_output(codec, spec->autocfg.speaker_pins[0],
530 PIN_OUT, &spec->speaker_path);
533 static bool is_smart51_pins(struct hda_codec *codec, hda_nid_t pin);
535 static void via_auto_init_analog_input(struct hda_codec *codec)
537 struct via_spec *spec = codec->spec;
538 const struct auto_pin_cfg *cfg = &spec->autocfg;
539 hda_nid_t conn[HDA_MAX_CONNECTIONS];
544 for (i = 0; i < spec->num_adc_nids; i++) {
545 snd_hda_codec_write(codec, spec->adc_nids[i], 0,
546 AC_VERB_SET_AMP_GAIN_MUTE,
551 for (i = 0; i < cfg->num_inputs; i++) {
552 hda_nid_t nid = cfg->inputs[i].pin;
553 if (spec->smart51_enabled && is_smart51_pins(codec, nid))
555 else if (cfg->inputs[i].type == AUTO_PIN_MIC)
559 snd_hda_codec_write(codec, nid, 0,
560 AC_VERB_SET_PIN_WIDGET_CONTROL, ctl);
564 for (i = 0; i < spec->num_adc_nids; i++) {
565 const struct hda_input_mux *imux = spec->input_mux;
566 if (!imux || !spec->mux_nids[i])
568 snd_hda_codec_write(codec, spec->mux_nids[i], 0,
569 AC_VERB_SET_CONNECT_SEL,
570 imux->items[spec->cur_mux[i]].index);
574 if (!spec->aa_mix_nid)
576 num_conns = snd_hda_get_connections(codec, spec->aa_mix_nid, conn,
578 for (i = 0; i < num_conns; i++) {
579 unsigned int caps = get_wcaps(codec, conn[i]);
580 if (get_wcaps_type(caps) == AC_WID_PIN)
581 snd_hda_codec_write(codec, spec->aa_mix_nid, 0,
582 AC_VERB_SET_AMP_GAIN_MUTE,
587 static void set_pin_power_state(struct hda_codec *codec, hda_nid_t nid,
588 unsigned int *affected_parm)
591 unsigned def_conf = snd_hda_codec_get_pincfg(codec, nid);
592 unsigned no_presence = (def_conf & AC_DEFCFG_MISC)
593 >> AC_DEFCFG_MISC_SHIFT
594 & AC_DEFCFG_MISC_NO_PRESENCE; /* do not support pin sense */
595 struct via_spec *spec = codec->spec;
596 unsigned present = 0;
598 no_presence |= spec->no_pin_power_ctl;
600 present = snd_hda_jack_detect(codec, nid);
601 if ((spec->smart51_enabled && is_smart51_pins(codec, nid))
602 || ((no_presence || present)
603 && get_defcfg_connect(def_conf) != AC_JACK_PORT_NONE)) {
604 *affected_parm = AC_PWRST_D0; /* if it's connected */
609 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE, parm);
612 static int via_pin_power_ctl_info(struct snd_kcontrol *kcontrol,
613 struct snd_ctl_elem_info *uinfo)
615 static const char * const texts[] = {
616 "Disabled", "Enabled"
619 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
621 uinfo->value.enumerated.items = 2;
622 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
623 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
624 strcpy(uinfo->value.enumerated.name,
625 texts[uinfo->value.enumerated.item]);
629 static int via_pin_power_ctl_get(struct snd_kcontrol *kcontrol,
630 struct snd_ctl_elem_value *ucontrol)
632 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
633 struct via_spec *spec = codec->spec;
634 ucontrol->value.enumerated.item[0] = !spec->no_pin_power_ctl;
638 static int via_pin_power_ctl_put(struct snd_kcontrol *kcontrol,
639 struct snd_ctl_elem_value *ucontrol)
641 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
642 struct via_spec *spec = codec->spec;
643 unsigned int val = !ucontrol->value.enumerated.item[0];
645 if (val == spec->no_pin_power_ctl)
647 spec->no_pin_power_ctl = val;
648 set_widgets_power_state(codec);
652 static const struct snd_kcontrol_new via_pin_power_ctl_enum = {
653 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
654 .name = "Dynamic Power-Control",
655 .info = via_pin_power_ctl_info,
656 .get = via_pin_power_ctl_get,
657 .put = via_pin_power_ctl_put,
664 static int via_mux_enum_info(struct snd_kcontrol *kcontrol,
665 struct snd_ctl_elem_info *uinfo)
667 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
668 struct via_spec *spec = codec->spec;
669 return snd_hda_input_mux_info(spec->input_mux, uinfo);
672 static int via_mux_enum_get(struct snd_kcontrol *kcontrol,
673 struct snd_ctl_elem_value *ucontrol)
675 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
676 struct via_spec *spec = codec->spec;
677 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
679 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
683 static int via_mux_enum_put(struct snd_kcontrol *kcontrol,
684 struct snd_ctl_elem_value *ucontrol)
686 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
687 struct via_spec *spec = codec->spec;
688 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
691 if (!spec->mux_nids[adc_idx])
693 /* switch to D0 beofre change index */
694 if (snd_hda_codec_read(codec, spec->mux_nids[adc_idx], 0,
695 AC_VERB_GET_POWER_STATE, 0x00) != AC_PWRST_D0)
696 snd_hda_codec_write(codec, spec->mux_nids[adc_idx], 0,
697 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
699 ret = snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
700 spec->mux_nids[adc_idx],
701 &spec->cur_mux[adc_idx]);
702 /* update jack power state */
703 set_widgets_power_state(codec);
708 static int via_independent_hp_info(struct snd_kcontrol *kcontrol,
709 struct snd_ctl_elem_info *uinfo)
711 static const char * const texts[] = { "OFF", "ON" };
713 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
715 uinfo->value.enumerated.items = 2;
716 if (uinfo->value.enumerated.item >= 2)
717 uinfo->value.enumerated.item = 1;
718 strcpy(uinfo->value.enumerated.name,
719 texts[uinfo->value.enumerated.item]);
723 static int via_independent_hp_get(struct snd_kcontrol *kcontrol,
724 struct snd_ctl_elem_value *ucontrol)
726 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
727 struct via_spec *spec = codec->spec;
729 ucontrol->value.enumerated.item[0] = spec->hp_independent_mode;
733 static int via_independent_hp_put(struct snd_kcontrol *kcontrol,
734 struct snd_ctl_elem_value *ucontrol)
736 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
737 struct via_spec *spec = codec->spec;
739 int i, idx, num_conns;
740 struct nid_path *path;
742 spec->hp_independent_mode = !!ucontrol->value.enumerated.item[0];
743 if (spec->hp_independent_mode)
744 path = &spec->hp_path;
746 path = &spec->hp_dep_path;
748 /* re-route the output path */
749 for (i = path->depth - 1; i > 0; i--) {
751 src = path->path[i - 1];
752 idx = __get_connection_index(codec, nid, src, &num_conns);
756 get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_AUD_MIX)
757 snd_hda_codec_write(codec, nid, 0,
758 AC_VERB_SET_CONNECT_SEL, idx);
761 /* update jack power state */
762 set_widgets_power_state(codec);
766 static const struct snd_kcontrol_new via_hp_mixer = {
767 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
768 .name = "Independent HP",
769 .info = via_independent_hp_info,
770 .get = via_independent_hp_get,
771 .put = via_independent_hp_put,
774 static int via_hp_build(struct hda_codec *codec)
776 struct via_spec *spec = codec->spec;
777 struct snd_kcontrol_new *knew;
780 nid = spec->autocfg.hp_pins[0];
781 knew = via_clone_control(spec, &via_hp_mixer);
785 knew->subdevice = HDA_SUBDEV_NID_FLAG | nid;
790 static void notify_aa_path_ctls(struct hda_codec *codec)
792 struct via_spec *spec = codec->spec;
795 for (i = 0; i < spec->smart51_nums; i++) {
796 struct snd_kcontrol *ctl;
797 struct snd_ctl_elem_id id;
798 memset(&id, 0, sizeof(id));
799 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
800 sprintf(id.name, "%s Playback Volume", spec->smart51_labels[i]);
801 ctl = snd_hda_find_mixer_ctl(codec, id.name);
803 snd_ctl_notify(codec->bus->card,
804 SNDRV_CTL_EVENT_MASK_VALUE,
809 static void mute_aa_path(struct hda_codec *codec, int mute)
811 struct via_spec *spec = codec->spec;
812 int val = mute ? HDA_AMP_MUTE : HDA_AMP_UNMUTE;
815 /* check AA path's mute status */
816 for (i = 0; i < spec->smart51_nums; i++) {
817 if (spec->smart51_idxs[i] < 0)
819 snd_hda_codec_amp_stereo(codec, spec->aa_mix_nid,
820 HDA_INPUT, spec->smart51_idxs[i],
825 static bool is_smart51_pins(struct hda_codec *codec, hda_nid_t pin)
827 struct via_spec *spec = codec->spec;
830 for (i = 0; i < spec->smart51_nums; i++)
831 if (spec->smart51_pins[i] == pin)
836 static int via_smart51_info(struct snd_kcontrol *kcontrol,
837 struct snd_ctl_elem_info *uinfo)
839 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
841 uinfo->value.integer.min = 0;
842 uinfo->value.integer.max = 1;
846 static int via_smart51_get(struct snd_kcontrol *kcontrol,
847 struct snd_ctl_elem_value *ucontrol)
849 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
850 struct via_spec *spec = codec->spec;
854 for (i = 0; i < spec->smart51_nums; i++) {
855 hda_nid_t nid = spec->smart51_pins[i];
857 ctl = snd_hda_codec_read(codec, nid, 0,
858 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
859 if ((ctl & AC_PINCTL_IN_EN) && !(ctl & AC_PINCTL_OUT_EN))
862 *ucontrol->value.integer.value = on;
866 static int via_smart51_put(struct snd_kcontrol *kcontrol,
867 struct snd_ctl_elem_value *ucontrol)
869 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
870 struct via_spec *spec = codec->spec;
871 int out_in = *ucontrol->value.integer.value
872 ? AC_PINCTL_OUT_EN : AC_PINCTL_IN_EN;
875 for (i = 0; i < spec->smart51_nums; i++) {
876 hda_nid_t nid = spec->smart51_pins[i];
879 parm = snd_hda_codec_read(codec, nid, 0,
880 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
881 parm &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
883 snd_hda_codec_write(codec, nid, 0,
884 AC_VERB_SET_PIN_WIDGET_CONTROL,
886 if (out_in == AC_PINCTL_OUT_EN) {
887 mute_aa_path(codec, 1);
888 notify_aa_path_ctls(codec);
891 spec->smart51_enabled = *ucontrol->value.integer.value;
892 set_widgets_power_state(codec);
896 static const struct snd_kcontrol_new via_smart51_mixer = {
897 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
900 .info = via_smart51_info,
901 .get = via_smart51_get,
902 .put = via_smart51_put,
905 static int via_smart51_build(struct hda_codec *codec)
907 struct via_spec *spec = codec->spec;
909 if (!spec->smart51_nums)
911 if (!via_clone_control(spec, &via_smart51_mixer))
916 /* check AA path's mute status */
917 static bool is_aa_path_mute(struct hda_codec *codec)
919 struct via_spec *spec = codec->spec;
920 const struct hda_amp_list *p;
923 for (i = 0; i < spec->num_loopbacks; i++) {
924 p = &spec->loopback_list[i];
925 for (ch = 0; ch < 2; ch++) {
926 v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
928 if (!(v & HDA_AMP_MUTE) && v > 0)
935 /* enter/exit analog low-current mode */
936 static void analog_low_current_mode(struct hda_codec *codec)
938 struct via_spec *spec = codec->spec;
940 unsigned int verb, parm;
942 enable = is_aa_path_mute(codec) && (spec->num_active_streams > 0);
944 /* decide low current mode's verb & parameter */
945 switch (spec->codec_type) {
949 parm = enable ? 0x02 : 0x00; /* 0x02: 2/3x, 0x00: 1x */
955 parm = enable ? 0x51 : 0xe1; /* 0x51: 4/28x, 0xe1: 1x */
959 parm = enable ? 0x01 : 0x1d; /* 0x01: 4/40x, 0x1d: 1x */
965 parm = enable ? 0x00 : 0xe0; /* 0x00: 4/40x, 0xe0: 1x */
968 return; /* other codecs are not supported */
971 snd_hda_codec_write(codec, codec->afg, 0, verb, parm);
975 * generic initialization of ADC, input mixers and output mixers
977 static const struct hda_verb vt1708_init_verbs[] = {
978 /* power down jack detect function */
983 static void set_stream_active(struct hda_codec *codec, bool active)
985 struct via_spec *spec = codec->spec;
988 spec->num_active_streams++;
990 spec->num_active_streams--;
991 analog_low_current_mode(codec);
994 static int via_playback_multi_pcm_open(struct hda_pcm_stream *hinfo,
995 struct hda_codec *codec,
996 struct snd_pcm_substream *substream)
998 struct via_spec *spec = codec->spec;
1001 if (!spec->hp_independent_mode)
1002 spec->multiout.hp_nid = spec->hp_dac_nid;
1003 set_stream_active(codec, true);
1004 err = snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
1007 spec->multiout.hp_nid = 0;
1008 set_stream_active(codec, false);
1014 static int via_playback_multi_pcm_close(struct hda_pcm_stream *hinfo,
1015 struct hda_codec *codec,
1016 struct snd_pcm_substream *substream)
1018 struct via_spec *spec = codec->spec;
1020 spec->multiout.hp_nid = 0;
1021 set_stream_active(codec, false);
1025 static int via_playback_hp_pcm_open(struct hda_pcm_stream *hinfo,
1026 struct hda_codec *codec,
1027 struct snd_pcm_substream *substream)
1029 struct via_spec *spec = codec->spec;
1031 if (snd_BUG_ON(!spec->hp_dac_nid))
1033 if (!spec->hp_independent_mode || spec->multiout.hp_nid)
1035 set_stream_active(codec, true);
1039 static int via_playback_hp_pcm_close(struct hda_pcm_stream *hinfo,
1040 struct hda_codec *codec,
1041 struct snd_pcm_substream *substream)
1043 set_stream_active(codec, false);
1047 static int via_playback_multi_pcm_prepare(struct hda_pcm_stream *hinfo,
1048 struct hda_codec *codec,
1049 unsigned int stream_tag,
1050 unsigned int format,
1051 struct snd_pcm_substream *substream)
1053 struct via_spec *spec = codec->spec;
1055 snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag,
1057 vt1708_start_hp_work(spec);
1061 static int via_playback_hp_pcm_prepare(struct hda_pcm_stream *hinfo,
1062 struct hda_codec *codec,
1063 unsigned int stream_tag,
1064 unsigned int format,
1065 struct snd_pcm_substream *substream)
1067 struct via_spec *spec = codec->spec;
1069 snd_hda_codec_setup_stream(codec, spec->hp_dac_nid,
1070 stream_tag, 0, format);
1071 vt1708_start_hp_work(spec);
1075 static int via_playback_multi_pcm_cleanup(struct hda_pcm_stream *hinfo,
1076 struct hda_codec *codec,
1077 struct snd_pcm_substream *substream)
1079 struct via_spec *spec = codec->spec;
1081 snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
1082 vt1708_stop_hp_work(spec);
1086 static int via_playback_hp_pcm_cleanup(struct hda_pcm_stream *hinfo,
1087 struct hda_codec *codec,
1088 struct snd_pcm_substream *substream)
1090 struct via_spec *spec = codec->spec;
1092 snd_hda_codec_setup_stream(codec, spec->hp_dac_nid, 0, 0, 0);
1093 vt1708_stop_hp_work(spec);
1100 static int via_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
1101 struct hda_codec *codec,
1102 struct snd_pcm_substream *substream)
1104 struct via_spec *spec = codec->spec;
1105 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
1108 static int via_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
1109 struct hda_codec *codec,
1110 struct snd_pcm_substream *substream)
1112 struct via_spec *spec = codec->spec;
1113 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
1116 static int via_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
1117 struct hda_codec *codec,
1118 unsigned int stream_tag,
1119 unsigned int format,
1120 struct snd_pcm_substream *substream)
1122 struct via_spec *spec = codec->spec;
1123 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
1124 stream_tag, format, substream);
1127 static int via_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
1128 struct hda_codec *codec,
1129 struct snd_pcm_substream *substream)
1131 struct via_spec *spec = codec->spec;
1132 snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
1139 static int via_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
1140 struct hda_codec *codec,
1141 unsigned int stream_tag,
1142 unsigned int format,
1143 struct snd_pcm_substream *substream)
1145 struct via_spec *spec = codec->spec;
1147 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
1148 stream_tag, 0, format);
1152 static int via_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
1153 struct hda_codec *codec,
1154 struct snd_pcm_substream *substream)
1156 struct via_spec *spec = codec->spec;
1157 snd_hda_codec_cleanup_stream(codec, spec->adc_nids[substream->number]);
1161 static const struct hda_pcm_stream via_pcm_analog_playback = {
1165 /* NID is set in via_build_pcms */
1167 .open = via_playback_multi_pcm_open,
1168 .close = via_playback_multi_pcm_close,
1169 .prepare = via_playback_multi_pcm_prepare,
1170 .cleanup = via_playback_multi_pcm_cleanup
1174 static const struct hda_pcm_stream via_pcm_hp_playback = {
1178 /* NID is set in via_build_pcms */
1180 .open = via_playback_hp_pcm_open,
1181 .close = via_playback_hp_pcm_close,
1182 .prepare = via_playback_hp_pcm_prepare,
1183 .cleanup = via_playback_hp_pcm_cleanup
1187 static const struct hda_pcm_stream vt1708_pcm_analog_s16_playback = {
1191 /* NID is set in via_build_pcms */
1192 /* We got noisy outputs on the right channel on VT1708 when
1193 * 24bit samples are used. Until any workaround is found,
1194 * disable the 24bit format, so far.
1196 .formats = SNDRV_PCM_FMTBIT_S16_LE,
1198 .open = via_playback_multi_pcm_open,
1199 .close = via_playback_multi_pcm_close,
1200 .prepare = via_playback_multi_pcm_prepare,
1201 .cleanup = via_playback_multi_pcm_cleanup
1205 static const struct hda_pcm_stream via_pcm_analog_capture = {
1206 .substreams = 1, /* will be changed in via_build_pcms() */
1209 /* NID is set in via_build_pcms */
1211 .prepare = via_capture_pcm_prepare,
1212 .cleanup = via_capture_pcm_cleanup
1216 static const struct hda_pcm_stream via_pcm_digital_playback = {
1220 /* NID is set in via_build_pcms */
1222 .open = via_dig_playback_pcm_open,
1223 .close = via_dig_playback_pcm_close,
1224 .prepare = via_dig_playback_pcm_prepare,
1225 .cleanup = via_dig_playback_pcm_cleanup
1229 static const struct hda_pcm_stream via_pcm_digital_capture = {
1236 * slave controls for virtual master
1238 static const char * const via_slave_vols[] = {
1239 "Front Playback Volume",
1240 "Surround Playback Volume",
1241 "Center Playback Volume",
1242 "LFE Playback Volume",
1243 "Side Playback Volume",
1244 "Headphone Playback Volume",
1245 "Speaker Playback Volume",
1249 static const char * const via_slave_sws[] = {
1250 "Front Playback Switch",
1251 "Surround Playback Switch",
1252 "Center Playback Switch",
1253 "LFE Playback Switch",
1254 "Side Playback Switch",
1255 "Headphone Playback Switch",
1256 "Speaker Playback Switch",
1260 static int via_build_controls(struct hda_codec *codec)
1262 struct via_spec *spec = codec->spec;
1263 struct snd_kcontrol *kctl;
1266 if (spec->set_widgets_power_state)
1267 if (!via_clone_control(spec, &via_pin_power_ctl_enum))
1270 for (i = 0; i < spec->num_mixers; i++) {
1271 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1276 if (spec->multiout.dig_out_nid) {
1277 err = snd_hda_create_spdif_out_ctls(codec,
1278 spec->multiout.dig_out_nid,
1279 spec->multiout.dig_out_nid);
1282 err = snd_hda_create_spdif_share_sw(codec,
1286 spec->multiout.share_spdif = 1;
1288 if (spec->dig_in_nid) {
1289 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1294 /* if we have no master control, let's create it */
1295 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1296 unsigned int vmaster_tlv[4];
1297 snd_hda_set_vmaster_tlv(codec, spec->multiout.dac_nids[0],
1298 HDA_OUTPUT, vmaster_tlv);
1299 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1300 vmaster_tlv, via_slave_vols);
1304 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
1305 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
1306 NULL, via_slave_sws);
1311 /* assign Capture Source enums to NID */
1312 kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
1313 for (i = 0; kctl && i < kctl->count; i++) {
1314 err = snd_hda_add_nid(codec, kctl, i, spec->mux_nids[i]);
1319 /* init power states */
1320 set_widgets_power_state(codec);
1321 analog_low_current_mode(codec);
1323 via_free_kctls(codec); /* no longer needed */
1327 static int via_build_pcms(struct hda_codec *codec)
1329 struct via_spec *spec = codec->spec;
1330 struct hda_pcm *info = spec->pcm_rec;
1332 codec->num_pcms = 1;
1333 codec->pcm_info = info;
1335 snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
1336 "%s Analog", codec->chip_name);
1337 info->name = spec->stream_name_analog;
1339 if (!spec->stream_analog_playback)
1340 spec->stream_analog_playback = &via_pcm_analog_playback;
1341 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
1342 *spec->stream_analog_playback;
1343 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
1344 spec->multiout.dac_nids[0];
1345 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
1346 spec->multiout.max_channels;
1348 if (!spec->stream_analog_capture)
1349 spec->stream_analog_capture = &via_pcm_analog_capture;
1350 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
1351 *spec->stream_analog_capture;
1352 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
1353 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
1356 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
1359 snprintf(spec->stream_name_digital,
1360 sizeof(spec->stream_name_digital),
1361 "%s Digital", codec->chip_name);
1362 info->name = spec->stream_name_digital;
1363 info->pcm_type = HDA_PCM_TYPE_SPDIF;
1364 if (spec->multiout.dig_out_nid) {
1365 if (!spec->stream_digital_playback)
1366 spec->stream_digital_playback =
1367 &via_pcm_digital_playback;
1368 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
1369 *spec->stream_digital_playback;
1370 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
1371 spec->multiout.dig_out_nid;
1373 if (spec->dig_in_nid) {
1374 if (!spec->stream_digital_capture)
1375 spec->stream_digital_capture =
1376 &via_pcm_digital_capture;
1377 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
1378 *spec->stream_digital_capture;
1379 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
1384 if (spec->hp_dac_nid) {
1387 snprintf(spec->stream_name_hp, sizeof(spec->stream_name_hp),
1388 "%s HP", codec->chip_name);
1389 info->name = spec->stream_name_hp;
1390 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = via_pcm_hp_playback;
1391 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
1397 static void via_free(struct hda_codec *codec)
1399 struct via_spec *spec = codec->spec;
1404 via_free_kctls(codec);
1405 vt1708_stop_hp_work(spec);
1409 /* mute/unmute outputs */
1410 static void toggle_output_mutes(struct hda_codec *codec, int num_pins,
1411 hda_nid_t *pins, bool mute)
1414 for (i = 0; i < num_pins; i++)
1415 snd_hda_codec_write(codec, pins[i], 0,
1416 AC_VERB_SET_PIN_WIDGET_CONTROL,
1417 mute ? 0 : PIN_OUT);
1420 /* mute internal speaker if line-out is plugged */
1421 static void via_line_automute(struct hda_codec *codec, int present)
1423 struct via_spec *spec = codec->spec;
1425 if (!spec->autocfg.speaker_outs)
1428 present = snd_hda_jack_detect(codec,
1429 spec->autocfg.line_out_pins[0]);
1430 toggle_output_mutes(codec, spec->autocfg.speaker_outs,
1431 spec->autocfg.speaker_pins,
1435 /* mute internal speaker if HP is plugged */
1436 static void via_hp_automute(struct hda_codec *codec)
1439 struct via_spec *spec = codec->spec;
1441 if (!spec->hp_independent_mode && spec->autocfg.hp_pins[0]) {
1442 present = snd_hda_jack_detect(codec, spec->autocfg.hp_pins[0]);
1443 toggle_output_mutes(codec, spec->autocfg.line_outs,
1444 spec->autocfg.line_out_pins,
1447 via_line_automute(codec, present);
1450 static void via_gpio_control(struct hda_codec *codec)
1452 unsigned int gpio_data;
1453 unsigned int vol_counter;
1455 unsigned int master_vol;
1457 struct via_spec *spec = codec->spec;
1459 gpio_data = snd_hda_codec_read(codec, codec->afg, 0,
1460 AC_VERB_GET_GPIO_DATA, 0) & 0x03;
1462 vol_counter = (snd_hda_codec_read(codec, codec->afg, 0,
1463 0xF84, 0) & 0x3F0000) >> 16;
1465 vol = vol_counter & 0x1F;
1466 master_vol = snd_hda_codec_read(codec, 0x1A, 0,
1467 AC_VERB_GET_AMP_GAIN_MUTE,
1470 if (gpio_data == 0x02) {
1471 /* unmute line out */
1472 snd_hda_codec_write(codec, spec->autocfg.line_out_pins[0], 0,
1473 AC_VERB_SET_PIN_WIDGET_CONTROL,
1475 if (vol_counter & 0x20) {
1476 /* decrease volume */
1477 if (vol > master_vol)
1479 snd_hda_codec_amp_stereo(codec, 0x1A, HDA_INPUT,
1483 /* increase volume */
1484 snd_hda_codec_amp_stereo(codec, 0x1A, HDA_INPUT, 0,
1486 ((master_vol+vol) > 0x2A) ? 0x2A :
1489 } else if (!(gpio_data & 0x02)) {
1491 snd_hda_codec_write(codec, spec->autocfg.line_out_pins[0], 0,
1492 AC_VERB_SET_PIN_WIDGET_CONTROL,
1497 /* unsolicited event for jack sensing */
1498 static void via_unsol_event(struct hda_codec *codec,
1503 if (res & VIA_JACK_EVENT)
1504 set_widgets_power_state(codec);
1506 res &= ~VIA_JACK_EVENT;
1508 if (res == VIA_HP_EVENT)
1509 via_hp_automute(codec);
1510 else if (res == VIA_GPIO_EVENT)
1511 via_gpio_control(codec);
1512 else if (res == VIA_LINE_EVENT)
1513 via_line_automute(codec, false);
1516 #ifdef SND_HDA_NEEDS_RESUME
1517 static int via_suspend(struct hda_codec *codec, pm_message_t state)
1519 struct via_spec *spec = codec->spec;
1520 vt1708_stop_hp_work(spec);
1525 #ifdef CONFIG_SND_HDA_POWER_SAVE
1526 static int via_check_power_status(struct hda_codec *codec, hda_nid_t nid)
1528 struct via_spec *spec = codec->spec;
1529 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
1536 static int via_init(struct hda_codec *codec);
1538 static const struct hda_codec_ops via_patch_ops = {
1539 .build_controls = via_build_controls,
1540 .build_pcms = via_build_pcms,
1543 .unsol_event = via_unsol_event,
1544 #ifdef SND_HDA_NEEDS_RESUME
1545 .suspend = via_suspend,
1547 #ifdef CONFIG_SND_HDA_POWER_SAVE
1548 .check_power_status = via_check_power_status,
1552 static bool is_empty_dac(struct hda_codec *codec, hda_nid_t dac)
1554 struct via_spec *spec = codec->spec;
1557 for (i = 0; i < spec->multiout.num_dacs; i++) {
1558 if (spec->multiout.dac_nids[i] == dac)
1561 if (spec->hp_dac_nid == dac)
1566 static bool __parse_output_path(struct hda_codec *codec, hda_nid_t nid,
1567 hda_nid_t target_dac, struct nid_path *path,
1568 int depth, int wid_type)
1573 nums = snd_hda_get_connections(codec, nid, conn, ARRAY_SIZE(conn));
1574 for (i = 0; i < nums; i++) {
1575 if (get_wcaps_type(get_wcaps(codec, conn[i])) != AC_WID_AUD_OUT)
1577 if (conn[i] == target_dac || is_empty_dac(codec, conn[i])) {
1578 path->path[0] = conn[i];
1584 if (depth >= MAX_NID_PATH_DEPTH)
1586 for (i = 0; i < nums; i++) {
1588 type = get_wcaps_type(get_wcaps(codec, conn[i]));
1589 if (type == AC_WID_AUD_OUT ||
1590 (wid_type != -1 && type != wid_type))
1592 if (__parse_output_path(codec, conn[i], target_dac,
1593 path, depth + 1, AC_WID_AUD_SEL)) {
1594 path->path[path->depth] = conn[i];
1595 path->idx[path->depth] = i;
1603 static bool parse_output_path(struct hda_codec *codec, hda_nid_t nid,
1604 hda_nid_t target_dac, struct nid_path *path)
1606 if (__parse_output_path(codec, nid, target_dac, path, 1, -1)) {
1607 path->path[path->depth] = nid;
1614 static int via_auto_fill_dac_nids(struct hda_codec *codec)
1616 struct via_spec *spec = codec->spec;
1617 const struct auto_pin_cfg *cfg = &spec->autocfg;
1621 spec->multiout.dac_nids = spec->private_dac_nids;
1622 spec->multiout.num_dacs = cfg->line_outs;
1623 for (i = 0; i < cfg->line_outs; i++) {
1624 nid = cfg->line_out_pins[i];
1627 if (parse_output_path(codec, nid, 0, &spec->out_path[i]))
1628 spec->private_dac_nids[i] = spec->out_path[i].path[0];
1633 static int create_ch_ctls(struct hda_codec *codec, const char *pfx,
1634 hda_nid_t pin, hda_nid_t dac, int chs)
1636 struct via_spec *spec = codec->spec;
1641 if (dac && check_amp_caps(codec, dac, HDA_OUTPUT, AC_AMPCAP_NUM_STEPS))
1643 else if (check_amp_caps(codec, pin, HDA_OUTPUT, AC_AMPCAP_NUM_STEPS))
1648 sprintf(name, "%s Playback Volume", pfx);
1649 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
1650 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
1655 if (dac && check_amp_caps(codec, dac, HDA_OUTPUT, AC_AMPCAP_MUTE))
1657 else if (check_amp_caps(codec, pin, HDA_OUTPUT, AC_AMPCAP_MUTE))
1662 sprintf(name, "%s Playback Switch", pfx);
1663 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
1664 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
1671 static void mangle_smart51(struct hda_codec *codec)
1673 struct via_spec *spec = codec->spec;
1674 struct auto_pin_cfg *cfg = &spec->autocfg;
1675 struct auto_pin_cfg_item *ins = cfg->inputs;
1676 int i, j, nums, attr;
1677 int pins[AUTO_CFG_MAX_INS];
1679 for (attr = INPUT_PIN_ATTR_REAR; attr >= INPUT_PIN_ATTR_NORMAL; attr--) {
1681 for (i = 0; i < cfg->num_inputs; i++) {
1683 if (ins[i].type > AUTO_PIN_LINE_IN)
1685 def = snd_hda_codec_get_pincfg(codec, ins[i].pin);
1686 if (snd_hda_get_input_pin_attr(def) != attr)
1688 for (j = 0; j < nums; j++)
1689 if (ins[pins[j]].type < ins[i].type) {
1690 memmove(pins + j + 1, pins + j,
1691 (nums - j - 1) * sizeof(int));
1697 if (cfg->line_outs + nums < 3)
1699 for (i = 0; i < nums; i++) {
1700 hda_nid_t pin = ins[pins[i]].pin;
1701 spec->smart51_pins[spec->smart51_nums++] = pin;
1702 cfg->line_out_pins[cfg->line_outs++] = pin;
1703 if (cfg->line_outs == 3)
1710 /* add playback controls from the parsed DAC table */
1711 static int via_auto_create_multi_out_ctls(struct hda_codec *codec)
1713 struct via_spec *spec = codec->spec;
1714 struct auto_pin_cfg *cfg = &spec->autocfg;
1715 static const char * const chname[4] = {
1716 "Front", "Surround", "C/LFE", "Side"
1722 old_line_outs = cfg->line_outs;
1723 if (cfg->line_outs == 1)
1724 mangle_smart51(codec);
1726 err = via_auto_fill_dac_nids(codec);
1730 for (i = 0; i < cfg->line_outs; i++) {
1732 pin = cfg->line_out_pins[i];
1733 dac = spec->multiout.dac_nids[i];
1736 if (i == HDA_CLFE) {
1737 err = create_ch_ctls(codec, "Center", pin, dac, 1);
1740 err = create_ch_ctls(codec, "LFE", pin, dac, 2);
1744 const char *pfx = chname[i];
1745 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT &&
1746 cfg->line_outs == 1)
1748 err = create_ch_ctls(codec, pfx, pin, dac, 3);
1754 idx = get_connection_index(codec, spec->aa_mix_nid,
1755 spec->multiout.dac_nids[0]);
1757 /* add control to mixer */
1758 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1759 "PCM Playback Volume",
1760 HDA_COMPOSE_AMP_VAL(spec->aa_mix_nid, 3,
1764 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1765 "PCM Playback Switch",
1766 HDA_COMPOSE_AMP_VAL(spec->aa_mix_nid, 3,
1772 cfg->line_outs = old_line_outs;
1777 static int via_auto_create_hp_ctls(struct hda_codec *codec, hda_nid_t pin)
1779 struct via_spec *spec = codec->spec;
1785 if (parse_output_path(codec, pin, 0, &spec->hp_path))
1786 spec->hp_dac_nid = spec->hp_path.path[0];
1788 if (!parse_output_path(codec, pin, spec->multiout.dac_nids[HDA_FRONT],
1789 &spec->hp_dep_path) &&
1793 err = create_ch_ctls(codec, "Headphone", pin, spec->hp_dac_nid, 3);
1800 static int via_auto_create_speaker_ctls(struct hda_codec *codec)
1802 struct via_spec *spec = codec->spec;
1805 pin = spec->autocfg.speaker_pins[0];
1806 if (!spec->autocfg.speaker_outs || !pin)
1809 if (parse_output_path(codec, pin, 0, &spec->speaker_path)) {
1810 dac = spec->speaker_path.path[0];
1811 spec->multiout.extra_out_nid[0] = dac;
1812 return create_ch_ctls(codec, "Speaker", pin, dac, 3);
1814 if (parse_output_path(codec, pin, spec->multiout.dac_nids[HDA_FRONT],
1815 &spec->speaker_path))
1816 return create_ch_ctls(codec, "Speaker", pin, 0, 3);
1822 static int via_fill_adcs(struct hda_codec *codec)
1824 struct via_spec *spec = codec->spec;
1825 hda_nid_t nid = codec->start_nid;
1828 for (i = 0; i < codec->num_nodes; i++, nid++) {
1829 unsigned int wcaps = get_wcaps(codec, nid);
1830 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
1832 if (wcaps & AC_WCAP_DIGITAL)
1834 if (!(wcaps & AC_WCAP_CONN_LIST))
1836 if (spec->num_adc_nids >= ARRAY_SIZE(spec->adc_nids))
1838 spec->adc_nids[spec->num_adc_nids++] = nid;
1843 static int get_mux_nids(struct hda_codec *codec);
1845 static const struct snd_kcontrol_new via_input_src_ctl = {
1846 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1847 /* The multiple "Capture Source" controls confuse alsamixer
1848 * So call somewhat different..
1850 /* .name = "Capture Source", */
1851 .name = "Input Source",
1852 .info = via_mux_enum_info,
1853 .get = via_mux_enum_get,
1854 .put = via_mux_enum_put,
1857 static void add_loopback_list(struct via_spec *spec, hda_nid_t mix, int idx)
1859 struct hda_amp_list *list;
1861 if (spec->num_loopbacks >= ARRAY_SIZE(spec->loopback_list) - 1)
1863 list = spec->loopback_list + spec->num_loopbacks;
1865 list->dir = HDA_INPUT;
1867 spec->num_loopbacks++;
1868 spec->loopback.amplist = spec->loopback_list;
1871 /* create playback/capture controls for input pins */
1872 static int via_auto_create_analog_input_ctls(struct hda_codec *codec,
1873 const struct auto_pin_cfg *cfg)
1875 struct via_spec *spec = codec->spec;
1876 struct hda_input_mux *imux = &spec->private_imux[0];
1877 int i, j, err, idx, idx2, type, type_idx = 0;
1879 hda_nid_t pin_idxs[8];
1882 err = via_fill_adcs(codec);
1885 err = get_mux_nids(codec);
1888 cap_nid = spec->mux_nids[0];
1890 num_idxs = snd_hda_get_connections(codec, cap_nid, pin_idxs,
1891 ARRAY_SIZE(pin_idxs));
1895 /* for internal loopback recording select */
1896 for (idx = 0; idx < num_idxs; idx++) {
1897 if (pin_idxs[idx] == spec->aa_mix_nid) {
1898 snd_hda_add_imux_item(imux, "Stereo Mixer", idx, NULL);
1903 for (i = 0; i < cfg->num_inputs; i++) {
1905 type = cfg->inputs[i].type;
1906 for (idx = 0; idx < num_idxs; idx++)
1907 if (pin_idxs[idx] == cfg->inputs[i].pin)
1909 if (idx >= num_idxs)
1911 if (i > 0 && type == cfg->inputs[i - 1].type)
1915 label = hda_get_autocfg_input_label(codec, cfg, i);
1916 idx2 = get_connection_index(codec, spec->aa_mix_nid,
1919 err = via_new_analog_input(spec, label, type_idx,
1920 idx2, spec->aa_mix_nid);
1923 add_loopback_list(spec, spec->aa_mix_nid, idx2);
1925 snd_hda_add_imux_item(imux, label, idx, NULL);
1927 /* remember the label for smart51 control */
1928 for (j = 0; j < spec->smart51_nums; j++) {
1929 if (spec->smart51_pins[j] == cfg->inputs[i].pin) {
1930 spec->smart51_idxs[j] = idx;
1931 spec->smart51_labels[j] = label;
1937 /* create capture mixer elements */
1938 for (i = 0; i < spec->num_adc_nids; i++) {
1939 hda_nid_t adc = spec->adc_nids[i];
1940 err = __via_add_control(spec, VIA_CTL_WIDGET_VOL,
1941 "Capture Volume", i,
1942 HDA_COMPOSE_AMP_VAL(adc, 3, 0,
1946 err = __via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1947 "Capture Switch", i,
1948 HDA_COMPOSE_AMP_VAL(adc, 3, 0,
1954 /* input-source control */
1955 for (i = 0; i < spec->num_adc_nids; i++)
1956 if (!spec->mux_nids[i])
1959 struct snd_kcontrol_new *knew;
1960 knew = via_clone_control(spec, &via_input_src_ctl);
1967 for (i = 0; i < cfg->num_inputs; i++) {
1968 hda_nid_t pin = cfg->inputs[i].pin;
1973 if (cfg->inputs[i].type != AUTO_PIN_MIC)
1975 caps = query_amp_caps(codec, pin, HDA_INPUT);
1976 if (caps == -1 || !(caps & AC_AMPCAP_NUM_STEPS))
1978 label = hda_get_autocfg_input_label(codec, cfg, i);
1979 snprintf(name, sizeof(name), "%s Boost Volume", label);
1980 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
1981 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_INPUT));
1989 static void vt1708_set_pinconfig_connect(struct hda_codec *codec, hda_nid_t nid)
1991 unsigned int def_conf;
1992 unsigned char seqassoc;
1994 def_conf = snd_hda_codec_get_pincfg(codec, nid);
1995 seqassoc = (unsigned char) get_defcfg_association(def_conf);
1996 seqassoc = (seqassoc << 4) | get_defcfg_sequence(def_conf);
1997 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE
1998 && (seqassoc == 0xf0 || seqassoc == 0xff)) {
1999 def_conf = def_conf & (~(AC_JACK_PORT_BOTH << 30));
2000 snd_hda_codec_set_pincfg(codec, nid, def_conf);
2006 static int vt1708_jack_detect_get(struct snd_kcontrol *kcontrol,
2007 struct snd_ctl_elem_value *ucontrol)
2009 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2010 struct via_spec *spec = codec->spec;
2012 if (spec->codec_type != VT1708)
2014 spec->vt1708_jack_detect =
2015 !((snd_hda_codec_read(codec, 0x1, 0, 0xf84, 0) >> 8) & 0x1);
2016 ucontrol->value.integer.value[0] = spec->vt1708_jack_detect;
2020 static int vt1708_jack_detect_put(struct snd_kcontrol *kcontrol,
2021 struct snd_ctl_elem_value *ucontrol)
2023 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2024 struct via_spec *spec = codec->spec;
2027 if (spec->codec_type != VT1708)
2029 spec->vt1708_jack_detect = ucontrol->value.integer.value[0];
2030 change = (0x1 & (snd_hda_codec_read(codec, 0x1, 0, 0xf84, 0) >> 8))
2031 == !spec->vt1708_jack_detect;
2032 if (spec->vt1708_jack_detect) {
2033 mute_aa_path(codec, 1);
2034 notify_aa_path_ctls(codec);
2039 static const struct snd_kcontrol_new vt1708_jack_detect_ctl = {
2040 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2041 .name = "Jack Detect",
2043 .info = snd_ctl_boolean_mono_info,
2044 .get = vt1708_jack_detect_get,
2045 .put = vt1708_jack_detect_put,
2048 static void fill_dig_outs(struct hda_codec *codec);
2049 static void fill_dig_in(struct hda_codec *codec);
2051 static int via_parse_auto_config(struct hda_codec *codec)
2053 struct via_spec *spec = codec->spec;
2056 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
2059 if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
2062 err = via_auto_create_multi_out_ctls(codec);
2065 err = via_auto_create_hp_ctls(codec, spec->autocfg.hp_pins[0]);
2068 err = via_auto_create_speaker_ctls(codec);
2071 err = via_auto_create_analog_input_ctls(codec, &spec->autocfg);
2075 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
2077 fill_dig_outs(codec);
2080 if (spec->kctls.list)
2081 spec->mixers[spec->num_mixers++] = spec->kctls.list;
2083 spec->init_verbs[spec->num_iverbs++] = vt1708_init_verbs;
2085 spec->input_mux = &spec->private_imux[0];
2087 if (spec->hp_dac_nid && spec->hp_dep_path.depth) {
2088 err = via_hp_build(codec);
2093 err = via_smart51_build(codec);
2097 /* assign slave outs */
2098 if (spec->slave_dig_outs[0])
2099 codec->slave_dig_outs = spec->slave_dig_outs;
2104 static void via_auto_init_dig_outs(struct hda_codec *codec)
2106 struct via_spec *spec = codec->spec;
2107 if (spec->multiout.dig_out_nid)
2108 init_output_pin(codec, spec->autocfg.dig_out_pins[0], PIN_OUT);
2109 if (spec->slave_dig_outs[0])
2110 init_output_pin(codec, spec->autocfg.dig_out_pins[1], PIN_OUT);
2113 static void via_auto_init_dig_in(struct hda_codec *codec)
2115 struct via_spec *spec = codec->spec;
2116 if (!spec->dig_in_nid)
2118 snd_hda_codec_write(codec, spec->autocfg.dig_in_pin, 0,
2119 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN);
2122 /* initialize the unsolicited events */
2123 static void via_auto_init_unsol_event(struct hda_codec *codec)
2125 struct via_spec *spec = codec->spec;
2126 struct auto_pin_cfg *cfg = &spec->autocfg;
2130 if (cfg->hp_pins[0] && is_jack_detectable(codec, cfg->hp_pins[0]))
2131 snd_hda_codec_write(codec, cfg->hp_pins[0], 0,
2132 AC_VERB_SET_UNSOLICITED_ENABLE,
2133 AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT);
2135 if (cfg->speaker_pins[0])
2136 ev = VIA_LINE_EVENT;
2139 for (i = 0; i < cfg->line_outs; i++) {
2140 if (cfg->line_out_pins[i] &&
2141 is_jack_detectable(codec, cfg->line_out_pins[i]))
2142 snd_hda_codec_write(codec, cfg->line_out_pins[0], 0,
2143 AC_VERB_SET_UNSOLICITED_ENABLE,
2144 AC_USRSP_EN | ev | VIA_JACK_EVENT);
2147 for (i = 0; i < cfg->num_inputs; i++) {
2148 if (is_jack_detectable(codec, cfg->inputs[i].pin))
2149 snd_hda_codec_write(codec, cfg->inputs[i].pin, 0,
2150 AC_VERB_SET_UNSOLICITED_ENABLE,
2151 AC_USRSP_EN | VIA_JACK_EVENT);
2155 static int via_init(struct hda_codec *codec)
2157 struct via_spec *spec = codec->spec;
2160 for (i = 0; i < spec->num_iverbs; i++)
2161 snd_hda_sequence_write(codec, spec->init_verbs[i]);
2163 via_auto_init_multi_out(codec);
2164 via_auto_init_hp_out(codec);
2165 via_auto_init_speaker_out(codec);
2166 via_auto_init_analog_input(codec);
2167 via_auto_init_dig_outs(codec);
2168 via_auto_init_dig_in(codec);
2170 via_auto_init_unsol_event(codec);
2172 via_hp_automute(codec);
2173 via_line_automute(codec, false);
2178 static void vt1708_update_hp_jack_state(struct work_struct *work)
2180 struct via_spec *spec = container_of(work, struct via_spec,
2181 vt1708_hp_work.work);
2182 if (spec->codec_type != VT1708)
2184 /* if jack state toggled */
2185 if (spec->vt1708_hp_present
2186 != snd_hda_jack_detect(spec->codec, spec->autocfg.hp_pins[0])) {
2187 spec->vt1708_hp_present ^= 1;
2188 via_hp_automute(spec->codec);
2190 vt1708_start_hp_work(spec);
2193 static int get_mux_nids(struct hda_codec *codec)
2195 struct via_spec *spec = codec->spec;
2196 hda_nid_t nid, conn[8];
2200 for (i = 0; i < spec->num_adc_nids; i++) {
2201 nid = spec->adc_nids[i];
2203 type = get_wcaps_type(get_wcaps(codec, nid));
2204 if (type == AC_WID_PIN)
2206 n = snd_hda_get_connections(codec, nid, conn,
2211 spec->mux_nids[i] = nid;
2220 static int patch_vt1708(struct hda_codec *codec)
2222 struct via_spec *spec;
2225 /* create a codec specific record */
2226 spec = via_new_spec(codec);
2230 spec->aa_mix_nid = 0x17;
2232 /* Add HP and CD pin config connect bit re-config action */
2233 vt1708_set_pinconfig_connect(codec, VT1708_HP_PIN_NID);
2234 vt1708_set_pinconfig_connect(codec, VT1708_CD_PIN_NID);
2236 /* automatic parse from the BIOS config */
2237 err = via_parse_auto_config(codec);
2243 /* add jack detect on/off control */
2244 if (!via_clone_control(spec, &vt1708_jack_detect_ctl))
2247 /* disable 32bit format on VT1708 */
2248 if (codec->vendor_id == 0x11061708)
2249 spec->stream_analog_playback = &vt1708_pcm_analog_s16_playback;
2251 codec->patch_ops = via_patch_ops;
2253 INIT_DELAYED_WORK(&spec->vt1708_hp_work, vt1708_update_hp_jack_state);
2257 static int patch_vt1709_10ch(struct hda_codec *codec)
2259 struct via_spec *spec;
2262 /* create a codec specific record */
2263 spec = via_new_spec(codec);
2267 spec->aa_mix_nid = 0x18;
2269 err = via_parse_auto_config(codec);
2275 codec->patch_ops = via_patch_ops;
2280 * generic initialization of ADC, input mixers and output mixers
2282 static int patch_vt1709_6ch(struct hda_codec *codec)
2284 struct via_spec *spec;
2287 /* create a codec specific record */
2288 spec = via_new_spec(codec);
2292 spec->aa_mix_nid = 0x18;
2294 err = via_parse_auto_config(codec);
2300 codec->patch_ops = via_patch_ops;
2305 static void set_widgets_power_state_vt1708B(struct hda_codec *codec)
2307 struct via_spec *spec = codec->spec;
2311 if ((spec->codec_type != VT1708B_4CH) &&
2312 (codec->vendor_id != 0x11064397))
2315 /* SW0 (17h) = stereo mixer */
2317 (snd_hda_codec_read(codec, 0x17, 0, AC_VERB_GET_CONNECT_SEL, 0x00)
2318 == ((spec->codec_type == VT1708S) ? 5 : 0));
2320 /* PW 1/2/5 (1ah/1bh/1eh) */
2322 set_pin_power_state(codec, 0x1a, &parm);
2323 set_pin_power_state(codec, 0x1b, &parm);
2324 set_pin_power_state(codec, 0x1e, &parm);
2327 /* SW0 (17h), AIW 0/1 (13h/14h) */
2328 snd_hda_codec_write(codec, 0x17, 0, AC_VERB_SET_POWER_STATE, parm);
2329 snd_hda_codec_write(codec, 0x13, 0, AC_VERB_SET_POWER_STATE, parm);
2330 snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_POWER_STATE, parm);
2333 /* PW0 (19h), SW1 (18h), AOW1 (11h) */
2335 set_pin_power_state(codec, 0x19, &parm);
2336 if (spec->smart51_enabled)
2337 set_pin_power_state(codec, 0x1b, &parm);
2338 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_POWER_STATE, parm);
2339 snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, parm);
2341 /* PW6 (22h), SW2 (26h), AOW2 (24h) */
2344 set_pin_power_state(codec, 0x22, &parm);
2345 if (spec->smart51_enabled)
2346 set_pin_power_state(codec, 0x1a, &parm);
2347 snd_hda_codec_write(codec, 0x26, 0,
2348 AC_VERB_SET_POWER_STATE, parm);
2349 snd_hda_codec_write(codec, 0x24, 0,
2350 AC_VERB_SET_POWER_STATE, parm);
2351 } else if (codec->vendor_id == 0x11064397) {
2352 /* PW7(23h), SW2(27h), AOW2(25h) */
2354 set_pin_power_state(codec, 0x23, &parm);
2355 if (spec->smart51_enabled)
2356 set_pin_power_state(codec, 0x1a, &parm);
2357 snd_hda_codec_write(codec, 0x27, 0,
2358 AC_VERB_SET_POWER_STATE, parm);
2359 snd_hda_codec_write(codec, 0x25, 0,
2360 AC_VERB_SET_POWER_STATE, parm);
2363 /* PW 3/4/7 (1ch/1dh/23h) */
2365 /* force to D0 for internal Speaker */
2366 set_pin_power_state(codec, 0x1c, &parm);
2367 set_pin_power_state(codec, 0x1d, &parm);
2369 set_pin_power_state(codec, 0x23, &parm);
2371 /* MW0 (16h), Sw3 (27h), AOW 0/3 (10h/25h) */
2372 snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_POWER_STATE,
2373 imux_is_smixer ? AC_PWRST_D0 : parm);
2374 snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, parm);
2376 snd_hda_codec_write(codec, 0x25, 0,
2377 AC_VERB_SET_POWER_STATE, parm);
2378 snd_hda_codec_write(codec, 0x27, 0,
2379 AC_VERB_SET_POWER_STATE, parm);
2380 } else if (codec->vendor_id == 0x11064397 && spec->hp_independent_mode)
2381 snd_hda_codec_write(codec, 0x25, 0,
2382 AC_VERB_SET_POWER_STATE, parm);
2385 static int patch_vt1708S(struct hda_codec *codec);
2386 static int patch_vt1708B_8ch(struct hda_codec *codec)
2388 struct via_spec *spec;
2391 if (get_codec_type(codec) == VT1708BCE)
2392 return patch_vt1708S(codec);
2393 /* create a codec specific record */
2394 spec = via_new_spec(codec);
2398 spec->aa_mix_nid = 0x16;
2400 /* automatic parse from the BIOS config */
2401 err = via_parse_auto_config(codec);
2407 codec->patch_ops = via_patch_ops;
2409 spec->set_widgets_power_state = set_widgets_power_state_vt1708B;
2414 static int patch_vt1708B_4ch(struct hda_codec *codec)
2416 struct via_spec *spec;
2419 /* create a codec specific record */
2420 spec = via_new_spec(codec);
2424 /* automatic parse from the BIOS config */
2425 err = via_parse_auto_config(codec);
2431 codec->patch_ops = via_patch_ops;
2433 spec->set_widgets_power_state = set_widgets_power_state_vt1708B;
2438 /* Patch for VT1708S */
2439 static const struct hda_verb vt1708S_init_verbs[] = {
2440 /* Enable Mic Boost Volume backdoor */
2442 /* don't bybass mixer */
2447 /* fill out digital output widgets; one for master and one for slave outputs */
2448 static void fill_dig_outs(struct hda_codec *codec)
2450 struct via_spec *spec = codec->spec;
2453 for (i = 0; i < spec->autocfg.dig_outs; i++) {
2457 nid = spec->autocfg.dig_out_pins[i];
2460 conn = snd_hda_get_connections(codec, nid, &nid, 1);
2463 if (!spec->multiout.dig_out_nid)
2464 spec->multiout.dig_out_nid = nid;
2466 spec->slave_dig_outs[0] = nid;
2467 break; /* at most two dig outs */
2472 static void fill_dig_in(struct hda_codec *codec)
2474 struct via_spec *spec = codec->spec;
2478 if (!spec->autocfg.dig_in_pin)
2481 dig_nid = codec->start_nid;
2482 for (i = 0; i < codec->num_nodes; i++, dig_nid++) {
2483 unsigned int wcaps = get_wcaps(codec, dig_nid);
2484 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
2486 if (!(wcaps & AC_WCAP_DIGITAL))
2488 if (!(wcaps & AC_WCAP_CONN_LIST))
2490 err = get_connection_index(codec, dig_nid,
2491 spec->autocfg.dig_in_pin);
2493 spec->dig_in_nid = dig_nid;
2499 static void override_mic_boost(struct hda_codec *codec, hda_nid_t pin,
2500 int offset, int num_steps, int step_size)
2502 snd_hda_override_amp_caps(codec, pin, HDA_INPUT,
2503 (offset << AC_AMPCAP_OFFSET_SHIFT) |
2504 (num_steps << AC_AMPCAP_NUM_STEPS_SHIFT) |
2505 (step_size << AC_AMPCAP_STEP_SIZE_SHIFT) |
2506 (0 << AC_AMPCAP_MUTE_SHIFT));
2509 static int patch_vt1708S(struct hda_codec *codec)
2511 struct via_spec *spec;
2514 /* create a codec specific record */
2515 spec = via_new_spec(codec);
2519 spec->aa_mix_nid = 0x16;
2520 override_mic_boost(codec, 0x1a, 0, 3, 40);
2521 override_mic_boost(codec, 0x1e, 0, 3, 40);
2523 /* automatic parse from the BIOS config */
2524 err = via_parse_auto_config(codec);
2530 spec->init_verbs[spec->num_iverbs++] = vt1708S_init_verbs;
2532 codec->patch_ops = via_patch_ops;
2534 /* correct names for VT1708BCE */
2535 if (get_codec_type(codec) == VT1708BCE) {
2536 kfree(codec->chip_name);
2537 codec->chip_name = kstrdup("VT1708BCE", GFP_KERNEL);
2538 snprintf(codec->bus->card->mixername,
2539 sizeof(codec->bus->card->mixername),
2540 "%s %s", codec->vendor_name, codec->chip_name);
2542 /* correct names for VT1705 */
2543 if (codec->vendor_id == 0x11064397) {
2544 kfree(codec->chip_name);
2545 codec->chip_name = kstrdup("VT1705", GFP_KERNEL);
2546 snprintf(codec->bus->card->mixername,
2547 sizeof(codec->bus->card->mixername),
2548 "%s %s", codec->vendor_name, codec->chip_name);
2550 spec->set_widgets_power_state = set_widgets_power_state_vt1708B;
2554 /* Patch for VT1702 */
2556 static const struct hda_verb vt1702_init_verbs[] = {
2564 static void set_widgets_power_state_vt1702(struct hda_codec *codec)
2566 int imux_is_smixer =
2567 snd_hda_codec_read(codec, 0x13, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 3;
2570 /* PW 1/2/5 (14h/15h/18h) */
2572 set_pin_power_state(codec, 0x14, &parm);
2573 set_pin_power_state(codec, 0x15, &parm);
2574 set_pin_power_state(codec, 0x18, &parm);
2576 parm = AC_PWRST_D0; /* SW0 (13h) = stereo mixer (idx 3) */
2577 /* SW0 (13h), AIW 0/1/2 (12h/1fh/20h) */
2578 snd_hda_codec_write(codec, 0x13, 0, AC_VERB_SET_POWER_STATE, parm);
2579 snd_hda_codec_write(codec, 0x12, 0, AC_VERB_SET_POWER_STATE, parm);
2580 snd_hda_codec_write(codec, 0x1f, 0, AC_VERB_SET_POWER_STATE, parm);
2581 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_POWER_STATE, parm);
2584 /* PW 3/4 (16h/17h) */
2586 set_pin_power_state(codec, 0x17, &parm);
2587 set_pin_power_state(codec, 0x16, &parm);
2588 /* MW0 (1ah), AOW 0/1 (10h/1dh) */
2589 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_POWER_STATE,
2590 imux_is_smixer ? AC_PWRST_D0 : parm);
2591 snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, parm);
2592 snd_hda_codec_write(codec, 0x1d, 0, AC_VERB_SET_POWER_STATE, parm);
2595 static int patch_vt1702(struct hda_codec *codec)
2597 struct via_spec *spec;
2600 /* create a codec specific record */
2601 spec = via_new_spec(codec);
2605 spec->aa_mix_nid = 0x1a;
2607 /* limit AA path volume to 0 dB */
2608 snd_hda_override_amp_caps(codec, 0x1A, HDA_INPUT,
2609 (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
2610 (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
2611 (0x5 << AC_AMPCAP_STEP_SIZE_SHIFT) |
2612 (1 << AC_AMPCAP_MUTE_SHIFT));
2614 /* automatic parse from the BIOS config */
2615 err = via_parse_auto_config(codec);
2621 spec->init_verbs[spec->num_iverbs++] = vt1702_init_verbs;
2623 codec->patch_ops = via_patch_ops;
2625 spec->set_widgets_power_state = set_widgets_power_state_vt1702;
2629 /* Patch for VT1718S */
2631 static const struct hda_verb vt1718S_init_verbs[] = {
2632 /* Enable MW0 adjust Gain 5 */
2634 /* Enable Boost Volume backdoor */
2640 static void set_widgets_power_state_vt1718S(struct hda_codec *codec)
2642 struct via_spec *spec = codec->spec;
2645 /* MUX6 (1eh) = stereo mixer */
2647 snd_hda_codec_read(codec, 0x1e, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 5;
2649 /* PW 5/6/7 (29h/2ah/2bh) */
2651 set_pin_power_state(codec, 0x29, &parm);
2652 set_pin_power_state(codec, 0x2a, &parm);
2653 set_pin_power_state(codec, 0x2b, &parm);
2656 /* MUX6/7 (1eh/1fh), AIW 0/1 (10h/11h) */
2657 snd_hda_codec_write(codec, 0x1e, 0, AC_VERB_SET_POWER_STATE, parm);
2658 snd_hda_codec_write(codec, 0x1f, 0, AC_VERB_SET_POWER_STATE, parm);
2659 snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, parm);
2660 snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, parm);
2663 /* PW3 (27h), MW2 (1ah), AOW3 (bh) */
2665 set_pin_power_state(codec, 0x27, &parm);
2666 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_POWER_STATE, parm);
2667 snd_hda_codec_write(codec, 0xb, 0, AC_VERB_SET_POWER_STATE, parm);
2669 /* PW2 (26h), AOW2 (ah) */
2671 set_pin_power_state(codec, 0x26, &parm);
2672 if (spec->smart51_enabled)
2673 set_pin_power_state(codec, 0x2b, &parm);
2674 snd_hda_codec_write(codec, 0xa, 0, AC_VERB_SET_POWER_STATE, parm);
2676 /* PW0 (24h), AOW0 (8h) */
2678 set_pin_power_state(codec, 0x24, &parm);
2679 if (!spec->hp_independent_mode) /* check for redirected HP */
2680 set_pin_power_state(codec, 0x28, &parm);
2681 snd_hda_codec_write(codec, 0x8, 0, AC_VERB_SET_POWER_STATE, parm);
2682 /* MW9 (21h), Mw2 (1ah), AOW0 (8h) */
2683 snd_hda_codec_write(codec, 0x21, 0, AC_VERB_SET_POWER_STATE,
2684 imux_is_smixer ? AC_PWRST_D0 : parm);
2686 /* PW1 (25h), AOW1 (9h) */
2688 set_pin_power_state(codec, 0x25, &parm);
2689 if (spec->smart51_enabled)
2690 set_pin_power_state(codec, 0x2a, &parm);
2691 snd_hda_codec_write(codec, 0x9, 0, AC_VERB_SET_POWER_STATE, parm);
2693 if (spec->hp_independent_mode) {
2694 /* PW4 (28h), MW3 (1bh), MUX1(34h), AOW4 (ch) */
2696 set_pin_power_state(codec, 0x28, &parm);
2697 snd_hda_codec_write(codec, 0x1b, 0,
2698 AC_VERB_SET_POWER_STATE, parm);
2699 snd_hda_codec_write(codec, 0x34, 0,
2700 AC_VERB_SET_POWER_STATE, parm);
2701 snd_hda_codec_write(codec, 0xc, 0,
2702 AC_VERB_SET_POWER_STATE, parm);
2706 static int patch_vt1718S(struct hda_codec *codec)
2708 struct via_spec *spec;
2711 /* create a codec specific record */
2712 spec = via_new_spec(codec);
2716 spec->aa_mix_nid = 0x21;
2717 override_mic_boost(codec, 0x2b, 0, 3, 40);
2718 override_mic_boost(codec, 0x29, 0, 3, 40);
2720 /* automatic parse from the BIOS config */
2721 err = via_parse_auto_config(codec);
2727 spec->init_verbs[spec->num_iverbs++] = vt1718S_init_verbs;
2729 codec->patch_ops = via_patch_ops;
2731 spec->set_widgets_power_state = set_widgets_power_state_vt1718S;
2736 /* Patch for VT1716S */
2738 static int vt1716s_dmic_info(struct snd_kcontrol *kcontrol,
2739 struct snd_ctl_elem_info *uinfo)
2741 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2743 uinfo->value.integer.min = 0;
2744 uinfo->value.integer.max = 1;
2748 static int vt1716s_dmic_get(struct snd_kcontrol *kcontrol,
2749 struct snd_ctl_elem_value *ucontrol)
2751 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2754 index = snd_hda_codec_read(codec, 0x26, 0,
2755 AC_VERB_GET_CONNECT_SEL, 0);
2757 *ucontrol->value.integer.value = index;
2762 static int vt1716s_dmic_put(struct snd_kcontrol *kcontrol,
2763 struct snd_ctl_elem_value *ucontrol)
2765 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2766 struct via_spec *spec = codec->spec;
2767 int index = *ucontrol->value.integer.value;
2769 snd_hda_codec_write(codec, 0x26, 0,
2770 AC_VERB_SET_CONNECT_SEL, index);
2771 spec->dmic_enabled = index;
2772 set_widgets_power_state(codec);
2776 static const struct snd_kcontrol_new vt1716s_dmic_mixer[] = {
2777 HDA_CODEC_VOLUME("Digital Mic Capture Volume", 0x22, 0x0, HDA_INPUT),
2779 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2780 .name = "Digital Mic Capture Switch",
2781 .subdevice = HDA_SUBDEV_NID_FLAG | 0x26,
2783 .info = vt1716s_dmic_info,
2784 .get = vt1716s_dmic_get,
2785 .put = vt1716s_dmic_put,
2791 /* mono-out mixer elements */
2792 static const struct snd_kcontrol_new vt1716S_mono_out_mixer[] = {
2793 HDA_CODEC_MUTE("Mono Playback Switch", 0x2a, 0x0, HDA_OUTPUT),
2797 static const struct hda_verb vt1716S_init_verbs[] = {
2798 /* Enable Boost Volume backdoor */
2800 /* don't bybass mixer */
2802 /* Enable mono output */
2807 static void set_widgets_power_state_vt1716S(struct hda_codec *codec)
2809 struct via_spec *spec = codec->spec;
2812 unsigned int mono_out, present;
2813 /* SW0 (17h) = stereo mixer */
2815 (snd_hda_codec_read(codec, 0x17, 0,
2816 AC_VERB_GET_CONNECT_SEL, 0x00) == 5);
2818 /* PW 1/2/5 (1ah/1bh/1eh) */
2820 set_pin_power_state(codec, 0x1a, &parm);
2821 set_pin_power_state(codec, 0x1b, &parm);
2822 set_pin_power_state(codec, 0x1e, &parm);
2825 /* SW0 (17h), AIW0(13h) */
2826 snd_hda_codec_write(codec, 0x17, 0, AC_VERB_SET_POWER_STATE, parm);
2827 snd_hda_codec_write(codec, 0x13, 0, AC_VERB_SET_POWER_STATE, parm);
2830 set_pin_power_state(codec, 0x1e, &parm);
2832 if (spec->dmic_enabled)
2833 set_pin_power_state(codec, 0x22, &parm);
2835 snd_hda_codec_write(codec, 0x22, 0,
2836 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
2838 /* SW2(26h), AIW1(14h) */
2839 snd_hda_codec_write(codec, 0x26, 0, AC_VERB_SET_POWER_STATE, parm);
2840 snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_POWER_STATE, parm);
2843 /* PW0 (19h), SW1 (18h), AOW1 (11h) */
2845 set_pin_power_state(codec, 0x19, &parm);
2846 /* Smart 5.1 PW2(1bh) */
2847 if (spec->smart51_enabled)
2848 set_pin_power_state(codec, 0x1b, &parm);
2849 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_POWER_STATE, parm);
2850 snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, parm);
2852 /* PW7 (23h), SW3 (27h), AOW3 (25h) */
2854 set_pin_power_state(codec, 0x23, &parm);
2855 /* Smart 5.1 PW1(1ah) */
2856 if (spec->smart51_enabled)
2857 set_pin_power_state(codec, 0x1a, &parm);
2858 snd_hda_codec_write(codec, 0x27, 0, AC_VERB_SET_POWER_STATE, parm);
2860 /* Smart 5.1 PW5(1eh) */
2861 if (spec->smart51_enabled)
2862 set_pin_power_state(codec, 0x1e, &parm);
2863 snd_hda_codec_write(codec, 0x25, 0, AC_VERB_SET_POWER_STATE, parm);
2866 /* SW4(28h)->MW1(29h)-> PW12 (2ah)*/
2867 present = snd_hda_jack_detect(codec, 0x1c);
2872 present = snd_hda_jack_detect(codec, 0x1d);
2873 if (!spec->hp_independent_mode && present)
2878 parm = mono_out ? AC_PWRST_D0 : AC_PWRST_D3;
2879 snd_hda_codec_write(codec, 0x28, 0, AC_VERB_SET_POWER_STATE, parm);
2880 snd_hda_codec_write(codec, 0x29, 0, AC_VERB_SET_POWER_STATE, parm);
2881 snd_hda_codec_write(codec, 0x2a, 0, AC_VERB_SET_POWER_STATE, parm);
2883 /* PW 3/4 (1ch/1dh) */
2885 set_pin_power_state(codec, 0x1c, &parm);
2886 set_pin_power_state(codec, 0x1d, &parm);
2887 /* HP Independent Mode, power on AOW3 */
2888 if (spec->hp_independent_mode)
2889 snd_hda_codec_write(codec, 0x25, 0,
2890 AC_VERB_SET_POWER_STATE, parm);
2892 /* force to D0 for internal Speaker */
2893 /* MW0 (16h), AOW0 (10h) */
2894 snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_POWER_STATE,
2895 imux_is_smixer ? AC_PWRST_D0 : parm);
2896 snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE,
2897 mono_out ? AC_PWRST_D0 : parm);
2900 static int patch_vt1716S(struct hda_codec *codec)
2902 struct via_spec *spec;
2905 /* create a codec specific record */
2906 spec = via_new_spec(codec);
2910 spec->aa_mix_nid = 0x16;
2911 override_mic_boost(codec, 0x1a, 0, 3, 40);
2912 override_mic_boost(codec, 0x1e, 0, 3, 40);
2914 /* automatic parse from the BIOS config */
2915 err = via_parse_auto_config(codec);
2921 spec->init_verbs[spec->num_iverbs++] = vt1716S_init_verbs;
2923 spec->mixers[spec->num_mixers] = vt1716s_dmic_mixer;
2926 spec->mixers[spec->num_mixers++] = vt1716S_mono_out_mixer;
2928 codec->patch_ops = via_patch_ops;
2930 spec->set_widgets_power_state = set_widgets_power_state_vt1716S;
2936 static const struct hda_verb vt2002P_init_verbs[] = {
2937 /* Class-D speaker related verbs */
2941 /* Enable Boost Volume backdoor */
2943 /* Enable AOW0 to MW9 */
2948 static const struct hda_verb vt1802_init_verbs[] = {
2949 /* Enable Boost Volume backdoor */
2951 /* Enable AOW0 to MW9 */
2956 static void set_widgets_power_state_vt2002P(struct hda_codec *codec)
2958 struct via_spec *spec = codec->spec;
2961 unsigned int present;
2962 /* MUX9 (1eh) = stereo mixer */
2964 snd_hda_codec_read(codec, 0x1e, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 3;
2966 /* PW 5/6/7 (29h/2ah/2bh) */
2968 set_pin_power_state(codec, 0x29, &parm);
2969 set_pin_power_state(codec, 0x2a, &parm);
2970 set_pin_power_state(codec, 0x2b, &parm);
2972 /* MUX9/10 (1eh/1fh), AIW 0/1 (10h/11h) */
2973 snd_hda_codec_write(codec, 0x1e, 0, AC_VERB_SET_POWER_STATE, parm);
2974 snd_hda_codec_write(codec, 0x1f, 0, AC_VERB_SET_POWER_STATE, parm);
2975 snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, parm);
2976 snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, parm);
2980 snd_hda_codec_write(codec, 0x8, 0, AC_VERB_SET_POWER_STATE, parm);
2982 if (spec->codec_type == VT1802) {
2983 /* PW4 (28h), MW4 (18h), MUX4(38h) */
2985 set_pin_power_state(codec, 0x28, &parm);
2986 snd_hda_codec_write(codec, 0x18, 0,
2987 AC_VERB_SET_POWER_STATE, parm);
2988 snd_hda_codec_write(codec, 0x38, 0,
2989 AC_VERB_SET_POWER_STATE, parm);
2991 /* PW4 (26h), MW4 (1ch), MUX4(37h) */
2993 set_pin_power_state(codec, 0x26, &parm);
2994 snd_hda_codec_write(codec, 0x1c, 0,
2995 AC_VERB_SET_POWER_STATE, parm);
2996 snd_hda_codec_write(codec, 0x37, 0,
2997 AC_VERB_SET_POWER_STATE, parm);
3000 if (spec->codec_type == VT1802) {
3001 /* PW1 (25h), MW1 (15h), MUX1(35h), AOW1 (9h) */
3003 set_pin_power_state(codec, 0x25, &parm);
3004 snd_hda_codec_write(codec, 0x15, 0,
3005 AC_VERB_SET_POWER_STATE, parm);
3006 snd_hda_codec_write(codec, 0x35, 0,
3007 AC_VERB_SET_POWER_STATE, parm);
3009 /* PW1 (25h), MW1 (19h), MUX1(35h), AOW1 (9h) */
3011 set_pin_power_state(codec, 0x25, &parm);
3012 snd_hda_codec_write(codec, 0x19, 0,
3013 AC_VERB_SET_POWER_STATE, parm);
3014 snd_hda_codec_write(codec, 0x35, 0,
3015 AC_VERB_SET_POWER_STATE, parm);
3018 if (spec->hp_independent_mode)
3019 snd_hda_codec_write(codec, 0x9, 0,
3020 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3023 /* PW0 (24h), MW0(18h/14h), MUX0(34h) */
3024 present = snd_hda_jack_detect(codec, 0x25);
3027 set_pin_power_state(codec, 0x24, &parm);
3028 parm = present ? AC_PWRST_D3 : AC_PWRST_D0;
3029 if (spec->codec_type == VT1802)
3030 snd_hda_codec_write(codec, 0x14, 0,
3031 AC_VERB_SET_POWER_STATE, parm);
3033 snd_hda_codec_write(codec, 0x18, 0,
3034 AC_VERB_SET_POWER_STATE, parm);
3035 snd_hda_codec_write(codec, 0x34, 0, AC_VERB_SET_POWER_STATE, parm);
3038 present = snd_hda_jack_detect(codec, 0x26);
3040 parm = present ? AC_PWRST_D3 : AC_PWRST_D0;
3041 if (spec->codec_type == VT1802) {
3042 /* PW15 (33h), MW8(1ch), MUX8(3ch) */
3043 snd_hda_codec_write(codec, 0x33, 0,
3044 AC_VERB_SET_POWER_STATE, parm);
3045 snd_hda_codec_write(codec, 0x1c, 0,
3046 AC_VERB_SET_POWER_STATE, parm);
3047 snd_hda_codec_write(codec, 0x3c, 0,
3048 AC_VERB_SET_POWER_STATE, parm);
3050 /* PW15 (31h), MW8(17h), MUX8(3bh) */
3051 snd_hda_codec_write(codec, 0x31, 0,
3052 AC_VERB_SET_POWER_STATE, parm);
3053 snd_hda_codec_write(codec, 0x17, 0,
3054 AC_VERB_SET_POWER_STATE, parm);
3055 snd_hda_codec_write(codec, 0x3b, 0,
3056 AC_VERB_SET_POWER_STATE, parm);
3059 if (imux_is_smixer || !is_aa_path_mute(codec))
3060 snd_hda_codec_write(codec, 0x21, 0,
3061 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3063 snd_hda_codec_write(codec, 0x21, 0,
3064 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3067 /* patch for vt2002P */
3068 static int patch_vt2002P(struct hda_codec *codec)
3070 struct via_spec *spec;
3073 /* create a codec specific record */
3074 spec = via_new_spec(codec);
3078 spec->aa_mix_nid = 0x21;
3079 override_mic_boost(codec, 0x2b, 0, 3, 40);
3080 override_mic_boost(codec, 0x29, 0, 3, 40);
3082 /* automatic parse from the BIOS config */
3083 err = via_parse_auto_config(codec);
3089 if (spec->codec_type == VT1802)
3090 spec->init_verbs[spec->num_iverbs++] = vt1802_init_verbs;
3092 spec->init_verbs[spec->num_iverbs++] = vt2002P_init_verbs;
3094 codec->patch_ops = via_patch_ops;
3096 spec->set_widgets_power_state = set_widgets_power_state_vt2002P;
3102 static const struct hda_verb vt1812_init_verbs[] = {
3103 /* Enable Boost Volume backdoor */
3105 /* Enable AOW0 to MW9 */
3110 static void set_widgets_power_state_vt1812(struct hda_codec *codec)
3112 struct via_spec *spec = codec->spec;
3113 int imux_is_smixer =
3114 snd_hda_codec_read(codec, 0x13, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 3;
3116 unsigned int present;
3117 /* MUX10 (1eh) = stereo mixer */
3119 snd_hda_codec_read(codec, 0x1e, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 5;
3121 /* PW 5/6/7 (29h/2ah/2bh) */
3123 set_pin_power_state(codec, 0x29, &parm);
3124 set_pin_power_state(codec, 0x2a, &parm);
3125 set_pin_power_state(codec, 0x2b, &parm);
3127 /* MUX10/11 (1eh/1fh), AIW 0/1 (10h/11h) */
3128 snd_hda_codec_write(codec, 0x1e, 0, AC_VERB_SET_POWER_STATE, parm);
3129 snd_hda_codec_write(codec, 0x1f, 0, AC_VERB_SET_POWER_STATE, parm);
3130 snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, parm);
3131 snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, parm);
3135 snd_hda_codec_write(codec, 0x8, 0,
3136 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3138 /* PW4 (28h), MW4 (18h), MUX4(38h) */
3140 set_pin_power_state(codec, 0x28, &parm);
3141 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_POWER_STATE, parm);
3142 snd_hda_codec_write(codec, 0x38, 0, AC_VERB_SET_POWER_STATE, parm);
3144 /* PW1 (25h), MW1 (15h), MUX1(35h), AOW1 (9h) */
3146 set_pin_power_state(codec, 0x25, &parm);
3147 snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_POWER_STATE, parm);
3148 snd_hda_codec_write(codec, 0x35, 0, AC_VERB_SET_POWER_STATE, parm);
3149 if (spec->hp_independent_mode)
3150 snd_hda_codec_write(codec, 0x9, 0,
3151 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3153 /* Internal Speaker */
3154 /* PW0 (24h), MW0(14h), MUX0(34h) */
3155 present = snd_hda_jack_detect(codec, 0x25);
3158 set_pin_power_state(codec, 0x24, &parm);
3160 snd_hda_codec_write(codec, 0x14, 0,
3161 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3162 snd_hda_codec_write(codec, 0x34, 0,
3163 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3165 snd_hda_codec_write(codec, 0x14, 0,
3166 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3167 snd_hda_codec_write(codec, 0x34, 0,
3168 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3173 /* PW13 (31h), MW13(1ch), MUX13(3ch), MW14(3eh) */
3174 present = snd_hda_jack_detect(codec, 0x28);
3177 set_pin_power_state(codec, 0x31, &parm);
3179 snd_hda_codec_write(codec, 0x1c, 0,
3180 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3181 snd_hda_codec_write(codec, 0x3c, 0,
3182 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3183 snd_hda_codec_write(codec, 0x3e, 0,
3184 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3186 snd_hda_codec_write(codec, 0x1c, 0,
3187 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3188 snd_hda_codec_write(codec, 0x3c, 0,
3189 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3190 snd_hda_codec_write(codec, 0x3e, 0,
3191 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3194 /* PW15 (33h), MW15 (1dh), MUX15(3dh) */
3196 set_pin_power_state(codec, 0x33, &parm);
3197 snd_hda_codec_write(codec, 0x1d, 0, AC_VERB_SET_POWER_STATE, parm);
3198 snd_hda_codec_write(codec, 0x3d, 0, AC_VERB_SET_POWER_STATE, parm);
3202 /* patch for vt1812 */
3203 static int patch_vt1812(struct hda_codec *codec)
3205 struct via_spec *spec;
3208 /* create a codec specific record */
3209 spec = via_new_spec(codec);
3213 spec->aa_mix_nid = 0x21;
3214 override_mic_boost(codec, 0x2b, 0, 3, 40);
3215 override_mic_boost(codec, 0x29, 0, 3, 40);
3217 /* automatic parse from the BIOS config */
3218 err = via_parse_auto_config(codec);
3224 spec->init_verbs[spec->num_iverbs++] = vt1812_init_verbs;
3226 codec->patch_ops = via_patch_ops;
3228 spec->set_widgets_power_state = set_widgets_power_state_vt1812;
3235 static const struct hda_codec_preset snd_hda_preset_via[] = {
3236 { .id = 0x11061708, .name = "VT1708", .patch = patch_vt1708},
3237 { .id = 0x11061709, .name = "VT1708", .patch = patch_vt1708},
3238 { .id = 0x1106170a, .name = "VT1708", .patch = patch_vt1708},
3239 { .id = 0x1106170b, .name = "VT1708", .patch = patch_vt1708},
3240 { .id = 0x1106e710, .name = "VT1709 10-Ch",
3241 .patch = patch_vt1709_10ch},
3242 { .id = 0x1106e711, .name = "VT1709 10-Ch",
3243 .patch = patch_vt1709_10ch},
3244 { .id = 0x1106e712, .name = "VT1709 10-Ch",
3245 .patch = patch_vt1709_10ch},
3246 { .id = 0x1106e713, .name = "VT1709 10-Ch",
3247 .patch = patch_vt1709_10ch},
3248 { .id = 0x1106e714, .name = "VT1709 6-Ch",
3249 .patch = patch_vt1709_6ch},
3250 { .id = 0x1106e715, .name = "VT1709 6-Ch",
3251 .patch = patch_vt1709_6ch},
3252 { .id = 0x1106e716, .name = "VT1709 6-Ch",
3253 .patch = patch_vt1709_6ch},
3254 { .id = 0x1106e717, .name = "VT1709 6-Ch",
3255 .patch = patch_vt1709_6ch},
3256 { .id = 0x1106e720, .name = "VT1708B 8-Ch",
3257 .patch = patch_vt1708B_8ch},
3258 { .id = 0x1106e721, .name = "VT1708B 8-Ch",
3259 .patch = patch_vt1708B_8ch},
3260 { .id = 0x1106e722, .name = "VT1708B 8-Ch",
3261 .patch = patch_vt1708B_8ch},
3262 { .id = 0x1106e723, .name = "VT1708B 8-Ch",
3263 .patch = patch_vt1708B_8ch},
3264 { .id = 0x1106e724, .name = "VT1708B 4-Ch",
3265 .patch = patch_vt1708B_4ch},
3266 { .id = 0x1106e725, .name = "VT1708B 4-Ch",
3267 .patch = patch_vt1708B_4ch},
3268 { .id = 0x1106e726, .name = "VT1708B 4-Ch",
3269 .patch = patch_vt1708B_4ch},
3270 { .id = 0x1106e727, .name = "VT1708B 4-Ch",
3271 .patch = patch_vt1708B_4ch},
3272 { .id = 0x11060397, .name = "VT1708S",
3273 .patch = patch_vt1708S},
3274 { .id = 0x11061397, .name = "VT1708S",
3275 .patch = patch_vt1708S},
3276 { .id = 0x11062397, .name = "VT1708S",
3277 .patch = patch_vt1708S},
3278 { .id = 0x11063397, .name = "VT1708S",
3279 .patch = patch_vt1708S},
3280 { .id = 0x11064397, .name = "VT1705",
3281 .patch = patch_vt1708S},
3282 { .id = 0x11065397, .name = "VT1708S",
3283 .patch = patch_vt1708S},
3284 { .id = 0x11066397, .name = "VT1708S",
3285 .patch = patch_vt1708S},
3286 { .id = 0x11067397, .name = "VT1708S",
3287 .patch = patch_vt1708S},
3288 { .id = 0x11060398, .name = "VT1702",
3289 .patch = patch_vt1702},
3290 { .id = 0x11061398, .name = "VT1702",
3291 .patch = patch_vt1702},
3292 { .id = 0x11062398, .name = "VT1702",
3293 .patch = patch_vt1702},
3294 { .id = 0x11063398, .name = "VT1702",
3295 .patch = patch_vt1702},
3296 { .id = 0x11064398, .name = "VT1702",
3297 .patch = patch_vt1702},
3298 { .id = 0x11065398, .name = "VT1702",
3299 .patch = patch_vt1702},
3300 { .id = 0x11066398, .name = "VT1702",
3301 .patch = patch_vt1702},
3302 { .id = 0x11067398, .name = "VT1702",
3303 .patch = patch_vt1702},
3304 { .id = 0x11060428, .name = "VT1718S",
3305 .patch = patch_vt1718S},
3306 { .id = 0x11064428, .name = "VT1718S",
3307 .patch = patch_vt1718S},
3308 { .id = 0x11060441, .name = "VT2020",
3309 .patch = patch_vt1718S},
3310 { .id = 0x11064441, .name = "VT1828S",
3311 .patch = patch_vt1718S},
3312 { .id = 0x11060433, .name = "VT1716S",
3313 .patch = patch_vt1716S},
3314 { .id = 0x1106a721, .name = "VT1716S",
3315 .patch = patch_vt1716S},
3316 { .id = 0x11060438, .name = "VT2002P", .patch = patch_vt2002P},
3317 { .id = 0x11064438, .name = "VT2002P", .patch = patch_vt2002P},
3318 { .id = 0x11060448, .name = "VT1812", .patch = patch_vt1812},
3319 { .id = 0x11060440, .name = "VT1818S",
3320 .patch = patch_vt1708S},
3321 { .id = 0x11060446, .name = "VT1802",
3322 .patch = patch_vt2002P},
3323 { .id = 0x11068446, .name = "VT1802",
3324 .patch = patch_vt2002P},
3328 MODULE_ALIAS("snd-hda-codec-id:1106*");
3330 static struct hda_codec_preset_list via_list = {
3331 .preset = snd_hda_preset_via,
3332 .owner = THIS_MODULE,
3335 MODULE_LICENSE("GPL");
3336 MODULE_DESCRIPTION("VIA HD-audio codec");
3338 static int __init patch_via_init(void)
3340 return snd_hda_add_codec_preset(&via_list);
3343 static void __exit patch_via_exit(void)
3345 snd_hda_delete_codec_preset(&via_list);
3348 module_init(patch_via_init)
3349 module_exit(patch_via_exit)