2 * Universal Interface for Intel High Definition Audio Codec
4 * HD audio interface patch for VIA VT1702/VT1708/VT1709 codec
6 * Copyright (c) 2006-2008 Lydia Wang <lydiawang@viatech.com>
7 * 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 */
40 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
43 #include <linux/init.h>
44 #include <linux/delay.h>
45 #include <linux/slab.h>
46 #include <sound/core.h>
47 #include <sound/asoundef.h>
48 #include "hda_codec.h"
49 #include "hda_local.h"
52 #define AMP_VAL_IDX_SHIFT 19
53 #define AMP_VAL_IDX_MASK (0x0f<<19)
56 #define VT1708_HP_NID 0x13
57 #define VT1708_DIGOUT_NID 0x14
58 #define VT1708_DIGIN_NID 0x16
59 #define VT1708_DIGIN_PIN 0x26
60 #define VT1708_HP_PIN_NID 0x20
61 #define VT1708_CD_PIN_NID 0x24
63 #define VT1709_HP_DAC_NID 0x28
64 #define VT1709_DIGOUT_NID 0x13
65 #define VT1709_DIGIN_NID 0x17
66 #define VT1709_DIGIN_PIN 0x25
68 #define VT1708B_HP_NID 0x25
69 #define VT1708B_DIGOUT_NID 0x12
70 #define VT1708B_DIGIN_NID 0x15
71 #define VT1708B_DIGIN_PIN 0x21
73 #define VT1708S_HP_NID 0x25
74 #define VT1708S_DIGOUT_NID 0x12
76 #define VT1702_HP_NID 0x17
77 #define VT1702_DIGOUT_NID 0x11
79 #define IS_VT1708_VENDORID(x) ((x) >= 0x11061708 && (x) <= 0x1106170b)
80 #define IS_VT1709_10CH_VENDORID(x) ((x) >= 0x1106e710 && (x) <= 0x1106e713)
81 #define IS_VT1709_6CH_VENDORID(x) ((x) >= 0x1106e714 && (x) <= 0x1106e717)
82 #define IS_VT1708B_8CH_VENDORID(x) ((x) >= 0x1106e720 && (x) <= 0x1106e723)
83 #define IS_VT1708B_4CH_VENDORID(x) ((x) >= 0x1106e724 && (x) <= 0x1106e727)
84 #define IS_VT1708S_VENDORID(x) ((x) >= 0x11060397 && (x) <= 0x11067397)
85 #define IS_VT1702_VENDORID(x) ((x) >= 0x11060398 && (x) <= 0x11067398)
99 static enum VIA_HDA_CODEC get_codec_type(u32 vendor_id)
101 u16 ven_id = vendor_id >> 16;
102 u16 dev_id = vendor_id & 0xffff;
103 enum VIA_HDA_CODEC codec_type;
106 if (ven_id != 0x1106)
107 codec_type = UNKNOWN;
108 else if (dev_id >= 0x1708 && dev_id <= 0x170b)
110 else if (dev_id >= 0xe710 && dev_id <= 0xe713)
111 codec_type = VT1709_10CH;
112 else if (dev_id >= 0xe714 && dev_id <= 0xe717)
113 codec_type = VT1709_6CH;
114 else if (dev_id >= 0xe720 && dev_id <= 0xe723)
115 codec_type = VT1708B_8CH;
116 else if (dev_id >= 0xe724 && dev_id <= 0xe727)
117 codec_type = VT1708B_4CH;
118 else if ((dev_id & 0xfff) == 0x397
119 && (dev_id >> 12) < 8)
120 codec_type = VT1708S;
121 else if ((dev_id & 0xfff) == 0x398
122 && (dev_id >> 12) < 8)
125 codec_type = UNKNOWN;
129 #define VIA_HP_EVENT 0x01
130 #define VIA_GPIO_EVENT 0x02
144 /* Some VT1708S based boards gets the micboost setting wrong, so we have
145 * to apply some brute-force and re-write the TLV's by software. */
146 static int mic_boost_tlv(struct snd_kcontrol *kcontrol, int op_flag,
147 unsigned int size, unsigned int __user *_tlv)
149 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
150 hda_nid_t nid = get_amp_nid(kcontrol);
152 if (get_codec_type(codec->vendor_id) == VT1708S
153 && (nid == 0x1a || nid == 0x1e)) {
154 if (size < 4 * sizeof(unsigned int))
156 if (put_user(1, _tlv)) /* SNDRV_CTL_TLVT_DB_SCALE */
158 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
160 if (put_user(0, _tlv + 2)) /* offset = 0 */
162 if (put_user(1000, _tlv + 3)) /* step size = 10 dB */
168 static int mic_boost_volume_info(struct snd_kcontrol *kcontrol,
169 struct snd_ctl_elem_info *uinfo)
171 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
172 hda_nid_t nid = get_amp_nid(kcontrol);
174 if (get_codec_type(codec->vendor_id) == VT1708S
175 && (nid == 0x1a || nid == 0x1e)) {
176 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
178 uinfo->value.integer.min = 0;
179 uinfo->value.integer.max = 3;
184 static struct snd_kcontrol_new vt1708_control_templates[] = {
185 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
186 HDA_CODEC_MUTE(NULL, 0, 0, 0),
191 /* codec parameterization */
192 struct snd_kcontrol_new *mixers[3];
193 unsigned int num_mixers;
195 struct hda_verb *init_verbs[5];
196 unsigned int num_iverbs;
198 char *stream_name_analog;
199 struct hda_pcm_stream *stream_analog_playback;
200 struct hda_pcm_stream *stream_analog_capture;
202 char *stream_name_digital;
203 struct hda_pcm_stream *stream_digital_playback;
204 struct hda_pcm_stream *stream_digital_capture;
207 struct hda_multi_out multiout;
208 hda_nid_t slave_dig_outs[2];
211 unsigned int num_adc_nids;
213 hda_nid_t mux_nids[3];
214 hda_nid_t dig_in_nid;
215 hda_nid_t dig_in_pin;
218 const struct hda_input_mux *input_mux;
219 unsigned int cur_mux[3];
221 /* PCM information */
222 struct hda_pcm pcm_rec[3];
224 /* dynamic controls, init_verbs and input_mux */
225 struct auto_pin_cfg autocfg;
226 struct snd_array kctls;
227 struct hda_input_mux private_imux[2];
228 hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
231 const struct hda_input_mux *hp_mux;
232 unsigned int hp_independent_mode;
234 #ifdef CONFIG_SND_HDA_POWER_SAVE
235 struct hda_loopback_check loopback;
239 static hda_nid_t vt1708_adc_nids[2] = {
244 static hda_nid_t vt1709_adc_nids[3] = {
249 static hda_nid_t vt1708B_adc_nids[2] = {
254 static hda_nid_t vt1708S_adc_nids[2] = {
259 static hda_nid_t vt1702_adc_nids[3] = {
264 /* add dynamic controls */
265 static int via_add_control(struct via_spec *spec, int type, const char *name,
268 struct snd_kcontrol_new *knew;
270 snd_array_init(&spec->kctls, sizeof(*knew), 32);
271 knew = snd_array_new(&spec->kctls);
274 *knew = vt1708_control_templates[type];
275 knew->name = kstrdup(name, GFP_KERNEL);
278 knew->private_value = val;
282 static void via_free_kctls(struct hda_codec *codec)
284 struct via_spec *spec = codec->spec;
286 if (spec->kctls.list) {
287 struct snd_kcontrol_new *kctl = spec->kctls.list;
289 for (i = 0; i < spec->kctls.used; i++)
292 snd_array_free(&spec->kctls);
295 /* create input playback/capture controls for the given pin */
296 static int via_new_analog_input(struct via_spec *spec, hda_nid_t pin,
297 const char *ctlname, int idx, int mix_nid)
302 sprintf(name, "%s Playback Volume", ctlname);
303 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
304 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
307 sprintf(name, "%s Playback Switch", ctlname);
308 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
309 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
315 static void via_auto_set_output_and_unmute(struct hda_codec *codec,
316 hda_nid_t nid, int pin_type,
320 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
322 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
324 if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
325 snd_hda_codec_write(codec, nid, 0,
326 AC_VERB_SET_EAPD_BTLENABLE, 0x02);
330 static void via_auto_init_multi_out(struct hda_codec *codec)
332 struct via_spec *spec = codec->spec;
335 for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
336 hda_nid_t nid = spec->autocfg.line_out_pins[i];
338 via_auto_set_output_and_unmute(codec, nid, PIN_OUT, i);
342 static void via_auto_init_hp_out(struct hda_codec *codec)
344 struct via_spec *spec = codec->spec;
347 pin = spec->autocfg.hp_pins[0];
348 if (pin) /* connect to front */
349 via_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
352 static void via_auto_init_analog_input(struct hda_codec *codec)
354 struct via_spec *spec = codec->spec;
357 for (i = 0; i < AUTO_PIN_LAST; i++) {
358 hda_nid_t nid = spec->autocfg.input_pins[i];
360 snd_hda_codec_write(codec, nid, 0,
361 AC_VERB_SET_PIN_WIDGET_CONTROL,
362 (i <= AUTO_PIN_FRONT_MIC ?
363 PIN_VREF50 : PIN_IN));
370 static int via_mux_enum_info(struct snd_kcontrol *kcontrol,
371 struct snd_ctl_elem_info *uinfo)
373 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
374 struct via_spec *spec = codec->spec;
375 return snd_hda_input_mux_info(spec->input_mux, uinfo);
378 static int via_mux_enum_get(struct snd_kcontrol *kcontrol,
379 struct snd_ctl_elem_value *ucontrol)
381 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
382 struct via_spec *spec = codec->spec;
383 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
385 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
389 static int via_mux_enum_put(struct snd_kcontrol *kcontrol,
390 struct snd_ctl_elem_value *ucontrol)
392 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
393 struct via_spec *spec = codec->spec;
394 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
396 if (!spec->mux_nids[adc_idx])
398 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
399 spec->mux_nids[adc_idx],
400 &spec->cur_mux[adc_idx]);
403 static int via_independent_hp_info(struct snd_kcontrol *kcontrol,
404 struct snd_ctl_elem_info *uinfo)
406 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
407 struct via_spec *spec = codec->spec;
408 return snd_hda_input_mux_info(spec->hp_mux, uinfo);
411 static int via_independent_hp_get(struct snd_kcontrol *kcontrol,
412 struct snd_ctl_elem_value *ucontrol)
414 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
415 struct via_spec *spec = codec->spec;
416 hda_nid_t nid = spec->autocfg.hp_pins[0];
417 unsigned int pinsel = snd_hda_codec_read(codec, nid, 0,
418 AC_VERB_GET_CONNECT_SEL,
421 ucontrol->value.enumerated.item[0] = pinsel;
426 static int via_independent_hp_put(struct snd_kcontrol *kcontrol,
427 struct snd_ctl_elem_value *ucontrol)
429 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
430 struct via_spec *spec = codec->spec;
431 hda_nid_t nid = spec->autocfg.hp_pins[0];
432 unsigned int pinsel = ucontrol->value.enumerated.item[0];
433 unsigned int con_nid = snd_hda_codec_read(codec, nid, 0,
434 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
436 if (con_nid == spec->multiout.hp_nid) {
438 if (!spec->hp_independent_mode) {
439 if (spec->multiout.num_dacs > 1)
440 spec->multiout.num_dacs -= 1;
441 spec->hp_independent_mode = 1;
443 } else if (pinsel == 1) {
444 if (spec->hp_independent_mode) {
445 if (spec->multiout.num_dacs > 1)
446 spec->multiout.num_dacs += 1;
447 spec->hp_independent_mode = 0;
452 if (spec->hp_independent_mode) {
453 if (spec->multiout.num_dacs > 1)
454 spec->multiout.num_dacs += 1;
455 spec->hp_independent_mode = 0;
457 } else if (pinsel == 1) {
458 if (!spec->hp_independent_mode) {
459 if (spec->multiout.num_dacs > 1)
460 spec->multiout.num_dacs -= 1;
461 spec->hp_independent_mode = 1;
465 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
468 if (spec->multiout.hp_nid &&
469 spec->multiout.hp_nid != spec->multiout.dac_nids[HDA_FRONT])
470 snd_hda_codec_setup_stream(codec,
471 spec->multiout.hp_nid,
477 static struct snd_kcontrol_new via_hp_mixer[] = {
479 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
480 .name = "Independent HP",
482 .info = via_independent_hp_info,
483 .get = via_independent_hp_get,
484 .put = via_independent_hp_put,
489 /* capture mixer elements */
490 static struct snd_kcontrol_new vt1708_capture_mixer[] = {
491 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_INPUT),
492 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_INPUT),
493 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x27, 0x0, HDA_INPUT),
494 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x27, 0x0, HDA_INPUT),
496 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
497 /* The multiple "Capture Source" controls confuse alsamixer
498 * So call somewhat different..
500 /* .name = "Capture Source", */
501 .name = "Input Source",
503 .info = via_mux_enum_info,
504 .get = via_mux_enum_get,
505 .put = via_mux_enum_put,
510 * generic initialization of ADC, input mixers and output mixers
512 static struct hda_verb vt1708_volume_init_verbs[] = {
514 * Unmute ADC0-1 and set the default input to mic-in
516 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
517 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
520 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
523 /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
524 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
525 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
526 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
527 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
528 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
531 * Set up output mixers (0x19 - 0x1b)
533 /* set vol=0 to output mixers */
534 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
535 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
536 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
538 /* Setup default input to PW4 */
539 {0x20, AC_VERB_SET_CONNECT_SEL, 0x1},
540 /* PW9 Output enable */
541 {0x25, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
545 static int via_playback_pcm_open(struct hda_pcm_stream *hinfo,
546 struct hda_codec *codec,
547 struct snd_pcm_substream *substream)
549 struct via_spec *spec = codec->spec;
550 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
554 static int via_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
555 struct hda_codec *codec,
556 unsigned int stream_tag,
558 struct snd_pcm_substream *substream)
560 struct via_spec *spec = codec->spec;
561 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
562 stream_tag, format, substream);
565 static int via_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
566 struct hda_codec *codec,
567 struct snd_pcm_substream *substream)
569 struct via_spec *spec = codec->spec;
570 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
574 static void playback_multi_pcm_prep_0(struct hda_codec *codec,
575 unsigned int stream_tag,
577 struct snd_pcm_substream *substream)
579 struct via_spec *spec = codec->spec;
580 struct hda_multi_out *mout = &spec->multiout;
581 hda_nid_t *nids = mout->dac_nids;
582 int chs = substream->runtime->channels;
585 mutex_lock(&codec->spdif_mutex);
586 if (mout->dig_out_nid && mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
588 snd_hda_is_supported_format(codec, mout->dig_out_nid,
590 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
591 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
592 /* turn off SPDIF once; otherwise the IEC958 bits won't
594 if (codec->spdif_ctls & AC_DIG1_ENABLE)
595 snd_hda_codec_write(codec, mout->dig_out_nid, 0,
596 AC_VERB_SET_DIGI_CONVERT_1,
598 ~AC_DIG1_ENABLE & 0xff);
599 snd_hda_codec_setup_stream(codec, mout->dig_out_nid,
600 stream_tag, 0, format);
601 /* turn on again (if needed) */
602 if (codec->spdif_ctls & AC_DIG1_ENABLE)
603 snd_hda_codec_write(codec, mout->dig_out_nid, 0,
604 AC_VERB_SET_DIGI_CONVERT_1,
605 codec->spdif_ctls & 0xff);
607 mout->dig_out_used = 0;
608 snd_hda_codec_setup_stream(codec, mout->dig_out_nid,
612 mutex_unlock(&codec->spdif_mutex);
615 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
618 if (mout->hp_nid && mout->hp_nid != nids[HDA_FRONT] &&
619 !spec->hp_independent_mode)
620 /* headphone out will just decode front left/right (stereo) */
621 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
624 /* extra outputs copied from front */
625 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
626 if (mout->extra_out_nid[i])
627 snd_hda_codec_setup_stream(codec,
628 mout->extra_out_nid[i],
629 stream_tag, 0, format);
632 for (i = 1; i < mout->num_dacs; i++) {
633 if (chs >= (i + 1) * 2) /* independent out */
634 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
636 else /* copy front */
637 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
642 static int via_playback_multi_pcm_prepare(struct hda_pcm_stream *hinfo,
643 struct hda_codec *codec,
644 unsigned int stream_tag,
646 struct snd_pcm_substream *substream)
648 struct via_spec *spec = codec->spec;
649 struct hda_multi_out *mout = &spec->multiout;
650 hda_nid_t *nids = mout->dac_nids;
652 if (substream->number == 0)
653 playback_multi_pcm_prep_0(codec, stream_tag, format,
656 if (mout->hp_nid && mout->hp_nid != nids[HDA_FRONT] &&
657 spec->hp_independent_mode)
658 snd_hda_codec_setup_stream(codec, mout->hp_nid,
659 stream_tag, 0, format);
665 static int via_playback_multi_pcm_cleanup(struct hda_pcm_stream *hinfo,
666 struct hda_codec *codec,
667 struct snd_pcm_substream *substream)
669 struct via_spec *spec = codec->spec;
670 struct hda_multi_out *mout = &spec->multiout;
671 hda_nid_t *nids = mout->dac_nids;
674 if (substream->number == 0) {
675 for (i = 0; i < mout->num_dacs; i++)
676 snd_hda_codec_setup_stream(codec, nids[i], 0, 0, 0);
678 if (mout->hp_nid && !spec->hp_independent_mode)
679 snd_hda_codec_setup_stream(codec, mout->hp_nid,
682 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
683 if (mout->extra_out_nid[i])
684 snd_hda_codec_setup_stream(codec,
685 mout->extra_out_nid[i],
687 mutex_lock(&codec->spdif_mutex);
688 if (mout->dig_out_nid &&
689 mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
690 snd_hda_codec_setup_stream(codec, mout->dig_out_nid,
692 mout->dig_out_used = 0;
694 mutex_unlock(&codec->spdif_mutex);
696 if (mout->hp_nid && mout->hp_nid != nids[HDA_FRONT] &&
697 spec->hp_independent_mode)
698 snd_hda_codec_setup_stream(codec, mout->hp_nid,
708 static int via_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
709 struct hda_codec *codec,
710 struct snd_pcm_substream *substream)
712 struct via_spec *spec = codec->spec;
713 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
716 static int via_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
717 struct hda_codec *codec,
718 struct snd_pcm_substream *substream)
720 struct via_spec *spec = codec->spec;
721 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
724 static int via_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
725 struct hda_codec *codec,
726 unsigned int stream_tag,
728 struct snd_pcm_substream *substream)
730 struct via_spec *spec = codec->spec;
731 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
732 stream_tag, format, substream);
735 static int via_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
736 struct hda_codec *codec,
737 struct snd_pcm_substream *substream)
739 struct via_spec *spec = codec->spec;
740 snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
747 static int via_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
748 struct hda_codec *codec,
749 unsigned int stream_tag,
751 struct snd_pcm_substream *substream)
753 struct via_spec *spec = codec->spec;
755 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
756 stream_tag, 0, format);
760 static int via_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
761 struct hda_codec *codec,
762 struct snd_pcm_substream *substream)
764 struct via_spec *spec = codec->spec;
765 snd_hda_codec_cleanup_stream(codec, spec->adc_nids[substream->number]);
769 static struct hda_pcm_stream vt1708_pcm_analog_playback = {
773 .nid = 0x10, /* NID to query formats and rates */
775 .open = via_playback_pcm_open,
776 .prepare = via_playback_multi_pcm_prepare,
777 .cleanup = via_playback_multi_pcm_cleanup
781 static struct hda_pcm_stream vt1708_pcm_analog_s16_playback = {
785 .nid = 0x10, /* NID to query formats and rates */
786 /* We got noisy outputs on the right channel on VT1708 when
787 * 24bit samples are used. Until any workaround is found,
788 * disable the 24bit format, so far.
790 .formats = SNDRV_PCM_FMTBIT_S16_LE,
792 .open = via_playback_pcm_open,
793 .prepare = via_playback_pcm_prepare,
794 .cleanup = via_playback_pcm_cleanup
798 static struct hda_pcm_stream vt1708_pcm_analog_capture = {
802 .nid = 0x15, /* NID to query formats and rates */
804 .prepare = via_capture_pcm_prepare,
805 .cleanup = via_capture_pcm_cleanup
809 static struct hda_pcm_stream vt1708_pcm_digital_playback = {
813 /* NID is set in via_build_pcms */
815 .open = via_dig_playback_pcm_open,
816 .close = via_dig_playback_pcm_close,
817 .prepare = via_dig_playback_pcm_prepare,
818 .cleanup = via_dig_playback_pcm_cleanup
822 static struct hda_pcm_stream vt1708_pcm_digital_capture = {
828 static int via_build_controls(struct hda_codec *codec)
830 struct via_spec *spec = codec->spec;
834 for (i = 0; i < spec->num_mixers; i++) {
835 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
840 if (spec->multiout.dig_out_nid) {
841 err = snd_hda_create_spdif_out_ctls(codec,
842 spec->multiout.dig_out_nid);
845 err = snd_hda_create_spdif_share_sw(codec,
849 spec->multiout.share_spdif = 1;
851 if (spec->dig_in_nid) {
852 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
856 via_free_kctls(codec); /* no longer needed */
860 static int via_build_pcms(struct hda_codec *codec)
862 struct via_spec *spec = codec->spec;
863 struct hda_pcm *info = spec->pcm_rec;
866 codec->pcm_info = info;
868 info->name = spec->stream_name_analog;
869 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
870 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
871 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
872 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
874 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
875 spec->multiout.max_channels;
877 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
880 info->name = spec->stream_name_digital;
881 info->pcm_type = HDA_PCM_TYPE_SPDIF;
882 if (spec->multiout.dig_out_nid) {
883 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
884 *(spec->stream_digital_playback);
885 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
886 spec->multiout.dig_out_nid;
888 if (spec->dig_in_nid) {
889 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
890 *(spec->stream_digital_capture);
891 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
899 static void via_free(struct hda_codec *codec)
901 struct via_spec *spec = codec->spec;
906 via_free_kctls(codec);
910 /* mute internal speaker if HP is plugged */
911 static void via_hp_automute(struct hda_codec *codec)
913 unsigned int present;
914 struct via_spec *spec = codec->spec;
916 present = snd_hda_codec_read(codec, spec->autocfg.hp_pins[0], 0,
917 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
918 snd_hda_codec_amp_stereo(codec, spec->autocfg.line_out_pins[0],
919 HDA_OUTPUT, 0, HDA_AMP_MUTE,
920 present ? HDA_AMP_MUTE : 0);
923 static void via_gpio_control(struct hda_codec *codec)
925 unsigned int gpio_data;
926 unsigned int vol_counter;
928 unsigned int master_vol;
930 struct via_spec *spec = codec->spec;
932 gpio_data = snd_hda_codec_read(codec, codec->afg, 0,
933 AC_VERB_GET_GPIO_DATA, 0) & 0x03;
935 vol_counter = (snd_hda_codec_read(codec, codec->afg, 0,
936 0xF84, 0) & 0x3F0000) >> 16;
938 vol = vol_counter & 0x1F;
939 master_vol = snd_hda_codec_read(codec, 0x1A, 0,
940 AC_VERB_GET_AMP_GAIN_MUTE,
943 if (gpio_data == 0x02) {
944 /* unmute line out */
945 snd_hda_codec_amp_stereo(codec, spec->autocfg.line_out_pins[0],
946 HDA_OUTPUT, 0, HDA_AMP_MUTE, 0);
948 if (vol_counter & 0x20) {
949 /* decrease volume */
950 if (vol > master_vol)
952 snd_hda_codec_amp_stereo(codec, 0x1A, HDA_INPUT,
956 /* increase volume */
957 snd_hda_codec_amp_stereo(codec, 0x1A, HDA_INPUT, 0,
959 ((master_vol+vol) > 0x2A) ? 0x2A :
962 } else if (!(gpio_data & 0x02)) {
964 snd_hda_codec_amp_stereo(codec,
965 spec->autocfg.line_out_pins[0],
966 HDA_OUTPUT, 0, HDA_AMP_MUTE,
971 /* unsolicited event for jack sensing */
972 static void via_unsol_event(struct hda_codec *codec,
976 if (res == VIA_HP_EVENT)
977 via_hp_automute(codec);
978 else if (res == VIA_GPIO_EVENT)
979 via_gpio_control(codec);
982 static int via_init(struct hda_codec *codec)
984 struct via_spec *spec = codec->spec;
986 for (i = 0; i < spec->num_iverbs; i++)
987 snd_hda_sequence_write(codec, spec->init_verbs[i]);
989 /* Lydia Add for EAPD enable */
990 if (!spec->dig_in_nid) { /* No Digital In connection */
991 if (spec->dig_in_pin) {
992 snd_hda_codec_write(codec, spec->dig_in_pin, 0,
993 AC_VERB_SET_PIN_WIDGET_CONTROL,
995 snd_hda_codec_write(codec, spec->dig_in_pin, 0,
996 AC_VERB_SET_EAPD_BTLENABLE, 0x02);
998 } else /* enable SPDIF-input pin */
999 snd_hda_codec_write(codec, spec->autocfg.dig_in_pin, 0,
1000 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN);
1002 /* assign slave outs */
1003 if (spec->slave_dig_outs[0])
1004 codec->slave_dig_outs = spec->slave_dig_outs;
1009 #ifdef CONFIG_SND_HDA_POWER_SAVE
1010 static int via_check_power_status(struct hda_codec *codec, hda_nid_t nid)
1012 struct via_spec *spec = codec->spec;
1013 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
1019 static struct hda_codec_ops via_patch_ops = {
1020 .build_controls = via_build_controls,
1021 .build_pcms = via_build_pcms,
1024 #ifdef CONFIG_SND_HDA_POWER_SAVE
1025 .check_power_status = via_check_power_status,
1029 /* fill in the dac_nids table from the parsed pin configuration */
1030 static int vt1708_auto_fill_dac_nids(struct via_spec *spec,
1031 const struct auto_pin_cfg *cfg)
1036 spec->multiout.num_dacs = cfg->line_outs;
1038 spec->multiout.dac_nids = spec->private_dac_nids;
1040 for(i = 0; i < 4; i++) {
1041 nid = cfg->line_out_pins[i];
1043 /* config dac list */
1045 case AUTO_SEQ_FRONT:
1046 spec->multiout.dac_nids[i] = 0x10;
1048 case AUTO_SEQ_CENLFE:
1049 spec->multiout.dac_nids[i] = 0x12;
1051 case AUTO_SEQ_SURROUND:
1052 spec->multiout.dac_nids[i] = 0x11;
1055 spec->multiout.dac_nids[i] = 0x13;
1064 /* add playback controls from the parsed DAC table */
1065 static int vt1708_auto_create_multi_out_ctls(struct via_spec *spec,
1066 const struct auto_pin_cfg *cfg)
1069 static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" };
1070 hda_nid_t nid, nid_vol = 0;
1073 for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
1074 nid = cfg->line_out_pins[i];
1079 if (i != AUTO_SEQ_FRONT)
1082 if (i == AUTO_SEQ_CENLFE) {
1084 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1085 "Center Playback Volume",
1086 HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
1090 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1091 "LFE Playback Volume",
1092 HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
1096 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1097 "Center Playback Switch",
1098 HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
1102 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1103 "LFE Playback Switch",
1104 HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
1108 } else if (i == AUTO_SEQ_FRONT){
1109 /* add control to mixer index 0 */
1110 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1111 "Master Front Playback Volume",
1112 HDA_COMPOSE_AMP_VAL(0x17, 3, 0,
1116 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1117 "Master Front Playback Switch",
1118 HDA_COMPOSE_AMP_VAL(0x17, 3, 0,
1123 /* add control to PW3 */
1124 sprintf(name, "%s Playback Volume", chname[i]);
1125 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
1126 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
1130 sprintf(name, "%s Playback Switch", chname[i]);
1131 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
1132 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
1137 sprintf(name, "%s Playback Volume", chname[i]);
1138 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
1139 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
1143 sprintf(name, "%s Playback Switch", chname[i]);
1144 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
1145 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
1155 static void create_hp_imux(struct via_spec *spec)
1158 struct hda_input_mux *imux = &spec->private_imux[1];
1159 static const char *texts[] = { "OFF", "ON", NULL};
1161 /* for hp mode select */
1163 while (texts[i] != NULL) {
1164 imux->items[imux->num_items].label = texts[i];
1165 imux->items[imux->num_items].index = i;
1170 spec->hp_mux = &spec->private_imux[1];
1173 static int vt1708_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
1180 spec->multiout.hp_nid = VT1708_HP_NID; /* AOW3 */
1182 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1183 "Headphone Playback Volume",
1184 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
1187 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1188 "Headphone Playback Switch",
1189 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
1193 create_hp_imux(spec);
1198 /* create playback/capture controls for input pins */
1199 static int vt1708_auto_create_analog_input_ctls(struct via_spec *spec,
1200 const struct auto_pin_cfg *cfg)
1202 static char *labels[] = {
1203 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
1205 struct hda_input_mux *imux = &spec->private_imux[0];
1206 int i, err, idx = 0;
1208 /* for internal loopback recording select */
1209 imux->items[imux->num_items].label = "Stereo Mixer";
1210 imux->items[imux->num_items].index = idx;
1213 for (i = 0; i < AUTO_PIN_LAST; i++) {
1214 if (!cfg->input_pins[i])
1217 switch (cfg->input_pins[i]) {
1218 case 0x1d: /* Mic */
1222 case 0x1e: /* Line In */
1226 case 0x21: /* Front Mic */
1234 err = via_new_analog_input(spec, cfg->input_pins[i], labels[i],
1238 imux->items[imux->num_items].label = labels[i];
1239 imux->items[imux->num_items].index = idx;
1245 #ifdef CONFIG_SND_HDA_POWER_SAVE
1246 static struct hda_amp_list vt1708_loopbacks[] = {
1247 { 0x17, HDA_INPUT, 1 },
1248 { 0x17, HDA_INPUT, 2 },
1249 { 0x17, HDA_INPUT, 3 },
1250 { 0x17, HDA_INPUT, 4 },
1255 static void vt1708_set_pinconfig_connect(struct hda_codec *codec, hda_nid_t nid)
1257 unsigned int def_conf;
1258 unsigned char seqassoc;
1260 def_conf = snd_hda_codec_get_pincfg(codec, nid);
1261 seqassoc = (unsigned char) get_defcfg_association(def_conf);
1262 seqassoc = (seqassoc << 4) | get_defcfg_sequence(def_conf);
1263 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE) {
1264 if (seqassoc == 0xff) {
1265 def_conf = def_conf & (~(AC_JACK_PORT_BOTH << 30));
1266 snd_hda_codec_set_pincfg(codec, nid, def_conf);
1273 static int vt1708_parse_auto_config(struct hda_codec *codec)
1275 struct via_spec *spec = codec->spec;
1278 /* Add HP and CD pin config connect bit re-config action */
1279 vt1708_set_pinconfig_connect(codec, VT1708_HP_PIN_NID);
1280 vt1708_set_pinconfig_connect(codec, VT1708_CD_PIN_NID);
1282 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
1285 err = vt1708_auto_fill_dac_nids(spec, &spec->autocfg);
1288 if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
1289 return 0; /* can't find valid BIOS pin config */
1291 err = vt1708_auto_create_multi_out_ctls(spec, &spec->autocfg);
1294 err = vt1708_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
1297 err = vt1708_auto_create_analog_input_ctls(spec, &spec->autocfg);
1301 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
1303 if (spec->autocfg.dig_outs)
1304 spec->multiout.dig_out_nid = VT1708_DIGOUT_NID;
1305 spec->dig_in_pin = VT1708_DIGIN_PIN;
1306 if (spec->autocfg.dig_in_pin)
1307 spec->dig_in_nid = VT1708_DIGIN_NID;
1309 if (spec->kctls.list)
1310 spec->mixers[spec->num_mixers++] = spec->kctls.list;
1312 spec->init_verbs[spec->num_iverbs++] = vt1708_volume_init_verbs;
1314 spec->input_mux = &spec->private_imux[0];
1317 spec->mixers[spec->num_mixers++] = via_hp_mixer;
1322 /* init callback for auto-configuration model -- overriding the default init */
1323 static int via_auto_init(struct hda_codec *codec)
1326 via_auto_init_multi_out(codec);
1327 via_auto_init_hp_out(codec);
1328 via_auto_init_analog_input(codec);
1332 static int get_mux_nids(struct hda_codec *codec)
1334 struct via_spec *spec = codec->spec;
1335 hda_nid_t nid, conn[8];
1339 for (i = 0; i < spec->num_adc_nids; i++) {
1340 nid = spec->adc_nids[i];
1342 type = get_wcaps_type(get_wcaps(codec, nid));
1343 if (type == AC_WID_PIN)
1345 n = snd_hda_get_connections(codec, nid, conn,
1350 spec->mux_nids[i] = nid;
1359 static int patch_vt1708(struct hda_codec *codec)
1361 struct via_spec *spec;
1364 /* create a codec specific record */
1365 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1371 /* automatic parse from the BIOS config */
1372 err = vt1708_parse_auto_config(codec);
1377 printk(KERN_INFO "hda_codec: Cannot set up configuration "
1378 "from BIOS. Using genenic mode...\n");
1382 spec->stream_name_analog = "VT1708 Analog";
1383 spec->stream_analog_playback = &vt1708_pcm_analog_playback;
1384 /* disable 32bit format on VT1708 */
1385 if (codec->vendor_id == 0x11061708)
1386 spec->stream_analog_playback = &vt1708_pcm_analog_s16_playback;
1387 spec->stream_analog_capture = &vt1708_pcm_analog_capture;
1389 spec->stream_name_digital = "VT1708 Digital";
1390 spec->stream_digital_playback = &vt1708_pcm_digital_playback;
1391 spec->stream_digital_capture = &vt1708_pcm_digital_capture;
1394 if (!spec->adc_nids && spec->input_mux) {
1395 spec->adc_nids = vt1708_adc_nids;
1396 spec->num_adc_nids = ARRAY_SIZE(vt1708_adc_nids);
1397 spec->mixers[spec->num_mixers] = vt1708_capture_mixer;
1401 codec->patch_ops = via_patch_ops;
1403 codec->patch_ops.init = via_auto_init;
1404 #ifdef CONFIG_SND_HDA_POWER_SAVE
1405 spec->loopback.amplist = vt1708_loopbacks;
1411 /* capture mixer elements */
1412 static struct snd_kcontrol_new vt1709_capture_mixer[] = {
1413 HDA_CODEC_VOLUME("Capture Volume", 0x14, 0x0, HDA_INPUT),
1414 HDA_CODEC_MUTE("Capture Switch", 0x14, 0x0, HDA_INPUT),
1415 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x15, 0x0, HDA_INPUT),
1416 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x15, 0x0, HDA_INPUT),
1417 HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x16, 0x0, HDA_INPUT),
1418 HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x16, 0x0, HDA_INPUT),
1420 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1421 /* The multiple "Capture Source" controls confuse alsamixer
1422 * So call somewhat different..
1424 /* .name = "Capture Source", */
1425 .name = "Input Source",
1427 .info = via_mux_enum_info,
1428 .get = via_mux_enum_get,
1429 .put = via_mux_enum_put,
1434 static struct hda_verb vt1709_uniwill_init_verbs[] = {
1435 {0x20, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_HP_EVENT},
1440 * generic initialization of ADC, input mixers and output mixers
1442 static struct hda_verb vt1709_10ch_volume_init_verbs[] = {
1444 * Unmute ADC0-2 and set the default input to mic-in
1446 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1447 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1448 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1451 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
1454 /* Amp Indices: AOW0=0, CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
1455 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1456 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1457 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
1458 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
1459 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
1462 * Set up output selector (0x1a, 0x1b, 0x29)
1464 /* set vol=0 to output mixers */
1465 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1466 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1467 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1470 * Unmute PW3 and PW4
1472 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1473 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1475 /* Set input of PW4 as AOW4 */
1476 {0x20, AC_VERB_SET_CONNECT_SEL, 0x1},
1477 /* PW9 Output enable */
1478 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
1482 static struct hda_pcm_stream vt1709_10ch_pcm_analog_playback = {
1486 .nid = 0x10, /* NID to query formats and rates */
1488 .open = via_playback_pcm_open,
1489 .prepare = via_playback_pcm_prepare,
1490 .cleanup = via_playback_pcm_cleanup
1494 static struct hda_pcm_stream vt1709_6ch_pcm_analog_playback = {
1498 .nid = 0x10, /* NID to query formats and rates */
1500 .open = via_playback_pcm_open,
1501 .prepare = via_playback_pcm_prepare,
1502 .cleanup = via_playback_pcm_cleanup
1506 static struct hda_pcm_stream vt1709_pcm_analog_capture = {
1510 .nid = 0x14, /* NID to query formats and rates */
1512 .prepare = via_capture_pcm_prepare,
1513 .cleanup = via_capture_pcm_cleanup
1517 static struct hda_pcm_stream vt1709_pcm_digital_playback = {
1521 /* NID is set in via_build_pcms */
1523 .open = via_dig_playback_pcm_open,
1524 .close = via_dig_playback_pcm_close
1528 static struct hda_pcm_stream vt1709_pcm_digital_capture = {
1534 static int vt1709_auto_fill_dac_nids(struct via_spec *spec,
1535 const struct auto_pin_cfg *cfg)
1540 if (cfg->line_outs == 4) /* 10 channels */
1541 spec->multiout.num_dacs = cfg->line_outs+1; /* AOW0~AOW4 */
1542 else if (cfg->line_outs == 3) /* 6 channels */
1543 spec->multiout.num_dacs = cfg->line_outs; /* AOW0~AOW2 */
1545 spec->multiout.dac_nids = spec->private_dac_nids;
1547 if (cfg->line_outs == 4) { /* 10 channels */
1548 for (i = 0; i < cfg->line_outs; i++) {
1549 nid = cfg->line_out_pins[i];
1551 /* config dac list */
1553 case AUTO_SEQ_FRONT:
1555 spec->multiout.dac_nids[i] = 0x10;
1557 case AUTO_SEQ_CENLFE:
1559 spec->multiout.dac_nids[i] = 0x12;
1561 case AUTO_SEQ_SURROUND:
1563 spec->multiout.dac_nids[i] = 0x11;
1567 spec->multiout.dac_nids[i] = 0x27;
1574 spec->multiout.dac_nids[cfg->line_outs] = 0x28; /* AOW4 */
1576 } else if (cfg->line_outs == 3) { /* 6 channels */
1577 for(i = 0; i < cfg->line_outs; i++) {
1578 nid = cfg->line_out_pins[i];
1580 /* config dac list */
1582 case AUTO_SEQ_FRONT:
1584 spec->multiout.dac_nids[i] = 0x10;
1586 case AUTO_SEQ_CENLFE:
1588 spec->multiout.dac_nids[i] = 0x12;
1590 case AUTO_SEQ_SURROUND:
1592 spec->multiout.dac_nids[i] = 0x11;
1604 /* add playback controls from the parsed DAC table */
1605 static int vt1709_auto_create_multi_out_ctls(struct via_spec *spec,
1606 const struct auto_pin_cfg *cfg)
1609 static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" };
1613 for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
1614 nid = cfg->line_out_pins[i];
1619 if (i == AUTO_SEQ_CENLFE) {
1621 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1622 "Center Playback Volume",
1623 HDA_COMPOSE_AMP_VAL(0x1b, 1, 0,
1627 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1628 "LFE Playback Volume",
1629 HDA_COMPOSE_AMP_VAL(0x1b, 2, 0,
1633 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1634 "Center Playback Switch",
1635 HDA_COMPOSE_AMP_VAL(0x1b, 1, 0,
1639 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1640 "LFE Playback Switch",
1641 HDA_COMPOSE_AMP_VAL(0x1b, 2, 0,
1645 } else if (i == AUTO_SEQ_FRONT){
1646 /* add control to mixer index 0 */
1647 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1648 "Master Front Playback Volume",
1649 HDA_COMPOSE_AMP_VAL(0x18, 3, 0,
1653 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1654 "Master Front Playback Switch",
1655 HDA_COMPOSE_AMP_VAL(0x18, 3, 0,
1660 /* add control to PW3 */
1661 sprintf(name, "%s Playback Volume", chname[i]);
1662 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
1663 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
1667 sprintf(name, "%s Playback Switch", chname[i]);
1668 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
1669 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
1673 } else if (i == AUTO_SEQ_SURROUND) {
1674 sprintf(name, "%s Playback Volume", chname[i]);
1675 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
1676 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0,
1680 sprintf(name, "%s Playback Switch", chname[i]);
1681 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
1682 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0,
1686 } else if (i == AUTO_SEQ_SIDE) {
1687 sprintf(name, "%s Playback Volume", chname[i]);
1688 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
1689 HDA_COMPOSE_AMP_VAL(0x29, 3, 0,
1693 sprintf(name, "%s Playback Switch", chname[i]);
1694 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
1695 HDA_COMPOSE_AMP_VAL(0x29, 3, 0,
1705 static int vt1709_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
1712 if (spec->multiout.num_dacs == 5) /* 10 channels */
1713 spec->multiout.hp_nid = VT1709_HP_DAC_NID;
1714 else if (spec->multiout.num_dacs == 3) /* 6 channels */
1715 spec->multiout.hp_nid = 0;
1717 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1718 "Headphone Playback Volume",
1719 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
1722 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1723 "Headphone Playback Switch",
1724 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
1731 /* create playback/capture controls for input pins */
1732 static int vt1709_auto_create_analog_input_ctls(struct via_spec *spec,
1733 const struct auto_pin_cfg *cfg)
1735 static char *labels[] = {
1736 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
1738 struct hda_input_mux *imux = &spec->private_imux[0];
1739 int i, err, idx = 0;
1741 /* for internal loopback recording select */
1742 imux->items[imux->num_items].label = "Stereo Mixer";
1743 imux->items[imux->num_items].index = idx;
1746 for (i = 0; i < AUTO_PIN_LAST; i++) {
1747 if (!cfg->input_pins[i])
1750 switch (cfg->input_pins[i]) {
1751 case 0x1d: /* Mic */
1755 case 0x1e: /* Line In */
1759 case 0x21: /* Front Mic */
1767 err = via_new_analog_input(spec, cfg->input_pins[i], labels[i],
1771 imux->items[imux->num_items].label = labels[i];
1772 imux->items[imux->num_items].index = idx;
1778 static int vt1709_parse_auto_config(struct hda_codec *codec)
1780 struct via_spec *spec = codec->spec;
1783 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
1786 err = vt1709_auto_fill_dac_nids(spec, &spec->autocfg);
1789 if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
1790 return 0; /* can't find valid BIOS pin config */
1792 err = vt1709_auto_create_multi_out_ctls(spec, &spec->autocfg);
1795 err = vt1709_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
1798 err = vt1709_auto_create_analog_input_ctls(spec, &spec->autocfg);
1802 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
1804 if (spec->autocfg.dig_outs)
1805 spec->multiout.dig_out_nid = VT1709_DIGOUT_NID;
1806 spec->dig_in_pin = VT1709_DIGIN_PIN;
1807 if (spec->autocfg.dig_in_pin)
1808 spec->dig_in_nid = VT1709_DIGIN_NID;
1810 if (spec->kctls.list)
1811 spec->mixers[spec->num_mixers++] = spec->kctls.list;
1813 spec->input_mux = &spec->private_imux[0];
1816 spec->mixers[spec->num_mixers++] = via_hp_mixer;
1821 #ifdef CONFIG_SND_HDA_POWER_SAVE
1822 static struct hda_amp_list vt1709_loopbacks[] = {
1823 { 0x18, HDA_INPUT, 1 },
1824 { 0x18, HDA_INPUT, 2 },
1825 { 0x18, HDA_INPUT, 3 },
1826 { 0x18, HDA_INPUT, 4 },
1831 static int patch_vt1709_10ch(struct hda_codec *codec)
1833 struct via_spec *spec;
1836 /* create a codec specific record */
1837 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1843 err = vt1709_parse_auto_config(codec);
1848 printk(KERN_INFO "hda_codec: Cannot set up configuration. "
1849 "Using genenic mode...\n");
1852 spec->init_verbs[spec->num_iverbs++] = vt1709_10ch_volume_init_verbs;
1853 spec->init_verbs[spec->num_iverbs++] = vt1709_uniwill_init_verbs;
1855 spec->stream_name_analog = "VT1709 Analog";
1856 spec->stream_analog_playback = &vt1709_10ch_pcm_analog_playback;
1857 spec->stream_analog_capture = &vt1709_pcm_analog_capture;
1859 spec->stream_name_digital = "VT1709 Digital";
1860 spec->stream_digital_playback = &vt1709_pcm_digital_playback;
1861 spec->stream_digital_capture = &vt1709_pcm_digital_capture;
1864 if (!spec->adc_nids && spec->input_mux) {
1865 spec->adc_nids = vt1709_adc_nids;
1866 spec->num_adc_nids = ARRAY_SIZE(vt1709_adc_nids);
1867 get_mux_nids(codec);
1868 spec->mixers[spec->num_mixers] = vt1709_capture_mixer;
1872 codec->patch_ops = via_patch_ops;
1874 codec->patch_ops.init = via_auto_init;
1875 codec->patch_ops.unsol_event = via_unsol_event;
1876 #ifdef CONFIG_SND_HDA_POWER_SAVE
1877 spec->loopback.amplist = vt1709_loopbacks;
1883 * generic initialization of ADC, input mixers and output mixers
1885 static struct hda_verb vt1709_6ch_volume_init_verbs[] = {
1887 * Unmute ADC0-2 and set the default input to mic-in
1889 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1890 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1891 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1894 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
1897 /* Amp Indices: AOW0=0, CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
1898 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1899 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1900 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
1901 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
1902 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
1905 * Set up output selector (0x1a, 0x1b, 0x29)
1907 /* set vol=0 to output mixers */
1908 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1909 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1910 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1913 * Unmute PW3 and PW4
1915 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1916 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1918 /* Set input of PW4 as MW0 */
1919 {0x20, AC_VERB_SET_CONNECT_SEL, 0},
1920 /* PW9 Output enable */
1921 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
1925 static int patch_vt1709_6ch(struct hda_codec *codec)
1927 struct via_spec *spec;
1930 /* create a codec specific record */
1931 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1937 err = vt1709_parse_auto_config(codec);
1942 printk(KERN_INFO "hda_codec: Cannot set up configuration. "
1943 "Using genenic mode...\n");
1946 spec->init_verbs[spec->num_iverbs++] = vt1709_6ch_volume_init_verbs;
1947 spec->init_verbs[spec->num_iverbs++] = vt1709_uniwill_init_verbs;
1949 spec->stream_name_analog = "VT1709 Analog";
1950 spec->stream_analog_playback = &vt1709_6ch_pcm_analog_playback;
1951 spec->stream_analog_capture = &vt1709_pcm_analog_capture;
1953 spec->stream_name_digital = "VT1709 Digital";
1954 spec->stream_digital_playback = &vt1709_pcm_digital_playback;
1955 spec->stream_digital_capture = &vt1709_pcm_digital_capture;
1958 if (!spec->adc_nids && spec->input_mux) {
1959 spec->adc_nids = vt1709_adc_nids;
1960 spec->num_adc_nids = ARRAY_SIZE(vt1709_adc_nids);
1961 get_mux_nids(codec);
1962 spec->mixers[spec->num_mixers] = vt1709_capture_mixer;
1966 codec->patch_ops = via_patch_ops;
1968 codec->patch_ops.init = via_auto_init;
1969 codec->patch_ops.unsol_event = via_unsol_event;
1970 #ifdef CONFIG_SND_HDA_POWER_SAVE
1971 spec->loopback.amplist = vt1709_loopbacks;
1976 /* capture mixer elements */
1977 static struct snd_kcontrol_new vt1708B_capture_mixer[] = {
1978 HDA_CODEC_VOLUME("Capture Volume", 0x13, 0x0, HDA_INPUT),
1979 HDA_CODEC_MUTE("Capture Switch", 0x13, 0x0, HDA_INPUT),
1980 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x14, 0x0, HDA_INPUT),
1981 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x14, 0x0, HDA_INPUT),
1983 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1984 /* The multiple "Capture Source" controls confuse alsamixer
1985 * So call somewhat different..
1987 /* .name = "Capture Source", */
1988 .name = "Input Source",
1990 .info = via_mux_enum_info,
1991 .get = via_mux_enum_get,
1992 .put = via_mux_enum_put,
1997 * generic initialization of ADC, input mixers and output mixers
1999 static struct hda_verb vt1708B_8ch_volume_init_verbs[] = {
2001 * Unmute ADC0-1 and set the default input to mic-in
2003 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2004 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2007 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
2010 /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
2011 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2012 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2013 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
2014 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
2015 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
2018 * Set up output mixers
2020 /* set vol=0 to output mixers */
2021 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2022 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2023 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2025 /* Setup default input to PW4 */
2026 {0x1d, AC_VERB_SET_CONNECT_SEL, 0x1},
2027 /* PW9 Output enable */
2028 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
2029 /* PW10 Input enable */
2030 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
2034 static struct hda_verb vt1708B_4ch_volume_init_verbs[] = {
2036 * Unmute ADC0-1 and set the default input to mic-in
2038 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2039 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2042 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
2045 /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
2046 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2047 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2048 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
2049 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
2050 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
2053 * Set up output mixers
2055 /* set vol=0 to output mixers */
2056 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2057 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2058 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2060 /* Setup default input of PW4 to MW0 */
2061 {0x1d, AC_VERB_SET_CONNECT_SEL, 0x0},
2062 /* PW9 Output enable */
2063 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
2064 /* PW10 Input enable */
2065 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
2069 static struct hda_verb vt1708B_uniwill_init_verbs[] = {
2070 {0x1D, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_HP_EVENT},
2074 static struct hda_pcm_stream vt1708B_8ch_pcm_analog_playback = {
2078 .nid = 0x10, /* NID to query formats and rates */
2080 .open = via_playback_pcm_open,
2081 .prepare = via_playback_multi_pcm_prepare,
2082 .cleanup = via_playback_multi_pcm_cleanup
2086 static struct hda_pcm_stream vt1708B_4ch_pcm_analog_playback = {
2090 .nid = 0x10, /* NID to query formats and rates */
2092 .open = via_playback_pcm_open,
2093 .prepare = via_playback_multi_pcm_prepare,
2094 .cleanup = via_playback_multi_pcm_cleanup
2098 static struct hda_pcm_stream vt1708B_pcm_analog_capture = {
2102 .nid = 0x13, /* NID to query formats and rates */
2104 .prepare = via_capture_pcm_prepare,
2105 .cleanup = via_capture_pcm_cleanup
2109 static struct hda_pcm_stream vt1708B_pcm_digital_playback = {
2113 /* NID is set in via_build_pcms */
2115 .open = via_dig_playback_pcm_open,
2116 .close = via_dig_playback_pcm_close,
2117 .prepare = via_dig_playback_pcm_prepare,
2118 .cleanup = via_dig_playback_pcm_cleanup
2122 static struct hda_pcm_stream vt1708B_pcm_digital_capture = {
2128 /* fill in the dac_nids table from the parsed pin configuration */
2129 static int vt1708B_auto_fill_dac_nids(struct via_spec *spec,
2130 const struct auto_pin_cfg *cfg)
2135 spec->multiout.num_dacs = cfg->line_outs;
2137 spec->multiout.dac_nids = spec->private_dac_nids;
2139 for (i = 0; i < 4; i++) {
2140 nid = cfg->line_out_pins[i];
2142 /* config dac list */
2144 case AUTO_SEQ_FRONT:
2145 spec->multiout.dac_nids[i] = 0x10;
2147 case AUTO_SEQ_CENLFE:
2148 spec->multiout.dac_nids[i] = 0x24;
2150 case AUTO_SEQ_SURROUND:
2151 spec->multiout.dac_nids[i] = 0x11;
2154 spec->multiout.dac_nids[i] = 0x25;
2163 /* add playback controls from the parsed DAC table */
2164 static int vt1708B_auto_create_multi_out_ctls(struct via_spec *spec,
2165 const struct auto_pin_cfg *cfg)
2168 static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" };
2169 hda_nid_t nid_vols[] = {0x16, 0x18, 0x26, 0x27};
2170 hda_nid_t nid, nid_vol = 0;
2173 for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
2174 nid = cfg->line_out_pins[i];
2179 nid_vol = nid_vols[i];
2181 if (i == AUTO_SEQ_CENLFE) {
2183 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2184 "Center Playback Volume",
2185 HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
2189 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2190 "LFE Playback Volume",
2191 HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
2195 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2196 "Center Playback Switch",
2197 HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
2201 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2202 "LFE Playback Switch",
2203 HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
2207 } else if (i == AUTO_SEQ_FRONT) {
2208 /* add control to mixer index 0 */
2209 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2210 "Master Front Playback Volume",
2211 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
2215 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2216 "Master Front Playback Switch",
2217 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
2222 /* add control to PW3 */
2223 sprintf(name, "%s Playback Volume", chname[i]);
2224 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
2225 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
2229 sprintf(name, "%s Playback Switch", chname[i]);
2230 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
2231 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
2236 sprintf(name, "%s Playback Volume", chname[i]);
2237 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
2238 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
2242 sprintf(name, "%s Playback Switch", chname[i]);
2243 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
2244 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
2254 static int vt1708B_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
2261 spec->multiout.hp_nid = VT1708B_HP_NID; /* AOW3 */
2263 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2264 "Headphone Playback Volume",
2265 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
2268 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2269 "Headphone Playback Switch",
2270 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
2274 create_hp_imux(spec);
2279 /* create playback/capture controls for input pins */
2280 static int vt1708B_auto_create_analog_input_ctls(struct via_spec *spec,
2281 const struct auto_pin_cfg *cfg)
2283 static char *labels[] = {
2284 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
2286 struct hda_input_mux *imux = &spec->private_imux[0];
2287 int i, err, idx = 0;
2289 /* for internal loopback recording select */
2290 imux->items[imux->num_items].label = "Stereo Mixer";
2291 imux->items[imux->num_items].index = idx;
2294 for (i = 0; i < AUTO_PIN_LAST; i++) {
2295 if (!cfg->input_pins[i])
2298 switch (cfg->input_pins[i]) {
2299 case 0x1a: /* Mic */
2303 case 0x1b: /* Line In */
2307 case 0x1e: /* Front Mic */
2315 err = via_new_analog_input(spec, cfg->input_pins[i], labels[i],
2319 imux->items[imux->num_items].label = labels[i];
2320 imux->items[imux->num_items].index = idx;
2326 static int vt1708B_parse_auto_config(struct hda_codec *codec)
2328 struct via_spec *spec = codec->spec;
2331 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
2334 err = vt1708B_auto_fill_dac_nids(spec, &spec->autocfg);
2337 if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
2338 return 0; /* can't find valid BIOS pin config */
2340 err = vt1708B_auto_create_multi_out_ctls(spec, &spec->autocfg);
2343 err = vt1708B_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
2346 err = vt1708B_auto_create_analog_input_ctls(spec, &spec->autocfg);
2350 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
2352 if (spec->autocfg.dig_outs)
2353 spec->multiout.dig_out_nid = VT1708B_DIGOUT_NID;
2354 spec->dig_in_pin = VT1708B_DIGIN_PIN;
2355 if (spec->autocfg.dig_in_pin)
2356 spec->dig_in_nid = VT1708B_DIGIN_NID;
2358 if (spec->kctls.list)
2359 spec->mixers[spec->num_mixers++] = spec->kctls.list;
2361 spec->input_mux = &spec->private_imux[0];
2364 spec->mixers[spec->num_mixers++] = via_hp_mixer;
2369 #ifdef CONFIG_SND_HDA_POWER_SAVE
2370 static struct hda_amp_list vt1708B_loopbacks[] = {
2371 { 0x16, HDA_INPUT, 1 },
2372 { 0x16, HDA_INPUT, 2 },
2373 { 0x16, HDA_INPUT, 3 },
2374 { 0x16, HDA_INPUT, 4 },
2379 static int patch_vt1708B_8ch(struct hda_codec *codec)
2381 struct via_spec *spec;
2384 /* create a codec specific record */
2385 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2391 /* automatic parse from the BIOS config */
2392 err = vt1708B_parse_auto_config(codec);
2397 printk(KERN_INFO "hda_codec: Cannot set up configuration "
2398 "from BIOS. Using genenic mode...\n");
2401 spec->init_verbs[spec->num_iverbs++] = vt1708B_8ch_volume_init_verbs;
2402 spec->init_verbs[spec->num_iverbs++] = vt1708B_uniwill_init_verbs;
2404 spec->stream_name_analog = "VT1708B Analog";
2405 spec->stream_analog_playback = &vt1708B_8ch_pcm_analog_playback;
2406 spec->stream_analog_capture = &vt1708B_pcm_analog_capture;
2408 spec->stream_name_digital = "VT1708B Digital";
2409 spec->stream_digital_playback = &vt1708B_pcm_digital_playback;
2410 spec->stream_digital_capture = &vt1708B_pcm_digital_capture;
2412 if (!spec->adc_nids && spec->input_mux) {
2413 spec->adc_nids = vt1708B_adc_nids;
2414 spec->num_adc_nids = ARRAY_SIZE(vt1708B_adc_nids);
2415 get_mux_nids(codec);
2416 spec->mixers[spec->num_mixers] = vt1708B_capture_mixer;
2420 codec->patch_ops = via_patch_ops;
2422 codec->patch_ops.init = via_auto_init;
2423 codec->patch_ops.unsol_event = via_unsol_event;
2424 #ifdef CONFIG_SND_HDA_POWER_SAVE
2425 spec->loopback.amplist = vt1708B_loopbacks;
2431 static int patch_vt1708B_4ch(struct hda_codec *codec)
2433 struct via_spec *spec;
2436 /* create a codec specific record */
2437 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2443 /* automatic parse from the BIOS config */
2444 err = vt1708B_parse_auto_config(codec);
2449 printk(KERN_INFO "hda_codec: Cannot set up configuration "
2450 "from BIOS. Using genenic mode...\n");
2453 spec->init_verbs[spec->num_iverbs++] = vt1708B_4ch_volume_init_verbs;
2454 spec->init_verbs[spec->num_iverbs++] = vt1708B_uniwill_init_verbs;
2456 spec->stream_name_analog = "VT1708B Analog";
2457 spec->stream_analog_playback = &vt1708B_4ch_pcm_analog_playback;
2458 spec->stream_analog_capture = &vt1708B_pcm_analog_capture;
2460 spec->stream_name_digital = "VT1708B Digital";
2461 spec->stream_digital_playback = &vt1708B_pcm_digital_playback;
2462 spec->stream_digital_capture = &vt1708B_pcm_digital_capture;
2464 if (!spec->adc_nids && spec->input_mux) {
2465 spec->adc_nids = vt1708B_adc_nids;
2466 spec->num_adc_nids = ARRAY_SIZE(vt1708B_adc_nids);
2467 get_mux_nids(codec);
2468 spec->mixers[spec->num_mixers] = vt1708B_capture_mixer;
2472 codec->patch_ops = via_patch_ops;
2474 codec->patch_ops.init = via_auto_init;
2475 codec->patch_ops.unsol_event = via_unsol_event;
2476 #ifdef CONFIG_SND_HDA_POWER_SAVE
2477 spec->loopback.amplist = vt1708B_loopbacks;
2483 /* Patch for VT1708S */
2485 /* VT1708S software backdoor based override for buggy hardware micboost
2487 #define MIC_BOOST_VOLUME(xname, nid) { \
2488 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2491 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
2492 SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
2493 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK, \
2494 .info = mic_boost_volume_info, \
2495 .get = snd_hda_mixer_amp_volume_get, \
2496 .put = snd_hda_mixer_amp_volume_put, \
2497 .tlv = { .c = mic_boost_tlv }, \
2498 .private_value = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT) }
2500 /* capture mixer elements */
2501 static struct snd_kcontrol_new vt1708S_capture_mixer[] = {
2502 HDA_CODEC_VOLUME("Capture Volume", 0x13, 0x0, HDA_INPUT),
2503 HDA_CODEC_MUTE("Capture Switch", 0x13, 0x0, HDA_INPUT),
2504 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x14, 0x0, HDA_INPUT),
2505 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x14, 0x0, HDA_INPUT),
2506 MIC_BOOST_VOLUME("Mic Boost Capture Volume", 0x1A),
2507 MIC_BOOST_VOLUME("Front Mic Boost Capture Volume", 0x1E),
2509 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2510 /* The multiple "Capture Source" controls confuse alsamixer
2511 * So call somewhat different..
2513 /* .name = "Capture Source", */
2514 .name = "Input Source",
2516 .info = via_mux_enum_info,
2517 .get = via_mux_enum_get,
2518 .put = via_mux_enum_put,
2523 static struct hda_verb vt1708S_volume_init_verbs[] = {
2524 /* Unmute ADC0-1 and set the default input to mic-in */
2525 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2526 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2528 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the
2529 * analog-loopback mixer widget */
2530 /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
2531 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2532 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2533 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
2534 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
2535 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
2537 /* Setup default input of PW4 to MW0 */
2538 {0x1d, AC_VERB_SET_CONNECT_SEL, 0x0},
2539 /* PW9, PW10 Output enable */
2540 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
2541 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
2542 /* Enable Mic Boost Volume backdoor */
2547 static struct hda_verb vt1708S_uniwill_init_verbs[] = {
2548 {0x1D, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_HP_EVENT},
2552 static struct hda_pcm_stream vt1708S_pcm_analog_playback = {
2556 .nid = 0x10, /* NID to query formats and rates */
2558 .open = via_playback_pcm_open,
2559 .prepare = via_playback_pcm_prepare,
2560 .cleanup = via_playback_pcm_cleanup
2564 static struct hda_pcm_stream vt1708S_pcm_analog_capture = {
2568 .nid = 0x13, /* NID to query formats and rates */
2570 .prepare = via_capture_pcm_prepare,
2571 .cleanup = via_capture_pcm_cleanup
2575 static struct hda_pcm_stream vt1708S_pcm_digital_playback = {
2579 /* NID is set in via_build_pcms */
2581 .open = via_dig_playback_pcm_open,
2582 .close = via_dig_playback_pcm_close,
2583 .prepare = via_dig_playback_pcm_prepare,
2584 .cleanup = via_dig_playback_pcm_cleanup
2588 /* fill in the dac_nids table from the parsed pin configuration */
2589 static int vt1708S_auto_fill_dac_nids(struct via_spec *spec,
2590 const struct auto_pin_cfg *cfg)
2595 spec->multiout.num_dacs = cfg->line_outs;
2597 spec->multiout.dac_nids = spec->private_dac_nids;
2599 for (i = 0; i < 4; i++) {
2600 nid = cfg->line_out_pins[i];
2602 /* config dac list */
2604 case AUTO_SEQ_FRONT:
2605 spec->multiout.dac_nids[i] = 0x10;
2607 case AUTO_SEQ_CENLFE:
2608 spec->multiout.dac_nids[i] = 0x24;
2610 case AUTO_SEQ_SURROUND:
2611 spec->multiout.dac_nids[i] = 0x11;
2614 spec->multiout.dac_nids[i] = 0x25;
2623 /* add playback controls from the parsed DAC table */
2624 static int vt1708S_auto_create_multi_out_ctls(struct via_spec *spec,
2625 const struct auto_pin_cfg *cfg)
2628 static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" };
2629 hda_nid_t nid_vols[] = {0x10, 0x11, 0x24, 0x25};
2630 hda_nid_t nid_mutes[] = {0x1C, 0x18, 0x26, 0x27};
2631 hda_nid_t nid, nid_vol, nid_mute;
2634 for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
2635 nid = cfg->line_out_pins[i];
2640 nid_vol = nid_vols[i];
2641 nid_mute = nid_mutes[i];
2643 if (i == AUTO_SEQ_CENLFE) {
2645 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2646 "Center Playback Volume",
2647 HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
2651 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2652 "LFE Playback Volume",
2653 HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
2657 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2658 "Center Playback Switch",
2659 HDA_COMPOSE_AMP_VAL(nid_mute,
2664 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2665 "LFE Playback Switch",
2666 HDA_COMPOSE_AMP_VAL(nid_mute,
2671 } else if (i == AUTO_SEQ_FRONT) {
2672 /* add control to mixer index 0 */
2673 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2674 "Master Front Playback Volume",
2675 HDA_COMPOSE_AMP_VAL(0x16, 3, 0,
2679 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2680 "Master Front Playback Switch",
2681 HDA_COMPOSE_AMP_VAL(0x16, 3, 0,
2687 sprintf(name, "%s Playback Volume", chname[i]);
2688 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
2689 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
2693 sprintf(name, "%s Playback Switch", chname[i]);
2694 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
2695 HDA_COMPOSE_AMP_VAL(nid_mute,
2701 sprintf(name, "%s Playback Volume", chname[i]);
2702 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
2703 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
2707 sprintf(name, "%s Playback Switch", chname[i]);
2708 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
2709 HDA_COMPOSE_AMP_VAL(nid_mute,
2720 static int vt1708S_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
2727 spec->multiout.hp_nid = VT1708S_HP_NID; /* AOW3 */
2729 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2730 "Headphone Playback Volume",
2731 HDA_COMPOSE_AMP_VAL(0x25, 3, 0, HDA_OUTPUT));
2735 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2736 "Headphone Playback Switch",
2737 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
2741 create_hp_imux(spec);
2746 /* create playback/capture controls for input pins */
2747 static int vt1708S_auto_create_analog_input_ctls(struct via_spec *spec,
2748 const struct auto_pin_cfg *cfg)
2750 static char *labels[] = {
2751 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
2753 struct hda_input_mux *imux = &spec->private_imux[0];
2754 int i, err, idx = 0;
2756 /* for internal loopback recording select */
2757 imux->items[imux->num_items].label = "Stereo Mixer";
2758 imux->items[imux->num_items].index = 5;
2761 for (i = 0; i < AUTO_PIN_LAST; i++) {
2762 if (!cfg->input_pins[i])
2765 switch (cfg->input_pins[i]) {
2766 case 0x1a: /* Mic */
2770 case 0x1b: /* Line In */
2774 case 0x1e: /* Front Mic */
2782 err = via_new_analog_input(spec, cfg->input_pins[i], labels[i],
2786 imux->items[imux->num_items].label = labels[i];
2787 imux->items[imux->num_items].index = idx-1;
2793 /* fill out digital output widgets; one for master and one for slave outputs */
2794 static void fill_dig_outs(struct hda_codec *codec)
2796 struct via_spec *spec = codec->spec;
2799 for (i = 0; i < spec->autocfg.dig_outs; i++) {
2803 nid = spec->autocfg.dig_out_pins[i];
2806 conn = snd_hda_get_connections(codec, nid, &nid, 1);
2809 if (!spec->multiout.dig_out_nid)
2810 spec->multiout.dig_out_nid = nid;
2812 spec->slave_dig_outs[0] = nid;
2813 break; /* at most two dig outs */
2818 static int vt1708S_parse_auto_config(struct hda_codec *codec)
2820 struct via_spec *spec = codec->spec;
2823 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
2826 err = vt1708S_auto_fill_dac_nids(spec, &spec->autocfg);
2829 if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
2830 return 0; /* can't find valid BIOS pin config */
2832 err = vt1708S_auto_create_multi_out_ctls(spec, &spec->autocfg);
2835 err = vt1708S_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
2838 err = vt1708S_auto_create_analog_input_ctls(spec, &spec->autocfg);
2842 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
2844 fill_dig_outs(codec);
2846 if (spec->kctls.list)
2847 spec->mixers[spec->num_mixers++] = spec->kctls.list;
2849 spec->input_mux = &spec->private_imux[0];
2852 spec->mixers[spec->num_mixers++] = via_hp_mixer;
2857 #ifdef CONFIG_SND_HDA_POWER_SAVE
2858 static struct hda_amp_list vt1708S_loopbacks[] = {
2859 { 0x16, HDA_INPUT, 1 },
2860 { 0x16, HDA_INPUT, 2 },
2861 { 0x16, HDA_INPUT, 3 },
2862 { 0x16, HDA_INPUT, 4 },
2867 static int patch_vt1708S(struct hda_codec *codec)
2869 struct via_spec *spec;
2872 /* create a codec specific record */
2873 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2879 /* automatic parse from the BIOS config */
2880 err = vt1708S_parse_auto_config(codec);
2885 printk(KERN_INFO "hda_codec: Cannot set up configuration "
2886 "from BIOS. Using genenic mode...\n");
2889 spec->init_verbs[spec->num_iverbs++] = vt1708S_volume_init_verbs;
2890 spec->init_verbs[spec->num_iverbs++] = vt1708S_uniwill_init_verbs;
2892 spec->stream_name_analog = "VT1708S Analog";
2893 spec->stream_analog_playback = &vt1708S_pcm_analog_playback;
2894 spec->stream_analog_capture = &vt1708S_pcm_analog_capture;
2896 spec->stream_name_digital = "VT1708S Digital";
2897 spec->stream_digital_playback = &vt1708S_pcm_digital_playback;
2899 if (!spec->adc_nids && spec->input_mux) {
2900 spec->adc_nids = vt1708S_adc_nids;
2901 spec->num_adc_nids = ARRAY_SIZE(vt1708S_adc_nids);
2902 get_mux_nids(codec);
2903 spec->mixers[spec->num_mixers] = vt1708S_capture_mixer;
2907 codec->patch_ops = via_patch_ops;
2909 codec->patch_ops.init = via_auto_init;
2910 codec->patch_ops.unsol_event = via_unsol_event;
2911 #ifdef CONFIG_SND_HDA_POWER_SAVE
2912 spec->loopback.amplist = vt1708S_loopbacks;
2918 /* Patch for VT1702 */
2920 /* capture mixer elements */
2921 static struct snd_kcontrol_new vt1702_capture_mixer[] = {
2922 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_INPUT),
2923 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_INPUT),
2924 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x20, 0x0, HDA_INPUT),
2925 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x20, 0x0, HDA_INPUT),
2926 HDA_CODEC_VOLUME("Digital Mic Capture Volume", 0x1F, 0x0, HDA_INPUT),
2927 HDA_CODEC_MUTE("Digital Mic Capture Switch", 0x1F, 0x0, HDA_INPUT),
2928 HDA_CODEC_VOLUME("Digital Mic Boost Capture Volume", 0x1E, 0x0,
2931 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2932 /* The multiple "Capture Source" controls confuse alsamixer
2933 * So call somewhat different..
2935 /* .name = "Capture Source", */
2936 .name = "Input Source",
2938 .info = via_mux_enum_info,
2939 .get = via_mux_enum_get,
2940 .put = via_mux_enum_put,
2945 static struct hda_verb vt1702_volume_init_verbs[] = {
2947 * Unmute ADC0-1 and set the default input to mic-in
2949 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2950 {0x1F, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2951 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2954 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
2957 /* Amp Indices: Mic1 = 1, Line = 1, Mic2 = 3 */
2958 {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2959 {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2960 {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
2961 {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
2962 {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2964 /* Setup default input of PW4 to MW0 */
2965 {0x17, AC_VERB_SET_CONNECT_SEL, 0x1},
2966 /* PW6 PW7 Output enable */
2967 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
2968 {0x1C, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
2972 static struct hda_verb vt1702_uniwill_init_verbs[] = {
2973 {0x01, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_GPIO_EVENT},
2974 {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_HP_EVENT},
2978 static struct hda_pcm_stream vt1702_pcm_analog_playback = {
2982 .nid = 0x10, /* NID to query formats and rates */
2984 .open = via_playback_pcm_open,
2985 .prepare = via_playback_multi_pcm_prepare,
2986 .cleanup = via_playback_multi_pcm_cleanup
2990 static struct hda_pcm_stream vt1702_pcm_analog_capture = {
2994 .nid = 0x12, /* NID to query formats and rates */
2996 .prepare = via_capture_pcm_prepare,
2997 .cleanup = via_capture_pcm_cleanup
3001 static struct hda_pcm_stream vt1702_pcm_digital_playback = {
3005 /* NID is set in via_build_pcms */
3007 .open = via_dig_playback_pcm_open,
3008 .close = via_dig_playback_pcm_close,
3009 .prepare = via_dig_playback_pcm_prepare,
3010 .cleanup = via_dig_playback_pcm_cleanup
3014 /* fill in the dac_nids table from the parsed pin configuration */
3015 static int vt1702_auto_fill_dac_nids(struct via_spec *spec,
3016 const struct auto_pin_cfg *cfg)
3018 spec->multiout.num_dacs = 1;
3019 spec->multiout.dac_nids = spec->private_dac_nids;
3021 if (cfg->line_out_pins[0]) {
3022 /* config dac list */
3023 spec->multiout.dac_nids[0] = 0x10;
3029 /* add playback controls from the parsed DAC table */
3030 static int vt1702_auto_create_line_out_ctls(struct via_spec *spec,
3031 const struct auto_pin_cfg *cfg)
3035 if (!cfg->line_out_pins[0])
3038 /* add control to mixer index 0 */
3039 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
3040 "Master Front Playback Volume",
3041 HDA_COMPOSE_AMP_VAL(0x1A, 3, 0, HDA_INPUT));
3044 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
3045 "Master Front Playback Switch",
3046 HDA_COMPOSE_AMP_VAL(0x1A, 3, 0, HDA_INPUT));
3051 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
3052 "Front Playback Volume",
3053 HDA_COMPOSE_AMP_VAL(0x10, 3, 0, HDA_OUTPUT));
3056 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
3057 "Front Playback Switch",
3058 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT));
3065 static int vt1702_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
3072 spec->multiout.hp_nid = 0x1D;
3074 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
3075 "Headphone Playback Volume",
3076 HDA_COMPOSE_AMP_VAL(0x1D, 3, 0, HDA_OUTPUT));
3080 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
3081 "Headphone Playback Switch",
3082 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
3086 create_hp_imux(spec);
3091 /* create playback/capture controls for input pins */
3092 static int vt1702_auto_create_analog_input_ctls(struct via_spec *spec,
3093 const struct auto_pin_cfg *cfg)
3095 static char *labels[] = {
3096 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
3098 struct hda_input_mux *imux = &spec->private_imux[0];
3099 int i, err, idx = 0;
3101 /* for internal loopback recording select */
3102 imux->items[imux->num_items].label = "Stereo Mixer";
3103 imux->items[imux->num_items].index = 3;
3106 for (i = 0; i < AUTO_PIN_LAST; i++) {
3107 if (!cfg->input_pins[i])
3110 switch (cfg->input_pins[i]) {
3111 case 0x14: /* Mic */
3115 case 0x15: /* Line In */
3119 case 0x18: /* Front Mic */
3123 err = via_new_analog_input(spec, cfg->input_pins[i],
3124 labels[i], idx, 0x1A);
3127 imux->items[imux->num_items].label = labels[i];
3128 imux->items[imux->num_items].index = idx-1;
3134 static int vt1702_parse_auto_config(struct hda_codec *codec)
3136 struct via_spec *spec = codec->spec;
3139 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
3142 err = vt1702_auto_fill_dac_nids(spec, &spec->autocfg);
3145 if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
3146 return 0; /* can't find valid BIOS pin config */
3148 err = vt1702_auto_create_line_out_ctls(spec, &spec->autocfg);
3151 err = vt1702_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
3154 err = vt1702_auto_create_analog_input_ctls(spec, &spec->autocfg);
3158 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3160 fill_dig_outs(codec);
3162 if (spec->kctls.list)
3163 spec->mixers[spec->num_mixers++] = spec->kctls.list;
3165 spec->input_mux = &spec->private_imux[0];
3168 spec->mixers[spec->num_mixers++] = via_hp_mixer;
3173 #ifdef CONFIG_SND_HDA_POWER_SAVE
3174 static struct hda_amp_list vt1702_loopbacks[] = {
3175 { 0x1A, HDA_INPUT, 1 },
3176 { 0x1A, HDA_INPUT, 2 },
3177 { 0x1A, HDA_INPUT, 3 },
3178 { 0x1A, HDA_INPUT, 4 },
3183 static int patch_vt1702(struct hda_codec *codec)
3185 struct via_spec *spec;
3187 unsigned int response;
3188 unsigned char control;
3190 /* create a codec specific record */
3191 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3197 /* automatic parse from the BIOS config */
3198 err = vt1702_parse_auto_config(codec);
3203 printk(KERN_INFO "hda_codec: Cannot set up configuration "
3204 "from BIOS. Using genenic mode...\n");
3207 spec->init_verbs[spec->num_iverbs++] = vt1702_volume_init_verbs;
3208 spec->init_verbs[spec->num_iverbs++] = vt1702_uniwill_init_verbs;
3210 spec->stream_name_analog = "VT1702 Analog";
3211 spec->stream_analog_playback = &vt1702_pcm_analog_playback;
3212 spec->stream_analog_capture = &vt1702_pcm_analog_capture;
3214 spec->stream_name_digital = "VT1702 Digital";
3215 spec->stream_digital_playback = &vt1702_pcm_digital_playback;
3217 if (!spec->adc_nids && spec->input_mux) {
3218 spec->adc_nids = vt1702_adc_nids;
3219 spec->num_adc_nids = ARRAY_SIZE(vt1702_adc_nids);
3220 get_mux_nids(codec);
3221 spec->mixers[spec->num_mixers] = vt1702_capture_mixer;
3225 codec->patch_ops = via_patch_ops;
3227 codec->patch_ops.init = via_auto_init;
3228 codec->patch_ops.unsol_event = via_unsol_event;
3229 #ifdef CONFIG_SND_HDA_POWER_SAVE
3230 spec->loopback.amplist = vt1702_loopbacks;
3234 response = snd_hda_codec_read(codec, codec->afg, 0, 0xF8C, 0);
3235 control = (unsigned char)(response & 0xff);
3237 snd_hda_codec_write(codec, codec->afg, 0, 0xF88, control);
3239 /* Enable GPIO 0&1 for volume&mute control */
3240 /* Enable GPIO 2 for DMIC-DATA */
3241 response = snd_hda_codec_read(codec, codec->afg, 0, 0xF84, 0);
3242 control = (unsigned char)((response >> 16) & 0x3f);
3243 snd_hda_codec_write(codec, codec->afg, 0, 0xF82, control);
3251 static struct hda_codec_preset snd_hda_preset_via[] = {
3252 { .id = 0x11061708, .name = "VT1708", .patch = patch_vt1708},
3253 { .id = 0x11061709, .name = "VT1708", .patch = patch_vt1708},
3254 { .id = 0x1106170a, .name = "VT1708", .patch = patch_vt1708},
3255 { .id = 0x1106170b, .name = "VT1708", .patch = patch_vt1708},
3256 { .id = 0x1106e710, .name = "VT1709 10-Ch",
3257 .patch = patch_vt1709_10ch},
3258 { .id = 0x1106e711, .name = "VT1709 10-Ch",
3259 .patch = patch_vt1709_10ch},
3260 { .id = 0x1106e712, .name = "VT1709 10-Ch",
3261 .patch = patch_vt1709_10ch},
3262 { .id = 0x1106e713, .name = "VT1709 10-Ch",
3263 .patch = patch_vt1709_10ch},
3264 { .id = 0x1106e714, .name = "VT1709 6-Ch",
3265 .patch = patch_vt1709_6ch},
3266 { .id = 0x1106e715, .name = "VT1709 6-Ch",
3267 .patch = patch_vt1709_6ch},
3268 { .id = 0x1106e716, .name = "VT1709 6-Ch",
3269 .patch = patch_vt1709_6ch},
3270 { .id = 0x1106e717, .name = "VT1709 6-Ch",
3271 .patch = patch_vt1709_6ch},
3272 { .id = 0x1106e720, .name = "VT1708B 8-Ch",
3273 .patch = patch_vt1708B_8ch},
3274 { .id = 0x1106e721, .name = "VT1708B 8-Ch",
3275 .patch = patch_vt1708B_8ch},
3276 { .id = 0x1106e722, .name = "VT1708B 8-Ch",
3277 .patch = patch_vt1708B_8ch},
3278 { .id = 0x1106e723, .name = "VT1708B 8-Ch",
3279 .patch = patch_vt1708B_8ch},
3280 { .id = 0x1106e724, .name = "VT1708B 4-Ch",
3281 .patch = patch_vt1708B_4ch},
3282 { .id = 0x1106e725, .name = "VT1708B 4-Ch",
3283 .patch = patch_vt1708B_4ch},
3284 { .id = 0x1106e726, .name = "VT1708B 4-Ch",
3285 .patch = patch_vt1708B_4ch},
3286 { .id = 0x1106e727, .name = "VT1708B 4-Ch",
3287 .patch = patch_vt1708B_4ch},
3288 { .id = 0x11060397, .name = "VT1708S",
3289 .patch = patch_vt1708S},
3290 { .id = 0x11061397, .name = "VT1708S",
3291 .patch = patch_vt1708S},
3292 { .id = 0x11062397, .name = "VT1708S",
3293 .patch = patch_vt1708S},
3294 { .id = 0x11063397, .name = "VT1708S",
3295 .patch = patch_vt1708S},
3296 { .id = 0x11064397, .name = "VT1708S",
3297 .patch = patch_vt1708S},
3298 { .id = 0x11065397, .name = "VT1708S",
3299 .patch = patch_vt1708S},
3300 { .id = 0x11066397, .name = "VT1708S",
3301 .patch = patch_vt1708S},
3302 { .id = 0x11067397, .name = "VT1708S",
3303 .patch = patch_vt1708S},
3304 { .id = 0x11060398, .name = "VT1702",
3305 .patch = patch_vt1702},
3306 { .id = 0x11061398, .name = "VT1702",
3307 .patch = patch_vt1702},
3308 { .id = 0x11062398, .name = "VT1702",
3309 .patch = patch_vt1702},
3310 { .id = 0x11063398, .name = "VT1702",
3311 .patch = patch_vt1702},
3312 { .id = 0x11064398, .name = "VT1702",
3313 .patch = patch_vt1702},
3314 { .id = 0x11065398, .name = "VT1702",
3315 .patch = patch_vt1702},
3316 { .id = 0x11066398, .name = "VT1702",
3317 .patch = patch_vt1702},
3318 { .id = 0x11067398, .name = "VT1702",
3319 .patch = patch_vt1702},
3323 MODULE_ALIAS("snd-hda-codec-id:1106*");
3325 static struct hda_codec_preset_list via_list = {
3326 .preset = snd_hda_preset_via,
3327 .owner = THIS_MODULE,
3330 MODULE_LICENSE("GPL");
3331 MODULE_DESCRIPTION("VIA HD-audio codec");
3333 static int __init patch_via_init(void)
3335 return snd_hda_add_codec_preset(&via_list);
3338 static void __exit patch_via_exit(void)
3340 snd_hda_delete_codec_preset(&via_list);
3343 module_init(patch_via_init)
3344 module_exit(patch_via_exit)