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 dig_in_nid;
214 hda_nid_t dig_in_pin;
217 const struct hda_input_mux *input_mux;
218 unsigned int cur_mux[3];
220 /* PCM information */
221 struct hda_pcm pcm_rec[3];
223 /* dynamic controls, init_verbs and input_mux */
224 struct auto_pin_cfg autocfg;
225 struct snd_array kctls;
226 struct hda_input_mux private_imux[2];
227 hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
230 const struct hda_input_mux *hp_mux;
231 unsigned int hp_independent_mode;
233 #ifdef CONFIG_SND_HDA_POWER_SAVE
234 struct hda_loopback_check loopback;
238 static hda_nid_t vt1708_adc_nids[2] = {
243 static hda_nid_t vt1709_adc_nids[3] = {
248 static hda_nid_t vt1708B_adc_nids[2] = {
253 static hda_nid_t vt1708S_adc_nids[2] = {
258 static hda_nid_t vt1702_adc_nids[3] = {
263 /* add dynamic controls */
264 static int via_add_control(struct via_spec *spec, int type, const char *name,
267 struct snd_kcontrol_new *knew;
269 snd_array_init(&spec->kctls, sizeof(*knew), 32);
270 knew = snd_array_new(&spec->kctls);
273 *knew = vt1708_control_templates[type];
274 knew->name = kstrdup(name, GFP_KERNEL);
277 knew->private_value = val;
281 static void via_free_kctls(struct hda_codec *codec)
283 struct via_spec *spec = codec->spec;
285 if (spec->kctls.list) {
286 struct snd_kcontrol_new *kctl = spec->kctls.list;
288 for (i = 0; i < spec->kctls.used; i++)
291 snd_array_free(&spec->kctls);
294 /* create input playback/capture controls for the given pin */
295 static int via_new_analog_input(struct via_spec *spec, hda_nid_t pin,
296 const char *ctlname, int idx, int mix_nid)
301 sprintf(name, "%s Playback Volume", ctlname);
302 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
303 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
306 sprintf(name, "%s Playback Switch", ctlname);
307 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
308 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
314 static void via_auto_set_output_and_unmute(struct hda_codec *codec,
315 hda_nid_t nid, int pin_type,
319 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
321 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
326 static void via_auto_init_multi_out(struct hda_codec *codec)
328 struct via_spec *spec = codec->spec;
331 for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
332 hda_nid_t nid = spec->autocfg.line_out_pins[i];
334 via_auto_set_output_and_unmute(codec, nid, PIN_OUT, i);
338 static void via_auto_init_hp_out(struct hda_codec *codec)
340 struct via_spec *spec = codec->spec;
343 pin = spec->autocfg.hp_pins[0];
344 if (pin) /* connect to front */
345 via_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
348 static void via_auto_init_analog_input(struct hda_codec *codec)
350 struct via_spec *spec = codec->spec;
353 for (i = 0; i < AUTO_PIN_LAST; i++) {
354 hda_nid_t nid = spec->autocfg.input_pins[i];
356 snd_hda_codec_write(codec, nid, 0,
357 AC_VERB_SET_PIN_WIDGET_CONTROL,
358 (i <= AUTO_PIN_FRONT_MIC ?
359 PIN_VREF50 : PIN_IN));
366 static int via_mux_enum_info(struct snd_kcontrol *kcontrol,
367 struct snd_ctl_elem_info *uinfo)
369 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
370 struct via_spec *spec = codec->spec;
371 return snd_hda_input_mux_info(spec->input_mux, uinfo);
374 static int via_mux_enum_get(struct snd_kcontrol *kcontrol,
375 struct snd_ctl_elem_value *ucontrol)
377 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
378 struct via_spec *spec = codec->spec;
379 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
381 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
385 static int via_mux_enum_put(struct snd_kcontrol *kcontrol,
386 struct snd_ctl_elem_value *ucontrol)
388 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
389 struct via_spec *spec = codec->spec;
390 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
391 unsigned int vendor_id = codec->vendor_id;
393 /* AIW0 lydia 060801 add for correct sw0 input select */
394 if (IS_VT1708_VENDORID(vendor_id) && (adc_idx == 0))
395 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
396 0x18, &spec->cur_mux[adc_idx]);
397 else if ((IS_VT1709_10CH_VENDORID(vendor_id) ||
398 IS_VT1709_6CH_VENDORID(vendor_id)) && (adc_idx == 0))
399 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
400 0x19, &spec->cur_mux[adc_idx]);
401 else if ((IS_VT1708B_8CH_VENDORID(vendor_id) ||
402 IS_VT1708B_4CH_VENDORID(vendor_id)) && (adc_idx == 0))
403 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
404 0x17, &spec->cur_mux[adc_idx]);
405 else if (IS_VT1702_VENDORID(vendor_id) && (adc_idx == 0))
406 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
407 0x13, &spec->cur_mux[adc_idx]);
409 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
410 spec->adc_nids[adc_idx],
411 &spec->cur_mux[adc_idx]);
414 static int via_independent_hp_info(struct snd_kcontrol *kcontrol,
415 struct snd_ctl_elem_info *uinfo)
417 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
418 struct via_spec *spec = codec->spec;
419 return snd_hda_input_mux_info(spec->hp_mux, uinfo);
422 static int via_independent_hp_get(struct snd_kcontrol *kcontrol,
423 struct snd_ctl_elem_value *ucontrol)
425 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
426 struct via_spec *spec = codec->spec;
427 hda_nid_t nid = spec->autocfg.hp_pins[0];
428 unsigned int pinsel = snd_hda_codec_read(codec, nid, 0,
429 AC_VERB_GET_CONNECT_SEL,
432 ucontrol->value.enumerated.item[0] = pinsel;
437 static int via_independent_hp_put(struct snd_kcontrol *kcontrol,
438 struct snd_ctl_elem_value *ucontrol)
440 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
441 struct via_spec *spec = codec->spec;
442 hda_nid_t nid = spec->autocfg.hp_pins[0];
443 unsigned int pinsel = ucontrol->value.enumerated.item[0];
444 unsigned int con_nid = snd_hda_codec_read(codec, nid, 0,
445 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
447 if (con_nid == spec->multiout.hp_nid) {
449 if (!spec->hp_independent_mode) {
450 if (spec->multiout.num_dacs > 1)
451 spec->multiout.num_dacs -= 1;
452 spec->hp_independent_mode = 1;
454 } else if (pinsel == 1) {
455 if (spec->hp_independent_mode) {
456 if (spec->multiout.num_dacs > 1)
457 spec->multiout.num_dacs += 1;
458 spec->hp_independent_mode = 0;
463 if (spec->hp_independent_mode) {
464 if (spec->multiout.num_dacs > 1)
465 spec->multiout.num_dacs += 1;
466 spec->hp_independent_mode = 0;
468 } else if (pinsel == 1) {
469 if (!spec->hp_independent_mode) {
470 if (spec->multiout.num_dacs > 1)
471 spec->multiout.num_dacs -= 1;
472 spec->hp_independent_mode = 1;
476 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
479 if (spec->multiout.hp_nid &&
480 spec->multiout.hp_nid != spec->multiout.dac_nids[HDA_FRONT])
481 snd_hda_codec_setup_stream(codec,
482 spec->multiout.hp_nid,
488 static struct snd_kcontrol_new via_hp_mixer[] = {
490 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
491 .name = "Independent HP",
493 .info = via_independent_hp_info,
494 .get = via_independent_hp_get,
495 .put = via_independent_hp_put,
500 /* capture mixer elements */
501 static struct snd_kcontrol_new vt1708_capture_mixer[] = {
502 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_INPUT),
503 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_INPUT),
504 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x27, 0x0, HDA_INPUT),
505 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x27, 0x0, HDA_INPUT),
507 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
508 /* The multiple "Capture Source" controls confuse alsamixer
509 * So call somewhat different..
511 /* .name = "Capture Source", */
512 .name = "Input Source",
514 .info = via_mux_enum_info,
515 .get = via_mux_enum_get,
516 .put = via_mux_enum_put,
521 * generic initialization of ADC, input mixers and output mixers
523 static struct hda_verb vt1708_volume_init_verbs[] = {
525 * Unmute ADC0-1 and set the default input to mic-in
527 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
528 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
531 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
534 /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
535 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
536 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
537 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
538 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
539 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
542 * Set up output mixers (0x19 - 0x1b)
544 /* set vol=0 to output mixers */
545 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
546 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
547 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
549 /* Setup default input to PW4 */
550 {0x20, AC_VERB_SET_CONNECT_SEL, 0x1},
551 /* PW9 Output enable */
552 {0x25, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
556 static int via_playback_pcm_open(struct hda_pcm_stream *hinfo,
557 struct hda_codec *codec,
558 struct snd_pcm_substream *substream)
560 struct via_spec *spec = codec->spec;
561 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
565 static int via_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
566 struct hda_codec *codec,
567 unsigned int stream_tag,
569 struct snd_pcm_substream *substream)
571 struct via_spec *spec = codec->spec;
572 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
573 stream_tag, format, substream);
576 static int via_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
577 struct hda_codec *codec,
578 struct snd_pcm_substream *substream)
580 struct via_spec *spec = codec->spec;
581 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
585 static void playback_multi_pcm_prep_0(struct hda_codec *codec,
586 unsigned int stream_tag,
588 struct snd_pcm_substream *substream)
590 struct via_spec *spec = codec->spec;
591 struct hda_multi_out *mout = &spec->multiout;
592 hda_nid_t *nids = mout->dac_nids;
593 int chs = substream->runtime->channels;
596 mutex_lock(&codec->spdif_mutex);
597 if (mout->dig_out_nid && mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
599 snd_hda_is_supported_format(codec, mout->dig_out_nid,
601 !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
602 mout->dig_out_used = HDA_DIG_ANALOG_DUP;
603 /* turn off SPDIF once; otherwise the IEC958 bits won't
605 if (codec->spdif_ctls & AC_DIG1_ENABLE)
606 snd_hda_codec_write(codec, mout->dig_out_nid, 0,
607 AC_VERB_SET_DIGI_CONVERT_1,
609 ~AC_DIG1_ENABLE & 0xff);
610 snd_hda_codec_setup_stream(codec, mout->dig_out_nid,
611 stream_tag, 0, format);
612 /* turn on again (if needed) */
613 if (codec->spdif_ctls & AC_DIG1_ENABLE)
614 snd_hda_codec_write(codec, mout->dig_out_nid, 0,
615 AC_VERB_SET_DIGI_CONVERT_1,
616 codec->spdif_ctls & 0xff);
618 mout->dig_out_used = 0;
619 snd_hda_codec_setup_stream(codec, mout->dig_out_nid,
623 mutex_unlock(&codec->spdif_mutex);
626 snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
629 if (mout->hp_nid && mout->hp_nid != nids[HDA_FRONT] &&
630 !spec->hp_independent_mode)
631 /* headphone out will just decode front left/right (stereo) */
632 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
635 /* extra outputs copied from front */
636 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
637 if (mout->extra_out_nid[i])
638 snd_hda_codec_setup_stream(codec,
639 mout->extra_out_nid[i],
640 stream_tag, 0, format);
643 for (i = 1; i < mout->num_dacs; i++) {
644 if (chs >= (i + 1) * 2) /* independent out */
645 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
647 else /* copy front */
648 snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
653 static int via_playback_multi_pcm_prepare(struct hda_pcm_stream *hinfo,
654 struct hda_codec *codec,
655 unsigned int stream_tag,
657 struct snd_pcm_substream *substream)
659 struct via_spec *spec = codec->spec;
660 struct hda_multi_out *mout = &spec->multiout;
661 hda_nid_t *nids = mout->dac_nids;
663 if (substream->number == 0)
664 playback_multi_pcm_prep_0(codec, stream_tag, format,
667 if (mout->hp_nid && mout->hp_nid != nids[HDA_FRONT] &&
668 spec->hp_independent_mode)
669 snd_hda_codec_setup_stream(codec, mout->hp_nid,
670 stream_tag, 0, format);
676 static int via_playback_multi_pcm_cleanup(struct hda_pcm_stream *hinfo,
677 struct hda_codec *codec,
678 struct snd_pcm_substream *substream)
680 struct via_spec *spec = codec->spec;
681 struct hda_multi_out *mout = &spec->multiout;
682 hda_nid_t *nids = mout->dac_nids;
685 if (substream->number == 0) {
686 for (i = 0; i < mout->num_dacs; i++)
687 snd_hda_codec_setup_stream(codec, nids[i], 0, 0, 0);
689 if (mout->hp_nid && !spec->hp_independent_mode)
690 snd_hda_codec_setup_stream(codec, mout->hp_nid,
693 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
694 if (mout->extra_out_nid[i])
695 snd_hda_codec_setup_stream(codec,
696 mout->extra_out_nid[i],
698 mutex_lock(&codec->spdif_mutex);
699 if (mout->dig_out_nid &&
700 mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
701 snd_hda_codec_setup_stream(codec, mout->dig_out_nid,
703 mout->dig_out_used = 0;
705 mutex_unlock(&codec->spdif_mutex);
707 if (mout->hp_nid && mout->hp_nid != nids[HDA_FRONT] &&
708 spec->hp_independent_mode)
709 snd_hda_codec_setup_stream(codec, mout->hp_nid,
719 static int via_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
720 struct hda_codec *codec,
721 struct snd_pcm_substream *substream)
723 struct via_spec *spec = codec->spec;
724 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
727 static int via_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
728 struct hda_codec *codec,
729 struct snd_pcm_substream *substream)
731 struct via_spec *spec = codec->spec;
732 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
735 static int via_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
736 struct hda_codec *codec,
737 unsigned int stream_tag,
739 struct snd_pcm_substream *substream)
741 struct via_spec *spec = codec->spec;
742 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
743 stream_tag, format, substream);
746 static int via_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
747 struct hda_codec *codec,
748 struct snd_pcm_substream *substream)
750 struct via_spec *spec = codec->spec;
751 snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
758 static int via_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
759 struct hda_codec *codec,
760 unsigned int stream_tag,
762 struct snd_pcm_substream *substream)
764 struct via_spec *spec = codec->spec;
766 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
767 stream_tag, 0, format);
771 static int via_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
772 struct hda_codec *codec,
773 struct snd_pcm_substream *substream)
775 struct via_spec *spec = codec->spec;
776 snd_hda_codec_cleanup_stream(codec, spec->adc_nids[substream->number]);
780 static struct hda_pcm_stream vt1708_pcm_analog_playback = {
784 .nid = 0x10, /* NID to query formats and rates */
786 .open = via_playback_pcm_open,
787 .prepare = via_playback_multi_pcm_prepare,
788 .cleanup = via_playback_multi_pcm_cleanup
792 static struct hda_pcm_stream vt1708_pcm_analog_s16_playback = {
796 .nid = 0x10, /* NID to query formats and rates */
797 /* We got noisy outputs on the right channel on VT1708 when
798 * 24bit samples are used. Until any workaround is found,
799 * disable the 24bit format, so far.
801 .formats = SNDRV_PCM_FMTBIT_S16_LE,
803 .open = via_playback_pcm_open,
804 .prepare = via_playback_pcm_prepare,
805 .cleanup = via_playback_pcm_cleanup
809 static struct hda_pcm_stream vt1708_pcm_analog_capture = {
813 .nid = 0x15, /* NID to query formats and rates */
815 .prepare = via_capture_pcm_prepare,
816 .cleanup = via_capture_pcm_cleanup
820 static struct hda_pcm_stream vt1708_pcm_digital_playback = {
824 /* NID is set in via_build_pcms */
826 .open = via_dig_playback_pcm_open,
827 .close = via_dig_playback_pcm_close,
828 .prepare = via_dig_playback_pcm_prepare,
829 .cleanup = via_dig_playback_pcm_cleanup
833 static struct hda_pcm_stream vt1708_pcm_digital_capture = {
839 static int via_build_controls(struct hda_codec *codec)
841 struct via_spec *spec = codec->spec;
845 for (i = 0; i < spec->num_mixers; i++) {
846 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
851 if (spec->multiout.dig_out_nid) {
852 err = snd_hda_create_spdif_out_ctls(codec,
853 spec->multiout.dig_out_nid);
856 err = snd_hda_create_spdif_share_sw(codec,
860 spec->multiout.share_spdif = 1;
862 if (spec->dig_in_nid) {
863 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
867 via_free_kctls(codec); /* no longer needed */
871 static int via_build_pcms(struct hda_codec *codec)
873 struct via_spec *spec = codec->spec;
874 struct hda_pcm *info = spec->pcm_rec;
877 codec->pcm_info = info;
879 info->name = spec->stream_name_analog;
880 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
881 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
882 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
883 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
885 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
886 spec->multiout.max_channels;
888 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
891 info->name = spec->stream_name_digital;
892 info->pcm_type = HDA_PCM_TYPE_SPDIF;
893 if (spec->multiout.dig_out_nid) {
894 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
895 *(spec->stream_digital_playback);
896 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
897 spec->multiout.dig_out_nid;
899 if (spec->dig_in_nid) {
900 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
901 *(spec->stream_digital_capture);
902 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
910 static void via_free(struct hda_codec *codec)
912 struct via_spec *spec = codec->spec;
917 via_free_kctls(codec);
921 /* mute internal speaker if HP is plugged */
922 static void via_hp_automute(struct hda_codec *codec)
924 unsigned int present;
925 struct via_spec *spec = codec->spec;
927 present = snd_hda_codec_read(codec, spec->autocfg.hp_pins[0], 0,
928 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
929 snd_hda_codec_amp_stereo(codec, spec->autocfg.line_out_pins[0],
930 HDA_OUTPUT, 0, HDA_AMP_MUTE,
931 present ? HDA_AMP_MUTE : 0);
934 static void via_gpio_control(struct hda_codec *codec)
936 unsigned int gpio_data;
937 unsigned int vol_counter;
939 unsigned int master_vol;
941 struct via_spec *spec = codec->spec;
943 gpio_data = snd_hda_codec_read(codec, codec->afg, 0,
944 AC_VERB_GET_GPIO_DATA, 0) & 0x03;
946 vol_counter = (snd_hda_codec_read(codec, codec->afg, 0,
947 0xF84, 0) & 0x3F0000) >> 16;
949 vol = vol_counter & 0x1F;
950 master_vol = snd_hda_codec_read(codec, 0x1A, 0,
951 AC_VERB_GET_AMP_GAIN_MUTE,
954 if (gpio_data == 0x02) {
955 /* unmute line out */
956 snd_hda_codec_amp_stereo(codec, spec->autocfg.line_out_pins[0],
957 HDA_OUTPUT, 0, HDA_AMP_MUTE, 0);
959 if (vol_counter & 0x20) {
960 /* decrease volume */
961 if (vol > master_vol)
963 snd_hda_codec_amp_stereo(codec, 0x1A, HDA_INPUT,
967 /* increase volume */
968 snd_hda_codec_amp_stereo(codec, 0x1A, HDA_INPUT, 0,
970 ((master_vol+vol) > 0x2A) ? 0x2A :
973 } else if (!(gpio_data & 0x02)) {
975 snd_hda_codec_amp_stereo(codec,
976 spec->autocfg.line_out_pins[0],
977 HDA_OUTPUT, 0, HDA_AMP_MUTE,
982 /* unsolicited event for jack sensing */
983 static void via_unsol_event(struct hda_codec *codec,
987 if (res == VIA_HP_EVENT)
988 via_hp_automute(codec);
989 else if (res == VIA_GPIO_EVENT)
990 via_gpio_control(codec);
993 static int via_init(struct hda_codec *codec)
995 struct via_spec *spec = codec->spec;
997 for (i = 0; i < spec->num_iverbs; i++)
998 snd_hda_sequence_write(codec, spec->init_verbs[i]);
1000 /* Lydia Add for EAPD enable */
1001 if (!spec->dig_in_nid) { /* No Digital In connection */
1002 if (spec->dig_in_pin) {
1003 snd_hda_codec_write(codec, spec->dig_in_pin, 0,
1004 AC_VERB_SET_PIN_WIDGET_CONTROL,
1006 snd_hda_codec_write(codec, spec->dig_in_pin, 0,
1007 AC_VERB_SET_EAPD_BTLENABLE, 0x02);
1009 } else /* enable SPDIF-input pin */
1010 snd_hda_codec_write(codec, spec->autocfg.dig_in_pin, 0,
1011 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN);
1013 /* assign slave outs */
1014 if (spec->slave_dig_outs[0])
1015 codec->slave_dig_outs = spec->slave_dig_outs;
1020 #ifdef CONFIG_SND_HDA_POWER_SAVE
1021 static int via_check_power_status(struct hda_codec *codec, hda_nid_t nid)
1023 struct via_spec *spec = codec->spec;
1024 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
1030 static struct hda_codec_ops via_patch_ops = {
1031 .build_controls = via_build_controls,
1032 .build_pcms = via_build_pcms,
1035 #ifdef CONFIG_SND_HDA_POWER_SAVE
1036 .check_power_status = via_check_power_status,
1040 /* fill in the dac_nids table from the parsed pin configuration */
1041 static int vt1708_auto_fill_dac_nids(struct via_spec *spec,
1042 const struct auto_pin_cfg *cfg)
1047 spec->multiout.num_dacs = cfg->line_outs;
1049 spec->multiout.dac_nids = spec->private_dac_nids;
1051 for(i = 0; i < 4; i++) {
1052 nid = cfg->line_out_pins[i];
1054 /* config dac list */
1056 case AUTO_SEQ_FRONT:
1057 spec->multiout.dac_nids[i] = 0x10;
1059 case AUTO_SEQ_CENLFE:
1060 spec->multiout.dac_nids[i] = 0x12;
1062 case AUTO_SEQ_SURROUND:
1063 spec->multiout.dac_nids[i] = 0x11;
1066 spec->multiout.dac_nids[i] = 0x13;
1075 /* add playback controls from the parsed DAC table */
1076 static int vt1708_auto_create_multi_out_ctls(struct via_spec *spec,
1077 const struct auto_pin_cfg *cfg)
1080 static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" };
1081 hda_nid_t nid, nid_vol = 0;
1084 for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
1085 nid = cfg->line_out_pins[i];
1090 if (i != AUTO_SEQ_FRONT)
1093 if (i == AUTO_SEQ_CENLFE) {
1095 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1096 "Center Playback Volume",
1097 HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
1101 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1102 "LFE Playback Volume",
1103 HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
1107 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1108 "Center Playback Switch",
1109 HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
1113 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1114 "LFE Playback Switch",
1115 HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
1119 } else if (i == AUTO_SEQ_FRONT){
1120 /* add control to mixer index 0 */
1121 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1122 "Master Front Playback Volume",
1123 HDA_COMPOSE_AMP_VAL(0x17, 3, 0,
1127 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1128 "Master Front Playback Switch",
1129 HDA_COMPOSE_AMP_VAL(0x17, 3, 0,
1134 /* add control to PW3 */
1135 sprintf(name, "%s Playback Volume", chname[i]);
1136 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
1137 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
1141 sprintf(name, "%s Playback Switch", chname[i]);
1142 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
1143 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
1148 sprintf(name, "%s Playback Volume", chname[i]);
1149 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
1150 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
1154 sprintf(name, "%s Playback Switch", chname[i]);
1155 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
1156 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
1166 static void create_hp_imux(struct via_spec *spec)
1169 struct hda_input_mux *imux = &spec->private_imux[1];
1170 static const char *texts[] = { "OFF", "ON", NULL};
1172 /* for hp mode select */
1174 while (texts[i] != NULL) {
1175 imux->items[imux->num_items].label = texts[i];
1176 imux->items[imux->num_items].index = i;
1181 spec->hp_mux = &spec->private_imux[1];
1184 static int vt1708_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
1191 spec->multiout.hp_nid = VT1708_HP_NID; /* AOW3 */
1193 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1194 "Headphone Playback Volume",
1195 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
1198 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1199 "Headphone Playback Switch",
1200 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
1204 create_hp_imux(spec);
1209 /* create playback/capture controls for input pins */
1210 static int vt1708_auto_create_analog_input_ctls(struct via_spec *spec,
1211 const struct auto_pin_cfg *cfg)
1213 static char *labels[] = {
1214 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
1216 struct hda_input_mux *imux = &spec->private_imux[0];
1217 int i, err, idx = 0;
1219 /* for internal loopback recording select */
1220 imux->items[imux->num_items].label = "Stereo Mixer";
1221 imux->items[imux->num_items].index = idx;
1224 for (i = 0; i < AUTO_PIN_LAST; i++) {
1225 if (!cfg->input_pins[i])
1228 switch (cfg->input_pins[i]) {
1229 case 0x1d: /* Mic */
1233 case 0x1e: /* Line In */
1237 case 0x21: /* Front Mic */
1245 err = via_new_analog_input(spec, cfg->input_pins[i], labels[i],
1249 imux->items[imux->num_items].label = labels[i];
1250 imux->items[imux->num_items].index = idx;
1256 #ifdef CONFIG_SND_HDA_POWER_SAVE
1257 static struct hda_amp_list vt1708_loopbacks[] = {
1258 { 0x17, HDA_INPUT, 1 },
1259 { 0x17, HDA_INPUT, 2 },
1260 { 0x17, HDA_INPUT, 3 },
1261 { 0x17, HDA_INPUT, 4 },
1266 static void vt1708_set_pinconfig_connect(struct hda_codec *codec, hda_nid_t nid)
1268 unsigned int def_conf;
1269 unsigned char seqassoc;
1271 def_conf = snd_hda_codec_get_pincfg(codec, nid);
1272 seqassoc = (unsigned char) get_defcfg_association(def_conf);
1273 seqassoc = (seqassoc << 4) | get_defcfg_sequence(def_conf);
1274 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE) {
1275 if (seqassoc == 0xff) {
1276 def_conf = def_conf & (~(AC_JACK_PORT_BOTH << 30));
1277 snd_hda_codec_set_pincfg(codec, nid, def_conf);
1284 static int vt1708_parse_auto_config(struct hda_codec *codec)
1286 struct via_spec *spec = codec->spec;
1289 /* Add HP and CD pin config connect bit re-config action */
1290 vt1708_set_pinconfig_connect(codec, VT1708_HP_PIN_NID);
1291 vt1708_set_pinconfig_connect(codec, VT1708_CD_PIN_NID);
1293 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
1296 err = vt1708_auto_fill_dac_nids(spec, &spec->autocfg);
1299 if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
1300 return 0; /* can't find valid BIOS pin config */
1302 err = vt1708_auto_create_multi_out_ctls(spec, &spec->autocfg);
1305 err = vt1708_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
1308 err = vt1708_auto_create_analog_input_ctls(spec, &spec->autocfg);
1312 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
1314 if (spec->autocfg.dig_outs)
1315 spec->multiout.dig_out_nid = VT1708_DIGOUT_NID;
1316 spec->dig_in_pin = VT1708_DIGIN_PIN;
1317 if (spec->autocfg.dig_in_pin)
1318 spec->dig_in_nid = VT1708_DIGIN_NID;
1320 if (spec->kctls.list)
1321 spec->mixers[spec->num_mixers++] = spec->kctls.list;
1323 spec->init_verbs[spec->num_iverbs++] = vt1708_volume_init_verbs;
1325 spec->input_mux = &spec->private_imux[0];
1328 spec->mixers[spec->num_mixers++] = via_hp_mixer;
1333 /* init callback for auto-configuration model -- overriding the default init */
1334 static int via_auto_init(struct hda_codec *codec)
1337 via_auto_init_multi_out(codec);
1338 via_auto_init_hp_out(codec);
1339 via_auto_init_analog_input(codec);
1343 static int patch_vt1708(struct hda_codec *codec)
1345 struct via_spec *spec;
1348 /* create a codec specific record */
1349 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1355 /* automatic parse from the BIOS config */
1356 err = vt1708_parse_auto_config(codec);
1361 printk(KERN_INFO "hda_codec: Cannot set up configuration "
1362 "from BIOS. Using genenic mode...\n");
1366 spec->stream_name_analog = "VT1708 Analog";
1367 spec->stream_analog_playback = &vt1708_pcm_analog_playback;
1368 /* disable 32bit format on VT1708 */
1369 if (codec->vendor_id == 0x11061708)
1370 spec->stream_analog_playback = &vt1708_pcm_analog_s16_playback;
1371 spec->stream_analog_capture = &vt1708_pcm_analog_capture;
1373 spec->stream_name_digital = "VT1708 Digital";
1374 spec->stream_digital_playback = &vt1708_pcm_digital_playback;
1375 spec->stream_digital_capture = &vt1708_pcm_digital_capture;
1378 if (!spec->adc_nids && spec->input_mux) {
1379 spec->adc_nids = vt1708_adc_nids;
1380 spec->num_adc_nids = ARRAY_SIZE(vt1708_adc_nids);
1381 spec->mixers[spec->num_mixers] = vt1708_capture_mixer;
1385 codec->patch_ops = via_patch_ops;
1387 codec->patch_ops.init = via_auto_init;
1388 #ifdef CONFIG_SND_HDA_POWER_SAVE
1389 spec->loopback.amplist = vt1708_loopbacks;
1395 /* capture mixer elements */
1396 static struct snd_kcontrol_new vt1709_capture_mixer[] = {
1397 HDA_CODEC_VOLUME("Capture Volume", 0x14, 0x0, HDA_INPUT),
1398 HDA_CODEC_MUTE("Capture Switch", 0x14, 0x0, HDA_INPUT),
1399 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x15, 0x0, HDA_INPUT),
1400 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x15, 0x0, HDA_INPUT),
1401 HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x16, 0x0, HDA_INPUT),
1402 HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x16, 0x0, HDA_INPUT),
1404 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1405 /* The multiple "Capture Source" controls confuse alsamixer
1406 * So call somewhat different..
1408 /* .name = "Capture Source", */
1409 .name = "Input Source",
1411 .info = via_mux_enum_info,
1412 .get = via_mux_enum_get,
1413 .put = via_mux_enum_put,
1418 static struct hda_verb vt1709_uniwill_init_verbs[] = {
1419 {0x20, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_HP_EVENT},
1424 * generic initialization of ADC, input mixers and output mixers
1426 static struct hda_verb vt1709_10ch_volume_init_verbs[] = {
1428 * Unmute ADC0-2 and set the default input to mic-in
1430 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1431 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1432 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1435 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
1438 /* Amp Indices: AOW0=0, CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
1439 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1440 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1441 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
1442 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
1443 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
1446 * Set up output selector (0x1a, 0x1b, 0x29)
1448 /* set vol=0 to output mixers */
1449 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1450 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1451 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1454 * Unmute PW3 and PW4
1456 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1457 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1459 /* Set input of PW4 as AOW4 */
1460 {0x20, AC_VERB_SET_CONNECT_SEL, 0x1},
1461 /* PW9 Output enable */
1462 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
1466 static struct hda_pcm_stream vt1709_10ch_pcm_analog_playback = {
1470 .nid = 0x10, /* NID to query formats and rates */
1472 .open = via_playback_pcm_open,
1473 .prepare = via_playback_pcm_prepare,
1474 .cleanup = via_playback_pcm_cleanup
1478 static struct hda_pcm_stream vt1709_6ch_pcm_analog_playback = {
1482 .nid = 0x10, /* NID to query formats and rates */
1484 .open = via_playback_pcm_open,
1485 .prepare = via_playback_pcm_prepare,
1486 .cleanup = via_playback_pcm_cleanup
1490 static struct hda_pcm_stream vt1709_pcm_analog_capture = {
1494 .nid = 0x14, /* NID to query formats and rates */
1496 .prepare = via_capture_pcm_prepare,
1497 .cleanup = via_capture_pcm_cleanup
1501 static struct hda_pcm_stream vt1709_pcm_digital_playback = {
1505 /* NID is set in via_build_pcms */
1507 .open = via_dig_playback_pcm_open,
1508 .close = via_dig_playback_pcm_close
1512 static struct hda_pcm_stream vt1709_pcm_digital_capture = {
1518 static int vt1709_auto_fill_dac_nids(struct via_spec *spec,
1519 const struct auto_pin_cfg *cfg)
1524 if (cfg->line_outs == 4) /* 10 channels */
1525 spec->multiout.num_dacs = cfg->line_outs+1; /* AOW0~AOW4 */
1526 else if (cfg->line_outs == 3) /* 6 channels */
1527 spec->multiout.num_dacs = cfg->line_outs; /* AOW0~AOW2 */
1529 spec->multiout.dac_nids = spec->private_dac_nids;
1531 if (cfg->line_outs == 4) { /* 10 channels */
1532 for (i = 0; i < cfg->line_outs; i++) {
1533 nid = cfg->line_out_pins[i];
1535 /* config dac list */
1537 case AUTO_SEQ_FRONT:
1539 spec->multiout.dac_nids[i] = 0x10;
1541 case AUTO_SEQ_CENLFE:
1543 spec->multiout.dac_nids[i] = 0x12;
1545 case AUTO_SEQ_SURROUND:
1547 spec->multiout.dac_nids[i] = 0x11;
1551 spec->multiout.dac_nids[i] = 0x27;
1558 spec->multiout.dac_nids[cfg->line_outs] = 0x28; /* AOW4 */
1560 } else if (cfg->line_outs == 3) { /* 6 channels */
1561 for(i = 0; i < cfg->line_outs; i++) {
1562 nid = cfg->line_out_pins[i];
1564 /* config dac list */
1566 case AUTO_SEQ_FRONT:
1568 spec->multiout.dac_nids[i] = 0x10;
1570 case AUTO_SEQ_CENLFE:
1572 spec->multiout.dac_nids[i] = 0x12;
1574 case AUTO_SEQ_SURROUND:
1576 spec->multiout.dac_nids[i] = 0x11;
1588 /* add playback controls from the parsed DAC table */
1589 static int vt1709_auto_create_multi_out_ctls(struct via_spec *spec,
1590 const struct auto_pin_cfg *cfg)
1593 static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" };
1597 for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
1598 nid = cfg->line_out_pins[i];
1603 if (i == AUTO_SEQ_CENLFE) {
1605 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1606 "Center Playback Volume",
1607 HDA_COMPOSE_AMP_VAL(0x1b, 1, 0,
1611 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1612 "LFE Playback Volume",
1613 HDA_COMPOSE_AMP_VAL(0x1b, 2, 0,
1617 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1618 "Center Playback Switch",
1619 HDA_COMPOSE_AMP_VAL(0x1b, 1, 0,
1623 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1624 "LFE Playback Switch",
1625 HDA_COMPOSE_AMP_VAL(0x1b, 2, 0,
1629 } else if (i == AUTO_SEQ_FRONT){
1630 /* add control to mixer index 0 */
1631 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1632 "Master Front Playback Volume",
1633 HDA_COMPOSE_AMP_VAL(0x18, 3, 0,
1637 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1638 "Master Front Playback Switch",
1639 HDA_COMPOSE_AMP_VAL(0x18, 3, 0,
1644 /* add control to PW3 */
1645 sprintf(name, "%s Playback Volume", chname[i]);
1646 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
1647 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
1651 sprintf(name, "%s Playback Switch", chname[i]);
1652 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
1653 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
1657 } else if (i == AUTO_SEQ_SURROUND) {
1658 sprintf(name, "%s Playback Volume", chname[i]);
1659 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
1660 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0,
1664 sprintf(name, "%s Playback Switch", chname[i]);
1665 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
1666 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0,
1670 } else if (i == AUTO_SEQ_SIDE) {
1671 sprintf(name, "%s Playback Volume", chname[i]);
1672 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
1673 HDA_COMPOSE_AMP_VAL(0x29, 3, 0,
1677 sprintf(name, "%s Playback Switch", chname[i]);
1678 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
1679 HDA_COMPOSE_AMP_VAL(0x29, 3, 0,
1689 static int vt1709_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
1696 if (spec->multiout.num_dacs == 5) /* 10 channels */
1697 spec->multiout.hp_nid = VT1709_HP_DAC_NID;
1698 else if (spec->multiout.num_dacs == 3) /* 6 channels */
1699 spec->multiout.hp_nid = 0;
1701 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1702 "Headphone Playback Volume",
1703 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
1706 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1707 "Headphone Playback Switch",
1708 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
1715 /* create playback/capture controls for input pins */
1716 static int vt1709_auto_create_analog_input_ctls(struct via_spec *spec,
1717 const struct auto_pin_cfg *cfg)
1719 static char *labels[] = {
1720 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
1722 struct hda_input_mux *imux = &spec->private_imux[0];
1723 int i, err, idx = 0;
1725 /* for internal loopback recording select */
1726 imux->items[imux->num_items].label = "Stereo Mixer";
1727 imux->items[imux->num_items].index = idx;
1730 for (i = 0; i < AUTO_PIN_LAST; i++) {
1731 if (!cfg->input_pins[i])
1734 switch (cfg->input_pins[i]) {
1735 case 0x1d: /* Mic */
1739 case 0x1e: /* Line In */
1743 case 0x21: /* Front Mic */
1751 err = via_new_analog_input(spec, cfg->input_pins[i], labels[i],
1755 imux->items[imux->num_items].label = labels[i];
1756 imux->items[imux->num_items].index = idx;
1762 static int vt1709_parse_auto_config(struct hda_codec *codec)
1764 struct via_spec *spec = codec->spec;
1767 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
1770 err = vt1709_auto_fill_dac_nids(spec, &spec->autocfg);
1773 if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
1774 return 0; /* can't find valid BIOS pin config */
1776 err = vt1709_auto_create_multi_out_ctls(spec, &spec->autocfg);
1779 err = vt1709_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
1782 err = vt1709_auto_create_analog_input_ctls(spec, &spec->autocfg);
1786 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
1788 if (spec->autocfg.dig_outs)
1789 spec->multiout.dig_out_nid = VT1709_DIGOUT_NID;
1790 spec->dig_in_pin = VT1709_DIGIN_PIN;
1791 if (spec->autocfg.dig_in_pin)
1792 spec->dig_in_nid = VT1709_DIGIN_NID;
1794 if (spec->kctls.list)
1795 spec->mixers[spec->num_mixers++] = spec->kctls.list;
1797 spec->input_mux = &spec->private_imux[0];
1800 spec->mixers[spec->num_mixers++] = via_hp_mixer;
1805 #ifdef CONFIG_SND_HDA_POWER_SAVE
1806 static struct hda_amp_list vt1709_loopbacks[] = {
1807 { 0x18, HDA_INPUT, 1 },
1808 { 0x18, HDA_INPUT, 2 },
1809 { 0x18, HDA_INPUT, 3 },
1810 { 0x18, HDA_INPUT, 4 },
1815 static int patch_vt1709_10ch(struct hda_codec *codec)
1817 struct via_spec *spec;
1820 /* create a codec specific record */
1821 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1827 err = vt1709_parse_auto_config(codec);
1832 printk(KERN_INFO "hda_codec: Cannot set up configuration. "
1833 "Using genenic mode...\n");
1836 spec->init_verbs[spec->num_iverbs++] = vt1709_10ch_volume_init_verbs;
1837 spec->init_verbs[spec->num_iverbs++] = vt1709_uniwill_init_verbs;
1839 spec->stream_name_analog = "VT1709 Analog";
1840 spec->stream_analog_playback = &vt1709_10ch_pcm_analog_playback;
1841 spec->stream_analog_capture = &vt1709_pcm_analog_capture;
1843 spec->stream_name_digital = "VT1709 Digital";
1844 spec->stream_digital_playback = &vt1709_pcm_digital_playback;
1845 spec->stream_digital_capture = &vt1709_pcm_digital_capture;
1848 if (!spec->adc_nids && spec->input_mux) {
1849 spec->adc_nids = vt1709_adc_nids;
1850 spec->num_adc_nids = ARRAY_SIZE(vt1709_adc_nids);
1851 spec->mixers[spec->num_mixers] = vt1709_capture_mixer;
1855 codec->patch_ops = via_patch_ops;
1857 codec->patch_ops.init = via_auto_init;
1858 codec->patch_ops.unsol_event = via_unsol_event;
1859 #ifdef CONFIG_SND_HDA_POWER_SAVE
1860 spec->loopback.amplist = vt1709_loopbacks;
1866 * generic initialization of ADC, input mixers and output mixers
1868 static struct hda_verb vt1709_6ch_volume_init_verbs[] = {
1870 * Unmute ADC0-2 and set the default input to mic-in
1872 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1873 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1874 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1877 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
1880 /* Amp Indices: AOW0=0, CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
1881 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1882 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1883 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
1884 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
1885 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
1888 * Set up output selector (0x1a, 0x1b, 0x29)
1890 /* set vol=0 to output mixers */
1891 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1892 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1893 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1896 * Unmute PW3 and PW4
1898 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1899 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1901 /* Set input of PW4 as MW0 */
1902 {0x20, AC_VERB_SET_CONNECT_SEL, 0},
1903 /* PW9 Output enable */
1904 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
1908 static int patch_vt1709_6ch(struct hda_codec *codec)
1910 struct via_spec *spec;
1913 /* create a codec specific record */
1914 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1920 err = vt1709_parse_auto_config(codec);
1925 printk(KERN_INFO "hda_codec: Cannot set up configuration. "
1926 "Using genenic mode...\n");
1929 spec->init_verbs[spec->num_iverbs++] = vt1709_6ch_volume_init_verbs;
1930 spec->init_verbs[spec->num_iverbs++] = vt1709_uniwill_init_verbs;
1932 spec->stream_name_analog = "VT1709 Analog";
1933 spec->stream_analog_playback = &vt1709_6ch_pcm_analog_playback;
1934 spec->stream_analog_capture = &vt1709_pcm_analog_capture;
1936 spec->stream_name_digital = "VT1709 Digital";
1937 spec->stream_digital_playback = &vt1709_pcm_digital_playback;
1938 spec->stream_digital_capture = &vt1709_pcm_digital_capture;
1941 if (!spec->adc_nids && spec->input_mux) {
1942 spec->adc_nids = vt1709_adc_nids;
1943 spec->num_adc_nids = ARRAY_SIZE(vt1709_adc_nids);
1944 spec->mixers[spec->num_mixers] = vt1709_capture_mixer;
1948 codec->patch_ops = via_patch_ops;
1950 codec->patch_ops.init = via_auto_init;
1951 codec->patch_ops.unsol_event = via_unsol_event;
1952 #ifdef CONFIG_SND_HDA_POWER_SAVE
1953 spec->loopback.amplist = vt1709_loopbacks;
1958 /* capture mixer elements */
1959 static struct snd_kcontrol_new vt1708B_capture_mixer[] = {
1960 HDA_CODEC_VOLUME("Capture Volume", 0x13, 0x0, HDA_INPUT),
1961 HDA_CODEC_MUTE("Capture Switch", 0x13, 0x0, HDA_INPUT),
1962 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x14, 0x0, HDA_INPUT),
1963 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x14, 0x0, HDA_INPUT),
1965 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1966 /* The multiple "Capture Source" controls confuse alsamixer
1967 * So call somewhat different..
1969 /* .name = "Capture Source", */
1970 .name = "Input Source",
1972 .info = via_mux_enum_info,
1973 .get = via_mux_enum_get,
1974 .put = via_mux_enum_put,
1979 * generic initialization of ADC, input mixers and output mixers
1981 static struct hda_verb vt1708B_8ch_volume_init_verbs[] = {
1983 * Unmute ADC0-1 and set the default input to mic-in
1985 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1986 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1989 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
1992 /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
1993 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1994 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1995 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
1996 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
1997 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
2000 * Set up output mixers
2002 /* set vol=0 to output mixers */
2003 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2004 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2005 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2007 /* Setup default input to PW4 */
2008 {0x1d, AC_VERB_SET_CONNECT_SEL, 0x1},
2009 /* PW9 Output enable */
2010 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
2011 /* PW10 Input enable */
2012 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
2016 static struct hda_verb vt1708B_4ch_volume_init_verbs[] = {
2018 * Unmute ADC0-1 and set the default input to mic-in
2020 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2021 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2024 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
2027 /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
2028 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2029 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2030 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
2031 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
2032 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
2035 * Set up output mixers
2037 /* set vol=0 to output mixers */
2038 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2039 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2040 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2042 /* Setup default input of PW4 to MW0 */
2043 {0x1d, AC_VERB_SET_CONNECT_SEL, 0x0},
2044 /* PW9 Output enable */
2045 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
2046 /* PW10 Input enable */
2047 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
2051 static struct hda_verb vt1708B_uniwill_init_verbs[] = {
2052 {0x1D, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_HP_EVENT},
2056 static struct hda_pcm_stream vt1708B_8ch_pcm_analog_playback = {
2060 .nid = 0x10, /* NID to query formats and rates */
2062 .open = via_playback_pcm_open,
2063 .prepare = via_playback_multi_pcm_prepare,
2064 .cleanup = via_playback_multi_pcm_cleanup
2068 static struct hda_pcm_stream vt1708B_4ch_pcm_analog_playback = {
2072 .nid = 0x10, /* NID to query formats and rates */
2074 .open = via_playback_pcm_open,
2075 .prepare = via_playback_multi_pcm_prepare,
2076 .cleanup = via_playback_multi_pcm_cleanup
2080 static struct hda_pcm_stream vt1708B_pcm_analog_capture = {
2084 .nid = 0x13, /* NID to query formats and rates */
2086 .prepare = via_capture_pcm_prepare,
2087 .cleanup = via_capture_pcm_cleanup
2091 static struct hda_pcm_stream vt1708B_pcm_digital_playback = {
2095 /* NID is set in via_build_pcms */
2097 .open = via_dig_playback_pcm_open,
2098 .close = via_dig_playback_pcm_close,
2099 .prepare = via_dig_playback_pcm_prepare,
2100 .cleanup = via_dig_playback_pcm_cleanup
2104 static struct hda_pcm_stream vt1708B_pcm_digital_capture = {
2110 /* fill in the dac_nids table from the parsed pin configuration */
2111 static int vt1708B_auto_fill_dac_nids(struct via_spec *spec,
2112 const struct auto_pin_cfg *cfg)
2117 spec->multiout.num_dacs = cfg->line_outs;
2119 spec->multiout.dac_nids = spec->private_dac_nids;
2121 for (i = 0; i < 4; i++) {
2122 nid = cfg->line_out_pins[i];
2124 /* config dac list */
2126 case AUTO_SEQ_FRONT:
2127 spec->multiout.dac_nids[i] = 0x10;
2129 case AUTO_SEQ_CENLFE:
2130 spec->multiout.dac_nids[i] = 0x24;
2132 case AUTO_SEQ_SURROUND:
2133 spec->multiout.dac_nids[i] = 0x11;
2136 spec->multiout.dac_nids[i] = 0x25;
2145 /* add playback controls from the parsed DAC table */
2146 static int vt1708B_auto_create_multi_out_ctls(struct via_spec *spec,
2147 const struct auto_pin_cfg *cfg)
2150 static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" };
2151 hda_nid_t nid_vols[] = {0x16, 0x18, 0x26, 0x27};
2152 hda_nid_t nid, nid_vol = 0;
2155 for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
2156 nid = cfg->line_out_pins[i];
2161 nid_vol = nid_vols[i];
2163 if (i == AUTO_SEQ_CENLFE) {
2165 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2166 "Center Playback Volume",
2167 HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
2171 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2172 "LFE Playback Volume",
2173 HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
2177 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2178 "Center Playback Switch",
2179 HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
2183 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2184 "LFE Playback Switch",
2185 HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
2189 } else if (i == AUTO_SEQ_FRONT) {
2190 /* add control to mixer index 0 */
2191 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2192 "Master Front Playback Volume",
2193 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
2197 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2198 "Master Front Playback Switch",
2199 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
2204 /* add control to PW3 */
2205 sprintf(name, "%s Playback Volume", chname[i]);
2206 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
2207 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
2211 sprintf(name, "%s Playback Switch", chname[i]);
2212 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
2213 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
2218 sprintf(name, "%s Playback Volume", chname[i]);
2219 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
2220 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
2224 sprintf(name, "%s Playback Switch", chname[i]);
2225 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
2226 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
2236 static int vt1708B_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
2243 spec->multiout.hp_nid = VT1708B_HP_NID; /* AOW3 */
2245 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2246 "Headphone Playback Volume",
2247 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
2250 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2251 "Headphone Playback Switch",
2252 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
2256 create_hp_imux(spec);
2261 /* create playback/capture controls for input pins */
2262 static int vt1708B_auto_create_analog_input_ctls(struct via_spec *spec,
2263 const struct auto_pin_cfg *cfg)
2265 static char *labels[] = {
2266 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
2268 struct hda_input_mux *imux = &spec->private_imux[0];
2269 int i, err, idx = 0;
2271 /* for internal loopback recording select */
2272 imux->items[imux->num_items].label = "Stereo Mixer";
2273 imux->items[imux->num_items].index = idx;
2276 for (i = 0; i < AUTO_PIN_LAST; i++) {
2277 if (!cfg->input_pins[i])
2280 switch (cfg->input_pins[i]) {
2281 case 0x1a: /* Mic */
2285 case 0x1b: /* Line In */
2289 case 0x1e: /* Front Mic */
2297 err = via_new_analog_input(spec, cfg->input_pins[i], labels[i],
2301 imux->items[imux->num_items].label = labels[i];
2302 imux->items[imux->num_items].index = idx;
2308 static int vt1708B_parse_auto_config(struct hda_codec *codec)
2310 struct via_spec *spec = codec->spec;
2313 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
2316 err = vt1708B_auto_fill_dac_nids(spec, &spec->autocfg);
2319 if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
2320 return 0; /* can't find valid BIOS pin config */
2322 err = vt1708B_auto_create_multi_out_ctls(spec, &spec->autocfg);
2325 err = vt1708B_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
2328 err = vt1708B_auto_create_analog_input_ctls(spec, &spec->autocfg);
2332 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
2334 if (spec->autocfg.dig_outs)
2335 spec->multiout.dig_out_nid = VT1708B_DIGOUT_NID;
2336 spec->dig_in_pin = VT1708B_DIGIN_PIN;
2337 if (spec->autocfg.dig_in_pin)
2338 spec->dig_in_nid = VT1708B_DIGIN_NID;
2340 if (spec->kctls.list)
2341 spec->mixers[spec->num_mixers++] = spec->kctls.list;
2343 spec->input_mux = &spec->private_imux[0];
2346 spec->mixers[spec->num_mixers++] = via_hp_mixer;
2351 #ifdef CONFIG_SND_HDA_POWER_SAVE
2352 static struct hda_amp_list vt1708B_loopbacks[] = {
2353 { 0x16, HDA_INPUT, 1 },
2354 { 0x16, HDA_INPUT, 2 },
2355 { 0x16, HDA_INPUT, 3 },
2356 { 0x16, HDA_INPUT, 4 },
2361 static int patch_vt1708B_8ch(struct hda_codec *codec)
2363 struct via_spec *spec;
2366 /* create a codec specific record */
2367 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2373 /* automatic parse from the BIOS config */
2374 err = vt1708B_parse_auto_config(codec);
2379 printk(KERN_INFO "hda_codec: Cannot set up configuration "
2380 "from BIOS. Using genenic mode...\n");
2383 spec->init_verbs[spec->num_iverbs++] = vt1708B_8ch_volume_init_verbs;
2384 spec->init_verbs[spec->num_iverbs++] = vt1708B_uniwill_init_verbs;
2386 spec->stream_name_analog = "VT1708B Analog";
2387 spec->stream_analog_playback = &vt1708B_8ch_pcm_analog_playback;
2388 spec->stream_analog_capture = &vt1708B_pcm_analog_capture;
2390 spec->stream_name_digital = "VT1708B Digital";
2391 spec->stream_digital_playback = &vt1708B_pcm_digital_playback;
2392 spec->stream_digital_capture = &vt1708B_pcm_digital_capture;
2394 if (!spec->adc_nids && spec->input_mux) {
2395 spec->adc_nids = vt1708B_adc_nids;
2396 spec->num_adc_nids = ARRAY_SIZE(vt1708B_adc_nids);
2397 spec->mixers[spec->num_mixers] = vt1708B_capture_mixer;
2401 codec->patch_ops = via_patch_ops;
2403 codec->patch_ops.init = via_auto_init;
2404 codec->patch_ops.unsol_event = via_unsol_event;
2405 #ifdef CONFIG_SND_HDA_POWER_SAVE
2406 spec->loopback.amplist = vt1708B_loopbacks;
2412 static int patch_vt1708B_4ch(struct hda_codec *codec)
2414 struct via_spec *spec;
2417 /* create a codec specific record */
2418 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2424 /* automatic parse from the BIOS config */
2425 err = vt1708B_parse_auto_config(codec);
2430 printk(KERN_INFO "hda_codec: Cannot set up configuration "
2431 "from BIOS. Using genenic mode...\n");
2434 spec->init_verbs[spec->num_iverbs++] = vt1708B_4ch_volume_init_verbs;
2435 spec->init_verbs[spec->num_iverbs++] = vt1708B_uniwill_init_verbs;
2437 spec->stream_name_analog = "VT1708B Analog";
2438 spec->stream_analog_playback = &vt1708B_4ch_pcm_analog_playback;
2439 spec->stream_analog_capture = &vt1708B_pcm_analog_capture;
2441 spec->stream_name_digital = "VT1708B Digital";
2442 spec->stream_digital_playback = &vt1708B_pcm_digital_playback;
2443 spec->stream_digital_capture = &vt1708B_pcm_digital_capture;
2445 if (!spec->adc_nids && spec->input_mux) {
2446 spec->adc_nids = vt1708B_adc_nids;
2447 spec->num_adc_nids = ARRAY_SIZE(vt1708B_adc_nids);
2448 spec->mixers[spec->num_mixers] = vt1708B_capture_mixer;
2452 codec->patch_ops = via_patch_ops;
2454 codec->patch_ops.init = via_auto_init;
2455 codec->patch_ops.unsol_event = via_unsol_event;
2456 #ifdef CONFIG_SND_HDA_POWER_SAVE
2457 spec->loopback.amplist = vt1708B_loopbacks;
2463 /* Patch for VT1708S */
2465 /* VT1708S software backdoor based override for buggy hardware micboost
2467 #define MIC_BOOST_VOLUME(xname, nid) { \
2468 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2471 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
2472 SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
2473 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK, \
2474 .info = mic_boost_volume_info, \
2475 .get = snd_hda_mixer_amp_volume_get, \
2476 .put = snd_hda_mixer_amp_volume_put, \
2477 .tlv = { .c = mic_boost_tlv }, \
2478 .private_value = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT) }
2480 /* capture mixer elements */
2481 static struct snd_kcontrol_new vt1708S_capture_mixer[] = {
2482 HDA_CODEC_VOLUME("Capture Volume", 0x13, 0x0, HDA_INPUT),
2483 HDA_CODEC_MUTE("Capture Switch", 0x13, 0x0, HDA_INPUT),
2484 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x14, 0x0, HDA_INPUT),
2485 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x14, 0x0, HDA_INPUT),
2486 MIC_BOOST_VOLUME("Mic Boost Capture Volume", 0x1A),
2487 MIC_BOOST_VOLUME("Front Mic Boost Capture Volume", 0x1E),
2489 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2490 /* The multiple "Capture Source" controls confuse alsamixer
2491 * So call somewhat different..
2493 /* .name = "Capture Source", */
2494 .name = "Input Source",
2496 .info = via_mux_enum_info,
2497 .get = via_mux_enum_get,
2498 .put = via_mux_enum_put,
2503 static struct hda_verb vt1708S_volume_init_verbs[] = {
2504 /* Unmute ADC0-1 and set the default input to mic-in */
2505 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2506 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2508 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the
2509 * analog-loopback mixer widget */
2510 /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
2511 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2512 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2513 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
2514 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
2515 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
2517 /* Setup default input of PW4 to MW0 */
2518 {0x1d, AC_VERB_SET_CONNECT_SEL, 0x0},
2519 /* PW9, PW10 Output enable */
2520 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
2521 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
2522 /* Enable Mic Boost Volume backdoor */
2527 static struct hda_verb vt1708S_uniwill_init_verbs[] = {
2528 {0x1D, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_HP_EVENT},
2532 static struct hda_pcm_stream vt1708S_pcm_analog_playback = {
2536 .nid = 0x10, /* NID to query formats and rates */
2538 .open = via_playback_pcm_open,
2539 .prepare = via_playback_pcm_prepare,
2540 .cleanup = via_playback_pcm_cleanup
2544 static struct hda_pcm_stream vt1708S_pcm_analog_capture = {
2548 .nid = 0x13, /* NID to query formats and rates */
2550 .prepare = via_capture_pcm_prepare,
2551 .cleanup = via_capture_pcm_cleanup
2555 static struct hda_pcm_stream vt1708S_pcm_digital_playback = {
2559 /* NID is set in via_build_pcms */
2561 .open = via_dig_playback_pcm_open,
2562 .close = via_dig_playback_pcm_close,
2563 .prepare = via_dig_playback_pcm_prepare,
2564 .cleanup = via_dig_playback_pcm_cleanup
2568 /* fill in the dac_nids table from the parsed pin configuration */
2569 static int vt1708S_auto_fill_dac_nids(struct via_spec *spec,
2570 const struct auto_pin_cfg *cfg)
2575 spec->multiout.num_dacs = cfg->line_outs;
2577 spec->multiout.dac_nids = spec->private_dac_nids;
2579 for (i = 0; i < 4; i++) {
2580 nid = cfg->line_out_pins[i];
2582 /* config dac list */
2584 case AUTO_SEQ_FRONT:
2585 spec->multiout.dac_nids[i] = 0x10;
2587 case AUTO_SEQ_CENLFE:
2588 spec->multiout.dac_nids[i] = 0x24;
2590 case AUTO_SEQ_SURROUND:
2591 spec->multiout.dac_nids[i] = 0x11;
2594 spec->multiout.dac_nids[i] = 0x25;
2603 /* add playback controls from the parsed DAC table */
2604 static int vt1708S_auto_create_multi_out_ctls(struct via_spec *spec,
2605 const struct auto_pin_cfg *cfg)
2608 static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" };
2609 hda_nid_t nid_vols[] = {0x10, 0x11, 0x24, 0x25};
2610 hda_nid_t nid_mutes[] = {0x1C, 0x18, 0x26, 0x27};
2611 hda_nid_t nid, nid_vol, nid_mute;
2614 for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
2615 nid = cfg->line_out_pins[i];
2620 nid_vol = nid_vols[i];
2621 nid_mute = nid_mutes[i];
2623 if (i == AUTO_SEQ_CENLFE) {
2625 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2626 "Center Playback Volume",
2627 HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
2631 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2632 "LFE Playback Volume",
2633 HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
2637 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2638 "Center Playback Switch",
2639 HDA_COMPOSE_AMP_VAL(nid_mute,
2644 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2645 "LFE Playback Switch",
2646 HDA_COMPOSE_AMP_VAL(nid_mute,
2651 } else if (i == AUTO_SEQ_FRONT) {
2652 /* add control to mixer index 0 */
2653 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2654 "Master Front Playback Volume",
2655 HDA_COMPOSE_AMP_VAL(0x16, 3, 0,
2659 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2660 "Master Front Playback Switch",
2661 HDA_COMPOSE_AMP_VAL(0x16, 3, 0,
2667 sprintf(name, "%s Playback Volume", chname[i]);
2668 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
2669 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
2673 sprintf(name, "%s Playback Switch", chname[i]);
2674 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
2675 HDA_COMPOSE_AMP_VAL(nid_mute,
2681 sprintf(name, "%s Playback Volume", chname[i]);
2682 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
2683 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
2687 sprintf(name, "%s Playback Switch", chname[i]);
2688 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
2689 HDA_COMPOSE_AMP_VAL(nid_mute,
2700 static int vt1708S_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
2707 spec->multiout.hp_nid = VT1708S_HP_NID; /* AOW3 */
2709 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2710 "Headphone Playback Volume",
2711 HDA_COMPOSE_AMP_VAL(0x25, 3, 0, HDA_OUTPUT));
2715 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2716 "Headphone Playback Switch",
2717 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
2721 create_hp_imux(spec);
2726 /* create playback/capture controls for input pins */
2727 static int vt1708S_auto_create_analog_input_ctls(struct via_spec *spec,
2728 const struct auto_pin_cfg *cfg)
2730 static char *labels[] = {
2731 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
2733 struct hda_input_mux *imux = &spec->private_imux[0];
2734 int i, err, idx = 0;
2736 /* for internal loopback recording select */
2737 imux->items[imux->num_items].label = "Stereo Mixer";
2738 imux->items[imux->num_items].index = 5;
2741 for (i = 0; i < AUTO_PIN_LAST; i++) {
2742 if (!cfg->input_pins[i])
2745 switch (cfg->input_pins[i]) {
2746 case 0x1a: /* Mic */
2750 case 0x1b: /* Line In */
2754 case 0x1e: /* Front Mic */
2762 err = via_new_analog_input(spec, cfg->input_pins[i], labels[i],
2766 imux->items[imux->num_items].label = labels[i];
2767 imux->items[imux->num_items].index = idx-1;
2773 /* fill out digital output widgets; one for master and one for slave outputs */
2774 static void fill_dig_outs(struct hda_codec *codec)
2776 struct via_spec *spec = codec->spec;
2779 for (i = 0; i < spec->autocfg.dig_outs; i++) {
2783 nid = spec->autocfg.dig_out_pins[i];
2786 conn = snd_hda_get_connections(codec, nid, &nid, 1);
2789 if (!spec->multiout.dig_out_nid)
2790 spec->multiout.dig_out_nid = nid;
2792 spec->slave_dig_outs[0] = nid;
2793 break; /* at most two dig outs */
2798 static int vt1708S_parse_auto_config(struct hda_codec *codec)
2800 struct via_spec *spec = codec->spec;
2803 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
2806 err = vt1708S_auto_fill_dac_nids(spec, &spec->autocfg);
2809 if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
2810 return 0; /* can't find valid BIOS pin config */
2812 err = vt1708S_auto_create_multi_out_ctls(spec, &spec->autocfg);
2815 err = vt1708S_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
2818 err = vt1708S_auto_create_analog_input_ctls(spec, &spec->autocfg);
2822 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
2824 fill_dig_outs(codec);
2826 if (spec->kctls.list)
2827 spec->mixers[spec->num_mixers++] = spec->kctls.list;
2829 spec->input_mux = &spec->private_imux[0];
2832 spec->mixers[spec->num_mixers++] = via_hp_mixer;
2837 #ifdef CONFIG_SND_HDA_POWER_SAVE
2838 static struct hda_amp_list vt1708S_loopbacks[] = {
2839 { 0x16, HDA_INPUT, 1 },
2840 { 0x16, HDA_INPUT, 2 },
2841 { 0x16, HDA_INPUT, 3 },
2842 { 0x16, HDA_INPUT, 4 },
2847 static int patch_vt1708S(struct hda_codec *codec)
2849 struct via_spec *spec;
2852 /* create a codec specific record */
2853 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2859 /* automatic parse from the BIOS config */
2860 err = vt1708S_parse_auto_config(codec);
2865 printk(KERN_INFO "hda_codec: Cannot set up configuration "
2866 "from BIOS. Using genenic mode...\n");
2869 spec->init_verbs[spec->num_iverbs++] = vt1708S_volume_init_verbs;
2870 spec->init_verbs[spec->num_iverbs++] = vt1708S_uniwill_init_verbs;
2872 spec->stream_name_analog = "VT1708S Analog";
2873 spec->stream_analog_playback = &vt1708S_pcm_analog_playback;
2874 spec->stream_analog_capture = &vt1708S_pcm_analog_capture;
2876 spec->stream_name_digital = "VT1708S Digital";
2877 spec->stream_digital_playback = &vt1708S_pcm_digital_playback;
2879 if (!spec->adc_nids && spec->input_mux) {
2880 spec->adc_nids = vt1708S_adc_nids;
2881 spec->num_adc_nids = ARRAY_SIZE(vt1708S_adc_nids);
2882 spec->mixers[spec->num_mixers] = vt1708S_capture_mixer;
2886 codec->patch_ops = via_patch_ops;
2888 codec->patch_ops.init = via_auto_init;
2889 codec->patch_ops.unsol_event = via_unsol_event;
2890 #ifdef CONFIG_SND_HDA_POWER_SAVE
2891 spec->loopback.amplist = vt1708S_loopbacks;
2897 /* Patch for VT1702 */
2899 /* capture mixer elements */
2900 static struct snd_kcontrol_new vt1702_capture_mixer[] = {
2901 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_INPUT),
2902 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_INPUT),
2903 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x20, 0x0, HDA_INPUT),
2904 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x20, 0x0, HDA_INPUT),
2905 HDA_CODEC_VOLUME("Digital Mic Capture Volume", 0x1F, 0x0, HDA_INPUT),
2906 HDA_CODEC_MUTE("Digital Mic Capture Switch", 0x1F, 0x0, HDA_INPUT),
2907 HDA_CODEC_VOLUME("Digital Mic Boost Capture Volume", 0x1E, 0x0,
2910 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2911 /* The multiple "Capture Source" controls confuse alsamixer
2912 * So call somewhat different..
2914 /* .name = "Capture Source", */
2915 .name = "Input Source",
2917 .info = via_mux_enum_info,
2918 .get = via_mux_enum_get,
2919 .put = via_mux_enum_put,
2924 static struct hda_verb vt1702_volume_init_verbs[] = {
2926 * Unmute ADC0-1 and set the default input to mic-in
2928 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2929 {0x1F, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2930 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2933 /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
2936 /* Amp Indices: Mic1 = 1, Line = 1, Mic2 = 3 */
2937 {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2938 {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2939 {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
2940 {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
2941 {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2943 /* Setup default input of PW4 to MW0 */
2944 {0x17, AC_VERB_SET_CONNECT_SEL, 0x1},
2945 /* PW6 PW7 Output enable */
2946 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
2947 {0x1C, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
2951 static struct hda_verb vt1702_uniwill_init_verbs[] = {
2952 {0x01, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_GPIO_EVENT},
2953 {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_HP_EVENT},
2957 static struct hda_pcm_stream vt1702_pcm_analog_playback = {
2961 .nid = 0x10, /* NID to query formats and rates */
2963 .open = via_playback_pcm_open,
2964 .prepare = via_playback_multi_pcm_prepare,
2965 .cleanup = via_playback_multi_pcm_cleanup
2969 static struct hda_pcm_stream vt1702_pcm_analog_capture = {
2973 .nid = 0x12, /* NID to query formats and rates */
2975 .prepare = via_capture_pcm_prepare,
2976 .cleanup = via_capture_pcm_cleanup
2980 static struct hda_pcm_stream vt1702_pcm_digital_playback = {
2984 /* NID is set in via_build_pcms */
2986 .open = via_dig_playback_pcm_open,
2987 .close = via_dig_playback_pcm_close,
2988 .prepare = via_dig_playback_pcm_prepare,
2989 .cleanup = via_dig_playback_pcm_cleanup
2993 /* fill in the dac_nids table from the parsed pin configuration */
2994 static int vt1702_auto_fill_dac_nids(struct via_spec *spec,
2995 const struct auto_pin_cfg *cfg)
2997 spec->multiout.num_dacs = 1;
2998 spec->multiout.dac_nids = spec->private_dac_nids;
3000 if (cfg->line_out_pins[0]) {
3001 /* config dac list */
3002 spec->multiout.dac_nids[0] = 0x10;
3008 /* add playback controls from the parsed DAC table */
3009 static int vt1702_auto_create_line_out_ctls(struct via_spec *spec,
3010 const struct auto_pin_cfg *cfg)
3014 if (!cfg->line_out_pins[0])
3017 /* add control to mixer index 0 */
3018 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
3019 "Master Front Playback Volume",
3020 HDA_COMPOSE_AMP_VAL(0x1A, 3, 0, HDA_INPUT));
3023 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
3024 "Master Front Playback Switch",
3025 HDA_COMPOSE_AMP_VAL(0x1A, 3, 0, HDA_INPUT));
3030 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
3031 "Front Playback Volume",
3032 HDA_COMPOSE_AMP_VAL(0x10, 3, 0, HDA_OUTPUT));
3035 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
3036 "Front Playback Switch",
3037 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT));
3044 static int vt1702_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
3051 spec->multiout.hp_nid = 0x1D;
3053 err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
3054 "Headphone Playback Volume",
3055 HDA_COMPOSE_AMP_VAL(0x1D, 3, 0, HDA_OUTPUT));
3059 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
3060 "Headphone Playback Switch",
3061 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
3065 create_hp_imux(spec);
3070 /* create playback/capture controls for input pins */
3071 static int vt1702_auto_create_analog_input_ctls(struct via_spec *spec,
3072 const struct auto_pin_cfg *cfg)
3074 static char *labels[] = {
3075 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
3077 struct hda_input_mux *imux = &spec->private_imux[0];
3078 int i, err, idx = 0;
3080 /* for internal loopback recording select */
3081 imux->items[imux->num_items].label = "Stereo Mixer";
3082 imux->items[imux->num_items].index = 3;
3085 for (i = 0; i < AUTO_PIN_LAST; i++) {
3086 if (!cfg->input_pins[i])
3089 switch (cfg->input_pins[i]) {
3090 case 0x14: /* Mic */
3094 case 0x15: /* Line In */
3098 case 0x18: /* Front Mic */
3102 err = via_new_analog_input(spec, cfg->input_pins[i],
3103 labels[i], idx, 0x1A);
3106 imux->items[imux->num_items].label = labels[i];
3107 imux->items[imux->num_items].index = idx-1;
3113 static int vt1702_parse_auto_config(struct hda_codec *codec)
3115 struct via_spec *spec = codec->spec;
3118 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
3121 err = vt1702_auto_fill_dac_nids(spec, &spec->autocfg);
3124 if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
3125 return 0; /* can't find valid BIOS pin config */
3127 err = vt1702_auto_create_line_out_ctls(spec, &spec->autocfg);
3130 err = vt1702_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
3133 err = vt1702_auto_create_analog_input_ctls(spec, &spec->autocfg);
3137 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3139 fill_dig_outs(codec);
3141 if (spec->kctls.list)
3142 spec->mixers[spec->num_mixers++] = spec->kctls.list;
3144 spec->input_mux = &spec->private_imux[0];
3147 spec->mixers[spec->num_mixers++] = via_hp_mixer;
3152 #ifdef CONFIG_SND_HDA_POWER_SAVE
3153 static struct hda_amp_list vt1702_loopbacks[] = {
3154 { 0x1A, HDA_INPUT, 1 },
3155 { 0x1A, HDA_INPUT, 2 },
3156 { 0x1A, HDA_INPUT, 3 },
3157 { 0x1A, HDA_INPUT, 4 },
3162 static int patch_vt1702(struct hda_codec *codec)
3164 struct via_spec *spec;
3166 unsigned int response;
3167 unsigned char control;
3169 /* create a codec specific record */
3170 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3176 /* automatic parse from the BIOS config */
3177 err = vt1702_parse_auto_config(codec);
3182 printk(KERN_INFO "hda_codec: Cannot set up configuration "
3183 "from BIOS. Using genenic mode...\n");
3186 spec->init_verbs[spec->num_iverbs++] = vt1702_volume_init_verbs;
3187 spec->init_verbs[spec->num_iverbs++] = vt1702_uniwill_init_verbs;
3189 spec->stream_name_analog = "VT1702 Analog";
3190 spec->stream_analog_playback = &vt1702_pcm_analog_playback;
3191 spec->stream_analog_capture = &vt1702_pcm_analog_capture;
3193 spec->stream_name_digital = "VT1702 Digital";
3194 spec->stream_digital_playback = &vt1702_pcm_digital_playback;
3196 if (!spec->adc_nids && spec->input_mux) {
3197 spec->adc_nids = vt1702_adc_nids;
3198 spec->num_adc_nids = ARRAY_SIZE(vt1702_adc_nids);
3199 spec->mixers[spec->num_mixers] = vt1702_capture_mixer;
3203 codec->patch_ops = via_patch_ops;
3205 codec->patch_ops.init = via_auto_init;
3206 codec->patch_ops.unsol_event = via_unsol_event;
3207 #ifdef CONFIG_SND_HDA_POWER_SAVE
3208 spec->loopback.amplist = vt1702_loopbacks;
3212 response = snd_hda_codec_read(codec, codec->afg, 0, 0xF8C, 0);
3213 control = (unsigned char)(response & 0xff);
3215 snd_hda_codec_write(codec, codec->afg, 0, 0xF88, control);
3217 /* Enable GPIO 0&1 for volume&mute control */
3218 /* Enable GPIO 2 for DMIC-DATA */
3219 response = snd_hda_codec_read(codec, codec->afg, 0, 0xF84, 0);
3220 control = (unsigned char)((response >> 16) & 0x3f);
3221 snd_hda_codec_write(codec, codec->afg, 0, 0xF82, control);
3229 static struct hda_codec_preset snd_hda_preset_via[] = {
3230 { .id = 0x11061708, .name = "VT1708", .patch = patch_vt1708},
3231 { .id = 0x11061709, .name = "VT1708", .patch = patch_vt1708},
3232 { .id = 0x1106170a, .name = "VT1708", .patch = patch_vt1708},
3233 { .id = 0x1106170b, .name = "VT1708", .patch = patch_vt1708},
3234 { .id = 0x1106e710, .name = "VT1709 10-Ch",
3235 .patch = patch_vt1709_10ch},
3236 { .id = 0x1106e711, .name = "VT1709 10-Ch",
3237 .patch = patch_vt1709_10ch},
3238 { .id = 0x1106e712, .name = "VT1709 10-Ch",
3239 .patch = patch_vt1709_10ch},
3240 { .id = 0x1106e713, .name = "VT1709 10-Ch",
3241 .patch = patch_vt1709_10ch},
3242 { .id = 0x1106e714, .name = "VT1709 6-Ch",
3243 .patch = patch_vt1709_6ch},
3244 { .id = 0x1106e715, .name = "VT1709 6-Ch",
3245 .patch = patch_vt1709_6ch},
3246 { .id = 0x1106e716, .name = "VT1709 6-Ch",
3247 .patch = patch_vt1709_6ch},
3248 { .id = 0x1106e717, .name = "VT1709 6-Ch",
3249 .patch = patch_vt1709_6ch},
3250 { .id = 0x1106e720, .name = "VT1708B 8-Ch",
3251 .patch = patch_vt1708B_8ch},
3252 { .id = 0x1106e721, .name = "VT1708B 8-Ch",
3253 .patch = patch_vt1708B_8ch},
3254 { .id = 0x1106e722, .name = "VT1708B 8-Ch",
3255 .patch = patch_vt1708B_8ch},
3256 { .id = 0x1106e723, .name = "VT1708B 8-Ch",
3257 .patch = patch_vt1708B_8ch},
3258 { .id = 0x1106e724, .name = "VT1708B 4-Ch",
3259 .patch = patch_vt1708B_4ch},
3260 { .id = 0x1106e725, .name = "VT1708B 4-Ch",
3261 .patch = patch_vt1708B_4ch},
3262 { .id = 0x1106e726, .name = "VT1708B 4-Ch",
3263 .patch = patch_vt1708B_4ch},
3264 { .id = 0x1106e727, .name = "VT1708B 4-Ch",
3265 .patch = patch_vt1708B_4ch},
3266 { .id = 0x11060397, .name = "VT1708S",
3267 .patch = patch_vt1708S},
3268 { .id = 0x11061397, .name = "VT1708S",
3269 .patch = patch_vt1708S},
3270 { .id = 0x11062397, .name = "VT1708S",
3271 .patch = patch_vt1708S},
3272 { .id = 0x11063397, .name = "VT1708S",
3273 .patch = patch_vt1708S},
3274 { .id = 0x11064397, .name = "VT1708S",
3275 .patch = patch_vt1708S},
3276 { .id = 0x11065397, .name = "VT1708S",
3277 .patch = patch_vt1708S},
3278 { .id = 0x11066397, .name = "VT1708S",
3279 .patch = patch_vt1708S},
3280 { .id = 0x11067397, .name = "VT1708S",
3281 .patch = patch_vt1708S},
3282 { .id = 0x11060398, .name = "VT1702",
3283 .patch = patch_vt1702},
3284 { .id = 0x11061398, .name = "VT1702",
3285 .patch = patch_vt1702},
3286 { .id = 0x11062398, .name = "VT1702",
3287 .patch = patch_vt1702},
3288 { .id = 0x11063398, .name = "VT1702",
3289 .patch = patch_vt1702},
3290 { .id = 0x11064398, .name = "VT1702",
3291 .patch = patch_vt1702},
3292 { .id = 0x11065398, .name = "VT1702",
3293 .patch = patch_vt1702},
3294 { .id = 0x11066398, .name = "VT1702",
3295 .patch = patch_vt1702},
3296 { .id = 0x11067398, .name = "VT1702",
3297 .patch = patch_vt1702},
3301 MODULE_ALIAS("snd-hda-codec-id:1106*");
3303 static struct hda_codec_preset_list via_list = {
3304 .preset = snd_hda_preset_via,
3305 .owner = THIS_MODULE,
3308 MODULE_LICENSE("GPL");
3309 MODULE_DESCRIPTION("VIA HD-audio codec");
3311 static int __init patch_via_init(void)
3313 return snd_hda_add_codec_preset(&via_list);
3316 static void __exit patch_via_exit(void)
3318 snd_hda_delete_codec_preset(&via_list);
3321 module_init(patch_via_init)
3322 module_exit(patch_via_exit)